]> git.saurik.com Git - apt.git/blame - apt-pkg/deb/debindexfile.cc
projects / apt.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge branch 'debian/sid' into debian/experimental
[apt.git] / apt-pkg / deb / debindexfile.cc
CommitLineData
b2e465d6
AL		 1// -*- mode: cpp; mode: fold -*-
2// Description /*{{{*/
7db98ffc 3// $Id: debindexfile.cc,v 1.5.2.3 2004/01/04 19:11:00 mdz Exp $
b2e465d6
AL		 4/* ######################################################################
5
6 Debian Specific sources.list types and the three sorts of Debian
7 index files.
8
9 ##################################################################### */
10 /*}}}*/
11// Include Files /*{{{*/
ea542140
DK		 12#include <config.h>
13
b2e465d6
AL		 14#include <apt-pkg/debindexfile.h>
15#include <apt-pkg/debsrcrecords.h>
16#include <apt-pkg/deblistparser.h>
17#include <apt-pkg/debrecords.h>
b2e465d6
AL		 18#include <apt-pkg/configuration.h>
19#include <apt-pkg/progress.h>
20#include <apt-pkg/error.h>
21#include <apt-pkg/strutl.h>
22#include <apt-pkg/acquire-item.h>
7db98ffc 23#include <apt-pkg/debmetaindex.h>
233b7808 24#include <apt-pkg/gpgv.h>
453b82a3
DK		 25#include <apt-pkg/fileutl.h>
26#include <apt-pkg/indexfile.h>
27#include <apt-pkg/mmap.h>
28#include <apt-pkg/pkgcache.h>
29#include <apt-pkg/cacheiterators.h>
30#include <apt-pkg/pkgcachegen.h>
31#include <apt-pkg/pkgrecords.h>
32#include <apt-pkg/srcrecords.h>
0d29b9d4 33#include <apt-pkg/sptr.h>
e011829d 34
453b82a3
DK		 35#include <stdio.h>
36#include <iostream>
37#include <string>
b2e465d6
AL		 38#include <sys/stat.h>
39 /*}}}*/
40
73688d27
DK		 41using std::string;
42
b2e465d6
AL		 43// SourcesIndex::debSourcesIndex - Constructor /*{{{*/
44// ---------------------------------------------------------------------
45/* */
7db98ffc
MZ		 46debSourcesIndex::debSourcesIndex(string URI,string Dist,string Section,bool Trusted) :
47 pkgIndexFile(Trusted), URI(URI), Dist(Dist), Section(Section)
b2e465d6
AL		 48{
49}
50 /*}}}*/
51// SourcesIndex::SourceInfo - Short 1 liner describing a source /*{{{*/
52// ---------------------------------------------------------------------
53/* The result looks like:
5e02df82 54 http://foo/debian/ stable/main src 1.1.1 (dsc) */
b2e465d6
AL		 55string debSourcesIndex::SourceInfo(pkgSrcRecords::Parser const &Record,
56 pkgSrcRecords::File const &File) const
57{
58 string Res;
5e02df82 59 Res = ::URI::NoUserPassword(URI) + ' ';
b2e465d6
AL		 60 if (Dist[Dist.size() - 1] == '/')
61 {
62 if (Dist != "/")
63 Res += Dist;
64 }
65 else
66 Res += Dist + '/' + Section;
67
68 Res += " ";
69 Res += Record.Package();
70 Res += " ";
71 Res += Record.Version();
72 if (File.Type.empty() == false)
73 Res += " (" + File.Type + ")";
74 return Res;
75}
76 /*}}}*/
77// SourcesIndex::CreateSrcParser - Get a parser for the source files /*{{{*/
78// ---------------------------------------------------------------------
79/* */
80pkgSrcRecords::Parser *debSourcesIndex::CreateSrcParser() const
81{
94e8c9d4 82 string SourcesURI = _config->FindDir("Dir::State::lists") +
83 URItoFileName(IndexURI("Sources"));
1aadba5a 84
b0f4b486
MV		 85 std::vector<std::string> types = APT::Configuration::getCompressionTypes();
86 for (std::vector<std::string>::const_iterator t = types.begin(); t != types.end(); ++t)
87 {
88 string p;
89 p = SourcesURI + '.' + *t;
90 if (FileExists(p))
91 return new debSrcRecordParser(p, this);
92 }
93 if (FileExists(SourcesURI))
94 return new debSrcRecordParser(SourcesURI, this);
95 return NULL;
b2e465d6
AL		 96}
97 /*}}}*/
98// SourcesIndex::Describe - Give a descriptive path to the index /*{{{*/
99// ---------------------------------------------------------------------
100/* */
af87ab54 101string debSourcesIndex::Describe(bool Short) const
b2e465d6
AL		 102{
103 char S[300];
af87ab54 104 if (Short == true)
cc742108 105 snprintf(S,sizeof(S),"%s",Info("Sources").c_str());
af87ab54 106 else
cc742108 107 snprintf(S,sizeof(S),"%s (%s)",Info("Sources").c_str(),
af87ab54
AL		 108 IndexFile("Sources").c_str());
109
b2e465d6
AL		 110 return S;
111}
112 /*}}}*/
113// SourcesIndex::Info - One liner describing the index URI /*{{{*/
114// ---------------------------------------------------------------------
115/* */
116string debSourcesIndex::Info(const char *Type) const
117{
5e02df82 118 string Info = ::URI::NoUserPassword(URI) + ' ';
b2e465d6
AL		 119 if (Dist[Dist.size() - 1] == '/')
120 {
121 if (Dist != "/")
122 Info += Dist;
123 }
124 else
125 Info += Dist + '/' + Section;
126 Info += " ";
127 Info += Type;
128 return Info;
129}
130 /*}}}*/
131// SourcesIndex::Index* - Return the URI to the index files /*{{{*/
132// ---------------------------------------------------------------------
133/* */
3809194b 134string debSourcesIndex::IndexFile(const char *Type) const
b2e465d6 135{
ec7a129e 136 string s = URItoFileName(IndexURI(Type));
b0f4b486
MV		 137
138 std::vector<std::string> types = APT::Configuration::getCompressionTypes();
139 for (std::vector<std::string>::const_iterator t = types.begin(); t != types.end(); ++t)
140 {
141 string p = s + '.' + *t;
142 if (FileExists(p))
143 return p;
144 }
145 return s;
b2e465d6 146}
ec7a129e 147
b2e465d6
AL		 148string debSourcesIndex::IndexURI(const char *Type) const
149{
150 string Res;
151 if (Dist[Dist.size() - 1] == '/')
152 {
153 if (Dist != "/")
154 Res = URI + Dist;
155 else
156 Res = URI;
157 }
158 else
159 Res = URI + "dists/" + Dist + '/' + Section +
160 "/source/";
161
162 Res += Type;
163 return Res;
164}
165 /*}}}*/
b2e465d6
AL		 166// SourcesIndex::Exists - Check if the index is available /*{{{*/
167// ---------------------------------------------------------------------
168/* */
169bool debSourcesIndex::Exists() const
170{
171 return FileExists(IndexFile("Sources"));
172}
173 /*}}}*/
174// SourcesIndex::Size - Return the size of the index /*{{{*/
175// ---------------------------------------------------------------------
176/* */
177unsigned long debSourcesIndex::Size() const
178{
915f0520
MP		 179 unsigned long size = 0;
180
181 /* we need to ignore errors here; if the lists are absent, just return 0 */
182 _error->PushToStack();
183
f0e83599 184 FileFd f(IndexFile("Sources"), FileFd::ReadOnly, FileFd::Extension);
915f0520
MP		 185 if (!f.Failed())
186 size = f.Size();
187
188 if (_error->PendingError() == true)
189 size = 0;
190 _error->RevertToStack();
5473df3f 191
915f0520 192 return size;
b2e465d6
AL		 193}
194 /*}}}*/
195
196// PackagesIndex::debPackagesIndex - Contructor /*{{{*/
197// ---------------------------------------------------------------------
198/* */
5dd4c8b8
DK		 199debPackagesIndex::debPackagesIndex(string const &URI, string const &Dist, string const &Section,
200 bool const &Trusted, string const &Arch) :
201 pkgIndexFile(Trusted), URI(URI), Dist(Dist), Section(Section), Architecture(Arch)
b2e465d6 202{
5dd4c8b8
DK		 203 if (Architecture == "native")
204 Architecture = _config->Find("APT::Architecture");
b2e465d6
AL		 205}
206 /*}}}*/
207// PackagesIndex::ArchiveInfo - Short version of the archive url /*{{{*/
208// ---------------------------------------------------------------------
209/* This is a shorter version that is designed to be < 60 chars or so */
210string debPackagesIndex::ArchiveInfo(pkgCache::VerIterator Ver) const
211{
5e02df82 212 string Res = ::URI::NoUserPassword(URI) + ' ';
b2e465d6
AL		 213 if (Dist[Dist.size() - 1] == '/')
214 {
215 if (Dist != "/")
216 Res += Dist;
217 }
218 else
219 Res += Dist + '/' + Section;
220
221 Res += " ";
222 Res += Ver.ParentPkg().Name();
223 Res += " ";
dd13742e
DK		 224 if (Dist[Dist.size() - 1] != '/')
225 Res.append(Ver.Arch()).append(" ");
b2e465d6
AL		 226 Res += Ver.VerStr();
227 return Res;
228}
229 /*}}}*/
230// PackagesIndex::Describe - Give a descriptive path to the index /*{{{*/
231// ---------------------------------------------------------------------
232/* This should help the user find the index in the sources.list and
233 in the filesystem for problem solving */
af87ab54 234string debPackagesIndex::Describe(bool Short) const
b2e465d6
AL		 235{
236 char S[300];
af87ab54
AL		 237 if (Short == true)
238 snprintf(S,sizeof(S),"%s",Info("Packages").c_str());
239 else
240 snprintf(S,sizeof(S),"%s (%s)",Info("Packages").c_str(),
241 IndexFile("Packages").c_str());
b2e465d6
AL		 242 return S;
243}
244 /*}}}*/
245// PackagesIndex::Info - One liner describing the index URI /*{{{*/
246// ---------------------------------------------------------------------
247/* */
248string debPackagesIndex::Info(const char *Type) const
249{
5e02df82 250 string Info = ::URI::NoUserPassword(URI) + ' ';
b2e465d6
AL		 251 if (Dist[Dist.size() - 1] == '/')
252 {
253 if (Dist != "/")
254 Info += Dist;
255 }
256 else
257 Info += Dist + '/' + Section;
258 Info += " ";
dd13742e
DK		 259 if (Dist[Dist.size() - 1] != '/')
260 Info += Architecture + " ";
b2e465d6
AL		 261 Info += Type;
262 return Info;
263}
264 /*}}}*/
265// PackagesIndex::Index* - Return the URI to the index files /*{{{*/
266// ---------------------------------------------------------------------
267/* */
3809194b 268string debPackagesIndex::IndexFile(const char *Type) const
b2e465d6 269{
ec7a129e 270 string s =_config->FindDir("Dir::State::lists") + URItoFileName(IndexURI(Type));
b0f4b486
MV		 271
272 std::vector<std::string> types = APT::Configuration::getCompressionTypes();
273 for (std::vector<std::string>::const_iterator t = types.begin(); t != types.end(); ++t)
274 {
275 string p = s + '.' + *t;
276 if (FileExists(p))
277 return p;
278 }
279 return s;
b2e465d6
AL		 280}
281string debPackagesIndex::IndexURI(const char *Type) const
282{
283 string Res;
284 if (Dist[Dist.size() - 1] == '/')
285 {
286 if (Dist != "/")
287 Res = URI + Dist;
288 else
289 Res = URI;
290 }
291 else
292 Res = URI + "dists/" + Dist + '/' + Section +
5dd4c8b8 293 "/binary-" + Architecture + '/';
b2e465d6
AL		 294
295 Res += Type;
296 return Res;
297}
298 /*}}}*/
b2e465d6
AL		 299// PackagesIndex::Exists - Check if the index is available /*{{{*/
300// ---------------------------------------------------------------------
301/* */
302bool debPackagesIndex::Exists() const
303{
304 return FileExists(IndexFile("Packages"));
305}
306 /*}}}*/
307// PackagesIndex::Size - Return the size of the index /*{{{*/
308// ---------------------------------------------------------------------
309/* This is really only used for progress reporting. */
310unsigned long debPackagesIndex::Size() const
311{
915f0520
MP		 312 unsigned long size = 0;
313
314 /* we need to ignore errors here; if the lists are absent, just return 0 */
315 _error->PushToStack();
316
f0e83599 317 FileFd f(IndexFile("Packages"), FileFd::ReadOnly, FileFd::Extension);
915f0520
MP		 318 if (!f.Failed())
319 size = f.Size();
5473df3f 320
915f0520
MP		 321 if (_error->PendingError() == true)
322 size = 0;
323 _error->RevertToStack();
324
325 return size;
b2e465d6
AL		 326}
327 /*}}}*/
328// PackagesIndex::Merge - Load the index file into a cache /*{{{*/
329// ---------------------------------------------------------------------
330/* */
2e5f4e45 331bool debPackagesIndex::Merge(pkgCacheGenerator &Gen,OpProgress *Prog) const
b2e465d6
AL		 332{
333 string PackageFile = IndexFile("Packages");
468720c5 334 FileFd Pkg(PackageFile,FileFd::ReadOnly, FileFd::Extension);
5dd4c8b8 335 debListParser Parser(&Pkg, Architecture);
3184b4cf 336
b2e465d6
AL		 337 if (_error->PendingError() == true)
338 return _error->Error("Problem opening %s",PackageFile.c_str());
2e5f4e45
DK		 339 if (Prog != NULL)
340 Prog->SubProgress(0,Info("Packages"));
b2e465d6
AL		 341 ::URI Tmp(URI);
342 if (Gen.SelectFile(PackageFile,Tmp.Host,*this) == false)
343 return _error->Error("Problem with SelectFile %s",PackageFile.c_str());
344
345 // Store the IMS information
346 pkgCache::PkgFileIterator File = Gen.GetCurFile();
a9fe5928 347 pkgCacheGenerator::Dynamic<pkgCache::PkgFileIterator> DynFile(File);
76a763e1
DK		 348 File->Size = Pkg.FileSize();
349 File->mtime = Pkg.ModificationTime();
b2e465d6
AL		 350
351 if (Gen.MergeList(Parser) == false)
352 return _error->Error("Problem with MergeList %s",PackageFile.c_str());
353
354 // Check the release file
fe0f7911
DK		 355 string ReleaseFile = debReleaseIndex(URI,Dist).MetaIndexFile("InRelease");
356 bool releaseExists = false;
b2e465d6 357 if (FileExists(ReleaseFile) == true)
fe0f7911
DK		 358 releaseExists = true;
359 else
360 ReleaseFile = debReleaseIndex(URI,Dist).MetaIndexFile("Release");
361
362 if (releaseExists == true || FileExists(ReleaseFile) == true)
b2e465d6 363 {
233b7808
DK		 364 FileFd Rel;
365 // Beware: The 'Release' file might be clearsigned in case the
366 // signature for an 'InRelease' file couldn't be checked
367 if (OpenMaybeClearSignedFile(ReleaseFile, Rel) == false)
368 return false;
369
b2e465d6
AL		 370 if (_error->PendingError() == true)
371 return false;
e011829d 372 Parser.LoadReleaseInfo(File,Rel,Section);
b2e465d6
AL		 373 }
374
375 return true;
376}
377 /*}}}*/
378// PackagesIndex::FindInCache - Find this index /*{{{*/
379// ---------------------------------------------------------------------
380/* */
381pkgCache::PkgFileIterator debPackagesIndex::FindInCache(pkgCache &Cache) const
382{
383 string FileName = IndexFile("Packages");
384 pkgCache::PkgFileIterator File = Cache.FileBegin();
f7f0d6c7 385 for (; File.end() == false; ++File)
b2e465d6 386 {
f6442c77 387 if (File.FileName() == NULL || FileName != File.FileName())
b2e465d6
AL		 388 continue;
389
390 struct stat St;
391 if (stat(File.FileName(),&St) != 0)
c8e572e3
MV		 392 {
393 if (_config->FindB("Debug::pkgCacheGen", false))
394 std::clog << "PackagesIndex::FindInCache - stat failed on " << File.FileName() << std::endl;
b2e465d6 395 return pkgCache::PkgFileIterator(Cache);
c8e572e3 396 }
b2e465d6 397 if ((unsigned)St.st_size != File->Size || St.st_mtime != File->mtime)
c8e572e3
MV		 398 {
399 if (_config->FindB("Debug::pkgCacheGen", false))
400 std::clog << "PackagesIndex::FindInCache - size (" << St.st_size << " <> " << File->Size
401 << ") or mtime (" << St.st_mtime << " <> " << File->mtime
402 << ") doesn't match for " << File.FileName() << std::endl;
b2e465d6 403 return pkgCache::PkgFileIterator(Cache);
c8e572e3 404 }
b2e465d6
AL		 405 return File;
406 }
407
408 return File;
409}
410 /*}}}*/
411
a52f938b
OS		 412// TranslationsIndex::debTranslationsIndex - Contructor /*{{{*/
413// ---------------------------------------------------------------------
414/* */
45df0ad2
DK		 415debTranslationsIndex::debTranslationsIndex(string URI,string Dist,string Section,
416 char const * const Translation) :
417 pkgIndexFile(true), URI(URI), Dist(Dist), Section(Section),
418 Language(Translation)
419{}
a52f938b
OS		 420 /*}}}*/
421// TranslationIndex::Trans* - Return the URI to the translation files /*{{{*/
422// ---------------------------------------------------------------------
423/* */
3809194b 424string debTranslationsIndex::IndexFile(const char *Type) const
a52f938b 425{
ec7a129e 426 string s =_config->FindDir("Dir::State::lists") + URItoFileName(IndexURI(Type));
b0f4b486
MV		 427
428 std::vector<std::string> types = APT::Configuration::getCompressionTypes();
429 for (std::vector<std::string>::const_iterator t = types.begin(); t != types.end(); ++t)
430 {
431 string p = s + '.' + *t;
432 if (FileExists(p))
433 return p;
434 }
435 return s;
a52f938b
OS		 436}
437string debTranslationsIndex::IndexURI(const char *Type) const
438{
439 string Res;
440 if (Dist[Dist.size() - 1] == '/')
441 {
442 if (Dist != "/")
422eeaaa 443 Res = URI + Dist;
a52f938b 444 else
422eeaaa 445 Res = URI;
a52f938b
OS		 446 }
447 else
422eeaaa 448 Res = URI + "dists/" + Dist + '/' + Section +
a52f938b
OS		 449 "/i18n/Translation-";
450
451 Res += Type;
452 return Res;
453}
454 /*}}}*/
455// TranslationsIndex::GetIndexes - Fetch the index files /*{{{*/
456// ---------------------------------------------------------------------
457/* */
458bool debTranslationsIndex::GetIndexes(pkgAcquire *Owner) const
459{
e4d30d3f
MV		 460 string const TranslationFile = string("Translation-").append(Language);
461 new pkgAcqIndexTrans(Owner, IndexURI(Language),
462 Info(TranslationFile.c_str()),
463 TranslationFile);
a52f938b
OS		 464
465 return true;
466}
467 /*}}}*/
468// TranslationsIndex::Describe - Give a descriptive path to the index /*{{{*/
469// ---------------------------------------------------------------------
470/* This should help the user find the index in the sources.list and
471 in the filesystem for problem solving */
472string debTranslationsIndex::Describe(bool Short) const
473{
474 char S[300];
475 if (Short == true)
476 snprintf(S,sizeof(S),"%s",Info(TranslationFile().c_str()).c_str());
477 else
478 snprintf(S,sizeof(S),"%s (%s)",Info(TranslationFile().c_str()).c_str(),
45df0ad2 479 IndexFile(Language).c_str());
a52f938b
OS		 480 return S;
481}
482 /*}}}*/
483// TranslationsIndex::Info - One liner describing the index URI /*{{{*/
484// ---------------------------------------------------------------------
485/* */
486string debTranslationsIndex::Info(const char *Type) const
487{
5e02df82 488 string Info = ::URI::NoUserPassword(URI) + ' ';
a52f938b
OS		 489 if (Dist[Dist.size() - 1] == '/')
490 {
491 if (Dist != "/")
492 Info += Dist;
493 }
494 else
495 Info += Dist + '/' + Section;
496 Info += " ";
497 Info += Type;
498 return Info;
499}
500 /*}}}*/
45df0ad2 501bool debTranslationsIndex::HasPackages() const /*{{{*/
11680bfd 502{
45df0ad2 503 return FileExists(IndexFile(Language));
11680bfd 504}
45df0ad2 505 /*}}}*/
a52f938b
OS		 506// TranslationsIndex::Exists - Check if the index is available /*{{{*/
507// ---------------------------------------------------------------------
508/* */
509bool debTranslationsIndex::Exists() const
510{
45df0ad2 511 return FileExists(IndexFile(Language));
a52f938b
OS		 512}
513 /*}}}*/
514// TranslationsIndex::Size - Return the size of the index /*{{{*/
515// ---------------------------------------------------------------------
516/* This is really only used for progress reporting. */
517unsigned long debTranslationsIndex::Size() const
518{
915f0520
MP		 519 unsigned long size = 0;
520
521 /* we need to ignore errors here; if the lists are absent, just return 0 */
522 _error->PushToStack();
523
f0e83599 524 FileFd f(IndexFile(Language), FileFd::ReadOnly, FileFd::Extension);
915f0520
MP		 525 if (!f.Failed())
526 size = f.Size();
5473df3f 527
915f0520
MP		 528 if (_error->PendingError() == true)
529 size = 0;
530 _error->RevertToStack();
5473df3f 531
915f0520 532 return size;
a52f938b
OS		 533}
534 /*}}}*/
535// TranslationsIndex::Merge - Load the index file into a cache /*{{{*/
536// ---------------------------------------------------------------------
537/* */
2e5f4e45 538bool debTranslationsIndex::Merge(pkgCacheGenerator &Gen,OpProgress *Prog) const
a52f938b
OS		 539{
540 // Check the translation file, if in use
45df0ad2 541 string TranslationFile = IndexFile(Language);
64c2bdc9 542 if (FileExists(TranslationFile))
a52f938b 543 {
468720c5 544 FileFd Trans(TranslationFile,FileFd::ReadOnly, FileFd::Extension);
bc1c9081 545 debTranslationsParser TransParser(&Trans);
a52f938b
OS		 546 if (_error->PendingError() == true)
547 return false;
548
2e5f4e45
DK		 549 if (Prog != NULL)
550 Prog->SubProgress(0, Info(TranslationFile.c_str()));
a52f938b
OS		 551 if (Gen.SelectFile(TranslationFile,string(),*this) == false)
552 return _error->Error("Problem with SelectFile %s",TranslationFile.c_str());
553
554 // Store the IMS information
555 pkgCache::PkgFileIterator TransFile = Gen.GetCurFile();
76a763e1
DK		 556 TransFile->Size = Trans.FileSize();
557 TransFile->mtime = Trans.ModificationTime();
a52f938b
OS		 558
559 if (Gen.MergeList(TransParser) == false)
560 return _error->Error("Problem with MergeList %s",TranslationFile.c_str());
561 }
562
563 return true;
564}
565 /*}}}*/
c51c6f08
OS		 566// TranslationsIndex::FindInCache - Find this index /*{{{*/
567// ---------------------------------------------------------------------
568/* */
569pkgCache::PkgFileIterator debTranslationsIndex::FindInCache(pkgCache &Cache) const
570{
45df0ad2 571 string FileName = IndexFile(Language);
4d34acf1 572
c51c6f08 573 pkgCache::PkgFileIterator File = Cache.FileBegin();
f7f0d6c7 574 for (; File.end() == false; ++File)
f416d22e
MV		 575 {
576 if (FileName != File.FileName())
577 continue;
4d34acf1 578
f416d22e
MV		 579 struct stat St;
580 if (stat(File.FileName(),&St) != 0)
c8e572e3
MV		 581 {
582 if (_config->FindB("Debug::pkgCacheGen", false))
583 std::clog << "TranslationIndex::FindInCache - stat failed on " << File.FileName() << std::endl;
f416d22e 584 return pkgCache::PkgFileIterator(Cache);
c8e572e3 585 }
f416d22e 586 if ((unsigned)St.st_size != File->Size || St.st_mtime != File->mtime)
c8e572e3
MV		 587 {
588 if (_config->FindB("Debug::pkgCacheGen", false))
589 std::clog << "TranslationIndex::FindInCache - size (" << St.st_size << " <> " << File->Size
590 << ") or mtime (" << St.st_mtime << " <> " << File->mtime
591 << ") doesn't match for " << File.FileName() << std::endl;
f416d22e 592 return pkgCache::PkgFileIterator(Cache);
c8e572e3 593 }
f416d22e
MV		 594 return File;
595 }
c51c6f08
OS		 596 return File;
597}
598 /*}}}*/
b2e465d6
AL		 599// StatusIndex::debStatusIndex - Constructor /*{{{*/
600// ---------------------------------------------------------------------
601/* */
7db98ffc 602debStatusIndex::debStatusIndex(string File) : pkgIndexFile(true), File(File)
b2e465d6
AL		 603{
604}
605 /*}}}*/
606// StatusIndex::Size - Return the size of the index /*{{{*/
607// ---------------------------------------------------------------------
608/* */
609unsigned long debStatusIndex::Size() const
610{
611 struct stat S;
612 if (stat(File.c_str(),&S) != 0)
613 return 0;
614 return S.st_size;
615}
616 /*}}}*/
617// StatusIndex::Merge - Load the index file into a cache /*{{{*/
618// ---------------------------------------------------------------------
619/* */
2e5f4e45 620bool debStatusIndex::Merge(pkgCacheGenerator &Gen,OpProgress *Prog) const
b2e465d6 621{
468720c5 622 FileFd Pkg(File,FileFd::ReadOnly, FileFd::Extension);
b2e465d6
AL		 623 if (_error->PendingError() == true)
624 return false;
625 debListParser Parser(&Pkg);
626 if (_error->PendingError() == true)
627 return false;
2e5f4e45
DK		 628
629 if (Prog != NULL)
630 Prog->SubProgress(0,File);
b2e465d6
AL		 631 if (Gen.SelectFile(File,string(),*this,pkgCache::Flag::NotSource) == false)
632 return _error->Error("Problem with SelectFile %s",File.c_str());
633
634 // Store the IMS information
635 pkgCache::PkgFileIterator CFile = Gen.GetCurFile();
76a763e1
DK		 636 CFile->Size = Pkg.FileSize();
637 CFile->mtime = Pkg.ModificationTime();
78a5476f 638 map_stringitem_t const storage = Gen.StoreString(pkgCacheGenerator::MIXED, "now");
2b803d40 639 CFile->Archive = storage;
b2e465d6
AL		 640
641 if (Gen.MergeList(Parser) == false)
642 return _error->Error("Problem with MergeList %s",File.c_str());
643 return true;
644}
645 /*}}}*/
646// StatusIndex::FindInCache - Find this index /*{{{*/
647// ---------------------------------------------------------------------
648/* */
649pkgCache::PkgFileIterator debStatusIndex::FindInCache(pkgCache &Cache) const
650{
651 pkgCache::PkgFileIterator File = Cache.FileBegin();
f7f0d6c7 652 for (; File.end() == false; ++File)
b2e465d6
AL		 653 {
654 if (this->File != File.FileName())
655 continue;
656
657 struct stat St;
658 if (stat(File.FileName(),&St) != 0)
c8e572e3
MV		 659 {
660 if (_config->FindB("Debug::pkgCacheGen", false))
661 std::clog << "StatusIndex::FindInCache - stat failed on " << File.FileName() << std::endl;
b2e465d6 662 return pkgCache::PkgFileIterator(Cache);
c8e572e3 663 }
b2e465d6 664 if ((unsigned)St.st_size != File->Size || St.st_mtime != File->mtime)
c8e572e3
MV		 665 {
666 if (_config->FindB("Debug::pkgCacheGen", false))
667 std::clog << "StatusIndex::FindInCache - size (" << St.st_size << " <> " << File->Size
668 << ") or mtime (" << St.st_mtime << " <> " << File->mtime
669 << ") doesn't match for " << File.FileName() << std::endl;
b2e465d6 670 return pkgCache::PkgFileIterator(Cache);
c8e572e3 671 }
b2e465d6
AL		 672 return File;
673 }
674 return File;
675}
676 /*}}}*/
677// StatusIndex::Exists - Check if the index is available /*{{{*/
678// ---------------------------------------------------------------------
679/* */
a02db58f 680APT_CONST bool debStatusIndex::Exists() const
b2e465d6
AL		 681{
682 // Abort if the file does not exist.
683 return true;
684}
685 /*}}}*/
686
0d29b9d4
MV		 687// debDebPkgFile - Single .deb file /*{{{*/
688// ---------------------------------------------------------------------
689debDebPkgFileIndex::debDebPkgFileIndex(std::string DebFile)
690 : pkgIndexFile(true), DebFile(DebFile)
691{
fb11075f 692 DebFileFullPath = flAbsPath(DebFile);
0d29b9d4
MV		 693}
694
695std::string debDebPkgFileIndex::ArchiveURI(std::string /*File*/) const
696{
697 return "file:" + DebFileFullPath;
698}
699
700bool debDebPkgFileIndex::Exists() const
701{
702 return FileExists(DebFile);
703}
704bool debDebPkgFileIndex::Merge(pkgCacheGenerator& Gen, OpProgress* Prog) const
705{
706 if(Prog)
707 Prog->SubProgress(0, "Reading deb file");
708
709 // get the control data out of the deb file vid dpkg -I
710 // ... can I haz libdpkg?
fdff5b03 711 Configuration::Item const *Opts = _config->Tree("DPkg::Options");
0cf39629 712 std::string dpkg = _config->Find("Dir::Bin::dpkg","dpkg");
fdff5b03
MV		 713 std::vector<const char *> Args;
714 Args.push_back(dpkg.c_str());
715 if (Opts != 0)
716 {
717 Opts = Opts->Child;
718 for (; Opts != 0; Opts = Opts->Next)
719 {
720 if (Opts->Value.empty() == true)
721 continue;
722 Args.push_back(Opts->Value.c_str());
723 }
724 }
725 Args.push_back("-I");
726 Args.push_back(DebFile.c_str());
727 Args.push_back("control");
728 Args.push_back(NULL);
a9d990a2
MV		 729 FileFd PipeFd;
730 pid_t Child;
fdff5b03 731 if(Popen((const char**)&Args[0], PipeFd, Child, FileFd::ReadOnly) == false)
a9d990a2 732 return _error->Error("Popen failed");
0d29b9d4
MV		 733 // FIXME: static buffer
734 char buf[8*1024];
a9d990a2
MV		 735 unsigned long long n = 0;
736 if(PipeFd.Read(buf, sizeof(buf)-1, &n) == false)
737 return _error->Errno("read", "Failed to read dpkg pipe");
738 ExecWait(Child, "Popen");
0d29b9d4
MV		 739
740 // now write the control data to a tempfile
fdff5b03 741 SPtr<FileFd> DebControl = GetTempFile("deb-file-" + flNotDir(DebFile));
0d29b9d4
MV		 742 if(DebControl == NULL)
743 return false;
744 DebControl->Write(buf, n);
745 // append size of the file
746 FileFd Fd(DebFile, FileFd::ReadOnly);
747 string Size;
748 strprintf(Size, "Size: %llu\n", Fd.Size());
749 DebControl->Write(Size.c_str(), Size.size());
750 // and rewind for the listparser
751 DebControl->Seek(0);
752
753 // and give it to the list parser
754 debDebFileParser Parser(DebControl, DebFile);
755 if(Gen.SelectFile(DebFile, "local", *this) == false)
756 return _error->Error("Problem with SelectFile %s", DebFile.c_str());
757
758 pkgCache::PkgFileIterator File = Gen.GetCurFile();
759 File->Size = DebControl->Size();
760 File->mtime = DebControl->ModificationTime();
761
762 if (Gen.MergeList(Parser) == false)
763 return _error->Error("Problem with MergeLister for %s", DebFile.c_str());
764
765 return true;
766}
767pkgCache::PkgFileIterator debDebPkgFileIndex::FindInCache(pkgCache &Cache) const
768{
0d29b9d4
MV		 769 pkgCache::PkgFileIterator File = Cache.FileBegin();
770 for (; File.end() == false; ++File)
771 {
772 if (File.FileName() == NULL || DebFile != File.FileName())
773 continue;
774
775 return File;
776 }
777
778 return File;
779}
780unsigned long debDebPkgFileIndex::Size() const
781{
782 struct stat buf;
783 if(stat(DebFile.c_str(), &buf) != 0)
784 return 0;
785 return buf.st_size;
786}
787 /*}}}*/
788
a49e7948
MV		 789// debDscFileIndex stuff
790debDscFileIndex::debDscFileIndex(std::string &DscFile)
791 : pkgIndexFile(true), DscFile(DscFile)
792{
793}
794
795bool debDscFileIndex::Exists() const
796{
797 return FileExists(DscFile);
798}
799
800unsigned long debDscFileIndex::Size() const
801{
802 struct stat buf;
803 if(stat(DscFile.c_str(), &buf) == 0)
804 return buf.st_size;
805 return 0;
806}
807
808// DscFileIndex::CreateSrcParser - Get a parser for the .dsc file /*{{{*/
a49e7948
MV		 809pkgSrcRecords::Parser *debDscFileIndex::CreateSrcParser() const
810{
811 if (!FileExists(DscFile))
812 return NULL;
813
814 return new debDscRecordParser(DscFile,this);
815}
816 /*}}}*/
b2e465d6
AL		 817// Index File types for Debian /*{{{*/
818class debIFTypeSrc : public pkgIndexFile::Type
819{
820 public:
821
822 debIFTypeSrc() {Label = "Debian Source Index";};
823};
824class debIFTypePkg : public pkgIndexFile::Type
825{
826 public:
827
828 virtual pkgRecords::Parser *CreatePkgParser(pkgCache::PkgFileIterator File) const
829 {
830 return new debRecordParser(File.FileName(),*File.Cache());
831 };
832 debIFTypePkg() {Label = "Debian Package Index";};
833};
97234432
MV		 834class debIFTypeTrans : public debIFTypePkg
835{
836 public:
837 debIFTypeTrans() {Label = "Debian Translation Index";};
838};
b2e465d6
AL		 839class debIFTypeStatus : public pkgIndexFile::Type
840{
841 public:
842
843 virtual pkgRecords::Parser *CreatePkgParser(pkgCache::PkgFileIterator File) const
844 {
845 return new debRecordParser(File.FileName(),*File.Cache());
846 };
847 debIFTypeStatus() {Label = "Debian dpkg status file";};
848};
0d29b9d4
MV		 849class debIFTypeDebPkgFile : public pkgIndexFile::Type
850{
851 public:
852 virtual pkgRecords::Parser *CreatePkgParser(pkgCache::PkgFileIterator File) const
853 {
854 return new debDebFileRecordParser(File.FileName(),*File.Cache());
855 };
856 debIFTypeDebPkgFile() {Label = "deb Package file";};
857};
a49e7948
MV		 858class debIFTypeDscFile : public pkgIndexFile::Type
859{
860 public:
861 virtual pkgSrcRecords::Parser *CreateSrcPkgParser(std::string DscFile) const
862 {
863 return new debDscRecordParser(DscFile, NULL);
864 };
865 debIFTypeDscFile() {Label = "dsc File Source Index";};
866};
77da39b9
MV		 867class debIFTypeDebianSourceDir : public pkgIndexFile::Type
868{
869 public:
870 virtual pkgSrcRecords::Parser *CreateSrcPkgParser(std::string SourceDir) const
871 {
872 return new debDscRecordParser(SourceDir + string("/debian/control"), NULL);
873 };
874 debIFTypeDebianSourceDir() {Label = "debian/control File Source Index";};
875};
a49e7948 876
b2e465d6
AL		 877static debIFTypeSrc _apt_Src;
878static debIFTypePkg _apt_Pkg;
97234432 879static debIFTypeTrans _apt_Trans;
b2e465d6 880static debIFTypeStatus _apt_Status;
0d29b9d4 881static debIFTypeDebPkgFile _apt_DebPkgFile;
a49e7948
MV		 882// file based pseudo indexes
883static debIFTypeDscFile _apt_DscFile;
77da39b9 884static debIFTypeDebianSourceDir _apt_DebianSourceDir;
b2e465d6
AL		 885
886const pkgIndexFile::Type *debSourcesIndex::GetType() const
887{
888 return &_apt_Src;
889}
890const pkgIndexFile::Type *debPackagesIndex::GetType() const
891{
892 return &_apt_Pkg;
893}
a52f938b
OS		 894const pkgIndexFile::Type *debTranslationsIndex::GetType() const
895{
97234432 896 return &_apt_Trans;
a52f938b 897}
b2e465d6
AL		 898const pkgIndexFile::Type *debStatusIndex::GetType() const
899{
900 return &_apt_Status;
901}
0d29b9d4
MV		 902const pkgIndexFile::Type *debDebPkgFileIndex::GetType() const
903{
904 return &_apt_DebPkgFile;
070536e6 905}
a49e7948
MV		 906const pkgIndexFile::Type *debDscFileIndex::GetType() const
907{
908 return &_apt_DscFile;
909}
77da39b9
MV		 910const pkgIndexFile::Type *debDebianSourceDirIndex::GetType() const
911{
912 return &_apt_DebianSourceDir;
0d29b9d4 913}
b2e465d6 914 /*}}}*/
862bafea
DK		 915
916debStatusIndex::~debStatusIndex() {}
917debPackagesIndex::~debPackagesIndex() {}
918debTranslationsIndex::~debTranslationsIndex() {}
919debSourcesIndex::~debSourcesIndex() {}
920
921debDebPkgFileIndex::~debDebPkgFileIndex() {}
APT (for Cydia)