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