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
 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 cummulate = 0;
 482   int indesc = 0;
 483   int indelta = 0;
 484   int last_found_pack = 0;
 485   Id first_new_pkg = 0;
 486   char *sp[5];
 487   struct parsedata pd;
 488   Repodata *data = 0;
 489   Id handle = 0;
 490   Hashtable joinhash = 0;
 491   Hashval joinhashm = 0;
 492   int createdpkgs = 0;
 493
 494   if ((flags & (SUSETAGS_EXTEND|REPO_EXTEND_SOLVABLES)) != 0 && repo->nrepodata)
 495     {
 496       joinhash = joinhash_init(repo, &joinhashm);
 497       indesc = 1;
 498     }
 499
 500   data = repo_add_repodata(repo, flags);
 501
 502   memset(&pd, 0, sizeof(pd));
 503   line = solv_malloc(1024);
 504   aline = 1024;
 505
 506   pd.pool = pool;
 507   pd.repo = repo;
 508   pd.data = data;
 509   pd.flags = flags;
 510   pd.language = language && *language ? solv_strdup(language) : 0;
 511
 512   linep = line;
 513   s = 0;
 514   freshens = 0;
 515
 516   /* if this is a join setup the recorded share data */
 517   if (joinhash)
 518     {
 519       Repodata *sdata;
 520       int i;
 521
 522       FOR_REPODATAS(repo, i, sdata)
 523         {
 524           int p;
 525           if (!repodata_has_keyname(sdata, SUSETAGS_SHARE_NAME))
 526             continue;
 527           for (p = sdata->start; p < sdata->end; p++)
 528             {
 529               Id name, evr, arch;
 530               name = lookup_shared_id(sdata, p, SUSETAGS_SHARE_NAME, pool->solvables[p].name, sdata == data);
 531               if (!name)
 532                 continue;
 533               evr = lookup_shared_id(sdata, p, SUSETAGS_SHARE_EVR, pool->solvables[p].evr, sdata == data);
 534               if (!evr)
 535                 continue;
 536               arch = lookup_shared_id(sdata, p, SUSETAGS_SHARE_ARCH, pool->solvables[p].arch, sdata == data);
 537               if (!arch)
 538                 continue;
 539               if (p - repo->start >= pd.nshare)
 540                 {
 541                   pd.share_with = solv_realloc2(pd.share_with, p - repo->start + 256, sizeof(*pd.share_with));
 542                   memset(pd.share_with + pd.nshare, 0, (p - repo->start + 256 - pd.nshare) * sizeof(*pd.share_with));
 543                   pd.nshare = p - repo->start + 256;
 544                 }
 545               pd.share_with[p - repo->start].name = name;
 546               pd.share_with[p - repo->start].evr = evr;
 547               pd.share_with[p - repo->start].arch = arch;
 548             }
 549         }
 550     }
 551
 552   /*
 553    * read complete file
 554    *
 555    * collect values in 'struct parsedata pd'
 556    * then build .solv (and .attr) file
 557    */
 558
 559   for (;;)
 560     {
 561       unsigned tag;
 562       char *olinep; /* old line pointer */
 563       char line_lang[6];
 564       int keylen = 3;
 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       olinep = linep;
 578       linep += strlen(linep);
 579       if (linep == line || linep[-1] != '\n')
 580         continue;
 581       pd.lineno++;
 582       *--linep = 0;
 583       if (linep == olinep)
 584         continue;
 585
 586       if (intag)
 587         {
 588           /* check for multi-line value tags (+Key:/-Key:) */
 589
 590           int is_end = (linep[-intag - keylen + 1] == '-')
 591                       && (linep[-1] == ':')
 592                       && (linep == line + 1 + intag + 1 + 1 + 1 + intag + 1 || linep[-intag - keylen] == '\n');
 593           if (is_end
 594               && strncmp(linep - 1 - intag, line + 1, intag))
 595             {
 596               pool_debug(pool, SOLV_ERROR, "susetags: Nonmatching multi-line tags: %d: '%s' '%s' %d\n", pd.lineno, linep - 1 - intag, line + 1, intag);
 597             }
 598           if (cummulate && !is_end)
 599             {
 600               *linep++ = '\n';
 601               continue;
 602             }
 603           if (cummulate && is_end)
 604             {
 605               linep[-intag - keylen + 1] = 0;
 606               if (linep[-intag - keylen] == '\n')
 607                 linep[-intag - keylen] = 0;
 608               linep = line;
 609               intag = 0;
 610             }
 611           if (!cummulate && is_end)
 612             {
 613               intag = 0;
 614               linep = line;
 615               continue;
 616             }
 617           if (!cummulate && !is_end)
 618             linep = line + intag + keylen;
 619         }
 620       else
 621         linep = line;
 622
 623       if (!intag && line[0] == '+' && line[1] && line[1] != ':') /* start of +Key:/-Key: tag */
 624         {
 625           char *tagend = strchr(line, ':');
 626           if (!tagend)
 627             {
 628               pd.ret = pool_error(pool, -1, "susetags: line %d: bad line '%s'\n", pd.lineno, line);
 629               break;
 630             }
 631           intag = tagend - (line + 1);
 632           cummulate = 0;
 633           switch (tag_from_string(line))       /* check if accumulation is needed */
 634             {
 635               case CTAG('+', 'D', 'e', 's'):
 636               case CTAG('+', 'E', 'u', 'l'):
 637               case CTAG('+', 'I', 'n', 's'):
 638               case CTAG('+', 'D', 'e', 'l'):
 639               case CTAG('+', 'A', 'u', 't'):
 640                 if (line[4] == ':' || line[4] == '.')
 641                   cummulate = 1;
 642                 break;
 643               default:
 644                 break;
 645             }
 646           line[0] = '=';                       /* handle lines between +Key:/-Key: as =Key: */
 647           line[intag + keylen - 1] = ' ';
 648           linep = line + intag + keylen;
 649           continue;
 650         }
 651       if (*line == '#' || !*line)
 652         continue;
 653       if (! (line[0] && line[1] && line[2] && line[3] && (line[4] == ':' || line[4] == '.')))
 654         continue;
 655       line_lang[0] = 0;
 656       if (line[4] == '.')
 657         {
 658           char *endlang;
 659           endlang = strchr(line + 5, ':');
 660           if (endlang)
 661             {
 662               int langsize = endlang - (line + 5);
 663               keylen = endlang - line - 1;
 664               if (langsize > 5)
 665                 langsize = 5;
 666               strncpy(line_lang, line + 5, langsize);
 667               line_lang[langsize] = 0;
 668             }
 669         }
 670       tag = tag_from_string(line);
 671
 672       if (indelta)
 673         {
 674           /* Example:
 675             =Dlt: subversion 1.6.16 1.3.1 i586
 676             =Dsq: subversion 1.6.15 4.2 i586 d57b3fc86e7a2f73796e8e35b96fa86212c910
 677             =Cks: SHA1 14a8410cf741856a5d70d89dab62984dba6a1ca7
 678             =Loc: 1 subversion-1.6.15_1.6.16-4.2_1.3.1.i586.delta.rpm
 679             =Siz: 81558
 680            */
 681           switch (tag)
 682             {
 683             case CTAG('=', 'D', 's', 'q'):
 684               {
 685                 Id evr;
 686                 if (split(line + 5, sp, 5) != 5)
 687                   continue;
 688                 repodata_set_id(data, handle, DELTA_SEQ_NAME, pool_str2id(pool, sp[0], 1));
 689                 evr = toevr(pool, &pd, sp[1], sp[2]);
 690                 repodata_set_id(data, handle, DELTA_SEQ_EVR, evr);
 691                 /* repodata_set_id(data, handle, DELTA_SEQ_ARCH, pool_str2id(pool, sp[3], 1)); */
 692                 repodata_set_str(data, handle, DELTA_SEQ_NUM, sp[4]);
 693                 repodata_set_id(data, handle, DELTA_BASE_EVR, evr);
 694                 continue;
 695               }
 696             case CTAG('=', 'C', 'k', 's'):
 697               set_checksum(&pd, data, handle, DELTA_CHECKSUM, line + 6);
 698               continue;
 699             case CTAG('=', 'L', 'o', 'c'):
 700               {
 701                 int i = split(line + 6, sp, 3);
 702                 if (i != 2 && i != 3)
 703                   {
 704                     pd.ret = pool_error(pool, -1, "susetags: line %d: bad location line '%s'\n", pd.lineno, line);
 705                     continue;
 706                   }
 707                 repodata_set_deltalocation(data, handle, atoi(sp[0]), i == 3 ? sp[2] : 0, sp[1]);
 708                 continue;
 709               }
 710             case CTAG('=', 'S', 'i', 'z'):
 711               if (split(line + 6, sp, 3) == 2)
 712                 repodata_set_num(data, handle, DELTA_DOWNLOADSIZE, strtoull(sp[0], 0, 10));
 713               continue;
 714             case CTAG('=', 'P', 'k', 'g'):
 715             case CTAG('=', 'P', 'a', 't'):
 716             case CTAG('=', 'D', 'l', 't'):
 717               handle = 0;
 718               indelta = 0;
 719               break;
 720             default:
 721               pool_debug(pool, SOLV_ERROR, "susetags: unknown line: %d: %s\n", pd.lineno, line);
 722               continue;
 723             }
 724         }
 725
 726       /*
 727        * start of (next) package or pattern or delta
 728        *
 729        * =Pkg: <name> <version> <release> <architecture>
 730        * (=Pat: ...)
 731        */
 732       if (tag == CTAG('=', 'D', 'l', 't'))
 733         {
 734           if (s)
 735             finish_solvable(&pd, s, freshens);
 736           s = 0;
 737           pd.kind = 0;
 738           if (split(line + 5, sp, 5) != 4)
 739             {
 740               pd.ret = pool_error(pool, -1, "susetags: line %d: bad line '%s'\n", pd.lineno, line);
 741               break;
 742             }
 743           handle = repodata_new_handle(data);
 744           repodata_set_id(data, handle, DELTA_PACKAGE_NAME, pool_str2id(pool, sp[0], 1));
 745           repodata_set_id(data, handle, DELTA_PACKAGE_EVR, toevr(pool, &pd, sp[1], sp[2]));
 746           repodata_set_id(data, handle, DELTA_PACKAGE_ARCH, pool_str2id(pool, sp[3], 1));
 747           repodata_add_flexarray(data, SOLVID_META, REPOSITORY_DELTAINFO, handle);
 748           indelta = 1;
 749           continue;
 750         }
 751       if (tag == CTAG('=', 'P', 'k', 'g')
 752            || tag == CTAG('=', 'P', 'a', 't'))
 753         {
 754           /* If we have an old solvable, complete it by filling in some
 755              default stuff.  */
 756           if (s)
 757             finish_solvable(&pd, s, freshens);
 758
 759           /*
 760            * define kind
 761            */
 762
 763           pd.kind = 0;
 764           if (line[3] == 't')
 765             pd.kind = "pattern";
 766
 767           /*
 768            * parse nevra
 769            */
 770
 771           if (split(line + 5, sp, 5) != 4)
 772             {
 773               pd.ret = pool_error(pool, -1, "susetags: line %d: bad line '%s'\n", pd.lineno, line);
 774               break;
 775             }
 776           s = 0;
 777           freshens = 0;
 778
 779           if (joinhash)
 780             {
 781               /* data join operation. find solvable matching name/arch/evr and
 782                * add data to it */
 783               Id name, evr, arch;
 784               /* we don't use the create flag here as a simple pre-check for existance */
 785               if (pd.kind)
 786                 name = pool_str2id(pool, join2(&pd.jd, pd.kind, ":", sp[0]), 0);
 787               else
 788                 name = pool_str2id(pool, sp[0], 0);
 789               evr = toevr(pool, &pd, sp[1], sp[2]);
 790               arch = pool_str2id(pool, sp[3], 0);
 791               if (name && arch)
 792                 {
 793                   Id start = (flags & REPO_EXTEND_SOLVABLES) ? 0 : first_new_pkg;
 794                   if (repo->start + last_found_pack + 1 >= start && repo->start + last_found_pack + 1 < repo->end)
 795                     {
 796                       s = pool->solvables + repo->start + last_found_pack + 1;
 797                       if (s->repo != repo || s->name != name || s->evr != evr || s->arch != arch)
 798                         s = 0;
 799                     }
 800                   if (!s)
 801                     s = joinhash_lookup(repo, joinhash, joinhashm, name, evr, arch, start);
 802                 }
 803               /* do not create new packages in EXTEND_SOLVABLES mode */
 804               if (!s && (flags & REPO_EXTEND_SOLVABLES) != 0)
 805                 continue;
 806               /* fallthrough to package creation */
 807             }
 808           if (!s)
 809             {
 810               /* normal operation. create a new solvable. */
 811               s = pool_id2solvable(pool, repo_add_solvable(repo));
 812               if (pd.kind)
 813                 s->name = pool_str2id(pool, join2(&pd.jd, pd.kind, ":", sp[0]), 1);
 814               else
 815                 s->name = pool_str2id(pool, sp[0], 1);
 816               s->evr = toevr(pool, &pd, sp[1], sp[2]);
 817               s->arch = pool_str2id(pool, sp[3], 1);
 818               s->vendor = defvendor;
 819               if (!first_new_pkg)
 820                 first_new_pkg = s - pool->solvables;
 821               createdpkgs = 1;
 822             }
 823           last_found_pack = (s - pool->solvables) - repo->start;
 824           if (data)
 825             handle = s - pool->solvables;
 826         }
 827
 828       /* If we have no current solvable to add to, ignore all further lines
 829          for it.  Probably invalid input data in the second set of
 830          solvables.  */
 831       if (indesc >= 2 && !s)
 832         {
 833 #if 0
 834           pool_debug(pool, SOLV_ERROR, "susetags: huh %d: %s?\n", pd.lineno, line);
 835 #endif
 836           continue;
 837         }
 838       switch (tag)
 839         {
 840           case CTAG('=', 'P', 'r', 'v'):                                        /* provides */
 841             if (line[6] == '/')
 842               {
 843                 /* probably a filelist entry. stash it away for now */
 844                 int l = strlen(line + 6) + 1;
 845                 if (pd.nfilelist + l > pd.afilelist)
 846                   {
 847                     pd.afilelist = pd.nfilelist + l + 512;
 848                     pd.filelist = solv_realloc(pd.filelist, pd.afilelist);
 849                   }
 850                 memcpy(pd.filelist + pd.nfilelist, line + 6, l);
 851                 pd.nfilelist += l;
 852                 break;
 853               }
 854             if (pd.nfilelist)
 855               {
 856                 int l;
 857                 for (l = 0; l < pd.nfilelist; l += strlen(pd.filelist + l) + 1)
 858                   s->provides = repo_addid_dep(pd.repo, s->provides, pool_str2id(pool, pd.filelist + l, 1), 0);
 859                 pd.nfilelist = 0;
 860               }
 861             s->provides = adddep(pool, &pd, s->provides, line, 0, pd.kind);
 862             continue;
 863           case CTAG('=', 'R', 'e', 'q'):                                        /* requires */
 864             s->requires = adddep(pool, &pd, s->requires, line, -SOLVABLE_PREREQMARKER, pd.kind);
 865             continue;
 866           case CTAG('=', 'P', 'r', 'q'):                                        /* pre-requires / packages required */
 867             if (pd.kind)
 868               {
 869                 s->requires = adddep(pool, &pd, s->requires, line, 0, 0);           /* patterns: a required package */
 870               }
 871             else
 872               s->requires = adddep(pool, &pd, s->requires, line, SOLVABLE_PREREQMARKER, 0); /* package: pre-requires */
 873             continue;
 874           case CTAG('=', 'O', 'b', 's'):                                        /* obsoletes */
 875             s->obsoletes = adddep(pool, &pd, s->obsoletes, line, 0, pd.kind);
 876             continue;
 877           case CTAG('=', 'C', 'o', 'n'):                                        /* conflicts */
 878             s->conflicts = adddep(pool, &pd, s->conflicts, line, 0, pd.kind);
 879             continue;
 880           case CTAG('=', 'R', 'e', 'c'):                                        /* recommends */
 881             s->recommends = adddep(pool, &pd, s->recommends, line, 0, pd.kind);
 882             continue;
 883           case CTAG('=', 'S', 'u', 'p'):                                        /* supplements */
 884             s->supplements = adddep(pool, &pd, s->supplements, line, 0, pd.kind);
 885             continue;
 886           case CTAG('=', 'E', 'n', 'h'):                                        /* enhances */
 887             s->enhances = adddep(pool, &pd, s->enhances, line, 0, pd.kind);
 888             continue;
 889           case CTAG('=', 'S', 'u', 'g'):                                        /* suggests */
 890             s->suggests = adddep(pool, &pd, s->suggests, line, 0, pd.kind);
 891             continue;
 892           case CTAG('=', 'F', 'r', 'e'):                                        /* freshens */
 893             freshens = adddep(pool, &pd, freshens, line, 0, pd.kind);
 894             continue;
 895           case CTAG('=', 'P', 'r', 'c'):                                        /* packages recommended */
 896             s->recommends = adddep(pool, &pd, s->recommends, line, 0, 0);
 897             continue;
 898           case CTAG('=', 'P', 's', 'g'):                                        /* packages suggested */
 899             s->suggests = adddep(pool, &pd, s->suggests, line, 0, 0);
 900             continue;
 901           case CTAG('=', 'P', 'c', 'n'):                                        /* pattern: package conflicts */
 902             s->conflicts = adddep(pool, &pd, s->conflicts, line, 0, 0);
 903             continue;
 904           case CTAG('=', 'P', 'o', 'b'):                                        /* pattern: package obsoletes */
 905             s->obsoletes = adddep(pool, &pd, s->obsoletes, line, 0, 0);
 906             continue;
 907           case CTAG('=', 'P', 'f', 'r'):                                        /* pattern: package freshens */
 908             freshens = adddep(pool, &pd, freshens, line, 0, 0);
 909             continue;
 910           case CTAG('=', 'P', 's', 'p'):                                        /* pattern: package supplements */
 911             s->supplements = adddep(pool, &pd, s->supplements, line, 0, 0);
 912             continue;
 913           case CTAG('=', 'P', 'e', 'n'):                                        /* pattern: package enhances */
 914             s->enhances = adddep(pool, &pd, s->enhances, line, 0, 0);
 915             continue;
 916           case CTAG('=', 'V', 'e', 'r'):                                        /* - version - */
 917             last_found_pack = 0;
 918             handle = 0;
 919             indesc++;
 920             if (createdpkgs)
 921               {
 922                 solv_free(joinhash);
 923                 joinhash = joinhash_init(repo, &joinhashm);
 924                 createdpkgs = 0;
 925               }
 926             continue;
 927           case CTAG('=', 'V', 'n', 'd'):                                        /* vendor */
 928             s->vendor = pool_str2id(pool, line + 6, 1);
 929             continue;
 930
 931         /* From here it's the attribute tags.  */
 932           case CTAG('=', 'G', 'r', 'p'):
 933             repodata_set_poolstr(data, handle, SOLVABLE_GROUP, line + 6);
 934             continue;
 935           case CTAG('=', 'L', 'i', 'c'):
 936             repodata_set_poolstr(data, handle, SOLVABLE_LICENSE, line + 6);
 937             continue;
 938           case CTAG('=', 'L', 'o', 'c'):
 939             {
 940               int i = split(line + 6, sp, 3);
 941               if (i != 2 && i != 3)
 942                 {
 943                   pd.ret = pool_error(pool, -1, "susetags: line %d: bad location line '%s'\n", pd.lineno, line);
 944                   continue;
 945                 }
 946               repodata_set_location(data, handle, atoi(sp[0]), i == 3 ? sp[2] : pool_id2str(pool, s->arch), sp[1]);
 947             }
 948             continue;
 949           case CTAG('=', 'S', 'r', 'c'):
 950             add_source(&pd, line + 6, s, handle);
 951             continue;
 952           case CTAG('=', 'S', 'i', 'z'):
 953             if (split(line + 6, sp, 3) == 2)
 954               {
 955                 repodata_set_num(data, handle, SOLVABLE_DOWNLOADSIZE, strtoull(sp[0], 0, 10));
 956                 repodata_set_num(data, handle, SOLVABLE_INSTALLSIZE, strtoull(sp[1], 0, 10));
 957               }
 958             continue;
 959           case CTAG('=', 'T', 'i', 'm'):
 960             {
 961               unsigned int t = atoi(line + 6);
 962               if (t)
 963                 repodata_set_num(data, handle, SOLVABLE_BUILDTIME, t);
 964             }
 965             continue;
 966           case CTAG('=', 'K', 'w', 'd'):
 967             repodata_add_poolstr_array(data, handle, SOLVABLE_KEYWORDS, line + 6);
 968             continue;
 969           case CTAG('=', 'A', 'u', 't'):
 970             repodata_set_str(data, handle, SOLVABLE_AUTHORS, line + 6);
 971             continue;
 972           case CTAG('=', 'S', 'u', 'm'):
 973             repodata_set_str(data, handle, langtag(&pd, SOLVABLE_SUMMARY, line_lang), line + 3 + keylen);
 974             continue;
 975           case CTAG('=', 'D', 'e', 's'):
 976             repodata_set_str(data, handle, langtag(&pd, SOLVABLE_DESCRIPTION, line_lang), line + 3 + keylen);
 977             continue;
 978           case CTAG('=', 'E', 'u', 'l'):
 979             repodata_set_str(data, handle, langtag(&pd, SOLVABLE_EULA, line_lang), line + 6);
 980             continue;
 981           case CTAG('=', 'I', 'n', 's'):
 982             repodata_set_str(data, handle, langtag(&pd, SOLVABLE_MESSAGEINS, line_lang), line + 6);
 983             continue;
 984           case CTAG('=', 'D', 'e', 'l'):
 985             repodata_set_str(data, handle, langtag(&pd, SOLVABLE_MESSAGEDEL, line_lang), line + 6);
 986             continue;
 987           case CTAG('=', 'V', 'i', 's'):
 988             {
 989               /* Accept numbers and textual bools.  */
 990               int k;
 991               k = atoi(line + 6);
 992               if (k || !strcasecmp(line + 6, "true"))
 993                 repodata_set_void(data, handle, SOLVABLE_ISVISIBLE);
 994             }
 995             continue;
 996           case CTAG('=', 'S', 'h', 'r'):
 997             {
 998               Id name, evr, arch;
 999               if (split(line + 6, sp, 5) != 4)
1000                 {
1001                   pd.ret = pool_error(pool, -1, "susetags: line %d: bad =Shr line '%s'\n", pd.lineno, line);
1002                   continue;
1003                 }
1004               name = pool_str2id(pool, sp[0], 1);
1005               evr = toevr(pool, &pd, sp[1], sp[2]);
1006               arch = pool_str2id(pool, sp[3], 1);
1007               if (last_found_pack >= pd.nshare)
1008                 {
1009                   pd.share_with = solv_realloc2(pd.share_with, last_found_pack + 256, sizeof(*pd.share_with));
1010                   memset(pd.share_with + pd.nshare, 0, (last_found_pack + 256 - pd.nshare) * sizeof(*pd.share_with));
1011                   pd.nshare = last_found_pack + 256;
1012                 }
1013               pd.share_with[last_found_pack].name = name;
1014               pd.share_with[last_found_pack].evr = evr;
1015               pd.share_with[last_found_pack].arch = arch;
1016               if ((flags & SUSETAGS_RECORD_SHARES) != 0)
1017                 {
1018                   if (s->name == name)
1019                     repodata_set_void(data, handle, SUSETAGS_SHARE_NAME);
1020                   else
1021                     repodata_set_id(data, handle, SUSETAGS_SHARE_NAME, name);
1022                   if (s->evr == evr)
1023                     repodata_set_void(data, handle, SUSETAGS_SHARE_EVR);
1024                   else
1025                     repodata_set_id(data, handle, SUSETAGS_SHARE_EVR, evr);
1026                   if (s->arch == arch)
1027                     repodata_set_void(data, handle, SUSETAGS_SHARE_ARCH);
1028                   else
1029                     repodata_set_id(data, handle, SUSETAGS_SHARE_ARCH, arch);
1030                 }
1031               continue;
1032             }
1033           case CTAG('=', 'D', 'i', 'r'):
1034             add_dirline(&pd, line + 6);
1035             continue;
1036           case CTAG('=', 'C', 'a', 't'):
1037             repodata_set_poolstr(data, handle, langtag(&pd, SOLVABLE_CATEGORY, line_lang), line + 3 + keylen);
1038             break;
1039           case CTAG('=', 'O', 'r', 'd'):
1040             /* Order is a string not a number, so we can retroactively insert
1041                new patterns in the middle, i.e. 1 < 15 < 2.  */
1042             repodata_set_str(data, handle, SOLVABLE_ORDER, line + 6);
1043             break;
1044           case CTAG('=', 'I', 'c', 'o'):
1045             repodata_set_str(data, handle, SOLVABLE_ICON, line + 6);
1046             break;
1047           case CTAG('=', 'E', 'x', 't'):
1048             repodata_add_poolstr_array(data, handle, SOLVABLE_EXTENDS, join2(&pd.jd, "pattern", ":", line + 6));
1049             break;
1050           case CTAG('=', 'I', 'n', 'c'):
1051             repodata_add_poolstr_array(data, handle, SOLVABLE_INCLUDES, join2(&pd.jd, "pattern", ":", line + 6));
1052             break;
1053           case CTAG('=', 'C', 'k', 's'):
1054             set_checksum(&pd, data, handle, SOLVABLE_CHECKSUM, line + 6);
1055             break;
1056           case CTAG('=', 'L', 'a', 'n'):
1057             pd.language = solv_free(pd.language);
1058             memset(pd.langcache, 0, sizeof(pd.langcache));
1059             if (line[6])
1060               pd.language = solv_strdup(line + 6);
1061             break;
1062
1063           case CTAG('=', 'F', 'l', 's'):
1064             {
1065               char *p = strrchr(line + 6, '/');
1066               Id did;
1067               /* strip trailing slash */
1068               if (p && p != line + 6 && !p[1])
1069                 {
1070                   *p = 0;
1071                   p = strrchr(line + 6, '/');
1072                 }
1073               if (p)
1074                 {
1075                   *p++ = 0;
1076                   did = repodata_str2dir(data, line + 6, 1);
1077                 }
1078               else
1079                 {
1080                   p = line + 6;
1081                   did = 0;
1082                 }
1083               if (!did)
1084                 did = repodata_str2dir(data, "/", 1);
1085               repodata_add_dirstr(data, handle, SOLVABLE_FILELIST, did, p);
1086               break;
1087             }
1088           case CTAG('=', 'H', 'd', 'r'):
1089             /* rpm header range */
1090             if (split(line + 6, sp, 3) == 2)
1091               {
1092                 /* we ignore the start value */
1093                 unsigned int end = (unsigned int)atoi(sp[1]);
1094                 if (end)
1095                   repodata_set_num(data, handle, SOLVABLE_HEADEREND, end);
1096               }
1097             break;
1098
1099           case CTAG('=', 'P', 'a', 't'):
1100           case CTAG('=', 'P', 'k', 'g'):
1101             break;
1102
1103           default:
1104 #if 0
1105             pool_debug(pool, SOLV_WARN, "susetags: unknown line: %d: %s\n", pd.lineno, line);
1106 #endif
1107             break;
1108         }
1109
1110     }
1111
1112   if (s)
1113     finish_solvable(&pd, s, freshens);
1114   solv_free(pd.filelist);
1115
1116   /* Shared attributes
1117    *  (e.g. multiple binaries built from same source)
1118    */
1119   if (pd.nshare)
1120     {
1121       int i, last_found;
1122       Map keyidmap;
1123
1124       map_init(&keyidmap, data->nkeys);
1125       for (i = 1; i < data->nkeys; i++)
1126         {
1127           Id keyname = data->keys[i].name;
1128           if (keyname == SOLVABLE_INSTALLSIZE || keyname == SOLVABLE_DISKUSAGE || keyname == SOLVABLE_FILELIST)
1129             continue;
1130           if (keyname == SOLVABLE_MEDIADIR || keyname == SOLVABLE_MEDIAFILE || keyname == SOLVABLE_MEDIANR)
1131             continue;
1132           if (keyname == SOLVABLE_DOWNLOADSIZE || keyname == SOLVABLE_CHECKSUM)
1133             continue;
1134           if (keyname == SOLVABLE_SOURCENAME || keyname == SOLVABLE_SOURCEARCH || keyname == SOLVABLE_SOURCEEVR)
1135             continue;
1136           if (keyname == SOLVABLE_PKGID || keyname == SOLVABLE_HDRID || keyname == SOLVABLE_LEADSIGID)
1137             continue;
1138           if (keyname == SUSETAGS_SHARE_NAME || keyname == SUSETAGS_SHARE_EVR || keyname == SUSETAGS_SHARE_ARCH)
1139             continue;
1140           MAPSET(&keyidmap, i);
1141         }
1142       last_found = 0;
1143       for (i = 0; i < pd.nshare; i++)
1144         {
1145           unsigned int n, nn;
1146           Solvable *found = 0;
1147           if (!pd.share_with[i].name)
1148             continue;
1149           for (n = repo->start, nn = repo->start + last_found; n < repo->end; n++, nn++)
1150             {
1151               if (nn >= repo->end)
1152                 nn = repo->start;
1153               found = pool->solvables + nn;
1154               if (found->repo == repo
1155                   && found->name == pd.share_with[i].name
1156                   && found->evr == pd.share_with[i].evr
1157                   && found->arch == pd.share_with[i].arch)
1158                 {
1159                   last_found = nn - repo->start;
1160                   break;
1161                 }
1162             }
1163           if (n != repo->end)
1164             repodata_merge_some_attrs(data, repo->start + i, repo->start + last_found, &keyidmap, 0);
1165         }
1166       free(pd.share_with);
1167       map_free(&keyidmap);
1168     }
1169
1170   solv_free(joinhash);
1171   repodata_free_dircache(data);
1172   if (!(flags & REPO_NO_INTERNALIZE))
1173     repodata_internalize(data);
1174
1175   solv_free(pd.language);
1176   solv_free(line);
1177   join_freemem(&pd.jd);
1178   return pd.ret;
1179 }