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_patchxml.h"
  18 #include "repo_rpmmd.h"
  19
  20
  21 enum state {
  22   STATE_START,
  23   STATE_PATCH,
  24   STATE_ATOM,
  25   STATE_NAME,
  26   STATE_ARCH,
  27   STATE_VERSION,
  28   STATE_REQUIRES,
  29   STATE_REQUIRESENTRY,
  30   STATE_PROVIDES,
  31   STATE_PROVIDESENTRY,
  32   STATE_OBSOLETES,
  33   STATE_OBSOLETESENTRY,
  34   STATE_CONFLICTS,
  35   STATE_CONFLICTSENTRY,
  36   STATE_RECOMMENDS,
  37   STATE_RECOMMENDSENTRY,
  38   STATE_SUPPLEMENTS,
  39   STATE_SUPPLEMENTSENTRY,
  40   STATE_SUGGESTS,
  41   STATE_SUGGESTSENTRY,
  42   STATE_ENHANCES,
  43   STATE_ENHANCESENTRY,
  44   STATE_FRESHENS,
  45   STATE_FRESHENSENTRY,
  46   NUMSTATES
  47 };
  48
  49 #define PACK_BLOCK 255
  50
  51
  52 struct stateswitch {
  53   enum state from;
  54   char *ename;
  55   enum state to;
  56   int docontent;
  57 };
  58
  59 static struct stateswitch stateswitches[] = {
  60   { STATE_START,       "patch",           STATE_PATCH, 0 },
  61   { STATE_START,       "package",         STATE_ATOM, 0 },
  62   { STATE_START,       "patches",         STATE_START, 0},
  63   { STATE_PATCH,       "yum:name",        STATE_NAME, 1 },
  64   { STATE_PATCH,       "yum:arch",        STATE_ARCH, 1 },
  65   { STATE_PATCH,       "yum:version",     STATE_VERSION, 0 },
  66   { STATE_PATCH,       "name",            STATE_NAME, 1 },
  67   { STATE_PATCH,       "arch",            STATE_ARCH, 1 },
  68   { STATE_PATCH,       "version",         STATE_VERSION, 0 },
  69   { STATE_PATCH,       "rpm:requires",    STATE_REQUIRES, 0 },
  70   { STATE_PATCH,       "rpm:provides",    STATE_PROVIDES, 0 },
  71   { STATE_PATCH,       "rpm:requires",    STATE_REQUIRES, 0 },
  72   { STATE_PATCH,       "rpm:obsoletes",   STATE_OBSOLETES , 0 },
  73   { STATE_PATCH,       "rpm:conflicts",   STATE_CONFLICTS , 0 },
  74   { STATE_PATCH,       "rpm:recommends" , STATE_RECOMMENDS , 0 },
  75   { STATE_PATCH,       "rpm:supplements", STATE_SUPPLEMENTS, 0 },
  76   { STATE_PATCH,       "rpm:suggests",    STATE_SUGGESTS, 0 },
  77   { STATE_PATCH,       "rpm:enhances",    STATE_ENHANCES, 0 },
  78   { STATE_PATCH,       "rpm:freshens",    STATE_FRESHENS, 0 },
  79   { STATE_PATCH,       "suse:freshens",   STATE_FRESHENS, 0 },
  80   { STATE_PATCH,       "atoms",           STATE_START, 0 },
  81   { STATE_PROVIDES,    "rpm:entry",       STATE_PROVIDESENTRY, 0 },
  82   { STATE_REQUIRES,    "rpm:entry",       STATE_REQUIRESENTRY, 0 },
  83   { STATE_OBSOLETES,   "rpm:entry",       STATE_OBSOLETESENTRY, 0 },
  84   { STATE_CONFLICTS,   "rpm:entry",       STATE_CONFLICTSENTRY, 0 },
  85   { STATE_RECOMMENDS,  "rpm:entry",       STATE_RECOMMENDSENTRY, 0 },
  86   { STATE_SUPPLEMENTS, "rpm:entry",       STATE_SUPPLEMENTSENTRY, 0 },
  87   { STATE_SUGGESTS,    "rpm:entry",       STATE_SUGGESTSENTRY, 0 },
  88   { STATE_ENHANCES,    "rpm:entry",       STATE_ENHANCESENTRY, 0 },
  89   { STATE_FRESHENS,    "rpm:entry",       STATE_FRESHENSENTRY, 0 },
  90   { STATE_FRESHENS,    "suse:entry",      STATE_FRESHENSENTRY, 0 },
  91   { NUMSTATES}
  92 };
  93
  94 struct parsedata {
  95   int depth;
  96   enum state state;
  97   int statedepth;
  98   char *content;
  99   int lcontent;
 100   int acontent;
 101   int docontent;
 102   int pack;
 103   Pool *pool;
 104   Repo *repo;
 105   Solvable *start;
 106   char *kind;
 107
 108   struct stateswitch *swtab[NUMSTATES];
 109   enum state sbtab[NUMSTATES];
 110 };
 111
 112 static Id
 113 makeevr_atts(Pool *pool, struct parsedata *pd, const char **atts)
 114 {
 115   const char *e, *v, *r, *v2;
 116   char *c;
 117   int l;
 118
 119   e = v = r = 0;
 120   for (; *atts; atts += 2)
 121     {
 122       if (!strcmp(*atts, "epoch"))
 123         e = atts[1];
 124       else if (!strcmp(*atts, "ver"))
 125         v = atts[1];
 126       else if (!strcmp(*atts, "rel"))
 127         r = atts[1];
 128     }
 129   if (e && !strcmp(e, "0"))
 130     e = 0;
 131   if (v && !e)
 132     {
 133       for (v2 = v; *v2 >= '0' && *v2 <= '9'; v2++)
 134         ;
 135       if (v2 > v && *v2 == ':')
 136         e = "0";
 137     }
 138   l = 1;
 139   if (e)
 140     l += strlen(e) + 1;
 141   if (v)
 142     l += strlen(v);
 143   if (r)
 144     l += strlen(r) + 1;
 145   if (l > pd->acontent)
 146     {
 147       pd->content = realloc(pd->content, l + 256);
 148       pd->acontent = l + 256;
 149     }
 150   c = pd->content;
 151   if (e)
 152     {
 153       strcpy(c, e);
 154       c += strlen(c);
 155       *c++ = ':';
 156     }
 157   if (v)
 158     {
 159       strcpy(c, v);
 160       c += strlen(c);
 161     }
 162   if (r)
 163     {
 164       *c++ = '-';
 165       strcpy(c, r);
 166       c += strlen(c);
 167     }
 168   *c = 0;
 169   if (!*pd->content)
 170     return 0;
 171 #if 0
 172   fprintf(stderr, "evr: %s\n", pd->content);
 173 #endif
 174   return str2id(pool, pd->content, 1);
 175 }
 176
 177 static char *flagtab[] = {
 178   "GT",
 179   "EQ",
 180   "GE",
 181   "LT",
 182   "NE",
 183   "LE"
 184 };
 185
 186 static unsigned int
 187 adddep(Pool *pool, struct parsedata *pd, unsigned int olddeps, const char **atts, int isreq)
 188 {
 189   Id id, name;
 190   const char *n, *f, *k;
 191   const char **a;
 192
 193   n = f = k = 0;
 194   for (a = atts; *a; a += 2)
 195     {
 196       if (!strcmp(*a, "name"))
 197         n = a[1];
 198       else if (!strcmp(*a, "flags"))
 199         f = a[1];
 200       else if (!strcmp(*a, "kind"))
 201         k = a[1];
 202       else if (isreq && !strcmp(*a, "pre") && a[1][0] == '1')
 203         isreq = 2;
 204     }
 205   if (!n)
 206     return olddeps;
 207   if (k && !strcmp(k, "package"))
 208     k = 0;
 209   if (k)
 210     {
 211       int l = strlen(k) + 1 + strlen(n) + 1;
 212       if (l > pd->acontent)
 213         {
 214           pd->content = realloc(pd->content, l + 256);
 215           pd->acontent = l + 256;
 216         }
 217       sprintf(pd->content, "%s:%s", k, n);
 218       name = str2id(pool, pd->content, 1);
 219     }
 220   else
 221     name = str2id(pool, (char *)n, 1);
 222   if (f)
 223     {
 224       Id evr = makeevr_atts(pool, pd, atts);
 225       int flags;
 226       for (flags = 0; flags < 6; flags++)
 227         if (!strcmp(f, flagtab[flags]))
 228           break;
 229       flags = flags < 6 ? flags + 1 : 0;
 230       id = rel2id(pool, name, evr, flags, 1);
 231     }
 232   else
 233     id = name;
 234 #if 0
 235   fprintf(stderr, "new dep %s%s%s\n", id2str(pool, d), id2rel(pool, d), id2evr(pool, d));
 236 #endif
 237   return repo_addid_dep(pd->repo, olddeps, id, isreq);
 238 }
 239
 240
 241 static void XMLCALL
 242 startElement(void *userData, const char *name, const char **atts)
 243 {
 244   struct parsedata *pd = userData;
 245   Pool *pool = pd->pool;
 246   Solvable *s = pd->start ? pd->start + pd->pack : 0;
 247   struct stateswitch *sw;
 248
 249   if (pd->depth != pd->statedepth)
 250     {
 251       pd->depth++;
 252       return;
 253     }
 254
 255   if (pd->state == STATE_PATCH && !strcmp(name, "format"))
 256     return;
 257
 258   pd->depth++;
 259   for (sw = pd->swtab[pd->state]; sw->from == pd->state; sw++)
 260     if (!strcmp(sw->ename, name))
 261       break;
 262   if (sw->from != pd->state)
 263     {
 264 #if 0
 265       fprintf(stderr, "into unknown: %s\n", name);
 266 #endif
 267       return;
 268     }
 269   pd->state = sw->to;
 270   pd->docontent = sw->docontent;
 271   pd->statedepth = pd->depth;
 272   pd->lcontent = 0;
 273   *pd->content = 0;
 274   switch(pd->state)
 275     {
 276     case STATE_NAME:
 277       if (pd->kind)
 278         {
 279           strcpy(pd->content, pd->kind);
 280           pd->lcontent = strlen(pd->content);
 281           pd->content[pd->lcontent++] = ':';
 282           pd->content[pd->lcontent] = 0;
 283         }
 284       break;
 285     case STATE_PATCH:
 286     case STATE_ATOM:
 287       if (pd->state == STATE_ATOM)
 288         {
 289           /* HACK: close patch */
 290           if (pd->kind && !strcmp(pd->kind, "patch"))
 291             {
 292               s->repo = pd->repo;
 293               if (!s->arch)
 294                 s->arch = ARCH_NOARCH;
 295               s->provides = repo_addid_dep(pd->repo, s->provides, rel2id(pool, s->name, s->evr, REL_EQ, 1), 0);
 296               pd->pack++;
 297             }
 298           pd->kind = "atom";
 299           pd->state = STATE_PATCH;
 300         }
 301       else
 302         pd->kind = "patch";
 303       if ((pd->pack & PACK_BLOCK) == 0)
 304         {
 305           pool->solvables = realloc(pool->solvables, (pool->nsolvables + pd->pack + PACK_BLOCK + 1) * sizeof(Solvable));
 306           pd->start = pool->solvables + pool->nsolvables;
 307           memset(pd->start + pd->pack, 0, (PACK_BLOCK + 1) * sizeof(Solvable));
 308         }
 309 #if 0
 310       fprintf(stderr, "package #%d\n", pd->pack);
 311 #endif
 312       break;
 313     case STATE_VERSION:
 314       s->evr = makeevr_atts(pool, pd, atts);
 315       break;
 316     case STATE_PROVIDES:
 317       s->provides = 0;
 318       break;
 319     case STATE_PROVIDESENTRY:
 320       s->provides = adddep(pool, pd, s->provides, atts, 0);
 321       break;
 322     case STATE_REQUIRES:
 323       s->requires = 0;
 324       break;
 325     case STATE_REQUIRESENTRY:
 326       s->requires = adddep(pool, pd, s->requires, atts, 1);
 327       break;
 328     case STATE_OBSOLETES:
 329       s->obsoletes = 0;
 330       break;
 331     case STATE_OBSOLETESENTRY:
 332       s->obsoletes = adddep(pool, pd, s->obsoletes, atts, 0);
 333       break;
 334     case STATE_CONFLICTS:
 335       s->conflicts = 0;
 336       break;
 337     case STATE_CONFLICTSENTRY:
 338       s->conflicts = adddep(pool, pd, s->conflicts, atts, 0);
 339       break;
 340     case STATE_RECOMMENDS:
 341       s->recommends = 0;
 342       break;
 343     case STATE_RECOMMENDSENTRY:
 344       s->recommends = adddep(pool, pd, s->recommends, atts, 0);
 345       break;
 346     case STATE_SUPPLEMENTS:
 347       s->supplements= 0;
 348       break;
 349     case STATE_SUPPLEMENTSENTRY:
 350       s->supplements = adddep(pool, pd, s->supplements, atts, 0);
 351       break;
 352     case STATE_SUGGESTS:
 353       s->suggests = 0;
 354       break;
 355     case STATE_SUGGESTSENTRY:
 356       s->suggests = adddep(pool, pd, s->suggests, atts, 0);
 357       break;
 358     case STATE_ENHANCES:
 359       s->enhances = 0;
 360       break;
 361     case STATE_ENHANCESENTRY:
 362       s->enhances = adddep(pool, pd, s->enhances, atts, 0);
 363       break;
 364     case STATE_FRESHENS:
 365       s->freshens = 0;
 366       break;
 367     case STATE_FRESHENSENTRY:
 368       s->freshens = adddep(pool, pd, s->freshens, atts, 0);
 369       break;
 370     default:
 371       break;
 372     }
 373 }
 374
 375 static void XMLCALL
 376 endElement(void *userData, const char *name)
 377 {
 378   struct parsedata *pd = userData;
 379   Pool *pool = pd->pool;
 380   Solvable *s = pd->start ? pd->start + pd->pack : 0;
 381
 382   if (pd->depth != pd->statedepth)
 383     {
 384       pd->depth--;
 385       // printf("back from unknown %d %d %d\n", pd->state, pd->depth, pd->statedepth);
 386       return;
 387     }
 388
 389   if (pd->state == STATE_PATCH && !strcmp(name, "format"))
 390     return;
 391
 392   pd->depth--;
 393   pd->statedepth--;
 394   switch (pd->state)
 395     {
 396     case STATE_PATCH:
 397       if (!strcmp(name, "patch") && strcmp(pd->kind, "patch"))
 398         break;  /* already closed */
 399       s->repo = pd->repo;
 400       if (!s->arch)
 401         s->arch = ARCH_NOARCH;
 402       if (s->arch != ARCH_SRC && s->arch != ARCH_NOSRC)
 403         s->provides = repo_addid_dep(pd->repo, s->provides, rel2id(pool, s->name, s->evr, REL_EQ, 1), 0);
 404       s->supplements = repo_fix_legacy(pd->repo, s->provides, s->supplements);
 405       pd->pack++;
 406       break;
 407     case STATE_NAME:
 408       s->name = str2id(pool, pd->content, 1);
 409       break;
 410     case STATE_ARCH:
 411       s->arch = str2id(pool, pd->content, 1);
 412       break;
 413     default:
 414       break;
 415     }
 416   pd->state = pd->sbtab[pd->state];
 417   pd->docontent = 0;
 418   // printf("back from known %d %d %d\n", pd->state, pd->depth, pd->statedepth);
 419 }
 420
 421 static void XMLCALL
 422 characterData(void *userData, const XML_Char *s, int len)
 423 {
 424   struct parsedata *pd = userData;
 425   int l;
 426   char *c;
 427
 428   if (!pd->docontent)
 429     return;
 430   l = pd->lcontent + len + 1;
 431   if (l > pd->acontent)
 432     {
 433       pd->content = realloc(pd->content, l + 256);
 434       pd->acontent = l + 256;
 435     }
 436   c = pd->content + pd->lcontent;
 437   pd->lcontent += len;
 438   while (len-- > 0)
 439     *c++ = *s++;
 440   *c = 0;
 441 }
 442
 443
 444 #define BUFF_SIZE 8192
 445
 446 void
 447 repo_add_patchxml(Repo *repo, FILE *fp)
 448 {
 449   Pool *pool = repo->pool;
 450   struct parsedata pd;
 451   char buf[BUFF_SIZE];
 452   int i, l;
 453   struct stateswitch *sw;
 454
 455   if (repo->start && repo->start + repo->nsolvables != pool->nsolvables)
 456     abort();
 457   if (!repo->start)
 458     repo->start = pool->nsolvables;
 459
 460   memset(&pd, 0, sizeof(pd));
 461   for (i = 0, sw = stateswitches; sw->from != NUMSTATES; i++, sw++)
 462     {
 463       if (!pd.swtab[sw->from])
 464         pd.swtab[sw->from] = sw;
 465       pd.sbtab[sw->to] = sw->from;
 466     }
 467   pd.pool = pool;
 468   pd.repo = repo;
 469   pd.content = malloc(256);
 470   pd.acontent = 256;
 471   pd.lcontent = 0;
 472   XML_Parser parser = XML_ParserCreate(NULL);
 473   XML_SetUserData(parser, &pd);
 474   XML_SetElementHandler(parser, startElement, endElement);
 475   XML_SetCharacterDataHandler(parser, characterData);
 476   for (;;)
 477     {
 478       l = fread(buf, 1, sizeof(buf), fp);
 479       if (XML_Parse(parser, buf, l, l == 0) == XML_STATUS_ERROR)
 480         {
 481           fprintf(stderr, "%s at line %u\n", XML_ErrorString(XML_GetErrorCode(parser)), (unsigned int)XML_GetCurrentLineNumber(parser));
 482           exit(1);
 483         }
 484       if (l == 0)
 485         break;
 486     }
 487   XML_ParserFree(parser);
 488
 489   pool->nsolvables += pd.pack;
 490   repo->nsolvables += pd.pack;
 491
 492   free(pd.content);
 493 }