]>
Commit | Line | Data |
---|---|---|
1 | // ijones, walters | |
2 | ||
3 | #ifdef __GNUG__ | |
4 | #pragma implementation "apt-pkg/debmetaindex.h" | |
5 | #endif | |
6 | ||
7 | #include <apt-pkg/debmetaindex.h> | |
8 | #include <apt-pkg/debindexfile.h> | |
9 | #include <apt-pkg/strutl.h> | |
10 | #include <apt-pkg/acquire-item.h> | |
11 | #include <apt-pkg/configuration.h> | |
12 | #include <apt-pkg/error.h> | |
13 | ||
14 | using namespace std; | |
15 | ||
16 | string debReleaseIndex::Info(const char *Type, const string Section) const | |
17 | { | |
18 | string Info = ::URI::SiteOnly(URI) + ' '; | |
19 | if (Dist[Dist.size() - 1] == '/') | |
20 | { | |
21 | if (Dist != "/") | |
22 | Info += Dist; | |
23 | } | |
24 | else | |
25 | Info += Dist + '/' + Section; | |
26 | Info += " "; | |
27 | Info += Type; | |
28 | return Info; | |
29 | } | |
30 | ||
31 | string debReleaseIndex::MetaIndexInfo(const char *Type) const | |
32 | { | |
33 | string Info = ::URI::SiteOnly(URI) + ' '; | |
34 | if (Dist[Dist.size() - 1] == '/') | |
35 | { | |
36 | if (Dist != "/") | |
37 | Info += Dist; | |
38 | } | |
39 | else | |
40 | Info += Dist; | |
41 | Info += " "; | |
42 | Info += Type; | |
43 | return Info; | |
44 | } | |
45 | ||
46 | string debReleaseIndex::MetaIndexFile(const char *Type) const | |
47 | { | |
48 | return _config->FindDir("Dir::State::lists") + | |
49 | URItoFileName(MetaIndexURI(Type)); | |
50 | } | |
51 | ||
52 | string debReleaseIndex::MetaIndexURI(const char *Type) const | |
53 | { | |
54 | string Res; | |
55 | ||
56 | if (Dist == "/") | |
57 | Res = URI; | |
58 | else if (Dist[Dist.size()-1] == '/') | |
59 | Res = URI + Dist; | |
60 | else | |
61 | Res = URI + "dists/" + Dist + "/"; | |
62 | ||
63 | Res += Type; | |
64 | return Res; | |
65 | } | |
66 | ||
67 | string debReleaseIndex::IndexURISuffix(const char *Type, const string Section) const | |
68 | { | |
69 | string Res =""; | |
70 | if (Dist[Dist.size() - 1] != '/') | |
71 | Res += Section + "/binary-" + _config->Find("APT::Architecture") + '/'; | |
72 | return Res + Type; | |
73 | } | |
74 | ||
75 | ||
76 | string debReleaseIndex::IndexURI(const char *Type, const string Section) const | |
77 | { | |
78 | if (Dist[Dist.size() - 1] == '/') | |
79 | { | |
80 | string Res; | |
81 | if (Dist != "/") | |
82 | Res = URI + Dist; | |
83 | else | |
84 | Res = URI; | |
85 | return Res + Type; | |
86 | } | |
87 | else | |
88 | return URI + "dists/" + Dist + '/' + IndexURISuffix(Type, Section); | |
89 | } | |
90 | ||
91 | string debReleaseIndex::SourceIndexURISuffix(const char *Type, const string Section) const | |
92 | { | |
93 | string Res =""; | |
94 | if (Dist[Dist.size() - 1] != '/') | |
95 | Res += Section + "/source/"; | |
96 | return Res + Type; | |
97 | } | |
98 | ||
99 | string debReleaseIndex::SourceIndexURI(const char *Type, const string Section) const | |
100 | { | |
101 | string Res; | |
102 | if (Dist[Dist.size() - 1] == '/') | |
103 | { | |
104 | if (Dist != "/") | |
105 | Res = URI + Dist; | |
106 | else | |
107 | Res = URI; | |
108 | return Res + Type; | |
109 | } | |
110 | else | |
111 | return URI + "dists/" + Dist + "/" + SourceIndexURISuffix(Type, Section); | |
112 | } | |
113 | ||
114 | debReleaseIndex::debReleaseIndex(string URI,string Dist) | |
115 | { | |
116 | this->URI = URI; | |
117 | this->Dist = Dist; | |
118 | this->Indexes = NULL; | |
119 | this->Type = "deb"; | |
120 | } | |
121 | ||
122 | vector <struct IndexTarget *>* debReleaseIndex::ComputeIndexTargets() const | |
123 | { | |
124 | vector <struct IndexTarget *>* IndexTargets = new vector <IndexTarget *>; | |
125 | for (vector <const debSectionEntry *>::const_iterator I = SectionEntries.begin(); | |
126 | I != SectionEntries.end(); | |
127 | I++) | |
128 | { | |
129 | IndexTarget * Target = new IndexTarget(); | |
130 | Target->ShortDesc = (*I)->IsSrc ? "Sources" : "Packages"; | |
131 | Target->MetaKey | |
132 | = (*I)->IsSrc ? SourceIndexURISuffix(Target->ShortDesc.c_str(), (*I)->Section) | |
133 | : IndexURISuffix(Target->ShortDesc.c_str(), (*I)->Section); | |
134 | Target->URI | |
135 | = (*I)->IsSrc ? SourceIndexURI(Target->ShortDesc.c_str(), (*I)->Section) | |
136 | : IndexURI(Target->ShortDesc.c_str(), (*I)->Section); | |
137 | ||
138 | Target->Description = Info (Target->ShortDesc.c_str(), (*I)->Section); | |
139 | IndexTargets->push_back (Target); | |
140 | } | |
141 | return IndexTargets; | |
142 | } | |
143 | /*}}}*/ | |
144 | bool debReleaseIndex::GetIndexes(pkgAcquire *Owner, bool GetAll) const | |
145 | { | |
146 | // special case for --print-uris | |
147 | if (GetAll) { | |
148 | vector <struct IndexTarget *> *targets = ComputeIndexTargets(); | |
149 | for (vector <struct IndexTarget*>::const_iterator Target = targets->begin(); Target != targets->end(); Target++) { | |
150 | new pkgAcqIndex(Owner, (*Target)->URI, (*Target)->Description, | |
151 | (*Target)->ShortDesc, ""); | |
152 | } | |
153 | } | |
154 | new pkgAcqMetaSig(Owner, MetaIndexURI("Release.gpg"), | |
155 | MetaIndexInfo("Release.gpg"), "Release.gpg", | |
156 | MetaIndexURI("Release"), MetaIndexInfo("Release"), "Release", | |
157 | ComputeIndexTargets(), | |
158 | new indexRecords (Dist)); | |
159 | ||
160 | return true; | |
161 | } | |
162 | ||
163 | bool debReleaseIndex::IsTrusted() const | |
164 | { | |
165 | string VerifiedSigFile = _config->FindDir("Dir::State::lists") + | |
166 | URItoFileName(MetaIndexURI("Release")) + ".gpg"; | |
167 | ||
168 | if(_config->FindB("APT::Authentication::TrustCDROM", false)) | |
169 | if(URI.substr(0,strlen("cdrom:")) == "cdrom:") | |
170 | return true; | |
171 | ||
172 | if (FileExists(VerifiedSigFile)) | |
173 | return true; | |
174 | return false; | |
175 | } | |
176 | ||
177 | vector <pkgIndexFile *> *debReleaseIndex::GetIndexFiles() | |
178 | { | |
179 | if (Indexes != NULL) | |
180 | return Indexes; | |
181 | ||
182 | Indexes = new vector <pkgIndexFile*>; | |
183 | for (vector<const debSectionEntry *>::const_iterator I = SectionEntries.begin(); | |
184 | I != SectionEntries.end(); I++) | |
185 | if ((*I)->IsSrc) | |
186 | Indexes->push_back(new debSourcesIndex (URI, Dist, (*I)->Section, IsTrusted())); | |
187 | else | |
188 | Indexes->push_back(new debPackagesIndex (URI, Dist, (*I)->Section, IsTrusted())); | |
189 | return Indexes; | |
190 | } | |
191 | ||
192 | void debReleaseIndex::PushSectionEntry(const debSectionEntry *Entry) | |
193 | { | |
194 | SectionEntries.push_back(Entry); | |
195 | } | |
196 | ||
197 | debReleaseIndex::debSectionEntry::debSectionEntry (string Section, bool IsSrc): Section(Section) | |
198 | { | |
199 | this->IsSrc = IsSrc; | |
200 | } | |
201 | ||
202 | class debSLTypeDebian : public pkgSourceList::Type | |
203 | { | |
204 | protected: | |
205 | ||
206 | bool CreateItemInternal(vector<metaIndex *> &List,string URI, | |
207 | string Dist,string Section, | |
208 | bool IsSrc) const | |
209 | { | |
210 | for (vector<metaIndex *>::const_iterator I = List.begin(); | |
211 | I != List.end(); I++) | |
212 | { | |
213 | // This check insures that there will be only one Release file | |
214 | // queued for all the Packages files and Sources files it | |
215 | // corresponds to. | |
216 | if ((*I)->GetType() == "deb") | |
217 | { | |
218 | debReleaseIndex *Deb = (debReleaseIndex *) (*I); | |
219 | // This check insures that there will be only one Release file | |
220 | // queued for all the Packages files and Sources files it | |
221 | // corresponds to. | |
222 | if (Deb->GetURI() == URI && Deb->GetDist() == Dist) | |
223 | { | |
224 | Deb->PushSectionEntry(new debReleaseIndex::debSectionEntry(Section, IsSrc)); | |
225 | return true; | |
226 | } | |
227 | } | |
228 | } | |
229 | // No currently created Release file indexes this entry, so we create a new one. | |
230 | // XXX determine whether this release is trusted or not | |
231 | debReleaseIndex *Deb = new debReleaseIndex(URI,Dist); | |
232 | Deb->PushSectionEntry (new debReleaseIndex::debSectionEntry(Section, IsSrc)); | |
233 | List.push_back(Deb); | |
234 | return true; | |
235 | } | |
236 | }; | |
237 | ||
238 | class debSLTypeDeb : public debSLTypeDebian | |
239 | { | |
240 | public: | |
241 | ||
242 | bool CreateItem(vector<metaIndex *> &List,string URI, | |
243 | string Dist,string Section) const | |
244 | { | |
245 | return CreateItemInternal(List, URI, Dist, Section, false); | |
246 | } | |
247 | ||
248 | debSLTypeDeb() | |
249 | { | |
250 | Name = "deb"; | |
251 | Label = "Standard Debian binary tree"; | |
252 | } | |
253 | }; | |
254 | ||
255 | class debSLTypeDebSrc : public debSLTypeDebian | |
256 | { | |
257 | public: | |
258 | ||
259 | bool CreateItem(vector<metaIndex *> &List,string URI, | |
260 | string Dist,string Section) const | |
261 | { | |
262 | return CreateItemInternal(List, URI, Dist, Section, true); | |
263 | } | |
264 | ||
265 | debSLTypeDebSrc() | |
266 | { | |
267 | Name = "deb-src"; | |
268 | Label = "Standard Debian source tree"; | |
269 | } | |
270 | }; | |
271 | ||
272 | debSLTypeDeb _apt_DebType; | |
273 | debSLTypeDebSrc _apt_DebSrcType; |