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