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