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