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