2 Unix SMB/CIFS implementation.
6 Copyright (C) Andrew Tridgell 2005
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
24 #include "nbt_server/nbt_server.h"
25 #include "nbt_server/wins/winsdb.h"
26 #include "lib/ldb/include/ldb.h"
27 #include "lib/ldb/include/ldb_errors.h"
29 #include "system/time.h"
32 return the new maxVersion and save it
34 static uint64_t winsdb_allocate_version(struct wins_server *winssrv)
37 struct ldb_context *ldb = winssrv->wins_db;
39 struct ldb_message **res = NULL;
40 struct ldb_message *msg = NULL;
41 TALLOC_CTX *tmp_ctx = talloc_new(winssrv);
42 uint64_t maxVersion = 0;
44 dn = ldb_dn_explode(tmp_ctx, "CN=VERSION");
47 ret |= ldb_msg_add_string(msg, "objectClass", "winsEntry");
48 ret |= ldb_msg_add_fmt(msg, "minVersion", "%llu", winssrv->min_version);
49 ret |= ldb_msg_add_fmt(msg, "maxVersion", "%llu", winssrv->max_version);
50 if (ret != 0) goto failed;
53 maxVersion = ldb_msg_find_uint64(res[0], "maxVersion", 0);
57 msg = ldb_msg_new(tmp_ctx);
58 if (!msg) goto failed;
62 ret = ldb_msg_add_empty(ldb, msg, "maxVersion", LDB_FLAG_MOD_REPLACE);
63 if (ret != 0) goto failed;
64 ret = ldb_msg_add_fmt(ldb, msg, "maxVersion", "%llu", maxVersion);
65 if (ret != 0) goto failed;
67 ret = ldb_modify(ldb, msg);
68 if (ret != 0) ret = ldb_add(ldb, msg);
69 if (ret != 0) goto failed;
80 return a DN for a nbt_name
82 static struct ldb_dn *winsdb_dn(TALLOC_CTX *mem_ctx, struct nbt_name *name)
86 dn = ldb_dn_string_compose(mem_ctx, NULL, "type=0x%02X", name->type);
87 if (dn && name->name && *name->name) {
88 dn = ldb_dn_string_compose(mem_ctx, dn, "name=%s", name->name);
90 if (dn && name->scope && *name->scope) {
91 dn = ldb_dn_string_compose(mem_ctx, dn, "scope=%s", name->scope);
96 static NTSTATUS winsdb_nbt_name(TALLOC_CTX *mem_ctx, struct ldb_dn *dn, struct nbt_name **_name)
99 struct nbt_name *name;
102 name = talloc(mem_ctx, struct nbt_name);
104 status = NT_STATUS_NO_MEMORY;
108 if (dn->comp_num > 3) {
109 status = NT_STATUS_INTERNAL_DB_CORRUPTION;
113 if (dn->comp_num > cur && strcasecmp("scope", dn->components[cur].name) == 0) {
114 name->scope = talloc_steal(name, dn->components[cur].value.data);
120 if (dn->comp_num > cur && strcasecmp("name", dn->components[cur].name) == 0) {
121 name->name = talloc_steal(name, dn->components[cur].value.data);
124 name->name = talloc_strdup(name, "");
126 status = NT_STATUS_NO_MEMORY;
131 if (dn->comp_num > cur && strcasecmp("type", dn->components[cur].name) == 0) {
132 name->type = strtoul((char *)dn->components[cur].value.data, NULL, 0);
135 status = NT_STATUS_INTERNAL_DB_CORRUPTION;
147 decode the winsdb_addr("address") attribute:
149 "172.31.1.1;winsOwner:172.31.9.202;expireTime:20050923032330.0Z;"
152 static BOOL winsdb_remove_version(struct wins_server *winssrv, uint64_t version)
154 if (version == winssrv->min_version) {
155 winssrv->min_version++;
156 return winsdb_save_version(winssrv);
163 encode the winsdb_addr("address") attribute like this:
164 "172.31.1.1;winsOwner:172.31.9.202;expireTime:20050923032330.0Z"
166 static int ldb_msg_add_winsdb_addr(struct ldb_context *ldb, struct ldb_message *msg,
167 const char *attr_name, struct winsdb_addr *addr)
172 dn = ldb_dn_string_compose(mem_ctx, NULL, "type=%02x", name->type);
174 addresses[len]->address = talloc_strdup(addresses[len], address);
175 if (!addresses[len]->address) {
176 talloc_free(addresses);
180 addresses[len]->wins_owner = talloc_strdup(addresses[len], wins_owner);
181 if (!addresses[len]->wins_owner) {
182 talloc_free(addresses);
186 addresses[len]->expire_time = expire_time;
188 addresses[len+1] = NULL;
193 void winsdb_addr_list_remove(struct winsdb_addr **addresses, const char *address)
197 for (i=0; addresses[i]; i++) {
198 if (strcmp(addresses[i]->address, address) == 0) {
202 if (!addresses[i]) return;
204 for (; addresses[i]; i++) {
205 addresses[i] = addresses[i+1];
211 struct winsdb_addr *winsdb_addr_list_check(struct winsdb_addr **addresses, const char *address)
215 for (i=0; addresses[i]; i++) {
216 if (strcmp(addresses[i]->address, address) == 0) {
224 size_t winsdb_addr_list_length(struct winsdb_addr **addresses)
227 for (i=0; addresses[i]; i++);
231 const char **winsdb_addr_string_list(TALLOC_CTX *mem_ctx, struct winsdb_addr **addresses)
233 size_t len = winsdb_addr_list_length(addresses);
234 const char **str_list;
237 str_list = talloc_array(mem_ctx, const char *, len + 1);
238 if (!str_list) return NULL;
240 for (i=0; i < len; i++) {
241 str_list[i] = talloc_strdup(str_list, addresses[i]->address);
243 talloc_free(str_list);
248 str_list[len] = NULL;
253 decode the winsdb_addr("address") attribute:
255 "172.31.1.1;winsOwner:172.31.9.202;expireTime:20050923032330.0Z"
258 static struct winsdb_addr *winsdb_addr_decode(struct winsdb_record *rec, TALLOC_CTX *mem_ctx, struct ldb_val *val)
261 struct winsdb_addr *addr;
267 addr = talloc(mem_ctx, struct winsdb_addr);
269 status = NT_STATUS_NO_MEMORY;
273 address = (char *)val->data;
275 p = strchr(address, ';');
277 /* support old entries, with only the address */
278 addr->address = talloc_steal(addr, val->data);
279 addr->wins_owner = rec->wins_owner;
280 addr->expire_time = rec->expire_time;
286 addr->address = talloc_strdup(addr, address);
287 if (!addr->address) {
288 status = NT_STATUS_NO_MEMORY;
292 if (strncmp("winsOwner:", p, 10) != 0) {
293 status = NT_STATUS_INTERNAL_DB_CORRUPTION;
297 p = strchr(wins_owner, ';');
299 status = NT_STATUS_INTERNAL_DB_CORRUPTION;
304 addr->wins_owner = talloc_strdup(addr, wins_owner);
305 if (!addr->wins_owner) {
306 status = NT_STATUS_NO_MEMORY;
310 if (strncmp("expireTime:", p, 11) != 0) {
311 status = NT_STATUS_INTERNAL_DB_CORRUPTION;
315 expire_time = p + 11;
316 p = strchr(expire_time, ';');
318 status = NT_STATUS_INTERNAL_DB_CORRUPTION;
323 addr->expire_time = ldap_string_to_time(expire_time);
333 encode the winsdb_addr("address") attribute like this:
334 "172.31.1.1;winsOwner:172.31.9.202;expireTime:20050923032330.0Z;"
336 static int ldb_msg_add_winsdb_addr(struct ldb_context *ldb, struct ldb_message *msg,
337 const char *attr_name, struct winsdb_addr *addr)
342 str = talloc_asprintf(msg, "%s;winsOwner:%s;expireTime:%s;",
343 addr->address, addr->wins_owner,
344 ldap_timestring(msg, addr->expire_time));
347 val.data = discard_const_p(uint8_t, str);
348 val.length = strlen(str);
350 return ldb_msg_add_value(ldb, msg, attr_name, &val);
353 struct winsdb_addr **winsdb_addr_list_make(TALLOC_CTX *mem_ctx)
355 struct winsdb_addr **addresses;
357 addresses = talloc_array(mem_ctx, struct winsdb_addr *, 1);
358 if (!addresses) return NULL;
365 struct winsdb_addr **winsdb_addr_list_add(struct winsdb_addr **addresses, const char *address,
366 const char *wins_owner, time_t expire_time)
368 size_t len = winsdb_addr_list_length(addresses);
370 addresses = talloc_realloc(addresses, addresses, struct winsdb_addr *, len + 2);
371 if (!addresses) return NULL;
373 addresses[len] = talloc(addresses, struct winsdb_addr);
374 if (!addresses[len]) {
375 talloc_free(addresses);
379 addresses[len]->address = talloc_strdup(addresses[len], address);
380 if (!addresses[len]->address) {
381 talloc_free(addresses);
385 addresses[len]->wins_owner = talloc_strdup(addresses[len], wins_owner);
386 if (!addresses[len]->wins_owner) {
387 talloc_free(addresses);
391 addresses[len]->expire_time = expire_time;
393 addresses[len+1] = NULL;
398 void winsdb_addr_list_remove(struct winsdb_addr **addresses, const char *address)
402 for (i=0; addresses[i]; i++) {
403 if (strcmp(addresses[i]->address, address) == 0) {
407 if (!addresses[i]) return;
409 for (; addresses[i]; i++) {
410 addresses[i] = addresses[i+1];
416 struct winsdb_addr *winsdb_addr_list_check(struct winsdb_addr **addresses, const char *address)
420 for (i=0; addresses[i]; i++) {
421 if (strcmp(addresses[i]->address, address) == 0) {
429 size_t winsdb_addr_list_length(struct winsdb_addr **addresses)
432 for (i=0; addresses[i]; i++);
436 const char **winsdb_addr_string_list(TALLOC_CTX *mem_ctx, struct winsdb_addr **addresses)
438 size_t len = winsdb_addr_list_length(addresses);
439 const char **str_list;
442 str_list = talloc_array(mem_ctx, const char *, len + 1);
443 if (!str_list) return NULL;
445 for (i=0; i < len; i++) {
446 str_list[i] = talloc_strdup(str_list, addresses[i]->address);
448 talloc_free(str_list);
453 str_list[len] = NULL;
458 load a WINS entry from the database
460 NTSTATUS winsdb_lookup(struct ldb_context *wins_db,
461 struct nbt_name *name,
463 struct winsdb_record **_rec)
466 struct ldb_message **res = NULL;
468 struct winsdb_record *rec;
469 TALLOC_CTX *tmp_ctx = talloc_new(mem_ctx);
471 /* find the record in the WINS database */
472 ret = ldb_search(wins_db, winsdb_dn(tmp_ctx, name), LDB_SCOPE_BASE,
475 talloc_steal(tmp_ctx, res);
478 status = NT_STATUS_OBJECT_NAME_NOT_FOUND;
480 } else if (ret != 1) {
481 status = NT_STATUS_INTERNAL_DB_CORRUPTION;
485 status = winsdb_record(res[0], name, tmp_ctx, &rec);
486 if (!NT_STATUS_IS_OK(status)) goto failed;
488 /* see if it has already expired */
489 if (rec->state == WINS_REC_ACTIVE &&
490 rec->expire_time <= time(NULL)) {
491 DEBUG(5,("WINS: expiring name %s (expired at %s)\n",
492 nbt_name_string(tmp_ctx, rec->name), timestring(tmp_ctx, rec->expire_time)));
493 rec->state = WINS_REC_RELEASED;
496 talloc_steal(mem_ctx, rec);
497 talloc_free(tmp_ctx);
502 talloc_free(tmp_ctx);
506 NTSTATUS winsdb_record(struct ldb_message *msg, struct nbt_name *name, TALLOC_CTX *mem_ctx, struct winsdb_record **_rec)
509 struct winsdb_record *rec;
510 struct ldb_message_element *el;
513 rec = talloc(mem_ctx, struct winsdb_record);
515 status = NT_STATUS_NO_MEMORY;
520 status = winsdb_nbt_name(rec, msg->dn, &name);
521 if (!NT_STATUS_IS_OK(status)) goto failed;
524 /* parse it into a more convenient winsdb_record structure */
526 rec->state = ldb_msg_find_int(res[0], "active", WINS_REC_RELEASED);
527 rec->nb_flags = ldb_msg_find_int(res[0], "nbFlags", 0);
528 rec->expire_time = ldb_string_to_time(ldb_msg_find_string(res[0], "expires", NULL));
529 rec->registered_by = ldb_msg_find_string(res[0], "registeredBy", NULL);
530 rec->version = ldb_msg_find_uint64(res[0], "version", 0);
531 talloc_steal(rec, rec->wins_owner);
532 talloc_steal(rec, rec->registered_by);
534 if (!rec->wins_owner) rec->wins_owner = WINSDB_OWNER_LOCAL;
536 el = ldb_msg_find_element(msg, "address");
538 status = NT_STATUS_INTERNAL_DB_CORRUPTION;
542 rec->addresses = talloc_array(rec, struct winsdb_addr *, el->num_values+1);
543 if (rec->addresses == NULL) {
544 status = NT_STATUS_NO_MEMORY;
548 for (i=0;i<el->num_values;i++) {
549 status = winsdb_addr_decode(rec, &el->values[i], rec->addresses, &rec->addresses[i]);
550 if (!NT_STATUS_IS_OK(status)) goto failed;
552 rec->addresses[i] = NULL;
557 if (NT_STATUS_EQUAL(NT_STATUS_INTERNAL_DB_CORRUPTION, status)) {
558 DEBUG(1,("winsdb_record: corrupted record: %s\n", ldb_dn_linearize(rec, msg->dn)));
564 rec = talloc(mem_ctx, struct winsdb_record);
566 status = NT_STATUS_NO_MEMORY;
571 status = winsdb_nbt_name(rec, msg->dn, &name);
572 if (!NT_STATUS_IS_OK(status)) goto failed;
575 /* parse it into a more convenient winsdb_record structure */
577 rec->state = ldb_msg_find_int(msg, "state", WINS_REC_RELEASED);
578 rec->nb_flags = ldb_msg_find_int(msg, "nbFlags", 0);
579 rec->wins_owner = ldb_msg_find_string(msg, "winsOwner", NULL);
580 rec->expire_time = ldap_string_to_time(ldb_msg_find_string(msg, "expireTime", NULL));
581 rec->registered_by = ldb_msg_find_string(msg, "registeredBy", NULL);
582 rec->version = ldb_msg_find_uint64(msg, "versionID", 0);
583 talloc_steal(rec, rec->wins_owner);
584 talloc_steal(rec, rec->registered_by);
586 if (!rec->wins_owner) rec->wins_owner = WINSDB_OWNER_LOCAL;
588 el = ldb_msg_find_element(msg, "address");
590 status = NT_STATUS_INTERNAL_DB_CORRUPTION;
594 rec->addresses = talloc_array(rec, struct winsdb_addr *, el->num_values+1);
595 if (rec->addresses == NULL) {
596 status = NT_STATUS_NO_MEMORY;
600 for (i=0;i<el->num_values;i++) {
601 status = winsdb_addr_decode(rec, &el->values[i], rec->addresses, &rec->addresses[i]);
602 if (!NT_STATUS_IS_OK(status)) goto failed;
604 rec->addresses[i] = NULL;
609 if (NT_STATUS_EQUAL(NT_STATUS_INTERNAL_DB_CORRUPTION, status)) {
610 DEBUG(1,("winsdb_record: corrupted record: %s\n", ldb_dn_linearize(rec, msg->dn)));
617 form a ldb_message from a winsdb_record
619 struct ldb_message *winsdb_message(struct ldb_context *ldb,
620 struct winsdb_record *rec, TALLOC_CTX *mem_ctx)
623 struct ldb_message *msg = ldb_msg_new(mem_ctx);
624 if (msg == NULL) goto failed;
626 msg->dn = winsdb_dn(msg, rec->name);
627 if (msg->dn == NULL) goto failed;
628 ret |= ldb_msg_add_fmt(msg, "objectClass", "wins");
629 ret |= ldb_msg_add_fmt(msg, "active", "%u", rec->state);
630 ret |= ldb_msg_add_fmt(msg, "nbFlags", "0x%04x", rec->nb_flags);
631 ret |= ldb_msg_add_string(msg, "registeredBy", rec->registered_by);
632 ret |= ldb_msg_add_string(msg, "expires",
633 ldb_timestring(msg, rec->expire_time));
634 ret |= ldb_msg_add_fmt(msg, "version", "%llu", rec->version);
635 for (i=0;rec->addresses[i];i++) {
636 ret |= ldb_msg_add_string(msg, "address", rec->addresses[i]);
638 if (ret != 0) goto failed;
647 save a WINS record into the database
649 uint8_t winsdb_add(struct wins_server *winssrv, struct winsdb_record *rec)
651 struct ldb_context *ldb = winssrv->wins_db;
652 struct ldb_message *msg;
653 TALLOC_CTX *tmp_ctx = talloc_new(winssrv);
658 trans = ldb_transaction_start(ldb);
659 if (trans != LDB_SUCCESS) goto failed;
661 rec->version = winsdb_allocate_version(winssrv);
662 if (rec->version == 0) goto failed;
664 msg = winsdb_message(winssrv->wins_db, rec, tmp_ctx);
665 if (msg == NULL) goto failed;
666 ret = ldb_add(ldb, msg);
667 if (ret != 0) goto failed;
669 trans = ldb_transaction_commit(ldb);
670 if (trans != LDB_SUCCESS) goto failed;
672 talloc_free(tmp_ctx);
676 if (trans == LDB_SUCCESS) ldb_transaction_cancel(ldb);
677 talloc_free(tmp_ctx);
678 return NBT_RCODE_SVR;
683 modify a WINS record in the database
685 uint8_t winsdb_modify(struct wins_server *winssrv, struct winsdb_record *rec)
687 struct ldb_context *ldb = winssrv->wins_db;
688 struct ldb_message *msg;
689 TALLOC_CTX *tmp_ctx = talloc_new(winssrv);
694 trans = ldb_transaction_start(ldb);
695 if (trans != LDB_SUCCESS) goto failed;
697 rec->version = winsdb_allocate_version(winssrv);
698 if (rec->version == 0) goto failed;
699 rec->wins_owner = WINSDB_OWNER_LOCAL;
701 msg = winsdb_message(winssrv->wins_db, rec, tmp_ctx);
702 if (msg == NULL) goto failed;
704 for (i=0;i<msg->num_elements;i++) {
705 msg->elements[i].flags = LDB_FLAG_MOD_REPLACE;
708 ret = ldb_modify(ldb, msg);
709 if (ret != 0) goto failed;
711 trans = ldb_transaction_commit(ldb);
712 if (trans != LDB_SUCCESS) goto failed;
714 talloc_free(tmp_ctx);
718 if (trans == LDB_SUCCESS) ldb_transaction_cancel(ldb);
719 talloc_free(tmp_ctx);
720 return NBT_RCODE_SVR;
725 delete a WINS record from the database
727 uint8_t winsdb_delete(struct wins_server *winssrv, struct winsdb_record *rec)
729 struct ldb_context *ldb = winssrv->wins_db;
730 TALLOC_CTX *tmp_ctx = talloc_new(winssrv);
731 const struct ldb_dn *dn;
735 trans = ldb_transaction_start(ldb);
736 if (trans != LDB_SUCCESS) goto failed;
738 if(!winsdb_remove_version(winssrv, rec->version))
741 dn = winsdb_dn(tmp_ctx, rec->name);
742 if (dn == NULL) goto failed;
744 ret = ldb_delete(ldb, dn);
745 if (ret != 0) goto failed;
747 trans = ldb_transaction_commit(ldb);
748 if (trans != LDB_SUCCESS) goto failed;
750 talloc_free(tmp_ctx);
754 if (trans == LDB_SUCCESS) ldb_transaction_cancel(ldb);
755 talloc_free(tmp_ctx);
756 return NBT_RCODE_SVR;
759 struct ldb_context *winsdb_connect(TALLOC_CTX *mem_ctx)
761 return ldb_wrap_connect(mem_ctx, lp_wins_url(), 0, NULL);