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