cmdline/apt-get.cc

   1 // -*- mode: cpp; mode: fold -*-
   2 // Description                                                          /*{{{*/
   3 // $Id: apt-get.cc,v 1.153 2004/01/26 18:10:57 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 is not available, but is referred to by another package.\n"
1041            "This may mean that the package is missing, has been obsoleted, or\n"
1042            "is only available from another source\n"),Pkg.Name());
1043
1044          string List;
1045          string VersionsList;
1046          SPtrArray<bool> Seen = new bool[Cache.Head().PackageCount];
1047          memset(Seen,0,Cache.Head().PackageCount*sizeof(*Seen));
1048          pkgCache::DepIterator Dep = Pkg.RevDependsList();
1049          for (; Dep.end() == false; Dep++)
1050          {
1051             if (Dep->Type != pkgCache::Dep::Replaces)
1052                continue;
1053             if (Seen[Dep.ParentPkg()->ID] == true)
1054                continue;
1055             Seen[Dep.ParentPkg()->ID] = true;
1056             List += string(Dep.ParentPkg().Name()) + " ";
1057         //VersionsList += string(Dep.ParentPkg().CurVersion) + "\n"; ???
1058          }
1059          ShowList(c1out,_("However the following packages replace it:"),List,VersionsList);
1060       }
1061
1062       _error->Error(_("Package %s has no installation candidate"),Pkg.Name());
1063       return false;
1064    }
1065
1066    Fix.Clear(Pkg);
1067    Fix.Protect(Pkg);
1068    if (Remove == true)
1069    {
1070       Fix.Remove(Pkg);
1071       Cache.MarkDelete(Pkg,_config->FindB("APT::Get::Purge",false));
1072       return true;
1073    }
1074
1075    // Install it
1076    Cache.MarkInstall(Pkg,false);
1077    if (State.Install() == false)
1078    {
1079       if (_config->FindB("APT::Get::ReInstall",false) == true)
1080       {
1081          if (Pkg->CurrentVer == 0 || Pkg.CurrentVer().Downloadable() == false)
1082             ioprintf(c1out,_("Reinstallation of %s is not possible, it cannot be downloaded.\n"),
1083                      Pkg.Name());
1084          else
1085             Cache.SetReInstall(Pkg,true);
1086       }
1087       else
1088       {
1089          if (AllowFail == true)
1090             ioprintf(c1out,_("%s is already the newest version.\n"),
1091                      Pkg.Name());
1092       }
1093    }
1094    else
1095       ExpectedInst++;
1096
1097    // Install it with autoinstalling enabled.
1098    if (State.InstBroken() == true && BrokenFix == false)
1099       Cache.MarkInstall(Pkg,true);
1100    return true;
1101 }
1102                                                                         /*}}}*/
1103 // TryToChangeVer - Try to change a candidate version                   /*{{{*/
1104 // ---------------------------------------------------------------------
1105 /* */
1106 bool TryToChangeVer(pkgCache::PkgIterator Pkg,pkgDepCache &Cache,
1107                     const char *VerTag,bool IsRel)
1108 {
1109    pkgVersionMatch Match(VerTag,(IsRel == true?pkgVersionMatch::Release :
1110                                  pkgVersionMatch::Version));
1111
1112    pkgCache::VerIterator Ver = Match.Find(Pkg);
1113
1114    if (Ver.end() == true)
1115    {
1116       if (IsRel == true)
1117          return _error->Error(_("Release '%s' for '%s' was not found"),
1118                               VerTag,Pkg.Name());
1119       return _error->Error(_("Version '%s' for '%s' was not found"),
1120                            VerTag,Pkg.Name());
1121    }
1122
1123    if (strcmp(VerTag,Ver.VerStr()) != 0)
1124    {
1125       ioprintf(c1out,_("Selected version %s (%s) for %s\n"),
1126                Ver.VerStr(),Ver.RelStr().c_str(),Pkg.Name());
1127    }
1128
1129    Cache.SetCandidateVersion(Ver);
1130    return true;
1131 }
1132                                                                         /*}}}*/
1133 // FindSrc - Find a source record                                       /*{{{*/
1134 // ---------------------------------------------------------------------
1135 /* */
1136 pkgSrcRecords::Parser *FindSrc(const char *Name,pkgRecords &Recs,
1137                                pkgSrcRecords &SrcRecs,string &Src,
1138                                pkgDepCache &Cache)
1139 {
1140    // We want to pull the version off the package specification..
1141    string VerTag;
1142    string TmpSrc = Name;
1143    string::size_type Slash = TmpSrc.rfind('=');
1144    if (Slash != string::npos)
1145    {
1146       VerTag = string(TmpSrc.begin() + Slash + 1,TmpSrc.end());
1147       TmpSrc = string(TmpSrc.begin(),TmpSrc.begin() + Slash);
1148    }
1149
1150    /* Lookup the version of the package we would install if we were to
1151       install a version and determine the source package name, then look
1152       in the archive for a source package of the same name. In theory
1153       we could stash the version string as well and match that too but
1154       today there aren't multi source versions in the archive. */
1155    if (_config->FindB("APT::Get::Only-Source") == false &&
1156        VerTag.empty() == true)
1157    {
1158       pkgCache::PkgIterator Pkg = Cache.FindPkg(TmpSrc);
1159       if (Pkg.end() == false)
1160       {
1161          pkgCache::VerIterator Ver = Cache.GetCandidateVer(Pkg);
1162          if (Ver.end() == false)
1163          {
1164             pkgRecords::Parser &Parse = Recs.Lookup(Ver.FileList());
1165             Src = Parse.SourcePkg();
1166          }
1167       }
1168    }
1169
1170    // No source package name..
1171    if (Src.empty() == true)
1172       Src = TmpSrc;
1173
1174    // The best hit
1175    pkgSrcRecords::Parser *Last = 0;
1176    unsigned long Offset = 0;
1177    string Version;
1178    bool IsMatch = false;
1179
1180    // If we are matching by version then we need exact matches to be happy
1181    if (VerTag.empty() == false)
1182       IsMatch = true;
1183
1184    /* Iterate over all of the hits, which includes the resulting
1185       binary packages in the search */
1186    pkgSrcRecords::Parser *Parse;
1187    SrcRecs.Restart();
1188    while ((Parse = SrcRecs.Find(Src.c_str(),false)) != 0)
1189    {
1190       string Ver = Parse->Version();
1191
1192       // Skip name mismatches
1193       if (IsMatch == true && Parse->Package() != Src)
1194          continue;
1195
1196       if (VerTag.empty() == false)
1197       {
1198          /* Don't want to fall through because we are doing exact version
1199             matching. */
1200          if (Cache.VS().CmpVersion(VerTag,Ver) != 0)
1201             continue;
1202
1203          Last = Parse;
1204          Offset = Parse->Offset();
1205          break;
1206       }
1207
1208       // Newer version or an exact match
1209       if (Last == 0 || Cache.VS().CmpVersion(Version,Ver) < 0 ||
1210           (Parse->Package() == Src && IsMatch == false))
1211       {
1212          IsMatch = Parse->Package() == Src;
1213          Last = Parse;
1214          Offset = Parse->Offset();
1215          Version = Ver;
1216       }
1217    }
1218
1219    if (Last == 0)
1220       return 0;
1221
1222    if (Last->Jump(Offset) == false)
1223       return 0;
1224
1225    return Last;
1226 }
1227                                                                         /*}}}*/
1228
1229 // DoUpdate - Update the package lists                                  /*{{{*/
1230 // ---------------------------------------------------------------------
1231 /* */
1232 bool DoUpdate(CommandLine &CmdL)
1233 {
1234    if (CmdL.FileSize() != 1)
1235       return _error->Error(_("The update command takes no arguments"));
1236
1237    // Get the source list
1238    pkgSourceList List;
1239    if (List.ReadMainList() == false)
1240       return false;
1241
1242    // Lock the list directory
1243    FileFd Lock;
1244    if (_config->FindB("Debug::NoLocking",false) == false)
1245    {
1246       Lock.Fd(GetLock(_config->FindDir("Dir::State::Lists") + "lock"));
1247       if (_error->PendingError() == true)
1248          return _error->Error(_("Unable to lock the list directory"));
1249    }
1250
1251    // Create the download object
1252    AcqTextStatus Stat(ScreenWidth,_config->FindI("quiet",0));
1253    pkgAcquire Fetcher(&Stat);
1254
1255    // Populate it with the source selection
1256    if (List.GetIndexes(&Fetcher) == false)
1257          return false;
1258
1259    // Just print out the uris an exit if the --print-uris flag was used
1260    if (_config->FindB("APT::Get::Print-URIs") == true)
1261    {
1262       pkgAcquire::UriIterator I = Fetcher.UriBegin();
1263       for (; I != Fetcher.UriEnd(); I++)
1264          cout << '\'' << I->URI << "' " << flNotDir(I->Owner->DestFile) << ' ' <<
1265                I->Owner->FileSize << ' ' << I->Owner->MD5Sum() << endl;
1266       return true;
1267    }
1268
1269    // Run it
1270    if (Fetcher.Run() == pkgAcquire::Failed)
1271       return false;
1272
1273    bool Failed = false;
1274    for (pkgAcquire::ItemIterator I = Fetcher.ItemsBegin(); I != Fetcher.ItemsEnd(); I++)
1275    {
1276       if ((*I)->Status == pkgAcquire::Item::StatDone)
1277          continue;
1278
1279       (*I)->Finished();
1280
1281       fprintf(stderr,_("Failed to fetch %s  %s\n"),(*I)->DescURI().c_str(),
1282               (*I)->ErrorText.c_str());
1283       Failed = true;
1284    }
1285
1286    // Clean out any old list files
1287    if (_config->FindB("APT::Get::List-Cleanup",true) == true)
1288    {
1289       if (Fetcher.Clean(_config->FindDir("Dir::State::lists")) == false ||
1290           Fetcher.Clean(_config->FindDir("Dir::State::lists") + "partial/") == false)
1291          return false;
1292    }
1293
1294    // Prepare the cache.
1295    CacheFile Cache;
1296    if (Cache.BuildCaches() == false)
1297       return false;
1298
1299    if (Failed == true)
1300       return _error->Error(_("Some index files failed to download, they have been ignored, or old ones used instead."));
1301
1302    return true;
1303 }
1304                                                                         /*}}}*/
1305 // DoUpgrade - Upgrade all packages                                     /*{{{*/
1306 // ---------------------------------------------------------------------
1307 /* Upgrade all packages without installing new packages or erasing old
1308    packages */
1309 bool DoUpgrade(CommandLine &CmdL)
1310 {
1311    CacheFile Cache;
1312    if (Cache.OpenForInstall() == false || Cache.CheckDeps() == false)
1313       return false;
1314
1315    // Do the upgrade
1316    if (pkgAllUpgrade(Cache) == false)
1317    {
1318       ShowBroken(c1out,Cache,false);
1319       return _error->Error(_("Internal Error, AllUpgrade broke stuff"));
1320    }
1321
1322    return InstallPackages(Cache,true);
1323 }
1324                                                                         /*}}}*/
1325 // DoInstall - Install packages from the command line                   /*{{{*/
1326 // ---------------------------------------------------------------------
1327 /* Install named packages */
1328 bool DoInstall(CommandLine &CmdL)
1329 {
1330    CacheFile Cache;
1331    if (Cache.OpenForInstall() == false ||
1332        Cache.CheckDeps(CmdL.FileSize() != 1) == false)
1333       return false;
1334
1335    // Enter the special broken fixing mode if the user specified arguments
1336    bool BrokenFix = false;
1337    if (Cache->BrokenCount() != 0)
1338       BrokenFix = true;
1339
1340    unsigned int ExpectedInst = 0;
1341    unsigned int Packages = 0;
1342    pkgProblemResolver Fix(Cache);
1343
1344    bool DefRemove = false;
1345    if (strcasecmp(CmdL.FileList[0],"remove") == 0)
1346       DefRemove = true;
1347
1348    for (const char **I = CmdL.FileList + 1; *I != 0; I++)
1349    {
1350       // Duplicate the string
1351       unsigned int Length = strlen(*I);
1352       char S[300];
1353       if (Length >= sizeof(S))
1354          continue;
1355       strcpy(S,*I);
1356
1357       // See if we are removing and special indicators..
1358       bool Remove = DefRemove;
1359       char *VerTag = 0;
1360       bool VerIsRel = false;
1361       while (Cache->FindPkg(S).end() == true)
1362       {
1363          // Handle an optional end tag indicating what to do
1364          if (Length >= 1 && S[Length - 1] == '-')
1365          {
1366             Remove = true;
1367             S[--Length] = 0;
1368             continue;
1369          }
1370
1371          if (Length >= 1 && S[Length - 1] == '+')
1372          {
1373             Remove = false;
1374             S[--Length] = 0;
1375             continue;
1376          }
1377
1378          char *Slash = strchr(S,'=');
1379          if (Slash != 0)
1380          {
1381             VerIsRel = false;
1382             *Slash = 0;
1383             VerTag = Slash + 1;
1384          }
1385
1386          Slash = strchr(S,'/');
1387          if (Slash != 0)
1388          {
1389             VerIsRel = true;
1390             *Slash = 0;
1391             VerTag = Slash + 1;
1392          }
1393
1394          break;
1395       }
1396
1397       // Locate the package
1398       pkgCache::PkgIterator Pkg = Cache->FindPkg(S);
1399       Packages++;
1400       if (Pkg.end() == true)
1401       {
1402          // Check if the name is a regex
1403          const char *I;
1404          for (I = S; *I != 0; I++)
1405             if (*I == '?' || *I == '*' || *I == '|' ||
1406                 *I == '[' || *I == '^' || *I == '$')
1407                break;
1408          if (*I == 0)
1409             return _error->Error(_("Couldn't find package %s"),S);
1410
1411          // Regexs must always be confirmed
1412          ExpectedInst += 1000;
1413
1414          // Compile the regex pattern
1415          regex_t Pattern;
1416          int Res;
1417          if ((Res = regcomp(&Pattern,S,REG_EXTENDED | REG_ICASE |
1418                      REG_NOSUB)) != 0)
1419          {
1420             char Error[300];
1421             regerror(Res,&Pattern,Error,sizeof(Error));
1422             return _error->Error(_("Regex compilation error - %s"),Error);
1423          }
1424
1425          // Run over the matches
1426          bool Hit = false;
1427          for (Pkg = Cache->PkgBegin(); Pkg.end() == false; Pkg++)
1428          {
1429             if (regexec(&Pattern,Pkg.Name(),0,0,0) != 0)
1430                continue;
1431
1432             ioprintf(c1out,_("Note, selecting %s for regex '%s'\n"),
1433                      Pkg.Name(),S);
1434
1435             if (VerTag != 0)
1436                if (TryToChangeVer(Pkg,Cache,VerTag,VerIsRel) == false)
1437                   return false;
1438
1439             Hit |= TryToInstall(Pkg,Cache,Fix,Remove,BrokenFix,
1440                                 ExpectedInst,false);
1441          }
1442          regfree(&Pattern);
1443
1444          if (Hit == false)
1445             return _error->Error(_("Couldn't find package %s"),S);
1446       }
1447       else
1448       {
1449          if (VerTag != 0)
1450             if (TryToChangeVer(Pkg,Cache,VerTag,VerIsRel) == false)
1451                return false;
1452          if (TryToInstall(Pkg,Cache,Fix,Remove,BrokenFix,ExpectedInst) == false)
1453             return false;
1454       }
1455    }
1456
1457    /* If we are in the Broken fixing mode we do not attempt to fix the
1458       problems. This is if the user invoked install without -f and gave
1459       packages */
1460    if (BrokenFix == true && Cache->BrokenCount() != 0)
1461    {
1462       c1out << _("You might want to run `apt-get -f install' to correct these:") << endl;
1463       ShowBroken(c1out,Cache,false);
1464
1465       return _error->Error(_("Unmet dependencies. Try 'apt-get -f install' with no packages (or specify a solution)."));
1466    }
1467
1468    // Call the scored problem resolver
1469    Fix.InstallProtect();
1470    if (Fix.Resolve(true) == false)
1471       _error->Discard();
1472
1473    // Now we check the state of the packages,
1474    if (Cache->BrokenCount() != 0)
1475    {
1476       c1out <<
1477        _("Some packages could not be installed. This may mean that you have\n"
1478          "requested an impossible situation or if you are using the unstable\n"
1479          "distribution that some required packages have not yet been created\n"
1480          "or been moved out of Incoming.") << endl;
1481       if (Packages == 1)
1482       {
1483          c1out << endl;
1484          c1out <<
1485           _("Since you only requested a single operation it is extremely likely that\n"
1486             "the package is simply not installable and a bug report against\n"
1487             "that package should be filed.") << endl;
1488       }
1489
1490       c1out << _("The following information may help to resolve the situation:") << endl;
1491       c1out << endl;
1492       ShowBroken(c1out,Cache,false);
1493       return _error->Error(_("Broken packages"));
1494    }
1495
1496    /* Print out a list of packages that are going to be installed extra
1497       to what the user asked */
1498    if (Cache->InstCount() != ExpectedInst)
1499    {
1500       string List;
1501       string VersionsList;
1502       for (unsigned J = 0; J < Cache->Head().PackageCount; J++)
1503       {
1504          pkgCache::PkgIterator I(Cache,Cache.List[J]);
1505          if ((*Cache)[I].Install() == false)
1506             continue;
1507
1508          const char **J;
1509          for (J = CmdL.FileList + 1; *J != 0; J++)
1510             if (strcmp(*J,I.Name()) == 0)
1511                 break;
1512
1513          if (*J == 0) {
1514             List += string(I.Name()) + " ";
1515         VersionsList += string(Cache[I].CandVersion) + "\n";
1516      }
1517       }
1518
1519       ShowList(c1out,_("The following extra packages will be installed:"),List,VersionsList);
1520    }
1521
1522    /* Print out a list of suggested and recommended packages */
1523    {
1524       string SuggestsList, RecommendsList, List;
1525       string SuggestsVersions, RecommendsVersions;
1526       for (unsigned J = 0; J < Cache->Head().PackageCount; J++)
1527       {
1528          pkgCache::PkgIterator I(Cache,Cache.List[J]);
1529
1530          /* Just look at the ones we want to install */
1531          if ((*Cache)[I].Install() == false)
1532            continue;
1533
1534          for (pkgCache::VerIterator V = I.VersionList(); V.end() == false; V++)
1535          {
1536              for (pkgCache::DepIterator D = V.DependsList(); D.end() == false; D++)
1537              {
1538                  pkgCache::DepIterator Start;
1539                  pkgCache::DepIterator End;
1540                  D.GlobOr(Start,End);
1541
1542                  /*
1543                   * If this is a virtual package, we need to check the list of
1544                   * packages that provide it and see if any of those are
1545                   * installed
1546                   */
1547
1548                  bool providedBySomething = false;
1549                  for (pkgCache::PrvIterator Prv = Start.TargetPkg().ProvidesList();
1550                       Prv.end() != true;
1551                       Prv++)
1552                     if ((*Cache)[Prv.OwnerPkg()].InstVerIter(*Cache).end() == false)
1553                     {
1554                        providedBySomething = true;
1555                        break;
1556                     }
1557
1558                  if (providedBySomething) continue;
1559
1560                  for(;;)
1561                  {
1562                      /* Skip if package is  installed already, or is about to be */
1563                      string target = string(Start.TargetPkg().Name()) + " ";
1564
1565                      if ((*Start.TargetPkg()).SelectedState == pkgCache::State::Install
1566                          || Cache[Start.TargetPkg()].Install())
1567                        break;
1568
1569                      /* Skip if we already saw it */
1570                      if (int(SuggestsList.find(target)) != -1 || int(RecommendsList.find(target)) != -1)
1571                        break;
1572
1573                      if (Start->Type == pkgCache::Dep::Suggests) {
1574                        SuggestsList += target;
1575                        SuggestsVersions += string(Cache[Start.TargetPkg()].CandVersion) + "\n";
1576                      }
1577
1578                      if (Start->Type == pkgCache::Dep::Recommends) {
1579                        RecommendsList += target;
1580                        RecommendsVersions += string(Cache[Start.TargetPkg()].CandVersion) + "\n";
1581                      }
1582
1583                      if (Start >= End)
1584                         break;
1585                      Start++;
1586                  }
1587              }
1588          }
1589       }
1590       ShowList(c1out,_("Suggested packages:"),SuggestsList,SuggestsVersions);
1591       ShowList(c1out,_("Recommended packages:"),RecommendsList,RecommendsVersions);
1592
1593    }
1594
1595    // See if we need to prompt
1596    if (Cache->InstCount() == ExpectedInst && Cache->DelCount() == 0)
1597       return InstallPackages(Cache,false,false);
1598
1599    return InstallPackages(Cache,false);
1600 }
1601                                                                         /*}}}*/
1602 // DoDistUpgrade - Automatic smart upgrader                             /*{{{*/
1603 // ---------------------------------------------------------------------
1604 /* Intelligent upgrader that will install and remove packages at will */
1605 bool DoDistUpgrade(CommandLine &CmdL)
1606 {
1607    CacheFile Cache;
1608    if (Cache.OpenForInstall() == false || Cache.CheckDeps() == false)
1609       return false;
1610
1611    c0out << _("Calculating Upgrade... ") << flush;
1612    if (pkgDistUpgrade(*Cache) == false)
1613    {
1614       c0out << _("Failed") << endl;
1615       ShowBroken(c1out,Cache,false);
1616       return false;
1617    }
1618
1619    c0out << _("Done") << endl;
1620
1621    return InstallPackages(Cache,true);
1622 }
1623                                                                         /*}}}*/
1624 // DoDSelectUpgrade - Do an upgrade by following dselects selections    /*{{{*/
1625 // ---------------------------------------------------------------------
1626 /* Follows dselect's selections */
1627 bool DoDSelectUpgrade(CommandLine &CmdL)
1628 {
1629    CacheFile Cache;
1630    if (Cache.OpenForInstall() == false || Cache.CheckDeps() == false)
1631       return false;
1632
1633    // Install everything with the install flag set
1634    pkgCache::PkgIterator I = Cache->PkgBegin();
1635    for (;I.end() != true; I++)
1636    {
1637       /* Install the package only if it is a new install, the autoupgrader
1638          will deal with the rest */
1639       if (I->SelectedState == pkgCache::State::Install)
1640          Cache->MarkInstall(I,false);
1641    }
1642
1643    /* Now install their deps too, if we do this above then order of
1644       the status file is significant for | groups */
1645    for (I = Cache->PkgBegin();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,true);
1651    }
1652
1653    // Apply erasures now, they override everything else.
1654    for (I = Cache->PkgBegin();I.end() != true; I++)
1655    {
1656       // Remove packages
1657       if (I->SelectedState == pkgCache::State::DeInstall ||
1658           I->SelectedState == pkgCache::State::Purge)
1659          Cache->MarkDelete(I,I->SelectedState == pkgCache::State::Purge);
1660    }
1661
1662    /* Resolve any problems that dselect created, allupgrade cannot handle
1663       such things. We do so quite agressively too.. */
1664    if (Cache->BrokenCount() != 0)
1665    {
1666       pkgProblemResolver Fix(Cache);
1667
1668       // Hold back held packages.
1669       if (_config->FindB("APT::Ignore-Hold",false) == false)
1670       {
1671          for (pkgCache::PkgIterator I = Cache->PkgBegin(); I.end() == false; I++)
1672          {
1673             if (I->SelectedState == pkgCache::State::Hold)
1674             {
1675                Fix.Protect(I);
1676                Cache->MarkKeep(I);
1677             }
1678          }
1679       }
1680
1681       if (Fix.Resolve() == false)
1682       {
1683          ShowBroken(c1out,Cache,false);
1684          return _error->Error("Internal Error, problem resolver broke stuff");
1685       }
1686    }
1687
1688    // Now upgrade everything
1689    if (pkgAllUpgrade(Cache) == false)
1690    {
1691       ShowBroken(c1out,Cache,false);
1692       return _error->Error("Internal Error, problem resolver broke stuff");
1693    }
1694
1695    return InstallPackages(Cache,false);
1696 }
1697                                                                         /*}}}*/
1698 // DoClean - Remove download archives                                   /*{{{*/
1699 // ---------------------------------------------------------------------
1700 /* */
1701 bool DoClean(CommandLine &CmdL)
1702 {
1703    if (_config->FindB("APT::Get::Simulate") == true)
1704    {
1705       cout << "Del " << _config->FindDir("Dir::Cache::archives") << "* " <<
1706          _config->FindDir("Dir::Cache::archives") << "partial/*" << endl;
1707       return true;
1708    }
1709
1710    // Lock the archive directory
1711    FileFd Lock;
1712    if (_config->FindB("Debug::NoLocking",false) == false)
1713    {
1714       Lock.Fd(GetLock(_config->FindDir("Dir::Cache::Archives") + "lock"));
1715       if (_error->PendingError() == true)
1716          return _error->Error(_("Unable to lock the download directory"));
1717    }
1718
1719    pkgAcquire Fetcher;
1720    Fetcher.Clean(_config->FindDir("Dir::Cache::archives"));
1721    Fetcher.Clean(_config->FindDir("Dir::Cache::archives") + "partial/");
1722    return true;
1723 }
1724                                                                         /*}}}*/
1725 // DoAutoClean - Smartly remove downloaded archives                     /*{{{*/
1726 // ---------------------------------------------------------------------
1727 /* This is similar to clean but it only purges things that cannot be
1728    downloaded, that is old versions of cached packages. */
1729 class LogCleaner : public pkgArchiveCleaner
1730 {
1731    protected:
1732    virtual void Erase(const char *File,string Pkg,string Ver,struct stat &St)
1733    {
1734       c1out << "Del " << Pkg << " " << Ver << " [" << SizeToStr(St.st_size) << "B]" << endl;
1735
1736       if (_config->FindB("APT::Get::Simulate") == false)
1737          unlink(File);
1738    };
1739 };
1740
1741 bool DoAutoClean(CommandLine &CmdL)
1742 {
1743    // Lock the archive directory
1744    FileFd Lock;
1745    if (_config->FindB("Debug::NoLocking",false) == false)
1746    {
1747       Lock.Fd(GetLock(_config->FindDir("Dir::Cache::Archives") + "lock"));
1748       if (_error->PendingError() == true)
1749          return _error->Error(_("Unable to lock the download directory"));
1750    }
1751
1752    CacheFile Cache;
1753    if (Cache.Open() == false)
1754       return false;
1755
1756    LogCleaner Cleaner;
1757
1758    return Cleaner.Go(_config->FindDir("Dir::Cache::archives"),*Cache) &&
1759       Cleaner.Go(_config->FindDir("Dir::Cache::archives") + "partial/",*Cache);
1760 }
1761                                                                         /*}}}*/
1762 // DoCheck - Perform the check operation                                /*{{{*/
1763 // ---------------------------------------------------------------------
1764 /* Opening automatically checks the system, this command is mostly used
1765    for debugging */
1766 bool DoCheck(CommandLine &CmdL)
1767 {
1768    CacheFile Cache;
1769    Cache.Open();
1770    Cache.CheckDeps();
1771
1772    return true;
1773 }
1774                                                                         /*}}}*/
1775 // DoSource - Fetch a source archive                                    /*{{{*/
1776 // ---------------------------------------------------------------------
1777 /* Fetch souce packages */
1778 struct DscFile
1779 {
1780    string Package;
1781    string Version;
1782    string Dsc;
1783 };
1784
1785 bool DoSource(CommandLine &CmdL)
1786 {
1787    CacheFile Cache;
1788    if (Cache.Open(false) == false)
1789       return false;
1790
1791    if (CmdL.FileSize() <= 1)
1792       return _error->Error(_("Must specify at least one package to fetch source for"));
1793
1794    // Read the source list
1795    pkgSourceList List;
1796    if (List.ReadMainList() == false)
1797       return _error->Error(_("The list of sources could not be read."));
1798
1799    // Create the text record parsers
1800    pkgRecords Recs(Cache);
1801    pkgSrcRecords SrcRecs(List);
1802    if (_error->PendingError() == true)
1803       return false;
1804
1805    // Create the download object
1806    AcqTextStatus Stat(ScreenWidth,_config->FindI("quiet",0));
1807    pkgAcquire Fetcher(&Stat);
1808
1809    DscFile *Dsc = new DscFile[CmdL.FileSize()];
1810
1811    // Load the requestd sources into the fetcher
1812    unsigned J = 0;
1813    for (const char **I = CmdL.FileList + 1; *I != 0; I++, J++)
1814    {
1815       string Src;
1816       pkgSrcRecords::Parser *Last = FindSrc(*I,Recs,SrcRecs,Src,*Cache);
1817
1818       if (Last == 0)
1819          return _error->Error(_("Unable to find a source package for %s"),Src.c_str());
1820
1821       // Back track
1822       vector<pkgSrcRecords::File> Lst;
1823       if (Last->Files(Lst) == false)
1824          return false;
1825
1826       // Load them into the fetcher
1827       for (vector<pkgSrcRecords::File>::const_iterator I = Lst.begin();
1828            I != Lst.end(); I++)
1829       {
1830          // Try to guess what sort of file it is we are getting.
1831          if (I->Type == "dsc")
1832          {
1833             Dsc[J].Package = Last->Package();
1834             Dsc[J].Version = Last->Version();
1835             Dsc[J].Dsc = flNotDir(I->Path);
1836          }
1837
1838          // Diff only mode only fetches .diff files
1839          if (_config->FindB("APT::Get::Diff-Only",false) == true &&
1840              I->Type != "diff")
1841             continue;
1842
1843          // Tar only mode only fetches .tar files
1844          if (_config->FindB("APT::Get::Tar-Only",false) == true &&
1845              I->Type != "tar")
1846             continue;
1847
1848          new pkgAcqFile(&Fetcher,Last->Index().ArchiveURI(I->Path),
1849                         I->MD5Hash,I->Size,
1850                         Last->Index().SourceInfo(*Last,*I),Src);
1851       }
1852    }
1853
1854    // Display statistics
1855    double FetchBytes = Fetcher.FetchNeeded();
1856    double FetchPBytes = Fetcher.PartialPresent();
1857    double DebBytes = Fetcher.TotalNeeded();
1858
1859    // Check for enough free space
1860    struct statvfs Buf;
1861    string OutputDir = ".";
1862    if (statvfs(OutputDir.c_str(),&Buf) != 0)
1863       return _error->Errno("statvfs","Couldn't determine free space in %s",
1864                            OutputDir.c_str());
1865    if (unsigned(Buf.f_bfree) < (FetchBytes - FetchPBytes)/Buf.f_bsize)
1866       return _error->Error(_("You don't have enough free space in %s"),
1867                            OutputDir.c_str());
1868
1869    // Number of bytes
1870    if (DebBytes != FetchBytes)
1871       ioprintf(c1out,_("Need to get %sB/%sB of source archives.\n"),
1872                SizeToStr(FetchBytes).c_str(),SizeToStr(DebBytes).c_str());
1873    else
1874       ioprintf(c1out,_("Need to get %sB of source archives.\n"),
1875                SizeToStr(DebBytes).c_str());
1876
1877    if (_config->FindB("APT::Get::Simulate",false) == true)
1878    {
1879       for (unsigned I = 0; I != J; I++)
1880          ioprintf(cout,_("Fetch Source %s\n"),Dsc[I].Package.c_str());
1881       return true;
1882    }
1883
1884    // Just print out the uris an exit if the --print-uris flag was used
1885    if (_config->FindB("APT::Get::Print-URIs") == true)
1886    {
1887       pkgAcquire::UriIterator I = Fetcher.UriBegin();
1888       for (; I != Fetcher.UriEnd(); I++)
1889          cout << '\'' << I->URI << "' " << flNotDir(I->Owner->DestFile) << ' ' <<
1890                I->Owner->FileSize << ' ' << I->Owner->MD5Sum() << endl;
1891       return true;
1892    }
1893
1894    // Run it
1895    if (Fetcher.Run() == pkgAcquire::Failed)
1896       return false;
1897
1898    // Print error messages
1899    bool Failed = false;
1900    for (pkgAcquire::ItemIterator I = Fetcher.ItemsBegin(); I != Fetcher.ItemsEnd(); I++)
1901    {
1902       if ((*I)->Status == pkgAcquire::Item::StatDone &&
1903           (*I)->Complete == true)
1904          continue;
1905
1906       fprintf(stderr,_("Failed to fetch %s  %s\n"),(*I)->DescURI().c_str(),
1907               (*I)->ErrorText.c_str());
1908       Failed = true;
1909    }
1910    if (Failed == true)
1911       return _error->Error(_("Failed to fetch some archives."));
1912
1913    if (_config->FindB("APT::Get::Download-only",false) == true)
1914    {
1915       c1out << _("Download complete and in download only mode") << endl;
1916       return true;
1917    }
1918
1919    // Unpack the sources
1920    pid_t Process = ExecFork();
1921
1922    if (Process == 0)
1923    {
1924       for (unsigned I = 0; I != J; I++)
1925       {
1926          string Dir = Dsc[I].Package + '-' + Cache->VS().UpstreamVersion(Dsc[I].Version.c_str());
1927
1928          // Diff only mode only fetches .diff files
1929          if (_config->FindB("APT::Get::Diff-Only",false) == true ||
1930              _config->FindB("APT::Get::Tar-Only",false) == true ||
1931              Dsc[I].Dsc.empty() == true)
1932             continue;
1933
1934          // See if the package is already unpacked
1935          struct stat Stat;
1936          if (stat(Dir.c_str(),&Stat) == 0 &&
1937              S_ISDIR(Stat.st_mode) != 0)
1938          {
1939             ioprintf(c0out ,_("Skipping unpack of already unpacked source in %s\n"),
1940                               Dir.c_str());
1941          }
1942          else
1943          {
1944             // Call dpkg-source
1945             char S[500];
1946             snprintf(S,sizeof(S),"%s -x %s",
1947                      _config->Find("Dir::Bin::dpkg-source","dpkg-source").c_str(),
1948                      Dsc[I].Dsc.c_str());
1949             if (system(S) != 0)
1950             {
1951                fprintf(stderr,_("Unpack command '%s' failed.\n"),S);
1952                _exit(1);
1953             }
1954          }
1955
1956          // Try to compile it with dpkg-buildpackage
1957          if (_config->FindB("APT::Get::Compile",false) == true)
1958          {
1959             // Call dpkg-buildpackage
1960             char S[500];
1961             snprintf(S,sizeof(S),"cd %s && %s %s",
1962                      Dir.c_str(),
1963                      _config->Find("Dir::Bin::dpkg-buildpackage","dpkg-buildpackage").c_str(),
1964                      _config->Find("DPkg::Build-Options","-b -uc").c_str());
1965
1966             if (system(S) != 0)
1967             {
1968                fprintf(stderr,_("Build command '%s' failed.\n"),S);
1969                _exit(1);
1970             }
1971          }
1972       }
1973
1974       _exit(0);
1975    }
1976
1977    // Wait for the subprocess
1978    int Status = 0;
1979    while (waitpid(Process,&Status,0) != Process)
1980    {
1981       if (errno == EINTR)
1982          continue;
1983       return _error->Errno("waitpid","Couldn't wait for subprocess");
1984    }
1985
1986    if (WIFEXITED(Status) == 0 || WEXITSTATUS(Status) != 0)
1987       return _error->Error(_("Child process failed"));
1988
1989    return true;
1990 }
1991                                                                         /*}}}*/
1992 // DoBuildDep - Install/removes packages to satisfy build dependencies  /*{{{*/
1993 // ---------------------------------------------------------------------
1994 /* This function will look at the build depends list of the given source
1995    package and install the necessary packages to make it true, or fail. */
1996 bool DoBuildDep(CommandLine &CmdL)
1997 {
1998    CacheFile Cache;
1999    if (Cache.Open(true) == false)
2000       return false;
2001
2002    if (CmdL.FileSize() <= 1)
2003       return _error->Error(_("Must specify at least one package to check builddeps for"));
2004
2005    // Read the source list
2006    pkgSourceList List;
2007    if (List.ReadMainList() == false)
2008       return _error->Error(_("The list of sources could not be read."));
2009
2010    // Create the text record parsers
2011    pkgRecords Recs(Cache);
2012    pkgSrcRecords SrcRecs(List);
2013    if (_error->PendingError() == true)
2014       return false;
2015
2016    // Create the download object
2017    AcqTextStatus Stat(ScreenWidth,_config->FindI("quiet",0));
2018    pkgAcquire Fetcher(&Stat);
2019
2020    unsigned J = 0;
2021    for (const char **I = CmdL.FileList + 1; *I != 0; I++, J++)
2022    {
2023       string Src;
2024       pkgSrcRecords::Parser *Last = FindSrc(*I,Recs,SrcRecs,Src,*Cache);
2025       if (Last == 0)
2026          return _error->Error(_("Unable to find a source package for %s"),Src.c_str());
2027
2028       // Process the build-dependencies
2029       vector<pkgSrcRecords::Parser::BuildDepRec> BuildDeps;
2030       if (Last->BuildDepends(BuildDeps, _config->FindB("APT::Get::Arch-Only",false)) == false)
2031         return _error->Error(_("Unable to get build-dependency information for %s"),Src.c_str());
2032
2033       // Also ensure that build-essential packages are present
2034       Configuration::Item const *Opts = _config->Tree("APT::Build-Essential");
2035       if (Opts)
2036          Opts = Opts->Child;
2037       for (; Opts; Opts = Opts->Next)
2038       {
2039          if (Opts->Value.empty() == true)
2040             continue;
2041
2042          pkgSrcRecords::Parser::BuildDepRec rec;
2043          rec.Package = Opts->Value;
2044          rec.Type = pkgSrcRecords::Parser::BuildDependIndep;
2045          rec.Op = 0;
2046          BuildDeps.push_back(rec);
2047       }
2048
2049       if (BuildDeps.size() == 0)
2050       {
2051          ioprintf(c1out,_("%s has no build depends.\n"),Src.c_str());
2052          continue;
2053       }
2054
2055       // Install the requested packages
2056       unsigned int ExpectedInst = 0;
2057       vector <pkgSrcRecords::Parser::BuildDepRec>::iterator D;
2058       pkgProblemResolver Fix(Cache);
2059       bool skipAlternatives = false; // skip remaining alternatives in an or group
2060       for (D = BuildDeps.begin(); D != BuildDeps.end(); D++)
2061       {
2062          bool hasAlternatives = (((*D).Op & pkgCache::Dep::Or) == pkgCache::Dep::Or);
2063
2064          if (skipAlternatives == true)
2065          {
2066             if (!hasAlternatives)
2067                skipAlternatives = false; // end of or group
2068             continue;
2069          }
2070
2071          if ((*D).Type == pkgSrcRecords::Parser::BuildConflict ||
2072              (*D).Type == pkgSrcRecords::Parser::BuildConflictIndep)
2073          {
2074             pkgCache::PkgIterator Pkg = Cache->FindPkg((*D).Package);
2075             // Build-conflicts on unknown packages are silently ignored
2076             if (Pkg.end() == true)
2077                continue;
2078
2079             pkgCache::VerIterator IV = (*Cache)[Pkg].InstVerIter(*Cache);
2080
2081             /*
2082              * Remove if we have an installed version that satisfies the
2083              * version criteria
2084              */
2085             if (IV.end() == false &&
2086                 Cache->VS().CheckDep(IV.VerStr(),(*D).Op,(*D).Version.c_str()) == true)
2087                TryToInstall(Pkg,Cache,Fix,true,false,ExpectedInst);
2088          }
2089          else // BuildDep || BuildDepIndep
2090          {
2091             pkgCache::PkgIterator Pkg = Cache->FindPkg((*D).Package);
2092             if (_config->FindB("Debug::BuildDeps",false) == true)
2093                  cout << "Looking for " << (*D).Package << "...\n";
2094
2095             if (Pkg.end() == true)
2096             {
2097                if (_config->FindB("Debug::BuildDeps",false) == true)
2098                     cout << " (not found)" << (*D).Package << endl;
2099
2100                if (hasAlternatives)
2101                   continue;
2102
2103                return _error->Error(_("%s dependency for %s cannot be satisfied "
2104                                       "because the package %s cannot be found"),
2105                                     Last->BuildDepType((*D).Type),Src.c_str(),
2106                                     (*D).Package.c_str());
2107             }
2108
2109             /*
2110              * if there are alternatives, we've already picked one, so skip
2111              * the rest
2112              *
2113              * TODO: this means that if there's a build-dep on A|B and B is
2114              * installed, we'll still try to install A; more importantly,
2115              * if A is currently broken, we cannot go back and try B. To fix
2116              * this would require we do a Resolve cycle for each package we
2117              * add to the install list. Ugh
2118              */
2119
2120             /*
2121              * If this is a virtual package, we need to check the list of
2122              * packages that provide it and see if any of those are
2123              * installed
2124              */
2125             pkgCache::PrvIterator Prv = Pkg.ProvidesList();
2126             for (; Prv.end() != true; Prv++)
2127             {
2128                if (_config->FindB("Debug::BuildDeps",false) == true)
2129                     cout << "  Checking provider " << Prv.OwnerPkg().Name() << endl;
2130
2131                if ((*Cache)[Prv.OwnerPkg()].InstVerIter(*Cache).end() == false)
2132                   break;
2133             }
2134
2135             // Get installed version and version we are going to install
2136             pkgCache::VerIterator IV = (*Cache)[Pkg].InstVerIter(*Cache);
2137
2138             if ((*D).Version[0] != '\0') {
2139                  // Versioned dependency
2140
2141                  pkgCache::VerIterator CV = (*Cache)[Pkg].CandidateVerIter(*Cache);
2142
2143                  for (; CV.end() != true; CV++)
2144                  {
2145                       if (Cache->VS().CheckDep(CV.VerStr(),(*D).Op,(*D).Version.c_str()) == true)
2146                            break;
2147                  }
2148                  if (CV.end() == true)
2149                    if (hasAlternatives)
2150                    {
2151                       continue;
2152                    }
2153                    else
2154                    {
2155                       return _error->Error(_("%s dependency for %s cannot be satisfied "
2156                                              "because no available versions of package %s "
2157                                              "can satisfy version requirements"),
2158                                            Last->BuildDepType((*D).Type),Src.c_str(),
2159                                            (*D).Package.c_str());
2160                    }
2161             }
2162             else
2163             {
2164                // Only consider virtual packages if there is no versioned dependency
2165                if (Prv.end() == false)
2166                {
2167                   if (_config->FindB("Debug::BuildDeps",false) == true)
2168                      cout << "  Is provided by installed package " << Prv.OwnerPkg().Name() << endl;
2169                   skipAlternatives = hasAlternatives;
2170                   continue;
2171                }
2172             }
2173
2174             if (IV.end() == false)
2175             {
2176                if (_config->FindB("Debug::BuildDeps",false) == true)
2177                   cout << "  Is installed\n";
2178
2179                if (Cache->VS().CheckDep(IV.VerStr(),(*D).Op,(*D).Version.c_str()) == true)
2180                {
2181                   skipAlternatives = hasAlternatives;
2182                   continue;
2183                }
2184
2185                if (_config->FindB("Debug::BuildDeps",false) == true)
2186                   cout << "    ...but the installed version doesn't meet the version requirement\n";
2187
2188                if (((*D).Op & pkgCache::Dep::LessEq) == pkgCache::Dep::LessEq)
2189                {
2190                   return _error->Error(_("Failed to satisfy %s dependency for %s: Installed package %s is too new"),
2191                                        Last->BuildDepType((*D).Type),
2192                                        Src.c_str(),
2193                                        Pkg.Name());
2194                }
2195             }
2196
2197
2198             if (_config->FindB("Debug::BuildDeps",false) == true)
2199                cout << "  Trying to install " << (*D).Package << endl;
2200
2201             if (TryToInstall(Pkg,Cache,Fix,false,false,ExpectedInst) == true)
2202             {
2203                // We successfully installed something; skip remaining alternatives
2204                skipAlternatives = hasAlternatives;
2205                continue;
2206             }
2207             else if (hasAlternatives)
2208             {
2209                if (_config->FindB("Debug::BuildDeps",false) == true)
2210                   cout << "  Unsatisfiable, trying alternatives\n";
2211                continue;
2212             }
2213             else
2214             {
2215                return _error->Error(_("Failed to satisfy %s dependency for %s: %s"),
2216                                     Last->BuildDepType((*D).Type),
2217                                     Src.c_str(),
2218                                     (*D).Package.c_str());
2219             }
2220          }
2221       }
2222
2223       Fix.InstallProtect();
2224       if (Fix.Resolve(true) == false)
2225          _error->Discard();
2226
2227       // Now we check the state of the packages,
2228       if (Cache->BrokenCount() != 0)
2229          return _error->Error(_("Build-dependencies for %s could not be satisfied."),*I);
2230    }
2231
2232    if (InstallPackages(Cache, false, true) == false)
2233       return _error->Error(_("Failed to process build dependencies"));
2234    return true;
2235 }
2236                                                                         /*}}}*/
2237
2238 // DoMoo - Never Ask, Never Tell                                        /*{{{*/
2239 // ---------------------------------------------------------------------
2240 /* */
2241 bool DoMoo(CommandLine &CmdL)
2242 {
2243    cout <<
2244       "         (__) \n"
2245       "         (oo) \n"
2246       "   /------\\/ \n"
2247       "  / |    ||   \n"
2248       " *  /\\---/\\ \n"
2249       "    ~~   ~~   \n"
2250       "....\"Have you mooed today?\"...\n";
2251
2252    return true;
2253 }
2254                                                                         /*}}}*/
2255 // ShowHelp - Show a help screen                                        /*{{{*/
2256 // ---------------------------------------------------------------------
2257 /* */
2258 bool ShowHelp(CommandLine &CmdL)
2259 {
2260    ioprintf(cout,_("%s %s for %s %s compiled on %s %s\n"),PACKAGE,VERSION,
2261             COMMON_OS,COMMON_CPU,__DATE__,__TIME__);
2262
2263    if (_config->FindB("version") == true)
2264    {
2265       cout << _("Supported Modules:") << endl;
2266
2267       for (unsigned I = 0; I != pkgVersioningSystem::GlobalListLen; I++)
2268       {
2269          pkgVersioningSystem *VS = pkgVersioningSystem::GlobalList[I];
2270          if (_system != 0 && _system->VS == VS)
2271             cout << '*';
2272          else
2273             cout << ' ';
2274          cout << "Ver: " << VS->Label << endl;
2275
2276          /* Print out all the packaging systems that will work with
2277             this VS */
2278          for (unsigned J = 0; J != pkgSystem::GlobalListLen; J++)
2279          {
2280             pkgSystem *Sys = pkgSystem::GlobalList[J];
2281             if (_system == Sys)
2282                cout << '*';
2283             else
2284                cout << ' ';
2285             if (Sys->VS->TestCompatibility(*VS) == true)
2286                cout << "Pkg:  " << Sys->Label << " (Priority " << Sys->Score(*_config) << ")" << endl;
2287          }
2288       }
2289
2290       for (unsigned I = 0; I != pkgSourceList::Type::GlobalListLen; I++)
2291       {
2292          pkgSourceList::Type *Type = pkgSourceList::Type::GlobalList[I];
2293          cout << " S.L: '" << Type->Name << "' " << Type->Label << endl;
2294       }
2295
2296       for (unsigned I = 0; I != pkgIndexFile::Type::GlobalListLen; I++)
2297       {
2298          pkgIndexFile::Type *Type = pkgIndexFile::Type::GlobalList[I];
2299          cout << " Idx: " << Type->Label << endl;
2300       }
2301
2302       return true;
2303    }
2304
2305    cout <<
2306     _("Usage: apt-get [options] command\n"
2307       "       apt-get [options] install|remove pkg1 [pkg2 ...]\n"
2308       "       apt-get [options] source pkg1 [pkg2 ...]\n"
2309       "\n"
2310       "apt-get is a simple command line interface for downloading and\n"
2311       "installing packages. The most frequently used commands are update\n"
2312       "and install.\n"
2313       "\n"
2314       "Commands:\n"
2315       "   update - Retrieve new lists of packages\n"
2316       "   upgrade - Perform an upgrade\n"
2317       "   install - Install new packages (pkg is libc6 not libc6.deb)\n"
2318       "   remove - Remove packages\n"
2319       "   source - Download source archives\n"
2320       "   build-dep - Configure build-dependencies for source packages\n"
2321       "   dist-upgrade - Distribution upgrade, see apt-get(8)\n"
2322       "   dselect-upgrade - Follow dselect selections\n"
2323       "   clean - Erase downloaded archive files\n"
2324       "   autoclean - Erase old downloaded archive files\n"
2325       "   check - Verify that there are no broken dependencies\n"
2326       "\n"
2327       "Options:\n"
2328       "  -h  This help text.\n"
2329       "  -q  Loggable output - no progress indicator\n"
2330       "  -qq No output except for errors\n"
2331       "  -d  Download only - do NOT install or unpack archives\n"
2332       "  -s  No-act. Perform ordering simulation\n"
2333       "  -y  Assume Yes to all queries and do not prompt\n"
2334       "  -f  Attempt to continue if the integrity check fails\n"
2335       "  -m  Attempt to continue if archives are unlocatable\n"
2336       "  -u  Show a list of upgraded packages as well\n"
2337       "  -b  Build the source package after fetching it\n"
2338       "  -V  Show verbose version numbers\n"
2339       "  -c=? Read this configuration file\n"
2340       "  -o=? Set an arbitary configuration option, eg -o dir::cache=/tmp\n"
2341       "See the apt-get(8), sources.list(5) and apt.conf(5) manual\n"
2342       "pages for more information and options.\n"
2343       "                       This APT has Super Cow Powers.\n");
2344    return true;
2345 }
2346                                                                         /*}}}*/
2347 // GetInitialize - Initialize things for apt-get                        /*{{{*/
2348 // ---------------------------------------------------------------------
2349 /* */
2350 void GetInitialize()
2351 {
2352    _config->Set("quiet",0);
2353    _config->Set("help",false);
2354    _config->Set("APT::Get::Download-Only",false);
2355    _config->Set("APT::Get::Simulate",false);
2356    _config->Set("APT::Get::Assume-Yes",false);
2357    _config->Set("APT::Get::Fix-Broken",false);
2358    _config->Set("APT::Get::Force-Yes",false);
2359    _config->Set("APT::Get::APT::Get::No-List-Cleanup",true);
2360 }
2361                                                                         /*}}}*/
2362 // SigWinch - Window size change signal handler                         /*{{{*/
2363 // ---------------------------------------------------------------------
2364 /* */
2365 void SigWinch(int)
2366 {
2367    // Riped from GNU ls
2368 #ifdef TIOCGWINSZ
2369    struct winsize ws;
2370
2371    if (ioctl(1, TIOCGWINSZ, &ws) != -1 && ws.ws_col >= 5)
2372       ScreenWidth = ws.ws_col - 1;
2373 #endif
2374 }
2375                                                                         /*}}}*/
2376
2377 int main(int argc,const char *argv[])
2378 {
2379    CommandLine::Args Args[] = {
2380       {'h',"help","help",0},
2381       {'v',"version","version",0},
2382       {'V',"verbose-versions","APT::Get::Show-Versions",0},
2383       {'q',"quiet","quiet",CommandLine::IntLevel},
2384       {'q',"silent","quiet",CommandLine::IntLevel},
2385       {'d',"download-only","APT::Get::Download-Only",0},
2386       {'b',"compile","APT::Get::Compile",0},
2387       {'b',"build","APT::Get::Compile",0},
2388       {'s',"simulate","APT::Get::Simulate",0},
2389       {'s',"just-print","APT::Get::Simulate",0},
2390       {'s',"recon","APT::Get::Simulate",0},
2391       {'s',"dry-run","APT::Get::Simulate",0},
2392       {'s',"no-act","APT::Get::Simulate",0},
2393       {'y',"yes","APT::Get::Assume-Yes",0},
2394       {'y',"assume-yes","APT::Get::Assume-Yes",0},
2395       {'f',"fix-broken","APT::Get::Fix-Broken",0},
2396       {'u',"show-upgraded","APT::Get::Show-Upgraded",0},
2397       {'m',"ignore-missing","APT::Get::Fix-Missing",0},
2398       {'t',"target-release","APT::Default-Release",CommandLine::HasArg},
2399       {'t',"default-release","APT::Default-Release",CommandLine::HasArg},
2400       {0,"download","APT::Get::Download",0},
2401       {0,"fix-missing","APT::Get::Fix-Missing",0},
2402       {0,"ignore-hold","APT::Ignore-Hold",0},
2403       {0,"upgrade","APT::Get::upgrade",0},
2404       {0,"force-yes","APT::Get::force-yes",0},
2405       {0,"print-uris","APT::Get::Print-URIs",0},
2406       {0,"diff-only","APT::Get::Diff-Only",0},
2407       {0,"tar-only","APT::Get::tar-Only",0},
2408       {0,"purge","APT::Get::Purge",0},
2409       {0,"list-cleanup","APT::Get::List-Cleanup",0},
2410       {0,"reinstall","APT::Get::ReInstall",0},
2411       {0,"trivial-only","APT::Get::Trivial-Only",0},
2412       {0,"remove","APT::Get::Remove",0},
2413       {0,"only-source","APT::Get::Only-Source",0},
2414       {0,"arch-only","APT::Get::Arch-Only",0},
2415       {'c',"config-file",0,CommandLine::ConfigFile},
2416       {'o',"option",0,CommandLine::ArbItem},
2417       {0,0,0,0}};
2418    CommandLine::Dispatch Cmds[] = {{"update",&DoUpdate},
2419                                    {"upgrade",&DoUpgrade},
2420                                    {"install",&DoInstall},
2421                                    {"remove",&DoInstall},
2422                                    {"dist-upgrade",&DoDistUpgrade},
2423                                    {"dselect-upgrade",&DoDSelectUpgrade},
2424                                    {"build-dep",&DoBuildDep},
2425                                    {"clean",&DoClean},
2426                                    {"autoclean",&DoAutoClean},
2427                                    {"check",&DoCheck},
2428                                    {"source",&DoSource},
2429                                    {"moo",&DoMoo},
2430                                    {"help",&ShowHelp},
2431                                    {0,0}};
2432
2433    // Set up gettext support
2434    setlocale(LC_ALL,"");
2435    textdomain(PACKAGE);
2436
2437    // Parse the command line and initialize the package library
2438    CommandLine CmdL(Args,_config);
2439    if (pkgInitConfig(*_config) == false ||
2440        CmdL.Parse(argc,argv) == false ||
2441        pkgInitSystem(*_config,_system) == false)
2442    {
2443       if (_config->FindB("version") == true)
2444          ShowHelp(CmdL);
2445
2446       _error->DumpErrors();
2447       return 100;
2448    }
2449
2450    // See if the help should be shown
2451    if (_config->FindB("help") == true ||
2452        _config->FindB("version") == true ||
2453        CmdL.FileSize() == 0)
2454    {
2455       ShowHelp(CmdL);
2456       return 0;
2457    }
2458
2459    // Deal with stdout not being a tty
2460    if (!isatty(STDOUT_FILENO) && _config->FindI("quiet",0) < 1)
2461       _config->Set("quiet","1");
2462
2463    // Setup the output streams
2464    c0out.rdbuf(cout.rdbuf());
2465    c1out.rdbuf(cout.rdbuf());
2466    c2out.rdbuf(cout.rdbuf());
2467    if (_config->FindI("quiet",0) > 0)
2468       c0out.rdbuf(devnull.rdbuf());
2469    if (_config->FindI("quiet",0) > 1)
2470       c1out.rdbuf(devnull.rdbuf());
2471
2472    // Setup the signals
2473    signal(SIGPIPE,SIG_IGN);
2474    signal(SIGWINCH,SigWinch);
2475    SigWinch(0);
2476
2477    // Match the operation
2478    CmdL.DispatchArg(Cmds);
2479
2480    // Print any errors or warnings found during parsing
2481    if (_error->empty() == false)
2482    {
2483       bool Errors = _error->PendingError();
2484       _error->DumpErrors();
2485       return Errors == true?100:0;
2486    }
2487
2488    return 0;
2489 }