cmdline/apt-get.cc

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