[C] Problema x programma di network su Unix

[mfonz85]

Ciao a tutti,
avrei un problema: devo far parlare un client e un server scritti in C che gireranno su Unix, e devo praticamente fare una sorta di handshaking iniziale dove il client manda un carattere di saluto (codificato in ASCII - 1 byte) seguito da un'altro numero, scritto sempre su 1 byte, che può assumere il valore 1, 2 o 4: questo valore serve praticamente a far capire al server che da quel momento io (client) inizierò a mandargli dei numeri interi codificati appunto su 1, 2 o 4 byte.

I problemi miei sono i seguenti:
1) ma per il little/big endian?? Non succedono casini quando invio dati binari?
2) per ricostruire lo stream al server, che si vede sostanzialmente arrivare uno stream di byte, come faccio??
3) E anche al client, come faccio a concatenare in modo intelligente questi byte??

Poniamo il caso che devo fare un programma così: handshaking con una "R" seguita dal numero 1, 2, o 4 scritto sempre su 1 byte. (byte di CODIFICA). Nel nostro esempio voglio che il client invii da quel momento in poi solo interi codificati su 2 byte.
Il server lo deve ricevere, e capire come aspettarsi i prossimi dati. (ovvero da adesso in poi si aspetta SOLO interi su 2 byte)
Poi da client voglio inviargli 4 numeri consecutivi codificati sul numero di byte scritto in precedenza sul secondo campo del primo invio (byte di CODIFICA)
Per esempio gli voglio inviare 67, 621 e 715 scritti su 2 byte. Questi numeri devono essere codificati su 2 byte, e messi in un'unico stream grosso di 4*2 = 8 byte (che saranno poi spezzettati al server)

Qualcuno mi può dare una mano a scrivere un pezzetto di codice che fa questo lavoretto??

Ringrazio anticipatamente!

[mfonz85]

nessuna idea ?!?!

[cionci]

Originariamente inviato da mfonz85

Ciao a tutti,
avrei un problema: devo far parlare un client e un server scritti in C che gireranno su Unix, e devo praticamente fare una sorta di handshaking iniziale dove il client manda un carattere di saluto (codificato in ASCII - 1 byte) seguito da un'altro numero, scritto sempre su 1 byte, che può assumere il valore 1, 2 o 4: questo valore serve praticamente a far capire al server che da quel momento io (client) inizierò a mandargli dei numeri interi codificati appunto su 1, 2 o 4 byte.

I problemi miei sono i seguenti:
1) ma per il little/big endian?? Non succedono casini quando invio dati binari?

Sì. Infatti, se non abbiamo problemi di "traffico", a volte quando si inviano molti dati strutturati si preferisce usare XML.
C'è comunque la possibilità di usare funzioni di libreria che rendono indipendenti i dati scritti dall'architettura: guarda il man di htonl e compagni.

Originariamente inviato da mfonz85

2) per ricostruire lo stream al server, che si vede sostanzialmente arrivare uno stream di byte, come faccio??

Devi costruirti un protocollo. Il server deve sapere a priori la dimensione dai dati. Te lo spiego sotto.

Originariamente inviato da mfonz85

3) E anche al client, come faccio a concatenare in modo intelligente questi byte??

Non importa, usa una struttura dati. Riempila con le debite conversioni hton* ed inviala per intero.

Originariamente inviato da mfonz85

Poniamo il caso che devo fare un programma così: handshaking con una "R" seguita dal numero 1, 2, o 4 scritto sempre su 1 byte. (byte di CODIFICA). Nel nostro esempio voglio che il client invii da quel momento in poi solo interi codificati su 2 byte.
Il server lo deve ricevere, e capire come aspettarsi i prossimi dati. (ovvero da adesso in poi si aspetta SOLO interi su 2 byte)
Poi da client voglio inviargli 4 numeri consecutivi codificati sul numero di byte scritto in precedenza sul secondo campo del primo invio (byte di CODIFICA)
Per esempio gli voglio inviare 67, 621 e 715 scritti su 2 byte. Questi numeri devono essere codificati su 2 byte, e messi in un'unico stream grosso di 4*2 = 8 byte (che saranno poi spezzettati al server)

