Abdujaparov
27-03-2006, 21:57
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);
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);