1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
|
// -*- mode: cpp; mode: fold -*-
// Description /*{{{*/
// $Id: apt-config.cc,v 1.11 2003/01/11 07:18:44 jgg Exp $
/* ######################################################################
APT Config - Program to manipulate APT configuration files
This program will parse a config file and then do something with it.
Commands:
shell - Shell mode. After this a series of word pairs should occur.
The first is the environment var to set and the second is
the key to set it from. Use like:
eval `apt-config shell QMode apt::QMode`
##################################################################### */
/*}}}*/
// Include Files /*{{{*/
#include<config.h>
#include <apt-pkg/cmndline.h>
#include <apt-pkg/error.h>
#include <apt-pkg/init.h>
#include <apt-pkg/strutl.h>
#include <apt-pkg/configuration.h>
#include <apt-pkg/aptconfiguration.h>
#include <apt-pkg/pkgsystem.h>
#include <locale.h>
#include <iostream>
#include <string>
#include <vector>
#include <apt-private/private-cmndline.h>
#include <apti18n.h>
/*}}}*/
using namespace std;
// DoShell - Handle the shell command /*{{{*/
// ---------------------------------------------------------------------
/* */
bool DoShell(CommandLine &CmdL)
{
for (const char **I = CmdL.FileList + 1; *I != 0; I += 2)
{
if (I[1] == 0 || strlen(I[1]) == 0)
return _error->Error(_("Arguments not in pairs"));
string key = I[1];
if (key.end()[-1] == '/') // old directory format
key.append("d");
if (_config->ExistsAny(key.c_str()))
cout << *I << "='" <<
SubstVar(_config->FindAny(key.c_str()),"'","'\\''") << '\'' << endl;
}
return true;
}
/*}}}*/
// DoDump - Dump the configuration space /*{{{*/
// ---------------------------------------------------------------------
/* */
bool DoDump(CommandLine &CmdL)
{
bool const empty = _config->FindB("APT::Config::Dump::EmptyValue", true);
std::string const format = _config->Find("APT::Config::Dump::Format", "%f \"%v\";\n");
if (CmdL.FileSize() == 1)
_config->Dump(cout, NULL, format.c_str(), empty);
else
for (const char **I = CmdL.FileList + 1; *I != 0; ++I)
_config->Dump(cout, *I, format.c_str(), empty);
return true;
}
/*}}}*/
// ShowHelp - Show the help screen /*{{{*/
// ---------------------------------------------------------------------
/* */
bool ShowHelp(CommandLine &CmdL)
{
ioprintf(cout,_("%s %s for %s compiled on %s %s\n"),PACKAGE,PACKAGE_VERSION,
COMMON_ARCH,__DATE__,__TIME__);
if (_config->FindB("version") == true)
return true;
cout <<
_("Usage: apt-config [options] command\n"
"\n"
"apt-config is a simple tool to read the APT config file\n"
"\n"
"Commands:\n"
" shell - Shell mode\n"
" dump - Show the configuration\n"
"\n"
"Options:\n"
" -h This help text.\n"
" -c=? Read this configuration file\n"
" -o=? Set an arbitrary configuration option, eg -o dir::cache=/tmp\n");
return true;
}
/*}}}*/
int main(int argc,const char *argv[]) /*{{{*/
{
CommandLine::Dispatch Cmds[] = {{"shell",&DoShell},
{"dump",&DoDump},
{"help",&ShowHelp},
{0,0}};
std::vector<CommandLine::Args> Args = getCommandArgs("apt-cdrom", CommandLine::GetCommand(Cmds, argc, argv));
// Set up gettext support
setlocale(LC_ALL,"");
textdomain(PACKAGE);
// Parse the command line and initialize the package library
CommandLine CmdL(Args.data(),_config);
if (pkgInitConfig(*_config) == false ||
CmdL.Parse(argc,argv) == false ||
pkgInitSystem(*_config,_system) == false)
{
_error->DumpErrors();
return 100;
}
// See if the help should be shown
if (_config->FindB("help") == true ||
CmdL.FileSize() == 0)
return ShowHelp(CmdL);
std::vector<std::string> const langs = APT::Configuration::getLanguages(true);
_config->Clear("Acquire::Languages");
for (std::vector<std::string>::const_iterator l = langs.begin(); l != langs.end(); ++l)
_config->Set("Acquire::Languages::", *l);
std::vector<std::string> const archs = APT::Configuration::getArchitectures();
_config->Clear("APT::Architectures");
for (std::vector<std::string>::const_iterator a = archs.begin(); a != archs.end(); ++a)
_config->Set("APT::Architectures::", *a);
std::vector<APT::Configuration::Compressor> const compressors = APT::Configuration::getCompressors();
_config->Clear("APT::Compressor");
string conf = "APT::Compressor::";
for (std::vector<APT::Configuration::Compressor>::const_iterator c = compressors.begin(); c != compressors.end(); ++c)
{
string comp = conf + c->Name + "::";
_config->Set(comp + "Name", c->Name);
_config->Set(comp + "Extension", c->Extension);
_config->Set(comp + "Binary", c->Binary);
_config->Set(std::string(comp + "Cost").c_str(), c->Cost);
for (std::vector<std::string>::const_iterator a = c->CompressArgs.begin(); a != c->CompressArgs.end(); ++a)
_config->Set(comp + "CompressArg::", *a);
for (std::vector<std::string>::const_iterator a = c->UncompressArgs.begin(); a != c->UncompressArgs.end(); ++a)
_config->Set(comp + "UncompressArg::", *a);
}
// Match the operation
CmdL.DispatchArg(Cmds);
// Print any errors or warnings found during parsing
if (_error->empty() == false)
{
bool Errors = _error->PendingError();
_error->DumpErrors();
return Errors == true?100:0;
}
return 0;
}
/*}}}*/
|
