Punteros y cadena.

[guzzano]

Buenos días. Tengo un problema con unos datos que quiero guardar en una cadena.

Tengo la siguiente función, que cargará los datos a una memoria dinámica que reciba desde un socket.

Código C:

int recv_text (int s_socket, int hlength,
  const char * header, httpstruct * st)
{
  char *buffer = NULL;
  char *bfflen;
  
  unsigned long long allrecv = 0; 
  int brecv = 0;
  int bsend = 0;
  
  int r_timeout;
  int s_timeout;
  
  timeout t_out;
  
  t_out.tv_sec = RESOLVED_TIMEOUT;
  t_out.tv_usec = 0;
  
  /* recv timeout */
  r_timeout = setsockopt (s_socket,  
    SOL_SOCKET, SO_RCVTIMEO, &t_out, 
    sizeof (timeout));
  
  /* send timeout */
  s_timeout = setsockopt (s_socket,  
    SOL_SOCKET, SO_SNDTIMEO, &t_out, 
    sizeof (timeout));
  
  if (r_timeout < 0 || s_timeout < 0)
    return NOT_SETOPT;
  
  bsend = send(s_socket, header, 
    hlength, 0);
  
  if (t_out.tv_sec == 0)
    return TIMEOUT;
  else if (bsend != hlength)
    return HEADER_IS_SHORT;
  
  do
  { 
    if (allrecv > BYTES_BUFFER_TRANFER)
    {
      buffer = realloc(buffer, allrecv);
      
      if (!buffer)
      {
        close(s_socket);
        return NOT_MEMORY;
      }
      
      bfflen = buffer + BYTES_BUFFER_TRANFER;
    }
    else
    {
      buffer = malloc(BYTES_BUFFER_TRANFER);
  
      if (!buffer)
        return NOT_MEMORY;
      
      bfflen = buffer;
    }
 
    brecv = recv(s_socket, bfflen, 
      BYTES_BUFFER_TRANFER, PROTOCOL_ZERO);
    
    allrecv += BYTES_BUFFER_TRANFER;
  } while (brecv > 0);
  
  /* debug without null byte; *(buffer+allrecv) = '\0'; */
  puts(buffer);
  free(buffer); /* for valgrind debug */
  /* */
  
  /* st->httpcontent = buffer */
  st->size_httpcontent = allrecv;
  
  close (s_socket);
  return SUCCESS;
}
 

El problema sucede que no guarda los datos. Creo la memoria dinámica, la lleno de datos, y cuando vuelva otra vez el bucle, reasignará un espacio a buffer y con bfflen le digo que tiene que empezar a llenar luego de x espacios (BYTES_BUFFER_TRANFER), pero no funciona. Siempre me muestra la cadena mal formada. Disculpen si no me supe explicar.

Saludos.

[vosk]

No se si lo has solucionado, pero por ahi veo algo raro. Cuando trabajas con sockets no puedes esperar recibir BYTES_BUFFER_TRANFER, sino que le indicas al recv que dispones de BYTES_BUFFER_TRANFER bytes para guardar datos y que te copie lo que sea posible, con eso te retorna el nº de bytes copiados (en tu codigo brecv), y es ese valor el que tienes que usar para incrementar el contador de recibidos; por lo mismo tienes que truncar el buffer de datos recibidos al nº de bytes copiados si ese no se llena.

Otra cosa, en la parte de malloc y realloc; supongamos que BYTES_BUFFER_TRANFER es 256; inicias el proceso:

Código C:

//inicio
allrecv = 0;
 
//primer ciclo
si allrecv > 256 => realloc //no porque allrecv = 0
sino => malloc // estamos en este caso
recv //recibes 256
allrecv += 256
 
//segundo ciclo, ahora allrecv = 256 ok?
si allrecv > 256 => realloc //tampoco porque allrecv = 256
sino => malloc // volvemos a estar en este caso ?!?!
//fin de la partida
 

Supongo que ya ves por donde van los tiros.

Aun otra cosa: supongo que cuando descomentas la linea st->httpcontent = buffer entonces comentas la de free(buffer) :)

Lo que se hace en estos casos es implementar una funcion que bloquea memoria y a la vez concatena lo recibido; te copio una que precisamente hice el otro dia (forma parte de una libreria para un proyecto que tenemos entre manos con un colega):

