Commit | Line | Data |
---|---|---|
0118833a AL |
1 | // -*- mode: cpp; mode: fold -*- |
2 | // Description /*{{{*/ | |
b3d44315 | 3 | // $Id: acquire-item.cc,v 1.46.2.9 2004/01/16 18:51:11 mdz Exp $ |
0118833a AL |
4 | /* ###################################################################### |
5 | ||
6 | Acquire Item - Item to acquire | |
7 | ||
8 | Each item can download to exactly one file at a time. This means you | |
9 | cannot create an item that fetches two uri's to two files at the same | |
10 | time. The pkgAcqIndex class creates a second class upon instantiation | |
11 | to fetch the other index files because of this. | |
b185acc2 | 12 | |
0118833a AL |
13 | ##################################################################### */ |
14 | /*}}}*/ | |
15 | // Include Files /*{{{*/ | |
16 | #ifdef __GNUG__ | |
17 | #pragma implementation "apt-pkg/acquire-item.h" | |
18 | #endif | |
19 | #include <apt-pkg/acquire-item.h> | |
20 | #include <apt-pkg/configuration.h> | |
b2e465d6 | 21 | #include <apt-pkg/sourcelist.h> |
b3d44315 | 22 | #include <apt-pkg/vendorlist.h> |
03e39e59 | 23 | #include <apt-pkg/error.h> |
cdcc6d34 | 24 | #include <apt-pkg/strutl.h> |
36375005 | 25 | #include <apt-pkg/fileutl.h> |
b3d44315 | 26 | #include <apt-pkg/md5.h> |
ac5b205a MV |
27 | #include <apt-pkg/sha1.h> |
28 | #include <apt-pkg/tagfile.h> | |
0a8a80e5 | 29 | |
b2e465d6 AL |
30 | #include <apti18n.h> |
31 | ||
0a8a80e5 AL |
32 | #include <sys/stat.h> |
33 | #include <unistd.h> | |
c88edf1d | 34 | #include <errno.h> |
5819a761 | 35 | #include <string> |
ac5b205a | 36 | #include <sstream> |
c88edf1d | 37 | #include <stdio.h> |
0118833a AL |
38 | /*}}}*/ |
39 | ||
b3d44315 | 40 | using namespace std; |
5819a761 | 41 | |
0118833a AL |
42 | // Acquire::Item::Item - Constructor /*{{{*/ |
43 | // --------------------------------------------------------------------- | |
44 | /* */ | |
8267fe24 | 45 | pkgAcquire::Item::Item(pkgAcquire *Owner) : Owner(Owner), FileSize(0), |
6b1ff003 AL |
46 | PartialSize(0), Mode(0), ID(0), Complete(false), |
47 | Local(false), QueueCounter(0) | |
0118833a AL |
48 | { |
49 | Owner->Add(this); | |
c88edf1d | 50 | Status = StatIdle; |
0118833a AL |
51 | } |
52 | /*}}}*/ | |
53 | // Acquire::Item::~Item - Destructor /*{{{*/ | |
54 | // --------------------------------------------------------------------- | |
55 | /* */ | |
56 | pkgAcquire::Item::~Item() | |
57 | { | |
58 | Owner->Remove(this); | |
59 | } | |
60 | /*}}}*/ | |
c88edf1d AL |
61 | // Acquire::Item::Failed - Item failed to download /*{{{*/ |
62 | // --------------------------------------------------------------------- | |
93bf083d AL |
63 | /* We return to an idle state if there are still other queues that could |
64 | fetch this object */ | |
7d8afa39 | 65 | void pkgAcquire::Item::Failed(string Message,pkgAcquire::MethodConfig *Cnf) |
c88edf1d | 66 | { |
93bf083d | 67 | Status = StatIdle; |
db890fdb | 68 | ErrorText = LookupTag(Message,"Message"); |
c88edf1d | 69 | if (QueueCounter <= 1) |
93bf083d | 70 | { |
a72ace20 | 71 | /* This indicates that the file is not available right now but might |
7d8afa39 | 72 | be sometime later. If we do a retry cycle then this should be |
17caf1b1 | 73 | retried [CDROMs] */ |
7d8afa39 AL |
74 | if (Cnf->LocalOnly == true && |
75 | StringToBool(LookupTag(Message,"Transient-Failure"),false) == true) | |
a72ace20 AL |
76 | { |
77 | Status = StatIdle; | |
681d76d0 | 78 | Dequeue(); |
a72ace20 AL |
79 | return; |
80 | } | |
81 | ||
93bf083d | 82 | Status = StatError; |
681d76d0 | 83 | Dequeue(); |
93bf083d | 84 | } |
c88edf1d AL |
85 | } |
86 | /*}}}*/ | |
8267fe24 AL |
87 | // Acquire::Item::Start - Item has begun to download /*{{{*/ |
88 | // --------------------------------------------------------------------- | |
17caf1b1 AL |
89 | /* Stash status and the file size. Note that setting Complete means |
90 | sub-phases of the acquire process such as decompresion are operating */ | |
727f18af | 91 | void pkgAcquire::Item::Start(string /*Message*/,unsigned long Size) |
8267fe24 AL |
92 | { |
93 | Status = StatFetching; | |
94 | if (FileSize == 0 && Complete == false) | |
95 | FileSize = Size; | |
96 | } | |
97 | /*}}}*/ | |
c88edf1d AL |
98 | // Acquire::Item::Done - Item downloaded OK /*{{{*/ |
99 | // --------------------------------------------------------------------- | |
100 | /* */ | |
459681d3 AL |
101 | void pkgAcquire::Item::Done(string Message,unsigned long Size,string, |
102 | pkgAcquire::MethodConfig *Cnf) | |
c88edf1d | 103 | { |
b98f2859 AL |
104 | // We just downloaded something.. |
105 | string FileName = LookupTag(Message,"Filename"); | |
8f30ca30 MV |
106 | // we only inform the Log class if it was actually not a local thing |
107 | if (Complete == false && !Local && FileName == DestFile) | |
b98f2859 AL |
108 | { |
109 | if (Owner->Log != 0) | |
110 | Owner->Log->Fetched(Size,atoi(LookupTag(Message,"Resume-Point","0").c_str())); | |
111 | } | |
aa0e1101 AL |
112 | |
113 | if (FileSize == 0) | |
114 | FileSize= Size; | |
b98f2859 | 115 | |
c88edf1d AL |
116 | Status = StatDone; |
117 | ErrorText = string(); | |
118 | Owner->Dequeue(this); | |
119 | } | |
120 | /*}}}*/ | |
8b89e57f AL |
121 | // Acquire::Item::Rename - Rename a file /*{{{*/ |
122 | // --------------------------------------------------------------------- | |
123 | /* This helper function is used by alot of item methods as thier final | |
124 | step */ | |
125 | void pkgAcquire::Item::Rename(string From,string To) | |
126 | { | |
127 | if (rename(From.c_str(),To.c_str()) != 0) | |
128 | { | |
129 | char S[300]; | |
0fcd01de | 130 | snprintf(S,sizeof(S),_("rename failed, %s (%s -> %s)."),strerror(errno), |
8b89e57f AL |
131 | From.c_str(),To.c_str()); |
132 | Status = StatError; | |
133 | ErrorText = S; | |
7a3c2ab0 | 134 | } |
8b89e57f AL |
135 | } |
136 | /*}}}*/ | |
0118833a | 137 | |
2237bd01 MV |
138 | |
139 | // AcqDiffIndex::AcqDiffIndex - Constructor | |
ac5b205a | 140 | // --------------------------------------------------------------------- |
2237bd01 MV |
141 | /* Get the DiffIndex file first and see if there are patches availabe |
142 | * If so, create a pkgAcqIndexDiffs fetcher that will get and apply the | |
143 | * patches. If anything goes wrong in that process, it will fall back to | |
144 | * the original packages file | |
ac5b205a | 145 | */ |
2237bd01 MV |
146 | pkgAcqDiffIndex::pkgAcqDiffIndex(pkgAcquire *Owner, |
147 | string URI,string URIDesc,string ShortDesc, | |
148 | string ExpectedMD5) | |
149 | : Item(Owner), RealURI(URI), ExpectedMD5(ExpectedMD5), Description(URIDesc) | |
ac5b205a MV |
150 | { |
151 | ||
ac5b205a MV |
152 | Debug = _config->FindB("Debug::pkgAcquire::Diffs",false); |
153 | ||
2237bd01 | 154 | Desc.Description = URIDesc + "/DiffIndex"; |
ac5b205a MV |
155 | Desc.Owner = this; |
156 | Desc.ShortDesc = ShortDesc; | |
2237bd01 MV |
157 | Desc.URI = URI + ".diff/Index"; |
158 | ||
159 | DestFile = _config->FindDir("Dir::State::lists") + "partial/"; | |
160 | DestFile += URItoFileName(URI) + string(".DiffIndex"); | |
161 | ||
162 | if(Debug) | |
163 | std::clog << "pkgAcqDiffIndex: " << Desc.URI << std::endl; | |
ac5b205a | 164 | |
2237bd01 | 165 | // look for the current package file |
ac5b205a MV |
166 | CurrentPackagesFile = _config->FindDir("Dir::State::lists"); |
167 | CurrentPackagesFile += URItoFileName(RealURI); | |
168 | ||
b4e57d2d MV |
169 | // FIXME: this file:/ check is a hack to prevent fetching |
170 | // from local sources. this is really silly, and | |
171 | // should be fixed cleanly as soon as possible | |
ac5b205a | 172 | if(!FileExists(CurrentPackagesFile) || |
81fcf9e2 | 173 | Desc.URI.substr(0,strlen("file:/")) == "file:/") |
2ac3eeb6 | 174 | { |
ac5b205a MV |
175 | // we don't have a pkg file or we don't want to queue |
176 | if(Debug) | |
b4e57d2d | 177 | std::clog << "No index file, local or canceld by user" << std::endl; |
ac5b205a MV |
178 | Failed("", NULL); |
179 | return; | |
180 | } | |
181 | ||
2ac3eeb6 | 182 | if(Debug) |
2237bd01 MV |
183 | std::clog << "pkgAcqIndexDiffs::pkgAcqIndexDiffs(): " |
184 | << CurrentPackagesFile << std::endl; | |
2ac3eeb6 | 185 | |
ac5b205a | 186 | QueueURI(Desc); |
2237bd01 | 187 | |
ac5b205a MV |
188 | } |
189 | ||
6cb30d01 MV |
190 | // AcqIndex::Custom600Headers - Insert custom request headers /*{{{*/ |
191 | // --------------------------------------------------------------------- | |
192 | /* The only header we use is the last-modified header. */ | |
2237bd01 | 193 | string pkgAcqDiffIndex::Custom600Headers() |
6cb30d01 | 194 | { |
6cb30d01 MV |
195 | string Final = _config->FindDir("Dir::State::lists"); |
196 | Final += URItoFileName(RealURI) + string(".IndexDiff"); | |
197 | ||
198 | if(Debug) | |
199 | std::clog << "Custom600Header-IMS: " << Final << std::endl; | |
200 | ||
201 | struct stat Buf; | |
202 | if (stat(Final.c_str(),&Buf) != 0) | |
203 | return "\nIndex-File: true"; | |
204 | ||
205 | return "\nIndex-File: true\nLast-Modified: " + TimeRFC1123(Buf.st_mtime); | |
206 | } | |
207 | ||
2237bd01 MV |
208 | |
209 | bool pkgAcqDiffIndex::ParseDiffIndex(string IndexDiffFile) | |
210 | { | |
211 | if(Debug) | |
212 | std::clog << "pkgAcqIndexDiffs::ParseIndexDiff() " << IndexDiffFile | |
213 | << std::endl; | |
214 | ||
215 | pkgTagSection Tags; | |
216 | string ServerSha1; | |
217 | vector<DiffInfo> available_patches; | |
218 | ||
219 | FileFd Fd(IndexDiffFile,FileFd::ReadOnly); | |
220 | pkgTagFile TF(&Fd); | |
221 | if (_error->PendingError() == true) | |
222 | return false; | |
223 | ||
224 | if(TF.Step(Tags) == true) | |
225 | { | |
226 | string local_sha1; | |
002d9943 MV |
227 | bool found = false; |
228 | DiffInfo d; | |
229 | string size; | |
230 | ||
2237bd01 MV |
231 | string tmp = Tags.FindS("SHA1-Current"); |
232 | std::stringstream ss(tmp); | |
233 | ss >> ServerSha1; | |
234 | ||
235 | FileFd fd(CurrentPackagesFile, FileFd::ReadOnly); | |
236 | SHA1Summation SHA1; | |
237 | SHA1.AddFD(fd.Fd(), fd.Size()); | |
238 | local_sha1 = string(SHA1.Result()); | |
239 | ||
2ac3eeb6 MV |
240 | if(local_sha1 == ServerSha1) |
241 | { | |
242 | // we have the same sha1 as the server | |
2237bd01 MV |
243 | if(Debug) |
244 | std::clog << "Package file is up-to-date" << std::endl; | |
002d9943 MV |
245 | // set found to true, this will queue a pkgAcqIndexDiffs with |
246 | // a empty availabe_patches | |
247 | found = true; | |
2ac3eeb6 MV |
248 | } |
249 | else | |
250 | { | |
002d9943 MV |
251 | if(Debug) |
252 | std::clog << "SHA1-Current: " << ServerSha1 << std::endl; | |
253 | ||
254 | // check the historie and see what patches we need | |
255 | string history = Tags.FindS("SHA1-History"); | |
256 | std::stringstream hist(history); | |
2ac3eeb6 MV |
257 | while(hist >> d.sha1 >> size >> d.file) |
258 | { | |
002d9943 MV |
259 | d.size = atoi(size.c_str()); |
260 | // read until the first match is found | |
261 | if(d.sha1 == local_sha1) | |
262 | found=true; | |
263 | // from that point on, we probably need all diffs | |
2ac3eeb6 MV |
264 | if(found) |
265 | { | |
002d9943 MV |
266 | if(Debug) |
267 | std::clog << "Need to get diff: " << d.file << std::endl; | |
268 | available_patches.push_back(d); | |
269 | } | |
2237bd01 MV |
270 | } |
271 | } | |
272 | ||
273 | // no information how to get the patches, bail out | |
2ac3eeb6 MV |
274 | if(!found) |
275 | { | |
2237bd01 MV |
276 | if(Debug) |
277 | std::clog << "Can't find a patch in the index file" << std::endl; | |
278 | // Failed will queue a big package file | |
279 | Failed("", NULL); | |
2ac3eeb6 MV |
280 | } |
281 | else | |
282 | { | |
2237bd01 MV |
283 | // queue the diffs |
284 | new pkgAcqIndexDiffs(Owner, RealURI, Description, Desc.ShortDesc, | |
285 | ExpectedMD5, available_patches); | |
286 | Complete = false; | |
287 | Status = StatDone; | |
288 | Dequeue(); | |
289 | return true; | |
290 | } | |
291 | } | |
292 | ||
293 | return false; | |
294 | } | |
295 | ||
296 | void pkgAcqDiffIndex::Failed(string Message,pkgAcquire::MethodConfig *Cnf) | |
297 | { | |
298 | if(Debug) | |
299 | std::clog << "pkgAcqDiffIndex failed: " << Desc.URI << std::endl | |
300 | << "Falling back to normal index file aquire" << std::endl; | |
301 | ||
002d9943 | 302 | new pkgAcqIndex(Owner, RealURI, Description, Desc.ShortDesc, |
2237bd01 MV |
303 | ExpectedMD5); |
304 | ||
305 | Complete = false; | |
306 | Status = StatDone; | |
307 | Dequeue(); | |
308 | } | |
309 | ||
310 | void pkgAcqDiffIndex::Done(string Message,unsigned long Size,string Md5Hash, | |
311 | pkgAcquire::MethodConfig *Cnf) | |
312 | { | |
313 | if(Debug) | |
314 | std::clog << "pkgAcqDiffIndex::Done(): " << Desc.URI << std::endl; | |
315 | ||
316 | Item::Done(Message,Size,Md5Hash,Cnf); | |
317 | ||
318 | string FinalFile; | |
319 | FinalFile = _config->FindDir("Dir::State::lists")+URItoFileName(RealURI); | |
320 | ||
321 | // sucess in downloading the index | |
322 | // rename the index | |
323 | FinalFile += string(".IndexDiff"); | |
324 | if(Debug) | |
325 | std::clog << "Renaming: " << DestFile << " -> " << FinalFile | |
326 | << std::endl; | |
327 | Rename(DestFile,FinalFile); | |
328 | chmod(FinalFile.c_str(),0644); | |
329 | DestFile = FinalFile; | |
330 | ||
331 | if(!ParseDiffIndex(DestFile)) | |
332 | return Failed("", NULL); | |
333 | ||
334 | Complete = true; | |
335 | Status = StatDone; | |
336 | Dequeue(); | |
337 | return; | |
338 | } | |
339 | ||
340 | ||
341 | ||
342 | // AcqIndexDiffs::AcqIndexDiffs - Constructor | |
343 | // --------------------------------------------------------------------- | |
344 | /* The package diff is added to the queue. one object is constructed | |
345 | * for each diff and the index | |
346 | */ | |
347 | pkgAcqIndexDiffs::pkgAcqIndexDiffs(pkgAcquire *Owner, | |
348 | string URI,string URIDesc,string ShortDesc, | |
349 | string ExpectedMD5, vector<DiffInfo> diffs) | |
350 | : Item(Owner), RealURI(URI), ExpectedMD5(ExpectedMD5), | |
351 | available_patches(diffs) | |
352 | { | |
353 | ||
354 | DestFile = _config->FindDir("Dir::State::lists") + "partial/"; | |
355 | DestFile += URItoFileName(URI); | |
356 | ||
357 | Debug = _config->FindB("Debug::pkgAcquire::Diffs",false); | |
358 | ||
359 | Desc.Description = URIDesc; | |
360 | Desc.Owner = this; | |
361 | Desc.ShortDesc = ShortDesc; | |
362 | ||
2ac3eeb6 MV |
363 | if(available_patches.size() == 0) |
364 | { | |
2237bd01 MV |
365 | // we are done (yeah!) |
366 | Finish(true); | |
2ac3eeb6 MV |
367 | } |
368 | else | |
369 | { | |
2237bd01 MV |
370 | // get the next diff |
371 | State = StateFetchDiff; | |
372 | QueueNextDiff(); | |
373 | } | |
374 | } | |
375 | ||
376 | ||
ac5b205a MV |
377 | void pkgAcqIndexDiffs::Failed(string Message,pkgAcquire::MethodConfig *Cnf) |
378 | { | |
2237bd01 MV |
379 | if(Debug) |
380 | std::clog << "pkgAcqIndexDiffs failed: " << Desc.URI << std::endl | |
381 | << "Falling back to normal index file aquire" << std::endl; | |
382 | new pkgAcqIndex(Owner, RealURI, Description,Desc.ShortDesc, | |
ac5b205a MV |
383 | ExpectedMD5); |
384 | Finish(); | |
385 | } | |
386 | ||
387 | ||
388 | // helper that cleans the item out of the fetcher queue | |
389 | void pkgAcqIndexDiffs::Finish(bool allDone) | |
390 | { | |
391 | // we restore the original name, this is required, otherwise | |
392 | // the file will be cleaned | |
2ac3eeb6 MV |
393 | if(allDone) |
394 | { | |
ac5b205a MV |
395 | DestFile = _config->FindDir("Dir::State::lists"); |
396 | DestFile += URItoFileName(RealURI); | |
2d4722e2 MV |
397 | |
398 | // do the final md5sum checking | |
399 | MD5Summation sum; | |
400 | FileFd Fd(DestFile, FileFd::ReadOnly); | |
401 | sum.AddFD(Fd.Fd(), Fd.Size()); | |
402 | Fd.Close(); | |
403 | string MD5 = (string)sum.Result(); | |
404 | ||
405 | if (!ExpectedMD5.empty() && MD5 != ExpectedMD5) | |
406 | { | |
407 | Status = StatAuthError; | |
408 | ErrorText = _("MD5Sum mismatch"); | |
409 | Rename(DestFile,DestFile + ".FAILED"); | |
410 | Dequeue(); | |
411 | return; | |
412 | } | |
413 | ||
414 | // this is for the "real" finish | |
ac5b205a | 415 | Complete = true; |
cffc2ddd | 416 | Status = StatDone; |
ac5b205a MV |
417 | Dequeue(); |
418 | if(Debug) | |
419 | std::clog << "\n\nallDone: " << DestFile << "\n" << std::endl; | |
420 | return; | |
ac5b205a MV |
421 | } |
422 | ||
423 | if(Debug) | |
424 | std::clog << "Finishing: " << Desc.URI << std::endl; | |
425 | Complete = false; | |
426 | Status = StatDone; | |
427 | Dequeue(); | |
428 | return; | |
429 | } | |
430 | ||
431 | ||
ac5b205a MV |
432 | |
433 | bool pkgAcqIndexDiffs::QueueNextDiff() | |
434 | { | |
3de9ff77 | 435 | |
94dc9d7d MV |
436 | // calc sha1 of the just patched file |
437 | string FinalFile = _config->FindDir("Dir::State::lists"); | |
438 | FinalFile += URItoFileName(RealURI); | |
439 | ||
440 | FileFd fd(FinalFile, FileFd::ReadOnly); | |
441 | SHA1Summation SHA1; | |
442 | SHA1.AddFD(fd.Fd(), fd.Size()); | |
443 | string local_sha1 = string(SHA1.Result()); | |
3de9ff77 MV |
444 | if(Debug) |
445 | std::clog << "QueueNextDiff: " | |
446 | << FinalFile << " (" << local_sha1 << ")"<<std::endl; | |
94dc9d7d | 447 | |
26d27645 MV |
448 | // remove all patches until the next matching patch is found |
449 | // this requires the Index file to be ordered | |
94dc9d7d | 450 | for(vector<DiffInfo>::iterator I=available_patches.begin(); |
2ac3eeb6 MV |
451 | available_patches.size() > 0 && |
452 | I != available_patches.end() && | |
453 | (*I).sha1 != local_sha1; | |
454 | I++) | |
455 | { | |
26d27645 | 456 | available_patches.erase(I); |
59a704f0 | 457 | } |
94dc9d7d MV |
458 | |
459 | // error checking and falling back if no patch was found | |
2ac3eeb6 MV |
460 | if(available_patches.size() == 0) |
461 | { | |
94dc9d7d MV |
462 | Failed("", NULL); |
463 | return false; | |
464 | } | |
6cb30d01 | 465 | |
94dc9d7d | 466 | // queue the right diff |
2237bd01 | 467 | Desc.URI = string(RealURI) + ".diff/" + available_patches[0].file + ".gz"; |
94dc9d7d | 468 | Desc.Description = available_patches[0].file + string(".pdiff"); |
ac5b205a MV |
469 | |
470 | DestFile = _config->FindDir("Dir::State::lists") + "partial/"; | |
2237bd01 | 471 | DestFile += URItoFileName(RealURI + ".diff/" + available_patches[0].file); |
ac5b205a MV |
472 | |
473 | if(Debug) | |
474 | std::clog << "pkgAcqIndexDiffs::QueueNextDiff(): " << Desc.URI << std::endl; | |
475 | ||
476 | QueueURI(Desc); | |
477 | ||
478 | return true; | |
479 | } | |
480 | ||
ac5b205a MV |
481 | |
482 | ||
483 | void pkgAcqIndexDiffs::Done(string Message,unsigned long Size,string Md5Hash, | |
484 | pkgAcquire::MethodConfig *Cnf) | |
485 | { | |
486 | if(Debug) | |
487 | std::clog << "pkgAcqIndexDiffs::Done(): " << Desc.URI << std::endl; | |
488 | ||
489 | Item::Done(Message,Size,Md5Hash,Cnf); | |
490 | ||
4a0a786f MV |
491 | string FinalFile; |
492 | FinalFile = _config->FindDir("Dir::State::lists")+URItoFileName(RealURI); | |
6cb30d01 | 493 | |
4a0a786f MV |
494 | // sucess in downloading a diff, enter ApplyDiff state |
495 | if(State == StateFetchDiff) | |
496 | { | |
497 | ||
498 | if(Debug) | |
499 | std::clog << "Sending to gzip method: " << FinalFile << std::endl; | |
500 | ||
501 | string FileName = LookupTag(Message,"Filename"); | |
502 | State = StateUnzipDiff; | |
b7347826 | 503 | Local = true; |
4a0a786f MV |
504 | Desc.URI = "gzip:" + FileName; |
505 | DestFile += ".decomp"; | |
506 | QueueURI(Desc); | |
507 | Mode = "gzip"; | |
508 | return; | |
509 | } | |
510 | ||
511 | // sucess in downloading a diff, enter ApplyDiff state | |
512 | if(State == StateUnzipDiff) | |
513 | { | |
514 | ||
515 | // rred excepts the patch as $FinalFile.ed | |
516 | Rename(DestFile,FinalFile+".ed"); | |
517 | ||
518 | if(Debug) | |
519 | std::clog << "Sending to rred method: " << FinalFile << std::endl; | |
520 | ||
521 | State = StateApplyDiff; | |
b7347826 | 522 | Local = true; |
4a0a786f MV |
523 | Desc.URI = "rred:" + FinalFile; |
524 | QueueURI(Desc); | |
525 | Mode = "rred"; | |
526 | return; | |
527 | } | |
528 | ||
529 | ||
530 | // success in download/apply a diff, queue next (if needed) | |
531 | if(State == StateApplyDiff) | |
532 | { | |
533 | // remove the just applied patch | |
94dc9d7d | 534 | available_patches.erase(available_patches.begin()); |
ac5b205a | 535 | |
4a0a786f | 536 | // move into place |
59a704f0 MV |
537 | if(Debug) |
538 | { | |
4a0a786f MV |
539 | std::clog << "Moving patched file in place: " << std::endl |
540 | << DestFile << " -> " << FinalFile << std::endl; | |
59a704f0 | 541 | } |
4a0a786f MV |
542 | Rename(DestFile,FinalFile); |
543 | ||
544 | // see if there is more to download | |
94dc9d7d | 545 | if(available_patches.size() > 0) { |
ac5b205a | 546 | new pkgAcqIndexDiffs(Owner, RealURI, Description, Desc.ShortDesc, |
94dc9d7d | 547 | ExpectedMD5, available_patches); |
4a0a786f MV |
548 | return Finish(); |
549 | } else | |
550 | return Finish(true); | |
ac5b205a | 551 | } |
ac5b205a MV |
552 | } |
553 | ||
554 | ||
0118833a AL |
555 | // AcqIndex::AcqIndex - Constructor /*{{{*/ |
556 | // --------------------------------------------------------------------- | |
557 | /* The package file is added to the queue and a second class is | |
b2e465d6 AL |
558 | instantiated to fetch the revision file */ |
559 | pkgAcqIndex::pkgAcqIndex(pkgAcquire *Owner, | |
b3d44315 | 560 | string URI,string URIDesc,string ShortDesc, |
ac5b205a MV |
561 | string ExpectedMD5, string comprExt) |
562 | : Item(Owner), RealURI(URI), ExpectedMD5(ExpectedMD5) | |
0118833a | 563 | { |
8b89e57f | 564 | Decompression = false; |
bfd22fc0 | 565 | Erase = false; |
13e8426f | 566 | |
0a8a80e5 | 567 | DestFile = _config->FindDir("Dir::State::lists") + "partial/"; |
b2e465d6 | 568 | DestFile += URItoFileName(URI); |
8267fe24 | 569 | |
b3d44315 MV |
570 | if(comprExt.empty()) |
571 | { | |
13e8426f MV |
572 | // autoselect the compression method |
573 | if(FileExists("/usr/bin/bzip2")) | |
574 | CompressionExtension = ".bz2"; | |
575 | else | |
576 | CompressionExtension = ".gz"; | |
b3d44315 | 577 | } else { |
13e8426f | 578 | CompressionExtension = comprExt; |
b3d44315 | 579 | } |
13e8426f | 580 | Desc.URI = URI + CompressionExtension; |
b3d44315 | 581 | |
b2e465d6 | 582 | Desc.Description = URIDesc; |
8267fe24 | 583 | Desc.Owner = this; |
b2e465d6 | 584 | Desc.ShortDesc = ShortDesc; |
8267fe24 AL |
585 | |
586 | QueueURI(Desc); | |
0118833a AL |
587 | } |
588 | /*}}}*/ | |
0a8a80e5 | 589 | // AcqIndex::Custom600Headers - Insert custom request headers /*{{{*/ |
0118833a | 590 | // --------------------------------------------------------------------- |
0a8a80e5 AL |
591 | /* The only header we use is the last-modified header. */ |
592 | string pkgAcqIndex::Custom600Headers() | |
0118833a | 593 | { |
0a8a80e5 | 594 | string Final = _config->FindDir("Dir::State::lists"); |
b2e465d6 | 595 | Final += URItoFileName(RealURI); |
0a8a80e5 AL |
596 | |
597 | struct stat Buf; | |
598 | if (stat(Final.c_str(),&Buf) != 0) | |
a72ace20 | 599 | return "\nIndex-File: true"; |
0118833a | 600 | |
a72ace20 | 601 | return "\nIndex-File: true\nLast-Modified: " + TimeRFC1123(Buf.st_mtime); |
0118833a AL |
602 | } |
603 | /*}}}*/ | |
debc84b2 MZ |
604 | |
605 | void pkgAcqIndex::Failed(string Message,pkgAcquire::MethodConfig *Cnf) | |
606 | { | |
607 | // no .bz2 found, retry with .gz | |
608 | if(Desc.URI.substr(Desc.URI.size()-3,Desc.URI.size()-1) == "bz2") { | |
609 | Desc.URI = Desc.URI.substr(0,Desc.URI.size()-3) + "gz"; | |
b3d44315 MV |
610 | |
611 | // retry with a gzip one | |
612 | new pkgAcqIndex(Owner, RealURI, Desc.Description,Desc.ShortDesc, | |
613 | ExpectedMD5, string(".gz")); | |
614 | Status = StatDone; | |
615 | Complete = false; | |
616 | Dequeue(); | |
debc84b2 MZ |
617 | return; |
618 | } | |
619 | ||
620 | ||
621 | Item::Failed(Message,Cnf); | |
622 | } | |
623 | ||
624 | ||
8b89e57f AL |
625 | // AcqIndex::Done - Finished a fetch /*{{{*/ |
626 | // --------------------------------------------------------------------- | |
627 | /* This goes through a number of states.. On the initial fetch the | |
628 | method could possibly return an alternate filename which points | |
629 | to the uncompressed version of the file. If this is so the file | |
630 | is copied into the partial directory. In all other cases the file | |
631 | is decompressed with a gzip uri. */ | |
459681d3 AL |
632 | void pkgAcqIndex::Done(string Message,unsigned long Size,string MD5, |
633 | pkgAcquire::MethodConfig *Cfg) | |
8b89e57f | 634 | { |
459681d3 | 635 | Item::Done(Message,Size,MD5,Cfg); |
8b89e57f AL |
636 | |
637 | if (Decompression == true) | |
638 | { | |
b3d44315 MV |
639 | if (_config->FindB("Debug::pkgAcquire::Auth", false)) |
640 | { | |
641 | std::cerr << std::endl << RealURI << ": Computed MD5: " << MD5; | |
642 | std::cerr << " Expected MD5: " << ExpectedMD5 << std::endl; | |
643 | } | |
644 | ||
645 | if (MD5.empty()) | |
646 | { | |
647 | MD5Summation sum; | |
648 | FileFd Fd(DestFile, FileFd::ReadOnly); | |
649 | sum.AddFD(Fd.Fd(), Fd.Size()); | |
650 | Fd.Close(); | |
651 | MD5 = (string)sum.Result(); | |
652 | } | |
653 | ||
654 | if (!ExpectedMD5.empty() && MD5 != ExpectedMD5) | |
655 | { | |
656 | Status = StatAuthError; | |
657 | ErrorText = _("MD5Sum mismatch"); | |
658 | Rename(DestFile,DestFile + ".FAILED"); | |
659 | return; | |
660 | } | |
8b89e57f AL |
661 | // Done, move it into position |
662 | string FinalFile = _config->FindDir("Dir::State::lists"); | |
b2e465d6 | 663 | FinalFile += URItoFileName(RealURI); |
8b89e57f | 664 | Rename(DestFile,FinalFile); |
7a3c2ab0 | 665 | chmod(FinalFile.c_str(),0644); |
bfd22fc0 | 666 | |
7a7fa5f0 AL |
667 | /* We restore the original name to DestFile so that the clean operation |
668 | will work OK */ | |
669 | DestFile = _config->FindDir("Dir::State::lists") + "partial/"; | |
b2e465d6 | 670 | DestFile += URItoFileName(RealURI); |
7a7fa5f0 | 671 | |
bfd22fc0 AL |
672 | // Remove the compressed version. |
673 | if (Erase == true) | |
bfd22fc0 | 674 | unlink(DestFile.c_str()); |
8b89e57f AL |
675 | return; |
676 | } | |
bfd22fc0 AL |
677 | |
678 | Erase = false; | |
8267fe24 | 679 | Complete = true; |
bfd22fc0 | 680 | |
8b89e57f AL |
681 | // Handle the unzipd case |
682 | string FileName = LookupTag(Message,"Alt-Filename"); | |
683 | if (FileName.empty() == false) | |
684 | { | |
685 | // The files timestamp matches | |
686 | if (StringToBool(LookupTag(Message,"Alt-IMS-Hit"),false) == true) | |
687 | return; | |
b3d44315 | 688 | |
8b89e57f | 689 | Decompression = true; |
a6568219 | 690 | Local = true; |
8b89e57f | 691 | DestFile += ".decomp"; |
8267fe24 AL |
692 | Desc.URI = "copy:" + FileName; |
693 | QueueURI(Desc); | |
b98f2859 | 694 | Mode = "copy"; |
8b89e57f AL |
695 | return; |
696 | } | |
697 | ||
698 | FileName = LookupTag(Message,"Filename"); | |
699 | if (FileName.empty() == true) | |
700 | { | |
701 | Status = StatError; | |
702 | ErrorText = "Method gave a blank filename"; | |
703 | } | |
704 | ||
705 | // The files timestamp matches | |
706 | if (StringToBool(LookupTag(Message,"IMS-Hit"),false) == true) | |
707 | return; | |
bfd22fc0 AL |
708 | |
709 | if (FileName == DestFile) | |
710 | Erase = true; | |
8267fe24 | 711 | else |
a6568219 | 712 | Local = true; |
8b89e57f | 713 | |
debc84b2 MZ |
714 | string compExt = Desc.URI.substr(Desc.URI.size()-3,Desc.URI.size()-1); |
715 | char *decompProg; | |
716 | if(compExt == "bz2") | |
717 | decompProg = "bzip2"; | |
718 | else if(compExt == ".gz") | |
719 | decompProg = "gzip"; | |
720 | else { | |
721 | _error->Error("Unsupported extension: %s", compExt.c_str()); | |
722 | return; | |
723 | } | |
724 | ||
8b89e57f AL |
725 | Decompression = true; |
726 | DestFile += ".decomp"; | |
debc84b2 | 727 | Desc.URI = string(decompProg) + ":" + FileName; |
8267fe24 | 728 | QueueURI(Desc); |
debc84b2 | 729 | Mode = decompProg; |
8b89e57f | 730 | } |
8b89e57f | 731 | |
b3d44315 MV |
732 | pkgAcqMetaSig::pkgAcqMetaSig(pkgAcquire *Owner, |
733 | string URI,string URIDesc,string ShortDesc, | |
734 | string MetaIndexURI, string MetaIndexURIDesc, | |
735 | string MetaIndexShortDesc, | |
736 | const vector<IndexTarget*>* IndexTargets, | |
737 | indexRecords* MetaIndexParser) : | |
738 | Item(Owner), RealURI(URI), MetaIndexURI(MetaIndexURI), | |
739 | MetaIndexURIDesc(MetaIndexURIDesc), MetaIndexShortDesc(MetaIndexShortDesc) | |
0118833a | 740 | { |
b3d44315 MV |
741 | this->MetaIndexParser = MetaIndexParser; |
742 | this->IndexTargets = IndexTargets; | |
0a8a80e5 | 743 | DestFile = _config->FindDir("Dir::State::lists") + "partial/"; |
b2e465d6 | 744 | DestFile += URItoFileName(URI); |
b3d44315 | 745 | |
f6237efd MV |
746 | // remove any partial downloaded sig-file. it may confuse proxies |
747 | // and is too small to warrant a partial download anyway | |
748 | unlink(DestFile.c_str()); | |
749 | ||
8267fe24 | 750 | // Create the item |
b2e465d6 | 751 | Desc.Description = URIDesc; |
8267fe24 | 752 | Desc.Owner = this; |
b3d44315 MV |
753 | Desc.ShortDesc = ShortDesc; |
754 | Desc.URI = URI; | |
755 | ||
756 | ||
757 | string Final = _config->FindDir("Dir::State::lists"); | |
758 | Final += URItoFileName(RealURI); | |
759 | struct stat Buf; | |
760 | if (stat(Final.c_str(),&Buf) == 0) | |
761 | { | |
762 | // File was already in place. It needs to be re-verified | |
763 | // because Release might have changed, so Move it into partial | |
764 | Rename(Final,DestFile); | |
284c8bbc MV |
765 | // unlink the file and do not try to use I-M-S and Last-Modified |
766 | // if the users proxy is broken | |
767 | if(_config->FindB("Acquire::BrokenProxy", false) == true) { | |
768 | std::cerr << "forcing re-get of the signature file as requested" << std::endl; | |
769 | unlink(DestFile.c_str()); | |
770 | } | |
b3d44315 | 771 | } |
8267fe24 | 772 | |
8267fe24 | 773 | QueueURI(Desc); |
0118833a AL |
774 | } |
775 | /*}}}*/ | |
b3d44315 | 776 | // pkgAcqMetaSig::Custom600Headers - Insert custom request headers /*{{{*/ |
0118833a | 777 | // --------------------------------------------------------------------- |
0a8a80e5 | 778 | /* The only header we use is the last-modified header. */ |
b3d44315 | 779 | string pkgAcqMetaSig::Custom600Headers() |
0118833a | 780 | { |
0a8a80e5 | 781 | struct stat Buf; |
2aab5956 | 782 | if (stat(DestFile.c_str(),&Buf) != 0) |
a72ace20 | 783 | return "\nIndex-File: true"; |
a789b983 | 784 | |
a72ace20 | 785 | return "\nIndex-File: true\nLast-Modified: " + TimeRFC1123(Buf.st_mtime); |
0118833a | 786 | } |
b3d44315 MV |
787 | |
788 | void pkgAcqMetaSig::Done(string Message,unsigned long Size,string MD5, | |
789 | pkgAcquire::MethodConfig *Cfg) | |
c88edf1d | 790 | { |
459681d3 | 791 | Item::Done(Message,Size,MD5,Cfg); |
c88edf1d AL |
792 | |
793 | string FileName = LookupTag(Message,"Filename"); | |
794 | if (FileName.empty() == true) | |
795 | { | |
796 | Status = StatError; | |
797 | ErrorText = "Method gave a blank filename"; | |
8b89e57f | 798 | return; |
c88edf1d | 799 | } |
8b89e57f | 800 | |
c88edf1d AL |
801 | if (FileName != DestFile) |
802 | { | |
b3d44315 | 803 | // We have to copy it into place |
a6568219 | 804 | Local = true; |
8267fe24 AL |
805 | Desc.URI = "copy:" + FileName; |
806 | QueueURI(Desc); | |
c88edf1d AL |
807 | return; |
808 | } | |
b3d44315 MV |
809 | |
810 | Complete = true; | |
811 | ||
812 | // queue a pkgAcqMetaIndex to be verified against the sig we just retrieved | |
813 | new pkgAcqMetaIndex(Owner, MetaIndexURI, MetaIndexURIDesc, MetaIndexShortDesc, | |
814 | DestFile, IndexTargets, MetaIndexParser); | |
815 | ||
c88edf1d AL |
816 | } |
817 | /*}}}*/ | |
b3d44315 | 818 | void pkgAcqMetaSig::Failed(string Message,pkgAcquire::MethodConfig *Cnf) |
681d76d0 | 819 | { |
b3d44315 MV |
820 | // Delete any existing sigfile, so that this source isn't |
821 | // mistakenly trusted | |
822 | string Final = _config->FindDir("Dir::State::lists") + URItoFileName(RealURI); | |
823 | unlink(Final.c_str()); | |
a789b983 | 824 | |
24057ad6 | 825 | // if we get a timeout if fail |
25182152 MV |
826 | if(LookupTag(Message,"FailReason") == "Timeout" || |
827 | LookupTag(Message,"FailReason") == "TmpResolveFailure") { | |
24057ad6 MV |
828 | Item::Failed(Message,Cnf); |
829 | return; | |
830 | } | |
831 | ||
b3d44315 MV |
832 | // queue a pkgAcqMetaIndex with no sigfile |
833 | new pkgAcqMetaIndex(Owner, MetaIndexURI, MetaIndexURIDesc, MetaIndexShortDesc, | |
834 | "", IndexTargets, MetaIndexParser); | |
835 | ||
681d76d0 AL |
836 | if (Cnf->LocalOnly == true || |
837 | StringToBool(LookupTag(Message,"Transient-Failure"),false) == false) | |
838 | { | |
2b154e53 AL |
839 | // Ignore this |
840 | Status = StatDone; | |
841 | Complete = false; | |
681d76d0 AL |
842 | Dequeue(); |
843 | return; | |
844 | } | |
845 | ||
846 | Item::Failed(Message,Cnf); | |
847 | } | |
b3d44315 MV |
848 | |
849 | pkgAcqMetaIndex::pkgAcqMetaIndex(pkgAcquire *Owner, | |
850 | string URI,string URIDesc,string ShortDesc, | |
851 | string SigFile, | |
852 | const vector<struct IndexTarget*>* IndexTargets, | |
853 | indexRecords* MetaIndexParser) : | |
854 | Item(Owner), RealURI(URI), SigFile(SigFile) | |
855 | { | |
856 | this->AuthPass = false; | |
857 | this->MetaIndexParser = MetaIndexParser; | |
858 | this->IndexTargets = IndexTargets; | |
859 | DestFile = _config->FindDir("Dir::State::lists") + "partial/"; | |
860 | DestFile += URItoFileName(URI); | |
861 | ||
862 | // Create the item | |
863 | Desc.Description = URIDesc; | |
864 | Desc.Owner = this; | |
865 | Desc.ShortDesc = ShortDesc; | |
866 | Desc.URI = URI; | |
867 | ||
868 | QueueURI(Desc); | |
869 | } | |
870 | ||
871 | /*}}}*/ | |
872 | // pkgAcqMetaIndex::Custom600Headers - Insert custom request headers /*{{{*/ | |
873 | // --------------------------------------------------------------------- | |
874 | /* The only header we use is the last-modified header. */ | |
875 | string pkgAcqMetaIndex::Custom600Headers() | |
876 | { | |
877 | string Final = _config->FindDir("Dir::State::lists"); | |
878 | Final += URItoFileName(RealURI); | |
879 | ||
880 | struct stat Buf; | |
881 | if (stat(Final.c_str(),&Buf) != 0) | |
882 | return "\nIndex-File: true"; | |
883 | ||
884 | return "\nIndex-File: true\nLast-Modified: " + TimeRFC1123(Buf.st_mtime); | |
885 | } | |
886 | ||
887 | void pkgAcqMetaIndex::Done(string Message,unsigned long Size,string MD5, | |
888 | pkgAcquire::MethodConfig *Cfg) | |
889 | { | |
890 | Item::Done(Message,Size,MD5,Cfg); | |
891 | ||
892 | // MetaIndexes are done in two passes: one to download the | |
893 | // metaindex with an appropriate method, and a second to verify it | |
894 | // with the gpgv method | |
895 | ||
896 | if (AuthPass == true) | |
897 | { | |
898 | AuthDone(Message); | |
899 | } | |
900 | else | |
901 | { | |
902 | RetrievalDone(Message); | |
903 | if (!Complete) | |
904 | // Still more retrieving to do | |
905 | return; | |
906 | ||
907 | if (SigFile == "") | |
908 | { | |
909 | // There was no signature file, so we are finished. Download | |
910 | // the indexes without verification. | |
911 | QueueIndexes(false); | |
912 | } | |
913 | else | |
914 | { | |
915 | // There was a signature file, so pass it to gpgv for | |
916 | // verification | |
917 | ||
918 | if (_config->FindB("Debug::pkgAcquire::Auth", false)) | |
919 | std::cerr << "Metaindex acquired, queueing gpg verification (" | |
920 | << SigFile << "," << DestFile << ")\n"; | |
921 | AuthPass = true; | |
922 | Desc.URI = "gpgv:" + SigFile; | |
923 | QueueURI(Desc); | |
924 | Mode = "gpgv"; | |
925 | } | |
926 | } | |
927 | } | |
928 | ||
929 | void pkgAcqMetaIndex::RetrievalDone(string Message) | |
930 | { | |
931 | // We have just finished downloading a Release file (it is not | |
932 | // verified yet) | |
933 | ||
934 | string FileName = LookupTag(Message,"Filename"); | |
935 | if (FileName.empty() == true) | |
936 | { | |
937 | Status = StatError; | |
938 | ErrorText = "Method gave a blank filename"; | |
939 | return; | |
940 | } | |
941 | ||
942 | if (FileName != DestFile) | |
943 | { | |
944 | Local = true; | |
945 | Desc.URI = "copy:" + FileName; | |
946 | QueueURI(Desc); | |
947 | return; | |
948 | } | |
949 | ||
950 | Complete = true; | |
951 | ||
952 | string FinalFile = _config->FindDir("Dir::State::lists"); | |
953 | FinalFile += URItoFileName(RealURI); | |
954 | ||
955 | // The files timestamp matches | |
956 | if (StringToBool(LookupTag(Message,"IMS-Hit"),false) == false) | |
957 | { | |
958 | // Move it into position | |
959 | Rename(DestFile,FinalFile); | |
960 | } | |
961 | DestFile = FinalFile; | |
962 | } | |
963 | ||
964 | void pkgAcqMetaIndex::AuthDone(string Message) | |
965 | { | |
966 | // At this point, the gpgv method has succeeded, so there is a | |
967 | // valid signature from a key in the trusted keyring. We | |
968 | // perform additional verification of its contents, and use them | |
969 | // to verify the indexes we are about to download | |
970 | ||
971 | if (!MetaIndexParser->Load(DestFile)) | |
972 | { | |
973 | Status = StatAuthError; | |
974 | ErrorText = MetaIndexParser->ErrorText; | |
975 | return; | |
976 | } | |
977 | ||
978 | if (!VerifyVendor()) | |
979 | { | |
980 | return; | |
981 | } | |
982 | ||
983 | if (_config->FindB("Debug::pkgAcquire::Auth", false)) | |
984 | std::cerr << "Signature verification succeeded: " | |
985 | << DestFile << std::endl; | |
986 | ||
987 | // Download further indexes with verification | |
988 | QueueIndexes(true); | |
989 | ||
990 | // Done, move signature file into position | |
991 | ||
992 | string VerifiedSigFile = _config->FindDir("Dir::State::lists") + | |
993 | URItoFileName(RealURI) + ".gpg"; | |
994 | Rename(SigFile,VerifiedSigFile); | |
995 | chmod(VerifiedSigFile.c_str(),0644); | |
996 | } | |
997 | ||
998 | void pkgAcqMetaIndex::QueueIndexes(bool verify) | |
999 | { | |
1000 | for (vector <struct IndexTarget*>::const_iterator Target = IndexTargets->begin(); | |
1001 | Target != IndexTargets->end(); | |
1002 | Target++) | |
1003 | { | |
1004 | string ExpectedIndexMD5; | |
1005 | if (verify) | |
1006 | { | |
1007 | const indexRecords::checkSum *Record = MetaIndexParser->Lookup((*Target)->MetaKey); | |
1008 | if (!Record) | |
1009 | { | |
1010 | Status = StatAuthError; | |
1011 | ErrorText = "Unable to find expected entry " | |
1012 | + (*Target)->MetaKey + " in Meta-index file (malformed Release file?)"; | |
1013 | return; | |
1014 | } | |
1015 | ExpectedIndexMD5 = Record->MD5Hash; | |
1016 | if (_config->FindB("Debug::pkgAcquire::Auth", false)) | |
1017 | { | |
1018 | std::cerr << "Queueing: " << (*Target)->URI << std::endl; | |
1019 | std::cerr << "Expected MD5: " << ExpectedIndexMD5 << std::endl; | |
1020 | } | |
1021 | if (ExpectedIndexMD5.empty()) | |
1022 | { | |
1023 | Status = StatAuthError; | |
1024 | ErrorText = "Unable to find MD5 sum for " | |
1025 | + (*Target)->MetaKey + " in Meta-index file"; | |
1026 | return; | |
1027 | } | |
1028 | } | |
1029 | ||
2ac3eeb6 MV |
1030 | // Queue Packages file (either diff or full packages files, depending |
1031 | // on the users option) | |
27299daf | 1032 | if(_config->FindB("Acquire::PDiffs",true) == true) |
2ac3eeb6 MV |
1033 | new pkgAcqDiffIndex(Owner, (*Target)->URI, (*Target)->Description, |
1034 | (*Target)->ShortDesc, ExpectedIndexMD5); | |
1035 | else | |
81fcf9e2 | 1036 | new pkgAcqIndex(Owner, (*Target)->URI, (*Target)->Description, |
2ac3eeb6 | 1037 | (*Target)->ShortDesc, ExpectedIndexMD5); |
b3d44315 MV |
1038 | } |
1039 | } | |
1040 | ||
1041 | bool pkgAcqMetaIndex::VerifyVendor() | |
1042 | { | |
1043 | // // Maybe this should be made available from above so we don't have | |
1044 | // // to read and parse it every time? | |
1045 | // pkgVendorList List; | |
1046 | // List.ReadMainList(); | |
1047 | ||
1048 | // const Vendor* Vndr = NULL; | |
1049 | // for (std::vector<string>::const_iterator I = GPGVOutput.begin(); I != GPGVOutput.end(); I++) | |
1050 | // { | |
1051 | // string::size_type pos = (*I).find("VALIDSIG "); | |
1052 | // if (_config->FindB("Debug::Vendor", false)) | |
1053 | // std::cerr << "Looking for VALIDSIG in \"" << (*I) << "\": pos " << pos | |
1054 | // << std::endl; | |
1055 | // if (pos != std::string::npos) | |
1056 | // { | |
1057 | // string Fingerprint = (*I).substr(pos+sizeof("VALIDSIG")); | |
1058 | // if (_config->FindB("Debug::Vendor", false)) | |
1059 | // std::cerr << "Looking for \"" << Fingerprint << "\" in vendor..." << | |
1060 | // std::endl; | |
1061 | // Vndr = List.FindVendor(Fingerprint) != ""; | |
1062 | // if (Vndr != NULL); | |
1063 | // break; | |
1064 | // } | |
1065 | // } | |
1066 | ||
1067 | string Transformed = MetaIndexParser->GetExpectedDist(); | |
1068 | ||
1069 | if (Transformed == "../project/experimental") | |
1070 | { | |
1071 | Transformed = "experimental"; | |
1072 | } | |
1073 | ||
1074 | string::size_type pos = Transformed.rfind('/'); | |
1075 | if (pos != string::npos) | |
1076 | { | |
1077 | Transformed = Transformed.substr(0, pos); | |
1078 | } | |
1079 | ||
1080 | if (Transformed == ".") | |
1081 | { | |
1082 | Transformed = ""; | |
1083 | } | |
1084 | ||
1085 | if (_config->FindB("Debug::pkgAcquire::Auth", false)) | |
1086 | { | |
1087 | std::cerr << "Got Codename: " << MetaIndexParser->GetDist() << std::endl; | |
1088 | std::cerr << "Expecting Dist: " << MetaIndexParser->GetExpectedDist() << std::endl; | |
1089 | std::cerr << "Transformed Dist: " << Transformed << std::endl; | |
1090 | } | |
1091 | ||
1092 | if (MetaIndexParser->CheckDist(Transformed) == false) | |
1093 | { | |
1094 | // This might become fatal one day | |
1095 | // Status = StatAuthError; | |
1096 | // ErrorText = "Conflicting distribution; expected " | |
1097 | // + MetaIndexParser->GetExpectedDist() + " but got " | |
1098 | // + MetaIndexParser->GetDist(); | |
1099 | // return false; | |
1100 | if (!Transformed.empty()) | |
1101 | { | |
1102 | _error->Warning("Conflicting distribution: %s (expected %s but got %s)", | |
1103 | Desc.Description.c_str(), | |
1104 | Transformed.c_str(), | |
1105 | MetaIndexParser->GetDist().c_str()); | |
1106 | } | |
1107 | } | |
1108 | ||
1109 | return true; | |
1110 | } | |
1111 | /*}}}*/ | |
1112 | // pkgAcqMetaIndex::Failed - no Release file present or no signature | |
1113 | // file present /*{{{*/ | |
1114 | // --------------------------------------------------------------------- | |
1115 | /* */ | |
1116 | void pkgAcqMetaIndex::Failed(string Message,pkgAcquire::MethodConfig *Cnf) | |
1117 | { | |
1118 | if (AuthPass == true) | |
1119 | { | |
1120 | // gpgv method failed | |
1121 | _error->Warning("GPG error: %s: %s", | |
1122 | Desc.Description.c_str(), | |
1123 | LookupTag(Message,"Message").c_str()); | |
1124 | } | |
1125 | ||
1126 | // No Release file was present, or verification failed, so fall | |
1127 | // back to queueing Packages files without verification | |
1128 | QueueIndexes(false); | |
1129 | } | |
1130 | ||
681d76d0 | 1131 | /*}}}*/ |
03e39e59 AL |
1132 | |
1133 | // AcqArchive::AcqArchive - Constructor /*{{{*/ | |
1134 | // --------------------------------------------------------------------- | |
17caf1b1 AL |
1135 | /* This just sets up the initial fetch environment and queues the first |
1136 | possibilitiy */ | |
03e39e59 | 1137 | pkgAcqArchive::pkgAcqArchive(pkgAcquire *Owner,pkgSourceList *Sources, |
30e1eab5 AL |
1138 | pkgRecords *Recs,pkgCache::VerIterator const &Version, |
1139 | string &StoreFilename) : | |
1140 | Item(Owner), Version(Version), Sources(Sources), Recs(Recs), | |
b3d44315 MV |
1141 | StoreFilename(StoreFilename), Vf(Version.FileList()), |
1142 | Trusted(false) | |
03e39e59 | 1143 | { |
7d8afa39 | 1144 | Retries = _config->FindI("Acquire::Retries",0); |
813c8eea AL |
1145 | |
1146 | if (Version.Arch() == 0) | |
bdae53f1 | 1147 | { |
d1f1f6a8 | 1148 | _error->Error(_("I wasn't able to locate a file for the %s package. " |
7a3c2ab0 AL |
1149 | "This might mean you need to manually fix this package. " |
1150 | "(due to missing arch)"), | |
813c8eea | 1151 | Version.ParentPkg().Name()); |
bdae53f1 AL |
1152 | return; |
1153 | } | |
813c8eea | 1154 | |
b2e465d6 AL |
1155 | /* We need to find a filename to determine the extension. We make the |
1156 | assumption here that all the available sources for this version share | |
1157 | the same extension.. */ | |
1158 | // Skip not source sources, they do not have file fields. | |
1159 | for (; Vf.end() == false; Vf++) | |
1160 | { | |
1161 | if ((Vf.File()->Flags & pkgCache::Flag::NotSource) != 0) | |
1162 | continue; | |
1163 | break; | |
1164 | } | |
1165 | ||
1166 | // Does not really matter here.. we are going to fail out below | |
1167 | if (Vf.end() != true) | |
1168 | { | |
1169 | // If this fails to get a file name we will bomb out below. | |
1170 | pkgRecords::Parser &Parse = Recs->Lookup(Vf); | |
1171 | if (_error->PendingError() == true) | |
1172 | return; | |
1173 | ||
1174 | // Generate the final file name as: package_version_arch.foo | |
1175 | StoreFilename = QuoteString(Version.ParentPkg().Name(),"_:") + '_' + | |
1176 | QuoteString(Version.VerStr(),"_:") + '_' + | |
1177 | QuoteString(Version.Arch(),"_:.") + | |
1178 | "." + flExtension(Parse.FileName()); | |
1179 | } | |
b3d44315 MV |
1180 | |
1181 | // check if we have one trusted source for the package. if so, switch | |
1182 | // to "TrustedOnly" mode | |
1183 | for (pkgCache::VerFileIterator i = Version.FileList(); i.end() == false; i++) | |
1184 | { | |
1185 | pkgIndexFile *Index; | |
1186 | if (Sources->FindIndex(i.File(),Index) == false) | |
1187 | continue; | |
1188 | if (_config->FindB("Debug::pkgAcquire::Auth", false)) | |
1189 | { | |
1190 | std::cerr << "Checking index: " << Index->Describe() | |
1191 | << "(Trusted=" << Index->IsTrusted() << ")\n"; | |
1192 | } | |
1193 | if (Index->IsTrusted()) { | |
1194 | Trusted = true; | |
1195 | break; | |
1196 | } | |
1197 | } | |
1198 | ||
03e39e59 | 1199 | // Select a source |
b185acc2 | 1200 | if (QueueNext() == false && _error->PendingError() == false) |
b2e465d6 AL |
1201 | _error->Error(_("I wasn't able to locate file for the %s package. " |
1202 | "This might mean you need to manually fix this package."), | |
b185acc2 AL |
1203 | Version.ParentPkg().Name()); |
1204 | } | |
1205 | /*}}}*/ | |
1206 | // AcqArchive::QueueNext - Queue the next file source /*{{{*/ | |
1207 | // --------------------------------------------------------------------- | |
17caf1b1 AL |
1208 | /* This queues the next available file version for download. It checks if |
1209 | the archive is already available in the cache and stashs the MD5 for | |
1210 | checking later. */ | |
b185acc2 | 1211 | bool pkgAcqArchive::QueueNext() |
b2e465d6 | 1212 | { |
03e39e59 AL |
1213 | for (; Vf.end() == false; Vf++) |
1214 | { | |
1215 | // Ignore not source sources | |
1216 | if ((Vf.File()->Flags & pkgCache::Flag::NotSource) != 0) | |
1217 | continue; | |
1218 | ||
1219 | // Try to cross match against the source list | |
b2e465d6 AL |
1220 | pkgIndexFile *Index; |
1221 | if (Sources->FindIndex(Vf.File(),Index) == false) | |
1222 | continue; | |
03e39e59 | 1223 | |
b3d44315 MV |
1224 | // only try to get a trusted package from another source if that source |
1225 | // is also trusted | |
1226 | if(Trusted && !Index->IsTrusted()) | |
1227 | continue; | |
1228 | ||
03e39e59 AL |
1229 | // Grab the text package record |
1230 | pkgRecords::Parser &Parse = Recs->Lookup(Vf); | |
1231 | if (_error->PendingError() == true) | |
b185acc2 | 1232 | return false; |
03e39e59 | 1233 | |
b2e465d6 | 1234 | string PkgFile = Parse.FileName(); |
03e39e59 AL |
1235 | MD5 = Parse.MD5Hash(); |
1236 | if (PkgFile.empty() == true) | |
b2e465d6 AL |
1237 | return _error->Error(_("The package index files are corrupted. No Filename: " |
1238 | "field for package %s."), | |
1239 | Version.ParentPkg().Name()); | |
a6568219 | 1240 | |
b3d44315 MV |
1241 | Desc.URI = Index->ArchiveURI(PkgFile); |
1242 | Desc.Description = Index->ArchiveInfo(Version); | |
1243 | Desc.Owner = this; | |
1244 | Desc.ShortDesc = Version.ParentPkg().Name(); | |
1245 | ||
17caf1b1 | 1246 | // See if we already have the file. (Legacy filenames) |
a6568219 AL |
1247 | FileSize = Version->Size; |
1248 | string FinalFile = _config->FindDir("Dir::Cache::Archives") + flNotDir(PkgFile); | |
1249 | struct stat Buf; | |
1250 | if (stat(FinalFile.c_str(),&Buf) == 0) | |
1251 | { | |
1252 | // Make sure the size matches | |
1253 | if ((unsigned)Buf.st_size == Version->Size) | |
1254 | { | |
1255 | Complete = true; | |
1256 | Local = true; | |
1257 | Status = StatDone; | |
30e1eab5 | 1258 | StoreFilename = DestFile = FinalFile; |
b185acc2 | 1259 | return true; |
a6568219 AL |
1260 | } |
1261 | ||
6b1ff003 AL |
1262 | /* Hmm, we have a file and its size does not match, this means it is |
1263 | an old style mismatched arch */ | |
a6568219 AL |
1264 | unlink(FinalFile.c_str()); |
1265 | } | |
17caf1b1 AL |
1266 | |
1267 | // Check it again using the new style output filenames | |
1268 | FinalFile = _config->FindDir("Dir::Cache::Archives") + flNotDir(StoreFilename); | |
1269 | if (stat(FinalFile.c_str(),&Buf) == 0) | |
1270 | { | |
1271 | // Make sure the size matches | |
1272 | if ((unsigned)Buf.st_size == Version->Size) | |
1273 | { | |
1274 | Complete = true; | |
1275 | Local = true; | |
1276 | Status = StatDone; | |
1277 | StoreFilename = DestFile = FinalFile; | |
1278 | return true; | |
1279 | } | |
1280 | ||
1281 | /* Hmm, we have a file and its size does not match, this shouldnt | |
1282 | happen.. */ | |
1283 | unlink(FinalFile.c_str()); | |
1284 | } | |
1285 | ||
1286 | DestFile = _config->FindDir("Dir::Cache::Archives") + "partial/" + flNotDir(StoreFilename); | |
6b1ff003 AL |
1287 | |
1288 | // Check the destination file | |
1289 | if (stat(DestFile.c_str(),&Buf) == 0) | |
1290 | { | |
1291 | // Hmm, the partial file is too big, erase it | |
1292 | if ((unsigned)Buf.st_size > Version->Size) | |
1293 | unlink(DestFile.c_str()); | |
1294 | else | |
1295 | PartialSize = Buf.st_size; | |
1296 | } | |
1297 | ||
03e39e59 | 1298 | // Create the item |
b2e465d6 AL |
1299 | Local = false; |
1300 | Desc.URI = Index->ArchiveURI(PkgFile); | |
1301 | Desc.Description = Index->ArchiveInfo(Version); | |
03e39e59 AL |
1302 | Desc.Owner = this; |
1303 | Desc.ShortDesc = Version.ParentPkg().Name(); | |
1304 | QueueURI(Desc); | |
b185acc2 AL |
1305 | |
1306 | Vf++; | |
1307 | return true; | |
03e39e59 | 1308 | } |
b185acc2 AL |
1309 | return false; |
1310 | } | |
03e39e59 AL |
1311 | /*}}}*/ |
1312 | // AcqArchive::Done - Finished fetching /*{{{*/ | |
1313 | // --------------------------------------------------------------------- | |
1314 | /* */ | |
459681d3 AL |
1315 | void pkgAcqArchive::Done(string Message,unsigned long Size,string Md5Hash, |
1316 | pkgAcquire::MethodConfig *Cfg) | |
03e39e59 | 1317 | { |
459681d3 | 1318 | Item::Done(Message,Size,Md5Hash,Cfg); |
03e39e59 AL |
1319 | |
1320 | // Check the size | |
1321 | if (Size != Version->Size) | |
1322 | { | |
bdae53f1 | 1323 | Status = StatError; |
b2e465d6 | 1324 | ErrorText = _("Size mismatch"); |
03e39e59 AL |
1325 | return; |
1326 | } | |
1327 | ||
1328 | // Check the md5 | |
1329 | if (Md5Hash.empty() == false && MD5.empty() == false) | |
1330 | { | |
1331 | if (Md5Hash != MD5) | |
1332 | { | |
bdae53f1 | 1333 | Status = StatError; |
b2e465d6 | 1334 | ErrorText = _("MD5Sum mismatch"); |
13e8426f MV |
1335 | if(FileExists(DestFile)) |
1336 | Rename(DestFile,DestFile + ".FAILED"); | |
03e39e59 AL |
1337 | return; |
1338 | } | |
1339 | } | |
a6568219 AL |
1340 | |
1341 | // Grab the output filename | |
03e39e59 AL |
1342 | string FileName = LookupTag(Message,"Filename"); |
1343 | if (FileName.empty() == true) | |
1344 | { | |
1345 | Status = StatError; | |
1346 | ErrorText = "Method gave a blank filename"; | |
1347 | return; | |
1348 | } | |
a6568219 AL |
1349 | |
1350 | Complete = true; | |
30e1eab5 AL |
1351 | |
1352 | // Reference filename | |
a6568219 AL |
1353 | if (FileName != DestFile) |
1354 | { | |
30e1eab5 | 1355 | StoreFilename = DestFile = FileName; |
a6568219 AL |
1356 | Local = true; |
1357 | return; | |
1358 | } | |
1359 | ||
1360 | // Done, move it into position | |
1361 | string FinalFile = _config->FindDir("Dir::Cache::Archives"); | |
17caf1b1 | 1362 | FinalFile += flNotDir(StoreFilename); |
a6568219 | 1363 | Rename(DestFile,FinalFile); |
03e39e59 | 1364 | |
30e1eab5 | 1365 | StoreFilename = DestFile = FinalFile; |
03e39e59 AL |
1366 | Complete = true; |
1367 | } | |
1368 | /*}}}*/ | |
db890fdb AL |
1369 | // AcqArchive::Failed - Failure handler /*{{{*/ |
1370 | // --------------------------------------------------------------------- | |
1371 | /* Here we try other sources */ | |
7d8afa39 | 1372 | void pkgAcqArchive::Failed(string Message,pkgAcquire::MethodConfig *Cnf) |
db890fdb AL |
1373 | { |
1374 | ErrorText = LookupTag(Message,"Message"); | |
b2e465d6 AL |
1375 | |
1376 | /* We don't really want to retry on failed media swaps, this prevents | |
1377 | that. An interesting observation is that permanent failures are not | |
1378 | recorded. */ | |
1379 | if (Cnf->Removable == true && | |
1380 | StringToBool(LookupTag(Message,"Transient-Failure"),false) == true) | |
1381 | { | |
1382 | // Vf = Version.FileList(); | |
1383 | while (Vf.end() == false) Vf++; | |
1384 | StoreFilename = string(); | |
1385 | Item::Failed(Message,Cnf); | |
1386 | return; | |
1387 | } | |
1388 | ||
db890fdb | 1389 | if (QueueNext() == false) |
7d8afa39 AL |
1390 | { |
1391 | // This is the retry counter | |
1392 | if (Retries != 0 && | |
1393 | Cnf->LocalOnly == false && | |
1394 | StringToBool(LookupTag(Message,"Transient-Failure"),false) == true) | |
1395 | { | |
1396 | Retries--; | |
1397 | Vf = Version.FileList(); | |
1398 | if (QueueNext() == true) | |
1399 | return; | |
1400 | } | |
1401 | ||
9dbb421f | 1402 | StoreFilename = string(); |
7d8afa39 AL |
1403 | Item::Failed(Message,Cnf); |
1404 | } | |
db890fdb AL |
1405 | } |
1406 | /*}}}*/ | |
b3d44315 MV |
1407 | // AcqArchive::IsTrusted - Determine whether this archive comes from a |
1408 | // trusted source /*{{{*/ | |
1409 | // --------------------------------------------------------------------- | |
1410 | bool pkgAcqArchive::IsTrusted() | |
1411 | { | |
1412 | return Trusted; | |
1413 | } | |
1414 | ||
ab559b35 AL |
1415 | // AcqArchive::Finished - Fetching has finished, tidy up /*{{{*/ |
1416 | // --------------------------------------------------------------------- | |
1417 | /* */ | |
1418 | void pkgAcqArchive::Finished() | |
1419 | { | |
1420 | if (Status == pkgAcquire::Item::StatDone && | |
1421 | Complete == true) | |
1422 | return; | |
1423 | StoreFilename = string(); | |
1424 | } | |
1425 | /*}}}*/ | |
36375005 AL |
1426 | |
1427 | // AcqFile::pkgAcqFile - Constructor /*{{{*/ | |
1428 | // --------------------------------------------------------------------- | |
1429 | /* The file is added to the queue */ | |
1430 | pkgAcqFile::pkgAcqFile(pkgAcquire *Owner,string URI,string MD5, | |
1431 | unsigned long Size,string Dsc,string ShortDesc) : | |
b3c39978 | 1432 | Item(Owner), Md5Hash(MD5) |
36375005 | 1433 | { |
08cfc005 AL |
1434 | Retries = _config->FindI("Acquire::Retries",0); |
1435 | ||
36375005 AL |
1436 | DestFile = flNotDir(URI); |
1437 | ||
1438 | // Create the item | |
1439 | Desc.URI = URI; | |
1440 | Desc.Description = Dsc; | |
1441 | Desc.Owner = this; | |
1442 | ||
1443 | // Set the short description to the archive component | |
1444 | Desc.ShortDesc = ShortDesc; | |
1445 | ||
1446 | // Get the transfer sizes | |
1447 | FileSize = Size; | |
1448 | struct stat Buf; | |
1449 | if (stat(DestFile.c_str(),&Buf) == 0) | |
1450 | { | |
1451 | // Hmm, the partial file is too big, erase it | |
1452 | if ((unsigned)Buf.st_size > Size) | |
1453 | unlink(DestFile.c_str()); | |
1454 | else | |
1455 | PartialSize = Buf.st_size; | |
1456 | } | |
1457 | ||
1458 | QueueURI(Desc); | |
1459 | } | |
1460 | /*}}}*/ | |
1461 | // AcqFile::Done - Item downloaded OK /*{{{*/ | |
1462 | // --------------------------------------------------------------------- | |
1463 | /* */ | |
459681d3 AL |
1464 | void pkgAcqFile::Done(string Message,unsigned long Size,string MD5, |
1465 | pkgAcquire::MethodConfig *Cnf) | |
36375005 | 1466 | { |
b3c39978 AL |
1467 | // Check the md5 |
1468 | if (Md5Hash.empty() == false && MD5.empty() == false) | |
1469 | { | |
1470 | if (Md5Hash != MD5) | |
1471 | { | |
1472 | Status = StatError; | |
1473 | ErrorText = "MD5Sum mismatch"; | |
1474 | Rename(DestFile,DestFile + ".FAILED"); | |
1475 | return; | |
1476 | } | |
1477 | } | |
1478 | ||
459681d3 | 1479 | Item::Done(Message,Size,MD5,Cnf); |
36375005 AL |
1480 | |
1481 | string FileName = LookupTag(Message,"Filename"); | |
1482 | if (FileName.empty() == true) | |
1483 | { | |
1484 | Status = StatError; | |
1485 | ErrorText = "Method gave a blank filename"; | |
1486 | return; | |
1487 | } | |
1488 | ||
1489 | Complete = true; | |
1490 | ||
1491 | // The files timestamp matches | |
1492 | if (StringToBool(LookupTag(Message,"IMS-Hit"),false) == true) | |
1493 | return; | |
1494 | ||
1495 | // We have to copy it into place | |
1496 | if (FileName != DestFile) | |
1497 | { | |
1498 | Local = true; | |
459681d3 AL |
1499 | if (_config->FindB("Acquire::Source-Symlinks",true) == false || |
1500 | Cnf->Removable == true) | |
917ae805 AL |
1501 | { |
1502 | Desc.URI = "copy:" + FileName; | |
1503 | QueueURI(Desc); | |
1504 | return; | |
1505 | } | |
1506 | ||
83ab33fc AL |
1507 | // Erase the file if it is a symlink so we can overwrite it |
1508 | struct stat St; | |
1509 | if (lstat(DestFile.c_str(),&St) == 0) | |
1510 | { | |
1511 | if (S_ISLNK(St.st_mode) != 0) | |
1512 | unlink(DestFile.c_str()); | |
1513 | } | |
1514 | ||
1515 | // Symlink the file | |
917ae805 AL |
1516 | if (symlink(FileName.c_str(),DestFile.c_str()) != 0) |
1517 | { | |
83ab33fc | 1518 | ErrorText = "Link to " + DestFile + " failure "; |
917ae805 AL |
1519 | Status = StatError; |
1520 | Complete = false; | |
1521 | } | |
36375005 AL |
1522 | } |
1523 | } | |
1524 | /*}}}*/ | |
08cfc005 AL |
1525 | // AcqFile::Failed - Failure handler /*{{{*/ |
1526 | // --------------------------------------------------------------------- | |
1527 | /* Here we try other sources */ | |
1528 | void pkgAcqFile::Failed(string Message,pkgAcquire::MethodConfig *Cnf) | |
1529 | { | |
1530 | ErrorText = LookupTag(Message,"Message"); | |
1531 | ||
1532 | // This is the retry counter | |
1533 | if (Retries != 0 && | |
1534 | Cnf->LocalOnly == false && | |
1535 | StringToBool(LookupTag(Message,"Transient-Failure"),false) == true) | |
1536 | { | |
1537 | Retries--; | |
1538 | QueueURI(Desc); | |
1539 | return; | |
1540 | } | |
1541 | ||
1542 | Item::Failed(Message,Cnf); | |
1543 | } | |
1544 | /*}}}*/ |