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