1 // -*- mode: cpp; mode: fold -*-
3 // $Id: acquire-item.cc,v 1.46.2.9 2004/01/16 18:51:11 mdz Exp $
4 /* ######################################################################
6 Acquire Item - Item to acquire
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.
13 ##################################################################### */
15 // Include Files /*{{{*/
18 #include <apt-pkg/acquire-item.h>
19 #include <apt-pkg/configuration.h>
20 #include <apt-pkg/aptconfiguration.h>
21 #include <apt-pkg/sourcelist.h>
22 #include <apt-pkg/error.h>
23 #include <apt-pkg/strutl.h>
24 #include <apt-pkg/fileutl.h>
25 #include <apt-pkg/sha1.h>
26 #include <apt-pkg/tagfile.h>
27 #include <apt-pkg/indexrecords.h>
28 #include <apt-pkg/acquire.h>
29 #include <apt-pkg/hashes.h>
30 #include <apt-pkg/indexfile.h>
31 #include <apt-pkg/pkgcache.h>
32 #include <apt-pkg/cacheiterators.h>
33 #include <apt-pkg/pkgrecords.h>
53 static void printHashSumComparision(std::string
const &URI
, HashStringList
const &Expected
, HashStringList
const &Actual
) /*{{{*/
55 if (_config
->FindB("Debug::Acquire::HashSumMismatch", false) == false)
57 std::cerr
<< std::endl
<< URI
<< ":" << std::endl
<< " Expected Hash: " << std::endl
;
58 for (HashStringList::const_iterator hs
= Expected
.begin(); hs
!= Expected
.end(); ++hs
)
59 std::cerr
<< "\t- " << hs
->toStr() << std::endl
;
60 std::cerr
<< " Actual Hash: " << std::endl
;
61 for (HashStringList::const_iterator hs
= Actual
.begin(); hs
!= Actual
.end(); ++hs
)
62 std::cerr
<< "\t- " << hs
->toStr() << std::endl
;
66 // Acquire::Item::Item - Constructor /*{{{*/
67 pkgAcquire::Item::Item(pkgAcquire
*Owner
,
68 HashStringList
const &ExpectedHashes
,
69 unsigned long TransactionID
)
70 : Owner(Owner
), FileSize(0), PartialSize(0), Mode(0), ID(0), Complete(false),
71 Local(false), QueueCounter(0), TransactionID(TransactionID
),
72 ExpectedAdditionalItems(0), ExpectedHashes(ExpectedHashes
)
78 // Acquire::Item::~Item - Destructor /*{{{*/
79 // ---------------------------------------------------------------------
81 pkgAcquire::Item::~Item()
86 // Acquire::Item::Failed - Item failed to download /*{{{*/
87 // ---------------------------------------------------------------------
88 /* We return to an idle state if there are still other queues that could
90 void pkgAcquire::Item::Failed(string Message
,pkgAcquire::MethodConfig
*Cnf
)
94 ErrorText
= LookupTag(Message
,"Message");
95 UsedMirror
= LookupTag(Message
,"UsedMirror");
96 if (QueueCounter
<= 1)
98 /* This indicates that the file is not available right now but might
99 be sometime later. If we do a retry cycle then this should be
101 if (Cnf
->LocalOnly
== true &&
102 StringToBool(LookupTag(Message
,"Transient-Failure"),false) == true)
113 // report mirror failure back to LP if we actually use a mirror
114 string FailReason
= LookupTag(Message
, "FailReason");
115 if(FailReason
.size() != 0)
116 ReportMirrorFailure(FailReason
);
118 ReportMirrorFailure(ErrorText
);
121 // Acquire::Item::Start - Item has begun to download /*{{{*/
122 // ---------------------------------------------------------------------
123 /* Stash status and the file size. Note that setting Complete means
124 sub-phases of the acquire process such as decompresion are operating */
125 void pkgAcquire::Item::Start(string
/*Message*/,unsigned long long Size
)
127 Status
= StatFetching
;
128 if (FileSize
== 0 && Complete
== false)
132 // Acquire::Item::Done - Item downloaded OK /*{{{*/
133 // ---------------------------------------------------------------------
135 void pkgAcquire::Item::Done(string Message
,unsigned long long Size
,HashStringList
const &/*Hash*/,
136 pkgAcquire::MethodConfig
* /*Cnf*/)
138 // We just downloaded something..
139 string FileName
= LookupTag(Message
,"Filename");
140 UsedMirror
= LookupTag(Message
,"UsedMirror");
141 if (Complete
== false && !Local
&& FileName
== DestFile
)
144 Owner
->Log
->Fetched(Size
,atoi(LookupTag(Message
,"Resume-Point","0").c_str()));
150 ErrorText
= string();
151 Owner
->Dequeue(this);
154 // Acquire::Item::Rename - Rename a file /*{{{*/
155 // ---------------------------------------------------------------------
156 /* This helper function is used by a lot of item methods as their final
158 void pkgAcquire::Item::Rename(string From
,string To
)
160 if (rename(From
.c_str(),To
.c_str()) != 0)
163 snprintf(S
,sizeof(S
),_("rename failed, %s (%s -> %s)."),strerror(errno
),
164 From
.c_str(),To
.c_str());
170 bool pkgAcquire::Item::RenameOnError(pkgAcquire::Item::RenameOnErrorState
const error
)/*{{{*/
172 if(FileExists(DestFile
))
173 Rename(DestFile
, DestFile
+ ".FAILED");
177 case HashSumMismatch
:
178 ErrorText
= _("Hash Sum mismatch");
179 Status
= StatAuthError
;
180 ReportMirrorFailure("HashChecksumFailure");
183 ErrorText
= _("Size mismatch");
184 Status
= StatAuthError
;
185 ReportMirrorFailure("SizeFailure");
188 ErrorText
= _("Invalid file format");
190 // do not report as usually its not the mirrors fault, but Portal/Proxy
196 // Acquire::Item::ReportMirrorFailure /*{{{*/
197 // ---------------------------------------------------------------------
198 void pkgAcquire::Item::ReportMirrorFailure(string FailCode
)
200 // we only act if a mirror was used at all
201 if(UsedMirror
.empty())
204 std::cerr
<< "\nReportMirrorFailure: "
206 << " Uri: " << DescURI()
208 << FailCode
<< std::endl
;
210 const char *Args
[40];
212 string report
= _config
->Find("Methods::Mirror::ProblemReporting",
213 "/usr/lib/apt/apt-report-mirror-failure");
214 if(!FileExists(report
))
216 Args
[i
++] = report
.c_str();
217 Args
[i
++] = UsedMirror
.c_str();
218 Args
[i
++] = DescURI().c_str();
219 Args
[i
++] = FailCode
.c_str();
221 pid_t pid
= ExecFork();
224 _error
->Error("ReportMirrorFailure Fork failed");
229 execvp(Args
[0], (char**)Args
);
230 std::cerr
<< "Could not exec " << Args
[0] << std::endl
;
233 if(!ExecWait(pid
, "report-mirror-failure"))
235 _error
->Warning("Couldn't report problem to '%s'",
236 _config
->Find("Methods::Mirror::ProblemReporting").c_str());
240 // AcqSubIndex::AcqSubIndex - Constructor /*{{{*/
241 // ---------------------------------------------------------------------
242 /* Get a sub-index file based on checksums from a 'master' file and
243 possibly query additional files */
244 pkgAcqSubIndex::pkgAcqSubIndex(pkgAcquire
*Owner
,
245 unsigned long TransactionID
,
247 string
const &URIDesc
, string
const &ShortDesc
,
248 HashStringList
const &ExpectedHashes
)
249 : Item(Owner
, ExpectedHashes
, TransactionID
)
251 /* XXX: Beware: Currently this class does nothing (of value) anymore ! */
252 Debug
= _config
->FindB("Debug::pkgAcquire::SubIndex",false);
254 DestFile
= _config
->FindDir("Dir::State::lists") + "partial/";
255 DestFile
+= URItoFileName(URI
);
258 Desc
.Description
= URIDesc
;
260 Desc
.ShortDesc
= ShortDesc
;
265 std::clog
<< "pkgAcqSubIndex: " << Desc
.URI
<< std::endl
;
268 // AcqSubIndex::Custom600Headers - Insert custom request headers /*{{{*/
269 // ---------------------------------------------------------------------
270 /* The only header we use is the last-modified header. */
271 string
pkgAcqSubIndex::Custom600Headers() const
273 string Final
= _config
->FindDir("Dir::State::lists");
274 Final
+= URItoFileName(Desc
.URI
);
277 if (stat(Final
.c_str(),&Buf
) != 0)
278 return "\nIndex-File: true\nFail-Ignore: true\n";
279 return "\nIndex-File: true\nFail-Ignore: true\nLast-Modified: " + TimeRFC1123(Buf
.st_mtime
);
282 void pkgAcqSubIndex::Failed(string Message
,pkgAcquire::MethodConfig
* /*Cnf*/)/*{{{*/
285 std::clog
<< "pkgAcqSubIndex failed: " << Desc
.URI
<< " with " << Message
<< std::endl
;
291 // No good Index is provided
294 void pkgAcqSubIndex::Done(string Message
,unsigned long long Size
,HashStringList
const &Hashes
, /*{{{*/
295 pkgAcquire::MethodConfig
*Cnf
)
298 std::clog
<< "pkgAcqSubIndex::Done(): " << Desc
.URI
<< std::endl
;
300 string FileName
= LookupTag(Message
,"Filename");
301 if (FileName
.empty() == true)
304 ErrorText
= "Method gave a blank filename";
308 if (FileName
!= DestFile
)
311 Desc
.URI
= "copy:" + FileName
;
316 Item::Done(Message
, Size
, Hashes
, Cnf
);
318 string FinalFile
= _config
->FindDir("Dir::State::lists")+URItoFileName(Desc
.URI
);
320 /* Downloaded invalid transindex => Error (LP: #346386) (Closes: #627642) */
321 indexRecords SubIndexParser
;
322 if (FileExists(DestFile
) == true && !SubIndexParser
.Load(DestFile
)) {
324 ErrorText
= SubIndexParser
.ErrorText
;
328 // success in downloading the index
331 std::clog
<< "Renaming: " << DestFile
<< " -> " << FinalFile
<< std::endl
;
332 Rename(DestFile
,FinalFile
);
333 chmod(FinalFile
.c_str(),0644);
334 DestFile
= FinalFile
;
336 if(ParseIndex(DestFile
) == false)
337 return Failed("", NULL
);
345 bool pkgAcqSubIndex::ParseIndex(string
const &IndexFile
) /*{{{*/
347 indexRecords SubIndexParser
;
348 if (FileExists(IndexFile
) == false || SubIndexParser
.Load(IndexFile
) == false)
350 // so something with the downloaded index
354 // AcqDiffIndex::AcqDiffIndex - Constructor /*{{{*/
355 // ---------------------------------------------------------------------
356 /* Get the DiffIndex file first and see if there are patches available
357 * If so, create a pkgAcqIndexDiffs fetcher that will get and apply the
358 * patches. If anything goes wrong in that process, it will fall back to
359 * the original packages file
361 pkgAcqDiffIndex::pkgAcqDiffIndex(pkgAcquire
*Owner
,
362 unsigned long TransactionID
,
363 IndexTarget
const * const Target
,
364 HashStringList
const &ExpectedHashes
,
365 indexRecords
*MetaIndexParser
)
366 : pkgAcqBaseIndex(Owner
, TransactionID
, Target
, ExpectedHashes
,
370 Debug
= _config
->FindB("Debug::pkgAcquire::Diffs",false);
372 RealURI
= Target
->URI
;
374 Desc
.Description
= Target
->Description
+ "/DiffIndex";
375 Desc
.ShortDesc
= Target
->ShortDesc
;
376 Desc
.URI
= Target
->URI
+ ".diff/Index";
378 DestFile
= _config
->FindDir("Dir::State::lists") + "partial/";
379 DestFile
+= URItoFileName(Target
->URI
) + string(".DiffIndex");
382 std::clog
<< "pkgAcqDiffIndex: " << Desc
.URI
<< std::endl
;
384 // look for the current package file
385 CurrentPackagesFile
= _config
->FindDir("Dir::State::lists");
386 CurrentPackagesFile
+= URItoFileName(RealURI
);
388 // FIXME: this file:/ check is a hack to prevent fetching
389 // from local sources. this is really silly, and
390 // should be fixed cleanly as soon as possible
391 if(!FileExists(CurrentPackagesFile
) ||
392 Desc
.URI
.substr(0,strlen("file:/")) == "file:/")
394 // we don't have a pkg file or we don't want to queue
396 std::clog
<< "No index file, local or canceld by user" << std::endl
;
402 std::clog
<< "pkgAcqDiffIndex::pkgAcqDiffIndex(): "
403 << CurrentPackagesFile
<< std::endl
;
409 // AcqIndex::Custom600Headers - Insert custom request headers /*{{{*/
410 // ---------------------------------------------------------------------
411 /* The only header we use is the last-modified header. */
412 string
pkgAcqDiffIndex::Custom600Headers() const
414 string Final
= _config
->FindDir("Dir::State::lists");
415 Final
+= URItoFileName(RealURI
) + string(".IndexDiff");
418 std::clog
<< "Custom600Header-IMS: " << Final
<< std::endl
;
421 if (stat(Final
.c_str(),&Buf
) != 0)
422 return "\nIndex-File: true";
424 return "\nIndex-File: true\nLast-Modified: " + TimeRFC1123(Buf
.st_mtime
);
427 bool pkgAcqDiffIndex::ParseDiffIndex(string IndexDiffFile
) /*{{{*/
430 std::clog
<< "pkgAcqDiffIndex::ParseIndexDiff() " << IndexDiffFile
435 vector
<DiffInfo
> available_patches
;
437 FileFd
Fd(IndexDiffFile
,FileFd::ReadOnly
);
439 if (_error
->PendingError() == true)
442 if(TF
.Step(Tags
) == true)
448 string
const tmp
= Tags
.FindS("SHA1-Current");
449 std::stringstream
ss(tmp
);
450 ss
>> ServerSha1
>> size
;
451 unsigned long const ServerSize
= atol(size
.c_str());
453 FileFd
fd(CurrentPackagesFile
, FileFd::ReadOnly
);
456 string
const local_sha1
= SHA1
.Result();
458 if(local_sha1
== ServerSha1
)
460 // we have the same sha1 as the server so we are done here
462 std::clog
<< "Package file is up-to-date" << std::endl
;
463 // list cleanup needs to know that this file as well as the already
464 // present index is ours, so we create an empty diff to save it for us
465 new pkgAcqIndexDiffs(Owner
, TransactionID
, Target
,
466 ExpectedHashes
, MetaIndexParser
,
467 ServerSha1
, available_patches
);
473 std::clog
<< "SHA1-Current: " << ServerSha1
<< " and we start at "<< fd
.Name() << " " << fd
.Size() << " " << local_sha1
<< std::endl
;
475 // check the historie and see what patches we need
476 string
const history
= Tags
.FindS("SHA1-History");
477 std::stringstream
hist(history
);
478 while(hist
>> d
.sha1
>> size
>> d
.file
)
480 // read until the first match is found
481 // from that point on, we probably need all diffs
482 if(d
.sha1
== local_sha1
)
484 else if (found
== false)
488 std::clog
<< "Need to get diff: " << d
.file
<< std::endl
;
489 available_patches
.push_back(d
);
492 if (available_patches
.empty() == false)
494 // patching with too many files is rather slow compared to a fast download
495 unsigned long const fileLimit
= _config
->FindI("Acquire::PDiffs::FileLimit", 0);
496 if (fileLimit
!= 0 && fileLimit
< available_patches
.size())
499 std::clog
<< "Need " << available_patches
.size() << " diffs (Limit is " << fileLimit
500 << ") so fallback to complete download" << std::endl
;
504 // see if the patches are too big
505 found
= false; // it was true and it will be true again at the end
506 d
= *available_patches
.begin();
507 string
const firstPatch
= d
.file
;
508 unsigned long patchesSize
= 0;
509 std::stringstream
patches(Tags
.FindS("SHA1-Patches"));
510 while(patches
>> d
.sha1
>> size
>> d
.file
)
512 if (firstPatch
== d
.file
)
514 else if (found
== false)
517 patchesSize
+= atol(size
.c_str());
519 unsigned long const sizeLimit
= ServerSize
* _config
->FindI("Acquire::PDiffs::SizeLimit", 100);
520 if (sizeLimit
> 0 && (sizeLimit
/100) < patchesSize
)
523 std::clog
<< "Need " << patchesSize
<< " bytes (Limit is " << sizeLimit
/100
524 << ") so fallback to complete download" << std::endl
;
530 // we have something, queue the next diff
534 string::size_type
const last_space
= Description
.rfind(" ");
535 if(last_space
!= string::npos
)
536 Description
.erase(last_space
, Description
.size()-last_space
);
538 /* decide if we should download patches one by one or in one go:
539 The first is good if the server merges patches, but many don't so client
540 based merging can be attempt in which case the second is better.
541 "bad things" will happen if patches are merged on the server,
542 but client side merging is attempt as well */
543 bool pdiff_merge
= _config
->FindB("Acquire::PDiffs::Merge", true);
544 if (pdiff_merge
== true)
546 // reprepro adds this flag if it has merged patches on the server
547 std::string
const precedence
= Tags
.FindS("X-Patch-Precedence");
548 pdiff_merge
= (precedence
!= "merged");
551 if (pdiff_merge
== false)
553 new pkgAcqIndexDiffs(Owner
, TransactionID
, Target
, ExpectedHashes
,
555 ServerSha1
, available_patches
);
559 std::vector
<pkgAcqIndexMergeDiffs
*> *diffs
= new std::vector
<pkgAcqIndexMergeDiffs
*>(available_patches
.size());
560 for(size_t i
= 0; i
< available_patches
.size(); ++i
)
561 (*diffs
)[i
] = new pkgAcqIndexMergeDiffs(Owner
,
566 available_patches
[i
],
577 // Nothing found, report and return false
578 // Failing here is ok, if we return false later, the full
579 // IndexFile is queued
581 std::clog
<< "Can't find a patch in the index file" << std::endl
;
585 void pkgAcqDiffIndex::Failed(string Message
,pkgAcquire::MethodConfig
* /*Cnf*/)/*{{{*/
588 std::clog
<< "pkgAcqDiffIndex failed: " << Desc
.URI
<< " with " << Message
<< std::endl
589 << "Falling back to normal index file acquire" << std::endl
;
591 new pkgAcqIndex(Owner
, TransactionID
, Target
, ExpectedHashes
, MetaIndexParser
);
598 void pkgAcqDiffIndex::Done(string Message
,unsigned long long Size
,HashStringList
const &Hashes
, /*{{{*/
599 pkgAcquire::MethodConfig
*Cnf
)
602 std::clog
<< "pkgAcqDiffIndex::Done(): " << Desc
.URI
<< std::endl
;
604 Item::Done(Message
, Size
, Hashes
, Cnf
);
607 FinalFile
= _config
->FindDir("Dir::State::lists")+URItoFileName(RealURI
);
609 // success in downloading the index
611 FinalFile
+= string(".IndexDiff");
613 std::clog
<< "Renaming: " << DestFile
<< " -> " << FinalFile
615 Rename(DestFile
,FinalFile
);
616 chmod(FinalFile
.c_str(),0644);
617 DestFile
= FinalFile
;
619 if(!ParseDiffIndex(DestFile
))
620 return Failed("", NULL
);
628 // AcqIndexDiffs::AcqIndexDiffs - Constructor /*{{{*/
629 // ---------------------------------------------------------------------
630 /* The package diff is added to the queue. one object is constructed
631 * for each diff and the index
633 pkgAcqIndexDiffs::pkgAcqIndexDiffs(pkgAcquire
*Owner
,
634 unsigned long TransactionID
,
635 struct IndexTarget
const * const Target
,
636 HashStringList
const &ExpectedHashes
,
637 indexRecords
*MetaIndexParser
,
639 vector
<DiffInfo
> diffs
)
640 : pkgAcqBaseIndex(Owner
, TransactionID
, Target
, ExpectedHashes
, MetaIndexParser
),
641 available_patches(diffs
), ServerSha1(ServerSha1
)
644 DestFile
= _config
->FindDir("Dir::State::lists") + "partial/";
645 DestFile
+= URItoFileName(Target
->URI
);
647 Debug
= _config
->FindB("Debug::pkgAcquire::Diffs",false);
649 RealURI
= Target
->URI
;
651 Description
= Target
->Description
;
652 Desc
.ShortDesc
= Target
->ShortDesc
;
654 if(available_patches
.empty() == true)
656 // we are done (yeah!)
662 State
= StateFetchDiff
;
667 void pkgAcqIndexDiffs::Failed(string Message
,pkgAcquire::MethodConfig
* /*Cnf*/)/*{{{*/
670 std::clog
<< "pkgAcqIndexDiffs failed: " << Desc
.URI
<< " with " << Message
<< std::endl
671 << "Falling back to normal index file acquire" << std::endl
;
672 new pkgAcqIndex(Owner
, TransactionID
, Target
, ExpectedHashes
, MetaIndexParser
);
676 // Finish - helper that cleans the item out of the fetcher queue /*{{{*/
677 void pkgAcqIndexDiffs::Finish(bool allDone
)
679 // we restore the original name, this is required, otherwise
680 // the file will be cleaned
683 DestFile
= _config
->FindDir("Dir::State::lists");
684 DestFile
+= URItoFileName(RealURI
);
686 if(HashSums().usable() && !HashSums().VerifyFile(DestFile
))
688 RenameOnError(HashSumMismatch
);
693 // this is for the "real" finish
698 std::clog
<< "\n\nallDone: " << DestFile
<< "\n" << std::endl
;
703 std::clog
<< "Finishing: " << Desc
.URI
<< std::endl
;
710 bool pkgAcqIndexDiffs::QueueNextDiff() /*{{{*/
713 // calc sha1 of the just patched file
714 string FinalFile
= _config
->FindDir("Dir::State::lists");
715 FinalFile
+= URItoFileName(RealURI
);
717 FileFd
fd(FinalFile
, FileFd::ReadOnly
);
720 string local_sha1
= string(SHA1
.Result());
722 std::clog
<< "QueueNextDiff: "
723 << FinalFile
<< " (" << local_sha1
<< ")"<<std::endl
;
725 // final file reached before all patches are applied
726 if(local_sha1
== ServerSha1
)
732 // remove all patches until the next matching patch is found
733 // this requires the Index file to be ordered
734 for(vector
<DiffInfo
>::iterator I
=available_patches
.begin();
735 available_patches
.empty() == false &&
736 I
!= available_patches
.end() &&
737 I
->sha1
!= local_sha1
;
740 available_patches
.erase(I
);
743 // error checking and falling back if no patch was found
744 if(available_patches
.empty() == true)
750 // queue the right diff
751 Desc
.URI
= RealURI
+ ".diff/" + available_patches
[0].file
+ ".gz";
752 Desc
.Description
= Description
+ " " + available_patches
[0].file
+ string(".pdiff");
753 DestFile
= _config
->FindDir("Dir::State::lists") + "partial/";
754 DestFile
+= URItoFileName(RealURI
+ ".diff/" + available_patches
[0].file
);
757 std::clog
<< "pkgAcqIndexDiffs::QueueNextDiff(): " << Desc
.URI
<< std::endl
;
764 void pkgAcqIndexDiffs::Done(string Message
,unsigned long long Size
, HashStringList
const &Hashes
, /*{{{*/
765 pkgAcquire::MethodConfig
*Cnf
)
768 std::clog
<< "pkgAcqIndexDiffs::Done(): " << Desc
.URI
<< std::endl
;
770 Item::Done(Message
, Size
, Hashes
, Cnf
);
773 FinalFile
= _config
->FindDir("Dir::State::lists")+URItoFileName(RealURI
);
775 // success in downloading a diff, enter ApplyDiff state
776 if(State
== StateFetchDiff
)
779 // rred excepts the patch as $FinalFile.ed
780 Rename(DestFile
,FinalFile
+".ed");
783 std::clog
<< "Sending to rred method: " << FinalFile
<< std::endl
;
785 State
= StateApplyDiff
;
787 Desc
.URI
= "rred:" + FinalFile
;
794 // success in download/apply a diff, queue next (if needed)
795 if(State
== StateApplyDiff
)
797 // remove the just applied patch
798 available_patches
.erase(available_patches
.begin());
799 unlink((FinalFile
+ ".ed").c_str());
804 std::clog
<< "Moving patched file in place: " << std::endl
805 << DestFile
<< " -> " << FinalFile
<< std::endl
;
807 Rename(DestFile
,FinalFile
);
808 chmod(FinalFile
.c_str(),0644);
810 // see if there is more to download
811 if(available_patches
.empty() == false) {
812 new pkgAcqIndexDiffs(Owner
, TransactionID
, Target
,
813 ExpectedHashes
, MetaIndexParser
,
814 ServerSha1
, available_patches
);
821 // AcqIndexMergeDiffs::AcqIndexMergeDiffs - Constructor /*{{{*/
822 pkgAcqIndexMergeDiffs::pkgAcqIndexMergeDiffs(pkgAcquire
*Owner
,
823 unsigned long TransactionID
,
824 struct IndexTarget
const * const Target
,
825 HashStringList
const &ExpectedHashes
,
826 indexRecords
*MetaIndexParser
,
827 DiffInfo
const &patch
,
828 std::vector
<pkgAcqIndexMergeDiffs
*> const * const allPatches
)
829 : pkgAcqBaseIndex(Owner
, TransactionID
, Target
, ExpectedHashes
, MetaIndexParser
),
830 patch(patch
), allPatches(allPatches
), State(StateFetchDiff
)
833 DestFile
= _config
->FindDir("Dir::State::lists") + "partial/";
834 DestFile
+= URItoFileName(Target
->URI
);
836 Debug
= _config
->FindB("Debug::pkgAcquire::Diffs",false);
838 RealURI
= Target
->URI
;
840 Description
= Target
->Description
;
841 Desc
.ShortDesc
= Target
->ShortDesc
;
843 Desc
.URI
= RealURI
+ ".diff/" + patch
.file
+ ".gz";
844 Desc
.Description
= Description
+ " " + patch
.file
+ string(".pdiff");
845 DestFile
= _config
->FindDir("Dir::State::lists") + "partial/";
846 DestFile
+= URItoFileName(RealURI
+ ".diff/" + patch
.file
);
849 std::clog
<< "pkgAcqIndexMergeDiffs: " << Desc
.URI
<< std::endl
;
854 void pkgAcqIndexMergeDiffs::Failed(string Message
,pkgAcquire::MethodConfig
* /*Cnf*/)/*{{{*/
857 std::clog
<< "pkgAcqIndexMergeDiffs failed: " << Desc
.URI
<< " with " << Message
<< std::endl
;
862 // check if we are the first to fail, otherwise we are done here
863 State
= StateDoneDiff
;
864 for (std::vector
<pkgAcqIndexMergeDiffs
*>::const_iterator I
= allPatches
->begin();
865 I
!= allPatches
->end(); ++I
)
866 if ((*I
)->State
== StateErrorDiff
)
869 // first failure means we should fallback
870 State
= StateErrorDiff
;
871 std::clog
<< "Falling back to normal index file acquire" << std::endl
;
872 new pkgAcqIndex(Owner
, TransactionID
, Target
, ExpectedHashes
, MetaIndexParser
);
875 void pkgAcqIndexMergeDiffs::Done(string Message
,unsigned long long Size
,HashStringList
const &Hashes
, /*{{{*/
876 pkgAcquire::MethodConfig
*Cnf
)
879 std::clog
<< "pkgAcqIndexMergeDiffs::Done(): " << Desc
.URI
<< std::endl
;
881 Item::Done(Message
,Size
,Hashes
,Cnf
);
883 string
const FinalFile
= _config
->FindDir("Dir::State::lists") + URItoFileName(RealURI
);
885 if (State
== StateFetchDiff
)
887 // rred expects the patch as $FinalFile.ed.$patchname.gz
888 Rename(DestFile
, FinalFile
+ ".ed." + patch
.file
+ ".gz");
890 // check if this is the last completed diff
891 State
= StateDoneDiff
;
892 for (std::vector
<pkgAcqIndexMergeDiffs
*>::const_iterator I
= allPatches
->begin();
893 I
!= allPatches
->end(); ++I
)
894 if ((*I
)->State
!= StateDoneDiff
)
897 std::clog
<< "Not the last done diff in the batch: " << Desc
.URI
<< std::endl
;
901 // this is the last completed diff, so we are ready to apply now
902 State
= StateApplyDiff
;
905 std::clog
<< "Sending to rred method: " << FinalFile
<< std::endl
;
908 Desc
.URI
= "rred:" + FinalFile
;
913 // success in download/apply all diffs, clean up
914 else if (State
== StateApplyDiff
)
916 // see if we really got the expected file
917 if(ExpectedHashes
.usable() && !ExpectedHashes
.VerifyFile(DestFile
))
919 RenameOnError(HashSumMismatch
);
923 // move the result into place
925 std::clog
<< "Moving patched file in place: " << std::endl
926 << DestFile
<< " -> " << FinalFile
<< std::endl
;
927 Rename(DestFile
, FinalFile
);
928 chmod(FinalFile
.c_str(), 0644);
930 // otherwise lists cleanup will eat the file
931 DestFile
= FinalFile
;
933 // ensure the ed's are gone regardless of list-cleanup
934 for (std::vector
<pkgAcqIndexMergeDiffs
*>::const_iterator I
= allPatches
->begin();
935 I
!= allPatches
->end(); ++I
)
937 std::string patch
= FinalFile
+ ".ed." + (*I
)->patch
.file
+ ".gz";
938 unlink(patch
.c_str());
944 std::clog
<< "allDone: " << DestFile
<< "\n" << std::endl
;
948 // AcqIndex::AcqIndex - Constructor /*{{{*/
949 // ---------------------------------------------------------------------
950 /* The package file is added to the queue and a second class is
951 instantiated to fetch the revision file */
952 pkgAcqIndex::pkgAcqIndex(pkgAcquire
*Owner
,
953 string URI
,string URIDesc
,string ShortDesc
,
954 HashStringList
const &ExpectedHash
, string comprExt
)
955 : pkgAcqBaseIndex(Owner
, 0, NULL
, ExpectedHash
, NULL
), RealURI(URI
)
957 if(comprExt
.empty() == true)
959 // autoselect the compression method
960 std::vector
<std::string
> types
= APT::Configuration::getCompressionTypes();
961 for (std::vector
<std::string
>::const_iterator t
= types
.begin(); t
!= types
.end(); ++t
)
962 comprExt
.append(*t
).append(" ");
963 if (comprExt
.empty() == false)
964 comprExt
.erase(comprExt
.end()-1);
966 CompressionExtension
= comprExt
;
968 Init(URI
, URIDesc
, ShortDesc
);
971 pkgAcqIndex::pkgAcqIndex(pkgAcquire
*Owner
, IndexTarget
const *Target
,
972 HashStringList
const &ExpectedHash
,
973 indexRecords
*MetaIndexParser
)
974 : pkgAcqBaseIndex(Owner
, Target
, ExpectedHash
, MetaIndexParser
),
977 // autoselect the compression method
978 AutoSelectCompression();
979 Init(Target
->URI
, Target
->Description
, Target
->ShortDesc
);
983 pkgAcqIndex::pkgAcqIndex(pkgAcquire
*Owner
,
984 unsigned long TransactionID
,
985 IndexTarget
const *Target
,
986 HashStringList
const &ExpectedHash
,
987 indexRecords
*MetaIndexParser
)
988 : pkgAcqBaseIndex(Owner
, TransactionID
, Target
, ExpectedHash
,
989 MetaIndexParser
), RealURI(Target
->URI
)
991 // autoselect the compression method
992 AutoSelectCompression();
993 Init(Target
->URI
, Target
->Description
, Target
->ShortDesc
);
995 if(_config
->FindB("Debug::Acquire::Transaction", false) == true)
996 std::clog
<< "New pkgIndex with TransactionID "
997 << TransactionID
<< std::endl
;
1000 void pkgAcqIndex::AutoSelectCompression()
1002 std::vector
<std::string
> types
= APT::Configuration::getCompressionTypes();
1003 CompressionExtension
= "";
1004 if (ExpectedHashes
.usable())
1006 for (std::vector
<std::string
>::const_iterator t
= types
.begin(); t
!= types
.end(); ++t
)
1007 if (*t
== "uncompressed" || MetaIndexParser
->Exists(string(Target
->MetaKey
).append(".").append(*t
)) == true)
1008 CompressionExtension
.append(*t
).append(" ");
1012 for (std::vector
<std::string
>::const_iterator t
= types
.begin(); t
!= types
.end(); ++t
)
1013 CompressionExtension
.append(*t
).append(" ");
1015 if (CompressionExtension
.empty() == false)
1016 CompressionExtension
.erase(CompressionExtension
.end()-1);
1018 // AcqIndex::Init - defered Constructor /*{{{*/
1019 void pkgAcqIndex::Init(string
const &URI
, string
const &URIDesc
, string
const &ShortDesc
) {
1020 Decompression
= false;
1023 DestFile
= _config
->FindDir("Dir::State::lists") + "partial/";
1024 DestFile
+= URItoFileName(URI
);
1026 std::string
const comprExt
= CompressionExtension
.substr(0, CompressionExtension
.find(' '));
1027 std::string MetaKey
;
1028 if (comprExt
== "uncompressed")
1032 MetaKey
= string(Target
->MetaKey
);
1036 Desc
.URI
= URI
+ '.' + comprExt
;
1038 MetaKey
= string(Target
->MetaKey
) + '.' + comprExt
;
1041 // load the filesize
1044 indexRecords::checkSum
*Record
= MetaIndexParser
->Lookup(MetaKey
);
1046 FileSize
= Record
->Size
;
1048 InitByHashIfNeeded(MetaKey
);
1051 Desc
.Description
= URIDesc
;
1053 Desc
.ShortDesc
= ShortDesc
;
1058 // AcqIndex::AdjustForByHash - modify URI for by-hash support /*{{{*/
1059 // ---------------------------------------------------------------------
1061 void pkgAcqIndex::InitByHashIfNeeded(const std::string MetaKey
)
1064 // - (maybe?) add support for by-hash into the sources.list as flag
1065 // - make apt-ftparchive generate the hashes (and expire?)
1066 std::string HostKnob
= "APT::Acquire::" + ::URI(Desc
.URI
).Host
+ "::By-Hash";
1067 if(_config
->FindB("APT::Acquire::By-Hash", false) == true ||
1068 _config
->FindB(HostKnob
, false) == true ||
1069 MetaIndexParser
->GetSupportsAcquireByHash())
1071 indexRecords::checkSum
*Record
= MetaIndexParser
->Lookup(MetaKey
);
1074 // FIXME: should we really use the best hash here? or a fixed one?
1075 const HashString
*TargetHash
= Record
->Hashes
.find("");
1076 std::string ByHash
= "/by-hash/" + TargetHash
->HashType() + "/" + TargetHash
->HashValue();
1077 size_t trailing_slash
= Desc
.URI
.find_last_of("/");
1078 Desc
.URI
= Desc
.URI
.replace(
1080 Desc
.URI
.substr(trailing_slash
+1).size()+1,
1084 "Fetching ByHash requested but can not find record for %s",
1090 // AcqIndex::Custom600Headers - Insert custom request headers /*{{{*/
1091 // ---------------------------------------------------------------------
1092 /* The only header we use is the last-modified header. */
1093 string
pkgAcqIndex::Custom600Headers() const
1095 string Final
= _config
->FindDir("Dir::State::lists");
1096 Final
+= URItoFileName(RealURI
);
1097 if (_config
->FindB("Acquire::GzipIndexes",false))
1100 string msg
= "\nIndex-File: true";
1101 // FIXME: this really should use "IndexTarget::IsOptional()" but that
1102 // seems to be difficult without breaking ABI
1103 if (ShortDesc().find("Translation") != 0)
1104 msg
+= "\nFail-Ignore: true";
1106 if (stat(Final
.c_str(),&Buf
) == 0)
1107 msg
+= "\nLast-Modified: " + TimeRFC1123(Buf
.st_mtime
);
1112 void pkgAcqIndex::Failed(string Message
,pkgAcquire::MethodConfig
*Cnf
) /*{{{*/
1114 size_t const nextExt
= CompressionExtension
.find(' ');
1115 if (nextExt
!= std::string::npos
)
1117 CompressionExtension
= CompressionExtension
.substr(nextExt
+1);
1118 Init(RealURI
, Desc
.Description
, Desc
.ShortDesc
);
1122 // on decompression failure, remove bad versions in partial/
1123 if (Decompression
&& Erase
) {
1124 string s
= _config
->FindDir("Dir::State::lists") + "partial/";
1125 s
.append(URItoFileName(RealURI
));
1129 Item::Failed(Message
,Cnf
);
1131 /// cancel the entire transaction
1132 Owner
->AbortTransaction(TransactionID
);
1135 // AcqIndex::Done - Finished a fetch /*{{{*/
1136 // ---------------------------------------------------------------------
1137 /* This goes through a number of states.. On the initial fetch the
1138 method could possibly return an alternate filename which points
1139 to the uncompressed version of the file. If this is so the file
1140 is copied into the partial directory. In all other cases the file
1141 is decompressed with a gzip uri. */
1142 void pkgAcqIndex::Done(string Message
,unsigned long long Size
,HashStringList
const &Hashes
,
1143 pkgAcquire::MethodConfig
*Cfg
)
1145 Item::Done(Message
,Size
,Hashes
,Cfg
);
1147 if (Decompression
== true)
1149 if (ExpectedHashes
.usable() && ExpectedHashes
!= Hashes
)
1151 RenameOnError(HashSumMismatch
);
1152 printHashSumComparision(RealURI
, ExpectedHashes
, Hashes
);
1153 Failed(Message
, Cfg
);
1157 // FIXME: this can go away once we only ever download stuff that
1158 // has a valid hash and we never do GET based probing
1160 /* Always verify the index file for correctness (all indexes must
1161 * have a Package field) (LP: #346386) (Closes: #627642)
1163 FileFd
fd(DestFile
, FileFd::ReadOnly
);
1164 // Only test for correctness if the file is not empty (empty is ok)
1165 if (fd
.FileSize() > 0)
1168 pkgTagFile
tag(&fd
);
1170 // all our current indexes have a field 'Package' in each section
1171 if (_error
->PendingError() == true || tag
.Step(sec
) == false || sec
.Exists("Package") == false)
1173 RenameOnError(InvalidFormat
);
1174 Failed(Message
, Cfg
);
1179 // Done, queue for rename on transaction finished
1180 PartialFile
= DestFile
;
1182 string FinalFile
= _config
->FindDir("Dir::State::lists");
1183 FinalFile
+= URItoFileName(RealURI
);
1184 DestFile
= FinalFile
;
1186 /* We restore the original name to DestFile so that the clean operation
1188 DestFile
= _config
->FindDir("Dir::State::lists") + "partial/";
1189 DestFile
+= URItoFileName(RealURI
);
1191 // Remove the compressed version.
1193 unlink(DestFile
.c_str());
1201 // Handle the unzipd case
1202 string FileName
= LookupTag(Message
,"Alt-Filename");
1203 if (FileName
.empty() == false)
1205 // The files timestamp matches
1206 if (StringToBool(LookupTag(Message
,"Alt-IMS-Hit"),false) == true)
1208 Decompression
= true;
1210 DestFile
+= ".decomp";
1211 Desc
.URI
= "copy:" + FileName
;
1217 FileName
= LookupTag(Message
,"Filename");
1218 if (FileName
.empty() == true)
1221 ErrorText
= "Method gave a blank filename";
1224 std::string
const compExt
= CompressionExtension
.substr(0, CompressionExtension
.find(' '));
1226 // The files timestamp matches
1227 if (StringToBool(LookupTag(Message
,"IMS-Hit"),false) == true) {
1228 if (_config
->FindB("Acquire::GzipIndexes",false) && compExt
== "gz")
1229 // Update DestFile for .gz suffix so that the clean operation keeps it
1234 if (FileName
== DestFile
)
1241 // If we enable compressed indexes and already have gzip, keep it
1242 if (_config
->FindB("Acquire::GzipIndexes",false) && compExt
== "gz" && !Local
) {
1243 string FinalFile
= _config
->FindDir("Dir::State::lists");
1244 FinalFile
+= URItoFileName(RealURI
) + ".gz";
1245 Rename(DestFile
,FinalFile
);
1246 chmod(FinalFile
.c_str(),0644);
1248 // Update DestFile for .gz suffix so that the clean operation keeps it
1249 DestFile
= _config
->FindDir("Dir::State::lists") + "partial/";
1250 DestFile
+= URItoFileName(RealURI
) + ".gz";
1254 // get the binary name for your used compression type
1255 decompProg
= _config
->Find(string("Acquire::CompressionTypes::").append(compExt
),"");
1256 if(decompProg
.empty() == false);
1257 else if(compExt
== "uncompressed")
1258 decompProg
= "copy";
1260 _error
->Error("Unsupported extension: %s", compExt
.c_str());
1264 Decompression
= true;
1265 DestFile
+= ".decomp";
1266 Desc
.URI
= decompProg
+ ":" + FileName
;
1269 // FIXME: this points to a c++ string that goes out of scope
1270 Mode
= decompProg
.c_str();
1273 // AcqIndexTrans::pkgAcqIndexTrans - Constructor /*{{{*/
1274 // ---------------------------------------------------------------------
1275 /* The Translation file is added to the queue */
1276 pkgAcqIndexTrans::pkgAcqIndexTrans(pkgAcquire
*Owner
,
1277 string URI
,string URIDesc
,string ShortDesc
)
1278 : pkgAcqIndex(Owner
, URI
, URIDesc
, ShortDesc
, HashStringList(), "")
1282 pkgAcqIndexTrans::pkgAcqIndexTrans(pkgAcquire
*Owner
,
1283 unsigned long TransactionID
,
1284 IndexTarget
const * const Target
,
1285 HashStringList
const &ExpectedHashes
,
1286 indexRecords
*MetaIndexParser
)
1287 : pkgAcqIndex(Owner
, TransactionID
, Target
, ExpectedHashes
, MetaIndexParser
)
1289 // load the filesize
1290 indexRecords::checkSum
*Record
= MetaIndexParser
->Lookup(string(Target
->MetaKey
));
1292 FileSize
= Record
->Size
;
1295 // AcqIndexTrans::Custom600Headers - Insert custom request headers /*{{{*/
1296 // ---------------------------------------------------------------------
1297 string
pkgAcqIndexTrans::Custom600Headers() const
1299 string Final
= _config
->FindDir("Dir::State::lists");
1300 Final
+= URItoFileName(RealURI
);
1303 if (stat(Final
.c_str(),&Buf
) != 0)
1304 return "\nFail-Ignore: true\nIndex-File: true";
1305 return "\nFail-Ignore: true\nIndex-File: true\nLast-Modified: " + TimeRFC1123(Buf
.st_mtime
);
1308 // AcqIndexTrans::Failed - Silence failure messages for missing files /*{{{*/
1309 // ---------------------------------------------------------------------
1311 void pkgAcqIndexTrans::Failed(string Message
,pkgAcquire::MethodConfig
*Cnf
)
1313 size_t const nextExt
= CompressionExtension
.find(' ');
1314 if (nextExt
!= std::string::npos
)
1316 CompressionExtension
= CompressionExtension
.substr(nextExt
+1);
1317 Init(RealURI
, Desc
.Description
, Desc
.ShortDesc
);
1322 // FIXME: this is used often (e.g. in pkgAcqIndexTrans) so refactor
1323 if (Cnf
->LocalOnly
== true ||
1324 StringToBool(LookupTag(Message
,"Transient-Failure"),false) == false)
1333 Item::Failed(Message
,Cnf
);
1336 pkgAcqMetaSig::pkgAcqMetaSig(pkgAcquire
*Owner
, /*{{{*/
1337 unsigned long TransactionID
,
1338 string URI
,string URIDesc
,string ShortDesc
,
1339 string MetaIndexFile
,
1340 const vector
<IndexTarget
*>* IndexTargets
,
1341 indexRecords
* MetaIndexParser
) :
1342 Item(Owner
, HashStringList(), TransactionID
), RealURI(URI
),
1343 MetaIndexParser(MetaIndexParser
), MetaIndexFile(MetaIndexFile
),
1344 IndexTargets(IndexTargets
), AuthPass(false), IMSHit(false)
1346 DestFile
= _config
->FindDir("Dir::State::lists") + "partial/";
1347 DestFile
+= URItoFileName(URI
);
1349 // remove any partial downloaded sig-file in partial/.
1350 // it may confuse proxies and is too small to warrant a
1351 // partial download anyway
1352 unlink(DestFile
.c_str());
1354 // set the TransactionID
1355 if(_config
->FindB("Debug::Acquire::Transaction", false) == true)
1356 std::clog
<< "New pkgAcqMetaSig with TransactionID "
1357 << TransactionID
<< std::endl
;
1360 Desc
.Description
= URIDesc
;
1362 Desc
.ShortDesc
= ShortDesc
;
1368 pkgAcqMetaSig::~pkgAcqMetaSig() /*{{{*/
1372 // pkgAcqMetaSig::Custom600Headers - Insert custom request headers /*{{{*/
1373 // ---------------------------------------------------------------------
1374 /* The only header we use is the last-modified header. */
1375 string
pkgAcqMetaSig::Custom600Headers() const
1377 string FinalFile
= _config
->FindDir("Dir::State::lists");
1378 FinalFile
+= URItoFileName(RealURI
);
1381 if (stat(FinalFile
.c_str(),&Buf
) != 0)
1382 return "\nIndex-File: true";
1384 return "\nIndex-File: true\nLast-Modified: " + TimeRFC1123(Buf
.st_mtime
);
1387 void pkgAcqMetaSig::Done(string Message
,unsigned long long Size
, HashStringList
const &Hashes
,
1388 pkgAcquire::MethodConfig
*Cfg
)
1390 Item::Done(Message
, Size
, Hashes
, Cfg
);
1392 string FileName
= LookupTag(Message
,"Filename");
1393 if (FileName
.empty() == true)
1396 ErrorText
= "Method gave a blank filename";
1400 if (FileName
!= DestFile
)
1402 // We have to copy it into place
1404 Desc
.URI
= "copy:" + FileName
;
1409 if(StringToBool(LookupTag(Message
,"IMS-Hit"),false) == true)
1412 // adjust paths if its a ims-hit
1415 string FinalFile
= _config
->FindDir("Dir::State::lists");
1416 FinalFile
+= URItoFileName(RealURI
);
1418 DestFile
= PartialFile
= FinalFile
;
1422 if(AuthPass
== false)
1425 Desc
.URI
= "gpgv:" + DestFile
;
1426 DestFile
= MetaIndexFile
;
1431 // queue to copy the file in place if it was not a ims hit, on ims
1432 // hit the file is already at the right place
1435 PartialFile
= _config
->FindDir("Dir::State::lists") + "partial/";
1436 PartialFile
+= URItoFileName(RealURI
);
1438 DestFile
= _config
->FindDir("Dir::State::lists");
1439 DestFile
+= URItoFileName(RealURI
);
1446 void pkgAcqMetaSig::Failed(string Message
,pkgAcquire::MethodConfig
*Cnf
)/*{{{*/
1448 string Final
= _config
->FindDir("Dir::State::lists") + URItoFileName(RealURI
);
1450 // this ensures that any file in the lists/ dir is removed by the
1452 DestFile
= _config
->FindDir("Dir::State::lists") + "partial/";
1453 DestFile
+= URItoFileName(RealURI
);
1456 // FIXME: this is used often (e.g. in pkgAcqIndexTrans) so refactor
1457 if (Cnf
->LocalOnly
== true ||
1458 StringToBool(LookupTag(Message
,"Transient-Failure"),false) == false)
1466 Item::Failed(Message
,Cnf
);
1469 pkgAcqMetaIndex::pkgAcqMetaIndex(pkgAcquire
*Owner
, /*{{{*/
1470 unsigned long TransactionID
,
1471 string URI
,string URIDesc
,string ShortDesc
,
1472 string MetaIndexSigURI
,string MetaIndexSigURIDesc
, string MetaIndexSigShortDesc
,
1473 const vector
<IndexTarget
*>* IndexTargets
,
1474 indexRecords
* MetaIndexParser
) :
1475 Item(Owner
, HashStringList(), TransactionID
), RealURI(URI
), IndexTargets(IndexTargets
),
1476 MetaIndexParser(MetaIndexParser
), AuthPass(false), IMSHit(false),
1477 MetaIndexSigURI(MetaIndexSigURI
), MetaIndexSigURIDesc(MetaIndexSigURIDesc
),
1478 MetaIndexSigShortDesc(MetaIndexSigShortDesc
)
1480 if(TransactionID
== 0)
1481 this->TransactionID
= (unsigned long)this;
1483 if(_config
->FindB("Debug::Acquire::Transaction", false) == true)
1484 std::clog
<< "New pkgAcqMetaIndex with TransactionID "
1485 << TransactionID
<< std::endl
;
1487 Init(URIDesc
, ShortDesc
);
1490 // pkgAcqMetaIndex::Init - Delayed constructor /*{{{*/
1491 void pkgAcqMetaIndex::Init(std::string URIDesc
, std::string ShortDesc
)
1493 DestFile
= _config
->FindDir("Dir::State::lists") + "partial/";
1494 DestFile
+= URItoFileName(RealURI
);
1497 Desc
.Description
= URIDesc
;
1499 Desc
.ShortDesc
= ShortDesc
;
1502 // we expect more item
1503 ExpectedAdditionalItems
= IndexTargets
->size();
1506 // pkgAcqMetaIndex::Custom600Headers - Insert custom request headers /*{{{*/
1507 // ---------------------------------------------------------------------
1508 /* The only header we use is the last-modified header. */
1509 string
pkgAcqMetaIndex::Custom600Headers() const
1511 string Final
= _config
->FindDir("Dir::State::lists");
1512 Final
+= URItoFileName(RealURI
);
1515 if (stat(Final
.c_str(),&Buf
) != 0)
1516 return "\nIndex-File: true";
1518 return "\nIndex-File: true\nLast-Modified: " + TimeRFC1123(Buf
.st_mtime
);
1521 void pkgAcqMetaIndex::Done(string Message
,unsigned long long Size
,HashStringList
const &Hashes
, /*{{{*/
1522 pkgAcquire::MethodConfig
*Cfg
)
1524 Item::Done(Message
,Size
,Hashes
,Cfg
);
1526 // MetaIndexes are done in two passes: one to download the
1527 // metaindex with an appropriate method, and a second to verify it
1528 // with the gpgv method
1530 if (AuthPass
== true)
1534 // all cool, move Release file into place
1539 RetrievalDone(Message
);
1541 // Still more retrieving to do
1546 // load indexes, the signature will downloaded afterwards
1547 MetaIndexParser
->Load(DestFile
);
1552 // FIXME: move this into pkgAcqMetaClearSig::Done on the next
1555 // if we expect a ClearTextSignature (InRelase), ensure that
1556 // this is what we get and if not fail to queue a
1557 // Release/Release.gpg, see #346386
1558 if (SigFile
== DestFile
&& !StartsWithGPGClearTextSignature(DestFile
))
1560 Failed(Message
, Cfg
);
1564 // There was a signature file, so pass it to gpgv for
1566 if (_config
->FindB("Debug::pkgAcquire::Auth", false))
1567 std::cerr
<< "Metaindex acquired, queueing gpg verification ("
1568 << SigFile
<< "," << DestFile
<< ")\n";
1570 Desc
.URI
= "gpgv:" + SigFile
;
1577 if (Complete
== true)
1579 string FinalFile
= _config
->FindDir("Dir::State::lists");
1580 FinalFile
+= URItoFileName(RealURI
);
1581 if (SigFile
== DestFile
)
1582 SigFile
= FinalFile
;
1583 // queue for copy in place
1584 PartialFile
= DestFile
;
1585 DestFile
= FinalFile
;
1589 void pkgAcqMetaIndex::RetrievalDone(string Message
) /*{{{*/
1591 // We have just finished downloading a Release file (it is not
1594 string FileName
= LookupTag(Message
,"Filename");
1595 if (FileName
.empty() == true)
1598 ErrorText
= "Method gave a blank filename";
1602 if (FileName
!= DestFile
)
1605 Desc
.URI
= "copy:" + FileName
;
1610 // make sure to verify against the right file on I-M-S hit
1611 IMSHit
= StringToBool(LookupTag(Message
,"IMS-Hit"),false);
1614 string FinalFile
= _config
->FindDir("Dir::State::lists");
1615 FinalFile
+= URItoFileName(RealURI
);
1616 if (SigFile
== DestFile
)
1618 SigFile
= FinalFile
;
1619 // constructor of pkgAcqMetaClearSig moved it out of the way,
1620 // now move it back in on IMS hit for the 'old' file
1621 string
const OldClearSig
= DestFile
+ ".reverify";
1622 if (RealFileExists(OldClearSig
) == true)
1623 Rename(OldClearSig
, FinalFile
);
1625 DestFile
= FinalFile
;
1628 // queue a signature
1629 if(SigFile
!= DestFile
)
1630 new pkgAcqMetaSig(Owner
, TransactionID
,
1631 MetaIndexSigURI
, MetaIndexSigURIDesc
,
1632 MetaIndexSigShortDesc
, DestFile
, IndexTargets
,
1638 void pkgAcqMetaIndex::AuthDone(string Message
) /*{{{*/
1640 // At this point, the gpgv method has succeeded, so there is a
1641 // valid signature from a key in the trusted keyring. We
1642 // perform additional verification of its contents, and use them
1643 // to verify the indexes we are about to download
1645 if (!MetaIndexParser
->Load(DestFile
))
1647 Status
= StatAuthError
;
1648 ErrorText
= MetaIndexParser
->ErrorText
;
1652 if (!VerifyVendor(Message
))
1657 if (_config
->FindB("Debug::pkgAcquire::Auth", false))
1658 std::cerr
<< "Signature verification succeeded: "
1659 << DestFile
<< std::endl
;
1661 // Download further indexes with verification
1665 // is it a clearsigned MetaIndex file?
1666 if (DestFile
== SigFile
)
1669 // Done, move signature file into position
1670 string VerifiedSigFile
= _config
->FindDir("Dir::State::lists") +
1671 URItoFileName(RealURI
) + ".gpg";
1672 Rename(SigFile
,VerifiedSigFile
);
1673 chmod(VerifiedSigFile
.c_str(),0644);
1677 void pkgAcqMetaIndex::QueueIndexes(bool verify
) /*{{{*/
1679 bool transInRelease
= false;
1681 std::vector
<std::string
> const keys
= MetaIndexParser
->MetaKeys();
1682 for (std::vector
<std::string
>::const_iterator k
= keys
.begin(); k
!= keys
.end(); ++k
)
1683 // FIXME: Feels wrong to check for hardcoded string here, but what should we do else…
1684 if (k
->find("Translation-") != std::string::npos
)
1686 transInRelease
= true;
1691 // at this point the real Items are loaded in the fetcher
1692 ExpectedAdditionalItems
= 0;
1693 for (vector
<IndexTarget
*>::const_iterator Target
= IndexTargets
->begin();
1694 Target
!= IndexTargets
->end();
1697 HashStringList ExpectedIndexHashes
;
1698 const indexRecords::checkSum
*Record
= MetaIndexParser
->Lookup((*Target
)->MetaKey
);
1699 bool compressedAvailable
= false;
1702 if ((*Target
)->IsOptional() == true)
1704 std::vector
<std::string
> types
= APT::Configuration::getCompressionTypes();
1705 for (std::vector
<std::string
>::const_iterator t
= types
.begin(); t
!= types
.end(); ++t
)
1706 if (MetaIndexParser
->Exists((*Target
)->MetaKey
+ "." + *t
) == true)
1708 compressedAvailable
= true;
1712 else if (verify
== true)
1714 Status
= StatAuthError
;
1715 strprintf(ErrorText
, _("Unable to find expected entry '%s' in Release file (Wrong sources.list entry or malformed file)"), (*Target
)->MetaKey
.c_str());
1721 ExpectedIndexHashes
= Record
->Hashes
;
1722 if (_config
->FindB("Debug::pkgAcquire::Auth", false))
1724 std::cerr
<< "Queueing: " << (*Target
)->URI
<< std::endl
1725 << "Expected Hash:" << std::endl
;
1726 for (HashStringList::const_iterator hs
= ExpectedIndexHashes
.begin(); hs
!= ExpectedIndexHashes
.end(); ++hs
)
1727 std::cerr
<< "\t- " << hs
->toStr() << std::endl
;
1728 std::cerr
<< "For: " << Record
->MetaKeyFilename
<< std::endl
;
1730 if (verify
== true && ExpectedIndexHashes
.empty() == true && (*Target
)->IsOptional() == false)
1732 Status
= StatAuthError
;
1733 strprintf(ErrorText
, _("Unable to find hash sum for '%s' in Release file"), (*Target
)->MetaKey
.c_str());
1738 if ((*Target
)->IsOptional() == true)
1740 if ((*Target
)->IsSubIndex() == true)
1741 new pkgAcqSubIndex(Owner
, TransactionID
,
1742 (*Target
)->URI
, (*Target
)->Description
,
1743 (*Target
)->ShortDesc
, ExpectedIndexHashes
);
1744 else if (transInRelease
== false || Record
!= NULL
|| compressedAvailable
== true)
1746 if (_config
->FindB("Acquire::PDiffs",true) == true && transInRelease
== true &&
1747 MetaIndexParser
->Exists((*Target
)->MetaKey
+ ".diff/Index") == true)
1748 new pkgAcqDiffIndex(Owner
, TransactionID
, *Target
, ExpectedIndexHashes
, MetaIndexParser
);
1750 new pkgAcqIndexTrans(Owner
, TransactionID
, *Target
, ExpectedIndexHashes
, MetaIndexParser
);
1755 /* Queue Packages file (either diff or full packages files, depending
1756 on the users option) - we also check if the PDiff Index file is listed
1757 in the Meta-Index file. Ideal would be if pkgAcqDiffIndex would test this
1758 instead, but passing the required info to it is to much hassle */
1759 if(_config
->FindB("Acquire::PDiffs",true) == true && (verify
== false ||
1760 MetaIndexParser
->Exists((*Target
)->MetaKey
+ ".diff/Index") == true))
1761 new pkgAcqDiffIndex(Owner
, TransactionID
, *Target
, ExpectedIndexHashes
, MetaIndexParser
);
1763 new pkgAcqIndex(Owner
, TransactionID
, *Target
, ExpectedIndexHashes
, MetaIndexParser
);
1767 bool pkgAcqMetaIndex::VerifyVendor(string Message
) /*{{{*/
1769 string::size_type pos
;
1771 // check for missing sigs (that where not fatal because otherwise we had
1774 string msg
= _("There is no public key available for the "
1775 "following key IDs:\n");
1776 pos
= Message
.find("NO_PUBKEY ");
1777 if (pos
!= std::string::npos
)
1779 string::size_type start
= pos
+strlen("NO_PUBKEY ");
1780 string Fingerprint
= Message
.substr(start
, Message
.find("\n")-start
);
1781 missingkeys
+= (Fingerprint
);
1783 if(!missingkeys
.empty())
1784 _error
->Warning("%s", (msg
+ missingkeys
).c_str());
1786 string Transformed
= MetaIndexParser
->GetExpectedDist();
1788 if (Transformed
== "../project/experimental")
1790 Transformed
= "experimental";
1793 pos
= Transformed
.rfind('/');
1794 if (pos
!= string::npos
)
1796 Transformed
= Transformed
.substr(0, pos
);
1799 if (Transformed
== ".")
1804 if (_config
->FindB("Acquire::Check-Valid-Until", true) == true &&
1805 MetaIndexParser
->GetValidUntil() > 0) {
1806 time_t const invalid_since
= time(NULL
) - MetaIndexParser
->GetValidUntil();
1807 if (invalid_since
> 0)
1808 // TRANSLATOR: The first %s is the URL of the bad Release file, the second is
1809 // the time since then the file is invalid - formated in the same way as in
1810 // the download progress display (e.g. 7d 3h 42min 1s)
1811 return _error
->Error(
1812 _("Release file for %s is expired (invalid since %s). "
1813 "Updates for this repository will not be applied."),
1814 RealURI
.c_str(), TimeToStr(invalid_since
).c_str());
1817 if (_config
->FindB("Debug::pkgAcquire::Auth", false))
1819 std::cerr
<< "Got Codename: " << MetaIndexParser
->GetDist() << std::endl
;
1820 std::cerr
<< "Expecting Dist: " << MetaIndexParser
->GetExpectedDist() << std::endl
;
1821 std::cerr
<< "Transformed Dist: " << Transformed
<< std::endl
;
1824 if (MetaIndexParser
->CheckDist(Transformed
) == false)
1826 // This might become fatal one day
1827 // Status = StatAuthError;
1828 // ErrorText = "Conflicting distribution; expected "
1829 // + MetaIndexParser->GetExpectedDist() + " but got "
1830 // + MetaIndexParser->GetDist();
1832 if (!Transformed
.empty())
1834 _error
->Warning(_("Conflicting distribution: %s (expected %s but got %s)"),
1835 Desc
.Description
.c_str(),
1836 Transformed
.c_str(),
1837 MetaIndexParser
->GetDist().c_str());
1844 // pkgAcqMetaIndex::Failed - no Release file present or no signature file present /*{{{*/
1845 // ---------------------------------------------------------------------
1847 void pkgAcqMetaIndex::Failed(string
/*Message*/,
1848 pkgAcquire::MethodConfig
* /*Cnf*/)
1851 if (AuthPass
== true)
1853 // gpgv method failed, if we have a good signature
1854 string LastGoodSigFile
= _config
->FindDir("Dir::State::lists").append("partial/").append(URItoFileName(RealURI
));
1855 if (DestFile
!= SigFile
)
1856 LastGoodSigFile
.append(".gpg");
1857 LastGoodSigFile
.append(".reverify");
1859 if(FileExists(LastGoodSigFile
))
1861 string VerifiedSigFile
= _config
->FindDir("Dir::State::lists") + URItoFileName(RealURI
);
1862 if (DestFile
!= SigFile
)
1863 VerifiedSigFile
.append(".gpg");
1864 Rename(LastGoodSigFile
, VerifiedSigFile
);
1865 Status
= StatTransientNetworkError
;
1866 _error
->Warning(_("An error occurred during the signature "
1867 "verification. The repository is not updated "
1868 "and the previous index files will be used. "
1869 "GPG error: %s: %s\n"),
1870 Desc
.Description
.c_str(),
1871 LookupTag(Message
,"Message").c_str());
1872 RunScripts("APT::Update::Auth-Failure");
1874 } else if (LookupTag(Message
,"Message").find("NODATA") != string::npos
) {
1875 /* Invalid signature file, reject (LP: #346386) (Closes: #627642) */
1876 _error
->Error(_("GPG error: %s: %s"),
1877 Desc
.Description
.c_str(),
1878 LookupTag(Message
,"Message").c_str());
1881 _error
->Warning(_("GPG error: %s: %s"),
1882 Desc
.Description
.c_str(),
1883 LookupTag(Message
,"Message").c_str());
1885 // gpgv method failed
1886 ReportMirrorFailure("GPGFailure");
1889 /* Always move the meta index, even if gpgv failed. This ensures
1890 * that PackageFile objects are correctly filled in */
1891 if (FileExists(DestFile
)) {
1892 string FinalFile
= _config
->FindDir("Dir::State::lists");
1893 FinalFile
+= URItoFileName(RealURI
);
1894 /* InRelease files become Release files, otherwise
1895 * they would be considered as trusted later on */
1896 if (SigFile
== DestFile
) {
1897 RealURI
= RealURI
.replace(RealURI
.rfind("InRelease"), 9,
1899 FinalFile
= FinalFile
.replace(FinalFile
.rfind("InRelease"), 9,
1901 SigFile
= FinalFile
;
1903 Rename(DestFile
,FinalFile
);
1904 chmod(FinalFile
.c_str(),0644);
1906 DestFile
= FinalFile
;
1909 // No Release file was present, or verification failed, so fall
1910 // back to queueing Packages files without verification
1911 QueueIndexes(false);
1915 void pkgAcqMetaIndex::Finished()
1917 if(_config
->FindB("Debug::Acquire::Transaction", false) == true)
1918 std::clog
<< "Finished: " << DestFile
<<std::endl
;
1919 if(Owner
->TransactionHasError(TransactionID
) == false &&
1921 Owner
->CommitTransaction(TransactionID
);
1925 pkgAcqMetaClearSig::pkgAcqMetaClearSig(pkgAcquire
*Owner
, /*{{{*/
1926 string
const &URI
, string
const &URIDesc
, string
const &ShortDesc
,
1927 string
const &MetaIndexURI
, string
const &MetaIndexURIDesc
, string
const &MetaIndexShortDesc
,
1928 string
const &MetaSigURI
, string
const &MetaSigURIDesc
, string
const &MetaSigShortDesc
,
1929 const vector
<IndexTarget
*>* IndexTargets
,
1930 indexRecords
* MetaIndexParser
) :
1931 pkgAcqMetaIndex(Owner
, (unsigned long)this, URI
, URIDesc
, ShortDesc
, MetaSigURI
, MetaSigURIDesc
,MetaSigShortDesc
, IndexTargets
, MetaIndexParser
),
1932 MetaIndexURI(MetaIndexURI
), MetaIndexURIDesc(MetaIndexURIDesc
), MetaIndexShortDesc(MetaIndexShortDesc
),
1933 MetaSigURI(MetaSigURI
), MetaSigURIDesc(MetaSigURIDesc
), MetaSigShortDesc(MetaSigShortDesc
)
1937 // index targets + (worst case:) Release/Release.gpg
1938 ExpectedAdditionalItems
= IndexTargets
->size() + 2;
1940 // keep the old InRelease around in case of transistent network errors
1941 string
const Final
= _config
->FindDir("Dir::State::lists") + URItoFileName(RealURI
);
1942 if (RealFileExists(Final
) == true)
1944 string
const LastGoodSig
= DestFile
+ ".reverify";
1945 Rename(Final
,LastGoodSig
);
1949 pkgAcqMetaClearSig::~pkgAcqMetaClearSig() /*{{{*/
1951 // if the file was never queued undo file-changes done in the constructor
1952 if (QueueCounter
== 1 && Status
== StatIdle
&& FileSize
== 0 && Complete
== false)
1954 string
const Final
= _config
->FindDir("Dir::State::lists") + URItoFileName(RealURI
);
1955 string
const LastGoodSig
= DestFile
+ ".reverify";
1956 if (RealFileExists(Final
) == false && RealFileExists(LastGoodSig
) == true)
1957 Rename(LastGoodSig
, Final
);
1961 // pkgAcqMetaClearSig::Custom600Headers - Insert custom request headers /*{{{*/
1962 // ---------------------------------------------------------------------
1963 // FIXME: this can go away once the InRelease file is used widely
1964 string
pkgAcqMetaClearSig::Custom600Headers() const
1966 string Final
= _config
->FindDir("Dir::State::lists");
1967 Final
+= URItoFileName(RealURI
);
1970 if (stat(Final
.c_str(),&Buf
) != 0)
1972 Final
= DestFile
+ ".reverify";
1973 if (stat(Final
.c_str(),&Buf
) != 0)
1974 return "\nIndex-File: true\nFail-Ignore: true\n";
1977 return "\nIndex-File: true\nFail-Ignore: true\nLast-Modified: " + TimeRFC1123(Buf
.st_mtime
);
1980 void pkgAcqMetaClearSig::Failed(string Message
,pkgAcquire::MethodConfig
*Cnf
) /*{{{*/
1982 // we failed, we will not get additional items from this method
1983 ExpectedAdditionalItems
= 0;
1985 if (AuthPass
== false)
1987 // Remove the 'old' InRelease file if we try Release.gpg now as otherwise
1988 // the file will stay around and gives a false-auth impression (CVE-2012-0214)
1989 string FinalFile
= _config
->FindDir("Dir::State::lists");
1990 FinalFile
.append(URItoFileName(RealURI
));
1991 if (FileExists(FinalFile
))
1992 unlink(FinalFile
.c_str());
1994 new pkgAcqMetaIndex(Owner
, TransactionID
,
1995 MetaIndexURI
, MetaIndexURIDesc
, MetaIndexShortDesc
,
1996 MetaSigURI
, MetaSigURIDesc
, MetaSigShortDesc
,
1997 IndexTargets
, MetaIndexParser
);
1998 if (Cnf
->LocalOnly
== true ||
1999 StringToBool(LookupTag(Message
, "Transient-Failure"), false) == false)
2003 pkgAcqMetaIndex::Failed(Message
, Cnf
);
2006 // AcqArchive::AcqArchive - Constructor /*{{{*/
2007 // ---------------------------------------------------------------------
2008 /* This just sets up the initial fetch environment and queues the first
2010 pkgAcqArchive::pkgAcqArchive(pkgAcquire
*Owner
,pkgSourceList
*Sources
,
2011 pkgRecords
*Recs
,pkgCache::VerIterator
const &Version
,
2012 string
&StoreFilename
) :
2013 Item(Owner
, HashStringList()), Version(Version
), Sources(Sources
), Recs(Recs
),
2014 StoreFilename(StoreFilename
), Vf(Version
.FileList()),
2017 Retries
= _config
->FindI("Acquire::Retries",0);
2019 if (Version
.Arch() == 0)
2021 _error
->Error(_("I wasn't able to locate a file for the %s package. "
2022 "This might mean you need to manually fix this package. "
2023 "(due to missing arch)"),
2024 Version
.ParentPkg().FullName().c_str());
2028 /* We need to find a filename to determine the extension. We make the
2029 assumption here that all the available sources for this version share
2030 the same extension.. */
2031 // Skip not source sources, they do not have file fields.
2032 for (; Vf
.end() == false; ++Vf
)
2034 if ((Vf
.File()->Flags
& pkgCache::Flag::NotSource
) != 0)
2039 // Does not really matter here.. we are going to fail out below
2040 if (Vf
.end() != true)
2042 // If this fails to get a file name we will bomb out below.
2043 pkgRecords::Parser
&Parse
= Recs
->Lookup(Vf
);
2044 if (_error
->PendingError() == true)
2047 // Generate the final file name as: package_version_arch.foo
2048 StoreFilename
= QuoteString(Version
.ParentPkg().Name(),"_:") + '_' +
2049 QuoteString(Version
.VerStr(),"_:") + '_' +
2050 QuoteString(Version
.Arch(),"_:.") +
2051 "." + flExtension(Parse
.FileName());
2054 // check if we have one trusted source for the package. if so, switch
2055 // to "TrustedOnly" mode - but only if not in AllowUnauthenticated mode
2056 bool const allowUnauth
= _config
->FindB("APT::Get::AllowUnauthenticated", false);
2057 bool const debugAuth
= _config
->FindB("Debug::pkgAcquire::Auth", false);
2058 bool seenUntrusted
= false;
2059 for (pkgCache::VerFileIterator i
= Version
.FileList(); i
.end() == false; ++i
)
2061 pkgIndexFile
*Index
;
2062 if (Sources
->FindIndex(i
.File(),Index
) == false)
2065 if (debugAuth
== true)
2066 std::cerr
<< "Checking index: " << Index
->Describe()
2067 << "(Trusted=" << Index
->IsTrusted() << ")" << std::endl
;
2069 if (Index
->IsTrusted() == true)
2072 if (allowUnauth
== false)
2076 seenUntrusted
= true;
2079 // "allow-unauthenticated" restores apts old fetching behaviour
2080 // that means that e.g. unauthenticated file:// uris are higher
2081 // priority than authenticated http:// uris
2082 if (allowUnauth
== true && seenUntrusted
== true)
2086 if (QueueNext() == false && _error
->PendingError() == false)
2087 _error
->Error(_("Can't find a source to download version '%s' of '%s'"),
2088 Version
.VerStr(), Version
.ParentPkg().FullName(false).c_str());
2091 // AcqArchive::QueueNext - Queue the next file source /*{{{*/
2092 // ---------------------------------------------------------------------
2093 /* This queues the next available file version for download. It checks if
2094 the archive is already available in the cache and stashs the MD5 for
2096 bool pkgAcqArchive::QueueNext()
2098 for (; Vf
.end() == false; ++Vf
)
2100 // Ignore not source sources
2101 if ((Vf
.File()->Flags
& pkgCache::Flag::NotSource
) != 0)
2104 // Try to cross match against the source list
2105 pkgIndexFile
*Index
;
2106 if (Sources
->FindIndex(Vf
.File(),Index
) == false)
2109 // only try to get a trusted package from another source if that source
2111 if(Trusted
&& !Index
->IsTrusted())
2114 // Grab the text package record
2115 pkgRecords::Parser
&Parse
= Recs
->Lookup(Vf
);
2116 if (_error
->PendingError() == true)
2119 string PkgFile
= Parse
.FileName();
2120 ExpectedHashes
= Parse
.Hashes();
2122 if (PkgFile
.empty() == true)
2123 return _error
->Error(_("The package index files are corrupted. No Filename: "
2124 "field for package %s."),
2125 Version
.ParentPkg().Name());
2127 Desc
.URI
= Index
->ArchiveURI(PkgFile
);
2128 Desc
.Description
= Index
->ArchiveInfo(Version
);
2130 Desc
.ShortDesc
= Version
.ParentPkg().FullName(true);
2132 // See if we already have the file. (Legacy filenames)
2133 FileSize
= Version
->Size
;
2134 string FinalFile
= _config
->FindDir("Dir::Cache::Archives") + flNotDir(PkgFile
);
2136 if (stat(FinalFile
.c_str(),&Buf
) == 0)
2138 // Make sure the size matches
2139 if ((unsigned long long)Buf
.st_size
== Version
->Size
)
2144 StoreFilename
= DestFile
= FinalFile
;
2148 /* Hmm, we have a file and its size does not match, this means it is
2149 an old style mismatched arch */
2150 unlink(FinalFile
.c_str());
2153 // Check it again using the new style output filenames
2154 FinalFile
= _config
->FindDir("Dir::Cache::Archives") + flNotDir(StoreFilename
);
2155 if (stat(FinalFile
.c_str(),&Buf
) == 0)
2157 // Make sure the size matches
2158 if ((unsigned long long)Buf
.st_size
== Version
->Size
)
2163 StoreFilename
= DestFile
= FinalFile
;
2167 /* Hmm, we have a file and its size does not match, this shouldn't
2169 unlink(FinalFile
.c_str());
2172 DestFile
= _config
->FindDir("Dir::Cache::Archives") + "partial/" + flNotDir(StoreFilename
);
2174 // Check the destination file
2175 if (stat(DestFile
.c_str(),&Buf
) == 0)
2177 // Hmm, the partial file is too big, erase it
2178 if ((unsigned long long)Buf
.st_size
> Version
->Size
)
2179 unlink(DestFile
.c_str());
2181 PartialSize
= Buf
.st_size
;
2184 // Disables download of archives - useful if no real installation follows,
2185 // e.g. if we are just interested in proposed installation order
2186 if (_config
->FindB("Debug::pkgAcqArchive::NoQueue", false) == true)
2191 StoreFilename
= DestFile
= FinalFile
;
2205 // AcqArchive::Done - Finished fetching /*{{{*/
2206 // ---------------------------------------------------------------------
2208 void pkgAcqArchive::Done(string Message
,unsigned long long Size
, HashStringList
const &CalcHashes
,
2209 pkgAcquire::MethodConfig
*Cfg
)
2211 Item::Done(Message
, Size
, CalcHashes
, Cfg
);
2214 if (Size
!= Version
->Size
)
2216 RenameOnError(SizeMismatch
);
2220 // FIXME: could this empty() check impose *any* sort of security issue?
2221 if(ExpectedHashes
.usable() && ExpectedHashes
!= CalcHashes
)
2223 RenameOnError(HashSumMismatch
);
2224 printHashSumComparision(DestFile
, ExpectedHashes
, CalcHashes
);
2228 // Grab the output filename
2229 string FileName
= LookupTag(Message
,"Filename");
2230 if (FileName
.empty() == true)
2233 ErrorText
= "Method gave a blank filename";
2239 // Reference filename
2240 if (FileName
!= DestFile
)
2242 StoreFilename
= DestFile
= FileName
;
2247 // Done, move it into position
2248 string FinalFile
= _config
->FindDir("Dir::Cache::Archives");
2249 FinalFile
+= flNotDir(StoreFilename
);
2250 Rename(DestFile
,FinalFile
);
2252 StoreFilename
= DestFile
= FinalFile
;
2256 // AcqArchive::Failed - Failure handler /*{{{*/
2257 // ---------------------------------------------------------------------
2258 /* Here we try other sources */
2259 void pkgAcqArchive::Failed(string Message
,pkgAcquire::MethodConfig
*Cnf
)
2261 ErrorText
= LookupTag(Message
,"Message");
2263 /* We don't really want to retry on failed media swaps, this prevents
2264 that. An interesting observation is that permanent failures are not
2266 if (Cnf
->Removable
== true &&
2267 StringToBool(LookupTag(Message
,"Transient-Failure"),false) == true)
2269 // Vf = Version.FileList();
2270 while (Vf
.end() == false) ++Vf
;
2271 StoreFilename
= string();
2272 Item::Failed(Message
,Cnf
);
2276 if (QueueNext() == false)
2278 // This is the retry counter
2280 Cnf
->LocalOnly
== false &&
2281 StringToBool(LookupTag(Message
,"Transient-Failure"),false) == true)
2284 Vf
= Version
.FileList();
2285 if (QueueNext() == true)
2289 StoreFilename
= string();
2290 Item::Failed(Message
,Cnf
);
2294 // AcqArchive::IsTrusted - Determine whether this archive comes from a trusted source /*{{{*/
2295 // ---------------------------------------------------------------------
2296 APT_PURE
bool pkgAcqArchive::IsTrusted() const
2301 // AcqArchive::Finished - Fetching has finished, tidy up /*{{{*/
2302 // ---------------------------------------------------------------------
2304 void pkgAcqArchive::Finished()
2306 if (Status
== pkgAcquire::Item::StatDone
&&
2309 StoreFilename
= string();
2312 // AcqFile::pkgAcqFile - Constructor /*{{{*/
2313 // ---------------------------------------------------------------------
2314 /* The file is added to the queue */
2315 pkgAcqFile::pkgAcqFile(pkgAcquire
*Owner
,string URI
, HashStringList
const &Hashes
,
2316 unsigned long long Size
,string Dsc
,string ShortDesc
,
2317 const string
&DestDir
, const string
&DestFilename
,
2319 Item(Owner
, Hashes
), IsIndexFile(IsIndexFile
)
2321 Retries
= _config
->FindI("Acquire::Retries",0);
2323 if(!DestFilename
.empty())
2324 DestFile
= DestFilename
;
2325 else if(!DestDir
.empty())
2326 DestFile
= DestDir
+ "/" + flNotDir(URI
);
2328 DestFile
= flNotDir(URI
);
2332 Desc
.Description
= Dsc
;
2335 // Set the short description to the archive component
2336 Desc
.ShortDesc
= ShortDesc
;
2338 // Get the transfer sizes
2341 if (stat(DestFile
.c_str(),&Buf
) == 0)
2343 // Hmm, the partial file is too big, erase it
2344 if ((Size
> 0) && (unsigned long long)Buf
.st_size
> Size
)
2345 unlink(DestFile
.c_str());
2347 PartialSize
= Buf
.st_size
;
2353 // AcqFile::Done - Item downloaded OK /*{{{*/
2354 // ---------------------------------------------------------------------
2356 void pkgAcqFile::Done(string Message
,unsigned long long Size
,HashStringList
const &CalcHashes
,
2357 pkgAcquire::MethodConfig
*Cnf
)
2359 Item::Done(Message
,Size
,CalcHashes
,Cnf
);
2362 if(ExpectedHashes
.usable() && ExpectedHashes
!= CalcHashes
)
2364 RenameOnError(HashSumMismatch
);
2365 printHashSumComparision(DestFile
, ExpectedHashes
, CalcHashes
);
2369 string FileName
= LookupTag(Message
,"Filename");
2370 if (FileName
.empty() == true)
2373 ErrorText
= "Method gave a blank filename";
2379 // The files timestamp matches
2380 if (StringToBool(LookupTag(Message
,"IMS-Hit"),false) == true)
2383 // We have to copy it into place
2384 if (FileName
!= DestFile
)
2387 if (_config
->FindB("Acquire::Source-Symlinks",true) == false ||
2388 Cnf
->Removable
== true)
2390 Desc
.URI
= "copy:" + FileName
;
2395 // Erase the file if it is a symlink so we can overwrite it
2397 if (lstat(DestFile
.c_str(),&St
) == 0)
2399 if (S_ISLNK(St
.st_mode
) != 0)
2400 unlink(DestFile
.c_str());
2404 if (symlink(FileName
.c_str(),DestFile
.c_str()) != 0)
2406 ErrorText
= "Link to " + DestFile
+ " failure ";
2413 // AcqFile::Failed - Failure handler /*{{{*/
2414 // ---------------------------------------------------------------------
2415 /* Here we try other sources */
2416 void pkgAcqFile::Failed(string Message
,pkgAcquire::MethodConfig
*Cnf
)
2418 ErrorText
= LookupTag(Message
,"Message");
2420 // This is the retry counter
2422 Cnf
->LocalOnly
== false &&
2423 StringToBool(LookupTag(Message
,"Transient-Failure"),false) == true)
2430 Item::Failed(Message
,Cnf
);
2433 // AcqIndex::Custom600Headers - Insert custom request headers /*{{{*/
2434 // ---------------------------------------------------------------------
2435 /* The only header we use is the last-modified header. */
2436 string
pkgAcqFile::Custom600Headers() const
2439 return "\nIndex-File: true";