2004-03-23 Marcus Brinkmann <marcus@g10code.de>
[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     {
591       char *filename;
592
593       /* List options and default values in the GPG Conf format.  */
594
595       /* The following list is taken from gnupg/tools/gpgconf-comp.c.  */
596       /* Option flags.  YOU MUST NOT CHANGE THE NUMBERS OF THE EXISTING
597          FLAGS, AS THEY ARE PART OF THE EXTERNAL INTERFACE.  */
598 #define GC_OPT_FLAG_NONE        0UL
599       /* The RUNTIME flag for an option indicates that the option can be
600          changed at runtime.  */
601 #define GC_OPT_FLAG_RUNTIME     (1UL << 3)
602       /* The DEFAULT flag for an option indicates that the option has a
603          default value.  */
604 #define GC_OPT_FLAG_DEFAULT     (1UL << 4)
605       /* The DEF_DESC flag for an option indicates that the option has a
606          default, which is described by the value of the default field.  */
607 #define GC_OPT_FLAG_DEF_DESC    (1UL << 5)
608       /* The NO_ARG_DESC flag for an option indicates that the argument has
609          a default, which is described by the value of the ARGDEF field.  */
610 #define GC_OPT_FLAG_NO_ARG_DESC (1UL << 6)
611
612       filename = make_filename (opt.homedir, "gpg-agent.conf", NULL );
613       printf ("gpgconf-gpg-agent.conf:%lu:\"%s\n",
614               GC_OPT_FLAG_DEFAULT, filename);
615       xfree (filename);
616
617       printf ("verbose:%lu:\n"
618               "quiet:%lu:\n"
619               "debug-level:%lu:\"none:\n"
620               "log-file:%lu:\n",
621               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME,
622               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME,
623               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME,
624               GC_OPT_FLAG_NONE );
625       printf ("default-cache-ttl:%lu:%d:\n",
626               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME, DEFAULT_CACHE_TTL );
627       printf ("no-grab:%lu:\n", 
628               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
629       printf ("ignore-cache-for-signing:%lu:\n",
630               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
631
632       agent_exit (0);
633     }
634
635   if (!pipe_server && !is_daemon)
636     log_info (_("please use the option `--daemon'"
637                 " to run the program in the background\n"));
638   
639 #ifdef ENABLE_NLS
640   /* gpg-agent usually does not output any messages because it runs in
641      the background.  For log files it is acceptable to have messages
642      always encoded in utf-8.  We switch here to utf-8, so that
643      commands like --help still give native messages.  It is far
644      easier to switch only once instead of for every message and it
645      actually helps when more then one thread is active (avoids an
646      extra copy step). */
647     bind_textdomain_codeset (PACKAGE, "UTF-8");
648 #endif
649
650   /* now start with logging to a file if this is desired */
651   if (logfile)
652     {
653       log_set_file (logfile);
654       log_set_prefix (NULL, 1|2|4);
655     }
656
657   /* Make sure that we have a default ttyname. */
658   if (!default_ttyname && ttyname (1))
659     default_ttyname = xstrdup (ttyname (1));
660   if (!default_ttytype && getenv ("TERM"))
661     default_ttytype = xstrdup (getenv ("TERM"));
662
663   if (pipe_server)
664     { /* this is the simple pipe based server */
665       start_command_handler (-1, -1);
666     }
667   else if (!is_daemon)
668     ;
669   else
670     { /* regular server mode */
671       int fd;
672       pid_t pid;
673       int len;
674       struct sockaddr_un serv_addr;
675       char *p;
676
677       /* Remove the DISPLAY variable so that a pinentry does not
678          default to a specific display.  There is still a default
679          display when gpg-agent weas started using --display or a
680          client requested this using an OPTION command. */
681       if (!opt.keep_display)
682         unsetenv ("DISPLAY");
683
684       *socket_name = 0;
685       snprintf (socket_name, DIM(socket_name)-1,
686                 "/tmp/gpg-XXXXXX/S.gpg-agent");
687       socket_name[DIM(socket_name)-1] = 0;
688       p = strrchr (socket_name, '/');
689       if (!p)
690         BUG ();
691       *p = 0;;
692       if (!mkdtemp(socket_name))
693         {
694           log_error ("can't create directory `%s': %s\n",
695                      socket_name, strerror(errno) );
696           exit (1);
697         }
698       *p = '/';
699
700       if (strchr (socket_name, ':') )
701         {
702           log_error ("colons are not allowed in the socket name\n");
703           exit (1);
704         }
705       if (strlen (socket_name)+1 >= sizeof serv_addr.sun_path ) 
706         {
707           log_error ("name of socket too long\n");
708           exit (1);
709         }
710    
711
712       fd = socket (AF_UNIX, SOCK_STREAM, 0);
713       if (fd == -1)
714         {
715           log_error ("can't create socket: %s\n", strerror(errno) );
716           exit (1);
717         }
718
719       memset (&serv_addr, 0, sizeof serv_addr);
720       serv_addr.sun_family = AF_UNIX;
721       strcpy (serv_addr.sun_path, socket_name);
722       len = (offsetof (struct sockaddr_un, sun_path)
723              + strlen(serv_addr.sun_path) + 1);
724
725       if (bind (fd, (struct sockaddr*)&serv_addr, len) == -1)
726         {
727           log_error ("error binding socket to `%s': %s\n",
728                      serv_addr.sun_path, strerror (errno) );
729           close (fd);
730           exit (1);
731         }
732   
733       if (listen (fd, 5 ) == -1)
734         {
735           log_error ("listen() failed: %s\n", strerror (errno));
736           close (fd);
737           exit (1);
738         }
739
740       if (opt.verbose)
741         log_info ("listening on socket `%s'\n", socket_name );
742
743
744       fflush (NULL);
745       pid = fork ();
746       if (pid == (pid_t)-1) 
747         {
748           log_fatal ("fork failed: %s\n", strerror (errno) );
749           exit (1);
750         }
751       else if (pid) 
752         { /* we are the parent */
753           char *infostr;
754           
755           close (fd);
756           
757           /* create the info string: <name>:<pid>:<protocol_version> */
758           if (asprintf (&infostr, "GPG_AGENT_INFO=%s:%lu:1",
759                         socket_name, (ulong)pid ) < 0)
760             {
761               log_error ("out of core\n");
762               kill (pid, SIGTERM);
763               exit (1);
764             }
765           *socket_name = 0; /* don't let cleanup() remove the socket -
766                                the child should do this from now on */
767           if (argc) 
768             { /* run the program given on the commandline */
769               if (putenv (infostr))
770                 {
771                   log_error ("failed to set environment: %s\n",
772                              strerror (errno) );
773                   kill (pid, SIGTERM );
774                   exit (1);
775                 }
776               execvp (argv[0], argv);
777               log_error ("failed to run the command: %s\n", strerror (errno));
778               kill (pid, SIGTERM);
779               exit (1);
780             }
781           else
782             {
783               /* print the environment string, so that the caller can use
784                  shell's eval to set it */
785               if (csh_style)
786                 {
787                   *strchr (infostr, '=') = ' ';
788                   printf ( "setenv %s\n", infostr);
789                 }
790               else
791                 {
792                   printf ( "%s; export GPG_AGENT_INFO;\n", infostr);
793                 }
794               free (infostr);
795               exit (0); 
796             }
797           /*NEVER REACHED*/
798         } /* end parent */
799       
800
801       /* this is the child */
802
803       /* detach from tty and put process into a new session */
804       if (!nodetach )
805         { 
806           int i;
807
808           /* close stdin, stdout and stderr unless it is the log stream */
809           for (i=0; i <= 2; i++) 
810             {
811               if ( log_get_fd () != i)
812                 close (i);
813             }
814           if (setsid() == -1)
815             {
816               log_error ("setsid() failed: %s\n", strerror(errno) );
817               cleanup ();
818               exit (1);
819             }
820           opt.running_detached = 1;
821         }
822
823       if (chdir("/"))
824         {
825           log_error ("chdir to / failed: %s\n", strerror (errno));
826           exit (1);
827         }
828
829
830 #ifdef USE_GNU_PTH
831       if (!disable_pth)
832         {
833           struct sigaction sa;
834
835           sa.sa_handler = SIG_IGN;
836           sigemptyset (&sa.sa_mask);
837           sa.sa_flags = 0;
838           sigaction (SIGPIPE, &sa, NULL);
839           handle_connections (fd);
840         }
841       else
842 #endif /*!USE_GNU_PTH*/
843       /* setup signals */
844         {
845           struct sigaction oact, nact;
846           
847           nact.sa_handler = cleanup_sh;
848           sigemptyset (&nact.sa_mask);
849           nact.sa_flags = 0;
850           
851           sigaction (SIGHUP, NULL, &oact);
852           if (oact.sa_handler != SIG_IGN)
853             sigaction (SIGHUP, &nact, NULL);
854           sigaction( SIGTERM, NULL, &oact );
855           if (oact.sa_handler != SIG_IGN)
856             sigaction (SIGTERM, &nact, NULL);
857           nact.sa_handler = SIG_IGN;
858           sigaction (SIGPIPE, &nact, NULL);
859           sigaction (SIGINT, &nact, NULL);
860
861           start_command_handler (fd, -1);
862         }
863       close (fd);
864     }
865   
866   return 0;
867 }
868
869 void
870 agent_exit (int rc)
871 {
872   /*FIXME: update_random_seed_file();*/
873 #if 1
874   /* at this time a bit annoying */
875   if (opt.debug & DBG_MEMSTAT_VALUE)
876     {
877       gcry_control( GCRYCTL_DUMP_MEMORY_STATS );
878       gcry_control( GCRYCTL_DUMP_RANDOM_STATS );
879     }
880   if (opt.debug)
881     gcry_control (GCRYCTL_DUMP_SECMEM_STATS );
882 #endif
883   gcry_control (GCRYCTL_TERM_SECMEM );
884   rc = rc? rc : log_get_errorcount(0)? 2 : 0;
885   exit (rc);
886 }
887
888
889 void
890 agent_init_default_ctrl (struct server_control_s *ctrl)
891 {
892   ctrl->connection_fd = -1;
893
894   /* Note we ignore malloc errors because we can't do much about it
895      and the request will fail anyway shortly after this
896      initialization. */
897   if (ctrl->display)
898     free (ctrl->display);
899   ctrl->display = default_display? strdup (default_display) : NULL;
900
901   if (ctrl->ttyname)
902     free (ctrl->ttyname);
903   ctrl->ttyname = default_ttyname? strdup (default_ttyname) : NULL;
904
905   if (ctrl->ttytype)
906     free (ctrl->ttytype);
907   ctrl->ttytype = default_ttytype? strdup (default_ttytype) : NULL;
908
909   if (ctrl->lc_ctype)
910     free (ctrl->lc_ctype);
911   ctrl->lc_ctype = default_lc_ctype? strdup (default_lc_ctype) : NULL;
912
913   if (ctrl->lc_messages)
914     free (ctrl->lc_messages);
915   ctrl->lc_messages = default_lc_messages? strdup (default_lc_messages) : NULL;
916 }
917
918
919 /* Reread parts of the configuration.  Note, that this function is
920    obviously not thread-safe and should only be called from the PTH
921    signal handler. 
922
923    Fixme: Due to the way the argument parsing works, we create a
924    memory leak here for all string type arguments.  There is currently
925    no clean way to tell whether the memory for the argument has been
926    allocated or points into the process' original arguments.  Unless
927    we have a mechanism to tell this, we need to live on with this. */
928 static void
929 reread_configuration (void)
930 {
931   ARGPARSE_ARGS pargs;
932   FILE *fp;
933   unsigned int configlineno = 0;
934   int dummy;
935
936   if (!config_filename)
937     return; /* No config file. */
938
939   fp = fopen (config_filename, "r");
940   if (!fp)
941     {
942       log_error (_("option file `%s': %s\n"),
943                  config_filename, strerror(errno) );
944       return;
945     }
946
947   parse_rereadable_options (NULL); /* Start from the default values. */
948
949   memset (&pargs, 0, sizeof pargs);
950   dummy = 0;
951   pargs.argc = &dummy;
952   pargs.flags = 1;  /* do not remove the args */
953   while (optfile_parse (fp, config_filename, &configlineno, &pargs, opts) )
954     {
955       if (pargs.r_opt < -1)
956         pargs.err = 1; /* Print a warning. */
957       else /* Try to parse this option - ignore unchangeable ones. */
958         parse_rereadable_options (&pargs);
959     }
960   fclose (fp);
961   set_debug ();
962 }
963
964
965 static void
966 create_private_keys_directory (const char *home)
967 {
968   char *fname;
969   struct stat statbuf;
970
971   fname = make_filename (home, GNUPG_PRIVATE_KEYS_DIR, NULL);
972   if (stat (fname, &statbuf) && errno == ENOENT)
973     {
974       if (mkdir (fname, S_IRUSR|S_IWUSR|S_IXUSR ))
975         log_error (_("can't create directory `%s': %s\n"),
976                    fname,       strerror(errno) );
977       else if (!opt.quiet)
978         log_info (_("directory `%s' created\n"), fname);
979     }
980   xfree (fname);
981 }
982
983 /* Create the directory only if the supplied directory name is the
984    same as the default one.  This way we avoid to create arbitrary
985    directories when a non-default home directory is used.  To cope
986    with HOME, we compare only the suffix if we see that the default
987    homedir does start with a tilde.  We don't stop here in case of
988    problems because other functions will throw an error anyway.*/
989 static void
990 create_directories (void)
991 {
992   struct stat statbuf;
993   const char *defhome = GNUPG_DEFAULT_HOMEDIR;
994   char *home;
995
996   home  = make_filename (opt.homedir, NULL);
997   if ( stat (home, &statbuf) )
998     {
999       if (errno == ENOENT)
1000         {
1001           if ( (*defhome == '~'
1002                 && (strlen (home) >= strlen (defhome+1)
1003                     && !strcmp (home + strlen(home)
1004                                 - strlen (defhome+1), defhome+1)))
1005                || (*defhome != '~' && !strcmp (home, defhome) )
1006                )
1007             {
1008               if (mkdir (home, S_IRUSR|S_IWUSR|S_IXUSR ))
1009                 log_error (_("can't create directory `%s': %s\n"),
1010                            home, strerror(errno) );
1011               else 
1012                 {
1013                   if (!opt.quiet)
1014                     log_info (_("directory `%s' created\n"), home);
1015                   create_private_keys_directory (home);
1016                 }
1017             }
1018         }
1019       else
1020         log_error ("error stat-ing `%s': %s\n", home, strerror (errno));
1021     }
1022   else if ( !S_ISDIR(statbuf.st_mode))
1023     {
1024       log_error ("can't use `%s' as home directory\n", home);
1025     }
1026   else /* exists and is a directory. */
1027     {
1028       create_private_keys_directory (home);
1029     }
1030   xfree (home);
1031 }
1032
1033
1034
1035 #ifdef USE_GNU_PTH
1036 static void
1037 handle_signal (int signo)
1038 {
1039   switch (signo)
1040     {
1041     case SIGHUP:
1042       log_info ("SIGHUP received - "
1043                 "re-reading configuration and flushing cache\n");
1044       agent_flush_cache ();
1045       reread_configuration ();
1046       break;
1047       
1048     case SIGUSR1:
1049       if (opt.verbose < 5)
1050         opt.verbose++;
1051       log_info ("SIGUSR1 received - verbosity set to %d\n", opt.verbose);
1052       break;
1053
1054     case SIGUSR2:
1055       if (opt.verbose)
1056         opt.verbose--;
1057       log_info ("SIGUSR2 received - verbosity set to %d\n", opt.verbose );
1058       break;
1059
1060     case SIGTERM:
1061       if (!shutdown_pending)
1062         log_info ("SIGTERM received - shutting down ...\n");
1063       else
1064         log_info ("SIGTERM received - still %ld running threads\n",
1065                   pth_ctrl( PTH_CTRL_GETTHREADS ));
1066       shutdown_pending++;
1067       if (shutdown_pending > 2)
1068         {
1069           log_info ("shutdown forced\n");
1070           log_info ("%s %s stopped\n", strusage(11), strusage(13) );
1071           cleanup ();
1072           agent_exit (0);
1073         }
1074       break;
1075         
1076     case SIGINT:
1077       log_info ("SIGINT received - immediate shutdown\n");
1078       log_info( "%s %s stopped\n", strusage(11), strusage(13));
1079       cleanup ();
1080       agent_exit (0);
1081       break;
1082
1083     default:
1084       log_info ("signal %d received - no action defined\n", signo);
1085     }
1086 }
1087
1088
1089 static void *
1090 start_connection_thread (void *arg)
1091 {
1092   int fd = (int)arg;
1093
1094   if (opt.verbose)
1095     log_info ("handler for fd %d started\n", fd);
1096   start_command_handler (-1, fd);
1097   if (opt.verbose)
1098     log_info ("handler for fd %d terminated\n", fd);
1099   
1100   return NULL;
1101 }
1102
1103
1104 static void
1105 handle_connections (int listen_fd)
1106 {
1107   pth_attr_t tattr;
1108   pth_event_t ev;
1109   sigset_t sigs;
1110   int signo;
1111   struct sockaddr_un paddr;
1112   socklen_t plen = sizeof( paddr );
1113   int fd;
1114
1115   tattr = pth_attr_new();
1116   pth_attr_set (tattr, PTH_ATTR_JOINABLE, 0);
1117   pth_attr_set (tattr, PTH_ATTR_STACK_SIZE, 32*1024);
1118   pth_attr_set (tattr, PTH_ATTR_NAME, "gpg-agent");
1119
1120   sigemptyset (&sigs );
1121   sigaddset (&sigs, SIGHUP);
1122   sigaddset (&sigs, SIGUSR1);
1123   sigaddset (&sigs, SIGUSR2);
1124   sigaddset (&sigs, SIGINT);
1125   sigaddset (&sigs, SIGTERM);
1126   ev = pth_event (PTH_EVENT_SIGS, &sigs, &signo);
1127
1128   for (;;)
1129     {
1130       if (shutdown_pending)
1131         {
1132           if (pth_ctrl (PTH_CTRL_GETTHREADS) == 1)
1133             break; /* ready */
1134
1135           /* Do not accept anymore connections and wait for existing
1136              connections to terminate */
1137           signo = 0;
1138           pth_wait (ev);
1139           if (pth_event_occurred (ev) && signo)
1140             handle_signal (signo);
1141           continue;
1142         }
1143
1144       fd = pth_accept_ev (listen_fd, (struct sockaddr *)&paddr, &plen, ev);
1145       if (fd == -1)
1146         {
1147 #ifdef PTH_STATUS_OCCURRED     /* This is Pth 2 */
1148           if (pth_event_status (ev) == PTH_STATUS_OCCURRED)
1149 #else
1150           if (pth_event_occurred (ev))
1151 #endif
1152             {
1153               handle_signal (signo);
1154               continue;
1155             }
1156           log_error ("accept failed: %s - waiting 1s\n", strerror (errno));
1157           pth_sleep(1);
1158           continue;
1159         }
1160
1161       if (!pth_spawn (tattr, start_connection_thread, (void*)fd))
1162         {
1163           log_error ("error spawning connection handler: %s\n",
1164                      strerror (errno) );
1165           close (fd);
1166         }
1167     }
1168
1169   pth_event_free (ev, PTH_FREE_ALL);
1170   cleanup ();
1171   log_info ("%s %s stopped\n", strusage(11), strusage(13));
1172 }
1173 #endif /*USE_GNU_PTH*/