diff options
Diffstat (limited to 'source4/nbt_server/wins/winsserver.c')
| -rw-r--r-- | source4/nbt_server/wins/winsserver.c | 1074 |
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; +} |