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