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