**/test/interactive-helper/mthdcat

**/test/interactive-helper/test_fileutl

**/test/interactive-helper/test_udevcdrom

**/test/libapt/libapt_test

# Documentation

/debian/libapt-pkg-dev/

/debian/libapt-pkg-doc/

/debian/apt-transport-https/

# generated for and by abicheck

/abicheck/apt_build.xml

language: cpp

cache: ccache

sudo: required

install:

before_script:

script:

after_script:

VERBATIM

)

# cycles.

add_custom_target(vendor-${AVF_OUTPUT} ALL DEPENDS ${out})

endfunction()

#cmakedefine CONF_DIR "${CONF_DIR}"

#cmakedefine LIBEXEC_DIR "${LIBEXEC_DIR}"

#cmakedefine BIN_DIR "${BIN_DIR}"

/* Group of the root user */

#cmakedefine ROOT_GROUP "${ROOT_GROUP}"

find_package(LFS REQUIRED)

find_package(Iconv REQUIRED)

if(USE_NLS)

find_package(Intl REQUIRED)

link_libraries(${Intl_LIBRARIES})

check_function_exists(statvfs HAVE_STATVFS)

if (NOT HAVE_STATVFS)

endif()

CHECK_STRUCT_HAS_MEMBER("struct statfs" f_type sys/vfs.h HAVE_STRUCT_STATFS_F_TYPE)

# Configure some variables like package, version and architecture.

set(PACKAGE ${PROJECT_NAME})

set(PACKAGE_MAIL "APT Development Team <deity@lists.debian.org>")

if (NOT DEFINED COMMON_ARCH)

execute_process(COMMAND dpkg-architecture -qDEB_HOST_ARCH

OUTPUT_VARIABLE COMMON_ARCH OUTPUT_STRIP_TRAILING_WHITESPACE)

Everyone is permitted to copy and distribute verbatim copies

of this license document, but changing it is not allowed.

The licenses for most software are designed to take away your

freedom to share and change it. By contrast, the GNU General Public

General Public License applies to most of the Free Software

Foundation's software and to any other program whose authors commit to

