source4/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 ret;
  37         struct ldb_context *ldb = winssrv->wins_db;
  38         struct ldb_dn *dn;
  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;
  43
  44         dn = ldb_dn_explode(tmp_ctx, "CN=VERSION");
  45         if (!dn) goto failed;
  46
  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;
  51
  52         if (ret == 1) {
  53                 maxVersion = ldb_msg_find_uint64(res[0], "maxVersion", 0);
  54         }
  55         maxVersion++;
  56
  57         msg = ldb_msg_new(tmp_ctx);
  58         if (!msg) goto failed;
  59         msg->dn = dn;
  60
  61
  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;
  66
  67         ret = ldb_modify(ldb, msg);
  68         if (ret != 0) ret = ldb_add(ldb, msg);
  69         if (ret != 0) goto failed;
  70
  71         talloc_free(tmp_ctx);
  72         return maxVersion;
  73
  74 failed:
  75         talloc_free(tmp_ctx);
  76         return 0;
  77 }
  78
  79 /*
  80   return a DN for a nbt_name
  81 */
  82 static struct ldb_dn *winsdb_dn(TALLOC_CTX *mem_ctx, struct nbt_name *name)
  83 {
  84         struct ldb_dn *dn;
  85
  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);
  89         }
  90         if (dn && name->scope && *name->scope) {
  91                 dn = ldb_dn_string_compose(mem_ctx, dn, "scope=%s", name->scope);
  92         }
  93         return dn;
  94 }
  95
  96 static NTSTATUS winsdb_nbt_name(TALLOC_CTX *mem_ctx, struct ldb_dn *dn, struct nbt_name **_name)
  97 {
  98         NTSTATUS status;
  99         struct nbt_name *name;
 100         uint32_t cur = 0;
 101
 102         name = talloc(mem_ctx, struct nbt_name);
 103         if (!name) {
 104                 status = NT_STATUS_NO_MEMORY;
 105                 goto failed;
 106         }
 107
 108         if (dn->comp_num > 3) {
 109                 status = NT_STATUS_INTERNAL_DB_CORRUPTION;
 110                 goto failed;
 111         }
 112
 113         if (dn->comp_num > cur && strcasecmp("scope", dn->components[cur].name) == 0) {
 114                 name->scope     = talloc_steal(name, dn->components[cur].value.data);
 115                 cur++;
 116         } else {
 117                 name->scope     = NULL;
 118         }
 119
 120         if (dn->comp_num > cur && strcasecmp("name", dn->components[cur].name) == 0) {
 121                 name->name      = talloc_steal(name, dn->components[cur].value.data);
 122                 cur++;
 123         } else {
 124                 name->name      = talloc_strdup(name, "");
 125                 if (!name->name) {
 126                         status = NT_STATUS_NO_MEMORY;
 127                         goto failed;
 128                 }
 129         }
 130
 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);
 133                 cur++;
 134         } else {
 135                 status = NT_STATUS_INTERNAL_DB_CORRUPTION;
 136                 goto failed;
 137         }
 138
 139         *_name = name;
 140         return NT_STATUS_OK;
 141 failed:
 142         talloc_free(name);
 143         return status;
 144 }
 145
 146 /*
 147  decode the winsdb_addr("address") attribute:
 148  "172.31.1.1" or
 149  "172.31.1.1;winsOwner:172.31.9.202;expireTime:20050923032330.0Z;"
 150  are valid records
 151 */
 152 static BOOL winsdb_remove_version(struct wins_server *winssrv, uint64_t version)
 153 {
 154         if (version == winssrv->min_version) {
 155                 winssrv->min_version++;
 156                 return winsdb_save_version(winssrv);
 157         }
 158
 159         return True;
 160 }
 161
 162 /*
 163  encode the winsdb_addr("address") attribute like this:
 164  "172.31.1.1;winsOwner:172.31.9.202;expireTime:20050923032330.0Z"
 165 */
 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)
 168 {
 169         struct ldb_val val;
 170         const char *str;
 171
 172         dn = ldb_dn_string_compose(mem_ctx, NULL, "type=%02x", name->type);
 173
 174         addresses[len]->address = talloc_strdup(addresses[len], address);
 175         if (!addresses[len]->address) {
 176                 talloc_free(addresses);
 177                 return NULL;
 178         }
 179
 180         addresses[len]->wins_owner = talloc_strdup(addresses[len], wins_owner);
 181         if (!addresses[len]->wins_owner) {
 182                 talloc_free(addresses);
 183                 return NULL;
 184         }
 185
 186         addresses[len]->expire_time = expire_time;
 187
 188         addresses[len+1] = NULL;
 189
 190         return addresses;
 191 }
 192
 193 void winsdb_addr_list_remove(struct winsdb_addr **addresses, const char *address)
 194 {
 195         size_t i;
 196
 197         for (i=0; addresses[i]; i++) {
 198                 if (strcmp(addresses[i]->address, address) == 0) {
 199                         break;
 200                 }
 201         }
 202         if (!addresses[i]) return;
 203
 204         for (; addresses[i]; i++) {
 205                 addresses[i] = addresses[i+1];
 206         }
 207
 208         return;
 209 }
 210
 211 struct winsdb_addr *winsdb_addr_list_check(struct winsdb_addr **addresses, const char *address)
 212 {
 213         size_t i;
 214
 215         for (i=0; addresses[i]; i++) {
 216                 if (strcmp(addresses[i]->address, address) == 0) {
 217                         return addresses[i];
 218                 }
 219         }
 220
 221         return NULL;
 222 }
 223
 224 size_t winsdb_addr_list_length(struct winsdb_addr **addresses)
 225 {
 226         size_t i;
 227         for (i=0; addresses[i]; i++);
 228         return i;
 229 }
 230
 231 const char **winsdb_addr_string_list(TALLOC_CTX *mem_ctx, struct winsdb_addr **addresses)
 232 {
 233         size_t len = winsdb_addr_list_length(addresses);
 234         const char **str_list;
 235         size_t i;
 236
 237         str_list = talloc_array(mem_ctx, const char *, len + 1);
 238         if (!str_list) return NULL;
 239
 240         for (i=0; i < len; i++) {
 241                 str_list[i] = talloc_strdup(str_list, addresses[i]->address);
 242                 if (!str_list[i]) {
 243                         talloc_free(str_list);
 244                         return NULL;
 245                 }
 246         }
 247
 248         str_list[len] = NULL;
 249         return str_list;
 250 }
 251
 252 /*
 253  decode the winsdb_addr("address") attribute:
 254  "172.31.1.1" or
 255  "172.31.1.1;winsOwner:172.31.9.202;expireTime:20050923032330.0Z"
 256  are valid records
 257 */
 258 static struct winsdb_addr *winsdb_addr_decode(struct winsdb_record *rec, TALLOC_CTX *mem_ctx, struct ldb_val *val)
 259 {
 260         NTSTATUS status;
 261         struct winsdb_addr *addr;
 262         char *address;
 263         char *wins_owner;
 264         char *expire_time;
 265         char *p;
 266
 267         addr = talloc(mem_ctx, struct winsdb_addr);
 268         if (!addr) {
 269                 status = NT_STATUS_NO_MEMORY;
 270                 goto failed;
 271         }
 272
 273         address = (char *)val->data;
 274
 275         p = strchr(address, ';');
 276         if (!p) {
 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;
 281                 *_addr = addr;
 282                 return NT_STATUS_OK;
 283         }
 284
 285         *p = '\0';p++;
 286         addr->address = talloc_strdup(addr, address);
 287         if (!addr->address) {
 288                 status = NT_STATUS_NO_MEMORY;
 289                 goto failed;
 290         }
 291
 292         if (strncmp("winsOwner:", p, 10) != 0) {
 293                 status = NT_STATUS_INTERNAL_DB_CORRUPTION;
 294                 goto failed;
 295         }
 296         wins_owner = p + 10;
 297         p = strchr(wins_owner, ';');
 298         if (!p) {
 299                 status = NT_STATUS_INTERNAL_DB_CORRUPTION;
 300                 goto failed;
 301         }
 302
 303         *p = '\0';p++;
 304         addr->wins_owner = talloc_strdup(addr, wins_owner);
 305         if (!addr->wins_owner) {
 306                 status = NT_STATUS_NO_MEMORY;
 307                 goto failed;
 308         }
 309
 310         if (strncmp("expireTime:", p, 11) != 0) {
 311                 status = NT_STATUS_INTERNAL_DB_CORRUPTION;
 312                 goto failed;
 313         }
 314
 315         expire_time = p + 11;
 316         p = strchr(expire_time, ';');
 317         if (!p) {
 318                 status = NT_STATUS_INTERNAL_DB_CORRUPTION;
 319                 goto failed;
 320         }
 321
 322         *p = '\0';p++;
 323         addr->expire_time = ldap_string_to_time(expire_time);
 324
 325         *_addr = addr;
 326         return NT_STATUS_OK;
 327 failed:
 328         talloc_free(addr);
 329         return status;
 330 }
 331
 332 /*
 333  encode the winsdb_addr("address") attribute like this:
 334  "172.31.1.1;winsOwner:172.31.9.202;expireTime:20050923032330.0Z;"
 335 */
 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)
 338 {
 339         struct ldb_val val;
 340         const char *str;
 341
 342         str = talloc_asprintf(msg, "%s;winsOwner:%s;expireTime:%s;",
 343                               addr->address, addr->wins_owner,
 344                               ldap_timestring(msg, addr->expire_time));
 345         if (!str) return -1;
 346
 347         val.data = discard_const_p(uint8_t, str);
 348         val.length = strlen(str);
 349
 350         return ldb_msg_add_value(ldb, msg, attr_name, &val);
 351 }
 352
 353 struct winsdb_addr **winsdb_addr_list_make(TALLOC_CTX *mem_ctx)
 354 {
 355         struct winsdb_addr **addresses;
 356
 357         addresses = talloc_array(mem_ctx, struct winsdb_addr *, 1);
 358         if (!addresses) return NULL;
 359
 360         addresses[0] = NULL;
 361
 362         return addresses;
 363 }
 364
 365 struct winsdb_addr **winsdb_addr_list_add(struct winsdb_addr **addresses, const char *address,
 366                                           const char *wins_owner, time_t expire_time)
 367 {
 368         size_t len = winsdb_addr_list_length(addresses);
 369
 370         addresses = talloc_realloc(addresses, addresses, struct winsdb_addr *, len + 2);
 371         if (!addresses) return NULL;
 372
 373         addresses[len] = talloc(addresses, struct winsdb_addr);
 374         if (!addresses[len]) {
 375                 talloc_free(addresses);
 376                 return NULL;
 377         }
 378
 379         addresses[len]->address = talloc_strdup(addresses[len], address);
 380         if (!addresses[len]->address) {
 381                 talloc_free(addresses);
 382                 return NULL;
 383         }
 384
 385         addresses[len]->wins_owner = talloc_strdup(addresses[len], wins_owner);
 386         if (!addresses[len]->wins_owner) {
 387                 talloc_free(addresses);
 388                 return NULL;
 389         }
 390
 391         addresses[len]->expire_time = expire_time;
 392
 393         addresses[len+1] = NULL;
 394
 395         return addresses;
 396 }
 397
 398 void winsdb_addr_list_remove(struct winsdb_addr **addresses, const char *address)
 399 {
 400         size_t i;
 401
 402         for (i=0; addresses[i]; i++) {
 403                 if (strcmp(addresses[i]->address, address) == 0) {
 404                         break;
 405                 }
 406         }
 407         if (!addresses[i]) return;
 408
 409         for (; addresses[i]; i++) {
 410                 addresses[i] = addresses[i+1];
 411         }
 412
 413         return;
 414 }
 415
 416 struct winsdb_addr *winsdb_addr_list_check(struct winsdb_addr **addresses, const char *address)
 417 {
 418         size_t i;
 419
 420         for (i=0; addresses[i]; i++) {
 421                 if (strcmp(addresses[i]->address, address) == 0) {
 422                         return addresses[i];
 423                 }
 424         }
 425
 426         return NULL;
 427 }
 428
 429 size_t winsdb_addr_list_length(struct winsdb_addr **addresses)
 430 {
 431         size_t i;
 432         for (i=0; addresses[i]; i++);
 433         return i;
 434 }
 435
 436 const char **winsdb_addr_string_list(TALLOC_CTX *mem_ctx, struct winsdb_addr **addresses)
 437 {
 438         size_t len = winsdb_addr_list_length(addresses);
 439         const char **str_list;
 440         size_t i;
 441
 442         str_list = talloc_array(mem_ctx, const char *, len + 1);
 443         if (!str_list) return NULL;
 444
 445         for (i=0; i < len; i++) {
 446                 str_list[i] = talloc_strdup(str_list, addresses[i]->address);
 447                 if (!str_list[i]) {
 448                         talloc_free(str_list);
 449                         return NULL;
 450                 }
 451         }
 452
 453         str_list[len] = NULL;
 454         return str_list;
 455 }
 456
 457 /*
 458   load a WINS entry from the database
 459 */
 460 NTSTATUS winsdb_lookup(struct ldb_context *wins_db,
 461                        struct nbt_name *name,
 462                        TALLOC_CTX *mem_ctx,
 463                        struct winsdb_record **_rec)
 464 {
 465         NTSTATUS status;
 466         struct ldb_message **res = NULL;
 467         int ret;
 468         struct winsdb_record *rec;
 469         TALLOC_CTX *tmp_ctx = talloc_new(mem_ctx);
 470
 471         /* find the record in the WINS database */
 472         ret = ldb_search(wins_db, winsdb_dn(tmp_ctx, name), LDB_SCOPE_BASE,
 473                          NULL, NULL, &res);
 474         if (res != NULL) {
 475                 talloc_steal(tmp_ctx, res);
 476         }
 477         if (ret == 0) {
 478                 status = NT_STATUS_OBJECT_NAME_NOT_FOUND;
 479                 goto failed;
 480         } else if (ret != 1) {
 481                 status = NT_STATUS_INTERNAL_DB_CORRUPTION;
 482                 goto failed;
 483         }
 484
 485         status = winsdb_record(res[0], name, tmp_ctx, &rec);
 486         if (!NT_STATUS_IS_OK(status)) goto failed;
 487
 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;
 494         }
 495
 496         talloc_steal(mem_ctx, rec);
 497         talloc_free(tmp_ctx);
 498         *_rec = rec;
 499         return NT_STATUS_OK;
 500
 501 failed:
 502         talloc_free(tmp_ctx);
 503         return status;
 504 }
 505
 506 NTSTATUS winsdb_record(struct ldb_message *msg, struct nbt_name *name, TALLOC_CTX *mem_ctx, struct winsdb_record **_rec)
 507 {
 508         NTSTATUS status;
 509         struct winsdb_record *rec;
 510         struct ldb_message_element *el;
 511         uint32_t i;
 512
 513         rec = talloc(mem_ctx, struct winsdb_record);
 514         if (rec == NULL) {
 515                 status = NT_STATUS_NO_MEMORY;
 516                 goto failed;
 517         }
 518
 519         if (!name) {
 520                 status = winsdb_nbt_name(rec, msg->dn, &name);
 521                 if (!NT_STATUS_IS_OK(status)) goto failed;
 522         }
 523
 524         /* parse it into a more convenient winsdb_record structure */
 525         rec->name           = name;
 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);
 533
 534         if (!rec->wins_owner) rec->wins_owner = WINSDB_OWNER_LOCAL;
 535
 536         el = ldb_msg_find_element(msg, "address");
 537         if (el == NULL) {
 538                 status = NT_STATUS_INTERNAL_DB_CORRUPTION;
 539                 goto failed;
 540         }
 541
 542         rec->addresses     = talloc_array(rec, struct winsdb_addr *, el->num_values+1);
 543         if (rec->addresses == NULL) {
 544                 status = NT_STATUS_NO_MEMORY;
 545                 goto failed;
 546         }
 547
 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;
 551         }
 552         rec->addresses[i] = NULL;
 553
 554         *_rec = rec;
 555         return NT_STATUS_OK;
 556 failed:
 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)));
 559         }
 560         talloc_free(rec);
 561         return status;
 562 }
 563
 564         rec = talloc(mem_ctx, struct winsdb_record);
 565         if (rec == NULL) {
 566                 status = NT_STATUS_NO_MEMORY;
 567                 goto failed;
 568         }
 569
 570         if (!name) {
 571                 status = winsdb_nbt_name(rec, msg->dn, &name);
 572                 if (!NT_STATUS_IS_OK(status)) goto failed;
 573         }
 574
 575         /* parse it into a more convenient winsdb_record structure */
 576         rec->name           = name;
 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);
 585
 586         if (!rec->wins_owner) rec->wins_owner = WINSDB_OWNER_LOCAL;
 587
 588         el = ldb_msg_find_element(msg, "address");
 589         if (el == NULL) {
 590                 status = NT_STATUS_INTERNAL_DB_CORRUPTION;
 591                 goto failed;
 592         }
 593
 594         rec->addresses     = talloc_array(rec, struct winsdb_addr *, el->num_values+1);
 595         if (rec->addresses == NULL) {
 596                 status = NT_STATUS_NO_MEMORY;
 597                 goto failed;
 598         }
 599
 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;
 603         }
 604         rec->addresses[i] = NULL;
 605
 606         *_rec = rec;
 607         return NT_STATUS_OK;
 608 failed:
 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)));
 611         }
 612         talloc_free(rec);
 613         return status;
 614 }
 615
 616         rec = talloc(mem_ctx, struct winsdb_record);
 617         if (rec == NULL) {
 618                 status = NT_STATUS_NO_MEMORY;
 619                 goto failed;
 620         }
 621
 622         if (!name) {
 623                 status = winsdb_nbt_name(rec, msg->dn, &name);
 624                 if (!NT_STATUS_IS_OK(status)) goto failed;
 625         }
 626
 627         /* parse it into a more convenient winsdb_record structure */
 628         rec->name           = name;
 629         rec->state          = ldb_msg_find_int(msg, "state", WINS_REC_RELEASED);
 630         rec->nb_flags       = ldb_msg_find_int(msg, "nbFlags", 0);
 631         rec->wins_owner     = ldb_msg_find_string(msg, "winsOwner", NULL);
 632         rec->expire_time    = ldap_string_to_time(ldb_msg_find_string(msg, "expireTime", NULL));
 633         rec->registered_by  = ldb_msg_find_string(msg, "registeredBy", NULL);
 634         rec->version        = ldb_msg_find_uint64(msg, "versionID", 0);
 635         talloc_steal(rec, rec->wins_owner);
 636         talloc_steal(rec, rec->registered_by);
 637
 638         if (!rec->wins_owner) rec->wins_owner = WINSDB_OWNER_LOCAL;
 639
 640         el = ldb_msg_find_element(msg, "address");
 641         if (el == NULL) {
 642                 status = NT_STATUS_INTERNAL_DB_CORRUPTION;
 643                 goto failed;
 644         }
 645
 646         rec->addresses     = talloc_array(rec, struct winsdb_addr *, el->num_values+1);
 647         if (rec->addresses == NULL) {
 648                 status = NT_STATUS_NO_MEMORY;
 649                 goto failed;
 650         }
 651
 652         for (i=0;i<el->num_values;i++) {
 653                 status = winsdb_addr_decode(rec, &el->values[i], rec->addresses, &rec->addresses[i]);
 654                 if (!NT_STATUS_IS_OK(status)) goto failed;
 655         }
 656         rec->addresses[i] = NULL;
 657
 658         *_rec = rec;
 659         return NT_STATUS_OK;
 660 failed:
 661         if (NT_STATUS_EQUAL(NT_STATUS_INTERNAL_DB_CORRUPTION, status)) {
 662                 DEBUG(1,("winsdb_record: corrupted record: %s\n", ldb_dn_linearize(rec, msg->dn)));
 663         }
 664         talloc_free(rec);
 665         return status;
 666 }
 667
 668 /*
 669   form a ldb_message from a winsdb_record
 670 */
 671 struct ldb_message *winsdb_message(struct ldb_context *ldb,
 672                                    struct winsdb_record *rec, TALLOC_CTX *mem_ctx)
 673 {
 674         int i, ret=0;
 675         struct ldb_message *msg = ldb_msg_new(mem_ctx);
 676         if (msg == NULL) goto failed;
 677
 678         msg->dn = winsdb_dn(msg, rec->name);
 679         if (msg->dn == NULL) goto failed;
 680         ret |= ldb_msg_add_fmt(msg, "objectClass", "wins");
 681         ret |= ldb_msg_add_fmt(msg, "active", "%u", rec->state);
 682         ret |= ldb_msg_add_fmt(msg, "nbFlags", "0x%04x", rec->nb_flags);
 683         ret |= ldb_msg_add_string(msg, "registeredBy", rec->registered_by);
 684         ret |= ldb_msg_add_string(msg, "expires",
 685                                   ldb_timestring(msg, rec->expire_time));
 686         ret |= ldb_msg_add_fmt(msg, "version", "%llu", rec->version);
 687         for (i=0;rec->addresses[i];i++) {
 688                 ret |= ldb_msg_add_string(msg, "address", rec->addresses[i]);
 689         }
 690         if (ret != 0) goto failed;
 691         return msg;
 692
 693 failed:
 694         talloc_free(msg);
 695         return NULL;
 696 }
 697
 698 /*
 699   save a WINS record into the database
 700 */
 701 uint8_t winsdb_add(struct wins_server *winssrv, struct winsdb_record *rec)
 702 {
 703         struct ldb_context *ldb = winssrv->wins_db;
 704         struct ldb_message *msg;
 705         TALLOC_CTX *tmp_ctx = talloc_new(winssrv);
 706         int trans = -1;
 707         int ret = 0;
 708
 709
 710         trans = ldb_transaction_start(ldb);
 711         if (trans != LDB_SUCCESS) goto failed;
 712
 713         rec->version = winsdb_allocate_version(winssrv);
 714         if (rec->version == 0) goto failed;
 715
 716         msg = winsdb_message(winssrv->wins_db, rec, tmp_ctx);
 717         if (msg == NULL) goto failed;
 718         ret = ldb_add(ldb, msg);
 719         if (ret != 0) goto failed;
 720
 721         trans = ldb_transaction_commit(ldb);
 722         if (trans != LDB_SUCCESS) goto failed;
 723
 724         talloc_free(tmp_ctx);
 725         return NBT_RCODE_OK;
 726
 727 failed:
 728         if (trans == LDB_SUCCESS) ldb_transaction_cancel(ldb);
 729         talloc_free(tmp_ctx);
 730         return NBT_RCODE_SVR;
 731 }
 732
 733
 734 /*
 735   modify a WINS record in the database
 736 */
 737 uint8_t winsdb_modify(struct wins_server *winssrv, struct winsdb_record *rec)
 738 {
 739         struct ldb_context *ldb = winssrv->wins_db;
 740         struct ldb_message *msg;
 741         TALLOC_CTX *tmp_ctx = talloc_new(winssrv);
 742         int trans;
 743         int ret;
 744         int i;
 745
 746         trans = ldb_transaction_start(ldb);
 747         if (trans != LDB_SUCCESS) goto failed;
 748
 749         rec->version = winsdb_allocate_version(winssrv);
 750         if (rec->version == 0) goto failed;
 751         rec->wins_owner = WINSDB_OWNER_LOCAL;
 752
 753         msg = winsdb_message(winssrv->wins_db, rec, tmp_ctx);
 754         if (msg == NULL) goto failed;
 755
 756         for (i=0;i<msg->num_elements;i++) {
 757                 msg->elements[i].flags = LDB_FLAG_MOD_REPLACE;
 758         }
 759
 760         ret = ldb_modify(ldb, msg);
 761         if (ret != 0) goto failed;
 762
 763         trans = ldb_transaction_commit(ldb);
 764         if (trans != LDB_SUCCESS) goto failed;
 765
 766         talloc_free(tmp_ctx);
 767         return NBT_RCODE_OK;
 768
 769 failed:
 770         if (trans == LDB_SUCCESS) ldb_transaction_cancel(ldb);
 771         talloc_free(tmp_ctx);
 772         return NBT_RCODE_SVR;
 773 }
 774
 775
 776 /*
 777   delete a WINS record from the database
 778 */
 779 uint8_t winsdb_delete(struct wins_server *winssrv, struct winsdb_record *rec)
 780 {
 781         struct ldb_context *ldb = winssrv->wins_db;
 782         TALLOC_CTX *tmp_ctx = talloc_new(winssrv);
 783         const struct ldb_dn *dn;
 784         int trans;
 785         int ret;
 786
 787         trans = ldb_transaction_start(ldb);
 788         if (trans != LDB_SUCCESS) goto failed;
 789
 790         if(!winsdb_remove_version(winssrv, rec->version))
 791                 goto failed;
 792
 793         dn = winsdb_dn(tmp_ctx, rec->name);
 794         if (dn == NULL) goto failed;
 795
 796         ret = ldb_delete(ldb, dn);
 797         if (ret != 0) goto failed;
 798
 799         trans = ldb_transaction_commit(ldb);
 800         if (trans != LDB_SUCCESS) goto failed;
 801
 802         talloc_free(tmp_ctx);
 803         return NBT_RCODE_OK;
 804
 805 failed:
 806         if (trans == LDB_SUCCESS) ldb_transaction_cancel(ldb);
 807         talloc_free(tmp_ctx);
 808         return NBT_RCODE_SVR;
 809 }
 810
 811 struct ldb_context *winsdb_connect(TALLOC_CTX *mem_ctx)
 812 {
 813         return ldb_wrap_connect(mem_ctx, lp_wins_url(), 0, NULL);
 814 }