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