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