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
 463       queue_init(&q);
 464       selection_solvables(pool, &sel, &q);
 465       queue_free(&sel);
 466       for (i = 0; i < q.count; i++)
 467         {
 468           Solvable *s = pool_id2solvable(pool, q.elements[i]);
 469           printf("  - %s [%s]: %s\n", pool_solvable2str(pool, s), s->repo->name, solvable_lookup_str(s, SOLVABLE_SUMMARY));
 470         }
 471       queue_free(&q);
 472       exit(0);
 473     }
 474
 475   /* process command line packages */
 476   if (mainmode == MODE_LIST || mainmode == MODE_INFO || mainmode == MODE_INSTALL)
 477     {
 478       for (i = 1; i < argc; i++)
 479         {
 480           if (!is_cmdline_package((const char *)argv[i]))
 481             continue;
 482           if (access(argv[i], R_OK))
 483             {
 484               perror(argv[i]);
 485               exit(1);
 486             }
 487           if (!commandlinepkgs)
 488             commandlinepkgs = solv_calloc(argc, sizeof(Id));
 489           if (!commandlinerepo)
 490             commandlinerepo = repo_create(pool, "@commandline");
 491           p = add_cmdline_package(commandlinerepo, (const char *)argv[i]);
 492           if (!p)
 493             {
 494               fprintf(stderr, "could not add '%s'\n", argv[i]);
 495               exit(1);
 496             }
 497           commandlinepkgs[i] = p;
 498         }
 499       if (commandlinerepo)
 500         {
 501           repo_internalize(commandlinerepo);
 502 #ifdef SUSE
 503           repo_add_autopattern(commandlinerepo, 0);
 504 #endif
 505         }
 506     }
 507
 508 #if defined(ENABLE_RPMDB)
 509   if (pool->disttype == DISTTYPE_RPM)
 510     addfileprovides(pool);
 511 #endif
 512   pool_createwhatprovides(pool);
 513
 514   if (keyname)
 515     keyname = solv_dupjoin("solvable:", keyname, 0);
 516   queue_init(&job);
 517   for (i = 1; i < argc; i++)
 518     {
 519       Queue job2;
 520       int flags, rflags;
 521
 522       if (commandlinepkgs && commandlinepkgs[i])
 523         {
 524           queue_push2(&job, SOLVER_SOLVABLE, commandlinepkgs[i]);
 525           continue;
 526         }
 527       queue_init(&job2);
 528       flags = SELECTION_NAME|SELECTION_PROVIDES|SELECTION_GLOB;
 529       flags |= SELECTION_CANON|SELECTION_DOTARCH|SELECTION_REL;
 530       if (kindfilter.count)
 531         flags |= SELECTION_SKIP_KIND;
 532       if (mode == MODE_LIST || archfilter_src)
 533         flags |= SELECTION_WITH_SOURCE;
 534       if (argv[i][0] == '/')
 535         flags |= SELECTION_FILELIST | (mode == MODE_ERASE ? SELECTION_INSTALLED_ONLY : 0);
 536       if (keyname && keyname_depstr)
 537         flags |= SELECTION_MATCH_DEPSTR;
 538       if (!keyname)
 539         rflags = selection_make(pool, &job2, argv[i], flags);
 540       else
 541         rflags = selection_make_matchdeps(pool, &job2, argv[i], flags, pool_str2id(pool, keyname, 1), 0);
 542       if (repofilter.count)
 543         selection_filter(pool, &job2, &repofilter);
 544       if (archfilter.count)
 545         selection_filter(pool, &job2, &archfilter);
 546       if (kindfilter.count)
 547         selection_filter(pool, &job2, &kindfilter);
 548       if (!job2.count)
 549         {
 550           flags |= SELECTION_NOCASE;
 551           if (!keyname)
 552             rflags = selection_make(pool, &job2, argv[i], flags);
 553           else
 554             rflags = selection_make_matchdeps(pool, &job2, argv[i], flags, pool_str2id(pool, keyname, 1), 0);
 555           if (repofilter.count)
 556             selection_filter(pool, &job2, &repofilter);
 557           if (archfilter.count)
 558             selection_filter(pool, &job2, &archfilter);
 559           if (kindfilter.count)
 560             selection_filter(pool, &job2, &kindfilter);
 561           if (job2.count)
 562             printf("[ignoring case for '%s']\n", argv[i]);
 563         }
 564       if (!job2.count)
 565         {
 566           fprintf(stderr, "nothing matches '%s'\n", argv[i]);
 567           exit(1);
 568         }
 569       if (rflags & SELECTION_FILELIST)
 570         printf("[using file list match for '%s']\n", argv[i]);
 571       if (rflags & SELECTION_PROVIDES)
 572         printf("[using capability match for '%s']\n", argv[i]);
 573       queue_insertn(&job, job.count, job2.count, job2.elements);
 574       queue_free(&job2);
 575     }
 576   keyname = solv_free(keyname);
 577
 578   if (!job.count && (mainmode == MODE_UPDATE || mainmode == MODE_DISTUPGRADE || mainmode == MODE_VERIFY || repofilter.count || archfilter.count || kindfilter.count))
 579     {
 580       queue_push2(&job, SOLVER_SOLVABLE_ALL, 0);
 581       if (repofilter.count)
 582         selection_filter(pool, &job, &repofilter);
 583       if (archfilter.count)
 584         selection_filter(pool, &job, &archfilter);
 585       if (kindfilter.count)
 586         selection_filter(pool, &job, &kindfilter);
 587     }
 588   queue_free(&repofilter);
 589   queue_free(&archfilter);
 590   queue_free(&kindfilter);
 591
 592   if (!job.count && mainmode != MODE_PATCH)
 593     {
 594       printf("no package matched\n");
 595       exit(1);
 596     }
 597
 598   if (mainmode == MODE_LIST || mainmode == MODE_INFO)
 599     {
 600       /* list mode, no solver needed */
 601       Queue q;
 602       queue_init(&q);
 603       for (i = 0; i < job.count; i += 2)
 604         {
 605           int j;
 606           queue_empty(&q);
 607           pool_job2solvables(pool, &q, job.elements[i], job.elements[i + 1]);
 608           for (j = 0; j < q.count; j++)
 609             {
 610               Solvable *s = pool_id2solvable(pool, q.elements[j]);
 611               if (mainmode == MODE_INFO)
 612                 {
 613                   const char *str;
 614                   printf("Name:        %s\n", pool_solvable2str(pool, s));
 615                   printf("Repo:        %s\n", s->repo->name);
 616                   printf("Summary:     %s\n", solvable_lookup_str(s, SOLVABLE_SUMMARY));
 617                   str = solvable_lookup_str(s, SOLVABLE_URL);
 618                   if (str)
 619                     printf("Url:         %s\n", str);
 620                   str = solvable_lookup_str(s, SOLVABLE_LICENSE);
 621                   if (str)
 622                     printf("License:     %s\n", str);
 623                   printf("Description:\n%s\n", solvable_lookup_str(s, SOLVABLE_DESCRIPTION));
 624                   printf("\n");
 625                 }
 626               else
 627                 {
 628 #if 1
 629                   const char *sum = solvable_lookup_str_lang(s, SOLVABLE_SUMMARY, "de", 1);
 630 #else
 631                   const char *sum = solvable_lookup_str_poollang(s, SOLVABLE_SUMMARY);
 632 #endif
 633                   printf("  - %s [%s]\n", pool_solvable2str(pool, s), s->repo->name);
 634                   if (sum)
 635                     printf("    %s\n", sum);
 636                 }
 637             }
 638         }
 639       queue_free(&q);
 640       queue_free(&job);
 641       pool_free(pool);
 642       free_repoinfos(repoinfos, nrepoinfos);
 643       solv_free(commandlinepkgs);
 644       exit(0);
 645     }
 646
 647 #if defined(SUSE) || defined(FEDORA) || defined(MAGEIA)
 648   if (mainmode == MODE_PATCH)
 649     add_patchjobs(pool, &job);
 650 #endif
 651
 652   // add mode
 653   for (i = 0; i < job.count; i += 2)
 654     {
 655       job.elements[i] |= mode;
 656       if (mode == SOLVER_UPDATE && pool_isemptyupdatejob(pool, job.elements[i], job.elements[i + 1]))
 657         job.elements[i] ^= SOLVER_UPDATE ^ SOLVER_INSTALL;
 658       if (cleandeps)
 659         job.elements[i] |= SOLVER_CLEANDEPS;
 660       if (forcebest)
 661         job.elements[i] |= SOLVER_FORCEBEST;
 662     }
 663
 664 #if 0
 665   // multiversion test
 666   queue_push2(&job, SOLVER_MULTIVERSION|SOLVER_SOLVABLE_PROVIDES, pool_str2id(pool, "multiversion(kernel)", 1));
 667 #endif
 668 #if 0
 669   queue_push2(&job, SOLVER_INSTALL|SOLVER_SOLVABLE_PROVIDES, pool_rel2id(pool, NAMESPACE_LANGUAGE, 0, REL_NAMESPACE, 1));
 670   queue_push2(&job, SOLVER_ERASE|SOLVER_CLEANDEPS|SOLVER_SOLVABLE_PROVIDES, pool_rel2id(pool, NAMESPACE_LANGUAGE, 0, REL_NAMESPACE, 1));
 671 #endif
 672
 673 rerunsolver:
 674   solv = solver_create(pool);
 675   solver_set_flag(solv, SOLVER_FLAG_SPLITPROVIDES, 1);
 676 #if 0
 677   solver_set_flag(solv, SOLVER_FLAG_IGNORE_RECOMMENDED, 1);
 678 #endif
 679 #if defined(FEDORA) || defined(MAGEIA)
 680   solver_set_flag(solv, SOLVER_FLAG_ALLOW_VENDORCHANGE, 1);
 681 #endif
 682   if (mainmode == MODE_ERASE)
 683     solver_set_flag(solv, SOLVER_FLAG_ALLOW_UNINSTALL, 1);      /* don't nag */
 684   solver_set_flag(solv, SOLVER_FLAG_BEST_OBEY_POLICY, 1);
 685
 686   for (;;)
 687     {
 688       Id problem, solution;
 689       int pcnt, scnt;
 690
 691       pcnt = solver_solve(solv, &job);
 692       if (testcase)
 693         {
 694           printf("Writing solver testcase:\n");
 695           if (!testcase_write(solv, testcase, TESTCASE_RESULT_TRANSACTION | TESTCASE_RESULT_PROBLEMS, 0, 0))
 696             printf("%s\n", pool_errstr(pool));
 697           testcase = 0;
 698         }
 699       if (!pcnt)
 700         break;
 701       pcnt = solver_problem_count(solv);
 702       printf("Found %d problems:\n", pcnt);
 703       for (problem = 1; problem <= pcnt; problem++)
 704         {
 705           int take = 0;
 706           printf("Problem %d/%d:\n", problem, pcnt);
 707           solver_printprobleminfo(solv, problem);
 708           printf("\n");
 709           scnt = solver_solution_count(solv, problem);
 710           for (solution = 1; solution <= scnt; solution++)
 711             {
 712               printf("Solution %d:\n", solution);
 713               solver_printsolution(solv, problem, solution);
 714               printf("\n");
 715             }
 716           for (;;)
 717             {
 718               char inbuf[128], *ip;
 719               printf("Please choose a solution: ");
 720               fflush(stdout);
 721               *inbuf = 0;
 722               if (!(ip = fgets(inbuf, sizeof(inbuf), stdin)))
 723                 {
 724                   printf("Abort.\n");
 725                   exit(1);
 726                 }
 727               while (*ip == ' ' || *ip == '\t')
 728                 ip++;
 729               if (*ip >= '0' && *ip <= '9')
 730                 {
 731                   take = atoi(ip);
 732                   if (take >= 1 && take <= scnt)
 733                     break;
 734                 }
 735               if (*ip == 's')
 736                 {
 737                   take = 0;
 738                   break;
 739                 }
 740               if (*ip == 'q')
 741                 {
 742                   printf("Abort.\n");
 743                   exit(1);
 744                 }
 745             }
 746           if (!take)
 747             continue;
 748           solver_take_solution(solv, problem, take, &job);
 749         }
 750     }
 751
 752   trans = solver_create_transaction(solv);
 753   if (!trans->steps.count)
 754     {
 755       printf("Nothing to do.\n");
 756       transaction_free(trans);
 757       solver_free(solv);
 758       queue_free(&job);
 759       pool_free(pool);
 760       free_repoinfos(repoinfos, nrepoinfos);
 761       solv_free(commandlinepkgs);
 762       exit(1);
 763     }
 764
 765   /* display transaction to the user and ask for confirmation */
 766   printf("\n");
 767   printf("Transaction summary:\n\n");
 768   transaction_print(trans);
 769 #if defined(SUSE)
 770   showdiskusagechanges(trans);
 771 #endif
 772   printf("install size change: %d K\n", transaction_calc_installsizechange(trans));
 773   printf("\n");
 774
 775   acnt = solver_alternatives_count(solv);
 776   if (acnt)
 777     {
 778       if (acnt == 1)
 779         printf("Have one alternative:\n");
 780       else
 781         printf("Have %d alternatives:\n", acnt);
 782       for (i = 1; i <= acnt; i++)
 783         {
 784           Id id, from;
 785           int atype = solver_get_alternative(solv, i, &id, &from, 0, 0, 0);
 786           printf("  - %s\n", solver_alternative2str(solv, atype, id, from));
 787         }
 788       printf("\n");
 789       answer = yesno("OK to continue (y/n/a)? ", 'a');
 790     }
 791   else
 792     answer = yesno("OK to continue (y/n)? ", 0);
 793   if (answer == 'a')
 794     {
 795       Queue choicesq;
 796       Queue answerq;
 797       Id id, from, chosen;
 798       int j;
 799
 800       queue_init(&choicesq);
 801       queue_init(&answerq);
 802       for (i = 1; i <= acnt; i++)
 803         {
 804           int atype = solver_get_alternative(solv, i, &id, &from, &chosen, &choicesq, 0);
 805           printf("\n%s\n", solver_alternative2str(solv, atype, id, from));
 806           for (j = 0; j < choicesq.count; j++)
 807             {
 808               Id p = choicesq.elements[j];
 809               if (p < 0)
 810                 p = -p;
 811               queue_push(&answerq, p);
 812               printf("%6d: %s\n", answerq.count, pool_solvid2str(pool, p));
 813             }
 814         }
 815       queue_free(&choicesq);
 816       printf("\n");
 817       for (;;)
 818         {
 819           char inbuf[128], *ip;
 820           int neg = 0;
 821           printf("OK to continue (y/n), or number to change alternative: ");
 822           fflush(stdout);
 823           *inbuf = 0;
 824           if (!(ip = fgets(inbuf, sizeof(inbuf), stdin)))
 825             {
 826               printf("Abort.\n");
 827               exit(1);
 828             }
 829           while (*ip == ' ' || *ip == '\t')
 830             ip++;
 831           if (*ip == '-' && ip[1] >= '0' && ip[1] <= '9')
 832             {
 833               neg = 1;
 834               ip++;
 835             }
 836           if (*ip >= '0' && *ip <= '9')
 837             {
 838               int take = atoi(ip);
 839               if (take > 0 && take <= answerq.count)
 840                 {
 841                   Id p = answerq.elements[take - 1];
 842                   queue_free(&answerq);
 843                   queue_push2(&job, (neg ? SOLVER_DISFAVOR : SOLVER_FAVOR) | SOLVER_SOLVABLE_NAME, pool->solvables[p].name);
 844                   solver_free(solv);
 845                   solv = 0;
 846                   goto rerunsolver;
 847                   break;
 848                 }
 849             }
 850           if (*ip == 'n' || *ip == 'y')
 851             {
 852               answer = *ip == 'n' ? 0 : *ip;
 853               break;
 854             }
 855         }
 856       queue_free(&answerq);
 857     }
 858   if (!answer)
 859     {
 860       printf("Abort.\n");
 861       transaction_free(trans);
 862       solver_free(solv);
 863       queue_free(&job);
 864       pool_free(pool);
 865       free_repoinfos(repoinfos, nrepoinfos);
 866       solv_free(commandlinepkgs);
 867       exit(1);
 868     }
 869
 870   /* download all new packages */
 871   queue_init(&checkq);
 872   newpkgs = transaction_installedresult(trans, &checkq);
 873   newpkgsfps = 0;
 874   if (newpkgs)
 875     {
 876       int downloadsize = 0;
 877       for (i = 0; i < newpkgs; i++)
 878         {
 879           Solvable *s;
 880
 881           p = checkq.elements[i];
 882           s = pool_id2solvable(pool, p);
 883           downloadsize += solvable_lookup_sizek(s, SOLVABLE_DOWNLOADSIZE, 0);
 884         }
 885       printf("Downloading %d packages, %d K\n", newpkgs, downloadsize);
 886       newpkgsfps = solv_calloc(newpkgs, sizeof(*newpkgsfps));
 887       for (i = 0; i < newpkgs; i++)
 888         {
 889           const char *loc;
 890           Solvable *s;
 891           struct repoinfo *cinfo;
 892
 893           p = checkq.elements[i];
 894           s = pool_id2solvable(pool, p);
 895           if (s->repo == commandlinerepo)
 896             {
 897               loc = solvable_lookup_location(s, 0);
 898               if (!loc)
 899                 continue;
 900               if (!(newpkgsfps[i] = fopen(loc, "r")))
 901                 {
 902                   perror(loc);
 903                   exit(1);
 904                 }
 905               putchar('.');
 906               continue;
 907             }
 908           cinfo = s->repo->appdata;
 909           if (!cinfo || cinfo->type == TYPE_INSTALLED)
 910             {
 911               printf("%s: no repository information\n", s->repo->name);
 912               exit(1);
 913             }
 914           loc = solvable_lookup_location(s, 0);
 915           if (!loc)
 916              continue;  /* pseudo package? */
 917 #if defined(ENABLE_RPMDB)
 918           if (pool->installed && pool->installed->nsolvables)
 919             {
 920               if ((newpkgsfps[i] = trydeltadownload(s, loc)) != 0)
 921                 {
 922                   putchar('d');
 923                   fflush(stdout);
 924                   continue;             /* delta worked! */
 925                 }
 926             }
 927 #endif
 928           if ((newpkgsfps[i] = downloadpackage(s, loc)) == 0)
 929             {
 930               printf("\n%s: %s not found in repository\n", s->repo->name, loc);
 931               exit(1);
 932             }
 933           putchar('.');
 934           fflush(stdout);
 935         }
 936       putchar('\n');
 937     }
 938
 939 #if defined(ENABLE_RPMDB) && (defined(SUSE) || defined(FEDORA) || defined(MANDRIVA) || defined(MAGEIA))
 940   /* check for file conflicts */
 941   if (newpkgs)
 942     {
 943       Queue conflicts;
 944       queue_init(&conflicts);
 945       if (checkfileconflicts(pool, &checkq, newpkgs, newpkgsfps, &conflicts))
 946         {
 947           if (yesno("Re-run solver (y/n/q)? ", 0))
 948             {
 949               for (i = 0; i < newpkgs; i++)
 950                 if (newpkgsfps[i])
 951                   fclose(newpkgsfps[i]);
 952               newpkgsfps = solv_free(newpkgsfps);
 953               solver_free(solv);
 954               solv = 0;
 955               pool_add_fileconflicts_deps(pool, &conflicts);
 956               queue_free(&conflicts);
 957               goto rerunsolver;
 958             }
 959         }
 960       queue_free(&conflicts);
 961     }
 962 #endif
 963
 964   /* and finally commit the transaction */
 965   printf("Committing transaction:\n\n");
 966   transaction_order(trans, 0);
 967   for (i = 0; i < trans->steps.count; i++)
 968     {
 969       int j;
 970       FILE *fp;
 971       Id type;
 972
 973       p = trans->steps.elements[i];
 974       type = transaction_type(trans, p, SOLVER_TRANSACTION_RPM_ONLY);
 975       switch(type)
 976         {
 977         case SOLVER_TRANSACTION_ERASE:
 978           printf("erase %s\n", pool_solvid2str(pool, p));
 979           commit_transactionelement(pool, type, p, 0);
 980           break;
 981         case SOLVER_TRANSACTION_INSTALL:
 982         case SOLVER_TRANSACTION_MULTIINSTALL:
 983           printf("install %s\n", pool_solvid2str(pool, p));
 984           for (j = 0; j < newpkgs; j++)
 985             if (checkq.elements[j] == p)
 986               break;
 987           fp = j < newpkgs ? newpkgsfps[j] : 0;
 988           if (!fp)
 989             continue;
 990           commit_transactionelement(pool, type, p, fp);
 991           fclose(fp);
 992           newpkgsfps[j] = 0;
 993           break;
 994         default:
 995           break;
 996         }
 997     }
 998
 999   for (i = 0; i < newpkgs; i++)
1000     if (newpkgsfps[i])
1001       fclose(newpkgsfps[i]);
1002   solv_free(newpkgsfps);
1003   queue_free(&checkq);
1004   transaction_free(trans);
1005   solver_free(solv);
1006   queue_free(&job);
1007   pool_free(pool);
1008   free_repoinfos(repoinfos, nrepoinfos);
1009   solv_free(commandlinepkgs);
1010   exit(0);
1011 }