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