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