tools/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 <limits.h>
  10 #include <fcntl.h>
  11 #include <stdio.h>
  12 #include <stdlib.h>
  13 #include <string.h>
  14 #include <expat.h>
  15
  16 #include "pool.h"
  17 #include "repo.h"
  18 #define DISABLE_SPLIT
  19 #include "tools_util.h"
  20 #include "repo_rpmmd.h"
  21
  22
  23 enum state {
  24   STATE_START,
  25   STATE_METADATA,
  26   STATE_SOLVABLE,
  27   STATE_PRODUCT,
  28   STATE_PATTERN,
  29   STATE_PATCH,
  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   /* patch */
  56   STATE_ID,
  57   STATE_TIMESTAMP,
  58   STATE_AFFECTSPKG,
  59   STATE_REBOOTNEEDED,
  60
  61   // pattern attributes
  62   STATE_CATEGORY, /* pattern and patches */
  63   STATE_SCRIPT,
  64   STATE_ICON,
  65   STATE_USERVISIBLE,
  66   STATE_DEFAULT,
  67   STATE_INSTALL_TIME,
  68
  69   /* product */
  70   STATE_SHORTNAME,
  71   STATE_DISTNAME, // obsolete
  72   STATE_DISTEDITION, // obsolete
  73   STATE_SOURCE,
  74   STATE_TYPE,
  75   STATE_RELNOTESURL,
  76   STATE_UPDATEURL,
  77   STATE_OPTIONALURL,
  78   STATE_FLAG,
  79   STATE_FLAVOR,
  80   STATE_REFERENCES,
  81
  82   /* rpm-md dependencies inside the
  83      format tag */
  84   STATE_PROVIDES,
  85   STATE_REQUIRES,
  86   STATE_OBSOLETES,
  87   STATE_CONFLICTS,
  88   STATE_RECOMMENDS,
  89   STATE_SUPPLEMENTS,
  90   STATE_SUGGESTS,
  91   STATE_ENHANCES,
  92   STATE_FRESHENS,
  93   STATE_SOURCERPM,
  94   STATE_HEADERRANGE,
  95
  96   STATE_PROVIDESENTRY,
  97   STATE_REQUIRESENTRY,
  98   STATE_OBSOLETESENTRY,
  99   STATE_CONFLICTSENTRY,
 100   STATE_RECOMMENDSENTRY,
 101   STATE_SUPPLEMENTSENTRY,
 102   STATE_SUGGESTSENTRY,
 103   STATE_ENHANCESENTRY,
 104   STATE_FRESHENSENTRY,
 105
 106   STATE_FILE,
 107
 108   STATE_DISKUSAGE,
 109   STATE_TRANSLATIONS,
 110   STATE_DUINFO,
 111   STATE_DIRS,
 112   STATE_DIR,
 113
 114   // general
 115   NUMSTATES
 116 };
 117
 118 struct stateswitch {
 119   enum state from;
 120   char *ename;
 121   enum state to;
 122   int docontent;
 123 };
 124
 125 static struct stateswitch stateswitches[] = {
 126
 127   { STATE_START,       "product",         STATE_SOLVABLE, 0 },
 128   { STATE_START,       "pattern",         STATE_SOLVABLE, 0 },
 129   { STATE_START,       "patch",           STATE_SOLVABLE, 0 },
 130   { STATE_START,       "package",         STATE_SOLVABLE, 0 },
 131   { STATE_START,       "diskusage",       STATE_DISKUSAGE, 0 },
 132   { STATE_START,       "translations",    STATE_TRANSLATIONS, 0 },
 133
 134   { STATE_SOLVABLE,    "name",            STATE_NAME, 1 },
 135   { STATE_SOLVABLE,    "arch",            STATE_ARCH, 1 },
 136   { STATE_SOLVABLE,    "version",         STATE_VERSION, 0 },
 137
 138   // package attributes rpm-md
 139   { STATE_SOLVABLE,    "location",        STATE_LOCATION, 0 },
 140   { STATE_SOLVABLE,    "checksum",        STATE_CHECKSUM, 1 },
 141
 142   /* resobject attributes */
 143
 144   { STATE_SOLVABLE,    "summary",         STATE_SUMMARY,      1 },
 145   { STATE_SOLVABLE,    "description",     STATE_DESCRIPTION,  1 },
 146   { STATE_SOLVABLE,    "distribution",    STATE_DISTRIBUTION, 1 },
 147   { STATE_SOLVABLE,    "url",             STATE_URL,          1 },
 148   { STATE_SOLVABLE,    "packager",        STATE_PACKAGER,     1 },
 149   //{ STATE_SOLVABLE,    "???",         STATE_INSNOTIFY, 1 },
 150   //{ STATE_SOLVABLE,    "??",     STATE_DELNOTIFY, 1 },
 151   { STATE_SOLVABLE,    "vendor",          STATE_VENDOR,       1 },
 152   { STATE_SOLVABLE,    "size",            STATE_SIZE,         0 },
 153   { STATE_SOLVABLE,    "archive-size",    STATE_DOWNLOADSIZE, 1 },
 154   { STATE_SOLVABLE,    "install-time",    STATE_INSTALLTIME,  1 },
 155   { STATE_SOLVABLE,    "install-only",    STATE_INSTALLONLY,  1 },
 156   { STATE_SOLVABLE,    "time",            STATE_TIME,         0 },
 157
 158   // pattern attribute
 159   { STATE_SOLVABLE,    "script",          STATE_SCRIPT,        1 },
 160   { STATE_SOLVABLE,    "icon",            STATE_ICON,          1 },
 161   { STATE_SOLVABLE,    "uservisible",     STATE_USERVISIBLE,   1 },
 162   { STATE_SOLVABLE,    "category",        STATE_CATEGORY,      1 },
 163   { STATE_SOLVABLE,    "default",         STATE_DEFAULT,       1 },
 164   { STATE_SOLVABLE,    "install-time",    STATE_INSTALL_TIME,  1 },
 165
 166   /* product attributes */
 167   /* note the product type is an attribute */
 168   { STATE_SOLVABLE,    "release-notes-url", STATE_RELNOTESURL, 1 },
 169   { STATE_SOLVABLE,    "update-url",        STATE_UPDATEURL,   1 },
 170   { STATE_SOLVABLE,    "optional-url",      STATE_OPTIONALURL, 1 },
 171   { STATE_SOLVABLE,    "flag",              STATE_FLAG,        1 },
 172   { STATE_SOLVABLE,    "flavor",            STATE_FLAVOR,      1 },
 173   { STATE_SOLVABLE,    "references",        STATE_REFERENCES,  1 },
 174
 175   { STATE_SOLVABLE,      "rpm:vendor",      STATE_VENDOR,      1 },
 176   { STATE_SOLVABLE,      "rpm:group",       STATE_RPM_GROUP,   1 },
 177   { STATE_SOLVABLE,      "rpm:license",     STATE_RPM_LICENSE, 1 },
 178
 179   /* rpm-md dependencies */
 180   { STATE_SOLVABLE,      "rpm:provides",    STATE_PROVIDES,     0 },
 181   { STATE_SOLVABLE,      "rpm:requires",    STATE_REQUIRES,     0 },
 182   { STATE_SOLVABLE,      "rpm:obsoletes",   STATE_OBSOLETES,    0 },
 183   { STATE_SOLVABLE,      "rpm:conflicts",   STATE_CONFLICTS,    0 },
 184   { STATE_SOLVABLE,      "rpm:recommends",  STATE_RECOMMENDS ,  0 },
 185   { STATE_SOLVABLE,      "rpm:supplements", STATE_SUPPLEMENTS,  0 },
 186   { STATE_SOLVABLE,      "rpm:suggests",    STATE_SUGGESTS,     0 },
 187   { STATE_SOLVABLE,      "rpm:enhances",    STATE_ENHANCES,     0 },
 188   { STATE_SOLVABLE,      "rpm:freshens",    STATE_FRESHENS,     0 },
 189   { STATE_SOLVABLE,      "rpm:sourcerpm",   STATE_SOURCERPM,    1 },
 190   { STATE_SOLVABLE,      "rpm:header-range", STATE_HEADERRANGE, 0 },
 191   { STATE_SOLVABLE,      "file",            STATE_FILE, 1 },
 192
 193   { STATE_PROVIDES,    "rpm:entry",       STATE_PROVIDESENTRY, 0 },
 194   { STATE_REQUIRES,    "rpm:entry",       STATE_REQUIRESENTRY, 0 },
 195   { STATE_OBSOLETES,   "rpm:entry",       STATE_OBSOLETESENTRY, 0 },
 196   { STATE_CONFLICTS,   "rpm:entry",       STATE_CONFLICTSENTRY, 0 },
 197   { STATE_RECOMMENDS,  "rpm:entry",       STATE_RECOMMENDSENTRY, 0 },
 198   { STATE_SUPPLEMENTS, "rpm:entry",       STATE_SUPPLEMENTSENTRY, 0 },
 199   { STATE_SUGGESTS,    "rpm:entry",       STATE_SUGGESTSENTRY, 0 },
 200   { STATE_ENHANCES,    "rpm:entry",       STATE_ENHANCESENTRY, 0 },
 201   { STATE_FRESHENS,    "rpm:entry",       STATE_FRESHENSENTRY, 0 },
 202
 203   /* diskusage.xml */
 204   { STATE_DISKUSAGE,   "duinfo",          STATE_DUINFO, 0 },
 205   { STATE_DUINFO,      "dirs",            STATE_DIRS, 0 },
 206   { STATE_DIRS,        "dir",             STATE_DIR, 0 },
 207
 208   { NUMSTATES}
 209 };
 210
 211
 212 struct parsedata {
 213   struct parsedata_common common;
 214   char *kind;
 215   int depth;
 216   enum state state;
 217   int statedepth;
 218   char *content;
 219   int lcontent;
 220   int acontent;
 221   int docontent;
 222   Solvable *solvable;
 223   Offset freshens;
 224   struct stateswitch *swtab[NUMSTATES];
 225   enum state sbtab[NUMSTATES];
 226   const char *lang;
 227   const char *capkind;
 228   // used to store tmp attributes
 229   // while the tag ends
 230   const char *tmpattr;
 231   Repodata *data;
 232   Id handle;
 233   XML_Parser *parser;
 234   Id (*dirs)[3]; // dirid, size, nfiles
 235   int ndirs;
 236   Id langcache[ID_NUM_INTERNAL];
 237 };
 238
 239
 240 /*
 241  * makeevr_atts
 242  * parse 'epoch', 'ver' and 'rel', return evr Id
 243  *
 244  */
 245
 246 static Id
 247 makeevr_atts(Pool *pool, struct parsedata *pd, const char **atts)
 248 {
 249   const char *e, *v, *r, *v2;
 250   char *c;
 251   int l;
 252
 253   e = v = r = 0;
 254   for (; *atts; atts += 2)
 255     {
 256       if (!strcmp(*atts, "epoch"))
 257         e = atts[1];
 258       else if (!strcmp(*atts, "ver"))
 259         v = atts[1];
 260       else if (!strcmp(*atts, "rel"))
 261         r = atts[1];
 262     }
 263   if (e && !strcmp(e, "0"))
 264     e = 0;
 265   if (v && !e)
 266     {
 267       for (v2 = v; *v2 >= '0' && *v2 <= '9'; v2++)
 268         ;
 269       if (v2 > v && *v2 == ':')
 270         e = "0";
 271     }
 272   l = 1;
 273   if (e)
 274     l += strlen(e) + 1;
 275   if (v)
 276     l += strlen(v);
 277   if (r)
 278     l += strlen(r) + 1;
 279   if (l > pd->acontent)
 280     {
 281       pd->content = sat_realloc(pd->content, l + 256);
 282       pd->acontent = l + 256;
 283     }
 284   c = pd->content;
 285   if (e)
 286     {
 287       strcpy(c, e);
 288       c += strlen(c);
 289       *c++ = ':';
 290     }
 291   if (v)
 292     {
 293       strcpy(c, v);
 294       c += strlen(c);
 295     }
 296   if (r)
 297     {
 298       *c++ = '-';
 299       strcpy(c, r);
 300       c += strlen(c);
 301     }
 302   *c = 0;
 303   if (!*pd->content)
 304     return 0;
 305 #if 0
 306   fprintf(stderr, "evr: %s\n", pd->content);
 307 #endif
 308   return str2id(pool, pd->content, 1);
 309 }
 310
 311
 312 /*
 313  * find_attr
 314  * find value for xml attribute
 315  * I: txt, name of attribute
 316  * I: atts, list of key/value attributes
 317  * O: pointer to value of matching key, or NULL
 318  *
 319  */
 320
 321 static inline const char *
 322 find_attr(const char *txt, const char **atts)
 323 {
 324   for (; *atts; atts += 2)
 325     {
 326       if (!strcmp(*atts, txt))
 327         return atts[1];
 328     }
 329   return 0;
 330 }
 331
 332
 333 /*
 334  * dependency relations
 335  */
 336
 337 static char *flagtab[] = {
 338   "GT",
 339   "EQ",
 340   "GE",
 341   "LT",
 342   "NE",
 343   "LE"
 344 };
 345
 346
 347 /*
 348  * adddep
 349  * parse attributes to reldep Id
 350  *
 351  */
 352
 353 static unsigned int
 354 adddep(Pool *pool, struct parsedata *pd, unsigned int olddeps, const char **atts, int isreq)
 355 {
 356   Id id, name, marker;
 357   const char *n, *f, *k;
 358   const char **a;
 359
 360   n = f = k = 0;
 361   marker = isreq ? -SOLVABLE_PREREQMARKER : 0;
 362   for (a = atts; *a; a += 2)
 363     {
 364       if (!strcmp(*a, "name"))
 365         n = a[1];
 366       else if (!strcmp(*a, "flags"))
 367         f = a[1];
 368       else if (!strcmp(*a, "kind"))
 369         k = a[1];
 370       else if (isreq && !strcmp(*a, "pre") && a[1][0] == '1')
 371         marker = SOLVABLE_PREREQMARKER;
 372     }
 373   if (!n)
 374     return olddeps;
 375   if (k && !strcmp(k, "package"))
 376     k = 0;
 377   if (k)
 378     {
 379       int l = strlen(k) + 1 + strlen(n) + 1;
 380       if (l > pd->acontent)
 381         {
 382           pd->content = sat_realloc(pd->content, l + 256);
 383           pd->acontent = l + 256;
 384         }
 385       sprintf(pd->content, "%s:%s", k, n);
 386       name = str2id(pool, pd->content, 1);
 387     }
 388   else
 389     name = str2id(pool, (char *)n, 1);
 390   if (f)
 391     {
 392       Id evr = makeevr_atts(pool, pd, atts);
 393       int flags;
 394       for (flags = 0; flags < 6; flags++)
 395         if (!strcmp(f, flagtab[flags]))
 396           break;
 397       flags = flags < 6 ? flags + 1 : 0;
 398       id = rel2id(pool, name, evr, flags, 1);
 399     }
 400   else
 401     id = name;
 402 #if 0
 403   fprintf(stderr, "new dep %s%s%s\n", id2str(pool, d), id2rel(pool, d), id2evr(pool, d));
 404 #endif
 405   return repo_addid_dep(pd->common.repo, olddeps, id, marker);
 406 }
 407
 408
 409 /*
 410  * set_desciption_author
 411  *
 412  */
 413
 414 static void
 415 set_desciption_author(Repodata *data, Id handle, char *str)
 416 {
 417   char *aut, *p;
 418
 419   if (!str || !*str)
 420     return;
 421   for (aut = str; (aut = strchr(aut, '\n')) != 0; aut++)
 422     if (!strncmp(aut, "\nAuthors:\n--------\n", 19))
 423       break;
 424   if (aut)
 425     {
 426       /* oh my, found SUSE special author section */
 427       int l = aut - str;
 428       str[l] = 0;
 429       while (l > 0 && str[l - 1] == '\n')
 430         str[--l] = 0;
 431       if (l)
 432         repodata_set_str(data, handle, SOLVABLE_DESCRIPTION, str);
 433       p = aut + 19;
 434       aut = str;        /* copy over */
 435       while (*p == ' ' || *p == '\n')
 436         p++;
 437       while (*p)
 438         {
 439           if (*p == '\n')
 440             {
 441               *aut++ = *p++;
 442               while (*p == ' ')
 443                 p++;
 444               continue;
 445             }
 446           *aut++ = *p++;
 447         }
 448       while (aut != str && aut[-1] == '\n')
 449         aut--;
 450       *aut = 0;
 451       if (*str)
 452         repodata_set_str(data, handle, SOLVABLE_AUTHORS, str);
 453     }
 454   else if (*str)
 455     repodata_set_str(data, handle, SOLVABLE_DESCRIPTION, str);
 456 }
 457
 458
 459 /*
 460  * set_sourcerpm
 461  *
 462  */
 463
 464 static void
 465 set_sourcerpm(Repodata *data, Solvable *s, Id handle, char *sourcerpm)
 466 {
 467   const char *p, *sevr, *sarch, *name, *evr;
 468   Pool *pool;
 469
 470   p = strrchr(sourcerpm, '.');
 471   if (!p || strcmp(p, ".rpm") != 0)
 472     return;
 473   p--;
 474   while (p > sourcerpm && *p != '.')
 475     p--;
 476   if (*p != '.' || p == sourcerpm)
 477     return;
 478   sarch = p-- + 1;
 479   while (p > sourcerpm && *p != '-')
 480     p--;
 481   if (*p != '-' || p == sourcerpm)
 482     return;
 483   p--;
 484   while (p > sourcerpm && *p != '-')
 485     p--;
 486   if (*p != '-' || p == sourcerpm)
 487     return;
 488   sevr = p + 1;
 489   pool = s->repo->pool;
 490   name = id2str(pool, s->name);
 491   evr = id2str(pool, s->evr);
 492   if (!strcmp(sarch, "src.rpm"))
 493     repodata_set_constantid(data, handle, SOLVABLE_SOURCEARCH, ARCH_SRC);
 494   else if (!strcmp(sarch, "nosrc.rpm"))
 495     repodata_set_constantid(data, handle, SOLVABLE_SOURCEARCH, ARCH_NOSRC);
 496   else
 497     repodata_set_constantid(data, handle, SOLVABLE_SOURCEARCH, strn2id(pool, sarch, strlen(sarch) - 4, 1));
 498   if (!strncmp(sevr, evr, sarch - sevr - 1) && evr[sarch - sevr - 1] == 0)
 499     repodata_set_void(data, handle, SOLVABLE_SOURCEEVR);
 500   else
 501     repodata_set_id(data, handle, SOLVABLE_SOURCEEVR, strn2id(pool, sevr, sarch - sevr - 1, 1));
 502   if (!strncmp(sourcerpm, name, sevr - sourcerpm - 1) && name[sevr - sourcerpm -
 503  1] == 0)
 504     repodata_set_void(data, handle, SOLVABLE_SOURCENAME);
 505   else
 506     repodata_set_id(data, handle, SOLVABLE_SOURCENAME, strn2id(pool, sourcerpm, sevr - sourcerpm - 1, 1));
 507 }
 508
 509 /*-----------------------------------------------*/
 510 /* XML callbacks */
 511
 512 /*
 513  * startElement
 514  * XML callback
 515  *
 516  */
 517
 518 static void XMLCALL
 519 startElement(void *userData, const char *name, const char **atts)
 520 {
 521   //fprintf(stderr,"+tag: %s\n", name);
 522   struct parsedata *pd = userData;
 523   Pool *pool = pd->common.pool;
 524   Solvable *s = pd->solvable;
 525   struct stateswitch *sw;
 526   const char *str;
 527   Id handle = pd->handle;
 528
 529   // fprintf(stderr, "into %s, from %d, depth %d, statedepth %d\n", name, pd->state, pd->depth, pd->statedepth);
 530
 531   if (pd->depth != pd->statedepth)
 532     {
 533       pd->depth++;
 534       return;
 535     }
 536
 537   if (pd->state == STATE_START && !strcmp(name, "patterns"))
 538     return;
 539   if (pd->state == STATE_START && !strcmp(name, "metadata"))
 540     return;
 541   if (pd->state == STATE_SOLVABLE && !strcmp(name, "format"))
 542     return;
 543
 544   pd->depth++;
 545   for (sw = pd->swtab[pd->state]; sw->from == pd->state; sw++)
 546     if (!strcmp(sw->ename, name))
 547       break;
 548   if (sw->from != pd->state)
 549     {
 550 #if 0
 551       fprintf(stderr, "into unknown: %s\n", name);
 552 #endif
 553       return;
 554     }
 555   pd->state = sw->to;
 556   pd->docontent = sw->docontent;
 557   pd->statedepth = pd->depth;
 558   pd->lcontent = 0;
 559   *pd->content = 0;
 560   switch(pd->state)
 561     {
 562     case STATE_SOLVABLE:
 563       pd->kind = 0;
 564       if (name[2] == 't' && name[3] == 't')
 565         pd->kind = "pattern";
 566       else if (name[1] == 'r')
 567         pd->kind = "product";
 568       else if (name[2] == 't' && name[3] == 'c')
 569         pd->kind = "patch";
 570
 571       /* this is a new package */
 572       /*fprintf(stderr, "new package\n");*/
 573       pd->solvable = pool_id2solvable(pool, repo_add_solvable(pd->common.repo));
 574       pd->freshens = 0;
 575       repodata_extend(pd->data, pd->solvable - pool->solvables);
 576       pd->handle = repodata_get_handle(pd->data, (pd->solvable - pool->solvables) - pd->data->start);
 577 #if 0
 578       fprintf(stderr, "package #%d\n", pd->solvable - pool->solvables);
 579 #endif
 580       break;
 581     case STATE_VERSION:
 582       s->evr = makeevr_atts(pool, pd, atts);
 583       break;
 584     case STATE_PROVIDES:
 585       s->provides = 0;
 586       break;
 587     case STATE_PROVIDESENTRY:
 588       s->provides = adddep(pool, pd, s->provides, atts, 0);
 589       break;
 590     case STATE_REQUIRES:
 591       s->requires = 0;
 592       break;
 593     case STATE_REQUIRESENTRY:
 594       s->requires = adddep(pool, pd, s->requires, atts, 1);
 595       break;
 596     case STATE_OBSOLETES:
 597       s->obsoletes = 0;
 598       break;
 599     case STATE_OBSOLETESENTRY:
 600       s->obsoletes = adddep(pool, pd, s->obsoletes, atts, 0);
 601       break;
 602     case STATE_CONFLICTS:
 603       s->conflicts = 0;
 604       break;
 605     case STATE_CONFLICTSENTRY:
 606       s->conflicts = adddep(pool, pd, s->conflicts, atts, 0);
 607       break;
 608     case STATE_RECOMMENDS:
 609       s->recommends = 0;
 610       break;
 611     case STATE_RECOMMENDSENTRY:
 612       s->recommends = adddep(pool, pd, s->recommends, atts, 0);
 613       break;
 614     case STATE_SUPPLEMENTS:
 615       s->supplements= 0;
 616       break;
 617     case STATE_SUPPLEMENTSENTRY:
 618       s->supplements = adddep(pool, pd, s->supplements, atts, 0);
 619       break;
 620     case STATE_SUGGESTS:
 621       s->suggests = 0;
 622       break;
 623     case STATE_SUGGESTSENTRY:
 624       s->suggests = adddep(pool, pd, s->suggests, atts, 0);
 625       break;
 626     case STATE_ENHANCES:
 627       s->enhances = 0;
 628       break;
 629     case STATE_ENHANCESENTRY:
 630       s->enhances = adddep(pool, pd, s->enhances, atts, 0);
 631       break;
 632     case STATE_FRESHENS:
 633       pd->freshens = 0;
 634       break;
 635     case STATE_FRESHENSENTRY:
 636       pd->freshens = adddep(pool, pd, pd->freshens, atts, 0);
 637       break;
 638     case STATE_SUMMARY:
 639     case STATE_DESCRIPTION:
 640       pd->lang = find_attr("lang", atts);
 641       break;
 642     case STATE_LOCATION:
 643       str = find_attr("href", atts);
 644       if (str)
 645         {
 646           const char *str2 = strrchr(str, '/');
 647           if (str2)
 648             {
 649               char *str3 = strdup(str);
 650               str3[str2 - str] = 0;
 651               repodata_set_poolstr(pd->data, handle, SOLVABLE_MEDIADIR, str3);
 652               free(str3);
 653               repodata_set_str(pd->data, handle, SOLVABLE_MEDIAFILE, str2 + 1);
 654             }
 655           else
 656             repodata_set_str(pd->data, handle, SOLVABLE_MEDIAFILE, str);
 657         }
 658       break;
 659     case STATE_CHECKSUM:
 660       pd->tmpattr = find_attr("type", atts);
 661       break;
 662     case STATE_TIME:
 663       {
 664         unsigned int t;
 665         str = find_attr("build", atts);
 666         if (str && (t = atoi(str)) != 0)
 667           repodata_set_num(pd->data, handle, SOLVABLE_BUILDTIME, t);
 668         break;
 669       }
 670     case STATE_SIZE:
 671       {
 672         unsigned int k;
 673         str = find_attr("installed", atts);
 674         if (str && (k = atoi(str)) != 0)
 675           repodata_set_num(pd->data, handle, SOLVABLE_INSTALLSIZE, (k + 1023) / 1024);
 676         /* XXX the "package" attribute gives the size of the rpm file,
 677            i.e. the download size.  Except on packman, there it seems to be
 678            something else entirely, it has a value near to the other two
 679            values, as if the rpm is uncompressed.  */
 680         str = find_attr("package", atts);
 681         if (str && (k = atoi(str)) != 0)
 682           repodata_set_num(pd->data, handle, SOLVABLE_DOWNLOADSIZE, (k + 1023) / 1024);
 683         break;
 684       }
 685     case STATE_HEADERRANGE:
 686       {
 687         unsigned int end;
 688         str = find_attr("end", atts);
 689         if (str && (end = atoi(str)) != 0)
 690           repodata_set_num(pd->data, handle, SOLVABLE_HEADEREND, end);
 691       }
 692     case STATE_DISKUSAGE:
 693     case STATE_TRANSLATIONS:
 694     case STATE_DUINFO:
 695     case STATE_DIRS:
 696     case STATE_DIR:
 697
 698     default:
 699       break;
 700     }
 701 }
 702
 703
 704 /*
 705  * endElement
 706  * XML callback
 707  *
 708  */
 709
 710 static void XMLCALL
 711 endElement(void *userData, const char *name)
 712 {
 713   //fprintf(stderr,"-tag: %s\n", name);
 714   struct parsedata *pd = userData;
 715   Pool *pool = pd->common.pool;
 716   Solvable *s = pd->solvable;
 717   Repo *repo = pd->common.repo;
 718   Id handle = pd->handle;
 719   Id id;
 720   char *p;
 721
 722   if (pd->depth != pd->statedepth)
 723     {
 724       pd->depth--;
 725       // printf("back from unknown %d %d %d\n", pd->state, pd->depth, pd->statedepth);
 726       return;
 727     }
 728
 729   /* ignore patterns & metadata */
 730   if (pd->state == STATE_START && !strcmp(name, "patterns"))
 731     return;
 732   if (pd->state == STATE_START && !strcmp(name, "metadata"))
 733     return;
 734   if (pd->state == STATE_SOLVABLE && !strcmp(name, "format"))
 735     return;
 736
 737   pd->depth--;
 738   pd->statedepth--;
 739   switch (pd->state)
 740     {
 741     case STATE_PATTERN:
 742     case STATE_PRODUCT:
 743     case STATE_SOLVABLE:
 744       if (!s->arch)
 745         s->arch = ARCH_NOARCH;
 746       if (!s->evr)
 747         s->evr = ID_EMPTY;      /* some patterns have this */
 748       if (s->arch != ARCH_SRC && s->arch != ARCH_NOSRC)
 749         s->provides = repo_addid_dep(repo, s->provides, rel2id(pool, s->name, s->evr, REL_EQ, 1), 0);
 750       s->supplements = repo_fix_legacy(repo, s->provides, s->supplements, pd->freshens);
 751       pd->freshens = 0;
 752       pd->kind = 0;
 753       break;
 754     case STATE_NAME:
 755       if ( pd->kind )
 756           s->name = str2id(pool, join2( pd->kind, ":", pd->content), 1);
 757       else
 758           s->name = str2id(pool, pd->content, 1);
 759       break;
 760     case STATE_ARCH:
 761       s->arch = str2id(pool, pd->content, 1);
 762       break;
 763     case STATE_VENDOR:
 764       s->vendor = str2id(pool, pd->content, 1);
 765       break;
 766     case STATE_RPM_GROUP:
 767       repodata_set_poolstr(pd->data, handle, SOLVABLE_GROUP, pd->content);
 768       break;
 769     case STATE_RPM_LICENSE:
 770       repodata_set_poolstr(pd->data, handle, SOLVABLE_LICENSE, pd->content);
 771       break;
 772     case STATE_CHECKSUM:
 773       {
 774         int l;
 775         Id type;
 776         if (!strcasecmp (pd->tmpattr, "sha") || !strcasecmp (pd->tmpattr, "sha1"))
 777           l = SIZEOF_SHA1 * 2, type = REPOKEY_TYPE_SHA1;
 778         else if (!strcasecmp (pd->tmpattr, "md5"))
 779           l = SIZEOF_MD5 * 2, type = REPOKEY_TYPE_MD5;
 780         else
 781           {
 782             fprintf(stderr, "Unknown checksum type: %d: %s\n", (unsigned int)XML_GetCurrentLineNumber(*pd->parser), pd->tmpattr);
 783             exit(1);
 784           }
 785         if (strlen(pd->content) != l)
 786           {
 787             fprintf(stderr, "Invalid checksum length: %d: for %s\n", (unsigned int)XML_GetCurrentLineNumber(*pd->parser), pd->tmpattr);
 788             exit(1);
 789           }
 790         repodata_set_checksum(pd->data, handle, SOLVABLE_CHECKSUM, type, pd->content);
 791       }
 792       break;
 793     case STATE_FILE:
 794 #if 0
 795       id = str2id(pool, pd->content, 1);
 796       s->provides = repo_addid_dep(repo, s->provides, id, SOLVABLE_FILEMARKER);
 797 #endif
 798       if ((p = strrchr(pd->content, '/')) != 0)
 799         {
 800           *p++ = 0;
 801           id = repodata_str2dir(pd->data, pd->content, 1);
 802         }
 803       else
 804         {
 805           p = pd->content;
 806           id = 0;
 807         }
 808       if (!id)
 809         id = repodata_str2dir(pd->data, "/", 1);
 810       repodata_add_dirstr(pd->data, handle, SOLVABLE_FILELIST, id, p);
 811       break;
 812     case STATE_SUMMARY:
 813       pd->lang = 0;
 814       repodata_set_str(pd->data, handle, SOLVABLE_SUMMARY, pd->content);
 815       break;
 816     case STATE_DESCRIPTION:
 817       pd->lang = 0;
 818       set_desciption_author(pd->data, handle, pd->content);
 819       break;
 820     case STATE_DISTRIBUTION:
 821         repodata_set_poolstr(pd->data, handle, SOLVABLE_DISTRIBUTION, pd->content);
 822         break;
 823     case STATE_URL:
 824       if (pd->content[0])
 825         repodata_set_str(pd->data, handle, SOLVABLE_URL, pd->content);
 826       break;
 827     case STATE_PACKAGER:
 828       if (pd->content[0])
 829         repodata_set_poolstr(pd->data, handle, SOLVABLE_PACKAGER, pd->content);
 830       break;
 831     case STATE_SOURCERPM:
 832       set_sourcerpm(pd->data, s, handle, pd->content);
 833       break;
 834     case STATE_RELNOTESURL:
 835       if (pd->content[0])
 836           repodata_set_poolstr(pd->data, handle, PRODUCT_RELNOTESURL, pd->content);
 837       break;
 838     case STATE_UPDATEURL:
 839       if (pd->content[0])
 840           repodata_set_poolstr(pd->data, handle, PRODUCT_EXTRAURLS, pd->content);
 841       break;
 842     case STATE_OPTIONALURL:
 843       if (pd->content[0])
 844           repodata_set_poolstr(pd->data, handle, PRODUCT_OPTIONALURLS, pd->content);
 845       break;
 846     case STATE_FLAG:
 847       if (pd->content[0])
 848           repodata_set_poolstr(pd->data, handle, PRODUCT_FLAGS, pd->content);
 849       break;
 850     case STATE_FLAVOR:
 851       if (pd->content[0])
 852         repodata_set_str(pd->data, handle, PRODUCT_FLAVOR, pd->content);
 853       break;
 854     case STATE_REFERENCES:
 855       if (pd->content[0])
 856         repodata_set_str(pd->data, handle, PRODUCT_REFERENCES, pd->content);
 857       break;
 858     default:
 859       break;
 860     }
 861   pd->state = pd->sbtab[pd->state];
 862   pd->docontent = 0;
 863   // fprintf(stderr, "back from known %d %d %d\n", pd->state, pd->depth, pd->statedepth);
 864 }
 865
 866
 867 /*
 868  * characterData
 869  * XML callback
 870  *
 871  */
 872
 873 static void XMLCALL
 874 characterData(void *userData, const XML_Char *s, int len)
 875 {
 876   struct parsedata *pd = userData;
 877   int l;
 878   char *c;
 879
 880   if (!pd->docontent)
 881     return;
 882   l = pd->lcontent + len + 1;
 883   if (l > pd->acontent)
 884     {
 885       pd->content = sat_realloc(pd->content, l + 256);
 886       pd->acontent = l + 256;
 887     }
 888   c = pd->content + pd->lcontent;
 889   pd->lcontent += len;
 890   while (len-- > 0)
 891     *c++ = *s++;
 892   *c = 0;
 893 }
 894
 895
 896 /*-----------------------------------------------*/
 897 /* 'main' */
 898
 899 #define BUFF_SIZE 8192
 900
 901 /*
 902  * repo_add_rpmmd
 903  * parse rpm-md metadata (primary, others, diskusage, translations)
 904  *
 905  */
 906
 907 void
 908 repo_add_rpmmd(Repo *repo, FILE *fp, int flags)
 909 {
 910   Pool *pool = repo->pool;
 911   struct parsedata pd;
 912   char buf[BUFF_SIZE];
 913   int i, l;
 914   struct stateswitch *sw;
 915
 916   memset(&pd, 0, sizeof(pd));
 917   for (i = 0, sw = stateswitches; sw->from != NUMSTATES; i++, sw++)
 918     {
 919       if (!pd.swtab[sw->from])
 920         pd.swtab[sw->from] = sw;
 921       pd.sbtab[sw->to] = sw->from;
 922     }
 923   pd.common.pool = pool;
 924   pd.common.repo = repo;
 925
 926   pd.data = repo_add_repodata(repo, 0);
 927
 928   pd.content = sat_malloc(256);
 929   pd.acontent = 256;
 930   pd.lcontent = 0;
 931   pd.common.tmp = 0;
 932   pd.common.tmpl = 0;
 933   pd.kind = 0;
 934   XML_Parser parser = XML_ParserCreate(NULL);
 935   XML_SetUserData(parser, &pd);
 936   pd.parser = &parser;
 937   XML_SetElementHandler(parser, startElement, endElement);
 938   XML_SetCharacterDataHandler(parser, characterData);
 939   for (;;)
 940     {
 941       l = fread(buf, 1, sizeof(buf), fp);
 942       if (XML_Parse(parser, buf, l, l == 0) == XML_STATUS_ERROR)
 943         {
 944           fprintf(stderr, "repo_rpmmd: %s at line %u:%u\n", XML_ErrorString(XML_GetErrorCode(parser)), (unsigned int)XML_GetCurrentLineNumber(parser), (unsigned int)XML_GetCurrentColumnNumber(parser));
 945           exit(1);
 946         }
 947       if (l == 0)
 948         break;
 949     }
 950   XML_ParserFree(parser);
 951
 952   if (pd.data)
 953     repodata_internalize(pd.data);
 954   sat_free(pd.content);
 955   join_freemem();
 956 }