Allow to run the test without a running 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             }
728           else
729             {
730               log_error (_("option file `%s': %s\n"),
731                          configname, strerror(errno) );
732               exit(2);
733             }
734           xfree (configname); 
735           configname = NULL;
736         }
737       if (parse_debug && configname )
738         log_info (_("reading options from `%s'\n"), configname );
739       default_config = 0;
740     }
741
742   while (optfile_parse( configfp, configname, &configlineno, &pargs, opts) )
743     {
744       if (parse_rereadable_options (&pargs, 0))
745         continue; /* Already handled */
746       switch (pargs.r_opt)
747         {
748         case aGPGConfList: gpgconf_list = 1; break;
749         case aGPGConfTest: gpgconf_list = 2; break;
750         case aUseStandardSocketP: gpgconf_list = 3; break;
751         case oBatch: opt.batch=1; break;
752
753         case oDebugWait: debug_wait = pargs.r.ret_int; break;
754
755         case oOptions:
756           /* config files may not be nested (silently ignore them) */
757           if (!configfp)
758             {
759                 xfree(configname);
760                 configname = xstrdup(pargs.r.ret_str);
761                 goto next_pass;
762             }
763           break;
764         case oNoGreeting: nogreeting = 1; break;
765         case oNoVerbose: opt.verbose = 0; break;
766         case oNoOptions: break; /* no-options */
767         case oHomedir: opt.homedir = pargs.r.ret_str; break;
768         case oNoDetach: nodetach = 1; break;
769         case oLogFile: logfile = pargs.r.ret_str; break;
770         case oCsh: csh_style = 1; break;
771         case oSh: csh_style = 0; break;
772         case oServer: pipe_server = 1; break;
773         case oDaemon: is_daemon = 1; break;
774
775         case oDisplay: default_display = xstrdup (pargs.r.ret_str); break;
776         case oTTYname: default_ttyname = xstrdup (pargs.r.ret_str); break;
777         case oTTYtype: default_ttytype = xstrdup (pargs.r.ret_str); break;
778         case oLCctype: default_lc_ctype = xstrdup (pargs.r.ret_str); break;
779         case oLCmessages: default_lc_messages = xstrdup (pargs.r.ret_str);
780         case oXauthority: default_xauthority = xstrdup (pargs.r.ret_str);
781           break;
782
783         case oUseStandardSocket:   opt.use_standard_socket = 1; break;
784         case oNoUseStandardSocket: opt.use_standard_socket = 0; break;
785
786         case oFakedSystemTime:
787           {
788             time_t faked_time = isotime2epoch (pargs.r.ret_str); 
789             if (faked_time == (time_t)(-1))
790               faked_time = (time_t)strtoul (pargs.r.ret_str, NULL, 10);
791             gnupg_set_time (faked_time, 0);
792           }
793           break;
794
795         case oKeepTTY: opt.keep_tty = 1; break;
796         case oKeepDISPLAY: opt.keep_display = 1; break;
797
798         case oSSHSupport:  opt.ssh_support = 1; break;
799         case oWriteEnvFile:
800           if (pargs.r_type)
801             env_file_name = pargs.r.ret_str;
802           else
803             env_file_name = make_filename ("~/.gpg-agent-info", NULL);
804           break;
805
806         default : pargs.err = configfp? 1:2; break;
807         }
808     }
809   if (configfp)
810     {
811       fclose( configfp );
812       configfp = NULL;
813       /* Keep a copy of the name so that it can be read on SIGHUP. */
814       config_filename = configname;
815       configname = NULL;
816       goto next_pass;
817     }
818   xfree (configname);
819   configname = NULL;
820   if (log_get_errorcount(0))
821     exit(2);
822   if (nogreeting )
823     greeting = 0;
824
825   if (greeting)
826     {
827       fprintf (stderr, "%s %s; %s\n",
828                  strusage(11), strusage(13), strusage(14) );
829       fprintf (stderr, "%s\n", strusage(15) );
830     }
831 #ifdef IS_DEVELOPMENT_VERSION
832   /* We don't want to print it here because gpg-agent is useful of its
833      own and quite matured.  */
834   /*log_info ("NOTE: this is a development version!\n");*/
835 #endif
836
837   set_debug ();
838   
839   if (atexit (cleanup))
840     {
841       log_error ("atexit failed\n");
842       cleanup ();
843       exit (1);
844     }
845
846   initialize_module_call_pinentry ();
847   initialize_module_call_scd ();
848   initialize_module_trustlist ();
849   
850   /* Try to create missing directories. */
851   create_directories ();
852
853   if (debug_wait && pipe_server)
854     {
855       log_debug ("waiting for debugger - my pid is %u .....\n",
856                  (unsigned int)getpid());
857       gnupg_sleep (debug_wait);
858       log_debug ("... okay\n");
859     }
860   
861   if (gpgconf_list == 3)
862     agent_exit (!opt.use_standard_socket);
863   if (gpgconf_list == 2)
864     agent_exit (0);
865   if (gpgconf_list)
866     {
867       char *filename;
868       char *filename_esc;
869
870       /* List options and default values in the GPG Conf format.  */
871       filename = make_filename (opt.homedir, "gpg-agent.conf", NULL );
872       filename_esc = percent_escape (filename, NULL);
873
874       printf ("gpgconf-gpg-agent.conf:%lu:\"%s\n",
875               GC_OPT_FLAG_DEFAULT, filename_esc);
876       xfree (filename);
877       xfree (filename_esc);
878
879       printf ("verbose:%lu:\n"
880               "quiet:%lu:\n"
881               "debug-level:%lu:\"none:\n"
882               "log-file:%lu:\n",
883               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME,
884               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME,
885               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME,
886               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME );
887       printf ("default-cache-ttl:%lu:%d:\n",
888               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME, DEFAULT_CACHE_TTL );
889       printf ("default-cache-ttl-ssh:%lu:%d:\n",
890               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME, DEFAULT_CACHE_TTL_SSH );
891       printf ("max-cache-ttl:%lu:%d:\n",
892               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME, MAX_CACHE_TTL );
893       printf ("max-cache-ttl-ssh:%lu:%d:\n",
894               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME, MAX_CACHE_TTL_SSH );
895       printf ("enforce-passphrase-constraints:%lu:\n", 
896               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
897       printf ("min-passphrase-len:%lu:%d:\n",
898               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME, MIN_PASSPHRASE_LEN );
899       printf ("min-passphrase-nonalpha:%lu:%d:\n",
900               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME, 
901               MIN_PASSPHRASE_NONALPHA);
902       printf ("check-passphrase-pattern:%lu:\n",
903               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME);
904       printf ("max-passphrase-days:%lu:%d:\n",
905               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME, 
906               MAX_PASSPHRASE_DAYS);
907       printf ("enable-passphrase-history:%lu:\n", 
908               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
909       printf ("no-grab:%lu:\n", 
910               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
911       printf ("ignore-cache-for-signing:%lu:\n",
912               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
913       printf ("allow-mark-trusted:%lu:\n",
914               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
915       printf ("disable-scdaemon:%lu:\n",
916               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
917
918       agent_exit (0);
919     }
920
921   /* If this has been called without any options, we merely check
922      whether an agent is already running.  We do this here so that we
923      don't clobber a logfile but print it directly to stderr. */
924   if (!pipe_server && !is_daemon)
925     {
926       log_set_prefix (NULL, JNLIB_LOG_WITH_PREFIX); 
927       check_for_running_agent (0, 0);
928       agent_exit (0);
929     }
930   
931 #ifdef ENABLE_NLS
932   /* gpg-agent usually does not output any messages because it runs in
933      the background.  For log files it is acceptable to have messages
934      always encoded in utf-8.  We switch here to utf-8, so that
935      commands like --help still give native messages.  It is far
936      easier to switch only once instead of for every message and it
937      actually helps when more then one thread is active (avoids an
938      extra copy step). */
939     bind_textdomain_codeset (PACKAGE_GT, "UTF-8");
940 #endif
941
942   /* Now start with logging to a file if this is desired. */
943   if (logfile)
944     {
945       log_set_file (logfile);
946       log_set_prefix (NULL, (JNLIB_LOG_WITH_PREFIX
947                              |JNLIB_LOG_WITH_TIME
948                              |JNLIB_LOG_WITH_PID));
949       current_logfile = xstrdup (logfile);
950     }
951   if (DBG_ASSUAN)
952     assuan_set_assuan_log_stream (log_get_stream ());
953
954   /* Make sure that we have a default ttyname. */
955   if (!default_ttyname && ttyname (1))
956     default_ttyname = xstrdup (ttyname (1));
957   if (!default_ttytype && getenv ("TERM"))
958     default_ttytype = xstrdup (getenv ("TERM"));
959
960
961   if (pipe_server)
962     { 
963       /* This is the simple pipe based server */
964       ctrl_t ctrl;
965
966       ctrl = xtrycalloc (1, sizeof *ctrl);
967       if (!ctrl)
968         {
969           log_error ("error allocating connection control data: %s\n",
970                      strerror (errno) );
971           agent_exit (1);
972         }
973       ctrl->session_env = session_env_new ();
974       if (!ctrl->session_env)
975         {
976           log_error ("error allocating session environment block: %s\n",
977                      strerror (errno) );
978           xfree (ctrl);
979           agent_exit (1);
980         }
981       agent_init_default_ctrl (ctrl);
982       start_command_handler (ctrl, GNUPG_INVALID_FD, GNUPG_INVALID_FD);
983       agent_deinit_default_ctrl (ctrl);
984       xfree (ctrl);
985     }
986   else if (!is_daemon)
987     ; /* NOTREACHED */
988   else
989     { /* Regular server mode */
990       gnupg_fd_t fd;
991       gnupg_fd_t fd_ssh;
992       pid_t pid;
993
994       /* Remove the DISPLAY variable so that a pinentry does not
995          default to a specific display.  There is still a default
996          display when gpg-agent was started using --display or a
997          client requested this using an OPTION command.  Note, that we
998          don't do this when running in reverse daemon mode (i.e. when
999          exec the program given as arguments). */
1000 #ifndef HAVE_W32_SYSTEM
1001       if (!opt.keep_display && !argc)
1002         unsetenv ("DISPLAY");
1003 #endif
1004
1005
1006       /* Create the sockets.  */
1007       socket_name = create_socket_name 
1008         ("S.gpg-agent", "/tmp/gpg-XXXXXX/S.gpg-agent");
1009       if (opt.ssh_support)
1010         socket_name_ssh = create_socket_name 
1011           ("S.gpg-agent.ssh", "/tmp/gpg-XXXXXX/S.gpg-agent.ssh");
1012
1013       fd = create_server_socket (socket_name, 0, &socket_nonce);
1014       if (opt.ssh_support)
1015         fd_ssh = create_server_socket (socket_name_ssh, 1, &socket_nonce_ssh);
1016       else
1017         fd_ssh = GNUPG_INVALID_FD;
1018
1019       /* If we are going to exec a program in the parent, we record
1020          the PID, so that the child may check whether the program is
1021          still alive. */
1022       if (argc)
1023         parent_pid = getpid ();
1024
1025       fflush (NULL);
1026 #ifdef HAVE_W32_SYSTEM
1027       pid = getpid ();
1028       printf ("set GPG_AGENT_INFO=%s;%lu;1\n", socket_name, (ulong)pid);
1029 #else /*!HAVE_W32_SYSTEM*/
1030       pid = fork ();
1031       if (pid == (pid_t)-1) 
1032         {
1033           log_fatal ("fork failed: %s\n", strerror (errno) );
1034           exit (1);
1035         }
1036       else if (pid) 
1037         { /* We are the parent */
1038           char *infostr, *infostr_ssh_sock, *infostr_ssh_pid;
1039
1040           /* Close the socket FD. */
1041           close (fd);
1042
1043           /* Note that we used a standard fork so that Pth runs in
1044              both the parent and the child.  The pth_fork would
1045              terminate Pth in the child but that is not the way we
1046              want it.  Thus we use a plain fork and terminate Pth here
1047              in the parent.  The pth_kill may or may not work reliable
1048              but it should not harm to call it.  Because Pth fiddles
1049              with the signal mask the signal mask might not be correct
1050              right now and thus we restore it.  That is not strictly
1051              necessary but some programs falsely assume a cleared
1052              signal mask.  */
1053           if ( !pth_kill () )
1054             log_error ("pth_kill failed in forked process\n");
1055             
1056 #ifdef HAVE_SIGPROCMASK
1057           if (startup_signal_mask_valid)
1058             {
1059               if (sigprocmask (SIG_SETMASK, &startup_signal_mask, NULL))
1060                 log_error ("error restoring signal mask: %s\n",
1061                            strerror (errno));
1062             }
1063           else
1064             log_info ("no saved signal mask\n");
1065 #endif /*HAVE_SIGPROCMASK*/          
1066
1067           /* Create the info string: <name>:<pid>:<protocol_version> */
1068           if (asprintf (&infostr, "GPG_AGENT_INFO=%s:%lu:1",
1069                         socket_name, (ulong)pid ) < 0)
1070             {
1071               log_error ("out of core\n");
1072               kill (pid, SIGTERM);
1073               exit (1);
1074             }
1075           if (opt.ssh_support)
1076             {
1077               if (asprintf (&infostr_ssh_sock, "SSH_AUTH_SOCK=%s",
1078                             socket_name_ssh) < 0)
1079                 {
1080                   log_error ("out of core\n");
1081                   kill (pid, SIGTERM);
1082                   exit (1);
1083                 }
1084               if (asprintf (&infostr_ssh_pid, "SSH_AGENT_PID=%u",
1085                             pid) < 0)
1086                 {
1087                   log_error ("out of core\n");
1088                   kill (pid, SIGTERM);
1089                   exit (1);
1090                 }
1091             }
1092
1093           *socket_name = 0; /* Don't let cleanup() remove the socket -
1094                                the child should do this from now on */
1095           if (opt.ssh_support)
1096             *socket_name_ssh = 0;
1097
1098           if (env_file_name)
1099             {
1100               FILE *fp;
1101               
1102               fp = fopen (env_file_name, "w");
1103               if (!fp)
1104                 log_error (_("error creating `%s': %s\n"),
1105                              env_file_name, strerror (errno));
1106               else
1107                 {
1108                   fputs (infostr, fp);
1109                   putc ('\n', fp);
1110                   if (opt.ssh_support)
1111                     {
1112                       fputs (infostr_ssh_sock, fp);
1113                       putc ('\n', fp);
1114                       fputs (infostr_ssh_pid, fp);
1115                       putc ('\n', fp);
1116                     }
1117                   fclose (fp);
1118                 }
1119             }
1120
1121
1122           if (argc) 
1123             { /* Run the program given on the commandline.  */
1124               if (putenv (infostr))
1125                 {
1126                   log_error ("failed to set environment: %s\n",
1127                              strerror (errno) );
1128                   kill (pid, SIGTERM );
1129                   exit (1);
1130                 }
1131               if (opt.ssh_support && putenv (infostr_ssh_sock))
1132                 {
1133                   log_error ("failed to set environment: %s\n",
1134                              strerror (errno) );
1135                   kill (pid, SIGTERM );
1136                   exit (1);
1137                 }
1138               if (opt.ssh_support && putenv (infostr_ssh_pid))
1139                 {
1140                   log_error ("failed to set environment: %s\n",
1141                              strerror (errno) );
1142                   kill (pid, SIGTERM );
1143                   exit (1);
1144                 }
1145
1146               /* Close all the file descriptors except the standard
1147                  ones and those open at startup.  We explicitly don't
1148                  close 0,1,2 in case something went wrong collecting
1149                  them at startup.  */
1150               close_all_fds (3, startup_fd_list);
1151
1152               /* Run the command.  */
1153               execvp (argv[0], argv);
1154               log_error ("failed to run the command: %s\n", strerror (errno));
1155               kill (pid, SIGTERM);
1156               exit (1);
1157             }
1158           else
1159             {
1160               /* Print the environment string, so that the caller can use
1161                  shell's eval to set it */
1162               if (csh_style)
1163                 {
1164                   *strchr (infostr, '=') = ' ';
1165                   printf ("setenv %s\n", infostr);
1166                   if (opt.ssh_support)
1167                     {
1168                       *strchr (infostr_ssh_sock, '=') = ' ';
1169                       printf ("setenv %s\n", infostr_ssh_sock);
1170                       *strchr (infostr_ssh_pid, '=') = ' ';
1171                       printf ("setenv %s\n", infostr_ssh_pid);
1172                     }
1173                 }
1174               else
1175                 {
1176                   printf ( "%s; export GPG_AGENT_INFO;\n", infostr);
1177                   if (opt.ssh_support)
1178                     {
1179                       printf ("%s; export SSH_AUTH_SOCK;\n", infostr_ssh_sock);
1180                       printf ("%s; export SSH_AGENT_PID;\n", infostr_ssh_pid);
1181                     }
1182                 }
1183               xfree (infostr); 
1184               if (opt.ssh_support)
1185                 {
1186                   xfree (infostr_ssh_sock);
1187                   xfree (infostr_ssh_pid);
1188                 }
1189               exit (0); 
1190             }
1191           /*NOTREACHED*/
1192         } /* End parent */
1193
1194       /* 
1195          This is the child
1196        */
1197
1198       /* Detach from tty and put process into a new session */
1199       if (!nodetach )
1200         { 
1201           int i;
1202           unsigned int oldflags;
1203
1204           /* Close stdin, stdout and stderr unless it is the log stream */
1205           for (i=0; i <= 2; i++) 
1206             {
1207               if (!log_test_fd (i) && i != fd )
1208                 {
1209                   if ( ! close (i)
1210                        && open ("/dev/null", i? O_WRONLY : O_RDONLY) == -1)
1211                     {
1212                       log_error ("failed to open `%s': %s\n",
1213                                  "/dev/null", strerror (errno));
1214                       cleanup ();
1215                       exit (1);
1216                     }
1217                 }
1218             }
1219           if (setsid() == -1)
1220             {
1221               log_error ("setsid() failed: %s\n", strerror(errno) );
1222               cleanup ();
1223               exit (1);
1224             }
1225
1226           log_get_prefix (&oldflags);
1227           log_set_prefix (NULL, oldflags | JNLIB_LOG_RUN_DETACHED);
1228           opt.running_detached = 1;
1229         }
1230
1231       if (chdir("/"))
1232         {
1233           log_error ("chdir to / failed: %s\n", strerror (errno));
1234           exit (1);
1235         }
1236
1237       {
1238         struct sigaction sa;
1239         
1240         sa.sa_handler = SIG_IGN;
1241         sigemptyset (&sa.sa_mask);
1242         sa.sa_flags = 0;
1243         sigaction (SIGPIPE, &sa, NULL);
1244       }
1245 #endif /*!HAVE_W32_SYSTEM*/
1246
1247       log_info ("%s %s started\n", strusage(11), strusage(13) );
1248       handle_connections (fd, opt.ssh_support ? fd_ssh : GNUPG_INVALID_FD);
1249       assuan_sock_close (fd);
1250     }
1251   
1252   return 0;
1253 }
1254
1255
1256 void
1257 agent_exit (int rc)
1258 {
1259   /*FIXME: update_random_seed_file();*/
1260 #if 1
1261   /* at this time a bit annoying */
1262   if (opt.debug & DBG_MEMSTAT_VALUE)
1263     {
1264       gcry_control( GCRYCTL_DUMP_MEMORY_STATS );
1265       gcry_control( GCRYCTL_DUMP_RANDOM_STATS );
1266     }
1267   if (opt.debug)
1268     gcry_control (GCRYCTL_DUMP_SECMEM_STATS );
1269 #endif
1270   gcry_control (GCRYCTL_TERM_SECMEM );
1271   rc = rc? rc : log_get_errorcount(0)? 2 : 0;
1272   exit (rc);
1273 }
1274
1275
1276 static void
1277 agent_init_default_ctrl (ctrl_t ctrl)
1278 {
1279   /* Note we ignore malloc errors because we can't do much about it
1280      and the request will fail anyway shortly after this
1281      initialization. */
1282   session_env_setenv (ctrl->session_env, "DISPLAY", default_display);
1283   session_env_setenv (ctrl->session_env, "GPG_TTY", default_ttyname);
1284   session_env_setenv (ctrl->session_env, "TERM", default_ttytype);
1285   session_env_setenv (ctrl->session_env, "XAUTHORITY", default_xauthority);
1286   session_env_setenv (ctrl->session_env, "PINENTRY_USER_DATA", NULL);
1287   
1288   if (ctrl->lc_ctype)
1289     xfree (ctrl->lc_ctype);
1290   ctrl->lc_ctype = default_lc_ctype? xtrystrdup (default_lc_ctype) : NULL;
1291   
1292   if (ctrl->lc_messages)
1293     xfree (ctrl->lc_messages);
1294   ctrl->lc_messages = default_lc_messages? xtrystrdup (default_lc_messages)
1295                                     /**/ : NULL;
1296
1297 }
1298
1299
1300 static void
1301 agent_deinit_default_ctrl (ctrl_t ctrl)
1302 {
1303   session_env_release (ctrl->session_env);
1304
1305   if (ctrl->lc_ctype)
1306     xfree (ctrl->lc_ctype);
1307   if (ctrl->lc_messages)
1308     xfree (ctrl->lc_messages);
1309 }
1310
1311
1312 /* Reread parts of the configuration.  Note, that this function is
1313    obviously not thread-safe and should only be called from the PTH
1314    signal handler. 
1315
1316    Fixme: Due to the way the argument parsing works, we create a
1317    memory leak here for all string type arguments.  There is currently
1318    no clean way to tell whether the memory for the argument has been
1319    allocated or points into the process' original arguments.  Unless
1320    we have a mechanism to tell this, we need to live on with this. */
1321 static void
1322 reread_configuration (void)
1323 {
1324   ARGPARSE_ARGS pargs;
1325   FILE *fp;
1326   unsigned int configlineno = 0;
1327   int dummy;
1328
1329   if (!config_filename)
1330     return; /* No config file. */
1331
1332   fp = fopen (config_filename, "r");
1333   if (!fp)
1334     {
1335       log_error (_("option file `%s': %s\n"),
1336                  config_filename, strerror(errno) );
1337       return;
1338     }
1339
1340   parse_rereadable_options (NULL, 1); /* Start from the default values. */
1341
1342   memset (&pargs, 0, sizeof pargs);
1343   dummy = 0;
1344   pargs.argc = &dummy;
1345   pargs.flags = 1;  /* do not remove the args */
1346   while (optfile_parse (fp, config_filename, &configlineno, &pargs, opts) )
1347     {
1348       if (pargs.r_opt < -1)
1349         pargs.err = 1; /* Print a warning. */
1350       else /* Try to parse this option - ignore unchangeable ones. */
1351         parse_rereadable_options (&pargs, 1);
1352     }
1353   fclose (fp);
1354   set_debug ();
1355 }
1356
1357
1358 /* Return the file name of the socket we are using for native
1359    requests.  */
1360 const char *
1361 get_agent_socket_name (void)
1362 {
1363   const char *s = socket_name;
1364
1365   return (s && *s)? s : NULL;
1366 }
1367
1368 /* Return the file name of the socket we are using for SSH
1369    requests.  */
1370 const char *
1371 get_agent_ssh_socket_name (void)
1372 {
1373   const char *s = socket_name_ssh;
1374
1375   return (s && *s)? s : NULL;
1376 }
1377
1378
1379 /* Under W32, this function returns the handle of the scdaemon
1380    notification event.  Calling it the first time creates that
1381    event.  */
1382 #ifdef HAVE_W32_SYSTEM
1383 void *
1384 get_agent_scd_notify_event (void)
1385 {
1386   static HANDLE the_event;
1387
1388   if (!the_event)
1389     {
1390       HANDLE h, h2;
1391       SECURITY_ATTRIBUTES sa = { sizeof (SECURITY_ATTRIBUTES), NULL, TRUE};
1392
1393       /* We need to use manual reset evet object due to the way our
1394          w32-pth wait function works: If we would use an automatic
1395          reset event we are not able to figure out which handle has
1396          been signaled because at the time we single out the signaled
1397          handles using WFSO the event has already been reset due to
1398          the WFMO.  */
1399       h = CreateEvent (&sa, TRUE, FALSE, NULL);
1400       if (!h)
1401         log_error ("can't create scd notify event: %s\n", w32_strerror (-1) );
1402       else if (!DuplicateHandle (GetCurrentProcess(), h,
1403                                  GetCurrentProcess(), &h2,
1404                                  EVENT_MODIFY_STATE|SYNCHRONIZE, TRUE, 0)) 
1405         {
1406           log_error ("setting syncronize for scd notify event failed: %s\n",
1407                      w32_strerror (-1) );
1408           CloseHandle (h);
1409         }
1410       else
1411         {
1412           CloseHandle (h);
1413           the_event = h2;
1414         }
1415     }
1416
1417   log_debug  ("returning notify handle %p\n", the_event);
1418   return the_event;
1419 }
1420 #endif /*HAVE_W32_SYSTEM*/
1421
1422
1423
1424 /* Create a name for the socket.  With USE_STANDARD_SOCKET given as
1425    true using STANDARD_NAME in the home directory or if given as
1426    false from the mkdir type name TEMPLATE.  In the latter case a
1427    unique name in a unique new directory will be created.  In both
1428    cases check for valid characters as well as against a maximum
1429    allowed length for a unix domain socket is done.  The function
1430    terminates the process in case of an error.  Returns: Pointer to an
1431    allocated string with the absolute name of the socket used.  */
1432 static char *
1433 create_socket_name (char *standard_name, char *template)
1434 {
1435   char *name, *p;
1436
1437   if (opt.use_standard_socket)
1438     name = make_filename (opt.homedir, standard_name, NULL);
1439   else
1440     {
1441       name = xstrdup (template);
1442       p = strrchr (name, '/');
1443       if (!p)
1444         BUG ();
1445       *p = 0;
1446       if (!mkdtemp (name))
1447         {
1448           log_error (_("can't create directory `%s': %s\n"),
1449                      name, strerror (errno));
1450           agent_exit (2);
1451         }
1452       *p = '/';
1453     }
1454
1455   if (strchr (name, PATHSEP_C))
1456     {
1457       log_error (("`%s' are not allowed in the socket name\n"), PATHSEP_S);
1458       agent_exit (2);
1459     }
1460   if (strlen (name) + 1 >= DIMof (struct sockaddr_un, sun_path) )
1461     {
1462       log_error (_("name of socket too long\n"));
1463       agent_exit (2);
1464     }
1465   return name;
1466 }
1467
1468
1469
1470 /* Create a Unix domain socket with NAME.  Returns the file descriptor
1471    or terminates the process in case of an error.  Not that this
1472    function needs to be used for the regular socket first and only
1473    then for the ssh socket.  */
1474 static gnupg_fd_t
1475 create_server_socket (char *name, int is_ssh, assuan_sock_nonce_t *nonce)
1476 {
1477   struct sockaddr_un *serv_addr;
1478   socklen_t len;
1479   gnupg_fd_t fd;
1480   int rc;
1481
1482   fd = assuan_sock_new (AF_UNIX, SOCK_STREAM, 0);
1483   if (fd == ASSUAN_INVALID_FD)
1484     {
1485       log_error (_("can't create socket: %s\n"), strerror (errno));
1486       agent_exit (2);
1487     }
1488
1489   serv_addr = xmalloc (sizeof (*serv_addr)); 
1490   memset (serv_addr, 0, sizeof *serv_addr);
1491   serv_addr->sun_family = AF_UNIX;
1492   if (strlen (name) + 1 >= sizeof (serv_addr->sun_path))
1493     {
1494       log_error (_("socket name `%s' is too long\n"), name);
1495       agent_exit (2);
1496     }
1497   strcpy (serv_addr->sun_path, name);
1498   len = SUN_LEN (serv_addr);
1499   rc = assuan_sock_bind (fd, (struct sockaddr*) serv_addr, len);
1500   if (opt.use_standard_socket && rc == -1 && errno == EADDRINUSE)
1501     {
1502       /* Check whether a gpg-agent is already running on the standard
1503          socket.  We do this test only if this is not the ssh socket.
1504          For ssh we assume that a test for gpg-agent has already been
1505          done and reuse the requested ssh socket.  Testing the
1506          ssh-socket is not possible because at this point, though we
1507          know the new Assuan socket, the Assuan server and thus the
1508          ssh-agent server is not yet operational.  This would lead to
1509          a hang.  */
1510       if (!is_ssh && !check_for_running_agent (1, 1))
1511         {
1512           log_error (_("a gpg-agent is already running - "
1513                        "not starting a new one\n"));
1514           *name = 0; /* Inhibit removal of the socket by cleanup(). */
1515           assuan_sock_close (fd);
1516           agent_exit (2);
1517         }
1518       remove (name);
1519       rc = assuan_sock_bind (fd, (struct sockaddr*) serv_addr, len);
1520     }
1521   if (rc != -1 
1522       && (rc=assuan_sock_get_nonce ((struct sockaddr*)serv_addr, len, nonce)))
1523     log_error (_("error getting nonce for the socket\n"));
1524   if (rc == -1)
1525     {
1526       /* We use gpg_strerror here because it allows us to get strings
1527          for some W32 socket error codes.  */
1528       log_error (_("error binding socket to `%s': %s\n"),
1529                  serv_addr->sun_path, 
1530                  gpg_strerror (gpg_error_from_errno (errno)));
1531       
1532       assuan_sock_close (fd);
1533       if (opt.use_standard_socket)
1534         *name = 0; /* Inhibit removal of the socket by cleanup(). */
1535       agent_exit (2);
1536     }
1537
1538   if (listen (FD2INT(fd), 5 ) == -1)
1539     {
1540       log_error (_("listen() failed: %s\n"), strerror (errno));
1541       assuan_sock_close (fd);
1542       agent_exit (2);
1543     }
1544           
1545   if (opt.verbose)
1546     log_info (_("listening on socket `%s'\n"), serv_addr->sun_path);
1547
1548   return fd;
1549 }
1550
1551
1552 /* Check that the directory for storing the private keys exists and
1553    create it if not.  This function won't fail as it is only a
1554    convenience function and not strictly necessary.  */
1555 static void
1556 create_private_keys_directory (const char *home)
1557 {
1558   char *fname;
1559   struct stat statbuf;
1560
1561   fname = make_filename (home, GNUPG_PRIVATE_KEYS_DIR, NULL);
1562   if (stat (fname, &statbuf) && errno == ENOENT)
1563     {
1564 #ifdef HAVE_W32_SYSTEM  /*FIXME: Setup proper permissions.  */
1565       if (!CreateDirectory (fname, NULL))
1566         log_error (_("can't create directory `%s': %s\n"),
1567                    fname, w32_strerror (-1) );
1568 #else
1569       if (mkdir (fname, S_IRUSR|S_IWUSR|S_IXUSR ))
1570         log_error (_("can't create directory `%s': %s\n"),
1571                    fname, strerror (errno) );
1572 #endif
1573       else if (!opt.quiet)
1574         log_info (_("directory `%s' created\n"), fname);
1575     }
1576   xfree (fname);
1577 }
1578
1579 /* Create the directory only if the supplied directory name is the
1580    same as the default one.  This way we avoid to create arbitrary
1581    directories when a non-default home directory is used.  To cope
1582    with HOME, we compare only the suffix if we see that the default
1583    homedir does start with a tilde.  We don't stop here in case of
1584    problems because other functions will throw an error anyway.*/
1585 static void
1586 create_directories (void)
1587 {
1588   struct stat statbuf;
1589   const char *defhome = standard_homedir ();
1590   char *home;
1591
1592   home = make_filename (opt.homedir, NULL);
1593   if ( stat (home, &statbuf) )
1594     {
1595       if (errno == ENOENT)
1596         {
1597           if (
1598 #ifdef HAVE_W32_SYSTEM
1599               ( !compare_filenames (home, defhome) )
1600 #else
1601               (*defhome == '~'
1602                 && (strlen (home) >= strlen (defhome+1)
1603                     && !strcmp (home + strlen(home)
1604                                 - strlen (defhome+1), defhome+1)))
1605                || (*defhome != '~' && !strcmp (home, defhome) )
1606 #endif
1607                )
1608             {
1609 #ifdef HAVE_W32_SYSTEM
1610               if (!CreateDirectory (home, NULL))
1611                 log_error (_("can't create directory `%s': %s\n"),
1612                            home, w32_strerror (-1) );
1613 #else
1614               if (mkdir (home, S_IRUSR|S_IWUSR|S_IXUSR ))
1615                 log_error (_("can't create directory `%s': %s\n"),
1616                            home, strerror (errno) );
1617 #endif
1618               else 
1619                 {
1620                   if (!opt.quiet)
1621                     log_info (_("directory `%s' created\n"), home);
1622                   create_private_keys_directory (home);
1623                 }
1624             }
1625         }
1626       else
1627         log_error (_("stat() failed for `%s': %s\n"), home, strerror (errno));
1628     }
1629   else if ( !S_ISDIR(statbuf.st_mode))
1630     {
1631       log_error (_("can't use `%s' as home directory\n"), home);
1632     }
1633   else /* exists and is a directory. */
1634     {
1635       create_private_keys_directory (home);
1636     }
1637   xfree (home);
1638 }
1639
1640
1641
1642 /* This is the worker for the ticker.  It is called every few seconds
1643    and may only do fast operations. */
1644 static void
1645 handle_tick (void)
1646 {
1647   static time_t last_minute;
1648
1649   if (!last_minute)
1650     last_minute = time (NULL);
1651
1652   /* Check whether the scdaemon has died and cleanup in this case. */
1653   agent_scd_check_aliveness ();
1654
1655   /* If we are running as a child of another process, check whether
1656      the parent is still alive and shutdown if not. */
1657 #ifndef HAVE_W32_SYSTEM
1658   if (parent_pid != (pid_t)(-1))
1659     {
1660       if (kill (parent_pid, 0))
1661         {
1662           shutdown_pending = 2;
1663           log_info ("parent process died - shutting down\n");
1664           log_info ("%s %s stopped\n", strusage(11), strusage(13) );
1665           cleanup ();
1666           agent_exit (0);
1667         }
1668     }
1669 #endif /*HAVE_W32_SYSTEM*/
1670   
1671   /* Code to be run every minute.  */
1672   if (last_minute + 60 <= time (NULL))
1673     {
1674       check_own_socket ();
1675       last_minute = time (NULL);
1676     }
1677
1678 }
1679
1680
1681 /* A global function which allows us to call the reload stuff from
1682    other places too.  This is only used when build for W32.  */
1683 void
1684 agent_sighup_action (void)
1685 {
1686   log_info ("SIGHUP received - "
1687             "re-reading configuration and flushing cache\n");
1688   agent_flush_cache ();
1689   reread_configuration ();
1690   agent_reload_trustlist ();
1691 }
1692
1693
1694 static void
1695 agent_sigusr2_action (void)
1696 {
1697   if (opt.verbose)
1698     log_info ("SIGUSR2 received - updating card event counter\n");
1699   /* Nothing to check right now.  We only increment a counter.  */
1700   bump_card_eventcounter ();
1701 }
1702
1703
1704 static void
1705 handle_signal (int signo)
1706 {
1707   switch (signo)
1708     {
1709 #ifndef HAVE_W32_SYSTEM
1710     case SIGHUP:
1711       agent_sighup_action ();
1712       break;
1713       
1714     case SIGUSR1:
1715       log_info ("SIGUSR1 received - printing internal information:\n");
1716       pth_ctrl (PTH_CTRL_DUMPSTATE, log_get_stream ());
1717       agent_query_dump_state ();
1718       agent_scd_dump_state ();
1719       break;
1720       
1721     case SIGUSR2:
1722       agent_sigusr2_action ();
1723       break;
1724
1725     case SIGTERM:
1726       if (!shutdown_pending)
1727         log_info ("SIGTERM received - shutting down ...\n");
1728       else
1729         log_info ("SIGTERM received - still %ld running threads\n",
1730                   pth_ctrl( PTH_CTRL_GETTHREADS ));
1731       shutdown_pending++;
1732       if (shutdown_pending > 2)
1733         {
1734           log_info ("shutdown forced\n");
1735           log_info ("%s %s stopped\n", strusage(11), strusage(13) );
1736           cleanup ();
1737           agent_exit (0);
1738         }
1739       break;
1740         
1741     case SIGINT:
1742       log_info ("SIGINT received - immediate shutdown\n");
1743       log_info( "%s %s stopped\n", strusage(11), strusage(13));
1744       cleanup ();
1745       agent_exit (0);
1746       break;
1747 #endif
1748     default:
1749       log_info ("signal %d received - no action defined\n", signo);
1750     }
1751 }
1752
1753
1754 /* Check the nonce on a new connection.  This is a NOP unless we we
1755    are using our Unix domain socket emulation under Windows.  */
1756 static int 
1757 check_nonce (ctrl_t ctrl, assuan_sock_nonce_t *nonce)
1758 {
1759   if (assuan_sock_check_nonce (ctrl->thread_startup.fd, nonce))
1760     {
1761       log_info (_("error reading nonce on fd %d: %s\n"), 
1762                 FD2INT(ctrl->thread_startup.fd), strerror (errno));
1763       assuan_sock_close (ctrl->thread_startup.fd);
1764       xfree (ctrl);
1765       return -1;
1766     }
1767   else
1768     return 0;
1769 }
1770
1771
1772 /* This is the standard connection thread's main function.  */
1773 static void *
1774 start_connection_thread (void *arg)
1775 {
1776   ctrl_t ctrl = arg;
1777
1778   if (check_nonce (ctrl, &socket_nonce))
1779     return NULL;
1780
1781   agent_init_default_ctrl (ctrl);
1782   if (opt.verbose)
1783     log_info (_("handler 0x%lx for fd %d started\n"), 
1784               pth_thread_id (), FD2INT(ctrl->thread_startup.fd));
1785
1786   start_command_handler (ctrl, GNUPG_INVALID_FD, ctrl->thread_startup.fd);
1787   if (opt.verbose)
1788     log_info (_("handler 0x%lx for fd %d terminated\n"), 
1789               pth_thread_id (), FD2INT(ctrl->thread_startup.fd));
1790   
1791   agent_deinit_default_ctrl (ctrl);
1792   xfree (ctrl);
1793   return NULL;
1794 }
1795
1796
1797 /* This is the ssh connection thread's main function.  */
1798 static void *
1799 start_connection_thread_ssh (void *arg)
1800 {
1801   ctrl_t ctrl = arg;
1802
1803   if (check_nonce (ctrl, &socket_nonce_ssh))
1804     return NULL;
1805
1806   agent_init_default_ctrl (ctrl);
1807   if (opt.verbose)
1808     log_info (_("ssh handler 0x%lx for fd %d started\n"),
1809               pth_thread_id (), FD2INT(ctrl->thread_startup.fd));
1810
1811   start_command_handler_ssh (ctrl, ctrl->thread_startup.fd);
1812   if (opt.verbose)
1813     log_info (_("ssh handler 0x%lx for fd %d terminated\n"),
1814               pth_thread_id (), FD2INT(ctrl->thread_startup.fd));
1815   
1816   agent_deinit_default_ctrl (ctrl);
1817   xfree (ctrl);
1818   return NULL;
1819 }
1820
1821
1822 /* Connection handler loop.  Wait for connection requests and spawn a
1823    thread after accepting a connection.  */
1824 static void
1825 handle_connections (gnupg_fd_t listen_fd, gnupg_fd_t listen_fd_ssh)
1826 {
1827   pth_attr_t tattr;
1828   pth_event_t ev, time_ev;
1829   sigset_t sigs;
1830   int signo;
1831   struct sockaddr_un paddr;
1832   socklen_t plen;
1833   fd_set fdset, read_fdset;
1834   int ret;
1835   gnupg_fd_t fd;
1836   int nfd;
1837
1838   tattr = pth_attr_new();
1839   pth_attr_set (tattr, PTH_ATTR_JOINABLE, 0);
1840   pth_attr_set (tattr, PTH_ATTR_STACK_SIZE, 256*1024);
1841
1842 #ifndef HAVE_W32_SYSTEM /* fixme */
1843   /* Make sure that the signals we are going to handle are not blocked
1844      and create an event object for them.  We also set the default
1845      action to ignore because we use an Pth event to get notified
1846      about signals.  This avoids that the default action is taken in
1847      case soemthing goes wrong within Pth.  The problem might also be
1848      a Pth bug.  */
1849   sigemptyset (&sigs );
1850   {
1851     static const int mysigs[] = { SIGHUP, SIGUSR1, SIGUSR2, SIGINT, SIGTERM };
1852     struct sigaction sa;
1853     int i;
1854
1855     for (i=0; i < DIM (mysigs); i++)
1856       {
1857         sigemptyset (&sa.sa_mask);
1858         sa.sa_handler = SIG_IGN;
1859         sa.sa_flags = 0;
1860         sigaction (mysigs[i], &sa, NULL);
1861         
1862         sigaddset (&sigs, mysigs[i]);
1863       }
1864   }
1865
1866   pth_sigmask (SIG_UNBLOCK, &sigs, NULL);
1867   ev = pth_event (PTH_EVENT_SIGS, &sigs, &signo);
1868 #else
1869 # ifdef PTH_EVENT_HANDLE
1870   sigs = 0;
1871   ev = pth_event (PTH_EVENT_HANDLE, get_agent_scd_notify_event ());
1872   signo = 0;
1873 # else
1874   /* Use a dummy event. */
1875   sigs = 0;
1876   ev = pth_event (PTH_EVENT_SIGS, &sigs, &signo);
1877 # endif
1878 #endif
1879   time_ev = NULL;
1880
1881   FD_ZERO (&fdset);
1882   FD_SET (FD2INT (listen_fd), &fdset);
1883   nfd = FD2INT (listen_fd);
1884   if (listen_fd_ssh != GNUPG_INVALID_FD)
1885     {
1886       FD_SET ( FD2INT(listen_fd_ssh), &fdset);
1887       if (FD2INT (listen_fd_ssh) > nfd)
1888         nfd = FD2INT (listen_fd_ssh);
1889     }
1890
1891   for (;;)
1892     {
1893       /* Make sure that our signals are not blocked.  */
1894       pth_sigmask (SIG_UNBLOCK, &sigs, NULL);
1895
1896       /* Shutdown test.  */
1897       if (shutdown_pending)
1898         {
1899           if (pth_ctrl (PTH_CTRL_GETTHREADS) == 1)
1900             break; /* ready */
1901
1902           /* Do not accept new connections but keep on running the
1903              loop to cope with the timer events.  */
1904           FD_ZERO (&fdset);
1905         }
1906
1907       /* Create a timeout event if needed.  To help with power saving
1908          we syncronize the ticks to the next full second.  */
1909       if (!time_ev)
1910         {
1911           pth_time_t nexttick;
1912
1913           nexttick = pth_timeout (TIMERTICK_INTERVAL, 0);
1914           if (nexttick.tv_usec > 10)  /* Use a 10 usec threshhold.  */
1915             {
1916               nexttick.tv_sec++;
1917               nexttick.tv_usec = 0;
1918             }
1919           time_ev = pth_event (PTH_EVENT_TIME, nexttick);
1920         }
1921
1922       /* POSIX says that fd_set should be implemented as a structure,
1923          thus a simple assignment is fine to copy the entire set.  */
1924       read_fdset = fdset;
1925
1926       if (time_ev)
1927         pth_event_concat (ev, time_ev, NULL);
1928       ret = pth_select_ev (nfd+1, &read_fdset, NULL, NULL, NULL, ev);
1929       if (time_ev)
1930         pth_event_isolate (time_ev);
1931
1932       if (ret == -1)
1933         {
1934           if (pth_event_occurred (ev)
1935               || (time_ev && pth_event_occurred (time_ev)))
1936             {
1937               if (pth_event_occurred (ev))
1938                 {
1939 #if defined(HAVE_W32_SYSTEM) && defined(PTH_EVENT_HANDLE)
1940                   agent_sigusr2_action ();
1941 #else
1942                   handle_signal (signo);
1943 #endif
1944                 }
1945               if (time_ev && pth_event_occurred (time_ev))
1946                 {
1947                   pth_event_free (time_ev, PTH_FREE_ALL);
1948                   time_ev = NULL;
1949                   handle_tick ();
1950                 }
1951               continue;
1952             }
1953           log_error (_("pth_select failed: %s - waiting 1s\n"),
1954                      strerror (errno));
1955           pth_sleep (1);
1956           continue;
1957         }
1958
1959       if (pth_event_occurred (ev))
1960         {
1961 #if defined(HAVE_W32_SYSTEM) && defined(PTH_EVENT_HANDLE)
1962           agent_sigusr2_action ();
1963 #else
1964           handle_signal (signo);
1965 #endif
1966         }
1967
1968       if (time_ev && pth_event_occurred (time_ev))
1969         {
1970           pth_event_free (time_ev, PTH_FREE_ALL);
1971           time_ev = NULL;
1972           handle_tick ();
1973         }
1974
1975
1976       /* We now might create new threads and because we don't want any
1977          signals (as we are handling them here) to be delivered to a
1978          new thread.  Thus we need to block those signals. */
1979       pth_sigmask (SIG_BLOCK, &sigs, NULL);
1980
1981       if (!shutdown_pending && FD_ISSET (FD2INT (listen_fd), &read_fdset))
1982         {
1983           ctrl_t ctrl;
1984
1985           plen = sizeof paddr;
1986           fd = INT2FD (pth_accept (FD2INT(listen_fd),
1987                                    (struct sockaddr *)&paddr, &plen));
1988           if (fd == GNUPG_INVALID_FD)
1989             {
1990               log_error ("accept failed: %s\n", strerror (errno));
1991             }
1992           else if ( !(ctrl = xtrycalloc (1, sizeof *ctrl)) )
1993             {
1994               log_error ("error allocating connection control data: %s\n",
1995                          strerror (errno) );
1996               assuan_sock_close (fd);
1997             }
1998           else if ( !(ctrl->session_env = session_env_new ()) )
1999             {
2000               log_error ("error allocating session environment block: %s\n",
2001                          strerror (errno) );
2002               xfree (ctrl);
2003               assuan_sock_close (fd);
2004             }
2005           else 
2006             {
2007               char threadname[50];
2008
2009               snprintf (threadname, sizeof threadname-1,
2010                         "conn fd=%d (gpg)", FD2INT(fd));
2011               threadname[sizeof threadname -1] = 0;
2012               pth_attr_set (tattr, PTH_ATTR_NAME, threadname);
2013               ctrl->thread_startup.fd = fd;
2014               if (!pth_spawn (tattr, start_connection_thread, ctrl))
2015                 {
2016                   log_error ("error spawning connection handler: %s\n",
2017                              strerror (errno) );
2018                   assuan_sock_close (fd);
2019                   xfree (ctrl);
2020                 }
2021             }
2022           fd = GNUPG_INVALID_FD;
2023         }
2024
2025       if (!shutdown_pending && listen_fd_ssh != GNUPG_INVALID_FD 
2026           && FD_ISSET ( FD2INT (listen_fd_ssh), &read_fdset))
2027         {
2028           ctrl_t ctrl;
2029
2030           plen = sizeof paddr;
2031           fd = INT2FD(pth_accept (FD2INT(listen_fd_ssh),
2032                                   (struct sockaddr *)&paddr, &plen));
2033           if (fd == GNUPG_INVALID_FD)
2034             {
2035               log_error ("accept failed for ssh: %s\n", strerror (errno));
2036             }
2037           else if ( !(ctrl = xtrycalloc (1, sizeof *ctrl)) )
2038             {
2039               log_error ("error allocating connection control data: %s\n",
2040                          strerror (errno) );
2041               assuan_sock_close (fd);
2042             }
2043           else if ( !(ctrl->session_env = session_env_new ()) )
2044             {
2045               log_error ("error allocating session environment block: %s\n",
2046                          strerror (errno) );
2047               xfree (ctrl);
2048               assuan_sock_close (fd);
2049             }
2050           else
2051             {
2052               char threadname[50];
2053
2054               agent_init_default_ctrl (ctrl);
2055               snprintf (threadname, sizeof threadname-1,
2056                         "conn fd=%d (ssh)", FD2INT(fd));
2057               threadname[sizeof threadname -1] = 0;
2058               pth_attr_set (tattr, PTH_ATTR_NAME, threadname);
2059               ctrl->thread_startup.fd = fd;
2060               if (!pth_spawn (tattr, start_connection_thread_ssh, ctrl) )
2061                 {
2062                   log_error ("error spawning ssh connection handler: %s\n",
2063                              strerror (errno) );
2064                   assuan_sock_close (fd);
2065                   xfree (ctrl);
2066                 }
2067             }
2068           fd = GNUPG_INVALID_FD;
2069         }
2070     }
2071
2072   pth_event_free (ev, PTH_FREE_ALL);
2073   if (time_ev)
2074     pth_event_free (time_ev, PTH_FREE_ALL);
2075   cleanup ();
2076   log_info (_("%s %s stopped\n"), strusage(11), strusage(13));
2077 }
2078
2079
2080
2081 /* Helper for check_own_socket.  */
2082 static gpg_error_t
2083 check_own_socket_pid_cb (void *opaque, const void *buffer, size_t length)
2084 {
2085   membuf_t *mb = opaque;
2086   put_membuf (mb, buffer, length);
2087   return 0;
2088 }
2089
2090
2091 /* The thread running the actual check.  We need to run this in a
2092    separate thread so that check_own_thread can be called from the
2093    timer tick.  */
2094 static void *
2095 check_own_socket_thread (void *arg)
2096 {
2097   int rc;
2098   char *sockname = arg;
2099   assuan_context_t ctx = NULL;
2100   membuf_t mb;
2101   char *buffer;
2102
2103   check_own_socket_running++;
2104
2105   rc = assuan_new (&ctx);
2106   if (rc)
2107     {
2108       log_error ("can't allocate assuan context: %s\n", gpg_strerror (rc));
2109       goto leave;
2110     }
2111
2112   rc = assuan_socket_connect (ctx, sockname, (pid_t)(-1), 0);
2113   if (rc)
2114     {
2115       log_error ("can't connect my own socket: %s\n", gpg_strerror (rc));
2116       goto leave;
2117     }
2118  
2119   init_membuf (&mb, 100);
2120   rc = assuan_transact (ctx, "GETINFO pid", check_own_socket_pid_cb, &mb,
2121                         NULL, NULL, NULL, NULL);
2122   put_membuf (&mb, "", 1);
2123   buffer = get_membuf (&mb, NULL);
2124   if (rc || !buffer)
2125     {
2126       log_error ("sending command \"%s\" to my own socket failed: %s\n", 
2127                  "GETINFO pid", gpg_strerror (rc));
2128       rc = 1;
2129     }
2130   else if ( (pid_t)strtoul (buffer, NULL, 10) != getpid ())
2131     {
2132       log_error ("socket is now serviced by another server\n");
2133       rc = 1;
2134     }
2135   else if (opt.verbose > 1)
2136     log_error ("socket is still served by this server\n");
2137     
2138   xfree (buffer);
2139
2140  leave:
2141   xfree (sockname);
2142   if (ctx)
2143     assuan_release (ctx);
2144   if (rc)
2145     {
2146       /* We may not remove the socket as it is now in use by another
2147          server.  Setting the name to empty does this.  */
2148       if (socket_name)
2149         *socket_name = 0;
2150       if (socket_name_ssh)
2151         *socket_name_ssh = 0;
2152       shutdown_pending = 2;
2153       log_info ("this process is useless - shutting down\n");
2154     }
2155   check_own_socket_running--;
2156   return NULL;
2157 }
2158
2159
2160 /* Check whether we are still listening on our own socket.  In case
2161    another gpg-agent process started after us has taken ownership of
2162    our socket, we woul linger around without any real taks.  Thus we
2163    better check once in a while whether we are really needed.  */
2164 static void
2165 check_own_socket (void)
2166 {
2167   char *sockname;
2168   pth_attr_t tattr;
2169
2170   if (!opt.use_standard_socket)
2171     return; /* This check makes only sense in standard socket mode.  */
2172
2173   if (check_own_socket_running || shutdown_pending)
2174     return;  /* Still running or already shutting down.  */
2175
2176   sockname = make_filename (opt.homedir, "S.gpg-agent", NULL);
2177   if (!sockname)
2178     return; /* Out of memory.  */
2179
2180   tattr = pth_attr_new();
2181   pth_attr_set (tattr, PTH_ATTR_JOINABLE, 0);
2182   pth_attr_set (tattr, PTH_ATTR_STACK_SIZE, 256*1024);
2183   pth_attr_set (tattr, PTH_ATTR_NAME, "check-own-socket");
2184
2185   if (!pth_spawn (tattr, check_own_socket_thread, sockname))
2186       log_error ("error spawning check_own_socket_thread: %s\n",
2187                  strerror (errno) );
2188   pth_attr_destroy (tattr);
2189 }
2190
2191
2192
2193 /* Figure out whether an agent is available and running. Prints an
2194    error if not.  If SILENT is true, no messages are printed.  Usually
2195    started with MODE 0.  Returns 0 if the agent is running. */
2196 static int
2197 check_for_running_agent (int silent, int mode)
2198 {
2199   int rc;
2200   char *infostr, *p;
2201   assuan_context_t ctx = NULL;
2202   int prot, pid;
2203
2204   if (!mode)
2205     {
2206       infostr = getenv ("GPG_AGENT_INFO");
2207       if (!infostr || !*infostr)
2208         {
2209           if (!check_for_running_agent (silent, 1))
2210             return 0; /* Okay, its running on the standard socket. */
2211           if (!silent)
2212             log_error (_("no gpg-agent running in this session\n"));
2213           return -1;
2214         }
2215
2216       infostr = xstrdup (infostr);
2217       if ( !(p = strchr (infostr, PATHSEP_C)) || p == infostr)
2218         {
2219           xfree (infostr);
2220           if (!check_for_running_agent (silent, 1))
2221             return 0; /* Okay, its running on the standard socket. */
2222           if (!silent)
2223             log_error (_("malformed GPG_AGENT_INFO environment variable\n"));
2224           return -1;
2225         }
2226
2227       *p++ = 0;
2228       pid = atoi (p);
2229       while (*p && *p != PATHSEP_C)
2230         p++;
2231       prot = *p? atoi (p+1) : 0;
2232       if (prot != 1)
2233         {
2234           xfree (infostr);
2235           if (!silent)
2236             log_error (_("gpg-agent protocol version %d is not supported\n"),
2237                        prot);
2238           if (!check_for_running_agent (silent, 1))
2239             return 0; /* Okay, its running on the standard socket. */
2240           return -1;
2241         }
2242     }
2243   else /* MODE != 0 */
2244     {
2245       infostr = make_filename (opt.homedir, "S.gpg-agent", NULL);
2246       pid = (pid_t)(-1);
2247     }
2248
2249   rc = assuan_new (&ctx);
2250   if (! rc)
2251     rc = assuan_socket_connect (ctx, infostr, pid, 0);
2252   xfree (infostr);
2253   if (rc)
2254     {
2255       if (!mode && !check_for_running_agent (silent, 1))
2256         return 0; /* Okay, its running on the standard socket. */
2257
2258       if (!mode && !silent)
2259         log_error ("can't connect to the agent: %s\n", gpg_strerror (rc));
2260
2261       if (ctx)
2262         assuan_release (ctx);
2263       return -1;
2264     }
2265
2266   if (!opt.quiet && !silent)
2267     log_info ("gpg-agent running and available\n");
2268
2269   assuan_release (ctx);
2270   return 0;
2271 }