cmdline/apt-get.cc

   1 // -*- mode: cpp; mode: fold -*-
   2 // Description                                                          /*{{{*/
   3 // $Id: apt-get.cc,v 1.156 2004/08/28 01:05:16 mdz Exp $
   4 /* ######################################################################
   5
   6    apt-get - Cover for dpkg
   7
   8    This is an allout cover for dpkg implementing a safer front end. It is
   9    based largely on libapt-pkg.
  10
  11    The syntax is different,
  12       apt-get [opt] command [things]
  13    Where command is:
  14       update - Resyncronize the package files from their sources
  15       upgrade - Smart-Download the newest versions of all packages
  16       dselect-upgrade - Follows dselect's changes to the Status: field
  17                        and installes new and removes old packages
  18       dist-upgrade - Powerfull upgrader designed to handle the issues with
  19                     a new distribution.
  20       install - Download and install a given package (by name, not by .deb)
  21       check - Update the package cache and check for broken packages
  22       clean - Erase the .debs downloaded to /var/cache/apt/archives and
  23               the partial dir too
  24
  25    ##################################################################### */
  26                                                                         /*}}}*/
  27 // Include Files                                                        /*{{{*/
  28 #include <config.h>
  29
  30 #include <apt-pkg/aptconfiguration.h>
  31 #include <apt-pkg/error.h>
  32 #include <apt-pkg/cmndline.h>
  33 #include <apt-pkg/init.h>
  34 #include <apt-pkg/depcache.h>
  35 #include <apt-pkg/sourcelist.h>
  36 #include <apt-pkg/algorithms.h>
  37 #include <apt-pkg/acquire-item.h>
  38 #include <apt-pkg/strutl.h>
  39 #include <apt-pkg/fileutl.h>
  40 #include <apt-pkg/clean.h>
  41 #include <apt-pkg/srcrecords.h>
  42 #include <apt-pkg/version.h>
  43 #include <apt-pkg/cachefile.h>
  44 #include <apt-pkg/cacheset.h>
  45 #include <apt-pkg/sptr.h>
  46 #include <apt-pkg/md5.h>
  47 #include <apt-pkg/versionmatch.h>
  48 #include <apt-pkg/progress.h>
  49 #include <apt-pkg/pkgsystem.h>
  50 #include <apt-pkg/pkgrecords.h>
  51 #include <apt-pkg/indexfile.h>
  52
  53 #include "acqprogress.h"
  54
  55 #include <set>
  56 #include <locale.h>
  57 #include <langinfo.h>
  58 #include <fstream>
  59 #include <termios.h>
  60 #include <sys/ioctl.h>
  61 #include <sys/stat.h>
  62 #include <sys/statfs.h>
  63 #include <sys/statvfs.h>
  64 #include <signal.h>
  65 #include <unistd.h>
  66 #include <stdio.h>
  67 #include <errno.h>
  68 #include <regex.h>
  69 #include <sys/wait.h>
  70 #include <sstream>
  71
  72 #include <apti18n.h>
  73                                                                         /*}}}*/
  74
  75 #define RAMFS_MAGIC     0x858458f6
  76
  77 using namespace std;
  78
  79 ostream c0out(0);
  80 ostream c1out(0);
  81 ostream c2out(0);
  82 ofstream devnull("/dev/null");
  83 unsigned int ScreenWidth = 80 - 1; /* - 1 for the cursor */
  84
  85 // class CacheFile - Cover class for some dependency cache functions    /*{{{*/
  86 // ---------------------------------------------------------------------
  87 /* */
  88 class CacheFile : public pkgCacheFile
  89 {
  90    static pkgCache *SortCache;
  91    static int NameComp(const void *a,const void *b);
  92
  93    public:
  94    pkgCache::Package **List;
  95
  96    void Sort();
  97    bool CheckDeps(bool AllowBroken = false);
  98    bool BuildCaches(bool WithLock = true)
  99    {
 100       OpTextProgress Prog(*_config);
 101       if (pkgCacheFile::BuildCaches(&Prog,WithLock) == false)
 102          return false;
 103       return true;
 104    }
 105    bool Open(bool WithLock = true)
 106    {
 107       OpTextProgress Prog(*_config);
 108       if (pkgCacheFile::Open(&Prog,WithLock) == false)
 109          return false;
 110       Sort();
 111
 112       return true;
 113    };
 114    bool OpenForInstall()
 115    {
 116       if (_config->FindB("APT::Get::Print-URIs") == true)
 117          return Open(false);
 118       else
 119          return Open(true);
 120    }
 121    CacheFile() : List(0) {};
 122    ~CacheFile() {
 123       delete[] List;
 124    }
 125 };
 126                                                                         /*}}}*/
 127
 128 // YnPrompt - Yes No Prompt.                                            /*{{{*/
 129 // ---------------------------------------------------------------------
 130 /* Returns true on a Yes.*/
 131 bool YnPrompt(bool Default=true)
 132 {
 133    if (_config->FindB("APT::Get::Assume-Yes",false) == true)
 134    {
 135       c1out << _("Y") << endl;
 136       return true;
 137    }
 138    else if (_config->FindB("APT::Get::Assume-No",false) == true)
 139    {
 140       c1out << _("N") << endl;
 141       return false;
 142    }
 143
 144    char response[1024] = "";
 145    cin.getline(response, sizeof(response));
 146
 147    if (!cin)
 148       return false;
 149
 150    if (strlen(response) == 0)
 151       return Default;
 152
 153    regex_t Pattern;
 154    int Res;
 155
 156    Res = regcomp(&Pattern, nl_langinfo(YESEXPR),
 157                  REG_EXTENDED|REG_ICASE|REG_NOSUB);
 158
 159    if (Res != 0) {
 160       char Error[300];
 161       regerror(Res,&Pattern,Error,sizeof(Error));
 162       return _error->Error(_("Regex compilation error - %s"),Error);
 163    }
 164
 165    Res = regexec(&Pattern, response, 0, NULL, 0);
 166    if (Res == 0)
 167       return true;
 168    return false;
 169 }
 170                                                                         /*}}}*/
 171 // AnalPrompt - Annoying Yes No Prompt.                                 /*{{{*/
 172 // ---------------------------------------------------------------------
 173 /* Returns true on a Yes.*/
 174 bool AnalPrompt(const char *Text)
 175 {
 176    char Buf[1024];
 177    cin.getline(Buf,sizeof(Buf));
 178    if (strcmp(Buf,Text) == 0)
 179       return true;
 180    return false;
 181 }
 182                                                                         /*}}}*/
 183 // ShowList - Show a list                                               /*{{{*/
 184 // ---------------------------------------------------------------------
 185 /* This prints out a string of space separated words with a title and
 186    a two space indent line wraped to the current screen width. */
 187 bool ShowList(ostream &out,string Title,string List,string VersionsList)
 188 {
 189    if (List.empty() == true)
 190       return true;
 191    // trim trailing space
 192    int NonSpace = List.find_last_not_of(' ');
 193    if (NonSpace != -1)
 194    {
 195       List = List.erase(NonSpace + 1);
 196       if (List.empty() == true)
 197          return true;
 198    }
 199
 200    // Acount for the leading space
 201    int ScreenWidth = ::ScreenWidth - 3;
 202
 203    out << Title << endl;
 204    string::size_type Start = 0;
 205    string::size_type VersionsStart = 0;
 206    while (Start < List.size())
 207    {
 208       if(_config->FindB("APT::Get::Show-Versions",false) == true &&
 209          VersionsList.size() > 0) {
 210          string::size_type End;
 211          string::size_type VersionsEnd;
 212
 213          End = List.find(' ',Start);
 214          VersionsEnd = VersionsList.find('\n', VersionsStart);
 215
 216          out << "   " << string(List,Start,End - Start) << " (" <<
 217             string(VersionsList,VersionsStart,VersionsEnd - VersionsStart) <<
 218             ")" << endl;
 219
 220          if (End == string::npos || End < Start)
 221             End = Start + ScreenWidth;
 222
 223          Start = End + 1;
 224          VersionsStart = VersionsEnd + 1;
 225       } else {
 226          string::size_type End;
 227
 228          if (Start + ScreenWidth >= List.size())
 229             End = List.size();
 230          else
 231             End = List.rfind(' ',Start+ScreenWidth);
 232
 233          if (End == string::npos || End < Start)
 234             End = Start + ScreenWidth;
 235          out << "  " << string(List,Start,End - Start) << endl;
 236          Start = End + 1;
 237       }
 238    }
 239
 240    return false;
 241 }
 242                                                                         /*}}}*/
 243 // ShowBroken - Debugging aide                                          /*{{{*/
 244 // ---------------------------------------------------------------------
 245 /* This prints out the names of all the packages that are broken along
 246    with the name of each each broken dependency and a quite version
 247    description.
 248
 249    The output looks like:
 250  The following packages have unmet dependencies:
 251      exim: Depends: libc6 (>= 2.1.94) but 2.1.3-10 is to be installed
 252            Depends: libldap2 (>= 2.0.2-2) but it is not going to be installed
 253            Depends: libsasl7 but it is not going to be installed
 254  */
 255 void ShowBroken(ostream &out,CacheFile &Cache,bool Now)
 256 {
 257    if (Cache->BrokenCount() == 0)
 258       return;
 259
 260    out << _("The following packages have unmet dependencies:") << endl;
 261    for (unsigned J = 0; J < Cache->Head().PackageCount; J++)
 262    {
 263       pkgCache::PkgIterator I(Cache,Cache.List[J]);
 264
 265       if (Now == true)
 266       {
 267          if (Cache[I].NowBroken() == false)
 268             continue;
 269       }
 270       else
 271       {
 272          if (Cache[I].InstBroken() == false)
 273             continue;
 274       }
 275
 276       // Print out each package and the failed dependencies
 277       out << " " << I.FullName(true) << " :";
 278       unsigned const Indent = I.FullName(true).size() + 3;
 279       bool First = true;
 280       pkgCache::VerIterator Ver;
 281
 282       if (Now == true)
 283          Ver = I.CurrentVer();
 284       else
 285          Ver = Cache[I].InstVerIter(Cache);
 286
 287       if (Ver.end() == true)
 288       {
 289          out << endl;
 290          continue;
 291       }
 292
 293       for (pkgCache::DepIterator D = Ver.DependsList(); D.end() == false;)
 294       {
 295          // Compute a single dependency element (glob or)
 296          pkgCache::DepIterator Start;
 297          pkgCache::DepIterator End;
 298          D.GlobOr(Start,End); // advances D
 299
 300          if (Cache->IsImportantDep(End) == false)
 301             continue;
 302
 303          if (Now == true)
 304          {
 305             if ((Cache[End] & pkgDepCache::DepGNow) == pkgDepCache::DepGNow)
 306                continue;
 307          }
 308          else
 309          {
 310             if ((Cache[End] & pkgDepCache::DepGInstall) == pkgDepCache::DepGInstall)
 311                continue;
 312          }
 313
 314          bool FirstOr = true;
 315          while (1)
 316          {
 317             if (First == false)
 318                for (unsigned J = 0; J != Indent; J++)
 319                   out << ' ';
 320             First = false;
 321
 322             if (FirstOr == false)
 323             {
 324                for (unsigned J = 0; J != strlen(End.DepType()) + 3; J++)
 325                   out << ' ';
 326             }
 327             else
 328                out << ' ' << End.DepType() << ": ";
 329             FirstOr = false;
 330
 331             out << Start.TargetPkg().FullName(true);
 332
 333             // Show a quick summary of the version requirements
 334             if (Start.TargetVer() != 0)
 335                out << " (" << Start.CompType() << " " << Start.TargetVer() << ")";
 336
 337             /* Show a summary of the target package if possible. In the case
 338                of virtual packages we show nothing */
 339             pkgCache::PkgIterator Targ = Start.TargetPkg();
 340             if (Targ->ProvidesList == 0)
 341             {
 342                out << ' ';
 343                pkgCache::VerIterator Ver = Cache[Targ].InstVerIter(Cache);
 344                if (Now == true)
 345                   Ver = Targ.CurrentVer();
 346
 347                if (Ver.end() == false)
 348                {
 349                   if (Now == true)
 350                      ioprintf(out,_("but %s is installed"),Ver.VerStr());
 351                   else
 352                      ioprintf(out,_("but %s is to be installed"),Ver.VerStr());
 353                }
 354                else
 355                {
 356                   if (Cache[Targ].CandidateVerIter(Cache).end() == true)
 357                   {
 358                      if (Targ->ProvidesList == 0)
 359                         out << _("but it is not installable");
 360                      else
 361                         out << _("but it is a virtual package");
 362                   }
 363                   else
 364                      out << (Now?_("but it is not installed"):_("but it is not going to be installed"));
 365                }
 366             }
 367
 368             if (Start != End)
 369                out << _(" or");
 370             out << endl;
 371
 372             if (Start == End)
 373                break;
 374             ++Start;
 375          }
 376       }
 377    }
 378 }
 379                                                                         /*}}}*/
 380 // ShowNew - Show packages to newly install                             /*{{{*/
 381 // ---------------------------------------------------------------------
 382 /* */
 383 void ShowNew(ostream &out,CacheFile &Cache)
 384 {
 385    /* Print out a list of packages that are going to be installed extra
 386       to what the user asked */
 387    string List;
 388    string VersionsList;
 389    for (unsigned J = 0; J < Cache->Head().PackageCount; J++)
 390    {
 391       pkgCache::PkgIterator I(Cache,Cache.List[J]);
 392       if (Cache[I].NewInstall() == true) {
 393          List += I.FullName(true) + " ";
 394          VersionsList += string(Cache[I].CandVersion) + "\n";
 395       }
 396    }
 397
 398    ShowList(out,_("The following NEW packages will be installed:"),List,VersionsList);
 399 }
 400                                                                         /*}}}*/
 401 // ShowDel - Show packages to delete                                    /*{{{*/
 402 // ---------------------------------------------------------------------
 403 /* */
 404 void ShowDel(ostream &out,CacheFile &Cache)
 405 {
 406    /* Print out a list of packages that are going to be removed extra
 407       to what the user asked */
 408    string List;
 409    string VersionsList;
 410    for (unsigned J = 0; J < Cache->Head().PackageCount; J++)
 411    {
 412       pkgCache::PkgIterator I(Cache,Cache.List[J]);
 413       if (Cache[I].Delete() == true)
 414       {
 415          if ((Cache[I].iFlags & pkgDepCache::Purge) == pkgDepCache::Purge)
 416             List += I.FullName(true) + "* ";
 417          else
 418             List += I.FullName(true) + " ";
 419
 420      VersionsList += string(Cache[I].CandVersion)+ "\n";
 421       }
 422    }
 423
 424    ShowList(out,_("The following packages will be REMOVED:"),List,VersionsList);
 425 }
 426                                                                         /*}}}*/
 427 // ShowKept - Show kept packages                                        /*{{{*/
 428 // ---------------------------------------------------------------------
 429 /* */
 430 void ShowKept(ostream &out,CacheFile &Cache)
 431 {
 432    string List;
 433    string VersionsList;
 434    for (unsigned J = 0; J < Cache->Head().PackageCount; J++)
 435    {
 436       pkgCache::PkgIterator I(Cache,Cache.List[J]);
 437
 438       // Not interesting
 439       if (Cache[I].Upgrade() == true || Cache[I].Upgradable() == false ||
 440           I->CurrentVer == 0 || Cache[I].Delete() == true)
 441          continue;
 442
 443       List += I.FullName(true) + " ";
 444       VersionsList += string(Cache[I].CurVersion) + " => " + Cache[I].CandVersion + "\n";
 445    }
 446    ShowList(out,_("The following packages have been kept back:"),List,VersionsList);
 447 }
 448                                                                         /*}}}*/
 449 // ShowUpgraded - Show upgraded packages                                /*{{{*/
 450 // ---------------------------------------------------------------------
 451 /* */
 452 void ShowUpgraded(ostream &out,CacheFile &Cache)
 453 {
 454    string List;
 455    string VersionsList;
 456    for (unsigned J = 0; J < Cache->Head().PackageCount; J++)
 457    {
 458       pkgCache::PkgIterator I(Cache,Cache.List[J]);
 459
 460       // Not interesting
 461       if (Cache[I].Upgrade() == false || Cache[I].NewInstall() == true)
 462          continue;
 463
 464       List += I.FullName(true) + " ";
 465       VersionsList += string(Cache[I].CurVersion) + " => " + Cache[I].CandVersion + "\n";
 466    }
 467    ShowList(out,_("The following packages will be upgraded:"),List,VersionsList);
 468 }
 469                                                                         /*}}}*/
 470 // ShowDowngraded - Show downgraded packages                            /*{{{*/
 471 // ---------------------------------------------------------------------
 472 /* */
 473 bool ShowDowngraded(ostream &out,CacheFile &Cache)
 474 {
 475    string List;
 476    string VersionsList;
 477    for (unsigned J = 0; J < Cache->Head().PackageCount; J++)
 478    {
 479       pkgCache::PkgIterator I(Cache,Cache.List[J]);
 480
 481       // Not interesting
 482       if (Cache[I].Downgrade() == false || Cache[I].NewInstall() == true)
 483          continue;
 484
 485       List += I.FullName(true) + " ";
 486       VersionsList += string(Cache[I].CurVersion) + " => " + Cache[I].CandVersion + "\n";
 487    }
 488    return ShowList(out,_("The following packages will be DOWNGRADED:"),List,VersionsList);
 489 }
 490                                                                         /*}}}*/
 491 // ShowHold - Show held but changed packages                            /*{{{*/
 492 // ---------------------------------------------------------------------
 493 /* */
 494 bool ShowHold(ostream &out,CacheFile &Cache)
 495 {
 496    string List;
 497    string VersionsList;
 498    for (unsigned J = 0; J < Cache->Head().PackageCount; J++)
 499    {
 500       pkgCache::PkgIterator I(Cache,Cache.List[J]);
 501       if (Cache[I].InstallVer != (pkgCache::Version *)I.CurrentVer() &&
 502           I->SelectedState == pkgCache::State::Hold) {
 503          List += I.FullName(true) + " ";
 504                  VersionsList += string(Cache[I].CurVersion) + " => " + Cache[I].CandVersion + "\n";
 505       }
 506    }
 507
 508    return ShowList(out,_("The following held packages will be changed:"),List,VersionsList);
 509 }
 510                                                                         /*}}}*/
 511 // ShowEssential - Show an essential package warning                    /*{{{*/
 512 // ---------------------------------------------------------------------
 513 /* This prints out a warning message that is not to be ignored. It shows
 514    all essential packages and their dependents that are to be removed.
 515    It is insanely risky to remove the dependents of an essential package! */
 516 bool ShowEssential(ostream &out,CacheFile &Cache)
 517 {
 518    string List;
 519    string VersionsList;
 520    bool *Added = new bool[Cache->Head().PackageCount];
 521    for (unsigned int I = 0; I != Cache->Head().PackageCount; I++)
 522       Added[I] = false;
 523
 524    for (unsigned J = 0; J < Cache->Head().PackageCount; J++)
 525    {
 526       pkgCache::PkgIterator I(Cache,Cache.List[J]);
 527       if ((I->Flags & pkgCache::Flag::Essential) != pkgCache::Flag::Essential &&
 528           (I->Flags & pkgCache::Flag::Important) != pkgCache::Flag::Important)
 529          continue;
 530
 531       // The essential package is being removed
 532       if (Cache[I].Delete() == true)
 533       {
 534          if (Added[I->ID] == false)
 535          {
 536             Added[I->ID] = true;
 537             List += I.FullName(true) + " ";
 538         //VersionsList += string(Cache[I].CurVersion) + "\n"; ???
 539          }
 540       }
 541       else
 542          continue;
 543
 544       if (I->CurrentVer == 0)
 545          continue;
 546
 547       // Print out any essential package depenendents that are to be removed
 548       for (pkgCache::DepIterator D = I.CurrentVer().DependsList(); D.end() == false; ++D)
 549       {
 550          // Skip everything but depends
 551          if (D->Type != pkgCache::Dep::PreDepends &&
 552              D->Type != pkgCache::Dep::Depends)
 553             continue;
 554
 555          pkgCache::PkgIterator P = D.SmartTargetPkg();
 556          if (Cache[P].Delete() == true)
 557          {
 558             if (Added[P->ID] == true)
 559                continue;
 560             Added[P->ID] = true;
 561
 562             char S[300];
 563             snprintf(S,sizeof(S),_("%s (due to %s) "),P.FullName(true).c_str(),I.FullName(true).c_str());
 564             List += S;
 565         //VersionsList += "\n"; ???
 566          }
 567       }
 568    }
 569
 570    delete [] Added;
 571    return ShowList(out,_("WARNING: The following essential packages will be removed.\n"
 572                          "This should NOT be done unless you know exactly what you are doing!"),List,VersionsList);
 573 }
 574
 575                                                                         /*}}}*/
 576 // Stats - Show some statistics                                         /*{{{*/
 577 // ---------------------------------------------------------------------
 578 /* */
 579 void Stats(ostream &out,pkgDepCache &Dep)
 580 {
 581    unsigned long Upgrade = 0;
 582    unsigned long Downgrade = 0;
 583    unsigned long Install = 0;
 584    unsigned long ReInstall = 0;
 585    for (pkgCache::PkgIterator I = Dep.PkgBegin(); I.end() == false; ++I)
 586    {
 587       if (Dep[I].NewInstall() == true)
 588          Install++;
 589       else
 590       {
 591          if (Dep[I].Upgrade() == true)
 592             Upgrade++;
 593          else
 594             if (Dep[I].Downgrade() == true)
 595                Downgrade++;
 596       }
 597
 598       if (Dep[I].Delete() == false && (Dep[I].iFlags & pkgDepCache::ReInstall) == pkgDepCache::ReInstall)
 599          ReInstall++;
 600    }
 601
 602    ioprintf(out,_("%lu upgraded, %lu newly installed, "),
 603             Upgrade,Install);
 604
 605    if (ReInstall != 0)
 606       ioprintf(out,_("%lu reinstalled, "),ReInstall);
 607    if (Downgrade != 0)
 608       ioprintf(out,_("%lu downgraded, "),Downgrade);
 609
 610    ioprintf(out,_("%lu to remove and %lu not upgraded.\n"),
 611             Dep.DelCount(),Dep.KeepCount());
 612
 613    if (Dep.BadCount() != 0)
 614       ioprintf(out,_("%lu not fully installed or removed.\n"),
 615                Dep.BadCount());
 616 }
 617                                                                         /*}}}*/
 618 // CacheSetHelperAPTGet - responsible for message telling from the CacheSets/*{{{*/
 619 class CacheSetHelperAPTGet : public APT::CacheSetHelper {
 620         /** \brief stream message should be printed to */
 621         std::ostream &out;
 622         /** \brief were things like Task or RegEx used to select packages? */
 623         bool explicitlyNamed;
 624
 625         APT::PackageSet virtualPkgs;
 626
 627 public:
 628         std::list<std::pair<pkgCache::VerIterator, std::string> > selectedByRelease;
 629
 630         CacheSetHelperAPTGet(std::ostream &out) : APT::CacheSetHelper(true), out(out) {
 631                 explicitlyNamed = true;
 632         }
 633
 634         virtual void showTaskSelection(pkgCache::PkgIterator const &Pkg, string const &pattern) {
 635                 ioprintf(out, _("Note, selecting '%s' for task '%s'\n"),
 636                                 Pkg.FullName(true).c_str(), pattern.c_str());
 637                 explicitlyNamed = false;
 638         }
 639         virtual void showRegExSelection(pkgCache::PkgIterator const &Pkg, string const &pattern) {
 640                 ioprintf(out, _("Note, selecting '%s' for regex '%s'\n"),
 641                                 Pkg.FullName(true).c_str(), pattern.c_str());
 642                 explicitlyNamed = false;
 643         }
 644         virtual void showSelectedVersion(pkgCache::PkgIterator const &Pkg, pkgCache::VerIterator const Ver,
 645                                  string const &ver, bool const verIsRel) {
 646                 if (ver == Ver.VerStr())
 647                         return;
 648                 selectedByRelease.push_back(make_pair(Ver, ver));
 649         }
 650
 651         bool showVirtualPackageErrors(pkgCacheFile &Cache) {
 652                 if (virtualPkgs.empty() == true)
 653                         return true;
 654                 for (APT::PackageSet::const_iterator Pkg = virtualPkgs.begin();
 655                      Pkg != virtualPkgs.end(); ++Pkg) {
 656                         if (Pkg->ProvidesList != 0) {
 657                                 ioprintf(c1out,_("Package %s is a virtual package provided by:\n"),
 658                                          Pkg.FullName(true).c_str());
 659
 660                                 pkgCache::PrvIterator I = Pkg.ProvidesList();
 661                                 unsigned short provider = 0;
 662                                 for (; I.end() == false; ++I) {
 663                                         pkgCache::PkgIterator Pkg = I.OwnerPkg();
 664
 665                                         if (Cache[Pkg].CandidateVerIter(Cache) == I.OwnerVer()) {
 666                                                 c1out << "  " << Pkg.FullName(true) << " " << I.OwnerVer().VerStr();
 667                                                 if (Cache[Pkg].Install() == true && Cache[Pkg].NewInstall() == false)
 668                                                         c1out << _(" [Installed]");
 669                                                 c1out << endl;
 670                                                 ++provider;
 671                                         }
 672                                 }
 673                                 // if we found no candidate which provide this package, show non-candidates
 674                                 if (provider == 0)
 675                                         for (I = Pkg.ProvidesList(); I.end() == false; ++I)
 676                                                 c1out << "  " << I.OwnerPkg().FullName(true) << " " << I.OwnerVer().VerStr()
 677                                                     << _(" [Not candidate version]") << endl;
 678                                 else
 679                                         out << _("You should explicitly select one to install.") << endl;
 680                         } else {
 681                                 ioprintf(c1out,
 682                                         _("Package %s is not available, but is referred to by another package.\n"
 683                                           "This may mean that the package is missing, has been obsoleted, or\n"
 684                                           "is only available from another source\n"),Pkg.FullName(true).c_str());
 685
 686                                 string List;
 687                                 string VersionsList;
 688                                 SPtrArray<bool> Seen = new bool[Cache.GetPkgCache()->Head().PackageCount];
 689                                 memset(Seen,0,Cache.GetPkgCache()->Head().PackageCount*sizeof(*Seen));
 690                                 for (pkgCache::DepIterator Dep = Pkg.RevDependsList();
 691                                      Dep.end() == false; ++Dep) {
 692                                         if (Dep->Type != pkgCache::Dep::Replaces)
 693                                                 continue;
 694                                         if (Seen[Dep.ParentPkg()->ID] == true)
 695                                                 continue;
 696                                         Seen[Dep.ParentPkg()->ID] = true;
 697                                         List += Dep.ParentPkg().FullName(true) + " ";
 698                                         //VersionsList += string(Dep.ParentPkg().CurVersion) + "\n"; ???
 699                                 }
 700                                 ShowList(c1out,_("However the following packages replace it:"),List,VersionsList);
 701                         }
 702                         c1out << std::endl;
 703                 }
 704                 return false;
 705         }
 706
 707         virtual pkgCache::VerIterator canNotFindCandidateVer(pkgCacheFile &Cache, pkgCache::PkgIterator const &Pkg) {
 708                 APT::VersionSet const verset = tryVirtualPackage(Cache, Pkg, APT::VersionSet::CANDIDATE);
 709                 if (verset.empty() == false)
 710                         return *(verset.begin());
 711                 else if (ShowError == true) {
 712                         _error->Error(_("Package '%s' has no installation candidate"),Pkg.FullName(true).c_str());
 713                         virtualPkgs.insert(Pkg);
 714                 }
 715                 return pkgCache::VerIterator(Cache, 0);
 716         }
 717
 718         virtual pkgCache::VerIterator canNotFindNewestVer(pkgCacheFile &Cache, pkgCache::PkgIterator const &Pkg) {
 719                 if (Pkg->ProvidesList != 0)
 720                 {
 721                         APT::VersionSet const verset = tryVirtualPackage(Cache, Pkg, APT::VersionSet::NEWEST);
 722                         if (verset.empty() == false)
 723                                 return *(verset.begin());
 724                         if (ShowError == true)
 725                                 ioprintf(out, _("Virtual packages like '%s' can't be removed\n"), Pkg.FullName(true).c_str());
 726                 }
 727                 else
 728                 {
 729                         pkgCache::GrpIterator Grp = Pkg.Group();
 730                         pkgCache::PkgIterator P = Grp.PackageList();
 731                         for (; P.end() != true; P = Grp.NextPkg(P))
 732                         {
 733                                 if (P == Pkg)
 734                                         continue;
 735                                 if (P->CurrentVer != 0) {
 736                                         // TRANSLATORS: Note, this is not an interactive question
 737                                         ioprintf(c1out,_("Package '%s' is not installed, so not removed. Did you mean '%s'?\n"),
 738                                                  Pkg.FullName(true).c_str(), P.FullName(true).c_str());
 739                                         break;
 740                                 }
 741                         }
 742                         if (P.end() == true)
 743                                 ioprintf(c1out,_("Package '%s' is not installed, so not removed\n"),Pkg.FullName(true).c_str());
 744                 }
 745                 return pkgCache::VerIterator(Cache, 0);
 746         }
 747
 748         APT::VersionSet tryVirtualPackage(pkgCacheFile &Cache, pkgCache::PkgIterator const &Pkg,
 749                                                 APT::VersionSet::Version const &select) {
 750                 /* This is a pure virtual package and there is a single available
 751                    candidate providing it. */
 752                 if (unlikely(Cache[Pkg].CandidateVer != 0) || Pkg->ProvidesList == 0)
 753                         return APT::VersionSet();
 754
 755                 pkgCache::PkgIterator Prov;
 756                 bool found_one = false;
 757                 for (pkgCache::PrvIterator P = Pkg.ProvidesList(); P; ++P) {
 758                         pkgCache::VerIterator const PVer = P.OwnerVer();
 759                         pkgCache::PkgIterator const PPkg = PVer.ParentPkg();
 760
 761                         /* Ignore versions that are not a candidate. */
 762                         if (Cache[PPkg].CandidateVer != PVer)
 763                                 continue;
 764
 765                         if (found_one == false) {
 766                                 Prov = PPkg;
 767                                 found_one = true;
 768                         } else if (PPkg != Prov) {
 769                                 // same group, so it's a foreign package
 770                                 if (PPkg->Group == Prov->Group) {
 771                                         // do we already have the requested arch?
 772                                         if (strcmp(Pkg.Arch(), Prov.Arch()) == 0 ||
 773                                             strcmp(Prov.Arch(), "all") == 0 ||
 774                                             unlikely(strcmp(PPkg.Arch(), Prov.Arch()) == 0)) // packages have only on candidate, but just to be sure
 775                                                 continue;
 776                                         // see which architecture we prefer more and switch to it
 777                                         std::vector<std::string> archs = APT::Configuration::getArchitectures();
 778                                         if (std::find(archs.begin(), archs.end(), PPkg.Arch()) < std::find(archs.begin(), archs.end(), Prov.Arch()))
 779                                                 Prov = PPkg;
 780                                         continue;
 781                                 }
 782                                 found_one = false; // we found at least two
 783                                 break;
 784                         }
 785                 }
 786
 787                 if (found_one == true) {
 788                         ioprintf(out, _("Note, selecting '%s' instead of '%s'\n"),
 789                                  Prov.FullName(true).c_str(), Pkg.FullName(true).c_str());
 790                         return APT::VersionSet::FromPackage(Cache, Prov, select, *this);
 791                 }
 792                 return APT::VersionSet();
 793         }
 794
 795         inline bool allPkgNamedExplicitly() const { return explicitlyNamed; }
 796
 797 };
 798                                                                         /*}}}*/
 799 // TryToInstall - Mark a package for installation                       /*{{{*/
 800 struct TryToInstall {
 801    pkgCacheFile* Cache;
 802    pkgProblemResolver* Fix;
 803    bool FixBroken;
 804    unsigned long AutoMarkChanged;
 805    APT::PackageSet doAutoInstallLater;
 806
 807    TryToInstall(pkgCacheFile &Cache, pkgProblemResolver *PM, bool const FixBroken) : Cache(&Cache), Fix(PM),
 808                         FixBroken(FixBroken), AutoMarkChanged(0) {};
 809
 810    void operator() (pkgCache::VerIterator const &Ver) {
 811       pkgCache::PkgIterator Pkg = Ver.ParentPkg();
 812
 813       Cache->GetDepCache()->SetCandidateVersion(Ver);
 814       pkgDepCache::StateCache &State = (*Cache)[Pkg];
 815
 816       // Handle the no-upgrade case
 817       if (_config->FindB("APT::Get::upgrade",true) == false && Pkg->CurrentVer != 0)
 818          ioprintf(c1out,_("Skipping %s, it is already installed and upgrade is not set.\n"),
 819                   Pkg.FullName(true).c_str());
 820       // Ignore request for install if package would be new
 821       else if (_config->FindB("APT::Get::Only-Upgrade", false) == true && Pkg->CurrentVer == 0)
 822          ioprintf(c1out,_("Skipping %s, it is not installed and only upgrades are requested.\n"),
 823                   Pkg.FullName(true).c_str());
 824       else {
 825          if (Fix != NULL) {
 826             Fix->Clear(Pkg);
 827             Fix->Protect(Pkg);
 828          }
 829          Cache->GetDepCache()->MarkInstall(Pkg,false);
 830
 831          if (State.Install() == false) {
 832             if (_config->FindB("APT::Get::ReInstall",false) == true) {
 833                if (Pkg->CurrentVer == 0 || Pkg.CurrentVer().Downloadable() == false)
 834                   ioprintf(c1out,_("Reinstallation of %s is not possible, it cannot be downloaded.\n"),
 835                            Pkg.FullName(true).c_str());
 836                else
 837                   Cache->GetDepCache()->SetReInstall(Pkg, true);
 838             } else
 839                ioprintf(c1out,_("%s is already the newest version.\n"),
 840                         Pkg.FullName(true).c_str());
 841          }
 842
 843          // Install it with autoinstalling enabled (if we not respect the minial
 844          // required deps or the policy)
 845          if (FixBroken == false)
 846             doAutoInstallLater.insert(Pkg);
 847       }
 848
 849       // see if we need to fix the auto-mark flag
 850       // e.g. apt-get install foo
 851       // where foo is marked automatic
 852       if (State.Install() == false &&
 853           (State.Flags & pkgCache::Flag::Auto) &&
 854           _config->FindB("APT::Get::ReInstall",false) == false &&
 855           _config->FindB("APT::Get::Only-Upgrade",false) == false &&
 856           _config->FindB("APT::Get::Download-Only",false) == false)
 857       {
 858          ioprintf(c1out,_("%s set to manually installed.\n"),
 859                   Pkg.FullName(true).c_str());
 860          Cache->GetDepCache()->MarkAuto(Pkg,false);
 861          AutoMarkChanged++;
 862       }
 863    }
 864
 865    bool propergateReleaseCandiateSwitching(std::list<std::pair<pkgCache::VerIterator, std::string> > start, std::ostream &out)
 866    {
 867       for (std::list<std::pair<pkgCache::VerIterator, std::string> >::const_iterator s = start.begin();
 868                 s != start.end(); ++s)
 869          Cache->GetDepCache()->SetCandidateVersion(s->first);
 870
 871       bool Success = true;
 872       std::list<std::pair<pkgCache::VerIterator, pkgCache::VerIterator> > Changed;
 873       for (std::list<std::pair<pkgCache::VerIterator, std::string> >::const_iterator s = start.begin();
 874                 s != start.end(); ++s)
 875       {
 876          Changed.push_back(std::make_pair(s->first, pkgCache::VerIterator(*Cache)));
 877          // We continue here even if it failed to enhance the ShowBroken output
 878          Success &= Cache->GetDepCache()->SetCandidateRelease(s->first, s->second, Changed);
 879       }
 880       for (std::list<std::pair<pkgCache::VerIterator, pkgCache::VerIterator> >::const_iterator c = Changed.begin();
 881            c != Changed.end(); ++c)
 882       {
 883          if (c->second.end() == true)
 884             ioprintf(out, _("Selected version '%s' (%s) for '%s'\n"),
 885                      c->first.VerStr(), c->first.RelStr().c_str(), c->first.ParentPkg().FullName(true).c_str());
 886          else if (c->first.ParentPkg()->Group != c->second.ParentPkg()->Group)
 887          {
 888             pkgCache::VerIterator V = (*Cache)[c->first.ParentPkg()].CandidateVerIter(*Cache);
 889             ioprintf(out, _("Selected version '%s' (%s) for '%s' because of '%s'\n"), V.VerStr(),
 890                      V.RelStr().c_str(), V.ParentPkg().FullName(true).c_str(), c->second.ParentPkg().FullName(true).c_str());
 891          }
 892       }
 893       return Success;
 894    }
 895
 896    void doAutoInstall() {
 897       for (APT::PackageSet::const_iterator P = doAutoInstallLater.begin();
 898            P != doAutoInstallLater.end(); ++P) {
 899          pkgDepCache::StateCache &State = (*Cache)[P];
 900          if (State.InstBroken() == false && State.InstPolicyBroken() == false)
 901             continue;
 902          Cache->GetDepCache()->MarkInstall(P, true);
 903       }
 904       doAutoInstallLater.clear();
 905    }
 906 };
 907                                                                         /*}}}*/
 908 // TryToRemove - Mark a package for removal                             /*{{{*/
 909 struct TryToRemove {
 910    pkgCacheFile* Cache;
 911    pkgProblemResolver* Fix;
 912    bool PurgePkgs;
 913
 914    TryToRemove(pkgCacheFile &Cache, pkgProblemResolver *PM) : Cache(&Cache), Fix(PM),
 915                                 PurgePkgs(_config->FindB("APT::Get::Purge", false)) {};
 916
 917    void operator() (pkgCache::VerIterator const &Ver)
 918    {
 919       pkgCache::PkgIterator Pkg = Ver.ParentPkg();
 920
 921       if (Fix != NULL)
 922       {
 923          Fix->Clear(Pkg);
 924          Fix->Protect(Pkg);
 925          Fix->Remove(Pkg);
 926       }
 927
 928       if ((Pkg->CurrentVer == 0 && PurgePkgs == false) ||
 929           (PurgePkgs == true && Pkg->CurrentState == pkgCache::State::NotInstalled))
 930       {
 931          pkgCache::GrpIterator Grp = Pkg.Group();
 932          pkgCache::PkgIterator P = Grp.PackageList();
 933          for (; P.end() != true; P = Grp.NextPkg(P))
 934          {
 935             if (P == Pkg)
 936                continue;
 937             if (P->CurrentVer != 0 || (PurgePkgs == true && P->CurrentState != pkgCache::State::NotInstalled))
 938             {
 939                // TRANSLATORS: Note, this is not an interactive question
 940                ioprintf(c1out,_("Package '%s' is not installed, so not removed. Did you mean '%s'?\n"),
 941                         Pkg.FullName(true).c_str(), P.FullName(true).c_str());
 942                break;
 943             }
 944          }
 945          if (P.end() == true)
 946             ioprintf(c1out,_("Package '%s' is not installed, so not removed\n"),Pkg.FullName(true).c_str());
 947
 948          // MarkInstall refuses to install packages on hold
 949          Pkg->SelectedState = pkgCache::State::Hold;
 950       }
 951       else
 952          Cache->GetDepCache()->MarkDelete(Pkg, PurgePkgs);
 953    }
 954 };
 955                                                                         /*}}}*/
 956 // CacheFile::NameComp - QSort compare by name                          /*{{{*/
 957 // ---------------------------------------------------------------------
 958 /* */
 959 pkgCache *CacheFile::SortCache = 0;
 960 int CacheFile::NameComp(const void *a,const void *b)
 961 {
 962    if (*(pkgCache::Package **)a == 0 || *(pkgCache::Package **)b == 0)
 963       return *(pkgCache::Package **)a - *(pkgCache::Package **)b;
 964
 965    const pkgCache::Package &A = **(pkgCache::Package **)a;
 966    const pkgCache::Package &B = **(pkgCache::Package **)b;
 967
 968    return strcmp(SortCache->StrP + A.Name,SortCache->StrP + B.Name);
 969 }
 970                                                                         /*}}}*/
 971 // CacheFile::Sort - Sort by name                                       /*{{{*/
 972 // ---------------------------------------------------------------------
 973 /* */
 974 void CacheFile::Sort()
 975 {
 976    delete [] List;
 977    List = new pkgCache::Package *[Cache->Head().PackageCount];
 978    memset(List,0,sizeof(*List)*Cache->Head().PackageCount);
 979    pkgCache::PkgIterator I = Cache->PkgBegin();
 980    for (;I.end() != true; ++I)
 981       List[I->ID] = I;
 982
 983    SortCache = *this;
 984    qsort(List,Cache->Head().PackageCount,sizeof(*List),NameComp);
 985 }
 986                                                                         /*}}}*/
 987 // CacheFile::CheckDeps - Open the cache file                           /*{{{*/
 988 // ---------------------------------------------------------------------
 989 /* This routine generates the caches and then opens the dependency cache
 990    and verifies that the system is OK. */
 991 bool CacheFile::CheckDeps(bool AllowBroken)
 992 {
 993    bool FixBroken = _config->FindB("APT::Get::Fix-Broken",false);
 994
 995    if (_error->PendingError() == true)
 996       return false;
 997
 998    // Check that the system is OK
 999    if (DCache->DelCount() != 0 || DCache->InstCount() != 0)
1000       return _error->Error("Internal error, non-zero counts");
1001
1002    // Apply corrections for half-installed packages
1003    if (pkgApplyStatus(*DCache) == false)
1004       return false;
1005
1006    if (_config->FindB("APT::Get::Fix-Policy-Broken",false) == true)
1007    {
1008       FixBroken = true;
1009       if ((DCache->PolicyBrokenCount() > 0))
1010       {
1011          // upgrade all policy-broken packages with ForceImportantDeps=True
1012          for (pkgCache::PkgIterator I = Cache->PkgBegin(); !I.end(); ++I)
1013             if ((*DCache)[I].NowPolicyBroken() == true)
1014                DCache->MarkInstall(I,true,0, false, true);
1015       }
1016    }
1017
1018    // Nothing is broken
1019    if (DCache->BrokenCount() == 0 || AllowBroken == true)
1020       return true;
1021
1022    // Attempt to fix broken things
1023    if (FixBroken == true)
1024    {
1025       c1out << _("Correcting dependencies...") << flush;
1026       if (pkgFixBroken(*DCache) == false || DCache->BrokenCount() != 0)
1027       {
1028          c1out << _(" failed.") << endl;
1029          ShowBroken(c1out,*this,true);
1030
1031          return _error->Error(_("Unable to correct dependencies"));
1032       }
1033       if (pkgMinimizeUpgrade(*DCache) == false)
1034          return _error->Error(_("Unable to minimize the upgrade set"));
1035
1036       c1out << _(" Done") << endl;
1037    }
1038    else
1039    {
1040       c1out << _("You might want to run 'apt-get -f install' to correct these.") << endl;
1041       ShowBroken(c1out,*this,true);
1042
1043       return _error->Error(_("Unmet dependencies. Try using -f."));
1044    }
1045
1046    return true;
1047 }
1048                                                                         /*}}}*/
1049 // CheckAuth - check if each download comes form a trusted source       /*{{{*/
1050 // ---------------------------------------------------------------------
1051 /* */
1052 static bool CheckAuth(pkgAcquire& Fetcher)
1053 {
1054    string UntrustedList;
1055    for (pkgAcquire::ItemIterator I = Fetcher.ItemsBegin(); I < Fetcher.ItemsEnd(); ++I)
1056    {
1057       if (!(*I)->IsTrusted())
1058       {
1059          UntrustedList += string((*I)->ShortDesc()) + " ";
1060       }
1061    }
1062
1063    if (UntrustedList == "")
1064    {
1065       return true;
1066    }
1067
1068    ShowList(c2out,_("WARNING: The following packages cannot be authenticated!"),UntrustedList,"");
1069
1070    if (_config->FindB("APT::Get::AllowUnauthenticated",false) == true)
1071    {
1072       c2out << _("Authentication warning overridden.\n");
1073       return true;
1074    }
1075
1076    if (_config->FindI("quiet",0) < 2
1077        && _config->FindB("APT::Get::Assume-Yes",false) == false)
1078    {
1079       c2out << _("Install these packages without verification [y/N]? ") << flush;
1080       if (!YnPrompt(false))
1081          return _error->Error(_("Some packages could not be authenticated"));
1082
1083       return true;
1084    }
1085    else if (_config->FindB("APT::Get::Force-Yes",false) == true)
1086    {
1087       return true;
1088    }
1089
1090    return _error->Error(_("There are problems and -y was used without --force-yes"));
1091 }
1092                                                                         /*}}}*/
1093 // InstallPackages - Actually download and install the packages         /*{{{*/
1094 // ---------------------------------------------------------------------
1095 /* This displays the informative messages describing what is going to
1096    happen and then calls the download routines */
1097 bool InstallPackages(CacheFile &Cache,bool ShwKept,bool Ask = true,
1098                      bool Safety = true)
1099 {
1100    if (_config->FindB("APT::Get::Purge",false) == true)
1101    {
1102       pkgCache::PkgIterator I = Cache->PkgBegin();
1103       for (; I.end() == false; ++I)
1104       {
1105          if (I.Purge() == false && Cache[I].Mode == pkgDepCache::ModeDelete)
1106             Cache->MarkDelete(I,true);
1107       }
1108    }
1109
1110    bool Fail = false;
1111    bool Essential = false;
1112
1113    // Show all the various warning indicators
1114    ShowDel(c1out,Cache);
1115    ShowNew(c1out,Cache);
1116    if (ShwKept == true)
1117       ShowKept(c1out,Cache);
1118    Fail |= !ShowHold(c1out,Cache);
1119    if (_config->FindB("APT::Get::Show-Upgraded",true) == true)
1120       ShowUpgraded(c1out,Cache);
1121    Fail |= !ShowDowngraded(c1out,Cache);
1122    if (_config->FindB("APT::Get::Download-Only",false) == false)
1123         Essential = !ShowEssential(c1out,Cache);
1124    Fail |= Essential;
1125    Stats(c1out,Cache);
1126
1127    // Sanity check
1128    if (Cache->BrokenCount() != 0)
1129    {
1130       ShowBroken(c1out,Cache,false);
1131       return _error->Error(_("Internal error, InstallPackages was called with broken packages!"));
1132    }
1133
1134    if (Cache->DelCount() == 0 && Cache->InstCount() == 0 &&
1135        Cache->BadCount() == 0)
1136       return true;
1137
1138    // No remove flag
1139    if (Cache->DelCount() != 0 && _config->FindB("APT::Get::Remove",true) == false)
1140       return _error->Error(_("Packages need to be removed but remove is disabled."));
1141
1142    // Run the simulator ..
1143    if (_config->FindB("APT::Get::Simulate") == true)
1144    {
1145       pkgSimulate PM(Cache);
1146       int status_fd = _config->FindI("APT::Status-Fd",-1);
1147       pkgPackageManager::OrderResult Res = PM.DoInstall(status_fd);
1148       if (Res == pkgPackageManager::Failed)
1149          return false;
1150       if (Res != pkgPackageManager::Completed)
1151          return _error->Error(_("Internal error, Ordering didn't finish"));
1152       return true;
1153    }
1154
1155    // Create the text record parser
1156    pkgRecords Recs(Cache);
1157    if (_error->PendingError() == true)
1158       return false;
1159
1160    // Create the download object
1161    pkgAcquire Fetcher;
1162    AcqTextStatus Stat(ScreenWidth,_config->FindI("quiet",0));
1163    if (_config->FindB("APT::Get::Print-URIs", false) == true)
1164    {
1165       // force a hashsum for compatibility reasons
1166       _config->CndSet("Acquire::ForceHash", "md5sum");
1167    }
1168    else if (Fetcher.Setup(&Stat, _config->FindDir("Dir::Cache::Archives")) == false)
1169       return false;
1170
1171    // Read the source list
1172    if (Cache.BuildSourceList() == false)
1173       return false;
1174    pkgSourceList *List = Cache.GetSourceList();
1175
1176    // Create the package manager and prepare to download
1177    SPtr<pkgPackageManager> PM= _system->CreatePM(Cache);
1178    if (PM->GetArchives(&Fetcher,List,&Recs) == false ||
1179        _error->PendingError() == true)
1180       return false;
1181
1182    // Display statistics
1183    unsigned long long FetchBytes = Fetcher.FetchNeeded();
1184    unsigned long long FetchPBytes = Fetcher.PartialPresent();
1185    unsigned long long DebBytes = Fetcher.TotalNeeded();
1186    if (DebBytes != Cache->DebSize())
1187    {
1188       c0out << DebBytes << ',' << Cache->DebSize() << endl;
1189       c0out << _("How odd.. The sizes didn't match, email apt@packages.debian.org") << endl;
1190    }
1191
1192    // Number of bytes
1193    if (DebBytes != FetchBytes)
1194       //TRANSLATOR: The required space between number and unit is already included
1195       // in the replacement strings, so %sB will be correctly translate in e.g. 1,5 MB
1196       ioprintf(c1out,_("Need to get %sB/%sB of archives.\n"),
1197                SizeToStr(FetchBytes).c_str(),SizeToStr(DebBytes).c_str());
1198    else if (DebBytes != 0)
1199       //TRANSLATOR: The required space between number and unit is already included
1200       // in the replacement string, so %sB will be correctly translate in e.g. 1,5 MB
1201       ioprintf(c1out,_("Need to get %sB of archives.\n"),
1202                SizeToStr(DebBytes).c_str());
1203
1204    // Size delta
1205    if (Cache->UsrSize() >= 0)
1206       //TRANSLATOR: The required space between number and unit is already included
1207       // in the replacement string, so %sB will be correctly translate in e.g. 1,5 MB
1208       ioprintf(c1out,_("After this operation, %sB of additional disk space will be used.\n"),
1209                SizeToStr(Cache->UsrSize()).c_str());
1210    else
1211       //TRANSLATOR: The required space between number and unit is already included
1212       // in the replacement string, so %sB will be correctly translate in e.g. 1,5 MB
1213       ioprintf(c1out,_("After this operation, %sB disk space will be freed.\n"),
1214                SizeToStr(-1*Cache->UsrSize()).c_str());
1215
1216    if (_error->PendingError() == true)
1217       return false;
1218
1219    /* Check for enough free space, but only if we are actually going to
1220       download */
1221    if (_config->FindB("APT::Get::Print-URIs") == false &&
1222        _config->FindB("APT::Get::Download",true) == true)
1223    {
1224       struct statvfs Buf;
1225       string OutputDir = _config->FindDir("Dir::Cache::Archives");
1226       if (statvfs(OutputDir.c_str(),&Buf) != 0) {
1227          if (errno == EOVERFLOW)
1228             return _error->WarningE("statvfs",_("Couldn't determine free space in %s"),
1229                                  OutputDir.c_str());
1230          else
1231             return _error->Errno("statvfs",_("Couldn't determine free space in %s"),
1232                                  OutputDir.c_str());
1233       } else if (unsigned(Buf.f_bfree) < (FetchBytes - FetchPBytes)/Buf.f_bsize)
1234       {
1235          struct statfs Stat;
1236          if (statfs(OutputDir.c_str(),&Stat) != 0
1237 #if HAVE_STRUCT_STATFS_F_TYPE
1238              || unsigned(Stat.f_type) != RAMFS_MAGIC
1239 #endif
1240              )
1241             return _error->Error(_("You don't have enough free space in %s."),
1242                 OutputDir.c_str());
1243       }
1244    }
1245
1246    // Fail safe check
1247    if (_config->FindI("quiet",0) >= 2 ||
1248        _config->FindB("APT::Get::Assume-Yes",false) == true)
1249    {
1250       if (Fail == true && _config->FindB("APT::Get::Force-Yes",false) == false)
1251          return _error->Error(_("There are problems and -y was used without --force-yes"));
1252    }
1253
1254    if (Essential == true && Safety == true)
1255    {
1256       if (_config->FindB("APT::Get::Trivial-Only",false) == true)
1257          return _error->Error(_("Trivial Only specified but this is not a trivial operation."));
1258
1259       // TRANSLATOR: This string needs to be typed by the user as a confirmation, so be
1260       //             careful with hard to type or special characters (like non-breaking spaces)
1261       const char *Prompt = _("Yes, do as I say!");
1262       ioprintf(c2out,
1263                _("You are about to do something potentially harmful.\n"
1264                  "To continue type in the phrase '%s'\n"
1265                  " ?] "),Prompt);
1266       c2out << flush;
1267       if (AnalPrompt(Prompt) == false)
1268       {
1269          c2out << _("Abort.") << endl;
1270          exit(1);
1271       }
1272    }
1273    else
1274    {
1275       // Prompt to continue
1276       if (Ask == true || Fail == true)
1277       {
1278          if (_config->FindB("APT::Get::Trivial-Only",false) == true)
1279             return _error->Error(_("Trivial Only specified but this is not a trivial operation."));
1280
1281          if (_config->FindI("quiet",0) < 2 &&
1282              _config->FindB("APT::Get::Assume-Yes",false) == false)
1283          {
1284             c2out << _("Do you want to continue [Y/n]? ") << flush;
1285
1286             if (YnPrompt() == false)
1287             {
1288                c2out << _("Abort.") << endl;
1289                exit(1);
1290             }
1291          }
1292       }
1293    }
1294
1295    // Just print out the uris an exit if the --print-uris flag was used
1296    if (_config->FindB("APT::Get::Print-URIs") == true)
1297    {
1298       pkgAcquire::UriIterator I = Fetcher.UriBegin();
1299       for (; I != Fetcher.UriEnd(); ++I)
1300          cout << '\'' << I->URI << "' " << flNotDir(I->Owner->DestFile) << ' ' <<
1301                I->Owner->FileSize << ' ' << I->Owner->HashSum() << endl;
1302       return true;
1303    }
1304
1305    if (!CheckAuth(Fetcher))
1306       return false;
1307
1308    /* Unlock the dpkg lock if we are not going to be doing an install
1309       after. */
1310    if (_config->FindB("APT::Get::Download-Only",false) == true)
1311       _system->UnLock();
1312
1313    // Run it
1314    while (1)
1315    {
1316       bool Transient = false;
1317       if (_config->FindB("APT::Get::Download",true) == false)
1318       {
1319          for (pkgAcquire::ItemIterator I = Fetcher.ItemsBegin(); I < Fetcher.ItemsEnd();)
1320          {
1321             if ((*I)->Local == true)
1322             {
1323                ++I;
1324                continue;
1325             }
1326
1327             // Close the item and check if it was found in cache
1328             (*I)->Finished();
1329             if ((*I)->Complete == false)
1330                Transient = true;
1331
1332             // Clear it out of the fetch list
1333             delete *I;
1334             I = Fetcher.ItemsBegin();
1335          }
1336       }
1337
1338       if (Fetcher.Run() == pkgAcquire::Failed)
1339          return false;
1340
1341       // Print out errors
1342       bool Failed = false;
1343       for (pkgAcquire::ItemIterator I = Fetcher.ItemsBegin(); I != Fetcher.ItemsEnd(); ++I)
1344       {
1345          if ((*I)->Status == pkgAcquire::Item::StatDone &&
1346              (*I)->Complete == true)
1347             continue;
1348
1349          if ((*I)->Status == pkgAcquire::Item::StatIdle)
1350          {
1351             Transient = true;
1352             // Failed = true;
1353             continue;
1354          }
1355
1356          fprintf(stderr,_("Failed to fetch %s  %s\n"),(*I)->DescURI().c_str(),
1357                  (*I)->ErrorText.c_str());
1358          Failed = true;
1359       }
1360
1361       /* If we are in no download mode and missing files and there were
1362          'failures' then the user must specify -m. Furthermore, there
1363          is no such thing as a transient error in no-download mode! */
1364       if (Transient == true &&
1365           _config->FindB("APT::Get::Download",true) == false)
1366       {
1367          Transient = false;
1368          Failed = true;
1369       }
1370
1371       if (_config->FindB("APT::Get::Download-Only",false) == true)
1372       {
1373          if (Failed == true && _config->FindB("APT::Get::Fix-Missing",false) == false)
1374             return _error->Error(_("Some files failed to download"));
1375          c1out << _("Download complete and in download only mode") << endl;
1376          return true;
1377       }
1378
1379       if (Failed == true && _config->FindB("APT::Get::Fix-Missing",false) == false)
1380       {
1381          return _error->Error(_("Unable to fetch some archives, maybe run apt-get update or try with --fix-missing?"));
1382       }
1383
1384       if (Transient == true && Failed == true)
1385          return _error->Error(_("--fix-missing and media swapping is not currently supported"));
1386
1387       // Try to deal with missing package files
1388       if (Failed == true && PM->FixMissing() == false)
1389       {
1390          cerr << _("Unable to correct missing packages.") << endl;
1391          return _error->Error(_("Aborting install."));
1392       }
1393
1394       _system->UnLock();
1395       int status_fd = _config->FindI("APT::Status-Fd",-1);
1396       pkgPackageManager::OrderResult Res = PM->DoInstall(status_fd);
1397       if (Res == pkgPackageManager::Failed || _error->PendingError() == true)
1398          return false;
1399       if (Res == pkgPackageManager::Completed)
1400          break;
1401
1402       // Reload the fetcher object and loop again for media swapping
1403       Fetcher.Shutdown();
1404       if (PM->GetArchives(&Fetcher,List,&Recs) == false)
1405          return false;
1406
1407       _system->Lock();
1408    }
1409
1410    std::set<std::string> const disappearedPkgs = PM->GetDisappearedPackages();
1411    if (disappearedPkgs.empty() == true)
1412       return true;
1413
1414    string disappear;
1415    for (std::set<std::string>::const_iterator d = disappearedPkgs.begin();
1416         d != disappearedPkgs.end(); ++d)
1417       disappear.append(*d).append(" ");
1418
1419    ShowList(c1out, P_("The following package disappeared from your system as\n"
1420         "all files have been overwritten by other packages:",
1421         "The following packages disappeared from your system as\n"
1422         "all files have been overwritten by other packages:", disappearedPkgs.size()), disappear, "");
1423    c0out << _("Note: This is done automatically and on purpose by dpkg.") << std::endl;
1424
1425    return true;
1426 }
1427                                                                         /*}}}*/
1428 // TryToInstallBuildDep - Try to install a single package               /*{{{*/
1429 // ---------------------------------------------------------------------
1430 /* This used to be inlined in DoInstall, but with the advent of regex package
1431    name matching it was split out.. */
1432 bool TryToInstallBuildDep(pkgCache::PkgIterator Pkg,pkgCacheFile &Cache,
1433                   pkgProblemResolver &Fix,bool Remove,bool BrokenFix,
1434                   bool AllowFail = true)
1435 {
1436    if (Cache[Pkg].CandidateVer == 0 && Pkg->ProvidesList != 0)
1437    {
1438       CacheSetHelperAPTGet helper(c1out);
1439       helper.showErrors(false);
1440       pkgCache::VerIterator Ver = helper.canNotFindNewestVer(Cache, Pkg);
1441       if (Ver.end() == false)
1442          Pkg = Ver.ParentPkg();
1443       else if (helper.showVirtualPackageErrors(Cache) == false)
1444          return AllowFail;
1445    }
1446
1447    if (_config->FindB("Debug::BuildDeps",false) == true)
1448    {
1449       if (Remove == true)
1450          cout << "  Trying to remove " << Pkg << endl;
1451       else
1452          cout << "  Trying to install " << Pkg << endl;
1453    }
1454
1455    if (Remove == true)
1456    {
1457       TryToRemove RemoveAction(Cache, &Fix);
1458       RemoveAction(Pkg.VersionList());
1459    } else if (Cache[Pkg].CandidateVer != 0) {
1460       TryToInstall InstallAction(Cache, &Fix, BrokenFix);
1461       InstallAction(Cache[Pkg].CandidateVerIter(Cache));
1462       InstallAction.doAutoInstall();
1463    } else
1464       return AllowFail;
1465
1466    return true;
1467 }
1468                                                                         /*}}}*/
1469 // FindSrc - Find a source record                                       /*{{{*/
1470 // ---------------------------------------------------------------------
1471 /* */
1472 pkgSrcRecords::Parser *FindSrc(const char *Name,pkgRecords &Recs,
1473                                pkgSrcRecords &SrcRecs,string &Src,
1474                                pkgDepCache &Cache)
1475 {
1476    string VerTag;
1477    string DefRel = _config->Find("APT::Default-Release");
1478    string TmpSrc = Name;
1479
1480    // extract the version/release from the pkgname
1481    const size_t found = TmpSrc.find_last_of("/=");
1482    if (found != string::npos) {
1483       if (TmpSrc[found] == '/')
1484          DefRel = TmpSrc.substr(found+1);
1485       else
1486          VerTag = TmpSrc.substr(found+1);
1487       TmpSrc = TmpSrc.substr(0,found);
1488    }
1489
1490    /* Lookup the version of the package we would install if we were to
1491       install a version and determine the source package name, then look
1492       in the archive for a source package of the same name. */
1493    bool MatchSrcOnly = _config->FindB("APT::Get::Only-Source");
1494    const pkgCache::PkgIterator Pkg = Cache.FindPkg(TmpSrc);
1495    if (MatchSrcOnly == false && Pkg.end() == false)
1496    {
1497       if(VerTag.empty() == false || DefRel.empty() == false)
1498       {
1499          bool fuzzy = false;
1500          // we have a default release, try to locate the pkg. we do it like
1501          // this because GetCandidateVer() will not "downgrade", that means
1502          // "apt-get source -t stable apt" won't work on a unstable system
1503          for (pkgCache::VerIterator Ver = Pkg.VersionList();; ++Ver)
1504          {
1505             // try first only exact matches, later fuzzy matches
1506             if (Ver.end() == true)
1507             {
1508                if (fuzzy == true)
1509                   break;
1510                fuzzy = true;
1511                Ver = Pkg.VersionList();
1512                // exit right away from the Pkg.VersionList() loop if we
1513                // don't have any versions
1514                if (Ver.end() == true)
1515                   break;
1516             }
1517             // We match against a concrete version (or a part of this version)
1518             if (VerTag.empty() == false &&
1519                 (fuzzy == true || Cache.VS().CmpVersion(VerTag, Ver.VerStr()) != 0) && // exact match
1520                 (fuzzy == false || strncmp(VerTag.c_str(), Ver.VerStr(), VerTag.size()) != 0)) // fuzzy match
1521                continue;
1522
1523             for (pkgCache::VerFileIterator VF = Ver.FileList();
1524                  VF.end() == false; ++VF)
1525             {
1526                /* If this is the status file, and the current version is not the
1527                   version in the status file (ie it is not installed, or somesuch)
1528                   then it is not a candidate for installation, ever. This weeds
1529                   out bogus entries that may be due to config-file states, or
1530                   other. */
1531                if ((VF.File()->Flags & pkgCache::Flag::NotSource) ==
1532                    pkgCache::Flag::NotSource && Pkg.CurrentVer() != Ver)
1533                   continue;
1534
1535                // or we match against a release
1536                if(VerTag.empty() == false ||
1537                   (VF.File().Archive() != 0 && VF.File().Archive() == DefRel) ||
1538                   (VF.File().Codename() != 0 && VF.File().Codename() == DefRel))
1539                {
1540                   pkgRecords::Parser &Parse = Recs.Lookup(VF);
1541                   Src = Parse.SourcePkg();
1542                   // no SourcePkg name, so it is the "binary" name
1543                   if (Src.empty() == true)
1544                      Src = TmpSrc;
1545                   // the Version we have is possibly fuzzy or includes binUploads,
1546                   // so we use the Version of the SourcePkg (empty if same as package)
1547                   VerTag = Parse.SourceVer();
1548                   if (VerTag.empty() == true)
1549                      VerTag = Ver.VerStr();
1550                   break;
1551                }
1552             }
1553             if (Src.empty() == false)
1554                break;
1555          }
1556          if (Src.empty() == true)
1557          {
1558             // Sources files have no codename information
1559             if (VerTag.empty() == true && DefRel.empty() == false)
1560             {
1561                _error->Error(_("Ignore unavailable target release '%s' of package '%s'"), DefRel.c_str(), TmpSrc.c_str());
1562                return 0;
1563             }
1564          }
1565       }
1566       if (Src.empty() == true)
1567       {
1568          // if we don't have found a fitting package yet so we will
1569          // choose a good candidate and proceed with that.
1570          // Maybe we will find a source later on with the right VerTag
1571          pkgCache::VerIterator Ver = Cache.GetCandidateVer(Pkg);
1572          if (Ver.end() == false)
1573          {
1574             pkgRecords::Parser &Parse = Recs.Lookup(Ver.FileList());
1575             Src = Parse.SourcePkg();
1576             if (VerTag.empty() == true)
1577                VerTag = Parse.SourceVer();
1578          }
1579       }
1580    }
1581
1582    if (Src.empty() == true)
1583       Src = TmpSrc;
1584    else
1585    {
1586       /* if we have a source pkg name, make sure to only search
1587          for srcpkg names, otherwise apt gets confused if there
1588          is a binary package "pkg1" and a source package "pkg1"
1589          with the same name but that comes from different packages */
1590       MatchSrcOnly = true;
1591       if (Src != TmpSrc)
1592       {
1593          ioprintf(c1out, _("Picking '%s' as source package instead of '%s'\n"), Src.c_str(), TmpSrc.c_str());
1594       }
1595    }
1596
1597    // The best hit
1598    pkgSrcRecords::Parser *Last = 0;
1599    unsigned long Offset = 0;
1600    string Version;
1601
1602    /* Iterate over all of the hits, which includes the resulting
1603       binary packages in the search */
1604    pkgSrcRecords::Parser *Parse;
1605    while (true)
1606    {
1607       SrcRecs.Restart();
1608       while ((Parse = SrcRecs.Find(Src.c_str(), MatchSrcOnly)) != 0)
1609       {
1610          const string Ver = Parse->Version();
1611
1612          // Ignore all versions which doesn't fit
1613          if (VerTag.empty() == false &&
1614              Cache.VS().CmpVersion(VerTag, Ver) != 0) // exact match
1615             continue;
1616
1617          // Newer version or an exact match? Save the hit
1618          if (Last == 0 || Cache.VS().CmpVersion(Version,Ver) < 0) {
1619             Last = Parse;
1620             Offset = Parse->Offset();
1621             Version = Ver;
1622          }
1623
1624          // was the version check above an exact match? If so, we don't need to look further
1625          if (VerTag.empty() == false && VerTag.size() == Ver.size())
1626             break;
1627       }
1628       if (Last != 0 || VerTag.empty() == true)
1629          break;
1630       //if (VerTag.empty() == false && Last == 0)
1631       _error->Error(_("Ignore unavailable version '%s' of package '%s'"), VerTag.c_str(), TmpSrc.c_str());
1632       return 0;
1633    }
1634
1635    if (Last == 0 || Last->Jump(Offset) == false)
1636       return 0;
1637
1638    return Last;
1639 }
1640                                                                         /*}}}*/
1641 // DoUpdate - Update the package lists                                  /*{{{*/
1642 // ---------------------------------------------------------------------
1643 /* */
1644 bool DoUpdate(CommandLine &CmdL)
1645 {
1646    if (CmdL.FileSize() != 1)
1647       return _error->Error(_("The update command takes no arguments"));
1648
1649    CacheFile Cache;
1650
1651    // Get the source list
1652    if (Cache.BuildSourceList() == false)
1653       return false;
1654    pkgSourceList *List = Cache.GetSourceList();
1655
1656    // Create the progress
1657    AcqTextStatus Stat(ScreenWidth,_config->FindI("quiet",0));
1658
1659    // Just print out the uris an exit if the --print-uris flag was used
1660    if (_config->FindB("APT::Get::Print-URIs") == true)
1661    {
1662       // force a hashsum for compatibility reasons
1663       _config->CndSet("Acquire::ForceHash", "md5sum");
1664
1665       // get a fetcher
1666       pkgAcquire Fetcher;
1667       if (Fetcher.Setup(&Stat) == false)
1668          return false;
1669
1670       // Populate it with the source selection and get all Indexes
1671       // (GetAll=true)
1672       if (List->GetIndexes(&Fetcher,true) == false)
1673          return false;
1674
1675       pkgAcquire::UriIterator I = Fetcher.UriBegin();
1676       for (; I != Fetcher.UriEnd(); ++I)
1677          cout << '\'' << I->URI << "' " << flNotDir(I->Owner->DestFile) << ' ' <<
1678                I->Owner->FileSize << ' ' << I->Owner->HashSum() << endl;
1679       return true;
1680    }
1681
1682    // do the work
1683    if (_config->FindB("APT::Get::Download",true) == true)
1684        ListUpdate(Stat, *List);
1685
1686    // Rebuild the cache.
1687    if (_config->FindB("pkgCacheFile::Generate", true) == true)
1688    {
1689       pkgCacheFile::RemoveCaches();
1690       if (Cache.BuildCaches() == false)
1691          return false;
1692    }
1693
1694    return true;
1695 }
1696                                                                         /*}}}*/
1697 // DoAutomaticRemove - Remove all automatic unused packages             /*{{{*/
1698 // ---------------------------------------------------------------------
1699 /* Remove unused automatic packages */
1700 bool DoAutomaticRemove(CacheFile &Cache)
1701 {
1702    bool Debug = _config->FindI("Debug::pkgAutoRemove",false);
1703    bool doAutoRemove = _config->FindB("APT::Get::AutomaticRemove", false);
1704    bool hideAutoRemove = _config->FindB("APT::Get::HideAutoRemove");
1705
1706    pkgDepCache::ActionGroup group(*Cache);
1707    if(Debug)
1708       std::cout << "DoAutomaticRemove()" << std::endl;
1709
1710    if (doAutoRemove == true &&
1711         _config->FindB("APT::Get::Remove",true) == false)
1712    {
1713       c1out << _("We are not supposed to delete stuff, can't start "
1714                  "AutoRemover") << std::endl;
1715       return false;
1716    }
1717
1718    bool purgePkgs = _config->FindB("APT::Get::Purge", false);
1719    bool smallList = (hideAutoRemove == false &&
1720                 strcasecmp(_config->Find("APT::Get::HideAutoRemove","").c_str(),"small") == 0);
1721
1722    unsigned long autoRemoveCount = 0;
1723    APT::PackageSet tooMuch;
1724    APT::PackageList autoRemoveList;
1725    // look over the cache to see what can be removed
1726    for (unsigned J = 0; J < Cache->Head().PackageCount; ++J)
1727    {
1728       pkgCache::PkgIterator Pkg(Cache,Cache.List[J]);
1729       if (Cache[Pkg].Garbage)
1730       {
1731          if(Pkg.CurrentVer() != 0 || Cache[Pkg].Install())
1732             if(Debug)
1733                std::cout << "We could delete %s" <<  Pkg.FullName(true).c_str() << std::endl;
1734
1735          if (doAutoRemove)
1736          {
1737             if(Pkg.CurrentVer() != 0 &&
1738                Pkg->CurrentState != pkgCache::State::ConfigFiles)
1739                Cache->MarkDelete(Pkg, purgePkgs, 0, false);
1740             else
1741                Cache->MarkKeep(Pkg, false, false);
1742          }
1743          else
1744          {
1745             if (hideAutoRemove == false && Cache[Pkg].Delete() == false)
1746                autoRemoveList.insert(Pkg);
1747             // if the package is a new install and already garbage we don't need to
1748             // install it in the first place, so nuke it instead of show it
1749             if (Cache[Pkg].Install() == true && Pkg.CurrentVer() == 0)
1750             {
1751                if (Pkg.CandVersion() != 0)
1752                   tooMuch.insert(Pkg);
1753                Cache->MarkDelete(Pkg, false, 0, false);
1754             }
1755             // only show stuff in the list that is not yet marked for removal
1756             else if(hideAutoRemove == false && Cache[Pkg].Delete() == false)
1757                ++autoRemoveCount;
1758          }
1759       }
1760    }
1761
1762    // we could have removed a new dependency of a garbage package,
1763    // so check if a reverse depends is broken and if so install it again.
1764    if (tooMuch.empty() == false && (Cache->BrokenCount() != 0 || Cache->PolicyBrokenCount() != 0))
1765    {
1766       bool Changed;
1767       do {
1768          Changed = false;
1769          for (APT::PackageSet::const_iterator Pkg = tooMuch.begin();
1770               Pkg != tooMuch.end() && Changed == false; ++Pkg)
1771          {
1772             APT::PackageSet too;
1773             too.insert(*Pkg);
1774             for (pkgCache::PrvIterator Prv = Cache[Pkg].CandidateVerIter(Cache).ProvidesList();
1775                  Prv.end() == false; ++Prv)
1776                too.insert(Prv.ParentPkg());
1777             for (APT::PackageSet::const_iterator P = too.begin();
1778                  P != too.end() && Changed == false; ++P) {
1779                for (pkgCache::DepIterator R = P.RevDependsList();
1780                     R.end() == false; ++R)
1781                {
1782                   if (R.IsNegative() == true ||
1783                       Cache->IsImportantDep(R) == false)
1784                      continue;
1785                  pkgCache::PkgIterator N = R.ParentPkg();
1786                  if (N.end() == true || (N->CurrentVer == 0 && (*Cache)[N].Install() == false))
1787                     continue;
1788                  if (Debug == true)
1789                     std::clog << "Save " << Pkg << " as another installed garbage package depends on it" << std::endl;
1790                  Cache->MarkInstall(Pkg, false, 0, false);
1791                  if (hideAutoRemove == false)
1792                     ++autoRemoveCount;
1793                  tooMuch.erase(Pkg);
1794                  Changed = true;
1795                  break;
1796                }
1797             }
1798          }
1799       } while (Changed == true);
1800    }
1801
1802    std::string autoremovelist, autoremoveversions;
1803    if (smallList == false && autoRemoveCount != 0)
1804    {
1805       for (APT::PackageList::const_iterator Pkg = autoRemoveList.begin(); Pkg != autoRemoveList.end(); ++Pkg)
1806       {
1807          if (Cache[Pkg].Garbage == false)
1808             continue;
1809          autoremovelist += Pkg.FullName(true) + " ";
1810          autoremoveversions += string(Cache[Pkg].CandVersion) + "\n";
1811       }
1812    }
1813
1814    // Now see if we had destroyed anything (if we had done anything)
1815    if (Cache->BrokenCount() != 0)
1816    {
1817       c1out << _("Hmm, seems like the AutoRemover destroyed something which really\n"
1818                  "shouldn't happen. Please file a bug report against apt.") << endl;
1819       c1out << endl;
1820       c1out << _("The following information may help to resolve the situation:") << endl;
1821       c1out << endl;
1822       ShowBroken(c1out,Cache,false);
1823
1824       return _error->Error(_("Internal Error, AutoRemover broke stuff"));
1825    }
1826
1827    // if we don't remove them, we should show them!
1828    if (doAutoRemove == false && (autoremovelist.empty() == false || autoRemoveCount != 0))
1829    {
1830       if (smallList == false)
1831          ShowList(c1out, P_("The following package was automatically installed and is no longer required:",
1832                   "The following packages were automatically installed and are no longer required:",
1833                   autoRemoveCount), autoremovelist, autoremoveversions);
1834       else
1835          ioprintf(c1out, P_("%lu package was automatically installed and is no longer required.\n",
1836                   "%lu packages were automatically installed and are no longer required.\n", autoRemoveCount), autoRemoveCount);
1837       c1out << P_("Use 'apt-get autoremove' to remove it.", "Use 'apt-get autoremove' to remove them.", autoRemoveCount) << std::endl;
1838    }
1839    return true;
1840 }
1841                                                                         /*}}}*/
1842 // DoUpgrade - Upgrade all packages                                     /*{{{*/
1843 // ---------------------------------------------------------------------
1844 /* Upgrade all packages without installing new packages or erasing old
1845    packages */
1846 bool DoUpgrade(CommandLine &CmdL)
1847 {
1848    CacheFile Cache;
1849    if (Cache.OpenForInstall() == false || Cache.CheckDeps() == false)
1850       return false;
1851
1852    // Do the upgrade
1853    if (pkgAllUpgrade(Cache) == false)
1854    {
1855       ShowBroken(c1out,Cache,false);
1856       return _error->Error(_("Internal error, AllUpgrade broke stuff"));
1857    }
1858
1859    return InstallPackages(Cache,true);
1860 }
1861                                                                         /*}}}*/
1862 // DoInstall - Install packages from the command line                   /*{{{*/
1863 // ---------------------------------------------------------------------
1864 /* Install named packages */
1865 bool DoInstall(CommandLine &CmdL)
1866 {
1867    CacheFile Cache;
1868    if (Cache.OpenForInstall() == false ||
1869        Cache.CheckDeps(CmdL.FileSize() != 1) == false)
1870       return false;
1871
1872    // Enter the special broken fixing mode if the user specified arguments
1873    bool BrokenFix = false;
1874    if (Cache->BrokenCount() != 0)
1875       BrokenFix = true;
1876
1877    pkgProblemResolver* Fix = NULL;
1878    if (_config->FindB("APT::Get::CallResolver", true) == true)
1879       Fix = new pkgProblemResolver(Cache);
1880
1881    static const unsigned short MOD_REMOVE = 1;
1882    static const unsigned short MOD_INSTALL = 2;
1883
1884    unsigned short fallback = MOD_INSTALL;
1885    if (strcasecmp(CmdL.FileList[0],"remove") == 0)
1886       fallback = MOD_REMOVE;
1887    else if (strcasecmp(CmdL.FileList[0], "purge") == 0)
1888    {
1889       _config->Set("APT::Get::Purge", true);
1890       fallback = MOD_REMOVE;
1891    }
1892    else if (strcasecmp(CmdL.FileList[0], "autoremove") == 0)
1893    {
1894       _config->Set("APT::Get::AutomaticRemove", "true");
1895       fallback = MOD_REMOVE;
1896    }
1897
1898    std::list<APT::VersionSet::Modifier> mods;
1899    mods.push_back(APT::VersionSet::Modifier(MOD_INSTALL, "+",
1900                 APT::VersionSet::Modifier::POSTFIX, APT::VersionSet::CANDIDATE));
1901    mods.push_back(APT::VersionSet::Modifier(MOD_REMOVE, "-",
1902                 APT::VersionSet::Modifier::POSTFIX, APT::VersionSet::NEWEST));
1903    CacheSetHelperAPTGet helper(c0out);
1904    std::map<unsigned short, APT::VersionSet> verset = APT::VersionSet::GroupedFromCommandLine(Cache,
1905                 CmdL.FileList + 1, mods, fallback, helper);
1906
1907    if (_error->PendingError() == true)
1908    {
1909       helper.showVirtualPackageErrors(Cache);
1910       if (Fix != NULL)
1911          delete Fix;
1912       return false;
1913    }
1914
1915
1916   TryToInstall InstallAction(Cache, Fix, BrokenFix);
1917   TryToRemove RemoveAction(Cache, Fix);
1918
1919    // new scope for the ActionGroup
1920    {
1921       pkgDepCache::ActionGroup group(Cache);
1922       unsigned short const order[] = { MOD_REMOVE, MOD_INSTALL, 0 };
1923
1924       for (unsigned short i = 0; order[i] != 0; ++i)
1925       {
1926          if (order[i] == MOD_INSTALL)
1927             InstallAction = std::for_each(verset[MOD_INSTALL].begin(), verset[MOD_INSTALL].end(), InstallAction);
1928          else if (order[i] == MOD_REMOVE)
1929             RemoveAction = std::for_each(verset[MOD_REMOVE].begin(), verset[MOD_REMOVE].end(), RemoveAction);
1930       }
1931
1932       if (Fix != NULL && _config->FindB("APT::Get::AutoSolving", true) == true)
1933       {
1934          for (unsigned short i = 0; order[i] != 0; ++i)
1935          {
1936             if (order[i] != MOD_INSTALL)
1937                continue;
1938             InstallAction.propergateReleaseCandiateSwitching(helper.selectedByRelease, c0out);
1939             InstallAction.doAutoInstall();
1940          }
1941       }
1942
1943       if (_error->PendingError() == true)
1944       {
1945          if (Fix != NULL)
1946             delete Fix;
1947          return false;
1948       }
1949
1950       /* If we are in the Broken fixing mode we do not attempt to fix the
1951          problems. This is if the user invoked install without -f and gave
1952          packages */
1953       if (BrokenFix == true && Cache->BrokenCount() != 0)
1954       {
1955          c1out << _("You might want to run 'apt-get -f install' to correct these:") << endl;
1956          ShowBroken(c1out,Cache,false);
1957          if (Fix != NULL)
1958             delete Fix;
1959          return _error->Error(_("Unmet dependencies. Try 'apt-get -f install' with no packages (or specify a solution)."));
1960       }
1961
1962       if (Fix != NULL)
1963       {
1964          // Call the scored problem resolver
1965          Fix->Resolve(true);
1966          delete Fix;
1967       }
1968
1969       // Now we check the state of the packages,
1970       if (Cache->BrokenCount() != 0)
1971       {
1972          c1out <<
1973             _("Some packages could not be installed. This may mean that you have\n"
1974               "requested an impossible situation or if you are using the unstable\n"
1975               "distribution that some required packages have not yet been created\n"
1976               "or been moved out of Incoming.") << endl;
1977          /*
1978          if (Packages == 1)
1979          {
1980             c1out << endl;
1981             c1out <<
1982                _("Since you only requested a single operation it is extremely likely that\n"
1983                  "the package is simply not installable and a bug report against\n"
1984                  "that package should be filed.") << endl;
1985          }
1986          */
1987
1988          c1out << _("The following information may help to resolve the situation:") << endl;
1989          c1out << endl;
1990          ShowBroken(c1out,Cache,false);
1991          if (_error->PendingError() == true)
1992             return false;
1993          else
1994             return _error->Error(_("Broken packages"));
1995       }
1996    }
1997    if (!DoAutomaticRemove(Cache))
1998       return false;
1999
2000    /* Print out a list of packages that are going to be installed extra
2001       to what the user asked */
2002    if (Cache->InstCount() != verset[MOD_INSTALL].size())
2003    {
2004       string List;
2005       string VersionsList;
2006       for (unsigned J = 0; J < Cache->Head().PackageCount; J++)
2007       {
2008          pkgCache::PkgIterator I(Cache,Cache.List[J]);
2009          if ((*Cache)[I].Install() == false)
2010             continue;
2011          pkgCache::VerIterator Cand = Cache[I].CandidateVerIter(Cache);
2012
2013          if (verset[MOD_INSTALL].find(Cand) != verset[MOD_INSTALL].end())
2014             continue;
2015
2016          List += I.FullName(true) + " ";
2017          VersionsList += string(Cache[I].CandVersion) + "\n";
2018       }
2019
2020       ShowList(c1out,_("The following extra packages will be installed:"),List,VersionsList);
2021    }
2022
2023    /* Print out a list of suggested and recommended packages */
2024    {
2025       string SuggestsList, RecommendsList;
2026       string SuggestsVersions, RecommendsVersions;
2027       for (unsigned J = 0; J < Cache->Head().PackageCount; J++)
2028       {
2029          pkgCache::PkgIterator Pkg(Cache,Cache.List[J]);
2030
2031          /* Just look at the ones we want to install */
2032          if ((*Cache)[Pkg].Install() == false)
2033            continue;
2034
2035          // get the recommends/suggests for the candidate ver
2036          pkgCache::VerIterator CV = (*Cache)[Pkg].CandidateVerIter(*Cache);
2037          for (pkgCache::DepIterator D = CV.DependsList(); D.end() == false; )
2038          {
2039             pkgCache::DepIterator Start;
2040             pkgCache::DepIterator End;
2041             D.GlobOr(Start,End); // advances D
2042
2043             // FIXME: we really should display a or-group as a or-group to the user
2044             //        the problem is that ShowList is incapable of doing this
2045             string RecommendsOrList,RecommendsOrVersions;
2046             string SuggestsOrList,SuggestsOrVersions;
2047             bool foundInstalledInOrGroup = false;
2048             for(;;)
2049             {
2050                /* Skip if package is  installed already, or is about to be */
2051                string target = Start.TargetPkg().FullName(true) + " ";
2052                pkgCache::PkgIterator const TarPkg = Start.TargetPkg();
2053                if (TarPkg->SelectedState == pkgCache::State::Install ||
2054                    TarPkg->SelectedState == pkgCache::State::Hold ||
2055                    Cache[Start.TargetPkg()].Install())
2056                {
2057                   foundInstalledInOrGroup=true;
2058                   break;
2059                }
2060
2061                /* Skip if we already saw it */
2062                if (int(SuggestsList.find(target)) != -1 || int(RecommendsList.find(target)) != -1)
2063                {
2064                   foundInstalledInOrGroup=true;
2065                   break;
2066                }
2067
2068                // this is a dep on a virtual pkg, check if any package that provides it
2069                // should be installed
2070                if(Start.TargetPkg().ProvidesList() != 0)
2071                {
2072                   pkgCache::PrvIterator I = Start.TargetPkg().ProvidesList();
2073                   for (; I.end() == false; ++I)
2074                   {
2075                      pkgCache::PkgIterator Pkg = I.OwnerPkg();
2076                      if (Cache[Pkg].CandidateVerIter(Cache) == I.OwnerVer() &&
2077                          Pkg.CurrentVer() != 0)
2078                         foundInstalledInOrGroup=true;
2079                   }
2080                }
2081
2082                if (Start->Type == pkgCache::Dep::Suggests)
2083                {
2084                   SuggestsOrList += target;
2085                   SuggestsOrVersions += string(Cache[Start.TargetPkg()].CandVersion) + "\n";
2086                }
2087
2088                if (Start->Type == pkgCache::Dep::Recommends)
2089                {
2090                   RecommendsOrList += target;
2091                   RecommendsOrVersions += string(Cache[Start.TargetPkg()].CandVersion) + "\n";
2092                }
2093
2094                if (Start >= End)
2095                   break;
2096                ++Start;
2097             }
2098
2099             if(foundInstalledInOrGroup == false)
2100             {
2101                RecommendsList += RecommendsOrList;
2102                RecommendsVersions += RecommendsOrVersions;
2103                SuggestsList += SuggestsOrList;
2104                SuggestsVersions += SuggestsOrVersions;
2105             }
2106
2107          }
2108       }
2109
2110       ShowList(c1out,_("Suggested packages:"),SuggestsList,SuggestsVersions);
2111       ShowList(c1out,_("Recommended packages:"),RecommendsList,RecommendsVersions);
2112
2113    }
2114
2115    // if nothing changed in the cache, but only the automark information
2116    // we write the StateFile here, otherwise it will be written in
2117    // cache.commit()
2118    if (InstallAction.AutoMarkChanged > 0 &&
2119        Cache->DelCount() == 0 && Cache->InstCount() == 0 &&
2120        Cache->BadCount() == 0 &&
2121        _config->FindB("APT::Get::Simulate",false) == false)
2122       Cache->writeStateFile(NULL);
2123
2124    // See if we need to prompt
2125    // FIXME: check if really the packages in the set are going to be installed
2126    if (Cache->InstCount() == verset[MOD_INSTALL].size() && Cache->DelCount() == 0)
2127       return InstallPackages(Cache,false,false);
2128
2129    return InstallPackages(Cache,false);
2130 }
2131                                                                         /*}}}*/
2132 /* mark packages as automatically/manually installed.                   {{{*/
2133 bool DoMarkAuto(CommandLine &CmdL)
2134 {
2135    bool Action = true;
2136    int AutoMarkChanged = 0;
2137    OpTextProgress progress;
2138    CacheFile Cache;
2139    if (Cache.Open() == false)
2140       return false;
2141
2142    if (strcasecmp(CmdL.FileList[0],"markauto") == 0)
2143       Action = true;
2144    else if (strcasecmp(CmdL.FileList[0],"unmarkauto") == 0)
2145       Action = false;
2146
2147    for (const char **I = CmdL.FileList + 1; *I != 0; I++)
2148    {
2149       const char *S = *I;
2150       // Locate the package
2151       pkgCache::PkgIterator Pkg = Cache->FindPkg(S);
2152       if (Pkg.end() == true) {
2153          return _error->Error(_("Couldn't find package %s"),S);
2154       }
2155       else
2156       {
2157          if (!Action)
2158             ioprintf(c1out,_("%s set to manually installed.\n"), Pkg.Name());
2159          else
2160             ioprintf(c1out,_("%s set to automatically installed.\n"),
2161                       Pkg.Name());
2162
2163          Cache->MarkAuto(Pkg,Action);
2164          AutoMarkChanged++;
2165       }
2166    }
2167
2168    _error->Notice(_("This command is deprecated. Please use 'apt-mark auto' and 'apt-mark manual' instead."));
2169
2170    if (AutoMarkChanged && ! _config->FindB("APT::Get::Simulate",false))
2171       return Cache->writeStateFile(NULL);
2172    return false;
2173 }
2174                                                                         /*}}}*/
2175 // DoDistUpgrade - Automatic smart upgrader                             /*{{{*/
2176 // ---------------------------------------------------------------------
2177 /* Intelligent upgrader that will install and remove packages at will */
2178 bool DoDistUpgrade(CommandLine &CmdL)
2179 {
2180    CacheFile Cache;
2181    if (Cache.OpenForInstall() == false || Cache.CheckDeps() == false)
2182       return false;
2183
2184    c0out << _("Calculating upgrade... ") << flush;
2185    if (pkgDistUpgrade(*Cache) == false)
2186    {
2187       c0out << _("Failed") << endl;
2188       ShowBroken(c1out,Cache,false);
2189       return false;
2190    }
2191
2192    c0out << _("Done") << endl;
2193
2194    return InstallPackages(Cache,true);
2195 }
2196                                                                         /*}}}*/
2197 // DoDSelectUpgrade - Do an upgrade by following dselects selections    /*{{{*/
2198 // ---------------------------------------------------------------------
2199 /* Follows dselect's selections */
2200 bool DoDSelectUpgrade(CommandLine &CmdL)
2201 {
2202    CacheFile Cache;
2203    if (Cache.OpenForInstall() == false || Cache.CheckDeps() == false)
2204       return false;
2205
2206    pkgDepCache::ActionGroup group(Cache);
2207
2208    // Install everything with the install flag set
2209    pkgCache::PkgIterator I = Cache->PkgBegin();
2210    for (;I.end() != true; ++I)
2211    {
2212       /* Install the package only if it is a new install, the autoupgrader
2213          will deal with the rest */
2214       if (I->SelectedState == pkgCache::State::Install)
2215          Cache->MarkInstall(I,false);
2216    }
2217
2218    /* Now install their deps too, if we do this above then order of
2219       the status file is significant for | groups */
2220    for (I = Cache->PkgBegin();I.end() != true; ++I)
2221    {
2222       /* Install the package only if it is a new install, the autoupgrader
2223          will deal with the rest */
2224       if (I->SelectedState == pkgCache::State::Install)
2225          Cache->MarkInstall(I,true);
2226    }
2227
2228    // Apply erasures now, they override everything else.
2229    for (I = Cache->PkgBegin();I.end() != true; ++I)
2230    {
2231       // Remove packages
2232       if (I->SelectedState == pkgCache::State::DeInstall ||
2233           I->SelectedState == pkgCache::State::Purge)
2234          Cache->MarkDelete(I,I->SelectedState == pkgCache::State::Purge);
2235    }
2236
2237    /* Resolve any problems that dselect created, allupgrade cannot handle
2238       such things. We do so quite agressively too.. */
2239    if (Cache->BrokenCount() != 0)
2240    {
2241       pkgProblemResolver Fix(Cache);
2242
2243       // Hold back held packages.
2244       if (_config->FindB("APT::Ignore-Hold",false) == false)
2245       {
2246          for (pkgCache::PkgIterator I = Cache->PkgBegin(); I.end() == false; ++I)
2247          {
2248             if (I->SelectedState == pkgCache::State::Hold)
2249             {
2250                Fix.Protect(I);
2251                Cache->MarkKeep(I);
2252             }
2253          }
2254       }
2255
2256       if (Fix.Resolve() == false)
2257       {
2258          ShowBroken(c1out,Cache,false);
2259          return _error->Error(_("Internal error, problem resolver broke stuff"));
2260       }
2261    }
2262
2263    // Now upgrade everything
2264    if (pkgAllUpgrade(Cache) == false)
2265    {
2266       ShowBroken(c1out,Cache,false);
2267       return _error->Error(_("Internal error, problem resolver broke stuff"));
2268    }
2269
2270    return InstallPackages(Cache,false);
2271 }
2272                                                                         /*}}}*/
2273 // DoClean - Remove download archives                                   /*{{{*/
2274 // ---------------------------------------------------------------------
2275 /* */
2276 bool DoClean(CommandLine &CmdL)
2277 {
2278    std::string const archivedir = _config->FindDir("Dir::Cache::archives");
2279    std::string const pkgcache = _config->FindFile("Dir::cache::pkgcache");
2280    std::string const srcpkgcache = _config->FindFile("Dir::cache::srcpkgcache");
2281
2282    if (_config->FindB("APT::Get::Simulate") == true)
2283    {
2284       cout << "Del " << archivedir << "* " << archivedir << "partial/*"<< endl
2285            << "Del " << pkgcache << " " << srcpkgcache << endl;
2286       return true;
2287    }
2288
2289    // Lock the archive directory
2290    FileFd Lock;
2291    if (_config->FindB("Debug::NoLocking",false) == false)
2292    {
2293       int lock_fd = GetLock(archivedir + "lock");
2294       if (lock_fd < 0)
2295          return _error->Error(_("Unable to lock the download directory"));
2296       Lock.Fd(lock_fd);
2297    }
2298
2299    pkgAcquire Fetcher;
2300    Fetcher.Clean(archivedir);
2301    Fetcher.Clean(archivedir + "partial/");
2302
2303    pkgCacheFile::RemoveCaches();
2304
2305    return true;
2306 }
2307                                                                         /*}}}*/
2308 // DoAutoClean - Smartly remove downloaded archives                     /*{{{*/
2309 // ---------------------------------------------------------------------
2310 /* This is similar to clean but it only purges things that cannot be
2311    downloaded, that is old versions of cached packages. */
2312 class LogCleaner : public pkgArchiveCleaner
2313 {
2314    protected:
2315    virtual void Erase(const char *File,string Pkg,string Ver,struct stat &St)
2316    {
2317       c1out << "Del " << Pkg << " " << Ver << " [" << SizeToStr(St.st_size) << "B]" << endl;
2318
2319       if (_config->FindB("APT::Get::Simulate") == false)
2320          unlink(File);
2321    };
2322 };
2323
2324 bool DoAutoClean(CommandLine &CmdL)
2325 {
2326    // Lock the archive directory
2327    FileFd Lock;
2328    if (_config->FindB("Debug::NoLocking",false) == false)
2329    {
2330       int lock_fd = GetLock(_config->FindDir("Dir::Cache::Archives") + "lock");
2331       if (lock_fd < 0)
2332          return _error->Error(_("Unable to lock the download directory"));
2333       Lock.Fd(lock_fd);
2334    }
2335
2336    CacheFile Cache;
2337    if (Cache.Open() == false)
2338       return false;
2339
2340    LogCleaner Cleaner;
2341
2342    return Cleaner.Go(_config->FindDir("Dir::Cache::archives"),*Cache) &&
2343       Cleaner.Go(_config->FindDir("Dir::Cache::archives") + "partial/",*Cache);
2344 }
2345                                                                         /*}}}*/
2346 // DoDownload - download a binary                                       /*{{{*/
2347 // ---------------------------------------------------------------------
2348 bool DoDownload(CommandLine &CmdL)
2349 {
2350    CacheFile Cache;
2351    if (Cache.ReadOnlyOpen() == false)
2352       return false;
2353
2354    APT::CacheSetHelper helper(c0out);
2355    APT::VersionList verset = APT::VersionList::FromCommandLine(Cache,
2356                 CmdL.FileList + 1, APT::VersionList::CANDIDATE, helper);
2357
2358    if (verset.empty() == true)
2359       return false;
2360
2361    pkgAcquire Fetcher;
2362    AcqTextStatus Stat(ScreenWidth, _config->FindI("quiet",0));
2363    if (_config->FindB("APT::Get::Print-URIs") == false)
2364       Fetcher.Setup(&Stat);
2365
2366    pkgRecords Recs(Cache);
2367    pkgSourceList *SrcList = Cache.GetSourceList();
2368    bool gotAll = true;
2369
2370    for (APT::VersionList::const_iterator Ver = verset.begin();
2371         Ver != verset.end();
2372         ++Ver)
2373    {
2374       string descr;
2375       // get the right version
2376       pkgCache::PkgIterator Pkg = Ver.ParentPkg();
2377       pkgRecords::Parser &rec=Recs.Lookup(Ver.FileList());
2378       pkgCache::VerFileIterator Vf = Ver.FileList();
2379       if (Vf.end() == true)
2380       {
2381          _error->Error("Can not find VerFile for %s in version %s", Pkg.FullName().c_str(), Ver.VerStr());
2382          gotAll = false;
2383          continue;
2384       }
2385       pkgCache::PkgFileIterator F = Vf.File();
2386       pkgIndexFile *index;
2387       if(SrcList->FindIndex(F, index) == false)
2388       {
2389          _error->Error(_("Can't find a source to download version '%s' of '%s'"), Ver.VerStr(), Pkg.FullName().c_str());
2390          gotAll = false;
2391          continue;
2392       }
2393       string uri = index->ArchiveURI(rec.FileName());
2394       strprintf(descr, _("Downloading %s %s"), Pkg.Name(), Ver.VerStr());
2395       // get the most appropriate hash
2396       HashString hash;
2397       if (rec.SHA512Hash() != "")
2398          hash = HashString("sha512", rec.SHA512Hash());
2399       else if (rec.SHA256Hash() != "")
2400          hash = HashString("sha256", rec.SHA256Hash());
2401       else if (rec.SHA1Hash() != "")
2402          hash = HashString("sha1", rec.SHA1Hash());
2403       else if (rec.MD5Hash() != "")
2404          hash = HashString("md5", rec.MD5Hash());
2405       // get the file
2406       new pkgAcqFile(&Fetcher, uri, hash.toStr(), (*Ver)->Size, descr, Pkg.Name(), ".");
2407    }
2408    if (gotAll == false)
2409       return false;
2410
2411    // Just print out the uris and exit if the --print-uris flag was used
2412    if (_config->FindB("APT::Get::Print-URIs") == true)
2413    {
2414       pkgAcquire::UriIterator I = Fetcher.UriBegin();
2415       for (; I != Fetcher.UriEnd(); ++I)
2416          cout << '\'' << I->URI << "' " << flNotDir(I->Owner->DestFile) << ' ' <<
2417                I->Owner->FileSize << ' ' << I->Owner->HashSum() << endl;
2418       return true;
2419    }
2420
2421    return (Fetcher.Run() == pkgAcquire::Continue);
2422 }
2423                                                                         /*}}}*/
2424 // DoCheck - Perform the check operation                                /*{{{*/
2425 // ---------------------------------------------------------------------
2426 /* Opening automatically checks the system, this command is mostly used
2427    for debugging */
2428 bool DoCheck(CommandLine &CmdL)
2429 {
2430    CacheFile Cache;
2431    Cache.Open();
2432    Cache.CheckDeps();
2433
2434    return true;
2435 }
2436                                                                         /*}}}*/
2437 // DoSource - Fetch a source archive                                    /*{{{*/
2438 // ---------------------------------------------------------------------
2439 /* Fetch souce packages */
2440 struct DscFile
2441 {
2442    string Package;
2443    string Version;
2444    string Dsc;
2445 };
2446
2447 bool DoSource(CommandLine &CmdL)
2448 {
2449    CacheFile Cache;
2450    if (Cache.Open(false) == false)
2451       return false;
2452
2453    if (CmdL.FileSize() <= 1)
2454       return _error->Error(_("Must specify at least one package to fetch source for"));
2455
2456    // Read the source list
2457    if (Cache.BuildSourceList() == false)
2458       return false;
2459    pkgSourceList *List = Cache.GetSourceList();
2460
2461    // Create the text record parsers
2462    pkgRecords Recs(Cache);
2463    pkgSrcRecords SrcRecs(*List);
2464    if (_error->PendingError() == true)
2465       return false;
2466
2467    // Create the download object
2468    AcqTextStatus Stat(ScreenWidth,_config->FindI("quiet",0));
2469    pkgAcquire Fetcher;
2470    Fetcher.SetLog(&Stat);
2471
2472    DscFile *Dsc = new DscFile[CmdL.FileSize()];
2473
2474    // insert all downloaded uris into this set to avoid downloading them
2475    // twice
2476    set<string> queued;
2477
2478    // Diff only mode only fetches .diff files
2479    bool const diffOnly = _config->FindB("APT::Get::Diff-Only", false);
2480    // Tar only mode only fetches .tar files
2481    bool const tarOnly = _config->FindB("APT::Get::Tar-Only", false);
2482    // Dsc only mode only fetches .dsc files
2483    bool const dscOnly = _config->FindB("APT::Get::Dsc-Only", false);
2484
2485    // Load the requestd sources into the fetcher
2486    unsigned J = 0;
2487    for (const char **I = CmdL.FileList + 1; *I != 0; I++, J++)
2488    {
2489       string Src;
2490       pkgSrcRecords::Parser *Last = FindSrc(*I,Recs,SrcRecs,Src,*Cache);
2491
2492       if (Last == 0) {
2493          delete[] Dsc;
2494          return _error->Error(_("Unable to find a source package for %s"),Src.c_str());
2495       }
2496
2497       string srec = Last->AsStr();
2498       string::size_type pos = srec.find("\nVcs-");
2499       while (pos != string::npos)
2500       {
2501          pos += strlen("\nVcs-");
2502          string vcs = srec.substr(pos,srec.find(":",pos)-pos);
2503          if(vcs == "Browser")
2504          {
2505             pos = srec.find("\nVcs-", pos);
2506             continue;
2507          }
2508          pos += vcs.length()+2;
2509          string::size_type epos = srec.find("\n", pos);
2510          string uri = srec.substr(pos,epos-pos).c_str();
2511          ioprintf(c1out, _("NOTICE: '%s' packaging is maintained in "
2512                            "the '%s' version control system at:\n"
2513                            "%s\n"),
2514                   Src.c_str(), vcs.c_str(), uri.c_str());
2515          if(vcs == "Bzr")
2516             ioprintf(c1out,_("Please use:\n"
2517                              "bzr branch %s\n"
2518                              "to retrieve the latest (possibly unreleased) "
2519                              "updates to the package.\n"),
2520                      uri.c_str());
2521          break;
2522       }
2523
2524       // Back track
2525       vector<pkgSrcRecords::File> Lst;
2526       if (Last->Files(Lst) == false) {
2527          delete[] Dsc;
2528          return false;
2529       }
2530
2531       // Load them into the fetcher
2532       for (vector<pkgSrcRecords::File>::const_iterator I = Lst.begin();
2533            I != Lst.end(); ++I)
2534       {
2535          // Try to guess what sort of file it is we are getting.
2536          if (I->Type == "dsc")
2537          {
2538             Dsc[J].Package = Last->Package();
2539             Dsc[J].Version = Last->Version();
2540             Dsc[J].Dsc = flNotDir(I->Path);
2541          }
2542
2543          // Handle the only options so that multiple can be used at once
2544          if (diffOnly == true || tarOnly == true || dscOnly == true)
2545          {
2546             if ((diffOnly == true && I->Type == "diff") ||
2547                 (tarOnly == true && I->Type == "tar") ||
2548                 (dscOnly == true && I->Type == "dsc"))
2549                 ; // Fine, we want this file downloaded
2550             else
2551                continue;
2552          }
2553
2554          // don't download the same uri twice (should this be moved to
2555          // the fetcher interface itself?)
2556          if(queued.find(Last->Index().ArchiveURI(I->Path)) != queued.end())
2557             continue;
2558          queued.insert(Last->Index().ArchiveURI(I->Path));
2559
2560          // check if we have a file with that md5 sum already localy
2561          if(!I->MD5Hash.empty() && FileExists(flNotDir(I->Path)))
2562          {
2563             FileFd Fd(flNotDir(I->Path), FileFd::ReadOnly);
2564             MD5Summation sum;
2565             sum.AddFD(Fd.Fd(), Fd.Size());
2566             Fd.Close();
2567             if((string)sum.Result() == I->MD5Hash)
2568             {
2569                ioprintf(c1out,_("Skipping already downloaded file '%s'\n"),
2570                         flNotDir(I->Path).c_str());
2571                continue;
2572             }
2573          }
2574
2575          new pkgAcqFile(&Fetcher,Last->Index().ArchiveURI(I->Path),
2576                         I->MD5Hash,I->Size,
2577                         Last->Index().SourceInfo(*Last,*I),Src);
2578       }
2579    }
2580
2581    // Display statistics
2582    unsigned long long FetchBytes = Fetcher.FetchNeeded();
2583    unsigned long long FetchPBytes = Fetcher.PartialPresent();
2584    unsigned long long DebBytes = Fetcher.TotalNeeded();
2585
2586    // Check for enough free space
2587    struct statvfs Buf;
2588    string OutputDir = ".";
2589    if (statvfs(OutputDir.c_str(),&Buf) != 0) {
2590       delete[] Dsc;
2591       if (errno == EOVERFLOW)
2592          return _error->WarningE("statvfs",_("Couldn't determine free space in %s"),
2593                                 OutputDir.c_str());
2594       else
2595          return _error->Errno("statvfs",_("Couldn't determine free space in %s"),
2596                                 OutputDir.c_str());
2597    } else if (unsigned(Buf.f_bfree) < (FetchBytes - FetchPBytes)/Buf.f_bsize)
2598      {
2599        struct statfs Stat;
2600        if (statfs(OutputDir.c_str(),&Stat) != 0
2601 #if HAVE_STRUCT_STATFS_F_TYPE
2602            || unsigned(Stat.f_type) != RAMFS_MAGIC
2603 #endif
2604            )  {
2605          delete[] Dsc;
2606           return _error->Error(_("You don't have enough free space in %s"),
2607               OutputDir.c_str());
2608        }
2609      }
2610
2611    // Number of bytes
2612    if (DebBytes != FetchBytes)
2613       //TRANSLATOR: The required space between number and unit is already included
2614       // in the replacement strings, so %sB will be correctly translate in e.g. 1,5 MB
2615       ioprintf(c1out,_("Need to get %sB/%sB of source archives.\n"),
2616                SizeToStr(FetchBytes).c_str(),SizeToStr(DebBytes).c_str());
2617    else
2618       //TRANSLATOR: The required space between number and unit is already included
2619       // in the replacement string, so %sB will be correctly translate in e.g. 1,5 MB
2620       ioprintf(c1out,_("Need to get %sB of source archives.\n"),
2621                SizeToStr(DebBytes).c_str());
2622
2623    if (_config->FindB("APT::Get::Simulate",false) == true)
2624    {
2625       for (unsigned I = 0; I != J; I++)
2626          ioprintf(cout,_("Fetch source %s\n"),Dsc[I].Package.c_str());
2627       delete[] Dsc;
2628       return true;
2629    }
2630
2631    // Just print out the uris an exit if the --print-uris flag was used
2632    if (_config->FindB("APT::Get::Print-URIs") == true)
2633    {
2634       pkgAcquire::UriIterator I = Fetcher.UriBegin();
2635       for (; I != Fetcher.UriEnd(); ++I)
2636          cout << '\'' << I->URI << "' " << flNotDir(I->Owner->DestFile) << ' ' <<
2637                I->Owner->FileSize << ' ' << I->Owner->HashSum() << endl;
2638       delete[] Dsc;
2639       return true;
2640    }
2641
2642    // Run it
2643    if (Fetcher.Run() == pkgAcquire::Failed)
2644    {
2645       delete[] Dsc;
2646       return false;
2647    }
2648
2649    // Print error messages
2650    bool Failed = false;
2651    for (pkgAcquire::ItemIterator I = Fetcher.ItemsBegin(); I != Fetcher.ItemsEnd(); ++I)
2652    {
2653       if ((*I)->Status == pkgAcquire::Item::StatDone &&
2654           (*I)->Complete == true)
2655          continue;
2656
2657       fprintf(stderr,_("Failed to fetch %s  %s\n"),(*I)->DescURI().c_str(),
2658               (*I)->ErrorText.c_str());
2659       Failed = true;
2660    }
2661    if (Failed == true)
2662    {
2663       delete[] Dsc;
2664       return _error->Error(_("Failed to fetch some archives."));
2665    }
2666
2667    if (_config->FindB("APT::Get::Download-only",false) == true)
2668    {
2669       c1out << _("Download complete and in download only mode") << endl;
2670       delete[] Dsc;
2671       return true;
2672    }
2673
2674    // Unpack the sources
2675    pid_t Process = ExecFork();
2676
2677    if (Process == 0)
2678    {
2679       bool const fixBroken = _config->FindB("APT::Get::Fix-Broken", false);
2680       for (unsigned I = 0; I != J; ++I)
2681       {
2682          string Dir = Dsc[I].Package + '-' + Cache->VS().UpstreamVersion(Dsc[I].Version.c_str());
2683
2684          // Diff only mode only fetches .diff files
2685          if (_config->FindB("APT::Get::Diff-Only",false) == true ||
2686              _config->FindB("APT::Get::Tar-Only",false) == true ||
2687              Dsc[I].Dsc.empty() == true)
2688             continue;
2689
2690          // See if the package is already unpacked
2691          struct stat Stat;
2692          if (fixBroken == false && stat(Dir.c_str(),&Stat) == 0 &&
2693              S_ISDIR(Stat.st_mode) != 0)
2694          {
2695             ioprintf(c0out ,_("Skipping unpack of already unpacked source in %s\n"),
2696                               Dir.c_str());
2697          }
2698          else
2699          {
2700             // Call dpkg-source
2701             char S[500];
2702             snprintf(S,sizeof(S),"%s -x %s",
2703                      _config->Find("Dir::Bin::dpkg-source","dpkg-source").c_str(),
2704                      Dsc[I].Dsc.c_str());
2705             if (system(S) != 0)
2706             {
2707                fprintf(stderr,_("Unpack command '%s' failed.\n"),S);
2708                fprintf(stderr,_("Check if the 'dpkg-dev' package is installed.\n"));
2709                _exit(1);
2710             }
2711          }
2712
2713          // Try to compile it with dpkg-buildpackage
2714          if (_config->FindB("APT::Get::Compile",false) == true)
2715          {
2716             string buildopts = _config->Find("APT::Get::Host-Architecture");
2717             if (buildopts.empty() == false)
2718                buildopts = "-a" + buildopts + " ";
2719             buildopts.append(_config->Find("DPkg::Build-Options","-b -uc"));
2720
2721             // Call dpkg-buildpackage
2722             char S[500];
2723             snprintf(S,sizeof(S),"cd %s && %s %s",
2724                      Dir.c_str(),
2725                      _config->Find("Dir::Bin::dpkg-buildpackage","dpkg-buildpackage").c_str(),
2726                      buildopts.c_str());
2727
2728             if (system(S) != 0)
2729             {
2730                fprintf(stderr,_("Build command '%s' failed.\n"),S);
2731                _exit(1);
2732             }
2733          }
2734       }
2735
2736       _exit(0);
2737    }
2738    delete[] Dsc;
2739
2740    // Wait for the subprocess
2741    int Status = 0;
2742    while (waitpid(Process,&Status,0) != Process)
2743    {
2744       if (errno == EINTR)
2745          continue;
2746       return _error->Errno("waitpid","Couldn't wait for subprocess");
2747    }
2748
2749    if (WIFEXITED(Status) == 0 || WEXITSTATUS(Status) != 0)
2750       return _error->Error(_("Child process failed"));
2751
2752    return true;
2753 }
2754                                                                         /*}}}*/
2755 // DoBuildDep - Install/removes packages to satisfy build dependencies  /*{{{*/
2756 // ---------------------------------------------------------------------
2757 /* This function will look at the build depends list of the given source
2758    package and install the necessary packages to make it true, or fail. */
2759 bool DoBuildDep(CommandLine &CmdL)
2760 {
2761    CacheFile Cache;
2762
2763    _config->Set("APT::Install-Recommends", false);
2764
2765    if (Cache.Open(true) == false)
2766       return false;
2767
2768    if (CmdL.FileSize() <= 1)
2769       return _error->Error(_("Must specify at least one package to check builddeps for"));
2770
2771    // Read the source list
2772    if (Cache.BuildSourceList() == false)
2773       return false;
2774    pkgSourceList *List = Cache.GetSourceList();
2775
2776    // Create the text record parsers
2777    pkgRecords Recs(Cache);
2778    pkgSrcRecords SrcRecs(*List);
2779    if (_error->PendingError() == true)
2780       return false;
2781
2782    // Create the download object
2783    AcqTextStatus Stat(ScreenWidth,_config->FindI("quiet",0));
2784    pkgAcquire Fetcher;
2785    if (Fetcher.Setup(&Stat) == false)
2786       return false;
2787
2788    bool StripMultiArch;
2789    string hostArch = _config->Find("APT::Get::Host-Architecture");
2790    if (hostArch.empty() == false)
2791    {
2792       std::vector<std::string> archs = APT::Configuration::getArchitectures();
2793       if (std::find(archs.begin(), archs.end(), hostArch) == archs.end())
2794          return _error->Error(_("No architecture information available for %s. See apt.conf(5) APT::Architectures for setup"), hostArch.c_str());
2795       StripMultiArch = false;
2796    }
2797    else
2798       StripMultiArch = true;
2799
2800    unsigned J = 0;
2801    for (const char **I = CmdL.FileList + 1; *I != 0; I++, J++)
2802    {
2803       string Src;
2804       pkgSrcRecords::Parser *Last = FindSrc(*I,Recs,SrcRecs,Src,*Cache);
2805       if (Last == 0)
2806          return _error->Error(_("Unable to find a source package for %s"),Src.c_str());
2807
2808       // Process the build-dependencies
2809       vector<pkgSrcRecords::Parser::BuildDepRec> BuildDeps;
2810       // FIXME: Can't specify architecture to use for [wildcard] matching, so switch default arch temporary
2811       if (hostArch.empty() == false)
2812       {
2813          std::string nativeArch = _config->Find("APT::Architecture");
2814          _config->Set("APT::Architecture", hostArch);
2815          bool Success = Last->BuildDepends(BuildDeps, _config->FindB("APT::Get::Arch-Only", false), StripMultiArch);
2816          _config->Set("APT::Architecture", nativeArch);
2817          if (Success == false)
2818             return _error->Error(_("Unable to get build-dependency information for %s"),Src.c_str());
2819       }
2820       else if (Last->BuildDepends(BuildDeps, _config->FindB("APT::Get::Arch-Only", false), StripMultiArch) == false)
2821             return _error->Error(_("Unable to get build-dependency information for %s"),Src.c_str());
2822
2823       // Also ensure that build-essential packages are present
2824       Configuration::Item const *Opts = _config->Tree("APT::Build-Essential");
2825       if (Opts)
2826          Opts = Opts->Child;
2827       for (; Opts; Opts = Opts->Next)
2828       {
2829          if (Opts->Value.empty() == true)
2830             continue;
2831
2832          pkgSrcRecords::Parser::BuildDepRec rec;
2833          rec.Package = Opts->Value;
2834          rec.Type = pkgSrcRecords::Parser::BuildDependIndep;
2835          rec.Op = 0;
2836          BuildDeps.push_back(rec);
2837       }
2838
2839       if (BuildDeps.empty() == true)
2840       {
2841          ioprintf(c1out,_("%s has no build depends.\n"),Src.c_str());
2842          continue;
2843       }
2844
2845       // Install the requested packages
2846       vector <pkgSrcRecords::Parser::BuildDepRec>::iterator D;
2847       pkgProblemResolver Fix(Cache);
2848       bool skipAlternatives = false; // skip remaining alternatives in an or group
2849       for (D = BuildDeps.begin(); D != BuildDeps.end(); ++D)
2850       {
2851          bool hasAlternatives = (((*D).Op & pkgCache::Dep::Or) == pkgCache::Dep::Or);
2852
2853          if (skipAlternatives == true)
2854          {
2855             /*
2856              * if there are alternatives, we've already picked one, so skip
2857              * the rest
2858              *
2859              * TODO: this means that if there's a build-dep on A|B and B is
2860              * installed, we'll still try to install A; more importantly,
2861              * if A is currently broken, we cannot go back and try B. To fix
2862              * this would require we do a Resolve cycle for each package we
2863              * add to the install list. Ugh
2864              */
2865             if (!hasAlternatives)
2866                skipAlternatives = false; // end of or group
2867             continue;
2868          }
2869
2870          if ((*D).Type == pkgSrcRecords::Parser::BuildConflict ||
2871              (*D).Type == pkgSrcRecords::Parser::BuildConflictIndep)
2872          {
2873             pkgCache::GrpIterator Grp = Cache->FindGrp((*D).Package);
2874             // Build-conflicts on unknown packages are silently ignored
2875             if (Grp.end() == true)
2876                continue;
2877
2878             for (pkgCache::PkgIterator Pkg = Grp.PackageList(); Pkg.end() == false; Pkg = Grp.NextPkg(Pkg))
2879             {
2880                pkgCache::VerIterator IV = (*Cache)[Pkg].InstVerIter(*Cache);
2881                /*
2882                 * Remove if we have an installed version that satisfies the
2883                 * version criteria
2884                 */
2885                if (IV.end() == false &&
2886                    Cache->VS().CheckDep(IV.VerStr(),(*D).Op,(*D).Version.c_str()) == true)
2887                   TryToInstallBuildDep(Pkg,Cache,Fix,true,false);
2888             }
2889          }
2890          else // BuildDep || BuildDepIndep
2891          {
2892             if (_config->FindB("Debug::BuildDeps",false) == true)
2893                  cout << "Looking for " << (*D).Package << "...\n";
2894
2895             pkgCache::PkgIterator Pkg;
2896
2897             // Cross-Building?
2898             if (StripMultiArch == false && D->Type != pkgSrcRecords::Parser::BuildDependIndep)
2899             {
2900                size_t const colon = D->Package.find(":");
2901                if (colon != string::npos)
2902                {
2903                   if (strcmp(D->Package.c_str() + colon, ":any") == 0 || strcmp(D->Package.c_str() + colon, ":native") == 0)
2904                      Pkg = Cache->FindPkg(D->Package.substr(0,colon));
2905                   else
2906                      Pkg = Cache->FindPkg(D->Package);
2907                }
2908                else
2909                   Pkg = Cache->FindPkg(D->Package, hostArch);
2910
2911                // a bad version either is invalid or doesn't satify dependency
2912                #define BADVER(Ver) (Ver.end() == true || \
2913                                     (D->Version.empty() == false && \
2914                                      Cache->VS().CheckDep(Ver.VerStr(),D->Op,D->Version.c_str()) == false))
2915
2916                APT::VersionList verlist;
2917                if (Pkg.end() == false)
2918                {
2919                   pkgCache::VerIterator Ver = (*Cache)[Pkg].InstVerIter(*Cache);
2920                   if (BADVER(Ver) == false)
2921                      verlist.insert(Ver);
2922                   Ver = (*Cache)[Pkg].CandidateVerIter(*Cache);
2923                   if (BADVER(Ver) == false)
2924                      verlist.insert(Ver);
2925                }
2926                if (verlist.empty() == true)
2927                {
2928                   pkgCache::PkgIterator BuildPkg = Cache->FindPkg(D->Package, "native");
2929                   if (BuildPkg.end() == false && Pkg != BuildPkg)
2930                   {
2931                      pkgCache::VerIterator Ver = (*Cache)[BuildPkg].InstVerIter(*Cache);
2932                      if (BADVER(Ver) == false)
2933                         verlist.insert(Ver);
2934                      Ver = (*Cache)[BuildPkg].CandidateVerIter(*Cache);
2935                      if (BADVER(Ver) == false)
2936                         verlist.insert(Ver);
2937                   }
2938                }
2939                #undef BADVER
2940
2941                string forbidden;
2942                // We need to decide if host or build arch, so find a version we can look at
2943                APT::VersionList::const_iterator Ver = verlist.begin();
2944                for (; Ver != verlist.end(); ++Ver)
2945                {
2946                   forbidden.clear();
2947                   if (Ver->MultiArch == pkgCache::Version::None || Ver->MultiArch == pkgCache::Version::All)
2948                   {
2949                      if (colon == string::npos)
2950                         Pkg = Ver.ParentPkg().Group().FindPkg(hostArch);
2951                      else if (strcmp(D->Package.c_str() + colon, ":any") == 0)
2952                         forbidden = "Multi-Arch: none";
2953                      else if (strcmp(D->Package.c_str() + colon, ":native") == 0)
2954                         Pkg = Ver.ParentPkg().Group().FindPkg("native");
2955                   }
2956                   else if (Ver->MultiArch == pkgCache::Version::Same)
2957                   {
2958                      if (colon == string::npos)
2959                         Pkg = Ver.ParentPkg().Group().FindPkg(hostArch);
2960                      else if (strcmp(D->Package.c_str() + colon, ":any") == 0)
2961                         forbidden = "Multi-Arch: same";
2962                      else if (strcmp(D->Package.c_str() + colon, ":native") == 0)
2963                         Pkg = Ver.ParentPkg().Group().FindPkg("native");
2964                   }
2965                   else if ((Ver->MultiArch & pkgCache::Version::Foreign) == pkgCache::Version::Foreign)
2966                   {
2967                      if (colon == string::npos)
2968                         Pkg = Ver.ParentPkg().Group().FindPkg("native");
2969                      else if (strcmp(D->Package.c_str() + colon, ":any") == 0 ||
2970                               strcmp(D->Package.c_str() + colon, ":native") == 0)
2971                         forbidden = "Multi-Arch: foreign";
2972                   }
2973                   else if ((Ver->MultiArch & pkgCache::Version::Allowed) == pkgCache::Version::Allowed)
2974                   {
2975                      if (colon == string::npos)
2976                         Pkg = Ver.ParentPkg().Group().FindPkg(hostArch);
2977                      else if (strcmp(D->Package.c_str() + colon, ":any") == 0)
2978                      {
2979                         // prefer any installed over preferred non-installed architectures
2980                         pkgCache::GrpIterator Grp = Ver.ParentPkg().Group();
2981                         // we don't check for version here as we are better of with upgrading than remove and install
2982                         for (Pkg = Grp.PackageList(); Pkg.end() == false; Pkg = Grp.NextPkg(Pkg))
2983                            if (Pkg.CurrentVer().end() == false)
2984                               break;
2985                         if (Pkg.end() == true)
2986                            Pkg = Grp.FindPreferredPkg(true);
2987                      }
2988                      else if (strcmp(D->Package.c_str() + colon, ":native") == 0)
2989                         Pkg = Ver.ParentPkg().Group().FindPkg("native");
2990                   }
2991
2992                   if (forbidden.empty() == false)
2993                   {
2994                      if (_config->FindB("Debug::BuildDeps",false) == true)
2995                         cout << D->Package.substr(colon, string::npos) << " is not allowed from " << forbidden << " package " << (*D).Package << " (" << Ver.VerStr() << ")" << endl;
2996                      continue;
2997                   }
2998
2999                   //we found a good version
3000                   break;
3001                }
3002                if (Ver == verlist.end())
3003                {
3004                   if (_config->FindB("Debug::BuildDeps",false) == true)
3005                      cout << " No multiarch info as we have no satisfying installed nor candidate for " << D->Package << " on build or host arch" << endl;
3006
3007                   if (forbidden.empty() == false)
3008                   {
3009                      if (hasAlternatives)
3010                         continue;
3011                      return _error->Error(_("%s dependency for %s can't be satisfied "
3012                                             "because %s is not allowed on '%s' packages"),
3013                                           Last->BuildDepType(D->Type), Src.c_str(),
3014                                           D->Package.c_str(), forbidden.c_str());
3015                   }
3016                }
3017             }
3018             else
3019                Pkg = Cache->FindPkg(D->Package);
3020
3021             if (Pkg.end() == true || (Pkg->VersionList == 0 && Pkg->ProvidesList == 0))
3022             {
3023                if (_config->FindB("Debug::BuildDeps",false) == true)
3024                     cout << " (not found)" << (*D).Package << endl;
3025
3026                if (hasAlternatives)
3027                   continue;
3028
3029                return _error->Error(_("%s dependency for %s cannot be satisfied "
3030                                       "because the package %s cannot be found"),
3031                                     Last->BuildDepType((*D).Type),Src.c_str(),
3032                                     (*D).Package.c_str());
3033             }
3034
3035             pkgCache::VerIterator IV = (*Cache)[Pkg].InstVerIter(*Cache);
3036             if (IV.end() == false)
3037             {
3038                if (_config->FindB("Debug::BuildDeps",false) == true)
3039                   cout << "  Is installed\n";
3040
3041                if (D->Version.empty() == true ||
3042                    Cache->VS().CheckDep(IV.VerStr(),(*D).Op,(*D).Version.c_str()) == true)
3043                {
3044                   skipAlternatives = hasAlternatives;
3045                   continue;
3046                }
3047
3048                if (_config->FindB("Debug::BuildDeps",false) == true)
3049                   cout << "    ...but the installed version doesn't meet the version requirement\n";
3050
3051                if (((*D).Op & pkgCache::Dep::LessEq) == pkgCache::Dep::LessEq)
3052                   return _error->Error(_("Failed to satisfy %s dependency for %s: Installed package %s is too new"),
3053                                         Last->BuildDepType((*D).Type), Src.c_str(), Pkg.FullName(true).c_str());
3054             }
3055
3056             // Only consider virtual packages if there is no versioned dependency
3057             if ((*D).Version.empty() == true)
3058             {
3059                /*
3060                 * If this is a virtual package, we need to check the list of
3061                 * packages that provide it and see if any of those are
3062                 * installed
3063                 */
3064                pkgCache::PrvIterator Prv = Pkg.ProvidesList();
3065                for (; Prv.end() != true; ++Prv)
3066                {
3067                   if (_config->FindB("Debug::BuildDeps",false) == true)
3068                      cout << "  Checking provider " << Prv.OwnerPkg().FullName() << endl;
3069
3070                   if ((*Cache)[Prv.OwnerPkg()].InstVerIter(*Cache).end() == false)
3071                      break;
3072                }
3073
3074                if (Prv.end() == false)
3075                {
3076                   if (_config->FindB("Debug::BuildDeps",false) == true)
3077                      cout << "  Is provided by installed package " << Prv.OwnerPkg().FullName() << endl;
3078                   skipAlternatives = hasAlternatives;
3079                   continue;
3080                }
3081             }
3082             else // versioned dependency
3083             {
3084                pkgCache::VerIterator CV = (*Cache)[Pkg].CandidateVerIter(*Cache);
3085                if (CV.end() == true ||
3086                    Cache->VS().CheckDep(CV.VerStr(),(*D).Op,(*D).Version.c_str()) == false)
3087                {
3088                   if (hasAlternatives)
3089                      continue;
3090                   else if (CV.end() == false)
3091                      return _error->Error(_("%s dependency for %s cannot be satisfied "
3092                                             "because candidate version of package %s "
3093                                             "can't satisfy version requirements"),
3094                                           Last->BuildDepType(D->Type), Src.c_str(),
3095                                           D->Package.c_str());
3096                   else
3097                      return _error->Error(_("%s dependency for %s cannot be satisfied "
3098                                             "because package %s has no candidate version"),
3099                                           Last->BuildDepType(D->Type), Src.c_str(),
3100                                           D->Package.c_str());
3101                }
3102             }
3103
3104             if (TryToInstallBuildDep(Pkg,Cache,Fix,false,false,false) == true)
3105             {
3106                // We successfully installed something; skip remaining alternatives
3107                skipAlternatives = hasAlternatives;
3108                if(_config->FindB("APT::Get::Build-Dep-Automatic", false) == true)
3109                   Cache->MarkAuto(Pkg, true);
3110                continue;
3111             }
3112             else if (hasAlternatives)
3113             {
3114                if (_config->FindB("Debug::BuildDeps",false) == true)
3115                   cout << "  Unsatisfiable, trying alternatives\n";
3116                continue;
3117             }
3118             else
3119             {
3120                return _error->Error(_("Failed to satisfy %s dependency for %s: %s"),
3121                                     Last->BuildDepType((*D).Type),
3122                                     Src.c_str(),
3123                                     (*D).Package.c_str());
3124             }
3125          }
3126       }
3127
3128       if (Fix.Resolve(true) == false)
3129          _error->Discard();
3130
3131       // Now we check the state of the packages,
3132       if (Cache->BrokenCount() != 0)
3133       {
3134          ShowBroken(cout, Cache, false);
3135          return _error->Error(_("Build-dependencies for %s could not be satisfied."),*I);
3136       }
3137    }
3138
3139    if (InstallPackages(Cache, false, true) == false)
3140       return _error->Error(_("Failed to process build dependencies"));
3141    return true;
3142 }
3143                                                                         /*}}}*/
3144 // GetChangelogPath - return a path pointing to a changelog file or dir /*{{{*/
3145 // ---------------------------------------------------------------------
3146 /* This returns a "path" string for the changelog url construction.
3147  * Please note that its not complete, it either needs a "/changelog"
3148  * appended (for the packages.debian.org/changelogs site) or a
3149  * ".changelog" (for third party sites that store the changelog in the
3150  * pool/ next to the deb itself)
3151  * Example return: "pool/main/a/apt/apt_0.8.8ubuntu3"
3152  */
3153 string GetChangelogPath(CacheFile &Cache,
3154                         pkgCache::PkgIterator Pkg,
3155                         pkgCache::VerIterator Ver)
3156 {
3157    string path;
3158
3159    pkgRecords Recs(Cache);
3160    pkgRecords::Parser &rec=Recs.Lookup(Ver.FileList());
3161    string srcpkg = rec.SourcePkg().empty() ? Pkg.Name() : rec.SourcePkg();
3162    string ver = Ver.VerStr();
3163    // if there is a source version it always wins
3164    if (rec.SourceVer() != "")
3165       ver = rec.SourceVer();
3166    path = flNotFile(rec.FileName());
3167    path += srcpkg + "_" + StripEpoch(ver);
3168    return path;
3169 }
3170                                                                         /*}}}*/
3171 // GuessThirdPartyChangelogUri - return url                             /*{{{*/
3172 // ---------------------------------------------------------------------
3173 /* Contruct a changelog file path for third party sites that do not use
3174  * packages.debian.org/changelogs
3175  * This simply uses the ArchiveURI() of the source pkg and looks for
3176  * a .changelog file there, Example for "mediabuntu":
3177  * apt-get changelog mplayer-doc:
3178  *  http://packages.medibuntu.org/pool/non-free/m/mplayer/mplayer_1.0~rc4~try1.dsfg1-1ubuntu1+medibuntu1.changelog
3179  */
3180 bool GuessThirdPartyChangelogUri(CacheFile &Cache,
3181                                  pkgCache::PkgIterator Pkg,
3182                                  pkgCache::VerIterator Ver,
3183                                  string &out_uri)
3184 {
3185    // get the binary deb server path
3186    pkgCache::VerFileIterator Vf = Ver.FileList();
3187    if (Vf.end() == true)
3188       return false;
3189    pkgCache::PkgFileIterator F = Vf.File();
3190    pkgIndexFile *index;
3191    pkgSourceList *SrcList = Cache.GetSourceList();
3192    if(SrcList->FindIndex(F, index) == false)
3193       return false;
3194
3195    // get archive uri for the binary deb
3196    string path_without_dot_changelog = GetChangelogPath(Cache, Pkg, Ver);
3197    out_uri = index->ArchiveURI(path_without_dot_changelog + ".changelog");
3198
3199    // now strip away the filename and add srcpkg_srcver.changelog
3200    return true;
3201 }
3202                                                                         /*}}}*/
3203 // DownloadChangelog - Download the changelog                           /*{{{*/
3204 // ---------------------------------------------------------------------
3205 bool DownloadChangelog(CacheFile &CacheFile, pkgAcquire &Fetcher,
3206                        pkgCache::VerIterator Ver, string targetfile)
3207 /* Download a changelog file for the given package version to
3208  * targetfile. This will first try the server from Apt::Changelogs::Server
3209  * (http://packages.debian.org/changelogs by default) and if that gives
3210  * a 404 tries to get it from the archive directly (see
3211  * GuessThirdPartyChangelogUri for details how)
3212  */
3213 {
3214    string path;
3215    string descr;
3216    string server;
3217    string changelog_uri;
3218
3219    // data structures we need
3220    pkgCache::PkgIterator Pkg = Ver.ParentPkg();
3221
3222    // make the server root configurable
3223    server = _config->Find("Apt::Changelogs::Server",
3224                           "http://packages.debian.org/changelogs");
3225    path = GetChangelogPath(CacheFile, Pkg, Ver);
3226    strprintf(changelog_uri, "%s/%s/changelog", server.c_str(), path.c_str());
3227    if (_config->FindB("APT::Get::Print-URIs", false) == true)
3228    {
3229       std::cout << '\'' << changelog_uri << '\'' << std::endl;
3230       return true;
3231    }
3232
3233    strprintf(descr, _("Changelog for %s (%s)"), Pkg.Name(), changelog_uri.c_str());
3234    // queue it
3235    new pkgAcqFile(&Fetcher, changelog_uri, "", 0, descr, Pkg.Name(), "ignored", targetfile);
3236
3237    // try downloading it, if that fails, try third-party-changelogs location
3238    // FIXME: Fetcher.Run() is "Continue" even if I get a 404?!?
3239    Fetcher.Run();
3240    if (!FileExists(targetfile))
3241    {
3242       string third_party_uri;
3243       if (GuessThirdPartyChangelogUri(CacheFile, Pkg, Ver, third_party_uri))
3244       {
3245          strprintf(descr, _("Changelog for %s (%s)"), Pkg.Name(), third_party_uri.c_str());
3246          new pkgAcqFile(&Fetcher, third_party_uri, "", 0, descr, Pkg.Name(), "ignored", targetfile);
3247          Fetcher.Run();
3248       }
3249    }
3250
3251    if (FileExists(targetfile))
3252       return true;
3253
3254    // error
3255    return _error->Error("changelog download failed");
3256 }
3257                                                                         /*}}}*/
3258 // DisplayFileInPager - Display File with pager                         /*{{{*/
3259 void DisplayFileInPager(string filename)
3260 {
3261    pid_t Process = ExecFork();
3262    if (Process == 0)
3263    {
3264       const char *Args[3];
3265       Args[0] = "/usr/bin/sensible-pager";
3266       Args[1] = filename.c_str();
3267       Args[2] = 0;
3268       execvp(Args[0],(char **)Args);
3269       exit(100);
3270    }
3271
3272    // Wait for the subprocess
3273    ExecWait(Process, "sensible-pager", false);
3274 }
3275                                                                         /*}}}*/
3276 // DoChangelog - Get changelog from the command line                    /*{{{*/
3277 // ---------------------------------------------------------------------
3278 bool DoChangelog(CommandLine &CmdL)
3279 {
3280    CacheFile Cache;
3281    if (Cache.ReadOnlyOpen() == false)
3282       return false;
3283
3284    APT::CacheSetHelper helper(c0out);
3285    APT::VersionList verset = APT::VersionList::FromCommandLine(Cache,
3286                 CmdL.FileList + 1, APT::VersionList::CANDIDATE, helper);
3287    if (verset.empty() == true)
3288       return false;
3289    pkgAcquire Fetcher;
3290
3291    if (_config->FindB("APT::Get::Print-URIs", false) == true)
3292    {
3293       bool Success = true;
3294       for (APT::VersionList::const_iterator Ver = verset.begin();
3295            Ver != verset.end(); ++Ver)
3296          Success &= DownloadChangelog(Cache, Fetcher, Ver, "");
3297       return Success;
3298    }
3299
3300    AcqTextStatus Stat(ScreenWidth, _config->FindI("quiet",0));
3301    Fetcher.Setup(&Stat);
3302
3303    bool const downOnly = _config->FindB("APT::Get::Download-Only", false);
3304
3305    char tmpname[100];
3306    char* tmpdir = NULL;
3307    if (downOnly == false)
3308    {
3309       const char* const tmpDir = getenv("TMPDIR");
3310       if (tmpDir != NULL && *tmpDir != '\0')
3311          snprintf(tmpname, sizeof(tmpname), "%s/apt-changelog-XXXXXX", tmpDir);
3312       else
3313          strncpy(tmpname, "/tmp/apt-changelog-XXXXXX", sizeof(tmpname));
3314       tmpdir = mkdtemp(tmpname);
3315       if (tmpdir == NULL)
3316          return _error->Errno("mkdtemp", "mkdtemp failed");
3317    }
3318
3319    for (APT::VersionList::const_iterator Ver = verset.begin();
3320         Ver != verset.end();
3321         ++Ver)
3322    {
3323       string changelogfile;
3324       if (downOnly == false)
3325          changelogfile.append(tmpname).append("changelog");
3326       else
3327          changelogfile.append(Ver.ParentPkg().Name()).append(".changelog");
3328       if (DownloadChangelog(Cache, Fetcher, Ver, changelogfile) && downOnly == false)
3329       {
3330          DisplayFileInPager(changelogfile);
3331          // cleanup temp file
3332          unlink(changelogfile.c_str());
3333       }
3334    }
3335    // clenaup tmp dir
3336    if (tmpdir != NULL)
3337       rmdir(tmpdir);
3338    return true;
3339 }
3340                                                                         /*}}}*/
3341 // DoMoo - Never Ask, Never Tell                                        /*{{{*/
3342 // ---------------------------------------------------------------------
3343 /* */
3344 bool DoMoo(CommandLine &CmdL)
3345 {
3346    cout <<
3347       "         (__) \n"
3348       "         (oo) \n"
3349       "   /------\\/ \n"
3350       "  / |    ||   \n"
3351       " *  /\\---/\\ \n"
3352       "    ~~   ~~   \n"
3353       "....\"Have you mooed today?\"...\n";
3354
3355    return true;
3356 }
3357                                                                         /*}}}*/
3358 // ShowHelp - Show a help screen                                        /*{{{*/
3359 // ---------------------------------------------------------------------
3360 /* */
3361 bool ShowHelp(CommandLine &CmdL)
3362 {
3363    ioprintf(cout,_("%s %s for %s compiled on %s %s\n"),PACKAGE,PACKAGE_VERSION,
3364             COMMON_ARCH,__DATE__,__TIME__);
3365
3366    if (_config->FindB("version") == true)
3367    {
3368       cout << _("Supported modules:") << endl;
3369
3370       for (unsigned I = 0; I != pkgVersioningSystem::GlobalListLen; I++)
3371       {
3372          pkgVersioningSystem *VS = pkgVersioningSystem::GlobalList[I];
3373          if (_system != 0 && _system->VS == VS)
3374             cout << '*';
3375          else
3376             cout << ' ';
3377          cout << "Ver: " << VS->Label << endl;
3378
3379          /* Print out all the packaging systems that will work with
3380             this VS */
3381          for (unsigned J = 0; J != pkgSystem::GlobalListLen; J++)
3382          {
3383             pkgSystem *Sys = pkgSystem::GlobalList[J];
3384             if (_system == Sys)
3385                cout << '*';
3386             else
3387                cout << ' ';
3388             if (Sys->VS->TestCompatibility(*VS) == true)
3389                cout << "Pkg:  " << Sys->Label << " (Priority " << Sys->Score(*_config) << ")" << endl;
3390          }
3391       }
3392
3393       for (unsigned I = 0; I != pkgSourceList::Type::GlobalListLen; I++)
3394       {
3395          pkgSourceList::Type *Type = pkgSourceList::Type::GlobalList[I];
3396          cout << " S.L: '" << Type->Name << "' " << Type->Label << endl;
3397       }
3398
3399       for (unsigned I = 0; I != pkgIndexFile::Type::GlobalListLen; I++)
3400       {
3401          pkgIndexFile::Type *Type = pkgIndexFile::Type::GlobalList[I];
3402          cout << " Idx: " << Type->Label << endl;
3403       }
3404
3405       return true;
3406    }
3407
3408    cout <<
3409     _("Usage: apt-get [options] command\n"
3410       "       apt-get [options] install|remove pkg1 [pkg2 ...]\n"
3411       "       apt-get [options] source pkg1 [pkg2 ...]\n"
3412       "\n"
3413       "apt-get is a simple command line interface for downloading and\n"
3414       "installing packages. The most frequently used commands are update\n"
3415       "and install.\n"
3416       "\n"
3417       "Commands:\n"
3418       "   update - Retrieve new lists of packages\n"
3419       "   upgrade - Perform an upgrade\n"
3420       "   install - Install new packages (pkg is libc6 not libc6.deb)\n"
3421       "   remove - Remove packages\n"
3422       "   autoremove - Remove automatically all unused packages\n"
3423       "   purge - Remove packages and config files\n"
3424       "   source - Download source archives\n"
3425       "   build-dep - Configure build-dependencies for source packages\n"
3426       "   dist-upgrade - Distribution upgrade, see apt-get(8)\n"
3427       "   dselect-upgrade - Follow dselect selections\n"
3428       "   clean - Erase downloaded archive files\n"
3429       "   autoclean - Erase old downloaded archive files\n"
3430       "   check - Verify that there are no broken dependencies\n"
3431       "   changelog - Download and display the changelog for the given package\n"
3432       "   download - Download the binary package into the current directory\n"
3433       "\n"
3434       "Options:\n"
3435       "  -h  This help text.\n"
3436       "  -q  Loggable output - no progress indicator\n"
3437       "  -qq No output except for errors\n"
3438       "  -d  Download only - do NOT install or unpack archives\n"
3439       "  -s  No-act. Perform ordering simulation\n"
3440       "  -y  Assume Yes to all queries and do not prompt\n"
3441       "  -f  Attempt to correct a system with broken dependencies in place\n"
3442       "  -m  Attempt to continue if archives are unlocatable\n"
3443       "  -u  Show a list of upgraded packages as well\n"
3444       "  -b  Build the source package after fetching it\n"
3445       "  -V  Show verbose version numbers\n"
3446       "  -c=? Read this configuration file\n"
3447       "  -o=? Set an arbitrary configuration option, eg -o dir::cache=/tmp\n"
3448       "See the apt-get(8), sources.list(5) and apt.conf(5) manual\n"
3449       "pages for more information and options.\n"
3450       "                       This APT has Super Cow Powers.\n");
3451    return true;
3452 }
3453                                                                         /*}}}*/
3454 // SigWinch - Window size change signal handler                         /*{{{*/
3455 // ---------------------------------------------------------------------
3456 /* */
3457 void SigWinch(int)
3458 {
3459    // Riped from GNU ls
3460 #ifdef TIOCGWINSZ
3461    struct winsize ws;
3462
3463    if (ioctl(1, TIOCGWINSZ, &ws) != -1 && ws.ws_col >= 5)
3464       ScreenWidth = ws.ws_col - 1;
3465 #endif
3466 }
3467                                                                         /*}}}*/
3468 int main(int argc,const char *argv[])                                   /*{{{*/
3469 {
3470    CommandLine::Args Args[] = {
3471       {'h',"help","help",0},
3472       {'v',"version","version",0},
3473       {'V',"verbose-versions","APT::Get::Show-Versions",0},
3474       {'q',"quiet","quiet",CommandLine::IntLevel},
3475       {'q',"silent","quiet",CommandLine::IntLevel},
3476       {'d',"download-only","APT::Get::Download-Only",0},
3477       {'b',"compile","APT::Get::Compile",0},
3478       {'b',"build","APT::Get::Compile",0},
3479       {'s',"simulate","APT::Get::Simulate",0},
3480       {'s',"just-print","APT::Get::Simulate",0},
3481       {'s',"recon","APT::Get::Simulate",0},
3482       {'s',"dry-run","APT::Get::Simulate",0},
3483       {'s',"no-act","APT::Get::Simulate",0},
3484       {'y',"yes","APT::Get::Assume-Yes",0},
3485       {'y',"assume-yes","APT::Get::Assume-Yes",0},
3486       {0,"assume-no","APT::Get::Assume-No",0},
3487       {'f',"fix-broken","APT::Get::Fix-Broken",0},
3488       {'u',"show-upgraded","APT::Get::Show-Upgraded",0},
3489       {'m',"ignore-missing","APT::Get::Fix-Missing",0},
3490       {'t',"target-release","APT::Default-Release",CommandLine::HasArg},
3491       {'t',"default-release","APT::Default-Release",CommandLine::HasArg},
3492       {'a',"host-architecture","APT::Get::Host-Architecture",CommandLine::HasArg},
3493       {0,"download","APT::Get::Download",0},
3494       {0,"fix-missing","APT::Get::Fix-Missing",0},
3495       {0,"ignore-hold","APT::Ignore-Hold",0},
3496       {0,"upgrade","APT::Get::upgrade",0},
3497       {0,"only-upgrade","APT::Get::Only-Upgrade",0},
3498       {0,"force-yes","APT::Get::force-yes",0},
3499       {0,"print-uris","APT::Get::Print-URIs",0},
3500       {0,"diff-only","APT::Get::Diff-Only",0},
3501       {0,"debian-only","APT::Get::Diff-Only",0},
3502       {0,"tar-only","APT::Get::Tar-Only",0},
3503       {0,"dsc-only","APT::Get::Dsc-Only",0},
3504       {0,"purge","APT::Get::Purge",0},
3505       {0,"list-cleanup","APT::Get::List-Cleanup",0},
3506       {0,"reinstall","APT::Get::ReInstall",0},
3507       {0,"trivial-only","APT::Get::Trivial-Only",0},
3508       {0,"remove","APT::Get::Remove",0},
3509       {0,"only-source","APT::Get::Only-Source",0},
3510       {0,"arch-only","APT::Get::Arch-Only",0},
3511       {0,"auto-remove","APT::Get::AutomaticRemove",0},
3512       {0,"allow-unauthenticated","APT::Get::AllowUnauthenticated",0},
3513       {0,"install-recommends","APT::Install-Recommends",CommandLine::Boolean},
3514       {0,"install-suggests","APT::Install-Suggests",CommandLine::Boolean},
3515       {0,"fix-policy","APT::Get::Fix-Policy-Broken",0},
3516       {0,"solver","APT::Solver",CommandLine::HasArg},
3517       {'c',"config-file",0,CommandLine::ConfigFile},
3518       {'o',"option",0,CommandLine::ArbItem},
3519       {0,0,0,0}};
3520    CommandLine::Dispatch Cmds[] = {{"update",&DoUpdate},
3521                                    {"upgrade",&DoUpgrade},
3522                                    {"install",&DoInstall},
3523                                    {"remove",&DoInstall},
3524                                    {"purge",&DoInstall},
3525                                    {"autoremove",&DoInstall},
3526                                    {"markauto",&DoMarkAuto},
3527                                    {"unmarkauto",&DoMarkAuto},
3528                                    {"dist-upgrade",&DoDistUpgrade},
3529                                    {"dselect-upgrade",&DoDSelectUpgrade},
3530                                    {"build-dep",&DoBuildDep},
3531                                    {"clean",&DoClean},
3532                                    {"autoclean",&DoAutoClean},
3533                                    {"check",&DoCheck},
3534                                    {"source",&DoSource},
3535                                    {"download",&DoDownload},
3536                                    {"changelog",&DoChangelog},
3537                                    {"moo",&DoMoo},
3538                                    {"help",&ShowHelp},
3539                                    {0,0}};
3540
3541    // Set up gettext support
3542    setlocale(LC_ALL,"");
3543    textdomain(PACKAGE);
3544
3545    // Parse the command line and initialize the package library
3546    CommandLine CmdL(Args,_config);
3547    if (pkgInitConfig(*_config) == false ||
3548        CmdL.Parse(argc,argv) == false ||
3549        pkgInitSystem(*_config,_system) == false)
3550    {
3551       if (_config->FindB("version") == true)
3552          ShowHelp(CmdL);
3553
3554       _error->DumpErrors();
3555       return 100;
3556    }
3557
3558    // See if the help should be shown
3559    if (_config->FindB("help") == true ||
3560        _config->FindB("version") == true ||
3561        CmdL.FileSize() == 0)
3562    {
3563       ShowHelp(CmdL);
3564       return 0;
3565    }
3566
3567    // simulate user-friendly if apt-get has no root privileges
3568    if (getuid() != 0 && _config->FindB("APT::Get::Simulate") == true &&
3569         (CmdL.FileSize() == 0 ||
3570          (strcmp(CmdL.FileList[0], "source") != 0 && strcmp(CmdL.FileList[0], "download") != 0 &&
3571           strcmp(CmdL.FileList[0], "changelog") != 0)))
3572    {
3573       if (_config->FindB("APT::Get::Show-User-Simulation-Note",true) == true)
3574          cout << _("NOTE: This is only a simulation!\n"
3575             "      apt-get needs root privileges for real execution.\n"
3576             "      Keep also in mind that locking is deactivated,\n"
3577             "      so don't depend on the relevance to the real current situation!"
3578          ) << std::endl;
3579       _config->Set("Debug::NoLocking",true);
3580    }
3581
3582    // Deal with stdout not being a tty
3583    if (!isatty(STDOUT_FILENO) && _config->FindI("quiet", -1) == -1)
3584       _config->Set("quiet","1");
3585
3586    // Setup the output streams
3587    c0out.rdbuf(cout.rdbuf());
3588    c1out.rdbuf(cout.rdbuf());
3589    c2out.rdbuf(cout.rdbuf());
3590    if (_config->FindI("quiet",0) > 0)
3591       c0out.rdbuf(devnull.rdbuf());
3592    if (_config->FindI("quiet",0) > 1)
3593       c1out.rdbuf(devnull.rdbuf());
3594
3595    // Setup the signals
3596    signal(SIGPIPE,SIG_IGN);
3597    signal(SIGWINCH,SigWinch);
3598    SigWinch(0);
3599
3600    // Match the operation
3601    CmdL.DispatchArg(Cmds);
3602
3603    // Print any errors or warnings found during parsing
3604    bool const Errors = _error->PendingError();
3605    if (_config->FindI("quiet",0) > 0)
3606       _error->DumpErrors();
3607    else
3608       _error->DumpErrors(GlobalError::DEBUG);
3609    return Errors == true ? 100 : 0;
3610 }
3611                                                                         /*}}}*/