2 Unix SMB/CIFS implementation.
6 Copyright (C) Andrew Tridgell 2005
7 Copyright (C) Stefan Metzmacher 2005
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
25 #include "nbt_server/nbt_server.h"
26 #include "nbt_server/wins/winsdb.h"
27 #include "lib/ldb/include/ldb.h"
28 #include "lib/ldb/include/ldb_errors.h"
29 #include "system/time.h"
31 uint64_t winsdb_get_maxVersion(struct winsdb_handle *h)
34 struct ldb_context *ldb = h->ldb;
36 struct ldb_result *res = NULL;
37 TALLOC_CTX *tmp_ctx = talloc_new(ldb);
38 uint64_t maxVersion = 0;
40 dn = ldb_dn_explode(tmp_ctx, "CN=VERSION");
43 /* find the record in the WINS database */
44 ret = ldb_search(ldb, dn, LDB_SCOPE_BASE,
46 if (ret != LDB_SUCCESS) goto failed;
47 talloc_steal(tmp_ctx, res);
48 if (res->count > 1) goto failed;
50 if (res->count == 1) {
51 maxVersion = ldb_msg_find_uint64(res->msgs[0], "maxVersion", 0);
60 if newVersion == 0 return the old maxVersion + 1 and save it
61 if newVersion > 0 return MAX(oldMaxVersion, newMaxVersion) and save it
63 uint64_t winsdb_set_maxVersion(struct winsdb_handle *h, uint64_t newMaxVersion)
68 struct ldb_result *res = NULL;
69 struct ldb_message *msg = NULL;
70 struct ldb_context *wins_db = h->ldb;
71 TALLOC_CTX *tmp_ctx = talloc_new(wins_db);
72 uint64_t oldMaxVersion = 0;
74 trans = ldb_transaction_start(wins_db);
75 if (trans != LDB_SUCCESS) goto failed;
77 dn = ldb_dn_explode(tmp_ctx, "CN=VERSION");
80 /* find the record in the WINS database */
81 ret = ldb_search(wins_db, dn, LDB_SCOPE_BASE, NULL, NULL, &res);
83 if (ret != LDB_SUCCESS) goto failed;
84 if (res->count > 1) goto failed;
86 talloc_steal(tmp_ctx, res);
88 if (res->count == 1) {
89 oldMaxVersion = ldb_msg_find_uint64(res->msgs[0], "maxVersion", 0);
92 if (newMaxVersion == 0) {
93 newMaxVersion = oldMaxVersion + 1;
95 newMaxVersion = MAX(oldMaxVersion, newMaxVersion);
98 msg = ldb_msg_new(tmp_ctx);
99 if (!msg) goto failed;
103 ret = ldb_msg_add_empty(msg, "objectClass", LDB_FLAG_MOD_REPLACE);
104 if (ret != 0) goto failed;
105 ret = ldb_msg_add_string(msg, "objectClass", "winsMaxVersion");
106 if (ret != 0) goto failed;
107 ret = ldb_msg_add_empty(msg, "maxVersion", LDB_FLAG_MOD_REPLACE);
108 if (ret != 0) goto failed;
109 ret = ldb_msg_add_fmt(msg, "maxVersion", "%llu", (long long)newMaxVersion);
110 if (ret != 0) goto failed;
112 ret = ldb_modify(wins_db, msg);
113 if (ret != 0) ret = ldb_add(wins_db, msg);
114 if (ret != 0) goto failed;
116 trans = ldb_transaction_commit(wins_db);
117 if (trans != LDB_SUCCESS) goto failed;
119 talloc_free(tmp_ctx);
120 return newMaxVersion;
123 if (trans == LDB_SUCCESS) ldb_transaction_cancel(wins_db);
124 talloc_free(tmp_ctx);
128 uint64_t winsdb_get_seqnumber(struct winsdb_handle *h)
131 struct ldb_context *ldb = h->ldb;
133 struct ldb_result *res = NULL;
134 TALLOC_CTX *tmp_ctx = talloc_new(ldb);
135 uint64_t seqnumber = 0;
137 dn = ldb_dn_explode(tmp_ctx, "@BASEINFO");
138 if (!dn) goto failed;
140 /* find the record in the WINS database */
141 ret = ldb_search(ldb, dn, LDB_SCOPE_BASE,
143 if (ret != LDB_SUCCESS) goto failed;
144 talloc_steal(tmp_ctx, res);
145 if (res->count > 1) goto failed;
147 if (res->count == 1) {
148 seqnumber = ldb_msg_find_uint64(res->msgs[0], "sequenceNumber", 0);
152 talloc_free(tmp_ctx);
157 return a DN for a nbt_name
159 static struct ldb_dn *winsdb_dn(TALLOC_CTX *mem_ctx, struct nbt_name *name)
163 dn = ldb_dn_string_compose(mem_ctx, NULL, "type=0x%02X", name->type);
164 if (dn && name->name && *name->name) {
165 dn = ldb_dn_string_compose(mem_ctx, dn, "name=%s", name->name);
167 if (dn && name->scope && *name->scope) {
168 dn = ldb_dn_string_compose(mem_ctx, dn, "scope=%s", name->scope);
173 static NTSTATUS winsdb_nbt_name(TALLOC_CTX *mem_ctx, struct ldb_dn *dn, struct nbt_name **_name)
176 struct nbt_name *name;
179 name = talloc(mem_ctx, struct nbt_name);
181 status = NT_STATUS_NO_MEMORY;
185 if (dn->comp_num > 3) {
186 status = NT_STATUS_INTERNAL_DB_CORRUPTION;
190 if (dn->comp_num > cur && strcasecmp("scope", dn->components[cur].name) == 0) {
191 name->scope = talloc_steal(name, dn->components[cur].value.data);
197 if (dn->comp_num > cur && strcasecmp("name", dn->components[cur].name) == 0) {
198 name->name = talloc_steal(name, dn->components[cur].value.data);
201 name->name = talloc_strdup(name, "");
203 status = NT_STATUS_NO_MEMORY;
208 if (dn->comp_num > cur && strcasecmp("type", dn->components[cur].name) == 0) {
209 name->type = strtoul((char *)dn->components[cur].value.data, NULL, 0);
212 status = NT_STATUS_INTERNAL_DB_CORRUPTION;
224 decode the winsdb_addr("address") attribute:
226 "172.31.1.1;winsOwner:172.31.9.202;expireTime:20050923032330.0Z;"
229 static NTSTATUS winsdb_addr_decode(struct winsdb_handle *h, struct winsdb_record *rec, struct ldb_val *val,
230 TALLOC_CTX *mem_ctx, struct winsdb_addr **_addr)
233 struct winsdb_addr *addr;
235 const char *wins_owner;
236 const char *expire_time;
239 addr = talloc(mem_ctx, struct winsdb_addr);
241 status = NT_STATUS_NO_MEMORY;
245 address = (char *)val->data;
247 p = strchr(address, ';');
249 /* support old entries, with only the address */
250 addr->address = talloc_steal(addr, val->data);
251 addr->wins_owner = talloc_reference(addr, rec->wins_owner);
252 if (!addr->wins_owner) {
253 status = NT_STATUS_NO_MEMORY;
256 addr->expire_time = rec->expire_time;
262 addr->address = talloc_strdup(addr, address);
263 if (!addr->address) {
264 status = NT_STATUS_NO_MEMORY;
268 if (strncmp("winsOwner:", p, 10) != 0) {
269 status = NT_STATUS_INTERNAL_DB_CORRUPTION;
273 p = strchr(wins_owner, ';');
275 status = NT_STATUS_INTERNAL_DB_CORRUPTION;
280 if (strcmp(wins_owner, "0.0.0.0") == 0) {
281 wins_owner = h->local_owner;
283 addr->wins_owner = talloc_strdup(addr, wins_owner);
284 if (!addr->wins_owner) {
285 status = NT_STATUS_NO_MEMORY;
289 if (strncmp("expireTime:", p, 11) != 0) {
290 status = NT_STATUS_INTERNAL_DB_CORRUPTION;
294 expire_time = p + 11;
295 p = strchr(expire_time, ';');
297 status = NT_STATUS_INTERNAL_DB_CORRUPTION;
302 addr->expire_time = ldb_string_to_time(expire_time);
312 encode the winsdb_addr("address") attribute like this:
314 "172.31.1.1;winsOwner:172.31.9.202;expireTime:20050923032330.0Z;"
318 static int ldb_msg_add_winsdb_addr(struct ldb_message *msg, struct winsdb_record *rec,
319 const char *attr_name, struct winsdb_addr *addr)
324 if (rec->is_static) {
325 str = talloc_strdup(msg, addr->address);
329 expire_time = ldb_timestring(msg, addr->expire_time);
330 if (!expire_time) return -1;
331 str = talloc_asprintf(msg, "%s;winsOwner:%s;expireTime:%s;",
332 addr->address, addr->wins_owner,
334 talloc_free(expire_time);
338 val.data = discard_const_p(uint8_t, str);
339 val.length = strlen(str);
341 return ldb_msg_add_value(msg, attr_name, &val);
344 struct winsdb_addr **winsdb_addr_list_make(TALLOC_CTX *mem_ctx)
346 struct winsdb_addr **addresses;
348 addresses = talloc_array(mem_ctx, struct winsdb_addr *, 1);
349 if (!addresses) return NULL;
356 static int winsdb_addr_sort_list (struct winsdb_addr **p1, struct winsdb_addr **p2, void *opaque)
358 struct winsdb_addr *a1 = talloc_get_type(*p1, struct winsdb_addr);
359 struct winsdb_addr *a2 = talloc_get_type(*p2, struct winsdb_addr);
360 struct winsdb_handle *h= talloc_get_type(opaque, struct winsdb_handle);
361 BOOL a1_owned = False;
362 BOOL a2_owned = False;
365 * first the owned addresses with the newest to the oldest address
366 * then the replica addresses with the newest to the oldest address
368 if (a2->expire_time != a1->expire_time) {
369 return a2->expire_time - a1->expire_time;
372 if (strcmp(a2->wins_owner, h->local_owner) == 0) {
376 if (strcmp(a1->wins_owner, h->local_owner) == 0) {
380 return a2_owned - a1_owned;
383 struct winsdb_addr **winsdb_addr_list_add(struct winsdb_handle *h, const struct winsdb_record *rec,
384 struct winsdb_addr **addresses, const char *address,
385 const char *wins_owner, time_t expire_time,
386 BOOL is_name_registration)
388 struct winsdb_addr *old_addr = NULL;
391 BOOL found_old_replica = False;
394 * count the addresses and maybe
395 * find an old entry for the new address
397 for (i=0; addresses[i]; i++) {
398 if (old_addr) continue;
399 if (strcmp(addresses[i]->address, address) == 0) {
400 old_addr = addresses[i];
406 * the address is already there
407 * and we can replace it
410 goto remove_old_addr;
414 * if we don't have 25 addresses already,
415 * we can just add the new address
422 * if we haven't found the address,
423 * and we have already have 25 addresses
424 * if so then we need to do the following:
425 * - if it isn't a name registration, then just ignore the new address
426 * - if it is a name registration, then first search for
427 * the oldest replica and if there's no replica address
428 * search the oldest owned address
430 if (!is_name_registration) {
435 * find the oldest replica address, if there's no replica
436 * record at all, find the oldest owned address
438 for (i=0; addresses[i]; i++) {
439 BOOL cur_is_replica = False;
440 /* find out if the current address is a replica */
441 if (strcmp(addresses[i]->wins_owner, h->local_owner) != 0) {
442 cur_is_replica = True;
446 * if we already found a replica address and the current address
447 * is not a replica, then skip it
449 if (found_old_replica && !cur_is_replica) continue;
452 * if we found the first replica address, reset the address
453 * that would be replaced
455 if (!found_old_replica && cur_is_replica) {
456 found_old_replica = True;
457 old_addr = addresses[i];
462 * if the first address isn't a replica, just start with
466 old_addr = addresses[i];
471 * see if we find an older address
473 if (addresses[i]->expire_time < old_addr->expire_time) {
474 old_addr = addresses[i];
480 winsdb_addr_list_remove(addresses, old_addr->address);
484 addresses = talloc_realloc(addresses, addresses, struct winsdb_addr *, len + 2);
485 if (!addresses) return NULL;
487 addresses[len] = talloc(addresses, struct winsdb_addr);
488 if (!addresses[len]) {
489 talloc_free(addresses);
493 addresses[len]->address = talloc_strdup(addresses[len], address);
494 if (!addresses[len]->address) {
495 talloc_free(addresses);
499 addresses[len]->wins_owner = talloc_strdup(addresses[len], wins_owner);
500 if (!addresses[len]->wins_owner) {
501 talloc_free(addresses);
505 addresses[len]->expire_time = expire_time;
507 addresses[len+1] = NULL;
509 ldb_qsort(addresses, len+1 , sizeof(addresses[0]), h, (ldb_qsort_cmp_fn_t)winsdb_addr_sort_list);
514 void winsdb_addr_list_remove(struct winsdb_addr **addresses, const char *address)
518 for (i=0; addresses[i]; i++) {
519 if (strcmp(addresses[i]->address, address) == 0) {
523 if (addresses[i]) talloc_free(addresses[i]);
525 for (; addresses[i]; i++) {
526 addresses[i] = addresses[i+1];
532 struct winsdb_addr *winsdb_addr_list_check(struct winsdb_addr **addresses, const char *address)
536 for (i=0; addresses[i]; i++) {
537 if (strcmp(addresses[i]->address, address) == 0) {
545 size_t winsdb_addr_list_length(struct winsdb_addr **addresses)
548 for (i=0; addresses[i]; i++);
552 const char **winsdb_addr_string_list(TALLOC_CTX *mem_ctx, struct winsdb_addr **addresses)
554 size_t len = winsdb_addr_list_length(addresses);
555 const char **str_list=NULL;
558 for (i=0; i < len; i++) {
559 str_list = str_list_add(str_list, addresses[i]->address);
564 talloc_steal(mem_ctx, str_list);
569 load a WINS entry from the database
571 NTSTATUS winsdb_lookup(struct winsdb_handle *h,
572 struct nbt_name *name,
574 struct winsdb_record **_rec)
577 struct ldb_result *res = NULL;
579 struct winsdb_record *rec;
580 struct ldb_context *wins_db = h->ldb;
581 TALLOC_CTX *tmp_ctx = talloc_new(mem_ctx);
582 time_t now = time(NULL);
584 /* find the record in the WINS database */
585 ret = ldb_search(wins_db, winsdb_dn(tmp_ctx, name), LDB_SCOPE_BASE,
588 if (ret != LDB_SUCCESS || res->count > 1) {
589 status = NT_STATUS_INTERNAL_DB_CORRUPTION;
591 } else if (res->count== 0) {
592 status = NT_STATUS_OBJECT_NAME_NOT_FOUND;
596 talloc_steal(tmp_ctx, res);
598 status = winsdb_record(h, res->msgs[0], tmp_ctx, now, &rec);
599 if (!NT_STATUS_IS_OK(status)) goto failed;
601 talloc_steal(mem_ctx, rec);
602 talloc_free(tmp_ctx);
607 talloc_free(tmp_ctx);
611 NTSTATUS winsdb_record(struct winsdb_handle *h, struct ldb_message *msg, TALLOC_CTX *mem_ctx, time_t now, struct winsdb_record **_rec)
614 struct winsdb_record *rec;
615 struct ldb_message_element *el;
616 struct nbt_name *name;
617 uint32_t i, j, num_values;
619 rec = talloc(mem_ctx, struct winsdb_record);
621 status = NT_STATUS_NO_MEMORY;
625 status = winsdb_nbt_name(rec, msg->dn, &name);
626 if (!NT_STATUS_IS_OK(status)) goto failed;
628 if (strlen(name->name) > 15) {
629 status = NT_STATUS_INTERNAL_DB_CORRUPTION;
632 if (name->scope && strlen(name->scope) > 238) {
633 status = NT_STATUS_INTERNAL_DB_CORRUPTION;
637 /* parse it into a more convenient winsdb_record structure */
639 rec->type = ldb_msg_find_int(msg, "recordType", WREPL_TYPE_UNIQUE);
640 rec->state = ldb_msg_find_int(msg, "recordState", WREPL_STATE_RELEASED);
641 rec->node = ldb_msg_find_int(msg, "nodeType", WREPL_NODE_B);
642 rec->is_static = ldb_msg_find_int(msg, "isStatic", 0);
643 rec->expire_time = ldb_string_to_time(ldb_msg_find_string(msg, "expireTime", NULL));
644 rec->version = ldb_msg_find_uint64(msg, "versionID", 0);
645 rec->wins_owner = ldb_msg_find_string(msg, "winsOwner", NULL);
646 rec->registered_by = ldb_msg_find_string(msg, "registeredBy", NULL);
647 talloc_steal(rec, rec->wins_owner);
648 talloc_steal(rec, rec->registered_by);
650 if (!rec->wins_owner || strcmp(rec->wins_owner, "0.0.0.0") == 0) {
651 rec->wins_owner = h->local_owner;
654 el = ldb_msg_find_element(msg, "address");
656 num_values = el->num_values;
661 if (rec->type == WREPL_TYPE_UNIQUE || rec->type == WREPL_TYPE_GROUP) {
662 if (num_values != 1) {
663 status = NT_STATUS_INTERNAL_DB_CORRUPTION;
667 if (rec->state == WREPL_STATE_ACTIVE) {
668 if (num_values < 1) {
669 status = NT_STATUS_INTERNAL_DB_CORRUPTION;
673 if (num_values > 25) {
674 status = NT_STATUS_INTERNAL_DB_CORRUPTION;
678 /* see if it has already expired */
679 if (!rec->is_static &&
680 rec->expire_time <= now &&
681 rec->state == WREPL_STATE_ACTIVE) {
682 DEBUG(5,("WINS: expiring name %s (expired at %s)\n",
683 nbt_name_string(mem_ctx, rec->name), timestring(mem_ctx, rec->expire_time)));
684 rec->state = WREPL_STATE_RELEASED;
687 rec->addresses = talloc_array(rec, struct winsdb_addr *, num_values+1);
688 if (rec->addresses == NULL) {
689 status = NT_STATUS_NO_MEMORY;
693 for (i=0,j=0;i<num_values;i++) {
694 status = winsdb_addr_decode(h, rec, &el->values[i], rec->addresses, &rec->addresses[j]);
695 if (!NT_STATUS_IS_OK(status)) goto failed;
698 * the record isn't static and is active
699 * then don't add the address if it's expired
701 if (!rec->is_static &&
702 rec->addresses[j]->expire_time <= now &&
703 rec->state == WREPL_STATE_ACTIVE) {
704 DEBUG(5,("WINS: expiring name addr %s of %s (expired at %s)\n",
705 rec->addresses[j]->address, nbt_name_string(rec->addresses[j], rec->name),
706 timestring(rec->addresses[j], rec->addresses[j]->expire_time)));
707 talloc_free(rec->addresses[j]);
708 rec->addresses[j] = NULL;
713 rec->addresses[j] = NULL;
716 if (rec->is_static && rec->state == WREPL_STATE_ACTIVE) {
717 rec->expire_time = get_time_t_max();
718 for (i=0;rec->addresses[i];i++) {
719 rec->addresses[i]->expire_time = rec->expire_time;
723 if (rec->state == WREPL_STATE_ACTIVE) {
724 if (num_values < 1) {
725 DEBUG(5,("WINS: expiring name %s (because it has no active addresses)\n",
726 nbt_name_string(mem_ctx, rec->name)));
727 rec->state = WREPL_STATE_RELEASED;
734 if (NT_STATUS_EQUAL(NT_STATUS_INTERNAL_DB_CORRUPTION, status)) {
735 DEBUG(1,("winsdb_record: corrupted record: %s\n", ldb_dn_linearize(rec, msg->dn)));
742 form a ldb_message from a winsdb_record
744 struct ldb_message *winsdb_message(struct ldb_context *ldb,
745 struct winsdb_record *rec, TALLOC_CTX *mem_ctx)
749 const char *expire_time;
750 struct ldb_message *msg = ldb_msg_new(mem_ctx);
751 if (msg == NULL) goto failed;
753 /* make sure we don't put in corrupted records */
754 addr_count = winsdb_addr_list_length(rec->addresses);
755 if (rec->state == WREPL_STATE_ACTIVE && addr_count == 0) {
756 rec->state = WREPL_STATE_RELEASED;
758 if (rec->type == WREPL_TYPE_UNIQUE && addr_count > 1) {
759 rec->type = WREPL_TYPE_MHOMED;
762 expire_time = ldb_timestring(msg, rec->expire_time);
767 msg->dn = winsdb_dn(msg, rec->name);
768 if (msg->dn == NULL) goto failed;
769 ret |= ldb_msg_add_fmt(msg, "type", "0x%02X", rec->name->type);
770 if (rec->name->name && *rec->name->name) {
771 ret |= ldb_msg_add_string(msg, "name", rec->name->name);
773 if (rec->name->scope && *rec->name->scope) {
774 ret |= ldb_msg_add_string(msg, "scope", rec->name->scope);
776 ret |= ldb_msg_add_fmt(msg, "objectClass", "winsRecord");
777 ret |= ldb_msg_add_fmt(msg, "recordType", "%u", rec->type);
778 ret |= ldb_msg_add_fmt(msg, "recordState", "%u", rec->state);
779 ret |= ldb_msg_add_fmt(msg, "nodeType", "%u", rec->node);
780 ret |= ldb_msg_add_fmt(msg, "isStatic", "%u", rec->is_static);
781 ret |= ldb_msg_add_empty(msg, "expireTime", 0);
782 if (!(rec->is_static && rec->state == WREPL_STATE_ACTIVE)) {
783 ret |= ldb_msg_add_string(msg, "expireTime", expire_time);
785 ret |= ldb_msg_add_fmt(msg, "versionID", "%llu", (long long)rec->version);
786 ret |= ldb_msg_add_string(msg, "winsOwner", rec->wins_owner);
787 ret |= ldb_msg_add_empty(msg, "address", 0);
788 for (i=0;rec->addresses[i];i++) {
789 ret |= ldb_msg_add_winsdb_addr(msg, rec, "address", rec->addresses[i]);
791 ret |= ldb_msg_add_empty(msg, "registeredBy", 0);
792 if (rec->registered_by) {
793 ret |= ldb_msg_add_string(msg, "registeredBy", rec->registered_by);
794 if (ret != 0) goto failed;
804 save a WINS record into the database
806 uint8_t winsdb_add(struct winsdb_handle *h, struct winsdb_record *rec, uint32_t flags)
808 struct ldb_message *msg;
809 struct ldb_context *wins_db = h->ldb;
810 TALLOC_CTX *tmp_ctx = talloc_new(wins_db);
814 trans = ldb_transaction_start(wins_db);
815 if (trans != LDB_SUCCESS) goto failed;
817 if (flags & WINSDB_FLAG_ALLOC_VERSION) {
818 /* passing '0' means auto-allocate a new one */
819 rec->version = winsdb_set_maxVersion(h, 0);
820 if (rec->version == 0) goto failed;
822 if (flags & WINSDB_FLAG_TAKE_OWNERSHIP) {
823 rec->wins_owner = h->local_owner;
826 msg = winsdb_message(wins_db, rec, tmp_ctx);
827 if (msg == NULL) goto failed;
828 ret = ldb_add(wins_db, msg);
829 if (ret != 0) goto failed;
831 trans = ldb_transaction_commit(wins_db);
832 if (trans != LDB_SUCCESS) goto failed;
834 wins_hook(h, rec, WINS_HOOK_ADD);
836 talloc_free(tmp_ctx);
840 if (trans == LDB_SUCCESS) ldb_transaction_cancel(wins_db);
841 talloc_free(tmp_ctx);
842 return NBT_RCODE_SVR;
847 modify a WINS record in the database
849 uint8_t winsdb_modify(struct winsdb_handle *h, struct winsdb_record *rec, uint32_t flags)
851 struct ldb_message *msg;
852 struct ldb_context *wins_db = h->ldb;
853 TALLOC_CTX *tmp_ctx = talloc_new(wins_db);
858 trans = ldb_transaction_start(wins_db);
859 if (trans != LDB_SUCCESS) goto failed;
861 if (flags & WINSDB_FLAG_ALLOC_VERSION) {
862 /* passing '0' means auto-allocate a new one */
863 rec->version = winsdb_set_maxVersion(h, 0);
864 if (rec->version == 0) goto failed;
866 if (flags & WINSDB_FLAG_TAKE_OWNERSHIP) {
867 rec->wins_owner = h->local_owner;
870 msg = winsdb_message(wins_db, rec, tmp_ctx);
871 if (msg == NULL) goto failed;
873 for (i=0;i<msg->num_elements;i++) {
874 msg->elements[i].flags = LDB_FLAG_MOD_REPLACE;
877 ret = ldb_modify(wins_db, msg);
878 if (ret != 0) goto failed;
880 trans = ldb_transaction_commit(wins_db);
881 if (trans != LDB_SUCCESS) goto failed;
883 wins_hook(h, rec, WINS_HOOK_MODIFY);
885 talloc_free(tmp_ctx);
889 if (trans == LDB_SUCCESS) ldb_transaction_cancel(wins_db);
890 talloc_free(tmp_ctx);
891 return NBT_RCODE_SVR;
896 delete a WINS record from the database
898 uint8_t winsdb_delete(struct winsdb_handle *h, struct winsdb_record *rec)
900 struct ldb_context *wins_db = h->ldb;
901 TALLOC_CTX *tmp_ctx = talloc_new(wins_db);
902 const struct ldb_dn *dn;
906 trans = ldb_transaction_start(wins_db);
907 if (trans != LDB_SUCCESS) goto failed;
909 dn = winsdb_dn(tmp_ctx, rec->name);
910 if (dn == NULL) goto failed;
912 ret = ldb_delete(wins_db, dn);
913 if (ret != 0) goto failed;
915 trans = ldb_transaction_commit(wins_db);
916 if (trans != LDB_SUCCESS) goto failed;
918 wins_hook(h, rec, WINS_HOOK_DELETE);
920 talloc_free(tmp_ctx);
924 if (trans == LDB_SUCCESS) ldb_transaction_cancel(wins_db);
925 talloc_free(tmp_ctx);
926 return NBT_RCODE_SVR;
929 static BOOL winsdb_check_or_add_module_list(struct winsdb_handle *h)
934 struct ldb_result *res = NULL;
935 struct ldb_message *msg = NULL;
936 TALLOC_CTX *tmp_ctx = talloc_new(h);
937 unsigned int flags = 0;
939 trans = ldb_transaction_start(h->ldb);
940 if (trans != LDB_SUCCESS) goto failed;
942 /* check if we have a special @MODULES record already */
943 dn = ldb_dn_explode(tmp_ctx, "@MODULES");
944 if (!dn) goto failed;
946 /* find the record in the WINS database */
947 ret = ldb_search(h->ldb, dn, LDB_SCOPE_BASE, NULL, NULL, &res);
948 if (ret != LDB_SUCCESS) goto failed;
949 talloc_steal(tmp_ctx, res);
951 if (res->count > 0) goto skip;
953 /* if there's no record, add one */
954 msg = ldb_msg_new(tmp_ctx);
955 if (!msg) goto failed;
958 ret = ldb_msg_add_string(msg, "@LIST", "wins_ldb");
959 if (ret != 0) goto failed;
961 ret = ldb_add(h->ldb, msg);
962 if (ret != 0) goto failed;
964 trans = ldb_transaction_commit(h->ldb);
965 if (trans != LDB_SUCCESS) goto failed;
967 /* close and reopen the database, with the modules */
968 trans = LDB_ERR_OTHER;
972 if (lp_parm_bool(-1,"winsdb", "nosync", False)) {
973 flags |= LDB_FLG_NOSYNC;
976 h->ldb = ldb_wrap_connect(h, lock_path(h, lp_wins_url()),
977 NULL, NULL, flags, NULL);
978 if (!h->ldb) goto failed;
980 talloc_free(tmp_ctx);
984 if (trans == LDB_SUCCESS) ldb_transaction_cancel(h->ldb);
985 talloc_free(tmp_ctx);
989 if (trans == LDB_SUCCESS) ldb_transaction_cancel(h->ldb);
990 talloc_free(tmp_ctx);
994 struct winsdb_handle *winsdb_connect(TALLOC_CTX *mem_ctx, enum winsdb_handle_caller caller)
996 struct winsdb_handle *h = NULL;
998 unsigned int flags = 0;
1002 h = talloc(mem_ctx, struct winsdb_handle);
1003 if (!h) return NULL;
1005 if (lp_parm_bool(-1,"winsdb", "nosync", False)) {
1006 flags |= LDB_FLG_NOSYNC;
1009 h->ldb = ldb_wrap_connect(h, lock_path(h, lp_wins_url()),
1010 NULL, NULL, flags, NULL);
1011 if (!h->ldb) goto failed;
1015 owner = lp_parm_string(-1, "winsdb", "local_owner");
1017 owner = iface_n_ip(0);
1020 h->local_owner = talloc_strdup(h, owner);
1021 if (!h->local_owner) goto failed;
1023 /* make sure the module list is available and used */
1024 ret = winsdb_check_or_add_module_list(h);
1025 if (!ret) goto failed;
1027 ldb_err = ldb_set_opaque(h->ldb, "winsdb_handle", h);
1028 if (ldb_err != LDB_SUCCESS) goto failed;