* gpg-agent.c (main): Disable core dumps.
[gnupg.git] / agent / gpg-agent.c
1 /* gpg-agent.c  -  The GnuPG Agent
2  *      Copyright (C) 2000, 2001 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
37 #include <gcrypt.h>
38
39 #define JNLIB_NEED_LOG_LOGV
40 #include "agent.h"
41 #include "../assuan/assuan.h" /* malloc hooks */
42
43 #include "sysutils.h"
44
45
46 #define N_(a) a
47 #define _(a) a
48
49
50 enum cmd_and_opt_values 
51 { aNull = 0,
52   oCsh            = 'c',
53   oQuiet          = 'q',
54   oSh             = 's',
55   oVerbose        = 'v',
56   
57   oNoVerbose = 500,
58   oOptions,
59   oDebug,
60   oDebugAll,
61   oDebugWait,
62   oNoGreeting,
63   oNoOptions,
64   oHomedir,
65   oNoDetach,
66   oNoGrab,
67   oLogFile,
68   oServer,
69   oBatch,
70   
71   oPinentryProgram,
72
73 aTest };
74
75
76
77 static ARGPARSE_OPTS opts[] = {
78   
79   { 301, NULL, 0, N_("@Options:\n ") },
80
81   { oServer,   "server",     0, N_("run in server mode") },
82   { oVerbose, "verbose",   0, N_("verbose") },
83   { oQuiet,     "quiet",     0, N_("be somewhat more quiet") },
84   { oSh,        "sh",        0, N_("sh-style command output") },
85   { oCsh,       "csh",       0, N_("csh-style command output") },
86   { oOptions, "options"  , 2, N_("read options from file")},
87   { oDebug,     "debug"     ,4|16, N_("set debugging flags")},
88   { oDebugAll, "debug-all" ,0, N_("enable full debugging")},
89   { oDebugWait,"debug-wait",1, "@"},
90   { oNoDetach, "no-detach" ,0, N_("do not detach from the console")},
91   { oNoGrab, "no-grab"     ,0, N_("do not grab keyboard and mouse")},
92   { oLogFile, "log-file"   ,2, N_("use a log file for the server")},
93
94   { oPinentryProgram, "pinentry-program", 2 , "Path of PIN Entry program" },
95
96
97   {0}
98 };
99
100
101 static volatile int caught_fatal_sig = 0;
102
103 /* It is possible that we are currently running under setuid permissions */
104 static int maybe_setuid = 1;
105
106 /* Name of the communication socket */
107 static char socket_name[128];
108
109
110
111 static const char *
112 my_strusage (int level)
113 {
114   const char *p;
115   switch (level)
116     {
117     case 11: p = "gpg-agent (GnuPG)";
118       break;
119     case 13: p = VERSION; break;
120     case 17: p = PRINTABLE_OS_NAME; break;
121     case 19: p = _("Please report bugs to <" PACKAGE_BUGREPORT ">.\n");
122       break;
123     case 1:
124     case 40: p =  _("Usage: gpg-agent [options] (-h for help)");
125       break;
126     case 41: p =  _("Syntax: gpg-agent [options] [command [args]]\n"
127                     "Secret key management for GnuPG\n");
128     break;
129     
130     default: p = NULL;
131     }
132   return p;
133 }
134
135
136
137 static void
138 i18n_init (void)
139 {
140 #ifdef USE_SIMPLE_GETTEXT
141     set_gettext_file( PACKAGE );
142 #else
143 #ifdef ENABLE_NLS
144     /* gtk_set_locale (); HMMM: We have not yet called gtk_init */
145     bindtextdomain( PACKAGE, GNUPG_LOCALEDIR );
146     textdomain( PACKAGE );
147 #endif
148 #endif
149 }
150
151
152
153 /* Use by gcry for logging */
154 static void
155 my_gcry_logger (void *dummy, int level, const char *fmt, va_list arg_ptr)
156 {
157   /* translate the log levels */
158   switch (level)
159     {
160     case GCRY_LOG_CONT: level = JNLIB_LOG_CONT; break;
161     case GCRY_LOG_INFO: level = JNLIB_LOG_INFO; break;
162     case GCRY_LOG_WARN: level = JNLIB_LOG_WARN; break;
163     case GCRY_LOG_ERROR:level = JNLIB_LOG_ERROR; break;
164     case GCRY_LOG_FATAL:level = JNLIB_LOG_FATAL; break;
165     case GCRY_LOG_BUG:  level = JNLIB_LOG_BUG; break;
166     case GCRY_LOG_DEBUG:level = JNLIB_LOG_DEBUG; break;
167     default:            level = JNLIB_LOG_ERROR; break;  
168     }
169   log_logv (level, fmt, arg_ptr);
170 }
171
172
173 static void
174 cleanup (void)
175 {
176   if (*socket_name)
177     {
178       char *p;
179
180       remove (socket_name);
181       p = strrchr (socket_name, '/');
182       if (p)
183         {
184           *p = 0;
185           rmdir (socket_name);
186           *p = '/';
187         }
188       *socket_name = 0;
189     }
190 }
191
192
193 static RETSIGTYPE
194 cleanup_sh (int sig)
195 {
196   if (caught_fatal_sig)
197     raise (sig);
198   caught_fatal_sig = 1;
199
200   /* gcry_control( GCRYCTL_TERM_SECMEM );*/
201   cleanup ();
202
203 #ifndef HAVE_DOSISH_SYSTEM
204   {     /* reset action to default action and raise signal again */
205     struct sigaction nact;
206     nact.sa_handler = SIG_DFL;
207     sigemptyset( &nact.sa_mask );
208     nact.sa_flags = 0;
209     sigaction( sig, &nact, NULL);
210   }
211 #endif
212   raise( sig );
213 }
214
215 int
216 main (int argc, char **argv )
217 {
218   ARGPARSE_ARGS pargs;
219   int orig_argc;
220   int may_coredump;
221   char **orig_argv;
222   FILE *configfp = NULL;
223   char *configname = NULL;
224   const char *shell;
225   unsigned configlineno;
226   int parse_debug = 0;
227   int default_config =1;
228   int greeting = 0;
229   int nogreeting = 0;
230   int pipe_server = 0;
231   int nodetach = 0;
232   int grab = 0;
233   int csh_style = 0;
234   char *logfile = NULL;
235   int debug_wait = 0;
236
237   set_strusage (my_strusage);
238   gcry_control (GCRYCTL_SUSPEND_SECMEM_WARN);
239   /* Please note that we may running SUID(ROOT), so be very CAREFUL
240      when adding any stuff between here and the call to INIT_SECMEM()
241      somewhere after the option parsing */
242   log_set_prefix ("gpg-agent", 1|4); 
243   i18n_init ();
244
245   /* check that the libraries are suitable.  Do it here because
246      the option parsing may need services of the library */
247   if (!gcry_check_version ( "1.1.4" ) )
248     {
249       log_fatal( _("libgcrypt is too old (need %s, have %s)\n"),
250                  VERSION, gcry_check_version (NULL) );
251     }
252
253   assuan_set_malloc_hooks (gcry_malloc, gcry_realloc, gcry_free);
254   gcry_set_log_handler (my_gcry_logger, NULL);
255   gcry_control (GCRYCTL_USE_SECURE_RNDPOOL);
256
257   may_coredump = disable_core_dumps ();
258
259   shell = getenv ("SHELL");
260   if (shell && strlen (shell) >= 3 && !strcmp (shell+strlen (shell)-3, "csh") )
261     csh_style = 1;
262   
263   opt.homedir = getenv("GNUPGHOME");
264   if (!opt.homedir || !*opt.homedir)
265     {
266 #ifdef HAVE_DRIVE_LETTERS
267       opt.homedir = "c:/gnupg-test";
268 #else
269       opt.homedir = "~/.gnupg-test";
270 #endif
271     }
272   grab = 1;
273
274   /* check whether we have a config file on the commandline */
275   orig_argc = argc;
276   orig_argv = argv;
277   pargs.argc = &argc;
278   pargs.argv = &argv;
279   pargs.flags= 1|(1<<6);  /* do not remove the args, ignore version */
280   while (arg_parse( &pargs, opts))
281     {
282       if (pargs.r_opt == oDebug || pargs.r_opt == oDebugAll)
283         parse_debug++;
284       else if (pargs.r_opt == oOptions)
285         { /* yes there is one, so we do not try the default one, but
286              read the option file when it is encountered at the
287              commandline */
288           default_config = 0;
289         }
290         else if (pargs.r_opt == oNoOptions)
291           default_config = 0; /* --no-options */
292         else if (pargs.r_opt == oHomedir)
293           opt.homedir = pargs.r.ret_str;
294     }
295
296   /* initialize the secure memory. */
297   gcry_control (GCRYCTL_INIT_SECMEM, 16384, 0);
298   maybe_setuid = 0;
299
300   /* 
301      Now we are now working under our real uid 
302   */
303
304
305   if (default_config)
306     configname = make_filename (opt.homedir, "gpg-agent.conf", NULL );
307   
308   argc = orig_argc;
309   argv = orig_argv;
310   pargs.argc = &argc;
311   pargs.argv = &argv;
312   pargs.flags=  1;  /* do not remove the args */
313  next_pass:
314   if (configname)
315     {
316       configlineno = 0;
317       configfp = fopen (configname, "r");
318       if (!configfp)
319         {
320           if (default_config)
321             {
322               if( parse_debug )
323                 log_info (_("NOTE: no default option file `%s'\n"),
324                           configname );
325             }
326           else
327             {
328               log_error (_("option file `%s': %s\n"),
329                          configname, strerror(errno) );
330               exit(2);
331             }
332           xfree (configname); 
333           configname = NULL;
334         }
335       if (parse_debug && configname )
336         log_info (_("reading options from `%s'\n"), configname );
337       default_config = 0;
338     }
339
340   while (optfile_parse( configfp, configname, &configlineno, &pargs, opts) )
341     {
342       switch (pargs.r_opt)
343         {
344         case oQuiet: opt.quiet = 1; break;
345         case oVerbose: opt.verbose++; break;
346         case oBatch: opt.batch=1; break;
347
348         case oDebug: opt.debug |= pargs.r.ret_ulong; break;
349         case oDebugAll: opt.debug = ~0; break;
350         case oDebugWait: debug_wait = pargs.r.ret_int; break;
351
352         case oOptions:
353           /* config files may not be nested (silently ignore them) */
354           if (!configfp)
355             {
356                 xfree(configname);
357                 configname = xstrdup(pargs.r.ret_str);
358                 goto next_pass;
359             }
360           break;
361         case oNoGreeting: nogreeting = 1; break;
362         case oNoVerbose: opt.verbose = 0; break;
363         case oNoOptions: break; /* no-options */
364         case oHomedir: opt.homedir = pargs.r.ret_str; break;
365         case oNoDetach: nodetach = 1; break;
366         case oNoGrab: grab = 0; break;
367         case oLogFile: logfile = pargs.r.ret_str; break;
368         case oCsh: csh_style = 1; break;
369         case oSh: csh_style = 0; break;
370         case oServer: pipe_server = 1; break;
371
372         case oPinentryProgram: opt.pinentry_program = pargs.r.ret_str; break;
373
374         default : pargs.err = configfp? 1:2; break;
375         }
376     }
377   if (configfp)
378     {
379       fclose( configfp );
380       configfp = NULL;
381       xfree(configname);
382       configname = NULL;
383       goto next_pass;
384     }
385   xfree (configname);
386   configname = NULL;
387   if (log_get_errorcount(0))
388     exit(2);
389   if (nogreeting )
390     greeting = 0;
391
392   if (greeting)
393     {
394       fprintf (stderr, "%s %s; %s\n",
395                  strusage(11), strusage(13), strusage(14) );
396       fprintf (stderr, "%s\n", strusage(15) );
397     }
398 #ifdef IS_DEVELOPMENT_VERSION
399   log_info ("NOTE: this is a development version!\n");
400 #endif
401
402   
403   if (atexit (cleanup))
404     {
405       log_error ("atexit failed\n");
406       cleanup ();
407       exit (1);
408     }
409
410   if (debug_wait && pipe_server)
411     {
412       log_debug ("waiting for debugger - my pid is %u .....\n",
413                  (unsigned int)getpid());
414       sleep (debug_wait);
415       log_debug ("... okay\n");
416     }
417   
418   /* now start with logging to a file if this is desired */
419   if (logfile)
420     {
421       log_set_file (logfile);
422       log_set_prefix (NULL, 1|2|4);
423     }
424
425
426   if (pipe_server)
427     { /* this is the simple pipe based server */
428       start_command_handler (-1);
429     }
430   else
431     { /* regular server mode */
432       int fd;
433       pid_t pid;
434       int i;
435       int len;
436       struct sockaddr_un serv_addr;
437       char *p;
438
439       *socket_name = 0;
440       snprintf (socket_name, DIM(socket_name)-1,
441                 "/tmp/gpg-XXXXXX/S.gpg-agent");
442       socket_name[DIM(socket_name)-1] = 0;
443       p = strrchr (socket_name, '/');
444       if (!p)
445         BUG ();
446       *p = 0;;
447       if (!mkdtemp(socket_name))
448         {
449           log_error ("can't create directory `%s': %s\n",
450                      socket_name, strerror(errno) );
451           exit (1);
452         }
453       *p = '/';
454
455       if (strchr (socket_name, ':') )
456         {
457           log_error ("colons are not allowed in the socket name\n");
458           exit (1);
459         }
460       if (strlen (socket_name)+1 >= sizeof serv_addr.sun_path ) 
461         {
462           log_error ("name of socket to long\n");
463           exit (1);
464         }
465    
466
467       fd = socket (AF_UNIX, SOCK_STREAM, 0);
468       if (fd == -1)
469         {
470           log_error ("can't create socket: %s\n", strerror(errno) );
471           exit (1);
472         }
473
474       memset (&serv_addr, 0, sizeof serv_addr);
475       serv_addr.sun_family = AF_UNIX;
476       strcpy (serv_addr.sun_path, socket_name);
477       len = (offsetof (struct sockaddr_un, sun_path)
478              + strlen(serv_addr.sun_path) + 1);
479
480       if (bind (fd, (struct sockaddr*)&serv_addr, len) == -1)
481         {
482           log_error ("error binding socket to `%s': %s\n",
483                      serv_addr.sun_path, strerror (errno) );
484           close (fd);
485           exit (1);
486         }
487   
488       if (listen (fd, 5 ) == -1)
489         {
490           log_error ("listen() failed: %s\n", strerror (errno));
491           close (fd);
492           exit (1);
493         }
494
495       if (opt.verbose)
496         log_info ("listening on socket `%s'\n", socket_name );
497
498
499       fflush (NULL);
500       pid = fork ();
501       if (pid == (pid_t)-1) 
502         {
503           log_fatal ("fork failed: %s\n", strerror (errno) );
504           exit (1);
505         }
506       else if (pid) 
507         { /* we are the parent */
508           char *infostr;
509           
510           close (fd);
511           
512           /* create the info string: <name>:<pid>:<protocol_version> */
513           if (asprintf (&infostr, "GPG_AGENT_INFO=%s:%lu:1",
514                         socket_name, (ulong)pid ) < 0)
515             {
516               log_error ("out of core\n");
517               kill (pid, SIGTERM);
518               exit (1);
519             }
520           *socket_name = 0; /* don't let cleanup() remove the socket -
521                                the child should do this from now on */
522           if (argc) 
523             { /* run the program given on the commandline */
524               if (putenv (infostr))
525                 {
526                   log_error ("failed to set environment: %s\n",
527                              strerror (errno) );
528                   kill (pid, SIGTERM );
529                   exit (1);
530                 }
531               execvp (argv[0], argv);
532               log_error ("failed to run the command: %s\n", strerror (errno));
533               kill (pid, SIGTERM);
534               exit (1);
535             }
536           else
537             {
538               /* print the environment string, so that the caller can use
539                  shell's eval to set it */
540               if (csh_style)
541                 {
542                   *strchr (infostr, '=') = ' ';
543                   printf ( "setenv %s\n", infostr);
544                 }
545               else
546                 {
547                   printf ( "%s; export GPG_AGENT_INFO;\n", infostr);
548                 }
549               free (infostr);
550               exit (0); 
551             }
552           /*NEVER REACHED*/
553         } /* end parent */
554       
555       /* this is the child */
556
557       /* detach from tty and put process into a new session */
558       if (!nodetach )
559         {  /* close stdin, stdout and stderr unless it is the log stream */
560           for (i=0; i <= 2; i++) 
561             {
562               if ( log_get_fd () != i)
563                 close (i);
564             }
565           if (setsid() == -1)
566             {
567               log_error ("setsid() failed: %s\n", strerror(errno) );
568               cleanup ();
569               exit (1);
570             }
571         }
572
573       /* setup signals */
574       {
575         struct sigaction oact, nact;
576         
577         nact.sa_handler = cleanup_sh;
578         sigemptyset (&nact.sa_mask);
579         nact.sa_flags = 0;
580         
581         sigaction (SIGHUP, NULL, &oact);
582         if (oact.sa_handler != SIG_IGN)
583           sigaction (SIGHUP, &nact, NULL);
584         sigaction( SIGTERM, NULL, &oact );
585         if (oact.sa_handler != SIG_IGN)
586           sigaction (SIGTERM, &nact, NULL);
587         nact.sa_handler = SIG_IGN;
588         sigaction (SIGPIPE, &nact, NULL);
589         sigaction (SIGINT, &nact, NULL);
590       }
591
592       if (chdir("/"))
593         {
594           log_error ("chdir to / failed: %s\n", strerror (errno));
595           exit (1);
596         }
597
598       start_command_handler (fd);
599
600       close (fd);
601     }
602   
603   return 0;
604 }
605
606 void
607 agent_exit (int rc)
608 {
609   #if 0
610 #warning no update_random_seed_file
611   update_random_seed_file();
612   #endif
613 #if 0
614   /* at this time a bit annoying */
615   if (opt.debug & DBG_MEMSTAT_VALUE)
616     {
617       gcry_control( GCRYCTL_DUMP_MEMORY_STATS );
618       gcry_control( GCRYCTL_DUMP_RANDOM_STATS );
619     }
620   if (opt.debug)
621     gcry_control (GCRYCTL_DUMP_SECMEM_STATS );
622 #endif
623   gcry_control (GCRYCTL_TERM_SECMEM );
624   rc = rc? rc : log_get_errorcount(0)? 2 : 0;
625   exit (rc);
626 }
627