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