[c/c++] ho un problema ad accedere alla memoria

[misterx]

ciao,
ho la seguente dichiarazione

void *buffer;
buffer = (char *)malloc(ByteToRecive);
int ByteRecived = Socket->ReceiveBuf(buffer, ByteToRecive);

ora ho un buffer pieno di dati inviato da client ma non riesco ad accedere al singolo carattere.
Perchè vorrei fare questo?
Perchè ho notato che ricevendo e salvando su file n volte buffer, questo viene terminato con caratteri sporchi.
La mia idea era una cosa del tipo

buffer[strlen(buffer)-1]='\0';

che non funziona.

Non avendo mai usato una dichiarazione del tipo void *buffer; chiedo lumi.

grazie


p.s.
magari è anche elementare questa domanda

[wingman87]

E' chi manda i dati che dovrebbe terminare i dati in modo opportuno (con il carattere nullo ad esempio). Oppure specificando la quantità di dati che seguirà nei primi byte.
strlen stessa mi sembra che si basa sulla ricerca del carattere nullo...

[misterx]

ciao,
quello che viene inviato dal client è un file ASCII. La dimensione di quanto inviato dal client viene catturata dal server attraverso la funzione postata e quindi non rappresenta un problema. Il fatto è che si invia più volte il medesimo file ASCII questo dopo due o tre invii presenta in coda dei caratteri spuri che cercavo di eliminare aggiungendo un carattere nullo al termine del file.

[wingman87]

Se hai la dimensione dei dati come mai hai bisogno di aggiungere un carattere terminatore?

Sinceramente credo di non aver capito appieno il problema. Ti dico cosa ho capito:
- Il server invia un file
- Il client riceve il file e la dimensione, il contenuto del file finisce in un buffer la cui dimensione è la dimensione del file ricevuto
- Il client riscrive il contenuto del buffer da qualche altra parte, ma siccome non c'è un carattere terminatore, sul nuovo file viene aggiunto qualche carattere sporco che si trova oltre la dimensione del buffer.

Se è così quando crei il buffer dagli un byte in più di spazio per aggiungere in fondo \0.

[misterx]

Originariamente inviato da wingman87

Se hai la dimensione dei dati come mai hai bisogno di aggiungere un carattere terminatore?

Sinceramente credo di non aver capito appieno il problema. Ti dico cosa ho capito:
- Il server invia un file
- Il client riceve il file e la dimensione, il contenuto del file finisce in un buffer la cui dimensione è la dimensione del file ricevuto
- Il client riscrive il contenuto del buffer da qualche altra parte, ma siccome non c'è un carattere terminatore, sul nuovo file viene aggiunto qualche carattere sporco che si trova oltre la dimensione del buffer.

Se è così quando crei il buffer dagli un byte in più di spazio per aggiungere in fondo \0.

hai capito benissimo: il fatto è che siccome la dichiarazione è un void *buffer; il compilatore non accetta scrittre del tipo buffer[strlen(buffer)-1]='\0'; ottenfo i seguenti errori di compilazione:

Size of the type 'void' is unknown or zero
Not an allowed type

[wingman87]

Prova con un cast:

void *buffer;
buffer = (char *)malloc(ByteToRecive+1);
int ByteRecived = Socket->ReceiveBuf(buffer, ByteToRecive);
((char *)buffer)[ByteToRecive] = '\0';

[misterx]

è perfetto, grazie 1000

ciao

[WarDuck]

Il problema è presto detto, buffer è un puntatore void e mi chiedo perché hai fatto questa scelta, considerato che poi fai un cast a char sulla malloc.

Per definizione non puoi deferenziare un puntatore void, per cui non ha alcun senso accedere ad un'array di void (tipo di dato che non esiste) .

Io farei così:

char* Buffer;

Buffer = malloc( ... ); /* se il compilatore si lamenta aggiungi il cast */

...


Buffer[x] = '\0';

Attenzione comunque: il tuo codice ha un problema, strlen(buffer) funziona se e solo se buffer è già terminato, per cui l'operazione che tenti di fare non è corretta.

La cosa ideale sarebbe capire quanto effettivamente leggi dal socket, e terminare il Buffer nella posizione corrispondente (ovvero in base a quanto hai letto).

Ad esempio:

Buffer[ByteReceived] = '\0';

Nota, non conosco le altre parti del tuo programma, non so dunque se leggi più volte a gruppi di TOT bytes oppure fai un'unica lettura da socket... nel primo caso dovresti comunque controllare che il buffer non sia esaurito e tenere conto del totale dei bytes letti.

Edit: ho letto adesso che wingman ti ha fatto notare la cosa.

[wingman87]

Originariamente inviato da WarDuck

Edit: ho letto adesso che wingman ti ha fatto notare la cosa.

Comunque il tuo post è stato utile, anche perché mi hai fatto notare un errore nel codice che ho scritto nel precedente post:

void *buffer;
buffer = (char *)malloc(ByteToRecive+1);
int ByteRecived = Socket->ReceiveBuf(buffer, ByteToRecive);
((char *)buffer)[ByteToRecive] = '\0';

ByteToRecive dovrebbe essere ByteRecived

[misterx]

Originariamente inviato da WarDuck

