Remove use of gnulib (part 1)
[gnupg.git] / agent / gpg-agent.c
1 /* gpg-agent.c  -  The GnuPG Agent
2  * Copyright (C) 2000-2007, 2009-2010 Free Software Foundation, Inc.
3  * Copyright (C) 2000-2014 Werner Koch
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 #ifdef HAVE_W32_SYSTEM
34 # ifndef WINVER
35 #  define WINVER 0x0500  /* Same as in common/sysutils.c */
36 # endif
37 # ifdef HAVE_WINSOCK2_H
38 #  include <winsock2.h>
39 # endif
40 # include <aclapi.h>
41 # include <sddl.h>
42 #else /*!HAVE_W32_SYSTEM*/
43 # include <sys/socket.h>
44 # include <sys/un.h>
45 #endif /*!HAVE_W32_SYSTEM*/
46 #include <unistd.h>
47 #ifdef HAVE_SIGNAL_H
48 # include <signal.h>
49 #endif
50 #include <npth.h>
51
52 #define JNLIB_NEED_LOG_LOGV
53 #define JNLIB_NEED_AFLOCAL
54 #include "agent.h"
55 #include <assuan.h> /* Malloc hooks  and socket wrappers. */
56
57 #include "i18n.h"
58 #include "sysutils.h"
59 #include "gc-opt-flags.h"
60 #include "exechelp.h"
61 #include "asshelp.h"
62 #include "openpgpdefs.h"  /* for PUBKEY_ALGO_ECDSA, PUBKEY_ALGO_ECDH */
63 #include "../common/init.h"
64
65
66 enum cmd_and_opt_values
67 { aNull = 0,
68   oCsh            = 'c',
69   oQuiet          = 'q',
70   oSh             = 's',
71   oVerbose        = 'v',
72
73   oNoVerbose = 500,
74   aGPGConfList,
75   aGPGConfTest,
76   aUseStandardSocketP,
77   oOptions,
78   oDebug,
79   oDebugAll,
80   oDebugLevel,
81   oDebugWait,
82   oDebugQuickRandom,
83   oNoGreeting,
84   oNoOptions,
85   oHomedir,
86   oNoDetach,
87   oNoGrab,
88   oLogFile,
89   oServer,
90   oDaemon,
91   oBatch,
92
93   oPinentryProgram,
94   oPinentryTouchFile,
95   oDisplay,
96   oTTYname,
97   oTTYtype,
98   oLCctype,
99   oLCmessages,
100   oXauthority,
101   oScdaemonProgram,
102   oDefCacheTTL,
103   oDefCacheTTLSSH,
104   oMaxCacheTTL,
105   oMaxCacheTTLSSH,
106   oEnforcePassphraseConstraints,
107   oMinPassphraseLen,
108   oMinPassphraseNonalpha,
109   oCheckPassphrasePattern,
110   oMaxPassphraseDays,
111   oEnablePassphraseHistory,
112   oUseStandardSocket,
113   oNoUseStandardSocket,
114   oFakedSystemTime,
115
116   oIgnoreCacheForSigning,
117   oAllowMarkTrusted,
118   oNoAllowMarkTrusted,
119   oAllowPresetPassphrase,
120   oAllowLoopbackPinentry,
121   oKeepTTY,
122   oKeepDISPLAY,
123   oSSHSupport,
124   oPuttySupport,
125   oDisableScdaemon,
126   oDisableCheckOwnSocket,
127   oWriteEnvFile
128 };
129
130
131
132 static ARGPARSE_OPTS opts[] = {
133
134   { aGPGConfList, "gpgconf-list", 256, "@" },
135   { aGPGConfTest, "gpgconf-test", 256, "@" },
136   { aUseStandardSocketP, "use-standard-socket-p", 256, "@" },
137
138   { 301, NULL, 0, N_("@Options:\n ") },
139
140   { oDaemon,   "daemon",     0, N_("run in daemon mode (background)") },
141   { oServer,   "server",     0, N_("run in server mode (foreground)") },
142   { oVerbose, "verbose",     0, N_("verbose") },
143   { oQuiet,     "quiet",     0, N_("be somewhat more quiet") },
144   { oSh,        "sh",        0, N_("sh-style command output") },
145   { oCsh,       "csh",       0, N_("csh-style command output") },
146   { oOptions, "options"  , 2, N_("|FILE|read options from FILE")},
147   { oDebug,     "debug"     ,4|16, "@"},
148   { oDebugAll, "debug-all"     ,0, "@"},
149   { oDebugLevel, "debug-level" ,2, "@"},
150   { oDebugWait,"debug-wait",1, "@"},
151   ARGPARSE_s_n (oDebugQuickRandom, "debug-quick-random", "@"),
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         else if (pargs.r_opt == oDebugQuickRandom)
734           {
735             gcry_control (GCRYCTL_ENABLE_QUICK_RANDOM, 0);
736           }
737
738     }
739
740   /* Initialize the secure memory. */
741   gcry_control (GCRYCTL_INIT_SECMEM, 32768, 0);
742   maybe_setuid = 0;
743
744   /*
745      Now we are now working under our real uid
746   */
747
748   if (default_config)
749     configname = make_filename (opt.homedir, GPG_AGENT_NAME EXTSEP_S "conf",
750                                 NULL );
751
752   argc = orig_argc;
753   argv = orig_argv;
754   pargs.argc = &argc;
755   pargs.argv = &argv;
756   pargs.flags=  1;  /* do not remove the args */
757  next_pass:
758   if (configname)
759     {
760       configlineno = 0;
761       configfp = fopen (configname, "r");
762       if (!configfp)
763         {
764           if (default_config)
765             {
766               if( parse_debug )
767                 log_info (_("Note: no default option file '%s'\n"),
768                           configname );
769               /* Save the default conf file name so that
770                  reread_configuration is able to test whether the
771                  config file has been created in the meantime.  */
772               xfree (config_filename);
773               config_filename = configname;
774               configname = NULL;
775             }
776           else
777             {
778               log_error (_("option file '%s': %s\n"),
779                          configname, strerror(errno) );
780               exit(2);
781             }
782           xfree (configname);
783           configname = NULL;
784         }
785       if (parse_debug && configname )
786         log_info (_("reading options from '%s'\n"), configname );
787       default_config = 0;
788     }
789
790   while (optfile_parse( configfp, configname, &configlineno, &pargs, opts) )
791     {
792       if (parse_rereadable_options (&pargs, 0))
793         continue; /* Already handled */
794       switch (pargs.r_opt)
795         {
796         case aGPGConfList: gpgconf_list = 1; break;
797         case aGPGConfTest: gpgconf_list = 2; break;
798         case aUseStandardSocketP: gpgconf_list = 3; break;
799         case oBatch: opt.batch=1; break;
800
801         case oDebugWait: debug_wait = pargs.r.ret_int; break;
802
803         case oOptions:
804           /* config files may not be nested (silently ignore them) */
805           if (!configfp)
806             {
807                 xfree(configname);
808                 configname = xstrdup(pargs.r.ret_str);
809                 goto next_pass;
810             }
811           break;
812         case oNoGreeting: /* Dummy option.  */ break;
813         case oNoVerbose: opt.verbose = 0; break;
814         case oNoOptions: break; /* no-options */
815         case oHomedir: opt.homedir = pargs.r.ret_str; break;
816         case oNoDetach: nodetach = 1; break;
817         case oLogFile: logfile = pargs.r.ret_str; break;
818         case oCsh: csh_style = 1; break;
819         case oSh: csh_style = 0; break;
820         case oServer: pipe_server = 1; break;
821         case oDaemon: is_daemon = 1; break;
822
823         case oDisplay: default_display = xstrdup (pargs.r.ret_str); break;
824         case oTTYname: default_ttyname = xstrdup (pargs.r.ret_str); break;
825         case oTTYtype: default_ttytype = xstrdup (pargs.r.ret_str); break;
826         case oLCctype: default_lc_ctype = xstrdup (pargs.r.ret_str); break;
827         case oLCmessages: default_lc_messages = xstrdup (pargs.r.ret_str);
828           break;
829         case oXauthority: default_xauthority = xstrdup (pargs.r.ret_str);
830           break;
831
832         case oUseStandardSocket:   /* dummy */ break;
833         case oNoUseStandardSocket: /* dummy */ break;
834
835         case oFakedSystemTime:
836           {
837             time_t faked_time = isotime2epoch (pargs.r.ret_str);
838             if (faked_time == (time_t)(-1))
839               faked_time = (time_t)strtoul (pargs.r.ret_str, NULL, 10);
840             gnupg_set_time (faked_time, 0);
841           }
842           break;
843
844         case oKeepTTY: opt.keep_tty = 1; break;
845         case oKeepDISPLAY: opt.keep_display = 1; break;
846
847         case oSSHSupport:  opt.ssh_support = 1; break;
848         case oPuttySupport:
849 #        ifdef HAVE_W32_SYSTEM
850           putty_support = 1;
851           opt.ssh_support = 1;
852 #        endif
853           break;
854
855         case oDebugQuickRandom:
856           /* Only used by the first stage command line parser.  */
857           break;
858
859         case oWriteEnvFile: /* dummy */ break;
860
861         default : pargs.err = configfp? 1:2; break;
862         }
863     }
864   if (configfp)
865     {
866       fclose( configfp );
867       configfp = NULL;
868       /* Keep a copy of the name so that it can be read on SIGHUP. */
869       if (config_filename != configname)
870         {
871           xfree (config_filename);
872           config_filename = configname;
873         }
874       configname = NULL;
875       goto next_pass;
876     }
877
878   xfree (configname);
879   configname = NULL;
880   if (log_get_errorcount(0))
881     exit(2);
882
883   /* Turn the homedir into an absolute one. */
884   opt.homedir = make_absfilename (opt.homedir, NULL);
885
886   /* Print a warning if an argument looks like an option.  */
887   if (!opt.quiet && !(pargs.flags & ARGPARSE_FLAG_STOP_SEEN))
888     {
889       int i;
890
891       for (i=0; i < argc; i++)
892         if (argv[i][0] == '-' && argv[i][1] == '-')
893           log_info (_("Note: '%s' is not considered an option\n"), argv[i]);
894     }
895
896 #ifdef ENABLE_NLS
897   /* gpg-agent usually does not output any messages because it runs in
898      the background.  For log files it is acceptable to have messages
899      always encoded in utf-8.  We switch here to utf-8, so that
900      commands like --help still give native messages.  It is far
901      easier to switch only once instead of for every message and it
902      actually helps when more then one thread is active (avoids an
903      extra copy step). */
904     bind_textdomain_codeset (PACKAGE_GT, "UTF-8");
905 #endif
906
907   if (!pipe_server && !is_daemon && !gpgconf_list)
908     {
909      /* We have been called without any options and thus we merely
910         check whether an agent is already running.  We do this right
911         here so that we don't clobber a logfile with this check but
912         print the status directly to stderr. */
913       opt.debug = 0;
914       set_debug ();
915       check_for_running_agent (0);
916       agent_exit (0);
917     }
918
919   set_debug ();
920
921   if (atexit (cleanup))
922     {
923       log_error ("atexit failed\n");
924       cleanup ();
925       exit (1);
926     }
927
928   initialize_module_cache ();
929   initialize_module_call_pinentry ();
930   initialize_module_call_scd ();
931   initialize_module_trustlist ();
932
933   /* Try to create missing directories. */
934   create_directories ();
935
936   if (debug_wait && pipe_server)
937     {
938       log_debug ("waiting for debugger - my pid is %u .....\n",
939                  (unsigned int)getpid());
940       gnupg_sleep (debug_wait);
941       log_debug ("... okay\n");
942     }
943
944   if (gpgconf_list == 3)
945     {
946       /* We now use the standard socket always - return true for
947          backward compatibility.  */
948       agent_exit (0);
949     }
950   else if (gpgconf_list == 2)
951     agent_exit (0);
952   else if (gpgconf_list)
953     {
954       char *filename;
955       char *filename_esc;
956
957       /* List options and default values in the GPG Conf format.  */
958       filename = make_filename (opt.homedir, GPG_AGENT_NAME EXTSEP_S "conf",
959                                 NULL );
960       filename_esc = percent_escape (filename, NULL);
961
962       es_printf ("%s-%s.conf:%lu:\"%s\n",
963                  GPGCONF_NAME, GPG_AGENT_NAME,
964                  GC_OPT_FLAG_DEFAULT, filename_esc);
965       xfree (filename);
966       xfree (filename_esc);
967
968       es_printf ("verbose:%lu:\n"
969               "quiet:%lu:\n"
970               "debug-level:%lu:\"none:\n"
971               "log-file:%lu:\n",
972               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME,
973               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME,
974               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME,
975               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME );
976       es_printf ("default-cache-ttl:%lu:%d:\n",
977               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME, DEFAULT_CACHE_TTL );
978       es_printf ("default-cache-ttl-ssh:%lu:%d:\n",
979               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME, DEFAULT_CACHE_TTL_SSH );
980       es_printf ("max-cache-ttl:%lu:%d:\n",
981               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME, MAX_CACHE_TTL );
982       es_printf ("max-cache-ttl-ssh:%lu:%d:\n",
983               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME, MAX_CACHE_TTL_SSH );
984       es_printf ("enforce-passphrase-constraints:%lu:\n",
985               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
986       es_printf ("min-passphrase-len:%lu:%d:\n",
987               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME, MIN_PASSPHRASE_LEN );
988       es_printf ("min-passphrase-nonalpha:%lu:%d:\n",
989               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME,
990               MIN_PASSPHRASE_NONALPHA);
991       es_printf ("check-passphrase-pattern:%lu:\n",
992               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME);
993       es_printf ("max-passphrase-days:%lu:%d:\n",
994               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME,
995               MAX_PASSPHRASE_DAYS);
996       es_printf ("enable-passphrase-history:%lu:\n",
997               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
998       es_printf ("no-grab:%lu:\n",
999               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
1000       es_printf ("ignore-cache-for-signing:%lu:\n",
1001               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
1002       es_printf ("no-allow-mark-trusted:%lu:\n",
1003               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
1004       es_printf ("disable-scdaemon:%lu:\n",
1005               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
1006 #ifdef HAVE_W32_SYSTEM
1007       es_printf ("enable-putty-support:%lu:\n", GC_OPT_FLAG_NONE);
1008 #else
1009       es_printf ("enable-ssh-support:%lu:\n", GC_OPT_FLAG_NONE);
1010 #endif
1011
1012       agent_exit (0);
1013     }
1014
1015   /* Now start with logging to a file if this is desired. */
1016   if (logfile)
1017     {
1018       log_set_file (logfile);
1019       log_set_prefix (NULL, (JNLIB_LOG_WITH_PREFIX
1020                              |JNLIB_LOG_WITH_TIME
1021                              |JNLIB_LOG_WITH_PID));
1022       current_logfile = xstrdup (logfile);
1023     }
1024
1025   /* Make sure that we have a default ttyname. */
1026   if (!default_ttyname && gnupg_ttyname (1))
1027     default_ttyname = xstrdup (gnupg_ttyname (1));
1028   if (!default_ttytype && getenv ("TERM"))
1029     default_ttytype = xstrdup (getenv ("TERM"));
1030
1031
1032   if (pipe_server)
1033     {
1034       /* This is the simple pipe based server */
1035       ctrl_t ctrl;
1036
1037       ctrl = xtrycalloc (1, sizeof *ctrl);
1038       if (!ctrl)
1039         {
1040           log_error ("error allocating connection control data: %s\n",
1041                      strerror (errno) );
1042           agent_exit (1);
1043         }
1044       ctrl->session_env = session_env_new ();
1045       if (!ctrl->session_env)
1046         {
1047           log_error ("error allocating session environment block: %s\n",
1048                      strerror (errno) );
1049           xfree (ctrl);
1050           agent_exit (1);
1051         }
1052       agent_init_default_ctrl (ctrl);
1053       start_command_handler (ctrl, GNUPG_INVALID_FD, GNUPG_INVALID_FD);
1054       agent_deinit_default_ctrl (ctrl);
1055       xfree (ctrl);
1056     }
1057   else if (!is_daemon)
1058     ; /* NOTREACHED */
1059   else
1060     { /* Regular server mode */
1061       gnupg_fd_t fd;
1062       gnupg_fd_t fd_ssh;
1063       pid_t pid;
1064
1065       /* Remove the DISPLAY variable so that a pinentry does not
1066          default to a specific display.  There is still a default
1067          display when gpg-agent was started using --display or a
1068          client requested this using an OPTION command.  Note, that we
1069          don't do this when running in reverse daemon mode (i.e. when
1070          exec the program given as arguments). */
1071 #ifndef HAVE_W32_SYSTEM
1072       if (!opt.keep_display && !argc)
1073         gnupg_unsetenv ("DISPLAY");
1074 #endif
1075
1076
1077       /* Create the sockets.  */
1078       socket_name = create_socket_name (GPG_AGENT_SOCK_NAME);
1079       fd = create_server_socket (socket_name, 0, &socket_nonce);
1080       if (opt.ssh_support)
1081         {
1082           socket_name_ssh = create_socket_name (GPG_AGENT_SSH_SOCK_NAME);
1083           fd_ssh = create_server_socket (socket_name_ssh, 1, &socket_nonce_ssh);
1084         }
1085       else
1086         fd_ssh = GNUPG_INVALID_FD;
1087
1088       /* If we are going to exec a program in the parent, we record
1089          the PID, so that the child may check whether the program is
1090          still alive. */
1091       if (argc)
1092         parent_pid = getpid ();
1093
1094       fflush (NULL);
1095 #ifdef HAVE_W32_SYSTEM
1096       (void)csh_style;
1097       (void)nodetach;
1098       pid = getpid ();
1099 #else /*!HAVE_W32_SYSTEM*/
1100       pid = fork ();
1101       if (pid == (pid_t)-1)
1102         {
1103           log_fatal ("fork failed: %s\n", strerror (errno) );
1104           exit (1);
1105         }
1106       else if (pid)
1107         { /* We are the parent */
1108           char *infostr_ssh_sock, *infostr_ssh_valid;
1109
1110           /* Close the socket FD. */
1111           close (fd);
1112
1113           /* The signal mask might not be correct right now and thus
1114              we restore it.  That is not strictly necessary but some
1115              programs falsely assume a cleared signal mask.  */
1116
1117 #ifdef HAVE_SIGPROCMASK
1118           if (startup_signal_mask_valid)
1119             {
1120               if (sigprocmask (SIG_SETMASK, &startup_signal_mask, NULL))
1121                 log_error ("error restoring signal mask: %s\n",
1122                            strerror (errno));
1123             }
1124           else
1125             log_info ("no saved signal mask\n");
1126 #endif /*HAVE_SIGPROCMASK*/
1127
1128           /* Create the SSH info string if enabled. */
1129           if (opt.ssh_support)
1130             {
1131               if (asprintf (&infostr_ssh_sock, "SSH_AUTH_SOCK=%s",
1132                             socket_name_ssh) < 0)
1133                 {
1134                   log_error ("out of core\n");
1135                   kill (pid, SIGTERM);
1136                   exit (1);
1137                 }
1138               if (asprintf (&infostr_ssh_valid, "gnupg_SSH_AUTH_SOCK_by=%lu",
1139                             (unsigned long)getpid()) < 0)
1140                 {
1141                   log_error ("out of core\n");
1142                   kill (pid, SIGTERM);
1143                   exit (1);
1144                 }
1145             }
1146
1147           *socket_name = 0; /* Don't let cleanup() remove the socket -
1148                                the child should do this from now on */
1149           if (opt.ssh_support)
1150             *socket_name_ssh = 0;
1151
1152           if (argc)
1153             { /* Run the program given on the commandline.  */
1154               if (opt.ssh_support && (putenv (infostr_ssh_sock)
1155                                       || putenv (infostr_ssh_valid)))
1156                 {
1157                   log_error ("failed to set environment: %s\n",
1158                              strerror (errno) );
1159                   kill (pid, SIGTERM );
1160                   exit (1);
1161                 }
1162
1163               /* Close all the file descriptors except the standard
1164                  ones and those open at startup.  We explicitly don't
1165                  close 0,1,2 in case something went wrong collecting
1166                  them at startup.  */
1167               close_all_fds (3, startup_fd_list);
1168
1169               /* Run the command.  */
1170               execvp (argv[0], argv);
1171               log_error ("failed to run the command: %s\n", strerror (errno));
1172               kill (pid, SIGTERM);
1173               exit (1);
1174             }
1175           else
1176             {
1177               /* Print the environment string, so that the caller can use
1178                  shell's eval to set it */
1179               if (csh_style)
1180                 {
1181                   if (opt.ssh_support)
1182                     {
1183                       *strchr (infostr_ssh_sock, '=') = ' ';
1184                       es_printf ("setenv %s;\n", infostr_ssh_sock);
1185                     }
1186                 }
1187               else
1188                 {
1189                   if (opt.ssh_support)
1190                     {
1191                       es_printf ("%s; export SSH_AUTH_SOCK;\n",
1192                                  infostr_ssh_sock);
1193                     }
1194                 }
1195               if (opt.ssh_support)
1196                 {
1197                   xfree (infostr_ssh_sock);
1198                   xfree (infostr_ssh_valid);
1199                 }
1200               exit (0);
1201             }
1202           /*NOTREACHED*/
1203         } /* End parent */
1204
1205       /*
1206          This is the child
1207        */
1208
1209       /* Detach from tty and put process into a new session */
1210       if (!nodetach )
1211         {
1212           int i;
1213           unsigned int oldflags;
1214
1215           /* Close stdin, stdout and stderr unless it is the log stream */
1216           for (i=0; i <= 2; i++)
1217             {
1218               if (!log_test_fd (i) && i != fd )
1219                 {
1220                   if ( ! close (i)
1221                        && open ("/dev/null", i? O_WRONLY : O_RDONLY) == -1)
1222                     {
1223                       log_error ("failed to open '%s': %s\n",
1224                                  "/dev/null", strerror (errno));
1225                       cleanup ();
1226                       exit (1);
1227                     }
1228                 }
1229             }
1230           if (setsid() == -1)
1231             {
1232               log_error ("setsid() failed: %s\n", strerror(errno) );
1233               cleanup ();
1234               exit (1);
1235             }
1236
1237           log_get_prefix (&oldflags);
1238           log_set_prefix (NULL, oldflags | JNLIB_LOG_RUN_DETACHED);
1239           opt.running_detached = 1;
1240         }
1241
1242       if (chdir("/"))
1243         {
1244           log_error ("chdir to / failed: %s\n", strerror (errno));
1245           exit (1);
1246         }
1247
1248       {
1249         struct sigaction sa;
1250
1251         sa.sa_handler = SIG_IGN;
1252         sigemptyset (&sa.sa_mask);
1253         sa.sa_flags = 0;
1254         sigaction (SIGPIPE, &sa, NULL);
1255       }
1256 #endif /*!HAVE_W32_SYSTEM*/
1257
1258       log_info ("%s %s started\n", strusage(11), strusage(13) );
1259       handle_connections (fd, opt.ssh_support ? fd_ssh : GNUPG_INVALID_FD);
1260       assuan_sock_close (fd);
1261     }
1262
1263   return 0;
1264 }
1265
1266
1267 /* Exit entry point.  This function should be called instead of a
1268    plain exit.  */
1269 void
1270 agent_exit (int rc)
1271 {
1272   /*FIXME: update_random_seed_file();*/
1273
1274   /* We run our cleanup handler because that may close cipher contexts
1275      stored in secure memory and thus this needs to be done before we
1276      explicitly terminate secure memory.  */
1277   cleanup ();
1278
1279 #if 1
1280   /* at this time a bit annoying */
1281   if (opt.debug & DBG_MEMSTAT_VALUE)
1282     {
1283       gcry_control( GCRYCTL_DUMP_MEMORY_STATS );
1284       gcry_control( GCRYCTL_DUMP_RANDOM_STATS );
1285     }
1286   if (opt.debug)
1287     gcry_control (GCRYCTL_DUMP_SECMEM_STATS );
1288 #endif
1289   gcry_control (GCRYCTL_TERM_SECMEM );
1290   rc = rc? rc : log_get_errorcount(0)? 2 : 0;
1291   exit (rc);
1292 }
1293
1294
1295 /* Each thread has its own local variables conveyed by a control
1296    structure usually identified by an argument named CTRL.  This
1297    function is called immediately after allocating the control
1298    structure.  Its purpose is to setup the default values for that
1299    structure.  */
1300 static void
1301 agent_init_default_ctrl (ctrl_t ctrl)
1302 {
1303   assert (ctrl->session_env);
1304
1305   /* Note we ignore malloc errors because we can't do much about it
1306      and the request will fail anyway shortly after this
1307      initialization. */
1308   session_env_setenv (ctrl->session_env, "DISPLAY", default_display);
1309   session_env_setenv (ctrl->session_env, "GPG_TTY", default_ttyname);
1310   session_env_setenv (ctrl->session_env, "TERM", default_ttytype);
1311   session_env_setenv (ctrl->session_env, "XAUTHORITY", default_xauthority);
1312   session_env_setenv (ctrl->session_env, "PINENTRY_USER_DATA", NULL);
1313
1314   if (ctrl->lc_ctype)
1315     xfree (ctrl->lc_ctype);
1316   ctrl->lc_ctype = default_lc_ctype? xtrystrdup (default_lc_ctype) : NULL;
1317
1318   if (ctrl->lc_messages)
1319     xfree (ctrl->lc_messages);
1320   ctrl->lc_messages = default_lc_messages? xtrystrdup (default_lc_messages)
1321                                     /**/ : NULL;
1322   ctrl->cache_ttl_opt_preset = CACHE_TTL_OPT_PRESET;
1323 }
1324
1325
1326 /* Release all resources allocated by default in the control
1327    structure.  This is the counterpart to agent_init_default_ctrl.  */
1328 static void
1329 agent_deinit_default_ctrl (ctrl_t ctrl)
1330 {
1331   session_env_release (ctrl->session_env);
1332
1333   if (ctrl->lc_ctype)
1334     xfree (ctrl->lc_ctype);
1335   if (ctrl->lc_messages)
1336     xfree (ctrl->lc_messages);
1337 }
1338
1339
1340 /* Reread parts of the configuration.  Note, that this function is
1341    obviously not thread-safe and should only be called from the PTH
1342    signal handler.
1343
1344    Fixme: Due to the way the argument parsing works, we create a
1345    memory leak here for all string type arguments.  There is currently
1346    no clean way to tell whether the memory for the argument has been
1347    allocated or points into the process' original arguments.  Unless
1348    we have a mechanism to tell this, we need to live on with this. */
1349 static void
1350 reread_configuration (void)
1351 {
1352   ARGPARSE_ARGS pargs;
1353   FILE *fp;
1354   unsigned int configlineno = 0;
1355   int dummy;
1356
1357   if (!config_filename)
1358     return; /* No config file. */
1359
1360   fp = fopen (config_filename, "r");
1361   if (!fp)
1362     {
1363       log_info (_("option file '%s': %s\n"),
1364                 config_filename, strerror(errno) );
1365       return;
1366     }
1367
1368   parse_rereadable_options (NULL, 1); /* Start from the default values. */
1369
1370   memset (&pargs, 0, sizeof pargs);
1371   dummy = 0;
1372   pargs.argc = &dummy;
1373   pargs.flags = 1;  /* do not remove the args */
1374   while (optfile_parse (fp, config_filename, &configlineno, &pargs, opts) )
1375     {
1376       if (pargs.r_opt < -1)
1377         pargs.err = 1; /* Print a warning. */
1378       else /* Try to parse this option - ignore unchangeable ones. */
1379         parse_rereadable_options (&pargs, 1);
1380     }
1381   fclose (fp);
1382   set_debug ();
1383 }
1384
1385
1386 /* Return the file name of the socket we are using for native
1387    requests.  */
1388 const char *
1389 get_agent_socket_name (void)
1390 {
1391   const char *s = socket_name;
1392
1393   return (s && *s)? s : NULL;
1394 }
1395
1396 /* Return the file name of the socket we are using for SSH
1397    requests.  */
1398 const char *
1399 get_agent_ssh_socket_name (void)
1400 {
1401   const char *s = socket_name_ssh;
1402
1403   return (s && *s)? s : NULL;
1404 }
1405
1406
1407 /* Under W32, this function returns the handle of the scdaemon
1408    notification event.  Calling it the first time creates that
1409    event.  */
1410 #if defined(HAVE_W32_SYSTEM) && !defined(HAVE_W32CE_SYSTEM)
1411 void *
1412 get_agent_scd_notify_event (void)
1413 {
1414   static HANDLE the_event = INVALID_HANDLE_VALUE;
1415
1416   if (the_event == INVALID_HANDLE_VALUE)
1417     {
1418       HANDLE h, h2;
1419       SECURITY_ATTRIBUTES sa = { sizeof (SECURITY_ATTRIBUTES), NULL, TRUE};
1420
1421       /* We need to use a manual reset event object due to the way our
1422          w32-pth wait function works: If we would use an automatic
1423          reset event we are not able to figure out which handle has
1424          been signaled because at the time we single out the signaled
1425          handles using WFSO the event has already been reset due to
1426          the WFMO.  */
1427       h = CreateEvent (&sa, TRUE, FALSE, NULL);
1428       if (!h)
1429         log_error ("can't create scd notify event: %s\n", w32_strerror (-1) );
1430       else if (!DuplicateHandle (GetCurrentProcess(), h,
1431                                  GetCurrentProcess(), &h2,
1432                                  EVENT_MODIFY_STATE|SYNCHRONIZE, TRUE, 0))
1433         {
1434           log_error ("setting syncronize for scd notify event failed: %s\n",
1435                      w32_strerror (-1) );
1436           CloseHandle (h);
1437         }
1438       else
1439         {
1440           CloseHandle (h);
1441           the_event = h2;
1442         }
1443     }
1444
1445   return the_event;
1446 }
1447 #endif /*HAVE_W32_SYSTEM && !HAVE_W32CE_SYSTEM*/
1448
1449
1450
1451 /* Create a name for the socket in the home directory as using
1452    STANDARD_NAME.  We also check for valid characters as well as
1453    against a maximum allowed length for a unix domain socket is done.
1454    The function terminates the process in case of an error.  Returns:
1455    Pointer to an allocated string with the absolute name of the socket
1456    used.  */
1457 static char *
1458 create_socket_name (char *standard_name)
1459 {
1460   char *name;
1461
1462   name = make_filename (opt.homedir, standard_name, NULL);
1463   if (strchr (name, PATHSEP_C))
1464     {
1465       log_error (("'%s' are not allowed in the socket name\n"), PATHSEP_S);
1466       agent_exit (2);
1467     }
1468   if (strlen (name) + 1 >= DIMof (struct sockaddr_un, sun_path) )
1469     {
1470       log_error (_("name of socket too long\n"));
1471       agent_exit (2);
1472     }
1473   return name;
1474 }
1475
1476
1477
1478 /* Create a Unix domain socket with NAME.  Returns the file descriptor
1479    or terminates the process in case of an error.  Not that this
1480    function needs to be used for the regular socket first and only
1481    then for the ssh socket.  */
1482 static gnupg_fd_t
1483 create_server_socket (char *name, int is_ssh, assuan_sock_nonce_t *nonce)
1484 {
1485   struct sockaddr_un *serv_addr;
1486   socklen_t len;
1487   gnupg_fd_t fd;
1488   int rc;
1489
1490   fd = assuan_sock_new (AF_UNIX, SOCK_STREAM, 0);
1491   if (fd == ASSUAN_INVALID_FD)
1492     {
1493       log_error (_("can't create socket: %s\n"), strerror (errno));
1494       agent_exit (2);
1495     }
1496
1497   serv_addr = xmalloc (sizeof (*serv_addr));
1498   memset (serv_addr, 0, sizeof *serv_addr);
1499   serv_addr->sun_family = AF_UNIX;
1500   if (strlen (name) + 1 >= sizeof (serv_addr->sun_path))
1501     {
1502       log_error (_("socket name '%s' is too long\n"), name);
1503       agent_exit (2);
1504     }
1505   strcpy (serv_addr->sun_path, name);
1506   len = SUN_LEN (serv_addr);
1507   rc = assuan_sock_bind (fd, (struct sockaddr*) serv_addr, len);
1508
1509   /* Our error code mapping on W32CE returns EEXIST thus we also test
1510      for this. */
1511   if (rc == -1
1512       && (errno == EADDRINUSE
1513 #ifdef HAVE_W32_SYSTEM
1514           || errno == EEXIST
1515 #endif
1516           ))
1517     {
1518       /* Check whether a gpg-agent is already running.
1519          We do this test only if this is not the ssh socket.
1520          For ssh we assume that a test for gpg-agent has already been
1521          done and reuse the requested ssh socket.  Testing the
1522          ssh-socket is not possible because at this point, though we
1523          know the new Assuan socket, the Assuan server and thus the
1524          ssh-agent server is not yet operational.  This would lead to
1525          a hang.  */
1526       if (!is_ssh && !check_for_running_agent (1))
1527         {
1528           log_set_prefix (NULL, JNLIB_LOG_WITH_PREFIX);
1529           log_set_file (NULL);
1530           log_error (_("a gpg-agent is already running - "
1531                        "not starting a new one\n"));
1532           *name = 0; /* Inhibit removal of the socket by cleanup(). */
1533           assuan_sock_close (fd);
1534           agent_exit (2);
1535         }
1536       gnupg_remove (name);
1537       rc = assuan_sock_bind (fd, (struct sockaddr*) serv_addr, len);
1538     }
1539   if (rc != -1
1540       && (rc=assuan_sock_get_nonce ((struct sockaddr*)serv_addr, len, nonce)))
1541     log_error (_("error getting nonce for the socket\n"));
1542   if (rc == -1)
1543     {
1544       /* We use gpg_strerror here because it allows us to get strings
1545          for some W32 socket error codes.  */
1546       log_error (_("error binding socket to '%s': %s\n"),
1547                  serv_addr->sun_path,
1548                  gpg_strerror (gpg_error_from_errno (errno)));
1549
1550       assuan_sock_close (fd);
1551       *name = 0; /* Inhibit removal of the socket by cleanup(). */
1552       agent_exit (2);
1553     }
1554
1555   if (listen (FD2INT(fd), 5 ) == -1)
1556     {
1557       log_error (_("listen() failed: %s\n"), strerror (errno));
1558       assuan_sock_close (fd);
1559       agent_exit (2);
1560     }
1561
1562   if (opt.verbose)
1563     log_info (_("listening on socket '%s'\n"), serv_addr->sun_path);
1564
1565   return fd;
1566 }
1567
1568
1569 /* Check that the directory for storing the private keys exists and
1570    create it if not.  This function won't fail as it is only a
1571    convenience function and not strictly necessary.  */
1572 static void
1573 create_private_keys_directory (const char *home)
1574 {
1575   char *fname;
1576   struct stat statbuf;
1577
1578   fname = make_filename (home, GNUPG_PRIVATE_KEYS_DIR, NULL);
1579   if (stat (fname, &statbuf) && errno == ENOENT)
1580     {
1581       if (gnupg_mkdir (fname, "-rwx"))
1582         log_error (_("can't create directory '%s': %s\n"),
1583                    fname, strerror (errno) );
1584       else if (!opt.quiet)
1585         log_info (_("directory '%s' created\n"), fname);
1586     }
1587   xfree (fname);
1588 }
1589
1590 /* Create the directory only if the supplied directory name is the
1591    same as the default one.  This way we avoid to create arbitrary
1592    directories when a non-default home directory is used.  To cope
1593    with HOME, we compare only the suffix if we see that the default
1594    homedir does start with a tilde.  We don't stop here in case of
1595    problems because other functions will throw an error anyway.*/
1596 static void
1597 create_directories (void)
1598 {
1599   struct stat statbuf;
1600   const char *defhome = standard_homedir ();
1601   char *home;
1602
1603   home = make_filename (opt.homedir, NULL);
1604   if ( stat (home, &statbuf) )
1605     {
1606       if (errno == ENOENT)
1607         {
1608           if (
1609 #ifdef HAVE_W32_SYSTEM
1610               ( !compare_filenames (home, defhome) )
1611 #else
1612               (*defhome == '~'
1613                 && (strlen (home) >= strlen (defhome+1)
1614                     && !strcmp (home + strlen(home)
1615                                 - strlen (defhome+1), defhome+1)))
1616                || (*defhome != '~' && !strcmp (home, defhome) )
1617 #endif
1618                )
1619             {
1620               if (gnupg_mkdir (home, "-rwx"))
1621                 log_error (_("can't create directory '%s': %s\n"),
1622                            home, strerror (errno) );
1623               else
1624                 {
1625                   if (!opt.quiet)
1626                     log_info (_("directory '%s' created\n"), home);
1627                   create_private_keys_directory (home);
1628                 }
1629             }
1630         }
1631       else
1632         log_error (_("stat() failed for '%s': %s\n"), home, strerror (errno));
1633     }
1634   else if ( !S_ISDIR(statbuf.st_mode))
1635     {
1636       log_error (_("can't use '%s' as home directory\n"), home);
1637     }
1638   else /* exists and is a directory. */
1639     {
1640       create_private_keys_directory (home);
1641     }
1642   xfree (home);
1643 }
1644
1645
1646
1647 /* This is the worker for the ticker.  It is called every few seconds
1648    and may only do fast operations. */
1649 static void
1650 handle_tick (void)
1651 {
1652   static time_t last_minute;
1653
1654   if (!last_minute)
1655     last_minute = time (NULL);
1656
1657   /* Check whether the scdaemon has died and cleanup in this case. */
1658   agent_scd_check_aliveness ();
1659
1660   /* If we are running as a child of another process, check whether
1661      the parent is still alive and shutdown if not. */
1662 #ifndef HAVE_W32_SYSTEM
1663   if (parent_pid != (pid_t)(-1))
1664     {
1665       if (kill (parent_pid, 0))
1666         {
1667           shutdown_pending = 2;
1668           log_info ("parent process died - shutting down\n");
1669           log_info ("%s %s stopped\n", strusage(11), strusage(13) );
1670           cleanup ();
1671           agent_exit (0);
1672         }
1673     }
1674 #endif /*HAVE_W32_SYSTEM*/
1675
1676   /* Code to be run from time to time.  */
1677 #if CHECK_OWN_SOCKET_INTERVAL > 0
1678   if (last_minute + CHECK_OWN_SOCKET_INTERVAL <= time (NULL))
1679     {
1680       check_own_socket ();
1681       last_minute = time (NULL);
1682     }
1683 #endif
1684
1685 }
1686
1687
1688 /* A global function which allows us to call the reload stuff from
1689    other places too.  This is only used when build for W32.  */
1690 void
1691 agent_sighup_action (void)
1692 {
1693   log_info ("SIGHUP received - "
1694             "re-reading configuration and flushing cache\n");
1695   agent_flush_cache ();
1696   reread_configuration ();
1697   agent_reload_trustlist ();
1698 }
1699
1700
1701 /* A helper function to handle SIGUSR2.  */
1702 static void
1703 agent_sigusr2_action (void)
1704 {
1705   if (opt.verbose)
1706     log_info ("SIGUSR2 received - updating card event counter\n");
1707   /* Nothing to check right now.  We only increment a counter.  */
1708   bump_card_eventcounter ();
1709 }
1710
1711
1712 #ifndef HAVE_W32_SYSTEM
1713 /* The signal handler for this program.  It is expected to be run in
1714    its own trhead and not in the context of a signal handler.  */
1715 static void
1716 handle_signal (int signo)
1717 {
1718   switch (signo)
1719     {
1720 #ifndef HAVE_W32_SYSTEM
1721     case SIGHUP:
1722       agent_sighup_action ();
1723       break;
1724
1725     case SIGUSR1:
1726       log_info ("SIGUSR1 received - printing internal information:\n");
1727       /* Fixme: We need to see how to integrate pth dumping into our
1728          logging system.  */
1729       /* pth_ctrl (PTH_CTRL_DUMPSTATE, log_get_stream ()); */
1730       agent_query_dump_state ();
1731       agent_scd_dump_state ();
1732       break;
1733
1734     case SIGUSR2:
1735       agent_sigusr2_action ();
1736       break;
1737
1738     case SIGTERM:
1739       if (!shutdown_pending)
1740         log_info ("SIGTERM received - shutting down ...\n");
1741       else
1742         log_info ("SIGTERM received - still %i open connections\n",
1743                   active_connections);
1744       shutdown_pending++;
1745       if (shutdown_pending > 2)
1746         {
1747           log_info ("shutdown forced\n");
1748           log_info ("%s %s stopped\n", strusage(11), strusage(13) );
1749           cleanup ();
1750           agent_exit (0);
1751         }
1752       break;
1753
1754     case SIGINT:
1755       log_info ("SIGINT received - immediate shutdown\n");
1756       log_info( "%s %s stopped\n", strusage(11), strusage(13));
1757       cleanup ();
1758       agent_exit (0);
1759       break;
1760 #endif
1761     default:
1762       log_info ("signal %d received - no action defined\n", signo);
1763     }
1764 }
1765 #endif
1766
1767 /* Check the nonce on a new connection.  This is a NOP unless we we
1768    are using our Unix domain socket emulation under Windows.  */
1769 static int
1770 check_nonce (ctrl_t ctrl, assuan_sock_nonce_t *nonce)
1771 {
1772   if (assuan_sock_check_nonce (ctrl->thread_startup.fd, nonce))
1773     {
1774       log_info (_("error reading nonce on fd %d: %s\n"),
1775                 FD2INT(ctrl->thread_startup.fd), strerror (errno));
1776       assuan_sock_close (ctrl->thread_startup.fd);
1777       xfree (ctrl);
1778       return -1;
1779     }
1780   else
1781     return 0;
1782 }
1783
1784
1785 #ifdef HAVE_W32_SYSTEM
1786 /* The window message processing function for Putty.  Warning: This
1787    code runs as a native Windows thread.  Use of our own functions
1788    needs to be bracket with pth_leave/pth_enter. */
1789 static LRESULT CALLBACK
1790 putty_message_proc (HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)
1791 {
1792   int ret = 0;
1793   int w32rc;
1794   COPYDATASTRUCT *cds;
1795   const char *mapfile;
1796   HANDLE maphd;
1797   PSID mysid = NULL;
1798   PSID mapsid = NULL;
1799   void *data = NULL;
1800   PSECURITY_DESCRIPTOR psd = NULL;
1801   ctrl_t ctrl = NULL;
1802
1803   if (msg != WM_COPYDATA)
1804     {
1805       return DefWindowProc (hwnd, msg, wparam, lparam);
1806     }
1807
1808   cds = (COPYDATASTRUCT*)lparam;
1809   if (cds->dwData != PUTTY_IPC_MAGIC)
1810     return 0;  /* Ignore data with the wrong magic.  */
1811   mapfile = cds->lpData;
1812   if (!cds->cbData || mapfile[cds->cbData - 1])
1813     return 0;  /* Ignore empty and non-properly terminated strings.  */
1814
1815   if (DBG_ASSUAN)
1816     {
1817       npth_protect ();
1818       log_debug ("ssh map file '%s'", mapfile);
1819       npth_unprotect ();
1820     }
1821
1822   maphd = OpenFileMapping (FILE_MAP_ALL_ACCESS, FALSE, mapfile);
1823   if (DBG_ASSUAN)
1824     {
1825       npth_protect ();
1826       log_debug ("ssh map handle %p\n", maphd);
1827       npth_unprotect ();
1828     }
1829
1830   if (!maphd || maphd == INVALID_HANDLE_VALUE)
1831     return 0;
1832
1833   npth_protect ();
1834
1835   mysid = w32_get_user_sid ();
1836   if (!mysid)
1837     {
1838       log_error ("error getting my sid\n");
1839       goto leave;
1840     }
1841
1842   w32rc = GetSecurityInfo (maphd, SE_KERNEL_OBJECT,
1843                            OWNER_SECURITY_INFORMATION,
1844                            &mapsid, NULL, NULL, NULL,
1845                            &psd);
1846   if (w32rc)
1847     {
1848       log_error ("error getting sid of ssh map file: rc=%d", w32rc);
1849       goto leave;
1850     }
1851
1852   if (DBG_ASSUAN)
1853     {
1854       char *sidstr;
1855
1856       if (!ConvertSidToStringSid (mysid, &sidstr))
1857         sidstr = NULL;
1858       log_debug ("          my sid: '%s'", sidstr? sidstr: "[error]");
1859       LocalFree (sidstr);
1860       if (!ConvertSidToStringSid (mapsid, &sidstr))
1861         sidstr = NULL;
1862       log_debug ("ssh map file sid: '%s'", sidstr? sidstr: "[error]");
1863       LocalFree (sidstr);
1864     }
1865
1866   if (!EqualSid (mysid, mapsid))
1867     {
1868       log_error ("ssh map file has a non-matching sid\n");
1869       goto leave;
1870     }
1871
1872   data = MapViewOfFile (maphd, FILE_MAP_ALL_ACCESS, 0, 0, 0);
1873   if (DBG_ASSUAN)
1874     log_debug ("ssh IPC buffer at %p\n", data);
1875   if (!data)
1876     goto leave;
1877
1878   /* log_printhex ("request:", data, 20); */
1879
1880   ctrl = xtrycalloc (1, sizeof *ctrl);
1881   if (!ctrl)
1882     {
1883       log_error ("error allocating connection control data: %s\n",
1884                  strerror (errno) );
1885       goto leave;
1886     }
1887   ctrl->session_env = session_env_new ();
1888   if (!ctrl->session_env)
1889     {
1890       log_error ("error allocating session environment block: %s\n",
1891                  strerror (errno) );
1892       goto leave;
1893     }
1894
1895   agent_init_default_ctrl (ctrl);
1896   if (!serve_mmapped_ssh_request (ctrl, data, PUTTY_IPC_MAXLEN))
1897     ret = 1; /* Valid ssh message has been constructed.  */
1898   agent_deinit_default_ctrl (ctrl);
1899   /* log_printhex ("  reply:", data, 20); */
1900
1901  leave:
1902   xfree (ctrl);
1903   if (data)
1904     UnmapViewOfFile (data);
1905   xfree (mapsid);
1906   if (psd)
1907     LocalFree (psd);
1908   xfree (mysid);
1909   CloseHandle (maphd);
1910
1911   npth_unprotect ();
1912
1913   return ret;
1914 }
1915 #endif /*HAVE_W32_SYSTEM*/
1916
1917
1918 #ifdef HAVE_W32_SYSTEM
1919 /* The thread handling Putty's IPC requests.  */
1920 static void *
1921 putty_message_thread (void *arg)
1922 {
1923   WNDCLASS wndwclass = {0, putty_message_proc, 0, 0,
1924                         NULL, NULL, NULL, NULL, NULL, "Pageant"};
1925   HWND hwnd;
1926   MSG msg;
1927
1928   (void)arg;
1929
1930   if (opt.verbose)
1931     log_info ("putty message loop thread started\n");
1932
1933   /* The message loop runs as thread independent from our nPth system.
1934      This also means that we need to make sure that we switch back to
1935      our system before calling any no-windows function.  */
1936   npth_unprotect ();
1937
1938   /* First create a window to make sure that a message queue exists
1939      for this thread.  */
1940   if (!RegisterClass (&wndwclass))
1941     {
1942       npth_protect ();
1943       log_error ("error registering Pageant window class");
1944       return NULL;
1945     }
1946   hwnd = CreateWindowEx (0, "Pageant", "Pageant", 0,
1947                          0, 0, 0, 0,
1948                          HWND_MESSAGE,  /* hWndParent */
1949                          NULL,          /* hWndMenu   */
1950                          NULL,          /* hInstance  */
1951                          NULL);         /* lpParm     */
1952   if (!hwnd)
1953     {
1954       npth_protect ();
1955       log_error ("error creating Pageant window");
1956       return NULL;
1957     }
1958
1959   while (GetMessage(&msg, NULL, 0, 0))
1960     {
1961       TranslateMessage(&msg);
1962       DispatchMessage(&msg);
1963     }
1964
1965   /* Back to nPth.  */
1966   npth_protect ();
1967
1968   if (opt.verbose)
1969     log_info ("putty message loop thread stopped\n");
1970   return NULL;
1971 }
1972 #endif /*HAVE_W32_SYSTEM*/
1973
1974
1975 /* This is the standard connection thread's main function.  */
1976 static void *
1977 start_connection_thread (void *arg)
1978 {
1979   ctrl_t ctrl = arg;
1980
1981   if (check_nonce (ctrl, &socket_nonce))
1982     {
1983       log_error ("handler 0x%lx nonce check FAILED\n",
1984                  (unsigned long) npth_self());
1985       return NULL;
1986     }
1987
1988   agent_init_default_ctrl (ctrl);
1989   if (opt.verbose)
1990     log_info (_("handler 0x%lx for fd %d started\n"),
1991               (unsigned long) npth_self(), FD2INT(ctrl->thread_startup.fd));
1992
1993   start_command_handler (ctrl, GNUPG_INVALID_FD, ctrl->thread_startup.fd);
1994   if (opt.verbose)
1995     log_info (_("handler 0x%lx for fd %d terminated\n"),
1996               (unsigned long) npth_self(), FD2INT(ctrl->thread_startup.fd));
1997
1998   agent_deinit_default_ctrl (ctrl);
1999   xfree (ctrl);
2000   return NULL;
2001 }
2002
2003
2004 /* This is the ssh connection thread's main function.  */
2005 static void *
2006 start_connection_thread_ssh (void *arg)
2007 {
2008   ctrl_t ctrl = arg;
2009
2010   if (check_nonce (ctrl, &socket_nonce_ssh))
2011     return NULL;
2012
2013   agent_init_default_ctrl (ctrl);
2014   if (opt.verbose)
2015     log_info (_("ssh handler 0x%lx for fd %d started\n"),
2016               (unsigned long) npth_self(), FD2INT(ctrl->thread_startup.fd));
2017
2018   start_command_handler_ssh (ctrl, ctrl->thread_startup.fd);
2019   if (opt.verbose)
2020     log_info (_("ssh handler 0x%lx for fd %d terminated\n"),
2021               (unsigned long) npth_self(), FD2INT(ctrl->thread_startup.fd));
2022
2023   agent_deinit_default_ctrl (ctrl);
2024   xfree (ctrl);
2025   return NULL;
2026 }
2027
2028
2029 /* Connection handler loop.  Wait for connection requests and spawn a
2030    thread after accepting a connection.  */
2031 static void
2032 handle_connections (gnupg_fd_t listen_fd, gnupg_fd_t listen_fd_ssh)
2033 {
2034   npth_attr_t tattr;
2035   struct sockaddr_un paddr;
2036   socklen_t plen;
2037   fd_set fdset, read_fdset;
2038   int ret;
2039   gnupg_fd_t fd;
2040   int nfd;
2041   int saved_errno;
2042   struct timespec abstime;
2043   struct timespec curtime;
2044   struct timespec timeout;
2045 #ifdef HAVE_W32_SYSTEM
2046   HANDLE events[2];
2047   unsigned int events_set;
2048 #endif
2049
2050   ret = npth_attr_init(&tattr);
2051   if (ret)
2052     log_fatal ("error allocating thread attributes: %s\n",
2053                strerror (ret));
2054   npth_attr_setdetachstate (&tattr, NPTH_CREATE_DETACHED);
2055
2056 #ifndef HAVE_W32_SYSTEM
2057   npth_sigev_init ();
2058   npth_sigev_add (SIGHUP);
2059   npth_sigev_add (SIGUSR1);
2060   npth_sigev_add (SIGUSR2);
2061   npth_sigev_add (SIGINT);
2062   npth_sigev_add (SIGTERM);
2063   npth_sigev_fini ();
2064 #else
2065 # ifdef HAVE_W32CE_SYSTEM
2066   /* Use a dummy event. */
2067   sigs = 0;
2068   ev = pth_event (PTH_EVENT_SIGS, &sigs, &signo);
2069 # else
2070   events[0] = get_agent_scd_notify_event ();
2071   events[1] = INVALID_HANDLE_VALUE;
2072 # endif
2073 #endif
2074
2075   /* On Windows we need to fire up a separate thread to listen for
2076      requests from Putty (an SSH client), so we can replace Putty's
2077      Pageant (its ssh-agent implementation). */
2078 #ifdef HAVE_W32_SYSTEM
2079   if (putty_support)
2080     {
2081       npth_t thread;
2082
2083       ret = npth_create (&thread, &tattr, putty_message_thread, NULL);
2084       if (ret)
2085         {
2086           log_error ("error spawning putty message loop: %s\n", strerror (ret));
2087         }
2088     }
2089 #endif /*HAVE_W32_SYSTEM*/
2090
2091   /* Set a flag to tell call-scd.c that it may enable event
2092      notifications.  */
2093   opt.sigusr2_enabled = 1;
2094
2095   FD_ZERO (&fdset);
2096   FD_SET (FD2INT (listen_fd), &fdset);
2097   nfd = FD2INT (listen_fd);
2098   if (listen_fd_ssh != GNUPG_INVALID_FD)
2099     {
2100       FD_SET ( FD2INT(listen_fd_ssh), &fdset);
2101       if (FD2INT (listen_fd_ssh) > nfd)
2102         nfd = FD2INT (listen_fd_ssh);
2103     }
2104
2105   npth_clock_gettime (&abstime);
2106   abstime.tv_sec += TIMERTICK_INTERVAL;
2107
2108   for (;;)
2109     {
2110       /* Shutdown test.  */
2111       if (shutdown_pending)
2112         {
2113           if (active_connections == 0)
2114             break; /* ready */
2115
2116           /* Do not accept new connections but keep on running the
2117              loop to cope with the timer events.  */
2118           FD_ZERO (&fdset);
2119         }
2120
2121       /* POSIX says that fd_set should be implemented as a structure,
2122          thus a simple assignment is fine to copy the entire set.  */
2123       read_fdset = fdset;
2124
2125       npth_clock_gettime (&curtime);
2126       if (!(npth_timercmp (&curtime, &abstime, <)))
2127         {
2128           /* Timeout.  */
2129           handle_tick ();
2130           npth_clock_gettime (&abstime);
2131           abstime.tv_sec += TIMERTICK_INTERVAL;
2132         }
2133       npth_timersub (&abstime, &curtime, &timeout);
2134
2135 #ifndef HAVE_W32_SYSTEM
2136       ret = npth_pselect (nfd+1, &read_fdset, NULL, NULL, &timeout,
2137                           npth_sigev_sigmask ());
2138       saved_errno = errno;
2139
2140       {
2141         int signo;
2142         while (npth_sigev_get_pending (&signo))
2143           handle_signal (signo);
2144       }
2145 #else
2146       ret = npth_eselect (nfd+1, &read_fdset, NULL, NULL, &timeout,
2147                           events, &events_set);
2148       saved_errno = errno;
2149
2150       /* This is valid even if npth_eselect returns an error.  */
2151       if (events_set & 1)
2152         agent_sigusr2_action ();
2153 #endif
2154
2155       if (ret == -1 && saved_errno != EINTR)
2156         {
2157           log_error (_("npth_pselect failed: %s - waiting 1s\n"),
2158                      strerror (saved_errno));
2159           npth_sleep (1);
2160           continue;
2161         }
2162       if (ret <= 0)
2163         /* Interrupt or timeout.  Will be handled when calculating the
2164            next timeout.  */
2165         continue;
2166
2167       if (!shutdown_pending && FD_ISSET (FD2INT (listen_fd), &read_fdset))
2168         {
2169           ctrl_t ctrl;
2170
2171           plen = sizeof paddr;
2172           fd = INT2FD (npth_accept (FD2INT(listen_fd),
2173                                     (struct sockaddr *)&paddr, &plen));
2174           if (fd == GNUPG_INVALID_FD)
2175             {
2176               log_error ("accept failed: %s\n", strerror (errno));
2177             }
2178           else if ( !(ctrl = xtrycalloc (1, sizeof *ctrl)) )
2179             {
2180               log_error ("error allocating connection control data: %s\n",
2181                          strerror (errno) );
2182               assuan_sock_close (fd);
2183             }
2184           else if ( !(ctrl->session_env = session_env_new ()) )
2185             {
2186               log_error ("error allocating session environment block: %s\n",
2187                          strerror (errno) );
2188               xfree (ctrl);
2189               assuan_sock_close (fd);
2190             }
2191           else
2192             {
2193               npth_t thread;
2194
2195               ctrl->thread_startup.fd = fd;
2196               ret = npth_create (&thread, &tattr,
2197                                  start_connection_thread, ctrl);
2198               if (ret)
2199                 {
2200                   log_error ("error spawning connection handler: %s\n",
2201                              strerror (ret));
2202                   assuan_sock_close (fd);
2203                   xfree (ctrl);
2204                 }
2205
2206             }
2207           fd = GNUPG_INVALID_FD;
2208         }
2209
2210       if (!shutdown_pending && listen_fd_ssh != GNUPG_INVALID_FD
2211           && FD_ISSET ( FD2INT (listen_fd_ssh), &read_fdset))
2212         {
2213           ctrl_t ctrl;
2214
2215           plen = sizeof paddr;
2216           fd = INT2FD(npth_accept (FD2INT(listen_fd_ssh),
2217                                    (struct sockaddr *)&paddr, &plen));
2218           if (fd == GNUPG_INVALID_FD)
2219             {
2220               log_error ("accept failed for ssh: %s\n", strerror (errno));
2221             }
2222           else if ( !(ctrl = xtrycalloc (1, sizeof *ctrl)) )
2223             {
2224               log_error ("error allocating connection control data: %s\n",
2225                          strerror (errno) );
2226               assuan_sock_close (fd);
2227             }
2228           else if ( !(ctrl->session_env = session_env_new ()) )
2229             {
2230               log_error ("error allocating session environment block: %s\n",
2231                          strerror (errno) );
2232               xfree (ctrl);
2233               assuan_sock_close (fd);
2234             }
2235           else
2236             {
2237               npth_t thread;
2238
2239               agent_init_default_ctrl (ctrl);
2240               ctrl->thread_startup.fd = fd;
2241               ret = npth_create (&thread, &tattr,
2242                                  start_connection_thread_ssh, ctrl);
2243               if (ret)
2244                 {
2245                   log_error ("error spawning ssh connection handler: %s\n",
2246                              strerror (ret));
2247                   assuan_sock_close (fd);
2248                   xfree (ctrl);
2249                 }
2250             }
2251           fd = GNUPG_INVALID_FD;
2252         }
2253     }
2254
2255   cleanup ();
2256   log_info (_("%s %s stopped\n"), strusage(11), strusage(13));
2257   npth_attr_destroy (&tattr);
2258 }
2259
2260
2261
2262 /* Helper for check_own_socket.  */
2263 static gpg_error_t
2264 check_own_socket_pid_cb (void *opaque, const void *buffer, size_t length)
2265 {
2266   membuf_t *mb = opaque;
2267   put_membuf (mb, buffer, length);
2268   return 0;
2269 }
2270
2271
2272 /* The thread running the actual check.  We need to run this in a
2273    separate thread so that check_own_thread can be called from the
2274    timer tick.  */
2275 static void *
2276 check_own_socket_thread (void *arg)
2277 {
2278   int rc;
2279   char *sockname = arg;
2280   assuan_context_t ctx = NULL;
2281   membuf_t mb;
2282   char *buffer;
2283
2284   check_own_socket_running++;
2285
2286   rc = assuan_new (&ctx);
2287   if (rc)
2288     {
2289       log_error ("can't allocate assuan context: %s\n", gpg_strerror (rc));
2290       goto leave;
2291     }
2292
2293   rc = assuan_socket_connect (ctx, sockname, (pid_t)(-1), 0);
2294   if (rc)
2295     {
2296       log_error ("can't connect my own socket: %s\n", gpg_strerror (rc));
2297       goto leave;
2298     }
2299
2300   init_membuf (&mb, 100);
2301   rc = assuan_transact (ctx, "GETINFO pid", check_own_socket_pid_cb, &mb,
2302                         NULL, NULL, NULL, NULL);
2303   put_membuf (&mb, "", 1);
2304   buffer = get_membuf (&mb, NULL);
2305   if (rc || !buffer)
2306     {
2307       log_error ("sending command \"%s\" to my own socket failed: %s\n",
2308                  "GETINFO pid", gpg_strerror (rc));
2309       rc = 1;
2310     }
2311   else if ( (pid_t)strtoul (buffer, NULL, 10) != getpid ())
2312     {
2313       log_error ("socket is now serviced by another server\n");
2314       rc = 1;
2315     }
2316   else if (opt.verbose > 1)
2317     log_error ("socket is still served by this server\n");
2318
2319   xfree (buffer);
2320
2321  leave:
2322   xfree (sockname);
2323   if (ctx)
2324     assuan_release (ctx);
2325   if (rc)
2326     {
2327       /* We may not remove the socket as it is now in use by another
2328          server.  Setting the name to empty does this.  */
2329       if (socket_name)
2330         *socket_name = 0;
2331       if (socket_name_ssh)
2332         *socket_name_ssh = 0;
2333       shutdown_pending = 2;
2334       log_info ("this process is useless - shutting down\n");
2335     }
2336   check_own_socket_running--;
2337   return NULL;
2338 }
2339
2340
2341 /* Check whether we are still listening on our own socket.  In case
2342    another gpg-agent process started after us has taken ownership of
2343    our socket, we would linger around without any real task.  Thus we
2344    better check once in a while whether we are really needed.  */
2345 static void
2346 check_own_socket (void)
2347 {
2348   char *sockname;
2349   npth_t thread;
2350   npth_attr_t tattr;
2351   int err;
2352
2353   if (disable_check_own_socket)
2354     return;
2355
2356   if (check_own_socket_running || shutdown_pending)
2357     return;  /* Still running or already shutting down.  */
2358
2359   sockname = make_filename (opt.homedir, GPG_AGENT_SOCK_NAME, NULL);
2360   if (!sockname)
2361     return; /* Out of memory.  */
2362
2363   err = npth_attr_init (&tattr);
2364   if (err)
2365     return;
2366   npth_attr_setdetachstate (&tattr, NPTH_CREATE_DETACHED);
2367   err = npth_create (&thread, &tattr, check_own_socket_thread, sockname);
2368   if (err)
2369     log_error ("error spawning check_own_socket_thread: %s\n", strerror (err));
2370   npth_attr_destroy (&tattr);
2371 }
2372
2373
2374
2375 /* Figure out whether an agent is available and running. Prints an
2376    error if not.  If SILENT is true, no messages are printed.
2377    Returns 0 if the agent is running. */
2378 static int
2379 check_for_running_agent (int silent)
2380 {
2381   gpg_error_t err;
2382   char *sockname;
2383   assuan_context_t ctx = NULL;
2384
2385   sockname = make_filename (opt.homedir, GPG_AGENT_SOCK_NAME, NULL);
2386
2387   err = assuan_new (&ctx);
2388   if (!err)
2389     err = assuan_socket_connect (ctx, sockname, (pid_t)(-1), 0);
2390   xfree (sockname);
2391   if (err)
2392     {
2393       if (!silent)
2394         log_error (_("no gpg-agent running in this session\n"));
2395
2396       if (ctx)
2397         assuan_release (ctx);
2398       return -1;
2399     }
2400
2401   if (!opt.quiet && !silent)
2402     log_info ("gpg-agent running and available\n");
2403
2404   assuan_release (ctx);
2405   return 0;
2406 }