[C] token corrotto

[lavoro76]

salve,

ho riscontrato uno strano problema programmando in C sotto ambiente linux.
Si tratta di un progettino accademico.
Classico modello client/server (che girano in locale sulla stessa macchina), una mini-mini-versione di istant messaging.

Quando cerco di mandare un messaggio ad una persona la cui login è lunga esattamente 5 caratteri, la split_arg o forse la lettura da namedpipe, mi aggiunge della roba (nonostante la strlen "spergiuri" che si tratta ancora di una stringa di 5 caratteri.)

Queste sono le righe incriminate :

char ** split_arg(char *linea, char *separatori, int *numerotoken)
{
  int i = 0;   /* numero token trovati */
  char **argv; /* vettore dei token */
  char *copialinea;  /* copia della linea */
  char **indirizzocopialinea = &copialinea; /* punta a copialinea */
                                                                                                       
  /* copia la stringa argomento */
  copialinea = (char *) malloc( strlen(linea) + 1 );
  strcpy(copialinea, linea);
                                                                                                       
  /* alloco prima posizione vettore dei token */
  argv = (char **) malloc(sizeof(char *));
                                                                                                       
  while( (argv[i] = strsep(indirizzocopialinea, separatori)) != NULL  ) {
                                                                                                       
    /* ancora un token */
    i++;
                                                                                                       
    /* ridimensiona vettore dei token */
    argv = (char **) realloc(argv, (i + 1) * sizeof(char *));
  }
                                                                                                       
  /* scrive il numero di token trovati */
  *numerotoken = i;
                                                                                                       
  /* libera lo spazio allocato */
  free(copialinea);
  return(argv);
}



/*fine split_arg*/

Questa l'ha scritta la prof, funziona ma se puo' servire...

/*
  File: send_una_sola_write.c
  Description: funzione di scrittura su pipe con protocollo variabile che usa
  una sola write per evitare malfunzionamenti in caso di piu' processi
  scrittori
                                                                                                       
*/
                                                                                                       
/*
  @description -- funzione di scrittura su pipe con protocollo variabile
  che usa una sola write
                                                                                                       
  @param fdpipe -- file descriptor della pipe
  @parame message -- messaggio da trasmettere (una stringa) non puo' essere
  NULL
                                                                                                       
*/
                                                                                                       
                                                                                                       
void sendmessageonpipe(int fdpipe, char * message)
     /*in base a message, crea un opportuno messaggio secondo
      la codifica a lunghezza variabile e lo invia sulla pipe*/
{
  char * msg;
  int lung;
                                                                                                       
  /*alloco memoria per il messaggio, per la sua lunghezza e per il terminatore*/
  if (!(msg = malloc(sizeof(int)+strlen(message)+1))) {
    WRITELN("Errore allocando memoria per un messaggio");
    exit(-1);
  }
  lung = strlen(message);
                                                                                                       
  /*scrivo la lunghezza del messaggio in testa a msg*/
                                                                                                       
  memcpy(msg,&lung,sizeof(int));
  /*dopo la lunghezza copio integralmente message (la strcpy mette il terminatore)*/
  strcpy(msg+sizeof(int),message);
                                                                                                       
  WRITE("sendmessageonpipe: ");
  WRITELN(message);
                                                                                                       
  /*invio il tutto sulla pipe*/
  IFERROR(write(fdpipe,msg,lung+sizeof(int)),"Errore scrivendo su una pipe");
}



/*fine sendmessageonpipe*/

Dalla pipe leggo cosi':

IFERROR(fdpipeC = open(clientpipe, O_RDONLY), "Errore: apertura pipe server client");
                                                                                                         read(fdpipeC, &lunghezza, sizeof(int));
  msg = calloc((lunghezza),sizeof(char));
  read(fdpipeC, msg, lunghezza);
                                                                                           IFERROR(close(fdpipeC), "Errore: chiusura pipe server client");
  risptok = split_arg(msg, " ", &ntok);
  free(msg);

 /*fine lettura*/

In pratica se il secondo token e' di 5 caratteri viene corrotto, mentre se misura una qualsiasi lunghezza != 5
funziona perfettamente!

scusate per l'enorme lunghezza del messaggio, ma sono disperato

[MMarzia]

Originariamente inviato da lavoro76
scusate per l'enorme lunghezza del messaggio, ma sono disperato

di nulla, però come da regolamento ricordati di inserire il codice nell'apposito tag [*CODE] ... [*/CODE] (senza asterischi) per renderlo più leggibile e utilizza titoli meno generici

[lavoro76]

OK.

Cmq potete chiudere il topic, ho risolto aggiungendo uno " " in fondo alla stringa da scrivere sulla pipe.