Piccolo server c II

[Abdujaparov]

Salve a tuti, sto cercando di realizzare un piccolo server c che dopo aver permesso all'utente di autenticarsi riceve in ingresso un determinato insieme di byte e ritorna la radice n-esima dei numeri ricevuto. In pratica il server riceve un byte con l'indice della radice, un byte contenente la dimensione dell'operando e in base al numero ricevuto legge gli n byte dell'operando.
Io ho scritto il server (il figlio che viene generato, è un server concorrente) in questo modo, solo che non mi viene preso l'operando. Sotto copio solo la parte essenziale per la riceizione e l'invio di dati, da parte del server. Io non ho il client, devo realizzare un server per un client che "dialoga" con il protocollo scritto sopra. Allego anche la parte del client che ho provato a scrivere per fare le prove.
Qualcuno può aiutarmi a capire cosa sbaglio?
Grazie, ciao ciao.

//SERVER
static void compito(int connfd, char* file_pass){

char buf[BUFL];
int n;//numero di byte letti
uint8_t radice, uris;
uint16_t base2;



//parte di autenticazione omessa, quella funziona, sono dati ascci

//entro nel ciclo e vi rimango fino a quando il client non termina la connessione
while(1){
//azzero il buffer in cui metterò i dati binari
memset (&buf, 0, sizeof(buf));
n=0;//azzero il contatore dei byte letti


//attendo di leggere i dati che l'utente mi invia

n=readn(connfd, buf, 2); //leggo i primi due byte

//prendo la radice e la metto in un uint8 che ha grandezza un byte
memcpy(&radice, &buf[0], 1); //copio il primo byte nella variabile radice



//prendo la dimensione e la metto in un uint8 che ha grandezza un byte
uint8_t dim;
memcpy(&dim, &buf[1], 1);
//pulisco il buffer
memset (&buf, 0, sizeof(buf));



//lascio solo il caso in cui la dimensione è due (gli altri valori consentiti sono 1 e 4)
if(dim==2){
n=readn(connfd, buf, 2);
memcpy(&base2, &buf[0], dim);//leggo gli altri 2 byte, solo che n mi viene detto che è 0 e non legge nulla, ma la readn, se non riceve nulla, non dovrebbe rimanere bloccata? perchè invece il programma continua ad andare avanti?


base2=ntohs(base2);
uint16_t ris = sqrtn(base2, radice);
ris=htons(ris);
struct risposta{uint8_t uris; uint16_t risultato;}__attribute__((packed)) dati;
dati.uris=0;
dati.risultato=ris;

Writen(connfd, &dati, sizeof(dati)); //invio la struttura con il risultato

}

}




//CLIENT
uint8_t radice=5;
base= htonl(base); // operando in formato di rete, è un uint16_t
dim = sizeof(base); //dimensione operando, è un uint8_t

//invio i dati
Writen(socket,&pluto, sizeof(radice));
Writen(socket,&dim, sizeof(dim));
Writen(socket,&base,sizeof(base)); //non mi viene letto, mi legge 0 byte dopo aver letto i primi due


//parte per leggere il risultato dal server
int nonno = Readn(socket, buf, 1);
memcpy(&stato,&buf[0],1);

memset(&buf, 0, sizeof(buf));
nonno = Readn(socket, buf, sizeof(base));
memcpy(&ris,&buf[0],sizeof(base));
ris=ntohs(ris);

[mr_hyde]

Originariamente inviato da Abdujaparov

[...]
n=readn(connfd, buf, 2);
memcpy(&base2, &buf[0], dim);//leggo gli altri 2 byte, solo che n mi viene detto che è 0 e non legge nulla, ma la readn, se non riceve nulla, non dovrebbe rimanere bloccata? perchè invece il programma continua ad andare avanti?

Come ti ho gia' scritto nell'altro 3ad non conosco "readn", ma se funziona come "read" ti puo' restituire 0 (e non rimanere bloccata) in alcuni casi, ad esempio se l'altro "capo" della connessione e' stato chiuso (o se ci sono stati altri errori). Controlla sulla documentazone relativa a "readn" se, per caso, quando non restituisce "0" non imposta anche "errno" in modo da capire il significato dello "0" (ho visto alcune implementazioni che fanno proprio cosi').
Comunque, in generale, una read (non "readn" che ripeto non conosco) che restituisce "0" indica un end of file (be', in questo caso direi piu' end of transmission)

//CLIENT
uint8_t radice=5;
base= htonl(base); // operando in formato di rete, è un uint16_t

Occhio che htonl converte tipi a 4 byte, non 2 (ti serve quindi un uint32). E' "htons" che va con uint16

dim = sizeof(base); //dimensione operando, è un uint8_t

