65d5fd5a6dbc11809d0ec8c3cb29d57701861a67
[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 #ifdef HAVE_W32_SYSTEM
441   /* For W32 we need pth.  */
442   pth_init ();
443 #else
444   err = gcry_control (GCRYCTL_SET_THREAD_CBS, &gcry_threads_pth);
445   if (err)
446     {
447       log_fatal ("can't register GNU Pth with Libgcrypt: %s\n",
448                  gpg_strerror (err));
449     }
450 #endif
451 #endif /*USE_GNU_PTH*/
452
453
454   /* Check that the libraries are suitable.  Do it here because
455      the option parsing may need services of the library. */
456   if (!gcry_check_version (NEED_LIBGCRYPT_VERSION) )
457     {
458       log_fatal( _("libgcrypt is too old (need %s, have %s)\n"),
459                  NEED_LIBGCRYPT_VERSION, gcry_check_version (NULL) );
460     }
461
462   assuan_set_malloc_hooks (gcry_malloc, gcry_realloc, gcry_free);
463   assuan_set_assuan_log_stream (log_get_stream ());
464   assuan_set_assuan_log_prefix (log_get_prefix (NULL));
465
466   gcry_set_log_handler (my_gcry_logger, NULL);
467   gcry_control (GCRYCTL_USE_SECURE_RNDPOOL);
468
469   may_coredump = disable_core_dumps ();
470
471   parse_rereadable_options (NULL, 0); /* Reset them to default values. */
472
473   shell = getenv ("SHELL");
474   if (shell && strlen (shell) >= 3 && !strcmp (shell+strlen (shell)-3, "csh") )
475     csh_style = 1;
476   
477   opt.homedir = getenv("GNUPGHOME");
478   if (!opt.homedir || !*opt.homedir)
479     opt.homedir = GNUPG_DEFAULT_HOMEDIR;
480
481
482   /* check whether we have a config file on the commandline */
483   orig_argc = argc;
484   orig_argv = argv;
485   pargs.argc = &argc;
486   pargs.argv = &argv;
487   pargs.flags= 1|(1<<6);  /* do not remove the args, ignore version */
488   while (arg_parse( &pargs, opts))
489     {
490       if (pargs.r_opt == oDebug || pargs.r_opt == oDebugAll)
491         parse_debug++;
492       else if (pargs.r_opt == oOptions)
493         { /* yes there is one, so we do not try the default one, but
494              read the option file when it is encountered at the
495              commandline */
496           default_config = 0;
497         }
498         else if (pargs.r_opt == oNoOptions)
499           default_config = 0; /* --no-options */
500         else if (pargs.r_opt == oHomedir)
501           opt.homedir = pargs.r.ret_str;
502     }
503
504   /* initialize the secure memory. */
505   gcry_control (GCRYCTL_INIT_SECMEM, 16384, 0);
506   maybe_setuid = 0;
507
508   /* 
509      Now we are now working under our real uid 
510   */
511
512
513   if (default_config)
514     configname = make_filename (opt.homedir, "gpg-agent.conf", NULL );
515   
516   argc = orig_argc;
517   argv = orig_argv;
518   pargs.argc = &argc;
519   pargs.argv = &argv;
520   pargs.flags=  1;  /* do not remove the args */
521  next_pass:
522   if (configname)
523     {
524       configlineno = 0;
525       configfp = fopen (configname, "r");
526       if (!configfp)
527         {
528           if (default_config)
529             {
530               if( parse_debug )
531                 log_info (_("NOTE: no default option file `%s'\n"),
532                           configname );
533             }
534           else
535             {
536               log_error (_("option file `%s': %s\n"),
537                          configname, strerror(errno) );
538               exit(2);
539             }
540           xfree (configname); 
541           configname = NULL;
542         }
543       if (parse_debug && configname )
544         log_info (_("reading options from `%s'\n"), configname );
545       default_config = 0;
546     }
547
548   while (optfile_parse( configfp, configname, &configlineno, &pargs, opts) )
549     {
550       if (parse_rereadable_options (&pargs, 0))
551         continue; /* Already handled */
552       switch (pargs.r_opt)
553         {
554         case aGPGConfList: gpgconf_list = 1; break;
555         case oBatch: opt.batch=1; break;
556
557         case oDebugWait: debug_wait = pargs.r.ret_int; break;
558
559         case oOptions:
560           /* config files may not be nested (silently ignore them) */
561           if (!configfp)
562             {
563                 xfree(configname);
564                 configname = xstrdup(pargs.r.ret_str);
565                 goto next_pass;
566             }
567           break;
568         case oNoGreeting: nogreeting = 1; break;
569         case oNoVerbose: opt.verbose = 0; break;
570         case oNoOptions: break; /* no-options */
571         case oHomedir: opt.homedir = pargs.r.ret_str; break;
572         case oNoDetach: nodetach = 1; break;
573         case oLogFile: logfile = pargs.r.ret_str; break;
574         case oCsh: csh_style = 1; break;
575         case oSh: csh_style = 0; break;
576         case oServer: pipe_server = 1; break;
577         case oDaemon: is_daemon = 1; break;
578         case oDisablePth: disable_pth = 1; break;
579
580         case oDisplay: default_display = xstrdup (pargs.r.ret_str); break;
581         case oTTYname: default_ttyname = xstrdup (pargs.r.ret_str); break;
582         case oTTYtype: default_ttytype = xstrdup (pargs.r.ret_str); break;
583         case oLCctype: default_lc_ctype = xstrdup (pargs.r.ret_str); break;
584         case oLCmessages: default_lc_messages = xstrdup (pargs.r.ret_str);
585           break;
586
587         case oKeepTTY: opt.keep_tty = 1; break;
588         case oKeepDISPLAY: opt.keep_display = 1; break;
589
590         default : pargs.err = configfp? 1:2; break;
591         }
592     }
593   if (configfp)
594     {
595       fclose( configfp );
596       configfp = NULL;
597       /* Keep a copy of the name so that it can be read on SIGHUP. */
598       config_filename = configname;
599       configname = NULL;
600       goto next_pass;
601     }
602   xfree (configname);
603   configname = NULL;
604   if (log_get_errorcount(0))
605     exit(2);
606   if (nogreeting )
607     greeting = 0;
608
609   if (greeting)
610     {
611       fprintf (stderr, "%s %s; %s\n",
612                  strusage(11), strusage(13), strusage(14) );
613       fprintf (stderr, "%s\n", strusage(15) );
614     }
615 #ifdef IS_DEVELOPMENT_VERSION
616   /* We don't want to print it here because gpg-agent is useful of its
617      own and quite matured.  */
618   /*log_info ("NOTE: this is a development version!\n");*/
619 #endif
620
621   set_debug ();
622   
623   if (atexit (cleanup))
624     {
625       log_error ("atexit failed\n");
626       cleanup ();
627       exit (1);
628     }
629
630   initialize_module_query ();
631   initialize_module_call_scd ();
632   
633   /* Try to create missing directories. */
634   create_directories ();
635
636   if (debug_wait && pipe_server)
637     {
638       log_debug ("waiting for debugger - my pid is %u .....\n",
639                  (unsigned int)getpid());
640       sleep (debug_wait);
641       log_debug ("... okay\n");
642     }
643   
644   if (gpgconf_list)
645     {
646       char *filename;
647
648       /* List options and default values in the GPG Conf format.  */
649
650       /* The following list is taken from gnupg/tools/gpgconf-comp.c.  */
651       /* Option flags.  YOU MUST NOT CHANGE THE NUMBERS OF THE EXISTING
652          FLAGS, AS THEY ARE PART OF THE EXTERNAL INTERFACE.  */
653 #define GC_OPT_FLAG_NONE        0UL
654       /* The RUNTIME flag for an option indicates that the option can be
655          changed at runtime.  */
656 #define GC_OPT_FLAG_RUNTIME     (1UL << 3)
657       /* The DEFAULT flag for an option indicates that the option has a
658          default value.  */
659 #define GC_OPT_FLAG_DEFAULT     (1UL << 4)
660       /* The DEF_DESC flag for an option indicates that the option has a
661          default, which is described by the value of the default field.  */
662 #define GC_OPT_FLAG_DEF_DESC    (1UL << 5)
663       /* The NO_ARG_DESC flag for an option indicates that the argument has
664          a default, which is described by the value of the ARGDEF field.  */
665 #define GC_OPT_FLAG_NO_ARG_DESC (1UL << 6)
666
667       filename = make_filename (opt.homedir, "gpg-agent.conf", NULL );
668       printf ("gpgconf-gpg-agent.conf:%lu:\"%s\n",
669               GC_OPT_FLAG_DEFAULT, filename);
670       xfree (filename);
671
672       printf ("verbose:%lu:\n"
673               "quiet:%lu:\n"
674               "debug-level:%lu:\"none:\n"
675               "log-file:%lu:\n",
676               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME,
677               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME,
678               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME,
679               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME );
680       printf ("default-cache-ttl:%lu:%d:\n",
681               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME, DEFAULT_CACHE_TTL );
682       printf ("no-grab:%lu:\n", 
683               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
684       printf ("ignore-cache-for-signing:%lu:\n",
685               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
686       printf ("allow-mark-trusted:%lu:\n",
687               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
688
689       agent_exit (0);
690     }
691
692   /* If this has been called without any options, we merely check
693      whether an agent is already running.  We do this here so that we
694      don't clobber a logfile but print it directly to stderr. */
695   if (!pipe_server && !is_daemon)
696     {
697       log_set_prefix (NULL, JNLIB_LOG_WITH_PREFIX); 
698       check_for_running_agent ();
699       agent_exit (0);
700     }
701   
702 #ifdef ENABLE_NLS
703   /* gpg-agent usually does not output any messages because it runs in
704      the background.  For log files it is acceptable to have messages
705      always encoded in utf-8.  We switch here to utf-8, so that
706      commands like --help still give native messages.  It is far
707      easier to switch only once instead of for every message and it
708      actually helps when more then one thread is active (avoids an
709      extra copy step). */
710     bind_textdomain_codeset (PACKAGE_GT, "UTF-8");
711 #endif
712
713   /* Now start with logging to a file if this is desired. */
714   if (logfile)
715     {
716       log_set_file (logfile);
717       log_set_prefix (NULL, (JNLIB_LOG_WITH_PREFIX
718                              |JNLIB_LOG_WITH_TIME
719                              |JNLIB_LOG_WITH_PID));
720       current_logfile = xstrdup (logfile);
721     }
722
723   /* Make sure that we have a default ttyname. */
724   if (!default_ttyname && ttyname (1))
725     default_ttyname = xstrdup (ttyname (1));
726   if (!default_ttytype && getenv ("TERM"))
727     default_ttytype = xstrdup (getenv ("TERM"));
728
729
730   if (pipe_server)
731     { /* this is the simple pipe based server */
732       start_command_handler (-1, -1);
733     }
734   else if (!is_daemon)
735     ; /* NOTREACHED */
736   else
737     { /* Regular server mode */
738       int fd;
739       pid_t pid;
740       int len;
741       struct sockaddr_un serv_addr;
742       char *p;
743
744       /* Remove the DISPLAY variable so that a pinentry does not
745          default to a specific display.  There is still a default
746          display when gpg-agent weas started using --display or a
747          client requested this using an OPTION command. */
748 #ifndef HAVE_W32_SYSTEM
749       if (!opt.keep_display)
750         unsetenv ("DISPLAY");
751 #endif
752
753       *socket_name = 0;
754       snprintf (socket_name, DIM(socket_name)-1,
755                 "/tmp/gpg-XXXXXX/S.gpg-agent");
756       socket_name[DIM(socket_name)-1] = 0;
757       p = strrchr (socket_name, '/');
758       if (!p)
759         BUG ();
760       *p = 0;;
761
762 #ifndef HAVE_W32_SYSTEM
763       if (!mkdtemp(socket_name))
764         {
765           log_error ("can't create directory `%s': %s\n",
766                      socket_name, strerror(errno) );
767           exit (1);
768         }
769 #endif
770       *p = '/';
771
772       if (strchr (socket_name, ':') )
773         {
774           log_error ("colons are not allowed in the socket name\n");
775           exit (1);
776         }
777       if (strlen (socket_name)+1 >= sizeof serv_addr.sun_path ) 
778         {
779           log_error ("name of socket too long\n");
780           exit (1);
781         }
782    
783 #ifdef HAVE_W32_SYSTEM
784       fd = _w32_sock_new (AF_UNIX, SOCK_STREAM, 0);
785 #else
786       fd = socket (AF_UNIX, SOCK_STREAM, 0);
787 #endif
788       if (fd == -1)
789         {
790           log_error ("can't create socket: %s\n", strerror(errno) );
791           exit (1);
792         }
793
794       memset (&serv_addr, 0, sizeof serv_addr);
795       serv_addr.sun_family = AF_UNIX;
796       strcpy (serv_addr.sun_path, socket_name);
797       len = (offsetof (struct sockaddr_un, sun_path)
798              + strlen(serv_addr.sun_path) + 1);
799
800       if (
801 #ifdef HAVE_W32_SYSTEM
802           _w32_sock_bind
803 #else
804           bind 
805 #endif
806           (fd, (struct sockaddr*)&serv_addr, len) == -1)
807         {
808           log_error ("error binding socket to `%s': %s\n",
809                      serv_addr.sun_path, strerror (errno) );
810           close (fd);
811           exit (1);
812         }
813   
814       if (listen (fd, 5 ) == -1)
815         {
816           log_error ("listen() failed: %s\n", strerror (errno));
817           close (fd);
818           exit (1);
819         }
820
821       if (opt.verbose)
822         log_info ("listening on socket `%s'\n", socket_name );
823
824
825       fflush (NULL);
826 #ifndef HAVE_W32_SYSTEM
827       pid = fork ();
828       if (pid == (pid_t)-1) 
829         {
830           log_fatal ("fork failed: %s\n", strerror (errno) );
831           exit (1);
832         }
833       else if (pid) 
834         { /* We are the parent */
835           char *infostr;
836           
837           close (fd);
838           
839           /* create the info string: <name>:<pid>:<protocol_version> */
840           if (asprintf (&infostr, "GPG_AGENT_INFO=%s:%lu:1",
841                         socket_name, (ulong)pid ) < 0)
842             {
843               log_error ("out of core\n");
844               kill (pid, SIGTERM);
845               exit (1);
846             }
847           *socket_name = 0; /* don't let cleanup() remove the socket -
848                                the child should do this from now on */
849           if (argc) 
850             { /* run the program given on the commandline */
851               if (putenv (infostr))
852                 {
853                   log_error ("failed to set environment: %s\n",
854                              strerror (errno) );
855                   kill (pid, SIGTERM );
856                   exit (1);
857                 }
858               execvp (argv[0], argv);
859               log_error ("failed to run the command: %s\n", strerror (errno));
860               kill (pid, SIGTERM);
861               exit (1);
862             }
863           else
864             {
865               /* print the environment string, so that the caller can use
866                  shell's eval to set it */
867               if (csh_style)
868                 {
869                   *strchr (infostr, '=') = ' ';
870                   printf ( "setenv %s\n", infostr);
871                 }
872               else
873                 {
874                   printf ( "%s; export GPG_AGENT_INFO;\n", infostr);
875                 }
876               free (infostr);
877               exit (0); 
878             }
879           /*NEVER REACHED*/
880         } /* end parent */
881
882       /* 
883          This is the child
884        */
885
886       /* Detach from tty and put process into a new session */
887       if (!nodetach )
888         { 
889           int i;
890           unsigned int oldflags;
891
892           /* Close stdin, stdout and stderr unless it is the log stream */
893           for (i=0; i <= 2; i++) 
894             {
895               if (!log_test_fd (i) && i != fd )
896                 close (i);
897             }
898           if (setsid() == -1)
899             {
900               log_error ("setsid() failed: %s\n", strerror(errno) );
901               cleanup ();
902               exit (1);
903             }
904
905           log_get_prefix (&oldflags);
906           log_set_prefix (NULL, oldflags | JNLIB_LOG_RUN_DETACHED);
907           opt.running_detached = 1;
908         }
909
910       if (chdir("/"))
911         {
912           log_error ("chdir to / failed: %s\n", strerror (errno));
913           exit (1);
914         }
915
916 #endif /*!HAVE_W32_SYSTEM*/
917
918
919 #ifdef USE_GNU_PTH
920       if (!disable_pth)
921         {
922 #ifndef HAVE_W32_SYSTEM  /* FIXME */
923           struct sigaction sa;
924
925           sa.sa_handler = SIG_IGN;
926           sigemptyset (&sa.sa_mask);
927           sa.sa_flags = 0;
928           sigaction (SIGPIPE, &sa, NULL);
929 #endif
930           handle_connections (fd);
931         }
932       else
933 #endif /*!USE_GNU_PTH*/
934       /* setup signals */
935         {
936 #ifndef HAVE_W32_SYSTEM  /* FIXME */
937           struct sigaction oact, nact;
938           
939           nact.sa_handler = cleanup_sh;
940           sigemptyset (&nact.sa_mask);
941           nact.sa_flags = 0;
942           
943           sigaction (SIGHUP, NULL, &oact);
944           if (oact.sa_handler != SIG_IGN)
945             sigaction (SIGHUP, &nact, NULL);
946           sigaction( SIGTERM, NULL, &oact );
947           if (oact.sa_handler != SIG_IGN)
948             sigaction (SIGTERM, &nact, NULL);
949           nact.sa_handler = SIG_IGN;
950           sigaction (SIGPIPE, &nact, NULL);
951           sigaction (SIGINT, &nact, NULL);
952 #endif
953           start_command_handler (fd, -1);
954         }
955       close (fd);
956     }
957   
958   return 0;
959 }
960
961 void
962 agent_exit (int rc)
963 {
964   /*FIXME: update_random_seed_file();*/
965 #if 1
966   /* at this time a bit annoying */
967   if (opt.debug & DBG_MEMSTAT_VALUE)
968     {
969       gcry_control( GCRYCTL_DUMP_MEMORY_STATS );
970       gcry_control( GCRYCTL_DUMP_RANDOM_STATS );
971     }
972   if (opt.debug)
973     gcry_control (GCRYCTL_DUMP_SECMEM_STATS );
974 #endif
975   gcry_control (GCRYCTL_TERM_SECMEM );
976   rc = rc? rc : log_get_errorcount(0)? 2 : 0;
977   exit (rc);
978 }
979
980
981 void
982 agent_init_default_ctrl (struct server_control_s *ctrl)
983 {
984   ctrl->connection_fd = -1;
985
986   /* Note we ignore malloc errors because we can't do much about it
987      and the request will fail anyway shortly after this
988      initialization. */
989   if (ctrl->display)
990     free (ctrl->display);
991   ctrl->display = default_display? strdup (default_display) : NULL;
992
993   if (ctrl->ttyname)
994     free (ctrl->ttyname);
995   ctrl->ttyname = default_ttyname? strdup (default_ttyname) : NULL;
996
997   if (ctrl->ttytype)
998     free (ctrl->ttytype);
999   ctrl->ttytype = default_ttytype? strdup (default_ttytype) : NULL;
1000
1001   if (ctrl->lc_ctype)
1002     free (ctrl->lc_ctype);
1003   ctrl->lc_ctype = default_lc_ctype? strdup (default_lc_ctype) : NULL;
1004
1005   if (ctrl->lc_messages)
1006     free (ctrl->lc_messages);
1007   ctrl->lc_messages = default_lc_messages? strdup (default_lc_messages) : NULL;
1008 }
1009
1010
1011 /* Reread parts of the configuration.  Note, that this function is
1012    obviously not thread-safe and should only be called from the PTH
1013    signal handler. 
1014
1015    Fixme: Due to the way the argument parsing works, we create a
1016    memory leak here for all string type arguments.  There is currently
1017    no clean way to tell whether the memory for the argument has been
1018    allocated or points into the process' original arguments.  Unless
1019    we have a mechanism to tell this, we need to live on with this. */
1020 static void
1021 reread_configuration (void)
1022 {
1023   ARGPARSE_ARGS pargs;
1024   FILE *fp;
1025   unsigned int configlineno = 0;
1026   int dummy;
1027
1028   if (!config_filename)
1029     return; /* No config file. */
1030
1031   fp = fopen (config_filename, "r");
1032   if (!fp)
1033     {
1034       log_error (_("option file `%s': %s\n"),
1035                  config_filename, strerror(errno) );
1036       return;
1037     }
1038
1039   parse_rereadable_options (NULL, 1); /* Start from the default values. */
1040
1041   memset (&pargs, 0, sizeof pargs);
1042   dummy = 0;
1043   pargs.argc = &dummy;
1044   pargs.flags = 1;  /* do not remove the args */
1045   while (optfile_parse (fp, config_filename, &configlineno, &pargs, opts) )
1046     {
1047       if (pargs.r_opt < -1)
1048         pargs.err = 1; /* Print a warning. */
1049       else /* Try to parse this option - ignore unchangeable ones. */
1050         parse_rereadable_options (&pargs, 1);
1051     }
1052   fclose (fp);
1053   set_debug ();
1054 }
1055
1056
1057 static void
1058 create_private_keys_directory (const char *home)
1059 {
1060   char *fname;
1061   struct stat statbuf;
1062
1063   fname = make_filename (home, GNUPG_PRIVATE_KEYS_DIR, NULL);
1064   if (stat (fname, &statbuf) && errno == ENOENT)
1065     {
1066 #ifdef HAVE_W32_SYSTEM  /*FIXME: Setup proper permissions.  */
1067       if (!CreateDirectory (fname, NULL))
1068         log_error (_("can't create directory `%s': %s\n"),
1069                    fname, w32_strerror (-1) );
1070 #else
1071       if (mkdir (fname, S_IRUSR|S_IWUSR|S_IXUSR ))
1072         log_error (_("can't create directory `%s': %s\n"),
1073                    fname, strerror (errno) );
1074 #endif
1075       else if (!opt.quiet)
1076         log_info (_("directory `%s' created\n"), fname);
1077     }
1078   xfree (fname);
1079 }
1080
1081 /* Create the directory only if the supplied directory name is the
1082    same as the default one.  This way we avoid to create arbitrary
1083    directories when a non-default home directory is used.  To cope
1084    with HOME, we compare only the suffix if we see that the default
1085    homedir does start with a tilde.  We don't stop here in case of
1086    problems because other functions will throw an error anyway.*/
1087 static void
1088 create_directories (void)
1089 {
1090   struct stat statbuf;
1091   const char *defhome = GNUPG_DEFAULT_HOMEDIR;
1092   char *home;
1093
1094   home  = make_filename (opt.homedir, NULL);
1095   if ( stat (home, &statbuf) )
1096     {
1097       if (errno == ENOENT)
1098         {
1099           if ( (*defhome == '~'
1100                 && (strlen (home) >= strlen (defhome+1)
1101                     && !strcmp (home + strlen(home)
1102                                 - strlen (defhome+1), defhome+1)))
1103                || (*defhome != '~' && !strcmp (home, defhome) )
1104                )
1105             {
1106 #ifdef HAVE_W32_SYSTEM
1107               if (!CreateDirectory (home, NULL))
1108                 log_error (_("can't create directory `%s': %s\n"),
1109                            home, w32_strerror (-1) );
1110 #else
1111               if (mkdir (home, S_IRUSR|S_IWUSR|S_IXUSR ))
1112                 log_error (_("can't create directory `%s': %s\n"),
1113                            home, strerror (errno) );
1114 #endif
1115               else 
1116                 {
1117                   if (!opt.quiet)
1118                     log_info (_("directory `%s' created\n"), home);
1119                   create_private_keys_directory (home);
1120                 }
1121             }
1122         }
1123       else
1124         log_error ("error stat-ing `%s': %s\n", home, strerror (errno));
1125     }
1126   else if ( !S_ISDIR(statbuf.st_mode))
1127     {
1128       log_error ("can't use `%s' as home directory\n", home);
1129     }
1130   else /* exists and is a directory. */
1131     {
1132       create_private_keys_directory (home);
1133     }
1134   xfree (home);
1135 }
1136
1137
1138
1139 #ifdef USE_GNU_PTH
1140 static void
1141 handle_signal (int signo)
1142 {
1143   switch (signo)
1144     {
1145 #ifndef HAVE_W32_SYSTEM
1146     case SIGHUP:
1147       log_info ("SIGHUP received - "
1148                 "re-reading configuration and flushing cache\n");
1149       agent_flush_cache ();
1150       reread_configuration ();
1151       agent_reload_trustlist ();
1152       break;
1153       
1154     case SIGUSR1:
1155       log_info ("SIGUSR1 received - no action defined\n");
1156       break;
1157       
1158     case SIGUSR2:
1159       log_info ("SIGUSR2 received - checking smartcard status\n");
1160       break;
1161
1162     case SIGTERM:
1163       if (!shutdown_pending)
1164         log_info ("SIGTERM received - shutting down ...\n");
1165       else
1166         log_info ("SIGTERM received - still %ld running threads\n",
1167                   pth_ctrl( PTH_CTRL_GETTHREADS ));
1168       shutdown_pending++;
1169       if (shutdown_pending > 2)
1170         {
1171           log_info ("shutdown forced\n");
1172           log_info ("%s %s stopped\n", strusage(11), strusage(13) );
1173           cleanup ();
1174           agent_exit (0);
1175         }
1176       break;
1177         
1178     case SIGINT:
1179       log_info ("SIGINT received - immediate shutdown\n");
1180       log_info( "%s %s stopped\n", strusage(11), strusage(13));
1181       cleanup ();
1182       agent_exit (0);
1183       break;
1184 #endif
1185     default:
1186       log_info ("signal %d received - no action defined\n", signo);
1187     }
1188 }
1189
1190
1191 static void *
1192 start_connection_thread (void *arg)
1193 {
1194   int fd = (int)arg;
1195
1196   if (opt.verbose)
1197     log_info ("handler for fd %d started\n", fd);
1198
1199   /* FIXME: Move this housekeeping into a ticker function.  Calling it
1200      for each connection should work but won't work anymore if our
1201      clients start to keep connections. */
1202   agent_trustlist_housekeeping ();
1203
1204   start_command_handler (-1, fd);
1205   if (opt.verbose)
1206     log_info ("handler for fd %d terminated\n", fd);
1207   
1208   return NULL;
1209 }
1210
1211
1212 static void
1213 handle_connections (int listen_fd)
1214 {
1215   pth_attr_t tattr;
1216   pth_event_t ev;
1217   sigset_t sigs;
1218   int signo;
1219   struct sockaddr_un paddr;
1220   socklen_t plen = sizeof( paddr );
1221   int fd;
1222
1223   tattr = pth_attr_new();
1224   pth_attr_set (tattr, PTH_ATTR_JOINABLE, 0);
1225   pth_attr_set (tattr, PTH_ATTR_STACK_SIZE, 256*1024);
1226   pth_attr_set (tattr, PTH_ATTR_NAME, "gpg-agent");
1227
1228 #ifndef HAVE_W32_SYSTEM /* fixme */
1229   sigemptyset (&sigs );
1230   sigaddset (&sigs, SIGHUP);
1231   sigaddset (&sigs, SIGUSR1);
1232   sigaddset (&sigs, SIGUSR2);
1233   sigaddset (&sigs, SIGINT);
1234   sigaddset (&sigs, SIGTERM);
1235   ev = pth_event (PTH_EVENT_SIGS, &sigs, &signo);
1236 #else
1237   ev = NULL;
1238 #endif
1239
1240   for (;;)
1241     {
1242       if (shutdown_pending)
1243         {
1244           if (pth_ctrl (PTH_CTRL_GETTHREADS) == 1)
1245             break; /* ready */
1246
1247           /* Do not accept anymore connections and wait for existing
1248              connections to terminate */
1249           signo = 0;
1250           pth_wait (ev);
1251           if (pth_event_occurred (ev) && signo)
1252             handle_signal (signo);
1253           continue;
1254         }
1255
1256       fd = pth_accept_ev (listen_fd, (struct sockaddr *)&paddr, &plen, ev);
1257       if (fd == -1)
1258         {
1259 #ifdef PTH_STATUS_OCCURRED     /* This is Pth 2 */
1260           if (pth_event_status (ev) == PTH_STATUS_OCCURRED)
1261 #else
1262           if (pth_event_occurred (ev))
1263 #endif
1264             {
1265               handle_signal (signo);
1266               continue;
1267             }
1268           log_error ("accept failed: %s - waiting 1s\n", strerror (errno));
1269           pth_sleep(1);
1270           continue;
1271         }
1272
1273       if (!pth_spawn (tattr, start_connection_thread, (void*)fd))
1274         {
1275           log_error ("error spawning connection handler: %s\n",
1276                      strerror (errno) );
1277           close (fd);
1278         }
1279     }
1280
1281   pth_event_free (ev, PTH_FREE_ALL);
1282   cleanup ();
1283   log_info ("%s %s stopped\n", strusage(11), strusage(13));
1284 }
1285 #endif /*USE_GNU_PTH*/
1286
1287
1288 /* Figure out whether an agent is available and running. Prints an
1289    error if not.  */
1290 static void
1291 check_for_running_agent ()
1292 {
1293   int rc;
1294   char *infostr, *p;
1295   assuan_context_t ctx;
1296   int prot, pid;
1297
1298   infostr = getenv ("GPG_AGENT_INFO");
1299   if (!infostr || !*infostr)
1300     {
1301       log_error (_("no gpg-agent running in this session\n"));
1302       return;
1303     }
1304
1305   infostr = xstrdup (infostr);
1306   if ( !(p = strchr (infostr, ':')) || p == infostr)
1307     {
1308       log_error (_("malformed GPG_AGENT_INFO environment variable\n"));
1309       xfree (infostr);
1310       return;
1311     }
1312
1313   *p++ = 0;
1314   pid = atoi (p);
1315   while (*p && *p != ':')
1316     p++;
1317   prot = *p? atoi (p+1) : 0;
1318   if (prot != 1)
1319     {
1320       log_error (_("gpg-agent protocol version %d is not supported\n"),
1321                  prot);
1322       xfree (infostr);
1323       return;
1324     }
1325
1326   rc = assuan_socket_connect (&ctx, infostr, pid);
1327   xfree (infostr);
1328   if (rc)
1329     {
1330       log_error ("can't connect to the agent: %s\n", assuan_strerror (rc));
1331       return;
1332     }
1333
1334   if (!opt.quiet)
1335     log_info ("gpg-agent running and available\n");
1336
1337   assuan_disconnect (ctx);
1338 }