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