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