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