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