Non e' certo questo il problema, io pero' qui per "pulizia di codice" metterei un cast per evidenziare a chi legge il codice che c'e' un'assegnazione tra tipi diversi che, potenzialmente, puo' portare a perdita di informazione.
Infatti "sizeof" restituisce un tipo "size_t" che, tipicamente, e' semplicemente una typedef ad "unsigned int",
quindi ad un tipo di dato che viene memorizzato su 4 byte, mentre dim e' un uin8 (da quello che scrivi)

//parte per leggere il risultato dal server
int nonno = Readn(socket, buf, 1);
memcpy(&stato,&buf[0],1);

scusa, ma perche' non fai semplicemente
uin8_t stato;
int nonno = Readn(socket, &stato, sizeof(uint8_t)) ?
immagino che pero' il prototipo di Readn sia

int Readn(int socketId, void* buffer, unsigned int size)

allora dovresti scrivere

int nonno = Readn(socket, (void*) &stato, sizeof(uint8_t));

memset(&buf, 0, sizeof(buf));
nonno = Readn(socket, buf, sizeof(base));
memcpy(&ris,&buf[0],sizeof(base));

cosiderazione analoga a prima

ris=ntohs(ris);

quindi ris e' un16_t?

Ciao,
Mr Hyde

[Abdujaparov]

Si è uint16_t, mi sono confuso perchè l'operando può essere, a descrizione del client, un uint_t, uint16_t e uint32_t. La readn dovrebbe essere bloccante e rimanere incantata fino a quando non riceve il numero di byte che aspetta.
A me interessa leggere i byte a piccoli blocchi, prima i primi due, poi l'operando, elaboro (invio un byte di sato ed il risultato su tanti byte quanti sono i byte dell'operando) lo invio e ritorno in attesa, senza altri fronzoli.
Non so se il client mi invia tutto insieme in una struct o prima mi invia prima un byte, poi un byte e poi l'operando con 3 write. Se metto una read mi viene letto solo il primo write, appunto per questo, voglio leggerli a blocchi.
Grazie moltissimo, ciao ciao.

[Abdujaparov]

Ciao a tutti, volevo ringraziare MrHyde sono riuscito a risolvere tutto finalmente ed ora sono contento, però volevo chiedere un'ultima cosa.
Quando il client chiude la connessione il server non esce subito ma prima fa tutte le readn dicendo che ha ricevuto zero ovunque e poi esce. Vedendo quello che sucede spero di essere più chiaro:

Pezzo server:

while(1){

#ifdef TRACE
err_msg("Sono in attesa dei dati su cui operare.\n");
#endif

//attendo di leggere i dati che l'utente mi invia
n=ReadN(connfd, buf, 2);
#ifdef TRACE
err_msg("Ho ricevuto %d bytes\n", n);
#endif

//prendo la radice e la metto in un uint8 che ha grandezza un byte
memcpy(&radice, &buf[0], 1);



#ifdef TRACE
err_msg("Ho ricevuto questa radice %u\n", radice);
#endif


memcpy(&dim, &buf[1], 1);
//pulisco il buffer
memset (&buf, 0, sizeof(buf));

#ifdef TRACE
err_msg("La dimensione dell'operando e': %u\n", dim);
#endif

//qua c'è una readn come le precedenti

#ifdef TRACE
err_msg("La variabile errori e': %u\n", errori);
#endif

/*Se il calcolo è corretto invio 0 seguito dal risultato se è sbagliato invio 1*/


//fine del ciclo e si ritorna su sono in attesa di un operando

}

}

La chiusura del client avviene dopo aver inviato una richiesta ed aver letto la risposta, in questo modo:

Close(socket);

exit(0);

L'output che mi da il server è il seguente:

Sono in attesa dei dati su cui operare.

Ho ricevuto 2 bytes

Ho ricevuto questa radice 3

La dimensione dell'operando e': 4

La variabile errori e': 0

L'operando è: 729 //fine della richiesta

Sono in attesa dei dati su cui operare. //inizio del cliclo

Ho ricevuto 0 bytes //prima readn, non dovrebbe uscire qui?

Ho ricevuto questa radice 0

La dimensione dell'operando e': 0

La variabile errori e': 1

Sono in attesa dei dati su cui operare.

//ora esce del programma
(./server) info - connessione chiusa dal client
(./server) info - figlio 3472 terminato con status 0



Come posso evitare che il server esamini una richiesta inesistente in chiusura di connessione?
Io ho wrappato la funzione readn perchè chiuda il programma appena ci sono problemi nella connessione.
Grazie, ciao ciao.

[mr_hyde]

Non ho ancora letto bene il tuo post, ma forse setsockopt e SO_LINGER ti possono aiutare.

Ciao,
Mr Hyde