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 NTSTATUS winsdb_addr_decode(struct winsdb_record *rec, struct ldb_val *val,
 153                                    TALLOC_CTX *mem_ctx, struct winsdb_addr **_addr)
 154 {
 155         NTSTATUS status;
 156         struct winsdb_addr *addr;
 157         char *address;
 158         char *wins_owner;
 159         char *expire_time;
 160         char *p;
 161
 162         addr = talloc(mem_ctx, struct winsdb_addr);
 163         if (!addr) {
 164                 status = NT_STATUS_NO_MEMORY;
 165                 goto failed;
 166         }
 167
 168         address = (char *)val->data;
 169
 170         p = strchr(address, ';');
 171         if (!p) {
 172                 /* support old entries, with only the address */
 173                 addr->address           = talloc_steal(addr, val->data);
 174                 addr->wins_owner        = rec->wins_owner;
 175                 addr->expire_time       = rec->expire_time;
 176                 *_addr = addr;
 177                 return NT_STATUS_OK;
 178         }
 179
 180         *p = '\0';p++;
 181         addr->address = talloc_strdup(addr, address);
 182         if (!addr->address) {
 183                 status = NT_STATUS_NO_MEMORY;
 184                 goto failed;
 185         }
 186
 187         if (strncmp("winsOwner:", p, 10) != 0) {
 188                 status = NT_STATUS_INTERNAL_DB_CORRUPTION;
 189                 goto failed;
 190         }
 191         wins_owner = p + 10;
 192         p = strchr(wins_owner, ';');
 193         if (!p) {
 194                 status = NT_STATUS_INTERNAL_DB_CORRUPTION;
 195                 goto failed;
 196         }
 197
 198         *p = '\0';p++;
 199         addr->wins_owner = talloc_strdup(addr, wins_owner);
 200         if (!addr->wins_owner) {
 201                 status = NT_STATUS_NO_MEMORY;
 202                 goto failed;
 203         }
 204
 205         if (strncmp("expireTime:", p, 11) != 0) {
 206                 status = NT_STATUS_INTERNAL_DB_CORRUPTION;
 207                 goto failed;
 208         }
 209
 210         expire_time = p + 11;
 211         p = strchr(expire_time, ';');
 212         if (!p) {
 213                 status = NT_STATUS_INTERNAL_DB_CORRUPTION;
 214                 goto failed;
 215         }
 216
 217         *p = '\0';p++;
 218         addr->expire_time = ldap_string_to_time(expire_time);
 219
 220         *_addr = addr;
 221         return NT_STATUS_OK;
 222 failed:
 223         talloc_free(addr);
 224         return status;
 225 }
 226
 227 /*
 228  encode the winsdb_addr("address") attribute like this:
 229  "172.31.1.1;winsOwner:172.31.9.202;expireTime:20050923032330.0Z"
 230 */
 231 static int ldb_msg_add_winsdb_addr(struct ldb_context *ldb, struct ldb_message *msg,
 232                                    const char *attr_name, struct winsdb_addr *addr)
 233 {
 234         struct ldb_val val;
 235         const char *str;
 236
 237         dn = ldb_dn_string_compose(mem_ctx, NULL, "type=%02x", name->type);
 238
 239         addresses[len]->address = talloc_strdup(addresses[len], address);
 240         if (!addresses[len]->address) {
 241                 talloc_free(addresses);
 242                 return NULL;
 243         }
 244
 245         addresses[len]->wins_owner = talloc_strdup(addresses[len], wins_owner);
 246         if (!addresses[len]->wins_owner) {
 247                 talloc_free(addresses);
 248                 return NULL;
 249         }
 250
 251         addresses[len]->expire_time = expire_time;
 252
 253         addresses[len+1] = NULL;
 254
 255         return addresses;
 256 }
 257
 258 void winsdb_addr_list_remove(struct winsdb_addr **addresses, const char *address)
 259 {
 260         size_t i;
 261
 262         for (i=0; addresses[i]; i++) {
 263                 if (strcmp(addresses[i]->address, address) == 0) {
 264                         break;
 265                 }
 266         }
 267         if (!addresses[i]) return;
 268
 269         for (; addresses[i]; i++) {
 270                 addresses[i] = addresses[i+1];
 271         }
 272
 273         return;
 274 }
 275
 276 struct winsdb_addr *winsdb_addr_list_check(struct winsdb_addr **addresses, const char *address)
 277 {
 278         size_t i;
 279
 280         for (i=0; addresses[i]; i++) {
 281                 if (strcmp(addresses[i]->address, address) == 0) {
 282                         return addresses[i];
 283                 }
 284         }
 285
 286         return NULL;
 287 }
 288
 289 size_t winsdb_addr_list_length(struct winsdb_addr **addresses)
 290 {
 291         size_t i;
 292         for (i=0; addresses[i]; i++);
 293         return i;
 294 }
 295
 296 const char **winsdb_addr_string_list(TALLOC_CTX *mem_ctx, struct winsdb_addr **addresses)
 297 {
 298         size_t len = winsdb_addr_list_length(addresses);
 299         const char **str_list;
 300         size_t i;
 301
 302         str_list = talloc_array(mem_ctx, const char *, len + 1);
 303         if (!str_list) return NULL;
 304
 305         for (i=0; i < len; i++) {
 306                 str_list[i] = talloc_strdup(str_list, addresses[i]->address);
 307                 if (!str_list[i]) {
 308                         talloc_free(str_list);
 309                         return NULL;
 310                 }
 311         }
 312
 313         str_list[len] = NULL;
 314         return str_list;
 315 }
 316
 317 /*
 318  decode the winsdb_addr("address") attribute:
 319  "172.31.1.1" or
 320  "172.31.1.1;winsOwner:172.31.9.202;expireTime:20050923032330.0Z"
 321  are valid records
 322 */
 323 static struct winsdb_addr *winsdb_addr_decode(struct winsdb_record *rec, TALLOC_CTX *mem_ctx, struct ldb_val *val)
 324 {
 325         NTSTATUS status;
 326         struct winsdb_addr *addr;
 327         char *address;
 328         char *wins_owner;
 329         char *expire_time;
 330         char *p;
 331
 332         addr = talloc(mem_ctx, struct winsdb_addr);
 333         if (!addr) {
 334                 status = NT_STATUS_NO_MEMORY;
 335                 goto failed;
 336         }
 337
 338         address = (char *)val->data;
 339
 340         p = strchr(address, ';');
 341         if (!p) {
 342                 /* support old entries, with only the address */
 343                 addr->address           = talloc_steal(addr, val->data);
 344                 addr->wins_owner        = rec->wins_owner;
 345                 addr->expire_time       = rec->expire_time;
 346                 *_addr = addr;
 347                 return NT_STATUS_OK;
 348         }
 349
 350         *p = '\0';p++;
 351         addr->address = talloc_strdup(addr, address);
 352         if (!addr->address) {
 353                 status = NT_STATUS_NO_MEMORY;
 354                 goto failed;
 355         }
 356
 357         if (strncmp("winsOwner:", p, 10) != 0) {
 358                 status = NT_STATUS_INTERNAL_DB_CORRUPTION;
 359                 goto failed;
 360         }
 361         wins_owner = p + 10;
 362         p = strchr(wins_owner, ';');
 363         if (!p) {
 364                 status = NT_STATUS_INTERNAL_DB_CORRUPTION;
 365                 goto failed;
 366         }
 367
 368         *p = '\0';p++;
 369         addr->wins_owner = talloc_strdup(addr, wins_owner);
 370         if (!addr->wins_owner) {
 371                 status = NT_STATUS_NO_MEMORY;
 372                 goto failed;
 373         }
 374
 375         if (strncmp("expireTime:", p, 11) != 0) {
 376                 status = NT_STATUS_INTERNAL_DB_CORRUPTION;
 377                 goto failed;
 378         }
 379
 380         expire_time = p + 11;
 381         p = strchr(expire_time, ';');
 382         if (!p) {
 383                 status = NT_STATUS_INTERNAL_DB_CORRUPTION;
 384                 goto failed;
 385         }
 386
 387         *p = '\0';p++;
 388         addr->expire_time = ldap_string_to_time(expire_time);
 389
 390         *_addr = addr;
 391         return NT_STATUS_OK;
 392 failed:
 393         talloc_free(addr);
 394         return status;
 395 }
 396
 397 /*
 398  encode the winsdb_addr("address") attribute like this:
 399  "172.31.1.1;winsOwner:172.31.9.202;expireTime:20050923032330.0Z;"
 400 */
 401 static int ldb_msg_add_winsdb_addr(struct ldb_context *ldb, struct ldb_message *msg,
 402                                    const char *attr_name, struct winsdb_addr *addr)
 403 {
 404         struct ldb_val val;
 405         const char *str;
 406
 407         str = talloc_asprintf(msg, "%s;winsOwner:%s;expireTime:%s;",
 408                               addr->address, addr->wins_owner,
 409                               ldap_timestring(msg, addr->expire_time));
 410         if (!str) return -1;
 411
 412         val.data = discard_const_p(uint8_t, str);
 413         val.length = strlen(str);
 414
 415         return ldb_msg_add_value(ldb, msg, attr_name, &val);
 416 }
 417
 418 struct winsdb_addr **winsdb_addr_list_make(TALLOC_CTX *mem_ctx)
 419 {
 420         struct winsdb_addr **addresses;
 421
 422         addresses = talloc_array(mem_ctx, struct winsdb_addr *, 1);
 423         if (!addresses) return NULL;
 424
 425         addresses[0] = NULL;
 426
 427         return addresses;
 428 }
 429
 430 struct winsdb_addr **winsdb_addr_list_add(struct winsdb_addr **addresses, const char *address,
 431                                           const char *wins_owner, time_t expire_time)
 432 {
 433         size_t len = winsdb_addr_list_length(addresses);
 434
 435         addresses = talloc_realloc(addresses, addresses, struct winsdb_addr *, len + 2);
 436         if (!addresses) return NULL;
 437
 438         addresses[len] = talloc(addresses, struct winsdb_addr);
 439         if (!addresses[len]) {
 440                 talloc_free(addresses);
 441                 return NULL;
 442         }
 443
 444         addresses[len]->address = talloc_strdup(addresses[len], address);
 445         if (!addresses[len]->address) {
 446                 talloc_free(addresses);
 447                 return NULL;
 448         }
 449
 450         addresses[len]->wins_owner = talloc_strdup(addresses[len], wins_owner);
 451         if (!addresses[len]->wins_owner) {
 452                 talloc_free(addresses);
 453                 return NULL;
 454         }
 455
 456         addresses[len]->expire_time = expire_time;
 457
 458         addresses[len+1] = NULL;
 459
 460         return addresses;
 461 }
 462
 463 void winsdb_addr_list_remove(struct winsdb_addr **addresses, const char *address)
 464 {
 465         size_t i;
 466
 467         for (i=0; addresses[i]; i++) {
 468                 if (strcmp(addresses[i]->address, address) == 0) {
 469                         break;
 470                 }
 471         }
 472         if (!addresses[i]) return;
 473
 474         for (; addresses[i]; i++) {
 475                 addresses[i] = addresses[i+1];
 476         }
 477
 478         return;
 479 }
 480
 481 struct winsdb_addr *winsdb_addr_list_check(struct winsdb_addr **addresses, const char *address)
 482 {
 483         size_t i;
 484
 485         for (i=0; addresses[i]; i++) {
 486                 if (strcmp(addresses[i]->address, address) == 0) {
 487                         return addresses[i];
 488                 }
 489         }
 490
 491         return NULL;
 492 }
 493
 494 size_t winsdb_addr_list_length(struct winsdb_addr **addresses)
 495 {
 496         size_t i;
 497         for (i=0; addresses[i]; i++);
 498         return i;
 499 }
 500
 501 const char **winsdb_addr_string_list(TALLOC_CTX *mem_ctx, struct winsdb_addr **addresses)
 502 {
 503         size_t len = winsdb_addr_list_length(addresses);
 504         const char **str_list;
 505         size_t i;
 506
 507         str_list = talloc_array(mem_ctx, const char *, len + 1);
 508         if (!str_list) return NULL;
 509
 510         for (i=0; i < len; i++) {
 511                 str_list[i] = talloc_strdup(str_list, addresses[i]->address);
 512                 if (!str_list[i]) {
 513                         talloc_free(str_list);
 514                         return NULL;
 515                 }
 516         }
 517
 518         str_list[len] = NULL;
 519         return str_list;
 520 }
 521
 522 /*
 523   load a WINS entry from the database
 524 */
 525 NTSTATUS winsdb_lookup(struct ldb_context *wins_db,
 526                        struct nbt_name *name,
 527                        TALLOC_CTX *mem_ctx,
 528                        struct winsdb_record **_rec)
 529 {
 530         NTSTATUS status;
 531         struct ldb_message **res = NULL;
 532         int ret;
 533         struct winsdb_record *rec;
 534         TALLOC_CTX *tmp_ctx = talloc_new(mem_ctx);
 535
 536         /* find the record in the WINS database */
 537         ret = ldb_search(wins_db, winsdb_dn(tmp_ctx, name), LDB_SCOPE_BASE,
 538                          NULL, NULL, &res);
 539         if (res != NULL) {
 540                 talloc_steal(tmp_ctx, res);
 541         }
 542         if (ret == 0) {
 543                 status = NT_STATUS_OBJECT_NAME_NOT_FOUND;
 544                 goto failed;
 545         } else if (ret != 1) {
 546                 status = NT_STATUS_INTERNAL_DB_CORRUPTION;
 547                 goto failed;
 548         }
 549
 550         status = winsdb_record(res[0], name, tmp_ctx, &rec);
 551         if (!NT_STATUS_IS_OK(status)) goto failed;
 552
 553         /* see if it has already expired */
 554         if (rec->state == WINS_REC_ACTIVE &&
 555             rec->expire_time <= time(NULL)) {
 556                 DEBUG(5,("WINS: expiring name %s (expired at %s)\n",
 557                          nbt_name_string(tmp_ctx, rec->name), timestring(tmp_ctx, rec->expire_time)));
 558                 rec->state = WINS_REC_RELEASED;
 559         }
 560
 561         talloc_steal(mem_ctx, rec);
 562         talloc_free(tmp_ctx);
 563         *_rec = rec;
 564         return NT_STATUS_OK;
 565
 566 failed:
 567         talloc_free(tmp_ctx);
 568         return status;
 569 }
 570
 571 NTSTATUS winsdb_record(struct ldb_message *msg, struct nbt_name *name, TALLOC_CTX *mem_ctx, struct winsdb_record **_rec)
 572 {
 573         NTSTATUS status;
 574         struct winsdb_record *rec;
 575         struct ldb_message_element *el;
 576         uint32_t i;
 577
 578         rec = talloc(mem_ctx, struct winsdb_record);
 579         if (rec == NULL) {
 580                 status = NT_STATUS_NO_MEMORY;
 581                 goto failed;
 582         }
 583
 584         if (!name) {
 585                 status = winsdb_nbt_name(rec, msg->dn, &name);
 586                 if (!NT_STATUS_IS_OK(status)) goto failed;
 587         }
 588
 589         /* parse it into a more convenient winsdb_record structure */
 590         rec->name           = name;
 591         rec->state          = ldb_msg_find_int(res[0], "active", WINS_REC_RELEASED);
 592         rec->nb_flags       = ldb_msg_find_int(res[0], "nbFlags", 0);
 593         rec->expire_time    = ldb_string_to_time(ldb_msg_find_string(res[0], "expires", NULL));
 594         rec->registered_by  = ldb_msg_find_string(res[0], "registeredBy", NULL);
 595         rec->version        = ldb_msg_find_uint64(res[0], "version", 0);
 596         talloc_steal(rec, rec->wins_owner);
 597         talloc_steal(rec, rec->registered_by);
 598
 599         if (!rec->wins_owner) rec->wins_owner = WINSDB_OWNER_LOCAL;
 600
 601         el = ldb_msg_find_element(msg, "address");
 602         if (el == NULL) {
 603                 status = NT_STATUS_INTERNAL_DB_CORRUPTION;
 604                 goto failed;
 605         }
 606
 607         rec->addresses     = talloc_array(rec, struct winsdb_addr *, el->num_values+1);
 608         if (rec->addresses == NULL) {
 609                 status = NT_STATUS_NO_MEMORY;
 610                 goto failed;
 611         }
 612
 613         for (i=0;i<el->num_values;i++) {
 614                 status = winsdb_addr_decode(rec, &el->values[i], rec->addresses, &rec->addresses[i]);
 615                 if (!NT_STATUS_IS_OK(status)) goto failed;
 616         }
 617         rec->addresses[i] = NULL;
 618
 619         *_rec = rec;
 620         return NT_STATUS_OK;
 621 failed:
 622         if (NT_STATUS_EQUAL(NT_STATUS_INTERNAL_DB_CORRUPTION, status)) {
 623                 DEBUG(1,("winsdb_record: corrupted record: %s\n", ldb_dn_linearize(rec, msg->dn)));
 624         }
 625         talloc_free(rec);
 626         return status;
 627 }
 628
 629         rec = talloc(mem_ctx, struct winsdb_record);
 630         if (rec == NULL) {
 631                 status = NT_STATUS_NO_MEMORY;
 632                 goto failed;
 633         }
 634
 635         if (!name) {
 636                 status = winsdb_nbt_name(rec, msg->dn, &name);
 637                 if (!NT_STATUS_IS_OK(status)) goto failed;
 638         }
 639
 640         /* parse it into a more convenient winsdb_record structure */
 641         rec->name           = name;
 642         rec->state          = ldb_msg_find_int(msg, "state", WINS_REC_RELEASED);
 643         rec->nb_flags       = ldb_msg_find_int(msg, "nbFlags", 0);
 644         rec->wins_owner     = ldb_msg_find_string(msg, "winsOwner", NULL);
 645         rec->expire_time    = ldap_string_to_time(ldb_msg_find_string(msg, "expireTime", NULL));
 646         rec->registered_by  = ldb_msg_find_string(msg, "registeredBy", NULL);
 647         rec->version        = ldb_msg_find_uint64(msg, "versionID", 0);
 648         talloc_steal(rec, rec->wins_owner);
 649         talloc_steal(rec, rec->registered_by);
 650
 651         if (!rec->wins_owner) rec->wins_owner = WINSDB_OWNER_LOCAL;
 652
 653         el = ldb_msg_find_element(msg, "address");
 654         if (el == NULL) {
 655                 status = NT_STATUS_INTERNAL_DB_CORRUPTION;
 656                 goto failed;
 657         }
 658
 659         rec->addresses     = talloc_array(rec, struct winsdb_addr *, el->num_values+1);
 660         if (rec->addresses == NULL) {
 661                 status = NT_STATUS_NO_MEMORY;
 662                 goto failed;
 663         }
 664
 665         for (i=0;i<el->num_values;i++) {
 666                 status = winsdb_addr_decode(rec, &el->values[i], rec->addresses, &rec->addresses[i]);
 667                 if (!NT_STATUS_IS_OK(status)) goto failed;
 668         }
 669         rec->addresses[i] = NULL;
 670
 671         *_rec = rec;
 672         return NT_STATUS_OK;
 673 failed:
 674         if (NT_STATUS_EQUAL(NT_STATUS_INTERNAL_DB_CORRUPTION, status)) {
 675                 DEBUG(1,("winsdb_record: corrupted record: %s\n", ldb_dn_linearize(rec, msg->dn)));
 676         }
 677         talloc_free(rec);
 678         return status;
 679 }
 680
 681         rec = talloc(mem_ctx, struct winsdb_record);
 682         if (rec == NULL) {
 683                 status = NT_STATUS_NO_MEMORY;
 684                 goto failed;
 685         }
 686
 687         if (!name) {
 688                 status = winsdb_nbt_name(rec, msg->dn, &name);
 689                 if (!NT_STATUS_IS_OK(status)) goto failed;
 690         }
 691
 692         /* parse it into a more convenient winsdb_record structure */
 693         rec->name           = name;
 694         rec->state          = ldb_msg_find_int(msg, "state", WINS_REC_RELEASED);
 695         rec->nb_flags       = ldb_msg_find_int(msg, "nbFlags", 0);
 696         rec->wins_owner     = ldb_msg_find_string(msg, "winsOwner", NULL);
 697         rec->expire_time    = ldap_string_to_time(ldb_msg_find_string(msg, "expireTime", NULL));
 698         rec->registered_by  = ldb_msg_find_string(msg, "registeredBy", NULL);
 699         rec->version        = ldb_msg_find_uint64(msg, "versionID", 0);
 700         talloc_steal(rec, rec->wins_owner);
 701         talloc_steal(rec, rec->registered_by);
 702
 703         if (!rec->wins_owner) rec->wins_owner = WINSDB_OWNER_LOCAL;
 704
 705         el = ldb_msg_find_element(msg, "address");
 706         if (el == NULL) {
 707                 status = NT_STATUS_INTERNAL_DB_CORRUPTION;
 708                 goto failed;
 709         }
 710
 711         rec->addresses     = talloc_array(rec, struct winsdb_addr *, el->num_values+1);
 712         if (rec->addresses == NULL) {
 713                 status = NT_STATUS_NO_MEMORY;
 714                 goto failed;
 715         }
 716
 717         for (i=0;i<el->num_values;i++) {
 718                 status = winsdb_addr_decode(rec, &el->values[i], rec->addresses, &rec->addresses[i]);
 719                 if (!NT_STATUS_IS_OK(status)) goto failed;
 720         }
 721         rec->addresses[i] = NULL;
 722
 723         *_rec = rec;
 724         return NT_STATUS_OK;
 725 failed:
 726         if (NT_STATUS_EQUAL(NT_STATUS_INTERNAL_DB_CORRUPTION, status)) {
 727                 DEBUG(1,("winsdb_record: corrupted record: %s\n", ldb_dn_linearize(rec, msg->dn)));
 728         }
 729         talloc_free(rec);
 730         return status;
 731 }
 732
 733 /*
 734   form a ldb_message from a winsdb_record
 735 */
 736 struct ldb_message *winsdb_message(struct ldb_context *ldb,
 737                                    struct winsdb_record *rec, TALLOC_CTX *mem_ctx)
 738 {
 739         int i, ret=0;
 740         struct ldb_message *msg = ldb_msg_new(mem_ctx);
 741         if (msg == NULL) goto failed;
 742
 743         msg->dn = winsdb_dn(msg, rec->name);
 744         if (msg->dn == NULL) goto failed;
 745         ret |= ldb_msg_add_fmt(msg, "objectClass", "wins");
 746         ret |= ldb_msg_add_fmt(msg, "active", "%u", rec->state);
 747         ret |= ldb_msg_add_fmt(msg, "nbFlags", "0x%04x", rec->nb_flags);
 748         ret |= ldb_msg_add_string(msg, "registeredBy", rec->registered_by);
 749         ret |= ldb_msg_add_string(msg, "expires",
 750                                   ldb_timestring(msg, rec->expire_time));
 751         ret |= ldb_msg_add_fmt(msg, "version", "%llu", rec->version);
 752         for (i=0;rec->addresses[i];i++) {
 753                 ret |= ldb_msg_add_string(msg, "address", rec->addresses[i]);
 754         }
 755         if (ret != 0) goto failed;
 756         return msg;
 757
 758 failed:
 759         talloc_free(msg);
 760         return NULL;
 761 }
 762
 763 /*
 764   save a WINS record into the database
 765 */
 766 uint8_t winsdb_add(struct wins_server *winssrv, struct winsdb_record *rec)
 767 {
 768         struct ldb_context *ldb = winssrv->wins_db;
 769         struct ldb_message *msg;
 770         TALLOC_CTX *tmp_ctx = talloc_new(winssrv);
 771         int trans = -1;
 772         int ret = 0;
 773
 774
 775         trans = ldb_transaction_start(ldb);
 776         if (trans != LDB_SUCCESS) goto failed;
 777
 778         rec->version = winsdb_allocate_version(winssrv);
 779         if (rec->version == 0) goto failed;
 780
 781         msg = winsdb_message(winssrv->wins_db, rec, tmp_ctx);
 782         if (msg == NULL) goto failed;
 783         ret = ldb_add(ldb, msg);
 784         if (ret != 0) goto failed;
 785
 786         trans = ldb_transaction_commit(ldb);
 787         if (trans != LDB_SUCCESS) goto failed;
 788
 789         talloc_free(tmp_ctx);
 790         return NBT_RCODE_OK;
 791
 792 failed:
 793         if (trans == LDB_SUCCESS) ldb_transaction_cancel(ldb);
 794         talloc_free(tmp_ctx);
 795         return NBT_RCODE_SVR;
 796 }
 797
 798
 799 /*
 800   modify a WINS record in the database
 801 */
 802 uint8_t winsdb_modify(struct wins_server *winssrv, struct winsdb_record *rec)
 803 {
 804         struct ldb_context *ldb = winssrv->wins_db;
 805         struct ldb_message *msg;
 806         TALLOC_CTX *tmp_ctx = talloc_new(winssrv);
 807         int trans;
 808         int ret;
 809         int i;
 810
 811         trans = ldb_transaction_start(ldb);
 812         if (trans != LDB_SUCCESS) goto failed;
 813
 814         rec->version = winsdb_allocate_version(winssrv);
 815         if (rec->version == 0) goto failed;
 816         rec->wins_owner = WINSDB_OWNER_LOCAL;
 817
 818         msg = winsdb_message(winssrv->wins_db, rec, tmp_ctx);
 819         if (msg == NULL) goto failed;
 820
 821         for (i=0;i<msg->num_elements;i++) {
 822                 msg->elements[i].flags = LDB_FLAG_MOD_REPLACE;
 823         }
 824
 825         ret = ldb_modify(ldb, msg);
 826         if (ret != 0) goto failed;
 827
 828         trans = ldb_transaction_commit(ldb);
 829         if (trans != LDB_SUCCESS) goto failed;
 830
 831         talloc_free(tmp_ctx);
 832         return NBT_RCODE_OK;
 833
 834 failed:
 835         if (trans == LDB_SUCCESS) ldb_transaction_cancel(ldb);
 836         talloc_free(tmp_ctx);
 837         return NBT_RCODE_SVR;
 838 }
 839
 840
 841 /*
 842   delete a WINS record from the database
 843 */
 844 uint8_t winsdb_delete(struct wins_server *winssrv, struct winsdb_record *rec)
 845 {
 846         struct ldb_context *ldb = winssrv->wins_db;
 847         TALLOC_CTX *tmp_ctx = talloc_new(winssrv);
 848         const struct ldb_dn *dn;
 849         int trans;
 850         int ret;
 851
 852         if(!winsdb_remove_version(winssrv, rec->version))
 853                 goto failed;
 854
 855         dn = winsdb_dn(tmp_ctx, rec->name);
 856         if (dn == NULL) goto failed;
 857
 858         ret = ldb_delete(ldb, dn);
 859         if (ret != 0) goto failed;
 860
 861         trans = ldb_transaction_commit(ldb);
 862         if (trans != LDB_SUCCESS) goto failed;
 863
 864         talloc_free(tmp_ctx);
 865         return NBT_RCODE_OK;
 866
 867 failed:
 868         if (trans == LDB_SUCCESS) ldb_transaction_cancel(ldb);
 869         talloc_free(tmp_ctx);
 870         return NBT_RCODE_SVR;
 871 }
 872
 873 struct ldb_context *winsdb_connect(TALLOC_CTX *mem_ctx)
 874 {
 875         return ldb_wrap_connect(mem_ctx, lp_wins_url(), 0, NULL);
 876 }