[W32] Changed default socket for dirmngr.
[gnupg.git] / agent / gpg-agent.c
1 /* gpg-agent.c  -  The GnuPG Agent
2  * Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005,
3  *               2006, 2007 Free Software Foundation, Inc.
4  *
5  * This file is part of GnuPG.
6  *
7  * GnuPG is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 3 of the License, or
10  * (at your option) any later version.
11  *
12  * GnuPG is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, see <http://www.gnu.org/licenses/>.
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 #include <pth.h>
40
41 #define JNLIB_NEED_LOG_LOGV
42 #include "agent.h"
43 #include <assuan.h> /* Malloc hooks  and socket wrappers. */
44
45 #include "i18n.h"
46 #include "mkdtemp.h" /* Gnulib replacement. */
47 #include "sysutils.h"
48 #include "setenv.h"
49 #include "gc-opt-flags.h"
50
51
52 enum cmd_and_opt_values 
53 { aNull = 0,
54   oCsh            = 'c',
55   oQuiet          = 'q',
56   oSh             = 's',
57   oVerbose        = 'v',
58
59   oNoVerbose = 500,
60   aGPGConfList,
61   aGPGConfTest,
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   oPinentryTouchFile,
79   oDisplay,
80   oTTYname,
81   oTTYtype,
82   oLCctype,
83   oLCmessages,
84   oXauthority,
85   oScdaemonProgram,
86   oDefCacheTTL,
87   oDefCacheTTLSSH,
88   oMaxCacheTTL,
89   oMaxCacheTTLSSH,
90   oEnforcePassphraseConstraints,
91   oMinPassphraseLen,
92   oMinPassphraseNonalpha,
93   oCheckPassphrasePattern,
94   oMaxPassphraseDays,
95   oEnablePassphraseHistory,
96   oUseStandardSocket,
97   oNoUseStandardSocket,
98   oFakedSystemTime,
99
100   oIgnoreCacheForSigning,
101   oAllowMarkTrusted,
102   oAllowPresetPassphrase,
103   oKeepTTY,
104   oKeepDISPLAY,
105   oSSHSupport,
106   oDisableScdaemon,
107   oWriteEnvFile
108 };
109
110
111
112 static ARGPARSE_OPTS opts[] = {
113
114   { aGPGConfList, "gpgconf-list", 256, "@" },
115   { aGPGConfTest, "gpgconf-test", 256, "@" },
116   
117   { 301, NULL, 0, N_("@Options:\n ") },
118
119   { oServer,   "server",     0, N_("run in server mode (foreground)") },
120   { oDaemon,   "daemon",     0, N_("run in daemon mode (background)") },
121   { oVerbose, "verbose",     0, N_("verbose") },
122   { oQuiet,     "quiet",     0, N_("be somewhat more quiet") },
123   { oSh,        "sh",        0, N_("sh-style command output") },
124   { oCsh,       "csh",       0, N_("csh-style command output") },
125   { oOptions, "options"  , 2, N_("|FILE|read options from FILE")},
126   { oDebug,     "debug"     ,4|16, "@"},
127   { oDebugAll, "debug-all"     ,0, "@"},
128   { oDebugLevel, "debug-level" ,2, "@"},
129   { oDebugWait,"debug-wait",1, "@"},
130   { oNoDetach, "no-detach" ,0, N_("do not detach from the console")},
131   { oNoGrab, "no-grab"     ,0, N_("do not grab keyboard and mouse")},
132   { oLogFile, "log-file"   ,2, N_("use a log file for the server")},
133   { oUseStandardSocket, "use-standard-socket", 0,
134                       N_("use a standard location for the socket")},
135   { oNoUseStandardSocket, "no-use-standard-socket", 0, "@"},
136   { oPinentryProgram, "pinentry-program", 2 ,
137                                N_("|PGM|use PGM as the PIN-Entry program") },
138   { oPinentryTouchFile, "pinentry-touch-file", 2 , "@" },
139   { oScdaemonProgram, "scdaemon-program", 2 ,
140                                N_("|PGM|use PGM as the SCdaemon program") },
141   { oDisableScdaemon, "disable-scdaemon", 0, N_("do not use the SCdaemon") },
142   { oFakedSystemTime, "faked-system-time", 2, "@" }, /* (epoch time) */
143
144   { oDisplay,    "display",     2, "@" },
145   { oTTYname,    "ttyname",     2, "@" },
146   { oTTYtype,    "ttytype",     2, "@" },
147   { oLCctype,    "lc-ctype",    2, "@" },
148   { oLCmessages, "lc-messages", 2, "@" },
149   { oXauthority, "xauthority",  2, "@" },
150   { oKeepTTY,    "keep-tty",    0,  N_("ignore requests to change the TTY")},
151   { oKeepDISPLAY, "keep-display",
152                           0, N_("ignore requests to change the X display")},
153
154   { oDefCacheTTL, "default-cache-ttl", 4,
155                                N_("|N|expire cached PINs after N seconds")},
156   { oDefCacheTTLSSH, "default-cache-ttl-ssh", 4, "@" },
157   { oMaxCacheTTL, "max-cache-ttl", 4, "@" },
158   { oMaxCacheTTLSSH, "max-cache-ttl-ssh", 4, "@" },
159
160   { oEnforcePassphraseConstraints, "enforce-passphrase-constraints", 0, "@"},
161   { oMinPassphraseLen, "min-passphrase-len", 4, "@" },
162   { oMinPassphraseNonalpha, "min-passphrase-nonalpha", 4, "@" },
163   { oCheckPassphrasePattern, "check-passphrase-pattern", 2, "@" },
164   { oMaxPassphraseDays, "max-passphrase-days", 4, "@" },
165   { oEnablePassphraseHistory, "enable-passphrase-history", 0, "@" },
166
167   { oIgnoreCacheForSigning, "ignore-cache-for-signing", 0,
168                                N_("do not use the PIN cache when signing")},
169   { oAllowMarkTrusted, "allow-mark-trusted", 0,
170                              N_("allow clients to mark keys as \"trusted\"")},
171   { oAllowPresetPassphrase, "allow-preset-passphrase", 0,
172                              N_("allow presetting passphrase")},
173   { oSSHSupport, "enable-ssh-support", 0, N_("enable ssh-agent emulation") },
174   { oWriteEnvFile, "write-env-file", 2|8,
175             N_("|FILE|write environment settings also to FILE")},
176   {0}
177 };
178
179
180 #define DEFAULT_CACHE_TTL     (10*60)  /* 10 minutes */
181 #define DEFAULT_CACHE_TTL_SSH (30*60)  /* 30 minutes */
182 #define MAX_CACHE_TTL         (120*60) /* 2 hours */
183 #define MAX_CACHE_TTL_SSH     (120*60) /* 2 hours */
184 #define MIN_PASSPHRASE_LEN    (8)      
185 #define MIN_PASSPHRASE_NONALPHA (1)      
186 #define MAX_PASSPHRASE_DAYS   (0)
187
188 /* The timer tick used for housekeeping stuff.  For Windows we use a
189    longer period as the SetWaitableTimer seems to signal earlier than
190    the 2 seconds.  */
191 #ifdef HAVE_W32_SYSTEM
192 #define TIMERTICK_INTERVAL    (4)
193 #else
194 #define TIMERTICK_INTERVAL    (2)    /* Seconds.  */
195 #endif
196
197 /* flag to indicate that a shutdown was requested */
198 static int shutdown_pending;
199
200
201 /* It is possible that we are currently running under setuid permissions */
202 static int maybe_setuid = 1;
203
204 /* Name of the communication socket used for native gpg-agent requests.  */
205 static char *socket_name;
206
207 /* Name of the communication socket used for ssh-agent-emulation.  */
208 static char *socket_name_ssh;
209
210 /* We need to keep track of the server's nonces (these are dummies for
211    POSIX systems). */
212 static assuan_sock_nonce_t socket_nonce;
213 static assuan_sock_nonce_t socket_nonce_ssh;
214
215
216 /* Default values for options passed to the pinentry. */
217 static char *default_display;
218 static char *default_ttyname;
219 static char *default_ttytype;
220 static char *default_lc_ctype;
221 static char *default_lc_messages;
222 static char *default_xauthority;
223
224 /* Name of a config file, which will be reread on a HUP if it is not NULL. */
225 static char *config_filename;
226
227 /* Helper to implement --debug-level */
228 static const char *debug_level;
229
230 /* Keep track of the current log file so that we can avoid updating
231    the log file after a SIGHUP if it didn't changed. Malloced. */
232 static char *current_logfile;
233
234 /* The handle_tick() function may test whether a parent is still
235    running.  We record the PID of the parent here or -1 if it should be
236    watched. */
237 static pid_t parent_pid = (pid_t)(-1);
238
239 \f
240 /*
241    Local prototypes. 
242  */
243
244 static char *create_socket_name (int use_standard_socket,
245                                  char *standard_name, char *template);
246 static gnupg_fd_t create_server_socket (int is_standard_name, char *name, 
247                                         assuan_sock_nonce_t *nonce);
248 static void create_directories (void);
249
250 static void agent_init_default_ctrl (ctrl_t ctrl);
251 static void agent_deinit_default_ctrl (ctrl_t ctrl);
252
253 static void handle_connections (gnupg_fd_t listen_fd,
254                                 gnupg_fd_t listen_fd_ssh);
255 static int check_for_running_agent (int silent, int mode);
256
257 /* Pth wrapper function definitions. */
258 GCRY_THREAD_OPTION_PTH_IMPL;
259 static int fixed_gcry_pth_init (void)
260 {
261   return pth_self ()? 0 : (pth_init () == FALSE) ? errno : 0;
262 }
263
264
265
266 \f
267 /*
268    Functions. 
269  */
270
271
272 static const char *
273 my_strusage (int level)
274 {
275   const char *p;
276   switch (level)
277     {
278     case 11: p = "gpg-agent (GnuPG)";
279       break;
280     case 13: p = VERSION; break;
281     case 17: p = PRINTABLE_OS_NAME; break;
282     case 19: p = _("Please report bugs to <" PACKAGE_BUGREPORT ">.\n");
283       break;
284     case 1:
285     case 40: p =  _("Usage: gpg-agent [options] (-h for help)");
286       break;
287     case 41: p =  _("Syntax: gpg-agent [options] [command [args]]\n"
288                     "Secret key management for GnuPG\n");
289     break;
290     
291     default: p = NULL;
292     }
293   return p;
294 }
295
296
297
298 /* Setup the debugging.  With the global variable DEBUG_LEVEL set to NULL
299    only the active debug flags are propagated to the subsystems.  With
300    DEBUG_LEVEL set, a specific set of debug flags is set; thus overriding
301    all flags already set. Note that we don't fail here, because it is
302    important to keep gpg-agent running even after re-reading the
303    options due to a SIGHUP. */
304 static void
305 set_debug (void)
306 {
307   if (!debug_level)
308     ;
309   else if (!strcmp (debug_level, "none"))
310     opt.debug = 0;
311   else if (!strcmp (debug_level, "basic"))
312     opt.debug = DBG_ASSUAN_VALUE;
313   else if (!strcmp (debug_level, "advanced"))
314     opt.debug = DBG_ASSUAN_VALUE|DBG_COMMAND_VALUE;
315   else if (!strcmp (debug_level, "expert"))
316     opt.debug = (DBG_ASSUAN_VALUE|DBG_COMMAND_VALUE
317                  |DBG_CACHE_VALUE);
318   else if (!strcmp (debug_level, "guru"))
319     opt.debug = ~0;
320   else
321     {
322       log_error (_("invalid debug-level `%s' given\n"), debug_level);
323       opt.debug = 0; /* Reset debugging, so that prior debug
324                         statements won't have an undesired effect. */
325     }
326
327   if (opt.debug && !opt.verbose)
328     opt.verbose = 1;
329   if (opt.debug && opt.quiet)
330     opt.quiet = 0;
331
332   if (opt.debug & DBG_MPI_VALUE)
333     gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 2);
334   if (opt.debug & DBG_CRYPTO_VALUE )
335     gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 1);
336   gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
337 }
338  
339
340 /* Helper for cleanup to remove one socket with NAME.  */
341 static void
342 remove_socket (char *name)
343 {
344   if (name && *name)
345     {
346       char *p;
347
348       remove (name);
349       p = strrchr (name, '/');
350       if (p)
351         {
352           *p = 0;
353           rmdir (name);
354           *p = '/';
355         }
356       *name = 0;
357     }
358 }  
359
360 static void
361 cleanup (void)
362 {
363   remove_socket (socket_name);
364   remove_socket (socket_name_ssh);
365 }
366
367
368
369 /* Handle options which are allowed to be reset after program start.
370    Return true when the current option in PARGS could be handled and
371    false if not.  As a special feature, passing a value of NULL for
372    PARGS, resets the options to the default.  REREAD should be set
373    true if it is not the initial option parsing. */
374 static int
375 parse_rereadable_options (ARGPARSE_ARGS *pargs, int reread)
376 {
377   if (!pargs)
378     { /* reset mode */
379       opt.quiet = 0;
380       opt.verbose = 0;
381       opt.debug = 0;
382       opt.no_grab = 0;
383       opt.pinentry_program = NULL;
384       opt.pinentry_touch_file = NULL;
385       opt.scdaemon_program = NULL;
386       opt.def_cache_ttl = DEFAULT_CACHE_TTL;
387       opt.def_cache_ttl_ssh = DEFAULT_CACHE_TTL_SSH;
388       opt.max_cache_ttl = MAX_CACHE_TTL;
389       opt.max_cache_ttl_ssh = MAX_CACHE_TTL_SSH;
390       opt.enforce_passphrase_constraints = 0;
391       opt.min_passphrase_len = MIN_PASSPHRASE_LEN;
392       opt.min_passphrase_nonalpha = MIN_PASSPHRASE_NONALPHA;
393       opt.check_passphrase_pattern = NULL;
394       opt.max_passphrase_days = MAX_PASSPHRASE_DAYS;
395       opt.enable_passhrase_history = 0;
396       opt.ignore_cache_for_signing = 0;
397       opt.allow_mark_trusted = 0;
398       opt.disable_scdaemon = 0;
399       return 1;
400     }
401
402   switch (pargs->r_opt)
403     {
404     case oQuiet: opt.quiet = 1; break;
405     case oVerbose: opt.verbose++; break;
406
407     case oDebug: opt.debug |= pargs->r.ret_ulong; break;
408     case oDebugAll: opt.debug = ~0; break;
409     case oDebugLevel: debug_level = pargs->r.ret_str; break;
410
411     case oLogFile:
412       if (!reread)
413         return 0; /* not handeld */
414       if (!current_logfile || !pargs->r.ret_str
415           || strcmp (current_logfile, pargs->r.ret_str))
416         {
417           log_set_file (pargs->r.ret_str);
418           xfree (current_logfile);
419           current_logfile = xtrystrdup (pargs->r.ret_str);
420         }
421       break;
422
423     case oNoGrab: opt.no_grab = 1; break;
424       
425     case oPinentryProgram: opt.pinentry_program = pargs->r.ret_str; break;
426     case oPinentryTouchFile: opt.pinentry_touch_file = pargs->r.ret_str; break;
427     case oScdaemonProgram: opt.scdaemon_program = pargs->r.ret_str; break;
428     case oDisableScdaemon: opt.disable_scdaemon = 1; break;
429
430     case oDefCacheTTL: opt.def_cache_ttl = pargs->r.ret_ulong; break;
431     case oDefCacheTTLSSH: opt.def_cache_ttl_ssh = pargs->r.ret_ulong; break;
432     case oMaxCacheTTL: opt.max_cache_ttl = pargs->r.ret_ulong; break;
433     case oMaxCacheTTLSSH: opt.max_cache_ttl_ssh = pargs->r.ret_ulong; break;
434       
435     case oEnforcePassphraseConstraints: 
436       opt.enforce_passphrase_constraints=1;
437       break;
438     case oMinPassphraseLen: opt.min_passphrase_len = pargs->r.ret_ulong; break;
439     case oMinPassphraseNonalpha: 
440       opt.min_passphrase_nonalpha = pargs->r.ret_ulong;
441       break;
442     case oCheckPassphrasePattern:
443       opt.check_passphrase_pattern = pargs->r.ret_str;
444       break;
445     case oMaxPassphraseDays:
446       opt.max_passphrase_days = pargs->r.ret_ulong; 
447       break;
448     case oEnablePassphraseHistory:
449       opt.enable_passhrase_history = 1;
450       break;
451
452     case oIgnoreCacheForSigning: opt.ignore_cache_for_signing = 1; break;
453
454     case oAllowMarkTrusted: opt.allow_mark_trusted = 1; break;
455
456     case oAllowPresetPassphrase: opt.allow_preset_passphrase = 1; break;
457
458     default:
459       return 0; /* not handled */
460     }
461
462   return 1; /* handled */
463 }
464
465
466 /* The main entry point.  */
467 int
468 main (int argc, char **argv )
469 {
470   ARGPARSE_ARGS pargs;
471   int orig_argc;
472   int may_coredump;
473   char **orig_argv;
474   FILE *configfp = NULL;
475   char *configname = NULL;
476   const char *shell;
477   unsigned configlineno;
478   int parse_debug = 0;
479   int default_config =1;
480   int greeting = 0;
481   int nogreeting = 0;
482   int pipe_server = 0;
483   int is_daemon = 0;
484   int nodetach = 0;
485   int csh_style = 0;
486   char *logfile = NULL;
487   int debug_wait = 0;
488   int gpgconf_list = 0;
489   int standard_socket = 0;
490   gpg_error_t err;
491   const char *env_file_name = NULL;
492
493
494   set_strusage (my_strusage);
495   gcry_control (GCRYCTL_SUSPEND_SECMEM_WARN);
496   /* Please note that we may running SUID(ROOT), so be very CAREFUL
497      when adding any stuff between here and the call to INIT_SECMEM()
498      somewhere after the option parsing */
499   log_set_prefix ("gpg-agent", JNLIB_LOG_WITH_PREFIX|JNLIB_LOG_WITH_PID); 
500
501   /* Make sure that our subsystems are ready.  */
502   init_common_subsystems ();
503
504   i18n_init ();
505
506   /* Libgcrypt requires us to register the threading model first.
507      Note that this will also do the pth_init. */
508   gcry_threads_pth.init = fixed_gcry_pth_init;
509   err = gcry_control (GCRYCTL_SET_THREAD_CBS, &gcry_threads_pth);
510   if (err)
511     {
512       log_fatal ("can't register GNU Pth with Libgcrypt: %s\n",
513                  gpg_strerror (err));
514     }
515
516
517   /* Check that the libraries are suitable.  Do it here because
518      the option parsing may need services of the library. */
519   if (!gcry_check_version (NEED_LIBGCRYPT_VERSION) )
520     {
521       log_fatal( _("%s is too old (need %s, have %s)\n"), "libgcrypt",
522                  NEED_LIBGCRYPT_VERSION, gcry_check_version (NULL) );
523     }
524
525   assuan_set_malloc_hooks (gcry_malloc, gcry_realloc, gcry_free);
526   assuan_set_assuan_log_stream (log_get_stream ());
527   assuan_set_assuan_log_prefix (log_get_prefix (NULL));
528   assuan_set_assuan_err_source (GPG_ERR_SOURCE_DEFAULT);
529
530   setup_libgcrypt_logging ();
531   gcry_control (GCRYCTL_USE_SECURE_RNDPOOL);
532
533   may_coredump = disable_core_dumps ();
534
535   /* Set default options.  */
536   parse_rereadable_options (NULL, 0); /* Reset them to default values. */
537 #ifdef HAVE_W32_SYSTEM
538   standard_socket = 1;  /* Under Windows we always use a standard
539                            socket.  */
540 #endif
541   
542   shell = getenv ("SHELL");
543   if (shell && strlen (shell) >= 3 && !strcmp (shell+strlen (shell)-3, "csh") )
544     csh_style = 1;
545
546   opt.homedir = default_homedir ();
547
548   /* Record some of the original environment strings. */
549   opt.startup_display = getenv ("DISPLAY");
550   if (opt.startup_display)
551     opt.startup_display = xstrdup (opt.startup_display);
552   opt.startup_ttyname = ttyname (0);
553   if (opt.startup_ttyname)
554     opt.startup_ttyname = xstrdup (opt.startup_ttyname);
555   opt.startup_ttytype = getenv ("TERM");
556   if (opt.startup_ttytype)
557     opt.startup_ttytype = xstrdup (opt.startup_ttytype);
558   /* Fixme: Better use the locale function here.  */
559   opt.startup_lc_ctype = getenv ("LC_CTYPE");
560   if (opt.startup_lc_ctype) 
561     opt.startup_lc_ctype = xstrdup (opt.startup_lc_ctype);
562   opt.startup_lc_messages = getenv ("LC_MESSAGES");
563   if (opt.startup_lc_messages)
564     opt.startup_lc_messages = xstrdup (opt.startup_lc_messages);
565   opt.startup_xauthority = getenv ("XAUTHORITY");
566   if (opt.startup_xauthority)
567     opt.startup_xauthority = xstrdup (opt.startup_xauthority);
568   opt.startup_pinentry_user_data = getenv ("PINENTRY_USER_DATA");
569   if (opt.startup_pinentry_user_data)
570     opt.startup_pinentry_user_data = xstrdup (opt.startup_pinentry_user_data);
571
572   /* Check whether we have a config file on the commandline */
573   orig_argc = argc;
574   orig_argv = argv;
575   pargs.argc = &argc;
576   pargs.argv = &argv;
577   pargs.flags= 1|(1<<6);  /* do not remove the args, ignore version */
578   while (arg_parse( &pargs, opts))
579     {
580       if (pargs.r_opt == oDebug || pargs.r_opt == oDebugAll)
581         parse_debug++;
582       else if (pargs.r_opt == oOptions)
583         { /* yes there is one, so we do not try the default one, but
584              read the option file when it is encountered at the
585              commandline */
586           default_config = 0;
587         }
588         else if (pargs.r_opt == oNoOptions)
589           default_config = 0; /* --no-options */
590         else if (pargs.r_opt == oHomedir)
591           opt.homedir = pargs.r.ret_str;
592     }
593
594   /* Initialize the secure memory. */
595   gcry_control (GCRYCTL_INIT_SECMEM, 32768, 0);
596   maybe_setuid = 0;
597
598   /* 
599      Now we are now working under our real uid 
600   */
601
602   if (default_config)
603     configname = make_filename (opt.homedir, "gpg-agent.conf", NULL );
604   
605   argc = orig_argc;
606   argv = orig_argv;
607   pargs.argc = &argc;
608   pargs.argv = &argv;
609   pargs.flags=  1;  /* do not remove the args */
610  next_pass:
611   if (configname)
612     {
613       configlineno = 0;
614       configfp = fopen (configname, "r");
615       if (!configfp)
616         {
617           if (default_config)
618             {
619               if( parse_debug )
620                 log_info (_("NOTE: no default option file `%s'\n"),
621                           configname );
622             }
623           else
624             {
625               log_error (_("option file `%s': %s\n"),
626                          configname, strerror(errno) );
627               exit(2);
628             }
629           xfree (configname); 
630           configname = NULL;
631         }
632       if (parse_debug && configname )
633         log_info (_("reading options from `%s'\n"), configname );
634       default_config = 0;
635     }
636
637   while (optfile_parse( configfp, configname, &configlineno, &pargs, opts) )
638     {
639       if (parse_rereadable_options (&pargs, 0))
640         continue; /* Already handled */
641       switch (pargs.r_opt)
642         {
643         case aGPGConfList: gpgconf_list = 1; break;
644         case aGPGConfTest: gpgconf_list = 2; break;
645         case oBatch: opt.batch=1; break;
646
647         case oDebugWait: debug_wait = pargs.r.ret_int; break;
648
649         case oOptions:
650           /* config files may not be nested (silently ignore them) */
651           if (!configfp)
652             {
653                 xfree(configname);
654                 configname = xstrdup(pargs.r.ret_str);
655                 goto next_pass;
656             }
657           break;
658         case oNoGreeting: nogreeting = 1; break;
659         case oNoVerbose: opt.verbose = 0; break;
660         case oNoOptions: break; /* no-options */
661         case oHomedir: opt.homedir = pargs.r.ret_str; break;
662         case oNoDetach: nodetach = 1; break;
663         case oLogFile: logfile = pargs.r.ret_str; break;
664         case oCsh: csh_style = 1; break;
665         case oSh: csh_style = 0; break;
666         case oServer: pipe_server = 1; break;
667         case oDaemon: is_daemon = 1; break;
668
669         case oDisplay: default_display = xstrdup (pargs.r.ret_str); break;
670         case oTTYname: default_ttyname = xstrdup (pargs.r.ret_str); break;
671         case oTTYtype: default_ttytype = xstrdup (pargs.r.ret_str); break;
672         case oLCctype: default_lc_ctype = xstrdup (pargs.r.ret_str); break;
673         case oLCmessages: default_lc_messages = xstrdup (pargs.r.ret_str);
674         case oXauthority: default_xauthority = xstrdup (pargs.r.ret_str);
675           break;
676
677         case oUseStandardSocket: standard_socket = 1; break;
678         case oNoUseStandardSocket: standard_socket = 0; break;
679
680         case oFakedSystemTime:
681           {
682             time_t faked_time = isotime2epoch (pargs.r.ret_str); 
683             if (faked_time == (time_t)(-1))
684               faked_time = (time_t)strtoul (pargs.r.ret_str, NULL, 10);
685             gnupg_set_time (faked_time, 0);
686           }
687           break;
688
689         case oKeepTTY: opt.keep_tty = 1; break;
690         case oKeepDISPLAY: opt.keep_display = 1; break;
691
692         case oSSHSupport:  opt.ssh_support = 1; break;
693         case oWriteEnvFile:
694           if (pargs.r_type)
695             env_file_name = pargs.r.ret_str;
696           else
697             env_file_name = make_filename ("~/.gpg-agent-info", NULL);
698           break;
699
700         default : pargs.err = configfp? 1:2; break;
701         }
702     }
703   if (configfp)
704     {
705       fclose( configfp );
706       configfp = NULL;
707       /* Keep a copy of the name so that it can be read on SIGHUP. */
708       config_filename = configname;
709       configname = NULL;
710       goto next_pass;
711     }
712   xfree (configname);
713   configname = NULL;
714   if (log_get_errorcount(0))
715     exit(2);
716   if (nogreeting )
717     greeting = 0;
718
719   if (greeting)
720     {
721       fprintf (stderr, "%s %s; %s\n",
722                  strusage(11), strusage(13), strusage(14) );
723       fprintf (stderr, "%s\n", strusage(15) );
724     }
725 #ifdef IS_DEVELOPMENT_VERSION
726   /* We don't want to print it here because gpg-agent is useful of its
727      own and quite matured.  */
728   /*log_info ("NOTE: this is a development version!\n");*/
729 #endif
730
731   set_debug ();
732   
733   if (atexit (cleanup))
734     {
735       log_error ("atexit failed\n");
736       cleanup ();
737       exit (1);
738     }
739
740   initialize_module_call_pinentry ();
741   initialize_module_call_scd ();
742   initialize_module_trustlist ();
743   
744   /* Try to create missing directories. */
745   create_directories ();
746
747   if (debug_wait && pipe_server)
748     {
749       log_debug ("waiting for debugger - my pid is %u .....\n",
750                  (unsigned int)getpid());
751       gnupg_sleep (debug_wait);
752       log_debug ("... okay\n");
753     }
754   
755   if (gpgconf_list == 2)
756     agent_exit (0);
757   if (gpgconf_list)
758     {
759       char *filename;
760       char *filename_esc;
761
762       /* List options and default values in the GPG Conf format.  */
763       filename = make_filename (opt.homedir, "gpg-agent.conf", NULL );
764       filename_esc = percent_escape (filename, NULL);
765
766       printf ("gpgconf-gpg-agent.conf:%lu:\"%s\n",
767               GC_OPT_FLAG_DEFAULT, filename_esc);
768       xfree (filename);
769       xfree (filename_esc);
770
771       printf ("verbose:%lu:\n"
772               "quiet:%lu:\n"
773               "debug-level:%lu:\"none:\n"
774               "log-file:%lu:\n",
775               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME,
776               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME,
777               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME,
778               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME );
779       printf ("default-cache-ttl:%lu:%d:\n",
780               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME, DEFAULT_CACHE_TTL );
781       printf ("default-cache-ttl-ssh:%lu:%d:\n",
782               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME, DEFAULT_CACHE_TTL_SSH );
783       printf ("max-cache-ttl:%lu:%d:\n",
784               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME, MAX_CACHE_TTL );
785       printf ("max-cache-ttl-ssh:%lu:%d:\n",
786               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME, MAX_CACHE_TTL_SSH );
787       printf ("enforce-passphrase-constraints:%lu:\n", 
788               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
789       printf ("min-passphrase-len:%lu:%d:\n",
790               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME, MIN_PASSPHRASE_LEN );
791       printf ("min-passphrase-nonalpha:%lu:%d:\n",
792               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME, 
793               MIN_PASSPHRASE_NONALPHA);
794       printf ("check-passphrase-pattern:%lu:\n",
795               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME);
796       printf ("max-passphrase-days:%lu:%d:\n",
797               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME, 
798               MAX_PASSPHRASE_DAYS);
799       printf ("enable-passphrase-history:%lu:\n", 
800               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
801       printf ("no-grab:%lu:\n", 
802               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
803       printf ("ignore-cache-for-signing:%lu:\n",
804               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
805       printf ("allow-mark-trusted:%lu:\n",
806               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
807       printf ("disable-scdaemon:%lu:\n",
808               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
809
810       agent_exit (0);
811     }
812
813   /* If this has been called without any options, we merely check
814      whether an agent is already running.  We do this here so that we
815      don't clobber a logfile but print it directly to stderr. */
816   if (!pipe_server && !is_daemon)
817     {
818       log_set_prefix (NULL, JNLIB_LOG_WITH_PREFIX); 
819       check_for_running_agent (0, 0);
820       agent_exit (0);
821     }
822   
823 #ifdef ENABLE_NLS
824   /* gpg-agent usually does not output any messages because it runs in
825      the background.  For log files it is acceptable to have messages
826      always encoded in utf-8.  We switch here to utf-8, so that
827      commands like --help still give native messages.  It is far
828      easier to switch only once instead of for every message and it
829      actually helps when more then one thread is active (avoids an
830      extra copy step). */
831     bind_textdomain_codeset (PACKAGE_GT, "UTF-8");
832 #endif
833
834   /* Now start with logging to a file if this is desired. */
835   if (logfile)
836     {
837       log_set_file (logfile);
838       log_set_prefix (NULL, (JNLIB_LOG_WITH_PREFIX
839                              |JNLIB_LOG_WITH_TIME
840                              |JNLIB_LOG_WITH_PID));
841       current_logfile = xstrdup (logfile);
842     }
843
844   /* Make sure that we have a default ttyname. */
845   if (!default_ttyname && ttyname (1))
846     default_ttyname = xstrdup (ttyname (1));
847   if (!default_ttytype && getenv ("TERM"))
848     default_ttytype = xstrdup (getenv ("TERM"));
849
850
851   if (pipe_server)
852     { 
853       /* This is the simple pipe based server */
854       ctrl_t ctrl;
855
856       ctrl = xtrycalloc (1, sizeof *ctrl);
857       if (!ctrl)
858         {
859           log_error ("error allocating connection control data: %s\n",
860                      strerror (errno) );
861           agent_exit (1);
862         }
863       agent_init_default_ctrl (ctrl);
864       start_command_handler (ctrl, GNUPG_INVALID_FD, GNUPG_INVALID_FD);
865       agent_deinit_default_ctrl (ctrl);
866       xfree (ctrl);
867     }
868   else if (!is_daemon)
869     ; /* NOTREACHED */
870   else
871     { /* Regular server mode */
872       gnupg_fd_t fd;
873       gnupg_fd_t fd_ssh;
874       pid_t pid;
875
876       /* Remove the DISPLAY variable so that a pinentry does not
877          default to a specific display.  There is still a default
878          display when gpg-agent was started using --display or a
879          client requested this using an OPTION command.  Note, that we
880          don't do this when running in reverse daemon mode (i.e. when
881          exec the program given as arguments). */
882 #ifndef HAVE_W32_SYSTEM
883       if (!opt.keep_display && !argc)
884         unsetenv ("DISPLAY");
885 #endif
886
887
888       /* Create the sockets.  */
889       socket_name = create_socket_name (standard_socket,
890                                         "S.gpg-agent",
891                                         "/tmp/gpg-XXXXXX/S.gpg-agent");
892       if (opt.ssh_support)
893         socket_name_ssh = create_socket_name (standard_socket, 
894                                             "S.gpg-agent.ssh",
895                                             "/tmp/gpg-XXXXXX/S.gpg-agent.ssh");
896
897       fd = create_server_socket (standard_socket, socket_name,
898                                  &socket_nonce);
899       if (opt.ssh_support)
900         fd_ssh = create_server_socket (standard_socket, socket_name_ssh,
901                                        &socket_nonce_ssh);
902       else
903         fd_ssh = GNUPG_INVALID_FD;
904
905       /* If we are going to exec a program in the parent, we record
906          the PID, so that the child may check whether the program is
907          still alive. */
908       if (argc)
909         parent_pid = getpid ();
910
911       fflush (NULL);
912 #ifdef HAVE_W32_SYSTEM
913       pid = getpid ();
914       printf ("set GPG_AGENT_INFO=%s;%lu;1\n", socket_name, (ulong)pid);
915 #else /*!HAVE_W32_SYSTEM*/
916       pid = fork ();
917       if (pid == (pid_t)-1) 
918         {
919           log_fatal ("fork failed: %s\n", strerror (errno) );
920           exit (1);
921         }
922       else if (pid) 
923         { /* We are the parent */
924           char *infostr, *infostr_ssh_sock, *infostr_ssh_pid;
925           
926           close (fd);
927           
928           /* Create the info string: <name>:<pid>:<protocol_version> */
929           if (asprintf (&infostr, "GPG_AGENT_INFO=%s:%lu:1",
930                         socket_name, (ulong)pid ) < 0)
931             {
932               log_error ("out of core\n");
933               kill (pid, SIGTERM);
934               exit (1);
935             }
936           if (opt.ssh_support)
937             {
938               if (asprintf (&infostr_ssh_sock, "SSH_AUTH_SOCK=%s",
939                             socket_name_ssh) < 0)
940                 {
941                   log_error ("out of core\n");
942                   kill (pid, SIGTERM);
943                   exit (1);
944                 }
945               if (asprintf (&infostr_ssh_pid, "SSH_AGENT_PID=%u",
946                             pid) < 0)
947                 {
948                   log_error ("out of core\n");
949                   kill (pid, SIGTERM);
950                   exit (1);
951                 }
952             }
953
954           *socket_name = 0; /* Don't let cleanup() remove the socket -
955                                the child should do this from now on */
956           if (opt.ssh_support)
957             *socket_name_ssh = 0;
958
959           if (env_file_name)
960             {
961               FILE *fp;
962               
963               fp = fopen (env_file_name, "w");
964               if (!fp)
965                 log_error (_("error creating `%s': %s\n"),
966                              env_file_name, strerror (errno));
967               else
968                 {
969                   fputs (infostr, fp);
970                   putc ('\n', fp);
971                   if (opt.ssh_support)
972                     {
973                       fputs (infostr_ssh_sock, fp);
974                       putc ('\n', fp);
975                       fputs (infostr_ssh_pid, fp);
976                       putc ('\n', fp);
977                     }
978                   fclose (fp);
979                 }
980             }
981
982
983           if (argc) 
984             { /* Run the program given on the commandline.  */
985               if (putenv (infostr))
986                 {
987                   log_error ("failed to set environment: %s\n",
988                              strerror (errno) );
989                   kill (pid, SIGTERM );
990                   exit (1);
991                 }
992               if (opt.ssh_support && putenv (infostr_ssh_sock))
993                 {
994                   log_error ("failed to set environment: %s\n",
995                              strerror (errno) );
996                   kill (pid, SIGTERM );
997                   exit (1);
998                 }
999               if (opt.ssh_support && putenv (infostr_ssh_pid))
1000                 {
1001                   log_error ("failed to set environment: %s\n",
1002                              strerror (errno) );
1003                   kill (pid, SIGTERM );
1004                   exit (1);
1005                 }
1006               execvp (argv[0], argv);
1007               log_error ("failed to run the command: %s\n", strerror (errno));
1008               kill (pid, SIGTERM);
1009               exit (1);
1010             }
1011           else
1012             {
1013               /* Print the environment string, so that the caller can use
1014                  shell's eval to set it */
1015               if (csh_style)
1016                 {
1017                   *strchr (infostr, '=') = ' ';
1018                   printf ("setenv %s\n", infostr);
1019                   if (opt.ssh_support)
1020                     {
1021                       *strchr (infostr_ssh_sock, '=') = ' ';
1022                       printf ("setenv %s\n", infostr_ssh_sock);
1023                       *strchr (infostr_ssh_pid, '=') = ' ';
1024                       printf ("setenv %s\n", infostr_ssh_pid);
1025                     }
1026                 }
1027               else
1028                 {
1029                   printf ( "%s; export GPG_AGENT_INFO;\n", infostr);
1030                   if (opt.ssh_support)
1031                     {
1032                       printf ("%s; export SSH_AUTH_SOCK;\n", infostr_ssh_sock);
1033                       printf ("%s; export SSH_AGENT_PID;\n", infostr_ssh_pid);
1034                     }
1035                 }
1036               free (infostr); /* (Note that a vanilla free is here correct.) */
1037               if (opt.ssh_support)
1038                 {
1039                   free (infostr_ssh_sock);
1040                   free (infostr_ssh_pid);
1041                 }
1042               exit (0); 
1043             }
1044           /*NOTREACHED*/
1045         } /* End parent */
1046
1047       /* 
1048          This is the child
1049        */
1050
1051       /* Detach from tty and put process into a new session */
1052       if (!nodetach )
1053         { 
1054           int i;
1055           unsigned int oldflags;
1056
1057           /* Close stdin, stdout and stderr unless it is the log stream */
1058           for (i=0; i <= 2; i++) 
1059             {
1060               if (!log_test_fd (i) && i != fd )
1061                 {
1062                   if ( ! close (i)
1063                        && open ("/dev/null", i? O_WRONLY : O_RDONLY) == -1)
1064                     {
1065                       log_error ("failed to open `%s': %s\n",
1066                                  "/dev/null", strerror (errno));
1067                       cleanup ();
1068                       exit (1);
1069                     }
1070                 }
1071             }
1072           if (setsid() == -1)
1073             {
1074               log_error ("setsid() failed: %s\n", strerror(errno) );
1075               cleanup ();
1076               exit (1);
1077             }
1078
1079           log_get_prefix (&oldflags);
1080           log_set_prefix (NULL, oldflags | JNLIB_LOG_RUN_DETACHED);
1081           opt.running_detached = 1;
1082         }
1083
1084       if (chdir("/"))
1085         {
1086           log_error ("chdir to / failed: %s\n", strerror (errno));
1087           exit (1);
1088         }
1089
1090       {
1091         struct sigaction sa;
1092         
1093         sa.sa_handler = SIG_IGN;
1094         sigemptyset (&sa.sa_mask);
1095         sa.sa_flags = 0;
1096         sigaction (SIGPIPE, &sa, NULL);
1097       }
1098 #endif /*!HAVE_W32_SYSTEM*/
1099
1100       handle_connections (fd, opt.ssh_support ? fd_ssh : GNUPG_INVALID_FD);
1101       assuan_sock_close (fd);
1102     }
1103   
1104   return 0;
1105 }
1106
1107
1108 void
1109 agent_exit (int rc)
1110 {
1111   /*FIXME: update_random_seed_file();*/
1112 #if 1
1113   /* at this time a bit annoying */
1114   if (opt.debug & DBG_MEMSTAT_VALUE)
1115     {
1116       gcry_control( GCRYCTL_DUMP_MEMORY_STATS );
1117       gcry_control( GCRYCTL_DUMP_RANDOM_STATS );
1118     }
1119   if (opt.debug)
1120     gcry_control (GCRYCTL_DUMP_SECMEM_STATS );
1121 #endif
1122   gcry_control (GCRYCTL_TERM_SECMEM );
1123   rc = rc? rc : log_get_errorcount(0)? 2 : 0;
1124   exit (rc);
1125 }
1126
1127 static void
1128 agent_init_default_ctrl (ctrl_t ctrl)
1129 {
1130   /* Note we ignore malloc errors because we can't do much about it
1131      and the request will fail anyway shortly after this
1132      initialization. */
1133   if (ctrl->display)
1134     free (ctrl->display);
1135   ctrl->display = default_display? strdup (default_display) : NULL;
1136
1137   if (ctrl->ttyname)
1138     free (ctrl->ttyname);
1139   ctrl->ttyname = default_ttyname? strdup (default_ttyname) : NULL;
1140
1141   if (ctrl->ttytype)
1142     free (ctrl->ttytype);
1143   ctrl->ttytype = default_ttytype? strdup (default_ttytype) : NULL;
1144
1145   if (ctrl->lc_ctype)
1146     free (ctrl->lc_ctype);
1147   ctrl->lc_ctype = default_lc_ctype? strdup (default_lc_ctype) : NULL;
1148
1149   if (ctrl->lc_messages)
1150     free (ctrl->lc_messages);
1151   ctrl->lc_messages = default_lc_messages? strdup (default_lc_messages) : NULL;
1152
1153   if (ctrl->xauthority)
1154     free (ctrl->xauthority);
1155   ctrl->xauthority = default_xauthority? strdup (default_xauthority) : NULL;
1156
1157   if (ctrl->pinentry_user_data)
1158     free (ctrl->pinentry_user_data);
1159   ctrl->pinentry_user_data = NULL;
1160 }
1161
1162
1163 static void
1164 agent_deinit_default_ctrl (ctrl_t ctrl)
1165 {
1166   if (ctrl->display)
1167     free (ctrl->display);
1168   if (ctrl->ttyname)
1169     free (ctrl->ttyname);
1170   if (ctrl->ttytype)
1171     free (ctrl->ttytype);
1172   if (ctrl->lc_ctype)
1173     free (ctrl->lc_ctype);
1174   if (ctrl->lc_messages)
1175     free (ctrl->lc_messages);
1176   if (ctrl->xauthority)
1177     free (ctrl->xauthority);
1178   if (ctrl->pinentry_user_data)
1179     free (ctrl->pinentry_user_data);
1180 }
1181
1182 /* Reread parts of the configuration.  Note, that this function is
1183    obviously not thread-safe and should only be called from the PTH
1184    signal handler. 
1185
1186    Fixme: Due to the way the argument parsing works, we create a
1187    memory leak here for all string type arguments.  There is currently
1188    no clean way to tell whether the memory for the argument has been
1189    allocated or points into the process' original arguments.  Unless
1190    we have a mechanism to tell this, we need to live on with this. */
1191 static void
1192 reread_configuration (void)
1193 {
1194   ARGPARSE_ARGS pargs;
1195   FILE *fp;
1196   unsigned int configlineno = 0;
1197   int dummy;
1198
1199   if (!config_filename)
1200     return; /* No config file. */
1201
1202   fp = fopen (config_filename, "r");
1203   if (!fp)
1204     {
1205       log_error (_("option file `%s': %s\n"),
1206                  config_filename, strerror(errno) );
1207       return;
1208     }
1209
1210   parse_rereadable_options (NULL, 1); /* Start from the default values. */
1211
1212   memset (&pargs, 0, sizeof pargs);
1213   dummy = 0;
1214   pargs.argc = &dummy;
1215   pargs.flags = 1;  /* do not remove the args */
1216   while (optfile_parse (fp, config_filename, &configlineno, &pargs, opts) )
1217     {
1218       if (pargs.r_opt < -1)
1219         pargs.err = 1; /* Print a warning. */
1220       else /* Try to parse this option - ignore unchangeable ones. */
1221         parse_rereadable_options (&pargs, 1);
1222     }
1223   fclose (fp);
1224   set_debug ();
1225 }
1226
1227
1228 /* Return the file name of the socket we are using for native
1229    requests.  */
1230 const char *
1231 get_agent_socket_name (void)
1232 {
1233   const char *s = socket_name;
1234
1235   return (s && *s)? s : NULL;
1236 }
1237
1238 /* Return the file name of the socket we are using for SSH
1239    requests.  */
1240 const char *
1241 get_agent_ssh_socket_name (void)
1242 {
1243   const char *s = socket_name_ssh;
1244
1245   return (s && *s)? s : NULL;
1246 }
1247
1248
1249 /* Under W32, this function returns the handle of the scdaemon
1250    notification event.  Calling it the first time creates that
1251    event.  */
1252 #ifdef HAVE_W32_SYSTEM
1253 void *
1254 get_agent_scd_notify_event (void)
1255 {
1256   static HANDLE the_event;
1257
1258   if (!the_event)
1259     {
1260       SECURITY_ATTRIBUTES sa = { sizeof (SECURITY_ATTRIBUTES), NULL, TRUE};
1261
1262       the_event = CreateEvent ( &sa, FALSE, FALSE, NULL);
1263       if (!the_event)
1264         log_error ("can't create scd notify event: %s\n", w32_strerror (-1) );
1265     }
1266   return the_event;
1267 }
1268 #endif /*HAVE_W32_SYSTEM*/
1269
1270
1271
1272 /* Create a name for the socket.  With USE_STANDARD_SOCKET given as
1273    true using STANDARD_NAME in the home directory or if given as
1274    false from the mkdir type name TEMPLATE.  In the latter case a
1275    unique name in a unique new directory will be created.  In both
1276    cases check for valid characters as well as against a maximum
1277    allowed length for a unix domain socket is done.  The function
1278    terminates the process in case of an error.  Returns: Pointer to an
1279    allocated string with the absolute name of the socket used.  */
1280 static char *
1281 create_socket_name (int use_standard_socket,
1282                     char *standard_name, char *template)
1283 {
1284   char *name, *p;
1285
1286   if (use_standard_socket)
1287     name = make_filename (opt.homedir, standard_name, NULL);
1288   else
1289     {
1290       name = xstrdup (template);
1291       p = strrchr (name, '/');
1292       if (!p)
1293         BUG ();
1294       *p = 0;
1295       if (!mkdtemp (name))
1296         {
1297           log_error (_("can't create directory `%s': %s\n"),
1298                      name, strerror (errno));
1299           agent_exit (2);
1300         }
1301       *p = '/';
1302     }
1303
1304   if (strchr (name, PATHSEP_C))
1305     {
1306       log_error (("`%s' are not allowed in the socket name\n"), PATHSEP_S);
1307       agent_exit (2);
1308     }
1309   if (strlen (name) + 1 >= DIMof (struct sockaddr_un, sun_path) )
1310     {
1311       log_error (_("name of socket too long\n"));
1312       agent_exit (2);
1313     }
1314   return name;
1315 }
1316
1317
1318
1319 /* Create a Unix domain socket with NAME.  IS_STANDARD_NAME indicates
1320    whether a non-random socket is used.  Returns the file descriptor or
1321    terminates the process in case of an error. */
1322 static gnupg_fd_t
1323 create_server_socket (int is_standard_name, char *name,
1324                       assuan_sock_nonce_t *nonce)
1325 {
1326   struct sockaddr_un *serv_addr;
1327   socklen_t len;
1328   gnupg_fd_t fd;
1329   int rc;
1330
1331   fd = assuan_sock_new (AF_UNIX, SOCK_STREAM, 0);
1332   if (fd == ASSUAN_INVALID_FD)
1333     {
1334       log_error (_("can't create socket: %s\n"), strerror (errno));
1335       agent_exit (2);
1336     }
1337
1338   serv_addr = xmalloc (sizeof (*serv_addr)); 
1339   memset (serv_addr, 0, sizeof *serv_addr);
1340   serv_addr->sun_family = AF_UNIX;
1341   if (strlen (name) + 1 >= sizeof (serv_addr->sun_path))
1342     {
1343       log_error (_("socket name `%s' is too long\n"), name);
1344       agent_exit (2);
1345     }
1346   strcpy (serv_addr->sun_path, name);
1347   len = (offsetof (struct sockaddr_un, sun_path)
1348          + strlen (serv_addr->sun_path) + 1);
1349
1350   rc = assuan_sock_bind (fd, (struct sockaddr*) serv_addr, len);
1351   if (is_standard_name && rc == -1 && errno == EADDRINUSE)
1352     {
1353       if (!check_for_running_agent (1, 1))
1354         {
1355           log_error (_("a gpg-agent is already running - "
1356                        "not starting a new one\n"));
1357           *name = 0; /* Inhibit removal of the socket by cleanup(). */
1358           assuan_sock_close (fd);
1359           agent_exit (2);
1360         }
1361       remove (name);
1362       rc = assuan_sock_bind (fd, (struct sockaddr*) serv_addr, len);
1363     }
1364   if (rc != -1 
1365       && (rc=assuan_sock_get_nonce ((struct sockaddr*)serv_addr, len, nonce)))
1366     log_error (_("error getting nonce for the socket\n"));
1367   if (rc == -1)
1368     {
1369       /* We use gpg_strerror here because it allows us to get strings
1370          for some W32 socket error codes.  */
1371       log_error (_("error binding socket to `%s': %s\n"),
1372                  serv_addr->sun_path, 
1373                  gpg_strerror (gpg_error_from_errno (errno)));
1374       
1375       assuan_sock_close (fd);
1376       if (is_standard_name)
1377         *name = 0; /* Inhibit removal of the socket by cleanup(). */
1378       agent_exit (2);
1379     }
1380
1381   if (listen (FD2INT(fd), 5 ) == -1)
1382     {
1383       log_error (_("listen() failed: %s\n"), strerror (errno));
1384       assuan_sock_close (fd);
1385       agent_exit (2);
1386     }
1387           
1388   if (opt.verbose)
1389     log_info (_("listening on socket `%s'\n"), serv_addr->sun_path);
1390
1391   return fd;
1392 }
1393
1394
1395 /* Check that the directory for storing the private keys exists and
1396    create it if not.  This function won't fail as it is only a
1397    convenience function and not strictly necessary.  */
1398 static void
1399 create_private_keys_directory (const char *home)
1400 {
1401   char *fname;
1402   struct stat statbuf;
1403
1404   fname = make_filename (home, GNUPG_PRIVATE_KEYS_DIR, NULL);
1405   if (stat (fname, &statbuf) && errno == ENOENT)
1406     {
1407 #ifdef HAVE_W32_SYSTEM  /*FIXME: Setup proper permissions.  */
1408       if (!CreateDirectory (fname, NULL))
1409         log_error (_("can't create directory `%s': %s\n"),
1410                    fname, w32_strerror (-1) );
1411 #else
1412       if (mkdir (fname, S_IRUSR|S_IWUSR|S_IXUSR ))
1413         log_error (_("can't create directory `%s': %s\n"),
1414                    fname, strerror (errno) );
1415 #endif
1416       else if (!opt.quiet)
1417         log_info (_("directory `%s' created\n"), fname);
1418     }
1419   xfree (fname);
1420 }
1421
1422 /* Create the directory only if the supplied directory name is the
1423    same as the default one.  This way we avoid to create arbitrary
1424    directories when a non-default home directory is used.  To cope
1425    with HOME, we compare only the suffix if we see that the default
1426    homedir does start with a tilde.  We don't stop here in case of
1427    problems because other functions will throw an error anyway.*/
1428 static void
1429 create_directories (void)
1430 {
1431   struct stat statbuf;
1432   const char *defhome = standard_homedir ();
1433   char *home;
1434
1435   home = make_filename (opt.homedir, NULL);
1436   if ( stat (home, &statbuf) )
1437     {
1438       if (errno == ENOENT)
1439         {
1440           if (
1441 #ifdef HAVE_W32_SYSTEM
1442               ( !compare_filenames (home, defhome) )
1443 #else
1444               (*defhome == '~'
1445                 && (strlen (home) >= strlen (defhome+1)
1446                     && !strcmp (home + strlen(home)
1447                                 - strlen (defhome+1), defhome+1)))
1448                || (*defhome != '~' && !strcmp (home, defhome) )
1449 #endif
1450                )
1451             {
1452 #ifdef HAVE_W32_SYSTEM
1453               if (!CreateDirectory (home, NULL))
1454                 log_error (_("can't create directory `%s': %s\n"),
1455                            home, w32_strerror (-1) );
1456 #else
1457               if (mkdir (home, S_IRUSR|S_IWUSR|S_IXUSR ))
1458                 log_error (_("can't create directory `%s': %s\n"),
1459                            home, strerror (errno) );
1460 #endif
1461               else 
1462                 {
1463                   if (!opt.quiet)
1464                     log_info (_("directory `%s' created\n"), home);
1465                   create_private_keys_directory (home);
1466                 }
1467             }
1468         }
1469       else
1470         log_error (_("stat() failed for `%s': %s\n"), home, strerror (errno));
1471     }
1472   else if ( !S_ISDIR(statbuf.st_mode))
1473     {
1474       log_error (_("can't use `%s' as home directory\n"), home);
1475     }
1476   else /* exists and is a directory. */
1477     {
1478       create_private_keys_directory (home);
1479     }
1480   xfree (home);
1481 }
1482
1483
1484
1485 /* This is the worker for the ticker.  It is called every few seconds
1486    and may only do fast operations. */
1487 static void
1488 handle_tick (void)
1489 {
1490   /* Check whether the scdaemon has died and cleanup in this case. */
1491   agent_scd_check_aliveness ();
1492
1493   /* If we are running as a child of another process, check whether
1494      the parent is still alive and shutdown if not. */
1495 #ifndef HAVE_W32_SYSTEM
1496   if (parent_pid != (pid_t)(-1))
1497     {
1498       if (kill (parent_pid, 0))
1499         {
1500           shutdown_pending = 2;
1501           log_info ("parent process died - shutting down\n");
1502           log_info ("%s %s stopped\n", strusage(11), strusage(13) );
1503           cleanup ();
1504           agent_exit (0);
1505         }
1506     }
1507 #endif /*HAVE_W32_SYSTEM*/
1508 }
1509
1510
1511 /* A global function which allows us to call the reload stuff from
1512    other places too.  This is only used when build for W32.  */
1513 void
1514 agent_sighup_action (void)
1515 {
1516   log_info ("SIGHUP received - "
1517             "re-reading configuration and flushing cache\n");
1518   agent_flush_cache ();
1519   reread_configuration ();
1520   agent_reload_trustlist ();
1521 }
1522
1523
1524 static void
1525 agent_sigusr2_action (void)
1526 {
1527   if (opt.verbose)
1528     log_info ("SIGUSR2 received - checking smartcard status\n");
1529   /* Nothing to check right now.  We only increment a counter.  */
1530   bump_card_eventcounter ();
1531 }
1532
1533
1534 static void
1535 handle_signal (int signo)
1536 {
1537   switch (signo)
1538     {
1539 #ifndef HAVE_W32_SYSTEM
1540     case SIGHUP:
1541       agent_sighup_action ();
1542       break;
1543       
1544     case SIGUSR1:
1545       log_info ("SIGUSR1 received - printing internal information:\n");
1546       pth_ctrl (PTH_CTRL_DUMPSTATE, log_get_stream ());
1547       agent_query_dump_state ();
1548       agent_scd_dump_state ();
1549       break;
1550       
1551     case SIGUSR2:
1552       agent_sigusr2_action ();
1553       break;
1554
1555     case SIGTERM:
1556       if (!shutdown_pending)
1557         log_info ("SIGTERM received - shutting down ...\n");
1558       else
1559         log_info ("SIGTERM received - still %ld running threads\n",
1560                   pth_ctrl( PTH_CTRL_GETTHREADS ));
1561       shutdown_pending++;
1562       if (shutdown_pending > 2)
1563         {
1564           log_info ("shutdown forced\n");
1565           log_info ("%s %s stopped\n", strusage(11), strusage(13) );
1566           cleanup ();
1567           agent_exit (0);
1568         }
1569       break;
1570         
1571     case SIGINT:
1572       log_info ("SIGINT received - immediate shutdown\n");
1573       log_info( "%s %s stopped\n", strusage(11), strusage(13));
1574       cleanup ();
1575       agent_exit (0);
1576       break;
1577 #endif
1578     default:
1579       log_info ("signal %d received - no action defined\n", signo);
1580     }
1581 }
1582
1583
1584 /* Check the nonce on a new connection.  This is a NOP unless we we
1585    are using our Unix domain socket emulation under Windows.  */
1586 static int 
1587 check_nonce (ctrl_t ctrl, assuan_sock_nonce_t *nonce)
1588 {
1589   if (assuan_sock_check_nonce (ctrl->thread_startup.fd, nonce))
1590     {
1591       log_info (_("error reading nonce on fd %d: %s\n"), 
1592                 FD2INT(ctrl->thread_startup.fd), strerror (errno));
1593       assuan_sock_close (ctrl->thread_startup.fd);
1594       xfree (ctrl);
1595       return -1;
1596     }
1597   else
1598     return 0;
1599 }
1600
1601
1602 /* This is the standard connection thread's main function.  */
1603 static void *
1604 start_connection_thread (void *arg)
1605 {
1606   ctrl_t ctrl = arg;
1607
1608   if (check_nonce (ctrl, &socket_nonce))
1609     return NULL;
1610
1611   agent_init_default_ctrl (ctrl);
1612   if (opt.verbose)
1613     log_info (_("handler 0x%lx for fd %d started\n"), 
1614               (long)pth_self (), FD2INT(ctrl->thread_startup.fd));
1615
1616   start_command_handler (ctrl, GNUPG_INVALID_FD, ctrl->thread_startup.fd);
1617   if (opt.verbose)
1618     log_info (_("handler 0x%lx for fd %d terminated\n"), 
1619               (long)pth_self (), FD2INT(ctrl->thread_startup.fd));
1620   
1621   agent_deinit_default_ctrl (ctrl);
1622   xfree (ctrl);
1623   return NULL;
1624 }
1625
1626
1627 /* This is the ssh connection thread's main function.  */
1628 static void *
1629 start_connection_thread_ssh (void *arg)
1630 {
1631   ctrl_t ctrl = arg;
1632
1633   if (check_nonce (ctrl, &socket_nonce_ssh))
1634     return NULL;
1635
1636   agent_init_default_ctrl (ctrl);
1637   if (opt.verbose)
1638     log_info (_("ssh handler 0x%lx for fd %d started\n"),
1639               (long)pth_self (), FD2INT(ctrl->thread_startup.fd));
1640
1641   start_command_handler_ssh (ctrl, ctrl->thread_startup.fd);
1642   if (opt.verbose)
1643     log_info (_("ssh handler 0x%lx for fd %d terminated\n"),
1644               (long)pth_self (), FD2INT(ctrl->thread_startup.fd));
1645   
1646   agent_deinit_default_ctrl (ctrl);
1647   xfree (ctrl);
1648   return NULL;
1649 }
1650
1651
1652 /* Connection handler loop.  Wait for connection requests and spawn a
1653    thread after accepting a connection.  */
1654 static void
1655 handle_connections (gnupg_fd_t listen_fd, gnupg_fd_t listen_fd_ssh)
1656 {
1657   pth_attr_t tattr;
1658   pth_event_t ev, time_ev;
1659   sigset_t sigs;
1660   int signo;
1661   struct sockaddr_un paddr;
1662   socklen_t plen;
1663   fd_set fdset, read_fdset;
1664   int ret;
1665   gnupg_fd_t fd;
1666   int nfd;
1667
1668   tattr = pth_attr_new();
1669   pth_attr_set (tattr, PTH_ATTR_JOINABLE, 0);
1670   pth_attr_set (tattr, PTH_ATTR_STACK_SIZE, 256*1024);
1671
1672 #ifndef HAVE_W32_SYSTEM /* fixme */
1673   /* Make sure that the signals we are going to handle are not blocked
1674      and create an event object for them. */
1675   sigemptyset (&sigs );
1676   sigaddset (&sigs, SIGHUP);
1677   sigaddset (&sigs, SIGUSR1);
1678   sigaddset (&sigs, SIGUSR2);
1679   sigaddset (&sigs, SIGINT);
1680   sigaddset (&sigs, SIGTERM);
1681   pth_sigmask (SIG_UNBLOCK, &sigs, NULL);
1682   ev = pth_event (PTH_EVENT_SIGS, &sigs, &signo);
1683 #else
1684 # ifdef PTH_EVENT_HANDLE
1685   sigs = 0;
1686   ev = pth_event (PTH_EVENT_HANDLE, get_agent_scd_notify_event ());
1687   signo = 0;
1688 # else
1689   /* Use a dummy event. */
1690   sigs = 0;
1691   ev = pth_event (PTH_EVENT_SIGS, &sigs, &signo);
1692 # endif
1693 #endif
1694   time_ev = NULL;
1695
1696   FD_ZERO (&fdset);
1697   FD_SET (FD2INT (listen_fd), &fdset);
1698   nfd = FD2INT (listen_fd);
1699   if (listen_fd_ssh != GNUPG_INVALID_FD)
1700     {
1701       FD_SET ( FD2INT(listen_fd_ssh), &fdset);
1702       if (FD2INT (listen_fd_ssh) > nfd)
1703         nfd = FD2INT (listen_fd_ssh);
1704     }
1705
1706   for (;;)
1707     {
1708       sigset_t oldsigs;
1709
1710       if (shutdown_pending)
1711         {
1712           if (pth_ctrl (PTH_CTRL_GETTHREADS) == 1)
1713             break; /* ready */
1714
1715           /* Do not accept anymore connections and wait for existing
1716              connections to terminate */
1717           signo = 0;
1718           pth_wait (ev);
1719           if (pth_event_occurred (ev) && signo)
1720             handle_signal (signo);
1721           continue;
1722         }
1723
1724       /* Create a timeout event if needed. */
1725       if (!time_ev)
1726         time_ev = pth_event (PTH_EVENT_TIME, 
1727                              pth_timeout (TIMERTICK_INTERVAL, 0));
1728
1729       /* POSIX says that fd_set should be implemented as a structure,
1730          thus a simple assignment is fine to copy the entire set.  */
1731       read_fdset = fdset;
1732
1733       if (time_ev)
1734         pth_event_concat (ev, time_ev, NULL);
1735       ret = pth_select_ev (nfd+1, &read_fdset, NULL, NULL, NULL, ev);
1736       if (time_ev)
1737         pth_event_isolate (time_ev);
1738
1739       if (ret == -1)
1740         {
1741           if (pth_event_occurred (ev)
1742               || (time_ev && pth_event_occurred (time_ev)))
1743             {
1744               if (pth_event_occurred (ev))
1745                 {
1746 #if defined(HAVE_W32_SYSTEM) && defined(PTH_EVENT_HANDLE)
1747                   agent_sigusr2_action ();
1748 #else
1749                   handle_signal (signo);
1750 #endif
1751                 }
1752               if (time_ev && pth_event_occurred (time_ev))
1753                 {
1754                   pth_event_free (time_ev, PTH_FREE_ALL);
1755                   time_ev = NULL;
1756                   handle_tick ();
1757                 }
1758               continue;
1759             }
1760           log_error (_("pth_select failed: %s - waiting 1s\n"),
1761                      strerror (errno));
1762           pth_sleep (1);
1763           continue;
1764         }
1765
1766       if (pth_event_occurred (ev))
1767         {
1768 #if defined(HAVE_W32_SYSTEM) && defined(PTH_EVENT_HANDLE)
1769           agent_sigusr2_action ();
1770 #else
1771           handle_signal (signo);
1772 #endif
1773         }
1774
1775       if (time_ev && pth_event_occurred (time_ev))
1776         {
1777           pth_event_free (time_ev, PTH_FREE_ALL);
1778           time_ev = NULL;
1779           handle_tick ();
1780         }
1781
1782       
1783       /* We now might create new threads and because we don't want any
1784          signals (as we are handling them here) to be delivered to a
1785          new thread.  Thus we need to block those signals. */
1786       pth_sigmask (SIG_BLOCK, &sigs, &oldsigs);
1787
1788       if (FD_ISSET (FD2INT (listen_fd), &read_fdset))
1789         {
1790           ctrl_t ctrl;
1791
1792           plen = sizeof paddr;
1793           fd = INT2FD (pth_accept (FD2INT(listen_fd),
1794                                    (struct sockaddr *)&paddr, &plen));
1795           if (fd == GNUPG_INVALID_FD)
1796             {
1797               log_error ("accept failed: %s\n", strerror (errno));
1798             }
1799           else if ( !(ctrl = xtrycalloc (1, sizeof *ctrl)) )
1800             {
1801               log_error ("error allocating connection control data: %s\n",
1802                          strerror (errno) );
1803               assuan_sock_close (fd);
1804             }
1805           else 
1806             {
1807               char threadname[50];
1808
1809               snprintf (threadname, sizeof threadname-1,
1810                         "conn fd=%d (gpg)", FD2INT(fd));
1811               threadname[sizeof threadname -1] = 0;
1812               pth_attr_set (tattr, PTH_ATTR_NAME, threadname);
1813               ctrl->thread_startup.fd = fd;
1814               if (!pth_spawn (tattr, start_connection_thread, ctrl))
1815                 {
1816                   log_error ("error spawning connection handler: %s\n",
1817                              strerror (errno) );
1818                   assuan_sock_close (fd);
1819                   xfree (ctrl);
1820                 }
1821             }
1822           fd = GNUPG_INVALID_FD;
1823         }
1824
1825       if (listen_fd_ssh != GNUPG_INVALID_FD 
1826           && FD_ISSET ( FD2INT (listen_fd_ssh), &read_fdset))
1827         {
1828           ctrl_t ctrl;
1829
1830           plen = sizeof paddr;
1831           fd = INT2FD(pth_accept (FD2INT(listen_fd_ssh),
1832                                   (struct sockaddr *)&paddr, &plen));
1833           if (fd == GNUPG_INVALID_FD)
1834             {
1835               log_error ("accept failed for ssh: %s\n", strerror (errno));
1836             }
1837           else if ( !(ctrl = xtrycalloc (1, sizeof *ctrl)) )
1838             {
1839               log_error ("error allocating connection control data: %s\n",
1840                          strerror (errno) );
1841               assuan_sock_close (fd);
1842             }
1843           else
1844             {
1845               char threadname[50];
1846
1847               agent_init_default_ctrl (ctrl);
1848               snprintf (threadname, sizeof threadname-1,
1849                         "conn fd=%d (ssh)", FD2INT(fd));
1850               threadname[sizeof threadname -1] = 0;
1851               pth_attr_set (tattr, PTH_ATTR_NAME, threadname);
1852               ctrl->thread_startup.fd = fd;
1853               if (!pth_spawn (tattr, start_connection_thread_ssh, ctrl) )
1854                 {
1855                   log_error ("error spawning ssh connection handler: %s\n",
1856                              strerror (errno) );
1857                   assuan_sock_close (fd);
1858                   xfree (ctrl);
1859                 }
1860             }
1861           fd = GNUPG_INVALID_FD;
1862         }
1863
1864       /* Restore the signal mask. */
1865       pth_sigmask (SIG_SETMASK, &oldsigs, NULL);
1866
1867     }
1868
1869   pth_event_free (ev, PTH_FREE_ALL);
1870   if (time_ev)
1871     pth_event_free (time_ev, PTH_FREE_ALL);
1872   cleanup ();
1873   log_info (_("%s %s stopped\n"), strusage(11), strusage(13));
1874 }
1875
1876
1877 /* Figure out whether an agent is available and running. Prints an
1878    error if not.  If SILENT is true, no mesdsages are printed.  Usually
1879    started with MODE 0.  Returns 0 if the agent is running. */
1880 static int
1881 check_for_running_agent (int silent, int mode)
1882 {
1883   int rc;
1884   char *infostr, *p;
1885   assuan_context_t ctx;
1886   int prot, pid;
1887
1888   if (!mode)
1889     {
1890       infostr = getenv ("GPG_AGENT_INFO");
1891       if (!infostr || !*infostr)
1892         {
1893           if (!check_for_running_agent (silent, 1))
1894             return 0; /* Okay, its running on the standard socket. */
1895           if (!silent)
1896             log_error (_("no gpg-agent running in this session\n"));
1897           return -1;
1898         }
1899
1900       infostr = xstrdup (infostr);
1901       if ( !(p = strchr (infostr, PATHSEP_C)) || p == infostr)
1902         {
1903           xfree (infostr);
1904           if (!check_for_running_agent (silent, 1))
1905             return 0; /* Okay, its running on the standard socket. */
1906           if (!silent)
1907             log_error (_("malformed GPG_AGENT_INFO environment variable\n"));
1908           return -1;
1909         }
1910
1911       *p++ = 0;
1912       pid = atoi (p);
1913       while (*p && *p != PATHSEP_C)
1914         p++;
1915       prot = *p? atoi (p+1) : 0;
1916       if (prot != 1)
1917         {
1918           xfree (infostr);
1919           if (!silent)
1920             log_error (_("gpg-agent protocol version %d is not supported\n"),
1921                        prot);
1922           if (!check_for_running_agent (silent, 1))
1923             return 0; /* Okay, its running on the standard socket. */
1924           return -1;
1925         }
1926     }
1927   else /* MODE != 0 */
1928     {
1929       infostr = make_filename (opt.homedir, "S.gpg-agent", NULL);
1930       pid = (pid_t)(-1);
1931     }
1932
1933
1934   rc = assuan_socket_connect (&ctx, infostr, pid);
1935   xfree (infostr);
1936   if (rc)
1937     {
1938       if (!mode && !check_for_running_agent (silent, 1))
1939         return 0; /* Okay, its running on the standard socket. */
1940
1941       if (!mode && !silent)
1942         log_error ("can't connect to the agent: %s\n", gpg_strerror (rc));
1943       return -1;
1944     }
1945
1946   if (!opt.quiet && !silent)
1947     log_info ("gpg-agent running and available\n");
1948
1949   assuan_disconnect (ctx);
1950   return 0;
1951 }