#include "nbt_server/wins/winsdb.h"
#include "lib/ldb/include/ldb.h"
#include "lib/ldb/include/ldb_errors.h"
-#include "db_wrap.h"
+#include "librpc/gen_ndr/ndr_nbt.h"
#include "system/time.h"
+#include "db_wrap.h"
+#include "system/network.h"
+#include "netif/netif.h"
+
+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_explode(tmp_ctx, "CN=VERSION");
+ if (!dn) goto failed;
+
+ /* find the record in the WINS database */
+ ret = ldb_search(ldb, dn, LDB_SCOPE_BASE,
+ NULL, NULL, &res);
+ if (ret != LDB_SUCCESS) goto failed;
+ talloc_steal(tmp_ctx, res);
+ if (res->count > 1) goto failed;
+
+ if (res->count == 1) {
+ maxVersion = ldb_msg_find_uint64(res->msgs[0], "maxVersion", 0);
+ }
+
+failed:
+ talloc_free(tmp_ctx);
+ return maxVersion;
+}
/*
- return the new maxVersion and save it
+ if newVersion == 0 return the old maxVersion + 1 and save it
+ if newVersion > 0 return MAX(oldMaxVersion, newMaxVersion) and save it
*/
-static uint64_t winsdb_allocate_version(struct ldb_context *wins_db)
+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 maxVersion = 0;
+ uint64_t oldMaxVersion = 0;
trans = ldb_transaction_start(wins_db);
if (trans != LDB_SUCCESS) goto failed;
talloc_steal(tmp_ctx, res);
if (res->count == 1) {
- maxVersion = ldb_msg_find_uint64(res->msgs[0], "maxVersion", 0);
+ oldMaxVersion = ldb_msg_find_uint64(res->msgs[0], "maxVersion", 0);
+ }
+
+ if (newMaxVersion == 0) {
+ newMaxVersion = oldMaxVersion + 1;
+ } else {
+ newMaxVersion = MAX(oldMaxVersion, newMaxVersion);
}
- maxVersion++;
msg = ldb_msg_new(tmp_ctx);
if (!msg) goto failed;
if (ret != 0) goto failed;
ret = ldb_msg_add_empty(msg, "maxVersion", LDB_FLAG_MOD_REPLACE);
if (ret != 0) goto failed;
- ret = ldb_msg_add_fmt(msg, "maxVersion", "%llu", (long long)maxVersion);
+ ret = ldb_msg_add_fmt(msg, "maxVersion", "%llu", (long long)newMaxVersion);
if (ret != 0) goto failed;
ret = ldb_modify(wins_db, msg);
if (trans != LDB_SUCCESS) goto failed;
talloc_free(tmp_ctx);
- return maxVersion;
+ return newMaxVersion;
failed:
if (trans == LDB_SUCCESS) ldb_transaction_cancel(wins_db);
return 0;
}
+uint64_t winsdb_get_seqnumber(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 seqnumber = 0;
+
+ dn = ldb_dn_explode(tmp_ctx, "@BASEINFO");
+ if (!dn) goto failed;
+
+ /* find the record in the WINS database */
+ ret = ldb_search(ldb, dn, LDB_SCOPE_BASE,
+ NULL, NULL, &res);
+ if (ret != LDB_SUCCESS) goto failed;
+ talloc_steal(tmp_ctx, res);
+ if (res->count > 1) goto failed;
+
+ if (res->count == 1) {
+ seqnumber = ldb_msg_find_uint64(res->msgs[0], "sequenceNumber", 0);
+ }
+
+failed:
+ talloc_free(tmp_ctx);
+ return seqnumber;
+}
+
/*
return a DN for a nbt_name
*/
"172.31.1.1;winsOwner:172.31.9.202;expireTime:20050923032330.0Z;"
are valid records
*/
-static NTSTATUS winsdb_addr_decode(struct winsdb_record *rec, struct ldb_val *val,
+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;
- char *address;
- char *wins_owner;
- char *expire_time;
+ const char *address;
+ const char *wins_owner;
+ const char *expire_time;
char *p;
addr = talloc(mem_ctx, struct winsdb_addr);
}
*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;
/*
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,
+static int ldb_msg_add_winsdb_addr(struct ldb_message *msg, struct winsdb_record *rec,
const char *attr_name, struct winsdb_addr *addr)
{
struct ldb_val val;
const char *str;
- str = talloc_asprintf(msg, "%s;winsOwner:%s;expireTime:%s;",
- addr->address, addr->wins_owner,
- ldb_timestring(msg, addr->expire_time));
- if (!str) return -1;
+ if (rec->is_static) {
+ str = talloc_strdup(msg, addr->address);
+ if (!str) return -1;
+ } else {
+ char *expire_time;
+ expire_time = ldb_timestring(msg, addr->expire_time);
+ if (!expire_time) return -1;
+ str = talloc_asprintf(msg, "%s;winsOwner:%s;expireTime:%s;",
+ addr->address, addr->wins_owner,
+ expire_time);
+ talloc_free(expire_time);
+ if (!str) return -1;
+ }
val.data = discard_const_p(uint8_t, str);
val.length = strlen(str);
return addresses;
}
-struct winsdb_addr **winsdb_addr_list_add(struct winsdb_addr **addresses, const char *address,
- const char *wins_owner, time_t expire_time)
+static int winsdb_addr_sort_list (struct winsdb_addr **p1, struct winsdb_addr **p2, void *opaque)
{
- size_t len = winsdb_addr_list_length(addresses);
+ 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+1] = NULL;
+ ldb_qsort(addresses, len+1 , sizeof(addresses[0]), h, (ldb_qsort_cmp_fn_t)winsdb_addr_sort_list);
+
return addresses;
}
break;
}
}
- if (!addresses[i]) return;
for (; addresses[i]; i++) {
addresses[i] = addresses[i+1];
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;
+ const char **str_list=NULL;
size_t i;
- str_list = talloc_array(mem_ctx, const char *, len + 1);
- if (!str_list) return NULL;
-
for (i=0; i < len; i++) {
- str_list[i] = talloc_strdup(str_list, addresses[i]->address);
+ str_list = str_list_add(str_list, addresses[i]->address);
if (!str_list[i]) {
- talloc_free(str_list);
return NULL;
}
}
-
- str_list[len] = NULL;
+ talloc_steal(mem_ctx, str_list);
return str_list;
}
/*
load a WINS entry from the database
*/
-NTSTATUS winsdb_lookup(struct ldb_context *wins_db,
+NTSTATUS winsdb_lookup(struct winsdb_handle *h,
struct nbt_name *name,
TALLOC_CTX *mem_ctx,
struct winsdb_record **_rec)
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, winsdb_dn(tmp_ctx, name), LDB_SCOPE_BASE,
talloc_steal(tmp_ctx, res);
- status = winsdb_record(res->msgs[0], tmp_ctx, &rec);
+ status = winsdb_record(h, res->msgs[0], tmp_ctx, now, &rec);
if (!NT_STATUS_IS_OK(status)) goto failed;
- /* see if it has already expired */
- if (rec->state == WREPL_STATE_ACTIVE &&
- rec->expire_time <= time(NULL)) {
- DEBUG(5,("WINS: expiring name %s (expired at %s)\n",
- nbt_name_string(tmp_ctx, rec->name), timestring(tmp_ctx, rec->expire_time)));
- rec->state = WREPL_STATE_RELEASED;
- }
-
talloc_steal(mem_ctx, rec);
talloc_free(tmp_ctx);
*_rec = rec;
return status;
}
-NTSTATUS winsdb_record(struct ldb_message *msg, TALLOC_CTX *mem_ctx, struct winsdb_record **_rec)
+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, num_values;
+ uint32_t i, j, num_values;
rec = talloc(mem_ctx, struct winsdb_record);
if (rec == NULL) {
talloc_steal(rec, rec->wins_owner);
talloc_steal(rec, rec->registered_by);
- if (!rec->wins_owner) {
- rec->wins_owner = talloc_strdup(rec, WINSDB_OWNER_LOCAL);
- if (rec->wins_owner == NULL) {
- status = NT_STATUS_NO_MEMORY;
- goto failed;
- }
+ 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");
goto failed;
}
}
+ if (num_values > 25) {
+ status = NT_STATUS_INTERNAL_DB_CORRUPTION;
+ goto failed;
+ }
+
+ /* see if it has already expired */
+ if (!rec->is_static &&
+ rec->expire_time <= now &&
+ rec->state == WREPL_STATE_ACTIVE) {
+ DEBUG(5,("WINS: expiring name %s (expired at %s)\n",
+ nbt_name_string(mem_ctx, rec->name), timestring(mem_ctx, rec->expire_time)));
+ rec->state = WREPL_STATE_RELEASED;
+ }
rec->addresses = talloc_array(rec, struct winsdb_addr *, num_values+1);
if (rec->addresses == NULL) {
goto failed;
}
- for (i=0;i<num_values;i++) {
- status = winsdb_addr_decode(rec, &el->values[i], rec->addresses, &rec->addresses[i]);
+ for (i=0,j=0;i<num_values;i++) {
+ status = winsdb_addr_decode(h, rec, &el->values[i], rec->addresses, &rec->addresses[j]);
if (!NT_STATUS_IS_OK(status)) goto failed;
+
+ /*
+ * the record isn't static and is active
+ * then don't add the address if it's expired
+ */
+ if (!rec->is_static &&
+ rec->addresses[j]->expire_time <= now &&
+ rec->state == WREPL_STATE_ACTIVE) {
+ 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->addresses[i] = NULL;
*_rec = rec;
return NT_STATUS_OK;
{
int i, ret=0;
size_t addr_count;
+ const char *expire_time;
struct ldb_message *msg = ldb_msg_new(mem_ctx);
if (msg == NULL) goto failed;
rec->type = WREPL_TYPE_MHOMED;
}
+ expire_time = ldb_timestring(msg, rec->expire_time);
+ if (!expire_time) {
+ goto failed;
+ }
+
msg->dn = winsdb_dn(msg, rec->name);
if (msg->dn == NULL) goto failed;
ret |= ldb_msg_add_fmt(msg, "type", "0x%02X", rec->name->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_string(msg, "expireTime",
- ldb_timestring(msg, rec->expire_time));
+ ret |= ldb_msg_add_empty(msg, "expireTime", 0);
+ 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);
for (i=0;rec->addresses[i];i++) {
- ret |= ldb_msg_add_winsdb_addr(msg, "address", rec->addresses[i]);
+ ret |= ldb_msg_add_winsdb_addr(msg, rec, "address", rec->addresses[i]);
}
ret |= ldb_msg_add_empty(msg, "registeredBy", 0);
if (rec->registered_by) {
/*
save a WINS record into the database
*/
-uint8_t winsdb_add(struct ldb_context *wins_db, struct winsdb_record *rec, uint32_t flags)
+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 = 0;
if (trans != LDB_SUCCESS) goto failed;
if (flags & WINSDB_FLAG_ALLOC_VERSION) {
- rec->version = winsdb_allocate_version(wins_db);
+ /* 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 = WINSDB_OWNER_LOCAL;
+ rec->wins_owner = h->local_owner;
}
msg = winsdb_message(wins_db, rec, tmp_ctx);
trans = ldb_transaction_commit(wins_db);
if (trans != LDB_SUCCESS) goto failed;
+ wins_hook(h, rec, WINS_HOOK_ADD);
+
talloc_free(tmp_ctx);
return NBT_RCODE_OK;
/*
modify a WINS record in the database
*/
-uint8_t winsdb_modify(struct ldb_context *wins_db, struct winsdb_record *rec, uint32_t flags)
+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;
if (trans != LDB_SUCCESS) goto failed;
if (flags & WINSDB_FLAG_ALLOC_VERSION) {
- rec->version = winsdb_allocate_version(wins_db);
+ /* 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 = WINSDB_OWNER_LOCAL;
+ rec->wins_owner = h->local_owner;
}
msg = winsdb_message(wins_db, rec, tmp_ctx);
trans = ldb_transaction_commit(wins_db);
if (trans != LDB_SUCCESS) goto failed;
+ wins_hook(h, rec, WINS_HOOK_MODIFY);
+
talloc_free(tmp_ctx);
return NBT_RCODE_OK;
/*
delete a WINS record from the database
*/
-uint8_t winsdb_delete(struct ldb_context *wins_db, struct winsdb_record *rec)
+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);
const struct ldb_dn *dn;
int trans;
trans = ldb_transaction_commit(wins_db);
if (trans != LDB_SUCCESS) goto failed;
+ wins_hook(h, rec, WINS_HOOK_DELETE);
+
talloc_free(tmp_ctx);
return NBT_RCODE_OK;
return NBT_RCODE_SVR;
}
-struct ldb_context *winsdb_connect(TALLOC_CTX *mem_ctx)
+static BOOL winsdb_check_or_add_module_list(struct winsdb_handle *h)
{
- return ldb_wrap_connect(mem_ctx, lock_path(mem_ctx, lp_wins_url()),
- system_session(mem_ctx), NULL, 0, NULL);
+ 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_explode(tmp_ctx, "@MODULES");
+ if (!dn) goto failed;
+
+ /* find the record in the WINS database */
+ ret = ldb_search(h->ldb, dn, LDB_SCOPE_BASE, NULL, NULL, &res);
+ if (ret != LDB_SUCCESS) goto failed;
+ talloc_steal(tmp_ctx, res);
+
+ 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 != 0) goto failed;
+
+ ret = ldb_add(h->ldb, msg);
+ if (ret != 0) 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 (lp_parm_bool(-1,"winsdb", "nosync", False)) {
+ flags |= LDB_FLG_NOSYNC;
+ }
+
+ h->ldb = ldb_wrap_connect(h, lock_path(h, lp_wins_url()),
+ NULL, NULL, flags, NULL);
+ 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, enum winsdb_handle_caller caller)
+{
+ struct winsdb_handle *h = NULL;
+ const char *owner;
+ unsigned int flags = 0;
+ BOOL ret;
+ int ldb_err;
+
+ h = talloc(mem_ctx, struct winsdb_handle);
+ if (!h) return NULL;
+
+ if (lp_parm_bool(-1,"winsdb", "nosync", False)) {
+ flags |= LDB_FLG_NOSYNC;
+ }
+
+ h->ldb = ldb_wrap_connect(h, lock_path(h, lp_wins_url()),
+ NULL, NULL, flags, NULL);
+ if (!h->ldb) goto failed;
+
+ h->caller = caller;
+
+ owner = lp_parm_string(-1, "winsdb", "local_owner");
+ if (!owner) {
+ owner = iface_n_ip(0);
+ }
+
+ 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(h);
+ 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;
}
git.samba.org / garming / samba-autobuild / .git / blobdiff