add options to disable specific checksums for Indexes

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

diff --git a/apt-pkg/aptconfiguration.cc b/apt-pkg/aptconfiguration.cc
index 899004d9f0d964c1482386f4551471047e6d0014..3cf4d24295bb0e55b4ef01e0ff68c4fc4994364a 100644 (file)
--- a/apt-pkg/aptconfiguration.cc
+++ b/apt-pkg/aptconfiguration.cc
@@ -8,13 +8,19 @@
    ##################################################################### */
                                                                        /*}}}*/
 // Include Files                                                       /*{{{*/
    ##################################################################### */
                                                                        /*}}}*/
 // Include Files                                                       /*{{{*/

-#include <apt-pkg/fileutl.h>

 #include <apt-pkg/aptconfiguration.h>
 #include <apt-pkg/configuration.h>
 #include <apt-pkg/aptconfiguration.h>
 #include <apt-pkg/configuration.h>

+#include <apt-pkg/error.h>
+#include <apt-pkg/fileutl.h>
+#include <apt-pkg/macros.h>
+#include <apt-pkg/strutl.h>
+
+#include <sys/types.h>
+#include <dirent.h>

 
 

-#include <vector>
-#include <string>

 #include <algorithm>
 #include <algorithm>

+#include <string>
+#include <vector>

                                                                        /*}}}*/
 namespace APT {
 // getCompressionTypes - Return Vector of usbale compressiontypes      /*{{{*/
                                                                        /*}}}*/
 namespace APT {
 // getCompressionTypes - Return Vector of usbale compressiontypes      /*{{{*/


@@ -84,6 +90,14 @@ const Configuration::getCompressionTypes(bool const &Cached) {
                types.push_back(Types->Tag);
        }
 
                types.push_back(Types->Tag);
        }
 

+       // add the special "uncompressed" type
+       if (std::find(types.begin(), types.end(), "uncompressed") == types.end())
+       {
+               string const uncompr = _config->FindFile("Dir::Bin::uncompressed", "");
+               if (uncompr.empty() == true || FileExists(uncompr) == true)
+                       types.push_back("uncompressed");
+       }
+

        return types;
 }
                                                                        /*}}}*/
        return types;
 }
                                                                        /*}}}*/


@@ -96,7 +110,7 @@ const Configuration::getCompressionTypes(bool const &Cached) {
    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,
    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) {
+                               bool const &Cached, char const ** const Locale) {

        using std::string;
 
        // The detection is boring and has a lot of cornercases,
        using std::string;
 
        // The detection is boring and has a lot of cornercases,


@@ -117,45 +131,97 @@ std::vector<std::string> const Configuration::getLanguages(bool const &All,
                }
        }
 
                }
        }
 

-       // 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;
+       // Include all Language codes we have a Translation file for in /var/lib/apt/lists
+       // so they will be all included in the Cache.
+       std::vector<string> builtin;
+       DIR *D = opendir(_config->FindDir("Dir::State::lists").c_str());
+       if (D != 0) {
+               builtin.push_back("none");
+               for (struct dirent *Ent = readdir(D); Ent != 0; Ent = readdir(D)) {
+                       string const name = Ent->d_name;
+                       size_t const foundDash = name.rfind("-");
+                       size_t const foundUnderscore = name.rfind("_");
+                       if (foundDash == string::npos || foundUnderscore == string::npos ||
+                           foundDash <= foundUnderscore ||
+                           name.substr(foundUnderscore+1, foundDash-(foundUnderscore+1)) != "Translation")
+                               continue;
+                       string const c = name.substr(foundDash+1);
+                       if (unlikely(c.empty() == true) || c == "en")
+                               continue;
+                       // Skip unusual files, like backups or that alike
+                       string::const_iterator s = c.begin();
+                       for (;s != c.end(); ++s) {
+                               if (isalpha(*s) == 0)
+                                       break;

                        }
                        }

+                       if (s != c.end())
+                               continue;
+                       if (std::find(builtin.begin(), builtin.end(), c) != builtin.end())
+                               continue;
+                       builtin.push_back(c);
+               }

        }
        }

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

 
        // 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") {
 
        // 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") {

+               // TRANSLATORS: the two %s are APT configuration options
+               _error->Notice("Option '%s' is deprecated. Please use '%s' instead, see 'man 5 apt.conf' for details.",
+                               "APT::Acquire::Translation", "Acquire::Languages");

                if (oldAcquire != "none")
                        codes.push_back(oldAcquire);
                if (oldAcquire != "none")
                        codes.push_back(oldAcquire);

