cmdline/apt-get.cc

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