- add repo_add_debdb() helper
[opensuse:sat-solver-moved-to-github.git] / ext / repo_deb.c
1 /*
2  * Copyright (c) 2009, Novell Inc.
3  *
4  * This program is licensed under the BSD license, read LICENSE.BSD
5  * for further information
6  */
7
8 #include <sys/types.h>
9 #include <sys/stat.h>
10 #include <stdio.h>
11 #include <stdlib.h>
12 #include <string.h>
13 #include <unistd.h>
14 #include <zlib.h>
15
16 #include "pool.h"
17 #include "repo.h"
18 #include "util.h"
19 #include "chksum.h"
20 #include "repo_deb.h"
21
22 static unsigned char *
23 decompress(unsigned char *in, int inl, int *outlp)
24 {
25   z_stream strm;
26   int outl, ret;
27   unsigned char *out;
28
29   memset(&strm, 0, sizeof(strm));
30   strm.next_in = in;
31   strm.avail_in = inl;
32   out = sat_malloc(4096);
33   strm.next_out = out;
34   strm.avail_out = 4096;
35   outl = 0;
36   ret = inflateInit2(&strm, -MAX_WBITS);
37   if (ret != Z_OK)
38     {
39       free(out);
40       return 0;
41     }
42   for (;;)
43     {
44       if (strm.avail_out == 0)
45         {
46           outl += 4096;
47           out = sat_realloc(out, outl + 4096);
48           strm.next_out = out + outl;
49           strm.avail_out = 4096;
50         }
51       ret = inflate(&strm, Z_NO_FLUSH);
52       if (ret == Z_STREAM_END)
53         break;
54       if (ret != Z_OK)
55         {
56           free(out);
57           return 0;
58         }
59     }
60   outl += 4096 - strm.avail_out;
61   inflateEnd(&strm);
62   *outlp = outl;
63   return out;
64 }
65
66 static Id
67 parseonedep(Pool *pool, char *p)
68 {
69   char *n, *ne, *e, *ee;
70   Id name, evr;
71   int flags;
72
73   while (*p == ' ' || *p == '\t' || *p == '\n')
74     p++;
75   if (!*p || *p == '(')
76     return 0;
77   n = p;
78   /* find end of name */
79   while (*p && *p != ' ' && *p != '\t' && *p != '\n' && *p != '(' && *p != '|')
80     p++;
81   ne = p;
82   while (*p == ' ' || *p == '\t' || *p == '\n')
83     p++;
84   evr = 0;
85   flags = 0;
86   e = ee = 0;
87   if (*p == '(')
88     {
89       p++;
90       while (*p == ' ' || *p == '\t' || *p == '\n')
91         p++;
92       if (*p == '>')
93         flags |= REL_GT;
94       else if (*p == '=')
95         flags |= REL_EQ;
96       else if (*p == '<')
97         flags |= REL_LT;
98       if (flags)
99         {
100           p++;
101           if (*p == '>')
102             flags |= REL_GT;
103           else if (*p == '=')
104             flags |= REL_EQ;
105           else if (*p == '<')
106             flags |= REL_LT;
107           else
108             p--;
109           p++;
110         }
111       while (*p == ' ' || *p == '\t' || *p == '\n')
112         p++;
113       e = p;
114       while (*p && *p != ' ' && *p != '\t' && *p != '\n' && *p != ')')
115         p++;
116       ee = p;
117       while (*p && *p != ')')
118         p++;
119       if (*p)
120         p++;
121       while (*p == ' ' || *p == '\t' || *p == '\n')
122         p++;
123     }
124   name = strn2id(pool, n, ne - n, 1);
125   if (e)
126     {
127       evr = strn2id(pool, e, ee - e, 1);
128       name = rel2id(pool, name, evr, flags, 1);
129     }
130   if (*p == '|')
131     {
132       Id id = parseonedep(pool, p + 1);
133       if (id)
134         name = rel2id(pool, name, id, REL_OR, 1);
135     }
136   return name;
137 }
138
139 static unsigned int
140 makedeps(Repo *repo, char *deps, unsigned int olddeps, Id marker)
141 {
142   Pool *pool = repo->pool;
143   char *p;
144   Id id;
145
146   while ((p = strchr(deps, ',')) != 0)
147     {
148       *p = 0;
149       olddeps = makedeps(repo, deps, olddeps, marker);
150       *p = ',';
151       deps = p + 1;
152     }
153   id = parseonedep(pool, deps);
154   if (!id)
155     return olddeps;
156   return repo_addid_dep(repo, olddeps, id, marker);
157 }
158
159
160 /* put data from control file into the solvable */
161 /* warning: does inplace changes */
162 static void
163 control2solvable(Solvable *s, Repodata *data, char *control)
164 {
165   Repo *repo = s->repo;
166   Pool *pool = repo->pool;
167   char *p, *q, *end, *tag;
168   int x, l;
169   int havesource = 0;
170   char checksum[32 * 2 + 1];
171   Id checksumtype = 0;
172   Id newtype;
173
174   p = control;
175   while (*p)
176     {
177       p = strchr(p, '\n');
178       if (!p)
179         break;
180       if (p[1] == ' ' || p[1] == '\t')
181         {
182           char *q;
183           /* continuation line */
184           q = p - 1;
185           while (q >= control && *q == ' ' && *q == '\t')
186             q--;
187           l = q + 1 - control;
188           if (l)
189             memmove(p + 1 - l, control, l);
190           control = p + 1 - l;
191           p[1] = '\n';
192           p += 2;
193           continue;
194         }
195       end = p - 1;
196       if (*p)
197         *p++ = 0;
198       /* strip trailing space */
199       while (end >= control && *end == ' ' && *end == '\t')
200         *end-- = 0;
201       tag = control;
202       control = p;
203       q = strchr(tag, ':');
204       if (!q || q - tag < 4)
205         continue;
206       *q++ = 0;
207       while (*q == ' ' || *q == '\t')
208         q++;
209       x = '@' + (tag[0] & 0x1f);
210       x = (x << 8) + '@' + (tag[1] & 0x1f);
211       switch(x)
212         {
213         case 'A' << 8 | 'R':
214           if (!strcasecmp(tag, "architecture"))
215             s->arch = str2id(pool, q, 1);
216           break;
217         case 'B' << 8 | 'R':
218           if (!strcasecmp(tag, "breaks"))
219             s->conflicts = makedeps(repo, q, s->conflicts, 0);
220           break;
221         case 'C' << 8 | 'O':
222           if (!strcasecmp(tag, "conflicts"))
223             s->conflicts = makedeps(repo, q, s->conflicts, 0);
224           break;
225         case 'D' << 8 | 'E':
226           if (!strcasecmp(tag, "depends"))
227             s->requires = makedeps(repo, q, s->requires, -SOLVABLE_PREREQMARKER);
228           else if (!strcasecmp(tag, "description"))
229             {
230               char *ld = strchr(q, '\n');
231               if (ld)
232                 {
233                   *ld++ = 0;
234                   repodata_set_str(data, s - pool->solvables, SOLVABLE_DESCRIPTION, ld);
235                 }
236               else
237                 repodata_set_str(data, s - pool->solvables, SOLVABLE_DESCRIPTION, q);
238               repodata_set_str(data, s - pool->solvables, SOLVABLE_SUMMARY, q);
239             }
240           break;
241         case 'E' << 8 | 'N':
242           if (!strcasecmp(tag, "enhances"))
243             s->enhances = makedeps(repo, q, s->enhances, 0);
244           break;
245         case 'F' << 8 | 'I':
246           if (!strcasecmp(tag, "filename"))
247             repodata_set_location(data, s - pool->solvables, 0, 0, q);
248           break;
249         case 'H' << 8 | 'O':
250           if (!strcasecmp(tag, "homepage"))
251             repodata_set_str(data, s - pool->solvables, SOLVABLE_URL, q);
252           break;
253         case 'I' << 8 | 'N':
254           if (!strcasecmp(tag, "installed-size"))
255             repodata_set_num(data, s - pool->solvables, SOLVABLE_INSTALLSIZE, atoi(q));
256           break;
257         case 'M' << 8 | 'D':
258           if (!strcasecmp(tag, "md5sum") && !checksumtype && strlen(q) == 16 * 2)
259             {
260               strcpy(checksum, q);
261               checksumtype = REPOKEY_TYPE_MD5;
262             }
263           break;
264         case 'P' << 8 | 'A':
265           if (!strcasecmp(tag, "package"))
266             s->name = str2id(pool, q, 1);
267           break;
268         case 'P' << 8 | 'R':
269           if (!strcasecmp(tag, "pre-depends"))
270             s->requires = makedeps(repo, q, s->requires, SOLVABLE_PREREQMARKER);
271           else if (!strcasecmp(tag, "provides"))
272             s->provides = makedeps(repo, q, s->provides, 0);
273           break;
274         case 'R' << 8 | 'E':
275           if (!strcasecmp(tag, "replaces"))
276             s->obsoletes = makedeps(repo, q, s->conflicts, 0);
277           else if (!strcasecmp(tag, "recommends"))
278             s->recommends = makedeps(repo, q, s->recommends, 0);
279           break;
280         case 'S' << 8 | 'H':
281           newtype = sat_chksum_str2type(tag);
282           if (!newtype || sat_chksum_len(newtype) * 2 != strlen(q))
283             break;
284           if (!checksumtype || (newtype == REPOKEY_TYPE_SHA1 && checksumtype != REPOKEY_TYPE_SHA256) || newtype == REPOKEY_TYPE_SHA256)
285             {
286               strcpy(checksum, q);
287               checksumtype = newtype;
288             }
289           break;
290         case 'S' << 8 | 'O':
291           if (!strcasecmp(tag, "source"))
292             {
293               char *q2;
294               /* ignore version for now */
295               for (q2 = q; *q2; q2++)
296                 if (*q2 == ' ' || *q2 == '\t')
297                   {
298                     *q2 = 0;
299                     break;
300                   }
301               if (s->name && !strcmp(q, id2str(pool, s->name)))
302                 repodata_set_void(data, s - pool->solvables, SOLVABLE_SOURCENAME);
303               else
304                 repodata_set_id(data, s - pool->solvables, SOLVABLE_SOURCENAME, str2id(pool, q, 1));
305               havesource = 1;
306             }
307           break;
308         case 'S' << 8 | 'U':
309           if (!strcasecmp(tag, "suggests"))
310             s->suggests = makedeps(repo, q, s->suggests, 0);
311           break;
312         case 'V' << 8 | 'E':
313           if (!strcasecmp(tag, "version"))
314             s->evr = str2id(pool, q, 1);
315           break;
316         }
317     }
318   if (checksumtype)
319     repodata_set_checksum(data, s - pool->solvables, SOLVABLE_CHECKSUM, checksumtype, checksum);
320   if (!s->arch)
321     s->arch = ARCH_ALL;
322   if (!s->evr)
323     s->evr = ID_EMPTY;
324   if (s->name)
325     s->provides = repo_addid_dep(repo, s->provides, rel2id(pool, s->name, s->evr, REL_EQ, 1), 0);
326   if (s->name && !havesource)
327     repodata_set_void(data, s - pool->solvables, SOLVABLE_SOURCENAME);
328   if (s->obsoletes)
329     {
330       /* obsoletes only count when the packages also conflict */
331       int i, j, k;
332       Id d;
333       for (i = j = s->obsoletes; (d = repo->idarraydata[i]) != 0; i++)
334         {
335           if (s->conflicts)
336             {
337               for (k = s->conflicts; repo->idarraydata[k] != 0; k++)
338                 if (repo->idarraydata[k] == d)
339                   break;
340               if (repo->idarraydata[k])
341                 {
342                   repo->idarraydata[j++] = d;
343                 }
344             }
345         }
346       repo->idarraydata[j] = 0;
347     }
348 }
349
350 void
351 repo_add_debpackages(Repo *repo, FILE *fp, int flags)
352 {
353   Pool *pool = repo->pool;
354   Repodata *data;
355   char *buf, *p;
356   int bufl, l, ll;
357   Solvable *s;
358
359   data = repo_add_repodata(repo, flags);
360   buf = sat_malloc(4096);
361   bufl = 4096;
362   l = 0;
363   buf[l] = 0;
364   p = buf;
365   for (;;)
366     {
367       if (!(p = strchr(p, '\n')))
368         {
369           int l3;
370           if (l + 1024 >= bufl)
371             {
372               buf = sat_realloc(buf, bufl + 4096);
373               bufl += 4096;
374               p = buf + l;
375               continue;
376             }
377           p = buf + l;
378           ll = fread(p, 1, bufl - l - 1, fp);
379           if (ll <= 0)
380             break;
381           p[ll] = 0;
382           while ((l3 = strlen(p)) < ll)
383             p[l3] = '\n';
384           l += ll;
385           continue;
386         }
387       p++;
388       if (*p != '\n')
389         continue;
390       *p = 0;
391       ll = p - buf + 1;
392       s = pool_id2solvable(pool, repo_add_solvable(repo));
393       control2solvable(s, data, buf);
394       if (!s->name)
395         repo_free_solvable_block(repo, s - pool->solvables, 1, 1);
396       if (l > ll)
397         memmove(buf, p + 1, l - ll);
398       l -= ll;
399       p = buf;
400       buf[l] = 0;
401     }
402   if (l)
403     {
404       s = pool_id2solvable(pool, repo_add_solvable(repo));
405       control2solvable(s, data, buf);
406       if (!s->name)
407         repo_free_solvable_block(repo, s - pool->solvables, 1, 1);
408     }
409   sat_free(buf);
410   if (!(flags & REPO_NO_INTERNALIZE))
411     repodata_internalize(data);
412 }
413
414 void
415 repo_add_debdb(Repo *repo, const char *rootdir, int flags)
416 {
417   FILE *fp;
418   const char *path = "/var/lib/dpkg/status";
419   if (rootdir)
420     path = pool_tmpjoin(repo->pool, rootdir, path, 0);
421   if ((fp = fopen(path, "r")) == 0)
422     {
423       perror(path);
424       exit(1);
425     }
426   repo_add_debpackages(repo, fp, flags);
427   fclose(fp);
428 }
429
430 void
431 repo_add_debs(Repo *repo, const char **debs, int ndebs, int flags)
432 {
433   Pool *pool = repo->pool;
434   Repodata *data;
435   unsigned char buf[4096], *bp;
436   int i, l, l2, vlen, clen, ctarlen;
437   unsigned char *ctgz;
438   unsigned char pkgid[16];
439   unsigned char *ctar;
440   int gotpkgid;
441   FILE *fp;
442   Solvable *s;
443   struct stat stb;
444
445   data = repo_add_repodata(repo, flags);
446   for (i = 0; i < ndebs; i++)
447     {
448       if ((fp = fopen(debs[i], "r")) == 0)
449         {
450           perror(debs[i]);
451           continue;
452         }
453       if (fstat(fileno(fp), &stb))
454         {
455           perror("stat");
456           continue;
457         }
458       l = fread(buf, 1, sizeof(buf), fp);
459       if (l < 8 + 60 || strncmp((char *)buf, "!<arch>\ndebian-binary   ", 8 + 16) != 0)
460         {
461           fprintf(stderr, "%s: not a deb package\n", debs[i]);
462           fclose(fp);
463           continue;
464         }
465       vlen = atoi((char *)buf + 8 + 48);
466       if (vlen < 0 || vlen > l)
467         {
468           fprintf(stderr, "%s: not a deb package\n", debs[i]);
469           fclose(fp);
470           continue;
471         }
472       vlen += vlen & 1;
473       if (l < 8 + 60 + vlen + 60)
474         {
475           fprintf(stderr, "%s: unhandled deb package\n", debs[i]);
476           fclose(fp);
477           continue;
478         }
479       if (strncmp((char *)buf + 8 + 60 + vlen, "control.tar.gz  ", 16) != 0)
480         {
481           fprintf(stderr, "%s: control.tar.gz is not second entry\n", debs[i]);
482           fclose(fp);
483           continue;
484         }
485       clen = atoi((char *)buf + 8 + 60 + vlen + 48);
486       if (clen <= 0)
487         {
488           fprintf(stderr, "%s: control.tar.gz has illegal size\n", debs[i]);
489           fclose(fp);
490           continue;
491         }
492       ctgz = sat_calloc(1, clen + 4);
493       bp = buf + 8 + 60 + vlen + 60;
494       l -= 8 + 60 + vlen + 60;
495       if (l > clen)
496         l = clen;
497       if (l)
498         memcpy(ctgz, bp, l);
499       if (l < clen)
500         {
501           if (fread(ctgz + l, clen - l, 1, fp) != 1)
502             {
503               fprintf(stderr, "%s: unexpected EOF\n", debs[i]);
504               sat_free(ctgz);
505               fclose(fp);
506               continue;
507             }
508         }
509       fclose(fp);
510       gotpkgid = 0;
511       if (flags & DEBS_ADD_WITH_PKGID)
512         {
513           void *handle = sat_chksum_create(REPOKEY_TYPE_MD5);
514           sat_chksum_add(handle, ctgz, clen);
515           sat_chksum_free(handle, pkgid);
516           gotpkgid = 1;
517         }
518       if (ctgz[0] != 0x1f || ctgz[1] != 0x8b)
519         {
520           fprintf(stderr, "%s: control.tar.gz is not gzipped\n", debs[i]);
521           sat_free(ctgz);
522           continue;
523         }
524       if (ctgz[2] != 8 || (ctgz[3] & 0xe0) != 0)
525         {
526           fprintf(stderr, "%s: control.tar.gz is compressed in a strange way\n", debs[i]);
527           sat_free(ctgz);
528           continue;
529         }
530       bp = ctgz + 4;
531       bp += 6;  /* skip time, xflags and OS code */
532       if (ctgz[3] & 0x04)
533         {
534           /* skip extra field */
535           l = bp[0] | bp[1] << 8;
536           bp += l + 2;
537           if (bp >= ctgz + clen)
538             {
539               fprintf(stderr, "%s: corrupt gzip\n", debs[i]);
540               sat_free(ctgz);
541               continue;
542             }
543         }
544       if (ctgz[3] & 0x08)       /* orig filename */
545         while (*bp)
546           bp++;
547       if (ctgz[3] & 0x10)       /* file comment */
548         while (*bp)
549           bp++;
550       if (ctgz[3] & 0x02)       /* header crc */
551         bp += 2;
552       if (bp >= ctgz + clen)
553         {
554           fprintf(stderr, "%s: corrupt control.tar.gz\n", debs[i]);
555           sat_free(ctgz);
556           continue;
557         }
558       ctar = decompress(bp, ctgz + clen - bp, &ctarlen);
559       sat_free(ctgz);
560       if (!ctar)
561         {
562           fprintf(stderr, "%s: corrupt control.tar.gz\n", debs[i]);
563           continue;
564         }
565       bp = ctar;
566       l = ctarlen;
567       while (l > 512)
568         {
569           int j;
570           l2 = 0;
571           for (j = 124; j < 124 + 12; j++)
572             if (bp[j] >= '0' && bp[j] <= '7')
573               l2 = l2 * 8 + (bp[j] - '0');
574           if (!strcmp((char *)bp, "./control"))
575             break;
576           l2 = 512 + ((l2 + 511) & ~511);
577           l -= l2;
578           bp += l2;
579         }
580       if (l <= 512 || l - 512 - l2 <= 0 || l2 <= 0)
581         {
582           fprintf(stderr, "%s: control.tar.gz contains no ./control file\n", debs[i]);
583           free(ctar);
584           continue;
585         }
586       memmove(ctar, bp + 512, l2);
587       ctar = sat_realloc(ctar, l2 + 1);
588       ctar[l2] = 0;
589       s = pool_id2solvable(pool, repo_add_solvable(repo));
590       control2solvable(s, data, (char *)ctar);
591       repodata_set_location(data, s - pool->solvables, 0, 0, debs[i]);
592       if (S_ISREG(stb.st_mode))
593         repodata_set_num(data, s - pool->solvables, SOLVABLE_DOWNLOADSIZE, (unsigned int)((stb.st_size + 1023) / 1024));
594       if (gotpkgid)
595         repodata_set_bin_checksum(data, s - pool->solvables, SOLVABLE_PKGID, REPOKEY_TYPE_MD5, pkgid);
596       sat_free(ctar);
597     }
598   if (!(flags & REPO_NO_INTERNALIZE))
599     repodata_internalize(data);
600 }
601
602 Id
603 repo_add_deb(Repo *repo, const char *deb, int flags)
604 {
605   int end = repo->end;
606   repo_add_debs(repo, &deb, 1, flags);
607   if (end == repo->end)
608     return 0;
609   else
610     return repo->end - 1;
611 }