[apt.git] / apt-pkg / aptconfiguration.cc

// -*- mode: cpp; mode: fold -*-
// Description								/*{{{*/
/* ######################################################################

   Provide access methods to various configuration settings,
   setup defaults and returns validate settings.

   ##################################################################### */
									/*}}}*/
// Include Files							/*{{{*/
#include <apt-pkg/fileutl.h>
#include <apt-pkg/aptconfiguration.h>
#include <apt-pkg/configuration.h>
#include <apt-pkg/macros.h>

#include <vector>
#include <string>
#include <algorithm>
									/*}}}*/
namespace APT {
// getCompressionTypes - Return Vector of usbale compressiontypes	/*{{{*/
// ---------------------------------------------------------------------
/* return a vector of compression types in the prefered order. */
std::vector<std::string>
const Configuration::getCompressionTypes(bool const &Cached) {
	static std::vector<std::string> types;
	if (types.empty() == false) {
		if (Cached == true)
			return types;
		else
			types.clear();
	}

	// setup the defaults for the compressiontypes => method mapping
	_config->CndSet("Acquire::CompressionTypes::bz2","bzip2");
	_config->CndSet("Acquire::CompressionTypes::lzma","lzma");
	_config->CndSet("Acquire::CompressionTypes::gz","gzip");

	// Set default application paths to check for optional compression types
	_config->CndSet("Dir::Bin::lzma", "/usr/bin/lzma");
	_config->CndSet("Dir::Bin::bzip2", "/bin/bzip2");

	// accept non-list order as override setting for config settings on commandline
	std::string const overrideOrder = _config->Find("Acquire::CompressionTypes::Order","");
	if (overrideOrder.empty() == false)
		types.push_back(overrideOrder);

	// load the order setting into our vector
	std::vector<std::string> const order = _config->FindVector("Acquire::CompressionTypes::Order");
	for (std::vector<std::string>::const_iterator o = order.begin();
	     o != order.end(); o++) {
		if ((*o).empty() == true)
			continue;
		// ignore types we have no method ready to use
		if (_config->Exists(string("Acquire::CompressionTypes::").append(*o)) == false)
			continue;
		// ignore types we have no app ready to use
		string const appsetting = string("Dir::Bin::").append(*o);
		if (_config->Exists(appsetting) == true) {
			std::string const app = _config->FindFile(appsetting.c_str(), "");
			if (app.empty() == false && FileExists(app) == false)
				continue;
		}
		types.push_back(*o);
	}

	// move again over the option tree to add all missing compression types
	::Configuration::Item const *Types = _config->Tree("Acquire::CompressionTypes");
	if (Types != 0)
		Types = Types->Child;

	for (; Types != 0; Types = Types->Next) {
		if (Types->Tag == "Order" || Types->Tag.empty() == true)
			continue;
		// ignore types we already have in the vector
		if (std::find(types.begin(),types.end(),Types->Tag) != types.end())
			continue;
		// ignore types we have no app ready to use
		string const appsetting = string("Dir::Bin::").append(Types->Value);
		if (appsetting.empty() == false && _config->Exists(appsetting) == true) {
			std::string const app = _config->FindFile(appsetting.c_str(), "");
			if (app.empty() == false && FileExists(app) == false)
				continue;
		}
		types.push_back(Types->Tag);
	}

	return types;
}
									/*}}}*/
// GetLanguages - Return Vector of Language Codes			/*{{{*/
// ---------------------------------------------------------------------
/* return a vector of language codes in the prefered order.
   the special word "environment" will be replaced with the long and the short
   code of the local settings and it will be insured that this will not add
   duplicates. So in an german local the setting "environment, de_DE, en, de"
   will result in "de_DE, de, en".
   The special word "none" is the stopcode for the not-All code vector */
std::vector<std::string> const Configuration::getLanguages(bool const &All,
				bool const &Cached, char const * const Locale) {
	using std::string;

	// The detection is boring and has a lot of cornercases,
	// so we cache the results to calculated it only once.
	std::vector<string> static allCodes;
	std::vector<string> static codes;

	// we have something in the cache
	if (codes.empty() == false || allCodes.empty() == false) {
		if (Cached == true) {
			if(All == true && allCodes.empty() == false)
				return allCodes;
			else
				return codes;
		} else {
			allCodes.clear();
			codes.clear();
		}
	}

	// get the environment language code
	// we extract both, a long and a short code and then we will
	// check if we actually need both (rare) or if the short is enough
	string const envMsg = string(Locale == 0 ? std::setlocale(LC_MESSAGES, NULL) : Locale);
	size_t const lenShort = (envMsg.find('_') != string::npos) ? envMsg.find('_') : 2;
	size_t const lenLong = (envMsg.find('.') != string::npos) ? envMsg.find('.') : (lenShort + 3);

	string envLong = envMsg.substr(0,lenLong);
	string const envShort = envLong.substr(0,lenShort);
	bool envLongIncluded = true, envShortIncluded = false;

	// first cornercase: LANG=C, so we use only "en" Translation
	if (envLong == "C") {
		codes.push_back("en");
		return codes;
	}

	if (envLong != envShort) {
		// to save the servers from unneeded queries, we only try also long codes
		// for languages it is realistic to have a long code translation file...
		char const *needLong[] = { "cs", "en", "pt", "sv", "zh", NULL };
		for (char const **l = needLong; *l != NULL; l++)
			if (envShort.compare(*l) == 0) {
				envLongIncluded = false;
				break;
			}
	}

	// we don't add the long code, but we allow the user to do so
	if (envLongIncluded == true)
		envLong.clear();

	// FIXME: Remove support for the old APT::Acquire::Translation
	// it was undocumented and so it should be not very widthly used
	string const oldAcquire = _config->Find("APT::Acquire::Translation","");
	if (oldAcquire.empty() == false && oldAcquire != "environment") {
		if (oldAcquire != "none")
			codes.push_back(oldAcquire);
		return codes;
	}

	// Support settings like Acquire::Translation=none on the command line to
	// override the configuration settings vector of languages.
	string const forceLang = _config->Find("Acquire::Languages","");
	if (forceLang.empty() == false) {
		if (forceLang == "environment") {
			if (envLongIncluded == false)
				codes.push_back(envLong);
			if (envShortIncluded == false)
				codes.push_back(envShort);
			return codes;
		} else if (forceLang != "none")
			codes.push_back(forceLang);
		return codes;
	}

	std::vector<string> const lang = _config->FindVector("Acquire::Languages");
	// the default setting -> "environment, en"
	if (lang.empty() == true) {
		if (envLongIncluded == false)
			codes.push_back(envLong);
		if (envShortIncluded == false)
			codes.push_back(envShort);
		if (envShort != "en")
			codes.push_back("en");
		return codes;
	}

	// the configs define the order, so add the environment
	// then needed and ensure the codes are not listed twice.
	bool noneSeen = false;
	for (std::vector<string>::const_iterator l = lang.begin();
	     l != lang.end(); l++) {
		if (*l == "environment") {
			if (envLongIncluded == true && envShortIncluded == true)
				continue;
			if (envLongIncluded == false) {
				envLongIncluded = true;
				if (noneSeen == false)
					codes.push_back(envLong);
				allCodes.push_back(envLong);
			}
			if (envShortIncluded == false) {
				envShortIncluded = true;
				if (noneSeen == false)
					codes.push_back(envShort);
				allCodes.push_back(envShort);
			}
			continue;
		} else if (*l == "none") {
			noneSeen = true;
			continue;
		} else if ((envLongIncluded == true && *l == envLong) ||
		         (envShortIncluded == true && *l == envShort))
			continue;

		if (noneSeen == false)
			codes.push_back(*l);
		allCodes.push_back(*l);
	}
	if (All == true)
		return allCodes;
	else
		return codes;
}
									/*}}}*/
// getArchitectures - Return Vector of prefered Architectures		/*{{{*/
std::vector<std::string> const Configuration::getArchitectures(bool const &Cached) {
	using std::string;

	std::vector<string> static archs;
	if (likely(Cached == true) && archs.empty() == false)
		return archs;

	string const arch = _config->Find("APT::Architecture");
	archs = _config->FindVector("APT::Architectures");
	if (archs.empty() == true ||
	    std::find(archs.begin(), archs.end(), arch) == archs.end())
		archs.push_back(arch);
	return archs;
}
									/*}}}*/
// checkArchitecture - are we interested in the given Architecture?	/*{{{*/
bool const Configuration::checkArchitecture(std::string const &Arch) {
	if (Arch == "all")
		return true;
	std::vector<std::string> const archs = getArchitectures(true);
	return (std::find(archs.begin(), archs.end(), Arch) != archs.end());
}
									/*}}}*/
}
Commit	Line	Data
e878aedb DK	1	// -- mode: cpp; mode: fold --
	2	// Description /{{{/
	3	/* ######################################################################
	4
	5	Provide access methods to various configuration settings,
	6	setup defaults and returns validate settings.
	7
	8	##################################################################### */
	9	/}}}/
	10	// Include Files /{{{/
	11	#include <apt-pkg/fileutl.h>
	12	#include <apt-pkg/aptconfiguration.h>
	13	#include <apt-pkg/configuration.h>