Código C:

/**
    buffer, buffer de trabajo
    block, datos con los que vamos a ampliar el buffer
    block_size, tamaño de block
    buffer_size, tamaño de buffer antes de la ampliacion
    zend, boleano para añadir un 0 al final, es un parche para trabajar con texto
*/
int hsock_alloc_strcat(void **buffer, void *block, int block_size, int buffer_size, char zend) {
    char *ptr;
    char endz =(zend)?1:0;
 
    if(!(*buffer)) {
        if(!(*buffer = malloc(block_size + endz))) {
            return 0;
        }
        memset(*buffer, 0, block_size + endz);
    } else {
        if(!(ptr = realloc(*buffer, block_size + buffer_size + endz))) {
            return 0;
        }
        *buffer = ptr;
    }
 
    memcpy(*buffer + buffer_size, block, block_size);
 
    return block_size;
}
 
//ejemplo
char *mibuffer = 0;
char tmp[512];
int nbr, nbc, ttbuffer = 0;
 
//tal como recibo le digo que me amplie el buffer
nbr = recv(socket, tmp, sizeof(tmp), 0);
nbc = hsock_alloc_strcat(&mibuffer, tmp, nbr, ttbuffer, 0);
ttbuffer += nbc;
 
//al finalizar
free(mibuffer);
 

Espero que te sirva
Saludos
vosk

[guzzano]

Buenas vosk.

Sobre el primer punto, ya lo tenía tomado en cuenta, estaba arreglado en el código original, pero en un momento probando y reservando 512 en cada bucle lo dejé así y no lo arreglé. Es una perdida de memoria grande, si los datos que se recibirán de de forma pequeña. Lo sé. Error mío.

Lo demás, ya está arreglado tal como me dices, muchas gracias, estaré implementando una función como la tuya a ver que tal funciona, estaba pensando hacer algo parecido, pero me pareció mejor hacerlo sin una variable temporal.

En efecto, sí, cuando descomento una línea, comento free.

Ya te comentaré resultados, saludos y suerte en ese proyecto.

[vosk]

"...suerte en ese proyecto..."

Gracias, la vamos a necesitar :)

Saludos
vosk

[guzzano]

Hice una función parecida a la tuya, no crees que es meter siempre el espacio del byte nulo. Así cuando se guarde una cadena, agrega al final el 0, y si se tiene que agregar otra, lo remplaza y vuelve a meter el byte nulo al final. Sé que lo agregas sobre todo para trabajar con textos, pero recuerda que muchas funciones usan el 0 para terminar la búsqueda. Así no rellenas la variable completa de 0.

Código C:

int block_mem(char **buff, char *block, size_t block_size, 
  size_t new_size)
{
  if (!(*buff))
  {
    /* +1 = null byte */
    *buff = malloc((new_size + 1));
    
    if (!(*buff))
      return NOT_MEMORY;
  }
  else
  {
    *buff = realloc(*buff, block_size + new_size);
    
    if (!*(buff))
      return NOT_MEMORY;
  }
  
  memcpy(*buff + block_size, block, new_size);
  *(*buff + block_size + new_size) = '\0';
  
  return new_size;
}
 

[vosk]

Saludos guzzano, buena observacion; la opcion del 0 final lo puse con el proposito de reutilizar la funcion: por defecto en datos bajados de red (aun en texto plano) no quiero el 0 final, pero para cualquier otro tipo de operacion si. Es lo que tienes en tu codigo:

Código C:

/* +1 = null byte */
*buff = malloc((new_size + 1));
 

Para el proyecto no nos interesa que siempre termine en 0.

Lo de rellenar la variable completa de 0 lo puse y ahi se quedo (solo está en el malloc), tengo que quitarlo ya que no tiene sentido.

Y una observacion:

Código C:

*buff = realloc(*buff, block_size + new_size);
if (!*(buff))
    return NOT_MEMORY;
 

No apliques el realloc sobre la variable final, en caso de error obtienes una perdida de memoria (memory leak); usa un temporal para la asignacion:

Código C:

char *tmp;
if(!(tmp = realloc(*buff, block_size + new_size))) {
    return NOT_MEMORY;
}
*buff = tmp;
memcpy(*buff...
 

Saludos
vosk