cmdline/apt-get.cc

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