ext/repo_susetags.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
  15 #include "pool.h"
  16 #include "repo.h"
  17 #include "hash.h"
  18 #include "chksum.h"
  19 #include "tools_util.h"
  20 #include "repo_susetags.h"
  21 #ifdef ENABLE_COMPLEX_DEPS
  22 #include "pool_parserpmrichdep.h"
  23 #endif
  24
  25 struct datashare {
  26   Id name;
  27   Id evr;
  28   Id arch;
  29 };
  30
  31 struct parsedata {
  32   int ret;
  33   Pool *pool;
  34   Repo *repo;
  35   Repodata *data;
  36   char *kind;
  37   int flags;
  38   int last_found_source;
  39   struct datashare *share_with;
  40   int nshare;
  41   Id (*dirs)[3];                        /* dirid, size, nfiles */
  42   int ndirs;
  43   struct joindata jd;
  44   char *language;                       /* the default language */
  45   Id langcache[ID_NUM_INTERNAL];        /* cache for the default language */
  46   int lineno;
  47   char *filelist;
  48   int afilelist;                        /* allocated */
  49   int nfilelist;                        /* used */
  50 };
  51
  52 static char *flagtab[] = {
  53   ">",
  54   "=",
  55   ">=",
  56   "<",
  57   "!=",
  58   "<="
  59 };
  60
  61
  62 static Id
  63 langtag(struct parsedata *pd, Id tag, const char *language)
  64 {
  65   if (language && *language)
  66     return pool_id2langid(pd->repo->pool, tag, language, 1);
  67   if (!pd->language)
  68     return tag;
  69   if (tag >= ID_NUM_INTERNAL)
  70     return pool_id2langid(pd->repo->pool, tag, pd->language, 1);
  71   if (!pd->langcache[tag])
  72     pd->langcache[tag] = pool_id2langid(pd->repo->pool, tag, pd->language, 1);
  73   return pd->langcache[tag];
  74 }
  75
  76 /*
  77  * adddep
  78  * create and add dependency
  79  */
  80
  81 static unsigned int
  82 adddep(Pool *pool, struct parsedata *pd, unsigned int olddeps, char *line, Id marker, char *kind)
  83 {
  84   int i, flags;
  85   Id id, evrid;
  86   char *sp[4];
  87
  88   if (line[6] == '/')
  89     {
  90       /* A file dependency. Do not try to parse it */
  91       id = pool_str2id(pool, line + 6, 1);
  92     }
  93 #ifdef ENABLE_COMPLEX_DEPS
  94   else if (line[6] == '(')
  95     {
  96       id = pool_parserpmrichdep(pool, line + 6);
  97       if (!id)
  98         {
  99           pd->ret = pool_error(pool, -1, "susetags: line %d: bad dependency: '%s'\n", pd->lineno, line);
 100           return olddeps;
 101         }
 102     }
 103 #endif
 104   else
 105     {
 106       i = split(line + 6, sp, 4); /* name, <op>, evr, ? */
 107       if (i != 1 && i != 3) /* expect either 'name' or 'name' <op> 'evr' */
 108         {
 109           pd->ret = pool_error(pool, -1, "susetags: line %d: bad dependency: '%s'\n", pd->lineno, line);
 110           return olddeps;
 111         }
 112       if (kind)
 113         id = pool_str2id(pool, join2(&pd->jd, kind, ":", sp[0]), 1);
 114       else
 115         id = pool_str2id(pool, sp[0], 1);
 116       if (i == 3)
 117         {
 118           evrid = makeevr(pool, sp[2]);
 119           for (flags = 0; flags < 6; flags++)
 120             if (!strcmp(sp[1], flagtab[flags]))
 121               break;
 122           if (flags == 6)
 123             {
 124               if (!strcmp(sp[1], "<>"))
 125                 flags = 4;
 126               else
 127                 {
 128                   pd->ret = pool_error(pool, -1, "susetags: line %d: unknown relation: '%s'\n", pd->lineno, sp[1]);
 129                   return olddeps;
 130                 }
 131             }
 132           id = pool_rel2id(pool, id, evrid, flags + 1, 1);
 133         }
 134     }
 135   return repo_addid_dep(pd->repo, olddeps, id, marker);
 136 }
 137
 138
 139 /*
 140  * add_source
 141  *
 142  */
 143
 144 static void
 145 add_source(struct parsedata *pd, char *line, Solvable *s, Id handle)
 146 {
 147   Pool *pool = s->repo->pool;
 148   char *sp[5];
 149   Id name;
 150   Id arch;
 151   const char *evr, *sevr;
 152
 153   if (split(line, sp, 5) != 4)
 154     {
 155       pd->ret = pool_error(pool, -1, "susetags: line %d: bad source line '%s'\n", pd->lineno, line);
 156       return;
 157     }
 158
 159   name = pool_str2id(pool, sp[0], 1);
 160   arch = pool_str2id(pool, sp[3], 1);   /* do this before id2str */
 161   evr = join2(&pd->jd, sp[1], "-", sp[2]);
 162   sevr = pool_id2str(pool, s->evr);
 163   if (sevr)
 164     {
 165       /* strip epoch */
 166       const char *p;
 167       for (p = sevr; *p >= '0' && *p <= '9'; p++)
 168         ;
 169       if (p != sevr && *p == ':' && p[1])
 170         sevr = p;
 171     }
 172   if (name == s->name)
 173     repodata_set_void(pd->data, handle, SOLVABLE_SOURCENAME);
 174   else
 175     repodata_set_id(pd->data, handle, SOLVABLE_SOURCENAME, name);
 176   if (sevr && !strcmp(sevr, evr))
 177     repodata_set_void(pd->data, handle, SOLVABLE_SOURCEEVR);
 178   else
 179     repodata_set_id(pd->data, handle, SOLVABLE_SOURCEEVR, pool_str2id(pool, evr, 1));
 180   repodata_set_constantid(pd->data, handle, SOLVABLE_SOURCEARCH, arch);
 181 }
 182
 183 /*
 184  * add_dirline
 185  * add a line with directory information
 186  *
 187  */
 188
 189 static void
 190 add_dirline(struct parsedata *pd, char *line)
 191 {
 192   char *sp[6];
 193   long filesz;
 194   long filenum;
 195   Id dirid;
 196   if (split(line, sp, 6) != 5)
 197     return;
 198   pd->dirs = solv_extend(pd->dirs, pd->ndirs, 1, sizeof(pd->dirs[0]), 31);
 199   filesz = strtol(sp[1], 0, 0);
 200   filesz += strtol(sp[2], 0, 0);
 201   filenum = strtol(sp[3], 0, 0);
 202   filenum += strtol(sp[4], 0, 0);
 203   /* hack: we know that there's room for a / */
 204   if (*sp[0] != '/')
 205     *--sp[0] = '/';
 206   dirid = repodata_str2dir(pd->data, sp[0], 1);
 207 #if 0
 208 fprintf(stderr, "%s -> %d\n", sp[0], dirid);
 209 #endif
 210   pd->dirs[pd->ndirs][0] = dirid;
 211   pd->dirs[pd->ndirs][1] = filesz;
 212   pd->dirs[pd->ndirs][2] = filenum;
 213   pd->ndirs++;
 214 }
 215
 216 static void
 217 set_checksum(struct parsedata *pd, Repodata *data, Id handle, Id keyname, char *line)
 218 {
 219   char *sp[3];
 220   Id type;
 221   if (split(line, sp, 3) != 2)
 222     {
 223       pd->ret = pool_error(pd->pool, -1, "susetags: line %d: bad checksum line '%s'\n", pd->lineno, line);
 224       return;
 225     }
 226   type = solv_chksum_str2type(sp[0]);
 227   if (!type)
 228     {
 229       pd->ret = pool_error(pd->pool, -1, "susetags: line %d: unknown checksum type: '%s'\n", pd->lineno, sp[0]);
 230       return;
 231     }
 232   if (strlen(sp[1]) != 2 * solv_chksum_len(type))
 233     {
 234       pd->ret = pool_error(pd->pool, -1, "susetags: line %d: bad checksum length for type %s: '%s'\n", pd->lineno, sp[0], sp[1]);
 235       return;
 236     }
 237   repodata_set_checksum(data, handle, keyname, type, sp[1]);
 238 }
 239
 240
 241 /*
 242  * id3_cmp
 243  * compare
 244  *
 245  */
 246
 247 static int
 248 id3_cmp(const void *v1, const void *v2, void *dp)
 249 {
 250   Id *i1 = (Id*)v1;
 251   Id *i2 = (Id*)v2;
 252   return i1[0] - i2[0];
 253 }
 254
 255
 256 /*
 257  * commit_diskusage
 258  *
 259  */
 260
 261 static void
 262 commit_diskusage(struct parsedata *pd, Id handle)
 263 {
 264   int i;
 265   Dirpool *dp = &pd->data->dirpool;
 266   /* Now sort in dirid order.  This ensures that parents come before
 267      their children.  */
 268   if (pd->ndirs > 1)
 269     solv_sort(pd->dirs, pd->ndirs, sizeof(pd->dirs[0]), id3_cmp, 0);
 270   /* Substract leaf numbers from all parents to make the numbers
 271      non-cumulative.  This must be done post-order (i.e. all leafs
 272      adjusted before parents).  We ensure this by starting at the end of
 273      the array moving to the start, hence seeing leafs before parents.  */
 274   for (i = pd->ndirs; i--;)
 275     {
 276       Id p = dirpool_parent(dp, pd->dirs[i][0]);
 277       int j = i;
 278       for (; p; p = dirpool_parent(dp, p))
 279         {
 280           for (; j--;)
 281             if (pd->dirs[j][0] == p)
 282               break;
 283           if (j >= 0)
 284             {
 285               if (pd->dirs[j][1] < pd->dirs[i][1])
 286                 pd->dirs[j][1] = 0;
 287               else
 288                 pd->dirs[j][1] -= pd->dirs[i][1];
 289               if (pd->dirs[j][2] < pd->dirs[i][2])
 290                 pd->dirs[j][2] = 0;
 291               else
 292                 pd->dirs[j][2] -= pd->dirs[i][2];
 293             }
 294           else
 295             /* Haven't found this parent in the list, look further if
 296                we maybe find the parents parent.  */
 297             j = i;
 298         }
 299     }
 300 #if 0
 301   char sbuf[1024];
 302   char *buf = sbuf;
 303   unsigned slen = sizeof(sbuf);
 304   for (i = 0; i < pd->ndirs; i++)
 305     {
 306       dir2str(attr, pd->dirs[i][0], &buf, &slen);
 307       fprintf(stderr, "have dir %d %d %d %s\n", pd->dirs[i][0], pd->dirs[i][1], pd->dirs[i][2], buf);
 308     }
 309   if (buf != sbuf)
 310     free (buf);
 311 #endif
 312   for (i = 0; i < pd->ndirs; i++)
 313     if (pd->dirs[i][1] || pd->dirs[i][2])
 314       {
 315         repodata_add_dirnumnum(pd->data, handle, SOLVABLE_DISKUSAGE, pd->dirs[i][0], pd->dirs[i][1], pd->dirs[i][2]);
 316       }
 317   pd->ndirs = 0;
 318 }
 319
 320
 321 /* Unfortunately "a"[0] is no constant expression in the C languages,
 322    so we need to pass the four characters individually :-/  */
 323 #define CTAG(a,b,c,d) ((unsigned)(((unsigned char)a) << 24) \
 324  | ((unsigned char)b << 16) \
 325  | ((unsigned char)c << 8) \
 326  | ((unsigned char)d))
 327
 328 /*
 329  * tag_from_string
 330  *
 331  */
 332
 333 static inline unsigned int
 334 tag_from_string(char *cs)
 335 {
 336   unsigned char *s = (unsigned char *)cs;
 337   return ((s[0] << 24) | (s[1] << 16) | (s[2] << 8) | s[3]);
 338 }
 339
 340
 341 /*
 342  * repo_add_susetags
 343  * Parse susetags file passed in fp, fill solvables into repo
 344  *
 345  * susetags is key,value based
 346  *  for short values
 347  *    =key: value
 348  *  is used
 349  *  for long (multi-line) values,
 350  *    +key:
 351  *    value
 352  *    value
 353  *    -key:
 354  *  is used
 355  *
 356  * See http://en.opensuse.org/Standards/YaST2_Repository_Metadata
 357  * and http://en.opensuse.org/Standards/YaST2_Repository_Metadata/packages
 358  * and http://en.opensuse.org/Standards/YaST2_Repository_Metadata/pattern
 359  *
 360  * Assumptions:
 361  *   All keys have 3 characters and end in ':'
 362  */
 363
 364 static void
 365 finish_solvable(struct parsedata *pd, Solvable *s, Offset freshens)
 366 {
 367   Pool *pool = pd->repo->pool;
 368   Id handle = s - pool->solvables;
 369
 370   if (pd->nfilelist)
 371     {
 372       int l;
 373       Id did;
 374       for (l = 0; l < pd->nfilelist; l += strlen(pd->filelist + l) + 1)
 375         {
 376           char *p = strrchr(pd->filelist + l, '/');
 377           if (!p)
 378             continue;
 379           *p++ = 0;
 380           did = repodata_str2dir(pd->data, pd->filelist + l, 1);
 381           p[-1] = '/';
 382           if (!did)
 383             did = repodata_str2dir(pd->data, "/", 1);
 384           repodata_add_dirstr(pd->data, handle, SOLVABLE_FILELIST, did, p);
 385         }
 386       pd->nfilelist = 0;
 387     }
 388   /* A self provide, except for source packages.  This is harmless
 389      to do twice (in case we see the same package twice).  */
 390   if (s->name && s->arch != ARCH_SRC && s->arch != ARCH_NOSRC)
 391     s->provides = repo_addid_dep(pd->repo, s->provides, pool_rel2id(pool, s->name, s->evr, REL_EQ, 1), 0);
 392   repo_rewrite_suse_deps(s, freshens);
 393   if (pd->ndirs)
 394     commit_diskusage(pd, handle);
 395 }
 396
 397 static Hashtable
 398 joinhash_init(Repo *repo, Hashval *hmp)
 399 {
 400   Hashval hm = mkmask(repo->nsolvables);
 401   Hashtable ht = solv_calloc(hm + 1, sizeof(*ht));
 402   Hashval h, hh;
 403   Solvable *s;
 404   int i;
 405
 406   FOR_REPO_SOLVABLES(repo, i, s)
 407     {
 408       hh = HASHCHAIN_START;
 409       h = s->name & hm;
 410       while (ht[h])
 411         h = HASHCHAIN_NEXT(h, hh, hm);
 412       ht[h] = i;
 413     }
 414   *hmp = hm;
 415   return ht;
 416 }
 417
 418 static Solvable *
 419 joinhash_lookup(Repo *repo, Hashtable ht, Hashval hm, Id name, Id evr, Id arch, Id start)
 420 {
 421   Hashval h, hh;
 422
 423   if (!name || !arch || !evr)
 424     return 0;
 425   hh = HASHCHAIN_START;
 426   h = name & hm;
 427   while (ht[h])
 428     {
 429       Solvable *s = repo->pool->solvables + ht[h];
 430       if (ht[h] >= start && s->name == name && s->evr == evr && s->arch == arch)
 431         return s;
 432       h = HASHCHAIN_NEXT(h, hh, hm);
 433     }
 434   return 0;
 435 }
 436
 437 static Id
 438 lookup_shared_id(Repodata *data, Id p, Id keyname, Id voidid, int uninternalized)
 439 {
 440   Id r;
 441   r = repodata_lookup_type(data, p, keyname);
 442   if (r)
 443     {
 444       if (r == REPOKEY_TYPE_VOID)
 445         return voidid;
 446       r = repodata_lookup_id(data, p, keyname);
 447       if (r)
 448         return r;
 449     }
 450   if (uninternalized)
 451     return repodata_lookup_id_uninternalized(data, p, keyname, voidid);
 452   return 0;
 453 }
 454
 455 static inline Id
 456 toevr(Pool *pool, struct parsedata *pd, const char *version, const char *release)
 457 {
 458   return makeevr(pool, !release || (release[0] == '-' && !release[1]) ?
 459         version : join2(&pd->jd, version, "-", release));
 460 }
 461
 462
 463 /*
 464  * parse susetags
 465  *
 466  * fp: file to read from
 467  * defvendor: default vendor (0 if none)
 468  * language: current language (0 if none)
 469  * flags: flags
 470  */
 471
 472 int
 473 repo_add_susetags(Repo *repo, FILE *fp, Id defvendor, const char *language, int flags)
 474 {
 475   Pool *pool = repo->pool;
 476   char *line, *linep;
 477   int aline;
 478   Solvable *s;
 479   Offset freshens;
 480   int intag = 0;
 481   int intag_linestart = 0;
 482   int cummulate = 0;
 483   int indesc = 0;
 484   int indelta = 0;
 485   int last_found_pack = 0;
 486   Id first_new_pkg = 0;
 487   char *sp[5];
 488   struct parsedata pd;
 489   Repodata *data = 0;
 490   Id handle = 0;
 491   Hashtable joinhash = 0;
 492   Hashval joinhashm = 0;
 493   int createdpkgs = 0;
 494
 495   if ((flags & (SUSETAGS_EXTEND|REPO_EXTEND_SOLVABLES)) != 0 && repo->nrepodata)
 496     {
 497       joinhash = joinhash_init(repo, &joinhashm);
 498       indesc = 1;
 499     }
 500
 501   data = repo_add_repodata(repo, flags);
 502
 503   memset(&pd, 0, sizeof(pd));
 504   line = solv_malloc(1024);
 505   aline = 1024;
 506
 507   pd.pool = pool;
 508   pd.repo = repo;
 509   pd.data = data;
 510   pd.flags = flags;
 511   pd.language = language && *language ? solv_strdup(language) : 0;
 512
 513   linep = line;
 514   s = 0;
 515   freshens = 0;
 516
 517   /* if this is a join setup the recorded share data */
 518   if (joinhash)
 519     {
 520       Repodata *sdata;
 521       int i;
 522
 523       FOR_REPODATAS(repo, i, sdata)
 524         {
 525           int p;
 526           if (!repodata_has_keyname(sdata, SUSETAGS_SHARE_NAME))
 527             continue;
 528           for (p = sdata->start; p < sdata->end; p++)
 529             {
 530               Id name, evr, arch;
 531               name = lookup_shared_id(sdata, p, SUSETAGS_SHARE_NAME, pool->solvables[p].name, sdata == data);
 532               if (!name)
 533                 continue;
 534               evr = lookup_shared_id(sdata, p, SUSETAGS_SHARE_EVR, pool->solvables[p].evr, sdata == data);
 535               if (!evr)
 536                 continue;
 537               arch = lookup_shared_id(sdata, p, SUSETAGS_SHARE_ARCH, pool->solvables[p].arch, sdata == data);
 538               if (!arch)
 539                 continue;
 540               if (p - repo->start >= pd.nshare)
 541                 {
 542                   pd.share_with = solv_realloc2(pd.share_with, p - repo->start + 256, sizeof(*pd.share_with));
 543                   memset(pd.share_with + pd.nshare, 0, (p - repo->start + 256 - pd.nshare) * sizeof(*pd.share_with));
 544                   pd.nshare = p - repo->start + 256;
 545                 }
 546               pd.share_with[p - repo->start].name = name;
 547               pd.share_with[p - repo->start].evr = evr;
 548               pd.share_with[p - repo->start].arch = arch;
 549             }
 550         }
 551     }
 552
 553   /*
 554    * read complete file
 555    *
 556    * collect values in 'struct parsedata pd'
 557    * then build .solv (and .attr) file
 558    */
 559
 560   for (;;)
 561     {
 562       unsigned int tag;
 563       char line_lang[6];
 564       int keylen;
 565
 566       if (pd.ret)
 567         break;
 568       if (linep - line + 16 > aline)              /* (re-)alloc buffer */
 569         {
 570           aline = linep - line;
 571           line = solv_realloc(line, aline + 512);
 572           linep = line + aline;
 573           aline += 512;
 574         }
 575       if (!fgets(linep, aline - (linep - line), fp)) /* read line */
 576         break;
 577       linep += strlen(linep);
 578       if (linep == line || linep[-1] != '\n')
 579         continue;
 580       pd.lineno++;
 581       *--linep = 0;
 582
 583       if (intag)
 584         {
 585           /* in multi-line value tags (+Key:/-Key:), check for end, cummulate */
 586           int is_end = line[intag_linestart] == '-' && linep[-1] == ':' && linep - line == intag_linestart + intag + 2;
 587           if (is_end && strncmp(linep - 1 - intag, line + 1, intag))
 588             {
 589               pool_debug(pool, SOLV_ERROR, "susetags: Nonmatching multi-line tags: %d: '%s' '%.*s'\n", pd.lineno, linep - 1 - intag, intag, line + 1);
 590             }
 591           if (!is_end)
 592             {
 593               if (cummulate)
 594                 {
 595                   *linep++ = '\n';
 596                   intag_linestart = linep - line;
 597                   continue;
 598                 }
 599               intag_linestart = intag + 3;
 600               linep = line + intag_linestart;
 601               if (!*linep)
 602                 continue;               /* ignore empty lines, bnc#381828 */
 603             }
 604           else
 605             {
 606               intag = 0;
 607               linep = line;
 608               if (!cummulate)
 609                 continue;
 610               line[intag_linestart] = 0;
 611               if (line[intag_linestart - 1] == '\n')
 612                 line[intag_linestart - 1] = 0;          /* strip trailing newline */
 613             }
 614         }
 615       else
 616         linep = line;
 617
 618       /* ignore comments and empty lines */
 619       if (!*line || *line == '#')
 620         continue;
 621
 622       /* ignore malformed lines */
 623       if (!(line[0] && line[1] && line[2] && line[3] && (line[4] == ':' || line[4] == '.')))
 624         continue;
 625
 626       if (!intag && line[0] == '+' && line[1] != ':') /* start of +Key:/-Key: tag */
 627         {
 628           char *tagend = strchr(line, ':');
 629           if (!tagend || tagend - line > 100)
 630             {
 631               pd.ret = pool_error(pool, -1, "susetags: line %d: bad line '%s'\n", pd.lineno, line);
 632               break;
 633             }
 634           intag = tagend - (line + 1);          /* set to tagsize */
 635           cummulate = 0;
 636           switch (tag_from_string(line))        /* check if accumulation is needed */
 637             {
 638               case CTAG('+', 'D', 'e', 's'):
 639               case CTAG('+', 'E', 'u', 'l'):
 640               case CTAG('+', 'I', 'n', 's'):
 641               case CTAG('+', 'D', 'e', 'l'):
 642               case CTAG('+', 'A', 'u', 't'):
 643                 cummulate = 1;
 644                 break;
 645               default:
 646                 break;
 647             }
 648           line[0] = '=';                        /* handle lines between +Key:/-Key: as =Key: */
 649           line[intag + 2] = ' ';
 650           intag_linestart = intag + 3;
 651           linep = line + intag_linestart;
 652           continue;
 653         }
 654
 655       /* support language suffix */
 656       keylen = 3;
 657       line_lang[0] = 0;
 658       if (line[4] == '.')
 659         {
 660           char *endlang;
 661           endlang = strchr(line + 5, ':');
 662           if (endlang)
 663             {
 664               int langsize = endlang - (line + 5);
 665               keylen = endlang - line - 1;
 666               if (langsize > 5)
 667                 langsize = 5;
 668               strncpy(line_lang, line + 5, langsize);
 669               line_lang[langsize] = 0;
 670             }
 671         }
 672
 673       tag = tag_from_string(line);
 674
 675       if (indelta)
 676         {
 677           /* Example:
 678             =Dlt: subversion 1.6.16 1.3.1 i586
 679             =Dsq: subversion 1.6.15 4.2 i586 d57b3fc86e7a2f73796e8e35b96fa86212c910
 680             =Cks: SHA1 14a8410cf741856a5d70d89dab62984dba6a1ca7
 681             =Loc: 1 subversion-1.6.15_1.6.16-4.2_1.3.1.i586.delta.rpm
 682             =Siz: 81558
 683            */
 684           switch (tag)
 685             {
 686             case CTAG('=', 'D', 's', 'q'):
 687               {
 688                 Id evr;
 689                 if (split(line + 5, sp, 5) != 5)
 690                   continue;
 691                 repodata_set_id(data, handle, DELTA_SEQ_NAME, pool_str2id(pool, sp[0], 1));
 692                 evr = toevr(pool, &pd, sp[1], sp[2]);
 693                 repodata_set_id(data, handle, DELTA_SEQ_EVR, evr);
 694                 /* repodata_set_id(data, handle, DELTA_SEQ_ARCH, pool_str2id(pool, sp[3], 1)); */
 695                 repodata_set_str(data, handle, DELTA_SEQ_NUM, sp[4]);
 696                 repodata_set_id(data, handle, DELTA_BASE_EVR, evr);
 697                 continue;
 698               }
 699             case CTAG('=', 'C', 'k', 's'):
 700               set_checksum(&pd, data, handle, DELTA_CHECKSUM, line + 6);
 701               continue;
 702             case CTAG('=', 'L', 'o', 'c'):
 703               {
 704                 int i = split(line + 6, sp, 3);
 705                 if (i != 2 && i != 3)
 706                   {
 707                     pd.ret = pool_error(pool, -1, "susetags: line %d: bad location line '%s'\n", pd.lineno, line);
 708                     continue;
 709                   }
 710                 repodata_set_deltalocation(data, handle, atoi(sp[0]), i == 3 ? sp[2] : 0, sp[1]);
 711                 continue;
 712               }
 713             case CTAG('=', 'S', 'i', 'z'):
 714               if (split(line + 6, sp, 3) == 2)
 715                 repodata_set_num(data, handle, DELTA_DOWNLOADSIZE, strtoull(sp[0], 0, 10));
 716               continue;
 717             case CTAG('=', 'P', 'k', 'g'):
 718             case CTAG('=', 'P', 'a', 't'):
 719             case CTAG('=', 'D', 'l', 't'):
 720               handle = 0;
 721               indelta = 0;
 722               break;
 723             default:
 724               pool_debug(pool, SOLV_ERROR, "susetags: unknown line: %d: %s\n", pd.lineno, line);
 725               continue;
 726             }
 727         }
 728
 729       /*
 730        * start of (next) package or pattern or delta
 731        *
 732        * =Pkg: <name> <version> <release> <architecture>
 733        * (=Pat: ...)
 734        */
 735       if (tag == CTAG('=', 'D', 'l', 't'))
 736         {
 737           if (s)
 738             finish_solvable(&pd, s, freshens);
 739           s = 0;
 740           pd.kind = 0;
 741           if (split(line + 5, sp, 5) != 4)
 742             {
 743               pd.ret = pool_error(pool, -1, "susetags: line %d: bad line '%s'\n", pd.lineno, line);
 744               break;
 745             }
 746           handle = repodata_new_handle(data);
 747           repodata_set_id(data, handle, DELTA_PACKAGE_NAME, pool_str2id(pool, sp[0], 1));
 748           repodata_set_id(data, handle, DELTA_PACKAGE_EVR, toevr(pool, &pd, sp[1], sp[2]));
 749           repodata_set_id(data, handle, DELTA_PACKAGE_ARCH, pool_str2id(pool, sp[3], 1));
 750           repodata_add_flexarray(data, SOLVID_META, REPOSITORY_DELTAINFO, handle);
 751           indelta = 1;
 752           continue;
 753         }
 754       if (tag == CTAG('=', 'P', 'k', 'g')
 755            || tag == CTAG('=', 'P', 'a', 't'))
 756         {
 757           /* If we have an old solvable, complete it by filling in some
 758              default stuff.  */
 759           if (s)
 760             finish_solvable(&pd, s, freshens);
 761
 762           /*
 763            * define kind
 764            */
 765
 766           pd.kind = 0;
 767           if (line[3] == 't')
 768             pd.kind = "pattern";
 769
 770           /*
 771            * parse nevra
 772            */
 773
 774           if (split(line + 5, sp, 5) != 4)
 775             {
 776               pd.ret = pool_error(pool, -1, "susetags: line %d: bad line '%s'\n", pd.lineno, line);
 777               break;
 778             }
 779           s = 0;
 780           freshens = 0;
 781
 782           if (joinhash)
 783             {
 784               /* data join operation. find solvable matching name/arch/evr and
 785                * add data to it */
 786               Id name, evr, arch;
 787               /* we don't use the create flag here as a simple pre-check for existance */
 788               if (pd.kind)
 789                 name = pool_str2id(pool, join2(&pd.jd, pd.kind, ":", sp[0]), 0);
 790               else
 791                 name = pool_str2id(pool, sp[0], 0);
 792               evr = toevr(pool, &pd, sp[1], sp[2]);
 793               arch = pool_str2id(pool, sp[3], 0);
 794               if (name && arch)
 795                 {
 796                   Id start = (flags & REPO_EXTEND_SOLVABLES) ? 0 : first_new_pkg;
 797                   if (repo->start + last_found_pack + 1 >= start && repo->start + last_found_pack + 1 < repo->end)
 798                     {
 799                       s = pool->solvables + repo->start + last_found_pack + 1;
 800                       if (s->repo != repo || s->name != name || s->evr != evr || s->arch != arch)
 801                         s = 0;
 802                     }
 803                   if (!s)
 804                     s = joinhash_lookup(repo, joinhash, joinhashm, name, evr, arch, start);
 805                 }
 806               /* do not create new packages in EXTEND_SOLVABLES mode */
 807               if (!s && (flags & REPO_EXTEND_SOLVABLES) != 0)
 808                 continue;
 809               /* fallthrough to package creation */
 810             }
 811           if (!s)
 812             {
 813               /* normal operation. create a new solvable. */
 814               s = pool_id2solvable(pool, repo_add_solvable(repo));
 815               if (pd.kind)
 816                 s->name = pool_str2id(pool, join2(&pd.jd, pd.kind, ":", sp[0]), 1);
 817               else
 818                 s->name = pool_str2id(pool, sp[0], 1);
 819               s->evr = toevr(pool, &pd, sp[1], sp[2]);
 820               s->arch = pool_str2id(pool, sp[3], 1);
 821               s->vendor = defvendor;
 822               if (!first_new_pkg)
 823                 first_new_pkg = s - pool->solvables;
 824               createdpkgs = 1;
 825             }
 826           last_found_pack = (s - pool->solvables) - repo->start;
 827           if (data)
 828             handle = s - pool->solvables;
 829         }
 830
 831       /* If we have no current solvable to add to, ignore all further lines
 832          for it.  Probably invalid input data in the second set of
 833          solvables.  */
 834       if (indesc >= 2 && !s)
 835         {
 836 #if 0
 837           pool_debug(pool, SOLV_ERROR, "susetags: huh %d: %s?\n", pd.lineno, line);
 838 #endif
 839           continue;
 840         }
 841       switch (tag)
 842         {
 843           case CTAG('=', 'P', 'r', 'v'):                                        /* provides */
 844             if (line[6] == '/')
 845               {
 846                 /* probably a filelist entry. stash it away for now */
 847                 int l = strlen(line + 6) + 1;
 848                 if (pd.nfilelist + l > pd.afilelist)
 849                   {
 850                     pd.afilelist = pd.nfilelist + l + 512;
 851                     pd.filelist = solv_realloc(pd.filelist, pd.afilelist);
 852                   }
 853                 memcpy(pd.filelist + pd.nfilelist, line + 6, l);
 854                 pd.nfilelist += l;
 855                 break;
 856               }
 857             if (pd.nfilelist)
 858               {
 859                 int l;
 860                 for (l = 0; l < pd.nfilelist; l += strlen(pd.filelist + l) + 1)
 861                   s->provides = repo_addid_dep(pd.repo, s->provides, pool_str2id(pool, pd.filelist + l, 1), 0);
 862                 pd.nfilelist = 0;
 863               }
 864             s->provides = adddep(pool, &pd, s->provides, line, 0, pd.kind);
 865             continue;
 866           case CTAG('=', 'R', 'e', 'q'):                                        /* requires */
 867             s->requires = adddep(pool, &pd, s->requires, line, -SOLVABLE_PREREQMARKER, pd.kind);
 868             continue;
 869           case CTAG('=', 'P', 'r', 'q'):                                        /* pre-requires / packages required */
 870             if (pd.kind)
 871               {
 872                 s->requires = adddep(pool, &pd, s->requires, line, 0, 0);           /* patterns: a required package */
 873               }
 874             else
 875               s->requires = adddep(pool, &pd, s->requires, line, SOLVABLE_PREREQMARKER, 0); /* package: pre-requires */
 876             continue;
 877           case CTAG('=', 'O', 'b', 's'):                                        /* obsoletes */
 878             s->obsoletes = adddep(pool, &pd, s->obsoletes, line, 0, pd.kind);
 879             continue;
 880           case CTAG('=', 'C', 'o', 'n'):                                        /* conflicts */
 881             s->conflicts = adddep(pool, &pd, s->conflicts, line, 0, pd.kind);
 882             continue;
 883           case CTAG('=', 'R', 'e', 'c'):                                        /* recommends */
 884             s->recommends = adddep(pool, &pd, s->recommends, line, 0, pd.kind);
 885             continue;
 886           case CTAG('=', 'S', 'u', 'p'):                                        /* supplements */
 887             s->supplements = adddep(pool, &pd, s->supplements, line, 0, pd.kind);
 888             continue;
 889           case CTAG('=', 'E', 'n', 'h'):                                        /* enhances */
 890             s->enhances = adddep(pool, &pd, s->enhances, line, 0, pd.kind);
 891             continue;
 892           case CTAG('=', 'S', 'u', 'g'):                                        /* suggests */
 893             s->suggests = adddep(pool, &pd, s->suggests, line, 0, pd.kind);
 894             continue;
 895           case CTAG('=', 'F', 'r', 'e'):                                        /* freshens */
 896             freshens = adddep(pool, &pd, freshens, line, 0, pd.kind);
 897             continue;
 898           case CTAG('=', 'P', 'r', 'c'):                                        /* packages recommended */
 899             s->recommends = adddep(pool, &pd, s->recommends, line, 0, 0);
 900             continue;
 901           case CTAG('=', 'P', 's', 'g'):                                        /* packages suggested */
 902             s->suggests = adddep(pool, &pd, s->suggests, line, 0, 0);
 903             continue;
 904           case CTAG('=', 'P', 'c', 'n'):                                        /* pattern: package conflicts */
 905             s->conflicts = adddep(pool, &pd, s->conflicts, line, 0, 0);
 906             continue;
 907           case CTAG('=', 'P', 'o', 'b'):                                        /* pattern: package obsoletes */
 908             s->obsoletes = adddep(pool, &pd, s->obsoletes, line, 0, 0);
 909             continue;
 910           case CTAG('=', 'P', 'f', 'r'):                                        /* pattern: package freshens */
 911             freshens = adddep(pool, &pd, freshens, line, 0, 0);
 912             continue;
 913           case CTAG('=', 'P', 's', 'p'):                                        /* pattern: package supplements */
 914             s->supplements = adddep(pool, &pd, s->supplements, line, 0, 0);
 915             continue;
 916           case CTAG('=', 'P', 'e', 'n'):                                        /* pattern: package enhances */
 917             s->enhances = adddep(pool, &pd, s->enhances, line, 0, 0);
 918             continue;
 919           case CTAG('=', 'V', 'e', 'r'):                                        /* - version - */
 920             last_found_pack = 0;
 921             handle = 0;
 922             indesc++;
 923             if (createdpkgs)
 924               {
 925                 solv_free(joinhash);
 926                 joinhash = joinhash_init(repo, &joinhashm);
 927                 createdpkgs = 0;
 928               }
 929             continue;
 930           case CTAG('=', 'V', 'n', 'd'):                                        /* vendor */
 931             s->vendor = pool_str2id(pool, line + 6, 1);
 932             continue;
 933
 934         /* From here it's the attribute tags.  */
 935           case CTAG('=', 'G', 'r', 'p'):
 936             repodata_set_poolstr(data, handle, SOLVABLE_GROUP, line + 6);
 937             continue;
 938           case CTAG('=', 'L', 'i', 'c'):
 939             repodata_set_poolstr(data, handle, SOLVABLE_LICENSE, line + 6);
 940             continue;
 941           case CTAG('=', 'L', 'o', 'c'):
 942             {
 943               int i = split(line + 6, sp, 3);
 944               if (i != 2 && i != 3)
 945                 {
 946                   pd.ret = pool_error(pool, -1, "susetags: line %d: bad location line '%s'\n", pd.lineno, line);
 947                   continue;
 948                 }
 949               repodata_set_location(data, handle, atoi(sp[0]), i == 3 ? sp[2] : pool_id2str(pool, s->arch), sp[1]);
 950             }
 951             continue;
 952           case CTAG('=', 'S', 'r', 'c'):
 953             add_source(&pd, line + 6, s, handle);
 954             continue;
 955           case CTAG('=', 'S', 'i', 'z'):
 956             if (split(line + 6, sp, 3) == 2)
 957               {
 958                 repodata_set_num(data, handle, SOLVABLE_DOWNLOADSIZE, strtoull(sp[0], 0, 10));
 959                 repodata_set_num(data, handle, SOLVABLE_INSTALLSIZE, strtoull(sp[1], 0, 10));
 960               }
 961             continue;
 962           case CTAG('=', 'T', 'i', 'm'):
 963             {
 964               unsigned int t = atoi(line + 6);
 965               if (t)
 966                 repodata_set_num(data, handle, SOLVABLE_BUILDTIME, t);
 967             }
 968             continue;
 969           case CTAG('=', 'K', 'w', 'd'):
 970             repodata_add_poolstr_array(data, handle, SOLVABLE_KEYWORDS, line + 6);
 971             continue;
 972           case CTAG('=', 'A', 'u', 't'):
 973             repodata_set_str(data, handle, SOLVABLE_AUTHORS, line + 6);
 974             continue;
 975           case CTAG('=', 'S', 'u', 'm'):
 976             repodata_set_str(data, handle, langtag(&pd, SOLVABLE_SUMMARY, line_lang), line + 3 + keylen);
 977             continue;
 978           case CTAG('=', 'D', 'e', 's'):
 979             repodata_set_str(data, handle, langtag(&pd, SOLVABLE_DESCRIPTION, line_lang), line + 3 + keylen);
 980             continue;
 981           case CTAG('=', 'E', 'u', 'l'):
 982             repodata_set_str(data, handle, langtag(&pd, SOLVABLE_EULA, line_lang), line + 6);
 983             continue;
 984           case CTAG('=', 'I', 'n', 's'):
 985             repodata_set_str(data, handle, langtag(&pd, SOLVABLE_MESSAGEINS, line_lang), line + 6);
 986             continue;
 987           case CTAG('=', 'D', 'e', 'l'):
 988             repodata_set_str(data, handle, langtag(&pd, SOLVABLE_MESSAGEDEL, line_lang), line + 6);
 989             continue;
 990           case CTAG('=', 'V', 'i', 's'):
 991             {
 992               /* Accept numbers and textual bools.  */
 993               int k;
 994               k = atoi(line + 6);
 995               if (k || !strcasecmp(line + 6, "true"))
 996                 repodata_set_void(data, handle, SOLVABLE_ISVISIBLE);
 997             }
 998             continue;
 999           case CTAG('=', 'S', 'h', 'r'):
1000             {
1001               Id name, evr, arch;
1002               if (split(line + 6, sp, 5) != 4)
1003                 {
1004                   pd.ret = pool_error(pool, -1, "susetags: line %d: bad =Shr line '%s'\n", pd.lineno, line);
1005                   continue;
1006                 }
1007               name = pool_str2id(pool, sp[0], 1);
1008               evr = toevr(pool, &pd, sp[1], sp[2]);
1009               arch = pool_str2id(pool, sp[3], 1);
1010               if (last_found_pack >= pd.nshare)
1011                 {
1012                   pd.share_with = solv_realloc2(pd.share_with, last_found_pack + 256, sizeof(*pd.share_with));
1013                   memset(pd.share_with + pd.nshare, 0, (last_found_pack + 256 - pd.nshare) * sizeof(*pd.share_with));
1014                   pd.nshare = last_found_pack + 256;
1015                 }
1016               pd.share_with[last_found_pack].name = name;
1017               pd.share_with[last_found_pack].evr = evr;
1018               pd.share_with[last_found_pack].arch = arch;
1019               if ((flags & SUSETAGS_RECORD_SHARES) != 0)
1020                 {
1021                   if (s->name == name)
1022                     repodata_set_void(data, handle, SUSETAGS_SHARE_NAME);
1023                   else
1024                     repodata_set_id(data, handle, SUSETAGS_SHARE_NAME, name);
1025                   if (s->evr == evr)
1026                     repodata_set_void(data, handle, SUSETAGS_SHARE_EVR);
1027                   else
1028                     repodata_set_id(data, handle, SUSETAGS_SHARE_EVR, evr);
1029                   if (s->arch == arch)
1030                     repodata_set_void(data, handle, SUSETAGS_SHARE_ARCH);
1031                   else
1032                     repodata_set_id(data, handle, SUSETAGS_SHARE_ARCH, arch);
1033                 }
1034               continue;
1035             }
1036           case CTAG('=', 'D', 'i', 'r'):
1037             add_dirline(&pd, line + 6);
1038             continue;
1039           case CTAG('=', 'C', 'a', 't'):
1040             repodata_set_poolstr(data, handle, langtag(&pd, SOLVABLE_CATEGORY, line_lang), line + 3 + keylen);
1041             break;
1042           case CTAG('=', 'O', 'r', 'd'):
1043             /* Order is a string not a number, so we can retroactively insert
1044                new patterns in the middle, i.e. 1 < 15 < 2.  */
1045             repodata_set_str(data, handle, SOLVABLE_ORDER, line + 6);
1046             break;
1047           case CTAG('=', 'I', 'c', 'o'):
1048             repodata_set_str(data, handle, SOLVABLE_ICON, line + 6);
1049             break;
1050           case CTAG('=', 'E', 'x', 't'):
1051             repodata_add_poolstr_array(data, handle, SOLVABLE_EXTENDS, join2(&pd.jd, "pattern", ":", line + 6));
1052             break;
1053           case CTAG('=', 'I', 'n', 'c'):
1054             repodata_add_poolstr_array(data, handle, SOLVABLE_INCLUDES, join2(&pd.jd, "pattern", ":", line + 6));
1055             break;
1056           case CTAG('=', 'C', 'k', 's'):
1057             set_checksum(&pd, data, handle, SOLVABLE_CHECKSUM, line + 6);
1058             break;
1059           case CTAG('=', 'L', 'a', 'n'):
1060             pd.language = solv_free(pd.language);
1061             memset(pd.langcache, 0, sizeof(pd.langcache));
1062             if (line[6])
1063               pd.language = solv_strdup(line + 6);
1064             break;
1065
1066           case CTAG('=', 'F', 'l', 's'):
1067             {
1068               char *p = strrchr(line + 6, '/');
1069               Id did;
1070               /* strip trailing slash */
1071               if (p && p != line + 6 && !p[1])
1072                 {
1073                   *p = 0;
1074                   p = strrchr(line + 6, '/');
1075                 }
1076               if (p)
1077                 {
1078                   *p++ = 0;
1079                   did = repodata_str2dir(data, line + 6, 1);
1080                 }
1081               else
1082                 {
1083                   p = line + 6;
1084                   did = 0;
1085                 }
1086               if (!did)
1087                 did = repodata_str2dir(data, "/", 1);
1088               repodata_add_dirstr(data, handle, SOLVABLE_FILELIST, did, p);
1089               break;
1090             }
1091           case CTAG('=', 'H', 'd', 'r'):
1092             /* rpm header range */
1093             if (split(line + 6, sp, 3) == 2)
1094               {
1095                 /* we ignore the start value */
1096                 unsigned int end = (unsigned int)atoi(sp[1]);
1097                 if (end)
1098                   repodata_set_num(data, handle, SOLVABLE_HEADEREND, end);
1099               }
1100             break;
1101
1102           case CTAG('=', 'P', 'a', 't'):
1103           case CTAG('=', 'P', 'k', 'g'):
1104             break;
1105
1106           default:
1107 #if 0
1108             pool_debug(pool, SOLV_WARN, "susetags: unknown line: %d: %s\n", pd.lineno, line);
1109 #endif
1110             break;
1111         }
1112
1113     }
1114
1115   if (s)
1116     finish_solvable(&pd, s, freshens);
1117   solv_free(pd.filelist);
1118
1119   /* Shared attributes
1120    *  (e.g. multiple binaries built from same source)
1121    */
1122   if (pd.nshare)
1123     {
1124       int i, last_found;
1125       Map keyidmap;
1126
1127       map_init(&keyidmap, data->nkeys);
1128       for (i = 1; i < data->nkeys; i++)
1129         {
1130           Id keyname = data->keys[i].name;
1131           if (keyname == SOLVABLE_INSTALLSIZE || keyname == SOLVABLE_DISKUSAGE || keyname == SOLVABLE_FILELIST)
1132             continue;
1133           if (keyname == SOLVABLE_MEDIADIR || keyname == SOLVABLE_MEDIAFILE || keyname == SOLVABLE_MEDIANR)
1134             continue;
1135           if (keyname == SOLVABLE_DOWNLOADSIZE || keyname == SOLVABLE_CHECKSUM)
1136             continue;
1137           if (keyname == SOLVABLE_SOURCENAME || keyname == SOLVABLE_SOURCEARCH || keyname == SOLVABLE_SOURCEEVR)
1138             continue;
1139           if (keyname == SOLVABLE_PKGID || keyname == SOLVABLE_HDRID || keyname == SOLVABLE_LEADSIGID)
1140             continue;
1141           if (keyname == SUSETAGS_SHARE_NAME || keyname == SUSETAGS_SHARE_EVR || keyname == SUSETAGS_SHARE_ARCH)
1142             continue;
1143           MAPSET(&keyidmap, i);
1144         }
1145       last_found = 0;
1146       for (i = 0; i < pd.nshare; i++)
1147         {
1148           unsigned int n, nn;
1149           Solvable *found = 0;
1150           if (!pd.share_with[i].name)
1151             continue;
1152           for (n = repo->start, nn = repo->start + last_found; n < repo->end; n++, nn++)
1153             {
1154               if (nn >= repo->end)
1155                 nn = repo->start;
1156               found = pool->solvables + nn;
1157               if (found->repo == repo
1158                   && found->name == pd.share_with[i].name
1159                   && found->evr == pd.share_with[i].evr
1160                   && found->arch == pd.share_with[i].arch)
1161                 {
1162                   last_found = nn - repo->start;
1163                   break;
1164                 }
1165             }
1166           if (n != repo->end)
1167             repodata_merge_some_attrs(data, repo->start + i, repo->start + last_found, &keyidmap, 0);
1168         }
1169       free(pd.share_with);
1170       map_free(&keyidmap);
1171     }
1172
1173   solv_free(joinhash);
1174   repodata_free_dircache(data);
1175   if (!(flags & REPO_NO_INTERNALIZE))
1176     repodata_internalize(data);
1177
1178   solv_free(pd.language);
1179   solv_free(line);
1180   join_freemem(&pd.jd);
1181   return pd.ret;
1182 }