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