socket TCP su C

[Cimmo]

Ho questo problema:
lavoro su socket TCP su C, spedisco un sacco di messaggi da un host all'altro, pero' il secondo host non riceve niente (sta bloccato sulla read) finche' l'host che spedisce non chiude la connessione o gli faccio io un kill -9...perche'?
Se sono stato troppo vago fatemelo sapere...

ciao e grazie
Cimmo

[cionci]

Diminuisci il buffer della read...

[ilsensine]

Dovrebbe funzionare ugualmente, in quanto la read dovrebbe ritornare anche se è disponibile una quantità di dati inferiore a quella richiesta (blocca solo se non ci sono dati).
Puoi mandare il codice incriminato? (sia del client che del server)

[Cimmo]

Non posso mandarvi tutto il codice perche' e' una pappardella che non ci cavereste i piedi, pero' vi mando quello che riceve e dopo un po' di debug ho scoperto qualcosa.
Io mi sono fatto una funzione per ricevere i messaggi (quella che posto dopo nel messaggio) e lui cosa fa: praticamente va' avanti a leggere pero' non becca mai il delimitatore '\0' e quindi non esce mai dal while e cosi' neanche dalla funzione. Diminuendo il buffer non fa altro che fare piu' giri di while per leggere tutto, pero' quando ha finito si inchioda lo stesso in attesa del e non esce.
Se pero' il processo che spedisce termina, allora il processo che contiene questa funzione si sblocca...mi sapreste dire il perche'?

grazie e 1000

ciao
Cimmo


int receiveData(int socketfd, char *msg)
{
int nread, n;

/* lettura */
nread=0;
printf ("\nread()\n");
fflush(stdout);

while (1)
{
if ((n=read(socketfd, &(msg[nread]), MAXSIZE)) <=0)
{
if (errno!=EINTR)
{
char msgerror[1024];
sprintf(msgerror,"read() failed [err %d] ",errno);
perror(msgerror);
fflush(stderr);
return(1);
}
}
else
{
nread+=n;

if ((msg[nread-1]=='\0') || (nread>=MAXSIZE))
break;
}
}

fflush(stdout);

return(0);
};

[cionci]

Ma tu sei sicuro di spedirlo lo '\0' ?
Se la stringa che spedisci è lunga 10 caratteri...dovrai spedirne 11 con la send...

[ilsensine]

