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 || ReadPinDir(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 Important = _config->FindB("APT::Cache::Important",false);
 559    bool DidSomething;
 560    do
 561    {
 562       DidSomething = false;
 563       for (pkgCache::PkgIterator Pkg = Cache.PkgBegin(); Pkg.end() == false; Pkg++)
 564       {
 565          if (Colours[Pkg->ID] != 1)
 566             continue;
 567          Colours[Pkg->ID] = 2;
 568          DidSomething = true;
 569
 570          pkgCache::VerIterator Ver = Pkg.VersionList();
 571          if (Ver.end() == true)
 572          {
 573             cout << '<' << Pkg.Name() << '>' << endl;
 574             continue;
 575          }
 576
 577          cout << Pkg.Name() << endl;
 578
 579          for (pkgCache::DepIterator D = Ver.DependsList(); D.end() == false; D++)
 580          {
 581             // Important deps only
 582             if (Important == true)
 583                if (D->Type != pkgCache::Dep::PreDepends &&
 584                    D->Type != pkgCache::Dep::Depends)
 585                   continue;
 586
 587             pkgCache::PkgIterator Trg = D.TargetPkg();
 588
 589             if((Installed && Trg->CurrentVer != 0) || !Installed)
 590               {
 591
 592                 if ((D->CompareOp & pkgCache::Dep::Or) == pkgCache::Dep::Or)
 593                   cout << " |";
 594                 else
 595                   cout << "  ";
 596
 597                 // Show the package
 598                 if (Trg->VersionList == 0)
 599                   cout << D.DepType() << ": <" << Trg.Name() << ">" << endl;
 600                 else
 601                   cout << D.DepType() << ": " << Trg.Name() << endl;
 602
 603                 if (Recurse == true)
 604                   Colours[D.TargetPkg()->ID]++;
 605
 606               }
 607
 608             // Display all solutions
 609             SPtrArray<pkgCache::Version *> List = D.AllTargets();
 610             pkgPrioSortList(Cache,List);
 611             for (pkgCache::Version **I = List; *I != 0; I++)
 612             {
 613                pkgCache::VerIterator V(Cache,*I);
 614                if (V != Cache.VerP + V.ParentPkg()->VersionList ||
 615                    V->ParentPkg == D->Package)
 616                   continue;
 617                cout << "    " << V.ParentPkg().Name() << endl;
 618
 619                if (Recurse == true)
 620                   Colours[D.ParentPkg()->ID]++;
 621             }
 622          }
 623       }
 624    }
 625    while (DidSomething == true);
 626
 627    return true;
 628 }
 629                                                                         /*}}}*/
 630 // RDepends - Print out a reverse dependency tree - mbc                 /*{{{*/
 631 // ---------------------------------------------------------------------
 632 /* */
 633 bool RDepends(CommandLine &CmdL)
 634 {
 635    pkgCache &Cache = *GCache;
 636    SPtrArray<unsigned> Colours = new unsigned[Cache.Head().PackageCount];
 637    memset(Colours,0,sizeof(*Colours)*Cache.Head().PackageCount);
 638
 639    for (const char **I = CmdL.FileList + 1; *I != 0; I++)
 640    {
 641       pkgCache::PkgIterator Pkg = Cache.FindPkg(*I);
 642       if (Pkg.end() == true)
 643       {
 644          _error->Warning(_("Unable to locate package %s"),*I);
 645          continue;
 646       }
 647       Colours[Pkg->ID] = 1;
 648    }
 649
 650    bool Recurse = _config->FindB("APT::Cache::RecurseDepends",false);
 651    bool Installed = _config->FindB("APT::Cache::Installed",false);
 652    bool DidSomething;
 653    do
 654    {
 655       DidSomething = false;
 656       for (pkgCache::PkgIterator Pkg = Cache.PkgBegin(); Pkg.end() == false; Pkg++)
 657       {
 658          if (Colours[Pkg->ID] != 1)
 659             continue;
 660          Colours[Pkg->ID] = 2;
 661          DidSomething = true;
 662
 663          pkgCache::VerIterator Ver = Pkg.VersionList();
 664          if (Ver.end() == true)
 665          {
 666             cout << '<' << Pkg.Name() << '>' << endl;
 667             continue;
 668          }
 669
 670          cout << Pkg.Name() << endl;
 671
 672          cout << "Reverse Depends:" << endl;
 673          for (pkgCache::DepIterator D = Pkg.RevDependsList(); D.end() == false; D++)
 674          {
 675             // Show the package
 676             pkgCache::PkgIterator Trg = D.ParentPkg();
 677
 678             if((Installed && Trg->CurrentVer != 0) || !Installed)
 679               {
 680
 681                 if ((D->CompareOp & pkgCache::Dep::Or) == pkgCache::Dep::Or)
 682                   cout << " |";
 683                 else
 684                   cout << "  ";
 685
 686                 if (Trg->VersionList == 0)
 687                   cout << D.DepType() << ": <" << Trg.Name() << ">" << endl;
 688                 else
 689                   cout << Trg.Name() << endl;
 690
 691                 if (Recurse == true)
 692                   Colours[D.ParentPkg()->ID]++;
 693
 694               }
 695
 696             // Display all solutions
 697             SPtrArray<pkgCache::Version *> List = D.AllTargets();
 698             pkgPrioSortList(Cache,List);
 699             for (pkgCache::Version **I = List; *I != 0; I++)
 700             {
 701                pkgCache::VerIterator V(Cache,*I);
 702                if (V != Cache.VerP + V.ParentPkg()->VersionList ||
 703                    V->ParentPkg == D->Package)
 704                   continue;
 705                cout << "    " << V.ParentPkg().Name() << endl;
 706
 707                if (Recurse == true)
 708                   Colours[D.ParentPkg()->ID]++;
 709             }
 710          }
 711       }
 712    }
 713    while (DidSomething == true);
 714
 715    return true;
 716 }
 717                                                                         /*}}}*/
 718 // xvcg - Generate a graph for xvcg                                     /*{{{*/
 719 // ---------------------------------------------------------------------
 720 // Code contributed from Junichi Uekawa <dancer@debian.org> on 20 June 2002.
 721
 722 bool XVcg(CommandLine &CmdL)
 723 {
 724    pkgCache &Cache = *GCache;
 725    bool GivenOnly = _config->FindB("APT::Cache::GivenOnly",false);
 726
 727    /* Normal packages are boxes
 728       Pure Provides are triangles
 729       Mixed are diamonds
 730       rhomb are missing packages*/
 731    const char *Shapes[] = {"ellipse","triangle","box","rhomb"};
 732
 733    /* Initialize the list of packages to show.
 734       1 = To Show
 735       2 = To Show no recurse
 736       3 = Emitted no recurse
 737       4 = Emitted
 738       0 = None */
 739    enum States {None=0, ToShow, ToShowNR, DoneNR, Done};
 740    enum TheFlags {ForceNR=(1<<0)};
 741    unsigned char *Show = new unsigned char[Cache.Head().PackageCount];
 742    unsigned char *Flags = new unsigned char[Cache.Head().PackageCount];
 743    unsigned char *ShapeMap = new unsigned char[Cache.Head().PackageCount];
 744
 745    // Show everything if no arguments given
 746    if (CmdL.FileList[1] == 0)
 747       for (unsigned long I = 0; I != Cache.Head().PackageCount; I++)
 748          Show[I] = ToShow;
 749    else
 750       for (unsigned long I = 0; I != Cache.Head().PackageCount; I++)
 751          Show[I] = None;
 752    memset(Flags,0,sizeof(*Flags)*Cache.Head().PackageCount);
 753
 754    // Map the shapes
 755    for (pkgCache::PkgIterator Pkg = Cache.PkgBegin(); Pkg.end() == false; Pkg++)
 756    {
 757       if (Pkg->VersionList == 0)
 758       {
 759          // Missing
 760          if (Pkg->ProvidesList == 0)
 761             ShapeMap[Pkg->ID] = 0;
 762          else
 763             ShapeMap[Pkg->ID] = 1;
 764       }
 765       else
 766       {
 767          // Normal
 768          if (Pkg->ProvidesList == 0)
 769             ShapeMap[Pkg->ID] = 2;
 770          else
 771             ShapeMap[Pkg->ID] = 3;
 772       }
 773    }
 774
 775    // Load the list of packages from the command line into the show list
 776    for (const char **I = CmdL.FileList + 1; *I != 0; I++)
 777    {
 778       // Process per-package flags
 779       string P = *I;
 780       bool Force = false;
 781       if (P.length() > 3)
 782       {
 783          if (P.end()[-1] == '^')
 784          {
 785             Force = true;
 786             P.erase(P.end()-1);
 787          }
 788
 789          if (P.end()[-1] == ',')
 790             P.erase(P.end()-1);
 791       }
 792
 793       // Locate the package
 794       pkgCache::PkgIterator Pkg = Cache.FindPkg(P);
 795       if (Pkg.end() == true)
 796       {
 797          _error->Warning(_("Unable to locate package %s"),*I);
 798          continue;
 799       }
 800       Show[Pkg->ID] = ToShow;
 801
 802       if (Force == true)
 803          Flags[Pkg->ID] |= ForceNR;
 804    }
 805
 806    // Little header
 807    cout << "graph: { title: \"packages\"" << endl <<
 808      "xmax: 700 ymax: 700 x: 30 y: 30" << endl <<
 809      "layout_downfactor: 8" << endl;
 810
 811    bool Act = true;
 812    while (Act == true)
 813    {
 814       Act = false;
 815       for (pkgCache::PkgIterator Pkg = Cache.PkgBegin(); Pkg.end() == false; Pkg++)
 816       {
 817          // See we need to show this package
 818          if (Show[Pkg->ID] == None || Show[Pkg->ID] >= DoneNR)
 819             continue;
 820
 821          //printf ("node: { title: \"%s\" label: \"%s\" }\n", Pkg.Name(), Pkg.Name());
 822
 823          // Colour as done
 824          if (Show[Pkg->ID] == ToShowNR || (Flags[Pkg->ID] & ForceNR) == ForceNR)
 825          {
 826             // Pure Provides and missing packages have no deps!
 827             if (ShapeMap[Pkg->ID] == 0 || ShapeMap[Pkg->ID] == 1)
 828                Show[Pkg->ID] = Done;
 829             else
 830                Show[Pkg->ID] = DoneNR;
 831          }
 832          else
 833             Show[Pkg->ID] = Done;
 834          Act = true;
 835
 836          // No deps to map out
 837          if (Pkg->VersionList == 0 || Show[Pkg->ID] == DoneNR)
 838             continue;
 839
 840          pkgCache::VerIterator Ver = Pkg.VersionList();
 841          for (pkgCache::DepIterator D = Ver.DependsList(); D.end() == false; D++)
 842          {
 843             // See if anything can meet this dep
 844             // Walk along the actual package providing versions
 845             bool Hit = false;
 846             pkgCache::PkgIterator DPkg = D.TargetPkg();
 847             for (pkgCache::VerIterator I = DPkg.VersionList();
 848                       I.end() == false && Hit == false; I++)
 849             {
 850                if (Cache.VS->CheckDep(I.VerStr(),D->CompareOp,D.TargetVer()) == true)
 851                   Hit = true;
 852             }
 853
 854             // Follow all provides
 855             for (pkgCache::PrvIterator I = DPkg.ProvidesList();
 856                       I.end() == false && Hit == false; I++)
 857             {
 858                if (Cache.VS->CheckDep(I.ProvideVersion(),D->CompareOp,D.TargetVer()) == false)
 859                   Hit = true;
 860             }
 861
 862
 863             // Only graph critical deps
 864             if (D.IsCritical() == true)
 865             {
 866                printf ("edge: { sourcename: \"%s\" targetname: \"%s\" class: 2 ",Pkg.Name(), D.TargetPkg().Name() );
 867
 868                // Colour the node for recursion
 869                if (Show[D.TargetPkg()->ID] <= DoneNR)
 870                {
 871                   /* If a conflicts does not meet anything in the database
 872                      then show the relation but do not recurse */
 873                   if (Hit == false &&
 874                       (D->Type == pkgCache::Dep::Conflicts ||
 875                        D->Type == pkgCache::Dep::DpkgBreaks ||
 876                        D->Type == pkgCache::Dep::Obsoletes))
 877                   {
 878                      if (Show[D.TargetPkg()->ID] == None &&
 879                          Show[D.TargetPkg()->ID] != ToShow)
 880                         Show[D.TargetPkg()->ID] = ToShowNR;
 881                   }
 882                   else
 883                   {
 884                      if (GivenOnly == true && Show[D.TargetPkg()->ID] != ToShow)
 885                         Show[D.TargetPkg()->ID] = ToShowNR;
 886                      else
 887                         Show[D.TargetPkg()->ID] = ToShow;
 888                   }
 889                }
 890
 891                // Edge colour
 892                switch(D->Type)
 893                {
 894                   case pkgCache::Dep::Conflicts:
 895                     printf("label: \"conflicts\" color: lightgreen }\n");
 896                     break;
 897                   case pkgCache::Dep::DpkgBreaks:
 898                     printf("label: \"breaks\" color: lightgreen }\n");
 899                     break;
 900                   case pkgCache::Dep::Obsoletes:
 901                     printf("label: \"obsoletes\" color: lightgreen }\n");
 902                     break;
 903
 904                   case pkgCache::Dep::PreDepends:
 905                     printf("label: \"predepends\" color: blue }\n");
 906                     break;
 907
 908                   default:
 909                     printf("}\n");
 910                   break;
 911                }
 912             }
 913          }
 914       }
 915    }
 916
 917    /* Draw the box colours after the fact since we can not tell what colour
 918       they should be until everything is finished drawing */
 919    for (pkgCache::PkgIterator Pkg = Cache.PkgBegin(); Pkg.end() == false; Pkg++)
 920    {
 921       if (Show[Pkg->ID] < DoneNR)
 922          continue;
 923
 924       if (Show[Pkg->ID] == DoneNR)
 925          printf("node: { title: \"%s\" label: \"%s\" color: orange shape: %s }\n", Pkg.Name(), Pkg.Name(),
 926                 Shapes[ShapeMap[Pkg->ID]]);
 927       else
 928         printf("node: { title: \"%s\" label: \"%s\" shape: %s }\n", Pkg.Name(), Pkg.Name(),
 929                 Shapes[ShapeMap[Pkg->ID]]);
 930
 931    }
 932
 933    delete[] Show;
 934    delete[] Flags;
 935    delete[] ShapeMap;
 936
 937    printf("}\n");
 938    return true;
 939 }
 940                                                                         /*}}}*/
 941 // Dotty - Generate a graph for Dotty                                   /*{{{*/
 942 // ---------------------------------------------------------------------
 943 /* Dotty is the graphvis program for generating graphs. It is a fairly
 944    simple queuing algorithm that just writes dependencies and nodes.
 945    http://www.research.att.com/sw/tools/graphviz/ */
 946 bool Dotty(CommandLine &CmdL)
 947 {
 948    pkgCache &Cache = *GCache;
 949    bool GivenOnly = _config->FindB("APT::Cache::GivenOnly",false);
 950
 951    /* Normal packages are boxes
 952       Pure Provides are triangles
 953       Mixed are diamonds
 954       Hexagons are missing packages*/
 955    const char *Shapes[] = {"hexagon","triangle","box","diamond"};
 956
 957    /* Initialize the list of packages to show.
 958       1 = To Show
 959       2 = To Show no recurse
 960       3 = Emitted no recurse
 961       4 = Emitted
 962       0 = None */
 963    enum States {None=0, ToShow, ToShowNR, DoneNR, Done};
 964    enum TheFlags {ForceNR=(1<<0)};
 965    unsigned char *Show = new unsigned char[Cache.Head().PackageCount];
 966    unsigned char *Flags = new unsigned char[Cache.Head().PackageCount];
 967    unsigned char *ShapeMap = new unsigned char[Cache.Head().PackageCount];
 968
 969    // Show everything if no arguments given
 970    if (CmdL.FileList[1] == 0)
 971       for (unsigned long I = 0; I != Cache.Head().PackageCount; I++)
 972          Show[I] = ToShow;
 973    else
 974       for (unsigned long I = 0; I != Cache.Head().PackageCount; I++)
 975          Show[I] = None;
 976    memset(Flags,0,sizeof(*Flags)*Cache.Head().PackageCount);
 977
 978    // Map the shapes
 979    for (pkgCache::PkgIterator Pkg = Cache.PkgBegin(); Pkg.end() == false; Pkg++)
 980    {
 981       if (Pkg->VersionList == 0)
 982       {
 983          // Missing
 984          if (Pkg->ProvidesList == 0)
 985             ShapeMap[Pkg->ID] = 0;
 986          else
 987             ShapeMap[Pkg->ID] = 1;
 988       }
 989       else
 990       {
 991          // Normal
 992          if (Pkg->ProvidesList == 0)
 993             ShapeMap[Pkg->ID] = 2;
 994          else
 995             ShapeMap[Pkg->ID] = 3;
 996       }
 997    }
 998
 999    // Load the list of packages from the command line into the show list
1000    for (const char **I = CmdL.FileList + 1; *I != 0; I++)
1001    {
1002       // Process per-package flags
1003       string P = *I;
1004       bool Force = false;
1005       if (P.length() > 3)
1006       {
1007          if (P.end()[-1] == '^')
1008          {
1009             Force = true;
1010             P.erase(P.end()-1);
1011          }
1012
1013          if (P.end()[-1] == ',')
1014             P.erase(P.end()-1);
1015       }
1016
1017       // Locate the package
1018       pkgCache::PkgIterator Pkg = Cache.FindPkg(P);
1019       if (Pkg.end() == true)
1020       {
1021          _error->Warning(_("Unable to locate package %s"),*I);
1022          continue;
1023       }
1024       Show[Pkg->ID] = ToShow;
1025
1026       if (Force == true)
1027          Flags[Pkg->ID] |= ForceNR;
1028    }
1029
1030    // Little header
1031    printf("digraph packages {\n");
1032    printf("concentrate=true;\n");
1033    printf("size=\"30,40\";\n");
1034
1035    bool Act = true;
1036    while (Act == true)
1037    {
1038       Act = false;
1039       for (pkgCache::PkgIterator Pkg = Cache.PkgBegin(); Pkg.end() == false; Pkg++)
1040       {
1041          // See we need to show this package
1042          if (Show[Pkg->ID] == None || Show[Pkg->ID] >= DoneNR)
1043             continue;
1044
1045          // Colour as done
1046          if (Show[Pkg->ID] == ToShowNR || (Flags[Pkg->ID] & ForceNR) == ForceNR)
1047          {
1048             // Pure Provides and missing packages have no deps!
1049             if (ShapeMap[Pkg->ID] == 0 || ShapeMap[Pkg->ID] == 1)
1050                Show[Pkg->ID] = Done;
1051             else
1052                Show[Pkg->ID] = DoneNR;
1053          }
1054          else
1055             Show[Pkg->ID] = Done;
1056          Act = true;
1057
1058          // No deps to map out
1059          if (Pkg->VersionList == 0 || Show[Pkg->ID] == DoneNR)
1060             continue;
1061
1062          pkgCache::VerIterator Ver = Pkg.VersionList();
1063          for (pkgCache::DepIterator D = Ver.DependsList(); D.end() == false; D++)
1064          {
1065             // See if anything can meet this dep
1066             // Walk along the actual package providing versions
1067             bool Hit = false;
1068             pkgCache::PkgIterator DPkg = D.TargetPkg();
1069             for (pkgCache::VerIterator I = DPkg.VersionList();
1070                       I.end() == false && Hit == false; I++)
1071             {
1072                if (Cache.VS->CheckDep(I.VerStr(),D->CompareOp,D.TargetVer()) == true)
1073                   Hit = true;
1074             }
1075
1076             // Follow all provides
1077             for (pkgCache::PrvIterator I = DPkg.ProvidesList();
1078                       I.end() == false && Hit == false; I++)
1079             {
1080                if (Cache.VS->CheckDep(I.ProvideVersion(),D->CompareOp,D.TargetVer()) == false)
1081                   Hit = true;
1082             }
1083
1084             // Only graph critical deps
1085             if (D.IsCritical() == true)
1086             {
1087                printf("\"%s\" -> \"%s\"",Pkg.Name(),D.TargetPkg().Name());
1088
1089                // Colour the node for recursion
1090                if (Show[D.TargetPkg()->ID] <= DoneNR)
1091                {
1092                   /* If a conflicts does not meet anything in the database
1093                      then show the relation but do not recurse */
1094                   if (Hit == false &&
1095                       (D->Type == pkgCache::Dep::Conflicts ||
1096                        D->Type == pkgCache::Dep::Obsoletes))
1097                   {
1098                      if (Show[D.TargetPkg()->ID] == None &&
1099                          Show[D.TargetPkg()->ID] != ToShow)
1100                         Show[D.TargetPkg()->ID] = ToShowNR;
1101                   }
1102                   else
1103                   {
1104                      if (GivenOnly == true && Show[D.TargetPkg()->ID] != ToShow)
1105                         Show[D.TargetPkg()->ID] = ToShowNR;
1106                      else
1107                         Show[D.TargetPkg()->ID] = ToShow;
1108                   }
1109                }
1110
1111                // Edge colour
1112                switch(D->Type)
1113                {
1114                   case pkgCache::Dep::Conflicts:
1115                   case pkgCache::Dep::Obsoletes:
1116                   printf("[color=springgreen];\n");
1117                   break;
1118
1119                   case pkgCache::Dep::PreDepends:
1120                   printf("[color=blue];\n");
1121                   break;
1122
1123                   default:
1124                   printf(";\n");
1125                   break;
1126                }
1127             }
1128          }
1129       }
1130    }
1131
1132    /* Draw the box colours after the fact since we can not tell what colour
1133       they should be until everything is finished drawing */
1134    for (pkgCache::PkgIterator Pkg = Cache.PkgBegin(); Pkg.end() == false; Pkg++)
1135    {
1136       if (Show[Pkg->ID] < DoneNR)
1137          continue;
1138
1139       // Orange box for early recursion stoppage
1140       if (Show[Pkg->ID] == DoneNR)
1141          printf("\"%s\" [color=orange,shape=%s];\n",Pkg.Name(),
1142                 Shapes[ShapeMap[Pkg->ID]]);
1143       else
1144          printf("\"%s\" [shape=%s];\n",Pkg.Name(),
1145                 Shapes[ShapeMap[Pkg->ID]]);
1146    }
1147
1148    printf("}\n");
1149    return true;
1150 }
1151                                                                         /*}}}*/
1152 // DoAdd - Perform an adding operation                                  /*{{{*/
1153 // ---------------------------------------------------------------------
1154 /* */
1155 bool DoAdd(CommandLine &CmdL)
1156 {
1157    return _error->Error("Unimplemented");
1158 #if 0
1159    // Make sure there is at least one argument
1160    if (CmdL.FileSize() <= 1)
1161       return _error->Error("You must give at least one file name");
1162
1163    // Open the cache
1164    FileFd CacheF(_config->FindFile("Dir::Cache::pkgcache"),FileFd::WriteAny);
1165    if (_error->PendingError() == true)
1166       return false;
1167
1168    DynamicMMap Map(CacheF,MMap::Public);
1169    if (_error->PendingError() == true)
1170       return false;
1171
1172    OpTextProgress Progress(*_config);
1173    pkgCacheGenerator Gen(Map,Progress);
1174    if (_error->PendingError() == true)
1175       return false;
1176
1177    unsigned long Length = CmdL.FileSize() - 1;
1178    for (const char **I = CmdL.FileList + 1; *I != 0; I++)
1179    {
1180       Progress.OverallProgress(I - CmdL.FileList,Length,1,"Generating cache");
1181       Progress.SubProgress(Length);
1182
1183       // Do the merge
1184       FileFd TagF(*I,FileFd::ReadOnly);
1185       debListParser Parser(TagF);
1186       if (_error->PendingError() == true)
1187          return _error->Error("Problem opening %s",*I);
1188
1189       if (Gen.SelectFile(*I,"") == false)
1190          return _error->Error("Problem with SelectFile");
1191
1192       if (Gen.MergeList(Parser) == false)
1193          return _error->Error("Problem with MergeList");
1194    }
1195
1196    Progress.Done();
1197    GCache = &Gen.GetCache();
1198    Stats(CmdL);
1199
1200    return true;
1201 #endif
1202 }
1203                                                                         /*}}}*/
1204 // DisplayRecord - Displays the complete record for the package         /*{{{*/
1205 // ---------------------------------------------------------------------
1206 /* This displays the package record from the proper package index file.
1207    It is not used by DumpAvail for performance reasons. */
1208 bool DisplayRecord(pkgCache::VerIterator V)
1209 {
1210    // Find an appropriate file
1211    pkgCache::VerFileIterator Vf = V.FileList();
1212    for (; Vf.end() == false; Vf++)
1213       if ((Vf.File()->Flags & pkgCache::Flag::NotSource) == 0)
1214          break;
1215    if (Vf.end() == true)
1216       Vf = V.FileList();
1217
1218    // Check and load the package list file
1219    pkgCache::PkgFileIterator I = Vf.File();
1220    if (I.IsOk() == false)
1221       return _error->Error(_("Package file %s is out of sync."),I.FileName());
1222
1223    FileFd PkgF(I.FileName(),FileFd::ReadOnly);
1224    if (_error->PendingError() == true)
1225       return false;
1226
1227    // Read the record
1228    unsigned char *Buffer = new unsigned char[GCache->HeaderP->MaxVerFileSize+1];
1229    Buffer[V.FileList()->Size] = '\n';
1230    if (PkgF.Seek(V.FileList()->Offset) == false ||
1231        PkgF.Read(Buffer,V.FileList()->Size) == false)
1232    {
1233       delete [] Buffer;
1234       return false;
1235    }
1236
1237    // Get a pointer to start of Description field
1238    const unsigned char *DescP = (unsigned char*)strstr((char*)Buffer, "Description:");
1239
1240    // Write all but Description
1241    if (fwrite(Buffer,1,DescP - Buffer,stdout) < (size_t)(DescP - Buffer))
1242    {
1243       delete [] Buffer;
1244       return false;
1245    }
1246
1247    // Show the right description
1248    pkgRecords Recs(*GCache);
1249    pkgCache::DescIterator Desc = V.TranslatedDescription();
1250    pkgRecords::Parser &P = Recs.Lookup(Desc.FileList());
1251    cout << "Description" << ( (strcmp(Desc.LanguageCode(),"") != 0) ? "-" : "" ) << Desc.LanguageCode() << ": " << P.LongDesc();
1252
1253    // Find the first field after the description (if there is any)
1254    for(DescP++;DescP != &Buffer[V.FileList()->Size];DescP++)
1255    {
1256       if(*DescP == '\n' && *(DescP+1) != ' ')
1257       {
1258          // write the rest of the buffer
1259          const unsigned char *end=&Buffer[V.FileList()->Size];
1260          if (fwrite(DescP,1,end-DescP,stdout) < (size_t)(end-DescP))
1261          {
1262             delete [] Buffer;
1263             return false;
1264          }
1265
1266          break;
1267       }
1268    }
1269    // write a final newline (after the description)
1270    cout<<endl;
1271    delete [] Buffer;
1272
1273    return true;
1274 }
1275                                                                         /*}}}*/
1276
1277 struct ExDescFile
1278 {
1279    pkgCache::DescFile *Df;
1280    bool NameMatch;
1281 };
1282
1283 // Search - Perform a search                                            /*{{{*/
1284 // ---------------------------------------------------------------------
1285 /* This searches the package names and package descriptions for a pattern */
1286 bool Search(CommandLine &CmdL)
1287 {
1288    pkgCache &Cache = *GCache;
1289    bool ShowFull = _config->FindB("APT::Cache::ShowFull",false);
1290    bool NamesOnly = _config->FindB("APT::Cache::NamesOnly",false);
1291    unsigned NumPatterns = CmdL.FileSize() -1;
1292
1293    pkgDepCache::Policy Plcy;
1294
1295    // Make sure there is at least one argument
1296    if (NumPatterns < 1)
1297       return _error->Error(_("You must give exactly one pattern"));
1298
1299    // Compile the regex pattern
1300    regex_t *Patterns = new regex_t[NumPatterns];
1301    memset(Patterns,0,sizeof(*Patterns)*NumPatterns);
1302    for (unsigned I = 0; I != NumPatterns; I++)
1303    {
1304       if (regcomp(&Patterns[I],CmdL.FileList[I+1],REG_EXTENDED | REG_ICASE |
1305                   REG_NOSUB) != 0)
1306       {
1307          for (; I != 0; I--)
1308             regfree(&Patterns[I]);
1309          return _error->Error("Regex compilation error");
1310       }
1311    }
1312
1313    // Create the text record parser
1314    pkgRecords Recs(Cache);
1315    if (_error->PendingError() == true)
1316    {
1317       for (unsigned I = 0; I != NumPatterns; I++)
1318          regfree(&Patterns[I]);
1319       return false;
1320    }
1321
1322    ExDescFile *DFList = new ExDescFile[Cache.HeaderP->PackageCount+1];
1323    memset(DFList,0,sizeof(*DFList)*Cache.HeaderP->PackageCount+1);
1324
1325    // Map versions that we want to write out onto the VerList array.
1326    for (pkgCache::PkgIterator P = Cache.PkgBegin(); P.end() == false; P++)
1327    {
1328       DFList[P->ID].NameMatch = NumPatterns != 0;
1329       for (unsigned I = 0; I != NumPatterns; I++)
1330       {
1331          if (regexec(&Patterns[I],P.Name(),0,0,0) == 0)
1332             DFList[P->ID].NameMatch &= true;
1333          else
1334             DFList[P->ID].NameMatch = false;
1335       }
1336
1337       // Doing names only, drop any that dont match..
1338       if (NamesOnly == true && DFList[P->ID].NameMatch == false)
1339          continue;
1340
1341       // Find the proper version to use.
1342       pkgCache::VerIterator V = Plcy.GetCandidateVer(P);
1343       if (V.end() == false)
1344          DFList[P->ID].Df = V.DescriptionList().FileList();
1345    }
1346
1347    // Include all the packages that provide matching names too
1348    for (pkgCache::PkgIterator P = Cache.PkgBegin(); P.end() == false; P++)
1349    {
1350       if (DFList[P->ID].NameMatch == false)
1351          continue;
1352
1353       for (pkgCache::PrvIterator Prv = P.ProvidesList() ; Prv.end() == false; Prv++)
1354       {
1355          pkgCache::VerIterator V = Plcy.GetCandidateVer(Prv.OwnerPkg());
1356          if (V.end() == false)
1357          {
1358             DFList[Prv.OwnerPkg()->ID].Df = V.DescriptionList().FileList();
1359             DFList[Prv.OwnerPkg()->ID].NameMatch = true;
1360          }
1361       }
1362    }
1363
1364    LocalitySort(&DFList->Df,Cache.HeaderP->PackageCount,sizeof(*DFList));
1365
1366    // Iterate over all the version records and check them
1367    for (ExDescFile *J = DFList; J->Df != 0; J++)
1368    {
1369       pkgRecords::Parser &P = Recs.Lookup(pkgCache::DescFileIterator(Cache,J->Df));
1370
1371       bool Match = true;
1372       if (J->NameMatch == false)
1373       {
1374          string LongDesc = P.LongDesc();
1375          Match = NumPatterns != 0;
1376          for (unsigned I = 0; I != NumPatterns; I++)
1377          {
1378             if (regexec(&Patterns[I],LongDesc.c_str(),0,0,0) == 0)
1379                Match &= true;
1380             else
1381                Match = false;
1382          }
1383       }
1384
1385       if (Match == true)
1386       {
1387          if (ShowFull == true)
1388          {
1389             const char *Start;
1390             const char *End;
1391             P.GetRec(Start,End);
1392             fwrite(Start,End-Start,1,stdout);
1393             putc('\n',stdout);
1394          }
1395          else
1396             printf("%s - %s\n",P.Name().c_str(),P.ShortDesc().c_str());
1397       }
1398    }
1399
1400    delete [] DFList;
1401    for (unsigned I = 0; I != NumPatterns; I++)
1402       regfree(&Patterns[I]);
1403    if (ferror(stdout))
1404        return _error->Error("Write to stdout failed");
1405    return true;
1406 }
1407                                                                         /*}}}*/
1408 // ShowPackage - Dump the package record to the screen                  /*{{{*/
1409 // ---------------------------------------------------------------------
1410 /* */
1411 bool ShowPackage(CommandLine &CmdL)
1412 {
1413    pkgCache &Cache = *GCache;
1414    pkgDepCache::Policy Plcy;
1415
1416    unsigned found = 0;
1417
1418    for (const char **I = CmdL.FileList + 1; *I != 0; I++)
1419    {
1420       pkgCache::PkgIterator Pkg = Cache.FindPkg(*I);
1421       if (Pkg.end() == true)
1422       {
1423          _error->Warning(_("Unable to locate package %s"),*I);
1424          continue;
1425       }
1426
1427       ++found;
1428
1429       // Find the proper version to use.
1430       if (_config->FindB("APT::Cache::AllVersions","true") == true)
1431       {
1432          pkgCache::VerIterator V;
1433          for (V = Pkg.VersionList(); V.end() == false; V++)
1434          {
1435             if (DisplayRecord(V) == false)
1436                return false;
1437          }
1438       }
1439       else
1440       {
1441          pkgCache::VerIterator V = Plcy.GetCandidateVer(Pkg);
1442          if (V.end() == true || V.FileList().end() == true)
1443             continue;
1444          if (DisplayRecord(V) == false)
1445             return false;
1446       }
1447    }
1448
1449    if (found > 0)
1450         return true;
1451    return _error->Error(_("No packages found"));
1452 }
1453                                                                         /*}}}*/
1454 // ShowPkgNames - Show package names                                    /*{{{*/
1455 // ---------------------------------------------------------------------
1456 /* This does a prefix match on the first argument */
1457 bool ShowPkgNames(CommandLine &CmdL)
1458 {
1459    pkgCache &Cache = *GCache;
1460    pkgCache::PkgIterator I = Cache.PkgBegin();
1461    bool All = _config->FindB("APT::Cache::AllNames","false");
1462
1463    if (CmdL.FileList[1] != 0)
1464    {
1465       for (;I.end() != true; I++)
1466       {
1467          if (All == false && I->VersionList == 0)
1468             continue;
1469
1470          if (strncmp(I.Name(),CmdL.FileList[1],strlen(CmdL.FileList[1])) == 0)
1471             cout << I.Name() << endl;
1472       }
1473
1474       return true;
1475    }
1476
1477    // Show all pkgs
1478    for (;I.end() != true; I++)
1479    {
1480       if (All == false && I->VersionList == 0)
1481          continue;
1482       cout << I.Name() << endl;
1483    }
1484
1485    return true;
1486 }
1487                                                                         /*}}}*/
1488 // ShowSrcPackage - Show source package records                         /*{{{*/
1489 // ---------------------------------------------------------------------
1490 /* */
1491 bool ShowSrcPackage(CommandLine &CmdL)
1492 {
1493    pkgSourceList List;
1494    List.ReadMainList();
1495
1496    // Create the text record parsers
1497    pkgSrcRecords SrcRecs(List);
1498    if (_error->PendingError() == true)
1499       return false;
1500
1501    for (const char **I = CmdL.FileList + 1; *I != 0; I++)
1502    {
1503       SrcRecs.Restart();
1504
1505       pkgSrcRecords::Parser *Parse;
1506       while ((Parse = SrcRecs.Find(*I,false)) != 0)
1507          cout << Parse->AsStr() << endl;;
1508    }
1509    return true;
1510 }
1511                                                                         /*}}}*/
1512 // Policy - Show the results of the preferences file                    /*{{{*/
1513 // ---------------------------------------------------------------------
1514 /* */
1515 bool Policy(CommandLine &CmdL)
1516 {
1517    if (SrcList == 0)
1518       return _error->Error("Generate must be enabled for this function");
1519
1520    pkgCache &Cache = *GCache;
1521    pkgPolicy Plcy(&Cache);
1522    if (ReadPinFile(Plcy) == false || ReadPinDir(Plcy) == false)
1523       return false;
1524
1525    // Print out all of the package files
1526    if (CmdL.FileList[1] == 0)
1527    {
1528       cout << _("Package files:") << endl;
1529       for (pkgCache::PkgFileIterator F = Cache.FileBegin(); F.end() == false; F++)
1530       {
1531          // Locate the associated index files so we can derive a description
1532          pkgIndexFile *Indx;
1533          if (SrcList->FindIndex(F,Indx) == false &&
1534              _system->FindIndex(F,Indx) == false)
1535             return _error->Error(_("Cache is out of sync, can't x-ref a package file"));
1536
1537          printf("%4i %s\n",
1538                 Plcy.GetPriority(F),Indx->Describe(true).c_str());
1539
1540          // Print the reference information for the package
1541          string Str = F.RelStr();
1542          if (Str.empty() == false)
1543             printf("     release %s\n",F.RelStr().c_str());
1544          if (F.Site() != 0 && F.Site()[0] != 0)
1545             printf("     origin %s\n",F.Site());
1546       }
1547
1548       // Show any packages have explicit pins
1549       cout << _("Pinned packages:") << endl;
1550       pkgCache::PkgIterator I = Cache.PkgBegin();
1551       for (;I.end() != true; I++)
1552       {
1553          if (Plcy.GetPriority(I) == 0)
1554             continue;
1555
1556          // Print the package name and the version we are forcing to
1557          cout << "     " << I.Name() << " -> ";
1558
1559          pkgCache::VerIterator V = Plcy.GetMatch(I);
1560          if (V.end() == true)
1561             cout << _("(not found)") << endl;
1562          else
1563             cout << V.VerStr() << endl;
1564       }
1565
1566       return true;
1567    }
1568
1569    // Print out detailed information for each package
1570    for (const char **I = CmdL.FileList + 1; *I != 0; I++)
1571    {
1572       pkgCache::PkgIterator Pkg = Cache.FindPkg(*I);
1573       if (Pkg.end() == true)
1574       {
1575          _error->Warning(_("Unable to locate package %s"),*I);
1576          continue;
1577       }
1578
1579       cout << Pkg.Name() << ":" << endl;
1580
1581       // Installed version
1582       cout << _("  Installed: ");
1583       if (Pkg->CurrentVer == 0)
1584          cout << _("(none)") << endl;
1585       else
1586          cout << Pkg.CurrentVer().VerStr() << endl;
1587
1588       // Candidate Version
1589       cout << _("  Candidate: ");
1590       pkgCache::VerIterator V = Plcy.GetCandidateVer(Pkg);
1591       if (V.end() == true)
1592          cout << _("(none)") << endl;
1593       else
1594          cout << V.VerStr() << endl;
1595
1596       // Pinned version
1597       if (Plcy.GetPriority(Pkg) != 0)
1598       {
1599          cout << _("  Package pin: ");
1600          V = Plcy.GetMatch(Pkg);
1601          if (V.end() == true)
1602             cout << _("(not found)") << endl;
1603          else
1604             cout << V.VerStr() << endl;
1605       }
1606
1607       // Show the priority tables
1608       cout << _("  Version table:") << endl;
1609       for (V = Pkg.VersionList(); V.end() == false; V++)
1610       {
1611          if (Pkg.CurrentVer() == V)
1612             cout << " *** " << V.VerStr();
1613          else
1614             cout << "     " << V.VerStr();
1615          cout << " " << Plcy.GetPriority(Pkg) << endl;
1616          for (pkgCache::VerFileIterator VF = V.FileList(); VF.end() == false; VF++)
1617          {
1618             // Locate the associated index files so we can derive a description
1619             pkgIndexFile *Indx;
1620             if (SrcList->FindIndex(VF.File(),Indx) == false &&
1621                 _system->FindIndex(VF.File(),Indx) == false)
1622                return _error->Error(_("Cache is out of sync, can't x-ref a package file"));
1623             printf("       %4i %s\n",Plcy.GetPriority(VF.File()),
1624                    Indx->Describe(true).c_str());
1625          }
1626       }
1627    }
1628
1629    return true;
1630 }
1631                                                                         /*}}}*/
1632 // Madison - Look a bit like katie's madison                            /*{{{*/
1633 // ---------------------------------------------------------------------
1634 /* */
1635 bool Madison(CommandLine &CmdL)
1636 {
1637    if (SrcList == 0)
1638       return _error->Error("Generate must be enabled for this function");
1639
1640    SrcList->ReadMainList();
1641
1642    pkgCache &Cache = *GCache;
1643
1644    // Create the src text record parsers and ignore errors about missing
1645    // deb-src lines that are generated from pkgSrcRecords::pkgSrcRecords
1646    pkgSrcRecords SrcRecs(*SrcList);
1647    if (_error->PendingError() == true)
1648       _error->Discard();
1649
1650    for (const char **I = CmdL.FileList + 1; *I != 0; I++)
1651    {
1652       pkgCache::PkgIterator Pkg = Cache.FindPkg(*I);
1653
1654       if (Pkg.end() == false)
1655       {
1656          for (pkgCache::VerIterator V = Pkg.VersionList(); V.end() == false; V++)
1657          {
1658             for (pkgCache::VerFileIterator VF = V.FileList(); VF.end() == false; VF++)
1659             {
1660 // This might be nice, but wouldn't uniquely identify the source -mdz
1661 //                if (VF.File().Archive() != 0)
1662 //                {
1663 //                   cout << setw(10) << Pkg.Name() << " | " << setw(10) << V.VerStr() << " | "
1664 //                        << VF.File().Archive() << endl;
1665 //                }
1666
1667                // Locate the associated index files so we can derive a description
1668                for (pkgSourceList::const_iterator S = SrcList->begin(); S != SrcList->end(); S++)
1669                {
1670                     vector<pkgIndexFile *> *Indexes = (*S)->GetIndexFiles();
1671                     for (vector<pkgIndexFile *>::const_iterator IF = Indexes->begin();
1672                          IF != Indexes->end(); IF++)
1673                     {
1674                          if ((*IF)->FindInCache(*(VF.File().Cache())) == VF.File())
1675                          {
1676                                    cout << setw(10) << Pkg.Name() << " | " << setw(10) << V.VerStr() << " | "
1677                                         << (*IF)->Describe(true) << endl;
1678                          }
1679                     }
1680                }
1681             }
1682          }
1683       }
1684
1685
1686       SrcRecs.Restart();
1687       pkgSrcRecords::Parser *SrcParser;
1688       while ((SrcParser = SrcRecs.Find(*I,false)) != 0)
1689       {
1690          // Maybe support Release info here too eventually
1691          cout << setw(10) << SrcParser->Package() << " | "
1692               << setw(10) << SrcParser->Version() << " | "
1693               << SrcParser->Index().Describe(true) << endl;
1694       }
1695    }
1696
1697    return true;
1698 }
1699                                                                         /*}}}*/
1700 // GenCaches - Call the main cache generator                            /*{{{*/
1701 // ---------------------------------------------------------------------
1702 /* */
1703 bool GenCaches(CommandLine &Cmd)
1704 {
1705    OpTextProgress Progress(*_config);
1706
1707    pkgSourceList List;
1708    if (List.ReadMainList() == false)
1709       return false;
1710    return pkgMakeStatusCache(List,Progress);
1711 }
1712                                                                         /*}}}*/
1713 // ShowHelp - Show a help screen                                        /*{{{*/
1714 // ---------------------------------------------------------------------
1715 /* */
1716 bool ShowHelp(CommandLine &Cmd)
1717 {
1718    ioprintf(cout,_("%s %s for %s compiled on %s %s\n"),PACKAGE,VERSION,
1719             COMMON_ARCH,__DATE__,__TIME__);
1720
1721    if (_config->FindB("version") == true)
1722      return true;
1723
1724    cout <<
1725     _("Usage: apt-cache [options] command\n"
1726       "       apt-cache [options] add file1 [file2 ...]\n"
1727       "       apt-cache [options] showpkg pkg1 [pkg2 ...]\n"
1728       "       apt-cache [options] showsrc pkg1 [pkg2 ...]\n"
1729       "\n"
1730       "apt-cache is a low-level tool used to manipulate APT's binary\n"
1731       "cache files, and query information from them\n"
1732       "\n"
1733       "Commands:\n"
1734       "   add - Add a package file to the source cache\n"
1735       "   gencaches - Build both the package and source cache\n"
1736       "   showpkg - Show some general information for a single package\n"
1737       "   showsrc - Show source records\n"
1738       "   stats - Show some basic statistics\n"
1739       "   dump - Show the entire file in a terse form\n"
1740       "   dumpavail - Print an available file to stdout\n"
1741       "   unmet - Show unmet dependencies\n"
1742       "   search - Search the package list for a regex pattern\n"
1743       "   show - Show a readable record for the package\n"
1744       "   depends - Show raw dependency information for a package\n"
1745       "   rdepends - Show reverse dependency information for a package\n"
1746       "   pkgnames - List the names of all packages in the system\n"
1747       "   dotty - Generate package graphs for GraphViz\n"
1748       "   xvcg - Generate package graphs for xvcg\n"
1749       "   policy - Show policy settings\n"
1750       "\n"
1751       "Options:\n"
1752       "  -h   This help text.\n"
1753       "  -p=? The package cache.\n"
1754       "  -s=? The source cache.\n"
1755       "  -q   Disable progress indicator.\n"
1756       "  -i   Show only important deps for the unmet command.\n"
1757       "  -c=? Read this configuration file\n"
1758       "  -o=? Set an arbitrary configuration option, eg -o dir::cache=/tmp\n"
1759       "See the apt-cache(8) and apt.conf(5) manual pages for more information.\n");
1760    return true;
1761 }
1762                                                                         /*}}}*/
1763 // CacheInitialize - Initialize things for apt-cache                    /*{{{*/
1764 // ---------------------------------------------------------------------
1765 /* */
1766 void CacheInitialize()
1767 {
1768    _config->Set("quiet",0);
1769    _config->Set("help",false);
1770 }
1771                                                                         /*}}}*/
1772 int main(int argc,const char *argv[])                                   /*{{{*/
1773 {
1774    CommandLine::Args Args[] = {
1775       {'h',"help","help",0},
1776       {'v',"version","version",0},
1777       {'p',"pkg-cache","Dir::Cache::pkgcache",CommandLine::HasArg},
1778       {'s',"src-cache","Dir::Cache::srcpkgcache",CommandLine::HasArg},
1779       {'q',"quiet","quiet",CommandLine::IntLevel},
1780       {'i',"important","APT::Cache::Important",0},
1781       {'f',"full","APT::Cache::ShowFull",0},
1782       {'g',"generate","APT::Cache::Generate",0},
1783       {'a',"all-versions","APT::Cache::AllVersions",0},
1784       {'n',"names-only","APT::Cache::NamesOnly",0},
1785       {0,"all-names","APT::Cache::AllNames",0},
1786       {0,"recurse","APT::Cache::RecurseDepends",0},
1787       {'c',"config-file",0,CommandLine::ConfigFile},
1788       {'o',"option",0,CommandLine::ArbItem},
1789       {0,"installed","APT::Cache::Installed",0},
1790       {0,0,0,0}};
1791    CommandLine::Dispatch CmdsA[] = {{"help",&ShowHelp},
1792                                     {"add",&DoAdd},
1793                                     {"gencaches",&GenCaches},
1794                                     {"showsrc",&ShowSrcPackage},
1795                                     {0,0}};
1796    CommandLine::Dispatch CmdsB[] = {{"showpkg",&DumpPackage},
1797                                     {"stats",&Stats},
1798                                     {"dump",&Dump},
1799                                     {"dumpavail",&DumpAvail},
1800                                     {"unmet",&UnMet},
1801                                     {"search",&Search},
1802                                     {"depends",&Depends},
1803                                     {"rdepends",&RDepends},
1804                                     {"dotty",&Dotty},
1805                                     {"xvcg",&XVcg},
1806                                     {"show",&ShowPackage},
1807                                     {"pkgnames",&ShowPkgNames},
1808                                     {"policy",&Policy},
1809                                     {"madison",&Madison},
1810                                     {0,0}};
1811
1812    CacheInitialize();
1813
1814    // Set up gettext support
1815    setlocale(LC_ALL,"");
1816    textdomain(PACKAGE);
1817
1818    // Parse the command line and initialize the package library
1819    CommandLine CmdL(Args,_config);
1820    if (pkgInitConfig(*_config) == false ||
1821        CmdL.Parse(argc,argv) == false ||
1822        pkgInitSystem(*_config,_system) == false)
1823    {
1824       _error->DumpErrors();
1825       return 100;
1826    }
1827
1828    // See if the help should be shown
1829    if (_config->FindB("help") == true ||
1830        CmdL.FileSize() == 0)
1831    {
1832       ShowHelp(CmdL);
1833       return 0;
1834    }
1835
1836    // Deal with stdout not being a tty
1837    if (isatty(STDOUT_FILENO) && _config->FindI("quiet",0) < 1)
1838       _config->Set("quiet","1");
1839
1840    if (CmdL.DispatchArg(CmdsA,false) == false && _error->PendingError() == false)
1841    {
1842       MMap *Map = 0;
1843       if (_config->FindB("APT::Cache::Generate",true) == false)
1844       {
1845          Map = new MMap(*new FileFd(_config->FindFile("Dir::Cache::pkgcache"),
1846                                     FileFd::ReadOnly),MMap::Public|MMap::ReadOnly);
1847       }
1848       else
1849       {
1850          // Open the cache file
1851          SrcList = new pkgSourceList;
1852          SrcList->ReadMainList();
1853
1854          // Generate it and map it
1855          OpProgress Prog;
1856          pkgMakeStatusCache(*SrcList,Prog,&Map,true);
1857       }
1858
1859       if (_error->PendingError() == false)
1860       {
1861          pkgCache Cache(Map);
1862          GCache = &Cache;
1863          if (_error->PendingError() == false)
1864             CmdL.DispatchArg(CmdsB);
1865       }
1866       delete Map;
1867    }
1868
1869    // Print any errors or warnings found during parsing
1870    if (_error->empty() == false)
1871    {
1872       bool Errors = _error->PendingError();
1873       _error->DumpErrors();
1874       return Errors == true?100:0;
1875    }
1876
1877    return 0;
1878 }
1879                                                                         /*}}}*/