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 <config.h>
  12
  13 #include <apt-pkg/aptconfiguration.h>
  14 #include <apt-pkg/configuration.h>
  15 #include <apt-pkg/error.h>
  16 #include <apt-pkg/fileutl.h>
  17 #include <apt-pkg/macros.h>
  18 #include <apt-pkg/strutl.h>
  19
  20 #include <sys/types.h>
  21 #include <dirent.h>
  22 #include <stdio.h>
  23 #include <fcntl.h>
  24
  25 #include <algorithm>
  26 #include <string>
  27 #include <vector>
  28                                                                         /*}}}*/
  29 namespace APT {
  30 // getCompressionTypes - Return Vector of usbale compressiontypes       /*{{{*/
  31 // ---------------------------------------------------------------------
  32 /* return a vector of compression types in the prefered order. */
  33 std::vector<std::string>
  34 const Configuration::getCompressionTypes(bool const &Cached) {
  35         static std::vector<std::string> types;
  36         if (types.empty() == false) {
  37                 if (Cached == true)
  38                         return types;
  39                 else
  40                         types.clear();
  41         }
  42
  43         // setup the defaults for the compressiontypes => method mapping
  44         _config->CndSet("Acquire::CompressionTypes::bz2","bzip2");
  45         _config->CndSet("Acquire::CompressionTypes::xz","xz");
  46         _config->CndSet("Acquire::CompressionTypes::lzma","lzma");
  47         _config->CndSet("Acquire::CompressionTypes::gz","gzip");
  48
  49         setDefaultConfigurationForCompressors();
  50         std::vector<APT::Configuration::Compressor> const compressors = getCompressors();
  51
  52         // accept non-list order as override setting for config settings on commandline
  53         std::string const overrideOrder = _config->Find("Acquire::CompressionTypes::Order","");
  54         if (overrideOrder.empty() == false)
  55                 types.push_back(overrideOrder);
  56
  57         // load the order setting into our vector
  58         std::vector<std::string> const order = _config->FindVector("Acquire::CompressionTypes::Order");
  59         for (std::vector<std::string>::const_iterator o = order.begin();
  60              o != order.end(); ++o) {
  61                 if ((*o).empty() == true)
  62                         continue;
  63                 // ignore types we have no method ready to use
  64                 std::string const method = std::string("Acquire::CompressionTypes::").append(*o);
  65                 if (_config->Exists(method) == false)
  66                         continue;
  67                 // ignore types we have no app ready to use
  68                 std::string const app = _config->Find(method);
  69                 std::vector<APT::Configuration::Compressor>::const_iterator c = compressors.begin();
  70                 for (; c != compressors.end(); ++c)
  71                         if (c->Name == app)
  72                                 break;
  73                 if (c == compressors.end())
  74                         continue;
  75                 types.push_back(*o);
  76         }
  77
  78         // move again over the option tree to add all missing compression types
  79         ::Configuration::Item const *Types = _config->Tree("Acquire::CompressionTypes");
  80         if (Types != 0)
  81                 Types = Types->Child;
  82
  83         for (; Types != 0; Types = Types->Next) {
  84                 if (Types->Tag == "Order" || Types->Tag.empty() == true)
  85                         continue;
  86                 // ignore types we already have in the vector
  87                 if (std::find(types.begin(),types.end(),Types->Tag) != types.end())
  88                         continue;
  89                 // ignore types we have no app ready to use
  90                 std::vector<APT::Configuration::Compressor>::const_iterator c = compressors.begin();
  91                 for (; c != compressors.end(); ++c)
  92                         if (c->Name == Types->Value)
  93                                 break;
  94                 if (c == compressors.end())
  95                         continue;
  96                 types.push_back(Types->Tag);
  97         }
  98
  99         // add the special "uncompressed" type
 100         if (std::find(types.begin(), types.end(), "uncompressed") == types.end())
 101         {
 102                 std::string const uncompr = _config->FindFile("Dir::Bin::uncompressed", "");
 103                 if (uncompr.empty() == true || FileExists(uncompr) == true)
 104                         types.push_back("uncompressed");
 105         }
 106
 107         return types;
 108 }
 109                                                                         /*}}}*/
 110 // GetLanguages - Return Vector of Language Codes                       /*{{{*/
 111 // ---------------------------------------------------------------------
 112 /* return a vector of language codes in the prefered order.
 113    the special word "environment" will be replaced with the long and the short
 114    code of the local settings and it will be insured that this will not add
 115    duplicates. So in an german local the setting "environment, de_DE, en, de"
 116    will result in "de_DE, de, en".
 117    The special word "none" is the stopcode for the not-All code vector */
 118 std::vector<std::string> const Configuration::getLanguages(bool const &All,
 119                                 bool const &Cached, char const ** const Locale) {
 120         using std::string;
 121
 122         // The detection is boring and has a lot of cornercases,
 123         // so we cache the results to calculated it only once.
 124         std::vector<string> static allCodes;
 125         std::vector<string> static codes;
 126
 127         // we have something in the cache
 128         if (codes.empty() == false || allCodes.empty() == false) {
 129                 if (Cached == true) {
 130                         if(All == true && allCodes.empty() == false)
 131                                 return allCodes;
 132                         else
 133                                 return codes;
 134                 } else {
 135                         allCodes.clear();
 136                         codes.clear();
 137                 }
 138         }
 139
 140         // Include all Language codes we have a Translation file for in /var/lib/apt/lists
 141         // so they will be all included in the Cache.
 142         std::vector<string> builtin;
 143         DIR *D = opendir(_config->FindDir("Dir::State::lists").c_str());
 144         if (D != 0) {
 145                 builtin.push_back("none");
 146                 for (struct dirent *Ent = readdir(D); Ent != 0; Ent = readdir(D)) {
 147                         string const name = SubstVar(Ent->d_name, "%5f", "_");
 148                         size_t const foundDash = name.rfind("-");
 149                         size_t const foundUnderscore = name.rfind("_", foundDash);
 150                         if (foundDash == string::npos || foundUnderscore == string::npos ||
 151                             foundDash <= foundUnderscore ||
 152                             name.substr(foundUnderscore+1, foundDash-(foundUnderscore+1)) != "Translation")
 153                                 continue;
 154                         string const c = name.substr(foundDash+1);
 155                         if (unlikely(c.empty() == true) || c == "en")
 156                                 continue;
 157                         // Skip unusual files, like backups or that alike
 158                         string::const_iterator s = c.begin();
 159                         for (;s != c.end(); ++s) {
 160                                 if (isalpha(*s) == 0 && *s != '_')
 161                                         break;
 162                         }
 163                         if (s != c.end())
 164                                 continue;
 165                         if (std::find(builtin.begin(), builtin.end(), c) != builtin.end())
 166                                 continue;
 167                         builtin.push_back(c);
 168                 }
 169         }
 170         closedir(D);
 171
 172         // FIXME: Remove support for the old APT::Acquire::Translation
 173         // it was undocumented and so it should be not very widthly used
 174         string const oldAcquire = _config->Find("APT::Acquire::Translation","");
 175         if (oldAcquire.empty() == false && oldAcquire != "environment") {
 176                 // TRANSLATORS: the two %s are APT configuration options
 177                 _error->Notice("Option '%s' is deprecated. Please use '%s' instead, see 'man 5 apt.conf' for details.",
 178                                 "APT::Acquire::Translation", "Acquire::Languages");
 179                 if (oldAcquire != "none")
 180                         codes.push_back(oldAcquire);
 181                 codes.push_back("en");
 182                 allCodes = codes;
 183                 for (std::vector<string>::const_iterator b = builtin.begin();
 184                      b != builtin.end(); ++b)
 185                         if (std::find(allCodes.begin(), allCodes.end(), *b) == allCodes.end())
 186                                 allCodes.push_back(*b);
 187                 if (All == true)
 188                         return allCodes;
 189                 else
 190                         return codes;
 191         }
 192
 193         // get the environment language codes: LC_MESSAGES (and later LANGUAGE)
 194         // we extract both, a long and a short code and then we will
 195         // check if we actually need both (rare) or if the short is enough
 196         string const envMsg = string(Locale == 0 ? std::setlocale(LC_MESSAGES, NULL) : *Locale);
 197         size_t const lenShort = (envMsg.find('_') != string::npos) ? envMsg.find('_') : 2;
 198         size_t const lenLong = (envMsg.find_first_of(".@") != string::npos) ? envMsg.find_first_of(".@") : (lenShort + 3);
 199
 200         string const envLong = envMsg.substr(0,lenLong);
 201         string const envShort = envLong.substr(0,lenShort);
 202
 203         // It is very likely we will need the environment codes later,
 204         // so let us generate them now from LC_MESSAGES and LANGUAGE
 205         std::vector<string> environment;
 206         if (envShort != "C") {
 207                 // take care of LC_MESSAGES
 208                 if (envLong != envShort)
 209                         environment.push_back(envLong);
 210                 environment.push_back(envShort);
 211                 // take care of LANGUAGE
 212                 const char *language_env = getenv("LANGUAGE") == 0 ? "" : getenv("LANGUAGE");
 213                 string envLang = Locale == 0 ? language_env : *(Locale+1);
 214                 if (envLang.empty() == false) {
 215                         std::vector<string> env = VectorizeString(envLang,':');
 216                         short addedLangs = 0; // add a maximum of 3 fallbacks from the environment
 217                         for (std::vector<string>::const_iterator e = env.begin();
 218                              e != env.end() && addedLangs < 3; ++e) {
 219                                 if (unlikely(e->empty() == true) || *e == "en")
 220                                         continue;
 221                                 if (*e == envLong || *e == envShort)
 222                                         continue;
 223                                 if (std::find(environment.begin(), environment.end(), *e) != environment.end())
 224                                         continue;
 225                                 ++addedLangs;
 226                                 environment.push_back(*e);
 227                         }
 228                 }
 229         } else {
 230                 environment.push_back("en");
 231         }
 232
 233         // Support settings like Acquire::Languages=none on the command line to
 234         // override the configuration settings vector of languages.
 235         string const forceLang = _config->Find("Acquire::Languages","");
 236         if (forceLang.empty() == false) {
 237                 if (forceLang == "none") {
 238                         codes.clear();
 239                         allCodes.clear();
 240                         allCodes.push_back("none");
 241                 } else {
 242                         if (forceLang == "environment")
 243                                 codes = environment;
 244                         else
 245                                 codes.push_back(forceLang);
 246                         allCodes = codes;
 247                         for (std::vector<string>::const_iterator b = builtin.begin();
 248                              b != builtin.end(); ++b)
 249                                 if (std::find(allCodes.begin(), allCodes.end(), *b) == allCodes.end())
 250                                         allCodes.push_back(*b);
 251                 }
 252                 if (All == true)
 253                         return allCodes;
 254                 else
 255                         return codes;
 256         }
 257
 258         // cornercase: LANG=C, so we use only "en" Translation
 259         if (envShort == "C") {
 260                 allCodes = codes = environment;
 261                 allCodes.insert(allCodes.end(), builtin.begin(), builtin.end());
 262                 if (All == true)
 263                         return allCodes;
 264                 else
 265                         return codes;
 266         }
 267
 268         std::vector<string> const lang = _config->FindVector("Acquire::Languages");
 269         // the default setting -> "environment, en"
 270         if (lang.empty() == true) {
 271                 codes = environment;
 272                 if (envShort != "en")
 273                         codes.push_back("en");
 274                 allCodes = codes;
 275                 for (std::vector<string>::const_iterator b = builtin.begin();
 276                      b != builtin.end(); ++b)
 277                         if (std::find(allCodes.begin(), allCodes.end(), *b) == allCodes.end())
 278                                 allCodes.push_back(*b);
 279                 if (All == true)
 280                         return allCodes;
 281                 else
 282                         return codes;
 283         }
 284
 285         // the configs define the order, so add the environment
 286         // then needed and ensure the codes are not listed twice.
 287         bool noneSeen = false;
 288         for (std::vector<string>::const_iterator l = lang.begin();
 289              l != lang.end(); ++l) {
 290                 if (*l == "environment") {
 291                         for (std::vector<string>::const_iterator e = environment.begin();
 292                              e != environment.end(); ++e) {
 293                                 if (std::find(allCodes.begin(), allCodes.end(), *e) != allCodes.end())
 294                                         continue;
 295                                 if (noneSeen == false)
 296                                         codes.push_back(*e);
 297                                 allCodes.push_back(*e);
 298                         }
 299                         continue;
 300                 } else if (*l == "none") {
 301                         noneSeen = true;
 302                         continue;
 303                 } else if (std::find(allCodes.begin(), allCodes.end(), *l) != allCodes.end())
 304                         continue;
 305
 306                 if (noneSeen == false)
 307                         codes.push_back(*l);
 308                 allCodes.push_back(*l);
 309         }
 310
 311         for (std::vector<string>::const_iterator b = builtin.begin();
 312              b != builtin.end(); ++b)
 313                 if (std::find(allCodes.begin(), allCodes.end(), *b) == allCodes.end())
 314                         allCodes.push_back(*b);
 315
 316         if (All == true)
 317                 return allCodes;
 318         else
 319                 return codes;
 320 }
 321                                                                         /*}}}*/
 322 // checkLanguage - are we interested in the given Language?             /*{{{*/
 323 bool const Configuration::checkLanguage(std::string Lang, bool const All) {
 324         // the empty Language is always interesting as it is the original
 325         if (Lang.empty() == true)
 326                 return true;
 327         // filenames are encoded, so undo this
 328         Lang = SubstVar(Lang, "%5f", "_");
 329         std::vector<std::string> const langs = getLanguages(All, true);
 330         return (std::find(langs.begin(), langs.end(), Lang) != langs.end());
 331 }
 332                                                                         /*}}}*/
 333 // getArchitectures - Return Vector of prefered Architectures           /*{{{*/
 334 std::vector<std::string> const Configuration::getArchitectures(bool const &Cached) {
 335         using std::string;
 336
 337         std::vector<string> static archs;
 338         if (likely(Cached == true) && archs.empty() == false)
 339                 return archs;
 340
 341         string const arch = _config->Find("APT::Architecture");
 342         archs = _config->FindVector("APT::Architectures");
 343
 344         if (unlikely(arch.empty() == true))
 345                 return archs;
 346
 347         // FIXME: It is a bit unclean to have debian specific code here…
 348         if (archs.empty() == true) {
 349                 archs.push_back(arch);
 350
 351                 // Generate the base argument list for dpkg
 352                 std::vector<const char *> Args;
 353                 string Tmp = _config->Find("Dir::Bin::dpkg","dpkg");
 354                 {
 355                         string const dpkgChrootDir = _config->FindDir("DPkg::Chroot-Directory", "/");
 356                         size_t dpkgChrootLen = dpkgChrootDir.length();
 357                         if (dpkgChrootDir != "/" && Tmp.find(dpkgChrootDir) == 0) {
 358                                 if (dpkgChrootDir[dpkgChrootLen - 1] == '/')
 359                                         --dpkgChrootLen;
 360                                 Tmp = Tmp.substr(dpkgChrootLen);
 361                         }
 362                 }
 363                 Args.push_back(Tmp.c_str());
 364
 365                 // Stick in any custom dpkg options
 366                 ::Configuration::Item const *Opts = _config->Tree("DPkg::Options");
 367                 if (Opts != 0) {
 368                         Opts = Opts->Child;
 369                         for (; Opts != 0; Opts = Opts->Next)
 370                         {
 371                                 if (Opts->Value.empty() == true)
 372                                         continue;
 373                                 Args.push_back(Opts->Value.c_str());
 374                         }
 375                 }
 376
 377                 Args.push_back("--print-foreign-architectures");
 378                 Args.push_back(NULL);
 379
 380                 int external[2] = {-1, -1};
 381                 if (pipe(external) != 0)
 382                 {
 383                         _error->WarningE("getArchitecture", "Can't create IPC pipe for dpkg --print-foreign-architectures");
 384                         return archs;
 385                 }
 386
 387                 pid_t dpkgMultiArch = ExecFork();
 388                 if (dpkgMultiArch == 0) {
 389                         close(external[0]);
 390                         std::string const chrootDir = _config->FindDir("DPkg::Chroot-Directory");
 391                         int const nullfd = open("/dev/null", O_RDONLY);
 392                         dup2(nullfd, STDIN_FILENO);
 393                         dup2(external[1], STDOUT_FILENO);
 394                         dup2(nullfd, STDERR_FILENO);
 395                         if (chrootDir != "/" && chroot(chrootDir.c_str()) != 0 && chdir("/") != 0)
 396                                 _error->WarningE("getArchitecture", "Couldn't chroot into %s for dpkg --print-foreign-architectures", chrootDir.c_str());
 397                         execvp(Args[0], (char**) &Args[0]);
 398                         _error->WarningE("getArchitecture", "Can't detect foreign architectures supported by dpkg!");
 399                         _exit(100);
 400                 }
 401                 close(external[1]);
 402
 403                 FILE *dpkg = fdopen(external[0], "r");
 404                 if(dpkg != NULL) {
 405                         char buf[1024];
 406                         while (fgets(buf, sizeof(buf), dpkg) != NULL) {
 407                                 char* arch = strtok(buf, " ");
 408                                 while (arch != NULL) {
 409                                         for (; isspace(*arch) != 0; ++arch);
 410                                         if (arch[0] != '\0') {
 411                                                 char const* archend = arch;
 412                                                 for (; isspace(*archend) == 0 && *archend != '\0'; ++archend);
 413                                                 string a(arch, (archend - arch));
 414                                                 if (std::find(archs.begin(), archs.end(), a) == archs.end())
 415                                                         archs.push_back(a);
 416                                         }
 417                                         arch = strtok(NULL, " ");
 418                                 }
 419                         }
 420                         fclose(dpkg);
 421                 }
 422                 ExecWait(dpkgMultiArch, "dpkg --print-foreign-architectures", true);
 423                 return archs;
 424         }
 425
 426         if (archs.empty() == true ||
 427             std::find(archs.begin(), archs.end(), arch) == archs.end())
 428                 archs.insert(archs.begin(), arch);
 429
 430         // erase duplicates and empty strings
 431         for (std::vector<string>::reverse_iterator a = archs.rbegin();
 432              a != archs.rend(); ++a) {
 433                 if (a->empty() == true || std::find(a + 1, archs.rend(), *a) != archs.rend())
 434                         archs.erase(a.base()-1);
 435                 if (a == archs.rend())
 436                         break;
 437         }
 438
 439         return archs;
 440 }
 441                                                                         /*}}}*/
 442 // checkArchitecture - are we interested in the given Architecture?     /*{{{*/
 443 bool const Configuration::checkArchitecture(std::string const &Arch) {
 444         if (Arch == "all")
 445                 return true;
 446         std::vector<std::string> const archs = getArchitectures(true);
 447         return (std::find(archs.begin(), archs.end(), Arch) != archs.end());
 448 }
 449                                                                         /*}}}*/
 450 // setDefaultConfigurationForCompressors                                /*{{{*/
 451 void Configuration::setDefaultConfigurationForCompressors() {
 452         // Set default application paths to check for optional compression types
 453         _config->CndSet("Dir::Bin::bzip2", "/bin/bzip2");
 454         _config->CndSet("Dir::Bin::xz", "/usr/bin/xz");
 455         if (FileExists(_config->FindFile("Dir::Bin::xz")) == true) {
 456                 _config->Set("Dir::Bin::lzma", _config->FindFile("Dir::Bin::xz"));
 457                 _config->Set("APT::Compressor::lzma::Binary", "xz");
 458                 if (_config->Exists("APT::Compressor::lzma::CompressArg") == false) {
 459                         _config->Set("APT::Compressor::lzma::CompressArg::", "--format=lzma");
 460                         _config->Set("APT::Compressor::lzma::CompressArg::", "-9");
 461                 }
 462                 if (_config->Exists("APT::Compressor::lzma::UncompressArg") == false) {
 463                         _config->Set("APT::Compressor::lzma::UncompressArg::", "--format=lzma");
 464                         _config->Set("APT::Compressor::lzma::UncompressArg::", "-d");
 465                 }
 466         } else {
 467                 _config->CndSet("Dir::Bin::lzma", "/usr/bin/lzma");
 468                 if (_config->Exists("APT::Compressor::lzma::CompressArg") == false) {
 469                         _config->Set("APT::Compressor::lzma::CompressArg::", "--suffix=");
 470                         _config->Set("APT::Compressor::lzma::CompressArg::", "-9");
 471                 }
 472                 if (_config->Exists("APT::Compressor::lzma::UncompressArg") == false) {
 473                         _config->Set("APT::Compressor::lzma::UncompressArg::", "--suffix=");
 474                         _config->Set("APT::Compressor::lzma::UncompressArg::", "-d");
 475                 }
 476         }
 477 }
 478                                                                         /*}}}*/
 479 // getCompressors - Return Vector of usbale compressors                 /*{{{*/
 480 // ---------------------------------------------------------------------
 481 /* return a vector of compressors used by apt-ftparchive in the
 482    multicompress functionality or to detect data.tar files */
 483 std::vector<APT::Configuration::Compressor>
 484 const Configuration::getCompressors(bool const Cached) {
 485         static std::vector<APT::Configuration::Compressor> compressors;
 486         if (compressors.empty() == false) {
 487                 if (Cached == true)
 488                         return compressors;
 489                 else
 490                         compressors.clear();
 491         }
 492
 493         setDefaultConfigurationForCompressors();
 494
 495         compressors.push_back(Compressor(".", "", "", NULL, NULL, 1));
 496         if (_config->Exists("Dir::Bin::gzip") == false || FileExists(_config->FindFile("Dir::Bin::gzip")) == true)
 497                 compressors.push_back(Compressor("gzip",".gz","gzip","-9n","-d",2));
 498 #ifdef HAVE_ZLIB
 499         else
 500                 compressors.push_back(Compressor("gzip",".gz","false", NULL, NULL, 2));
 501 #endif
 502         if (_config->Exists("Dir::Bin::bzip2") == false || FileExists(_config->FindFile("Dir::Bin::bzip2")) == true)
 503                 compressors.push_back(Compressor("bzip2",".bz2","bzip2","-9","-d",3));
 504 #ifdef HAVE_BZ2
 505         else
 506                 compressors.push_back(Compressor("bzip2",".bz2","false", NULL, NULL, 3));
 507 #endif
 508         if (_config->Exists("Dir::Bin::xz") == false || FileExists(_config->FindFile("Dir::Bin::xz")) == true)
 509                 compressors.push_back(Compressor("xz",".xz","xz","-6","-d",4));
 510         if (_config->Exists("Dir::Bin::lzma") == false || FileExists(_config->FindFile("Dir::Bin::lzma")) == true)
 511                 compressors.push_back(Compressor("lzma",".lzma","lzma","-9","-d",5));
 512
 513         std::vector<std::string> const comp = _config->FindVector("APT::Compressor");
 514         for (std::vector<std::string>::const_iterator c = comp.begin();
 515              c != comp.end(); ++c) {
 516                 if (*c == "." || *c == "gzip" || *c == "bzip2" || *c == "lzma" || *c == "xz")
 517                         continue;
 518                 compressors.push_back(Compressor(c->c_str(), std::string(".").append(*c).c_str(), c->c_str(), "-9", "-d", 100));
 519         }
 520
 521         return compressors;
 522 }
 523                                                                         /*}}}*/
 524 // getCompressorExtensions - supported data.tar extensions              /*{{{*/
 525 // ---------------------------------------------------------------------
 526 /* */
 527 std::vector<std::string> const Configuration::getCompressorExtensions() {
 528         std::vector<APT::Configuration::Compressor> const compressors = getCompressors();
 529         std::vector<std::string> ext;
 530         for (std::vector<APT::Configuration::Compressor>::const_iterator c = compressors.begin();
 531              c != compressors.end(); ++c)
 532                 if (c->Extension.empty() == false && c->Extension != ".")
 533                         ext.push_back(c->Extension);
 534         return ext;
 535 }
 536                                                                         /*}}}*/
 537 // Compressor constructor                                               /*{{{*/
 538 // ---------------------------------------------------------------------
 539 /* */
 540 Configuration::Compressor::Compressor(char const *name, char const *extension,
 541                                       char const *binary,
 542                                       char const *compressArg, char const *uncompressArg,
 543                                       unsigned short const cost) {
 544         std::string const config = std::string("APT::Compressor::").append(name).append("::");
 545         Name = _config->Find(std::string(config).append("Name"), name);
 546         Extension = _config->Find(std::string(config).append("Extension"), extension);
 547         Binary = _config->Find(std::string(config).append("Binary"), binary);
 548         Cost = _config->FindI(std::string(config).append("Cost"), cost);
 549         std::string const compConf = std::string(config).append("CompressArg");
 550         if (_config->Exists(compConf) == true)
 551                 CompressArgs = _config->FindVector(compConf);
 552         else if (compressArg != NULL)
 553                 CompressArgs.push_back(compressArg);
 554         std::string const uncompConf = std::string(config).append("UncompressArg");
 555         if (_config->Exists(uncompConf) == true)
 556                 UncompressArgs = _config->FindVector(uncompConf);
 557         else if (uncompressArg != NULL)
 558                 UncompressArgs.push_back(uncompressArg);
 559 }
 560                                                                         /*}}}*/
 561 }