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