cmdline/apt-get.cc

   1 // -*- mode: cpp; mode: fold -*-
   2 // Description                                                          /*{{{*/
   3 // $Id: apt-get.cc,v 1.83 1999/10/22 05:58:54 jgg 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/dpkgpm.h>
  36 #include <apt-pkg/strutl.h>
  37 #include <apt-pkg/clean.h>
  38 #include <apt-pkg/srcrecords.h>
  39 #include <apt-pkg/version.h>
  40 #include <apt-pkg/cachefile.h>
  41
  42 #include <config.h>
  43
  44 #include "acqprogress.h"
  45
  46 #include <fstream.h>
  47 #include <termios.h>
  48 #include <sys/ioctl.h>
  49 #include <sys/stat.h>
  50 #include <sys/vfs.h>
  51 #include <signal.h>
  52 #include <unistd.h>
  53 #include <stdio.h>
  54 #include <errno.h>
  55 #include <regex.h>
  56 #include <sys/wait.h>
  57                                                                         /*}}}*/
  58
  59 ostream c0out;
  60 ostream c1out;
  61 ostream c2out;
  62 ofstream devnull("/dev/null");
  63 unsigned int ScreenWidth = 80;
  64
  65 // class CacheFile - Cover class for some dependency cache functions    /*{{{*/
  66 // ---------------------------------------------------------------------
  67 /* */
  68 class CacheFile : public pkgCacheFile
  69 {
  70    static pkgCache *SortCache;
  71    static int NameComp(const void *a,const void *b);
  72
  73    public:
  74    pkgCache::Package **List;
  75
  76    void Sort();
  77    bool CheckDeps(bool AllowBroken = false);
  78    bool Open(bool WithLock = true)
  79    {
  80       OpTextProgress Prog(*_config);
  81       if (pkgCacheFile::Open(Prog,WithLock) == false)
  82          return false;
  83       Sort();
  84       return true;
  85    };
  86    CacheFile() : List(0) {};
  87 };
  88                                                                         /*}}}*/
  89
  90 // YnPrompt - Yes No Prompt.                                            /*{{{*/
  91 // ---------------------------------------------------------------------
  92 /* Returns true on a Yes.*/
  93 bool YnPrompt()
  94 {
  95    if (_config->FindB("APT::Get::Assume-Yes",false) == true)
  96    {
  97       c1out << 'Y' << endl;
  98       return true;
  99    }
 100
 101    char C = 0;
 102    char Jnk = 0;
 103    read(STDIN_FILENO,&C,1);
 104    while (C != '\n' && Jnk != '\n') read(STDIN_FILENO,&Jnk,1);
 105
 106    if (!(C == 'Y' || C == 'y' || C == '\n' || C == '\r'))
 107       return false;
 108    return true;
 109 }
 110                                                                         /*}}}*/
 111 // AnalPrompt - Annoying Yes No Prompt.                                 /*{{{*/
 112 // ---------------------------------------------------------------------
 113 /* Returns true on a Yes.*/
 114 bool AnalPrompt(const char *Text)
 115 {
 116    char Buf[1024];
 117    cin.getline(Buf,sizeof(Buf));
 118    if (strcmp(Buf,Text) == 0)
 119       return true;
 120    return false;
 121 }
 122                                                                         /*}}}*/
 123 // ShowList - Show a list                                               /*{{{*/
 124 // ---------------------------------------------------------------------
 125 /* This prints out a string of space seperated words with a title and
 126    a two space indent line wraped to the current screen width. */
 127 bool ShowList(ostream &out,string Title,string List)
 128 {
 129    if (List.empty() == true)
 130       return true;
 131
 132    // Acount for the leading space
 133    int ScreenWidth = ::ScreenWidth - 3;
 134
 135    out << Title << endl;
 136    string::size_type Start = 0;
 137    while (Start < List.size())
 138    {
 139       string::size_type End;
 140       if (Start + ScreenWidth >= List.size())
 141          End = List.size();
 142       else
 143          End = List.rfind(' ',Start+ScreenWidth);
 144
 145       if (End == string::npos || End < Start)
 146          End = Start + ScreenWidth;
 147       out << "  " << string(List,Start,End - Start) << endl;
 148       Start = End + 1;
 149    }
 150    return false;
 151 }
 152                                                                         /*}}}*/
 153 // ShowBroken - Debugging aide                                          /*{{{*/
 154 // ---------------------------------------------------------------------
 155 /* This prints out the names of all the packages that are broken along
 156    with the name of each each broken dependency and a quite version
 157    description. */
 158 void ShowBroken(ostream &out,CacheFile &Cache,bool Now)
 159 {
 160    out << "Sorry, but the following packages have unmet dependencies:" << endl;
 161    for (unsigned J = 0; J < Cache->Head().PackageCount; J++)
 162    {
 163       pkgCache::PkgIterator I(Cache,Cache.List[J]);
 164
 165       if (Cache[I].InstBroken() == false)
 166           continue;
 167
 168       // Print out each package and the failed dependencies
 169       out <<"  " <<  I.Name() << ":";
 170       unsigned Indent = strlen(I.Name()) + 3;
 171       bool First = true;
 172       if (Cache[I].InstVerIter(Cache).end() == true)
 173       {
 174          cout << endl;
 175          continue;
 176       }
 177
 178       for (pkgCache::DepIterator D = Cache[I].InstVerIter(Cache).DependsList(); D.end() == false;)
 179       {
 180          // Compute a single dependency element (glob or)
 181          pkgCache::DepIterator Start;
 182          pkgCache::DepIterator End;
 183          D.GlobOr(Start,End);
 184
 185          if (Cache->IsImportantDep(End) == false ||
 186              (Cache[End] & pkgDepCache::DepGInstall) == pkgDepCache::DepGInstall)
 187             continue;
 188
 189          bool FirstOr = true;
 190          while (1)
 191          {
 192             if (First == false)
 193                for (unsigned J = 0; J != Indent; J++)
 194                   out << ' ';
 195             First = false;
 196
 197             if (FirstOr == false)
 198             {
 199                for (unsigned J = 0; J != strlen(End.DepType()) + 3; J++)
 200                   out << ' ';
 201             }
 202             else
 203                out << ' ' << End.DepType() << ": ";
 204             FirstOr = false;
 205
 206             out << Start.TargetPkg().Name();
 207
 208             // Show a quick summary of the version requirements
 209             if (Start.TargetVer() != 0)
 210                out << " (" << Start.CompType() << " " << Start.TargetVer() <<
 211                ")";
 212
 213             /* Show a summary of the target package if possible. In the case
 214                of virtual packages we show nothing */
 215             pkgCache::PkgIterator Targ = Start.TargetPkg();
 216             if (Targ->ProvidesList == 0)
 217             {
 218                out << " but ";
 219                pkgCache::VerIterator Ver = Cache[Targ].InstVerIter(Cache);
 220                if (Ver.end() == false)
 221                   out << Ver.VerStr() << (Now?" is installed":" is to be installed");
 222                else
 223                {
 224                   if (Cache[Targ].CandidateVerIter(Cache).end() == true)
 225                   {
 226                      if (Targ->ProvidesList == 0)
 227                         out << "it is not installable";
 228                      else
 229                         out << "it is a virtual package";
 230                   }
 231                   else
 232                      out << (Now?"it is not installed":"it is not going to be installed");
 233                }
 234             }
 235
 236             if (Start != End)
 237                cout << " or";
 238             out << endl;
 239
 240             if (Start == End)
 241                break;
 242             Start++;
 243          }
 244       }
 245    }
 246 }
 247                                                                         /*}}}*/
 248 // ShowNew - Show packages to newly install                             /*{{{*/
 249 // ---------------------------------------------------------------------
 250 /* */
 251 void ShowNew(ostream &out,CacheFile &Cache)
 252 {
 253    /* Print out a list of packages that are going to be removed extra
 254       to what the user asked */
 255    string List;
 256    for (unsigned J = 0; J < Cache->Head().PackageCount; J++)
 257    {
 258       pkgCache::PkgIterator I(Cache,Cache.List[J]);
 259       if (Cache[I].NewInstall() == true)
 260          List += string(I.Name()) + " ";
 261    }
 262
 263    ShowList(out,"The following NEW packages will be installed:",List);
 264 }
 265                                                                         /*}}}*/
 266 // ShowDel - Show packages to delete                                    /*{{{*/
 267 // ---------------------------------------------------------------------
 268 /* */
 269 void ShowDel(ostream &out,CacheFile &Cache)
 270 {
 271    /* Print out a list of packages that are going to be removed extra
 272       to what the user asked */
 273    string List;
 274    for (unsigned J = 0; J < Cache->Head().PackageCount; J++)
 275    {
 276       pkgCache::PkgIterator I(Cache,Cache.List[J]);
 277       if (Cache[I].Delete() == true)
 278       {
 279          if ((Cache[I].iFlags & pkgDepCache::Purge) == pkgDepCache::Purge)
 280             List += string(I.Name()) + "* ";
 281          else
 282             List += string(I.Name()) + " ";
 283       }
 284    }
 285
 286    ShowList(out,"The following packages will be REMOVED:",List);
 287 }
 288                                                                         /*}}}*/
 289 // ShowKept - Show kept packages                                        /*{{{*/
 290 // ---------------------------------------------------------------------
 291 /* */
 292 void ShowKept(ostream &out,CacheFile &Cache)
 293 {
 294    string List;
 295    for (unsigned J = 0; J < Cache->Head().PackageCount; J++)
 296    {
 297       pkgCache::PkgIterator I(Cache,Cache.List[J]);
 298
 299       // Not interesting
 300       if (Cache[I].Upgrade() == true || Cache[I].Upgradable() == false ||
 301           I->CurrentVer == 0 || Cache[I].Delete() == true)
 302          continue;
 303
 304       List += string(I.Name()) + " ";
 305    }
 306    ShowList(out,"The following packages have been kept back",List);
 307 }
 308                                                                         /*}}}*/
 309 // ShowUpgraded - Show upgraded packages                                /*{{{*/
 310 // ---------------------------------------------------------------------
 311 /* */
 312 void ShowUpgraded(ostream &out,CacheFile &Cache)
 313 {
 314    string List;
 315    for (unsigned J = 0; J < Cache->Head().PackageCount; J++)
 316    {
 317       pkgCache::PkgIterator I(Cache,Cache.List[J]);
 318
 319       // Not interesting
 320       if (Cache[I].Upgrade() == false || Cache[I].NewInstall() == true)
 321          continue;
 322
 323       List += string(I.Name()) + " ";
 324    }
 325    ShowList(out,"The following packages will be upgraded",List);
 326 }
 327                                                                         /*}}}*/
 328 // ShowHold - Show held but changed packages                            /*{{{*/
 329 // ---------------------------------------------------------------------
 330 /* */
 331 bool ShowHold(ostream &out,CacheFile &Cache)
 332 {
 333    string List;
 334    for (unsigned J = 0; J < Cache->Head().PackageCount; J++)
 335    {
 336       pkgCache::PkgIterator I(Cache,Cache.List[J]);
 337       if (Cache[I].InstallVer != (pkgCache::Version *)I.CurrentVer() &&
 338           I->SelectedState == pkgCache::State::Hold)
 339          List += string(I.Name()) + " ";
 340    }
 341
 342    return ShowList(out,"The following held packages will be changed:",List);
 343 }
 344                                                                         /*}}}*/
 345 // ShowEssential - Show an essential package warning                    /*{{{*/
 346 // ---------------------------------------------------------------------
 347 /* This prints out a warning message that is not to be ignored. It shows
 348    all essential packages and their dependents that are to be removed.
 349    It is insanely risky to remove the dependents of an essential package! */
 350 bool ShowEssential(ostream &out,CacheFile &Cache)
 351 {
 352    string List;
 353    bool *Added = new bool[Cache->HeaderP->PackageCount];
 354    for (unsigned int I = 0; I != Cache->HeaderP->PackageCount; I++)
 355       Added[I] = false;
 356
 357    for (unsigned J = 0; J < Cache->Head().PackageCount; J++)
 358    {
 359       pkgCache::PkgIterator I(Cache,Cache.List[J]);
 360       if ((I->Flags & pkgCache::Flag::Essential) != pkgCache::Flag::Essential)
 361          continue;
 362
 363       // The essential package is being removed
 364       if (Cache[I].Delete() == true)
 365       {
 366          if (Added[I->ID] == false)
 367          {
 368             Added[I->ID] = true;
 369             List += string(I.Name()) + " ";
 370          }
 371       }
 372
 373       if (I->CurrentVer == 0)
 374          continue;
 375
 376       // Print out any essential package depenendents that are to be removed
 377       for (pkgDepCache::DepIterator D = I.CurrentVer().DependsList(); D.end() == false; D++)
 378       {
 379          // Skip everything but depends
 380          if (D->Type != pkgCache::Dep::PreDepends &&
 381              D->Type != pkgCache::Dep::Depends)
 382             continue;
 383
 384          pkgCache::PkgIterator P = D.SmartTargetPkg();
 385          if (Cache[P].Delete() == true)
 386          {
 387             if (Added[P->ID] == true)
 388                continue;
 389             Added[P->ID] = true;
 390
 391             char S[300];
 392             sprintf(S,"%s (due to %s) ",P.Name(),I.Name());
 393             List += S;
 394          }
 395       }
 396    }
 397
 398    delete [] Added;
 399    if (List.empty() == false)
 400       out << "WARNING: The following essential packages will be removed" << endl;
 401    return ShowList(out,"This should NOT be done unless you know exactly what you are doing!",List);
 402 }
 403                                                                         /*}}}*/
 404 // Stats - Show some statistics                                         /*{{{*/
 405 // ---------------------------------------------------------------------
 406 /* */
 407 void Stats(ostream &out,pkgDepCache &Dep)
 408 {
 409    unsigned long Upgrade = 0;
 410    unsigned long Install = 0;
 411    unsigned long ReInstall = 0;
 412    for (pkgCache::PkgIterator I = Dep.PkgBegin(); I.end() == false; I++)
 413    {
 414       if (Dep[I].NewInstall() == true)
 415          Install++;
 416       else
 417          if (Dep[I].Upgrade() == true)
 418             Upgrade++;
 419       if (Dep[I].Delete() == false && (Dep[I].iFlags & pkgDepCache::ReInstall) == pkgDepCache::ReInstall)
 420          ReInstall++;
 421    }
 422
 423    out << Upgrade << " packages upgraded, " <<
 424       Install << " newly installed, ";
 425    if (ReInstall != 0)
 426       out << ReInstall << " reinstalled, ";
 427    out << Dep.DelCount() << " to remove and " <<
 428       Dep.KeepCount() << " not upgraded." << endl;
 429
 430    if (Dep.BadCount() != 0)
 431       out << Dep.BadCount() << " packages not fully installed or removed." << endl;
 432 }
 433                                                                         /*}}}*/
 434
 435 // CacheFile::NameComp - QSort compare by name                          /*{{{*/
 436 // ---------------------------------------------------------------------
 437 /* */
 438 pkgCache *CacheFile::SortCache = 0;
 439 int CacheFile::NameComp(const void *a,const void *b)
 440 {
 441    if (*(pkgCache::Package **)a == 0 || *(pkgCache::Package **)b == 0)
 442       return *(pkgCache::Package **)a - *(pkgCache::Package **)b;
 443
 444    const pkgCache::Package &A = **(pkgCache::Package **)a;
 445    const pkgCache::Package &B = **(pkgCache::Package **)b;
 446
 447    return strcmp(SortCache->StrP + A.Name,SortCache->StrP + B.Name);
 448 }
 449                                                                         /*}}}*/
 450 // CacheFile::Sort - Sort by name                                       /*{{{*/
 451 // ---------------------------------------------------------------------
 452 /* */
 453 void CacheFile::Sort()
 454 {
 455    delete [] List;
 456    List = new pkgCache::Package *[Cache->Head().PackageCount];
 457    memset(List,0,sizeof(*List)*Cache->Head().PackageCount);
 458    pkgCache::PkgIterator I = Cache->PkgBegin();
 459    for (;I.end() != true; I++)
 460       List[I->ID] = I;
 461
 462    SortCache = *this;
 463    qsort(List,Cache->Head().PackageCount,sizeof(*List),NameComp);
 464 }
 465                                                                         /*}}}*/
 466 // CacheFile::Open - Open the cache file                                /*{{{*/
 467 // ---------------------------------------------------------------------
 468 /* This routine generates the caches and then opens the dependency cache
 469    and verifies that the system is OK. */
 470 bool CacheFile::CheckDeps(bool AllowBroken)
 471 {
 472    if (_error->PendingError() == true)
 473       return false;
 474
 475    // Check that the system is OK
 476    if (Cache->DelCount() != 0 || Cache->InstCount() != 0)
 477       return _error->Error("Internal Error, non-zero counts");
 478
 479    // Apply corrections for half-installed packages
 480    if (pkgApplyStatus(*Cache) == false)
 481       return false;
 482
 483    // Nothing is broken
 484    if (Cache->BrokenCount() == 0 || AllowBroken == true)
 485       return true;
 486
 487    // Attempt to fix broken things
 488    if (_config->FindB("APT::Get::Fix-Broken",false) == true)
 489    {
 490       c1out << "Correcting dependencies..." << flush;
 491       if (pkgFixBroken(*Cache) == false || Cache->BrokenCount() != 0)
 492       {
 493          c1out << " failed." << endl;
 494          ShowBroken(c1out,*this,true);
 495
 496          return _error->Error("Unable to correct dependencies");
 497       }
 498       if (pkgMinimizeUpgrade(*Cache) == false)
 499          return _error->Error("Unable to minimize the upgrade set");
 500
 501       c1out << " Done" << endl;
 502    }
 503    else
 504    {
 505       c1out << "You might want to run `apt-get -f install' to correct these." << endl;
 506       ShowBroken(c1out,*this,true);
 507
 508       return _error->Error("Unmet dependencies. Try using -f.");
 509    }
 510
 511    return true;
 512 }
 513                                                                         /*}}}*/
 514
 515 // InstallPackages - Actually download and install the packages         /*{{{*/
 516 // ---------------------------------------------------------------------
 517 /* This displays the informative messages describing what is going to
 518    happen and then calls the download routines */
 519 bool InstallPackages(CacheFile &Cache,bool ShwKept,bool Ask = true,bool Saftey = true)
 520 {
 521    if (_config->FindB("APT::Get::Purge",false) == true)
 522    {
 523       pkgCache::PkgIterator I = Cache->PkgBegin();
 524       for (; I.end() == false; I++)
 525       {
 526          if (I.Purge() == false && Cache[I].Mode == pkgDepCache::ModeDelete)
 527             Cache->MarkDelete(I,true);
 528       }
 529    }
 530
 531    bool Fail = false;
 532    bool Essential = false;
 533
 534    // Show all the various warning indicators
 535    ShowDel(c1out,Cache);
 536    ShowNew(c1out,Cache);
 537    if (ShwKept == true)
 538       ShowKept(c1out,Cache);
 539    Fail |= !ShowHold(c1out,Cache);
 540    if (_config->FindB("APT::Get::Show-Upgraded",false) == true)
 541       ShowUpgraded(c1out,Cache);
 542    Essential = !ShowEssential(c1out,Cache);
 543    Fail |= Essential;
 544    Stats(c1out,Cache);
 545
 546    // Sanity check
 547    if (Cache->BrokenCount() != 0)
 548    {
 549       ShowBroken(c1out,Cache,false);
 550       return _error->Error("Internal Error, InstallPackages was called with broken packages!");
 551    }
 552
 553    if (Cache->DelCount() == 0 && Cache->InstCount() == 0 &&
 554        Cache->BadCount() == 0)
 555       return true;
 556
 557    // Run the simulator ..
 558    if (_config->FindB("APT::Get::Simulate") == true)
 559    {
 560       pkgSimulate PM(Cache);
 561       pkgPackageManager::OrderResult Res = PM.DoInstall();
 562       if (Res == pkgPackageManager::Failed)
 563          return false;
 564       if (Res != pkgPackageManager::Completed)
 565          return _error->Error("Internal Error, Ordering didn't finish");
 566       return true;
 567    }
 568
 569    // Create the text record parser
 570    pkgRecords Recs(Cache);
 571    if (_error->PendingError() == true)
 572       return false;
 573
 574    // Lock the archive directory
 575    FileFd Lock;
 576    if (_config->FindB("Debug::NoLocking",false) == false)
 577    {
 578       Lock.Fd(GetLock(_config->FindDir("Dir::Cache::Archives") + "lock"));
 579       if (_error->PendingError() == true)
 580          return _error->Error("Unable to lock the download directory");
 581    }
 582
 583    // Create the download object
 584    AcqTextStatus Stat(ScreenWidth,_config->FindI("quiet",0));
 585    pkgAcquire Fetcher(&Stat);
 586
 587    // Read the source list
 588    pkgSourceList List;
 589    if (List.ReadMainList() == false)
 590       return _error->Error("The list of sources could not be read.");
 591
 592    // Create the package manager and prepare to download
 593    pkgDPkgPM PM(Cache);
 594    if (PM.GetArchives(&Fetcher,&List,&Recs) == false ||
 595        _error->PendingError() == true)
 596       return false;
 597
 598    // Display statistics
 599    unsigned long FetchBytes = Fetcher.FetchNeeded();
 600    unsigned long FetchPBytes = Fetcher.PartialPresent();
 601    unsigned long DebBytes = Fetcher.TotalNeeded();
 602    if (DebBytes != Cache->DebSize())
 603    {
 604       c0out << DebBytes << ',' << Cache->DebSize() << endl;
 605       c0out << "How odd.. The sizes didn't match, email apt@packages.debian.org" << endl;
 606    }
 607
 608    // Number of bytes
 609    c1out << "Need to get ";
 610    if (DebBytes != FetchBytes)
 611       c1out << SizeToStr(FetchBytes) << "B/" << SizeToStr(DebBytes) << 'B';
 612    else
 613       c1out << SizeToStr(DebBytes) << 'B';
 614
 615    c1out << " of archives. After unpacking ";
 616
 617    // Check for enough free space
 618    struct statfs Buf;
 619    string OutputDir = _config->FindDir("Dir::Cache::Archives");
 620    if (statfs(OutputDir.c_str(),&Buf) != 0)
 621       return _error->Errno("statfs","Couldn't determine free space in %s",
 622                            OutputDir.c_str());
 623    if (unsigned(Buf.f_bfree) < (FetchBytes - FetchPBytes)/Buf.f_bsize)
 624       return _error->Error("Sorry, you don't have enough free space in %s to hold all the .debs.",
 625                            OutputDir.c_str());
 626
 627    // Size delta
 628    if (Cache->UsrSize() >= 0)
 629       c1out << SizeToStr(Cache->UsrSize()) << "B will be used." << endl;
 630    else
 631       c1out << SizeToStr(-1*Cache->UsrSize()) << "B will be freed." << endl;
 632
 633    if (_error->PendingError() == true)
 634       return false;
 635
 636    // Fail safe check
 637    if (_config->FindI("quiet",0) >= 2 ||
 638        _config->FindB("APT::Get::Assume-Yes",false) == true)
 639    {
 640       if (Fail == true && _config->FindB("APT::Get::Force-Yes",false) == false)
 641          return _error->Error("There are problems and -y was used without --force-yes");
 642    }
 643
 644    if (Essential == true && Saftey == true)
 645    {
 646       c2out << "You are about to do something potentially harmful" << endl;
 647       c2out << "To continue type in the phrase 'Yes, I understand this may be bad'" << endl;
 648       c2out << " ?] " << flush;
 649       if (AnalPrompt("Yes, I understand this may be bad") == false)
 650       {
 651          c2out << "Abort." << endl;
 652          exit(1);
 653       }
 654    }
 655    else
 656    {
 657       // Prompt to continue
 658       if (Ask == true || Fail == true)
 659       {
 660          if (_config->FindI("quiet",0) < 2 &&
 661              _config->FindB("APT::Get::Assume-Yes",false) == false)
 662          {
 663             c2out << "Do you want to continue? [Y/n] " << flush;
 664
 665             if (YnPrompt() == false)
 666             {
 667                c2out << "Abort." << endl;
 668                exit(1);
 669             }
 670          }
 671       }
 672    }
 673
 674    // Just print out the uris an exit if the --print-uris flag was used
 675    if (_config->FindB("APT::Get::Print-URIs") == true)
 676    {
 677       pkgAcquire::UriIterator I = Fetcher.UriBegin();
 678       for (; I != Fetcher.UriEnd(); I++)
 679          cout << '\'' << I->URI << "' " << flNotDir(I->Owner->DestFile) << ' ' <<
 680                I->Owner->FileSize << ' ' << I->Owner->MD5Sum() << endl;
 681       return true;
 682    }
 683
 684    // Run it
 685    while (1)
 686    {
 687       if (_config->FindB("APT::Get::No-Download",false) == false)
 688          if (Fetcher.Run() == pkgAcquire::Failed)
 689             return false;
 690
 691       // Print out errors
 692       bool Failed = false;
 693       bool Transient = false;
 694       for (pkgAcquire::Item **I = Fetcher.ItemsBegin(); I != Fetcher.ItemsEnd(); I++)
 695       {
 696          if ((*I)->Status == pkgAcquire::Item::StatDone &&
 697              (*I)->Complete == true)
 698             continue;
 699
 700          if ((*I)->Status == pkgAcquire::Item::StatIdle)
 701          {
 702             Transient = true;
 703             // Failed = true;
 704             continue;
 705          }
 706
 707          cerr << "Failed to fetch " << (*I)->DescURI() << endl;
 708          cerr << "  " << (*I)->ErrorText << endl;
 709          Failed = true;
 710       }
 711
 712       /* If we are in no download mode and missing files then there were
 713          'failures' then the user must specify -m. Furthermore, there
 714          is no such thing as a transient error in no-download mode! */
 715       if (Transient == true &&
 716           _config->FindB("APT::Get::No-Download",false) == true)
 717       {
 718          Transient = false;
 719          Failed = true;
 720       }
 721
 722       if (_config->FindB("APT::Get::Download-Only",false) == true)
 723       {
 724          if (Failed == true && _config->FindB("APT::Get::Fix-Missing",false) == false)
 725             return _error->Error("Some files failed to download");
 726          return true;
 727       }
 728
 729       if (Failed == true && _config->FindB("APT::Get::Fix-Missing",false) == false)
 730       {
 731          return _error->Error("Unable to fetch some archives, maybe try with --fix-missing?");
 732       }
 733
 734       if (Transient == true && Failed == true)
 735          return _error->Error("--fix-missing and media swapping is not currently supported");
 736
 737       // Try to deal with missing package files
 738       if (Failed == true && PM.FixMissing() == false)
 739       {
 740          cerr << "Unable to correct missing packages." << endl;
 741          return _error->Error("Aborting Install.");
 742       }
 743
 744       Cache.ReleaseLock();
 745       pkgPackageManager::OrderResult Res = PM.DoInstall();
 746       if (Res == pkgPackageManager::Failed || _error->PendingError() == true)
 747          return false;
 748       if (Res == pkgPackageManager::Completed)
 749          return true;
 750
 751       // Reload the fetcher object and loop again for media swapping
 752       Fetcher.Shutdown();
 753       if (PM.GetArchives(&Fetcher,&List,&Recs) == false)
 754          return false;
 755    }
 756 }
 757                                                                         /*}}}*/
 758 // TryToInstall - Try to install a single package                       /*{{{*/
 759 // ---------------------------------------------------------------------
 760 /* This used to be inlined in DoInstall, but with the advent of regex package
 761    name matching it was split out.. */
 762 bool TryToInstall(pkgCache::PkgIterator Pkg,pkgDepCache &Cache,
 763                   pkgProblemResolver &Fix,bool Remove,bool BrokenFix,
 764                   unsigned int &ExpectedInst,bool AllowFail = true)
 765 {
 766    /* This is a pure virtual package and there is a single available
 767       provides */
 768    if (Cache[Pkg].CandidateVer == 0 && Pkg->ProvidesList != 0 &&
 769        Pkg.ProvidesList()->NextProvides == 0)
 770    {
 771       pkgCache::PkgIterator Tmp = Pkg.ProvidesList().OwnerPkg();
 772       c1out << "Note, installing " << Tmp.Name() << " instead of " << Pkg.Name() << endl;
 773       Pkg = Tmp;
 774    }
 775
 776    // Handle the no-upgrade case
 777    if (_config->FindB("APT::Get::no-upgrade",false) == true &&
 778        Pkg->CurrentVer != 0)
 779    {
 780       if (AllowFail == true)
 781          c1out << "Skipping " << Pkg.Name() << ", it is already installed and no-upgrade is set." << endl;
 782       return true;
 783    }
 784
 785    // Check if there is something at all to install
 786    pkgDepCache::StateCache &State = Cache[Pkg];
 787    if (State.CandidateVer == 0)
 788    {
 789       if (AllowFail == false)
 790          return false;
 791
 792       if (Pkg->ProvidesList != 0)
 793       {
 794          c1out << "Package " << Pkg.Name() << " is a virtual package provided by:" << endl;
 795
 796          pkgCache::PrvIterator I = Pkg.ProvidesList();
 797          for (; I.end() == false; I++)
 798          {
 799             pkgCache::PkgIterator Pkg = I.OwnerPkg();
 800
 801             if (Cache[Pkg].CandidateVerIter(Cache) == I.OwnerVer())
 802             {
 803                if (Cache[Pkg].Install() == true && Cache[Pkg].NewInstall() == false)
 804                   c1out << "  " << Pkg.Name() << " " << I.OwnerVer().VerStr() <<
 805                   " [Installed]"<< endl;
 806                else
 807                   c1out << "  " << Pkg.Name() << " " << I.OwnerVer().VerStr() << endl;
 808             }
 809          }
 810          c1out << "You should explicitly select one to install." << endl;
 811       }
 812       else
 813       {
 814          c1out << "Package " << Pkg.Name() << " has no available version, but exists in the database." << endl;
 815          c1out << "This typically means that the package was mentioned in a dependency and " << endl;
 816          c1out << "never uploaded, or that it is an obsolete package." << endl;
 817
 818          string List;
 819          pkgCache::DepIterator Dep = Pkg.RevDependsList();
 820          for (; Dep.end() == false; Dep++)
 821          {
 822             if (Dep->Type != pkgCache::Dep::Replaces)
 823                continue;
 824             List += string(Dep.ParentPkg().Name()) + " ";
 825          }
 826          ShowList(c1out,"However the following packages replace it:",List);
 827       }
 828
 829       _error->Error("Package %s has no installation candidate",Pkg.Name());
 830       return false;
 831    }
 832
 833    Fix.Protect(Pkg);
 834    if (Remove == true)
 835    {
 836       Fix.Remove(Pkg);
 837       Cache.MarkDelete(Pkg,_config->FindB("APT::Get::Purge",false));
 838       return true;
 839    }
 840
 841    // Install it
 842    Cache.MarkInstall(Pkg,false);
 843    if (State.Install() == false)
 844    {
 845       if (_config->FindB("APT::Get::ReInstall",false) == true)
 846       {
 847          if (Pkg->CurrentVer == 0 || Pkg.CurrentVer().Downloadable() == false)
 848             c1out << "Sorry, re-installation of " << Pkg.Name() << " is not possible, it cannot be downloaded" << endl;
 849          else
 850             Cache.SetReInstall(Pkg,true);
 851       }
 852       else
 853       {
 854          if (AllowFail == true)
 855             c1out << "Sorry, " << Pkg.Name() << " is already the newest version"  << endl;
 856       }
 857    }
 858    else
 859       ExpectedInst++;
 860
 861    // Install it with autoinstalling enabled.
 862    if (State.InstBroken() == true && BrokenFix == false)
 863       Cache.MarkInstall(Pkg,true);
 864    return true;
 865 }
 866                                                                         /*}}}*/
 867
 868 // DoUpdate - Update the package lists                                  /*{{{*/
 869 // ---------------------------------------------------------------------
 870 /* */
 871 bool DoUpdate(CommandLine &)
 872 {
 873    // Get the source list
 874    pkgSourceList List;
 875    if (List.ReadMainList() == false)
 876       return false;
 877
 878    // Lock the list directory
 879    FileFd Lock;
 880    if (_config->FindB("Debug::NoLocking",false) == false)
 881    {
 882       Lock.Fd(GetLock(_config->FindDir("Dir::State::Lists") + "lock"));
 883       if (_error->PendingError() == true)
 884          return _error->Error("Unable to lock the list directory");
 885    }
 886
 887    // Create the download object
 888    AcqTextStatus Stat(ScreenWidth,_config->FindI("quiet",0));
 889    pkgAcquire Fetcher(&Stat);
 890
 891    // Populate it with the source selection
 892    pkgSourceList::const_iterator I;
 893    for (I = List.begin(); I != List.end(); I++)
 894    {
 895       new pkgAcqIndex(&Fetcher,I);
 896       if (_error->PendingError() == true)
 897          return false;
 898    }
 899
 900    // Run it
 901    if (Fetcher.Run() == pkgAcquire::Failed)
 902       return false;
 903
 904    bool Failed = false;
 905    for (pkgAcquire::Item **I = Fetcher.ItemsBegin(); I != Fetcher.ItemsEnd(); I++)
 906    {
 907       if ((*I)->Status == pkgAcquire::Item::StatDone)
 908          continue;
 909
 910       (*I)->Finished();
 911
 912       cerr << "Failed to fetch " << (*I)->DescURI() << endl;
 913       cerr << "  " << (*I)->ErrorText << endl;
 914       Failed = true;
 915    }
 916
 917    // Clean out any old list files
 918    if (_config->FindB("APT::Get::List-Cleanup",false) == false)
 919    {
 920       if (Fetcher.Clean(_config->FindDir("Dir::State::lists")) == false ||
 921           Fetcher.Clean(_config->FindDir("Dir::State::lists") + "partial/") == false)
 922          return false;
 923    }
 924
 925    // Prepare the cache.
 926    CacheFile Cache;
 927    if (Cache.Open() == false)
 928       return false;
 929
 930    if (Failed == true)
 931       return _error->Error("Some index files failed to download, they have been ignored, or old ones used instead.");
 932    return true;
 933 }
 934                                                                         /*}}}*/
 935 // DoUpgrade - Upgrade all packages                                     /*{{{*/
 936 // ---------------------------------------------------------------------
 937 /* Upgrade all packages without installing new packages or erasing old
 938    packages */
 939 bool DoUpgrade(CommandLine &CmdL)
 940 {
 941    CacheFile Cache;
 942    if (Cache.Open() == false || Cache.CheckDeps() == false)
 943       return false;
 944
 945    // Do the upgrade
 946    if (pkgAllUpgrade(Cache) == false)
 947    {
 948       ShowBroken(c1out,Cache,false);
 949       return _error->Error("Internal Error, AllUpgrade broke stuff");
 950    }
 951
 952    return InstallPackages(Cache,true);
 953 }
 954                                                                         /*}}}*/
 955 // DoInstall - Install packages from the command line                   /*{{{*/
 956 // ---------------------------------------------------------------------
 957 /* Install named packages */
 958 bool DoInstall(CommandLine &CmdL)
 959 {
 960    CacheFile Cache;
 961    if (Cache.Open() == false || Cache.CheckDeps(CmdL.FileSize() != 1) == false)
 962       return false;
 963
 964    // Enter the special broken fixing mode if the user specified arguments
 965    bool BrokenFix = false;
 966    if (Cache->BrokenCount() != 0)
 967       BrokenFix = true;
 968
 969    unsigned int ExpectedInst = 0;
 970    unsigned int Packages = 0;
 971    pkgProblemResolver Fix(Cache);
 972
 973    bool DefRemove = false;
 974    if (strcasecmp(CmdL.FileList[0],"remove") == 0)
 975       DefRemove = true;
 976
 977    for (const char **I = CmdL.FileList + 1; *I != 0; I++)
 978    {
 979       // Duplicate the string
 980       unsigned int Length = strlen(*I);
 981       char S[300];
 982       if (Length >= sizeof(S))
 983          continue;
 984       strcpy(S,*I);
 985
 986       // See if we are removing the package
 987       bool Remove = DefRemove;
 988       while (Cache->FindPkg(S).end() == true)
 989       {
 990          // Handle an optional end tag indicating what to do
 991          if (S[Length - 1] == '-')
 992          {
 993             Remove = true;
 994             S[--Length] = 0;
 995             continue;
 996          }
 997
 998          if (S[Length - 1] == '+')
 999          {
1000             Remove = false;
1001             S[--Length] = 0;
1002             continue;
1003          }
1004          break;
1005       }
1006
1007       // Locate the package
1008       pkgCache::PkgIterator Pkg = Cache->FindPkg(S);
1009       Packages++;
1010       if (Pkg.end() == true)
1011       {
1012          // Check if the name is a regex
1013          const char *I;
1014          for (I = S; *I != 0; I++)
1015             if (*I == '.' || *I == '?' || *I == '*')
1016                break;
1017          if (*I == 0)
1018             return _error->Error("Couldn't find package %s",S);
1019
1020          // Regexs must always be confirmed
1021          ExpectedInst += 1000;
1022
1023          // Compile the regex pattern
1024          regex_t Pattern;
1025          if (regcomp(&Pattern,S,REG_EXTENDED | REG_ICASE |
1026                      REG_NOSUB) != 0)
1027             return _error->Error("Regex compilation error");
1028
1029          // Run over the matches
1030          bool Hit = false;
1031          for (Pkg = Cache->PkgBegin(); Pkg.end() == false; Pkg++)
1032          {
1033             if (regexec(&Pattern,Pkg.Name(),0,0,0) != 0)
1034                continue;
1035
1036             Hit |= TryToInstall(Pkg,Cache,Fix,Remove,BrokenFix,
1037                                 ExpectedInst,false);
1038          }
1039          regfree(&Pattern);
1040
1041          if (Hit == false)
1042             return _error->Error("Couldn't find package %s",S);
1043       }
1044       else
1045       {
1046          if (TryToInstall(Pkg,Cache,Fix,Remove,BrokenFix,ExpectedInst) == false)
1047             return false;
1048       }
1049    }
1050
1051    /* If we are in the Broken fixing mode we do not attempt to fix the
1052       problems. This is if the user invoked install without -f and gave
1053       packages */
1054    if (BrokenFix == true && Cache->BrokenCount() != 0)
1055    {
1056       c1out << "You might want to run `apt-get -f install' to correct these:" << endl;
1057       ShowBroken(c1out,Cache,false);
1058
1059       return _error->Error("Unmet dependencies. Try 'apt-get -f install' with no packages (or specify a solution).");
1060    }
1061
1062    // Call the scored problem resolver
1063    Fix.InstallProtect();
1064    if (Fix.Resolve(true) == false)
1065       _error->Discard();
1066
1067    // Now we check the state of the packages,
1068    if (Cache->BrokenCount() != 0)
1069    {
1070       c1out << "Some packages could not be installed. This may mean that you have" << endl;
1071       c1out << "requested an impossible situation or if you are using the unstable" << endl;
1072       c1out << "distribution that some required packages have not yet been created" << endl;
1073       c1out << "or been moved out of Incoming." << endl;
1074       if (Packages == 1)
1075       {
1076          c1out << endl;
1077          c1out << "Since you only requested a single operation it is extremely likely that" << endl;
1078          c1out << "the package is simply not installable and a bug report against" << endl;
1079          c1out << "that package should be filed." << endl;
1080       }
1081
1082       c1out << "The following information may help to resolve the situation:" << endl;
1083       c1out << endl;
1084       ShowBroken(c1out,Cache,false);
1085       return _error->Error("Sorry, broken packages");
1086    }
1087
1088    /* Print out a list of packages that are going to be installed extra
1089       to what the user asked */
1090    if (Cache->InstCount() != ExpectedInst)
1091    {
1092       string List;
1093       for (unsigned J = 0; J < Cache->Head().PackageCount; J++)
1094       {
1095          pkgCache::PkgIterator I(Cache,Cache.List[J]);
1096          if ((*Cache)[I].Install() == false)
1097             continue;
1098
1099          const char **J;
1100          for (J = CmdL.FileList + 1; *J != 0; J++)
1101             if (strcmp(*J,I.Name()) == 0)
1102                 break;
1103
1104          if (*J == 0)
1105             List += string(I.Name()) + " ";
1106       }
1107
1108       ShowList(c1out,"The following extra packages will be installed:",List);
1109    }
1110
1111    // See if we need to prompt
1112    if (Cache->InstCount() == ExpectedInst && Cache->DelCount() == 0)
1113       return InstallPackages(Cache,false,false);
1114
1115    return InstallPackages(Cache,false);
1116 }
1117                                                                         /*}}}*/
1118 // DoDistUpgrade - Automatic smart upgrader                             /*{{{*/
1119 // ---------------------------------------------------------------------
1120 /* Intelligent upgrader that will install and remove packages at will */
1121 bool DoDistUpgrade(CommandLine &CmdL)
1122 {
1123    CacheFile Cache;
1124    if (Cache.Open() == false || Cache.CheckDeps() == false)
1125       return false;
1126
1127    c0out << "Calculating Upgrade... " << flush;
1128    if (pkgDistUpgrade(*Cache) == false)
1129    {
1130       c0out << "Failed" << endl;
1131       ShowBroken(c1out,Cache,false);
1132       return false;
1133    }
1134
1135    c0out << "Done" << endl;
1136
1137    return InstallPackages(Cache,true);
1138 }
1139                                                                         /*}}}*/
1140 // DoDSelectUpgrade - Do an upgrade by following dselects selections    /*{{{*/
1141 // ---------------------------------------------------------------------
1142 /* Follows dselect's selections */
1143 bool DoDSelectUpgrade(CommandLine &CmdL)
1144 {
1145    CacheFile Cache;
1146    if (Cache.Open() == false || Cache.CheckDeps() == false)
1147       return false;
1148
1149    // Install everything with the install flag set
1150    pkgCache::PkgIterator I = Cache->PkgBegin();
1151    for (;I.end() != true; I++)
1152    {
1153       /* Install the package only if it is a new install, the autoupgrader
1154          will deal with the rest */
1155       if (I->SelectedState == pkgCache::State::Install)
1156          Cache->MarkInstall(I,false);
1157    }
1158
1159    /* Now install their deps too, if we do this above then order of
1160       the status file is significant for | groups */
1161    for (I = Cache->PkgBegin();I.end() != true; I++)
1162    {
1163       /* Install the package only if it is a new install, the autoupgrader
1164          will deal with the rest */
1165       if (I->SelectedState == pkgCache::State::Install)
1166          Cache->MarkInstall(I,true);
1167    }
1168
1169    // Apply erasures now, they override everything else.
1170    for (I = Cache->PkgBegin();I.end() != true; I++)
1171    {
1172       // Remove packages
1173       if (I->SelectedState == pkgCache::State::DeInstall ||
1174           I->SelectedState == pkgCache::State::Purge)
1175          Cache->MarkDelete(I,I->SelectedState == pkgCache::State::Purge);
1176    }
1177
1178    /* Resolve any problems that dselect created, allupgrade cannot handle
1179       such things. We do so quite agressively too.. */
1180    if (Cache->BrokenCount() != 0)
1181    {
1182       pkgProblemResolver Fix(Cache);
1183
1184       // Hold back held packages.
1185       if (_config->FindB("APT::Ingore-Hold",false) == false)
1186       {
1187          for (pkgCache::PkgIterator I = Cache->PkgBegin(); I.end() == false; I++)
1188          {
1189             if (I->SelectedState == pkgCache::State::Hold)
1190             {
1191                Fix.Protect(I);
1192                Cache->MarkKeep(I);
1193             }
1194          }
1195       }
1196
1197       if (Fix.Resolve() == false)
1198       {
1199          ShowBroken(c1out,Cache,false);
1200          return _error->Error("Internal Error, problem resolver broke stuff");
1201       }
1202    }
1203
1204    // Now upgrade everything
1205    if (pkgAllUpgrade(Cache) == false)
1206    {
1207       ShowBroken(c1out,Cache,false);
1208       return _error->Error("Internal Error, problem resolver broke stuff");
1209    }
1210
1211    return InstallPackages(Cache,false);
1212 }
1213                                                                         /*}}}*/
1214 // DoClean - Remove download archives                                   /*{{{*/
1215 // ---------------------------------------------------------------------
1216 /* */
1217 bool DoClean(CommandLine &CmdL)
1218 {
1219    pkgAcquire Fetcher;
1220    Fetcher.Clean(_config->FindDir("Dir::Cache::archives"));
1221    Fetcher.Clean(_config->FindDir("Dir::Cache::archives") + "partial/");
1222    return true;
1223 }
1224                                                                         /*}}}*/
1225 // DoAutoClean - Smartly remove downloaded archives                     /*{{{*/
1226 // ---------------------------------------------------------------------
1227 /* This is similar to clean but it only purges things that cannot be
1228    downloaded, that is old versions of cached packages. */
1229 class LogCleaner : public pkgArchiveCleaner
1230 {
1231    protected:
1232    virtual void Erase(const char *File,string Pkg,string Ver,struct stat &St)
1233    {
1234       cout << "Del " << Pkg << " " << Ver << " [" << SizeToStr(St.st_size) << "B]" << endl;
1235
1236       if (_config->FindB("APT::Get::Simulate") == false)
1237          unlink(File);
1238    };
1239 };
1240
1241 bool DoAutoClean(CommandLine &CmdL)
1242 {
1243    CacheFile Cache;
1244    if (Cache.Open() == false)
1245       return false;
1246
1247    LogCleaner Cleaner;
1248
1249    return Cleaner.Go(_config->FindDir("Dir::Cache::archives"),*Cache) &&
1250       Cleaner.Go(_config->FindDir("Dir::Cache::archives") + "partial/",*Cache);
1251 }
1252                                                                         /*}}}*/
1253 // DoCheck - Perform the check operation                                /*{{{*/
1254 // ---------------------------------------------------------------------
1255 /* Opening automatically checks the system, this command is mostly used
1256    for debugging */
1257 bool DoCheck(CommandLine &CmdL)
1258 {
1259    CacheFile Cache;
1260    Cache.Open();
1261    Cache.CheckDeps();
1262
1263    return true;
1264 }
1265                                                                         /*}}}*/
1266 // DoSource - Fetch a source archive                                    /*{{{*/
1267 // ---------------------------------------------------------------------
1268 /* Fetch souce packages */
1269 struct DscFile
1270 {
1271    string Package;
1272    string Version;
1273    string Dsc;
1274 };
1275
1276 bool DoSource(CommandLine &CmdL)
1277 {
1278    CacheFile Cache;
1279    if (Cache.Open(false) == false)
1280       return false;
1281
1282    if (CmdL.FileSize() <= 1)
1283       return _error->Error("Must specify at least one package to fetch source for");
1284
1285    // Read the source list
1286    pkgSourceList List;
1287    if (List.ReadMainList() == false)
1288       return _error->Error("The list of sources could not be read.");
1289
1290    // Create the text record parsers
1291    pkgRecords Recs(Cache);
1292    pkgSrcRecords SrcRecs(List);
1293    if (_error->PendingError() == true)
1294       return false;
1295
1296    // Create the download object
1297    AcqTextStatus Stat(ScreenWidth,_config->FindI("quiet",0));
1298    pkgAcquire Fetcher(&Stat);
1299
1300    DscFile *Dsc = new DscFile[CmdL.FileSize()];
1301
1302    // Load the requestd sources into the fetcher
1303    unsigned J = 0;
1304    for (const char **I = CmdL.FileList + 1; *I != 0; I++, J++)
1305    {
1306       string Src;
1307
1308       /* Lookup the version of the package we would install if we were to
1309          install a version and determine the source package name, then look
1310          in the archive for a source package of the same name. In theory
1311          we could stash the version string as well and match that too but
1312          today there aren't multi source versions in the archive. */
1313       pkgCache::PkgIterator Pkg = Cache->FindPkg(*I);
1314       if (Pkg.end() == false)
1315       {
1316          pkgCache::VerIterator Ver = Cache->GetCandidateVer(Pkg);
1317          if (Ver.end() == false)
1318          {
1319             pkgRecords::Parser &Parse = Recs.Lookup(Ver.FileList());
1320             Src = Parse.SourcePkg();
1321          }
1322       }
1323
1324       // No source package name..
1325       if (Src.empty() == true)
1326          Src = *I;
1327
1328       // The best hit
1329       pkgSrcRecords::Parser *Last = 0;
1330       unsigned long Offset = 0;
1331       string Version;
1332       bool IsMatch = false;
1333
1334       // Iterate over all of the hits
1335       pkgSrcRecords::Parser *Parse;
1336       SrcRecs.Restart();
1337       while ((Parse = SrcRecs.Find(Src.c_str(),false)) != 0)
1338       {
1339          string Ver = Parse->Version();
1340
1341          // Skip name mismatches
1342          if (IsMatch == true && Parse->Package() != Src)
1343             continue;
1344
1345          // Newer version or an exact match
1346          if (Last == 0 || pkgVersionCompare(Version,Ver) < 0 ||
1347              (Parse->Package() == Src && IsMatch == false))
1348          {
1349             IsMatch = Parse->Package() == Src;
1350             Last = Parse;
1351             Offset = Parse->Offset();
1352             Version = Ver;
1353          }
1354       }
1355
1356       if (Last == 0)
1357          return _error->Error("Unable to find a source package for %s",Src.c_str());
1358
1359       // Back track
1360       vector<pkgSrcRecords::File> Lst;
1361       if (Last->Jump(Offset) == false || Last->Files(Lst) == false)
1362          return false;
1363
1364       // Load them into the fetcher
1365       for (vector<pkgSrcRecords::File>::const_iterator I = Lst.begin();
1366            I != Lst.end(); I++)
1367       {
1368          // Try to guess what sort of file it is we are getting.
1369          string Comp;
1370          if (I->Path.find(".dsc") != string::npos)
1371          {
1372             Comp = "dsc";
1373             Dsc[J].Package = Last->Package();
1374             Dsc[J].Version = Last->Version();
1375             Dsc[J].Dsc = flNotDir(I->Path);
1376          }
1377
1378          if (I->Path.find(".tar.gz") != string::npos)
1379             Comp = "tar";
1380          if (I->Path.find(".diff.gz") != string::npos)
1381             Comp = "diff";
1382
1383          // Diff only mode only fetches .diff files
1384          if (_config->FindB("APT::Get::Diff-Only",false) == true &&
1385              Comp != "diff")
1386             continue;
1387
1388          // Tar only mode only fetches .tar files
1389          if (_config->FindB("APT::Get::Tar-Only",false) == true &&
1390              Comp != "tar")
1391             continue;
1392
1393          new pkgAcqFile(&Fetcher,Last->Source()->ArchiveURI(I->Path),
1394                         I->MD5Hash,I->Size,Last->Source()->SourceInfo(Src,
1395                         Last->Version(),Comp),Src);
1396       }
1397    }
1398
1399    // Display statistics
1400    unsigned long FetchBytes = Fetcher.FetchNeeded();
1401    unsigned long FetchPBytes = Fetcher.PartialPresent();
1402    unsigned long DebBytes = Fetcher.TotalNeeded();
1403
1404    // Check for enough free space
1405    struct statfs Buf;
1406    string OutputDir = ".";
1407    if (statfs(OutputDir.c_str(),&Buf) != 0)
1408       return _error->Errno("statfs","Couldn't determine free space in %s",
1409                            OutputDir.c_str());
1410    if (unsigned(Buf.f_bfree) < (FetchBytes - FetchPBytes)/Buf.f_bsize)
1411       return _error->Error("Sorry, you don't have enough free space in %s",
1412                            OutputDir.c_str());
1413
1414    // Number of bytes
1415    c1out << "Need to get ";
1416    if (DebBytes != FetchBytes)
1417       c1out << SizeToStr(FetchBytes) << "B/" << SizeToStr(DebBytes) << 'B';
1418    else
1419       c1out << SizeToStr(DebBytes) << 'B';
1420    c1out << " of source archives." << endl;
1421
1422    if (_config->FindB("APT::Get::Simulate",false) == true)
1423    {
1424       for (unsigned I = 0; I != J; I++)
1425          cout << "Fetch Source " << Dsc[I].Package << endl;
1426       return true;
1427    }
1428
1429    // Just print out the uris an exit if the --print-uris flag was used
1430    if (_config->FindB("APT::Get::Print-URIs") == true)
1431    {
1432       pkgAcquire::UriIterator I = Fetcher.UriBegin();
1433       for (; I != Fetcher.UriEnd(); I++)
1434          cout << '\'' << I->URI << "' " << flNotDir(I->Owner->DestFile) << ' ' <<
1435                I->Owner->FileSize << ' ' << I->Owner->MD5Sum() << endl;
1436       return true;
1437    }
1438
1439    // Run it
1440    if (Fetcher.Run() == pkgAcquire::Failed)
1441       return false;
1442
1443    // Print error messages
1444    bool Failed = false;
1445    for (pkgAcquire::Item **I = Fetcher.ItemsBegin(); I != Fetcher.ItemsEnd(); I++)
1446    {
1447       if ((*I)->Status == pkgAcquire::Item::StatDone &&
1448           (*I)->Complete == true)
1449          continue;
1450
1451       cerr << "Failed to fetch " << (*I)->DescURI() << endl;
1452       cerr << "  " << (*I)->ErrorText << endl;
1453       Failed = true;
1454    }
1455    if (Failed == true)
1456       return _error->Error("Failed to fetch some archives.");
1457
1458    if (_config->FindB("APT::Get::Download-only",false) == true)
1459       return true;
1460
1461    // Unpack the sources
1462    pid_t Process = ExecFork();
1463
1464    if (Process == 0)
1465    {
1466       for (unsigned I = 0; I != J; I++)
1467       {
1468          string Dir = Dsc[I].Package + '-' + pkgBaseVersion(Dsc[I].Version.c_str());
1469
1470          // Diff only mode only fetches .diff files
1471          if (_config->FindB("APT::Get::Diff-Only",false) == true ||
1472              _config->FindB("APT::Get::Tar-Only",false) == true)
1473             continue;
1474
1475          // See if the package is already unpacked
1476          struct stat Stat;
1477          if (stat(Dir.c_str(),&Stat) == 0 &&
1478              S_ISDIR(Stat.st_mode) != 0)
1479          {
1480             c0out << "Skipping unpack of already unpacked source in " << Dir << endl;
1481          }
1482          else
1483          {
1484             // Call dpkg-source
1485             char S[500];
1486             snprintf(S,sizeof(S),"%s -x %s",
1487                      _config->Find("Dir::Bin::dpkg-source","dpkg-source").c_str(),
1488                      Dsc[I].Dsc.c_str());
1489             if (system(S) != 0)
1490             {
1491                cerr << "Unpack command '" << S << "' failed." << endl;
1492                _exit(1);
1493             }
1494          }
1495
1496          // Try to compile it with dpkg-buildpackage
1497          if (_config->FindB("APT::Get::Compile",false) == true)
1498          {
1499             // Call dpkg-buildpackage
1500             char S[500];
1501             snprintf(S,sizeof(S),"cd %s && %s %s",
1502                      Dir.c_str(),
1503                      _config->Find("Dir::Bin::dpkg-buildpackage","dpkg-buildpackage").c_str(),
1504                      _config->Find("DPkg::Build-Options","-b -uc").c_str());
1505
1506             if (system(S) != 0)
1507             {
1508                cerr << "Build command '" << S << "' failed." << endl;
1509                _exit(1);
1510             }
1511          }
1512       }
1513
1514       _exit(0);
1515    }
1516
1517    // Wait for the subprocess
1518    int Status = 0;
1519    while (waitpid(Process,&Status,0) != Process)
1520    {
1521       if (errno == EINTR)
1522          continue;
1523       return _error->Errno("waitpid","Couldn't wait for subprocess");
1524    }
1525
1526    if (WIFEXITED(Status) == 0 || WEXITSTATUS(Status) != 0)
1527       return _error->Error("Child process failed");
1528
1529    return true;
1530 }
1531                                                                         /*}}}*/
1532
1533 // ShowHelp - Show a help screen                                        /*{{{*/
1534 // ---------------------------------------------------------------------
1535 /* */
1536 bool ShowHelp(CommandLine &CmdL)
1537 {
1538    cout << PACKAGE << ' ' << VERSION << " for " << ARCHITECTURE <<
1539        " compiled on " << __DATE__ << "  " << __TIME__ << endl;
1540    if (_config->FindB("version") == true)
1541       return 100;
1542
1543    cout << "Usage: apt-get [options] command" << endl;
1544    cout << "       apt-get [options] install pkg1 [pkg2 ...]" << endl;
1545    cout << endl;
1546    cout << "apt-get is a simple command line interface for downloading and" << endl;
1547    cout << "installing packages. The most frequently used commands are update" << endl;
1548    cout << "and install." << endl;
1549    cout << endl;
1550    cout << "Commands:" << endl;
1551    cout << "   update - Retrieve new lists of packages" << endl;
1552    cout << "   upgrade - Perform an upgrade" << endl;
1553    cout << "   install - Install new packages (pkg is libc6 not libc6.deb)" << endl;
1554    cout << "   remove - Remove packages" << endl;
1555    cout << "   source - Download source archives" << endl;
1556    cout << "   dist-upgrade - Distribution upgrade, see apt-get(8)" << endl;
1557    cout << "   dselect-upgrade - Follow dselect selections" << endl;
1558    cout << "   clean - Erase downloaded archive files" << endl;
1559    cout << "   autoclean - Erase old downloaded archive files" << endl;
1560    cout << "   check - Verify that there are no broken dependencies" << endl;
1561    cout << endl;
1562    cout << "Options:" << endl;
1563    cout << "  -h  This help text." << endl;
1564    cout << "  -q  Loggable output - no progress indicator" << endl;
1565    cout << "  -qq No output except for errors" << endl;
1566    cout << "  -d  Download only - do NOT install or unpack archives" << endl;
1567    cout << "  -s  No-act. Perform ordering simulation" << endl;
1568    cout << "  -y  Assume Yes to all queries and do not prompt" << endl;
1569    cout << "  -f  Attempt to continue if the integrity check fails" << endl;
1570    cout << "  -m  Attempt to continue if archives are unlocatable" << endl;
1571    cout << "  -u  Show a list of upgraded packages as well" << endl;
1572    cout << "  -b  Build the source package after fetching it" << endl;
1573    cout << "  -c=? Read this configuration file" << endl;
1574    cout << "  -o=? Set an arbitary configuration option, eg -o dir::cache=/tmp" << endl;
1575    cout << "See the apt-get(8), sources.list(5) and apt.conf(5) manual" << endl;
1576    cout << "pages for more information and options." << endl;
1577    return 100;
1578 }
1579                                                                         /*}}}*/
1580 // GetInitialize - Initialize things for apt-get                        /*{{{*/
1581 // ---------------------------------------------------------------------
1582 /* */
1583 void GetInitialize()
1584 {
1585    _config->Set("quiet",0);
1586    _config->Set("help",false);
1587    _config->Set("APT::Get::Download-Only",false);
1588    _config->Set("APT::Get::Simulate",false);
1589    _config->Set("APT::Get::Assume-Yes",false);
1590    _config->Set("APT::Get::Fix-Broken",false);
1591    _config->Set("APT::Get::Force-Yes",false);
1592    _config->Set("APT::Get::APT::Get::No-List-Cleanup",true);
1593 }
1594                                                                         /*}}}*/
1595 // SigWinch - Window size change signal handler                         /*{{{*/
1596 // ---------------------------------------------------------------------
1597 /* */
1598 void SigWinch(int)
1599 {
1600    // Riped from GNU ls
1601 #ifdef TIOCGWINSZ
1602    struct winsize ws;
1603
1604    if (ioctl(1, TIOCGWINSZ, &ws) != -1 && ws.ws_col >= 5)
1605       ScreenWidth = ws.ws_col - 1;
1606 #endif
1607 }
1608                                                                         /*}}}*/
1609
1610 int main(int argc,const char *argv[])
1611 {
1612    CommandLine::Args Args[] = {
1613       {'h',"help","help",0},
1614       {'v',"version","version",0},
1615       {'q',"quiet","quiet",CommandLine::IntLevel},
1616       {'q',"silent","quiet",CommandLine::IntLevel},
1617       {'d',"download-only","APT::Get::Download-Only",0},
1618       {'b',"compile","APT::Get::Compile",0},
1619       {'b',"build","APT::Get::Compile",0},
1620       {'s',"simulate","APT::Get::Simulate",0},
1621       {'s',"just-print","APT::Get::Simulate",0},
1622       {'s',"recon","APT::Get::Simulate",0},
1623       {'s',"no-act","APT::Get::Simulate",0},
1624       {'y',"yes","APT::Get::Assume-Yes",0},
1625       {'y',"assume-yes","APT::Get::Assume-Yes",0},
1626       {'f',"fix-broken","APT::Get::Fix-Broken",0},
1627       {'u',"show-upgraded","APT::Get::Show-Upgraded",0},
1628       {'m',"ignore-missing","APT::Get::Fix-Missing",0},
1629       {0,"no-download","APT::Get::No-Download",0},
1630       {0,"fix-missing","APT::Get::Fix-Missing",0},
1631       {0,"ignore-hold","APT::Ingore-Hold",0},
1632       {0,"no-upgrade","APT::Get::no-upgrade",0},
1633       {0,"force-yes","APT::Get::force-yes",0},
1634       {0,"print-uris","APT::Get::Print-URIs",0},
1635       {0,"diff-only","APT::Get::Diff-Only",0},
1636       {0,"tar-only","APT::Get::tar-Only",0},
1637       {0,"purge","APT::Get::Purge",0},
1638       {0,"list-cleanup","APT::Get::List-Cleanup",0},
1639       {0,"reinstall","APT::Get::ReInstall",0},
1640       {'c',"config-file",0,CommandLine::ConfigFile},
1641       {'o',"option",0,CommandLine::ArbItem},
1642       {0,0,0,0}};
1643    CommandLine::Dispatch Cmds[] = {{"update",&DoUpdate},
1644                                    {"upgrade",&DoUpgrade},
1645                                    {"install",&DoInstall},
1646                                    {"remove",&DoInstall},
1647                                    {"dist-upgrade",&DoDistUpgrade},
1648                                    {"dselect-upgrade",&DoDSelectUpgrade},
1649                                    {"clean",&DoClean},
1650                                    {"autoclean",&DoAutoClean},
1651                                    {"check",&DoCheck},
1652                                    {"source",&DoSource},
1653                                    {"help",&ShowHelp},
1654                                    {0,0}};
1655
1656    // Parse the command line and initialize the package library
1657    CommandLine CmdL(Args,_config);
1658    if (pkgInitialize(*_config) == false ||
1659        CmdL.Parse(argc,argv) == false)
1660    {
1661       _error->DumpErrors();
1662       return 100;
1663    }
1664
1665    // See if the help should be shown
1666    if (_config->FindB("help") == true ||
1667        _config->FindB("version") == true ||
1668        CmdL.FileSize() == 0)
1669       return ShowHelp(CmdL);
1670
1671    // Deal with stdout not being a tty
1672    if (ttyname(STDOUT_FILENO) == 0 && _config->FindI("quiet",0) < 1)
1673       _config->Set("quiet","1");
1674
1675    // Setup the output streams
1676    c0out.rdbuf(cout.rdbuf());
1677    c1out.rdbuf(cout.rdbuf());
1678    c2out.rdbuf(cout.rdbuf());
1679    if (_config->FindI("quiet",0) > 0)
1680       c0out.rdbuf(devnull.rdbuf());
1681    if (_config->FindI("quiet",0) > 1)
1682       c1out.rdbuf(devnull.rdbuf());
1683
1684    // Setup the signals
1685    signal(SIGPIPE,SIG_IGN);
1686    signal(SIGWINCH,SigWinch);
1687    SigWinch(0);
1688
1689    // Match the operation
1690    CmdL.DispatchArg(Cmds);
1691
1692    // Print any errors or warnings found during parsing
1693    if (_error->empty() == false)
1694    {
1695       bool Errors = _error->PendingError();
1696       _error->DumpErrors();
1697       return Errors == true?100:0;
1698    }
1699
1700    return 0;
1701 }