1 // -*- mode: cpp; mode: fold -*-
3 // $Id: debindexfile.cc,v 1.5.2.3 2004/01/04 19:11:00 mdz Exp $
4 /* ######################################################################
6 Debian Specific sources.list types and the three sorts of Debian
9 ##################################################################### */
11 // Include Files /*{{{*/
14 #include <apt-pkg/debindexfile.h>
15 #include <apt-pkg/debsrcrecords.h>
16 #include <apt-pkg/deblistparser.h>
17 #include <apt-pkg/debrecords.h>
18 #include <apt-pkg/sourcelist.h>
19 #include <apt-pkg/configuration.h>
20 #include <apt-pkg/progress.h>
21 #include <apt-pkg/error.h>
22 #include <apt-pkg/strutl.h>
23 #include <apt-pkg/acquire-item.h>
24 #include <apt-pkg/debmetaindex.h>
29 // SourcesIndex::debSourcesIndex - Constructor /*{{{*/
30 // ---------------------------------------------------------------------
32 debSourcesIndex::debSourcesIndex(string URI
,string Dist
,string Section
,bool Trusted
) :
33 pkgIndexFile(Trusted
), URI(URI
), Dist(Dist
), Section(Section
)
37 // SourcesIndex::SourceInfo - Short 1 liner describing a source /*{{{*/
38 // ---------------------------------------------------------------------
39 /* The result looks like:
40 http://foo/debian/ stable/main src 1.1.1 (dsc) */
41 string
debSourcesIndex::SourceInfo(pkgSrcRecords::Parser
const &Record
,
42 pkgSrcRecords::File
const &File
) const
45 Res
= ::URI::NoUserPassword(URI
) + ' ';
46 if (Dist
[Dist
.size() - 1] == '/')
52 Res
+= Dist
+ '/' + Section
;
55 Res
+= Record
.Package();
57 Res
+= Record
.Version();
58 if (File
.Type
.empty() == false)
59 Res
+= " (" + File
.Type
+ ")";
63 // SourcesIndex::CreateSrcParser - Get a parser for the source files /*{{{*/
64 // ---------------------------------------------------------------------
66 pkgSrcRecords::Parser
*debSourcesIndex::CreateSrcParser() const
68 string SourcesURI
= _config
->FindDir("Dir::State::lists") +
69 URItoFileName(IndexURI("Sources"));
70 string SourcesURIgzip
= SourcesURI
+ ".gz";
72 if (!FileExists(SourcesURI
) && !FileExists(SourcesURIgzip
))
74 else if (!FileExists(SourcesURI
) && FileExists(SourcesURIgzip
))
75 SourcesURI
= SourcesURIgzip
;
77 return new debSrcRecordParser(SourcesURI
,this);
80 // SourcesIndex::Describe - Give a descriptive path to the index /*{{{*/
81 // ---------------------------------------------------------------------
83 string
debSourcesIndex::Describe(bool Short
) const
87 snprintf(S
,sizeof(S
),"%s",Info("Sources").c_str());
89 snprintf(S
,sizeof(S
),"%s (%s)",Info("Sources").c_str(),
90 IndexFile("Sources").c_str());
95 // SourcesIndex::Info - One liner describing the index URI /*{{{*/
96 // ---------------------------------------------------------------------
98 string
debSourcesIndex::Info(const char *Type
) const
100 string Info
= ::URI::NoUserPassword(URI
) + ' ';
101 if (Dist
[Dist
.size() - 1] == '/')
107 Info
+= Dist
+ '/' + Section
;
113 // SourcesIndex::Index* - Return the URI to the index files /*{{{*/
114 // ---------------------------------------------------------------------
116 inline string
debSourcesIndex::IndexFile(const char *Type
) const
118 string s
= URItoFileName(IndexURI(Type
));
119 string sgzip
= s
+ ".gz";
120 if (!FileExists(s
) && FileExists(sgzip
))
126 string
debSourcesIndex::IndexURI(const char *Type
) const
129 if (Dist
[Dist
.size() - 1] == '/')
137 Res
= URI
+ "dists/" + Dist
+ '/' + Section
+
144 // SourcesIndex::Exists - Check if the index is available /*{{{*/
145 // ---------------------------------------------------------------------
147 bool debSourcesIndex::Exists() const
149 return FileExists(IndexFile("Sources"));
152 // SourcesIndex::Size - Return the size of the index /*{{{*/
153 // ---------------------------------------------------------------------
155 unsigned long debSourcesIndex::Size() const
157 unsigned long size
= 0;
159 /* we need to ignore errors here; if the lists are absent, just return 0 */
160 _error
->PushToStack();
162 FileFd f
= FileFd (IndexFile("Sources"), FileFd::ReadOnly
, FileFd::Extension
);
166 if (_error
->PendingError() == true)
168 _error
->RevertToStack();
174 // PackagesIndex::debPackagesIndex - Contructor /*{{{*/
175 // ---------------------------------------------------------------------
177 debPackagesIndex::debPackagesIndex(string
const &URI
, string
const &Dist
, string
const &Section
,
178 bool const &Trusted
, string
const &Arch
) :
179 pkgIndexFile(Trusted
), URI(URI
), Dist(Dist
), Section(Section
), Architecture(Arch
)
181 if (Architecture
== "native")
182 Architecture
= _config
->Find("APT::Architecture");
185 // PackagesIndex::ArchiveInfo - Short version of the archive url /*{{{*/
186 // ---------------------------------------------------------------------
187 /* This is a shorter version that is designed to be < 60 chars or so */
188 string
debPackagesIndex::ArchiveInfo(pkgCache::VerIterator Ver
) const
190 string Res
= ::URI::NoUserPassword(URI
) + ' ';
191 if (Dist
[Dist
.size() - 1] == '/')
197 Res
+= Dist
+ '/' + Section
;
200 Res
+= Ver
.ParentPkg().Name();
202 if (Dist
[Dist
.size() - 1] != '/')
203 Res
.append(Ver
.Arch()).append(" ");
208 // PackagesIndex::Describe - Give a descriptive path to the index /*{{{*/
209 // ---------------------------------------------------------------------
210 /* This should help the user find the index in the sources.list and
211 in the filesystem for problem solving */
212 string
debPackagesIndex::Describe(bool Short
) const
216 snprintf(S
,sizeof(S
),"%s",Info("Packages").c_str());
218 snprintf(S
,sizeof(S
),"%s (%s)",Info("Packages").c_str(),
219 IndexFile("Packages").c_str());
223 // PackagesIndex::Info - One liner describing the index URI /*{{{*/
224 // ---------------------------------------------------------------------
226 string
debPackagesIndex::Info(const char *Type
) const
228 string Info
= ::URI::NoUserPassword(URI
) + ' ';
229 if (Dist
[Dist
.size() - 1] == '/')
235 Info
+= Dist
+ '/' + Section
;
237 if (Dist
[Dist
.size() - 1] != '/')
238 Info
+= Architecture
+ " ";
243 // PackagesIndex::Index* - Return the URI to the index files /*{{{*/
244 // ---------------------------------------------------------------------
246 inline string
debPackagesIndex::IndexFile(const char *Type
) const
248 string s
=_config
->FindDir("Dir::State::lists") + URItoFileName(IndexURI(Type
));
249 string sgzip
= s
+ ".gz";
250 if (!FileExists(s
) && FileExists(sgzip
))
255 string
debPackagesIndex::IndexURI(const char *Type
) const
258 if (Dist
[Dist
.size() - 1] == '/')
266 Res
= URI
+ "dists/" + Dist
+ '/' + Section
+
267 "/binary-" + Architecture
+ '/';
273 // PackagesIndex::Exists - Check if the index is available /*{{{*/
274 // ---------------------------------------------------------------------
276 bool debPackagesIndex::Exists() const
278 return FileExists(IndexFile("Packages"));
281 // PackagesIndex::Size - Return the size of the index /*{{{*/
282 // ---------------------------------------------------------------------
283 /* This is really only used for progress reporting. */
284 unsigned long debPackagesIndex::Size() const
286 unsigned long size
= 0;
288 /* we need to ignore errors here; if the lists are absent, just return 0 */
289 _error
->PushToStack();
291 FileFd f
= FileFd (IndexFile("Packages"), FileFd::ReadOnly
, FileFd::Extension
);
295 if (_error
->PendingError() == true)
297 _error
->RevertToStack();
302 // PackagesIndex::Merge - Load the index file into a cache /*{{{*/
303 // ---------------------------------------------------------------------
305 bool debPackagesIndex::Merge(pkgCacheGenerator
&Gen
,OpProgress
*Prog
) const
307 string PackageFile
= IndexFile("Packages");
308 FileFd
Pkg(PackageFile
,FileFd::ReadOnly
, FileFd::Extension
);
309 debListParser
Parser(&Pkg
, Architecture
);
311 if (_error
->PendingError() == true)
312 return _error
->Error("Problem opening %s",PackageFile
.c_str());
314 Prog
->SubProgress(0,Info("Packages"));
316 if (Gen
.SelectFile(PackageFile
,Tmp
.Host
,*this) == false)
317 return _error
->Error("Problem with SelectFile %s",PackageFile
.c_str());
319 // Store the IMS information
320 pkgCache::PkgFileIterator File
= Gen
.GetCurFile();
321 pkgCacheGenerator::Dynamic
<pkgCache::PkgFileIterator
> DynFile(File
);
322 File
->Size
= Pkg
.FileSize();
323 File
->mtime
= Pkg
.ModificationTime();
325 if (Gen
.MergeList(Parser
) == false)
326 return _error
->Error("Problem with MergeList %s",PackageFile
.c_str());
328 // Check the release file
329 string ReleaseFile
= debReleaseIndex(URI
,Dist
).MetaIndexFile("InRelease");
330 bool releaseExists
= false;
331 if (FileExists(ReleaseFile
) == true)
332 releaseExists
= true;
334 ReleaseFile
= debReleaseIndex(URI
,Dist
).MetaIndexFile("Release");
336 if (releaseExists
== true || FileExists(ReleaseFile
) == true)
338 FileFd
Rel(ReleaseFile
,FileFd::ReadOnly
);
339 if (_error
->PendingError() == true)
341 Parser
.LoadReleaseInfo(File
,Rel
,Section
);
347 // PackagesIndex::FindInCache - Find this index /*{{{*/
348 // ---------------------------------------------------------------------
350 pkgCache::PkgFileIterator
debPackagesIndex::FindInCache(pkgCache
&Cache
) const
352 string FileName
= IndexFile("Packages");
353 pkgCache::PkgFileIterator File
= Cache
.FileBegin();
354 for (; File
.end() == false; ++File
)
356 if (File
.FileName() == NULL
|| FileName
!= File
.FileName())
360 if (stat(File
.FileName(),&St
) != 0)
362 if (_config
->FindB("Debug::pkgCacheGen", false))
363 std::clog
<< "PackagesIndex::FindInCache - stat failed on " << File
.FileName() << std::endl
;
364 return pkgCache::PkgFileIterator(Cache
);
366 if ((unsigned)St
.st_size
!= File
->Size
|| St
.st_mtime
!= File
->mtime
)
368 if (_config
->FindB("Debug::pkgCacheGen", false))
369 std::clog
<< "PackagesIndex::FindInCache - size (" << St
.st_size
<< " <> " << File
->Size
370 << ") or mtime (" << St
.st_mtime
<< " <> " << File
->mtime
371 << ") doesn't match for " << File
.FileName() << std::endl
;
372 return pkgCache::PkgFileIterator(Cache
);
381 // TranslationsIndex::debTranslationsIndex - Contructor /*{{{*/
382 // ---------------------------------------------------------------------
384 debTranslationsIndex::debTranslationsIndex(string URI
,string Dist
,string Section
,
385 char const * const Translation
) :
386 pkgIndexFile(true), URI(URI
), Dist(Dist
), Section(Section
),
387 Language(Translation
)
390 // TranslationIndex::Trans* - Return the URI to the translation files /*{{{*/
391 // ---------------------------------------------------------------------
393 inline string
debTranslationsIndex::IndexFile(const char *Type
) const
395 string s
=_config
->FindDir("Dir::State::lists") + URItoFileName(IndexURI(Type
));
396 string sgzip
= s
+ ".gz";
397 if (!FileExists(s
) && FileExists(sgzip
))
402 string
debTranslationsIndex::IndexURI(const char *Type
) const
405 if (Dist
[Dist
.size() - 1] == '/')
413 Res
= URI
+ "dists/" + Dist
+ '/' + Section
+
414 "/i18n/Translation-";
420 // TranslationsIndex::GetIndexes - Fetch the index files /*{{{*/
421 // ---------------------------------------------------------------------
423 bool debTranslationsIndex::GetIndexes(pkgAcquire
*Owner
) const
425 string
const TranslationFile
= string("Translation-").append(Language
);
426 new pkgAcqIndexTrans(Owner
, IndexURI(Language
),
427 Info(TranslationFile
.c_str()),
433 // TranslationsIndex::Describe - Give a descriptive path to the index /*{{{*/
434 // ---------------------------------------------------------------------
435 /* This should help the user find the index in the sources.list and
436 in the filesystem for problem solving */
437 string
debTranslationsIndex::Describe(bool Short
) const
441 snprintf(S
,sizeof(S
),"%s",Info(TranslationFile().c_str()).c_str());
443 snprintf(S
,sizeof(S
),"%s (%s)",Info(TranslationFile().c_str()).c_str(),
444 IndexFile(Language
).c_str());
448 // TranslationsIndex::Info - One liner describing the index URI /*{{{*/
449 // ---------------------------------------------------------------------
451 string
debTranslationsIndex::Info(const char *Type
) const
453 string Info
= ::URI::NoUserPassword(URI
) + ' ';
454 if (Dist
[Dist
.size() - 1] == '/')
460 Info
+= Dist
+ '/' + Section
;
466 bool debTranslationsIndex::HasPackages() const /*{{{*/
468 return FileExists(IndexFile(Language
));
471 // TranslationsIndex::Exists - Check if the index is available /*{{{*/
472 // ---------------------------------------------------------------------
474 bool debTranslationsIndex::Exists() const
476 return FileExists(IndexFile(Language
));
479 // TranslationsIndex::Size - Return the size of the index /*{{{*/
480 // ---------------------------------------------------------------------
481 /* This is really only used for progress reporting. */
482 unsigned long debTranslationsIndex::Size() const
484 unsigned long size
= 0;
486 /* we need to ignore errors here; if the lists are absent, just return 0 */
487 _error
->PushToStack();
489 FileFd f
= FileFd (IndexFile(Language
), FileFd::ReadOnly
, FileFd::Extension
);
493 if (_error
->PendingError() == true)
495 _error
->RevertToStack();
500 // TranslationsIndex::Merge - Load the index file into a cache /*{{{*/
501 // ---------------------------------------------------------------------
503 bool debTranslationsIndex::Merge(pkgCacheGenerator
&Gen
,OpProgress
*Prog
) const
505 // Check the translation file, if in use
506 string TranslationFile
= IndexFile(Language
);
507 if (FileExists(TranslationFile
))
509 FileFd
Trans(TranslationFile
,FileFd::ReadOnly
, FileFd::Extension
);
510 debListParser
TransParser(&Trans
);
511 if (_error
->PendingError() == true)
515 Prog
->SubProgress(0, Info(TranslationFile
.c_str()));
516 if (Gen
.SelectFile(TranslationFile
,string(),*this) == false)
517 return _error
->Error("Problem with SelectFile %s",TranslationFile
.c_str());
519 // Store the IMS information
520 pkgCache::PkgFileIterator TransFile
= Gen
.GetCurFile();
521 TransFile
->Size
= Trans
.FileSize();
522 TransFile
->mtime
= Trans
.ModificationTime();
524 if (Gen
.MergeList(TransParser
) == false)
525 return _error
->Error("Problem with MergeList %s",TranslationFile
.c_str());
531 // TranslationsIndex::FindInCache - Find this index /*{{{*/
532 // ---------------------------------------------------------------------
534 pkgCache::PkgFileIterator
debTranslationsIndex::FindInCache(pkgCache
&Cache
) const
536 string FileName
= IndexFile(Language
);
538 pkgCache::PkgFileIterator File
= Cache
.FileBegin();
539 for (; File
.end() == false; ++File
)
541 if (FileName
!= File
.FileName())
545 if (stat(File
.FileName(),&St
) != 0)
547 if (_config
->FindB("Debug::pkgCacheGen", false))
548 std::clog
<< "TranslationIndex::FindInCache - stat failed on " << File
.FileName() << std::endl
;
549 return pkgCache::PkgFileIterator(Cache
);
551 if ((unsigned)St
.st_size
!= File
->Size
|| St
.st_mtime
!= File
->mtime
)
553 if (_config
->FindB("Debug::pkgCacheGen", false))
554 std::clog
<< "TranslationIndex::FindInCache - size (" << St
.st_size
<< " <> " << File
->Size
555 << ") or mtime (" << St
.st_mtime
<< " <> " << File
->mtime
556 << ") doesn't match for " << File
.FileName() << std::endl
;
557 return pkgCache::PkgFileIterator(Cache
);
564 // StatusIndex::debStatusIndex - Constructor /*{{{*/
565 // ---------------------------------------------------------------------
567 debStatusIndex::debStatusIndex(string File
) : pkgIndexFile(true), File(File
)
571 // StatusIndex::Size - Return the size of the index /*{{{*/
572 // ---------------------------------------------------------------------
574 unsigned long debStatusIndex::Size() const
577 if (stat(File
.c_str(),&S
) != 0)
582 // StatusIndex::Merge - Load the index file into a cache /*{{{*/
583 // ---------------------------------------------------------------------
585 bool debStatusIndex::Merge(pkgCacheGenerator
&Gen
,OpProgress
*Prog
) const
587 FileFd
Pkg(File
,FileFd::ReadOnly
, FileFd::Extension
);
588 if (_error
->PendingError() == true)
590 debListParser
Parser(&Pkg
);
591 if (_error
->PendingError() == true)
595 Prog
->SubProgress(0,File
);
596 if (Gen
.SelectFile(File
,string(),*this,pkgCache::Flag::NotSource
) == false)
597 return _error
->Error("Problem with SelectFile %s",File
.c_str());
599 // Store the IMS information
600 pkgCache::PkgFileIterator CFile
= Gen
.GetCurFile();
602 if (fstat(Pkg
.Fd(),&St
) != 0)
603 return _error
->Errno("fstat","Failed to stat");
604 CFile
->Size
= Pkg
.FileSize();
605 CFile
->mtime
= Pkg
.ModificationTime();
606 CFile
->Archive
= Gen
.WriteUniqString("now");
608 if (Gen
.MergeList(Parser
) == false)
609 return _error
->Error("Problem with MergeList %s",File
.c_str());
613 // StatusIndex::FindInCache - Find this index /*{{{*/
614 // ---------------------------------------------------------------------
616 pkgCache::PkgFileIterator
debStatusIndex::FindInCache(pkgCache
&Cache
) const
618 pkgCache::PkgFileIterator File
= Cache
.FileBegin();
619 for (; File
.end() == false; ++File
)
621 if (this->File
!= File
.FileName())
625 if (stat(File
.FileName(),&St
) != 0)
627 if (_config
->FindB("Debug::pkgCacheGen", false))
628 std::clog
<< "StatusIndex::FindInCache - stat failed on " << File
.FileName() << std::endl
;
629 return pkgCache::PkgFileIterator(Cache
);
631 if ((unsigned)St
.st_size
!= File
->Size
|| St
.st_mtime
!= File
->mtime
)
633 if (_config
->FindB("Debug::pkgCacheGen", false))
634 std::clog
<< "StatusIndex::FindInCache - size (" << St
.st_size
<< " <> " << File
->Size
635 << ") or mtime (" << St
.st_mtime
<< " <> " << File
->mtime
636 << ") doesn't match for " << File
.FileName() << std::endl
;
637 return pkgCache::PkgFileIterator(Cache
);
644 // StatusIndex::Exists - Check if the index is available /*{{{*/
645 // ---------------------------------------------------------------------
647 bool debStatusIndex::Exists() const
649 // Abort if the file does not exist.
654 // Index File types for Debian /*{{{*/
655 class debIFTypeSrc
: public pkgIndexFile::Type
659 debIFTypeSrc() {Label
= "Debian Source Index";};
661 class debIFTypePkg
: public pkgIndexFile::Type
665 virtual pkgRecords::Parser
*CreatePkgParser(pkgCache::PkgFileIterator File
) const
667 return new debRecordParser(File
.FileName(),*File
.Cache());
669 debIFTypePkg() {Label
= "Debian Package Index";};
671 class debIFTypeTrans
: public debIFTypePkg
674 debIFTypeTrans() {Label
= "Debian Translation Index";};
676 class debIFTypeStatus
: public pkgIndexFile::Type
680 virtual pkgRecords::Parser
*CreatePkgParser(pkgCache::PkgFileIterator File
) const
682 return new debRecordParser(File
.FileName(),*File
.Cache());
684 debIFTypeStatus() {Label
= "Debian dpkg status file";};
686 static debIFTypeSrc _apt_Src
;
687 static debIFTypePkg _apt_Pkg
;
688 static debIFTypeTrans _apt_Trans
;
689 static debIFTypeStatus _apt_Status
;
691 const pkgIndexFile::Type
*debSourcesIndex::GetType() const
695 const pkgIndexFile::Type
*debPackagesIndex::GetType() const
699 const pkgIndexFile::Type
*debTranslationsIndex::GetType() const
703 const pkgIndexFile::Type
*debStatusIndex::GetType() const