cmdline/apt-get.cc

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