cmdline/apt-cache.cc

   1 // -*- mode: cpp; mode: fold -*-
   2 // Description                                                          /*{{{*/
   3 // $Id: apt-cache.cc,v 1.72 2004/04/30 04:34:03 mdz Exp $
   4 /* ######################################################################
   5
   6    apt-cache - Manages the cache files
   7
   8    apt-cache provides some functions fo manipulating the cache files.
   9    It uses the command line interface common to all the APT tools.
  10
  11    Returns 100 on failure, 0 on success.
  12
  13    ##################################################################### */
  14                                                                         /*}}}*/
  15 // Include Files                                                        /*{{{*/
  16 #include<config.h>
  17
  18 #include <apt-pkg/error.h>
  19 #include <apt-pkg/cachefile.h>
  20 #include <apt-pkg/cacheset.h>
  21 #include <apt-pkg/init.h>
  22 #include <apt-pkg/progress.h>
  23 #include <apt-pkg/sourcelist.h>
  24 #include <apt-pkg/cmndline.h>
  25 #include <apt-pkg/strutl.h>
  26 #include <apt-pkg/fileutl.h>
  27 #include <apt-pkg/pkgrecords.h>
  28 #include <apt-pkg/srcrecords.h>
  29 #include <apt-pkg/version.h>
  30 #include <apt-pkg/policy.h>
  31 #include <apt-pkg/tagfile.h>
  32 #include <apt-pkg/algorithms.h>
  33 #include <apt-pkg/sptr.h>
  34 #include <apt-pkg/pkgsystem.h>
  35 #include <apt-pkg/indexfile.h>
  36 #include <apt-pkg/metaindex.h>
  37
  38 #include <cassert>
  39 #include <locale.h>
  40 #include <iostream>
  41 #include <unistd.h>
  42 #include <errno.h>
  43 #include <regex.h>
  44 #include <stdio.h>
  45 #include <iomanip>
  46 #include <algorithm>
  47
  48 #include <apti18n.h>
  49                                                                         /*}}}*/
  50
  51 using namespace std;
  52
  53 // CacheSetHelper saving virtual packages                               /*{{{*/
  54 class CacheSetHelperVirtuals: public APT::CacheSetHelper {
  55 public:
  56    APT::PackageSet virtualPkgs;
  57
  58    virtual pkgCache::VerIterator canNotFindCandidateVer(pkgCacheFile &Cache, pkgCache::PkgIterator const &Pkg) {
  59       virtualPkgs.insert(Pkg);
  60       return CacheSetHelper::canNotFindCandidateVer(Cache, Pkg);
  61    }
  62
  63    virtual pkgCache::VerIterator canNotFindNewestVer(pkgCacheFile &Cache, pkgCache::PkgIterator const &Pkg) {
  64       virtualPkgs.insert(Pkg);
  65       return CacheSetHelper::canNotFindNewestVer(Cache, Pkg);
  66    }
  67
  68    virtual void canNotFindAllVer(APT::VersionContainerInterface * vci, pkgCacheFile &Cache, pkgCache::PkgIterator const &Pkg) {
  69       virtualPkgs.insert(Pkg);
  70       CacheSetHelper::canNotFindAllVer(vci, Cache, Pkg);
  71    }
  72
  73    CacheSetHelperVirtuals(bool const ShowErrors = true, GlobalError::MsgType const &ErrorType = GlobalError::NOTICE) : CacheSetHelper(ShowErrors, ErrorType) {}
  74 };
  75                                                                         /*}}}*/
  76 // LocalitySort - Sort a version list by package file locality          /*{{{*/
  77 // ---------------------------------------------------------------------
  78 /* */
  79 int LocalityCompare(const void *a, const void *b)
  80 {
  81    pkgCache::VerFile *A = *(pkgCache::VerFile **)a;
  82    pkgCache::VerFile *B = *(pkgCache::VerFile **)b;
  83
  84    if (A == 0 && B == 0)
  85       return 0;
  86    if (A == 0)
  87       return 1;
  88    if (B == 0)
  89       return -1;
  90
  91    if (A->File == B->File)
  92       return A->Offset - B->Offset;
  93    return A->File - B->File;
  94 }
  95
  96 void LocalitySort(pkgCache::VerFile **begin,
  97                   unsigned long Count,size_t Size)
  98 {
  99    qsort(begin,Count,Size,LocalityCompare);
 100 }
 101
 102 void LocalitySort(pkgCache::DescFile **begin,
 103                   unsigned long Count,size_t Size)
 104 {
 105    qsort(begin,Count,Size,LocalityCompare);
 106 }
 107                                                                         /*}}}*/
 108 // UnMet - Show unmet dependencies                                      /*{{{*/
 109 // ---------------------------------------------------------------------
 110 /* */
 111 bool ShowUnMet(pkgCache::VerIterator const &V, bool const Important)
 112 {
 113          bool Header = false;
 114          for (pkgCache::DepIterator D = V.DependsList(); D.end() == false;)
 115          {
 116             // Collect or groups
 117             pkgCache::DepIterator Start;
 118             pkgCache::DepIterator End;
 119             D.GlobOr(Start,End);
 120
 121             // Important deps only
 122             if (Important == true)
 123                if (End->Type != pkgCache::Dep::PreDepends &&
 124                    End->Type != pkgCache::Dep::Depends)
 125                   continue;
 126
 127             // Skip conflicts and replaces
 128             if (End.IsNegative() == true)
 129                continue;
 130
 131             // Verify the or group
 132             bool OK = false;
 133             pkgCache::DepIterator RealStart = Start;
 134             do
 135             {
 136                // See if this dep is Ok
 137                pkgCache::Version **VList = Start.AllTargets();
 138                if (*VList != 0)
 139                {
 140                   OK = true;
 141                   delete [] VList;
 142                   break;
 143                }
 144                delete [] VList;
 145
 146                if (Start == End)
 147                   break;
 148                ++Start;
 149             }
 150             while (1);
 151
 152             // The group is OK
 153             if (OK == true)
 154                continue;
 155
 156             // Oops, it failed..
 157             if (Header == false)
 158                ioprintf(cout,_("Package %s version %s has an unmet dep:\n"),
 159                         V.ParentPkg().FullName(true).c_str(),V.VerStr());
 160             Header = true;
 161
 162             // Print out the dep type
 163             cout << " " << End.DepType() << ": ";
 164
 165             // Show the group
 166             Start = RealStart;
 167             do
 168             {
 169                cout << Start.TargetPkg().FullName(true);
 170                if (Start.TargetVer() != 0)
 171                   cout << " (" << Start.CompType() << " " << Start.TargetVer() <<
 172                   ")";
 173                if (Start == End)
 174                   break;
 175                cout << " | ";
 176                ++Start;
 177             }
 178             while (1);
 179
 180             cout << endl;
 181          }
 182    return true;
 183 }
 184 bool UnMet(CommandLine &CmdL)
 185 {
 186    bool const Important = _config->FindB("APT::Cache::Important",false);
 187
 188    pkgCacheFile CacheFile;
 189    if (unlikely(CacheFile.GetPkgCache() == NULL))
 190       return false;
 191
 192    if (CmdL.FileSize() <= 1)
 193    {
 194       for (pkgCache::PkgIterator P = CacheFile.GetPkgCache()->PkgBegin(); P.end() == false; ++P)
 195          for (pkgCache::VerIterator V = P.VersionList(); V.end() == false; ++V)
 196             if (ShowUnMet(V, Important) == false)
 197                return false;
 198    }
 199    else
 200    {
 201       CacheSetHelperVirtuals helper(true, GlobalError::NOTICE);
 202       APT::VersionList verset = APT::VersionList::FromCommandLine(CacheFile, CmdL.FileList + 1,
 203                                 APT::VersionList::CANDIDATE, helper);
 204       for (APT::VersionList::iterator V = verset.begin(); V != verset.end(); ++V)
 205          if (ShowUnMet(V, Important) == false)
 206             return false;
 207    }
 208    return true;
 209 }
 210                                                                         /*}}}*/
 211 // DumpPackage - Show a dump of a package record                        /*{{{*/
 212 // ---------------------------------------------------------------------
 213 /* */
 214 bool DumpPackage(CommandLine &CmdL)
 215 {
 216    pkgCacheFile CacheFile;
 217    APT::CacheSetHelper helper(true, GlobalError::NOTICE);
 218    APT::PackageList pkgset = APT::PackageList::FromCommandLine(CacheFile, CmdL.FileList + 1, helper);
 219
 220    for (APT::PackageList::const_iterator Pkg = pkgset.begin(); Pkg != pkgset.end(); ++Pkg)
 221    {
 222       cout << "Package: " << Pkg.FullName(true) << endl;
 223       cout << "Versions: " << endl;
 224       for (pkgCache::VerIterator Cur = Pkg.VersionList(); Cur.end() != true; ++Cur)
 225       {
 226          cout << Cur.VerStr();
 227          for (pkgCache::VerFileIterator Vf = Cur.FileList(); Vf.end() == false; ++Vf)
 228             cout << " (" << Vf.File().FileName() << ")";
 229          cout << endl;
 230          for (pkgCache::DescIterator D = Cur.DescriptionList(); D.end() == false; ++D)
 231          {
 232             cout << " Description Language: " << D.LanguageCode() << endl
 233                  << "                 File: " << D.FileList().File().FileName() << endl
 234                  << "                  MD5: " << D.md5() << endl;
 235          }
 236          cout << endl;
 237       }
 238
 239       cout << endl;
 240
 241       cout << "Reverse Depends: " << endl;
 242       for (pkgCache::DepIterator D = Pkg.RevDependsList(); D.end() != true; ++D)
 243       {
 244          cout << "  " << D.ParentPkg().FullName(true) << ',' << D.TargetPkg().FullName(true);
 245          if (D->Version != 0)
 246             cout << ' ' << DeNull(D.TargetVer()) << endl;
 247          else
 248             cout << endl;
 249       }
 250
 251       cout << "Dependencies: " << endl;
 252       for (pkgCache::VerIterator Cur = Pkg.VersionList(); Cur.end() != true; ++Cur)
 253       {
 254          cout << Cur.VerStr() << " - ";
 255          for (pkgCache::DepIterator Dep = Cur.DependsList(); Dep.end() != true; ++Dep)
 256             cout << Dep.TargetPkg().FullName(true) << " (" << (int)Dep->CompareOp << " " << DeNull(Dep.TargetVer()) << ") ";
 257          cout << endl;
 258       }
 259
 260       cout << "Provides: " << endl;
 261       for (pkgCache::VerIterator Cur = Pkg.VersionList(); Cur.end() != true; ++Cur)
 262       {
 263          cout << Cur.VerStr() << " - ";
 264          for (pkgCache::PrvIterator Prv = Cur.ProvidesList(); Prv.end() != true; ++Prv)
 265             cout << Prv.ParentPkg().FullName(true) << " ";
 266          cout << endl;
 267       }
 268       cout << "Reverse Provides: " << endl;
 269       for (pkgCache::PrvIterator Prv = Pkg.ProvidesList(); Prv.end() != true; ++Prv)
 270          cout << Prv.OwnerPkg().FullName(true) << " " << Prv.OwnerVer().VerStr() << endl;
 271    }
 272
 273    return true;
 274 }
 275                                                                         /*}}}*/
 276 // Stats - Dump some nice statistics                                    /*{{{*/
 277 // ---------------------------------------------------------------------
 278 /* */
 279 bool Stats(CommandLine &Cmd)
 280 {
 281    pkgCacheFile CacheFile;
 282    pkgCache *Cache = CacheFile.GetPkgCache();
 283    if (unlikely(Cache == NULL))
 284       return false;
 285
 286    cout << _("Total package names: ") << Cache->Head().GroupCount << " (" <<
 287       SizeToStr(Cache->Head().GroupCount*Cache->Head().GroupSz) << ')' << endl
 288         << _("Total package structures: ") << Cache->Head().PackageCount << " (" <<
 289       SizeToStr(Cache->Head().PackageCount*Cache->Head().PackageSz) << ')' << endl;
 290
 291    int Normal = 0;
 292    int Virtual = 0;
 293    int NVirt = 0;
 294    int DVirt = 0;
 295    int Missing = 0;
 296    pkgCache::PkgIterator I = Cache->PkgBegin();
 297    for (;I.end() != true; ++I)
 298    {
 299       if (I->VersionList != 0 && I->ProvidesList == 0)
 300       {
 301          Normal++;
 302          continue;
 303       }
 304
 305       if (I->VersionList != 0 && I->ProvidesList != 0)
 306       {
 307          NVirt++;
 308          continue;
 309       }
 310
 311       if (I->VersionList == 0 && I->ProvidesList != 0)
 312       {
 313          // Only 1 provides
 314          if (I.ProvidesList()->NextProvides == 0)
 315          {
 316             DVirt++;
 317          }
 318          else
 319             Virtual++;
 320          continue;
 321       }
 322       if (I->VersionList == 0 && I->ProvidesList == 0)
 323       {
 324          Missing++;
 325          continue;
 326       }
 327    }
 328    cout << _("  Normal packages: ") << Normal << endl;
 329    cout << _("  Pure virtual packages: ") << Virtual << endl;
 330    cout << _("  Single virtual packages: ") << DVirt << endl;
 331    cout << _("  Mixed virtual packages: ") << NVirt << endl;
 332    cout << _("  Missing: ") << Missing << endl;
 333
 334    cout << _("Total distinct versions: ") << Cache->Head().VersionCount << " (" <<
 335       SizeToStr(Cache->Head().VersionCount*Cache->Head().VersionSz) << ')' << endl;
 336    cout << _("Total distinct descriptions: ") << Cache->Head().DescriptionCount << " (" <<
 337       SizeToStr(Cache->Head().DescriptionCount*Cache->Head().DescriptionSz) << ')' << endl;
 338    cout << _("Total dependencies: ") << Cache->Head().DependsCount << " (" <<
 339       SizeToStr(Cache->Head().DependsCount*Cache->Head().DependencySz) << ')' << endl;
 340
 341    cout << _("Total ver/file relations: ") << Cache->Head().VerFileCount << " (" <<
 342       SizeToStr(Cache->Head().VerFileCount*Cache->Head().VerFileSz) << ')' << endl;
 343    cout << _("Total Desc/File relations: ") << Cache->Head().DescFileCount << " (" <<
 344       SizeToStr(Cache->Head().DescFileCount*Cache->Head().DescFileSz) << ')' << endl;
 345    cout << _("Total Provides mappings: ") << Cache->Head().ProvidesCount << " (" <<
 346       SizeToStr(Cache->Head().ProvidesCount*Cache->Head().ProvidesSz) << ')' << endl;
 347
 348    // String list stats
 349    unsigned long Size = 0;
 350    unsigned long Count = 0;
 351    for (pkgCache::StringItem *I = Cache->StringItemP + Cache->Head().StringList;
 352         I!= Cache->StringItemP; I = Cache->StringItemP + I->NextItem)
 353    {
 354       Count++;
 355       Size += strlen(Cache->StrP + I->String) + 1;
 356    }
 357    cout << _("Total globbed strings: ") << Count << " (" << SizeToStr(Size) << ')' << endl;
 358
 359    unsigned long DepVerSize = 0;
 360    for (pkgCache::PkgIterator P = Cache->PkgBegin(); P.end() == false; ++P)
 361    {
 362       for (pkgCache::VerIterator V = P.VersionList(); V.end() == false; ++V)
 363       {
 364          for (pkgCache::DepIterator D = V.DependsList(); D.end() == false; ++D)
 365          {
 366             if (D->Version != 0)
 367                DepVerSize += strlen(D.TargetVer()) + 1;
 368          }
 369       }
 370    }
 371    cout << _("Total dependency version space: ") << SizeToStr(DepVerSize) << endl;
 372
 373    unsigned long Slack = 0;
 374    for (int I = 0; I != 7; I++)
 375       Slack += Cache->Head().Pools[I].ItemSize*Cache->Head().Pools[I].Count;
 376    cout << _("Total slack space: ") << SizeToStr(Slack) << endl;
 377
 378    unsigned long Total = 0;
 379    Total = Slack + Size + Cache->Head().DependsCount*Cache->Head().DependencySz +
 380            Cache->Head().VersionCount*Cache->Head().VersionSz +
 381            Cache->Head().PackageCount*Cache->Head().PackageSz +
 382            Cache->Head().VerFileCount*Cache->Head().VerFileSz +
 383            Cache->Head().ProvidesCount*Cache->Head().ProvidesSz;
 384    cout << _("Total space accounted for: ") << SizeToStr(Total) << endl;
 385
 386    return true;
 387 }
 388                                                                         /*}}}*/
 389 // Dump - show everything                                               /*{{{*/
 390 // ---------------------------------------------------------------------
 391 /* This is worthless except fer debugging things */
 392 bool Dump(CommandLine &Cmd)
 393 {
 394    pkgCacheFile CacheFile;
 395    pkgCache *Cache = CacheFile.GetPkgCache();
 396    if (unlikely(Cache == NULL))
 397       return false;
 398
 399    cout << "Using Versioning System: " << Cache->VS->Label << endl;
 400
 401    for (pkgCache::PkgIterator P = Cache->PkgBegin(); P.end() == false; ++P)
 402    {
 403       cout << "Package: " << P.FullName(true) << endl;
 404       for (pkgCache::VerIterator V = P.VersionList(); V.end() == false; ++V)
 405       {
 406          cout << " Version: " << V.VerStr() << endl;
 407          cout << "     File: " << V.FileList().File().FileName() << endl;
 408          for (pkgCache::DepIterator D = V.DependsList(); D.end() == false; ++D)
 409             cout << "  Depends: " << D.TargetPkg().FullName(true) << ' ' <<
 410                              DeNull(D.TargetVer()) << endl;
 411          for (pkgCache::DescIterator D = V.DescriptionList(); D.end() == false; ++D)
 412          {
 413             cout << " Description Language: " << D.LanguageCode() << endl
 414                  << "                 File: " << D.FileList().File().FileName() << endl
 415                  << "                  MD5: " << D.md5() << endl;
 416          }
 417       }
 418    }
 419
 420    for (pkgCache::PkgFileIterator F = Cache->FileBegin(); F.end() == false; ++F)
 421    {
 422       cout << "File: " << F.FileName() << endl;
 423       cout << " Type: " << F.IndexType() << endl;
 424       cout << " Size: " << F->Size << endl;
 425       cout << " ID: " << F->ID << endl;
 426       cout << " Flags: " << F->Flags << endl;
 427       cout << " Time: " << TimeRFC1123(F->mtime) << endl;
 428       cout << " Archive: " << DeNull(F.Archive()) << endl;
 429       cout << " Component: " << DeNull(F.Component()) << endl;
 430       cout << " Version: " << DeNull(F.Version()) << endl;
 431       cout << " Origin: " << DeNull(F.Origin()) << endl;
 432       cout << " Site: " << DeNull(F.Site()) << endl;
 433       cout << " Label: " << DeNull(F.Label()) << endl;
 434       cout << " Architecture: " << DeNull(F.Architecture()) << endl;
 435    }
 436
 437    return true;
 438 }
 439                                                                         /*}}}*/
 440 // DumpAvail - Print out the available list                             /*{{{*/
 441 // ---------------------------------------------------------------------
 442 /* This is needed to make dpkg --merge happy.. I spent a bit of time to
 443    make this run really fast, perhaps I went a little overboard.. */
 444 bool DumpAvail(CommandLine &Cmd)
 445 {
 446    pkgCacheFile CacheFile;
 447    pkgCache *Cache = CacheFile.GetPkgCache();
 448    if (unlikely(Cache == NULL || CacheFile.BuildPolicy() == false))
 449       return false;
 450
 451    unsigned long Count = Cache->HeaderP->PackageCount+1;
 452    pkgCache::VerFile **VFList = new pkgCache::VerFile *[Count];
 453    memset(VFList,0,sizeof(*VFList)*Count);
 454
 455    // Map versions that we want to write out onto the VerList array.
 456    for (pkgCache::PkgIterator P = Cache->PkgBegin(); P.end() == false; ++P)
 457    {
 458       if (P->VersionList == 0)
 459          continue;
 460
 461       /* Find the proper version to use. If the policy says there are no
 462          possible selections we return the installed version, if available..
 463          This prevents dselect from making it obsolete. */
 464       pkgCache::VerIterator V = CacheFile.GetPolicy()->GetCandidateVer(P);
 465       if (V.end() == true)
 466       {
 467          if (P->CurrentVer == 0)
 468             continue;
 469          V = P.CurrentVer();
 470       }
 471
 472       pkgCache::VerFileIterator VF = V.FileList();
 473       for (; VF.end() == false ; ++VF)
 474          if ((VF.File()->Flags & pkgCache::Flag::NotSource) == 0)
 475             break;
 476
 477       /* Okay, here we have a bit of a problem.. The policy has selected the
 478          currently installed package - however it only exists in the
 479          status file.. We need to write out something or dselect will mark
 480          the package as obsolete! Thus we emit the status file entry, but
 481          below we remove the status line to make it valid for the
 482          available file. However! We only do this if their do exist *any*
 483          non-source versions of the package - that way the dselect obsolete
 484          handling works OK. */
 485       if (VF.end() == true)
 486       {
 487          for (pkgCache::VerIterator Cur = P.VersionList(); Cur.end() != true; ++Cur)
 488          {
 489             for (VF = Cur.FileList(); VF.end() == false; ++VF)
 490             {
 491                if ((VF.File()->Flags & pkgCache::Flag::NotSource) == 0)
 492                {
 493                   VF = V.FileList();
 494                   break;
 495                }
 496             }
 497
 498             if (VF.end() == false)
 499                break;
 500          }
 501       }
 502
 503       VFList[P->ID] = VF;
 504    }
 505
 506    LocalitySort(VFList,Count,sizeof(*VFList));
 507
 508    // Iterate over all the package files and write them out.
 509    char *Buffer = new char[Cache->HeaderP->MaxVerFileSize+10];
 510    for (pkgCache::VerFile **J = VFList; *J != 0;)
 511    {
 512       pkgCache::PkgFileIterator File(*Cache,(*J)->File + Cache->PkgFileP);
 513       if (File.IsOk() == false)
 514       {
 515          _error->Error(_("Package file %s is out of sync."),File.FileName());
 516          break;
 517       }
 518
 519       FileFd PkgF(File.FileName(),FileFd::ReadOnly);
 520       if (_error->PendingError() == true)
 521          break;
 522
 523       /* Write all of the records from this package file, since we
 524          already did locality sorting we can now just seek through the
 525          file in read order. We apply 1 more optimization here, since often
 526          there will be < 1 byte gaps between records (for the \n) we read that
 527          into the next buffer and offset a bit.. */
 528       unsigned long Pos = 0;
 529       for (; *J != 0; J++)
 530       {
 531          if ((*J)->File + Cache->PkgFileP != File)
 532             break;
 533
 534          const pkgCache::VerFile &VF = **J;
 535
 536          // Read the record and then write it out again.
 537          unsigned long Jitter = VF.Offset - Pos;
 538          if (Jitter > 8)
 539          {
 540             if (PkgF.Seek(VF.Offset) == false)
 541                break;
 542             Jitter = 0;
 543          }
 544
 545          if (PkgF.Read(Buffer,VF.Size + Jitter) == false)
 546             break;
 547          Buffer[VF.Size + Jitter] = '\n';
 548
 549          // See above..
 550          if ((File->Flags & pkgCache::Flag::NotSource) == pkgCache::Flag::NotSource)
 551          {
 552             pkgTagSection Tags;
 553             TFRewriteData RW[] = {{"Status",0},{"Config-Version",0},{}};
 554             const char *Zero = 0;
 555             if (Tags.Scan(Buffer+Jitter,VF.Size+1) == false ||
 556                 TFRewrite(stdout,Tags,&Zero,RW) == false)
 557             {
 558                _error->Error("Internal Error, Unable to parse a package record");
 559                break;
 560             }
 561             fputc('\n',stdout);
 562          }
 563          else
 564          {
 565             if (fwrite(Buffer+Jitter,VF.Size+1,1,stdout) != 1)
 566                break;
 567          }
 568
 569          Pos = VF.Offset + VF.Size;
 570       }
 571
 572       fflush(stdout);
 573       if (_error->PendingError() == true)
 574          break;
 575    }
 576
 577    delete [] Buffer;
 578    delete [] VFList;
 579    return !_error->PendingError();
 580 }
 581                                                                         /*}}}*/
 582 // ShowDepends - Helper for printing out a dependency tree              /*{{{*/
 583 bool ShowDepends(CommandLine &CmdL, bool const RevDepends)
 584 {
 585    pkgCacheFile CacheFile;
 586    pkgCache *Cache = CacheFile.GetPkgCache();
 587    if (unlikely(Cache == NULL))
 588       return false;
 589
 590    CacheSetHelperVirtuals helper(false);
 591    APT::VersionList verset = APT::VersionList::FromCommandLine(CacheFile, CmdL.FileList + 1, APT::VersionList::CANDIDATE, helper);
 592    if (verset.empty() == true && helper.virtualPkgs.empty() == true)
 593       return _error->Error(_("No packages found"));
 594    std::vector<bool> Shown(Cache->Head().PackageCount);
 595
 596    bool const Recurse = _config->FindB("APT::Cache::RecurseDepends", false);
 597    bool const Installed = _config->FindB("APT::Cache::Installed", false);
 598    bool const Important = _config->FindB("APT::Cache::Important", false);
 599    bool const ShowDepType = _config->FindB("APT::Cache::ShowDependencyType", RevDepends == false);
 600    bool const ShowVersion = _config->FindB("APT::Cache::ShowVersion", false);
 601    bool const ShowPreDepends = _config->FindB("APT::Cache::ShowPre-Depends", true);
 602    bool const ShowDepends = _config->FindB("APT::Cache::ShowDepends", true);
 603    bool const ShowRecommends = _config->FindB("APT::Cache::ShowRecommends", Important == false);
 604    bool const ShowSuggests = _config->FindB("APT::Cache::ShowSuggests", Important == false);
 605    bool const ShowReplaces = _config->FindB("APT::Cache::ShowReplaces", Important == false);
 606    bool const ShowConflicts = _config->FindB("APT::Cache::ShowConflicts", Important == false);
 607    bool const ShowBreaks = _config->FindB("APT::Cache::ShowBreaks", Important == false);
 608    bool const ShowEnhances = _config->FindB("APT::Cache::ShowEnhances", Important == false);
 609    bool const ShowOnlyFirstOr = _config->FindB("APT::Cache::ShowOnlyFirstOr", false);
 610
 611    while (verset.empty() != true)
 612    {
 613       pkgCache::VerIterator Ver = *verset.begin();
 614       verset.erase(verset.begin());
 615       pkgCache::PkgIterator Pkg = Ver.ParentPkg();
 616       Shown[Pkg->ID] = true;
 617
 618          cout << Pkg.FullName(true) << endl;
 619
 620          if (RevDepends == true)
 621             cout << "Reverse Depends:" << endl;
 622          for (pkgCache::DepIterator D = RevDepends ? Pkg.RevDependsList() : Ver.DependsList();
 623               D.end() == false; ++D)
 624          {
 625             switch (D->Type) {
 626             case pkgCache::Dep::PreDepends: if (!ShowPreDepends) continue; break;
 627             case pkgCache::Dep::Depends: if (!ShowDepends) continue; break;
 628             case pkgCache::Dep::Recommends: if (!ShowRecommends) continue; break;
 629             case pkgCache::Dep::Suggests: if (!ShowSuggests) continue; break;
 630             case pkgCache::Dep::Replaces: if (!ShowReplaces) continue; break;
 631             case pkgCache::Dep::Conflicts: if (!ShowConflicts) continue; break;
 632             case pkgCache::Dep::DpkgBreaks: if (!ShowBreaks) continue; break;
 633             case pkgCache::Dep::Enhances: if (!ShowEnhances) continue; break;
 634             }
 635
 636             pkgCache::PkgIterator Trg = RevDepends ? D.ParentPkg() : D.TargetPkg();
 637
 638             if((Installed && Trg->CurrentVer != 0) || !Installed)
 639               {
 640
 641                 if ((D->CompareOp & pkgCache::Dep::Or) == pkgCache::Dep::Or && ShowOnlyFirstOr == false)
 642                   cout << " |";
 643                 else
 644                   cout << "  ";
 645
 646                 // Show the package
 647                 if (ShowDepType == true)
 648                   cout << D.DepType() << ": ";
 649                 if (Trg->VersionList == 0)
 650                   cout << "<" << Trg.FullName(true) << ">";
 651                 else
 652                   cout << Trg.FullName(true);
 653                 if (ShowVersion == true && D->Version != 0)
 654                    cout << " (" << pkgCache::CompTypeDeb(D->CompareOp) << ' ' << D.TargetVer() << ')';
 655                 cout << std::endl;
 656
 657                 if (Recurse == true && Shown[Trg->ID] == false)
 658                 {
 659                   Shown[Trg->ID] = true;
 660                   verset.insert(APT::VersionSet::FromPackage(CacheFile, Trg, APT::VersionSet::CANDIDATE, helper));
 661                 }
 662
 663               }
 664
 665             // Display all solutions
 666             SPtrArray<pkgCache::Version *> List = D.AllTargets();
 667             pkgPrioSortList(*Cache,List);
 668             for (pkgCache::Version **I = List; *I != 0; I++)
 669             {
 670                pkgCache::VerIterator V(*Cache,*I);
 671                if (V != Cache->VerP + V.ParentPkg()->VersionList ||
 672                    V->ParentPkg == D->Package)
 673                   continue;
 674                cout << "    " << V.ParentPkg().FullName(true) << endl;
 675
 676                 if (Recurse == true && Shown[V.ParentPkg()->ID] == false)
 677                 {
 678                   Shown[V.ParentPkg()->ID] = true;
 679                   verset.insert(APT::VersionSet::FromPackage(CacheFile, V.ParentPkg(), APT::VersionSet::CANDIDATE, helper));
 680                 }
 681             }
 682
 683             if (ShowOnlyFirstOr == true)
 684                while ((D->CompareOp & pkgCache::Dep::Or) == pkgCache::Dep::Or) ++D;
 685          }
 686    }
 687
 688    for (APT::PackageSet::const_iterator Pkg = helper.virtualPkgs.begin();
 689         Pkg != helper.virtualPkgs.end(); ++Pkg)
 690       cout << '<' << Pkg.FullName(true) << '>' << endl;
 691
 692    return true;
 693 }
 694                                                                         /*}}}*/
 695 // Depends - Print out a dependency tree                                /*{{{*/
 696 // ---------------------------------------------------------------------
 697 /* */
 698 bool Depends(CommandLine &CmdL)
 699 {
 700    return ShowDepends(CmdL, false);
 701 }
 702                                                                         /*}}}*/
 703 // RDepends - Print out a reverse dependency tree                       /*{{{*/
 704 // ---------------------------------------------------------------------
 705 /* */
 706 bool RDepends(CommandLine &CmdL)
 707 {
 708    return ShowDepends(CmdL, true);
 709 }
 710                                                                         /*}}}*/
 711 // xvcg - Generate a graph for xvcg                                     /*{{{*/
 712 // ---------------------------------------------------------------------
 713 // Code contributed from Junichi Uekawa <dancer@debian.org> on 20 June 2002.
 714
 715 bool XVcg(CommandLine &CmdL)
 716 {
 717    pkgCacheFile CacheFile;
 718    pkgCache *Cache = CacheFile.GetPkgCache();
 719    if (unlikely(Cache == NULL))
 720       return false;
 721
 722    bool GivenOnly = _config->FindB("APT::Cache::GivenOnly",false);
 723
 724    /* Normal packages are boxes
 725       Pure Provides are triangles
 726       Mixed are diamonds
 727       rhomb are missing packages*/
 728    const char *Shapes[] = {"ellipse","triangle","box","rhomb"};
 729
 730    /* Initialize the list of packages to show.
 731       1 = To Show
 732       2 = To Show no recurse
 733       3 = Emitted no recurse
 734       4 = Emitted
 735       0 = None */
 736    enum States {None=0, ToShow, ToShowNR, DoneNR, Done};
 737    enum TheFlags {ForceNR=(1<<0)};
 738    unsigned char *Show = new unsigned char[Cache->Head().PackageCount];
 739    unsigned char *Flags = new unsigned char[Cache->Head().PackageCount];
 740    unsigned char *ShapeMap = new unsigned char[Cache->Head().PackageCount];
 741
 742    // Show everything if no arguments given
 743    if (CmdL.FileList[1] == 0)
 744       for (unsigned long I = 0; I != Cache->Head().PackageCount; I++)
 745          Show[I] = ToShow;
 746    else
 747       for (unsigned long I = 0; I != Cache->Head().PackageCount; I++)
 748          Show[I] = None;
 749    memset(Flags,0,sizeof(*Flags)*Cache->Head().PackageCount);
 750
 751    // Map the shapes
 752    for (pkgCache::PkgIterator Pkg = Cache->PkgBegin(); Pkg.end() == false; ++Pkg)
 753    {
 754       if (Pkg->VersionList == 0)
 755       {
 756          // Missing
 757          if (Pkg->ProvidesList == 0)
 758             ShapeMap[Pkg->ID] = 0;
 759          else
 760             ShapeMap[Pkg->ID] = 1;
 761       }
 762       else
 763       {
 764          // Normal
 765          if (Pkg->ProvidesList == 0)
 766             ShapeMap[Pkg->ID] = 2;
 767          else
 768             ShapeMap[Pkg->ID] = 3;
 769       }
 770    }
 771
 772    // Load the list of packages from the command line into the show list
 773    APT::CacheSetHelper helper(true, GlobalError::NOTICE);
 774    std::list<APT::PackageSet::Modifier> mods;
 775    mods.push_back(APT::PackageSet::Modifier(0, ",", APT::PackageSet::Modifier::POSTFIX));
 776    mods.push_back(APT::PackageSet::Modifier(1, "^", APT::PackageSet::Modifier::POSTFIX));
 777    std::map<unsigned short, APT::PackageSet> pkgsets =
 778                 APT::PackageSet::GroupedFromCommandLine(CacheFile, CmdL.FileList + 1, mods, 0, helper);
 779
 780    for (APT::PackageSet::const_iterator Pkg = pkgsets[0].begin();
 781         Pkg != pkgsets[0].end(); ++Pkg)
 782       Show[Pkg->ID] = ToShow;
 783    for (APT::PackageSet::const_iterator Pkg = pkgsets[1].begin();
 784         Pkg != pkgsets[1].end(); ++Pkg)
 785    {
 786       Show[Pkg->ID] = ToShow;
 787       Flags[Pkg->ID] |= ForceNR;
 788    }
 789
 790    // Little header
 791    cout << "graph: { title: \"packages\"" << endl <<
 792      "xmax: 700 ymax: 700 x: 30 y: 30" << endl <<
 793      "layout_downfactor: 8" << endl;
 794
 795    bool Act = true;
 796    while (Act == true)
 797    {
 798       Act = false;
 799       for (pkgCache::PkgIterator Pkg = Cache->PkgBegin(); Pkg.end() == false; ++Pkg)
 800       {
 801          // See we need to show this package
 802          if (Show[Pkg->ID] == None || Show[Pkg->ID] >= DoneNR)
 803             continue;
 804
 805          //printf ("node: { title: \"%s\" label: \"%s\" }\n", Pkg.Name(), Pkg.Name());
 806
 807          // Colour as done
 808          if (Show[Pkg->ID] == ToShowNR || (Flags[Pkg->ID] & ForceNR) == ForceNR)
 809          {
 810             // Pure Provides and missing packages have no deps!
 811             if (ShapeMap[Pkg->ID] == 0 || ShapeMap[Pkg->ID] == 1)
 812                Show[Pkg->ID] = Done;
 813             else
 814                Show[Pkg->ID] = DoneNR;
 815          }
 816          else
 817             Show[Pkg->ID] = Done;
 818          Act = true;
 819
 820          // No deps to map out
 821          if (Pkg->VersionList == 0 || Show[Pkg->ID] == DoneNR)
 822             continue;
 823
 824          pkgCache::VerIterator Ver = Pkg.VersionList();
 825          for (pkgCache::DepIterator D = Ver.DependsList(); D.end() == false; ++D)
 826          {
 827             // See if anything can meet this dep
 828             // Walk along the actual package providing versions
 829             bool Hit = false;
 830             pkgCache::PkgIterator DPkg = D.TargetPkg();
 831             for (pkgCache::VerIterator I = DPkg.VersionList();
 832                       I.end() == false && Hit == false; ++I)
 833             {
 834                if (Cache->VS->CheckDep(I.VerStr(),D->CompareOp,D.TargetVer()) == true)
 835                   Hit = true;
 836             }
 837
 838             // Follow all provides
 839             for (pkgCache::PrvIterator I = DPkg.ProvidesList();
 840                       I.end() == false && Hit == false; ++I)
 841             {
 842                if (Cache->VS->CheckDep(I.ProvideVersion(),D->CompareOp,D.TargetVer()) == false)
 843                   Hit = true;
 844             }
 845
 846
 847             // Only graph critical deps
 848             if (D.IsCritical() == true)
 849             {
 850                printf ("edge: { sourcename: \"%s\" targetname: \"%s\" class: 2 ",Pkg.FullName(true).c_str(), D.TargetPkg().FullName(true).c_str() );
 851
 852                // Colour the node for recursion
 853                if (Show[D.TargetPkg()->ID] <= DoneNR)
 854                {
 855                   /* If a conflicts does not meet anything in the database
 856                      then show the relation but do not recurse */
 857                   if (Hit == false && D.IsNegative() == true)
 858                   {
 859                      if (Show[D.TargetPkg()->ID] == None &&
 860                          Show[D.TargetPkg()->ID] != ToShow)
 861                         Show[D.TargetPkg()->ID] = ToShowNR;
 862                   }
 863                   else
 864                   {
 865                      if (GivenOnly == true && Show[D.TargetPkg()->ID] != ToShow)
 866                         Show[D.TargetPkg()->ID] = ToShowNR;
 867                      else
 868                         Show[D.TargetPkg()->ID] = ToShow;
 869                   }
 870                }
 871
 872                // Edge colour
 873                switch(D->Type)
 874                {
 875                   case pkgCache::Dep::Conflicts:
 876                     printf("label: \"conflicts\" color: lightgreen }\n");
 877                     break;
 878                   case pkgCache::Dep::DpkgBreaks:
 879                     printf("label: \"breaks\" color: lightgreen }\n");
 880                     break;
 881                   case pkgCache::Dep::Obsoletes:
 882                     printf("label: \"obsoletes\" color: lightgreen }\n");
 883                     break;
 884
 885                   case pkgCache::Dep::PreDepends:
 886                     printf("label: \"predepends\" color: blue }\n");
 887                     break;
 888
 889                   default:
 890                     printf("}\n");
 891                   break;
 892                }
 893             }
 894          }
 895       }
 896    }
 897
 898    /* Draw the box colours after the fact since we can not tell what colour
 899       they should be until everything is finished drawing */
 900    for (pkgCache::PkgIterator Pkg = Cache->PkgBegin(); Pkg.end() == false; ++Pkg)
 901    {
 902       if (Show[Pkg->ID] < DoneNR)
 903          continue;
 904
 905       if (Show[Pkg->ID] == DoneNR)
 906          printf("node: { title: \"%s\" label: \"%s\" color: orange shape: %s }\n", Pkg.FullName(true).c_str(), Pkg.FullName(true).c_str(),
 907                 Shapes[ShapeMap[Pkg->ID]]);
 908       else
 909         printf("node: { title: \"%s\" label: \"%s\" shape: %s }\n", Pkg.FullName(true).c_str(), Pkg.FullName(true).c_str(),
 910                 Shapes[ShapeMap[Pkg->ID]]);
 911
 912    }
 913
 914    delete[] Show;
 915    delete[] Flags;
 916    delete[] ShapeMap;
 917
 918    printf("}\n");
 919    return true;
 920 }
 921                                                                         /*}}}*/
 922 // Dotty - Generate a graph for Dotty                                   /*{{{*/
 923 // ---------------------------------------------------------------------
 924 /* Dotty is the graphvis program for generating graphs. It is a fairly
 925    simple queuing algorithm that just writes dependencies and nodes.
 926    http://www.research.att.com/sw/tools/graphviz/ */
 927 bool Dotty(CommandLine &CmdL)
 928 {
 929    pkgCacheFile CacheFile;
 930    pkgCache *Cache = CacheFile.GetPkgCache();
 931    if (unlikely(Cache == NULL))
 932       return false;
 933
 934    bool GivenOnly = _config->FindB("APT::Cache::GivenOnly",false);
 935
 936    /* Normal packages are boxes
 937       Pure Provides are triangles
 938       Mixed are diamonds
 939       Hexagons are missing packages*/
 940    const char *Shapes[] = {"hexagon","triangle","box","diamond"};
 941
 942    /* Initialize the list of packages to show.
 943       1 = To Show
 944       2 = To Show no recurse
 945       3 = Emitted no recurse
 946       4 = Emitted
 947       0 = None */
 948    enum States {None=0, ToShow, ToShowNR, DoneNR, Done};
 949    enum TheFlags {ForceNR=(1<<0)};
 950    unsigned char *Show = new unsigned char[Cache->Head().PackageCount];
 951    unsigned char *Flags = new unsigned char[Cache->Head().PackageCount];
 952    unsigned char *ShapeMap = new unsigned char[Cache->Head().PackageCount];
 953
 954    // Show everything if no arguments given
 955    if (CmdL.FileList[1] == 0)
 956       for (unsigned long I = 0; I != Cache->Head().PackageCount; I++)
 957          Show[I] = ToShow;
 958    else
 959       for (unsigned long I = 0; I != Cache->Head().PackageCount; I++)
 960          Show[I] = None;
 961    memset(Flags,0,sizeof(*Flags)*Cache->Head().PackageCount);
 962
 963    // Map the shapes
 964    for (pkgCache::PkgIterator Pkg = Cache->PkgBegin(); Pkg.end() == false; ++Pkg)
 965    {
 966       if (Pkg->VersionList == 0)
 967       {
 968          // Missing
 969          if (Pkg->ProvidesList == 0)
 970             ShapeMap[Pkg->ID] = 0;
 971          else
 972             ShapeMap[Pkg->ID] = 1;
 973       }
 974       else
 975       {
 976          // Normal
 977          if (Pkg->ProvidesList == 0)
 978             ShapeMap[Pkg->ID] = 2;
 979          else
 980             ShapeMap[Pkg->ID] = 3;
 981       }
 982    }
 983
 984    // Load the list of packages from the command line into the show list
 985    APT::CacheSetHelper helper(true, GlobalError::NOTICE);
 986    std::list<APT::PackageSet::Modifier> mods;
 987    mods.push_back(APT::PackageSet::Modifier(0, ",", APT::PackageSet::Modifier::POSTFIX));
 988    mods.push_back(APT::PackageSet::Modifier(1, "^", APT::PackageSet::Modifier::POSTFIX));
 989    std::map<unsigned short, APT::PackageSet> pkgsets =
 990                 APT::PackageSet::GroupedFromCommandLine(CacheFile, CmdL.FileList + 1, mods, 0, helper);
 991
 992    for (APT::PackageSet::const_iterator Pkg = pkgsets[0].begin();
 993         Pkg != pkgsets[0].end(); ++Pkg)
 994       Show[Pkg->ID] = ToShow;
 995    for (APT::PackageSet::const_iterator Pkg = pkgsets[1].begin();
 996         Pkg != pkgsets[1].end(); ++Pkg)
 997    {
 998       Show[Pkg->ID] = ToShow;
 999       Flags[Pkg->ID] |= ForceNR;
1000    }
1001
1002    // Little header
1003    printf("digraph packages {\n");
1004    printf("concentrate=true;\n");
1005    printf("size=\"30,40\";\n");
1006
1007    bool Act = true;
1008    while (Act == true)
1009    {
1010       Act = false;
1011       for (pkgCache::PkgIterator Pkg = Cache->PkgBegin(); Pkg.end() == false; ++Pkg)
1012       {
1013          // See we need to show this package
1014          if (Show[Pkg->ID] == None || Show[Pkg->ID] >= DoneNR)
1015             continue;
1016
1017          // Colour as done
1018          if (Show[Pkg->ID] == ToShowNR || (Flags[Pkg->ID] & ForceNR) == ForceNR)
1019          {
1020             // Pure Provides and missing packages have no deps!
1021             if (ShapeMap[Pkg->ID] == 0 || ShapeMap[Pkg->ID] == 1)
1022                Show[Pkg->ID] = Done;
1023             else
1024                Show[Pkg->ID] = DoneNR;
1025          }
1026          else
1027             Show[Pkg->ID] = Done;
1028          Act = true;
1029
1030          // No deps to map out
1031          if (Pkg->VersionList == 0 || Show[Pkg->ID] == DoneNR)
1032             continue;
1033
1034          pkgCache::VerIterator Ver = Pkg.VersionList();
1035          for (pkgCache::DepIterator D = Ver.DependsList(); D.end() == false; ++D)
1036          {
1037             // See if anything can meet this dep
1038             // Walk along the actual package providing versions
1039             bool Hit = false;
1040             pkgCache::PkgIterator DPkg = D.TargetPkg();
1041             for (pkgCache::VerIterator I = DPkg.VersionList();
1042                       I.end() == false && Hit == false; ++I)
1043             {
1044                if (Cache->VS->CheckDep(I.VerStr(),D->CompareOp,D.TargetVer()) == true)
1045                   Hit = true;
1046             }
1047
1048             // Follow all provides
1049             for (pkgCache::PrvIterator I = DPkg.ProvidesList();
1050                       I.end() == false && Hit == false; ++I)
1051             {
1052                if (Cache->VS->CheckDep(I.ProvideVersion(),D->CompareOp,D.TargetVer()) == false)
1053                   Hit = true;
1054             }
1055
1056             // Only graph critical deps
1057             if (D.IsCritical() == true)
1058             {
1059                printf("\"%s\" -> \"%s\"",Pkg.FullName(true).c_str(),D.TargetPkg().FullName(true).c_str());
1060
1061                // Colour the node for recursion
1062                if (Show[D.TargetPkg()->ID] <= DoneNR)
1063                {
1064                   /* If a conflicts does not meet anything in the database
1065                      then show the relation but do not recurse */
1066                   if (Hit == false && D.IsNegative() == true)
1067                   {
1068                      if (Show[D.TargetPkg()->ID] == None &&
1069                          Show[D.TargetPkg()->ID] != ToShow)
1070                         Show[D.TargetPkg()->ID] = ToShowNR;
1071                   }
1072                   else
1073                   {
1074                      if (GivenOnly == true && Show[D.TargetPkg()->ID] != ToShow)
1075                         Show[D.TargetPkg()->ID] = ToShowNR;
1076                      else
1077                         Show[D.TargetPkg()->ID] = ToShow;
1078                   }
1079                }
1080
1081                // Edge colour
1082                switch(D->Type)
1083                {
1084                   case pkgCache::Dep::Conflicts:
1085                   case pkgCache::Dep::Obsoletes:
1086                   case pkgCache::Dep::DpkgBreaks:
1087                   printf("[color=springgreen];\n");
1088                   break;
1089
1090                   case pkgCache::Dep::PreDepends:
1091                   printf("[color=blue];\n");
1092                   break;
1093
1094                   default:
1095                   printf(";\n");
1096                   break;
1097                }
1098             }
1099          }
1100       }
1101    }
1102
1103    /* Draw the box colours after the fact since we can not tell what colour
1104       they should be until everything is finished drawing */
1105    for (pkgCache::PkgIterator Pkg = Cache->PkgBegin(); Pkg.end() == false; ++Pkg)
1106    {
1107       if (Show[Pkg->ID] < DoneNR)
1108          continue;
1109
1110       // Orange box for early recursion stoppage
1111       if (Show[Pkg->ID] == DoneNR)
1112          printf("\"%s\" [color=orange,shape=%s];\n",Pkg.FullName(true).c_str(),
1113                 Shapes[ShapeMap[Pkg->ID]]);
1114       else
1115          printf("\"%s\" [shape=%s];\n",Pkg.FullName(true).c_str(),
1116                 Shapes[ShapeMap[Pkg->ID]]);
1117    }
1118
1119    printf("}\n");
1120    delete[] Show;
1121    delete[] Flags;
1122    delete[] ShapeMap;
1123    return true;
1124 }
1125                                                                         /*}}}*/
1126 // DisplayRecord - Displays the complete record for the package         /*{{{*/
1127 // ---------------------------------------------------------------------
1128 /* This displays the package record from the proper package index file.
1129    It is not used by DumpAvail for performance reasons. */
1130 bool DisplayRecord(pkgCacheFile &CacheFile, pkgCache::VerIterator V)
1131 {
1132    pkgCache *Cache = CacheFile.GetPkgCache();
1133    if (unlikely(Cache == NULL))
1134       return false;
1135
1136    // Find an appropriate file
1137    pkgCache::VerFileIterator Vf = V.FileList();
1138    for (; Vf.end() == false; ++Vf)
1139       if ((Vf.File()->Flags & pkgCache::Flag::NotSource) == 0)
1140          break;
1141    if (Vf.end() == true)
1142       Vf = V.FileList();
1143
1144    // Check and load the package list file
1145    pkgCache::PkgFileIterator I = Vf.File();
1146    if (I.IsOk() == false)
1147       return _error->Error(_("Package file %s is out of sync."),I.FileName());
1148
1149    FileFd PkgF;
1150    if (PkgF.Open(I.FileName(), FileFd::ReadOnly, FileFd::Extension) == false)
1151       return false;
1152
1153    // Read the record
1154    unsigned char *Buffer = new unsigned char[Cache->HeaderP->MaxVerFileSize+1];
1155    Buffer[V.FileList()->Size] = '\n';
1156    if (PkgF.Seek(V.FileList()->Offset) == false ||
1157        PkgF.Read(Buffer,V.FileList()->Size) == false)
1158    {
1159       delete [] Buffer;
1160       return false;
1161    }
1162
1163    // Get a pointer to start of Description field
1164    const unsigned char *DescP = (unsigned char*)strstr((char*)Buffer, "Description:");
1165
1166    // Write all but Description
1167    if (fwrite(Buffer,1,DescP - Buffer,stdout) < (size_t)(DescP - Buffer))
1168    {
1169       delete [] Buffer;
1170       return false;
1171    }
1172
1173    // Show the right description
1174    pkgRecords Recs(*Cache);
1175    pkgCache::DescIterator Desc = V.TranslatedDescription();
1176    pkgRecords::Parser &P = Recs.Lookup(Desc.FileList());
1177    cout << "Description" << ( (strcmp(Desc.LanguageCode(),"") != 0) ? "-" : "" ) << Desc.LanguageCode() << ": " << P.LongDesc();
1178
1179    // Find the first field after the description (if there is any)
1180    for(DescP++;DescP != &Buffer[V.FileList()->Size];DescP++)
1181    {
1182       if(*DescP == '\n' && *(DescP+1) != ' ')
1183       {
1184          // write the rest of the buffer
1185          const unsigned char *end=&Buffer[V.FileList()->Size];
1186          if (fwrite(DescP,1,end-DescP,stdout) < (size_t)(end-DescP))
1187          {
1188             delete [] Buffer;
1189             return false;
1190          }
1191
1192          break;
1193       }
1194    }
1195    // write a final newline (after the description)
1196    cout<<endl;
1197    delete [] Buffer;
1198
1199    return true;
1200 }
1201                                                                         /*}}}*/
1202
1203 struct ExDescFile
1204 {
1205    pkgCache::DescFile *Df;
1206    bool NameMatch;
1207 };
1208
1209 // Search - Perform a search                                            /*{{{*/
1210 // ---------------------------------------------------------------------
1211 /* This searches the package names and package descriptions for a pattern */
1212 bool Search(CommandLine &CmdL)
1213 {
1214    bool const ShowFull = _config->FindB("APT::Cache::ShowFull",false);
1215    bool const NamesOnly = _config->FindB("APT::Cache::NamesOnly",false);
1216    unsigned int const NumPatterns = CmdL.FileSize() -1;
1217
1218    pkgCacheFile CacheFile;
1219    pkgCache *Cache = CacheFile.GetPkgCache();
1220    pkgDepCache::Policy *Plcy = CacheFile.GetPolicy();
1221    if (unlikely(Cache == NULL || Plcy == NULL))
1222       return false;
1223
1224    // Make sure there is at least one argument
1225    if (NumPatterns < 1)
1226       return _error->Error(_("You must give at least one search pattern"));
1227
1228    // Compile the regex pattern
1229    regex_t *Patterns = new regex_t[NumPatterns];
1230    memset(Patterns,0,sizeof(*Patterns)*NumPatterns);
1231    for (unsigned I = 0; I != NumPatterns; I++)
1232    {
1233       if (regcomp(&Patterns[I],CmdL.FileList[I+1],REG_EXTENDED | REG_ICASE |
1234                   REG_NOSUB) != 0)
1235       {
1236          for (; I != 0; I--)
1237             regfree(&Patterns[I]);
1238          return _error->Error("Regex compilation error");
1239       }
1240    }
1241
1242    if (_error->PendingError() == true)
1243    {
1244       for (unsigned I = 0; I != NumPatterns; I++)
1245          regfree(&Patterns[I]);
1246       return false;
1247    }
1248
1249    ExDescFile *DFList = new ExDescFile[Cache->HeaderP->GroupCount+1];
1250    memset(DFList, 0, sizeof(*DFList) * (Cache->HeaderP->GroupCount + 1));
1251
1252    // Map versions that we want to write out onto the VerList array.
1253    for (pkgCache::GrpIterator G = Cache->GrpBegin(); G.end() == false; ++G)
1254    {
1255       if (DFList[G->ID].NameMatch == true)
1256          continue;
1257
1258       DFList[G->ID].NameMatch = true;
1259       for (unsigned I = 0; I != NumPatterns; I++)
1260       {
1261          if (regexec(&Patterns[I],G.Name(),0,0,0) == 0)
1262             continue;
1263          DFList[G->ID].NameMatch = false;
1264          break;
1265       }
1266
1267       // Doing names only, drop any that dont match..
1268       if (NamesOnly == true && DFList[G->ID].NameMatch == false)
1269          continue;
1270
1271       // Find the proper version to use
1272       pkgCache::PkgIterator P = G.FindPreferredPkg();
1273       if (P.end() == true)
1274          continue;
1275       pkgCache::VerIterator V = Plcy->GetCandidateVer(P);
1276       if (V.end() == false)
1277          DFList[G->ID].Df = V.TranslatedDescription().FileList();
1278
1279       if (DFList[G->ID].NameMatch == false)
1280          continue;
1281
1282       // Include all the packages that provide matching names too
1283       for (pkgCache::PrvIterator Prv = P.ProvidesList() ; Prv.end() == false; ++Prv)
1284       {
1285          pkgCache::VerIterator V = Plcy->GetCandidateVer(Prv.OwnerPkg());
1286          if (V.end() == true)
1287             continue;
1288
1289          unsigned long id = Prv.OwnerPkg().Group()->ID;
1290          DFList[id].Df = V.TranslatedDescription().FileList();
1291          DFList[id].NameMatch = true;
1292       }
1293    }
1294
1295    LocalitySort(&DFList->Df,Cache->HeaderP->GroupCount,sizeof(*DFList));
1296
1297    // Create the text record parser
1298    pkgRecords Recs(*Cache);
1299    // Iterate over all the version records and check them
1300    for (ExDescFile *J = DFList; J->Df != 0; J++)
1301    {
1302       pkgRecords::Parser &P = Recs.Lookup(pkgCache::DescFileIterator(*Cache,J->Df));
1303
1304       if (J->NameMatch == false && NamesOnly == false)
1305       {
1306          string const LongDesc = P.LongDesc();
1307          J->NameMatch = true;
1308          for (unsigned I = 0; I != NumPatterns; I++)
1309          {
1310             if (regexec(&Patterns[I],LongDesc.c_str(),0,0,0) == 0)
1311                continue;
1312             J->NameMatch = false;
1313             break;
1314          }
1315       }
1316
1317       if (J->NameMatch == true)
1318       {
1319          if (ShowFull == true)
1320          {
1321             const char *Start;
1322             const char *End;
1323             P.GetRec(Start,End);
1324             fwrite(Start,End-Start,1,stdout);
1325             putc('\n',stdout);
1326          }
1327          else
1328             printf("%s - %s\n",P.Name().c_str(),P.ShortDesc().c_str());
1329       }
1330    }
1331
1332    delete [] DFList;
1333    for (unsigned I = 0; I != NumPatterns; I++)
1334       regfree(&Patterns[I]);
1335    if (ferror(stdout))
1336        return _error->Error("Write to stdout failed");
1337    return true;
1338 }
1339                                                                         /*}}}*/
1340 /* ShowAuto - show automatically installed packages (sorted)            {{{*/
1341 bool ShowAuto(CommandLine &CmdL)
1342 {
1343    pkgCacheFile CacheFile;
1344    pkgCache *Cache = CacheFile.GetPkgCache();
1345    pkgDepCache *DepCache = CacheFile.GetDepCache();
1346    if (unlikely(Cache == NULL || DepCache == NULL))
1347       return false;
1348
1349    std::vector<string> packages;
1350    packages.reserve(Cache->HeaderP->PackageCount / 3);
1351
1352    for (pkgCache::PkgIterator P = Cache->PkgBegin(); P.end() == false; ++P)
1353       if ((*DepCache)[P].Flags & pkgCache::Flag::Auto)
1354          packages.push_back(P.Name());
1355
1356     std::sort(packages.begin(), packages.end());
1357
1358     for (vector<string>::iterator I = packages.begin(); I != packages.end(); ++I)
1359             cout << *I << "\n";
1360
1361    _error->Notice(_("This command is deprecated. Please use 'apt-mark showauto' instead."));
1362    return true;
1363 }
1364                                                                         /*}}}*/
1365 // ShowPackage - Dump the package record to the screen                  /*{{{*/
1366 // ---------------------------------------------------------------------
1367 /* */
1368 bool ShowPackage(CommandLine &CmdL)
1369 {
1370    pkgCacheFile CacheFile;
1371    CacheSetHelperVirtuals helper(true, GlobalError::NOTICE);
1372    APT::VersionList::Version const select = _config->FindB("APT::Cache::AllVersions", true) ?
1373                         APT::VersionList::ALL : APT::VersionList::CANDIDATE;
1374    APT::VersionList const verset = APT::VersionList::FromCommandLine(CacheFile, CmdL.FileList + 1, select, helper);
1375    for (APT::VersionList::const_iterator Ver = verset.begin(); Ver != verset.end(); ++Ver)
1376       if (DisplayRecord(CacheFile, Ver) == false)
1377          return false;
1378
1379    if (verset.empty() == true)
1380    {
1381       if (helper.virtualPkgs.empty() == true)
1382         return _error->Error(_("No packages found"));
1383       else
1384         _error->Notice(_("No packages found"));
1385    }
1386    return true;
1387 }
1388                                                                         /*}}}*/
1389 // ShowPkgNames - Show package names                                    /*{{{*/
1390 // ---------------------------------------------------------------------
1391 /* This does a prefix match on the first argument */
1392 bool ShowPkgNames(CommandLine &CmdL)
1393 {
1394    pkgCacheFile CacheFile;
1395    if (unlikely(CacheFile.BuildCaches(NULL, false) == false))
1396       return false;
1397    pkgCache::GrpIterator I = CacheFile.GetPkgCache()->GrpBegin();
1398    bool const All = _config->FindB("APT::Cache::AllNames","false");
1399
1400    if (CmdL.FileList[1] != 0)
1401    {
1402       for (;I.end() != true; ++I)
1403       {
1404          if (All == false && I->FirstPackage == 0)
1405             continue;
1406          if (I.FindPkg("any")->VersionList == 0)
1407             continue;
1408          if (strncmp(I.Name(),CmdL.FileList[1],strlen(CmdL.FileList[1])) == 0)
1409             cout << I.Name() << endl;
1410       }
1411
1412       return true;
1413    }
1414
1415    // Show all pkgs
1416    for (;I.end() != true; ++I)
1417    {
1418       if (All == false && I->FirstPackage == 0)
1419          continue;
1420       if (I.FindPkg("any")->VersionList == 0)
1421          continue;
1422       cout << I.Name() << endl;
1423    }
1424
1425    return true;
1426 }
1427                                                                         /*}}}*/
1428 // ShowSrcPackage - Show source package records                         /*{{{*/
1429 // ---------------------------------------------------------------------
1430 /* */
1431 bool ShowSrcPackage(CommandLine &CmdL)
1432 {
1433    pkgCacheFile CacheFile;
1434    pkgSourceList *List = CacheFile.GetSourceList();
1435    if (unlikely(List == NULL))
1436       return false;
1437
1438    // Create the text record parsers
1439    pkgSrcRecords SrcRecs(*List);
1440    if (_error->PendingError() == true)
1441       return false;
1442
1443    unsigned found = 0;
1444    for (const char **I = CmdL.FileList + 1; *I != 0; I++)
1445    {
1446       SrcRecs.Restart();
1447
1448       pkgSrcRecords::Parser *Parse;
1449       unsigned found_this = 0;
1450       while ((Parse = SrcRecs.Find(*I,false)) != 0) {
1451         cout << Parse->AsStr() << endl;;
1452         found++;
1453         found_this++;
1454       }
1455       if (found_this == 0) {
1456         _error->Warning(_("Unable to locate package %s"),*I);
1457         continue;
1458       }
1459    }
1460    if (found == 0)
1461       _error->Notice(_("No packages found"));
1462    return true;
1463 }
1464                                                                         /*}}}*/
1465 // Policy - Show the results of the preferences file                    /*{{{*/
1466 // ---------------------------------------------------------------------
1467 /* */
1468 bool Policy(CommandLine &CmdL)
1469 {
1470    pkgCacheFile CacheFile;
1471    pkgCache *Cache = CacheFile.GetPkgCache();
1472    pkgPolicy *Plcy = CacheFile.GetPolicy();
1473    pkgSourceList *SrcList = CacheFile.GetSourceList();
1474    if (unlikely(Cache == NULL || Plcy == NULL || SrcList == NULL))
1475       return false;
1476
1477    /* Should the MultiArchKiller be run to see which pseudo packages for an
1478       arch all package are currently installed? Activating it gives a speed
1479       penality for no real gain beside enhanced debugging, so in general no. */
1480    if (_config->FindB("APT::Cache::Policy::DepCache", false) == true)
1481       CacheFile.GetDepCache();
1482
1483    // Print out all of the package files
1484    if (CmdL.FileList[1] == 0)
1485    {
1486       cout << _("Package files:") << endl;
1487       for (pkgCache::PkgFileIterator F = Cache->FileBegin(); F.end() == false; ++F)
1488       {
1489          // Locate the associated index files so we can derive a description
1490          pkgIndexFile *Indx;
1491          if (SrcList->FindIndex(F,Indx) == false &&
1492              _system->FindIndex(F,Indx) == false)
1493             return _error->Error(_("Cache is out of sync, can't x-ref a package file"));
1494
1495          printf("%4i %s\n",
1496                 Plcy->GetPriority(F),Indx->Describe(true).c_str());
1497
1498          // Print the reference information for the package
1499          string Str = F.RelStr();
1500          if (Str.empty() == false)
1501             printf("     release %s\n",F.RelStr().c_str());
1502          if (F.Site() != 0 && F.Site()[0] != 0)
1503             printf("     origin %s\n",F.Site());
1504       }
1505
1506       // Show any packages have explicit pins
1507       cout << _("Pinned packages:") << endl;
1508       pkgCache::PkgIterator I = Cache->PkgBegin();
1509       for (;I.end() != true; ++I)
1510       {
1511          if (Plcy->GetPriority(I) == 0)
1512             continue;
1513
1514          // Print the package name and the version we are forcing to
1515          cout << "     " << I.FullName(true) << " -> ";
1516
1517          pkgCache::VerIterator V = Plcy->GetMatch(I);
1518          if (V.end() == true)
1519             cout << _("(not found)") << endl;
1520          else
1521             cout << V.VerStr() << endl;
1522       }
1523
1524       return true;
1525    }
1526
1527    char const * const msgInstalled = _("  Installed: ");
1528    char const * const msgCandidate = _("  Candidate: ");
1529    short const InstalledLessCandidate =
1530                 mbstowcs(NULL, msgInstalled, 0) - mbstowcs(NULL, msgCandidate, 0);
1531    short const deepInstalled =
1532                 (InstalledLessCandidate < 0 ? (InstalledLessCandidate*-1) : 0) - 1;
1533    short const deepCandidate =
1534                 (InstalledLessCandidate > 0 ? (InstalledLessCandidate) : 0) - 1;
1535
1536    // Print out detailed information for each package
1537    APT::CacheSetHelper helper(true, GlobalError::NOTICE);
1538    APT::PackageList pkgset = APT::PackageList::FromCommandLine(CacheFile, CmdL.FileList + 1, helper);
1539    for (APT::PackageList::const_iterator Pkg = pkgset.begin(); Pkg != pkgset.end(); ++Pkg)
1540    {
1541       cout << Pkg.FullName(true) << ":" << endl;
1542
1543       // Installed version
1544       cout << msgInstalled << OutputInDepth(deepInstalled, " ");
1545       if (Pkg->CurrentVer == 0)
1546          cout << _("(none)") << endl;
1547       else
1548          cout << Pkg.CurrentVer().VerStr() << endl;
1549
1550       // Candidate Version
1551       cout << msgCandidate << OutputInDepth(deepCandidate, " ");
1552       pkgCache::VerIterator V = Plcy->GetCandidateVer(Pkg);
1553       if (V.end() == true)
1554          cout << _("(none)") << endl;
1555       else
1556          cout << V.VerStr() << endl;
1557
1558       // Pinned version
1559       if (Plcy->GetPriority(Pkg) != 0)
1560       {
1561          cout << _("  Package pin: ");
1562          V = Plcy->GetMatch(Pkg);
1563          if (V.end() == true)
1564             cout << _("(not found)") << endl;
1565          else
1566             cout << V.VerStr() << endl;
1567       }
1568
1569       // Show the priority tables
1570       cout << _("  Version table:") << endl;
1571       for (V = Pkg.VersionList(); V.end() == false; ++V)
1572       {
1573          if (Pkg.CurrentVer() == V)
1574             cout << " *** " << V.VerStr();
1575          else
1576             cout << "     " << V.VerStr();
1577          cout << " " << Plcy->GetPriority(Pkg) << endl;
1578          for (pkgCache::VerFileIterator VF = V.FileList(); VF.end() == false; ++VF)
1579          {
1580             // Locate the associated index files so we can derive a description
1581             pkgIndexFile *Indx;
1582             if (SrcList->FindIndex(VF.File(),Indx) == false &&
1583                 _system->FindIndex(VF.File(),Indx) == false)
1584                return _error->Error(_("Cache is out of sync, can't x-ref a package file"));
1585             printf("       %4i %s\n",Plcy->GetPriority(VF.File()),
1586                    Indx->Describe(true).c_str());
1587          }
1588       }
1589    }
1590
1591    return true;
1592 }
1593                                                                         /*}}}*/
1594 // Madison - Look a bit like katie's madison                            /*{{{*/
1595 // ---------------------------------------------------------------------
1596 /* */
1597 bool Madison(CommandLine &CmdL)
1598 {
1599    pkgCacheFile CacheFile;
1600    pkgSourceList *SrcList = CacheFile.GetSourceList();
1601
1602    if (SrcList == 0)
1603       return false;
1604
1605    // Create the src text record parsers and ignore errors about missing
1606    // deb-src lines that are generated from pkgSrcRecords::pkgSrcRecords
1607    pkgSrcRecords SrcRecs(*SrcList);
1608    if (_error->PendingError() == true)
1609       _error->Discard();
1610
1611    APT::CacheSetHelper helper(true, GlobalError::NOTICE);
1612    for (const char **I = CmdL.FileList + 1; *I != 0; I++)
1613    {
1614       _error->PushToStack();
1615       APT::PackageList pkgset = APT::PackageList::FromString(CacheFile, *I, helper);
1616       for (APT::PackageList::const_iterator Pkg = pkgset.begin(); Pkg != pkgset.end(); ++Pkg)
1617       {
1618          for (pkgCache::VerIterator V = Pkg.VersionList(); V.end() == false; ++V)
1619          {
1620             for (pkgCache::VerFileIterator VF = V.FileList(); VF.end() == false; ++VF)
1621             {
1622 // This might be nice, but wouldn't uniquely identify the source -mdz
1623 //                if (VF.File().Archive() != 0)
1624 //                {
1625 //                   cout << setw(10) << Pkg.Name() << " | " << setw(10) << V.VerStr() << " | "
1626 //                        << VF.File().Archive() << endl;
1627 //                }
1628
1629                // Locate the associated index files so we can derive a description
1630                for (pkgSourceList::const_iterator S = SrcList->begin(); S != SrcList->end(); ++S)
1631                {
1632                     vector<pkgIndexFile *> *Indexes = (*S)->GetIndexFiles();
1633                     for (vector<pkgIndexFile *>::const_iterator IF = Indexes->begin();
1634                          IF != Indexes->end(); ++IF)
1635                     {
1636                          if ((*IF)->FindInCache(*(VF.File().Cache())) == VF.File())
1637                          {
1638                                    cout << setw(10) << Pkg.FullName(true) << " | " << setw(10) << V.VerStr() << " | "
1639                                         << (*IF)->Describe(true) << endl;
1640                          }
1641                     }
1642                }
1643             }
1644          }
1645       }
1646
1647       SrcRecs.Restart();
1648       pkgSrcRecords::Parser *SrcParser;
1649       bool foundSomething = false;
1650       while ((SrcParser = SrcRecs.Find(*I, false)) != 0)
1651       {
1652          foundSomething = true;
1653          // Maybe support Release info here too eventually
1654          cout << setw(10) << SrcParser->Package() << " | "
1655               << setw(10) << SrcParser->Version() << " | "
1656               << SrcParser->Index().Describe(true) << endl;
1657       }
1658       if (foundSomething == true)
1659          _error->RevertToStack();
1660       else
1661          _error->MergeWithStack();
1662    }
1663
1664    return true;
1665 }
1666                                                                         /*}}}*/
1667 // GenCaches - Call the main cache generator                            /*{{{*/
1668 // ---------------------------------------------------------------------
1669 /* */
1670 bool GenCaches(CommandLine &Cmd)
1671 {
1672    OpTextProgress Progress(*_config);
1673
1674    pkgCacheFile CacheFile;
1675    return CacheFile.BuildCaches(&Progress, true);
1676 }
1677                                                                         /*}}}*/
1678 // ShowHelp - Show a help screen                                        /*{{{*/
1679 // ---------------------------------------------------------------------
1680 /* */
1681 bool ShowHelp(CommandLine &Cmd)
1682 {
1683    ioprintf(cout,_("%s %s for %s compiled on %s %s\n"),PACKAGE,PACKAGE_VERSION,
1684             COMMON_ARCH,__DATE__,__TIME__);
1685
1686    if (_config->FindB("version") == true)
1687      return true;
1688
1689    cout <<
1690     _("Usage: apt-cache [options] command\n"
1691       "       apt-cache [options] showpkg pkg1 [pkg2 ...]\n"
1692       "       apt-cache [options] showsrc pkg1 [pkg2 ...]\n"
1693       "\n"
1694       "apt-cache is a low-level tool used to query information\n"
1695       "from APT's binary cache files\n"
1696       "\n"
1697       "Commands:\n"
1698       "   gencaches - Build both the package and source cache\n"
1699       "   showpkg - Show some general information for a single package\n"
1700       "   showsrc - Show source records\n"
1701       "   stats - Show some basic statistics\n"
1702       "   dump - Show the entire file in a terse form\n"
1703       "   dumpavail - Print an available file to stdout\n"
1704       "   unmet - Show unmet dependencies\n"
1705       "   search - Search the package list for a regex pattern\n"
1706       "   show - Show a readable record for the package\n"
1707       "   depends - Show raw dependency information for a package\n"
1708       "   rdepends - Show reverse dependency information for a package\n"
1709       "   pkgnames - List the names of all packages in the system\n"
1710       "   dotty - Generate package graphs for GraphViz\n"
1711       "   xvcg - Generate package graphs for xvcg\n"
1712       "   policy - Show policy settings\n"
1713       "\n"
1714       "Options:\n"
1715       "  -h   This help text.\n"
1716       "  -p=? The package cache.\n"
1717       "  -s=? The source cache.\n"
1718       "  -q   Disable progress indicator.\n"
1719       "  -i   Show only important deps for the unmet command.\n"
1720       "  -c=? Read this configuration file\n"
1721       "  -o=? Set an arbitrary configuration option, eg -o dir::cache=/tmp\n"
1722       "See the apt-cache(8) and apt.conf(5) manual pages for more information.\n");
1723    return true;
1724 }
1725                                                                         /*}}}*/
1726 int main(int argc,const char *argv[])                                   /*{{{*/
1727 {
1728    CommandLine::Args Args[] = {
1729       {'h',"help","help",0},
1730       {'v',"version","version",0},
1731       {'p',"pkg-cache","Dir::Cache::pkgcache",CommandLine::HasArg},
1732       {'s',"src-cache","Dir::Cache::srcpkgcache",CommandLine::HasArg},
1733       {'q',"quiet","quiet",CommandLine::IntLevel},
1734       {'i',"important","APT::Cache::Important",0},
1735       {'f',"full","APT::Cache::ShowFull",0},
1736       {'g',"generate","APT::Cache::Generate",0},
1737       {'a',"all-versions","APT::Cache::AllVersions",0},
1738       {'n',"names-only","APT::Cache::NamesOnly",0},
1739       {0,"all-names","APT::Cache::AllNames",0},
1740       {0,"recurse","APT::Cache::RecurseDepends",0},
1741       {'t',"target-release","APT::Default-Release",CommandLine::HasArg},
1742       {'t',"default-release","APT::Default-Release",CommandLine::HasArg},
1743       {'c',"config-file",0,CommandLine::ConfigFile},
1744       {'o',"option",0,CommandLine::ArbItem},
1745       {0,"installed","APT::Cache::Installed",0},
1746       {0,"pre-depends","APT::Cache::ShowPre-Depends",0},
1747       {0,"depends","APT::Cache::ShowDepends",0},
1748       {0,"recommends","APT::Cache::ShowRecommends",0},
1749       {0,"suggests","APT::Cache::ShowSuggests",0},
1750       {0,"replaces","APT::Cache::ShowReplaces",0},
1751       {0,"breaks","APT::Cache::ShowBreaks",0},
1752       {0,"conflicts","APT::Cache::ShowConflicts",0},
1753       {0,"enhances","APT::Cache::ShowEnhances",0},
1754       {0,0,0,0}};
1755    CommandLine::Dispatch CmdsA[] = {{"help",&ShowHelp},
1756                                     {"gencaches",&GenCaches},
1757                                     {"showsrc",&ShowSrcPackage},
1758                                     {0,0}};
1759    CommandLine::Dispatch CmdsB[] = {{"showpkg",&DumpPackage},
1760                                     {"stats",&Stats},
1761                                     {"dump",&Dump},
1762                                     {"dumpavail",&DumpAvail},
1763                                     {"unmet",&UnMet},
1764                                     {"search",&Search},
1765                                     {"depends",&Depends},
1766                                     {"rdepends",&RDepends},
1767                                     {"dotty",&Dotty},
1768                                     {"xvcg",&XVcg},
1769                                     {"show",&ShowPackage},
1770                                     {"pkgnames",&ShowPkgNames},
1771                                     {"showauto",&ShowAuto},
1772                                     {"policy",&Policy},
1773                                     {"madison",&Madison},
1774                                     {0,0}};
1775
1776    // Set up gettext support
1777    setlocale(LC_ALL,"");
1778    textdomain(PACKAGE);
1779
1780    // Parse the command line and initialize the package library
1781    CommandLine CmdL(Args,_config);
1782    if (pkgInitConfig(*_config) == false ||
1783        CmdL.Parse(argc,argv) == false ||
1784        pkgInitSystem(*_config,_system) == false)
1785    {
1786       _error->DumpErrors();
1787       return 100;
1788    }
1789
1790    // See if the help should be shown
1791    if (_config->FindB("help") == true ||
1792        CmdL.FileSize() == 0)
1793    {
1794       ShowHelp(CmdL);
1795       return 0;
1796    }
1797
1798    // Deal with stdout not being a tty
1799    if (!isatty(STDOUT_FILENO) && _config->FindI("quiet", -1) == -1)
1800       _config->Set("quiet","1");
1801
1802    if (_config->Exists("APT::Cache::Generate") == true)
1803       _config->Set("pkgCacheFile::Generate", _config->FindB("APT::Cache::Generate", true));
1804
1805    if (CmdL.DispatchArg(CmdsA,false) == false && _error->PendingError() == false)
1806       CmdL.DispatchArg(CmdsB);
1807
1808    // Print any errors or warnings found during parsing
1809    bool const Errors = _error->PendingError();
1810    if (_config->FindI("quiet",0) > 0)
1811       _error->DumpErrors();
1812    else
1813       _error->DumpErrors(GlobalError::DEBUG);
1814    return Errors == true ? 100 : 0;
1815 }
1816                                                                         /*}}}*/