if (errno!=EINTR)
{
char msgerror[1024];
sprintf(msgerror,"read() failed [err %d] ",errno);
perror(msgerror);
fflush(stderr);
return(1);
}
}
else
{
nread+=n;

Dove sta scritto che la read setta errno=EINTR in caso di successo?

if ((msg[nread-1]=='\0') || (nread>=MAXSIZE))
break;

Sbagliato.
Nessuno può assicurarti che più pacchetti non siano stati riassemblati prima della read, dopo essere stati ad es. divisi a metà durante la trasmissione. Questo vuol dire che con una singola read ne puoi ricevere uno e mezzo, poi altre due metà ecc.
Devi controllare tutti i byte ricevuti in una read, alla ricerca di eventuali '\0' intermedi. Il tcp è stream, ma la dinamica del flusso non la puoi controllare.

[Cimmo]

Originariamente inviato da ilsensine
Dove sta scritto che la read setta errno=EINTR in caso di successo?

No qui non hai capito tu, nel senso che se c'e' un errore (cioe' la read ha restituito un numero <=0) allora non tiene conto dell'errore EINTR che altro non e' che una interruzione dovuta ad una sistem call. Se invece la read restituisce un numero >0 va' nel ramo else e quell'if non lo esegue neanche.
[B]
Sbagliato.
Nessuno può assicurarti che più pacchetti non siano stati riassemblati prima della read, dopo essere stati ad es. divisi a metà durante la trasmissione. Questo vuol dire che con una singola read ne puoi ricevere uno e mezzo, poi altre due metà ecc.
Devi controllare tutti i byte ricevuti in una read, alla ricerca di eventuali 'Originariamente inviato da ilsensine
[B]Dove sta scritto che la read setta errno=EINTR in caso di successo?

No qui non hai capito tu, nel senso che se c'e' un errore (cioe' la read ha restituito un numero <=0) allora non tiene conto dell'errore EINTR che altro non e' che una interruzione dovuta ad una sistem call. Se invece la read restituisce un numero >0 va' nel ramo else e quell'if non lo esegue neanche.

Sbagliato.
Nessuno può assicurarti che più pacchetti non siano stati riassemblati prima della read, dopo essere stati ad es. divisi a metà durante la trasmissione. Questo vuol dire che con una singola read ne puoi ricevere uno e mezzo, poi altre due metà ecc.
Devi controllare tutti i byte ricevuti in una read, alla ricerca di eventuali '\0' intermedi. Il tcp è stream, ma la dinamica del flusso non la puoi controllare. ' intermedi. Il tcp è stream, ma la dinamica del flusso non la puoi controllare.
Si lo so che la read puo' leggere pezzi a caso, ma io allora come faccio? E poi comunque ho notato che anche quando ha letto tutto quello che c'era da leggere alla fine non trova lo stesso il '\0' e si blocca.
Addirittura succede cosi':
faccio partire il server che si mette in attesa, faccio partire il client che si connette e comincia a spedire al server il quale riceve, ma si inchioda come ho gia' spiegato, poi il client a suo volta lo faccio bloccare e tutto rimane bloccato. Se a manoni uccido (con kill -9) il client, il server si sblocca dalla read e mi ritorna magicamente tutto il messaggione con tutto quello che ho spedito.
Cosa devo fare?

[ilsensine]

No qui non hai capito tu, nel senso che se c'e' un errore (cioe' la read ha restituito un numero <=0) allora non tiene conto dell'errore EINTR che altro non e' che una interruzione dovuta ad una sistem call. Se invece la read restituisce un numero >0 va' nel ramo else e quell'if non lo esegue neanche.
Ok avevo perso qualche parentesi

Si lo so che la read puo' leggere pezzi a caso, ma io allora come faccio? E poi comunque ho notato che anche quando ha letto tutto quello che c'era da leggere alla fine non trova lo stesso il 'No qui non hai capito tu, nel senso che se c'e' un errore (cioe' la read ha restituito un numero <=0) allora non tiene conto dell'errore EINTR che altro non e' che una interruzione dovuta ad una sistem call. Se invece la read restituisce un numero >0 va' nel ramo else e quell'if non lo esegue neanche.
Ok avevo perso qualche parentesi

Si lo so che la read puo' leggere pezzi a caso, ma io allora come faccio? E poi comunque ho notato che anche quando ha letto tutto quello che c'era da leggere alla fine non trova lo stesso il '\0' e si blocca.
Addirittura succede cosi':
faccio partire il server che si mette in attesa, faccio partire il client che si connette e comincia a spedire al server il quale riceve, ma si inchioda come ho gia' spiegato, poi il client a suo volta lo faccio bloccare e tutto rimane bloccato. Se a manoni uccido (con kill -9) il client, il server si sblocca dalla read e mi ritorna magicamente tutto il messaggione con tutto quello che ho spedito.
Cosa devo fare?' e si blocca.
Addirittura succede cosi':
faccio partire il server che si mette in attesa, faccio partire il client che si connette e comincia a spedire al server il quale riceve, ma si inchioda come ho gia' spiegato, poi il client a suo volta lo faccio bloccare e tutto rimane bloccato. Se a manoni uccido (con kill -9) il client, il server si sblocca dalla read e mi ritorna magicamente tutto il messaggione con tutto quello che ho spedito.
Cosa devo fare?
Innanzitutto verifica quello che ha detto cionci, ovvero che se devi spedire una stringa s devi trasmettere strlen(s)+1 byte.
Poi potresti mettere dei messaggi di debug dopo la read per vedere quello che succede.
Nota che il risultato della read è <0 se c'è stato un errore e ==0 se il client si è disconnesso (e in questo caso errno rimane indefinito)

[Cimmo]

Originariamente inviato da ilsensine
[B]
Ok avevo perso qualche parentesi


Innanzitutto verifica quello che ha detto cionci, ovvero che se devi spedire una stringa s devi trasmettere strlen(s)+1 byte.
Poi potresti mettere dei messaggi di debug dopo la read per vedere quello che succede.
Nota che il risultato della read è <0 se c'è stato un errore e ==0 se il client si è disconnesso (e in questo caso errno rimane indefinito)
Ma sto '\0' glielo devo mettere io o mi basta che durante la spedizione do' come lunghezza della stringa strlen(s)+1? Il mio professore dell'universita' mi ha detto che non dovevo fare cosi'...AIUTO!
Comunque il debug l'ho fatto (con DDD) e mi si inchioda sulla read non boccheggia il '\0'...

[cionci]

Se è una stringa lo '\0' c'è sempre in fondo...e per definizione una stringa in C è una sequenza di caratteri a aprtire da un certo indirizzo con un '\0' che indica la fine della stringa...

Quindi se quello che mandi è una stringa allora c'è lo '\0' in fondo e per mandarlo devi dare la dimensione strlen(str) + 1 alla send...

[Cimmo]

Ok nella send ho messo strlen(s)+1, io faccio 5 write:
1) scrivo 1/
2) scrivo 6/
3) scrivo 247/
4) scrivo 1/
5) scrivo 3/

