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