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