cmdline/apt-get.cc

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