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