]> git.saurik.com Git - apt.git/blame_incremental - apt-pkg/cacheset.cc
projects / apt.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
merged from the debian-sid branch
[apt.git] / apt-pkg / cacheset.cc
... / ...
CommitLineData
1// -*- mode: cpp; mode: fold -*-
2// Description /*{{{*/
3/* ######################################################################
4
5 Simple wrapper around a std::set to provide a similar interface to
6 a set of cache structures as to the complete set of all structures
7 in the pkgCache. Currently only Package is supported.
8
9 ##################################################################### */
10 /*}}}*/
11// Include Files /*{{{*/
12#include <config.h>
13
14#include <apt-pkg/aptconfiguration.h>
15#include <apt-pkg/cachefile.h>
16#include <apt-pkg/cachefilter.h>
17#include <apt-pkg/cacheset.h>
18#include <apt-pkg/error.h>
19#include <apt-pkg/strutl.h>
20#include <apt-pkg/versionmatch.h>
21#include <apt-pkg/pkgrecords.h>
22#include <apt-pkg/policy.h>
23
24#include <vector>
25
26#include <regex.h>
27
28#include <apti18n.h>
29 /*}}}*/
30namespace APT {
31// FromTask - Return all packages in the cache from a specific task /*{{{*/
32bool PackageContainerInterface::FromTask(PackageContainerInterface * const pci, pkgCacheFile &Cache, std::string pattern, CacheSetHelper &helper) {
33 size_t const archfound = pattern.find_last_of(':');
34 std::string arch = "native";
35 if (archfound != std::string::npos) {
36 arch = pattern.substr(archfound+1);
37 pattern.erase(archfound);
38 }
39
40 if (pattern[pattern.length() -1] != '^')
41 return false;
42 pattern.erase(pattern.length()-1);
43
44 if (unlikely(Cache.GetPkgCache() == 0 || Cache.GetDepCache() == 0))
45 return false;
46
47 bool const wasEmpty = pci->empty();
48 if (wasEmpty == true)
49 pci->setConstructor(TASK);
50
51 // get the records
52 pkgRecords Recs(Cache);
53
54 // build regexp for the task
55 regex_t Pattern;
56 char S[300];
57 snprintf(S, sizeof(S), "^Task:.*[, ]%s([, ]|$)", pattern.c_str());
58 if(regcomp(&Pattern,S, REG_EXTENDED | REG_NOSUB | REG_NEWLINE) != 0) {
59 _error->Error("Failed to compile task regexp");
60 return false;
61 }
62
63 bool found = false;
64 for (pkgCache::GrpIterator Grp = Cache->GrpBegin(); Grp.end() == false; ++Grp) {
65 pkgCache::PkgIterator Pkg = Grp.FindPkg(arch);
66 if (Pkg.end() == true)
67 continue;
68 pkgCache::VerIterator ver = Cache[Pkg].CandidateVerIter(Cache);
69 if(ver.end() == true)
70 continue;
71
72 pkgRecords::Parser &parser = Recs.Lookup(ver.FileList());
73 const char *start, *end;
74 parser.GetRec(start,end);
75 unsigned int const length = end - start;
76 char buf[length];
77 strncpy(buf, start, length);
78 buf[length-1] = '\0';
79 if (regexec(&Pattern, buf, 0, 0, 0) != 0)
80 continue;
81
82 pci->insert(Pkg);
83 helper.showTaskSelection(Pkg, pattern);
84 found = true;
85 }
86 regfree(&Pattern);
87
88 if (found == false) {
89 helper.canNotFindTask(pci, Cache, pattern);
90 pci->setConstructor(UNKNOWN);
91 return false;
92 }
93
94 if (wasEmpty == false && pci->getConstructor() != UNKNOWN)
95 pci->setConstructor(UNKNOWN);
96
97 return true;
98}
99 /*}}}*/
100// FromRegEx - Return all packages in the cache matching a pattern /*{{{*/
101bool PackageContainerInterface::FromRegEx(PackageContainerInterface * const pci, pkgCacheFile &Cache, std::string pattern, CacheSetHelper &helper) {
102 static const char * const isregex = ".?+*|[^$";
103 if (pattern.find_first_of(isregex) == std::string::npos)
104 return false;
105
106 bool const wasEmpty = pci->empty();
107 if (wasEmpty == true)
108 pci->setConstructor(REGEX);
109
110 size_t archfound = pattern.find_last_of(':');
111 std::string arch = "native";
112 if (archfound != std::string::npos) {
113 arch = pattern.substr(archfound+1);
114 if (arch.find_first_of(isregex) == std::string::npos)
115 pattern.erase(archfound);
116 else
117 arch = "native";
118 }
119
120 if (unlikely(Cache.GetPkgCache() == 0))
121 return false;
122
123 APT::CacheFilter::PackageNameMatchesRegEx regexfilter(pattern);
124
125 bool found = false;
126 for (pkgCache::GrpIterator Grp = Cache.GetPkgCache()->GrpBegin(); Grp.end() == false; ++Grp) {
127 if (regexfilter(Grp) == false)
128 continue;
129 pkgCache::PkgIterator Pkg = Grp.FindPkg(arch);
130 if (Pkg.end() == true) {
131 if (archfound == std::string::npos) {
132 std::vector<std::string> archs = APT::Configuration::getArchitectures();
133 for (std::vector<std::string>::const_iterator a = archs.begin();
134 a != archs.end() && Pkg.end() != true; ++a)
135 Pkg = Grp.FindPkg(*a);
136 }
137 if (Pkg.end() == true)
138 continue;
139 }
140
141 pci->insert(Pkg);
142 helper.showRegExSelection(Pkg, pattern);
143 found = true;
144 }
145
146 if (found == false) {
147 helper.canNotFindRegEx(pci, Cache, pattern);
148 pci->setConstructor(UNKNOWN);
149 return false;
150 }
151
152 if (wasEmpty == false && pci->getConstructor() != UNKNOWN)
153 pci->setConstructor(UNKNOWN);
154
155 return true;
156}
157 /*}}}*/
158// FromName - Returns the package defined by this string /*{{{*/
159pkgCache::PkgIterator PackageContainerInterface::FromName(pkgCacheFile &Cache,
160 std::string const &str, CacheSetHelper &helper) {
161 std::string pkg = str;
162 size_t archfound = pkg.find_last_of(':');
163 std::string arch;
164 if (archfound != std::string::npos) {
165 arch = pkg.substr(archfound+1);
166 pkg.erase(archfound);
167 }
168
169 if (Cache.GetPkgCache() == 0)
170 return pkgCache::PkgIterator(Cache, 0);
171
172 pkgCache::PkgIterator Pkg(Cache, 0);
173 if (arch.empty() == true) {
174 pkgCache::GrpIterator Grp = Cache.GetPkgCache()->FindGrp(pkg);
175 if (Grp.end() == false)
176 Pkg = Grp.FindPreferredPkg();
177 } else
178 Pkg = Cache.GetPkgCache()->FindPkg(pkg, arch);
179
180 if (Pkg.end() == true)
181 return helper.canNotFindPkgName(Cache, str);
182 return Pkg;
183}
184 /*}}}*/
185// FromGroup - Returns the package defined by this string /*{{{*/
186bool PackageContainerInterface::FromGroup(PackageContainerInterface * const pci, pkgCacheFile &Cache,
187 std::string pkg, CacheSetHelper &helper) {
188 if (unlikely(Cache.GetPkgCache() == 0))
189 return false;
190
191 size_t const archfound = pkg.find_last_of(':');
192 std::string arch;
193 if (archfound != std::string::npos) {
194 arch = pkg.substr(archfound+1);
195 pkg.erase(archfound);
196 if (arch == "all" || arch == "native")
197 arch = _config->Find("APT::Architecture");
198 }
199
200 pkgCache::GrpIterator Grp = Cache.GetPkgCache()->FindGrp(pkg);
201 if (Grp.end() == false) {
202 if (arch.empty() == true) {
203 pkgCache::PkgIterator Pkg = Grp.FindPreferredPkg();
204 if (Pkg.end() == false)
205 {
206 pci->insert(Pkg);
207 return true;
208 }
209 } else {
210 bool found = false;
211 // for 'linux-any' return the first package matching, for 'linux-*' return all matches
212 bool const isGlobal = arch.find('*') != std::string::npos;
213 APT::CacheFilter::PackageArchitectureMatchesSpecification pams(arch);
214 for (pkgCache::PkgIterator Pkg = Grp.PackageList(); Pkg.end() == false; Pkg = Grp.NextPkg(Pkg)) {
215 if (pams(Pkg) == false)
216 continue;
217 pci->insert(Pkg);
218 found = true;
219 if (isGlobal == false)
220 break;
221 }
222 if (found == true)
223 return true;
224 }
225 }
226
227 pkgCache::PkgIterator Pkg = helper.canNotFindPkgName(Cache, pkg);
228 if (Pkg.end() == true)
229 return false;
230
231 pci->insert(Pkg);
232 return true;
233}
234 /*}}}*/
235// FromString - Return all packages matching a specific string /*{{{*/
236bool PackageContainerInterface::FromString(PackageContainerInterface * const pci, pkgCacheFile &Cache, std::string const &str, CacheSetHelper &helper) {
237 bool found = true;
238 _error->PushToStack();
239
240 if (FromGroup(pci, Cache, str, helper) == false &&
241 FromTask(pci, Cache, str, helper) == false &&
242 FromRegEx(pci, Cache, str, helper) == false)
243 {
244 helper.canNotFindPackage(pci, Cache, str);
245 found = false;
246 }
247
248 if (found == true)
249 _error->RevertToStack();
250 else
251 _error->MergeWithStack();
252 return found;
253}
254 /*}}}*/
255// FromCommandLine - Return all packages specified on commandline /*{{{*/
256bool PackageContainerInterface::FromCommandLine(PackageContainerInterface * const pci, pkgCacheFile &Cache, const char **cmdline, CacheSetHelper &helper) {
257 bool found = false;
258 for (const char **I = cmdline; *I != 0; ++I)
259 found |= PackageContainerInterface::FromString(pci, Cache, *I, helper);
260 return found;
261}
262 /*}}}*/
263// FromModifierCommandLine - helper doing the work for PKG:GroupedFromCommandLine /*{{{*/
264bool PackageContainerInterface::FromModifierCommandLine(unsigned short &modID, PackageContainerInterface * const pci,
265 pkgCacheFile &Cache, const char * cmdline,
266 std::list<Modifier> const &mods, CacheSetHelper &helper) {
267 std::string str = cmdline;
268 unsigned short fallback = modID;
269 bool modifierPresent = false;
270 for (std::list<Modifier>::const_iterator mod = mods.begin();
271 mod != mods.end(); ++mod) {
272 size_t const alength = strlen(mod->Alias);
273 switch(mod->Pos) {
274 case Modifier::POSTFIX:
275 if (str.compare(str.length() - alength, alength,
276 mod->Alias, 0, alength) != 0)
277 continue;
278 str.erase(str.length() - alength);
279 modID = mod->ID;
280 break;
281 case Modifier::PREFIX:
282 continue;
283 case Modifier::NONE:
284 continue;
285 }
286 modifierPresent = true;
287 break;
288 }
289 if (modifierPresent == true) {
290 bool const errors = helper.showErrors(false);
291 pkgCache::PkgIterator Pkg = FromName(Cache, cmdline, helper);
292 helper.showErrors(errors);
293 if (Pkg.end() == false) {
294 pci->insert(Pkg);
295 modID = fallback;
296 return true;
297 }
298 }
299 return FromString(pci, Cache, str, helper);
300}
301 /*}}}*/
302// FromModifierCommandLine - helper doing the work for VER:GroupedFromCommandLine /*{{{*/
303bool VersionContainerInterface::FromModifierCommandLine(unsigned short &modID,
304 VersionContainerInterface * const vci,
305 pkgCacheFile &Cache, const char * cmdline,
306 std::list<Modifier> const &mods,
307 CacheSetHelper &helper) {
308 Version select = NEWEST;
309 std::string str = cmdline;
310 bool modifierPresent = false;
311 unsigned short fallback = modID;
312 for (std::list<Modifier>::const_iterator mod = mods.begin();
313 mod != mods.end(); ++mod) {
314 if (modID == fallback && mod->ID == fallback)
315 select = mod->SelectVersion;
316 size_t const alength = strlen(mod->Alias);
317 switch(mod->Pos) {
318 case Modifier::POSTFIX:
319 if (str.compare(str.length() - alength, alength,
320 mod->Alias, 0, alength) != 0)
321 continue;
322 str.erase(str.length() - alength);
323 modID = mod->ID;
324 select = mod->SelectVersion;
325 break;
326 case Modifier::PREFIX:
327 continue;
328 case Modifier::NONE:
329 continue;
330 }
331 modifierPresent = true;
332 break;
333 }
334 if (modifierPresent == true) {
335 bool const errors = helper.showErrors(false);
336 bool const found = VersionContainerInterface::FromString(vci, Cache, cmdline, select, helper, true);
337 helper.showErrors(errors);
338 if (found == true) {
339 modID = fallback;
340 return true;
341 }
342 }
343 return FromString(vci, Cache, str, select, helper);
344}
345 /*}}}*/
346// FromCommandLine - Return all versions specified on commandline /*{{{*/
347bool VersionContainerInterface::FromCommandLine(VersionContainerInterface * const vci,
348 pkgCacheFile &Cache, const char **cmdline,
349 Version const &fallback, CacheSetHelper &helper) {
350 bool found = false;
351 for (const char **I = cmdline; *I != 0; ++I)
352 found |= VersionContainerInterface::FromString(vci, Cache, *I, fallback, helper);
353 return found;
354}
355 /*}}}*/
356// FromString - Returns all versions spedcified by a string /*{{{*/
357bool VersionContainerInterface::FromString(VersionContainerInterface * const vci,
358 pkgCacheFile &Cache, std::string pkg,
359 Version const &fallback, CacheSetHelper &helper,
360 bool const onlyFromName) {
361 std::string ver;
362 bool verIsRel = false;
363 size_t const vertag = pkg.find_last_of("/=");
364 if (vertag != std::string::npos) {
365 ver = pkg.substr(vertag+1);
366 verIsRel = (pkg[vertag] == '/');
367 pkg.erase(vertag);
368 }
369 PackageSet pkgset;
370 if (onlyFromName == false)
371 PackageContainerInterface::FromString(&pkgset, Cache, pkg, helper);
372 else {
373 pkgset.insert(PackageContainerInterface::FromName(Cache, pkg, helper));
374 }
375
376 bool errors = true;
377 if (pkgset.getConstructor() != PackageSet::UNKNOWN)
378 errors = helper.showErrors(false);
379
380 bool found = false;
381 for (PackageSet::const_iterator P = pkgset.begin();
382 P != pkgset.end(); ++P) {
383 if (vertag == std::string::npos) {
384 found |= VersionContainerInterface::FromPackage(vci, Cache, P, fallback, helper);
385 continue;
386 }
387 pkgCache::VerIterator V;
388 if (ver == "installed")
389 V = getInstalledVer(Cache, P, helper);
390 else if (ver == "candidate")
391 V = getCandidateVer(Cache, P, helper);
392 else if (ver == "newest") {
393 if (P->VersionList != 0)
394 V = P.VersionList();
395 else
396 V = helper.canNotFindNewestVer(Cache, P);
397 } else {
398 pkgVersionMatch Match(ver, (verIsRel == true ? pkgVersionMatch::Release :
399 pkgVersionMatch::Version));
400 V = Match.Find(P);
401 if (V.end() == true) {
402 if (verIsRel == true)
403 _error->Error(_("Release '%s' for '%s' was not found"),
404 ver.c_str(), P.FullName(true).c_str());
405 else
406 _error->Error(_("Version '%s' for '%s' was not found"),
407 ver.c_str(), P.FullName(true).c_str());
408 continue;
409 }
410 }
411 if (V.end() == true)
412 continue;
413 helper.showSelectedVersion(P, V, ver, verIsRel);
414 vci->insert(V);
415 found = true;
416 }
417 if (pkgset.getConstructor() != PackageSet::UNKNOWN)
418 helper.showErrors(errors);
419 return found;
420}
421 /*}}}*/
422// FromPackage - versions from package based on fallback /*{{{*/
423bool VersionContainerInterface::FromPackage(VersionContainerInterface * const vci,
424 pkgCacheFile &Cache,
425 pkgCache::PkgIterator const &P,
426 Version const &fallback,
427 CacheSetHelper &helper) {
428 pkgCache::VerIterator V;
429 bool showErrors;
430 bool found = false;
431 switch(fallback) {
432 case ALL:
433 if (P->VersionList != 0)
434 for (V = P.VersionList(); V.end() != true; ++V)
435 found |= vci->insert(V);
436 else
437 helper.canNotFindAllVer(vci, Cache, P);
438 break;
439 case CANDANDINST:
440 found |= vci->insert(getInstalledVer(Cache, P, helper));
441 found |= vci->insert(getCandidateVer(Cache, P, helper));
442 break;
443 case CANDIDATE:
444 found |= vci->insert(getCandidateVer(Cache, P, helper));
445 break;
446 case INSTALLED:
447 found |= vci->insert(getInstalledVer(Cache, P, helper));
448 break;
449 case CANDINST:
450 showErrors = helper.showErrors(false);
451 V = getCandidateVer(Cache, P, helper);
452 if (V.end() == true)
453 V = getInstalledVer(Cache, P, helper);
454 helper.showErrors(showErrors);
455 if (V.end() == false)
456 found |= vci->insert(V);
457 else
458 helper.canNotFindInstCandVer(vci, Cache, P);
459 break;
460 case INSTCAND:
461 showErrors = helper.showErrors(false);
462 V = getInstalledVer(Cache, P, helper);
463 if (V.end() == true)
464 V = getCandidateVer(Cache, P, helper);
465 helper.showErrors(showErrors);
466 if (V.end() == false)
467 found |= vci->insert(V);
468 else
469 helper.canNotFindInstCandVer(vci, Cache, P);
470 break;
471 case NEWEST:
472 if (P->VersionList != 0)
473 found |= vci->insert(P.VersionList());
474 else
475 helper.canNotFindNewestVer(Cache, P);
476 break;
477 }
478 return found;
479}
480 /*}}}*/
481// getCandidateVer - Returns the candidate version of the given package /*{{{*/
482pkgCache::VerIterator VersionContainerInterface::getCandidateVer(pkgCacheFile &Cache,
483 pkgCache::PkgIterator const &Pkg, CacheSetHelper &helper) {
484 pkgCache::VerIterator Cand;
485 if (Cache.IsPolicyBuilt() == true || Cache.IsDepCacheBuilt() == false) {
486 if (unlikely(Cache.GetPolicy() == 0))
487 return pkgCache::VerIterator(Cache);
488 Cand = Cache.GetPolicy()->GetCandidateVer(Pkg);
489 } else {
490 Cand = Cache[Pkg].CandidateVerIter(Cache);
491 }
492 if (Cand.end() == true)
493 return helper.canNotFindCandidateVer(Cache, Pkg);
494 return Cand;
495}
496 /*}}}*/
497// getInstalledVer - Returns the installed version of the given package /*{{{*/
498pkgCache::VerIterator VersionContainerInterface::getInstalledVer(pkgCacheFile &Cache,
499 pkgCache::PkgIterator const &Pkg, CacheSetHelper &helper) {
500 if (Pkg->CurrentVer == 0)
501 return helper.canNotFindInstalledVer(Cache, Pkg);
502 return Pkg.CurrentVer();
503}
504 /*}}}*/
505
506// canNotFindPkgName - handle the case no package has this name /*{{{*/
507pkgCache::PkgIterator CacheSetHelper::canNotFindPkgName(pkgCacheFile &Cache,
508 std::string const &str) {
509 if (ShowError == true)
510 _error->Insert(ErrorType, _("Unable to locate package %s"), str.c_str());
511 return pkgCache::PkgIterator(Cache, 0);
512}
513 /*}}}*/
514// canNotFindTask - handle the case no package is found for a task /*{{{*/
515void CacheSetHelper::canNotFindTask(PackageContainerInterface * const pci, pkgCacheFile &Cache, std::string pattern) {
516 if (ShowError == true)
517 _error->Insert(ErrorType, _("Couldn't find task '%s'"), pattern.c_str());
518}
519 /*}}}*/
520// canNotFindRegEx - handle the case no package is found by a regex /*{{{*/
521void CacheSetHelper::canNotFindRegEx(PackageContainerInterface * const pci, pkgCacheFile &Cache, std::string pattern) {
522 if (ShowError == true)
523 _error->Insert(ErrorType, _("Couldn't find any package by regex '%s'"), pattern.c_str());
524}
525 /*}}}*/
526// canNotFindPackage - handle the case no package is found from a string/*{{{*/
527void CacheSetHelper::canNotFindPackage(PackageContainerInterface * const pci, pkgCacheFile &Cache, std::string const &str) {
528}
529 /*}}}*/
530// canNotFindAllVer /*{{{*/
531void CacheSetHelper::canNotFindAllVer(VersionContainerInterface * const vci, pkgCacheFile &Cache,
532 pkgCache::PkgIterator const &Pkg) {
533 if (ShowError == true)
534 _error->Insert(ErrorType, _("Can't select versions from package '%s' as it is purely virtual"), Pkg.FullName(true).c_str());
535}
536 /*}}}*/
537// canNotFindInstCandVer /*{{{*/
538void CacheSetHelper::canNotFindInstCandVer(VersionContainerInterface * const vci, pkgCacheFile &Cache,
539 pkgCache::PkgIterator const &Pkg) {
540 if (ShowError == true)
541 _error->Insert(ErrorType, _("Can't select installed nor candidate version from package '%s' as it has neither of them"), Pkg.FullName(true).c_str());
542}
543 /*}}}*/
544// canNotFindInstCandVer /*{{{*/
545void CacheSetHelper::canNotFindCandInstVer(VersionContainerInterface * const vci, pkgCacheFile &Cache,
546 pkgCache::PkgIterator const &Pkg) {
547 if (ShowError == true)
548 _error->Insert(ErrorType, _("Can't select installed nor candidate version from package '%s' as it has neither of them"), Pkg.FullName(true).c_str());
549}
550 /*}}}*/
551// canNotFindNewestVer /*{{{*/
552pkgCache::VerIterator CacheSetHelper::canNotFindNewestVer(pkgCacheFile &Cache,
553 pkgCache::PkgIterator const &Pkg) {
554 if (ShowError == true)
555 _error->Insert(ErrorType, _("Can't select newest version from package '%s' as it is purely virtual"), Pkg.FullName(true).c_str());
556 return pkgCache::VerIterator(Cache, 0);
557}
558 /*}}}*/
559// canNotFindCandidateVer /*{{{*/
560pkgCache::VerIterator CacheSetHelper::canNotFindCandidateVer(pkgCacheFile &Cache,
561 pkgCache::PkgIterator const &Pkg) {
562 if (ShowError == true)
563 _error->Insert(ErrorType, _("Can't select candidate version from package %s as it has no candidate"), Pkg.FullName(true).c_str());
564 return pkgCache::VerIterator(Cache, 0);
565}
566 /*}}}*/
567// canNotFindInstalledVer /*{{{*/
568pkgCache::VerIterator CacheSetHelper::canNotFindInstalledVer(pkgCacheFile &Cache,
569 pkgCache::PkgIterator const &Pkg) {
570 if (ShowError == true)
571 _error->Insert(ErrorType, _("Can't select installed version from package %s as it is not installed"), Pkg.FullName(true).c_str());
572 return pkgCache::VerIterator(Cache, 0);
573}
574 /*}}}*/
575// showTaskSelection /*{{{*/
576void CacheSetHelper::showTaskSelection(pkgCache::PkgIterator const &pkg,
577 std::string const &pattern) {
578}
579 /*}}}*/
580// showRegExSelection /*{{{*/
581void CacheSetHelper::showRegExSelection(pkgCache::PkgIterator const &pkg,
582 std::string const &pattern) {
583}
584 /*}}}*/
585// showSelectedVersion /*{{{*/
586void CacheSetHelper::showSelectedVersion(pkgCache::PkgIterator const &Pkg,
587 pkgCache::VerIterator const Ver,
588 std::string const &ver,
589 bool const verIsRel) {
590}
591 /*}}}*/
592}
APT (for Cydia)