Hai descritto un protocollo. Il modo migliore per gestire un protocollo è quello di una macchina a stati, ad esempio (me lo invento):
avviene la connessione: passo allo stato IDENTIFYING
IDENTIFYING: devo ricevere username e password. La codifica dei dati deve essere composta da (in sequenza di lettura):
- 2 byte per la dimensione dello username
- stringa username
- 2 byte per la dimensione della password
- stringa password
se l'autenticazione ha successo passo a ENCODING
se l'autenticazione non ha successo passo a FAIL

ENCODING: devo ricevere R seguito da 1 byte, quindi leggo 2 byte.
Se le informazioni non sono corrette passo a FAIL
Se ricevo 1 passo a 1BYTE_ENCODED
Se ricevo 2 passo a 2BYTE_ENCODED
Se ricevo 4 passo a 4BYTE_ENCODED

1BYTE_ENCODED: leggo la dimensione dei dati da leggere, leggo un byte alla volta e faccio quello che ci devo fare
2BYTE_ENCODED: leggo la dimensione dei dati da leggere, leggo due byte alla volta e faccio quello che ci devo fare
4BYTE_ENCODED: leggo la dimensione dei dati da leggere, leggo quattro byte alla volta e faccio quello che ci devo fare

FAIL: rispondo con una stringa di errore (sempre dimensione, seguito dalla stringa). Vado a CLOSING

CLOSING: termino la connessione

La macchina a stati te la gestisci in maniera semplice con un enum, in base al valore dello stato sai quello che devi fare (il modo più immediato per implementarlo è uno switch),

[mfonz85]

Grazie, sei stato molto chiaro...ma vorrei farti ancora un paio di domande...

Originariamente inviato da cionci

Non importa, usa una struttura dati. Riempila con le debite conversioni hton* ed inviala per intero.

Quindi quando devo inviare al server l'handshaking, invio i dati inseriti in 1 roba del genere?

struct _dati {
   char saluto;
   char codifica; //con valori possibili 1,2, o 4
} DATI;

DATI.saluto = 'R';
DATI.codifica = 2;

//problema: devo usare "uint16_t htons" (host to network short) per un carattere: ma si può fare?!?!?

(short int) DATI.saluto = htons((int) DATI.saluto); //ma si può fare?!?!?
(short int) DATI.codifica = htons((int) DATI.codifica); //ma si può fare?!?!?

//problema 2: con che funzione e come la invio la struttura dati?? Come un puntatore void * liscio??

... to do ... to do ... to do

Originariamente inviato da cionci

1BYTE_ENCODED: leggo la dimensione dei dati da leggere, leggo un byte alla volta e faccio quello che ci devo fare
2BYTE_ENCODED: leggo la dimensione dei dati da leggere, leggo due byte alla volta e faccio quello che ci devo fare
4BYTE_ENCODED: leggo la dimensione dei dati da leggere, leggo quattro byte alla volta e faccio quello che ci devo fare

E per leggere un byte alla volta?? Con htons mi arrivano dei dati interi su 2 byte...quindi 2 byte per volta...

Avrei bisogno di un pezzo di codice, un esempietto, per capire...

[cionci]

Per i char non devi usare funzioni di conversione....

send(s, &DATO, sizeof(DATO), 0);

In ricezione puoi anche semplicemente leggere un byte alla volta oppure una struttura dati intera:

recv(s, &DATO, sizeof(DATO), 0);
Attenzione nei messaggi lunghi, la recv può anche ritornare prima di aver letto sizeof(DATO).

Come vedi sono perfettamente speculari.
Ovviamente se DATO fosse una struttura più complessa dovresti usare le funzioni di conversione per i dati contenuti nella struttura di dimensione superiore a 1 byte

[mfonz85]

Originariamente inviato da cionci

Per i char non devi usare funzioni di conversione....

send(s, &DATO, sizeof(DATO), 0);

Quindi niente problemi little/big endian per caratteri singoli??
Quindi prendiamo per esempio il carattere H maiuscolo, codice ASCII 72, codifica binaria 10001000: lo invio con una send, senza hton o simili, e poi al server mi sparo una recv su 1 byte?

Originariamente inviato da cionci

