* gpg-agent.c (main): Tell the logging code taht we are runnign
[gnupg.git] / agent / gpg-agent.c
1 /* gpg-agent.c  -  The GnuPG Agent
2  *      Copyright (C) 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
3  *
4  * This file is part of GnuPG.
5  *
6  * GnuPG is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * GnuPG is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
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/socket.h>
33 #include <sys/un.h>
34 #include <unistd.h>
35 #include <signal.h>
36 #ifdef USE_GNU_PTH
37 # include <pth.h>
38 #endif
39
40 #define JNLIB_NEED_LOG_LOGV
41 #include "agent.h"
42 #include <assuan.h> /* malloc hooks */
43
44 #include "i18n.h"
45 #include "sysutils.h"
46
47
48 enum cmd_and_opt_values 
49 { aNull = 0,
50   oCsh            = 'c',
51   oQuiet          = 'q',
52   oSh             = 's',
53   oVerbose        = 'v',
54
55   oNoVerbose = 500,
56   aGPGConfList,
57   oOptions,
58   oDebug,
59   oDebugAll,
60   oDebugLevel,
61   oDebugWait,
62   oNoGreeting,
63   oNoOptions,
64   oHomedir,
65   oNoDetach,
66   oNoGrab,
67   oLogFile,
68   oServer,
69   oDaemon,
70   oBatch,
71
72   oPinentryProgram,
73   oDisplay,
74   oTTYname,
75   oTTYtype,
76   oLCctype,
77   oLCmessages,
78   oScdaemonProgram,
79   oDefCacheTTL,
80   oDisablePth,
81
82   oIgnoreCacheForSigning,
83   oKeepTTY,
84   oKeepDISPLAY,
85
86 aTest };
87
88
89
90 static ARGPARSE_OPTS opts[] = {
91
92   { aGPGConfList, "gpgconf-list", 256, "@" },
93   
94   { 301, NULL, 0, N_("@Options:\n ") },
95
96   { oServer,   "server",     0, N_("run in server mode (foreground)") },
97   { oDaemon,   "daemon",     0, N_("run in daemon mode (background)") },
98   { oVerbose, "verbose",     0, N_("verbose") },
99   { oQuiet,     "quiet",     0, N_("be somewhat more quiet") },
100   { oSh,        "sh",        0, N_("sh-style command output") },
101   { oCsh,       "csh",       0, N_("csh-style command output") },
102   { oOptions, "options"  , 2, N_("|FILE|read options from FILE")},
103   { oDebug,     "debug"     ,4|16, "@"},
104   { oDebugAll, "debug-all"     ,0, "@"},
105   { oDebugLevel, "debug-level" ,2, "@"},
106   { oDebugWait,"debug-wait",1, "@"},
107   { oNoDetach, "no-detach" ,0, N_("do not detach from the console")},
108   { oNoGrab, "no-grab"     ,0, N_("do not grab keyboard and mouse")},
109   { oLogFile, "log-file"   ,2, N_("use a log file for the server")},
110   { oDisablePth, "disable-pth", 0, N_("do not allow multiple connections")},
111
112   { oPinentryProgram, "pinentry-program", 2 , "path to PIN Entry program" },
113   { oDisplay,    "display",     2, "set the display" },
114   { oTTYname,    "ttyname",     2, "set the tty terminal node name" },
115   { oTTYtype,    "ttytype",     2, "set the tty terminal type" },
116   { oLCctype,    "lc-ctype",    2, "set the tty LC_CTYPE value" },
117   { oLCmessages, "lc-messages", 2, "set the tty LC_MESSAGES value" },
118
119   { oScdaemonProgram, "scdaemon-program", 2 , "path to SCdaemon program" },
120   { oDefCacheTTL, "default-cache-ttl", 4,
121                                  "|N|expire cached PINs after N seconds"},
122   { oIgnoreCacheForSigning, "ignore-cache-for-signing", 0,
123                                  "do not use the PIN cache when signing"},
124   { oKeepTTY, "keep-tty", 0,  N_("ignore requests to change the TTY")},
125   { oKeepDISPLAY, "keep-display",
126                           0, N_("ignore requests to change the X display")},
127   {0}
128 };
129
130
131 #define DEFAULT_CACHE_TTL (10*60) /* 10 minutes */
132
133 static volatile int caught_fatal_sig = 0;
134
135 /* flag to indicate that a shutdown was requested */
136 static int shutdown_pending;
137
138
139 /* It is possible that we are currently running under setuid permissions */
140 static int maybe_setuid = 1;
141
142 /* Name of the communication socket */
143 static char socket_name[128];
144
145 /* Default values for options passed to the pinentry. */
146 static char *default_display;
147 static char *default_ttyname;
148 static char *default_ttytype;
149 static char *default_lc_ctype;
150 static char *default_lc_messages;
151
152 /* Name of a config file, which will be reread on a HUP if it is not NULL. */
153 static char *config_filename;
154
155 /* Helper to implement --debug-level */
156 static const char *debug_level;
157
158 /* Local prototypes. */
159 static void create_directories (void);
160 #ifdef USE_GNU_PTH
161 static void handle_connections (int listen_fd);
162
163 /* Pth wrapper function definitions. */
164 GCRY_THREAD_OPTION_PTH_IMPL;
165
166 #endif /*USE_GNU_PTH*/
167
168
169
170 static const char *
171 my_strusage (int level)
172 {
173   const char *p;
174   switch (level)
175     {
176     case 11: p = "gpg-agent (GnuPG)";
177       break;
178     case 13: p = VERSION; break;
179     case 17: p = PRINTABLE_OS_NAME; break;
180     case 19: p = _("Please report bugs to <" PACKAGE_BUGREPORT ">.\n");
181       break;
182     case 1:
183     case 40: p =  _("Usage: gpg-agent [options] (-h for help)");
184       break;
185     case 41: p =  _("Syntax: gpg-agent [options] [command [args]]\n"
186                     "Secret key management for GnuPG\n");
187     break;
188     
189     default: p = NULL;
190     }
191   return p;
192 }
193
194
195
196 static void
197 i18n_init (void)
198 {
199 #ifdef USE_SIMPLE_GETTEXT
200     set_gettext_file( PACKAGE_GT );
201 #else
202 #ifdef ENABLE_NLS
203     setlocale (LC_ALL, "");
204     bindtextdomain (PACKAGE_GT, LOCALEDIR);
205     textdomain (PACKAGE_GT);
206 #endif
207 #endif
208 }
209
210
211
212 /* Used by gcry for logging */
213 static void
214 my_gcry_logger (void *dummy, int level, const char *fmt, va_list arg_ptr)
215 {
216   /* translate the log levels */
217   switch (level)
218     {
219     case GCRY_LOG_CONT: level = JNLIB_LOG_CONT; break;
220     case GCRY_LOG_INFO: level = JNLIB_LOG_INFO; break;
221     case GCRY_LOG_WARN: level = JNLIB_LOG_WARN; break;
222     case GCRY_LOG_ERROR:level = JNLIB_LOG_ERROR; break;
223     case GCRY_LOG_FATAL:level = JNLIB_LOG_FATAL; break;
224     case GCRY_LOG_BUG:  level = JNLIB_LOG_BUG; break;
225     case GCRY_LOG_DEBUG:level = JNLIB_LOG_DEBUG; break;
226     default:            level = JNLIB_LOG_ERROR; break;  
227     }
228   log_logv (level, fmt, arg_ptr);
229 }
230
231
232 /* Setup the debugging.  With a LEVEL of NULL only the active debug
233    flags are propagated to the subsystems.  With LEVEL set, a specific
234    set of debug flags is set; thus overriding all flags already
235    set. Note that we don't fail here, because it is important to keep
236    gpg-agent running even after re-reading the options due to a
237    SIGHUP. */
238 static void
239 set_debug (void)
240 {
241   if (!debug_level)
242     ;
243   else if (!strcmp (debug_level, "none"))
244     opt.debug = 0;
245   else if (!strcmp (debug_level, "basic"))
246     opt.debug = DBG_ASSUAN_VALUE;
247   else if (!strcmp (debug_level, "advanced"))
248     opt.debug = DBG_ASSUAN_VALUE|DBG_COMMAND_VALUE;
249   else if (!strcmp (debug_level, "expert"))
250     opt.debug = (DBG_ASSUAN_VALUE|DBG_COMMAND_VALUE
251                  |DBG_CACHE_VALUE);
252   else if (!strcmp (debug_level, "guru"))
253     opt.debug = ~0;
254   else
255     {
256       log_error (_("invalid debug-level `%s' given\n"), debug_level);
257       opt.debug = 0; /* Reset debugging, so that prior debug
258                         statements won't have an undesired effect. */
259     }
260
261   if (opt.debug && !opt.verbose)
262     opt.verbose = 1;
263   if (opt.debug && opt.quiet)
264     opt.quiet = 0;
265
266   if (opt.debug & DBG_MPI_VALUE)
267     gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 2);
268   if (opt.debug & DBG_CRYPTO_VALUE )
269     gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 1);
270   gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
271 }
272  
273
274 static void
275 cleanup (void)
276 {
277   if (*socket_name)
278     {
279       char *p;
280
281       remove (socket_name);
282       p = strrchr (socket_name, '/');
283       if (p)
284         {
285           *p = 0;
286           rmdir (socket_name);
287           *p = '/';
288         }
289       *socket_name = 0;
290     }
291 }
292
293
294 static RETSIGTYPE
295 cleanup_sh (int sig)
296 {
297   if (caught_fatal_sig)
298     raise (sig);
299   caught_fatal_sig = 1;
300
301   /* gcry_control( GCRYCTL_TERM_SECMEM );*/
302   cleanup ();
303
304 #ifndef HAVE_DOSISH_SYSTEM
305   {     /* reset action to default action and raise signal again */
306     struct sigaction nact;
307     nact.sa_handler = SIG_DFL;
308     sigemptyset( &nact.sa_mask );
309     nact.sa_flags = 0;
310     sigaction( sig, &nact, NULL);
311   }
312 #endif
313   raise( sig );
314 }
315
316
317 /* Handle options which are allowed to be reset after program start.
318    Return true when the current option in PARGS could be handled and
319    false if not.  As a special feature, passing a value of NULL for
320    PARGS, resets the options to the default. */
321 static int
322 parse_rereadable_options (ARGPARSE_ARGS *pargs)
323 {
324   if (!pargs)
325     { /* reset mode */
326       opt.quiet = 0;
327       opt.verbose = 0;
328       opt.debug = 0;
329       opt.no_grab = 0;
330       opt.pinentry_program = NULL;
331       opt.scdaemon_program = NULL;
332       opt.def_cache_ttl = DEFAULT_CACHE_TTL;
333       opt.ignore_cache_for_signing = 0;
334       return 1;
335     }
336
337   switch (pargs->r_opt)
338     {
339     case oQuiet: opt.quiet = 1; break;
340     case oVerbose: opt.verbose++; break;
341
342     case oDebug: opt.debug |= pargs->r.ret_ulong; break;
343     case oDebugAll: opt.debug = ~0; break;
344     case oDebugLevel: debug_level = pargs->r.ret_str; break;
345
346     case oNoGrab: opt.no_grab = 1; break;
347       
348     case oPinentryProgram: opt.pinentry_program = pargs->r.ret_str; break;
349     case oScdaemonProgram: opt.scdaemon_program = pargs->r.ret_str; break;
350
351     case oDefCacheTTL: opt.def_cache_ttl = pargs->r.ret_ulong; break;
352       
353     case oIgnoreCacheForSigning: opt.ignore_cache_for_signing = 1; break;
354
355     default:
356       return 0; /* not handled */
357     }
358   return 1; /* handled */
359 }
360
361
362 int
363 main (int argc, char **argv )
364 {
365   ARGPARSE_ARGS pargs;
366   int orig_argc;
367   int may_coredump;
368   char **orig_argv;
369   FILE *configfp = NULL;
370   char *configname = NULL;
371   const char *shell;
372   unsigned configlineno;
373   int parse_debug = 0;
374   int default_config =1;
375   int greeting = 0;
376   int nogreeting = 0;
377   int pipe_server = 0;
378   int is_daemon = 0;
379   int nodetach = 0;
380   int csh_style = 0;
381   char *logfile = NULL;
382   int debug_wait = 0;
383   int disable_pth = 0;
384   int gpgconf_list = 0;
385   gpg_error_t err;
386
387   set_strusage (my_strusage);
388   gcry_control (GCRYCTL_SUSPEND_SECMEM_WARN);
389   /* Please note that we may running SUID(ROOT), so be very CAREFUL
390      when adding any stuff between here and the call to INIT_SECMEM()
391      somewhere after the option parsing */
392   log_set_prefix ("gpg-agent", JNLIB_LOG_WITH_PREFIX|JNLIB_LOG_WITH_PID); 
393
394   /* Try to auto set the character set.  */
395   set_native_charset (NULL); 
396
397   i18n_init ();
398
399   /* Libgcrypt requires us to register the threading model first.
400      Note that this will also do the pth_init. */
401 #ifdef USE_GNU_PTH
402   err = gcry_control (GCRYCTL_SET_THREAD_CBS, &gcry_threads_pth);
403   if (err)
404     {
405       log_fatal ("can't register GNU Pth with Libgcrypt: %s\n",
406                  gpg_strerror (err));
407     }
408 #endif /*USE_GNU_PTH*/
409
410   /* Check that the libraries are suitable.  Do it here because
411      the option parsing may need services of the library. */
412   if (!gcry_check_version (NEED_LIBGCRYPT_VERSION) )
413     {
414       log_fatal( _("libgcrypt is too old (need %s, have %s)\n"),
415                  NEED_LIBGCRYPT_VERSION, gcry_check_version (NULL) );
416     }
417
418   assuan_set_malloc_hooks (gcry_malloc, gcry_realloc, gcry_free);
419   assuan_set_assuan_log_stream (log_get_stream ());
420   assuan_set_assuan_log_prefix (log_get_prefix (NULL));
421
422   gcry_set_log_handler (my_gcry_logger, NULL);
423   gcry_control (GCRYCTL_USE_SECURE_RNDPOOL);
424
425   may_coredump = disable_core_dumps ();
426
427   parse_rereadable_options (NULL); /* Reset them to default values. */
428
429   shell = getenv ("SHELL");
430   if (shell && strlen (shell) >= 3 && !strcmp (shell+strlen (shell)-3, "csh") )
431     csh_style = 1;
432   
433   opt.homedir = getenv("GNUPGHOME");
434   if (!opt.homedir || !*opt.homedir)
435     opt.homedir = GNUPG_DEFAULT_HOMEDIR;
436
437
438   /* check whether we have a config file on the commandline */
439   orig_argc = argc;
440   orig_argv = argv;
441   pargs.argc = &argc;
442   pargs.argv = &argv;
443   pargs.flags= 1|(1<<6);  /* do not remove the args, ignore version */
444   while (arg_parse( &pargs, opts))
445     {
446       if (pargs.r_opt == oDebug || pargs.r_opt == oDebugAll)
447         parse_debug++;
448       else if (pargs.r_opt == oOptions)
449         { /* yes there is one, so we do not try the default one, but
450              read the option file when it is encountered at the
451              commandline */
452           default_config = 0;
453         }
454         else if (pargs.r_opt == oNoOptions)
455           default_config = 0; /* --no-options */
456         else if (pargs.r_opt == oHomedir)
457           opt.homedir = pargs.r.ret_str;
458     }
459
460   /* initialize the secure memory. */
461   gcry_control (GCRYCTL_INIT_SECMEM, 16384, 0);
462   maybe_setuid = 0;
463
464   /* 
465      Now we are now working under our real uid 
466   */
467
468
469   if (default_config)
470     configname = make_filename (opt.homedir, "gpg-agent.conf", NULL );
471   
472   argc = orig_argc;
473   argv = orig_argv;
474   pargs.argc = &argc;
475   pargs.argv = &argv;
476   pargs.flags=  1;  /* do not remove the args */
477  next_pass:
478   if (configname)
479     {
480       configlineno = 0;
481       configfp = fopen (configname, "r");
482       if (!configfp)
483         {
484           if (default_config)
485             {
486               if( parse_debug )
487                 log_info (_("NOTE: no default option file `%s'\n"),
488                           configname );
489             }
490           else
491             {
492               log_error (_("option file `%s': %s\n"),
493                          configname, strerror(errno) );
494               exit(2);
495             }
496           xfree (configname); 
497           configname = NULL;
498         }
499       if (parse_debug && configname )
500         log_info (_("reading options from `%s'\n"), configname );
501       default_config = 0;
502     }
503
504   while (optfile_parse( configfp, configname, &configlineno, &pargs, opts) )
505     {
506       if (parse_rereadable_options (&pargs))
507         continue; /* Already handled */
508       switch (pargs.r_opt)
509         {
510         case aGPGConfList: gpgconf_list = 1; break;
511         case oBatch: opt.batch=1; break;
512
513         case oDebugWait: debug_wait = pargs.r.ret_int; break;
514
515         case oOptions:
516           /* config files may not be nested (silently ignore them) */
517           if (!configfp)
518             {
519                 xfree(configname);
520                 configname = xstrdup(pargs.r.ret_str);
521                 goto next_pass;
522             }
523           break;
524         case oNoGreeting: nogreeting = 1; break;
525         case oNoVerbose: opt.verbose = 0; break;
526         case oNoOptions: break; /* no-options */
527         case oHomedir: opt.homedir = pargs.r.ret_str; break;
528         case oNoDetach: nodetach = 1; break;
529         case oLogFile: logfile = pargs.r.ret_str; break;
530         case oCsh: csh_style = 1; break;
531         case oSh: csh_style = 0; break;
532         case oServer: pipe_server = 1; break;
533         case oDaemon: is_daemon = 1; break;
534         case oDisablePth: disable_pth = 1; break;
535
536         case oDisplay: default_display = xstrdup (pargs.r.ret_str); break;
537         case oTTYname: default_ttyname = xstrdup (pargs.r.ret_str); break;
538         case oTTYtype: default_ttytype = xstrdup (pargs.r.ret_str); break;
539         case oLCctype: default_lc_ctype = xstrdup (pargs.r.ret_str); break;
540         case oLCmessages: default_lc_messages = xstrdup (pargs.r.ret_str);
541           break;
542
543         case oKeepTTY: opt.keep_tty = 1; break;
544         case oKeepDISPLAY: opt.keep_display = 1; break;
545
546         default : pargs.err = configfp? 1:2; break;
547         }
548     }
549   if (configfp)
550     {
551       fclose( configfp );
552       configfp = NULL;
553       /* Keep a copy of the name so that it can be read on SIGHUP. */
554       config_filename = configname;
555       configname = NULL;
556       goto next_pass;
557     }
558   xfree (configname);
559   configname = NULL;
560   if (log_get_errorcount(0))
561     exit(2);
562   if (nogreeting )
563     greeting = 0;
564
565   if (greeting)
566     {
567       fprintf (stderr, "%s %s; %s\n",
568                  strusage(11), strusage(13), strusage(14) );
569       fprintf (stderr, "%s\n", strusage(15) );
570     }
571 #ifdef IS_DEVELOPMENT_VERSION
572   log_info ("NOTE: this is a development version!\n");
573 #endif
574
575   set_debug ();
576   
577   if (atexit (cleanup))
578     {
579       log_error ("atexit failed\n");
580       cleanup ();
581       exit (1);
582     }
583
584   create_directories ();
585
586   if (debug_wait && pipe_server)
587     {
588       log_debug ("waiting for debugger - my pid is %u .....\n",
589                  (unsigned int)getpid());
590       sleep (debug_wait);
591       log_debug ("... okay\n");
592     }
593   
594   if (gpgconf_list)
595     {
596       char *filename;
597
598       /* List options and default values in the GPG Conf format.  */
599
600       /* The following list is taken from gnupg/tools/gpgconf-comp.c.  */
601       /* Option flags.  YOU MUST NOT CHANGE THE NUMBERS OF THE EXISTING
602          FLAGS, AS THEY ARE PART OF THE EXTERNAL INTERFACE.  */
603 #define GC_OPT_FLAG_NONE        0UL
604       /* The RUNTIME flag for an option indicates that the option can be
605          changed at runtime.  */
606 #define GC_OPT_FLAG_RUNTIME     (1UL << 3)
607       /* The DEFAULT flag for an option indicates that the option has a
608          default value.  */
609 #define GC_OPT_FLAG_DEFAULT     (1UL << 4)
610       /* The DEF_DESC flag for an option indicates that the option has a
611          default, which is described by the value of the default field.  */
612 #define GC_OPT_FLAG_DEF_DESC    (1UL << 5)
613       /* The NO_ARG_DESC flag for an option indicates that the argument has
614          a default, which is described by the value of the ARGDEF field.  */
615 #define GC_OPT_FLAG_NO_ARG_DESC (1UL << 6)
616
617       filename = make_filename (opt.homedir, "gpg-agent.conf", NULL );
618       printf ("gpgconf-gpg-agent.conf:%lu:\"%s\n",
619               GC_OPT_FLAG_DEFAULT, filename);
620       xfree (filename);
621
622       printf ("verbose:%lu:\n"
623               "quiet:%lu:\n"
624               "debug-level:%lu:\"none:\n"
625               "log-file:%lu:\n",
626               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME,
627               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME,
628               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME,
629               GC_OPT_FLAG_NONE );
630       printf ("default-cache-ttl:%lu:%d:\n",
631               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME, DEFAULT_CACHE_TTL );
632       printf ("no-grab:%lu:\n", 
633               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
634       printf ("ignore-cache-for-signing:%lu:\n",
635               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
636
637       agent_exit (0);
638     }
639
640   if (!pipe_server && !is_daemon)
641     log_info (_("please use the option `--daemon'"
642                 " to run the program in the background\n"));
643   
644 #ifdef ENABLE_NLS
645   /* gpg-agent usually does not output any messages because it runs in
646      the background.  For log files it is acceptable to have messages
647      always encoded in utf-8.  We switch here to utf-8, so that
648      commands like --help still give native messages.  It is far
649      easier to switch only once instead of for every message and it
650      actually helps when more then one thread is active (avoids an
651      extra copy step). */
652     bind_textdomain_codeset (PACKAGE_GT, "UTF-8");
653 #endif
654
655   /* Now start with logging to a file if this is desired. */
656   if (logfile)
657     {
658       log_set_file (logfile);
659       log_set_prefix (NULL, (JNLIB_LOG_WITH_PREFIX
660                              |JNLIB_LOG_WITH_TIME
661                              |JNLIB_LOG_WITH_PID));
662     }
663
664   /* Make sure that we have a default ttyname. */
665   if (!default_ttyname && ttyname (1))
666     default_ttyname = xstrdup (ttyname (1));
667   if (!default_ttytype && getenv ("TERM"))
668     default_ttytype = xstrdup (getenv ("TERM"));
669
670   if (pipe_server)
671     { /* this is the simple pipe based server */
672       start_command_handler (-1, -1);
673     }
674   else if (!is_daemon)
675     ;
676   else
677     { /* regular server mode */
678       int fd;
679       pid_t pid;
680       int len;
681       struct sockaddr_un serv_addr;
682       char *p;
683
684       /* Remove the DISPLAY variable so that a pinentry does not
685          default to a specific display.  There is still a default
686          display when gpg-agent weas started using --display or a
687          client requested this using an OPTION command. */
688       if (!opt.keep_display)
689         unsetenv ("DISPLAY");
690
691       *socket_name = 0;
692       snprintf (socket_name, DIM(socket_name)-1,
693                 "/tmp/gpg-XXXXXX/S.gpg-agent");
694       socket_name[DIM(socket_name)-1] = 0;
695       p = strrchr (socket_name, '/');
696       if (!p)
697         BUG ();
698       *p = 0;;
699       if (!mkdtemp(socket_name))
700         {
701           log_error ("can't create directory `%s': %s\n",
702                      socket_name, strerror(errno) );
703           exit (1);
704         }
705       *p = '/';
706
707       if (strchr (socket_name, ':') )
708         {
709           log_error ("colons are not allowed in the socket name\n");
710           exit (1);
711         }
712       if (strlen (socket_name)+1 >= sizeof serv_addr.sun_path ) 
713         {
714           log_error ("name of socket too long\n");
715           exit (1);
716         }
717    
718
719       fd = socket (AF_UNIX, SOCK_STREAM, 0);
720       if (fd == -1)
721         {
722           log_error ("can't create socket: %s\n", strerror(errno) );
723           exit (1);
724         }
725
726       memset (&serv_addr, 0, sizeof serv_addr);
727       serv_addr.sun_family = AF_UNIX;
728       strcpy (serv_addr.sun_path, socket_name);
729       len = (offsetof (struct sockaddr_un, sun_path)
730              + strlen(serv_addr.sun_path) + 1);
731
732       if (bind (fd, (struct sockaddr*)&serv_addr, len) == -1)
733         {
734           log_error ("error binding socket to `%s': %s\n",
735                      serv_addr.sun_path, strerror (errno) );
736           close (fd);
737           exit (1);
738         }
739   
740       if (listen (fd, 5 ) == -1)
741         {
742           log_error ("listen() failed: %s\n", strerror (errno));
743           close (fd);
744           exit (1);
745         }
746
747       if (opt.verbose)
748         log_info ("listening on socket `%s'\n", socket_name );
749
750
751       fflush (NULL);
752       pid = fork ();
753       if (pid == (pid_t)-1) 
754         {
755           log_fatal ("fork failed: %s\n", strerror (errno) );
756           exit (1);
757         }
758       else if (pid) 
759         { /* We are the parent */
760           char *infostr;
761           
762           close (fd);
763           
764           /* create the info string: <name>:<pid>:<protocol_version> */
765           if (asprintf (&infostr, "GPG_AGENT_INFO=%s:%lu:1",
766                         socket_name, (ulong)pid ) < 0)
767             {
768               log_error ("out of core\n");
769               kill (pid, SIGTERM);
770               exit (1);
771             }
772           *socket_name = 0; /* don't let cleanup() remove the socket -
773                                the child should do this from now on */
774           if (argc) 
775             { /* run the program given on the commandline */
776               if (putenv (infostr))
777                 {
778                   log_error ("failed to set environment: %s\n",
779                              strerror (errno) );
780                   kill (pid, SIGTERM );
781                   exit (1);
782                 }
783               execvp (argv[0], argv);
784               log_error ("failed to run the command: %s\n", strerror (errno));
785               kill (pid, SIGTERM);
786               exit (1);
787             }
788           else
789             {
790               /* print the environment string, so that the caller can use
791                  shell's eval to set it */
792               if (csh_style)
793                 {
794                   *strchr (infostr, '=') = ' ';
795                   printf ( "setenv %s\n", infostr);
796                 }
797               else
798                 {
799                   printf ( "%s; export GPG_AGENT_INFO;\n", infostr);
800                 }
801               free (infostr);
802               exit (0); 
803             }
804           /*NEVER REACHED*/
805         } /* end parent */
806       
807
808       /* 
809          This is the child
810        */
811
812       /* Detach from tty and put process into a new session */
813       if (!nodetach )
814         { 
815           int i;
816           unsigned int oldflags;
817
818           /* Close stdin, stdout and stderr unless it is the log stream */
819           for (i=0; i <= 2; i++) 
820             {
821               if (!log_test_fd (i) )
822                 close (i);
823             }
824           if (setsid() == -1)
825             {
826               log_error ("setsid() failed: %s\n", strerror(errno) );
827               cleanup ();
828               exit (1);
829             }
830
831           log_get_prefix (&oldflags);
832           log_set_prefix (NULL, oldflags | JNLIB_LOG_RUN_DETACHED);
833           opt.running_detached = 1;
834         }
835
836       if (chdir("/"))
837         {
838           log_error ("chdir to / failed: %s\n", strerror (errno));
839           exit (1);
840         }
841
842
843 #ifdef USE_GNU_PTH
844       if (!disable_pth)
845         {
846           struct sigaction sa;
847
848           sa.sa_handler = SIG_IGN;
849           sigemptyset (&sa.sa_mask);
850           sa.sa_flags = 0;
851           sigaction (SIGPIPE, &sa, NULL);
852           handle_connections (fd);
853         }
854       else
855 #endif /*!USE_GNU_PTH*/
856       /* setup signals */
857         {
858           struct sigaction oact, nact;
859           
860           nact.sa_handler = cleanup_sh;
861           sigemptyset (&nact.sa_mask);
862           nact.sa_flags = 0;
863           
864           sigaction (SIGHUP, NULL, &oact);
865           if (oact.sa_handler != SIG_IGN)
866             sigaction (SIGHUP, &nact, NULL);
867           sigaction( SIGTERM, NULL, &oact );
868           if (oact.sa_handler != SIG_IGN)
869             sigaction (SIGTERM, &nact, NULL);
870           nact.sa_handler = SIG_IGN;
871           sigaction (SIGPIPE, &nact, NULL);
872           sigaction (SIGINT, &nact, NULL);
873
874           start_command_handler (fd, -1);
875         }
876       close (fd);
877     }
878   
879   return 0;
880 }
881
882 void
883 agent_exit (int rc)
884 {
885   /*FIXME: update_random_seed_file();*/
886 #if 1
887   /* at this time a bit annoying */
888   if (opt.debug & DBG_MEMSTAT_VALUE)
889     {
890       gcry_control( GCRYCTL_DUMP_MEMORY_STATS );
891       gcry_control( GCRYCTL_DUMP_RANDOM_STATS );
892     }
893   if (opt.debug)
894     gcry_control (GCRYCTL_DUMP_SECMEM_STATS );
895 #endif
896   gcry_control (GCRYCTL_TERM_SECMEM );
897   rc = rc? rc : log_get_errorcount(0)? 2 : 0;
898   exit (rc);
899 }
900
901
902 void
903 agent_init_default_ctrl (struct server_control_s *ctrl)
904 {
905   ctrl->connection_fd = -1;
906
907   /* Note we ignore malloc errors because we can't do much about it
908      and the request will fail anyway shortly after this
909      initialization. */
910   if (ctrl->display)
911     free (ctrl->display);
912   ctrl->display = default_display? strdup (default_display) : NULL;
913
914   if (ctrl->ttyname)
915     free (ctrl->ttyname);
916   ctrl->ttyname = default_ttyname? strdup (default_ttyname) : NULL;
917
918   if (ctrl->ttytype)
919     free (ctrl->ttytype);
920   ctrl->ttytype = default_ttytype? strdup (default_ttytype) : NULL;
921
922   if (ctrl->lc_ctype)
923     free (ctrl->lc_ctype);
924   ctrl->lc_ctype = default_lc_ctype? strdup (default_lc_ctype) : NULL;
925
926   if (ctrl->lc_messages)
927     free (ctrl->lc_messages);
928   ctrl->lc_messages = default_lc_messages? strdup (default_lc_messages) : NULL;
929 }
930
931
932 /* Reread parts of the configuration.  Note, that this function is
933    obviously not thread-safe and should only be called from the PTH
934    signal handler. 
935
936    Fixme: Due to the way the argument parsing works, we create a
937    memory leak here for all string type arguments.  There is currently
938    no clean way to tell whether the memory for the argument has been
939    allocated or points into the process' original arguments.  Unless
940    we have a mechanism to tell this, we need to live on with this. */
941 static void
942 reread_configuration (void)
943 {
944   ARGPARSE_ARGS pargs;
945   FILE *fp;
946   unsigned int configlineno = 0;
947   int dummy;
948
949   if (!config_filename)
950     return; /* No config file. */
951
952   fp = fopen (config_filename, "r");
953   if (!fp)
954     {
955       log_error (_("option file `%s': %s\n"),
956                  config_filename, strerror(errno) );
957       return;
958     }
959
960   parse_rereadable_options (NULL); /* Start from the default values. */
961
962   memset (&pargs, 0, sizeof pargs);
963   dummy = 0;
964   pargs.argc = &dummy;
965   pargs.flags = 1;  /* do not remove the args */
966   while (optfile_parse (fp, config_filename, &configlineno, &pargs, opts) )
967     {
968       if (pargs.r_opt < -1)
969         pargs.err = 1; /* Print a warning. */
970       else /* Try to parse this option - ignore unchangeable ones. */
971         parse_rereadable_options (&pargs);
972     }
973   fclose (fp);
974   set_debug ();
975 }
976
977
978 static void
979 create_private_keys_directory (const char *home)
980 {
981   char *fname;
982   struct stat statbuf;
983
984   fname = make_filename (home, GNUPG_PRIVATE_KEYS_DIR, NULL);
985   if (stat (fname, &statbuf) && errno == ENOENT)
986     {
987       if (mkdir (fname, S_IRUSR|S_IWUSR|S_IXUSR ))
988         log_error (_("can't create directory `%s': %s\n"),
989                    fname,       strerror(errno) );
990       else if (!opt.quiet)
991         log_info (_("directory `%s' created\n"), fname);
992     }
993   xfree (fname);
994 }
995
996 /* Create the directory only if the supplied directory name is the
997    same as the default one.  This way we avoid to create arbitrary
998    directories when a non-default home directory is used.  To cope
999    with HOME, we compare only the suffix if we see that the default
1000    homedir does start with a tilde.  We don't stop here in case of
1001    problems because other functions will throw an error anyway.*/
1002 static void
1003 create_directories (void)
1004 {
1005   struct stat statbuf;
1006   const char *defhome = GNUPG_DEFAULT_HOMEDIR;
1007   char *home;
1008
1009   home  = make_filename (opt.homedir, NULL);
1010   if ( stat (home, &statbuf) )
1011     {
1012       if (errno == ENOENT)
1013         {
1014           if ( (*defhome == '~'
1015                 && (strlen (home) >= strlen (defhome+1)
1016                     && !strcmp (home + strlen(home)
1017                                 - strlen (defhome+1), defhome+1)))
1018                || (*defhome != '~' && !strcmp (home, defhome) )
1019                )
1020             {
1021               if (mkdir (home, S_IRUSR|S_IWUSR|S_IXUSR ))
1022                 log_error (_("can't create directory `%s': %s\n"),
1023                            home, strerror(errno) );
1024               else 
1025                 {
1026                   if (!opt.quiet)
1027                     log_info (_("directory `%s' created\n"), home);
1028                   create_private_keys_directory (home);
1029                 }
1030             }
1031         }
1032       else
1033         log_error ("error stat-ing `%s': %s\n", home, strerror (errno));
1034     }
1035   else if ( !S_ISDIR(statbuf.st_mode))
1036     {
1037       log_error ("can't use `%s' as home directory\n", home);
1038     }
1039   else /* exists and is a directory. */
1040     {
1041       create_private_keys_directory (home);
1042     }
1043   xfree (home);
1044 }
1045
1046
1047
1048 #ifdef USE_GNU_PTH
1049 static void
1050 handle_signal (int signo)
1051 {
1052   switch (signo)
1053     {
1054     case SIGHUP:
1055       log_info ("SIGHUP received - "
1056                 "re-reading configuration and flushing cache\n");
1057       agent_flush_cache ();
1058       reread_configuration ();
1059       break;
1060       
1061     case SIGUSR1:
1062       if (opt.verbose < 5)
1063         opt.verbose++;
1064       log_info ("SIGUSR1 received - verbosity set to %d\n", opt.verbose);
1065       break;
1066
1067     case SIGUSR2:
1068       if (opt.verbose)
1069         opt.verbose--;
1070       log_info ("SIGUSR2 received - verbosity set to %d\n", opt.verbose );
1071       break;
1072
1073     case SIGTERM:
1074       if (!shutdown_pending)
1075         log_info ("SIGTERM received - shutting down ...\n");
1076       else
1077         log_info ("SIGTERM received - still %ld running threads\n",
1078                   pth_ctrl( PTH_CTRL_GETTHREADS ));
1079       shutdown_pending++;
1080       if (shutdown_pending > 2)
1081         {
1082           log_info ("shutdown forced\n");
1083           log_info ("%s %s stopped\n", strusage(11), strusage(13) );
1084           cleanup ();
1085           agent_exit (0);
1086         }
1087       break;
1088         
1089     case SIGINT:
1090       log_info ("SIGINT received - immediate shutdown\n");
1091       log_info( "%s %s stopped\n", strusage(11), strusage(13));
1092       cleanup ();
1093       agent_exit (0);
1094       break;
1095
1096     default:
1097       log_info ("signal %d received - no action defined\n", signo);
1098     }
1099 }
1100
1101
1102 static void *
1103 start_connection_thread (void *arg)
1104 {
1105   int fd = (int)arg;
1106
1107   if (opt.verbose)
1108     log_info ("handler for fd %d started\n", fd);
1109   start_command_handler (-1, fd);
1110   if (opt.verbose)
1111     log_info ("handler for fd %d terminated\n", fd);
1112   
1113   return NULL;
1114 }
1115
1116
1117 static void
1118 handle_connections (int listen_fd)
1119 {
1120   pth_attr_t tattr;
1121   pth_event_t ev;
1122   sigset_t sigs;
1123   int signo;
1124   struct sockaddr_un paddr;
1125   socklen_t plen = sizeof( paddr );
1126   int fd;
1127
1128   tattr = pth_attr_new();
1129   pth_attr_set (tattr, PTH_ATTR_JOINABLE, 0);
1130   pth_attr_set (tattr, PTH_ATTR_STACK_SIZE, 32*1024);
1131   pth_attr_set (tattr, PTH_ATTR_NAME, "gpg-agent");
1132
1133   sigemptyset (&sigs );
1134   sigaddset (&sigs, SIGHUP);
1135   sigaddset (&sigs, SIGUSR1);
1136   sigaddset (&sigs, SIGUSR2);
1137   sigaddset (&sigs, SIGINT);
1138   sigaddset (&sigs, SIGTERM);
1139   ev = pth_event (PTH_EVENT_SIGS, &sigs, &signo);
1140
1141   for (;;)
1142     {
1143       if (shutdown_pending)
1144         {
1145           if (pth_ctrl (PTH_CTRL_GETTHREADS) == 1)
1146             break; /* ready */
1147
1148           /* Do not accept anymore connections and wait for existing
1149              connections to terminate */
1150           signo = 0;
1151           pth_wait (ev);
1152           if (pth_event_occurred (ev) && signo)
1153             handle_signal (signo);
1154           continue;
1155         }
1156
1157       fd = pth_accept_ev (listen_fd, (struct sockaddr *)&paddr, &plen, ev);
1158       if (fd == -1)
1159         {
1160 #ifdef PTH_STATUS_OCCURRED     /* This is Pth 2 */
1161           if (pth_event_status (ev) == PTH_STATUS_OCCURRED)
1162 #else
1163           if (pth_event_occurred (ev))
1164 #endif
1165             {
1166               handle_signal (signo);
1167               continue;
1168             }
1169           log_error ("accept failed: %s - waiting 1s\n", strerror (errno));
1170           pth_sleep(1);
1171           continue;
1172         }
1173
1174       if (!pth_spawn (tattr, start_connection_thread, (void*)fd))
1175         {
1176           log_error ("error spawning connection handler: %s\n",
1177                      strerror (errno) );
1178           close (fd);
1179         }
1180     }
1181
1182   pth_event_free (ev, PTH_FREE_ALL);
1183   cleanup ();
1184   log_info ("%s %s stopped\n", strusage(11), strusage(13));
1185 }
1186 #endif /*USE_GNU_PTH*/