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