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