source/lib/socket/socket_ipv4.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3
   4    Socket IPv4 functions
   5
   6    Copyright (C) Stefan Metzmacher 2004
   7    Copyright (C) Andrew Tridgell 2004-2005
   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 #include "system/network.h"
  26 #include "system/filesys.h"
  27 #include "lib/socket/socket.h"
  28
  29 static NTSTATUS ipv4_init(struct socket_context *sock)
  30 {
  31         int type;
  32
  33         switch (sock->type) {
  34         case SOCKET_TYPE_STREAM:
  35                 type = SOCK_STREAM;
  36                 break;
  37         case SOCKET_TYPE_DGRAM:
  38                 type = SOCK_DGRAM;
  39                 break;
  40         default:
  41                 return NT_STATUS_INVALID_PARAMETER;
  42         }
  43
  44         sock->fd = socket(PF_INET, type, 0);
  45         if (sock->fd == -1) {
  46                 return map_nt_error_from_unix(errno);
  47         }
  48
  49         sock->backend_name = "ipv4";
  50
  51         return NT_STATUS_OK;
  52 }
  53
  54 static void ipv4_close(struct socket_context *sock)
  55 {
  56         close(sock->fd);
  57 }
  58
  59 static NTSTATUS ipv4_connect_complete(struct socket_context *sock, uint32_t flags)
  60 {
  61         int error=0, ret;
  62         socklen_t len = sizeof(error);
  63
  64         /* check for any errors that may have occurred - this is needed
  65            for non-blocking connect */
  66         ret = getsockopt(sock->fd, SOL_SOCKET, SO_ERROR, &error, &len);
  67         if (ret == -1) {
  68                 return map_nt_error_from_unix(errno);
  69         }
  70         if (error != 0) {
  71                 return map_nt_error_from_unix(error);
  72         }
  73
  74         if (!(flags & SOCKET_FLAG_BLOCK)) {
  75                 ret = set_blocking(sock->fd, False);
  76                 if (ret == -1) {
  77                         return map_nt_error_from_unix(errno);
  78                 }
  79         }
  80
  81         sock->state = SOCKET_STATE_CLIENT_CONNECTED;
  82
  83         return NT_STATUS_OK;
  84 }
  85
  86
  87 static NTSTATUS ipv4_connect(struct socket_context *sock,
  88                                  const char *my_address, int my_port,
  89                                  const char *srv_address, int srv_port,
  90                                  uint32_t flags)
  91 {
  92         struct sockaddr_in srv_addr;
  93         struct ipv4_addr my_ip;
  94         struct ipv4_addr srv_ip;
  95         int ret;
  96
  97         my_ip = interpret_addr2(my_address);
  98
  99         if (my_ip.addr != 0 || my_port != 0) {
 100                 struct sockaddr_in my_addr;
 101                 ZERO_STRUCT(my_addr);
 102 #ifdef HAVE_SOCK_SIN_LEN
 103                 my_addr.sin_len         = sizeof(my_addr);
 104 #endif
 105                 my_addr.sin_addr.s_addr = my_ip.addr;
 106                 my_addr.sin_port        = htons(my_port);
 107                 my_addr.sin_family      = PF_INET;
 108
 109                 ret = bind(sock->fd, (struct sockaddr *)&my_addr, sizeof(my_addr));
 110                 if (ret == -1) {
 111                         return map_nt_error_from_unix(errno);
 112                 }
 113         }
 114
 115         srv_ip = interpret_addr2(srv_address);
 116         if (!srv_ip.addr) {
 117                 return NT_STATUS_BAD_NETWORK_NAME;
 118         }
 119
 120         ZERO_STRUCT(srv_addr);
 121 #ifdef HAVE_SOCK_SIN_LEN
 122         srv_addr.sin_len        = sizeof(srv_addr);
 123 #endif
 124         srv_addr.sin_addr.s_addr= srv_ip.addr;
 125         srv_addr.sin_port       = htons(srv_port);
 126         srv_addr.sin_family     = PF_INET;
 127
 128         ret = connect(sock->fd, (const struct sockaddr *)&srv_addr, sizeof(srv_addr));
 129         if (ret == -1) {
 130                 return map_nt_error_from_unix(errno);
 131         }
 132
 133         return ipv4_connect_complete(sock, flags);
 134 }
 135
 136
 137 /*
 138   note that for simplicity of the API, socket_listen() is also
 139   use for DGRAM sockets, but in reality only a bind() is done
 140 */
 141 static NTSTATUS ipv4_listen(struct socket_context *sock,
 142                             const char *my_address, int port,
 143                             int queue_size, uint32_t flags)
 144 {
 145         struct sockaddr_in my_addr;
 146         struct ipv4_addr ip_addr;
 147         int ret;
 148
 149         socket_set_option(sock, "SO_REUSEADDR=1", NULL);
 150
 151         ip_addr = interpret_addr2(my_address);
 152
 153         ZERO_STRUCT(my_addr);
 154 #ifdef HAVE_SOCK_SIN_LEN
 155         my_addr.sin_len         = sizeof(my_addr);
 156 #endif
 157         my_addr.sin_addr.s_addr = ip_addr.addr;
 158         my_addr.sin_port        = htons(port);
 159         my_addr.sin_family      = PF_INET;
 160
 161         ret = bind(sock->fd, (struct sockaddr *)&my_addr, sizeof(my_addr));
 162         if (ret == -1) {
 163                 return map_nt_error_from_unix(errno);
 164         }
 165
 166         if (sock->type == SOCKET_TYPE_STREAM) {
 167                 ret = listen(sock->fd, queue_size);
 168                 if (ret == -1) {
 169                         return map_nt_error_from_unix(errno);
 170                 }
 171         }
 172
 173         if (!(flags & SOCKET_FLAG_BLOCK)) {
 174                 ret = set_blocking(sock->fd, False);
 175                 if (ret == -1) {
 176                         return map_nt_error_from_unix(errno);
 177                 }
 178         }
 179
 180         sock->state= SOCKET_STATE_SERVER_LISTEN;
 181
 182         return NT_STATUS_OK;
 183 }
 184
 185 static NTSTATUS ipv4_accept(struct socket_context *sock, struct socket_context **new_sock)
 186 {
 187         struct sockaddr_in cli_addr;
 188         socklen_t cli_addr_len = sizeof(cli_addr);
 189         int new_fd;
 190
 191         if (sock->type != SOCKET_TYPE_STREAM) {
 192                 return NT_STATUS_INVALID_PARAMETER;
 193         }
 194
 195         new_fd = accept(sock->fd, (struct sockaddr *)&cli_addr, &cli_addr_len);
 196         if (new_fd == -1) {
 197                 return map_nt_error_from_unix(errno);
 198         }
 199
 200         if (!(sock->flags & SOCKET_FLAG_BLOCK)) {
 201                 int ret = set_blocking(new_fd, False);
 202                 if (ret == -1) {
 203                         close(new_fd);
 204                         return map_nt_error_from_unix(errno);
 205                 }
 206         }
 207
 208         /* TODO: we could add a 'accept_check' hook here
 209          *       which get the black/white lists via socket_set_accept_filter()
 210          *       or something like that
 211          *       --metze
 212          */
 213
 214         (*new_sock) = talloc(NULL, struct socket_context);
 215         if (!(*new_sock)) {
 216                 close(new_fd);
 217                 return NT_STATUS_NO_MEMORY;
 218         }
 219
 220         /* copy the socket_context */
 221         (*new_sock)->type               = sock->type;
 222         (*new_sock)->state              = SOCKET_STATE_SERVER_CONNECTED;
 223         (*new_sock)->flags              = sock->flags;
 224
 225         (*new_sock)->fd                 = new_fd;
 226
 227         (*new_sock)->private_data       = NULL;
 228         (*new_sock)->ops                = sock->ops;
 229         (*new_sock)->backend_name       = sock->backend_name;
 230
 231         return NT_STATUS_OK;
 232 }
 233
 234 static NTSTATUS ipv4_recv(struct socket_context *sock, void *buf,
 235                               size_t wantlen, size_t *nread, uint32_t flags)
 236 {
 237         ssize_t gotlen;
 238         int flgs = 0;
 239
 240         /* TODO: we need to map all flags here */
 241         if (flags & SOCKET_FLAG_PEEK) {
 242                 flgs |= MSG_PEEK;
 243         }
 244
 245         if (flags & SOCKET_FLAG_BLOCK) {
 246                 flgs |= MSG_WAITALL;
 247         }
 248
 249         *nread = 0;
 250
 251         gotlen = recv(sock->fd, buf, wantlen, flgs);
 252         if (gotlen == 0) {
 253                 return NT_STATUS_END_OF_FILE;
 254         } else if (gotlen == -1) {
 255                 return map_nt_error_from_unix(errno);
 256         }
 257
 258         *nread = gotlen;
 259
 260         return NT_STATUS_OK;
 261 }
 262
 263
 264 static NTSTATUS ipv4_recvfrom(struct socket_context *sock, void *buf,
 265                               size_t wantlen, size_t *nread, uint32_t flags,
 266                               const char **src_addr, int *src_port)
 267 {
 268         ssize_t gotlen;
 269         int flgs = 0;
 270         struct sockaddr_in from_addr;
 271         socklen_t from_len = sizeof(from_addr);
 272         const char *addr;
 273
 274         if (flags & SOCKET_FLAG_PEEK) {
 275                 flgs |= MSG_PEEK;
 276         }
 277
 278         if (flags & SOCKET_FLAG_BLOCK) {
 279                 flgs |= MSG_WAITALL;
 280         }
 281
 282         *nread = 0;
 283
 284         gotlen = recvfrom(sock->fd, buf, wantlen, flgs,
 285                           (struct sockaddr *)&from_addr, &from_len);
 286         if (gotlen == 0) {
 287                 return NT_STATUS_END_OF_FILE;
 288         } else if (gotlen == -1) {
 289                 return map_nt_error_from_unix(errno);
 290         }
 291
 292         addr = inet_ntoa(from_addr.sin_addr);
 293         if (addr == NULL) {
 294                 return NT_STATUS_INTERNAL_ERROR;
 295         }
 296         *src_addr = talloc_strdup(sock, addr);
 297         NT_STATUS_HAVE_NO_MEMORY(*src_addr);
 298         *src_port = ntohs(from_addr.sin_port);
 299
 300         *nread = gotlen;
 301
 302         return NT_STATUS_OK;
 303 }
 304
 305 static NTSTATUS ipv4_send(struct socket_context *sock,
 306                               const DATA_BLOB *blob, size_t *sendlen, uint32_t flags)
 307 {
 308         ssize_t len;
 309         int flgs = 0;
 310
 311         *sendlen = 0;
 312
 313         len = send(sock->fd, blob->data, blob->length, flgs);
 314         if (len == -1) {
 315                 return map_nt_error_from_unix(errno);
 316         }
 317
 318         *sendlen = len;
 319
 320         return NT_STATUS_OK;
 321 }
 322
 323 static NTSTATUS ipv4_sendto(struct socket_context *sock,
 324                             const DATA_BLOB *blob, size_t *sendlen, uint32_t flags,
 325                             const char *dest_addr, int dest_port)
 326 {
 327         ssize_t len;
 328         int flgs = 0;
 329         struct sockaddr_in srv_addr;
 330         struct ipv4_addr addr;
 331
 332         ZERO_STRUCT(srv_addr);
 333 #ifdef HAVE_SOCK_SIN_LEN
 334         srv_addr.sin_len         = sizeof(srv_addr);
 335 #endif
 336         addr                     = interpret_addr2(dest_addr);
 337         srv_addr.sin_addr.s_addr = addr.addr;
 338         srv_addr.sin_port        = htons(dest_port);
 339         srv_addr.sin_family      = PF_INET;
 340
 341         *sendlen = 0;
 342
 343         len = sendto(sock->fd, blob->data, blob->length, flgs,
 344                    (struct sockaddr *)&srv_addr, sizeof(srv_addr));
 345         if (len == -1) {
 346                 return map_nt_error_from_unix(errno);
 347         }
 348
 349         *sendlen = len;
 350
 351         return NT_STATUS_OK;
 352 }
 353
 354 static NTSTATUS ipv4_set_option(struct socket_context *sock, const char *option, const char *val)
 355 {
 356         set_socket_options(sock->fd, option);
 357         return NT_STATUS_OK;
 358 }
 359
 360 static char *ipv4_get_peer_name(struct socket_context *sock, TALLOC_CTX *mem_ctx)
 361 {
 362         struct sockaddr_in peer_addr;
 363         socklen_t len = sizeof(peer_addr);
 364         struct hostent *he;
 365         int ret;
 366
 367         ret = getpeername(sock->fd, (struct sockaddr *)&peer_addr, &len);
 368         if (ret == -1) {
 369                 return NULL;
 370         }
 371
 372         he = gethostbyaddr((char *)&peer_addr.sin_addr, sizeof(peer_addr.sin_addr), AF_INET);
 373         if (he == NULL) {
 374                 return NULL;
 375         }
 376
 377         return talloc_strdup(mem_ctx, he->h_name);
 378 }
 379
 380 static char *ipv4_get_peer_addr(struct socket_context *sock, TALLOC_CTX *mem_ctx)
 381 {
 382         struct sockaddr_in peer_addr;
 383         socklen_t len = sizeof(peer_addr);
 384         int ret;
 385
 386         ret = getpeername(sock->fd, (struct sockaddr *)&peer_addr, &len);
 387         if (ret == -1) {
 388                 return NULL;
 389         }
 390
 391         return talloc_strdup(mem_ctx, inet_ntoa(peer_addr.sin_addr));
 392 }
 393
 394 static int ipv4_get_peer_port(struct socket_context *sock)
 395 {
 396         struct sockaddr_in peer_addr;
 397         socklen_t len = sizeof(peer_addr);
 398         int ret;
 399
 400         ret = getpeername(sock->fd, (struct sockaddr *)&peer_addr, &len);
 401         if (ret == -1) {
 402                 return -1;
 403         }
 404
 405         return ntohs(peer_addr.sin_port);
 406 }
 407
 408 static char *ipv4_get_my_addr(struct socket_context *sock, TALLOC_CTX *mem_ctx)
 409 {
 410         struct sockaddr_in my_addr;
 411         socklen_t len = sizeof(my_addr);
 412         int ret;
 413
 414         ret = getsockname(sock->fd, (struct sockaddr *)&my_addr, &len);
 415         if (ret == -1) {
 416                 return NULL;
 417         }
 418
 419         return talloc_strdup(mem_ctx, inet_ntoa(my_addr.sin_addr));
 420 }
 421
 422 static int ipv4_get_my_port(struct socket_context *sock)
 423 {
 424         struct sockaddr_in my_addr;
 425         socklen_t len = sizeof(my_addr);
 426         int ret;
 427
 428         ret = getsockname(sock->fd, (struct sockaddr *)&my_addr, &len);
 429         if (ret == -1) {
 430                 return -1;
 431         }
 432
 433         return ntohs(my_addr.sin_port);
 434 }
 435
 436 static int ipv4_get_fd(struct socket_context *sock)
 437 {
 438         return sock->fd;
 439 }
 440
 441 static NTSTATUS ipv4_pending(struct socket_context *sock, size_t *npending)
 442 {
 443         int value = 0;
 444         if (ioctl(sock->fd, FIONREAD, &value) == 0) {
 445                 *npending = value;
 446                 return NT_STATUS_OK;
 447         }
 448         return map_nt_error_from_unix(errno);
 449 }
 450
 451 static const struct socket_ops ipv4_ops = {
 452         .name                   = "ipv4",
 453         .fn_init                = ipv4_init,
 454         .fn_connect             = ipv4_connect,
 455         .fn_connect_complete    = ipv4_connect_complete,
 456         .fn_listen              = ipv4_listen,
 457         .fn_accept              = ipv4_accept,
 458         .fn_recv                = ipv4_recv,
 459         .fn_recvfrom            = ipv4_recvfrom,
 460         .fn_send                = ipv4_send,
 461         .fn_sendto              = ipv4_sendto,
 462         .fn_pending             = ipv4_pending,
 463         .fn_close               = ipv4_close,
 464
 465         .fn_set_option          = ipv4_set_option,
 466
 467         .fn_get_peer_name       = ipv4_get_peer_name,
 468         .fn_get_peer_addr       = ipv4_get_peer_addr,
 469         .fn_get_peer_port       = ipv4_get_peer_port,
 470         .fn_get_my_addr         = ipv4_get_my_addr,
 471         .fn_get_my_port         = ipv4_get_my_port,
 472
 473         .fn_get_fd              = ipv4_get_fd
 474 };
 475
 476 const struct socket_ops *socket_ipv4_ops(enum socket_type type)
 477 {
 478         return &ipv4_ops;
 479 }