Saludos

tengo la siguiente función que se llama checkSumS1() que creo que me esta ocasionando que me truene un programa, no quiero publicar el código completo porque son 3,500 y tantas líneas de código. Lo que hace es que le paso 3 cadenas(Longitud, direccion y codigo_datos) y dentro de la función las concatena en una variable llamada registroS1, después va leyendo registroS1 de dos caracteres en dos. Por ejemplo si tengo ABE31000 primero va a obtener AB, que se supone es un "numero hexadecimal" y lo voy a convertir a su equivalente en decimal, y lo mismo con los demas caracteres. los decimales se van sumando, a la suma se le saca complemento a 1 y se obtienen sus 2 ultimos caracteres

char *CheckSumS1(char *Longitud,char *direccion,char *codigo_datos)
{
    int i,j,k,numero,x = 0,base = 16,suma = 0,complemento;
    char *registroS1,*byte,digito[2],*checksum;
    registroS1 = (char*)malloc(39*sizeof(char));
    checksum = (char*)malloc(3*sizeof(char));
    sprintf(registroS1,"%s%s%s",Longitud,direccion,codigo_datos);
    for(i = 0;registroS1[i];i+=2)
    {
        byte = (char*)calloc(3,sizeof(char));
        for(j = 1,k = i;j <= 2;j++,k++)
        {
            sprintf(digito,"%c",registroS1[k]);
            strcat(byte,digito);
        }
        numero = obtenerNumero(byte,x,base);
        suma+=numero;
        free(byte);
    }
    complemento = ~suma;
    sprintf(checksum,"%02X",complemento);
    checksum = ultimos2bits(checksum);
    return checksum;
}

no se bien cual podria ser la causa de que cada vez que cuando el  codigo llega a esta función para ejecutarla a veces me truena y otras no. no se si  el sprintf y el strcat sean la mejor opcion para usarlos en la función, pero fue lo único que se me ocurrió para que me fuera leyendo de 2 en dos. si alguien me dijera cual es el bug que tiene me codigo se lo agradeceria mucho

gracias

gracias eferion por tu respuesta, le haré esos cambios a mi código. Una última pregunta, si tengo declarada un puntero como *cadena y después le asigno memoria así:

codigo_datos = (char*)malloc(33*sizeof(char));

es correcto después de hacer esto inicializarla con NULL??

En mi opinión la causa mas probable es la indicada por eferion, otro escenario donde la función puede reventar se da si el total de caracteres a procesar es impar, en ese caso el bucle principal eventualmente procesara el carácter siguiente al '\0'.

Con todo respeto no son, ni de lejos, las mejores opciones. Eso ya lo había comentado en varios de tus temas.

Para el caso es mejor utilizar aritmética de punteros y sscanf para leer cada uno de los bytes (base 16, dos dígitos). Un ejemplo sin las validaciones recomendadas (de malloc y sscanf):

unsigned char chk(char *lon, char *dir, char *cod)
{
   size_t nb = strlen(lon) + strlen(dir) + strlen(cod);
   size_t i;
 
   char *p = malloc(nb + 1);
   unsigned total = 0;
   unsigned byte;
 
   sprintf(p, "%s%s%s", lon, dir, cod);
   for (i = 0; i < nb; i += 2){
      sscanf(p + i, "%2x", &byte);
      total += byte;
   }
 
   return ~total & 0xFF;
}

El tipo de retorno es unsigned char para evitar la reserva de memoria.

Tal vez se pueda mejorar pero ello depende de cierta información que no provees, por ejemplo si el numero de caracteres de cada cadena esta garantizado a ser par se puede evitar la reserva de memoria (mediante malloc) y en su lugar utilizar un array de punteros y dos bucles anidados.

Un saludo