In ricezione puoi anche semplicemente leggere un byte alla volta oppure una struttura dati intera:

recv(s, &DATO, sizeof(DATO), 0);
Attenzione nei messaggi lunghi, la recv può anche ritornare prima di aver letto sizeof(DATO).

Come vedi sono perfettamente speculari.
Ovviamente se DATO fosse una struttura più complessa dovresti usare le funzioni di conversione per i dati contenuti nella struttura di dimensione superiore a 1 byte

Ecco, è questo che non riesco a capire...se DATO fosse una struttura complessa...come faccio a crearmela al client e poi a smontarmela al server??

[cionci]

Fai send e recv come ho scritto sopra e riempi la struttura.

Sul sender fai hton* per ogni dato superiore al byte e sul receiver applichi la funzione inversa ntoh*.

[mfonz85]

Ok, vediamo se ho capito bene...

//client-side Data Sending

struct _numeri_su_2_byte {
   uint_16 numeroA;
   uint_16 numeroB;
   uint_8 operatore;
} DUEBYTE;

int main(void)
{
   DUEBYTE *ptr;
   ptr = (DUEBYTE) malloc(sizeof(DUEBYTE));
   ptr.numeroA = htons(16); //primo operatore: 16
   ptr.numeroB = htons(57); //secondo operatore: 57
   ptr.operatore = htons(43) //codice ASCII per il '+'
   send(socket, &DUEBYTE, sizeof(DUEBYTE), 0);
}

E' tutto ok??

Al server quindi basta in questo caso fare una recv su 5 byte giusto??

//server-side Data Receiving

struct _numeri_su_2_byte {
   uint_16 numeroA;
   uint_16 numeroB;
   uint_8 operatore;
} arrivato;

int main(void) 
{
   uint_16 A, B;
   char op;
   
   recv(socket, &arrivato, 5*sizeof(char), 0);
   A = (uint_16) ntohs(arrivato.numeroA);
   B = (uint_16) ntohs(arrivato.numeroB);
   op = (char) ntohs(arrivato.operatore);
}

Tutto ok anche qui??

Ci sono altre migliorie/ottimizzazioni/idee a riguardo, trattandosi si roba delicata di trasferimenti via ethernet??
Domanda: se al server non ricevessi proprio 5 byte, ma di meno (o di più) come mi comporto??

[mfonz85]

Ma no, no, nooooo! Non funziona

sia che uso

union DUEBYTE {
   u_int8_t operatore;
   u_int16_t numeroA;
   u_int16_t numeroB;
};

che

typedef struct _numeri_su_2_byte {
   u_int8_t operatore;
   u_int16_t numeroA;
   u_int16_t numeroB;
} DUEBYTE;

quando vado a fare

char op;
u_int16_t a,b;
DUEBYTE ptr;

if (sscanf(buf,"%d %c %d",&a, &op, &b) != 2) err_quit("(%s) error", prog);
else {
     ptr = malloc(sizeof(DUEBYTE));
     ptr.numeroA = htons(a); //primo operatore
     ptr.numeroB = htons(b); //secondo operatore
     ptr.operatore = htons(op); //codice ASCII per l'op
     send(sockfd, &DUEBYTE, sizeof(DUEBYTE), 0);
}

gcc, nel primo caso (union) mi fa:
DUEBYTE undeclared, ptr udneclared.

sempre gcc, nel secondo caso (typedef struct) mi fa:
request for member numeroA, numeroB, operatore in something not a structure or union...
Ma come?!?! Cosa vuole di più dalla vita il gcc? E' tutto perfetto!!
E oltretutto sto guardando una guida, mica mi sto inventando nulla: http://www.codeguru.com/forum/showthread.php?t=306399

[cionci]

Non usare la union...

char op;
u_int16_t a,b;
DUEBYTE *ptr;

if (sscanf(buf,"%d %c %d",&a, &op, &b) != 2) err_quit("(%s) error", prog);
else {
     ptr = malloc(sizeof(DUEBYTE));
     ptr->numeroA = htons(a); //primo operatore
     ptr->numeroB = htons(b); //secondo operatore
     ptr->operatore = htons(op); //codice ASCII per l'op
     send(sockfd, ptr, sizeof(DUEBYTE), 0);
}