Adding upstream version 2:4.20.0+dfsg.upstream/2%4.20.0+dfsg

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 1074 insertions, 0 deletions

diff --git a/source4/nbt_server/wins/winsserver.c b/source4/nbt_server/wins/winsserver.c
new file mode 100644
index 0000000..a9f3ecd
--- /dev/null
+++ b/source4/nbt_server/wins/winsserver.c
@@ -0,0 +1,1074 @@
+/* 
+   Unix SMB/CIFS implementation.
+
+   core wins server handling
+
+   Copyright (C) Andrew Tridgell	2005
+   Copyright (C) Stefan Metzmacher	2005
+      
+   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"
+#include "lib/util/dlinklist.h"
+#include "nbt_server/nbt_server.h"
+#include "nbt_server/wins/winsdb.h"
+#include "nbt_server/wins/winsserver.h"
+#include "librpc/gen_ndr/ndr_nbt.h"
+#include "system/time.h"
+#include "libcli/composite/composite.h"
+#include "samba/service_task.h"
+#include "system/network.h"
+#include "lib/socket/socket.h"
+#include "lib/socket/netif.h"
+#include <ldb.h>
+#include "param/param.h"
+#include "libcli/resolve/resolve.h"
+#include "lib/util/util_net.h"
+
+/*
+  work out the ttl we will use given a client requested ttl
+*/
+uint32_t wins_server_ttl(struct wins_server *winssrv, uint32_t ttl)
+{
+	ttl = MIN(ttl, winssrv->config.max_renew_interval);
+	ttl = MAX(ttl, winssrv->config.min_renew_interval);
+	return ttl;
+}
+
+static enum wrepl_name_type wrepl_type(uint16_t nb_flags, struct nbt_name *name, bool mhomed)
+{
+	/* this copes with the nasty hack that is the type 0x1c name */
+	if (name->type == NBT_NAME_LOGON) {
+		return WREPL_TYPE_SGROUP;
+	}
+	if (nb_flags & NBT_NM_GROUP) {
+		return WREPL_TYPE_GROUP;
+	}
+	if (mhomed) {
+		return WREPL_TYPE_MHOMED;
+	}
+	return WREPL_TYPE_UNIQUE;
+}
+
+/*
+  register a new name with WINS
+*/
+static uint8_t wins_register_new(struct nbt_name_socket *nbtsock, 
+				 struct nbt_name_packet *packet, 
+				 const struct socket_address *src,
+				 enum wrepl_name_type type)
+{
+	struct nbtd_interface *iface = talloc_get_type(nbtsock->incoming.private_data,
+						       struct nbtd_interface);
+	struct wins_server *winssrv = iface->nbtsrv->winssrv;
+	struct nbt_name *name = &packet->questions[0].name;
+	uint32_t ttl = wins_server_ttl(winssrv, packet->additional[0].ttl);
+	uint16_t nb_flags = packet->additional[0].rdata.netbios.addresses[0].nb_flags;
+	const char *address = packet->additional[0].rdata.netbios.addresses[0].ipaddr;
+	struct winsdb_record rec;
+	enum wrepl_name_node node;
+
+#define WREPL_NODE_NBT_FLAGS(nb_flags) \
+	((nb_flags & NBT_NM_OWNER_TYPE)>>13)
+
+	node	= WREPL_NODE_NBT_FLAGS(nb_flags);
+
+	rec.name		= name;
+	rec.type		= type;
+	rec.state		= WREPL_STATE_ACTIVE;
+	rec.node		= node;
+	rec.is_static		= false;
+	rec.expire_time		= time(NULL) + ttl;
+	rec.version		= 0; /* will be allocated later */
+	rec.wins_owner		= NULL; /* will be set later */
+	rec.registered_by	= src->addr;
+	rec.addresses		= winsdb_addr_list_make(packet);
+	if (rec.addresses == NULL) return NBT_RCODE_SVR;
+
+	rec.addresses     = winsdb_addr_list_add(winssrv->wins_db,
+						 &rec, rec.addresses,
+						 address,
+						 winssrv->wins_db->local_owner,
+						 rec.expire_time,
+						 true);
+	if (rec.addresses == NULL) return NBT_RCODE_SVR;
+
+	DEBUG(4,("WINS: accepted registration of %s with address %s\n",
+		 nbt_name_string(packet, name), rec.addresses[0]->address));
+	
+	return winsdb_add(winssrv->wins_db, &rec, WINSDB_FLAG_ALLOC_VERSION | WINSDB_FLAG_TAKE_OWNERSHIP);
+}
+
+
+/*
+  update the ttl on an existing record
+*/
+static uint8_t wins_update_ttl(struct nbt_name_socket *nbtsock, 
+			       struct nbt_name_packet *packet, 
+			       struct winsdb_record *rec,
+			       struct winsdb_addr *winsdb_addr,
+			       const struct socket_address *src)
+{
+	struct nbtd_interface *iface = talloc_get_type(nbtsock->incoming.private_data,
+						       struct nbtd_interface);
+	struct wins_server *winssrv = iface->nbtsrv->winssrv;
+	uint32_t ttl = wins_server_ttl(winssrv, packet->additional[0].ttl);
+	const char *address = packet->additional[0].rdata.netbios.addresses[0].ipaddr;
+	uint32_t modify_flags = 0;
+
+	rec->expire_time   = time(NULL) + ttl;
+	rec->registered_by = src->addr;
+
+	if (winsdb_addr) {
+		rec->addresses = winsdb_addr_list_add(winssrv->wins_db,
+						      rec, rec->addresses,
+						      winsdb_addr->address,
+						      winssrv->wins_db->local_owner,
+						      rec->expire_time,
+						      true);
+		if (rec->addresses == NULL) return NBT_RCODE_SVR;
+	}
+
+	if (strcmp(winssrv->wins_db->local_owner, rec->wins_owner) != 0) {
+		modify_flags = WINSDB_FLAG_ALLOC_VERSION | WINSDB_FLAG_TAKE_OWNERSHIP;
+	}
+
+	DEBUG(5,("WINS: refreshed registration of %s at %s\n",
+		 nbt_name_string(packet, rec->name), address));
+	
+	return winsdb_modify(winssrv->wins_db, rec, modify_flags);
+}
+
+/*
+  do a sgroup merge
+*/
+static uint8_t wins_sgroup_merge(struct nbt_name_socket *nbtsock, 
+				 struct nbt_name_packet *packet, 
+			         struct winsdb_record *rec,
+			         const char *address,
+			         const struct socket_address *src)
+{
+	struct nbtd_interface *iface = talloc_get_type(nbtsock->incoming.private_data,
+						       struct nbtd_interface);
+	struct wins_server *winssrv = iface->nbtsrv->winssrv;
+	uint32_t ttl = wins_server_ttl(winssrv, packet->additional[0].ttl);
+
+	rec->expire_time   = time(NULL) + ttl;
+	rec->registered_by = src->addr;
+
+	rec->addresses     = winsdb_addr_list_add(winssrv->wins_db,
+						  rec, rec->addresses,
+						  address,
+						  winssrv->wins_db->local_owner,
+						  rec->expire_time,
+						  true);
+	if (rec->addresses == NULL) return NBT_RCODE_SVR;
+
+	DEBUG(5,("WINS: sgroup merge of %s at %s\n",
+		 nbt_name_string(packet, rec->name), address));
+	
+	return winsdb_modify(winssrv->wins_db, rec, WINSDB_FLAG_ALLOC_VERSION | WINSDB_FLAG_TAKE_OWNERSHIP);
+}
+
+struct nbtd_wins_wack_state {
+	struct nbtd_wins_wack_state *prev, *next;
+	struct wins_server *winssrv;
+	struct nbt_name_socket *nbtsock;
+	struct nbtd_interface *iface;
+	struct nbt_name_packet *request_packet;
+	struct winsdb_record *rec;
+	struct socket_address *src;
+	const char *reg_address;
+	enum wrepl_name_type new_type;
+	struct wins_challenge_io io;
+	NTSTATUS status;
+};
+
+static int nbtd_wins_wack_state_destructor(struct nbtd_wins_wack_state *s)
+{
+	DLIST_REMOVE(s->iface->wack_queue, s);
+	return 0;
+}
+
+static bool wins_check_wack_queue(struct nbtd_interface *iface,
+				  struct nbt_name_packet *packet,
+				  struct socket_address *src)
+{
+	struct nbtd_wins_wack_state *s;
+
+	for (s= iface->wack_queue; s; s = s->next) {
+		if (packet->name_trn_id != s->request_packet->name_trn_id) {
+			continue;
+		}
+		if (packet->operation != s->request_packet->operation) {
+			continue;
+		}
+		if (src->port != s->src->port) {
+			continue;
+		}
+		if (strcmp(src->addr, s->src->addr) != 0) {
+			continue;
+		}
+
+		return true;
+	}
+
+	return false;
+}
+
+/*
+  deny a registration request
+*/
+static void wins_wack_deny(struct nbtd_wins_wack_state *s)
+{
+	nbtd_name_registration_reply(s->nbtsock, s->request_packet, 
+				     s->src, NBT_RCODE_ACT);
+	DEBUG(4,("WINS: denied name registration request for %s from %s:%d\n",
+		 nbt_name_string(s, s->rec->name), s->src->addr, s->src->port));
+	talloc_free(s);
+}
+
+/*
+  allow a registration request
+*/
+static void wins_wack_allow(struct nbtd_wins_wack_state *s)
+{
+	NTSTATUS status;
+	uint32_t ttl = wins_server_ttl(s->winssrv, s->request_packet->additional[0].ttl);
+	struct winsdb_record *rec = s->rec, *rec2;
+	uint32_t i,j;
+
+	status = winsdb_lookup(s->winssrv->wins_db, rec->name, s, &rec2);
+	if (!NT_STATUS_IS_OK(status) ||
+	    rec2->version != rec->version ||
+	    strcmp(rec2->wins_owner, rec->wins_owner) != 0) {
+		DEBUG(5,("WINS: record %s changed during WACK - failing registration\n",
+			 nbt_name_string(s, rec->name)));
+		wins_wack_deny(s);
+		return;
+	}
+
+	/*
+	 * if the old name owner doesn't hold the name anymore
+	 * handle the request as new registration for the new name owner
+	 */
+	if (!NT_STATUS_IS_OK(s->status)) {
+		uint8_t rcode;
+
+		winsdb_delete(s->winssrv->wins_db, rec);
+		rcode = wins_register_new(s->nbtsock, s->request_packet, s->src, s->new_type);
+		if (rcode != NBT_RCODE_OK) {
+			DEBUG(1,("WINS: record %s failed to register as new during WACK\n",
+				 nbt_name_string(s, rec->name)));
+			wins_wack_deny(s);
+			return;
+		}
+		goto done;
+	}
+
+	rec->expire_time = time(NULL) + ttl;
+	rec->registered_by = s->src->addr;
+
+	/*
+	 * now remove all addresses that the client doesn't hold anymore
+	 * and update the time stamp and owner for the ones that are still there
+	 */
+	for (i=0; rec->addresses[i]; i++) {
+		bool found = false;
+		for (j=0; j < s->io.out.num_addresses; j++) {
+			if (strcmp(rec->addresses[i]->address, s->io.out.addresses[j]) != 0) continue;
+
+			found = true;
+			break;
+		}
+		if (found) {
+			rec->addresses = winsdb_addr_list_add(s->winssrv->wins_db,
+							      rec, rec->addresses,
+							      s->reg_address,
+							      s->winssrv->wins_db->local_owner,
+							      rec->expire_time,
+							      true);
+			if (rec->addresses == NULL) goto failed;
+			continue;
+		}
+
+		winsdb_addr_list_remove(rec->addresses, rec->addresses[i]->address);
+	}
+
+	rec->addresses = winsdb_addr_list_add(s->winssrv->wins_db,
+					      rec, rec->addresses,
+					      s->reg_address,
+					      s->winssrv->wins_db->local_owner,
+					      rec->expire_time,
+					      true);
+	if (rec->addresses == NULL) goto failed;
+
+	/* if we have more than one address, this becomes implicit a MHOMED record */
+	if (winsdb_addr_list_length(rec->addresses) > 1) {
+		rec->type = WREPL_TYPE_MHOMED;
+	}
+
+	winsdb_modify(s->winssrv->wins_db, rec, WINSDB_FLAG_ALLOC_VERSION | WINSDB_FLAG_TAKE_OWNERSHIP);
+
+	DEBUG(4,("WINS: accepted registration of %s with address %s\n",
+		 nbt_name_string(s, rec->name), s->reg_address));
+
+done:
+	nbtd_name_registration_reply(s->nbtsock, s->request_packet, 
+				     s->src, NBT_RCODE_OK);
+failed:
+	talloc_free(s);
+}
+
+/*
+  called when a name query to a current owner completes
+*/
+static void wack_wins_challenge_handler(struct composite_context *c_req)
+{
+	struct nbtd_wins_wack_state *s = talloc_get_type(c_req->async.private_data,
+					 struct nbtd_wins_wack_state);
+	bool found;
+	uint32_t i;
+
+	s->status = wins_challenge_recv(c_req, s, &s->io);
+
+	/*
+	 * if the owner denies it holds the name, then allow
+	 * the registration
+	 */
+	if (!NT_STATUS_IS_OK(s->status)) {
+		wins_wack_allow(s);
+		return;
+	}
+
+	if (s->new_type == WREPL_TYPE_GROUP || s->new_type == WREPL_TYPE_SGROUP) {
+		DEBUG(1,("WINS: record %s failed to register as group type(%u) during WACK, it's still type(%u)\n",
+			 nbt_name_string(s, s->rec->name), s->new_type, s->rec->type));
+		wins_wack_deny(s);
+		return;
+	}
+
+	/*
+	 * if the owner still wants the name and doesn't reply
+	 * with the address trying to be registered, then deny
+	 * the registration
+	 */
+	found = false;
+	for (i=0; i < s->io.out.num_addresses; i++) {
+		if (strcmp(s->reg_address, s->io.out.addresses[i]) != 0) continue;
+
+		found = true;
+		break;
+	}
+	if (!found) {
+		wins_wack_deny(s);
+		return;
+	}
+
+	wins_wack_allow(s);
+	return;
+}
+
+
+/*
+  a client has asked to register a unique name that someone else owns. We
+  need to ask each of the current owners if they still want it. If they do
+  then reject the registration, otherwise allow it
+*/
+static void wins_register_wack(struct nbt_name_socket *nbtsock, 
+			       struct nbt_name_packet *packet, 
+			       struct winsdb_record *rec,
+			       struct socket_address *src,
+			       enum wrepl_name_type new_type)
+{
+	struct nbtd_interface *iface = talloc_get_type(nbtsock->incoming.private_data,
+						       struct nbtd_interface);
+	struct wins_server *winssrv = iface->nbtsrv->winssrv;
+	struct nbtd_wins_wack_state *s;
+	struct composite_context *c_req;
+	uint32_t ttl;
+
+	s = talloc_zero(nbtsock, struct nbtd_wins_wack_state);
+	if (s == NULL) goto failed;
+
+	/* package up the state variables for this wack request */
+	s->winssrv		= winssrv;
+	s->nbtsock		= nbtsock;
+	s->iface		= iface;
+	s->request_packet	= talloc_steal(s, packet);
+	s->rec			= talloc_steal(s, rec);
+	s->reg_address		= packet->additional[0].rdata.netbios.addresses[0].ipaddr;
+	s->new_type		= new_type;
+	s->src		        = socket_address_copy(s, src);
+	if (s->src == NULL) goto failed;
+
+	s->io.in.nbtd_server	= iface->nbtsrv;
+	s->io.in.nbt_port       = lpcfg_nbt_port(iface->nbtsrv->task->lp_ctx);
+	s->io.in.event_ctx	= iface->nbtsrv->task->event_ctx;
+	s->io.in.name		= rec->name;
+	s->io.in.num_addresses	= winsdb_addr_list_length(rec->addresses);
+	s->io.in.addresses	= winsdb_addr_string_list(s, rec->addresses);
+	if (s->io.in.addresses == NULL) goto failed;
+
+	DLIST_ADD_END(iface->wack_queue, s);
+
+	talloc_set_destructor(s, nbtd_wins_wack_state_destructor);
+
+	/*
+	 * send a WACK to the client, specifying the maximum time it could
+         * take to check with the owner, plus some slack
+	 */
+	ttl = 5 + 4 * winsdb_addr_list_length(rec->addresses);
+	nbtd_wack_reply(nbtsock, packet, src, ttl);
+
+	/*
+	 * send the challenge to the old addresses
+	 */
+	c_req = wins_challenge_send(s, &s->io);
+	if (c_req == NULL) goto failed;
+
+	c_req->async.fn			= wack_wins_challenge_handler;
+	c_req->async.private_data	= s;
+	return;
+
+failed:
+	talloc_free(s);
+	nbtd_name_registration_reply(nbtsock, packet, src, NBT_RCODE_SVR);
+}
+
+/*
+  register a name
+*/
+static void nbtd_winsserver_register(struct nbt_name_socket *nbtsock, 
+				     struct nbt_name_packet *packet, 
+				     struct socket_address *src)
+{
+	NTSTATUS status;
+	struct nbtd_interface *iface = talloc_get_type(nbtsock->incoming.private_data,
+						       struct nbtd_interface);
+	struct wins_server *winssrv = iface->nbtsrv->winssrv;
+	struct nbt_name *name = &packet->questions[0].name;
+	struct winsdb_record *rec;
+	uint8_t rcode = NBT_RCODE_OK;
+	uint16_t nb_flags = packet->additional[0].rdata.netbios.addresses[0].nb_flags;
+	const char *address = packet->additional[0].rdata.netbios.addresses[0].ipaddr;
+	bool mhomed = ((packet->operation & NBT_OPCODE) == NBT_OPCODE_MULTI_HOME_REG);
+	enum wrepl_name_type new_type = wrepl_type(nb_flags, name, mhomed);
+	struct winsdb_addr *winsdb_addr = NULL;
+	bool duplicate_packet;
+
+	/*
+	 * as a special case, the local master browser name is always accepted
+	 * for registration, but never stored, but w2k3 stores it if it's registered
+	 * as a group name, (but a query for the 0x1D name still returns not found!)
+	 */
+	if (name->type == NBT_NAME_MASTER && !(nb_flags & NBT_NM_GROUP)) {
+		rcode = NBT_RCODE_OK;
+		goto done;
+	}
+
+	/* w2k3 refuses 0x1B names with marked as group */
+	if (name->type == NBT_NAME_PDC && (nb_flags & NBT_NM_GROUP)) {
+		rcode = NBT_RCODE_RFS;
+		goto done;
+	}
+
+	/* w2k3 refuses 0x1C names with out marked as group */
+	if (name->type == NBT_NAME_LOGON && !(nb_flags & NBT_NM_GROUP)) {
+		rcode = NBT_RCODE_RFS;
+		goto done;
+	}
+
+	/* w2k3 refuses 0x1E names with out marked as group */
+	if (name->type == NBT_NAME_BROWSER && !(nb_flags & NBT_NM_GROUP)) {
+		rcode = NBT_RCODE_RFS;
+		goto done;
+	}
+
+	if (name->scope && strlen(name->scope) > 237) {
+		rcode = NBT_RCODE_SVR;
+		goto done;
+	}
+
+	duplicate_packet = wins_check_wack_queue(iface, packet, src);
+	if (duplicate_packet) {
+		/* just ignore the packet */
+		DEBUG(5,("Ignoring duplicate packet while WACK is pending from %s:%d\n",
+			 src->addr, src->port));
+		return;
+	}
+
+	status = winsdb_lookup(winssrv->wins_db, name, packet, &rec);
+	if (NT_STATUS_EQUAL(NT_STATUS_OBJECT_NAME_NOT_FOUND, status)) {
+		rcode = wins_register_new(nbtsock, packet, src, new_type);
+		goto done;
+	} else if (!NT_STATUS_IS_OK(status)) {
+		rcode = NBT_RCODE_SVR;
+		goto done;
+	} else if (rec->is_static) {
+		if (rec->type == WREPL_TYPE_GROUP || rec->type == WREPL_TYPE_SGROUP) {
+			rcode = NBT_RCODE_OK;
+			goto done;
+		}
+		rcode = NBT_RCODE_ACT;
+		goto done;
+	}
+
+	if (rec->type == WREPL_TYPE_GROUP) {
+		if (new_type != WREPL_TYPE_GROUP) {
+			DEBUG(2,("WINS: Attempt to register name %s as non normal group(%u)"
+				 " while a normal group is already there\n",
+				 nbt_name_string(packet, name), new_type));
+			rcode = NBT_RCODE_ACT;
+			goto done;
+		}
+
+		if (rec->state == WREPL_STATE_ACTIVE) {
+			/* TODO: is this correct? */
+			rcode = wins_update_ttl(nbtsock, packet, rec, NULL, src);
+			goto done;
+		}
+
+		/* TODO: is this correct? */
+		winsdb_delete(winssrv->wins_db, rec);
+		rcode = wins_register_new(nbtsock, packet, src, new_type);
+		goto done;
+	}
+
+	if (rec->state != WREPL_STATE_ACTIVE) {
+		winsdb_delete(winssrv->wins_db, rec);
+		rcode = wins_register_new(nbtsock, packet, src, new_type);
+		goto done;
+	}
+
+	switch (rec->type) {
+	case WREPL_TYPE_UNIQUE:
+	case WREPL_TYPE_MHOMED:
+		/* 
+		 * if its an active unique name, and the registration is for a group, then
+		 * see if the unique name owner still wants the name
+		 * TODO: is this correct?
+		 */
+		if (new_type == WREPL_TYPE_GROUP || new_type == WREPL_TYPE_GROUP) {
+			wins_register_wack(nbtsock, packet, rec, src, new_type);
+			return;
+		}
+
+		/* 
+		 * if the registration is for an address that is currently active, then 
+		 * just update the expiry time of the record and the address
+		 */
+		winsdb_addr = winsdb_addr_list_check(rec->addresses, address);
+		if (winsdb_addr) {
+			rcode = wins_update_ttl(nbtsock, packet, rec, winsdb_addr, src);
+			goto done;
+		}
+
+		/*
+		 * we have to do a WACK to see if the current owner is willing
+		 * to give up its claim
+		 */
+		wins_register_wack(nbtsock, packet, rec, src, new_type);
+		return;
+
+	case WREPL_TYPE_GROUP:
+		/* this should not be reached as normal groups are handled above */
+		DEBUG(0,("BUG at %s\n",__location__));
+		rcode = NBT_RCODE_ACT;
+		goto done;
+
+	case WREPL_TYPE_SGROUP:
+		/* if the new record isn't also a special group, refuse the registration */ 
+		if (new_type != WREPL_TYPE_SGROUP) {
+			DEBUG(2,("WINS: Attempt to register name %s as non special group(%u)"
+				 " while a special group is already there\n",
+				 nbt_name_string(packet, name), new_type));
+			rcode = NBT_RCODE_ACT;
+			goto done;
+		}
+
+		/* 
+		 * if the registration is for an address that is currently active, then 
+		 * just update the expiry time of the record and the address
+		 */
+		winsdb_addr = winsdb_addr_list_check(rec->addresses, address);
+		if (winsdb_addr) {
+			rcode = wins_update_ttl(nbtsock, packet, rec, winsdb_addr, src);
+			goto done;
+		}
+
+		rcode = wins_sgroup_merge(nbtsock, packet, rec, address, src);
+		goto done;
+	}
+
+done:
+	nbtd_name_registration_reply(nbtsock, packet, src, rcode);
+}
+
+static uint32_t ipv4_match_bits(struct in_addr ip1, struct in_addr ip2)
+{
+	uint32_t i, j, match=0;
+	uint8_t *p1, *p2;
+
+	p1 = (uint8_t *)&ip1.s_addr;
+	p2 = (uint8_t *)&ip2.s_addr;
+
+	for (i=0; i<4; i++) {
+		if (p1[i] != p2[i]) break;
+		match += 8;
+	}
+
+	if (i==4) return match;
+
+	for (j=0; j<8; j++) {
+		if ((p1[i] & (1<<(7-j))) != (p2[i] & (1<<(7-j))))
+			break;
+		match++;
+	}
+
+	return match;
+}
+
+static int nbtd_wins_randomize1Clist_sort(void *p1,/* (const char **) */
+					  void *p2,/* (const char **) */
+					  struct socket_address *src)
+{
+	const char *a1 = (const char *)*(const char **)p1;
+	const char *a2 = (const char *)*(const char **)p2;
+	uint32_t match_bits1;
+	uint32_t match_bits2;
+
+	match_bits1 = ipv4_match_bits(interpret_addr2(a1), interpret_addr2(src->addr));
+	match_bits2 = ipv4_match_bits(interpret_addr2(a2), interpret_addr2(src->addr));
+
+	return match_bits2 - match_bits1;
+}
+
+static void nbtd_wins_randomize1Clist(struct loadparm_context *lp_ctx,
+				      const char **addresses, struct socket_address *src)
+{
+	const char *mask;
+	const char *tmp;
+	uint32_t num_addrs;
+	uint32_t idx, sidx;
+	int r;
+
+	for (num_addrs=0; addresses[num_addrs]; num_addrs++) { /* noop */ }
+
+	if (num_addrs <= 1) return; /* nothing to do */
+
+	/* first sort the addresses depending on the matching to the client */
+	LDB_TYPESAFE_QSORT(addresses, num_addrs, src, nbtd_wins_randomize1Clist_sort);
+
+	mask = lpcfg_parm_string(lp_ctx, NULL, "nbtd", "wins_randomize1Clist_mask");
+	if (!mask) {
+		mask = "255.255.255.0";
+	}
+
+	/* 
+	 * choose a random address to be the first in the response to the client,
+	 * prefer the addresses inside the nbtd:wins_randomize1Clist_mask netmask
+	 */
+	r = random();
+	idx = sidx = r % num_addrs;
+
+	while (1) {
+		bool same;
+
+		/* if the current one is in the same subnet, use it */
+		same = iface_list_same_net(addresses[idx], src->addr, mask);
+		if (same) {
+			sidx = idx;
+			break;
+		}
+
+		/* we need to check for idx == 0, after checking for the same net */
+		if (idx == 0) break;
+		/* 
+		 * if we haven't found an address in the same subnet, search in ones
+		 * which match the client more
+		 *
+		 * some notes:
+		 *
+		 * it's not "idx = idx % r" but "idx = r % idx"
+		 * because in "a % b" b is the allowed range
+		 * and b-1 is the maximum possible result, so it must be decreasing
+		 * and the above idx == 0 check breaks the while(1) loop.
+		 */
+		idx = r % idx;
+	}
+
+	/* note sidx == 0 is also valid here ... */
+	tmp		= addresses[0];
+	addresses[0]	= addresses[sidx];
+	addresses[sidx]	= tmp;
+}
+
+/*
+  query a name
+*/
+static void nbtd_winsserver_query(struct loadparm_context *lp_ctx,
+				  struct nbt_name_socket *nbtsock, 
+				  struct nbt_name_packet *packet, 
+				  struct socket_address *src)
+{
+	NTSTATUS status;
+	struct nbtd_interface *iface = talloc_get_type(nbtsock->incoming.private_data,
+						       struct nbtd_interface);
+	struct wins_server *winssrv = iface->nbtsrv->winssrv;
+	struct nbt_name *name = &packet->questions[0].name;
+	struct winsdb_record *rec;
+	struct winsdb_record *rec_1b = NULL;
+	const char **addresses;
+	const char **addresses_1b = NULL;
+	uint16_t nb_flags = 0;
+
+	if (name->type == NBT_NAME_MASTER) {
+		goto notfound;
+	}
+
+	/*
+	 * w2k3 returns the first address of the 0x1B record as first address
+	 * to a 0x1C query
+	 *
+	 * since Windows 2000 Service Pack 2 there's on option to trigger this behavior:
+	 *
+	 * HKEY_LOCAL_MACHINE\System\CurrentControlset\Services\WINS\Parameters\Prepend1BTo1CQueries
+	 * Typ: Daten REG_DWORD
+	 * Value: 0 = deactivated, 1 = activated
+	 */
+	if (name->type == NBT_NAME_LOGON && 
+	    lpcfg_parm_bool(lp_ctx, NULL, "nbtd", "wins_prepend1Bto1Cqueries", true)) {
+		struct nbt_name name_1b;
+
+		name_1b = *name;
+		name_1b.type = NBT_NAME_PDC;
+
+		status = winsdb_lookup(winssrv->wins_db, &name_1b, packet, &rec_1b);
+		if (NT_STATUS_IS_OK(status)) {
+			addresses_1b = winsdb_addr_string_list(packet, rec_1b->addresses);
+		}
+	}
+
+	status = winsdb_lookup(winssrv->wins_db, name, packet, &rec);
+	if (!NT_STATUS_IS_OK(status)) {
+		if (!lpcfg_wins_dns_proxy(lp_ctx)) {
+			goto notfound;
+		}
+
+		if (name->type != NBT_NAME_CLIENT && name->type != NBT_NAME_SERVER) {
+			goto notfound;
+		}
+
+		nbtd_wins_dns_proxy_query(nbtsock, packet, src);
+		return;
+	}
+
+	/*
+	 * for group's we always reply with
+	 * 255.255.255.255 as address, even if
+	 * the record is released or tombstoned
+	 */
+	if (rec->type == WREPL_TYPE_GROUP) {
+		addresses = str_list_add(NULL, "255.255.255.255");
+		talloc_steal(packet, addresses);
+		if (!addresses) {
+			goto notfound;
+		}
+		nb_flags |= NBT_NM_GROUP;
+		goto found;
+	}
+
+	if (rec->state != WREPL_STATE_ACTIVE) {
+		goto notfound;
+	}
+
+	addresses = winsdb_addr_string_list(packet, rec->addresses);
+	if (!addresses) {
+		goto notfound;
+	}
+
+	/* 
+	 * if addresses_1b isn't NULL, we have a 0x1C query and need to return the
+	 * first 0x1B address as first address
+	 */
+	if (addresses_1b && addresses_1b[0]) {
+		const char **addresses_1c = addresses;
+		uint32_t i;
+		uint32_t num_addrs;
+
+		addresses = str_list_add(NULL, addresses_1b[0]);
+		if (!addresses) {
+			goto notfound;
+		}
+		talloc_steal(packet, addresses);
+		num_addrs = 1;
+
+		for (i=0; addresses_1c[i]; i++) {
+			if (strcmp(addresses_1b[0], addresses_1c[i]) == 0) continue;
+
+			/*
+			 * stop when we already have 25 addresses
+			 */
+			if (num_addrs >= 25) break;
+
+			num_addrs++;			
+			addresses = str_list_add(addresses, addresses_1c[i]);
+			if (!addresses) {
+				goto notfound;
+			}
+		}
+	}
+
+	if (rec->type == WREPL_TYPE_SGROUP) {
+		nb_flags |= NBT_NM_GROUP;
+	} else {
+		nb_flags |= (rec->node <<13);
+	}
+
+	/*
+	 * since Windows 2000 Service Pack 2 there's on option to trigger this behavior:
+	 *
+	 * HKEY_LOCAL_MACHINE\System\CurrentControlset\Services\WINS\Parameters\Randomize1CList
+	 * Typ: Daten REG_DWORD
+	 * Value: 0 = deactivated, 1 = activated
+	 */
+	if (name->type == NBT_NAME_LOGON && 
+	    lpcfg_parm_bool(lp_ctx, NULL, "nbtd", "wins_randomize1Clist", false)) {
+		nbtd_wins_randomize1Clist(lp_ctx, addresses, src);
+	}
+
+found:
+	nbtd_name_query_reply(nbtsock, packet, src, name, 
+			      0, nb_flags, addresses);
+	return;
+
+notfound:
+	nbtd_negative_name_query_reply(nbtsock, packet, src);
+}
+
+/*
+  release a name
+*/
+static void nbtd_winsserver_release(struct nbt_name_socket *nbtsock, 
+				    struct nbt_name_packet *packet, 
+				    struct socket_address *src)
+{
+	NTSTATUS status;
+	struct nbtd_interface *iface = talloc_get_type(nbtsock->incoming.private_data,
+						       struct nbtd_interface);
+	struct wins_server *winssrv = iface->nbtsrv->winssrv;
+	struct nbt_name *name = &packet->questions[0].name;
+	struct winsdb_record *rec;
+	uint32_t modify_flags = 0;
+	uint8_t ret;
+
+	if (name->type == NBT_NAME_MASTER) {
+		goto done;
+	}
+
+	if (name->scope && strlen(name->scope) > 237) {
+		goto done;
+	}
+
+	status = winsdb_lookup(winssrv->wins_db, name, packet, &rec);
+	if (!NT_STATUS_IS_OK(status)) {
+		goto done;
+	}
+
+	if (rec->is_static) {
+		if (rec->type == WREPL_TYPE_UNIQUE || rec->type == WREPL_TYPE_MHOMED) {
+			goto done;
+		}
+		nbtd_name_release_reply(nbtsock, packet, src, NBT_RCODE_ACT);
+		return;
+	}
+
+	if (rec->state != WREPL_STATE_ACTIVE) {
+		goto done;
+	}
+
+	/* 
+	 * TODO: do we need to check if
+	 *       src->addr matches packet->additional[0].rdata.netbios.addresses[0].ipaddr
+	 *       here?
+	 */
+
+	/* 
+	 * we only allow releases from an owner - other releases are
+	 * silently ignored
+	 */
+	if (!winsdb_addr_list_check(rec->addresses, src->addr)) {
+		int i;
+		DEBUG(4,("WINS: silently ignoring attempted name release on %s from %s\n", nbt_name_string(rec, rec->name), src->addr));
+		DEBUGADD(4, ("Registered Addresses: \n"));
+		for (i=0; rec->addresses && rec->addresses[i]; i++) {
+			DEBUGADD(4, ("%s\n", rec->addresses[i]->address));
+		}
+		goto done;
+	}
+
+	DEBUG(4,("WINS: released name %s from %s\n", nbt_name_string(rec, rec->name), src->addr));
+
+	switch (rec->type) {
+	case WREPL_TYPE_UNIQUE:
+		rec->state = WREPL_STATE_RELEASED;
+		break;
+
+	case WREPL_TYPE_GROUP:
+		rec->state = WREPL_STATE_RELEASED;
+		break;
+
+	case WREPL_TYPE_SGROUP:
+		winsdb_addr_list_remove(rec->addresses, src->addr);
+		/* TODO: do we need to take the ownership here? */
+		if (winsdb_addr_list_length(rec->addresses) == 0) {
+			rec->state = WREPL_STATE_RELEASED;
+		}
+		break;
+
+	case WREPL_TYPE_MHOMED:
+		winsdb_addr_list_remove(rec->addresses, src->addr);
+		/* TODO: do we need to take the ownership here? */
+		if (winsdb_addr_list_length(rec->addresses) == 0) {
+			rec->state = WREPL_STATE_RELEASED;
+		}
+		break;
+	}
+
+	if (rec->state == WREPL_STATE_ACTIVE) {
+		/*
+		 * If the record is still active, we need to update the
+		 * expire_time.
+		 *
+		 * if we're not the owner, we need to take the ownership.
+		 */
+		rec->expire_time= time(NULL) + winssrv->config.max_renew_interval;
+		if (strcmp(rec->wins_owner, winssrv->wins_db->local_owner) != 0) {
+			modify_flags = WINSDB_FLAG_ALLOC_VERSION | WINSDB_FLAG_TAKE_OWNERSHIP;
+		}
+		if (lpcfg_parm_bool(iface->nbtsrv->task->lp_ctx, NULL, "wreplsrv", "propagate name releases", false)) {
+			/*
+			 * We have an option to propagate every name release,
+			 * this is off by default to match windows servers
+			 */
+			modify_flags = WINSDB_FLAG_ALLOC_VERSION | WINSDB_FLAG_TAKE_OWNERSHIP;
+		}
+	} else if (rec->state == WREPL_STATE_RELEASED) {
+		/*
+		 * if we're not the owner, we need to take the owner ship
+		 * and make the record tombstone, but expire after
+		 * tombstone_interval + tombstone_timeout and not only after tombstone_timeout
+		 * like for normal tombstone records.
+		 * This is to replicate the record directly to the original owner,
+		 * where the record is still active
+		 */ 
+		if (strcmp(rec->wins_owner, winssrv->wins_db->local_owner) == 0) {
+			rec->expire_time= time(NULL) + winssrv->config.tombstone_interval;
+		} else {
+			rec->state	= WREPL_STATE_TOMBSTONE;
+			rec->expire_time= time(NULL) + 
+					  winssrv->config.tombstone_interval +
+					  winssrv->config.tombstone_timeout;
+			modify_flags	= WINSDB_FLAG_ALLOC_VERSION | WINSDB_FLAG_TAKE_OWNERSHIP;
+		}
+	}
+
+	ret = winsdb_modify(winssrv->wins_db, rec, modify_flags);
+	if (ret != NBT_RCODE_OK) {
+		DEBUG(1,("WINS: FAILED: released name %s at %s: error:%u\n",
+			nbt_name_string(rec, rec->name), src->addr, ret));
+	}
+done:
+	/* we match w2k3 by always giving a positive reply to name releases. */
+	nbtd_name_release_reply(nbtsock, packet, src, NBT_RCODE_OK);
+}
+
+
+/*
+  answer a name query
+*/
+void nbtd_winsserver_request(struct nbt_name_socket *nbtsock, 
+			     struct nbt_name_packet *packet, 
+			     struct socket_address *src)
+{
+	struct nbtd_interface *iface = talloc_get_type(nbtsock->incoming.private_data,
+						       struct nbtd_interface);
+	struct wins_server *winssrv = iface->nbtsrv->winssrv;
+	if ((packet->operation & NBT_FLAG_BROADCAST) || winssrv == NULL) {
+		return;
+	}
+
+	switch (packet->operation & NBT_OPCODE) {
+	case NBT_OPCODE_QUERY:
+		nbtd_winsserver_query(iface->nbtsrv->task->lp_ctx, nbtsock, packet, src);
+		break;
+
+	case NBT_OPCODE_REGISTER:
+	case NBT_OPCODE_REFRESH:
+	case NBT_OPCODE_REFRESH2:
+	case NBT_OPCODE_MULTI_HOME_REG:
+		nbtd_winsserver_register(nbtsock, packet, src);
+		break;
+
+	case NBT_OPCODE_RELEASE:
+		nbtd_winsserver_release(nbtsock, packet, src);
+		break;
+	}
+
+}
+
+/*
+  startup the WINS server, if configured
+*/
+NTSTATUS nbtd_winsserver_init(struct nbtd_server *nbtsrv)
+{
+	uint32_t tmp;
+	const char *owner;
+
+	if (!lpcfg_we_are_a_wins_server(nbtsrv->task->lp_ctx)) {
+		nbtsrv->winssrv = NULL;
+		return NT_STATUS_OK;
+	}
+
+	nbtsrv->winssrv = talloc_zero(nbtsrv, struct wins_server);
+	NT_STATUS_HAVE_NO_MEMORY(nbtsrv->winssrv);
+
+	nbtsrv->winssrv->config.max_renew_interval = lpcfg_max_wins_ttl(nbtsrv->task->lp_ctx);
+	nbtsrv->winssrv->config.min_renew_interval = lpcfg_min_wins_ttl(nbtsrv->task->lp_ctx);
+	tmp = lpcfg_parm_int(nbtsrv->task->lp_ctx, NULL, "wreplsrv", "tombstone_interval", 6*24*60*60);
+	nbtsrv->winssrv->config.tombstone_interval = tmp;
+	tmp = lpcfg_parm_int(nbtsrv->task->lp_ctx, NULL, "wreplsrv"," tombstone_timeout", 1*24*60*60);
+	nbtsrv->winssrv->config.tombstone_timeout = tmp;
+
+	owner = lpcfg_parm_string(nbtsrv->task->lp_ctx, NULL, "winsdb", "local_owner");
+
+	if (owner == NULL) {
+		struct interface *ifaces;
+		load_interface_list(nbtsrv->task, nbtsrv->task->lp_ctx, &ifaces);
+		owner = iface_list_first_v4(ifaces);
+	}
+
+	nbtsrv->winssrv->wins_db     = winsdb_connect(nbtsrv->winssrv, nbtsrv->task->event_ctx, 
+						      nbtsrv->task->lp_ctx,
+						      owner, WINSDB_HANDLE_CALLER_NBTD);
+	if (!nbtsrv->winssrv->wins_db) {
+		return NT_STATUS_INTERNAL_DB_ERROR;
+	}
+
+	irpc_add_name(nbtsrv->task->msg_ctx, "wins_server");
+
+	return NT_STATUS_OK;
+}