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