cmdline/apt-get.cc

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