cmdline/apt-get.cc

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