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