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