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