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    map_ptrloc ID;
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    size_t const descCount = Cache->HeaderP->GroupCount + 1;
1250    ExDescFile *DFList = new ExDescFile[descCount];
1251    memset(DFList,0,sizeof(*DFList) * descCount);
1252
1253    bool PatternMatch[descCount * NumPatterns];
1254    memset(PatternMatch,false,sizeof(PatternMatch));
1255
1256    // Map versions that we want to write out onto the VerList array.
1257    for (pkgCache::GrpIterator G = Cache->GrpBegin(); G.end() == false; ++G)
1258    {
1259       size_t const PatternOffset = G->ID * NumPatterns;
1260       size_t unmatched = 0, matched = 0;
1261       for (unsigned I = 0; I < NumPatterns; ++I)
1262       {
1263          if (PatternMatch[PatternOffset + I] == true)
1264             ++matched;
1265          else if (regexec(&Patterns[I],G.Name(),0,0,0) == 0)
1266             PatternMatch[PatternOffset + I] = true;
1267          else
1268             ++unmatched;
1269       }
1270
1271       // already dealt with this package?
1272       if (matched == NumPatterns)
1273          continue;
1274
1275       // Doing names only, drop any that don't match..
1276       if (NamesOnly == true && unmatched == NumPatterns)
1277          continue;
1278
1279       // Find the proper version to use
1280       pkgCache::PkgIterator P = G.FindPreferredPkg();
1281       if (P.end() == true)
1282          continue;
1283       pkgCache::VerIterator V = Plcy->GetCandidateVer(P);
1284       if (V.end() == false)
1285       {
1286          DFList[G->ID].Df = V.TranslatedDescription().FileList();
1287          DFList[G->ID].ID = G->ID;
1288       }
1289
1290       if (unmatched == NumPatterns)
1291          continue;
1292
1293       // Include all the packages that provide matching names too
1294       for (pkgCache::PrvIterator Prv = P.ProvidesList() ; Prv.end() == false; ++Prv)
1295       {
1296          pkgCache::VerIterator V = Plcy->GetCandidateVer(Prv.OwnerPkg());
1297          if (V.end() == true)
1298             continue;
1299
1300          unsigned long id = Prv.OwnerPkg().Group()->ID;
1301          DFList[id].Df = V.TranslatedDescription().FileList();
1302          DFList[id].ID = id;
1303
1304          size_t const PrvPatternOffset = id * NumPatterns;
1305          for (unsigned I = 0; I < NumPatterns; ++I)
1306             PatternMatch[PrvPatternOffset + I] = PatternMatch[PatternOffset + I];
1307       }
1308    }
1309
1310    LocalitySort(&DFList->Df,Cache->HeaderP->GroupCount,sizeof(*DFList));
1311
1312    // Create the text record parser
1313    pkgRecords Recs(*Cache);
1314    // Iterate over all the version records and check them
1315    for (ExDescFile *J = DFList; J->Df != 0; ++J)
1316    {
1317       pkgRecords::Parser &P = Recs.Lookup(pkgCache::DescFileIterator(*Cache,J->Df));
1318       size_t const PatternOffset = J->ID * NumPatterns;
1319
1320       if (NamesOnly == false)
1321       {
1322          string const LongDesc = P.LongDesc();
1323          for (unsigned I = 0; I < NumPatterns; ++I)
1324          {
1325             if (PatternMatch[PatternOffset + I] == true)
1326                continue;
1327             else if (regexec(&Patterns[I],LongDesc.c_str(),0,0,0) == 0)
1328                PatternMatch[PatternOffset + I] = true;
1329          }
1330       }
1331
1332       bool matchedAll = true;
1333       for (unsigned I = 0; I < NumPatterns; ++I)
1334          if (PatternMatch[PatternOffset + I] == false)
1335          {
1336             matchedAll = false;
1337             break;
1338          }
1339
1340       if (matchedAll == true)
1341       {
1342          if (ShowFull == true)
1343          {
1344             const char *Start;
1345             const char *End;
1346             P.GetRec(Start,End);
1347             fwrite(Start,End-Start,1,stdout);
1348             putc('\n',stdout);
1349          }
1350          else
1351             printf("%s - %s\n",P.Name().c_str(),P.ShortDesc().c_str());
1352       }
1353    }
1354
1355    delete [] DFList;
1356    for (unsigned I = 0; I != NumPatterns; I++)
1357       regfree(&Patterns[I]);
1358    if (ferror(stdout))
1359        return _error->Error("Write to stdout failed");
1360    return true;
1361 }
1362                                                                         /*}}}*/
1363 /* ShowAuto - show automatically installed packages (sorted)            {{{*/
1364 bool ShowAuto(CommandLine &CmdL)
1365 {
1366    pkgCacheFile CacheFile;
1367    pkgCache *Cache = CacheFile.GetPkgCache();
1368    pkgDepCache *DepCache = CacheFile.GetDepCache();
1369    if (unlikely(Cache == NULL || DepCache == NULL))
1370       return false;
1371
1372    std::vector<string> packages;
1373    packages.reserve(Cache->HeaderP->PackageCount / 3);
1374
1375    for (pkgCache::PkgIterator P = Cache->PkgBegin(); P.end() == false; ++P)
1376       if ((*DepCache)[P].Flags & pkgCache::Flag::Auto)
1377          packages.push_back(P.Name());
1378
1379     std::sort(packages.begin(), packages.end());
1380
1381     for (vector<string>::iterator I = packages.begin(); I != packages.end(); ++I)
1382             cout << *I << "\n";
1383
1384    _error->Notice(_("This command is deprecated. Please use 'apt-mark showauto' instead."));
1385    return true;
1386 }
1387                                                                         /*}}}*/
1388 // ShowPackage - Dump the package record to the screen                  /*{{{*/
1389 // ---------------------------------------------------------------------
1390 /* */
1391 bool ShowPackage(CommandLine &CmdL)
1392 {
1393    pkgCacheFile CacheFile;
1394    CacheSetHelperVirtuals helper(true, GlobalError::NOTICE);
1395    APT::VersionList::Version const select = _config->FindB("APT::Cache::AllVersions", true) ?
1396                         APT::VersionList::ALL : APT::VersionList::CANDIDATE;
1397    APT::VersionList const verset = APT::VersionList::FromCommandLine(CacheFile, CmdL.FileList + 1, select, helper);
1398    for (APT::VersionList::const_iterator Ver = verset.begin(); Ver != verset.end(); ++Ver)
1399       if (DisplayRecord(CacheFile, Ver) == false)
1400          return false;
1401
1402    if (verset.empty() == true)
1403    {
1404       if (helper.virtualPkgs.empty() == true)
1405         return _error->Error(_("No packages found"));
1406       else
1407         _error->Notice(_("No packages found"));
1408    }
1409    return true;
1410 }
1411                                                                         /*}}}*/
1412 // ShowPkgNames - Show package names                                    /*{{{*/
1413 // ---------------------------------------------------------------------
1414 /* This does a prefix match on the first argument */
1415 bool ShowPkgNames(CommandLine &CmdL)
1416 {
1417    pkgCacheFile CacheFile;
1418    if (unlikely(CacheFile.BuildCaches(NULL, false) == false))
1419       return false;
1420    pkgCache::GrpIterator I = CacheFile.GetPkgCache()->GrpBegin();
1421    bool const All = _config->FindB("APT::Cache::AllNames","false");
1422
1423    if (CmdL.FileList[1] != 0)
1424    {
1425       for (;I.end() != true; ++I)
1426       {
1427          if (All == false && I->FirstPackage == 0)
1428             continue;
1429          if (I.FindPkg("any")->VersionList == 0)
1430             continue;
1431          if (strncmp(I.Name(),CmdL.FileList[1],strlen(CmdL.FileList[1])) == 0)
1432             cout << I.Name() << endl;
1433       }
1434
1435       return true;
1436    }
1437
1438    // Show all pkgs
1439    for (;I.end() != true; ++I)
1440    {
1441       if (All == false && I->FirstPackage == 0)
1442          continue;
1443       if (I.FindPkg("any")->VersionList == 0)
1444          continue;
1445       cout << I.Name() << endl;
1446    }
1447
1448    return true;
1449 }
1450                                                                         /*}}}*/
1451 // ShowSrcPackage - Show source package records                         /*{{{*/
1452 // ---------------------------------------------------------------------
1453 /* */
1454 bool ShowSrcPackage(CommandLine &CmdL)
1455 {
1456    pkgCacheFile CacheFile;
1457    pkgSourceList *List = CacheFile.GetSourceList();
1458    if (unlikely(List == NULL))
1459       return false;
1460
1461    // Create the text record parsers
1462    pkgSrcRecords SrcRecs(*List);
1463    if (_error->PendingError() == true)
1464       return false;
1465
1466    unsigned found = 0;
1467    for (const char **I = CmdL.FileList + 1; *I != 0; I++)
1468    {
1469       SrcRecs.Restart();
1470
1471       pkgSrcRecords::Parser *Parse;
1472       unsigned found_this = 0;
1473       while ((Parse = SrcRecs.Find(*I,false)) != 0) {
1474         cout << Parse->AsStr() << endl;;
1475         found++;
1476         found_this++;
1477       }
1478       if (found_this == 0) {
1479         _error->Warning(_("Unable to locate package %s"),*I);
1480         continue;
1481       }
1482    }
1483    if (found == 0)
1484       _error->Notice(_("No packages found"));
1485    return true;
1486 }
1487                                                                         /*}}}*/
1488 // Policy - Show the results of the preferences file                    /*{{{*/
1489 // ---------------------------------------------------------------------
1490 /* */
1491 bool Policy(CommandLine &CmdL)
1492 {
1493    pkgCacheFile CacheFile;
1494    pkgCache *Cache = CacheFile.GetPkgCache();
1495    pkgPolicy *Plcy = CacheFile.GetPolicy();
1496    pkgSourceList *SrcList = CacheFile.GetSourceList();
1497    if (unlikely(Cache == NULL || Plcy == NULL || SrcList == NULL))
1498       return false;
1499
1500    /* Should the MultiArchKiller be run to see which pseudo packages for an
1501       arch all package are currently installed? Activating it gives a speed
1502       penality for no real gain beside enhanced debugging, so in general no. */
1503    if (_config->FindB("APT::Cache::Policy::DepCache", false) == true)
1504       CacheFile.GetDepCache();
1505
1506    // Print out all of the package files
1507    if (CmdL.FileList[1] == 0)
1508    {
1509       cout << _("Package files:") << endl;
1510       for (pkgCache::PkgFileIterator F = Cache->FileBegin(); F.end() == false; ++F)
1511       {
1512          // Locate the associated index files so we can derive a description
1513          pkgIndexFile *Indx;
1514          if (SrcList->FindIndex(F,Indx) == false &&
1515              _system->FindIndex(F,Indx) == false)
1516             return _error->Error(_("Cache is out of sync, can't x-ref a package file"));
1517
1518          printf("%4i %s\n",
1519                 Plcy->GetPriority(F),Indx->Describe(true).c_str());
1520
1521          // Print the reference information for the package
1522          string Str = F.RelStr();
1523          if (Str.empty() == false)
1524             printf("     release %s\n",F.RelStr().c_str());
1525          if (F.Site() != 0 && F.Site()[0] != 0)
1526             printf("     origin %s\n",F.Site());
1527       }
1528
1529       // Show any packages have explicit pins
1530       cout << _("Pinned packages:") << endl;
1531       pkgCache::PkgIterator I = Cache->PkgBegin();
1532       for (;I.end() != true; ++I)
1533       {
1534          if (Plcy->GetPriority(I) == 0)
1535             continue;
1536
1537          // Print the package name and the version we are forcing to
1538          cout << "     " << I.FullName(true) << " -> ";
1539
1540          pkgCache::VerIterator V = Plcy->GetMatch(I);
1541          if (V.end() == true)
1542             cout << _("(not found)") << endl;
1543          else
1544             cout << V.VerStr() << endl;
1545       }
1546
1547       return true;
1548    }
1549
1550    char const * const msgInstalled = _("  Installed: ");
1551    char const * const msgCandidate = _("  Candidate: ");
1552    short const InstalledLessCandidate =
1553                 mbstowcs(NULL, msgInstalled, 0) - mbstowcs(NULL, msgCandidate, 0);
1554    short const deepInstalled =
1555                 (InstalledLessCandidate < 0 ? (InstalledLessCandidate*-1) : 0) - 1;
1556    short const deepCandidate =
1557                 (InstalledLessCandidate > 0 ? (InstalledLessCandidate) : 0) - 1;
1558
1559    // Print out detailed information for each package
1560    APT::CacheSetHelper helper(true, GlobalError::NOTICE);
1561    APT::PackageList pkgset = APT::PackageList::FromCommandLine(CacheFile, CmdL.FileList + 1, helper);
1562    for (APT::PackageList::const_iterator Pkg = pkgset.begin(); Pkg != pkgset.end(); ++Pkg)
1563    {
1564       cout << Pkg.FullName(true) << ":" << endl;
1565
1566       // Installed version
1567       cout << msgInstalled << OutputInDepth(deepInstalled, " ");
1568       if (Pkg->CurrentVer == 0)
1569          cout << _("(none)") << endl;
1570       else
1571          cout << Pkg.CurrentVer().VerStr() << endl;
1572
1573       // Candidate Version
1574       cout << msgCandidate << OutputInDepth(deepCandidate, " ");
1575       pkgCache::VerIterator V = Plcy->GetCandidateVer(Pkg);
1576       if (V.end() == true)
1577          cout << _("(none)") << endl;
1578       else
1579          cout << V.VerStr() << endl;
1580
1581       // Pinned version
1582       if (Plcy->GetPriority(Pkg) != 0)
1583       {
1584          cout << _("  Package pin: ");
1585          V = Plcy->GetMatch(Pkg);
1586          if (V.end() == true)
1587             cout << _("(not found)") << endl;
1588          else
1589             cout << V.VerStr() << endl;
1590       }
1591
1592       // Show the priority tables
1593       cout << _("  Version table:") << endl;
1594       for (V = Pkg.VersionList(); V.end() == false; ++V)
1595       {
1596          if (Pkg.CurrentVer() == V)
1597             cout << " *** " << V.VerStr();
1598          else
1599             cout << "     " << V.VerStr();
1600          cout << " " << Plcy->GetPriority(Pkg) << endl;
1601          for (pkgCache::VerFileIterator VF = V.FileList(); VF.end() == false; ++VF)
1602          {
1603             // Locate the associated index files so we can derive a description
1604             pkgIndexFile *Indx;
1605             if (SrcList->FindIndex(VF.File(),Indx) == false &&
1606                 _system->FindIndex(VF.File(),Indx) == false)
1607                return _error->Error(_("Cache is out of sync, can't x-ref a package file"));
1608             printf("       %4i %s\n",Plcy->GetPriority(VF.File()),
1609                    Indx->Describe(true).c_str());
1610          }
1611       }
1612    }
1613
1614    return true;
1615 }
1616                                                                         /*}}}*/
1617 // Madison - Look a bit like katie's madison                            /*{{{*/
1618 // ---------------------------------------------------------------------
1619 /* */
1620 bool Madison(CommandLine &CmdL)
1621 {
1622    pkgCacheFile CacheFile;
1623    pkgSourceList *SrcList = CacheFile.GetSourceList();
1624
1625    if (SrcList == 0)
1626       return false;
1627
1628    // Create the src text record parsers and ignore errors about missing
1629    // deb-src lines that are generated from pkgSrcRecords::pkgSrcRecords
1630    pkgSrcRecords SrcRecs(*SrcList);
1631    if (_error->PendingError() == true)
1632       _error->Discard();
1633
1634    APT::CacheSetHelper helper(true, GlobalError::NOTICE);
1635    for (const char **I = CmdL.FileList + 1; *I != 0; I++)
1636    {
1637       _error->PushToStack();
1638       APT::PackageList pkgset = APT::PackageList::FromString(CacheFile, *I, helper);
1639       for (APT::PackageList::const_iterator Pkg = pkgset.begin(); Pkg != pkgset.end(); ++Pkg)
1640       {
1641          for (pkgCache::VerIterator V = Pkg.VersionList(); V.end() == false; ++V)
1642          {
1643             for (pkgCache::VerFileIterator VF = V.FileList(); VF.end() == false; ++VF)
1644             {
1645 // This might be nice, but wouldn't uniquely identify the source -mdz
1646 //                if (VF.File().Archive() != 0)
1647 //                {
1648 //                   cout << setw(10) << Pkg.Name() << " | " << setw(10) << V.VerStr() << " | "
1649 //                        << VF.File().Archive() << endl;
1650 //                }
1651
1652                // Locate the associated index files so we can derive a description
1653                for (pkgSourceList::const_iterator S = SrcList->begin(); S != SrcList->end(); ++S)
1654                {
1655                     vector<pkgIndexFile *> *Indexes = (*S)->GetIndexFiles();
1656                     for (vector<pkgIndexFile *>::const_iterator IF = Indexes->begin();
1657                          IF != Indexes->end(); ++IF)
1658                     {
1659                          if ((*IF)->FindInCache(*(VF.File().Cache())) == VF.File())
1660                          {
1661                                    cout << setw(10) << Pkg.FullName(true) << " | " << setw(10) << V.VerStr() << " | "
1662                                         << (*IF)->Describe(true) << endl;
1663                          }
1664                     }
1665                }
1666             }
1667          }
1668       }
1669
1670       SrcRecs.Restart();
1671       pkgSrcRecords::Parser *SrcParser;
1672       bool foundSomething = false;
1673       while ((SrcParser = SrcRecs.Find(*I, false)) != 0)
1674       {
1675          foundSomething = true;
1676          // Maybe support Release info here too eventually
1677          cout << setw(10) << SrcParser->Package() << " | "
1678               << setw(10) << SrcParser->Version() << " | "
1679               << SrcParser->Index().Describe(true) << endl;
1680       }
1681       if (foundSomething == true)
1682          _error->RevertToStack();
1683       else
1684          _error->MergeWithStack();
1685    }
1686
1687    return true;
1688 }
1689                                                                         /*}}}*/
1690 // GenCaches - Call the main cache generator                            /*{{{*/
1691 // ---------------------------------------------------------------------
1692 /* */
1693 bool GenCaches(CommandLine &Cmd)
1694 {
1695    OpTextProgress Progress(*_config);
1696
1697    pkgCacheFile CacheFile;
1698    return CacheFile.BuildCaches(&Progress, true);
1699 }
1700                                                                         /*}}}*/
1701 // ShowHelp - Show a help screen                                        /*{{{*/
1702 // ---------------------------------------------------------------------
1703 /* */
1704 bool ShowHelp(CommandLine &Cmd)
1705 {
1706    ioprintf(cout,_("%s %s for %s compiled on %s %s\n"),PACKAGE,PACKAGE_VERSION,
1707             COMMON_ARCH,__DATE__,__TIME__);
1708
1709    if (_config->FindB("version") == true)
1710      return true;
1711
1712    cout <<
1713     _("Usage: apt-cache [options] command\n"
1714       "       apt-cache [options] showpkg pkg1 [pkg2 ...]\n"
1715       "       apt-cache [options] showsrc pkg1 [pkg2 ...]\n"
1716       "\n"
1717       "apt-cache is a low-level tool used to query information\n"
1718       "from APT's binary cache files\n"
1719       "\n"
1720       "Commands:\n"
1721       "   gencaches - Build both the package and source cache\n"
1722       "   showpkg - Show some general information for a single package\n"
1723       "   showsrc - Show source records\n"
1724       "   stats - Show some basic statistics\n"
1725       "   dump - Show the entire file in a terse form\n"
1726       "   dumpavail - Print an available file to stdout\n"
1727       "   unmet - Show unmet dependencies\n"
1728       "   search - Search the package list for a regex pattern\n"
1729       "   show - Show a readable record for the package\n"
1730       "   depends - Show raw dependency information for a package\n"
1731       "   rdepends - Show reverse dependency information for a package\n"
1732       "   pkgnames - List the names of all packages in the system\n"
1733       "   dotty - Generate package graphs for GraphViz\n"
1734       "   xvcg - Generate package graphs for xvcg\n"
1735       "   policy - Show policy settings\n"
1736       "\n"
1737       "Options:\n"
1738       "  -h   This help text.\n"
1739       "  -p=? The package cache.\n"
1740       "  -s=? The source cache.\n"
1741       "  -q   Disable progress indicator.\n"
1742       "  -i   Show only important deps for the unmet command.\n"
1743       "  -c=? Read this configuration file\n"
1744       "  -o=? Set an arbitrary configuration option, eg -o dir::cache=/tmp\n"
1745       "See the apt-cache(8) and apt.conf(5) manual pages for more information.\n");
1746    return true;
1747 }
1748                                                                         /*}}}*/
1749 int main(int argc,const char *argv[])                                   /*{{{*/
1750 {
1751    CommandLine::Args Args[] = {
1752       {'h',"help","help",0},
1753       {'v',"version","version",0},
1754       {'p',"pkg-cache","Dir::Cache::pkgcache",CommandLine::HasArg},
1755       {'s',"src-cache","Dir::Cache::srcpkgcache",CommandLine::HasArg},
1756       {'q',"quiet","quiet",CommandLine::IntLevel},
1757       {'i',"important","APT::Cache::Important",0},
1758       {'f',"full","APT::Cache::ShowFull",0},
1759       {'g',"generate","APT::Cache::Generate",0},
1760       {'a',"all-versions","APT::Cache::AllVersions",0},
1761       {'n',"names-only","APT::Cache::NamesOnly",0},
1762       {0,"all-names","APT::Cache::AllNames",0},
1763       {0,"recurse","APT::Cache::RecurseDepends",0},
1764       {'t',"target-release","APT::Default-Release",CommandLine::HasArg},
1765       {'t',"default-release","APT::Default-Release",CommandLine::HasArg},
1766       {'c',"config-file",0,CommandLine::ConfigFile},
1767       {'o',"option",0,CommandLine::ArbItem},
1768       {0,"installed","APT::Cache::Installed",0},
1769       {0,"pre-depends","APT::Cache::ShowPre-Depends",0},
1770       {0,"depends","APT::Cache::ShowDepends",0},
1771       {0,"recommends","APT::Cache::ShowRecommends",0},
1772       {0,"suggests","APT::Cache::ShowSuggests",0},
1773       {0,"replaces","APT::Cache::ShowReplaces",0},
1774       {0,"breaks","APT::Cache::ShowBreaks",0},
1775       {0,"conflicts","APT::Cache::ShowConflicts",0},
1776       {0,"enhances","APT::Cache::ShowEnhances",0},
1777       {0,0,0,0}};
1778    CommandLine::Dispatch CmdsA[] = {{"help",&ShowHelp},
1779                                     {"gencaches",&GenCaches},
1780                                     {"showsrc",&ShowSrcPackage},
1781                                     {0,0}};
1782    CommandLine::Dispatch CmdsB[] = {{"showpkg",&DumpPackage},
1783                                     {"stats",&Stats},
1784                                     {"dump",&Dump},
1785                                     {"dumpavail",&DumpAvail},
1786                                     {"unmet",&UnMet},
1787                                     {"search",&Search},
1788                                     {"depends",&Depends},
1789                                     {"rdepends",&RDepends},
1790                                     {"dotty",&Dotty},
1791                                     {"xvcg",&XVcg},
1792                                     {"show",&ShowPackage},
1793                                     {"pkgnames",&ShowPkgNames},
1794                                     {"showauto",&ShowAuto},
1795                                     {"policy",&Policy},
1796                                     {"madison",&Madison},
1797                                     {0,0}};
1798
1799    // Set up gettext support
1800    setlocale(LC_ALL,"");
1801    textdomain(PACKAGE);
1802
1803    // Parse the command line and initialize the package library
1804    CommandLine CmdL(Args,_config);
1805    if (pkgInitConfig(*_config) == false ||
1806        CmdL.Parse(argc,argv) == false ||
1807        pkgInitSystem(*_config,_system) == false)
1808    {
1809       _error->DumpErrors();
1810       return 100;
1811    }
1812
1813    // See if the help should be shown
1814    if (_config->FindB("help") == true ||
1815        CmdL.FileSize() == 0)
1816    {
1817       ShowHelp(CmdL);
1818       return 0;
1819    }
1820
1821    // Deal with stdout not being a tty
1822    if (!isatty(STDOUT_FILENO) && _config->FindI("quiet", -1) == -1)
1823       _config->Set("quiet","1");
1824
1825    if (_config->Exists("APT::Cache::Generate") == true)
1826       _config->Set("pkgCacheFile::Generate", _config->FindB("APT::Cache::Generate", true));
1827
1828    if (CmdL.DispatchArg(CmdsA,false) == false && _error->PendingError() == false)
1829       CmdL.DispatchArg(CmdsB);
1830
1831    // Print any errors or warnings found during parsing
1832    bool const Errors = _error->PendingError();
1833    if (_config->FindI("quiet",0) > 0)
1834       _error->DumpErrors();
1835    else
1836       _error->DumpErrors(GlobalError::DEBUG);
1837    return Errors == true ? 100 : 0;
1838 }
1839                                                                         /*}}}*/