source: branches/samba-3.2.x/source/nsswitch/wins.c

/* 
   Unix SMB/CIFS implementation.
   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
   the Free Software Foundation; either version 3 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, see <http://www.gnu.org/licenses/>.
   
*/

#include "includes.h"
#ifdef HAVE_NS_API_H
#undef VOLATILE

#include <ns_daemon.h>
#endif

#if HAVE_PTHREAD_H
#include <pthread.h>
#endif

#if HAVE_PTHREAD
static pthread_mutex_t wins_nss_mutex = PTHREAD_MUTEX_INITIALIZER;
#endif

#ifndef INADDRSZ
#define INADDRSZ 4
#endif

static int initialised;

extern bool AllowDebugChange;

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);

/* 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;

        if (setsockopt(res,SOL_SOCKET,SO_REUSEADDR,(char *)&val,sizeof(val)) != 0) {
                close(res);
                return -1;
        }
#ifdef SO_REUSEPORT
        if (setsockopt(res,SOL_SOCKET,SO_REUSEPORT,(char *)&val,sizeof(val)) != 0) {
                close(res);
                return -1;
        }
#endif /* SO_REUSEPORT */

        /* now we've got a socket - we need to bind it */

        if (bind(res, (struct sockaddr * ) &sock,sizeof(sock)) < 0) {
                close(res);
                return(-1);
        }

        set_socket_options(res,"SO_BROADCAST");

        return res;
}


static void nss_wins_init(void)
{
        initialised = 1;
        DEBUGLEVEL = 0;
        AllowDebugChange = False;

        TimeInit();
        setup_logging("nss_wins",False);
        load_case_tables();
        lp_load(get_dyn_CONFIGFILE(),True,False,False,True);
        load_interfaces();
}

static struct in_addr *lookup_byname_backend(const char *name, int *count)
{
        int fd = -1;
        struct ip_service *address = NULL;
        struct in_addr *ret = NULL;
        int j, flags = 0;

        if (!initialised) {
                nss_wins_init();
        }

        *count = 0;

        /* always try with wins first */
        if (NT_STATUS_IS_OK(resolve_wins(name,0x00,&address,count))) {
                if ( (ret = SMB_MALLOC_P(struct in_addr)) == NULL ) {
                        free( address );
                        return NULL;
                }
                if (address[0].ss.ss_family != AF_INET) {
                        free(address);
                        free(ret);
                        return NULL;
                }
                *ret = ((struct sockaddr_in *)&address[0].ss)->sin_addr;
                free( address );
                return ret;
        }

        fd = wins_lookup_open_socket_in();
        if (fd == -1) {
                return NULL;
        }

        /* uggh, we have to broadcast to each interface in turn */
        for (j=iface_count() - 1;j >= 0;j--) {
                const struct in_addr *bcast = iface_n_bcast_v4(j);
                struct sockaddr_storage ss;
                struct sockaddr_storage *pss;
                if (!bcast) {
                        continue;
                }
                in_addr_to_sockaddr_storage(&ss, *bcast);
                pss = name_query(fd,name,0x00,True,True,&ss,count, &flags, NULL);
                if (pss) {
                        if ((ret = SMB_MALLOC_P(struct in_addr)) == NULL) {
                                return NULL;
                        }
                        *ret = ((struct sockaddr_in *)pss)->sin_addr;
                        break;
                }
        }

        close(fd);
        return ret;
}

#ifdef HAVE_NS_API_H

static NODE_STATUS_STRUCT *lookup_byaddr_backend(char *addr, int *count)
{
        int fd;
        struct sockaddr_storage ss;
        struct nmb_name nname;
        NODE_STATUS_STRUCT *status;

        if (!initialised) {
                nss_wins_init();
        }

        fd = wins_lookup_open_socket_in();
        if (fd == -1)
                return NULL;

        make_nmb_name(&nname, "*", 0);
        if (!interpret_string_addr(&ss, addr, AI_NUMERICHOST)) {
                return NULL;
        }
        status = node_status_query(fd, &nname, &ss, count, NULL);

        close(fd);
        return status;
}

/* IRIX version */

int init(void)