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