libopkg/pkg_parse.c

   1 /* pkg_parse.c - the itsy package management system
   2
   3    Steven M. Ayer
   4
   5    Copyright (C) 2002 Compaq Computer Corporation
   6
   7    This program is free software; you can redistribute it and/or
   8    modify it under the terms of the GNU General Public License as
   9    published by the Free Software Foundation; either version 2, or (at
  10    your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful, but
  13    WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15    General Public License for more details.
  16 */
  17
  18 #include "includes.h"
  19 #include <errno.h>
  20 #include <ctype.h>
  21
  22 #include "pkg.h"
  23 #include "opkg_utils.h"
  24 #include "pkg_parse.h"
  25
  26 int isGenericFieldType(char * type, char * line)
  27 {
  28     if(!strncmp(line, type, strlen(type)))
  29         return 1;
  30     return 0;
  31 }
  32
  33 char * parseGenericFieldType(char * type, char * raw)
  34 {
  35     char * field_value = raw + (strlen(type) + 1);
  36     return trim_alloc(field_value);
  37 }
  38
  39 void parseStatus(pkg_t *pkg, char * raw)
  40 {
  41     char sw_str[64], sf_str[64], ss_str[64];
  42
  43     sscanf(raw, "Status: %s %s %s", sw_str, sf_str, ss_str);
  44     pkg->state_want = pkg_state_want_from_str(sw_str);
  45     pkg->state_flag = pkg_state_flag_from_str(sf_str);
  46     pkg->state_status = pkg_state_status_from_str(ss_str);
  47 }
  48
  49 char ** parseDependsString(char * raw, int * depends_count)
  50 {
  51     char ** depends = NULL;
  52     int line_count = 0;
  53     char buff[2048], * dest;
  54
  55     while(raw && *raw && !isspace(*raw)) {
  56         raw++;
  57     }
  58
  59     if(line_is_blank(raw)){
  60         *depends_count = line_count;
  61         return NULL;
  62     }
  63     while(raw && *raw){
  64         depends = (char **)realloc(depends, sizeof(char *) * (line_count + 1));
  65
  66         while(isspace(*raw)) raw++;
  67
  68         dest = buff;
  69         while((*raw != ',') && *raw)
  70             *dest++ = *raw++;
  71
  72         *dest = '\0';
  73         depends[line_count] = trim_alloc(buff);
  74         if(depends[line_count] ==NULL)
  75            return NULL;
  76         line_count++;
  77         if(*raw == ',')
  78             raw++;
  79     }
  80     *depends_count = line_count;
  81     return depends;
  82 }
  83
  84 void parseConffiles(pkg_t * pkg, char * raw)
  85 {
  86     char file_name[1048], md5sum[1048];  /* please tell me there aren't any longer that 1k */
  87
  88     if(!strncmp(raw, "Conffiles:", 10))
  89         raw += strlen("Conffiles:");
  90
  91     while(*raw && (sscanf(raw, "%s%s", file_name, md5sum) == 2)){
  92         conffile_list_append(&pkg->conffiles, file_name, md5sum);
  93         /*      fprintf(stderr, "%s %s ", file_name, md5sum);*/
  94         while (*raw && isspace(*raw)) {
  95             raw++;
  96         }
  97         raw += strlen(file_name);
  98         while (*raw && isspace(*raw)) {
  99             raw++;
 100         }
 101         raw += strlen(md5sum);
 102     }
 103 }
 104
 105 int parseVersion(pkg_t *pkg, char *raw)
 106 {
 107   char *colon, *eepochcolon;
 108   char *hyphen;
 109   unsigned long epoch;
 110
 111   if (!*raw) {
 112       fprintf(stderr, "%s: ERROR: version string is empty", __FUNCTION__);
 113       return EINVAL;
 114   }
 115
 116   if (strncmp(raw, "Version:", 8) == 0) {
 117       raw += 8;
 118   }
 119   while (*raw && isspace(*raw)) {
 120       raw++;
 121   }
 122
 123   colon= strchr(raw,':');
 124   if (colon) {
 125     epoch= strtoul(raw,&eepochcolon,10);
 126     if (colon != eepochcolon) {
 127         fprintf(stderr, "%s: ERROR: epoch in version is not number", __FUNCTION__);
 128         return EINVAL;
 129     }
 130     if (!*++colon) {
 131         fprintf(stderr, "%s: ERROR: nothing after colon in version number", __FUNCTION__);
 132         return EINVAL;
 133     }
 134     raw= colon;
 135     pkg->epoch= epoch;
 136   } else {
 137     pkg->epoch= 0;
 138   }
 139
 140   pkg->revision = "";
 141   pkg->familiar_revision = "";
 142
 143   pkg->version= malloc(strlen(raw)+1);
 144   if ( pkg->version == NULL ) {
 145      fprintf(stderr, "%s: out of memory \n", __FUNCTION__);
 146      return ENOMEM;
 147   }
 148   strcpy(pkg->version, raw);
 149
 150   hyphen= strrchr(pkg->version,'-');
 151
 152   if (hyphen) {
 153     *hyphen++= 0;
 154       pkg->revision = hyphen;
 155   }
 156
 157 /*
 158   fprintf(stderr,"Parsed version: %lu, %s, %s, %s\n",
 159           pkg->epoch,
 160           pkg->version,
 161           pkg->revision,
 162           pkg->familiar_revision);
 163 */
 164
 165   return 0;
 166 }
 167
 168
 169 /* This code is needed to insert in first position the keyword for the aligning bug */
 170
 171 int alterProvidesLine(char *raw, char *temp)
 172 {
 173
 174
 175   if (!*raw) {
 176       fprintf(stderr, "%s: ERROR: Provides string is empty", __FUNCTION__);
 177       return -EINVAL;
 178   }
 179
 180   if ( temp == NULL ) {
 181      fprintf(stderr, "%s: out of memory \n", __FUNCTION__);
 182      return -ENOMEM;
 183   }
 184
 185   if (strncmp(raw, "Provides:", 9) == 0) {
 186       raw += 9;
 187   }
 188   while (*raw && isspace(*raw)) {
 189       raw++;
 190   }
 191
 192   snprintf ( temp, 35, "Provides: opkg_internal_use_only, ");           /* First part of the line */
 193   while (*raw) {
 194      strncat( temp, raw++, 1);
 195   }
 196   return 0;
 197
 198 }
 199
 200 /* Some random thoughts from Carl:
 201
 202    This function could be considerably simplified if we just kept
 203    an array of all the generic string-valued field names, and looped
 204    through those looking for a match. Also, these fields could perhaps
 205    be stored in the package as an array as well, (or, probably better,
 206    as an nv_pair_list_t).
 207
 208    Fields which require special parsing or storage, (such as Depends:
 209    and Status:) could be handled as they are now.
 210 */
 211 /* XXX: FEATURE: The Suggests: field needs to be changed from a string
 212    to a dependency list. And, since we already have
 213    Depends/Pre-Depends and need to add Conflicts, Recommends, and
 214    Enhances, perhaps we could generalize all of these and save some
 215    code duplication.
 216 */
 217 int pkg_parse_raw(pkg_t *pkg, char ***raw, pkg_src_t *src, pkg_dest_t *dest)
 218 {
 219     int reading_conffiles, reading_description;
 220     int pkg_false_provides=1;
 221     char ** lines;
 222     char * provide=NULL;
 223
 224     pkg->src = src;
 225     pkg->dest = dest;
 226
 227     reading_conffiles = reading_description = 0;
 228
 229     for (lines = *raw; *lines; lines++) {
 230         /*      fprintf(stderr, "PARSING %s\n", *lines);*/
 231         switch (**lines) {
 232         case 'P':
 233             if(isGenericFieldType("Package:", *lines))
 234                 pkg->name = parseGenericFieldType("Package", *lines);
 235             else if(isGenericFieldType("Priority:", *lines))
 236                 pkg->priority = parseGenericFieldType("Priority", *lines);
 237             else if(isGenericFieldType("Provides", *lines)){
 238 /* Here we add the internal_use to align the off by one problem between provides_str and provides */
 239                 provide = (char * ) malloc(strlen(*lines)+ 35 ); /* Preparing the space for the new opkg_internal_use_only */
 240                 if ( alterProvidesLine(*lines,provide) ){
 241                     return EINVAL;
 242                 }
 243                 pkg->provides_str = parseDependsString( provide, &pkg->provides_count);
 244 /* Let's try to hack a bit here.
 245    The idea is that if a package has no Provides, we would add one generic, to permit the check of dependencies
 246    in alot of other places. We will remove it before writing down the status database */
 247                 pkg_false_provides=0;
 248                 free(provide);
 249             }
 250             else if(isGenericFieldType("Pre-Depends", *lines))
 251                 pkg->pre_depends_str = parseDependsString(*lines, &pkg->pre_depends_count);
 252             break;
 253
 254         case 'A':
 255             if(isGenericFieldType("Architecture:", *lines))
 256                 pkg->architecture = parseGenericFieldType("Architecture", *lines);
 257             else if(isGenericFieldType("Auto-Installed:", *lines)) {
 258                 char *auto_installed_value;
 259                 auto_installed_value = parseGenericFieldType("Auto-Installed:", *lines);
 260                 if (strcmp(auto_installed_value, "yes") == 0) {
 261                     pkg->auto_installed = 1;
 262                 }
 263                 free(auto_installed_value);
 264             }
 265             break;
 266
 267         case 'F':
 268             if(isGenericFieldType("Filename:", *lines))
 269                 pkg->filename = parseGenericFieldType("Filename", *lines);
 270             break;
 271
 272         case 'S':
 273             if(isGenericFieldType("Section:", *lines))
 274                 pkg->section = parseGenericFieldType("Section", *lines);
 275             else if(isGenericFieldType("Size:", *lines))
 276                 pkg->size = parseGenericFieldType("Size", *lines);
 277             else if(isGenericFieldType("Source:", *lines))
 278                 pkg->source = parseGenericFieldType("Source", *lines);
 279             else if(isGenericFieldType("Status", *lines))
 280                 parseStatus(pkg, *lines);
 281             else if(isGenericFieldType("Suggests", *lines))
 282                 pkg->suggests_str = parseDependsString(*lines, &pkg->suggests_count);
 283             break;
 284
 285         case 'T':
 286             if(isGenericFieldType("Tags:", *lines))
 287                 pkg->tags = parseGenericFieldType("Tags", *lines);
 288             break;
 289
 290         case 'M':
 291             if(isGenericFieldType("MD5sum:", *lines))
 292                 pkg->md5sum = parseGenericFieldType("MD5sum", *lines);
 293             /* The old opkg wrote out status files with the wrong case for MD5sum,
 294                 let's parse it either way */
 295             else if(isGenericFieldType("MD5Sum:", *lines))
 296                 pkg->md5sum = parseGenericFieldType("MD5Sum", *lines);
 297             else if(isGenericFieldType("Maintainer", *lines))
 298                 pkg->maintainer = parseGenericFieldType("Maintainer", *lines);
 299             break;
 300
 301         case 'I':
 302             if(isGenericFieldType("Installed-Size:", *lines))
 303                 pkg->installed_size = parseGenericFieldType("Installed-Size", *lines);
 304             else if(isGenericFieldType("Installed-Time:", *lines)) {
 305                 char *time_str = parseGenericFieldType("Installed-Time", *lines);
 306                 pkg->installed_time = strtoul(time_str, NULL, 0);
 307             }
 308             break;
 309
 310         case 'E':
 311             if(isGenericFieldType("Essential:", *lines)) {
 312                 char *essential_value;
 313                 essential_value = parseGenericFieldType("Essential", *lines);
 314                 if (strcmp(essential_value, "yes") == 0) {
 315                     pkg->essential = 1;
 316                 }
 317                 free(essential_value);
 318             }
 319             break;
 320
 321         case 'V':
 322             if(isGenericFieldType("Version", *lines))
 323                 parseVersion(pkg, *lines);
 324             break;
 325
 326         case 'C':
 327             if(isGenericFieldType("Conffiles", *lines)){
 328                 parseConffiles(pkg, *lines);
 329                 reading_conffiles = 1;
 330             }
 331             else if(isGenericFieldType("Conflicts", *lines))
 332                 pkg->conflicts_str = parseDependsString(*lines, &pkg->conflicts_count);
 333             break;
 334
 335         case 'D':
 336             if(isGenericFieldType("Description", *lines)) {
 337                 pkg->description = parseGenericFieldType("Description", *lines);
 338                 reading_conffiles = 0;
 339                 reading_description = 1;
 340             }
 341             else if(isGenericFieldType("Depends", *lines))
 342                 pkg->depends_str = parseDependsString(*lines, &pkg->depends_count);
 343             break;
 344
 345         case 'R':
 346             if(isGenericFieldType("Recommends", *lines))
 347                 pkg->recommends_str = parseDependsString(*lines, &pkg->recommends_count);
 348             else if(isGenericFieldType("Replaces", *lines))
 349                 pkg->replaces_str = parseDependsString(*lines, &pkg->replaces_count);
 350
 351             break;
 352
 353         case ' ':
 354             if(reading_description) {
 355                 /* we already know it's not blank, so the rest of description */
 356                 pkg->description = realloc(pkg->description,
 357                                            strlen(pkg->description)
 358                                            + 1 + strlen(*lines) + 1);
 359                 strcat(pkg->description, "\n");
 360                 strcat(pkg->description, (*lines));
 361             }
 362             else if(reading_conffiles)
 363                 parseConffiles(pkg, *lines);
 364
 365             break;
 366
 367         default:
 368             if(line_is_blank(*lines)) {
 369                 lines++;
 370                 goto out;
 371             }
 372         }
 373     }
 374 out:;
 375
 376     *raw = lines;
 377 /* If the ipk has not a Provides line, we insert our false line */
 378     if ( pkg_false_provides==1)
 379        pkg->provides_str = parseDependsString ((char *)"Provides: opkg_internal_use_only ", &pkg->provides_count);
 380
 381     if (pkg->name) {
 382         return 0;
 383     } else {
 384         return EINVAL;
 385     }
 386 }
 387
 388 int pkg_valorize_other_field(pkg_t *pkg, char ***raw)
 389 {
 390     char ** lines;
 391
 392     for (lines = *raw; *lines; lines++) {
 393         if(isGenericFieldType("Essential:", *lines)) {
 394             char *essential_value;
 395             essential_value = parseGenericFieldType("Essential", *lines);
 396             if (strcmp(essential_value, "yes") == 0) {
 397                 pkg->essential = 1;
 398             }
 399             free(essential_value);
 400         }
 401     }
 402     *raw = lines;
 403
 404     return 0;
 405 }