e il risultato e' che invece di arrivarmi 1/6/247/1/3/ mi arriva cosi': 1/\0006/\000247/\0001/\0003/\000

perche'?

grazie della pazienza!

[cionci]

Ci puoi far vedere il modo in cui costruisci i messaggi che invii ?

[ilsensine]

Congruente con quello che ti ho detto. Leggendo MAXSIZE byte, dici al kernel di "svuotare" la coda tcp fino ad un massimo di MAXSIZE byte. Ovviamente i pacchetti che sono arrivati fin'ora vengono "impacchettati" e letti tutti insieme dalla read().
Soluzioni possibili:
- Leggi 1 byte per volta (bleah!)
- Dividi la lettura in 2 strati: uno (quello attuale) che legge i dati e li mette in un buffer fregandosene di trovare gli '\0'; un altro che legge dal buffer, cerca la prima occorrenza di '\0' ed estrae la stringa dal buffer.
- Prima di spedire una stringa, spedisci un int indicante la sua lunghezza. Così non hai neanche necessità di inviare lo '\0' finale.

[cionci]

Originariamente inviato da Cimmo
Ok nella send ho messo strlen(s)+1, io faccio 5 write:
1) scrivo 1/
2) scrivo 6/
3) scrivo 247/
4) scrivo 1/
5) scrivo 3/

e il risultato e' che invece di arrivarmi 1/6/247/1/3/ mi arriva cosi': 1/Originariamente inviato da Cimmo
[B]Ok nella send ho messo strlen(s)+1, io faccio 5 write:
1) scrivo 1/
2) scrivo 6/
3) scrivo 247/
4) scrivo 1/
5) scrivo 3/

e il risultato e' che invece di arrivarmi 1/6/247/1/3/ mi arriva cosi': 1/\0006/\000247/\0001/\0003/\000

perche'?

grazie della pazienza! 006/Originariamente inviato da Cimmo
Ok nella send ho messo strlen(s)+1, io faccio 5 write:
1) scrivo 1/
2) scrivo 6/
3) scrivo 247/
4) scrivo 1/
5) scrivo 3/

e il risultato e' che invece di arrivarmi 1/6/247/1/3/ mi arriva cosi': 1/\0006/\000247/\0001/\0003/\000

perche'?

grazie della pazienza! 00247/Originariamente inviato da Cimmo
Ok nella send ho messo strlen(s)+1, io faccio 5 write:
1) scrivo 1/
2) scrivo 6/
3) scrivo 247/
4) scrivo 1/
5) scrivo 3/

e il risultato e' che invece di arrivarmi 1/6/247/1/3/ mi arriva cosi': 1/\0006/\000247/\0001/\0003/\000

perche'?

grazie della pazienza! 001/Originariamente inviato da Cimmo
Ok nella send ho messo strlen(s)+1, io faccio 5 write:
1) scrivo 1/
2) scrivo 6/
3) scrivo 247/
4) scrivo 1/
5) scrivo 3/

e il risultato e' che invece di arrivarmi 1/6/247/1/3/ mi arriva cosi': 1/\0006/\000247/\0001/\0003/\000

