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