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