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