2004-10-28 18:57:48 +00:00
/*
Unix SMB / CIFS implementation .
Socket IPv6 functions
Copyright ( C ) Stefan Metzmacher 2004
Copyright ( C ) Jelmer Vernooij 2004
This program is free software ; you can redistribute it and / or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation ; either version 2 of the License , or
( at your option ) any later version .
This program is distributed in the hope that it will be useful ,
but WITHOUT ANY WARRANTY ; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE . See the
GNU General Public License for more details .
You should have received a copy of the GNU General Public License
along with this program ; if not , write to the Free Software
Foundation , Inc . , 675 Mass Ave , Cambridge , MA 0213 9 , USA .
*/
# include "includes.h"
2005-02-10 06:59:29 +00:00
# include "lib/socket/socket.h"
2006-09-10 10:00:42 +00:00
# include "system/filesys.h" /* needed for close() */
2004-11-01 22:48:25 +00:00
# include "system/network.h"
2004-10-28 18:57:48 +00:00
static struct in6_addr interpret_addr6 ( const char * name )
{
struct hostent * he ;
if ( name = = NULL ) return in6addr_any ;
2006-05-22 09:02:16 +00:00
if ( strcasecmp ( name , " localhost " ) = = 0 ) {
name = " ::1 " ;
}
2004-10-28 18:57:48 +00:00
he = gethostbyname2 ( name , PF_INET6 ) ;
if ( he = = NULL ) return in6addr_any ;
return * ( ( struct in6_addr * ) he - > h_addr ) ;
}
static NTSTATUS ipv6_tcp_init ( struct socket_context * sock )
{
sock - > fd = socket ( PF_INET6 , SOCK_STREAM , 0 ) ;
if ( sock - > fd = = - 1 ) {
return map_nt_error_from_unix ( errno ) ;
}
2005-08-28 02:37:38 +00:00
sock - > backend_name = " ipv6 " ;
2004-10-28 18:57:48 +00:00
return NT_STATUS_OK ;
}
static void ipv6_tcp_close ( struct socket_context * sock )
{
close ( sock - > fd ) ;
}
2005-01-15 10:28:08 +00:00
static NTSTATUS ipv6_tcp_connect_complete ( struct socket_context * sock , uint32_t flags )
{
int error = 0 , ret ;
socklen_t len = sizeof ( error ) ;
/* check for any errors that may have occurred - this is needed
for non - blocking connect */
ret = getsockopt ( sock - > fd , SOL_SOCKET , SO_ERROR , & error , & len ) ;
if ( ret = = - 1 ) {
return map_nt_error_from_unix ( errno ) ;
}
if ( error ! = 0 ) {
return map_nt_error_from_unix ( error ) ;
}
if ( ! ( flags & SOCKET_FLAG_BLOCK ) ) {
ret = set_blocking ( sock - > fd , False ) ;
if ( ret = = - 1 ) {
return map_nt_error_from_unix ( errno ) ;
}
}
sock - > state = SOCKET_STATE_CLIENT_CONNECTED ;
return NT_STATUS_OK ;
}
2004-10-28 18:57:48 +00:00
static NTSTATUS ipv6_tcp_connect ( struct socket_context * sock ,
2006-01-09 22:12:53 +00:00
const struct socket_address * my_address ,
const struct socket_address * srv_address ,
2004-10-28 18:57:48 +00:00
uint32_t flags )
{
int ret ;
2006-01-09 22:12:53 +00:00
if ( my_address & & my_address - > sockaddr ) {
ret = bind ( sock - > fd , my_address - > sockaddr , my_address - > sockaddrlen ) ;
2004-10-28 18:57:48 +00:00
if ( ret = = - 1 ) {
return map_nt_error_from_unix ( errno ) ;
}
2006-01-09 22:12:53 +00:00
} else if ( my_address ) {
struct in6_addr my_ip ;
my_ip = interpret_addr6 ( my_address - > addr ) ;
if ( memcmp ( & my_ip , & in6addr_any , sizeof ( my_ip ) ) | | my_address - > port ! = 0 ) {
struct sockaddr_in6 my_addr ;
ZERO_STRUCT ( my_addr ) ;
my_addr . sin6_addr = my_ip ;
my_addr . sin6_port = htons ( my_address - > port ) ;
my_addr . sin6_family = PF_INET6 ;
ret = bind ( sock - > fd , ( struct sockaddr * ) & my_addr , sizeof ( my_addr ) ) ;
if ( ret = = - 1 ) {
return map_nt_error_from_unix ( errno ) ;
}
}
2004-10-28 18:57:48 +00:00
}
2006-01-09 22:12:53 +00:00
if ( srv_address - > sockaddr ) {
ret = connect ( sock - > fd , srv_address - > sockaddr , srv_address - > sockaddrlen ) ;
} else {
struct in6_addr srv_ip ;
struct sockaddr_in6 srv_addr ;
srv_ip = interpret_addr6 ( srv_address - > addr ) ;
if ( memcmp ( & srv_ip , & in6addr_any , sizeof ( srv_ip ) ) = = 0 ) {
return NT_STATUS_BAD_NETWORK_NAME ;
}
ZERO_STRUCT ( srv_addr ) ;
srv_addr . sin6_addr = srv_ip ;
srv_addr . sin6_port = htons ( srv_address - > port ) ;
srv_addr . sin6_family = PF_INET6 ;
ret = connect ( sock - > fd , ( const struct sockaddr * ) & srv_addr , sizeof ( srv_addr ) ) ;
2005-03-19 10:28:31 +00:00
}
2004-10-28 18:57:48 +00:00
if ( ret = = - 1 ) {
return map_nt_error_from_unix ( errno ) ;
}
2005-01-15 10:28:08 +00:00
return ipv6_tcp_connect_complete ( sock , flags ) ;
2004-10-28 18:57:48 +00:00
}
static NTSTATUS ipv6_tcp_listen ( struct socket_context * sock ,
2006-01-09 22:12:53 +00:00
const struct socket_address * my_address ,
int queue_size , uint32_t flags )
2004-10-28 18:57:48 +00:00
{
struct sockaddr_in6 my_addr ;
struct in6_addr ip_addr ;
int ret ;
2005-01-30 10:24:36 +00:00
socket_set_option ( sock , " SO_REUSEADDR=1 " , NULL ) ;
2006-01-09 22:12:53 +00:00
if ( my_address - > sockaddr ) {
ret = bind ( sock - > fd , my_address - > sockaddr , my_address - > sockaddrlen ) ;
} else {
ip_addr = interpret_addr6 ( my_address - > addr ) ;
ZERO_STRUCT ( my_addr ) ;
my_addr . sin6_addr = ip_addr ;
my_addr . sin6_port = htons ( my_address - > port ) ;
my_addr . sin6_family = PF_INET6 ;
ret = bind ( sock - > fd , ( struct sockaddr * ) & my_addr , sizeof ( my_addr ) ) ;
}
2004-10-28 18:57:48 +00:00
if ( ret = = - 1 ) {
return map_nt_error_from_unix ( errno ) ;
}
2007-04-23 15:32:47 +00:00
if ( sock - > type = = SOCKET_TYPE_STREAM ) {
ret = listen ( sock - > fd , queue_size ) ;
if ( ret = = - 1 ) {
return map_nt_error_from_unix ( errno ) ;
}
2004-10-28 18:57:48 +00:00
}
if ( ! ( flags & SOCKET_FLAG_BLOCK ) ) {
ret = set_blocking ( sock - > fd , False ) ;
if ( ret = = - 1 ) {
return map_nt_error_from_unix ( errno ) ;
}
}
sock - > state = SOCKET_STATE_SERVER_LISTEN ;
return NT_STATUS_OK ;
}
static NTSTATUS ipv6_tcp_accept ( struct socket_context * sock , struct socket_context * * new_sock )
{
struct sockaddr_in cli_addr ;
socklen_t cli_addr_len = sizeof ( cli_addr ) ;
int new_fd ;
2007-04-24 13:55:04 +00:00
if ( sock - > type ! = SOCKET_TYPE_STREAM ) {
return NT_STATUS_INVALID_PARAMETER ;
}
2004-10-28 18:57:48 +00:00
new_fd = accept ( sock - > fd , ( struct sockaddr * ) & cli_addr , & cli_addr_len ) ;
if ( new_fd = = - 1 ) {
return map_nt_error_from_unix ( errno ) ;
}
if ( ! ( sock - > flags & SOCKET_FLAG_BLOCK ) ) {
int ret = set_blocking ( new_fd , False ) ;
if ( ret = = - 1 ) {
close ( new_fd ) ;
return map_nt_error_from_unix ( errno ) ;
}
}
/* TODO: we could add a 'accept_check' hook here
* which get the black / white lists via socket_set_accept_filter ( )
* or something like that
* - - metze
*/
2005-01-27 07:08:20 +00:00
( * new_sock ) = talloc ( NULL , struct socket_context ) ;
2004-10-28 18:57:48 +00:00
if ( ! ( * new_sock ) ) {
close ( new_fd ) ;
return NT_STATUS_NO_MEMORY ;
}
/* copy the socket_context */
( * new_sock ) - > type = sock - > type ;
( * new_sock ) - > state = SOCKET_STATE_SERVER_CONNECTED ;
( * new_sock ) - > flags = sock - > flags ;
( * new_sock ) - > fd = new_fd ;
( * new_sock ) - > private_data = NULL ;
( * new_sock ) - > ops = sock - > ops ;
2005-08-28 02:37:49 +00:00
( * new_sock ) - > backend_name = sock - > backend_name ;
2004-10-28 18:57:48 +00:00
return NT_STATUS_OK ;
}
static NTSTATUS ipv6_tcp_recv ( struct socket_context * sock , void * buf ,
2006-04-30 05:58:31 +00:00
size_t wantlen , size_t * nread )
2004-10-28 18:57:48 +00:00
{
ssize_t gotlen ;
* nread = 0 ;
2006-04-30 05:58:31 +00:00
gotlen = recv ( sock - > fd , buf , wantlen , 0 ) ;
2004-10-28 18:57:48 +00:00
if ( gotlen = = 0 ) {
return NT_STATUS_END_OF_FILE ;
} else if ( gotlen = = - 1 ) {
return map_nt_error_from_unix ( errno ) ;
}
* nread = gotlen ;
return NT_STATUS_OK ;
}
2007-04-24 13:55:04 +00:00
static NTSTATUS ipv6_recvfrom ( struct socket_context * sock , void * buf ,
size_t wantlen , size_t * nread ,
TALLOC_CTX * addr_ctx , struct socket_address * * _src )
{
ssize_t gotlen ;
struct sockaddr_in6 * from_addr ;
socklen_t from_len = sizeof ( * from_addr ) ;
struct socket_address * src ;
struct hostent * he ;
src = talloc ( addr_ctx , struct socket_address ) ;
if ( ! src ) {
return NT_STATUS_NO_MEMORY ;
}
src - > family = sock - > backend_name ;
from_addr = talloc ( src , struct sockaddr_in6 ) ;
if ( ! from_addr ) {
talloc_free ( src ) ;
return NT_STATUS_NO_MEMORY ;
}
src - > sockaddr = ( struct sockaddr * ) from_addr ;
* nread = 0 ;
gotlen = recvfrom ( sock - > fd , buf , wantlen , 0 ,
src - > sockaddr , & from_len ) ;
if ( gotlen = = 0 ) {
talloc_free ( src ) ;
return NT_STATUS_END_OF_FILE ;
} else if ( gotlen = = - 1 ) {
talloc_free ( src ) ;
return map_nt_error_from_unix ( errno ) ;
}
src - > sockaddrlen = from_len ;
he = gethostbyaddr ( ( void * ) & from_addr - > sin6_addr , sizeof ( from_addr - > sin6_addr ) , AF_INET6 ) ;
if ( he = = NULL ) {
talloc_free ( src ) ;
return NT_STATUS_INTERNAL_ERROR ;
}
src - > addr = talloc_strdup ( src , he - > h_name ) ;
if ( src - > addr = = NULL ) {
talloc_free ( src ) ;
return NT_STATUS_NO_MEMORY ;
}
src - > port = ntohs ( from_addr - > sin6_port ) ;
* nread = gotlen ;
* _src = src ;
return NT_STATUS_OK ;
}
2004-10-28 18:57:48 +00:00
static NTSTATUS ipv6_tcp_send ( struct socket_context * sock ,
2006-04-30 05:58:31 +00:00
const DATA_BLOB * blob , size_t * sendlen )
2004-10-28 18:57:48 +00:00
{
ssize_t len ;
* sendlen = 0 ;
2006-04-30 05:58:31 +00:00
len = send ( sock - > fd , blob - > data , blob - > length , 0 ) ;
2004-10-28 18:57:48 +00:00
if ( len = = - 1 ) {
return map_nt_error_from_unix ( errno ) ;
}
* sendlen = len ;
return NT_STATUS_OK ;
}
2007-04-24 13:55:04 +00:00
static NTSTATUS ipv6_sendto ( struct socket_context * sock ,
const DATA_BLOB * blob , size_t * sendlen ,
const struct socket_address * dest_addr )
{
ssize_t len ;
if ( dest_addr - > sockaddr ) {
len = sendto ( sock - > fd , blob - > data , blob - > length , 0 ,
dest_addr - > sockaddr , dest_addr - > sockaddrlen ) ;
} else {
struct sockaddr_in6 srv_addr ;
struct in6_addr addr ;
ZERO_STRUCT ( srv_addr ) ;
addr = interpret_addr6 ( dest_addr - > addr ) ;
if ( addr . s6_addr = = 0 ) {
return NT_STATUS_HOST_UNREACHABLE ;
}
srv_addr . sin6_addr = addr ;
srv_addr . sin6_port = htons ( dest_addr - > port ) ;
srv_addr . sin6_family = PF_INET6 ;
* sendlen = 0 ;
len = sendto ( sock - > fd , blob - > data , blob - > length , 0 ,
( struct sockaddr * ) & srv_addr , sizeof ( srv_addr ) ) ;
}
if ( len = = - 1 ) {
return map_nt_error_from_unix ( errno ) ;
}
* sendlen = len ;
return NT_STATUS_OK ;
}
2004-10-28 18:57:48 +00:00
static NTSTATUS ipv6_tcp_set_option ( struct socket_context * sock , const char * option , const char * val )
{
set_socket_options ( sock - > fd , option ) ;
return NT_STATUS_OK ;
}
static char * ipv6_tcp_get_peer_name ( struct socket_context * sock , TALLOC_CTX * mem_ctx )
{
struct sockaddr_in6 peer_addr ;
socklen_t len = sizeof ( peer_addr ) ;
struct hostent * he ;
int ret ;
ret = getpeername ( sock - > fd , ( struct sockaddr * ) & peer_addr , & len ) ;
if ( ret = = - 1 ) {
return NULL ;
}
he = gethostbyaddr ( ( char * ) & peer_addr . sin6_addr , sizeof ( peer_addr . sin6_addr ) , AF_INET6 ) ;
if ( he = = NULL ) {
return NULL ;
}
return talloc_strdup ( mem_ctx , he - > h_name ) ;
}
2006-01-09 22:12:53 +00:00
static struct socket_address * ipv6_tcp_get_peer_addr ( struct socket_context * sock , TALLOC_CTX * mem_ctx )
2004-10-28 18:57:48 +00:00
{
2006-01-09 22:12:53 +00:00
struct sockaddr_in6 * peer_addr ;
socklen_t len = sizeof ( * peer_addr ) ;
struct socket_address * peer ;
2004-10-28 18:57:48 +00:00
int ret ;
2006-04-29 20:01:07 +00:00
char addr [ 128 ] ;
const char * addr_ret ;
2006-01-09 22:12:53 +00:00
peer = talloc ( mem_ctx , struct socket_address ) ;
if ( ! peer ) {
return NULL ;
}
peer - > family = sock - > backend_name ;
peer_addr = talloc ( peer , struct sockaddr_in6 ) ;
if ( ! peer_addr ) {
talloc_free ( peer ) ;
return NULL ;
}
2004-10-28 18:57:48 +00:00
2006-01-09 22:12:53 +00:00
peer - > sockaddr = ( struct sockaddr * ) peer_addr ;
ret = getpeername ( sock - > fd , peer - > sockaddr , & len ) ;
2004-10-28 18:57:48 +00:00
if ( ret = = - 1 ) {
2006-01-09 22:12:53 +00:00
talloc_free ( peer ) ;
2004-10-28 18:57:48 +00:00
return NULL ;
}
2006-01-09 22:12:53 +00:00
peer - > sockaddrlen = len ;
2006-04-29 20:01:07 +00:00
addr_ret = inet_ntop ( AF_INET6 , & peer_addr - > sin6_addr , addr , sizeof ( addr ) ) ;
if ( addr_ret = = NULL ) {
2006-01-09 22:12:53 +00:00
talloc_free ( peer ) ;
2004-10-28 18:57:48 +00:00
return NULL ;
}
2006-04-29 20:01:07 +00:00
peer - > addr = talloc_strdup ( peer , addr_ret ) ;
if ( peer - > addr = = NULL ) {
2006-01-09 22:12:53 +00:00
talloc_free ( peer ) ;
return NULL ;
2004-10-28 18:57:48 +00:00
}
2006-04-29 20:01:07 +00:00
2006-01-09 22:12:53 +00:00
peer - > port = ntohs ( peer_addr - > sin6_port ) ;
2004-10-28 18:57:48 +00:00
2006-01-09 22:12:53 +00:00
return peer ;
2004-10-28 18:57:48 +00:00
}
2006-01-09 22:12:53 +00:00
static struct socket_address * ipv6_tcp_get_my_addr ( struct socket_context * sock , TALLOC_CTX * mem_ctx )
2004-10-28 18:57:48 +00:00
{
2006-01-09 22:12:53 +00:00
struct sockaddr_in6 * local_addr ;
socklen_t len = sizeof ( * local_addr ) ;
struct socket_address * local ;
2004-10-28 18:57:48 +00:00
int ret ;
struct hostent * he ;
2006-01-09 22:12:53 +00:00
local = talloc ( mem_ctx , struct socket_address ) ;
if ( ! local ) {
return NULL ;
}
local - > family = sock - > backend_name ;
local_addr = talloc ( local , struct sockaddr_in6 ) ;
if ( ! local_addr ) {
talloc_free ( local ) ;
2004-10-28 18:57:48 +00:00
return NULL ;
}
2006-01-09 22:12:53 +00:00
local - > sockaddr = ( struct sockaddr * ) local_addr ;
ret = getsockname ( sock - > fd , local - > sockaddr , & len ) ;
if ( ret = = - 1 ) {
talloc_free ( local ) ;
2004-10-28 18:57:48 +00:00
return NULL ;
}
2006-01-09 22:12:53 +00:00
local - > sockaddrlen = len ;
2004-10-28 18:57:48 +00:00
2006-01-09 22:12:53 +00:00
he = gethostbyaddr ( ( char * ) & local_addr - > sin6_addr , len , AF_INET6 ) ;
2004-10-28 18:57:48 +00:00
2006-01-09 22:12:53 +00:00
if ( ! he | | ! he - > h_name ) {
talloc_free ( local ) ;
return NULL ;
}
local - > addr = talloc_strdup ( mem_ctx , he - > h_name ) ;
if ( ! local - > addr ) {
talloc_free ( local ) ;
return NULL ;
2004-10-28 18:57:48 +00:00
}
2006-01-09 22:12:53 +00:00
local - > port = ntohs ( local_addr - > sin6_port ) ;
2004-10-28 18:57:48 +00:00
2006-01-09 22:12:53 +00:00
return local ;
2004-10-28 18:57:48 +00:00
}
static int ipv6_tcp_get_fd ( struct socket_context * sock )
{
return sock - > fd ;
}
2007-04-23 15:32:47 +00:00
static NTSTATUS ipv6_pending ( struct socket_context * sock , size_t * npending )
{
int value = 0 ;
if ( ioctl ( sock - > fd , FIONREAD , & value ) = = 0 ) {
* npending = value ;
return NT_STATUS_OK ;
}
return map_nt_error_from_unix ( errno ) ;
}
2004-10-28 18:57:48 +00:00
static const struct socket_ops ipv6_tcp_ops = {
2004-11-02 02:01:04 +00:00
. name = " ipv6 " ,
. fn_init = ipv6_tcp_init ,
. fn_connect = ipv6_tcp_connect ,
2005-01-15 10:28:08 +00:00
. fn_connect_complete = ipv6_tcp_connect_complete ,
2004-11-02 02:01:04 +00:00
. fn_listen = ipv6_tcp_listen ,
. fn_accept = ipv6_tcp_accept ,
. fn_recv = ipv6_tcp_recv ,
2007-04-24 13:55:04 +00:00
. fn_recvfrom = ipv6_recvfrom ,
. fn_sendto = ipv6_sendto ,
2004-11-02 02:01:04 +00:00
. fn_send = ipv6_tcp_send ,
. fn_close = ipv6_tcp_close ,
2007-04-23 15:32:47 +00:00
. fn_pending = ipv6_pending ,
2004-11-02 02:01:04 +00:00
. fn_set_option = ipv6_tcp_set_option ,
. fn_get_peer_name = ipv6_tcp_get_peer_name ,
. fn_get_peer_addr = ipv6_tcp_get_peer_addr ,
. fn_get_my_addr = ipv6_tcp_get_my_addr ,
. fn_get_fd = ipv6_tcp_get_fd
2004-10-28 18:57:48 +00:00
} ;
2005-01-19 03:20:20 +00:00
const struct socket_ops * socket_ipv6_ops ( enum socket_type type )
2004-10-28 18:57:48 +00:00
{
return & ipv6_tcp_ops ;
}