src/solvable.c

   1 /*
   2  * Copyright (c) 2008, Novell Inc.
   3  *
   4  * This program is licensed under the BSD license, read LICENSE.BSD
   5  * for further information
   6  */
   7
   8 /*
   9  * solvable.c
  10  *
  11  * set/retrieve data from solvables
  12  */
  13
  14 #include <stdio.h>
  15 #include <stdlib.h>
  16 #include <stdarg.h>
  17 #include <unistd.h>
  18 #include <string.h>
  19
  20 #include "pool.h"
  21 #include "repo.h"
  22 #include "util.h"
  23 #include "policy.h"
  24 #include "poolvendor.h"
  25 #include "chksum.h"
  26 #include "linkedpkg.h"
  27
  28 const char *
  29 pool_solvable2str(Pool *pool, Solvable *s)
  30 {
  31   const char *n, *e, *a;
  32   int nl, el, al;
  33   char *p;
  34   n = pool_id2str(pool, s->name);
  35   e = pool_id2str(pool, s->evr);
  36   /* XXX: may want to skip the epoch here */
  37   a = pool_id2str(pool, s->arch);
  38   nl = strlen(n);
  39   el = strlen(e);
  40   al = strlen(a);
  41   if (pool->havedistepoch)
  42     {
  43       /* strip the distepoch from the evr */
  44       const char *de = strrchr(e, '-');
  45       if (de && (de = strchr(de, ':')) != 0)
  46         el = de - e;
  47     }
  48   p = pool_alloctmpspace(pool, nl + el + al + 3);
  49   strcpy(p, n);
  50   if (el)
  51     {
  52       p[nl++] = '-';
  53       strncpy(p + nl, e, el);
  54       p[nl + el] = 0;
  55     }
  56   if (al)
  57     {
  58       p[nl + el] = pool->disttype == DISTTYPE_HAIKU ? '-' : '.';
  59       strcpy(p + nl + el + 1, a);
  60     }
  61   return p;
  62 }
  63
  64 Id
  65 solvable_lookup_type(Solvable *s, Id keyname)
  66 {
  67   if (!s->repo)
  68     return 0;
  69   return repo_lookup_type(s->repo, s - s->repo->pool->solvables, keyname);
  70 }
  71
  72 Id
  73 solvable_lookup_id(Solvable *s, Id keyname)
  74 {
  75   if (!s->repo)
  76     return 0;
  77   return repo_lookup_id(s->repo, s - s->repo->pool->solvables, keyname);
  78 }
  79
  80 int
  81 solvable_lookup_idarray(Solvable *s, Id keyname, Queue *q)
  82 {
  83   if (!s->repo)
  84     {
  85       queue_empty(q);
  86       return 0;
  87     }
  88   return repo_lookup_idarray(s->repo, s - s->repo->pool->solvables, keyname, q);
  89 }
  90
  91 int
  92 solvable_lookup_deparray(Solvable *s, Id keyname, Queue *q, Id marker)
  93 {
  94   if (!s->repo)
  95     {
  96       queue_empty(q);
  97       return 0;
  98     }
  99   return repo_lookup_deparray(s->repo, s - s->repo->pool->solvables, keyname, q, marker);
 100 }
 101
 102 static const char *
 103 solvable_lookup_str_joinarray(Solvable *s, Id keyname, const char *joinstr)
 104 {
 105   Queue q;
 106   Id qbuf[10];
 107   char *str = 0;
 108
 109   queue_init_buffer(&q, qbuf, sizeof(qbuf)/sizeof(*qbuf));
 110   if (solvable_lookup_idarray(s, keyname, &q) && q.count)
 111     {
 112       Pool *pool = s->repo->pool;
 113       int i;
 114       str = pool_tmpjoin(pool, pool_id2str(pool, q.elements[0]), 0, 0);
 115       for (i = 1; i < q.count; i++)
 116         str = pool_tmpappend(pool, str, joinstr, pool_id2str(pool, q.elements[i]));
 117     }
 118   queue_free(&q);
 119   return str;
 120 }
 121
 122 const char *
 123 solvable_lookup_str(Solvable *s, Id keyname)
 124 {
 125   const char *str;
 126   if (!s->repo)
 127     return 0;
 128   str = repo_lookup_str(s->repo, s - s->repo->pool->solvables, keyname);
 129   if (!str && (keyname == SOLVABLE_LICENSE || keyname == SOLVABLE_GROUP))
 130     str = solvable_lookup_str_joinarray(s, keyname, ", ");
 131   return str;
 132 }
 133
 134 static const char *
 135 solvable_lookup_str_base(Solvable *s, Id keyname, Id basekeyname, int usebase)
 136 {
 137   Pool *pool;
 138   const char *str, *basestr;
 139   Id p, pp, name;
 140   Solvable *s2;
 141   int pass;
 142
 143   if (!s->repo)
 144     return 0;
 145   pool = s->repo->pool;
 146   str = solvable_lookup_str(s, keyname);
 147   if (str || keyname == basekeyname)
 148     return str;
 149   basestr = solvable_lookup_str(s, basekeyname);
 150   if (!basestr)
 151     return 0;
 152   /* search for a solvable with same name and same base that has the
 153    * translation */
 154   if (!pool->whatprovides)
 155     return usebase ? basestr : 0;
 156   name = s->name;
 157   /* we do this in two passes, first same vendor, then all other vendors */
 158   for (pass = 0; pass < 2; pass++)
 159     {
 160       FOR_PROVIDES(p, pp, name)
 161         {
 162           s2 = pool->solvables + p;
 163           if (s2->name != name)
 164             continue;
 165           if ((s->vendor == s2->vendor) != (pass == 0))
 166             continue;
 167           str = solvable_lookup_str(s2, basekeyname);
 168           if (!str || strcmp(str, basestr))
 169             continue;
 170           str = solvable_lookup_str(s2, keyname);
 171           if (str)
 172             return str;
 173         }
 174 #ifdef ENABLE_LINKED_PKGS
 175       /* autopattern/product translation magic */
 176       if (pass)
 177         {
 178           const char *n = pool_id2str(pool, name);
 179           if (*n == 'p')
 180             {
 181               if (!strncmp("pattern:", n, 8) && (name = find_autopattern_name(pool, s)) != 0)
 182                 pass = -1;
 183               if (!strncmp("product:", n, 8) && (name = find_autoproduct_name(pool, s)) != 0)
 184                 pass = -1;
 185             }
 186         }
 187 #endif
 188     }
 189   return usebase ? basestr : 0;
 190 }
 191
 192 const char *
 193 solvable_lookup_str_poollang(Solvable *s, Id keyname)
 194 {
 195   Pool *pool;
 196   int i, cols;
 197   const char *str;
 198   Id *row;
 199
 200   if (!s->repo)
 201     return 0;
 202   pool = s->repo->pool;
 203   if (!pool->nlanguages)
 204     return solvable_lookup_str(s, keyname);
 205   cols = pool->nlanguages + 1;
 206   if (!pool->languagecache)
 207     {
 208       pool->languagecache = solv_calloc(cols * ID_NUM_INTERNAL, sizeof(Id));
 209       pool->languagecacheother = 0;
 210     }
 211   if (keyname >= ID_NUM_INTERNAL)
 212     {
 213       row = pool->languagecache + ID_NUM_INTERNAL * cols;
 214       for (i = 0; i < pool->languagecacheother; i++, row += cols)
 215         if (*row == keyname)
 216           break;
 217       if (i >= pool->languagecacheother)
 218         {
 219           pool->languagecache = solv_realloc2(pool->languagecache, pool->languagecacheother + 1, cols * sizeof(Id));
 220           row = pool->languagecache + cols * (ID_NUM_INTERNAL + pool->languagecacheother++);
 221           *row = keyname;
 222         }
 223     }
 224   else
 225     row = pool->languagecache + keyname * cols;
 226   row++;        /* skip keyname */
 227   for (i = 0; i < pool->nlanguages; i++, row++)
 228     {
 229       if (!*row)
 230         *row = pool_id2langid(pool, keyname, pool->languages[i], 1);
 231       str = solvable_lookup_str_base(s, *row, keyname, 0);
 232       if (str)
 233         return str;
 234     }
 235   return solvable_lookup_str(s, keyname);
 236 }
 237
 238 const char *
 239 solvable_lookup_str_lang(Solvable *s, Id keyname, const char *lang, int usebase)
 240 {
 241   if (s->repo)
 242     {
 243       Id id = pool_id2langid(s->repo->pool, keyname, lang, 0);
 244       if (id)
 245         return solvable_lookup_str_base(s, id, keyname, usebase);
 246       if (!usebase)
 247         return 0;
 248     }
 249   return solvable_lookup_str(s, keyname);
 250 }
 251
 252 unsigned long long
 253 solvable_lookup_num(Solvable *s, Id keyname, unsigned long long notfound)
 254 {
 255   if (!s->repo)
 256     return notfound;
 257   return repo_lookup_num(s->repo, s - s->repo->pool->solvables, keyname, notfound);
 258 }
 259
 260 unsigned int
 261 solvable_lookup_sizek(Solvable *s, Id keyname, unsigned int notfound)
 262 {
 263   unsigned long long size;
 264   if (!s->repo)
 265     return notfound;
 266   size = solvable_lookup_num(s, keyname, (unsigned long long)notfound << 10);
 267   return (unsigned int)((size + 1023) >> 10);
 268 }
 269
 270 int
 271 solvable_lookup_void(Solvable *s, Id keyname)
 272 {
 273   if (!s->repo)
 274     return 0;
 275   return repo_lookup_void(s->repo, s - s->repo->pool->solvables, keyname);
 276 }
 277
 278 int
 279 solvable_lookup_bool(Solvable *s, Id keyname)
 280 {
 281   if (!s->repo)
 282     return 0;
 283   /* historic nonsense: there are two ways of storing a bool, as num == 1 or void. test both. */
 284   if (repo_lookup_type(s->repo, s - s->repo->pool->solvables, keyname) == REPOKEY_TYPE_VOID)
 285     return 1;
 286   return repo_lookup_num(s->repo, s - s->repo->pool->solvables, keyname, 0) == 1;
 287 }
 288
 289 const unsigned char *
 290 solvable_lookup_bin_checksum(Solvable *s, Id keyname, Id *typep)
 291 {
 292   Repo *repo = s->repo;
 293
 294   if (!repo)
 295     {
 296       *typep = 0;
 297       return 0;
 298     }
 299   return repo_lookup_bin_checksum(repo, s - repo->pool->solvables, keyname, typep);
 300 }
 301
 302 const char *
 303 solvable_lookup_checksum(Solvable *s, Id keyname, Id *typep)
 304 {
 305   const unsigned char *chk = solvable_lookup_bin_checksum(s, keyname, typep);
 306   return chk ? pool_bin2hex(s->repo->pool, chk, solv_chksum_len(*typep)) : 0;
 307 }
 308
 309 static inline const char *
 310 evrid2vrstr(Pool *pool, Id evrid)
 311 {
 312   const char *p, *evr = pool_id2str(pool, evrid);
 313   if (!evr)
 314     return evr;
 315   for (p = evr; *p >= '0' && *p <= '9'; p++)
 316     ;
 317   return p != evr && *p == ':' && p[1] ? p + 1 : evr;
 318 }
 319
 320 const char *
 321 solvable_lookup_location(Solvable *s, unsigned int *medianrp)
 322 {
 323   Pool *pool;
 324   int l = 0;
 325   char *loc;
 326   const char *mediadir, *mediafile;
 327
 328   if (medianrp)
 329     *medianrp = 0;
 330   if (!s->repo)
 331     return 0;
 332   pool = s->repo->pool;
 333   if (medianrp)
 334     *medianrp = solvable_lookup_num(s, SOLVABLE_MEDIANR, 0);
 335   if (solvable_lookup_void(s, SOLVABLE_MEDIADIR))
 336     mediadir = pool_id2str(pool, s->arch);
 337   else
 338     mediadir = solvable_lookup_str(s, SOLVABLE_MEDIADIR);
 339   if (mediadir)
 340     l = strlen(mediadir) + 1;
 341   if (solvable_lookup_void(s, SOLVABLE_MEDIAFILE))
 342     {
 343       const char *name, *evr, *arch;
 344       name = pool_id2str(pool, s->name);
 345       evr = evrid2vrstr(pool, s->evr);
 346       arch = pool_id2str(pool, s->arch);
 347       /* name-vr.arch.rpm */
 348       loc = pool_alloctmpspace(pool, l + strlen(name) + strlen(evr) + strlen(arch) + 7);
 349       if (mediadir)
 350         sprintf(loc, "%s/%s-%s.%s.rpm", mediadir, name, evr, arch);
 351       else
 352         sprintf(loc, "%s-%s.%s.rpm", name, evr, arch);
 353     }
 354   else
 355     {
 356       mediafile = solvable_lookup_str(s, SOLVABLE_MEDIAFILE);
 357       if (!mediafile)
 358         return 0;
 359       loc = pool_alloctmpspace(pool, l + strlen(mediafile) + 1);
 360       if (mediadir)
 361         sprintf(loc, "%s/%s", mediadir, mediafile);
 362       else
 363         strcpy(loc, mediafile);
 364     }
 365   return loc;
 366 }
 367
 368 const char *
 369 solvable_get_location(Solvable *s, unsigned int *medianrp)
 370 {
 371   const char *loc = solvable_lookup_location(s, medianrp);
 372   if (medianrp && *medianrp == 0)
 373     *medianrp = 1;      /* compat, to be removed */
 374   return loc;
 375 }
 376
 377 const char *
 378 solvable_lookup_sourcepkg(Solvable *s)
 379 {
 380   Pool *pool;
 381   const char *evr, *name;
 382   Id archid;
 383
 384   if (!s->repo)
 385     return 0;
 386   pool = s->repo->pool;
 387   if (solvable_lookup_void(s, SOLVABLE_SOURCENAME))
 388     name = pool_id2str(pool, s->name);
 389   else
 390     name = solvable_lookup_str(s, SOLVABLE_SOURCENAME);
 391   if (!name)
 392     return 0;
 393   archid = solvable_lookup_id(s, SOLVABLE_SOURCEARCH);
 394   if (solvable_lookup_void(s, SOLVABLE_SOURCEEVR))
 395     evr = evrid2vrstr(pool, s->evr);
 396   else
 397     evr = solvable_lookup_str(s, SOLVABLE_SOURCEEVR);
 398   if (archid == ARCH_SRC || archid == ARCH_NOSRC)
 399     {
 400       char *str;
 401       str = pool_tmpjoin(pool, name, evr ? "-" : 0, evr);
 402       str = pool_tmpappend(pool, str, ".", pool_id2str(pool, archid));
 403       return pool_tmpappend(pool, str, ".rpm", 0);
 404     }
 405   else
 406     return name;        /* FIXME */
 407 }
 408
 409
 410 /*****************************************************************************/
 411
 412 /*
 413  * Create maps containing the state of each solvable. Input is a "installed" queue,
 414  * it contains all solvable ids that are considered to be installed.
 415  *
 416  * The created maps can be used for * pool_calc_duchanges() and
 417  * pool_calc_installsizechange().
 418  *
 419  */
 420 void
 421 pool_create_state_maps(Pool *pool, Queue *installed, Map *installedmap, Map *conflictsmap)
 422 {
 423   int i;
 424   Solvable *s;
 425   Id p, *dp;
 426   Id *conp, con;
 427
 428   map_init(installedmap, pool->nsolvables);
 429   if (conflictsmap)
 430     map_init(conflictsmap, pool->nsolvables);
 431   for (i = 0; i < installed->count; i++)
 432     {
 433       p = installed->elements[i];
 434       if (p <= 0)       /* makes it work with decisionq */
 435         continue;
 436       MAPSET(installedmap, p);
 437       if (!conflictsmap)
 438         continue;
 439       s = pool->solvables + p;
 440       if (!s->conflicts)
 441         continue;
 442       conp = s->repo->idarraydata + s->conflicts;
 443       while ((con = *conp++) != 0)
 444         {
 445           dp = pool_whatprovides_ptr(pool, con);
 446           for (; *dp; dp++)
 447             MAPSET(conflictsmap, *dp);
 448         }
 449     }
 450 }
 451
 452 /* Tests if two solvables have identical content. Currently
 453  * both solvables need to come from the same pool
 454  */
 455
 456 int
 457 solvable_identical(Solvable *s1, Solvable *s2)
 458 {
 459   unsigned int bt1, bt2;
 460   Id rq1, rq2;
 461   Id *reqp;
 462   if (s1->name != s2->name)
 463     return 0;
 464   if (s1->arch != s2->arch)
 465     return 0;
 466   if (s1->evr != s2->evr)
 467     return 0;
 468
 469   /* check vendor, map missing vendor to empty string */
 470   if ((s1->vendor ? s1->vendor : 1) != (s2->vendor ? s2->vendor : 1))
 471     {
 472       /* workaround for bug 881493 */
 473       if (s1->repo && !strncmp(pool_id2str(s1->repo->pool, s1->name), "product:", 8))
 474         return 1;
 475       return 0;
 476     }
 477
 478   /* looking good, try some fancier stuff */
 479   /* might also look up the package checksum here */
 480   bt1 = solvable_lookup_num(s1, SOLVABLE_BUILDTIME, 0);
 481   bt2 = solvable_lookup_num(s2, SOLVABLE_BUILDTIME, 0);
 482   if (bt1 && bt2)
 483     {
 484       if (bt1 != bt2)
 485         return 0;
 486     }
 487   else
 488     {
 489       if (s1->repo)
 490         {
 491           /* workaround for bugs 881493 and 885830*/
 492           const char *n = pool_id2str(s1->repo->pool, s1->name);
 493           if (!strncmp(n, "product:", 8) || !strncmp(n, "application:", 12))
 494             return 1;
 495         }
 496       /* look at requires in a last attempt to find recompiled packages */
 497       rq1 = rq2 = 0;
 498       if (s1->requires)
 499         for (reqp = s1->repo->idarraydata + s1->requires; *reqp; reqp++)
 500           rq1 ^= *reqp;
 501       if (s2->requires)
 502         for (reqp = s2->repo->idarraydata + s2->requires; *reqp; reqp++)
 503           rq2 ^= *reqp;
 504       if (rq1 != rq2)
 505          return 0;
 506     }
 507   return 1;
 508 }
 509
 510 /* return the self provide dependency of a solvable */
 511 Id
 512 solvable_selfprovidedep(Solvable *s)
 513 {
 514   Pool *pool;
 515   Reldep *rd;
 516   Id prov, *provp;
 517
 518   if (!s->repo)
 519     return s->name;
 520   pool = s->repo->pool;
 521   if (s->provides)
 522     {
 523       provp = s->repo->idarraydata + s->provides;
 524       while ((prov = *provp++) != 0)
 525         {
 526           if (!ISRELDEP(prov))
 527             continue;
 528           rd = GETRELDEP(pool, prov);
 529           if (rd->name == s->name && rd->evr == s->evr && rd->flags == REL_EQ)
 530             return prov;
 531         }
 532     }
 533   return pool_rel2id(pool, s->name, s->evr, REL_EQ, 1);
 534 }
 535
 536 /* setter functions, simply call the repo variants */
 537 void
 538 solvable_set_id(Solvable *s, Id keyname, Id id)
 539 {
 540   repo_set_id(s->repo, s - s->repo->pool->solvables, keyname, id);
 541 }
 542
 543 void
 544 solvable_set_num(Solvable *s, Id keyname, unsigned long long num)
 545 {
 546   repo_set_num(s->repo, s - s->repo->pool->solvables, keyname, num);
 547 }
 548
 549 void
 550 solvable_set_str(Solvable *s, Id keyname, const char *str)
 551 {
 552   repo_set_str(s->repo, s - s->repo->pool->solvables, keyname, str);
 553 }
 554
 555 void
 556 solvable_set_poolstr(Solvable *s, Id keyname, const char *str)
 557 {
 558   repo_set_poolstr(s->repo, s - s->repo->pool->solvables, keyname, str);
 559 }
 560
 561 void
 562 solvable_add_poolstr_array(Solvable *s, Id keyname, const char *str)
 563 {
 564   repo_add_poolstr_array(s->repo, s - s->repo->pool->solvables, keyname, str);
 565 }
 566
 567 void
 568 solvable_add_idarray(Solvable *s, Id keyname, Id id)
 569 {
 570   repo_add_idarray(s->repo, s - s->repo->pool->solvables, keyname, id);
 571 }
 572
 573 void
 574 solvable_add_deparray(Solvable *s, Id keyname, Id dep, Id marker)
 575 {
 576   repo_add_deparray(s->repo, s - s->repo->pool->solvables, keyname, dep, marker);
 577 }
 578
 579 void
 580 solvable_set_idarray(Solvable *s, Id keyname, Queue *q)
 581 {
 582   repo_set_idarray(s->repo, s - s->repo->pool->solvables, keyname, q);
 583 }
 584
 585 void
 586 solvable_set_deparray(Solvable *s, Id keyname, Queue *q, Id marker)
 587 {
 588   repo_set_deparray(s->repo, s - s->repo->pool->solvables, keyname, q, marker);
 589 }
 590
 591 void
 592 solvable_unset(Solvable *s, Id keyname)
 593 {
 594   repo_unset(s->repo, s - s->repo->pool->solvables, keyname);
 595 }
 596
 597 /* return true if a dependency intersects dep in the keyname array */
 598 int
 599 solvable_matchesdep(Solvable *s, Id keyname, Id dep, int marker)
 600 {
 601   int i;
 602   Pool *pool = s->repo->pool;
 603   Queue q;
 604
 605   if (keyname == SOLVABLE_NAME)
 606     return pool_match_nevr(pool, s, dep) ? 1 : 0;       /* nevr match hack */
 607   queue_init(&q);
 608   solvable_lookup_deparray(s, keyname, &q, marker);
 609   for (i = 0; i < q.count; i++)
 610     if (pool_match_dep(pool, q.elements[i], dep))
 611       break;
 612   i = i == q.count ? 0 : 1;
 613   queue_free(&q);
 614   return i;
 615 }