source4/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
  27 static NTSTATUS ipv4_tcp_init(struct socket_context *sock)
  28 {
  29         sock->fd = socket(PF_INET, SOCK_STREAM, 0);
  30         if (sock->fd == -1) {
  31                 return map_nt_error_from_unix(errno);
  32         }
  33
  34         return NT_STATUS_OK;
  35 }
  36
  37 static void ipv4_tcp_close(struct socket_context *sock)
  38 {
  39         close(sock->fd);
  40 }
  41
  42 static NTSTATUS ipv4_tcp_connect_complete(struct socket_context *sock, uint32_t flags)
  43 {
  44         int error=0, ret;
  45         socklen_t len = sizeof(error);
  46
  47         /* check for any errors that may have occurred - this is needed
  48            for non-blocking connect */
  49         ret = getsockopt(sock->fd, SOL_SOCKET, SO_ERROR, &error, &len);
  50         if (ret == -1) {
  51                 return map_nt_error_from_unix(errno);
  52         }
  53         if (error != 0) {
  54                 return map_nt_error_from_unix(error);
  55         }
  56
  57         if (!(flags & SOCKET_FLAG_BLOCK)) {
  58                 ret = set_blocking(sock->fd, False);
  59                 if (ret == -1) {
  60                         return map_nt_error_from_unix(errno);
  61                 }
  62         }
  63
  64         sock->state = SOCKET_STATE_CLIENT_CONNECTED;
  65
  66         return NT_STATUS_OK;
  67 }
  68
  69
  70 static NTSTATUS ipv4_tcp_connect(struct socket_context *sock,
  71                                  const char *my_address, int my_port,
  72                                  const char *srv_address, int srv_port,
  73                                  uint32_t flags)
  74 {
  75         struct sockaddr_in srv_addr;
  76         struct ipv4_addr my_ip;
  77         struct ipv4_addr srv_ip;
  78         int ret;
  79
  80         my_ip = interpret_addr2(my_address);
  81
  82         if (my_ip.addr != 0 || my_port != 0) {
  83                 struct sockaddr_in my_addr;
  84                 ZERO_STRUCT(my_addr);
  85 #ifdef HAVE_SOCK_SIN_LEN
  86                 my_addr.sin_len         = sizeof(my_addr);
  87 #endif
  88                 my_addr.sin_addr.s_addr = my_ip.addr;
  89                 my_addr.sin_port        = htons(my_port);
  90                 my_addr.sin_family      = PF_INET;
  91
  92                 ret = bind(sock->fd, (struct sockaddr *)&my_addr, sizeof(my_addr));
  93                 if (ret == -1) {
  94                         return map_nt_error_from_unix(errno);
  95                 }
  96         }
  97
  98         srv_ip = interpret_addr2(srv_address);
  99
 100         ZERO_STRUCT(srv_addr);
 101 #ifdef HAVE_SOCK_SIN_LEN
 102         srv_addr.sin_len        = sizeof(srv_addr);
 103 #endif
 104         srv_addr.sin_addr.s_addr= srv_ip.addr;
 105         srv_addr.sin_port       = htons(srv_port);
 106         srv_addr.sin_family     = PF_INET;
 107
 108         ret = connect(sock->fd, (const struct sockaddr *)&srv_addr, sizeof(srv_addr));
 109         if (ret == -1) {
 110                 return map_nt_error_from_unix(errno);
 111         }
 112
 113         return ipv4_tcp_connect_complete(sock, flags);
 114 }
 115
 116
 117 static NTSTATUS ipv4_tcp_listen(struct socket_context *sock,
 118                                         const char *my_address, int port,
 119                                         int queue_size, uint32_t flags)
 120 {
 121         struct sockaddr_in my_addr;
 122         struct ipv4_addr ip_addr;
 123         int ret;
 124
 125         ip_addr = interpret_addr2(my_address);
 126
 127         ZERO_STRUCT(my_addr);
 128 #ifdef HAVE_SOCK_SIN_LEN
 129         my_addr.sin_len         = sizeof(my_addr);
 130 #endif
 131         my_addr.sin_addr.s_addr = ip_addr.addr;
 132         my_addr.sin_port        = htons(port);
 133         my_addr.sin_family      = PF_INET;
 134
 135         ret = bind(sock->fd, (struct sockaddr *)&my_addr, sizeof(my_addr));
 136         if (ret == -1) {
 137                 return map_nt_error_from_unix(errno);
 138         }
 139
 140         ret = listen(sock->fd, queue_size);
 141         if (ret == -1) {
 142                 return map_nt_error_from_unix(errno);
 143         }
 144
 145         if (!(flags & SOCKET_FLAG_BLOCK)) {
 146                 ret = set_blocking(sock->fd, False);
 147                 if (ret == -1) {
 148                         return map_nt_error_from_unix(errno);
 149                 }
 150         }
 151
 152         sock->state= SOCKET_STATE_SERVER_LISTEN;
 153
 154         return NT_STATUS_OK;
 155 }
 156
 157 static NTSTATUS ipv4_tcp_accept(struct socket_context *sock, struct socket_context **new_sock)
 158 {
 159         struct sockaddr_in cli_addr;
 160         socklen_t cli_addr_len = sizeof(cli_addr);
 161         int new_fd;
 162
 163         new_fd = accept(sock->fd, (struct sockaddr *)&cli_addr, &cli_addr_len);
 164         if (new_fd == -1) {
 165                 return map_nt_error_from_unix(errno);
 166         }
 167
 168         if (!(sock->flags & SOCKET_FLAG_BLOCK)) {
 169                 int ret = set_blocking(new_fd, False);
 170                 if (ret == -1) {
 171                         close(new_fd);
 172                         return map_nt_error_from_unix(errno);
 173                 }
 174         }
 175
 176         /* TODO: we could add a 'accept_check' hook here
 177          *       which get the black/white lists via socket_set_accept_filter()
 178          *       or something like that
 179          *       --metze
 180          */
 181
 182         (*new_sock) = talloc_p(NULL, struct socket_context);
 183         if (!(*new_sock)) {
 184                 close(new_fd);
 185                 return NT_STATUS_NO_MEMORY;
 186         }
 187
 188         /* copy the socket_context */
 189         (*new_sock)->type               = sock->type;
 190         (*new_sock)->state              = SOCKET_STATE_SERVER_CONNECTED;
 191         (*new_sock)->flags              = sock->flags;
 192
 193         (*new_sock)->fd                 = new_fd;
 194
 195         (*new_sock)->private_data       = NULL;
 196         (*new_sock)->ops                = sock->ops;
 197
 198         return NT_STATUS_OK;
 199 }
 200
 201 static NTSTATUS ipv4_tcp_recv(struct socket_context *sock, void *buf,
 202                               size_t wantlen, size_t *nread, uint32_t flags)
 203 {
 204         ssize_t gotlen;
 205         int flgs = 0;
 206
 207         /* TODO: we need to map all flags here */
 208         if (flags & SOCKET_FLAG_PEEK) {
 209                 flgs |= MSG_PEEK;
 210         }
 211
 212         if (flags & SOCKET_FLAG_BLOCK) {
 213                 flgs |= MSG_WAITALL;
 214         }
 215
 216         *nread = 0;
 217
 218         gotlen = recv(sock->fd, buf, wantlen, flgs);
 219         if (gotlen == 0) {
 220                 return NT_STATUS_END_OF_FILE;
 221         } else if (gotlen == -1) {
 222                 return map_nt_error_from_unix(errno);
 223         }
 224
 225         *nread = gotlen;
 226
 227         return NT_STATUS_OK;
 228 }
 229
 230 static NTSTATUS ipv4_tcp_send(struct socket_context *sock,
 231                               const DATA_BLOB *blob, size_t *sendlen, uint32_t flags)
 232 {
 233         ssize_t len;
 234         int flgs = 0;
 235
 236         *sendlen = 0;
 237
 238         len = send(sock->fd, blob->data, blob->length, flgs);
 239         if (len == -1) {
 240                 return map_nt_error_from_unix(errno);
 241         }
 242
 243         *sendlen = len;
 244
 245         return NT_STATUS_OK;
 246 }
 247
 248 static NTSTATUS ipv4_tcp_set_option(struct socket_context *sock, const char *option, const char *val)
 249 {
 250         set_socket_options(sock->fd, option);
 251         return NT_STATUS_OK;
 252 }
 253
 254 static char *ipv4_tcp_get_peer_name(struct socket_context *sock, TALLOC_CTX *mem_ctx)
 255 {
 256         struct sockaddr_in peer_addr;
 257         socklen_t len = sizeof(peer_addr);
 258         struct hostent *he;
 259         int ret;
 260
 261         ret = getpeername(sock->fd, (struct sockaddr *)&peer_addr, &len);
 262         if (ret == -1) {
 263                 return NULL;
 264         }
 265
 266         he = gethostbyaddr((char *)&peer_addr.sin_addr, sizeof(peer_addr.sin_addr), AF_INET);
 267         if (he == NULL) {
 268                 return NULL;
 269         }
 270
 271         return talloc_strdup(mem_ctx, he->h_name);
 272 }
 273
 274 static char *ipv4_tcp_get_peer_addr(struct socket_context *sock, TALLOC_CTX *mem_ctx)
 275 {
 276         struct sockaddr_in peer_addr;
 277         socklen_t len = sizeof(peer_addr);
 278         int ret;
 279
 280         ret = getpeername(sock->fd, (struct sockaddr *)&peer_addr, &len);
 281         if (ret == -1) {
 282                 return NULL;
 283         }
 284
 285         return talloc_strdup(mem_ctx, inet_ntoa(peer_addr.sin_addr));
 286 }
 287
 288 static int ipv4_tcp_get_peer_port(struct socket_context *sock)
 289 {
 290         struct sockaddr_in peer_addr;
 291         socklen_t len = sizeof(peer_addr);
 292         int ret;
 293
 294         ret = getpeername(sock->fd, (struct sockaddr *)&peer_addr, &len);
 295         if (ret == -1) {
 296                 return -1;
 297         }
 298
 299         return ntohs(peer_addr.sin_port);
 300 }
 301
 302 static char *ipv4_tcp_get_my_addr(struct socket_context *sock, TALLOC_CTX *mem_ctx)
 303 {
 304         struct sockaddr_in my_addr;
 305         socklen_t len = sizeof(my_addr);
 306         int ret;
 307
 308         ret = getsockname(sock->fd, (struct sockaddr *)&my_addr, &len);
 309         if (ret == -1) {
 310                 return NULL;
 311         }
 312
 313         return talloc_strdup(mem_ctx, inet_ntoa(my_addr.sin_addr));
 314 }
 315
 316 static int ipv4_tcp_get_my_port(struct socket_context *sock)
 317 {
 318         struct sockaddr_in my_addr;
 319         socklen_t len = sizeof(my_addr);
 320         int ret;
 321
 322         ret = getsockname(sock->fd, (struct sockaddr *)&my_addr, &len);
 323         if (ret == -1) {
 324                 return -1;
 325         }
 326
 327         return ntohs(my_addr.sin_port);
 328 }
 329
 330 static int ipv4_tcp_get_fd(struct socket_context *sock)
 331 {
 332         return sock->fd;
 333 }
 334
 335 static const struct socket_ops ipv4_tcp_ops = {
 336         .name                   = "ipv4",
 337         .type                   = SOCKET_TYPE_STREAM,
 338
 339         .fn_init                = ipv4_tcp_init,
 340         .fn_connect             = ipv4_tcp_connect,
 341         .fn_connect_complete    = ipv4_tcp_connect_complete,
 342         .fn_listen              = ipv4_tcp_listen,
 343         .fn_accept              = ipv4_tcp_accept,
 344         .fn_recv                = ipv4_tcp_recv,
 345         .fn_send                = ipv4_tcp_send,
 346         .fn_close               = ipv4_tcp_close,
 347
 348         .fn_set_option          = ipv4_tcp_set_option,
 349
 350         .fn_get_peer_name       = ipv4_tcp_get_peer_name,
 351         .fn_get_peer_addr       = ipv4_tcp_get_peer_addr,
 352         .fn_get_peer_port       = ipv4_tcp_get_peer_port,
 353         .fn_get_my_addr         = ipv4_tcp_get_my_addr,
 354         .fn_get_my_port         = ipv4_tcp_get_my_port,
 355
 356         .fn_get_fd              = ipv4_tcp_get_fd
 357 };
 358
 359 const struct socket_ops *socket_ipv4_ops(void)
 360 {
 361         return &ipv4_tcp_ops;
 362 }