tools/repo_patchxml.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 "repo_patchxml.h"
  19 #include "repo_rpmmd.h"
  20
  21 //#define TESTMM
  22
  23 enum state {
  24   STATE_START,
  25   STATE_PATCH,
  26   STATE_ATOM,
  27   STATE_NAME,
  28   STATE_ARCH,
  29   STATE_VERSION,
  30   STATE_PKGFILES,
  31   STATE_DELTARPM,
  32   STATE_DLOCATION,
  33   STATE_DCHECKSUM,
  34   STATE_DTIME,
  35   STATE_DSIZE,
  36   STATE_DBASEVERSION,
  37   STATE_REQUIRES,
  38   STATE_REQUIRESENTRY,
  39   STATE_PROVIDES,
  40   STATE_PROVIDESENTRY,
  41   STATE_OBSOLETES,
  42   STATE_OBSOLETESENTRY,
  43   STATE_CONFLICTS,
  44   STATE_CONFLICTSENTRY,
  45   STATE_RECOMMENDS,
  46   STATE_RECOMMENDSENTRY,
  47   STATE_SUPPLEMENTS,
  48   STATE_SUPPLEMENTSENTRY,
  49   STATE_SUGGESTS,
  50   STATE_SUGGESTSENTRY,
  51   STATE_ENHANCES,
  52   STATE_ENHANCESENTRY,
  53   STATE_FRESHENS,
  54   STATE_FRESHENSENTRY,
  55   NUMSTATES
  56 };
  57
  58
  59 struct stateswitch {
  60   enum state from;
  61   char *ename;
  62   enum state to;
  63   int docontent;
  64 };
  65
  66 static struct stateswitch stateswitches[] = {
  67   { STATE_START,       "patch",           STATE_PATCH, 0 },
  68   { STATE_START,       "package",         STATE_ATOM, 0 },
  69   { STATE_START,       "patches",         STATE_START, 0},
  70   { STATE_PATCH,       "yum:name",        STATE_NAME, 1 },
  71   { STATE_PATCH,       "yum:arch",        STATE_ARCH, 1 },
  72   { STATE_PATCH,       "yum:version",     STATE_VERSION, 0 },
  73   { STATE_PATCH,       "name",            STATE_NAME, 1 },
  74   { STATE_PATCH,       "arch",            STATE_ARCH, 1 },
  75   { STATE_PATCH,       "version",         STATE_VERSION, 0 },
  76   { STATE_PATCH,       "rpm:requires",    STATE_REQUIRES, 0 },
  77   { STATE_PATCH,       "rpm:provides",    STATE_PROVIDES, 0 },
  78   { STATE_PATCH,       "rpm:requires",    STATE_REQUIRES, 0 },
  79   { STATE_PATCH,       "rpm:obsoletes",   STATE_OBSOLETES , 0 },
  80   { STATE_PATCH,       "rpm:conflicts",   STATE_CONFLICTS , 0 },
  81   { STATE_PATCH,       "rpm:recommends" , STATE_RECOMMENDS , 0 },
  82   { STATE_PATCH,       "rpm:supplements", STATE_SUPPLEMENTS, 0 },
  83   { STATE_PATCH,       "rpm:suggests",    STATE_SUGGESTS, 0 },
  84   { STATE_PATCH,       "rpm:enhances",    STATE_ENHANCES, 0 },
  85   { STATE_PATCH,       "rpm:freshens",    STATE_FRESHENS, 0 },
  86   { STATE_PATCH,       "suse:freshens",   STATE_FRESHENS, 0 },
  87   { STATE_PATCH,       "atoms",           STATE_START, 0 },
  88   { STATE_PATCH,       "pkgfiles",        STATE_PKGFILES, 0 },
  89   { STATE_PKGFILES,    "deltarpm",        STATE_DELTARPM, 0 },
  90   { STATE_PKGFILES,    "patchrpm",        STATE_DELTARPM, 0 },
  91   { STATE_DELTARPM,    "location",        STATE_DLOCATION, 0 },
  92   { STATE_DELTARPM,    "checksum",        STATE_DCHECKSUM, 1 },
  93   { STATE_DELTARPM,    "time",            STATE_DTIME, 0 },
  94   { STATE_DELTARPM,    "size",            STATE_DSIZE, 0 },
  95   { STATE_DELTARPM,    "base-version",    STATE_DBASEVERSION, 0 },
  96   { STATE_PROVIDES,    "rpm:entry",       STATE_PROVIDESENTRY, 0 },
  97   { STATE_REQUIRES,    "rpm:entry",       STATE_REQUIRESENTRY, 0 },
  98   { STATE_OBSOLETES,   "rpm:entry",       STATE_OBSOLETESENTRY, 0 },
  99   { STATE_CONFLICTS,   "rpm:entry",       STATE_CONFLICTSENTRY, 0 },
 100   { STATE_RECOMMENDS,  "rpm:entry",       STATE_RECOMMENDSENTRY, 0 },
 101   { STATE_SUPPLEMENTS, "rpm:entry",       STATE_SUPPLEMENTSENTRY, 0 },
 102   { STATE_SUGGESTS,    "rpm:entry",       STATE_SUGGESTSENTRY, 0 },
 103   { STATE_ENHANCES,    "rpm:entry",       STATE_ENHANCESENTRY, 0 },
 104   { STATE_FRESHENS,    "rpm:entry",       STATE_FRESHENSENTRY, 0 },
 105   { STATE_FRESHENS,    "suse:entry",      STATE_FRESHENSENTRY, 0 },
 106   { NUMSTATES}
 107 };
 108
 109 /* Cumulated info about the current deltarpm or patchrpm */
 110 struct deltarpm {
 111   Id locdir;
 112   Id locname;
 113   Id locevr;
 114   Id locsuffix;
 115   unsigned buildtime;
 116   unsigned downloadsize, archivesize;
 117   char *filechecksum;
 118   /* Baseversions.  deltarpm only has one, patchrpm may have more.  */
 119   Id *bevr;
 120   unsigned nbevr;
 121   /* If deltarpm, then this is filled.  */
 122   char *sequence_info;
 123 };
 124
 125 struct parsedata {
 126   int depth;
 127   enum state state;
 128   int statedepth;
 129   char *content;
 130   int lcontent;
 131   int acontent;
 132   int docontent;
 133   Pool *pool;
 134   Repo *repo;
 135   Solvable *solvable;
 136   char *kind;
 137
 138   struct stateswitch *swtab[NUMSTATES];
 139   enum state sbtab[NUMSTATES];
 140   char *tempstr;
 141   int ltemp;
 142   int atemp;
 143   struct deltarpm delta;
 144 };
 145
 146 static void
 147 append_str(struct parsedata *pd, const char *s)
 148 {
 149   if (!s)
 150     return;
 151   int l = pd->ltemp + strlen(s) + 1;
 152   if (l > pd->atemp)
 153     {
 154       pd->tempstr = realloc(pd->tempstr, l + 256);
 155       pd->atemp = l + 256;
 156     }
 157   strcpy(pd->tempstr + pd->ltemp, s);
 158   pd->ltemp += strlen(s);
 159 }
 160
 161 static Id
 162 makeevr_atts(Pool *pool, struct parsedata *pd, const char **atts)
 163 {
 164   const char *e, *v, *r, *v2;
 165   char *c;
 166   int l;
 167
 168   e = v = r = 0;
 169   for (; *atts; atts += 2)
 170     {
 171       if (!strcmp(*atts, "epoch"))
 172         e = atts[1];
 173       else if (!strcmp(*atts, "ver"))
 174         v = atts[1];
 175       else if (!strcmp(*atts, "rel"))
 176         r = atts[1];
 177     }
 178   if (e && !strcmp(e, "0"))
 179     e = 0;
 180   if (v && !e)
 181     {
 182       for (v2 = v; *v2 >= '0' && *v2 <= '9'; v2++)
 183         ;
 184       if (v2 > v && *v2 == ':')
 185         e = "0";
 186     }
 187   l = 1;
 188   if (e)
 189     l += strlen(e) + 1;
 190   if (v)
 191     l += strlen(v);
 192   if (r)
 193     l += strlen(r) + 1;
 194   if (l > pd->acontent)
 195     {
 196       pd->content = realloc(pd->content, l + 256);
 197       pd->acontent = l + 256;
 198     }
 199   c = pd->content;
 200   if (e)
 201     {
 202       strcpy(c, e);
 203       c += strlen(c);
 204       *c++ = ':';
 205     }
 206   if (v)
 207     {
 208       strcpy(c, v);
 209       c += strlen(c);
 210     }
 211   if (r)
 212     {
 213       *c++ = '-';
 214       strcpy(c, r);
 215       c += strlen(c);
 216     }
 217   *c = 0;
 218   if (!*pd->content)
 219     return 0;
 220 #if 0
 221   fprintf(stderr, "evr: %s\n", pd->content);
 222 #endif
 223   return str2id(pool, pd->content, 1);
 224 }
 225
 226 static const char *
 227 find_attr(const char *txt, const char **atts)
 228 {
 229   for (; *atts; atts += 2)
 230     {
 231       if (!strcmp(*atts, txt))
 232         return atts[1];
 233     }
 234   return 0;
 235 }
 236
 237 static char *flagtab[] = {
 238   "GT",
 239   "EQ",
 240   "GE",
 241   "LT",
 242   "NE",
 243   "LE"
 244 };
 245
 246 static unsigned int
 247 adddep(Pool *pool, struct parsedata *pd, unsigned int olddeps, const char **atts, int isreq)
 248 {
 249   Id id, name, marker;
 250   const char *n, *f, *k;
 251   const char **a;
 252
 253   n = f = k = 0;
 254   marker = isreq ? -SOLVABLE_PREREQMARKER : 0;
 255   for (a = atts; *a; a += 2)
 256     {
 257       if (!strcmp(*a, "name"))
 258         n = a[1];
 259       else if (!strcmp(*a, "flags"))
 260         f = a[1];
 261       else if (!strcmp(*a, "kind"))
 262         k = a[1];
 263       else if (isreq && !strcmp(*a, "pre") && a[1][0] == '1')
 264         marker = SOLVABLE_PREREQMARKER;
 265     }
 266   if (!n)
 267     return olddeps;
 268   if (k && !strcmp(k, "package"))
 269     k = 0;
 270   if (k)
 271     {
 272       int l = strlen(k) + 1 + strlen(n) + 1;
 273       if (l > pd->acontent)
 274         {
 275           pd->content = realloc(pd->content, l + 256);
 276           pd->acontent = l + 256;
 277         }
 278       sprintf(pd->content, "%s:%s", k, n);
 279       name = str2id(pool, pd->content, 1);
 280     }
 281   else
 282     name = str2id(pool, (char *)n, 1);
 283   if (f)
 284     {
 285       Id evr = makeevr_atts(pool, pd, atts);
 286       int flags;
 287       for (flags = 0; flags < 6; flags++)
 288         if (!strcmp(f, flagtab[flags]))
 289           break;
 290       flags = flags < 6 ? flags + 1 : 0;
 291       id = rel2id(pool, name, evr, flags, 1);
 292     }
 293   else
 294     id = name;
 295 #if 0
 296   fprintf(stderr, "new dep %s%s%s\n", id2str(pool, d), id2rel(pool, d), id2evr(pool, d));
 297 #endif
 298   return repo_addid_dep(pd->repo, olddeps, id, marker);
 299 }
 300
 301
 302 static void XMLCALL
 303 startElement(void *userData, const char *name, const char **atts)
 304 {
 305   struct parsedata *pd = userData;
 306   Pool *pool = pd->pool;
 307   Solvable *s = pd->solvable;
 308   struct stateswitch *sw;
 309   const char *str;
 310
 311   if (pd->depth != pd->statedepth)
 312     {
 313       pd->depth++;
 314       return;
 315     }
 316
 317   if (pd->state == STATE_PATCH && !strcmp(name, "format"))
 318     return;
 319
 320   pd->depth++;
 321   for (sw = pd->swtab[pd->state]; sw->from == pd->state; sw++)
 322     if (!strcmp(sw->ename, name))
 323       break;
 324   if (sw->from != pd->state)
 325     {
 326 #if 0
 327       fprintf(stderr, "into unknown: %s\n", name);
 328 #endif
 329       return;
 330     }
 331   pd->state = sw->to;
 332   pd->docontent = sw->docontent;
 333   pd->statedepth = pd->depth;
 334   pd->lcontent = 0;
 335   *pd->content = 0;
 336   switch(pd->state)
 337     {
 338     case STATE_NAME:
 339       if (pd->kind)
 340         {
 341           strcpy(pd->content, pd->kind);
 342           pd->lcontent = strlen(pd->content);
 343           pd->content[pd->lcontent++] = ':';
 344           pd->content[pd->lcontent] = 0;
 345         }
 346       break;
 347     case STATE_PATCH:
 348     case STATE_ATOM:
 349       if (pd->state == STATE_ATOM)
 350         {
 351           /* HACK: close patch */
 352           if (pd->kind && !strcmp(pd->kind, "patch"))
 353             {
 354               if (!s->arch)
 355                 s->arch = ARCH_NOARCH;
 356               s->provides = repo_addid_dep(pd->repo, s->provides, rel2id(pool, s->name, s->evr, REL_EQ, 1), 0);
 357             }
 358           pd->kind = "atom";
 359           pd->state = STATE_PATCH;
 360         }
 361       else
 362         pd->kind = "patch";
 363
 364       pd->solvable = pool_id2solvable(pool, repo_add_solvable(pd->repo));
 365 #if 0
 366       fprintf(stderr, "package #%d\n", pd->solvable - pool->solvables);
 367 #endif
 368       break;
 369     case STATE_DELTARPM:
 370       memset(&pd->delta, 0, sizeof (pd->delta));
 371       *pd->tempstr = 0;
 372       pd->ltemp = 0;
 373       break;
 374     case STATE_DLOCATION:
 375       if ((str = find_attr("href", atts)))
 376         {
 377           /* Separate the filename into its different parts.
 378              rpm/x86_64/alsa-1.0.14-31_31.2.x86_64.delta.rpm
 379              --> dir = rpm/x86_64
 380                  name = alsa
 381                  evr = 1.0.14-31_31.2
 382                  suffix = x86_64.delta.rpm.  */
 383           char *real_str = strdup(str);
 384           char *s = real_str;
 385           char *s1, *s2;
 386           s1 = strrchr (s, '/');
 387           if (s1)
 388             {
 389               pd->delta.locdir = strn2id(pool, s, s1 - s, 1);
 390               s = s1 + 1;
 391             }
 392           /* Guess suffix.  */
 393           s1 = strrchr (s, '.');
 394           if (s1)
 395             {
 396               for (s2 = s1 - 1; s2 > s; s2--)
 397                 if (*s2 == '.')
 398                   break;
 399               if (!strcmp (s2, ".delta.rpm") || !strcmp (s2, ".patch.rpm"))
 400                 {
 401                   s1 = s2;
 402                   /* We accept one more item as suffix.  */
 403                   for (s2 = s1 - 1; s2 > s; s2--)
 404                     if (*s2 == '.')
 405                       break;
 406                   s1 = s2;
 407                 }
 408               if (*s1 == '.')
 409                 *s1++ = 0;
 410               pd->delta.locsuffix = str2id(pool, s1, 1);
 411             }
 412           /* Last '-'.  */
 413           s1 = strrchr (s, '-');
 414           if (s1)
 415             {
 416               /* Second to last '-'.  */
 417               for (s2 = s1 - 1; s2 > s; s2--)
 418                 if (*s2 == '-')
 419                   break;
 420             }
 421           else
 422             s2 = 0;
 423           if (s2 > s && *s2 == '-')
 424             {
 425               *s2++ = 0;
 426               pd->delta.locevr = str2id(pool, s2, 1);
 427             }
 428           pd->delta.locname = str2id(pool, s, 1);
 429           free(real_str);
 430         }
 431       break;
 432     case STATE_DTIME:
 433       str = find_attr("build", atts);
 434       if (str)
 435         pd->delta.buildtime = atoi(str);
 436       break;
 437     case STATE_DSIZE:
 438       if ((str = find_attr("package", atts)))
 439         pd->delta.downloadsize = atoi(str);
 440       if ((str = find_attr("archive", atts)))
 441         pd->delta.archivesize = atoi(str);
 442       break;
 443     case STATE_DBASEVERSION:
 444       if ((str = find_attr("sequence_info", atts)))
 445         pd->delta.sequence_info = strdup(str);
 446       pd->delta.nbevr++;
 447       pd->delta.bevr = sat_realloc (pd->delta.bevr, pd->delta.nbevr * sizeof(Id));
 448       pd->delta.bevr[pd->delta.nbevr - 1] = makeevr_atts(pool, pd, atts);
 449       break;
 450     case STATE_VERSION:
 451       s->evr = makeevr_atts(pool, pd, atts);
 452       break;
 453     case STATE_PROVIDES:
 454       s->provides = 0;
 455       break;
 456     case STATE_PROVIDESENTRY:
 457       s->provides = adddep(pool, pd, s->provides, atts, 0);
 458       break;
 459     case STATE_REQUIRES:
 460       s->requires = 0;
 461       break;
 462     case STATE_REQUIRESENTRY:
 463       s->requires = adddep(pool, pd, s->requires, atts, 1);
 464       break;
 465     case STATE_OBSOLETES:
 466       s->obsoletes = 0;
 467       break;
 468     case STATE_OBSOLETESENTRY:
 469       s->obsoletes = adddep(pool, pd, s->obsoletes, atts, 0);
 470       break;
 471     case STATE_CONFLICTS:
 472       s->conflicts = 0;
 473       break;
 474     case STATE_CONFLICTSENTRY:
 475       s->conflicts = adddep(pool, pd, s->conflicts, atts, 0);
 476       break;
 477     case STATE_RECOMMENDS:
 478       s->recommends = 0;
 479       break;
 480     case STATE_RECOMMENDSENTRY:
 481       s->recommends = adddep(pool, pd, s->recommends, atts, 0);
 482       break;
 483     case STATE_SUPPLEMENTS:
 484       s->supplements= 0;
 485       break;
 486     case STATE_SUPPLEMENTSENTRY:
 487       s->supplements = adddep(pool, pd, s->supplements, atts, 0);
 488       break;
 489     case STATE_SUGGESTS:
 490       s->suggests = 0;
 491       break;
 492     case STATE_SUGGESTSENTRY:
 493       s->suggests = adddep(pool, pd, s->suggests, atts, 0);
 494       break;
 495     case STATE_ENHANCES:
 496       s->enhances = 0;
 497       break;
 498     case STATE_ENHANCESENTRY:
 499       s->enhances = adddep(pool, pd, s->enhances, atts, 0);
 500       break;
 501     case STATE_FRESHENS:
 502       s->freshens = 0;
 503       break;
 504     case STATE_FRESHENSENTRY:
 505       s->freshens = adddep(pool, pd, s->freshens, atts, 0);
 506       break;
 507     default:
 508       break;
 509     }
 510 }
 511
 512 static void XMLCALL
 513 endElement(void *userData, const char *name)
 514 {
 515   struct parsedata *pd = userData;
 516   Pool *pool = pd->pool;
 517   Solvable *s = pd->solvable;
 518
 519   if (pd->depth != pd->statedepth)
 520     {
 521       pd->depth--;
 522       // printf("back from unknown %d %d %d\n", pd->state, pd->depth, pd->statedepth);
 523       return;
 524     }
 525
 526   if (pd->state == STATE_PATCH && !strcmp(name, "format"))
 527     return;
 528
 529   pd->depth--;
 530   pd->statedepth--;
 531   switch (pd->state)
 532     {
 533     case STATE_PATCH:
 534       if (!strcmp(name, "patch") && strcmp(pd->kind, "patch"))
 535         break;  /* already closed */
 536       if (!s->arch)
 537         s->arch = ARCH_NOARCH;
 538       if (s->arch != ARCH_SRC && s->arch != ARCH_NOSRC)
 539         s->provides = repo_addid_dep(pd->repo, s->provides, rel2id(pool, s->name, s->evr, REL_EQ, 1), 0);
 540       s->supplements = repo_fix_legacy(pd->repo, s->provides, s->supplements);
 541       break;
 542     case STATE_NAME:
 543       s->name = str2id(pool, pd->content, 1);
 544       break;
 545     case STATE_ARCH:
 546       s->arch = str2id(pool, pd->content, 1);
 547       break;
 548     case STATE_DELTARPM:
 549 #ifdef TESTMM
 550       {
 551         int i;
 552         struct deltarpm *d = &pd->delta;
 553         fprintf (stderr, "found deltarpm for %s:\n", id2str(pool, s->name));
 554         fprintf (stderr, "   loc: %s %s %s %s\n", id2str(pool, d->locdir),
 555                  id2str(pool, d->locname), id2str(pool, d->locevr),
 556                  id2str(pool, d->locsuffix));
 557         fprintf (stderr, "  time: %u\n", d->buildtime);
 558         fprintf (stderr, "  size: %d down, %d archive\n", d->downloadsize,
 559                  d->archivesize);
 560         fprintf (stderr, "  chek: %s\n", d->filechecksum);
 561         if (d->sequence_info)
 562           {
 563             fprintf (stderr, "  base: %s, seq: %s\n", id2str(pool, d->bevr[0]),
 564                      d->sequence_info);
 565           }
 566         else
 567           {
 568             fprintf (stderr, "  base:");
 569             for (i = 0; i < d->nbevr; i++)
 570               fprintf (stderr, " %s", id2str(pool, d->bevr[i]));
 571             fprintf (stderr, "\n");
 572           }
 573       }
 574 #endif
 575       free(pd->delta.filechecksum);
 576       free(pd->delta.bevr);
 577       free(pd->delta.sequence_info);
 578       break;
 579     case STATE_DCHECKSUM:
 580       pd->delta.filechecksum = strdup(pd->content);
 581       break;
 582     default:
 583       break;
 584     }
 585   pd->state = pd->sbtab[pd->state];
 586   pd->docontent = 0;
 587   // printf("back from known %d %d %d\n", pd->state, pd->depth, pd->statedepth);
 588 }
 589
 590 static void XMLCALL
 591 characterData(void *userData, const XML_Char *s, int len)
 592 {
 593   struct parsedata *pd = userData;
 594   int l;
 595   char *c;
 596
 597   if (!pd->docontent)
 598     return;
 599   l = pd->lcontent + len + 1;
 600   if (l > pd->acontent)
 601     {
 602       pd->content = realloc(pd->content, l + 256);
 603       pd->acontent = l + 256;
 604     }
 605   c = pd->content + pd->lcontent;
 606   pd->lcontent += len;
 607   while (len-- > 0)
 608     *c++ = *s++;
 609   *c = 0;
 610 }
 611
 612
 613 #define BUFF_SIZE 8192
 614
 615 void
 616 repo_add_patchxml(Repo *repo, FILE *fp, int flags)
 617 {
 618   Pool *pool = repo->pool;
 619   struct parsedata pd;
 620   char buf[BUFF_SIZE];
 621   int i, l;
 622   struct stateswitch *sw;
 623
 624   memset(&pd, 0, sizeof(pd));
 625   for (i = 0, sw = stateswitches; sw->from != NUMSTATES; i++, sw++)
 626     {
 627       if (!pd.swtab[sw->from])
 628         pd.swtab[sw->from] = sw;
 629       pd.sbtab[sw->to] = sw->from;
 630     }
 631   pd.pool = pool;
 632   pd.repo = repo;
 633   pd.content = malloc(256);
 634   pd.acontent = 256;
 635   pd.lcontent = 0;
 636   pd.tempstr = malloc(256);
 637   pd.atemp = 256;
 638   pd.ltemp = 0;
 639   XML_Parser parser = XML_ParserCreate(NULL);
 640   XML_SetUserData(parser, &pd);
 641   XML_SetElementHandler(parser, startElement, endElement);
 642   XML_SetCharacterDataHandler(parser, characterData);
 643   for (;;)
 644     {
 645       l = fread(buf, 1, sizeof(buf), fp);
 646       if (XML_Parse(parser, buf, l, l == 0) == XML_STATUS_ERROR)
 647         {
 648           fprintf(stderr, "repo_patchxml: %s at line %u\n", XML_ErrorString(XML_GetErrorCode(parser)), (unsigned int)XML_GetCurrentLineNumber(parser));
 649           exit(1);
 650         }
 651       if (l == 0)
 652         break;
 653     }
 654   XML_ParserFree(parser);
 655
 656   free(pd.content);
 657 }