1999-12-17 09:11:25 +03:00
/*
2002-01-30 09:08:46 +03:00
Unix SMB / CIFS implementation .
1999-12-17 09:11:25 +03:00
a WINS nsswitch module
Copyright ( C ) Andrew Tridgell 1999
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
1999-12-17 09:11:25 +03:00
( 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
2007-07-10 04:52:41 +04:00
along with this program . If not , see < http : //www.gnu.org/licenses/>.
1999-12-17 09:11:25 +03:00
*/
# include "includes.h"
2001-12-12 19:08:32 +03:00
# ifdef HAVE_NS_API_H
# include <ns_daemon.h>
# endif
1999-12-17 09:11:25 +03:00
2008-11-19 22:22:50 +03:00
# if HAVE_PTHREAD_H
# include <pthread.h>
# endif
# if HAVE_PTHREAD
static pthread_mutex_t wins_nss_mutex = PTHREAD_MUTEX_INITIALIZER ;
# endif
1999-12-17 09:11:25 +03:00
# ifndef INADDRSZ
# define INADDRSZ 4
# endif
2001-12-12 19:08:32 +03:00
static int initialised ;
2007-10-19 04:40:25 +04:00
extern bool AllowDebugChange ;
2001-12-12 19:08:32 +03:00
2006-12-20 04:10:04 +03:00
NSS_STATUS _nss_wins_gethostbyname_r ( const char * hostname , struct hostent * he ,
char * buffer , size_t buflen , int * h_errnop ) ;
NSS_STATUS _nss_wins_gethostbyname2_r ( const char * name , int af , struct hostent * he ,
char * buffer , size_t buflen , int * h_errnop ) ;
2001-05-16 01:53:19 +04:00
/* Use our own create socket code so we don't recurse.... */
static int wins_lookup_open_socket_in ( void )
{
struct sockaddr_in sock ;
int val = 1 ;
int res ;
memset ( ( char * ) & sock , ' \0 ' , sizeof ( sock ) ) ;
# ifdef HAVE_SOCK_SIN_LEN
sock . sin_len = sizeof ( sock ) ;
# endif
sock . sin_port = 0 ;
sock . sin_family = AF_INET ;
sock . sin_addr . s_addr = interpret_addr ( " 0.0.0.0 " ) ;
res = socket ( AF_INET , SOCK_DGRAM , 0 ) ;
if ( res = = - 1 )
return - 1 ;
2008-03-15 01:26:28 +03:00
if ( setsockopt ( res , SOL_SOCKET , SO_REUSEADDR , ( char * ) & val , sizeof ( val ) ) ! = 0 ) {
close ( res ) ;
return - 1 ;
}
2001-05-16 01:53:19 +04:00
# ifdef SO_REUSEPORT
2008-03-15 01:26:28 +03:00
if ( setsockopt ( res , SOL_SOCKET , SO_REUSEPORT , ( char * ) & val , sizeof ( val ) ) ! = 0 ) {
close ( res ) ;
return - 1 ;
}
2001-05-16 01:53:19 +04:00
# endif /* SO_REUSEPORT */
/* now we've got a socket - we need to bind it */
2001-12-22 03:51:32 +03:00
if ( bind ( res , ( struct sockaddr * ) & sock , sizeof ( sock ) ) < 0 ) {
close ( res ) ;
2001-05-16 01:53:19 +04:00
return ( - 1 ) ;
2001-12-22 03:51:32 +03:00
}
set_socket_options ( res , " SO_BROADCAST " ) ;
2001-05-16 01:53:19 +04:00
return res ;
}
2001-12-12 19:08:32 +03:00
static void nss_wins_init ( void )
{
initialised = 1 ;
DEBUGLEVEL = 0 ;
2001-12-22 03:51:32 +03:00
AllowDebugChange = False ;
TimeInit ( ) ;
2001-12-12 19:08:32 +03:00
setup_logging ( " nss_wins " , False ) ;
2006-07-18 02:19:54 +04:00
load_case_tables ( ) ;
2007-12-10 22:30:37 +03:00
lp_load ( get_dyn_CONFIGFILE ( ) , True , False , False , True ) ;
2001-12-12 19:08:32 +03:00
load_interfaces ( ) ;
2001-12-22 03:51:32 +03:00
}
static struct in_addr * lookup_byname_backend ( const char * name , int * count )
1999-12-17 09:11:25 +03:00
{
2002-07-15 14:35:28 +04:00
int fd = - 1 ;
2003-06-25 21:41:05 +04:00
struct ip_service * address = NULL ;
2004-07-25 17:14:00 +04:00
struct in_addr * ret = NULL ;
2002-07-15 14:35:28 +04:00
int j , flags = 0 ;
1999-12-17 09:11:25 +03:00
if ( ! initialised ) {
2001-12-12 19:08:32 +03:00
nss_wins_init ( ) ;
1999-12-17 09:11:25 +03:00
}
* count = 0 ;
2002-07-15 14:35:28 +04:00
/* always try with wins first */
2007-08-28 18:20:53 +04:00
if ( NT_STATUS_IS_OK ( resolve_wins ( name , 0x00 , & address , count ) ) ) {
2004-12-07 21:25:53 +03:00
if ( ( ret = SMB_MALLOC_P ( struct in_addr ) ) = = NULL ) {
2003-06-25 21:41:05 +04:00
free ( address ) ;
return NULL ;
}
2007-10-25 01:16:54 +04:00
if ( address [ 0 ] . ss . ss_family ! = AF_INET ) {
free ( address ) ;
2008-03-06 13:37:01 +03:00
free ( ret ) ;
2007-10-25 01:16:54 +04:00
return NULL ;
}
* ret = ( ( struct sockaddr_in * ) & address [ 0 ] . ss ) - > sin_addr ;
2003-06-25 21:41:05 +04:00
free ( address ) ;
2002-07-15 14:35:28 +04:00
return ret ;
1999-12-17 09:11:25 +03:00
}
2002-07-15 14:35:28 +04:00
fd = wins_lookup_open_socket_in ( ) ;
if ( fd = = - 1 ) {
return NULL ;
1999-12-17 09:11:25 +03:00
}
/* uggh, we have to broadcast to each interface in turn */
2002-07-15 14:35:28 +04:00
for ( j = iface_count ( ) - 1 ; j > = 0 ; j - - ) {
2007-10-11 05:25:16 +04:00
const struct in_addr * bcast = iface_n_bcast_v4 ( j ) ;
2007-10-25 01:16:54 +04:00
struct sockaddr_storage ss ;
struct sockaddr_storage * pss ;
2007-10-11 05:25:16 +04:00
if ( ! bcast ) {
continue ;
}
2007-10-25 01:16:54 +04:00
in_addr_to_sockaddr_storage ( & ss , * bcast ) ;
pss = name_query ( fd , name , 0x00 , True , True , & ss , count , & flags , NULL ) ;
if ( pss ) {
2008-05-06 19:02:31 +04:00
if ( ( ret = SMB_MALLOC_P ( struct in_addr ) ) = = NULL ) {
return NULL ;
}
2007-10-25 01:16:54 +04:00
* ret = ( ( struct sockaddr_in * ) pss ) - > sin_addr ;
break ;
}
1999-12-17 09:11:25 +03:00
}
close ( fd ) ;
return ret ;
}
2001-12-12 19:08:32 +03:00
# ifdef HAVE_NS_API_H
2003-07-23 10:37:51 +04:00
2005-06-25 00:25:18 +04:00
static NODE_STATUS_STRUCT * lookup_byaddr_backend ( char * addr , int * count )
2003-07-23 10:37:51 +04:00
{
int fd ;
2008-02-27 12:06:53 +03:00
struct sockaddr_storage ss ;
2003-07-23 10:37:51 +04:00
struct nmb_name nname ;
2005-06-25 00:25:18 +04:00
NODE_STATUS_STRUCT * status ;
2003-07-23 10:37:51 +04:00
if ( ! initialised ) {
nss_wins_init ( ) ;
}
fd = wins_lookup_open_socket_in ( ) ;
if ( fd = = - 1 )
return NULL ;
make_nmb_name ( & nname , " * " , 0 ) ;
2008-02-27 12:06:53 +03:00
if ( ! interpret_string_addr ( & ss , addr , AI_NUMERICHOST ) ) {
return NULL ;
}
status = node_status_query ( fd , & nname , & ss , count , NULL ) ;
2003-07-23 10:37:51 +04:00
close ( fd ) ;
return status ;
}
2001-12-12 19:08:32 +03:00
/* IRIX version */
int init ( void )
{
2001-12-22 03:51:32 +03:00
nsd_logprintf ( NSD_LOG_MIN , " entering init (wins) \n " ) ;
2001-12-12 19:08:32 +03:00
nss_wins_init ( ) ;
return NSD_OK ;
}
int lookup ( nsd_file_t * rq )
{
char * map ;
char * key ;
2001-12-22 03:51:32 +03:00
char * addr ;
2001-12-12 19:08:32 +03:00
struct in_addr * ip_list ;
2005-06-25 00:25:18 +04:00
NODE_STATUS_STRUCT * status ;
2001-12-22 03:51:32 +03:00
int i , count , len , size ;
char response [ 1024 ] ;
2007-10-19 04:40:25 +04:00
bool found = False ;
2001-12-12 19:08:32 +03:00
2001-12-22 03:51:32 +03:00
nsd_logprintf ( NSD_LOG_MIN , " entering lookup (wins) \n " ) ;
2001-12-12 19:08:32 +03:00
if ( ! rq )
return NSD_ERROR ;
map = nsd_attr_fetch_string ( rq - > f_attrs , " table " , ( char * ) 0 ) ;
if ( ! map ) {
rq - > f_status = NS_FATAL ;
return NSD_ERROR ;
}
key = nsd_attr_fetch_string ( rq - > f_attrs , " key " , ( char * ) 0 ) ;
if ( ! key | | ! * key ) {
rq - > f_status = NS_FATAL ;
return NSD_ERROR ;
}
2001-12-22 03:51:32 +03:00
response [ 0 ] = ' \0 ' ;
len = sizeof ( response ) - 2 ;
/*
* response needs to be a string of the following format
* ip_address [ ip_address ] * \ tname [ alias ] *
*/
2004-01-09 01:53:37 +03:00
if ( StrCaseCmp ( map , " hosts.byaddr " ) = = 0 ) {
2001-12-22 03:51:32 +03:00
if ( status = lookup_byaddr_backend ( key , & count ) ) {
size = strlen ( key ) + 1 ;
if ( size > len ) {
free ( status ) ;
return NSD_ERROR ;
}
len - = size ;
strncat ( response , key , size ) ;
strncat ( response , " \t " , 1 ) ;
for ( i = 0 ; i < count ; i + + ) {
/* ignore group names */
if ( status [ i ] . flags & 0x80 ) continue ;
if ( status [ i ] . type = = 0x20 ) {
size = sizeof ( status [ i ] . name ) + 1 ;
if ( size > len ) {
free ( status ) ;
return NSD_ERROR ;
}
len - = size ;
strncat ( response , status [ i ] . name , size ) ;
strncat ( response , " " , 1 ) ;
found = True ;
}
}
response [ strlen ( response ) - 1 ] = ' \n ' ;
free ( status ) ;
}
2004-01-09 01:53:37 +03:00
} else if ( StrCaseCmp ( map , " hosts.byname " ) = = 0 ) {
2001-12-22 03:51:32 +03:00
if ( ip_list = lookup_byname_backend ( key , & count ) ) {
for ( i = count ; i ; i - - ) {
addr = inet_ntoa ( ip_list [ i - 1 ] ) ;
size = strlen ( addr ) + 1 ;
if ( size > len ) {
free ( ip_list ) ;
return NSD_ERROR ;
}
len - = size ;
if ( i ! = 0 )
response [ strlen ( response ) - 1 ] = ' ' ;
strncat ( response , addr , size ) ;
strncat ( response , " \t " , 1 ) ;
}
size = strlen ( key ) + 1 ;
if ( size > len ) {
free ( ip_list ) ;
return NSD_ERROR ;
}
strncat ( response , key , size ) ;
strncat ( response , " \n " , 1 ) ;
found = True ;
free ( ip_list ) ;
}
2001-12-12 19:08:32 +03:00
}
2001-12-22 03:51:32 +03:00
if ( found ) {
nsd_logprintf ( NSD_LOG_LOW , " lookup (wins %s) %s \n " , map , response ) ;
nsd_set_result ( rq , NS_SUCCESS , response , strlen ( response ) , VOLATILE ) ;
return NSD_OK ;
}
nsd_logprintf ( NSD_LOG_LOW , " lookup (wins) not found \n " ) ;
rq - > f_status = NS_NOTFOUND ;
return NSD_NEXT ;
2001-12-12 19:08:32 +03:00
}
# else
2003-09-08 09:51:57 +04:00
/* Allocate some space from the nss static buffer. The buffer and buflen
are the pointers passed in by the C library to the _nss_ * _ *
functions . */
2003-12-11 18:35:11 +03:00
static char * get_static ( char * * buffer , size_t * buflen , int len )
2003-09-08 09:51:57 +04:00
{
char * result ;
/* Error check. We return false if things aren't set up right, or
there isn ' t enough buffer space left . */
if ( ( buffer = = NULL ) | | ( buflen = = NULL ) | | ( * buflen < len ) ) {
return NULL ;
}
/* Return an index into the static buffer */
result = * buffer ;
* buffer + = len ;
* buflen - = len ;
return result ;
}
2001-12-22 03:51:32 +03:00
/****************************************************************************
gethostbyname ( ) - we ignore any domain portion of the name and only
handle names that are at most 15 characters long
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2001-12-12 19:08:32 +03:00
NSS_STATUS
2003-09-08 09:51:57 +04:00
_nss_wins_gethostbyname_r ( const char * hostname , struct hostent * he ,
char * buffer , size_t buflen , int * h_errnop )
1999-12-17 09:11:25 +03:00
{
2008-11-19 22:22:50 +03:00
NSS_STATUS nss_status = NSS_STATUS_SUCCESS ;
1999-12-17 09:11:25 +03:00
struct in_addr * ip_list ;
int i , count ;
2003-09-08 09:51:57 +04:00
fstring name ;
size_t namelen ;
2001-12-12 19:08:32 +03:00
2008-11-19 22:22:50 +03:00
# if HAVE_PTHREAD
pthread_mutex_lock ( & wins_nss_mutex ) ;
# endif
2001-05-16 02:01:48 +04:00
memset ( he , ' \0 ' , sizeof ( * he ) ) ;
2003-09-08 09:51:57 +04:00
fstrcpy ( name , hostname ) ;
/* Do lookup */
2001-05-16 02:01:48 +04:00
2001-12-22 03:51:32 +03:00
ip_list = lookup_byname_backend ( name , & count ) ;
1999-12-17 09:11:25 +03:00
2008-11-19 22:22:50 +03:00
if ( ! ip_list ) {
nss_status = NSS_STATUS_NOTFOUND ;
goto out ;
}
1999-12-17 09:11:25 +03:00
2003-09-08 09:51:57 +04:00
/* Copy h_name */
1999-12-17 09:11:25 +03:00
2003-09-08 09:51:57 +04:00
namelen = strlen ( name ) + 1 ;
2007-09-08 09:18:08 +04:00
if ( ( he - > h_name = get_static ( & buffer , & buflen , namelen ) ) = = NULL ) {
free ( ip_list ) ;
2008-11-19 22:22:50 +03:00
nss_status = NSS_STATUS_TRYAGAIN ;
goto out ;
2007-09-08 09:18:08 +04:00
}
2003-09-08 09:51:57 +04:00
memcpy ( he - > h_name , name , namelen ) ;
/* Copy h_addr_list, align to pointer boundary first */
1999-12-17 09:11:25 +03:00
2003-09-08 09:51:57 +04:00
if ( ( i = ( unsigned long ) ( buffer ) % sizeof ( char * ) ) ! = 0 )
i = sizeof ( char * ) - i ;
2007-09-08 09:18:08 +04:00
if ( get_static ( & buffer , & buflen , i ) = = NULL ) {
free ( ip_list ) ;
2008-11-19 22:22:50 +03:00
nss_status = NSS_STATUS_TRYAGAIN ;
goto out ;
2007-09-08 09:18:08 +04:00
}
2003-09-08 09:51:57 +04:00
if ( ( he - > h_addr_list = ( char * * ) get_static (
2007-09-08 09:18:08 +04:00
& buffer , & buflen , ( count + 1 ) * sizeof ( char * ) ) ) = = NULL ) {
free ( ip_list ) ;
2008-11-19 22:22:50 +03:00
nss_status = NSS_STATUS_TRYAGAIN ;
goto out ;
2007-09-08 09:18:08 +04:00
}
2003-09-08 09:51:57 +04:00
for ( i = 0 ; i < count ; i + + ) {
if ( ( he - > h_addr_list [ i ] = get_static ( & buffer , & buflen ,
2007-09-08 09:18:08 +04:00
INADDRSZ ) ) = = NULL ) {
free ( ip_list ) ;
2008-11-19 22:22:50 +03:00
nss_status = NSS_STATUS_TRYAGAIN ;
goto out ;
2007-09-08 09:18:08 +04:00
}
2003-09-08 09:51:57 +04:00
memcpy ( he - > h_addr_list [ i ] , & ip_list [ i ] , INADDRSZ ) ;
1999-12-17 09:11:25 +03:00
}
2003-09-08 09:51:57 +04:00
he - > h_addr_list [ count ] = NULL ;
2007-09-08 09:18:08 +04:00
free ( ip_list ) ;
2001-05-16 01:53:19 +04:00
2003-09-08 09:51:57 +04:00
/* Set h_addr_type and h_length */
he - > h_addrtype = AF_INET ;
he - > h_length = INADDRSZ ;
/* Set h_aliases */
if ( ( i = ( unsigned long ) ( buffer ) % sizeof ( char * ) ) ! = 0 )
i = sizeof ( char * ) - i ;
2008-11-19 22:22:50 +03:00
if ( get_static ( & buffer , & buflen , i ) = = NULL ) {
nss_status = NSS_STATUS_TRYAGAIN ;
goto out ;
}
2003-09-08 09:51:57 +04:00
if ( ( he - > h_aliases = ( char * * ) get_static (
2008-11-19 22:22:50 +03:00
& buffer , & buflen , sizeof ( char * ) ) ) = = NULL ) {
nss_status = NSS_STATUS_TRYAGAIN ;
goto out ;
}
2003-09-08 09:51:57 +04:00
he - > h_aliases [ 0 ] = NULL ;
1999-12-17 09:11:25 +03:00
2008-11-19 22:22:50 +03:00
nss_status = NSS_STATUS_SUCCESS ;
out :
# if HAVE_PTHREAD
pthread_mutex_unlock ( & wins_nss_mutex ) ;
# endif
return nss_status ;
1999-12-17 09:11:25 +03:00
}
2001-12-12 19:08:32 +03:00
2002-07-15 14:35:28 +04:00
NSS_STATUS
_nss_wins_gethostbyname2_r ( const char * name , int af , struct hostent * he ,
2003-09-08 09:51:57 +04:00
char * buffer , size_t buflen , int * h_errnop )
2002-07-15 14:35:28 +04:00
{
2008-11-19 22:22:50 +03:00
NSS_STATUS nss_status ;
2002-07-15 14:35:28 +04:00
if ( af ! = AF_INET ) {
* h_errnop = NO_DATA ;
2008-11-19 22:22:50 +03:00
nss_status = NSS_STATUS_UNAVAIL ;
} else {
nss_status = _nss_wins_gethostbyname_r (
name , he , buffer , buflen , h_errnop ) ;
2002-07-15 14:35:28 +04:00
}
2008-11-19 22:22:50 +03:00
return nss_status ;
2002-07-15 14:35:28 +04:00
}
# endif