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 /*{{{*/
17 #pragma implementation "apt-pkg/acquire-item.h"
19 #include <apt-pkg/acquire-item.h>
20 #include <apt-pkg/configuration.h>
21 #include <apt-pkg/sourcelist.h>
22 #include <apt-pkg/vendorlist.h>
23 #include <apt-pkg/error.h>
24 #include <apt-pkg/strutl.h>
25 #include <apt-pkg/fileutl.h>
26 #include <apt-pkg/md5.h>
27 #include <apt-pkg/sha1.h>
28 #include <apt-pkg/tagfile.h>
42 // Acquire::Item::Item - Constructor /*{{{*/
43 // ---------------------------------------------------------------------
45 pkgAcquire::Item::Item(pkgAcquire
*Owner
) : Owner(Owner
), FileSize(0),
46 PartialSize(0), Mode(0), ID(0), Complete(false),
47 Local(false), QueueCounter(0)
53 // Acquire::Item::~Item - Destructor /*{{{*/
54 // ---------------------------------------------------------------------
56 pkgAcquire::Item::~Item()
61 // Acquire::Item::Failed - Item failed to download /*{{{*/
62 // ---------------------------------------------------------------------
63 /* We return to an idle state if there are still other queues that could
65 void pkgAcquire::Item::Failed(string Message
,pkgAcquire::MethodConfig
*Cnf
)
68 ErrorText
= LookupTag(Message
,"Message");
69 if (QueueCounter
<= 1)
71 /* This indicates that the file is not available right now but might
72 be sometime later. If we do a retry cycle then this should be
74 if (Cnf
->LocalOnly
== true &&
75 StringToBool(LookupTag(Message
,"Transient-Failure"),false) == true)
87 // Acquire::Item::Start - Item has begun to download /*{{{*/
88 // ---------------------------------------------------------------------
89 /* Stash status and the file size. Note that setting Complete means
90 sub-phases of the acquire process such as decompresion are operating */
91 void pkgAcquire::Item::Start(string
/*Message*/,unsigned long Size
)
93 Status
= StatFetching
;
94 if (FileSize
== 0 && Complete
== false)
98 // Acquire::Item::Done - Item downloaded OK /*{{{*/
99 // ---------------------------------------------------------------------
101 void pkgAcquire::Item::Done(string Message
,unsigned long Size
,string
,
102 pkgAcquire::MethodConfig
*Cnf
)
104 // We just downloaded something..
105 string FileName
= LookupTag(Message
,"Filename");
106 // we only inform the Log class if it was actually not a local thing
107 if (Complete
== false && !Local
&& FileName
== DestFile
)
110 Owner
->Log
->Fetched(Size
,atoi(LookupTag(Message
,"Resume-Point","0").c_str()));
117 ErrorText
= string();
118 Owner
->Dequeue(this);
121 // Acquire::Item::Rename - Rename a file /*{{{*/
122 // ---------------------------------------------------------------------
123 /* This helper function is used by alot of item methods as thier final
125 void pkgAcquire::Item::Rename(string From
,string To
)
127 if (rename(From
.c_str(),To
.c_str()) != 0)
130 snprintf(S
,sizeof(S
),_("rename failed, %s (%s -> %s)."),strerror(errno
),
131 From
.c_str(),To
.c_str());
139 // AcqDiffIndex::AcqDiffIndex - Constructor
140 // ---------------------------------------------------------------------
141 /* Get the DiffIndex file first and see if there are patches availabe
142 * If so, create a pkgAcqIndexDiffs fetcher that will get and apply the
143 * patches. If anything goes wrong in that process, it will fall back to
144 * the original packages file
146 pkgAcqDiffIndex::pkgAcqDiffIndex(pkgAcquire
*Owner
,
147 string URI
,string URIDesc
,string ShortDesc
,
149 : Item(Owner
), RealURI(URI
), ExpectedMD5(ExpectedMD5
), Description(URIDesc
)
152 Debug
= _config
->FindB("Debug::pkgAcquire::Diffs",false);
154 Desc
.Description
= URIDesc
+ "/DiffIndex";
156 Desc
.ShortDesc
= ShortDesc
;
157 Desc
.URI
= URI
+ ".diff/Index";
159 DestFile
= _config
->FindDir("Dir::State::lists") + "partial/";
160 DestFile
+= URItoFileName(URI
) + string(".DiffIndex");
163 std::clog
<< "pkgAcqDiffIndex: " << Desc
.URI
<< std::endl
;
165 // look for the current package file
166 CurrentPackagesFile
= _config
->FindDir("Dir::State::lists");
167 CurrentPackagesFile
+= URItoFileName(RealURI
);
169 // FIXME: this file:/ check is a hack to prevent fetching
170 // from local sources. this is really silly, and
171 // should be fixed cleanly as soon as possible
172 if(!FileExists(CurrentPackagesFile
) ||
173 Desc
.URI
.substr(0,strlen("file:/")) == "file:/")
175 // we don't have a pkg file or we don't want to queue
177 std::clog
<< "No index file, local or canceld by user" << std::endl
;
183 std::clog
<< "pkgAcqIndexDiffs::pkgAcqIndexDiffs(): "
184 << CurrentPackagesFile
<< std::endl
;
190 // AcqIndex::Custom600Headers - Insert custom request headers /*{{{*/
191 // ---------------------------------------------------------------------
192 /* The only header we use is the last-modified header. */
193 string
pkgAcqDiffIndex::Custom600Headers()
195 string Final
= _config
->FindDir("Dir::State::lists");
196 Final
+= URItoFileName(RealURI
) + string(".IndexDiff");
199 std::clog
<< "Custom600Header-IMS: " << Final
<< std::endl
;
202 if (stat(Final
.c_str(),&Buf
) != 0)
203 return "\nIndex-File: true";
205 return "\nIndex-File: true\nLast-Modified: " + TimeRFC1123(Buf
.st_mtime
);
209 bool pkgAcqDiffIndex::ParseDiffIndex(string IndexDiffFile
)
212 std::clog
<< "pkgAcqIndexDiffs::ParseIndexDiff() " << IndexDiffFile
217 vector
<DiffInfo
> available_patches
;
219 FileFd
Fd(IndexDiffFile
,FileFd::ReadOnly
);
221 if (_error
->PendingError() == true)
224 if(TF
.Step(Tags
) == true)
231 string tmp
= Tags
.FindS("SHA1-Current");
232 std::stringstream
ss(tmp
);
235 FileFd
fd(CurrentPackagesFile
, FileFd::ReadOnly
);
237 SHA1
.AddFD(fd
.Fd(), fd
.Size());
238 local_sha1
= string(SHA1
.Result());
240 if(local_sha1
== ServerSha1
)
242 // we have the same sha1 as the server
244 std::clog
<< "Package file is up-to-date" << std::endl
;
245 // set found to true, this will queue a pkgAcqIndexDiffs with
246 // a empty availabe_patches
252 std::clog
<< "SHA1-Current: " << ServerSha1
<< std::endl
;
254 // check the historie and see what patches we need
255 string history
= Tags
.FindS("SHA1-History");
256 std::stringstream
hist(history
);
257 while(hist
>> d
.sha1
>> size
>> d
.file
)
259 d
.size
= atoi(size
.c_str());
260 // read until the first match is found
261 if(d
.sha1
== local_sha1
)
263 // from that point on, we probably need all diffs
267 std::clog
<< "Need to get diff: " << d
.file
<< std::endl
;
268 available_patches
.push_back(d
);
273 // no information how to get the patches, bail out
277 std::clog
<< "Can't find a patch in the index file" << std::endl
;
278 // Failed will queue a big package file
284 new pkgAcqIndexDiffs(Owner
, RealURI
, Description
, Desc
.ShortDesc
,
285 ExpectedMD5
, available_patches
);
296 void pkgAcqDiffIndex::Failed(string Message
,pkgAcquire::MethodConfig
*Cnf
)
299 std::clog
<< "pkgAcqDiffIndex failed: " << Desc
.URI
<< std::endl
300 << "Falling back to normal index file aquire" << std::endl
;
302 new pkgAcqIndex(Owner
, RealURI
, Description
, Desc
.ShortDesc
,
310 void pkgAcqDiffIndex::Done(string Message
,unsigned long Size
,string Md5Hash
,
311 pkgAcquire::MethodConfig
*Cnf
)
314 std::clog
<< "pkgAcqDiffIndex::Done(): " << Desc
.URI
<< std::endl
;
316 Item::Done(Message
,Size
,Md5Hash
,Cnf
);
319 FinalFile
= _config
->FindDir("Dir::State::lists")+URItoFileName(RealURI
);
321 // sucess in downloading the index
323 FinalFile
+= string(".IndexDiff");
325 std::clog
<< "Renaming: " << DestFile
<< " -> " << FinalFile
327 Rename(DestFile
,FinalFile
);
328 chmod(FinalFile
.c_str(),0644);
329 DestFile
= FinalFile
;
331 if(!ParseDiffIndex(DestFile
))
332 return Failed("", NULL
);
342 // AcqIndexDiffs::AcqIndexDiffs - Constructor
343 // ---------------------------------------------------------------------
344 /* The package diff is added to the queue. one object is constructed
345 * for each diff and the index
347 pkgAcqIndexDiffs::pkgAcqIndexDiffs(pkgAcquire
*Owner
,
348 string URI
,string URIDesc
,string ShortDesc
,
349 string ExpectedMD5
, vector
<DiffInfo
> diffs
)
350 : Item(Owner
), RealURI(URI
), ExpectedMD5(ExpectedMD5
),
351 available_patches(diffs
)
354 DestFile
= _config
->FindDir("Dir::State::lists") + "partial/";
355 DestFile
+= URItoFileName(URI
);
357 Debug
= _config
->FindB("Debug::pkgAcquire::Diffs",false);
359 Desc
.Description
= URIDesc
;
361 Desc
.ShortDesc
= ShortDesc
;
363 if(available_patches
.size() == 0)
365 // we are done (yeah!)
371 State
= StateFetchDiff
;
377 void pkgAcqIndexDiffs::Failed(string Message
,pkgAcquire::MethodConfig
*Cnf
)
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
,
388 // helper that cleans the item out of the fetcher queue
389 void pkgAcqIndexDiffs::Finish(bool allDone
)
391 // we restore the original name, this is required, otherwise
392 // the file will be cleaned
395 DestFile
= _config
->FindDir("Dir::State::lists");
396 DestFile
+= URItoFileName(RealURI
);
398 // do the final md5sum checking
400 FileFd
Fd(DestFile
, FileFd::ReadOnly
);
401 sum
.AddFD(Fd
.Fd(), Fd
.Size());
403 string MD5
= (string
)sum
.Result();
405 if (!ExpectedMD5
.empty() && MD5
!= ExpectedMD5
)
407 Status
= StatAuthError
;
408 ErrorText
= _("MD5Sum mismatch");
409 Rename(DestFile
,DestFile
+ ".FAILED");
414 // this is for the "real" finish
419 std::clog
<< "\n\nallDone: " << DestFile
<< "\n" << std::endl
;
424 std::clog
<< "Finishing: " << Desc
.URI
<< std::endl
;
433 bool pkgAcqIndexDiffs::QueueNextDiff()
436 // calc sha1 of the just patched file
437 string FinalFile
= _config
->FindDir("Dir::State::lists");
438 FinalFile
+= URItoFileName(RealURI
);
440 FileFd
fd(FinalFile
, FileFd::ReadOnly
);
442 SHA1
.AddFD(fd
.Fd(), fd
.Size());
443 string local_sha1
= string(SHA1
.Result());
445 std::clog
<< "QueueNextDiff: "
446 << FinalFile
<< " (" << local_sha1
<< ")"<<std::endl
;
448 // remove all patches until the next matching patch is found
449 // this requires the Index file to be ordered
450 for(vector
<DiffInfo
>::iterator I
=available_patches
.begin();
451 available_patches
.size() > 0 &&
452 I
!= available_patches
.end() &&
453 (*I
).sha1
!= local_sha1
;
456 available_patches
.erase(I
);
459 // error checking and falling back if no patch was found
460 if(available_patches
.size() == 0)
466 // queue the right diff
467 Desc
.URI
= string(RealURI
) + ".diff/" + available_patches
[0].file
+ ".gz";
468 Desc
.Description
= available_patches
[0].file
+ string(".pdiff");
470 DestFile
= _config
->FindDir("Dir::State::lists") + "partial/";
471 DestFile
+= URItoFileName(RealURI
+ ".diff/" + available_patches
[0].file
);
474 std::clog
<< "pkgAcqIndexDiffs::QueueNextDiff(): " << Desc
.URI
<< std::endl
;
483 void pkgAcqIndexDiffs::Done(string Message
,unsigned long Size
,string Md5Hash
,
484 pkgAcquire::MethodConfig
*Cnf
)
487 std::clog
<< "pkgAcqIndexDiffs::Done(): " << Desc
.URI
<< std::endl
;
489 Item::Done(Message
,Size
,Md5Hash
,Cnf
);
492 FinalFile
= _config
->FindDir("Dir::State::lists")+URItoFileName(RealURI
);
494 // sucess in downloading a diff, enter ApplyDiff state
495 if(State
== StateFetchDiff
)
499 std::clog
<< "Sending to gzip method: " << FinalFile
<< std::endl
;
501 string FileName
= LookupTag(Message
,"Filename");
502 State
= StateUnzipDiff
;
504 Desc
.URI
= "gzip:" + FileName
;
505 DestFile
+= ".decomp";
511 // sucess in downloading a diff, enter ApplyDiff state
512 if(State
== StateUnzipDiff
)
515 // rred excepts the patch as $FinalFile.ed
516 Rename(DestFile
,FinalFile
+".ed");
519 std::clog
<< "Sending to rred method: " << FinalFile
<< std::endl
;
521 State
= StateApplyDiff
;
523 Desc
.URI
= "rred:" + FinalFile
;
530 // success in download/apply a diff, queue next (if needed)
531 if(State
== StateApplyDiff
)
533 // remove the just applied patch
534 available_patches
.erase(available_patches
.begin());
539 std::clog
<< "Moving patched file in place: " << std::endl
540 << DestFile
<< " -> " << FinalFile
<< std::endl
;
542 Rename(DestFile
,FinalFile
);
544 // see if there is more to download
545 if(available_patches
.size() > 0) {
546 new pkgAcqIndexDiffs(Owner
, RealURI
, Description
, Desc
.ShortDesc
,
547 ExpectedMD5
, available_patches
);
555 // AcqIndex::AcqIndex - Constructor /*{{{*/
556 // ---------------------------------------------------------------------
557 /* The package file is added to the queue and a second class is
558 instantiated to fetch the revision file */
559 pkgAcqIndex::pkgAcqIndex(pkgAcquire
*Owner
,
560 string URI
,string URIDesc
,string ShortDesc
,
561 string ExpectedMD5
, string comprExt
)
562 : Item(Owner
), RealURI(URI
), ExpectedMD5(ExpectedMD5
)
564 Decompression
= false;
567 DestFile
= _config
->FindDir("Dir::State::lists") + "partial/";
568 DestFile
+= URItoFileName(URI
);
572 // autoselect the compression method
573 if(FileExists("/usr/bin/bzip2"))
574 CompressionExtension
= ".bz2";
576 CompressionExtension
= ".gz";
578 CompressionExtension
= comprExt
;
580 Desc
.URI
= URI
+ CompressionExtension
;
582 Desc
.Description
= URIDesc
;
584 Desc
.ShortDesc
= ShortDesc
;
589 // AcqIndex::Custom600Headers - Insert custom request headers /*{{{*/
590 // ---------------------------------------------------------------------
591 /* The only header we use is the last-modified header. */
592 string
pkgAcqIndex::Custom600Headers()
594 string Final
= _config
->FindDir("Dir::State::lists");
595 Final
+= URItoFileName(RealURI
);
598 if (stat(Final
.c_str(),&Buf
) != 0)
599 return "\nIndex-File: true";
601 return "\nIndex-File: true\nLast-Modified: " + TimeRFC1123(Buf
.st_mtime
);
605 void pkgAcqIndex::Failed(string Message
,pkgAcquire::MethodConfig
*Cnf
)
607 // no .bz2 found, retry with .gz
608 if(Desc
.URI
.substr(Desc
.URI
.size()-3,Desc
.URI
.size()-1) == "bz2") {
609 Desc
.URI
= Desc
.URI
.substr(0,Desc
.URI
.size()-3) + "gz";
611 // retry with a gzip one
612 new pkgAcqIndex(Owner
, RealURI
, Desc
.Description
,Desc
.ShortDesc
,
613 ExpectedMD5
, string(".gz"));
621 Item::Failed(Message
,Cnf
);
625 // AcqIndex::Done - Finished a fetch /*{{{*/
626 // ---------------------------------------------------------------------
627 /* This goes through a number of states.. On the initial fetch the
628 method could possibly return an alternate filename which points
629 to the uncompressed version of the file. If this is so the file
630 is copied into the partial directory. In all other cases the file
631 is decompressed with a gzip uri. */
632 void pkgAcqIndex::Done(string Message
,unsigned long Size
,string MD5
,
633 pkgAcquire::MethodConfig
*Cfg
)
635 Item::Done(Message
,Size
,MD5
,Cfg
);
637 if (Decompression
== true)
639 if (_config
->FindB("Debug::pkgAcquire::Auth", false))
641 std::cerr
<< std::endl
<< RealURI
<< ": Computed MD5: " << MD5
;
642 std::cerr
<< " Expected MD5: " << ExpectedMD5
<< std::endl
;
648 FileFd
Fd(DestFile
, FileFd::ReadOnly
);
649 sum
.AddFD(Fd
.Fd(), Fd
.Size());
651 MD5
= (string
)sum
.Result();
654 if (!ExpectedMD5
.empty() && MD5
!= ExpectedMD5
)
656 Status
= StatAuthError
;
657 ErrorText
= _("MD5Sum mismatch");
658 Rename(DestFile
,DestFile
+ ".FAILED");
661 // Done, move it into position
662 string FinalFile
= _config
->FindDir("Dir::State::lists");
663 FinalFile
+= URItoFileName(RealURI
);
664 Rename(DestFile
,FinalFile
);
665 chmod(FinalFile
.c_str(),0644);
667 /* We restore the original name to DestFile so that the clean operation
669 DestFile
= _config
->FindDir("Dir::State::lists") + "partial/";
670 DestFile
+= URItoFileName(RealURI
);
672 // Remove the compressed version.
674 unlink(DestFile
.c_str());
681 // Handle the unzipd case
682 string FileName
= LookupTag(Message
,"Alt-Filename");
683 if (FileName
.empty() == false)
685 // The files timestamp matches
686 if (StringToBool(LookupTag(Message
,"Alt-IMS-Hit"),false) == true)
689 Decompression
= true;
691 DestFile
+= ".decomp";
692 Desc
.URI
= "copy:" + FileName
;
698 FileName
= LookupTag(Message
,"Filename");
699 if (FileName
.empty() == true)
702 ErrorText
= "Method gave a blank filename";
705 // The files timestamp matches
706 if (StringToBool(LookupTag(Message
,"IMS-Hit"),false) == true)
709 if (FileName
== DestFile
)
714 string compExt
= Desc
.URI
.substr(Desc
.URI
.size()-3,Desc
.URI
.size()-1);
717 decompProg
= "bzip2";
718 else if(compExt
== ".gz")
721 _error
->Error("Unsupported extension: %s", compExt
.c_str());
725 Decompression
= true;
726 DestFile
+= ".decomp";
727 Desc
.URI
= string(decompProg
) + ":" + FileName
;
732 pkgAcqMetaSig::pkgAcqMetaSig(pkgAcquire
*Owner
,
733 string URI
,string URIDesc
,string ShortDesc
,
734 string MetaIndexURI
, string MetaIndexURIDesc
,
735 string MetaIndexShortDesc
,
736 const vector
<IndexTarget
*>* IndexTargets
,
737 indexRecords
* MetaIndexParser
) :
738 Item(Owner
), RealURI(URI
), MetaIndexURI(MetaIndexURI
),
739 MetaIndexURIDesc(MetaIndexURIDesc
), MetaIndexShortDesc(MetaIndexShortDesc
)
741 this->MetaIndexParser
= MetaIndexParser
;
742 this->IndexTargets
= IndexTargets
;
743 DestFile
= _config
->FindDir("Dir::State::lists") + "partial/";
744 DestFile
+= URItoFileName(URI
);
746 // remove any partial downloaded sig-file. it may confuse proxies
747 // and is too small to warrant a partial download anyway
748 unlink(DestFile
.c_str());
751 Desc
.Description
= URIDesc
;
753 Desc
.ShortDesc
= ShortDesc
;
757 string Final
= _config
->FindDir("Dir::State::lists");
758 Final
+= URItoFileName(RealURI
);
760 if (stat(Final
.c_str(),&Buf
) == 0)
762 // File was already in place. It needs to be re-verified
763 // because Release might have changed, so Move it into partial
764 Rename(Final
,DestFile
);
765 // unlink the file and do not try to use I-M-S and Last-Modified
766 // if the users proxy is broken
767 if(_config
->FindB("Acquire::BrokenProxy", false) == true) {
768 std::cerr
<< "forcing re-get of the signature file as requested" << std::endl
;
769 unlink(DestFile
.c_str());
776 // pkgAcqMetaSig::Custom600Headers - Insert custom request headers /*{{{*/
777 // ---------------------------------------------------------------------
778 /* The only header we use is the last-modified header. */
779 string
pkgAcqMetaSig::Custom600Headers()
782 if (stat(DestFile
.c_str(),&Buf
) != 0)
783 return "\nIndex-File: true";
785 return "\nIndex-File: true\nLast-Modified: " + TimeRFC1123(Buf
.st_mtime
);
788 void pkgAcqMetaSig::Done(string Message
,unsigned long Size
,string MD5
,
789 pkgAcquire::MethodConfig
*Cfg
)
791 Item::Done(Message
,Size
,MD5
,Cfg
);
793 string FileName
= LookupTag(Message
,"Filename");
794 if (FileName
.empty() == true)
797 ErrorText
= "Method gave a blank filename";
801 if (FileName
!= DestFile
)
803 // We have to copy it into place
805 Desc
.URI
= "copy:" + FileName
;
812 // queue a pkgAcqMetaIndex to be verified against the sig we just retrieved
813 new pkgAcqMetaIndex(Owner
, MetaIndexURI
, MetaIndexURIDesc
, MetaIndexShortDesc
,
814 DestFile
, IndexTargets
, MetaIndexParser
);
818 void pkgAcqMetaSig::Failed(string Message
,pkgAcquire::MethodConfig
*Cnf
)
820 // Delete any existing sigfile, so that this source isn't
821 // mistakenly trusted
822 string Final
= _config
->FindDir("Dir::State::lists") + URItoFileName(RealURI
);
823 unlink(Final
.c_str());
825 // if we get a timeout if fail
826 if(LookupTag(Message
,"FailReason") == "Timeout" ||
827 LookupTag(Message
,"FailReason") == "TmpResolveFailure") {
828 Item::Failed(Message
,Cnf
);
832 // queue a pkgAcqMetaIndex with no sigfile
833 new pkgAcqMetaIndex(Owner
, MetaIndexURI
, MetaIndexURIDesc
, MetaIndexShortDesc
,
834 "", IndexTargets
, MetaIndexParser
);
836 if (Cnf
->LocalOnly
== true ||
837 StringToBool(LookupTag(Message
,"Transient-Failure"),false) == false)
846 Item::Failed(Message
,Cnf
);
849 pkgAcqMetaIndex::pkgAcqMetaIndex(pkgAcquire
*Owner
,
850 string URI
,string URIDesc
,string ShortDesc
,
852 const vector
<struct IndexTarget
*>* IndexTargets
,
853 indexRecords
* MetaIndexParser
) :
854 Item(Owner
), RealURI(URI
), SigFile(SigFile
)
856 this->AuthPass
= false;
857 this->MetaIndexParser
= MetaIndexParser
;
858 this->IndexTargets
= IndexTargets
;
859 DestFile
= _config
->FindDir("Dir::State::lists") + "partial/";
860 DestFile
+= URItoFileName(URI
);
863 Desc
.Description
= URIDesc
;
865 Desc
.ShortDesc
= ShortDesc
;
872 // pkgAcqMetaIndex::Custom600Headers - Insert custom request headers /*{{{*/
873 // ---------------------------------------------------------------------
874 /* The only header we use is the last-modified header. */
875 string
pkgAcqMetaIndex::Custom600Headers()
877 string Final
= _config
->FindDir("Dir::State::lists");
878 Final
+= URItoFileName(RealURI
);
881 if (stat(Final
.c_str(),&Buf
) != 0)
882 return "\nIndex-File: true";
884 return "\nIndex-File: true\nLast-Modified: " + TimeRFC1123(Buf
.st_mtime
);
887 void pkgAcqMetaIndex::Done(string Message
,unsigned long Size
,string MD5
,
888 pkgAcquire::MethodConfig
*Cfg
)
890 Item::Done(Message
,Size
,MD5
,Cfg
);
892 // MetaIndexes are done in two passes: one to download the
893 // metaindex with an appropriate method, and a second to verify it
894 // with the gpgv method
896 if (AuthPass
== true)
902 RetrievalDone(Message
);
904 // Still more retrieving to do
909 // There was no signature file, so we are finished. Download
910 // the indexes without verification.
915 // There was a signature file, so pass it to gpgv for
918 if (_config
->FindB("Debug::pkgAcquire::Auth", false))
919 std::cerr
<< "Metaindex acquired, queueing gpg verification ("
920 << SigFile
<< "," << DestFile
<< ")\n";
922 Desc
.URI
= "gpgv:" + SigFile
;
929 void pkgAcqMetaIndex::RetrievalDone(string Message
)
931 // We have just finished downloading a Release file (it is not
934 string FileName
= LookupTag(Message
,"Filename");
935 if (FileName
.empty() == true)
938 ErrorText
= "Method gave a blank filename";
942 if (FileName
!= DestFile
)
945 Desc
.URI
= "copy:" + FileName
;
952 string FinalFile
= _config
->FindDir("Dir::State::lists");
953 FinalFile
+= URItoFileName(RealURI
);
955 // The files timestamp matches
956 if (StringToBool(LookupTag(Message
,"IMS-Hit"),false) == false)
958 // Move it into position
959 Rename(DestFile
,FinalFile
);
961 DestFile
= FinalFile
;
964 void pkgAcqMetaIndex::AuthDone(string Message
)
966 // At this point, the gpgv method has succeeded, so there is a
967 // valid signature from a key in the trusted keyring. We
968 // perform additional verification of its contents, and use them
969 // to verify the indexes we are about to download
971 if (!MetaIndexParser
->Load(DestFile
))
973 Status
= StatAuthError
;
974 ErrorText
= MetaIndexParser
->ErrorText
;
983 if (_config
->FindB("Debug::pkgAcquire::Auth", false))
984 std::cerr
<< "Signature verification succeeded: "
985 << DestFile
<< std::endl
;
987 // Download further indexes with verification
990 // Done, move signature file into position
992 string VerifiedSigFile
= _config
->FindDir("Dir::State::lists") +
993 URItoFileName(RealURI
) + ".gpg";
994 Rename(SigFile
,VerifiedSigFile
);
995 chmod(VerifiedSigFile
.c_str(),0644);
998 void pkgAcqMetaIndex::QueueIndexes(bool verify
)
1000 for (vector
<struct IndexTarget
*>::const_iterator Target
= IndexTargets
->begin();
1001 Target
!= IndexTargets
->end();
1004 string ExpectedIndexMD5
;
1007 const indexRecords::checkSum
*Record
= MetaIndexParser
->Lookup((*Target
)->MetaKey
);
1010 Status
= StatAuthError
;
1011 ErrorText
= "Unable to find expected entry "
1012 + (*Target
)->MetaKey
+ " in Meta-index file (malformed Release file?)";
1015 ExpectedIndexMD5
= Record
->MD5Hash
;
1016 if (_config
->FindB("Debug::pkgAcquire::Auth", false))
1018 std::cerr
<< "Queueing: " << (*Target
)->URI
<< std::endl
;
1019 std::cerr
<< "Expected MD5: " << ExpectedIndexMD5
<< std::endl
;
1021 if (ExpectedIndexMD5
.empty())
1023 Status
= StatAuthError
;
1024 ErrorText
= "Unable to find MD5 sum for "
1025 + (*Target
)->MetaKey
+ " in Meta-index file";
1030 // Queue Packages file (either diff or full packages files, depending
1031 // on the users option)
1032 if(_config
->FindB("Acquire::PDiffs",true) == true)
1033 new pkgAcqDiffIndex(Owner
, (*Target
)->URI
, (*Target
)->Description
,
1034 (*Target
)->ShortDesc
, ExpectedIndexMD5
);
1036 new pkgAcqIndex(Owner
, (*Target
)->URI
, (*Target
)->Description
,
1037 (*Target
)->ShortDesc
, ExpectedIndexMD5
);
1041 bool pkgAcqMetaIndex::VerifyVendor()
1043 // // Maybe this should be made available from above so we don't have
1044 // // to read and parse it every time?
1045 // pkgVendorList List;
1046 // List.ReadMainList();
1048 // const Vendor* Vndr = NULL;
1049 // for (std::vector<string>::const_iterator I = GPGVOutput.begin(); I != GPGVOutput.end(); I++)
1051 // string::size_type pos = (*I).find("VALIDSIG ");
1052 // if (_config->FindB("Debug::Vendor", false))
1053 // std::cerr << "Looking for VALIDSIG in \"" << (*I) << "\": pos " << pos
1055 // if (pos != std::string::npos)
1057 // string Fingerprint = (*I).substr(pos+sizeof("VALIDSIG"));
1058 // if (_config->FindB("Debug::Vendor", false))
1059 // std::cerr << "Looking for \"" << Fingerprint << "\" in vendor..." <<
1061 // Vndr = List.FindVendor(Fingerprint) != "";
1062 // if (Vndr != NULL);
1067 string Transformed
= MetaIndexParser
->GetExpectedDist();
1069 if (Transformed
== "../project/experimental")
1071 Transformed
= "experimental";
1074 string::size_type pos
= Transformed
.rfind('/');
1075 if (pos
!= string::npos
)
1077 Transformed
= Transformed
.substr(0, pos
);
1080 if (Transformed
== ".")
1085 if (_config
->FindB("Debug::pkgAcquire::Auth", false))
1087 std::cerr
<< "Got Codename: " << MetaIndexParser
->GetDist() << std::endl
;
1088 std::cerr
<< "Expecting Dist: " << MetaIndexParser
->GetExpectedDist() << std::endl
;
1089 std::cerr
<< "Transformed Dist: " << Transformed
<< std::endl
;
1092 if (MetaIndexParser
->CheckDist(Transformed
) == false)
1094 // This might become fatal one day
1095 // Status = StatAuthError;
1096 // ErrorText = "Conflicting distribution; expected "
1097 // + MetaIndexParser->GetExpectedDist() + " but got "
1098 // + MetaIndexParser->GetDist();
1100 if (!Transformed
.empty())
1102 _error
->Warning("Conflicting distribution: %s (expected %s but got %s)",
1103 Desc
.Description
.c_str(),
1104 Transformed
.c_str(),
1105 MetaIndexParser
->GetDist().c_str());
1112 // pkgAcqMetaIndex::Failed - no Release file present or no signature
1113 // file present /*{{{*/
1114 // ---------------------------------------------------------------------
1116 void pkgAcqMetaIndex::Failed(string Message
,pkgAcquire::MethodConfig
*Cnf
)
1118 if (AuthPass
== true)
1120 // gpgv method failed
1121 _error
->Warning("GPG error: %s: %s",
1122 Desc
.Description
.c_str(),
1123 LookupTag(Message
,"Message").c_str());
1126 // No Release file was present, or verification failed, so fall
1127 // back to queueing Packages files without verification
1128 QueueIndexes(false);
1133 // AcqArchive::AcqArchive - Constructor /*{{{*/
1134 // ---------------------------------------------------------------------
1135 /* This just sets up the initial fetch environment and queues the first
1137 pkgAcqArchive::pkgAcqArchive(pkgAcquire
*Owner
,pkgSourceList
*Sources
,
1138 pkgRecords
*Recs
,pkgCache::VerIterator
const &Version
,
1139 string
&StoreFilename
) :
1140 Item(Owner
), Version(Version
), Sources(Sources
), Recs(Recs
),
1141 StoreFilename(StoreFilename
), Vf(Version
.FileList()),
1144 Retries
= _config
->FindI("Acquire::Retries",0);
1146 if (Version
.Arch() == 0)
1148 _error
->Error(_("I wasn't able to locate a file for the %s package. "
1149 "This might mean you need to manually fix this package. "
1150 "(due to missing arch)"),
1151 Version
.ParentPkg().Name());
1155 /* We need to find a filename to determine the extension. We make the
1156 assumption here that all the available sources for this version share
1157 the same extension.. */
1158 // Skip not source sources, they do not have file fields.
1159 for (; Vf
.end() == false; Vf
++)
1161 if ((Vf
.File()->Flags
& pkgCache::Flag::NotSource
) != 0)
1166 // Does not really matter here.. we are going to fail out below
1167 if (Vf
.end() != true)
1169 // If this fails to get a file name we will bomb out below.
1170 pkgRecords::Parser
&Parse
= Recs
->Lookup(Vf
);
1171 if (_error
->PendingError() == true)
1174 // Generate the final file name as: package_version_arch.foo
1175 StoreFilename
= QuoteString(Version
.ParentPkg().Name(),"_:") + '_' +
1176 QuoteString(Version
.VerStr(),"_:") + '_' +
1177 QuoteString(Version
.Arch(),"_:.") +
1178 "." + flExtension(Parse
.FileName());
1181 // check if we have one trusted source for the package. if so, switch
1182 // to "TrustedOnly" mode
1183 for (pkgCache::VerFileIterator i
= Version
.FileList(); i
.end() == false; i
++)
1185 pkgIndexFile
*Index
;
1186 if (Sources
->FindIndex(i
.File(),Index
) == false)
1188 if (_config
->FindB("Debug::pkgAcquire::Auth", false))
1190 std::cerr
<< "Checking index: " << Index
->Describe()
1191 << "(Trusted=" << Index
->IsTrusted() << ")\n";
1193 if (Index
->IsTrusted()) {
1200 if (QueueNext() == false && _error
->PendingError() == false)
1201 _error
->Error(_("I wasn't able to locate file for the %s package. "
1202 "This might mean you need to manually fix this package."),
1203 Version
.ParentPkg().Name());
1206 // AcqArchive::QueueNext - Queue the next file source /*{{{*/
1207 // ---------------------------------------------------------------------
1208 /* This queues the next available file version for download. It checks if
1209 the archive is already available in the cache and stashs the MD5 for
1211 bool pkgAcqArchive::QueueNext()
1213 for (; Vf
.end() == false; Vf
++)
1215 // Ignore not source sources
1216 if ((Vf
.File()->Flags
& pkgCache::Flag::NotSource
) != 0)
1219 // Try to cross match against the source list
1220 pkgIndexFile
*Index
;
1221 if (Sources
->FindIndex(Vf
.File(),Index
) == false)
1224 // only try to get a trusted package from another source if that source
1226 if(Trusted
&& !Index
->IsTrusted())
1229 // Grab the text package record
1230 pkgRecords::Parser
&Parse
= Recs
->Lookup(Vf
);
1231 if (_error
->PendingError() == true)
1234 string PkgFile
= Parse
.FileName();
1235 MD5
= Parse
.MD5Hash();
1236 if (PkgFile
.empty() == true)
1237 return _error
->Error(_("The package index files are corrupted. No Filename: "
1238 "field for package %s."),
1239 Version
.ParentPkg().Name());
1241 Desc
.URI
= Index
->ArchiveURI(PkgFile
);
1242 Desc
.Description
= Index
->ArchiveInfo(Version
);
1244 Desc
.ShortDesc
= Version
.ParentPkg().Name();
1246 // See if we already have the file. (Legacy filenames)
1247 FileSize
= Version
->Size
;
1248 string FinalFile
= _config
->FindDir("Dir::Cache::Archives") + flNotDir(PkgFile
);
1250 if (stat(FinalFile
.c_str(),&Buf
) == 0)
1252 // Make sure the size matches
1253 if ((unsigned)Buf
.st_size
== Version
->Size
)
1258 StoreFilename
= DestFile
= FinalFile
;
1262 /* Hmm, we have a file and its size does not match, this means it is
1263 an old style mismatched arch */
1264 unlink(FinalFile
.c_str());
1267 // Check it again using the new style output filenames
1268 FinalFile
= _config
->FindDir("Dir::Cache::Archives") + flNotDir(StoreFilename
);
1269 if (stat(FinalFile
.c_str(),&Buf
) == 0)
1271 // Make sure the size matches
1272 if ((unsigned)Buf
.st_size
== Version
->Size
)
1277 StoreFilename
= DestFile
= FinalFile
;
1281 /* Hmm, we have a file and its size does not match, this shouldnt
1283 unlink(FinalFile
.c_str());
1286 DestFile
= _config
->FindDir("Dir::Cache::Archives") + "partial/" + flNotDir(StoreFilename
);
1288 // Check the destination file
1289 if (stat(DestFile
.c_str(),&Buf
) == 0)
1291 // Hmm, the partial file is too big, erase it
1292 if ((unsigned)Buf
.st_size
> Version
->Size
)
1293 unlink(DestFile
.c_str());
1295 PartialSize
= Buf
.st_size
;
1300 Desc
.URI
= Index
->ArchiveURI(PkgFile
);
1301 Desc
.Description
= Index
->ArchiveInfo(Version
);
1303 Desc
.ShortDesc
= Version
.ParentPkg().Name();
1312 // AcqArchive::Done - Finished fetching /*{{{*/
1313 // ---------------------------------------------------------------------
1315 void pkgAcqArchive::Done(string Message
,unsigned long Size
,string Md5Hash
,
1316 pkgAcquire::MethodConfig
*Cfg
)
1318 Item::Done(Message
,Size
,Md5Hash
,Cfg
);
1321 if (Size
!= Version
->Size
)
1324 ErrorText
= _("Size mismatch");
1329 if (Md5Hash
.empty() == false && MD5
.empty() == false)
1334 ErrorText
= _("MD5Sum mismatch");
1335 if(FileExists(DestFile
))
1336 Rename(DestFile
,DestFile
+ ".FAILED");
1341 // Grab the output filename
1342 string FileName
= LookupTag(Message
,"Filename");
1343 if (FileName
.empty() == true)
1346 ErrorText
= "Method gave a blank filename";
1352 // Reference filename
1353 if (FileName
!= DestFile
)
1355 StoreFilename
= DestFile
= FileName
;
1360 // Done, move it into position
1361 string FinalFile
= _config
->FindDir("Dir::Cache::Archives");
1362 FinalFile
+= flNotDir(StoreFilename
);
1363 Rename(DestFile
,FinalFile
);
1365 StoreFilename
= DestFile
= FinalFile
;
1369 // AcqArchive::Failed - Failure handler /*{{{*/
1370 // ---------------------------------------------------------------------
1371 /* Here we try other sources */
1372 void pkgAcqArchive::Failed(string Message
,pkgAcquire::MethodConfig
*Cnf
)
1374 ErrorText
= LookupTag(Message
,"Message");
1376 /* We don't really want to retry on failed media swaps, this prevents
1377 that. An interesting observation is that permanent failures are not
1379 if (Cnf
->Removable
== true &&
1380 StringToBool(LookupTag(Message
,"Transient-Failure"),false) == true)
1382 // Vf = Version.FileList();
1383 while (Vf
.end() == false) Vf
++;
1384 StoreFilename
= string();
1385 Item::Failed(Message
,Cnf
);
1389 if (QueueNext() == false)
1391 // This is the retry counter
1393 Cnf
->LocalOnly
== false &&
1394 StringToBool(LookupTag(Message
,"Transient-Failure"),false) == true)
1397 Vf
= Version
.FileList();
1398 if (QueueNext() == true)
1402 StoreFilename
= string();
1403 Item::Failed(Message
,Cnf
);
1407 // AcqArchive::IsTrusted - Determine whether this archive comes from a
1408 // trusted source /*{{{*/
1409 // ---------------------------------------------------------------------
1410 bool pkgAcqArchive::IsTrusted()
1415 // AcqArchive::Finished - Fetching has finished, tidy up /*{{{*/
1416 // ---------------------------------------------------------------------
1418 void pkgAcqArchive::Finished()
1420 if (Status
== pkgAcquire::Item::StatDone
&&
1423 StoreFilename
= string();
1427 // AcqFile::pkgAcqFile - Constructor /*{{{*/
1428 // ---------------------------------------------------------------------
1429 /* The file is added to the queue */
1430 pkgAcqFile::pkgAcqFile(pkgAcquire
*Owner
,string URI
,string MD5
,
1431 unsigned long Size
,string Dsc
,string ShortDesc
) :
1432 Item(Owner
), Md5Hash(MD5
)
1434 Retries
= _config
->FindI("Acquire::Retries",0);
1436 DestFile
= flNotDir(URI
);
1440 Desc
.Description
= Dsc
;
1443 // Set the short description to the archive component
1444 Desc
.ShortDesc
= ShortDesc
;
1446 // Get the transfer sizes
1449 if (stat(DestFile
.c_str(),&Buf
) == 0)
1451 // Hmm, the partial file is too big, erase it
1452 if ((unsigned)Buf
.st_size
> Size
)
1453 unlink(DestFile
.c_str());
1455 PartialSize
= Buf
.st_size
;
1461 // AcqFile::Done - Item downloaded OK /*{{{*/
1462 // ---------------------------------------------------------------------
1464 void pkgAcqFile::Done(string Message
,unsigned long Size
,string MD5
,
1465 pkgAcquire::MethodConfig
*Cnf
)
1468 if (Md5Hash
.empty() == false && MD5
.empty() == false)
1473 ErrorText
= "MD5Sum mismatch";
1474 Rename(DestFile
,DestFile
+ ".FAILED");
1479 Item::Done(Message
,Size
,MD5
,Cnf
);
1481 string FileName
= LookupTag(Message
,"Filename");
1482 if (FileName
.empty() == true)
1485 ErrorText
= "Method gave a blank filename";
1491 // The files timestamp matches
1492 if (StringToBool(LookupTag(Message
,"IMS-Hit"),false) == true)
1495 // We have to copy it into place
1496 if (FileName
!= DestFile
)
1499 if (_config
->FindB("Acquire::Source-Symlinks",true) == false ||
1500 Cnf
->Removable
== true)
1502 Desc
.URI
= "copy:" + FileName
;
1507 // Erase the file if it is a symlink so we can overwrite it
1509 if (lstat(DestFile
.c_str(),&St
) == 0)
1511 if (S_ISLNK(St
.st_mode
) != 0)
1512 unlink(DestFile
.c_str());
1516 if (symlink(FileName
.c_str(),DestFile
.c_str()) != 0)
1518 ErrorText
= "Link to " + DestFile
+ " failure ";
1525 // AcqFile::Failed - Failure handler /*{{{*/
1526 // ---------------------------------------------------------------------
1527 /* Here we try other sources */
1528 void pkgAcqFile::Failed(string Message
,pkgAcquire::MethodConfig
*Cnf
)
1530 ErrorText
= LookupTag(Message
,"Message");
1532 // This is the retry counter
1534 Cnf
->LocalOnly
== false &&
1535 StringToBool(LookupTag(Message
,"Transient-Failure"),false) == true)
1542 Item::Failed(Message
,Cnf
);