cmdline/apt-cache.cc

   1 // -*- mode: cpp; mode: fold -*-
   2 // Description                                                          /*{{{*/
   3 // $Id: apt-cache.cc,v 1.14 1998/12/04 22:56:53 jgg 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. The
  10    only really usefull function right now is dumpavail which is used
  11    by the dselect method. Everything else is ment as a debug aide.
  12
  13    Returns 100 on failure, 0 on success.
  14
  15    ##################################################################### */
  16                                                                         /*}}}*/
  17 // Include Files                                                        /*{{{*/
  18 #include <apt-pkg/error.h>
  19 #include <apt-pkg/pkgcachegen.h>
  20 #include <apt-pkg/deblistparser.h>
  21 #include <apt-pkg/init.h>
  22 #include <apt-pkg/progress.h>
  23 #include <apt-pkg/sourcelist.h>
  24 #include <apt-pkg/cmndline.h>
  25
  26 #include <iostream.h>
  27 #include <config.h>
  28                                                                         /*}}}*/
  29
  30 // UnMet - Show unmet dependencies                                      /*{{{*/
  31 // ---------------------------------------------------------------------
  32 /* */
  33 bool UnMet(pkgCache &Cache)
  34 {
  35    bool Important = _config->FindB("Important",false);
  36
  37    for (pkgCache::PkgIterator P = Cache.PkgBegin(); P.end() == false; P++)
  38    {
  39       for (pkgCache::VerIterator V = P.VersionList(); V.end() == false; V++)
  40       {
  41          bool Header = false;
  42          for (pkgCache::DepIterator D = V.DependsList(); D.end() == false;)
  43          {
  44             // Collect or groups
  45             pkgCache::DepIterator Start;
  46             pkgCache::DepIterator End;
  47             D.GlobOr(Start,End);
  48
  49 /*          cout << "s: Check " << Start.TargetPkg().Name() << ',' <<
  50                End.TargetPkg().Name() << endl;*/
  51
  52             // Skip conflicts and replaces
  53             if (End->Type != pkgCache::Dep::PreDepends &&
  54                 End->Type != pkgCache::Dep::Depends &&
  55                 End->Type != pkgCache::Dep::Suggests &&
  56                 End->Type != pkgCache::Dep::Recommends)
  57                continue;
  58
  59             // Important deps only
  60             if (Important == true)
  61                if (End->Type != pkgCache::Dep::PreDepends &&
  62                    End->Type != pkgCache::Dep::Depends)
  63                   continue;
  64
  65             // Verify the or group
  66             bool OK = false;
  67             pkgCache::DepIterator RealStart = Start;
  68             do
  69             {
  70                // See if this dep is Ok
  71                pkgCache::Version **VList = Start.AllTargets();
  72                if (*VList != 0)
  73                {
  74                   OK = true;
  75                   delete [] VList;
  76                   break;
  77                }
  78                delete [] VList;
  79
  80                if (Start == End)
  81                   break;
  82                Start++;
  83             }
  84             while (1);
  85
  86             // The group is OK
  87             if (OK == true)
  88                continue;
  89
  90             // Oops, it failed..
  91             if (Header == false)
  92                   cout << "Package " << P.Name() << " version " <<
  93                V.VerStr() << " has an unmet dep:" << endl;
  94             Header = true;
  95
  96             // Print out the dep type
  97             cout << " " << End.DepType() << ": ";
  98
  99             // Show the group
 100             Start = RealStart;
 101             do
 102             {
 103                cout << Start.TargetPkg().Name();
 104                if (Start.TargetVer() != 0)
 105                   cout << " (" << Start.CompType() << " " << Start.TargetVer() <<
 106                   ")";
 107                if (Start == End)
 108                   break;
 109                cout << " | ";
 110                Start++;
 111             }
 112             while (1);
 113
 114             cout << endl;
 115          }
 116       }
 117    }
 118    return true;
 119 }
 120                                                                         /*}}}*/
 121 // DumpPackage - Show a dump of a package record                        /*{{{*/
 122 // ---------------------------------------------------------------------
 123 /* */
 124 bool DumpPackage(pkgCache &Cache,CommandLine &CmdL)
 125 {
 126    for (const char **I = CmdL.FileList + 1; *I != 0; I++)
 127    {
 128       pkgCache::PkgIterator Pkg = Cache.FindPkg(*I);
 129       if (Pkg.end() == true)
 130       {
 131          _error->Warning("Unable to locate package %s",*I);
 132          continue;
 133       }
 134
 135       cout << "Package: " << Pkg.Name() << endl;
 136       cout << "Versions: ";
 137       for (pkgCache::VerIterator Cur = Pkg.VersionList(); Cur.end() != true; Cur++)
 138       {
 139          cout << Cur.VerStr();
 140          for (pkgCache::VerFileIterator Vf = Cur.FileList(); Vf.end() == false; Vf++)
 141             cout << "(" << Vf.File().FileName() << ")";
 142          cout << ',';
 143       }
 144
 145       cout << endl;
 146
 147       cout << "Reverse Depends: " << endl;
 148       for (pkgCache::DepIterator D = Pkg.RevDependsList(); D.end() != true; D++)
 149          cout << "  " << D.ParentPkg().Name() << ',' << D.TargetPkg().Name() << endl;
 150
 151       cout << "Dependencies: " << endl;
 152       for (pkgCache::VerIterator Cur = Pkg.VersionList(); Cur.end() != true; Cur++)
 153       {
 154          cout << Cur.VerStr() << " - ";
 155          for (pkgCache::DepIterator Dep = Cur.DependsList(); Dep.end() != true; Dep++)
 156             cout << Dep.TargetPkg().Name() << " (" << (int)Dep->CompareOp << " " << Dep.TargetVer() << ") ";
 157          cout << endl;
 158       }
 159
 160       cout << "Provides: " << endl;
 161       for (pkgCache::VerIterator Cur = Pkg.VersionList(); Cur.end() != true; Cur++)
 162       {
 163          cout << Cur.VerStr() << " - ";
 164          for (pkgCache::PrvIterator Prv = Cur.ProvidesList(); Prv.end() != true; Prv++)
 165             cout << Prv.ParentPkg().Name() << " ";
 166          cout << endl;
 167       }
 168       cout << "Reverse Provides: " << endl;
 169       for (pkgCache::PrvIterator Prv = Pkg.ProvidesList(); Prv.end() != true; Prv++)
 170          cout << Prv.OwnerPkg().Name() << " " << Prv.OwnerVer().VerStr();
 171       cout << endl;
 172
 173    }
 174
 175    return true;
 176 }
 177                                                                         /*}}}*/
 178 // Stats - Dump some nice statistics                                    /*{{{*/
 179 // ---------------------------------------------------------------------
 180 /* */
 181 bool Stats(pkgCache &Cache)
 182 {
 183    cout << "Total Package Names : " << Cache.Head().PackageCount << endl;
 184    pkgCache::PkgIterator I = Cache.PkgBegin();
 185
 186    int Normal = 0;
 187    int Virtual = 0;
 188    int NVirt = 0;
 189    int DVirt = 0;
 190    int Missing = 0;
 191    for (;I.end() != true; I++)
 192    {
 193       if (I->VersionList != 0 && I->ProvidesList == 0)
 194       {
 195          Normal++;
 196          continue;
 197       }
 198
 199       if (I->VersionList != 0 && I->ProvidesList != 0)
 200       {
 201          NVirt++;
 202          continue;
 203       }
 204
 205       if (I->VersionList == 0 && I->ProvidesList != 0)
 206       {
 207          // Only 1 provides
 208          if (I.ProvidesList()->NextProvides == 0)
 209          {
 210             DVirt++;
 211          }
 212          else
 213             Virtual++;
 214          continue;
 215       }
 216       if (I->VersionList == 0 && I->ProvidesList == 0)
 217       {
 218          Missing++;
 219          continue;
 220       }
 221    }
 222    cout << "  Normal Packages: " << Normal << endl;
 223    cout << "  Pure Virtual Packages: " << Virtual << endl;
 224    cout << "  Single Virtual Packages: " << DVirt << endl;
 225    cout << "  Mixed Virtual Packages: " << NVirt << endl;
 226    cout << "  Missing: " << Missing << endl;
 227
 228    cout << "Total Distinct Versions: " << Cache.Head().VersionCount << endl;
 229    cout << "Total Dependencies: " << Cache.Head().DependsCount << endl;
 230    return true;
 231 }
 232                                                                         /*}}}*/
 233 // Check - Check some things about the cache                            /*{{{*/
 234 // ---------------------------------------------------------------------
 235 /* Debug aide mostly */
 236 bool Check(pkgCache &Cache)
 237 {
 238    pkgCache::PkgIterator Pkg = Cache.PkgBegin();
 239    for (;Pkg.end() != true; Pkg++)
 240    {
 241       if (Pkg.Section() == 0 && Pkg->VersionList != 0)
 242          cout << "Bad section " << Pkg.Name() << endl;
 243
 244       for (pkgCache::VerIterator Cur = Pkg.VersionList();
 245            Cur.end() != true; Cur++)
 246       {
 247          if (Cur->Priority < 1 || Cur->Priority > 5)
 248             cout << "Bad prio " << Pkg.Name() << ',' << Cur.VerStr() << " == " << (int)Cur->Priority << endl;
 249       }
 250    }
 251    return true;
 252 }
 253                                                                         /*}}}*/
 254 // Dump - show everything                                               /*{{{*/
 255 // ---------------------------------------------------------------------
 256 /* */
 257 bool Dump(pkgCache &Cache)
 258 {
 259    for (pkgCache::PkgIterator P = Cache.PkgBegin(); P.end() == false; P++)
 260    {
 261       cout << "Package: " << P.Name() << endl;
 262       for (pkgCache::VerIterator V = P.VersionList(); V.end() == false; V++)
 263       {
 264          cout << " Version: " << V.VerStr() << endl;
 265          cout << "     File: " << V.FileList().File().FileName() << endl;
 266          for (pkgCache::DepIterator D = V.DependsList(); D.end() == false; D++)
 267             cout << "  Depends: " << D.TargetPkg().Name() << ' ' << D.TargetVer() << endl;
 268       }
 269    }
 270
 271    for (pkgCache::PkgFileIterator F(Cache); F.end() == false; F++)
 272    {
 273       cout << "File: " << F.FileName() << endl;
 274       cout << " Size: " << F->Size << endl;
 275       cout << " ID: " << F->ID << endl;
 276       cout << " Flags: " << F->Flags << endl;
 277       cout << " Time: " << ctime(&F->mtime) << endl;
 278    }
 279
 280    return true;
 281 }
 282                                                                         /*}}}*/
 283 // DumpAvail - Print out the available list                             /*{{{*/
 284 // ---------------------------------------------------------------------
 285 /* This is needed to make dpkg --merge happy */
 286 bool DumpAvail(pkgCache &Cache)
 287 {
 288    unsigned char *Buffer = new unsigned char[Cache.HeaderP->MaxVerFileSize];
 289
 290    for (pkgCache::PkgFileIterator I = Cache.FileBegin(); I.end() == false; I++)
 291    {
 292       if ((I->Flags & pkgCache::Flag::NotSource) != 0)
 293          continue;
 294
 295       if (I.IsOk() == false)
 296       {
 297          delete [] Buffer;
 298          return _error->Error("Package file %s is out of sync.",I.FileName());
 299       }
 300
 301       FileFd PkgF(I.FileName(),FileFd::ReadOnly);
 302       if (_error->PendingError() == true)
 303       {
 304          delete [] Buffer;
 305          return false;
 306       }
 307
 308       /* Write all of the records from this package file, we search the entire
 309          structure to find them */
 310       for (pkgCache::PkgIterator P = Cache.PkgBegin(); P.end() == false; P++)
 311       {
 312          for (pkgCache::VerIterator V = P.VersionList(); V.end() == false; V++)
 313          {
 314             if (V->FileList == 0)
 315                continue;
 316             if (V.FileList().File() != I)
 317                continue;
 318
 319             // Read the record and then write it out again.
 320             if (PkgF.Seek(V.FileList()->Offset) == false ||
 321                 PkgF.Read(Buffer,V.FileList()->Size) == false ||
 322                 write(STDOUT_FILENO,Buffer,V.FileList()->Size) != V.FileList()->Size)
 323             {
 324                delete [] Buffer;
 325                return false;
 326             }
 327          }
 328       }
 329    }
 330
 331    return true;
 332 }
 333                                                                         /*}}}*/
 334 // DoAdd - Perform an adding operation                                  /*{{{*/
 335 // ---------------------------------------------------------------------
 336 /* */
 337 bool DoAdd(CommandLine &CmdL)
 338 {
 339    // Make sure there is at least one argument
 340    if (CmdL.FileSize() <= 1)
 341       return _error->Error("You must give at least one file name");
 342
 343    // Open the cache
 344    FileFd CacheF(_config->FindFile("Dir::Cache::pkgcache"),FileFd::WriteAny);
 345    if (_error->PendingError() == true)
 346       return false;
 347
 348    DynamicMMap Map(CacheF,MMap::Public);
 349    if (_error->PendingError() == true)
 350       return false;
 351
 352    OpTextProgress Progress(*_config);
 353    pkgCacheGenerator Gen(Map,Progress);
 354    if (_error->PendingError() == true)
 355       return false;
 356
 357    unsigned long Length = CmdL.FileSize() - 1;
 358    for (const char **I = CmdL.FileList + 1; *I != 0; I++)
 359    {
 360       Progress.OverallProgress(I - CmdL.FileList,Length,1,"Generating cache");
 361       Progress.SubProgress(Length);
 362
 363       // Do the merge
 364       FileFd TagF(*I,FileFd::ReadOnly);
 365       debListParser Parser(TagF);
 366       if (_error->PendingError() == true)
 367          return _error->Error("Problem opening %s",*I);
 368
 369       if (Gen.SelectFile(*I) == false)
 370          return _error->Error("Problem with SelectFile");
 371
 372       if (Gen.MergeList(Parser) == false)
 373          return _error->Error("Problem with MergeList");
 374    }
 375
 376    Progress.Done();
 377    Stats(Gen.GetCache());
 378
 379    return true;
 380 }
 381                                                                         /*}}}*/
 382 // GenCaches - Call the main cache generator                            /*{{{*/
 383 // ---------------------------------------------------------------------
 384 /* */
 385 bool GenCaches()
 386 {
 387    OpTextProgress Progress(*_config);
 388
 389    pkgSourceList List;
 390    List.ReadMainList();
 391    return pkgMakeStatusCache(List,Progress);
 392 }
 393                                                                         /*}}}*/
 394 // ShowHelp - Show a help screen                                        /*{{{*/
 395 // ---------------------------------------------------------------------
 396 /* */
 397 int ShowHelp()
 398 {
 399    cout << PACKAGE << ' ' << VERSION << " for " << ARCHITECTURE <<
 400        " compiled on " << __DATE__ << "  " << __TIME__ << endl;
 401
 402    cout << "Usage: apt-cache [options] command" << endl;
 403    cout << "       apt-cache [options] add file1 [file1 ...]" << endl;
 404    cout << "       apt-cache [options] showpkg pkg1 [pkg2 ...]" << endl;
 405    cout << endl;
 406    cout << "apt-cache is a low-level tool used to manipulate APT's binary" << endl;
 407    cout << "cache files stored in " << _config->FindFile("Dir::Cache") << endl;
 408    cout << "It is not ment for ordinary use only as a debug aide." << endl;
 409    cout << endl;
 410    cout << "Commands:" << endl;
 411    cout << "   add - Add an package file to the source cache" << endl;
 412    cout << "   gencaches - Build both the package and source cache" << endl;
 413    cout << "   showpkg - Show some general information for a single package" << endl;
 414    cout << "   stats - Show some basic statistics" << endl;
 415    cout << "   dump - Show the entire file in a terse form" << endl;
 416    cout << "   dumpavail - Print an available file to stdout" << endl;
 417    cout << "   unmet - Show unmet dependencies" << endl;
 418    cout << "   check - Check the cache a bit" << endl;
 419    cout << endl;
 420    cout << "Options:" << endl;
 421    cout << "  -h   This help text." << endl;
 422    cout << "  -p=? The package cache. [" << _config->FindFile("Dir::Cache::pkgcache") << ']' << endl;
 423    cout << "  -s=? The source cache. [" << _config->FindFile("Dir::Cache::srcpkgcache") << ']' << endl;
 424    cout << "  -q   Disable progress indicator. " << endl;
 425    cout << "  -c=? Read this configuration file" << endl;
 426    cout << "  -o=? Set an arbitary configuration option, ie -o dir::cache=/tmp" << endl;
 427    cout << "See the apt-cache(8) and apt.conf(8) manual pages for more information." << endl;
 428    return 100;
 429 }
 430                                                                         /*}}}*/
 431 // CacheInitialize - Initialize things for apt-cache                    /*{{{*/
 432 // ---------------------------------------------------------------------
 433 /* */
 434 void CacheInitialize()
 435 {
 436    _config->Set("quiet",0);
 437    _config->Set("help",false);
 438 }
 439                                                                         /*}}}*/
 440
 441 int main(int argc,const char *argv[])
 442 {
 443    CommandLine::Args Args[] = {
 444       {'h',"help","help",0},
 445       {'p',"pkg-cache","Dir::Cache::pkgcache",CommandLine::HasArg},
 446       {'s',"src-cache","Dir::Cache::srcpkgcache",CommandLine::HasArg},
 447       {'q',"quiet","quiet",CommandLine::IntLevel},
 448       {'i',"important","Important",0},
 449       {'c',"config-file",0,CommandLine::ConfigFile},
 450       {'o',"option",0,CommandLine::ArbItem},
 451       {0,0,0,0}};
 452
 453    CacheInitialize();
 454
 455    // Parse the command line and initialize the package library
 456    CommandLine CmdL(Args,_config);
 457    if (pkgInitialize(*_config) == false ||
 458        CmdL.Parse(argc,argv) == false)
 459    {
 460       _error->DumpErrors();
 461       return 100;
 462    }
 463
 464    // See if the help should be shown
 465    if (_config->FindB("help") == true ||
 466        CmdL.FileSize() == 0)
 467       return ShowHelp();
 468
 469    while (1)
 470    {
 471       if (strcmp(CmdL.FileList[0],"add") == 0)
 472       {
 473          DoAdd(CmdL);
 474          break;
 475       }
 476
 477       if (strcmp(CmdL.FileList[0],"gencaches") == 0)
 478       {
 479          GenCaches();
 480          break;
 481       }
 482
 483       // Open the cache file
 484       FileFd CacheF(_config->FindFile("Dir::Cache::pkgcache"),FileFd::ReadOnly);
 485       if (_error->PendingError() == true)
 486          break;
 487
 488       MMap Map(CacheF,MMap::Public | MMap::ReadOnly);
 489       if (_error->PendingError() == true)
 490          break;
 491
 492       pkgCache Cache(Map);
 493       if (_error->PendingError() == true)
 494          break;
 495
 496       if (strcmp(CmdL.FileList[0],"showpkg") == 0)
 497       {
 498          DumpPackage(Cache,CmdL);
 499          break;
 500       }
 501
 502       if (strcmp(CmdL.FileList[0],"stats") == 0)
 503       {
 504          Stats(Cache);
 505          break;
 506       }
 507
 508       if (strcmp(CmdL.FileList[0],"dump") == 0)
 509       {
 510          Dump(Cache);
 511          break;
 512       }
 513
 514       if (strcmp(CmdL.FileList[0],"dumpavail") == 0)
 515       {
 516          DumpAvail(Cache);
 517          break;
 518       }
 519
 520       if (strcmp(CmdL.FileList[0],"unmet") == 0)
 521       {
 522          UnMet(Cache);
 523          break;
 524       }
 525
 526       if (strcmp(CmdL.FileList[0],"check") == 0)
 527       {
 528          Check(Cache);
 529          break;
 530       }
 531
 532       _error->Error("Invalid operation %s", CmdL.FileList[0]);
 533       break;
 534    }
 535
 536    // Print any errors or warnings found during parsing
 537    if (_error->empty() == false)
 538    {
 539       bool Errors = _error->PendingError();
 540       _error->DumpErrors();
 541       return Errors == true?100:0;
 542    }
 543
 544    return 0;
 545 }