Bucle inusual

[guzzano]

Buenas, tengo un problema con un bucle que no termina y se repita dos veces aun así coloque un break, la linea es la 137.

Código C:

/*
 
    @author:        Alberto Jsé <guzzan0>
    @package:       pkgrmd - This package remove all dependences alone of a applications.
 
*/
 
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <dirent.h>
 
#define VERSION "Dannie27"
 
void search_package(char *package_name);
void depends_parser(FILE *pkgfile_dir);
 
int main(int argc, char *argv[]) 
{
    if (argc > 1) 
    {
        if (strncmp(argv[1], "--info", 6) == 0)
        {
            printf("Written by Alberto Jse <guzzan0>\nVersion: %s\n\nPlease report bug to [email protected]\n", VERSION);
        }
        else if (strncmp(argv[1], "--help", 6) == 0)
        {
            printf("Usage: pkgrmd <commands> or <package to remove>\nExample: pkgrmd wine, pkgrmd xorg, etc.\n\n");
            printf("Commands avaiable: \n\n--help (Show this help) \n--info (Show the current version and author)\n");
        }
        else
        {
            if ((strlen(argv[1])) > 20)
            {
                printf("[pkgrmd] Sorry, max name package is 20 characteres. \n");
            }
            else
            {
                search_package(argv[1]);
            }
        }
    }
    else 
    {
        printf("[pkgrmd] Try \"pkgdmr --help\" for more information. \n");
    }
}
 
void search_package(char *package_name)
{
    FILE* package_installed = fopen("/var/lib/pkg/db", "r");
    
    char *package_n, package_file_lines[225];
    int package_install = 0;
 
    package_n = (char *) malloc(strlen(package_name)+2);
 
    if (!package_n)
    {
        puts("Malloc can not create more space.");
        exit(0);
    }
    
    sprintf(package_n, "%s\n", package_name);
    
    if (package_installed != NULL)
    {
        while (fgets(package_file_lines, sizeof(package_file_lines), package_installed) != NULL)
        {
            if (strcmp(package_file_lines, package_n) == 0)
            {
                package_install = 1;
                break;
            }
            else
            {
                package_install = 0;
            }
        }
        free(package_n);
    }
    else
    {
        puts("[pkgrmd] I can't open file: /var/lib/pkg/db - Sorry");
        exit(0);
    }
 
    fclose(package_installed);
 
    if (package_install == 1)
    {
        DIR *ports_directory, *package_directory;
        struct dirent *structure_directory, *structure_package;
 
        char ports_base[12] = "/usr/ports/", *package_directories = NULL;
 
        if ((ports_directory = opendir(ports_base)) != NULL) 
        {
            while ((structure_directory = readdir(ports_directory)) != NULL)
            {
                if (*structure_directory->d_name == '.') 
                    continue;
 
                package_directories = (char *) malloc(strlen(ports_base)+strlen(structure_directory->d_name)+1);
                if (!package_directories)
                {
                    puts("Malloc can't create more space.");
                    exit(0);
                }
                
                sprintf(package_directories, "%s%s/", ports_base, structure_directory->d_name);
 
                if ((package_directory = opendir(package_directories)) != NULL)
                {
                    while ((structure_package = readdir(package_directory)) != NULL)
                    {
                        if (*structure_package->d_name == '.') 
                            continue;
                            
                        if (strcmp(package_name, structure_package->d_name) == 0)
                        {   
                            FILE *pkgbuild;
                            char *depends;
                            
                            depends = (char *) malloc(strlen(package_directories)+strlen(structure_package->d_name)+9);
                            if (!depends)
                            {
                                puts("Malloc can't create more space.");
                                exit(0);
                            }
                            
                            sprintf(depends, "%s%s/Pkgfile", package_directories, structure_package->d_name);
 
                            if ((pkgbuild = fopen(depends, "r")))
                            {
                                puts("s");
                                fclose(pkgbuild);
                            }
                            else
                            {
                                printf("[pkgrmd] The package %s not have file pkgfile. Renew pkgfile with commands \"ports -u\" and try again. \n", structure_package->d_name);
                            }
 
                            break;
                        }
                    }
                    puts("test");
                }
                else
                {
                    printf("[pkgrmd] This error no is fatal. But I can't open dir: %s%s", package_directories, structure_package->d_name);
                    exit(0);
                }
            }
            closedir(ports_directory);
            closedir(package_directory);
        }
        else 
        {
            printf("[pkgrmd] I cant read directory: %s, you have installed prt-get?", ports_base);
            exit(0);
        }
    }
    else
    {
        printf("[pkgrmd] The package %s not is installed. \n[pkgrmd] Please verify package with: prt-get search [name_package] \n", package_name);
        exit(0);
    }
}
 

Como una duda adicional, ¿estará mal abusar de la función exit()? y he visto ejemplos donde con malloc se tiene que multiplicar lo que queremos abrir por sizeof(char*) ¿tengo que hacerlo?

Muchas gracias, saludos!

[cesar_casla]

se tiene que multiplicar lo que queremos abrir por sizeof(char*)

el caso de sizeof(char *) se usa para crear arreglos de punteros. En tu caso debe ser sizeof(char), y apesar de que el tipo char ocupa un byte para mi gusto es necesario ponerlo mas que nada por una forma mas ordenada de programacion( todos sabemos que 1 x cualquier_numero = cualquier_numero )

¿estará mal abusar de la función exit()?

