]> git.saurik.com Git - apt-legacy.git/blame - apt-pkg/acquire-item.cc
Upgraded to APT 0.7.
[apt-legacy.git] / apt-pkg / acquire-item.cc
CommitLineData
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
37using namespace std;
38
39// Acquire::Item::Item - Constructor /*{{{*/
40// ---------------------------------------------------------------------
41/* */
42pkgAcquire::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/* */
53pkgAcquire::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 */
62void 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 */
88void 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 98void 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 */
122void 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 */
143pkgAcqDiffIndex::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. */
191string 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
207bool 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
295void 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
309void 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 */
346pkgAcqIndexDiffs::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
377void 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
389void 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
426bool 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
475void 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 */
552pkgAcqIndex::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. */
585string 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
598void 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 642void 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 */
742pkgAcqIndexTrans::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/* */
752void 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
768pkgAcqMetaSig::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. */
812string 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
821void 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 /*}}}*/
857void 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
894pkgAcqMetaIndex::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. */
918string 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 930void 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
972void 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
1011void 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
1045void 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
1088bool 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/* */
1179void 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 */
1220pkgAcqArchive::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. */
1300bool 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 1409void 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 */
1463void 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// ---------------------------------------------------------------------
1501bool pkgAcqArchive::IsTrusted()
1502{
1503 return Trusted;
1504}
1505
1506// AcqArchive::Finished - Fetching has finished, tidy up /*{{{*/
1507// ---------------------------------------------------------------------
1508/* */
1509void 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 1521pkgAcqFile::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 1561void 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 */
1622void 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 /*}}}*/