assuan/src/assuan-uds.c

   1 /* assuan-uds.c - Assuan unix domain socket utilities
   2  * Copyright (C) 2006 Free Software Foundation, Inc.
   3  *
   4  * This file is part of Assuan.
   5  *
   6  * Assuan is free software; you can redistribute it and/or modify it
   7  * under the terms of the GNU Lesser General Public License as
   8  * published by the Free Software Foundation; either version 2.1 of
   9  * the License, or (at your option) any later version.
  10  *
  11  * Assuan is distributed in the hope that it will be useful, but
  12  * WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this program; if not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 #ifdef HAVE_CONFIG_H
  21 #include <config.h>
  22 #endif
  23
  24 #include <stdlib.h>
  25 #include <stddef.h>
  26 #include <stdio.h>
  27 #include <errno.h>
  28 #include <sys/types.h>
  29 #ifndef HAVE_W32_SYSTEM
  30 #include <sys/socket.h>
  31 #include <sys/un.h>
  32 #else
  33 #include <windows.h>
  34 #endif
  35 #if HAVE_SYS_UIO_H
  36 #include <sys/uio.h>
  37 #endif
  38 #include <unistd.h>
  39 #include <fcntl.h>
  40 #include <string.h>
  41 #include <assert.h>
  42
  43 #include "assuan-defs.h"
  44
  45 #ifdef USE_DESCRIPTOR_PASSING
  46 /* Provide replacement for missing CMSG maccros.  We assume that
  47    size_t matches the alignment requirement. */
  48 #define MY_ALIGN(n) ((((n))+ sizeof(size_t)-1) & (size_t)~(sizeof(size_t)-1))
  49 #ifndef CMSG_SPACE
  50 #define CMSG_SPACE(n) (MY_ALIGN(sizeof(struct cmsghdr)) + MY_ALIGN((n)))
  51 #endif
  52 #ifndef CMSG_LEN
  53 #define CMSG_LEN(n) (MY_ALIGN(sizeof(struct cmsghdr)) + (n))
  54 #endif
  55 #ifndef CMSG_FIRSTHDR
  56 #define CMSG_FIRSTHDR(mhdr) \
  57   ((size_t)(mhdr)->msg_controllen >= sizeof (struct cmsghdr)                  \
  58    ? (struct cmsghdr*) (mhdr)->msg_control : (struct cmsghdr*)NULL)
  59 #endif
  60 #ifndef CMSG_DATA
  61 #define CMSG_DATA(cmsg) ((unsigned char*)((struct cmsghdr*)(cmsg)+1))
  62 #endif
  63 #endif /*USE_DESCRIPTOR_PASSING*/
  64
  65
  66 /* Read from a unix domain socket using sendmsg.
  67
  68    FIXME: We don't need the buffering. It is a leftover from the time
  69    when we used datagrams. */
  70 static ssize_t
  71 uds_reader (assuan_context_t ctx, void *buf, size_t buflen)
  72 {
  73 #ifndef HAVE_W32_SYSTEM
  74   int len = ctx->uds.buffersize;
  75
  76   if (!ctx->uds.bufferallocated)
  77     {
  78       ctx->uds.buffer = xtrymalloc (2048);
  79       if (!ctx->uds.buffer)
  80         return _assuan_error (ASSUAN_Out_Of_Core);
  81       ctx->uds.bufferallocated = 2048;
  82     }
  83
  84   while (!len)  /* No data is buffered.  */
  85     {
  86       struct msghdr msg;
  87       struct iovec iovec;
  88 #ifdef USE_DESCRIPTOR_PASSING
  89       union {
  90         struct cmsghdr cm;
  91         char control[CMSG_SPACE(sizeof (int))];
  92       } control_u;
  93       struct cmsghdr *cmptr;
  94 #endif /*USE_DESCRIPTOR_PASSING*/
  95
  96       memset (&msg, 0, sizeof (msg));
  97
  98       msg.msg_name = NULL;
  99       msg.msg_namelen = 0;
 100       msg.msg_iov = &iovec;
 101       msg.msg_iovlen = 1;
 102       iovec.iov_base = ctx->uds.buffer;
 103       iovec.iov_len = ctx->uds.bufferallocated;
 104 #ifdef USE_DESCRIPTOR_PASSING
 105       msg.msg_control = control_u.control;
 106       msg.msg_controllen = sizeof (control_u.control);
 107 #endif
 108
 109       len = _assuan_simple_recvmsg (ctx, &msg);
 110       if (len < 0)
 111         return -1;
 112       if (len == 0)
 113         return 0;
 114
 115       ctx->uds.buffersize = len;
 116       ctx->uds.bufferoffset = 0;
 117
 118 #ifdef USE_DESCRIPTOR_PASSING
 119       cmptr = CMSG_FIRSTHDR (&msg);
 120       if (cmptr && cmptr->cmsg_len == CMSG_LEN (sizeof(int)))
 121         {
 122           if (cmptr->cmsg_level != SOL_SOCKET
 123               || cmptr->cmsg_type != SCM_RIGHTS)
 124             _assuan_log_printf ("unexpected ancillary data received\n");
 125           else
 126             {
 127               int fd = *((int*)CMSG_DATA (cmptr));
 128
 129               if (ctx->uds.pendingfdscount >= DIM (ctx->uds.pendingfds))
 130                 {
 131                   _assuan_log_printf ("too many descriptors pending - "
 132                                       "closing received descriptor %d\n", fd);
 133                   _assuan_close (fd);
 134                 }
 135               else
 136                 ctx->uds.pendingfds[ctx->uds.pendingfdscount++] = fd;
 137             }
 138         }
 139 #endif /*USE_DESCRIPTOR_PASSING*/
 140     }
 141
 142   /* Return some data to the user.  */
 143
 144   if (len > buflen) /* We have more than the user requested.  */
 145     len = buflen;
 146
 147   memcpy (buf, (char*)ctx->uds.buffer + ctx->uds.bufferoffset, len);
 148   ctx->uds.buffersize -= len;
 149   assert (ctx->uds.buffersize >= 0);
 150   ctx->uds.bufferoffset += len;
 151   assert (ctx->uds.bufferoffset <= ctx->uds.bufferallocated);
 152
 153   return len;
 154 #else /*HAVE_W32_SYSTEM*/
 155   int res = recvfrom (HANDLE2SOCKET(ctx->inbound.fd), buf, buflen, 0, NULL, NULL);
 156   if (res < 0)
 157     errno = _assuan_sock_wsa2errno (WSAGetLastError ());
 158   return res;
 159 #endif /*HAVE_W32_SYSTEM*/
 160 }
 161
 162
 163 /* Write to the domain server.  */
 164 static ssize_t
 165 uds_writer (assuan_context_t ctx, const void *buf, size_t buflen)
 166 {
 167 #ifndef HAVE_W32_SYSTEM
 168   struct msghdr msg;
 169   struct iovec iovec;
 170   ssize_t len;
 171
 172   memset (&msg, 0, sizeof (msg));
 173
 174   msg.msg_name = NULL;
 175   msg.msg_namelen = 0;
 176   msg.msg_iovlen = 1;
 177   msg.msg_iov = &iovec;
 178   iovec.iov_base = (void*)buf;
 179   iovec.iov_len = buflen;
 180
 181   len = _assuan_simple_sendmsg (ctx, &msg);
 182
 183   return len;
 184 #else /*HAVE_W32_SYSTEM*/
 185   int res = sendto (HANDLE2SOCKET(ctx->outbound.fd), buf, buflen, 0,
 186                     (struct sockaddr *)&ctx->serveraddr,
 187                     sizeof (struct sockaddr_in));
 188   if (res < 0)
 189     errno = _assuan_sock_wsa2errno (WSAGetLastError ());
 190   return res;
 191 #endif /*HAVE_W32_SYSTEM*/
 192 }
 193
 194
 195 static assuan_error_t
 196 uds_sendfd (assuan_context_t ctx, assuan_fd_t fd)
 197 {
 198 #ifdef USE_DESCRIPTOR_PASSING
 199   struct msghdr msg;
 200   struct iovec iovec;
 201   union {
 202     struct cmsghdr cm;
 203     char control[CMSG_SPACE(sizeof (int))];
 204   } control_u;
 205   struct cmsghdr *cmptr;
 206   int len;
 207   char buffer[80];
 208
 209   /* We need to send some real data so that a read won't return 0
 210      which will be taken as an EOF.  It also helps with debugging. */
 211   snprintf (buffer, sizeof(buffer)-1, "# descriptor %d is in flight\n", fd);
 212   buffer[sizeof(buffer)-1] = 0;
 213
 214   memset (&msg, 0, sizeof (msg));
 215
 216   msg.msg_name = NULL;
 217   msg.msg_namelen = 0;
 218   msg.msg_iovlen = 1;
 219   msg.msg_iov = &iovec;
 220   iovec.iov_base = buffer;
 221   iovec.iov_len = strlen (buffer);
 222
 223   msg.msg_control = control_u.control;
 224   msg.msg_controllen = sizeof (control_u.control);
 225   cmptr = CMSG_FIRSTHDR (&msg);
 226   cmptr->cmsg_len = CMSG_LEN(sizeof(int));
 227   cmptr->cmsg_level = SOL_SOCKET;
 228   cmptr->cmsg_type = SCM_RIGHTS;
 229   *((int*)CMSG_DATA (cmptr)) = fd;
 230
 231   len = _assuan_simple_sendmsg (ctx, &msg);
 232   if (len < 0)
 233     {
 234       _assuan_log_printf ("uds_sendfd: %s\n", strerror (errno));
 235       return _assuan_error (ASSUAN_Write_Error);
 236     }
 237   else
 238     return 0;
 239 #else
 240   return _assuan_error (ASSUAN_Not_Implemented);
 241 #endif
 242 }
 243
 244
 245 static assuan_error_t
 246 uds_receivefd (assuan_context_t ctx, assuan_fd_t *fd)
 247 {
 248 #ifdef USE_DESCRIPTOR_PASSING
 249   int i;
 250
 251   if (!ctx->uds.pendingfdscount)
 252     {
 253       _assuan_log_printf ("no pending file descriptors!\n");
 254       return _assuan_error (ASSUAN_General_Error);
 255     }
 256   assert (ctx->uds.pendingfdscount <= DIM(ctx->uds.pendingfds));
 257
 258   *fd = ctx->uds.pendingfds[0];
 259   for (i=1; i < ctx->uds.pendingfdscount; i++)
 260     ctx->uds.pendingfds[i-1] = ctx->uds.pendingfds[i];
 261   ctx->uds.pendingfdscount--;
 262
 263   return 0;
 264 #else
 265   return _assuan_error (ASSUAN_Not_Implemented);
 266 #endif
 267 }
 268
 269
 270 /* Close all pending fds. */
 271 void
 272 _assuan_uds_close_fds (assuan_context_t ctx)
 273 {
 274   int i;
 275
 276   for (i = 0; i < ctx->uds.pendingfdscount; i++)
 277     _assuan_close (ctx->uds.pendingfds[i]);
 278   ctx->uds.pendingfdscount = 0;
 279 }
 280
 281 /* Deinitialize the unix domain socket I/O functions.  */
 282 void
 283 _assuan_uds_deinit (assuan_context_t ctx)
 284 {
 285   /* First call the finish_handler which should close descriptors etc. */
 286   ctx->finish_handler (ctx);
 287
 288   if (ctx->uds.buffer)
 289     {
 290       assert (ctx->uds.bufferallocated);
 291       ctx->uds.bufferallocated = 0;
 292       xfree (ctx->uds.buffer);
 293     }
 294
 295   _assuan_uds_close_fds (ctx);
 296 }
 297
 298
 299 /* Helper function to initialize a context for domain I/O. */
 300 void
 301 _assuan_init_uds_io (assuan_context_t ctx)
 302 {
 303   static struct assuan_io io = { uds_reader, uds_writer,
 304                                  uds_sendfd, uds_receivefd };
 305
 306   ctx->io = &io;
 307   ctx->uds.buffer = 0;
 308   ctx->uds.bufferoffset = 0;
 309   ctx->uds.buffersize = 0;
 310   ctx->uds.bufferallocated = 0;
 311   ctx->uds.pendingfdscount = 0;
 312 }
 313