examples/solv.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 /* solv, a little software installer demoing the sat solver library */
   9
  10 /* things available in the library but missing from solv:
  11  * - vendor policy loading
  12  * - soft locks file handling
  13  * - multi version handling
  14  */
  15
  16 #define _GNU_SOURCE
  17
  18 #include <stdio.h>
  19 #include <stdlib.h>
  20 #include <dirent.h>
  21 #include <fnmatch.h>
  22 #include <unistd.h>
  23 #include <zlib.h>
  24 #include <fcntl.h>
  25 #include <assert.h>
  26 #include <sys/utsname.h>
  27 #include <sys/types.h>
  28 #include <sys/wait.h>
  29 #include <time.h>
  30 #include <sys/time.h>
  31
  32 #include <sys/socket.h>
  33 #include <netdb.h>
  34 #include <poll.h>
  35 #include <errno.h>
  36
  37 #include "pool.h"
  38 #include "poolarch.h"
  39 #include "repo.h"
  40 #include "evr.h"
  41 #include "policy.h"
  42 #include "util.h"
  43 #include "solver.h"
  44 #include "solverdebug.h"
  45 #include "chksum.h"
  46 #include "repo_solv.h"
  47
  48 #include "repo_write.h"
  49 #include "repo_rpmdb.h"
  50 #include "repo_products.h"
  51 #include "repo_rpmmd.h"
  52 #include "repo_susetags.h"
  53 #include "repo_repomdxml.h"
  54 #include "repo_updateinfoxml.h"
  55 #include "repo_deltainfoxml.h"
  56 #include "repo_content.h"
  57 #include "pool_fileconflicts.h"
  58
  59
  60 #ifdef FEDORA
  61 # define REPOINFO_PATH "/etc/yum.repos.d"
  62 #else
  63 # define REPOINFO_PATH "/etc/zypp/repos.d"
  64 # define PRODUCTS_PATH "/etc/products.d"
  65 # define SOFTLOCKS_PATH "/var/lib/zypp/SoftLocks"
  66 #endif
  67
  68 #define SOLVCACHE_PATH "/var/cache/solv"
  69
  70 #define METADATA_EXPIRE (60 * 90)
  71
  72 struct repoinfo {
  73   Repo *repo;
  74
  75   char *alias;
  76   char *name;
  77   int enabled;
  78   int autorefresh;
  79   char *baseurl;
  80   char *metalink;
  81   char *mirrorlist;
  82   char *path;
  83   int type;
  84   int pkgs_gpgcheck;
  85   int repo_gpgcheck;
  86   int priority;
  87   int keeppackages;
  88   int metadata_expire;
  89
  90   unsigned char cookie[32];
  91   unsigned char extcookie[32];
  92 };
  93
  94 #ifdef FEDORA
  95 char *
  96 yum_substitute(Pool *pool, char *line)
  97 {
  98   char *p, *p2;
  99
 100   p = line;
 101   while ((p2 = strchr(p, '$')) != 0)
 102     {
 103       if (!strncmp(p2, "$releasever", 11))
 104         {
 105           static char *releaseevr;
 106           if (!releaseevr)
 107             {
 108               Queue q;
 109
 110               queue_init(&q);
 111               rpm_installedrpmdbids(0, "Providename", "redhat-release", &q);
 112               if (q.count)
 113                 {
 114                   void *handle, *state = 0;
 115                   char *p;
 116                   handle = rpm_byrpmdbid(q.elements[0], 0, &state);
 117                   releaseevr = rpm_query(handle, SOLVABLE_EVR);
 118                   rpm_byrpmdbid(0, 0, &state);
 119                   if ((p = strchr(releaseevr, '-')) != 0)
 120                     *p = 0;
 121                 }
 122               queue_free(&q);
 123               if (!releaseevr)
 124                 releaseevr = strdup("?");
 125             }
 126           *p2 = 0;
 127           p = pool_tmpjoin(pool, line, releaseevr, p2 + 11);
 128           p2 = p + (p2 - line);
 129           line = p;
 130           p = p2 + strlen(releaseevr);
 131           continue;
 132         }
 133       if (!strncmp(p2, "$basearch", 9))
 134         {
 135           static char *basearch;
 136           if (!basearch)
 137             {
 138               struct utsname un;
 139               if (uname(&un))
 140                 {
 141                   perror("uname");
 142                   exit(1);
 143                 }
 144               basearch = strdup(un.machine);
 145               if (basearch[0] == 'i' && basearch[1] && !strcmp(basearch + 2, "86"))
 146                 basearch[1] = '3';
 147             }
 148           *p2 = 0;
 149           p = pool_tmpjoin(pool, line, basearch, p2 + 9);
 150           p2 = p + (p2 - line);
 151           line = p;
 152           p = p2 + strlen(basearch);
 153           continue;
 154         }
 155       p = p2 + 1;
 156     }
 157   return line;
 158 }
 159 #endif
 160
 161 #define TYPE_UNKNOWN    0
 162 #define TYPE_SUSETAGS   1
 163 #define TYPE_RPMMD      2
 164 #define TYPE_PLAINDIR   3
 165
 166 static int
 167 read_repoinfos_sort(const void *ap, const void *bp)
 168 {
 169   const struct repoinfo *a = ap;
 170   const struct repoinfo *b = bp;
 171   return strcmp(a->alias, b->alias);
 172 }
 173
 174 struct repoinfo *
 175 read_repoinfos(Pool *pool, const char *reposdir, int *nrepoinfosp)
 176 {
 177   char buf[4096];
 178   char buf2[4096], *kp, *vp, *kpe;
 179   DIR *dir;
 180   FILE *fp;
 181   struct dirent *ent;
 182   int l, rdlen;
 183   struct repoinfo *repoinfos = 0, *cinfo;
 184   int nrepoinfos = 0;
 185
 186   rdlen = strlen(reposdir);
 187   dir = opendir(reposdir);
 188   if (!dir)
 189     {
 190       *nrepoinfosp = 0;
 191       return 0;
 192     }
 193   while ((ent = readdir(dir)) != 0)
 194     {
 195       l = strlen(ent->d_name);
 196       if (l < 6 || rdlen + 2 + l >= sizeof(buf) || strcmp(ent->d_name + l - 5, ".repo") != 0)
 197         continue;
 198       snprintf(buf, sizeof(buf), "%s/%s", reposdir, ent->d_name);
 199       if ((fp = fopen(buf, "r")) == 0)
 200         {
 201           perror(buf);
 202           continue;
 203         }
 204       cinfo = 0;
 205       while(fgets(buf2, sizeof(buf2), fp))
 206         {
 207           l = strlen(buf2);
 208           if (l == 0)
 209             continue;
 210           while (l && (buf2[l - 1] == '\n' || buf2[l - 1] == ' ' || buf2[l - 1] == '\t'))
 211             buf2[--l] = 0;
 212           kp = buf2;
 213           while (*kp == ' ' || *kp == '\t')
 214             kp++;
 215           if (!*kp || *kp == '#')
 216             continue;
 217 #ifdef FEDORA
 218           if (strchr(kp, '$'))
 219             kp = yum_substitute(pool, kp);
 220 #endif
 221           if (*kp == '[')
 222             {
 223               vp = strrchr(kp, ']');
 224               if (!vp)
 225                 continue;
 226               *vp = 0;
 227               repoinfos = sat_extend(repoinfos, nrepoinfos, 1, sizeof(*repoinfos), 15);
 228               cinfo = repoinfos + nrepoinfos++;
 229               memset(cinfo, 0, sizeof(*cinfo));
 230               cinfo->alias = strdup(kp + 1);
 231               cinfo->type = TYPE_RPMMD;
 232               cinfo->autorefresh = 1;
 233 #ifndef FEDORA
 234               cinfo->repo_gpgcheck = 1;
 235 #endif
 236               cinfo->metadata_expire = METADATA_EXPIRE;
 237               continue;
 238             }
 239           if (!cinfo)
 240             continue;
 241           vp = strchr(kp, '=');
 242           if (!vp)
 243             continue;
 244           for (kpe = vp - 1; kpe >= kp; kpe--)
 245             if (*kpe != ' ' && *kpe != '\t')
 246               break;
 247           if (kpe == kp)
 248             continue;
 249           vp++;
 250           while (*vp == ' ' || *vp == '\t')
 251             vp++;
 252           kpe[1] = 0;
 253           if (!strcmp(kp, "name"))
 254             cinfo->name = strdup(vp);
 255           else if (!strcmp(kp, "enabled"))
 256             cinfo->enabled = *vp == '0' ? 0 : 1;
 257           else if (!strcmp(kp, "autorefresh"))
 258             cinfo->autorefresh = *vp == '0' ? 0 : 1;
 259           else if (!strcmp(kp, "gpgcheck"))
 260             cinfo->pkgs_gpgcheck = *vp == '0' ? 0 : 1;
 261           else if (!strcmp(kp, "repo_gpgcheck"))
 262             cinfo->repo_gpgcheck = *vp == '0' ? 0 : 1;
 263           else if (!strcmp(kp, "baseurl"))
 264             cinfo->baseurl = strdup(vp);
 265           else if (!strcmp(kp, "mirrorlist"))
 266             {
 267               if (strstr(vp, "metalink"))
 268                 cinfo->metalink = strdup(vp);
 269               else
 270                 cinfo->mirrorlist = strdup(vp);
 271             }
 272           else if (!strcmp(kp, "path"))
 273             {
 274               if (vp && strcmp(vp, "/") != 0)
 275                 cinfo->path = strdup(vp);
 276             }
 277           else if (!strcmp(kp, "type"))
 278             {
 279               if (!strcmp(vp, "yast2"))
 280                 cinfo->type = TYPE_SUSETAGS;
 281               else if (!strcmp(vp, "rpm-md"))
 282                 cinfo->type = TYPE_RPMMD;
 283               else if (!strcmp(vp, "plaindir"))
 284                 cinfo->type = TYPE_PLAINDIR;
 285               else
 286                 cinfo->type = TYPE_UNKNOWN;
 287             }
 288           else if (!strcmp(kp, "priority"))
 289             cinfo->priority = atoi(vp);
 290           else if (!strcmp(kp, "keeppackages"))
 291             cinfo->keeppackages = *vp == '0' ? 0 : 1;
 292         }
 293       fclose(fp);
 294       cinfo = 0;
 295     }
 296   closedir(dir);
 297   qsort(repoinfos, nrepoinfos, sizeof(*repoinfos), read_repoinfos_sort);
 298   *nrepoinfosp = nrepoinfos;
 299   return repoinfos;
 300 }
 301
 302 void
 303 free_repoinfos(struct repoinfo *repoinfos, int nrepoinfos)
 304 {
 305   int i;
 306   for (i = 0; i < nrepoinfos; i++)
 307     {
 308       struct repoinfo *cinfo = repoinfos + i;
 309       sat_free(cinfo->name);
 310       sat_free(cinfo->alias);
 311       sat_free(cinfo->path);
 312       sat_free(cinfo->metalink);
 313       sat_free(cinfo->mirrorlist);
 314       sat_free(cinfo->baseurl);
 315     }
 316   sat_free(repoinfos);
 317 }
 318
 319 static inline int
 320 opentmpfile()
 321 {
 322   char tmpl[100];
 323   int fd;
 324
 325   strcpy(tmpl, "/var/tmp/solvXXXXXX");
 326   fd = mkstemp(tmpl);
 327   if (fd < 0)
 328     {
 329       perror("mkstemp");
 330       exit(1);
 331     }
 332   unlink(tmpl);
 333   return fd;
 334 }
 335
 336 static int
 337 verify_checksum(int fd, const char *file, const unsigned char *chksum, Id chksumtype)
 338 {
 339   char buf[1024];
 340   unsigned char *sum;
 341   void *h;
 342   int l;
 343
 344   h = sat_chksum_create(chksumtype);
 345   if (!h)
 346     {
 347       printf("%s: unknown checksum type\n", file);
 348       return 0;
 349     }
 350   while ((l = read(fd, buf, sizeof(buf))) > 0)
 351     sat_chksum_add(h, buf, l);
 352   lseek(fd, 0, SEEK_SET);
 353   l = 0;
 354   sum = sat_chksum_get(h, &l);
 355   if (memcmp(sum, chksum, l))
 356     {
 357       printf("%s: checksum mismatch\n", file);
 358       return 0;
 359     }
 360   return 1;
 361 }
 362
 363 void
 364 findfastest(char **urls, int nurls)
 365 {
 366   int i, j, port;
 367   int *socks, qc;
 368   struct pollfd *fds;
 369   char *p, *p2, *q;
 370   char portstr[16];
 371   struct addrinfo hints, *result;;
 372
 373   fds = sat_calloc(nurls, sizeof(*fds));
 374   socks = sat_calloc(nurls, sizeof(*socks));
 375   for (i = 0; i < nurls; i++)
 376     {
 377       socks[i] = -1;
 378       p = strchr(urls[i], '/');
 379       if (!p)
 380         continue;
 381       if (p[1] != '/')
 382         continue;
 383       p += 2;
 384       q = strchr(p, '/');
 385       qc = 0;
 386       if (q)
 387         {
 388           qc = *q;
 389           *q = 0;
 390         }
 391       if ((p2 = strchr(p, '@')) != 0)
 392         p = p2 + 1;
 393       port = 80;
 394       if (!strncmp("https:", urls[i], 6))
 395         port = 443;
 396       else if (!strncmp("ftp:", urls[i], 4))
 397         port = 21;
 398       if ((p2 = strrchr(p, ':')) != 0)
 399         {
 400           port = atoi(p2 + 1);
 401           if (q)
 402             *q = qc;
 403           q = p2;
 404           qc = *q;
 405           *q = 0;
 406         }
 407       sprintf(portstr, "%d", port);
 408       memset(&hints, 0, sizeof(struct addrinfo));
 409       hints.ai_family = AF_UNSPEC;
 410       hints.ai_socktype = SOCK_STREAM;
 411       hints.ai_flags = AI_NUMERICSERV;
 412       result = 0;
 413       if (!getaddrinfo(p, portstr, &hints, &result))
 414         {
 415           socks[i] = socket(result->ai_family, result->ai_socktype, result->ai_protocol);
 416           if (socks[i] >= 0)
 417             {
 418               fcntl(socks[i], F_SETFL, O_NONBLOCK);
 419               if (connect(socks[i], result->ai_addr, result->ai_addrlen) == -1)
 420                 {
 421                   if (errno != EINPROGRESS)
 422                     {
 423                       close(socks[i]);
 424                       socks[i] = -1;
 425                     }
 426                 }
 427             }
 428           freeaddrinfo(result);
 429         }
 430       if (q)
 431         *q = qc;
 432     }
 433   for (;;)
 434     {
 435       for (i = j = 0; i < nurls; i++)
 436         {
 437           if (socks[i] < 0)
 438             continue;
 439           fds[j].fd = socks[i];
 440           fds[j].events = POLLOUT;
 441           j++;
 442         }
 443       if (j < 2)
 444         {
 445           i = j - 1;
 446           break;
 447         }
 448       if (poll(fds, j, 10000) <= 0)
 449         {
 450           i = -1;       /* something is wrong */
 451           break;
 452         }
 453       for (i = 0; i < j; i++)
 454         if ((fds[i].revents & POLLOUT) != 0)
 455           {
 456             int soe = 0;
 457             socklen_t soel = sizeof(int);
 458             if (getsockopt(fds[i].fd, SOL_SOCKET, SO_ERROR, &soe, &soel) == -1 || soe != 0)
 459               {
 460                 /* connect failed, kill socket */
 461                 for (j = 0; j < nurls; j++)
 462                   if (socks[j] == fds[i].fd)
 463                     {
 464                       close(socks[j]);
 465                       socks[j] = -1;
 466                     }
 467                 i = j + 1;
 468                 break;
 469               }
 470             break;      /* horray! */
 471           }
 472       if (i == j + 1)
 473         continue;
 474       if (i == j)
 475         i = -1;         /* something is wrong, no bit was set */
 476       break;
 477     }
 478   /* now i contains the fastest fd index */
 479   if (i >= 0)
 480     {
 481       for (j = 0; j < nurls; j++)
 482         if (socks[j] == fds[i].fd)
 483           break;
 484       if (j != 0)
 485         {
 486           char *url0 = urls[0];
 487           urls[0] = urls[j];
 488           urls[j] = url0;
 489         }
 490     }
 491   for (i = j = 0; i < nurls; i++)
 492     if (socks[i] >= 0)
 493       close(socks[i]);
 494   free(socks);
 495   free(fds);
 496 }
 497
 498 char *
 499 findmetalinkurl(FILE *fp, unsigned char *chksump, Id *chksumtypep)
 500 {
 501   char buf[4096], *bp, *ep;
 502   char **urls = 0;
 503   int nurls = 0;
 504   int i;
 505
 506   if (chksumtypep)
 507     *chksumtypep = 0;
 508   while((bp = fgets(buf, sizeof(buf), fp)) != 0)
 509     {
 510       while (*bp == ' ' || *bp == '\t')
 511         bp++;
 512       if (chksumtypep && !*chksumtypep && !strncmp(bp, "<hash type=\"sha256\">", 20))
 513         {
 514           int i;
 515
 516           bp += 20;
 517           memset(chksump, 0, 32);
 518           for (i = 0; i < 64; i++)
 519             {
 520               int c = *bp++;
 521               if (c >= '0' && c <= '9')
 522                 chksump[i / 2] = chksump[i / 2] * 16 + (c - '0');
 523               else if (c >= 'a' && c <= 'f')
 524                 chksump[i / 2] = chksump[i / 2] * 16 + (c - ('a' - 10));
 525               else if (c >= 'A' && c <= 'F')
 526                 chksump[i / 2] = chksump[i / 2] * 16 + (c - ('A' - 10));
 527               else
 528                 break;
 529             }
 530           if (i == 64)
 531             *chksumtypep = REPOKEY_TYPE_SHA256;
 532           continue;
 533         }
 534       if (strncmp(bp, "<url", 4))
 535         continue;
 536       bp = strchr(bp, '>');
 537       if (!bp)
 538         continue;
 539       bp++;
 540       ep = strstr(bp, "repodata/repomd.xml</url>");
 541       if (!ep)
 542         continue;
 543       *ep = 0;
 544       if (strncmp(bp, "http", 4))
 545         continue;
 546       urls = sat_extend(urls, nurls, 1, sizeof(*urls), 15);
 547       urls[nurls++] = strdup(bp);
 548     }
 549   if (nurls)
 550     {
 551       if (nurls > 1)
 552         findfastest(urls, nurls > 5 ? 5 : nurls);
 553       bp = urls[0];
 554       urls[0] = 0;
 555       for (i = 0; i < nurls; i++)
 556         sat_free(urls[i]);
 557       sat_free(urls);
 558       ep = strchr(bp, '/');
 559       if ((ep = strchr(ep + 2, '/')) != 0)
 560         {
 561           *ep = 0;
 562           printf("[using mirror %s]\n", bp);
 563           *ep = '/';
 564         }
 565       return bp;
 566     }
 567   return 0;
 568 }
 569
 570 char *
 571 findmirrorlisturl(FILE *fp)
 572 {
 573   char buf[4096], *bp, *ep;
 574   int i, l;
 575   char **urls = 0;
 576   int nurls = 0;
 577
 578   while((bp = fgets(buf, sizeof(buf), fp)) != 0)
 579     {
 580       while (*bp == ' ' || *bp == '\t')
 581         bp++;
 582       if (!*bp || *bp == '#')
 583         continue;
 584       l = strlen(bp);
 585       while (l > 0 && (bp[l - 1] == ' ' || bp[l - 1] == '\t' || bp[l - 1] == '\n'))
 586         bp[--l] = 0;
 587       urls = sat_extend(urls, nurls, 1, sizeof(*urls), 15);
 588       urls[nurls++] = strdup(bp);
 589     }
 590   if (nurls)
 591     {
 592       if (nurls > 1)
 593         findfastest(urls, nurls > 5 ? 5 : nurls);
 594       bp = urls[0];
 595       urls[0] = 0;
 596       for (i = 0; i < nurls; i++)
 597         sat_free(urls[i]);
 598       sat_free(urls);
 599       ep = strchr(bp, '/');
 600       if ((ep = strchr(ep + 2, '/')) != 0)
 601         {
 602           *ep = 0;
 603           printf("[using mirror %s]\n", bp);
 604           *ep = '/';
 605         }
 606       return bp;
 607     }
 608   return 0;
 609 }
 610
 611 static ssize_t
 612 cookie_gzread(void *cookie, char *buf, size_t nbytes)
 613 {
 614   return gzread((gzFile *)cookie, buf, nbytes);
 615 }
 616
 617 static int
 618 cookie_gzclose(void *cookie)
 619 {
 620   return gzclose((gzFile *)cookie);
 621 }
 622
 623 FILE *
 624 curlfopen(struct repoinfo *cinfo, const char *file, int uncompress, const unsigned char *chksum, Id chksumtype, int *badchecksump)
 625 {
 626   pid_t pid;
 627   int fd, l;
 628   int status;
 629   char url[4096];
 630   const char *baseurl = cinfo->baseurl;
 631
 632   if (!baseurl)
 633     {
 634       if (!cinfo->metalink && !cinfo->mirrorlist)
 635         return 0;
 636       if (file != cinfo->metalink && file != cinfo->mirrorlist)
 637         {
 638           FILE *fp = curlfopen(cinfo, cinfo->metalink ? cinfo->metalink : cinfo->mirrorlist, 0, 0, 0, 0);
 639           unsigned char mlchksum[32];
 640           Id mlchksumtype = 0;
 641           if (!fp)
 642             return 0;
 643           if (cinfo->metalink)
 644             cinfo->baseurl = findmetalinkurl(fp, mlchksum, &mlchksumtype);
 645           else
 646             cinfo->baseurl = findmirrorlisturl(fp);
 647           fclose(fp);
 648           if (!cinfo->baseurl)
 649             return 0;
 650           if (!chksumtype && mlchksumtype && !strcmp(file, "repodata/repomd.xml"))
 651             {
 652               chksumtype = mlchksumtype;
 653               chksum = mlchksum;
 654             }
 655           return curlfopen(cinfo, file, uncompress, chksum, chksumtype, badchecksump);
 656         }
 657       snprintf(url, sizeof(url), "%s", file);
 658     }
 659   else
 660     {
 661       l = strlen(baseurl);
 662       if (l && baseurl[l - 1] == '/')
 663         snprintf(url, sizeof(url), "%s%s", baseurl, file);
 664       else
 665         snprintf(url, sizeof(url), "%s/%s", baseurl, file);
 666     }
 667   fd = opentmpfile();
 668   // printf("url: %s\n", url);
 669   if ((pid = fork()) == (pid_t)-1)
 670     {
 671       perror("fork");
 672       exit(1);
 673     }
 674   if (pid == 0)
 675     {
 676       if (fd != 1)
 677         {
 678           dup2(fd, 1);
 679           close(fd);
 680         }
 681       execlp("curl", "curl", "-f", "-s", "-L", url, (char *)0);
 682       perror("curl");
 683       _exit(0);
 684     }
 685   status = 0;
 686   while (waitpid(pid, &status, 0) != pid)
 687     ;
 688   if (lseek(fd, 0, SEEK_END) == 0 && (!status || !chksumtype))
 689     {
 690       /* empty file */
 691       close(fd);
 692       return 0;
 693     }
 694   lseek(fd, 0, SEEK_SET);
 695   if (status)
 696     {
 697       printf("%s: download error %d\n", file, status >> 8 ? status >> 8 : status);
 698       if (badchecksump)
 699         *badchecksump = 1;
 700       close(fd);
 701       return 0;
 702     }
 703   if (chksumtype && !verify_checksum(fd, file, chksum, chksumtype))
 704     {
 705       if (badchecksump)
 706         *badchecksump = 1;
 707       close(fd);
 708       return 0;
 709     }
 710   if (uncompress)
 711     {
 712       char tmpl[100];
 713       cookie_io_functions_t cio;
 714       gzFile *gzf;
 715
 716       sprintf(tmpl, "/dev/fd/%d", fd);
 717       gzf = gzopen(tmpl, "r");
 718       close(fd);
 719       if (!gzf)
 720         {
 721           fprintf(stderr, "could not open /dev/fd/%d, /proc not mounted?\n", fd);
 722           exit(1);
 723         }
 724       memset(&cio, 0, sizeof(cio));
 725       cio.read = cookie_gzread;
 726       cio.close = cookie_gzclose;
 727       return fopencookie(gzf, "r", cio);
 728     }
 729   fcntl(fd, F_SETFD, FD_CLOEXEC);
 730   return fdopen(fd, "r");
 731 }
 732
 733 static void
 734 cleanupgpg(char *gpgdir)
 735 {
 736   char cmd[256];
 737   snprintf(cmd, sizeof(cmd), "%s/pubring.gpg", gpgdir);
 738   unlink(cmd);
 739   snprintf(cmd, sizeof(cmd), "%s/pubring.gpg~", gpgdir);
 740   unlink(cmd);
 741   snprintf(cmd, sizeof(cmd), "%s/secring.gpg", gpgdir);
 742   unlink(cmd);
 743   snprintf(cmd, sizeof(cmd), "%s/trustdb.gpg", gpgdir);
 744   unlink(cmd);
 745   snprintf(cmd, sizeof(cmd), "%s/keys", gpgdir);
 746   unlink(cmd);
 747   rmdir(gpgdir);
 748 }
 749
 750 int
 751 checksig(Pool *sigpool, FILE *fp, FILE *sigfp)
 752 {
 753   char *gpgdir;
 754   char *keysfile;
 755   const char *pubkey;
 756   char cmd[256];
 757   FILE *kfp;
 758   Solvable *s;
 759   Id p;
 760   off_t posfp, possigfp;
 761   int r, nkeys;
 762
 763   gpgdir = mkdtemp(pool_tmpjoin(sigpool, "/var/tmp/solvgpg.XXXXXX", 0, 0));
 764   if (!gpgdir)
 765     return 0;
 766   keysfile = pool_tmpjoin(sigpool, gpgdir, "/keys", 0);
 767   if (!(kfp = fopen(keysfile, "w")) )
 768     {
 769       cleanupgpg(gpgdir);
 770       return 0;
 771     }
 772   nkeys = 0;
 773   for (p = 1, s = sigpool->solvables + p; p < sigpool->nsolvables; p++, s++)
 774     {
 775       if (!s->repo)
 776         continue;
 777       pubkey = solvable_lookup_str(s, SOLVABLE_DESCRIPTION);
 778       if (!pubkey || !*pubkey)
 779         continue;
 780       if (fwrite(pubkey, strlen(pubkey), 1, kfp) != 1)
 781         break;
 782       if (fputc('\n', kfp) == EOF)      /* Just in case... */
 783         break;
 784       nkeys++;
 785     }
 786   if (fclose(kfp) || !nkeys)
 787     {
 788       cleanupgpg(gpgdir);
 789       return 0;
 790     }
 791   snprintf(cmd, sizeof(cmd), "gpg2 -q --homedir %s --import %s", gpgdir, keysfile);
 792   if (system(cmd))
 793     {
 794       fprintf(stderr, "key import error\n");
 795       cleanupgpg(gpgdir);
 796       return 0;
 797     }
 798   unlink(keysfile);
 799   posfp = lseek(fileno(fp), 0, SEEK_CUR);
 800   lseek(fileno(fp), 0, SEEK_SET);
 801   possigfp = lseek(fileno(sigfp), 0, SEEK_CUR);
 802   lseek(fileno(sigfp), 0, SEEK_SET);
 803   snprintf(cmd, sizeof(cmd), "gpg -q --homedir %s --verify /dev/fd/%d /dev/fd/%d >/dev/null 2>&1", gpgdir, fileno(sigfp), fileno(fp));
 804   fcntl(fileno(fp), F_SETFD, 0);        /* clear CLOEXEC */
 805   fcntl(fileno(sigfp), F_SETFD, 0);     /* clear CLOEXEC */
 806   r = system(cmd);
 807   lseek(fileno(sigfp), possigfp, SEEK_SET);
 808   lseek(fileno(fp), posfp, SEEK_SET);
 809   fcntl(fileno(fp), F_SETFD, FD_CLOEXEC);
 810   fcntl(fileno(sigfp), F_SETFD, FD_CLOEXEC);
 811   cleanupgpg(gpgdir);
 812   return r == 0 ? 1 : 0;
 813 }
 814
 815 #define CHKSUM_IDENT "1.1"
 816
 817 void
 818 calc_checksum_fp(FILE *fp, Id chktype, unsigned char *out)
 819 {
 820   char buf[4096];
 821   void *h = sat_chksum_create(chktype);
 822   int l;
 823
 824   sat_chksum_add(h, CHKSUM_IDENT, strlen(CHKSUM_IDENT));
 825   while ((l = fread(buf, 1, sizeof(buf), fp)) > 0)
 826     sat_chksum_add(h, buf, l);
 827   rewind(fp);
 828   sat_chksum_free(h, out);
 829 }
 830
 831 void
 832 calc_checksum_stat(struct stat *stb, Id chktype, unsigned char *out)
 833 {
 834   void *h = sat_chksum_create(chktype);
 835   sat_chksum_add(h, CHKSUM_IDENT, strlen(CHKSUM_IDENT));
 836   sat_chksum_add(h, &stb->st_dev, sizeof(stb->st_dev));
 837   sat_chksum_add(h, &stb->st_ino, sizeof(stb->st_ino));
 838   sat_chksum_add(h, &stb->st_size, sizeof(stb->st_size));
 839   sat_chksum_add(h, &stb->st_mtime, sizeof(stb->st_mtime));
 840   sat_chksum_free(h, out);
 841 }
 842
 843 void
 844 setarch(Pool *pool)
 845 {
 846   struct utsname un;
 847   if (uname(&un))
 848     {
 849       perror("uname");
 850       exit(1);
 851     }
 852   pool_setarch(pool, un.machine);
 853 }
 854
 855 char *calccachepath(Repo *repo, const char *repoext)
 856 {
 857   char *q, *p = pool_tmpjoin(repo->pool, SOLVCACHE_PATH, "/", repo->name);
 858   if (repoext)
 859     {
 860       p = pool_tmpjoin(repo->pool, p, "_", repoext);
 861       p = pool_tmpjoin(repo->pool, p, ".solvx", 0);
 862     }
 863   else
 864     p = pool_tmpjoin(repo->pool, p, ".solv", 0);
 865   q = p + strlen(SOLVCACHE_PATH) + 1;
 866   if (*q == '.')
 867     *q = '_';
 868   for (; *q; q++)
 869     if (*q == '/')
 870       *q = '_';
 871   return p;
 872 }
 873
 874 int
 875 usecachedrepo(Repo *repo, const char *repoext, unsigned char *cookie, int mark)
 876 {
 877   FILE *fp;
 878   unsigned char mycookie[32];
 879   unsigned char myextcookie[32];
 880   struct repoinfo *cinfo;
 881   int flags;
 882
 883   cinfo = repo->appdata;
 884   if (!(fp = fopen(calccachepath(repo, repoext), "r")))
 885     return 0;
 886   if (fseek(fp, -sizeof(mycookie), SEEK_END) || fread(mycookie, sizeof(mycookie), 1, fp) != 1)
 887     {
 888       fclose(fp);
 889       return 0;
 890     }
 891   if (cookie && memcmp(cookie, mycookie, sizeof(mycookie)))
 892     {
 893       fclose(fp);
 894       return 0;
 895     }
 896   if (cinfo && !repoext)
 897     {
 898       if (fseek(fp, -sizeof(mycookie) * 2, SEEK_END) || fread(myextcookie, sizeof(myextcookie), 1, fp) != 1)
 899         {
 900           fclose(fp);
 901           return 0;
 902         }
 903     }
 904   rewind(fp);
 905
 906   flags = 0;
 907   if (repoext)
 908     flags = REPO_USE_LOADING|REPO_EXTEND_SOLVABLES;
 909   if (repoext && strcmp(repoext, "DL") != 0)
 910     flags |= REPO_LOCALPOOL;    /* no local pool for DL so that we can compare IDs */
 911
 912   if (repo_add_solv_flags(repo, fp, flags))
 913     {
 914       fclose(fp);
 915       return 0;
 916     }
 917   if (cinfo && !repoext)
 918     {
 919       memcpy(cinfo->cookie, mycookie, sizeof(mycookie));
 920       memcpy(cinfo->extcookie, myextcookie, sizeof(myextcookie));
 921     }
 922   if (mark)
 923     futimes(fileno(fp), 0);     /* try to set modification time */
 924   fclose(fp);
 925   return 1;
 926 }
 927
 928 void
 929 writecachedrepo(Repo *repo, Repodata *info, const char *repoext, unsigned char *cookie)
 930 {
 931   FILE *fp;
 932   int i, fd;
 933   char *tmpl;
 934   struct repoinfo *cinfo;
 935   int onepiece;
 936
 937   cinfo = repo->appdata;
 938   mkdir(SOLVCACHE_PATH, 0755);
 939   tmpl = sat_dupjoin(SOLVCACHE_PATH, "/", ".newsolv-XXXXXX");
 940   fd = mkstemp(tmpl);
 941   if (fd < 0)
 942     {
 943       free(tmpl);
 944       return;
 945     }
 946   fchmod(fd, 0444);
 947   if (!(fp = fdopen(fd, "w")))
 948     {
 949       close(fd);
 950       unlink(tmpl);
 951       free(tmpl);
 952       return;
 953     }
 954
 955   onepiece = 1;
 956   for (i = repo->start; i < repo->end; i++)
 957    if (repo->pool->solvables[i].repo != repo)
 958      break;
 959   if (i < repo->end)
 960     onepiece = 0;
 961
 962   if (!info)
 963     repo_write(repo, fp, repo_write_stdkeyfilter, 0, 0);
 964   else if (repoext)
 965     repodata_write(info, fp, repo_write_stdkeyfilter, 0);
 966   else
 967     {
 968       int oldnrepodata = repo->nrepodata;
 969       repo->nrepodata = 1;      /* XXX: do this right */
 970       repo_write(repo, fp, repo_write_stdkeyfilter, 0, 0);
 971       repo->nrepodata = oldnrepodata;
 972       onepiece = 0;
 973     }
 974
 975   if (!repoext && cinfo)
 976     {
 977       if (!cinfo->extcookie[0])
 978         {
 979           /* create the ext cookie and append it */
 980           /* we just need some unique ID */
 981           struct stat stb;
 982           if (!fstat(fileno(fp), &stb))
 983             {
 984               int i;
 985
 986               calc_checksum_stat(&stb, REPOKEY_TYPE_SHA256, cinfo->extcookie);
 987               for (i = 0; i < 32; i++)
 988                 cinfo->extcookie[i] ^= cookie[i];
 989             }
 990           if (cinfo->extcookie[0] == 0)
 991             cinfo->extcookie[0] = 1;
 992         }
 993       if (fwrite(cinfo->extcookie, 32, 1, fp) != 1)
 994         {
 995           fclose(fp);
 996           unlink(tmpl);
 997           free(tmpl);
 998           return;
 999         }
1000     }
1001   /* append our cookie describing the metadata state */
1002   if (fwrite(cookie, 32, 1, fp) != 1)
1003     {
1004       fclose(fp);
1005       unlink(tmpl);
1006       free(tmpl);
1007       return;
1008     }
1009   if (fclose(fp))
1010     {
1011       unlink(tmpl);
1012       free(tmpl);
1013       return;
1014     }
1015   if (onepiece)
1016     {
1017       /* switch to just saved repo to activate paging and save memory */
1018       FILE *fp = fopen(tmpl, "r");
1019       if (fp)
1020         {
1021           if (!repoext)
1022             {
1023               /* main repo */
1024               repo_empty(repo, 1);
1025               if (repo_add_solv_flags(repo, fp, SOLV_ADD_NO_STUBS))
1026                 {
1027                   /* oops, no way to recover from here */
1028                   fprintf(stderr, "internal error\n");
1029                   exit(1);
1030                 }
1031             }
1032           else
1033             {
1034               /* make sure repodata contains complete repo */
1035               /* (this is how repodata_write saves it) */
1036               repodata_extend_block(info, repo->start, repo->end - repo->start);
1037               info->state = REPODATA_LOADING;
1038               /* no need for LOCALPOOL as pool already contains ids */
1039               repo_add_solv_flags(repo, fp, REPO_USE_LOADING|REPO_EXTEND_SOLVABLES);
1040               info->state = REPODATA_AVAILABLE; /* in case the load failed */
1041             }
1042           fclose(fp);
1043         }
1044     }
1045   if (!rename(tmpl, calccachepath(repo, repoext)))
1046     unlink(tmpl);
1047   free(tmpl);
1048 }
1049
1050
1051 static Pool *
1052 read_sigs()
1053 {
1054   Pool *sigpool = pool_create();
1055   Repo *repo = repo_create(sigpool, "rpmdbkeys");
1056   repo_add_rpmdb_pubkeys(repo, 0, 0);
1057   return sigpool;
1058 }
1059
1060
1061 /* repomd helpers */
1062
1063 static inline const char *
1064 repomd_find(Repo *repo, const char *what, const unsigned char **chksump, Id *chksumtypep)
1065 {
1066   Pool *pool = repo->pool;
1067   Dataiterator di;
1068   const char *filename;
1069
1070   filename = 0;
1071   *chksump = 0;
1072   *chksumtypep = 0;
1073   dataiterator_init(&di, pool, repo, SOLVID_META, REPOSITORY_REPOMD_TYPE, what, SEARCH_STRING);
1074   dataiterator_prepend_keyname(&di, REPOSITORY_REPOMD);
1075   if (dataiterator_step(&di))
1076     {
1077       dataiterator_setpos_parent(&di);
1078       filename = pool_lookup_str(pool, SOLVID_POS, REPOSITORY_REPOMD_LOCATION);
1079       *chksump = pool_lookup_bin_checksum(pool, SOLVID_POS, REPOSITORY_REPOMD_CHECKSUM, chksumtypep);
1080     }
1081   dataiterator_free(&di);
1082   if (filename && !*chksumtypep)
1083     {
1084       printf("no %s file checksum!\n", what);
1085       filename = 0;
1086     }
1087   return filename;
1088 }
1089
1090 int
1091 repomd_add_ext(Repo *repo, Repodata *data, const char *what)
1092 {
1093   Pool *pool = repo->pool;
1094   Dataiterator di;
1095   Id chksumtype, handle;
1096   const unsigned char *chksum;
1097   const char *filename;
1098
1099   dataiterator_init(&di, pool, repo, SOLVID_META, REPOSITORY_REPOMD_TYPE, what, SEARCH_STRING);
1100   dataiterator_prepend_keyname(&di, REPOSITORY_REPOMD);
1101   if (!dataiterator_step(&di))
1102     {
1103       dataiterator_free(&di);
1104       return 0;
1105     }
1106   if (!strcmp(what, "prestodelta"))
1107     what = "deltainfo";
1108   dataiterator_setpos_parent(&di);
1109   filename = pool_lookup_str(pool, SOLVID_POS, REPOSITORY_REPOMD_LOCATION);
1110   chksum = pool_lookup_bin_checksum(pool, SOLVID_POS, REPOSITORY_REPOMD_CHECKSUM, &chksumtype);
1111   if (!filename || !chksum)
1112     {
1113       dataiterator_free(&di);
1114       return 0;
1115     }
1116   handle = repodata_new_handle(data);
1117   repodata_set_poolstr(data, handle, REPOSITORY_REPOMD_TYPE, what);
1118   repodata_set_str(data, handle, REPOSITORY_REPOMD_LOCATION, filename);
1119   if (chksumtype)
1120     repodata_set_bin_checksum(data, handle, REPOSITORY_REPOMD_CHECKSUM, chksumtype, chksum);
1121   if (!strcmp(what, "deltainfo"))
1122     {
1123       repodata_add_idarray(data, handle, REPOSITORY_KEYS, REPOSITORY_DELTAINFO);
1124       repodata_add_idarray(data, handle, REPOSITORY_KEYS, REPOKEY_TYPE_FLEXARRAY);
1125     }
1126   if (!strcmp(what, "filelists"))
1127     {
1128       repodata_add_idarray(data, handle, REPOSITORY_KEYS, SOLVABLE_FILELIST);
1129       repodata_add_idarray(data, handle, REPOSITORY_KEYS, REPOKEY_TYPE_DIRSTRARRAY);
1130     }
1131   dataiterator_free(&di);
1132   repodata_add_flexarray(data, SOLVID_META, REPOSITORY_EXTERNAL, handle);
1133   return 1;
1134 }
1135
1136
1137 /* susetags helpers */
1138
1139 static inline const char *
1140 susetags_find(Repo *repo, const char *what, const unsigned char **chksump, Id *chksumtypep)
1141 {
1142   Pool *pool = repo->pool;
1143   Dataiterator di;
1144   const char *filename;
1145
1146   filename = 0;
1147   *chksump = 0;
1148   *chksumtypep = 0;
1149   dataiterator_init(&di, pool, repo, SOLVID_META, SUSETAGS_FILE_NAME, what, SEARCH_STRING);
1150   dataiterator_prepend_keyname(&di, SUSETAGS_FILE);
1151   if (dataiterator_step(&di))
1152     {
1153       dataiterator_setpos_parent(&di);
1154       *chksump = pool_lookup_bin_checksum(pool, SOLVID_POS, SUSETAGS_FILE_CHECKSUM, chksumtypep);
1155       filename = what;
1156     }
1157   dataiterator_free(&di);
1158   if (filename && !*chksumtypep)
1159     {
1160       printf("no %s file checksum!\n", what);
1161       filename = 0;
1162     }
1163   return filename;
1164 }
1165
1166 static Id susetags_langtags[] = {
1167   SOLVABLE_SUMMARY, REPOKEY_TYPE_STR,
1168   SOLVABLE_DESCRIPTION, REPOKEY_TYPE_STR,
1169   SOLVABLE_EULA, REPOKEY_TYPE_STR,
1170   SOLVABLE_MESSAGEINS, REPOKEY_TYPE_STR,
1171   SOLVABLE_MESSAGEDEL, REPOKEY_TYPE_STR,
1172   SOLVABLE_CATEGORY, REPOKEY_TYPE_ID,
1173   0, 0
1174 };
1175
1176 void
1177 susetags_add_ext(Repo *repo, Repodata *data)
1178 {
1179   Pool *pool = repo->pool;
1180   Dataiterator di;
1181   char ext[3];
1182   Id handle, filechksumtype;
1183   const unsigned char *filechksum;
1184   int i;
1185
1186   dataiterator_init(&di, pool, repo, SOLVID_META, SUSETAGS_FILE_NAME, 0, 0);
1187   dataiterator_prepend_keyname(&di, SUSETAGS_FILE);
1188   while (dataiterator_step(&di))
1189     {
1190       if (strncmp(di.kv.str, "packages.", 9) != 0)
1191         continue;
1192       if (!di.kv.str[9] || !di.kv.str[10] || (di.kv.str[11] && di.kv.str[11] != '.'))
1193         continue;
1194       ext[0] = di.kv.str[9];
1195       ext[1] = di.kv.str[10];
1196       ext[2] = 0;
1197       if (!susetags_find(repo, di.kv.str, &filechksum, &filechksumtype))
1198         continue;
1199       handle = repodata_new_handle(data);
1200       repodata_set_str(data, handle, SUSETAGS_FILE_NAME, di.kv.str);
1201       if (filechksumtype)
1202         repodata_set_bin_checksum(data, handle, SUSETAGS_FILE_CHECKSUM, filechksumtype, filechksum);
1203       if (!strcmp(ext, "DU"))
1204         {
1205           repodata_add_idarray(data, handle, REPOSITORY_KEYS, SOLVABLE_DISKUSAGE);
1206           repodata_add_idarray(data, handle, REPOSITORY_KEYS, REPOKEY_TYPE_DIRNUMNUMARRAY);
1207         }
1208       if (!strcmp(ext, "FL"))
1209         {
1210           repodata_add_idarray(data, handle, REPOSITORY_KEYS, SOLVABLE_FILELIST);
1211           repodata_add_idarray(data, handle, REPOSITORY_KEYS, REPOKEY_TYPE_DIRSTRARRAY);
1212         }
1213       else
1214         {
1215           for (i = 0; susetags_langtags[i]; i += 2)
1216             {
1217               repodata_add_idarray(data, handle, REPOSITORY_KEYS, pool_id2langid(pool, susetags_langtags[i], ext, 1));
1218               repodata_add_idarray(data, handle, REPOSITORY_KEYS, susetags_langtags[i + 1]);
1219             }
1220         }
1221       repodata_add_flexarray(data, SOLVID_META, REPOSITORY_EXTERNAL, handle);
1222     }
1223   dataiterator_free(&di);
1224 }
1225
1226
1227 static inline int
1228 iscompressed(const char *name)
1229 {
1230   int l = strlen(name);
1231   return l > 3 && !strcmp(name + l - 3, ".gz") ? 1 : 0;
1232 }
1233
1234
1235 /* load callback */
1236
1237 int
1238 load_stub(Pool *pool, Repodata *data, void *dp)
1239 {
1240   const char *filename, *descrdir, *repomdtype;
1241   const unsigned char *filechksum;
1242   Id filechksumtype;
1243   struct repoinfo *cinfo;
1244   FILE *fp;
1245   Id defvendor;
1246   char ext[3];
1247
1248   cinfo = data->repo->appdata;
1249
1250   filename = repodata_lookup_str(data, SOLVID_META, SUSETAGS_FILE_NAME);
1251   if (filename)
1252     {
1253       /* susetags load */
1254       ext[0] = filename[9];
1255       ext[1] = filename[10];
1256       ext[2] = 0;
1257 #if 1
1258       printf("[%s:%s", data->repo->name, ext);
1259 #endif
1260       if (usecachedrepo(data->repo, ext, cinfo->extcookie, 0))
1261         {
1262           printf(" cached]\n"); fflush(stdout);
1263           return 1;
1264         }
1265 #if 1
1266       printf(" fetching]\n"); fflush(stdout);
1267 #endif
1268       defvendor = repo_lookup_id(data->repo, SOLVID_META, SUSETAGS_DEFAULTVENDOR);
1269       descrdir = repo_lookup_str(data->repo, SOLVID_META, SUSETAGS_DESCRDIR);
1270       if (!descrdir)
1271         descrdir = "suse/setup/descr";
1272       filechksumtype = 0;
1273       filechksum = repodata_lookup_bin_checksum(data, SOLVID_META, SUSETAGS_FILE_CHECKSUM, &filechksumtype);
1274       if ((fp = curlfopen(cinfo, pool_tmpjoin(pool, descrdir, "/", filename), iscompressed(filename), filechksum, filechksumtype, 0)) == 0)
1275         return 0;
1276       repo_add_susetags(data->repo, fp, defvendor, ext, REPO_USE_LOADING|REPO_EXTEND_SOLVABLES);
1277       fclose(fp);
1278       writecachedrepo(data->repo, data, ext, cinfo->extcookie);
1279       return 1;
1280     }
1281
1282   repomdtype = repodata_lookup_str(data, SOLVID_META, REPOSITORY_REPOMD_TYPE);
1283   if (repomdtype)
1284     {
1285       if (!strcmp(repomdtype, "filelists"))
1286         strcpy(ext, "FL");
1287       else if (!strcmp(repomdtype, "deltainfo"))
1288         strcpy(ext, "DL");
1289       else
1290         return 0;
1291 #if 1
1292       printf("[%s:%s", data->repo->name, ext);
1293 #endif
1294       if (usecachedrepo(data->repo, ext, cinfo->extcookie, 0))
1295         {
1296           printf(" cached]\n");fflush(stdout);
1297           return 1;
1298         }
1299       printf(" fetching]\n"); fflush(stdout);
1300       filename = repodata_lookup_str(data, SOLVID_META, REPOSITORY_REPOMD_LOCATION);
1301       filechksumtype = 0;
1302       filechksum = repodata_lookup_bin_checksum(data, SOLVID_META, REPOSITORY_REPOMD_CHECKSUM, &filechksumtype);
1303       if ((fp = curlfopen(cinfo, filename, iscompressed(filename), filechksum, filechksumtype, 0)) == 0)
1304         return 0;
1305       if (!strcmp(ext, "FL"))
1306         repo_add_rpmmd(data->repo, fp, ext, REPO_USE_LOADING|REPO_EXTEND_SOLVABLES);
1307       else if (!strcmp(ext, "DL"))
1308         repo_add_deltainfoxml(data->repo, fp, REPO_USE_LOADING);
1309       fclose(fp);
1310       writecachedrepo(data->repo, data, ext, cinfo->extcookie);
1311       return 1;
1312     }
1313
1314   return 0;
1315 }
1316
1317 static unsigned char installedcookie[32];
1318
1319 void
1320 read_repos(Pool *pool, struct repoinfo *repoinfos, int nrepoinfos)
1321 {
1322   Repo *repo;
1323   struct repoinfo *cinfo;
1324   int i;
1325   FILE *fp;
1326   FILE *sigfp;
1327   const char *filename;
1328   const unsigned char *filechksum;
1329   Id filechksumtype;
1330   const char *descrdir;
1331   int defvendor;
1332   struct stat stb;
1333   Pool *sigpool = 0;
1334   Repodata *data;
1335   int badchecksum;
1336   int dorefresh;
1337
1338   repo = repo_create(pool, "@System");
1339   printf("rpm database:");
1340   if (stat("/var/lib/rpm/Packages", &stb))
1341     memset(&stb, 0, sizeof(&stb));
1342   calc_checksum_stat(&stb, REPOKEY_TYPE_SHA256, installedcookie);
1343   if (usecachedrepo(repo, 0, installedcookie, 0))
1344     printf(" cached\n");
1345   else
1346     {
1347       FILE *ofp;
1348       printf(" reading\n");
1349       int done = 0;
1350
1351 #ifdef PRODUCTS_PATH
1352       repo_add_products(repo, PRODUCTS_PATH, 0, REPO_NO_INTERNALIZE);
1353 #endif
1354       if ((ofp = fopen(calccachepath(repo, 0), "r")) != 0)
1355         {
1356           Repo *ref = repo_create(pool, "@System.old");
1357           if (!repo_add_solv(ref, ofp))
1358             {
1359               repo_add_rpmdb(repo, ref, 0, REPO_REUSE_REPODATA);
1360               done = 1;
1361             }
1362           fclose(ofp);
1363           repo_free(ref, 1);
1364         }
1365       if (!done)
1366         repo_add_rpmdb(repo, 0, 0, REPO_REUSE_REPODATA);
1367       writecachedrepo(repo, 0, 0, installedcookie);
1368     }
1369   pool_set_installed(pool, repo);
1370
1371   for (i = 0; i < nrepoinfos; i++)
1372     {
1373       cinfo = repoinfos + i;
1374       if (!cinfo->enabled)
1375         continue;
1376
1377       repo = repo_create(pool, cinfo->alias);
1378       cinfo->repo = repo;
1379       repo->appdata = cinfo;
1380       repo->priority = 99 - cinfo->priority;
1381
1382       dorefresh = cinfo->autorefresh;
1383       if (dorefresh && cinfo->metadata_expire && stat(calccachepath(repo, 0), &stb) == 0)
1384         {
1385           if (cinfo->metadata_expire == -1 || time(0) - stb.st_mtime < cinfo->metadata_expire)
1386             dorefresh = 0;
1387         }
1388       if (!dorefresh && usecachedrepo(repo, 0, 0, 0))
1389         {
1390           printf("repo '%s':", cinfo->alias);
1391           printf(" cached\n");
1392           continue;
1393         }
1394       badchecksum = 0;
1395       switch (cinfo->type)
1396         {
1397         case TYPE_RPMMD:
1398           printf("rpmmd repo '%s':", cinfo->alias);
1399           fflush(stdout);
1400           if ((fp = curlfopen(cinfo, "repodata/repomd.xml", 0, 0, 0, 0)) == 0)
1401             {
1402               printf(" no repomd.xml file, skipped\n");
1403               repo_free(repo, 1);
1404               cinfo->repo = 0;
1405               break;
1406             }
1407           calc_checksum_fp(fp, REPOKEY_TYPE_SHA256, cinfo->cookie);
1408           if (usecachedrepo(repo, 0, cinfo->cookie, 1))
1409             {
1410               printf(" cached\n");
1411               fclose(fp);
1412               break;
1413             }
1414           if (cinfo->repo_gpgcheck)
1415             {
1416               sigfp = curlfopen(cinfo, "repodata/repomd.xml.asc", 0, 0, 0, 0);
1417               if (!sigfp)
1418                 {
1419                   printf(" unsigned, skipped\n");
1420                   fclose(fp);
1421                   break;
1422                 }
1423               if (!sigpool)
1424                 sigpool = read_sigs();
1425               if (!checksig(sigpool, fp, sigfp))
1426                 {
1427                   printf(" checksig failed, skipped\n");
1428                   fclose(sigfp);
1429                   fclose(fp);
1430                   break;
1431                 }
1432               fclose(sigfp);
1433             }
1434           repo_add_repomdxml(repo, fp, 0);
1435           fclose(fp);
1436           printf(" fetching\n");
1437           filename = repomd_find(repo, "primary", &filechksum, &filechksumtype);
1438           if (filename && (fp = curlfopen(cinfo, filename, iscompressed(filename), filechksum, filechksumtype, &badchecksum)) != 0)
1439             {
1440               repo_add_rpmmd(repo, fp, 0, 0);
1441               fclose(fp);
1442             }
1443           if (badchecksum)
1444             break;      /* hopeless */
1445
1446           filename = repomd_find(repo, "updateinfo", &filechksum, &filechksumtype);
1447           if (filename && (fp = curlfopen(cinfo, filename, iscompressed(filename), filechksum, filechksumtype, &badchecksum)) != 0)
1448             {
1449               repo_add_updateinfoxml(repo, fp, 0);
1450               fclose(fp);
1451             }
1452
1453           data = repo_add_repodata(repo, 0);
1454           if (!repomd_add_ext(repo, data, "deltainfo"))
1455             repomd_add_ext(repo, data, "prestodelta");
1456           repomd_add_ext(repo, data, "filelists");
1457           repodata_internalize(data);
1458           if (!badchecksum)
1459             writecachedrepo(repo, 0, 0, cinfo->cookie);
1460           repodata_create_stubs(repo_last_repodata(repo));
1461           break;
1462
1463         case TYPE_SUSETAGS:
1464           printf("susetags repo '%s':", cinfo->alias);
1465           fflush(stdout);
1466           descrdir = 0;
1467           defvendor = 0;
1468           if ((fp = curlfopen(cinfo, "content", 0, 0, 0, 0)) == 0)
1469             {
1470               printf(" no content file, skipped\n");
1471               repo_free(repo, 1);
1472               cinfo->repo = 0;
1473               break;
1474             }
1475           calc_checksum_fp(fp, REPOKEY_TYPE_SHA256, cinfo->cookie);
1476           if (usecachedrepo(repo, 0, cinfo->cookie, 1))
1477             {
1478               printf(" cached\n");
1479               fclose(fp);
1480               break;
1481             }
1482           if (cinfo->repo_gpgcheck)
1483             {
1484               sigfp = curlfopen(cinfo, "content.asc", 0, 0, 0, 0);
1485               if (!sigfp)
1486                 {
1487                   printf(" unsigned, skipped\n");
1488                   fclose(fp);
1489                   break;
1490                 }
1491               if (sigfp)
1492                 {
1493                   if (!sigpool)
1494                     sigpool = read_sigs();
1495                   if (!checksig(sigpool, fp, sigfp))
1496                     {
1497                       printf(" checksig failed, skipped\n");
1498                       fclose(sigfp);
1499                       fclose(fp);
1500                       break;
1501                     }
1502                   fclose(sigfp);
1503                 }
1504             }
1505           repo_add_content(repo, fp, 0);
1506           fclose(fp);
1507           defvendor = repo_lookup_id(repo, SOLVID_META, SUSETAGS_DEFAULTVENDOR);
1508           descrdir = repo_lookup_str(repo, SOLVID_META, SUSETAGS_DESCRDIR);
1509           if (!descrdir)
1510             descrdir = "suse/setup/descr";
1511           filename = susetags_find(repo, "packages.gz", &filechksum, &filechksumtype);
1512           if (!filename)
1513             filename = susetags_find(repo, "packages", &filechksum, &filechksumtype);
1514           if (!filename)
1515             {
1516               printf(" no packages file entry, skipped\n");
1517               break;
1518             }
1519           printf(" fetching\n");
1520           if ((fp = curlfopen(cinfo, pool_tmpjoin(pool, descrdir, "/", filename), iscompressed(filename), filechksum, filechksumtype, &badchecksum)) == 0)
1521             break;      /* hopeless */
1522           repo_add_susetags(repo, fp, defvendor, 0, 0);
1523           fclose(fp);
1524           data = repo_add_repodata(repo, 0);
1525           susetags_add_ext(repo, data);
1526           repodata_internalize(data);
1527           if (!badchecksum)
1528             writecachedrepo(repo, 0, 0, cinfo->cookie);
1529           repodata_create_stubs(repo_last_repodata(repo));
1530           break;
1531         default:
1532           printf("unsupported repo '%s': skipped\n", cinfo->alias);
1533           repo_free(repo, 1);
1534           cinfo->repo = 0;
1535           break;
1536         }
1537     }
1538   if (sigpool)
1539     pool_free(sigpool);
1540 }
1541
1542
1543 int
1544 str2archid(Pool *pool, char *arch)
1545 {
1546   Id id;
1547   if (!*arch)
1548     return 0;
1549   id = str2id(pool, arch, 0);
1550   if (id == ARCH_SRC || id == ARCH_NOSRC || id == ARCH_NOARCH)
1551     return id;
1552   if (pool->id2arch && (id > pool->lastarch || !pool->id2arch[id]))
1553     return 0;
1554   return id;
1555 }
1556
1557 int
1558 depglob(Pool *pool, char *name, Queue *job)
1559 {
1560   Id p, pp;
1561   Id id = str2id(pool, name, 0);
1562   int i, match = 0;
1563
1564   if (id)
1565     {
1566       FOR_PROVIDES(p, pp, id)
1567         {
1568           Solvable *s = pool->solvables + p;
1569           match = 1;
1570           if (s->name == id)
1571             {
1572               queue_push2(job, SOLVER_SOLVABLE_NAME, id);
1573               return 1;
1574             }
1575         }
1576       if (match)
1577         {
1578           printf("[using capability match for '%s']\n", name);
1579           queue_push2(job, SOLVER_SOLVABLE_PROVIDES, id);
1580           return 1;
1581         }
1582     }
1583
1584   if (strpbrk(name, "[*?") == 0)
1585     return 0;
1586
1587   /* looks like a name glob. hard work. */
1588   for (p = 1; p < pool->nsolvables; p++)
1589     {
1590       Solvable *s = pool->solvables + p;
1591       if (!s->repo || !pool_installable(pool, s))
1592         continue;
1593       id = s->name;
1594       if (fnmatch(name, id2str(pool, id), 0) == 0)
1595         {
1596           for (i = 0; i < job->count; i += 2)
1597             if (job->elements[i] == SOLVER_SOLVABLE_NAME && job->elements[i + 1] == id)
1598               break;
1599           if (i == job->count)
1600             queue_push2(job, SOLVER_SOLVABLE_NAME, id);
1601           match = 1;
1602         }
1603     }
1604   if (match)
1605     return 1;
1606   /* looks like a dep glob. really hard work. */
1607   for (id = 1; id < pool->ss.nstrings; id++)
1608     {
1609       if (!pool->whatprovides[id])
1610         continue;
1611       if (fnmatch(name, id2str(pool, id), 0) == 0)
1612         {
1613           if (!match)
1614             printf("[using capability match for '%s']\n", name);
1615           for (i = 0; i < job->count; i += 2)
1616             if (job->elements[i] == SOLVER_SOLVABLE_PROVIDES && job->elements[i + 1] == id)
1617               break;
1618           if (i == job->count)
1619             queue_push2(job, SOLVER_SOLVABLE_PROVIDES, id);
1620           match = 1;
1621         }
1622     }
1623   if (match)
1624     return 1;
1625   return 0;
1626 }
1627
1628 void
1629 addrelation(Pool *pool, Queue *job, int flags, Id evr)
1630 {
1631   int i;
1632   for (i = 0; i < job->count; i += 2)
1633     {
1634       if (job->elements[i] != SOLVER_SOLVABLE_NAME && job->elements[i] != SOLVER_SOLVABLE_PROVIDES)
1635         continue;
1636       job->elements[i + 1] = rel2id(pool, job->elements[i + 1], evr, flags, 1);
1637     }
1638 }
1639
1640 int
1641 limitevr(Pool *pool, char *evr, Queue *job, Id archid)
1642 {
1643   Queue mq;
1644   Id p, pp, evrid;
1645   int matched = 0;
1646   int i, j;
1647   Solvable *s;
1648
1649   queue_init(&mq);
1650   for (i = 0; i < job->count; i += 2)
1651     {
1652       queue_empty(&mq);
1653       FOR_JOB_SELECT(p, pp, job->elements[i], job->elements[i + 1])
1654         {
1655           s = pool_id2solvable(pool, p);
1656           if (archid && s->arch != archid)
1657             continue;
1658           if (evrcmp_str(pool, id2str(pool, s->evr), evr, EVRCMP_MATCH) == 0)
1659              queue_push(&mq, p);
1660         }
1661       if (mq.count)
1662         {
1663           if (!matched && i)
1664             {
1665               queue_deleten(job, 0, i);
1666               i = 0;
1667             }
1668           matched = 1;
1669           /* if all solvables have the same evr */
1670           s = pool_id2solvable(pool, mq.elements[0]);
1671           evrid = s->evr;
1672           for (j = 0; j < mq.count; j++)
1673             {
1674               s = pool_id2solvable(pool, mq.elements[j]);
1675               if (s->evr != evrid)
1676                 break;
1677             }
1678           if (j == mq.count && j > 1)
1679             {
1680               prune_to_best_arch(pool, &mq);
1681               // prune_to_highest_prio(pool, &mq);
1682               mq.count = 1;
1683             }
1684           if (mq.count > 1)
1685             {
1686               job->elements[i] = SOLVER_SOLVABLE_ONE_OF;
1687               job->elements[i + 1] = pool_queuetowhatprovides(pool, &mq);
1688             }
1689           else
1690             {
1691               job->elements[i] = SOLVER_SOLVABLE;
1692               job->elements[i + 1] = mq.elements[0];
1693             }
1694         }
1695       else if (matched)
1696         {
1697           queue_deleten(job, i, 2);
1698           i -= 2;
1699         }
1700     }
1701   queue_free(&mq);
1702   if (matched)
1703     return 1;
1704   if (!archid)
1705     {
1706       char *r;
1707       if ((r = strrchr(evr, '.')) != 0 && r[1] && (archid = str2archid(pool, r + 1)) != 0)
1708         {
1709           *r = 0;
1710           if (limitevr(pool, evr, job, archid))
1711             {
1712               *r = '.';
1713               return 1;
1714             }
1715           *r = '.';
1716         }
1717     }
1718   return 0;
1719 }
1720
1721 void
1722 mkselect(Pool *pool, int mode, char *name, Queue *job)
1723 {
1724   char *r, *r2;
1725   Id archid;
1726
1727   if (*name == '/')
1728     {
1729       Dataiterator di;
1730       Queue q;
1731       int match = 0;
1732
1733       queue_init(&q);
1734       dataiterator_init(&di, pool, mode == SOLVER_ERASE ? pool->installed : 0, 0, SOLVABLE_FILELIST, name, SEARCH_STRING|SEARCH_FILES|SEARCH_COMPLETE_FILELIST);
1735       while (dataiterator_step(&di))
1736         {
1737           Solvable *s = pool->solvables + di.solvid;
1738           if (!s->repo || !pool_installable(pool, s))
1739             continue;
1740           queue_push(&q, di.solvid);
1741           dataiterator_skip_solvable(&di);
1742         }
1743       dataiterator_free(&di);
1744       if (q.count)
1745         {
1746           printf("[using file list match for '%s']\n", name);
1747           match = 1;
1748           if (q.count > 1)
1749             queue_push2(job, SOLVER_SOLVABLE_ONE_OF, pool_queuetowhatprovides(pool, &q));
1750           else
1751             queue_push2(job, SOLVER_SOLVABLE, q.elements[0]);
1752         }
1753       queue_free(&q);
1754       if (match)
1755         return;
1756     }
1757   if ((r = strpbrk(name, "<=>")) != 0)
1758     {
1759       /* relation case, support:
1760        * depglob rel
1761        * depglob.rpm rel
1762        */
1763       int rflags = 0;
1764       int nend = r - name;
1765       for (; *r; r++)
1766         {
1767           if (*r == '<')
1768             rflags |= REL_LT;
1769           else if (*r == '=')
1770             rflags |= REL_EQ;
1771           else if (*r == '>')
1772             rflags |= REL_GT;
1773           else
1774             break;
1775         }
1776       while (*r && *r == ' ' && *r == '\t')
1777         r++;
1778       while (nend && (name[nend - 1] == ' ' || name[nend -1 ] == '\t'))
1779         nend--;
1780       name[nend] = 0;
1781       if (!*name || !*r)
1782         {
1783           fprintf(stderr, "bad relation\n");
1784           exit(1);
1785         }
1786       if (depglob(pool, name, job))
1787         {
1788           addrelation(pool, job, rflags, str2id(pool, r, 1));
1789           return;
1790         }
1791       if ((r2 = strrchr(name, '.')) != 0 && r2[1] && (archid = str2archid(pool, r2 + 1)) != 0)
1792         {
1793           *r2 = 0;
1794           if (depglob(pool, name, job))
1795             {
1796               *r2 = '.';
1797               addrelation(pool, job, REL_ARCH, archid);
1798               addrelation(pool, job, rflags, str2id(pool, r, 1));
1799               return;
1800             }
1801           *r2 = '.';
1802         }
1803     }
1804   else
1805     {
1806       /* no relation case, support:
1807        * depglob
1808        * depglob.arch
1809        * depglob-version-release
1810        * depglob-version-release.arch
1811        */
1812       if (depglob(pool, name, job))
1813         return;
1814       archid = 0;
1815       if ((r = strrchr(name, '.')) != 0 && r[1] && (archid = str2archid(pool, r + 1)) != 0)
1816         {
1817           *r = 0;
1818           if (depglob(pool, name, job))
1819             {
1820               *r = '.';
1821               addrelation(pool, job, REL_ARCH, archid);
1822               return;
1823             }
1824           *r = '.';
1825         }
1826       if ((r = strrchr(name, '-')) != 0)
1827         {
1828           *r = 0;
1829           if (depglob(pool, name, job))
1830             {
1831               /* have just the version */
1832               *r = '-';
1833               if (limitevr(pool, r + 1, job, 0))
1834                 return;
1835             }
1836           if ((r2 = strrchr(name, '-')) != 0)
1837             {
1838               *r = '-';
1839               *r2 = 0;
1840               if (depglob(pool, name, job))
1841                 {
1842                   *r2 = '-';
1843                   if (limitevr(pool, r2 + 1, job, 0))
1844                     return;
1845                 }
1846               *r2 = '-';
1847             }
1848           *r = '-';
1849         }
1850     }
1851   fprintf(stderr, "nothing matches '%s'\n", name);
1852   exit(1);
1853 }
1854
1855
1856 int
1857 yesno(const char *str)
1858 {
1859   char inbuf[128], *ip;
1860
1861   for (;;)
1862     {
1863       printf("%s", str);
1864       fflush(stdout);
1865       *inbuf = 0;
1866       if (!(ip = fgets(inbuf, sizeof(inbuf), stdin)))
1867         {
1868           printf("Abort.\n");
1869           exit(1);
1870         }
1871       while (*ip == ' ' || *ip == '\t')
1872         ip++;
1873       if (*ip == 'q')
1874         {
1875           printf("Abort.\n");
1876           exit(1);
1877         }
1878       if (*ip == 'y' || *ip == 'n')
1879         return *ip == 'y' ? 1 : 0;
1880     }
1881 }
1882
1883 struct fcstate {
1884   FILE **newpkgsfps;
1885   Queue *checkq;
1886   int newpkgscnt;
1887   void *rpmdbstate;
1888 };
1889
1890 static void *
1891 fileconflict_cb(Pool *pool, Id p, void *cbdata)
1892 {
1893   struct fcstate *fcstate = cbdata;
1894   Solvable *s;
1895   Id rpmdbid;
1896   int i;
1897   FILE *fp;
1898
1899   if (!p)
1900     {
1901       rpm_byrpmdbid(0, 0, &fcstate->rpmdbstate);
1902       return 0;
1903     }
1904   s = pool_id2solvable(pool, p);
1905   if (pool->installed && s->repo == pool->installed)
1906     {
1907       if (!s->repo->rpmdbid)
1908         return 0;
1909       rpmdbid = s->repo->rpmdbid[p - s->repo->start];
1910       if (!rpmdbid)
1911         return 0;
1912        return rpm_byrpmdbid(rpmdbid, 0, &fcstate->rpmdbstate);
1913     }
1914   for (i = 0; i < fcstate->newpkgscnt; i++)
1915     if (fcstate->checkq->elements[i] == p)
1916       break;
1917   if (i == fcstate->newpkgscnt)
1918     return 0;
1919   fp = fcstate->newpkgsfps[i];
1920   if (!fp)
1921     return 0;
1922   rewind(fp);
1923   return rpm_byfp(fp, solvable2str(pool, s), &fcstate->rpmdbstate);
1924 }
1925
1926 void
1927 runrpm(const char *arg, const char *name, int dupfd3)
1928 {
1929   pid_t pid;
1930   int status;
1931
1932   if ((pid = fork()) == (pid_t)-1)
1933     {
1934       perror("fork");
1935       exit(1);
1936     }
1937   if (pid == 0)
1938     {
1939       if (dupfd3 != -1 && dupfd3 != 3)
1940         {
1941           dup2(dupfd3, 3);
1942           close(dupfd3);
1943         }
1944       if (dupfd3 != -1)
1945         fcntl(3, F_SETFD, 0);   /* clear CLOEXEC */
1946       if (strcmp(arg, "-e") == 0)
1947         execlp("rpm", "rpm", arg, "--nodeps", "--nodigest", "--nosignature", name, (char *)0);
1948       else
1949         execlp("rpm", "rpm", arg, "--force", "--nodeps", "--nodigest", "--nosignature", name, (char *)0);
1950       perror("rpm");
1951       _exit(0);
1952     }
1953   while (waitpid(pid, &status, 0) != pid)
1954     ;
1955   if (status)
1956     {
1957       printf("rpm failed\n");
1958       exit(1);
1959     }
1960 }
1961
1962 static Id
1963 nscallback(Pool *pool, void *data, Id name, Id evr)
1964 {
1965   if (name == NAMESPACE_PRODUCTBUDDY)
1966     {
1967       /* SUSE specific hack: each product has an associated rpm */
1968       Solvable *s = pool->solvables + evr;
1969       Id p, pp, cap;
1970
1971       cap = str2id(pool, pool_tmpjoin(pool, "product(", id2str(pool, s->name) + 8, ")"), 0);
1972       if (!cap)
1973         return 0;
1974       cap = rel2id(pool, cap, s->evr, REL_EQ, 0);
1975       if (!cap)
1976         return 0;
1977       FOR_PROVIDES(p, pp, cap)
1978         {
1979           Solvable *ps = pool->solvables + p;
1980           if (ps->repo == s->repo && ps->arch == s->arch)
1981             break;
1982         }
1983       return p;
1984     }
1985   return 0;
1986 }
1987
1988 #ifdef SOFTLOCKS_PATH
1989
1990 void
1991 addsoftlocks(Pool *pool, Queue *job)
1992 {
1993   FILE *fp;
1994   Id type, id, p, pp;
1995   char *bp, *ep, buf[4096];
1996
1997   if ((fp = fopen(SOFTLOCKS_PATH, "r")) == 0)
1998     return;
1999   while((bp = fgets(buf, sizeof(buf), fp)) != 0)
2000     {
2001       while (*bp == ' ' || *bp == '\t')
2002         bp++;
2003       if (!*bp || *bp == '#')
2004         continue;
2005       for (ep = bp; *ep; ep++)
2006         if (*ep == ' ' || *ep == '\t' || *ep == '\n')
2007           break;
2008       *ep = 0;
2009       type = SOLVER_SOLVABLE_NAME;
2010       if (!strncmp(bp, "provides:", 9) && bp[9])
2011         {
2012           type = SOLVER_SOLVABLE_PROVIDES;
2013           bp += 9;
2014         }
2015       id = str2id(pool, bp, 1);
2016       if (pool->installed)
2017         {
2018           FOR_JOB_SELECT(p, pp, type, id)
2019             if (pool->solvables[p].repo == pool->installed)
2020               break;
2021           if (p)
2022             continue;   /* ignore, as it is already installed */
2023         }
2024       queue_push2(job, SOLVER_LOCK|SOLVER_WEAK|type, id);
2025     }
2026   fclose(fp);
2027 }
2028
2029 #endif
2030
2031
2032 void
2033 rewrite_repos(Pool *pool, Id *addedfileprovides)
2034 {
2035   Repo *repo;
2036   Repodata *data;
2037   Map providedids;
2038   Queue fileprovidesq;
2039   Id id;
2040   int i, j, n, nprovidedids;
2041   struct repoinfo *cinfo;
2042
2043   map_init(&providedids, pool->ss.nstrings);
2044   queue_init(&fileprovidesq);
2045   for (nprovidedids = 0; (id = addedfileprovides[nprovidedids]) != 0; nprovidedids++)
2046     MAPSET(&providedids, id);
2047   FOR_REPOS(i, repo)
2048     {
2049       /* make sure this repo has just one main repodata */
2050       if (!repo->nrepodata)
2051         continue;
2052       cinfo = repo->appdata;
2053       data = repo->repodata + 0;
2054       if (data->store.pagefd == -1)
2055         continue;
2056       if (repodata_lookup_idarray(data, SOLVID_META, REPOSITORY_ADDEDFILEPROVIDES, &fileprovidesq))
2057         {
2058           n = 0;
2059           for (j = 0; j < fileprovidesq.count; j++)
2060             if (MAPTST(&providedids, fileprovidesq.elements[j]))
2061               n++;
2062           if (n == nprovidedids)
2063             continue;   /* nothing new added */
2064         }
2065       /* oh my! */
2066       for (j = 0; addedfileprovides[j]; j++)
2067         repodata_add_idarray(data, SOLVID_META, REPOSITORY_ADDEDFILEPROVIDES, addedfileprovides[j]);
2068       repodata_internalize(data);
2069       writecachedrepo(repo, data, 0, cinfo ? cinfo->cookie : installedcookie);
2070     }
2071   queue_free(&fileprovidesq);
2072   map_free(&providedids);
2073 }
2074
2075 #define MODE_LIST        0
2076 #define MODE_INSTALL     1
2077 #define MODE_ERASE       2
2078 #define MODE_UPDATE      3
2079 #define MODE_DISTUPGRADE 4
2080 #define MODE_VERIFY      5
2081 #define MODE_PATCH       6
2082 #define MODE_INFO        7
2083 #define MODE_REPOLIST    8
2084 #define MODE_SEARCH      9
2085
2086 void
2087 usage(int r)
2088 {
2089   fprintf(stderr, "Usage: solv COMMAND <select>\n");
2090   fprintf(stderr, "\n");
2091   fprintf(stderr, "    distupgrade: replace installed packages with\n");
2092   fprintf(stderr, "                 versions from the repositories\n");
2093   fprintf(stderr, "    erase:       erase installed packages\n");
2094   fprintf(stderr, "    info:        display package information\n");
2095   fprintf(stderr, "    install:     install packages\n");
2096   fprintf(stderr, "    list:        list packages\n");
2097   fprintf(stderr, "    repos:       list enabled repositories\n");
2098   fprintf(stderr, "    search:      search name/summary/description\n");
2099   fprintf(stderr, "    update:      update installed packages\n");
2100   fprintf(stderr, "    verify:      check dependencies of installed packages\n");
2101   fprintf(stderr, "\n");
2102   exit(r);
2103 }
2104
2105 int
2106 main(int argc, char **argv)
2107 {
2108   Pool *pool;
2109   Repo *commandlinerepo = 0;
2110   Id *commandlinepkgs = 0;
2111   Id p, pp;
2112   struct repoinfo *repoinfos;
2113   int nrepoinfos = 0;
2114   int mainmode = 0, mode = 0;
2115   int i, newpkgs;
2116   Queue job, checkq;
2117   Solver *solv = 0;
2118   Transaction *trans;
2119   char inbuf[128], *ip;
2120   int allpkgs = 0;
2121   FILE **newpkgsfps;
2122   struct fcstate fcstate;
2123   Id *addedfileprovides = 0;
2124
2125   argc--;
2126   argv++;
2127   if (!argv[0])
2128     usage(1);
2129   if (!strcmp(argv[0], "install") || !strcmp(argv[0], "in"))
2130     {
2131       mainmode = MODE_INSTALL;
2132       mode = SOLVER_INSTALL;
2133     }
2134   else if (!strcmp(argv[0], "patch"))
2135     {
2136       mainmode = MODE_PATCH;
2137       mode = SOLVER_INSTALL;
2138     }
2139   else if (!strcmp(argv[0], "erase") || !strcmp(argv[0], "rm"))
2140     {
2141       mainmode = MODE_ERASE;
2142       mode = SOLVER_ERASE;
2143     }
2144   else if (!strcmp(argv[0], "list"))
2145     {
2146       mainmode = MODE_LIST;
2147       mode = 0;
2148     }
2149   else if (!strcmp(argv[0], "info"))
2150     {
2151       mainmode = MODE_INFO;
2152       mode = 0;
2153     }
2154   else if (!strcmp(argv[0], "search"))
2155     {
2156       mainmode = MODE_SEARCH;
2157       mode = 0;
2158     }
2159   else if (!strcmp(argv[0], "verify"))
2160     {
2161       mainmode = MODE_VERIFY;
2162       mode = SOLVER_VERIFY;
2163     }
2164   else if (!strcmp(argv[0], "update") || !strcmp(argv[0], "up"))
2165     {
2166       mainmode = MODE_UPDATE;
2167       mode = SOLVER_UPDATE;
2168     }
2169   else if (!strcmp(argv[0], "dist-upgrade") || !strcmp(argv[0], "dup"))
2170     {
2171       mainmode = MODE_DISTUPGRADE;
2172       mode = SOLVER_UPDATE;
2173     }
2174   else if (!strcmp(argv[0], "repos") || !strcmp(argv[0], "repolist") || !strcmp(argv[0], "lr"))
2175     {
2176       mainmode = MODE_REPOLIST;
2177       mode = 0;
2178     }
2179   else
2180     usage(1);
2181
2182   pool = pool_create();
2183 #ifdef FEDORA
2184   pool->obsoleteusescolors = 1;
2185 #endif
2186   pool_setloadcallback(pool, load_stub, 0);
2187   pool->nscallback = nscallback;
2188   // pool_setdebuglevel(pool, 2);
2189   setarch(pool);
2190   repoinfos = read_repoinfos(pool, REPOINFO_PATH, &nrepoinfos);
2191
2192   if (mainmode == MODE_REPOLIST)
2193     {
2194       int j = 1;
2195       for (i = 0; i < nrepoinfos; i++)
2196         {
2197           struct repoinfo *cinfo = repoinfos + i;
2198           if (!cinfo->enabled)
2199             continue;
2200           printf("%d: %-20s %s\n", j++, cinfo->alias, cinfo->name);
2201         }
2202       exit(0);
2203     }
2204
2205   read_repos(pool, repoinfos, nrepoinfos);
2206
2207   if (mainmode == MODE_SEARCH)
2208     {
2209       Dataiterator di;
2210       Map m;
2211       if (argc != 2)
2212         usage(1);
2213       map_init(&m, pool->nsolvables);
2214       dataiterator_init(&di, pool, 0, 0, 0, argv[1], SEARCH_SUBSTRING|SEARCH_NOCASE);
2215       dataiterator_set_keyname(&di, SOLVABLE_NAME);
2216       dataiterator_set_search(&di, 0, 0);
2217       while (dataiterator_step(&di))
2218         MAPSET(&m, di.solvid);
2219       dataiterator_set_keyname(&di, SOLVABLE_SUMMARY);
2220       dataiterator_set_search(&di, 0, 0);
2221       while (dataiterator_step(&di))
2222         MAPSET(&m, di.solvid);
2223       dataiterator_set_keyname(&di, SOLVABLE_DESCRIPTION);
2224       dataiterator_set_search(&di, 0, 0);
2225       while (dataiterator_step(&di))
2226         MAPSET(&m, di.solvid);
2227       dataiterator_free(&di);
2228
2229       for (p = 1; p < pool->nsolvables; p++)
2230         {
2231           Solvable *s = pool_id2solvable(pool, p);
2232           if (!MAPTST(&m, p))
2233             continue;
2234           printf("  - %s: %s\n", solvable2str(pool, s), solvable_lookup_str(s, SOLVABLE_SUMMARY));
2235         }
2236       map_free(&m);
2237       exit(0);
2238     }
2239
2240
2241   if (mainmode == MODE_LIST || mainmode == MODE_INSTALL)
2242     {
2243       for (i = 1; i < argc; i++)
2244         {
2245           int l;
2246           l = strlen(argv[i]);
2247           if (l <= 4 || strcmp(argv[i] + l - 4, ".rpm"))
2248             continue;
2249           if (access(argv[i], R_OK))
2250             {
2251               perror(argv[i]);
2252               exit(1);
2253             }
2254           if (!commandlinepkgs)
2255             commandlinepkgs = sat_calloc(argc, sizeof(Id));
2256           if (!commandlinerepo)
2257             commandlinerepo = repo_create(pool, "@commandline");
2258           repo_add_rpms(commandlinerepo, (const char **)argv + i, 1, REPO_REUSE_REPODATA|REPO_NO_INTERNALIZE);
2259           commandlinepkgs[i] = commandlinerepo->end - 1;
2260         }
2261       if (commandlinerepo)
2262         repo_internalize(commandlinerepo);
2263     }
2264
2265   // FOR_REPOS(i, repo)
2266   //   printf("%s: %d solvables\n", repo->name, repo->nsolvables);
2267   addedfileprovides = 0;
2268   pool_addfileprovides_ids(pool, 0, &addedfileprovides);
2269   if (addedfileprovides && *addedfileprovides)
2270     rewrite_repos(pool, addedfileprovides);
2271   sat_free(addedfileprovides);
2272   pool_createwhatprovides(pool);
2273
2274   queue_init(&job);
2275   for (i = 1; i < argc; i++)
2276     {
2277       Queue job2;
2278       int j;
2279
2280       if (commandlinepkgs && commandlinepkgs[i])
2281         {
2282           queue_push2(&job, SOLVER_SOLVABLE, commandlinepkgs[i]);
2283           continue;
2284         }
2285       queue_init(&job2);
2286       mkselect(pool, mode, argv[i], &job2);
2287       for (j = 0; j < job2.count; j++)
2288         queue_push(&job, job2.elements[j]);
2289       queue_free(&job2);
2290     }
2291
2292   if (!job.count && mainmode != MODE_UPDATE && mainmode != MODE_DISTUPGRADE && mainmode != MODE_VERIFY && mainmode != MODE_PATCH)
2293     {
2294       printf("no package matched\n");
2295       exit(1);
2296     }
2297
2298   if (!job.count)
2299     allpkgs = 1;
2300
2301   if (mainmode == MODE_LIST || mainmode == MODE_INFO)
2302     {
2303       /* list mode, no solver needed */
2304       for (i = 0; i < job.count; i += 2)
2305         {
2306           FOR_JOB_SELECT(p, pp, job.elements[i], job.elements[i + 1])
2307             {
2308               Solvable *s = pool_id2solvable(pool, p);
2309               if (mainmode == MODE_INFO)
2310                 {
2311                   printf("Name:        %s\n", solvable2str(pool, s));
2312                   printf("Repo:        %s\n", s->repo->name);
2313                   printf("Summary:     %s\n", solvable_lookup_str(s, SOLVABLE_SUMMARY));
2314                   printf("Url:         %s\n", solvable_lookup_str(s, SOLVABLE_URL));
2315                   printf("License:     %s\n", solvable_lookup_str(s, SOLVABLE_LICENSE));
2316                   printf("Description:\n%s\n", solvable_lookup_str(s, SOLVABLE_DESCRIPTION));
2317                   printf("\n");
2318                 }
2319               else
2320                 {
2321                   const char *sum = solvable_lookup_str_lang(s, SOLVABLE_SUMMARY, "de");
2322                   printf("  - %s [%s]\n", solvable2str(pool, s), s->repo->name);
2323                   if (sum)
2324                     printf("    %s\n", sum);
2325                 }
2326             }
2327         }
2328       queue_free(&job);
2329       pool_free(pool);
2330       free_repoinfos(repoinfos, nrepoinfos);
2331       sat_free(commandlinepkgs);
2332       exit(0);
2333     }
2334
2335   if (mainmode == MODE_PATCH)
2336     {
2337       int pruneyou = 0;
2338       Map installedmap;
2339       Solvable *s;
2340
2341       map_init(&installedmap, pool->nsolvables);
2342       if (pool->installed)
2343         FOR_REPO_SOLVABLES(pool->installed, p, s)
2344           MAPSET(&installedmap, p);
2345
2346       /* install all patches */
2347       for (p = 1; p < pool->nsolvables; p++)
2348         {
2349           const char *type;
2350           int r;
2351           Id p2;
2352
2353           s = pool->solvables + p;
2354           if (strncmp(id2str(pool, s->name), "patch:", 6) != 0)
2355             continue;
2356           FOR_PROVIDES(p2, pp, s->name)
2357             {
2358               Solvable *s2 = pool->solvables + p2;
2359               if (s2->name != s->name)
2360                 continue;
2361               r = evrcmp(pool, s->evr, s2->evr, EVRCMP_COMPARE);
2362               if (r < 0 || (r == 0 && p > p2))
2363                 break;
2364             }
2365           if (p2)
2366             continue;
2367           type = solvable_lookup_str(s, SOLVABLE_PATCHCATEGORY);
2368           if (type && !strcmp(type, "optional"))
2369             continue;
2370           r = solvable_trivial_installable_map(s, &installedmap, 0);
2371           if (r == -1)
2372             continue;
2373           if (solvable_lookup_bool(s, UPDATE_RESTART) && r == 0)
2374             {
2375               if (!pruneyou++)
2376                 queue_empty(&job);
2377             }
2378           else if (pruneyou)
2379             continue;
2380           queue_push2(&job, SOLVER_SOLVABLE, p);
2381         }
2382       map_free(&installedmap);
2383     }
2384
2385   // add mode
2386   for (i = 0; i < job.count; i += 2)
2387     {
2388       if (mode == SOLVER_UPDATE)
2389         {
2390           /* make update of not installed packages an install */
2391           FOR_JOB_SELECT(p, pp, job.elements[i], job.elements[i + 1])
2392             if (pool->installed && pool->solvables[p].repo == pool->installed)
2393               break;
2394           if (!p)
2395             {
2396               job.elements[i] |= SOLVER_INSTALL;
2397               continue;
2398             }
2399         }
2400       job.elements[i] |= mode;
2401     }
2402
2403   // multiversion test
2404   // queue_push2(&job, SOLVER_NOOBSOLETES|SOLVER_SOLVABLE_NAME, str2id(pool, "kernel-pae", 1));
2405   // queue_push2(&job, SOLVER_NOOBSOLETES|SOLVER_SOLVABLE_NAME, str2id(pool, "kernel-pae-base", 1));
2406   // queue_push2(&job, SOLVER_NOOBSOLETES|SOLVER_SOLVABLE_NAME, str2id(pool, "kernel-pae-extra", 1));
2407
2408 #ifdef SOFTLOCKS_PATH
2409   addsoftlocks(pool, &job);
2410 #endif
2411
2412 rerunsolver:
2413   for (;;)
2414     {
2415       Id problem, solution;
2416       int pcnt, scnt;
2417
2418       solv = solver_create(pool);
2419       solv->ignorealreadyrecommended = 1;
2420       solv->updatesystem = allpkgs && (mainmode == MODE_UPDATE || mainmode == MODE_DISTUPGRADE);
2421       solv->dosplitprovides = solv->updatesystem;
2422       solv->fixsystem = allpkgs && (mainmode == MODE_VERIFY);
2423       if (mainmode == MODE_DISTUPGRADE)
2424         {
2425           solv->distupgrade = 1;
2426           solv->allowdowngrade = 1;
2427           solv->allowarchchange = 1;
2428           solv->allowvendorchange = 1;
2429         }
2430       if (mainmode == MODE_ERASE)
2431         solv->allowuninstall = 1;       /* don't nag */
2432
2433       // queue_push2(&job, SOLVER_DISTUPGRADE, 3);
2434       solver_solve(solv, &job);
2435       if (!solv->problems.count)
2436         break;
2437       pcnt = solver_problem_count(solv);
2438       printf("Found %d problems:\n", pcnt);
2439       for (problem = 1; problem <= pcnt; problem++)
2440         {
2441           int take = 0;
2442           printf("Problem %d:\n", problem);
2443           solver_printprobleminfo(solv, problem);
2444           printf("\n");
2445           scnt = solver_solution_count(solv, problem);
2446           for (solution = 1; solution <= scnt; solution++)
2447             {
2448               printf("Solution %d:\n", solution);
2449               solver_printsolution(solv, problem, solution);
2450               printf("\n");
2451             }
2452           for (;;)
2453             {
2454               printf("Please choose a solution: ");
2455               fflush(stdout);
2456               *inbuf = 0;
2457               if (!(ip = fgets(inbuf, sizeof(inbuf), stdin)))
2458                 {
2459                   printf("Abort.\n");
2460                   exit(1);
2461                 }
2462               while (*ip == ' ' || *ip == '\t')
2463                 ip++;
2464               if (*ip >= '0' && *ip <= '9')
2465                 {
2466                   take = atoi(ip);
2467                   if (take >= 1 && take <= scnt)
2468                     break;
2469                 }
2470               if (*ip == 's')
2471                 {
2472                   take = 0;
2473                   break;
2474                 }
2475               if (*ip == 'q')
2476                 {
2477                   printf("Abort.\n");
2478                   exit(1);
2479                 }
2480             }
2481           if (!take)
2482             continue;
2483           solver_take_solution(solv, problem, take, &job);
2484         }
2485       solver_free(solv);
2486       solv = 0;
2487     }
2488
2489   trans = &solv->trans;
2490   if (!trans->steps.count)
2491     {
2492       printf("Nothing to do.\n");
2493       exit(1);
2494     }
2495   printf("\n");
2496   printf("Transaction summary:\n\n");
2497   solver_printtransaction(solv);
2498
2499 #ifndef FEDORA
2500   if (1)
2501     {
2502       DUChanges duc[4];
2503       int i;
2504
2505       duc[0].path = "/";
2506       duc[1].path = "/usr/share/man";
2507       duc[2].path = "/sbin";
2508       duc[3].path = "/etc";
2509       transaction_calc_duchanges(trans, duc, 4);
2510       for (i = 0; i < 4; i++)
2511         printf("duchanges %s: %d K  %d inodes\n", duc[i].path, duc[i].kbytes, duc[i].files);
2512     }
2513 #endif
2514   printf("install size change: %d K\n", transaction_calc_installsizechange(trans));
2515   printf("\n");
2516
2517   if (!yesno("OK to continue (y/n)? "))
2518     {
2519       printf("Abort.\n");
2520       exit(1);
2521     }
2522
2523   queue_init(&checkq);
2524   newpkgs = transaction_installedresult(trans, &checkq);
2525   newpkgsfps = 0;
2526
2527   if (newpkgs)
2528     {
2529       int downloadsize = 0;
2530       for (i = 0; i < newpkgs; i++)
2531         {
2532           Solvable *s;
2533
2534           p = checkq.elements[i];
2535           s = pool_id2solvable(pool, p);
2536           downloadsize += solvable_lookup_num(s, SOLVABLE_DOWNLOADSIZE, 0);
2537         }
2538       printf("Downloading %d packages, %d K\n", newpkgs, downloadsize);
2539       newpkgsfps = sat_calloc(newpkgs, sizeof(*newpkgsfps));
2540       for (i = 0; i < newpkgs; i++)
2541         {
2542           unsigned int medianr;
2543           char *loc;
2544           Solvable *s;
2545           struct repoinfo *cinfo;
2546           const unsigned char *chksum;
2547           Id chksumtype;
2548           Dataiterator di;
2549
2550           p = checkq.elements[i];
2551           s = pool_id2solvable(pool, p);
2552           if (s->repo == commandlinerepo)
2553             {
2554               loc = solvable_get_location(s, &medianr);
2555               if (!(newpkgsfps[i] = fopen(loc, "r")))
2556                 {
2557                   perror(loc);
2558                   exit(1);
2559                 }
2560               putchar('.');
2561               continue;
2562             }
2563           cinfo = s->repo->appdata;
2564           if (!cinfo)
2565             {
2566               printf("%s: no repository information\n", s->repo->name);
2567               exit(1);
2568             }
2569           loc = solvable_get_location(s, &medianr);
2570           if (!loc)
2571              continue;
2572
2573           if (pool->installed && pool->installed->nsolvables)
2574             {
2575               /* try a delta first */
2576               char *matchname = strdup(id2str(pool, s->name));
2577               dataiterator_init(&di, pool, s->repo, SOLVID_META, DELTA_PACKAGE_NAME, matchname, SEARCH_STRING);
2578               dataiterator_prepend_keyname(&di, REPOSITORY_DELTAINFO);
2579               while (dataiterator_step(&di))
2580                 {
2581                   Id baseevr, op;
2582
2583                   dataiterator_setpos_parent(&di);
2584                   if (pool_lookup_id(pool, SOLVID_POS, DELTA_PACKAGE_EVR) != s->evr ||
2585                       pool_lookup_id(pool, SOLVID_POS, DELTA_PACKAGE_ARCH) != s->arch)
2586                     continue;
2587                   baseevr = pool_lookup_id(pool, SOLVID_POS, DELTA_BASE_EVR);
2588                   FOR_PROVIDES(op, pp, s->name)
2589                     {
2590                       Solvable *os = pool->solvables + op;
2591                       if (os->repo == pool->installed && os->name == s->name && os->arch == s->arch && os->evr == baseevr)
2592                         break;
2593                     }
2594                   if (op && access("/usr/bin/applydeltarpm", X_OK) == 0)
2595                     {
2596                       /* base is installed, run sequence check */
2597                       const char *seqname;
2598                       const char *seqevr;
2599                       const char *seqnum;
2600                       const char *seq;
2601                       const char *dloc;
2602                       FILE *fp;
2603                       char cmd[128];
2604                       int newfd;
2605
2606                       seqname = pool_lookup_str(pool, SOLVID_POS, DELTA_SEQ_NAME);
2607                       seqevr = pool_lookup_str(pool, SOLVID_POS, DELTA_SEQ_EVR);
2608                       seqnum = pool_lookup_str(pool, SOLVID_POS, DELTA_SEQ_NUM);
2609                       seq = pool_tmpjoin(pool, seqname, "-", seqevr);
2610                       seq = pool_tmpjoin(pool, seq, "-", seqnum);
2611 #ifdef FEDORA
2612                       sprintf(cmd, "/usr/bin/applydeltarpm -a %s -c -s ", id2str(pool, s->arch));
2613 #else
2614                       sprintf(cmd, "/usr/bin/applydeltarpm -c -s ");
2615 #endif
2616                       if (system(pool_tmpjoin(pool, cmd, seq, 0)) != 0)
2617                         continue;       /* didn't match */
2618                       /* looks good, download delta */
2619                       chksumtype = 0;
2620                       chksum = pool_lookup_bin_checksum(pool, SOLVID_POS, DELTA_CHECKSUM, &chksumtype);
2621                       if (!chksumtype)
2622                         continue;       /* no way! */
2623                       dloc = pool_lookup_str(pool, SOLVID_POS, DELTA_LOCATION_DIR);
2624                       dloc = pool_tmpjoin(pool, dloc, "/", pool_lookup_str(pool, SOLVID_POS, DELTA_LOCATION_NAME));
2625                       dloc = pool_tmpjoin(pool, dloc, "-", pool_lookup_str(pool, SOLVID_POS, DELTA_LOCATION_EVR));
2626                       dloc = pool_tmpjoin(pool, dloc, ".", pool_lookup_str(pool, SOLVID_POS, DELTA_LOCATION_SUFFIX));
2627                       if ((fp = curlfopen(cinfo, dloc, 0, chksum, chksumtype, 0)) == 0)
2628                         continue;
2629                       /* got it, now reconstruct */
2630                       newfd = opentmpfile();
2631 #ifdef FEDORA
2632                       sprintf(cmd, "applydeltarpm -a %s /dev/fd/%d /dev/fd/%d", id2str(pool, s->arch), fileno(fp), newfd);
2633 #else
2634                       sprintf(cmd, "applydeltarpm /dev/fd/%d /dev/fd/%d", fileno(fp), newfd);
2635 #endif
2636                       fcntl(fileno(fp), F_SETFD, 0);
2637                       if (system(cmd))
2638                         {
2639                           close(newfd);
2640                           fclose(fp);
2641                           continue;
2642                         }
2643                       lseek(newfd, 0, SEEK_SET);
2644                       chksumtype = 0;
2645                       chksum = solvable_lookup_bin_checksum(s, SOLVABLE_CHECKSUM, &chksumtype);
2646                       if (chksumtype && !verify_checksum(newfd, loc, chksum, chksumtype))
2647                         {
2648                           close(newfd);
2649                           fclose(fp);
2650                           continue;
2651                         }
2652                       newpkgsfps[i] = fdopen(newfd, "r");
2653                       fclose(fp);
2654                       break;
2655                     }
2656                 }
2657               dataiterator_free(&di);
2658               sat_free(matchname);
2659             }
2660
2661           if (newpkgsfps[i])
2662             {
2663               putchar('d');
2664               fflush(stdout);
2665               continue;         /* delta worked! */
2666             }
2667           if (cinfo->type == TYPE_SUSETAGS)
2668             {
2669               const char *datadir = repo_lookup_str(cinfo->repo, SOLVID_META, SUSETAGS_DATADIR);
2670               loc = pool_tmpjoin(pool, datadir ? datadir : "suse", "/", loc);
2671             }
2672           chksumtype = 0;
2673           chksum = solvable_lookup_bin_checksum(s, SOLVABLE_CHECKSUM, &chksumtype);
2674           if ((newpkgsfps[i] = curlfopen(cinfo, loc, 0, chksum, chksumtype, 0)) == 0)
2675             {
2676               printf("\n%s: %s not found in repository\n", s->repo->name, loc);
2677               exit(1);
2678             }
2679           putchar('.');
2680           fflush(stdout);
2681         }
2682       putchar('\n');
2683     }
2684
2685   if (newpkgs)
2686     {
2687       Queue conflicts;
2688
2689       printf("Searching for file conflicts\n");
2690       queue_init(&conflicts);
2691       fcstate.rpmdbstate = 0;
2692       fcstate.newpkgscnt = newpkgs;
2693       fcstate.checkq = &checkq;
2694       fcstate.newpkgsfps = newpkgsfps;
2695       pool_findfileconflicts(pool, &checkq, newpkgs, &conflicts, &fileconflict_cb, &fcstate);
2696       if (conflicts.count)
2697         {
2698           printf("\n");
2699           for (i = 0; i < conflicts.count; i += 5)
2700             printf("file %s of package %s conflicts with package %s\n", id2str(pool, conflicts.elements[i]), solvid2str(pool, conflicts.elements[i + 1]), solvid2str(pool, conflicts.elements[i + 3]));
2701           printf("\n");
2702           if (yesno("Re-run solver (y/n/q)? "))
2703             {
2704               for (i = 0; i < newpkgs; i++)
2705                 if (newpkgsfps[i])
2706                   fclose(newpkgsfps[i]);
2707               newpkgsfps = sat_free(newpkgsfps);
2708               solver_free(solv);
2709               pool_add_fileconflicts_deps(pool, &conflicts);
2710               pool_createwhatprovides(pool);    /* Hmm... */
2711               goto rerunsolver;
2712             }
2713         }
2714       queue_free(&conflicts);
2715     }
2716
2717   printf("Committing transaction:\n\n");
2718   transaction_order(trans, 0);
2719   for (i = 0; i < trans->steps.count; i++)
2720     {
2721       const char *evr, *evrp, *nvra;
2722       Solvable *s;
2723       int j;
2724       FILE *fp;
2725
2726       p = trans->steps.elements[i];
2727       s = pool_id2solvable(pool, p);
2728       Id type = transaction_type(trans, p, SOLVER_TRANSACTION_RPM_ONLY);
2729       switch(type)
2730         {
2731         case SOLVER_TRANSACTION_ERASE:
2732           printf("erase %s\n", solvid2str(pool, p));
2733           if (!s->repo->rpmdbid || !s->repo->rpmdbid[p - s->repo->start])
2734             continue;
2735           /* strip epoch from evr */
2736           evr = evrp = id2str(pool, s->evr);
2737           while (*evrp >= '0' && *evrp <= '9')
2738             evrp++;
2739           if (evrp > evr && evrp[0] == ':' && evrp[1])
2740             evr = evrp + 1;
2741           nvra = pool_tmpjoin(pool, id2str(pool, s->name), "-", evr);
2742           nvra = pool_tmpjoin(pool, nvra, ".", id2str(pool, s->arch));
2743           runrpm("-e", nvra, -1);       /* to bad that --querybynumber doesn't work */
2744           break;
2745         case SOLVER_TRANSACTION_INSTALL:
2746         case SOLVER_TRANSACTION_MULTIINSTALL:
2747           printf("install %s\n", solvid2str(pool, p));
2748           for (j = 0; j < newpkgs; j++)
2749             if (checkq.elements[j] == p)
2750               break;
2751           fp = j < newpkgs ? newpkgsfps[j] : 0;
2752           if (!fp)
2753             continue;
2754           rewind(fp);
2755           lseek(fileno(fp), 0, SEEK_SET);
2756           runrpm(type == SOLVER_TRANSACTION_MULTIINSTALL ? "-i" : "-U", "/dev/fd/3", fileno(fp));
2757           fclose(fp);
2758           newpkgsfps[j] = 0;
2759           break;
2760         default:
2761           break;
2762         }
2763     }
2764
2765   for (i = 0; i < newpkgs; i++)
2766     if (newpkgsfps[i])
2767       fclose(newpkgsfps[i]);
2768   sat_free(newpkgsfps);
2769   queue_free(&checkq);
2770   solver_free(solv);
2771   queue_free(&job);
2772   pool_free(pool);
2773   free_repoinfos(repoinfos, nrepoinfos);
2774   sat_free(commandlinepkgs);
2775   exit(0);
2776 }