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