Newsgroup: it.comp.lang.c
Titolo: problema stringhe

ciao,
ho queste linee di codice che vengono gestite da una connessione
socket:
read(csock,&car,1);
write(csock,&car,1);
putchar(car);
write(csock,message,strlen(message));
il mio problema nasce da fatto che vorrei memorizzare i caratteri che
provengono dal csock in una stringa ... ho provato con strcat ma non
va...
mi aiutate??
ciao e grazie

solo una chiarificazione:
in pratica non riesco ad archiviare il contenuto di csock in una
stringa (csock e' il socket che apro in fase di connessione):
csock=accept(s,(st...));
ciao e arigrazie


 ha scritto nel messaggio
news:3cf60732...@news.interbusiness.it...

immagino che car sia definito cosi':
char car;
questo spiegherebbe perche' strcat non ti funziona (vuole sequenze
di caratteri null terminated).
prova questo:
char Buf[1024];
int i=0;
memset(Buff, 0, 1024);
..........................
............................
............................
read(csock,&car,1);
Buff[i++]=car;                    // mette l'iesimo carattere dentro Buf -
poi aggiunge 1 ad i per
                                        // il successivo inserimento.
write(csock,&car,1);
putchar(car);
write(csock,message,strlen(message));
Buff alla fine conterra' tutti i caratteri ricevuti dalla socket.
E sara' pure null-terminated (cioe' usabile nelle funzioni strcat, strlen,
strcpy, printf.....).
Ci sono pero le seguenti note:
1) I caratteri inviati via socket NON devono superare i 1023 (altrimenti
esci fuori
    dalla grandezza di Buf. Con conseguenti problemi di memoria.
2) Quello che ho detto per le funzioni strcpy ecc e' vero se e soltanto se
sulla
    socket vengono inviati caratteri ASCII stampabili. Ad esempio se sulla
socket
    transita uno zero (e' il carattere di terminazione stringa) le suddette
funzioni penseranno
    che il buffer finisca li'.
    Ho il dubbio di non essermi spiegato bene. Insomma potrai usare Buf come
parametro
    per le funzioni che usano stringhe se sulla socket viaggiano caratteri
tipo '0'...'9' ..'a'...'z'....
                                                             Andrea Z.

grazie mille Andrea!!!
cmq ieri sera (pur senza guardare il NG avevo risolto) ... facevo una
sprintf del char in una stringa di appoggio dopodiche facevo la strcat
in message (la stringa finale) .... alla fine pero' ho utilizzato la
tua soluzione perche' mi piaceva di piu'
ciao e grazie ancora...

 sprintf del char in una stringa di appoggio dopodiche facevo la strcat
  ^^^^^^^
Meno male che non la utilizzi piu'!!! :-).
Non prenderla male!! Voglio solo farti notare
alcune cose sulla sprintf e sul suo uso un po'
spregiudicato che spesso se ne fa.
1) La sprintf e' una funzione estremamente complessa
e quindi time-consuming. Utilizzarla per trasformare un
carattere in una stringa, quando basta:
string[0]=carattere_da_usare;
string[1]=0;  o string[1]='\0';   // 0 e' il carattere terminatore
e' un inutile spreco di potenza di calcolo.
2) La sprintf se cerchi di copiare caratteri che non siano
printabili, potrebbe condurre a risultati inaspettati.
3) La sprintf (come tutte le funzioni che agiscono su stringhe)
deve essere utilizzata con attenzione (molta, puo' provocare
errori difficili da rintracciare) e quando utile.
Comunque anche la mia soluzione e' incompleta. Il Buf
e' stato definito di una certa lunghezza. Se si supera quella
lunghezza il risultato potrebbe essere impredicibile. Considera
che la piu' gran parte degli exploit dei sistemi operativi
si basano proprio su mandare stringhe particolari e di
lunghezza superiore al previsto.
Quindi nel mio programma bisognerebbe aggiungere un
controllo tipo:
if(i>1022) {
    // azioni da intrapprendere se si sta' per sforare il buffer
    // ad esempio rifiutando gli altri caratteri e riportando un errore
    // oppure ridimensionare (usando malloc e realloc....)
}
va da se che se si vuole ridimensionare il buffer non va usato il numero
1022 nel controllo ma una varibile pari alla dimensione del buffer -2.
                                           Andrea Z.

grazie ancora per l'utile spiegazione...
.. per quel problema di sforamento del buffer avevo pensato di crearmi
dinamicamente la stringa "giocando" (con molta attenzione) con 2 o 3
puntatori a stringhe.... credo sia l'unico modo ... non vorrei
limitare la quantita di caratteri trasmettibili.. che ne dici?
ciao

 ha scritto nel messaggio
news:3cf76b51...@news.interbusiness.it...

Direi di usare malloc e realloc. Riprendendo l'esempio
precedente  e facendo qualche modifica...
int LEN_BUFFER=1024;
char *Buf;
char *newBuf;
int i=0;
Buf=(char *) malloc(LEN_BUFFER);
memset(Buf, 0, LEN_BUFFER);
..........................
............................
............................
read(csock,&car,1);
Buf[i]=car;                   // mette l'iesimo carattere dentro Buf
if(i > LEN_BUFFER-2) {                                // se il numero di
caratteri sfora
    LEN_BUFFER=LEN_BUFFER*2;
    newBuf=(char *) realloc (Buf, LEN_BUFFER);    // raddoppia il buffer
    if(newBuf==NULL) {
        printf("Ach! Non possibile reallocare tanto spazio. Ma quanta roba
pensi di mandare?\n");
        // gestire quest'errore (non e' piu' possibile storare in memoria)
ad esempio reinizzializzare i: i=0;
    } else {
        memset(&newBuf[LEN_BUFFER/2], 0, LEN_BUFFER/2); // ripulisce il
buffer aggiunto. Non e' necessario, ma lo preferisco.
        Buf=newBuf;                                                   //
punta al nuovo buffer raddoppiato
    }
}
write(csock,&car,1);
putchar(car);
write(csock,message,strlen(message));

....grazie anche se "non voglio" leggere la soluzione... me la
guardero' con calma ... dopo che ci avro' sbattuto un po' la testa...
;-)
ciao