using it. (Some other Free Software Foundation software is covered by

your programs, too.

When we speak of free software, we are referring to freedom, not

The precise terms and conditions for copying, distribution and

modification follow.

TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION

0. This License applies to any program or other work which contains

License. (Exception: if the Program itself is interactive but

does not normally print such an announcement, your work based on

the Program is not required to print an announcement.)

These requirements apply to the modified work as a whole. If

identifiable sections of that work are not derived from the Program,

and can be reasonably considered independent and separate works in

access to copy the source code from the same place counts as

distribution of the source code, even though third parties are not

compelled to copy the source along with the object code.

4. You may not copy, modify, sublicense, or distribute the Program

except as expressly provided under this License. Any attempt

otherwise to copy, modify, sublicense or distribute the Program is

This section is intended to make thoroughly clear what is believed to

be a consequence of the rest of this License.

8. If the distribution and/or use of the Program is restricted in

certain countries either by patents or by copyrighted interfaces, the

original copyright holder who places the Program under this License

of preserving the free status of all derivatives of our free software and

of promoting the sharing and reuse of software generally.

11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY

FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN

PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE

POSSIBILITY OF SUCH DAMAGES.

If you develop a new program, and you want it to be of the greatest

possible use to the public, the best way to achieve this is to make it

the "copyright" line and a pointer to where the full notice is found.

<one line to give the program's name and a brief idea of what it does.>

This program is free software; you can redistribute it and/or modify

it under the terms of the GNU General Public License as published by

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

GNU General Public License for more details.

Also add information on how to contact you by electronic and paper mail.

If the program is interactive, make it output a short notice like this

when it starts in an interactive mode:

Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.

This is free software, and you are welcome to redistribute it

under certain conditions; type `show c' for details.

This General Public License does not permit incorporating your program into

proprietary programs. If your program is a subroutine library, you may

consider it more useful to permit linking proprietary applications with the

Public License instead of this License.

PkgName = the name of the package

TotalPercentage = the total progress between [0..100]

Example:

AlreadyDownloaded = the number of already downloaded packages

TotalPercentage = the total progress between [0..100]

Example:

dlstatus:1:9.05654:Downloading file 1 of 3 (4m40s remaining)

dlstatus:1:9.46357:Downloading file 1 of 3 (4m39s remaining)

set(MINOR 0)

set(APT_INST_MAJOR ${MAJOR} PARENT_SCOPE)

file(GLOB_RECURSE library "*.cc")

file(GLOB_RECURSE headers "*.h")

is invoked.

As we unpack we record the file list differences in the FL cache. If

and can undo. When we need to erase then it knows which files have not

been unpacked.

/*}}}*/

// FLCache::PrintTree - Print out a tree /*{{{*/

// ---------------------------------------------------------------------

void pkgFLCache::PrintTree(map_ptrloc Base,unsigned long Size)

{

if (Base == 0)

The storage content of the class is maintained in a memory map and is

written directly to the file system. Performance is traded against

space to give something that performs well and remains small.

36k files. Directory paths are collected into a binary tree and stored

only once, this offsets the cost of the hash nodes enough to keep

memory usage slightly less than the sum of the filenames.

add_definitions("-DAPT_PKG_EXPOSE_STRING_VIEW")

file(MAKE_DIRECTORY ${PROJECT_BINARY_DIR}/include/apt-pkg/)

--ignore-case

--header ${PROJECT_BINARY_DIR}/include/apt-pkg/tagfile-keys.h

--code ${CMAKE_CURRENT_BINARY_DIR}/tagfile-keys.cc

message(STATUS "Building libapt-pkg ${MAJOR} (release ${MINOR})")

set(APT_PKG_MAJOR ${MAJOR} PARENT_SCOPE) # exporting for methods/CMakeLists.txt

file(GLOB_RECURSE library "*.cc" "${CMAKE_CURRENT_BINARY_DIR}/tagfile-keys.cc")

file(GLOB_RECURSE headers "*.h")

{

auto const Releasegpg = GetFinalFilename();

auto const Release = MetaIndex->GetFinalFilename();

// (previously an unknown pubkey) – but only if the Release file exists locally (unlikely

// event of InRelease removed from the mirror causing fallback but still an IMS-Hit)

if (TransactionManager->IMSHit == false ||

<< TransactionManager << std::endl;

}

/*}}}*/

static void NextCompressionExtension(std::string &CurrentCompressionExtension, std::string &CompressionExtensions, bool const preview)

{

size_t const nextExt = CompressionExtensions.find(' ');

if (Template.find("@CHANGEPATH@") == std::string::npos)

return "";

std::string Src = SrcName;

std::string path = APT::String::Startswith(SrcName, "lib") ? Src.substr(0, 4) : Src.substr(0,1);

path.append("/").append(Src).append("/");

/** \brief A client-supplied unique identifier.

*

* clients that wish to use it to uniquely identify items.

*

* APT progress reporting will store an ID there as shown in "Get:42 …"

Dequeue();

}

/*}}}*/

// ---------------------------------------------------------------------

/* This sends a 403 Media Failure message to the APT and waits for it

to be ackd */

if (isDoomedItem(Item->Owner))

return true;

string Message = "600 URI Acquire\n";

Message.reserve(300);

Message += "URI: " + Item->URI;

for (HashStringList::const_iterator hs = hsl.begin(); hs != hsl.end(); ++hs)

Message += "\nExpected-" + hs->HashType() + ": " + hs->HashValue();

{

unsigned long long FileSize = Item->GetMaximumSize();

if(FileSize > 0)

}

}

Message += "\n\n";

if (RealFileExists(Item->Owner->DestFile))

if (chmod(partial.c_str(), 0700) != 0)

_error->WarningE("SetupAPTPartialDirectory", "chmod 0700 of directory %s failed", partial.c_str());

return true;

}

bool pkgAcquire::Setup(pkgAcquireStatus *Progress, string const &Lock)

// if destination file is inaccessible all hope is lost for privilege dropping

if (IsAccessibleBySandboxUser((*I)->DestFile, true) == false)

{

(*I)->DestFile.c_str(), SandboxUser.c_str());

_config->Set("APT::Sandbox::User", "");

break;

if (IsAccessibleBySandboxUser(source.Path, false) == false)

{

source.Path.c_str(), SandboxUser.c_str());

_config->CndSet("Binary::file::APT::Sandbox::User", "root");

_config->CndSet("Binary::copy::APT::Sandbox::User", "root");

/* */

bool pkgAcquire::Queue::Enqueue(ItemDesc &Item)

{

QItem **OptimalI = &Items;

QItem **I = &Items;

// move to the end of the queue and check for duplicates here

for (; *I != 0; ) {

{

if (_config->FindB("Debug::pkgAcquire::Worker",false) == true)

std::cerr << " @ Queue: Action combined for " << Item.URI << " and " << (*I)->URI << std::endl;

Each file to download is represented by an Acquire::Item class subclassed

into a specialization. The Item class can add itself to several URI

queues are fed into the handlers by the schedular until the queues are

empty. This allows for an Item to be downloaded from an alternate source

of multiple items from multiple sources as well as dynamic balancing

of load between the sources.

*/

bool RunFdsSane(fd_set *RSet,fd_set *WSet);

// ABI/API break. RunFdsSane() is what should be used as it

// returns if there is an error condition on one of the fds

virtual void RunFds(fd_set *RSet,fd_set *WSet);

/** \brief Represents a single download source from which an item

* should be downloaded.

*

*/

struct pkgAcquire::ItemDesc : public WeakPointable

{

}

}

if (VList[0] == 0 &&

Start.IsNegative() == false &&

(Flags[I->ID] & Protected) != Protected)

pkgCache::PkgIterator I = Cache.PkgBegin();

for (;I.end() != true; ++I) {

if (Cache[I].NewInstall() && !(Flags[I->ID] & PreInstalled)) {

std::clog << "Resolve installed new pkg: " << I.FullName(false)

<< " (now marking it as auto)" << std::endl;

}

/*}}}*/

// ProblemResolver::ResolveByKeep - Resolve problems using keep /*{{{*/

// ---------------------------------------------------------------------

in that it does not install or remove any packages. It is assumed that the

system was non-broken previously. */

bool pkgProblemResolver::ResolveByKeep(OpProgress * const Progress)

/*}}}*/

// ProblemResolver::ResolveByKeepInternal - Resolve problems using keep /*{{{*/

// ---------------------------------------------------------------------

in that it does not install or remove any packages. It is assumed that the

system was non-broken previously. */

bool pkgProblemResolver::ResolveByKeepInternal()

continue;

/* Hm, the group is broken.. I suppose the best thing to do is to

slow, and this never happens, just be conservative and assume the

list of ors is in preference and keep till it starts to work. */

while (true)

/*}}}*/

// PrioSortList - Sort a list of versions by priority /*{{{*/

// ---------------------------------------------------------------------

of versions ordered by preference. */

struct PrioComp {

string const arch = _config->Find("APT::Architecture");

archs = _config->FindVector("APT::Architectures");

archs = _system->ArchitecturesSupported();

if (archs.empty() == true ||

#include <apt-pkg/strutl.h>

#include <apt-pkg/macros.h>

#include <string>

#include <string.h>

#include <regex.h>

#include <fnmatch.h>

#include <apti18n.h>

/*}}}*/

namespace APT {

namespace CacheFilter {

APT_CONST Matcher::~Matcher() {}

APT_CONST PackageMatcher::~PackageMatcher() {}

return fnmatch(Pattern.c_str(), Grp.Name(), FNM_CASEFOLD) == 0;

}

/*}}}*/

//----------------------------------------------------------------------

{

}

}

}

PackageArchitectureMatchesSpecification::PackageArchitectureMatchesSpecification(std::string const &pattern, bool const pisPattern) :

literal(pattern), complete(CompleteArch(pattern, pisPattern)), isPattern(pisPattern) {

case TASK: showTaskSelection(pkg, pattern); break;

case FNMATCH: showFnmatchSelection(pkg, pattern); break;

APT_IGNORE_DEPRECATED_POP

case STRING: /* handled by the special cases */ break;

case UNKNOWN: break;

}

case INSTCAND:

case ALL:

case CANDANDINST:

break;

}

}

/** \brief returns all packages in the cache who belong to the given task

A simple helper responsible for search for all members of a task

packages chosen cause of the given task.

\param Cache the packages are in

\param pattern name of the task

/** \brief returns all packages in the cache whose name matchs a given pattern

A simple helper responsible for executing a regular expression on all

packages chosen cause of the given package.

\param Cache the packages are in

\param pattern regular expression for package names

InfoDir = InfoDir + CD + ".disk/";

}

if (RealFileExists(".aptignr") == true)

return true;

bool closeQuote = false;

for (unsigned int i = 0; i < argc && length < sizeof(cmdline); ++i, ++length)

{

{

if (lastWasOption == true && argv[i][j] == '=')

{

// That is possibly an option: Quote it if it includes spaces,

// the benefit is that this will eliminate also most false positives

const char* c = strchr(&argv[i][j+1], ' ');

if (c == NULL) continue;

closeQuote = true;

}

}

if (closeQuote == true)

// Problem: detects also --hello

if (cmdline[length-1] == 'o')

lastWasOption = true;

#include <string.h>

#include <algorithm>

#include <string>

#include <stack>

#include <vector>

#include <fstream>

#include <apti18n.h>

Configuration *_config = new Configuration;

// Configuration::Configuration - Constructor /*{{{*/

// ---------------------------------------------------------------------

/* */

/* */

string Configuration::Find(const char *Name,const char *Default) const

{

const Item *Itm = Lookup(Name);

if (Itm == 0 || Itm->Value.empty() == true)

{

*/

string Configuration::FindFile(const char *Name,const char *Default) const

{

const Item *RootItem = Lookup("RootDir");

std::string result = (RootItem == 0) ? "" : RootItem->Value;

if(result.empty() == false && result[result.size() - 1] != '/')

/* This is like findfile execept the result is terminated in a / */

string Configuration::FindDir(const char *Name,const char *Default) const

{

string Res = FindFile(Name,Default);

if (Res.end()[-1] != '/')

{

/* Returns a vector of config values under the given item */

vector<string> Configuration::FindVector(const char *Name, std::string const &Default, bool const Keys) const

{

vector<string> Vec;

const Item *Top = Lookup(Name);

if (Top == NULL)

/* */

int Configuration::FindI(const char *Name,int const &Default) const

{

const Item *Itm = Lookup(Name);

if (Itm == 0 || Itm->Value.empty() == true)

return Default;

/* */

bool Configuration::FindB(const char *Name,bool const &Default) const

{

const Item *Itm = Lookup(Name);

if (Itm == 0 || Itm->Value.empty() == true)

return Default;

if ((*I == '/' && I + 1 != End && I[1] == '/') ||

(*I == '#' && strcmp(string(I,I+6).c_str(),"#clear") != 0 &&

{

End = I;

break;

{

Stack.push(ParentTag);

tag string */

if (AsSectional == true && Word.empty() == false)

{

return _error->Error(_("Syntax error %s:%u: Included from here"),FName.c_str(),CurLine);

}

}

else

return _error->Error(_("Syntax error %s:%u: Unsupported directive '%s'"),FName.c_str(),CurLine,Tag.c_str());

}

// $Id: error.h,v 1.8 2001/05/07 05:06:52 jgg Exp $

/* ######################################################################

This class has a single global instance. When a function needs to

generate an error condition, such as a read error, it calls a member

stat(tmpdir, &st) != 0 || (st.st_mode & S_IFDIR) == 0) // exists and is directory

tmpdir = "/tmp";

else if (geteuid() != 0 && // root can do everything anyway

tmpdir = "/tmp";

return string(tmpdir);

}

enum { DETACHED, CLEARSIGNED } releaseSignature = (FileGPG != File) ? DETACHED : CLEARSIGNED;

char * sig = NULL;

char * data = NULL;

char * conf = nullptr;

message.OpenDescriptor(dataFd, FileFd::WriteOnly, true);

if (signature.Failed() == true || message.Failed() == true ||

{

apt_error(std::cerr, statusfd, fd, "Splitting up %s into data and signature failed", File.c_str());

local_exit(112);

}

/*}}}*/

// SplitClearSignedFile - split message into data/signature /*{{{*/

bool SplitClearSignedFile(std::string const &InFile, FileFd * const ContentFile,

std::vector<std::string> * const ContentHeader, FileFd * const SignatureFile)

{

bool skip_until_empty_line = false;

bool found_signature = false;

bool first_line = true;

char *buf = NULL;

size_t buf_size = 0;

{

_strrstrip(buf);

if (found_message_start == false)

found_message_start = true;

skip_until_empty_line = true;

}

}

else if (skip_until_empty_line == true)

{

if (ContentFile != NULL)

ContentFile->Write(dashfree, strlen(dashfree));

}

}

else if (found_signature == true)

{

found_signature = false; // look for other signatures

}

// all the rest is whitespace, unsigned garbage or additional message blocks we ignore

}

fclose(in);

if (buf != NULL)

free(buf);

if (found_signature == true)

return _error->Error("Signature in file %s wasn't closed", InFile.c_str());

free(message);

return _error->Errno("mkstemp", "Couldn't create temporary file to work with %s", ClearSignedFileName.c_str());

}

unlink(message);

free(message);

return true;

}

/*}}}*/

// ---------------------------------------------------------------------

not return till all IO is complete */

bool MMap::Sync()

{

return true;

}

/*}}}*/

// ---------------------------------------------------------------------

/* */

bool MMap::Sync(unsigned long Start,unsigned long Stop)

from file fd's this function will use read and normal allocated

memory.

class is deleted. Ie it will rewrite the file, unless it is readonly

The DynamicMMap class is used to help the on-disk data structure

// Description /*{{{*/

/* ######################################################################

##################################################################### */

/*}}}*/

#include <locale>

#include <sstream>

#include <string>

#include <vector>

#include <stddef.h>

return (s.compare(0, start.size(), start) == 0);

}

}

}

/*}}}*/

// TimeRFC1123 - Convert a time_t into RFC1123 format /*{{{*/

// ---------------------------------------------------------------------

/* This converts a time_t into a string time representation that is

string TimeRFC1123(time_t Date)

{

return TimeRFC1123(Date, false);

// tolower_ascii - tolower() function that ignores the locale /*{{{*/

// ---------------------------------------------------------------------

/* This little function is the most called method we have and tries

standard tolower/toupper and as a bonus avoids problems with different

locales - we only operate on ascii chars anyway. */

#undef tolower_ascii

// isspace_ascii - isspace() function that ignores the locale /*{{{*/

// ---------------------------------------------------------------------

/* This little function is one of the most called methods we have and tries

standard isspace() and as a bonus avoids problems with different

locales - we only operate on ascii chars anyway. */

#undef isspace_ascii

std::string Strip(const std::string &s);

bool Endswith(const std::string &s, const std::string &ending);

bool Startswith(const std::string &s, const std::string &starting);

}

}

string Result = Section.Find(pkgTagSection::Key::Package).to_string();

// Normalize mixed case package names to lower case, like dpkg does

if(unlikely(Result.empty() == true))

_error->Warning("Encountered a section with no Package: header");

bool const &StripMultiArch,

bool const &ParseRestrictionsList)

{

StringView PackageView;

StringView VerView;

auto res = ParseDepends(Start, Stop, PackageView, VerView, Op, (bool)ParseArchFlags,

Package = PackageView.to_string();

Ver = VerView.to_string();

bool StripMultiArch,

bool ParseRestrictionsList)

{

// Strip off leading space

for (;Start != Stop && isspace_ascii(*Start) != 0; ++Start);

if (unlikely(ParseArchFlags == true))

{

// Parse an architecture

if (I != Stop && *I == '[')

std::string &Package,std::string &Ver,unsigned int &Op,

bool const &ParseArchFlags, bool const &StripMultiArch,

bool const &ParseRestrictionsList);

#ifdef APT_PKG_EXPOSE_STRING_VIEW

APT_HIDDEN static const char *ParseDepends(const char *Start,const char *Stop,

APT::StringView &Ver,unsigned int &Op,

bool const ParseArchFlags = false, bool StripMultiArch = true,

bool const ParseRestrictionsList = false);

#endif

APT_PUBLIC static const char *ConvertRelation(const char *I,unsigned int &Op);

if (dup != IndexTargets.end())

{

std::string const dupEntry = dup->Option(IndexTarget::SOURCESENTRY);

if (tplMetaKey.find(BreakPoint) == std::string::npos)

break;

continue;

UseByHash = _config->Find("Acquire::By-Hash", UseByHash);

{

std::string const host = ::URI(URI).Host;

std::map<std::string, std::string>::const_iterator const opt = Options.find("by-hash");

if (opt != Options.end())

UseByHash = opt->second;

Debian Package Records - Parser for debian package records

services. There should be no overlap between these two.

##################################################################### */

return _error->Error("Problem parsing dependency: %s", fields[I]);

rec.Type = I;

BuildDeps.push_back(rec);

if (Start == Stop)

break;

if (unlikely(candset.empty()))

{

if (Debug == true)

return;

}

else if (candset.size() == 1) // we are lucky

if (pkgname.find(':') != std::string::npos)

{

if (Debug == true)

return;

}

}

// DPkgPM::OpenLog /*{{{*/

bool pkgDPkgPM::OpenLog()

{

if(CreateAPTDirectoryIfNeeded(logdir, logdir) == false)

// FIXME: use a better string after freeze

return _error->Error(_("Directory '%s' missing"), logdir.c_str());

strftime(timestr, sizeof(timestr), "%F %T", tmp);

// open terminal log

if (!logfile_name.empty())

{

d->term_out = fopen(logfile_name.c_str(),"a");

}

// write your history

if (!history_name.empty())

{

d->history_out = fopen(history_name.c_str(),"a");

}

bool pkgDPkgPM::Go(APT::Progress::PackageManager *progress)

{

// we need them only temporarily through, so keep the length and erase afterwards

decltype(List)::const_iterator::difference_type explicitIdx =

std::distance(List.cbegin(), List.cend());

dpkg_recursive_install = Cache.VS().CmpVersion("1.18.5", dpkgpkg.CurrentVer().VerStr()) <= 0;

}

// no point in doing this dance for a handful of packages only

// FIXME: workaround for dpkg bug, see our ./test-bug-740843-versioned-up-down-breaks test

bool const dpkg_recursive_install_numbered = _config->FindB("dpkg::install::recursive::numbered", true);

ADDARG(fullname);

}

}

if (oldSize == Size)

continue;

}

if (d->dpkg_error.empty() == false)

{

StripAlreadyDoneFrom(approvedStates.Remove());

StripAlreadyDoneFrom(approvedStates.Purge());

APT::StateChanges undo;

ActionGroup group(*this);

// auto-mark information if a user selects a package for removal

// but changes his mind then and sets it for keep again

// - this makes sense as default when all Garbage dependencies

StateCache &P = PkgState[Pkg->ID];

if (P.CandidateVer == 0)

return false;

{

if (InstallRecommends)

return true;

// sections

// FIXME: this is a meant as a temporarly solution until the

// recommends are cleaned up

3 dependency results.

Now - Compared using the Currently install version

Install - Compared using the install version (final state)

The candidate and now results are used to decide wheather a package

should be automatically installed or if it should be left alone.

}

/*}}}*/

// EDSP::WriteError - format an error message to be send to file descriptor /*{{{*/

bool EDSP::WriteError(char const * const uuid, std::string const &message, FILE* output) {

fprintf(output, "Error: %s\n", uuid);

return true;

}

bool EDSP::WriteError(char const * const uuid, std::string const &message, FileFd &output) {

return WriteOkay(output, "Error: ", uuid, "\n",

"\n\n");

}

/*}}}*/

* \param[out] remove is a list which gets populated with requested removals

* \param[out] upgrade is true if it is a request like apt-get upgrade

* \param[out] distUpgrade is true if it is a request like apt-get dist-upgrade

*

* \return true if the request could be found and worked on, otherwise false

*/

rather bad (doesn't take three character like ast into account).*/

APT_DEPRECATED_MSG("These methods make no sense anymore with multi-language support") static bool CheckLanguageCode(const char * const Lang);

/* As we have now possibly more than one LanguageCode this method is

APT_DEPRECATED_MSG("These methods make no sense anymore with multi-language support") static std::string LanguageCode();

bool IsTrusted() const { return Trusted; };

#include <string.h>

#include <cstdlib>

#include <apti18n.h>

/*}}}*/

const char *pkgLibVersion = Stringfy(APT_PKG_MAJOR) "."

Stringfy(APT_PKG_MINOR) "."

Stringfy(APT_PKG_RELEASE);

// pkgInitConfig - Initialize the configuration class /*{{{*/

// ---------------------------------------------------------------------

Cnf.Set("Dir::Ignore-Files-Silently::", "\\.disabled$");

Cnf.Set("Dir::Ignore-Files-Silently::", "\\.bak$");

Cnf.Set("Dir::Ignore-Files-Silently::", "\\.dpkg-[a-z]+$");

Cnf.Set("Dir::Ignore-Files-Silently::", "\\.save$");

Cnf.Set("Dir::Ignore-Files-Silently::", "\\.orig$");

Cnf.Set("Dir::Ignore-Files-Silently::", "\\.distUpgrade$");

if (Sys == 0)

return _error->Error(_("Unable to determine a suitable packaging system type"));

}

return Sys->Initialize(Cnf);

}

There are complications in this algorithm when presented with cycles.

For all known practical cases it works, all cases where it doesn't work

is fixable by tweaking the package descriptions. However, it should be

presented with cycles.

##################################################################### */

/*}}}*/

// OrderList::DoRun - Does an order run /*{{{*/

// ---------------------------------------------------------------------

bool pkgOrderList::DoRun()

{

// Temp list

DepFunc Old = Primary;

if (IsFlag(Pkg,Immediate) == true && Primary != &pkgOrderList::DepUnPackPre)

Primary = &pkgOrderList::DepUnPackPreD;

orders configuration so that when a package comes to be configured it's

dependents are configured.

bool pkgOrderList::DepConfigure(DepIterator D)

{

// Never consider reverse configuration dependencies.

return Resolve.ResolveByKeep() == true && Cache.BrokenCount() == 0;

}

/*}}}*/

// ---------------------------------------------------------------------

/* This adds the immediate flag to the pkg and recursively to the

dependencies

break;

}

if (List->IsFlag(DepPkg,pkgOrderList::UnPacked) == false)

{

// two packages pre-depending on each other can't be handled sanely

return false;

if (Immediate == true) {

if (SmartConfigure(Pkg, Depth + 1) == false)

_error->Error(_("Could not perform immediate configuration on '%s'. "

"Please see man 5 apt.conf under APT::Immediate-Configure for details. (%d)"),Pkg.FullName().c_str(),2);

Three steps are

- Aquiration of archives (stores the list of final file names)

- Sorting of operations

This is the final stage when the package cache entities get converted

into file names and the state stored in a DepCache is transformed

/* This intellegently looks at dep target packages and tries to figure

out which package should be used. This is needed to nicely handle

provide mapping. If the target package has no other providing packages

Otherwise true is returned and the target package is set. The return

result indicates whether the node should be expandable

ScopedErrorRevert() { _error->PushToStack(); }

~ScopedErrorRevert() { _error->RevertToStack(); }

};

pkgSourceList &List,

FileIterator const Start,

FileIterator const End,

MMap **OutMap = 0,

pkgCache **OutCache = 0)

{

ScopedErrorRevert ser;

bool const Debug = _config->FindB("Debug::pkgCacheGen", false);

// No file, certainly invalid

{

if (Debug == true)

return false;

}

{

if (Debug == true)

std::clog << "sources.list is newer than the cache" << std::endl;

}

// Map it

if (unlikely(Map->validData()) == false)

return false;

std::unique_ptr<pkgCache> CacheP(new pkgCache(Map.get()));

if (_error->PendingError() || Map->Size() == 0)

{

if (Debug == true)

}

std::unique_ptr<bool[]> RlsVisited(new bool[Cache.HeaderP->ReleaseFileCount]);

return true;

}

static bool loadBackMMapFromFile(std::unique_ptr<pkgCacheGenerator> &Gen,

{

Map.reset(CreateDynamicMMap(NULL, 0));

if (unlikely(Map->validData()) == false)

return false;

return false;

_error->PushToStack();

map_pointer_t const alloc = Map->RawAllocate(CacheF.Size());

return false;

// Decide if we can write to the files..

// ensure the cache directory exists

{

string dir = _config->FindDir("Dir::Cache");

size_t const len = dir.size();

if (len > 5 && dir.find("/apt/", len - 6, 5) == len - 5)

dir = dir.substr(0, len - 5);

}

if (Progress != NULL)

bool pkgcache_fine = false;

bool srcpkgcache_fine = false;

bool volatile_fine = List.GetVolatileFiles().empty();

volatile_fine ? OutCache : NULL) == true)

{

if (Debug == true)

pkgcache_fine = true;

srcpkgcache_fine = true;

}

if (pkgcache_fine == false)

{

{

if (Debug == true)

std::clog << "srcpkgcache.bin is valid - it can be reused" << std::endl;

bool Writeable = false;

if (srcpkgcache_fine == false || pkgcache_fine == false)

{

if (Debug == true)

std::clog << "Do we have write-access to the cache files? " << (Writeable ? "YES" : "NO") << std::endl;

BuildCache(*Gen, Progress, CurrentSize, TotalSize, &List,

Files.end(),Files.end());

return false;

}

BuildCache(*Gen, Progress, CurrentSize, TotalSize, NULL,

Files.begin(), Files.end());

return false;

}

package files. This is different than the generators parser in that

it is used to access information not generate information. No

information touched by the generator should be parable from here as

##################################################################### */

/*}}}*/

standard 'Version 0' engine is included inside the DepCache which is

it's historical location.

version selection. There are three primary means to choose a version

* Selection by version match

* Selection by Release file match

"Kernel-Version", // Used only by d-i

"Built-Using",

"Built-For-Profiles",

"Multi-Arch",

"Status",

"Priority",

Rewrite[J].NewTag = Rewrite[J].Tag;

}

if (Order != NULL)

{

for (unsigned int I = 0; Order[I] != 0; I++)

/** \brief amount of Tags in the current section

*

* times, but only the last occurrence is available via Find methods.

*/

unsigned int Count() const;

// Description /*{{{*/

/* ######################################################################

##################################################################### */

/*}}}*/

if (Progress != NULL)

Progress->Progress(50);

for (pkgCache::PkgIterator I = Cache.PkgBegin(); I.end() == false; ++I)

if (Cache[I].Delete() == true)

Cache.MarkKeep(I, false, false);

// Description /*{{{*/

/* ######################################################################

##################################################################### */

/*}}}*/

set(MAJOR 0.0)

set(MINOR 0)

file(GLOB_RECURSE library "*.cc")

file(GLOB_RECURSE headers "*.h")

}

else

{

ShowBroken(c1out,*this,true);

}

return true;

addArg('P', "build-profiles", "APT::Build-Profiles", CommandLine::HasArg);

addArg(0, "purge", "APT::Get::Purge", 0);

addArg(0, "solver", "APT::Solver", CommandLine::HasArg);

// this has no effect *but* sbuild is using it (see LP: #1255806)

// once sbuild is fixed, this option can be removed

addArg('f', "fix-broken", "APT::Get::Fix-Broken", 0);

addArg(0,"trivial-only","APT::Get::Trivial-Only",0);

addArg(0,"remove","APT::Get::Remove",0);

addArg(0,"only-source","APT::Get::Only-Source",0);

addArg(0,"allow-unauthenticated","APT::Get::AllowUnauthenticated",0);

addArg(0,"allow-insecure-repositories","Acquire::AllowInsecureRepositories",0);

addArg(0,"allow-weak-repositories","Acquire::AllowWeakRepositories",0);

std::string const binary = flNotDir(Binary);

if (binary == "apt-get" && CmdMatches("update"))

_config->CndSet("Binary::apt-get::Acquire::AllowInsecureRepositories", true);

}

#undef CmdMatches

/*}}}*/

for (auto const& cmd : CmdsWithHelp)

Cmds.push_back({cmd.Match, cmd.Handler});

char const * CmdCalled = nullptr;

if (Cmds.empty() == false && Cmds[0].Handler != nullptr)

CmdCalled = CommandLine::GetCommand(Cmds.data(), argc, argv);

BinaryCommandSpecificConfiguration(argv[0], CmdCalled);

std::string const conf = "Binary::" + _config->Find("Binary");

_config->MoveSubTree(conf.c_str(), nullptr);

auto Args = getCommandArgs(Binary, CmdCalled);

CmdL = CommandLine(Args.data(), _config);

}

CacheFile Cache;

return false;

LogCleaner Cleaner;

_error->PendingError() == true)

return false;

{

bool Missing = false;

RemoveDownloadNeedingItemsFromFetcher(Fetcher, Missing);

if (Missing)

Fetcher.Shutdown();

return false;

}

/* Remove unused automatic packages */

bool DoAutomaticRemove(CacheFile &Cache)

{

bool doAutoRemove = _config->FindB("APT::Get::AutomaticRemove", false);

bool hideAutoRemove = _config->FindB("APT::Get::HideAutoRemove");

packages */

if (BrokenFix == true && Cache->BrokenCount() != 0)

{

ShowBroken(c1out,Cache,false);

}

if (Fix != NULL)

#include <apt-private/private-moo.h>

#include <apt-private/private-output.h>

#include <stddef.h>

#include <string.h>

#include <apti18n.h>

/*}}}*/

struct tm special;

localtime_r(&timenow, &special);

enum { NORMAL, PACKAGEMANAGER, APPRECIATION, AGITATION, AIRBORN } line;

return out.str();

}

/*}}}*/

return true;

}

/*}}}*/

{

// our trustworthy super cow since 2001

if (_config->FindI("quiet") >= 2)

size_t const depth = moo.length()/4;

c1out <<

OutputInDepth(depth, " ") << " (__) \n" <<

return true;

}

/*}}}*/

{

// by Fernando Ribeiro in lp:56125

if (_config->FindI("quiet") >= 2)

size_t const depth = moo.length()/4;

if (_config->FindB("APT::Moo::Color", false) == false)

c1out <<

return true;

}

/*}}}*/

{

// by Robert Millan in deb:134156

if (_config->FindI("quiet") >= 2)

size_t const depth = moo.length()/16;

c1out <<

OutputInDepth(depth, " ") << " \\_/ \n" <<

return true;

}

/*}}}*/

{

// by Christopher Allan Webber and proposed by Paul Tagliamonte

// in a "Community outreach": https://lists.debian.org/debian-devel/2013/04/msg00045.html

/*}}}*/

bool DoMoo(CommandLine &CmdL) /*{{{*/

{

struct tm april;

localtime_r(&timenow, &april);

if (april.tm_mday == 1 && april.tm_mon == 3)

signed short SuperCow = 1;

if (CmdL.FileSize() != 0)

}

switch(SuperCow) {

}

return true;

class CommandLine;

APT_PUBLIC bool DoMoo(CommandLine &CmdL);

#endif

// ShowBroken - Debugging aide /*{{{*/

// ---------------------------------------------------------------------

/* This prints out the names of all the packages that are broken along

description.

The output looks like:

The following packages have unmet dependencies:

exim: Depends: libc6 (>= 2.1.94) but 2.1.3-10 is to be installed

Depends: libldap2 (>= 2.0.2-2) but it is not going to be installed

*/

static void ShowBrokenPackage(ostream &out, pkgCacheFile * const Cache, pkgCache::PkgIterator const &Pkg, bool const Now)

{

/*}}}*/

// DoSource - Fetch a source archive /*{{{*/

// ---------------------------------------------------------------------

struct DscFile

{

std::string Package;

if (_error->PendingError() == true)

return false;

// insert all downloaded uris into this set to avoid downloading them

// twice

// Load the requestd sources into the fetcher

aptAcquireWithTextStatus Fetcher;

std::vector<std::string> UntrustedList;

{

std::string Src;

pkgSrcRecords::Parser *Last = FindSrc(*I,SrcRecs,Src,Cache);

return false;

}

// Load them into the fetcher

for (std::vector<pkgSrcRecords::File2>::const_iterator I = Lst.begin();

I != Lst.end(); ++I)

// Try to guess what sort of file it is we are getting.

if (I->Type == "dsc")

{

}

// Handle the only options so that multiple can be used at once

{

ioprintf(c1out, "Skipping download of file '%s' as requested hashsum is not available for authentication\n",

localFile.c_str());

continue;

}

new pkgAcqFile(&Fetcher,Last->Index().ArchiveURI(I->Path),

I->Hashes, I->FileSize, Last->Index().SourceInfo(*Last,*I), Src);

}

}

// Display statistics

if (_config->FindB("APT::Get::Simulate",false) == true)

{

return true;

}

// Run it

bool Failed = false;

if (AcquireRun(Fetcher, 0, &Failed, NULL) == false || Failed == true)

return _error->Error(_("Failed to fetch some archives."));

{

c1out << _("Download complete and in download only mode") << std::endl;

return true;

}

{

{

{

{

}

}

}

}

}

}

/*}}}*/

// DoBuildDep - Install/removes packages to satisfy build dependencies /*{{{*/

<< "Architecture: " << Arch << "\n"

<< "Version: 1\n";

std::string depends, conflicts;

for (auto const &dep: Dependencies)

{

std::string * type;

if (dep.Type == pkgSrcRecords::Parser::BuildConflict ||

dep.Type == pkgSrcRecords::Parser::BuildConflictIndep ||

// deal with the build essentials first

{

std::vector<pkgSrcRecords::Parser::BuildDepRec> BuildDeps;

{

continue;

pkgSrcRecords::Parser::BuildDepRec rec;

rec.Type = pkgSrcRecords::Parser::BuildDependIndep;

rec.Op = 0;

BuildDeps.push_back(rec);

ListUpdate(Stat, *List);

}

// Rebuild the cache.

// show basic stats (if the user whishes)

if (_config->FindB("APT::Cmd::Show-Update-Stats", false) == true)

{

int upgradable = 0;

return false;

for (pkgCache::PkgIterator I = Cache->PkgBegin(); I.end() != true; ++I)

{

#include <config.h>

#include <apt-pkg/configuration.h>

#include <apt-pkg/fileutl.h>

#include <apt-private/private-utils.h>

#include <cstdlib>

#include <unistd.h>

// DisplayFileInPager - Display File with pager /*{{{*/

return ExecWait(Process, "editor", false);

}

/*}}}*/

bool DisplayFileInPager(std::string const &filename);

bool EditFileInSensibleEditor(std::string const &filename);

#endif

#!/bin/sh

set -e

export IFS="$(printf "\n\b")"

MASTER_KEYRING='&keyring-master-filename;'

# … other more complicated ones pipe gpg into gpg.

aptkey_execute() { echo >&2 'EXEC:' "$@"; sh "$@"; }

;;

--*)

echo >&2 "Unknown option: $1"

usage

rm -rf "$GPGHOMEDIR"

}

create_gpg_home() {

if [ -n "$TMPDIR" ]; then

# tmpdir is a directory and current user has rwx access to it

# same tests as in apt-pkg/contrib/fileutl.cc GetTempDir()

unset TMPDIR

fi

fi

CURRENTTRAP="${CURRENTTRAP} cleanup_gpg_home;"

trap "${CURRENTTRAP}" 0 HUP INT QUIT ILL ABRT FPE SEGV PIPE TERM

if [ -z "$GPGHOMEDIR" ]; then

create_gpg_home

# create the trustdb with an (empty) dummy keyring

# older gpgs required it, newer gpgs even warn that it isn't needed,

# but require it nonetheless for some commands, so we just play safe

false

fi

# We don't usually need a secret keyring, of course, but

# for advanced operations, we might really need a secret keyring after all

if [ -n "$FORCED_SECRET_KEYRING" ] && [ -r "$FORCED_SECRET_KEYRING" ]; then

if ! aptkey_execute "$GPG" -v --batch --import "$FORCED_SECRET_KEYRING" >"${GPGHOMEDIR}/gpgoutput.log" 2>&1; then

fi

else

# and then, there are older versions of gpg which panic and implode

' -- "$cur" ) )

return 0

;;

COMPREPLY=( $( compgen -W '

-s --simulate --dry-run

' -- "$cur" ) )

install)

COMPREPLY=( $( apt-cache --no-generate pkgnames "$cur" \

2> /dev/null ) )

return 0

;;

source|build-dep|showsrc|policy)

apt (1.4~beta1) unstable; urgency=medium

Support for GPG signatures using the SHA1 or RIPE-MD/160 hash

[Unit]

Documentation=man:apt(8)

ConditionACPower=true

[Service]

Type=oneshot

[Unit]

[Timer]

OnCalendar=*-*-* 6,18:00

RandomizedDelaySec=12h

Persistent=true

[Install]

if [ -n "$unamer" ]; then

running_version="$(echo "$list" | awk "\$1 == \"$unamer\" { print \$2;exit; }")"

fi

latest_version="$(echo "$debverlist" | sed -n 1p)"

previous_version="$(echo "$debverlist" | sed -n 2p)"

# list of different kernel versions:

$debverlist

# Installing kernel: $installed_version ($1)

# Last kernel: $latest_version

# Previous kernel: $previous_version

# Kernel versions list to keep:

chown -R root:root /var/lib/apt/lists /var/cache/apt/archives || true

fi

if dpkg --compare-versions "$2" lt-nl 0.9.7.7; then

# ensure permissions are right

chmod -f 0640 /var/log/apt/term.log* || true

}

# ------------------------ main ----------------------------

if test -r /var/lib/apt/extended_states; then

# Backup the 7 last versions of APT's extended_states file

exit 0

fi

else

fi

else

fi

else

fi

fi

else

fi

fi

else

fi

else

fi

else

fi

#

# vim: set sts=4 ai :

apt (1.4~beta1) unstable; urgency=medium

[ Chris Leick ]

* Make auto-remove and auto-clean aliases for the versions without -

(Closes: #274159)

* apt: Add autoremove and auto-remove commands

Thanks to Lintian

* debian/control: Replace debian by Debian.

Thanks to Lintian

Do not download more data in the mehotds than expected if we know

the size. For the InRelease/Release/Release.gpg add new

Acquire::MaxReleaseFileSize that defaults to 10Mb for now

* Only load unauthenticated data into our parsers when the user

explicitly asked for it via --allow-insecure-repositories

(Acquire::AllowInsecureRepositories)

(Closes: 733028)

* use apt-key adv (+ gnupg) instead of gpgv for verify

* support gnupg2 as drop-in replacement for gnupg

* use only one --keyring in gpg interactions

* add and use 'apt-key verify' which prefers gpgv over gpg

* remove empty keyrings in trusted.gpg.d on upgrade

* Improve the API for APT::Upgrade::Upgrade()

* Re-add "Calculating upgrade..." message

* Move ListUpdate/AcquireUpdate into update.{cc,h}

* Add new apt-pkg/install-progress.h with APT::Progress::PackageManager

progress reporting classes

* exclude config.{sub,guess} from source package

* update the symbol files to reflect current state

* unset LANGUAGE for showing [Y/n] answer hints

* specific pins below 1000 cause downgrades (Closes: 543966)

* use pkgTagFile to parse "header" of Release files

* fix: --print-uris removes authentication (Closes: 719263)

[ Michael Vogt ]

* moved source to http://git.debian.org/apt/apt.git

* updated gbp.conf to match what bzr-buildpackage is doing

-- Michael Vogt <mvo@debian.org> Thu, 16 May 2013 14:50:43 +0200

-- Michael Vogt <mvo@debian.org> Fri, 22 Mar 2013 21:57:08 +0100

* SECURITY UPDATE: InRelease verification bypass

- CVE-2013-1051

- show a debug why a package was kept by ResolveByKeep()

* apt-pkg/packagemanager.cc:

- do not fail on unpacked packages in SmartUnPack, just don't

- do not enter an endless loop for (essential) pre-dependency loops

* apt-pkg/contrib/sha2_internal.cc:

- use a pointer-union to peace gcc strict-aliasing warning

- honor Dpkg::Chroot-Directory in the RunScripts*() methods

* apt-pkg/contrib/cdromutl.{cc,h}, apt-pkg/cdrom.{cc,h}:

- deal with missing FSTAB_DIR when using libudev to discover cdrom

When this is set to false apt-cdrom will handle any removable

[ Christian Perrier ]

* Fix error in French translation of manpages (apt_preferences(5)).

* apt-pkg/deb/deblistparser.cc:

- overrule NotAutomatic in case of ButAutomaticUpgrades

* debian/apt.cron.daily:

directly instead of building the paths on our own (Closes: #596421)

* debian/control:

- build-depend on docbook-xml to ensure that the xml DTDs are always

- handle "circular" conflicts for "all" packages correctly

* cmdline/apt-cache.cc:

- be able to omit dependency types in (r)depends (Closes: #319006)

- share the (r)depends code instead of codecopy

* apt-pkg/cacheset.cc:

- move them back to the library as they look stable now

- add another round of const& madness as the previous round accidentally

NOT overrides the virtual GetCandidateVer() method (Closes: #587725)

* apt-pkg/pkgcachegen.{cc,h}:

applying (some) mad pointer magic (Closes: #195018)

[ Michael Vogt ]

[ Michael Vogt ]

* apt-pkg/pkgcache.cc:

triggers-pending state. dpkg will deal with the trigger and

it if does it before we trigger it, dpkg will error out

(LP: #414631)

* doc/apt.conf.5.xml:

- merged patch from Aurélien Couderc to improve the text

(thanks!)

"apt-udev-auto" to Acquire::Cdrom::mount and the cdrom method will

dynamically find/mount the cdrom device (if libhal is available)

so that it can correct any missing dependencies

* debian/apt.cron.daily:

- sleep random amount of time (default within 0-30min) before

* doc/apt_preferences.5.xml:

- fix typo

* added debian/README.source

- added "Dpkg::StopOnError" variable that controls if apt

will abort on errors from dpkg

* apt-pkg/deb/debsrcrecords.{cc,h}:

* Merged from Christian Perrier bzr branch:

- uk.po: New Ukrainian translation: 483t28f3u

- el.po: Update to 503t9f2u

* When matching regexs always print a message. Change regex activation

charset. Closes: #147817

* Don't die if lines in sources.list are too long. Closes: #146846

* i18n gettext stuff, based on work from Michael Piefel: Closes: #95933

* Some highly unlikely memory faults. Closes: #155842

* C++ stuff for G++3.2. Closes: #162617, #165515,

* Various changes to the locking metholodgy for --print-uris.

Closes: #100590

* Lame LD_LIBRARY_PATH thing. Closes: #98928

* Checksum and long lines problem. Closes: #106591

* .aptignr and empty files are just a warning. Closes: #97364

* Caching can be turned off by setting the cache file names blank.

* Ignores arches it does not know about when autocleaning. Closes: #72862

* New function in apt-config to return dirs, files, bools and integers.

complex cases involving OR groups and provides.

68754 describes confusing messages which are the result of this..

Closes: #63149, #69394, #68754, #77683, #66806, #81486, #78712

* Fixed Jay's relative path bug

* Allowed source only CDs. Closes: #58952

* Space check is suppressed if --print-uris is given. Closes: #58965

* Typo in the package description. Closes: #60230

* Man Page typo. Closes: #60347

* Typo in Algorithms.cc. Closes: #63577

* Now compiles on OpenBSD, Solaris and HP-UX

* Clarify segfault errors

* More debhelper fixes. Closes: #52662, #54566, #52090, #53531, #54769

* Fix for Ben Collins file: uri from slink upgrade.

* Fixed resume code in FTP. Closes: #54323

* Take more precautions to prevent the corruption Joey Hess saw.

* Added a check for an empty cache directory. Closes: #37963

* Return a failure code if -d is given and packages fail to download.

Closes: #38127

important note in the sources.list man page.

* Accounted for resumed files in the cps calculation. Closes: #36787

* Deal with duplicate same version different packages. Closes: #30237

;preexport = ./prepare-release pre-export

prebuild = ./prepare-release pre-build

postbuild = ./prepare-release post-build

debian-tag = %(version)s

export-dir = ../build-area

sign-tags = True

(c++)"void std::vector<pkgDPkgPM::Item, std::allocator<pkgDPkgPM::Item> >::emplace_back<pkgDPkgPM::Item::Ops, pkgCache::PkgIterator&>(pkgDPkgPM::Item::Ops&&, pkgCache::PkgIterator&)@APTPKG_5.0" 1.3~rc2

(c++)"void std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > >::emplace_back<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&)@APTPKG_5.0" 1.3~rc2

(c++)"void std::vector<std::pair<pkgDPkgPM::Item*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::allocator<std::pair<pkgDPkgPM::Item*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >::emplace_back<pkgDPkgPM::Item*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >(pkgDPkgPM::Item*&&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >&&)@APTPKG_5.0" 1.3~rc2

%:

dh $@

override_dh_install-indep:

dh_install --list-missing

# Do not restart "apt-daily.service" because this script runs

# unattended-upgrades. So if apt itself is upgraded as part of

# an unattended-upgrades run it would kill itself

override_dh_auto_configure-arch: flags=-DWITH_DOC=OFF

override_dh_auto_configure-indep: flags=-DWITH_DOC=ON

apt-get indextargets --format '$(FILENAME)' "Identifier: Translations" "Language: en"

The line-based filtering and the formatting is rather crude and feature-

filters and formatting for this command, it is recommend to use piping

and dedicated tools like 'grep-dctrl' if you need more than the basics

provided.

&apt-email;

&apt-product;

<!-- The last update date -->

</refentryinfo>

<refmeta>

Configuration Item: <literal>APT::Get::Diff-Only</literal>, <literal>APT::Get::Dsc-Only</literal>, and

<literal>APT::Get::Tar-Only</literal>.</para></listitem>

</varlistentry>

<varlistentry><term><option>--arch-only</option></term>

<listitem><para>Only process architecture-dependent build-dependencies.

Configuration Item: <literal>APT::Get::Arch-Only</literal>.</para></listitem>

</varlistentry>

<varlistentry><term><option>--allow-unauthenticated</option></term>

<listitem><para>Ignore if packages can't be authenticated and don't prompt

about it. This can be useful while working with local repositories,

<listitem>

<para>

Pass advanced options to gpg. With <command>adv --recv-key</command> you

keys. Note that there are <emphasis>no</emphasis> checks performed, so it is

easy to completely undermine the &apt-secure; infrastructure if used without

care.

">

<!-- this will be updated by 'prepare-release' -->

<!-- (Code)names for various things used all over the place -->

<!-- good and bad just refers to matching and not matching a pattern…

It is not a remark about the specific perl version.

<!-- Arguments -->

<!ENTITY synopsis-arg-option "<arg><option>-o=<replaceable>&synopsis-config-string;</replaceable></option></arg>">

</listitem>

</itemizedlist>

<para>

version, for example "&lt;= 0.5-1", "== 2.7.2-1", etc. The comparators

available are:-

</para>

Acquire::https[::repo.domain.tld]::IssuerCert "/path/to/issuer/cert.pem";

https mirrors or a specific one) to a specific issuer. If the

server certificate has not been issued by this certificate,

connection fails.

items in a custom configuration.

In some instances involving filenames it is possible to set the default

directory when the path is evaluated. This means you can use relative

paths within the sub scope.

The configuration directives are specified in a tree with {} designating

a subscope relative to the tag before the {}. You can further specify

APT::Architecture "i386";

This is prefixed with the current scope. Scope notation must be used

if an option is specified on the command line with -o.

*/

// Options for APT in general

{

// Options for apt-get

{

};

{

};

{

};

Update

Post-Invoke {"touch /var/lib/apt/post-update-stamp"; };

};

Name "rev";

Extension ".reversed";

Binary "rev";

UncompressArg {};

Cost "10";

};

Authentication

{

};

// Some general options

// be installed by default

// reverse Recommends or Suggests prevent autoremoval

// consider dependencies of packages in this section manual

Never-MarkAuto-Sections {"metapackages"; "universe/metapackages"; };

// Write progress messages on this fd (for stuff like base-config)

// Keep the list of FDs open (normally apt closes all fds when it

// does a ExecFork)

Keep-Fds {};

};

// Options for the downloading routines

Acquire

{

// HTTP method configuration

{

Proxy "http://127.0.0.1:3128";

Proxy::http.us.debian.org "DIRECT"; // Specific per-host setting

// Cache Control. Note these do not work with Squid 2.0.2

No-Cache "false";

Max-Age "86400"; // 1 Day age on index files

User-Agent "Debian APT-HTTP/1.3";

};

// HTTPS method configuration: uses the http

// - proxy config

// - cache-control values

// if not set explicit for https

//

// see /usr/share/doc/apt/examples/apt-https-method-example.conf.gz

No-Cache "false";

Max-Age "86400"; // 1 Day age on index files

No-Store "false"; // Prevent the cache from storing archives

User-Agent "Debian APT-CURL/1.0";

};

cdrom

{

// when auto-detecting, only look for cdrom/dvd. when this is false

// it will support any removable device as a "cdrom" source

CdromOnly "true";

Options {"--ignore-time-conflict";} // not very useful on a normal system

};

{

bz2 "bzip2";

lzma "lzma";

gz "gzip";

Order { "uncompressed"; "gz"; "lzma"; "bz2"; };

// Location of the changelogs with the placeholder @CHANGEPATH@ (e.g. "main/a/apt/apt_1.1")

};

// Directory layout

{

// Location of the state dir

{

};

// Location of the cache dir

};

// Config files

};

// Locations of binaries

Bin {

gpg "/usr/bin/gpgv";

dpkg-buildpackage "/usr/bin/dpkg-buildpackage";

};

};

{

};

};

// Things that effect the APT dselect method

{

Clean "auto"; // always|auto|prompt|never

Options "-f";

DPkg

{

// Probably don't want to use force-downgrade..

Options {"--force-overwrite";"--force-downgrade";}

// Flush the contents of stdin before forking dpkg.

FlushSTDIN "true";

// controls if apt will apport on the first dpkg error or if it

// tries to install as many packages as possible

of classes in the source code */

Debug

{

pkgCacheGen

{

Note: the Status field present in the dpkg database must not be passed

to the external solver, as it's an internal dpkg field. Installed and

- **Hold:** (optional, defaults to `no`). Allowed values: `yes`,

`no`. When set to `yes`, the corresponding package is marked as "on

<abstract>

<para>

</para>

</abstract>

# apt-get check

Reading Package Lists... Done

Building Dependency Tree... Done

Sorry, but the following packages have unmet dependencies:

9fonts: Depends: xlib6g but it is not installed

uucp: Depends: mailx but it is not installed

method separately after constructing it. Users of pkgCacheFile do not

need to worry about this

* GetCandidateVer/etc is gone from the pkgCache. It exists only in the

</orderedlist>

<para>

The two internal methods, copy and gzip, are used by the acquire code to

copying package files around the file system. Both methods can be seen to act

the same except that one decompresses on the fly. APT uses them by generating

a copy URI that is formed identically to a file URI. The destination file is

#, fuzzy

msgid ""

msgstr ""

"Report-Msgid-Bugs-To: APT Development Team <deity@lists.debian.org>\n"

"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"

"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"

"Language-Team: LANGUAGE <LL@li.org>\n"

#. type: Content of: <refentry><refsect1><variablelist><varlistentry><listitem><para>

#: apt-get.8.xml:1

msgid ""

"Ignore if packages can't be authenticated and don't prompt about it. This "

"can be useful while working with local repositories, but is a huge security "

"risk if data authenticity isn't ensured in another way by the user itself. "

#: apt-key.8.xml:1

msgid ""

"Pass advanced options to gpg. With <command>adv --recv-key</command> you can "

"keys. Note that there are <emphasis>no</emphasis> checks performed, so it is "

"easy to completely undermine the &apt-secure; infrastructure if used without "

"care."

#. type: Content of: <book><bookinfo><abstract><para>

#: guide.dbk:1

msgstr ""

#. type: Content of: <book><bookinfo>

"# apt-get check\n"

"Reading Package Lists... Done\n"

"Building Dependency Tree... Done\n"

"Sorry, but the following packages have unmet dependencies:\n"

" 9fonts: Depends: xlib6g but it is not installed\n"

" uucp: Depends: mailx but it is not installed\n"

msgstr ""

"Project-Id-Version: apt-doc 1.3\n"

"Report-Msgid-Bugs-To: APT Development Team <deity@lists.debian.org>\n"

"PO-Revision-Date: 2016-11-15 21:51+0200\n"

"Last-Translator: Chris Leick <c.leick@vollbio.de>\n"

"Language-Team: German <debian-l10n-german@lists.debian.org>\n"

#. type: Content of: <refentry><refsect1><variablelist><varlistentry><listitem><para>

#: apt-get.8.xml

msgid ""

"Ignore if packages can't be authenticated and don't prompt about it. This "

"can be useful while working with local repositories, but is a huge security "

#: apt-key.8.xml

msgid ""

"Pass advanced options to gpg. With <command>adv --recv-key</command> you can "

"Note that there are <emphasis>no</emphasis> checks performed, so it is easy "

"to completely undermine the &apt-secure; infrastructure if used without care."

msgstr ""

#. type: Content of: <book><bookinfo><abstract><para>

#: guide.dbk

msgid ""

msgstr ""

"Dieses Dokument stellt eine Übersicht bereit, wie das APT-"

"Paketverwaltungsprogramm benutzt wird."

"# apt-get check\n"

"Reading Package Lists... Done\n"

"Building Dependency Tree... Done\n"

"Sorry, but the following packages have unmet dependencies:\n"

" 9fonts: Depends: xlib6g but it is not installed\n"

" uucp: Depends: mailx but it is not installed\n"

"Paketlisten werden gelesen … Fertig Fertig\n"

"Abhängigkeitsbaum wird aufgebaut\n"

"Status-Informationen einlesen … Fertig Fertig\n"

"Die folgenden Pakete haben nichterfüllte Abhängigkeiten:\n"

" 9fonts: Hängt ab: xlib6g ist aber nicht installiert\n"

" uucp: Hängt ab: mailx ist aber nicht installiert\n"

msgstr ""

"Project-Id-Version: apt-doc 1.0.5\n"

"Report-Msgid-Bugs-To: APT Development Team <deity@lists.debian.org>\n"

"PO-Revision-Date: 2014-07-04 01:31+0200\n"

"Last-Translator: Omar Campagne <ocampagne@gmail.com>\n"

"Language-Team: Debian l10n Spanish <debian-l10n-spanish@lists.debian.org>\n"

#. type: Content of: <refentry><refsect1><variablelist><varlistentry><listitem><para>

#: apt-get.8.xml

msgid ""

"Ignore if packages can't be authenticated and don't prompt about it. This "

"can be useful while working with local repositories, but is a huge security "

#: apt-key.8.xml

msgid ""

"Pass advanced options to gpg. With <command>adv --recv-key</command> you can "

"Note that there are <emphasis>no</emphasis> checks performed, so it is easy "

"to completely undermine the &apt-secure; infrastructure if used without care."

msgstr ""

#. type: Content of: <book><bookinfo><abstract><para>

#: guide.dbk

msgid ""

msgstr ""

"Este documento ofrece una introducción sobre cómo usar el gestor de paquetes "

"APT."

"# apt-get check\n"

"Reading Package Lists... Done\n"

"Building Dependency Tree... Done\n"

"Sorry, but the following packages have unmet dependencies:\n"

" 9fonts: Depends: xlib6g but it is not installed\n"

" uucp: Depends: mailx but it is not installed\n"

"# apt-get check\n"

"Leyendo lista de paquetes... Hecho\n"

"Creando árbol de dependencias... Hecho\n"

"Los siguientes paquetes tienen dependencias incumplidas:\n"

" 9fonts: Depende: xlib6g pero no está instalado\n"

" uucp: Depende: mailx pero no está instalado\n"

# This file is distributed under the same license as the apt package.

#

# Translators:

# Jérôme Marant, 2000.

# Philippe Batailler, 2005.

# Christian Perrier <bubulle@debian.org>, 2009, 2010, 2011, 2012, 2013.

msgid ""

msgstr ""

"Project-Id-Version: apt-doc 1.0.5\n"

"Report-Msgid-Bugs-To: APT Development Team <deity@lists.debian.org>\n"

"Last-Translator: Jean-Pierre Giraud <jean-pierregiraud@neuf.fr>\n"

"Language-Team: French <debian-l10n-french@lists.debian.org>\n"

"Language: fr\n"

"enables some options better suited for interactive usage by default compared "

"to more specialized APT tools like &apt-get; and &apt-cache;."

msgstr ""

#. type: Content of: <refentry><refsect1><para>

#: apt.8.xml

"partly to not duplicate information in multiple places and partly to avoid "

"overwhelming readers with a cornucopia of options and details."

msgstr ""

#. type: Content of: <refentry><refsect1><variablelist><varlistentry><term>

#: apt.8.xml

"package upgrades or search in and display details about all packages "

"available for installation."

msgstr ""

#. type: Content of: <refentry><refsect1><variablelist><varlistentry><listitem><para>

#: apt.8.xml

msgid ""

"<option>upgrade</option> is used to install available upgrades of all "

"packages currently installed on the system from the sources configured via "

"a package requires the remove of an installed package the upgrade for this "

"package isn't performed."

msgstr ""