-               return codes;
+               codes.push_back("en");
+               allCodes = codes;
+               for (std::vector<string>::const_iterator b = builtin.begin();
+                    b != builtin.end(); ++b)
+                       if (std::find(allCodes.begin(), allCodes.end(), *b) == allCodes.end())
+                               allCodes.push_back(*b);
+               if (All == true)
+                       return allCodes;
+               else
+                       return codes;
+       }
+
+       // get the environment language codes: LC_MESSAGES (and later LANGUAGE)
+       // 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_first_of(".@") != string::npos) ? envMsg.find_first_of(".@") : (lenShort + 3);
+
+       string const envLong = envMsg.substr(0,lenLong);
+       string const envShort = envLong.substr(0,lenShort);
+
+       // It is very likely we will need the environment codes later,
+       // so let us generate them now from LC_MESSAGES and LANGUAGE
+       std::vector<string> environment;
+       if (envShort != "C") {
+               // take care of LC_MESSAGES
+               if (envLong != envShort)
+                       environment.push_back(envLong);
+               environment.push_back(envShort);
+               // take care of LANGUAGE
+               const char *language_env = getenv("LANGUAGE") == 0 ? "" : getenv("LANGUAGE");
+               string envLang = Locale == 0 ? language_env : *(Locale+1);
+               if (envLang.empty() == false) {
+                       std::vector<string> env = VectorizeString(envLang,':');
+                       short addedLangs = 0; // add a maximum of 3 fallbacks from the environment
+                       for (std::vector<string>::const_iterator e = env.begin();
+                            e != env.end() && addedLangs < 3; ++e) {
+                               if (unlikely(e->empty() == true) || *e == "en")
+                                       continue;
+                               if (*e == envLong || *e == envShort)
+                                       continue;
+                               if (std::find(environment.begin(), environment.end(), *e) != environment.end())
+                                       continue;
+                               ++addedLangs;
+                               environment.push_back(*e);
+                       }
+               }
+       } else {
+               environment.push_back("en");

        }
 
        // Support settings like Acquire::Translation=none on the command line to
        }
 
        // Support settings like Acquire::Translation=none on the command line to


@@ -163,26 +229,45 @@ std::vector<std::string> const Configuration::getLanguages(bool const &All,
        string const forceLang = _config->Find("Acquire::Languages","");
        if (forceLang.empty() == false) {
                if (forceLang == "environment") {
        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;
+                       codes = environment;

                } else if (forceLang != "none")
                        codes.push_back(forceLang);
                } else if (forceLang != "none")
                        codes.push_back(forceLang);

-               return codes;
+               allCodes = codes;
+               for (std::vector<string>::const_iterator b = builtin.begin();
+                    b != builtin.end(); ++b)
+                       if (std::find(allCodes.begin(), allCodes.end(), *b) == allCodes.end())
+                               allCodes.push_back(*b);
+               if (All == true)
+                       return allCodes;
+               else
+                       return codes;
+       }
+
+       // cornercase: LANG=C, so we use only "en" Translation
+       if (envShort == "C") {
+               allCodes = codes = environment;
+               allCodes.insert(allCodes.end(), builtin.begin(), builtin.end());
+               if (All == true)
+                       return allCodes;
+               else
+                       return codes;

        }
 
        std::vector<string> const lang = _config->FindVector("Acquire::Languages");
        // the default setting -> "environment, en"
        if (lang.empty() == true) {
        }
 
        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);
+               codes = environment;

                if (envShort != "en")
                        codes.push_back("en");
                if (envShort != "en")
                        codes.push_back("en");

-               return codes;
+               allCodes = codes;
+               for (std::vector<string>::const_iterator b = builtin.begin();
+                    b != builtin.end(); ++b)
+                       if (std::find(allCodes.begin(), allCodes.end(), *b) == allCodes.end())
+                               allCodes.push_back(*b);
+               if (All == true)
+                       return allCodes;
+               else
+                       return codes;

        }
 
        // the configs define the order, so add the environment
        }
 
        // the configs define the order, so add the environment


@@ -191,36 +276,72 @@ std::vector<std::string> const Configuration::getLanguages(bool const &All,
        for (std::vector<string>::const_iterator l = lang.begin();
             l != lang.end(); l++) {
                if (*l == "environment") {
        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;
+                       for (std::vector<string>::const_iterator e = environment.begin();
+                            e != environment.end(); ++e) {
+                               if (std::find(allCodes.begin(), allCodes.end(), *e) != allCodes.end())
+                                       continue;

                                if (noneSeen == false)
                                if (noneSeen == false)

-                                       codes.push_back(envShort);
-                               allCodes.push_back(envShort);
+                                       codes.push_back(*e);
+                               allCodes.push_back(*e);

                        }
                        continue;
                } else if (*l == "none") {
                        noneSeen = true;
                        continue;
                        }
                        continue;
                } else if (*l == "none") {
                        noneSeen = true;
                        continue;

-               } else if ((envLongIncluded == true && *l == envLong) ||
-                        (envShortIncluded == true && *l == envShort))
+               } else if (std::find(allCodes.begin(), allCodes.end(), *l) != allCodes.end())

                        continue;
 
                if (noneSeen == false)
                        codes.push_back(*l);
                allCodes.push_back(*l);
        }
                        continue;
 
                if (noneSeen == false)
                        codes.push_back(*l);
                allCodes.push_back(*l);
        }

+
+       for (std::vector<string>::const_iterator b = builtin.begin();
+            b != builtin.end(); ++b)
+               if (std::find(allCodes.begin(), allCodes.end(), *b) == allCodes.end())
+                       allCodes.push_back(*b);
+

        if (All == true)
                return allCodes;
        else
                return codes;
 }
                                                                        /*}}}*/
        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;
+
+       archs = _config->FindVector("APT::Architectures");
+       string const arch = _config->Find("APT::Architecture");
+       if (unlikely(arch.empty() == true))
+               return archs;
+
+       if (archs.empty() == true ||
+           std::find(archs.begin(), archs.end(), arch) == archs.end())
+               archs.push_back(arch);
+
+       // erase duplicates and empty strings
+       for (std::vector<string>::reverse_iterator a = archs.rbegin();
+            a != archs.rend(); ++a) {
+               if (a->empty() == true || std::find(a + 1, archs.rend(), *a) != archs.rend())
+                       archs.erase(a.base()-1);
+               if (a == archs.rend())
+                       break;
+       }
+
+       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());
+}
+                                                                       /*}}}*/

 }
 }