agent: Stop scdaemon after reload when disable_scdaemon.
[gnupg.git] / tools / gpgconf.c
1 /* gpgconf.c - Configuration utility for GnuPG
2  * Copyright (C) 2003, 2007, 2009, 2011 Free Software Foundation, Inc.
3  * Copyright (C) 2016 g10 Code GmbH.
4  *
5  * This file is part of GnuPG.
6  *
7  * GnuPG is free software; you can redistribute it and/or modify
8  * it 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,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, see <https://www.gnu.org/licenses/>.
19  */
20
21 #include <config.h>
22 #include <errno.h>
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <unistd.h>
27
28 #include "gpgconf.h"
29 #include "../common/i18n.h"
30 #include "../common/sysutils.h"
31 #include "../common/init.h"
32 #include "../common/status.h"
33
34
35 /* Constants to identify the commands and options. */
36 enum cmd_and_opt_values
37   {
38     aNull = 0,
39     oDryRun     = 'n',
40     oOutput     = 'o',
41     oQuiet      = 'q',
42     oVerbose    = 'v',
43     oRuntime    = 'r',
44     oComponent  = 'c',
45     oNull       = '0',
46     oNoVerbose  = 500,
47     oHomedir,
48     oBuilddir,
49     oStatusFD,
50     oShowSocket,
51
52     aListComponents,
53     aCheckPrograms,
54     aListOptions,
55     aChangeOptions,
56     aCheckOptions,
57     aApplyDefaults,
58     aListConfig,
59     aCheckConfig,
60     aQuerySWDB,
61     aListDirs,
62     aLaunch,
63     aKill,
64     aCreateSocketDir,
65     aRemoveSocketDir,
66     aApplyProfile,
67     aReload
68   };
69
70
71 /* The list of commands and options. */
72 static ARGPARSE_OPTS opts[] =
73   {
74     { 300, NULL, 0, N_("@Commands:\n ") },
75
76     { aListComponents, "list-components", 256, N_("list all components") },
77     { aCheckPrograms, "check-programs", 256, N_("check all programs") },
78     { aListOptions, "list-options", 256, N_("|COMPONENT|list options") },
79     { aChangeOptions, "change-options", 256, N_("|COMPONENT|change options") },
80     { aCheckOptions, "check-options", 256, N_("|COMPONENT|check options") },
81     { aApplyDefaults, "apply-defaults", 256,
82       N_("apply global default values") },
83     { aApplyProfile, "apply-profile", 256,
84       N_("|FILE|update configuration files using FILE") },
85     { aListDirs, "list-dirs", 256,
86       N_("get the configuration directories for @GPGCONF@") },
87     { aListConfig,   "list-config", 256,
88       N_("list global configuration file") },
89     { aCheckConfig,   "check-config", 256,
90       N_("check global configuration file") },
91     { aQuerySWDB,     "query-swdb", 256,
92       N_("query the software version database") },
93     { aReload,        "reload", 256, N_("reload all or a given component")},
94     { aLaunch,        "launch", 256, N_("launch a given component")},
95     { aKill,          "kill", 256,   N_("kill a given component")},
96     { aCreateSocketDir, "create-socketdir", 256, "@"},
97     { aRemoveSocketDir, "remove-socketdir", 256, "@"},
98
99     { 301, NULL, 0, N_("@\nOptions:\n ") },
100
101     { oOutput, "output",    2, N_("use as output file") },
102     { oVerbose, "verbose",  0, N_("verbose") },
103     { oQuiet, "quiet",      0, N_("quiet") },
104     { oDryRun, "dry-run",   0, N_("do not make any changes") },
105     { oRuntime, "runtime",  0, N_("activate changes at runtime, if possible") },
106   ARGPARSE_s_i (oStatusFD, "status-fd", N_("|FD|write status info to this FD")),
107     /* hidden options */
108     { oHomedir, "homedir", 2, "@" },
109     { oBuilddir, "build-prefix", 2, "@" },
110     { oNull, "null", 0, "@" },
111     { oNoVerbose, "no-verbose",  0, "@"},
112     ARGPARSE_s_n (oShowSocket, "show-socket", "@"),
113
114     ARGPARSE_end(),
115   };
116
117
118 /* The stream to output the status information.  Status Output is disabled if
119  * this is NULL.  */
120 static estream_t statusfp;
121
122
123 /* Print usage information and provide strings for help. */
124 static const char *
125 my_strusage( int level )
126 {
127   const char *p;
128
129   switch (level)
130     {
131     case 11: p = "@GPGCONF@ (@GNUPG@)";
132       break;
133     case 13: p = VERSION; break;
134     case 17: p = PRINTABLE_OS_NAME; break;
135     case 19: p = _("Please report bugs to <@EMAIL@>.\n"); break;
136
137     case 1:
138     case 40: p = _("Usage: @GPGCONF@ [options] (-h for help)");
139       break;
140     case 41:
141       p = _("Syntax: @GPGCONF@ [options]\n"
142             "Manage configuration options for tools of the @GNUPG@ system\n");
143       break;
144
145     default: p = NULL; break;
146     }
147   return p;
148 }
149
150
151 /* Return the fp for the output.  This is usually stdout unless
152    --output has been used.  In the latter case this function opens
153    that file.  */
154 static estream_t
155 get_outfp (estream_t *fp)
156 {
157   if (!*fp)
158     {
159       if (opt.outfile)
160         {
161           *fp = es_fopen (opt.outfile, "w");
162           if (!*fp)
163             gc_error (1, errno, "can not open '%s'", opt.outfile);
164         }
165       else
166         *fp = es_stdout;
167     }
168   return *fp;
169 }
170
171
172 /* Set the status FD.  */
173 static void
174 set_status_fd (int fd)
175 {
176   static int last_fd = -1;
177
178   if (fd != -1 && last_fd == fd)
179     return;
180
181   if (statusfp && statusfp != es_stdout && statusfp != es_stderr)
182     es_fclose (statusfp);
183   statusfp = NULL;
184   if (fd == -1)
185     return;
186
187   if (fd == 1)
188     statusfp = es_stdout;
189   else if (fd == 2)
190     statusfp = es_stderr;
191   else
192     statusfp = es_fdopen (fd, "w");
193   if (!statusfp)
194     {
195       log_fatal ("can't open fd %d for status output: %s\n",
196                  fd, gpg_strerror (gpg_error_from_syserror ()));
197     }
198   last_fd = fd;
199 }
200
201
202 /* Write a status line with code NO followed by the output of the
203  * printf style FORMAT.  The caller needs to make sure that LFs and
204  * CRs are not printed.  */
205 void
206 gpgconf_write_status (int no, const char *format, ...)
207 {
208   va_list arg_ptr;
209
210   if (!statusfp)
211     return;  /* Not enabled.  */
212
213   es_fputs ("[GNUPG:] ", statusfp);
214   es_fputs (get_status_string (no), statusfp);
215   if (format)
216     {
217       es_putc (' ', statusfp);
218       va_start (arg_ptr, format);
219       es_vfprintf (statusfp, format, arg_ptr);
220       va_end (arg_ptr);
221     }
222   es_putc ('\n', statusfp);
223 }
224
225
226 static void
227 list_dirs (estream_t fp, char **names)
228 {
229   static struct {
230     const char *name;
231     const char *(*fnc)(void);
232     const char *extra;
233   } list[] = {
234     { "sysconfdir",         gnupg_sysconfdir, NULL },
235     { "bindir",             gnupg_bindir,     NULL },
236     { "libexecdir",         gnupg_libexecdir, NULL },
237     { "libdir",             gnupg_libdir,     NULL },
238     { "datadir",            gnupg_datadir,    NULL },
239     { "localedir",          gnupg_localedir,  NULL },
240     { "socketdir",          gnupg_socketdir,  NULL },
241     { "dirmngr-socket",     dirmngr_socket_name, NULL,},
242     { "agent-ssh-socket",   gnupg_socketdir,  GPG_AGENT_SSH_SOCK_NAME },
243     { "agent-extra-socket", gnupg_socketdir,  GPG_AGENT_EXTRA_SOCK_NAME },
244     { "agent-browser-socket",gnupg_socketdir, GPG_AGENT_BROWSER_SOCK_NAME },
245     { "agent-socket",       gnupg_socketdir,  GPG_AGENT_SOCK_NAME },
246     { "homedir",            gnupg_homedir,    NULL }
247   };
248   int idx, j;
249   char *tmp;
250   const char *s;
251
252
253   for (idx = 0; idx < DIM (list); idx++)
254     {
255       s = list[idx].fnc ();
256       if (list[idx].extra)
257         {
258           tmp = make_filename (s, list[idx].extra, NULL);
259           s = tmp;
260         }
261       else
262         tmp = NULL;
263       if (!names)
264         es_fprintf (fp, "%s:%s\n", list[idx].name, gc_percent_escape (s));
265       else
266         {
267           for (j=0; names[j]; j++)
268             if (!strcmp (names[j], list[idx].name))
269               {
270                 es_fputs (s, fp);
271                 es_putc (opt.null? '\0':'\n', fp);
272               }
273         }
274
275       xfree (tmp);
276     }
277 }
278
279
280
281 /* Check whether NAME is valid argument for query_swdb().  Valid names
282  * start with a letter and contain only alphanumeric characters or an
283  * underscore.  */
284 static int
285 valid_swdb_name_p (const char *name)
286 {
287   if (!name || !*name || !alphap (name))
288     return 0;
289
290   for (name++; *name; name++)
291     if (!alnump (name) && *name != '_')
292       return 0;
293
294   return 1;
295 }
296
297
298 /* Query the SWDB file.  If necessary and possible this functions asks
299  * the dirmngr to load an updated version of that file.  The caller
300  * needs to provide the NAME to query (e.g. "gnupg", "libgcrypt") and
301  * optional the currently installed version in CURRENT_VERSION.  The
302  * output written to OUT is a colon delimited line with these fields:
303  *
304  * name   :: The name of the package
305  * curvers:: The installed version if given.
306  * status :: This value tells the status of the software package
307  *           '-' :: No information available
308  *                  (error or CURRENT_VERSION not given)
309  *           '?' :: Unknown NAME
310  *           'u' :: Update available
311  *           'c' :: The version is Current
312  *           'n' :: The current version is already Newer than the
313  *                  available one.
314  * urgency :: If the value is greater than zero an urgent update is required.
315  * error   :: 0 on success or an gpg_err_code_t
316  *            Common codes seen:
317  *            GPG_ERR_TOO_OLD :: The SWDB file is to old to be used.
318  *            GPG_ERR_ENOENT  :: The SWDB file is not available.
319  *            GPG_ERR_BAD_SIGNATURE :: Currupted SWDB file.
320  * filedate:: Date of the swdb file (yyyymmddThhmmss)
321  * verified:: Date we checked the validity of the file (yyyyymmddThhmmss)
322  * version :: The version string from the swdb.
323  * reldate :: Release date of that version (yyyymmddThhmmss)
324  * size    :: Size of the package in bytes.
325  * hash    :: SHA-2 hash of the package.
326  *
327  */
328 static void
329 query_swdb (estream_t out, const char *name, const char *current_version)
330 {
331   gpg_error_t err;
332   const char *search_name;
333   char *fname = NULL;
334   estream_t fp = NULL;
335   char *line = NULL;
336   char *self_version = NULL;
337   size_t length_of_line = 0;
338   size_t  maxlen;
339   ssize_t len;
340   char *fields[2];
341   char *p;
342   gnupg_isotime_t filedate = {0};
343   gnupg_isotime_t verified = {0};
344   char *value_ver = NULL;
345   gnupg_isotime_t value_date = {0};
346   char *value_size = NULL;
347   char *value_sha2 = NULL;
348   unsigned long value_size_ul = 0;
349   int status, i;
350
351
352   if (!valid_swdb_name_p (name))
353     {
354       log_error ("error in package name '%s': %s\n",
355                  name, gpg_strerror (GPG_ERR_INV_NAME));
356       goto leave;
357     }
358   if (!strcmp (name, "gnupg"))
359     search_name = GNUPG_SWDB_TAG;
360   else if (!strcmp (name, "gnupg1"))
361     search_name = "gnupg1";
362   else
363     search_name = name;
364
365   if (!current_version && !strcmp (name, "gnupg"))
366     {
367       /* Use our own version but string a possible beta string.  */
368       self_version = xstrdup (PACKAGE_VERSION);
369       p = strchr (self_version, '-');
370       if (p)
371         *p = 0;
372       current_version = self_version;
373     }
374
375   if (current_version && (strchr (current_version, ':')
376                           || compare_version_strings (current_version, NULL)))
377     {
378       log_error ("error in version string '%s': %s\n",
379                  current_version, gpg_strerror (GPG_ERR_INV_ARG));
380       goto leave;
381     }
382
383   fname = make_filename (gnupg_homedir (), "swdb.lst", NULL);
384   fp = es_fopen (fname, "r");
385   if (!fp)
386     {
387       err = gpg_error_from_syserror ();
388       es_fprintf (out, "%s:%s:-::%u:::::::\n",
389                   name,
390                   current_version? current_version : "",
391                   gpg_err_code (err));
392       if (gpg_err_code (err) != GPG_ERR_ENOENT)
393         log_error (_("error opening '%s': %s\n"), fname, gpg_strerror (err));
394       goto leave;
395     }
396
397   /* Note that the parser uses the first occurrence of a matching
398    * values and ignores possible duplicated values.  */
399
400   maxlen = 2048; /* Set limit.  */
401   while ((len = es_read_line (fp, &line, &length_of_line, &maxlen)) > 0)
402     {
403       if (!maxlen)
404         {
405           err = gpg_error (GPG_ERR_LINE_TOO_LONG);
406           log_error (_("error reading '%s': %s\n"), fname, gpg_strerror (err));
407           goto leave;
408         }
409       /* Strip newline and carriage return, if present.  */
410       while (len > 0 && (line[len - 1] == '\n' || line[len - 1] == '\r'))
411         line[--len] = '\0';
412
413       if (split_fields (line, fields, DIM (fields)) < DIM(fields))
414         continue; /* Skip empty lines and names w/o a value.  */
415       if (*fields[0] == '#')
416         continue; /* Skip comments.  */
417
418       /* Record the meta data.  */
419       if (!*filedate && !strcmp (fields[0], ".filedate"))
420         {
421           string2isotime (filedate, fields[1]);
422           continue;
423         }
424       if (!*verified && !strcmp (fields[0], ".verified"))
425         {
426           string2isotime (verified, fields[1]);
427           continue;
428         }
429
430       /* Tokenize the name.  */
431       p = strrchr (fields[0], '_');
432       if (!p)
433         continue; /* Name w/o an underscore.  */
434       *p++ = 0;
435
436       /* Wait for the requested name.  */
437       if (!strcmp (fields[0], search_name))
438         {
439           if (!strcmp (p, "ver") && !value_ver)
440             value_ver = xstrdup (fields[1]);
441           else if (!strcmp (p, "date") && !*value_date)
442             string2isotime (value_date, fields[1]);
443           else if (!strcmp (p, "size") && !value_size)
444             value_size = xstrdup (fields[1]);
445           else if (!strcmp (p, "sha2") && !value_sha2)
446             value_sha2 = xstrdup (fields[1]);
447         }
448     }
449   if (len < 0 || es_ferror (fp))
450     {
451       err = gpg_error_from_syserror ();
452       log_error (_("error reading '%s': %s\n"), fname, gpg_strerror (err));
453       goto leave;
454     }
455
456   if (!*filedate || !*verified)
457     {
458       err = gpg_error (GPG_ERR_INV_TIME);
459       es_fprintf (out, "%s:%s:-::%u:::::::\n",
460                   name,
461                   current_version? current_version : "",
462                   gpg_err_code (err));
463       goto leave;
464     }
465
466   if (!value_ver)
467     {
468       es_fprintf (out, "%s:%s:?:::::::::\n",
469                   name,
470                   current_version? current_version : "");
471       goto leave;
472     }
473
474   if (value_size)
475     {
476       gpg_err_set_errno (0);
477       value_size_ul = strtoul (value_size, &p, 10);
478       if (errno)
479         value_size_ul = 0;
480       else if (*p == 'k')
481         value_size_ul *= 1024;
482     }
483
484   err = 0;
485   status = '-';
486   if (compare_version_strings (value_ver, NULL))
487     err = gpg_error (GPG_ERR_INV_VALUE);
488   else if (!current_version)
489     ;
490   else if (!(i = compare_version_strings (value_ver, current_version)))
491     status = 'c';
492   else if (i > 0)
493     status = 'u';
494   else
495     status = 'n';
496
497   es_fprintf (out, "%s:%s:%c::%d:%s:%s:%s:%s:%lu:%s:\n",
498               name,
499               current_version? current_version : "",
500               status,
501               err,
502               filedate,
503               verified,
504               value_ver,
505               value_date,
506               value_size_ul,
507               value_sha2? value_sha2 : "");
508
509  leave:
510   xfree (value_ver);
511   xfree (value_size);
512   xfree (value_sha2);
513   xfree (line);
514   es_fclose (fp);
515   xfree (fname);
516   xfree (self_version);
517 }
518
519
520 /* gpgconf main. */
521 int
522 main (int argc, char **argv)
523 {
524   gpg_error_t err;
525   ARGPARSE_ARGS pargs;
526   const char *fname;
527   int no_more_options = 0;
528   enum cmd_and_opt_values cmd = 0;
529   estream_t outfp = NULL;
530   int show_socket = 0;
531
532   early_system_init ();
533   gnupg_reopen_std (GPGCONF_NAME);
534   set_strusage (my_strusage);
535   log_set_prefix (GPGCONF_NAME, GPGRT_LOG_WITH_PREFIX);
536
537   /* Make sure that our subsystems are ready.  */
538   i18n_init();
539   init_common_subsystems (&argc, &argv);
540   gc_components_init ();
541
542   /* Parse the command line. */
543   pargs.argc  = &argc;
544   pargs.argv  = &argv;
545   pargs.flags =  1;  /* Do not remove the args.  */
546   while (!no_more_options && optfile_parse (NULL, NULL, NULL, &pargs, opts))
547     {
548       switch (pargs.r_opt)
549         {
550         case oOutput:    opt.outfile = pargs.r.ret_str; break;
551         case oQuiet:     opt.quiet = 1; break;
552         case oDryRun:    opt.dry_run = 1; break;
553         case oRuntime:
554           opt.runtime = 1;
555           break;
556         case oVerbose:   opt.verbose++; break;
557         case oNoVerbose: opt.verbose = 0; break;
558         case oHomedir:   gnupg_set_homedir (pargs.r.ret_str); break;
559         case oBuilddir:  gnupg_set_builddir (pargs.r.ret_str); break;
560         case oNull:      opt.null = 1; break;
561         case oStatusFD:
562           set_status_fd (translate_sys2libc_fd_int (pargs.r.ret_int, 1));
563           break;
564         case oShowSocket: show_socket = 1; break;
565
566         case aListDirs:
567         case aListComponents:
568         case aCheckPrograms:
569         case aListOptions:
570         case aChangeOptions:
571         case aCheckOptions:
572         case aApplyDefaults:
573         case aApplyProfile:
574         case aListConfig:
575         case aCheckConfig:
576         case aQuerySWDB:
577         case aReload:
578         case aLaunch:
579         case aKill:
580         case aCreateSocketDir:
581         case aRemoveSocketDir:
582           cmd = pargs.r_opt;
583           break;
584
585         default: pargs.err = 2; break;
586         }
587     }
588
589   if (log_get_errorcount (0))
590     gpgconf_failure (GPG_ERR_USER_2);
591
592   /* Print a warning if an argument looks like an option.  */
593   if (!opt.quiet && !(pargs.flags & ARGPARSE_FLAG_STOP_SEEN))
594     {
595       int i;
596
597       for (i=0; i < argc; i++)
598         if (argv[i][0] == '-' && argv[i][1] == '-')
599           log_info (_("Note: '%s' is not considered an option\n"), argv[i]);
600     }
601
602   fname = argc ? *argv : NULL;
603
604   switch (cmd)
605     {
606     case aListComponents:
607     default:
608       /* List all components. */
609       gc_component_list_components (get_outfp (&outfp));
610       break;
611
612     case aCheckPrograms:
613       /* Check all programs. */
614       gc_check_programs (get_outfp (&outfp));
615       break;
616
617     case aListOptions:
618     case aChangeOptions:
619     case aCheckOptions:
620       if (!fname)
621         {
622           es_fprintf (es_stderr, _("usage: %s [options] "), GPGCONF_NAME);
623           es_putc ('\n', es_stderr);
624           es_fputs (_("Need one component argument"), es_stderr);
625           es_putc ('\n', es_stderr);
626           gpgconf_failure (GPG_ERR_USER_2);
627         }
628       else
629         {
630           int idx = gc_component_find (fname);
631           if (idx < 0)
632             {
633               es_fputs (_("Component not found"), es_stderr);
634               es_putc ('\n', es_stderr);
635               gpgconf_failure (0);
636             }
637           if (cmd == aCheckOptions)
638             gc_component_check_options (idx, get_outfp (&outfp), NULL);
639           else
640             {
641               gc_component_retrieve_options (idx);
642               if (gc_process_gpgconf_conf (NULL, 1, 0, NULL))
643                 gpgconf_failure (0);
644               if (cmd == aListOptions)
645                 gc_component_list_options (idx, get_outfp (&outfp));
646               else if (cmd == aChangeOptions)
647                 gc_component_change_options (idx, es_stdin,
648                                              get_outfp (&outfp), 0);
649             }
650         }
651       break;
652
653     case aLaunch:
654     case aKill:
655       if (!fname)
656         {
657           es_fprintf (es_stderr, _("usage: %s [options] "), GPGCONF_NAME);
658           es_putc ('\n', es_stderr);
659           es_fputs (_("Need one component argument"), es_stderr);
660           es_putc ('\n', es_stderr);
661           gpgconf_failure (GPG_ERR_USER_2);
662         }
663       else if (!strcmp (fname, "all"))
664         {
665           if (cmd == aLaunch)
666             {
667               if (gc_component_launch (-1))
668                 gpgconf_failure (0);
669             }
670           else
671             {
672               gc_component_kill (-1);
673             }
674         }
675       else
676         {
677           /* Launch/Kill a given component.  */
678           int idx;
679
680           idx = gc_component_find (fname);
681           if (idx < 0)
682             {
683               es_fputs (_("Component not found"), es_stderr);
684               es_putc ('\n', es_stderr);
685               gpgconf_failure (0);
686             }
687           else if (cmd == aLaunch)
688             {
689               err = gc_component_launch (idx);
690               if (show_socket)
691                 {
692                   char *names[2];
693
694                   if (idx == GC_COMPONENT_GPG_AGENT)
695                     names[0] = "agent-socket";
696                   else if (idx == GC_COMPONENT_DIRMNGR)
697                     names[0] = "dirmngr-socket";
698                   else
699                     names[0] = NULL;
700                   names[1] = NULL;
701                   get_outfp (&outfp);
702                   list_dirs (outfp, names);
703                 }
704               if (err)
705                 gpgconf_failure (0);
706             }
707           else
708             {
709               /* We don't error out if the kill failed because this
710                  command should do nothing if the component is not
711                  running.  */
712               gc_component_kill (idx);
713             }
714         }
715       break;
716
717     case aReload:
718       if (!fname || !strcmp (fname, "all"))
719         {
720           /* Reload all.  */
721           gc_component_reload (-1);
722         }
723       else
724         {
725           /* Reload given component.  */
726           int idx;
727
728           idx = gc_component_find (fname);
729           if (idx < 0)
730             {
731               es_fputs (_("Component not found"), es_stderr);
732               es_putc ('\n', es_stderr);
733               gpgconf_failure (0);
734             }
735           else
736             {
737               gc_component_reload (idx);
738             }
739         }
740       break;
741
742     case aListConfig:
743       if (gc_process_gpgconf_conf (fname, 0, 0, get_outfp (&outfp)))
744         gpgconf_failure (0);
745       break;
746
747     case aCheckConfig:
748       if (gc_process_gpgconf_conf (fname, 0, 0, NULL))
749         gpgconf_failure (0);
750       break;
751
752     case aApplyDefaults:
753       if (fname)
754         {
755           es_fprintf (es_stderr, _("usage: %s [options] "), GPGCONF_NAME);
756           es_putc ('\n', es_stderr);
757           es_fputs (_("No argument allowed"), es_stderr);
758           es_putc ('\n', es_stderr);
759           gpgconf_failure (GPG_ERR_USER_2);
760         }
761       gc_component_retrieve_options (-1);
762       if (gc_process_gpgconf_conf (NULL, 1, 1, NULL))
763         gpgconf_failure (0);
764       break;
765
766     case aApplyProfile:
767       gc_component_retrieve_options (-1);
768       if (gc_apply_profile (fname))
769         gpgconf_failure (0);
770       break;
771
772     case aListDirs:
773       /* Show the system configuration directories for gpgconf.  */
774       get_outfp (&outfp);
775       list_dirs (outfp, argc? argv : NULL);
776       break;
777
778     case aQuerySWDB:
779       /* Query the software version database.  */
780       if (!fname || argc > 2)
781         {
782           es_fprintf (es_stderr, "usage: %s --query-swdb NAME [VERSION]\n",
783                       GPGCONF_NAME);
784           gpgconf_failure (GPG_ERR_USER_2);
785         }
786       get_outfp (&outfp);
787       query_swdb (outfp, fname, argc > 1? argv[1] : NULL);
788       break;
789
790     case aCreateSocketDir:
791       {
792         char *socketdir;
793         unsigned int flags;
794
795         /* Make sure that the top /run/user/UID/gnupg dir has been
796          * created.  */
797         gnupg_socketdir ();
798
799         /* Check the /var/run dir.  */
800         socketdir = _gnupg_socketdir_internal (1, &flags);
801         if ((flags & 64) && !opt.dry_run)
802           {
803             /* No sub dir - create it. */
804             if (gnupg_mkdir (socketdir, "-rwx"))
805               gc_error (1, errno, "error creating '%s'", socketdir);
806             /* Try again.  */
807             xfree (socketdir);
808             socketdir = _gnupg_socketdir_internal (1, &flags);
809           }
810
811         /* Give some info.  */
812         if ( (flags & ~32) || opt.verbose || opt.dry_run)
813           {
814             log_info ("socketdir is '%s'\n", socketdir);
815             if ((flags &   1)) log_info ("\tgeneral error\n");
816             if ((flags &   2)) log_info ("\tno /run/user dir\n");
817             if ((flags &   4)) log_info ("\tbad permissions\n");
818             if ((flags &   8)) log_info ("\tbad permissions (subdir)\n");
819             if ((flags &  16)) log_info ("\tmkdir failed\n");
820             if ((flags &  32)) log_info ("\tnon-default homedir\n");
821             if ((flags &  64)) log_info ("\tno such subdir\n");
822             if ((flags & 128)) log_info ("\tusing homedir as fallback\n");
823           }
824
825         if ((flags & ~32) && !opt.dry_run)
826           gc_error (1, 0, "error creating socket directory");
827
828         xfree (socketdir);
829       }
830       break;
831
832     case aRemoveSocketDir:
833       {
834         char *socketdir;
835         unsigned int flags;
836
837         /* Check the /var/run dir.  */
838         socketdir = _gnupg_socketdir_internal (1, &flags);
839         if ((flags & 128))
840           log_info ("ignoring request to remove non /run/user socket dir\n");
841         else if (opt.dry_run)
842           ;
843         else if (rmdir (socketdir))
844           {
845             /* If the director is not empty we first try to delete
846              * socket files.  */
847             err = gpg_error_from_syserror ();
848             if (gpg_err_code (err) == GPG_ERR_ENOTEMPTY
849                 || gpg_err_code (err) == GPG_ERR_EEXIST)
850               {
851                 static const char * const names[] = {
852                   GPG_AGENT_SOCK_NAME,
853                   GPG_AGENT_EXTRA_SOCK_NAME,
854                   GPG_AGENT_BROWSER_SOCK_NAME,
855                   GPG_AGENT_SSH_SOCK_NAME,
856                   SCDAEMON_SOCK_NAME,
857                   DIRMNGR_SOCK_NAME
858                 };
859                 int i;
860                 char *p;
861
862                 for (i=0; i < DIM(names); i++)
863                   {
864                     p = strconcat (socketdir , "/", names[i], NULL);
865                     if (p)
866                       gnupg_remove (p);
867                     xfree (p);
868                   }
869                 if (rmdir (socketdir))
870                   gc_error (1, 0, "error removing '%s': %s",
871                             socketdir, gpg_strerror (err));
872               }
873             else if (gpg_err_code (err) == GPG_ERR_ENOENT)
874               gc_error (0, 0, "warning: removing '%s' failed: %s",
875                         socketdir, gpg_strerror (err));
876             else
877               gc_error (1, 0, "error removing '%s': %s",
878                         socketdir, gpg_strerror (err));
879           }
880
881         xfree (socketdir);
882       }
883       break;
884
885     }
886
887   if (outfp != es_stdout)
888     if (es_fclose (outfp))
889       gc_error (1, errno, "error closing '%s'", opt.outfile);
890
891
892   if (log_get_errorcount (0))
893     gpgconf_failure (0);
894   else
895     gpgconf_write_status (STATUS_SUCCESS, NULL);
896   return 0;
897 }
898
899
900 void
901 gpgconf_failure (gpg_error_t err)
902 {
903   if (!err)
904     err = gpg_error (GPG_ERR_GENERAL);
905   gpgconf_write_status
906     (STATUS_FAILURE, "- %u",
907      gpg_err_code (err) == GPG_ERR_USER_2? GPG_ERR_EINVAL : err);
908   exit (gpg_err_code (err) == GPG_ERR_USER_2? 2 : 1);
909 }