src/linkedpkg.c

   1 /*
   2  * Copyright (c) 2013, SUSE Inc.
   3  *
   4  * This program is licensed under the BSD license, read LICENSE.BSD
   5  * for further information
   6  */
   7
   8 /*
   9  * linkedpkg.c
  10  *
  11  * Linked packages are "pseudo" packages that are bound to real packages but
  12  * contain different information (name/summary/description). They are normally
  13  * somehow generated from the real packages, either when the repositories are
  14  * created or automatically from the packages by looking at the provides.
  15  *
  16  * We currently support:
  17  *
  18  * application:
  19  *   created from AppStream appdata xml in the repository (which is generated
  20  *   from files in /usr/share/appdata)
  21  *
  22  * product:
  23  *   created from product data in the repository (which is generated from files
  24  *   in /etc/products.d). In the future we may switch to using product()
  25  *   provides of packages.
  26  *
  27  * pattern:
  28  *   created from pattern() provides of packages.
  29  *
  30  */
  31
  32 #include <stdio.h>
  33 #include <stdlib.h>
  34 #include <unistd.h>
  35 #include <string.h>
  36 #include <assert.h>
  37
  38 #include "pool.h"
  39 #include "repo.h"
  40 #include "solver.h"
  41 #include "evr.h"
  42 #include "bitmap.h"
  43 #include "linkedpkg.h"
  44
  45 #ifdef ENABLE_LINKED_PKGS
  46
  47 void
  48 find_application_link(Pool *pool, Solvable *s, Id *reqidp, Queue *qr, Id *prvidp, Queue *qp)
  49 {
  50   Id req = 0;
  51   Id prv = 0;
  52   Id p, pp;
  53   Id pkgname = 0, appdataid = 0;
  54
  55   /* find appdata requires */
  56   if (s->requires)
  57     {
  58       Id *reqp = s->repo->idarraydata + s->requires;
  59       while ((req = *reqp++) != 0)            /* go through all requires */
  60         {
  61           if (ISRELDEP(req))
  62             continue;
  63           if (!strncmp("appdata(", pool_id2str(pool, req), 8))
  64             appdataid = req;
  65           else
  66             pkgname = req;
  67         }
  68     }
  69   req = appdataid ? appdataid : pkgname;
  70   if (!req)
  71     return;
  72   /* find application-appdata provides */
  73   if (s->provides)
  74     {
  75       Id *prvp = s->repo->idarraydata + s->provides;
  76       const char *reqs = pool_id2str(pool, req);
  77       const char *prvs;
  78       while ((prv = *prvp++) != 0)            /* go through all provides */
  79         {
  80           if (ISRELDEP(prv))
  81             continue;
  82           prvs = pool_id2str(pool, prv);
  83           if (strncmp("application-appdata(", prvs, 20))
  84             continue;
  85           if (appdataid)
  86             {
  87               if (!strcmp(prvs + 12, reqs))
  88                 break;
  89             }
  90           else
  91             {
  92               int reqsl = strlen(reqs);
  93               if (!strncmp(prvs + 20, reqs, reqsl) && !strcmp(prvs + 20 + reqsl, ")"))
  94                 break;
  95             }
  96         }
  97     }
  98   if (!prv)
  99     return;     /* huh, no provides found? */
 100   /* now link em */
 101   FOR_PROVIDES(p, pp, req)
 102     if (pool->solvables[p].repo == s->repo)
 103       if (!pkgname || pool->solvables[p].name == pkgname)
 104         queue_push(qr, p);
 105   if (!qr->count && pkgname && appdataid)
 106     {
 107       /* huh, no matching package? try without pkgname filter */
 108       FOR_PROVIDES(p, pp, req)
 109         if (pool->solvables[p].repo == s->repo)
 110           queue_push(qr, p);
 111     }
 112   if (qp)
 113     {
 114       FOR_PROVIDES(p, pp, prv)
 115         if (pool->solvables[p].repo == s->repo)
 116           queue_push(qp, p);
 117     }
 118   if (reqidp)
 119     *reqidp = req;
 120   if (prvidp)
 121     *prvidp = prv;
 122 }
 123
 124 void
 125 find_product_link(Pool *pool, Solvable *s, Id *reqidp, Queue *qr, Id *prvidp, Queue *qp)
 126 {
 127   Id p, pp, namerelid;
 128   char *str;
 129   unsigned int sbt = 0;
 130
 131   /* search for project requires */
 132   namerelid = 0;
 133   if (s->requires)
 134     {
 135       Id req, *reqp = s->repo->idarraydata + s->requires;
 136       const char *nn = pool_id2str(pool, s->name);
 137       int nnl = strlen(nn);
 138       while ((req = *reqp++) != 0)            /* go through all requires */
 139         if (ISRELDEP(req))
 140           {
 141             const char *rn;
 142             Reldep *rd = GETRELDEP(pool, req);
 143             if (rd->flags != REL_EQ || rd->evr != s->evr)
 144               continue;
 145             rn = pool_id2str(pool, rd->name);
 146             if (!strncmp(rn, "product(", 8) && !strncmp(rn + 8, nn + 8, nnl - 8) && !strcmp( rn + nnl, ")"))
 147               {
 148                 namerelid = req;
 149                 break;
 150               }
 151           }
 152     }
 153   if (!namerelid)
 154     {
 155       /* too bad. construct from scratch */
 156       str = pool_tmpjoin(pool, pool_id2str(pool, s->name), ")", 0);
 157       str[7] = '(';
 158       namerelid = pool_rel2id(pool, pool_str2id(pool, str, 1), s->evr, REL_EQ, 1);
 159     }
 160   FOR_PROVIDES(p, pp, namerelid)
 161     {
 162       Solvable *ps = pool->solvables + p;
 163       if (ps->repo != s->repo || ps->arch != s->arch)
 164         continue;
 165       queue_push(qr, p);
 166     }
 167   if (qr->count > 1)
 168     {
 169       /* multiple providers. try buildtime filter */
 170       sbt = solvable_lookup_num(s, SOLVABLE_BUILDTIME, 0);
 171       if (sbt)
 172         {
 173           unsigned int bt;
 174           int i, j;
 175           int filterqp = 1;
 176           for (i = j = 0; i < qr->count; i++)
 177             {
 178               bt = solvable_lookup_num(pool->solvables + qr->elements[i], SOLVABLE_BUILDTIME, 0);
 179               if (!bt)
 180                 filterqp = 0;   /* can't filter */
 181               if (!bt || bt == sbt)
 182                 qr->elements[j++] = qr->elements[i];
 183             }
 184           if (j)
 185             qr->count = j;
 186           if (!j || !filterqp)
 187             sbt = 0;    /* filter failed */
 188         }
 189     }
 190   if (!qr->count && s->repo == pool->installed)
 191     {
 192       /* oh no! Look up reference file */
 193       Dataiterator di;
 194       const char *refbasename = solvable_lookup_str(s, PRODUCT_REFERENCEFILE);
 195       dataiterator_init(&di, pool, s->repo, 0, SOLVABLE_FILELIST, refbasename, SEARCH_STRING);
 196       while (dataiterator_step(&di))
 197         queue_push(qr, di.solvid);
 198       dataiterator_free(&di);
 199       if (qp)
 200         {
 201           dataiterator_init(&di, pool, s->repo, 0, PRODUCT_REFERENCEFILE, refbasename, SEARCH_STRING);
 202           while (dataiterator_step(&di))
 203             queue_push(qp, di.solvid);
 204           dataiterator_free(&di);
 205         }
 206     }
 207   else if (qp)
 208     {
 209       /* find qp */
 210       FOR_PROVIDES(p, pp, s->name)
 211         {
 212           Solvable *ps = pool->solvables + p;
 213           if (s->name != ps->name || ps->repo != s->repo || ps->arch != s->arch || s->evr != ps->evr)
 214             continue;
 215           if (sbt && solvable_lookup_num(ps, SOLVABLE_BUILDTIME, 0) != sbt)
 216             continue;
 217           queue_push(qp, p);
 218         }
 219     }
 220   if (reqidp)
 221     *reqidp = namerelid;
 222   if (prvidp)
 223     *prvidp = solvable_selfprovidedep(s);
 224 }
 225
 226 void
 227 find_pattern_link(Pool *pool, Solvable *s, Id *reqidp, Queue *qr, Id *prvidp, Queue *qp)
 228 {
 229   Id p, pp, *pr, apevr = 0, aprel = 0;
 230
 231   /* check if autopattern */
 232   if (!s->provides)
 233     return;
 234   for (pr = s->repo->idarraydata + s->provides; (p = *pr++) != 0; )
 235     if (ISRELDEP(p))
 236       {
 237         Reldep *rd = GETRELDEP(pool, p);
 238         if (rd->flags == REL_EQ && !strcmp(pool_id2str(pool, rd->name), "autopattern()"))
 239           {
 240             aprel = p;
 241             apevr = rd->evr;
 242             break;
 243           }
 244       }
 245   if (!apevr)
 246     return;
 247   FOR_PROVIDES(p, pp, apevr)
 248     {
 249       Solvable *s2 = pool->solvables + p;
 250       if (s2->repo == s->repo && s2->name == apevr && s2->evr == s->evr && s2->vendor == s->vendor)
 251         queue_push(qr, p);
 252     }
 253   if (qp)
 254     {
 255       FOR_PROVIDES(p, pp, aprel)
 256         {
 257           Solvable *s2 = pool->solvables + p;
 258           if (s2->repo == s->repo && s2->evr == s->evr && s2->vendor == s->vendor)
 259             queue_push(qp, p);
 260         }
 261     }
 262   if (reqidp)
 263     *reqidp = apevr;
 264   if (prvidp)
 265     *prvidp = aprel;
 266 }
 267
 268 /* the following two functions are used in solvable_lookup_str_base to do
 269  * translated lookups on the product/pattern packages
 270  */
 271 Id
 272 find_autopattern_name(Pool *pool, Solvable *s)
 273 {
 274   Id prv, *prvp;
 275   if (!s->provides)
 276     return 0;
 277   for (prvp = s->repo->idarraydata + s->provides; (prv = *prvp++) != 0; )
 278     if (ISRELDEP(prv))
 279       {
 280         Reldep *rd = GETRELDEP(pool, prv);
 281         if (rd->flags == REL_EQ && !strcmp(pool_id2str(pool, rd->name), "autopattern()"))
 282           return strncmp(pool_id2str(pool, rd->evr), "pattern:", 8) != 0 ? rd->evr : 0;
 283       }
 284   return 0;
 285 }
 286
 287 Id
 288 find_autoproduct_name(Pool *pool, Solvable *s)
 289 {
 290   Id prv, *prvp;
 291   if (!s->provides)
 292     return 0;
 293   for (prvp = s->repo->idarraydata + s->provides; (prv = *prvp++) != 0; )
 294     if (ISRELDEP(prv))
 295       {
 296         Reldep *rd = GETRELDEP(pool, prv);
 297         if (rd->flags == REL_EQ && !strcmp(pool_id2str(pool, rd->name), "autoproduct()"))
 298           return strncmp(pool_id2str(pool, rd->evr), "product:", 8) != 0 ? rd->evr : 0;
 299       }
 300   return 0;
 301 }
 302
 303 void
 304 find_package_link(Pool *pool, Solvable *s, Id *reqidp, Queue *qr, Id *prvidp, Queue *qp)
 305 {
 306   const char *name = pool_id2str(pool, s->name);
 307   if (name[0] == 'a' && !strncmp("application:", name, 12))
 308     find_application_link(pool, s, reqidp, qr, prvidp, qp);
 309   else if (name[0] == 'p' && !strncmp("pattern:", name, 7))
 310     find_pattern_link(pool, s, reqidp, qr, prvidp, qp);
 311   else if (name[0] == 'p' && !strncmp("product:", name, 8))
 312     find_product_link(pool, s, reqidp, qr, prvidp, qp);
 313 }
 314
 315 static int
 316 name_min_max(Pool *pool, Solvable *s, Id *namep, Id *minp, Id *maxp)
 317 {
 318   Queue q;
 319   Id qbuf[4];
 320   Id name, min, max;
 321   int i;
 322
 323   queue_init_buffer(&q, qbuf, sizeof(qbuf)/sizeof(*qbuf));
 324   find_package_link(pool, s, 0, &q, 0, 0);
 325   if (!q.count)
 326     {
 327       queue_free(&q);
 328       return 0;
 329     }
 330   s = pool->solvables + q.elements[0];
 331   name = s->name;
 332   min = max = s->evr;
 333   for (i = 1; i < q.count; i++)
 334     {
 335       s = pool->solvables + q.elements[i];
 336       if (s->name != name)
 337         {
 338           queue_free(&q);
 339           return 0;
 340         }
 341       if (s->evr == min || s->evr == max)
 342         continue;
 343       if (pool_evrcmp(pool, min, s->evr, EVRCMP_COMPARE) >= 0)
 344         min = s->evr;
 345       else if (min == max || pool_evrcmp(pool, max, s->evr, EVRCMP_COMPARE) <= 0)
 346         max = s->evr;
 347     }
 348   queue_free(&q);
 349   *namep = name;
 350   *minp = min;
 351   *maxp = max;
 352   return 1;
 353 }
 354
 355 int
 356 pool_link_evrcmp(Pool *pool, Solvable *s1, Solvable *s2)
 357 {
 358   Id name1, evrmin1, evrmax1;
 359   Id name2, evrmin2, evrmax2;
 360
 361   if (s1->name != s2->name)
 362     return 0;   /* can't compare */
 363   if (!name_min_max(pool, s1, &name1, &evrmin1, &evrmax1))
 364     return 0;
 365   if (!name_min_max(pool, s2, &name2, &evrmin2, &evrmax2))
 366     return 0;
 367   /* compare linked names */
 368   if (name1 != name2)
 369     return 0;
 370   if (evrmin1 == evrmin2 && evrmax1 == evrmax2)
 371     return 0;
 372   /* now compare evr intervals */
 373   if (evrmin1 == evrmax1 && evrmin2 == evrmax2)
 374     return pool_evrcmp(pool, evrmin1, evrmax2, EVRCMP_COMPARE);
 375   if (evrmin1 != evrmax2 && pool_evrcmp(pool, evrmin1, evrmax2, EVRCMP_COMPARE) > 0)
 376     return 1;
 377   if (evrmax1 != evrmin2 && pool_evrcmp(pool, evrmax1, evrmin2, EVRCMP_COMPARE) < 0)
 378     return -1;
 379   return 0;
 380 }
 381
 382 void
 383 extend_updatemap_to_buddies(Solver *solv)
 384 {
 385   Pool *pool = solv->pool;
 386   Repo *installed = solv->installed;
 387   Solvable *s;
 388   int p, ip;
 389
 390   if (!installed)
 391     return;
 392   if (!solv->updatemap.size || !solv->instbuddy)
 393     return;
 394   FOR_REPO_SOLVABLES(installed, p, s)
 395     {
 396       if (!MAPTST(&solv->updatemap, p - installed->start))
 397         continue;
 398       if ((ip = solv->instbuddy[p - installed->start]) <= 1)
 399         continue;
 400       if (!has_package_link(pool, s))   /* only look at pseudo -> real relations */
 401         continue;
 402       if (ip < installed->start || ip >= installed->end || pool->solvables[ip].repo != installed)
 403         continue;                       /* just in case... */
 404       MAPSET(&solv->updatemap, ip - installed->start);
 405     }
 406 }
 407
 408 #endif