cmdline/apt-get.cc

   1 // -*- mode: cpp; mode: fold -*-
   2 // Description                                                          /*{{{*/
   3 // $Id: apt-get.cc,v 1.156 2004/08/28 01:05:16 mdz Exp $
   4 /* ######################################################################
   5
   6    apt-get - Cover for dpkg
   7
   8    This is an allout cover for dpkg implementing a safer front end. It is
   9    based largely on libapt-pkg.
  10
  11    The syntax is different,
  12       apt-get [opt] command [things]
  13    Where command is:
  14       update - Resyncronize the package files from their sources
  15       upgrade - Smart-Download the newest versions of all packages
  16       dselect-upgrade - Follows dselect's changes to the Status: field
  17                        and installes new and removes old packages
  18       dist-upgrade - Powerfull upgrader designed to handle the issues with
  19                     a new distribution.
  20       install - Download and install a given package (by name, not by .deb)
  21       check - Update the package cache and check for broken packages
  22       clean - Erase the .debs downloaded to /var/cache/apt/archives and
  23               the partial dir too
  24
  25    ##################################################################### */
  26                                                                         /*}}}*/
  27 // Include Files                                                        /*{{{*/
  28 #include <config.h>
  29
  30 #include <apt-pkg/aptconfiguration.h>
  31 #include <apt-pkg/error.h>
  32 #include <apt-pkg/cmndline.h>
  33 #include <apt-pkg/init.h>
  34 #include <apt-pkg/depcache.h>
  35 #include <apt-pkg/sourcelist.h>
  36 #include <apt-pkg/algorithms.h>
  37 #include <apt-pkg/acquire-item.h>
  38 #include <apt-pkg/strutl.h>
  39 #include <apt-pkg/clean.h>
  40 #include <apt-pkg/srcrecords.h>
  41 #include <apt-pkg/version.h>
  42 #include <apt-pkg/cachefile.h>
  43 #include <apt-pkg/cacheset.h>
  44 #include <apt-pkg/sptr.h>
  45 #include <apt-pkg/md5.h>
  46 #include <apt-pkg/versionmatch.h>
  47
  48 #include "acqprogress.h"
  49
  50 #include <set>
  51 #include <locale.h>
  52 #include <langinfo.h>
  53 #include <fstream>
  54 #include <termios.h>
  55 #include <sys/ioctl.h>
  56 #include <sys/stat.h>
  57 #include <sys/statfs.h>
  58 #include <sys/statvfs.h>
  59 #include <signal.h>
  60 #include <unistd.h>
  61 #include <stdio.h>
  62 #include <errno.h>
  63 #include <regex.h>
  64 #include <sys/wait.h>
  65 #include <sstream>
  66
  67 #include <apti18n.h>
  68                                                                         /*}}}*/
  69
  70 #define RAMFS_MAGIC     0x858458f6
  71
  72 using namespace std;
  73
  74 ostream c0out(0);
  75 ostream c1out(0);
  76 ostream c2out(0);
  77 ofstream devnull("/dev/null");
  78 unsigned int ScreenWidth = 80 - 1; /* - 1 for the cursor */
  79
  80 // class CacheFile - Cover class for some dependency cache functions    /*{{{*/
  81 // ---------------------------------------------------------------------
  82 /* */
  83 class CacheFile : public pkgCacheFile
  84 {
  85    static pkgCache *SortCache;
  86    static int NameComp(const void *a,const void *b);
  87
  88    public:
  89    pkgCache::Package **List;
  90
  91    void Sort();
  92    bool CheckDeps(bool AllowBroken = false);
  93    bool BuildCaches(bool WithLock = true)
  94    {
  95       OpTextProgress Prog(*_config);
  96       if (pkgCacheFile::BuildCaches(&Prog,WithLock) == false)
  97          return false;
  98       return true;
  99    }
 100    bool Open(bool WithLock = true)
 101    {
 102       OpTextProgress Prog(*_config);
 103       if (pkgCacheFile::Open(&Prog,WithLock) == false)
 104          return false;
 105       Sort();
 106
 107       return true;
 108    };
 109    bool OpenForInstall()
 110    {
 111       if (_config->FindB("APT::Get::Print-URIs") == true)
 112          return Open(false);
 113       else
 114          return Open(true);
 115    }
 116    CacheFile() : List(0) {};
 117    ~CacheFile() {
 118       delete[] List;
 119    }
 120 };
 121                                                                         /*}}}*/
 122
 123 // YnPrompt - Yes No Prompt.                                            /*{{{*/
 124 // ---------------------------------------------------------------------
 125 /* Returns true on a Yes.*/
 126 bool YnPrompt(bool Default=true)
 127 {
 128    if (_config->FindB("APT::Get::Assume-Yes",false) == true)
 129    {
 130       c1out << _("Y") << endl;
 131       return true;
 132    }
 133    else if (_config->FindB("APT::Get::Assume-No",false) == true)
 134    {
 135       c1out << _("N") << endl;
 136       return false;
 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          Fix->Resolve(true);
1890          delete Fix;
1891       }
1892
1893       // Now we check the state of the packages,
1894       if (Cache->BrokenCount() != 0)
1895       {
1896          c1out <<
1897             _("Some packages could not be installed. This may mean that you have\n"
1898               "requested an impossible situation or if you are using the unstable\n"
1899               "distribution that some required packages have not yet been created\n"
1900               "or been moved out of Incoming.") << endl;
1901          /*
1902          if (Packages == 1)
1903          {
1904             c1out << endl;
1905             c1out <<
1906                _("Since you only requested a single operation it is extremely likely that\n"
1907                  "the package is simply not installable and a bug report against\n"
1908                  "that package should be filed.") << endl;
1909          }
1910          */
1911
1912          c1out << _("The following information may help to resolve the situation:") << endl;
1913          c1out << endl;
1914          ShowBroken(c1out,Cache,false);
1915          if (_error->PendingError() == true)
1916             return false;
1917          else
1918             return _error->Error(_("Broken packages"));
1919       }
1920    }
1921    if (!DoAutomaticRemove(Cache))
1922       return false;
1923
1924    /* Print out a list of packages that are going to be installed extra
1925       to what the user asked */
1926    if (Cache->InstCount() != verset[MOD_INSTALL].size())
1927    {
1928       string List;
1929       string VersionsList;
1930       for (unsigned J = 0; J < Cache->Head().PackageCount; J++)
1931       {
1932          pkgCache::PkgIterator I(Cache,Cache.List[J]);
1933          if ((*Cache)[I].Install() == false)
1934             continue;
1935          pkgCache::VerIterator Cand = Cache[I].CandidateVerIter(Cache);
1936
1937          if (verset[MOD_INSTALL].find(Cand) != verset[MOD_INSTALL].end())
1938             continue;
1939
1940          List += I.FullName(true) + " ";
1941          VersionsList += string(Cache[I].CandVersion) + "\n";
1942       }
1943
1944       ShowList(c1out,_("The following extra packages will be installed:"),List,VersionsList);
1945    }
1946
1947    /* Print out a list of suggested and recommended packages */
1948    {
1949       string SuggestsList, RecommendsList, List;
1950       string SuggestsVersions, RecommendsVersions;
1951       for (unsigned J = 0; J < Cache->Head().PackageCount; J++)
1952       {
1953          pkgCache::PkgIterator Pkg(Cache,Cache.List[J]);
1954
1955          /* Just look at the ones we want to install */
1956          if ((*Cache)[Pkg].Install() == false)
1957            continue;
1958
1959          // get the recommends/suggests for the candidate ver
1960          pkgCache::VerIterator CV = (*Cache)[Pkg].CandidateVerIter(*Cache);
1961          for (pkgCache::DepIterator D = CV.DependsList(); D.end() == false; )
1962          {
1963             pkgCache::DepIterator Start;
1964             pkgCache::DepIterator End;
1965             D.GlobOr(Start,End); // advances D
1966
1967             // FIXME: we really should display a or-group as a or-group to the user
1968             //        the problem is that ShowList is incapable of doing this
1969             string RecommendsOrList,RecommendsOrVersions;
1970             string SuggestsOrList,SuggestsOrVersions;
1971             bool foundInstalledInOrGroup = false;
1972             for(;;)
1973             {
1974                /* Skip if package is  installed already, or is about to be */
1975                string target = Start.TargetPkg().FullName(true) + " ";
1976                pkgCache::PkgIterator const TarPkg = Start.TargetPkg();
1977                if (TarPkg->SelectedState == pkgCache::State::Install ||
1978                    TarPkg->SelectedState == pkgCache::State::Hold ||
1979                    Cache[Start.TargetPkg()].Install())
1980                {
1981                   foundInstalledInOrGroup=true;
1982                   break;
1983                }
1984
1985                /* Skip if we already saw it */
1986                if (int(SuggestsList.find(target)) != -1 || int(RecommendsList.find(target)) != -1)
1987                {
1988                   foundInstalledInOrGroup=true;
1989                   break;
1990                }
1991
1992                // this is a dep on a virtual pkg, check if any package that provides it
1993                // should be installed
1994                if(Start.TargetPkg().ProvidesList() != 0)
1995                {
1996                   pkgCache::PrvIterator I = Start.TargetPkg().ProvidesList();
1997                   for (; I.end() == false; I++)
1998                   {
1999                      pkgCache::PkgIterator Pkg = I.OwnerPkg();
2000                      if (Cache[Pkg].CandidateVerIter(Cache) == I.OwnerVer() &&
2001                          Pkg.CurrentVer() != 0)
2002                         foundInstalledInOrGroup=true;
2003                   }
2004                }
2005
2006                if (Start->Type == pkgCache::Dep::Suggests)
2007                {
2008                   SuggestsOrList += target;
2009                   SuggestsOrVersions += string(Cache[Start.TargetPkg()].CandVersion) + "\n";
2010                }
2011
2012                if (Start->Type == pkgCache::Dep::Recommends)
2013                {
2014                   RecommendsOrList += target;
2015                   RecommendsOrVersions += string(Cache[Start.TargetPkg()].CandVersion) + "\n";
2016                }
2017
2018                if (Start >= End)
2019                   break;
2020                Start++;
2021             }
2022
2023             if(foundInstalledInOrGroup == false)
2024             {
2025                RecommendsList += RecommendsOrList;
2026                RecommendsVersions += RecommendsOrVersions;
2027                SuggestsList += SuggestsOrList;
2028                SuggestsVersions += SuggestsOrVersions;
2029             }
2030
2031          }
2032       }
2033
2034       ShowList(c1out,_("Suggested packages:"),SuggestsList,SuggestsVersions);
2035       ShowList(c1out,_("Recommended packages:"),RecommendsList,RecommendsVersions);
2036
2037    }
2038
2039    // if nothing changed in the cache, but only the automark information
2040    // we write the StateFile here, otherwise it will be written in
2041    // cache.commit()
2042    if (InstallAction.AutoMarkChanged > 0 &&
2043        Cache->DelCount() == 0 && Cache->InstCount() == 0 &&
2044        Cache->BadCount() == 0 &&
2045        _config->FindB("APT::Get::Simulate",false) == false)
2046       Cache->writeStateFile(NULL);
2047
2048    // See if we need to prompt
2049    // FIXME: check if really the packages in the set are going to be installed
2050    if (Cache->InstCount() == verset[MOD_INSTALL].size() && Cache->DelCount() == 0)
2051       return InstallPackages(Cache,false,false);
2052
2053    return InstallPackages(Cache,false);
2054 }
2055                                                                         /*}}}*/
2056 /* mark packages as automatically/manually installed.                   {{{*/
2057 bool DoMarkAuto(CommandLine &CmdL)
2058 {
2059    bool Action = true;
2060    int AutoMarkChanged = 0;
2061    OpTextProgress progress;
2062    CacheFile Cache;
2063    if (Cache.Open() == false)
2064       return false;
2065
2066    if (strcasecmp(CmdL.FileList[0],"markauto") == 0)
2067       Action = true;
2068    else if (strcasecmp(CmdL.FileList[0],"unmarkauto") == 0)
2069       Action = false;
2070
2071    for (const char **I = CmdL.FileList + 1; *I != 0; I++)
2072    {
2073       const char *S = *I;
2074       // Locate the package
2075       pkgCache::PkgIterator Pkg = Cache->FindPkg(S);
2076       if (Pkg.end() == true) {
2077          return _error->Error(_("Couldn't find package %s"),S);
2078       }
2079       else
2080       {
2081          if (!Action)
2082             ioprintf(c1out,_("%s set to manually installed.\n"), Pkg.Name());
2083          else
2084             ioprintf(c1out,_("%s set to automatically installed.\n"),
2085                       Pkg.Name());
2086
2087          Cache->MarkAuto(Pkg,Action);
2088          AutoMarkChanged++;
2089       }
2090    }
2091
2092    _error->Notice(_("This command is deprecated. Please use 'apt-mark auto' and 'apt-mark manual' instead."));
2093
2094    if (AutoMarkChanged && ! _config->FindB("APT::Get::Simulate",false))
2095       return Cache->writeStateFile(NULL);
2096    return false;
2097 }
2098                                                                         /*}}}*/
2099 // DoDistUpgrade - Automatic smart upgrader                             /*{{{*/
2100 // ---------------------------------------------------------------------
2101 /* Intelligent upgrader that will install and remove packages at will */
2102 bool DoDistUpgrade(CommandLine &CmdL)
2103 {
2104    CacheFile Cache;
2105    if (Cache.OpenForInstall() == false || Cache.CheckDeps() == false)
2106       return false;
2107
2108    c0out << _("Calculating upgrade... ") << flush;
2109    if (pkgDistUpgrade(*Cache) == false)
2110    {
2111       c0out << _("Failed") << endl;
2112       ShowBroken(c1out,Cache,false);
2113       return false;
2114    }
2115
2116    c0out << _("Done") << endl;
2117
2118    return InstallPackages(Cache,true);
2119 }
2120                                                                         /*}}}*/
2121 // DoDSelectUpgrade - Do an upgrade by following dselects selections    /*{{{*/
2122 // ---------------------------------------------------------------------
2123 /* Follows dselect's selections */
2124 bool DoDSelectUpgrade(CommandLine &CmdL)
2125 {
2126    CacheFile Cache;
2127    if (Cache.OpenForInstall() == false || Cache.CheckDeps() == false)
2128       return false;
2129
2130    pkgDepCache::ActionGroup group(Cache);
2131
2132    // Install everything with the install flag set
2133    pkgCache::PkgIterator I = Cache->PkgBegin();
2134    for (;I.end() != true; I++)
2135    {
2136       /* Install the package only if it is a new install, the autoupgrader
2137          will deal with the rest */
2138       if (I->SelectedState == pkgCache::State::Install)
2139          Cache->MarkInstall(I,false);
2140    }
2141
2142    /* Now install their deps too, if we do this above then order of
2143       the status file is significant for | groups */
2144    for (I = Cache->PkgBegin();I.end() != true; I++)
2145    {
2146       /* Install the package only if it is a new install, the autoupgrader
2147          will deal with the rest */
2148       if (I->SelectedState == pkgCache::State::Install)
2149          Cache->MarkInstall(I,true);
2150    }
2151
2152    // Apply erasures now, they override everything else.
2153    for (I = Cache->PkgBegin();I.end() != true; I++)
2154    {
2155       // Remove packages
2156       if (I->SelectedState == pkgCache::State::DeInstall ||
2157           I->SelectedState == pkgCache::State::Purge)
2158          Cache->MarkDelete(I,I->SelectedState == pkgCache::State::Purge);
2159    }
2160
2161    /* Resolve any problems that dselect created, allupgrade cannot handle
2162       such things. We do so quite agressively too.. */
2163    if (Cache->BrokenCount() != 0)
2164    {
2165       pkgProblemResolver Fix(Cache);
2166
2167       // Hold back held packages.
2168       if (_config->FindB("APT::Ignore-Hold",false) == false)
2169       {
2170          for (pkgCache::PkgIterator I = Cache->PkgBegin(); I.end() == false; I++)
2171          {
2172             if (I->SelectedState == pkgCache::State::Hold)
2173             {
2174                Fix.Protect(I);
2175                Cache->MarkKeep(I);
2176             }
2177          }
2178       }
2179
2180       if (Fix.Resolve() == false)
2181       {
2182          ShowBroken(c1out,Cache,false);
2183          return _error->Error(_("Internal error, problem resolver broke stuff"));
2184       }
2185    }
2186
2187    // Now upgrade everything
2188    if (pkgAllUpgrade(Cache) == false)
2189    {
2190       ShowBroken(c1out,Cache,false);
2191       return _error->Error(_("Internal error, problem resolver broke stuff"));
2192    }
2193
2194    return InstallPackages(Cache,false);
2195 }
2196                                                                         /*}}}*/
2197 // DoClean - Remove download archives                                   /*{{{*/
2198 // ---------------------------------------------------------------------
2199 /* */
2200 bool DoClean(CommandLine &CmdL)
2201 {
2202    if (_config->FindB("APT::Get::Simulate") == true)
2203    {
2204       cout << "Del " << _config->FindDir("Dir::Cache::archives") << "* " <<
2205          _config->FindDir("Dir::Cache::archives") << "partial/*" << endl;
2206       return true;
2207    }
2208
2209    // Lock the archive directory
2210    FileFd Lock;
2211    if (_config->FindB("Debug::NoLocking",false) == false)
2212    {
2213       Lock.Fd(GetLock(_config->FindDir("Dir::Cache::Archives") + "lock"));
2214       if (_error->PendingError() == true)
2215          return _error->Error(_("Unable to lock the download directory"));
2216    }
2217
2218    pkgAcquire Fetcher;
2219    Fetcher.Clean(_config->FindDir("Dir::Cache::archives"));
2220    Fetcher.Clean(_config->FindDir("Dir::Cache::archives") + "partial/");
2221    return true;
2222 }
2223                                                                         /*}}}*/
2224 // DoAutoClean - Smartly remove downloaded archives                     /*{{{*/
2225 // ---------------------------------------------------------------------
2226 /* This is similar to clean but it only purges things that cannot be
2227    downloaded, that is old versions of cached packages. */
2228 class LogCleaner : public pkgArchiveCleaner
2229 {
2230    protected:
2231    virtual void Erase(const char *File,string Pkg,string Ver,struct stat &St)
2232    {
2233       c1out << "Del " << Pkg << " " << Ver << " [" << SizeToStr(St.st_size) << "B]" << endl;
2234
2235       if (_config->FindB("APT::Get::Simulate") == false)
2236          unlink(File);
2237    };
2238 };
2239
2240 bool DoAutoClean(CommandLine &CmdL)
2241 {
2242    // Lock the archive directory
2243    FileFd Lock;
2244    if (_config->FindB("Debug::NoLocking",false) == false)
2245    {
2246       Lock.Fd(GetLock(_config->FindDir("Dir::Cache::Archives") + "lock"));
2247       if (_error->PendingError() == true)
2248          return _error->Error(_("Unable to lock the download directory"));
2249    }
2250
2251    CacheFile Cache;
2252    if (Cache.Open() == false)
2253       return false;
2254
2255    LogCleaner Cleaner;
2256
2257    return Cleaner.Go(_config->FindDir("Dir::Cache::archives"),*Cache) &&
2258       Cleaner.Go(_config->FindDir("Dir::Cache::archives") + "partial/",*Cache);
2259 }
2260                                                                         /*}}}*/
2261 // DoDownload - download a binary                                       /*{{{*/
2262 // ---------------------------------------------------------------------
2263 bool DoDownload(CommandLine &CmdL)
2264 {
2265    CacheFile Cache;
2266    if (Cache.ReadOnlyOpen() == false)
2267       return false;
2268
2269    APT::CacheSetHelper helper(c0out);
2270    APT::VersionSet verset = APT::VersionSet::FromCommandLine(Cache,
2271                 CmdL.FileList + 1, APT::VersionSet::CANDIDATE, helper);
2272
2273    if (verset.empty() == true)
2274       return false;
2275
2276    pkgAcquire Fetcher;
2277    AcqTextStatus Stat(ScreenWidth, _config->FindI("quiet",0));
2278    if (_config->FindB("APT::Get::Print-URIs") == true)
2279       Fetcher.Setup(&Stat);
2280
2281    pkgRecords Recs(Cache);
2282    pkgSourceList *SrcList = Cache.GetSourceList();
2283    for (APT::VersionSet::const_iterator Ver = verset.begin();
2284         Ver != verset.end();
2285         ++Ver)
2286    {
2287       string descr;
2288       // get the right version
2289       pkgCache::PkgIterator Pkg = Ver.ParentPkg();
2290       pkgRecords::Parser &rec=Recs.Lookup(Ver.FileList());
2291       pkgCache::VerFileIterator Vf = Ver.FileList();
2292       if (Vf.end() == true)
2293          return _error->Error("Can not find VerFile");
2294       pkgCache::PkgFileIterator F = Vf.File();
2295       pkgIndexFile *index;
2296       if(SrcList->FindIndex(F, index) == false)
2297          return _error->Error("FindIndex failed");
2298       string uri = index->ArchiveURI(rec.FileName());
2299       strprintf(descr, _("Downloading %s %s"), Pkg.Name(), Ver.VerStr());
2300       // get the most appropriate hash
2301       HashString hash;
2302       if (rec.SHA512Hash() != "")
2303          hash = HashString("sha512", rec.SHA512Hash());
2304       if (rec.SHA256Hash() != "")
2305          hash = HashString("sha256", rec.SHA256Hash());
2306       else if (rec.SHA1Hash() != "")
2307          hash = HashString("sha1", rec.SHA1Hash());
2308       else if (rec.MD5Hash() != "")
2309          hash = HashString("md5", rec.MD5Hash());
2310       // get the file
2311       new pkgAcqFile(&Fetcher, uri, hash.toStr(), (*Ver)->Size, descr, Pkg.Name(), ".");
2312    }
2313
2314    // Just print out the uris and exit if the --print-uris flag was used
2315    if (_config->FindB("APT::Get::Print-URIs") == true)
2316    {
2317       pkgAcquire::UriIterator I = Fetcher.UriBegin();
2318       for (; I != Fetcher.UriEnd(); I++)
2319          cout << '\'' << I->URI << "' " << flNotDir(I->Owner->DestFile) << ' ' <<
2320                I->Owner->FileSize << ' ' << I->Owner->HashSum() << endl;
2321       return true;
2322    }
2323
2324    return (Fetcher.Run() == pkgAcquire::Continue);
2325 }
2326                                                                         /*}}}*/
2327 // DoCheck - Perform the check operation                                /*{{{*/
2328 // ---------------------------------------------------------------------
2329 /* Opening automatically checks the system, this command is mostly used
2330    for debugging */
2331 bool DoCheck(CommandLine &CmdL)
2332 {
2333    CacheFile Cache;
2334    Cache.Open();
2335    Cache.CheckDeps();
2336
2337    return true;
2338 }
2339                                                                         /*}}}*/
2340 // DoSource - Fetch a source archive                                    /*{{{*/
2341 // ---------------------------------------------------------------------
2342 /* Fetch souce packages */
2343 struct DscFile
2344 {
2345    string Package;
2346    string Version;
2347    string Dsc;
2348 };
2349
2350 bool DoSource(CommandLine &CmdL)
2351 {
2352    CacheFile Cache;
2353    if (Cache.Open(false) == false)
2354       return false;
2355
2356    if (CmdL.FileSize() <= 1)
2357       return _error->Error(_("Must specify at least one package to fetch source for"));
2358
2359    // Read the source list
2360    if (Cache.BuildSourceList() == false)
2361       return false;
2362    pkgSourceList *List = Cache.GetSourceList();
2363
2364    // Create the text record parsers
2365    pkgRecords Recs(Cache);
2366    pkgSrcRecords SrcRecs(*List);
2367    if (_error->PendingError() == true)
2368       return false;
2369
2370    // Create the download object
2371    AcqTextStatus Stat(ScreenWidth,_config->FindI("quiet",0));
2372    pkgAcquire Fetcher;
2373    if (Fetcher.Setup(&Stat) == false)
2374       return false;
2375
2376    DscFile *Dsc = new DscFile[CmdL.FileSize()];
2377
2378    // insert all downloaded uris into this set to avoid downloading them
2379    // twice
2380    set<string> queued;
2381
2382    // Diff only mode only fetches .diff files
2383    bool const diffOnly = _config->FindB("APT::Get::Diff-Only", false);
2384    // Tar only mode only fetches .tar files
2385    bool const tarOnly = _config->FindB("APT::Get::Tar-Only", false);
2386    // Dsc only mode only fetches .dsc files
2387    bool const dscOnly = _config->FindB("APT::Get::Dsc-Only", false);
2388
2389    // Load the requestd sources into the fetcher
2390    unsigned J = 0;
2391    for (const char **I = CmdL.FileList + 1; *I != 0; I++, J++)
2392    {
2393       string Src;
2394       pkgSrcRecords::Parser *Last = FindSrc(*I,Recs,SrcRecs,Src,*Cache);
2395
2396       if (Last == 0) {
2397          delete[] Dsc;
2398          return _error->Error(_("Unable to find a source package for %s"),Src.c_str());
2399       }
2400
2401       string srec = Last->AsStr();
2402       string::size_type pos = srec.find("\nVcs-");
2403       while (pos != string::npos)
2404       {
2405          pos += strlen("\nVcs-");
2406          string vcs = srec.substr(pos,srec.find(":",pos)-pos);
2407          if(vcs == "Browser")
2408          {
2409             pos = srec.find("\nVcs-", pos);
2410             continue;
2411          }
2412          pos += vcs.length()+2;
2413          string::size_type epos = srec.find("\n", pos);
2414          string uri = srec.substr(pos,epos-pos).c_str();
2415          ioprintf(c1out, _("NOTICE: '%s' packaging is maintained in "
2416                            "the '%s' version control system at:\n"
2417                            "%s\n"),
2418                   Src.c_str(), vcs.c_str(), uri.c_str());
2419          if(vcs == "Bzr")
2420             ioprintf(c1out,_("Please use:\n"
2421                              "bzr get %s\n"
2422                              "to retrieve the latest (possibly unreleased) "
2423                              "updates to the package.\n"),
2424                      uri.c_str());
2425          break;
2426       }
2427
2428       // Back track
2429       vector<pkgSrcRecords::File> Lst;
2430       if (Last->Files(Lst) == false) {
2431          delete[] Dsc;
2432          return false;
2433       }
2434
2435       // Load them into the fetcher
2436       for (vector<pkgSrcRecords::File>::const_iterator I = Lst.begin();
2437            I != Lst.end(); I++)
2438       {
2439          // Try to guess what sort of file it is we are getting.
2440          if (I->Type == "dsc")
2441          {
2442             Dsc[J].Package = Last->Package();
2443             Dsc[J].Version = Last->Version();
2444             Dsc[J].Dsc = flNotDir(I->Path);
2445          }
2446
2447          // Handle the only options so that multiple can be used at once
2448          if (diffOnly == true || tarOnly == true || dscOnly == true)
2449          {
2450             if ((diffOnly == true && I->Type == "diff") ||
2451                 (tarOnly == true && I->Type == "tar") ||
2452                 (dscOnly == true && I->Type == "dsc"))
2453                 ; // Fine, we want this file downloaded
2454             else
2455                continue;
2456          }
2457
2458          // don't download the same uri twice (should this be moved to
2459          // the fetcher interface itself?)
2460          if(queued.find(Last->Index().ArchiveURI(I->Path)) != queued.end())
2461             continue;
2462          queued.insert(Last->Index().ArchiveURI(I->Path));
2463
2464          // check if we have a file with that md5 sum already localy
2465          if(!I->MD5Hash.empty() && FileExists(flNotDir(I->Path)))
2466          {
2467             FileFd Fd(flNotDir(I->Path), FileFd::ReadOnly);
2468             MD5Summation sum;
2469             sum.AddFD(Fd.Fd(), Fd.Size());
2470             Fd.Close();
2471             if((string)sum.Result() == I->MD5Hash)
2472             {
2473                ioprintf(c1out,_("Skipping already downloaded file '%s'\n"),
2474                         flNotDir(I->Path).c_str());
2475                continue;
2476             }
2477          }
2478
2479          new pkgAcqFile(&Fetcher,Last->Index().ArchiveURI(I->Path),
2480                         I->MD5Hash,I->Size,
2481                         Last->Index().SourceInfo(*Last,*I),Src);
2482       }
2483    }
2484
2485    // Display statistics
2486    unsigned long long FetchBytes = Fetcher.FetchNeeded();
2487    unsigned long long FetchPBytes = Fetcher.PartialPresent();
2488    unsigned long long DebBytes = Fetcher.TotalNeeded();
2489
2490    // Check for enough free space
2491    struct statvfs Buf;
2492    string OutputDir = ".";
2493    if (statvfs(OutputDir.c_str(),&Buf) != 0) {
2494       delete[] Dsc;
2495       if (errno == EOVERFLOW)
2496          return _error->WarningE("statvfs",_("Couldn't determine free space in %s"),
2497                                 OutputDir.c_str());
2498       else
2499          return _error->Errno("statvfs",_("Couldn't determine free space in %s"),
2500                                 OutputDir.c_str());
2501    } else if (unsigned(Buf.f_bfree) < (FetchBytes - FetchPBytes)/Buf.f_bsize)
2502      {
2503        struct statfs Stat;
2504        if (statfs(OutputDir.c_str(),&Stat) != 0
2505 #if HAVE_STRUCT_STATFS_F_TYPE
2506            || unsigned(Stat.f_type) != RAMFS_MAGIC
2507 #endif
2508            )  {
2509          delete[] Dsc;
2510           return _error->Error(_("You don't have enough free space in %s"),
2511               OutputDir.c_str());
2512        }
2513      }
2514
2515    // Number of bytes
2516    if (DebBytes != FetchBytes)
2517       //TRANSLATOR: The required space between number and unit is already included
2518       // in the replacement strings, so %sB will be correctly translate in e.g. 1,5 MB
2519       ioprintf(c1out,_("Need to get %sB/%sB of source archives.\n"),
2520                SizeToStr(FetchBytes).c_str(),SizeToStr(DebBytes).c_str());
2521    else
2522       //TRANSLATOR: The required space between number and unit is already included
2523       // in the replacement string, so %sB will be correctly translate in e.g. 1,5 MB
2524       ioprintf(c1out,_("Need to get %sB of source archives.\n"),
2525                SizeToStr(DebBytes).c_str());
2526
2527    if (_config->FindB("APT::Get::Simulate",false) == true)
2528    {
2529       for (unsigned I = 0; I != J; I++)
2530          ioprintf(cout,_("Fetch source %s\n"),Dsc[I].Package.c_str());
2531       delete[] Dsc;
2532       return true;
2533    }
2534
2535    // Just print out the uris an exit if the --print-uris flag was used
2536    if (_config->FindB("APT::Get::Print-URIs") == true)
2537    {
2538       pkgAcquire::UriIterator I = Fetcher.UriBegin();
2539       for (; I != Fetcher.UriEnd(); I++)
2540          cout << '\'' << I->URI << "' " << flNotDir(I->Owner->DestFile) << ' ' <<
2541                I->Owner->FileSize << ' ' << I->Owner->HashSum() << endl;
2542       delete[] Dsc;
2543       return true;
2544    }
2545
2546    // Run it
2547    if (Fetcher.Run() == pkgAcquire::Failed)
2548    {
2549       delete[] Dsc;
2550       return false;
2551    }
2552
2553    // Print error messages
2554    bool Failed = false;
2555    for (pkgAcquire::ItemIterator I = Fetcher.ItemsBegin(); I != Fetcher.ItemsEnd(); I++)
2556    {
2557       if ((*I)->Status == pkgAcquire::Item::StatDone &&
2558           (*I)->Complete == true)
2559          continue;
2560
2561       fprintf(stderr,_("Failed to fetch %s  %s\n"),(*I)->DescURI().c_str(),
2562               (*I)->ErrorText.c_str());
2563       Failed = true;
2564    }
2565    if (Failed == true)
2566    {
2567       delete[] Dsc;
2568       return _error->Error(_("Failed to fetch some archives."));
2569    }
2570
2571    if (_config->FindB("APT::Get::Download-only",false) == true)
2572    {
2573       c1out << _("Download complete and in download only mode") << endl;
2574       delete[] Dsc;
2575       return true;
2576    }
2577
2578    // Unpack the sources
2579    pid_t Process = ExecFork();
2580
2581    if (Process == 0)
2582    {
2583       bool const fixBroken = _config->FindB("APT::Get::Fix-Broken", false);
2584       for (unsigned I = 0; I != J; I++)
2585       {
2586          string Dir = Dsc[I].Package + '-' + Cache->VS().UpstreamVersion(Dsc[I].Version.c_str());
2587
2588          // Diff only mode only fetches .diff files
2589          if (_config->FindB("APT::Get::Diff-Only",false) == true ||
2590              _config->FindB("APT::Get::Tar-Only",false) == true ||
2591              Dsc[I].Dsc.empty() == true)
2592             continue;
2593
2594          // See if the package is already unpacked
2595          struct stat Stat;
2596          if (fixBroken == false && stat(Dir.c_str(),&Stat) == 0 &&
2597              S_ISDIR(Stat.st_mode) != 0)
2598          {
2599             ioprintf(c0out ,_("Skipping unpack of already unpacked source in %s\n"),
2600                               Dir.c_str());
2601          }
2602          else
2603          {
2604             // Call dpkg-source
2605             char S[500];
2606             snprintf(S,sizeof(S),"%s -x %s",
2607                      _config->Find("Dir::Bin::dpkg-source","dpkg-source").c_str(),
2608                      Dsc[I].Dsc.c_str());
2609             if (system(S) != 0)
2610             {
2611                fprintf(stderr,_("Unpack command '%s' failed.\n"),S);
2612                fprintf(stderr,_("Check if the 'dpkg-dev' package is installed.\n"));
2613                _exit(1);
2614             }
2615          }
2616
2617          // Try to compile it with dpkg-buildpackage
2618          if (_config->FindB("APT::Get::Compile",false) == true)
2619          {
2620             // Call dpkg-buildpackage
2621             char S[500];
2622             snprintf(S,sizeof(S),"cd %s && %s %s",
2623                      Dir.c_str(),
2624                      _config->Find("Dir::Bin::dpkg-buildpackage","dpkg-buildpackage").c_str(),
2625                      _config->Find("DPkg::Build-Options","-b -uc").c_str());
2626
2627             if (system(S) != 0)
2628             {
2629                fprintf(stderr,_("Build command '%s' failed.\n"),S);
2630                _exit(1);
2631             }
2632          }
2633       }
2634
2635       _exit(0);
2636    }
2637    delete[] Dsc;
2638
2639    // Wait for the subprocess
2640    int Status = 0;
2641    while (waitpid(Process,&Status,0) != Process)
2642    {
2643       if (errno == EINTR)
2644          continue;
2645       return _error->Errno("waitpid","Couldn't wait for subprocess");
2646    }
2647
2648    if (WIFEXITED(Status) == 0 || WEXITSTATUS(Status) != 0)
2649       return _error->Error(_("Child process failed"));
2650
2651    return true;
2652 }
2653                                                                         /*}}}*/
2654 // DoBuildDep - Install/removes packages to satisfy build dependencies  /*{{{*/
2655 // ---------------------------------------------------------------------
2656 /* This function will look at the build depends list of the given source
2657    package and install the necessary packages to make it true, or fail. */
2658 bool DoBuildDep(CommandLine &CmdL)
2659 {
2660    CacheFile Cache;
2661
2662    _config->Set("APT::Install-Recommends", false);
2663
2664    if (Cache.Open(true) == false)
2665       return false;
2666
2667    if (CmdL.FileSize() <= 1)
2668       return _error->Error(_("Must specify at least one package to check builddeps for"));
2669
2670    // Read the source list
2671    if (Cache.BuildSourceList() == false)
2672       return false;
2673    pkgSourceList *List = Cache.GetSourceList();
2674
2675    // Create the text record parsers
2676    pkgRecords Recs(Cache);
2677    pkgSrcRecords SrcRecs(*List);
2678    if (_error->PendingError() == true)
2679       return false;
2680
2681    // Create the download object
2682    AcqTextStatus Stat(ScreenWidth,_config->FindI("quiet",0));
2683    pkgAcquire Fetcher;
2684    if (Fetcher.Setup(&Stat) == false)
2685       return false;
2686
2687    unsigned J = 0;
2688    bool const StripMultiArch = APT::Configuration::getArchitectures().size() <= 1;
2689    for (const char **I = CmdL.FileList + 1; *I != 0; I++, J++)
2690    {
2691       string Src;
2692       pkgSrcRecords::Parser *Last = FindSrc(*I,Recs,SrcRecs,Src,*Cache);
2693       if (Last == 0)
2694          return _error->Error(_("Unable to find a source package for %s"),Src.c_str());
2695
2696       // Process the build-dependencies
2697       vector<pkgSrcRecords::Parser::BuildDepRec> BuildDeps;
2698       if (Last->BuildDepends(BuildDeps, _config->FindB("APT::Get::Arch-Only", false), StripMultiArch) == false)
2699         return _error->Error(_("Unable to get build-dependency information for %s"),Src.c_str());
2700
2701       // Also ensure that build-essential packages are present
2702       Configuration::Item const *Opts = _config->Tree("APT::Build-Essential");
2703       if (Opts)
2704          Opts = Opts->Child;
2705       for (; Opts; Opts = Opts->Next)
2706       {
2707          if (Opts->Value.empty() == true)
2708             continue;
2709
2710          pkgSrcRecords::Parser::BuildDepRec rec;
2711          rec.Package = Opts->Value;
2712          rec.Type = pkgSrcRecords::Parser::BuildDependIndep;
2713          rec.Op = 0;
2714          BuildDeps.push_back(rec);
2715       }
2716
2717       if (BuildDeps.size() == 0)
2718       {
2719          ioprintf(c1out,_("%s has no build depends.\n"),Src.c_str());
2720          continue;
2721       }
2722
2723       // Install the requested packages
2724       vector <pkgSrcRecords::Parser::BuildDepRec>::iterator D;
2725       pkgProblemResolver Fix(Cache);
2726       bool skipAlternatives = false; // skip remaining alternatives in an or group
2727       for (D = BuildDeps.begin(); D != BuildDeps.end(); D++)
2728       {
2729          bool hasAlternatives = (((*D).Op & pkgCache::Dep::Or) == pkgCache::Dep::Or);
2730
2731          if (skipAlternatives == true)
2732          {
2733             if (!hasAlternatives)
2734                skipAlternatives = false; // end of or group
2735             continue;
2736          }
2737
2738          if ((*D).Type == pkgSrcRecords::Parser::BuildConflict ||
2739              (*D).Type == pkgSrcRecords::Parser::BuildConflictIndep)
2740          {
2741             pkgCache::PkgIterator Pkg = Cache->FindPkg((*D).Package);
2742             // Build-conflicts on unknown packages are silently ignored
2743             if (Pkg.end() == true)
2744                continue;
2745
2746             pkgCache::VerIterator IV = (*Cache)[Pkg].InstVerIter(*Cache);
2747
2748             /*
2749              * Remove if we have an installed version that satisfies the
2750              * version criteria
2751              */
2752             if (IV.end() == false &&
2753                 Cache->VS().CheckDep(IV.VerStr(),(*D).Op,(*D).Version.c_str()) == true)
2754                TryToInstallBuildDep(Pkg,Cache,Fix,true,false);
2755          }
2756          else // BuildDep || BuildDepIndep
2757          {
2758             pkgCache::PkgIterator Pkg = Cache->FindPkg((*D).Package);
2759             if (_config->FindB("Debug::BuildDeps",false) == true)
2760                  cout << "Looking for " << (*D).Package << "...\n";
2761
2762             if (Pkg.end() == true)
2763             {
2764                if (_config->FindB("Debug::BuildDeps",false) == true)
2765                     cout << " (not found)" << (*D).Package << endl;
2766
2767                if (hasAlternatives)
2768                   continue;
2769
2770                return _error->Error(_("%s dependency for %s cannot be satisfied "
2771                                       "because the package %s cannot be found"),
2772                                     Last->BuildDepType((*D).Type),Src.c_str(),
2773                                     (*D).Package.c_str());
2774             }
2775
2776             /*
2777              * if there are alternatives, we've already picked one, so skip
2778              * the rest
2779              *
2780              * TODO: this means that if there's a build-dep on A|B and B is
2781              * installed, we'll still try to install A; more importantly,
2782              * if A is currently broken, we cannot go back and try B. To fix
2783              * this would require we do a Resolve cycle for each package we
2784              * add to the install list. Ugh
2785              */
2786
2787             /*
2788              * If this is a virtual package, we need to check the list of
2789              * packages that provide it and see if any of those are
2790              * installed
2791              */
2792             pkgCache::PrvIterator Prv = Pkg.ProvidesList();
2793             for (; Prv.end() != true; Prv++)
2794             {
2795                if (_config->FindB("Debug::BuildDeps",false) == true)
2796                     cout << "  Checking provider " << Prv.OwnerPkg().FullName() << endl;
2797
2798                if ((*Cache)[Prv.OwnerPkg()].InstVerIter(*Cache).end() == false)
2799                   break;
2800             }
2801
2802             // Get installed version and version we are going to install
2803             pkgCache::VerIterator IV = (*Cache)[Pkg].InstVerIter(*Cache);
2804
2805             if ((*D).Version[0] != '\0') {
2806                  // Versioned dependency
2807
2808                  pkgCache::VerIterator CV = (*Cache)[Pkg].CandidateVerIter(*Cache);
2809
2810                  for (; CV.end() != true; CV++)
2811                  {
2812                       if (Cache->VS().CheckDep(CV.VerStr(),(*D).Op,(*D).Version.c_str()) == true)
2813                            break;
2814                  }
2815                  if (CV.end() == true)
2816                  {
2817                    if (hasAlternatives)
2818                    {
2819                       continue;
2820                    }
2821                    else
2822                    {
2823                       return _error->Error(_("%s dependency for %s cannot be satisfied "
2824                                              "because no available versions of package %s "
2825                                              "can satisfy version requirements"),
2826                                            Last->BuildDepType((*D).Type),Src.c_str(),
2827                                            (*D).Package.c_str());
2828                    }
2829                  }
2830             }
2831             else
2832             {
2833                // Only consider virtual packages if there is no versioned dependency
2834                if (Prv.end() == false)
2835                {
2836                   if (_config->FindB("Debug::BuildDeps",false) == true)
2837                      cout << "  Is provided by installed package " << Prv.OwnerPkg().FullName() << endl;
2838                   skipAlternatives = hasAlternatives;
2839                   continue;
2840                }
2841             }
2842
2843             if (IV.end() == false)
2844             {
2845                if (_config->FindB("Debug::BuildDeps",false) == true)
2846                   cout << "  Is installed\n";
2847
2848                if (Cache->VS().CheckDep(IV.VerStr(),(*D).Op,(*D).Version.c_str()) == true)
2849                {
2850                   skipAlternatives = hasAlternatives;
2851                   continue;
2852                }
2853
2854                if (_config->FindB("Debug::BuildDeps",false) == true)
2855                   cout << "    ...but the installed version doesn't meet the version requirement\n";
2856
2857                if (((*D).Op & pkgCache::Dep::LessEq) == pkgCache::Dep::LessEq)
2858                {
2859                   return _error->Error(_("Failed to satisfy %s dependency for %s: Installed package %s is too new"),
2860                                        Last->BuildDepType((*D).Type),
2861                                        Src.c_str(),
2862                                        Pkg.FullName(true).c_str());
2863                }
2864             }
2865
2866
2867             if (_config->FindB("Debug::BuildDeps",false) == true)
2868                cout << "  Trying to install " << (*D).Package << endl;
2869
2870             if (TryToInstallBuildDep(Pkg,Cache,Fix,false,false) == true)
2871             {
2872                // We successfully installed something; skip remaining alternatives
2873                skipAlternatives = hasAlternatives;
2874                if(_config->FindB("APT::Get::Build-Dep-Automatic", false) == true)
2875                   Cache->MarkAuto(Pkg, true);
2876                continue;
2877             }
2878             else if (hasAlternatives)
2879             {
2880                if (_config->FindB("Debug::BuildDeps",false) == true)
2881                   cout << "  Unsatisfiable, trying alternatives\n";
2882                continue;
2883             }
2884             else
2885             {
2886                return _error->Error(_("Failed to satisfy %s dependency for %s: %s"),
2887                                     Last->BuildDepType((*D).Type),
2888                                     Src.c_str(),
2889                                     (*D).Package.c_str());
2890             }
2891          }
2892       }
2893
2894       Fix.InstallProtect();
2895       if (Fix.Resolve(true) == false)
2896          _error->Discard();
2897
2898       // Now we check the state of the packages,
2899       if (Cache->BrokenCount() != 0)
2900       {
2901          ShowBroken(cout, Cache, false);
2902          return _error->Error(_("Build-dependencies for %s could not be satisfied."),*I);
2903       }
2904    }
2905
2906    if (InstallPackages(Cache, false, true) == false)
2907       return _error->Error(_("Failed to process build dependencies"));
2908    return true;
2909 }
2910                                                                         /*}}}*/
2911 // GetChangelogPath - return a path pointing to a changelog file or dir /*{{{*/
2912 // ---------------------------------------------------------------------
2913 /* This returns a "path" string for the changelog url construction.
2914  * Please note that its not complete, it either needs a "/changelog"
2915  * appended (for the packages.debian.org/changelogs site) or a
2916  * ".changelog" (for third party sites that store the changelog in the
2917  * pool/ next to the deb itself)
2918  * Example return: "pool/main/a/apt/apt_0.8.8ubuntu3"
2919  */
2920 string GetChangelogPath(CacheFile &Cache,
2921                         pkgCache::PkgIterator Pkg,
2922                         pkgCache::VerIterator Ver)
2923 {
2924    string path;
2925
2926    pkgRecords Recs(Cache);
2927    pkgRecords::Parser &rec=Recs.Lookup(Ver.FileList());
2928    string srcpkg = rec.SourcePkg().empty() ? Pkg.Name() : rec.SourcePkg();
2929    string ver = Ver.VerStr();
2930    // if there is a source version it always wins
2931    if (rec.SourceVer() != "")
2932       ver = rec.SourceVer();
2933    path = flNotFile(rec.FileName());
2934    path += srcpkg + "_" + StripEpoch(ver);
2935    return path;
2936 }
2937                                                                         /*}}}*/
2938 // GuessThirdPartyChangelogUri - return url                             /*{{{*/
2939 // ---------------------------------------------------------------------
2940 /* Contruct a changelog file path for third party sites that do not use
2941  * packages.debian.org/changelogs
2942  * This simply uses the ArchiveURI() of the source pkg and looks for
2943  * a .changelog file there, Example for "mediabuntu":
2944  * apt-get changelog mplayer-doc:
2945  *  http://packages.medibuntu.org/pool/non-free/m/mplayer/mplayer_1.0~rc4~try1.dsfg1-1ubuntu1+medibuntu1.changelog
2946  */
2947 bool GuessThirdPartyChangelogUri(CacheFile &Cache,
2948                                  pkgCache::PkgIterator Pkg,
2949                                  pkgCache::VerIterator Ver,
2950                                  string &out_uri)
2951 {
2952    // get the binary deb server path
2953    pkgCache::VerFileIterator Vf = Ver.FileList();
2954    if (Vf.end() == true)
2955       return false;
2956    pkgCache::PkgFileIterator F = Vf.File();
2957    pkgIndexFile *index;
2958    pkgSourceList *SrcList = Cache.GetSourceList();
2959    if(SrcList->FindIndex(F, index) == false)
2960       return false;
2961
2962    // get archive uri for the binary deb
2963    string path_without_dot_changelog = GetChangelogPath(Cache, Pkg, Ver);
2964    out_uri = index->ArchiveURI(path_without_dot_changelog + ".changelog");
2965
2966    // now strip away the filename and add srcpkg_srcver.changelog
2967    return true;
2968 }
2969                                                                         /*}}}*/
2970 // DownloadChangelog - Download the changelog                           /*{{{*/
2971 // ---------------------------------------------------------------------
2972 bool DownloadChangelog(CacheFile &CacheFile, pkgAcquire &Fetcher,
2973                        pkgCache::VerIterator Ver, string targetfile)
2974 /* Download a changelog file for the given package version to
2975  * targetfile. This will first try the server from Apt::Changelogs::Server
2976  * (http://packages.debian.org/changelogs by default) and if that gives
2977  * a 404 tries to get it from the archive directly (see
2978  * GuessThirdPartyChangelogUri for details how)
2979  */
2980 {
2981    string path;
2982    string descr;
2983    string server;
2984    string changelog_uri;
2985
2986    // data structures we need
2987    pkgCache::PkgIterator Pkg = Ver.ParentPkg();
2988
2989    // make the server root configurable
2990    server = _config->Find("Apt::Changelogs::Server",
2991                           "http://packages.debian.org/changelogs");
2992    path = GetChangelogPath(CacheFile, Pkg, Ver);
2993    strprintf(changelog_uri, "%s/%s/changelog", server.c_str(), path.c_str());
2994    if (_config->FindB("APT::Get::Print-URIs", false) == true)
2995    {
2996       std::cout << '\'' << changelog_uri << '\'' << std::endl;
2997       return true;
2998    }
2999
3000    strprintf(descr, _("Changelog for %s (%s)"), Pkg.Name(), changelog_uri.c_str());
3001    // queue it
3002    new pkgAcqFile(&Fetcher, changelog_uri, "", 0, descr, Pkg.Name(), "ignored", targetfile);
3003
3004    // try downloading it, if that fails, try third-party-changelogs location
3005    // FIXME: Fetcher.Run() is "Continue" even if I get a 404?!?
3006    Fetcher.Run();
3007    if (!FileExists(targetfile))
3008    {
3009       string third_party_uri;
3010       if (GuessThirdPartyChangelogUri(CacheFile, Pkg, Ver, third_party_uri))
3011       {
3012          strprintf(descr, _("Changelog for %s (%s)"), Pkg.Name(), third_party_uri.c_str());
3013          new pkgAcqFile(&Fetcher, third_party_uri, "", 0, descr, Pkg.Name(), "ignored", targetfile);
3014          Fetcher.Run();
3015       }
3016    }
3017
3018    if (FileExists(targetfile))
3019       return true;
3020
3021    // error
3022    return _error->Error("changelog download failed");
3023 }
3024                                                                         /*}}}*/
3025 // DisplayFileInPager - Display File with pager                         /*{{{*/
3026 void DisplayFileInPager(string filename)
3027 {
3028    pid_t Process = ExecFork();
3029    if (Process == 0)
3030    {
3031       const char *Args[3];
3032       Args[0] = "/usr/bin/sensible-pager";
3033       Args[1] = filename.c_str();
3034       Args[2] = 0;
3035       execvp(Args[0],(char **)Args);
3036       exit(100);
3037    }
3038
3039    // Wait for the subprocess
3040    ExecWait(Process, "sensible-pager", false);
3041 }
3042                                                                         /*}}}*/
3043 // DoChangelog - Get changelog from the command line                    /*{{{*/
3044 // ---------------------------------------------------------------------
3045 bool DoChangelog(CommandLine &CmdL)
3046 {
3047    CacheFile Cache;
3048    if (Cache.ReadOnlyOpen() == false)
3049       return false;
3050
3051    APT::CacheSetHelper helper(c0out);
3052    APT::VersionSet verset = APT::VersionSet::FromCommandLine(Cache,
3053                 CmdL.FileList + 1, APT::VersionSet::CANDIDATE, helper);
3054    if (verset.empty() == true)
3055       return false;
3056    pkgAcquire Fetcher;
3057
3058    if (_config->FindB("APT::Get::Print-URIs", false) == true)
3059       for (APT::VersionSet::const_iterator Ver = verset.begin();
3060            Ver != verset.end(); ++Ver)
3061          return DownloadChangelog(Cache, Fetcher, Ver, "");
3062
3063    AcqTextStatus Stat(ScreenWidth, _config->FindI("quiet",0));
3064    Fetcher.Setup(&Stat);
3065
3066    bool const downOnly = _config->FindB("APT::Get::Download-Only", false);
3067
3068    char tmpname[100];
3069    char* tmpdir = NULL;
3070    if (downOnly == false)
3071    {
3072       const char* const tmpDir = getenv("TMPDIR");
3073       if (tmpDir != NULL && *tmpDir != '\0')
3074          snprintf(tmpname, sizeof(tmpname), "%s/apt-changelog-XXXXXX", tmpDir);
3075       else
3076          strncpy(tmpname, "/tmp/apt-changelog-XXXXXX", sizeof(tmpname));
3077       tmpdir = mkdtemp(tmpname);
3078       if (tmpdir == NULL)
3079          return _error->Errno("mkdtemp", "mkdtemp failed");
3080    }
3081
3082    for (APT::VersionSet::const_iterator Ver = verset.begin();
3083         Ver != verset.end();
3084         ++Ver)
3085    {
3086       string changelogfile;
3087       if (downOnly == false)
3088          changelogfile.append(tmpname).append("changelog");
3089       else
3090          changelogfile.append(Ver.ParentPkg().Name()).append(".changelog");
3091       if (DownloadChangelog(Cache, Fetcher, Ver, changelogfile) && downOnly == false)
3092       {
3093          DisplayFileInPager(changelogfile);
3094          // cleanup temp file
3095          unlink(changelogfile.c_str());
3096       }
3097    }
3098    // clenaup tmp dir
3099    if (tmpdir != NULL)
3100       rmdir(tmpdir);
3101    return true;
3102 }
3103                                                                         /*}}}*/
3104 // DoMoo - Never Ask, Never Tell                                        /*{{{*/
3105 // ---------------------------------------------------------------------
3106 /* */
3107 bool DoMoo(CommandLine &CmdL)
3108 {
3109    cout <<
3110       "         (__) \n"
3111       "         (oo) \n"
3112       "   /------\\/ \n"
3113       "  / |    ||   \n"
3114       " *  /\\---/\\ \n"
3115       "    ~~   ~~   \n"
3116       "....\"Have you mooed today?\"...\n";
3117
3118    return true;
3119 }
3120                                                                         /*}}}*/
3121 // ShowHelp - Show a help screen                                        /*{{{*/
3122 // ---------------------------------------------------------------------
3123 /* */
3124 bool ShowHelp(CommandLine &CmdL)
3125 {
3126    ioprintf(cout,_("%s %s for %s compiled on %s %s\n"),PACKAGE,VERSION,
3127             COMMON_ARCH,__DATE__,__TIME__);
3128
3129    if (_config->FindB("version") == true)
3130    {
3131       cout << _("Supported modules:") << endl;
3132
3133       for (unsigned I = 0; I != pkgVersioningSystem::GlobalListLen; I++)
3134       {
3135          pkgVersioningSystem *VS = pkgVersioningSystem::GlobalList[I];
3136          if (_system != 0 && _system->VS == VS)
3137             cout << '*';
3138          else
3139             cout << ' ';
3140          cout << "Ver: " << VS->Label << endl;
3141
3142          /* Print out all the packaging systems that will work with
3143             this VS */
3144          for (unsigned J = 0; J != pkgSystem::GlobalListLen; J++)
3145          {
3146             pkgSystem *Sys = pkgSystem::GlobalList[J];
3147             if (_system == Sys)
3148                cout << '*';
3149             else
3150                cout << ' ';
3151             if (Sys->VS->TestCompatibility(*VS) == true)
3152                cout << "Pkg:  " << Sys->Label << " (Priority " << Sys->Score(*_config) << ")" << endl;
3153          }
3154       }
3155
3156       for (unsigned I = 0; I != pkgSourceList::Type::GlobalListLen; I++)
3157       {
3158          pkgSourceList::Type *Type = pkgSourceList::Type::GlobalList[I];
3159          cout << " S.L: '" << Type->Name << "' " << Type->Label << endl;
3160       }
3161
3162       for (unsigned I = 0; I != pkgIndexFile::Type::GlobalListLen; I++)
3163       {
3164          pkgIndexFile::Type *Type = pkgIndexFile::Type::GlobalList[I];
3165          cout << " Idx: " << Type->Label << endl;
3166       }
3167
3168       return true;
3169    }
3170
3171    cout <<
3172     _("Usage: apt-get [options] command\n"
3173       "       apt-get [options] install|remove pkg1 [pkg2 ...]\n"
3174       "       apt-get [options] source pkg1 [pkg2 ...]\n"
3175       "\n"
3176       "apt-get is a simple command line interface for downloading and\n"
3177       "installing packages. The most frequently used commands are update\n"
3178       "and install.\n"
3179       "\n"
3180       "Commands:\n"
3181       "   update - Retrieve new lists of packages\n"
3182       "   upgrade - Perform an upgrade\n"
3183       "   install - Install new packages (pkg is libc6 not libc6.deb)\n"
3184       "   remove - Remove packages\n"
3185       "   autoremove - Remove automatically all unused packages\n"
3186       "   purge - Remove packages and config files\n"
3187       "   source - Download source archives\n"
3188       "   build-dep - Configure build-dependencies for source packages\n"
3189       "   dist-upgrade - Distribution upgrade, see apt-get(8)\n"
3190       "   dselect-upgrade - Follow dselect selections\n"
3191       "   clean - Erase downloaded archive files\n"
3192       "   autoclean - Erase old downloaded archive files\n"
3193       "   check - Verify that there are no broken dependencies\n"
3194       "   changelog - Download and display the changelog for the given package\n"
3195       "   download - Download the binary package into the current directory\n"
3196       "\n"
3197       "Options:\n"
3198       "  -h  This help text.\n"
3199       "  -q  Loggable output - no progress indicator\n"
3200       "  -qq No output except for errors\n"
3201       "  -d  Download only - do NOT install or unpack archives\n"
3202       "  -s  No-act. Perform ordering simulation\n"
3203       "  -y  Assume Yes to all queries and do not prompt\n"
3204       "  -f  Attempt to correct a system with broken dependencies in place\n"
3205       "  -m  Attempt to continue if archives are unlocatable\n"
3206       "  -u  Show a list of upgraded packages as well\n"
3207       "  -b  Build the source package after fetching it\n"
3208       "  -V  Show verbose version numbers\n"
3209       "  -c=? Read this configuration file\n"
3210       "  -o=? Set an arbitrary configuration option, eg -o dir::cache=/tmp\n"
3211       "See the apt-get(8), sources.list(5) and apt.conf(5) manual\n"
3212       "pages for more information and options.\n"
3213       "                       This APT has Super Cow Powers.\n");
3214    return true;
3215 }
3216                                                                         /*}}}*/
3217 // SigWinch - Window size change signal handler                         /*{{{*/
3218 // ---------------------------------------------------------------------
3219 /* */
3220 void SigWinch(int)
3221 {
3222    // Riped from GNU ls
3223 #ifdef TIOCGWINSZ
3224    struct winsize ws;
3225
3226    if (ioctl(1, TIOCGWINSZ, &ws) != -1 && ws.ws_col >= 5)
3227       ScreenWidth = ws.ws_col - 1;
3228 #endif
3229 }
3230                                                                         /*}}}*/
3231 int main(int argc,const char *argv[])                                   /*{{{*/
3232 {
3233    CommandLine::Args Args[] = {
3234       {'h',"help","help",0},
3235       {'v',"version","version",0},
3236       {'V',"verbose-versions","APT::Get::Show-Versions",0},
3237       {'q',"quiet","quiet",CommandLine::IntLevel},
3238       {'q',"silent","quiet",CommandLine::IntLevel},
3239       {'d',"download-only","APT::Get::Download-Only",0},
3240       {'b',"compile","APT::Get::Compile",0},
3241       {'b',"build","APT::Get::Compile",0},
3242       {'s',"simulate","APT::Get::Simulate",0},
3243       {'s',"just-print","APT::Get::Simulate",0},
3244       {'s',"recon","APT::Get::Simulate",0},
3245       {'s',"dry-run","APT::Get::Simulate",0},
3246       {'s',"no-act","APT::Get::Simulate",0},
3247       {'y',"yes","APT::Get::Assume-Yes",0},
3248       {'y',"assume-yes","APT::Get::Assume-Yes",0},
3249       {0,"assume-no","APT::Get::Assume-No",0},
3250       {'f',"fix-broken","APT::Get::Fix-Broken",0},
3251       {'u',"show-upgraded","APT::Get::Show-Upgraded",0},
3252       {'m',"ignore-missing","APT::Get::Fix-Missing",0},
3253       {'t',"target-release","APT::Default-Release",CommandLine::HasArg},
3254       {'t',"default-release","APT::Default-Release",CommandLine::HasArg},
3255       {0,"download","APT::Get::Download",0},
3256       {0,"fix-missing","APT::Get::Fix-Missing",0},
3257       {0,"ignore-hold","APT::Ignore-Hold",0},
3258       {0,"upgrade","APT::Get::upgrade",0},
3259       {0,"only-upgrade","APT::Get::Only-Upgrade",0},
3260       {0,"force-yes","APT::Get::force-yes",0},
3261       {0,"print-uris","APT::Get::Print-URIs",0},
3262       {0,"diff-only","APT::Get::Diff-Only",0},
3263       {0,"debian-only","APT::Get::Diff-Only",0},
3264       {0,"tar-only","APT::Get::Tar-Only",0},
3265       {0,"dsc-only","APT::Get::Dsc-Only",0},
3266       {0,"purge","APT::Get::Purge",0},
3267       {0,"list-cleanup","APT::Get::List-Cleanup",0},
3268       {0,"reinstall","APT::Get::ReInstall",0},
3269       {0,"trivial-only","APT::Get::Trivial-Only",0},
3270       {0,"remove","APT::Get::Remove",0},
3271       {0,"only-source","APT::Get::Only-Source",0},
3272       {0,"arch-only","APT::Get::Arch-Only",0},
3273       {0,"auto-remove","APT::Get::AutomaticRemove",0},
3274       {0,"allow-unauthenticated","APT::Get::AllowUnauthenticated",0},
3275       {0,"install-recommends","APT::Install-Recommends",CommandLine::Boolean},
3276       {0,"install-suggests","APT::Install-Suggests",CommandLine::Boolean},
3277       {0,"fix-policy","APT::Get::Fix-Policy-Broken",0},
3278       {0,"solver","APT::Solver",CommandLine::HasArg},
3279       {'c',"config-file",0,CommandLine::ConfigFile},
3280       {'o',"option",0,CommandLine::ArbItem},
3281       {0,0,0,0}};
3282    CommandLine::Dispatch Cmds[] = {{"update",&DoUpdate},
3283                                    {"upgrade",&DoUpgrade},
3284                                    {"install",&DoInstall},
3285                                    {"remove",&DoInstall},
3286                                    {"purge",&DoInstall},
3287                                    {"autoremove",&DoInstall},
3288                                    {"markauto",&DoMarkAuto},
3289                                    {"unmarkauto",&DoMarkAuto},
3290                                    {"dist-upgrade",&DoDistUpgrade},
3291                                    {"dselect-upgrade",&DoDSelectUpgrade},
3292                                    {"build-dep",&DoBuildDep},
3293                                    {"clean",&DoClean},
3294                                    {"autoclean",&DoAutoClean},
3295                                    {"check",&DoCheck},
3296                                    {"source",&DoSource},
3297                                    {"download",&DoDownload},
3298                                    {"changelog",&DoChangelog},
3299                                    {"moo",&DoMoo},
3300                                    {"help",&ShowHelp},
3301                                    {0,0}};
3302
3303    // Set up gettext support
3304    setlocale(LC_ALL,"");
3305    textdomain(PACKAGE);
3306
3307    // Parse the command line and initialize the package library
3308    CommandLine CmdL(Args,_config);
3309    if (pkgInitConfig(*_config) == false ||
3310        CmdL.Parse(argc,argv) == false ||
3311        pkgInitSystem(*_config,_system) == false)
3312    {
3313       if (_config->FindB("version") == true)
3314          ShowHelp(CmdL);
3315
3316       _error->DumpErrors();
3317       return 100;
3318    }
3319
3320    // See if the help should be shown
3321    if (_config->FindB("help") == true ||
3322        _config->FindB("version") == true ||
3323        CmdL.FileSize() == 0)
3324    {
3325       ShowHelp(CmdL);
3326       return 0;
3327    }
3328
3329    // simulate user-friendly if apt-get has no root privileges
3330    if (getuid() != 0 && _config->FindB("APT::Get::Simulate") == true &&
3331         (CmdL.FileSize() == 0 ||
3332          (strcmp(CmdL.FileList[0], "source") != 0 && strcmp(CmdL.FileList[0], "download") != 0 &&
3333           strcmp(CmdL.FileList[0], "changelog") != 0)))
3334    {
3335       if (_config->FindB("APT::Get::Show-User-Simulation-Note",true) == true)
3336          cout << _("NOTE: This is only a simulation!\n"
3337             "      apt-get needs root privileges for real execution.\n"
3338             "      Keep also in mind that locking is deactivated,\n"
3339             "      so don't depend on the relevance to the real current situation!"
3340          ) << std::endl;
3341       _config->Set("Debug::NoLocking",true);
3342    }
3343
3344    // Deal with stdout not being a tty
3345    if (!isatty(STDOUT_FILENO) && _config->FindI("quiet", -1) == -1)
3346       _config->Set("quiet","1");
3347
3348    // Setup the output streams
3349    c0out.rdbuf(cout.rdbuf());
3350    c1out.rdbuf(cout.rdbuf());
3351    c2out.rdbuf(cout.rdbuf());
3352    if (_config->FindI("quiet",0) > 0)
3353       c0out.rdbuf(devnull.rdbuf());
3354    if (_config->FindI("quiet",0) > 1)
3355       c1out.rdbuf(devnull.rdbuf());
3356
3357    // Setup the signals
3358    signal(SIGPIPE,SIG_IGN);
3359    signal(SIGWINCH,SigWinch);
3360    SigWinch(0);
3361
3362    // Match the operation
3363    CmdL.DispatchArg(Cmds);
3364
3365    // Print any errors or warnings found during parsing
3366    bool const Errors = _error->PendingError();
3367    if (_config->FindI("quiet",0) > 0)
3368       _error->DumpErrors();
3369    else
3370       _error->DumpErrors(GlobalError::DEBUG);
3371    return Errors == true ? 100 : 0;
3372 }
3373                                                                         /*}}}*/