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