source/nbt_server/wins/winsdb.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3
   4    WINS database routines
   5
   6    Copyright (C) Andrew Tridgell        2005
   7
   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.
  12
  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.
  17
  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.
  21 */
  22
  23 #include "includes.h"
  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"
  28 #include "db_wrap.h"
  29 #include "system/time.h"
  30
  31 /*
  32   return the new maxVersion and save it
  33 */
  34 static uint64_t winsdb_allocate_version(struct wins_server *winssrv)
  35 {
  36         int trans;
  37         int ret;
  38         struct ldb_context *ldb = winssrv->wins_db;
  39         struct ldb_dn *dn;
  40         struct ldb_message **res = NULL;
  41         struct ldb_message *msg = NULL;
  42         TALLOC_CTX *tmp_ctx = talloc_new(winssrv);
  43         uint64_t maxVersion = 0;
  44
  45         trans = ldb_transaction_start(ldb);
  46         if (trans != LDB_SUCCESS) goto failed;
  47
  48         dn = ldb_dn_explode(tmp_ctx, "CN=VERSION");
  49         if (!dn) goto failed;
  50
  51         /* find the record in the WINS database */
  52         ret = ldb_search(ldb, dn, LDB_SCOPE_BASE,
  53                          NULL, NULL, &res);
  54         if (res != NULL) {
  55                 talloc_steal(tmp_ctx, res);
  56         }
  57         if (ret < 0) goto failed;
  58         if (ret > 1) goto failed;
  59
  60         if (ret == 1) {
  61                 maxVersion = ldb_msg_find_uint64(res[0], "maxVersion", 0);
  62         }
  63         maxVersion++;
  64
  65         msg = ldb_msg_new(tmp_ctx);
  66         if (!msg) goto failed;
  67         msg->dn = dn;
  68
  69
  70         ret = ldb_msg_add_empty(msg, "objectClass", LDB_FLAG_MOD_REPLACE);
  71         if (ret != 0) goto failed;
  72         ret = ldb_msg_add_string(msg, "objectClass", "winsMaxVersion");
  73         if (ret != 0) goto failed;
  74         ret = ldb_msg_add_empty(msg, "maxVersion", LDB_FLAG_MOD_REPLACE);
  75         if (ret != 0) goto failed;
  76         ret = ldb_msg_add_fmt(msg, "maxVersion", "%llu", maxVersion);
  77         if (ret != 0) goto failed;
  78
  79         ret = ldb_modify(ldb, msg);
  80         if (ret != 0) ret = ldb_add(ldb, msg);
  81         if (ret != 0) goto failed;
  82
  83         trans = ldb_transaction_commit(ldb);
  84         if (trans != LDB_SUCCESS) goto failed;
  85
  86         talloc_free(tmp_ctx);
  87         return maxVersion;
  88
  89 failed:
  90         if (trans == LDB_SUCCESS) ldb_transaction_cancel(ldb);
  91         talloc_free(tmp_ctx);
  92         return 0;
  93 }
  94
  95 /*
  96   return a DN for a nbt_name
  97 */
  98 static struct ldb_dn *winsdb_dn(TALLOC_CTX *mem_ctx, struct nbt_name *name)
  99 {
 100         struct ldb_dn *dn;
 101
 102         dn = ldb_dn_string_compose(mem_ctx, NULL, "type=0x%02X", name->type);
 103         if (dn && name->name && *name->name) {
 104                 dn = ldb_dn_string_compose(mem_ctx, dn, "name=%s", name->name);
 105         }
 106         if (dn && name->scope && *name->scope) {
 107                 dn = ldb_dn_string_compose(mem_ctx, dn, "scope=%s", name->scope);
 108         }
 109         return dn;
 110 }
 111
 112 static NTSTATUS winsdb_nbt_name(TALLOC_CTX *mem_ctx, struct ldb_dn *dn, struct nbt_name **_name)
 113 {
 114         NTSTATUS status;
 115         struct nbt_name *name;
 116         uint32_t cur = 0;
 117
 118         name = talloc(mem_ctx, struct nbt_name);
 119         if (!name) {
 120                 status = NT_STATUS_NO_MEMORY;
 121                 goto failed;
 122         }
 123
 124         if (dn->comp_num > 3) {
 125                 status = NT_STATUS_INTERNAL_DB_CORRUPTION;
 126                 goto failed;
 127         }
 128
 129         if (dn->comp_num > cur && strcasecmp("scope", dn->components[cur].name) == 0) {
 130                 name->scope     = talloc_steal(name, dn->components[cur].value.data);
 131                 cur++;
 132         } else {
 133                 name->scope     = NULL;
 134         }
 135
 136         if (dn->comp_num > cur && strcasecmp("name", dn->components[cur].name) == 0) {
 137                 name->name      = talloc_steal(name, dn->components[cur].value.data);
 138                 cur++;
 139         } else {
 140                 name->name      = talloc_strdup(name, "");
 141                 if (!name->name) {
 142                         status = NT_STATUS_NO_MEMORY;
 143                         goto failed;
 144                 }
 145         }
 146
 147         if (dn->comp_num > cur && strcasecmp("type", dn->components[cur].name) == 0) {
 148                 name->type      = strtoul((char *)dn->components[cur].value.data, NULL, 0);
 149                 cur++;
 150         } else {
 151                 status = NT_STATUS_INTERNAL_DB_CORRUPTION;
 152                 goto failed;
 153         }
 154
 155         *_name = name;
 156         return NT_STATUS_OK;
 157 failed:
 158         talloc_free(name);
 159         return status;
 160 }
 161
 162 /*
 163  decode the winsdb_addr("address") attribute:
 164  "172.31.1.1" or
 165  "172.31.1.1;winsOwner:172.31.9.202;expireTime:20050923032330.0Z;"
 166  are valid records
 167 */
 168 static NTSTATUS winsdb_addr_decode(struct winsdb_record *rec, struct ldb_val *val,
 169                                    TALLOC_CTX *mem_ctx, struct winsdb_addr **_addr)
 170 {
 171         NTSTATUS status;
 172         struct winsdb_addr *addr;
 173         char *address;
 174         char *wins_owner;
 175         char *expire_time;
 176         char *p;
 177
 178         addr = talloc(mem_ctx, struct winsdb_addr);
 179         if (!addr) {
 180                 status = NT_STATUS_NO_MEMORY;
 181                 goto failed;
 182         }
 183
 184         address = (char *)val->data;
 185
 186         p = strchr(address, ';');
 187         if (!p) {
 188                 /* support old entries, with only the address */
 189                 addr->address           = talloc_steal(addr, val->data);
 190                 addr->wins_owner        = talloc_reference(addr, rec->wins_owner);
 191                 if (!addr->wins_owner) {
 192                         status = NT_STATUS_NO_MEMORY;
 193                         goto failed;
 194                 }
 195                 addr->expire_time       = rec->expire_time;
 196                 *_addr = addr;
 197                 return NT_STATUS_OK;
 198         }
 199
 200         *p = '\0';p++;
 201         addr->address = talloc_strdup(addr, address);
 202         if (!addr->address) {
 203                 status = NT_STATUS_NO_MEMORY;
 204                 goto failed;
 205         }
 206
 207         if (strncmp("winsOwner:", p, 10) != 0) {
 208                 status = NT_STATUS_INTERNAL_DB_CORRUPTION;
 209                 goto failed;
 210         }
 211         wins_owner = p + 10;
 212         p = strchr(wins_owner, ';');
 213         if (!p) {
 214                 status = NT_STATUS_INTERNAL_DB_CORRUPTION;
 215                 goto failed;
 216         }
 217
 218         *p = '\0';p++;
 219         addr->wins_owner = talloc_strdup(addr, wins_owner);
 220         if (!addr->wins_owner) {
 221                 status = NT_STATUS_NO_MEMORY;
 222                 goto failed;
 223         }
 224
 225         if (strncmp("expireTime:", p, 11) != 0) {
 226                 status = NT_STATUS_INTERNAL_DB_CORRUPTION;
 227                 goto failed;
 228         }
 229
 230         expire_time = p + 11;
 231         p = strchr(expire_time, ';');
 232         if (!p) {
 233                 status = NT_STATUS_INTERNAL_DB_CORRUPTION;
 234                 goto failed;
 235         }
 236
 237         *p = '\0';p++;
 238         addr->expire_time = ldb_string_to_time(expire_time);
 239
 240         *_addr = addr;
 241         return NT_STATUS_OK;
 242 failed:
 243         talloc_free(addr);
 244         return status;
 245 }
 246
 247 /*
 248  encode the winsdb_addr("address") attribute like this:
 249  "172.31.1.1;winsOwner:172.31.9.202;expireTime:20050923032330.0Z;"
 250 */
 251 static int ldb_msg_add_winsdb_addr(struct ldb_message *msg,
 252                                    const char *attr_name, struct winsdb_addr *addr)
 253 {
 254         struct ldb_val val;
 255         const char *str;
 256
 257         str = talloc_asprintf(msg, "%s;winsOwner:%s;expireTime:%s;",
 258                               addr->address, addr->wins_owner,
 259                               ldb_timestring(msg, addr->expire_time));
 260         if (!str) return -1;
 261
 262         val.data = discard_const_p(uint8_t, str);
 263         val.length = strlen(str);
 264
 265         return ldb_msg_add_value(msg, attr_name, &val);
 266 }
 267
 268 struct winsdb_addr **winsdb_addr_list_make(TALLOC_CTX *mem_ctx)
 269 {
 270         struct winsdb_addr **addresses;
 271
 272         addresses = talloc_array(mem_ctx, struct winsdb_addr *, 1);
 273         if (!addresses) return NULL;
 274
 275         addresses[0] = NULL;
 276
 277         return addresses;
 278 }
 279
 280 struct winsdb_addr **winsdb_addr_list_add(struct winsdb_addr **addresses, const char *address,
 281                                           const char *wins_owner, time_t expire_time)
 282 {
 283         size_t len = winsdb_addr_list_length(addresses);
 284
 285         addresses = talloc_realloc(addresses, addresses, struct winsdb_addr *, len + 2);
 286         if (!addresses) return NULL;
 287
 288         addresses[len] = talloc(addresses, struct winsdb_addr);
 289         if (!addresses[len]) {
 290                 talloc_free(addresses);
 291                 return NULL;
 292         }
 293
 294         addresses[len]->address = talloc_strdup(addresses[len], address);
 295         if (!addresses[len]->address) {
 296                 talloc_free(addresses);
 297                 return NULL;
 298         }
 299
 300         addresses[len]->wins_owner = talloc_strdup(addresses[len], wins_owner);
 301         if (!addresses[len]->wins_owner) {
 302                 talloc_free(addresses);
 303                 return NULL;
 304         }
 305
 306         addresses[len]->expire_time = expire_time;
 307
 308         addresses[len+1] = NULL;
 309
 310         return addresses;
 311 }
 312
 313 void winsdb_addr_list_remove(struct winsdb_addr **addresses, const char *address)
 314 {
 315         size_t i;
 316
 317         for (i=0; addresses[i]; i++) {
 318                 if (strcmp(addresses[i]->address, address) == 0) {
 319                         break;
 320                 }
 321         }
 322         if (!addresses[i]) return;
 323
 324         for (; addresses[i]; i++) {
 325                 addresses[i] = addresses[i+1];
 326         }
 327
 328         return;
 329 }
 330
 331 struct winsdb_addr *winsdb_addr_list_check(struct winsdb_addr **addresses, const char *address)
 332 {
 333         size_t i;
 334
 335         for (i=0; addresses[i]; i++) {
 336                 if (strcmp(addresses[i]->address, address) == 0) {
 337                         return addresses[i];
 338                 }
 339         }
 340
 341         return NULL;
 342 }
 343
 344 size_t winsdb_addr_list_length(struct winsdb_addr **addresses)
 345 {
 346         size_t i;
 347         for (i=0; addresses[i]; i++);
 348         return i;
 349 }
 350
 351 const char **winsdb_addr_string_list(TALLOC_CTX *mem_ctx, struct winsdb_addr **addresses)
 352 {
 353         size_t len = winsdb_addr_list_length(addresses);
 354         const char **str_list;
 355         size_t i;
 356
 357         str_list = talloc_array(mem_ctx, const char *, len + 1);
 358         if (!str_list) return NULL;
 359
 360         for (i=0; i < len; i++) {
 361                 str_list[i] = talloc_strdup(str_list, addresses[i]->address);
 362                 if (!str_list[i]) {
 363                         talloc_free(str_list);
 364                         return NULL;
 365                 }
 366         }
 367
 368         str_list[len] = NULL;
 369         return str_list;
 370 }
 371
 372 /*
 373   load a WINS entry from the database
 374 */
 375 NTSTATUS winsdb_lookup(struct ldb_context *wins_db,
 376                        struct nbt_name *name,
 377                        TALLOC_CTX *mem_ctx,
 378                        struct winsdb_record **_rec)
 379 {
 380         NTSTATUS status;
 381         struct ldb_message **res = NULL;
 382         int ret;
 383         struct winsdb_record *rec;
 384         TALLOC_CTX *tmp_ctx = talloc_new(mem_ctx);
 385
 386         /* find the record in the WINS database */
 387         ret = ldb_search(wins_db, winsdb_dn(tmp_ctx, name), LDB_SCOPE_BASE,
 388                          NULL, NULL, &res);
 389         if (res != NULL) {
 390                 talloc_steal(tmp_ctx, res);
 391         }
 392         if (ret == 0) {
 393                 status = NT_STATUS_OBJECT_NAME_NOT_FOUND;
 394                 goto failed;
 395         } else if (ret != 1) {
 396                 status = NT_STATUS_INTERNAL_DB_CORRUPTION;
 397                 goto failed;
 398         }
 399
 400         status = winsdb_record(res[0], name, tmp_ctx, &rec);
 401         if (!NT_STATUS_IS_OK(status)) goto failed;
 402
 403         /* see if it has already expired */
 404         if (rec->state == WREPL_STATE_ACTIVE &&
 405             rec->expire_time <= time(NULL)) {
 406                 DEBUG(5,("WINS: expiring name %s (expired at %s)\n",
 407                          nbt_name_string(tmp_ctx, rec->name), timestring(tmp_ctx, rec->expire_time)));
 408                 rec->state = WREPL_STATE_RELEASED;
 409         }
 410
 411         talloc_steal(mem_ctx, rec);
 412         talloc_free(tmp_ctx);
 413         *_rec = rec;
 414         return NT_STATUS_OK;
 415
 416 failed:
 417         talloc_free(tmp_ctx);
 418         return status;
 419 }
 420
 421 NTSTATUS winsdb_record(struct ldb_message *msg, struct nbt_name *name, TALLOC_CTX *mem_ctx, struct winsdb_record **_rec)
 422 {
 423         NTSTATUS status;
 424         struct winsdb_record *rec;
 425         struct ldb_message_element *el;
 426         uint32_t i;
 427
 428         rec = talloc(mem_ctx, struct winsdb_record);
 429         if (rec == NULL) {
 430                 status = NT_STATUS_NO_MEMORY;
 431                 goto failed;
 432         }
 433
 434         if (!name) {
 435                 status = winsdb_nbt_name(rec, msg->dn, &name);
 436                 if (!NT_STATUS_IS_OK(status)) goto failed;
 437         }
 438
 439         if (strlen(name->name) > 15) {
 440                 status = NT_STATUS_INTERNAL_DB_CORRUPTION;
 441                 goto failed;
 442         }
 443         if (name->scope && strlen(name->scope) > 238) {
 444                 status = NT_STATUS_INTERNAL_DB_CORRUPTION;
 445                 goto failed;
 446         }
 447
 448         /* parse it into a more convenient winsdb_record structure */
 449         rec->name               = name;
 450         rec->type               = ldb_msg_find_int(msg, "recordType", WREPL_TYPE_UNIQUE);
 451         rec->state              = ldb_msg_find_int(msg, "recordState", WREPL_STATE_RELEASED);
 452         rec->node               = ldb_msg_find_int(msg, "nodeType", WREPL_NODE_B);
 453         rec->is_static          = ldb_msg_find_int(msg, "isStatic", 0);
 454         rec->expire_time        = ldb_string_to_time(ldb_msg_find_string(msg, "expireTime", NULL));
 455         rec->version            = ldb_msg_find_uint64(msg, "versionID", 0);
 456         rec->wins_owner         = ldb_msg_find_string(msg, "winsOwner", NULL);
 457         rec->registered_by      = ldb_msg_find_string(msg, "registeredBy", NULL);
 458         talloc_steal(rec, rec->wins_owner);
 459         talloc_steal(rec, rec->registered_by);
 460
 461         if (!rec->wins_owner) {
 462                 rec->wins_owner = talloc_strdup(rec, WINSDB_OWNER_LOCAL);
 463                 if (rec->wins_owner == NULL) {
 464                         status = NT_STATUS_NO_MEMORY;
 465                         goto failed;
 466                 }
 467         }
 468
 469         el = ldb_msg_find_element(msg, "address");
 470         if (el == NULL) {
 471                 status = NT_STATUS_INTERNAL_DB_CORRUPTION;
 472                 goto failed;
 473         }
 474
 475         if (rec->type == WREPL_TYPE_UNIQUE || rec->type == WREPL_TYPE_GROUP) {
 476                 if (el->num_values != 1) {
 477                         status = NT_STATUS_INTERNAL_DB_CORRUPTION;
 478                         goto failed;
 479                 }
 480         }
 481
 482         rec->addresses     = talloc_array(rec, struct winsdb_addr *, el->num_values+1);
 483         if (rec->addresses == NULL) {
 484                 status = NT_STATUS_NO_MEMORY;
 485                 goto failed;
 486         }
 487
 488         for (i=0;i<el->num_values;i++) {
 489                 status = winsdb_addr_decode(rec, &el->values[i], rec->addresses, &rec->addresses[i]);
 490                 if (!NT_STATUS_IS_OK(status)) goto failed;
 491         }
 492         rec->addresses[i] = NULL;
 493
 494         *_rec = rec;
 495         return NT_STATUS_OK;
 496 failed:
 497         if (NT_STATUS_EQUAL(NT_STATUS_INTERNAL_DB_CORRUPTION, status)) {
 498                 DEBUG(1,("winsdb_record: corrupted record: %s\n", ldb_dn_linearize(rec, msg->dn)));
 499         }
 500         talloc_free(rec);
 501         return status;
 502 }
 503
 504 /*
 505   form a ldb_message from a winsdb_record
 506 */
 507 struct ldb_message *winsdb_message(struct ldb_context *ldb,
 508                                    struct winsdb_record *rec, TALLOC_CTX *mem_ctx)
 509 {
 510         int i, ret=0;
 511         struct ldb_message *msg = ldb_msg_new(mem_ctx);
 512         if (msg == NULL) goto failed;
 513
 514         msg->dn = winsdb_dn(msg, rec->name);
 515         if (msg->dn == NULL) goto failed;
 516         ret |= ldb_msg_add_fmt(msg, "type", "0x%02X", rec->name->type);
 517         if (rec->name->name) {
 518                 ret |= ldb_msg_add_string(msg, "name", rec->name->name);
 519         }
 520         if (rec->name->scope) {
 521                 ret |= ldb_msg_add_string(msg, "scope", rec->name->scope);
 522         }
 523         ret |= ldb_msg_add_fmt(msg, "objectClass", "winsRecord");
 524         ret |= ldb_msg_add_fmt(msg, "recordType", "%u", rec->type);
 525         ret |= ldb_msg_add_fmt(msg, "recordState", "%u", rec->state);
 526         ret |= ldb_msg_add_fmt(msg, "nodeType", "%u", rec->node);
 527         ret |= ldb_msg_add_fmt(msg, "isStatic", "%u", rec->is_static);
 528         ret |= ldb_msg_add_string(msg, "expireTime",
 529                                   ldb_timestring(msg, rec->expire_time));
 530         ret |= ldb_msg_add_fmt(msg, "versionID", "%llu", rec->version);
 531         ret |= ldb_msg_add_string(msg, "winsOwner", rec->wins_owner);
 532         for (i=0;rec->addresses[i];i++) {
 533                 ret |= ldb_msg_add_winsdb_addr(msg, "address", rec->addresses[i]);
 534         }
 535         ret |= ldb_msg_add_string(msg, "registeredBy", rec->registered_by);
 536         if (ret != 0) goto failed;
 537         return msg;
 538
 539 failed:
 540         talloc_free(msg);
 541         return NULL;
 542 }
 543
 544 /*
 545   save a WINS record into the database
 546 */
 547 uint8_t winsdb_add(struct wins_server *winssrv, struct winsdb_record *rec)
 548 {
 549         struct ldb_context *ldb = winssrv->wins_db;
 550         struct ldb_message *msg;
 551         TALLOC_CTX *tmp_ctx = talloc_new(winssrv);
 552         int trans = -1;
 553         int ret = 0;
 554
 555         trans = ldb_transaction_start(ldb);
 556         if (trans != LDB_SUCCESS) goto failed;
 557
 558         rec->version = winsdb_allocate_version(winssrv);
 559         if (rec->version == 0) goto failed;
 560         rec->wins_owner = WINSDB_OWNER_LOCAL;
 561
 562         msg = winsdb_message(winssrv->wins_db, rec, tmp_ctx);
 563         if (msg == NULL) goto failed;
 564         ret = ldb_add(ldb, msg);
 565         if (ret != 0) goto failed;
 566
 567         trans = ldb_transaction_commit(ldb);
 568         if (trans != LDB_SUCCESS) goto failed;
 569
 570         talloc_free(tmp_ctx);
 571         return NBT_RCODE_OK;
 572
 573 failed:
 574         if (trans == LDB_SUCCESS) ldb_transaction_cancel(ldb);
 575         talloc_free(tmp_ctx);
 576         return NBT_RCODE_SVR;
 577 }
 578
 579
 580 /*
 581   modify a WINS record in the database
 582 */
 583 uint8_t winsdb_modify(struct wins_server *winssrv, struct winsdb_record *rec)
 584 {
 585         struct ldb_context *ldb = winssrv->wins_db;
 586         struct ldb_message *msg;
 587         TALLOC_CTX *tmp_ctx = talloc_new(winssrv);
 588         int trans;
 589         int ret;
 590         int i;
 591
 592         trans = ldb_transaction_start(ldb);
 593         if (trans != LDB_SUCCESS) goto failed;
 594
 595         rec->version = winsdb_allocate_version(winssrv);
 596         if (rec->version == 0) goto failed;
 597         rec->wins_owner = WINSDB_OWNER_LOCAL;
 598
 599         msg = winsdb_message(winssrv->wins_db, rec, tmp_ctx);
 600         if (msg == NULL) goto failed;
 601
 602         for (i=0;i<msg->num_elements;i++) {
 603                 msg->elements[i].flags = LDB_FLAG_MOD_REPLACE;
 604         }
 605
 606         ret = ldb_modify(ldb, msg);
 607         if (ret != 0) goto failed;
 608
 609         trans = ldb_transaction_commit(ldb);
 610         if (trans != LDB_SUCCESS) goto failed;
 611
 612         talloc_free(tmp_ctx);
 613         return NBT_RCODE_OK;
 614
 615 failed:
 616         if (trans == LDB_SUCCESS) ldb_transaction_cancel(ldb);
 617         talloc_free(tmp_ctx);
 618         return NBT_RCODE_SVR;
 619 }
 620
 621
 622 /*
 623   delete a WINS record from the database
 624 */
 625 uint8_t winsdb_delete(struct wins_server *winssrv, struct winsdb_record *rec)
 626 {
 627         struct ldb_context *ldb = winssrv->wins_db;
 628         TALLOC_CTX *tmp_ctx = talloc_new(winssrv);
 629         const struct ldb_dn *dn;
 630         int trans;
 631         int ret;
 632
 633         trans = ldb_transaction_start(ldb);
 634         if (trans != LDB_SUCCESS) goto failed;
 635
 636         dn = winsdb_dn(tmp_ctx, rec->name);
 637         if (dn == NULL) goto failed;
 638
 639         ret = ldb_delete(ldb, dn);
 640         if (ret != 0) goto failed;
 641
 642         trans = ldb_transaction_commit(ldb);
 643         if (trans != LDB_SUCCESS) goto failed;
 644
 645         talloc_free(tmp_ctx);
 646         return NBT_RCODE_OK;
 647
 648 failed:
 649         if (trans == LDB_SUCCESS) ldb_transaction_cancel(ldb);
 650         talloc_free(tmp_ctx);
 651         return NBT_RCODE_SVR;
 652 }
 653
 654 struct ldb_context *winsdb_connect(TALLOC_CTX *mem_ctx)
 655 {
 656         return ldb_wrap_connect(mem_ctx, lp_wins_url(), 0, NULL);
 657 }