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