cmdline/apt-get.cc

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