- some bug fixes + stop handling, nothing fancy
[platform/upstream/libsolv.git] / src / repo.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 /*
9  * repo.c
10  *
11  * Manage metadata coming from one repository
12  * 
13  */
14
15 #include <stdio.h>
16 #include <stdlib.h>
17 #include <string.h>
18
19 #include "repo.h"
20 #include "pool.h"
21 #include "poolid_private.h"
22 #include "util.h"
23 #include "attr_store_p.h"
24
25 #define IDARRAY_BLOCK     4095
26
27
28 /*
29  * create empty repo
30  * and add to pool
31  */
32
33 Repo *
34 repo_create(Pool *pool, const char *name)
35 {
36   Repo *repo;
37
38   pool_freewhatprovides(pool);
39   repo = (Repo *)xcalloc(1, sizeof(*repo));
40   pool->repos = (Repo **)xrealloc(pool->repos, (pool->nrepos + 1) * sizeof(Repo *));
41   pool->repos[pool->nrepos++] = repo;
42   repo->name = name ? strdup(name) : 0;
43   repo->pool = pool;
44   repo->start = pool->nsolvables;
45   repo->end = pool->nsolvables;
46   repo->nsolvables = 0;
47   return repo;
48 }
49
50 static void
51 repo_freedata(Repo *repo)
52 {
53   xfree(repo->idarraydata);
54   xfree(repo->rpmdbid);
55   xfree((char *)repo->name);
56   xfree(repo);
57 }
58
59 /*
60  * add Id to repo
61  * olddeps = old array to extend
62  * 
63  */
64
65 Offset
66 repo_addid(Repo *repo, Offset olddeps, Id id)
67 {
68   Id *idarray;
69   int idarraysize;
70   int i;
71   
72   idarray = repo->idarraydata;
73   idarraysize = repo->idarraysize;
74
75   if (!idarray)                        /* alloc idarray if not done yet */
76     {
77       idarray = (Id *)xmalloc((1 + IDARRAY_BLOCK) * sizeof(Id));
78       idarray[0] = 0;
79       idarraysize = 1;
80       repo->lastoff = 0;
81     }
82
83   if (!olddeps)                         /* no deps yet */
84     {   
85       olddeps = idarraysize;
86       if ((idarraysize & IDARRAY_BLOCK) == 0)
87         idarray = (Id *)xrealloc(idarray, (idarraysize + 1 + IDARRAY_BLOCK) * sizeof(Id));
88     }   
89   else if (olddeps == repo->lastoff)    /* extend at end */
90     idarraysize--;
91   else                                  /* can't extend, copy old */
92     {
93       i = olddeps;
94       olddeps = idarraysize;
95       for (; idarray[i]; i++)
96         {
97           if ((idarraysize & IDARRAY_BLOCK) == 0)
98             idarray = (Id *)xrealloc(idarray, (idarraysize + 1 + IDARRAY_BLOCK) * sizeof(Id));
99           idarray[idarraysize++] = idarray[i];
100         }
101       if ((idarraysize & IDARRAY_BLOCK) == 0)
102         idarray = (Id *)xrealloc(idarray, (idarraysize + 1 + IDARRAY_BLOCK) * sizeof(Id));
103     }
104   
105   idarray[idarraysize++] = id;          /* insert Id into array */
106
107   if ((idarraysize & IDARRAY_BLOCK) == 0)   /* realloc if at block boundary */
108     idarray = (Id *)xrealloc(idarray, (idarraysize + 1 + IDARRAY_BLOCK) * sizeof(Id));
109
110   idarray[idarraysize++] = 0;           /* ensure NULL termination */
111
112   repo->idarraydata = idarray;
113   repo->idarraysize = idarraysize;
114   repo->lastoff = olddeps;
115
116   return olddeps;
117 }
118
119
120 /*
121  * add dependency (as Id) to repo
122  * olddeps = offset into idarraydata
123  * isreq = 0 for normal dep
124  * isreq = 1 for requires
125  * isreq = 2 for pre-requires
126  * 
127  */
128
129 Offset
130 repo_addid_dep(Repo *repo, Offset olddeps, Id id, int isreq)
131 {
132   Id oid, *oidp, *marker = 0;
133
134   if (!olddeps)
135     return repo_addid(repo, olddeps, id);
136
137   if (!isreq)
138     {
139       for (oidp = repo->idarraydata + olddeps; (oid = *oidp) != ID_NULL; oidp++)
140         {
141           if (oid == id)
142             return olddeps;
143         }
144       return repo_addid(repo, olddeps, id);
145     }
146
147   for (oidp = repo->idarraydata + olddeps; (oid = *oidp) != ID_NULL; oidp++)
148     {
149       if (oid == SOLVABLE_PREREQMARKER)
150         marker = oidp;
151       else if (oid == id)
152         break;
153     }
154
155   if (oid)
156     {
157       if (marker || isreq == 1)
158         return olddeps;
159       marker = oidp++;
160       for (; (oid = *oidp) != ID_NULL; oidp++)
161         if (oid == SOLVABLE_PREREQMARKER)
162           break;
163       if (!oid)
164         {
165           oidp--;
166           if (marker < oidp)
167             memmove(marker, marker + 1, (oidp - marker) * sizeof(Id));
168           *oidp = SOLVABLE_PREREQMARKER;
169           return repo_addid(repo, olddeps, id);
170         }
171       while (oidp[1])
172         oidp++;
173       memmove(marker, marker + 1, (oidp - marker) * sizeof(Id));
174       *oidp = id;
175       return olddeps;
176     }
177   if (isreq == 2 && !marker)
178     olddeps = repo_addid(repo, olddeps, SOLVABLE_PREREQMARKER);
179   else if (isreq == 1 && marker)
180     {
181       *marker++ = id;
182       id = *--oidp;
183       if (marker < oidp)
184         memmove(marker + 1, marker, (oidp - marker) * sizeof(Id));
185       *marker = SOLVABLE_PREREQMARKER;
186     }
187   return repo_addid(repo, olddeps, id);
188 }
189
190
191 /*
192  * reserve Ids
193  * make space for 'num' more dependencies
194  */
195
196 Offset
197 repo_reserve_ids(Repo *repo, Offset olddeps, int num)
198 {
199   num++;        /* room for trailing ID_NULL */
200
201   if (!repo->idarraysize)              /* ensure buffer space */
202     {
203       repo->idarraysize = 1;
204       repo->idarraydata = (Id *)xmalloc(((1 + num + IDARRAY_BLOCK) & ~IDARRAY_BLOCK) * sizeof(Id));
205       repo->idarraydata[0] = 0;
206       repo->lastoff = 1;
207       return 1;
208     }
209
210   if (olddeps && olddeps != repo->lastoff)   /* if not appending */
211     {
212       /* can't insert into idarray, this would invalidate all 'larger' offsets
213        * so create new space at end and move existing deps there.
214        * Leaving 'hole' at old position.
215        */
216       
217       Id *idstart, *idend;
218       int count;
219
220       for (idstart = idend = repo->idarraydata + olddeps; *idend++; )   /* find end */
221         ;
222       count = idend - idstart - 1 + num;               /* new size */
223
224       /* realloc if crossing block boundary */
225       if (((repo->idarraysize - 1) | IDARRAY_BLOCK) != ((repo->idarraysize + count - 1) | IDARRAY_BLOCK))
226         repo->idarraydata = (Id *)xrealloc(repo->idarraydata, ((repo->idarraysize + count + IDARRAY_BLOCK) & ~IDARRAY_BLOCK) * sizeof(Id));
227
228       /* move old deps to end */
229       olddeps = repo->lastoff = repo->idarraysize;
230       memcpy(repo->idarraydata + olddeps, idstart, count - num);
231       repo->idarraysize = olddeps + count - num;
232
233       return olddeps;
234     }
235
236   if (olddeps)                         /* appending */
237     repo->idarraysize--;
238
239   /* realloc if crossing block boundary */
240   if (((repo->idarraysize - 1) | IDARRAY_BLOCK) != ((repo->idarraysize + num - 1) | IDARRAY_BLOCK))
241     repo->idarraydata = (Id *)xrealloc(repo->idarraydata, ((repo->idarraysize + num + IDARRAY_BLOCK) & ~IDARRAY_BLOCK) * sizeof(Id));
242
243   /* appending or new */
244   repo->lastoff = olddeps ? olddeps : repo->idarraysize;
245
246   return repo->lastoff;
247 }
248
249
250 /*
251  * remove repo from pool, zero out solvables 
252  * 
253  */
254
255 void
256 repo_free(Repo *repo, int reuseids)
257 {
258   Pool *pool = repo->pool;
259   Solvable *s;
260   int i;
261
262   pool_freewhatprovides(pool);
263
264   if (reuseids && repo->end == pool->nsolvables)
265     {
266       /* it's ok to reuse the ids. As this is the last repo, we can
267          just shrink the solvable array */
268       for (i = repo->end - 1, s = pool->solvables + i; i >= repo->start; i--, s--)
269         if (s->repo != repo)
270           break;
271       repo->end = i + 1;
272       pool->nsolvables = i + 1;
273     }
274   /* zero out solvables belonging to this repo */
275   for (i = repo->start, s = pool->solvables + i; i < repo->end; i++, s++)
276     if (s->repo == repo)
277       memset(s, 0, sizeof(*s));
278   for (i = 0; i < pool->nrepos; i++)    /* find repo in pool */
279     if (pool->repos[i] == repo)
280       break;
281   if (i == pool->nrepos)               /* repo not in pool, return */
282     return;
283   if (i < pool->nrepos - 1)
284     memmove(pool->repos + i, pool->repos + i + 1, (pool->nrepos - 1 - i) * sizeof(Repo *));
285   pool->nrepos--;
286   repo_freedata(repo);
287 }
288
289 void
290 repo_freeallrepos(Pool *pool, int reuseids)
291 {
292   int i;
293
294   pool_freewhatprovides(pool);
295   for (i = 0; i < pool->nrepos; i++)
296     repo_freedata(pool->repos[i]);
297   pool->repos = xfree(pool->repos);
298   pool->nrepos = 0;
299   /* the first two solvables don't belong to a repo */
300   pool_free_solvable_block(pool, 2, pool->nsolvables - 2, reuseids);
301 }
302
303 Offset
304 repo_fix_legacy(Repo *repo, Offset provides, Offset supplements)
305 {
306   Pool *pool = repo->pool;
307   Id id, idp, idl, idns;
308   char buf[1024], *p, *dep;
309   int i;
310
311   if (provides)
312     {
313       for (i = provides; repo->idarraydata[i]; i++)
314         {
315           id = repo->idarraydata[i];
316           if (ISRELDEP(id))
317             continue;
318           dep = (char *)id2str(pool, id);
319           if (!strncmp(dep, "locale(", 7) && strlen(dep) < sizeof(buf) - 2)
320             {
321               idp = 0;
322               strcpy(buf + 2, dep);
323               dep = buf + 2 + 7;
324               if ((p = strchr(dep, ':')) != 0 && p != dep)
325                 {
326                   *p++ = 0;
327                   idp = str2id(pool, dep, 1);
328                   dep = p;
329                 }
330               id = 0;
331               while ((p = strchr(dep, ';')) != 0)
332                 {
333                   if (p == dep)
334                     {
335                       dep = p + 1;
336                       continue;
337                     }
338                   strncpy(dep - 9, "language:", 9);
339                   *p++ = 0;
340                   idl = str2id(pool, dep - 9, 1);
341                   if (id)
342                     id = rel2id(pool, id, idl, REL_OR, 1);
343                   else
344                     id = idl;
345                   dep = p;
346                 }
347               if (dep[0] && dep[1])
348                 {
349                   for (p = dep; *p && *p != ')'; p++)
350                     ;
351                   *p = 0;
352                   strncpy(dep - 9, "language:", 9);
353                   idl = str2id(pool, dep - 9, 1);
354                   if (id)
355                     id = rel2id(pool, id, idl, REL_OR, 1);
356                   else
357                     id = idl;
358                 }
359               if (idp)
360                 id = rel2id(pool, idp, id, REL_AND, 1);
361               if (id)
362                 supplements = repo_addid_dep(repo, supplements, id, 0);
363             }
364           else if ((p = strchr(dep, ':')) != 0 && p != dep && p[1] == '/' && strlen(dep) < sizeof(buf))
365             {
366               strcpy(buf, dep);
367               p = buf + (p - dep);
368               *p++ = 0;
369               idp = str2id(pool, buf, 1);
370               idns = str2id(pool, "namespace:installed", 1);
371               id = str2id(pool, p, 1);
372               id = rel2id(pool, idns, id, REL_NAMESPACE, 1);
373               id = rel2id(pool, idp, id, REL_AND, 1);
374               supplements = repo_addid_dep(repo, supplements, id, 0);
375             }
376         }
377     }
378   if (!supplements)
379     return 0;
380   for (i = supplements; repo->idarraydata[i]; i++)
381     {
382       id = repo->idarraydata[i];
383       if (ISRELDEP(id))
384         continue;
385       dep = (char *)id2str(pool, id);
386       if (!strncmp(dep, "system:modalias(", 16))
387         dep += 7;
388       if (!strncmp(dep, "modalias(", 9) && dep[9] && dep[10] && strlen(dep) < sizeof(buf))
389         {
390           strcpy(buf, dep);
391           p = strchr(buf + 9, ':');
392           idns = str2id(pool, "namespace:modalias", 1);
393           if (p && p != buf + 9 && strchr(p + 1, ':'))
394             {
395               *p++ = 0;
396               idp = str2id(pool, buf + 9, 1);
397               p[strlen(p) - 1] = 0;
398               id = str2id(pool, p, 1);
399               id = rel2id(pool, idns, id, REL_NAMESPACE, 1);
400               id = rel2id(pool, idp, id, REL_AND, 1);
401             }
402           else
403             {
404               p = buf + 9;
405               p[strlen(p) - 1] = 0;
406               id = str2id(pool, p, 1);
407               id = rel2id(pool, idns, id, REL_NAMESPACE, 1);
408             }
409           if (id)
410             repo->idarraydata[i] = id;
411         }
412       else if (!strncmp(dep, "packageand(", 11) && strlen(dep) < sizeof(buf))
413         {
414           strcpy(buf, dep);
415           id = 0;
416           dep = buf + 11;
417           while ((p = strchr(dep, ':')) != 0)
418             {
419               if (p == dep)
420                 {
421                   dep = p + 1;
422                   continue;
423                 }
424               *p++ = 0;
425               idp = str2id(pool, dep, 1);
426               if (id)
427                 id = rel2id(pool, id, idp, REL_AND, 1);
428               else
429                 id = idp;
430               dep = p;
431             }
432           if (dep[0] && dep[1])
433             {
434               dep[strlen(dep) - 1] = 0;
435               idp = str2id(pool, dep, 1);
436               if (id)
437                 id = rel2id(pool, id, idp, REL_AND, 1);
438               else
439                 id = idp;
440             }
441           if (id)
442             repo->idarraydata[i] = id;
443         }
444     }
445   return supplements;
446 }
447
448 static unsigned char *
449 data_read_id(unsigned char *dp, Id *idp)
450 {
451   Id x = 0;
452   unsigned char c;
453   for (;;)
454     {
455       c = *dp++;
456       if (!(c & 0x80))
457         {
458           *idp = (x << 7) ^ c;
459           return dp;
460         }
461       x = (x << 7) ^ c ^ 128;
462     }
463 }
464
465 static unsigned char *
466 data_skip(unsigned char *dp, int type)
467 {
468   switch (type)
469     {
470     case TYPE_VOID:
471       return dp;
472     case TYPE_ID:
473       while ((*dp & 0x80) != 0)
474         dp++;
475       return dp;
476     case TYPE_IDARRAY:
477     case TYPE_REL_IDARRAY:
478     case TYPE_IDVALUEARRAY:
479     case TYPE_IDVALUEVALUEARRAY:
480       while ((*dp & 0xc0) != 0)
481         dp++;
482       return dp;
483     default:
484       fprintf(stderr, "unknown type in data_skip\n");
485       exit(1);
486     }
487 }
488
489 static unsigned char *
490 forward_to_key(Repodata *data, Id key, Id schema, unsigned char *dp)
491 {
492   Id k, *keyp;
493
494   keyp = data->schemadata + schema;
495   while ((k = *keyp++) != 0)
496     {
497       if (k == key)
498         return dp;
499       if (data->keys[k].storage == KEY_STORAGE_VERTICAL_OFFSET)
500         {
501           /* skip that offset */
502           dp = data_skip(dp, TYPE_ID);
503           continue;
504         }
505       if (data->keys[k].storage != KEY_STORAGE_INCORE)
506         continue;
507       dp = data_skip(dp, data->keys[k].type);
508     }
509   return 0;
510 }
511
512 static unsigned char *
513 load_page_range(Repodata *data, unsigned int pstart, unsigned int pend)
514 {
515   /* add smart paging here */
516   return 0;
517 }
518
519 static unsigned char *
520 get_data(Repodata *data, Repokey *key, unsigned char **dpp)
521 {
522   Id off;
523   unsigned char *dp = *dpp;
524   int i, max;
525   unsigned int pstart, pend, poff, plen;
526
527   if (!dp)
528     return 0;
529   if (key->storage == KEY_STORAGE_INCORE)
530     {
531       *dpp = data_skip(dp, key->type);
532       return dp;
533     }
534   if (key->storage != KEY_STORAGE_VERTICAL_OFFSET)
535     return 0;
536   if (!data->fp)
537     return 0;
538   dp = data_read_id(dp, &off);
539   *dpp = dp;
540   if (key->type == TYPE_VOID)
541     return 0;
542   max = key->size - off;
543   if (max <= 0)
544     return 0;
545   /* we now have the offset, go into vertical */
546   for (i = key - data->keys - 1; i > 0; i--)
547     if (data->keys[i].storage == KEY_STORAGE_VERTICAL_OFFSET)
548       off += data->keys[i].size;
549   pstart = off / BLOB_PAGESIZE;
550   pend = pstart;
551   poff = off % BLOB_PAGESIZE;
552   plen = BLOB_PAGESIZE - poff;
553   for (;;)
554     {
555       if (plen > max)
556         plen = max;
557       dp = load_page_range(data, pstart, pend) + poff;
558       if (!dp)
559         return 0;
560       switch (key->type)
561         {
562         case TYPE_STR:
563           if (memchr(dp, 0, plen))
564             return dp;
565           break;
566         case TYPE_ID:
567           for (i = 0; i < plen; i++)
568             if ((dp[i] & 0x80) == 0)
569               return dp;
570           break;
571         case TYPE_IDARRAY:
572         case TYPE_REL_IDARRAY:
573         case TYPE_IDVALUEARRAY:
574         case TYPE_IDVALUEVALUEARRAY:
575           for (i = 0; i < plen; i++)
576             if ((dp[i] & 0xc0) == 0)
577               return dp;
578           break;
579         }
580       if (plen == max)
581         return 0;
582       pend++;
583       plen += BLOB_PAGESIZE;
584     }
585 }
586
587
588 const char *
589 repodata_lookup_str(Repodata *data, Id entry, Id key)
590 {
591   Id schema;
592   Id id, k, *kp, *keyp;
593   unsigned char *dp;
594
595   if (data->entryschemau8)
596     schema = data->entryschemau8[entry];
597   else
598     schema = data->entryschema[entry];
599   keyp = data->schemadata + schema;
600   /* make sure the schema of this solvable contains the key */
601   for (kp = keyp; (k = *kp++) != 0; )
602     if (k == key)
603       break;
604   if (k == 0)
605     return 0;
606   dp = forward_to_key(data, key, schema, data->incoredata + data->incoreoffset[entry]);
607   dp = get_data(data, data->keys + key, &dp);
608   if (!dp)
609     return 0;
610   if (data->keys[key].type == TYPE_STR)
611     return (const char *)dp;
612   /* id type, must either use global or local string strore*/
613   dp = data_read_id(dp, &id);
614 #if 0
615   /* not yet working */
616   return data->ss.stringspace + data->ss.strings[id];
617 #else
618   return id2str(data->repo->pool, id);
619 #endif
620 }
621
622 #define SEARCH_NEXT_KEY         1
623 #define SEARCH_NEXT_SOLVABLE    2
624 #define SEACH_STOP              3
625
626 struct matchdata
627 {
628   Pool *pool;
629   const char *matchstr;
630   int flags;
631 #if 0
632   regex_t regex;
633 #endif
634   int stop;
635   int (*callback)(void *data, Solvable *s, Id key, const char *str);
636   void *callback_data;
637 };
638
639 static void
640 domatch(Id p, Id key, struct matchdata *md, const char *str)
641 {
642   /* fill match code here */
643   md->stop = md->callback(md->callback_data, md->pool->solvables + p, key, str);
644 }
645
646 static void
647 repodata_search(Repodata *data, Id entry, Id key, struct matchdata *md)
648 {
649   Id schema;
650   Id id, k, *kp, *keyp;
651   unsigned char *dp, *ddp;
652   int onekey = 0;
653
654   if (data->entryschemau8)
655     schema = data->entryschemau8[entry];
656   else
657     schema = data->entryschema[entry];
658   keyp = data->schemadata + schema;
659   dp = data->incoredata + data->incoreoffset[entry];
660   if (key)
661     {
662       /* search in a specific key */
663       for (kp = keyp; (k = *kp++) != 0; )
664         if (k == key)
665           break;
666       if (k == 0)
667         return;
668       dp = forward_to_key(data, key, schema, dp);
669       if (!dp)
670         return;
671       keyp = kp - 1;
672       onekey = 1;
673     }
674   md->stop = 0;
675   while ((key = *keyp++) != 0)
676     {
677       ddp = get_data(data, data->keys + key, &dp);
678       while (ddp)
679         {
680           switch (data->keys[key].type)
681             {
682             case TYPE_STR:
683               domatch(data->start + entry, data->keys[key].name, md, (const char *)ddp);
684               ddp = 0;
685               break;
686             case TYPE_ID:
687               data_read_id(ddp, &id);
688               /* domatch */
689               ddp = 0;
690               break;
691             case TYPE_IDARRAY:
692               ddp = data_read_id(ddp, &id);
693               if ((id & 0x40) == 0)
694                 ddp = 0;
695               id = (id & 0x3f) | ((id >> 1) & ~0x3f);
696               /* domatch */
697               while (md->stop == SEARCH_NEXT_KEY && ddp)
698                 ddp = data_read_id(ddp, &id);
699               break;
700             default:
701               ddp = 0;
702             }
703         }
704       if (onekey || md->stop > SEARCH_NEXT_KEY)
705         return;
706     }
707 }
708
709 static void
710 domatch_idarray(Id p, Id key, struct matchdata *md, Id *ida)
711 {
712   for (; *ida && !md->stop; ida++)
713     domatch(p, key, md, id2str(md->pool, *ida));
714 }
715
716 static void
717 repo_search_md(Repo *repo, Id p, Id key, struct matchdata *md)
718 {
719   Pool *pool = repo->pool;
720   Repodata *data;
721   Solvable *s;
722   int i;
723
724   md->stop = 0;
725   if (!p)
726     {
727       for (p = repo->start, s = repo->pool->solvables + p; p < repo->end; p++, s++)
728         {
729           if (s->repo == repo)
730             repo_search_md(repo, p, key, md);
731           if (md->stop > SEARCH_NEXT_SOLVABLE)
732             break;
733         }
734       return;
735     }
736   s = pool->solvables + p;
737   switch(key)
738     {
739       case 0:
740       case SOLVABLE_NAME:
741         if (s->name)
742           domatch(p, SOLVABLE_NAME, md, id2str(pool, s->name));
743         if (key || md->stop > SEARCH_NEXT_KEY)
744           return;
745       case SOLVABLE_ARCH:
746         if (s->arch)
747           domatch(p, SOLVABLE_ARCH, md, id2str(pool, s->arch));
748         if (key || md->stop > SEARCH_NEXT_KEY)
749           return;
750       case SOLVABLE_EVR:
751         if (s->evr)
752           domatch(p, SOLVABLE_EVR, md, id2str(pool, s->evr));
753         if (key || md->stop > SEARCH_NEXT_KEY)
754           return;
755       case SOLVABLE_VENDOR:
756         if (s->vendor)
757           domatch(p, SOLVABLE_VENDOR, md, id2str(pool, s->vendor));
758         if (key || md->stop > SEARCH_NEXT_KEY)
759           return;
760       case SOLVABLE_PROVIDES:
761         if (s->provides)
762           domatch_idarray(p, SOLVABLE_PROVIDES, md, repo->idarraydata + s->provides);
763         if (key || md->stop > SEARCH_NEXT_KEY)
764           return;
765       case SOLVABLE_OBSOLETES:
766         if (s->obsoletes)
767           domatch_idarray(p, SOLVABLE_OBSOLETES, md, repo->idarraydata + s->obsoletes);
768         if (key || md->stop > SEARCH_NEXT_KEY)
769           return;
770       case SOLVABLE_CONFLICTS:
771         if (s->obsoletes)
772           domatch_idarray(p, SOLVABLE_CONFLICTS, md, repo->idarraydata + s->conflicts);
773         if (key || md->stop > SEARCH_NEXT_KEY)
774           return;
775       case SOLVABLE_REQUIRES:
776         if (s->requires)
777           domatch_idarray(p, SOLVABLE_REQUIRES, md, repo->idarraydata + s->requires);
778         if (key || md->stop > SEARCH_NEXT_KEY)
779           return;
780       case SOLVABLE_RECOMMENDS:
781         if (s->recommends)
782           domatch_idarray(p, SOLVABLE_RECOMMENDS, md, repo->idarraydata + s->recommends);
783         if (key || md->stop > SEARCH_NEXT_KEY)
784           return;
785       case SOLVABLE_SUPPLEMENTS:
786         if (s->supplements)
787           domatch_idarray(p, SOLVABLE_SUPPLEMENTS, md, repo->idarraydata + s->supplements);
788         if (key || md->stop > SEARCH_NEXT_KEY)
789           return;
790       case SOLVABLE_SUGGESTS:
791         if (s->suggests)
792           domatch_idarray(p, SOLVABLE_SUGGESTS, md, repo->idarraydata + s->suggests);
793         if (key || md->stop > SEARCH_NEXT_KEY)
794           return;
795       case SOLVABLE_ENHANCES:
796         if (s->enhances)
797           domatch_idarray(p, SOLVABLE_ENHANCES, md, repo->idarraydata + s->enhances);
798         if (key || md->stop > SEARCH_NEXT_KEY)
799           return;
800       case SOLVABLE_FRESHENS:
801         if (s->freshens)
802           domatch_idarray(p, SOLVABLE_FRESHENS, md, repo->idarraydata + s->freshens);
803         if (key || md->stop > SEARCH_NEXT_KEY)
804           return;
805       default:
806         break;
807     }
808
809   for (i = 0, data = repo->repodata; i < repo->nrepodata; i++, data++)
810     {
811       if (p < data->start || p >= data->end)
812         continue;
813       repodata_search(data, p - data->start, key, md);
814       if (md->stop > SEARCH_NEXT_KEY)
815         break;
816     }
817 }
818
819 void
820 repo_search(Repo *repo, Id p, Id key, const char *match, int flags, int (*callback)(void *data, Solvable *s, Id key, const char *str), void *callback_data)
821 {
822   struct matchdata md;
823
824   memset(&md, 0, sizeof(md));
825   md.pool = repo->pool;
826   md.matchstr = match;
827   md.flags = flags;
828   md.callback = callback;
829   md.callback_data = callback_data;
830   repo_search_md(repo, p, key, &md);
831 }
832
833 const char *
834 repo_lookup_str(Solvable *s, Id key)
835 {
836   Repo *repo = s->repo;
837   Pool *pool = repo->pool;
838   Repodata *data;
839   int i, j, n;
840
841   switch(key)
842     {
843     case SOLVABLE_NAME:
844       return id2str(pool, s->name);
845     case SOLVABLE_ARCH:
846       return id2str(pool, s->arch);
847     case SOLVABLE_EVR:
848       return id2str(pool, s->evr);
849     case SOLVABLE_VENDOR:
850       return id2str(pool, s->vendor);
851     }
852   n = s - pool->solvables;
853   for (i = 0, data = repo->repodata; i < repo->nrepodata; i++, data++)
854     {
855       if (n < data->start || n >= data->end)
856         continue;
857       for (j = 1; j < data->nkeys; j++)
858         {
859           if (data->keys[j].name == key && (data->keys[j].type == TYPE_ID || data->keys[j].type == TYPE_STR))
860             return repodata_lookup_str(data, n - data->start, j);
861         }
862     }
863   return 0;
864 }
865
866
867
868 static int
869 key_cmp (const void *pa, const void *pb)
870 {
871   Repokey *a = (Repokey *)pa;
872   Repokey *b = (Repokey *)pb;
873   return a->name - b->name;
874 }
875
876 void
877 repo_add_attrstore (Repo *repo, Attrstore *s, const char *location)
878 {
879   unsigned i;
880   Repodata *data;
881   /* If this is meant to be the embedded attributes, make sure we don't
882      have them already.  */
883   if (!location)
884     {
885       for (i = 0; i < repo->nrepodata; i++)
886         if (repo->repodata[i].location == 0)
887           break;
888       if (i != repo->nrepodata)
889         {
890           pool_debug (repo->pool, SAT_FATAL, "embedded attribs added twice\n");
891           exit (1);
892         }
893     }
894   repo->nrepodata++;
895   repo->repodata = xrealloc (repo->repodata, repo->nrepodata * sizeof (*data));
896   data = repo->repodata + repo->nrepodata - 1;
897   memset (data, 0, sizeof (*data));
898   data->s = s;
899   data->nkeys = s->nkeys;
900   if (data->nkeys)
901     {
902       data->keys = xmalloc(data->nkeys * sizeof(data->keys[0]));
903       for (i = 1; i < data->nkeys; i++)
904         {
905           data->keys[i].name = s->keys[i].name;
906           data->keys[i].type = s->keys[i].type;
907         }
908       if (data->nkeys > 2)
909         qsort(data->keys + 1, data->nkeys - 1, sizeof(data->keys[0]), key_cmp);
910     }
911   if (location)
912     data->location = strdup(location);
913 }
914
915 // EOF