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