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    // Create the download object
 816    pkgAcquire Fetcher;
 817    AcqTextStatus Stat(ScreenWidth,_config->FindI("quiet",0));
 818    if (_config->FindB("APT::Get::Print-URIs", false) == true)
 819    {
 820       // force a hashsum for compatibility reasons
 821       _config->CndSet("Acquire::ForceHash", "md5sum");
 822       if (Fetcher.Setup(&Stat, "") == false)
 823          return false;
 824    }
 825    else if (Fetcher.Setup(&Stat, _config->FindDir("Dir::Cache::Archives")) == false)
 826       return false;
 827
 828    // Read the source list
 829    pkgSourceList List;
 830    if (List.ReadMainList() == false)
 831       return _error->Error(_("The list of sources could not be read."));
 832
 833    // Create the package manager and prepare to download
 834    SPtr<pkgPackageManager> PM= _system->CreatePM(Cache);
 835    if (PM->GetArchives(&Fetcher,&List,&Recs) == false ||
 836        _error->PendingError() == true)
 837       return false;
 838
 839    // Display statistics
 840    double FetchBytes = Fetcher.FetchNeeded();
 841    double FetchPBytes = Fetcher.PartialPresent();
 842    double DebBytes = Fetcher.TotalNeeded();
 843    if (DebBytes != Cache->DebSize())
 844    {
 845       c0out << DebBytes << ',' << Cache->DebSize() << endl;
 846       c0out << _("How odd.. The sizes didn't match, email apt@packages.debian.org") << endl;
 847    }
 848
 849    // Number of bytes
 850    if (DebBytes != FetchBytes)
 851       ioprintf(c1out,_("Need to get %sB/%sB of archives.\n"),
 852                SizeToStr(FetchBytes).c_str(),SizeToStr(DebBytes).c_str());
 853    else if (DebBytes != 0)
 854       ioprintf(c1out,_("Need to get %sB of archives.\n"),
 855                SizeToStr(DebBytes).c_str());
 856
 857    // Size delta
 858    if (Cache->UsrSize() >= 0)
 859       ioprintf(c1out,_("After this operation, %sB of additional disk space will be used.\n"),
 860                SizeToStr(Cache->UsrSize()).c_str());
 861    else
 862       ioprintf(c1out,_("After this operation, %sB disk space will be freed.\n"),
 863                SizeToStr(-1*Cache->UsrSize()).c_str());
 864
 865    if (_error->PendingError() == true)
 866       return false;
 867
 868    /* Check for enough free space, but only if we are actually going to
 869       download */
 870    if (_config->FindB("APT::Get::Print-URIs") == false &&
 871        _config->FindB("APT::Get::Download",true) == true)
 872    {
 873       struct statvfs Buf;
 874       string OutputDir = _config->FindDir("Dir::Cache::Archives");
 875       if (statvfs(OutputDir.c_str(),&Buf) != 0) {
 876          if (errno == EOVERFLOW)
 877             return _error->WarningE("statvfs",_("Couldn't determine free space in %s"),
 878                                  OutputDir.c_str());
 879          else
 880             return _error->Errno("statvfs",_("Couldn't determine free space in %s"),
 881                                  OutputDir.c_str());
 882       } else if (unsigned(Buf.f_bfree) < (FetchBytes - FetchPBytes)/Buf.f_bsize)
 883       {
 884          struct statfs Stat;
 885          if (statfs(OutputDir.c_str(),&Stat) != 0
 886 #if HAVE_STRUCT_STATFS_F_TYPE
 887              || unsigned(Stat.f_type) != RAMFS_MAGIC
 888 #endif
 889              )
 890             return _error->Error(_("You don't have enough free space in %s."),
 891                 OutputDir.c_str());
 892       }
 893    }
 894
 895    // Fail safe check
 896    if (_config->FindI("quiet",0) >= 2 ||
 897        _config->FindB("APT::Get::Assume-Yes",false) == true)
 898    {
 899       if (Fail == true && _config->FindB("APT::Get::Force-Yes",false) == false)
 900          return _error->Error(_("There are problems and -y was used without --force-yes"));
 901    }
 902
 903    if (Essential == true && Safety == true)
 904    {
 905       if (_config->FindB("APT::Get::Trivial-Only",false) == true)
 906          return _error->Error(_("Trivial Only specified but this is not a trivial operation."));
 907
 908       const char *Prompt = _("Yes, do as I say!");
 909       ioprintf(c2out,
 910                _("You are about to do something potentially harmful.\n"
 911                  "To continue type in the phrase '%s'\n"
 912                  " ?] "),Prompt);
 913       c2out << flush;
 914       if (AnalPrompt(Prompt) == false)
 915       {
 916          c2out << _("Abort.") << endl;
 917          exit(1);
 918       }
 919    }
 920    else
 921    {
 922       // Prompt to continue
 923       if (Ask == true || Fail == true)
 924       {
 925          if (_config->FindB("APT::Get::Trivial-Only",false) == true)
 926             return _error->Error(_("Trivial Only specified but this is not a trivial operation."));
 927
 928          if (_config->FindI("quiet",0) < 2 &&
 929              _config->FindB("APT::Get::Assume-Yes",false) == false)
 930          {
 931             c2out << _("Do you want to continue [Y/n]? ") << flush;
 932
 933             if (YnPrompt() == false)
 934             {
 935                c2out << _("Abort.") << endl;
 936                exit(1);
 937             }
 938          }
 939       }
 940    }
 941
 942    // Just print out the uris an exit if the --print-uris flag was used
 943    if (_config->FindB("APT::Get::Print-URIs") == true)
 944    {
 945       pkgAcquire::UriIterator I = Fetcher.UriBegin();
 946       for (; I != Fetcher.UriEnd(); I++)
 947          cout << '\'' << I->URI << "' " << flNotDir(I->Owner->DestFile) << ' ' <<
 948                I->Owner->FileSize << ' ' << I->Owner->HashSum() << endl;
 949       return true;
 950    }
 951
 952    if (!CheckAuth(Fetcher))
 953       return false;
 954
 955    /* Unlock the dpkg lock if we are not going to be doing an install
 956       after. */
 957    if (_config->FindB("APT::Get::Download-Only",false) == true)
 958       _system->UnLock();
 959
 960    // Run it
 961    while (1)
 962    {
 963       bool Transient = false;
 964       if (_config->FindB("APT::Get::Download",true) == false)
 965       {
 966          for (pkgAcquire::ItemIterator I = Fetcher.ItemsBegin(); I < Fetcher.ItemsEnd();)
 967          {
 968             if ((*I)->Local == true)
 969             {
 970                I++;
 971                continue;
 972             }
 973
 974             // Close the item and check if it was found in cache
 975             (*I)->Finished();
 976             if ((*I)->Complete == false)
 977                Transient = true;
 978
 979             // Clear it out of the fetch list
 980             delete *I;
 981             I = Fetcher.ItemsBegin();
 982          }
 983       }
 984
 985       if (Fetcher.Run() == pkgAcquire::Failed)
 986          return false;
 987
 988       // Print out errors
 989       bool Failed = false;
 990       for (pkgAcquire::ItemIterator I = Fetcher.ItemsBegin(); I != Fetcher.ItemsEnd(); I++)
 991       {
 992          if ((*I)->Status == pkgAcquire::Item::StatDone &&
 993              (*I)->Complete == true)
 994             continue;
 995
 996          if ((*I)->Status == pkgAcquire::Item::StatIdle)
 997          {
 998             Transient = true;
 999             // Failed = true;
1000             continue;
1001          }
1002
1003          fprintf(stderr,_("Failed to fetch %s  %s\n"),(*I)->DescURI().c_str(),
1004                  (*I)->ErrorText.c_str());
1005          Failed = true;
1006       }
1007
1008       /* If we are in no download mode and missing files and there were
1009          'failures' then the user must specify -m. Furthermore, there
1010          is no such thing as a transient error in no-download mode! */
1011       if (Transient == true &&
1012           _config->FindB("APT::Get::Download",true) == false)
1013       {
1014          Transient = false;
1015          Failed = true;
1016       }
1017
1018       if (_config->FindB("APT::Get::Download-Only",false) == true)
1019       {
1020          if (Failed == true && _config->FindB("APT::Get::Fix-Missing",false) == false)
1021             return _error->Error(_("Some files failed to download"));
1022          c1out << _("Download complete and in download only mode") << endl;
1023          return true;
1024       }
1025
1026       if (Failed == true && _config->FindB("APT::Get::Fix-Missing",false) == false)
1027       {
1028          return _error->Error(_("Unable to fetch some archives, maybe run apt-get update or try with --fix-missing?"));
1029       }
1030
1031       if (Transient == true && Failed == true)
1032          return _error->Error(_("--fix-missing and media swapping is not currently supported"));
1033
1034       // Try to deal with missing package files
1035       if (Failed == true && PM->FixMissing() == false)
1036       {
1037          cerr << _("Unable to correct missing packages.") << endl;
1038          return _error->Error(_("Aborting install."));
1039       }
1040
1041       _system->UnLock();
1042       int status_fd = _config->FindI("APT::Status-Fd",-1);
1043       pkgPackageManager::OrderResult Res = PM->DoInstall(status_fd);
1044       if (Res == pkgPackageManager::Failed || _error->PendingError() == true)
1045          return false;
1046       if (Res == pkgPackageManager::Completed)
1047          return true;
1048
1049       // Reload the fetcher object and loop again for media swapping
1050       Fetcher.Shutdown();
1051       if (PM->GetArchives(&Fetcher,&List,&Recs) == false)
1052          return false;
1053
1054       _system->Lock();
1055    }
1056 }
1057                                                                         /*}}}*/
1058 // TryToInstall - Try to install a single package                       /*{{{*/
1059 // ---------------------------------------------------------------------
1060 /* This used to be inlined in DoInstall, but with the advent of regex package
1061    name matching it was split out.. */
1062 bool TryToInstall(pkgCache::PkgIterator Pkg,pkgDepCache &Cache,
1063                   pkgProblemResolver &Fix,bool Remove,bool BrokenFix,
1064                   unsigned int &ExpectedInst,bool AllowFail = true)
1065 {
1066    /* This is a pure virtual package and there is a single available
1067       candidate providing it. */
1068    if (Cache[Pkg].CandidateVer == 0 && Pkg->ProvidesList != 0)
1069    {
1070       pkgCache::PkgIterator Prov;
1071       bool found_one = false;
1072
1073       for (pkgCache::PrvIterator P = Pkg.ProvidesList(); P; P++)
1074       {
1075          pkgCache::VerIterator const PVer = P.OwnerVer();
1076          pkgCache::PkgIterator const PPkg = PVer.ParentPkg();
1077
1078          /* Ignore versions that are not a candidate. */
1079          if (Cache[PPkg].CandidateVer != PVer)
1080              continue;
1081
1082          if (found_one == false)
1083          {
1084             Prov = PPkg;
1085             found_one = true;
1086          }
1087          else if (PPkg != Prov)
1088          {
1089             found_one = false; // we found at least two
1090             break;
1091          }
1092       }
1093
1094       if (found_one == true)
1095       {
1096          ioprintf(c1out,_("Note, selecting %s instead of %s\n"),
1097                   Prov.FullName(true).c_str(),Pkg.FullName(true).c_str());
1098          Pkg = Prov;
1099       }
1100    }
1101
1102    // Handle the no-upgrade case
1103    if (_config->FindB("APT::Get::upgrade",true) == false &&
1104        Pkg->CurrentVer != 0)
1105    {
1106       if (AllowFail == true)
1107          ioprintf(c1out,_("Skipping %s, it is already installed and upgrade is not set.\n"),
1108                   Pkg.FullName(true).c_str());
1109       return true;
1110    }
1111
1112    // Ignore request for install if package would be new
1113    if (_config->FindB("APT::Get::Only-Upgrade", false) == true &&
1114        Pkg->CurrentVer == 0)
1115    {
1116       if (AllowFail == true)
1117          ioprintf(c1out,_("Skipping %s, it is not installed and only upgrades are requested.\n"),
1118                   Pkg.Name());
1119       return true;
1120    }
1121
1122    // Check if there is something at all to install
1123    pkgDepCache::StateCache &State = Cache[Pkg];
1124    if (Remove == true && Pkg->CurrentVer == 0)
1125    {
1126       Fix.Clear(Pkg);
1127       Fix.Protect(Pkg);
1128       Fix.Remove(Pkg);
1129
1130       /* We want to continue searching for regex hits, so we return false here
1131          otherwise this is not really an error. */
1132       if (AllowFail == false)
1133          return false;
1134
1135       ioprintf(c1out,_("Package %s is not installed, so not removed\n"),Pkg.FullName(true).c_str());
1136       return true;
1137    }
1138
1139    if (State.CandidateVer == 0 && Remove == false)
1140    {
1141       if (AllowFail == false)
1142          return false;
1143
1144       if (Pkg->ProvidesList != 0)
1145       {
1146          ioprintf(c1out,_("Package %s is a virtual package provided by:\n"),
1147                   Pkg.FullName(true).c_str());
1148
1149          pkgCache::PrvIterator I = Pkg.ProvidesList();
1150          unsigned short provider = 0;
1151          for (; I.end() == false; I++)
1152          {
1153             pkgCache::PkgIterator Pkg = I.OwnerPkg();
1154
1155             if (Cache[Pkg].CandidateVerIter(Cache) == I.OwnerVer())
1156             {
1157                c1out << "  " << Pkg.FullName(true) << " " << I.OwnerVer().VerStr();
1158                if (Cache[Pkg].Install() == true && Cache[Pkg].NewInstall() == false)
1159                   c1out << _(" [Installed]");
1160                c1out << endl;
1161                ++provider;
1162             }
1163          }
1164          // if we found no candidate which provide this package, show non-candidates
1165          if (provider == 0)
1166             for (I = Pkg.ProvidesList(); I.end() == false; I++)
1167                c1out << "  " << I.OwnerPkg().FullName(true) << " " << I.OwnerVer().VerStr()
1168                 << _(" [Not candidate version]") << endl;
1169          else
1170             c1out << _("You should explicitly select one to install.") << endl;
1171       }
1172       else
1173       {
1174          ioprintf(c1out,
1175          _("Package %s is not available, but is referred to by another package.\n"
1176            "This may mean that the package is missing, has been obsoleted, or\n"
1177            "is only available from another source\n"),Pkg.FullName(true).c_str());
1178
1179          string List;
1180          string VersionsList;
1181          SPtrArray<bool> Seen = new bool[Cache.Head().PackageCount];
1182          memset(Seen,0,Cache.Head().PackageCount*sizeof(*Seen));
1183          pkgCache::DepIterator Dep = Pkg.RevDependsList();
1184          for (; Dep.end() == false; Dep++)
1185          {
1186             if (Dep->Type != pkgCache::Dep::Replaces)
1187                continue;
1188             if (Seen[Dep.ParentPkg()->ID] == true)
1189                continue;
1190             Seen[Dep.ParentPkg()->ID] = true;
1191             List += Dep.ParentPkg().FullName(true) + " ";
1192         //VersionsList += string(Dep.ParentPkg().CurVersion) + "\n"; ???
1193          }
1194          ShowList(c1out,_("However the following packages replace it:"),List,VersionsList);
1195       }
1196
1197       _error->Error(_("Package %s has no installation candidate"),Pkg.FullName(true).c_str());
1198       return false;
1199    }
1200
1201    Fix.Clear(Pkg);
1202    Fix.Protect(Pkg);
1203    if (Remove == true)
1204    {
1205       Fix.Remove(Pkg);
1206       Cache.MarkDelete(Pkg,_config->FindB("APT::Get::Purge",false));
1207       return true;
1208    }
1209
1210    // Install it
1211    Cache.MarkInstall(Pkg,false);
1212    if (State.Install() == false)
1213    {
1214       if (_config->FindB("APT::Get::ReInstall",false) == true)
1215       {
1216          if (Pkg->CurrentVer == 0 || Pkg.CurrentVer().Downloadable() == false)
1217             ioprintf(c1out,_("Reinstallation of %s is not possible, it cannot be downloaded.\n"),
1218                      Pkg.FullName(true).c_str());
1219          else
1220             Cache.SetReInstall(Pkg,true);
1221       }
1222       else
1223       {
1224          if (AllowFail == true)
1225             ioprintf(c1out,_("%s is already the newest version.\n"),
1226                      Pkg.FullName(true).c_str());
1227       }
1228    }
1229    else
1230       ExpectedInst++;
1231
1232    // Install it with autoinstalling enabled (if we not respect the minial
1233    // required deps or the policy)
1234    if ((State.InstBroken() == true || State.InstPolicyBroken() == true) && BrokenFix == false)
1235       Cache.MarkInstall(Pkg,true);
1236
1237    return true;
1238 }
1239                                                                         /*}}}*/
1240 // TryToChangeVer - Try to change a candidate version                   /*{{{*/
1241 // ---------------------------------------------------------------------
1242 /* */
1243 bool TryToChangeVer(pkgCache::PkgIterator Pkg,pkgDepCache &Cache,
1244                     const char *VerTag,bool IsRel)
1245 {
1246    pkgVersionMatch Match(VerTag,(IsRel == true?pkgVersionMatch::Release :
1247                                  pkgVersionMatch::Version));
1248
1249    pkgCache::VerIterator Ver = Match.Find(Pkg);
1250
1251    if (Ver.end() == true)
1252    {
1253       if (IsRel == true)
1254          return _error->Error(_("Release '%s' for '%s' was not found"),
1255                               VerTag,Pkg.FullName(true).c_str());
1256       return _error->Error(_("Version '%s' for '%s' was not found"),
1257                            VerTag,Pkg.FullName(true).c_str());
1258    }
1259
1260    if (strcmp(VerTag,Ver.VerStr()) != 0)
1261    {
1262       ioprintf(c1out,_("Selected version %s (%s) for %s\n"),
1263                Ver.VerStr(),Ver.RelStr().c_str(),Pkg.FullName(true).c_str());
1264    }
1265
1266    Cache.SetCandidateVersion(Ver);
1267
1268    // Set the all package to the same candidate
1269    if (Ver.Pseudo() == true)
1270       Cache.SetCandidateVersion(Match.Find(Pkg.Group().FindPkg("all")));
1271
1272    return true;
1273 }
1274                                                                         /*}}}*/
1275 // FindSrc - Find a source record                                       /*{{{*/
1276 // ---------------------------------------------------------------------
1277 /* */
1278 pkgSrcRecords::Parser *FindSrc(const char *Name,pkgRecords &Recs,
1279                                pkgSrcRecords &SrcRecs,string &Src,
1280                                pkgDepCache &Cache)
1281 {
1282    string VerTag;
1283    string DefRel = _config->Find("APT::Default-Release");
1284    string TmpSrc = Name;
1285
1286    // extract the version/release from the pkgname
1287    const size_t found = TmpSrc.find_last_of("/=");
1288    if (found != string::npos) {
1289       if (TmpSrc[found] == '/')
1290          DefRel = TmpSrc.substr(found+1);
1291       else
1292          VerTag = TmpSrc.substr(found+1);
1293       TmpSrc = TmpSrc.substr(0,found);
1294    }
1295
1296    /* Lookup the version of the package we would install if we were to
1297       install a version and determine the source package name, then look
1298       in the archive for a source package of the same name. */
1299    bool MatchSrcOnly = _config->FindB("APT::Get::Only-Source");
1300    const pkgCache::PkgIterator Pkg = Cache.FindPkg(TmpSrc);
1301    if (MatchSrcOnly == false && Pkg.end() == false)
1302    {
1303       if(VerTag.empty() == false || DefRel.empty() == false)
1304       {
1305          bool fuzzy = false;
1306          // we have a default release, try to locate the pkg. we do it like
1307          // this because GetCandidateVer() will not "downgrade", that means
1308          // "apt-get source -t stable apt" won't work on a unstable system
1309          for (pkgCache::VerIterator Ver = Pkg.VersionList();; Ver++)
1310          {
1311             // try first only exact matches, later fuzzy matches
1312             if (Ver.end() == true)
1313             {
1314                if (fuzzy == true)
1315                   break;
1316                fuzzy = true;
1317                Ver = Pkg.VersionList();
1318             }
1319             // We match against a concrete version (or a part of this version)
1320             if (VerTag.empty() == false &&
1321                 (fuzzy == true || Cache.VS().CmpVersion(VerTag, Ver.VerStr()) != 0) && // exact match
1322                 (fuzzy == false || strncmp(VerTag.c_str(), Ver.VerStr(), VerTag.size()) != 0)) // fuzzy match
1323                continue;
1324
1325             for (pkgCache::VerFileIterator VF = Ver.FileList();
1326                  VF.end() == false; VF++)
1327             {
1328                /* If this is the status file, and the current version is not the
1329                   version in the status file (ie it is not installed, or somesuch)
1330                   then it is not a candidate for installation, ever. This weeds
1331                   out bogus entries that may be due to config-file states, or
1332                   other. */
1333                if ((VF.File()->Flags & pkgCache::Flag::NotSource) ==
1334                    pkgCache::Flag::NotSource && Pkg.CurrentVer() != Ver)
1335                   continue;
1336
1337                // or we match against a release
1338                if(VerTag.empty() == false ||
1339                   (VF.File().Archive() != 0 && VF.File().Archive() == DefRel) ||
1340                   (VF.File().Codename() != 0 && VF.File().Codename() == DefRel))
1341                {
1342                   pkgRecords::Parser &Parse = Recs.Lookup(VF);
1343                   Src = Parse.SourcePkg();
1344                   // no SourcePkg name, so it is the "binary" name
1345                   if (Src.empty() == true)
1346                      Src = TmpSrc;
1347                   // the Version we have is possibly fuzzy or includes binUploads,
1348                   // so we use the Version of the SourcePkg (empty if same as package)
1349                   VerTag = Parse.SourceVer();
1350                   if (VerTag.empty() == true)
1351                      VerTag = Ver.VerStr();
1352                   break;
1353                }
1354             }
1355             if (Src.empty() == false)
1356                break;
1357          }
1358          if (Src.empty() == true)
1359          {
1360             // Sources files have no codename information
1361             if (VerTag.empty() == true && DefRel.empty() == false)
1362             {
1363                _error->Error(_("Ignore unavailable target release '%s' of package '%s'"), DefRel.c_str(), TmpSrc.c_str());
1364                return 0;
1365             }
1366          }
1367       }
1368       if (Src.empty() == true)
1369       {
1370          // if we don't have found a fitting package yet so we will
1371          // choose a good candidate and proceed with that.
1372          // Maybe we will find a source later on with the right VerTag
1373          pkgCache::VerIterator Ver = Cache.GetCandidateVer(Pkg);
1374          if (Ver.end() == false)
1375          {
1376             pkgRecords::Parser &Parse = Recs.Lookup(Ver.FileList());
1377             Src = Parse.SourcePkg();
1378             if (VerTag.empty() == true)
1379                VerTag = Parse.SourceVer();
1380          }
1381       }
1382    }
1383
1384    if (Src.empty() == true)
1385       Src = TmpSrc;
1386    else
1387    {
1388       /* if we have a source pkg name, make sure to only search
1389          for srcpkg names, otherwise apt gets confused if there
1390          is a binary package "pkg1" and a source package "pkg1"
1391          with the same name but that comes from different packages */
1392       MatchSrcOnly = true;
1393       if (Src != TmpSrc)
1394       {
1395          ioprintf(c1out, _("Picking '%s' as source package instead of '%s'\n"), Src.c_str(), TmpSrc.c_str());
1396       }
1397    }
1398
1399    // The best hit
1400    pkgSrcRecords::Parser *Last = 0;
1401    unsigned long Offset = 0;
1402    string Version;
1403
1404    /* Iterate over all of the hits, which includes the resulting
1405       binary packages in the search */
1406    pkgSrcRecords::Parser *Parse;
1407    while (true)
1408    {
1409       SrcRecs.Restart();
1410       while ((Parse = SrcRecs.Find(Src.c_str(), MatchSrcOnly)) != 0)
1411       {
1412          const string Ver = Parse->Version();
1413
1414          // Ignore all versions which doesn't fit
1415          if (VerTag.empty() == false &&
1416              Cache.VS().CmpVersion(VerTag, Ver) != 0) // exact match
1417             continue;
1418
1419          // Newer version or an exact match? Save the hit
1420          if (Last == 0 || Cache.VS().CmpVersion(Version,Ver) < 0) {
1421             Last = Parse;
1422             Offset = Parse->Offset();
1423             Version = Ver;
1424          }
1425
1426          // was the version check above an exact match? If so, we don't need to look further
1427          if (VerTag.empty() == false && VerTag.size() == Ver.size())
1428             break;
1429       }
1430       if (Last != 0 || VerTag.empty() == true)
1431          break;
1432       //if (VerTag.empty() == false && Last == 0)
1433       _error->Error(_("Ignore unavailable version '%s' of package '%s'"), VerTag.c_str(), TmpSrc.c_str());
1434       return 0;
1435    }
1436
1437    if (Last == 0 || Last->Jump(Offset) == false)
1438       return 0;
1439
1440    return Last;
1441 }
1442                                                                         /*}}}*/
1443 // DoUpdate - Update the package lists                                  /*{{{*/
1444 // ---------------------------------------------------------------------
1445 /* */
1446 bool DoUpdate(CommandLine &CmdL)
1447 {
1448    if (CmdL.FileSize() != 1)
1449       return _error->Error(_("The update command takes no arguments"));
1450
1451    // Get the source list
1452    pkgSourceList List;
1453    if (List.ReadMainList() == false)
1454       return false;
1455
1456    // Create the progress
1457    AcqTextStatus Stat(ScreenWidth,_config->FindI("quiet",0));
1458
1459    // Just print out the uris an exit if the --print-uris flag was used
1460    if (_config->FindB("APT::Get::Print-URIs") == true)
1461    {
1462       // force a hashsum for compatibility reasons
1463       _config->CndSet("Acquire::ForceHash", "md5sum");
1464
1465       // get a fetcher
1466       pkgAcquire Fetcher;
1467       if (Fetcher.Setup(&Stat) == false)
1468          return false;
1469
1470       // Populate it with the source selection and get all Indexes
1471       // (GetAll=true)
1472       if (List.GetIndexes(&Fetcher,true) == false)
1473          return false;
1474
1475       pkgAcquire::UriIterator I = Fetcher.UriBegin();
1476       for (; I != Fetcher.UriEnd(); I++)
1477          cout << '\'' << I->URI << "' " << flNotDir(I->Owner->DestFile) << ' ' <<
1478                I->Owner->FileSize << ' ' << I->Owner->HashSum() << endl;
1479       return true;
1480    }
1481
1482    // do the work
1483    CacheFile Cache;
1484    if (_config->FindB("APT::Get::Download",true) == true)
1485        ListUpdate(Stat, List);
1486
1487    // Rebuild the cache.
1488    if (Cache.BuildCaches() == false)
1489       return false;
1490
1491    return true;
1492 }
1493                                                                         /*}}}*/
1494 // DoAutomaticRemove - Remove all automatic unused packages             /*{{{*/
1495 // ---------------------------------------------------------------------
1496 /* Remove unused automatic packages */
1497 bool DoAutomaticRemove(CacheFile &Cache)
1498 {
1499    bool Debug = _config->FindI("Debug::pkgAutoRemove",false);
1500    bool doAutoRemove = _config->FindB("APT::Get::AutomaticRemove", false);
1501    bool hideAutoRemove = _config->FindB("APT::Get::HideAutoRemove");
1502
1503    pkgDepCache::ActionGroup group(*Cache);
1504    if(Debug)
1505       std::cout << "DoAutomaticRemove()" << std::endl;
1506
1507    // we don't want to autoremove and we don't want to see it, so why calculating?
1508    if (doAutoRemove == false && hideAutoRemove == true)
1509       return true;
1510
1511    if (doAutoRemove == true &&
1512         _config->FindB("APT::Get::Remove",true) == false)
1513    {
1514       c1out << _("We are not supposed to delete stuff, can't start "
1515                  "AutoRemover") << std::endl;
1516       return false;
1517    }
1518
1519    bool purgePkgs = _config->FindB("APT::Get::Purge", false);
1520    bool smallList = (hideAutoRemove == false &&
1521         strcasecmp(_config->Find("APT::Get::HideAutoRemove","").c_str(),"small") == 0);
1522
1523    string autoremovelist, autoremoveversions;
1524    unsigned long autoRemoveCount = 0;
1525    // look over the cache to see what can be removed
1526    for (pkgCache::PkgIterator Pkg = Cache->PkgBegin(); ! Pkg.end(); ++Pkg)
1527    {
1528       if (Cache[Pkg].Garbage)
1529       {
1530          if(Pkg.CurrentVer() != 0 || Cache[Pkg].Install())
1531             if(Debug)
1532                std::cout << "We could delete %s" <<  Pkg.FullName(true).c_str() << std::endl;
1533
1534          if (doAutoRemove)
1535          {
1536             if(Pkg.CurrentVer() != 0 &&
1537                Pkg->CurrentState != pkgCache::State::ConfigFiles)
1538                Cache->MarkDelete(Pkg, purgePkgs);
1539             else
1540                Cache->MarkKeep(Pkg, false, false);
1541          }
1542          else
1543          {
1544             // only show stuff in the list that is not yet marked for removal
1545             if(Cache[Pkg].Delete() == false)
1546             {
1547                ++autoRemoveCount;
1548                // we don't need to fill the strings if we don't need them
1549                if (smallList == false)
1550                {
1551                  autoremovelist += Pkg.FullName(true) + " ";
1552                  autoremoveversions += string(Cache[Pkg].CandVersion) + "\n";
1553                }
1554             }
1555          }
1556       }
1557    }
1558    // if we don't remove them, we should show them!
1559    if (doAutoRemove == false && (autoremovelist.empty() == false || autoRemoveCount != 0))
1560    {
1561       if (smallList == false)
1562          ShowList(c1out, P_("The following package is automatically installed and is no longer required:",
1563                   "The following packages were automatically installed and are no longer required:",
1564                   autoRemoveCount), autoremovelist, autoremoveversions);
1565       else
1566          ioprintf(c1out, P_("%lu package was automatically installed and is no longer required.\n",
1567                   "%lu packages were automatically installed and are no longer required.\n", autoRemoveCount), autoRemoveCount);
1568       c1out << _("Use 'apt-get autoremove' to remove them.") << std::endl;
1569    }
1570    // Now see if we had destroyed anything (if we had done anything)
1571    else if (Cache->BrokenCount() != 0)
1572    {
1573       c1out << _("Hmm, seems like the AutoRemover destroyed something which really\n"
1574                  "shouldn't happen. Please file a bug report against apt.") << endl;
1575       c1out << endl;
1576       c1out << _("The following information may help to resolve the situation:") << endl;
1577       c1out << endl;
1578       ShowBroken(c1out,Cache,false);
1579
1580       return _error->Error(_("Internal Error, AutoRemover broke stuff"));
1581    }
1582    return true;
1583 }
1584                                                                         /*}}}*/
1585 // DoUpgrade - Upgrade all packages                                     /*{{{*/
1586 // ---------------------------------------------------------------------
1587 /* Upgrade all packages without installing new packages or erasing old
1588    packages */
1589 bool DoUpgrade(CommandLine &CmdL)
1590 {
1591    CacheFile Cache;
1592    if (Cache.OpenForInstall() == false || Cache.CheckDeps() == false)
1593       return false;
1594
1595    // Do the upgrade
1596    if (pkgAllUpgrade(Cache) == false)
1597    {
1598       ShowBroken(c1out,Cache,false);
1599       return _error->Error(_("Internal error, AllUpgrade broke stuff"));
1600    }
1601
1602    return InstallPackages(Cache,true);
1603 }
1604                                                                         /*}}}*/
1605 // DoInstallTask - Install task from the command line                   /*{{{*/
1606 // ---------------------------------------------------------------------
1607 /* Install named task */
1608 bool TryInstallTask(pkgDepCache &Cache, pkgProblemResolver &Fix,
1609                     bool BrokenFix,
1610                     unsigned int& ExpectedInst,
1611                     const char *taskname,
1612                     bool Remove)
1613 {
1614    const char *start, *end;
1615    pkgCache::PkgIterator Pkg;
1616    char buf[64*1024];
1617    regex_t Pattern;
1618
1619    // get the records
1620    pkgRecords Recs(Cache);
1621
1622    // build regexp for the task
1623    char S[300];
1624    snprintf(S, sizeof(S), "^Task:.*[, ]%s([, ]|$)", taskname);
1625    if(regcomp(&Pattern,S, REG_EXTENDED | REG_NOSUB | REG_NEWLINE) != 0)
1626       return _error->Error("Failed to compile task regexp");
1627
1628    bool found = false;
1629    bool res = true;
1630
1631    // two runs, first ignore dependencies, second install any missing
1632    for(int IgnoreBroken=1; IgnoreBroken >= 0; IgnoreBroken--)
1633    {
1634       for (Pkg = Cache.PkgBegin(); Pkg.end() == false; Pkg++)
1635       {
1636          pkgCache::VerIterator ver = Cache[Pkg].CandidateVerIter(Cache);
1637          if(ver.end())
1638             continue;
1639          pkgRecords::Parser &parser = Recs.Lookup(ver.FileList());
1640          parser.GetRec(start,end);
1641          strncpy(buf, start, end-start);
1642          buf[end-start] = 0x0;
1643          if (regexec(&Pattern,buf,0,0,0) != 0)
1644             continue;
1645          res &= TryToInstall(Pkg,Cache,Fix,Remove,IgnoreBroken,ExpectedInst);
1646          found = true;
1647       }
1648    }
1649
1650    // now let the problem resolver deal with any issues
1651    Fix.Resolve(true);
1652
1653    if(!found)
1654       _error->Error(_("Couldn't find task %s"),taskname);
1655
1656    regfree(&Pattern);
1657    return res;
1658 }
1659                                                                         /*}}}*/
1660 // DoInstall - Install packages from the command line                   /*{{{*/
1661 // ---------------------------------------------------------------------
1662 /* Install named packages */
1663 bool DoInstall(CommandLine &CmdL)
1664 {
1665    CacheFile Cache;
1666    if (Cache.OpenForInstall() == false ||
1667        Cache.CheckDeps(CmdL.FileSize() != 1) == false)
1668       return false;
1669
1670    // Enter the special broken fixing mode if the user specified arguments
1671    bool BrokenFix = false;
1672    if (Cache->BrokenCount() != 0)
1673       BrokenFix = true;
1674
1675    unsigned int AutoMarkChanged = 0;
1676    unsigned int ExpectedInst = 0;
1677    unsigned int Packages = 0;
1678    pkgProblemResolver Fix(Cache);
1679
1680    bool DefRemove = false;
1681    if (strcasecmp(CmdL.FileList[0],"remove") == 0)
1682       DefRemove = true;
1683    else if (strcasecmp(CmdL.FileList[0], "purge") == 0)
1684    {
1685       _config->Set("APT::Get::Purge", true);
1686       DefRemove = true;
1687    }
1688    else if (strcasecmp(CmdL.FileList[0], "autoremove") == 0)
1689    {
1690       _config->Set("APT::Get::AutomaticRemove", "true");
1691       DefRemove = true;
1692    }
1693    // new scope for the ActionGroup
1694    {
1695       pkgDepCache::ActionGroup group(Cache);
1696       for (const char **I = CmdL.FileList + 1; *I != 0; I++)
1697       {
1698          // Duplicate the string
1699          unsigned int Length = strlen(*I);
1700          char S[300];
1701          if (Length >= sizeof(S))
1702             continue;
1703          strcpy(S,*I);
1704
1705          // See if we are removing and special indicators..
1706          bool Remove = DefRemove;
1707          char *VerTag = 0;
1708          bool VerIsRel = false;
1709
1710          // this is a task!
1711          if (Length >= 1 && S[Length - 1] == '^')
1712          {
1713             S[--Length] = 0;
1714             // tasks must always be confirmed
1715             ExpectedInst += 1000;
1716             // see if we can install it
1717             TryInstallTask(Cache, Fix, BrokenFix, ExpectedInst, S, Remove);
1718             continue;
1719          }
1720
1721          while (Cache->FindPkg(S).end() == true)
1722          {
1723             // Handle an optional end tag indicating what to do
1724             if (Length >= 1 && S[Length - 1] == '-')
1725             {
1726                Remove = true;
1727                S[--Length] = 0;
1728                continue;
1729             }
1730
1731             if (Length >= 1 && S[Length - 1] == '+')
1732             {
1733                Remove = false;
1734                S[--Length] = 0;
1735                continue;
1736             }
1737
1738             char *Slash = strchr(S,'=');
1739             if (Slash != 0)
1740             {
1741                VerIsRel = false;
1742                *Slash = 0;
1743                VerTag = Slash + 1;
1744             }
1745
1746             Slash = strchr(S,'/');
1747             if (Slash != 0)
1748             {
1749                VerIsRel = true;
1750                *Slash = 0;
1751                VerTag = Slash + 1;
1752             }
1753
1754             break;
1755          }
1756
1757          // Locate the package
1758          pkgCache::PkgIterator Pkg = Cache->FindPkg(S);
1759          Packages++;
1760          if (Pkg.end() == true)
1761          {
1762             // Check if the name is a regex
1763             const char *I;
1764             for (I = S; *I != 0; I++)
1765                if (*I == '?' || *I == '*' || *I == '|' ||
1766                    *I == '[' || *I == '^' || *I == '$')
1767                   break;
1768             if (*I == 0)
1769                return _error->Error(_("Couldn't find package %s"),S);
1770
1771             // Regexs must always be confirmed
1772             ExpectedInst += 1000;
1773
1774             // Compile the regex pattern
1775             regex_t Pattern;
1776             int Res;
1777             if ((Res = regcomp(&Pattern,S,REG_EXTENDED | REG_ICASE |
1778                                REG_NOSUB)) != 0)
1779             {
1780                char Error[300];
1781                regerror(Res,&Pattern,Error,sizeof(Error));
1782                return _error->Error(_("Regex compilation error - %s"),Error);
1783             }
1784
1785             // Run over the matches
1786             bool Hit = false;
1787             for (pkgCache::GrpIterator Grp = Cache->GrpBegin(); Grp.end() == false; ++Grp)
1788             {
1789                if (regexec(&Pattern,Grp.Name(),0,0,0) != 0)
1790                   continue;
1791                Pkg = Grp.FindPkg("native");
1792                if (unlikely(Pkg.end() == true))
1793                   continue;
1794
1795                ioprintf(c1out,_("Note, selecting %s for regex '%s'\n"),
1796                         Pkg.Name(),S);
1797
1798                if (VerTag != 0)
1799                   if (TryToChangeVer(Pkg,Cache,VerTag,VerIsRel) == false)
1800                      return false;
1801
1802                Hit |= TryToInstall(Pkg,Cache,Fix,Remove,BrokenFix,
1803                                    ExpectedInst,false);
1804             }
1805             regfree(&Pattern);
1806
1807             if (Hit == false)
1808                return _error->Error(_("Couldn't find package %s"),S);
1809          }
1810          else
1811          {
1812             if (VerTag != 0)
1813                if (TryToChangeVer(Pkg,Cache,VerTag,VerIsRel) == false)
1814                   return false;
1815             if (TryToInstall(Pkg,Cache,Fix,Remove,BrokenFix,ExpectedInst) == false)
1816                return false;
1817
1818             // see if we need to fix the auto-mark flag
1819             // e.g. apt-get install foo
1820             // where foo is marked automatic
1821             if(!Remove &&
1822                Cache[Pkg].Install() == false &&
1823                (Cache[Pkg].Flags & pkgCache::Flag::Auto) &&
1824                _config->FindB("APT::Get::ReInstall",false) == false &&
1825                _config->FindB("APT::Get::Only-Upgrade",false) == false &&
1826                _config->FindB("APT::Get::Download-Only",false) == false)
1827             {
1828                ioprintf(c1out,_("%s set to manually installed.\n"),
1829                         Pkg.FullName(true).c_str());
1830                Cache->MarkAuto(Pkg,false);
1831                AutoMarkChanged++;
1832             }
1833          }
1834       }
1835
1836       /* If we are in the Broken fixing mode we do not attempt to fix the
1837          problems. This is if the user invoked install without -f and gave
1838          packages */
1839       if (BrokenFix == true && Cache->BrokenCount() != 0)
1840       {
1841          c1out << _("You might want to run 'apt-get -f install' to correct these:") << endl;
1842          ShowBroken(c1out,Cache,false);
1843
1844          return _error->Error(_("Unmet dependencies. Try 'apt-get -f install' with no packages (or specify a solution)."));
1845       }
1846
1847       // Call the scored problem resolver
1848       Fix.InstallProtect();
1849       if (Fix.Resolve(true) == false)
1850          _error->Discard();
1851
1852       // Now we check the state of the packages,
1853       if (Cache->BrokenCount() != 0)
1854       {
1855          c1out <<
1856             _("Some packages could not be installed. This may mean that you have\n"
1857               "requested an impossible situation or if you are using the unstable\n"
1858               "distribution that some required packages have not yet been created\n"
1859               "or been moved out of Incoming.") << endl;
1860          /*
1861          if (Packages == 1)
1862          {
1863             c1out << endl;
1864             c1out <<
1865                _("Since you only requested a single operation it is extremely likely that\n"
1866                  "the package is simply not installable and a bug report against\n"
1867                  "that package should be filed.") << endl;
1868          }
1869          */
1870
1871          c1out << _("The following information may help to resolve the situation:") << endl;
1872          c1out << endl;
1873          ShowBroken(c1out,Cache,false);
1874          return _error->Error(_("Broken packages"));
1875       }
1876    }
1877    if (!DoAutomaticRemove(Cache))
1878       return false;
1879
1880    /* Print out a list of packages that are going to be installed extra
1881       to what the user asked */
1882    if (Cache->InstCount() != ExpectedInst)
1883    {
1884       string List;
1885       string VersionsList;
1886       for (unsigned J = 0; J < Cache->Head().PackageCount; J++)
1887       {
1888          pkgCache::PkgIterator I(Cache,Cache.List[J]);
1889          if ((*Cache)[I].Install() == false)
1890             continue;
1891
1892          const char **J;
1893          for (J = CmdL.FileList + 1; *J != 0; J++)
1894             if (strcmp(*J,I.Name()) == 0)
1895                 break;
1896
1897          if (*J == 0) {
1898             List += I.FullName(true) + " ";
1899             VersionsList += string(Cache[I].CandVersion) + "\n";
1900          }
1901       }
1902
1903       ShowList(c1out,_("The following extra packages will be installed:"),List,VersionsList);
1904    }
1905
1906    /* Print out a list of suggested and recommended packages */
1907    {
1908       string SuggestsList, RecommendsList, List;
1909       string SuggestsVersions, RecommendsVersions;
1910       for (unsigned J = 0; J < Cache->Head().PackageCount; J++)
1911       {
1912          pkgCache::PkgIterator Pkg(Cache,Cache.List[J]);
1913
1914          /* Just look at the ones we want to install */
1915          if ((*Cache)[Pkg].Install() == false)
1916            continue;
1917
1918          // get the recommends/suggests for the candidate ver
1919          pkgCache::VerIterator CV = (*Cache)[Pkg].CandidateVerIter(*Cache);
1920          for (pkgCache::DepIterator D = CV.DependsList(); D.end() == false; )
1921          {
1922             pkgCache::DepIterator Start;
1923             pkgCache::DepIterator End;
1924             D.GlobOr(Start,End); // advances D
1925
1926             // FIXME: we really should display a or-group as a or-group to the user
1927             //        the problem is that ShowList is incapable of doing this
1928             string RecommendsOrList,RecommendsOrVersions;
1929             string SuggestsOrList,SuggestsOrVersions;
1930             bool foundInstalledInOrGroup = false;
1931             for(;;)
1932             {
1933                /* Skip if package is  installed already, or is about to be */
1934                string target = Start.TargetPkg().FullName(true) + " ";
1935
1936                if ((*Start.TargetPkg()).SelectedState == pkgCache::State::Install
1937                    || Cache[Start.TargetPkg()].Install())
1938                {
1939                   foundInstalledInOrGroup=true;
1940                   break;
1941                }
1942
1943                /* Skip if we already saw it */
1944                if (int(SuggestsList.find(target)) != -1 || int(RecommendsList.find(target)) != -1)
1945                {
1946                   foundInstalledInOrGroup=true;
1947                   break;
1948                }
1949
1950                // this is a dep on a virtual pkg, check if any package that provides it
1951                // should be installed
1952                if(Start.TargetPkg().ProvidesList() != 0)
1953                {
1954                   pkgCache::PrvIterator I = Start.TargetPkg().ProvidesList();
1955                   for (; I.end() == false; I++)
1956                   {
1957                      pkgCache::PkgIterator Pkg = I.OwnerPkg();
1958                      if (Cache[Pkg].CandidateVerIter(Cache) == I.OwnerVer() &&
1959                          Pkg.CurrentVer() != 0)
1960                         foundInstalledInOrGroup=true;
1961                   }
1962                }
1963
1964                if (Start->Type == pkgCache::Dep::Suggests)
1965                {
1966                   SuggestsOrList += target;
1967                   SuggestsOrVersions += string(Cache[Start.TargetPkg()].CandVersion) + "\n";
1968                }
1969
1970                if (Start->Type == pkgCache::Dep::Recommends)
1971                {
1972                   RecommendsOrList += target;
1973                   RecommendsOrVersions += string(Cache[Start.TargetPkg()].CandVersion) + "\n";
1974                }
1975
1976                if (Start >= End)
1977                   break;
1978                Start++;
1979             }
1980
1981             if(foundInstalledInOrGroup == false)
1982             {
1983                RecommendsList += RecommendsOrList;
1984                RecommendsVersions += RecommendsOrVersions;
1985                SuggestsList += SuggestsOrList;
1986                SuggestsVersions += SuggestsOrVersions;
1987             }
1988
1989          }
1990       }
1991
1992       ShowList(c1out,_("Suggested packages:"),SuggestsList,SuggestsVersions);
1993       ShowList(c1out,_("Recommended packages:"),RecommendsList,RecommendsVersions);
1994
1995    }
1996
1997    // if nothing changed in the cache, but only the automark information
1998    // we write the StateFile here, otherwise it will be written in
1999    // cache.commit()
2000    if (AutoMarkChanged > 0 &&
2001        Cache->DelCount() == 0 && Cache->InstCount() == 0 &&
2002        Cache->BadCount() == 0 &&
2003        _config->FindB("APT::Get::Simulate",false) == false)
2004       Cache->writeStateFile(NULL);
2005
2006    // See if we need to prompt
2007    if (Cache->InstCount() == ExpectedInst && Cache->DelCount() == 0)
2008       return InstallPackages(Cache,false,false);
2009
2010    return InstallPackages(Cache,false);
2011 }
2012                                                                         /*}}}*/
2013 // DoDistUpgrade - Automatic smart upgrader                             /*{{{*/
2014 // ---------------------------------------------------------------------
2015 /* Intelligent upgrader that will install and remove packages at will */
2016 bool DoDistUpgrade(CommandLine &CmdL)
2017 {
2018    CacheFile Cache;
2019    if (Cache.OpenForInstall() == false || Cache.CheckDeps() == false)
2020       return false;
2021
2022    c0out << _("Calculating upgrade... ") << flush;
2023    if (pkgDistUpgrade(*Cache) == false)
2024    {
2025       c0out << _("Failed") << endl;
2026       ShowBroken(c1out,Cache,false);
2027       return false;
2028    }
2029
2030    c0out << _("Done") << endl;
2031
2032    return InstallPackages(Cache,true);
2033 }
2034                                                                         /*}}}*/
2035 // DoDSelectUpgrade - Do an upgrade by following dselects selections    /*{{{*/
2036 // ---------------------------------------------------------------------
2037 /* Follows dselect's selections */
2038 bool DoDSelectUpgrade(CommandLine &CmdL)
2039 {
2040    CacheFile Cache;
2041    if (Cache.OpenForInstall() == false || Cache.CheckDeps() == false)
2042       return false;
2043
2044    pkgDepCache::ActionGroup group(Cache);
2045
2046    // Install everything with the install flag set
2047    pkgCache::PkgIterator I = Cache->PkgBegin();
2048    for (;I.end() != true; I++)
2049    {
2050       /* Install the package only if it is a new install, the autoupgrader
2051          will deal with the rest */
2052       if (I->SelectedState == pkgCache::State::Install)
2053          Cache->MarkInstall(I,false);
2054    }
2055
2056    /* Now install their deps too, if we do this above then order of
2057       the status file is significant for | groups */
2058    for (I = Cache->PkgBegin();I.end() != true; I++)
2059    {
2060       /* Install the package only if it is a new install, the autoupgrader
2061          will deal with the rest */
2062       if (I->SelectedState == pkgCache::State::Install)
2063          Cache->MarkInstall(I,true);
2064    }
2065
2066    // Apply erasures now, they override everything else.
2067    for (I = Cache->PkgBegin();I.end() != true; I++)
2068    {
2069       // Remove packages
2070       if (I->SelectedState == pkgCache::State::DeInstall ||
2071           I->SelectedState == pkgCache::State::Purge)
2072          Cache->MarkDelete(I,I->SelectedState == pkgCache::State::Purge);
2073    }
2074
2075    /* Resolve any problems that dselect created, allupgrade cannot handle
2076       such things. We do so quite agressively too.. */
2077    if (Cache->BrokenCount() != 0)
2078    {
2079       pkgProblemResolver Fix(Cache);
2080
2081       // Hold back held packages.
2082       if (_config->FindB("APT::Ignore-Hold",false) == false)
2083       {
2084          for (pkgCache::PkgIterator I = Cache->PkgBegin(); I.end() == false; I++)
2085          {
2086             if (I->SelectedState == pkgCache::State::Hold)
2087             {
2088                Fix.Protect(I);
2089                Cache->MarkKeep(I);
2090             }
2091          }
2092       }
2093
2094       if (Fix.Resolve() == false)
2095       {
2096          ShowBroken(c1out,Cache,false);
2097          return _error->Error(_("Internal error, problem resolver broke stuff"));
2098       }
2099    }
2100
2101    // Now upgrade everything
2102    if (pkgAllUpgrade(Cache) == false)
2103    {
2104       ShowBroken(c1out,Cache,false);
2105       return _error->Error(_("Internal error, problem resolver broke stuff"));
2106    }
2107
2108    return InstallPackages(Cache,false);
2109 }
2110                                                                         /*}}}*/
2111 // DoClean - Remove download archives                                   /*{{{*/
2112 // ---------------------------------------------------------------------
2113 /* */
2114 bool DoClean(CommandLine &CmdL)
2115 {
2116    if (_config->FindB("APT::Get::Simulate") == true)
2117    {
2118       cout << "Del " << _config->FindDir("Dir::Cache::archives") << "* " <<
2119          _config->FindDir("Dir::Cache::archives") << "partial/*" << endl;
2120       return true;
2121    }
2122
2123    // Lock the archive directory
2124    FileFd Lock;
2125    if (_config->FindB("Debug::NoLocking",false) == false)
2126    {
2127       Lock.Fd(GetLock(_config->FindDir("Dir::Cache::Archives") + "lock"));
2128       if (_error->PendingError() == true)
2129          return _error->Error(_("Unable to lock the download directory"));
2130    }
2131
2132    pkgAcquire Fetcher;
2133    Fetcher.Clean(_config->FindDir("Dir::Cache::archives"));
2134    Fetcher.Clean(_config->FindDir("Dir::Cache::archives") + "partial/");
2135    return true;
2136 }
2137                                                                         /*}}}*/
2138 // DoAutoClean - Smartly remove downloaded archives                     /*{{{*/
2139 // ---------------------------------------------------------------------
2140 /* This is similar to clean but it only purges things that cannot be
2141    downloaded, that is old versions of cached packages. */
2142 class LogCleaner : public pkgArchiveCleaner
2143 {
2144    protected:
2145    virtual void Erase(const char *File,string Pkg,string Ver,struct stat &St)
2146    {
2147       c1out << "Del " << Pkg << " " << Ver << " [" << SizeToStr(St.st_size) << "B]" << endl;
2148
2149       if (_config->FindB("APT::Get::Simulate") == false)
2150          unlink(File);
2151    };
2152 };
2153
2154 bool DoAutoClean(CommandLine &CmdL)
2155 {
2156    // Lock the archive directory
2157    FileFd Lock;
2158    if (_config->FindB("Debug::NoLocking",false) == false)
2159    {
2160       Lock.Fd(GetLock(_config->FindDir("Dir::Cache::Archives") + "lock"));
2161       if (_error->PendingError() == true)
2162          return _error->Error(_("Unable to lock the download directory"));
2163    }
2164
2165    CacheFile Cache;
2166    if (Cache.Open() == false)
2167       return false;
2168
2169    LogCleaner Cleaner;
2170
2171    return Cleaner.Go(_config->FindDir("Dir::Cache::archives"),*Cache) &&
2172       Cleaner.Go(_config->FindDir("Dir::Cache::archives") + "partial/",*Cache);
2173 }
2174                                                                         /*}}}*/
2175 // DoCheck - Perform the check operation                                /*{{{*/
2176 // ---------------------------------------------------------------------
2177 /* Opening automatically checks the system, this command is mostly used
2178    for debugging */
2179 bool DoCheck(CommandLine &CmdL)
2180 {
2181    CacheFile Cache;
2182    Cache.Open();
2183    Cache.CheckDeps();
2184
2185    return true;
2186 }
2187                                                                         /*}}}*/
2188 // DoSource - Fetch a source archive                                    /*{{{*/
2189 // ---------------------------------------------------------------------
2190 /* Fetch souce packages */
2191 struct DscFile
2192 {
2193    string Package;
2194    string Version;
2195    string Dsc;
2196 };
2197
2198 bool DoSource(CommandLine &CmdL)
2199 {
2200    CacheFile Cache;
2201    if (Cache.Open(false) == false)
2202       return false;
2203
2204    if (CmdL.FileSize() <= 1)
2205       return _error->Error(_("Must specify at least one package to fetch source for"));
2206
2207    // Read the source list
2208    pkgSourceList List;
2209    if (List.ReadMainList() == false)
2210       return _error->Error(_("The list of sources could not be read."));
2211
2212    // Create the text record parsers
2213    pkgRecords Recs(Cache);
2214    pkgSrcRecords SrcRecs(List);
2215    if (_error->PendingError() == true)
2216       return false;
2217
2218    // Create the download object
2219    AcqTextStatus Stat(ScreenWidth,_config->FindI("quiet",0));
2220    pkgAcquire Fetcher;
2221    if (Fetcher.Setup(&Stat) == false)
2222       return false;
2223
2224    DscFile *Dsc = new DscFile[CmdL.FileSize()];
2225
2226    // insert all downloaded uris into this set to avoid downloading them
2227    // twice
2228    set<string> queued;
2229    // Load the requestd sources into the fetcher
2230    unsigned J = 0;
2231    for (const char **I = CmdL.FileList + 1; *I != 0; I++, J++)
2232    {
2233       string Src;
2234       pkgSrcRecords::Parser *Last = FindSrc(*I,Recs,SrcRecs,Src,*Cache);
2235
2236       if (Last == 0)
2237          return _error->Error(_("Unable to find a source package for %s"),Src.c_str());
2238
2239       // Back track
2240       vector<pkgSrcRecords::File> Lst;
2241       if (Last->Files(Lst) == false)
2242          return false;
2243
2244       // Load them into the fetcher
2245       for (vector<pkgSrcRecords::File>::const_iterator I = Lst.begin();
2246            I != Lst.end(); I++)
2247       {
2248          // Try to guess what sort of file it is we are getting.
2249          if (I->Type == "dsc")
2250          {
2251             Dsc[J].Package = Last->Package();
2252             Dsc[J].Version = Last->Version();
2253             Dsc[J].Dsc = flNotDir(I->Path);
2254          }
2255
2256          // Diff only mode only fetches .diff files
2257          if (_config->FindB("APT::Get::Diff-Only",false) == true &&
2258              I->Type != "diff")
2259             continue;
2260
2261          // Tar only mode only fetches .tar files
2262          if (_config->FindB("APT::Get::Tar-Only",false) == true &&
2263              I->Type != "tar")
2264             continue;
2265
2266          // Dsc only mode only fetches .dsc files
2267          if (_config->FindB("APT::Get::Dsc-Only",false) == true &&
2268              I->Type != "dsc")
2269             continue;
2270
2271          // don't download the same uri twice (should this be moved to
2272          // the fetcher interface itself?)
2273          if(queued.find(Last->Index().ArchiveURI(I->Path)) != queued.end())
2274             continue;
2275          queued.insert(Last->Index().ArchiveURI(I->Path));
2276
2277          // check if we have a file with that md5 sum already localy
2278          if(!I->MD5Hash.empty() && FileExists(flNotDir(I->Path)))
2279          {
2280             FileFd Fd(flNotDir(I->Path), FileFd::ReadOnly);
2281             MD5Summation sum;
2282             sum.AddFD(Fd.Fd(), Fd.Size());
2283             Fd.Close();
2284             if((string)sum.Result() == I->MD5Hash)
2285             {
2286                ioprintf(c1out,_("Skipping already downloaded file '%s'\n"),
2287                         flNotDir(I->Path).c_str());
2288                continue;
2289             }
2290          }
2291
2292          new pkgAcqFile(&Fetcher,Last->Index().ArchiveURI(I->Path),
2293                         I->MD5Hash,I->Size,
2294                         Last->Index().SourceInfo(*Last,*I),Src);
2295       }
2296    }
2297
2298    // Display statistics
2299    double FetchBytes = Fetcher.FetchNeeded();
2300    double FetchPBytes = Fetcher.PartialPresent();
2301    double DebBytes = Fetcher.TotalNeeded();
2302
2303    // Check for enough free space
2304    struct statvfs Buf;
2305    string OutputDir = ".";
2306    if (statvfs(OutputDir.c_str(),&Buf) != 0) {
2307       if (errno == EOVERFLOW)
2308          return _error->WarningE("statvfs",_("Couldn't determine free space in %s"),
2309                                 OutputDir.c_str());
2310       else
2311          return _error->Errno("statvfs",_("Couldn't determine free space in %s"),
2312                                 OutputDir.c_str());
2313    } else if (unsigned(Buf.f_bfree) < (FetchBytes - FetchPBytes)/Buf.f_bsize)
2314      {
2315        struct statfs Stat;
2316        if (statfs(OutputDir.c_str(),&Stat) != 0
2317 #if HAVE_STRUCT_STATFS_F_TYPE
2318            || unsigned(Stat.f_type) != RAMFS_MAGIC
2319 #endif
2320            )
2321           return _error->Error(_("You don't have enough free space in %s"),
2322               OutputDir.c_str());
2323       }
2324
2325    // Number of bytes
2326    if (DebBytes != FetchBytes)
2327       ioprintf(c1out,_("Need to get %sB/%sB of source archives.\n"),
2328                SizeToStr(FetchBytes).c_str(),SizeToStr(DebBytes).c_str());
2329    else
2330       ioprintf(c1out,_("Need to get %sB of source archives.\n"),
2331                SizeToStr(DebBytes).c_str());
2332
2333    if (_config->FindB("APT::Get::Simulate",false) == true)
2334    {
2335       for (unsigned I = 0; I != J; I++)
2336          ioprintf(cout,_("Fetch source %s\n"),Dsc[I].Package.c_str());
2337       delete[] Dsc;
2338       return true;
2339    }
2340
2341    // Just print out the uris an exit if the --print-uris flag was used
2342    if (_config->FindB("APT::Get::Print-URIs") == true)
2343    {
2344       pkgAcquire::UriIterator I = Fetcher.UriBegin();
2345       for (; I != Fetcher.UriEnd(); I++)
2346          cout << '\'' << I->URI << "' " << flNotDir(I->Owner->DestFile) << ' ' <<
2347                I->Owner->FileSize << ' ' << I->Owner->HashSum() << endl;
2348       delete[] Dsc;
2349       return true;
2350    }
2351
2352    // Run it
2353    if (Fetcher.Run() == pkgAcquire::Failed)
2354       return false;
2355
2356    // Print error messages
2357    bool Failed = false;
2358    for (pkgAcquire::ItemIterator I = Fetcher.ItemsBegin(); I != Fetcher.ItemsEnd(); I++)
2359    {
2360       if ((*I)->Status == pkgAcquire::Item::StatDone &&
2361           (*I)->Complete == true)
2362          continue;
2363
2364       fprintf(stderr,_("Failed to fetch %s  %s\n"),(*I)->DescURI().c_str(),
2365               (*I)->ErrorText.c_str());
2366       Failed = true;
2367    }
2368    if (Failed == true)
2369       return _error->Error(_("Failed to fetch some archives."));
2370
2371    if (_config->FindB("APT::Get::Download-only",false) == true)
2372    {
2373       c1out << _("Download complete and in download only mode") << endl;
2374       delete[] Dsc;
2375       return true;
2376    }
2377
2378    // Unpack the sources
2379    pid_t Process = ExecFork();
2380
2381    if (Process == 0)
2382    {
2383       for (unsigned I = 0; I != J; I++)
2384       {
2385          string Dir = Dsc[I].Package + '-' + Cache->VS().UpstreamVersion(Dsc[I].Version.c_str());
2386
2387          // Diff only mode only fetches .diff files
2388          if (_config->FindB("APT::Get::Diff-Only",false) == true ||
2389              _config->FindB("APT::Get::Tar-Only",false) == true ||
2390              Dsc[I].Dsc.empty() == true)
2391             continue;
2392
2393          // See if the package is already unpacked
2394          struct stat Stat;
2395          if (stat(Dir.c_str(),&Stat) == 0 &&
2396              S_ISDIR(Stat.st_mode) != 0)
2397          {
2398             ioprintf(c0out ,_("Skipping unpack of already unpacked source in %s\n"),
2399                               Dir.c_str());
2400          }
2401          else
2402          {
2403             // Call dpkg-source
2404             char S[500];
2405             snprintf(S,sizeof(S),"%s -x %s",
2406                      _config->Find("Dir::Bin::dpkg-source","dpkg-source").c_str(),
2407                      Dsc[I].Dsc.c_str());
2408             if (system(S) != 0)
2409             {
2410                fprintf(stderr,_("Unpack command '%s' failed.\n"),S);
2411                fprintf(stderr,_("Check if the 'dpkg-dev' package is installed.\n"));
2412                _exit(1);
2413             }
2414          }
2415
2416          // Try to compile it with dpkg-buildpackage
2417          if (_config->FindB("APT::Get::Compile",false) == true)
2418          {
2419             // Call dpkg-buildpackage
2420             char S[500];
2421             snprintf(S,sizeof(S),"cd %s && %s %s",
2422                      Dir.c_str(),
2423                      _config->Find("Dir::Bin::dpkg-buildpackage","dpkg-buildpackage").c_str(),
2424                      _config->Find("DPkg::Build-Options","-b -uc").c_str());
2425
2426             if (system(S) != 0)
2427             {
2428                fprintf(stderr,_("Build command '%s' failed.\n"),S);
2429                _exit(1);
2430             }
2431          }
2432       }
2433
2434       _exit(0);
2435    }
2436    delete[] Dsc;
2437
2438    // Wait for the subprocess
2439    int Status = 0;
2440    while (waitpid(Process,&Status,0) != Process)
2441    {
2442       if (errno == EINTR)
2443          continue;
2444       return _error->Errno("waitpid","Couldn't wait for subprocess");
2445    }
2446
2447    if (WIFEXITED(Status) == 0 || WEXITSTATUS(Status) != 0)
2448       return _error->Error(_("Child process failed"));
2449
2450    return true;
2451 }
2452                                                                         /*}}}*/
2453 // DoBuildDep - Install/removes packages to satisfy build dependencies  /*{{{*/
2454 // ---------------------------------------------------------------------
2455 /* This function will look at the build depends list of the given source
2456    package and install the necessary packages to make it true, or fail. */
2457 bool DoBuildDep(CommandLine &CmdL)
2458 {
2459    CacheFile Cache;
2460    if (Cache.Open(true) == false)
2461       return false;
2462
2463    if (CmdL.FileSize() <= 1)
2464       return _error->Error(_("Must specify at least one package to check builddeps for"));
2465
2466    // Read the source list
2467    pkgSourceList List;
2468    if (List.ReadMainList() == false)
2469       return _error->Error(_("The list of sources could not be read."));
2470
2471    // Create the text record parsers
2472    pkgRecords Recs(Cache);
2473    pkgSrcRecords SrcRecs(List);
2474    if (_error->PendingError() == true)
2475       return false;
2476
2477    // Create the download object
2478    AcqTextStatus Stat(ScreenWidth,_config->FindI("quiet",0));
2479    pkgAcquire Fetcher;
2480    if (Fetcher.Setup(&Stat) == false)
2481       return false;
2482
2483    unsigned J = 0;
2484    for (const char **I = CmdL.FileList + 1; *I != 0; I++, J++)
2485    {
2486       string Src;
2487       pkgSrcRecords::Parser *Last = FindSrc(*I,Recs,SrcRecs,Src,*Cache);
2488       if (Last == 0)
2489          return _error->Error(_("Unable to find a source package for %s"),Src.c_str());
2490
2491       // Process the build-dependencies
2492       vector<pkgSrcRecords::Parser::BuildDepRec> BuildDeps;
2493       if (Last->BuildDepends(BuildDeps, _config->FindB("APT::Get::Arch-Only",true)) == false)
2494         return _error->Error(_("Unable to get build-dependency information for %s"),Src.c_str());
2495
2496       // Also ensure that build-essential packages are present
2497       Configuration::Item const *Opts = _config->Tree("APT::Build-Essential");
2498       if (Opts)
2499          Opts = Opts->Child;
2500       for (; Opts; Opts = Opts->Next)
2501       {
2502          if (Opts->Value.empty() == true)
2503             continue;
2504
2505          pkgSrcRecords::Parser::BuildDepRec rec;
2506          rec.Package = Opts->Value;
2507          rec.Type = pkgSrcRecords::Parser::BuildDependIndep;
2508          rec.Op = 0;
2509          BuildDeps.push_back(rec);
2510       }
2511
2512       if (BuildDeps.size() == 0)
2513       {
2514          ioprintf(c1out,_("%s has no build depends.\n"),Src.c_str());
2515          continue;
2516       }
2517
2518       // Install the requested packages
2519       unsigned int ExpectedInst = 0;
2520       vector <pkgSrcRecords::Parser::BuildDepRec>::iterator D;
2521       pkgProblemResolver Fix(Cache);
2522       bool skipAlternatives = false; // skip remaining alternatives in an or group
2523       for (D = BuildDeps.begin(); D != BuildDeps.end(); D++)
2524       {
2525          bool hasAlternatives = (((*D).Op & pkgCache::Dep::Or) == pkgCache::Dep::Or);
2526
2527          if (skipAlternatives == true)
2528          {
2529             if (!hasAlternatives)
2530                skipAlternatives = false; // end of or group
2531             continue;
2532          }
2533
2534          if ((*D).Type == pkgSrcRecords::Parser::BuildConflict ||
2535              (*D).Type == pkgSrcRecords::Parser::BuildConflictIndep)
2536          {
2537             pkgCache::PkgIterator Pkg = Cache->FindPkg((*D).Package);
2538             // Build-conflicts on unknown packages are silently ignored
2539             if (Pkg.end() == true)
2540                continue;
2541
2542             pkgCache::VerIterator IV = (*Cache)[Pkg].InstVerIter(*Cache);
2543
2544             /*
2545              * Remove if we have an installed version that satisfies the
2546              * version criteria
2547              */
2548             if (IV.end() == false &&
2549                 Cache->VS().CheckDep(IV.VerStr(),(*D).Op,(*D).Version.c_str()) == true)
2550                TryToInstall(Pkg,Cache,Fix,true,false,ExpectedInst);
2551          }
2552          else // BuildDep || BuildDepIndep
2553          {
2554             pkgCache::PkgIterator Pkg = Cache->FindPkg((*D).Package);
2555             if (_config->FindB("Debug::BuildDeps",false) == true)
2556                  cout << "Looking for " << (*D).Package << "...\n";
2557
2558             if (Pkg.end() == true)
2559             {
2560                if (_config->FindB("Debug::BuildDeps",false) == true)
2561                     cout << " (not found)" << (*D).Package << endl;
2562
2563                if (hasAlternatives)
2564                   continue;
2565
2566                return _error->Error(_("%s dependency for %s cannot be satisfied "
2567                                       "because the package %s cannot be found"),
2568                                     Last->BuildDepType((*D).Type),Src.c_str(),
2569                                     (*D).Package.c_str());
2570             }
2571
2572             /*
2573              * if there are alternatives, we've already picked one, so skip
2574              * the rest
2575              *
2576              * TODO: this means that if there's a build-dep on A|B and B is
2577              * installed, we'll still try to install A; more importantly,
2578              * if A is currently broken, we cannot go back and try B. To fix
2579              * this would require we do a Resolve cycle for each package we
2580              * add to the install list. Ugh
2581              */
2582
2583             /*
2584              * If this is a virtual package, we need to check the list of
2585              * packages that provide it and see if any of those are
2586              * installed
2587              */
2588             pkgCache::PrvIterator Prv = Pkg.ProvidesList();
2589             for (; Prv.end() != true; Prv++)
2590             {
2591                if (_config->FindB("Debug::BuildDeps",false) == true)
2592                     cout << "  Checking provider " << Prv.OwnerPkg().FullName() << endl;
2593
2594                if ((*Cache)[Prv.OwnerPkg()].InstVerIter(*Cache).end() == false)
2595                   break;
2596             }
2597
2598             // Get installed version and version we are going to install
2599             pkgCache::VerIterator IV = (*Cache)[Pkg].InstVerIter(*Cache);
2600
2601             if ((*D).Version[0] != '\0') {
2602                  // Versioned dependency
2603
2604                  pkgCache::VerIterator CV = (*Cache)[Pkg].CandidateVerIter(*Cache);
2605
2606                  for (; CV.end() != true; CV++)
2607                  {
2608                       if (Cache->VS().CheckDep(CV.VerStr(),(*D).Op,(*D).Version.c_str()) == true)
2609                            break;
2610                  }
2611                  if (CV.end() == true)
2612                  {
2613                    if (hasAlternatives)
2614                    {
2615                       continue;
2616                    }
2617                    else
2618                    {
2619                       return _error->Error(_("%s dependency for %s cannot be satisfied "
2620                                              "because no available versions of package %s "
2621                                              "can satisfy version requirements"),
2622                                            Last->BuildDepType((*D).Type),Src.c_str(),
2623                                            (*D).Package.c_str());
2624                    }
2625                  }
2626             }
2627             else
2628             {
2629                // Only consider virtual packages if there is no versioned dependency
2630                if (Prv.end() == false)
2631                {
2632                   if (_config->FindB("Debug::BuildDeps",false) == true)
2633                      cout << "  Is provided by installed package " << Prv.OwnerPkg().FullName() << endl;
2634                   skipAlternatives = hasAlternatives;
2635                   continue;
2636                }
2637             }
2638
2639             if (IV.end() == false)
2640             {
2641                if (_config->FindB("Debug::BuildDeps",false) == true)
2642                   cout << "  Is installed\n";
2643
2644                if (Cache->VS().CheckDep(IV.VerStr(),(*D).Op,(*D).Version.c_str()) == true)
2645                {
2646                   skipAlternatives = hasAlternatives;
2647                   continue;
2648                }
2649
2650                if (_config->FindB("Debug::BuildDeps",false) == true)
2651                   cout << "    ...but the installed version doesn't meet the version requirement\n";
2652
2653                if (((*D).Op & pkgCache::Dep::LessEq) == pkgCache::Dep::LessEq)
2654                {
2655                   return _error->Error(_("Failed to satisfy %s dependency for %s: Installed package %s is too new"),
2656                                        Last->BuildDepType((*D).Type),
2657                                        Src.c_str(),
2658                                        Pkg.FullName(true).c_str());
2659                }
2660             }
2661
2662
2663             if (_config->FindB("Debug::BuildDeps",false) == true)
2664                cout << "  Trying to install " << (*D).Package << endl;
2665
2666             if (TryToInstall(Pkg,Cache,Fix,false,false,ExpectedInst) == true)
2667             {
2668                // We successfully installed something; skip remaining alternatives
2669                skipAlternatives = hasAlternatives;
2670                if(_config->FindB("APT::Get::Build-Dep-Automatic", false) == true)
2671                   Cache->MarkAuto(Pkg, true);
2672                continue;
2673             }
2674             else if (hasAlternatives)
2675             {
2676                if (_config->FindB("Debug::BuildDeps",false) == true)
2677                   cout << "  Unsatisfiable, trying alternatives\n";
2678                continue;
2679             }
2680             else
2681             {
2682                return _error->Error(_("Failed to satisfy %s dependency for %s: %s"),
2683                                     Last->BuildDepType((*D).Type),
2684                                     Src.c_str(),
2685                                     (*D).Package.c_str());
2686             }
2687          }
2688       }
2689
2690       Fix.InstallProtect();
2691       if (Fix.Resolve(true) == false)
2692          _error->Discard();
2693
2694       // Now we check the state of the packages,
2695       if (Cache->BrokenCount() != 0)
2696       {
2697          ShowBroken(cout, Cache, false);
2698          return _error->Error(_("Build-dependencies for %s could not be satisfied."),*I);
2699       }
2700    }
2701
2702    if (InstallPackages(Cache, false, true) == false)
2703       return _error->Error(_("Failed to process build dependencies"));
2704    return true;
2705 }
2706                                                                         /*}}}*/
2707 // DoMoo - Never Ask, Never Tell                                        /*{{{*/
2708 // ---------------------------------------------------------------------
2709 /* */
2710 bool DoMoo(CommandLine &CmdL)
2711 {
2712    cout <<
2713       "         (__) \n"
2714       "         (oo) \n"
2715       "   /------\\/ \n"
2716       "  / |    ||   \n"
2717       " *  /\\---/\\ \n"
2718       "    ~~   ~~   \n"
2719       "....\"Have you mooed today?\"...\n";
2720
2721    return true;
2722 }
2723                                                                         /*}}}*/
2724 // ShowHelp - Show a help screen                                        /*{{{*/
2725 // ---------------------------------------------------------------------
2726 /* */
2727 bool ShowHelp(CommandLine &CmdL)
2728 {
2729    ioprintf(cout,_("%s %s for %s compiled on %s %s\n"),PACKAGE,VERSION,
2730             COMMON_ARCH,__DATE__,__TIME__);
2731
2732    if (_config->FindB("version") == true)
2733    {
2734       cout << _("Supported modules:") << endl;
2735
2736       for (unsigned I = 0; I != pkgVersioningSystem::GlobalListLen; I++)
2737       {
2738          pkgVersioningSystem *VS = pkgVersioningSystem::GlobalList[I];
2739          if (_system != 0 && _system->VS == VS)
2740             cout << '*';
2741          else
2742             cout << ' ';
2743          cout << "Ver: " << VS->Label << endl;
2744
2745          /* Print out all the packaging systems that will work with
2746             this VS */
2747          for (unsigned J = 0; J != pkgSystem::GlobalListLen; J++)
2748          {
2749             pkgSystem *Sys = pkgSystem::GlobalList[J];
2750             if (_system == Sys)
2751                cout << '*';
2752             else
2753                cout << ' ';
2754             if (Sys->VS->TestCompatibility(*VS) == true)
2755                cout << "Pkg:  " << Sys->Label << " (Priority " << Sys->Score(*_config) << ")" << endl;
2756          }
2757       }
2758
2759       for (unsigned I = 0; I != pkgSourceList::Type::GlobalListLen; I++)
2760       {
2761          pkgSourceList::Type *Type = pkgSourceList::Type::GlobalList[I];
2762          cout << " S.L: '" << Type->Name << "' " << Type->Label << endl;
2763       }
2764
2765       for (unsigned I = 0; I != pkgIndexFile::Type::GlobalListLen; I++)
2766       {
2767          pkgIndexFile::Type *Type = pkgIndexFile::Type::GlobalList[I];
2768          cout << " Idx: " << Type->Label << endl;
2769       }
2770
2771       return true;
2772    }
2773
2774    cout <<
2775     _("Usage: apt-get [options] command\n"
2776       "       apt-get [options] install|remove pkg1 [pkg2 ...]\n"
2777       "       apt-get [options] source pkg1 [pkg2 ...]\n"
2778       "\n"
2779       "apt-get is a simple command line interface for downloading and\n"
2780       "installing packages. The most frequently used commands are update\n"
2781       "and install.\n"
2782       "\n"
2783       "Commands:\n"
2784       "   update - Retrieve new lists of packages\n"
2785       "   upgrade - Perform an upgrade\n"
2786       "   install - Install new packages (pkg is libc6 not libc6.deb)\n"
2787       "   remove - Remove packages\n"
2788       "   autoremove - Remove automatically all unused packages\n"
2789       "   purge - Remove packages and config files\n"
2790       "   source - Download source archives\n"
2791       "   build-dep - Configure build-dependencies for source packages\n"
2792       "   dist-upgrade - Distribution upgrade, see apt-get(8)\n"
2793       "   dselect-upgrade - Follow dselect selections\n"
2794       "   clean - Erase downloaded archive files\n"
2795       "   autoclean - Erase old downloaded archive files\n"
2796       "   check - Verify that there are no broken dependencies\n"
2797       "\n"
2798       "Options:\n"
2799       "  -h  This help text.\n"
2800       "  -q  Loggable output - no progress indicator\n"
2801       "  -qq No output except for errors\n"
2802       "  -d  Download only - do NOT install or unpack archives\n"
2803       "  -s  No-act. Perform ordering simulation\n"
2804       "  -y  Assume Yes to all queries and do not prompt\n"
2805       "  -f  Attempt to correct a system with broken dependencies in place\n"
2806       "  -m  Attempt to continue if archives are unlocatable\n"
2807       "  -u  Show a list of upgraded packages as well\n"
2808       "  -b  Build the source package after fetching it\n"
2809       "  -V  Show verbose version numbers\n"
2810       "  -c=? Read this configuration file\n"
2811       "  -o=? Set an arbitrary configuration option, eg -o dir::cache=/tmp\n"
2812       "See the apt-get(8), sources.list(5) and apt.conf(5) manual\n"
2813       "pages for more information and options.\n"
2814       "                       This APT has Super Cow Powers.\n");
2815    return true;
2816 }
2817                                                                         /*}}}*/
2818 // GetInitialize - Initialize things for apt-get                        /*{{{*/
2819 // ---------------------------------------------------------------------
2820 /* */
2821 void GetInitialize()
2822 {
2823    _config->Set("quiet",0);
2824    _config->Set("help",false);
2825    _config->Set("APT::Get::Download-Only",false);
2826    _config->Set("APT::Get::Simulate",false);
2827    _config->Set("APT::Get::Assume-Yes",false);
2828    _config->Set("APT::Get::Fix-Broken",false);
2829    _config->Set("APT::Get::Force-Yes",false);
2830    _config->Set("APT::Get::List-Cleanup",true);
2831    _config->Set("APT::Get::AutomaticRemove",false);
2832 }
2833                                                                         /*}}}*/
2834 // SigWinch - Window size change signal handler                         /*{{{*/
2835 // ---------------------------------------------------------------------
2836 /* */
2837 void SigWinch(int)
2838 {
2839    // Riped from GNU ls
2840 #ifdef TIOCGWINSZ
2841    struct winsize ws;
2842
2843    if (ioctl(1, TIOCGWINSZ, &ws) != -1 && ws.ws_col >= 5)
2844       ScreenWidth = ws.ws_col - 1;
2845 #endif
2846 }
2847                                                                         /*}}}*/
2848 int main(int argc,const char *argv[])                                   /*{{{*/
2849 {
2850    CommandLine::Args Args[] = {
2851       {'h',"help","help",0},
2852       {'v',"version","version",0},
2853       {'V',"verbose-versions","APT::Get::Show-Versions",0},
2854       {'q',"quiet","quiet",CommandLine::IntLevel},
2855       {'q',"silent","quiet",CommandLine::IntLevel},
2856       {'d',"download-only","APT::Get::Download-Only",0},
2857       {'b',"compile","APT::Get::Compile",0},
2858       {'b',"build","APT::Get::Compile",0},
2859       {'s',"simulate","APT::Get::Simulate",0},
2860       {'s',"just-print","APT::Get::Simulate",0},
2861       {'s',"recon","APT::Get::Simulate",0},
2862       {'s',"dry-run","APT::Get::Simulate",0},
2863       {'s',"no-act","APT::Get::Simulate",0},
2864       {'y',"yes","APT::Get::Assume-Yes",0},
2865       {'y',"assume-yes","APT::Get::Assume-Yes",0},
2866       {'f',"fix-broken","APT::Get::Fix-Broken",0},
2867       {'u',"show-upgraded","APT::Get::Show-Upgraded",0},
2868       {'m',"ignore-missing","APT::Get::Fix-Missing",0},
2869       {'t',"target-release","APT::Default-Release",CommandLine::HasArg},
2870       {'t',"default-release","APT::Default-Release",CommandLine::HasArg},
2871       {0,"download","APT::Get::Download",0},
2872       {0,"fix-missing","APT::Get::Fix-Missing",0},
2873       {0,"ignore-hold","APT::Ignore-Hold",0},
2874       {0,"upgrade","APT::Get::upgrade",0},
2875       {0,"only-upgrade","APT::Get::Only-Upgrade",0},
2876       {0,"force-yes","APT::Get::force-yes",0},
2877       {0,"print-uris","APT::Get::Print-URIs",0},
2878       {0,"diff-only","APT::Get::Diff-Only",0},
2879       {0,"debian-only","APT::Get::Diff-Only",0},
2880       {0,"tar-only","APT::Get::Tar-Only",0},
2881       {0,"dsc-only","APT::Get::Dsc-Only",0},
2882       {0,"purge","APT::Get::Purge",0},
2883       {0,"list-cleanup","APT::Get::List-Cleanup",0},
2884       {0,"reinstall","APT::Get::ReInstall",0},
2885       {0,"trivial-only","APT::Get::Trivial-Only",0},
2886       {0,"remove","APT::Get::Remove",0},
2887       {0,"only-source","APT::Get::Only-Source",0},
2888       {0,"arch-only","APT::Get::Arch-Only",0},
2889       {0,"auto-remove","APT::Get::AutomaticRemove",0},
2890       {0,"allow-unauthenticated","APT::Get::AllowUnauthenticated",0},
2891       {0,"install-recommends","APT::Install-Recommends",CommandLine::Boolean},
2892       {0,"fix-policy","APT::Get::Fix-Policy-Broken",0},
2893       {'c',"config-file",0,CommandLine::ConfigFile},
2894       {'o',"option",0,CommandLine::ArbItem},
2895       {0,0,0,0}};
2896    CommandLine::Dispatch Cmds[] = {{"update",&DoUpdate},
2897                                    {"upgrade",&DoUpgrade},
2898                                    {"install",&DoInstall},
2899                                    {"remove",&DoInstall},
2900                                    {"purge",&DoInstall},
2901                                    {"autoremove",&DoInstall},
2902                                    {"purge",&DoInstall},
2903                                    {"dist-upgrade",&DoDistUpgrade},
2904                                    {"dselect-upgrade",&DoDSelectUpgrade},
2905                                    {"build-dep",&DoBuildDep},
2906                                    {"clean",&DoClean},
2907                                    {"autoclean",&DoAutoClean},
2908                                    {"check",&DoCheck},
2909                                    {"source",&DoSource},
2910                                    {"moo",&DoMoo},
2911                                    {"help",&ShowHelp},
2912                                    {0,0}};
2913
2914    // Set up gettext support
2915    setlocale(LC_ALL,"");
2916    textdomain(PACKAGE);
2917
2918    // Parse the command line and initialize the package library
2919    CommandLine CmdL(Args,_config);
2920    if (pkgInitConfig(*_config) == false ||
2921        CmdL.Parse(argc,argv) == false ||
2922        pkgInitSystem(*_config,_system) == false)
2923    {
2924       if (_config->FindB("version") == true)
2925          ShowHelp(CmdL);
2926
2927       _error->DumpErrors();
2928       return 100;
2929    }
2930
2931    // See if the help should be shown
2932    if (_config->FindB("help") == true ||
2933        _config->FindB("version") == true ||
2934        CmdL.FileSize() == 0)
2935    {
2936       ShowHelp(CmdL);
2937       return 0;
2938    }
2939
2940    // simulate user-friendly if apt-get has no root privileges
2941    if (getuid() != 0 && _config->FindB("APT::Get::Simulate") == true)
2942    {
2943       if (_config->FindB("APT::Get::Show-User-Simulation-Note",true) == true)
2944          cout << _("NOTE: This is only a simulation!\n"
2945             "      apt-get needs root privileges for real execution.\n"
2946             "      Keep also in mind that locking is deactivated,\n"
2947             "      so don't depend on the relevance to the real current situation!"
2948          ) << std::endl;
2949       _config->Set("Debug::NoLocking",true);
2950    }
2951
2952    // Deal with stdout not being a tty
2953    if (!isatty(STDOUT_FILENO) && _config->FindI("quiet",0) < 1)
2954       _config->Set("quiet","1");
2955
2956    // Setup the output streams
2957    c0out.rdbuf(cout.rdbuf());
2958    c1out.rdbuf(cout.rdbuf());
2959    c2out.rdbuf(cout.rdbuf());
2960    if (_config->FindI("quiet",0) > 0)
2961       c0out.rdbuf(devnull.rdbuf());
2962    if (_config->FindI("quiet",0) > 1)
2963       c1out.rdbuf(devnull.rdbuf());
2964
2965    // Setup the signals
2966    signal(SIGPIPE,SIG_IGN);
2967    signal(SIGWINCH,SigWinch);
2968    SigWinch(0);
2969
2970    // Match the operation
2971    CmdL.DispatchArg(Cmds);
2972
2973    // Print any errors or warnings found during parsing
2974    if (_error->empty() == false)
2975    {
2976       bool Errors = _error->PendingError();
2977       _error->DumpErrors();
2978       return Errors == true?100:0;
2979    }
2980
2981    return 0;
2982 }
2983                                                                         /*}}}*/