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