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