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