2004-09-13 18:17:41 +04:00
/*
Unix SMB / CIFS implementation .
2005-01-15 13:28:08 +03:00
2004-09-13 18:17:41 +04:00
Socket IPv4 functions
2005-01-15 13:28:08 +03:00
2004-09-13 18:17:41 +04:00
Copyright ( C ) Stefan Metzmacher 2004
2005-01-15 13:28:08 +03:00
Copyright ( C ) Andrew Tridgell 2004 - 2005
2004-09-13 18:17:41 +04:00
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"
2004-11-02 01:48:25 +03:00
# include "system/network.h"
2004-09-13 18:17:41 +04:00
static NTSTATUS ipv4_tcp_init ( struct socket_context * sock )
{
sock - > fd = socket ( PF_INET , SOCK_STREAM , 0 ) ;
if ( sock - > fd = = - 1 ) {
2004-10-27 07:15:42 +04:00
return map_nt_error_from_unix ( errno ) ;
2004-09-13 18:17:41 +04:00
}
return NT_STATUS_OK ;
}
static void ipv4_tcp_close ( struct socket_context * sock )
{
close ( sock - > fd ) ;
}
2005-01-15 13:28:08 +03:00
static NTSTATUS ipv4_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-09-13 18:17:41 +04:00
static NTSTATUS ipv4_tcp_connect ( struct socket_context * sock ,
2004-10-27 07:15:42 +04:00
const char * my_address , int my_port ,
const char * srv_address , int srv_port ,
uint32_t flags )
2004-09-13 18:17:41 +04:00
{
struct sockaddr_in srv_addr ;
2004-11-02 01:48:25 +03:00
struct ipv4_addr my_ip ;
struct ipv4_addr srv_ip ;
2004-09-13 18:17:41 +04:00
int ret ;
2004-10-27 07:15:42 +04:00
my_ip = interpret_addr2 ( my_address ) ;
2004-09-13 18:17:41 +04:00
2004-11-02 06:58:27 +03:00
if ( my_ip . addr ! = 0 | | my_port ! = 0 ) {
2004-10-27 07:15:42 +04:00
struct sockaddr_in my_addr ;
ZERO_STRUCT ( my_addr ) ;
2004-09-13 18:17:41 +04:00
# ifdef HAVE_SOCK_SIN_LEN
2004-10-27 07:15:42 +04:00
my_addr . sin_len = sizeof ( my_addr ) ;
2004-09-13 18:17:41 +04:00
# endif
2004-11-02 06:58:27 +03:00
my_addr . sin_addr . s_addr = my_ip . addr ;
2004-10-27 07:15:42 +04:00
my_addr . sin_port = htons ( my_port ) ;
my_addr . sin_family = PF_INET ;
ret = bind ( sock - > fd , ( struct sockaddr * ) & my_addr , sizeof ( my_addr ) ) ;
if ( ret = = - 1 ) {
return map_nt_error_from_unix ( errno ) ;
}
2004-09-13 18:17:41 +04:00
}
2004-10-27 07:15:42 +04:00
srv_ip = interpret_addr2 ( srv_address ) ;
2004-09-13 18:17:41 +04:00
ZERO_STRUCT ( srv_addr ) ;
# ifdef HAVE_SOCK_SIN_LEN
srv_addr . sin_len = sizeof ( srv_addr ) ;
# endif
2004-11-02 06:58:27 +03:00
srv_addr . sin_addr . s_addr = srv_ip . addr ;
2004-09-13 18:17:41 +04:00
srv_addr . sin_port = htons ( srv_port ) ;
srv_addr . sin_family = PF_INET ;
2004-10-27 07:15:42 +04:00
ret = connect ( sock - > fd , ( const struct sockaddr * ) & srv_addr , sizeof ( srv_addr ) ) ;
if ( ret = = - 1 ) {
return map_nt_error_from_unix ( errno ) ;
}
2005-01-15 13:28:08 +03:00
return ipv4_tcp_connect_complete ( sock , flags ) ;
2004-09-13 18:17:41 +04:00
}
2005-01-15 13:28:08 +03:00
2004-09-13 18:17:41 +04:00
static NTSTATUS ipv4_tcp_listen ( struct socket_context * sock ,
const char * my_address , int port ,
int queue_size , uint32_t flags )
{
struct sockaddr_in my_addr ;
2004-11-02 01:48:25 +03:00
struct ipv4_addr ip_addr ;
2004-09-13 18:17:41 +04:00
int ret ;
2004-10-27 07:15:42 +04:00
ip_addr = interpret_addr2 ( my_address ) ;
2004-09-13 18:17:41 +04:00
2004-09-20 13:13:17 +04:00
ZERO_STRUCT ( my_addr ) ;
2004-09-13 18:17:41 +04:00
# ifdef HAVE_SOCK_SIN_LEN
my_addr . sin_len = sizeof ( my_addr ) ;
# endif
2004-11-02 06:58:27 +03:00
my_addr . sin_addr . s_addr = ip_addr . addr ;
2004-09-13 18:17:41 +04:00
my_addr . sin_port = htons ( port ) ;
my_addr . sin_family = PF_INET ;
2004-09-20 13:13:17 +04:00
ret = bind ( sock - > fd , ( struct sockaddr * ) & my_addr , sizeof ( my_addr ) ) ;
2004-09-13 18:17:41 +04:00
if ( ret = = - 1 ) {
2004-10-27 07:15:42 +04:00
return map_nt_error_from_unix ( errno ) ;
2004-09-13 18:17:41 +04:00
}
ret = listen ( sock - > fd , queue_size ) ;
if ( ret = = - 1 ) {
2004-10-27 07:15:42 +04:00
return map_nt_error_from_unix ( errno ) ;
2004-09-13 18:17:41 +04:00
}
2004-09-15 16:14:47 +04:00
if ( ! ( flags & SOCKET_FLAG_BLOCK ) ) {
ret = set_blocking ( sock - > fd , False ) ;
if ( ret = = - 1 ) {
2004-10-27 07:15:42 +04:00
return map_nt_error_from_unix ( errno ) ;
2004-09-15 16:14:47 +04:00
}
}
2004-09-20 13:13:17 +04:00
sock - > state = SOCKET_STATE_SERVER_LISTEN ;
return NT_STATUS_OK ;
2004-09-13 18:17:41 +04:00
}
2004-10-28 11:55:33 +04:00
static NTSTATUS ipv4_tcp_accept ( struct socket_context * sock , struct socket_context * * new_sock )
2004-09-13 18:17:41 +04:00
{
struct sockaddr_in cli_addr ;
2004-10-17 09:07:07 +04:00
socklen_t cli_addr_len = sizeof ( cli_addr ) ;
2004-09-13 18:17:41 +04:00
int new_fd ;
2004-09-25 15:48:30 +04:00
new_fd = accept ( sock - > fd , ( struct sockaddr * ) & cli_addr , & cli_addr_len ) ;
2004-09-13 18:17:41 +04:00
if ( new_fd = = - 1 ) {
2004-10-27 07:15:42 +04:00
return map_nt_error_from_unix ( errno ) ;
2004-09-13 18:17:41 +04:00
}
2004-10-28 11:55:33 +04:00
if ( ! ( sock - > flags & SOCKET_FLAG_BLOCK ) ) {
2004-10-28 11:34:11 +04:00
int ret = set_blocking ( new_fd , False ) ;
if ( ret = = - 1 ) {
close ( new_fd ) ;
return map_nt_error_from_unix ( errno ) ;
}
}
2004-09-13 18:17:41 +04:00
/* 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
*/
( * new_sock ) = talloc_p ( NULL , struct socket_context ) ;
if ( ! ( * new_sock ) ) {
2004-10-17 09:07:07 +04:00
close ( new_fd ) ;
2004-09-13 18:17:41 +04:00
return NT_STATUS_NO_MEMORY ;
}
/* copy the socket_context */
( * new_sock ) - > type = sock - > type ;
( * new_sock ) - > state = SOCKET_STATE_SERVER_CONNECTED ;
2004-10-28 11:55:33 +04:00
( * new_sock ) - > flags = sock - > flags ;
2004-09-13 18:17:41 +04:00
( * new_sock ) - > fd = new_fd ;
( * new_sock ) - > private_data = NULL ;
( * new_sock ) - > ops = sock - > ops ;
2004-09-15 16:14:47 +04:00
return NT_STATUS_OK ;
2004-09-13 18:17:41 +04:00
}
2004-10-28 08:00:43 +04:00
static NTSTATUS ipv4_tcp_recv ( struct socket_context * sock , void * buf ,
size_t wantlen , size_t * nread , uint32_t flags )
2004-09-13 18:17:41 +04:00
{
ssize_t gotlen ;
int flgs = 0 ;
2004-09-15 16:14:47 +04:00
/* TODO: we need to map all flags here */
if ( flags & SOCKET_FLAG_PEEK ) {
flgs | = MSG_PEEK ;
}
2004-09-25 15:16:30 +04:00
if ( flags & SOCKET_FLAG_BLOCK ) {
flgs | = MSG_WAITALL ;
}
2004-10-28 08:00:43 +04:00
* nread = 0 ;
2004-09-13 18:17:41 +04:00
gotlen = recv ( sock - > fd , buf , wantlen , flgs ) ;
2004-09-15 16:14:47 +04:00
if ( gotlen = = 0 ) {
return NT_STATUS_END_OF_FILE ;
} else if ( gotlen = = - 1 ) {
2004-10-28 08:00:43 +04:00
return map_nt_error_from_unix ( errno ) ;
2004-09-13 18:17:41 +04:00
}
2004-10-28 08:00:43 +04:00
* nread = gotlen ;
2004-09-13 18:17:41 +04:00
return NT_STATUS_OK ;
}
2004-10-28 08:00:43 +04:00
static NTSTATUS ipv4_tcp_send ( struct socket_context * sock ,
2004-10-27 07:45:35 +04:00
const DATA_BLOB * blob , size_t * sendlen , uint32_t flags )
2004-09-13 18:17:41 +04:00
{
ssize_t len ;
2004-09-16 09:30:19 +04:00
int flgs = 0 ;
2004-09-13 18:17:41 +04:00
2004-10-28 01:29:55 +04:00
* sendlen = 0 ;
2004-09-13 18:17:41 +04:00
len = send ( sock - > fd , blob - > data , blob - > length , flgs ) ;
if ( len = = - 1 ) {
2004-10-27 07:15:42 +04:00
return map_nt_error_from_unix ( errno ) ;
2004-09-13 18:17:41 +04:00
}
* sendlen = len ;
return NT_STATUS_OK ;
}
static NTSTATUS ipv4_tcp_set_option ( struct socket_context * sock , const char * option , const char * val )
{
2004-09-15 16:14:47 +04:00
set_socket_options ( sock - > fd , option ) ;
return NT_STATUS_OK ;
2004-09-13 18:17:41 +04:00
}
2004-09-24 07:34:55 +04:00
static char * ipv4_tcp_get_peer_name ( struct socket_context * sock , TALLOC_CTX * mem_ctx )
{
struct sockaddr_in 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 . sin_addr , sizeof ( peer_addr . sin_addr ) , AF_INET ) ;
if ( he = = NULL ) {
return NULL ;
}
return talloc_strdup ( mem_ctx , he - > h_name ) ;
}
2004-09-15 16:14:47 +04:00
static char * ipv4_tcp_get_peer_addr ( struct socket_context * sock , TALLOC_CTX * mem_ctx )
2004-09-13 18:17:41 +04:00
{
2004-09-20 16:03:49 +04:00
struct sockaddr_in peer_addr ;
socklen_t len = sizeof ( peer_addr ) ;
int ret ;
ret = getpeername ( sock - > fd , ( struct sockaddr * ) & peer_addr , & len ) ;
if ( ret = = - 1 ) {
return NULL ;
}
return talloc_strdup ( mem_ctx , inet_ntoa ( peer_addr . sin_addr ) ) ;
2004-09-13 18:17:41 +04:00
}
2004-09-20 13:13:17 +04:00
static int ipv4_tcp_get_peer_port ( struct socket_context * sock )
2004-09-13 18:17:41 +04:00
{
2004-09-20 16:03:49 +04:00
struct sockaddr_in peer_addr ;
socklen_t len = sizeof ( peer_addr ) ;
int ret ;
ret = getpeername ( sock - > fd , ( struct sockaddr * ) & peer_addr , & len ) ;
if ( ret = = - 1 ) {
return - 1 ;
}
return ntohs ( peer_addr . sin_port ) ;
2004-09-13 18:17:41 +04:00
}
2004-09-15 16:14:47 +04:00
static char * ipv4_tcp_get_my_addr ( struct socket_context * sock , TALLOC_CTX * mem_ctx )
2004-09-13 18:17:41 +04:00
{
2004-09-20 16:03:49 +04:00
struct sockaddr_in my_addr ;
socklen_t len = sizeof ( my_addr ) ;
int ret ;
ret = getsockname ( sock - > fd , ( struct sockaddr * ) & my_addr , & len ) ;
if ( ret = = - 1 ) {
return NULL ;
}
return talloc_strdup ( mem_ctx , inet_ntoa ( my_addr . sin_addr ) ) ;
2004-09-13 18:17:41 +04:00
}
2004-09-20 13:13:17 +04:00
static int ipv4_tcp_get_my_port ( struct socket_context * sock )
2004-09-13 18:17:41 +04:00
{
2004-09-20 16:03:49 +04:00
struct sockaddr_in my_addr ;
socklen_t len = sizeof ( my_addr ) ;
int ret ;
ret = getsockname ( sock - > fd , ( struct sockaddr * ) & my_addr , & len ) ;
if ( ret = = - 1 ) {
return - 1 ;
}
return ntohs ( my_addr . sin_port ) ;
2004-09-13 18:17:41 +04:00
}
2004-09-20 13:13:17 +04:00
static int ipv4_tcp_get_fd ( struct socket_context * sock )
2004-09-13 18:17:41 +04:00
{
return sock - > fd ;
}
static const struct socket_ops ipv4_tcp_ops = {
2004-11-02 05:01:04 +03:00
. name = " ipv4 " ,
. type = SOCKET_TYPE_STREAM ,
. fn_init = ipv4_tcp_init ,
. fn_connect = ipv4_tcp_connect ,
2005-01-15 13:28:08 +03:00
. fn_connect_complete = ipv4_tcp_connect_complete ,
2004-11-02 05:01:04 +03:00
. fn_listen = ipv4_tcp_listen ,
. fn_accept = ipv4_tcp_accept ,
. fn_recv = ipv4_tcp_recv ,
. fn_send = ipv4_tcp_send ,
. fn_close = ipv4_tcp_close ,
. fn_set_option = ipv4_tcp_set_option ,
. fn_get_peer_name = ipv4_tcp_get_peer_name ,
. fn_get_peer_addr = ipv4_tcp_get_peer_addr ,
. fn_get_peer_port = ipv4_tcp_get_peer_port ,
. fn_get_my_addr = ipv4_tcp_get_my_addr ,
. fn_get_my_port = ipv4_tcp_get_my_port ,
. fn_get_fd = ipv4_tcp_get_fd
2004-09-13 18:17:41 +04:00
} ;
const struct socket_ops * socket_ipv4_ops ( void )
{
return & ipv4_tcp_ops ;
}