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