mmm la verdad nose pero viste que el abuso siempre es malo :)..... Lo que deberias cambiar es el argumento que le pasas a la funcion cuando hay un error; el 0(cero) se utiliza en caso de exito y distinto de cero si hubo un error. Para esto hay definidas dos macros: EXIT_SUCCESS y EXIT_FAILURE


Saludos

[guzzano]

Iniciado por cesar_casla

el caso de sizeof(char *) se usa para crear arreglos de punteros. En tu caso debe ser sizeof(char), y apesar de que el tipo char ocupa un byte para mi gusto es necesario ponerlo mas que nada por una forma mas ordenada de programacion( todos sabemos que 1 x cualquier_numero = cualquier_numero )


mmm la verdad nose pero viste que el abuso siempre es malo :)..... Lo que deberias cambiar es el argumento que le pasas a la funcion cuando hay un error; el 0(cero) se utiliza en caso de exito y distinto de cero si hubo un error. Para esto hay definidas dos macros: EXIT_SUCCESS y EXIT_FAILURE


Saludos

Perfecto, mejore el código para que en algunas cosas saliera sin necesidad de invocar exit(); Otra duda, ya que veo que sabes acerca, digamos que quiero un string, osea

Código C:

char *package[2] = {"xorg", "wine");
 

El compilador asigna creo yo cuantos caracteres debe tener este string, pero dado el caso que yo quiera asignarlo desde malloc.

Crear el ejemplo de arriba desde malloc. ¿Tienes idea?

Sobre el bucle lo solucione agregando una variable que al encontrar el paquete haga un break; en el otro bucle.

Saludos.

[cesar_casla]

Seria algo asi:

Código C:

char **p=NULL;
 
p=(char **)malloc(sizeof(char *)*CANT_PUNTEROS); /* reservo "x" punteros */
 
for(i=0;i<CANT_PUNTEROS;i++)  
  p[i]=(char *)malloc(sizeof(char)*MAX_STRING); /* a cada puntero le reservo "x" longitud de tamaño*/
 

Viendolo como una matriz: CANT_PPUNTEROS=num_filas y MAX_STRING=num_columnas


Saludos

[guzzano]

Nada más que decir, ¡GENIO! muchas gracias!

Edito, probe, estudie un poco sobre los arrays multidimensionales, los probe en varias cosas y me funcionaron. Pero aquí, al parecer no, a ver si me puedes decir en donde me he equivocado, y disculpa el abuso.

Código C:

char *depends_parser(FILE *pkgfile_dir)
{
    char character, last_character = '0', *string_depends = NULL, **depends_alone = NULL, *depends_p;
    int character_count = 0, memory_count = 1, memory_count2 = 1, position_check = 0;
 
    depends_alone = (char **) malloc(sizeof(char *)*memory_count2);
 
    while ((character = getc(pkgfile_dir)) != EOF)
    {
        if (character == '\n')
        {
            if ((strstr(string_depends, "Depends on:")))
            {
                
                string_depends[character_count] = '\0';
                depends_p = string_depends;
 
                character_count = 0;
                memory_count = 1;
                
                while (*depends_p != '\0')
                {
                    
                    if (*depends_p == ':')
                    {
                        position_check = 1;
                        depends_p++;
 
                        if (!isalpha(*depends_p)){}
                        else
                        {
                            depends_p--;
                        }
                    }
                    else if (position_check == 1)
                    {
                        if (*depends_p == ' ')
                        {
                            memory_count2++;
 
                            depends_alone = (char **) realloc(depends_alone, sizeof(char *)*memory_count2); 
                            
                            character_count = 0;
                            memory_count = 1;
                        }
                        
                        if (isalpha(*depends_p) || *depends_p == '-' || isdigit(*depends_p))
                        {
                            
                            depends_alone[memory_count2] = (char *) realloc(depends_alone[memory_count2], sizeof(char)*memory_count);
                            depends_alone[memory_count2][character_count] = *depends_p;
 
 
                            character_count++;
                            memory_count++;
                        }
                    }
                    
                    depends_p++;
                }
                break;
            }
            else
            {
                character_count = 0; 
                memory_count = 1;
                string_depends = malloc(0);
            }
        }
        else
        {
            
            string_depends = (char *) realloc(string_depends, memory_count);
            string_depends[character_count] = character;
 
            character_count++;
            memory_count++;
        }
    }
 
    //puts(depends_alone[0]);
 
    if (string_depends)
        free(string_depends);
}
 

[guzzano]

Doble post, lo siento.

[cesar_casla]

Un poco dificil de entender ya que nose bien como es el formato del archivo que estas usando... igual el problema puede ser que usas memory_count2 como indice del arreglo dinamico de punteros:

1° inicializas a memory_count2=1, y reservas memoria a depends_alone
2° si se cumple if (*depends_p == ' ') memory_count incrementa a 2, luego volves a reservar memoria a depends_alone(le reservas dos punteros). Hasta aca todo bien

3°

Código C:

depends_alone[memory_count2] = (char *) realloc(depends_alone[memory_count2], sizeof(char)*memory_count);
 

aca esta el problema: si reservaste dos punteros, osea posiciones 0 y 1 del arreglo de punteros, no podes acceder a depends_alone[memory_count2] ya que estas accediendo a la posicion 2 que no existe


Creo q ese es el error, sino trata de detallar mas que te marca el compilador


Saludos

[guzzano]

Muchisimas gracias, estoy volviendo a hacer la función ya lo probare!

Saludos.