diff options
Diffstat (limited to 'source4/nbt_server/wins/winsdb.c')
| -rw-r--r-- | source4/nbt_server/wins/winsdb.c | 1027 |
1 files changed, 1027 insertions, 0 deletions
diff --git a/source4/nbt_server/wins/winsdb.c b/source4/nbt_server/wins/winsdb.c new file mode 100644 index 0000000..2a05e96 --- /dev/null +++ b/source4/nbt_server/wins/winsdb.c @@ -0,0 +1,1027 @@ +/* + Unix SMB/CIFS implementation. + + WINS database routines + + 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 "nbt_server/nbt_server.h" +#include "nbt_server/wins/winsdb.h" +#include <ldb.h> +#include <ldb_errors.h> +#include "librpc/gen_ndr/ndr_nbt.h" +#include "system/time.h" +#include "ldb_wrap.h" +#include "system/network.h" +#include "lib/socket/netif.h" +#include "param/param.h" +#include "lib/util/smb_strtox.h" + +#undef strcasecmp + +uint64_t winsdb_get_maxVersion(struct winsdb_handle *h) +{ + int ret; + struct ldb_context *ldb = h->ldb; + struct ldb_dn *dn; + struct ldb_result *res = NULL; + TALLOC_CTX *tmp_ctx = talloc_new(ldb); + uint64_t maxVersion = 0; + + dn = ldb_dn_new(tmp_ctx, ldb, "CN=VERSION"); + if (!dn) goto failed; + + /* find the record in the WINS database */ + ret = ldb_search(ldb, tmp_ctx, &res, dn, LDB_SCOPE_BASE, NULL, NULL); + if (ret != LDB_SUCCESS) goto failed; + if (res->count > 1) goto failed; + + if (res->count == 1) { + maxVersion = ldb_msg_find_attr_as_uint64(res->msgs[0], "maxVersion", 0); + } + +failed: + talloc_free(tmp_ctx); + return maxVersion; +} + +/* + if newVersion == 0 return the old maxVersion + 1 and save it + if newVersion > 0 return MAX(oldMaxVersion, newMaxVersion) and save it +*/ +uint64_t winsdb_set_maxVersion(struct winsdb_handle *h, uint64_t newMaxVersion) +{ + int trans; + int ret; + struct ldb_dn *dn; + struct ldb_result *res = NULL; + struct ldb_message *msg = NULL; + struct ldb_context *wins_db = h->ldb; + TALLOC_CTX *tmp_ctx = talloc_new(wins_db); + uint64_t oldMaxVersion = 0; + + trans = ldb_transaction_start(wins_db); + if (trans != LDB_SUCCESS) goto failed; + + dn = ldb_dn_new(tmp_ctx, wins_db, "CN=VERSION"); + if (!dn) goto failed; + + /* find the record in the WINS database */ + ret = ldb_search(wins_db, tmp_ctx, &res, dn, LDB_SCOPE_BASE, NULL, NULL); + if (ret != LDB_SUCCESS) goto failed; + if (res->count > 1) goto failed; + + if (res->count == 1) { + oldMaxVersion = ldb_msg_find_attr_as_uint64(res->msgs[0], "maxVersion", 0); + } + + if (newMaxVersion == 0) { + newMaxVersion = oldMaxVersion + 1; + } else { + newMaxVersion = MAX(oldMaxVersion, newMaxVersion); + } + + msg = ldb_msg_new(tmp_ctx); + if (!msg) goto failed; + msg->dn = dn; + + + ret = ldb_msg_append_string(msg, "objectClass", "winsMaxVersion", + LDB_FLAG_MOD_REPLACE); + if (ret != LDB_SUCCESS) goto failed; + ret = ldb_msg_append_fmt(msg, LDB_FLAG_MOD_REPLACE, + "maxVersion", "%llu", (long long)newMaxVersion); + if (ret != LDB_SUCCESS) goto failed; + + ret = ldb_modify(wins_db, msg); + if (ret != LDB_SUCCESS) ret = ldb_add(wins_db, msg); + if (ret != LDB_SUCCESS) goto failed; + + trans = ldb_transaction_commit(wins_db); + if (trans != LDB_SUCCESS) goto failed; + + talloc_free(tmp_ctx); + return newMaxVersion; + +failed: + if (trans == LDB_SUCCESS) ldb_transaction_cancel(wins_db); + talloc_free(tmp_ctx); + return 0; +} + +/* + return a DN for a nbt_name +*/ +static struct ldb_dn *winsdb_dn(TALLOC_CTX *mem_ctx, struct ldb_context *ldb, + const struct nbt_name *name) +{ + struct ldb_dn *dn; + + dn = ldb_dn_new_fmt(mem_ctx, ldb, "type=0x%02X", name->type); + if (ldb_dn_is_valid(dn) && name->name && *name->name) { + ldb_dn_add_child_fmt(dn, "name=%s", name->name); + } + if (ldb_dn_is_valid(dn) && name->scope && *name->scope) { + ldb_dn_add_child_fmt(dn, "scope=%s", name->scope); + } + return dn; +} + +static NTSTATUS winsdb_nbt_name(TALLOC_CTX *mem_ctx, struct ldb_dn *dn, struct nbt_name **_name) +{ + NTSTATUS status; + struct nbt_name *name; + unsigned int comp_num; + uint32_t cur = 0; + int error = 0; + + name = talloc(mem_ctx, struct nbt_name); + if (!name) { + status = NT_STATUS_NO_MEMORY; + goto failed; + } + + comp_num = ldb_dn_get_comp_num(dn); + + if (comp_num > 3) { + status = NT_STATUS_INTERNAL_DB_CORRUPTION; + goto failed; + } + + if (comp_num > cur && strcasecmp("scope", ldb_dn_get_component_name(dn, cur)) == 0) { + name->scope = (const char *)talloc_strdup(name, (char *)ldb_dn_get_component_val(dn, cur)->data); + cur++; + } else { + name->scope = NULL; + } + + if (comp_num > cur && strcasecmp("name", ldb_dn_get_component_name(dn, cur)) == 0) { + name->name = (const char *)talloc_strdup(name, (char *)ldb_dn_get_component_val(dn, cur)->data); + cur++; + } else { + name->name = talloc_strdup(name, ""); + if (!name->name) { + status = NT_STATUS_NO_MEMORY; + goto failed; + } + } + + if (comp_num > cur && strcasecmp("type", ldb_dn_get_component_name(dn, cur)) == 0) { + name->type = + smb_strtoul( + (char *)ldb_dn_get_component_val(dn, cur)->data, + NULL, + 0, + &error, + SMB_STR_STANDARD); + if (error != 0) { + status = NT_STATUS_INTERNAL_DB_CORRUPTION; + goto failed; + } + cur++; + } else { + status = NT_STATUS_INTERNAL_DB_CORRUPTION; + goto failed; + } + + *_name = name; + return NT_STATUS_OK; +failed: + talloc_free(name); + return status; +} + +/* + decode the winsdb_addr("address") attribute: + "172.31.1.1" or + "172.31.1.1;winsOwner:172.31.9.202;expireTime:20050923032330.0Z;" + are valid records +*/ +static NTSTATUS winsdb_addr_decode(struct winsdb_handle *h, struct winsdb_record *rec, struct ldb_val *val, + TALLOC_CTX *mem_ctx, struct winsdb_addr **_addr) +{ + NTSTATUS status; + struct winsdb_addr *addr; + const char *address; + const char *wins_owner; + const char *expire_time; + char *p; + + addr = talloc(mem_ctx, struct winsdb_addr); + if (!addr) { + status = NT_STATUS_NO_MEMORY; + goto failed; + } + + address = (char *)val->data; + + p = strchr(address, ';'); + if (!p) { + /* support old entries, with only the address */ + addr->address = (const char *)talloc_steal(addr, val->data); + addr->wins_owner = talloc_strdup(addr, rec->wins_owner); + if (!addr->wins_owner) { + status = NT_STATUS_NO_MEMORY; + goto failed; + } + addr->expire_time = rec->expire_time; + *_addr = addr; + return NT_STATUS_OK; + } + + *p = '\0'; p++; + addr->address = talloc_strdup(addr, address); + if (!addr->address) { + status = NT_STATUS_NO_MEMORY; + goto failed; + } + + if (strncmp("winsOwner:", p, 10) != 0) { + status = NT_STATUS_INTERNAL_DB_CORRUPTION; + goto failed; + } + wins_owner = p + 10; + p = strchr(wins_owner, ';'); + if (!p) { + status = NT_STATUS_INTERNAL_DB_CORRUPTION; + goto failed; + } + + *p = '\0';p++; + if (strcmp(wins_owner, "0.0.0.0") == 0) { + wins_owner = h->local_owner; + } + addr->wins_owner = talloc_strdup(addr, wins_owner); + if (!addr->wins_owner) { + status = NT_STATUS_NO_MEMORY; + goto failed; + } + + if (strncmp("expireTime:", p, 11) != 0) { + status = NT_STATUS_INTERNAL_DB_CORRUPTION; + goto failed; + } + + expire_time = p + 11; + p = strchr(expire_time, ';'); + if (!p) { + status = NT_STATUS_INTERNAL_DB_CORRUPTION; + goto failed; + } + + *p = '\0';p++; + addr->expire_time = ldb_string_to_time(expire_time); + + *_addr = addr; + return NT_STATUS_OK; +failed: + talloc_free(addr); + return status; +} + +/* + encode the winsdb_addr("address") attribute like this: + non-static record: + "172.31.1.1;winsOwner:172.31.9.202;expireTime:20050923032330.0Z;" + static record: + "172.31.1.1" +*/ +static int ldb_msg_add_winsdb_addr(struct ldb_message *msg, struct winsdb_record *rec, + const char *attr_name, struct winsdb_addr *addr) +{ + const char *str; + + if (rec->is_static) { + str = talloc_strdup(msg, addr->address); + if (!str) return LDB_ERR_OPERATIONS_ERROR; + } else { + char *expire_time; + expire_time = ldb_timestring(msg, addr->expire_time); + if (!expire_time) return LDB_ERR_OPERATIONS_ERROR; + str = talloc_asprintf(msg, "%s;winsOwner:%s;expireTime:%s;", + addr->address, addr->wins_owner, + expire_time); + talloc_free(expire_time); + if (!str) return LDB_ERR_OPERATIONS_ERROR; + } + + return ldb_msg_add_string(msg, attr_name, str); +} + +struct winsdb_addr **winsdb_addr_list_make(TALLOC_CTX *mem_ctx) +{ + struct winsdb_addr **addresses; + + addresses = talloc_array(mem_ctx, struct winsdb_addr *, 1); + if (!addresses) return NULL; + + addresses[0] = NULL; + + return addresses; +} + +static int winsdb_addr_sort_list (struct winsdb_addr **p1, struct winsdb_addr **p2, void *opaque) +{ + struct winsdb_addr *a1 = talloc_get_type(*p1, struct winsdb_addr); + struct winsdb_addr *a2 = talloc_get_type(*p2, struct winsdb_addr); + struct winsdb_handle *h= talloc_get_type(opaque, struct winsdb_handle); + bool a1_owned = false; + bool a2_owned = false; + + /* + * first the owned addresses with the newest to the oldest address + * then the replica addresses with the newest to the oldest address + */ + if (a2->expire_time != a1->expire_time) { + return a2->expire_time - a1->expire_time; + } + + if (strcmp(a2->wins_owner, h->local_owner) == 0) { + a2_owned = true; + } + + if (strcmp(a1->wins_owner, h->local_owner) == 0) { + a1_owned = true; + } + + return a2_owned - a1_owned; +} + +struct winsdb_addr **winsdb_addr_list_add(struct winsdb_handle *h, const struct winsdb_record *rec, + struct winsdb_addr **addresses, const char *address, + const char *wins_owner, time_t expire_time, + bool is_name_registration) +{ + struct winsdb_addr *old_addr = NULL; + size_t len = 0; + size_t i; + bool found_old_replica = false; + + /* + * count the addresses and maybe + * find an old entry for the new address + */ + for (i=0; addresses[i]; i++) { + if (old_addr) continue; + if (strcmp(addresses[i]->address, address) == 0) { + old_addr = addresses[i]; + } + } + len = i; + + /* + * the address is already there + * and we can replace it + */ + if (old_addr) { + goto remove_old_addr; + } + + /* + * if we don't have 25 addresses already, + * we can just add the new address + */ + if (len < 25) { + goto add_new_addr; + } + + /* + * if we haven't found the address, + * and we have already have 25 addresses + * if so then we need to do the following: + * - if it isn't a name registration, then just ignore the new address + * - if it is a name registration, then first search for + * the oldest replica and if there's no replica address + * search the oldest owned address + */ + if (!is_name_registration) { + return addresses; + } + + /* + * find the oldest replica address, if there's no replica + * record at all, find the oldest owned address + */ + for (i=0; addresses[i]; i++) { + bool cur_is_replica = false; + /* find out if the current address is a replica */ + if (strcmp(addresses[i]->wins_owner, h->local_owner) != 0) { + cur_is_replica = true; + } + + /* + * if we already found a replica address and the current address + * is not a replica, then skip it + */ + if (found_old_replica && !cur_is_replica) continue; + + /* + * if we found the first replica address, reset the address + * that would be replaced + */ + if (!found_old_replica && cur_is_replica) { + found_old_replica = true; + old_addr = addresses[i]; + continue; + } + + /* + * if the first address isn't a replica, just start with + * the first one + */ + if (!old_addr) { + old_addr = addresses[i]; + continue; + } + + /* + * see if we find an older address + */ + if (addresses[i]->expire_time < old_addr->expire_time) { + old_addr = addresses[i]; + continue; + } + } + +remove_old_addr: + winsdb_addr_list_remove(addresses, old_addr->address); + len --; + +add_new_addr: + addresses = talloc_realloc(addresses, addresses, struct winsdb_addr *, len + 2); + if (!addresses) return NULL; + + addresses[len] = talloc(addresses, struct winsdb_addr); + if (!addresses[len]) { + talloc_free(addresses); + return NULL; + } + + addresses[len]->address = talloc_strdup(addresses[len], address); + if (!addresses[len]->address) { + talloc_free(addresses); + return NULL; + } + + addresses[len]->wins_owner = talloc_strdup(addresses[len], wins_owner); + if (!addresses[len]->wins_owner) { + talloc_free(addresses); + return NULL; + } + + addresses[len]->expire_time = expire_time; + + addresses[len+1] = NULL; + + LDB_TYPESAFE_QSORT(addresses, len+1, h, winsdb_addr_sort_list); + + return addresses; +} + +void winsdb_addr_list_remove(struct winsdb_addr **addresses, const char *address) +{ + size_t i; + + for (i=0; addresses[i]; i++) { + if (strcmp(addresses[i]->address, address) == 0) { + break; + } + } + + for (; addresses[i]; i++) { + addresses[i] = addresses[i+1]; + } + + return; +} + +struct winsdb_addr *winsdb_addr_list_check(struct winsdb_addr **addresses, const char *address) +{ + size_t i; + + for (i=0; addresses[i]; i++) { + if (strcmp(addresses[i]->address, address) == 0) { + return addresses[i]; + } + } + + return NULL; +} + +size_t winsdb_addr_list_length(struct winsdb_addr **addresses) +{ + size_t i; + for (i=0; addresses[i]; i++); + return i; +} + +const char **winsdb_addr_string_list(TALLOC_CTX *mem_ctx, struct winsdb_addr **addresses) +{ + size_t len = winsdb_addr_list_length(addresses); + const char **str_list=NULL; + size_t i; + + for (i=0; i < len; i++) { + str_list = str_list_add(str_list, addresses[i]->address); + if (!str_list[i]) { + return NULL; + } + } + talloc_steal(mem_ctx, str_list); + return str_list; +} + +/* + load a WINS entry from the database +*/ +NTSTATUS winsdb_lookup(struct winsdb_handle *h, + const struct nbt_name *name, + TALLOC_CTX *mem_ctx, + struct winsdb_record **_rec) +{ + NTSTATUS status; + struct ldb_result *res = NULL; + int ret; + struct winsdb_record *rec; + struct ldb_context *wins_db = h->ldb; + TALLOC_CTX *tmp_ctx = talloc_new(mem_ctx); + time_t now = time(NULL); + + /* find the record in the WINS database */ + ret = ldb_search(wins_db, tmp_ctx, &res, + winsdb_dn(tmp_ctx, wins_db, name), + LDB_SCOPE_BASE, NULL, NULL); + + if (ret != LDB_SUCCESS || res->count > 1) { + status = NT_STATUS_INTERNAL_DB_CORRUPTION; + goto failed; + } else if (res->count== 0) { + status = NT_STATUS_OBJECT_NAME_NOT_FOUND; + goto failed; + } + + status = winsdb_record(h, res->msgs[0], tmp_ctx, now, &rec); + if (!NT_STATUS_IS_OK(status)) goto failed; + + talloc_steal(mem_ctx, rec); + talloc_free(tmp_ctx); + *_rec = rec; + return NT_STATUS_OK; + +failed: + talloc_free(tmp_ctx); + return status; +} + +NTSTATUS winsdb_record(struct winsdb_handle *h, struct ldb_message *msg, TALLOC_CTX *mem_ctx, time_t now, struct winsdb_record **_rec) +{ + NTSTATUS status; + struct winsdb_record *rec; + struct ldb_message_element *el; + struct nbt_name *name; + uint32_t i, j, num_values; + + rec = talloc(mem_ctx, struct winsdb_record); + if (rec == NULL) { + status = NT_STATUS_NO_MEMORY; + goto failed; + } + + status = winsdb_nbt_name(rec, msg->dn, &name); + if (!NT_STATUS_IS_OK(status)) goto failed; + + if (strlen(name->name) > 15) { + status = NT_STATUS_INTERNAL_DB_CORRUPTION; + goto failed; + } + if (name->scope && strlen(name->scope) > 238) { + status = NT_STATUS_INTERNAL_DB_CORRUPTION; + goto failed; + } + + /* parse it into a more convenient winsdb_record structure */ + rec->name = name; + rec->type = ldb_msg_find_attr_as_int(msg, "recordType", WREPL_TYPE_UNIQUE); + rec->state = ldb_msg_find_attr_as_int(msg, "recordState", WREPL_STATE_RELEASED); + rec->node = ldb_msg_find_attr_as_int(msg, "nodeType", WREPL_NODE_B); + rec->is_static = ldb_msg_find_attr_as_int(msg, "isStatic", 0); + rec->expire_time = ldb_string_to_time(ldb_msg_find_attr_as_string(msg, "expireTime", NULL)); + rec->version = ldb_msg_find_attr_as_uint64(msg, "versionID", 0); + rec->wins_owner = ldb_msg_find_attr_as_string(msg, "winsOwner", NULL); + rec->registered_by = ldb_msg_find_attr_as_string(msg, "registeredBy", NULL); + talloc_steal(rec, rec->wins_owner); + talloc_steal(rec, rec->registered_by); + + if (!rec->wins_owner || strcmp(rec->wins_owner, "0.0.0.0") == 0) { + rec->wins_owner = h->local_owner; + } + + el = ldb_msg_find_element(msg, "address"); + if (el) { + num_values = el->num_values; + } else { + num_values = 0; + } + + if (rec->type == WREPL_TYPE_UNIQUE || rec->type == WREPL_TYPE_GROUP) { + if (num_values != 1) { + status = NT_STATUS_INTERNAL_DB_CORRUPTION; + goto failed; + } + } + if (rec->state == WREPL_STATE_ACTIVE) { + if (num_values < 1) { + status = NT_STATUS_INTERNAL_DB_CORRUPTION; + goto failed; + } + } + if (num_values > 25) { + status = NT_STATUS_INTERNAL_DB_CORRUPTION; + goto failed; + } + + rec->addresses = talloc_array(rec, struct winsdb_addr *, num_values+1); + if (rec->addresses == NULL) { + status = NT_STATUS_NO_MEMORY; + goto failed; + } + + for (i=0,j=0;i<num_values;i++) { + bool we_are_owner = false; + + status = winsdb_addr_decode(h, rec, &el->values[i], rec->addresses, &rec->addresses[j]); + if (!NT_STATUS_IS_OK(status)) goto failed; + + if (strcmp(rec->addresses[j]->wins_owner, h->local_owner) == 0) { + we_are_owner = true; + } + + /* + * the record isn't static and is active + * then don't add the address if it's expired, + * but only if we're the owner of the address + * + * This is important for SGROUP records, + * because each server thinks he's the owner of the + * record and the record isn't replicated on a + * name_refresh. So addresses owned by another owner + * could expire, but we still need to return them + * (as windows does). + */ + if (!rec->is_static && + rec->addresses[j]->expire_time <= now && + rec->state == WREPL_STATE_ACTIVE && + we_are_owner) { + DEBUG(5,("WINS: expiring name addr %s of %s (expired at %s)\n", + rec->addresses[j]->address, nbt_name_string(rec->addresses[j], rec->name), + timestring(rec->addresses[j], rec->addresses[j]->expire_time))); + talloc_free(rec->addresses[j]); + rec->addresses[j] = NULL; + continue; + } + j++; + } + rec->addresses[j] = NULL; + num_values = j; + + if (rec->is_static && rec->state == WREPL_STATE_ACTIVE) { + rec->expire_time = get_time_t_max(); + for (i=0;rec->addresses[i];i++) { + rec->addresses[i]->expire_time = rec->expire_time; + } + } + + if (rec->state == WREPL_STATE_ACTIVE) { + if (num_values < 1) { + DEBUG(5,("WINS: expiring name %s (because it has no active addresses)\n", + nbt_name_string(mem_ctx, rec->name))); + rec->state = WREPL_STATE_RELEASED; + } + } + + *_rec = rec; + return NT_STATUS_OK; +failed: + if (NT_STATUS_EQUAL(NT_STATUS_INTERNAL_DB_CORRUPTION, status)) { + DEBUG(1,("winsdb_record: corrupted record: %s\n", ldb_dn_get_linearized(msg->dn))); + } + talloc_free(rec); + return status; +} + +/* + form a ldb_message from a winsdb_record +*/ +static struct ldb_message *winsdb_message(struct ldb_context *ldb, + struct winsdb_record *rec, + TALLOC_CTX *mem_ctx) +{ + int i, ret; + size_t addr_count; + const char *expire_time; + struct ldb_message *msg = ldb_msg_new(mem_ctx); + if (msg == NULL) goto failed; + + /* make sure we don't put in corrupted records */ + addr_count = winsdb_addr_list_length(rec->addresses); + if (rec->state == WREPL_STATE_ACTIVE && addr_count == 0) { + rec->state = WREPL_STATE_RELEASED; + } + if (rec->type == WREPL_TYPE_UNIQUE && addr_count > 1) { + rec->type = WREPL_TYPE_MHOMED; + } + + expire_time = ldb_timestring(msg, rec->expire_time); + if (!expire_time) { + goto failed; + } + + msg->dn = winsdb_dn(msg, ldb, rec->name); + if (msg->dn == NULL) goto failed; + ret = ldb_msg_add_fmt(msg, "type", "0x%02X", rec->name->type); + if (rec->name->name && *rec->name->name) { + ret |= ldb_msg_add_string(msg, "name", rec->name->name); + } + if (rec->name->scope && *rec->name->scope) { + ret |= ldb_msg_add_string(msg, "scope", rec->name->scope); + } + ret |= ldb_msg_add_fmt(msg, "objectClass", "winsRecord"); + ret |= ldb_msg_add_fmt(msg, "recordType", "%u", rec->type); + ret |= ldb_msg_add_fmt(msg, "recordState", "%u", rec->state); + ret |= ldb_msg_add_fmt(msg, "nodeType", "%u", rec->node); + ret |= ldb_msg_add_fmt(msg, "isStatic", "%u", rec->is_static); + ret |= ldb_msg_add_empty(msg, "expireTime", 0, NULL); + if (!(rec->is_static && rec->state == WREPL_STATE_ACTIVE)) { + ret |= ldb_msg_add_string(msg, "expireTime", expire_time); + } + ret |= ldb_msg_add_fmt(msg, "versionID", "%llu", (long long)rec->version); + ret |= ldb_msg_add_string(msg, "winsOwner", rec->wins_owner); + ret |= ldb_msg_add_empty(msg, "address", 0, NULL); + for (i=0;rec->addresses[i];i++) { + ret |= ldb_msg_add_winsdb_addr(msg, rec, "address", rec->addresses[i]); + } + if (rec->registered_by) { + ret |= ldb_msg_append_string(msg, "registeredBy", rec->registered_by, 0); + } + if (ret != LDB_SUCCESS) goto failed; + return msg; + +failed: + talloc_free(msg); + return NULL; +} + +/* + save a WINS record into the database +*/ +uint8_t winsdb_add(struct winsdb_handle *h, struct winsdb_record *rec, uint32_t flags) +{ + struct ldb_message *msg; + struct ldb_context *wins_db = h->ldb; + TALLOC_CTX *tmp_ctx = talloc_new(wins_db); + int trans = -1; + int ret; + + trans = ldb_transaction_start(wins_db); + if (trans != LDB_SUCCESS) goto failed; + + if (flags & WINSDB_FLAG_ALLOC_VERSION) { + /* passing '0' means auto-allocate a new one */ + rec->version = winsdb_set_maxVersion(h, 0); + if (rec->version == 0) goto failed; + } + if (flags & WINSDB_FLAG_TAKE_OWNERSHIP) { + rec->wins_owner = h->local_owner; + } + + msg = winsdb_message(wins_db, rec, tmp_ctx); + if (msg == NULL) goto failed; + ret = ldb_add(wins_db, msg); + if (ret != LDB_SUCCESS) goto failed; + + trans = ldb_transaction_commit(wins_db); + if (trans != LDB_SUCCESS) goto failed; + + wins_hook(h, rec, WINS_HOOK_ADD, h->hook_script); + + talloc_free(tmp_ctx); + return NBT_RCODE_OK; + +failed: + if (trans == LDB_SUCCESS) ldb_transaction_cancel(wins_db); + talloc_free(tmp_ctx); + return NBT_RCODE_SVR; +} + + +/* + modify a WINS record in the database +*/ +uint8_t winsdb_modify(struct winsdb_handle *h, struct winsdb_record *rec, uint32_t flags) +{ + struct ldb_message *msg; + struct ldb_context *wins_db = h->ldb; + TALLOC_CTX *tmp_ctx = talloc_new(wins_db); + int trans; + int ret; + unsigned int i; + + trans = ldb_transaction_start(wins_db); + if (trans != LDB_SUCCESS) goto failed; + + if (flags & WINSDB_FLAG_ALLOC_VERSION) { + /* passing '0' means auto-allocate a new one */ + rec->version = winsdb_set_maxVersion(h, 0); + if (rec->version == 0) goto failed; + } + if (flags & WINSDB_FLAG_TAKE_OWNERSHIP) { + rec->wins_owner = h->local_owner; + } + + msg = winsdb_message(wins_db, rec, tmp_ctx); + if (msg == NULL) goto failed; + + for (i=0;i<msg->num_elements;i++) { + msg->elements[i].flags = LDB_FLAG_MOD_REPLACE; + } + + ret = ldb_modify(wins_db, msg); + if (ret != LDB_SUCCESS) goto failed; + + trans = ldb_transaction_commit(wins_db); + if (trans != LDB_SUCCESS) goto failed; + + wins_hook(h, rec, WINS_HOOK_MODIFY, h->hook_script); + + talloc_free(tmp_ctx); + return NBT_RCODE_OK; + +failed: + if (trans == LDB_SUCCESS) ldb_transaction_cancel(wins_db); + talloc_free(tmp_ctx); + return NBT_RCODE_SVR; +} + + +/* + delete a WINS record from the database +*/ +uint8_t winsdb_delete(struct winsdb_handle *h, struct winsdb_record *rec) +{ + struct ldb_context *wins_db = h->ldb; + TALLOC_CTX *tmp_ctx = talloc_new(wins_db); + struct ldb_dn *dn; + int trans; + int ret; + + trans = ldb_transaction_start(wins_db); + if (trans != LDB_SUCCESS) goto failed; + + dn = winsdb_dn(tmp_ctx, wins_db, rec->name); + if (dn == NULL) goto failed; + + ret = ldb_delete(wins_db, dn); + if (ret != LDB_SUCCESS) goto failed; + + trans = ldb_transaction_commit(wins_db); + if (trans != LDB_SUCCESS) goto failed; + + wins_hook(h, rec, WINS_HOOK_DELETE, h->hook_script); + + talloc_free(tmp_ctx); + return NBT_RCODE_OK; + +failed: + if (trans == LDB_SUCCESS) ldb_transaction_cancel(wins_db); + talloc_free(tmp_ctx); + return NBT_RCODE_SVR; +} + +static bool winsdb_check_or_add_module_list(struct tevent_context *ev_ctx, + struct loadparm_context *lp_ctx, struct winsdb_handle *h, + const char *wins_path) +{ + int trans; + int ret; + struct ldb_dn *dn; + struct ldb_result *res = NULL; + struct ldb_message *msg = NULL; + TALLOC_CTX *tmp_ctx = talloc_new(h); + unsigned int flags = 0; + + trans = ldb_transaction_start(h->ldb); + if (trans != LDB_SUCCESS) goto failed; + + /* check if we have a special @MODULES record already */ + dn = ldb_dn_new(tmp_ctx, h->ldb, "@MODULES"); + if (!dn) goto failed; + + /* find the record in the WINS database */ + ret = ldb_search(h->ldb, tmp_ctx, &res, dn, LDB_SCOPE_BASE, NULL, NULL); + if (ret != LDB_SUCCESS) goto failed; + + if (res->count > 0) goto skip; + + /* if there's no record, add one */ + msg = ldb_msg_new(tmp_ctx); + if (!msg) goto failed; + msg->dn = dn; + + ret = ldb_msg_add_string(msg, "@LIST", "wins_ldb"); + if (ret != LDB_SUCCESS) goto failed; + + ret = ldb_add(h->ldb, msg); + if (ret != LDB_SUCCESS) goto failed; + + trans = ldb_transaction_commit(h->ldb); + if (trans != LDB_SUCCESS) goto failed; + + /* close and reopen the database, with the modules */ + trans = LDB_ERR_OTHER; + talloc_free(h->ldb); + h->ldb = NULL; + + if (lpcfg_parm_bool(lp_ctx, NULL,"winsdb", "nosync", false)) { + flags |= LDB_FLG_NOSYNC; + } + + h->ldb = ldb_wrap_connect(h, ev_ctx, lp_ctx, wins_path, + NULL, NULL, flags); + if (!h->ldb) goto failed; + + talloc_free(tmp_ctx); + return true; + +skip: + if (trans == LDB_SUCCESS) ldb_transaction_cancel(h->ldb); + talloc_free(tmp_ctx); + return true; + +failed: + if (trans == LDB_SUCCESS) ldb_transaction_cancel(h->ldb); + talloc_free(tmp_ctx); + return false; +} + +struct winsdb_handle *winsdb_connect(TALLOC_CTX *mem_ctx, + struct tevent_context *ev_ctx, + struct loadparm_context *lp_ctx, + const char *owner, + enum winsdb_handle_caller caller) +{ + const struct loadparm_substitution *lp_sub = + lpcfg_noop_substitution(); + struct winsdb_handle *h = NULL; + unsigned int flags = 0; + bool ret; + int ldb_err; + char *wins_path; + + h = talloc_zero(mem_ctx, struct winsdb_handle); + if (!h) return NULL; + + wins_path = lpcfg_state_path(h, lp_ctx, "wins.ldb"); + + if (lpcfg_parm_bool(lp_ctx, NULL,"winsdb", "nosync", false)) { + flags |= LDB_FLG_NOSYNC; + } + + h->ldb = ldb_wrap_connect(h, ev_ctx, lp_ctx, wins_path, + NULL, NULL, flags); + if (!h->ldb) goto failed; + + h->caller = caller; + h->hook_script = lpcfg_wins_hook(lp_ctx, lp_sub, h); + + h->local_owner = talloc_strdup(h, owner); + if (!h->local_owner) goto failed; + + /* make sure the module list is available and used */ + ret = winsdb_check_or_add_module_list(ev_ctx, lp_ctx, h, wins_path); + if (!ret) goto failed; + + ldb_err = ldb_set_opaque(h->ldb, "winsdb_handle", h); + if (ldb_err != LDB_SUCCESS) goto failed; + + return h; +failed: + talloc_free(h); + return NULL; +} + |