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