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   Id seqname;
 123   Id seqevr;
 124   char *seqnum;
 125 };
 126
 127 struct parsedata {
 128   int depth;
 129   enum state state;
 130   int statedepth;
 131   char *content;
 132   int lcontent;
 133   int acontent;
 134   int docontent;
 135   Pool *pool;
 136   Repo *repo;
 137   Solvable *solvable;
 138   char *kind;
 139
 140   struct stateswitch *swtab[NUMSTATES];
 141   enum state sbtab[NUMSTATES];
 142   char *tempstr;
 143   int ltemp;
 144   int atemp;
 145   struct deltarpm delta;
 146 };
 147
 148 #if 0
 149 static void
 150 append_str(struct parsedata *pd, const char *s)
 151 {
 152   if (!s)
 153     return;
 154   int l = pd->ltemp + strlen(s) + 1;
 155   if (l > pd->atemp)
 156     {
 157       pd->tempstr = realloc(pd->tempstr, l + 256);
 158       pd->atemp = l + 256;
 159     }
 160   strcpy(pd->tempstr + pd->ltemp, s);
 161   pd->ltemp += strlen(s);
 162 }
 163 #endif
 164
 165 /*
 166  * create evr (as Id) from 'epoch', 'ver' and 'rel' attributes
 167  */
 168
 169 static Id
 170 makeevr_atts(Pool *pool, struct parsedata *pd, const char **atts)
 171 {
 172   const char *e, *v, *r, *v2;
 173   char *c;
 174   int l;
 175
 176   e = v = r = 0;
 177   for (; *atts; atts += 2)
 178     {
 179       if (!strcmp(*atts, "epoch"))
 180         e = atts[1];
 181       else if (!strcmp(*atts, "ver"))
 182         v = atts[1];
 183       else if (!strcmp(*atts, "rel"))
 184         r = atts[1];
 185     }
 186   if (e && !strcmp(e, "0"))
 187     e = 0;
 188   if (v && !e)
 189     {
 190       for (v2 = v; *v2 >= '0' && *v2 <= '9'; v2++)
 191         ;
 192       if (v2 > v && *v2 == ':')
 193         e = "0";
 194     }
 195   l = 1;
 196   if (e)
 197     l += strlen(e) + 1;
 198   if (v)
 199     l += strlen(v);
 200   if (r)
 201     l += strlen(r) + 1;
 202   if (l > pd->acontent)
 203     {
 204       pd->content = realloc(pd->content, l + 256);
 205       pd->acontent = l + 256;
 206     }
 207   c = pd->content;
 208   if (e)
 209     {
 210       strcpy(c, e);
 211       c += strlen(c);
 212       *c++ = ':';
 213     }
 214   if (v)
 215     {
 216       strcpy(c, v);
 217       c += strlen(c);
 218     }
 219   if (r)
 220     {
 221       *c++ = '-';
 222       strcpy(c, r);
 223       c += strlen(c);
 224     }
 225   *c = 0;
 226   if (!*pd->content)
 227     return 0;
 228 #if 0
 229   fprintf(stderr, "evr: %s\n", pd->content);
 230 #endif
 231   return str2id(pool, pd->content, 1);
 232 }
 233
 234
 235 /*
 236  * find attribute
 237  */
 238
 239 static const char *
 240 find_attr(const char *txt, const char **atts)
 241 {
 242   for (; *atts; atts += 2)
 243     {
 244       if (!strcmp(*atts, txt))
 245         return atts[1];
 246     }
 247   return 0;
 248 }
 249
 250
 251 /*
 252  * relation comparision operators
 253  */
 254
 255 static char *flagtab[] = {
 256   "GT",
 257   "EQ",
 258   "GE",
 259   "LT",
 260   "NE",
 261   "LE"
 262 };
 263
 264
 265 /*
 266  * add dependency
 267  */
 268
 269 static unsigned int
 270 adddep(Pool *pool, struct parsedata *pd, unsigned int olddeps, const char **atts, int isreq)
 271 {
 272   Id id, name, marker;
 273   const char *n, *f, *k;
 274   const char **a;
 275
 276   n = f = k = 0;
 277   marker = isreq ? -SOLVABLE_PREREQMARKER : 0;
 278   for (a = atts; *a; a += 2)
 279     {
 280       if (!strcmp(*a, "name"))
 281         n = a[1];
 282       else if (!strcmp(*a, "flags"))
 283         f = a[1];
 284       else if (!strcmp(*a, "kind"))
 285         k = a[1];
 286       else if (isreq && !strcmp(*a, "pre") && a[1][0] == '1')
 287         marker = SOLVABLE_PREREQMARKER;
 288     }
 289   if (!n)
 290     return olddeps;
 291   if (k && !strcmp(k, "package"))            /* kind 'package' -> ignore */
 292     k = 0;
 293   if (k)
 294     {
 295       int l = strlen(k) + 1 + strlen(n) + 1;
 296       if (l > pd->acontent)
 297         {
 298           pd->content = realloc(pd->content, l + 256);
 299           pd->acontent = l + 256;
 300         }
 301       sprintf(pd->content, "%s:%s", k, n);   /* prepend kind to name */
 302       name = str2id(pool, pd->content, 1);
 303     }
 304   else
 305     name = str2id(pool, (char *)n, 1);
 306   if (f)                                     /* flags means name,operator,relation */
 307     {
 308       Id evr = makeevr_atts(pool, pd, atts);
 309       int flags;
 310       for (flags = 0; flags < 6; flags++)
 311         if (!strcmp(f, flagtab[flags]))
 312           break;
 313       flags = flags < 6 ? flags + 1 : 0;
 314       id = rel2id(pool, name, evr, flags, 1);
 315     }
 316   else
 317     id = name;
 318 #if 0
 319   fprintf(stderr, "new dep %s%s%s\n", id2str(pool, d), id2rel(pool, d), id2evr(pool, d));
 320 #endif
 321   return repo_addid_dep(pd->repo, olddeps, id, marker);
 322 }
 323
 324
 325 static void XMLCALL
 326 startElement(void *userData, const char *name, const char **atts)
 327 {
 328   struct parsedata *pd = userData;
 329   Pool *pool = pd->pool;
 330   Solvable *s = pd->solvable;
 331   struct stateswitch *sw;
 332   const char *str;
 333
 334   if (pd->depth != pd->statedepth)
 335     {
 336       pd->depth++;
 337       return;
 338     }
 339
 340   if (pd->state == STATE_PATCH && !strcmp(name, "format"))
 341     return;
 342
 343   pd->depth++;
 344   for (sw = pd->swtab[pd->state]; sw->from == pd->state; sw++)  /* find name in statetable */
 345     if (!strcmp(sw->ename, name))
 346       break;
 347
 348   if (sw->from != pd->state)
 349     {
 350 #if 0
 351       fprintf(stderr, "into unknown: %s\n", name);
 352 #endif
 353       return;
 354     }
 355   pd->state = sw->to;
 356   pd->docontent = sw->docontent;
 357   pd->statedepth = pd->depth;
 358   pd->lcontent = 0;
 359   *pd->content = 0;
 360   switch(pd->state)
 361     {
 362     case STATE_NAME:
 363       if (pd->kind)
 364         {
 365           strcpy(pd->content, pd->kind);
 366           pd->lcontent = strlen(pd->content);
 367           pd->content[pd->lcontent++] = ':';
 368           pd->content[pd->lcontent] = 0;
 369         }
 370       break;
 371     case STATE_PATCH:
 372     case STATE_ATOM:
 373       if (pd->state == STATE_ATOM)
 374         {
 375           /* HACK: close patch */
 376           if (pd->kind && !strcmp(pd->kind, "patch"))
 377             {
 378               if (!s->arch)
 379                 s->arch = ARCH_NOARCH;
 380               s->provides = repo_addid_dep(pd->repo, s->provides, rel2id(pool, s->name, s->evr, REL_EQ, 1), 0);
 381             }
 382           pd->kind = "atom";
 383           pd->state = STATE_PATCH;
 384         }
 385       else
 386         pd->kind = "patch";
 387
 388       pd->solvable = pool_id2solvable(pool, repo_add_solvable(pd->repo));
 389 #if 0
 390       fprintf(stderr, "package #%d\n", pd->solvable - pool->solvables);
 391 #endif
 392       break;
 393     case STATE_DELTARPM:
 394       memset(&pd->delta, 0, sizeof (pd->delta));
 395       *pd->tempstr = 0;
 396       pd->ltemp = 0;
 397       break;
 398     case STATE_DLOCATION:
 399       if ((str = find_attr("href", atts)))
 400         {
 401           /* Separate the filename into its different parts.
 402              rpm/x86_64/alsa-1.0.14-31_31.2.x86_64.delta.rpm
 403              --> dir = rpm/x86_64
 404                  name = alsa
 405                  evr = 1.0.14-31_31.2
 406                  suffix = x86_64.delta.rpm.  */
 407           char *real_str = strdup(str);
 408           char *s = real_str;
 409           char *s1, *s2;
 410           s1 = strrchr (s, '/');
 411           if (s1)
 412             {
 413               pd->delta.locdir = strn2id(pool, s, s1 - s, 1);
 414               s = s1 + 1;
 415             }
 416           /* Guess suffix.  */
 417           s1 = strrchr (s, '.');
 418           if (s1)
 419             {
 420               for (s2 = s1 - 1; s2 > s; s2--)
 421                 if (*s2 == '.')
 422                   break;
 423               if (!strcmp (s2, ".delta.rpm") || !strcmp (s2, ".patch.rpm"))
 424                 {
 425                   s1 = s2;
 426                   /* We accept one more item as suffix.  */
 427                   for (s2 = s1 - 1; s2 > s; s2--)
 428                     if (*s2 == '.')
 429                       break;
 430                   s1 = s2;
 431                 }
 432               if (*s1 == '.')
 433                 *s1++ = 0;
 434               pd->delta.locsuffix = str2id(pool, s1, 1);
 435             }
 436           /* Last '-'.  */
 437           s1 = strrchr (s, '-');
 438           if (s1)
 439             {
 440               /* Second to last '-'.  */
 441               for (s2 = s1 - 1; s2 > s; s2--)
 442                 if (*s2 == '-')
 443                   break;
 444             }
 445           else
 446             s2 = 0;
 447           if (s2 > s && *s2 == '-')
 448             {
 449               *s2++ = 0;
 450               pd->delta.locevr = str2id(pool, s2, 1);
 451             }
 452           pd->delta.locname = str2id(pool, s, 1);
 453           free(real_str);
 454         }
 455       break;
 456     case STATE_DTIME:
 457       str = find_attr("build", atts);
 458       if (str)
 459         pd->delta.buildtime = atoi(str);
 460       break;
 461     case STATE_DSIZE:
 462       if ((str = find_attr("package", atts)))
 463         pd->delta.downloadsize = atoi(str);
 464       if ((str = find_attr("archive", atts)))
 465         pd->delta.archivesize = atoi(str);
 466       break;
 467     case STATE_DBASEVERSION:
 468       if ((str = find_attr("sequence_info", atts)))
 469         {
 470           const char *s1, *s2;
 471           s1 = strrchr(str, '-');
 472           if (s1)
 473             {
 474               for (s2 = s1 - 1; s2 > str; s2--)
 475                 if (*s2 == '-')
 476                   break;
 477               if (*s2 == '-')
 478                 {
 479                   for (s2 = s2 - 1; s2 > str; s2--)
 480                     if (*s2 == '-')
 481                       break;
 482                   if (*s2 == '-')
 483                     {
 484                       pd->delta.seqevr = strn2id(pool, s2 + 1, s1 - s2 - 1, 1);
 485                       pd->delta.seqname = strn2id(pool, str, s2 - str, 1);
 486                       str = s1 + 1;
 487                     }
 488                 }
 489             }
 490           pd->delta.seqnum = strdup(str);
 491         }
 492       pd->delta.nbevr++;
 493       pd->delta.bevr = sat_realloc (pd->delta.bevr, pd->delta.nbevr * sizeof(Id));
 494       pd->delta.bevr[pd->delta.nbevr - 1] = makeevr_atts(pool, pd, atts);
 495       break;
 496     case STATE_VERSION:
 497       s->evr = makeevr_atts(pool, pd, atts);
 498       break;
 499     case STATE_PROVIDES:
 500       s->provides = 0;
 501       break;
 502     case STATE_PROVIDESENTRY:
 503       s->provides = adddep(pool, pd, s->provides, atts, 0);
 504       break;
 505     case STATE_REQUIRES:
 506       s->requires = 0;
 507       break;
 508     case STATE_REQUIRESENTRY:
 509       s->requires = adddep(pool, pd, s->requires, atts, 1);
 510       break;
 511     case STATE_OBSOLETES:
 512       s->obsoletes = 0;
 513       break;
 514     case STATE_OBSOLETESENTRY:
 515       s->obsoletes = adddep(pool, pd, s->obsoletes, atts, 0);
 516       break;
 517     case STATE_CONFLICTS:
 518       s->conflicts = 0;
 519       break;
 520     case STATE_CONFLICTSENTRY:
 521       s->conflicts = adddep(pool, pd, s->conflicts, atts, 0);
 522       break;
 523     case STATE_RECOMMENDS:
 524       s->recommends = 0;
 525       break;
 526     case STATE_RECOMMENDSENTRY:
 527       s->recommends = adddep(pool, pd, s->recommends, atts, 0);
 528       break;
 529     case STATE_SUPPLEMENTS:
 530       s->supplements= 0;
 531       break;
 532     case STATE_SUPPLEMENTSENTRY:
 533       s->supplements = adddep(pool, pd, s->supplements, atts, 0);
 534       break;
 535     case STATE_SUGGESTS:
 536       s->suggests = 0;
 537       break;
 538     case STATE_SUGGESTSENTRY:
 539       s->suggests = adddep(pool, pd, s->suggests, atts, 0);
 540       break;
 541     case STATE_ENHANCES:
 542       s->enhances = 0;
 543       break;
 544     case STATE_ENHANCESENTRY:
 545       s->enhances = adddep(pool, pd, s->enhances, atts, 0);
 546       break;
 547     case STATE_FRESHENS:
 548       s->freshens = 0;
 549       break;
 550     case STATE_FRESHENSENTRY:
 551       s->freshens = adddep(pool, pd, s->freshens, atts, 0);
 552       break;
 553     default:
 554       break;
 555     }
 556 }
 557
 558 static void XMLCALL
 559 endElement(void *userData, const char *name)
 560 {
 561   struct parsedata *pd = userData;
 562   Pool *pool = pd->pool;
 563   Solvable *s = pd->solvable;
 564
 565   if (pd->depth != pd->statedepth)
 566     {
 567       pd->depth--;
 568       // printf("back from unknown %d %d %d\n", pd->state, pd->depth, pd->statedepth);
 569       return;
 570     }
 571
 572   if (pd->state == STATE_PATCH && !strcmp(name, "format"))
 573     return;
 574
 575   pd->depth--;
 576   pd->statedepth--;
 577   switch (pd->state)
 578     {
 579     case STATE_PATCH:
 580       if (!strcmp(name, "patch") && strcmp(pd->kind, "patch"))
 581         break;  /* already closed */
 582       if (!s->arch)
 583         s->arch = ARCH_NOARCH;
 584       if (s->arch != ARCH_SRC && s->arch != ARCH_NOSRC)
 585         s->provides = repo_addid_dep(pd->repo, s->provides, rel2id(pool, s->name, s->evr, REL_EQ, 1), 0);
 586       s->supplements = repo_fix_legacy(pd->repo, s->provides, s->supplements);
 587       break;
 588     case STATE_NAME:
 589       s->name = str2id(pool, pd->content, 1);
 590       break;
 591     case STATE_ARCH:
 592       s->arch = str2id(pool, pd->content, 1);
 593       break;
 594     case STATE_DELTARPM:
 595 #ifdef TESTMM
 596       {
 597         int i;
 598         struct deltarpm *d = &pd->delta;
 599         fprintf (stderr, "found deltarpm for %s:\n", id2str(pool, s->name));
 600         fprintf (stderr, "   loc: %s %s %s %s\n", id2str(pool, d->locdir),
 601                  id2str(pool, d->locname), id2str(pool, d->locevr),
 602                  id2str(pool, d->locsuffix));
 603         fprintf (stderr, "  time: %u\n", d->buildtime);
 604         fprintf (stderr, "  size: %d down, %d archive\n", d->downloadsize,
 605                  d->archivesize);
 606         fprintf (stderr, "  chek: %s\n", d->filechecksum);
 607         if (d->seqnum)
 608           {
 609             fprintf (stderr, "  base: %s, seq: %s %s %s\n",
 610                      id2str(pool, d->bevr[0]), id2str(pool, d->seqname),
 611                      id2str(pool, d->seqevr), d->seqnum);
 612             if (d->seqevr != d->bevr[0])
 613               fprintf (stderr, "XXXXX evr\n");
 614             /* Name of package ("atom:xxxx") should match the sequence info
 615                name.  */
 616             if (strcmp(id2str(pool, d->seqname), id2str(pool, s->name) + 5))
 617               fprintf (stderr, "XXXXX name\n");
 618           }
 619         else
 620           {
 621             fprintf (stderr, "  base:");
 622             for (i = 0; i < d->nbevr; i++)
 623               fprintf (stderr, " %s", id2str(pool, d->bevr[i]));
 624             fprintf (stderr, "\n");
 625           }
 626       }
 627 #endif
 628       free(pd->delta.filechecksum);
 629       free(pd->delta.bevr);
 630       free(pd->delta.seqnum);
 631       break;
 632     case STATE_DCHECKSUM:
 633       pd->delta.filechecksum = strdup(pd->content);
 634       break;
 635     default:
 636       break;
 637     }
 638   pd->state = pd->sbtab[pd->state];
 639   pd->docontent = 0;
 640   // printf("back from known %d %d %d\n", pd->state, pd->depth, pd->statedepth);
 641 }
 642
 643 static void XMLCALL
 644 characterData(void *userData, const XML_Char *s, int len)
 645 {
 646   struct parsedata *pd = userData;
 647   int l;
 648   char *c;
 649
 650   if (!pd->docontent)
 651     return;
 652   l = pd->lcontent + len + 1;
 653   if (l > pd->acontent)
 654     {
 655       pd->content = realloc(pd->content, l + 256);
 656       pd->acontent = l + 256;
 657     }
 658   c = pd->content + pd->lcontent;
 659   pd->lcontent += len;
 660   while (len-- > 0)
 661     *c++ = *s++;
 662   *c = 0;
 663 }
 664
 665
 666 #define BUFF_SIZE 8192
 667
 668 void
 669 repo_add_patchxml(Repo *repo, FILE *fp, int flags)
 670 {
 671   Pool *pool = repo->pool;
 672   struct parsedata pd;
 673   char buf[BUFF_SIZE];
 674   int i, l;
 675   struct stateswitch *sw;
 676
 677   memset(&pd, 0, sizeof(pd));
 678   for (i = 0, sw = stateswitches; sw->from != NUMSTATES; i++, sw++)
 679     {
 680       if (!pd.swtab[sw->from])
 681         pd.swtab[sw->from] = sw;
 682       pd.sbtab[sw->to] = sw->from;
 683     }
 684   pd.pool = pool;
 685   pd.repo = repo;
 686   pd.content = malloc(256);
 687   pd.acontent = 256;
 688   pd.lcontent = 0;
 689   pd.tempstr = malloc(256);
 690   pd.atemp = 256;
 691   pd.ltemp = 0;
 692   XML_Parser parser = XML_ParserCreate(NULL);
 693   XML_SetUserData(parser, &pd);
 694   XML_SetElementHandler(parser, startElement, endElement);
 695   XML_SetCharacterDataHandler(parser, characterData);
 696   for (;;)
 697     {
 698       l = fread(buf, 1, sizeof(buf), fp);
 699       if (XML_Parse(parser, buf, l, l == 0) == XML_STATUS_ERROR)
 700         {
 701           fprintf(stderr, "repo_patchxml: %s at line %u:%u\n", XML_ErrorString(XML_GetErrorCode(parser)), (unsigned int)XML_GetCurrentLineNumber(parser), (unsigned int)XML_GetCurrentColumnNumber(parser));
 702           exit(1);
 703         }
 704       if (l == 0)
 705         break;
 706     }
 707   XML_ParserFree(parser);
 708
 709   free(pd.content);
 710 }