[SOLUCIONADO] El bucle se queda parado (Listas enlazadas)

[guzzano]

Buenos días, he tratado por mis propios medios tratar de solucionar este problema, pero no doy con una solución. Trataré de explicarlo. El problema es, tengo un bucle que recorre una estructura, hace un parseo con una función y agrega datos, funciona perfecto en una primera llamada que le hago, pero a la segunda, el bucle se queda parado.

La cabecera

Código C:

#define PORTS_DIR "/usr/ports/"
#define DB_DIR "/var/lib/pkg/db"
 
struct deppkg
{
  char n_pkg[256];
  char d_pkg[PATH_MAX];
  
  int r_list; /* is read? */
  int i_file; /* in other pkgfile of a pkg is installed? */
  
  struct deppkg * pkgnext;
};
 
struct deppkg * d_firts = NULL;
struct deppkg * d_last = NULL;
 
int 
add_dep (const char * n_pkg, const char * d_pkg)
{
  struct deppkg * aux;
  
  aux = malloc(sizeof(struct deppkg));
  
  if (aux == NULL)
    return -1;
  
  aux->pkgnext = NULL;
  
  aux->n_pkg[0] = '\0';
  aux->d_pkg[0] = '\0';
  
  strncat(aux->n_pkg, n_pkg, strlen(n_pkg));
  strncat(aux->d_pkg, d_pkg, strlen(d_pkg));
  
  aux->r_list = 0;
  aux->i_file = 0;
  
  if (d_firts == NULL)
  {
    d_firts = aux;
    d_last = aux;
  }
  else
  {
    d_last->pkgnext = aux;
    d_last = aux; 
  }
  
  return 0;
}
 
void 
clean_dep ()
{
  struct deppkg * curr = d_firts;
  struct deppkg * aux;
  
  while (curr != NULL)
  {
    aux = curr->pkgnext;
    
    free(curr);
    
    curr = aux;
  }
}
 
int 
parse_dep (const char * d_pkg, char *r_pkg, size_t len)
{
  if (d_pkg == 0 || r_pkg == 0 || len <= 0)
    return -1;
  
  char * buffer_next;
  char buffer[3072];
  
  int count = 0;
  static int num_m = 1;
  
  memset(r_pkg, '\0', len);
  
  FILE * pkgfile;
  
  pkgfile = fopen(d_pkg, "r");
  
  if (pkgfile == NULL)
  {
    fprintf(
      stderr,
      "pkgrmd >> Error opening «%s»: %s\n",
      d_pkg,
      strerror(errno)
    );
    
    return -1;
  }
  
  while (fgets(buffer, sizeof(buffer), pkgfile) != NULL)
  {
    if (buffer[0] != '#')
      break;
    
    if (strncmp(buffer, "# Depends on:", 13) == 0)
    {
      buffer_next = strchr(buffer, ':');
      buffer_next += num_m;
     
      while (!isalpha(*buffer_next)) {
        if (*buffer_next == '\0')
          break;
          
        buffer_next++;
        num_m++;
      }
      
      while (*buffer_next != '\0') {
        if (isalpha(*buffer_next) != 0 || isdigit(*buffer_next) != 0
            || *buffer_next == '-')
        {
          r_pkg[count] = *buffer_next;
          
          count++;
        }
        
        if (*buffer_next == ' ' || *buffer_next == ',' 
            || *buffer_next == '\n') 
        {
          fclose(pkgfile);
          
          return 0;
        }
        
        buffer_next++;
        num_m++;
      }
    }
  }
  
  /* Test... */
  num_m = 1;
  
  fclose(pkgfile);
  
  return -1;
}
 
int 
pkg_is_installed (const char * n_pkg)
{
  if (strlen(n_pkg) <= 0)
    return -1;
  
  char pkg_fix[254];
  char buffer[256];
  
  int len;
  
  len = snprintf(pkg_fix, sizeof(pkg_fix), "%s\n", n_pkg);
  
  if (len <= 0)
    return -1;
 
  FILE * db;
  
  db = fopen(DB_DIR, "r");
  
  if (db == NULL) 
  {
    fprintf(
      stderr,
      "pkgrmd >> Error opening «%s»: %s\n",
      DB_DIR,
      strerror(errno)
    );
    
    return -1;
  }
  
  while (fgets(buffer, sizeof(buffer), db) != NULL)
    if (strcmp(buffer, pkg_fix) == 0) {
      fclose(db);
    
      return 0;
    }
      
    
  fclose(db);
  
  return -1;
}
 
