X-Git-Url: https://git.saurik.com/apt.git/blobdiff_plain/95278287f4e1eeaf5d96749d6fc9bfc53fb400d0..831ea74cddf8568b8648edddb394fdd3d1ba7b8e:/apt-pkg/acquire-item.cc diff --git a/apt-pkg/acquire-item.cc b/apt-pkg/acquire-item.cc index c5b701fdc..446551cc2 100644 --- a/apt-pkg/acquire-item.cc +++ b/apt-pkg/acquire-item.cc @@ -85,32 +85,16 @@ static std::string GetKeepCompressedFileName(std::string file, IndexTarget const if (Target.KeepCompressed == false) return file; - std::string const CompressionTypes = Target.Option(IndexTarget::COMPRESSIONTYPES); - if (CompressionTypes.empty() == false) + std::string const KeepCompressedAs = Target.Option(IndexTarget::KEEPCOMPRESSEDAS); + if (KeepCompressedAs.empty() == false) { - std::string const ext = CompressionTypes.substr(0, CompressionTypes.find(' ')); + std::string const ext = KeepCompressedAs.substr(0, KeepCompressedAs.find(' ')); if (ext != "uncompressed") file.append(".").append(ext); } return file; } /*}}}*/ -static std::string GetCompressedFileName(IndexTarget const &Target, std::string const &Name, std::string const &Ext) /*{{{*/ -{ - if (Ext.empty() || Ext == "uncompressed") - return Name; - - // do not reverify cdrom sources as apt-cdrom may rewrite the Packages - // file when its doing the indexcopy - if (Target.URI.substr(0,6) == "cdrom:") - return Name; - - // adjust DestFile if its compressed on disk - if (Target.KeepCompressed == true) - return Name + '.' + Ext; - return Name; -} - /*}}}*/ static std::string GetMergeDiffsPatchFileName(std::string const &Final, std::string const &Patch)/*{{{*/ { // rred expects the patch as $FinalFile.ed.$patchname.gz @@ -123,37 +107,55 @@ static std::string GetDiffsPatchFileName(std::string const &Final) /*{{{*/ return Final + ".ed"; } /*}}}*/ -static bool BootstrapPDiffWith(std::string const &PartialFile, std::string const &FinalFile, IndexTarget const &Target)/*{{{*/ +static std::string GetExistingFilename(std::string const &File) /*{{{*/ { - // patching needs to be bootstrapped with the 'old' version - std::vector types = VectorizeString(Target.Option(IndexTarget::COMPRESSIONTYPES), ' '); - auto typeItr = types.cbegin(); - for (; typeItr != types.cend(); ++typeItr) + if (RealFileExists(File)) + return File; + for (auto const &type : APT::Configuration::getCompressorExtensions()) { - std::string Final = FinalFile; - if (*typeItr != "uncompressed") - Final.append(".").append(*typeItr); - if (RealFileExists(Final) == false) - continue; - std::string Partial = PartialFile; - if (*typeItr != "uncompressed") - Partial.append(".").append(*typeItr); - if (FileExists(Partial.c_str()) == true) - return true; - if (symlink(Final.c_str(), Partial.c_str()) != 0) - return false; - break; + std::string const Final = File + type; + if (RealFileExists(Final)) + return Final; } - return typeItr != types.cend(); + return ""; } /*}}}*/ -static bool AllowInsecureRepositories(metaIndex const * const MetaIndexParser, pkgAcqMetaClearSig * const TransactionManager, pkgAcquire::Item * const I) /*{{{*/ +static bool MessageInsecureRepository(bool const isError, std::string const &msg)/*{{{*/ +{ + if (isError) + { + _error->Error("%s", msg.c_str()); + _error->Notice("%s", _("Updating from such a repository can't be done securely, and is therefore disabled by default.")); + } + else + { + _error->Warning("%s", msg.c_str()); + _error->Notice("%s", _("Data from such a repository can't be authenticated and is therefore potentially dangerous to use.")); + } + _error->Notice("%s", _("See apt-secure(8) manpage for repository creation and user configuration details.")); + return false; +} +static bool MessageInsecureRepository(bool const isError, char const * const msg, std::string const &repo) +{ + std::string m; + strprintf(m, msg, repo.c_str()); + return MessageInsecureRepository(isError, m); +} + /*}}}*/ +static bool AllowInsecureRepositories(char const * const msg, std::string const &repo,/*{{{*/ + metaIndex const * const MetaIndexParser, pkgAcqMetaClearSig * const TransactionManager, pkgAcquire::Item * const I) { - if(MetaIndexParser->GetTrusted() == metaIndex::TRI_YES || _config->FindB("Acquire::AllowInsecureRepositories") == true) + if(MetaIndexParser->GetTrusted() == metaIndex::TRI_YES) return true; - _error->Error(_("Use --allow-insecure-repositories to force the update")); + if (_config->FindB("Acquire::AllowInsecureRepositories") == true) + { + MessageInsecureRepository(false, msg, repo); + return true; + } + + MessageInsecureRepository(true, msg, repo); TransactionManager->AbortTransaction(); I->Status = pkgAcquire::Item::StatError; return false; @@ -184,7 +186,7 @@ APT_CONST bool pkgAcqTransactionItem::HashesRequired() const Only repositories without a Release file can (obviously) not have hashes – and they are very uncommon and strongly discouraged */ return TransactionManager->MetaIndexParser != NULL && - TransactionManager->MetaIndexParser->GetLoadedSuccessfully() != metaIndex::TRI_UNSET; + TransactionManager->MetaIndexParser->GetLoadedSuccessfully() == metaIndex::TRI_YES; } HashStringList pkgAcqTransactionItem::GetExpectedHashes() const { @@ -308,7 +310,7 @@ std::string pkgAcqDiffIndex::GetFinalFilename() const std::string pkgAcqIndex::GetFinalFilename() const { std::string const FinalFile = GetFinalFileNameFromURI(Target.URI); - return GetCompressedFileName(Target, FinalFile, CurrentCompressionExtension); + return GetKeepCompressedFileName(FinalFile, Target); } std::string pkgAcqMetaSig::GetFinalFilename() const { @@ -359,16 +361,66 @@ bool pkgAcqTransactionItem::TransactionState(TransactionStates const state) } break; case TransactionCommit: - if(PartialFile != "") + if(PartialFile.empty() == false) { - if(Debug == true) - std::clog << "mv " << PartialFile << " -> "<< DestFile << " # " << DescURI() << std::endl; + bool sameFile = (PartialFile == DestFile); + // we use symlinks on IMS-Hit to avoid copies + if (RealFileExists(DestFile)) + { + struct stat Buf; + if (lstat(PartialFile.c_str(), &Buf) != -1) + { + if (S_ISLNK(Buf.st_mode) && Buf.st_size > 0) + { + char partial[Buf.st_size + 1]; + ssize_t const sp = readlink(PartialFile.c_str(), partial, Buf.st_size); + if (sp == -1) + _error->Errno("pkgAcqTransactionItem::TransactionState-sp", _("Failed to readlink %s"), PartialFile.c_str()); + else + { + partial[sp] = '\0'; + sameFile = (DestFile == partial); + } + } + } + else + _error->Errno("pkgAcqTransactionItem::TransactionState-stat", _("Failed to stat %s"), PartialFile.c_str()); + } + if (sameFile == false) + { + // ensure that even without lists-cleanup all compressions are nuked + std::string FinalFile = GetFinalFileNameFromURI(Target.URI); + if (FileExists(FinalFile)) + { + if(Debug == true) + std::clog << "rm " << FinalFile << " # " << DescURI() << std::endl; + if (RemoveFile("TransactionStates-Cleanup", FinalFile) == false) + return false; + } + for (auto const &ext: APT::Configuration::getCompressorExtensions()) + { + auto const Final = FinalFile + ext; + if (FileExists(Final)) + { + if(Debug == true) + std::clog << "rm " << Final << " # " << DescURI() << std::endl; + if (RemoveFile("TransactionStates-Cleanup", Final) == false) + return false; + } + } + if(Debug == true) + std::clog << "mv " << PartialFile << " -> "<< DestFile << " # " << DescURI() << std::endl; + if (Rename(PartialFile, DestFile) == false) + return false; + } + else if(Debug == true) + std::clog << "keep " << PartialFile << " # " << DescURI() << std::endl; - Rename(PartialFile, DestFile); } else { if(Debug == true) std::clog << "rm " << DestFile << " # " << DescURI() << std::endl; - unlink(DestFile.c_str()); + if (RemoveFile("TransactionCommit", DestFile) == false) + return false; } break; } @@ -393,13 +445,13 @@ bool pkgAcqIndex::TransactionState(TransactionStates const state) { // keep the compressed file, but drop the decompressed EraseFileName.clear(); - if (PartialFile.empty() == false && flExtension(PartialFile) == "decomp") - unlink(PartialFile.c_str()); + if (PartialFile.empty() == false && flExtension(PartialFile) != CurrentCompressionExtension) + RemoveFile("TransactionAbort", PartialFile); } break; case TransactionCommit: if (EraseFileName.empty() == false) - unlink(EraseFileName.c_str()); + RemoveFile("TransactionCommit", EraseFileName); break; } return true; @@ -415,7 +467,7 @@ bool pkgAcqDiffIndex::TransactionState(TransactionStates const state) break; case TransactionAbort: std::string const Partial = GetPartialFileNameFromURI(Target.URI); - unlink(Partial.c_str()); + RemoveFile("TransactionAbort", Partial); break; } @@ -909,7 +961,7 @@ bool pkgAcqMetaBase::CheckDownloadDone(pkgAcqTransactionItem * const I, const st if (RealFileExists(FinalFile) && Hashes.VerifyFile(FinalFile) == true) { IMSHit = true; - unlink(I->DestFile.c_str()); + RemoveFile("CheckDownloadDone", I->DestFile); } } @@ -999,10 +1051,28 @@ void pkgAcqMetaBase::QueueIndexes(bool const verify) /*{{{*/ // at this point the real Items are loaded in the fetcher ExpectedAdditionalItems = 0; + bool metaBaseSupportsByHash = false; + if (TransactionManager != NULL && TransactionManager->MetaIndexParser != NULL) + metaBaseSupportsByHash = TransactionManager->MetaIndexParser->GetSupportsAcquireByHash(); + for (std::vector ::iterator Target = IndexTargets.begin(); Target != IndexTargets.end(); ++Target) { + // all is an implementation detail. Users shouldn't use this as arch + // We need this support trickery here as e.g. Debian has binary-all files already, + // but arch:all packages are still in the arch:any files, so we would waste precious + // download time, bandwidth and diskspace for nothing, BUT Debian doesn't feature all + // in the set of supported architectures, so we can filter based on this property rather + // than invent an entirely new flag we would need to carry for all of eternity. + if (Target->Option(IndexTarget::ARCHITECTURE) == "all") + { + if (TransactionManager->MetaIndexParser->IsArchitectureSupported("all") == false) + continue; + if (TransactionManager->MetaIndexParser->IsArchitectureAllSupportedFor(*Target) == false) + continue; + } + bool trypdiff = Target->OptionBool(IndexTarget::PDIFFS); if (verify == true) { @@ -1012,10 +1082,36 @@ void pkgAcqMetaBase::QueueIndexes(bool const verify) /*{{{*/ if (Target->IsOptional) continue; + std::string const &arch = Target->Option(IndexTarget::ARCHITECTURE); + if (arch.empty() == false) + { + if (TransactionManager->MetaIndexParser->IsArchitectureSupported(arch) == false) + { + _error->Notice(_("Skipping acquire of configured file '%s' as repository '%s' doesn't support architecture '%s'"), + Target->MetaKey.c_str(), TransactionManager->Target.Description.c_str(), arch.c_str()); + continue; + } + // if the architecture is officially supported but currently no packages for it available, + // ignore silently as this is pretty much the same as just shipping an empty file. + // if we don't know which architectures are supported, we do NOT ignore it to notify user about this + if (TransactionManager->MetaIndexParser->IsArchitectureSupported("*undefined*") == false) + continue; + } + Status = StatAuthError; strprintf(ErrorText, _("Unable to find expected entry '%s' in Release file (Wrong sources.list entry or malformed file)"), Target->MetaKey.c_str()); return; } + else + { + auto const hashes = GetExpectedHashesFor(Target->MetaKey); + if (hashes.usable() == false && hashes.empty() == false) + { + _error->Warning(_("Skipping acquire of configured file '%s' as repository '%s' provides only weak security information for it"), + Target->MetaKey.c_str(), TransactionManager->Target.Description.c_str()); + continue; + } + } // autoselect the compression method std::vector types = VectorizeString(Target->Option(IndexTarget::COMPRESSIONTYPES), ' '); @@ -1028,6 +1124,15 @@ void pkgAcqMetaBase::QueueIndexes(bool const verify) /*{{{*/ if (types.empty() == false) { std::ostringstream os; + // add the special compressiontype byhash first if supported + std::string const useByHashConf = Target->Option(IndexTarget::BY_HASH); + bool useByHash = false; + if(useByHashConf == "force") + useByHash = true; + else + useByHash = StringToBool(useByHashConf) == true && metaBaseSupportsByHash; + if (useByHash == true) + os << "by-hash "; std::copy(types.begin(), types.end()-1, std::ostream_iterator(os, " ")); os << *types.rbegin(); Target->Options["COMPRESSIONTYPES"] = os.str(); @@ -1035,19 +1140,7 @@ void pkgAcqMetaBase::QueueIndexes(bool const verify) /*{{{*/ else Target->Options["COMPRESSIONTYPES"].clear(); - std::string filename = GetFinalFileNameFromURI(Target->URI); - if (RealFileExists(filename) == false) - { - if (Target->KeepCompressed) - { - filename = GetKeepCompressedFileName(filename, *Target); - if (RealFileExists(filename) == false) - filename.clear(); - } - else - filename.clear(); - } - + std::string filename = GetExistingFilename(GetFinalFileNameFromURI(Target->URI)); if (filename.empty() == false) { // if the Release file is a hit and we have an index it must be the current one @@ -1072,6 +1165,9 @@ void pkgAcqMetaBase::QueueIndexes(bool const verify) /*{{{*/ if (filename.empty() == false) { new NoActionItem(Owner, *Target, filename); + std::string const idxfilename = GetFinalFileNameFromURI(Target->URI + ".diff/Index"); + if (FileExists(idxfilename)) + new NoActionItem(Owner, *Target, idxfilename); continue; } @@ -1081,19 +1177,7 @@ void pkgAcqMetaBase::QueueIndexes(bool const verify) /*{{{*/ else { // if we have no file to patch, no point in trying - std::string filename = GetFinalFileNameFromURI(Target->URI); - if (RealFileExists(filename) == false) - { - if (Target->KeepCompressed) - { - filename = GetKeepCompressedFileName(filename, *Target); - if (RealFileExists(filename) == false) - filename.clear(); - } - else - filename.clear(); - } - trypdiff &= (filename.empty() == false); + trypdiff &= (GetExistingFilename(GetFinalFileNameFromURI(Target->URI)).empty() == false); } // no point in patching from local sources @@ -1174,7 +1258,7 @@ bool pkgAcqMetaBase::VerifyVendor(string const &Message) /*{{{*/ TransactionManager->LastMetaIndexParser->GetDate() > TransactionManager->MetaIndexParser->GetDate()) { TransactionManager->IMSHit = true; - unlink(DestFile.c_str()); + RemoveFile("VerifyVendor", DestFile); PartialFile = DestFile = GetFinalFilename(); // load the 'old' file in the 'new' one instead of flipping pointers as // the new one isn't owned by us, while the old one is so cleanup would be confused. @@ -1247,7 +1331,7 @@ string pkgAcqMetaClearSig::Custom600Headers() const return Header; } /*}}}*/ -bool pkgAcqMetaClearSig::VerifyDone(std::string const &Message, +bool pkgAcqMetaClearSig::VerifyDone(std::string const &Message, /*{{{*/ pkgAcquire::MethodConfig const * const Cnf) { Item::VerifyDone(Message, Cnf); @@ -1257,6 +1341,7 @@ bool pkgAcqMetaClearSig::VerifyDone(std::string const &Message, return true; } + /*}}}*/ // pkgAcqMetaClearSig::Done - We got a file /*{{{*/ void pkgAcqMetaClearSig::Done(std::string const &Message, HashStringList const &Hashes, @@ -1294,10 +1379,10 @@ void pkgAcqMetaClearSig::Failed(string const &Message,pkgAcquire::MethodConfig c if (AuthPass == false) { - if (Status == StatAuthError) + if (Status == StatAuthError || Status == StatTransientNetworkError) { - // if we expected a ClearTextSignature (InRelease) and got a file, - // but it wasn't valid we end up here (see VerifyDone). + // if we expected a ClearTextSignature (InRelease) but got a network + // error or got a file, but it wasn't valid, we end up here (see VerifyDone). // As these is usually called by web-portals we do not try Release/Release.gpg // as this is gonna fail anyway and instead abort our try (LP#346386) TransactionManager->AbortTransaction(); @@ -1317,14 +1402,10 @@ void pkgAcqMetaClearSig::Failed(string const &Message,pkgAcquire::MethodConfig c if(CheckStopAuthentication(this, Message)) return; - _error->Warning(_("The data from '%s' is not signed. Packages " - "from that repository can not be authenticated."), - ClearsignedTarget.Description.c_str()); - // No Release file was present, or verification failed, so fall // back to queueing Packages files without verification - // only allow going further if the users explicitely wants it - if(AllowInsecureRepositories(TransactionManager->MetaIndexParser, TransactionManager, this) == true) + // only allow going further if the user explicitly wants it + if(AllowInsecureRepositories(_("The repository '%s' is not signed."), ClearsignedTarget.Description, TransactionManager->MetaIndexParser, TransactionManager, this) == true) { Status = StatDone; @@ -1419,14 +1500,10 @@ void pkgAcqMetaIndex::Failed(string const &Message, pkgAcquire::Item::Failed(Message, Cnf); Status = StatDone; - _error->Warning(_("The repository '%s' does not have a Release file. " - "This is deprecated, please contact the owner of the " - "repository."), Target.Description.c_str()); - // No Release file was present so fall // back to queueing Packages files without verification - // only allow going further if the users explicitely wants it - if(AllowInsecureRepositories(TransactionManager->MetaIndexParser, TransactionManager, this) == true) + // only allow going further if the user explicitly wants it + if(AllowInsecureRepositories(_("The repository '%s' does not have a Release file."), Target.Description, TransactionManager->MetaIndexParser, TransactionManager, this) == true) { // ensure old Release files are removed TransactionManager->TransactionStageRemoval(this, GetFinalFilename()); @@ -1464,7 +1541,7 @@ pkgAcqMetaSig::pkgAcqMetaSig(pkgAcquire * const Owner, // remove any partial downloaded sig-file in partial/. // it may confuse proxies and is too small to warrant a // partial download anyway - unlink(DestFile.c_str()); + RemoveFile("pkgAcqMetaSig", DestFile); // set the TransactionManager if(_config->FindB("Debug::Acquire::Transaction", false) == true) @@ -1564,7 +1641,7 @@ void pkgAcqMetaSig::Failed(string const &Message,pkgAcquire::MethodConfig const "given to override it.")); Status = StatDone; } else { - _error->Error("%s", downgrade_msg.c_str()); + MessageInsecureRepository(true, downgrade_msg); if (TransactionManager->IMSHit == false) Rename(MetaIndex->DestFile, MetaIndex->DestFile + ".FAILED"); Item::Failed("Message: " + downgrade_msg, Cnf); @@ -1572,16 +1649,12 @@ void pkgAcqMetaSig::Failed(string const &Message,pkgAcquire::MethodConfig const return; } } - else - _error->Warning(_("The data from '%s' is not signed. Packages " - "from that repository can not be authenticated."), - MetaIndex->Target.Description.c_str()); // ensures that a Release.gpg file in the lists/ is removed by the transaction TransactionManager->TransactionStageRemoval(this, DestFile); - // only allow going further if the users explicitely wants it - if(AllowInsecureRepositories(TransactionManager->MetaIndexParser, TransactionManager, this) == true) + // only allow going further if the user explicitly wants it + if (AllowInsecureRepositories(_("The repository '%s' is not signed."), MetaIndex->Target.Description, TransactionManager->MetaIndexParser, TransactionManager, this) == true) { if (RealFileExists(FinalReleasegpg) || RealFileExists(FinalInRelease)) { @@ -1609,10 +1682,11 @@ void pkgAcqMetaSig::Failed(string const &Message,pkgAcquire::MethodConfig const // we parse the indexes here because at this point the user wanted // a repository that may potentially harm him - if (TransactionManager->MetaIndexParser->Load(MetaIndex->DestFile, &ErrorText) == false || MetaIndex->VerifyVendor(Message) == false) + bool const GoodLoad = TransactionManager->MetaIndexParser->Load(MetaIndex->DestFile, &ErrorText); + if (MetaIndex->VerifyVendor(Message) == false) /* expired Release files are still a problem you need extra force for */; else - MetaIndex->QueueIndexes(true); + MetaIndex->QueueIndexes(GoodLoad); TransactionManager->TransactionStageCopy(MetaIndex, MetaIndex->DestFile, MetaIndex->GetFinalFilename()); } @@ -1670,6 +1744,9 @@ pkgAcqDiffIndex::pkgAcqDiffIndex(pkgAcquire * const Owner, /* The only header we use is the last-modified header. */ string pkgAcqDiffIndex::Custom600Headers() const { + if (TransactionManager->LastMetaIndexParser != NULL) + return "\nIndex-File: true"; + string const Final = GetFinalFilename(); if(Debug) @@ -1773,10 +1850,18 @@ bool pkgAcqDiffIndex::ParseDiffIndex(string const &IndexDiffFile) /*{{{*/ std::clog << "Server-Current: " << ServerHashes.find(NULL)->toStr() << " and we start at " << CurrentPackagesFile << " " << LocalHashes.FileSize() << " " << LocalHashes.find(NULL)->toStr() << std::endl; + // historically, older hashes have more info than newer ones, so start + // collecting with older ones first to avoid implementing complicated + // information merging techniques… a failure is after all always + // recoverable with a complete file and hashes aren't changed that often. + std::vector types; + for (char const * const * type = HashString::SupportedHashes(); *type != NULL; ++type) + types.push_back(*type); + // parse all of (provided) history vector available_patches; bool firstAcceptedHashes = true; - for (char const * const * type = HashString::SupportedHashes(); *type != NULL; ++type) + for (auto type = types.crbegin(); type != types.crend(); ++type) { if (LocalHashes.find(*type) == NULL) continue; @@ -1834,7 +1919,7 @@ bool pkgAcqDiffIndex::ParseDiffIndex(string const &IndexDiffFile) /*{{{*/ return false; } - for (char const * const * type = HashString::SupportedHashes(); *type != NULL; ++type) + for (auto type = types.crbegin(); type != types.crend(); ++type) { if (LocalHashes.find(*type) == NULL) continue; @@ -1874,7 +1959,7 @@ bool pkgAcqDiffIndex::ParseDiffIndex(string const &IndexDiffFile) /*{{{*/ } } - for (char const * const * type = HashString::SupportedHashes(); *type != NULL; ++type) + for (auto type = types.crbegin(); type != types.crend(); ++type) { std::string tagname = *type; tagname.append("-Download"); @@ -1947,18 +2032,55 @@ bool pkgAcqDiffIndex::ParseDiffIndex(string const &IndexDiffFile) /*{{{*/ } // calculate the size of all patches we have to get - // note that all sizes are uncompressed, while we download compressed files - unsigned long long patchesSize = 0; - for (std::vector::const_iterator cur = available_patches.begin(); - cur != available_patches.end(); ++cur) - patchesSize += cur->patch_hashes.FileSize(); - unsigned long long const sizeLimit = ServerSize * _config->FindI("Acquire::PDiffs::SizeLimit", 100); - if (sizeLimit > 0 && (sizeLimit/100) < patchesSize) - { - if (Debug) - std::clog << "Need " << patchesSize << " bytes (Limit is " << sizeLimit/100 - << ") so fallback to complete download" << std::endl; - return false; + unsigned short const sizeLimitPercent = _config->FindI("Acquire::PDiffs::SizeLimit", 100); + if (sizeLimitPercent > 0 && TransactionManager->MetaIndexParser != nullptr) + { + // compressed case + unsigned long long downloadSize = std::accumulate(available_patches.begin(), + available_patches.end(), 0llu, [](unsigned long long const T, DiffInfo const &I) { + return T + I.download_hashes.FileSize(); + }); + if (downloadSize != 0) + { + unsigned long long downloadSizeIdx = 0; + auto const types = VectorizeString(Target.Option(IndexTarget::COMPRESSIONTYPES), ' '); + for (auto const &t : types) + { + std::string MetaKey = Target.MetaKey; + if (t != "uncompressed") + MetaKey += '.' + t; + HashStringList const hsl = GetExpectedHashesFor(MetaKey); + if (unlikely(hsl.usable() == false)) + continue; + downloadSizeIdx = hsl.FileSize(); + break; + } + unsigned long long const sizeLimit = downloadSizeIdx * sizeLimitPercent; + if ((sizeLimit/100) < downloadSize) + { + if (Debug) + std::clog << "Need " << downloadSize << " compressed bytes (Limit is " << (sizeLimit/100) << ", " + << "original is " << downloadSizeIdx << ") so fallback to complete download" << std::endl; + return false; + } + } + // uncompressed case + downloadSize = std::accumulate(available_patches.begin(), + available_patches.end(), 0llu, [](unsigned long long const T, DiffInfo const &I) { + return T + I.patch_hashes.FileSize(); + }); + if (downloadSize != 0) + { + unsigned long long const downloadSizeIdx = ServerSize; + unsigned long long const sizeLimit = downloadSizeIdx * sizeLimitPercent; + if ((sizeLimit/100) < downloadSize) + { + if (Debug) + std::clog << "Need " << downloadSize << " uncompressed bytes (Limit is " << (sizeLimit/100) << ", " + << "original is " << downloadSizeIdx << ") so fallback to complete download" << std::endl; + return false; + } + } } // we have something, queue the diffs @@ -1979,6 +2101,41 @@ bool pkgAcqDiffIndex::ParseDiffIndex(string const &IndexDiffFile) /*{{{*/ pdiff_merge = (precedence != "merged"); } + // clean the plate + { + std::string const Final = GetExistingFilename(CurrentPackagesFile); + if (unlikely(Final.empty())) // because we wouldn't be called in such a case + return false; + std::string const PartialFile = GetPartialFileNameFromURI(Target.URI); + if (FileExists(PartialFile) && RemoveFile("Bootstrap-linking", PartialFile) == false) + { + if (Debug) + std::clog << "Bootstrap-linking for patching " << CurrentPackagesFile + << " by removing stale " << PartialFile << " failed!" << std::endl; + return false; + } + for (auto const &ext : APT::Configuration::getCompressorExtensions()) + { + std::string const Partial = PartialFile + ext; + if (FileExists(Partial) && RemoveFile("Bootstrap-linking", Partial) == false) + { + if (Debug) + std::clog << "Bootstrap-linking for patching " << CurrentPackagesFile + << " by removing stale " << Partial << " failed!" << std::endl; + return false; + } + } + std::string const Ext = Final.substr(CurrentPackagesFile.length()); + std::string const Partial = PartialFile + Ext; + if (symlink(Final.c_str(), Partial.c_str()) != 0) + { + if (Debug) + std::clog << "Bootstrap-linking for patching " << CurrentPackagesFile + << " by linking " << Final << " to " << Partial << " failed!" << std::endl; + return false; + } + } + if (pdiff_merge == false) new pkgAcqIndexDiffs(Owner, TransactionManager, Target, available_patches); else @@ -2073,13 +2230,6 @@ pkgAcqIndexDiffs::pkgAcqIndexDiffs(pkgAcquire * const Owner, } else { - if (BootstrapPDiffWith(GetPartialFileNameFromURI(Target.URI), GetFinalFilename(), Target) == false) - { - Failed("Bootstrapping of " + DestFile + " failed", NULL); - return; - } - - // get the next diff State = StateFetchDiff; QueueNextDiff(); } @@ -2097,7 +2247,10 @@ void pkgAcqIndexDiffs::Failed(string const &Message,pkgAcquire::MethodConfig con RenameOnError(PDiffError); std::string const patchname = GetDiffsPatchFileName(DestFile); if (RealFileExists(patchname)) - rename(patchname.c_str(), std::string(patchname + ".FAILED").c_str()); + Rename(patchname, patchname + ".FAILED"); + std::string const UnpatchedFile = GetExistingFilename(GetPartialFileNameFromURI(Target.URI)); + if (UnpatchedFile.empty() == false && FileExists(UnpatchedFile)) + Rename(UnpatchedFile, UnpatchedFile + ".FAILED"); new pkgAcqIndex(Owner, TransactionManager, Target); Finish(); } @@ -2114,13 +2267,7 @@ void pkgAcqIndexDiffs::Finish(bool allDone) // the file will be cleaned if(allDone) { - std::string Final = GetFinalFilename(); - if (Target.KeepCompressed) - { - std::string const ext = flExtension(DestFile); - if (ext.empty() == false) - Final.append(".").append(ext); - } + std::string const Final = GetKeepCompressedFileName(GetFinalFilename(), Target); TransactionManager->TransactionStageCopy(this, DestFile, Final); // this is for the "real" finish @@ -2145,29 +2292,28 @@ void pkgAcqIndexDiffs::Finish(bool allDone) bool pkgAcqIndexDiffs::QueueNextDiff() /*{{{*/ { // calc sha1 of the just patched file - std::string const FinalFile = GetKeepCompressedFileName(GetPartialFileNameFromURI(Target.URI), Target); - if(!FileExists(FinalFile)) + std::string const PartialFile = GetExistingFilename(GetPartialFileNameFromURI(Target.URI)); + if(unlikely(PartialFile.empty())) { - Failed("Message: No FinalFile " + FinalFile + " available", NULL); + Failed("Message: The file " + GetPartialFileNameFromURI(Target.URI) + " isn't available", NULL); return false; } - FileFd fd(FinalFile, FileFd::ReadOnly, FileFd::Extension); + FileFd fd(PartialFile, FileFd::ReadOnly, FileFd::Extension); Hashes LocalHashesCalc; LocalHashesCalc.AddFD(fd); HashStringList const LocalHashes = LocalHashesCalc.GetHashStringList(); if(Debug) - std::clog << "QueueNextDiff: " << FinalFile << " (" << LocalHashes.find(NULL)->toStr() << ")" << std::endl; + std::clog << "QueueNextDiff: " << PartialFile << " (" << LocalHashes.find(NULL)->toStr() << ")" << std::endl; HashStringList const TargetFileHashes = GetExpectedHashesFor(Target.MetaKey); if (unlikely(LocalHashes.usable() == false || TargetFileHashes.usable() == false)) { - Failed("Local/Expected hashes are not usable", NULL); + Failed("Local/Expected hashes are not usable for " + PartialFile, NULL); return false; } - // final file reached before all patches are applied if(LocalHashes == TargetFileHashes) { @@ -2177,19 +2323,15 @@ bool pkgAcqIndexDiffs::QueueNextDiff() /*{{{*/ // remove all patches until the next matching patch is found // this requires the Index file to be ordered - for(vector::iterator I = available_patches.begin(); - available_patches.empty() == false && - I != available_patches.end() && - I->result_hashes != LocalHashes; - ++I) - { - available_patches.erase(I); - } + available_patches.erase(available_patches.begin(), + std::find_if(available_patches.begin(), available_patches.end(), [&](DiffInfo const &I) { + return I.result_hashes == LocalHashes; + })); // error checking and falling back if no patch was found if(available_patches.empty() == true) { - Failed("No patches left to reach target", NULL); + Failed("No patches left to reach target for " + PartialFile, NULL); return false; } @@ -2209,55 +2351,51 @@ bool pkgAcqIndexDiffs::QueueNextDiff() /*{{{*/ void pkgAcqIndexDiffs::Done(string const &Message, HashStringList const &Hashes, /*{{{*/ pkgAcquire::MethodConfig const * const Cnf) { - if(Debug) + if (Debug) std::clog << "pkgAcqIndexDiffs::Done(): " << Desc.URI << std::endl; Item::Done(Message, Hashes, Cnf); - std::string const FinalFile = GetKeepCompressedFileName(GetPartialFileNameFromURI(Target.URI), Target); - std::string const PatchFile = GetDiffsPatchFileName(FinalFile); - - // success in downloading a diff, enter ApplyDiff state - if(State == StateFetchDiff) - { - Rename(DestFile, PatchFile); - - if(Debug) - std::clog << "Sending to rred method: " << FinalFile << std::endl; + std::string const UncompressedUnpatchedFile = GetPartialFileNameFromURI(Target.URI); + std::string const UnpatchedFile = GetExistingFilename(UncompressedUnpatchedFile); + std::string const PatchFile = GetDiffsPatchFileName(UnpatchedFile); + std::string const PatchedFile = GetKeepCompressedFileName(UncompressedUnpatchedFile, Target); - State = StateApplyDiff; - Local = true; - Desc.URI = "rred:" + FinalFile; - QueueURI(Desc); - SetActiveSubprocess("rred"); - return; - } - - // success in download/apply a diff, queue next (if needed) - if(State == StateApplyDiff) + switch (State) { - // remove the just applied patch - available_patches.erase(available_patches.begin()); - unlink(PatchFile.c_str()); - - // move into place - if(Debug) - { - std::clog << "Moving patched file in place: " << std::endl - << DestFile << " -> " << FinalFile << std::endl; - } - Rename(DestFile,FinalFile); - chmod(FinalFile.c_str(),0644); - - // see if there is more to download - if(available_patches.empty() == false) { - new pkgAcqIndexDiffs(Owner, TransactionManager, Target, - available_patches); - return Finish(); - } else - // update - DestFile = FinalFile; - return Finish(true); + // success in downloading a diff, enter ApplyDiff state + case StateFetchDiff: + Rename(DestFile, PatchFile); + DestFile = GetKeepCompressedFileName(UncompressedUnpatchedFile + "-patched", Target); + if(Debug) + std::clog << "Sending to rred method: " << UnpatchedFile << std::endl; + State = StateApplyDiff; + Local = true; + Desc.URI = "rred:" + UnpatchedFile; + QueueURI(Desc); + SetActiveSubprocess("rred"); + return; + // success in download/apply a diff, queue next (if needed) + case StateApplyDiff: + // remove the just applied patch and base file + available_patches.erase(available_patches.begin()); + RemoveFile("pkgAcqIndexDiffs::Done", PatchFile); + RemoveFile("pkgAcqIndexDiffs::Done", UnpatchedFile); + if(Debug) + std::clog << "Moving patched file in place: " << std::endl + << DestFile << " -> " << PatchedFile << std::endl; + Rename(DestFile, PatchedFile); + + // see if there is more to download + if(available_patches.empty() == false) + { + new pkgAcqIndexDiffs(Owner, TransactionManager, Target, available_patches); + Finish(); + } else { + DestFile = PatchedFile; + Finish(true); + } + return; } } /*}}}*/ @@ -2289,11 +2427,9 @@ pkgAcqIndexMergeDiffs::pkgAcqIndexMergeDiffs(pkgAcquire * const Owner, Desc.Owner = this; Description = Target.Description; Desc.ShortDesc = Target.ShortDesc; - Desc.URI = Target.URI + ".diff/" + patch.file + ".gz"; - Desc.Description = Description + " " + patch.file + string(".pdiff"); - - DestFile = GetKeepCompressedFileName(GetPartialFileNameFromURI(Target.URI + ".diff/" + patch.file), Target); + Desc.Description = Description + " " + patch.file + ".pdiff"; + DestFile = GetPartialFileNameFromURI(Desc.URI); if(Debug) std::clog << "pkgAcqIndexMergeDiffs: " << Desc.URI << std::endl; @@ -2320,13 +2456,15 @@ void pkgAcqIndexMergeDiffs::Failed(string const &Message,pkgAcquire::MethodConfi State = StateErrorDiff; if (Debug) std::clog << "Falling back to normal index file acquire" << std::endl; - DestFile = GetKeepCompressedFileName(GetPartialFileNameFromURI(Target.URI), Target); RenameOnError(PDiffError); - std::string const patchname = GetMergeDiffsPatchFileName(DestFile, patch.file); + std::string const patchname = GetPartialFileNameFromURI(Desc.URI); if (RealFileExists(patchname)) - rename(patchname.c_str(), std::string(patchname + ".FAILED").c_str()); - new pkgAcqIndex(Owner, TransactionManager, Target); + Rename(patchname, patchname + ".FAILED"); + std::string const UnpatchedFile = GetExistingFilename(GetPartialFileNameFromURI(Target.URI)); + if (UnpatchedFile.empty() == false && FileExists(UnpatchedFile)) + Rename(UnpatchedFile, UnpatchedFile + ".FAILED"); DestFile.clear(); + new pkgAcqIndex(Owner, TransactionManager, Target); } /*}}}*/ void pkgAcqIndexMergeDiffs::Done(string const &Message, HashStringList const &Hashes, /*{{{*/ @@ -2337,67 +2475,58 @@ void pkgAcqIndexMergeDiffs::Done(string const &Message, HashStringList const &Ha Item::Done(Message, Hashes, Cnf); - std::string const UncompressedFinalFile = GetPartialFileNameFromURI(Target.URI); - std::string const FinalFile = GetKeepCompressedFileName(GetPartialFileNameFromURI(Target.URI), Target); - if (State == StateFetchDiff) - { - Rename(DestFile, GetMergeDiffsPatchFileName(FinalFile, patch.file)); + std::string const UncompressedUnpatchedFile = GetPartialFileNameFromURI(Target.URI); + std::string const UnpatchedFile = GetExistingFilename(UncompressedUnpatchedFile); + std::string const PatchFile = GetMergeDiffsPatchFileName(UnpatchedFile, patch.file); + std::string const PatchedFile = GetKeepCompressedFileName(UncompressedUnpatchedFile, Target); - // check if this is the last completed diff - State = StateDoneDiff; - for (std::vector::const_iterator I = allPatches->begin(); - I != allPatches->end(); ++I) - if ((*I)->State != StateDoneDiff) - { - if(Debug) - std::clog << "Not the last done diff in the batch: " << Desc.URI << std::endl; - return; - } - - // this is the last completed diff, so we are ready to apply now - State = StateApplyDiff; - - if (BootstrapPDiffWith(UncompressedFinalFile, GetFinalFilename(), Target) == false) - { - Failed("Bootstrapping of " + DestFile + " failed", NULL); - return; - } - - if(Debug) - std::clog << "Sending to rred method: " << FinalFile << std::endl; - - Local = true; - Desc.URI = "rred:" + FinalFile; - QueueURI(Desc); - SetActiveSubprocess("rred"); - return; - } - // success in download/apply all diffs, clean up - else if (State == StateApplyDiff) + switch (State) { - // move the result into place - std::string const Final = GetKeepCompressedFileName(GetFinalFilename(), Target); - if(Debug) - std::clog << "Queue patched file in place: " << std::endl - << DestFile << " -> " << Final << std::endl; - - // queue for copy by the transaction manager - TransactionManager->TransactionStageCopy(this, DestFile, Final); - - // ensure the ed's are gone regardless of list-cleanup - for (std::vector::const_iterator I = allPatches->begin(); - I != allPatches->end(); ++I) - { - std::string const PartialFile = GetKeepCompressedFileName(GetPartialFileNameFromURI(Target.URI), Target); - std::string const patch = GetMergeDiffsPatchFileName(PartialFile, (*I)->patch.file); - unlink(patch.c_str()); - } - unlink(FinalFile.c_str()); + case StateFetchDiff: + Rename(DestFile, PatchFile); - // all set and done - Complete = true; - if(Debug) - std::clog << "allDone: " << DestFile << "\n" << std::endl; + // check if this is the last completed diff + State = StateDoneDiff; + for (std::vector::const_iterator I = allPatches->begin(); + I != allPatches->end(); ++I) + if ((*I)->State != StateDoneDiff) + { + if(Debug) + std::clog << "Not the last done diff in the batch: " << Desc.URI << std::endl; + return; + } + // this is the last completed diff, so we are ready to apply now + DestFile = GetKeepCompressedFileName(UncompressedUnpatchedFile + "-patched", Target); + if(Debug) + std::clog << "Sending to rred method: " << UnpatchedFile << std::endl; + State = StateApplyDiff; + Local = true; + Desc.URI = "rred:" + UnpatchedFile; + QueueURI(Desc); + SetActiveSubprocess("rred"); + return; + case StateApplyDiff: + // success in download & apply all diffs, finialize and clean up + if(Debug) + std::clog << "Queue patched file in place: " << std::endl + << DestFile << " -> " << PatchedFile << std::endl; + + // queue for copy by the transaction manager + TransactionManager->TransactionStageCopy(this, DestFile, GetKeepCompressedFileName(GetFinalFilename(), Target)); + + // ensure the ed's are gone regardless of list-cleanup + for (std::vector::const_iterator I = allPatches->begin(); + I != allPatches->end(); ++I) + RemoveFile("pkgAcqIndexMergeDiffs::Done", GetMergeDiffsPatchFileName(UnpatchedFile, (*I)->patch.file)); + RemoveFile("pkgAcqIndexMergeDiffs::Done", UnpatchedFile); + + // all set and done + Complete = true; + if(Debug) + std::clog << "allDone: " << DestFile << "\n" << std::endl; + return; + case StateDoneDiff: _error->Fatal("Done called for %s which is in an invalid Done state", PatchFile.c_str()); break; + case StateErrorDiff: _error->Fatal("Done called for %s which is in an invalid Error state", PatchFile.c_str()); break; } } /*}}}*/ @@ -2436,29 +2565,58 @@ pkgAcqIndex::pkgAcqIndex(pkgAcquire * const Owner, } /*}}}*/ // AcqIndex::Init - defered Constructor /*{{{*/ -void pkgAcqIndex::Init(string const &URI, string const &URIDesc, - string const &ShortDesc) +static void NextCompressionExtension(std::string &CurrentCompressionExtension, std::string &CompressionExtensions, bool const preview) { - Stage = STAGE_DOWNLOAD; - - DestFile = GetPartialFileNameFromURI(URI); - size_t const nextExt = CompressionExtensions.find(' '); if (nextExt == std::string::npos) { CurrentCompressionExtension = CompressionExtensions; - CompressionExtensions.clear(); + if (preview == false) + CompressionExtensions.clear(); } else { CurrentCompressionExtension = CompressionExtensions.substr(0, nextExt); - CompressionExtensions = CompressionExtensions.substr(nextExt+1); + if (preview == false) + CompressionExtensions = CompressionExtensions.substr(nextExt+1); } +} +void pkgAcqIndex::Init(string const &URI, string const &URIDesc, + string const &ShortDesc) +{ + Stage = STAGE_DOWNLOAD; + + DestFile = GetPartialFileNameFromURI(URI); + NextCompressionExtension(CurrentCompressionExtension, CompressionExtensions, false); if (CurrentCompressionExtension == "uncompressed") { Desc.URI = URI; } + else if (CurrentCompressionExtension == "by-hash") + { + NextCompressionExtension(CurrentCompressionExtension, CompressionExtensions, true); + if(unlikely(TransactionManager->MetaIndexParser == NULL || CurrentCompressionExtension.empty())) + return; + if (CurrentCompressionExtension != "uncompressed") + { + Desc.URI = URI + '.' + CurrentCompressionExtension; + DestFile = DestFile + '.' + CurrentCompressionExtension; + } + + HashStringList const Hashes = GetExpectedHashes(); + HashString const * const TargetHash = Hashes.find(NULL); + if (unlikely(TargetHash == nullptr)) + return; + std::string const ByHash = "/by-hash/" + TargetHash->HashType() + "/" + TargetHash->HashValue(); + size_t const trailing_slash = Desc.URI.find_last_of("/"); + if (unlikely(trailing_slash == std::string::npos)) + return; + Desc.URI = Desc.URI.replace( + trailing_slash, + Desc.URI.substr(trailing_slash+1).size()+1, + ByHash); + } else if (unlikely(CurrentCompressionExtension.empty())) return; else @@ -2467,8 +2625,6 @@ void pkgAcqIndex::Init(string const &URI, string const &URIDesc, DestFile = DestFile + '.' + CurrentCompressionExtension; } - if(TransactionManager->MetaIndexParser != NULL) - InitByHashIfNeeded(); Desc.Description = URIDesc; Desc.Owner = this; @@ -2477,47 +2633,22 @@ void pkgAcqIndex::Init(string const &URI, string const &URIDesc, QueueURI(Desc); } /*}}}*/ -// AcqIndex::AdjustForByHash - modify URI for by-hash support /*{{{*/ -void pkgAcqIndex::InitByHashIfNeeded() -{ - // TODO: - // - (maybe?) add support for by-hash into the sources.list as flag - // - make apt-ftparchive generate the hashes (and expire?) - std::string HostKnob = "APT::Acquire::" + ::URI(Desc.URI).Host + "::By-Hash"; - if(_config->FindB("APT::Acquire::By-Hash", false) == true || - _config->FindB(HostKnob, false) == true || - TransactionManager->MetaIndexParser->GetSupportsAcquireByHash()) - { - HashStringList const Hashes = GetExpectedHashes(); - if(Hashes.usable()) - { - // FIXME: should we really use the best hash here? or a fixed one? - HashString const * const TargetHash = Hashes.find(""); - std::string const ByHash = "/by-hash/" + TargetHash->HashType() + "/" + TargetHash->HashValue(); - size_t const trailing_slash = Desc.URI.find_last_of("/"); - Desc.URI = Desc.URI.replace( - trailing_slash, - Desc.URI.substr(trailing_slash+1).size()+1, - ByHash); - } else { - _error->Warning( - "Fetching ByHash requested but can not find record for %s", - GetMetaKey().c_str()); - } - } -} - /*}}}*/ // AcqIndex::Custom600Headers - Insert custom request headers /*{{{*/ // --------------------------------------------------------------------- /* The only header we use is the last-modified header. */ string pkgAcqIndex::Custom600Headers() const { - string Final = GetFinalFilename(); string msg = "\nIndex-File: true"; - struct stat Buf; - if (stat(Final.c_str(),&Buf) == 0) - msg += "\nLast-Modified: " + TimeRFC1123(Buf.st_mtime); + + if (TransactionManager->LastMetaIndexParser == NULL) + { + std::string const Final = GetFinalFilename(); + + struct stat Buf; + if (stat(Final.c_str(),&Buf) == 0) + msg += "\nLast-Modified: " + TimeRFC1123(Buf.st_mtime); + } if(Target.IsOptional) msg += "\nFail-Ignore: true"; @@ -2547,20 +2678,6 @@ void pkgAcqIndex::Failed(string const &Message,pkgAcquire::MethodConfig const * TransactionManager->AbortTransaction(); } /*}}}*/ -// AcqIndex::ReverifyAfterIMS - Reverify index after an ims-hit /*{{{*/ -void pkgAcqIndex::ReverifyAfterIMS() -{ - // update destfile to *not* include the compression extension when doing - // a reverify (as its uncompressed on disk already) - DestFile = GetCompressedFileName(Target, GetPartialFileNameFromURI(Target.URI), CurrentCompressionExtension); - - // copy FinalFile into partial/ so that we check the hash again - string FinalFile = GetFinalFilename(); - Stage = STAGE_DECOMPRESS_AND_VERIFY; - Desc.URI = "copy:" + FinalFile; - QueueURI(Desc); -} - /*}}}*/ // AcqIndex::Done - Finished a fetch /*{{{*/ // --------------------------------------------------------------------- /* This goes through a number of states.. On the initial fetch the @@ -2577,91 +2694,93 @@ void pkgAcqIndex::Done(string const &Message, switch(Stage) { case STAGE_DOWNLOAD: - StageDownloadDone(Message, Hashes, Cfg); + StageDownloadDone(Message); break; case STAGE_DECOMPRESS_AND_VERIFY: - StageDecompressDone(Message, Hashes, Cfg); + StageDecompressDone(); break; } } /*}}}*/ // AcqIndex::StageDownloadDone - Queue for decompress and verify /*{{{*/ -void pkgAcqIndex::StageDownloadDone(string const &Message, HashStringList const &, - pkgAcquire::MethodConfig const * const) +void pkgAcqIndex::StageDownloadDone(string const &Message) { + Local = true; Complete = true; - // Handle the unzipd case - std::string FileName = LookupTag(Message,"Alt-Filename"); - if (FileName.empty() == false) + std::string const AltFilename = LookupTag(Message,"Alt-Filename"); + std::string Filename = LookupTag(Message,"Filename"); + + // we need to verify the file against the current Release file again + // on if-modfied-since hit to avoid a stale attack against us + if(StringToBool(LookupTag(Message,"IMS-Hit"),false) == true) { + // copy FinalFile into partial/ so that we check the hash again + string const FinalFile = GetExistingFilename(GetFinalFileNameFromURI(Target.URI)); + if (symlink(FinalFile.c_str(), DestFile.c_str()) != 0) + _error->WarningE("pkgAcqIndex::StageDownloadDone", "Symlinking final file %s back to %s failed", FinalFile.c_str(), DestFile.c_str()); + else + { + EraseFileName = DestFile; + Filename = DestFile; + } Stage = STAGE_DECOMPRESS_AND_VERIFY; - Local = true; - DestFile += ".decomp"; - Desc.URI = "copy:" + FileName; + Desc.URI = "store:" + Filename; QueueURI(Desc); - SetActiveSubprocess("copy"); + SetActiveSubprocess(::URI(Desc.URI).Access); return; } - FileName = LookupTag(Message,"Filename"); - + // methods like file:// give us an alternative (uncompressed) file + else if (Target.KeepCompressed == false && AltFilename.empty() == false) + { + if (CurrentCompressionExtension != "uncompressed") + DestFile.erase(DestFile.length() - (CurrentCompressionExtension.length() + 1)); + Filename = AltFilename; + } // Methods like e.g. "file:" will give us a (compressed) FileName that is // not the "DestFile" we set, in this case we uncompress from the local file - if (FileName != DestFile && RealFileExists(DestFile) == false) - Local = true; - else - EraseFileName = FileName; - - // we need to verify the file against the current Release file again - // on if-modfied-since hit to avoid a stale attack against us - if(StringToBool(LookupTag(Message,"IMS-Hit"),false) == true) + else if (Filename != DestFile && RealFileExists(DestFile) == false) { - // The files timestamp matches, reverify by copy into partial/ - EraseFileName = ""; - ReverifyAfterIMS(); - return; + // symlinking ensures that the filename can be used for compression detection + // that is e.g. needed for by-hash which has no extension over file + if (symlink(Filename.c_str(),DestFile.c_str()) != 0) + _error->WarningE("pkgAcqIndex::StageDownloadDone", "Symlinking file %s to %s failed", Filename.c_str(), DestFile.c_str()); + else + { + EraseFileName = DestFile; + Filename = DestFile; + } } - // If we want compressed indexes, just copy in place for hash verification - if (Target.KeepCompressed == true) - { - DestFile = GetPartialFileNameFromURI(Target.URI + '.' + CurrentCompressionExtension); - EraseFileName = ""; - Stage = STAGE_DECOMPRESS_AND_VERIFY; - Desc.URI = "copy:" + FileName; - QueueURI(Desc); - SetActiveSubprocess("copy"); - return; - } - - // get the binary name for your used compression type - string decompProg; - if(CurrentCompressionExtension == "uncompressed") - decompProg = "copy"; + Stage = STAGE_DECOMPRESS_AND_VERIFY; + DestFile = GetKeepCompressedFileName(GetPartialFileNameFromURI(Target.URI), Target); + if (Filename != DestFile && flExtension(Filename) == flExtension(DestFile)) + Desc.URI = "copy:" + Filename; else - decompProg = _config->Find(string("Acquire::CompressionTypes::").append(CurrentCompressionExtension),""); - if(decompProg.empty() == true) + Desc.URI = "store:" + Filename; + if (DestFile == Filename) { - _error->Error("Unsupported extension: %s", CurrentCompressionExtension.c_str()); - return; + if (CurrentCompressionExtension == "uncompressed") + return StageDecompressDone(); + DestFile = "/dev/null"; } + if (EraseFileName.empty()) + EraseFileName = Filename; + // queue uri for the next stage - Stage = STAGE_DECOMPRESS_AND_VERIFY; - DestFile += ".decomp"; - Desc.URI = decompProg + ":" + FileName; QueueURI(Desc); - SetActiveSubprocess(decompProg); + SetActiveSubprocess(::URI(Desc.URI).Access); } /*}}}*/ // AcqIndex::StageDecompressDone - Final verification /*{{{*/ -void pkgAcqIndex::StageDecompressDone(string const &, - HashStringList const &, - pkgAcquire::MethodConfig const * const) +void pkgAcqIndex::StageDecompressDone() { + if (DestFile == "/dev/null") + DestFile = GetKeepCompressedFileName(GetPartialFileNameFromURI(Target.URI), Target); + // Done, queue for rename on transaction finished TransactionManager->TransactionStageCopy(this, DestFile, GetFinalFilename()); - return; } /*}}}*/ pkgAcqIndex::~pkgAcqIndex() {} @@ -2813,7 +2932,7 @@ bool pkgAcqArchive::QueueNext() /* Hmm, we have a file and its size does not match, this means it is an old style mismatched arch */ - unlink(FinalFile.c_str()); + RemoveFile("pkgAcqArchive::QueueNext", FinalFile); } // Check it again using the new style output filenames @@ -2832,7 +2951,7 @@ bool pkgAcqArchive::QueueNext() /* Hmm, we have a file and its size does not match, this shouldn't happen.. */ - unlink(FinalFile.c_str()); + RemoveFile("pkgAcqArchive::QueueNext", FinalFile); } DestFile = _config->FindDir("Dir::Cache::Archives") + "partial/" + flNotDir(StoreFilename); @@ -2842,7 +2961,7 @@ bool pkgAcqArchive::QueueNext() { // Hmm, the partial file is too big, erase it if ((unsigned long long)Buf.st_size > Version->Size) - unlink(DestFile.c_str()); + RemoveFile("pkgAcqArchive::QueueNext", DestFile); else PartialSize = Buf.st_size; } @@ -3107,7 +3226,7 @@ std::string pkgAcqChangelog::URI(std::string const &Template, char const * const Component, char const * const SrcName, char const * const SrcVersion) { - if (Template.find("CHANGEPATH") == std::string::npos) + if (Template.find("@CHANGEPATH@") == std::string::npos) return ""; // the path is: COMPONENT/SRC/SRCNAME/SRCNAME_SRCVER, e.g. main/a/apt/1.1 or contrib/liba/libapt/2.0 @@ -3119,7 +3238,7 @@ std::string pkgAcqChangelog::URI(std::string const &Template, if (Component != NULL && strlen(Component) != 0) path = std::string(Component) + "/" + path; - return SubstVar(Template, "CHANGEPATH", path); + return SubstVar(Template, "@CHANGEPATH@", path); } /*}}}*/ // AcqChangelog::Failed - Failure handler /*{{{*/ @@ -3152,7 +3271,7 @@ pkgAcqChangelog::~pkgAcqChangelog() /*{{{*/ { if (TemporaryDirectory.empty() == false) { - unlink(DestFile.c_str()); + RemoveFile("~pkgAcqChangelog", DestFile); rmdir(TemporaryDirectory.c_str()); } } @@ -3189,7 +3308,7 @@ pkgAcqFile::pkgAcqFile(pkgAcquire * const Owner,string const &URI, HashStringLis { // Hmm, the partial file is too big, erase it if ((Size > 0) && (unsigned long long)Buf.st_size > Size) - unlink(DestFile.c_str()); + RemoveFile("pkgAcqFile", DestFile); else PartialSize = Buf.st_size; } @@ -3227,7 +3346,7 @@ void pkgAcqFile::Done(string const &Message,HashStringList const &CalcHashes, if (lstat(DestFile.c_str(),&St) == 0) { if (S_ISLNK(St.st_mode) != 0) - unlink(DestFile.c_str()); + RemoveFile("pkgAcqFile::Done", DestFile); } // Symlink the file