]> git.saurik.com Git - apt.git/blame - apt-pkg/indexfile.cc
prevent C++ locale number formatting in text APIs (try 2)
[apt.git] / apt-pkg / indexfile.cc
CommitLineData
b2e465d6
AL
1// -*- mode: cpp; mode: fold -*-
2// Description /*{{{*/
7db98ffc 3// $Id: indexfile.cc,v 1.2.2.1 2003/12/24 23:09:17 mdz Exp $
b2e465d6
AL
4/* ######################################################################
5
6 Index File - Abstraction for an index of archive/souce file.
7
8 ##################################################################### */
9 /*}}}*/
10// Include Files /*{{{*/
ea542140
DK
11#include<config.h>
12
e3c1cfc7 13#include <apt-pkg/configuration.h>
b2e465d6
AL
14#include <apt-pkg/indexfile.h>
15#include <apt-pkg/error.h>
e3c1cfc7 16#include <apt-pkg/fileutl.h>
45df0ad2 17#include <apt-pkg/aptconfiguration.h>
453b82a3 18#include <apt-pkg/pkgcache.h>
c9443c01 19#include <apt-pkg/pkgcachegen.h>
453b82a3
DK
20#include <apt-pkg/cacheiterators.h>
21#include <apt-pkg/srcrecords.h>
d7a51997 22#include <apt-pkg/strutl.h>
c9443c01 23#include <apt-pkg/progress.h>
64b66a46 24#include <apt-pkg/deblistparser.h>
453b82a3 25#include <apt-pkg/macros.h>
a52f938b 26
64b66a46 27#include <apt-pkg/debindexfile.h>
c9443c01 28
c9443c01 29#include <sys/stat.h>
c9443c01 30
453b82a3
DK
31#include <string>
32#include <vector>
a52f938b 33#include <clocale>
4f333a8b 34#include <cstring>
c9443c01 35#include <memory>
b2e465d6
AL
36 /*}}}*/
37
38// Global list of Item supported
39static pkgIndexFile::Type *ItmList[10];
40pkgIndexFile::Type **pkgIndexFile::Type::GlobalList = ItmList;
41unsigned long pkgIndexFile::Type::GlobalListLen = 0;
42
43// Type::Type - Constructor /*{{{*/
44// ---------------------------------------------------------------------
45/* */
46pkgIndexFile::Type::Type()
47{
48 ItmList[GlobalListLen] = this;
dd688285
DK
49 GlobalListLen++;
50 Label = NULL;
b2e465d6
AL
51}
52 /*}}}*/
53// Type::GetType - Locate the type by name /*{{{*/
54// ---------------------------------------------------------------------
55/* */
56pkgIndexFile::Type *pkgIndexFile::Type::GetType(const char *Type)
57{
58 for (unsigned I = 0; I != GlobalListLen; I++)
59 if (strcmp(GlobalList[I]->Label,Type) == 0)
60 return GlobalList[I];
61 return 0;
e3c1cfc7
DK
62}
63 /*}}}*/
c9443c01 64pkgIndexFile::pkgIndexFile(bool const Trusted) : /*{{{*/
6c55f07a 65 d(NULL), Trusted(Trusted)
e3c1cfc7 66{
b2e465d6
AL
67}
68 /*}}}*/
b2e465d6 69// IndexFile::ArchiveInfo - Stub /*{{{*/
64b66a46 70std::string pkgIndexFile::ArchiveInfo(pkgCache::VerIterator const &Ver) const
b2e465d6 71{
64b66a46
DK
72 debDebPkgFileIndex const * const debfile = dynamic_cast<debDebPkgFileIndex const*>(this);
73 if (debfile != nullptr)
74 return debfile->ArchiveInfo_impl(Ver);
8f3ba4e8 75 return std::string();
b2e465d6
AL
76}
77 /*}}}*/
78// IndexFile::FindInCache - Stub /*{{{*/
b2e465d6
AL
79pkgCache::PkgFileIterator pkgIndexFile::FindInCache(pkgCache &Cache) const
80{
81 return pkgCache::PkgFileIterator(Cache);
82}
83 /*}}}*/
84// IndexFile::SourceIndex - Stub /*{{{*/
65512241
DK
85std::string pkgIndexFile::SourceInfo(pkgSrcRecords::Parser const &/*Record*/,
86 pkgSrcRecords::File const &/*File*/) const
b2e465d6 87{
8f3ba4e8 88 return std::string();
b2e465d6
AL
89}
90 /*}}}*/
45df0ad2 91// IndexFile::TranslationsAvailable - Check if will use Translation /*{{{*/
45df0ad2
DK
92bool pkgIndexFile::TranslationsAvailable() {
93 return (APT::Configuration::getLanguages().empty() != true);
a52f938b
OS
94}
95 /*}}}*/
45df0ad2 96// IndexFile::CheckLanguageCode - Check the Language Code /*{{{*/
5dd00edb 97bool pkgIndexFile::CheckLanguageCode(const char * const Lang)
a52f938b
OS
98{
99 if (strlen(Lang) == 2 || (strlen(Lang) == 5 && Lang[2] == '_'))
100 return true;
101
102 if (strcmp(Lang,"C") != 0)
103 _error->Warning("Wrong language code %s", Lang);
104
105 return false;
106}
107 /*}}}*/
45df0ad2 108// IndexFile::LanguageCode - Return the Language Code /*{{{*/
5dd00edb 109std::string pkgIndexFile::LanguageCode() {
668ae33a 110APT_IGNORE_DEPRECATED_PUSH
45df0ad2
DK
111 if (TranslationsAvailable() == false)
112 return "";
113 return APT::Configuration::getLanguages()[0];
668ae33a 114APT_IGNORE_DEPRECATED_POP
a52f938b
OS
115}
116 /*}}}*/
e3c1cfc7
DK
117
118// IndexTarget - Constructor /*{{{*/
119IndexTarget::IndexTarget(std::string const &MetaKey, std::string const &ShortDesc,
120 std::string const &LongDesc, std::string const &URI, bool const IsOptional,
653ef26c
DK
121 bool const KeepCompressed, std::map<std::string, std::string> const &Options) :
122 URI(URI), Description(LongDesc), ShortDesc(ShortDesc), MetaKey(MetaKey),
123 IsOptional(IsOptional), KeepCompressed(KeepCompressed), Options(Options)
e3c1cfc7
DK
124{
125}
126 /*}}}*/
001c76fe 127std::string IndexTarget::Option(OptionKeys const EnumKey) const /*{{{*/
e3c1cfc7 128{
001c76fe
DK
129 std::string Key;
130 switch (EnumKey)
131 {
132#define APT_CASE(X) case X: Key = #X; break
133 APT_CASE(SITE);
134 APT_CASE(RELEASE);
135 APT_CASE(COMPONENT);
136 APT_CASE(LANGUAGE);
137 APT_CASE(ARCHITECTURE);
138 APT_CASE(BASE_URI);
139 APT_CASE(REPO_URI);
39c724b4 140 APT_CASE(IDENTIFIER);
8881b11e 141 APT_CASE(TARGET_OF);
001c76fe 142 APT_CASE(CREATED_BY);
7f2d1eef 143 APT_CASE(FALLBACK_OF);
1a3a14ac 144 APT_CASE(PDIFFS);
9adb9778 145 APT_CASE(DEFAULTENABLED);
d7a51997 146 APT_CASE(COMPRESSIONTYPES);
3090ae69 147 APT_CASE(SOURCESENTRY);
24e8f24e 148 APT_CASE(BY_HASH);
0179cfa8 149 APT_CASE(KEEPCOMPRESSEDAS);
d03b947b
DK
150 APT_CASE(ALLOW_INSECURE);
151 APT_CASE(ALLOW_WEAK);
152 APT_CASE(ALLOW_DOWNGRADE_TO_INSECURE);
001c76fe 153#undef APT_CASE
8881b11e 154 case FILENAME: return _config->FindDir("Dir::State::lists") + URItoFileName(URI);
3fd89e62
DK
155 case EXISTING_FILENAME:
156 std::string const filename = Option(FILENAME);
d7a51997 157 std::vector<std::string> const types = VectorizeString(Option(COMPRESSIONTYPES), ' ');
3fd89e62
DK
158 for (std::vector<std::string>::const_iterator t = types.begin(); t != types.end(); ++t)
159 {
160 if (t->empty())
161 continue;
162 std::string const file = (*t == "uncompressed") ? filename : (filename + "." + *t);
163 if (FileExists(file))
164 return file;
165 }
166 return "";
001c76fe 167 }
e3c1cfc7
DK
168 std::map<std::string,std::string>::const_iterator const M = Options.find(Key);
169 if (M == Options.end())
170 return "";
171 return M->second;
172}
173 /*}}}*/
1a3a14ac
DK
174bool IndexTarget::OptionBool(OptionKeys const EnumKey) const /*{{{*/
175{
d03b947b 176 return StringToBool(Option(EnumKey), false);
1a3a14ac
DK
177}
178 /*}}}*/
8881b11e
DK
179std::string IndexTarget::Format(std::string format) const /*{{{*/
180{
181 for (std::map<std::string, std::string>::const_iterator O = Options.begin(); O != Options.end(); ++O)
182 {
183 format = SubstVar(format, std::string("$(") + O->first + ")", O->second);
184 }
185 format = SubstVar(format, "$(METAKEY)", MetaKey);
186 format = SubstVar(format, "$(SHORTDESC)", ShortDesc);
187 format = SubstVar(format, "$(DESCRIPTION)", Description);
188 format = SubstVar(format, "$(URI)", URI);
189 format = SubstVar(format, "$(FILENAME)", Option(IndexTarget::FILENAME));
190 return format;
191}
192 /*}}}*/
e3c1cfc7 193
c9443c01
DK
194pkgDebianIndexTargetFile::pkgDebianIndexTargetFile(IndexTarget const &Target, bool const Trusted) :/*{{{*/
195 pkgDebianIndexFile(Trusted), d(NULL), Target(Target)
e3c1cfc7
DK
196{
197}
198 /*}}}*/
c9443c01 199std::string pkgDebianIndexTargetFile::ArchiveURI(std::string const &File) const/*{{{*/
e3c1cfc7 200{
001c76fe 201 return Target.Option(IndexTarget::REPO_URI) + File;
e3c1cfc7
DK
202}
203 /*}}}*/
c9443c01 204std::string pkgDebianIndexTargetFile::Describe(bool const Short) const /*{{{*/
e3c1cfc7
DK
205{
206 if (Short)
207 return Target.Description;
208 return Target.Description + " (" + IndexFileName() + ")";
209}
210 /*}}}*/
c9443c01 211std::string pkgDebianIndexTargetFile::IndexFileName() const /*{{{*/
e3c1cfc7 212{
8881b11e 213 std::string const s = Target.Option(IndexTarget::FILENAME);
e3c1cfc7
DK
214 if (FileExists(s))
215 return s;
216
d7a51997 217 std::vector<std::string> const types = VectorizeString(Target.Option(IndexTarget::COMPRESSIONTYPES), ' ');
e3c1cfc7
DK
218 for (std::vector<std::string>::const_iterator t = types.begin(); t != types.end(); ++t)
219 {
220 std::string p = s + '.' + *t;
221 if (FileExists(p))
222 return p;
223 }
224 return s;
225}
226 /*}}}*/
c9443c01 227unsigned long pkgDebianIndexTargetFile::Size() const /*{{{*/
e3c1cfc7
DK
228{
229 unsigned long size = 0;
230
231 /* we need to ignore errors here; if the lists are absent, just return 0 */
232 _error->PushToStack();
233
234 FileFd f(IndexFileName(), FileFd::ReadOnly, FileFd::Extension);
235 if (!f.Failed())
236 size = f.Size();
237
238 if (_error->PendingError() == true)
239 size = 0;
240 _error->RevertToStack();
241
242 return size;
243}
244 /*}}}*/
c9443c01 245bool pkgDebianIndexTargetFile::Exists() const /*{{{*/
e3c1cfc7
DK
246{
247 return FileExists(IndexFileName());
248}
249 /*}}}*/
c9443c01
DK
250std::string pkgDebianIndexTargetFile::GetArchitecture() const /*{{{*/
251{
252 return Target.Option(IndexTarget::ARCHITECTURE);
253}
254 /*}}}*/
255std::string pkgDebianIndexTargetFile::GetComponent() const /*{{{*/
256{
257 return Target.Option(IndexTarget::COMPONENT);
258}
259 /*}}}*/
260bool pkgDebianIndexTargetFile::OpenListFile(FileFd &Pkg, std::string const &FileName)/*{{{*/
261{
262 if (Pkg.Open(FileName, FileFd::ReadOnly, FileFd::Extension) == false)
263 return _error->Error("Problem opening %s",FileName.c_str());
264 return true;
265}
266 /*}}}*/
267std::string pkgDebianIndexTargetFile::GetProgressDescription() const
268{
269 return Target.Description;
270}
271
7f58427b
DK
272pkgDebianIndexRealFile::pkgDebianIndexRealFile(std::string const &pFile, bool const Trusted) :/*{{{*/
273 pkgDebianIndexFile(Trusted), d(NULL)
c9443c01 274{
a249b3e6
DK
275 if (pFile.empty())
276 ;
277 else if (pFile == "/nonexistent/stdin")
7f58427b
DK
278 File = pFile;
279 else
280 File = flAbsPath(pFile);
c9443c01
DK
281}
282 /*}}}*/
283// IndexRealFile::Size - Return the size of the index /*{{{*/
284unsigned long pkgDebianIndexRealFile::Size() const
285{
286 struct stat S;
287 if (stat(File.c_str(),&S) != 0)
288 return 0;
289 return S.st_size;
290}
291 /*}}}*/
292bool pkgDebianIndexRealFile::Exists() const /*{{{*/
293{
294 return FileExists(File);
295}
296 /*}}}*/
297std::string pkgDebianIndexRealFile::Describe(bool const /*Short*/) const/*{{{*/
298{
299 return File;
300}
301 /*}}}*/
302std::string pkgDebianIndexRealFile::ArchiveURI(std::string const &/*File*/) const/*{{{*/
303{
304 return "file:" + File;
305}
306 /*}}}*/
307std::string pkgDebianIndexRealFile::IndexFileName() const /*{{{*/
308{
309 return File;
310}
311 /*}}}*/
312std::string pkgDebianIndexRealFile::GetProgressDescription() const
313{
314 return File;
315}
316bool pkgDebianIndexRealFile::OpenListFile(FileFd &Pkg, std::string const &FileName)/*{{{*/
317{
f41352ad 318 if (Pkg.Open(FileName, FileFd::ReadOnly, FileFd::Extension) == false)
c9443c01
DK
319 return _error->Error("Problem opening %s",FileName.c_str());
320 return true;
321}
322 /*}}}*/
323
324pkgDebianIndexFile::pkgDebianIndexFile(bool const Trusted) : pkgIndexFile(Trusted)
325{
326}
327pkgDebianIndexFile::~pkgDebianIndexFile()
328{
329}
330pkgCacheListParser * pkgDebianIndexFile::CreateListParser(FileFd &Pkg)
331{
332 if (Pkg.IsOpen() == false)
c48ef894 333 return nullptr;
c9443c01 334 _error->PushToStack();
7f8c0eed 335 pkgCacheListParser * const Parser = new debListParser(&Pkg);
c9443c01
DK
336 bool const newError = _error->PendingError();
337 _error->MergeWithStack();
c48ef894
DK
338 if (newError)
339 {
340 delete Parser;
341 return nullptr;
342 }
343 else
344 return Parser;
c9443c01
DK
345}
346bool pkgDebianIndexFile::Merge(pkgCacheGenerator &Gen,OpProgress * const Prog)
347{
348 std::string const PackageFile = IndexFileName();
349 FileFd Pkg;
350 if (OpenListFile(Pkg, PackageFile) == false)
351 return false;
352 _error->PushToStack();
353 std::unique_ptr<pkgCacheListParser> Parser(CreateListParser(Pkg));
354 bool const newError = _error->PendingError();
95278287 355 _error->MergeWithStack();
c9443c01
DK
356 if (newError == false && Parser == nullptr)
357 return true;
358 if (Parser == NULL)
359 return false;
360
361 if (Prog != NULL)
362 Prog->SubProgress(0, GetProgressDescription());
363
364 if (Gen.SelectFile(PackageFile, *this, GetArchitecture(), GetComponent(), GetIndexFlags()) == false)
365 return _error->Error("Problem with SelectFile %s",PackageFile.c_str());
366
367 // Store the IMS information
368 pkgCache::PkgFileIterator File = Gen.GetCurFile();
369 pkgCacheGenerator::Dynamic<pkgCache::PkgFileIterator> DynFile(File);
370 File->Size = Pkg.FileSize();
371 File->mtime = Pkg.ModificationTime();
372
373 if (Gen.MergeList(*Parser) == false)
374 return _error->Error("Problem with MergeList %s",PackageFile.c_str());
375 return true;
376}
377pkgCache::PkgFileIterator pkgDebianIndexFile::FindInCache(pkgCache &Cache) const
378{
379 std::string const FileName = IndexFileName();
380 pkgCache::PkgFileIterator File = Cache.FileBegin();
381 for (; File.end() == false; ++File)
382 {
383 if (File.FileName() == NULL || FileName != File.FileName())
384 continue;
385
386 struct stat St;
387 if (stat(File.FileName(),&St) != 0)
388 {
389 if (_config->FindB("Debug::pkgCacheGen", false))
390 std::clog << "DebianIndexFile::FindInCache - stat failed on " << File.FileName() << std::endl;
391 return pkgCache::PkgFileIterator(Cache);
392 }
393 if ((map_filesize_t)St.st_size != File->Size || St.st_mtime != File->mtime)
394 {
395 if (_config->FindB("Debug::pkgCacheGen", false))
396 std::clog << "DebianIndexFile::FindInCache - size (" << St.st_size << " <> " << File->Size
397 << ") or mtime (" << St.st_mtime << " <> " << File->mtime
398 << ") doesn't match for " << File.FileName() << std::endl;
399 return pkgCache::PkgFileIterator(Cache);
400 }
401 return File;
402 }
403
404 return File;
405}
c8a4ce6c
DK
406
407APT_CONST pkgIndexFile::~pkgIndexFile() {}
c9443c01
DK
408APT_CONST pkgDebianIndexTargetFile::~pkgDebianIndexTargetFile() {}
409APT_CONST pkgDebianIndexRealFile::~pkgDebianIndexRealFile() {}