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