examples/solv/solv.c

   1 /*
   2  * Copyright (c) 2009-2015, SUSE LLC.
   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 it does:
  11  * - understands globs for package names / dependencies
  12  * - understands .arch suffix
  13  * - installation of commandline packages
  14  * - repository data caching
  15  * - on demand loading of secondary repository data
  16  * - gpg and checksum verification
  17  * - file conflicts
  18  * - deltarpm support
  19  * - fastestmirror implementation
  20  *
  21  * things available in the library but missing from solv:
  22  * - vendor policy loading
  23  * - multi version handling
  24  */
  25
  26 #include <stdio.h>
  27 #include <stdlib.h>
  28 #include <unistd.h>
  29 #include <sys/utsname.h>
  30
  31 #include "pool.h"
  32 #include "poolarch.h"
  33 #include "evr.h"
  34 #include "selection.h"
  35 #include "repo.h"
  36 #include "solver.h"
  37 #include "solverdebug.h"
  38 #include "transaction.h"
  39 #include "testcase.h"
  40 #ifdef SUSE
  41 #include "repo_autopattern.h"
  42 #endif
  43
  44 #include "repoinfo.h"
  45 #include "repoinfo_cache.h"
  46 #include "repoinfo_download.h"
  47
  48 #if defined(ENABLE_RPMDB)
  49 #include "fileprovides.h"
  50 #include "fileconflicts.h"
  51 #include "deltarpm.h"
  52 #endif
  53 #if defined(SUSE) || defined(FEDORA) || defined(MAGEIA)
  54 #include "patchjobs.h"
  55 #endif
  56
  57 void
  58 setarch(Pool *pool)
  59 {
  60   struct utsname un;
  61   if (uname(&un))
  62     {
  63       perror("uname");
  64       exit(1);
  65     }
  66   pool_setarch(pool, un.machine);
  67 }
  68
  69
  70 int
  71 yesno(const char *str, int other)
  72 {
  73   char inbuf[128], *ip;
  74
  75   for (;;)
  76     {
  77       printf("%s", str);
  78       fflush(stdout);
  79       *inbuf = 0;
  80       if (!(ip = fgets(inbuf, sizeof(inbuf), stdin)))
  81         {
  82           printf("Abort.\n");
  83           exit(1);
  84         }
  85       while (*ip == ' ' || *ip == '\t')
  86         ip++;
  87       if (*ip == 'q')
  88         {
  89           printf("Abort.\n");
  90           exit(1);
  91         }
  92       if (*ip == 'y' || *ip == 'n' || *ip == other)
  93         return *ip == 'n' ? 0 : *ip;
  94     }
  95 }
  96
  97 #ifdef SUSE
  98 static Id
  99 nscallback(Pool *pool, void *data, Id name, Id evr)
 100 {
 101 #if 0
 102   if (name == NAMESPACE_LANGUAGE)
 103     {
 104       if (!strcmp(pool_id2str(pool, evr), "ja"))
 105         return 1;
 106       if (!strcmp(pool_id2str(pool, evr), "de"))
 107         return 1;
 108       if (!strcmp(pool_id2str(pool, evr), "en"))
 109         return 1;
 110       if (!strcmp(pool_id2str(pool, evr), "en_US"))
 111         return 1;
 112     }
 113 #endif
 114   return 0;
 115 }
 116 #endif
 117
 118 #ifdef SUSE
 119 static void
 120 showdiskusagechanges(Transaction *trans)
 121 {
 122   DUChanges duc[4];
 123   int i;
 124
 125   /* XXX: use mountpoints here */
 126   memset(duc, 0, sizeof(duc));
 127   duc[0].path = "/";
 128   duc[1].path = "/usr/share/man";
 129   duc[2].path = "/sbin";
 130   duc[3].path = "/etc";
 131   transaction_calc_duchanges(trans, duc, 4);
 132   for (i = 0; i < 4; i++)
 133     printf("duchanges %s: %d K  %d inodes\n", duc[i].path, duc[i].kbytes, duc[i].files);
 134 }
 135 #endif
 136
 137 static Id
 138 find_repo(const char *name, Pool *pool, struct repoinfo *repoinfos, int nrepoinfos)
 139 {
 140   const char *rp;
 141   int i;
 142
 143   for (rp = name; *rp; rp++)
 144     if (*rp <= '0' || *rp >= '9')
 145       break;
 146   if (!*rp)
 147     {
 148       /* repo specified by number */
 149       int rnum = atoi(name);
 150       for (i = 0; i < nrepoinfos; i++)
 151         {
 152           struct repoinfo *cinfo = repoinfos + i;
 153           if (!cinfo->enabled || !cinfo->repo)
 154             continue;
 155           if (--rnum == 0)
 156             return cinfo->repo->repoid;
 157         }
 158     }
 159   else
 160     {
 161       /* repo specified by alias */
 162       Repo *repo;
 163       FOR_REPOS(i, repo)
 164         {
 165           if (!strcasecmp(name, repo->name))
 166             return repo->repoid;
 167         }
 168     }
 169   return 0;
 170 }
 171
 172
 173 #define MODE_LIST        0
 174 #define MODE_INSTALL     1
 175 #define MODE_ERASE       2
 176 #define MODE_UPDATE      3
 177 #define MODE_DISTUPGRADE 4
 178 #define MODE_VERIFY      5
 179 #define MODE_PATCH       6
 180 #define MODE_INFO        7
 181 #define MODE_REPOLIST    8
 182 #define MODE_SEARCH      9
 183
 184 void
 185 usage(int r)
 186 {
 187   fprintf(stderr, "Usage: solv COMMAND <select>\n");
 188   fprintf(stderr, "\n");
 189   fprintf(stderr, "    dist-upgrade: replace installed packages with\n");
 190   fprintf(stderr, "                  versions from the repositories\n");
 191   fprintf(stderr, "    erase:        erase installed packages\n");
 192   fprintf(stderr, "    info:         display package information\n");
 193   fprintf(stderr, "    install:      install packages\n");
 194   fprintf(stderr, "    list:         list packages\n");
 195   fprintf(stderr, "    repos:        list enabled repositories\n");
 196   fprintf(stderr, "    search:       search name/summary/description\n");
 197   fprintf(stderr, "    update:       update installed packages\n");
 198   fprintf(stderr, "    verify:       check dependencies of installed packages\n");
 199 #if defined(SUSE) || defined(FEDORA) || defined(MAGEIA)
 200   fprintf(stderr, "    patch:        install newest maintenance updates\n");
 201 #endif
 202   fprintf(stderr, "\n");
 203   exit(r);
 204 }
 205
 206 int
 207 main(int argc, char **argv)
 208 {
 209   Pool *pool;
 210   Repo *commandlinerepo = 0;
 211   Id *commandlinepkgs = 0;
 212   Id p;
 213   struct repoinfo *repoinfos, installedrepoinfo;
 214   int nrepoinfos = 0;
 215   int mainmode = 0, mode = 0;
 216   int i, newpkgs;
 217   Queue job, checkq;
 218   Solver *solv = 0;
 219   Transaction *trans;
 220   FILE **newpkgsfps;
 221   Queue repofilter;
 222   Queue kindfilter;
 223   Queue archfilter;
 224   int archfilter_src = 0;
 225   int cleandeps = 0;
 226   int forcebest = 0;
 227   char *rootdir = 0;
 228   char *keyname = 0;
 229   int keyname_depstr = 0;
 230   int debuglevel = 0;
 231   int answer, acnt = 0;
 232   char *testcase = 0;
 233
 234   argc--;
 235   argv++;
 236   while (argc && !strcmp(argv[0], "-d"))
 237     {
 238       debuglevel++;
 239       argc--;
 240       argv++;
 241     }
 242   if (!argv[0])
 243     usage(1);
 244   if (!strcmp(argv[0], "install") || !strcmp(argv[0], "in"))
 245     {
 246       mainmode = MODE_INSTALL;
 247       mode = SOLVER_INSTALL;
 248     }
 249 #if defined(SUSE) || defined(FEDORA) || defined(MAGEIA)
 250   else if (!strcmp(argv[0], "patch"))
 251     {
 252       mainmode = MODE_PATCH;
 253       mode = SOLVER_INSTALL;
 254     }
 255 #endif
 256   else if (!strcmp(argv[0], "erase") || !strcmp(argv[0], "rm"))
 257     {
 258       mainmode = MODE_ERASE;
 259       mode = SOLVER_ERASE;
 260     }
 261   else if (!strcmp(argv[0], "list") || !strcmp(argv[0], "ls"))
 262     {
 263       mainmode = MODE_LIST;
 264       mode = 0;
 265     }
 266   else if (!strcmp(argv[0], "info"))
 267     {
 268       mainmode = MODE_INFO;
 269       mode = 0;
 270     }
 271   else if (!strcmp(argv[0], "search") || !strcmp(argv[0], "se"))
 272     {
 273       mainmode = MODE_SEARCH;
 274       mode = 0;
 275     }
 276   else if (!strcmp(argv[0], "verify"))
 277     {
 278       mainmode = MODE_VERIFY;
 279       mode = SOLVER_VERIFY;
 280     }
 281   else if (!strcmp(argv[0], "update") || !strcmp(argv[0], "up"))
 282     {
 283       mainmode = MODE_UPDATE;
 284       mode = SOLVER_UPDATE;
 285     }
 286   else if (!strcmp(argv[0], "dist-upgrade") || !strcmp(argv[0], "dup"))
 287     {
 288       mainmode = MODE_DISTUPGRADE;
 289       mode = SOLVER_DISTUPGRADE;
 290     }
 291   else if (!strcmp(argv[0], "repos") || !strcmp(argv[0], "repolist") || !strcmp(argv[0], "lr"))
 292     {
 293       mainmode = MODE_REPOLIST;
 294       mode = 0;
 295     }
 296   else
 297     usage(1);
 298
 299   for (;;)
 300     {
 301       if (argc > 2 && !strcmp(argv[1], "--root"))
 302         {
 303           rootdir = argv[2];
 304           argc -= 2;
 305           argv += 2;
 306         }
 307       else if (argc > 1 && !strcmp(argv[1], "--clean"))
 308         {
 309           cleandeps = 1;
 310           argc--;
 311           argv++;
 312         }
 313       else if (argc > 1 && !strcmp(argv[1], "--best"))
 314         {
 315           forcebest = 1;
 316           argc--;
 317           argv++;
 318         }
 319       else if (argc > 1 && !strcmp(argv[1], "--depstr"))
 320         {
 321           keyname_depstr = 1;
 322           argc--;
 323           argv++;
 324         }
 325       else if (argc > 2 && !strcmp(argv[1], "--keyname"))
 326         {
 327           keyname = argv[2];
 328           argc -= 2;
 329           argv += 2;
 330         }
 331       else if (argc > 2 && !strcmp(argv[1], "--testcase"))
 332         {
 333           testcase = argv[2];
 334           argc -= 2;
 335           argv += 2;
 336         }
 337       else
 338         break;
 339     }
 340
 341   set_userhome();
 342   pool = pool_create();
 343   pool_set_rootdir(pool, rootdir);
 344
 345 #if 0
 346   {
 347     const char *langs[] = {"de_DE", "de", "en"};
 348     pool_set_languages(pool, langs, sizeof(langs)/sizeof(*langs));
 349   }
 350 #endif
 351
 352   pool_setloadcallback(pool, load_stub, 0);
 353 #ifdef SUSE
 354   pool->nscallback = nscallback;
 355 #endif
 356   if (debuglevel)
 357     pool_setdebuglevel(pool, debuglevel);
 358   setarch(pool);
 359   pool_set_flag(pool, POOL_FLAG_ADDFILEPROVIDESFILTERED, 1);
 360   repoinfos = read_repoinfos(pool, &nrepoinfos);
 361   sort_repoinfos(repoinfos, nrepoinfos);
 362
 363   if (mainmode == MODE_REPOLIST)
 364     {
 365       int j = 1;
 366       for (i = 0; i < nrepoinfos; i++)
 367         {
 368           struct repoinfo *cinfo = repoinfos + i;
 369           if (!cinfo->enabled)
 370             continue;
 371           printf("%d: %-20s %s (prio %d)\n", j++, cinfo->alias, cinfo->name, cinfo->priority);
 372         }
 373       exit(0);
 374     }
 375   memset(&installedrepoinfo, 0, sizeof(installedrepoinfo));
 376   if (!read_installed_repo(&installedrepoinfo, pool))
 377     exit(1);
 378   read_repos(pool, repoinfos, nrepoinfos);
 379
 380   /* setup filters */
 381   queue_init(&repofilter);
 382   queue_init(&kindfilter);
 383   queue_init(&archfilter);
 384   while (argc > 1)
 385     {
 386       if (!strcmp(argv[1], "-i"))
 387         {
 388           queue_push2(&repofilter, SOLVER_SOLVABLE_REPO | SOLVER_SETREPO, pool->installed->repoid);
 389           argc--;
 390           argv++;
 391         }
 392       else if (argc > 2 && (!strcmp(argv[1], "-r") || !strcmp(argv[1], "--repo")))
 393         {
 394           Id repoid = find_repo(argv[2], pool, repoinfos, nrepoinfos);
 395           if (!repoid)
 396             {
 397               fprintf(stderr, "%s: no such repo\n", argv[2]);
 398               exit(1);
 399             }
 400           /* SETVENDOR is actually wrong but useful */
 401           queue_push2(&repofilter, SOLVER_SOLVABLE_REPO | SOLVER_SETREPO | SOLVER_SETVENDOR, repoid);
 402           argc -= 2;
 403           argv += 2;
 404         }
 405       else if (argc > 2 && !strcmp(argv[1], "--arch"))
 406         {
 407           if (!strcmp(argv[2], "src") || !strcmp(argv[2], "nosrc"))
 408             archfilter_src = 1;
 409           queue_push2(&archfilter, SOLVER_SOLVABLE_PROVIDES, pool_rel2id(pool, 0, pool_str2id(pool, argv[2], 1), REL_ARCH, 1));
 410           argc -= 2;
 411           argv += 2;
 412         }
 413       else if (argc > 2 && (!strcmp(argv[1], "-t") || !strcmp(argv[1], "--type")))
 414         {
 415           const char *kind = argv[2];
 416           if (!strcmp(kind, "srcpackage"))
 417             {
 418               /* hey! should use --arch! */
 419               queue_push2(&archfilter, SOLVER_SOLVABLE_PROVIDES, pool_rel2id(pool, 0, ARCH_SRC, REL_ARCH, 1));
 420               archfilter_src = 1;
 421               argc -= 2;
 422               argv += 2;
 423               continue;
 424             }
 425           if (!strcmp(kind, "package"))
 426             kind = "";
 427           if (!strcmp(kind, "all"))
 428             queue_push2(&kindfilter, SOLVER_SOLVABLE_ALL, 0);
 429           else
 430             queue_push2(&kindfilter, SOLVER_SOLVABLE_PROVIDES, pool_rel2id(pool, 0, pool_str2id(pool, kind, 1), REL_KIND, 1));
 431           argc -= 2;
 432           argv += 2;
 433         }
 434       else
 435         break;
 436     }
 437
 438   if (mainmode == MODE_SEARCH)
 439     {
 440       Queue sel, q;
 441       Dataiterator di;
 442       if (argc != 2)
 443         usage(1);
 444       pool_createwhatprovides(pool);
 445       queue_init(&sel);
 446       dataiterator_init(&di, pool, 0, 0, 0, argv[1], SEARCH_SUBSTRING|SEARCH_NOCASE);
 447       dataiterator_set_keyname(&di, SOLVABLE_NAME);
 448       dataiterator_set_search(&di, 0, 0);
 449       while (dataiterator_step(&di))
 450         queue_push2(&sel, SOLVER_SOLVABLE, di.solvid);
 451       dataiterator_set_keyname(&di, SOLVABLE_SUMMARY);
 452       dataiterator_set_search(&di, 0, 0);
 453       while (dataiterator_step(&di))
 454         queue_push2(&sel, SOLVER_SOLVABLE, di.solvid);
 455       dataiterator_set_keyname(&di, SOLVABLE_DESCRIPTION);
 456       dataiterator_set_search(&di, 0, 0);
 457       while (dataiterator_step(&di))
 458         queue_push2(&sel, SOLVER_SOLVABLE, di.solvid);
 459       dataiterator_free(&di);
 460       if (repofilter.count)
 461         selection_filter(pool, &sel, &repofilter);
 462       if (archfilter.count)
 463         selection_filter(pool, &sel, &archfilter);
 464       if (kindfilter.count)
 465         selection_filter(pool, &sel, &kindfilter);
 466
 467       queue_init(&q);
 468       selection_solvables(pool, &sel, &q);
 469       queue_free(&sel);
 470       for (i = 0; i < q.count; i++)
 471         {
 472           Solvable *s = pool_id2solvable(pool, q.elements[i]);
 473           printf("  - %s [%s]: %s\n", pool_solvable2str(pool, s), s->repo->name, solvable_lookup_str(s, SOLVABLE_SUMMARY));
 474         }
 475       queue_free(&q);
 476       exit(0);
 477     }
 478
 479   /* process command line packages */
 480   if (mainmode == MODE_LIST || mainmode == MODE_INFO || mainmode == MODE_INSTALL)
 481     {
 482       for (i = 1; i < argc; i++)
 483         {
 484           if (!is_cmdline_package((const char *)argv[i]))
 485             continue;
 486           if (access(argv[i], R_OK))
 487             {
 488               perror(argv[i]);
 489               exit(1);
 490             }
 491           if (!commandlinepkgs)
 492             commandlinepkgs = solv_calloc(argc, sizeof(Id));
 493           if (!commandlinerepo)
 494             commandlinerepo = repo_create(pool, "@commandline");
 495           p = add_cmdline_package(commandlinerepo, (const char *)argv[i]);
 496           if (!p)
 497             {
 498               fprintf(stderr, "could not add '%s'\n", argv[i]);
 499               exit(1);
 500             }
 501           commandlinepkgs[i] = p;
 502         }
 503       if (commandlinerepo)
 504         {
 505           repo_internalize(commandlinerepo);
 506 #ifdef SUSE
 507           repo_add_autopattern(commandlinerepo, 0);
 508 #endif
 509         }
 510     }
 511
 512 #if defined(ENABLE_RPMDB)
 513   if (pool->disttype == DISTTYPE_RPM)
 514     addfileprovides(pool);
 515 #endif
 516   pool_createwhatprovides(pool);
 517
 518   if (keyname)
 519     keyname = solv_dupjoin("solvable:", keyname, 0);
 520   queue_init(&job);
 521   for (i = 1; i < argc; i++)
 522     {
 523       Queue job2;
 524       int flags, rflags;
 525
 526       if (commandlinepkgs && commandlinepkgs[i])
 527         {
 528           queue_push2(&job, SOLVER_SOLVABLE, commandlinepkgs[i]);
 529           continue;
 530         }
 531       queue_init(&job2);
 532       flags = SELECTION_NAME|SELECTION_PROVIDES|SELECTION_GLOB;
 533       flags |= SELECTION_CANON|SELECTION_DOTARCH|SELECTION_REL;
 534       if (kindfilter.count)
 535         flags |= SELECTION_SKIP_KIND;
 536       if (mode == MODE_LIST || archfilter_src)
 537         flags |= SELECTION_WITH_SOURCE;
 538       if (argv[i][0] == '/')
 539         flags |= SELECTION_FILELIST | (mode == MODE_ERASE ? SELECTION_INSTALLED_ONLY : 0);
 540       if (keyname && keyname_depstr)
 541         flags |= SELECTION_MATCH_DEPSTR;
 542       if (!keyname)
 543         rflags = selection_make(pool, &job2, argv[i], flags);
 544       else
 545         rflags = selection_make_matchdeps(pool, &job2, argv[i], flags, pool_str2id(pool, keyname, 1), 0);
 546       if (repofilter.count)
 547         selection_filter(pool, &job2, &repofilter);
 548       if (archfilter.count)
 549         selection_filter(pool, &job2, &archfilter);
 550       if (kindfilter.count)
 551         selection_filter(pool, &job2, &kindfilter);
 552       if (!job2.count)
 553         {
 554           flags |= SELECTION_NOCASE;
 555           if (!keyname)
 556             rflags = selection_make(pool, &job2, argv[i], flags);
 557           else
 558             rflags = selection_make_matchdeps(pool, &job2, argv[i], flags, pool_str2id(pool, keyname, 1), 0);
 559           if (repofilter.count)
 560             selection_filter(pool, &job2, &repofilter);
 561           if (archfilter.count)
 562             selection_filter(pool, &job2, &archfilter);
 563           if (kindfilter.count)
 564             selection_filter(pool, &job2, &kindfilter);
 565           if (job2.count)
 566             printf("[ignoring case for '%s']\n", argv[i]);
 567         }
 568       if (!job2.count)
 569         {
 570           fprintf(stderr, "nothing matches '%s'\n", argv[i]);
 571           exit(1);
 572         }
 573       if (rflags & SELECTION_FILELIST)
 574         printf("[using file list match for '%s']\n", argv[i]);
 575       if (rflags & SELECTION_PROVIDES)
 576         printf("[using capability match for '%s']\n", argv[i]);
 577       queue_insertn(&job, job.count, job2.count, job2.elements);
 578       queue_free(&job2);
 579     }
 580   keyname = solv_free(keyname);
 581
 582   if (!job.count && (mainmode == MODE_UPDATE || mainmode == MODE_DISTUPGRADE || mainmode == MODE_VERIFY || repofilter.count || archfilter.count || kindfilter.count))
 583     {
 584       queue_push2(&job, SOLVER_SOLVABLE_ALL, 0);
 585       if (repofilter.count)
 586         selection_filter(pool, &job, &repofilter);
 587       if (archfilter.count)
 588         selection_filter(pool, &job, &archfilter);
 589       if (kindfilter.count)
 590         selection_filter(pool, &job, &kindfilter);
 591     }
 592   queue_free(&repofilter);
 593   queue_free(&archfilter);
 594   queue_free(&kindfilter);
 595
 596   if (!job.count && mainmode != MODE_PATCH)
 597     {
 598       printf("no package matched\n");
 599       exit(1);
 600     }
 601
 602   if (mainmode == MODE_LIST || mainmode == MODE_INFO)
 603     {
 604       /* list mode, no solver needed */
 605       Queue q;
 606       queue_init(&q);
 607       for (i = 0; i < job.count; i += 2)
 608         {
 609           int j;
 610           queue_empty(&q);
 611           pool_job2solvables(pool, &q, job.elements[i], job.elements[i + 1]);
 612           for (j = 0; j < q.count; j++)
 613             {
 614               Solvable *s = pool_id2solvable(pool, q.elements[j]);
 615               if (mainmode == MODE_INFO)
 616                 {
 617                   const char *str;
 618                   printf("Name:        %s\n", pool_solvable2str(pool, s));
 619                   printf("Repo:        %s\n", s->repo->name);
 620                   printf("Summary:     %s\n", solvable_lookup_str(s, SOLVABLE_SUMMARY));
 621                   str = solvable_lookup_str(s, SOLVABLE_URL);
 622                   if (str)
 623                     printf("Url:         %s\n", str);
 624                   str = solvable_lookup_str(s, SOLVABLE_LICENSE);
 625                   if (str)
 626                     printf("License:     %s\n", str);
 627                   printf("Description:\n%s\n", solvable_lookup_str(s, SOLVABLE_DESCRIPTION));
 628                   printf("\n");
 629                 }
 630               else
 631                 {
 632 #if 1
 633                   const char *sum = solvable_lookup_str_lang(s, SOLVABLE_SUMMARY, "de", 1);
 634 #else
 635                   const char *sum = solvable_lookup_str_poollang(s, SOLVABLE_SUMMARY);
 636 #endif
 637                   printf("  - %s [%s]\n", pool_solvable2str(pool, s), s->repo->name);
 638                   if (sum)
 639                     printf("    %s\n", sum);
 640                 }
 641             }
 642         }
 643       queue_free(&q);
 644       queue_free(&job);
 645       pool_free(pool);
 646       free_repoinfos(repoinfos, nrepoinfos);
 647       solv_free(commandlinepkgs);
 648       exit(0);
 649     }
 650
 651 #if defined(SUSE) || defined(FEDORA) || defined(MAGEIA)
 652   if (mainmode == MODE_PATCH)
 653     add_patchjobs(pool, &job);
 654 #endif
 655
 656   // add mode
 657   for (i = 0; i < job.count; i += 2)
 658     {
 659       job.elements[i] |= mode;
 660       if (mode == SOLVER_UPDATE && pool_isemptyupdatejob(pool, job.elements[i], job.elements[i + 1]))
 661         job.elements[i] ^= SOLVER_UPDATE ^ SOLVER_INSTALL;
 662       if (cleandeps)
 663         job.elements[i] |= SOLVER_CLEANDEPS;
 664       if (forcebest)
 665         job.elements[i] |= SOLVER_FORCEBEST;
 666     }
 667
 668 #if 0
 669   // multiversion test
 670   queue_push2(&job, SOLVER_MULTIVERSION|SOLVER_SOLVABLE_PROVIDES, pool_str2id(pool, "multiversion(kernel)", 1));
 671 #endif
 672 #if 0
 673   queue_push2(&job, SOLVER_INSTALL|SOLVER_SOLVABLE_PROVIDES, pool_rel2id(pool, NAMESPACE_LANGUAGE, 0, REL_NAMESPACE, 1));
 674   queue_push2(&job, SOLVER_ERASE|SOLVER_CLEANDEPS|SOLVER_SOLVABLE_PROVIDES, pool_rel2id(pool, NAMESPACE_LANGUAGE, 0, REL_NAMESPACE, 1));
 675 #endif
 676
 677 rerunsolver:
 678   solv = solver_create(pool);
 679   solver_set_flag(solv, SOLVER_FLAG_SPLITPROVIDES, 1);
 680 #if 0
 681   solver_set_flag(solv, SOLVER_FLAG_IGNORE_RECOMMENDED, 1);
 682 #endif
 683 #if defined(FEDORA) || defined(MAGEIA)
 684   solver_set_flag(solv, SOLVER_FLAG_ALLOW_VENDORCHANGE, 1);
 685 #endif
 686   if (mainmode == MODE_ERASE)
 687     solver_set_flag(solv, SOLVER_FLAG_ALLOW_UNINSTALL, 1);      /* don't nag */
 688   solver_set_flag(solv, SOLVER_FLAG_BEST_OBEY_POLICY, 1);
 689
 690   for (;;)
 691     {
 692       Id problem, solution;
 693       int pcnt, scnt;
 694
 695       pcnt = solver_solve(solv, &job);
 696       if (testcase)
 697         {
 698           printf("Writing solver testcase:\n");
 699           if (!testcase_write(solv, testcase, TESTCASE_RESULT_TRANSACTION | TESTCASE_RESULT_PROBLEMS, 0, 0))
 700             printf("%s\n", pool_errstr(pool));
 701           testcase = 0;
 702         }
 703       if (!pcnt)
 704         break;
 705       pcnt = solver_problem_count(solv);
 706       printf("Found %d problems:\n", pcnt);
 707       for (problem = 1; problem <= pcnt; problem++)
 708         {
 709           int take = 0;
 710           printf("Problem %d/%d:\n", problem, pcnt);
 711           solver_printprobleminfo(solv, problem);
 712           printf("\n");
 713           scnt = solver_solution_count(solv, problem);
 714           for (solution = 1; solution <= scnt; solution++)
 715             {
 716               printf("Solution %d:\n", solution);
 717               solver_printsolution(solv, problem, solution);
 718               printf("\n");
 719             }
 720           for (;;)
 721             {
 722               char inbuf[128], *ip;
 723               printf("Please choose a solution: ");
 724               fflush(stdout);
 725               *inbuf = 0;
 726               if (!(ip = fgets(inbuf, sizeof(inbuf), stdin)))
 727                 {
 728                   printf("Abort.\n");
 729                   exit(1);
 730                 }
 731               while (*ip == ' ' || *ip == '\t')
 732                 ip++;
 733               if (*ip >= '0' && *ip <= '9')
 734                 {
 735                   take = atoi(ip);
 736                   if (take >= 1 && take <= scnt)
 737                     break;
 738                 }
 739               if (*ip == 's')
 740                 {
 741                   take = 0;
 742                   break;
 743                 }
 744               if (*ip == 'q')
 745                 {
 746                   printf("Abort.\n");
 747                   exit(1);
 748                 }
 749             }
 750           if (!take)
 751             continue;
 752           solver_take_solution(solv, problem, take, &job);
 753         }
 754     }
 755
 756   trans = solver_create_transaction(solv);
 757   if (!trans->steps.count)
 758     {
 759       printf("Nothing to do.\n");
 760       transaction_free(trans);
 761       solver_free(solv);
 762       queue_free(&job);
 763       pool_free(pool);
 764       free_repoinfos(repoinfos, nrepoinfos);
 765       solv_free(commandlinepkgs);
 766       exit(1);
 767     }
 768
 769   /* display transaction to the user and ask for confirmation */
 770   printf("\n");
 771   printf("Transaction summary:\n\n");
 772   transaction_print(trans);
 773 #if defined(SUSE)
 774   showdiskusagechanges(trans);
 775 #endif
 776   printf("install size change: %d K\n", transaction_calc_installsizechange(trans));
 777   printf("\n");
 778
 779   acnt = solver_alternatives_count(solv);
 780   if (acnt)
 781     {
 782       if (acnt == 1)
 783         printf("Have one alternative:\n");
 784       else
 785         printf("Have %d alternatives:\n", acnt);
 786       for (i = 1; i <= acnt; i++)
 787         {
 788           Id id, from;
 789           int atype = solver_get_alternative(solv, i, &id, &from, 0, 0, 0);
 790           printf("  - %s\n", solver_alternative2str(solv, atype, id, from));
 791         }
 792       printf("\n");
 793       answer = yesno("OK to continue (y/n/a)? ", 'a');
 794     }
 795   else
 796     answer = yesno("OK to continue (y/n)? ", 0);
 797   if (answer == 'a')
 798     {
 799       Queue choicesq;
 800       Queue answerq;
 801       Id id, from, chosen;
 802       int j;
 803
 804       queue_init(&choicesq);
 805       queue_init(&answerq);
 806       for (i = 1; i <= acnt; i++)
 807         {
 808           int atype = solver_get_alternative(solv, i, &id, &from, &chosen, &choicesq, 0);
 809           printf("\n%s\n", solver_alternative2str(solv, atype, id, from));
 810           for (j = 0; j < choicesq.count; j++)
 811             {
 812               Id p = choicesq.elements[j];
 813               if (p < 0)
 814                 p = -p;
 815               queue_push(&answerq, p);
 816               printf("%6d: %s\n", answerq.count, pool_solvid2str(pool, p));
 817             }
 818         }
 819       queue_free(&choicesq);
 820       printf("\n");
 821       for (;;)
 822         {
 823           char inbuf[128], *ip;
 824           int neg = 0;
 825           printf("OK to continue (y/n), or number to change alternative: ");
 826           fflush(stdout);
 827           *inbuf = 0;
 828           if (!(ip = fgets(inbuf, sizeof(inbuf), stdin)))
 829             {
 830               printf("Abort.\n");
 831               exit(1);
 832             }
 833           while (*ip == ' ' || *ip == '\t')
 834             ip++;
 835           if (*ip == '-' && ip[1] >= '0' && ip[1] <= '9')
 836             {
 837               neg = 1;
 838               ip++;
 839             }
 840           if (*ip >= '0' && *ip <= '9')
 841             {
 842               int take = atoi(ip);
 843               if (take > 0 && take <= answerq.count)
 844                 {
 845                   Id p = answerq.elements[take - 1];
 846                   queue_free(&answerq);
 847                   queue_push2(&job, (neg ? SOLVER_DISFAVOR : SOLVER_FAVOR) | SOLVER_SOLVABLE_NAME, pool->solvables[p].name);
 848                   solver_free(solv);
 849                   solv = 0;
 850                   goto rerunsolver;
 851                   break;
 852                 }
 853             }
 854           if (*ip == 'n' || *ip == 'y')
 855             {
 856               answer = *ip == 'n' ? 0 : *ip;
 857               break;
 858             }
 859         }
 860       queue_free(&answerq);
 861     }
 862   if (!answer)
 863     {
 864       printf("Abort.\n");
 865       transaction_free(trans);
 866       solver_free(solv);
 867       queue_free(&job);
 868       pool_free(pool);
 869       free_repoinfos(repoinfos, nrepoinfos);
 870       solv_free(commandlinepkgs);
 871       exit(1);
 872     }
 873
 874   /* download all new packages */
 875   queue_init(&checkq);
 876   newpkgs = transaction_installedresult(trans, &checkq);
 877   newpkgsfps = 0;
 878   if (newpkgs)
 879     {
 880       int downloadsize = 0;
 881       for (i = 0; i < newpkgs; i++)
 882         {
 883           Solvable *s;
 884
 885           p = checkq.elements[i];
 886           s = pool_id2solvable(pool, p);
 887           downloadsize += solvable_lookup_sizek(s, SOLVABLE_DOWNLOADSIZE, 0);
 888         }
 889       printf("Downloading %d packages, %d K\n", newpkgs, downloadsize);
 890       newpkgsfps = solv_calloc(newpkgs, sizeof(*newpkgsfps));
 891       for (i = 0; i < newpkgs; i++)
 892         {
 893           const char *loc;
 894           Solvable *s;
 895           struct repoinfo *cinfo;
 896
 897           p = checkq.elements[i];
 898           s = pool_id2solvable(pool, p);
 899           if (s->repo == commandlinerepo)
 900             {
 901               loc = solvable_lookup_location(s, 0);
 902               if (!loc)
 903                 continue;
 904               if (!(newpkgsfps[i] = fopen(loc, "r")))
 905                 {
 906                   perror(loc);
 907                   exit(1);
 908                 }
 909               putchar('.');
 910               continue;
 911             }
 912           cinfo = s->repo->appdata;
 913           if (!cinfo || cinfo->type == TYPE_INSTALLED)
 914             {
 915               printf("%s: no repository information\n", s->repo->name);
 916               exit(1);
 917             }
 918           loc = solvable_lookup_location(s, 0);
 919           if (!loc)
 920              continue;  /* pseudo package? */
 921 #if defined(ENABLE_RPMDB)
 922           if (pool->installed && pool->installed->nsolvables)
 923             {
 924               if ((newpkgsfps[i] = trydeltadownload(s, loc)) != 0)
 925                 {
 926                   putchar('d');
 927                   fflush(stdout);
 928                   continue;             /* delta worked! */
 929                 }
 930             }
 931 #endif
 932           if ((newpkgsfps[i] = downloadpackage(s, loc)) == 0)
 933             {
 934               printf("\n%s: %s not found in repository\n", s->repo->name, loc);
 935               exit(1);
 936             }
 937           putchar('.');
 938           fflush(stdout);
 939         }
 940       putchar('\n');
 941     }
 942
 943 #if defined(ENABLE_RPMDB) && (defined(SUSE) || defined(FEDORA) || defined(MANDRIVA) || defined(MAGEIA))
 944   /* check for file conflicts */
 945   if (newpkgs)
 946     {
 947       Queue conflicts;
 948       queue_init(&conflicts);
 949       if (checkfileconflicts(pool, &checkq, newpkgs, newpkgsfps, &conflicts))
 950         {
 951           if (yesno("Re-run solver (y/n/q)? ", 0))
 952             {
 953               for (i = 0; i < newpkgs; i++)
 954                 if (newpkgsfps[i])
 955                   fclose(newpkgsfps[i]);
 956               newpkgsfps = solv_free(newpkgsfps);
 957               solver_free(solv);
 958               solv = 0;
 959               pool_add_fileconflicts_deps(pool, &conflicts);
 960               queue_free(&conflicts);
 961               goto rerunsolver;
 962             }
 963         }
 964       queue_free(&conflicts);
 965     }
 966 #endif
 967
 968   /* and finally commit the transaction */
 969   printf("Committing transaction:\n\n");
 970   transaction_order(trans, 0);
 971   for (i = 0; i < trans->steps.count; i++)
 972     {
 973       int j;
 974       FILE *fp;
 975       Id type;
 976
 977       p = trans->steps.elements[i];
 978       type = transaction_type(trans, p, SOLVER_TRANSACTION_RPM_ONLY);
 979       switch(type)
 980         {
 981         case SOLVER_TRANSACTION_ERASE:
 982           printf("erase %s\n", pool_solvid2str(pool, p));
 983           commit_transactionelement(pool, type, p, 0);
 984           break;
 985         case SOLVER_TRANSACTION_INSTALL:
 986         case SOLVER_TRANSACTION_MULTIINSTALL:
 987           printf("install %s\n", pool_solvid2str(pool, p));
 988           for (j = 0; j < newpkgs; j++)
 989             if (checkq.elements[j] == p)
 990               break;
 991           fp = j < newpkgs ? newpkgsfps[j] : 0;
 992           if (!fp)
 993             continue;
 994           commit_transactionelement(pool, type, p, fp);
 995           fclose(fp);
 996           newpkgsfps[j] = 0;
 997           break;
 998         default:
 999           break;
1000         }
1001     }
1002
1003   for (i = 0; i < newpkgs; i++)
1004     if (newpkgsfps[i])
1005       fclose(newpkgsfps[i]);
1006   solv_free(newpkgsfps);
1007   queue_free(&checkq);
1008   transaction_free(trans);
1009   solver_free(solv);
1010   queue_free(&job);
1011   pool_free(pool);
1012   free_repoinfos(repoinfos, nrepoinfos);
1013   solv_free(commandlinepkgs);
1014   exit(0);
1015 }