Il problema è presto detto, buffer è un puntatore void e mi chiedo perché hai fatto questa scelta, considerato che poi fai un cast a char sulla malloc.

Per definizione non puoi deferenziare un puntatore void, per cui non ha alcun senso accedere ad un'array di void (tipo di dato che non esiste) .

Io farei così:

char* Buffer;

Buffer = malloc( ... ); /* se il compilatore si lamenta aggiungi il cast */

...


Buffer[x] = '\0';

Attenzione comunque: il tuo codice ha un problema, strlen(buffer) funziona se e solo se buffer è già terminato, per cui l'operazione che tenti di fare non è corretta.

La cosa ideale sarebbe capire quanto effettivamente leggi dal socket, e terminare il Buffer nella posizione corrispondente (ovvero in base a quanto hai letto).

Ad esempio:

Buffer[ByteReceived] = '\0';

Nota, non conosco le altre parti del tuo programma, non so dunque se leggi più volte a gruppi di TOT bytes oppure fai un'unica lettura da socket... nel primo caso dovresti comunque controllare che il buffer non sia esaurito e tenere conto del totale dei bytes letti.

Edit: ho letto adesso che wingman ti ha fatto notare la cosa.

ciao,
è la funzione da me usatat Socket->ReceiveBuf(buffer, ByteToRecive);
che pretende un puntatore void.

Pensa che ho provato ad usarla addirittura nel modo seguente:

char buffer[100000];
int ByteRicevuti = Socket->ReceiveBuf(buffer, 100000);

dove pur non lamentandosi il compilatore, il contenut di buffer ritornato ogni volta è randomico, mentre mi aspettavo al massimo una troncatura dei caratteri in eccesso, quelli dopo il 100000 carattere.

Provando ad inviare un testo da client di 90000 caratteri, a volte manca la testa del file, a volte la coda ed altre è corretto.

[WarDuck]

Originariamente inviato da misterx

ciao,
è la funzione da me usatat Socket->ReceiveBuf(buffer, ByteToRecive);
che pretende un puntatore void.

Pensa che ho provato ad usarla addirittura nel modo seguente:

char buffer[100000];
int ByteRicevuti = Socket->ReceiveBuf(buffer, 100000);

dove pur non lamentandosi il compilatore, il contenut di buffer ritornato ogni volta è randomico, mentre mi aspettavo al massimo una troncatura dei caratteri in eccesso, quelli dopo il 100000 carattere.

Provando ad inviare un testo da client di 90000 caratteri, a volte manca la testa del file, a volte la coda ed altre è corretto.

Non è normale questo comportamento. Escludendo problemi di libreria, il mio consiglio è quello di inizializzare sempre il buffer a 0, e assicurarti che il client invii i dati correttamente.

Quest'ultima cosa la puoi fare abbastanza agevolmente con un analizzatore di protocollo come Wireshark .

La cosa importante comunque rimane terminare il buffer ricevuto con '\0' (se lo stai leggendo come stringa) e farlo correttamente.

Relativamente alle dimensioni del buffer, bisognerebbe vedere se ti serve solo come appoggio oppure ti serve per aggregare più pacchetti in sequenza.

Ti conviene usare un buffer medio, 4096 bytes dovrebbero essere sufficienti nella maggioranza dei casi.

Chiaramente ti devi assicurare che sia sempre verificata la condizione ByteLettiDaSocket < DimensioneBuffer.

Tutto comunque dipende da ciò che ci fai con quel buffer.

[misterx]

Originariamente inviato da WarDuck

Non è normale questo comportamento. Escludendo problemi di libreria, il mio consiglio è quello di inizializzare sempre il buffer a 0, e assicurarti che il client invii i dati correttamente.

Quest'ultima cosa la puoi fare abbastanza agevolmente con un analizzatore di protocollo come Wireshark .

La cosa importante comunque rimane terminare il buffer ricevuto con '\0' (se lo stai leggendo come stringa) e farlo correttamente.

Relativamente alle dimensioni del buffer, bisognerebbe vedere se ti serve solo come appoggio oppure ti serve per aggregare più pacchetti in sequenza.

Ti conviene usare un buffer medio, 4096 bytes dovrebbero essere sufficienti nella maggioranza dei casi.

Chiaramente ti devi assicurare che sia sempre verificata la condizione ByteLettiDaSocket < DimensioneBuffer.

Tutto comunque dipende da ciò che ci fai con quel buffer.

inizio a pensare che qualche componente di BCB abbia qualche problema a me non noto, ma indagherò.

Una notizia che avevo letto e che mi aveva depistato circa l'uso della funzione int ByteRicevuti = Socket->ReceiveBuf(buffer, 100000); e che hai in un certo qual modo risollevato tu scrivendo ByteLettiDaSocket < DimensioneBuffer, era che la funzione da me menzionata non legge i dati da socket in una volta sola, come se avessi dovuto implementare una sorta di while per leggere tutti i dati inviati dal client.

Facendo numerose prove con file di dimensioni anche considerevoli invece, ho notato che ora i dati al server arrivano tutti.

Mi chiedo se esistono allora du strade:
a) dichiaro un buffer fisso e chiamo n volte una certa funzione sino a leggere tutto lo stream
b) uso la funzione che sto usando dimensionando il suo buffer dinamicamente in funzione di ByteToRecive

grazie