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