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