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