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