]> git.saurik.com Git - apt.git/blame - apt-pkg/aptconfiguration.cc
* deb/deblistparser.cc:
[apt.git] / apt-pkg / aptconfiguration.cc
CommitLineData
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 /*{{{*/
ea542140
DK
11#include <config.h>
12
e878aedb
DK
13#include <apt-pkg/aptconfiguration.h>
14#include <apt-pkg/configuration.h>
9f9717fa 15#include <apt-pkg/error.h>
d7cf5923
DK
16#include <apt-pkg/fileutl.h>
17#include <apt-pkg/macros.h>
18#include <apt-pkg/strutl.h>
e878aedb 19
3f2d77b5
DK
20#include <sys/types.h>
21#include <dirent.h>
8aec002f 22#include <stdio.h>
b9ed63d3 23#include <fcntl.h>
3f2d77b5 24
8bd02d8b 25#include <algorithm>
3f2d77b5
DK
26#include <string>
27#include <vector>
e878aedb
DK
28 /*}}}*/
29namespace APT {
30// getCompressionTypes - Return Vector of usbale compressiontypes /*{{{*/
31// ---------------------------------------------------------------------
32/* return a vector of compression types in the prefered order. */
33std::vector<std::string>
34const 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
8bd02d8b
DK
43 // setup the defaults for the compressiontypes => method mapping
44 _config->CndSet("Acquire::CompressionTypes::bz2","bzip2");
b2430e6d 45 _config->CndSet("Acquire::CompressionTypes::xz","xz");
8bd02d8b
DK
46 _config->CndSet("Acquire::CompressionTypes::lzma","lzma");
47 _config->CndSet("Acquire::CompressionTypes::gz","gzip");
48
03bef784 49 setDefaultConfigurationForCompressors();
858fd39f 50 std::vector<APT::Configuration::Compressor> const compressors = getCompressors();
e878aedb 51
8bd02d8b
DK
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);
e878aedb 56
8bd02d8b
DK
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();
f7f0d6c7 60 o != order.end(); ++o) {
8bd02d8b
DK
61 if ((*o).empty() == true)
62 continue;
63 // ignore types we have no method ready to use
79b207bc
DK
64 std::string const method = std::string("Acquire::CompressionTypes::").append(*o);
65 if (_config->Exists(method) == false)
8bd02d8b
DK
66 continue;
67 // ignore types we have no app ready to use
79b207bc 68 std::string const app = _config->Find(method);
858fd39f
DK
69 std::vector<APT::Configuration::Compressor>::const_iterator c = compressors.begin();
70 for (; c != compressors.end(); ++c)
79b207bc 71 if (c->Name == app)
858fd39f
DK
72 break;
73 if (c == compressors.end())
74 continue;
8bd02d8b 75 types.push_back(*o);
e878aedb
DK
76 }
77
8bd02d8b 78 // move again over the option tree to add all missing compression types
e878aedb
DK
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) {
8bd02d8b
DK
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
858fd39f
DK
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;
e878aedb
DK
96 types.push_back(Types->Tag);
97 }
98
5d885723
DK
99 // add the special "uncompressed" type
100 if (std::find(types.begin(), types.end(), "uncompressed") == types.end())
101 {
8f3ba4e8 102 std::string const uncompr = _config->FindFile("Dir::Bin::uncompressed", "");
5d885723
DK
103 if (uncompr.empty() == true || FileExists(uncompr) == true)
104 types.push_back("uncompressed");
105 }
106
e878aedb
DK
107 return types;
108}
109 /*}}}*/
45df0ad2
DK
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 */
118std::vector<std::string> const Configuration::getLanguages(bool const &All,
d7cf5923 119 bool const &Cached, char const ** const Locale) {
45df0ad2
DK
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
3f2d77b5
DK
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)) {
527df5a2 147 string const name = SubstVar(Ent->d_name, "%5f", "_");
3f2d77b5 148 size_t const foundDash = name.rfind("-");
7cb28948 149 size_t const foundUnderscore = name.rfind("_", foundDash);
3f2d77b5
DK
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) {
7cb28948 160 if (isalpha(*s) == 0 && *s != '_')
3f2d77b5
DK
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 }
cf0e078c 170 closedir(D);
3f2d77b5 171
45df0ad2
DK
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") {
9f9717fa
DK
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");
45df0ad2
DK
179 if (oldAcquire != "none")
180 codes.push_back(oldAcquire);
3f2d77b5 181 codes.push_back("en");
d7cf5923 182 allCodes = codes;
3f2d77b5
DK
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;
45df0ad2
DK
191 }
192
ab53c018
DK
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,
d7cf5923
DK
204 // so let us generate them now from LC_MESSAGES and LANGUAGE
205 std::vector<string> environment;
eb3947c6
DK
206 if (envShort != "C") {
207 // take care of LC_MESSAGES
ab53c018 208 if (envLong != envShort)
eb3947c6
DK
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())
d7cf5923 224 continue;
eb3947c6
DK
225 ++addedLangs;
226 environment.push_back(*e);
d7cf5923 227 }
d7cf5923 228 }
eb3947c6
DK
229 } else {
230 environment.push_back("en");
d7cf5923
DK
231 }
232
da833832 233 // Support settings like Acquire::Languages=none on the command line to
45df0ad2
DK
234 // override the configuration settings vector of languages.
235 string const forceLang = _config->Find("Acquire::Languages","");
236 if (forceLang.empty() == false) {
f87fab03
DK
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 }
3f2d77b5
DK
252 if (All == true)
253 return allCodes;
254 else
255 return codes;
45df0ad2
DK
256 }
257
eb3947c6
DK
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
45df0ad2
DK
268 std::vector<string> const lang = _config->FindVector("Acquire::Languages");
269 // the default setting -> "environment, en"
270 if (lang.empty() == true) {
d7cf5923 271 codes = environment;
45df0ad2
DK
272 if (envShort != "en")
273 codes.push_back("en");
d7cf5923 274 allCodes = codes;
3f2d77b5
DK
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;
45df0ad2
DK
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();
f7f0d6c7 289 l != lang.end(); ++l) {
45df0ad2 290 if (*l == "environment") {
d7cf5923
DK
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;
45df0ad2 295 if (noneSeen == false)
d7cf5923
DK
296 codes.push_back(*e);
297 allCodes.push_back(*e);
45df0ad2
DK
298 }
299 continue;
300 } else if (*l == "none") {
301 noneSeen = true;
302 continue;
d7cf5923 303 } else if (std::find(allCodes.begin(), allCodes.end(), *l) != allCodes.end())
45df0ad2
DK
304 continue;
305
306 if (noneSeen == false)
307 codes.push_back(*l);
308 allCodes.push_back(*l);
309 }
3f2d77b5
DK
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
45df0ad2
DK
316 if (All == true)
317 return allCodes;
318 else
319 return codes;
320}
321 /*}}}*/
5dd4c8b8
DK
322// getArchitectures - Return Vector of prefered Architectures /*{{{*/
323std::vector<std::string> const Configuration::getArchitectures(bool const &Cached) {
324 using std::string;
325
326 std::vector<string> static archs;
327 if (likely(Cached == true) && archs.empty() == false)
328 return archs;
329
3152f4aa 330 string const arch = _config->Find("APT::Architecture");
8aec002f
DK
331 archs = _config->FindVector("APT::Architectures");
332
3152f4aa
DK
333 if (unlikely(arch.empty() == true))
334 return archs;
335
8aec002f
DK
336 // FIXME: It is a bit unclean to have debian specific code hereā€¦
337 if (archs.empty() == true) {
338 archs.push_back(arch);
b9ed63d3
DK
339
340 // Generate the base argument list for dpkg
341 std::vector<const char *> Args;
342 string Tmp = _config->Find("Dir::Bin::dpkg","dpkg");
343 {
344 string const dpkgChrootDir = _config->FindDir("DPkg::Chroot-Directory", "/");
345 size_t dpkgChrootLen = dpkgChrootDir.length();
346 if (dpkgChrootDir != "/" && Tmp.find(dpkgChrootDir) == 0) {
347 if (dpkgChrootDir[dpkgChrootLen - 1] == '/')
348 --dpkgChrootLen;
349 Tmp = Tmp.substr(dpkgChrootLen);
350 }
351 }
352 Args.push_back(Tmp.c_str());
353
354 // Stick in any custom dpkg options
355 ::Configuration::Item const *Opts = _config->Tree("DPkg::Options");
356 if (Opts != 0) {
357 Opts = Opts->Child;
358 for (; Opts != 0; Opts = Opts->Next)
359 {
360 if (Opts->Value.empty() == true)
361 continue;
362 Args.push_back(Opts->Value.c_str());
363 }
364 }
365
366 Args.push_back("--print-foreign-architectures");
367 Args.push_back(NULL);
368
369 int external[2] = {-1, -1};
370 if (pipe(external) != 0)
371 {
372 _error->WarningE("getArchitecture", "Can't create IPC pipe for dpkg --print-foreign-architectures");
373 return archs;
374 }
375
376 pid_t dpkgMultiArch = ExecFork();
377 if (dpkgMultiArch == 0) {
378 close(external[0]);
379 std::string const chrootDir = _config->FindDir("DPkg::Chroot-Directory");
380 if (chrootDir != "/" && chroot(chrootDir.c_str()) != 0)
381 _error->WarningE("getArchitecture", "Couldn't chroot into %s for dpkg --print-foreign-architectures", chrootDir.c_str());
382 int const nullfd = open("/dev/null", O_RDONLY);
383 dup2(nullfd, STDIN_FILENO);
384 dup2(external[1], STDOUT_FILENO);
385 dup2(nullfd, STDERR_FILENO);
17019a09 386 execvp(Args[0], (char**) &Args[0]);
b9ed63d3
DK
387 _error->WarningE("getArchitecture", "Can't detect foreign architectures supported by dpkg!");
388 _exit(100);
389 }
390 close(external[1]);
391
392 FILE *dpkg = fdopen(external[0], "r");
8aec002f
DK
393 char buf[1024];
394 if(dpkg != NULL) {
4df62de6 395 while (fgets(buf, sizeof(buf), dpkg) != NULL) {
8aec002f
DK
396 char* arch = strtok(buf, " ");
397 while (arch != NULL) {
398 for (; isspace(*arch) != 0; ++arch);
bdb3d92c 399 if (arch[0] != '\0') {
8aec002f
DK
400 char const* archend = arch;
401 for (; isspace(*archend) == 0 && *archend != '\0'; ++archend);
dd7233af
DK
402 string a(arch, (archend - arch));
403 if (std::find(archs.begin(), archs.end(), a) == archs.end())
404 archs.push_back(a);
8aec002f
DK
405 }
406 arch = strtok(NULL, " ");
407 }
408 }
b9ed63d3 409 fclose(dpkg);
8aec002f 410 }
b9ed63d3 411 ExecWait(dpkgMultiArch, "dpkg --print-foreign-architectures", true);
8aec002f
DK
412 return archs;
413 }
414
5dd4c8b8
DK
415 if (archs.empty() == true ||
416 std::find(archs.begin(), archs.end(), arch) == archs.end())
bd9d81e3 417 archs.insert(archs.begin(), arch);
3152f4aa
DK
418
419 // erase duplicates and empty strings
420 for (std::vector<string>::reverse_iterator a = archs.rbegin();
421 a != archs.rend(); ++a) {
422 if (a->empty() == true || std::find(a + 1, archs.rend(), *a) != archs.rend())
423 archs.erase(a.base()-1);
424 if (a == archs.rend())
425 break;
426 }
427
5dd4c8b8
DK
428 return archs;
429}
430 /*}}}*/
431// checkArchitecture - are we interested in the given Architecture? /*{{{*/
432bool const Configuration::checkArchitecture(std::string const &Arch) {
433 if (Arch == "all")
434 return true;
435 std::vector<std::string> const archs = getArchitectures(true);
436 return (std::find(archs.begin(), archs.end(), Arch) != archs.end());
437}
438 /*}}}*/
03bef784
DK
439// setDefaultConfigurationForCompressors /*{{{*/
440void Configuration::setDefaultConfigurationForCompressors() {
441 // Set default application paths to check for optional compression types
03bef784 442 _config->CndSet("Dir::Bin::bzip2", "/bin/bzip2");
2024154c
DK
443 _config->CndSet("Dir::Bin::xz", "/usr/bin/xz");
444 if (FileExists(_config->FindFile("Dir::Bin::xz")) == true) {
8bcbc694 445 _config->Clear("Dir::Bin::lzma");
2024154c
DK
446 _config->Set("APT::Compressor::lzma::Binary", "xz");
447 if (_config->Exists("APT::Compressor::lzma::CompressArg") == false) {
448 _config->Set("APT::Compressor::lzma::CompressArg::", "--format=lzma");
449 _config->Set("APT::Compressor::lzma::CompressArg::", "-9");
450 }
451 if (_config->Exists("APT::Compressor::lzma::UncompressArg") == false) {
452 _config->Set("APT::Compressor::lzma::UncompressArg::", "--format=lzma");
453 _config->Set("APT::Compressor::lzma::UncompressArg::", "-d");
454 }
455 } else {
456 _config->CndSet("Dir::Bin::lzma", "/usr/bin/lzma");
457 if (_config->Exists("APT::Compressor::lzma::CompressArg") == false) {
458 _config->Set("APT::Compressor::lzma::CompressArg::", "--suffix=");
459 _config->Set("APT::Compressor::lzma::CompressArg::", "-9");
460 }
461 if (_config->Exists("APT::Compressor::lzma::UncompressArg") == false) {
462 _config->Set("APT::Compressor::lzma::UncompressArg::", "--suffix=");
463 _config->Set("APT::Compressor::lzma::UncompressArg::", "-d");
464 }
465 }
03bef784
DK
466}
467 /*}}}*/
468// getCompressors - Return Vector of usbale compressors /*{{{*/
469// ---------------------------------------------------------------------
470/* return a vector of compressors used by apt-ftparchive in the
471 multicompress functionality or to detect data.tar files */
472std::vector<APT::Configuration::Compressor>
473const Configuration::getCompressors(bool const Cached) {
474 static std::vector<APT::Configuration::Compressor> compressors;
475 if (compressors.empty() == false) {
476 if (Cached == true)
477 return compressors;
478 else
479 compressors.clear();
480 }
481
482 setDefaultConfigurationForCompressors();
483
e29d7e3e 484 compressors.push_back(Compressor(".", "", "", NULL, NULL, 1));
03bef784
DK
485 if (_config->Exists("Dir::Bin::gzip") == false || FileExists(_config->FindFile("Dir::Bin::gzip")) == true)
486 compressors.push_back(Compressor("gzip",".gz","gzip","-9n","-d",2));
8dd623db
DK
487#ifdef HAVE_ZLIB
488 else
e29d7e3e 489 compressors.push_back(Compressor("gzip",".gz","false", NULL, NULL, 2));
8dd623db 490#endif
03bef784
DK
491 if (_config->Exists("Dir::Bin::bzip2") == false || FileExists(_config->FindFile("Dir::Bin::bzip2")) == true)
492 compressors.push_back(Compressor("bzip2",".bz2","bzip2","-9","-d",3));
c4997486
DK
493#ifdef HAVE_BZ2
494 else
e29d7e3e 495 compressors.push_back(Compressor("bzip2",".bz2","false", NULL, NULL, 3));
c4997486 496#endif
03bef784 497 if (_config->Exists("Dir::Bin::xz") == false || FileExists(_config->FindFile("Dir::Bin::xz")) == true)
2024154c
DK
498 compressors.push_back(Compressor("xz",".xz","xz","-6","-d",4));
499 if (_config->Exists("Dir::Bin::lzma") == false || FileExists(_config->FindFile("Dir::Bin::lzma")) == true)
500 compressors.push_back(Compressor("lzma",".lzma","lzma","-9","-d",5));
03bef784
DK
501
502 std::vector<std::string> const comp = _config->FindVector("APT::Compressor");
503 for (std::vector<std::string>::const_iterator c = comp.begin();
504 c != comp.end(); ++c) {
505 if (*c == "." || *c == "gzip" || *c == "bzip2" || *c == "lzma" || *c == "xz")
506 continue;
507 compressors.push_back(Compressor(c->c_str(), std::string(".").append(*c).c_str(), c->c_str(), "-9", "-d", 100));
508 }
509
510 return compressors;
511}
512 /*}}}*/
b0e1a43f
DK
513// getCompressorExtensions - supported data.tar extensions /*{{{*/
514// ---------------------------------------------------------------------
515/* */
516std::vector<std::string> const Configuration::getCompressorExtensions() {
517 std::vector<APT::Configuration::Compressor> const compressors = getCompressors();
518 std::vector<std::string> ext;
519 for (std::vector<APT::Configuration::Compressor>::const_iterator c = compressors.begin();
520 c != compressors.end(); ++c)
521 if (c->Extension.empty() == false && c->Extension != ".")
522 ext.push_back(c->Extension);
523 return ext;
524}
525 /*}}}*/
03bef784
DK
526// Compressor constructor /*{{{*/
527// ---------------------------------------------------------------------
528/* */
529Configuration::Compressor::Compressor(char const *name, char const *extension,
530 char const *binary,
531 char const *compressArg, char const *uncompressArg,
532 unsigned short const cost) {
2024154c 533 std::string const config = std::string("APT::Compressor::").append(name).append("::");
03bef784
DK
534 Name = _config->Find(std::string(config).append("Name"), name);
535 Extension = _config->Find(std::string(config).append("Extension"), extension);
536 Binary = _config->Find(std::string(config).append("Binary"), binary);
537 Cost = _config->FindI(std::string(config).append("Cost"), cost);
538 std::string const compConf = std::string(config).append("CompressArg");
539 if (_config->Exists(compConf) == true)
540 CompressArgs = _config->FindVector(compConf);
541 else if (compressArg != NULL)
542 CompressArgs.push_back(compressArg);
543 std::string const uncompConf = std::string(config).append("UncompressArg");
544 if (_config->Exists(uncompConf) == true)
545 UncompressArgs = _config->FindVector(uncompConf);
546 else if (uncompressArg != NULL)
547 UncompressArgs.push_back(uncompressArg);
548}
549 /*}}}*/
e878aedb 550}