apt-pkg/aptconfiguration.cc

   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/aptconfiguration.h>
  12 #include <apt-pkg/configuration.h>
  13 #include <apt-pkg/fileutl.h>
  14 #include <apt-pkg/macros.h>
  15 #include <apt-pkg/strutl.h>
  16
  17 #include <sys/types.h>
  18 #include <dirent.h>
  19
  20 #include <algorithm>
  21 #include <string>
  22 #include <vector>
  23                                                                         /*}}}*/
  24 namespace APT {
  25 // getCompressionTypes - Return Vector of usbale compressiontypes       /*{{{*/
  26 // ---------------------------------------------------------------------
  27 /* return a vector of compression types in the prefered order. */
  28 std::vector<std::string>
  29 const Configuration::getCompressionTypes(bool const &Cached) {
  30         static std::vector<std::string> types;
  31         if (types.empty() == false) {
  32                 if (Cached == true)
  33                         return types;
  34                 else
  35                         types.clear();
  36         }
  37
  38         // setup the defaults for the compressiontypes => method mapping
  39         _config->CndSet("Acquire::CompressionTypes::bz2","bzip2");
  40         _config->CndSet("Acquire::CompressionTypes::lzma","lzma");
  41         _config->CndSet("Acquire::CompressionTypes::gz","gzip");
  42
  43         // Set default application paths to check for optional compression types
  44         _config->CndSet("Dir::Bin::lzma", "/usr/bin/lzma");
  45         _config->CndSet("Dir::Bin::bzip2", "/bin/bzip2");
  46
  47         // accept non-list order as override setting for config settings on commandline
  48         std::string const overrideOrder = _config->Find("Acquire::CompressionTypes::Order","");
  49         if (overrideOrder.empty() == false)
  50                 types.push_back(overrideOrder);
  51
  52         // load the order setting into our vector
  53         std::vector<std::string> const order = _config->FindVector("Acquire::CompressionTypes::Order");
  54         for (std::vector<std::string>::const_iterator o = order.begin();
  55              o != order.end(); o++) {
  56                 if ((*o).empty() == true)
  57                         continue;
  58                 // ignore types we have no method ready to use
  59                 if (_config->Exists(string("Acquire::CompressionTypes::").append(*o)) == false)
  60                         continue;
  61                 // ignore types we have no app ready to use
  62                 string const appsetting = string("Dir::Bin::").append(*o);
  63                 if (_config->Exists(appsetting) == true) {
  64                         std::string const app = _config->FindFile(appsetting.c_str(), "");
  65                         if (app.empty() == false && FileExists(app) == false)
  66                                 continue;
  67                 }
  68                 types.push_back(*o);
  69         }
  70
  71         // move again over the option tree to add all missing compression types
  72         ::Configuration::Item const *Types = _config->Tree("Acquire::CompressionTypes");
  73         if (Types != 0)
  74                 Types = Types->Child;
  75
  76         for (; Types != 0; Types = Types->Next) {
  77                 if (Types->Tag == "Order" || Types->Tag.empty() == true)
  78                         continue;
  79                 // ignore types we already have in the vector
  80                 if (std::find(types.begin(),types.end(),Types->Tag) != types.end())
  81                         continue;
  82                 // ignore types we have no app ready to use
  83                 string const appsetting = string("Dir::Bin::").append(Types->Value);
  84                 if (appsetting.empty() == false && _config->Exists(appsetting) == true) {
  85                         std::string const app = _config->FindFile(appsetting.c_str(), "");
  86                         if (app.empty() == false && FileExists(app) == false)
  87                                 continue;
  88                 }
  89                 types.push_back(Types->Tag);
  90         }
  91
  92         return types;
  93 }
  94                                                                         /*}}}*/
  95 // GetLanguages - Return Vector of Language Codes                       /*{{{*/
  96 // ---------------------------------------------------------------------
  97 /* return a vector of language codes in the prefered order.
  98    the special word "environment" will be replaced with the long and the short
  99    code of the local settings and it will be insured that this will not add
 100    duplicates. So in an german local the setting "environment, de_DE, en, de"
 101    will result in "de_DE, de, en".
 102    The special word "none" is the stopcode for the not-All code vector */
 103 std::vector<std::string> const Configuration::getLanguages(bool const &All,
 104                                 bool const &Cached, char const ** const Locale) {
 105         using std::string;
 106
 107         // The detection is boring and has a lot of cornercases,
 108         // so we cache the results to calculated it only once.
 109         std::vector<string> static allCodes;
 110         std::vector<string> static codes;
 111
 112         // we have something in the cache
 113         if (codes.empty() == false || allCodes.empty() == false) {
 114                 if (Cached == true) {
 115                         if(All == true && allCodes.empty() == false)
 116                                 return allCodes;
 117                         else
 118                                 return codes;
 119                 } else {
 120                         allCodes.clear();
 121                         codes.clear();
 122                 }
 123         }
 124
 125         // Include all Language codes we have a Translation file for in /var/lib/apt/lists
 126         // so they will be all included in the Cache.
 127         std::vector<string> builtin;
 128         DIR *D = opendir(_config->FindDir("Dir::State::lists").c_str());
 129         if (D != 0) {
 130                 builtin.push_back("none");
 131                 for (struct dirent *Ent = readdir(D); Ent != 0; Ent = readdir(D)) {
 132                         string const name = Ent->d_name;
 133                         size_t const foundDash = name.rfind("-");
 134                         size_t const foundUnderscore = name.rfind("_");
 135                         if (foundDash == string::npos || foundUnderscore == string::npos ||
 136                             foundDash <= foundUnderscore ||
 137                             name.substr(foundUnderscore+1, foundDash-(foundUnderscore+1)) != "Translation")
 138                                 continue;
 139                         string const c = name.substr(foundDash+1);
 140                         if (unlikely(c.empty() == true) || c == "en")
 141                                 continue;
 142                         // Skip unusual files, like backups or that alike
 143                         string::const_iterator s = c.begin();
 144                         for (;s != c.end(); ++s) {
 145                                 if (isalpha(*s) == 0)
 146                                         break;
 147                         }
 148                         if (s != c.end())
 149                                 continue;
 150                         if (std::find(builtin.begin(), builtin.end(), c) != builtin.end())
 151                                 continue;
 152                         builtin.push_back(c);
 153                 }
 154         }
 155
 156         // get the environment language codes: LC_MESSAGES (and later LANGUAGE)
 157         // we extract both, a long and a short code and then we will
 158         // check if we actually need both (rare) or if the short is enough
 159         string const envMsg = string(Locale == 0 ? std::setlocale(LC_MESSAGES, NULL) : *Locale);
 160         size_t const lenShort = (envMsg.find('_') != string::npos) ? envMsg.find('_') : 2;
 161         size_t const lenLong = (envMsg.find_first_of(".@") != string::npos) ? envMsg.find_first_of(".@") : (lenShort + 3);
 162
 163         string envLong = envMsg.substr(0,lenLong);
 164         string const envShort = envLong.substr(0,lenShort);
 165         bool envLongIncluded = true;
 166
 167         // first cornercase: LANG=C, so we use only "en" Translation
 168         if (envLong == "C") {
 169                 codes.push_back("en");
 170                 allCodes = codes;
 171                 allCodes.insert(allCodes.end(), builtin.begin(), builtin.end());
 172                 if (All == true)
 173                         return allCodes;
 174                 else
 175                         return codes;
 176         }
 177
 178         // to save the servers from unneeded queries, we only try also long codes
 179         // for languages it is realistic to have a long code translation file…
 180         // TODO: Improve translation acquire system to drop them dynamic
 181         char const *needLong[] = { "cs", "en", "pt", "sv", "zh", NULL };
 182         if (envLong != envShort) {
 183                 for (char const **l = needLong; *l != NULL; l++)
 184                         if (envShort.compare(*l) == 0) {
 185                                 envLongIncluded = false;
 186                                 break;
 187                         }
 188         }
 189
 190         // we don't add the long code, but we allow the user to do so
 191         if (envLongIncluded == true)
 192                 envLong.clear();
 193
 194         // FIXME: Remove support for the old APT::Acquire::Translation
 195         // it was undocumented and so it should be not very widthly used
 196         string const oldAcquire = _config->Find("APT::Acquire::Translation","");
 197         if (oldAcquire.empty() == false && oldAcquire != "environment") {
 198                 if (oldAcquire != "none")
 199                         codes.push_back(oldAcquire);
 200                 codes.push_back("en");
 201                 allCodes = codes;
 202                 for (std::vector<string>::const_iterator b = builtin.begin();
 203                      b != builtin.end(); ++b)
 204                         if (std::find(allCodes.begin(), allCodes.end(), *b) == allCodes.end())
 205                                 allCodes.push_back(*b);
 206                 if (All == true)
 207                         return allCodes;
 208                 else
 209                         return codes;
 210         }
 211
 212         // It is very likely we will need to environment codes later,
 213         // so let us generate them now from LC_MESSAGES and LANGUAGE
 214         std::vector<string> environment;
 215         // take care of LC_MESSAGES
 216         if (envLongIncluded == false)
 217                 environment.push_back(envLong);
 218         environment.push_back(envShort);
 219         // take care of LANGUAGE
 220         const char *language_env = getenv("LANGUAGE") == 0 ? "" : getenv("LANGUAGE");
 221         string envLang = Locale == 0 ? language_env : *(Locale+1);
 222         if (envLang.empty() == false) {
 223                 std::vector<string> env = ExplodeString(envLang,':');
 224                 short addedLangs = 0; // add a maximum of 3 fallbacks from the environment
 225                 for (std::vector<string>::const_iterator e = env.begin();
 226                      e != env.end() && addedLangs < 3; ++e) {
 227                         if (unlikely(e->empty() == true) || *e == "en")
 228                                 continue;
 229                         if (*e == envLong || *e == envShort)
 230                                 continue;
 231                         if (std::find(environment.begin(), environment.end(), *e) != environment.end())
 232                                 continue;
 233                         if (e->find('_') != string::npos) {
 234                                 // Drop LongCodes here - ShortCodes are also included
 235                                 string const shorty = e->substr(0, e->find('_'));
 236                                 char const **n = needLong;
 237                                 for (; *n != NULL; ++n)
 238                                         if (shorty == *n)
 239                                                 break;
 240                                 if (*n == NULL)
 241                                         continue;
 242                         }
 243                         ++addedLangs;
 244                         environment.push_back(*e);
 245                 }
 246         }
 247
 248         // Support settings like Acquire::Translation=none on the command line to
 249         // override the configuration settings vector of languages.
 250         string const forceLang = _config->Find("Acquire::Languages","");
 251         if (forceLang.empty() == false) {
 252                 if (forceLang == "environment") {
 253                         codes = environment;
 254                 } else if (forceLang != "none")
 255                         codes.push_back(forceLang);
 256                 allCodes = codes;
 257                 for (std::vector<string>::const_iterator b = builtin.begin();
 258                      b != builtin.end(); ++b)
 259                         if (std::find(allCodes.begin(), allCodes.end(), *b) == allCodes.end())
 260                                 allCodes.push_back(*b);
 261                 if (All == true)
 262                         return allCodes;
 263                 else
 264                         return codes;
 265         }
 266
 267         std::vector<string> const lang = _config->FindVector("Acquire::Languages");
 268         // the default setting -> "environment, en"
 269         if (lang.empty() == true) {
 270                 codes = environment;
 271                 if (envShort != "en")
 272                         codes.push_back("en");
 273                 allCodes = codes;
 274                 for (std::vector<string>::const_iterator b = builtin.begin();
 275                      b != builtin.end(); ++b)
 276                         if (std::find(allCodes.begin(), allCodes.end(), *b) == allCodes.end())
 277                                 allCodes.push_back(*b);
 278                 if (All == true)
 279                         return allCodes;
 280                 else
 281                         return codes;
 282         }
 283
 284         // the configs define the order, so add the environment
 285         // then needed and ensure the codes are not listed twice.
 286         bool noneSeen = false;
 287         for (std::vector<string>::const_iterator l = lang.begin();
 288              l != lang.end(); l++) {
 289                 if (*l == "environment") {
 290                         for (std::vector<string>::const_iterator e = environment.begin();
 291                              e != environment.end(); ++e) {
 292                                 if (std::find(allCodes.begin(), allCodes.end(), *e) != allCodes.end())
 293                                         continue;
 294                                 if (noneSeen == false)
 295                                         codes.push_back(*e);
 296                                 allCodes.push_back(*e);
 297                         }
 298                         continue;
 299                 } else if (*l == "none") {
 300                         noneSeen = true;
 301                         continue;
 302                 } else if (std::find(allCodes.begin(), allCodes.end(), *l) != allCodes.end())
 303                         continue;
 304
 305                 if (noneSeen == false)
 306                         codes.push_back(*l);
 307                 allCodes.push_back(*l);
 308         }
 309
 310         for (std::vector<string>::const_iterator b = builtin.begin();
 311              b != builtin.end(); ++b)
 312                 if (std::find(allCodes.begin(), allCodes.end(), *b) == allCodes.end())
 313                         allCodes.push_back(*b);
 314
 315         if (All == true)
 316                 return allCodes;
 317         else
 318                 return codes;
 319 }
 320                                                                         /*}}}*/
 321 }