]> git.saurik.com Git - apt.git/blob - apt-pkg/acquire-item.cc
use one 'store' method to rule all (de)compressors
[apt.git] / apt-pkg / acquire-item.cc
1 // -*- mode: cpp; mode: fold -*-
2 // Description /*{{{*/
3 // $Id: acquire-item.cc,v 1.46.2.9 2004/01/16 18:51:11 mdz Exp $
4 /* ######################################################################
5
6 Acquire Item - Item to acquire
7
8 Each item can download to exactly one file at a time. This means you
9 cannot create an item that fetches two uri's to two files at the same
10 time. The pkgAcqIndex class creates a second class upon instantiation
11 to fetch the other index files because of this.
12
13 ##################################################################### */
14 /*}}}*/
15 // Include Files /*{{{*/
16 #include <config.h>
17
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/tagfile.h>
26 #include <apt-pkg/metaindex.h>
27 #include <apt-pkg/acquire.h>
28 #include <apt-pkg/hashes.h>
29 #include <apt-pkg/indexfile.h>
30 #include <apt-pkg/pkgcache.h>
31 #include <apt-pkg/cacheiterators.h>
32 #include <apt-pkg/pkgrecords.h>
33 #include <apt-pkg/gpgv.h>
34
35 #include <algorithm>
36 #include <stddef.h>
37 #include <stdlib.h>
38 #include <string.h>
39 #include <iostream>
40 #include <vector>
41 #include <sys/stat.h>
42 #include <unistd.h>
43 #include <errno.h>
44 #include <string>
45 #include <stdio.h>
46 #include <ctime>
47 #include <sstream>
48
49 #include <apti18n.h>
50 /*}}}*/
51
52 using namespace std;
53
54 static void printHashSumComparision(std::string const &URI, HashStringList const &Expected, HashStringList const &Actual) /*{{{*/
55 {
56 if (_config->FindB("Debug::Acquire::HashSumMismatch", false) == false)
57 return;
58 std::cerr << std::endl << URI << ":" << std::endl << " Expected Hash: " << std::endl;
59 for (HashStringList::const_iterator hs = Expected.begin(); hs != Expected.end(); ++hs)
60 std::cerr << "\t- " << hs->toStr() << std::endl;
61 std::cerr << " Actual Hash: " << std::endl;
62 for (HashStringList::const_iterator hs = Actual.begin(); hs != Actual.end(); ++hs)
63 std::cerr << "\t- " << hs->toStr() << std::endl;
64 }
65 /*}}}*/
66 static std::string GetPartialFileName(std::string const &file) /*{{{*/
67 {
68 std::string DestFile = _config->FindDir("Dir::State::lists") + "partial/";
69 DestFile += file;
70 return DestFile;
71 }
72 /*}}}*/
73 static std::string GetPartialFileNameFromURI(std::string const &uri) /*{{{*/
74 {
75 return GetPartialFileName(URItoFileName(uri));
76 }
77 /*}}}*/
78 static std::string GetFinalFileNameFromURI(std::string const &uri) /*{{{*/
79 {
80 return _config->FindDir("Dir::State::lists") + URItoFileName(uri);
81 }
82 /*}}}*/
83 static std::string GetKeepCompressedFileName(std::string file, IndexTarget const &Target)/*{{{*/
84 {
85 if (Target.KeepCompressed == false)
86 return file;
87
88 std::string const CompressionTypes = Target.Option(IndexTarget::COMPRESSIONTYPES);
89 if (CompressionTypes.empty() == false)
90 {
91 std::string const ext = CompressionTypes.substr(0, CompressionTypes.find(' '));
92 if (ext != "uncompressed")
93 file.append(".").append(ext);
94 }
95 return file;
96 }
97 /*}}}*/
98 static std::string GetCompressedFileName(IndexTarget const &Target, std::string const &Name, std::string const &Ext) /*{{{*/
99 {
100 if (Ext.empty() || Ext == "uncompressed")
101 return Name;
102
103 // do not reverify cdrom sources as apt-cdrom may rewrite the Packages
104 // file when its doing the indexcopy
105 if (Target.URI.substr(0,6) == "cdrom:")
106 return Name;
107
108 // adjust DestFile if its compressed on disk
109 if (Target.KeepCompressed == true)
110 return Name + '.' + Ext;
111 return Name;
112 }
113 /*}}}*/
114 static std::string GetMergeDiffsPatchFileName(std::string const &Final, std::string const &Patch)/*{{{*/
115 {
116 // rred expects the patch as $FinalFile.ed.$patchname.gz
117 return Final + ".ed." + Patch + ".gz";
118 }
119 /*}}}*/
120 static std::string GetDiffsPatchFileName(std::string const &Final) /*{{{*/
121 {
122 // rred expects the patch as $FinalFile.ed
123 return Final + ".ed";
124 }
125 /*}}}*/
126 static bool BootstrapPDiffWith(std::string const &PartialFile, std::string const &FinalFile, IndexTarget const &Target)/*{{{*/
127 {
128 // patching needs to be bootstrapped with the 'old' version
129 std::vector<std::string> types = VectorizeString(Target.Option(IndexTarget::COMPRESSIONTYPES), ' ');
130 auto typeItr = types.cbegin();
131 for (; typeItr != types.cend(); ++typeItr)
132 {
133 std::string Final = FinalFile;
134 if (*typeItr != "uncompressed")
135 Final.append(".").append(*typeItr);
136 if (RealFileExists(Final) == false)
137 continue;
138 std::string Partial = PartialFile;
139 if (*typeItr != "uncompressed")
140 Partial.append(".").append(*typeItr);
141 if (FileExists(Partial.c_str()) == true)
142 return true;
143 if (symlink(Final.c_str(), Partial.c_str()) != 0)
144 return false;
145 break;
146 }
147 return typeItr != types.cend();
148 }
149 /*}}}*/
150
151 static bool MessageInsecureRepository(bool const isError, std::string const &msg)/*{{{*/
152 {
153 if (isError)
154 {
155 _error->Error("%s", msg.c_str());
156 _error->Notice("%s", _("Updating from such a repository can't be done securely, and is therefore disabled by default."));
157 }
158 else
159 {
160 _error->Warning("%s", msg.c_str());
161 _error->Notice("%s", _("Data from such a repository can't be authenticated and is therefore potentially dangerous to use."));
162 }
163 _error->Notice("%s", _("See apt-secure(8) manpage for repository creation and user configuration details."));
164 return false;
165 }
166 static bool MessageInsecureRepository(bool const isError, char const * const msg, std::string const &repo)
167 {
168 std::string m;
169 strprintf(m, msg, repo.c_str());
170 return MessageInsecureRepository(isError, m);
171 }
172 /*}}}*/
173 static bool AllowInsecureRepositories(char const * const msg, std::string const &repo,/*{{{*/
174 metaIndex const * const MetaIndexParser, pkgAcqMetaClearSig * const TransactionManager, pkgAcquire::Item * const I)
175 {
176 if(MetaIndexParser->GetTrusted() == metaIndex::TRI_YES)
177 return true;
178
179 if (_config->FindB("Acquire::AllowInsecureRepositories") == true)
180 {
181 MessageInsecureRepository(false, msg, repo);
182 return true;
183 }
184
185 MessageInsecureRepository(true, msg, repo);
186 TransactionManager->AbortTransaction();
187 I->Status = pkgAcquire::Item::StatError;
188 return false;
189 }
190 /*}}}*/
191 static HashStringList GetExpectedHashesFromFor(metaIndex * const Parser, std::string const &MetaKey)/*{{{*/
192 {
193 if (Parser == NULL)
194 return HashStringList();
195 metaIndex::checkSum * const R = Parser->Lookup(MetaKey);
196 if (R == NULL)
197 return HashStringList();
198 return R->Hashes;
199 }
200 /*}}}*/
201
202 // all ::HashesRequired and ::GetExpectedHashes implementations /*{{{*/
203 /* ::GetExpectedHashes is abstract and has to be implemented by all subclasses.
204 It is best to implement it as broadly as possible, while ::HashesRequired defaults
205 to true and should be as restrictive as possible for false cases. Note that if
206 a hash is returned by ::GetExpectedHashes it must match. Only if it doesn't
207 ::HashesRequired is called to evaluate if its okay to have no hashes. */
208 APT_CONST bool pkgAcqTransactionItem::HashesRequired() const
209 {
210 /* signed repositories obviously have a parser and good hashes.
211 unsigned repositories, too, as even if we can't trust them for security,
212 we can at least trust them for integrity of the download itself.
213 Only repositories without a Release file can (obviously) not have
214 hashes – and they are very uncommon and strongly discouraged */
215 return TransactionManager->MetaIndexParser != NULL &&
216 TransactionManager->MetaIndexParser->GetLoadedSuccessfully() == metaIndex::TRI_YES;
217 }
218 HashStringList pkgAcqTransactionItem::GetExpectedHashes() const
219 {
220 return GetExpectedHashesFor(GetMetaKey());
221 }
222
223 APT_CONST bool pkgAcqMetaBase::HashesRequired() const
224 {
225 // Release and co have no hashes 'by design'.
226 return false;
227 }
228 HashStringList pkgAcqMetaBase::GetExpectedHashes() const
229 {
230 return HashStringList();
231 }
232
233 APT_CONST bool pkgAcqIndexDiffs::HashesRequired() const
234 {
235 /* We don't always have the diff of the downloaded pdiff file.
236 What we have for sure is hashes for the uncompressed file,
237 but rred uncompresses them on the fly while parsing, so not handled here.
238 Hashes are (also) checked while searching for (next) patch to apply. */
239 if (State == StateFetchDiff)
240 return available_patches[0].download_hashes.empty() == false;
241 return false;
242 }
243 HashStringList pkgAcqIndexDiffs::GetExpectedHashes() const
244 {
245 if (State == StateFetchDiff)
246 return available_patches[0].download_hashes;
247 return HashStringList();
248 }
249
250 APT_CONST bool pkgAcqIndexMergeDiffs::HashesRequired() const
251 {
252 /* @see #pkgAcqIndexDiffs::HashesRequired, with the difference that
253 we can check the rred result after all patches are applied as
254 we know the expected result rather than potentially apply more patches */
255 if (State == StateFetchDiff)
256 return patch.download_hashes.empty() == false;
257 return State == StateApplyDiff;
258 }
259 HashStringList pkgAcqIndexMergeDiffs::GetExpectedHashes() const
260 {
261 if (State == StateFetchDiff)
262 return patch.download_hashes;
263 else if (State == StateApplyDiff)
264 return GetExpectedHashesFor(Target.MetaKey);
265 return HashStringList();
266 }
267
268 APT_CONST bool pkgAcqArchive::HashesRequired() const
269 {
270 return LocalSource == false;
271 }
272 HashStringList pkgAcqArchive::GetExpectedHashes() const
273 {
274 // figured out while parsing the records
275 return ExpectedHashes;
276 }
277
278 APT_CONST bool pkgAcqFile::HashesRequired() const
279 {
280 // supplied as parameter at creation time, so the caller decides
281 return ExpectedHashes.usable();
282 }
283 HashStringList pkgAcqFile::GetExpectedHashes() const
284 {
285 return ExpectedHashes;
286 }
287 /*}}}*/
288 // Acquire::Item::QueueURI and specialisations from child classes /*{{{*/
289 bool pkgAcquire::Item::QueueURI(pkgAcquire::ItemDesc &Item)
290 {
291 Owner->Enqueue(Item);
292 return true;
293 }
294 /* The idea here is that an item isn't queued if it exists on disk and the
295 transition manager was a hit as this means that the files it contains
296 the checksums for can't be updated either (or they are and we are asking
297 for a hashsum mismatch to happen which helps nobody) */
298 bool pkgAcqTransactionItem::QueueURI(pkgAcquire::ItemDesc &Item)
299 {
300 std::string const FinalFile = GetFinalFilename();
301 if (TransactionManager != NULL && TransactionManager->IMSHit == true &&
302 FileExists(FinalFile) == true)
303 {
304 PartialFile = DestFile = FinalFile;
305 Status = StatDone;
306 return false;
307 }
308 return pkgAcquire::Item::QueueURI(Item);
309 }
310 /* The transition manager InRelease itself (or its older sisters-in-law
311 Release & Release.gpg) is always queued as this allows us to rerun gpgv
312 on it to verify that we aren't stalled with old files */
313 bool pkgAcqMetaBase::QueueURI(pkgAcquire::ItemDesc &Item)
314 {
315 return pkgAcquire::Item::QueueURI(Item);
316 }
317 /* the Diff/Index needs to queue also the up-to-date complete index file
318 to ensure that the list cleaner isn't eating it */
319 bool pkgAcqDiffIndex::QueueURI(pkgAcquire::ItemDesc &Item)
320 {
321 if (pkgAcqTransactionItem::QueueURI(Item) == true)
322 return true;
323 QueueOnIMSHit();
324 return false;
325 }
326 /*}}}*/
327 // Acquire::Item::GetFinalFilename and specialisations for child classes /*{{{*/
328 std::string pkgAcquire::Item::GetFinalFilename() const
329 {
330 return GetFinalFileNameFromURI(Desc.URI);
331 }
332 std::string pkgAcqDiffIndex::GetFinalFilename() const
333 {
334 // the logic we inherent from pkgAcqBaseIndex isn't what we need here
335 return pkgAcquire::Item::GetFinalFilename();
336 }
337 std::string pkgAcqIndex::GetFinalFilename() const
338 {
339 std::string const FinalFile = GetFinalFileNameFromURI(Target.URI);
340 return GetCompressedFileName(Target, FinalFile, CurrentCompressionExtension);
341 }
342 std::string pkgAcqMetaSig::GetFinalFilename() const
343 {
344 return GetFinalFileNameFromURI(Target.URI);
345 }
346 std::string pkgAcqBaseIndex::GetFinalFilename() const
347 {
348 return GetFinalFileNameFromURI(Target.URI);
349 }
350 std::string pkgAcqMetaBase::GetFinalFilename() const
351 {
352 return GetFinalFileNameFromURI(Target.URI);
353 }
354 std::string pkgAcqArchive::GetFinalFilename() const
355 {
356 return _config->FindDir("Dir::Cache::Archives") + flNotDir(StoreFilename);
357 }
358 /*}}}*/
359 // pkgAcqTransactionItem::GetMetaKey and specialisations for child classes /*{{{*/
360 std::string pkgAcqTransactionItem::GetMetaKey() const
361 {
362 return Target.MetaKey;
363 }
364 std::string pkgAcqIndex::GetMetaKey() const
365 {
366 if (Stage == STAGE_DECOMPRESS_AND_VERIFY || CurrentCompressionExtension == "uncompressed")
367 return Target.MetaKey;
368 return Target.MetaKey + "." + CurrentCompressionExtension;
369 }
370 std::string pkgAcqDiffIndex::GetMetaKey() const
371 {
372 return Target.MetaKey + ".diff/Index";
373 }
374 /*}}}*/
375 //pkgAcqTransactionItem::TransactionState and specialisations for child classes /*{{{*/
376 bool pkgAcqTransactionItem::TransactionState(TransactionStates const state)
377 {
378 bool const Debug = _config->FindB("Debug::Acquire::Transaction", false);
379 switch(state)
380 {
381 case TransactionAbort:
382 if(Debug == true)
383 std::clog << " Cancel: " << DestFile << std::endl;
384 if (Status == pkgAcquire::Item::StatIdle)
385 {
386 Status = pkgAcquire::Item::StatDone;
387 Dequeue();
388 }
389 break;
390 case TransactionCommit:
391 if(PartialFile != "")
392 {
393 if(Debug == true)
394 std::clog << "mv " << PartialFile << " -> "<< DestFile << " # " << DescURI() << std::endl;
395
396 Rename(PartialFile, DestFile);
397 } else {
398 if(Debug == true)
399 std::clog << "rm " << DestFile << " # " << DescURI() << std::endl;
400 RemoveFile("TransactionCommit", DestFile);
401 }
402 break;
403 }
404 return true;
405 }
406 bool pkgAcqMetaBase::TransactionState(TransactionStates const state)
407 {
408 // Do not remove InRelease on IMSHit of Release.gpg [yes, this is very edgecasey]
409 if (TransactionManager->IMSHit == false)
410 return pkgAcqTransactionItem::TransactionState(state);
411 return true;
412 }
413 bool pkgAcqIndex::TransactionState(TransactionStates const state)
414 {
415 if (pkgAcqTransactionItem::TransactionState(state) == false)
416 return false;
417
418 switch (state)
419 {
420 case TransactionAbort:
421 if (Stage == STAGE_DECOMPRESS_AND_VERIFY)
422 {
423 // keep the compressed file, but drop the decompressed
424 EraseFileName.clear();
425 if (PartialFile.empty() == false && flExtension(PartialFile) != CurrentCompressionExtension)
426 RemoveFile("TransactionAbort", PartialFile);
427 }
428 break;
429 case TransactionCommit:
430 if (EraseFileName.empty() == false)
431 RemoveFile("TransactionCommit", EraseFileName);
432 break;
433 }
434 return true;
435 }
436 bool pkgAcqDiffIndex::TransactionState(TransactionStates const state)
437 {
438 if (pkgAcqTransactionItem::TransactionState(state) == false)
439 return false;
440
441 switch (state)
442 {
443 case TransactionCommit:
444 break;
445 case TransactionAbort:
446 std::string const Partial = GetPartialFileNameFromURI(Target.URI);
447 RemoveFile("TransactionAbort", Partial);
448 break;
449 }
450
451 return true;
452 }
453 /*}}}*/
454
455 class APT_HIDDEN NoActionItem : public pkgAcquire::Item /*{{{*/
456 /* The sole purpose of this class is having an item which does nothing to
457 reach its done state to prevent cleanup deleting the mentioned file.
458 Handy in cases in which we know we have the file already, like IMS-Hits. */
459 {
460 IndexTarget const Target;
461 public:
462 virtual std::string DescURI() const APT_OVERRIDE {return Target.URI;};
463 virtual HashStringList GetExpectedHashes() const APT_OVERRIDE {return HashStringList();};
464
465 NoActionItem(pkgAcquire * const Owner, IndexTarget const &Target) :
466 pkgAcquire::Item(Owner), Target(Target)
467 {
468 Status = StatDone;
469 DestFile = GetFinalFileNameFromURI(Target.URI);
470 }
471 NoActionItem(pkgAcquire * const Owner, IndexTarget const &Target, std::string const &FinalFile) :
472 pkgAcquire::Item(Owner), Target(Target)
473 {
474 Status = StatDone;
475 DestFile = FinalFile;
476 }
477 };
478 /*}}}*/
479
480 // Acquire::Item::Item - Constructor /*{{{*/
481 APT_IGNORE_DEPRECATED_PUSH
482 pkgAcquire::Item::Item(pkgAcquire * const owner) :
483 FileSize(0), PartialSize(0), Mode(0), ID(0), Complete(false), Local(false),
484 QueueCounter(0), ExpectedAdditionalItems(0), Owner(owner), d(NULL)
485 {
486 Owner->Add(this);
487 Status = StatIdle;
488 }
489 APT_IGNORE_DEPRECATED_POP
490 /*}}}*/
491 // Acquire::Item::~Item - Destructor /*{{{*/
492 pkgAcquire::Item::~Item()
493 {
494 Owner->Remove(this);
495 }
496 /*}}}*/
497 std::string pkgAcquire::Item::Custom600Headers() const /*{{{*/
498 {
499 return std::string();
500 }
501 /*}}}*/
502 std::string pkgAcquire::Item::ShortDesc() const /*{{{*/
503 {
504 return DescURI();
505 }
506 /*}}}*/
507 APT_CONST void pkgAcquire::Item::Finished() /*{{{*/
508 {
509 }
510 /*}}}*/
511 APT_PURE pkgAcquire * pkgAcquire::Item::GetOwner() const /*{{{*/
512 {
513 return Owner;
514 }
515 /*}}}*/
516 APT_CONST pkgAcquire::ItemDesc &pkgAcquire::Item::GetItemDesc() /*{{{*/
517 {
518 return Desc;
519 }
520 /*}}}*/
521 APT_CONST bool pkgAcquire::Item::IsTrusted() const /*{{{*/
522 {
523 return false;
524 }
525 /*}}}*/
526 // Acquire::Item::Failed - Item failed to download /*{{{*/
527 // ---------------------------------------------------------------------
528 /* We return to an idle state if there are still other queues that could
529 fetch this object */
530 void pkgAcquire::Item::Failed(string const &Message,pkgAcquire::MethodConfig const * const Cnf)
531 {
532 if(ErrorText.empty())
533 ErrorText = LookupTag(Message,"Message");
534 if (QueueCounter <= 1)
535 {
536 /* This indicates that the file is not available right now but might
537 be sometime later. If we do a retry cycle then this should be
538 retried [CDROMs] */
539 if (Cnf != NULL && Cnf->LocalOnly == true &&
540 StringToBool(LookupTag(Message,"Transient-Failure"),false) == true)
541 {
542 Status = StatIdle;
543 Dequeue();
544 return;
545 }
546
547 switch (Status)
548 {
549 case StatIdle:
550 case StatFetching:
551 case StatDone:
552 Status = StatError;
553 break;
554 case StatAuthError:
555 case StatError:
556 case StatTransientNetworkError:
557 break;
558 }
559 Complete = false;
560 Dequeue();
561 }
562
563 string const FailReason = LookupTag(Message, "FailReason");
564 if (FailReason == "MaximumSizeExceeded")
565 RenameOnError(MaximumSizeExceeded);
566 else if (Status == StatAuthError)
567 RenameOnError(HashSumMismatch);
568
569 // report mirror failure back to LP if we actually use a mirror
570 if (FailReason.empty() == false)
571 ReportMirrorFailure(FailReason);
572 else
573 ReportMirrorFailure(ErrorText);
574
575 if (QueueCounter > 1)
576 Status = StatIdle;
577 }
578 /*}}}*/
579 // Acquire::Item::Start - Item has begun to download /*{{{*/
580 // ---------------------------------------------------------------------
581 /* Stash status and the file size. Note that setting Complete means
582 sub-phases of the acquire process such as decompresion are operating */
583 void pkgAcquire::Item::Start(string const &/*Message*/, unsigned long long const Size)
584 {
585 Status = StatFetching;
586 ErrorText.clear();
587 if (FileSize == 0 && Complete == false)
588 FileSize = Size;
589 }
590 /*}}}*/
591 // Acquire::Item::VerifyDone - check if Item was downloaded OK /*{{{*/
592 /* Note that hash-verification is 'hardcoded' in acquire-worker and has
593 * already passed if this method is called. */
594 bool pkgAcquire::Item::VerifyDone(std::string const &Message,
595 pkgAcquire::MethodConfig const * const /*Cnf*/)
596 {
597 std::string const FileName = LookupTag(Message,"Filename");
598 if (FileName.empty() == true)
599 {
600 Status = StatError;
601 ErrorText = "Method gave a blank filename";
602 return false;
603 }
604
605 return true;
606 }
607 /*}}}*/
608 // Acquire::Item::Done - Item downloaded OK /*{{{*/
609 void pkgAcquire::Item::Done(string const &/*Message*/, HashStringList const &Hashes,
610 pkgAcquire::MethodConfig const * const /*Cnf*/)
611 {
612 // We just downloaded something..
613 if (FileSize == 0)
614 {
615 unsigned long long const downloadedSize = Hashes.FileSize();
616 if (downloadedSize != 0)
617 {
618 FileSize = downloadedSize;
619 }
620 }
621 Status = StatDone;
622 ErrorText = string();
623 Owner->Dequeue(this);
624 }
625 /*}}}*/
626 // Acquire::Item::Rename - Rename a file /*{{{*/
627 // ---------------------------------------------------------------------
628 /* This helper function is used by a lot of item methods as their final
629 step */
630 bool pkgAcquire::Item::Rename(string const &From,string const &To)
631 {
632 if (From == To || rename(From.c_str(),To.c_str()) == 0)
633 return true;
634
635 std::string S;
636 strprintf(S, _("rename failed, %s (%s -> %s)."), strerror(errno),
637 From.c_str(),To.c_str());
638 Status = StatError;
639 if (ErrorText.empty())
640 ErrorText = S;
641 else
642 ErrorText = ErrorText + ": " + S;
643 return false;
644 }
645 /*}}}*/
646 void pkgAcquire::Item::Dequeue() /*{{{*/
647 {
648 Owner->Dequeue(this);
649 }
650 /*}}}*/
651 bool pkgAcquire::Item::RenameOnError(pkgAcquire::Item::RenameOnErrorState const error)/*{{{*/
652 {
653 if (RealFileExists(DestFile))
654 Rename(DestFile, DestFile + ".FAILED");
655
656 std::string errtext;
657 switch (error)
658 {
659 case HashSumMismatch:
660 errtext = _("Hash Sum mismatch");
661 Status = StatAuthError;
662 ReportMirrorFailure("HashChecksumFailure");
663 break;
664 case SizeMismatch:
665 errtext = _("Size mismatch");
666 Status = StatAuthError;
667 ReportMirrorFailure("SizeFailure");
668 break;
669 case InvalidFormat:
670 errtext = _("Invalid file format");
671 Status = StatError;
672 // do not report as usually its not the mirrors fault, but Portal/Proxy
673 break;
674 case SignatureError:
675 errtext = _("Signature error");
676 Status = StatError;
677 break;
678 case NotClearsigned:
679 strprintf(errtext, _("Clearsigned file isn't valid, got '%s' (does the network require authentication?)"), "NOSPLIT");
680 Status = StatAuthError;
681 break;
682 case MaximumSizeExceeded:
683 // the method is expected to report a good error for this
684 Status = StatError;
685 break;
686 case PDiffError:
687 // no handling here, done by callers
688 break;
689 }
690 if (ErrorText.empty())
691 ErrorText = errtext;
692 return false;
693 }
694 /*}}}*/
695 void pkgAcquire::Item::SetActiveSubprocess(const std::string &subprocess)/*{{{*/
696 {
697 ActiveSubprocess = subprocess;
698 APT_IGNORE_DEPRECATED(Mode = ActiveSubprocess.c_str();)
699 }
700 /*}}}*/
701 // Acquire::Item::ReportMirrorFailure /*{{{*/
702 void pkgAcquire::Item::ReportMirrorFailure(string const &FailCode)
703 {
704 // we only act if a mirror was used at all
705 if(UsedMirror.empty())
706 return;
707 #if 0
708 std::cerr << "\nReportMirrorFailure: "
709 << UsedMirror
710 << " Uri: " << DescURI()
711 << " FailCode: "
712 << FailCode << std::endl;
713 #endif
714 string report = _config->Find("Methods::Mirror::ProblemReporting",
715 "/usr/lib/apt/apt-report-mirror-failure");
716 if(!FileExists(report))
717 return;
718
719 std::vector<char const*> Args;
720 Args.push_back(report.c_str());
721 Args.push_back(UsedMirror.c_str());
722 Args.push_back(DescURI().c_str());
723 Args.push_back(FailCode.c_str());
724 Args.push_back(NULL);
725
726 pid_t pid = ExecFork();
727 if(pid < 0)
728 {
729 _error->Error("ReportMirrorFailure Fork failed");
730 return;
731 }
732 else if(pid == 0)
733 {
734 execvp(Args[0], (char**)Args.data());
735 std::cerr << "Could not exec " << Args[0] << std::endl;
736 _exit(100);
737 }
738 if(!ExecWait(pid, "report-mirror-failure"))
739 {
740 _error->Warning("Couldn't report problem to '%s'",
741 _config->Find("Methods::Mirror::ProblemReporting").c_str());
742 }
743 }
744 /*}}}*/
745 std::string pkgAcquire::Item::HashSum() const /*{{{*/
746 {
747 HashStringList const hashes = GetExpectedHashes();
748 HashString const * const hs = hashes.find(NULL);
749 return hs != NULL ? hs->toStr() : "";
750 }
751 /*}}}*/
752
753 pkgAcqTransactionItem::pkgAcqTransactionItem(pkgAcquire * const Owner, /*{{{*/
754 pkgAcqMetaClearSig * const transactionManager, IndexTarget const &target) :
755 pkgAcquire::Item(Owner), d(NULL), Target(target), TransactionManager(transactionManager)
756 {
757 if (TransactionManager != this)
758 TransactionManager->Add(this);
759 }
760 /*}}}*/
761 pkgAcqTransactionItem::~pkgAcqTransactionItem() /*{{{*/
762 {
763 }
764 /*}}}*/
765 HashStringList pkgAcqTransactionItem::GetExpectedHashesFor(std::string const &MetaKey) const /*{{{*/
766 {
767 return GetExpectedHashesFromFor(TransactionManager->MetaIndexParser, MetaKey);
768 }
769 /*}}}*/
770
771 // AcqMetaBase - Constructor /*{{{*/
772 pkgAcqMetaBase::pkgAcqMetaBase(pkgAcquire * const Owner,
773 pkgAcqMetaClearSig * const TransactionManager,
774 std::vector<IndexTarget> const &IndexTargets,
775 IndexTarget const &DataTarget)
776 : pkgAcqTransactionItem(Owner, TransactionManager, DataTarget), d(NULL),
777 IndexTargets(IndexTargets),
778 AuthPass(false), IMSHit(false)
779 {
780 }
781 /*}}}*/
782 // AcqMetaBase::Add - Add a item to the current Transaction /*{{{*/
783 void pkgAcqMetaBase::Add(pkgAcqTransactionItem * const I)
784 {
785 Transaction.push_back(I);
786 }
787 /*}}}*/
788 // AcqMetaBase::AbortTransaction - Abort the current Transaction /*{{{*/
789 void pkgAcqMetaBase::AbortTransaction()
790 {
791 if(_config->FindB("Debug::Acquire::Transaction", false) == true)
792 std::clog << "AbortTransaction: " << TransactionManager << std::endl;
793
794 // ensure the toplevel is in error state too
795 for (std::vector<pkgAcqTransactionItem*>::iterator I = Transaction.begin();
796 I != Transaction.end(); ++I)
797 {
798 (*I)->TransactionState(TransactionAbort);
799 }
800 Transaction.clear();
801 }
802 /*}}}*/
803 // AcqMetaBase::TransactionHasError - Check for errors in Transaction /*{{{*/
804 APT_PURE bool pkgAcqMetaBase::TransactionHasError() const
805 {
806 for (std::vector<pkgAcqTransactionItem*>::const_iterator I = Transaction.begin();
807 I != Transaction.end(); ++I)
808 {
809 switch((*I)->Status) {
810 case StatDone: break;
811 case StatIdle: break;
812 case StatAuthError: return true;
813 case StatError: return true;
814 case StatTransientNetworkError: return true;
815 case StatFetching: break;
816 }
817 }
818 return false;
819 }
820 /*}}}*/
821 // AcqMetaBase::CommitTransaction - Commit a transaction /*{{{*/
822 void pkgAcqMetaBase::CommitTransaction()
823 {
824 if(_config->FindB("Debug::Acquire::Transaction", false) == true)
825 std::clog << "CommitTransaction: " << this << std::endl;
826
827 // move new files into place *and* remove files that are not
828 // part of the transaction but are still on disk
829 for (std::vector<pkgAcqTransactionItem*>::iterator I = Transaction.begin();
830 I != Transaction.end(); ++I)
831 {
832 (*I)->TransactionState(TransactionCommit);
833 }
834 Transaction.clear();
835 }
836 /*}}}*/
837 // AcqMetaBase::TransactionStageCopy - Stage a file for copying /*{{{*/
838 void pkgAcqMetaBase::TransactionStageCopy(pkgAcqTransactionItem * const I,
839 const std::string &From,
840 const std::string &To)
841 {
842 I->PartialFile = From;
843 I->DestFile = To;
844 }
845 /*}}}*/
846 // AcqMetaBase::TransactionStageRemoval - Stage a file for removal /*{{{*/
847 void pkgAcqMetaBase::TransactionStageRemoval(pkgAcqTransactionItem * const I,
848 const std::string &FinalFile)
849 {
850 I->PartialFile = "";
851 I->DestFile = FinalFile;
852 }
853 /*}}}*/
854 // AcqMetaBase::GenerateAuthWarning - Check gpg authentication error /*{{{*/
855 bool pkgAcqMetaBase::CheckStopAuthentication(pkgAcquire::Item * const I, const std::string &Message)
856 {
857 // FIXME: this entire function can do now that we disallow going to
858 // a unauthenticated state and can cleanly rollback
859
860 string const Final = I->GetFinalFilename();
861 if(FileExists(Final))
862 {
863 I->Status = StatTransientNetworkError;
864 _error->Warning(_("An error occurred during the signature "
865 "verification. The repository is not updated "
866 "and the previous index files will be used. "
867 "GPG error: %s: %s"),
868 Desc.Description.c_str(),
869 LookupTag(Message,"Message").c_str());
870 RunScripts("APT::Update::Auth-Failure");
871 return true;
872 } else if (LookupTag(Message,"Message").find("NODATA") != string::npos) {
873 /* Invalid signature file, reject (LP: #346386) (Closes: #627642) */
874 _error->Error(_("GPG error: %s: %s"),
875 Desc.Description.c_str(),
876 LookupTag(Message,"Message").c_str());
877 I->Status = StatAuthError;
878 return true;
879 } else {
880 _error->Warning(_("GPG error: %s: %s"),
881 Desc.Description.c_str(),
882 LookupTag(Message,"Message").c_str());
883 }
884 // gpgv method failed
885 ReportMirrorFailure("GPGFailure");
886 return false;
887 }
888 /*}}}*/
889 // AcqMetaBase::Custom600Headers - Get header for AcqMetaBase /*{{{*/
890 // ---------------------------------------------------------------------
891 string pkgAcqMetaBase::Custom600Headers() const
892 {
893 std::string Header = "\nIndex-File: true";
894 std::string MaximumSize;
895 strprintf(MaximumSize, "\nMaximum-Size: %i",
896 _config->FindI("Acquire::MaxReleaseFileSize", 10*1000*1000));
897 Header += MaximumSize;
898
899 string const FinalFile = GetFinalFilename();
900 struct stat Buf;
901 if (stat(FinalFile.c_str(),&Buf) == 0)
902 Header += "\nLast-Modified: " + TimeRFC1123(Buf.st_mtime);
903
904 return Header;
905 }
906 /*}}}*/
907 // AcqMetaBase::QueueForSignatureVerify /*{{{*/
908 void pkgAcqMetaBase::QueueForSignatureVerify(pkgAcqTransactionItem * const I, std::string const &File, std::string const &Signature)
909 {
910 AuthPass = true;
911 I->Desc.URI = "gpgv:" + Signature;
912 I->DestFile = File;
913 QueueURI(I->Desc);
914 I->SetActiveSubprocess("gpgv");
915 }
916 /*}}}*/
917 // AcqMetaBase::CheckDownloadDone /*{{{*/
918 bool pkgAcqMetaBase::CheckDownloadDone(pkgAcqTransactionItem * const I, const std::string &Message, HashStringList const &Hashes) const
919 {
920 // We have just finished downloading a Release file (it is not
921 // verified yet)
922
923 std::string const FileName = LookupTag(Message,"Filename");
924 if (FileName != I->DestFile && RealFileExists(I->DestFile) == false)
925 {
926 I->Local = true;
927 I->Desc.URI = "copy:" + FileName;
928 I->QueueURI(I->Desc);
929 return false;
930 }
931
932 // make sure to verify against the right file on I-M-S hit
933 bool IMSHit = StringToBool(LookupTag(Message,"IMS-Hit"), false);
934 if (IMSHit == false && Hashes.usable())
935 {
936 // detect IMS-Hits servers haven't detected by Hash comparison
937 std::string const FinalFile = I->GetFinalFilename();
938 if (RealFileExists(FinalFile) && Hashes.VerifyFile(FinalFile) == true)
939 {
940 IMSHit = true;
941 RemoveFile("CheckDownloadDone", I->DestFile);
942 }
943 }
944
945 if(IMSHit == true)
946 {
947 // for simplicity, the transaction manager is always InRelease
948 // even if it doesn't exist.
949 if (TransactionManager != NULL)
950 TransactionManager->IMSHit = true;
951 I->PartialFile = I->DestFile = I->GetFinalFilename();
952 }
953
954 // set Item to complete as the remaining work is all local (verify etc)
955 I->Complete = true;
956
957 return true;
958 }
959 /*}}}*/
960 bool pkgAcqMetaBase::CheckAuthDone(string const &Message) /*{{{*/
961 {
962 // At this point, the gpgv method has succeeded, so there is a
963 // valid signature from a key in the trusted keyring. We
964 // perform additional verification of its contents, and use them
965 // to verify the indexes we are about to download
966
967 if (TransactionManager->IMSHit == false)
968 {
969 // open the last (In)Release if we have it
970 std::string const FinalFile = GetFinalFilename();
971 std::string FinalRelease;
972 std::string FinalInRelease;
973 if (APT::String::Endswith(FinalFile, "InRelease"))
974 {
975 FinalInRelease = FinalFile;
976 FinalRelease = FinalFile.substr(0, FinalFile.length() - strlen("InRelease")) + "Release";
977 }
978 else
979 {
980 FinalInRelease = FinalFile.substr(0, FinalFile.length() - strlen("Release")) + "InRelease";
981 FinalRelease = FinalFile;
982 }
983 if (RealFileExists(FinalInRelease) || RealFileExists(FinalRelease))
984 {
985 TransactionManager->LastMetaIndexParser = TransactionManager->MetaIndexParser->UnloadedClone();
986 if (TransactionManager->LastMetaIndexParser != NULL)
987 {
988 _error->PushToStack();
989 if (RealFileExists(FinalInRelease))
990 TransactionManager->LastMetaIndexParser->Load(FinalInRelease, NULL);
991 else
992 TransactionManager->LastMetaIndexParser->Load(FinalRelease, NULL);
993 // its unlikely to happen, but if what we have is bad ignore it
994 if (_error->PendingError())
995 {
996 delete TransactionManager->LastMetaIndexParser;
997 TransactionManager->LastMetaIndexParser = NULL;
998 }
999 _error->RevertToStack();
1000 }
1001 }
1002 }
1003
1004 if (TransactionManager->MetaIndexParser->Load(DestFile, &ErrorText) == false)
1005 {
1006 Status = StatAuthError;
1007 return false;
1008 }
1009
1010 if (!VerifyVendor(Message))
1011 {
1012 Status = StatAuthError;
1013 return false;
1014 }
1015
1016 if (_config->FindB("Debug::pkgAcquire::Auth", false))
1017 std::cerr << "Signature verification succeeded: "
1018 << DestFile << std::endl;
1019
1020 // Download further indexes with verification
1021 QueueIndexes(true);
1022
1023 return true;
1024 }
1025 /*}}}*/
1026 void pkgAcqMetaBase::QueueIndexes(bool const verify) /*{{{*/
1027 {
1028 // at this point the real Items are loaded in the fetcher
1029 ExpectedAdditionalItems = 0;
1030
1031 bool metaBaseSupportsByHash = false;
1032 if (TransactionManager != NULL && TransactionManager->MetaIndexParser != NULL)
1033 metaBaseSupportsByHash = TransactionManager->MetaIndexParser->GetSupportsAcquireByHash();
1034
1035 for (std::vector <IndexTarget>::iterator Target = IndexTargets.begin();
1036 Target != IndexTargets.end();
1037 ++Target)
1038 {
1039 // all is an implementation detail. Users shouldn't use this as arch
1040 // We need this support trickery here as e.g. Debian has binary-all files already,
1041 // but arch:all packages are still in the arch:any files, so we would waste precious
1042 // download time, bandwidth and diskspace for nothing, BUT Debian doesn't feature all
1043 // in the set of supported architectures, so we can filter based on this property rather
1044 // than invent an entirely new flag we would need to carry for all of eternity.
1045 if (Target->Option(IndexTarget::ARCHITECTURE) == "all")
1046 {
1047 if (TransactionManager->MetaIndexParser->IsArchitectureSupported("all") == false)
1048 continue;
1049 if (TransactionManager->MetaIndexParser->IsArchitectureAllSupportedFor(*Target) == false)
1050 continue;
1051 }
1052
1053 bool trypdiff = Target->OptionBool(IndexTarget::PDIFFS);
1054 if (verify == true)
1055 {
1056 if (TransactionManager->MetaIndexParser->Exists(Target->MetaKey) == false)
1057 {
1058 // optional targets that we do not have in the Release file are skipped
1059 if (Target->IsOptional)
1060 continue;
1061
1062 std::string const &arch = Target->Option(IndexTarget::ARCHITECTURE);
1063 if (arch.empty() == false)
1064 {
1065 if (TransactionManager->MetaIndexParser->IsArchitectureSupported(arch) == false)
1066 {
1067 _error->Notice(_("Skipping acquire of configured file '%s' as repository '%s' doesn't support architecture '%s'"),
1068 Target->MetaKey.c_str(), TransactionManager->Target.Description.c_str(), arch.c_str());
1069 continue;
1070 }
1071 // if the architecture is officially supported but currently no packages for it available,
1072 // ignore silently as this is pretty much the same as just shipping an empty file.
1073 // if we don't know which architectures are supported, we do NOT ignore it to notify user about this
1074 if (TransactionManager->MetaIndexParser->IsArchitectureSupported("*undefined*") == false)
1075 continue;
1076 }
1077
1078 Status = StatAuthError;
1079 strprintf(ErrorText, _("Unable to find expected entry '%s' in Release file (Wrong sources.list entry or malformed file)"), Target->MetaKey.c_str());
1080 return;
1081 }
1082 else
1083 {
1084 auto const hashes = GetExpectedHashesFor(Target->MetaKey);
1085 if (hashes.usable() == false && hashes.empty() == false)
1086 {
1087 _error->Warning(_("Skipping acquire of configured file '%s' as repository '%s' provides only weak security information for it"),
1088 Target->MetaKey.c_str(), TransactionManager->Target.Description.c_str());
1089 continue;
1090 }
1091 }
1092
1093 // autoselect the compression method
1094 std::vector<std::string> types = VectorizeString(Target->Option(IndexTarget::COMPRESSIONTYPES), ' ');
1095 types.erase(std::remove_if(types.begin(), types.end(), [&](std::string const &t) {
1096 if (t == "uncompressed")
1097 return TransactionManager->MetaIndexParser->Exists(Target->MetaKey) == false;
1098 std::string const MetaKey = Target->MetaKey + "." + t;
1099 return TransactionManager->MetaIndexParser->Exists(MetaKey) == false;
1100 }), types.end());
1101 if (types.empty() == false)
1102 {
1103 std::ostringstream os;
1104 // add the special compressiontype byhash first if supported
1105 std::string const useByHashConf = Target->Option(IndexTarget::BY_HASH);
1106 bool useByHash = false;
1107 if(useByHashConf == "force")
1108 useByHash = true;
1109 else
1110 useByHash = StringToBool(useByHashConf) == true && metaBaseSupportsByHash;
1111 if (useByHash == true)
1112 os << "by-hash ";
1113 std::copy(types.begin(), types.end()-1, std::ostream_iterator<std::string>(os, " "));
1114 os << *types.rbegin();
1115 Target->Options["COMPRESSIONTYPES"] = os.str();
1116 }
1117 else
1118 Target->Options["COMPRESSIONTYPES"].clear();
1119
1120 std::string filename = GetFinalFileNameFromURI(Target->URI);
1121 if (RealFileExists(filename) == false)
1122 {
1123 if (Target->KeepCompressed)
1124 {
1125 filename = GetKeepCompressedFileName(filename, *Target);
1126 if (RealFileExists(filename) == false)
1127 filename.clear();
1128 }
1129 else
1130 filename.clear();
1131 }
1132
1133 if (filename.empty() == false)
1134 {
1135 // if the Release file is a hit and we have an index it must be the current one
1136 if (TransactionManager->IMSHit == true)
1137 ;
1138 else if (TransactionManager->LastMetaIndexParser != NULL)
1139 {
1140 // see if the file changed since the last Release file
1141 // we use the uncompressed files as we might compress differently compared to the server,
1142 // so the hashes might not match, even if they contain the same data.
1143 HashStringList const newFile = GetExpectedHashesFromFor(TransactionManager->MetaIndexParser, Target->MetaKey);
1144 HashStringList const oldFile = GetExpectedHashesFromFor(TransactionManager->LastMetaIndexParser, Target->MetaKey);
1145 if (newFile != oldFile)
1146 filename.clear();
1147 }
1148 else
1149 filename.clear();
1150 }
1151 else
1152 trypdiff = false; // no file to patch
1153
1154 if (filename.empty() == false)
1155 {
1156 new NoActionItem(Owner, *Target, filename);
1157 std::string const idxfilename = GetFinalFileNameFromURI(Target->URI + ".diff/Index");
1158 if (FileExists(idxfilename))
1159 new NoActionItem(Owner, *Target, idxfilename);
1160 continue;
1161 }
1162
1163 // check if we have patches available
1164 trypdiff &= TransactionManager->MetaIndexParser->Exists(Target->MetaKey + ".diff/Index");
1165 }
1166 else
1167 {
1168 // if we have no file to patch, no point in trying
1169 std::string filename = GetFinalFileNameFromURI(Target->URI);
1170 if (RealFileExists(filename) == false)
1171 {
1172 if (Target->KeepCompressed)
1173 {
1174 filename = GetKeepCompressedFileName(filename, *Target);
1175 if (RealFileExists(filename) == false)
1176 filename.clear();
1177 }
1178 else
1179 filename.clear();
1180 }
1181 trypdiff &= (filename.empty() == false);
1182 }
1183
1184 // no point in patching from local sources
1185 if (trypdiff)
1186 {
1187 std::string const proto = Target->URI.substr(0, strlen("file:/"));
1188 if (proto == "file:/" || proto == "copy:/" || proto == "cdrom:")
1189 trypdiff = false;
1190 }
1191
1192 // Queue the Index file (Packages, Sources, Translation-$foo, …)
1193 if (trypdiff)
1194 new pkgAcqDiffIndex(Owner, TransactionManager, *Target);
1195 else
1196 new pkgAcqIndex(Owner, TransactionManager, *Target);
1197 }
1198 }
1199 /*}}}*/
1200 bool pkgAcqMetaBase::VerifyVendor(string const &Message) /*{{{*/
1201 {
1202 string::size_type pos;
1203
1204 // check for missing sigs (that where not fatal because otherwise we had
1205 // bombed earlier)
1206 string missingkeys;
1207 string msg = _("There is no public key available for the "
1208 "following key IDs:\n");
1209 pos = Message.find("NO_PUBKEY ");
1210 if (pos != std::string::npos)
1211 {
1212 string::size_type start = pos+strlen("NO_PUBKEY ");
1213 string Fingerprint = Message.substr(start, Message.find("\n")-start);
1214 missingkeys += (Fingerprint);
1215 }
1216 if(!missingkeys.empty())
1217 _error->Warning("%s", (msg + missingkeys).c_str());
1218
1219 string Transformed = TransactionManager->MetaIndexParser->GetExpectedDist();
1220
1221 if (Transformed == "../project/experimental")
1222 {
1223 Transformed = "experimental";
1224 }
1225
1226 pos = Transformed.rfind('/');
1227 if (pos != string::npos)
1228 {
1229 Transformed = Transformed.substr(0, pos);
1230 }
1231
1232 if (Transformed == ".")
1233 {
1234 Transformed = "";
1235 }
1236
1237 if (TransactionManager->MetaIndexParser->GetValidUntil() > 0)
1238 {
1239 time_t const invalid_since = time(NULL) - TransactionManager->MetaIndexParser->GetValidUntil();
1240 if (invalid_since > 0)
1241 {
1242 std::string errmsg;
1243 strprintf(errmsg,
1244 // TRANSLATOR: The first %s is the URL of the bad Release file, the second is
1245 // the time since then the file is invalid - formatted in the same way as in
1246 // the download progress display (e.g. 7d 3h 42min 1s)
1247 _("Release file for %s is expired (invalid since %s). "
1248 "Updates for this repository will not be applied."),
1249 Target.URI.c_str(), TimeToStr(invalid_since).c_str());
1250 if (ErrorText.empty())
1251 ErrorText = errmsg;
1252 return _error->Error("%s", errmsg.c_str());
1253 }
1254 }
1255
1256 /* Did we get a file older than what we have? This is a last minute IMS hit and doubles
1257 as a prevention of downgrading us to older (still valid) files */
1258 if (TransactionManager->IMSHit == false && TransactionManager->LastMetaIndexParser != NULL &&
1259 TransactionManager->LastMetaIndexParser->GetDate() > TransactionManager->MetaIndexParser->GetDate())
1260 {
1261 TransactionManager->IMSHit = true;
1262 RemoveFile("VerifyVendor", DestFile);
1263 PartialFile = DestFile = GetFinalFilename();
1264 // load the 'old' file in the 'new' one instead of flipping pointers as
1265 // the new one isn't owned by us, while the old one is so cleanup would be confused.
1266 TransactionManager->MetaIndexParser->swapLoad(TransactionManager->LastMetaIndexParser);
1267 delete TransactionManager->LastMetaIndexParser;
1268 TransactionManager->LastMetaIndexParser = NULL;
1269 }
1270
1271 if (_config->FindB("Debug::pkgAcquire::Auth", false))
1272 {
1273 std::cerr << "Got Codename: " << TransactionManager->MetaIndexParser->GetCodename() << std::endl;
1274 std::cerr << "Expecting Dist: " << TransactionManager->MetaIndexParser->GetExpectedDist() << std::endl;
1275 std::cerr << "Transformed Dist: " << Transformed << std::endl;
1276 }
1277
1278 if (TransactionManager->MetaIndexParser->CheckDist(Transformed) == false)
1279 {
1280 // This might become fatal one day
1281 // Status = StatAuthError;
1282 // ErrorText = "Conflicting distribution; expected "
1283 // + MetaIndexParser->GetExpectedDist() + " but got "
1284 // + MetaIndexParser->GetCodename();
1285 // return false;
1286 if (!Transformed.empty())
1287 {
1288 _error->Warning(_("Conflicting distribution: %s (expected %s but got %s)"),
1289 Desc.Description.c_str(),
1290 Transformed.c_str(),
1291 TransactionManager->MetaIndexParser->GetCodename().c_str());
1292 }
1293 }
1294
1295 return true;
1296 }
1297 /*}}}*/
1298 pkgAcqMetaBase::~pkgAcqMetaBase()
1299 {
1300 }
1301
1302 pkgAcqMetaClearSig::pkgAcqMetaClearSig(pkgAcquire * const Owner, /*{{{*/
1303 IndexTarget const &ClearsignedTarget,
1304 IndexTarget const &DetachedDataTarget, IndexTarget const &DetachedSigTarget,
1305 std::vector<IndexTarget> const &IndexTargets,
1306 metaIndex * const MetaIndexParser) :
1307 pkgAcqMetaIndex(Owner, this, ClearsignedTarget, DetachedSigTarget, IndexTargets),
1308 d(NULL), ClearsignedTarget(ClearsignedTarget),
1309 DetachedDataTarget(DetachedDataTarget),
1310 MetaIndexParser(MetaIndexParser), LastMetaIndexParser(NULL)
1311 {
1312 // index targets + (worst case:) Release/Release.gpg
1313 ExpectedAdditionalItems = IndexTargets.size() + 2;
1314 TransactionManager->Add(this);
1315 }
1316 /*}}}*/
1317 pkgAcqMetaClearSig::~pkgAcqMetaClearSig() /*{{{*/
1318 {
1319 if (LastMetaIndexParser != NULL)
1320 delete LastMetaIndexParser;
1321 }
1322 /*}}}*/
1323 // pkgAcqMetaClearSig::Custom600Headers - Insert custom request headers /*{{{*/
1324 string pkgAcqMetaClearSig::Custom600Headers() const
1325 {
1326 string Header = pkgAcqMetaBase::Custom600Headers();
1327 Header += "\nFail-Ignore: true";
1328 std::string const key = TransactionManager->MetaIndexParser->GetSignedBy();
1329 if (key.empty() == false)
1330 Header += "\nSigned-By: " + key;
1331
1332 return Header;
1333 }
1334 /*}}}*/
1335 bool pkgAcqMetaClearSig::VerifyDone(std::string const &Message, /*{{{*/
1336 pkgAcquire::MethodConfig const * const Cnf)
1337 {
1338 Item::VerifyDone(Message, Cnf);
1339
1340 if (FileExists(DestFile) && !StartsWithGPGClearTextSignature(DestFile))
1341 return RenameOnError(NotClearsigned);
1342
1343 return true;
1344 }
1345 /*}}}*/
1346 // pkgAcqMetaClearSig::Done - We got a file /*{{{*/
1347 void pkgAcqMetaClearSig::Done(std::string const &Message,
1348 HashStringList const &Hashes,
1349 pkgAcquire::MethodConfig const * const Cnf)
1350 {
1351 Item::Done(Message, Hashes, Cnf);
1352
1353 if(AuthPass == false)
1354 {
1355 if(CheckDownloadDone(this, Message, Hashes) == true)
1356 QueueForSignatureVerify(this, DestFile, DestFile);
1357 return;
1358 }
1359 else if(CheckAuthDone(Message) == true)
1360 {
1361 if (TransactionManager->IMSHit == false)
1362 TransactionManager->TransactionStageCopy(this, DestFile, GetFinalFilename());
1363 else if (RealFileExists(GetFinalFilename()) == false)
1364 {
1365 // We got an InRelease file IMSHit, but we haven't one, which means
1366 // we had a valid Release/Release.gpg combo stepping in, which we have
1367 // to 'acquire' now to ensure list cleanup isn't removing them
1368 new NoActionItem(Owner, DetachedDataTarget);
1369 new NoActionItem(Owner, DetachedSigTarget);
1370 }
1371 }
1372 }
1373 /*}}}*/
1374 void pkgAcqMetaClearSig::Failed(string const &Message,pkgAcquire::MethodConfig const * const Cnf) /*{{{*/
1375 {
1376 Item::Failed(Message, Cnf);
1377
1378 // we failed, we will not get additional items from this method
1379 ExpectedAdditionalItems = 0;
1380
1381 if (AuthPass == false)
1382 {
1383 if (Status == StatAuthError || Status == StatTransientNetworkError)
1384 {
1385 // if we expected a ClearTextSignature (InRelease) but got a network
1386 // error or got a file, but it wasn't valid, we end up here (see VerifyDone).
1387 // As these is usually called by web-portals we do not try Release/Release.gpg
1388 // as this is gonna fail anyway and instead abort our try (LP#346386)
1389 TransactionManager->AbortTransaction();
1390 return;
1391 }
1392
1393 // Queue the 'old' InRelease file for removal if we try Release.gpg
1394 // as otherwise the file will stay around and gives a false-auth
1395 // impression (CVE-2012-0214)
1396 TransactionManager->TransactionStageRemoval(this, GetFinalFilename());
1397 Status = StatDone;
1398
1399 new pkgAcqMetaIndex(Owner, TransactionManager, DetachedDataTarget, DetachedSigTarget, IndexTargets);
1400 }
1401 else
1402 {
1403 if(CheckStopAuthentication(this, Message))
1404 return;
1405
1406 // No Release file was present, or verification failed, so fall
1407 // back to queueing Packages files without verification
1408 // only allow going further if the user explicitly wants it
1409 if(AllowInsecureRepositories(_("The repository '%s' is not signed."), ClearsignedTarget.Description, TransactionManager->MetaIndexParser, TransactionManager, this) == true)
1410 {
1411 Status = StatDone;
1412
1413 /* InRelease files become Release files, otherwise
1414 * they would be considered as trusted later on */
1415 string const FinalRelease = GetFinalFileNameFromURI(DetachedDataTarget.URI);
1416 string const PartialRelease = GetPartialFileNameFromURI(DetachedDataTarget.URI);
1417 string const FinalReleasegpg = GetFinalFileNameFromURI(DetachedSigTarget.URI);
1418 string const FinalInRelease = GetFinalFilename();
1419 Rename(DestFile, PartialRelease);
1420 TransactionManager->TransactionStageCopy(this, PartialRelease, FinalRelease);
1421
1422 if (RealFileExists(FinalReleasegpg) || RealFileExists(FinalInRelease))
1423 {
1424 // open the last Release if we have it
1425 if (TransactionManager->IMSHit == false)
1426 {
1427 TransactionManager->LastMetaIndexParser = TransactionManager->MetaIndexParser->UnloadedClone();
1428 if (TransactionManager->LastMetaIndexParser != NULL)
1429 {
1430 _error->PushToStack();
1431 if (RealFileExists(FinalInRelease))
1432 TransactionManager->LastMetaIndexParser->Load(FinalInRelease, NULL);
1433 else
1434 TransactionManager->LastMetaIndexParser->Load(FinalRelease, NULL);
1435 // its unlikely to happen, but if what we have is bad ignore it
1436 if (_error->PendingError())
1437 {
1438 delete TransactionManager->LastMetaIndexParser;
1439 TransactionManager->LastMetaIndexParser = NULL;
1440 }
1441 _error->RevertToStack();
1442 }
1443 }
1444 }
1445
1446 // we parse the indexes here because at this point the user wanted
1447 // a repository that may potentially harm him
1448 if (TransactionManager->MetaIndexParser->Load(PartialRelease, &ErrorText) == false || VerifyVendor(Message) == false)
1449 /* expired Release files are still a problem you need extra force for */;
1450 else
1451 QueueIndexes(true);
1452 }
1453 }
1454 }
1455 /*}}}*/
1456
1457 pkgAcqMetaIndex::pkgAcqMetaIndex(pkgAcquire * const Owner, /*{{{*/
1458 pkgAcqMetaClearSig * const TransactionManager,
1459 IndexTarget const &DataTarget,
1460 IndexTarget const &DetachedSigTarget,
1461 vector<IndexTarget> const &IndexTargets) :
1462 pkgAcqMetaBase(Owner, TransactionManager, IndexTargets, DataTarget), d(NULL),
1463 DetachedSigTarget(DetachedSigTarget)
1464 {
1465 if(_config->FindB("Debug::Acquire::Transaction", false) == true)
1466 std::clog << "New pkgAcqMetaIndex with TransactionManager "
1467 << this->TransactionManager << std::endl;
1468
1469 DestFile = GetPartialFileNameFromURI(DataTarget.URI);
1470
1471 // Create the item
1472 Desc.Description = DataTarget.Description;
1473 Desc.Owner = this;
1474 Desc.ShortDesc = DataTarget.ShortDesc;
1475 Desc.URI = DataTarget.URI;
1476
1477 // we expect more item
1478 ExpectedAdditionalItems = IndexTargets.size();
1479 QueueURI(Desc);
1480 }
1481 /*}}}*/
1482 void pkgAcqMetaIndex::Done(string const &Message, /*{{{*/
1483 HashStringList const &Hashes,
1484 pkgAcquire::MethodConfig const * const Cfg)
1485 {
1486 Item::Done(Message,Hashes,Cfg);
1487
1488 if(CheckDownloadDone(this, Message, Hashes))
1489 {
1490 // we have a Release file, now download the Signature, all further
1491 // verify/queue for additional downloads will be done in the
1492 // pkgAcqMetaSig::Done() code
1493 new pkgAcqMetaSig(Owner, TransactionManager, DetachedSigTarget, this);
1494 }
1495 }
1496 /*}}}*/
1497 // pkgAcqMetaIndex::Failed - no Release file present /*{{{*/
1498 void pkgAcqMetaIndex::Failed(string const &Message,
1499 pkgAcquire::MethodConfig const * const Cnf)
1500 {
1501 pkgAcquire::Item::Failed(Message, Cnf);
1502 Status = StatDone;
1503
1504 // No Release file was present so fall
1505 // back to queueing Packages files without verification
1506 // only allow going further if the user explicitly wants it
1507 if(AllowInsecureRepositories(_("The repository '%s' does not have a Release file."), Target.Description, TransactionManager->MetaIndexParser, TransactionManager, this) == true)
1508 {
1509 // ensure old Release files are removed
1510 TransactionManager->TransactionStageRemoval(this, GetFinalFilename());
1511
1512 // queue without any kind of hashsum support
1513 QueueIndexes(false);
1514 }
1515 }
1516 /*}}}*/
1517 void pkgAcqMetaIndex::Finished() /*{{{*/
1518 {
1519 if(_config->FindB("Debug::Acquire::Transaction", false) == true)
1520 std::clog << "Finished: " << DestFile <<std::endl;
1521 if(TransactionManager != NULL &&
1522 TransactionManager->TransactionHasError() == false)
1523 TransactionManager->CommitTransaction();
1524 }
1525 /*}}}*/
1526 std::string pkgAcqMetaIndex::DescURI() const /*{{{*/
1527 {
1528 return Target.URI;
1529 }
1530 /*}}}*/
1531 pkgAcqMetaIndex::~pkgAcqMetaIndex() {}
1532
1533 // AcqMetaSig::AcqMetaSig - Constructor /*{{{*/
1534 pkgAcqMetaSig::pkgAcqMetaSig(pkgAcquire * const Owner,
1535 pkgAcqMetaClearSig * const TransactionManager,
1536 IndexTarget const &Target,
1537 pkgAcqMetaIndex * const MetaIndex) :
1538 pkgAcqTransactionItem(Owner, TransactionManager, Target), d(NULL), MetaIndex(MetaIndex)
1539 {
1540 DestFile = GetPartialFileNameFromURI(Target.URI);
1541
1542 // remove any partial downloaded sig-file in partial/.
1543 // it may confuse proxies and is too small to warrant a
1544 // partial download anyway
1545 RemoveFile("pkgAcqMetaSig", DestFile);
1546
1547 // set the TransactionManager
1548 if(_config->FindB("Debug::Acquire::Transaction", false) == true)
1549 std::clog << "New pkgAcqMetaSig with TransactionManager "
1550 << TransactionManager << std::endl;
1551
1552 // Create the item
1553 Desc.Description = Target.Description;
1554 Desc.Owner = this;
1555 Desc.ShortDesc = Target.ShortDesc;
1556 Desc.URI = Target.URI;
1557
1558 // If we got a hit for Release, we will get one for Release.gpg too (or obscure errors),
1559 // so we skip the download step and go instantly to verification
1560 if (TransactionManager->IMSHit == true && RealFileExists(GetFinalFilename()))
1561 {
1562 Complete = true;
1563 Status = StatDone;
1564 PartialFile = DestFile = GetFinalFilename();
1565 MetaIndexFileSignature = DestFile;
1566 MetaIndex->QueueForSignatureVerify(this, MetaIndex->DestFile, DestFile);
1567 }
1568 else
1569 QueueURI(Desc);
1570 }
1571 /*}}}*/
1572 pkgAcqMetaSig::~pkgAcqMetaSig() /*{{{*/
1573 {
1574 }
1575 /*}}}*/
1576 // pkgAcqMetaSig::Custom600Headers - Insert custom request headers /*{{{*/
1577 std::string pkgAcqMetaSig::Custom600Headers() const
1578 {
1579 std::string Header = pkgAcqTransactionItem::Custom600Headers();
1580 std::string const key = TransactionManager->MetaIndexParser->GetSignedBy();
1581 if (key.empty() == false)
1582 Header += "\nSigned-By: " + key;
1583 return Header;
1584 }
1585 /*}}}*/
1586 // AcqMetaSig::Done - The signature was downloaded/verified /*{{{*/
1587 void pkgAcqMetaSig::Done(string const &Message, HashStringList const &Hashes,
1588 pkgAcquire::MethodConfig const * const Cfg)
1589 {
1590 if (MetaIndexFileSignature.empty() == false)
1591 {
1592 DestFile = MetaIndexFileSignature;
1593 MetaIndexFileSignature.clear();
1594 }
1595 Item::Done(Message, Hashes, Cfg);
1596
1597 if(MetaIndex->AuthPass == false)
1598 {
1599 if(MetaIndex->CheckDownloadDone(this, Message, Hashes) == true)
1600 {
1601 // destfile will be modified to point to MetaIndexFile for the
1602 // gpgv method, so we need to save it here
1603 MetaIndexFileSignature = DestFile;
1604 MetaIndex->QueueForSignatureVerify(this, MetaIndex->DestFile, DestFile);
1605 }
1606 return;
1607 }
1608 else if(MetaIndex->CheckAuthDone(Message) == true)
1609 {
1610 if (TransactionManager->IMSHit == false)
1611 {
1612 TransactionManager->TransactionStageCopy(this, DestFile, GetFinalFilename());
1613 TransactionManager->TransactionStageCopy(MetaIndex, MetaIndex->DestFile, MetaIndex->GetFinalFilename());
1614 }
1615 }
1616 }
1617 /*}}}*/
1618 void pkgAcqMetaSig::Failed(string const &Message,pkgAcquire::MethodConfig const * const Cnf)/*{{{*/
1619 {
1620 Item::Failed(Message,Cnf);
1621
1622 // check if we need to fail at this point
1623 if (MetaIndex->AuthPass == true && MetaIndex->CheckStopAuthentication(this, Message))
1624 return;
1625
1626 string const FinalRelease = MetaIndex->GetFinalFilename();
1627 string const FinalReleasegpg = GetFinalFilename();
1628 string const FinalInRelease = TransactionManager->GetFinalFilename();
1629
1630 if (RealFileExists(FinalReleasegpg) || RealFileExists(FinalInRelease))
1631 {
1632 std::string downgrade_msg;
1633 strprintf(downgrade_msg, _("The repository '%s' is no longer signed."),
1634 MetaIndex->Target.Description.c_str());
1635 if(_config->FindB("Acquire::AllowDowngradeToInsecureRepositories"))
1636 {
1637 // meh, the users wants to take risks (we still mark the packages
1638 // from this repository as unauthenticated)
1639 _error->Warning("%s", downgrade_msg.c_str());
1640 _error->Warning(_("This is normally not allowed, but the option "
1641 "Acquire::AllowDowngradeToInsecureRepositories was "
1642 "given to override it."));
1643 Status = StatDone;
1644 } else {
1645 MessageInsecureRepository(true, downgrade_msg);
1646 if (TransactionManager->IMSHit == false)
1647 Rename(MetaIndex->DestFile, MetaIndex->DestFile + ".FAILED");
1648 Item::Failed("Message: " + downgrade_msg, Cnf);
1649 TransactionManager->AbortTransaction();
1650 return;
1651 }
1652 }
1653
1654 // ensures that a Release.gpg file in the lists/ is removed by the transaction
1655 TransactionManager->TransactionStageRemoval(this, DestFile);
1656
1657 // only allow going further if the user explicitly wants it
1658 if (AllowInsecureRepositories(_("The repository '%s' is not signed."), MetaIndex->Target.Description, TransactionManager->MetaIndexParser, TransactionManager, this) == true)
1659 {
1660 if (RealFileExists(FinalReleasegpg) || RealFileExists(FinalInRelease))
1661 {
1662 // open the last Release if we have it
1663 if (TransactionManager->IMSHit == false)
1664 {
1665 TransactionManager->LastMetaIndexParser = TransactionManager->MetaIndexParser->UnloadedClone();
1666 if (TransactionManager->LastMetaIndexParser != NULL)
1667 {
1668 _error->PushToStack();
1669 if (RealFileExists(FinalInRelease))
1670 TransactionManager->LastMetaIndexParser->Load(FinalInRelease, NULL);
1671 else
1672 TransactionManager->LastMetaIndexParser->Load(FinalRelease, NULL);
1673 // its unlikely to happen, but if what we have is bad ignore it
1674 if (_error->PendingError())
1675 {
1676 delete TransactionManager->LastMetaIndexParser;
1677 TransactionManager->LastMetaIndexParser = NULL;
1678 }
1679 _error->RevertToStack();
1680 }
1681 }
1682 }
1683
1684 // we parse the indexes here because at this point the user wanted
1685 // a repository that may potentially harm him
1686 bool const GoodLoad = TransactionManager->MetaIndexParser->Load(MetaIndex->DestFile, &ErrorText);
1687 if (MetaIndex->VerifyVendor(Message) == false)
1688 /* expired Release files are still a problem you need extra force for */;
1689 else
1690 MetaIndex->QueueIndexes(GoodLoad);
1691
1692 TransactionManager->TransactionStageCopy(MetaIndex, MetaIndex->DestFile, MetaIndex->GetFinalFilename());
1693 }
1694
1695 // FIXME: this is used often (e.g. in pkgAcqIndexTrans) so refactor
1696 if (Cnf->LocalOnly == true ||
1697 StringToBool(LookupTag(Message,"Transient-Failure"),false) == false)
1698 {
1699 // Ignore this
1700 Status = StatDone;
1701 }
1702 }
1703 /*}}}*/
1704
1705
1706 // AcqBaseIndex - Constructor /*{{{*/
1707 pkgAcqBaseIndex::pkgAcqBaseIndex(pkgAcquire * const Owner,
1708 pkgAcqMetaClearSig * const TransactionManager,
1709 IndexTarget const &Target)
1710 : pkgAcqTransactionItem(Owner, TransactionManager, Target), d(NULL)
1711 {
1712 }
1713 /*}}}*/
1714 pkgAcqBaseIndex::~pkgAcqBaseIndex() {}
1715
1716 // AcqDiffIndex::AcqDiffIndex - Constructor /*{{{*/
1717 // ---------------------------------------------------------------------
1718 /* Get the DiffIndex file first and see if there are patches available
1719 * If so, create a pkgAcqIndexDiffs fetcher that will get and apply the
1720 * patches. If anything goes wrong in that process, it will fall back to
1721 * the original packages file
1722 */
1723 pkgAcqDiffIndex::pkgAcqDiffIndex(pkgAcquire * const Owner,
1724 pkgAcqMetaClearSig * const TransactionManager,
1725 IndexTarget const &Target)
1726 : pkgAcqBaseIndex(Owner, TransactionManager, Target), d(NULL), diffs(NULL)
1727 {
1728 Debug = _config->FindB("Debug::pkgAcquire::Diffs",false);
1729
1730 Desc.Owner = this;
1731 Desc.Description = Target.Description + ".diff/Index";
1732 Desc.ShortDesc = Target.ShortDesc;
1733 Desc.URI = Target.URI + ".diff/Index";
1734
1735 DestFile = GetPartialFileNameFromURI(Desc.URI);
1736
1737 if(Debug)
1738 std::clog << "pkgAcqDiffIndex: " << Desc.URI << std::endl;
1739
1740 QueueURI(Desc);
1741 }
1742 /*}}}*/
1743 // AcqIndex::Custom600Headers - Insert custom request headers /*{{{*/
1744 // ---------------------------------------------------------------------
1745 /* The only header we use is the last-modified header. */
1746 string pkgAcqDiffIndex::Custom600Headers() const
1747 {
1748 if (TransactionManager->LastMetaIndexParser != NULL)
1749 return "\nIndex-File: true";
1750
1751 string const Final = GetFinalFilename();
1752
1753 if(Debug)
1754 std::clog << "Custom600Header-IMS: " << Final << std::endl;
1755
1756 struct stat Buf;
1757 if (stat(Final.c_str(),&Buf) != 0)
1758 return "\nIndex-File: true";
1759
1760 return "\nIndex-File: true\nLast-Modified: " + TimeRFC1123(Buf.st_mtime);
1761 }
1762 /*}}}*/
1763 void pkgAcqDiffIndex::QueueOnIMSHit() const /*{{{*/
1764 {
1765 // list cleanup needs to know that this file as well as the already
1766 // present index is ours, so we create an empty diff to save it for us
1767 new pkgAcqIndexDiffs(Owner, TransactionManager, Target);
1768 }
1769 /*}}}*/
1770 bool pkgAcqDiffIndex::ParseDiffIndex(string const &IndexDiffFile) /*{{{*/
1771 {
1772 // failing here is fine: our caller will take care of trying to
1773 // get the complete file if patching fails
1774 if(Debug)
1775 std::clog << "pkgAcqDiffIndex::ParseIndexDiff() " << IndexDiffFile
1776 << std::endl;
1777
1778 FileFd Fd(IndexDiffFile,FileFd::ReadOnly);
1779 pkgTagFile TF(&Fd);
1780 if (Fd.IsOpen() == false || Fd.Failed())
1781 return false;
1782
1783 pkgTagSection Tags;
1784 if(unlikely(TF.Step(Tags) == false))
1785 return false;
1786
1787 HashStringList ServerHashes;
1788 unsigned long long ServerSize = 0;
1789
1790 for (char const * const * type = HashString::SupportedHashes(); *type != NULL; ++type)
1791 {
1792 std::string tagname = *type;
1793 tagname.append("-Current");
1794 std::string const tmp = Tags.FindS(tagname.c_str());
1795 if (tmp.empty() == true)
1796 continue;
1797
1798 string hash;
1799 unsigned long long size;
1800 std::stringstream ss(tmp);
1801 ss >> hash >> size;
1802 if (unlikely(hash.empty() == true))
1803 continue;
1804 if (unlikely(ServerSize != 0 && ServerSize != size))
1805 continue;
1806 ServerHashes.push_back(HashString(*type, hash));
1807 ServerSize = size;
1808 }
1809
1810 if (ServerHashes.usable() == false)
1811 {
1812 if (Debug == true)
1813 std::clog << "pkgAcqDiffIndex: " << IndexDiffFile << ": Did not find a good hashsum in the index" << std::endl;
1814 return false;
1815 }
1816
1817 std::string const CurrentPackagesFile = GetFinalFileNameFromURI(Target.URI);
1818 HashStringList const TargetFileHashes = GetExpectedHashesFor(Target.MetaKey);
1819 if (TargetFileHashes.usable() == false || ServerHashes != TargetFileHashes)
1820 {
1821 if (Debug == true)
1822 {
1823 std::clog << "pkgAcqDiffIndex: " << IndexDiffFile << ": Index has different hashes than parser, probably older, so fail pdiffing" << std::endl;
1824 printHashSumComparision(CurrentPackagesFile, ServerHashes, TargetFileHashes);
1825 }
1826 return false;
1827 }
1828
1829 HashStringList LocalHashes;
1830 // try avoiding calculating the hash here as this is costly
1831 if (TransactionManager->LastMetaIndexParser != NULL)
1832 LocalHashes = GetExpectedHashesFromFor(TransactionManager->LastMetaIndexParser, Target.MetaKey);
1833 if (LocalHashes.usable() == false)
1834 {
1835 FileFd fd(CurrentPackagesFile, FileFd::ReadOnly, FileFd::Auto);
1836 Hashes LocalHashesCalc(ServerHashes);
1837 LocalHashesCalc.AddFD(fd);
1838 LocalHashes = LocalHashesCalc.GetHashStringList();
1839 }
1840
1841 if (ServerHashes == LocalHashes)
1842 {
1843 // we have the same sha1 as the server so we are done here
1844 if(Debug)
1845 std::clog << "pkgAcqDiffIndex: Package file " << CurrentPackagesFile << " is up-to-date" << std::endl;
1846 QueueOnIMSHit();
1847 return true;
1848 }
1849
1850 if(Debug)
1851 std::clog << "Server-Current: " << ServerHashes.find(NULL)->toStr() << " and we start at "
1852 << CurrentPackagesFile << " " << LocalHashes.FileSize() << " " << LocalHashes.find(NULL)->toStr() << std::endl;
1853
1854 // historically, older hashes have more info than newer ones, so start
1855 // collecting with older ones first to avoid implementing complicated
1856 // information merging techniques… a failure is after all always
1857 // recoverable with a complete file and hashes aren't changed that often.
1858 std::vector<char const *> types;
1859 for (char const * const * type = HashString::SupportedHashes(); *type != NULL; ++type)
1860 types.push_back(*type);
1861
1862 // parse all of (provided) history
1863 vector<DiffInfo> available_patches;
1864 bool firstAcceptedHashes = true;
1865 for (auto type = types.crbegin(); type != types.crend(); ++type)
1866 {
1867 if (LocalHashes.find(*type) == NULL)
1868 continue;
1869
1870 std::string tagname = *type;
1871 tagname.append("-History");
1872 std::string const tmp = Tags.FindS(tagname.c_str());
1873 if (tmp.empty() == true)
1874 continue;
1875
1876 string hash, filename;
1877 unsigned long long size;
1878 std::stringstream ss(tmp);
1879
1880 while (ss >> hash >> size >> filename)
1881 {
1882 if (unlikely(hash.empty() == true || filename.empty() == true))
1883 continue;
1884
1885 // see if we have a record for this file already
1886 std::vector<DiffInfo>::iterator cur = available_patches.begin();
1887 for (; cur != available_patches.end(); ++cur)
1888 {
1889 if (cur->file != filename)
1890 continue;
1891 cur->result_hashes.push_back(HashString(*type, hash));
1892 break;
1893 }
1894 if (cur != available_patches.end())
1895 continue;
1896 if (firstAcceptedHashes == true)
1897 {
1898 DiffInfo next;
1899 next.file = filename;
1900 next.result_hashes.push_back(HashString(*type, hash));
1901 next.result_hashes.FileSize(size);
1902 available_patches.push_back(next);
1903 }
1904 else
1905 {
1906 if (Debug == true)
1907 std::clog << "pkgAcqDiffIndex: " << IndexDiffFile << ": File " << filename
1908 << " wasn't in the list for the first parsed hash! (history)" << std::endl;
1909 break;
1910 }
1911 }
1912 firstAcceptedHashes = false;
1913 }
1914
1915 if (unlikely(available_patches.empty() == true))
1916 {
1917 if (Debug)
1918 std::clog << "pkgAcqDiffIndex: " << IndexDiffFile << ": "
1919 << "Couldn't find any patches for the patch series." << std::endl;
1920 return false;
1921 }
1922
1923 for (auto type = types.crbegin(); type != types.crend(); ++type)
1924 {
1925 if (LocalHashes.find(*type) == NULL)
1926 continue;
1927
1928 std::string tagname = *type;
1929 tagname.append("-Patches");
1930 std::string const tmp = Tags.FindS(tagname.c_str());
1931 if (tmp.empty() == true)
1932 continue;
1933
1934 string hash, filename;
1935 unsigned long long size;
1936 std::stringstream ss(tmp);
1937
1938 while (ss >> hash >> size >> filename)
1939 {
1940 if (unlikely(hash.empty() == true || filename.empty() == true))
1941 continue;
1942
1943 // see if we have a record for this file already
1944 std::vector<DiffInfo>::iterator cur = available_patches.begin();
1945 for (; cur != available_patches.end(); ++cur)
1946 {
1947 if (cur->file != filename)
1948 continue;
1949 if (cur->patch_hashes.empty())
1950 cur->patch_hashes.FileSize(size);
1951 cur->patch_hashes.push_back(HashString(*type, hash));
1952 break;
1953 }
1954 if (cur != available_patches.end())
1955 continue;
1956 if (Debug == true)
1957 std::clog << "pkgAcqDiffIndex: " << IndexDiffFile << ": File " << filename
1958 << " wasn't in the list for the first parsed hash! (patches)" << std::endl;
1959 break;
1960 }
1961 }
1962
1963 for (auto type = types.crbegin(); type != types.crend(); ++type)
1964 {
1965 std::string tagname = *type;
1966 tagname.append("-Download");
1967 std::string const tmp = Tags.FindS(tagname.c_str());
1968 if (tmp.empty() == true)
1969 continue;
1970
1971 string hash, filename;
1972 unsigned long long size;
1973 std::stringstream ss(tmp);
1974
1975 // FIXME: all of pdiff supports only .gz compressed patches
1976 while (ss >> hash >> size >> filename)
1977 {
1978 if (unlikely(hash.empty() == true || filename.empty() == true))
1979 continue;
1980 if (unlikely(APT::String::Endswith(filename, ".gz") == false))
1981 continue;
1982 filename.erase(filename.length() - 3);
1983
1984 // see if we have a record for this file already
1985 std::vector<DiffInfo>::iterator cur = available_patches.begin();
1986 for (; cur != available_patches.end(); ++cur)
1987 {
1988 if (cur->file != filename)
1989 continue;
1990 if (cur->download_hashes.empty())
1991 cur->download_hashes.FileSize(size);
1992 cur->download_hashes.push_back(HashString(*type, hash));
1993 break;
1994 }
1995 if (cur != available_patches.end())
1996 continue;
1997 if (Debug == true)
1998 std::clog << "pkgAcqDiffIndex: " << IndexDiffFile << ": File " << filename
1999 << " wasn't in the list for the first parsed hash! (download)" << std::endl;
2000 break;
2001 }
2002 }
2003
2004
2005 bool foundStart = false;
2006 for (std::vector<DiffInfo>::iterator cur = available_patches.begin();
2007 cur != available_patches.end(); ++cur)
2008 {
2009 if (LocalHashes != cur->result_hashes)
2010 continue;
2011
2012 available_patches.erase(available_patches.begin(), cur);
2013 foundStart = true;
2014 break;
2015 }
2016
2017 if (foundStart == false || unlikely(available_patches.empty() == true))
2018 {
2019 if (Debug)
2020 std::clog << "pkgAcqDiffIndex: " << IndexDiffFile << ": "
2021 << "Couldn't find the start of the patch series." << std::endl;
2022 return false;
2023 }
2024
2025 // patching with too many files is rather slow compared to a fast download
2026 unsigned long const fileLimit = _config->FindI("Acquire::PDiffs::FileLimit", 0);
2027 if (fileLimit != 0 && fileLimit < available_patches.size())
2028 {
2029 if (Debug)
2030 std::clog << "Need " << available_patches.size() << " diffs (Limit is " << fileLimit
2031 << ") so fallback to complete download" << std::endl;
2032 return false;
2033 }
2034
2035 // calculate the size of all patches we have to get
2036 // note that all sizes are uncompressed, while we download compressed files
2037 unsigned long long patchesSize = 0;
2038 for (std::vector<DiffInfo>::const_iterator cur = available_patches.begin();
2039 cur != available_patches.end(); ++cur)
2040 patchesSize += cur->patch_hashes.FileSize();
2041 unsigned long long const sizeLimit = ServerSize * _config->FindI("Acquire::PDiffs::SizeLimit", 100);
2042 if (sizeLimit > 0 && (sizeLimit/100) < patchesSize)
2043 {
2044 if (Debug)
2045 std::clog << "Need " << patchesSize << " bytes (Limit is " << sizeLimit/100
2046 << ") so fallback to complete download" << std::endl;
2047 return false;
2048 }
2049
2050 // we have something, queue the diffs
2051 string::size_type const last_space = Description.rfind(" ");
2052 if(last_space != string::npos)
2053 Description.erase(last_space, Description.size()-last_space);
2054
2055 /* decide if we should download patches one by one or in one go:
2056 The first is good if the server merges patches, but many don't so client
2057 based merging can be attempt in which case the second is better.
2058 "bad things" will happen if patches are merged on the server,
2059 but client side merging is attempt as well */
2060 bool pdiff_merge = _config->FindB("Acquire::PDiffs::Merge", true);
2061 if (pdiff_merge == true)
2062 {
2063 // reprepro adds this flag if it has merged patches on the server
2064 std::string const precedence = Tags.FindS("X-Patch-Precedence");
2065 pdiff_merge = (precedence != "merged");
2066 }
2067
2068 if (pdiff_merge == false)
2069 new pkgAcqIndexDiffs(Owner, TransactionManager, Target, available_patches);
2070 else
2071 {
2072 diffs = new std::vector<pkgAcqIndexMergeDiffs*>(available_patches.size());
2073 for(size_t i = 0; i < available_patches.size(); ++i)
2074 (*diffs)[i] = new pkgAcqIndexMergeDiffs(Owner, TransactionManager,
2075 Target,
2076 available_patches[i],
2077 diffs);
2078 }
2079
2080 Complete = false;
2081 Status = StatDone;
2082 Dequeue();
2083 return true;
2084 }
2085 /*}}}*/
2086 void pkgAcqDiffIndex::Failed(string const &Message,pkgAcquire::MethodConfig const * const Cnf)/*{{{*/
2087 {
2088 Item::Failed(Message,Cnf);
2089 Status = StatDone;
2090
2091 if(Debug)
2092 std::clog << "pkgAcqDiffIndex failed: " << Desc.URI << " with " << Message << std::endl
2093 << "Falling back to normal index file acquire" << std::endl;
2094
2095 new pkgAcqIndex(Owner, TransactionManager, Target);
2096 }
2097 /*}}}*/
2098 void pkgAcqDiffIndex::Done(string const &Message,HashStringList const &Hashes, /*{{{*/
2099 pkgAcquire::MethodConfig const * const Cnf)
2100 {
2101 if(Debug)
2102 std::clog << "pkgAcqDiffIndex::Done(): " << Desc.URI << std::endl;
2103
2104 Item::Done(Message, Hashes, Cnf);
2105
2106 string const FinalFile = GetFinalFilename();
2107 if(StringToBool(LookupTag(Message,"IMS-Hit"),false))
2108 DestFile = FinalFile;
2109
2110 if(ParseDiffIndex(DestFile) == false)
2111 {
2112 Failed("Message: Couldn't parse pdiff index", Cnf);
2113 // queue for final move - this should happen even if we fail
2114 // while parsing (e.g. on sizelimit) and download the complete file.
2115 TransactionManager->TransactionStageCopy(this, DestFile, FinalFile);
2116 return;
2117 }
2118
2119 TransactionManager->TransactionStageCopy(this, DestFile, FinalFile);
2120
2121 Complete = true;
2122 Status = StatDone;
2123 Dequeue();
2124
2125 return;
2126 }
2127 /*}}}*/
2128 pkgAcqDiffIndex::~pkgAcqDiffIndex()
2129 {
2130 if (diffs != NULL)
2131 delete diffs;
2132 }
2133
2134 // AcqIndexDiffs::AcqIndexDiffs - Constructor /*{{{*/
2135 // ---------------------------------------------------------------------
2136 /* The package diff is added to the queue. one object is constructed
2137 * for each diff and the index
2138 */
2139 pkgAcqIndexDiffs::pkgAcqIndexDiffs(pkgAcquire * const Owner,
2140 pkgAcqMetaClearSig * const TransactionManager,
2141 IndexTarget const &Target,
2142 vector<DiffInfo> const &diffs)
2143 : pkgAcqBaseIndex(Owner, TransactionManager, Target), d(NULL),
2144 available_patches(diffs)
2145 {
2146 DestFile = GetKeepCompressedFileName(GetPartialFileNameFromURI(Target.URI), Target);
2147
2148 Debug = _config->FindB("Debug::pkgAcquire::Diffs",false);
2149
2150 Desc.Owner = this;
2151 Description = Target.Description;
2152 Desc.ShortDesc = Target.ShortDesc;
2153
2154 if(available_patches.empty() == true)
2155 {
2156 // we are done (yeah!), check hashes against the final file
2157 DestFile = GetKeepCompressedFileName(GetFinalFileNameFromURI(Target.URI), Target);
2158 Finish(true);
2159 }
2160 else
2161 {
2162 if (BootstrapPDiffWith(GetPartialFileNameFromURI(Target.URI), GetFinalFilename(), Target) == false)
2163 {
2164 Failed("Bootstrapping of " + DestFile + " failed", NULL);
2165 return;
2166 }
2167
2168 // get the next diff
2169 State = StateFetchDiff;
2170 QueueNextDiff();
2171 }
2172 }
2173 /*}}}*/
2174 void pkgAcqIndexDiffs::Failed(string const &Message,pkgAcquire::MethodConfig const * const Cnf)/*{{{*/
2175 {
2176 Item::Failed(Message,Cnf);
2177 Status = StatDone;
2178
2179 DestFile = GetKeepCompressedFileName(GetPartialFileNameFromURI(Target.URI), Target);
2180 if(Debug)
2181 std::clog << "pkgAcqIndexDiffs failed: " << Desc.URI << " with " << Message << std::endl
2182 << "Falling back to normal index file acquire " << std::endl;
2183 RenameOnError(PDiffError);
2184 std::string const patchname = GetDiffsPatchFileName(DestFile);
2185 if (RealFileExists(patchname))
2186 rename(patchname.c_str(), std::string(patchname + ".FAILED").c_str());
2187 new pkgAcqIndex(Owner, TransactionManager, Target);
2188 Finish();
2189 }
2190 /*}}}*/
2191 // Finish - helper that cleans the item out of the fetcher queue /*{{{*/
2192 void pkgAcqIndexDiffs::Finish(bool allDone)
2193 {
2194 if(Debug)
2195 std::clog << "pkgAcqIndexDiffs::Finish(): "
2196 << allDone << " "
2197 << Desc.URI << std::endl;
2198
2199 // we restore the original name, this is required, otherwise
2200 // the file will be cleaned
2201 if(allDone)
2202 {
2203 std::string Final = GetFinalFilename();
2204 if (Target.KeepCompressed)
2205 {
2206 std::string const ext = flExtension(DestFile);
2207 if (ext.empty() == false)
2208 Final.append(".").append(ext);
2209 }
2210 TransactionManager->TransactionStageCopy(this, DestFile, Final);
2211
2212 // this is for the "real" finish
2213 Complete = true;
2214 Status = StatDone;
2215 Dequeue();
2216 if(Debug)
2217 std::clog << "\n\nallDone: " << DestFile << "\n" << std::endl;
2218 return;
2219 }
2220 else
2221 DestFile.clear();
2222
2223 if(Debug)
2224 std::clog << "Finishing: " << Desc.URI << std::endl;
2225 Complete = false;
2226 Status = StatDone;
2227 Dequeue();
2228 return;
2229 }
2230 /*}}}*/
2231 bool pkgAcqIndexDiffs::QueueNextDiff() /*{{{*/
2232 {
2233 // calc sha1 of the just patched file
2234 std::string const FinalFile = GetKeepCompressedFileName(GetPartialFileNameFromURI(Target.URI), Target);
2235 if(!FileExists(FinalFile))
2236 {
2237 Failed("Message: No FinalFile " + FinalFile + " available", NULL);
2238 return false;
2239 }
2240
2241 FileFd fd(FinalFile, FileFd::ReadOnly, FileFd::Extension);
2242 Hashes LocalHashesCalc;
2243 LocalHashesCalc.AddFD(fd);
2244 HashStringList const LocalHashes = LocalHashesCalc.GetHashStringList();
2245
2246 if(Debug)
2247 std::clog << "QueueNextDiff: " << FinalFile << " (" << LocalHashes.find(NULL)->toStr() << ")" << std::endl;
2248
2249 HashStringList const TargetFileHashes = GetExpectedHashesFor(Target.MetaKey);
2250 if (unlikely(LocalHashes.usable() == false || TargetFileHashes.usable() == false))
2251 {
2252 Failed("Local/Expected hashes are not usable", NULL);
2253 return false;
2254 }
2255
2256
2257 // final file reached before all patches are applied
2258 if(LocalHashes == TargetFileHashes)
2259 {
2260 Finish(true);
2261 return true;
2262 }
2263
2264 // remove all patches until the next matching patch is found
2265 // this requires the Index file to be ordered
2266 available_patches.erase(available_patches.begin(),
2267 std::find_if(available_patches.begin(), available_patches.end(), [&](DiffInfo const &I) {
2268 return I.result_hashes == LocalHashes;
2269 }));
2270
2271 // error checking and falling back if no patch was found
2272 if(available_patches.empty() == true)
2273 {
2274 Failed("No patches left to reach target", NULL);
2275 return false;
2276 }
2277
2278 // queue the right diff
2279 Desc.URI = Target.URI + ".diff/" + available_patches[0].file + ".gz";
2280 Desc.Description = Description + " " + available_patches[0].file + string(".pdiff");
2281 DestFile = GetKeepCompressedFileName(GetPartialFileNameFromURI(Target.URI + ".diff/" + available_patches[0].file), Target);
2282
2283 if(Debug)
2284 std::clog << "pkgAcqIndexDiffs::QueueNextDiff(): " << Desc.URI << std::endl;
2285
2286 QueueURI(Desc);
2287
2288 return true;
2289 }
2290 /*}}}*/
2291 void pkgAcqIndexDiffs::Done(string const &Message, HashStringList const &Hashes, /*{{{*/
2292 pkgAcquire::MethodConfig const * const Cnf)
2293 {
2294 if(Debug)
2295 std::clog << "pkgAcqIndexDiffs::Done(): " << Desc.URI << std::endl;
2296
2297 Item::Done(Message, Hashes, Cnf);
2298
2299 std::string const FinalFile = GetKeepCompressedFileName(GetPartialFileNameFromURI(Target.URI), Target);
2300 std::string const PatchFile = GetDiffsPatchFileName(FinalFile);
2301
2302 // success in downloading a diff, enter ApplyDiff state
2303 if(State == StateFetchDiff)
2304 {
2305 Rename(DestFile, PatchFile);
2306
2307 if(Debug)
2308 std::clog << "Sending to rred method: " << FinalFile << std::endl;
2309
2310 State = StateApplyDiff;
2311 Local = true;
2312 Desc.URI = "rred:" + FinalFile;
2313 QueueURI(Desc);
2314 SetActiveSubprocess("rred");
2315 return;
2316 }
2317
2318 // success in download/apply a diff, queue next (if needed)
2319 if(State == StateApplyDiff)
2320 {
2321 // remove the just applied patch
2322 available_patches.erase(available_patches.begin());
2323 RemoveFile("pkgAcqIndexDiffs::Done", PatchFile);
2324
2325 // move into place
2326 if(Debug)
2327 {
2328 std::clog << "Moving patched file in place: " << std::endl
2329 << DestFile << " -> " << FinalFile << std::endl;
2330 }
2331 Rename(DestFile,FinalFile);
2332 chmod(FinalFile.c_str(),0644);
2333
2334 // see if there is more to download
2335 if(available_patches.empty() == false) {
2336 new pkgAcqIndexDiffs(Owner, TransactionManager, Target,
2337 available_patches);
2338 return Finish();
2339 } else
2340 // update
2341 DestFile = FinalFile;
2342 return Finish(true);
2343 }
2344 }
2345 /*}}}*/
2346 std::string pkgAcqIndexDiffs::Custom600Headers() const /*{{{*/
2347 {
2348 if(State != StateApplyDiff)
2349 return pkgAcqBaseIndex::Custom600Headers();
2350 std::ostringstream patchhashes;
2351 HashStringList const ExpectedHashes = available_patches[0].patch_hashes;
2352 for (HashStringList::const_iterator hs = ExpectedHashes.begin(); hs != ExpectedHashes.end(); ++hs)
2353 patchhashes << "\nPatch-0-" << hs->HashType() << "-Hash: " << hs->HashValue();
2354 patchhashes << pkgAcqBaseIndex::Custom600Headers();
2355 return patchhashes.str();
2356 }
2357 /*}}}*/
2358 pkgAcqIndexDiffs::~pkgAcqIndexDiffs() {}
2359
2360 // AcqIndexMergeDiffs::AcqIndexMergeDiffs - Constructor /*{{{*/
2361 pkgAcqIndexMergeDiffs::pkgAcqIndexMergeDiffs(pkgAcquire * const Owner,
2362 pkgAcqMetaClearSig * const TransactionManager,
2363 IndexTarget const &Target,
2364 DiffInfo const &patch,
2365 std::vector<pkgAcqIndexMergeDiffs*> const * const allPatches)
2366 : pkgAcqBaseIndex(Owner, TransactionManager, Target), d(NULL),
2367 patch(patch), allPatches(allPatches), State(StateFetchDiff)
2368 {
2369 Debug = _config->FindB("Debug::pkgAcquire::Diffs",false);
2370
2371 Desc.Owner = this;
2372 Description = Target.Description;
2373 Desc.ShortDesc = Target.ShortDesc;
2374
2375 Desc.URI = Target.URI + ".diff/" + patch.file + ".gz";
2376 Desc.Description = Description + " " + patch.file + string(".pdiff");
2377
2378 DestFile = GetKeepCompressedFileName(GetPartialFileNameFromURI(Target.URI + ".diff/" + patch.file), Target);
2379
2380 if(Debug)
2381 std::clog << "pkgAcqIndexMergeDiffs: " << Desc.URI << std::endl;
2382
2383 QueueURI(Desc);
2384 }
2385 /*}}}*/
2386 void pkgAcqIndexMergeDiffs::Failed(string const &Message,pkgAcquire::MethodConfig const * const Cnf)/*{{{*/
2387 {
2388 if(Debug)
2389 std::clog << "pkgAcqIndexMergeDiffs failed: " << Desc.URI << " with " << Message << std::endl;
2390
2391 Item::Failed(Message,Cnf);
2392 Status = StatDone;
2393
2394 // check if we are the first to fail, otherwise we are done here
2395 State = StateDoneDiff;
2396 for (std::vector<pkgAcqIndexMergeDiffs *>::const_iterator I = allPatches->begin();
2397 I != allPatches->end(); ++I)
2398 if ((*I)->State == StateErrorDiff)
2399 return;
2400
2401 // first failure means we should fallback
2402 State = StateErrorDiff;
2403 if (Debug)
2404 std::clog << "Falling back to normal index file acquire" << std::endl;
2405 DestFile = GetKeepCompressedFileName(GetPartialFileNameFromURI(Target.URI), Target);
2406 RenameOnError(PDiffError);
2407 std::string const patchname = GetMergeDiffsPatchFileName(DestFile, patch.file);
2408 if (RealFileExists(patchname))
2409 rename(patchname.c_str(), std::string(patchname + ".FAILED").c_str());
2410 new pkgAcqIndex(Owner, TransactionManager, Target);
2411 DestFile.clear();
2412 }
2413 /*}}}*/
2414 void pkgAcqIndexMergeDiffs::Done(string const &Message, HashStringList const &Hashes, /*{{{*/
2415 pkgAcquire::MethodConfig const * const Cnf)
2416 {
2417 if(Debug)
2418 std::clog << "pkgAcqIndexMergeDiffs::Done(): " << Desc.URI << std::endl;
2419
2420 Item::Done(Message, Hashes, Cnf);
2421
2422 std::string const UncompressedFinalFile = GetPartialFileNameFromURI(Target.URI);
2423 std::string const FinalFile = GetKeepCompressedFileName(GetPartialFileNameFromURI(Target.URI), Target);
2424 if (State == StateFetchDiff)
2425 {
2426 Rename(DestFile, GetMergeDiffsPatchFileName(FinalFile, patch.file));
2427
2428 // check if this is the last completed diff
2429 State = StateDoneDiff;
2430 for (std::vector<pkgAcqIndexMergeDiffs *>::const_iterator I = allPatches->begin();
2431 I != allPatches->end(); ++I)
2432 if ((*I)->State != StateDoneDiff)
2433 {
2434 if(Debug)
2435 std::clog << "Not the last done diff in the batch: " << Desc.URI << std::endl;
2436 return;
2437 }
2438
2439 // this is the last completed diff, so we are ready to apply now
2440 State = StateApplyDiff;
2441
2442 if (BootstrapPDiffWith(UncompressedFinalFile, GetFinalFilename(), Target) == false)
2443 {
2444 Failed("Bootstrapping of " + DestFile + " failed", NULL);
2445 return;
2446 }
2447
2448 if(Debug)
2449 std::clog << "Sending to rred method: " << FinalFile << std::endl;
2450
2451 Local = true;
2452 Desc.URI = "rred:" + FinalFile;
2453 QueueURI(Desc);
2454 SetActiveSubprocess("rred");
2455 return;
2456 }
2457 // success in download/apply all diffs, clean up
2458 else if (State == StateApplyDiff)
2459 {
2460 // move the result into place
2461 std::string const Final = GetKeepCompressedFileName(GetFinalFilename(), Target);
2462 if(Debug)
2463 std::clog << "Queue patched file in place: " << std::endl
2464 << DestFile << " -> " << Final << std::endl;
2465
2466 // queue for copy by the transaction manager
2467 TransactionManager->TransactionStageCopy(this, DestFile, Final);
2468
2469 // ensure the ed's are gone regardless of list-cleanup
2470 for (std::vector<pkgAcqIndexMergeDiffs *>::const_iterator I = allPatches->begin();
2471 I != allPatches->end(); ++I)
2472 {
2473 std::string const PartialFile = GetKeepCompressedFileName(GetPartialFileNameFromURI(Target.URI), Target);
2474 std::string const patch = GetMergeDiffsPatchFileName(PartialFile, (*I)->patch.file);
2475 RemoveFile("pkgAcqIndexMergeDiffs::Done", patch);
2476 }
2477 RemoveFile("pkgAcqIndexMergeDiffs::Done", FinalFile);
2478
2479 // all set and done
2480 Complete = true;
2481 if(Debug)
2482 std::clog << "allDone: " << DestFile << "\n" << std::endl;
2483 }
2484 }
2485 /*}}}*/
2486 std::string pkgAcqIndexMergeDiffs::Custom600Headers() const /*{{{*/
2487 {
2488 if(State != StateApplyDiff)
2489 return pkgAcqBaseIndex::Custom600Headers();
2490 std::ostringstream patchhashes;
2491 unsigned int seen_patches = 0;
2492 for (std::vector<pkgAcqIndexMergeDiffs *>::const_iterator I = allPatches->begin();
2493 I != allPatches->end(); ++I)
2494 {
2495 HashStringList const ExpectedHashes = (*I)->patch.patch_hashes;
2496 for (HashStringList::const_iterator hs = ExpectedHashes.begin(); hs != ExpectedHashes.end(); ++hs)
2497 patchhashes << "\nPatch-" << seen_patches << "-" << hs->HashType() << "-Hash: " << hs->HashValue();
2498 ++seen_patches;
2499 }
2500 patchhashes << pkgAcqBaseIndex::Custom600Headers();
2501 return patchhashes.str();
2502 }
2503 /*}}}*/
2504 pkgAcqIndexMergeDiffs::~pkgAcqIndexMergeDiffs() {}
2505
2506 // AcqIndex::AcqIndex - Constructor /*{{{*/
2507 pkgAcqIndex::pkgAcqIndex(pkgAcquire * const Owner,
2508 pkgAcqMetaClearSig * const TransactionManager,
2509 IndexTarget const &Target)
2510 : pkgAcqBaseIndex(Owner, TransactionManager, Target), d(NULL), Stage(STAGE_DOWNLOAD),
2511 CompressionExtensions(Target.Option(IndexTarget::COMPRESSIONTYPES))
2512 {
2513 Init(Target.URI, Target.Description, Target.ShortDesc);
2514
2515 if(_config->FindB("Debug::Acquire::Transaction", false) == true)
2516 std::clog << "New pkgIndex with TransactionManager "
2517 << TransactionManager << std::endl;
2518 }
2519 /*}}}*/
2520 // AcqIndex::Init - defered Constructor /*{{{*/
2521 static void NextCompressionExtension(std::string &CurrentCompressionExtension, std::string &CompressionExtensions, bool const preview)
2522 {
2523 size_t const nextExt = CompressionExtensions.find(' ');
2524 if (nextExt == std::string::npos)
2525 {
2526 CurrentCompressionExtension = CompressionExtensions;
2527 if (preview == false)
2528 CompressionExtensions.clear();
2529 }
2530 else
2531 {
2532 CurrentCompressionExtension = CompressionExtensions.substr(0, nextExt);
2533 if (preview == false)
2534 CompressionExtensions = CompressionExtensions.substr(nextExt+1);
2535 }
2536 }
2537 void pkgAcqIndex::Init(string const &URI, string const &URIDesc,
2538 string const &ShortDesc)
2539 {
2540 Stage = STAGE_DOWNLOAD;
2541
2542 DestFile = GetPartialFileNameFromURI(URI);
2543 NextCompressionExtension(CurrentCompressionExtension, CompressionExtensions, false);
2544
2545 if (CurrentCompressionExtension == "uncompressed")
2546 {
2547 Desc.URI = URI;
2548 }
2549 else if (CurrentCompressionExtension == "by-hash")
2550 {
2551 NextCompressionExtension(CurrentCompressionExtension, CompressionExtensions, true);
2552 if(unlikely(TransactionManager->MetaIndexParser == NULL || CurrentCompressionExtension.empty()))
2553 return;
2554 if (CurrentCompressionExtension != "uncompressed")
2555 {
2556 Desc.URI = URI + '.' + CurrentCompressionExtension;
2557 DestFile = DestFile + '.' + CurrentCompressionExtension;
2558 }
2559
2560 HashStringList const Hashes = GetExpectedHashes();
2561 HashString const * const TargetHash = Hashes.find(NULL);
2562 if (unlikely(TargetHash == nullptr))
2563 return;
2564 std::string const ByHash = "/by-hash/" + TargetHash->HashType() + "/" + TargetHash->HashValue();
2565 size_t const trailing_slash = Desc.URI.find_last_of("/");
2566 if (unlikely(trailing_slash == std::string::npos))
2567 return;
2568 Desc.URI = Desc.URI.replace(
2569 trailing_slash,
2570 Desc.URI.substr(trailing_slash+1).size()+1,
2571 ByHash);
2572 }
2573 else if (unlikely(CurrentCompressionExtension.empty()))
2574 return;
2575 else
2576 {
2577 Desc.URI = URI + '.' + CurrentCompressionExtension;
2578 DestFile = DestFile + '.' + CurrentCompressionExtension;
2579 }
2580
2581
2582 Desc.Description = URIDesc;
2583 Desc.Owner = this;
2584 Desc.ShortDesc = ShortDesc;
2585
2586 QueueURI(Desc);
2587 }
2588 /*}}}*/
2589 // AcqIndex::Custom600Headers - Insert custom request headers /*{{{*/
2590 // ---------------------------------------------------------------------
2591 /* The only header we use is the last-modified header. */
2592 string pkgAcqIndex::Custom600Headers() const
2593 {
2594
2595 string msg = "\nIndex-File: true";
2596
2597 if (TransactionManager->LastMetaIndexParser == NULL)
2598 {
2599 std::string const Final = GetFinalFilename();
2600
2601 struct stat Buf;
2602 if (stat(Final.c_str(),&Buf) == 0)
2603 msg += "\nLast-Modified: " + TimeRFC1123(Buf.st_mtime);
2604 }
2605
2606 if(Target.IsOptional)
2607 msg += "\nFail-Ignore: true";
2608
2609 return msg;
2610 }
2611 /*}}}*/
2612 // AcqIndex::Failed - getting the indexfile failed /*{{{*/
2613 void pkgAcqIndex::Failed(string const &Message,pkgAcquire::MethodConfig const * const Cnf)
2614 {
2615 Item::Failed(Message,Cnf);
2616
2617 // authorisation matches will not be fixed by other compression types
2618 if (Status != StatAuthError)
2619 {
2620 if (CompressionExtensions.empty() == false)
2621 {
2622 Init(Target.URI, Desc.Description, Desc.ShortDesc);
2623 Status = StatIdle;
2624 return;
2625 }
2626 }
2627
2628 if(Target.IsOptional && GetExpectedHashes().empty() && Stage == STAGE_DOWNLOAD)
2629 Status = StatDone;
2630 else
2631 TransactionManager->AbortTransaction();
2632 }
2633 /*}}}*/
2634 // AcqIndex::ReverifyAfterIMS - Reverify index after an ims-hit /*{{{*/
2635 void pkgAcqIndex::ReverifyAfterIMS()
2636 {
2637 // update destfile to *not* include the compression extension when doing
2638 // a reverify (as its uncompressed on disk already)
2639 DestFile = GetCompressedFileName(Target, GetPartialFileNameFromURI(Target.URI), CurrentCompressionExtension);
2640
2641 // copy FinalFile into partial/ so that we check the hash again
2642 string FinalFile = GetFinalFilename();
2643 Stage = STAGE_DECOMPRESS_AND_VERIFY;
2644 Desc.URI = "copy:" + FinalFile;
2645 QueueURI(Desc);
2646 }
2647 /*}}}*/
2648 // AcqIndex::Done - Finished a fetch /*{{{*/
2649 // ---------------------------------------------------------------------
2650 /* This goes through a number of states.. On the initial fetch the
2651 method could possibly return an alternate filename which points
2652 to the uncompressed version of the file. If this is so the file
2653 is copied into the partial directory. In all other cases the file
2654 is decompressed with a compressed uri. */
2655 void pkgAcqIndex::Done(string const &Message,
2656 HashStringList const &Hashes,
2657 pkgAcquire::MethodConfig const * const Cfg)
2658 {
2659 Item::Done(Message,Hashes,Cfg);
2660
2661 switch(Stage)
2662 {
2663 case STAGE_DOWNLOAD:
2664 StageDownloadDone(Message, Hashes, Cfg);
2665 break;
2666 case STAGE_DECOMPRESS_AND_VERIFY:
2667 StageDecompressDone(Message, Hashes, Cfg);
2668 break;
2669 }
2670 }
2671 /*}}}*/
2672 // AcqIndex::StageDownloadDone - Queue for decompress and verify /*{{{*/
2673 void pkgAcqIndex::StageDownloadDone(string const &Message, HashStringList const &,
2674 pkgAcquire::MethodConfig const * const)
2675 {
2676 Complete = true;
2677
2678 // Handle the unzipd case
2679 std::string FileName = LookupTag(Message,"Alt-Filename");
2680 if (FileName.empty() == false)
2681 {
2682 Stage = STAGE_DECOMPRESS_AND_VERIFY;
2683 Local = true;
2684 if (CurrentCompressionExtension != "uncompressed")
2685 DestFile.erase(DestFile.length() - (CurrentCompressionExtension.length() + 1));
2686 Desc.URI = "copy:" + FileName;
2687 QueueURI(Desc);
2688 SetActiveSubprocess("copy");
2689 return;
2690 }
2691 FileName = LookupTag(Message,"Filename");
2692
2693 // Methods like e.g. "file:" will give us a (compressed) FileName that is
2694 // not the "DestFile" we set, in this case we uncompress from the local file
2695 if (FileName != DestFile && RealFileExists(DestFile) == false)
2696 {
2697 Local = true;
2698 if (Target.KeepCompressed == true)
2699 {
2700 // but if we don't keep the uncompress we copy the compressed file first
2701 Stage = STAGE_DOWNLOAD;
2702 Desc.URI = "copy:" + FileName;
2703 QueueURI(Desc);
2704 SetActiveSubprocess("copy");
2705 return;
2706 }
2707 else
2708 {
2709 // symlinking ensures that the filename can be used for compression detection
2710 // that is e.g. needed for by-hash over file
2711 if (symlink(FileName.c_str(),DestFile.c_str()) != 0)
2712 _error->WarningE("pkgAcqIndex::StageDownloadDone", "Symlinking file %s to %s failed", FileName.c_str(), DestFile.c_str());
2713 else
2714 {
2715 EraseFileName = DestFile;
2716 FileName = DestFile;
2717 }
2718 }
2719 }
2720 else
2721 EraseFileName = FileName;
2722
2723 // we need to verify the file against the current Release file again
2724 // on if-modfied-since hit to avoid a stale attack against us
2725 if(StringToBool(LookupTag(Message,"IMS-Hit"),false) == true)
2726 {
2727 // The files timestamp matches, reverify by copy into partial/
2728 EraseFileName = "";
2729 ReverifyAfterIMS();
2730 return;
2731 }
2732
2733 string decompProg = "store";
2734 if (Target.KeepCompressed == true)
2735 {
2736 DestFile = "/dev/null";
2737 EraseFileName.clear();
2738 }
2739 else
2740 {
2741 if (CurrentCompressionExtension == "uncompressed")
2742 decompProg = "copy";
2743 else
2744 DestFile.erase(DestFile.length() - (CurrentCompressionExtension.length() + 1));
2745 }
2746
2747 // queue uri for the next stage
2748 Stage = STAGE_DECOMPRESS_AND_VERIFY;
2749 Desc.URI = decompProg + ":" + FileName;
2750 QueueURI(Desc);
2751 SetActiveSubprocess(decompProg);
2752 }
2753 /*}}}*/
2754 // AcqIndex::StageDecompressDone - Final verification /*{{{*/
2755 void pkgAcqIndex::StageDecompressDone(string const &,
2756 HashStringList const &,
2757 pkgAcquire::MethodConfig const * const)
2758 {
2759 if (Target.KeepCompressed == true && DestFile == "/dev/null")
2760 DestFile = GetPartialFileNameFromURI(Target.URI + '.' + CurrentCompressionExtension);
2761
2762 // Done, queue for rename on transaction finished
2763 TransactionManager->TransactionStageCopy(this, DestFile, GetFinalFilename());
2764 return;
2765 }
2766 /*}}}*/
2767 pkgAcqIndex::~pkgAcqIndex() {}
2768
2769
2770 // AcqArchive::AcqArchive - Constructor /*{{{*/
2771 // ---------------------------------------------------------------------
2772 /* This just sets up the initial fetch environment and queues the first
2773 possibilitiy */
2774 pkgAcqArchive::pkgAcqArchive(pkgAcquire * const Owner,pkgSourceList * const Sources,
2775 pkgRecords * const Recs,pkgCache::VerIterator const &Version,
2776 string &StoreFilename) :
2777 Item(Owner), d(NULL), LocalSource(false), Version(Version), Sources(Sources), Recs(Recs),
2778 StoreFilename(StoreFilename), Vf(Version.FileList()),
2779 Trusted(false)
2780 {
2781 Retries = _config->FindI("Acquire::Retries",0);
2782
2783 if (Version.Arch() == 0)
2784 {
2785 _error->Error(_("I wasn't able to locate a file for the %s package. "
2786 "This might mean you need to manually fix this package. "
2787 "(due to missing arch)"),
2788 Version.ParentPkg().FullName().c_str());
2789 return;
2790 }
2791
2792 /* We need to find a filename to determine the extension. We make the
2793 assumption here that all the available sources for this version share
2794 the same extension.. */
2795 // Skip not source sources, they do not have file fields.
2796 for (; Vf.end() == false; ++Vf)
2797 {
2798 if (Vf.File().Flagged(pkgCache::Flag::NotSource))
2799 continue;
2800 break;
2801 }
2802
2803 // Does not really matter here.. we are going to fail out below
2804 if (Vf.end() != true)
2805 {
2806 // If this fails to get a file name we will bomb out below.
2807 pkgRecords::Parser &Parse = Recs->Lookup(Vf);
2808 if (_error->PendingError() == true)
2809 return;
2810
2811 // Generate the final file name as: package_version_arch.foo
2812 StoreFilename = QuoteString(Version.ParentPkg().Name(),"_:") + '_' +
2813 QuoteString(Version.VerStr(),"_:") + '_' +
2814 QuoteString(Version.Arch(),"_:.") +
2815 "." + flExtension(Parse.FileName());
2816 }
2817
2818 // check if we have one trusted source for the package. if so, switch
2819 // to "TrustedOnly" mode - but only if not in AllowUnauthenticated mode
2820 bool const allowUnauth = _config->FindB("APT::Get::AllowUnauthenticated", false);
2821 bool const debugAuth = _config->FindB("Debug::pkgAcquire::Auth", false);
2822 bool seenUntrusted = false;
2823 for (pkgCache::VerFileIterator i = Version.FileList(); i.end() == false; ++i)
2824 {
2825 pkgIndexFile *Index;
2826 if (Sources->FindIndex(i.File(),Index) == false)
2827 continue;
2828
2829 if (debugAuth == true)
2830 std::cerr << "Checking index: " << Index->Describe()
2831 << "(Trusted=" << Index->IsTrusted() << ")" << std::endl;
2832
2833 if (Index->IsTrusted() == true)
2834 {
2835 Trusted = true;
2836 if (allowUnauth == false)
2837 break;
2838 }
2839 else
2840 seenUntrusted = true;
2841 }
2842
2843 // "allow-unauthenticated" restores apts old fetching behaviour
2844 // that means that e.g. unauthenticated file:// uris are higher
2845 // priority than authenticated http:// uris
2846 if (allowUnauth == true && seenUntrusted == true)
2847 Trusted = false;
2848
2849 // Select a source
2850 if (QueueNext() == false && _error->PendingError() == false)
2851 _error->Error(_("Can't find a source to download version '%s' of '%s'"),
2852 Version.VerStr(), Version.ParentPkg().FullName(false).c_str());
2853 }
2854 /*}}}*/
2855 // AcqArchive::QueueNext - Queue the next file source /*{{{*/
2856 // ---------------------------------------------------------------------
2857 /* This queues the next available file version for download. It checks if
2858 the archive is already available in the cache and stashs the MD5 for
2859 checking later. */
2860 bool pkgAcqArchive::QueueNext()
2861 {
2862 for (; Vf.end() == false; ++Vf)
2863 {
2864 pkgCache::PkgFileIterator const PkgF = Vf.File();
2865 // Ignore not source sources
2866 if (PkgF.Flagged(pkgCache::Flag::NotSource))
2867 continue;
2868
2869 // Try to cross match against the source list
2870 pkgIndexFile *Index;
2871 if (Sources->FindIndex(PkgF, Index) == false)
2872 continue;
2873 LocalSource = PkgF.Flagged(pkgCache::Flag::LocalSource);
2874
2875 // only try to get a trusted package from another source if that source
2876 // is also trusted
2877 if(Trusted && !Index->IsTrusted())
2878 continue;
2879
2880 // Grab the text package record
2881 pkgRecords::Parser &Parse = Recs->Lookup(Vf);
2882 if (_error->PendingError() == true)
2883 return false;
2884
2885 string PkgFile = Parse.FileName();
2886 ExpectedHashes = Parse.Hashes();
2887
2888 if (PkgFile.empty() == true)
2889 return _error->Error(_("The package index files are corrupted. No Filename: "
2890 "field for package %s."),
2891 Version.ParentPkg().Name());
2892
2893 Desc.URI = Index->ArchiveURI(PkgFile);
2894 Desc.Description = Index->ArchiveInfo(Version);
2895 Desc.Owner = this;
2896 Desc.ShortDesc = Version.ParentPkg().FullName(true);
2897
2898 // See if we already have the file. (Legacy filenames)
2899 FileSize = Version->Size;
2900 string FinalFile = _config->FindDir("Dir::Cache::Archives") + flNotDir(PkgFile);
2901 struct stat Buf;
2902 if (stat(FinalFile.c_str(),&Buf) == 0)
2903 {
2904 // Make sure the size matches
2905 if ((unsigned long long)Buf.st_size == Version->Size)
2906 {
2907 Complete = true;
2908 Local = true;
2909 Status = StatDone;
2910 StoreFilename = DestFile = FinalFile;
2911 return true;
2912 }
2913
2914 /* Hmm, we have a file and its size does not match, this means it is
2915 an old style mismatched arch */
2916 RemoveFile("pkgAcqArchive::QueueNext", FinalFile);
2917 }
2918
2919 // Check it again using the new style output filenames
2920 FinalFile = _config->FindDir("Dir::Cache::Archives") + flNotDir(StoreFilename);
2921 if (stat(FinalFile.c_str(),&Buf) == 0)
2922 {
2923 // Make sure the size matches
2924 if ((unsigned long long)Buf.st_size == Version->Size)
2925 {
2926 Complete = true;
2927 Local = true;
2928 Status = StatDone;
2929 StoreFilename = DestFile = FinalFile;
2930 return true;
2931 }
2932
2933 /* Hmm, we have a file and its size does not match, this shouldn't
2934 happen.. */
2935 RemoveFile("pkgAcqArchive::QueueNext", FinalFile);
2936 }
2937
2938 DestFile = _config->FindDir("Dir::Cache::Archives") + "partial/" + flNotDir(StoreFilename);
2939
2940 // Check the destination file
2941 if (stat(DestFile.c_str(),&Buf) == 0)
2942 {
2943 // Hmm, the partial file is too big, erase it
2944 if ((unsigned long long)Buf.st_size > Version->Size)
2945 RemoveFile("pkgAcqArchive::QueueNext", DestFile);
2946 else
2947 PartialSize = Buf.st_size;
2948 }
2949
2950 // Disables download of archives - useful if no real installation follows,
2951 // e.g. if we are just interested in proposed installation order
2952 if (_config->FindB("Debug::pkgAcqArchive::NoQueue", false) == true)
2953 {
2954 Complete = true;
2955 Local = true;
2956 Status = StatDone;
2957 StoreFilename = DestFile = FinalFile;
2958 return true;
2959 }
2960
2961 // Create the item
2962 Local = false;
2963 QueueURI(Desc);
2964
2965 ++Vf;
2966 return true;
2967 }
2968 return false;
2969 }
2970 /*}}}*/
2971 // AcqArchive::Done - Finished fetching /*{{{*/
2972 // ---------------------------------------------------------------------
2973 /* */
2974 void pkgAcqArchive::Done(string const &Message, HashStringList const &Hashes,
2975 pkgAcquire::MethodConfig const * const Cfg)
2976 {
2977 Item::Done(Message, Hashes, Cfg);
2978
2979 // Grab the output filename
2980 std::string const FileName = LookupTag(Message,"Filename");
2981 if (DestFile != FileName && RealFileExists(DestFile) == false)
2982 {
2983 StoreFilename = DestFile = FileName;
2984 Local = true;
2985 Complete = true;
2986 return;
2987 }
2988
2989 // Done, move it into position
2990 string const FinalFile = GetFinalFilename();
2991 Rename(DestFile,FinalFile);
2992 StoreFilename = DestFile = FinalFile;
2993 Complete = true;
2994 }
2995 /*}}}*/
2996 // AcqArchive::Failed - Failure handler /*{{{*/
2997 // ---------------------------------------------------------------------
2998 /* Here we try other sources */
2999 void pkgAcqArchive::Failed(string const &Message,pkgAcquire::MethodConfig const * const Cnf)
3000 {
3001 Item::Failed(Message,Cnf);
3002
3003 /* We don't really want to retry on failed media swaps, this prevents
3004 that. An interesting observation is that permanent failures are not
3005 recorded. */
3006 if (Cnf->Removable == true &&
3007 StringToBool(LookupTag(Message,"Transient-Failure"),false) == true)
3008 {
3009 // Vf = Version.FileList();
3010 while (Vf.end() == false) ++Vf;
3011 StoreFilename = string();
3012 return;
3013 }
3014
3015 Status = StatIdle;
3016 if (QueueNext() == false)
3017 {
3018 // This is the retry counter
3019 if (Retries != 0 &&
3020 Cnf->LocalOnly == false &&
3021 StringToBool(LookupTag(Message,"Transient-Failure"),false) == true)
3022 {
3023 Retries--;
3024 Vf = Version.FileList();
3025 if (QueueNext() == true)
3026 return;
3027 }
3028
3029 StoreFilename = string();
3030 Status = StatError;
3031 }
3032 }
3033 /*}}}*/
3034 APT_PURE bool pkgAcqArchive::IsTrusted() const /*{{{*/
3035 {
3036 return Trusted;
3037 }
3038 /*}}}*/
3039 void pkgAcqArchive::Finished() /*{{{*/
3040 {
3041 if (Status == pkgAcquire::Item::StatDone &&
3042 Complete == true)
3043 return;
3044 StoreFilename = string();
3045 }
3046 /*}}}*/
3047 std::string pkgAcqArchive::DescURI() const /*{{{*/
3048 {
3049 return Desc.URI;
3050 }
3051 /*}}}*/
3052 std::string pkgAcqArchive::ShortDesc() const /*{{{*/
3053 {
3054 return Desc.ShortDesc;
3055 }
3056 /*}}}*/
3057 pkgAcqArchive::~pkgAcqArchive() {}
3058
3059 // AcqChangelog::pkgAcqChangelog - Constructors /*{{{*/
3060 pkgAcqChangelog::pkgAcqChangelog(pkgAcquire * const Owner, pkgCache::VerIterator const &Ver,
3061 std::string const &DestDir, std::string const &DestFilename) :
3062 pkgAcquire::Item(Owner), d(NULL), SrcName(Ver.SourcePkgName()), SrcVersion(Ver.SourceVerStr())
3063 {
3064 Desc.URI = URI(Ver);
3065 Init(DestDir, DestFilename);
3066 }
3067 // some parameters are char* here as they come likely from char* interfaces – which can also return NULL
3068 pkgAcqChangelog::pkgAcqChangelog(pkgAcquire * const Owner, pkgCache::RlsFileIterator const &RlsFile,
3069 char const * const Component, char const * const SrcName, char const * const SrcVersion,
3070 const string &DestDir, const string &DestFilename) :
3071 pkgAcquire::Item(Owner), d(NULL), SrcName(SrcName), SrcVersion(SrcVersion)
3072 {
3073 Desc.URI = URI(RlsFile, Component, SrcName, SrcVersion);
3074 Init(DestDir, DestFilename);
3075 }
3076 pkgAcqChangelog::pkgAcqChangelog(pkgAcquire * const Owner,
3077 std::string const &URI, char const * const SrcName, char const * const SrcVersion,
3078 const string &DestDir, const string &DestFilename) :
3079 pkgAcquire::Item(Owner), d(NULL), SrcName(SrcName), SrcVersion(SrcVersion)
3080 {
3081 Desc.URI = URI;
3082 Init(DestDir, DestFilename);
3083 }
3084 void pkgAcqChangelog::Init(std::string const &DestDir, std::string const &DestFilename)
3085 {
3086 if (Desc.URI.empty())
3087 {
3088 Status = StatError;
3089 // TRANSLATOR: %s=%s is sourcename=sourceversion, e.g. apt=1.1
3090 strprintf(ErrorText, _("Changelog unavailable for %s=%s"), SrcName.c_str(), SrcVersion.c_str());
3091 // Let the error message print something sensible rather than "Failed to fetch /"
3092 if (DestFilename.empty())
3093 DestFile = SrcName + ".changelog";
3094 else
3095 DestFile = DestFilename;
3096 Desc.URI = "changelog:/" + DestFile;
3097 return;
3098 }
3099
3100 if (DestDir.empty())
3101 {
3102 std::string const SandboxUser = _config->Find("APT::Sandbox::User");
3103 std::string const systemTemp = GetTempDir(SandboxUser);
3104 char tmpname[100];
3105 snprintf(tmpname, sizeof(tmpname), "%s/apt-changelog-XXXXXX", systemTemp.c_str());
3106 if (NULL == mkdtemp(tmpname))
3107 {
3108 _error->Errno("mkdtemp", "mkdtemp failed in changelog acquire of %s %s", SrcName.c_str(), SrcVersion.c_str());
3109 Status = StatError;
3110 return;
3111 }
3112 DestFile = TemporaryDirectory = tmpname;
3113
3114 ChangeOwnerAndPermissionOfFile("Item::QueueURI", DestFile.c_str(),
3115 SandboxUser.c_str(), "root", 0700);
3116 }
3117 else
3118 DestFile = DestDir;
3119
3120 if (DestFilename.empty())
3121 DestFile = flCombine(DestFile, SrcName + ".changelog");
3122 else
3123 DestFile = flCombine(DestFile, DestFilename);
3124
3125 Desc.ShortDesc = "Changelog";
3126 strprintf(Desc.Description, "%s %s %s Changelog", URI::SiteOnly(Desc.URI).c_str(), SrcName.c_str(), SrcVersion.c_str());
3127 Desc.Owner = this;
3128 QueueURI(Desc);
3129 }
3130 /*}}}*/
3131 std::string pkgAcqChangelog::URI(pkgCache::VerIterator const &Ver) /*{{{*/
3132 {
3133 char const * const SrcName = Ver.SourcePkgName();
3134 char const * const SrcVersion = Ver.SourceVerStr();
3135 pkgCache::PkgFileIterator PkgFile;
3136 // find the first source for this version which promises a changelog
3137 for (pkgCache::VerFileIterator VF = Ver.FileList(); VF.end() == false; ++VF)
3138 {
3139 pkgCache::PkgFileIterator const PF = VF.File();
3140 if (PF.Flagged(pkgCache::Flag::NotSource) || PF->Release == 0)
3141 continue;
3142 PkgFile = PF;
3143 pkgCache::RlsFileIterator const RF = PF.ReleaseFile();
3144 std::string const uri = URI(RF, PF.Component(), SrcName, SrcVersion);
3145 if (uri.empty())
3146 continue;
3147 return uri;
3148 }
3149 return "";
3150 }
3151 std::string pkgAcqChangelog::URITemplate(pkgCache::RlsFileIterator const &Rls)
3152 {
3153 if (Rls.end() == true || (Rls->Label == 0 && Rls->Origin == 0))
3154 return "";
3155 std::string const serverConfig = "Acquire::Changelogs::URI";
3156 std::string server;
3157 #define APT_EMPTY_SERVER \
3158 if (server.empty() == false) \
3159 { \
3160 if (server != "no") \
3161 return server; \
3162 return ""; \
3163 }
3164 #define APT_CHECK_SERVER(X, Y) \
3165 if (Rls->X != 0) \
3166 { \
3167 std::string const specialServerConfig = serverConfig + "::" + Y + #X + "::" + Rls.X(); \
3168 server = _config->Find(specialServerConfig); \
3169 APT_EMPTY_SERVER \
3170 }
3171 // this way e.g. Debian-Security can fallback to Debian
3172 APT_CHECK_SERVER(Label, "Override::")
3173 APT_CHECK_SERVER(Origin, "Override::")
3174
3175 if (RealFileExists(Rls.FileName()))
3176 {
3177 _error->PushToStack();
3178 FileFd rf;
3179 /* This can be costly. A caller wanting to get millions of URIs might
3180 want to do this on its own once and use Override settings.
3181 We don't do this here as Origin/Label are not as unique as they
3182 should be so this could produce request order-dependent anomalies */
3183 if (OpenMaybeClearSignedFile(Rls.FileName(), rf) == true)
3184 {
3185 pkgTagFile TagFile(&rf, rf.Size());
3186 pkgTagSection Section;
3187 if (TagFile.Step(Section) == true)
3188 server = Section.FindS("Changelogs");
3189 }
3190 _error->RevertToStack();
3191 APT_EMPTY_SERVER
3192 }
3193
3194 APT_CHECK_SERVER(Label, "")
3195 APT_CHECK_SERVER(Origin, "")
3196 #undef APT_CHECK_SERVER
3197 #undef APT_EMPTY_SERVER
3198 return "";
3199 }
3200 std::string pkgAcqChangelog::URI(pkgCache::RlsFileIterator const &Rls,
3201 char const * const Component, char const * const SrcName,
3202 char const * const SrcVersion)
3203 {
3204 return URI(URITemplate(Rls), Component, SrcName, SrcVersion);
3205 }
3206 std::string pkgAcqChangelog::URI(std::string const &Template,
3207 char const * const Component, char const * const SrcName,
3208 char const * const SrcVersion)
3209 {
3210 if (Template.find("@CHANGEPATH@") == std::string::npos)
3211 return "";
3212
3213 // the path is: COMPONENT/SRC/SRCNAME/SRCNAME_SRCVER, e.g. main/a/apt/1.1 or contrib/liba/libapt/2.0
3214 std::string Src = SrcName;
3215 std::string path = APT::String::Startswith(SrcName, "lib") ? Src.substr(0, 4) : Src.substr(0,1);
3216 path.append("/").append(Src).append("/");
3217 path.append(Src).append("_").append(StripEpoch(SrcVersion));
3218 // we omit component for releases without one (= flat-style repositories)
3219 if (Component != NULL && strlen(Component) != 0)
3220 path = std::string(Component) + "/" + path;
3221
3222 return SubstVar(Template, "@CHANGEPATH@", path);
3223 }
3224 /*}}}*/
3225 // AcqChangelog::Failed - Failure handler /*{{{*/
3226 void pkgAcqChangelog::Failed(string const &Message, pkgAcquire::MethodConfig const * const Cnf)
3227 {
3228 Item::Failed(Message,Cnf);
3229
3230 std::string errText;
3231 // TRANSLATOR: %s=%s is sourcename=sourceversion, e.g. apt=1.1
3232 strprintf(errText, _("Changelog unavailable for %s=%s"), SrcName.c_str(), SrcVersion.c_str());
3233
3234 // Error is probably something techy like 404 Not Found
3235 if (ErrorText.empty())
3236 ErrorText = errText;
3237 else
3238 ErrorText = errText + " (" + ErrorText + ")";
3239 return;
3240 }
3241 /*}}}*/
3242 // AcqChangelog::Done - Item downloaded OK /*{{{*/
3243 void pkgAcqChangelog::Done(string const &Message,HashStringList const &CalcHashes,
3244 pkgAcquire::MethodConfig const * const Cnf)
3245 {
3246 Item::Done(Message,CalcHashes,Cnf);
3247
3248 Complete = true;
3249 }
3250 /*}}}*/
3251 pkgAcqChangelog::~pkgAcqChangelog() /*{{{*/
3252 {
3253 if (TemporaryDirectory.empty() == false)
3254 {
3255 RemoveFile("~pkgAcqChangelog", DestFile);
3256 rmdir(TemporaryDirectory.c_str());
3257 }
3258 }
3259 /*}}}*/
3260
3261 // AcqFile::pkgAcqFile - Constructor /*{{{*/
3262 pkgAcqFile::pkgAcqFile(pkgAcquire * const Owner,string const &URI, HashStringList const &Hashes,
3263 unsigned long long const Size,string const &Dsc,string const &ShortDesc,
3264 const string &DestDir, const string &DestFilename,
3265 bool const IsIndexFile) :
3266 Item(Owner), d(NULL), IsIndexFile(IsIndexFile), ExpectedHashes(Hashes)
3267 {
3268 Retries = _config->FindI("Acquire::Retries",0);
3269
3270 if(!DestFilename.empty())
3271 DestFile = DestFilename;
3272 else if(!DestDir.empty())
3273 DestFile = DestDir + "/" + flNotDir(URI);
3274 else
3275 DestFile = flNotDir(URI);
3276
3277 // Create the item
3278 Desc.URI = URI;
3279 Desc.Description = Dsc;
3280 Desc.Owner = this;
3281
3282 // Set the short description to the archive component
3283 Desc.ShortDesc = ShortDesc;
3284
3285 // Get the transfer sizes
3286 FileSize = Size;
3287 struct stat Buf;
3288 if (stat(DestFile.c_str(),&Buf) == 0)
3289 {
3290 // Hmm, the partial file is too big, erase it
3291 if ((Size > 0) && (unsigned long long)Buf.st_size > Size)
3292 RemoveFile("pkgAcqFile", DestFile);
3293 else
3294 PartialSize = Buf.st_size;
3295 }
3296
3297 QueueURI(Desc);
3298 }
3299 /*}}}*/
3300 // AcqFile::Done - Item downloaded OK /*{{{*/
3301 void pkgAcqFile::Done(string const &Message,HashStringList const &CalcHashes,
3302 pkgAcquire::MethodConfig const * const Cnf)
3303 {
3304 Item::Done(Message,CalcHashes,Cnf);
3305
3306 std::string const FileName = LookupTag(Message,"Filename");
3307 Complete = true;
3308
3309 // The files timestamp matches
3310 if (StringToBool(LookupTag(Message,"IMS-Hit"),false) == true)
3311 return;
3312
3313 // We have to copy it into place
3314 if (RealFileExists(DestFile.c_str()) == false)
3315 {
3316 Local = true;
3317 if (_config->FindB("Acquire::Source-Symlinks",true) == false ||
3318 Cnf->Removable == true)
3319 {
3320 Desc.URI = "copy:" + FileName;
3321 QueueURI(Desc);
3322 return;
3323 }
3324
3325 // Erase the file if it is a symlink so we can overwrite it
3326 struct stat St;
3327 if (lstat(DestFile.c_str(),&St) == 0)
3328 {
3329 if (S_ISLNK(St.st_mode) != 0)
3330 RemoveFile("pkgAcqFile::Done", DestFile);
3331 }
3332
3333 // Symlink the file
3334 if (symlink(FileName.c_str(),DestFile.c_str()) != 0)
3335 {
3336 _error->PushToStack();
3337 _error->Errno("pkgAcqFile::Done", "Symlinking file %s failed", DestFile.c_str());
3338 std::stringstream msg;
3339 _error->DumpErrors(msg, GlobalError::DEBUG, false);
3340 _error->RevertToStack();
3341 ErrorText = msg.str();
3342 Status = StatError;
3343 Complete = false;
3344 }
3345 }
3346 }
3347 /*}}}*/
3348 // AcqFile::Failed - Failure handler /*{{{*/
3349 // ---------------------------------------------------------------------
3350 /* Here we try other sources */
3351 void pkgAcqFile::Failed(string const &Message, pkgAcquire::MethodConfig const * const Cnf)
3352 {
3353 Item::Failed(Message,Cnf);
3354
3355 // This is the retry counter
3356 if (Retries != 0 &&
3357 Cnf->LocalOnly == false &&
3358 StringToBool(LookupTag(Message,"Transient-Failure"),false) == true)
3359 {
3360 --Retries;
3361 QueueURI(Desc);
3362 Status = StatIdle;
3363 return;
3364 }
3365
3366 }
3367 /*}}}*/
3368 string pkgAcqFile::Custom600Headers() const /*{{{*/
3369 {
3370 if (IsIndexFile)
3371 return "\nIndex-File: true";
3372 return "";
3373 }
3374 /*}}}*/
3375 pkgAcqFile::~pkgAcqFile() {}