]> git.saurik.com Git - apt.git/blob - cmdline/apt-cache.cc
projects / apt.git / blob
? search:


b0034bf6d682f1b120309ca0223ae0217e8b900e
[apt.git] / 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.FullName(true).c_str(),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().FullName(true);
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.FullName(true) << 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().FullName(true) << ',' << D.TargetPkg().FullName(true);
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().FullName(true) << " (" << (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().FullName(true) << " ";
229 cout << endl;
230 }
231 cout << "Reverse Provides: " << endl;
232 for (pkgCache::PrvIterator Prv = Pkg.ProvidesList(); Prv.end() != true; Prv++)
233 cout << Prv.OwnerPkg().FullName(true) << " " << 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.FullName(true) << 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().FullName(true) << ' ' <<
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.FullName(true) << '>' << endl;
574 continue;
575 }
576
577 cout << Pkg.FullName(true) << 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.FullName(true) << ">" << endl;
600 else
601 cout << D.DepType() << ": " << Trg.FullName(true) << 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().FullName(true) << 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.FullName(true) << '>' << endl;
667 continue;
668 }
669
670 cout << Pkg.FullName(true) << 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.FullName(true) << ">" << endl;
688 else
689 cout << Trg.FullName(true) << 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().FullName(true) << 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.FullName(true).c_str(), D.TargetPkg().FullName(true).c_str() );
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.FullName(true).c_str(), Pkg.FullName(true).c_str(),
926 Shapes[ShapeMap[Pkg->ID]]);
927 else
928 printf("node: { title: \"%s\" label: \"%s\" shape: %s }\n", Pkg.FullName(true).c_str(), Pkg.FullName(true).c_str(),
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.FullName(true).c_str(),D.TargetPkg().FullName(true).c_str());
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.FullName(true).c_str(),
1142 Shapes[ShapeMap[Pkg->ID]]);
1143 else
1144 printf("\"%s\" [shape=%s];\n",Pkg.FullName(true).c_str(),
1145 Shapes[ShapeMap[Pkg->ID]]);
1146 }
1147
1148 printf("}\n");
1149 return true;
1150 }
1151 /*}}}*/
1152 // DoAdd - Perform an adding operation /*{{{*/
1153 // ---------------------------------------------------------------------
1154 /* */
1155 bool DoAdd(CommandLine &CmdL)
1156 {
1157 return _error->Error("Unimplemented");
1158 #if 0
1159 // Make sure there is at least one argument
1160 if (CmdL.FileSize() <= 1)
1161 return _error->Error("You must give at least one file name");
1162
1163 // Open the cache
1164 FileFd CacheF(_config->FindFile("Dir::Cache::pkgcache"),FileFd::WriteAny);
1165 if (_error->PendingError() == true)
1166 return false;
1167
1168 DynamicMMap Map(CacheF,MMap::Public);
1169 if (_error->PendingError() == true)
1170 return false;
1171
1172 OpTextProgress Progress(*_config);
1173 pkgCacheGenerator Gen(Map,Progress);
1174 if (_error->PendingError() == true)
1175 return false;
1176
1177 unsigned long Length = CmdL.FileSize() - 1;
1178 for (const char **I = CmdL.FileList + 1; *I != 0; I++)
1179 {
1180 Progress.OverallProgress(I - CmdL.FileList,Length,1,"Generating cache");
1181 Progress.SubProgress(Length);
1182
1183 // Do the merge
1184 FileFd TagF(*I,FileFd::ReadOnly);
1185 debListParser Parser(TagF);
1186 if (_error->PendingError() == true)
1187 return _error->Error("Problem opening %s",*I);
1188
1189 if (Gen.SelectFile(*I,"") == false)
1190 return _error->Error("Problem with SelectFile");
1191
1192 if (Gen.MergeList(Parser) == false)
1193 return _error->Error("Problem with MergeList");
1194 }
1195
1196 Progress.Done();
1197 GCache = &Gen.GetCache();
1198 Stats(CmdL);
1199
1200 return true;
1201 #endif
1202 }
1203 /*}}}*/
1204 // DisplayRecord - Displays the complete record for the package /*{{{*/
1205 // ---------------------------------------------------------------------
1206 /* This displays the package record from the proper package index file.
1207 It is not used by DumpAvail for performance reasons. */
1208 bool DisplayRecord(pkgCache::VerIterator V)
1209 {
1210 // Find an appropriate file
1211 pkgCache::VerFileIterator Vf = V.FileList();
1212 for (; Vf.end() == false; Vf++)
1213 if ((Vf.File()->Flags & pkgCache::Flag::NotSource) == 0)
1214 break;
1215 if (Vf.end() == true)
1216 Vf = V.FileList();
1217
1218 // Check and load the package list file
1219 pkgCache::PkgFileIterator I = Vf.File();
1220 if (I.IsOk() == false)
1221 return _error->Error(_("Package file %s is out of sync."),I.FileName());
1222
1223 FileFd PkgF(I.FileName(),FileFd::ReadOnly);
1224 if (_error->PendingError() == true)
1225 return false;
1226
1227 // Read the record
1228 unsigned char *Buffer = new unsigned char[GCache->HeaderP->MaxVerFileSize+1];
1229 Buffer[V.FileList()->Size] = '\n';
1230 if (PkgF.Seek(V.FileList()->Offset) == false ||
1231 PkgF.Read(Buffer,V.FileList()->Size) == false)
1232 {
1233 delete [] Buffer;
1234 return false;
1235 }
1236
1237 // Get a pointer to start of Description field
1238 const unsigned char *DescP = (unsigned char*)strstr((char*)Buffer, "Description:");
1239
1240 // Write all but Description
1241 if (fwrite(Buffer,1,DescP - Buffer,stdout) < (size_t)(DescP - Buffer))
1242 {
1243 delete [] Buffer;
1244 return false;
1245 }
1246
1247 // Show the right description
1248 pkgRecords Recs(*GCache);
1249 pkgCache::DescIterator Desc = V.TranslatedDescription();
1250 pkgRecords::Parser &P = Recs.Lookup(Desc.FileList());
1251 cout << "Description" << ( (strcmp(Desc.LanguageCode(),"") != 0) ? "-" : "" ) << Desc.LanguageCode() << ": " << P.LongDesc();
1252
1253 // Find the first field after the description (if there is any)
1254 for(DescP++;DescP != &Buffer[V.FileList()->Size];DescP++)
1255 {
1256 if(*DescP == '\n' && *(DescP+1) != ' ')
1257 {
1258 // write the rest of the buffer
1259 const unsigned char *end=&Buffer[V.FileList()->Size];
1260 if (fwrite(DescP,1,end-DescP,stdout) < (size_t)(end-DescP))
1261 {
1262 delete [] Buffer;
1263 return false;
1264 }
1265
1266 break;
1267 }
1268 }
1269 // write a final newline (after the description)
1270 cout<<endl;
1271 delete [] Buffer;
1272
1273 return true;
1274 }
1275 /*}}}*/
1276
1277 struct ExDescFile
1278 {
1279 pkgCache::DescFile *Df;
1280 bool NameMatch;
1281 };
1282
1283 // Search - Perform a search /*{{{*/
1284 // ---------------------------------------------------------------------
1285 /* This searches the package names and package descriptions for a pattern */
1286 bool Search(CommandLine &CmdL)
1287 {
1288 pkgCache &Cache = *GCache;
1289 bool ShowFull = _config->FindB("APT::Cache::ShowFull",false);
1290 bool NamesOnly = _config->FindB("APT::Cache::NamesOnly",false);
1291 unsigned NumPatterns = CmdL.FileSize() -1;
1292
1293 pkgDepCache::Policy Plcy;
1294
1295 // Make sure there is at least one argument
1296 if (NumPatterns < 1)
1297 return _error->Error(_("You must give exactly one pattern"));
1298
1299 // Compile the regex pattern
1300 regex_t *Patterns = new regex_t[NumPatterns];
1301 memset(Patterns,0,sizeof(*Patterns)*NumPatterns);
1302 for (unsigned I = 0; I != NumPatterns; I++)
1303 {
1304 if (regcomp(&Patterns[I],CmdL.FileList[I+1],REG_EXTENDED | REG_ICASE |
1305 REG_NOSUB) != 0)
1306 {
1307 for (; I != 0; I--)
1308 regfree(&Patterns[I]);
1309 return _error->Error("Regex compilation error");
1310 }
1311 }
1312
1313 // Create the text record parser
1314 pkgRecords Recs(Cache);
1315 if (_error->PendingError() == true)
1316 {
1317 for (unsigned I = 0; I != NumPatterns; I++)
1318 regfree(&Patterns[I]);
1319 return false;
1320 }
1321
1322 ExDescFile *DFList = new ExDescFile[Cache.HeaderP->PackageCount+1];
1323 memset(DFList,0,sizeof(*DFList)*Cache.HeaderP->PackageCount+1);
1324
1325 // Map versions that we want to write out onto the VerList array.
1326 for (pkgCache::PkgIterator P = Cache.PkgBegin(); P.end() == false; P++)
1327 {
1328 DFList[P->ID].NameMatch = NumPatterns != 0;
1329 for (unsigned I = 0; I != NumPatterns; I++)
1330 {
1331 if (regexec(&Patterns[I],P.Name(),0,0,0) == 0)
1332 DFList[P->ID].NameMatch &= true;
1333 else
1334 DFList[P->ID].NameMatch = false;
1335 }
1336
1337 // Doing names only, drop any that dont match..
1338 if (NamesOnly == true && DFList[P->ID].NameMatch == false)
1339 continue;
1340
1341 // Find the proper version to use.
1342 pkgCache::VerIterator V = Plcy.GetCandidateVer(P);
1343 if (V.end() == false)
1344 DFList[P->ID].Df = V.DescriptionList().FileList();
1345 }
1346
1347 // Include all the packages that provide matching names too
1348 for (pkgCache::PkgIterator P = Cache.PkgBegin(); P.end() == false; P++)
1349 {
1350 if (DFList[P->ID].NameMatch == false)
1351 continue;
1352
1353 for (pkgCache::PrvIterator Prv = P.ProvidesList() ; Prv.end() == false; Prv++)
1354 {
1355 pkgCache::VerIterator V = Plcy.GetCandidateVer(Prv.OwnerPkg());
1356 if (V.end() == false)
1357 {
1358 DFList[Prv.OwnerPkg()->ID].Df = V.DescriptionList().FileList();
1359 DFList[Prv.OwnerPkg()->ID].NameMatch = true;
1360 }
1361 }
1362 }
1363
1364 LocalitySort(&DFList->Df,Cache.HeaderP->PackageCount,sizeof(*DFList));
1365
1366 // Iterate over all the version records and check them
1367 for (ExDescFile *J = DFList; J->Df != 0; J++)
1368 {
1369 pkgRecords::Parser &P = Recs.Lookup(pkgCache::DescFileIterator(Cache,J->Df));
1370
1371 bool Match = true;
1372 if (J->NameMatch == false)
1373 {
1374 string LongDesc = P.LongDesc();
1375 Match = NumPatterns != 0;
1376 for (unsigned I = 0; I != NumPatterns; I++)
1377 {
1378 if (regexec(&Patterns[I],LongDesc.c_str(),0,0,0) == 0)
1379 Match &= true;
1380 else
1381 Match = false;
1382 }
1383 }
1384
1385 if (Match == true)
1386 {
1387 if (ShowFull == true)
1388 {
1389 const char *Start;
1390 const char *End;
1391 P.GetRec(Start,End);
1392 fwrite(Start,End-Start,1,stdout);
1393 putc('\n',stdout);
1394 }
1395 else
1396 printf("%s - %s\n",P.Name().c_str(),P.ShortDesc().c_str());
1397 }
1398 }
1399
1400 delete [] DFList;
1401 for (unsigned I = 0; I != NumPatterns; I++)
1402 regfree(&Patterns[I]);
1403 if (ferror(stdout))
1404 return _error->Error("Write to stdout failed");
1405 return true;
1406 }
1407 /*}}}*/
1408 // ShowPackage - Dump the package record to the screen /*{{{*/
1409 // ---------------------------------------------------------------------
1410 /* */
1411 bool ShowPackage(CommandLine &CmdL)
1412 {
1413 pkgCache &Cache = *GCache;
1414 pkgDepCache::Policy Plcy;
1415
1416 unsigned found = 0;
1417
1418 for (const char **I = CmdL.FileList + 1; *I != 0; I++)
1419 {
1420 // FIXME: Handle the case in which pkgname name:arch is not found
1421 pkgCache::PkgIterator Pkg = Cache.FindPkg(*I);
1422 if (Pkg.end() == true)
1423 {
1424 Pkg = Cache.FindPkg(*I, "any");
1425 if (Pkg.end() == true) {
1426 _error->Warning(_("Unable to locate package %s"),*I);
1427 continue;
1428 }
1429 }
1430
1431 ++found;
1432
1433 // Find the proper version to use.
1434 if (_config->FindB("APT::Cache::AllVersions","true") == true)
1435 {
1436 pkgCache::VerIterator V;
1437 for (V = Pkg.VersionList(); V.end() == false; V++)
1438 {
1439 if (DisplayRecord(V) == false)
1440 return false;
1441 }
1442 }
1443 else
1444 {
1445 pkgCache::VerIterator V = Plcy.GetCandidateVer(Pkg);
1446 if (V.end() == true || V.FileList().end() == true)
1447 continue;
1448 if (DisplayRecord(V) == false)
1449 return false;
1450 }
1451 }
1452
1453 if (found > 0)
1454 return true;
1455 return _error->Error(_("No packages found"));
1456 }
1457 /*}}}*/
1458 // ShowPkgNames - Show package names /*{{{*/
1459 // ---------------------------------------------------------------------
1460 /* This does a prefix match on the first argument */
1461 bool ShowPkgNames(CommandLine &CmdL)
1462 {
1463 pkgCache &Cache = *GCache;
1464 pkgCache::GrpIterator I = Cache.GrpBegin();
1465 bool const All = _config->FindB("APT::Cache::AllNames","false");
1466
1467 if (CmdL.FileList[1] != 0)
1468 {
1469 for (;I.end() != true; I++)
1470 {
1471 if (All == false && I->FirstPackage == 0)
1472 continue;
1473 if (I.FindPkg("any")->VersionList == 0)
1474 continue;
1475 if (strncmp(I.Name(),CmdL.FileList[1],strlen(CmdL.FileList[1])) == 0)
1476 cout << I.Name() << endl;
1477 }
1478
1479 return true;
1480 }
1481
1482 // Show all pkgs
1483 for (;I.end() != true; I++)
1484 {
1485 if (All == false && I->FirstPackage == 0)
1486 continue;
1487 if (I.FindPkg("any")->VersionList == 0)
1488 continue;
1489 cout << I.Name() << endl;
1490 }
1491
1492 return true;
1493 }
1494 /*}}}*/
1495 // ShowSrcPackage - Show source package records /*{{{*/
1496 // ---------------------------------------------------------------------
1497 /* */
1498 bool ShowSrcPackage(CommandLine &CmdL)
1499 {
1500 pkgSourceList List;
1501 List.ReadMainList();
1502
1503 // Create the text record parsers
1504 pkgSrcRecords SrcRecs(List);
1505 if (_error->PendingError() == true)
1506 return false;
1507
1508 unsigned found = 0;
1509 for (const char **I = CmdL.FileList + 1; *I != 0; I++)
1510 {
1511 SrcRecs.Restart();
1512
1513 pkgSrcRecords::Parser *Parse;
1514 unsigned found_this = 0;
1515 while ((Parse = SrcRecs.Find(*I,false)) != 0) {
1516 cout << Parse->AsStr() << endl;;
1517 found++;
1518 found_this++;
1519 }
1520 if (found_this == 0) {
1521 _error->Warning(_("Unable to locate package %s"),*I);
1522 continue;
1523 }
1524 }
1525 if (found > 0)
1526 return true;
1527 return _error->Error(_("No packages found"));
1528 }
1529 /*}}}*/
1530 // Policy - Show the results of the preferences file /*{{{*/
1531 // ---------------------------------------------------------------------
1532 /* */
1533 bool Policy(CommandLine &CmdL)
1534 {
1535 if (SrcList == 0)
1536 return _error->Error("Generate must be enabled for this function");
1537
1538 pkgCache &Cache = *GCache;
1539 pkgPolicy Plcy(&Cache);
1540 if (ReadPinFile(Plcy) == false || ReadPinDir(Plcy) == false)
1541 return false;
1542
1543 // Print out all of the package files
1544 if (CmdL.FileList[1] == 0)
1545 {
1546 cout << _("Package files:") << endl;
1547 for (pkgCache::PkgFileIterator F = Cache.FileBegin(); F.end() == false; F++)
1548 {
1549 // Locate the associated index files so we can derive a description
1550 pkgIndexFile *Indx;
1551 if (SrcList->FindIndex(F,Indx) == false &&
1552 _system->FindIndex(F,Indx) == false)
1553 return _error->Error(_("Cache is out of sync, can't x-ref a package file"));
1554
1555 printf("%4i %s\n",
1556 Plcy.GetPriority(F),Indx->Describe(true).c_str());
1557
1558 // Print the reference information for the package
1559 string Str = F.RelStr();
1560 if (Str.empty() == false)
1561 printf(" release %s\n",F.RelStr().c_str());
1562 if (F.Site() != 0 && F.Site()[0] != 0)
1563 printf(" origin %s\n",F.Site());
1564 }
1565
1566 // Show any packages have explicit pins
1567 cout << _("Pinned packages:") << endl;
1568 pkgCache::PkgIterator I = Cache.PkgBegin();
1569 for (;I.end() != true; I++)
1570 {
1571 if (Plcy.GetPriority(I) == 0)
1572 continue;
1573
1574 // Print the package name and the version we are forcing to
1575 cout << " " << I.FullName(true) << " -> ";
1576
1577 pkgCache::VerIterator V = Plcy.GetMatch(I);
1578 if (V.end() == true)
1579 cout << _("(not found)") << endl;
1580 else
1581 cout << V.VerStr() << endl;
1582 }
1583
1584 return true;
1585 }
1586
1587 string const myArch = _config->Find("APT::Architecture");
1588 char const * const msgInstalled = _(" Installed: ");
1589 char const * const msgCandidate = _(" Candidate: ");
1590 short const InstalledLessCandidate =
1591 mbstowcs(NULL, msgInstalled, 0) - mbstowcs(NULL, msgCandidate, 0);
1592 short const deepInstalled =
1593 (InstalledLessCandidate < 0 ? (InstalledLessCandidate*-1) : 0) - 1;
1594 short const deepCandidate =
1595 (InstalledLessCandidate > 0 ? (InstalledLessCandidate) : 0) - 1;
1596
1597 // Print out detailed information for each package
1598 for (const char **I = CmdL.FileList + 1; *I != 0; I++)
1599 {
1600 pkgCache::GrpIterator Grp = Cache.FindGrp(*I);
1601 pkgCache::PkgIterator Pkg = Grp.FindPkg("any");
1602 if (Pkg.end() == true)
1603 {
1604 _error->Warning(_("Unable to locate package %s"),*I);
1605 continue;
1606 }
1607
1608 for (; Pkg.end() != true; Pkg = Grp.NextPkg(Pkg)) {
1609 if (strcmp(Pkg.Arch(),"all") == 0)
1610 continue;
1611
1612 cout << Pkg.FullName(true) << ":" << endl;
1613
1614 // Installed version
1615 cout << msgInstalled << OutputInDepth(deepInstalled, " ");
1616 if (Pkg->CurrentVer == 0)
1617 cout << _("(none)") << endl;
1618 else
1619 cout << Pkg.CurrentVer().VerStr() << endl;
1620
1621 // Candidate Version
1622 cout << msgCandidate << OutputInDepth(deepCandidate, " ");
1623 pkgCache::VerIterator V = Plcy.GetCandidateVer(Pkg);
1624 if (V.end() == true)
1625 cout << _("(none)") << endl;
1626 else
1627 cout << V.VerStr() << endl;
1628
1629 // Pinned version
1630 if (Plcy.GetPriority(Pkg) != 0)
1631 {
1632 cout << _(" Package pin: ");
1633 V = Plcy.GetMatch(Pkg);
1634 if (V.end() == true)
1635 cout << _("(not found)") << endl;
1636 else
1637 cout << V.VerStr() << endl;
1638 }
1639
1640 // Show the priority tables
1641 cout << _(" Version table:") << endl;
1642 for (V = Pkg.VersionList(); V.end() == false; V++)
1643 {
1644 if (Pkg.CurrentVer() == V)
1645 cout << " *** " << V.VerStr();
1646 else
1647 cout << " " << V.VerStr();
1648 cout << " " << Plcy.GetPriority(Pkg) << endl;
1649 for (pkgCache::VerFileIterator VF = V.FileList(); VF.end() == false; VF++)
1650 {
1651 // Locate the associated index files so we can derive a description
1652 pkgIndexFile *Indx;
1653 if (SrcList->FindIndex(VF.File(),Indx) == false &&
1654 _system->FindIndex(VF.File(),Indx) == false)
1655 return _error->Error(_("Cache is out of sync, can't x-ref a package file"));
1656 printf(" %4i %s\n",Plcy.GetPriority(VF.File()),
1657 Indx->Describe(true).c_str());
1658 }
1659 }
1660 }
1661 }
1662
1663 return true;
1664 }
1665 /*}}}*/
1666 // Madison - Look a bit like katie's madison /*{{{*/
1667 // ---------------------------------------------------------------------
1668 /* */
1669 bool Madison(CommandLine &CmdL)
1670 {
1671 if (SrcList == 0)
1672 return _error->Error("Generate must be enabled for this function");
1673
1674 SrcList->ReadMainList();
1675
1676 pkgCache &Cache = *GCache;
1677
1678 // Create the src text record parsers and ignore errors about missing
1679 // deb-src lines that are generated from pkgSrcRecords::pkgSrcRecords
1680 pkgSrcRecords SrcRecs(*SrcList);
1681 if (_error->PendingError() == true)
1682 _error->Discard();
1683
1684 for (const char **I = CmdL.FileList + 1; *I != 0; I++)
1685 {
1686 pkgCache::PkgIterator Pkg = Cache.FindPkg(*I);
1687
1688 if (Pkg.end() == false)
1689 {
1690 for (pkgCache::VerIterator V = Pkg.VersionList(); V.end() == false; V++)
1691 {
1692 for (pkgCache::VerFileIterator VF = V.FileList(); VF.end() == false; VF++)
1693 {
1694 // This might be nice, but wouldn't uniquely identify the source -mdz
1695 // if (VF.File().Archive() != 0)
1696 // {
1697 // cout << setw(10) << Pkg.Name() << " | " << setw(10) << V.VerStr() << " | "
1698 // << VF.File().Archive() << endl;
1699 // }
1700
1701 // Locate the associated index files so we can derive a description
1702 for (pkgSourceList::const_iterator S = SrcList->begin(); S != SrcList->end(); S++)
1703 {
1704 vector<pkgIndexFile *> *Indexes = (*S)->GetIndexFiles();
1705 for (vector<pkgIndexFile *>::const_iterator IF = Indexes->begin();
1706 IF != Indexes->end(); IF++)
1707 {
1708 if ((*IF)->FindInCache(*(VF.File().Cache())) == VF.File())
1709 {
1710 cout << setw(10) << Pkg.FullName(true) << " | " << setw(10) << V.VerStr() << " | "
1711 << (*IF)->Describe(true) << endl;
1712 }
1713 }
1714 }
1715 }
1716 }
1717 }
1718
1719
1720 SrcRecs.Restart();
1721 pkgSrcRecords::Parser *SrcParser;
1722 while ((SrcParser = SrcRecs.Find(*I,false)) != 0)
1723 {
1724 // Maybe support Release info here too eventually
1725 cout << setw(10) << SrcParser->Package() << " | "
1726 << setw(10) << SrcParser->Version() << " | "
1727 << SrcParser->Index().Describe(true) << endl;
1728 }
1729 }
1730
1731 return true;
1732 }
1733 /*}}}*/
1734 // GenCaches - Call the main cache generator /*{{{*/
1735 // ---------------------------------------------------------------------
1736 /* */
1737 bool GenCaches(CommandLine &Cmd)
1738 {
1739 OpTextProgress Progress(*_config);
1740
1741 pkgSourceList List;
1742 if (List.ReadMainList() == false)
1743 return false;
1744 return pkgMakeStatusCache(List,Progress);
1745 }
1746 /*}}}*/
1747 // ShowHelp - Show a help screen /*{{{*/
1748 // ---------------------------------------------------------------------
1749 /* */
1750 bool ShowHelp(CommandLine &Cmd)
1751 {
1752 ioprintf(cout,_("%s %s for %s compiled on %s %s\n"),PACKAGE,VERSION,
1753 COMMON_ARCH,__DATE__,__TIME__);
1754
1755 if (_config->FindB("version") == true)
1756 return true;
1757
1758 cout <<
1759 _("Usage: apt-cache [options] command\n"
1760 " apt-cache [options] add file1 [file2 ...]\n"
1761 " apt-cache [options] showpkg pkg1 [pkg2 ...]\n"
1762 " apt-cache [options] showsrc pkg1 [pkg2 ...]\n"
1763 "\n"
1764 "apt-cache is a low-level tool used to manipulate APT's binary\n"
1765 "cache files, and query information from them\n"
1766 "\n"
1767 "Commands:\n"
1768 " add - Add a package file to the source cache\n"
1769 " gencaches - Build both the package and source cache\n"
1770 " showpkg - Show some general information for a single package\n"
1771 " showsrc - Show source records\n"
1772 " stats - Show some basic statistics\n"
1773 " dump - Show the entire file in a terse form\n"
1774 " dumpavail - Print an available file to stdout\n"
1775 " unmet - Show unmet dependencies\n"
1776 " search - Search the package list for a regex pattern\n"
1777 " show - Show a readable record for the package\n"
1778 " depends - Show raw dependency information for a package\n"
1779 " rdepends - Show reverse dependency information for a package\n"
1780 " pkgnames - List the names of all packages in the system\n"
1781 " dotty - Generate package graphs for GraphViz\n"
1782 " xvcg - Generate package graphs for xvcg\n"
1783 " policy - Show policy settings\n"
1784 "\n"
1785 "Options:\n"
1786 " -h This help text.\n"
1787 " -p=? The package cache.\n"
1788 " -s=? The source cache.\n"
1789 " -q Disable progress indicator.\n"
1790 " -i Show only important deps for the unmet command.\n"
1791 " -c=? Read this configuration file\n"
1792 " -o=? Set an arbitrary configuration option, eg -o dir::cache=/tmp\n"
1793 "See the apt-cache(8) and apt.conf(5) manual pages for more information.\n");
1794 return true;
1795 }
1796 /*}}}*/
1797 // CacheInitialize - Initialize things for apt-cache /*{{{*/
1798 // ---------------------------------------------------------------------
1799 /* */
1800 void CacheInitialize()
1801 {
1802 _config->Set("quiet",0);
1803 _config->Set("help",false);
1804 }
1805 /*}}}*/
1806 int main(int argc,const char *argv[]) /*{{{*/
1807 {
1808 CommandLine::Args Args[] = {
1809 {'h',"help","help",0},
1810 {'v',"version","version",0},
1811 {'p',"pkg-cache","Dir::Cache::pkgcache",CommandLine::HasArg},
1812 {'s',"src-cache","Dir::Cache::srcpkgcache",CommandLine::HasArg},
1813 {'q',"quiet","quiet",CommandLine::IntLevel},
1814 {'i',"important","APT::Cache::Important",0},
1815 {'f',"full","APT::Cache::ShowFull",0},
1816 {'g',"generate","APT::Cache::Generate",0},
1817 {'a',"all-versions","APT::Cache::AllVersions",0},
1818 {'n',"names-only","APT::Cache::NamesOnly",0},
1819 {0,"all-names","APT::Cache::AllNames",0},
1820 {0,"recurse","APT::Cache::RecurseDepends",0},
1821 {'c',"config-file",0,CommandLine::ConfigFile},
1822 {'o',"option",0,CommandLine::ArbItem},
1823 {0,"installed","APT::Cache::Installed",0},
1824 {0,0,0,0}};
1825 CommandLine::Dispatch CmdsA[] = {{"help",&ShowHelp},
1826 {"add",&DoAdd},
1827 {"gencaches",&GenCaches},
1828 {"showsrc",&ShowSrcPackage},
1829 {0,0}};
1830 CommandLine::Dispatch CmdsB[] = {{"showpkg",&DumpPackage},
1831 {"stats",&Stats},
1832 {"dump",&Dump},
1833 {"dumpavail",&DumpAvail},
1834 {"unmet",&UnMet},
1835 {"search",&Search},
1836 {"depends",&Depends},
1837 {"rdepends",&RDepends},
1838 {"dotty",&Dotty},
1839 {"xvcg",&XVcg},
1840 {"show",&ShowPackage},
1841 {"pkgnames",&ShowPkgNames},
1842 {"policy",&Policy},
1843 {"madison",&Madison},
1844 {0,0}};
1845
1846 CacheInitialize();
1847
1848 // Set up gettext support
1849 setlocale(LC_ALL,"");
1850 textdomain(PACKAGE);
1851
1852 // Parse the command line and initialize the package library
1853 CommandLine CmdL(Args,_config);
1854 if (pkgInitConfig(*_config) == false ||
1855 CmdL.Parse(argc,argv) == false ||
1856 pkgInitSystem(*_config,_system) == false)
1857 {
1858 _error->DumpErrors();
1859 return 100;
1860 }
1861
1862 // See if the help should be shown
1863 if (_config->FindB("help") == true ||
1864 CmdL.FileSize() == 0)
1865 {
1866 ShowHelp(CmdL);
1867 return 0;
1868 }
1869
1870 // Deal with stdout not being a tty
1871 if (isatty(STDOUT_FILENO) && _config->FindI("quiet",0) < 1)
1872 _config->Set("quiet","1");
1873
1874 if (CmdL.DispatchArg(CmdsA,false) == false && _error->PendingError() == false)
1875 {
1876 MMap *Map = 0;
1877 if (_config->FindB("APT::Cache::Generate",true) == false)
1878 {
1879 Map = new MMap(*new FileFd(_config->FindFile("Dir::Cache::pkgcache"),
1880 FileFd::ReadOnly),MMap::Public|MMap::ReadOnly);
1881 }
1882 else
1883 {
1884 // Open the cache file
1885 SrcList = new pkgSourceList;
1886 SrcList->ReadMainList();
1887
1888 // Generate it and map it
1889 OpProgress Prog;
1890 pkgMakeStatusCache(*SrcList,Prog,&Map,true);
1891 }
1892
1893 if (_error->PendingError() == false)
1894 {
1895 pkgCache Cache(Map);
1896 GCache = &Cache;
1897 if (_error->PendingError() == false)
1898 CmdL.DispatchArg(CmdsB);
1899 }
1900 delete Map;
1901 }
1902
1903 // Print any errors or warnings found during parsing
1904 if (_error->empty() == false)
1905 {
1906 bool Errors = _error->PendingError();
1907 _error->DumpErrors();
1908 return Errors == true?100:0;
1909 }
1910
1911 return 0;
1912 }
1913 /*}}}*/
APT (for Cydia)