2007-10-02 23:50:53 +04:00
/*
2002-01-30 09:08:46 +03:00
Unix SMB / CIFS implementation .
1998-11-09 19:40:38 +03:00
Samba utility functions
Copyright ( C ) Andrew Tridgell 1992 - 1998
2002-01-13 14:13:54 +03:00
Copyright ( C ) Tim Potter 2000 - 2001
2007-10-04 00:43:55 +04:00
Copyright ( C ) Jeremy Allison 1992 - 2007
2007-10-02 23:50:53 +04:00
1998-11-09 19:40:38 +03: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
2007-07-09 23:25:36 +04:00
the Free Software Foundation ; either version 3 of the License , or
1998-11-09 19:40:38 +03:00
( at your option ) any later version .
2007-10-02 23:50:53 +04:00
1998-11-09 19:40:38 +03:00
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 .
2007-10-02 23:50:53 +04:00
1998-11-09 19:40:38 +03:00
You should have received a copy of the GNU General Public License
2007-07-10 04:52:41 +04:00
along with this program . If not , see < http : //www.gnu.org/licenses/>.
1998-11-09 19:40:38 +03:00
*/
# include "includes.h"
2011-02-26 01:20:06 +03:00
# include "system/filesys.h"
2010-08-18 14:24:35 +04:00
# include "memcache.h"
2010-08-26 11:58:09 +04:00
# include "../lib/async_req/async_sock.h"
2010-10-01 12:08:15 +04:00
# include "../lib/util/select.h"
2011-02-25 01:51:28 +03:00
# include "interfaces.h"
1998-11-09 19:40:38 +03:00
2008-01-17 00:21:46 +03:00
/****************************************************************************
Get a port number in host byte order from a sockaddr_storage .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
uint16_t get_sockaddr_port ( const struct sockaddr_storage * pss )
{
uint16_t port = 0 ;
if ( pss - > ss_family ! = AF_INET ) {
# if defined(HAVE_IPV6)
/* IPv6 */
const struct sockaddr_in6 * sa6 =
( const struct sockaddr_in6 * ) pss ;
port = ntohs ( sa6 - > sin6_port ) ;
# endif
} else {
const struct sockaddr_in * sa =
( const struct sockaddr_in * ) pss ;
port = ntohs ( sa - > sin_port ) ;
}
return port ;
}
2007-10-11 05:25:16 +04:00
/****************************************************************************
Print out an IPv4 or IPv6 address from a struct sockaddr_storage .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2007-11-02 20:25:34 +03:00
static char * print_sockaddr_len ( char * dest ,
2007-10-11 05:25:16 +04:00
size_t destlen ,
2008-10-23 21:53:15 +04:00
const struct sockaddr * psa ,
2007-10-11 05:25:16 +04:00
socklen_t psalen )
{
if ( destlen > 0 ) {
dest [ 0 ] = ' \0 ' ;
}
2008-10-23 21:53:15 +04:00
( void ) sys_getnameinfo ( psa ,
2007-10-11 05:25:16 +04:00
psalen ,
dest , destlen ,
NULL , 0 ,
NI_NUMERICHOST ) ;
2007-10-04 00:43:55 +04:00
return dest ;
}
1998-11-09 19:40:38 +03:00
2007-10-25 01:16:54 +04:00
/****************************************************************************
Print out an IPv4 or IPv6 address from a struct sockaddr_storage .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
char * print_sockaddr ( char * dest ,
size_t destlen ,
const struct sockaddr_storage * psa )
{
2008-10-23 21:53:15 +04:00
return print_sockaddr_len ( dest , destlen , ( struct sockaddr * ) psa ,
2007-11-02 20:25:34 +03:00
sizeof ( struct sockaddr_storage ) ) ;
2007-10-25 01:16:54 +04:00
}
/****************************************************************************
Print out a canonical IPv4 or IPv6 address from a struct sockaddr_storage .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
char * print_canonical_sockaddr ( TALLOC_CTX * ctx ,
const struct sockaddr_storage * pss )
{
char addr [ INET6_ADDRSTRLEN ] ;
char * dest = NULL ;
int ret ;
2008-03-24 22:48:29 +03:00
/* Linux getnameinfo() man pages says port is unitialized if
service name is NULL . */
2008-01-17 00:21:46 +03:00
ret = sys_getnameinfo ( ( const struct sockaddr * ) pss ,
2007-10-25 01:16:54 +04:00
sizeof ( struct sockaddr_storage ) ,
addr , sizeof ( addr ) ,
NULL , 0 ,
NI_NUMERICHOST ) ;
2008-03-24 22:48:29 +03:00
if ( ret ! = 0 ) {
2007-10-25 01:16:54 +04:00
return NULL ;
}
2008-03-27 00:58:27 +03:00
if ( pss - > ss_family ! = AF_INET ) {
2007-10-25 01:16:54 +04:00
# if defined(HAVE_IPV6)
2008-03-27 00:58:27 +03:00
dest = talloc_asprintf ( ctx , " [%s] " , addr ) ;
2007-10-25 01:16:54 +04:00
# else
2008-03-27 00:58:27 +03:00
return NULL ;
2007-10-25 01:16:54 +04:00
# endif
2008-03-27 00:58:27 +03:00
} else {
dest = talloc_asprintf ( ctx , " %s " , addr ) ;
}
2011-02-09 01:08:21 +03:00
2007-10-25 01:16:54 +04:00
return dest ;
}
2007-10-11 05:25:16 +04:00
/****************************************************************************
2007-11-04 08:34:46 +03:00
Return the string of an IP address ( IPv4 or IPv6 ) .
2007-10-11 05:25:16 +04:00
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2007-11-04 08:34:46 +03:00
static const char * get_socket_addr ( int fd , char * addr_buf , size_t addr_len )
2004-02-10 07:02:53 +03:00
{
2007-10-04 00:43:55 +04:00
struct sockaddr_storage sa ;
2004-05-05 07:03:38 +04:00
socklen_t length = sizeof ( sa ) ;
2004-02-10 07:02:53 +03:00
2007-10-08 06:48:03 +04:00
/* Ok, returning a hard coded IPv4 address
* is bogus , but it ' s just as bogus as a
* zero IPv6 address . No good choice here .
*/
2007-11-07 23:48:58 +03:00
strlcpy ( addr_buf , " 0.0.0.0 " , addr_len ) ;
2004-02-10 07:02:53 +03:00
if ( fd = = - 1 ) {
return addr_buf ;
}
2007-10-02 23:50:53 +04:00
2007-10-04 00:43:55 +04:00
if ( getsockname ( fd , ( struct sockaddr * ) & sa , & length ) < 0 ) {
2007-10-02 23:50:53 +04:00
DEBUG ( 0 , ( " getsockname failed. Error was %s \n " ,
2007-10-04 00:43:55 +04:00
strerror ( errno ) ) ) ;
2004-02-10 07:02:53 +03:00
return addr_buf ;
}
2007-10-02 23:50:53 +04:00
2008-10-23 21:53:15 +04:00
return print_sockaddr_len ( addr_buf , addr_len , ( struct sockaddr * ) & sa , length ) ;
2004-02-10 07:02:53 +03:00
}
2007-10-11 05:25:16 +04:00
/****************************************************************************
Return the port number we ' ve bound to on a socket .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2009-04-12 16:25:02 +04:00
int get_socket_port ( int fd )
2004-06-10 21:09:00 +04:00
{
2007-10-04 00:43:55 +04:00
struct sockaddr_storage sa ;
2004-06-10 21:09:00 +04:00
socklen_t length = sizeof ( sa ) ;
2007-10-04 00:43:55 +04:00
if ( fd = = - 1 ) {
2004-06-10 21:09:00 +04:00
return - 1 ;
2007-10-04 00:43:55 +04:00
}
2007-10-02 23:50:53 +04:00
2007-10-04 00:43:55 +04:00
if ( getsockname ( fd , ( struct sockaddr * ) & sa , & length ) < 0 ) {
2010-03-26 17:14:35 +03:00
int level = ( errno = = ENOTCONN ) ? 2 : 0 ;
2010-12-06 16:05:49 +03:00
DEBUG ( level , ( " getsockname failed. Error was %s \n " ,
2010-03-26 17:14:35 +03:00
strerror ( errno ) ) ) ;
2004-06-10 21:09:00 +04:00
return - 1 ;
}
2007-10-02 23:50:53 +04:00
2007-10-19 17:14:12 +04:00
# if defined(HAVE_IPV6)
2007-10-04 00:43:55 +04:00
if ( sa . ss_family = = AF_INET6 ) {
return ntohs ( ( ( struct sockaddr_in6 * ) & sa ) - > sin6_port ) ;
}
# endif
if ( sa . ss_family = = AF_INET ) {
return ntohs ( ( ( struct sockaddr_in * ) & sa ) - > sin_port ) ;
}
return - 1 ;
2004-06-10 21:09:00 +04:00
}
2007-11-04 09:20:10 +03:00
const char * client_name ( int fd )
2005-06-14 02:26:08 +04:00
{
2007-11-04 09:20:10 +03:00
return get_peer_name ( fd , false ) ;
2005-06-14 02:26:08 +04:00
}
2007-11-04 09:20:10 +03:00
const char * client_addr ( int fd , char * addr , size_t addrlen )
2005-06-14 02:26:08 +04:00
{
2007-11-04 09:20:10 +03:00
return get_peer_addr ( fd , addr , addrlen ) ;
2005-06-14 02:26:08 +04:00
}
2007-11-04 09:20:10 +03:00
const char * client_socket_addr ( int fd , char * addr , size_t addr_len )
2005-06-14 02:26:08 +04:00
{
2007-11-04 09:20:10 +03:00
return get_socket_addr ( fd , addr , addr_len ) ;
2005-06-14 02:26:08 +04:00
}
2007-11-04 09:20:10 +03:00
#if 0
/* Not currently used. JRA. */
int client_socket_port ( int fd )
2005-06-14 02:26:08 +04:00
{
2007-11-04 09:20:10 +03:00
return get_socket_port ( fd ) ;
2005-06-14 02:26:08 +04:00
}
2007-11-04 09:20:10 +03:00
# endif
2005-06-14 02:26:08 +04:00
2007-11-04 01:12:42 +03:00
/****************************************************************************
Accessor functions to make thread - safe code easier later . . .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2007-11-05 22:12:56 +03:00
void set_smb_read_error ( enum smb_read_errors * pre ,
enum smb_read_errors newerr )
2007-11-04 01:12:42 +03:00
{
2007-11-05 22:12:56 +03:00
if ( pre ) {
* pre = newerr ;
}
2007-11-04 01:12:42 +03:00
}
2007-11-05 22:12:56 +03:00
void cond_set_smb_read_error ( enum smb_read_errors * pre ,
enum smb_read_errors newerr )
2007-11-04 01:12:42 +03:00
{
2007-11-05 22:12:56 +03:00
if ( pre & & * pre = = SMB_READ_OK ) {
* pre = newerr ;
2007-11-04 01:12:42 +03:00
}
}
2005-06-14 02:26:08 +04:00
1998-11-09 19:40:38 +03:00
/****************************************************************************
1999-12-13 16:27:58 +03:00
Determine if a file descriptor is in fact a socket .
1998-11-09 19:40:38 +03:00
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
1999-12-13 16:27:58 +03:00
2007-10-11 05:25:16 +04:00
bool is_a_socket ( int fd )
1998-11-09 19:40:38 +03:00
{
2004-05-05 07:03:38 +04:00
int v ;
socklen_t l ;
2002-07-15 14:35:28 +04:00
l = sizeof ( int ) ;
return ( getsockopt ( fd , SOL_SOCKET , SO_TYPE , ( char * ) & v , & l ) = = 0 ) ;
1998-11-09 19:40:38 +03:00
}
enum SOCK_OPT_TYPES { OPT_BOOL , OPT_INT , OPT_ON } ;
2002-07-15 14:35:28 +04:00
typedef struct smb_socket_option {
2003-01-03 11:28:12 +03:00
const char * name ;
2002-07-15 14:35:28 +04:00
int level ;
int option ;
int value ;
int opttype ;
2000-10-07 01:12:25 +04:00
} smb_socket_option ;
2002-07-15 14:35:28 +04:00
static const smb_socket_option socket_options [ ] = {
2007-10-02 23:50:53 +04:00
{ " SO_KEEPALIVE " , SOL_SOCKET , SO_KEEPALIVE , 0 , OPT_BOOL } ,
{ " SO_REUSEADDR " , SOL_SOCKET , SO_REUSEADDR , 0 , OPT_BOOL } ,
{ " SO_BROADCAST " , SOL_SOCKET , SO_BROADCAST , 0 , OPT_BOOL } ,
1998-11-09 19:40:38 +03:00
# ifdef TCP_NODELAY
2007-10-02 23:50:53 +04:00
{ " TCP_NODELAY " , IPPROTO_TCP , TCP_NODELAY , 0 , OPT_BOOL } ,
1998-11-09 19:40:38 +03:00
# endif
2005-05-01 14:13:08 +04:00
# ifdef TCP_KEEPCNT
2007-10-02 23:50:53 +04:00
{ " TCP_KEEPCNT " , IPPROTO_TCP , TCP_KEEPCNT , 0 , OPT_INT } ,
2005-05-01 14:13:08 +04:00
# endif
# ifdef TCP_KEEPIDLE
2007-10-02 23:50:53 +04:00
{ " TCP_KEEPIDLE " , IPPROTO_TCP , TCP_KEEPIDLE , 0 , OPT_INT } ,
2005-05-01 14:13:08 +04:00
# endif
# ifdef TCP_KEEPINTVL
2007-10-02 23:50:53 +04:00
{ " TCP_KEEPINTVL " , IPPROTO_TCP , TCP_KEEPINTVL , 0 , OPT_INT } ,
2005-05-01 14:13:08 +04:00
# endif
1998-11-09 19:40:38 +03:00
# ifdef IPTOS_LOWDELAY
2007-10-02 23:50:53 +04:00
{ " IPTOS_LOWDELAY " , IPPROTO_IP , IP_TOS , IPTOS_LOWDELAY , OPT_ON } ,
1998-11-09 19:40:38 +03:00
# endif
# ifdef IPTOS_THROUGHPUT
2007-10-02 23:50:53 +04:00
{ " IPTOS_THROUGHPUT " , IPPROTO_IP , IP_TOS , IPTOS_THROUGHPUT , OPT_ON } ,
1998-11-09 19:40:38 +03:00
# endif
2000-02-17 01:48:19 +03:00
# ifdef SO_REUSEPORT
2007-10-02 23:50:53 +04:00
{ " SO_REUSEPORT " , SOL_SOCKET , SO_REUSEPORT , 0 , OPT_BOOL } ,
2000-02-17 01:48:19 +03:00
# endif
1998-11-09 19:40:38 +03:00
# ifdef SO_SNDBUF
2007-10-02 23:50:53 +04:00
{ " SO_SNDBUF " , SOL_SOCKET , SO_SNDBUF , 0 , OPT_INT } ,
1998-11-09 19:40:38 +03:00
# endif
# ifdef SO_RCVBUF
2007-10-02 23:50:53 +04:00
{ " SO_RCVBUF " , SOL_SOCKET , SO_RCVBUF , 0 , OPT_INT } ,
1998-11-09 19:40:38 +03:00
# endif
# ifdef SO_SNDLOWAT
2007-10-02 23:50:53 +04:00
{ " SO_SNDLOWAT " , SOL_SOCKET , SO_SNDLOWAT , 0 , OPT_INT } ,
1998-11-09 19:40:38 +03:00
# endif
# ifdef SO_RCVLOWAT
2007-10-02 23:50:53 +04:00
{ " SO_RCVLOWAT " , SOL_SOCKET , SO_RCVLOWAT , 0 , OPT_INT } ,
1998-11-09 19:40:38 +03:00
# endif
# ifdef SO_SNDTIMEO
2007-10-02 23:50:53 +04:00
{ " SO_SNDTIMEO " , SOL_SOCKET , SO_SNDTIMEO , 0 , OPT_INT } ,
1998-11-09 19:40:38 +03:00
# endif
# ifdef SO_RCVTIMEO
2007-10-02 23:50:53 +04:00
{ " SO_RCVTIMEO " , SOL_SOCKET , SO_RCVTIMEO , 0 , OPT_INT } ,
2006-01-16 02:13:47 +03:00
# endif
# ifdef TCP_FASTACK
2007-10-02 23:50:53 +04:00
{ " TCP_FASTACK " , IPPROTO_TCP , TCP_FASTACK , 0 , OPT_INT } ,
2009-07-15 00:23:39 +04:00
# endif
# ifdef TCP_QUICKACK
{ " TCP_QUICKACK " , IPPROTO_TCP , TCP_QUICKACK , 0 , OPT_BOOL } ,
2010-10-06 20:24:27 +04:00
# endif
# ifdef TCP_KEEPALIVE_THRESHOLD
{ " TCP_KEEPALIVE_THRESHOLD " , IPPROTO_TCP , TCP_KEEPALIVE_THRESHOLD , 0 , OPT_INT } ,
# endif
# ifdef TCP_KEEPALIVE_ABORT_THRESHOLD
{ " TCP_KEEPALIVE_ABORT_THRESHOLD " , IPPROTO_TCP , TCP_KEEPALIVE_ABORT_THRESHOLD , 0 , OPT_INT } ,
1998-11-09 19:40:38 +03:00
# endif
{ NULL , 0 , 0 , 0 , 0 } } ;
2000-10-07 01:12:25 +04:00
/****************************************************************************
Print socket options .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2002-07-15 14:35:28 +04:00
2000-10-07 01:12:25 +04:00
static void print_socket_options ( int s )
{
2004-05-05 07:03:38 +04:00
int value ;
socklen_t vlen = 4 ;
2002-07-15 14:35:28 +04:00
const smb_socket_option * p = & socket_options [ 0 ] ;
2000-10-07 01:12:25 +04:00
2007-10-02 23:50:53 +04:00
/* wrapped in if statement to prevent streams
* leak in SCO Openserver 5.0 */
2003-04-11 18:18:02 +04:00
/* reported on samba-technical --jerry */
if ( DEBUGLEVEL > = 5 ) {
2008-12-16 04:12:49 +03:00
DEBUG ( 5 , ( " Socket options: \n " ) ) ;
2007-10-02 23:50:53 +04:00
for ( ; p - > name ! = NULL ; p + + ) {
if ( getsockopt ( s , p - > level , p - > option ,
( void * ) & value , & vlen ) = = - 1 ) {
2008-12-16 04:12:49 +03:00
DEBUGADD ( 5 , ( " \t Could not test socket option %s. \n " ,
2007-10-02 23:50:53 +04:00
p - > name ) ) ;
} else {
2008-12-16 04:12:49 +03:00
DEBUGADD ( 5 , ( " \t %s = %d \n " ,
2007-10-02 23:50:53 +04:00
p - > name , value ) ) ;
2003-04-11 18:18:02 +04:00
}
2000-10-07 01:12:25 +04:00
}
}
}
1998-11-09 19:40:38 +03:00
/****************************************************************************
1999-12-13 16:27:58 +03:00
Set user socket options .
1998-11-09 19:40:38 +03:00
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
1999-12-13 16:27:58 +03:00
2002-11-13 02:20:50 +03:00
void set_socket_options ( int fd , const char * options )
1998-11-09 19:40:38 +03:00
{
2007-12-08 04:32:32 +03:00
TALLOC_CTX * ctx = talloc_stackframe ( ) ;
char * tok ;
1999-12-13 16:27:58 +03:00
2007-12-08 04:32:32 +03:00
while ( next_token_talloc ( ctx , & options , & tok , " \t , " ) ) {
1999-12-13 16:27:58 +03:00
int ret = 0 , i ;
int value = 1 ;
char * p ;
2007-10-11 05:25:16 +04:00
bool got_value = false ;
1999-12-13 16:27:58 +03:00
2001-07-04 11:36:09 +04:00
if ( ( p = strchr_m ( tok , ' = ' ) ) ) {
1999-12-13 16:27:58 +03:00
* p = 0 ;
value = atoi ( p + 1 ) ;
2007-10-11 05:25:16 +04:00
got_value = true ;
1999-12-13 16:27:58 +03:00
}
1998-11-09 19:40:38 +03:00
1999-12-13 16:27:58 +03:00
for ( i = 0 ; socket_options [ i ] . name ; i + + )
if ( strequal ( socket_options [ i ] . name , tok ) )
break ;
1998-11-09 19:40:38 +03:00
1999-12-13 16:27:58 +03:00
if ( ! socket_options [ i ] . name ) {
DEBUG ( 0 , ( " Unknown socket option %s \n " , tok ) ) ;
continue ;
}
1998-11-09 19:40:38 +03:00
1999-12-13 16:27:58 +03:00
switch ( socket_options [ i ] . opttype ) {
case OPT_BOOL :
case OPT_INT :
ret = setsockopt ( fd , socket_options [ i ] . level ,
2007-10-02 23:50:53 +04:00
socket_options [ i ] . option ,
( char * ) & value , sizeof ( int ) ) ;
1999-12-13 16:27:58 +03:00
break ;
case OPT_ON :
if ( got_value )
2007-10-02 23:50:53 +04:00
DEBUG ( 0 , ( " syntax error - %s "
" does not take a value \n " , tok ) ) ;
1999-12-13 16:27:58 +03:00
{
int on = socket_options [ i ] . value ;
ret = setsockopt ( fd , socket_options [ i ] . level ,
2007-10-02 23:50:53 +04:00
socket_options [ i ] . option ,
( char * ) & on , sizeof ( int ) ) ;
1999-12-13 16:27:58 +03:00
}
2007-10-02 23:50:53 +04:00
break ;
}
if ( ret ! = 0 ) {
2008-04-07 13:22:14 +04:00
/* be aware that some systems like Solaris return
* EINVAL to a setsockopt ( ) call when the client
* sent a RST previously - no need to worry */
DEBUG ( 2 , ( " Failed to set socket option %s (Error %s) \n " ,
2007-10-02 23:50:53 +04:00
tok , strerror ( errno ) ) ) ;
1999-12-13 16:27:58 +03:00
}
}
2000-10-07 01:12:25 +04:00
2007-12-08 04:32:32 +03:00
TALLOC_FREE ( ctx ) ;
2000-10-07 01:12:25 +04:00
print_socket_options ( fd ) ;
1998-11-09 19:40:38 +03:00
}
/****************************************************************************
1999-12-13 16:27:58 +03:00
Read from a socket .
1998-11-09 19:40:38 +03:00
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2007-10-04 00:43:55 +04:00
ssize_t read_udp_v4_socket ( int fd ,
char * buf ,
size_t len ,
struct sockaddr_storage * psa )
1998-11-09 19:40:38 +03:00
{
2001-06-27 21:26:29 +04:00
ssize_t ret ;
2007-10-04 00:43:55 +04:00
socklen_t socklen = sizeof ( * psa ) ;
struct sockaddr_in * si = ( struct sockaddr_in * ) psa ;
memset ( ( char * ) psa , ' \0 ' , socklen ) ;
2001-06-27 21:26:29 +04:00
2007-10-02 23:50:53 +04:00
ret = ( ssize_t ) sys_recvfrom ( fd , buf , len , 0 ,
2007-10-04 00:43:55 +04:00
( struct sockaddr * ) psa , & socklen ) ;
2001-06-27 21:26:29 +04:00
if ( ret < = 0 ) {
2006-05-18 23:49:44 +04:00
/* Don't print a low debug error for a non-blocking socket. */
if ( errno = = EAGAIN ) {
2007-10-04 00:43:55 +04:00
DEBUG ( 10 , ( " read_udp_v4_socket: returned EAGAIN \n " ) ) ;
2006-05-18 23:49:44 +04:00
} else {
2007-10-04 00:43:55 +04:00
DEBUG ( 2 , ( " read_udp_v4_socket: failed. errno=%s \n " ,
strerror ( errno ) ) ) ;
2006-05-18 23:49:44 +04:00
}
2007-10-04 00:43:55 +04:00
return 0 ;
2001-06-27 21:26:29 +04:00
}
2007-10-04 00:43:55 +04:00
if ( psa - > ss_family ! = AF_INET ) {
2007-10-05 05:11:33 +04:00
DEBUG ( 2 , ( " read_udp_v4_socket: invalid address family %d "
2007-10-04 00:43:55 +04:00
" (not IPv4) \n " , ( int ) psa - > ss_family ) ) ;
return 0 ;
}
2001-06-27 21:26:29 +04:00
2007-10-05 05:11:33 +04:00
DEBUG ( 10 , ( " read_udp_v4_socket: ip %s port %d read: %lu \n " ,
2007-10-04 00:43:55 +04:00
inet_ntoa ( si - > sin_addr ) ,
si - > sin_port ,
( unsigned long ) ret ) ) ;
2001-06-27 21:26:29 +04:00
2007-10-04 00:43:55 +04:00
return ret ;
1998-11-09 19:40:38 +03:00
}
/****************************************************************************
2009-09-07 08:38:50 +04:00
Read data from a file descriptor with a timout in msec .
1999-12-13 16:27:58 +03:00
mincount = if timeout , minimum to read before returning
maxcount = number to be read .
time_out = timeout in milliseconds
2009-09-07 08:38:50 +04:00
NB . This can be called with a non - socket fd , don ' t change
sys_read ( ) to sys_recv ( ) or other socket call .
1998-11-09 19:40:38 +03:00
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2009-09-07 08:38:50 +04:00
NTSTATUS read_fd_with_timeout ( int fd , char * buf ,
2008-01-26 01:43:50 +03:00
size_t mincnt , size_t maxcnt ,
unsigned int time_out ,
size_t * size_ret )
1998-11-09 19:40:38 +03:00
{
2011-02-08 19:57:12 +03:00
int pollrtn ;
2002-01-13 15:33:42 +03:00
ssize_t readret ;
size_t nread = 0 ;
2007-10-02 23:50:53 +04:00
2002-01-13 15:33:42 +03:00
/* just checking .... */
if ( maxcnt < = 0 )
2008-01-24 21:17:14 +03:00
return NT_STATUS_OK ;
2007-10-02 23:50:53 +04:00
2002-01-13 15:33:42 +03:00
/* Blocking read */
2005-06-14 02:26:08 +04:00
if ( time_out = = 0 ) {
if ( mincnt = = 0 ) {
mincnt = maxcnt ;
}
2007-10-02 23:50:53 +04:00
2002-01-13 15:33:42 +03:00
while ( nread < mincnt ) {
2009-09-07 08:38:50 +04:00
readret = sys_read ( fd , buf + nread , maxcnt - nread ) ;
2007-10-02 23:50:53 +04:00
2002-01-13 15:33:42 +03:00
if ( readret = = 0 ) {
2009-09-07 08:38:50 +04:00
DEBUG ( 5 , ( " read_fd_with_timeout: "
2007-10-02 23:50:53 +04:00
" blocking read. EOF from client. \n " ) ) ;
2008-01-24 21:17:14 +03:00
return NT_STATUS_END_OF_FILE ;
2002-01-13 15:33:42 +03:00
}
2007-10-02 23:50:53 +04:00
2002-01-13 15:33:42 +03:00
if ( readret = = - 1 ) {
2010-08-18 13:17:52 +04:00
return map_nt_error_from_unix ( errno ) ;
2002-01-13 15:33:42 +03:00
}
nread + = readret ;
}
2008-01-24 21:17:14 +03:00
goto done ;
2002-01-13 15:33:42 +03:00
}
2007-10-02 23:50:53 +04:00
2002-01-13 15:33:42 +03:00
/* Most difficult - timeout read */
2007-10-02 23:50:53 +04:00
/* If this is ever called on a disk file and
2002-01-13 15:33:42 +03:00
mincnt is greater then the filesize then
2007-10-02 23:50:53 +04:00
system performance will suffer severely as
2002-01-13 15:33:42 +03:00
select always returns true on disk files */
2007-10-02 23:50:53 +04:00
for ( nread = 0 ; nread < mincnt ; ) {
2011-02-08 19:57:12 +03:00
int revents ;
2007-10-02 23:50:53 +04:00
2011-02-08 19:57:12 +03:00
pollrtn = poll_intr_one_fd ( fd , POLLIN | POLLHUP , time_out ,
& revents ) ;
2007-10-02 23:50:53 +04:00
2002-01-13 15:33:42 +03:00
/* Check if error */
2011-02-08 19:57:12 +03:00
if ( pollrtn = = - 1 ) {
2010-08-18 13:17:52 +04:00
return map_nt_error_from_unix ( errno ) ;
2002-01-13 15:33:42 +03:00
}
2007-10-02 23:50:53 +04:00
2002-01-13 15:33:42 +03:00
/* Did we timeout ? */
2011-02-08 19:57:12 +03:00
if ( ( pollrtn = = 0 ) | |
( ( revents & ( POLLIN | POLLHUP | POLLERR ) ) = = 0 ) ) {
2009-09-07 08:38:50 +04:00
DEBUG ( 10 , ( " read_fd_with_timeout: timeout read. "
2007-10-02 23:50:53 +04:00
" select timed out. \n " ) ) ;
2008-01-24 21:17:14 +03:00
return NT_STATUS_IO_TIMEOUT ;
2002-01-13 15:33:42 +03:00
}
2007-10-02 23:50:53 +04:00
2009-09-07 08:38:50 +04:00
readret = sys_read ( fd , buf + nread , maxcnt - nread ) ;
2007-10-02 23:50:53 +04:00
2002-01-13 15:33:42 +03:00
if ( readret = = 0 ) {
/* we got EOF on the file descriptor */
2009-09-07 08:38:50 +04:00
DEBUG ( 5 , ( " read_fd_with_timeout: timeout read. "
2007-10-02 23:50:53 +04:00
" EOF from client. \n " ) ) ;
2008-01-24 21:17:14 +03:00
return NT_STATUS_END_OF_FILE ;
2002-01-13 15:33:42 +03:00
}
2007-10-02 23:50:53 +04:00
2002-01-13 15:33:42 +03:00
if ( readret = = - 1 ) {
2008-01-24 21:17:14 +03:00
return map_nt_error_from_unix ( errno ) ;
2002-01-13 15:33:42 +03:00
}
2007-10-02 23:50:53 +04:00
2002-01-13 15:33:42 +03:00
nread + = readret ;
}
2007-10-02 23:50:53 +04:00
2008-01-24 21:17:14 +03:00
done :
2002-01-13 15:33:42 +03:00
/* Return the number we got */
2008-01-24 21:17:14 +03:00
if ( size_ret ) {
* size_ret = nread ;
}
return NT_STATUS_OK ;
}
2008-01-26 01:41:48 +03:00
/****************************************************************************
2009-09-07 08:38:50 +04:00
Read data from an fd , reading exactly N bytes .
NB . This can be called with a non - socket fd , don ' t add dependencies
on socket calls .
2008-01-26 01:41:48 +03:00
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2008-01-26 12:39:21 +03:00
NTSTATUS read_data ( int fd , char * buffer , size_t N )
2008-01-24 21:17:14 +03:00
{
2010-08-15 17:30:21 +04:00
return read_fd_with_timeout ( fd , buffer , N , N , 0 , NULL ) ;
1998-11-09 19:40:38 +03:00
}
2008-12-23 00:17:28 +03:00
/****************************************************************************
Write all data from an iov array
2009-09-07 08:38:50 +04:00
NB . This can be called with a non - socket fd , don ' t add dependencies
on socket calls .
2008-12-23 00:17:28 +03:00
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
ssize_t write_data_iov ( int fd , const struct iovec * orig_iov , int iovcnt )
{
int i ;
size_t to_send ;
ssize_t thistime ;
size_t sent ;
struct iovec * iov_copy , * iov ;
to_send = 0 ;
for ( i = 0 ; i < iovcnt ; i + + ) {
to_send + = orig_iov [ i ] . iov_len ;
}
thistime = sys_writev ( fd , orig_iov , iovcnt ) ;
if ( ( thistime < = 0 ) | | ( thistime = = to_send ) ) {
return thistime ;
}
sent = thistime ;
/*
* We could not send everything in one call . Make a copy of iov that
* we can mess with . We keep a copy of the array start in iov_copy for
* the TALLOC_FREE , because we ' re going to modify iov later on ,
* discarding elements .
*/
iov_copy = ( struct iovec * ) TALLOC_MEMDUP (
talloc_tos ( ) , orig_iov , sizeof ( struct iovec ) * iovcnt ) ;
if ( iov_copy = = NULL ) {
errno = ENOMEM ;
return - 1 ;
}
iov = iov_copy ;
while ( sent < to_send ) {
/*
* We have to discard " thistime " bytes from the beginning
* iov array , " thistime " contains the number of bytes sent
* via writev last .
*/
while ( thistime > 0 ) {
if ( thistime < iov [ 0 ] . iov_len ) {
char * new_base =
( char * ) iov [ 0 ] . iov_base + thistime ;
2009-05-12 22:45:37 +04:00
iov [ 0 ] . iov_base = ( void * ) new_base ;
2008-12-23 00:17:28 +03:00
iov [ 0 ] . iov_len - = thistime ;
break ;
}
thistime - = iov [ 0 ] . iov_len ;
iov + = 1 ;
iovcnt - = 1 ;
}
thistime = sys_writev ( fd , iov , iovcnt ) ;
if ( thistime < = 0 ) {
break ;
}
sent + = thistime ;
}
TALLOC_FREE ( iov_copy ) ;
return sent ;
}
1998-11-09 19:40:38 +03:00
/****************************************************************************
1999-12-13 16:27:58 +03:00
Write data to a fd .
2009-09-07 08:38:50 +04:00
NB . This can be called with a non - socket fd , don ' t add dependencies
on socket calls .
1998-11-09 19:40:38 +03:00
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
1999-12-13 16:27:58 +03:00
2005-05-18 22:02:15 +04:00
ssize_t write_data ( int fd , const char * buffer , size_t N )
1998-11-09 19:40:38 +03:00
{
2008-12-23 00:17:59 +03:00
struct iovec iov ;
1999-12-13 16:27:58 +03:00
2009-05-12 22:45:37 +04:00
iov . iov_base = CONST_DISCARD ( void * , buffer ) ;
2008-12-23 00:17:59 +03:00
iov . iov_len = N ;
2010-08-15 18:02:37 +04:00
return write_data_iov ( fd , & iov , 1 ) ;
1998-11-09 19:40:38 +03:00
}
2002-07-15 14:35:28 +04:00
/****************************************************************************
2003-07-17 01:06:21 +04:00
Send a keepalive packet ( rfc1002 ) .
2002-07-15 14:35:28 +04:00
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
1999-12-13 16:27:58 +03:00
2007-10-11 05:25:16 +04:00
bool send_keepalive ( int client )
2002-07-15 14:35:28 +04:00
{
unsigned char buf [ 4 ] ;
buf [ 0 ] = SMBkeepalive ;
buf [ 1 ] = buf [ 2 ] = buf [ 3 ] = 0 ;
2005-06-14 02:26:08 +04:00
return ( write_data ( client , ( char * ) buf , 4 ) = = 4 ) ;
1999-12-13 16:27:58 +03:00
}
1998-11-09 19:40:38 +03:00
/****************************************************************************
2003-07-17 01:06:21 +04:00
Read 4 bytes of a smb packet and return the smb length of the packet .
Store the result in the buffer .
This version of the function will return a length of zero on receiving
a keepalive packet .
Timeout is in milliseconds .
1998-11-09 19:40:38 +03:00
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
1999-12-13 16:27:58 +03:00
2008-01-25 23:24:48 +03:00
NTSTATUS read_smb_length_return_keepalive ( int fd , char * inbuf ,
unsigned int timeout ,
size_t * len )
1998-11-09 19:40:38 +03:00
{
2002-07-15 14:35:28 +04:00
int msg_type ;
2008-01-25 23:02:52 +03:00
NTSTATUS status ;
2009-09-07 08:38:50 +04:00
status = read_fd_with_timeout ( fd , inbuf , 4 , 4 , timeout , NULL ) ;
2008-01-25 23:02:52 +03:00
if ( ! NT_STATUS_IS_OK ( status ) ) {
2008-01-25 23:24:48 +03:00
return status ;
2008-01-25 11:21:44 +03:00
}
1998-11-09 19:40:38 +03:00
2008-01-25 23:24:48 +03:00
* len = smb_len ( inbuf ) ;
2008-01-25 11:21:44 +03:00
msg_type = CVAL ( inbuf , 0 ) ;
1998-11-09 19:40:38 +03:00
2008-01-25 11:21:44 +03:00
if ( msg_type = = SMBkeepalive ) {
DEBUG ( 5 , ( " Got keepalive packet \n " ) ) ;
2002-07-15 14:35:28 +04:00
}
1998-11-09 19:40:38 +03:00
2008-02-06 00:17:20 +03:00
DEBUG ( 10 , ( " got smb length of %lu \n " , ( unsigned long ) ( * len ) ) ) ;
1998-11-09 19:40:38 +03:00
2008-01-25 23:24:48 +03:00
return NT_STATUS_OK ;
1998-11-09 19:40:38 +03:00
}
/****************************************************************************
2008-05-28 20:31:42 +04:00
Read an smb from a fd .
2007-10-02 23:50:53 +04:00
The timeout is in milliseconds .
2003-07-17 01:06:21 +04:00
This function will return on receipt of a session keepalive packet .
2007-05-16 04:07:38 +04:00
maxlen is the max number of bytes to return , not including the 4 byte
2008-05-28 20:31:42 +04:00
length . If zero it means buflen limit .
2003-10-22 01:19:00 +04:00
Doesn ' t check the MAC on signed packets .
1998-11-09 19:40:38 +03:00
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
1999-12-13 16:27:58 +03:00
2008-05-28 20:31:42 +04:00
NTSTATUS receive_smb_raw ( int fd , char * buffer , size_t buflen , unsigned int timeout ,
2008-01-26 01:54:22 +03:00
size_t maxlen , size_t * p_len )
1998-11-09 19:40:38 +03:00
{
2008-01-25 23:24:48 +03:00
size_t len ;
NTSTATUS status ;
1998-11-09 19:40:38 +03:00
2008-01-25 23:24:48 +03:00
status = read_smb_length_return_keepalive ( fd , buffer , timeout , & len ) ;
2002-02-24 00:03:21 +03:00
2008-01-25 23:24:48 +03:00
if ( ! NT_STATUS_IS_OK ( status ) ) {
2010-08-15 17:40:08 +04:00
DEBUG ( 0 , ( " read_fd_with_timeout failed, read "
" error = %s. \n " , nt_errstr ( status ) ) ) ;
2008-01-26 01:54:22 +03:00
return status ;
2001-05-24 23:28:22 +04:00
}
1998-11-09 19:40:38 +03:00
2008-05-28 20:31:42 +04:00
if ( len > buflen ) {
2007-10-02 23:50:53 +04:00
DEBUG ( 0 , ( " Invalid packet length! (%lu bytes). \n " ,
( unsigned long ) len ) ) ;
2008-05-28 20:31:42 +04:00
return NT_STATUS_INVALID_PARAMETER ;
2001-05-24 23:28:22 +04:00
}
if ( len > 0 ) {
2007-05-16 04:07:38 +04:00
if ( maxlen ) {
len = MIN ( len , maxlen ) ;
}
2009-09-07 08:38:50 +04:00
status = read_fd_with_timeout (
2008-01-26 01:41:48 +03:00
fd , buffer + 4 , len , len , timeout , & len ) ;
if ( ! NT_STATUS_IS_OK ( status ) ) {
2010-08-15 17:40:08 +04:00
DEBUG ( 0 , ( " read_fd_with_timeout failed, read error = "
" %s. \n " , nt_errstr ( status ) ) ) ;
2008-01-26 01:54:22 +03:00
return status ;
2001-05-24 23:28:22 +04:00
}
2007-10-02 23:50:53 +04:00
/* not all of samba3 properly checks for packet-termination
* of strings . This ensures that we don ' t run off into
* empty space . */
2005-05-27 21:47:24 +04:00
SSVAL ( buffer + 4 , len , 0 ) ;
2001-05-24 23:28:22 +04:00
}
2008-01-26 01:54:22 +03:00
* p_len = len ;
return NT_STATUS_OK ;
2003-10-22 01:19:00 +04:00
}
1998-11-09 19:40:38 +03:00
/****************************************************************************
2001-08-26 23:11:33 +04:00
Open a socket of the specified type , port , and address for incoming data .
1998-11-09 19:40:38 +03:00
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
1999-12-13 16:27:58 +03:00
2007-10-02 23:50:53 +04:00
int open_socket_in ( int type ,
2007-10-25 01:16:54 +04:00
uint16_t port ,
2007-10-02 23:50:53 +04:00
int dlevel ,
2007-10-25 01:16:54 +04:00
const struct sockaddr_storage * psock ,
bool rebind )
2001-08-26 23:11:33 +04:00
{
2007-10-25 01:16:54 +04:00
struct sockaddr_storage sock ;
2001-08-26 23:11:33 +04:00
int res ;
2007-11-03 00:22:19 +03:00
socklen_t slen = sizeof ( struct sockaddr_in ) ;
1998-11-09 19:40:38 +03:00
2007-10-25 01:16:54 +04:00
sock = * psock ;
1998-11-09 19:40:38 +03:00
2007-10-25 01:16:54 +04:00
# if defined(HAVE_IPV6)
if ( sock . ss_family = = AF_INET6 ) {
( ( struct sockaddr_in6 * ) & sock ) - > sin6_port = htons ( port ) ;
2007-11-03 00:22:19 +03:00
slen = sizeof ( struct sockaddr_in6 ) ;
2007-10-25 01:16:54 +04:00
}
1998-11-09 19:40:38 +03:00
# endif
2007-10-25 01:16:54 +04:00
if ( sock . ss_family = = AF_INET ) {
( ( struct sockaddr_in * ) & sock ) - > sin_port = htons ( port ) ;
}
2001-08-26 23:11:33 +04:00
2007-10-25 01:16:54 +04:00
res = socket ( sock . ss_family , type , 0 ) ;
2001-08-26 23:11:33 +04:00
if ( res = = - 1 ) {
if ( DEBUGLVL ( 0 ) ) {
dbgtext ( " open_socket_in(): socket() call failed: " ) ;
dbgtext ( " %s \n " , strerror ( errno ) ) ;
}
return - 1 ;
}
2001-08-26 08:16:51 +04:00
2001-08-26 23:11:33 +04:00
/* This block sets/clears the SO_REUSEADDR and possibly SO_REUSEPORT. */
{
int val = rebind ? 1 : 0 ;
2007-10-02 23:50:53 +04:00
if ( setsockopt ( res , SOL_SOCKET , SO_REUSEADDR ,
( char * ) & val , sizeof ( val ) ) = = - 1 ) {
2001-08-26 23:11:33 +04:00
if ( DEBUGLVL ( dlevel ) ) {
dbgtext ( " open_socket_in(): setsockopt: " ) ;
2007-10-02 23:50:53 +04:00
dbgtext ( " SO_REUSEADDR = %s " ,
2007-10-11 05:25:16 +04:00
val ? " true " : " false " ) ;
2001-08-26 23:11:33 +04:00
dbgtext ( " on port %d failed " , port ) ;
dbgtext ( " with error = %s \n " , strerror ( errno ) ) ;
}
}
2000-02-17 01:48:19 +03:00
# ifdef SO_REUSEPORT
2007-10-02 23:50:53 +04:00
if ( setsockopt ( res , SOL_SOCKET , SO_REUSEPORT ,
( char * ) & val , sizeof ( val ) ) = = - 1 ) {
2001-08-26 23:11:33 +04:00
if ( DEBUGLVL ( dlevel ) ) {
2001-08-28 05:28:01 +04:00
dbgtext ( " open_socket_in(): setsockopt: " ) ;
2007-10-02 23:50:53 +04:00
dbgtext ( " SO_REUSEPORT = %s " ,
2007-10-25 01:16:54 +04:00
val ? " true " : " false " ) ;
dbgtext ( " on port %d failed " , port ) ;
dbgtext ( " with error = %s \n " , strerror ( errno ) ) ;
2001-08-26 23:11:33 +04:00
}
}
2000-02-17 01:48:19 +03:00
# endif /* SO_REUSEPORT */
2001-08-26 23:11:33 +04:00
}
1998-11-09 19:40:38 +03:00
2001-08-26 23:11:33 +04:00
/* now we've got a socket - we need to bind it */
2007-11-03 00:22:19 +03:00
if ( bind ( res , ( struct sockaddr * ) & sock , slen ) = = - 1 ) {
2007-10-02 23:50:53 +04:00
if ( DEBUGLVL ( dlevel ) & & ( port = = SMB_PORT1 | |
port = = SMB_PORT2 | | port = = NMB_PORT ) ) {
2007-10-25 01:16:54 +04:00
char addr [ INET6_ADDRSTRLEN ] ;
print_sockaddr ( addr , sizeof ( addr ) ,
& sock ) ;
dbgtext ( " bind failed on port %d " , port ) ;
dbgtext ( " socket_addr = %s. \n " , addr ) ;
dbgtext ( " Error = %s \n " , strerror ( errno ) ) ;
2001-08-26 23:11:33 +04:00
}
2007-10-25 01:16:54 +04:00
close ( res ) ;
2007-10-02 23:50:53 +04:00
return - 1 ;
2001-08-26 23:11:33 +04:00
}
1998-11-09 19:40:38 +03:00
2002-07-15 14:35:28 +04:00
DEBUG ( 10 , ( " bind succeeded on port %d \n " , port ) ) ;
2001-08-26 23:11:33 +04:00
return ( res ) ;
}
1998-11-09 19:40:38 +03:00
2009-01-03 21:50:05 +03:00
struct open_socket_out_state {
int fd ;
struct event_context * ev ;
struct sockaddr_storage ss ;
socklen_t salen ;
uint16_t port ;
int wait_nsec ;
} ;
2009-02-22 21:49:18 +03:00
static void open_socket_out_connected ( struct tevent_req * subreq ) ;
2009-01-03 21:50:05 +03:00
static int open_socket_out_state_destructor ( struct open_socket_out_state * s )
{
if ( s - > fd ! = - 1 ) {
close ( s - > fd ) ;
}
return 0 ;
}
1998-11-09 19:40:38 +03:00
/****************************************************************************
2003-07-17 01:06:21 +04:00
Create an outgoing socket . timeout is in milliseconds .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
1999-12-13 16:27:58 +03:00
2009-02-26 14:34:39 +03:00
struct tevent_req * open_socket_out_send ( TALLOC_CTX * mem_ctx ,
struct event_context * ev ,
const struct sockaddr_storage * pss ,
uint16_t port ,
int timeout )
1998-11-09 19:40:38 +03:00
{
2007-10-25 01:16:54 +04:00
char addr [ INET6_ADDRSTRLEN ] ;
2009-02-26 14:34:39 +03:00
struct tevent_req * result , * subreq ;
2009-01-03 21:50:05 +03:00
struct open_socket_out_state * state ;
NTSTATUS status ;
2009-02-26 14:34:39 +03:00
result = tevent_req_create ( mem_ctx , & state ,
struct open_socket_out_state ) ;
if ( result = = NULL ) {
2009-01-03 21:50:05 +03:00
return NULL ;
}
state - > ev = ev ;
state - > ss = * pss ;
state - > port = port ;
state - > wait_nsec = 10000 ;
state - > salen = - 1 ;
state - > fd = socket ( state - > ss . ss_family , SOCK_STREAM , 0 ) ;
if ( state - > fd = = - 1 ) {
status = map_nt_error_from_unix ( errno ) ;
goto post_status ;
}
talloc_set_destructor ( state , open_socket_out_state_destructor ) ;
2009-02-26 14:34:39 +03:00
if ( ! tevent_req_set_endtime (
result , ev , timeval_current_ofs ( 0 , timeout * 1000 ) ) ) {
2009-01-03 21:50:05 +03:00
goto fail ;
2003-07-17 01:06:21 +04:00
}
1998-11-09 19:40:38 +03:00
2007-10-25 01:16:54 +04:00
# if defined(HAVE_IPV6)
if ( pss - > ss_family = = AF_INET6 ) {
2009-01-03 21:50:05 +03:00
struct sockaddr_in6 * psa6 ;
psa6 = ( struct sockaddr_in6 * ) & state - > ss ;
2007-10-25 01:16:54 +04:00
psa6 - > sin6_port = htons ( port ) ;
2009-01-03 21:50:05 +03:00
if ( psa6 - > sin6_scope_id = = 0
& & IN6_IS_ADDR_LINKLOCAL ( & psa6 - > sin6_addr ) ) {
setup_linklocal_scope_id (
( struct sockaddr * ) & ( state - > ss ) ) ;
2007-10-26 05:28:36 +04:00
}
2009-01-03 21:50:05 +03:00
state - > salen = sizeof ( struct sockaddr_in6 ) ;
2007-10-25 01:16:54 +04:00
}
# endif
if ( pss - > ss_family = = AF_INET ) {
2009-01-03 21:50:05 +03:00
struct sockaddr_in * psa ;
psa = ( struct sockaddr_in * ) & state - > ss ;
2007-10-25 01:16:54 +04:00
psa - > sin_port = htons ( port ) ;
2009-01-03 21:50:05 +03:00
state - > salen = sizeof ( struct sockaddr_in ) ;
2007-10-25 01:16:54 +04:00
}
1998-11-09 19:40:38 +03:00
2009-06-06 02:47:53 +04:00
if ( pss - > ss_family = = AF_UNIX ) {
state - > salen = sizeof ( struct sockaddr_un ) ;
}
2009-01-03 21:50:05 +03:00
print_sockaddr ( addr , sizeof ( addr ) , & state - > ss ) ;
DEBUG ( 3 , ( " Connecting to %s at port %u \n " , addr , ( unsigned int ) port ) ) ;
subreq = async_connect_send ( state , state - > ev , state - > fd ,
( struct sockaddr * ) & state - > ss ,
state - > salen ) ;
if ( ( subreq = = NULL )
2009-02-22 21:49:18 +03:00
| | ! tevent_req_set_endtime (
subreq , state - > ev ,
timeval_current_ofs ( 0 , state - > wait_nsec ) ) ) {
2009-02-26 14:34:39 +03:00
goto fail ;
2009-01-03 21:50:05 +03:00
}
2009-02-28 23:44:30 +03:00
tevent_req_set_callback ( subreq , open_socket_out_connected , result ) ;
2009-01-03 21:50:05 +03:00
return result ;
1998-11-09 19:40:38 +03:00
2009-01-03 21:50:05 +03:00
post_status :
2009-02-26 14:34:39 +03:00
tevent_req_nterror ( result , status ) ;
return tevent_req_post ( result , ev ) ;
2009-01-03 21:50:05 +03:00
fail :
TALLOC_FREE ( result ) ;
return NULL ;
}
2007-10-02 23:50:53 +04:00
2009-02-22 21:49:18 +03:00
static void open_socket_out_connected ( struct tevent_req * subreq )
2009-01-03 21:50:05 +03:00
{
2009-02-28 23:44:30 +03:00
struct tevent_req * req =
tevent_req_callback_data ( subreq , struct tevent_req ) ;
struct open_socket_out_state * state =
tevent_req_data ( req , struct open_socket_out_state ) ;
2009-02-22 21:49:18 +03:00
int ret ;
2009-01-03 21:50:05 +03:00
int sys_errno ;
2003-07-17 01:06:21 +04:00
2009-02-22 21:49:18 +03:00
ret = async_connect_recv ( subreq , & sys_errno ) ;
2009-01-03 21:50:05 +03:00
TALLOC_FREE ( subreq ) ;
2009-02-22 21:49:18 +03:00
if ( ret = = 0 ) {
2009-02-26 14:34:39 +03:00
tevent_req_done ( req ) ;
2009-01-03 21:50:05 +03:00
return ;
}
2009-02-09 20:36:40 +03:00
if (
# ifdef ETIMEDOUT
( sys_errno = = ETIMEDOUT ) | |
# endif
( sys_errno = = EINPROGRESS ) | |
( sys_errno = = EALREADY ) | |
( sys_errno = = EAGAIN ) ) {
2009-01-03 21:50:05 +03:00
/*
* retry
*/
2003-07-17 01:06:21 +04:00
2009-01-03 21:50:05 +03:00
if ( state - > wait_nsec < 250000 ) {
state - > wait_nsec * = 1.5 ;
2003-07-17 01:06:21 +04:00
}
2009-01-03 21:50:05 +03:00
subreq = async_connect_send ( state , state - > ev , state - > fd ,
( struct sockaddr * ) & state - > ss ,
state - > salen ) ;
2009-02-26 14:34:39 +03:00
if ( tevent_req_nomem ( subreq , req ) ) {
2009-01-03 21:50:05 +03:00
return ;
}
2009-02-22 21:49:18 +03:00
if ( ! tevent_req_set_endtime (
subreq , state - > ev ,
timeval_current_ofs ( 0 , state - > wait_nsec ) ) ) {
2009-02-26 14:34:39 +03:00
tevent_req_nterror ( req , NT_STATUS_NO_MEMORY ) ;
2009-01-03 21:50:05 +03:00
return ;
}
2009-02-28 23:44:30 +03:00
tevent_req_set_callback ( subreq , open_socket_out_connected , req ) ;
2009-01-03 21:50:05 +03:00
return ;
2003-07-17 01:06:21 +04:00
}
1998-11-09 19:40:38 +03:00
# ifdef EISCONN
2009-01-03 21:50:05 +03:00
if ( sys_errno = = EISCONN ) {
2009-02-26 14:34:39 +03:00
tevent_req_done ( req ) ;
2009-01-03 21:50:05 +03:00
return ;
2003-07-17 01:06:21 +04:00
}
1998-11-09 19:40:38 +03:00
# endif
2009-01-03 21:50:05 +03:00
/* real error */
2009-02-26 14:34:39 +03:00
tevent_req_nterror ( req , map_nt_error_from_unix ( sys_errno ) ) ;
2009-01-03 21:50:05 +03:00
}
2009-02-26 14:34:39 +03:00
NTSTATUS open_socket_out_recv ( struct tevent_req * req , int * pfd )
2009-01-03 21:50:05 +03:00
{
2009-02-28 23:44:30 +03:00
struct open_socket_out_state * state =
tevent_req_data ( req , struct open_socket_out_state ) ;
2009-02-26 14:34:39 +03:00
NTSTATUS status ;
2009-01-03 21:50:05 +03:00
2009-02-26 14:34:39 +03:00
if ( tevent_req_is_nterror ( req , & status ) ) {
return status ;
2009-01-03 21:50:05 +03:00
}
* pfd = state - > fd ;
state - > fd = - 1 ;
return NT_STATUS_OK ;
}
NTSTATUS open_socket_out ( const struct sockaddr_storage * pss , uint16_t port ,
int timeout , int * pfd )
{
TALLOC_CTX * frame = talloc_stackframe ( ) ;
struct event_context * ev ;
2009-02-26 14:34:39 +03:00
struct tevent_req * req ;
2009-01-03 21:50:05 +03:00
NTSTATUS status = NT_STATUS_NO_MEMORY ;
ev = event_context_init ( frame ) ;
if ( ev = = NULL ) {
goto fail ;
2003-07-17 01:06:21 +04:00
}
1998-11-09 19:40:38 +03:00
2009-01-03 21:50:05 +03:00
req = open_socket_out_send ( frame , ev , pss , port , timeout ) ;
if ( req = = NULL ) {
goto fail ;
}
2009-02-26 14:34:39 +03:00
if ( ! tevent_req_poll ( req , ev ) ) {
status = NT_STATUS_INTERNAL_ERROR ;
goto fail ;
2009-01-03 21:50:05 +03:00
}
status = open_socket_out_recv ( req , pfd ) ;
fail :
TALLOC_FREE ( frame ) ;
return status ;
1998-11-09 19:40:38 +03:00
}
2009-01-04 03:45:06 +03:00
struct open_socket_out_defer_state {
struct event_context * ev ;
struct sockaddr_storage ss ;
uint16_t port ;
int timeout ;
int fd ;
} ;
2009-03-16 20:43:57 +03:00
static void open_socket_out_defer_waited ( struct tevent_req * subreq ) ;
2009-02-26 14:34:39 +03:00
static void open_socket_out_defer_connected ( struct tevent_req * subreq ) ;
2009-01-04 03:45:06 +03:00
2009-03-16 21:15:26 +03:00
struct tevent_req * open_socket_out_defer_send ( TALLOC_CTX * mem_ctx ,
struct event_context * ev ,
struct timeval wait_time ,
const struct sockaddr_storage * pss ,
uint16_t port ,
int timeout )
2009-01-04 03:45:06 +03:00
{
2009-03-16 21:15:26 +03:00
struct tevent_req * req , * subreq ;
2009-01-04 03:45:06 +03:00
struct open_socket_out_defer_state * state ;
2009-03-16 21:15:26 +03:00
req = tevent_req_create ( mem_ctx , & state ,
struct open_socket_out_defer_state ) ;
if ( req = = NULL ) {
2009-01-04 03:45:06 +03:00
return NULL ;
}
state - > ev = ev ;
state - > ss = * pss ;
state - > port = port ;
state - > timeout = timeout ;
2009-03-16 20:43:57 +03:00
subreq = tevent_wakeup_send (
state , ev ,
timeval_current_ofs ( wait_time . tv_sec , wait_time . tv_usec ) ) ;
2009-01-04 03:45:06 +03:00
if ( subreq = = NULL ) {
goto fail ;
}
2009-03-16 21:15:26 +03:00
tevent_req_set_callback ( subreq , open_socket_out_defer_waited , req ) ;
return req ;
2009-01-04 03:45:06 +03:00
fail :
2009-03-16 21:15:26 +03:00
TALLOC_FREE ( req ) ;
2009-01-04 03:45:06 +03:00
return NULL ;
}
2009-03-16 20:43:57 +03:00
static void open_socket_out_defer_waited ( struct tevent_req * subreq )
2009-01-04 03:45:06 +03:00
{
2009-03-16 21:15:26 +03:00
struct tevent_req * req = tevent_req_callback_data (
subreq , struct tevent_req ) ;
struct open_socket_out_defer_state * state = tevent_req_data (
req , struct open_socket_out_defer_state ) ;
2009-02-01 18:32:02 +03:00
bool ret ;
2009-01-04 03:45:06 +03:00
2009-03-16 20:43:57 +03:00
ret = tevent_wakeup_recv ( subreq ) ;
2009-01-04 03:45:06 +03:00
TALLOC_FREE ( subreq ) ;
2009-02-01 18:32:02 +03:00
if ( ! ret ) {
2009-03-16 21:15:26 +03:00
tevent_req_nterror ( req , NT_STATUS_INTERNAL_ERROR ) ;
2009-01-04 03:45:06 +03:00
return ;
}
2009-03-16 20:43:57 +03:00
subreq = open_socket_out_send ( state , state - > ev , & state - > ss ,
state - > port , state - > timeout ) ;
2009-03-16 21:15:26 +03:00
if ( tevent_req_nomem ( subreq , req ) ) {
2009-01-04 03:45:06 +03:00
return ;
}
2009-03-16 20:43:57 +03:00
tevent_req_set_callback ( subreq , open_socket_out_defer_connected , req ) ;
2009-01-04 03:45:06 +03:00
}
2009-02-26 14:34:39 +03:00
static void open_socket_out_defer_connected ( struct tevent_req * subreq )
2009-01-04 03:45:06 +03:00
{
2009-03-16 21:15:26 +03:00
struct tevent_req * req = tevent_req_callback_data (
subreq , struct tevent_req ) ;
struct open_socket_out_defer_state * state = tevent_req_data (
req , struct open_socket_out_defer_state ) ;
2009-01-04 03:45:06 +03:00
NTSTATUS status ;
status = open_socket_out_recv ( subreq , & state - > fd ) ;
TALLOC_FREE ( subreq ) ;
if ( ! NT_STATUS_IS_OK ( status ) ) {
2009-03-16 21:15:26 +03:00
tevent_req_nterror ( req , status ) ;
2009-01-04 03:45:06 +03:00
return ;
}
2009-03-16 21:15:26 +03:00
tevent_req_done ( req ) ;
2009-01-04 03:45:06 +03:00
}
2009-03-16 21:15:26 +03:00
NTSTATUS open_socket_out_defer_recv ( struct tevent_req * req , int * pfd )
2009-01-04 03:45:06 +03:00
{
2009-03-16 21:15:26 +03:00
struct open_socket_out_defer_state * state = tevent_req_data (
req , struct open_socket_out_defer_state ) ;
2009-01-04 03:45:06 +03:00
NTSTATUS status ;
2009-03-16 21:15:26 +03:00
if ( tevent_req_is_nterror ( req , & status ) ) {
2009-01-04 03:45:06 +03:00
return status ;
}
* pfd = state - > fd ;
state - > fd = - 1 ;
return NT_STATUS_OK ;
}
2003-07-17 01:06:21 +04:00
/****************************************************************************
Open a connected UDP socket to host on port
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2001-11-24 17:16:41 +03:00
int open_udp_socket ( const char * host , int port )
{
2009-06-09 00:26:39 +04:00
struct sockaddr_storage ss ;
2001-11-24 17:16:41 +03:00
int res ;
2009-06-09 00:26:39 +04:00
if ( ! interpret_string_addr ( & ss , host , 0 ) ) {
DEBUG ( 10 , ( " open_udp_socket: can't resolve name %s \n " ,
host ) ) ;
return - 1 ;
}
2001-11-24 17:16:41 +03:00
2009-06-09 00:26:39 +04:00
res = socket ( ss . ss_family , SOCK_DGRAM , 0 ) ;
2001-11-24 17:16:41 +03:00
if ( res = = - 1 ) {
return - 1 ;
}
2009-06-09 00:26:39 +04:00
# if defined(HAVE_IPV6)
if ( ss . ss_family = = AF_INET6 ) {
struct sockaddr_in6 * psa6 ;
psa6 = ( struct sockaddr_in6 * ) & ss ;
psa6 - > sin6_port = htons ( port ) ;
if ( psa6 - > sin6_scope_id = = 0
& & IN6_IS_ADDR_LINKLOCAL ( & psa6 - > sin6_addr ) ) {
setup_linklocal_scope_id (
( struct sockaddr * ) & ss ) ;
}
}
# endif
if ( ss . ss_family = = AF_INET ) {
struct sockaddr_in * psa ;
psa = ( struct sockaddr_in * ) & ss ;
psa - > sin_port = htons ( port ) ;
}
2001-11-24 17:16:41 +03:00
2009-06-09 00:26:39 +04:00
if ( sys_connect ( res , ( struct sockaddr * ) & ss ) ) {
2001-11-24 17:16:41 +03:00
close ( res ) ;
return - 1 ;
}
return res ;
}
2007-10-13 00:38:04 +04:00
/*******************************************************************
Return the IP addr of the remote end of a socket as a string .
Optionally return the struct sockaddr_storage .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
static const char * get_peer_addr_internal ( int fd ,
2007-11-04 04:41:26 +03:00
char * addr_buf ,
size_t addr_buf_len ,
2008-10-23 21:53:15 +04:00
struct sockaddr * pss ,
2007-10-13 00:38:04 +04:00
socklen_t * plength )
{
struct sockaddr_storage ss ;
socklen_t length = sizeof ( ss ) ;
2007-11-07 23:48:58 +03:00
strlcpy ( addr_buf , " 0.0.0.0 " , addr_buf_len ) ;
2007-10-13 00:38:04 +04:00
if ( fd = = - 1 ) {
return addr_buf ;
}
if ( pss = = NULL ) {
2008-10-23 21:53:15 +04:00
pss = ( struct sockaddr * ) & ss ;
2007-10-13 00:38:04 +04:00
plength = & length ;
}
if ( getpeername ( fd , ( struct sockaddr * ) pss , plength ) < 0 ) {
2010-03-26 17:14:35 +03:00
int level = ( errno = = ENOTCONN ) ? 2 : 0 ;
DEBUG ( level , ( " getpeername failed. Error was %s \n " ,
strerror ( errno ) ) ) ;
2007-10-13 00:38:04 +04:00
return addr_buf ;
}
2007-10-25 01:16:54 +04:00
print_sockaddr_len ( addr_buf ,
2007-11-04 06:27:59 +03:00
addr_buf_len ,
2007-10-13 00:38:04 +04:00
pss ,
* plength ) ;
return addr_buf ;
}
1998-11-09 19:40:38 +03:00
/*******************************************************************
2003-07-17 01:06:21 +04:00
Matchname - determine if host name matches IP address . Used to
confirm a hostname lookup to prevent spoof attacks .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2007-10-13 00:38:04 +04:00
static bool matchname ( const char * remotehost ,
2008-10-23 21:53:15 +04:00
const struct sockaddr * pss ,
2007-10-13 00:38:04 +04:00
socklen_t len )
1998-11-09 19:40:38 +03:00
{
2007-10-13 00:38:04 +04:00
struct addrinfo * res = NULL ;
struct addrinfo * ailist = NULL ;
char addr_buf [ INET6_ADDRSTRLEN ] ;
2007-10-16 03:11:48 +04:00
bool ret = interpret_string_addr_internal ( & ailist ,
remotehost ,
AI_ADDRCONFIG | AI_CANONNAME ) ;
2007-10-13 00:38:04 +04:00
2007-10-16 03:11:48 +04:00
if ( ! ret | | ailist = = NULL ) {
2007-10-13 00:38:04 +04:00
DEBUG ( 3 , ( " matchname: getaddrinfo failed for "
" name %s [%s] \n " ,
remotehost ,
gai_strerror ( ret ) ) ) ;
2007-10-11 05:25:16 +04:00
return false ;
2007-10-02 23:50:53 +04:00
}
2000-04-11 17:55:53 +04:00
/*
2007-10-13 00:38:04 +04:00
* Make sure that getaddrinfo ( ) returns the " correct " host name .
2000-04-11 17:55:53 +04:00
*/
2007-10-02 23:50:53 +04:00
2007-10-16 03:11:48 +04:00
if ( ailist - > ai_canonname = = NULL | |
( ! strequal ( remotehost , ailist - > ai_canonname ) & &
2007-10-13 00:38:04 +04:00
! strequal ( remotehost , " localhost " ) ) ) {
DEBUG ( 0 , ( " matchname: host name/name mismatch: %s != %s \n " ,
remotehost ,
2007-10-16 03:11:48 +04:00
ailist - > ai_canonname ?
ailist - > ai_canonname : " (NULL) " ) ) ;
freeaddrinfo ( ailist ) ;
2007-10-11 05:25:16 +04:00
return false ;
1998-11-09 19:40:38 +03:00
}
2007-10-02 23:50:53 +04:00
2000-04-11 17:55:53 +04:00
/* Look up the host address in the address list we just got. */
2007-10-16 03:11:48 +04:00
for ( res = ailist ; res ; res = res - > ai_next ) {
if ( ! res - > ai_addr ) {
2007-10-13 00:38:04 +04:00
continue ;
}
2008-12-03 10:29:57 +03:00
if ( sockaddr_equal ( ( const struct sockaddr * ) res - > ai_addr ,
2008-10-23 21:53:15 +04:00
( struct sockaddr * ) pss ) ) {
2007-10-16 03:11:48 +04:00
freeaddrinfo ( ailist ) ;
2007-10-11 05:25:16 +04:00
return true ;
2007-10-13 00:38:04 +04:00
}
1998-11-09 19:40:38 +03:00
}
2007-10-02 23:50:53 +04:00
2000-04-11 17:55:53 +04:00
/*
* The host name does not map to the original host address . Perhaps
* someone has compromised a name server . More likely someone botched
* it , but that could be dangerous , too .
*/
2007-10-02 23:50:53 +04:00
2007-10-13 00:38:04 +04:00
DEBUG ( 0 , ( " matchname: host name/address mismatch: %s != %s \n " ,
2007-10-25 01:16:54 +04:00
print_sockaddr_len ( addr_buf ,
2007-10-13 00:38:04 +04:00
sizeof ( addr_buf ) ,
pss ,
len ) ,
2007-10-16 03:11:48 +04:00
ailist - > ai_canonname ? ailist - > ai_canonname : " (NULL) " ) ) ;
2007-10-13 00:38:04 +04:00
2007-10-16 03:11:48 +04:00
if ( ailist ) {
freeaddrinfo ( ailist ) ;
}
2007-10-11 05:25:16 +04:00
return false ;
2000-04-11 17:55:53 +04:00
}
2008-01-03 04:37:39 +03:00
/*******************************************************************
Deal with the singleton cache .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
struct name_addr_pair {
struct sockaddr_storage ss ;
const char * name ;
} ;
/*******************************************************************
Lookup a name / addr pair . Returns memory allocated from memcache .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
static bool lookup_nc ( struct name_addr_pair * nc )
{
DATA_BLOB tmp ;
ZERO_STRUCTP ( nc ) ;
if ( ! memcache_lookup (
NULL , SINGLETON_CACHE ,
2008-10-13 07:20:26 +04:00
data_blob_string_const_null ( " get_peer_name " ) ,
2008-01-03 04:37:39 +03:00
& tmp ) ) {
return false ;
}
memcpy ( & nc - > ss , tmp . data , sizeof ( nc - > ss ) ) ;
nc - > name = ( const char * ) tmp . data + sizeof ( nc - > ss ) ;
return true ;
}
/*******************************************************************
Save a name / addr pair .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
static void store_nc ( const struct name_addr_pair * nc )
{
DATA_BLOB tmp ;
size_t namelen = strlen ( nc - > name ) ;
2008-01-03 12:24:45 +03:00
tmp = data_blob ( NULL , sizeof ( nc - > ss ) + namelen + 1 ) ;
2008-01-03 04:37:39 +03:00
if ( ! tmp . data ) {
return ;
}
memcpy ( tmp . data , & nc - > ss , sizeof ( nc - > ss ) ) ;
memcpy ( tmp . data + sizeof ( nc - > ss ) , nc - > name , namelen + 1 ) ;
memcache_add ( NULL , SINGLETON_CACHE ,
2008-10-13 07:20:26 +04:00
data_blob_string_const_null ( " get_peer_name " ) ,
2008-01-03 04:37:39 +03:00
tmp ) ;
2008-01-03 12:24:45 +03:00
data_blob_free ( & tmp ) ;
2008-01-03 04:37:39 +03:00
}
2007-11-07 23:48:58 +03:00
2000-04-11 17:55:53 +04:00
/*******************************************************************
2003-07-17 01:06:21 +04:00
Return the DNS name of the remote end of a socket .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2008-01-03 04:37:39 +03:00
const char * get_peer_name ( int fd , bool force_lookup )
2000-04-11 17:55:53 +04:00
{
2008-01-03 04:37:39 +03:00
struct name_addr_pair nc ;
2007-11-04 04:15:45 +03:00
char addr_buf [ INET6_ADDRSTRLEN ] ;
2007-10-13 00:38:04 +04:00
struct sockaddr_storage ss ;
socklen_t length = sizeof ( ss ) ;
2007-10-12 02:36:13 +04:00
const char * p ;
2007-10-13 00:38:04 +04:00
int ret ;
2007-11-16 05:27:26 +03:00
char name_buf [ MAX_DNS_NAME_LENGTH ] ;
char tmp_name [ MAX_DNS_NAME_LENGTH ] ;
2001-09-13 04:30:47 +04:00
/* reverse lookups can be *very* expensive, and in many
situations won ' t work because many networks don ' t link dhcp
with dns . To avoid the delay we avoid the lookup if
possible */
2007-10-11 05:25:16 +04:00
if ( ! lp_hostname_lookups ( ) & & ( force_lookup = = false ) ) {
2007-11-07 23:48:58 +03:00
length = sizeof ( nc . ss ) ;
2008-01-03 04:37:39 +03:00
nc . name = get_peer_addr_internal ( fd , addr_buf , sizeof ( addr_buf ) ,
2008-10-23 21:53:15 +04:00
( struct sockaddr * ) & nc . ss , & length ) ;
2008-01-03 04:37:39 +03:00
store_nc ( & nc ) ;
lookup_nc ( & nc ) ;
2007-11-07 23:48:58 +03:00
return nc . name ? nc . name : " UNKNOWN " ;
2001-09-13 04:30:47 +04:00
}
2007-10-02 23:50:53 +04:00
2008-01-03 04:37:39 +03:00
lookup_nc ( & nc ) ;
2007-11-07 23:48:58 +03:00
memset ( & ss , ' \0 ' , sizeof ( ss ) ) ;
2008-10-23 21:53:15 +04:00
p = get_peer_addr_internal ( fd , addr_buf , sizeof ( addr_buf ) , ( struct sockaddr * ) & ss , & length ) ;
2000-04-11 17:55:53 +04:00
/* it might be the same as the last one - save some DNS work */
2008-12-03 10:29:57 +03:00
if ( sockaddr_equal ( ( struct sockaddr * ) & ss , ( struct sockaddr * ) & nc . ss ) ) {
2007-11-07 23:48:58 +03:00
return nc . name ? nc . name : " UNKNOWN " ;
2007-10-13 00:38:04 +04:00
}
2000-04-11 17:55:53 +04:00
2008-01-03 04:37:39 +03:00
/* Not the same. We need to lookup. */
2007-10-13 00:38:04 +04:00
if ( fd = = - 1 ) {
2007-11-07 23:48:58 +03:00
return " UNKNOWN " ;
2007-10-13 00:38:04 +04:00
}
2000-04-11 17:55:53 +04:00
1998-11-09 19:40:38 +03:00
/* Look up the remote host name. */
2008-01-17 00:21:46 +03:00
ret = sys_getnameinfo ( ( struct sockaddr * ) & ss ,
2007-10-13 00:38:04 +04:00
length ,
name_buf ,
sizeof ( name_buf ) ,
NULL ,
0 ,
2007-10-26 03:14:52 +04:00
0 ) ;
2007-10-13 00:38:04 +04:00
if ( ret ) {
DEBUG ( 1 , ( " get_peer_name: getnameinfo failed "
" for %s with error %s \n " ,
p ,
gai_strerror ( ret ) ) ) ;
2007-11-07 23:48:58 +03:00
strlcpy ( name_buf , p , sizeof ( name_buf ) ) ;
1998-11-09 19:40:38 +03:00
} else {
2008-10-23 21:53:15 +04:00
if ( ! matchname ( name_buf , ( struct sockaddr * ) & ss , length ) ) {
2000-04-11 17:55:53 +04:00
DEBUG ( 0 , ( " Matchname failed on %s %s \n " , name_buf , p ) ) ;
2007-11-07 23:48:58 +03:00
strlcpy ( name_buf , " UNKNOWN " , sizeof ( name_buf ) ) ;
1998-11-09 19:40:38 +03:00
}
}
2001-07-05 08:44:09 +04:00
2007-11-07 23:48:58 +03:00
strlcpy ( tmp_name , name_buf , sizeof ( tmp_name ) ) ;
2003-12-09 21:20:27 +03:00
alpha_strcpy ( name_buf , tmp_name , " _-. " , sizeof ( name_buf ) ) ;
2001-07-05 08:44:09 +04:00
if ( strstr ( name_buf , " .. " ) ) {
2007-11-07 23:48:58 +03:00
strlcpy ( name_buf , " UNKNOWN " , sizeof ( name_buf ) ) ;
2001-07-05 08:44:09 +04:00
}
2008-01-03 04:37:39 +03:00
nc . name = name_buf ;
nc . ss = ss ;
store_nc ( & nc ) ;
lookup_nc ( & nc ) ;
2007-11-07 23:48:58 +03:00
return nc . name ? nc . name : " UNKNOWN " ;
1998-11-09 19:40:38 +03:00
}
/*******************************************************************
2003-07-17 01:06:21 +04:00
Return the IP addr of the remote end of a socket as a string .
1998-11-09 19:40:38 +03:00
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2003-07-17 01:06:21 +04:00
2007-11-04 04:41:26 +03:00
const char * get_peer_addr ( int fd , char * addr , size_t addr_len )
1998-11-09 19:40:38 +03:00
{
2007-11-04 04:41:26 +03:00
return get_peer_addr_internal ( fd , addr , addr_len , NULL , NULL ) ;
1998-11-09 19:40:38 +03:00
}
2000-01-03 22:19:48 +03:00
2002-01-13 14:13:54 +03:00
/*******************************************************************
Create protected unix domain socket .
2003-02-08 00:59:51 +03:00
Some unixes cannot set permissions on a ux - dom - sock , so we
2002-01-13 14:13:54 +03:00
have to make sure that the directory contains the protection
2003-02-08 00:59:51 +03:00
permissions instead .
2002-01-13 14:13:54 +03:00
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2003-02-08 00:59:51 +03:00
2002-01-13 14:13:54 +03:00
int create_pipe_sock ( const char * socket_dir ,
2002-07-15 14:35:28 +04:00
const char * socket_name ,
mode_t dir_perms )
2002-01-13 14:13:54 +03:00
{
2002-09-25 19:19:00 +04:00
# ifdef HAVE_UNIXSOCKET
2003-02-08 00:59:51 +03:00
struct sockaddr_un sunaddr ;
struct stat st ;
int sock ;
mode_t old_umask ;
2007-11-12 08:45:55 +03:00
char * path = NULL ;
2007-10-02 23:50:53 +04:00
2003-02-08 00:59:51 +03:00
old_umask = umask ( 0 ) ;
2007-10-02 23:50:53 +04:00
2003-02-08 00:59:51 +03:00
/* Create the socket directory or reuse the existing one */
2007-10-02 23:50:53 +04:00
2003-02-08 00:59:51 +03:00
if ( lstat ( socket_dir , & st ) = = - 1 ) {
if ( errno = = ENOENT ) {
/* Create directory */
if ( mkdir ( socket_dir , dir_perms ) = = - 1 ) {
DEBUG ( 0 , ( " error creating socket directory "
2007-10-02 23:50:53 +04:00
" %s: %s \n " , socket_dir ,
2003-02-08 00:59:51 +03:00
strerror ( errno ) ) ) ;
goto out_umask ;
}
} else {
DEBUG ( 0 , ( " lstat failed on socket directory %s: %s \n " ,
socket_dir , strerror ( errno ) ) ) ;
goto out_umask ;
}
} else {
/* Check ownership and permission on existing directory */
if ( ! S_ISDIR ( st . st_mode ) ) {
DEBUG ( 0 , ( " socket directory %s isn't a directory \n " ,
socket_dir ) ) ;
goto out_umask ;
}
2007-10-02 23:50:53 +04:00
if ( ( st . st_uid ! = sec_initial_uid ( ) ) | |
2003-02-08 00:59:51 +03:00
( ( st . st_mode & 0777 ) ! = dir_perms ) ) {
DEBUG ( 0 , ( " invalid permissions on socket directory "
" %s \n " , socket_dir ) ) ;
goto out_umask ;
}
}
2007-10-02 23:50:53 +04:00
2003-02-08 00:59:51 +03:00
/* Create the socket file */
2007-10-02 23:50:53 +04:00
2003-02-08 00:59:51 +03:00
sock = socket ( AF_UNIX , SOCK_STREAM , 0 ) ;
2007-10-02 23:50:53 +04:00
2003-02-08 00:59:51 +03:00
if ( sock = = - 1 ) {
2007-11-12 08:45:55 +03:00
DEBUG ( 0 , ( " create_pipe_sock: socket error %s \n " ,
strerror ( errno ) ) ) ;
goto out_close ;
2003-02-08 00:59:51 +03:00
}
2007-10-02 23:50:53 +04:00
2008-02-25 17:24:49 +03:00
if ( asprintf ( & path , " %s/%s " , socket_dir , socket_name ) = = - 1 ) {
2007-11-12 08:45:55 +03:00
goto out_close ;
}
2007-10-02 23:50:53 +04:00
2003-02-08 00:59:51 +03:00
unlink ( path ) ;
memset ( & sunaddr , 0 , sizeof ( sunaddr ) ) ;
sunaddr . sun_family = AF_UNIX ;
2007-11-07 23:48:58 +03:00
strlcpy ( sunaddr . sun_path , path , sizeof ( sunaddr . sun_path ) ) ;
2007-10-02 23:50:53 +04:00
2003-02-08 00:59:51 +03:00
if ( bind ( sock , ( struct sockaddr * ) & sunaddr , sizeof ( sunaddr ) ) = = - 1 ) {
DEBUG ( 0 , ( " bind failed on pipe socket %s: %s \n " , path ,
strerror ( errno ) ) ) ;
goto out_close ;
}
2007-10-02 23:50:53 +04:00
2003-02-08 00:59:51 +03:00
if ( listen ( sock , 5 ) = = - 1 ) {
DEBUG ( 0 , ( " listen failed on pipe socket %s: %s \n " , path ,
strerror ( errno ) ) ) ;
goto out_close ;
}
2007-10-02 23:50:53 +04:00
2007-11-12 08:45:55 +03:00
SAFE_FREE ( path ) ;
2003-02-08 00:59:51 +03:00
umask ( old_umask ) ;
return sock ;
out_close :
2007-11-12 08:45:55 +03:00
SAFE_FREE ( path ) ;
2008-02-18 02:43:46 +03:00
if ( sock ! = - 1 )
close ( sock ) ;
2003-02-08 00:59:51 +03:00
out_umask :
umask ( old_umask ) ;
return - 1 ;
2002-09-25 19:19:00 +04:00
# else
DEBUG ( 0 , ( " create_pipe_sock: No Unix sockets on this system \n " ) ) ;
return - 1 ;
# endif /* HAVE_UNIXSOCKET */
2002-01-13 14:13:54 +03:00
}
2007-10-11 05:25:16 +04:00
2007-10-16 03:11:48 +04:00
/****************************************************************************
Get my own canonical name , including domain .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2007-11-09 04:25:45 +03:00
const char * get_mydnsfullname ( void )
2007-10-16 03:11:48 +04:00
{
2008-01-03 04:37:39 +03:00
struct addrinfo * res = NULL ;
char my_hostname [ HOST_NAME_MAX ] ;
bool ret ;
DATA_BLOB tmp ;
2007-10-16 03:11:48 +04:00
2008-01-03 04:37:39 +03:00
if ( memcache_lookup ( NULL , SINGLETON_CACHE ,
2008-10-13 07:20:26 +04:00
data_blob_string_const_null ( " get_mydnsfullname " ) ,
2008-01-03 04:37:39 +03:00
& tmp ) ) {
SMB_ASSERT ( tmp . length > 0 ) ;
return ( const char * ) tmp . data ;
}
2007-10-16 03:11:48 +04:00
2008-01-03 04:37:39 +03:00
/* get my host name */
if ( gethostname ( my_hostname , sizeof ( my_hostname ) ) = = - 1 ) {
DEBUG ( 0 , ( " get_mydnsfullname: gethostname failed \n " ) ) ;
return NULL ;
}
2007-10-16 03:11:48 +04:00
2008-01-03 04:37:39 +03:00
/* Ensure null termination. */
my_hostname [ sizeof ( my_hostname ) - 1 ] = ' \0 ' ;
2007-10-16 03:11:48 +04:00
2008-01-03 04:37:39 +03:00
ret = interpret_string_addr_internal ( & res ,
2007-11-09 04:25:45 +03:00
my_hostname ,
2008-01-03 04:37:39 +03:00
AI_ADDRCONFIG | AI_CANONNAME ) ;
2007-10-16 03:11:48 +04:00
2008-01-03 04:37:39 +03:00
if ( ! ret | | res = = NULL ) {
DEBUG ( 3 , ( " get_mydnsfullname: getaddrinfo failed for "
" name %s [%s] \n " ,
my_hostname ,
gai_strerror ( ret ) ) ) ;
return NULL ;
}
2007-10-16 03:11:48 +04:00
2008-01-03 04:37:39 +03:00
/*
* Make sure that getaddrinfo ( ) returns the " correct " host name .
*/
2007-10-16 03:11:48 +04:00
2008-01-03 04:37:39 +03:00
if ( res - > ai_canonname = = NULL ) {
DEBUG ( 3 , ( " get_mydnsfullname: failed to get "
" canonical name for %s \n " ,
my_hostname ) ) ;
2007-10-16 03:11:48 +04:00
freeaddrinfo ( res ) ;
2008-01-03 04:37:39 +03:00
return NULL ;
}
/* This copies the data, so we must do a lookup
* afterwards to find the value to return .
*/
memcache_add ( NULL , SINGLETON_CACHE ,
2008-10-13 07:20:26 +04:00
data_blob_string_const_null ( " get_mydnsfullname " ) ,
data_blob_string_const_null ( res - > ai_canonname ) ) ;
2008-01-03 04:37:39 +03:00
if ( ! memcache_lookup ( NULL , SINGLETON_CACHE ,
2008-10-13 07:20:26 +04:00
data_blob_string_const_null ( " get_mydnsfullname " ) ,
2008-01-03 04:37:39 +03:00
& tmp ) ) {
2008-01-21 20:01:55 +03:00
tmp = data_blob_talloc ( talloc_tos ( ) , res - > ai_canonname ,
strlen ( res - > ai_canonname ) + 1 ) ;
2007-10-16 03:11:48 +04:00
}
2008-01-03 04:37:39 +03:00
2008-01-21 15:18:38 +03:00
freeaddrinfo ( res ) ;
2008-01-03 04:37:39 +03:00
return ( const char * ) tmp . data ;
2007-10-16 03:11:48 +04:00
}
2011-03-24 22:11:02 +03:00
/************************************************************
Is this my ip address ?
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
static bool is_my_ipaddr ( const char * ipaddr_str )
{
struct sockaddr_storage ss ;
struct iface_struct * nics ;
int i , n ;
if ( ! interpret_string_addr ( & ss , ipaddr_str , AI_NUMERICHOST ) ) {
return false ;
}
if ( ismyaddr ( ( struct sockaddr * ) & ss ) ) {
return true ;
}
if ( is_zero_addr ( & ss ) | |
is_loopback_addr ( ( struct sockaddr * ) & ss ) ) {
return false ;
}
n = get_interfaces ( talloc_tos ( ) , & nics ) ;
for ( i = 0 ; i < n ; i + + ) {
if ( sockaddr_equal ( ( struct sockaddr * ) & nics [ i ] . ip , ( struct sockaddr * ) & ss ) ) {
TALLOC_FREE ( nics ) ;
return true ;
}
}
TALLOC_FREE ( nics ) ;
return false ;
}
2007-10-11 05:25:16 +04:00
/************************************************************
2007-10-16 03:11:48 +04:00
Is this my name ?
2007-10-11 05:25:16 +04:00
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
bool is_myname_or_ipaddr ( const char * s )
{
2007-11-09 04:25:45 +03:00
TALLOC_CTX * ctx = talloc_tos ( ) ;
char * name = NULL ;
const char * dnsname ;
char * servername = NULL ;
2007-10-11 05:25:16 +04:00
2007-10-16 03:11:48 +04:00
if ( ! s ) {
2007-10-11 05:25:16 +04:00
return false ;
2007-10-13 08:50:41 +04:00
}
2007-10-11 05:25:16 +04:00
2007-10-16 03:11:48 +04:00
/* Santize the string from '\\name' */
2007-11-09 04:25:45 +03:00
name = talloc_strdup ( ctx , s ) ;
if ( ! name ) {
return false ;
}
2007-10-11 05:25:16 +04:00
2007-10-16 03:11:48 +04:00
servername = strrchr_m ( name , ' \\ ' ) ;
if ( ! servername ) {
2007-10-11 05:25:16 +04:00
servername = name ;
2007-10-16 03:11:48 +04:00
} else {
2007-10-11 05:25:16 +04:00
servername + + ;
2007-10-16 03:11:48 +04:00
}
2007-10-11 05:25:16 +04:00
2007-10-16 03:11:48 +04:00
/* Optimize for the common case */
if ( strequal ( servername , global_myname ( ) ) ) {
2007-10-11 05:25:16 +04:00
return true ;
2007-10-16 03:11:48 +04:00
}
2007-10-11 05:25:16 +04:00
2007-10-16 03:11:48 +04:00
/* Check for an alias */
if ( is_myname ( servername ) ) {
2007-10-11 05:25:16 +04:00
return true ;
2007-10-16 03:11:48 +04:00
}
2007-10-11 05:25:16 +04:00
2007-10-16 03:11:48 +04:00
/* Check for loopback */
if ( strequal ( servername , " 127.0.0.1 " ) | |
strequal ( servername , " ::1 " ) ) {
2007-10-11 05:25:16 +04:00
return true ;
2007-10-16 03:11:48 +04:00
}
2007-10-11 05:25:16 +04:00
2007-10-16 03:11:48 +04:00
if ( strequal ( servername , " localhost " ) ) {
2007-10-11 05:25:16 +04:00
return true ;
2007-10-16 03:11:48 +04:00
}
2007-10-11 05:25:16 +04:00
2007-10-16 03:11:48 +04:00
/* Maybe it's my dns name */
2007-11-09 04:25:45 +03:00
dnsname = get_mydnsfullname ( ) ;
if ( dnsname & & strequal ( servername , dnsname ) ) {
return true ;
2007-10-16 03:11:48 +04:00
}
2007-10-11 05:25:16 +04:00
2007-10-16 03:11:48 +04:00
/* Maybe its an IP address? */
if ( is_ipaddress ( servername ) ) {
2011-03-24 22:11:02 +03:00
return is_my_ipaddr ( servername ) ;
}
2007-10-11 05:25:16 +04:00
2011-03-24 22:11:02 +03:00
/* Handle possible CNAME records - convert to an IP addr. list. */
{
/* Use DNS to resolve the name, check all addresses. */
struct addrinfo * p = NULL ;
struct addrinfo * res = NULL ;
2009-04-08 14:47:10 +04:00
2011-03-24 22:11:02 +03:00
if ( ! interpret_string_addr_internal ( & res ,
servername ,
AI_ADDRCONFIG ) ) {
2007-10-16 03:11:48 +04:00
return false ;
}
2007-10-11 05:25:16 +04:00
2011-03-24 22:11:02 +03:00
for ( p = res ; p ; p = p - > ai_next ) {
char addr [ INET6_ADDRSTRLEN ] ;
struct sockaddr_storage ss ;
ZERO_STRUCT ( ss ) ;
memcpy ( & ss , p - > ai_addr , p - > ai_addrlen ) ;
print_sockaddr ( addr ,
sizeof ( addr ) ,
& ss ) ;
if ( is_my_ipaddr ( addr ) ) {
freeaddrinfo ( res ) ;
2007-10-11 05:25:16 +04:00
return true ;
}
}
2011-03-24 22:11:02 +03:00
freeaddrinfo ( res ) ;
2007-10-11 05:25:16 +04:00
}
2007-10-16 03:11:48 +04:00
/* No match */
2007-10-11 05:25:16 +04:00
return false ;
}
2009-04-05 21:58:20 +04:00
2009-04-26 02:01:43 +04:00
struct getaddrinfo_state {
const char * node ;
const char * service ;
const struct addrinfo * hints ;
struct addrinfo * res ;
int ret ;
} ;
static void getaddrinfo_do ( void * private_data ) ;
static void getaddrinfo_done ( struct tevent_req * subreq ) ;
struct tevent_req * getaddrinfo_send ( TALLOC_CTX * mem_ctx ,
struct tevent_context * ev ,
struct fncall_context * ctx ,
const char * node ,
const char * service ,
const struct addrinfo * hints )
{
struct tevent_req * req , * subreq ;
struct getaddrinfo_state * state ;
req = tevent_req_create ( mem_ctx , & state , struct getaddrinfo_state ) ;
if ( req = = NULL ) {
return NULL ;
}
state - > node = node ;
state - > service = service ;
state - > hints = hints ;
subreq = fncall_send ( state , ev , ctx , getaddrinfo_do , state ) ;
if ( tevent_req_nomem ( subreq , req ) ) {
return tevent_req_post ( req , ev ) ;
}
tevent_req_set_callback ( subreq , getaddrinfo_done , req ) ;
return req ;
}
static void getaddrinfo_do ( void * private_data )
{
struct getaddrinfo_state * state =
( struct getaddrinfo_state * ) private_data ;
state - > ret = getaddrinfo ( state - > node , state - > service , state - > hints ,
& state - > res ) ;
}
static void getaddrinfo_done ( struct tevent_req * subreq )
{
struct tevent_req * req = tevent_req_callback_data (
subreq , struct tevent_req ) ;
int ret , err ;
ret = fncall_recv ( subreq , & err ) ;
TALLOC_FREE ( subreq ) ;
if ( ret = = - 1 ) {
tevent_req_error ( req , err ) ;
return ;
}
tevent_req_done ( req ) ;
}
int getaddrinfo_recv ( struct tevent_req * req , struct addrinfo * * res )
{
struct getaddrinfo_state * state = tevent_req_data (
req , struct getaddrinfo_state ) ;
int err ;
if ( tevent_req_is_unix_error ( req , & err ) ) {
switch ( err ) {
case ENOMEM :
return EAI_MEMORY ;
default :
return EAI_FAIL ;
}
}
if ( state - > ret = = 0 ) {
* res = state - > res ;
}
return state - > ret ;
}
2011-02-07 18:55:16 +03:00
int poll_one_fd ( int fd , int events , int timeout , int * revents )
{
struct pollfd * fds ;
int ret ;
int saved_errno ;
fds = TALLOC_ZERO_ARRAY ( talloc_tos ( ) , struct pollfd , 2 ) ;
if ( fds = = NULL ) {
errno = ENOMEM ;
return - 1 ;
}
fds [ 0 ] . fd = fd ;
fds [ 0 ] . events = events ;
ret = sys_poll ( fds , 1 , timeout ) ;
/*
* Assign whatever poll did , even in the ret < = 0 case .
*/
* revents = fds [ 0 ] . revents ;
saved_errno = errno ;
TALLOC_FREE ( fds ) ;
errno = saved_errno ;
return ret ;
}
2011-02-08 19:33:59 +03:00
int poll_intr_one_fd ( int fd , int events , int timeout , int * revents )
{
struct pollfd pfd ;
int ret ;
pfd . fd = fd ;
pfd . events = events ;
ret = sys_poll_intr ( & pfd , 1 , timeout ) ;
if ( ret < = 0 ) {
* revents = 0 ;
return ret ;
}
* revents = pfd . revents ;
return 1 ;
}