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