perche'?

grazie della pazienza! 003/Originariamente inviato da Cimmo
Ok nella send ho messo strlen(s)+1, io faccio 5 write:
1) scrivo 1/
2) scrivo 6/
3) scrivo 247/
4) scrivo 1/
5) scrivo 3/

e il risultato e' che invece di arrivarmi 1/6/247/1/3/ mi arriva cosi': 1/\0006/\000247/\0001/\0003/\000

perche'?

grazie della pazienza! 00

perche'?

grazie della pazienza!
E poi...che te ne fai di spedire lo \0 ? Non hai già / che delimita le stringhe ?
Comunque ha ragione ilsensine...fai una lettura a due livelli...

[ilsensine]

1/1/\0006/\000247/\0001/\0003/\000006/1/\0006/\000247/\0001/\0003/\00000247/1/\0006/\000247/\0001/\0003/\000001/1/\0006/\000247/\0001/\0003/\000003/1/\0006/\000247/\0001/\0003/\00000
Al di là dell'impacchettamento, tutta quella abbondanza di '0' è corretta o mi sto perdendo qualche altra cosa?

[Cimmo]

Cosi' costruisco le stringhe...

strcpy(data,"");
sprintf(tmp,"%d/",TotHosts);
strcpy(data,tmp);
sendData(socketfd, data);
printf("%s\n",data);

alla fine infatti a me del delimitatore \0 non me ne frega niente, cosa dovrei fare cambiare l'ultimo if della receiveData e invece di ricercare il '\0' ricerco il '/'?

Tutti quei \0 io non li metto, non so come ci finiscono!

[ilsensine]

Forse fai qualcosa di sbagliato nella sendData.
nb tmp è inutile, basta fare
sprintf(data,"%d/",TotHosts);

[Cimmo]

Eccovi anche la sendData, ora c'e' len=strlen(msg) senza il +1, ma come vi ho detto ho gia' provato entrambi i modi ed e' andata come sapete...

int sendData(int socketfd, char msg[MAXSIZE])
{
int nwrite, len, n;

/* scrittura */
//len=strlen(msg)+1;
len=strlen(msg);
nwrite=0;
printf ("\nwrite()\n");
fflush(stdout);

while ((len-nwrite)>0)
{
if ((n=write(socketfd, &(msg[nwrite]), (len-nwrite))) <=0)
{
if (errno!=EINTR)
{
char msgerror[1024];
sprintf(msgerror,"write() failed [err %d] ",errno);
perror(msgerror);
fflush(stderr);

return(1);
}
}
else
nwrite+=n;
}

return(0);
};

[cionci]

Per leggerti le varie stringhe terminate con '/' puoi ad esempio farti una cosa del genere :

int readMsg(char *buf, char *msg, int nread)
{
static int start = 0;
int cur = start;
int n = 0;
len = strlen(msg);
while(n < (MSGMAX + 1 - len) && cur < nread)
{
if(buf[i] == '/')
break;
else
{
++n;
++cur;
}
}

if(n == (MSGMAX + 1 - len))
{
/*lunghezza del messaggio eccessiva, te la puoi
gestire come ti pare ad esempio riempiendo il msg corrente
oppure riportando l'errore ed ignorando il buffer fino al prox '/'*/
...
return 2;
}
if(cur == nread)
{
/*il msg è a metà fra due letture, riempio la parte corrente*/
buf[nread] = '\0';
strcpy(msg+len, buf+start);
start = 0; /*riparto dall'inizio del buffer dopo una nuova lettura*/
return 1;
}
/*se arrivo qui significa che ho trovato lo '/'*/
buf[cur] = '\0';
strcpy(msg+len, buf+start)
start = cur + 1;
return 0;
}

....
char buf[READMAX+1]; /*buffer di ricezione*/
char msg[MSGMAX+1]; /*contiene il messaggio ricevuto*/

while(1)
{
nread = leggiDaSocket(buf);
if(nread > 0)
while(!readMsg(buf, msg, nread))
{
/*qui ti gestisci il messaggio letto...ad esempio lo puoi visualizzare*/
printf("%s ", msg);
strcpy(msg, '\0');
}
}
....