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