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