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