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