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