[C]lettura e allocazione dinamica dati in ingresso..

[santaclause83]

per allocare dinamicamente memoria a parametri in arrivo di grandezza variabile spedisco la loro grandezza in byte allegata al dato da ricevere e salvare in memoria.

quind,se ricevo una stringa fatta in questo modo:

char* input = <lunghezza primo dato><primo dato>blankspace<lunghezza secondo dato><secondo dato>

per leggere e allocare memoria può andare be una cosa così?....

int lung_primo = atoi(input[0]);
malloc di lunghezza "lung_primo"

int lung_secondo = atoi(input[lung_primo])
malloc di lunghezza "lung_secondo"

se metto l'indice dell'array in questo modo non viene letto tutto l'array dall'indice in poi?
sulla seconda lettura non devo aggiungere 1 per saltare il blank space?

[cionci]

int lung_primo = atoi(input);
malloc di lunghezza "lung_primo"

int lung_secondo = atoi(&input[lung_primo])
malloc di lunghezza "lung_secondo"

Attenzione:
"If the first sequence of non-whitespace characters in str is not a valid integral number, or if no such sequence exists because either str is empty or it contains only whitespace characters, no conversion is performed."

Quindi a lung_primo ci devi aggiungere anche la lunghezza stessa del numero (che è tra l'altro variabile).
IMHO i dati li spedirei in forma binaria, quindi spedirei un intero di 4 byte con la lunghezza della stringa seguito dalla stringa (se vuoi comprendere o meno il terminatore di stringa lo devi decidere te), quindi niente spazio e subito di nuovo lunghezza su un intero di 4 byte seguito dalla stringa.
Ovviamente dopo non puoi usare atoi per ricostruire il numero...
Di solito per la spedizione di numeri intere sulla rete si usano i convertitori di numeri al formato standard di rete (due host che comunicano possono avere byte order non compatibile, ad esempio uno può essere big-endian e l'altro little-endian).
Le funzioni da usare sono htonl, ntohl, htons, ntohs...
Ad esempio, supponiamo di volere costruire un buffer da spedire sulla rete (costruisco il buffer, anche se in teoria non sarebbe necessario se i dati li spedisci con TCP).

Utilizzo un intero di 2 byte, invece di 4, perché suppongo che basti per quantificare il numero di caratteri.

sender:

char *s1;
char *s2;
/* s1 e s2 costituiscono le due stringhe da spedire, ovviamente opportunamente allocate */
unsigned short l1 = strlen(s1) + 1; /*il + 1 è per i caratteri di fine stringa*/
unsigned short l2 = strlen(s2) + 1;
unsigned short nl1 = htons(l1); /* ecco qui la conversione nel byte order di rete */
unsigned short nl2 = htons(l2);

unsigned char *buffer = (unsigned char *)malloc( 2 * sizeof(int) + l1 + l2);

memcpy(buffer, &nl1, sizeof(unsigned short));
memcpy(buffer + sizeof(unsigned short), s1, l1);

memcpy(buffer + sizeof(unsigned short) + l1, &nl2, sizeof(unsigned short));
memcpy(buffer + 2 * sizeof(unsigned short) + l1, s2, l2);

A questo punto nel buffer hai:
2 byte in network order per la dimensione della prima stringa
la prima stringa comprensiva di fine stringa
2 byte in network order per la dimensione della seconda stringa
la seconda stringa comprensiva di fine stringa

Per riprenderli dal buffer (anche qui se la connessione è TCP bastava leggere i primi due byte e convertirli):

char *s1;
char *s2;
/* s1 e s2 costituiscono le due stringhe da spedire, ovviamente opportunamente allocate */
unsigned short l1;
unsigned short l2;

memcpy(&l1, buffer, siezof(unsigned short)); /* leggo la dimensione della prima stringa */

/* converto la dimensione da byte order di rete a byte order locale */
l1 = ntohs(l1);

/* alloco e recupero s1 */
s1 = (char *)malloc(l1);
memcpy(s1. buffer + sizeof(unsigned short), l1);

/* leggo la dimensione della seconda stringa */
memcpy(&l2, buffer + sizeof(unsigned short) + l1, siezof(unsigned short));

/* converto la dimensione da byte order di rete a byte order locale */
l2 = ntohs(l2);

/* alloco e recupero s2 */
s2 = (char *)malloc(l2);
memcpy(s2. buffer + 2 * sizeof(unsigned short) + l1, l2);