* configure.ac: Require libgcrypt 1.1.94.
[gnupg.git] / agent / gpg-agent.c
1 /* gpg-agent.c  -  The GnuPG Agent
2  *      Copyright (C) 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
3  *
4  * This file is part of GnuPG.
5  *
6  * GnuPG is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * GnuPG is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
19  */
20
21 #include <config.h>
22
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <stddef.h>
26 #include <stdarg.h>
27 #include <string.h>
28 #include <errno.h>
29 #include <assert.h>
30 #include <time.h>
31 #include <fcntl.h>
32 #include <sys/socket.h>
33 #include <sys/un.h>
34 #include <unistd.h>
35 #include <signal.h>
36 #ifdef USE_GNU_PTH
37 # include <pth.h>
38 #endif
39
40 #define JNLIB_NEED_LOG_LOGV
41 #include "agent.h"
42 #include <assuan.h> /* malloc hooks */
43
44 #include "i18n.h"
45 #include "sysutils.h"
46
47
48 enum cmd_and_opt_values 
49 { aNull = 0,
50   oCsh            = 'c',
51   oQuiet          = 'q',
52   oSh             = 's',
53   oVerbose        = 'v',
54
55   oNoVerbose = 500,
56   aGPGConfList,
57   oOptions,
58   oDebug,
59   oDebugAll,
60   oDebugLevel,
61   oDebugWait,
62   oNoGreeting,
63   oNoOptions,
64   oHomedir,
65   oNoDetach,
66   oNoGrab,
67   oLogFile,
68   oServer,
69   oDaemon,
70   oBatch,
71
72   oPinentryProgram,
73   oDisplay,
74   oTTYname,
75   oTTYtype,
76   oLCctype,
77   oLCmessages,
78   oScdaemonProgram,
79   oDefCacheTTL,
80   oDisablePth,
81
82   oIgnoreCacheForSigning,
83   oKeepTTY,
84   oKeepDISPLAY,
85
86 aTest };
87
88
89
90 static ARGPARSE_OPTS opts[] = {
91
92   { aGPGConfList, "gpgconf-list", 256, "@" },
93   
94   { 301, NULL, 0, N_("@Options:\n ") },
95
96   { oServer,   "server",     0, N_("run in server mode (foreground)") },
97   { oDaemon,   "daemon",     0, N_("run in daemon mode (background)") },
98   { oVerbose, "verbose",     0, N_("verbose") },
99   { oQuiet,     "quiet",     0, N_("be somewhat more quiet") },
100   { oSh,        "sh",        0, N_("sh-style command output") },
101   { oCsh,       "csh",       0, N_("csh-style command output") },
102   { oOptions, "options"  , 2, N_("|FILE|read options from FILE")},
103   { oDebug,     "debug"     ,4|16, "@"},
104   { oDebugAll, "debug-all"     ,0, "@"},
105   { oDebugLevel, "debug-level" ,2, "@"},
106   { oDebugWait,"debug-wait",1, "@"},
107   { oNoDetach, "no-detach" ,0, N_("do not detach from the console")},
108   { oNoGrab, "no-grab"     ,0, N_("do not grab keyboard and mouse")},
109   { oLogFile, "log-file"   ,2, N_("use a log file for the server")},
110   { oDisablePth, "disable-pth", 0, N_("do not allow multiple connections")},
111
112   { oPinentryProgram, "pinentry-program", 2 , "path to PIN Entry program" },
113   { oDisplay,    "display",     2, "set the display" },
114   { oTTYname,    "ttyname",     2, "set the tty terminal node name" },
115   { oTTYtype,    "ttytype",     2, "set the tty terminal type" },
116   { oLCctype,    "lc-ctype",    2, "set the tty LC_CTYPE value" },
117   { oLCmessages, "lc-messages", 2, "set the tty LC_MESSAGES value" },
118
119   { oScdaemonProgram, "scdaemon-program", 2 , "path to SCdaemon program" },
120   { oDefCacheTTL, "default-cache-ttl", 4,
121                                  "|N|expire cached PINs after N seconds"},
122   { oIgnoreCacheForSigning, "ignore-cache-for-signing", 0,
123                                  "do not use the PIN cache when signing"},
124   { oKeepTTY, "keep-tty", 0,  N_("ignore requests to change the TTY")},
125   { oKeepDISPLAY, "keep-display",
126                           0, N_("ignore requests to change the X display")},
127   {0}
128 };
129
130
131 #define DEFAULT_CACHE_TTL (10*60) /* 10 minutes */
132
133 static volatile int caught_fatal_sig = 0;
134
135 /* flag to indicate that a shutdown was requested */
136 static int shutdown_pending;
137
138
139 /* It is possible that we are currently running under setuid permissions */
140 static int maybe_setuid = 1;
141
142 /* Name of the communication socket */
143 static char socket_name[128];
144
145 /* Default values for options passed to the pinentry. */
146 static char *default_display;
147 static char *default_ttyname;
148 static char *default_ttytype;
149 static char *default_lc_ctype;
150 static char *default_lc_messages;
151
152 /* Name of a config file, which will be reread on a HUP if it is not NULL. */
153 static char *config_filename;
154
155 /* Helper to implement --debug-level */
156 static const char *debug_level;
157
158 /* Local prototypes. */
159 static void create_directories (void);
160 #ifdef USE_GNU_PTH
161 static void handle_connections (int listen_fd);
162
163 /* Pth wrapper function definitions. */
164 GCRY_THREAD_OPTION_PTH_IMPL;
165
166 #endif /*USE_GNU_PTH*/
167
168
169
170 static const char *
171 my_strusage (int level)
172 {
173   const char *p;
174   switch (level)
175     {
176     case 11: p = "gpg-agent (GnuPG)";
177       break;
178     case 13: p = VERSION; break;
179     case 17: p = PRINTABLE_OS_NAME; break;
180     case 19: p = _("Please report bugs to <" PACKAGE_BUGREPORT ">.\n");
181       break;
182     case 1:
183     case 40: p =  _("Usage: gpg-agent [options] (-h for help)");
184       break;
185     case 41: p =  _("Syntax: gpg-agent [options] [command [args]]\n"
186                     "Secret key management for GnuPG\n");
187     break;
188     
189     default: p = NULL;
190     }
191   return p;
192 }
193
194
195
196 static void
197 i18n_init (void)
198 {
199 #ifdef USE_SIMPLE_GETTEXT
200     set_gettext_file( PACKAGE_GT );
201 #else
202 #ifdef ENABLE_NLS
203     setlocale (LC_ALL, "");
204     bindtextdomain (PACKAGE_GT, LOCALEDIR);
205     textdomain (PACKAGE_GT);
206 #endif
207 #endif
208 }
209
210
211
212 /* Used by gcry for logging */
213 static void
214 my_gcry_logger (void *dummy, int level, const char *fmt, va_list arg_ptr)
215 {
216   /* translate the log levels */
217   switch (level)
218     {
219     case GCRY_LOG_CONT: level = JNLIB_LOG_CONT; break;
220     case GCRY_LOG_INFO: level = JNLIB_LOG_INFO; break;
221     case GCRY_LOG_WARN: level = JNLIB_LOG_WARN; break;
222     case GCRY_LOG_ERROR:level = JNLIB_LOG_ERROR; break;
223     case GCRY_LOG_FATAL:level = JNLIB_LOG_FATAL; break;
224     case GCRY_LOG_BUG:  level = JNLIB_LOG_BUG; break;
225     case GCRY_LOG_DEBUG:level = JNLIB_LOG_DEBUG; break;
226     default:            level = JNLIB_LOG_ERROR; break;  
227     }
228   log_logv (level, fmt, arg_ptr);
229 }
230
231
232 /* Setup the debugging.  With a LEVEL of NULL only the active debug
233    flags are propagated to the subsystems.  With LEVEL set, a specific
234    set of debug flags is set; thus overriding all flags already
235    set. Note that we don't fail here, because it is important to keep
236    gpg-agent running even after re-reading the options due to a
237    SIGHUP. */
238 static void
239 set_debug (void)
240 {
241   if (!debug_level)
242     ;
243   else if (!strcmp (debug_level, "none"))
244     opt.debug = 0;
245   else if (!strcmp (debug_level, "basic"))
246     opt.debug = DBG_ASSUAN_VALUE;
247   else if (!strcmp (debug_level, "advanced"))
248     opt.debug = DBG_ASSUAN_VALUE|DBG_COMMAND_VALUE;
249   else if (!strcmp (debug_level, "expert"))
250     opt.debug = (DBG_ASSUAN_VALUE|DBG_COMMAND_VALUE
251                  |DBG_CACHE_VALUE);
252   else if (!strcmp (debug_level, "guru"))
253     opt.debug = ~0;
254   else
255     {
256       log_error (_("invalid debug-level `%s' given\n"), debug_level);
257       opt.debug = 0; /* Reset debugging, so that prior debug
258                         statements won't have an undesired effect. */
259     }
260
261   if (opt.debug && !opt.verbose)
262     opt.verbose = 1;
263   if (opt.debug && opt.quiet)
264     opt.quiet = 0;
265
266   if (opt.debug & DBG_MPI_VALUE)
267     gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 2);
268   if (opt.debug & DBG_CRYPTO_VALUE )
269     gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 1);
270   gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
271 }
272  
273
274 static void
275 cleanup (void)
276 {
277   if (*socket_name)
278     {
279       char *p;
280
281       remove (socket_name);
282       p = strrchr (socket_name, '/');
283       if (p)
284         {
285           *p = 0;
286           rmdir (socket_name);
287           *p = '/';
288         }
289       *socket_name = 0;
290     }
291 }
292
293
294 static RETSIGTYPE
295 cleanup_sh (int sig)
296 {
297   if (caught_fatal_sig)
298     raise (sig);
299   caught_fatal_sig = 1;
300
301   /* gcry_control( GCRYCTL_TERM_SECMEM );*/
302   cleanup ();
303
304 #ifndef HAVE_DOSISH_SYSTEM
305   {     /* reset action to default action and raise signal again */
306     struct sigaction nact;
307     nact.sa_handler = SIG_DFL;
308     sigemptyset( &nact.sa_mask );
309     nact.sa_flags = 0;
310     sigaction( sig, &nact, NULL);
311   }
312 #endif
313   raise( sig );
314 }
315
316
317 /* Handle options which are allowed to be reset after program start.
318    Return true when the current option in PARGS could be handled and
319    false if not.  As a special feature, passing a value of NULL for
320    PARGS, resets the options to the default. */
321 static int
322 parse_rereadable_options (ARGPARSE_ARGS *pargs)
323 {
324   if (!pargs)
325     { /* reset mode */
326       opt.quiet = 0;
327       opt.verbose = 0;
328       opt.debug = 0;
329       opt.no_grab = 0;
330       opt.pinentry_program = NULL;
331       opt.scdaemon_program = NULL;
332       opt.def_cache_ttl = DEFAULT_CACHE_TTL;
333       opt.ignore_cache_for_signing = 0;
334       return 1;
335     }
336
337   switch (pargs->r_opt)
338     {
339     case oQuiet: opt.quiet = 1; break;
340     case oVerbose: opt.verbose++; break;
341
342     case oDebug: opt.debug |= pargs->r.ret_ulong; break;
343     case oDebugAll: opt.debug = ~0; break;
344     case oDebugLevel: debug_level = pargs->r.ret_str; break;
345
346     case oNoGrab: opt.no_grab = 1; break;
347       
348     case oPinentryProgram: opt.pinentry_program = pargs->r.ret_str; break;
349     case oScdaemonProgram: opt.scdaemon_program = pargs->r.ret_str; break;
350
351     case oDefCacheTTL: opt.def_cache_ttl = pargs->r.ret_ulong; break;
352       
353     case oIgnoreCacheForSigning: opt.ignore_cache_for_signing = 1; break;
354
355     default:
356       return 0; /* not handled */
357     }
358   return 1; /* handled */
359 }
360
361
362 int
363 main (int argc, char **argv )
364 {
365   ARGPARSE_ARGS pargs;
366   int orig_argc;
367   int may_coredump;
368   char **orig_argv;
369   FILE *configfp = NULL;
370   char *configname = NULL;
371   const char *shell;
372   unsigned configlineno;
373   int parse_debug = 0;
374   int default_config =1;
375   int greeting = 0;
376   int nogreeting = 0;
377   int pipe_server = 0;
378   int is_daemon = 0;
379   int nodetach = 0;
380   int csh_style = 0;
381   char *logfile = NULL;
382   int debug_wait = 0;
383   int disable_pth = 0;
384   int gpgconf_list = 0;
385   gpg_error_t err;
386
387   set_strusage (my_strusage);
388   gcry_control (GCRYCTL_SUSPEND_SECMEM_WARN);
389   /* Please note that we may running SUID(ROOT), so be very CAREFUL
390      when adding any stuff between here and the call to INIT_SECMEM()
391      somewhere after the option parsing */
392   log_set_prefix ("gpg-agent", 1|4); 
393
394   /* Try to auto set the character set.  */
395   set_native_charset (NULL); 
396
397   i18n_init ();
398
399   /* Libgcrypt requires us to register the threading model first.
400      Note that this will also do the pth_init. */
401 #ifdef USE_GNU_PTH
402   err = gcry_control (GCRYCTL_SET_THREAD_CBS, &gcry_threads_pth);
403   if (err)
404     {
405       log_fatal ("can't register GNU Pth with Libgcrypt: %s\n",
406                  gpg_strerror (err));
407     }
408 #endif /*USE_GNU_PTH*/
409
410   /* Check that the libraries are suitable.  Do it here because
411      the option parsing may need services of the library. */
412   if (!gcry_check_version (NEED_LIBGCRYPT_VERSION) )
413     {
414       log_fatal( _("libgcrypt is too old (need %s, have %s)\n"),
415                  NEED_LIBGCRYPT_VERSION, gcry_check_version (NULL) );
416     }
417
418   assuan_set_malloc_hooks (gcry_malloc, gcry_realloc, gcry_free);
419   assuan_set_assuan_log_stream (log_get_stream ());
420   assuan_set_assuan_log_prefix (log_get_prefix (NULL));
421
422   gcry_set_log_handler (my_gcry_logger, NULL);
423   gcry_control (GCRYCTL_USE_SECURE_RNDPOOL);
424
425   may_coredump = disable_core_dumps ();
426
427   parse_rereadable_options (NULL); /* Reset them to default values. */
428
429   shell = getenv ("SHELL");
430   if (shell && strlen (shell) >= 3 && !strcmp (shell+strlen (shell)-3, "csh") )
431     csh_style = 1;
432   
433   opt.homedir = getenv("GNUPGHOME");
434   if (!opt.homedir || !*opt.homedir)
435     opt.homedir = GNUPG_DEFAULT_HOMEDIR;
436
437
438   /* check whether we have a config file on the commandline */
439   orig_argc = argc;
440   orig_argv = argv;
441   pargs.argc = &argc;
442   pargs.argv = &argv;
443   pargs.flags= 1|(1<<6);  /* do not remove the args, ignore version */
444   while (arg_parse( &pargs, opts))
445     {
446       if (pargs.r_opt == oDebug || pargs.r_opt == oDebugAll)
447         parse_debug++;
448       else if (pargs.r_opt == oOptions)
449         { /* yes there is one, so we do not try the default one, but
450              read the option file when it is encountered at the
451              commandline */
452           default_config = 0;
453         }
454         else if (pargs.r_opt == oNoOptions)
455           default_config = 0; /* --no-options */
456         else if (pargs.r_opt == oHomedir)
457           opt.homedir = pargs.r.ret_str;
458     }
459
460   /* initialize the secure memory. */
461   gcry_control (GCRYCTL_INIT_SECMEM, 16384, 0);
462   maybe_setuid = 0;
463
464   /* 
465      Now we are now working under our real uid 
466   */
467
468
469   if (default_config)
470     configname = make_filename (opt.homedir, "gpg-agent.conf", NULL );
471   
472   argc = orig_argc;
473   argv = orig_argv;
474   pargs.argc = &argc;
475   pargs.argv = &argv;
476   pargs.flags=  1;  /* do not remove the args */
477  next_pass:
478   if (configname)
479     {
480       configlineno = 0;
481       configfp = fopen (configname, "r");
482       if (!configfp)
483         {
484           if (default_config)
485             {
486               if( parse_debug )
487                 log_info (_("NOTE: no default option file `%s'\n"),
488                           configname );
489             }
490           else
491             {
492               log_error (_("option file `%s': %s\n"),
493                          configname, strerror(errno) );
494               exit(2);
495             }
496           xfree (configname); 
497           configname = NULL;
498         }
499       if (parse_debug && configname )
500         log_info (_("reading options from `%s'\n"), configname );
501       default_config = 0;
502     }
503
504   while (optfile_parse( configfp, configname, &configlineno, &pargs, opts) )
505     {
506       if (parse_rereadable_options (&pargs))
507         continue; /* Already handled */
508       switch (pargs.r_opt)
509         {
510         case aGPGConfList: gpgconf_list = 1; break;
511         case oBatch: opt.batch=1; break;
512
513         case oDebugWait: debug_wait = pargs.r.ret_int; break;
514
515         case oOptions:
516           /* config files may not be nested (silently ignore them) */
517           if (!configfp)
518             {
519                 xfree(configname);
520                 configname = xstrdup(pargs.r.ret_str);
521                 goto next_pass;
522             }
523           break;
524         case oNoGreeting: nogreeting = 1; break;
525         case oNoVerbose: opt.verbose = 0; break;
526         case oNoOptions: break; /* no-options */
527         case oHomedir: opt.homedir = pargs.r.ret_str; break;
528         case oNoDetach: nodetach = 1; break;
529         case oLogFile: logfile = pargs.r.ret_str; break;
530         case oCsh: csh_style = 1; break;
531         case oSh: csh_style = 0; break;
532         case oServer: pipe_server = 1; break;
533         case oDaemon: is_daemon = 1; break;
534         case oDisablePth: disable_pth = 1; break;
535
536         case oDisplay: default_display = xstrdup (pargs.r.ret_str); break;
537         case oTTYname: default_ttyname = xstrdup (pargs.r.ret_str); break;
538         case oTTYtype: default_ttytype = xstrdup (pargs.r.ret_str); break;
539         case oLCctype: default_lc_ctype = xstrdup (pargs.r.ret_str); break;
540         case oLCmessages: default_lc_messages = xstrdup (pargs.r.ret_str);
541           break;
542
543         case oKeepTTY: opt.keep_tty = 1; break;
544         case oKeepDISPLAY: opt.keep_display = 1; break;
545
546         default : pargs.err = configfp? 1:2; break;
547         }
548     }
549   if (configfp)
550     {
551       fclose( configfp );
552       configfp = NULL;
553       /* Keep a copy of the name so that it can be read on SIGHUP. */
554       config_filename = configname;
555       configname = NULL;
556       goto next_pass;
557     }
558   xfree (configname);
559   configname = NULL;
560   if (log_get_errorcount(0))
561     exit(2);
562   if (nogreeting )
563     greeting = 0;
564
565   if (greeting)
566     {
567       fprintf (stderr, "%s %s; %s\n",
568                  strusage(11), strusage(13), strusage(14) );
569       fprintf (stderr, "%s\n", strusage(15) );
570     }
571 #ifdef IS_DEVELOPMENT_VERSION
572   log_info ("NOTE: this is a development version!\n");
573 #endif
574
575   set_debug ();
576   
577   if (atexit (cleanup))
578     {
579       log_error ("atexit failed\n");
580       cleanup ();
581       exit (1);
582     }
583
584   create_directories ();
585
586   if (debug_wait && pipe_server)
587     {
588       log_debug ("waiting for debugger - my pid is %u .....\n",
589                  (unsigned int)getpid());
590       sleep (debug_wait);
591       log_debug ("... okay\n");
592     }
593   
594   if (gpgconf_list)
595     {
596       char *filename;
597
598       /* List options and default values in the GPG Conf format.  */
599
600       /* The following list is taken from gnupg/tools/gpgconf-comp.c.  */
601       /* Option flags.  YOU MUST NOT CHANGE THE NUMBERS OF THE EXISTING
602          FLAGS, AS THEY ARE PART OF THE EXTERNAL INTERFACE.  */
603 #define GC_OPT_FLAG_NONE        0UL
604       /* The RUNTIME flag for an option indicates that the option can be
605          changed at runtime.  */
606 #define GC_OPT_FLAG_RUNTIME     (1UL << 3)
607       /* The DEFAULT flag for an option indicates that the option has a
608          default value.  */
609 #define GC_OPT_FLAG_DEFAULT     (1UL << 4)
610       /* The DEF_DESC flag for an option indicates that the option has a
611          default, which is described by the value of the default field.  */
612 #define GC_OPT_FLAG_DEF_DESC    (1UL << 5)
613       /* The NO_ARG_DESC flag for an option indicates that the argument has
614          a default, which is described by the value of the ARGDEF field.  */
615 #define GC_OPT_FLAG_NO_ARG_DESC (1UL << 6)
616
617       filename = make_filename (opt.homedir, "gpg-agent.conf", NULL );
618       printf ("gpgconf-gpg-agent.conf:%lu:\"%s\n",
619               GC_OPT_FLAG_DEFAULT, filename);
620       xfree (filename);
621
622       printf ("verbose:%lu:\n"
623               "quiet:%lu:\n"
624               "debug-level:%lu:\"none:\n"
625               "log-file:%lu:\n",
626               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME,
627               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME,
628               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME,
629               GC_OPT_FLAG_NONE );
630       printf ("default-cache-ttl:%lu:%d:\n",
631               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME, DEFAULT_CACHE_TTL );
632       printf ("no-grab:%lu:\n", 
633               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
634       printf ("ignore-cache-for-signing:%lu:\n",
635               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
636
637       agent_exit (0);
638     }
639
640   if (!pipe_server && !is_daemon)
641     log_info (_("please use the option `--daemon'"
642                 " to run the program in the background\n"));
643   
644 #ifdef ENABLE_NLS
645   /* gpg-agent usually does not output any messages because it runs in
646      the background.  For log files it is acceptable to have messages
647      always encoded in utf-8.  We switch here to utf-8, so that
648      commands like --help still give native messages.  It is far
649      easier to switch only once instead of for every message and it
650      actually helps when more then one thread is active (avoids an
651      extra copy step). */
652     bind_textdomain_codeset (PACKAGE_GT, "UTF-8");
653 #endif
654
655   /* now start with logging to a file if this is desired */
656   if (logfile)
657     {
658       log_set_file (logfile);
659       log_set_prefix (NULL, 1|2|4);
660     }
661
662   /* Make sure that we have a default ttyname. */
663   if (!default_ttyname && ttyname (1))
664     default_ttyname = xstrdup (ttyname (1));
665   if (!default_ttytype && getenv ("TERM"))
666     default_ttytype = xstrdup (getenv ("TERM"));
667
668   if (pipe_server)
669     { /* this is the simple pipe based server */
670       start_command_handler (-1, -1);
671     }
672   else if (!is_daemon)
673     ;
674   else
675     { /* regular server mode */
676       int fd;
677       pid_t pid;
678       int len;
679       struct sockaddr_un serv_addr;
680       char *p;
681
682       /* Remove the DISPLAY variable so that a pinentry does not
683          default to a specific display.  There is still a default
684          display when gpg-agent weas started using --display or a
685          client requested this using an OPTION command. */
686       if (!opt.keep_display)
687         unsetenv ("DISPLAY");
688
689       *socket_name = 0;
690       snprintf (socket_name, DIM(socket_name)-1,
691                 "/tmp/gpg-XXXXXX/S.gpg-agent");
692       socket_name[DIM(socket_name)-1] = 0;
693       p = strrchr (socket_name, '/');
694       if (!p)
695         BUG ();
696       *p = 0;;
697       if (!mkdtemp(socket_name))
698         {
699           log_error ("can't create directory `%s': %s\n",
700                      socket_name, strerror(errno) );
701           exit (1);
702         }
703       *p = '/';
704
705       if (strchr (socket_name, ':') )
706         {
707           log_error ("colons are not allowed in the socket name\n");
708           exit (1);
709         }
710       if (strlen (socket_name)+1 >= sizeof serv_addr.sun_path ) 
711         {
712           log_error ("name of socket too long\n");
713           exit (1);
714         }
715    
716
717       fd = socket (AF_UNIX, SOCK_STREAM, 0);
718       if (fd == -1)
719         {
720           log_error ("can't create socket: %s\n", strerror(errno) );
721           exit (1);
722         }
723
724       memset (&serv_addr, 0, sizeof serv_addr);
725       serv_addr.sun_family = AF_UNIX;
726       strcpy (serv_addr.sun_path, socket_name);
727       len = (offsetof (struct sockaddr_un, sun_path)
728              + strlen(serv_addr.sun_path) + 1);
729
730       if (bind (fd, (struct sockaddr*)&serv_addr, len) == -1)
731         {
732           log_error ("error binding socket to `%s': %s\n",
733                      serv_addr.sun_path, strerror (errno) );
734           close (fd);
735           exit (1);
736         }
737   
738       if (listen (fd, 5 ) == -1)
739         {
740           log_error ("listen() failed: %s\n", strerror (errno));
741           close (fd);
742           exit (1);
743         }
744
745       if (opt.verbose)
746         log_info ("listening on socket `%s'\n", socket_name );
747
748
749       fflush (NULL);
750       pid = fork ();
751       if (pid == (pid_t)-1) 
752         {
753           log_fatal ("fork failed: %s\n", strerror (errno) );
754           exit (1);
755         }
756       else if (pid) 
757         { /* we are the parent */
758           char *infostr;
759           
760           close (fd);
761           
762           /* create the info string: <name>:<pid>:<protocol_version> */
763           if (asprintf (&infostr, "GPG_AGENT_INFO=%s:%lu:1",
764                         socket_name, (ulong)pid ) < 0)
765             {
766               log_error ("out of core\n");
767               kill (pid, SIGTERM);
768               exit (1);
769             }
770           *socket_name = 0; /* don't let cleanup() remove the socket -
771                                the child should do this from now on */
772           if (argc) 
773             { /* run the program given on the commandline */
774               if (putenv (infostr))
775                 {
776                   log_error ("failed to set environment: %s\n",
777                              strerror (errno) );
778                   kill (pid, SIGTERM );
779                   exit (1);
780                 }
781               execvp (argv[0], argv);
782               log_error ("failed to run the command: %s\n", strerror (errno));
783               kill (pid, SIGTERM);
784               exit (1);
785             }
786           else
787             {
788               /* print the environment string, so that the caller can use
789                  shell's eval to set it */
790               if (csh_style)
791                 {
792                   *strchr (infostr, '=') = ' ';
793                   printf ( "setenv %s\n", infostr);
794                 }
795               else
796                 {
797                   printf ( "%s; export GPG_AGENT_INFO;\n", infostr);
798                 }
799               free (infostr);
800               exit (0); 
801             }
802           /*NEVER REACHED*/
803         } /* end parent */
804       
805
806       /* this is the child */
807
808       /* detach from tty and put process into a new session */
809       if (!nodetach )
810         { 
811           int i;
812
813           /* close stdin, stdout and stderr unless it is the log stream */
814           for (i=0; i <= 2; i++) 
815             {
816               if ( log_get_fd () != i)
817                 close (i);
818             }
819           if (setsid() == -1)
820             {
821               log_error ("setsid() failed: %s\n", strerror(errno) );
822               cleanup ();
823               exit (1);
824             }
825           opt.running_detached = 1;
826         }
827
828       if (chdir("/"))
829         {
830           log_error ("chdir to / failed: %s\n", strerror (errno));
831           exit (1);
832         }
833
834
835 #ifdef USE_GNU_PTH
836       if (!disable_pth)
837         {
838           struct sigaction sa;
839
840           sa.sa_handler = SIG_IGN;
841           sigemptyset (&sa.sa_mask);
842           sa.sa_flags = 0;
843           sigaction (SIGPIPE, &sa, NULL);
844           handle_connections (fd);
845         }
846       else
847 #endif /*!USE_GNU_PTH*/
848       /* setup signals */
849         {
850           struct sigaction oact, nact;
851           
852           nact.sa_handler = cleanup_sh;
853           sigemptyset (&nact.sa_mask);
854           nact.sa_flags = 0;
855           
856           sigaction (SIGHUP, NULL, &oact);
857           if (oact.sa_handler != SIG_IGN)
858             sigaction (SIGHUP, &nact, NULL);
859           sigaction( SIGTERM, NULL, &oact );
860           if (oact.sa_handler != SIG_IGN)
861             sigaction (SIGTERM, &nact, NULL);
862           nact.sa_handler = SIG_IGN;
863           sigaction (SIGPIPE, &nact, NULL);
864           sigaction (SIGINT, &nact, NULL);
865
866           start_command_handler (fd, -1);
867         }
868       close (fd);
869     }
870   
871   return 0;
872 }
873
874 void
875 agent_exit (int rc)
876 {
877   /*FIXME: update_random_seed_file();*/
878 #if 1
879   /* at this time a bit annoying */
880   if (opt.debug & DBG_MEMSTAT_VALUE)
881     {
882       gcry_control( GCRYCTL_DUMP_MEMORY_STATS );
883       gcry_control( GCRYCTL_DUMP_RANDOM_STATS );
884     }
885   if (opt.debug)
886     gcry_control (GCRYCTL_DUMP_SECMEM_STATS );
887 #endif
888   gcry_control (GCRYCTL_TERM_SECMEM );
889   rc = rc? rc : log_get_errorcount(0)? 2 : 0;
890   exit (rc);
891 }
892
893
894 void
895 agent_init_default_ctrl (struct server_control_s *ctrl)
896 {
897   ctrl->connection_fd = -1;
898
899   /* Note we ignore malloc errors because we can't do much about it
900      and the request will fail anyway shortly after this
901      initialization. */
902   if (ctrl->display)
903     free (ctrl->display);
904   ctrl->display = default_display? strdup (default_display) : NULL;
905
906   if (ctrl->ttyname)
907     free (ctrl->ttyname);
908   ctrl->ttyname = default_ttyname? strdup (default_ttyname) : NULL;
909
910   if (ctrl->ttytype)
911     free (ctrl->ttytype);
912   ctrl->ttytype = default_ttytype? strdup (default_ttytype) : NULL;
913
914   if (ctrl->lc_ctype)
915     free (ctrl->lc_ctype);
916   ctrl->lc_ctype = default_lc_ctype? strdup (default_lc_ctype) : NULL;
917
918   if (ctrl->lc_messages)
919     free (ctrl->lc_messages);
920   ctrl->lc_messages = default_lc_messages? strdup (default_lc_messages) : NULL;
921 }
922
923
924 /* Reread parts of the configuration.  Note, that this function is
925    obviously not thread-safe and should only be called from the PTH
926    signal handler. 
927
928    Fixme: Due to the way the argument parsing works, we create a
929    memory leak here for all string type arguments.  There is currently
930    no clean way to tell whether the memory for the argument has been
931    allocated or points into the process' original arguments.  Unless
932    we have a mechanism to tell this, we need to live on with this. */
933 static void
934 reread_configuration (void)
935 {
936   ARGPARSE_ARGS pargs;
937   FILE *fp;
938   unsigned int configlineno = 0;
939   int dummy;
940
941   if (!config_filename)
942     return; /* No config file. */
943
944   fp = fopen (config_filename, "r");
945   if (!fp)
946     {
947       log_error (_("option file `%s': %s\n"),
948                  config_filename, strerror(errno) );
949       return;
950     }
951
952   parse_rereadable_options (NULL); /* Start from the default values. */
953
954   memset (&pargs, 0, sizeof pargs);
955   dummy = 0;
956   pargs.argc = &dummy;
957   pargs.flags = 1;  /* do not remove the args */
958   while (optfile_parse (fp, config_filename, &configlineno, &pargs, opts) )
959     {
960       if (pargs.r_opt < -1)
961         pargs.err = 1; /* Print a warning. */
962       else /* Try to parse this option - ignore unchangeable ones. */
963         parse_rereadable_options (&pargs);
964     }
965   fclose (fp);
966   set_debug ();
967 }
968
969
970 static void
971 create_private_keys_directory (const char *home)
972 {
973   char *fname;
974   struct stat statbuf;
975
976   fname = make_filename (home, GNUPG_PRIVATE_KEYS_DIR, NULL);
977   if (stat (fname, &statbuf) && errno == ENOENT)
978     {
979       if (mkdir (fname, S_IRUSR|S_IWUSR|S_IXUSR ))
980         log_error (_("can't create directory `%s': %s\n"),
981                    fname,       strerror(errno) );
982       else if (!opt.quiet)
983         log_info (_("directory `%s' created\n"), fname);
984     }
985   xfree (fname);
986 }
987
988 /* Create the directory only if the supplied directory name is the
989    same as the default one.  This way we avoid to create arbitrary
990    directories when a non-default home directory is used.  To cope
991    with HOME, we compare only the suffix if we see that the default
992    homedir does start with a tilde.  We don't stop here in case of
993    problems because other functions will throw an error anyway.*/
994 static void
995 create_directories (void)
996 {
997   struct stat statbuf;
998   const char *defhome = GNUPG_DEFAULT_HOMEDIR;
999   char *home;
1000
1001   home  = make_filename (opt.homedir, NULL);
1002   if ( stat (home, &statbuf) )
1003     {
1004       if (errno == ENOENT)
1005         {
1006           if ( (*defhome == '~'
1007                 && (strlen (home) >= strlen (defhome+1)
1008                     && !strcmp (home + strlen(home)
1009                                 - strlen (defhome+1), defhome+1)))
1010                || (*defhome != '~' && !strcmp (home, defhome) )
1011                )
1012             {
1013               if (mkdir (home, S_IRUSR|S_IWUSR|S_IXUSR ))
1014                 log_error (_("can't create directory `%s': %s\n"),
1015                            home, strerror(errno) );
1016               else 
1017                 {
1018                   if (!opt.quiet)
1019                     log_info (_("directory `%s' created\n"), home);
1020                   create_private_keys_directory (home);
1021                 }
1022             }
1023         }
1024       else
1025         log_error ("error stat-ing `%s': %s\n", home, strerror (errno));
1026     }
1027   else if ( !S_ISDIR(statbuf.st_mode))
1028     {
1029       log_error ("can't use `%s' as home directory\n", home);
1030     }
1031   else /* exists and is a directory. */
1032     {
1033       create_private_keys_directory (home);
1034     }
1035   xfree (home);
1036 }
1037
1038
1039
1040 #ifdef USE_GNU_PTH
1041 static void
1042 handle_signal (int signo)
1043 {
1044   switch (signo)
1045     {
1046     case SIGHUP:
1047       log_info ("SIGHUP received - "
1048                 "re-reading configuration and flushing cache\n");
1049       agent_flush_cache ();
1050       reread_configuration ();
1051       break;
1052       
1053     case SIGUSR1:
1054       if (opt.verbose < 5)
1055         opt.verbose++;
1056       log_info ("SIGUSR1 received - verbosity set to %d\n", opt.verbose);
1057       break;
1058
1059     case SIGUSR2:
1060       if (opt.verbose)
1061         opt.verbose--;
1062       log_info ("SIGUSR2 received - verbosity set to %d\n", opt.verbose );
1063       break;
1064
1065     case SIGTERM:
1066       if (!shutdown_pending)
1067         log_info ("SIGTERM received - shutting down ...\n");
1068       else
1069         log_info ("SIGTERM received - still %ld running threads\n",
1070                   pth_ctrl( PTH_CTRL_GETTHREADS ));
1071       shutdown_pending++;
1072       if (shutdown_pending > 2)
1073         {
1074           log_info ("shutdown forced\n");
1075           log_info ("%s %s stopped\n", strusage(11), strusage(13) );
1076           cleanup ();
1077           agent_exit (0);
1078         }
1079       break;
1080         
1081     case SIGINT:
1082       log_info ("SIGINT received - immediate shutdown\n");
1083       log_info( "%s %s stopped\n", strusage(11), strusage(13));
1084       cleanup ();
1085       agent_exit (0);
1086       break;
1087
1088     default:
1089       log_info ("signal %d received - no action defined\n", signo);
1090     }
1091 }
1092
1093
1094 static void *
1095 start_connection_thread (void *arg)
1096 {
1097   int fd = (int)arg;
1098
1099   if (opt.verbose)
1100     log_info ("handler for fd %d started\n", fd);
1101   start_command_handler (-1, fd);
1102   if (opt.verbose)
1103     log_info ("handler for fd %d terminated\n", fd);
1104   
1105   return NULL;
1106 }
1107
1108
1109 static void
1110 handle_connections (int listen_fd)
1111 {
1112   pth_attr_t tattr;
1113   pth_event_t ev;
1114   sigset_t sigs;
1115   int signo;
1116   struct sockaddr_un paddr;
1117   socklen_t plen = sizeof( paddr );
1118   int fd;
1119
1120   tattr = pth_attr_new();
1121   pth_attr_set (tattr, PTH_ATTR_JOINABLE, 0);
1122   pth_attr_set (tattr, PTH_ATTR_STACK_SIZE, 32*1024);
1123   pth_attr_set (tattr, PTH_ATTR_NAME, "gpg-agent");
1124
1125   sigemptyset (&sigs );
1126   sigaddset (&sigs, SIGHUP);
1127   sigaddset (&sigs, SIGUSR1);
1128   sigaddset (&sigs, SIGUSR2);
1129   sigaddset (&sigs, SIGINT);
1130   sigaddset (&sigs, SIGTERM);
1131   ev = pth_event (PTH_EVENT_SIGS, &sigs, &signo);
1132
1133   for (;;)
1134     {
1135       if (shutdown_pending)
1136         {
1137           if (pth_ctrl (PTH_CTRL_GETTHREADS) == 1)
1138             break; /* ready */
1139
1140           /* Do not accept anymore connections and wait for existing
1141              connections to terminate */
1142           signo = 0;
1143           pth_wait (ev);
1144           if (pth_event_occurred (ev) && signo)
1145             handle_signal (signo);
1146           continue;
1147         }
1148
1149       fd = pth_accept_ev (listen_fd, (struct sockaddr *)&paddr, &plen, ev);
1150       if (fd == -1)
1151         {
1152 #ifdef PTH_STATUS_OCCURRED     /* This is Pth 2 */
1153           if (pth_event_status (ev) == PTH_STATUS_OCCURRED)
1154 #else
1155           if (pth_event_occurred (ev))
1156 #endif
1157             {
1158               handle_signal (signo);
1159               continue;
1160             }
1161           log_error ("accept failed: %s - waiting 1s\n", strerror (errno));
1162           pth_sleep(1);
1163           continue;
1164         }
1165
1166       if (!pth_spawn (tattr, start_connection_thread, (void*)fd))
1167         {
1168           log_error ("error spawning connection handler: %s\n",
1169                      strerror (errno) );
1170           close (fd);
1171         }
1172     }
1173
1174   pth_event_free (ev, PTH_FREE_ALL);
1175   cleanup ();
1176   log_info ("%s %s stopped\n", strusage(11), strusage(13));
1177 }
1178 #endif /*USE_GNU_PTH*/