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