34e8a998	14	#include <apt-pkg/macros.h>
e878aedb DK	15
	16	#include <vector>
	17	#include <string>
8bd02d8b	18	#include <algorithm>
e878aedb DK	19	/}}}/
	20	namespace APT {
	21	// getCompressionTypes - Return Vector of usbale compressiontypes /{{{/
	22	// ---------------------------------------------------------------------
	23	/* return a vector of compression types in the prefered order. */
	24	std::vector<std::string>
	25	const Configuration::getCompressionTypes(bool const &Cached) {
	26	static std::vector<std::string> types;
	27	if (types.empty() == false) {
	28	if (Cached == true)
	29	return types;
	30	else
	31	types.clear();
	32	}
	33
8bd02d8b DK	34	// setup the defaults for the compressiontypes => method mapping
	35	_config->CndSet("Acquire::CompressionTypes::bz2","bzip2");
	36	_config->CndSet("Acquire::CompressionTypes::lzma","lzma");
	37	_config->CndSet("Acquire::CompressionTypes::gz","gzip");
	38
e878aedb DK	39	// Set default application paths to check for optional compression types
	40	_config->CndSet("Dir::Bin::lzma", "/usr/bin/lzma");
	41	_config->CndSet("Dir::Bin::bzip2", "/bin/bzip2");
	42
8bd02d8b DK	43	// accept non-list order as override setting for config settings on commandline
	44	std::string const overrideOrder = _config->Find("Acquire::CompressionTypes::Order","");
	45	if (overrideOrder.empty() == false)
	46	types.push_back(overrideOrder);
e878aedb	47
8bd02d8b DK	48	// load the order setting into our vector
	49	std::vector<std::string> const order = _config->FindVector("Acquire::CompressionTypes::Order");
	50	for (std::vector<std::string>::const_iterator o = order.begin();
	51	o != order.end(); o++) {
	52	if ((*o).empty() == true)
	53	continue;
	54	// ignore types we have no method ready to use
	55	if (_config->Exists(string("Acquire::CompressionTypes::").append(*o)) == false)
	56	continue;
	57	// ignore types we have no app ready to use
	58	string const appsetting = string("Dir::Bin::").append(*o);
	59	if (_config->Exists(appsetting) == true) {
	60	std::string const app = _config->FindFile(appsetting.c_str(), "");
	61	if (app.empty() == false && FileExists(app) == false)
	62	continue;
	63	}
	64	types.push_back(*o);
e878aedb DK	65	}
e878aedb DK	66
8bd02d8b	67	// move again over the option tree to add all missing compression types
e878aedb DK	68	::Configuration::Item const *Types = _config->Tree("Acquire::CompressionTypes");
	69	if (Types != 0)
	70	Types = Types->Child;
	71
	72	for (; Types != 0; Types = Types->Next) {
8bd02d8b DK	73	if (Types->Tag == "Order" \|\| Types->Tag.empty() == true)
	74	continue;
	75	// ignore types we already have in the vector
	76	if (std::find(types.begin(),types.end(),Types->Tag) != types.end())
	77	continue;
	78	// ignore types we have no app ready to use
e878aedb	79	string const appsetting = string("Dir::Bin::").append(Types->Value);
e878aedb DK	80	if (appsetting.empty() == false && _config->Exists(appsetting) == true) {
	81	std::string const app = _config->FindFile(appsetting.c_str(), "");
	82	if (app.empty() == false && FileExists(app) == false)
	83	continue;
	84	}
	85	types.push_back(Types->Tag);
	86	}
	87
	88	return types;
	89	}
	90	/}}}/
