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