support numeric debug levels.
[gnupg.git] / scd / scdaemon.c
1 /* scdaemon.c  -  The GnuPG Smartcard Daemon
2  * Copyright (C) 2001, 2002, 2004, 2005, 
3  *               2007, 2008, 2009 Free Software Foundation, Inc.
4  *
5  * This file is part of GnuPG.
6  *
7  * GnuPG is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 3 of the License, or
10  * (at your option) any later version.
11  *
12  * GnuPG is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, see <http://www.gnu.org/licenses/>.
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 #ifndef HAVE_W32_SYSTEM
33 #include <sys/socket.h>
34 #include <sys/un.h>
35 #endif /*HAVE_W32_SYSTEM*/
36 #include <unistd.h>
37 #include <signal.h>
38 #include <pth.h>
39
40 #define JNLIB_NEED_LOG_LOGV
41 #define JNLIB_NEED_AFLOCAL
42 #include "scdaemon.h"
43 #include <ksba.h>
44 #include <gcrypt.h>
45
46 #include <assuan.h> /* malloc hooks */
47
48 #include "i18n.h"
49 #include "sysutils.h"
50 #include "app-common.h"
51 #include "apdu.h"
52 #include "ccid-driver.h"
53 #include "mkdtemp.h"
54 #include "gc-opt-flags.h"
55
56 enum cmd_and_opt_values 
57 { aNull = 0,
58   oCsh            = 'c',
59   oQuiet          = 'q',
60   oSh             = 's',
61   oVerbose        = 'v',
62   
63   oNoVerbose = 500,
64   aGPGConfList,
65   aGPGConfTest,
66   oOptions,
67   oDebug,
68   oDebugAll,
69   oDebugLevel,
70   oDebugWait,
71   oDebugAllowCoreDump,
72   oDebugCCIDDriver,
73   oDebugLogTid,
74   oNoGreeting,
75   oNoOptions,
76   oHomedir,
77   oNoDetach,
78   oNoGrab,
79   oLogFile,
80   oServer,
81   oMultiServer,
82   oDaemon,
83   oBatch,
84   oReaderPort,
85   oCardTimeout,
86   octapiDriver,
87   opcscDriver,
88   oDisableCCID,
89   oDisableOpenSC,
90   oDisableKeypad,
91   oAllowAdmin,
92   oDenyAdmin,
93   oDisableApplication,
94   oDebugDisableTicker
95 };
96
97
98
99 static ARGPARSE_OPTS opts[] = {
100   ARGPARSE_c (aGPGConfList, "gpgconf-list", "@"),
101   ARGPARSE_c (aGPGConfTest, "gpgconf-test", "@"),
102   
103   ARGPARSE_group (301, N_("@Options:\n ")),
104
105   ARGPARSE_s_n (oServer,"server", N_("run in server mode (foreground)")),
106   ARGPARSE_s_n (oMultiServer, "multi-server", 
107                 N_("run in multi server mode (foreground)")),
108   ARGPARSE_s_n (oDaemon, "daemon", N_("run in daemon mode (background)")),
109   ARGPARSE_s_n (oVerbose, "verbose", N_("verbose")),
110   ARGPARSE_s_n (oQuiet, "quiet", N_("be somewhat more quiet")),
111   ARGPARSE_s_n (oSh,    "sh", N_("sh-style command output")),
112   ARGPARSE_s_n (oCsh,   "csh", N_("csh-style command output")),
113   ARGPARSE_s_s (oOptions, "options", N_("|FILE|read options from FILE")),
114   ARGPARSE_p_u (oDebug, "debug", "@"),
115   ARGPARSE_s_n (oDebugAll, "debug-all", "@"),
116   ARGPARSE_s_s (oDebugLevel, "debug-level" ,
117                 N_("|LEVEL|set the debugging level to LEVEL")),
118   ARGPARSE_s_i (oDebugWait, "debug-wait", "@"),
119   ARGPARSE_s_n (oDebugAllowCoreDump, "debug-allow-core-dump", "@"),
120   ARGPARSE_s_n (oDebugCCIDDriver, "debug-ccid-driver", "@"),
121   ARGPARSE_s_n (oDebugDisableTicker, "debug-disable-ticker", "@"),
122   ARGPARSE_s_n (oDebugLogTid, "debug-log-tid", "@"),
123   ARGPARSE_s_n (oNoDetach, "no-detach", N_("do not detach from the console")),
124   ARGPARSE_s_s (oLogFile,  "log-file", N_("|FILE|write a log to FILE")),
125   ARGPARSE_s_s (oReaderPort, "reader-port", 
126                 N_("|N|connect to reader at port N")),
127   ARGPARSE_s_s (octapiDriver, "ctapi-driver", 
128                 N_("|NAME|use NAME as ct-API driver")),
129   ARGPARSE_s_s (opcscDriver, "pcsc-driver", 
130                 N_("|NAME|use NAME as PC/SC driver")),
131   ARGPARSE_s_n (oDisableCCID, "disable-ccid",
132 #ifdef HAVE_LIBUSB
133                                     N_("do not use the internal CCID driver")
134 #else
135                                     "@"
136 #endif
137                 /* end --disable-ccid */),
138   ARGPARSE_s_u (oCardTimeout, "card-timeout", 
139                 N_("|N|disconnect the card after N seconds of inactivity")),
140   ARGPARSE_s_n (oDisableKeypad, "disable-keypad", 
141                 N_("do not use a reader's keypad")),
142   ARGPARSE_s_n (oAllowAdmin, "allow-admin", "@"),
143   ARGPARSE_s_n (oDenyAdmin, "deny-admin", 
144                 N_("deny the use of admin card commands")),
145   ARGPARSE_s_s (oDisableApplication, "disable-application", "@"),
146   
147   ARGPARSE_end ()
148 };
149
150
151 /* The card driver we use by default for PC/SC.  */
152 #if defined(HAVE_W32_SYSTEM) || defined(__CYGWIN__)
153 #define DEFAULT_PCSC_DRIVER "winscard.dll"
154 #elif defined(__APPLE__)
155 #define DEFAULT_PCSC_DRIVER "/System/Library/Frameworks/PCSC.framework/PCSC"
156 #elif defined(__GLIBC__)
157 #define DEFAULT_PCSC_DRIVER "libpcsclite.so.1"
158 #else
159 #define DEFAULT_PCSC_DRIVER "libpcsclite.so"
160 #endif
161
162 /* The timer tick used for housekeeping stuff.  We poll every 500ms to
163    let the user immediately know a status change.
164
165    This is not too good for power saving but given that there is no
166    easy way to block on card status changes it is the best we can do.
167    For PC/SC we could in theory use an extra thread to wait for status
168    changes but that requires a native thread because there is no way
169    to make the underlying PC/SC card change function block using a Pth
170    mechanism.  Given that a native thread could only be used under W32
171    we don't do that at all.  */
172 #define TIMERTICK_INTERVAL_SEC     (0)
173 #define TIMERTICK_INTERVAL_USEC    (500000)
174
175 /* Flag to indicate that a shutdown was requested. */
176 static int shutdown_pending;
177
178 /* It is possible that we are currently running under setuid permissions */
179 static int maybe_setuid = 1;
180
181 /* Flag telling whether we are running as a pipe server.  */
182 static int pipe_server;
183
184 /* Name of the communication socket */
185 static char *socket_name;
186
187 /* We need to keep track of the server's nonces (these are dummies for
188    POSIX systems). */
189 static assuan_sock_nonce_t socket_nonce;
190
191 /* Debug flag to disable the ticker.  The ticker is in fact not
192    disabled but it won't perform any ticker specific actions. */
193 static int ticker_disabled;
194
195
196 \f
197 static char *create_socket_name (int use_standard_socket,
198                                  char *standard_name, char *template);
199 static gnupg_fd_t create_server_socket (int is_standard_name, const char *name,
200                                         assuan_sock_nonce_t *nonce);
201
202 static void *start_connection_thread (void *arg);
203 static void handle_connections (int listen_fd);
204
205 /* Pth wrapper function definitions. */
206 ASSUAN_SYSTEM_PTH_IMPL;
207
208 GCRY_THREAD_OPTION_PTH_IMPL;
209 static int fixed_gcry_pth_init (void)
210 {
211   return pth_self ()? 0 : (pth_init () == FALSE) ? errno : 0;
212 }
213
214
215 \f
216 static char *
217 make_libversion (const char *libname, const char *(*getfnc)(const char*))
218 {
219   const char *s;
220   char *result;
221   
222   if (maybe_setuid)
223     {
224       gcry_control (GCRYCTL_INIT_SECMEM, 0, 0);  /* Drop setuid. */
225       maybe_setuid = 0;
226     }
227   s = getfnc (NULL);
228   result = xmalloc (strlen (libname) + 1 + strlen (s) + 1);
229   strcpy (stpcpy (stpcpy (result, libname), " "), s);
230   return result;
231 }
232
233
234 static const char *
235 my_strusage (int level)
236 {
237   static char *ver_gcry, *ver_ksba;
238   const char *p;
239
240   switch (level)
241     {
242     case 11: p = "scdaemon (GnuPG)";
243       break;
244     case 13: p = VERSION; break;
245     case 17: p = PRINTABLE_OS_NAME; break;
246     case 19: p = _("Please report bugs to <@EMAIL@>.\n"); break;
247
248     case 20:
249       if (!ver_gcry)
250         ver_gcry = make_libversion ("libgcrypt", gcry_check_version);
251       p = ver_gcry;
252       break;
253     case 21:
254       if (!ver_ksba)
255         ver_ksba = make_libversion ("libksba", ksba_check_version);
256       p = ver_ksba;
257       break;
258     case 1:
259     case 40: p =  _("Usage: scdaemon [options] (-h for help)");
260       break;
261     case 41: p =  _("Syntax: scdaemon [options] [command [args]]\n"
262                     "Smartcard daemon for GnuPG\n");
263     break;
264     
265     default: p = NULL;
266     }
267   return p;
268 }
269
270
271 static unsigned long
272 tid_log_callback (void)
273 {
274 #ifdef PTH_HAVE_PTH_THREAD_ID
275   return pth_thread_id ();
276 #else
277   return (unsigned long)pth_self ();
278 #endif
279 }
280
281
282
283
284
285 /* Setup the debugging.  With a LEVEL of NULL only the active debug
286    flags are propagated to the subsystems.  With LEVEL set, a specific
287    set of debug flags is set; thus overriding all flags already
288    set. */
289 static void
290 set_debug (const char *level)
291 {
292   int numok = (level && digitp (level));
293   int numlvl = numok? atoi (level) : 0;
294
295   if (!level)
296     ;
297   else if (!strcmp (level, "none") || (numok && numlvl < 1))
298     opt.debug = 0;
299   else if (!strcmp (level, "basic") || (numok && numlvl <= 2))
300     opt.debug = DBG_ASSUAN_VALUE;
301   else if (!strcmp (level, "advanced") || (numok && numlvl <= 5))
302     opt.debug = DBG_ASSUAN_VALUE|DBG_COMMAND_VALUE;
303   else if (!strcmp (level, "expert") || (numok && numlvl <= 8))
304     opt.debug = (DBG_ASSUAN_VALUE|DBG_COMMAND_VALUE
305                  |DBG_CACHE_VALUE|DBG_CARD_IO_VALUE);
306   else if (!strcmp (level, "guru") || numok)
307     {
308       opt.debug = ~0;
309       /* Unless the "guru" string has been used we don't want to allow
310          hashing debugging.  The rationale is that people tend to
311          select the highest debug value and would then clutter their
312          disk with debug files which may reveal confidential data.  */ 
313       if (numok)
314         opt.debug &= ~(DBG_HASHING_VALUE);
315     }
316   else
317     {
318       log_error (_("invalid debug-level `%s' given\n"), level);
319       scd_exit(2);
320     }
321
322
323   if (opt.debug && !opt.verbose)
324     opt.verbose = 1;
325   if (opt.debug && opt.quiet)
326     opt.quiet = 0;
327
328   if (opt.debug & DBG_MPI_VALUE)
329     gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 2);
330   if (opt.debug & DBG_CRYPTO_VALUE )
331     gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 1);
332   gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
333
334   if (opt.debug)
335     log_info ("enabled debug flags:%s%s%s%s%s%s%s%s%s\n",
336               (opt.debug & DBG_COMMAND_VALUE)? " command":"",    
337               (opt.debug & DBG_MPI_VALUE    )? " mpi":"",    
338               (opt.debug & DBG_CRYPTO_VALUE )? " crypto":"",    
339               (opt.debug & DBG_MEMORY_VALUE )? " memory":"", 
340               (opt.debug & DBG_CACHE_VALUE  )? " cache":"", 
341               (opt.debug & DBG_MEMSTAT_VALUE)? " memstat":"", 
342               (opt.debug & DBG_HASHING_VALUE)? " hashing":"", 
343               (opt.debug & DBG_ASSUAN_VALUE )? " assuan":"",
344               (opt.debug & DBG_CARD_IO_VALUE)? " cardio":"");
345 }
346  
347
348
349 static void
350 cleanup (void)
351 {
352   if (socket_name && *socket_name)
353     {
354       char *p;
355
356       remove (socket_name);
357       p = strrchr (socket_name, '/');
358       if (p)
359         {
360           *p = 0;
361           rmdir (socket_name);
362           *p = '/';
363         }
364       *socket_name = 0;
365     }
366 }
367
368
369
370 int
371 main (int argc, char **argv )
372 {
373   ARGPARSE_ARGS pargs;
374   int orig_argc;
375   gpg_error_t err;
376   int may_coredump;
377   char **orig_argv;
378   FILE *configfp = NULL;
379   char *configname = NULL;
380   const char *shell;
381   unsigned int configlineno;
382   int parse_debug = 0;
383   const char *debug_level = NULL;
384   int default_config =1;
385   int greeting = 0;
386   int nogreeting = 0;
387   int multi_server = 0;
388   int is_daemon = 0;
389   int nodetach = 0;
390   int csh_style = 0;
391   char *logfile = NULL;
392   int debug_wait = 0;
393   int gpgconf_list = 0;
394   const char *config_filename = NULL;
395   int allow_coredump = 0;
396   int standard_socket = 0;
397   struct assuan_malloc_hooks malloc_hooks;
398   
399   set_strusage (my_strusage);
400   gcry_control (GCRYCTL_SUSPEND_SECMEM_WARN);
401   /* Please note that we may running SUID(ROOT), so be very CAREFUL
402      when adding any stuff between here and the call to INIT_SECMEM()
403      somewhere after the option parsing */
404   log_set_prefix ("scdaemon", 1|4); 
405
406   /* Make sure that our subsystems are ready.  */
407   i18n_init ();
408   init_common_subsystems ();
409
410
411   /* Libgcrypt requires us to register the threading model first.
412      Note that this will also do the pth_init. */
413   gcry_threads_pth.init = fixed_gcry_pth_init;
414   err = gcry_control (GCRYCTL_SET_THREAD_CBS, &gcry_threads_pth);
415   if (err)
416     {
417       log_fatal ("can't register GNU Pth with Libgcrypt: %s\n",
418                  gpg_strerror (err));
419     }
420
421   /* Check that the libraries are suitable.  Do it here because
422      the option parsing may need services of the library */
423   if (!gcry_check_version (NEED_LIBGCRYPT_VERSION) )
424     {
425       log_fatal (_("%s is too old (need %s, have %s)\n"), "libgcrypt",
426                  NEED_LIBGCRYPT_VERSION, gcry_check_version (NULL) );
427     }
428
429   ksba_set_malloc_hooks (gcry_malloc, gcry_realloc, gcry_free);
430
431   malloc_hooks.malloc = gcry_malloc;
432   malloc_hooks.realloc = gcry_realloc;
433   malloc_hooks.free = gcry_free;
434   assuan_set_malloc_hooks (&malloc_hooks);
435   assuan_set_assuan_log_prefix (log_get_prefix (NULL));
436   assuan_set_gpg_err_source (GPG_ERR_SOURCE_DEFAULT);
437   assuan_set_system_hooks (ASSUAN_SYSTEM_PTH);
438   assuan_sock_init ();
439
440   setup_libgcrypt_logging ();
441   gcry_control (GCRYCTL_USE_SECURE_RNDPOOL);
442
443   may_coredump = disable_core_dumps ();
444
445   /* Set default options. */
446   opt.allow_admin = 1;
447   opt.pcsc_driver = DEFAULT_PCSC_DRIVER; 
448
449 #ifdef HAVE_W32_SYSTEM
450   standard_socket = 1;  /* Under Windows we always use a standard
451                            socket.  */
452 #endif
453
454
455   shell = getenv ("SHELL");
456   if (shell && strlen (shell) >= 3 && !strcmp (shell+strlen (shell)-3, "csh") )
457     csh_style = 1;
458   
459   opt.homedir = default_homedir ();
460
461   /* Check whether we have a config file on the commandline */
462   orig_argc = argc;
463   orig_argv = argv;
464   pargs.argc = &argc;
465   pargs.argv = &argv;
466   pargs.flags= 1|(1<<6);  /* do not remove the args, ignore version */
467   while (arg_parse( &pargs, opts))
468     {
469       if (pargs.r_opt == oDebug || pargs.r_opt == oDebugAll)
470         parse_debug++;
471       else if (pargs.r_opt == oOptions)
472         { /* yes there is one, so we do not try the default one, but
473              read the option file when it is encountered at the
474              commandline */
475           default_config = 0;
476         }
477         else if (pargs.r_opt == oNoOptions)
478           default_config = 0; /* --no-options */
479         else if (pargs.r_opt == oHomedir)
480           opt.homedir = pargs.r.ret_str;
481     }
482
483   /* initialize the secure memory. */
484   gcry_control (GCRYCTL_INIT_SECMEM, 16384, 0);
485   maybe_setuid = 0;
486
487   /* 
488      Now we are working under our real uid 
489   */
490
491
492   if (default_config)
493     configname = make_filename (opt.homedir, "scdaemon.conf", NULL );
494
495   
496   argc = orig_argc;
497   argv = orig_argv;
498   pargs.argc = &argc;
499   pargs.argv = &argv;
500   pargs.flags=  1;  /* do not remove the args */
501  next_pass:
502   if (configname)
503     {
504       configlineno = 0;
505       configfp = fopen (configname, "r");
506       if (!configfp)
507         {
508           if (default_config)
509             {
510               if( parse_debug )
511                 log_info (_("NOTE: no default option file `%s'\n"),
512                           configname );
513             }
514           else
515             {
516               log_error (_("option file `%s': %s\n"),
517                          configname, strerror(errno) );
518               exit(2);
519             }
520           xfree (configname); 
521           configname = NULL;
522         }
523       if (parse_debug && configname )
524         log_info (_("reading options from `%s'\n"), configname );
525       default_config = 0;
526     }
527
528   while (optfile_parse( configfp, configname, &configlineno, &pargs, opts) )
529     {
530       switch (pargs.r_opt)
531         {
532         case aGPGConfList: gpgconf_list = 1; break;
533         case aGPGConfTest: gpgconf_list = 2; break;
534         case oQuiet: opt.quiet = 1; break;
535         case oVerbose: opt.verbose++; break;
536         case oBatch: opt.batch=1; break;
537
538         case oDebug: opt.debug |= pargs.r.ret_ulong; break;
539         case oDebugAll: opt.debug = ~0; break;
540         case oDebugLevel: debug_level = pargs.r.ret_str; break;
541         case oDebugWait: debug_wait = pargs.r.ret_int; break;
542         case oDebugAllowCoreDump:
543           enable_core_dumps ();
544           allow_coredump = 1;
545           break;
546         case oDebugCCIDDriver: 
547 #ifdef HAVE_LIBUSB
548           ccid_set_debug_level (ccid_set_debug_level (-1)+1);
549 #endif /*HAVE_LIBUSB*/
550           break;
551         case oDebugDisableTicker: ticker_disabled = 1; break;
552         case oDebugLogTid: 
553           log_set_get_tid_callback (tid_log_callback);
554           break;
555
556         case oOptions:
557           /* config files may not be nested (silently ignore them) */
558           if (!configfp)
559             {
560                 xfree(configname);
561                 configname = xstrdup(pargs.r.ret_str);
562                 goto next_pass;
563             }
564           break;
565         case oNoGreeting: nogreeting = 1; break;
566         case oNoVerbose: opt.verbose = 0; break;
567         case oNoOptions: break; /* no-options */
568         case oHomedir: opt.homedir = pargs.r.ret_str; break;
569         case oNoDetach: nodetach = 1; break;
570         case oLogFile: logfile = pargs.r.ret_str; break;
571         case oCsh: csh_style = 1; break;
572         case oSh: csh_style = 0; break;
573         case oServer: pipe_server = 1; break;
574         case oMultiServer: pipe_server = 1; multi_server = 1; break;
575         case oDaemon: is_daemon = 1; break;
576
577         case oReaderPort: opt.reader_port = pargs.r.ret_str; break;
578         case octapiDriver: opt.ctapi_driver = pargs.r.ret_str; break;
579         case opcscDriver: opt.pcsc_driver = pargs.r.ret_str; break;
580         case oDisableCCID: opt.disable_ccid = 1; break;
581         case oDisableOpenSC: break;
582
583         case oDisableKeypad: opt.disable_keypad = 1; break;
584
585         case oAllowAdmin: /* Dummy because allow is now the default.  */
586           break;
587         case oDenyAdmin: opt.allow_admin = 0; break;
588           
589         case oCardTimeout: opt.card_timeout = pargs.r.ret_ulong; break;
590
591         case oDisableApplication:
592           add_to_strlist (&opt.disabled_applications, pargs.r.ret_str); 
593           break;
594
595         default: 
596           pargs.err = configfp? ARGPARSE_PRINT_WARNING:ARGPARSE_PRINT_ERROR; 
597           break;
598         }
599     }
600   if (configfp)
601     {
602       fclose( configfp );
603       configfp = NULL;
604       /* Keep a copy of the config name for use by --gpgconf-list. */
605       config_filename = configname;
606       configname = NULL;
607       goto next_pass;
608     }
609   xfree (configname);
610   configname = NULL;
611   if (log_get_errorcount(0))
612     exit(2);
613   if (nogreeting )
614     greeting = 0;
615
616   if (greeting)
617     {
618       fprintf (stderr, "%s %s; %s\n",
619                  strusage(11), strusage(13), strusage(14) );
620       fprintf (stderr, "%s\n", strusage(15) );
621     }
622 #ifdef IS_DEVELOPMENT_VERSION
623   log_info ("NOTE: this is a development version!\n");
624 #endif
625
626  
627   if (atexit (cleanup))
628     {
629       log_error ("atexit failed\n");
630       cleanup ();
631       exit (1);
632     }
633
634   set_debug (debug_level);
635
636   initialize_module_command ();
637
638   if (gpgconf_list == 2)
639     scd_exit (0);
640   if (gpgconf_list)
641     {
642       /* List options and default values in the GPG Conf format.  */
643       char *filename = NULL;
644       char *filename_esc;
645
646       if (config_filename)
647         filename = xstrdup (config_filename);
648       else
649         filename = make_filename (opt.homedir, "scdaemon.conf", NULL);
650       filename_esc = percent_escape (filename, NULL);
651
652       printf ("gpgconf-scdaemon.conf:%lu:\"%s\n",
653               GC_OPT_FLAG_DEFAULT, filename_esc);
654       xfree (filename_esc);
655       xfree (filename);
656
657       printf ("verbose:%lu:\n"
658               "quiet:%lu:\n"
659               "debug-level:%lu:\"none:\n"
660               "log-file:%lu:\n",
661               GC_OPT_FLAG_NONE,
662               GC_OPT_FLAG_NONE,
663               GC_OPT_FLAG_DEFAULT,
664               GC_OPT_FLAG_NONE );
665
666       printf ("reader-port:%lu:\n", GC_OPT_FLAG_NONE );
667       printf ("ctapi-driver:%lu:\n", GC_OPT_FLAG_NONE );
668       printf ("pcsc-driver:%lu:\"%s:\n",
669               GC_OPT_FLAG_DEFAULT, DEFAULT_PCSC_DRIVER );
670 #ifdef HAVE_LIBUSB
671       printf ("disable-ccid:%lu:\n", GC_OPT_FLAG_NONE );
672 #endif
673       printf ("deny-admin:%lu:\n", GC_OPT_FLAG_NONE );
674       printf ("disable-keypad:%lu:\n", GC_OPT_FLAG_NONE );
675       printf ("card-timeout:%lu:%d:\n", GC_OPT_FLAG_DEFAULT, 0);
676
677       scd_exit (0);
678     }
679
680   /* Now start with logging to a file if this is desired.  */
681   if (logfile)
682     {
683       log_set_file (logfile);
684       log_set_prefix (NULL, 1|2|4);
685     }
686
687   if (debug_wait && pipe_server)
688     {
689       log_debug ("waiting for debugger - my pid is %u .....\n",
690                  (unsigned int)getpid());
691       gnupg_sleep (debug_wait);
692       log_debug ("... okay\n");
693     }
694   
695   if (pipe_server)
696     { 
697       /* This is the simple pipe based server */
698       ctrl_t ctrl;
699       pth_attr_t tattr;
700       int fd = -1;
701
702 #ifndef HAVE_W32_SYSTEM
703       {
704         struct sigaction sa;
705         
706         sa.sa_handler = SIG_IGN;
707         sigemptyset (&sa.sa_mask);
708         sa.sa_flags = 0;
709         sigaction (SIGPIPE, &sa, NULL);
710       }
711 #endif
712
713       /* If --debug-allow-core-dump has been given we also need to
714          switch the working directory to a place where we can actually
715          write. */
716       if (allow_coredump)
717         {
718           if (chdir("/tmp"))
719             log_debug ("chdir to `/tmp' failed: %s\n", strerror (errno));
720           else
721             log_debug ("changed working directory to `/tmp'\n");
722         }
723
724       /* In multi server mode we need to listen on an additional
725          socket.  Create that socket now before starting the handler
726          for the pipe connection.  This allows that handler to send
727          back the name of that socket. */
728       if (multi_server)
729         {
730           socket_name = create_socket_name (standard_socket,
731                                             "S.scdaemon",
732                                             "/tmp/gpg-XXXXXX/S.scdaemon");
733           
734           fd = FD2INT(create_server_socket (standard_socket,
735                                             socket_name, &socket_nonce));
736         }
737
738       tattr = pth_attr_new();
739       pth_attr_set (tattr, PTH_ATTR_JOINABLE, 0);
740       pth_attr_set (tattr, PTH_ATTR_STACK_SIZE, 512*1024);
741       pth_attr_set (tattr, PTH_ATTR_NAME, "pipe-connection");
742
743       ctrl = xtrycalloc (1, sizeof *ctrl);
744       if ( !ctrl )
745         {
746           log_error ("error allocating connection control data: %s\n",
747                      strerror (errno) );
748           scd_exit (2);
749         }
750       ctrl->thread_startup.fd = GNUPG_INVALID_FD;
751       if ( !pth_spawn (tattr, start_connection_thread, ctrl) )
752         {
753           log_error ("error spawning pipe connection handler: %s\n",
754                      strerror (errno) );
755           xfree (ctrl);
756           scd_exit (2);
757         }
758
759       /* We run handle_connection to wait for the shutdown signal and
760          to run the ticker stuff.  */
761       handle_connections (fd);
762       if (fd != -1)
763         close (fd);
764     }
765   else if (!is_daemon)
766     {
767       log_info (_("please use the option `--daemon'"
768                   " to run the program in the background\n"));
769     }
770   else
771     { /* Regular server mode */
772       int fd;
773 #ifndef HAVE_W32_SYSTEM
774       pid_t pid;
775       int i;
776 #endif
777
778       /* Create the socket.  */
779       socket_name = create_socket_name (standard_socket,
780                                         "S.scdaemon",
781                                         "/tmp/gpg-XXXXXX/S.scdaemon");
782
783       fd = FD2INT (create_server_socket (standard_socket,
784                                          socket_name, &socket_nonce));
785
786
787       fflush (NULL);
788 #ifndef HAVE_W32_SYSTEM
789       pid = fork ();
790       if (pid == (pid_t)-1) 
791         {
792           log_fatal ("fork failed: %s\n", strerror (errno) );
793           exit (1);
794         }
795       else if (pid) 
796         { /* we are the parent */
797           char *infostr;
798           
799           close (fd);
800           
801           /* create the info string: <name>:<pid>:<protocol_version> */
802           if (estream_asprintf (&infostr, "SCDAEMON_INFO=%s:%lu:1",
803                                 socket_name, (ulong) pid) < 0)
804             {
805               log_error ("out of core\n");
806               kill (pid, SIGTERM);
807               exit (1);
808             }
809           *socket_name = 0; /* don't let cleanup() remove the socket -
810                                the child should do this from now on */
811           if (argc) 
812             { /* run the program given on the commandline */
813               if (putenv (infostr))
814                 {
815                   log_error ("failed to set environment: %s\n",
816                              strerror (errno) );
817                   kill (pid, SIGTERM );
818                   exit (1);
819                 }
820               execvp (argv[0], argv);
821               log_error ("failed to run the command: %s\n", strerror (errno));
822               kill (pid, SIGTERM);
823               exit (1);
824             }
825           else
826             {
827               /* Print the environment string, so that the caller can use
828                  shell's eval to set it */
829               if (csh_style)
830                 {
831                   *strchr (infostr, '=') = ' ';
832                   printf ( "setenv %s\n", infostr);
833                 }
834               else
835                 {
836                   printf ( "%s; export SCDAEMON_INFO;\n", infostr);
837                 }
838               xfree (infostr);
839               exit (0); 
840             }
841           /* NOTREACHED */
842         } /* end parent */
843       
844       /* This is the child. */
845
846       /* Detach from tty and put process into a new session. */
847       if (!nodetach )
848         {  
849           /* Close stdin, stdout and stderr unless it is the log stream. */
850           for (i=0; i <= 2; i++) 
851             {
852               if ( log_test_fd (i) && i != fd)
853                 close (i);
854             }
855           if (setsid() == -1)
856             {
857               log_error ("setsid() failed: %s\n", strerror(errno) );
858               cleanup ();
859               exit (1);
860             }
861         }
862
863       {
864         struct sigaction sa;
865         
866         sa.sa_handler = SIG_IGN;
867         sigemptyset (&sa.sa_mask);
868         sa.sa_flags = 0;
869         sigaction (SIGPIPE, &sa, NULL);
870       }
871
872       if (chdir("/"))
873         {
874           log_error ("chdir to / failed: %s\n", strerror (errno));
875           exit (1);
876         }
877
878 #endif /*!HAVE_W32_SYSTEM*/
879
880       handle_connections (fd);
881
882       close (fd);
883     }
884   
885   return 0;
886 }
887
888 void
889 scd_exit (int rc)
890 {
891   apdu_prepare_exit ();
892 #if 0
893 #warning no update_random_seed_file
894   update_random_seed_file();
895 #endif
896 #if 0
897   /* at this time a bit annoying */
898   if (opt.debug & DBG_MEMSTAT_VALUE)
899     {
900       gcry_control( GCRYCTL_DUMP_MEMORY_STATS );
901       gcry_control( GCRYCTL_DUMP_RANDOM_STATS );
902     }
903   if (opt.debug)
904     gcry_control (GCRYCTL_DUMP_SECMEM_STATS );
905 #endif
906   gcry_control (GCRYCTL_TERM_SECMEM );
907   rc = rc? rc : log_get_errorcount(0)? 2 : 0;
908   exit (rc);
909 }
910
911
912 static void
913 scd_init_default_ctrl (ctrl_t ctrl)
914 {
915   ctrl->reader_slot = -1;
916 }
917
918 static void
919 scd_deinit_default_ctrl (ctrl_t ctrl)
920 {
921   if (!ctrl)
922     return;
923   xfree (ctrl->in_data.value);
924   ctrl->in_data.value = NULL;
925   ctrl->in_data.valuelen = 0;
926 }
927
928
929 /* Return the name of the socket to be used to connect to this
930    process.  If no socket is available, return NULL. */
931 const char *
932 scd_get_socket_name ()
933 {
934   if (socket_name && *socket_name)
935     return socket_name;
936   return NULL;
937 }
938
939
940 static void
941 handle_signal (int signo)
942 {
943   switch (signo)
944     {
945 #ifndef HAVE_W32_SYSTEM
946     case SIGHUP:
947       log_info ("SIGHUP received - "
948                 "re-reading configuration and resetting cards\n");
949 /*       reread_configuration (); */
950       break;
951       
952     case SIGUSR1:
953       log_info ("SIGUSR1 received - printing internal information:\n");
954       pth_ctrl (PTH_CTRL_DUMPSTATE, log_get_stream ());
955       app_dump_state ();
956       break;
957
958     case SIGUSR2:
959       log_info ("SIGUSR2 received - no action defined\n");
960       break;
961
962     case SIGTERM:
963       if (!shutdown_pending)
964         log_info ("SIGTERM received - shutting down ...\n");
965       else
966         log_info ("SIGTERM received - still %ld running threads\n",
967                   pth_ctrl( PTH_CTRL_GETTHREADS ));
968       shutdown_pending++;
969       if (shutdown_pending > 2)
970         {
971           log_info ("shutdown forced\n");
972           log_info ("%s %s stopped\n", strusage(11), strusage(13) );
973           cleanup ();
974           scd_exit (0);
975         }
976       break;
977         
978     case SIGINT:
979       log_info ("SIGINT received - immediate shutdown\n");
980       log_info( "%s %s stopped\n", strusage(11), strusage(13));
981       cleanup ();
982       scd_exit (0);
983       break;
984 #endif /*!HAVE_W32_SYSTEM*/
985
986     default:
987       log_info ("signal %d received - no action defined\n", signo);
988     }
989 }
990
991
992 static void
993 handle_tick (void)
994 {
995   if (!ticker_disabled)
996     scd_update_reader_status_file ();
997 }
998
999
1000 /* Create a name for the socket.  With USE_STANDARD_SOCKET given as
1001    true using STANDARD_NAME in the home directory or if given has
1002    false from the mkdir type name TEMPLATE.  In the latter case a
1003    unique name in a unique new directory will be created.  In both
1004    cases check for valid characters as well as against a maximum
1005    allowed length for a unix domain socket is done.  The function
1006    terminates the process in case of an error.  Retunrs: Pointer to an
1007    allcoated string with the absolute name of the socket used.  */
1008 static char *
1009 create_socket_name (int use_standard_socket,
1010                     char *standard_name, char *template)
1011 {
1012   char *name, *p;
1013
1014   if (use_standard_socket)
1015     name = make_filename (opt.homedir, standard_name, NULL);
1016   else
1017     {
1018       name = xstrdup (template);
1019       p = strrchr (name, '/');
1020       if (!p)
1021         BUG ();
1022       *p = 0;
1023       if (!mkdtemp (name))
1024         {
1025           log_error (_("can't create directory `%s': %s\n"),
1026                      name, strerror (errno));
1027           scd_exit (2);
1028         }
1029       *p = '/';
1030     }
1031
1032   if (strchr (name, PATHSEP_C))
1033     {
1034       log_error (("`%s' are not allowed in the socket name\n"), PATHSEP_S);
1035       scd_exit (2);
1036     }
1037   if (strlen (name) + 1 >= DIMof (struct sockaddr_un, sun_path) )
1038     {
1039       log_error (_("name of socket too long\n"));
1040       scd_exit (2);
1041     }
1042   return name;
1043 }
1044
1045
1046
1047 /* Create a Unix domain socket with NAME.  IS_STANDARD_NAME indicates
1048    whether a non-random socket is used.  Returns the file descriptor
1049    or terminates the process in case of an error. */
1050 static gnupg_fd_t
1051 create_server_socket (int is_standard_name, const char *name,
1052                       assuan_sock_nonce_t *nonce)
1053 {
1054   struct sockaddr_un *serv_addr;
1055   socklen_t len;
1056   gnupg_fd_t fd;
1057   int rc;
1058
1059   fd = assuan_sock_new (AF_UNIX, SOCK_STREAM, 0);
1060   if (fd == GNUPG_INVALID_FD)
1061     {
1062       log_error (_("can't create socket: %s\n"), strerror (errno));
1063       scd_exit (2);
1064     }
1065
1066   serv_addr = xmalloc (sizeof (*serv_addr)); 
1067   memset (serv_addr, 0, sizeof *serv_addr);
1068   serv_addr->sun_family = AF_UNIX;
1069   assert (strlen (name) + 1 < sizeof (serv_addr->sun_path));
1070   strcpy (serv_addr->sun_path, name);
1071   len = SUN_LEN (serv_addr);
1072
1073   rc = assuan_sock_bind (fd, (struct sockaddr*) serv_addr, len);
1074   if (is_standard_name && rc == -1 && errno == EADDRINUSE)
1075     {
1076       remove (name);
1077       rc = assuan_sock_bind (fd, (struct sockaddr*) serv_addr, len);
1078     }
1079   if (rc != -1 
1080       && (rc=assuan_sock_get_nonce ((struct sockaddr*)serv_addr, len, nonce)))
1081     log_error (_("error getting nonce for the socket\n"));
1082  if (rc == -1)
1083     {
1084       log_error (_("error binding socket to `%s': %s\n"),
1085                  serv_addr->sun_path,
1086                  gpg_strerror (gpg_error_from_syserror ()));
1087       assuan_sock_close (fd);
1088       scd_exit (2);
1089     }
1090
1091   if (listen (FD2INT(fd), 5 ) == -1)
1092     {
1093       log_error (_("listen() failed: %s\n"),
1094                  gpg_strerror (gpg_error_from_syserror ()));
1095       assuan_sock_close (fd);
1096       scd_exit (2);
1097     }
1098           
1099   if (opt.verbose)
1100     log_info (_("listening on socket `%s'\n"), serv_addr->sun_path);
1101
1102   return fd;
1103 }
1104
1105
1106
1107 /* This is the standard connection thread's main function.  */
1108 static void *
1109 start_connection_thread (void *arg)
1110 {
1111   ctrl_t ctrl = arg;
1112
1113   if (ctrl->thread_startup.fd != GNUPG_INVALID_FD
1114       && assuan_sock_check_nonce (ctrl->thread_startup.fd, &socket_nonce))
1115     {
1116       log_info (_("error reading nonce on fd %d: %s\n"), 
1117                 FD2INT(ctrl->thread_startup.fd), strerror (errno));
1118       assuan_sock_close (ctrl->thread_startup.fd);
1119       xfree (ctrl);
1120       return NULL;
1121     }
1122
1123   scd_init_default_ctrl (ctrl);
1124   if (opt.verbose)
1125     log_info (_("handler for fd %d started\n"),
1126               FD2INT(ctrl->thread_startup.fd));
1127
1128   /* If this is a pipe server, we request a shutdown if the command
1129      handler asked for it.  With the next ticker event and given that
1130      no other connections are running the shutdown will then
1131      happen.  */
1132   if (scd_command_handler (ctrl, FD2INT(ctrl->thread_startup.fd))
1133       && pipe_server)
1134     shutdown_pending = 1;
1135
1136   if (opt.verbose)
1137     log_info (_("handler for fd %d terminated\n"),
1138               FD2INT (ctrl->thread_startup.fd));
1139
1140   scd_deinit_default_ctrl (ctrl);
1141   xfree (ctrl);
1142   return NULL;
1143 }
1144
1145
1146 /* Connection handler loop.  Wait for connection requests and spawn a
1147    thread after accepting a connection.  LISTEN_FD is allowed to be -1
1148    in which case this code will only do regular timeouts and handle
1149    signals. */
1150 static void
1151 handle_connections (int listen_fd)
1152 {
1153   pth_attr_t tattr;
1154   pth_event_t ev, time_ev;
1155   sigset_t sigs;
1156   int signo;
1157   struct sockaddr_un paddr;
1158   socklen_t plen;
1159   fd_set fdset, read_fdset;
1160   int ret;
1161   int fd;
1162   int nfd;
1163
1164   tattr = pth_attr_new();
1165   pth_attr_set (tattr, PTH_ATTR_JOINABLE, 0);
1166   pth_attr_set (tattr, PTH_ATTR_STACK_SIZE, 512*1024);
1167
1168 #ifndef HAVE_W32_SYSTEM /* fixme */
1169   sigemptyset (&sigs );
1170   sigaddset (&sigs, SIGHUP);
1171   sigaddset (&sigs, SIGUSR1);
1172   sigaddset (&sigs, SIGUSR2);
1173   sigaddset (&sigs, SIGINT);
1174   sigaddset (&sigs, SIGTERM);
1175   pth_sigmask (SIG_UNBLOCK, &sigs, NULL);
1176   ev = pth_event (PTH_EVENT_SIGS, &sigs, &signo);
1177 #else
1178   sigs = 0;
1179   ev = pth_event (PTH_EVENT_SIGS, &sigs, &signo);
1180 #endif
1181   time_ev = NULL;
1182
1183   FD_ZERO (&fdset);
1184   nfd = 0;
1185   if (listen_fd != -1)
1186     {
1187       FD_SET (listen_fd, &fdset);
1188       nfd = listen_fd;
1189     }
1190
1191   for (;;)
1192     {
1193       sigset_t oldsigs;
1194       
1195       if (shutdown_pending)
1196         {
1197           if (pth_ctrl (PTH_CTRL_GETTHREADS) == 1)
1198             break; /* ready */
1199
1200           /* Do not accept anymore connections but wait for existing
1201              connections to terminate. We do this by clearing out all
1202              file descriptors to wait for, so that the select will be
1203              used to just wait on a signal or timeout event. */
1204           FD_ZERO (&fdset);
1205           listen_fd = -1;
1206         }
1207
1208       /* Create a timeout event if needed.  Round it up to the next
1209          microsecond interval to help with power saving. */
1210       if (!time_ev)
1211         {
1212           pth_time_t nexttick = pth_timeout (TIMERTICK_INTERVAL_SEC,
1213                                              TIMERTICK_INTERVAL_USEC/2);
1214           if ((nexttick.tv_usec % (TIMERTICK_INTERVAL_USEC/2)) > 10)
1215             {
1216               nexttick.tv_usec = ((nexttick.tv_usec
1217                                    /(TIMERTICK_INTERVAL_USEC/2))
1218                                   + 1) * (TIMERTICK_INTERVAL_USEC/2);
1219               if (nexttick.tv_usec >= 1000000)
1220                 {
1221                   nexttick.tv_sec++;
1222                   nexttick.tv_usec = 0;
1223                 }
1224             }
1225           time_ev = pth_event (PTH_EVENT_TIME, nexttick);
1226         }
1227
1228       /* POSIX says that fd_set should be implemented as a structure,
1229          thus a simple assignment is fine to copy the entire set.  */
1230       read_fdset = fdset;
1231
1232       if (time_ev)
1233         pth_event_concat (ev, time_ev, NULL);
1234       ret = pth_select_ev (nfd+1, &read_fdset, NULL, NULL, NULL, ev);
1235       if (time_ev)
1236         pth_event_isolate (time_ev);
1237
1238       if (ret == -1)
1239         {
1240           if (pth_event_occurred (ev)
1241               || (time_ev && pth_event_occurred (time_ev)))
1242             {
1243               if (pth_event_occurred (ev))
1244                 handle_signal (signo);
1245               if (time_ev && pth_event_occurred (time_ev))
1246                 {
1247                   pth_event_free (time_ev, PTH_FREE_ALL);
1248                   time_ev = NULL;
1249                   handle_tick ();
1250                 }
1251               continue;
1252             }
1253           log_error (_("pth_select failed: %s - waiting 1s\n"),
1254                      strerror (errno));
1255           pth_sleep (1);
1256           continue;
1257         }
1258
1259       if (pth_event_occurred (ev))
1260         {
1261           handle_signal (signo);
1262         }
1263
1264       if (time_ev && pth_event_occurred (time_ev))
1265         {
1266           pth_event_free (time_ev, PTH_FREE_ALL);
1267           time_ev = NULL;
1268           handle_tick ();
1269         }
1270
1271       /* We now might create new threads and because we don't want any
1272          signals - we are handling here - to be delivered to a new
1273          thread. Thus we need to block those signals. */
1274       pth_sigmask (SIG_BLOCK, &sigs, &oldsigs);
1275
1276       if (listen_fd != -1 && FD_ISSET (listen_fd, &read_fdset))
1277         {
1278           ctrl_t ctrl;
1279
1280           plen = sizeof paddr;
1281           fd = pth_accept (listen_fd, (struct sockaddr *)&paddr, &plen);
1282           if (fd == -1)
1283             {
1284               log_error ("accept failed: %s\n", strerror (errno));
1285             }
1286           else if ( !(ctrl = xtrycalloc (1, sizeof *ctrl)) )
1287             {
1288               log_error ("error allocating connection control data: %s\n",
1289                          strerror (errno) );
1290               close (fd);
1291             }
1292           else
1293             {
1294               char threadname[50];
1295
1296               snprintf (threadname, sizeof threadname-1, "conn fd=%d", fd);
1297               threadname[sizeof threadname -1] = 0;
1298               pth_attr_set (tattr, PTH_ATTR_NAME, threadname);
1299               ctrl->thread_startup.fd = INT2FD (fd);
1300               if (!pth_spawn (tattr, start_connection_thread, ctrl))
1301                 {
1302                   log_error ("error spawning connection handler: %s\n",
1303                              strerror (errno) );
1304                   xfree (ctrl);
1305                   close (fd);
1306                 }
1307             }
1308           fd = -1;
1309         }
1310
1311       /* Restore the signal mask. */
1312       pth_sigmask (SIG_SETMASK, &oldsigs, NULL);
1313
1314     }
1315
1316   pth_event_free (ev, PTH_FREE_ALL);
1317   if (time_ev)
1318     pth_event_free (time_ev, PTH_FREE_ALL);
1319   cleanup ();
1320   log_info (_("%s %s stopped\n"), strusage(11), strusage(13));
1321 }
1322
1323