source4/lib/socket/socket_ip.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3
   4    Socket IPv4/IPv6 functions
   5
   6    Copyright (C) Stefan Metzmacher 2004
   7    Copyright (C) Andrew Tridgell 2004-2005
   8    Copyright (C) Jelmer Vernooij 2004
   9
  10    This program is free software; you can redistribute it and/or modify
  11    it under the terms of the GNU General Public License as published by
  12    the Free Software Foundation; either version 3 of the License, or
  13    (at your option) any later version.
  14
  15    This program is distributed in the hope that it will be useful,
  16    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18    GNU General Public License for more details.
  19
  20    You should have received a copy of the GNU General Public License
  21    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  22 */
  23
  24 #include "includes.h"
  25 #include "system/filesys.h"
  26 #include "lib/socket/socket.h"
  27 #include "system/network.h"
  28 #include "lib/util/util_net.h"
  29
  30 #undef strcasecmp
  31
  32 _PUBLIC_ const struct socket_ops *socket_ipv4_ops(enum socket_type type);
  33 _PUBLIC_ const struct socket_ops *socket_ipv6_ops(enum socket_type type);
  34
  35 static NTSTATUS ipv4_init(struct socket_context *sock)
  36 {
  37         int type;
  38
  39         switch (sock->type) {
  40         case SOCKET_TYPE_STREAM:
  41                 type = SOCK_STREAM;
  42                 break;
  43         case SOCKET_TYPE_DGRAM:
  44                 type = SOCK_DGRAM;
  45                 break;
  46         default:
  47                 return NT_STATUS_INVALID_PARAMETER;
  48         }
  49
  50         sock->fd = socket(PF_INET, type, 0);
  51         if (sock->fd == -1) {
  52                 return map_nt_error_from_unix_common(errno);
  53         }
  54
  55         smb_set_close_on_exec(sock->fd);
  56
  57         sock->backend_name = "ipv4";
  58         sock->family = AF_INET;
  59
  60         return NT_STATUS_OK;
  61 }
  62
  63 static void ip_close(struct socket_context *sock)
  64 {
  65         if (sock->fd != -1) {
  66                 close(sock->fd);
  67                 sock->fd = -1;
  68         }
  69 }
  70
  71 static NTSTATUS ip_connect_complete(struct socket_context *sock, uint32_t flags)
  72 {
  73         int error=0, ret;
  74         socklen_t len = sizeof(error);
  75
  76         /* check for any errors that may have occurred - this is needed
  77            for non-blocking connect */
  78         ret = getsockopt(sock->fd, SOL_SOCKET, SO_ERROR, &error, &len);
  79         if (ret == -1) {
  80                 return map_nt_error_from_unix_common(errno);
  81         }
  82         if (error != 0) {
  83                 return map_nt_error_from_unix_common(error);
  84         }
  85
  86         ret = set_blocking(sock->fd, false);
  87         if (ret == -1) {
  88                 return map_nt_error_from_unix_common(errno);
  89         }
  90
  91         sock->state = SOCKET_STATE_CLIENT_CONNECTED;
  92
  93         return NT_STATUS_OK;
  94 }
  95
  96
  97 static NTSTATUS ipv4_connect(struct socket_context *sock,
  98                              const struct socket_address *my_address,
  99                              const struct socket_address *srv_address,
 100                              uint32_t flags)
 101 {
 102         struct sockaddr_in srv_addr;
 103         struct in_addr my_ip;
 104         struct in_addr srv_ip;
 105         int ret;
 106
 107         if (my_address && my_address->sockaddr) {
 108                 ret = bind(sock->fd, my_address->sockaddr, my_address->sockaddrlen);
 109                 if (ret == -1) {
 110                         return map_nt_error_from_unix_common(errno);
 111                 }
 112         } else if (my_address) {
 113                 my_ip = interpret_addr2(my_address->addr);
 114
 115                 if (my_ip.s_addr != 0 || my_address->port != 0) {
 116                         struct sockaddr_in my_addr;
 117                         ZERO_STRUCT(my_addr);
 118 #ifdef HAVE_SOCK_SIN_LEN
 119                         my_addr.sin_len         = sizeof(my_addr);
 120 #endif
 121                         my_addr.sin_addr.s_addr = my_ip.s_addr;
 122                         my_addr.sin_port        = htons(my_address->port);
 123                         my_addr.sin_family      = PF_INET;
 124
 125                         ret = bind(sock->fd, (struct sockaddr *)&my_addr, sizeof(my_addr));
 126                         if (ret == -1) {
 127                                 return map_nt_error_from_unix_common(errno);
 128                         }
 129                 }
 130         }
 131
 132         if (srv_address->sockaddr) {
 133                 ret = connect(sock->fd, srv_address->sockaddr, srv_address->sockaddrlen);
 134                 if (ret == -1) {
 135                         return map_nt_error_from_unix_common(errno);
 136                 }
 137         } else {
 138                 srv_ip = interpret_addr2(srv_address->addr);
 139                 if (!srv_ip.s_addr) {
 140                         return NT_STATUS_BAD_NETWORK_NAME;
 141                 }
 142
 143                 SMB_ASSERT(srv_address->port != 0);
 144
 145                 ZERO_STRUCT(srv_addr);
 146 #ifdef HAVE_SOCK_SIN_LEN
 147                 srv_addr.sin_len        = sizeof(srv_addr);
 148 #endif
 149                 srv_addr.sin_addr.s_addr= srv_ip.s_addr;
 150                 srv_addr.sin_port       = htons(srv_address->port);
 151                 srv_addr.sin_family     = PF_INET;
 152
 153                 ret = connect(sock->fd, (const struct sockaddr *)&srv_addr, sizeof(srv_addr));
 154                 if (ret == -1) {
 155                         return map_nt_error_from_unix_common(errno);
 156                 }
 157         }
 158
 159         return ip_connect_complete(sock, flags);
 160 }
 161
 162
 163 /*
 164   note that for simplicity of the API, socket_listen() is also
 165   use for DGRAM sockets, but in reality only a bind() is done
 166 */
 167 static NTSTATUS ipv4_listen(struct socket_context *sock,
 168                             const struct socket_address *my_address,
 169                             int queue_size, uint32_t flags)
 170 {
 171         struct sockaddr_in my_addr;
 172         struct in_addr ip_addr;
 173         int ret;
 174
 175         socket_set_option(sock, "SO_REUSEADDR=1", NULL);
 176
 177         if (my_address->sockaddr) {
 178                 ret = bind(sock->fd, my_address->sockaddr, my_address->sockaddrlen);
 179         } else {
 180                 ip_addr = interpret_addr2(my_address->addr);
 181
 182                 ZERO_STRUCT(my_addr);
 183 #ifdef HAVE_SOCK_SIN_LEN
 184                 my_addr.sin_len         = sizeof(my_addr);
 185 #endif
 186                 my_addr.sin_addr.s_addr = ip_addr.s_addr;
 187                 my_addr.sin_port        = htons(my_address->port);
 188                 my_addr.sin_family      = PF_INET;
 189
 190                 ret = bind(sock->fd, (struct sockaddr *)&my_addr, sizeof(my_addr));
 191         }
 192
 193         if (ret == -1) {
 194                 return map_nt_error_from_unix_common(errno);
 195         }
 196
 197         if (sock->type == SOCKET_TYPE_STREAM) {
 198                 ret = listen(sock->fd, queue_size);
 199                 if (ret == -1) {
 200                         return map_nt_error_from_unix_common(errno);
 201                 }
 202         }
 203
 204         ret = set_blocking(sock->fd, false);
 205         if (ret == -1) {
 206                 return map_nt_error_from_unix_common(errno);
 207         }
 208
 209         sock->state= SOCKET_STATE_SERVER_LISTEN;
 210
 211         return NT_STATUS_OK;
 212 }
 213
 214 static NTSTATUS ipv4_accept(struct socket_context *sock, struct socket_context **new_sock)
 215 {
 216         struct sockaddr_in cli_addr;
 217         socklen_t cli_addr_len = sizeof(cli_addr);
 218         int new_fd, ret;
 219
 220         if (sock->type != SOCKET_TYPE_STREAM) {
 221                 return NT_STATUS_INVALID_PARAMETER;
 222         }
 223
 224         new_fd = accept(sock->fd, (struct sockaddr *)&cli_addr, &cli_addr_len);
 225         if (new_fd == -1) {
 226                 return map_nt_error_from_unix_common(errno);
 227         }
 228
 229         ret = set_blocking(new_fd, false);
 230         if (ret == -1) {
 231                 close(new_fd);
 232                 return map_nt_error_from_unix_common(errno);
 233         }
 234
 235         smb_set_close_on_exec(new_fd);
 236
 237
 238         /* TODO: we could add a 'accept_check' hook here
 239          *       which get the black/white lists via socket_set_accept_filter()
 240          *       or something like that
 241          *       --metze
 242          */
 243
 244         (*new_sock) = talloc(NULL, struct socket_context);
 245         if (!(*new_sock)) {
 246                 close(new_fd);
 247                 return NT_STATUS_NO_MEMORY;
 248         }
 249
 250         /* copy the socket_context */
 251         (*new_sock)->type               = sock->type;
 252         (*new_sock)->state              = SOCKET_STATE_SERVER_CONNECTED;
 253         (*new_sock)->flags              = sock->flags;
 254
 255         (*new_sock)->fd                 = new_fd;
 256
 257         (*new_sock)->private_data       = NULL;
 258         (*new_sock)->ops                = sock->ops;
 259         (*new_sock)->backend_name       = sock->backend_name;
 260
 261         return NT_STATUS_OK;
 262 }
 263
 264 static NTSTATUS ip_recv(struct socket_context *sock, void *buf,
 265                               size_t wantlen, size_t *nread)
 266 {
 267         ssize_t gotlen;
 268
 269         *nread = 0;
 270
 271         gotlen = recv(sock->fd, buf, wantlen, 0);
 272         if (gotlen == 0) {
 273                 return NT_STATUS_END_OF_FILE;
 274         } else if (gotlen == -1) {
 275                 return map_nt_error_from_unix_common(errno);
 276         }
 277
 278         *nread = gotlen;
 279
 280         return NT_STATUS_OK;
 281 }
 282
 283
 284 static NTSTATUS ipv4_recvfrom(struct socket_context *sock, void *buf,
 285                               size_t wantlen, size_t *nread,
 286                               TALLOC_CTX *addr_ctx, struct socket_address **_src)
 287 {
 288         ssize_t gotlen;
 289         struct sockaddr_in *from_addr;
 290         socklen_t from_len = sizeof(*from_addr);
 291         struct socket_address *src;
 292         char addrstring[INET_ADDRSTRLEN];
 293
 294         src = talloc(addr_ctx, struct socket_address);
 295         if (!src) {
 296                 return NT_STATUS_NO_MEMORY;
 297         }
 298
 299         src->family = sock->backend_name;
 300
 301         from_addr = talloc(src, struct sockaddr_in);
 302         if (!from_addr) {
 303                 talloc_free(src);
 304                 return NT_STATUS_NO_MEMORY;
 305         }
 306
 307         src->sockaddr = (struct sockaddr *)from_addr;
 308
 309         *nread = 0;
 310
 311         gotlen = recvfrom(sock->fd, buf, wantlen, 0,
 312                           src->sockaddr, &from_len);
 313         if (gotlen == 0) {
 314                 talloc_free(src);
 315                 return NT_STATUS_END_OF_FILE;
 316         }
 317         if (gotlen == -1) {
 318                 talloc_free(src);
 319                 return map_nt_error_from_unix_common(errno);
 320         }
 321
 322         src->sockaddrlen = from_len;
 323
 324         if (inet_ntop(AF_INET, &from_addr->sin_addr, addrstring,
 325                          sizeof(addrstring)) == NULL) {
 326                 talloc_free(src);
 327                 return NT_STATUS_INTERNAL_ERROR;
 328         }
 329         src->addr = talloc_strdup(src, addrstring);
 330         if (src->addr == NULL) {
 331                 talloc_free(src);
 332                 return NT_STATUS_NO_MEMORY;
 333         }
 334         src->port = ntohs(from_addr->sin_port);
 335
 336         *nread  = gotlen;
 337         *_src   = src;
 338         return NT_STATUS_OK;
 339 }
 340
 341 static NTSTATUS ip_send(struct socket_context *sock,
 342                               const DATA_BLOB *blob, size_t *sendlen)
 343 {
 344         ssize_t len;
 345
 346         *sendlen = 0;
 347
 348         len = send(sock->fd, blob->data, blob->length, 0);
 349         if (len == -1) {
 350                 return map_nt_error_from_unix_common(errno);
 351         }
 352
 353         *sendlen = len;
 354
 355         return NT_STATUS_OK;
 356 }
 357
 358 static NTSTATUS ipv4_sendto(struct socket_context *sock,
 359                             const DATA_BLOB *blob, size_t *sendlen,
 360                             const struct socket_address *dest_addr)
 361 {
 362         ssize_t len;
 363
 364         if (dest_addr->sockaddr) {
 365                 len = sendto(sock->fd, blob->data, blob->length, 0,
 366                              dest_addr->sockaddr, dest_addr->sockaddrlen);
 367         } else {
 368                 struct sockaddr_in srv_addr;
 369                 struct in_addr addr;
 370
 371                 SMB_ASSERT(dest_addr->port != 0);
 372
 373                 ZERO_STRUCT(srv_addr);
 374 #ifdef HAVE_SOCK_SIN_LEN
 375                 srv_addr.sin_len         = sizeof(srv_addr);
 376 #endif
 377                 addr                     = interpret_addr2(dest_addr->addr);
 378                 if (addr.s_addr == 0) {
 379                         return NT_STATUS_HOST_UNREACHABLE;
 380                 }
 381                 srv_addr.sin_addr.s_addr = addr.s_addr;
 382                 srv_addr.sin_port        = htons(dest_addr->port);
 383                 srv_addr.sin_family      = PF_INET;
 384
 385                 *sendlen = 0;
 386
 387                 len = sendto(sock->fd, blob->data, blob->length, 0,
 388                              (struct sockaddr *)&srv_addr, sizeof(srv_addr));
 389         }
 390         if (len == -1) {
 391                 return map_nt_error_from_unix_common(errno);
 392         }
 393
 394         *sendlen = len;
 395
 396         return NT_STATUS_OK;
 397 }
 398
 399 static NTSTATUS ipv4_set_option(struct socket_context *sock, const char *option, const char *val)
 400 {
 401         set_socket_options(sock->fd, option);
 402         return NT_STATUS_OK;
 403 }
 404
 405 static char *ipv4_get_peer_name(struct socket_context *sock, TALLOC_CTX *mem_ctx)
 406 {
 407         struct sockaddr_in peer_addr;
 408         socklen_t len = sizeof(peer_addr);
 409         struct hostent *he;
 410         int ret;
 411
 412         ret = getpeername(sock->fd, (struct sockaddr *)&peer_addr, &len);
 413         if (ret == -1) {
 414                 return NULL;
 415         }
 416
 417         he = gethostbyaddr((char *)&peer_addr.sin_addr, sizeof(peer_addr.sin_addr), AF_INET);
 418         if (he == NULL) {
 419                 return NULL;
 420         }
 421
 422         return talloc_strdup(mem_ctx, he->h_name);
 423 }
 424
 425 static struct socket_address *ipv4_get_peer_addr(struct socket_context *sock, TALLOC_CTX *mem_ctx)
 426 {
 427         struct sockaddr_in *peer_addr;
 428         socklen_t len = sizeof(*peer_addr);
 429         struct socket_address *peer;
 430         char addrstring[INET_ADDRSTRLEN];
 431         int ret;
 432
 433         peer = talloc(mem_ctx, struct socket_address);
 434         if (!peer) {
 435                 return NULL;
 436         }
 437
 438         peer->family = sock->backend_name;
 439         peer_addr = talloc(peer, struct sockaddr_in);
 440         if (!peer_addr) {
 441                 talloc_free(peer);
 442                 return NULL;
 443         }
 444
 445         peer->sockaddr = (struct sockaddr *)peer_addr;
 446
 447         ret = getpeername(sock->fd, peer->sockaddr, &len);
 448         if (ret == -1) {
 449                 talloc_free(peer);
 450                 return NULL;
 451         }
 452
 453         peer->sockaddrlen = len;
 454
 455         if (inet_ntop(AF_INET, &peer_addr->sin_addr, addrstring,
 456                          sizeof(addrstring)) == NULL) {
 457                 talloc_free(peer);
 458                 return NULL;
 459         }
 460         peer->addr = talloc_strdup(peer, addrstring);
 461         if (!peer->addr) {
 462                 talloc_free(peer);
 463                 return NULL;
 464         }
 465         peer->port = ntohs(peer_addr->sin_port);
 466
 467         return peer;
 468 }
 469
 470 static struct socket_address *ipv4_get_my_addr(struct socket_context *sock, TALLOC_CTX *mem_ctx)
 471 {
 472         struct sockaddr_in *local_addr;
 473         socklen_t len = sizeof(*local_addr);
 474         struct socket_address *local;
 475         char addrstring[INET_ADDRSTRLEN];
 476         int ret;
 477
 478         local = talloc(mem_ctx, struct socket_address);
 479         if (!local) {
 480                 return NULL;
 481         }
 482
 483         local->family = sock->backend_name;
 484         local_addr = talloc(local, struct sockaddr_in);
 485         if (!local_addr) {
 486                 talloc_free(local);
 487                 return NULL;
 488         }
 489
 490         local->sockaddr = (struct sockaddr *)local_addr;
 491
 492         ret = getsockname(sock->fd, local->sockaddr, &len);
 493         if (ret == -1) {
 494                 talloc_free(local);
 495                 return NULL;
 496         }
 497
 498         local->sockaddrlen = len;
 499
 500         if (inet_ntop(AF_INET, &local_addr->sin_addr, addrstring,
 501                          sizeof(addrstring)) == NULL) {
 502                 talloc_free(local);
 503                 return NULL;
 504         }
 505         local->addr = talloc_strdup(local, addrstring);
 506         if (!local->addr) {
 507                 talloc_free(local);
 508                 return NULL;
 509         }
 510         local->port = ntohs(local_addr->sin_port);
 511
 512         return local;
 513 }
 514 static int ip_get_fd(struct socket_context *sock)
 515 {
 516         return sock->fd;
 517 }
 518
 519 static NTSTATUS ip_pending(struct socket_context *sock, size_t *npending)
 520 {
 521         int value = 0;
 522         if (ioctl(sock->fd, FIONREAD, &value) == 0) {
 523                 *npending = value;
 524                 return NT_STATUS_OK;
 525         }
 526         return map_nt_error_from_unix_common(errno);
 527 }
 528
 529 static const struct socket_ops ipv4_ops = {
 530         .name                   = "ipv4",
 531         .fn_init                = ipv4_init,
 532         .fn_connect             = ipv4_connect,
 533         .fn_connect_complete    = ip_connect_complete,
 534         .fn_listen              = ipv4_listen,
 535         .fn_accept              = ipv4_accept,
 536         .fn_recv                = ip_recv,
 537         .fn_recvfrom            = ipv4_recvfrom,
 538         .fn_send                = ip_send,
 539         .fn_sendto              = ipv4_sendto,
 540         .fn_pending             = ip_pending,
 541         .fn_close               = ip_close,
 542
 543         .fn_set_option          = ipv4_set_option,
 544
 545         .fn_get_peer_name       = ipv4_get_peer_name,
 546         .fn_get_peer_addr       = ipv4_get_peer_addr,
 547         .fn_get_my_addr         = ipv4_get_my_addr,
 548
 549         .fn_get_fd              = ip_get_fd
 550 };
 551
 552 _PUBLIC_ const struct socket_ops *socket_ipv4_ops(enum socket_type type)
 553 {
 554         return &ipv4_ops;
 555 }
 556
 557 #ifdef HAVE_IPV6
 558
 559 static struct in6_addr interpret_addr6(const char *name)
 560 {
 561         char addr[INET6_ADDRSTRLEN];
 562         struct in6_addr dest6;
 563         const char *sp = name;
 564         char *p;
 565         int ret;
 566
 567         if (sp == NULL) return in6addr_any;
 568
 569         p = strchr_m(sp, '%');
 570
 571         if (strcasecmp(sp, "localhost") == 0) {
 572                 sp = "::1";
 573         }
 574
 575         /*
 576          * Cope with link-local.
 577          * This is IP:v6:addr%ifname.
 578          */
 579
 580         if (p && (p > sp) && (if_nametoindex(p+1) != 0)) {
 581                 strlcpy(addr, sp,
 582                         MIN(PTR_DIFF(p,sp)+1,
 583                                 sizeof(addr)));
 584                 sp = addr;
 585         }
 586
 587         ret = inet_pton(AF_INET6, sp, &dest6);
 588         if (ret > 0) {
 589                 return dest6;
 590         }
 591
 592         return in6addr_any;
 593 }
 594
 595 static NTSTATUS ipv6_init(struct socket_context *sock)
 596 {
 597         int type;
 598
 599         switch (sock->type) {
 600         case SOCKET_TYPE_STREAM:
 601                 type = SOCK_STREAM;
 602                 break;
 603         case SOCKET_TYPE_DGRAM:
 604                 type = SOCK_DGRAM;
 605                 break;
 606         default:
 607                 return NT_STATUS_INVALID_PARAMETER;
 608         }
 609
 610         sock->fd = socket(PF_INET6, type, 0);
 611         if (sock->fd == -1) {
 612                 return map_nt_error_from_unix_common(errno);
 613         }
 614
 615         smb_set_close_on_exec(sock->fd);
 616
 617         sock->backend_name = "ipv6";
 618         sock->family = AF_INET6;
 619
 620         return NT_STATUS_OK;
 621 }
 622
 623 static NTSTATUS ipv6_tcp_connect(struct socket_context *sock,
 624                                  const struct socket_address *my_address,
 625                                  const struct socket_address *srv_address,
 626                                  uint32_t flags)
 627 {
 628         int ret;
 629
 630         if (my_address && my_address->sockaddr) {
 631                 ret = bind(sock->fd, my_address->sockaddr, my_address->sockaddrlen);
 632                 if (ret == -1) {
 633                         return map_nt_error_from_unix_common(errno);
 634                 }
 635         } else if (my_address) {
 636                 struct in6_addr my_ip;
 637                 my_ip = interpret_addr6(my_address->addr);
 638
 639                 if (memcmp(&my_ip, &in6addr_any, sizeof(my_ip)) || my_address->port != 0) {
 640                         struct sockaddr_in6 my_addr;
 641                         ZERO_STRUCT(my_addr);
 642                         my_addr.sin6_addr       = my_ip;
 643                         my_addr.sin6_port       = htons(my_address->port);
 644                         my_addr.sin6_family     = PF_INET6;
 645
 646                         ret = bind(sock->fd, (struct sockaddr *)&my_addr, sizeof(my_addr));
 647                         if (ret == -1) {
 648                                 return map_nt_error_from_unix_common(errno);
 649                         }
 650                 }
 651         }
 652
 653         if (srv_address->sockaddr) {
 654                 ret = connect(sock->fd, srv_address->sockaddr, srv_address->sockaddrlen);
 655         } else {
 656                 struct in6_addr srv_ip;
 657                 struct sockaddr_in6 srv_addr;
 658                 srv_ip = interpret_addr6(srv_address->addr);
 659                 if (memcmp(&srv_ip, &in6addr_any, sizeof(srv_ip)) == 0) {
 660                         return NT_STATUS_BAD_NETWORK_NAME;
 661                 }
 662
 663                 ZERO_STRUCT(srv_addr);
 664                 srv_addr.sin6_addr      = srv_ip;
 665                 srv_addr.sin6_port      = htons(srv_address->port);
 666                 srv_addr.sin6_family    = PF_INET6;
 667
 668                 ret = connect(sock->fd, (const struct sockaddr *)&srv_addr, sizeof(srv_addr));
 669         }
 670         if (ret == -1) {
 671                 return map_nt_error_from_unix_common(errno);
 672         }
 673
 674         return ip_connect_complete(sock, flags);
 675 }
 676
 677 /*
 678   fix the sin6_scope_id based on the address interface
 679  */
 680 static void fix_scope_id(struct sockaddr_in6 *in6,
 681                          const char *address)
 682 {
 683         const char *p = strchr(address, '%');
 684         if (p != NULL) {
 685                 in6->sin6_scope_id = if_nametoindex(p+1);
 686         }
 687 }
 688
 689
 690 static NTSTATUS ipv6_listen(struct socket_context *sock,
 691                             const struct socket_address *my_address,
 692                             int queue_size, uint32_t flags)
 693 {
 694         struct sockaddr_in6 my_addr;
 695         struct in6_addr ip_addr;
 696         int ret;
 697
 698         socket_set_option(sock, "SO_REUSEADDR=1", NULL);
 699
 700         if (my_address->sockaddr) {
 701                 ret = bind(sock->fd, my_address->sockaddr, my_address->sockaddrlen);
 702         } else {
 703                 int one = 1;
 704                 ip_addr = interpret_addr6(my_address->addr);
 705
 706                 ZERO_STRUCT(my_addr);
 707                 my_addr.sin6_addr       = ip_addr;
 708                 my_addr.sin6_port       = htons(my_address->port);
 709                 my_addr.sin6_family     = PF_INET6;
 710                 fix_scope_id(&my_addr, my_address->addr);
 711
 712                 /* when binding on ipv6 we always want to only bind on v6 */
 713                 ret = setsockopt(sock->fd, IPPROTO_IPV6, IPV6_V6ONLY,
 714                                  (const void *)&one, sizeof(one));
 715                 if (ret != -1) {
 716                         ret = bind(sock->fd, (struct sockaddr *)&my_addr, sizeof(my_addr));
 717                 }
 718         }
 719
 720         if (ret == -1) {
 721                 return map_nt_error_from_unix_common(errno);
 722         }
 723
 724         if (sock->type == SOCKET_TYPE_STREAM) {
 725                 ret = listen(sock->fd, queue_size);
 726                 if (ret == -1) {
 727                         return map_nt_error_from_unix_common(errno);
 728                 }
 729         }
 730
 731         ret = set_blocking(sock->fd, false);
 732         if (ret == -1) {
 733                 return map_nt_error_from_unix_common(errno);
 734         }
 735
 736         sock->state= SOCKET_STATE_SERVER_LISTEN;
 737
 738         return NT_STATUS_OK;
 739 }
 740
 741 static NTSTATUS ipv6_tcp_accept(struct socket_context *sock, struct socket_context **new_sock)
 742 {
 743         struct sockaddr_in6 cli_addr;
 744         socklen_t cli_addr_len = sizeof(cli_addr);
 745         int new_fd, ret;
 746
 747         if (sock->type != SOCKET_TYPE_STREAM) {
 748                 return NT_STATUS_INVALID_PARAMETER;
 749         }
 750
 751         new_fd = accept(sock->fd, (struct sockaddr *)&cli_addr, &cli_addr_len);
 752         if (new_fd == -1) {
 753                 return map_nt_error_from_unix_common(errno);
 754         }
 755
 756         ret = set_blocking(new_fd, false);
 757         if (ret == -1) {
 758                 close(new_fd);
 759                 return map_nt_error_from_unix_common(errno);
 760         }
 761         smb_set_close_on_exec(new_fd);
 762
 763         /* TODO: we could add a 'accept_check' hook here
 764          *       which get the black/white lists via socket_set_accept_filter()
 765          *       or something like that
 766          *       --metze
 767          */
 768
 769         (*new_sock) = talloc(NULL, struct socket_context);
 770         if (!(*new_sock)) {
 771                 close(new_fd);
 772                 return NT_STATUS_NO_MEMORY;
 773         }
 774
 775         /* copy the socket_context */
 776         (*new_sock)->type               = sock->type;
 777         (*new_sock)->state              = SOCKET_STATE_SERVER_CONNECTED;
 778         (*new_sock)->flags              = sock->flags;
 779
 780         (*new_sock)->fd                 = new_fd;
 781
 782         (*new_sock)->private_data       = NULL;
 783         (*new_sock)->ops                = sock->ops;
 784         (*new_sock)->backend_name       = sock->backend_name;
 785
 786         return NT_STATUS_OK;
 787 }
 788
 789 static NTSTATUS ipv6_recvfrom(struct socket_context *sock, void *buf,
 790                               size_t wantlen, size_t *nread,
 791                               TALLOC_CTX *addr_ctx, struct socket_address **_src)
 792 {
 793         ssize_t gotlen;
 794         struct sockaddr_in6 *from_addr;
 795         socklen_t from_len = sizeof(*from_addr);
 796         struct socket_address *src;
 797         char addrstring[INET6_ADDRSTRLEN];
 798
 799         src = talloc(addr_ctx, struct socket_address);
 800         if (!src) {
 801                 return NT_STATUS_NO_MEMORY;
 802         }
 803
 804         src->family = sock->backend_name;
 805
 806         from_addr = talloc(src, struct sockaddr_in6);
 807         if (!from_addr) {
 808                 talloc_free(src);
 809                 return NT_STATUS_NO_MEMORY;
 810         }
 811
 812         src->sockaddr = (struct sockaddr *)from_addr;
 813
 814         *nread = 0;
 815
 816         gotlen = recvfrom(sock->fd, buf, wantlen, 0,
 817                           src->sockaddr, &from_len);
 818         if (gotlen == 0) {
 819                 talloc_free(src);
 820                 return NT_STATUS_END_OF_FILE;
 821         } else if (gotlen == -1) {
 822                 talloc_free(src);
 823                 return map_nt_error_from_unix_common(errno);
 824         }
 825
 826         src->sockaddrlen = from_len;
 827
 828         if (inet_ntop(AF_INET6, &from_addr->sin6_addr, addrstring, sizeof(addrstring)) == NULL) {
 829                 DEBUG(0, ("Unable to convert address to string: %s\n", strerror(errno)));
 830                 talloc_free(src);
 831                 return NT_STATUS_INTERNAL_ERROR;
 832         }
 833
 834         src->addr = talloc_strdup(src, addrstring);
 835         if (src->addr == NULL) {
 836                 talloc_free(src);
 837                 return NT_STATUS_NO_MEMORY;
 838         }
 839         src->port = ntohs(from_addr->sin6_port);
 840
 841         *nread  = gotlen;
 842         *_src   = src;
 843         return NT_STATUS_OK;
 844 }
 845
 846 static NTSTATUS ipv6_sendto(struct socket_context *sock,
 847                             const DATA_BLOB *blob, size_t *sendlen,
 848                             const struct socket_address *dest_addr)
 849 {
 850         ssize_t len;
 851
 852         if (dest_addr->sockaddr) {
 853                 len = sendto(sock->fd, blob->data, blob->length, 0,
 854                              dest_addr->sockaddr, dest_addr->sockaddrlen);
 855         } else {
 856                 struct sockaddr_in6 srv_addr;
 857                 struct in6_addr addr;
 858
 859                 ZERO_STRUCT(srv_addr);
 860                 addr                     = interpret_addr6(dest_addr->addr);
 861                 if (memcmp(&addr.s6_addr, &in6addr_any,
 862                            sizeof(addr.s6_addr)) == 0) {
 863                         return NT_STATUS_HOST_UNREACHABLE;
 864                 }
 865                 srv_addr.sin6_addr = addr;
 866                 srv_addr.sin6_port        = htons(dest_addr->port);
 867                 srv_addr.sin6_family      = PF_INET6;
 868
 869                 *sendlen = 0;
 870
 871                 len = sendto(sock->fd, blob->data, blob->length, 0,
 872                              (struct sockaddr *)&srv_addr, sizeof(srv_addr));
 873         }
 874         if (len == -1) {
 875                 return map_nt_error_from_unix_common(errno);
 876         }
 877
 878         *sendlen = len;
 879
 880         return NT_STATUS_OK;
 881 }
 882
 883 static NTSTATUS ipv6_set_option(struct socket_context *sock, const char *option, const char *val)
 884 {
 885         set_socket_options(sock->fd, option);
 886         return NT_STATUS_OK;
 887 }
 888
 889 static char *ipv6_tcp_get_peer_name(struct socket_context *sock, TALLOC_CTX *mem_ctx)
 890 {
 891         struct sockaddr_in6 peer_addr;
 892         socklen_t len = sizeof(peer_addr);
 893         struct hostent *he;
 894         int ret;
 895
 896         ret = getpeername(sock->fd, (struct sockaddr *)&peer_addr, &len);
 897         if (ret == -1) {
 898                 return NULL;
 899         }
 900
 901         he = gethostbyaddr((char *)&peer_addr.sin6_addr, sizeof(peer_addr.sin6_addr), AF_INET6);
 902         if (he == NULL) {
 903                 return NULL;
 904         }
 905
 906         return talloc_strdup(mem_ctx, he->h_name);
 907 }
 908
 909 static struct socket_address *ipv6_tcp_get_peer_addr(struct socket_context *sock, TALLOC_CTX *mem_ctx)
 910 {
 911         struct sockaddr_in6 *peer_addr;
 912         socklen_t len = sizeof(*peer_addr);
 913         struct socket_address *peer;
 914         int ret;
 915         char addr[128];
 916         const char *addr_ret;
 917
 918         peer = talloc(mem_ctx, struct socket_address);
 919         if (!peer) {
 920                 return NULL;
 921         }
 922
 923         peer->family = sock->backend_name;
 924         peer_addr = talloc(peer, struct sockaddr_in6);
 925         if (!peer_addr) {
 926                 talloc_free(peer);
 927                 return NULL;
 928         }
 929
 930         peer->sockaddr = (struct sockaddr *)peer_addr;
 931
 932         ret = getpeername(sock->fd, peer->sockaddr, &len);
 933         if (ret == -1) {
 934                 talloc_free(peer);
 935                 return NULL;
 936         }
 937
 938         peer->sockaddrlen = len;
 939
 940         addr_ret = inet_ntop(AF_INET6, &peer_addr->sin6_addr, addr, sizeof(addr));
 941         if (addr_ret == NULL) {
 942                 talloc_free(peer);
 943                 return NULL;
 944         }
 945
 946         peer->addr = talloc_strdup(peer, addr_ret);
 947         if (peer->addr == NULL) {
 948                 talloc_free(peer);
 949                 return NULL;
 950         }
 951
 952         peer->port = ntohs(peer_addr->sin6_port);
 953
 954         return peer;
 955 }
 956
 957 static struct socket_address *ipv6_tcp_get_my_addr(struct socket_context *sock, TALLOC_CTX *mem_ctx)
 958 {
 959         struct sockaddr_in6 *local_addr;
 960         socklen_t len = sizeof(*local_addr);
 961         struct socket_address *local;
 962         int ret;
 963         char addrstring[INET6_ADDRSTRLEN];
 964
 965         local = talloc(mem_ctx, struct socket_address);
 966         if (!local) {
 967                 return NULL;
 968         }
 969
 970         local->family = sock->backend_name;
 971         local_addr = talloc(local, struct sockaddr_in6);
 972         if (!local_addr) {
 973                 talloc_free(local);
 974                 return NULL;
 975         }
 976
 977         local->sockaddr = (struct sockaddr *)local_addr;
 978
 979         ret = getsockname(sock->fd, local->sockaddr, &len);
 980         if (ret == -1) {
 981                 talloc_free(local);
 982                 return NULL;
 983         }
 984
 985         local->sockaddrlen = len;
 986
 987         if (inet_ntop(AF_INET6, &local_addr->sin6_addr, addrstring,
 988                        sizeof(addrstring)) == NULL) {
 989                 DEBUG(0, ("Unable to convert address to string: %s\n",
 990                           strerror(errno)));
 991                 talloc_free(local);
 992                 return NULL;
 993         }
 994
 995         local->addr = talloc_strdup(local, addrstring);
 996         if (!local->addr) {
 997                 talloc_free(local);
 998                 return NULL;
 999         }
1000         local->port = ntohs(local_addr->sin6_port);
1001
1002         return local;
1003 }
1004
1005 static const struct socket_ops ipv6_tcp_ops = {
1006         .name                   = "ipv6",
1007         .fn_init                = ipv6_init,
1008         .fn_connect             = ipv6_tcp_connect,
1009         .fn_connect_complete    = ip_connect_complete,
1010         .fn_listen              = ipv6_listen,
1011         .fn_accept              = ipv6_tcp_accept,
1012         .fn_recv                = ip_recv,
1013         .fn_recvfrom            = ipv6_recvfrom,
1014         .fn_send                = ip_send,
1015         .fn_sendto              = ipv6_sendto,
1016         .fn_pending             = ip_pending,
1017         .fn_close               = ip_close,
1018
1019         .fn_set_option          = ipv6_set_option,
1020
1021         .fn_get_peer_name       = ipv6_tcp_get_peer_name,
1022         .fn_get_peer_addr       = ipv6_tcp_get_peer_addr,
1023         .fn_get_my_addr         = ipv6_tcp_get_my_addr,
1024
1025         .fn_get_fd              = ip_get_fd
1026 };
1027
1028 _PUBLIC_ const struct socket_ops *socket_ipv6_ops(enum socket_type type)
1029 {
1030         return &ipv6_tcp_ops;
1031 }
1032
1033 #endif