← Back to branch summary

~ubuntu-branches/ubuntu/jaunty/gnupg2/jaunty-security

« back to all changes in this revision

Viewing changes to scd/scdaemon.c

  • Committer: Bazaar Package Importer
  • Author(s): Eric Dorland
  • Date: 2008-04-28 03:22:20 UTC
  • mfrom: (1.1.10 upstream)
  • mto: This revision was merged to the branch mainline in revision 6.
  • Revision ID: james.westby@ubuntu.com-20080428032220-a8rl6klzavd4nvr4
Tags: 2.0.9-2
http://bugs.debian.org/459462
http://bugs.debian.org/477691
http://bugs.debian.org/462951
http://bugs.debian.org/476999
* The "I've neglected you too long" release.

* debian/control: 
  - Add recommends on gnupg-agent for gpgsm and gnupg2, since they need 
    it under most circumstances. (Closes: #459462, #477691)
  - Depend on pinentry instead of recommend, and move pinentry-gtk2 to the 
    front of the alternatives list. (Closes: #462951)
* keyserver/gpgkeys_curl.c, keyserver/gpgkeys_hkp.c: Fix FTBFS with gcc
  4.3 strictness on bitfields combined with curl. (Closes: #476999)

Show diffs side-by-side

added added

removed removed

Lines of Context:
scd/scdaemon.c
47
47
#include "i18n.h"
48
48
#include "sysutils.h"
49
49
#include "app-common.h"
50
 
#ifdef HAVE_W32_SYSTEM
51
 
#include "../jnlib/w32-afunix.h"
52
 
#endif
53
50
#include "ccid-driver.h"
54
51
#include "mkdtemp.h"
55
52
#include "gc-opt-flags.h"
170
167
/* Name of the communication socket */
171
168
static char *socket_name;
172
169
 
 
170
/* We need to keep track of the server's nonces (these are dummies for
 
171
   POSIX systems). */
 
172
static assuan_sock_nonce_t socket_nonce;
173
173
 
174
174
/* Debug flag to disable the ticker.  The ticker is in fact not
175
175
   disabled but it won't perform any ticker specific actions. */
179
179
 
180
180
static char *create_socket_name (int use_standard_socket,
181
181
                                 char *standard_name, char *template);
182
 
static int create_server_socket (int is_standard_name, const char *name);
 
182
static gnupg_fd_t create_server_socket (int is_standard_name, const char *name,
 
183
                                        assuan_sock_nonce_t *nonce);
183
184
 
184
185
static void *start_connection_thread (void *arg);
185
186
static void handle_connections (int listen_fd);
310
311
  int gpgconf_list = 0;
311
312
  const char *config_filename = NULL;
312
313
  int allow_coredump = 0;
 
314
  int standard_socket = 0;
313
315
 
314
316
  set_strusage (my_strusage);
315
317
  gcry_control (GCRYCTL_SUSPEND_SECMEM_WARN);
356
358
  /* Set default options. */
357
359
  opt.pcsc_driver = DEFAULT_PCSC_DRIVER; 
358
360
 
 
361
#ifdef HAVE_W32_SYSTEM
 
362
  standard_socket = 1;  /* Under Windows we always use a standard
 
363
                           socket.  */
 
364
#endif
 
365
 
359
366
 
360
367
  shell = getenv ("SHELL");
361
368
  if (shell && strlen (shell) >= 3 && !strcmp (shell+strlen (shell)-3, "csh") )
548
555
      char *filename = NULL;
549
556
      char *filename_esc;
550
557
 
551
 
      if (!config_filename)
552
 
        filename = make_filename (opt.homedir, "scdaemon.conf", NULL );
 
558
      if (config_filename)
 
559
        filename = xstrdup (config_filename);
 
560
      else
 
561
        filename = make_filename (opt.homedir, "scdaemon.conf", NULL);
553
562
      filename_esc = percent_escape (filename, NULL);
554
563
 
555
564
      printf ("gpgconf-scdaemon.conf:%lu:\"%s\n",
621
630
         back the name of that socket. */
622
631
      if (multi_server)
623
632
        {
624
 
          socket_name = create_socket_name (0,
 
633
          socket_name = create_socket_name (standard_socket,
625
634
                                            "S.scdaemon",
626
635
                                            "/tmp/gpg-XXXXXX/S.scdaemon");
627
636
          
628
 
          fd = create_server_socket (0, socket_name);
 
637
          fd = FD2INT(create_server_socket (standard_socket,
 
638
                                            socket_name, &socket_nonce));
629
639
        }
630
640
 
631
641
      tattr = pth_attr_new();
640
650
                     strerror (errno) );
641
651
          scd_exit (2);
642
652
        }
643
 
      ctrl->thread_startup.fd = -1;
 
653
      ctrl->thread_startup.fd = GNUPG_INVALID_FD;
644
654
      if ( !pth_spawn (tattr, start_connection_thread, ctrl) )
645
655
        {
646
656
          log_error ("error spawning pipe connection handler: %s\n",
649
659
          scd_exit (2);
650
660
        }
651
661
 
 
662
      /* We run handle_connection to wait for the shutdown signal and
 
663
         to run the ticker stuff.  */
652
664
      handle_connections (fd);
653
665
      if (fd != -1)
654
666
        close (fd);
661
673
  else
662
674
    { /* Regular server mode */
663
675
      int fd;
 
676
#ifndef HAVE_W32_SYSTEM
664
677
      pid_t pid;
665
678
      int i;
 
679
#endif
666
680
 
667
681
      /* Create the socket.  */
668
 
      socket_name = create_socket_name (0,
 
682
      socket_name = create_socket_name (standard_socket,
669
683
                                        "S.scdaemon",
670
684
                                        "/tmp/gpg-XXXXXX/S.scdaemon");
671
685
 
672
 
      fd = create_server_socket (0, socket_name);
 
686
      fd = FD2INT (create_server_socket (standard_socket,
 
687
                                         socket_name, &socket_nonce));
673
688
 
674
689
 
675
690
      fflush (NULL);
930
945
/* Create a Unix domain socket with NAME.  IS_STANDARD_NAME indicates
931
946
   whether a non-random socket is used.  Returns the file descriptor
932
947
   or terminates the process in case of an error. */
933
 
static int
934
 
create_server_socket (int is_standard_name, const char *name)
 
948
static gnupg_fd_t
 
949
create_server_socket (int is_standard_name, const char *name,
 
950
                      assuan_sock_nonce_t *nonce)
935
951
{
936
952
  struct sockaddr_un *serv_addr;
937
953
  socklen_t len;
938
 
  int fd;
 
954
  gnupg_fd_t fd;
939
955
  int rc;
940
956
 
941
 
#ifdef HAVE_W32_SYSTEM
942
 
  fd = _w32_sock_new (AF_UNIX, SOCK_STREAM, 0);
943
 
#else
944
 
  fd = socket (AF_UNIX, SOCK_STREAM, 0);
945
 
#endif
946
 
  if (fd == -1)
 
957
  fd = assuan_sock_new (AF_UNIX, SOCK_STREAM, 0);
 
958
  if (fd == GNUPG_INVALID_FD)
947
959
    {
948
960
      log_error (_("can't create socket: %s\n"), strerror (errno));
949
961
      scd_exit (2);
957
969
  len = (offsetof (struct sockaddr_un, sun_path)
958
970
         + strlen (serv_addr->sun_path) + 1);
959
971
 
960
 
#ifdef HAVE_W32_SYSTEM
961
 
  rc = _w32_sock_bind (fd, (struct sockaddr*) serv_addr, len);
962
 
  if (is_standard_name && rc == -1 )
963
 
    {
964
 
      remove (name);
965
 
      rc = bind (fd, (struct sockaddr*) serv_addr, len);
966
 
    }
967
 
#else
968
 
  rc = bind (fd, (struct sockaddr*) serv_addr, len);
 
972
  rc = assuan_sock_bind (fd, (struct sockaddr*) serv_addr, len);
969
973
  if (is_standard_name && rc == -1 && errno == EADDRINUSE)
970
974
    {
971
975
      remove (name);
972
 
      rc = bind (fd, (struct sockaddr*) serv_addr, len);
 
976
      rc = assuan_sock_bind (fd, (struct sockaddr*) serv_addr, len);
973
977
    }
974
 
#endif
975
 
  if (rc == -1)
 
978
  if (rc != -1 
 
979
      && (rc=assuan_sock_get_nonce ((struct sockaddr*)serv_addr, len, nonce)))
 
980
    log_error (_("error getting nonce for the socket\n"));
 
981
 if (rc == -1)
976
982
    {
977
983
      log_error (_("error binding socket to `%s': %s\n"),
978
 
                 serv_addr->sun_path, strerror (errno));
979
 
      close (fd);
 
984
                 serv_addr->sun_path,
 
985
                 gpg_strerror (gpg_error_from_syserror ()));
 
986
      assuan_sock_close (fd);
980
987
      scd_exit (2);
981
988
    }
982
989
 
983
 
  if (listen (fd, 5 ) == -1)
 
990
  if (listen (FD2INT(fd), 5 ) == -1)
984
991
    {
985
 
      log_error (_("listen() failed: %s\n"), strerror (errno));
986
 
      close (fd);
 
992
      log_error (_("listen() failed: %s\n"),
 
993
                 gpg_strerror (gpg_error_from_syserror ()));
 
994
      assuan_sock_close (fd);
987
995
      scd_exit (2);
988
996
    }
989
997
          
1001
1009
{
1002
1010
  ctrl_t ctrl = arg;
1003
1011
 
 
1012
  if (ctrl->thread_startup.fd != GNUPG_INVALID_FD
 
1013
      && assuan_sock_check_nonce (ctrl->thread_startup.fd, &socket_nonce))
 
1014
    {
 
1015
      log_info (_("error reading nonce on fd %d: %s\n"), 
 
1016
                FD2INT(ctrl->thread_startup.fd), strerror (errno));
 
1017
      assuan_sock_close (ctrl->thread_startup.fd);
 
1018
      xfree (ctrl);
 
1019
      return NULL;
 
1020
    }
 
1021
 
1004
1022
  scd_init_default_ctrl (ctrl);
1005
1023
  if (opt.verbose)
1006
 
    log_info (_("handler for fd %d started\n"), ctrl->thread_startup.fd);
 
1024
    log_info (_("handler for fd %d started\n"),
 
1025
              FD2INT(ctrl->thread_startup.fd));
1007
1026
 
1008
 
  scd_command_handler (ctrl, ctrl->thread_startup.fd);
 
1027
  scd_command_handler (ctrl, FD2INT(ctrl->thread_startup.fd));
1009
1028
 
1010
1029
  if (opt.verbose)
1011
 
    log_info (_("handler for fd %d terminated\n"), ctrl->thread_startup.fd);
 
1030
    log_info (_("handler for fd %d terminated\n"),
 
1031
              FD2INT (ctrl->thread_startup.fd));
1012
1032
 
1013
1033
  /* If this thread is the pipe connection thread, flag that a
1014
1034
     shutdown is required.  With the next ticker event and given that
1015
1035
     no other connections are running the shutdown will then
1016
1036
     happen. */
1017
 
  if (ctrl->thread_startup.fd == -1)
 
1037
  if (ctrl->thread_startup.fd == GNUPG_INVALID_FD)
1018
1038
    shutdown_pending = 1;
1019
1039
  
1020
1040
  scd_deinit_default_ctrl (ctrl);
1160
1180
              snprintf (threadname, sizeof threadname-1, "conn fd=%d", fd);
1161
1181
              threadname[sizeof threadname -1] = 0;
1162
1182
              pth_attr_set (tattr, PTH_ATTR_NAME, threadname);
1163
 
              ctrl->thread_startup.fd = fd;
 
1183
              ctrl->thread_startup.fd = INT2FD (fd);
1164
1184
              if (!pth_spawn (tattr, start_connection_thread, ctrl))
1165
1185
                {
1166
1186
                  log_error ("error spawning connection handler: %s\n",