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