]> git.saurik.com Git - apt.git/blob - apt-pkg/deb/debrecords.cc
pkgPolicy: Introduce storage and helpers for per-version pins
[apt.git] / apt-pkg / deb / debrecords.cc
1 // -*- mode: cpp; mode: fold -*-
2 // Description /*{{{*/
3 // $Id: debrecords.cc,v 1.10 2001/03/13 06:51:46 jgg Exp $
4 /* ######################################################################
5
6 Debian Package Records - Parser for debian package records
7
8 ##################################################################### */
9 /*}}}*/
10 // Include Files /*{{{*/
11 #include <config.h>
12
13 #include <apt-pkg/debrecords.h>
14 #include <apt-pkg/debindexfile.h>
15 #include <apt-pkg/strutl.h>
16 #include <apt-pkg/aptconfiguration.h>
17 #include <apt-pkg/fileutl.h>
18 #include <apt-pkg/cacheiterators.h>
19 #include <apt-pkg/pkgcache.h>
20 #include <apt-pkg/tagfile.h>
21 #include <apt-pkg/error.h>
22
23 #include <string.h>
24 #include <algorithm>
25 #include <sstream>
26 #include <string>
27 #include <vector>
28 #include <langinfo.h>
29
30 #include <apti18n.h>
31 /*}}}*/
32
33 using std::string;
34
35 // RecordParser::debRecordParser - Constructor /*{{{*/
36 debRecordParser::debRecordParser(string FileName,pkgCache &Cache) :
37 debRecordParserBase(), File(FileName, FileFd::ReadOnly, FileFd::Extension),
38 Tags(&File, std::max(Cache.Head().MaxVerFileSize, Cache.Head().MaxDescFileSize) + 200)
39 {
40 }
41 /*}}}*/
42 // RecordParser::Jump - Jump to a specific record /*{{{*/
43 bool debRecordParser::Jump(pkgCache::VerFileIterator const &Ver)
44 {
45 return Tags.Jump(Section,Ver->Offset);
46 }
47 bool debRecordParser::Jump(pkgCache::DescFileIterator const &Desc)
48 {
49 return Tags.Jump(Section,Desc->Offset);
50 }
51 /*}}}*/
52 debRecordParser::~debRecordParser() {}
53
54 debRecordParserBase::debRecordParserBase() : Parser() {}
55 // RecordParserBase::FileName - Return the archive filename on the site /*{{{*/
56 string debRecordParserBase::FileName()
57 {
58 return Section.FindS("Filename");
59 }
60 /*}}}*/
61 // RecordParserBase::Name - Return the package name /*{{{*/
62 string debRecordParserBase::Name()
63 {
64 return Section.FindS("Package");
65 }
66 /*}}}*/
67 // RecordParserBase::Homepage - Return the package homepage /*{{{*/
68 string debRecordParserBase::Homepage()
69 {
70 return Section.FindS("Homepage");
71 }
72 /*}}}*/
73 // RecordParserBase::Hashes - return the available archive hashes /*{{{*/
74 HashStringList debRecordParserBase::Hashes() const
75 {
76 HashStringList hashes;
77 for (char const * const * type = HashString::SupportedHashes(); *type != NULL; ++type)
78 {
79 std::string const hash = Section.FindS(*type);
80 if (hash.empty() == false)
81 hashes.push_back(HashString(*type, hash));
82 }
83 return hashes;
84 }
85 /*}}}*/
86 // RecordParserBase::Maintainer - Return the maintainer email /*{{{*/
87 string debRecordParserBase::Maintainer()
88 {
89 return Section.FindS("Maintainer");
90 }
91 /*}}}*/
92 // RecordParserBase::RecordField - Return the value of an arbitrary field /*{{*/
93 string debRecordParserBase::RecordField(const char *fieldName)
94 {
95 return Section.FindS(fieldName);
96 }
97 /*}}}*/
98 // RecordParserBase::ShortDesc - Return a 1 line description /*{{{*/
99 string debRecordParserBase::ShortDesc(std::string const &lang)
100 {
101 string const Res = LongDesc(lang);
102 if (Res.empty() == true)
103 return "";
104 string::size_type const Pos = Res.find('\n');
105 if (Pos == string::npos)
106 return Res;
107 return string(Res,0,Pos);
108 }
109 /*}}}*/
110 // RecordParserBase::LongDesc - Return a longer description /*{{{*/
111 string debRecordParserBase::LongDesc(std::string const &lang)
112 {
113 string orig;
114 if (lang.empty() == true)
115 {
116 std::vector<string> const lang = APT::Configuration::getLanguages();
117 for (std::vector<string>::const_iterator l = lang.begin();
118 l != lang.end(); ++l)
119 {
120 std::string const tagname = "Description-" + *l;
121 orig = Section.FindS(tagname.c_str());
122 if (orig.empty() == false)
123 break;
124 else if (*l == "en")
125 {
126 orig = Section.FindS("Description");
127 if (orig.empty() == false)
128 break;
129 }
130 }
131 if (orig.empty() == true)
132 orig = Section.FindS("Description");
133 }
134 else
135 {
136 std::string const tagname = "Description-" + lang;
137 orig = Section.FindS(tagname.c_str());
138 if (orig.empty() == true && lang == "en")
139 orig = Section.FindS("Description");
140 }
141
142 char const * const codeset = nl_langinfo(CODESET);
143 if (strcmp(codeset,"UTF-8") != 0) {
144 string dest;
145 UTF8ToCodeset(codeset, orig, &dest);
146 return dest;
147 }
148
149 return orig;
150 }
151 /*}}}*/
152
153 static const char * const SourceVerSeparators = " ()";
154 // RecordParserBase::SourcePkg - Return the source package name if any /*{{{*/
155 string debRecordParserBase::SourcePkg()
156 {
157 string Res = Section.FindS("Source");
158 string::size_type Pos = Res.find_first_of(SourceVerSeparators);
159 if (Pos == string::npos)
160 return Res;
161 return string(Res,0,Pos);
162 }
163 /*}}}*/
164 // RecordParserBase::SourceVer - Return the source version number if present /*{{{*/
165 string debRecordParserBase::SourceVer()
166 {
167 string Pkg = Section.FindS("Source");
168 string::size_type Pos = Pkg.find_first_of(SourceVerSeparators);
169 if (Pos == string::npos)
170 return "";
171
172 string::size_type VerStart = Pkg.find_first_not_of(SourceVerSeparators, Pos);
173 if(VerStart == string::npos)
174 return "";
175
176 string::size_type VerEnd = Pkg.find_first_of(SourceVerSeparators, VerStart);
177 if(VerEnd == string::npos)
178 // Corresponds to the case of, e.g., "foo (1.2" without a closing
179 // paren. Be liberal and guess what it means.
180 return string(Pkg, VerStart);
181 else
182 return string(Pkg, VerStart, VerEnd - VerStart);
183 }
184 /*}}}*/
185 // RecordParserBase::GetRec - Return the whole record /*{{{*/
186 void debRecordParserBase::GetRec(const char *&Start,const char *&Stop)
187 {
188 Section.GetSection(Start,Stop);
189 }
190 /*}}}*/
191 debRecordParserBase::~debRecordParserBase() {}
192
193 bool debDebFileRecordParser::LoadContent()
194 {
195 // load content only once
196 if (controlContent.empty() == false)
197 return true;
198
199 std::ostringstream content;
200 if (debDebPkgFileIndex::GetContent(content, debFileName) == false)
201 return false;
202 // add two newlines to make sure the scanner finds the section,
203 // which is usually done by pkgTagFile automatically if needed.
204 content << "\n\n";
205
206 controlContent = content.str();
207 if (Section.Scan(controlContent.c_str(), controlContent.length()) == false)
208 return _error->Error(_("Unable to parse package file %s (%d)"), debFileName.c_str(), 3);
209 return true;
210 }
211 bool debDebFileRecordParser::Jump(pkgCache::VerFileIterator const &) { return LoadContent(); }
212 bool debDebFileRecordParser::Jump(pkgCache::DescFileIterator const &) { return LoadContent(); }
213 std::string debDebFileRecordParser::FileName() { return debFileName; }
214
215 debDebFileRecordParser::debDebFileRecordParser(std::string FileName) : debRecordParserBase(), debFileName(FileName) {}
216 debDebFileRecordParser::~debDebFileRecordParser() {}