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