source: trunk/package/opkg/patches/008-fix_parsing_insanity.patch @ 18124

Last change on this file since 18124 was 18124, checked in by jow, 7 years ago

[package] opkg: ignore Section, Source and Maintainer as well when ignoring descriptions, saves a few hundred KB memory

File size: 26.3 KB
  • libopkg/opkg_utils.c

    a b  
    4444    return 0; 
    4545} 
    4646 
    47 char **read_raw_pkgs_from_file(const char *file_name) 
    48 { 
    49      FILE *fp;  
    50      char **ret; 
    51      
    52      if(!(fp = fopen(file_name, "r"))){ 
    53           fprintf(stderr, "can't get %s open for read\n", file_name); 
    54           return NULL; 
    55      } 
    56  
    57      ret = read_raw_pkgs_from_stream(fp); 
    58  
    59      fclose(fp); 
    60  
    61      return ret; 
    62 } 
    63  
    64 char **read_raw_pkgs_from_stream(FILE *fp) 
    65 {     
    66      char **raw = NULL, *buf, *scout; 
    67      int count = 0; 
    68      size_t size = 512; 
    69       
    70      buf = calloc (1, size); 
    71  
    72      while (fgets(buf, size, fp)) { 
    73           while (strlen (buf) == (size - 1) 
    74                  && buf[size-2] != '\n') { 
    75                size_t o = size - 1; 
    76                size *= 2; 
    77                buf = realloc (buf, size); 
    78                if (fgets (buf + o, size - o, fp) == NULL) 
    79                     break; 
    80           } 
    81            
    82           if(!(count % 50)) 
    83                raw = realloc(raw, (count + 50) * sizeof(char *)); 
    84          
    85           if((scout = strchr(buf, '\n'))) 
    86                *scout = '\0'; 
    87  
    88           raw[count++] = strdup(buf); 
    89      } 
    90      
    91      raw = realloc(raw, (count + 1) * sizeof(char *)); 
    92      raw[count] = NULL; 
    93  
    94      free (buf); 
    95      
    96      return raw; 
    97 } 
    98  
    9947/* something to remove whitespace, a hash pooper */ 
    10048char *trim_alloc(char *line) 
    10149{ 
  • libopkg/pkg.c

    a b  
    2020#include <alloca.h> 
    2121#include <string.h> 
    2222#include <stdbool.h> 
     23#include <unistd.h> 
     24#include <fcntl.h> 
    2325#include <errno.h> 
    2426 
    2527#include "pkg.h" 
     
    277279int pkg_init_from_file(pkg_t *pkg, const char *filename) 
    278280{ 
    279281     int err; 
    280      char **raw; 
    281282     FILE *control_file; 
    282283 
    283284     err = pkg_init(pkg); 
     
    290291     if (err) { return err; } 
    291292 
    292293     rewind(control_file); 
    293      raw = read_raw_pkgs_from_stream(control_file); 
    294      pkg_parse_raw(pkg, &raw, NULL, NULL); 
     294     pkg_parse_fd(pkg, fileno(control_file), NULL, NULL, 0); 
    295295 
    296296     fclose(control_file); 
    297297 
     
    459459 
    460460void set_flags_from_control(opkg_conf_t *conf, pkg_t *pkg){ 
    461461     char * temp_str; 
    462      char **raw =NULL; 
    463      char **raw_start=NULL;  
     462     int fd; 
    464463 
    465464     size_t str_size = strlen(pkg->dest->info_dir)+strlen(pkg->name)+12; 
    466465     temp_str = (char *) alloca (str_size); 
     
    471470        return; 
    472471     } 
    473472     sprintf( temp_str,"%s/%s.control",pkg->dest->info_dir,pkg->name); 
    474     
    475      raw = raw_start = read_raw_pkgs_from_file(temp_str); 
    476      if (raw == NULL ){ 
    477         opkg_message(conf, OPKG_ERROR, "Unable to open the control file in  %s\n", __FUNCTION__); 
    478         return; 
    479      } 
    480473 
    481      while(*raw){ 
    482         if (!pkg_valorize_other_field(pkg, &raw ) == 0) { 
    483             opkg_message(conf, OPKG_DEBUG, "unable to read control file for %s. May be empty\n", pkg->name); 
    484         } 
    485      } 
    486      raw = raw_start; 
    487      while (*raw) { 
    488         if (raw!=NULL) 
    489           free(*raw++); 
    490      } 
     474        if( (fd = open(temp_str, O_RDONLY)) > 0 ) 
     475        { 
     476                if( pkg_valorize_other_field(pkg, fd) ) 
     477                { 
     478                        opkg_message(conf, OPKG_DEBUG, "unable to read control file for %s. May be empty\n", pkg->name); 
     479                } 
    491480 
    492      free(raw_start);  
     481                close(fd); 
     482        } 
     483        else 
     484        { 
     485                opkg_message(conf, OPKG_ERROR, "Unable to open the control file in  %s\n", __FUNCTION__); 
     486                return; 
     487        } 
    493488 
    494489     return ; 
    495  
    496490} 
    497491 
    498492#define CHECK_BUFF_SIZE(buff, line, buf_size, page_size) do { \ 
  • libopkg/pkg_hash.c

    a b  
    2020#include <ctype.h> 
    2121#include <stdlib.h> 
    2222#include <string.h> 
     23#include <unistd.h> 
     24#include <fcntl.h> 
    2325 
    2426#include "hash_table.h" 
    2527#include "pkg.h" 
     
    110112} 
    111113 
    112114int pkg_hash_add_from_file(opkg_conf_t *conf, const char *file_name, 
    113                            pkg_src_t *src, pkg_dest_t *dest, int is_status_file) 
     115                           pkg_src_t *src, pkg_dest_t *dest, int is_status_file, int no_desc) 
    114116{ 
    115      hash_table_t *hash = &conf->pkg_hash; 
    116      char **raw; 
    117      char **raw_start; 
    118      pkg_t *pkg; 
    119      
    120      raw = raw_start = read_raw_pkgs_from_file(file_name); 
    121      if (!raw) 
    122         return -ENOMEM; 
    123  
    124      while(*raw){         /* don't worry, we'll increment raw in the parsing function */ 
    125           pkg = pkg_new(); 
    126           if (!pkg) 
    127                return -ENOMEM; 
    128  
    129           if (pkg_parse_raw(pkg, &raw, src, dest) == 0) { 
    130                if (!pkg->architecture) { 
    131                     char *version_str = pkg_version_str_alloc(pkg); 
    132                     pkg->architecture = pkg_get_default_arch(conf); 
    133                     opkg_message(conf, OPKG_ERROR, "Package %s version %s has no architecture specified, defaulting to %s.\n", 
    134                                  pkg->name, version_str, pkg->architecture); 
    135                     free(version_str); 
    136                } 
    137                hash_insert_pkg(hash, pkg, is_status_file,conf); 
    138           } else { 
    139                pkg_deinit (pkg); 
    140                free(pkg); 
    141           } 
    142      } 
     117        hash_table_t *hash = &conf->pkg_hash; 
     118        pkg_t *pkg; 
    143119 
    144      /* XXX: CLEANUP: I'd like a cleaner interface for cleaning up 
    145         memory after read_raw_pkgs_from_file */ 
    146      raw = raw_start; 
    147      while (*raw) { 
    148           free(*raw++); 
    149      } 
    150      free(raw_start); 
    151      return 0; 
     120        int fd; 
     121        int rv = 0; 
     122 
     123        if( (fd = open(file_name, O_RDONLY)) > 0 ) 
     124        { 
     125                while(1) 
     126                { 
     127                        pkg = pkg_new(); 
     128                        if(!pkg) { 
     129                                rv = -ENOMEM; 
     130                                break; 
     131                        } 
     132 
     133                        if (pkg_parse_fd(pkg, fd, src, dest, no_desc) == 0) { 
     134                                if (!pkg->architecture) { 
     135                                        char *version_str = pkg_version_str_alloc(pkg); 
     136                                        pkg->architecture = pkg_get_default_arch(conf); 
     137                                        opkg_message(conf, OPKG_ERROR, "Package %s version %s has no architecture specified, defaulting to %s.\n", 
     138                                        pkg->name, version_str, pkg->architecture); 
     139                                        free(version_str); 
     140                                } 
     141 
     142                                hash_insert_pkg(hash, pkg, is_status_file, conf); 
     143                        } else { 
     144                                pkg_deinit (pkg); 
     145                                free(pkg); 
     146                                break; 
     147                        } 
     148                } 
     149 
     150                close(fd); 
     151        } 
     152        else 
     153        { 
     154                opkg_message (conf, OPKG_ERROR, 
     155                        "Unable to open package list %s\n", file_name); 
     156 
     157                rv = -EINVAL; 
     158        } 
     159  
     160        return rv; 
    152161} 
    153162 
    154163abstract_pkg_t * abstract_pkg_fetch_by_name(hash_table_t * hash, const char * pkg_name) 
  • libopkg/pkg_parse.c

    a b  
    191191  
    192192} 
    193193 
    194 /* Some random thoughts from Carl: 
    195  
    196    This function could be considerably simplified if we just kept 
    197    an array of all the generic string-valued field names, and looped 
    198    through those looking for a match. Also, these fields could perhaps 
    199    be stored in the package as an array as well, (or, probably better, 
    200    as an nv_pair_list_t). 
    201  
    202    Fields which require special parsing or storage, (such as Depends: 
    203    and Status:) could be handled as they are now.  
    204 */ 
    205 /* XXX: FEATURE: The Suggests: field needs to be changed from a string 
    206    to a dependency list. And, since we already have 
    207    Depends/Pre-Depends and need to add Conflicts, Recommends, and 
    208    Enhances, perhaps we could generalize all of these and save some 
    209    code duplication. 
    210 */ 
    211 int pkg_parse_raw(pkg_t *pkg, char ***raw, pkg_src_t *src, pkg_dest_t *dest) 
     194int pkg_parse_fd(pkg_t *pkg, int fd, pkg_src_t *src, pkg_dest_t *dest, int no_desc) 
    212195{ 
    213     int reading_conffiles, reading_description; 
    214     int pkg_false_provides=1; 
    215     char ** lines; 
    216     char * provide=NULL; 
    217  
    218     pkg->src = src; 
    219     pkg->dest = dest; 
    220  
    221     reading_conffiles = reading_description = 0; 
    222  
    223     for (lines = *raw; *lines; lines++) { 
    224         /*      fprintf(stderr, "PARSING %s\n", *lines);*/ 
    225         switch (**lines) { 
    226         case 'P': 
    227             if(isGenericFieldType("Package:", *lines))  
    228                 pkg->name = parseGenericFieldType("Package", *lines); 
    229             else if(isGenericFieldType("Priority:", *lines)) 
    230                 pkg->priority = parseGenericFieldType("Priority", *lines); 
    231             else if(isGenericFieldType("Provides", *lines)){ 
    232 /* Here we add the internal_use to align the off by one problem between provides_str and provides */ 
    233                 provide = (char * ) calloc(1, strlen(*lines)+ 35 ); /* Preparing the space for the new opkg_internal_use_only */ 
    234                 if ( alterProvidesLine(*lines,provide) ){ 
    235                     return EINVAL; 
    236                 } 
    237                 pkg->provides_str = parseDependsString( provide, &pkg->provides_count); 
    238 /* Let's try to hack a bit here. 
    239    The idea is that if a package has no Provides, we would add one generic, to permit the check of dependencies 
    240    in alot of other places. We will remove it before writing down the status database */ 
    241                 pkg_false_provides=0; 
    242                 free(provide); 
    243             }  
    244             else if(isGenericFieldType("Pre-Depends", *lines)) 
    245                 pkg->pre_depends_str = parseDependsString(*lines, &pkg->pre_depends_count); 
    246             break; 
    247  
    248         case 'A': 
    249             if(isGenericFieldType("Architecture:", *lines)) 
    250                 pkg->architecture = parseGenericFieldType("Architecture", *lines); 
    251             else if(isGenericFieldType("Auto-Installed:", *lines)) { 
    252                 char *auto_installed_value; 
    253                 auto_installed_value = parseGenericFieldType("Auto-Installed:", *lines); 
    254                 if (strcmp(auto_installed_value, "yes") == 0) { 
    255                     pkg->auto_installed = 1; 
    256                 } 
    257                 free(auto_installed_value); 
    258             } 
    259             break; 
    260  
    261         case 'F': 
    262             if(isGenericFieldType("Filename:", *lines)) 
    263                 pkg->filename = parseGenericFieldType("Filename", *lines); 
    264             break; 
    265  
    266         case 'S': 
    267             if(isGenericFieldType("Section:", *lines)) 
    268                 pkg->section = parseGenericFieldType("Section", *lines); 
    269             else if(isGenericFieldType("Size:", *lines)) 
    270                 pkg->size = parseGenericFieldType("Size", *lines); 
    271             else if(isGenericFieldType("Source:", *lines)) 
    272                 pkg->source = parseGenericFieldType("Source", *lines); 
    273             else if(isGenericFieldType("Status", *lines)) 
    274                 parseStatus(pkg, *lines); 
    275             else if(isGenericFieldType("Suggests", *lines)) 
    276                 pkg->suggests_str = parseDependsString(*lines, &pkg->suggests_count); 
    277             break; 
    278  
    279         case 'T': 
    280             if(isGenericFieldType("Tags:", *lines)) 
    281                 pkg->tags = parseGenericFieldType("Tags", *lines); 
    282             break; 
    283  
    284         case 'M': 
    285             if(isGenericFieldType("MD5sum:", *lines)) 
    286                 pkg->md5sum = parseGenericFieldType("MD5sum", *lines); 
    287             /* The old opkg wrote out status files with the wrong case for MD5sum, 
    288                 let's parse it either way */ 
    289             else if(isGenericFieldType("MD5Sum:", *lines)) 
    290                 pkg->md5sum = parseGenericFieldType("MD5Sum", *lines); 
    291             else if(isGenericFieldType("Maintainer", *lines)) 
    292                 pkg->maintainer = parseGenericFieldType("Maintainer", *lines); 
    293             break; 
    294  
    295         case 'I': 
    296             if(isGenericFieldType("Installed-Size:", *lines)) 
    297                 pkg->installed_size = parseGenericFieldType("Installed-Size", *lines); 
    298             else if(isGenericFieldType("Installed-Time:", *lines)) { 
    299                 char *time_str = parseGenericFieldType("Installed-Time", *lines); 
    300                 pkg->installed_time = strtoul(time_str, NULL, 0); 
    301                 free (time_str); 
    302             }        
    303             break; 
    304  
    305         case 'E': 
    306             if(isGenericFieldType("Essential:", *lines)) { 
    307                 char *essential_value; 
    308                 essential_value = parseGenericFieldType("Essential", *lines); 
    309                 if (strcmp(essential_value, "yes") == 0) { 
    310                     pkg->essential = 1; 
    311                 } 
    312                 free(essential_value); 
    313             } 
    314             break; 
    315  
    316         case 'V': 
    317             if(isGenericFieldType("Version", *lines)) 
    318                 parseVersion(pkg, *lines); 
    319             break; 
    320  
    321         case 'C': 
    322             if(isGenericFieldType("Conffiles", *lines)){ 
    323                 parseConffiles(pkg, *lines); 
    324                 reading_conffiles = 1; 
    325             } 
    326             else if(isGenericFieldType("Conflicts", *lines)) 
    327                 pkg->conflicts_str = parseDependsString(*lines, &pkg->conflicts_count); 
    328             break; 
    329  
    330         case 'D': 
    331             if(isGenericFieldType("Description", *lines)) { 
    332                 pkg->description = parseGenericFieldType("Description", *lines); 
    333                 reading_conffiles = 0; 
    334                 reading_description = 1; 
    335             } 
    336             else if(isGenericFieldType("Depends", *lines)) 
    337                 pkg->depends_str = parseDependsString(*lines, &pkg->depends_count); 
    338             break; 
    339  
    340         case 'R': 
    341             if(isGenericFieldType("Recommends", *lines)) 
    342                 pkg->recommends_str = parseDependsString(*lines, &pkg->recommends_count); 
    343             else if(isGenericFieldType("Replaces", *lines)) 
    344                 pkg->replaces_str = parseDependsString(*lines, &pkg->replaces_count); 
    345              
    346             break; 
    347  
    348         case ' ': 
    349             if(reading_description) { 
    350                 /* we already know it's not blank, so the rest of description */       
    351                 pkg->description = realloc(pkg->description, 
    352                                            strlen(pkg->description) 
    353                                            + 1 + strlen(*lines) + 1); 
    354                 strcat(pkg->description, "\n"); 
    355                 strcat(pkg->description, (*lines)); 
    356             } 
    357             else if(reading_conffiles) 
    358                 parseConffiles(pkg, *lines); 
    359                  
    360             break; 
    361  
    362         default: 
    363             if(line_is_blank(*lines)) { 
    364                 lines++; 
    365                 goto out; 
    366             } 
     196        char buf[4096]; 
     197        char line[4096]; 
     198        char *nl; 
     199        int bsz = 0; 
     200        int eof = 0; 
     201        int rv = EINVAL; 
     202 
     203        int reading_conffiles, reading_description; 
     204        int pkg_false_provides=1; 
     205        char *provide = NULL; 
     206 
     207        pkg->src = src; 
     208        pkg->dest = dest; 
     209 
     210        reading_conffiles = reading_description = 0; 
     211 
     212        memset(buf, 0, sizeof(buf)); 
     213 
     214        while(!eof || (bsz > 0)) 
     215        { 
     216                if(!eof) 
     217                { 
     218                        rv = read(fd, &buf[bsz], sizeof(buf) - bsz - 1); 
     219 
     220                        if( rv == 0 ) 
     221                        { 
     222                                eof = 1; 
     223 
     224                                if( bsz == 0 ) 
     225                                { 
     226                                        rv = EINVAL; 
     227                                        break; 
     228                                } 
     229                        } 
     230                        else if( rv < 0 ) 
     231                        { 
     232                                /*opkg_message(conf, OPKG_ERROR, "I/O error while parsing package list\n");*/ 
     233                                printf("I/O error while parsing package list\n"); 
     234                                rv = EINVAL; 
     235                                break; 
     236                        } 
     237                        else 
     238                        { 
     239                                bsz += rv; 
     240                                buf[bsz] = 0; 
     241                                rv = 0; 
     242                        } 
     243                } 
     244 
     245                if( (nl = strchr(buf, '\n')) != NULL ) 
     246                { 
     247                        bsz -= (int)(nl - buf) + 1; 
     248 
     249                        memset(line, 0, sizeof(line)); 
     250                        memcpy(line, buf, (int)(nl - buf)); 
     251                        memmove(buf, &buf[(int)(nl - buf) + 1], bsz); 
     252 
     253                        switch(line[0]) 
     254                        { 
     255                                case 'P': 
     256                                        if(isGenericFieldType("Package:", line))  
     257                                                pkg->name = parseGenericFieldType("Package", line); 
     258                                        else if(isGenericFieldType("Priority:", line)) 
     259                                                pkg->priority = parseGenericFieldType("Priority", line); 
     260                                        else if(isGenericFieldType("Provides", line)){ 
     261                                                /* Here we add the internal_use to align the off by one problem between provides_str and provides */ 
     262                                                provide = (char * ) calloc(1, strlen(line)+ 35 ); /* Preparing the space for the new opkg_internal_use_only */ 
     263                                                if ( alterProvidesLine(line,provide) ){ 
     264                                                        rv = EINVAL; 
     265                                                        break; 
     266                                                } 
     267                                                pkg->provides_str = parseDependsString( provide, &pkg->provides_count); 
     268                                                /* Let's try to hack a bit here. 
     269                                                   The idea is that if a package has no Provides, we would add one generic, to permit the check of dependencies 
     270                                                   in alot of other places. We will remove it before writing down the status database */ 
     271                                                pkg_false_provides=0; 
     272                                                free(provide); 
     273                                        } 
     274                                        else if(isGenericFieldType("Pre-Depends", line)) 
     275                                                pkg->pre_depends_str = parseDependsString(line, &pkg->pre_depends_count); 
     276                                                break; 
     277 
     278                                case 'A': 
     279                                        if(isGenericFieldType("Architecture:", line)) 
     280                                                pkg->architecture = parseGenericFieldType("Architecture", line); 
     281                                        else if(isGenericFieldType("Auto-Installed:", line)) { 
     282                                                char *auto_installed_value; 
     283                                                auto_installed_value = parseGenericFieldType("Auto-Installed:", line); 
     284                                                if (strcmp(auto_installed_value, "yes") == 0) { 
     285                                                        pkg->auto_installed = 1; 
     286                                                } 
     287                                                free(auto_installed_value); 
     288                                        } 
     289                                        break; 
     290 
     291                                case 'F': 
     292                                        if(isGenericFieldType("Filename:", line)) 
     293                                                pkg->filename = parseGenericFieldType("Filename", line); 
     294                                        break; 
     295 
     296                                case 'S': 
     297                                        if(isGenericFieldType("Section:", line) && !no_desc) 
     298                                                pkg->section = parseGenericFieldType("Section", line); 
     299                                        else if(isGenericFieldType("Size:", line)) 
     300                                                pkg->size = parseGenericFieldType("Size", line); 
     301                                        else if(isGenericFieldType("Source:", line) && !no_desc) 
     302                                                pkg->source = parseGenericFieldType("Source", line); 
     303                                        else if(isGenericFieldType("Status", line)) 
     304                                                parseStatus(pkg, line); 
     305                                        else if(isGenericFieldType("Suggests", line)) 
     306                                                pkg->suggests_str = parseDependsString(line, &pkg->suggests_count); 
     307                                        break; 
     308 
     309                                case 'T': 
     310                                        if(isGenericFieldType("Tags:", line)) 
     311                                                pkg->tags = parseGenericFieldType("Tags", line); 
     312                                        break; 
     313 
     314                                case 'M': 
     315                                        if(isGenericFieldType("MD5sum:", line)) 
     316                                                pkg->md5sum = parseGenericFieldType("MD5sum", line); 
     317                                        /* The old opkg wrote out status files with the wrong case for MD5sum, 
     318                                           let's parse it either way */ 
     319                                        else if(isGenericFieldType("MD5Sum:", line)) 
     320                                                pkg->md5sum = parseGenericFieldType("MD5Sum", line); 
     321                                        else if(isGenericFieldType("Maintainer", line) && !no_desc) 
     322                                                pkg->maintainer = parseGenericFieldType("Maintainer", line); 
     323                                        break; 
     324 
     325                                case 'I': 
     326                                        if(isGenericFieldType("Installed-Size:", line)) 
     327                                                pkg->installed_size = parseGenericFieldType("Installed-Size", line); 
     328                                        else if(isGenericFieldType("Installed-Time:", line)) { 
     329                                                char *time_str = parseGenericFieldType("Installed-Time", line); 
     330                                                pkg->installed_time = strtoul(time_str, NULL, 0); 
     331                                                free (time_str); 
     332                                        }            
     333                                        break; 
     334 
     335                                case 'E': 
     336                                        if(isGenericFieldType("Essential:", line)) { 
     337                                                char *essential_value; 
     338                                                essential_value = parseGenericFieldType("Essential", line); 
     339                                                if (strcmp(essential_value, "yes") == 0) { 
     340                                                        pkg->essential = 1; 
     341                                                } 
     342                                                free(essential_value); 
     343                                        } 
     344                                        break; 
     345 
     346                                case 'V': 
     347                                        if(isGenericFieldType("Version", line)) 
     348                                                parseVersion(pkg, line); 
     349                                        break; 
     350 
     351                                case 'C': 
     352                                        if(isGenericFieldType("Conffiles", line)){ 
     353                                                parseConffiles(pkg, line); 
     354                                                reading_conffiles = 1; 
     355                                        } 
     356                                        else if(isGenericFieldType("Conflicts", line)) 
     357                                                pkg->conflicts_str = parseDependsString(line, &pkg->conflicts_count); 
     358                                        break; 
     359 
     360                                case 'D': 
     361                                        if(isGenericFieldType("Description", line)) { 
     362                                                if(!no_desc) 
     363                                                        pkg->description = parseGenericFieldType("Description", line); 
     364                                                reading_conffiles = 0; 
     365                                                reading_description = 1; 
     366                                        } 
     367                                        else if(isGenericFieldType("Depends", line)) 
     368                                                pkg->depends_str = parseDependsString(line, &pkg->depends_count); 
     369                                        break; 
     370 
     371                                case 'R': 
     372                                        if(isGenericFieldType("Recommends", line)) 
     373                                                pkg->recommends_str = parseDependsString(line, &pkg->recommends_count); 
     374                                        else if(isGenericFieldType("Replaces", line)) 
     375                                                pkg->replaces_str = parseDependsString(line, &pkg->replaces_count); 
     376                                        break; 
     377 
     378                                case ' ': 
     379                                        if(reading_description) { 
     380                                                /* we already know it's not blank, so the rest of description */ 
     381                                                if(!no_desc) 
     382                                                { 
     383                                                        pkg->description = realloc(pkg->description, 
     384                                                                strlen(pkg->description) + 1 + strlen(line) + 1); 
     385                                                        strcat(pkg->description, "\n"); 
     386                                                        strcat(pkg->description, (line)); 
     387                                                } 
     388                                        } 
     389                                        else if(reading_conffiles) 
     390                                                parseConffiles(pkg, line); 
     391                                        break; 
     392 
     393                                default: 
     394                                        if(line_is_blank(line)) 
     395                                                goto out; 
     396                        } 
     397                } 
     398                else 
     399                { 
     400                        /*opkg_message(conf, OPKG_ERROR, "Buffer exceeded while parsing line:\n[%s]\n", buf);*/ 
     401                        printf("Buffer exceeded while parsing line:\n[%s]\n", buf); 
     402                        rv = EINVAL; 
     403                        break; 
     404                } 
    367405        } 
    368     } 
    369 out:; 
    370      
    371     *raw = lines; 
    372 /* If the opk has not a Provides line, we insert our false line */  
    373     if ( pkg_false_provides==1) 
    374     { 
    375        pkg->provides_count = 1; 
    376        pkg->provides_str = calloc (1, sizeof (char*)); 
    377        pkg->provides_str[0] = strdup ("opkg_internal_use_only"); 
    378     } 
    379  
    380     if (pkg->name) { 
    381         return 0; 
    382     } else { 
    383         return EINVAL; 
    384     } 
     406 
     407        out: 
     408 
     409        if (bsz) 
     410                lseek(fd, -(off_t)bsz, SEEK_CUR); 
     411 
     412        if (!rv && pkg->name) 
     413                return 0; 
     414        else 
     415                return EINVAL; 
    385416} 
    386417 
    387 int pkg_valorize_other_field(pkg_t *pkg, char ***raw) 
     418int pkg_valorize_other_field(pkg_t *pkg, int fd) 
    388419{ 
    389     char ** lines; 
     420        char buf[4096]; 
     421        char line[4096]; 
     422        char *nl; 
     423        int bsz = 0; 
     424        int eof = 0; 
     425        int rv = EINVAL; 
     426 
     427        memset(buf, 0, sizeof(buf)); 
     428 
     429        while(!eof || (bsz > 0)) 
     430        { 
     431                if(!eof) 
     432                { 
     433                        rv = read(fd, &buf[bsz], sizeof(buf) - bsz - 1); 
     434 
     435                        if( rv == 0 ) 
     436                        { 
     437                                eof = 1; 
     438 
     439                                if( bsz == 0 ) 
     440                                { 
     441                                        rv = EINVAL; 
     442                                        break; 
     443                                } 
     444                        } 
     445                        else if( rv < 0 ) 
     446                        { 
     447                                rv = EINVAL; 
     448                                break; 
     449                        } 
     450                        else 
     451                        { 
     452                                bsz += rv; 
     453                                buf[bsz] = 0; 
     454                                rv = 0; 
     455                        } 
     456                } 
    390457 
    391     for (lines = *raw; *lines; lines++) { 
    392         if(isGenericFieldType("Essential:", *lines)) { 
    393             char *essential_value; 
    394             essential_value = parseGenericFieldType("Essential", *lines); 
    395             if (strcmp(essential_value, "yes") == 0) { 
    396                 pkg->essential = 1; 
    397             } 
    398             free(essential_value); 
     458                if( (nl = strchr(buf, '\n')) != NULL ) 
     459                { 
     460                        bsz -= (int)(nl - buf) + 1; 
     461 
     462                        memset(line, 0, sizeof(line)); 
     463                        memcpy(line, buf, (int)(nl - buf)); 
     464                        memmove(buf, &buf[(int)(nl - buf) + 1], bsz); 
     465 
     466                        if(isGenericFieldType("Essential:", line)) 
     467                        { 
     468                                char *essential_value; 
     469                                essential_value = parseGenericFieldType("Essential", line); 
     470                                if (strcmp(essential_value, "yes") == 0) { 
     471                                        pkg->essential = 1; 
     472                                } 
     473                                free(essential_value); 
     474                        } 
     475                } 
     476                else 
     477                { 
     478                        rv = EINVAL; 
     479                        break; 
     480                } 
    399481        } 
    400     } 
    401     *raw = lines; 
    402482 
    403     return 0; 
     483        if (bsz) 
     484                lseek(fd, -(off_t)bsz, SEEK_CUR); 
     485 
     486        if (!rv && pkg->name) 
     487                return 0; 
     488        else 
     489                return EINVAL; 
    404490} 
     491 
  • libopkg/pkg_parse.h

    a b  
    2525char ** parseDependsString(char * raw, int * depends_count); 
    2626int parseVersion(pkg_t *pkg, char *raw); 
    2727void parseConffiles(pkg_t * pkg, char * raw); 
    28 int pkg_parse_raw(pkg_t *pkg, char ***raw, pkg_src_t *src, pkg_dest_t *dest); 
    29 int pkg_valorize_other_field(pkg_t *pkg, char ***raw); 
     28int pkg_parse_fd(pkg_t *pkg, int fd, pkg_src_t *src, pkg_dest_t *dest, int no_desc); 
     29int pkg_valorize_other_field(pkg_t *pkg, int fd); 
    3030 
    3131#endif 
  • libopkg/opkg_utils.h

    a b  
    2626void free_error_list(); 
    2727 
    2828long unsigned int get_available_blocks(char * filesystem); 
    29 char **read_raw_pkgs_from_file(const char *file_name); 
    30 char **read_raw_pkgs_from_stream(FILE *fp); 
    3129char *trim_alloc(char * line); 
    3230int line_is_blank(const char *line); 
    3331 
  • libopkg/libopkg.c

    a b  
    8888        char *cmd_name; 
    8989        opkg_cmd_t *cmd; 
    9090        opkg_conf_t opkg_conf; 
     91        int no_desc = 1; 
    9192 
    9293        args_init (&args); 
    9394 
     
    122123             !strcmp(cmd_name,"status") ) 
    123124           args.noreadfeedsfile = 1; 
    124125 
     126        if( !strcmp(cmd_name,"list") || 
     127            !strcmp(cmd_name,"list-installed") || 
     128            !strcmp(cmd_name,"list_installed") || 
     129            !strcmp(cmd_name,"search") ) 
     130           no_desc = 0; 
     131 
    125132        opkg_cb_message = default_opkg_message_callback; 
    126133        opkg_cb_response = default_opkg_response_callback; 
    127134        opkg_cb_status = default_opkg_status_callback; 
    128135 
    129136 
    130         err = opkg_conf_init (&opkg_conf, &args); 
     137        err = opkg_conf_init (&opkg_conf, &args, no_desc); 
    131138        if (err) 
    132139        { 
    133140                opkg_print_error_list (&opkg_conf); 
  • libopkg/opkg.c

    a b  
    205205  } 
    206206 
    207207  opkg->conf = calloc (1, sizeof (opkg_conf_t)); 
    208   err = opkg_conf_init (opkg->conf, opkg->args); 
     208  err = opkg_conf_init (opkg->conf, opkg->args, 0); 
    209209  if (err) 
    210210  { 
    211211    free (opkg->conf); 
     
    286286 
    287287  /* throw away old opkg_conf and start again */ 
    288288  opkg_conf_deinit (opkg->conf); 
    289   opkg_conf_init (opkg->conf, opkg->args); 
     289  opkg_conf_init (opkg->conf, opkg->args, 0); 
    290290 
    291291  free (opkg->options); 
    292292  opkg_init_options_array (opkg->conf, &opkg->options); 
  • libopkg/opkg_conf.c

    a b  
    4444static int opkg_conf_set_default_dest(opkg_conf_t *conf, 
    4545                                      const char *default_dest_name); 
    4646static int set_and_load_pkg_src_list(opkg_conf_t *conf, 
    47                                      pkg_src_list_t *nv_pair_list); 
     47                                     pkg_src_list_t *nv_pair_list, int no_desc); 
    4848static int set_and_load_pkg_dest_list(opkg_conf_t *conf, 
    49                                       nv_pair_list_t *nv_pair_list, char * lists_dir); 
     49                                      nv_pair_list_t *nv_pair_list, char * lists_dir, int no_desc); 
    5050 
    5151int opkg_init_options_array(const opkg_conf_t *conf, opkg_option_t **options) 
    5252{ 
     
    106106     } 
    107107} 
    108108 
    109 int opkg_conf_init(opkg_conf_t *conf, const args_t *args) 
     109int opkg_conf_init(opkg_conf_t *conf, const args_t *args, int no_desc) 
    110110{ 
    111111     int err; 
    112112     char *tmp_dir_base; 
     
    294294     if ( !(args->nocheckfordirorfile)){ 
    295295        /* need to run load the source list before dest list -Jamey */ 
    296296        if ( !(args->noreadfeedsfile)) 
    297            set_and_load_pkg_src_list(conf, &conf->pkg_src_list); 
     297           set_and_load_pkg_src_list(conf, &conf->pkg_src_list, no_desc); 
    298298    
    299299        /* Now that we have resolved conf->offline_root, we can commit to 
    300300           the directory names for the dests and load in all the package 
    301301           lists. */ 
    302         set_and_load_pkg_dest_list(conf, &tmp_dest_nv_pair_list,lists_dir); 
     302        set_and_load_pkg_dest_list(conf, &tmp_dest_nv_pair_list,lists_dir, no_desc); 
    303303    
    304304        if (args->dest) { 
    305305             err = opkg_conf_set_default_dest(conf, args->dest); 
     
    409409     return 1; 
    410410} 
    411411 
    412 static int set_and_load_pkg_src_list(opkg_conf_t *conf, pkg_src_list_t *pkg_src_list) 
     412static int set_and_load_pkg_src_list(opkg_conf_t *conf, pkg_src_list_t *pkg_src_list, int no_desc) 
    413413{ 
    414414     pkg_src_list_elt_t *iter; 
    415415     pkg_src_t *src; 
     
    426426                          src->name); 
    427427 
    428428          if (file_exists(list_file)) { 
    429                pkg_hash_add_from_file(conf, list_file, src, NULL, 0); 
     429               pkg_hash_add_from_file(conf, list_file, src, NULL, 0, no_desc); 
    430430          } 
    431431          free(list_file); 
    432432     } 
     
    434434     return 0; 
    435435} 
    436436 
    437 static int set_and_load_pkg_dest_list(opkg_conf_t *conf, nv_pair_list_t *nv_pair_list, char *lists_dir ) 
     437static int set_and_load_pkg_dest_list(opkg_conf_t *conf, nv_pair_list_t *nv_pair_list, char *lists_dir, int no_desc) 
    438438{ 
    439439     nv_pair_list_elt_t *iter; 
    440440     nv_pair_t *nv_pair; 
     
    459459          } 
    460460          if (file_exists(dest->status_file_name)) { 
    461461               pkg_hash_add_from_file(conf, dest->status_file_name, 
    462                                       NULL, dest, 1); 
     462                                      NULL, dest, 1, no_desc); 
    463463          } 
    464464     } 
    465465 
  • libopkg/opkg_conf.h

    a b  
    102102     const void *value; 
    103103}; 
    104104 
    105 int opkg_conf_init(opkg_conf_t *conf, const args_t *args); 
     105int opkg_conf_init(opkg_conf_t *conf, const args_t *args, int no_desc); 
    106106void opkg_conf_deinit(opkg_conf_t *conf); 
    107107 
    108108int opkg_conf_write_status_files(opkg_conf_t *conf); 
  • tests/opkg_hash_test.c

    a b  
    3333    } 
    3434    pkg_hash_init("test", hash, 1024); 
    3535 
    36     pkg_hash_add_from_file(&conf, argv[1], NULL, NULL, 0); 
    37     pkg_hash_add_from_file(&conf, argv[2], NULL, NULL, 0); 
     36    pkg_hash_add_from_file(&conf, argv[1], NULL, NULL, 0, 0); 
     37    pkg_hash_add_from_file(&conf, argv[2], NULL, NULL, 0, 0); 
    3838 
    3939    if (argc < 4) { 
    4040        pkg_print_info( pkg_hash_fetch_by_name_version(hash, "libc6", "2.2.3-2"), stdout); 
  • libopkg/pkg_hash.h

    a b  
    3333void pkg_hash_fetch_available(hash_table_t *hash, pkg_vec_t *available); 
    3434 
    3535int pkg_hash_add_from_file(opkg_conf_t *conf, const char *file_name, 
    36                            pkg_src_t *src, pkg_dest_t *dest, int is_status_file); 
     36                           pkg_src_t *src, pkg_dest_t *dest, int is_status_file, int no_desc); 
    3737pkg_t *hash_insert_pkg(hash_table_t *hash, pkg_t *pkg, int set_status,opkg_conf_t *conf); 
    3838 
    3939abstract_pkg_t * ensure_abstract_pkg_by_name(hash_table_t * hash, const char * pkg_name); 
Note: See TracBrowser for help on using the repository browser.