45df0ad2 DK	91	// GetLanguages - Return Vector of Language Codes /{{{/
	92	// ---------------------------------------------------------------------
	93	/* return a vector of language codes in the prefered order.
	94	the special word "environment" will be replaced with the long and the short
	95	code of the local settings and it will be insured that this will not add
	96	duplicates. So in an german local the setting "environment, de_DE, en, de"
	97	will result in "de_DE, de, en".
	98	The special word "none" is the stopcode for the not-All code vector */
	99	std::vector<std::string> const Configuration::getLanguages(bool const &All,
	100	bool const &Cached, char const * const Locale) {
	101	using std::string;
	102
	103	// The detection is boring and has a lot of cornercases,
	104	// so we cache the results to calculated it only once.
	105	std::vector<string> static allCodes;
	106	std::vector<string> static codes;
	107
	108	// we have something in the cache
	109	if (codes.empty() == false \|\| allCodes.empty() == false) {
	110	if (Cached == true) {
	111	if(All == true && allCodes.empty() == false)
	112	return allCodes;
	113	else
	114	return codes;
	115	} else {
	116	allCodes.clear();
	117	codes.clear();
	118	}
	119	}
	120
	121	// get the environment language code
	122	// we extract both, a long and a short code and then we will
	123	// check if we actually need both (rare) or if the short is enough
	124	string const envMsg = string(Locale == 0 ? std::setlocale(LC_MESSAGES, NULL) : Locale);
	125	size_t const lenShort = (envMsg.find('_') != string::npos) ? envMsg.find('_') : 2;
	126	size_t const lenLong = (envMsg.find('.') != string::npos) ? envMsg.find('.') : (lenShort + 3);
	127
	128	string envLong = envMsg.substr(0,lenLong);
	129	string const envShort = envLong.substr(0,lenShort);
	130	bool envLongIncluded = true, envShortIncluded = false;
	131
	132	// first cornercase: LANG=C, so we use only "en" Translation
	133	if (envLong == "C") {
	134	codes.push_back("en");
	135	return codes;
	136	}
	137
	138	if (envLong != envShort) {
	139	// to save the servers from unneeded queries, we only try also long codes
	140	// for languages it is realistic to have a long code translation file...
	141	char const *needLong[] = { "cs", "en", "pt", "sv", "zh", NULL };
	142	for (char const *l = needLong; l != NULL; l++)
	143	if (envShort.compare(*l) == 0) {
	144	envLongIncluded = false;
	145	break;
	146	}
	147	}
	148
	149	// we don't add the long code, but we allow the user to do so
	150	if (envLongIncluded == true)
	151	envLong.clear();
	152
	153	// FIXME: Remove support for the old APT::Acquire::Translation
	154	// it was undocumented and so it should be not very widthly used
155	string const oldAcquire = _config->Find("APT::Acquire::Translation","");
156	if (oldAcquire.empty() == false && oldAcquire != "environment") {
157	if (oldAcquire != "none")
158	codes.push_back(oldAcquire);
159	return codes;
160	}
161
162	// Support settings like Acquire::Translation=none on the command line to
163	// override the configuration settings vector of languages.
164	string const forceLang = _config->Find("Acquire::Languages","");
165	if (forceLang.empty() == false) {
166	if (forceLang == "environment") {
167	if (envLongIncluded == false)
168	codes.push_back(envLong);
169	if (envShortIncluded == false)
170	codes.push_back(envShort);
171	return codes;
172	} else if (forceLang != "none")
173	codes.push_back(forceLang);
174	return codes;
175	}
176
177	std::vector<string> const lang = _config->FindVector("Acquire::Languages");
178	// the default setting -> "environment, en"
179	if (lang.empty() == true) {
180	if (envLongIncluded == false)
181	codes.push_back(envLong);
182	if (envShortIncluded == false)
183	codes.push_back(envShort);
184	if (envShort != "en")
185	codes.push_back("en");
186	return codes;
187	}
188
189	// the configs define the order, so add the environment
190	// then needed and ensure the codes are not listed twice.
191	bool noneSeen = false;
192	for (std::vector<string>::const_iterator l = lang.begin();
193	l != lang.end(); l++) {
194	if (*l == "environment") {
195	if (envLongIncluded == true && envShortIncluded == true)
196	continue;
197	if (envLongIncluded == false) {
198	envLongIncluded = true;
199	if (noneSeen == false)
200	codes.push_back(envLong);
201	allCodes.push_back(envLong);
202	}
203	if (envShortIncluded == false) {
204	envShortIncluded = true;
205	if (noneSeen == false)
206	codes.push_back(envShort);
207	allCodes.push_back(envShort);
208	}
209	continue;
210	} else if (*l == "none") {
211	noneSeen = true;
212	continue;
213	} else if ((envLongIncluded == true && *l == envLong) \|\|
214	(envShortIncluded == true && *l == envShort))
215	continue;
216
217	if (noneSeen == false)
218	codes.push_back(*l);
219	allCodes.push_back(*l);
220	}
221	if (All == true)
222	return allCodes;
223	else
224	return codes;
225	}
226	/}}}/
5dd4c8b8 DK	227	// getArchitectures - Return Vector of prefered Architectures /{{{/
	228	std::vector<std::string> const Configuration::getArchitectures(bool const &Cached) {
	229	using std::string;
	230
	231	std::vector<string> static archs;
	232	if (likely(Cached == true) && archs.empty() == false)
	233	return archs;
	234
	235	string const arch = _config->Find("APT::Architecture");
	236	archs = _config->FindVector("APT::Architectures");
	237	if (archs.empty() == true \|\|
	238	std::find(archs.begin(), archs.end(), arch) == archs.end())
	239	archs.push_back(arch);
	240	return archs;
	241	}
	242	/}}}/
	243	// checkArchitecture - are we interested in the given Architecture? /{{{/
	244	bool const Configuration::checkArchitecture(std::string const &Arch) {
	245	if (Arch == "all")
	246	return true;
	247	std::vector<std::string> const archs = getArchitectures(true);
	248	return (std::find(archs.begin(), archs.end(), Arch) != archs.end());
	249	}
	250	/}}}/
e878aedb	251	}