Newsgroup: it.comp.os.linux.development
Titolo: [ Reti ] Ricevere ed instradare senza memorizzare

Salve a tutti
ho un socket udp dove effettuo una ricezione ed inoltro cioè che ho
ricevuto con una send
Domanda :
Devo per forza allocare cio' che ricevo ?
se non conosco il tipo del messaggio da ricevere come posso effettuare
la ricezione ?
e dopo come posso controllare che tipo di dato ho ricevuto ?
Grazie!!

e dopo come posso controllare che tipo di dato ho ricevuto ?
non capisco cosa non conosci?
tutti i dati saranno salvati nel buffer, che puoi fare stringa char*
guarda un esempio di un server udp semplice
http://www.lilik.it/~mirko/gapil/gapilsu268.html

 e dopo come posso controllare che tipo di dato ho ricevuto ?
Come gia' ho detto sopra, tu ricevi sono una sequenza di byte. Cosa
c'e' dentro dipende da cosa ci ha inserito chi ha trasmesso il
pacchetto.
Cosi' e' difficile darti una mano. Se ci spieghi a cosa serve tutto
questo e cosa viene inserito nei pacchetti UDP forse potremmo darti
qualche informazione in piu'.
Saluti,
The Librarian

 
se ho capito bene cosa vuoi
man 2 sendfile
con input blockante e loopando un byte alla volta.
inefficiente, non allochi, non serve sapere la dimensione dei dati ma
almeno ti risparmi una commutazione di contesto per ogni byte.

Allora, mi spiego meglio
ho una funzione SEND che prende in input due parametri :
int *header, void *buf
entrambi sono già allocati , il size di header è 10 interi
il size di buf non lo conosco.
il mio primo problema è che devo fondere header+buf
e creare una nuova struttura messaggio che inviero' con
una sendto() ad un altro host che lo riceve con la funzione
FORWARDER
la Funzione FORWARDER riceve il messaggio
costruito come (heder + buff) tramite una recvfrom
e lo invia a un terzo host che richiama la funzione
RECV
La funzione recv riceve il messaggio, lo spacchetta
togliendo l'header che è un vettore di 10 int
e ritorna il buff
Le mie domande sono le seguenti :
1) come faccio a creare una nuova variabile messaggio
che contiene prima (int *header) e poi (void *buff)
e soprattutto di che tipo dovrà essere questo msg ,
considerando che void *buff lo prendo come parametro
ed è stato già allocato prima della chiamata alla funzione?
2) la funzione FORWARDER dovrà implementare
una recvfrom e una sendto del buffer ricevuto,
di che size dovro' implementare il buffer da allocare
considerando che non conosco a priori la dimensione?
Grazie

 Grazie
questo lo decidi tu,
i pacchetti che vengono dalla rete vengo bufferizzati (a livello
applicazione)  a tranci di dimensione decisa dall'applicativo, quindi
sei du a dare una dimensione con il 3' parametre della recvfrom,
magari 1024? 11111111? come vuoi tu.(sarebbe divertente vedere le
specifiche del payload che ha l'udp sulla tua rete... )
ma la vera domanda è come fai a riconoscere l'header se arrivano tanti
pacchetti dove alcuni possono essere persi e alcuni possono arrivare
in ordine misto??metti dei byte a 0 o dei controlli sui valori o un
checksum (fai tipo la somma di ogni tot di byte o un hash) ma tanto
proprio perche hai scelto udp non dovrebbe interessarti questo tipo di
problema..
Attenzione
non è detto che con la sendto ti invia tutto il buffer la prima volta,
dovrestri ripetere la sendto  finche non ha inviato tutto il buffer
 inviato=sendto(socket,buf,100,...);
inviato puo' essere <0 o un valore da 0 a 100
non sempre è 100

 considerando che non conosco a priori la dimensione?
devi aggiungere un header.


In realtà per non avere questi problemi ho pensato di
far viaggiare pacchetti di size fisso sulla rete
che sono composti da Header+Buff.
Quando ho un buffer lo splitto in tanti msg di size fisso
in modo da sapere sempre quanti byte ricevere o mandare
ovviamente header conterrà informazioni su quanti byte
sono usati nella struttura.
Il mio problema rimane fondere
header intero di 10 elementi
void *buff , non conosco la dimenzione ma potrei usare sizeof() ?
esiste qualche funzione a basso livello per copiare i byte da buff
a msg ?
e msg come la dovrei dichiarare ? è stato sugerito char, perchè ?
GRAZIE

 e msg come la dovrei dichiarare ? è stato sugerito char, perchè ?
Spero di non offenderti con questa osservazione, ma dalle domande che
fai sembra trasparire che le tue conoscenze del C siano piuttosto
scarse. Ora io non so se sviluppi questo programma per un esame
all'universita' o per altri motivi, ma comunque il mio consiglio e' di
spendere prima un po' di tempo ad imparare bene il C standard, perche'
altrimenti temo troverai difficolta' in continuazione. Per fare un
analogia, e' come se la difficolta' dello scrivere un tema risiedesse
nel tenere in mano la penna piu' che nel creare il contenuto.
Con delle solide basi di C potreti concentrarti su quello che devi
fare e non tanto sul come fare.
Saluti,
The Librarian

 scarse. Ora io non so se sviluppi questo programma per un esame
Ti ringrazio per le risposte date ,
Sai, credo che la presuzione di conoscere totalmente un argomento
non sia propria di persone meritevoli,
in ogni caso , illuminami !   dove ho fatto trasparire le me scarse
conoscenze C ?
credo che la mia domanda non sia banale :
fondere due array di tipo intrinsecamente diverso come potrebbero
essere ( char + long )
e creare una nuova struttura di una terza tipologia.
Grazie in ogni caso per le risposte date

 e creare una nuova struttura di una terza tipologia.
li casti a void* e hai finito.

 e creare una nuova struttura di una terza tipologia.
void* buff;
long* header;
const unsigned int buff_size = 1024;
const unsigned int header_size = 10 * sizeof(long);
char* msg = malloc(header_size + buff_size);
memcpy(msg, header, header_size);
memcpy(msg + header_size, buff, buff_size);
Saluti,
The Librarian