ext/repo_rpmmd.c

   1 /*
   2  * Copyright (c) 2007, Novell Inc.
   3  *
   4  * This program is licensed under the BSD license, read LICENSE.BSD
   5  * for further information
   6  */
   7
   8 #include <sys/types.h>
   9 #include <stdio.h>
  10 #include <stdlib.h>
  11 #include <string.h>
  12
  13 #include "pool.h"
  14 #include "repo.h"
  15 #define DISABLE_SPLIT
  16 #include "tools_util.h"
  17 #include "repo_rpmmd.h"
  18 #include "chksum.h"
  19 #include "solv_xmlparser.h"
  20 #ifdef ENABLE_COMPLEX_DEPS
  21 #include "pool_parserpmrichdep.h"
  22 #endif
  23 #include "repodata_diskusage.h"
  24
  25 enum state {
  26   STATE_START,
  27
  28   STATE_SOLVABLE,
  29
  30   STATE_NAME,
  31   STATE_ARCH,
  32   STATE_VERSION,
  33
  34   /* package rpm-md */
  35   STATE_LOCATION,
  36   STATE_CHECKSUM,
  37   STATE_RPM_GROUP,
  38   STATE_RPM_LICENSE,
  39
  40   /* resobject attributes */
  41   STATE_SUMMARY,
  42   STATE_DESCRIPTION,
  43   STATE_DISTRIBUTION,
  44   STATE_PACKAGER,
  45   STATE_URL,
  46   STATE_INSNOTIFY,
  47   STATE_DELNOTIFY,
  48   STATE_VENDOR,
  49   STATE_SIZE,
  50   STATE_TIME,
  51   STATE_DOWNLOADSIZE,
  52   STATE_INSTALLTIME,
  53   STATE_INSTALLONLY,
  54
  55   /* Novell/SUSE extended attributes */
  56   STATE_EULA,
  57   STATE_KEYWORD,
  58   STATE_DISKUSAGE,
  59   STATE_DIRS,
  60   STATE_DIR,
  61
  62   /* patch */
  63   STATE_ID,
  64   STATE_TIMESTAMP,
  65   STATE_AFFECTSPKG,
  66   STATE_REBOOTNEEDED,
  67
  68   /* pattern attributes */
  69   STATE_CATEGORY, /* pattern and patches */
  70   STATE_ORDER,
  71   STATE_INCLUDES,
  72   STATE_INCLUDESENTRY,
  73   STATE_EXTENDS,
  74   STATE_EXTENDSENTRY,
  75   STATE_SCRIPT,
  76   STATE_ICON,
  77   STATE_USERVISIBLE,
  78   STATE_DEFAULT,
  79   STATE_INSTALL_TIME,
  80
  81   /* product */
  82   STATE_RELNOTESURL,
  83   STATE_UPDATEURL,
  84   STATE_OPTIONALURL,
  85   STATE_FLAG,
  86
  87   /* rpm-md dependencies inside the format tag */
  88   STATE_PROVIDES,
  89   STATE_REQUIRES,
  90   STATE_OBSOLETES,
  91   STATE_CONFLICTS,
  92   STATE_RECOMMENDS,
  93   STATE_SUPPLEMENTS,
  94   STATE_SUGGESTS,
  95   STATE_ENHANCES,
  96   STATE_FRESHENS,
  97   STATE_SOURCERPM,
  98   STATE_HEADERRANGE,
  99   STATE_BUILDHOST,
 100
 101   STATE_PROVIDESENTRY,
 102   STATE_REQUIRESENTRY,
 103   STATE_OBSOLETESENTRY,
 104   STATE_CONFLICTSENTRY,
 105   STATE_RECOMMENDSENTRY,
 106   STATE_SUPPLEMENTSENTRY,
 107   STATE_SUGGESTSENTRY,
 108   STATE_ENHANCESENTRY,
 109   STATE_FRESHENSENTRY,
 110
 111   STATE_FILE,
 112
 113   STATE_CHANGELOG,
 114
 115   /* general */
 116   NUMSTATES
 117 };
 118
 119 static struct solv_xmlparser_element stateswitches[] = {
 120   /** fake tag used to enclose multiple xml files in one **/
 121   { STATE_START,       "rpmmd",           STATE_START,    0 },
 122
 123   /** tags for different package data, just ignore them **/
 124   { STATE_START,       "patterns",        STATE_START,    0 },
 125   { STATE_START,       "products",        STATE_START,    0 },
 126   { STATE_START,       "metadata",        STATE_START,    0 },
 127   { STATE_START,       "otherdata",       STATE_START,    0 },
 128   { STATE_START,       "filelists",       STATE_START,    0 },
 129   { STATE_START,       "diskusagedata",   STATE_START,    0 },
 130   { STATE_START,       "susedata",        STATE_START,    0 },
 131
 132   { STATE_START,       "product",         STATE_SOLVABLE, 0 },
 133   { STATE_START,       "pattern",         STATE_SOLVABLE, 0 },
 134   { STATE_START,       "patch",           STATE_SOLVABLE, 0 },
 135   { STATE_START,       "package",         STATE_SOLVABLE, 0 },
 136
 137   { STATE_SOLVABLE,    "format",          STATE_SOLVABLE, 0 },
 138
 139   { STATE_SOLVABLE,    "name",            STATE_NAME, 1 },
 140   { STATE_SOLVABLE,    "arch",            STATE_ARCH, 1 },
 141   { STATE_SOLVABLE,    "version",         STATE_VERSION, 0 },
 142
 143   /* package attributes rpm-md */
 144   { STATE_SOLVABLE,    "location",        STATE_LOCATION, 0 },
 145   { STATE_SOLVABLE,    "checksum",        STATE_CHECKSUM, 1 },
 146
 147   /* resobject attributes */
 148
 149   { STATE_SOLVABLE,    "summary",         STATE_SUMMARY,      1 },
 150   { STATE_SOLVABLE,    "description",     STATE_DESCRIPTION,  1 },
 151   { STATE_SOLVABLE,    "distribution",    STATE_DISTRIBUTION, 1 },
 152   { STATE_SOLVABLE,    "url",             STATE_URL,          1 },
 153   { STATE_SOLVABLE,    "packager",        STATE_PACKAGER,     1 },
 154   { STATE_SOLVABLE,    "vendor",          STATE_VENDOR,       1 },
 155   { STATE_SOLVABLE,    "size",            STATE_SIZE,         0 },
 156   { STATE_SOLVABLE,    "archive-size",    STATE_DOWNLOADSIZE, 1 },
 157   { STATE_SOLVABLE,    "install-time",    STATE_INSTALLTIME,  1 },
 158   { STATE_SOLVABLE,    "install-only",    STATE_INSTALLONLY,  1 },
 159   { STATE_SOLVABLE,    "time",            STATE_TIME,         0 },
 160
 161   /* extended Novell/SUSE attributes (susedata.xml) */
 162   { STATE_SOLVABLE,    "eula",            STATE_EULA,         1 },
 163   { STATE_SOLVABLE,    "keyword",         STATE_KEYWORD,      1 },
 164   { STATE_SOLVABLE,    "diskusage",       STATE_DISKUSAGE,    0 },
 165
 166   /* pattern attribute */
 167   { STATE_SOLVABLE,    "script",          STATE_SCRIPT,        1 },
 168   { STATE_SOLVABLE,    "icon",            STATE_ICON,          1 },
 169   { STATE_SOLVABLE,    "uservisible",     STATE_USERVISIBLE,   1 },
 170   { STATE_SOLVABLE,    "category",        STATE_CATEGORY,      1 },
 171   { STATE_SOLVABLE,    "order",           STATE_ORDER,         1 },
 172   { STATE_SOLVABLE,    "includes",        STATE_INCLUDES,      0 },
 173   { STATE_SOLVABLE,    "extends",         STATE_EXTENDS,       0 },
 174   { STATE_SOLVABLE,    "default",         STATE_DEFAULT,       1 },
 175   { STATE_SOLVABLE,    "install-time",    STATE_INSTALL_TIME,  1 },
 176
 177   /* product attributes */
 178   /* note the product type is an attribute */
 179   { STATE_SOLVABLE,    "release-notes-url", STATE_RELNOTESURL, 1 },
 180   { STATE_SOLVABLE,    "update-url",      STATE_UPDATEURL,   1 },
 181   { STATE_SOLVABLE,    "optional-url",    STATE_OPTIONALURL, 1 },
 182   { STATE_SOLVABLE,    "flag",            STATE_FLAG,        1 },
 183
 184   { STATE_SOLVABLE,    "rpm:vendor",      STATE_VENDOR,      1 },
 185   { STATE_SOLVABLE,    "rpm:group",       STATE_RPM_GROUP,   1 },
 186   { STATE_SOLVABLE,    "rpm:license",     STATE_RPM_LICENSE, 1 },
 187
 188   /* rpm-md dependencies */
 189   { STATE_SOLVABLE,    "rpm:provides",    STATE_PROVIDES,     0 },
 190   { STATE_SOLVABLE,    "rpm:requires",    STATE_REQUIRES,     0 },
 191   { STATE_SOLVABLE,    "rpm:obsoletes",   STATE_OBSOLETES,    0 },
 192   { STATE_SOLVABLE,    "rpm:conflicts",   STATE_CONFLICTS,    0 },
 193   { STATE_SOLVABLE,    "rpm:recommends",  STATE_RECOMMENDS ,  0 },
 194   { STATE_SOLVABLE,    "rpm:supplements", STATE_SUPPLEMENTS,  0 },
 195   { STATE_SOLVABLE,    "rpm:suggests",    STATE_SUGGESTS,     0 },
 196   { STATE_SOLVABLE,    "rpm:enhances",    STATE_ENHANCES,     0 },
 197   { STATE_SOLVABLE,    "rpm:freshens",    STATE_FRESHENS,     0 },
 198   { STATE_SOLVABLE,    "rpm:sourcerpm",   STATE_SOURCERPM,    1 },
 199   { STATE_SOLVABLE,    "rpm:header-range", STATE_HEADERRANGE, 0 },
 200   { STATE_SOLVABLE,    "rpm:buildhost",   STATE_BUILDHOST,    1 },
 201   { STATE_SOLVABLE,    "file",            STATE_FILE, 1 },
 202   { STATE_SOLVABLE,    "changelog",       STATE_CHANGELOG, 1 },
 203
 204    /* extended Novell/SUSE diskusage attributes (susedata.xml) */
 205   { STATE_DISKUSAGE,   "dirs",            STATE_DIRS,         0 },
 206   { STATE_DIRS,        "dir",             STATE_DIR,          0 },
 207
 208   { STATE_PROVIDES,    "rpm:entry",       STATE_PROVIDESENTRY, 0 },
 209   { STATE_REQUIRES,    "rpm:entry",       STATE_REQUIRESENTRY, 0 },
 210   { STATE_OBSOLETES,   "rpm:entry",       STATE_OBSOLETESENTRY, 0 },
 211   { STATE_CONFLICTS,   "rpm:entry",       STATE_CONFLICTSENTRY, 0 },
 212   { STATE_RECOMMENDS,  "rpm:entry",       STATE_RECOMMENDSENTRY, 0 },
 213   { STATE_SUPPLEMENTS, "rpm:entry",       STATE_SUPPLEMENTSENTRY, 0 },
 214   { STATE_SUGGESTS,    "rpm:entry",       STATE_SUGGESTSENTRY, 0 },
 215   { STATE_ENHANCES,    "rpm:entry",       STATE_ENHANCESENTRY, 0 },
 216   { STATE_FRESHENS,    "rpm:entry",       STATE_FRESHENSENTRY, 0 },
 217
 218   { STATE_INCLUDES,    "item",            STATE_INCLUDESENTRY, 0 },
 219   { STATE_EXTENDS,     "item",            STATE_EXTENDSENTRY,  0 },
 220
 221   { NUMSTATES}
 222 };
 223
 224 struct parsedata {
 225   int ret;
 226   Pool *pool;
 227   Repo *repo;
 228   Repodata *data;
 229   char *kind;
 230   Solvable *solvable;
 231   Offset freshens;
 232
 233   struct solv_xmlparser xmlp;
 234   struct joindata jd;
 235   /* temporal to store attribute tag language */
 236   const char *tmplang;
 237   Id chksumtype;
 238   Id handle;
 239   Queue diskusageq;
 240   const char *language;                 /* default language */
 241   Id langcache[ID_NUM_INTERNAL];        /* cache for the default language */
 242
 243   Id lastdir;
 244   char *lastdirstr;
 245   int lastdirstrl;
 246
 247   Id changelog_handle;
 248
 249   int extending;                        /* are we extending an existing solvable? */
 250   int first;                            /* first solvable we added */
 251   int cshash_filled;                    /* hash is filled with data */
 252
 253   Hashtable cshash;                     /* checksum hash -> offset into csdata */
 254   Hashval cshashm;                      /* hash mask */
 255   int ncshash;                          /* entries used */
 256   unsigned char *csdata;                /* [len, checksum, id] */
 257   int ncsdata;                          /* used bytes */
 258 };
 259
 260 static Id
 261 langtag(struct parsedata *pd, Id tag, const char *language)
 262 {
 263   if (language)
 264     {
 265       if (!language[0] || !strcmp(language, "en"))
 266         return tag;
 267       return pool_id2langid(pd->pool, tag, language, 1);
 268     }
 269   if (!pd->language)
 270     return tag;
 271   if (tag >= ID_NUM_INTERNAL)
 272     return pool_id2langid(pd->pool, tag, pd->language, 1);
 273   if (!pd->langcache[tag])
 274     pd->langcache[tag] = pool_id2langid(pd->pool, tag, pd->language, 1);
 275   return pd->langcache[tag];
 276 }
 277
 278 /*
 279  * makeevr_atts
 280  * parse 'epoch', 'ver' and 'rel', return evr Id
 281  *
 282  */
 283
 284 static Id
 285 makeevr_atts(Pool *pool, struct parsedata *pd, const char **atts)
 286 {
 287   const char *e, *v, *r, *v2;
 288   char *c, *space;
 289   int l;
 290
 291   e = v = r = 0;
 292   for (; *atts; atts += 2)
 293     {
 294       if (!strcmp(*atts, "epoch"))
 295         e = atts[1];
 296       else if (!strcmp(*atts, "ver"))
 297         v = atts[1];
 298       else if (!strcmp(*atts, "rel"))
 299         r = atts[1];
 300     }
 301   if (e && (!*e || !strcmp(e, "0")))
 302     e = 0;
 303   if (v && !e)
 304     {
 305       for (v2 = v; *v2 >= '0' && *v2 <= '9'; v2++)
 306         ;
 307       if (v2 > v && *v2 == ':')
 308         e = "0";
 309     }
 310   l = 1;
 311   if (e)
 312     l += strlen(e) + 1;
 313   if (v)
 314     l += strlen(v);
 315   if (r)
 316     l += strlen(r) + 1;
 317   c = space = solv_xmlparser_contentspace(&pd->xmlp, l);
 318   if (e)
 319     {
 320       strcpy(c, e);
 321       c += strlen(c);
 322       *c++ = ':';
 323     }
 324   if (v)
 325     {
 326       strcpy(c, v);
 327       c += strlen(c);
 328     }
 329   if (r)
 330     {
 331       *c++ = '-';
 332       strcpy(c, r);
 333       c += strlen(c);
 334     }
 335   *c = 0;
 336   if (!*space)
 337     return 0;
 338 #if 0
 339   fprintf(stderr, "evr: %s\n", space);
 340 #endif
 341   return pool_str2id(pool, space, 1);
 342 }
 343
 344
 345 /*
 346  * dependency relations
 347  */
 348
 349 static char *flagtab[] = {
 350   "GT",
 351   "EQ",
 352   "GE",
 353   "LT",
 354   "NE",
 355   "LE"
 356 };
 357
 358
 359 /*
 360  * adddep
 361  * parse attributes to reldep Id
 362  *
 363  */
 364
 365 static unsigned int
 366 adddep(Pool *pool, struct parsedata *pd, unsigned int olddeps, const char **atts, int isreq)
 367 {
 368   Id id, marker;
 369   const char *n, *f, *k;
 370   const char **a;
 371
 372   n = f = k = 0;
 373   marker = isreq ? -SOLVABLE_PREREQMARKER : 0;
 374   for (a = atts; *a; a += 2)
 375     {
 376       if (!strcmp(*a, "name"))
 377         n = a[1];
 378       else if (!strcmp(*a, "flags"))
 379         f = a[1];
 380       else if (!strcmp(*a, "kind"))
 381         k = a[1];
 382       else if (isreq && !strcmp(*a, "pre") && a[1][0] == '1')
 383         marker = SOLVABLE_PREREQMARKER;
 384     }
 385   if (!n)
 386     return olddeps;
 387   if (k && !strcmp(k, "package"))
 388     k = 0;
 389   if (k)
 390     {
 391       int l = strlen(k) + 1 + strlen(n) + 1;
 392       char *space = solv_xmlparser_contentspace(&pd->xmlp, l);
 393       sprintf(space, "%s:%s", k, n);
 394       id = pool_str2id(pool, space, 1);
 395     }
 396 #ifdef ENABLE_COMPLEX_DEPS
 397   else if (!f && n[0] == '(')
 398     {
 399       id = pool_parserpmrichdep(pool, n);
 400       if (!id)
 401         return olddeps;
 402     }
 403 #endif
 404   else
 405     id = pool_str2id(pool, (char *)n, 1);
 406   if (f)
 407     {
 408       Id evr = makeevr_atts(pool, pd, atts);
 409       int flags;
 410       for (flags = 0; flags < 6; flags++)
 411         if (!strcmp(f, flagtab[flags]))
 412           break;
 413       flags = flags < 6 ? flags + 1 : 0;
 414       id = pool_rel2id(pool, id, evr, flags, 1);
 415     }
 416 #if 0
 417   fprintf(stderr, "new dep %s\n", pool_dep2str(pool, id));
 418 #endif
 419   return repo_addid_dep(pd->repo, olddeps, id, marker);
 420 }
 421
 422
 423 /*
 424  * set_description_author
 425  *
 426  */
 427 static void
 428 set_description_author(Repodata *data, Id handle, char *str, struct parsedata *pd)
 429 {
 430   char *aut, *p;
 431
 432   if (!str || !*str)
 433     return;
 434   for (aut = str; (aut = strchr(aut, '\n')) != 0; aut++)
 435     if (!strncmp(aut, "\nAuthors:\n--------\n", 19))
 436       break;
 437   if (aut)
 438     {
 439       /* oh my, found SUSE special author section */
 440       int l = aut - str;
 441       str[l] = 0;
 442       while (l > 0 && str[l - 1] == '\n')
 443         str[--l] = 0;
 444       if (l)
 445         repodata_set_str(data, handle, langtag(pd, SOLVABLE_DESCRIPTION, pd->tmplang), str);
 446       p = aut + 19;
 447       aut = str;        /* copy over */
 448       while (*p == ' ' || *p == '\n')
 449         p++;
 450       while (*p)
 451         {
 452           if (*p == '\n')
 453             {
 454               *aut++ = *p++;
 455               while (*p == ' ')
 456                 p++;
 457               continue;
 458             }
 459           *aut++ = *p++;
 460         }
 461       while (aut != str && aut[-1] == '\n')
 462         aut--;
 463       *aut = 0;
 464       if (*str)
 465         repodata_set_str(data, handle, SOLVABLE_AUTHORS, str);
 466     }
 467   else if (*str)
 468     repodata_set_str(data, handle, langtag(pd, SOLVABLE_DESCRIPTION, pd->tmplang), str);
 469 }
 470
 471
 472 /*-----------------------------------------------*/
 473 /* checksum hash functions
 474  *
 475  * used to look up a solvable with the checksum for solvable extension purposes.
 476  *
 477  */
 478
 479 static void
 480 init_cshash(struct parsedata *pd)
 481 {
 482 }
 483
 484 static void
 485 free_cshash(struct parsedata *pd)
 486 {
 487   pd->cshash = solv_free(pd->cshash);
 488   pd->ncshash = 0;
 489   pd->cshashm = 0;
 490   pd->csdata = solv_free(pd->csdata);
 491   pd->ncsdata = 0;
 492 }
 493
 494 static inline Hashval
 495 hashkey(const unsigned char *key, int keyl)
 496 {
 497   return key[0] << 24 | key[1] << 16 | key[2] << 8 | key[3];
 498 }
 499
 500 static void
 501 rebuild_cshash(struct parsedata *pd)
 502 {
 503   Hashval h, hh, hm;
 504   Hashtable ht;
 505   unsigned char *d, *de;
 506
 507   hm = pd->cshashm;
 508 #if 0
 509   fprintf(stderr, "rebuild cshash with mask 0x%x\n", hm);
 510 #endif
 511   solv_free(pd->cshash);
 512   ht = pd->cshash = (Hashtable)solv_calloc(hm + 1, sizeof(Id));
 513   d = pd->csdata;
 514   de = d + pd->ncsdata;
 515   while (d != de)
 516     {
 517       h = hashkey(d + 1, d[0] + 1) & hm;
 518       hh = HASHCHAIN_START;
 519       while (ht[h])
 520         h = HASHCHAIN_NEXT(h, hh, hm);
 521       ht[h] = d + 1 - pd->csdata;
 522       d += 2 + d[0] + sizeof(Id);
 523     }
 524 }
 525
 526 static void
 527 put_in_cshash(struct parsedata *pd, const unsigned char *key, int keyl, Id id)
 528 {
 529   Hashtable ht;
 530   Hashval h, hh, hm;
 531   unsigned char *d;
 532
 533   if (keyl < 4 || keyl > 256)
 534     return;
 535   ht = pd->cshash;
 536   hm = pd->cshashm;
 537   h = hashkey(key, keyl) & hm;
 538   hh = HASHCHAIN_START;
 539   if (ht)
 540     {
 541       while (ht[h])
 542         {
 543           unsigned char *d = pd->csdata + ht[h];
 544           if (d[-1] == keyl - 1 && !memcmp(key, d, keyl))
 545             return;             /* XXX: first id wins... */
 546           h = HASHCHAIN_NEXT(h, hh, hm);
 547         }
 548     }
 549   /* a new entry. put in csdata */
 550   pd->csdata = solv_extend(pd->csdata, pd->ncsdata, 1 + keyl + sizeof(Id), 1, 4095);
 551   d = pd->csdata + pd->ncsdata;
 552   d[0] = keyl - 1;
 553   memcpy(d + 1, key, keyl);
 554   memcpy(d + 1 + keyl, &id, sizeof(Id));
 555   pd->ncsdata += 1 + keyl + sizeof(Id);
 556   if ((Hashval)++pd->ncshash * 2 > hm)
 557     {
 558       pd->cshashm = pd->cshashm ? (2 * pd->cshashm + 1) : 4095;
 559       rebuild_cshash(pd);
 560     }
 561   else
 562     ht[h] = pd->ncsdata - (keyl + sizeof(Id));
 563 }
 564
 565 static Id
 566 lookup_cshash(struct parsedata *pd, const unsigned char *key, int keyl)
 567 {
 568   Hashtable ht;
 569   Hashval h, hh, hm;
 570
 571   if (keyl < 4 || keyl > 256)
 572     return 0;
 573   ht = pd->cshash;
 574   if (!ht)
 575     return 0;
 576   hm = pd->cshashm;
 577   h = hashkey(key, keyl) & hm;
 578   hh = HASHCHAIN_START;
 579   while (ht[h])
 580     {
 581       unsigned char *d = pd->csdata + ht[h];
 582       if (d[-1] == keyl - 1 && !memcmp(key, d, keyl))
 583         {
 584           Id id;
 585           memcpy(&id, d + keyl, sizeof(Id));
 586           return id;
 587         }
 588       h = HASHCHAIN_NEXT(h, hh, hm);
 589     }
 590   return 0;
 591 }
 592
 593 static void
 594 fill_cshash_from_repo(struct parsedata *pd)
 595 {
 596   Dataiterator di;
 597   /* setup join data */
 598   dataiterator_init(&di, pd->pool, pd->repo, 0, SOLVABLE_CHECKSUM, 0, 0);
 599   while (dataiterator_step(&di))
 600     put_in_cshash(pd, (const unsigned char *)di.kv.str, solv_chksum_len(di.key->type), di.solvid);
 601   dataiterator_free(&di);
 602 }
 603
 604 static void
 605 fill_cshash_from_new_solvables(struct parsedata *pd)
 606 {
 607   Pool *pool = pd->pool;
 608   int i, l;
 609   KeyValue kv;
 610   Repokey *key;
 611
 612   for (i = pd->first; i < pool->nsolvables; i++)
 613     {
 614       if (pool->solvables[i].repo != pd->repo)
 615         continue;
 616       if ((key = repodata_lookup_kv_uninternalized(pd->data, i, SOLVABLE_CHECKSUM, &kv)) == 0)
 617         continue;
 618       if ((l = solv_chksum_len(key->type)) != 0)
 619         put_in_cshash(pd, (const unsigned char *)kv.str, l, i);
 620     }
 621 }
 622
 623 /*-----------------------------------------------*/
 624 /* XML callbacks */
 625
 626 /*
 627  * startElement
 628  */
 629
 630 static void
 631 startElement(struct solv_xmlparser *xmlp, int state, const char *name, const char **atts)
 632 {
 633   struct parsedata *pd = xmlp->userdata;
 634   Pool *pool = pd->pool;
 635   Solvable *s = pd->solvable;
 636   Id handle = pd->handle;
 637   const char *str;
 638   const char *pkgid;
 639
 640   if (!s && state != STATE_SOLVABLE)
 641     return;
 642
 643   switch(state)
 644     {
 645     case STATE_SOLVABLE:
 646       pd->kind = 0;
 647       if (name[2] == 't' && name[3] == 't')
 648         pd->kind = "pattern";
 649       else if (name[1] == 'r')
 650         pd->kind = "product";
 651       else if (name[2] == 't' && name[3] == 'c')
 652         pd->kind = "patch";
 653
 654       /* to support extension metadata files like others.xml which
 655          have the following structure:
 656
 657          <otherdata xmlns="http://linux.duke.edu/metadata/other"
 658                     packages="101">
 659            <package pkgid="b78f8664cd90efe42e09a345e272997ef1b53c18"
 660                     name="zaptel-kmp-default"
 661                     arch="i586"><version epoch="0"
 662                     ver="1.2.10_2.6.22_rc4_git6_2" rel="70"/>
 663               ...
 664
 665          we need to check if the pkgid is there and if it matches
 666          an already seen package, that means we don't need to create
 667          a new solvable but just append the attributes to the existing
 668          one.
 669       */
 670       pd->extending = 0;
 671       if ((pkgid = solv_xmlparser_find_attr("pkgid", atts)) != NULL)
 672         {
 673           unsigned char chk[256];
 674           int l;
 675           const char *str = pkgid;
 676           if (!pd->cshash_filled)
 677             {
 678               pd->cshash_filled = 1;
 679               fill_cshash_from_new_solvables(pd);
 680             }
 681           handle = 0;
 682           /* convert into bin checksum */
 683           l = solv_hex2bin(&str, chk, sizeof(chk));
 684           /* look at the checksum cache */
 685           if (l >= 4 && !pkgid[2 * l])
 686             handle = lookup_cshash(pd, chk, l);
 687 #if 0
 688           fprintf(stderr, "Lookup %s -> %d\n", pkgid, handle);
 689 #endif
 690           if (!handle)
 691             {
 692               pool_debug(pool, SOLV_WARN, "the repository specifies extra information about package with checksum '%s', which does not exist in the repository.\n", pkgid);
 693               pd->handle = 0;
 694               pd->solvable = 0;
 695               break;
 696             }
 697           pd->extending = 1;
 698         }
 699       else
 700         {
 701           /* this is a new package */
 702           handle = repo_add_solvable(pd->repo);
 703           if (!pd->first)
 704             pd->first = handle;
 705           pd->freshens = 0;
 706         }
 707       pd->handle = handle;
 708       pd->solvable = pool_id2solvable(pool, handle);
 709       if (pd->kind && pd->kind[1] == 'r')
 710         {
 711           /* products can have a type */
 712           const char *type = solv_xmlparser_find_attr("type", atts);
 713           if (type && *type)
 714             repodata_set_str(pd->data, handle, PRODUCT_TYPE, type);
 715         }
 716 #if 0
 717       fprintf(stderr, "package #%d\n", pd->solvable - pool->solvables);
 718 #endif
 719
 720       break;
 721     case STATE_VERSION:
 722       if (pd->extending && s->evr)
 723         break;          /* ignore version tag repetition in extend data */
 724       s->evr = makeevr_atts(pool, pd, atts);
 725       break;
 726     case STATE_PROVIDES:
 727       s->provides = 0;
 728       break;
 729     case STATE_PROVIDESENTRY:
 730       s->provides = adddep(pool, pd, s->provides, atts, 0);
 731       break;
 732     case STATE_REQUIRES:
 733       s->requires = 0;
 734       break;
 735     case STATE_REQUIRESENTRY:
 736       s->requires = adddep(pool, pd, s->requires, atts, 1);
 737       break;
 738     case STATE_OBSOLETES:
 739       s->obsoletes = 0;
 740       break;
 741     case STATE_OBSOLETESENTRY:
 742       s->obsoletes = adddep(pool, pd, s->obsoletes, atts, 0);
 743       break;
 744     case STATE_CONFLICTS:
 745       s->conflicts = 0;
 746       break;
 747     case STATE_CONFLICTSENTRY:
 748       s->conflicts = adddep(pool, pd, s->conflicts, atts, 0);
 749       break;
 750     case STATE_RECOMMENDS:
 751       s->recommends = 0;
 752       break;
 753     case STATE_RECOMMENDSENTRY:
 754       s->recommends = adddep(pool, pd, s->recommends, atts, 0);
 755       break;
 756     case STATE_SUPPLEMENTS:
 757       s->supplements= 0;
 758       break;
 759     case STATE_SUPPLEMENTSENTRY:
 760       s->supplements = adddep(pool, pd, s->supplements, atts, 0);
 761       break;
 762     case STATE_SUGGESTS:
 763       s->suggests = 0;
 764       break;
 765     case STATE_SUGGESTSENTRY:
 766       s->suggests = adddep(pool, pd, s->suggests, atts, 0);
 767       break;
 768     case STATE_ENHANCES:
 769       s->enhances = 0;
 770       break;
 771     case STATE_ENHANCESENTRY:
 772       s->enhances = adddep(pool, pd, s->enhances, atts, 0);
 773       break;
 774     case STATE_FRESHENS:
 775       pd->freshens = 0;
 776       break;
 777     case STATE_FRESHENSENTRY:
 778       pd->freshens = adddep(pool, pd, pd->freshens, atts, 0);
 779       break;
 780     case STATE_EULA:
 781     case STATE_SUMMARY:
 782     case STATE_CATEGORY:
 783     case STATE_DESCRIPTION:
 784       pd->tmplang = join_dup(&pd->jd, solv_xmlparser_find_attr("lang", atts));
 785       break;
 786     case STATE_USERVISIBLE:
 787       repodata_set_void(pd->data, handle, SOLVABLE_ISVISIBLE);
 788       break;
 789     case STATE_INCLUDESENTRY:
 790       str = solv_xmlparser_find_attr("pattern", atts);
 791       if (str)
 792         repodata_add_poolstr_array(pd->data, handle, SOLVABLE_INCLUDES, join2(&pd->jd, "pattern", ":", str));
 793       break;
 794     case STATE_EXTENDSENTRY:
 795       str = solv_xmlparser_find_attr("pattern", atts);
 796       if (str)
 797         repodata_add_poolstr_array(pd->data, handle, SOLVABLE_EXTENDS, join2(&pd->jd, "pattern", ":", str));
 798       break;
 799     case STATE_LOCATION:
 800       str = solv_xmlparser_find_attr("href", atts);
 801       if (str)
 802         {
 803           int medianr = 0;
 804           const char *base = solv_xmlparser_find_attr("xml:base", atts);
 805           if (base  && !strncmp(base, "media:", 6))
 806             {
 807               /* check for the media number in the fragment */
 808               int l = strlen(base);
 809               while (l && base[l - 1] >= '0' && base[l - 1] <= '9')
 810                 l--;
 811               if (l && base[l - 1] == '#' && base[l])
 812                 medianr = atoi(base + l);
 813             }
 814           repodata_set_location(pd->data, handle, medianr, 0, str);
 815           if (base)
 816             repodata_set_poolstr(pd->data, handle, SOLVABLE_MEDIABASE, base);
 817         }
 818       break;
 819     case STATE_CHECKSUM:
 820       str = solv_xmlparser_find_attr("type", atts);
 821       pd->chksumtype = str && *str ? solv_chksum_str2type(str) : 0;
 822       if (!pd->chksumtype)
 823         pd->ret = pool_error(pool, -1, "line %d: unknown checksum type: %s", solv_xmlparser_lineno(xmlp), str ? str : "NULL");
 824       break;
 825     case STATE_TIME:
 826       {
 827         unsigned int t;
 828         str = solv_xmlparser_find_attr("build", atts);
 829         if (str && (t = atoi(str)) != 0)
 830           repodata_set_num(pd->data, handle, SOLVABLE_BUILDTIME, t);
 831         break;
 832       }
 833     case STATE_SIZE:
 834       if ((str = solv_xmlparser_find_attr("installed", atts)) != 0)
 835         repodata_set_num(pd->data, handle, SOLVABLE_INSTALLSIZE, strtoull(str, 0, 10));
 836       if ((str = solv_xmlparser_find_attr("package", atts)) != 0)
 837         repodata_set_num(pd->data, handle, SOLVABLE_DOWNLOADSIZE, strtoull(str, 0, 10));
 838       break;
 839     case STATE_HEADERRANGE:
 840       {
 841         unsigned int end;
 842         str = solv_xmlparser_find_attr("end", atts);
 843         if (str && (end = atoi(str)) != 0)
 844           repodata_set_num(pd->data, handle, SOLVABLE_HEADEREND, end);
 845         break;
 846       }
 847       /*
 848         <diskusage>
 849           <dirs>
 850             <dir name="/" size="56" count="11"/>
 851             <dir name="usr/" size="56" count="11"/>
 852             <dir name="usr/bin/" size="38" count="10"/>
 853             <dir name="usr/share/" size="18" count="1"/>
 854             <dir name="usr/share/doc/" size="18" count="1"/>
 855           </dirs>
 856         </diskusage>
 857       */
 858     case STATE_DISKUSAGE:
 859       {
 860         /* Really, do nothing, wait for <dir> tag */
 861         break;
 862       }
 863     case STATE_DIR:
 864       {
 865         long filesz = 0, filenum = 0;
 866         Id did;
 867
 868         if ((str = solv_xmlparser_find_attr("name", atts)) == 0)
 869           {
 870             pd->ret = pool_error(pool, -1, "<dir .../> tag without 'name' attribute");
 871             break;
 872           }
 873         if (*str != '/')
 874           {
 875             if (s->arch == ARCH_SRC || s->arch == ARCH_NOSRC)
 876               str = "/usr/src";
 877             else
 878               {
 879                 int l = strlen(str) + 2;
 880                 char *space = solv_xmlparser_contentspace(xmlp, l);
 881                 space[0] = '/';
 882                 memcpy(space + 1, str, l - 1);
 883                 str = space;
 884             }
 885           }
 886         did = repodata_str2dir(pd->data, str, 1);
 887         if ((str = solv_xmlparser_find_attr("size", atts)) != 0)
 888           filesz = strtol(str, 0, 0);
 889         if ((str = solv_xmlparser_find_attr("count", atts)) != 0)
 890           filenum = strtol(str, 0, 0);
 891         if (filesz || filenum)
 892           {
 893             queue_push(&pd->diskusageq, did);
 894             queue_push2(&pd->diskusageq, filesz, filenum);
 895           }
 896         break;
 897       }
 898     case STATE_CHANGELOG:
 899       pd->changelog_handle = repodata_new_handle(pd->data);
 900       if ((str = solv_xmlparser_find_attr("date", atts)) != 0)
 901         repodata_set_num(pd->data, pd->changelog_handle, SOLVABLE_CHANGELOG_TIME, strtoull(str, 0, 10));
 902       if ((str = solv_xmlparser_find_attr("author", atts)) != 0)
 903         repodata_set_str(pd->data, pd->changelog_handle, SOLVABLE_CHANGELOG_AUTHOR, str);
 904       break;
 905     default:
 906       break;
 907     }
 908 }
 909
 910
 911 /*
 912  * endElement
 913  */
 914
 915 static void
 916 endElement(struct solv_xmlparser *xmlp, int state, char *content)
 917 {
 918   struct parsedata *pd = xmlp->userdata;
 919   Pool *pool = pd->pool;
 920   Solvable *s = pd->solvable;
 921   Repo *repo = pd->repo;
 922   Id handle = pd->handle;
 923   Id id;
 924   char *p;
 925
 926   if (!s)
 927     return;
 928
 929   switch (state)
 930     {
 931     case STATE_SOLVABLE:
 932       if (pd->extending)
 933         {
 934           pd->solvable = 0;
 935           break;
 936         }
 937       if (pd->kind && !s->name) /* add namespace in case of NULL name */
 938         s->name = pool_str2id(pool, join2(&pd->jd, pd->kind, ":", 0), 1);
 939       if (!s->arch)
 940         s->arch = ARCH_NOARCH;
 941       if (!s->evr)
 942         s->evr = ID_EMPTY;      /* some patterns have this */
 943       if (s->name && s->arch != ARCH_SRC && s->arch != ARCH_NOSRC)
 944         s->provides = repo_addid_dep(repo, s->provides, pool_rel2id(pool, s->name, s->evr, REL_EQ, 1), 0);
 945       repo_rewrite_suse_deps(s, pd->freshens);
 946       pd->freshens = 0;
 947       pd->kind = 0;
 948       pd->solvable = 0;
 949       break;
 950     case STATE_NAME:
 951       if (pd->kind)
 952         s->name = pool_str2id(pool, join2(&pd->jd, pd->kind, ":", content), 1);
 953       else
 954         s->name = pool_str2id(pool, content, 1);
 955       break;
 956     case STATE_ARCH:
 957       s->arch = pool_str2id(pool, content, 1);
 958       break;
 959     case STATE_VENDOR:
 960       s->vendor = pool_str2id(pool, content, 1);
 961       break;
 962     case STATE_RPM_GROUP:
 963       repodata_set_poolstr(pd->data, handle, SOLVABLE_GROUP, content);
 964       break;
 965     case STATE_RPM_LICENSE:
 966       repodata_set_poolstr(pd->data, handle, SOLVABLE_LICENSE, content);
 967       break;
 968     case STATE_CHECKSUM:
 969       {
 970         unsigned char chk[256];
 971         int l = solv_chksum_len(pd->chksumtype);
 972         const char *str = content;
 973         if (!l || l > sizeof(chk))
 974           break;
 975         if (solv_hex2bin(&str, chk, l) != l || content[2 * l])
 976           {
 977             pd->ret = pool_error(pool, -1, "line %u: invalid %s checksum", solv_xmlparser_lineno(xmlp), solv_chksum_type2str(pd->chksumtype));
 978             break;
 979           }
 980         repodata_set_bin_checksum(pd->data, handle, SOLVABLE_CHECKSUM, pd->chksumtype, chk);
 981         /* we save the checksum to solvable id relationship for extending metadata */
 982         if (pd->cshash_filled)
 983           put_in_cshash(pd, chk, l, s - pool->solvables);
 984         break;
 985       }
 986     case STATE_FILE:
 987       if ((p = strrchr(content, '/')) != 0)
 988         {
 989           *p++ = 0;
 990           if (pd->lastdir && !strcmp(pd->lastdirstr, content))
 991             {
 992               id = pd->lastdir;
 993             }
 994           else
 995             {
 996               int l = p - content;
 997               if (l + 1 > pd->lastdirstrl)      /* + 1 for the possible leading / we need to insert */
 998                 {
 999                   pd->lastdirstrl = l + 128;
1000                   pd->lastdirstr = solv_realloc(pd->lastdirstr, pd->lastdirstrl);
1001                 }
1002               if (content[0] != '/')
1003                 {
1004                   pd->lastdirstr[0] = '/';
1005                   memcpy(pd->lastdirstr + 1, content, l);
1006                   id = repodata_str2dir(pd->data, pd->lastdirstr, 1);
1007                 }
1008               else
1009                 id = repodata_str2dir(pd->data, content, 1);
1010               pd->lastdir = id;
1011               memcpy(pd->lastdirstr, content, l);
1012             }
1013         }
1014       else
1015         {
1016           p = content;
1017           id = repodata_str2dir(pd->data, "/", 1);
1018         }
1019       repodata_add_dirstr(pd->data, handle, SOLVABLE_FILELIST, id, p);
1020       break;
1021     case STATE_SUMMARY:
1022       repodata_set_str(pd->data, handle, langtag(pd, SOLVABLE_SUMMARY, pd->tmplang), content);
1023       break;
1024     case STATE_DESCRIPTION:
1025       set_description_author(pd->data, handle, content, pd);
1026       break;
1027     case STATE_CATEGORY:
1028       repodata_set_str(pd->data, handle, langtag(pd, SOLVABLE_CATEGORY, pd->tmplang), content);
1029       break;
1030     case STATE_DISTRIBUTION:
1031         repodata_set_poolstr(pd->data, handle, SOLVABLE_DISTRIBUTION, content);
1032         break;
1033     case STATE_URL:
1034       if (*content)
1035         repodata_set_str(pd->data, handle, SOLVABLE_URL, content);
1036       break;
1037     case STATE_PACKAGER:
1038       if (*content)
1039         repodata_set_poolstr(pd->data, handle, SOLVABLE_PACKAGER, content);
1040       break;
1041     case STATE_BUILDHOST:
1042       if (*content)
1043         repodata_set_str(pd->data, handle, SOLVABLE_BUILDHOST, content);
1044       break;
1045     case STATE_SOURCERPM:
1046       if (*content)
1047         repodata_set_sourcepkg(pd->data, handle, content);
1048       break;
1049     case STATE_RELNOTESURL:
1050       if (*content)
1051         {
1052           repodata_add_poolstr_array(pd->data, handle, PRODUCT_URL, content);
1053           repodata_add_idarray(pd->data, handle, PRODUCT_URL_TYPE, pool_str2id(pool, "releasenotes", 1));
1054         }
1055       break;
1056     case STATE_UPDATEURL:
1057       if (*content)
1058         {
1059           repodata_add_poolstr_array(pd->data, handle, PRODUCT_URL, content);
1060           repodata_add_idarray(pd->data, handle, PRODUCT_URL_TYPE, pool_str2id(pool, "update", 1));
1061         }
1062       break;
1063     case STATE_OPTIONALURL:
1064       if (*content)
1065         {
1066           repodata_add_poolstr_array(pd->data, handle, PRODUCT_URL, content);
1067           repodata_add_idarray(pd->data, handle, PRODUCT_URL_TYPE, pool_str2id(pool, "optional", 1));
1068         }
1069       break;
1070     case STATE_FLAG:
1071       if (*content)
1072         repodata_add_poolstr_array(pd->data, handle, PRODUCT_FLAGS, content);
1073       break;
1074     case STATE_EULA:
1075       if (*content)
1076         repodata_set_str(pd->data, handle, langtag(pd, SOLVABLE_EULA, pd->tmplang), content);
1077       break;
1078     case STATE_KEYWORD:
1079       if (*content)
1080         repodata_add_poolstr_array(pd->data, handle, SOLVABLE_KEYWORDS, content);
1081       break;
1082     case STATE_DISKUSAGE:
1083       if (pd->diskusageq.count)
1084         repodata_add_diskusage(pd->data, handle, &pd->diskusageq);
1085       break;
1086     case STATE_ORDER:
1087       if (*content)
1088         repodata_set_str(pd->data, handle, SOLVABLE_ORDER, content);
1089       break;
1090     case STATE_CHANGELOG:
1091       repodata_set_str(pd->data, pd->changelog_handle, SOLVABLE_CHANGELOG_TEXT, content);
1092       repodata_add_flexarray(pd->data, handle, SOLVABLE_CHANGELOG, pd->changelog_handle);
1093       pd->changelog_handle = 0;
1094       break;
1095     default:
1096       break;
1097     }
1098 }
1099
1100
1101 /*-----------------------------------------------*/
1102
1103 /*
1104  * repo_add_rpmmd
1105  * parse rpm-md metadata (primary, others)
1106  *
1107  */
1108
1109 int
1110 repo_add_rpmmd(Repo *repo, FILE *fp, const char *language, int flags)
1111 {
1112   Pool *pool = repo->pool;
1113   struct parsedata pd;
1114   Repodata *data;
1115   unsigned int now;
1116
1117   now = solv_timems(0);
1118   data = repo_add_repodata(repo, flags);
1119
1120   memset(&pd, 0, sizeof(pd));
1121   pd.pool = pool;
1122   pd.repo = repo;
1123   pd.data = data;
1124
1125   pd.kind = 0;
1126   pd.language = language && *language && strcmp(language, "en") != 0 ? language : 0;
1127   queue_init(&pd.diskusageq);
1128
1129   init_cshash(&pd);
1130   if ((flags & REPO_EXTEND_SOLVABLES) != 0)
1131     {
1132       /* setup join data */
1133       pd.cshash_filled = 1;
1134       fill_cshash_from_repo(&pd);
1135     }
1136
1137   solv_xmlparser_init(&pd.xmlp, stateswitches, &pd, startElement, endElement);
1138   if (solv_xmlparser_parse(&pd.xmlp, fp) != SOLV_XMLPARSER_OK)
1139     pd.ret = pool_error(pool, -1, "repo_rpmmd: %s at line %u:%u", pd.xmlp.errstr, pd.xmlp.line, pd.xmlp.column);
1140   solv_xmlparser_free(&pd.xmlp);
1141
1142   solv_free(pd.lastdirstr);
1143   join_freemem(&pd.jd);
1144   free_cshash(&pd);
1145   repodata_free_dircache(data);
1146   queue_free(&pd.diskusageq);
1147
1148   if ((flags & REPO_EXTEND_SOLVABLES) != 0)
1149     {
1150       /* is this a filelist extension? */
1151       if (repodata_has_keyname(data, SOLVABLE_FILELIST))
1152         repodata_set_filelisttype(data, REPODATA_FILELIST_EXTENSION);
1153     }
1154   else
1155     {
1156       /* is this a primary with a filtered filelist? */
1157       if (data->end > data->start)
1158         {
1159           repodata_set_filelisttype(data, REPODATA_FILELIST_FILTERED);
1160           repodata_set_void(data, SOLVID_META, REPOSITORY_FILTEREDFILELIST);
1161         }
1162     }
1163
1164   if (!(flags & REPO_NO_INTERNALIZE))
1165     repodata_internalize(data);
1166   POOL_DEBUG(SOLV_DEBUG_STATS, "repo_add_rpmmd took %d ms\n", solv_timems(now));
1167   POOL_DEBUG(SOLV_DEBUG_STATS, "repo size: %d solvables\n", repo->nsolvables);
1168   POOL_DEBUG(SOLV_DEBUG_STATS, "repo memory used: %d K incore, %d K idarray\n", repodata_memused(data)/1024, repo->idarraysize / (int)(1024/sizeof(Id)));
1169   return pd.ret;
1170 }