int 
pkg_dir_inst (const char * n_pkg, char * d_pkg, size_t len)
{
  if (n_pkg == 0 || len <= 0)
    return -1;
  
  char * verify = NULL;
  char buffer[PATH_MAX];
  int len_s;
 
  DIR * ports_dir;
  struct dirent *dir_s;
  
  ports_dir = opendir(PORTS_DIR);
  
  if (ports_dir == NULL) 
  {
    fprintf(
      stderr,
      "pkgrmd >> Error opening «%s»: %s\n",
      PORTS_DIR,
      strerror(errno)
    );
    
    return -1;
  }
  
  while ((dir_s = readdir(ports_dir)) != NULL)
  {
    if (strcmp(dir_s->d_name, ".") == 0) continue;
    else if (strcmp(dir_s->d_name, "..") == 0) continue;
    
    if (dir_s->d_type == DT_DIR) {
       len_s = snprintf(
        buffer, 
        sizeof(buffer), 
        "%s%s/%s/Pkgfile", 
        PORTS_DIR, 
        dir_s->d_name,
        n_pkg
       );
      
      if (len_s <= 0)
        return -1;
      
      if (access(buffer, F_OK) != -1) {
        verify = strncpy(d_pkg, buffer, len);
        break;
      }
    }
  }
  
  if (verify == NULL) 
  {
    closedir(ports_dir);
    
    return -1;
  }
    
  closedir(ports_dir);
  
  return 0;
}
 

El cuerpo

Código C:

#include <string.h>
#include <stdio.h>
#include <dirent.h>
#include <errno.h>
#include <ctype.h>  
#include <unistd.h>
#include <stdlib.h>
 
#include "pkgrmd.h"
 
int main (int argc, char * argv[])
{
  if (argc > 1)
  {
    char d_pkg[PATH_MAX] = {0};
    char n_pkg[255] = {0};
    
    char r_pkg[255] = {0};
    char d_pkg_buff[PATH_MAX] = {0};
       
    strncat(n_pkg, argv[1], sizeof(n_pkg)-1);
    
    if (pkg_is_installed(n_pkg) != 0)
    {
      fprintf(stderr, "pkgrmd >> This package is not installed\n");
 
      return EXIT_FAILURE;
     }
     
    if (pkg_dir_inst(n_pkg, d_pkg, sizeof(d_pkg)) != 0)
    {
      fprintf(stderr,"pkgrmd >> An error was encountered\n");
      
      return EXIT_FAILURE;
    }
    
    while (parse_dep(d_pkg, r_pkg, sizeof(r_pkg)) != -1) 
    {  
      if (pkg_dir_inst(r_pkg, d_pkg_buff, sizeof(d_pkg_buff)) != 0)
        continue;
        
      if (add_dep(r_pkg, d_pkg_buff) != 0)
        continue;
    }
    
    /* Has two structures, the first is NULL if not have data  */
    if (d_firts == NULL)
    {
      fprintf(stderr, 
      "pkgrmd >> The package %s not have depends.\n", n_pkg);
 
      return EXIT_FAILURE;
    }
    
    struct deppkg * aux = d_firts;
    
    while (aux != NULL)
    {
      if (aux->r_list != 0)
        continue;
      
      if (pkg_dir_inst(aux->n_pkg, 
            d_pkg_buff, 
            sizeof(d_pkg_buff)) != 0)
        continue;
      
      while (parse_dep(d_pkg_buff, r_pkg, sizeof(r_pkg)) != -1)
      {
        // Aquí...
        add_dep(r_pkg, "tes"t);
      
      }
      
      // Luego de arriba, aquí no se ejecuta.
 
      aux = aux->pkgnext;
    }
    
    clean_dep();
  }
  else
  {
    fprintf(
      stderr,
      "pkgrmd >> syntax: pkgrmd <name_package>\n"
    );
  }
  
  return 0;
}
 

Donde dice 'aquí' es la parte que donde se queda parado aún así el bucle haya terminado.

Muchas gracias, y espero sus respuestas. :)

[L3m0n]

No me he mirado el codigo muy a fondo, pero hay una tontería que podría ser el causante de todo.
Cuando llamas a la funcion add_dep, el segundo argumento es "tes"t y supongo que debería ser "test". Puede que eso sea lo que se carga el bucle.

[guzzano]

Gracias por tu respuesta. Eso fue un error al traspasar el código al foro, en el archivo donde compilo está bien.

Edito: Creo encontrar el problema, doy la solución por si alguien algún día se topa con este error. Volví a reprogramar y me di cuenta que estaba haciendo varios continue en un bucle que recorría una estructura dinámica, al esas condiciones ser falsas, hacía que el bucle fuera infinito ya que no estaba dando otra dirección en la memoria donde buscar.

Código C:

struct list {
  ... 
  struct list * next;
} ...
 
while (aux != NULL) {
  // No es lo mismo, esto
  if (...)
    continue;
  
  // A esto
  if (...) {
    aux = aux->next;
    continue
  }
  
  aux = aux->next;
}
 

Muchas gracias igual,
Saludos