Line data Source code
1 : /* gpgconf-comp.c - Configuration utility for GnuPG.
2 : * Copyright (C) 2004, 2007, 2008, 2009, 2010,
3 : * 2011 Free Software Foundation, Inc.
4 : *
5 : * This file is part of GnuPG.
6 : *
7 : * GnuPG is free software; you can redistribute it and/or modify it
8 : * under the terms of the GNU General Public License as published by
9 : * the Free Software Foundation; either version 3 of the License, or
10 : * (at your option) any later version.
11 : *
12 : * GnuPG is distributed in the hope that it will be useful, but
13 : * WITHOUT ANY WARRANTY; without even the implied warranty of
14 : * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 : * General Public License for more details.
16 : *
17 : * You should have received a copy of the GNU General Public License
18 : * along with GnuPG; if not, see <http://www.gnu.org/licenses/>.
19 : */
20 :
21 : #if HAVE_CONFIG_H
22 : #include <config.h>
23 : #endif
24 : #include <stdlib.h>
25 : #include <stdio.h>
26 : #include <string.h>
27 : #include <fcntl.h>
28 : #include <unistd.h>
29 : #include <sys/types.h>
30 : #include <assert.h>
31 : #include <errno.h>
32 : #include <time.h>
33 : #include <stdarg.h>
34 : #ifdef HAVE_SIGNAL_H
35 : # include <signal.h>
36 : #endif
37 : #include <ctype.h>
38 : #ifdef HAVE_W32_SYSTEM
39 : # define WIN32_LEAN_AND_MEAN 1
40 : # include <windows.h>
41 : #else
42 : # include <pwd.h>
43 : # include <grp.h>
44 : #endif
45 :
46 : /* For log_logv(), asctimestamp(), gnupg_get_time (). */
47 : #include "util.h"
48 : #include "i18n.h"
49 : #include "exechelp.h"
50 :
51 : #include "gc-opt-flags.h"
52 : #include "gpgconf.h"
53 :
54 : /* There is a problem with gpg 1.4 under Windows: --gpgconf-list
55 : returns a plain filename without escaping. As long as we have not
56 : fixed that we need to use gpg2. */
57 : #if defined(HAVE_W32_SYSTEM) && !defined(HAVE_W32CE_SYSTEM)
58 : #define GPGNAME "gpg2"
59 : #else
60 : #define GPGNAME GPG_NAME
61 : #endif
62 :
63 :
64 : /* TODO:
65 : Components: Add more components and their options.
66 : Robustness: Do more validation. Call programs to do validation for us.
67 : Add options to change backend binary path.
68 : Extract binary path for some backends from gpgsm/gpg config.
69 : */
70 :
71 :
72 : #if (__GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 5 ))
73 : void gc_error (int status, int errnum, const char *fmt, ...) \
74 : __attribute__ ((format (printf, 3, 4)));
75 : #endif
76 :
77 : /* Output a diagnostic message. If ERRNUM is not 0, then the output
78 : is followed by a colon, a white space, and the error string for the
79 : error number ERRNUM. In any case the output is finished by a
80 : newline. The message is prepended by the program name, a colon,
81 : and a whitespace. The output may be further formatted or
82 : redirected by the jnlib logging facility. */
83 : void
84 0 : gc_error (int status, int errnum, const char *fmt, ...)
85 : {
86 : va_list arg_ptr;
87 :
88 0 : va_start (arg_ptr, fmt);
89 0 : log_logv (GPGRT_LOG_ERROR, fmt, arg_ptr);
90 0 : va_end (arg_ptr);
91 :
92 0 : if (errnum)
93 0 : log_printf (": %s\n", strerror (errnum));
94 : else
95 0 : log_printf ("\n");
96 :
97 0 : if (status)
98 : {
99 0 : log_printf (NULL);
100 0 : log_printf ("fatal error (exit status %i)\n", status);
101 0 : exit (status);
102 : }
103 0 : }
104 :
105 :
106 : /* Forward declaration. */
107 : static void gpg_agent_runtime_change (int killflag);
108 : static void scdaemon_runtime_change (int killflag);
109 : static void dirmngr_runtime_change (int killflag);
110 :
111 : /* Backend configuration. Backends are used to decide how the default
112 : and current value of an option can be determined, and how the
113 : option can be changed. To every option in every component belongs
114 : exactly one backend that controls and determines the option. Some
115 : backends are programs from the GPG system. Others might be
116 : implemented by GPGConf itself. If you change this enum, don't
117 : forget to update GC_BACKEND below. */
118 : typedef enum
119 : {
120 : /* Any backend, used for find_option (). */
121 : GC_BACKEND_ANY,
122 :
123 : /* The Gnu Privacy Guard. */
124 : GC_BACKEND_GPG,
125 :
126 : /* The Gnu Privacy Guard for S/MIME. */
127 : GC_BACKEND_GPGSM,
128 :
129 : /* The GPG Agent. */
130 : GC_BACKEND_GPG_AGENT,
131 :
132 : /* The GnuPG SCDaemon. */
133 : GC_BACKEND_SCDAEMON,
134 :
135 : /* The GnuPG directory manager. */
136 : GC_BACKEND_DIRMNGR,
137 :
138 : /* The LDAP server list file for the director manager. */
139 : GC_BACKEND_DIRMNGR_LDAP_SERVER_LIST,
140 :
141 : /* The Pinentry (not a part of GnuPG, proper). */
142 : GC_BACKEND_PINENTRY,
143 :
144 : /* The number of the above entries. */
145 : GC_BACKEND_NR
146 : } gc_backend_t;
147 :
148 :
149 : /* To be able to implement generic algorithms for the various
150 : backends, we collect all information about them in this struct. */
151 : static struct
152 : {
153 : /* The name of the backend. */
154 : const char *name;
155 :
156 : /* The name of the program that acts as the backend. Some backends
157 : don't have an associated program, but are implemented directly by
158 : GPGConf. In this case, PROGRAM is NULL. */
159 : char *program;
160 :
161 : /* The module name (GNUPG_MODULE_NAME_foo) as defined by
162 : ../common/util.h. This value is used to get the actual installed
163 : path of the program. 0 is used if no backend program is
164 : available. */
165 : char module_name;
166 :
167 : /* The runtime change callback. If KILLFLAG is true the component
168 : is killed and not just reloaded. */
169 : void (*runtime_change) (int killflag);
170 :
171 : /* The option name for the configuration filename of this backend.
172 : This must be an absolute filename. It can be an option from a
173 : different backend (but then ordering of the options might
174 : matter). Note: This must be unique among all components. */
175 : const char *option_config_filename;
176 :
177 : /* If this is a file backend rather than a program backend, then
178 : this is the name of the option associated with the file. */
179 : const char *option_name;
180 : } gc_backend[GC_BACKEND_NR] =
181 : {
182 : { NULL }, /* GC_BACKEND_ANY dummy entry. */
183 : { GPG_DISP_NAME, GPGNAME, GNUPG_MODULE_NAME_GPG,
184 : NULL, GPGCONF_NAME "-" GPG_NAME ".conf" },
185 : { GPGSM_DISP_NAME, GPGSM_NAME, GNUPG_MODULE_NAME_GPGSM,
186 : NULL, GPGCONF_NAME "-" GPGSM_NAME ".conf" },
187 : { GPG_AGENT_DISP_NAME, GPG_AGENT_NAME, GNUPG_MODULE_NAME_AGENT,
188 : gpg_agent_runtime_change, GPGCONF_NAME"-" GPG_AGENT_NAME ".conf" },
189 : { SCDAEMON_DISP_NAME, SCDAEMON_NAME, GNUPG_MODULE_NAME_SCDAEMON,
190 : scdaemon_runtime_change, GPGCONF_NAME"-" SCDAEMON_NAME ".conf" },
191 : { DIRMNGR_DISP_NAME, DIRMNGR_NAME, GNUPG_MODULE_NAME_DIRMNGR,
192 : dirmngr_runtime_change, GPGCONF_NAME "-" DIRMNGR_NAME ".conf" },
193 : { DIRMNGR_DISP_NAME " LDAP Server List", NULL, 0,
194 : NULL, "ldapserverlist-file", "LDAP Server" },
195 : { "Pinentry", "pinentry", GNUPG_MODULE_NAME_PINENTRY,
196 : NULL, GPGCONF_NAME "-pinentry.conf" },
197 : };
198 :
199 :
200 : /* Option configuration. */
201 :
202 : /* An option might take an argument, or not. Argument types can be
203 : basic or complex. Basic types are generic and easy to validate.
204 : Complex types provide more specific information about the intended
205 : use, but can be difficult to validate. If you add to this enum,
206 : don't forget to update GC_ARG_TYPE below. YOU MUST NOT CHANGE THE
207 : NUMBERS OF THE EXISTING ENTRIES, AS THEY ARE PART OF THE EXTERNAL
208 : INTERFACE. */
209 : typedef enum
210 : {
211 : /* Basic argument types. */
212 :
213 : /* No argument. */
214 : GC_ARG_TYPE_NONE = 0,
215 :
216 : /* A String argument. */
217 : GC_ARG_TYPE_STRING = 1,
218 :
219 : /* A signed integer argument. */
220 : GC_ARG_TYPE_INT32 = 2,
221 :
222 : /* An unsigned integer argument. */
223 : GC_ARG_TYPE_UINT32 = 3,
224 :
225 : /* ADD NEW BASIC TYPE ENTRIES HERE. */
226 :
227 : /* Complex argument types. */
228 :
229 : /* A complete filename. */
230 : GC_ARG_TYPE_FILENAME = 32,
231 :
232 : /* An LDAP server in the format
233 : HOSTNAME:PORT:USERNAME:PASSWORD:BASE_DN. */
234 : GC_ARG_TYPE_LDAP_SERVER = 33,
235 :
236 : /* A 40 character fingerprint. */
237 : GC_ARG_TYPE_KEY_FPR = 34,
238 :
239 : /* A user ID or key ID or fingerprint for a certificate. */
240 : GC_ARG_TYPE_PUB_KEY = 35,
241 :
242 : /* A user ID or key ID or fingerprint for a certificate with a key. */
243 : GC_ARG_TYPE_SEC_KEY = 36,
244 :
245 : /* A alias list made up of a key, an equal sign and a space
246 : separated list of values. */
247 : GC_ARG_TYPE_ALIAS_LIST = 37,
248 :
249 : /* ADD NEW COMPLEX TYPE ENTRIES HERE. */
250 :
251 : /* The number of the above entries. */
252 : GC_ARG_TYPE_NR
253 : } gc_arg_type_t;
254 :
255 :
256 : /* For every argument, we record some information about it in the
257 : following struct. */
258 : static struct
259 : {
260 : /* For every argument type exists a basic argument type that can be
261 : used as a fallback for input and validation purposes. */
262 : gc_arg_type_t fallback;
263 :
264 : /* Human-readable name of the type. */
265 : const char *name;
266 : } gc_arg_type[GC_ARG_TYPE_NR] =
267 : {
268 : /* The basic argument types have their own types as fallback. */
269 : { GC_ARG_TYPE_NONE, "none" },
270 : { GC_ARG_TYPE_STRING, "string" },
271 : { GC_ARG_TYPE_INT32, "int32" },
272 : { GC_ARG_TYPE_UINT32, "uint32" },
273 :
274 : /* Reserved basic type entries for future extension. */
275 : { GC_ARG_TYPE_NR, NULL }, { GC_ARG_TYPE_NR, NULL },
276 : { GC_ARG_TYPE_NR, NULL }, { GC_ARG_TYPE_NR, NULL },
277 : { GC_ARG_TYPE_NR, NULL }, { GC_ARG_TYPE_NR, NULL },
278 : { GC_ARG_TYPE_NR, NULL }, { GC_ARG_TYPE_NR, NULL },
279 : { GC_ARG_TYPE_NR, NULL }, { GC_ARG_TYPE_NR, NULL },
280 : { GC_ARG_TYPE_NR, NULL }, { GC_ARG_TYPE_NR, NULL },
281 : { GC_ARG_TYPE_NR, NULL }, { GC_ARG_TYPE_NR, NULL },
282 : { GC_ARG_TYPE_NR, NULL }, { GC_ARG_TYPE_NR, NULL },
283 : { GC_ARG_TYPE_NR, NULL }, { GC_ARG_TYPE_NR, NULL },
284 : { GC_ARG_TYPE_NR, NULL }, { GC_ARG_TYPE_NR, NULL },
285 : { GC_ARG_TYPE_NR, NULL }, { GC_ARG_TYPE_NR, NULL },
286 : { GC_ARG_TYPE_NR, NULL }, { GC_ARG_TYPE_NR, NULL },
287 : { GC_ARG_TYPE_NR, NULL }, { GC_ARG_TYPE_NR, NULL },
288 : { GC_ARG_TYPE_NR, NULL }, { GC_ARG_TYPE_NR, NULL },
289 :
290 : /* The complex argument types have a basic type as fallback. */
291 : { GC_ARG_TYPE_STRING, "filename" },
292 : { GC_ARG_TYPE_STRING, "ldap server" },
293 : { GC_ARG_TYPE_STRING, "key fpr" },
294 : { GC_ARG_TYPE_STRING, "pub key" },
295 : { GC_ARG_TYPE_STRING, "sec key" },
296 : { GC_ARG_TYPE_STRING, "alias list" },
297 : };
298 :
299 :
300 : /* Every option has an associated expert level, than can be used to
301 : hide advanced and expert options from beginners. If you add to
302 : this list, don't forget to update GC_LEVEL below. YOU MUST NOT
303 : CHANGE THE NUMBERS OF THE EXISTING ENTRIES, AS THEY ARE PART OF THE
304 : EXTERNAL INTERFACE. */
305 : typedef enum
306 : {
307 : /* The basic options should always be displayed. */
308 : GC_LEVEL_BASIC,
309 :
310 : /* The advanced options may be hidden from beginners. */
311 : GC_LEVEL_ADVANCED,
312 :
313 : /* The expert options should only be displayed to experts. */
314 : GC_LEVEL_EXPERT,
315 :
316 : /* The invisible options should normally never be displayed. */
317 : GC_LEVEL_INVISIBLE,
318 :
319 : /* The internal options are never exported, they mark options that
320 : are recorded for internal use only. */
321 : GC_LEVEL_INTERNAL,
322 :
323 : /* ADD NEW ENTRIES HERE. */
324 :
325 : /* The number of the above entries. */
326 : GC_LEVEL_NR
327 : } gc_expert_level_t;
328 :
329 : /* A description for each expert level. */
330 : static struct
331 : {
332 : const char *name;
333 : } gc_level[] =
334 : {
335 : { "basic" },
336 : { "advanced" },
337 : { "expert" },
338 : { "invisible" },
339 : { "internal" }
340 : };
341 :
342 :
343 : /* Option flags. The flags which are used by the backends are defined
344 : by gc-opt-flags.h, included above.
345 :
346 : YOU MUST NOT CHANGE THE NUMBERS OF THE EXISTING FLAGS, AS THEY ARE
347 : PART OF THE EXTERNAL INTERFACE. */
348 :
349 : /* Some entries in the option list are not options, but mark the
350 : beginning of a new group of options. These entries have the GROUP
351 : flag set. */
352 : #define GC_OPT_FLAG_GROUP (1UL << 0)
353 : /* The ARG_OPT flag for an option indicates that the argument is
354 : optional. This is never set for GC_ARG_TYPE_NONE options. */
355 : #define GC_OPT_FLAG_ARG_OPT (1UL << 1)
356 : /* The LIST flag for an option indicates that the option can occur
357 : several times. A comma separated list of arguments is used as the
358 : argument value. */
359 : #define GC_OPT_FLAG_LIST (1UL << 2)
360 :
361 :
362 : /* A human-readable description for each flag. */
363 : static struct
364 : {
365 : const char *name;
366 : } gc_flag[] =
367 : {
368 : { "group" },
369 : { "optional arg" },
370 : { "list" },
371 : { "runtime" },
372 : { "default" },
373 : { "default desc" },
374 : { "no arg desc" },
375 : { "no change" }
376 : };
377 :
378 :
379 : /* To each option, or group marker, the information in the GC_OPTION
380 : struct is provided. If you change this, don't forget to update the
381 : option list of each component. */
382 : struct gc_option
383 : {
384 : /* If this is NULL, then this is a terminator in an array of unknown
385 : length. Otherwise, if this entry is a group marker (see FLAGS),
386 : then this is the name of the group described by this entry.
387 : Otherwise it is the name of the option described by this
388 : entry. The name must not contain a colon. */
389 : const char *name;
390 :
391 : /* The option flags. If the GROUP flag is set, then this entry is a
392 : group marker, not an option, and only the fields LEVEL,
393 : DESC_DOMAIN and DESC are valid. In all other cases, this entry
394 : describes a new option and all fields are valid. */
395 : unsigned long flags;
396 :
397 : /* The expert level. This field is valid for options and groups. A
398 : group has the expert level of the lowest-level option in the
399 : group. */
400 : gc_expert_level_t level;
401 :
402 : /* A gettext domain in which the following description can be found.
403 : If this is NULL, then DESC is not translated. Valid for groups
404 : and options.
405 :
406 : Note that we try to keep the description of groups within the
407 : gnupg domain.
408 :
409 : IMPORTANT: If you add a new domain please make sure to add a code
410 : set switching call to the function my_dgettext further below. */
411 : const char *desc_domain;
412 :
413 : /* A gettext description for this group or option. If it starts
414 : with a '|', then the string up to the next '|' describes the
415 : argument, and the description follows the second '|'.
416 :
417 : In general enclosing these description in N_() is not required
418 : because the description should be identical to the one in the
419 : help menu of the respective program. */
420 : const char *desc;
421 :
422 : /* The following fields are only valid for options. */
423 :
424 : /* The type of the option argument. */
425 : gc_arg_type_t arg_type;
426 :
427 : /* The backend that implements this option. */
428 : gc_backend_t backend;
429 :
430 : /* The following fields are set to NULL at startup (because all
431 : option's are declared as static variables). They are at the end
432 : of the list so that they can be omitted from the option
433 : declarations. */
434 :
435 : /* This is true if the option is supported by this version of the
436 : backend. */
437 : int active;
438 :
439 : /* The default value for this option. This is NULL if the option is
440 : not present in the backend, the empty string if no default is
441 : available, and otherwise a quoted string. */
442 : char *default_value;
443 :
444 : /* The default argument is only valid if the "optional arg" flag is
445 : set, and specifies the default argument (value) that is used if
446 : the argument is omitted. */
447 : char *default_arg;
448 :
449 : /* The current value of this option. */
450 : char *value;
451 :
452 : /* The new flags for this option. The only defined flag is actually
453 : GC_OPT_FLAG_DEFAULT, and it means that the option should be
454 : deleted. In this case, NEW_VALUE is NULL. */
455 : unsigned long new_flags;
456 :
457 : /* The new value of this option. */
458 : char *new_value;
459 : };
460 : typedef struct gc_option gc_option_t;
461 :
462 : /* Use this macro to terminate an option list. */
463 : #define GC_OPTION_NULL { NULL }
464 :
465 :
466 : #ifndef BUILD_WITH_AGENT
467 : #define gc_options_gpg_agent NULL
468 : #else
469 : /* The options of the GC_COMPONENT_GPG_AGENT component. */
470 : static gc_option_t gc_options_gpg_agent[] =
471 : {
472 : /* The configuration file to which we write the changes. */
473 : { GPGCONF_NAME"-" GPG_AGENT_NAME ".conf",
474 : GC_OPT_FLAG_NONE, GC_LEVEL_INTERNAL,
475 : NULL, NULL, GC_ARG_TYPE_FILENAME, GC_BACKEND_GPG_AGENT },
476 :
477 : { "Monitor",
478 : GC_OPT_FLAG_GROUP, GC_LEVEL_BASIC,
479 : "gnupg", N_("Options controlling the diagnostic output") },
480 : { "verbose", GC_OPT_FLAG_LIST|GC_OPT_FLAG_RUNTIME, GC_LEVEL_BASIC,
481 : "gnupg", "verbose",
482 : GC_ARG_TYPE_NONE, GC_BACKEND_GPG_AGENT },
483 : { "quiet", GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME, GC_LEVEL_BASIC,
484 : "gnupg", "be somewhat more quiet",
485 : GC_ARG_TYPE_NONE, GC_BACKEND_GPG_AGENT },
486 : { "no-greeting", GC_OPT_FLAG_NONE, GC_LEVEL_INVISIBLE,
487 : NULL, NULL,
488 : GC_ARG_TYPE_NONE, GC_BACKEND_GPG_AGENT },
489 :
490 : { "Configuration",
491 : GC_OPT_FLAG_GROUP, GC_LEVEL_BASIC,
492 : "gnupg", N_("Options controlling the configuration") },
493 : { "options", GC_OPT_FLAG_NONE, GC_LEVEL_EXPERT,
494 : "gnupg", "|FILE|read options from FILE",
495 : GC_ARG_TYPE_FILENAME, GC_BACKEND_GPG_AGENT },
496 : { "disable-scdaemon", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED,
497 : "gnupg", "do not use the SCdaemon",
498 : GC_ARG_TYPE_NONE, GC_BACKEND_GPG_AGENT },
499 : { "enable-ssh-support", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC,
500 : "gnupg", "enable ssh support",
501 : GC_ARG_TYPE_NONE, GC_BACKEND_GPG_AGENT },
502 : { "enable-putty-support", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC,
503 : "gnupg", "enable putty support",
504 : GC_ARG_TYPE_NONE, GC_BACKEND_GPG_AGENT },
505 :
506 : { "Debug",
507 : GC_OPT_FLAG_GROUP, GC_LEVEL_ADVANCED,
508 : "gnupg", N_("Options useful for debugging") },
509 : { "debug-level", GC_OPT_FLAG_ARG_OPT|GC_OPT_FLAG_RUNTIME, GC_LEVEL_ADVANCED,
510 : "gnupg", "|LEVEL|set the debugging level to LEVEL",
511 : GC_ARG_TYPE_STRING, GC_BACKEND_GPG_AGENT },
512 : { "log-file", GC_OPT_FLAG_RUNTIME, GC_LEVEL_ADVANCED,
513 : "gnupg", N_("|FILE|write server mode logs to FILE"),
514 : GC_ARG_TYPE_FILENAME, GC_BACKEND_GPG_AGENT },
515 : { "faked-system-time", GC_OPT_FLAG_NONE, GC_LEVEL_INVISIBLE,
516 : NULL, NULL,
517 : GC_ARG_TYPE_UINT32, GC_BACKEND_GPG_AGENT },
518 :
519 : { "Security",
520 : GC_OPT_FLAG_GROUP, GC_LEVEL_BASIC,
521 : "gnupg", N_("Options controlling the security") },
522 : { "default-cache-ttl", GC_OPT_FLAG_RUNTIME,
523 : GC_LEVEL_BASIC, "gnupg",
524 : "|N|expire cached PINs after N seconds",
525 : GC_ARG_TYPE_UINT32, GC_BACKEND_GPG_AGENT },
526 : { "default-cache-ttl-ssh", GC_OPT_FLAG_RUNTIME,
527 : GC_LEVEL_ADVANCED, "gnupg",
528 : N_("|N|expire SSH keys after N seconds"),
529 : GC_ARG_TYPE_UINT32, GC_BACKEND_GPG_AGENT },
530 : { "max-cache-ttl", GC_OPT_FLAG_RUNTIME,
531 : GC_LEVEL_EXPERT, "gnupg",
532 : N_("|N|set maximum PIN cache lifetime to N seconds"),
533 : GC_ARG_TYPE_UINT32, GC_BACKEND_GPG_AGENT },
534 : { "max-cache-ttl-ssh", GC_OPT_FLAG_RUNTIME,
535 : GC_LEVEL_EXPERT, "gnupg",
536 : N_("|N|set maximum SSH key lifetime to N seconds"),
537 : GC_ARG_TYPE_UINT32, GC_BACKEND_GPG_AGENT },
538 : { "ignore-cache-for-signing", GC_OPT_FLAG_RUNTIME,
539 : GC_LEVEL_BASIC, "gnupg", "do not use the PIN cache when signing",
540 : GC_ARG_TYPE_NONE, GC_BACKEND_GPG_AGENT },
541 : { "allow-emacs-pinentry", GC_OPT_FLAG_RUNTIME,
542 : GC_LEVEL_ADVANCED,
543 : "gnupg", "allow passphrase to be prompted through Emacs",
544 : GC_ARG_TYPE_NONE, GC_BACKEND_GPG_AGENT },
545 : { "no-allow-external-cache", GC_OPT_FLAG_RUNTIME,
546 : GC_LEVEL_BASIC, "gnupg", "disallow the use of an external password cache",
547 : GC_ARG_TYPE_NONE, GC_BACKEND_GPG_AGENT },
548 : { "no-allow-mark-trusted", GC_OPT_FLAG_RUNTIME,
549 : GC_LEVEL_ADVANCED, "gnupg", "disallow clients to mark keys as \"trusted\"",
550 : GC_ARG_TYPE_NONE, GC_BACKEND_GPG_AGENT },
551 : { "no-allow-loopback-pinentry", GC_OPT_FLAG_RUNTIME,
552 : GC_LEVEL_EXPERT, "gnupg", "disallow caller to override the pinentry",
553 : GC_ARG_TYPE_NONE, GC_BACKEND_GPG_AGENT },
554 : { "no-grab", GC_OPT_FLAG_RUNTIME, GC_LEVEL_EXPERT,
555 : "gnupg", "do not grab keyboard and mouse",
556 : GC_ARG_TYPE_NONE, GC_BACKEND_GPG_AGENT },
557 :
558 : { "Passphrase policy",
559 : GC_OPT_FLAG_GROUP, GC_LEVEL_ADVANCED,
560 : "gnupg", N_("Options enforcing a passphrase policy") },
561 : { "enforce-passphrase-constraints", GC_OPT_FLAG_RUNTIME,
562 : GC_LEVEL_EXPERT, "gnupg",
563 : N_("do not allow bypassing the passphrase policy"),
564 : GC_ARG_TYPE_NONE, GC_BACKEND_GPG_AGENT },
565 : { "min-passphrase-len", GC_OPT_FLAG_RUNTIME,
566 : GC_LEVEL_ADVANCED, "gnupg",
567 : N_("|N|set minimal required length for new passphrases to N"),
568 : GC_ARG_TYPE_UINT32, GC_BACKEND_GPG_AGENT },
569 : { "min-passphrase-nonalpha", GC_OPT_FLAG_RUNTIME,
570 : GC_LEVEL_EXPERT, "gnupg",
571 : N_("|N|require at least N non-alpha characters for a new passphrase"),
572 : GC_ARG_TYPE_UINT32, GC_BACKEND_GPG_AGENT },
573 : { "check-passphrase-pattern", GC_OPT_FLAG_RUNTIME,
574 : GC_LEVEL_EXPERT,
575 : "gnupg", N_("|FILE|check new passphrases against pattern in FILE"),
576 : GC_ARG_TYPE_FILENAME, GC_BACKEND_GPG_AGENT },
577 : { "max-passphrase-days", GC_OPT_FLAG_RUNTIME,
578 : GC_LEVEL_EXPERT, "gnupg",
579 : N_("|N|expire the passphrase after N days"),
580 : GC_ARG_TYPE_UINT32, GC_BACKEND_GPG_AGENT },
581 : { "enable-passphrase-history", GC_OPT_FLAG_RUNTIME,
582 : GC_LEVEL_EXPERT, "gnupg",
583 : N_("do not allow the reuse of old passphrases"),
584 : GC_ARG_TYPE_NONE, GC_BACKEND_GPG_AGENT },
585 : { "pinentry-timeout", GC_OPT_FLAG_RUNTIME,
586 : GC_LEVEL_ADVANCED, "gnupg",
587 : N_("|N|set the Pinentry timeout to N seconds"),
588 : GC_ARG_TYPE_UINT32, GC_BACKEND_GPG_AGENT },
589 :
590 : GC_OPTION_NULL
591 : };
592 : #endif /*BUILD_WITH_AGENT*/
593 :
594 :
595 : #ifndef BUILD_WITH_SCDAEMON
596 : #define gc_options_scdaemon NULL
597 : #else
598 : /* The options of the GC_COMPONENT_SCDAEMON component. */
599 : static gc_option_t gc_options_scdaemon[] =
600 : {
601 : /* The configuration file to which we write the changes. */
602 : { GPGCONF_NAME"-"SCDAEMON_NAME".conf",
603 : GC_OPT_FLAG_NONE, GC_LEVEL_INTERNAL,
604 : NULL, NULL, GC_ARG_TYPE_FILENAME, GC_BACKEND_SCDAEMON },
605 :
606 : { "Monitor",
607 : GC_OPT_FLAG_GROUP, GC_LEVEL_BASIC,
608 : "gnupg", N_("Options controlling the diagnostic output") },
609 : { "verbose", GC_OPT_FLAG_LIST|GC_OPT_FLAG_RUNTIME, GC_LEVEL_BASIC,
610 : "gnupg", "verbose",
611 : GC_ARG_TYPE_NONE, GC_BACKEND_SCDAEMON },
612 : { "quiet", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC,
613 : "gnupg", "be somewhat more quiet",
614 : GC_ARG_TYPE_NONE, GC_BACKEND_SCDAEMON },
615 : { "no-greeting", GC_OPT_FLAG_NONE, GC_LEVEL_INVISIBLE,
616 : NULL, NULL,
617 : GC_ARG_TYPE_NONE, GC_BACKEND_SCDAEMON },
618 :
619 : { "Configuration",
620 : GC_OPT_FLAG_GROUP, GC_LEVEL_EXPERT,
621 : "gnupg", N_("Options controlling the configuration") },
622 : { "options", GC_OPT_FLAG_NONE, GC_LEVEL_EXPERT,
623 : "gnupg", "|FILE|read options from FILE",
624 : GC_ARG_TYPE_FILENAME, GC_BACKEND_SCDAEMON },
625 : { "reader-port", GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME, GC_LEVEL_BASIC,
626 : "gnupg", "|N|connect to reader at port N",
627 : GC_ARG_TYPE_STRING, GC_BACKEND_SCDAEMON },
628 : { "ctapi-driver", GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME, GC_LEVEL_ADVANCED,
629 : "gnupg", "|NAME|use NAME as ct-API driver",
630 : GC_ARG_TYPE_STRING, GC_BACKEND_SCDAEMON },
631 : { "pcsc-driver", GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME, GC_LEVEL_ADVANCED,
632 : "gnupg", "|NAME|use NAME as PC/SC driver",
633 : GC_ARG_TYPE_STRING, GC_BACKEND_SCDAEMON },
634 : { "disable-ccid", GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME, GC_LEVEL_EXPERT,
635 : "gnupg", "do not use the internal CCID driver",
636 : GC_ARG_TYPE_NONE, GC_BACKEND_SCDAEMON },
637 : { "disable-pinpad", GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME, GC_LEVEL_BASIC,
638 : "gnupg", "do not use a reader's pinpad",
639 : GC_ARG_TYPE_NONE, GC_BACKEND_SCDAEMON },
640 : { "enable-pinpad-varlen",
641 : GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME, GC_LEVEL_BASIC,
642 : "gnupg", "use variable length input for pinpad",
643 : GC_ARG_TYPE_NONE, GC_BACKEND_SCDAEMON },
644 : { "card-timeout", GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME, GC_LEVEL_BASIC,
645 : "gnupg", "|N|disconnect the card after N seconds of inactivity",
646 : GC_ARG_TYPE_UINT32, GC_BACKEND_SCDAEMON },
647 :
648 : { "Debug",
649 : GC_OPT_FLAG_GROUP, GC_LEVEL_ADVANCED,
650 : "gnupg", N_("Options useful for debugging") },
651 : { "debug-level", GC_OPT_FLAG_ARG_OPT|GC_OPT_FLAG_RUNTIME, GC_LEVEL_ADVANCED,
652 : "gnupg", "|LEVEL|set the debugging level to LEVEL",
653 : GC_ARG_TYPE_STRING, GC_BACKEND_SCDAEMON },
654 : { "log-file", GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME, GC_LEVEL_ADVANCED,
655 : "gnupg", N_("|FILE|write a log to FILE"),
656 : GC_ARG_TYPE_FILENAME, GC_BACKEND_SCDAEMON },
657 :
658 : { "Security",
659 : GC_OPT_FLAG_GROUP, GC_LEVEL_BASIC,
660 : "gnupg", N_("Options controlling the security") },
661 : { "deny-admin", GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME, GC_LEVEL_BASIC,
662 : "gnupg", "deny the use of admin card commands",
663 : GC_ARG_TYPE_NONE, GC_BACKEND_SCDAEMON },
664 :
665 :
666 : GC_OPTION_NULL
667 : };
668 : #endif /*BUILD_WITH_SCDAEMON*/
669 :
670 : #ifndef BUILD_WITH_GPG
671 : #define gc_options_gpg NULL
672 : #else
673 : /* The options of the GC_COMPONENT_GPG component. */
674 : static gc_option_t gc_options_gpg[] =
675 : {
676 : /* The configuration file to which we write the changes. */
677 : { GPGCONF_NAME"-"GPG_NAME".conf",
678 : GC_OPT_FLAG_NONE, GC_LEVEL_INTERNAL,
679 : NULL, NULL, GC_ARG_TYPE_FILENAME, GC_BACKEND_GPG },
680 :
681 : { "Monitor",
682 : GC_OPT_FLAG_GROUP, GC_LEVEL_BASIC,
683 : "gnupg", N_("Options controlling the diagnostic output") },
684 : { "verbose", GC_OPT_FLAG_LIST, GC_LEVEL_BASIC,
685 : "gnupg", "verbose",
686 : GC_ARG_TYPE_NONE, GC_BACKEND_GPG },
687 : { "quiet", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC,
688 : "gnupg", "be somewhat more quiet",
689 : GC_ARG_TYPE_NONE, GC_BACKEND_GPG },
690 : { "no-greeting", GC_OPT_FLAG_NONE, GC_LEVEL_INVISIBLE,
691 : NULL, NULL,
692 : GC_ARG_TYPE_NONE, GC_BACKEND_GPG },
693 :
694 : { "Configuration",
695 : GC_OPT_FLAG_GROUP, GC_LEVEL_EXPERT,
696 : "gnupg", N_("Options controlling the configuration") },
697 : { "default-key", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC,
698 : "gnupg", N_("|NAME|use NAME as default secret key"),
699 : GC_ARG_TYPE_STRING, GC_BACKEND_GPG },
700 : { "encrypt-to", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC,
701 : "gnupg", N_("|NAME|encrypt to user ID NAME as well"),
702 : GC_ARG_TYPE_STRING, GC_BACKEND_GPG },
703 : { "group", GC_OPT_FLAG_LIST, GC_LEVEL_ADVANCED,
704 : "gnupg", N_("|SPEC|set up email aliases"),
705 : GC_ARG_TYPE_ALIAS_LIST, GC_BACKEND_GPG },
706 : { "options", GC_OPT_FLAG_NONE, GC_LEVEL_EXPERT,
707 : "gnupg", "|FILE|read options from FILE",
708 : GC_ARG_TYPE_FILENAME, GC_BACKEND_GPG },
709 : { "default_pubkey_algo",
710 : (GC_OPT_FLAG_ARG_OPT|GC_OPT_FLAG_NO_CHANGE), GC_LEVEL_INVISIBLE,
711 : NULL, NULL,
712 : GC_ARG_TYPE_STRING, GC_BACKEND_GPG },
713 :
714 :
715 : { "Debug",
716 : GC_OPT_FLAG_GROUP, GC_LEVEL_ADVANCED,
717 : "gnupg", N_("Options useful for debugging") },
718 : { "debug-level", GC_OPT_FLAG_ARG_OPT, GC_LEVEL_ADVANCED,
719 : "gnupg", "|LEVEL|set the debugging level to LEVEL",
720 : GC_ARG_TYPE_STRING, GC_BACKEND_GPG },
721 : { "log-file", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED,
722 : "gnupg", N_("|FILE|write server mode logs to FILE"),
723 : GC_ARG_TYPE_FILENAME, GC_BACKEND_GPG },
724 : /* { "faked-system-time", GC_OPT_FLAG_NONE, GC_LEVEL_INVISIBLE, */
725 : /* NULL, NULL, */
726 : /* GC_ARG_TYPE_UINT32, GC_BACKEND_GPG }, */
727 :
728 : { "Keyserver",
729 : GC_OPT_FLAG_GROUP, GC_LEVEL_BASIC,
730 : "gnupg", N_("Configuration for Keyservers") },
731 : { "keyserver", GC_OPT_FLAG_NONE, GC_LEVEL_EXPERT,
732 : "gnupg", N_("|URL|use keyserver at URL"), /* Deprecated - use dirmngr */
733 : GC_ARG_TYPE_STRING, GC_BACKEND_GPG },
734 : { "allow-pka-lookup", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC,
735 : "gnupg", N_("allow PKA lookups (DNS requests)"),
736 : GC_ARG_TYPE_NONE, GC_BACKEND_GPG },
737 : { "auto-key-locate", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED,
738 : "gnupg", N_("|MECHANISMS|use MECHANISMS to locate keys by mail address"),
739 : GC_ARG_TYPE_STRING, GC_BACKEND_GPG },
740 :
741 :
742 : GC_OPTION_NULL
743 : };
744 : #endif /*BUILD_WITH_GPG*/
745 :
746 :
747 : #ifndef BUILD_WITH_GPGSM
748 : #define gc_options_gpgsm NULL
749 : #else
750 : /* The options of the GC_COMPONENT_GPGSM component. */
751 : static gc_option_t gc_options_gpgsm[] =
752 : {
753 : /* The configuration file to which we write the changes. */
754 : { GPGCONF_NAME"-"GPGSM_NAME".conf",
755 : GC_OPT_FLAG_NONE, GC_LEVEL_INTERNAL,
756 : NULL, NULL, GC_ARG_TYPE_FILENAME, GC_BACKEND_GPGSM },
757 :
758 : { "Monitor",
759 : GC_OPT_FLAG_GROUP, GC_LEVEL_BASIC,
760 : "gnupg", N_("Options controlling the diagnostic output") },
761 : { "verbose", GC_OPT_FLAG_LIST, GC_LEVEL_BASIC,
762 : "gnupg", "verbose",
763 : GC_ARG_TYPE_NONE, GC_BACKEND_GPGSM },
764 : { "quiet", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC,
765 : "gnupg", "be somewhat more quiet",
766 : GC_ARG_TYPE_NONE, GC_BACKEND_GPGSM },
767 : { "no-greeting", GC_OPT_FLAG_NONE, GC_LEVEL_INVISIBLE,
768 : NULL, NULL,
769 : GC_ARG_TYPE_NONE, GC_BACKEND_GPGSM },
770 :
771 : { "Configuration",
772 : GC_OPT_FLAG_GROUP, GC_LEVEL_EXPERT,
773 : "gnupg", N_("Options controlling the configuration") },
774 : { "default-key", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC,
775 : "gnupg", N_("|NAME|use NAME as default secret key"),
776 : GC_ARG_TYPE_STRING, GC_BACKEND_GPGSM },
777 : { "encrypt-to", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC,
778 : "gnupg", N_("|NAME|encrypt to user ID NAME as well"),
779 : GC_ARG_TYPE_STRING, GC_BACKEND_GPGSM },
780 : { "options", GC_OPT_FLAG_NONE, GC_LEVEL_EXPERT,
781 : "gnupg", "|FILE|read options from FILE",
782 : GC_ARG_TYPE_FILENAME, GC_BACKEND_GPGSM },
783 : { "prefer-system-dirmngr", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED,
784 : "gnupg", "use system's dirmngr if available",
785 : GC_ARG_TYPE_NONE, GC_BACKEND_GPGSM },
786 : { "disable-dirmngr", GC_OPT_FLAG_NONE, GC_LEVEL_EXPERT,
787 : "gnupg", N_("disable all access to the dirmngr"),
788 : GC_ARG_TYPE_NONE, GC_BACKEND_GPGSM },
789 : { "p12-charset", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED,
790 : "gnupg", N_("|NAME|use encoding NAME for PKCS#12 passphrases"),
791 : GC_ARG_TYPE_STRING, GC_BACKEND_GPGSM },
792 : { "keyserver", GC_OPT_FLAG_LIST, GC_LEVEL_BASIC,
793 : "gnupg", N_("|SPEC|use this keyserver to lookup keys"),
794 : GC_ARG_TYPE_LDAP_SERVER, GC_BACKEND_GPGSM },
795 : { "default_pubkey_algo",
796 : (GC_OPT_FLAG_ARG_OPT|GC_OPT_FLAG_NO_CHANGE), GC_LEVEL_INVISIBLE,
797 : NULL, NULL,
798 : GC_ARG_TYPE_STRING, GC_BACKEND_GPGSM },
799 :
800 : { "Debug",
801 : GC_OPT_FLAG_GROUP, GC_LEVEL_ADVANCED,
802 : "gnupg", N_("Options useful for debugging") },
803 : { "debug-level", GC_OPT_FLAG_ARG_OPT, GC_LEVEL_ADVANCED,
804 : "gnupg", "|LEVEL|set the debugging level to LEVEL",
805 : GC_ARG_TYPE_STRING, GC_BACKEND_GPGSM },
806 : { "log-file", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED,
807 : "gnupg", N_("|FILE|write server mode logs to FILE"),
808 : GC_ARG_TYPE_FILENAME, GC_BACKEND_GPGSM },
809 : { "faked-system-time", GC_OPT_FLAG_NONE, GC_LEVEL_INVISIBLE,
810 : NULL, NULL,
811 : GC_ARG_TYPE_UINT32, GC_BACKEND_GPGSM },
812 :
813 : { "Security",
814 : GC_OPT_FLAG_GROUP, GC_LEVEL_BASIC,
815 : "gnupg", N_("Options controlling the security") },
816 : { "disable-crl-checks", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC,
817 : "gnupg", "never consult a CRL",
818 : GC_ARG_TYPE_NONE, GC_BACKEND_GPGSM },
819 : { "disable-trusted-cert-crl-check", GC_OPT_FLAG_NONE, GC_LEVEL_EXPERT,
820 : "gnupg", N_("do not check CRLs for root certificates"),
821 : GC_ARG_TYPE_NONE, GC_BACKEND_GPGSM },
822 : { "enable-ocsp", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED,
823 : "gnupg", "check validity using OCSP",
824 : GC_ARG_TYPE_NONE, GC_BACKEND_GPGSM },
825 : { "include-certs", GC_OPT_FLAG_NONE, GC_LEVEL_EXPERT,
826 : "gnupg", "|N|number of certificates to include",
827 : GC_ARG_TYPE_INT32, GC_BACKEND_GPGSM },
828 : { "disable-policy-checks", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED,
829 : "gnupg", "do not check certificate policies",
830 : GC_ARG_TYPE_NONE, GC_BACKEND_GPGSM },
831 : { "auto-issuer-key-retrieve", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC,
832 : "gnupg", "fetch missing issuer certificates",
833 : GC_ARG_TYPE_NONE, GC_BACKEND_GPGSM },
834 : { "cipher-algo", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED,
835 : "gnupg", "|NAME|use cipher algorithm NAME",
836 : GC_ARG_TYPE_STRING, GC_BACKEND_GPGSM },
837 :
838 : GC_OPTION_NULL
839 : };
840 : #endif /*BUILD_WITH_GPGSM*/
841 :
842 :
843 : #ifndef BUILD_WITH_DIRMNGR
844 : #define gc_options_dirmngr NULL
845 : #else
846 : /* The options of the GC_COMPONENT_DIRMNGR component. */
847 : static gc_option_t gc_options_dirmngr[] =
848 : {
849 : /* The configuration file to which we write the changes. */
850 : { GPGCONF_NAME"-"DIRMNGR_NAME".conf",
851 : GC_OPT_FLAG_NONE, GC_LEVEL_INTERNAL,
852 : NULL, NULL, GC_ARG_TYPE_FILENAME, GC_BACKEND_DIRMNGR },
853 :
854 : { "Monitor",
855 : GC_OPT_FLAG_GROUP, GC_LEVEL_BASIC,
856 : "gnupg", N_("Options controlling the diagnostic output") },
857 : { "verbose", GC_OPT_FLAG_LIST, GC_LEVEL_BASIC,
858 : "dirmngr", "verbose",
859 : GC_ARG_TYPE_NONE, GC_BACKEND_DIRMNGR },
860 : { "quiet", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC,
861 : "dirmngr", "be somewhat more quiet",
862 : GC_ARG_TYPE_NONE, GC_BACKEND_DIRMNGR },
863 : { "no-greeting", GC_OPT_FLAG_NONE, GC_LEVEL_INVISIBLE,
864 : NULL, NULL,
865 : GC_ARG_TYPE_NONE, GC_BACKEND_DIRMNGR },
866 :
867 : { "Format",
868 : GC_OPT_FLAG_GROUP, GC_LEVEL_BASIC,
869 : "gnupg", N_("Options controlling the format of the output") },
870 : { "sh", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC,
871 : "dirmngr", "sh-style command output",
872 : GC_ARG_TYPE_NONE, GC_BACKEND_DIRMNGR },
873 : { "csh", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC,
874 : "dirmngr", "csh-style command output",
875 : GC_ARG_TYPE_NONE, GC_BACKEND_DIRMNGR },
876 :
877 : { "Configuration",
878 : GC_OPT_FLAG_GROUP, GC_LEVEL_EXPERT,
879 : "gnupg", N_("Options controlling the configuration") },
880 : { "options", GC_OPT_FLAG_NONE, GC_LEVEL_EXPERT,
881 : "dirmngr", "|FILE|read options from FILE",
882 : GC_ARG_TYPE_FILENAME, GC_BACKEND_DIRMNGR },
883 :
884 : { "Debug",
885 : GC_OPT_FLAG_GROUP, GC_LEVEL_ADVANCED,
886 : "gnupg", N_("Options useful for debugging") },
887 : { "debug-level", GC_OPT_FLAG_ARG_OPT, GC_LEVEL_ADVANCED,
888 : "dirmngr", "|LEVEL|set the debugging level to LEVEL",
889 : GC_ARG_TYPE_STRING, GC_BACKEND_DIRMNGR },
890 : { "no-detach", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED,
891 : "dirmngr", "do not detach from the console",
892 : GC_ARG_TYPE_NONE, GC_BACKEND_DIRMNGR },
893 : { "log-file", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED,
894 : "dirmngr", N_("|FILE|write server mode logs to FILE"),
895 : GC_ARG_TYPE_FILENAME, GC_BACKEND_DIRMNGR },
896 : { "debug-wait", GC_OPT_FLAG_NONE, GC_LEVEL_INVISIBLE,
897 : NULL, NULL,
898 : GC_ARG_TYPE_UINT32, GC_BACKEND_DIRMNGR },
899 : { "faked-system-time", GC_OPT_FLAG_NONE, GC_LEVEL_INVISIBLE,
900 : NULL, NULL,
901 : GC_ARG_TYPE_UINT32, GC_BACKEND_DIRMNGR },
902 :
903 : { "Enforcement",
904 : GC_OPT_FLAG_GROUP, GC_LEVEL_BASIC,
905 : "gnupg", N_("Options controlling the interactivity and enforcement") },
906 : { "batch", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC,
907 : "dirmngr", "run without asking a user",
908 : GC_ARG_TYPE_NONE, GC_BACKEND_DIRMNGR },
909 : { "force", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC,
910 : "dirmngr", "force loading of outdated CRLs",
911 : GC_ARG_TYPE_NONE, GC_BACKEND_DIRMNGR },
912 :
913 : { "Tor",
914 : GC_OPT_FLAG_GROUP, GC_LEVEL_BASIC,
915 : "gnupg", N_("Options controlling the use of Tor") },
916 : { "use-tor", GC_OPT_FLAG_NONE, GC_LEVEL_INVISIBLE,
917 : "dirmngr", "route all network traffic via TOR",
918 : GC_ARG_TYPE_NONE, GC_BACKEND_DIRMNGR },
919 :
920 : { "Keyserver",
921 : GC_OPT_FLAG_GROUP, GC_LEVEL_BASIC,
922 : "gnupg", N_("Configuration for Keyservers") },
923 : { "keyserver", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC,
924 : "gnupg", N_("|URL|use keyserver at URL"),
925 : GC_ARG_TYPE_STRING, GC_BACKEND_DIRMNGR },
926 :
927 : { "HTTP",
928 : GC_OPT_FLAG_GROUP, GC_LEVEL_ADVANCED,
929 : "gnupg", N_("Configuration for HTTP servers") },
930 : { "disable-http", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED,
931 : "dirmngr", "inhibit the use of HTTP",
932 : GC_ARG_TYPE_NONE, GC_BACKEND_DIRMNGR },
933 : { "ignore-http-dp", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED,
934 : "dirmngr", "ignore HTTP CRL distribution points",
935 : GC_ARG_TYPE_NONE, GC_BACKEND_DIRMNGR },
936 : { "http-proxy", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED,
937 : "dirmngr", "|URL|redirect all HTTP requests to URL",
938 : GC_ARG_TYPE_STRING, GC_BACKEND_DIRMNGR },
939 : { "honor-http-proxy", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED,
940 : "gnupg", N_("use system's HTTP proxy setting"),
941 : GC_ARG_TYPE_NONE, GC_BACKEND_DIRMNGR },
942 :
943 : { "LDAP",
944 : GC_OPT_FLAG_GROUP, GC_LEVEL_BASIC,
945 : "gnupg", N_("Configuration of LDAP servers to use") },
946 : { "disable-ldap", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED,
947 : "dirmngr", "inhibit the use of LDAP",
948 : GC_ARG_TYPE_NONE, GC_BACKEND_DIRMNGR },
949 : { "ignore-ldap-dp", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED,
950 : "dirmngr", "ignore LDAP CRL distribution points",
951 : GC_ARG_TYPE_NONE, GC_BACKEND_DIRMNGR },
952 : { "ldap-proxy", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC,
953 : "dirmngr", "|HOST|use HOST for LDAP queries",
954 : GC_ARG_TYPE_STRING, GC_BACKEND_DIRMNGR },
955 : { "only-ldap-proxy", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED,
956 : "dirmngr", "do not use fallback hosts with --ldap-proxy",
957 : GC_ARG_TYPE_NONE, GC_BACKEND_DIRMNGR },
958 : { "add-servers", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED,
959 : "dirmngr", "add new servers discovered in CRL distribution points"
960 : " to serverlist", GC_ARG_TYPE_NONE, GC_BACKEND_DIRMNGR },
961 : { "ldaptimeout", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC,
962 : "dirmngr", "|N|set LDAP timeout to N seconds",
963 : GC_ARG_TYPE_UINT32, GC_BACKEND_DIRMNGR },
964 : /* The following entry must not be removed, as it is required for
965 : the GC_BACKEND_DIRMNGR_LDAP_SERVER_LIST. */
966 : { "ldapserverlist-file",
967 : GC_OPT_FLAG_NONE, GC_LEVEL_INTERNAL,
968 : "dirmngr", "|FILE|read LDAP server list from FILE",
969 : GC_ARG_TYPE_FILENAME, GC_BACKEND_DIRMNGR },
970 : /* This entry must come after at least one entry for
971 : GC_BACKEND_DIRMNGR in this component, so that the entry for
972 : "ldapserverlist-file will be initialized before this one. */
973 : { "LDAP Server", GC_OPT_FLAG_ARG_OPT|GC_OPT_FLAG_LIST, GC_LEVEL_BASIC,
974 : "gnupg", N_("LDAP server list"),
975 : GC_ARG_TYPE_LDAP_SERVER, GC_BACKEND_DIRMNGR_LDAP_SERVER_LIST },
976 : { "max-replies", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC,
977 : "dirmngr", "|N|do not return more than N items in one query",
978 : GC_ARG_TYPE_UINT32, GC_BACKEND_DIRMNGR },
979 :
980 : { "OCSP",
981 : GC_OPT_FLAG_GROUP, GC_LEVEL_ADVANCED,
982 : "gnupg", N_("Configuration for OCSP") },
983 : { "allow-ocsp", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC,
984 : "dirmngr", "allow sending OCSP requests",
985 : GC_ARG_TYPE_NONE, GC_BACKEND_DIRMNGR },
986 : { "ignore-ocsp-service-url", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED,
987 : "dirmngr", "ignore certificate contained OCSP service URLs",
988 : GC_ARG_TYPE_NONE, GC_BACKEND_DIRMNGR },
989 : { "ocsp-responder", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED,
990 : "dirmngr", "|URL|use OCSP responder at URL",
991 : GC_ARG_TYPE_STRING, GC_BACKEND_DIRMNGR },
992 : { "ocsp-signer", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED,
993 : "dirmngr", "|FPR|OCSP response signed by FPR",
994 : GC_ARG_TYPE_STRING, GC_BACKEND_DIRMNGR },
995 :
996 :
997 : GC_OPTION_NULL
998 : };
999 : #endif /*BUILD_WITH_DIRMNGR*/
1000 :
1001 :
1002 : /* The options of the GC_COMPONENT_PINENTRY component. */
1003 : static gc_option_t gc_options_pinentry[] =
1004 : {
1005 : /* A dummy option to allow gc_component_list_components to find the
1006 : pinentry backend. Needs to be a conf file. */
1007 : { GPGCONF_NAME"-pinentry.conf",
1008 : GC_OPT_FLAG_NONE, GC_LEVEL_INTERNAL,
1009 : NULL, NULL, GC_ARG_TYPE_FILENAME, GC_BACKEND_PINENTRY },
1010 :
1011 : GC_OPTION_NULL
1012 : };
1013 :
1014 :
1015 :
1016 : /* Component system. Each component is a set of options that can be
1017 : configured at the same time. If you change this, don't forget to
1018 : update GC_COMPONENT below. */
1019 : typedef enum
1020 : {
1021 : /* The classic GPG for OpenPGP. */
1022 : GC_COMPONENT_GPG,
1023 :
1024 : /* The GPG Agent. */
1025 : GC_COMPONENT_GPG_AGENT,
1026 :
1027 : /* The Smardcard Daemon. */
1028 : GC_COMPONENT_SCDAEMON,
1029 :
1030 : /* GPG for S/MIME. */
1031 : GC_COMPONENT_GPGSM,
1032 :
1033 : /* The LDAP Directory Manager for CRLs. */
1034 : GC_COMPONENT_DIRMNGR,
1035 :
1036 : /* The external Pinentry. */
1037 : GC_COMPONENT_PINENTRY,
1038 :
1039 : /* The number of components. */
1040 : GC_COMPONENT_NR
1041 : } gc_component_t;
1042 :
1043 :
1044 : /* The information associated with each component. */
1045 : static struct
1046 : {
1047 : /* The name of this component. Must not contain a colon (':')
1048 : character. */
1049 : const char *name;
1050 :
1051 : /* The gettext domain for the description DESC. If this is NULL,
1052 : then the description is not translated. */
1053 : const char *desc_domain;
1054 :
1055 : /* The description for this domain. */
1056 : const char *desc;
1057 :
1058 : /* The list of options for this component, terminated by
1059 : GC_OPTION_NULL. */
1060 : gc_option_t *options;
1061 : } gc_component[] =
1062 : {
1063 : { "gpg", "gnupg", N_("GPG for OpenPGP"), gc_options_gpg },
1064 : { "gpg-agent","gnupg", N_("GPG Agent"), gc_options_gpg_agent },
1065 : { "scdaemon", "gnupg", N_("Smartcard Daemon"), gc_options_scdaemon },
1066 : { "gpgsm", "gnupg", N_("GPG for S/MIME"), gc_options_gpgsm },
1067 : { "dirmngr", "gnupg", N_("Key Acquirer"), gc_options_dirmngr },
1068 : { "pinentry", "gnupg", N_("PIN and Passphrase Entry"), gc_options_pinentry }
1069 : };
1070 :
1071 :
1072 :
1073 : /* Structure used to collect error output of the backend programs. */
1074 : struct error_line_s;
1075 : typedef struct error_line_s *error_line_t;
1076 : struct error_line_s
1077 : {
1078 : error_line_t next; /* Link to next item. */
1079 : const char *fname; /* Name of the config file (points into BUFFER). */
1080 : unsigned int lineno; /* Line number of the config file. */
1081 : const char *errtext; /* Text of the error message (points into BUFFER). */
1082 : char buffer[1]; /* Helper buffer. */
1083 : };
1084 :
1085 :
1086 :
1087 : /* Engine specific support. */
1088 : static void
1089 0 : gpg_agent_runtime_change (int killflag)
1090 : {
1091 : gpg_error_t err;
1092 : const char *pgmname;
1093 : const char *argv[3];
1094 : pid_t pid;
1095 :
1096 0 : pgmname = gnupg_module_name (GNUPG_MODULE_NAME_CONNECT_AGENT);
1097 0 : argv[0] = "--no-autostart";
1098 0 : argv[1] = killflag? "KILLAGENT" : "RELOADAGENT";
1099 0 : argv[2] = NULL;
1100 :
1101 0 : err = gnupg_spawn_process_fd (pgmname, argv, -1, -1, -1, &pid);
1102 0 : if (!err)
1103 0 : err = gnupg_wait_process (pgmname, pid, 1, NULL);
1104 0 : if (err)
1105 0 : gc_error (0, 0, "error running '%s %s': %s",
1106 : pgmname, argv[1], gpg_strerror (err));
1107 0 : gnupg_release_process (pid);
1108 0 : }
1109 :
1110 :
1111 : static void
1112 0 : scdaemon_runtime_change (int killflag)
1113 : {
1114 : gpg_error_t err;
1115 : const char *pgmname;
1116 : const char *argv[7];
1117 : pid_t pid;
1118 :
1119 : (void)killflag; /* For scdaemon kill and reload are synonyms. */
1120 :
1121 : /* We use "GETINFO app_running" to see whether the agent is already
1122 : running and kill it only in this case. This avoids an explicit
1123 : starting of the agent in case it is not yet running. There is
1124 : obviously a race condition but that should not harm too much. */
1125 :
1126 0 : pgmname = gnupg_module_name (GNUPG_MODULE_NAME_CONNECT_AGENT);
1127 0 : argv[0] = "-s";
1128 0 : argv[1] = "--no-autostart";
1129 0 : argv[2] = "GETINFO scd_running";
1130 0 : argv[3] = "/if ${! $?}";
1131 0 : argv[4] = "scd killscd";
1132 0 : argv[5] = "/end";
1133 0 : argv[6] = NULL;
1134 :
1135 0 : err = gnupg_spawn_process_fd (pgmname, argv, -1, -1, -1, &pid);
1136 0 : if (!err)
1137 0 : err = gnupg_wait_process (pgmname, pid, 1, NULL);
1138 0 : if (err)
1139 0 : gc_error (0, 0, "error running '%s %s': %s",
1140 : pgmname, argv[4], gpg_strerror (err));
1141 0 : gnupg_release_process (pid);
1142 0 : }
1143 :
1144 :
1145 : static void
1146 0 : dirmngr_runtime_change (int killflag)
1147 : {
1148 : gpg_error_t err;
1149 : const char *pgmname;
1150 : const char *argv[4];
1151 : pid_t pid;
1152 :
1153 0 : pgmname = gnupg_module_name (GNUPG_MODULE_NAME_CONNECT_AGENT);
1154 0 : argv[0] = "--no-autostart";
1155 0 : argv[1] = "--dirmngr";
1156 0 : argv[2] = killflag? "KILLDIRMNGR" : "RELOADDIRMNGR";
1157 0 : argv[3] = NULL;
1158 :
1159 0 : err = gnupg_spawn_process_fd (pgmname, argv, -1, -1, -1, &pid);
1160 0 : if (!err)
1161 0 : err = gnupg_wait_process (pgmname, pid, 1, NULL);
1162 0 : if (err)
1163 0 : gc_error (0, 0, "error running '%s %s': %s",
1164 : pgmname, argv[2], gpg_strerror (err));
1165 0 : gnupg_release_process (pid);
1166 0 : }
1167 :
1168 :
1169 : /* Launch the gpg-agent or the dirmngr if not already running. */
1170 : gpg_error_t
1171 0 : gc_component_launch (int component)
1172 : {
1173 : gpg_error_t err;
1174 : const char *pgmname;
1175 : const char *argv[3];
1176 : int i;
1177 : pid_t pid;
1178 :
1179 0 : if (!(component == GC_COMPONENT_GPG_AGENT
1180 : || component == GC_COMPONENT_DIRMNGR))
1181 : {
1182 0 : es_fputs (_("Component not suitable for launching"), es_stderr);
1183 0 : es_putc ('\n', es_stderr);
1184 0 : exit (1);
1185 : }
1186 :
1187 0 : pgmname = gnupg_module_name (GNUPG_MODULE_NAME_CONNECT_AGENT);
1188 0 : i = 0;
1189 0 : if (component == GC_COMPONENT_DIRMNGR)
1190 0 : argv[i++] = "--dirmngr";
1191 0 : argv[i++] = "NOP";
1192 0 : argv[i] = NULL;
1193 :
1194 0 : err = gnupg_spawn_process_fd (pgmname, argv, -1, -1, -1, &pid);
1195 0 : if (!err)
1196 0 : err = gnupg_wait_process (pgmname, pid, 1, NULL);
1197 0 : if (err)
1198 0 : gc_error (0, 0, "error running '%s%s%s': %s",
1199 : pgmname,
1200 : component == GC_COMPONENT_DIRMNGR? " --dirmngr":"",
1201 : " NOP",
1202 : gpg_strerror (err));
1203 0 : gnupg_release_process (pid);
1204 0 : return err;
1205 : }
1206 :
1207 :
1208 : /* Unconditionally restart COMPONENT. */
1209 : void
1210 0 : gc_component_kill (int component)
1211 : {
1212 : int runtime[GC_BACKEND_NR];
1213 : gc_option_t *option;
1214 : gc_backend_t backend;
1215 :
1216 : /* Set a flag for the backends to be reloaded. */
1217 0 : for (backend = 0; backend < GC_BACKEND_NR; backend++)
1218 0 : runtime[backend] = 0;
1219 :
1220 0 : if (component >= 0)
1221 : {
1222 0 : assert (component < GC_COMPONENT_NR);
1223 0 : option = gc_component[component].options;
1224 0 : for (; option && option->name; option++)
1225 0 : runtime[option->backend] = 1;
1226 : }
1227 :
1228 : /* Do the restart for the selected backends. */
1229 0 : for (backend = 0; backend < GC_BACKEND_NR; backend++)
1230 : {
1231 0 : if (runtime[backend] && gc_backend[backend].runtime_change)
1232 0 : (*gc_backend[backend].runtime_change) (1);
1233 : }
1234 0 : }
1235 :
1236 :
1237 : /* Unconditionally reload COMPONENT or all components if COMPONENT is -1. */
1238 : void
1239 0 : gc_component_reload (int component)
1240 : {
1241 : int runtime[GC_BACKEND_NR];
1242 : gc_option_t *option;
1243 : gc_backend_t backend;
1244 :
1245 : /* Set a flag for the backends to be reloaded. */
1246 0 : for (backend = 0; backend < GC_BACKEND_NR; backend++)
1247 0 : runtime[backend] = 0;
1248 :
1249 0 : if (component == -1)
1250 : {
1251 0 : for (component = 0; component < GC_COMPONENT_NR; component++)
1252 : {
1253 0 : option = gc_component[component].options;
1254 0 : for (; option && option->name; option++)
1255 0 : runtime[option->backend] = 1;
1256 : }
1257 : }
1258 : else
1259 : {
1260 0 : assert (component < GC_COMPONENT_NR);
1261 0 : option = gc_component[component].options;
1262 0 : for (; option && option->name; option++)
1263 0 : runtime[option->backend] = 1;
1264 : }
1265 :
1266 : /* Do the reload for all selected backends. */
1267 0 : for (backend = 0; backend < GC_BACKEND_NR; backend++)
1268 : {
1269 0 : if (runtime[backend] && gc_backend[backend].runtime_change)
1270 0 : (*gc_backend[backend].runtime_change) (0);
1271 : }
1272 0 : }
1273 :
1274 :
1275 :
1276 : /* More or less Robust version of dgettext. It has the side effect of
1277 : switching the codeset to utf-8 because this is what we want to
1278 : output. In theory it is posible to keep the original code set and
1279 : switch back for regular disgnostic output (redefine "_(" for that)
1280 : but given the natur of this tool, being something invoked from
1281 : other pograms, it does not make much sense. */
1282 : static const char *
1283 0 : my_dgettext (const char *domain, const char *msgid)
1284 : {
1285 : #ifdef USE_SIMPLE_GETTEXT
1286 : if (domain)
1287 : {
1288 : static int switched_codeset;
1289 : char *text;
1290 :
1291 : if (!switched_codeset)
1292 : {
1293 : switched_codeset = 1;
1294 : gettext_use_utf8 (1);
1295 : }
1296 :
1297 : if (!strcmp (domain, "gnupg"))
1298 : domain = PACKAGE_GT;
1299 :
1300 : /* FIXME: we have no dgettext, thus we can't switch. */
1301 :
1302 : text = (char*)gettext (msgid);
1303 : return text ? text : msgid;
1304 : }
1305 : else
1306 : return msgid;
1307 : #elif defined(ENABLE_NLS)
1308 0 : if (domain)
1309 : {
1310 : static int switched_codeset;
1311 : char *text;
1312 :
1313 0 : if (!switched_codeset)
1314 : {
1315 0 : switched_codeset = 1;
1316 0 : bind_textdomain_codeset (PACKAGE_GT, "utf-8");
1317 :
1318 0 : bindtextdomain (DIRMNGR_NAME, LOCALEDIR);
1319 0 : bind_textdomain_codeset (DIRMNGR_NAME, "utf-8");
1320 :
1321 : }
1322 :
1323 : /* Note: This is a hack to actually use the gnupg2 domain as
1324 : long we are in a transition phase where gnupg 1.x and 1.9 may
1325 : coexist. */
1326 0 : if (!strcmp (domain, "gnupg"))
1327 0 : domain = PACKAGE_GT;
1328 :
1329 0 : text = dgettext (domain, msgid);
1330 0 : return text ? text : msgid;
1331 : }
1332 : else
1333 0 : return msgid;
1334 : #else
1335 : (void)domain;
1336 : return msgid;
1337 : #endif
1338 : }
1339 :
1340 :
1341 : /* Percent-Escape special characters. The string is valid until the
1342 : next invocation of the function. */
1343 : char *
1344 0 : gc_percent_escape (const char *src)
1345 : {
1346 : static char *esc_str;
1347 : static int esc_str_len;
1348 0 : int new_len = 3 * strlen (src) + 1;
1349 : char *dst;
1350 :
1351 0 : if (esc_str_len < new_len)
1352 : {
1353 0 : char *new_esc_str = realloc (esc_str, new_len);
1354 0 : if (!new_esc_str)
1355 0 : gc_error (1, errno, "can not escape string");
1356 0 : esc_str = new_esc_str;
1357 0 : esc_str_len = new_len;
1358 : }
1359 :
1360 0 : dst = esc_str;
1361 0 : while (*src)
1362 : {
1363 0 : if (*src == '%')
1364 : {
1365 0 : *(dst++) = '%';
1366 0 : *(dst++) = '2';
1367 0 : *(dst++) = '5';
1368 : }
1369 0 : else if (*src == ':')
1370 : {
1371 : /* The colon is used as field separator. */
1372 0 : *(dst++) = '%';
1373 0 : *(dst++) = '3';
1374 0 : *(dst++) = 'a';
1375 : }
1376 0 : else if (*src == ',')
1377 : {
1378 : /* The comma is used as list separator. */
1379 0 : *(dst++) = '%';
1380 0 : *(dst++) = '2';
1381 0 : *(dst++) = 'c';
1382 : }
1383 : else
1384 0 : *(dst++) = *(src);
1385 0 : src++;
1386 : }
1387 0 : *dst = '\0';
1388 0 : return esc_str;
1389 : }
1390 :
1391 :
1392 :
1393 : /* Percent-Deescape special characters. The string is valid until the
1394 : next invocation of the function. */
1395 : static char *
1396 0 : percent_deescape (const char *src)
1397 : {
1398 : static char *str;
1399 : static int str_len;
1400 0 : int new_len = 3 * strlen (src) + 1;
1401 : char *dst;
1402 :
1403 0 : if (str_len < new_len)
1404 : {
1405 0 : char *new_str = realloc (str, new_len);
1406 0 : if (!new_str)
1407 0 : gc_error (1, errno, "can not deescape string");
1408 0 : str = new_str;
1409 0 : str_len = new_len;
1410 : }
1411 :
1412 0 : dst = str;
1413 0 : while (*src)
1414 : {
1415 0 : if (*src == '%')
1416 : {
1417 0 : int val = hextobyte (src + 1);
1418 :
1419 0 : if (val < 0)
1420 0 : gc_error (1, 0, "malformed end of string %s", src);
1421 :
1422 0 : *(dst++) = (char) val;
1423 0 : src += 3;
1424 : }
1425 : else
1426 0 : *(dst++) = *(src++);
1427 : }
1428 0 : *dst = '\0';
1429 0 : return str;
1430 : }
1431 :
1432 :
1433 : /* List all components that are available. */
1434 : void
1435 0 : gc_component_list_components (estream_t out)
1436 : {
1437 : gc_component_t component;
1438 : gc_option_t *option;
1439 : gc_backend_t backend;
1440 : int backend_seen[GC_BACKEND_NR];
1441 : const char *desc;
1442 : const char *pgmname;
1443 :
1444 0 : for (component = 0; component < GC_COMPONENT_NR; component++)
1445 : {
1446 0 : option = gc_component[component].options;
1447 0 : if (option)
1448 : {
1449 0 : for (backend = 0; backend < GC_BACKEND_NR; backend++)
1450 0 : backend_seen[backend] = 0;
1451 :
1452 0 : pgmname = "";
1453 0 : for (; option && option->name; option++)
1454 : {
1455 0 : if ((option->flags & GC_OPT_FLAG_GROUP))
1456 0 : continue;
1457 0 : backend = option->backend;
1458 0 : if (backend_seen[backend])
1459 0 : continue;
1460 0 : backend_seen[backend] = 1;
1461 0 : assert (backend != GC_BACKEND_ANY);
1462 0 : if (gc_backend[backend].program
1463 0 : && !gc_backend[backend].module_name)
1464 0 : continue;
1465 0 : pgmname = gnupg_module_name (gc_backend[backend].module_name);
1466 0 : break;
1467 : }
1468 :
1469 0 : desc = gc_component[component].desc;
1470 0 : desc = my_dgettext (gc_component[component].desc_domain, desc);
1471 0 : es_fprintf (out, "%s:%s:",
1472 : gc_component[component].name, gc_percent_escape (desc));
1473 0 : es_fprintf (out, "%s\n", gc_percent_escape (pgmname));
1474 : }
1475 : }
1476 0 : }
1477 :
1478 :
1479 :
1480 : static int
1481 0 : all_digits_p (const char *p, size_t len)
1482 : {
1483 0 : if (!len)
1484 0 : return 0; /* No. */
1485 0 : for (; len; len--, p++)
1486 0 : if (!isascii (*p) || !isdigit (*p))
1487 0 : return 0; /* No. */
1488 0 : return 1; /* Yes. */
1489 : }
1490 :
1491 :
1492 : /* Collect all error lines from stream FP. Only lines prefixed with
1493 : TAG are considered. Returns a list of error line items (which may
1494 : be empty). There is no error return. */
1495 : static error_line_t
1496 0 : collect_error_output (estream_t fp, const char *tag)
1497 : {
1498 : char buffer[1024];
1499 : char *p, *p2, *p3;
1500 : int c, cont_line;
1501 : unsigned int pos;
1502 : error_line_t eitem, errlines, *errlines_tail;
1503 0 : size_t taglen = strlen (tag);
1504 :
1505 0 : errlines = NULL;
1506 0 : errlines_tail = &errlines;
1507 0 : pos = 0;
1508 0 : cont_line = 0;
1509 0 : while ((c=es_getc (fp)) != EOF)
1510 : {
1511 0 : buffer[pos++] = c;
1512 0 : if (pos >= sizeof buffer - 5 || c == '\n')
1513 : {
1514 0 : buffer[pos - (c == '\n')] = 0;
1515 0 : if (cont_line)
1516 : ; /*Ignore continuations of previous line. */
1517 0 : else if (!strncmp (buffer, tag, taglen) && buffer[taglen] == ':')
1518 : {
1519 : /* "gpgsm: foo:4: bla" */
1520 : /* Yep, we are interested in this line. */
1521 0 : p = buffer + taglen + 1;
1522 0 : while (*p == ' ' || *p == '\t')
1523 0 : p++;
1524 0 : trim_trailing_spaces (p); /* Get rid of extra CRs. */
1525 0 : if (!*p)
1526 : ; /* Empty lines are ignored. */
1527 0 : else if ( (p2 = strchr (p, ':')) && (p3 = strchr (p2+1, ':'))
1528 0 : && all_digits_p (p2+1, p3 - (p2+1)))
1529 : {
1530 : /* Line in standard compiler format. */
1531 0 : p3++;
1532 0 : while (*p3 == ' ' || *p3 == '\t')
1533 0 : p3++;
1534 0 : eitem = xmalloc (sizeof *eitem + strlen (p));
1535 0 : eitem->next = NULL;
1536 0 : strcpy (eitem->buffer, p);
1537 0 : eitem->fname = eitem->buffer;
1538 0 : eitem->buffer[p2-p] = 0;
1539 0 : eitem->errtext = eitem->buffer + (p3 - p);
1540 : /* (we already checked that there are only ascii
1541 : digits followed by a colon) */
1542 0 : eitem->lineno = 0;
1543 0 : for (p2++; isdigit (*p2); p2++)
1544 0 : eitem->lineno = eitem->lineno*10 + (*p2 - '0');
1545 0 : *errlines_tail = eitem;
1546 0 : errlines_tail = &eitem->next;
1547 : }
1548 : else
1549 : {
1550 : /* Other error output. */
1551 0 : eitem = xmalloc (sizeof *eitem + strlen (p));
1552 0 : eitem->next = NULL;
1553 0 : strcpy (eitem->buffer, p);
1554 0 : eitem->fname = NULL;
1555 0 : eitem->errtext = eitem->buffer;
1556 0 : eitem->lineno = 0;
1557 0 : *errlines_tail = eitem;
1558 0 : errlines_tail = &eitem->next;
1559 : }
1560 : }
1561 0 : pos = 0;
1562 : /* If this was not a complete line mark that we are in a
1563 : continuation. */
1564 0 : cont_line = (c != '\n');
1565 : }
1566 : }
1567 :
1568 : /* We ignore error lines not terminated by a LF. */
1569 0 : return errlines;
1570 : }
1571 :
1572 :
1573 : /* Check the options of a single component. Returns 0 if everything
1574 : is OK. */
1575 : int
1576 0 : gc_component_check_options (int component, estream_t out, const char *conf_file)
1577 : {
1578 : gpg_error_t err;
1579 : unsigned int result;
1580 : int backend_seen[GC_BACKEND_NR];
1581 : gc_backend_t backend;
1582 : gc_option_t *option;
1583 : const char *pgmname;
1584 : const char *argv[4];
1585 : int i;
1586 : pid_t pid;
1587 : int exitcode;
1588 : estream_t errfp;
1589 : error_line_t errlines;
1590 :
1591 0 : for (backend = 0; backend < GC_BACKEND_NR; backend++)
1592 0 : backend_seen[backend] = 0;
1593 :
1594 0 : option = gc_component[component].options;
1595 0 : for (; option && option->name; option++)
1596 : {
1597 0 : if ((option->flags & GC_OPT_FLAG_GROUP))
1598 0 : continue;
1599 0 : backend = option->backend;
1600 0 : if (backend_seen[backend])
1601 0 : continue;
1602 0 : backend_seen[backend] = 1;
1603 0 : assert (backend != GC_BACKEND_ANY);
1604 0 : if (!gc_backend[backend].program)
1605 0 : continue;
1606 0 : if (!gc_backend[backend].module_name)
1607 0 : continue;
1608 :
1609 0 : break;
1610 : }
1611 0 : if (! option || ! option->name)
1612 0 : return 0;
1613 :
1614 0 : pgmname = gnupg_module_name (gc_backend[backend].module_name);
1615 0 : i = 0;
1616 0 : if (conf_file)
1617 : {
1618 0 : argv[i++] = "--options";
1619 0 : argv[i++] = conf_file;
1620 : }
1621 0 : if (component == GC_COMPONENT_PINENTRY)
1622 0 : argv[i++] = "--version";
1623 : else
1624 0 : argv[i++] = "--gpgconf-test";
1625 0 : argv[i++] = NULL;
1626 :
1627 0 : result = 0;
1628 0 : errlines = NULL;
1629 0 : err = gnupg_spawn_process (pgmname, argv, NULL, NULL, 0,
1630 : NULL, NULL, &errfp, &pid);
1631 0 : if (err)
1632 0 : result |= 1; /* Program could not be run. */
1633 : else
1634 : {
1635 0 : errlines = collect_error_output (errfp,
1636 : gc_component[component].name);
1637 0 : if (gnupg_wait_process (pgmname, pid, 1, &exitcode))
1638 : {
1639 0 : if (exitcode == -1)
1640 0 : result |= 1; /* Program could not be run or it
1641 : terminated abnormally. */
1642 0 : result |= 2; /* Program returned an error. */
1643 : }
1644 0 : gnupg_release_process (pid);
1645 0 : es_fclose (errfp);
1646 : }
1647 :
1648 : /* If the program could not be run, we can't tell whether
1649 : the config file is good. */
1650 0 : if (result & 1)
1651 0 : result |= 2;
1652 :
1653 0 : if (out)
1654 : {
1655 : const char *desc;
1656 : error_line_t errptr;
1657 :
1658 0 : desc = gc_component[component].desc;
1659 0 : desc = my_dgettext (gc_component[component].desc_domain, desc);
1660 0 : es_fprintf (out, "%s:%s:",
1661 : gc_component[component].name, gc_percent_escape (desc));
1662 0 : es_fputs (gc_percent_escape (pgmname), out);
1663 0 : es_fprintf (out, ":%d:%d:", !(result & 1), !(result & 2));
1664 0 : for (errptr = errlines; errptr; errptr = errptr->next)
1665 : {
1666 0 : if (errptr != errlines)
1667 0 : es_fputs ("\n:::::", out); /* Continuation line. */
1668 0 : if (errptr->fname)
1669 0 : es_fputs (gc_percent_escape (errptr->fname), out);
1670 0 : es_putc (':', out);
1671 0 : if (errptr->fname)
1672 0 : es_fprintf (out, "%u", errptr->lineno);
1673 0 : es_putc (':', out);
1674 0 : es_fputs (gc_percent_escape (errptr->errtext), out);
1675 0 : es_putc (':', out);
1676 : }
1677 0 : es_putc ('\n', out);
1678 : }
1679 :
1680 0 : while (errlines)
1681 : {
1682 0 : error_line_t tmp = errlines->next;
1683 0 : xfree (errlines);
1684 0 : errlines = tmp;
1685 : }
1686 :
1687 0 : return result;
1688 : }
1689 :
1690 :
1691 :
1692 : /* Check all components that are available. */
1693 : void
1694 0 : gc_check_programs (estream_t out)
1695 : {
1696 : gc_component_t component;
1697 :
1698 0 : for (component = 0; component < GC_COMPONENT_NR; component++)
1699 0 : gc_component_check_options (component, out, NULL);
1700 0 : }
1701 :
1702 :
1703 :
1704 : /* Find the component with the name NAME. Returns -1 if not
1705 : found. */
1706 : int
1707 0 : gc_component_find (const char *name)
1708 : {
1709 : gc_component_t idx;
1710 :
1711 0 : for (idx = 0; idx < GC_COMPONENT_NR; idx++)
1712 : {
1713 0 : if (gc_component[idx].options
1714 0 : && !strcmp (name, gc_component[idx].name))
1715 0 : return idx;
1716 : }
1717 0 : return -1;
1718 : }
1719 :
1720 :
1721 : /* List the option OPTION. */
1722 : static void
1723 0 : list_one_option (const gc_option_t *option, estream_t out)
1724 : {
1725 0 : const char *desc = NULL;
1726 0 : char *arg_name = NULL;
1727 :
1728 0 : if (option->desc)
1729 : {
1730 0 : desc = my_dgettext (option->desc_domain, option->desc);
1731 :
1732 0 : if (*desc == '|')
1733 : {
1734 0 : const char *arg_tail = strchr (&desc[1], '|');
1735 :
1736 0 : if (arg_tail)
1737 : {
1738 0 : int arg_len = arg_tail - &desc[1];
1739 0 : arg_name = xmalloc (arg_len + 1);
1740 0 : memcpy (arg_name, &desc[1], arg_len);
1741 0 : arg_name[arg_len] = '\0';
1742 0 : desc = arg_tail + 1;
1743 : }
1744 : }
1745 : }
1746 :
1747 :
1748 : /* YOU MUST NOT REORDER THE FIELDS IN THIS OUTPUT, AS THEIR ORDER IS
1749 : PART OF THE EXTERNAL INTERFACE. YOU MUST NOT REMOVE ANY
1750 : FIELDS. */
1751 :
1752 : /* The name field. */
1753 0 : es_fprintf (out, "%s", option->name);
1754 :
1755 : /* The flags field. */
1756 0 : es_fprintf (out, ":%lu", option->flags);
1757 0 : if (opt.verbose)
1758 : {
1759 0 : es_putc (' ', out);
1760 :
1761 0 : if (!option->flags)
1762 0 : es_fprintf (out, "none");
1763 : else
1764 : {
1765 0 : unsigned long flags = option->flags;
1766 0 : unsigned long flag = 0;
1767 0 : unsigned long first = 1;
1768 :
1769 0 : while (flags)
1770 : {
1771 0 : if (flags & 1)
1772 : {
1773 0 : if (first)
1774 0 : first = 0;
1775 : else
1776 0 : es_putc (',', out);
1777 0 : es_fprintf (out, "%s", gc_flag[flag].name);
1778 : }
1779 0 : flags >>= 1;
1780 0 : flag++;
1781 : }
1782 : }
1783 : }
1784 :
1785 : /* The level field. */
1786 0 : es_fprintf (out, ":%u", option->level);
1787 0 : if (opt.verbose)
1788 0 : es_fprintf (out, " %s", gc_level[option->level].name);
1789 :
1790 : /* The description field. */
1791 0 : es_fprintf (out, ":%s", desc ? gc_percent_escape (desc) : "");
1792 :
1793 : /* The type field. */
1794 0 : es_fprintf (out, ":%u", option->arg_type);
1795 0 : if (opt.verbose)
1796 0 : es_fprintf (out, " %s", gc_arg_type[option->arg_type].name);
1797 :
1798 : /* The alternate type field. */
1799 0 : es_fprintf (out, ":%u", gc_arg_type[option->arg_type].fallback);
1800 0 : if (opt.verbose)
1801 0 : es_fprintf (out, " %s",
1802 0 : gc_arg_type[gc_arg_type[option->arg_type].fallback].name);
1803 :
1804 : /* The argument name field. */
1805 0 : es_fprintf (out, ":%s", arg_name ? gc_percent_escape (arg_name) : "");
1806 0 : xfree (arg_name);
1807 :
1808 : /* The default value field. */
1809 0 : es_fprintf (out, ":%s", option->default_value ? option->default_value : "");
1810 :
1811 : /* The default argument field. */
1812 0 : es_fprintf (out, ":%s", option->default_arg ? option->default_arg : "");
1813 :
1814 : /* The value field. */
1815 0 : if (gc_arg_type[option->arg_type].fallback == GC_ARG_TYPE_NONE
1816 0 : && (option->flags & GC_OPT_FLAG_LIST)
1817 0 : && option->value)
1818 : /* The special format "1,1,1,1,...,1" is converted to a number
1819 : here. */
1820 0 : es_fprintf (out, ":%u", (unsigned int)((strlen (option->value) + 1) / 2));
1821 : else
1822 0 : es_fprintf (out, ":%s", option->value ? option->value : "");
1823 :
1824 : /* ADD NEW FIELDS HERE. */
1825 :
1826 0 : es_putc ('\n', out);
1827 0 : }
1828 :
1829 :
1830 : /* List all options of the component COMPONENT. */
1831 : void
1832 0 : gc_component_list_options (int component, estream_t out)
1833 : {
1834 0 : const gc_option_t *option = gc_component[component].options;
1835 :
1836 0 : while (option && option->name)
1837 : {
1838 : /* Do not output unknown or internal options. */
1839 0 : if (!(option->flags & GC_OPT_FLAG_GROUP)
1840 0 : && (!option->active || option->level == GC_LEVEL_INTERNAL))
1841 : {
1842 0 : option++;
1843 0 : continue;
1844 : }
1845 :
1846 0 : if (option->flags & GC_OPT_FLAG_GROUP)
1847 : {
1848 0 : const gc_option_t *group_option = option + 1;
1849 0 : gc_expert_level_t level = GC_LEVEL_NR;
1850 :
1851 : /* The manual states that the group level is always the
1852 : minimum of the levels of all contained options. Due to
1853 : different active options, and because it is hard to
1854 : maintain manually, we calculate it here. The value in
1855 : the global static table is ignored. */
1856 :
1857 0 : while (group_option->name)
1858 : {
1859 0 : if (group_option->flags & GC_OPT_FLAG_GROUP)
1860 0 : break;
1861 0 : if (group_option->level < level)
1862 0 : level = group_option->level;
1863 0 : group_option++;
1864 : }
1865 :
1866 : /* Check if group is empty. */
1867 0 : if (level != GC_LEVEL_NR)
1868 : {
1869 : gc_option_t opt_copy;
1870 :
1871 : /* Fix up the group level. */
1872 0 : memcpy (&opt_copy, option, sizeof (opt_copy));
1873 0 : opt_copy.level = level;
1874 0 : list_one_option (&opt_copy, out);
1875 : }
1876 : }
1877 : else
1878 0 : list_one_option (option, out);
1879 :
1880 0 : option++;
1881 : }
1882 0 : }
1883 :
1884 :
1885 : /* Find the option NAME in component COMPONENT, for the backend
1886 : BACKEND. If BACKEND is GC_BACKEND_ANY, any backend will match. */
1887 : static gc_option_t *
1888 0 : find_option (gc_component_t component, const char *name,
1889 : gc_backend_t backend)
1890 : {
1891 0 : gc_option_t *option = gc_component[component].options;
1892 0 : while (option->name)
1893 : {
1894 0 : if (!(option->flags & GC_OPT_FLAG_GROUP)
1895 0 : && !strcmp (option->name, name)
1896 0 : && (backend == GC_BACKEND_ANY || option->backend == backend))
1897 : break;
1898 0 : option++;
1899 : }
1900 0 : return option->name ? option : NULL;
1901 : }
1902 :
1903 :
1904 : /* Determine the configuration filename for the component COMPONENT
1905 : and backend BACKEND. */
1906 : static char *
1907 0 : get_config_filename (gc_component_t component, gc_backend_t backend)
1908 : {
1909 0 : char *filename = NULL;
1910 0 : gc_option_t *option = find_option
1911 : (component, gc_backend[backend].option_config_filename, GC_BACKEND_ANY);
1912 0 : assert (option);
1913 0 : assert (option->arg_type == GC_ARG_TYPE_FILENAME);
1914 0 : assert (!(option->flags & GC_OPT_FLAG_LIST));
1915 :
1916 0 : if (!option->active || !option->default_value)
1917 0 : gc_error (1, 0, "Option %s, needed by backend %s, was not initialized",
1918 : gc_backend[backend].option_config_filename,
1919 : gc_backend[backend].name);
1920 :
1921 0 : if (option->value && *option->value)
1922 0 : filename = percent_deescape (&option->value[1]);
1923 0 : else if (option->default_value && *option->default_value)
1924 0 : filename = percent_deescape (&option->default_value[1]);
1925 : else
1926 0 : filename = "";
1927 :
1928 : #if HAVE_W32CE_SYSTEM
1929 : if (!(filename[0] == '/' || filename[0] == '\\'))
1930 : #elif defined(HAVE_DOSISH_SYSTEM)
1931 : if (!(filename[0]
1932 : && filename[1] == ':'
1933 : && (filename[2] == '/' || filename[2] == '\\')))
1934 : #else
1935 0 : if (filename[0] != '/')
1936 : #endif
1937 0 : gc_error (1, 0, "Option %s, needed by backend %s, is not absolute",
1938 : gc_backend[backend].option_config_filename,
1939 : gc_backend[backend].name);
1940 :
1941 0 : return filename;
1942 : }
1943 :
1944 :
1945 : /* Retrieve the options for the component COMPONENT from backend
1946 : BACKEND, which we already know is a program-type backend. */
1947 : static void
1948 0 : retrieve_options_from_program (gc_component_t component, gc_backend_t backend)
1949 : {
1950 : gpg_error_t err;
1951 : const char *pgmname;
1952 : const char *argv[2];
1953 : estream_t outfp;
1954 : int exitcode;
1955 : pid_t pid;
1956 0 : char *line = NULL;
1957 0 : size_t line_len = 0;
1958 : ssize_t length;
1959 : estream_t config;
1960 : char *config_filename;
1961 :
1962 0 : pgmname = (gc_backend[backend].module_name
1963 0 : ? gnupg_module_name (gc_backend[backend].module_name)
1964 0 : : gc_backend[backend].program );
1965 0 : argv[0] = "--gpgconf-list";
1966 0 : argv[1] = NULL;
1967 :
1968 0 : err = gnupg_spawn_process (pgmname, argv, NULL, NULL, 0,
1969 : NULL, &outfp, NULL, &pid);
1970 0 : if (err)
1971 : {
1972 0 : gc_error (1, 0, "could not gather active options from '%s': %s",
1973 : pgmname, gpg_strerror (err));
1974 : }
1975 :
1976 0 : while ((length = es_read_line (outfp, &line, &line_len, NULL)) > 0)
1977 : {
1978 : gc_option_t *option;
1979 : char *linep;
1980 0 : unsigned long flags = 0;
1981 0 : char *default_value = NULL;
1982 :
1983 : /* Strip newline and carriage return, if present. */
1984 0 : while (length > 0
1985 0 : && (line[length - 1] == '\n' || line[length - 1] == '\r'))
1986 0 : line[--length] = '\0';
1987 :
1988 0 : linep = strchr (line, ':');
1989 0 : if (linep)
1990 0 : *(linep++) = '\0';
1991 :
1992 : /* Extract additional flags. Default to none. */
1993 0 : if (linep)
1994 : {
1995 : char *end;
1996 : char *tail;
1997 :
1998 0 : end = strchr (linep, ':');
1999 0 : if (end)
2000 0 : *(end++) = '\0';
2001 :
2002 0 : gpg_err_set_errno (0);
2003 0 : flags = strtoul (linep, &tail, 0);
2004 0 : if (errno)
2005 0 : gc_error (1, errno, "malformed flags in option %s from %s",
2006 : line, pgmname);
2007 0 : if (!(*tail == '\0' || *tail == ':' || *tail == ' '))
2008 0 : gc_error (1, 0, "garbage after flags in option %s from %s",
2009 : line, pgmname);
2010 :
2011 0 : linep = end;
2012 : }
2013 :
2014 : /* Extract default value, if present. Default to empty if
2015 : not. */
2016 0 : if (linep)
2017 : {
2018 : char *end;
2019 :
2020 0 : end = strchr (linep, ':');
2021 0 : if (end)
2022 0 : *(end++) = '\0';
2023 :
2024 0 : if (flags & GC_OPT_FLAG_DEFAULT)
2025 0 : default_value = linep;
2026 :
2027 0 : linep = end;
2028 : }
2029 :
2030 : /* Look up the option in the component and install the
2031 : configuration data. */
2032 0 : option = find_option (component, line, backend);
2033 0 : if (option)
2034 : {
2035 0 : if (option->active)
2036 0 : gc_error (1, errno, "option %s returned twice from %s",
2037 : line, pgmname);
2038 0 : option->active = 1;
2039 :
2040 0 : option->flags |= flags;
2041 0 : if (default_value && *default_value)
2042 0 : option->default_value = xstrdup (default_value);
2043 : }
2044 : }
2045 0 : if (length < 0 || es_ferror (outfp))
2046 0 : gc_error (1, errno, "error reading from %s", pgmname);
2047 0 : if (es_fclose (outfp))
2048 0 : gc_error (1, errno, "error closing %s", pgmname);
2049 :
2050 0 : err = gnupg_wait_process (pgmname, pid, 1, &exitcode);
2051 0 : if (err)
2052 0 : gc_error (1, 0, "running %s failed (exitcode=%d): %s",
2053 : pgmname, exitcode, gpg_strerror (err));
2054 0 : gnupg_release_process (pid);
2055 :
2056 :
2057 : /* At this point, we can parse the configuration file. */
2058 0 : config_filename = get_config_filename (component, backend);
2059 :
2060 0 : config = es_fopen (config_filename, "r");
2061 0 : if (!config)
2062 0 : gc_error (0, errno, "warning: can not open config file %s",
2063 : config_filename);
2064 : else
2065 : {
2066 0 : while ((length = es_read_line (config, &line, &line_len, NULL)) > 0)
2067 : {
2068 : char *name;
2069 : char *value;
2070 : gc_option_t *option;
2071 :
2072 0 : name = line;
2073 0 : while (*name == ' ' || *name == '\t')
2074 0 : name++;
2075 0 : if (!*name || *name == '#' || *name == '\r' || *name == '\n')
2076 0 : continue;
2077 :
2078 0 : value = name;
2079 0 : while (*value && *value != ' ' && *value != '\t'
2080 0 : && *value != '#' && *value != '\r' && *value != '\n')
2081 0 : value++;
2082 0 : if (*value == ' ' || *value == '\t')
2083 0 : {
2084 : char *end;
2085 :
2086 0 : *(value++) = '\0';
2087 0 : while (*value == ' ' || *value == '\t')
2088 0 : value++;
2089 :
2090 0 : end = value;
2091 0 : while (*end && *end != '#' && *end != '\r' && *end != '\n')
2092 0 : end++;
2093 0 : while (end > value && (end[-1] == ' ' || end[-1] == '\t'))
2094 0 : end--;
2095 0 : *end = '\0';
2096 : }
2097 : else
2098 0 : *value = '\0';
2099 :
2100 : /* Look up the option in the component and install the
2101 : configuration data. */
2102 0 : option = find_option (component, line, backend);
2103 0 : if (option)
2104 : {
2105 : char *opt_value;
2106 :
2107 0 : if (gc_arg_type[option->arg_type].fallback == GC_ARG_TYPE_NONE)
2108 : {
2109 0 : if (*value)
2110 0 : gc_error (0, 0,
2111 : "warning: ignoring argument %s for option %s",
2112 : value, name);
2113 0 : opt_value = xstrdup ("1");
2114 : }
2115 0 : else if (gc_arg_type[option->arg_type].fallback
2116 : == GC_ARG_TYPE_STRING)
2117 0 : opt_value = xasprintf ("\"%s", gc_percent_escape (value));
2118 : else
2119 : {
2120 : /* FIXME: Verify that the number is sane. */
2121 0 : opt_value = xstrdup (value);
2122 : }
2123 :
2124 : /* Now enter the option into the table. */
2125 0 : if (!(option->flags & GC_OPT_FLAG_LIST))
2126 : {
2127 0 : if (option->value)
2128 0 : free (option->value);
2129 0 : option->value = opt_value;
2130 : }
2131 : else
2132 : {
2133 0 : if (!option->value)
2134 0 : option->value = opt_value;
2135 : else
2136 : {
2137 0 : char *opt_val = opt_value;
2138 :
2139 0 : option->value = xasprintf ("%s,%s", option->value,
2140 : opt_val);
2141 0 : xfree (opt_value);
2142 : }
2143 : }
2144 : }
2145 : }
2146 :
2147 0 : if (length < 0 || es_ferror (config))
2148 0 : gc_error (1, errno, "error reading from %s", config_filename);
2149 0 : if (es_fclose (config))
2150 0 : gc_error (1, errno, "error closing %s", config_filename);
2151 : }
2152 :
2153 0 : xfree (line);
2154 0 : }
2155 :
2156 :
2157 : /* Retrieve the options for the component COMPONENT from backend
2158 : BACKEND, which we already know is of type file list. */
2159 : static void
2160 0 : retrieve_options_from_file (gc_component_t component, gc_backend_t backend)
2161 : {
2162 : gc_option_t *list_option;
2163 : gc_option_t *config_option;
2164 : char *list_filename;
2165 : FILE *list_file;
2166 0 : char *line = NULL;
2167 0 : size_t line_len = 0;
2168 : ssize_t length;
2169 0 : char *list = NULL;
2170 :
2171 0 : list_option = find_option (component,
2172 : gc_backend[backend].option_name, GC_BACKEND_ANY);
2173 0 : assert (list_option);
2174 0 : assert (!list_option->active);
2175 :
2176 0 : list_filename = get_config_filename (component, backend);
2177 0 : list_file = fopen (list_filename, "r");
2178 0 : if (!list_file)
2179 0 : gc_error (0, errno, "warning: can not open list file %s", list_filename);
2180 : else
2181 : {
2182 :
2183 0 : while ((length = read_line (list_file, &line, &line_len, NULL)) > 0)
2184 : {
2185 : char *start;
2186 : char *end;
2187 : char *new_list;
2188 :
2189 0 : start = line;
2190 0 : while (*start == ' ' || *start == '\t')
2191 0 : start++;
2192 0 : if (!*start || *start == '#' || *start == '\r' || *start == '\n')
2193 0 : continue;
2194 :
2195 0 : end = start;
2196 0 : while (*end && *end != '#' && *end != '\r' && *end != '\n')
2197 0 : end++;
2198 : /* Walk back to skip trailing white spaces. Looks evil, but
2199 : works because of the conditions on START and END imposed
2200 : at this point (END is at least START + 1, and START is
2201 : not a whitespace character). */
2202 0 : while (*(end - 1) == ' ' || *(end - 1) == '\t')
2203 0 : end--;
2204 0 : *end = '\0';
2205 : /* FIXME: Oh, no! This is so lame! Should use realloc and
2206 : really append. */
2207 0 : if (list)
2208 : {
2209 0 : new_list = xasprintf ("%s,\"%s", list, gc_percent_escape (start));
2210 0 : xfree (list);
2211 0 : list = new_list;
2212 : }
2213 : else
2214 0 : list = xasprintf ("\"%s", gc_percent_escape (start));
2215 : }
2216 0 : if (length < 0 || ferror (list_file))
2217 0 : gc_error (1, errno, "can not read list file %s", list_filename);
2218 : }
2219 :
2220 0 : list_option->active = 1;
2221 0 : list_option->value = list;
2222 :
2223 : /* Fix up the read-only flag. */
2224 0 : config_option = find_option
2225 : (component, gc_backend[backend].option_config_filename, GC_BACKEND_ANY);
2226 0 : if (config_option->flags & GC_OPT_FLAG_NO_CHANGE)
2227 0 : list_option->flags |= GC_OPT_FLAG_NO_CHANGE;
2228 :
2229 0 : if (list_file && fclose (list_file))
2230 0 : gc_error (1, errno, "error closing %s", list_filename);
2231 0 : xfree (line);
2232 0 : }
2233 :
2234 :
2235 : /* Retrieve the currently active options and their defaults from all
2236 : involved backends for this component. Using -1 for component will
2237 : retrieve all options from all components. */
2238 : void
2239 0 : gc_component_retrieve_options (int component)
2240 : {
2241 0 : int process_all = 0;
2242 : int backend_seen[GC_BACKEND_NR];
2243 : gc_backend_t backend;
2244 : gc_option_t *option;
2245 :
2246 0 : if (component == GC_COMPONENT_PINENTRY)
2247 0 : return; /* Dummy module for now. */
2248 :
2249 0 : for (backend = 0; backend < GC_BACKEND_NR; backend++)
2250 0 : backend_seen[backend] = 0;
2251 :
2252 0 : if (component == -1)
2253 : {
2254 0 : process_all = 1;
2255 0 : component = 0;
2256 0 : assert (component < GC_COMPONENT_NR);
2257 : }
2258 :
2259 : do
2260 : {
2261 0 : option = gc_component[component].options;
2262 :
2263 0 : while (option && option->name)
2264 : {
2265 0 : if (!(option->flags & GC_OPT_FLAG_GROUP))
2266 : {
2267 0 : backend = option->backend;
2268 :
2269 0 : if (backend_seen[backend])
2270 : {
2271 0 : option++;
2272 0 : continue;
2273 : }
2274 0 : backend_seen[backend] = 1;
2275 :
2276 0 : assert (backend != GC_BACKEND_ANY);
2277 :
2278 0 : if (gc_backend[backend].program)
2279 0 : retrieve_options_from_program (component, backend);
2280 : else
2281 0 : retrieve_options_from_file (component, backend);
2282 : }
2283 0 : option++;
2284 : }
2285 : }
2286 0 : while (process_all && ++component < GC_COMPONENT_NR);
2287 :
2288 : }
2289 :
2290 :
2291 :
2292 : /* Perform a simple validity check based on the type. Return in
2293 : NEW_VALUE_NR the value of the number in NEW_VALUE if OPTION is of
2294 : type GC_ARG_TYPE_NONE. */
2295 : static void
2296 0 : option_check_validity (gc_option_t *option, unsigned long flags,
2297 : char *new_value, unsigned long *new_value_nr)
2298 : {
2299 : char *arg;
2300 :
2301 0 : if (!option->active)
2302 0 : gc_error (1, 0, "option %s not supported by backend %s",
2303 0 : option->name, gc_backend[option->backend].name);
2304 :
2305 0 : if (option->new_flags || option->new_value)
2306 0 : gc_error (1, 0, "option %s already changed", option->name);
2307 :
2308 0 : if (flags & GC_OPT_FLAG_DEFAULT)
2309 : {
2310 0 : if (*new_value)
2311 0 : gc_error (1, 0, "argument %s provided for deleted option %s",
2312 : new_value, option->name);
2313 :
2314 0 : return;
2315 : }
2316 :
2317 : /* GC_ARG_TYPE_NONE options have special list treatment. */
2318 0 : if (gc_arg_type[option->arg_type].fallback == GC_ARG_TYPE_NONE)
2319 : {
2320 : char *tail;
2321 :
2322 0 : gpg_err_set_errno (0);
2323 0 : *new_value_nr = strtoul (new_value, &tail, 0);
2324 :
2325 0 : if (errno)
2326 0 : gc_error (1, errno, "invalid argument for option %s",
2327 : option->name);
2328 0 : if (*tail)
2329 0 : gc_error (1, 0, "garbage after argument for option %s",
2330 : option->name);
2331 :
2332 0 : if (!(option->flags & GC_OPT_FLAG_LIST))
2333 : {
2334 0 : if (*new_value_nr != 1)
2335 0 : gc_error (1, 0, "argument for non-list option %s of type 0 "
2336 : "(none) must be 1", option->name);
2337 : }
2338 : else
2339 : {
2340 0 : if (*new_value_nr == 0)
2341 0 : gc_error (1, 0, "argument for option %s of type 0 (none) "
2342 : "must be positive", option->name);
2343 : }
2344 :
2345 0 : return;
2346 : }
2347 :
2348 0 : arg = new_value;
2349 : do
2350 : {
2351 0 : if (*arg == '\0' || *arg == ',')
2352 : {
2353 0 : if (!(option->flags & GC_OPT_FLAG_ARG_OPT))
2354 0 : gc_error (1, 0, "argument required for option %s", option->name);
2355 :
2356 0 : if (*arg == ',' && !(option->flags & GC_OPT_FLAG_LIST))
2357 0 : gc_error (1, 0, "list found for non-list option %s", option->name);
2358 : }
2359 0 : else if (gc_arg_type[option->arg_type].fallback == GC_ARG_TYPE_STRING)
2360 : {
2361 0 : if (*arg != '"')
2362 0 : gc_error (1, 0, "string argument for option %s must begin "
2363 : "with a quote (\") character", option->name);
2364 :
2365 : /* FIXME: We do not allow empty string arguments for now, as
2366 : we do not quote arguments in configuration files, and
2367 : thus no argument is indistinguishable from the empty
2368 : string. */
2369 0 : if (arg[1] == '\0' || arg[1] == ',')
2370 0 : gc_error (1, 0, "empty string argument for option %s is "
2371 : "currently not allowed. Please report this!",
2372 : option->name);
2373 : }
2374 0 : else if (gc_arg_type[option->arg_type].fallback == GC_ARG_TYPE_INT32)
2375 : {
2376 : long res;
2377 :
2378 0 : gpg_err_set_errno (0);
2379 0 : res = strtol (arg, &arg, 0);
2380 : (void) res;
2381 :
2382 0 : if (errno)
2383 0 : gc_error (1, errno, "invalid argument for option %s",
2384 : option->name);
2385 :
2386 0 : if (*arg != '\0' && *arg != ',')
2387 0 : gc_error (1, 0, "garbage after argument for option %s",
2388 : option->name);
2389 : }
2390 0 : else if (gc_arg_type[option->arg_type].fallback == GC_ARG_TYPE_UINT32)
2391 : {
2392 : unsigned long res;
2393 :
2394 0 : gpg_err_set_errno (0);
2395 0 : res = strtoul (arg, &arg, 0);
2396 : (void) res;
2397 :
2398 0 : if (errno)
2399 0 : gc_error (1, errno, "invalid argument for option %s",
2400 : option->name);
2401 :
2402 0 : if (*arg != '\0' && *arg != ',')
2403 0 : gc_error (1, 0, "garbage after argument for option %s",
2404 : option->name);
2405 : }
2406 0 : arg = strchr (arg, ',');
2407 0 : if (arg)
2408 0 : arg++;
2409 : }
2410 0 : while (arg && *arg);
2411 : }
2412 :
2413 : #ifdef HAVE_W32_SYSTEM
2414 : int
2415 : copy_file (const char *src_name, const char *dst_name)
2416 : {
2417 : #define BUF_LEN 4096
2418 : char buffer[BUF_LEN];
2419 : int len;
2420 : FILE *src;
2421 : FILE *dst;
2422 :
2423 : src = fopen (src_name, "r");
2424 : if (src == NULL)
2425 : return -1;
2426 :
2427 : dst = fopen (dst_name, "w");
2428 : if (dst == NULL)
2429 : {
2430 : int saved_err = errno;
2431 : fclose (src);
2432 : gpg_err_set_errno (saved_err);
2433 : return -1;
2434 : }
2435 :
2436 : do
2437 : {
2438 : int written;
2439 :
2440 : len = fread (buffer, 1, BUF_LEN, src);
2441 : if (len == 0)
2442 : break;
2443 : written = fwrite (buffer, 1, len, dst);
2444 : if (written != len)
2445 : break;
2446 : }
2447 : while (!feof (src) && !ferror (src) && !ferror (dst));
2448 :
2449 : if (ferror (src) || ferror (dst) || !feof (src))
2450 : {
2451 : int saved_errno = errno;
2452 : fclose (src);
2453 : fclose (dst);
2454 : unlink (dst_name);
2455 : gpg_err_set_errno (saved_errno);
2456 : return -1;
2457 : }
2458 :
2459 : if (fclose (dst))
2460 : gc_error (1, errno, "error closing %s", dst_name);
2461 : if (fclose (src))
2462 : gc_error (1, errno, "error closing %s", src_name);
2463 :
2464 : return 0;
2465 : }
2466 : #endif /* HAVE_W32_SYSTEM */
2467 :
2468 :
2469 : /* Create and verify the new configuration file for the specified
2470 : backend and component. Returns 0 on success and -1 on error. */
2471 : static int
2472 0 : change_options_file (gc_component_t component, gc_backend_t backend,
2473 : char **src_filenamep, char **dest_filenamep,
2474 : char **orig_filenamep)
2475 : {
2476 : static const char marker[] = "###+++--- " GPGCONF_DISP_NAME " ---+++###";
2477 : /* True if we are within the marker in the config file. */
2478 0 : int in_marker = 0;
2479 : gc_option_t *option;
2480 0 : char *line = NULL;
2481 : size_t line_len;
2482 : ssize_t length;
2483 : int res;
2484 : int fd;
2485 0 : FILE *src_file = NULL;
2486 0 : FILE *dest_file = NULL;
2487 : char *src_filename;
2488 : char *dest_filename;
2489 : char *orig_filename;
2490 : char *arg;
2491 0 : char *cur_arg = NULL;
2492 :
2493 0 : option = find_option (component,
2494 : gc_backend[backend].option_name, GC_BACKEND_ANY);
2495 0 : assert (option);
2496 0 : assert (option->active);
2497 0 : assert (gc_arg_type[option->arg_type].fallback != GC_ARG_TYPE_NONE);
2498 :
2499 : /* FIXME. Throughout the function, do better error reporting. */
2500 : /* Note that get_config_filename() calls percent_deescape(), so we
2501 : call this before processing the arguments. */
2502 0 : dest_filename = xstrdup (get_config_filename (component, backend));
2503 0 : src_filename = xasprintf ("%s.%s.%i.new",
2504 : dest_filename, GPGCONF_NAME, (int)getpid ());
2505 0 : orig_filename = xasprintf ("%s.%s.%i.bak",
2506 : dest_filename, GPGCONF_NAME, (int)getpid ());
2507 :
2508 0 : arg = option->new_value;
2509 0 : if (arg && arg[0] == '\0')
2510 0 : arg = NULL;
2511 0 : else if (arg)
2512 : {
2513 : char *end;
2514 :
2515 0 : arg++;
2516 0 : end = strchr (arg, ',');
2517 0 : if (end)
2518 0 : *end = '\0';
2519 :
2520 0 : cur_arg = percent_deescape (arg);
2521 0 : if (end)
2522 : {
2523 0 : *end = ',';
2524 0 : arg = end + 1;
2525 : }
2526 : else
2527 0 : arg = NULL;
2528 : }
2529 :
2530 : #ifdef HAVE_W32_SYSTEM
2531 : res = copy_file (dest_filename, orig_filename);
2532 : #else
2533 0 : res = link (dest_filename, orig_filename);
2534 : #endif
2535 0 : if (res < 0 && errno != ENOENT)
2536 : {
2537 0 : xfree (dest_filename);
2538 0 : return -1;
2539 : }
2540 0 : if (res < 0)
2541 : {
2542 0 : xfree (orig_filename);
2543 0 : orig_filename = NULL;
2544 : }
2545 :
2546 : /* We now initialize the return strings, so the caller can do the
2547 : cleanup for us. */
2548 0 : *src_filenamep = src_filename;
2549 0 : *dest_filenamep = dest_filename;
2550 0 : *orig_filenamep = orig_filename;
2551 :
2552 : /* Use open() so that we can use O_EXCL. */
2553 0 : fd = open (src_filename, O_CREAT | O_EXCL | O_WRONLY, 0644);
2554 0 : if (fd < 0)
2555 0 : return -1;
2556 0 : src_file = fdopen (fd, "w");
2557 0 : res = errno;
2558 0 : if (!src_file)
2559 : {
2560 0 : gpg_err_set_errno (res);
2561 0 : return -1;
2562 : }
2563 :
2564 : /* Only if ORIG_FILENAME is not NULL did the configuration file
2565 : exist already. In this case, we will copy its content into the
2566 : new configuration file, changing it to our liking in the
2567 : process. */
2568 0 : if (orig_filename)
2569 : {
2570 0 : dest_file = fopen (dest_filename, "r");
2571 0 : if (!dest_file)
2572 0 : goto change_file_one_err;
2573 :
2574 0 : while ((length = read_line (dest_file, &line, &line_len, NULL)) > 0)
2575 : {
2576 0 : int disable = 0;
2577 : char *start;
2578 :
2579 0 : if (!strncmp (marker, line, sizeof (marker) - 1))
2580 : {
2581 0 : if (!in_marker)
2582 0 : in_marker = 1;
2583 : else
2584 0 : break;
2585 : }
2586 :
2587 0 : start = line;
2588 0 : while (*start == ' ' || *start == '\t')
2589 0 : start++;
2590 0 : if (*start && *start != '\r' && *start != '\n' && *start != '#')
2591 : {
2592 : char *end;
2593 : char *endp;
2594 : char saved_end;
2595 :
2596 0 : endp = start;
2597 0 : end = endp;
2598 :
2599 : /* Search for the end of the line. */
2600 0 : while (*endp && *endp != '#' && *endp != '\r' && *endp != '\n')
2601 : {
2602 0 : endp++;
2603 0 : if (*endp && *endp != ' ' && *endp != '\t'
2604 0 : && *endp != '\r' && *endp != '\n' && *endp != '#')
2605 0 : end = endp + 1;
2606 : }
2607 0 : saved_end = *end;
2608 0 : *end = '\0';
2609 :
2610 0 : if ((option->new_flags & GC_OPT_FLAG_DEFAULT)
2611 0 : || !cur_arg || strcmp (start, cur_arg))
2612 0 : disable = 1;
2613 : else
2614 : {
2615 : /* Find next argument. */
2616 0 : if (arg)
2617 : {
2618 : char *arg_end;
2619 :
2620 0 : arg++;
2621 0 : arg_end = strchr (arg, ',');
2622 0 : if (arg_end)
2623 0 : *arg_end = '\0';
2624 :
2625 0 : cur_arg = percent_deescape (arg);
2626 0 : if (arg_end)
2627 : {
2628 0 : *arg_end = ',';
2629 0 : arg = arg_end + 1;
2630 : }
2631 : else
2632 0 : arg = NULL;
2633 : }
2634 : else
2635 0 : cur_arg = NULL;
2636 : }
2637 :
2638 0 : *end = saved_end;
2639 : }
2640 :
2641 0 : if (disable)
2642 : {
2643 0 : if (!in_marker)
2644 : {
2645 0 : fprintf (src_file,
2646 : "# %s disabled this option here at %s\n",
2647 0 : GPGCONF_DISP_NAME, asctimestamp (gnupg_get_time ()));
2648 0 : if (ferror (src_file))
2649 0 : goto change_file_one_err;
2650 0 : fprintf (src_file, "# %s", line);
2651 0 : if (ferror (src_file))
2652 0 : goto change_file_one_err;
2653 : }
2654 : }
2655 : else
2656 : {
2657 0 : fprintf (src_file, "%s", line);
2658 0 : if (ferror (src_file))
2659 0 : goto change_file_one_err;
2660 : }
2661 : }
2662 0 : if (length < 0 || ferror (dest_file))
2663 : goto change_file_one_err;
2664 : }
2665 :
2666 0 : if (!in_marker)
2667 : {
2668 : /* There was no marker. This is the first time we edit the
2669 : file. We add our own marker at the end of the file and
2670 : proceed. Note that we first write a newline, this guards us
2671 : against files which lack the newline at the end of the last
2672 : line, while it doesn't hurt us in all other cases. */
2673 0 : fprintf (src_file, "\n%s\n", marker);
2674 0 : if (ferror (src_file))
2675 0 : goto change_file_one_err;
2676 : }
2677 :
2678 : /* At this point, we have copied everything up to the end marker
2679 : into the new file, except for the arguments we are going to add.
2680 : Now, dump the new arguments and write the end marker, possibly
2681 : followed by the rest of the original file. */
2682 0 : while (cur_arg)
2683 : {
2684 0 : fprintf (src_file, "%s\n", cur_arg);
2685 :
2686 : /* Find next argument. */
2687 0 : if (arg)
2688 : {
2689 : char *end;
2690 :
2691 0 : arg++;
2692 0 : end = strchr (arg, ',');
2693 0 : if (end)
2694 0 : *end = '\0';
2695 :
2696 0 : cur_arg = percent_deescape (arg);
2697 0 : if (end)
2698 : {
2699 0 : *end = ',';
2700 0 : arg = end + 1;
2701 : }
2702 : else
2703 0 : arg = NULL;
2704 : }
2705 : else
2706 0 : cur_arg = NULL;
2707 : }
2708 :
2709 0 : fprintf (src_file, "%s %s\n", marker, asctimestamp (gnupg_get_time ()));
2710 0 : if (ferror (src_file))
2711 0 : goto change_file_one_err;
2712 :
2713 0 : if (!in_marker)
2714 : {
2715 0 : fprintf (src_file, "# %s edited this configuration file.\n",
2716 : GPGCONF_DISP_NAME);
2717 0 : if (ferror (src_file))
2718 0 : goto change_file_one_err;
2719 0 : fprintf (src_file, "# It will disable options before this marked "
2720 : "block, but it will\n");
2721 0 : if (ferror (src_file))
2722 0 : goto change_file_one_err;
2723 0 : fprintf (src_file, "# never change anything below these lines.\n");
2724 0 : if (ferror (src_file))
2725 0 : goto change_file_one_err;
2726 : }
2727 0 : if (dest_file)
2728 : {
2729 0 : while ((length = read_line (dest_file, &line, &line_len, NULL)) > 0)
2730 : {
2731 0 : fprintf (src_file, "%s", line);
2732 0 : if (ferror (src_file))
2733 0 : goto change_file_one_err;
2734 : }
2735 0 : if (length < 0 || ferror (dest_file))
2736 : goto change_file_one_err;
2737 : }
2738 0 : xfree (line);
2739 0 : line = NULL;
2740 :
2741 0 : res = fclose (src_file);
2742 0 : if (res)
2743 : {
2744 0 : res = errno;
2745 0 : close (fd);
2746 0 : if (dest_file)
2747 0 : fclose (dest_file);
2748 0 : gpg_err_set_errno (res);
2749 0 : return -1;
2750 : }
2751 0 : close (fd);
2752 0 : if (dest_file)
2753 : {
2754 0 : res = fclose (dest_file);
2755 0 : if (res)
2756 0 : return -1;
2757 : }
2758 0 : return 0;
2759 :
2760 : change_file_one_err:
2761 0 : xfree (line);
2762 0 : res = errno;
2763 0 : if (src_file)
2764 : {
2765 0 : fclose (src_file);
2766 0 : close (fd);
2767 : }
2768 0 : if (dest_file)
2769 0 : fclose (dest_file);
2770 0 : gpg_err_set_errno (res);
2771 0 : return -1;
2772 : }
2773 :
2774 :
2775 : /* Create and verify the new configuration file for the specified
2776 : backend and component. Returns 0 on success and -1 on error. */
2777 : static int
2778 0 : change_options_program (gc_component_t component, gc_backend_t backend,
2779 : char **src_filenamep, char **dest_filenamep,
2780 : char **orig_filenamep)
2781 : {
2782 : static const char marker[] = "###+++--- " GPGCONF_DISP_NAME " ---+++###";
2783 : /* True if we are within the marker in the config file. */
2784 0 : int in_marker = 0;
2785 : gc_option_t *option;
2786 0 : char *line = NULL;
2787 : size_t line_len;
2788 : ssize_t length;
2789 : int res;
2790 : int fd;
2791 0 : FILE *src_file = NULL;
2792 0 : FILE *dest_file = NULL;
2793 : char *src_filename;
2794 : char *dest_filename;
2795 : char *orig_filename;
2796 : /* Special hack for gpg, see below. */
2797 0 : int utf8strings_seen = 0;
2798 :
2799 : /* FIXME. Throughout the function, do better error reporting. */
2800 0 : dest_filename = xstrdup (get_config_filename (component, backend));
2801 0 : src_filename = xasprintf ("%s.%s.%i.new",
2802 : dest_filename, GPGCONF_NAME, (int)getpid ());
2803 0 : orig_filename = xasprintf ("%s.%s.%i.bak",
2804 : dest_filename, GPGCONF_NAME, (int)getpid ());
2805 :
2806 : #ifdef HAVE_W32_SYSTEM
2807 : res = copy_file (dest_filename, orig_filename);
2808 : #else
2809 0 : res = link (dest_filename, orig_filename);
2810 : #endif
2811 0 : if (res < 0 && errno != ENOENT)
2812 0 : return -1;
2813 0 : if (res < 0)
2814 : {
2815 0 : xfree (orig_filename);
2816 0 : orig_filename = NULL;
2817 : }
2818 :
2819 : /* We now initialize the return strings, so the caller can do the
2820 : cleanup for us. */
2821 0 : *src_filenamep = src_filename;
2822 0 : *dest_filenamep = dest_filename;
2823 0 : *orig_filenamep = orig_filename;
2824 :
2825 : /* Use open() so that we can use O_EXCL. */
2826 0 : fd = open (src_filename, O_CREAT | O_EXCL | O_WRONLY, 0644);
2827 0 : if (fd < 0)
2828 0 : return -1;
2829 0 : src_file = fdopen (fd, "w");
2830 0 : res = errno;
2831 0 : if (!src_file)
2832 : {
2833 0 : gpg_err_set_errno (res);
2834 0 : return -1;
2835 : }
2836 :
2837 : /* Only if ORIG_FILENAME is not NULL did the configuration file
2838 : exist already. In this case, we will copy its content into the
2839 : new configuration file, changing it to our liking in the
2840 : process. */
2841 0 : if (orig_filename)
2842 : {
2843 0 : dest_file = fopen (dest_filename, "r");
2844 0 : if (!dest_file)
2845 0 : goto change_one_err;
2846 :
2847 0 : while ((length = read_line (dest_file, &line, &line_len, NULL)) > 0)
2848 : {
2849 0 : int disable = 0;
2850 : char *start;
2851 :
2852 0 : if (!strncmp (marker, line, sizeof (marker) - 1))
2853 : {
2854 0 : if (!in_marker)
2855 0 : in_marker = 1;
2856 : else
2857 0 : break;
2858 : }
2859 0 : else if (backend == GC_BACKEND_GPG && in_marker
2860 0 : && ! strcmp ("utf8-strings\n", line))
2861 : {
2862 : /* Strip duplicated entries. */
2863 0 : if (utf8strings_seen)
2864 0 : disable = 1;
2865 : else
2866 0 : utf8strings_seen = 1;
2867 : }
2868 :
2869 0 : start = line;
2870 0 : while (*start == ' ' || *start == '\t')
2871 0 : start++;
2872 0 : if (*start && *start != '\r' && *start != '\n' && *start != '#')
2873 : {
2874 : char *end;
2875 : char saved_end;
2876 :
2877 0 : end = start;
2878 0 : while (*end && *end != ' ' && *end != '\t'
2879 0 : && *end != '\r' && *end != '\n' && *end != '#')
2880 0 : end++;
2881 0 : saved_end = *end;
2882 0 : *end = '\0';
2883 :
2884 0 : option = find_option (component, start, backend);
2885 0 : *end = saved_end;
2886 0 : if (option && ((option->new_flags & GC_OPT_FLAG_DEFAULT)
2887 0 : || option->new_value))
2888 0 : disable = 1;
2889 : }
2890 0 : if (disable)
2891 : {
2892 0 : if (!in_marker)
2893 : {
2894 0 : fprintf (src_file,
2895 : "# %s disabled this option here at %s\n",
2896 0 : GPGCONF_DISP_NAME, asctimestamp (gnupg_get_time ()));
2897 0 : if (ferror (src_file))
2898 0 : goto change_one_err;
2899 0 : fprintf (src_file, "# %s", line);
2900 0 : if (ferror (src_file))
2901 0 : goto change_one_err;
2902 : }
2903 : }
2904 : else
2905 : {
2906 0 : fprintf (src_file, "%s", line);
2907 0 : if (ferror (src_file))
2908 0 : goto change_one_err;
2909 : }
2910 : }
2911 0 : if (length < 0 || ferror (dest_file))
2912 : goto change_one_err;
2913 : }
2914 :
2915 0 : if (!in_marker)
2916 : {
2917 : /* There was no marker. This is the first time we edit the
2918 : file. We add our own marker at the end of the file and
2919 : proceed. Note that we first write a newline, this guards us
2920 : against files which lack the newline at the end of the last
2921 : line, while it doesn't hurt us in all other cases. */
2922 0 : fprintf (src_file, "\n%s\n", marker);
2923 0 : if (ferror (src_file))
2924 0 : goto change_one_err;
2925 : }
2926 : /* At this point, we have copied everything up to the end marker
2927 : into the new file, except for the options we are going to change.
2928 : Now, dump the changed options (except for those we are going to
2929 : revert to their default), and write the end marker, possibly
2930 : followed by the rest of the original file. */
2931 :
2932 : /* We have to turn on UTF8 strings for GnuPG. */
2933 0 : if (backend == GC_BACKEND_GPG && ! utf8strings_seen)
2934 0 : fprintf (src_file, "utf8-strings\n");
2935 :
2936 0 : option = gc_component[component].options;
2937 0 : while (option->name)
2938 : {
2939 0 : if (!(option->flags & GC_OPT_FLAG_GROUP)
2940 0 : && option->backend == backend
2941 0 : && option->new_value)
2942 : {
2943 0 : char *arg = option->new_value;
2944 :
2945 : do
2946 : {
2947 0 : if (*arg == '\0' || *arg == ',')
2948 : {
2949 0 : fprintf (src_file, "%s\n", option->name);
2950 0 : if (ferror (src_file))
2951 0 : goto change_one_err;
2952 : }
2953 0 : else if (gc_arg_type[option->arg_type].fallback
2954 : == GC_ARG_TYPE_NONE)
2955 : {
2956 0 : assert (*arg == '1');
2957 0 : fprintf (src_file, "%s\n", option->name);
2958 0 : if (ferror (src_file))
2959 0 : goto change_one_err;
2960 :
2961 0 : arg++;
2962 : }
2963 0 : else if (gc_arg_type[option->arg_type].fallback
2964 : == GC_ARG_TYPE_STRING)
2965 : {
2966 : char *end;
2967 :
2968 0 : assert (*arg == '"');
2969 0 : arg++;
2970 :
2971 0 : end = strchr (arg, ',');
2972 0 : if (end)
2973 0 : *end = '\0';
2974 :
2975 0 : fprintf (src_file, "%s %s\n", option->name,
2976 : percent_deescape (arg));
2977 0 : if (ferror (src_file))
2978 0 : goto change_one_err;
2979 :
2980 0 : if (end)
2981 0 : *end = ',';
2982 0 : arg = end;
2983 : }
2984 : else
2985 : {
2986 : char *end;
2987 :
2988 0 : end = strchr (arg, ',');
2989 0 : if (end)
2990 0 : *end = '\0';
2991 :
2992 0 : fprintf (src_file, "%s %s\n", option->name, arg);
2993 0 : if (ferror (src_file))
2994 0 : goto change_one_err;
2995 :
2996 0 : if (end)
2997 0 : *end = ',';
2998 0 : arg = end;
2999 : }
3000 :
3001 0 : assert (arg == NULL || *arg == '\0' || *arg == ',');
3002 0 : if (arg && *arg == ',')
3003 0 : arg++;
3004 : }
3005 0 : while (arg && *arg);
3006 : }
3007 0 : option++;
3008 : }
3009 :
3010 0 : fprintf (src_file, "%s %s\n", marker, asctimestamp (gnupg_get_time ()));
3011 0 : if (ferror (src_file))
3012 0 : goto change_one_err;
3013 :
3014 0 : if (!in_marker)
3015 : {
3016 0 : fprintf (src_file, "# %s edited this configuration file.\n",
3017 : GPGCONF_DISP_NAME);
3018 0 : if (ferror (src_file))
3019 0 : goto change_one_err;
3020 0 : fprintf (src_file, "# It will disable options before this marked "
3021 : "block, but it will\n");
3022 0 : if (ferror (src_file))
3023 0 : goto change_one_err;
3024 0 : fprintf (src_file, "# never change anything below these lines.\n");
3025 0 : if (ferror (src_file))
3026 0 : goto change_one_err;
3027 : }
3028 0 : if (dest_file)
3029 : {
3030 0 : while ((length = read_line (dest_file, &line, &line_len, NULL)) > 0)
3031 : {
3032 0 : fprintf (src_file, "%s", line);
3033 0 : if (ferror (src_file))
3034 0 : goto change_one_err;
3035 : }
3036 0 : if (length < 0 || ferror (dest_file))
3037 : goto change_one_err;
3038 : }
3039 0 : xfree (line);
3040 0 : line = NULL;
3041 :
3042 0 : res = fclose (src_file);
3043 0 : if (res)
3044 : {
3045 0 : res = errno;
3046 0 : close (fd);
3047 0 : if (dest_file)
3048 0 : fclose (dest_file);
3049 0 : gpg_err_set_errno (res);
3050 0 : return -1;
3051 : }
3052 0 : close (fd);
3053 0 : if (dest_file)
3054 : {
3055 0 : res = fclose (dest_file);
3056 0 : if (res)
3057 0 : return -1;
3058 : }
3059 0 : return 0;
3060 :
3061 : change_one_err:
3062 0 : xfree (line);
3063 0 : res = errno;
3064 0 : if (src_file)
3065 : {
3066 0 : fclose (src_file);
3067 0 : close (fd);
3068 : }
3069 0 : if (dest_file)
3070 0 : fclose (dest_file);
3071 0 : gpg_err_set_errno (res);
3072 0 : return -1;
3073 : }
3074 :
3075 :
3076 : /* Common code for gc_component_change_options and
3077 : gc_process_gpgconf_conf. */
3078 : static void
3079 0 : change_one_value (gc_option_t *option, int *runtime,
3080 : unsigned long flags, char *new_value)
3081 : {
3082 0 : unsigned long new_value_nr = 0;
3083 :
3084 0 : option_check_validity (option, flags, new_value, &new_value_nr);
3085 :
3086 0 : if (option->flags & GC_OPT_FLAG_RUNTIME)
3087 0 : runtime[option->backend] = 1;
3088 :
3089 0 : option->new_flags = flags;
3090 0 : if (!(flags & GC_OPT_FLAG_DEFAULT))
3091 : {
3092 0 : if (gc_arg_type[option->arg_type].fallback == GC_ARG_TYPE_NONE
3093 0 : && (option->flags & GC_OPT_FLAG_LIST))
3094 0 : {
3095 : char *str;
3096 :
3097 : /* We convert the number to a list of 1's for convenient
3098 : list handling. */
3099 0 : assert (new_value_nr > 0);
3100 0 : option->new_value = xmalloc ((2 * (new_value_nr - 1) + 1) + 1);
3101 0 : str = option->new_value;
3102 0 : *(str++) = '1';
3103 0 : while (--new_value_nr > 0)
3104 : {
3105 0 : *(str++) = ',';
3106 0 : *(str++) = '1';
3107 : }
3108 0 : *(str++) = '\0';
3109 : }
3110 : else
3111 0 : option->new_value = xstrdup (new_value);
3112 : }
3113 0 : }
3114 :
3115 :
3116 : /* Read the modifications from IN and apply them. If IN is NULL the
3117 : modifications are expected to already have been set to the global
3118 : table. */
3119 : void
3120 0 : gc_component_change_options (int component, estream_t in, estream_t out)
3121 : {
3122 0 : int err = 0;
3123 : int runtime[GC_BACKEND_NR];
3124 : char *src_filename[GC_BACKEND_NR];
3125 : char *dest_filename[GC_BACKEND_NR];
3126 : char *orig_filename[GC_BACKEND_NR];
3127 : gc_backend_t backend;
3128 : gc_option_t *option;
3129 0 : char *line = NULL;
3130 0 : size_t line_len = 0;
3131 : ssize_t length;
3132 :
3133 0 : if (component == GC_COMPONENT_PINENTRY)
3134 0 : return; /* Dummy component for now. */
3135 :
3136 0 : for (backend = 0; backend < GC_BACKEND_NR; backend++)
3137 : {
3138 0 : runtime[backend] = 0;
3139 0 : src_filename[backend] = NULL;
3140 0 : dest_filename[backend] = NULL;
3141 0 : orig_filename[backend] = NULL;
3142 : }
3143 :
3144 0 : if (in)
3145 : {
3146 : /* Read options from the file IN. */
3147 0 : while ((length = es_read_line (in, &line, &line_len, NULL)) > 0)
3148 : {
3149 : char *linep;
3150 0 : unsigned long flags = 0;
3151 0 : char *new_value = "";
3152 :
3153 : /* Strip newline and carriage return, if present. */
3154 0 : while (length > 0
3155 0 : && (line[length - 1] == '\n' || line[length - 1] == '\r'))
3156 0 : line[--length] = '\0';
3157 :
3158 0 : linep = strchr (line, ':');
3159 0 : if (linep)
3160 0 : *(linep++) = '\0';
3161 :
3162 : /* Extract additional flags. Default to none. */
3163 0 : if (linep)
3164 : {
3165 : char *end;
3166 : char *tail;
3167 :
3168 0 : end = strchr (linep, ':');
3169 0 : if (end)
3170 0 : *(end++) = '\0';
3171 :
3172 0 : gpg_err_set_errno (0);
3173 0 : flags = strtoul (linep, &tail, 0);
3174 0 : if (errno)
3175 0 : gc_error (1, errno, "malformed flags in option %s", line);
3176 0 : if (!(*tail == '\0' || *tail == ':' || *tail == ' '))
3177 0 : gc_error (1, 0, "garbage after flags in option %s", line);
3178 :
3179 0 : linep = end;
3180 : }
3181 :
3182 : /* Don't allow setting of the no change flag. */
3183 0 : flags &= ~GC_OPT_FLAG_NO_CHANGE;
3184 :
3185 : /* Extract default value, if present. Default to empty if not. */
3186 0 : if (linep)
3187 : {
3188 : char *end;
3189 0 : end = strchr (linep, ':');
3190 0 : if (end)
3191 0 : *(end++) = '\0';
3192 0 : new_value = linep;
3193 0 : linep = end;
3194 : }
3195 :
3196 0 : option = find_option (component, line, GC_BACKEND_ANY);
3197 0 : if (!option)
3198 0 : gc_error (1, 0, "unknown option %s", line);
3199 :
3200 0 : if ((option->flags & GC_OPT_FLAG_NO_CHANGE))
3201 : {
3202 0 : gc_error (0, 0, "ignoring new value for option %s",
3203 : option->name);
3204 0 : continue;
3205 : }
3206 :
3207 0 : change_one_value (option, runtime, flags, new_value);
3208 : }
3209 : }
3210 :
3211 : /* Now that we have collected and locally verified the changes,
3212 : write them out to new configuration files, verify them
3213 : externally, and then commit them. */
3214 0 : option = gc_component[component].options;
3215 0 : while (option && option->name)
3216 : {
3217 : /* Go on if we have already seen this backend, or if there is
3218 : nothing to do. */
3219 0 : if (src_filename[option->backend]
3220 0 : || !(option->new_flags || option->new_value))
3221 : {
3222 0 : option++;
3223 0 : continue;
3224 : }
3225 :
3226 0 : if (gc_backend[option->backend].program)
3227 : {
3228 0 : err = change_options_program (component, option->backend,
3229 0 : &src_filename[option->backend],
3230 0 : &dest_filename[option->backend],
3231 0 : &orig_filename[option->backend]);
3232 0 : if (! err)
3233 : {
3234 : /* External verification. */
3235 0 : err = gc_component_check_options (component, out,
3236 0 : src_filename[option->backend]);
3237 0 : if (err)
3238 : {
3239 0 : gc_error (0, 0,
3240 0 : _("External verification of component %s failed"),
3241 : gc_component[component].name);
3242 0 : gpg_err_set_errno (EINVAL);
3243 : }
3244 : }
3245 :
3246 : }
3247 : else
3248 0 : err = change_options_file (component, option->backend,
3249 0 : &src_filename[option->backend],
3250 0 : &dest_filename[option->backend],
3251 0 : &orig_filename[option->backend]);
3252 :
3253 0 : if (err)
3254 0 : break;
3255 :
3256 0 : option++;
3257 : }
3258 :
3259 0 : if (! err && ! opt.dry_run)
3260 : {
3261 : int i;
3262 :
3263 0 : for (i = 0; i < GC_BACKEND_NR; i++)
3264 : {
3265 0 : if (src_filename[i])
3266 : {
3267 : /* FIXME: Make a verification here. */
3268 :
3269 0 : assert (dest_filename[i]);
3270 :
3271 0 : if (orig_filename[i])
3272 : {
3273 : #ifdef HAVE_W32_SYSTEM
3274 : /* There is no atomic update on W32. */
3275 : err = unlink (dest_filename[i]);
3276 : #endif /* HAVE_W32_SYSTEM */
3277 0 : if (!err)
3278 0 : err = rename (src_filename[i], dest_filename[i]);
3279 : }
3280 : else
3281 : {
3282 : #ifdef HAVE_W32_SYSTEM
3283 : /* We skip the unlink if we expect the file not to
3284 : be there. */
3285 : err = rename (src_filename[i], dest_filename[i]);
3286 : #else /* HAVE_W32_SYSTEM */
3287 : /* This is a bit safer than rename() because we
3288 : expect DEST_FILENAME not to be there. If it
3289 : happens to be there, this will fail. */
3290 0 : err = link (src_filename[i], dest_filename[i]);
3291 0 : if (!err)
3292 0 : err = unlink (src_filename[i]);
3293 : #endif /* !HAVE_W32_SYSTEM */
3294 : }
3295 0 : if (err)
3296 0 : break;
3297 0 : src_filename[i] = NULL;
3298 : }
3299 : }
3300 : }
3301 :
3302 0 : if (err || opt.dry_run)
3303 : {
3304 : int i;
3305 0 : int saved_errno = errno;
3306 :
3307 : /* An error occurred or a dry-run is requested. */
3308 0 : for (i = 0; i < GC_BACKEND_NR; i++)
3309 : {
3310 0 : if (src_filename[i])
3311 : {
3312 : /* The change was not yet committed. */
3313 0 : unlink (src_filename[i]);
3314 0 : if (orig_filename[i])
3315 0 : unlink (orig_filename[i]);
3316 : }
3317 : else
3318 : {
3319 : /* The changes were already committed. FIXME: This is a
3320 : tad dangerous, as we don't know if we don't overwrite
3321 : a version of the file that is even newer than the one
3322 : we just installed. */
3323 0 : if (orig_filename[i])
3324 : {
3325 : #ifdef HAVE_W32_SYSTEM
3326 : /* There is no atomic update on W32. */
3327 : unlink (dest_filename[i]);
3328 : #endif /* HAVE_W32_SYSTEM */
3329 0 : rename (orig_filename[i], dest_filename[i]);
3330 : }
3331 : else
3332 0 : unlink (dest_filename[i]);
3333 : }
3334 : }
3335 0 : if (err)
3336 0 : gc_error (1, saved_errno, "could not commit changes");
3337 :
3338 : /* Fall-through for dry run. */
3339 0 : goto leave;
3340 : }
3341 :
3342 : /* If it all worked, notify the daemons of the changes. */
3343 0 : if (opt.runtime)
3344 0 : for (backend = 0; backend < GC_BACKEND_NR; backend++)
3345 : {
3346 0 : if (runtime[backend] && gc_backend[backend].runtime_change)
3347 0 : (*gc_backend[backend].runtime_change) (0);
3348 : }
3349 :
3350 : /* Move the per-process backup file into its place. */
3351 0 : for (backend = 0; backend < GC_BACKEND_NR; backend++)
3352 0 : if (orig_filename[backend])
3353 : {
3354 : char *backup_filename;
3355 :
3356 0 : assert (dest_filename[backend]);
3357 :
3358 0 : backup_filename = xasprintf ("%s.%s.bak",
3359 : dest_filename[backend], GPGCONF_NAME);
3360 :
3361 : #ifdef HAVE_W32_SYSTEM
3362 : /* There is no atomic update on W32. */
3363 : unlink (backup_filename);
3364 : #endif /* HAVE_W32_SYSTEM */
3365 0 : rename (orig_filename[backend], backup_filename);
3366 : }
3367 :
3368 : leave:
3369 0 : xfree (line);
3370 : }
3371 :
3372 :
3373 : /* Check whether USER matches the current user of one of its group.
3374 : This function may change USER. Returns true is there is a
3375 : match. */
3376 : static int
3377 0 : key_matches_user_or_group (char *user)
3378 : {
3379 : char *group;
3380 :
3381 0 : if (*user == '*' && user[1] == 0)
3382 0 : return 1; /* A single asterisk matches all users. */
3383 :
3384 0 : group = strchr (user, ':');
3385 0 : if (group)
3386 0 : *group++ = 0;
3387 :
3388 : #ifdef HAVE_W32_SYSTEM
3389 : /* Under Windows we don't support groups. */
3390 : if (group && *group)
3391 : gc_error (0, 0, _("Note that group specifications are ignored\n"));
3392 : #ifndef HAVE_W32CE_SYSTEM
3393 : if (*user)
3394 : {
3395 : static char *my_name;
3396 :
3397 : if (!my_name)
3398 : {
3399 : char tmp[1];
3400 : DWORD size = 1;
3401 :
3402 : GetUserNameA (tmp, &size);
3403 : my_name = xmalloc (size);
3404 : if (!GetUserNameA (my_name, &size))
3405 : gc_error (1,0, "error getting current user name: %s",
3406 : w32_strerror (-1));
3407 : }
3408 :
3409 : if (!strcmp (user, my_name))
3410 : return 1; /* Found. */
3411 : }
3412 : #endif /*HAVE_W32CE_SYSTEM*/
3413 : #else /*!HAVE_W32_SYSTEM*/
3414 : /* First check whether the user matches. */
3415 0 : if (*user)
3416 : {
3417 : static char *my_name;
3418 :
3419 0 : if (!my_name)
3420 : {
3421 0 : struct passwd *pw = getpwuid ( getuid () );
3422 0 : if (!pw)
3423 0 : gc_error (1, errno, "getpwuid failed for current user");
3424 0 : my_name = xstrdup (pw->pw_name);
3425 : }
3426 0 : if (!strcmp (user, my_name))
3427 0 : return 1; /* Found. */
3428 : }
3429 :
3430 : /* If that failed, check whether a group matches. */
3431 0 : if (group && *group)
3432 : {
3433 : static char *my_group;
3434 : static char **my_supgroups;
3435 : int n;
3436 :
3437 0 : if (!my_group)
3438 : {
3439 0 : struct group *gr = getgrgid ( getgid () );
3440 0 : if (!gr)
3441 0 : gc_error (1, errno, "getgrgid failed for current user");
3442 0 : my_group = xstrdup (gr->gr_name);
3443 : }
3444 0 : if (!strcmp (group, my_group))
3445 0 : return 1; /* Found. */
3446 :
3447 0 : if (!my_supgroups)
3448 : {
3449 : int ngids;
3450 : gid_t *gids;
3451 :
3452 0 : ngids = getgroups (0, NULL);
3453 0 : gids = xcalloc (ngids+1, sizeof *gids);
3454 0 : ngids = getgroups (ngids, gids);
3455 0 : if (ngids < 0)
3456 0 : gc_error (1, errno, "getgroups failed for current user");
3457 0 : my_supgroups = xcalloc (ngids+1, sizeof *my_supgroups);
3458 0 : for (n=0; n < ngids; n++)
3459 : {
3460 0 : struct group *gr = getgrgid ( gids[n] );
3461 0 : if (!gr)
3462 0 : gc_error (1, errno, "getgrgid failed for supplementary group");
3463 0 : my_supgroups[n] = xstrdup (gr->gr_name);
3464 : }
3465 0 : xfree (gids);
3466 : }
3467 :
3468 0 : for (n=0; my_supgroups[n]; n++)
3469 0 : if (!strcmp (group, my_supgroups[n]))
3470 0 : return 1; /* Found. */
3471 : }
3472 : #endif /*!HAVE_W32_SYSTEM*/
3473 0 : return 0; /* No match. */
3474 : }
3475 :
3476 :
3477 :
3478 : /* Read and process the global configuration file for gpgconf. This
3479 : optional file is used to update our internal tables at runtime and
3480 : may also be used to set new default values. If FNAME is NULL the
3481 : default name will be used. With UPDATE set to true the internal
3482 : tables are actually updated; if not set, only a syntax check is
3483 : done. If DEFAULTS is true the global options are written to the
3484 : configuration files. If LISTFP is set, no changes are done but the
3485 : configuration file is printed to LISTFP in a colon separated format.
3486 :
3487 : Returns 0 on success or if the config file is not present; -1 is
3488 : returned on error. */
3489 : int
3490 0 : gc_process_gpgconf_conf (const char *fname_arg, int update, int defaults,
3491 : estream_t listfp)
3492 : {
3493 0 : int result = 0;
3494 0 : char *line = NULL;
3495 0 : size_t line_len = 0;
3496 : ssize_t length;
3497 : FILE *config;
3498 0 : int lineno = 0;
3499 0 : int in_rule = 0;
3500 0 : int got_match = 0;
3501 : int runtime[GC_BACKEND_NR];
3502 : int backend_id, component_id;
3503 : char *fname;
3504 :
3505 0 : if (fname_arg)
3506 0 : fname = xstrdup (fname_arg);
3507 : else
3508 0 : fname = make_filename (gnupg_sysconfdir (), GPGCONF_NAME EXTSEP_S "conf",
3509 : NULL);
3510 :
3511 0 : for (backend_id = 0; backend_id < GC_BACKEND_NR; backend_id++)
3512 0 : runtime[backend_id] = 0;
3513 :
3514 0 : config = fopen (fname, "r");
3515 0 : if (!config)
3516 : {
3517 : /* Do not print an error if the file is not available, except
3518 : when running in syntax check mode. */
3519 0 : if (errno != ENOENT || !update)
3520 : {
3521 0 : gc_error (0, errno, "can not open global config file '%s'", fname);
3522 0 : result = -1;
3523 : }
3524 0 : xfree (fname);
3525 0 : return result;
3526 : }
3527 :
3528 0 : while ((length = read_line (config, &line, &line_len, NULL)) > 0)
3529 : {
3530 : char *key, *component, *option, *flags, *value;
3531 : char *empty;
3532 0 : gc_option_t *option_info = NULL;
3533 : char *p;
3534 : int is_continuation;
3535 :
3536 0 : lineno++;
3537 0 : key = line;
3538 0 : while (*key == ' ' || *key == '\t')
3539 0 : key++;
3540 0 : if (!*key || *key == '#' || *key == '\r' || *key == '\n')
3541 0 : continue;
3542 :
3543 0 : is_continuation = (key != line);
3544 :
3545 : /* Parse the key field. */
3546 0 : if (!is_continuation && got_match)
3547 : break; /* Finish after the first match. */
3548 0 : else if (!is_continuation)
3549 : {
3550 0 : in_rule = 0;
3551 0 : for (p=key+1; *p && !strchr (" \t\r\n", *p); p++)
3552 : ;
3553 0 : if (!*p)
3554 : {
3555 0 : gc_error (0, 0, "missing rule at '%s', line %d", fname, lineno);
3556 0 : result = -1;
3557 0 : continue;
3558 : }
3559 0 : *p++ = 0;
3560 0 : component = p;
3561 : }
3562 0 : else if (!in_rule)
3563 : {
3564 0 : gc_error (0, 0, "continuation but no rule at '%s', line %d",
3565 : fname, lineno);
3566 0 : result = -1;
3567 0 : continue;
3568 : }
3569 : else
3570 : {
3571 0 : component = key;
3572 0 : key = NULL;
3573 : }
3574 :
3575 0 : in_rule = 1;
3576 :
3577 : /* Parse the component. */
3578 0 : while (*component == ' ' || *component == '\t')
3579 0 : component++;
3580 0 : for (p=component; *p && !strchr (" \t\r\n", *p); p++)
3581 : ;
3582 0 : if (p == component)
3583 : {
3584 0 : gc_error (0, 0, "missing component at '%s', line %d",
3585 : fname, lineno);
3586 0 : result = -1;
3587 0 : continue;
3588 : }
3589 0 : empty = p;
3590 0 : *p++ = 0;
3591 0 : option = p;
3592 0 : component_id = gc_component_find (component);
3593 0 : if (component_id < 0)
3594 : {
3595 0 : gc_error (0, 0, "unknown component at '%s', line %d",
3596 : fname, lineno);
3597 0 : result = -1;
3598 : }
3599 :
3600 : /* Parse the option name. */
3601 0 : while (*option == ' ' || *option == '\t')
3602 0 : option++;
3603 0 : for (p=option; *p && !strchr (" \t\r\n", *p); p++)
3604 : ;
3605 0 : if (p == option)
3606 : {
3607 0 : gc_error (0, 0, "missing option at '%s', line %d",
3608 : fname, lineno);
3609 0 : result = -1;
3610 0 : continue;
3611 : }
3612 0 : *p++ = 0;
3613 0 : flags = p;
3614 0 : if ( component_id != -1)
3615 : {
3616 0 : option_info = find_option (component_id, option, GC_BACKEND_ANY);
3617 0 : if (!option_info)
3618 : {
3619 0 : gc_error (0, 0, "unknown option at '%s', line %d",
3620 : fname, lineno);
3621 0 : result = -1;
3622 : }
3623 : }
3624 :
3625 :
3626 : /* Parse the optional flags. */
3627 0 : while (*flags == ' ' || *flags == '\t')
3628 0 : flags++;
3629 0 : if (*flags == '[')
3630 : {
3631 0 : flags++;
3632 0 : p = strchr (flags, ']');
3633 0 : if (!p)
3634 : {
3635 0 : gc_error (0, 0, "syntax error in rule at '%s', line %d",
3636 : fname, lineno);
3637 0 : result = -1;
3638 0 : continue;
3639 : }
3640 0 : *p++ = 0;
3641 0 : value = p;
3642 : }
3643 : else /* No flags given. */
3644 : {
3645 0 : value = flags;
3646 0 : flags = NULL;
3647 : }
3648 :
3649 : /* Parse the optional value. */
3650 0 : while (*value == ' ' || *value == '\t')
3651 0 : value++;
3652 0 : for (p=value; *p && !strchr ("\r\n", *p); p++)
3653 : ;
3654 0 : if (p == value)
3655 0 : value = empty; /* No value given; let it point to an empty string. */
3656 : else
3657 : {
3658 : /* Strip trailing white space. */
3659 0 : *p = 0;
3660 0 : for (p--; p > value && (*p == ' ' || *p == '\t'); p--)
3661 0 : *p = 0;
3662 : }
3663 :
3664 : /* Check flag combinations. */
3665 0 : if (!flags)
3666 : ;
3667 0 : else if (!strcmp (flags, "default"))
3668 : {
3669 0 : if (*value)
3670 : {
3671 0 : gc_error (0, 0, "flag \"default\" may not be combined "
3672 : "with a value at '%s', line %d",
3673 : fname, lineno);
3674 0 : result = -1;
3675 : }
3676 : }
3677 0 : else if (!strcmp (flags, "change"))
3678 : ;
3679 0 : else if (!strcmp (flags, "no-change"))
3680 : ;
3681 : else
3682 : {
3683 0 : gc_error (0, 0, "unknown flag at '%s', line %d",
3684 : fname, lineno);
3685 0 : result = -1;
3686 : }
3687 :
3688 : /* In list mode we print out all records. */
3689 0 : if (listfp && !result)
3690 : {
3691 : /* If this is a new ruleset, print a key record. */
3692 0 : if (!is_continuation)
3693 : {
3694 0 : char *group = strchr (key, ':');
3695 0 : if (group)
3696 : {
3697 0 : *group++ = 0;
3698 0 : if ((p = strchr (group, ':')))
3699 0 : *p = 0; /* We better strip any extra stuff. */
3700 : }
3701 :
3702 0 : es_fprintf (listfp, "k:%s:", gc_percent_escape (key));
3703 0 : es_fprintf (listfp, "%s\n", group? gc_percent_escape (group):"");
3704 : }
3705 :
3706 : /* All other lines are rule records. */
3707 0 : es_fprintf (listfp, "r:::%s:%s:%s:",
3708 : gc_component[component_id].name,
3709 0 : option_info->name? option_info->name : "",
3710 : flags? flags : "");
3711 0 : if (value != empty)
3712 0 : es_fprintf (listfp, "\"%s", gc_percent_escape (value));
3713 :
3714 0 : es_putc ('\n', listfp);
3715 : }
3716 :
3717 : /* Check whether the key matches but do this only if we are not
3718 : running in syntax check mode. */
3719 0 : if ( update
3720 0 : && !result && !listfp
3721 0 : && (got_match || (key && key_matches_user_or_group (key))) )
3722 : {
3723 0 : int newflags = 0;
3724 :
3725 0 : got_match = 1;
3726 :
3727 : /* Apply the flags from gpgconf.conf. */
3728 0 : if (!flags)
3729 : ;
3730 0 : else if (!strcmp (flags, "default"))
3731 0 : newflags |= GC_OPT_FLAG_DEFAULT;
3732 0 : else if (!strcmp (flags, "no-change"))
3733 0 : option_info->flags |= GC_OPT_FLAG_NO_CHANGE;
3734 0 : else if (!strcmp (flags, "change"))
3735 0 : option_info->flags &= ~GC_OPT_FLAG_NO_CHANGE;
3736 :
3737 0 : if (defaults)
3738 : {
3739 : /* Here we explicitly allow updating the value again. */
3740 0 : if (newflags)
3741 : {
3742 0 : option_info->new_flags = 0;
3743 : }
3744 0 : if (*value)
3745 : {
3746 0 : xfree (option_info->new_value);
3747 0 : option_info->new_value = NULL;
3748 : }
3749 0 : change_one_value (option_info, runtime, newflags, value);
3750 : }
3751 : }
3752 : }
3753 :
3754 0 : if (length < 0 || ferror (config))
3755 : {
3756 0 : gc_error (0, errno, "error reading from '%s'", fname);
3757 0 : result = -1;
3758 : }
3759 0 : if (fclose (config))
3760 0 : gc_error (0, errno, "error closing '%s'", fname);
3761 :
3762 0 : xfree (line);
3763 :
3764 : /* If it all worked, process the options. */
3765 0 : if (!result && update && defaults && !listfp)
3766 : {
3767 : /* We need to switch off the runtime update, so that we can do
3768 : it later all at once. */
3769 0 : int save_opt_runtime = opt.runtime;
3770 0 : opt.runtime = 0;
3771 :
3772 0 : for (component_id = 0; component_id < GC_COMPONENT_NR; component_id++)
3773 : {
3774 0 : gc_component_change_options (component_id, NULL, NULL);
3775 : }
3776 0 : opt.runtime = save_opt_runtime;
3777 :
3778 0 : if (opt.runtime)
3779 : {
3780 0 : for (backend_id = 0; backend_id < GC_BACKEND_NR; backend_id++)
3781 0 : if (runtime[backend_id] && gc_backend[backend_id].runtime_change)
3782 0 : (*gc_backend[backend_id].runtime_change) (0);
3783 : }
3784 : }
3785 :
3786 0 : xfree (fname);
3787 0 : return result;
3788 : }
|
