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