source4/lib/socket/socket_unix.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3
   4    unix domain socket functions
   5
   6    Copyright (C) Stefan Metzmacher 2004
   7    Copyright (C) Andrew Tridgell 2004
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 2 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program; if not, write to the Free Software
  21    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  22 */
  23
  24 #include "includes.h"
  25
  26
  27
  28 /*
  29   approximate errno mapping
  30 */
  31 static NTSTATUS unixdom_error(int ernum)
  32 {
  33         switch (ernum) {
  34         case EBADF:
  35         case ENOTCONN:
  36         case ENOTSOCK:
  37         case EFAULT:
  38         case EINVAL:
  39                 return NT_STATUS_INVALID_PARAMETER;
  40         case EAGAIN:
  41         case EINTR:
  42                 return STATUS_MORE_ENTRIES;
  43         case ECONNREFUSED:
  44                 return NT_STATUS_CONNECTION_REFUSED;
  45         case ENOBUFS:
  46         case ENOMEM:
  47                 return NT_STATUS_NO_MEMORY;
  48         case ENFILE:
  49         case EMFILE:
  50                 return NT_STATUS_INSUFFICIENT_RESOURCES;
  51         case EPIPE:
  52                 return NT_STATUS_CONNECTION_DISCONNECTED;
  53         case EMSGSIZE:
  54                 return NT_STATUS_INVALID_BUFFER_SIZE;
  55         }
  56
  57         return NT_STATUS_UNSUCCESSFUL;
  58 }
  59
  60 static NTSTATUS unixdom_init(struct socket_context *sock)
  61 {
  62         sock->fd = socket(PF_UNIX, SOCK_STREAM, 0);
  63         if (sock->fd == -1) {
  64                 return NT_STATUS_INSUFFICIENT_RESOURCES;
  65         }
  66         sock->private_data = NULL;
  67
  68         return NT_STATUS_OK;
  69 }
  70
  71 static void unixdom_close(struct socket_context *sock)
  72 {
  73         close(sock->fd);
  74 }
  75
  76 static NTSTATUS unixdom_connect(struct socket_context *sock,
  77                                 const char *my_address, int my_port,
  78                                 const char *srv_address, int srv_port,
  79                                 uint32_t flags)
  80 {
  81         struct sockaddr_un srv_addr;
  82         int ret;
  83
  84         if (strlen(srv_address)+1 > sizeof(srv_addr.sun_path)) {
  85                 return NT_STATUS_INVALID_PARAMETER;
  86         }
  87
  88         ZERO_STRUCT(srv_addr);
  89         srv_addr.sun_family = AF_UNIX;
  90         strncpy(srv_addr.sun_path, srv_address, sizeof(srv_addr.sun_path));
  91
  92         if (!(flags & SOCKET_FLAG_BLOCK)) {
  93                 ret = set_blocking(sock->fd, False);
  94                 if (ret == -1) {
  95                         return NT_STATUS_INVALID_PARAMETER;
  96                 }
  97         }
  98
  99         ret = connect(sock->fd, (const struct sockaddr *)&srv_addr, sizeof(srv_addr));
 100         if (ret == -1) {
 101                 return unixdom_error(errno);
 102         }
 103
 104         sock->state = SOCKET_STATE_CLIENT_CONNECTED;
 105
 106         return NT_STATUS_OK;
 107 }
 108
 109 static NTSTATUS unixdom_listen(struct socket_context *sock,
 110                                const char *my_address, int port,
 111                                int queue_size, uint32_t flags)
 112 {
 113         struct sockaddr_un my_addr;
 114         int ret;
 115
 116         if (strlen(my_address)+1 > sizeof(my_addr.sun_path)) {
 117                 return NT_STATUS_INVALID_PARAMETER;
 118         }
 119
 120         /* delete if it already exists */
 121         unlink(my_address);
 122
 123         ZERO_STRUCT(my_addr);
 124         my_addr.sun_family = AF_UNIX;
 125         strncpy(my_addr.sun_path, my_address, sizeof(my_addr.sun_path));
 126
 127         ret = bind(sock->fd, (struct sockaddr *)&my_addr, sizeof(my_addr));
 128         if (ret == -1) {
 129                 return unixdom_error(errno);
 130         }
 131
 132         ret = listen(sock->fd, queue_size);
 133         if (ret == -1) {
 134                 return unixdom_error(errno);
 135         }
 136
 137         if (!(flags & SOCKET_FLAG_BLOCK)) {
 138                 ret = set_blocking(sock->fd, False);
 139                 if (ret == -1) {
 140                         return unixdom_error(errno);
 141                 }
 142         }
 143
 144         sock->state = SOCKET_STATE_SERVER_LISTEN;
 145         sock->private_data = (void *)talloc_strdup(sock, my_address);
 146
 147         return NT_STATUS_OK;
 148 }
 149
 150 static NTSTATUS unixdom_accept(struct socket_context *sock,
 151                                struct socket_context **new_sock,
 152                                uint32_t flags)
 153 {
 154         struct sockaddr_un cli_addr;
 155         socklen_t cli_addr_len = sizeof(cli_addr);
 156         int new_fd;
 157
 158         new_fd = accept(sock->fd, (struct sockaddr *)&cli_addr, &cli_addr_len);
 159         if (new_fd == -1) {
 160                 return unixdom_error(errno);
 161         }
 162
 163         (*new_sock) = talloc_p(NULL, struct socket_context);
 164         if (!(*new_sock)) {
 165                 close(new_fd);
 166                 return NT_STATUS_NO_MEMORY;
 167         }
 168
 169         /* copy the socket_context */
 170         (*new_sock)->type               = sock->type;
 171         (*new_sock)->state              = SOCKET_STATE_SERVER_CONNECTED;
 172         (*new_sock)->flags              = flags;
 173
 174         (*new_sock)->fd                 = new_fd;
 175
 176         (*new_sock)->private_data       = NULL;
 177         (*new_sock)->ops                = sock->ops;
 178
 179         return NT_STATUS_OK;
 180 }
 181
 182 static NTSTATUS unixdom_recv(struct socket_context *sock, TALLOC_CTX *mem_ctx,
 183                              DATA_BLOB *blob, size_t wantlen, uint32_t flags)
 184 {
 185         ssize_t gotlen;
 186         void *buf;
 187         int flgs = 0;
 188
 189         buf = talloc(mem_ctx, wantlen);
 190         if (!buf) {
 191                 return NT_STATUS_NO_MEMORY;
 192         }
 193
 194         /* TODO: we need to map all flags here */
 195         if (flags & SOCKET_FLAG_PEEK) {
 196                 flgs |= MSG_PEEK;
 197         }
 198
 199         if (!(flags & SOCKET_FLAG_BLOCK)) {
 200                 flgs |= MSG_DONTWAIT;
 201         }
 202
 203         if (flags & SOCKET_FLAG_BLOCK) {
 204                 flgs |= MSG_WAITALL;
 205         }
 206
 207         gotlen = recv(sock->fd, buf, wantlen, flgs);
 208         if (gotlen == 0) {
 209                 talloc_free(buf);
 210                 return NT_STATUS_END_OF_FILE;
 211         } else if (gotlen == -1) {
 212                 NTSTATUS status = unixdom_error(errno);
 213                 talloc_free(buf);
 214                 return status;
 215         }
 216
 217         blob->length = gotlen;
 218         blob->data = talloc_realloc(mem_ctx, buf, gotlen);
 219         if (!blob->data) {
 220                 return NT_STATUS_NO_MEMORY;
 221         }
 222
 223         return NT_STATUS_OK;
 224 }
 225
 226 static NTSTATUS unixdom_send(struct socket_context *sock, TALLOC_CTX *mem_ctx,
 227                              const DATA_BLOB *blob, size_t *sendlen, uint32_t flags)
 228 {
 229         ssize_t len;
 230         int flgs = 0;
 231
 232         *sendlen = 0;
 233
 234         /* TODO: we need to map all flags here */
 235         if (!(flags & SOCKET_FLAG_BLOCK)) {
 236                 flgs |= MSG_DONTWAIT;
 237         }
 238
 239         len = send(sock->fd, blob->data, blob->length, flgs);
 240         if (len == -1) {
 241                 return unixdom_error(errno);
 242         }
 243
 244         *sendlen = len;
 245
 246         return NT_STATUS_OK;
 247 }
 248
 249 static NTSTATUS unixdom_set_option(struct socket_context *sock,
 250                                    const char *option, const char *val)
 251 {
 252         set_socket_options(sock->fd, option);
 253         return NT_STATUS_OK;
 254 }
 255
 256 static char *unixdom_get_peer_name(struct socket_context *sock, TALLOC_CTX *mem_ctx)
 257 {
 258         return talloc_strdup(mem_ctx, "LOCAL/unixdom");
 259 }
 260
 261 static char *unixdom_get_peer_addr(struct socket_context *sock, TALLOC_CTX *mem_ctx)
 262 {
 263         return talloc_strdup(mem_ctx, "LOCAL/unixdom");
 264 }
 265
 266 static int unixdom_get_peer_port(struct socket_context *sock)
 267 {
 268         return 0;
 269 }
 270
 271 static char *unixdom_get_my_addr(struct socket_context *sock, TALLOC_CTX *mem_ctx)
 272 {
 273         return talloc_strdup(mem_ctx, "LOCAL/unixdom");
 274 }
 275
 276 static int unixdom_get_my_port(struct socket_context *sock)
 277 {
 278         return 0;
 279 }
 280
 281 static int unixdom_get_fd(struct socket_context *sock)
 282 {
 283         return sock->fd;
 284 }
 285
 286 static const struct socket_ops unixdom_ops = {
 287         .name           = "unix",
 288         .type           = SOCKET_TYPE_STREAM,
 289
 290         .init           = unixdom_init,
 291         .connect        = unixdom_connect,
 292         .listen         = unixdom_listen,
 293         .accept         = unixdom_accept,
 294         .recv           = unixdom_recv,
 295         .send           = unixdom_send,
 296         .close          = unixdom_close,
 297
 298         .set_option     = unixdom_set_option,
 299
 300         .get_peer_name  = unixdom_get_peer_name,
 301         .get_peer_addr  = unixdom_get_peer_addr,
 302         .get_peer_port  = unixdom_get_peer_port,
 303         .get_my_addr    = unixdom_get_my_addr,
 304         .get_my_port    = unixdom_get_my_port,
 305
 306         .get_fd         = unixdom_get_fd
 307 };
 308
 309 const struct socket_ops *socket_unixdom_ops(void)
 310 {
 311         return &unixdom_ops;
 312 }
 313
 314 NTSTATUS socket_unixdom_init(void)
 315 {
 316         return NT_STATUS_OK;
 317 }