Changeset 745 for trunk/server/source4/nbt_server/wins

Timestamp:

Nov 27, 2012, 4:43:17 PM (13 years ago)

Author:

Silvan Scherrer

Message:

Samba Server: updated trunk to 3.6.0

Location:

trunk/server

Files:

• . (modified) (1 prop)
• source4/nbt_server/wins/wins_hook.c (modified) (1 diff)
• source4/nbt_server/wins/wins_ldb.c (modified) (4 diffs)
• source4/nbt_server/wins/winsclient.c (modified) (10 diffs)
• source4/nbt_server/wins/winsdb.c (modified) (17 diffs)
• source4/nbt_server/wins/winsserver.c (modified) (12 diffs)
• source4/nbt_server/wins/winsserver.h (modified) (1 diff)
• source4/nbt_server/wins/winswack.c (modified) (3 diffs)

trunk/server/source4/nbt_server/wins/wins_hook.c

@@ -62 +62 @@
                               rec->name->name,
                               rec->name->type,
-                              rec->expire_time);
+                              (long int) rec->expire_time);
         if (!cmd) goto failed;
 

trunk/server/source4/nbt_server/wins/wins_ldb.c

@@ -32 +32 @@
 #include "nbt_server/nbt_server.h"
 #include "nbt_server/wins/winsdb.h"
-#include "lib/ldb/include/ldb_module.h"
+#include <ldb_module.h>
 #include "system/network.h"
 #include "lib/socket/netif.h"
@@ -90 +90 @@
         ldb_module_set_private(module, NULL);
 
-        owner = lp_parm_string(lp_ctx, NULL, "winsdb", "local_owner");
+        owner = lpcfg_parm_string(lp_ctx, NULL, "winsdb", "local_owner");
         if (!owner) {
                 struct interface *ifaces;
-                load_interfaces(module, lp_interfaces(lp_ctx), &ifaces);
+                load_interfaces(module, lpcfg_interfaces(lp_ctx), &ifaces);
                 owner = iface_n_ip(ifaces, 0);
                 if (!owner) {
@@ -114 +114 @@
 }
 
-_PUBLIC_ const struct ldb_module_ops ldb_wins_ldb_module_ops = {
+static const struct ldb_module_ops ldb_wins_ldb_module_ops = {
         .name          = "wins_ldb",
         .add           = wins_ldb_verify,
@@ -120 +120 @@
         .init_context  = wins_ldb_init
 };
+
+int ldb_wins_ldb_module_init(const char *version)
+{
+        LDB_MODULE_CHECK_VERSION(version);
+        return ldb_register_module(&ldb_wins_ldb_module_ops);
+}

trunk/server/source4/nbt_server/wins/winsclient.c

@@ -29 +29 @@
 #include "param/param.h"
 
-static void nbtd_wins_refresh_handler(struct composite_context *c);
-
 /* we send WINS client requests using our primary network interface 
 */
@@ -59 +57 @@
 {
         uint32_t refresh_time;
-        uint32_t max_refresh_time = lp_parm_int(iname->iface->nbtsrv->task->lp_ctx, NULL, "nbtd", "max_refresh_time", 7200);
+        uint32_t max_refresh_time = lpcfg_parm_int(iname->iface->nbtsrv->task->lp_ctx, NULL, "nbtd", "max_refresh_time", 7200);
 
         refresh_time = MIN(max_refresh_time, iname->ttl/2);
@@ -69 +67 @@
 }
 
+struct nbtd_wins_refresh_state {
+        struct nbtd_iface_name *iname;
+        struct nbt_name_refresh_wins io;
+};
+
 /*
   called when a wins name refresh has completed
 */
-static void nbtd_wins_refresh_handler(struct composite_context *c)
+static void nbtd_wins_refresh_handler(struct tevent_req *subreq)
 {
         NTSTATUS status;
-        struct nbt_name_refresh_wins io;
-        struct nbtd_iface_name *iname = talloc_get_type(c->async.private_data, 
-                                                        struct nbtd_iface_name);
-        TALLOC_CTX *tmp_ctx = talloc_new(iname);
-
-        status = nbt_name_refresh_wins_recv(c, tmp_ctx, &io);
+        struct nbtd_wins_refresh_state *state =
+                tevent_req_callback_data(subreq,
+                struct nbtd_wins_refresh_state);
+        struct nbtd_iface_name *iname = state->iname;
+
+        status = nbt_name_refresh_wins_recv(subreq, state, &state->io);
+        TALLOC_FREE(subreq);
         if (NT_STATUS_EQUAL(status, NT_STATUS_IO_TIMEOUT)) {
                 /* our WINS server is dead - start registration over
                    from scratch */
                 DEBUG(2,("Failed to refresh %s with WINS server %s\n",
-                         nbt_name_string(tmp_ctx, &iname->name), iname->wins_server));
-                talloc_free(tmp_ctx);
+                         nbt_name_string(state, &iname->name), iname->wins_server));
+                talloc_free(state);
                 nbtd_winsclient_register(iname);
                 return;
@@ -93 +97 @@
         if (!NT_STATUS_IS_OK(status)) {
                 DEBUG(1,("Name refresh failure with WINS for %s - %s\n", 
-                         nbt_name_string(tmp_ctx, &iname->name), nt_errstr(status)));
-                talloc_free(tmp_ctx);
-                return;
-        }
-
-        if (io.out.rcode != 0) {
+                         nbt_name_string(state, &iname->name), nt_errstr(status)));
+                talloc_free(state);
+                return;
+        }
+
+        if (state->io.out.rcode != 0) {
                 DEBUG(1,("WINS server %s rejected name refresh of %s - %s\n", 
-                         io.out.wins_server, nbt_name_string(tmp_ctx, &iname->name), 
-                         nt_errstr(nbt_rcode_to_ntstatus(io.out.rcode))));
+                         state->io.out.wins_server,
+                         nbt_name_string(state, &iname->name),
+                         nt_errstr(nbt_rcode_to_ntstatus(state->io.out.rcode))));
                 iname->nb_flags |= NBT_NM_CONFLICT;
-                talloc_free(tmp_ctx);
+                talloc_free(state);
                 return;
         }       
 
         DEBUG(4,("Refreshed name %s with WINS server %s\n",
-                 nbt_name_string(tmp_ctx, &iname->name), iname->wins_server));
+                 nbt_name_string(state, &iname->name), iname->wins_server));
         /* success - start a periodic name refresh */
         iname->nb_flags |= NBT_NM_ACTIVE;
@@ -116 +121 @@
                  * so steal it into the tmp context
                  */
-                talloc_steal(tmp_ctx, iname->wins_server);
-        }
-        iname->wins_server = talloc_steal(iname, io.out.wins_server);
-
+                talloc_steal(state, iname->wins_server);
+        }
+        iname->wins_server = talloc_move(iname, &state->io.out.wins_server);
         iname->registration_time = timeval_current();
+
+        talloc_free(state);
+
         nbtd_wins_start_refresh_timer(iname);
-
-        talloc_free(tmp_ctx);
 }
 
@@ -135 +140 @@
         struct nbtd_iface_name *iname = talloc_get_type(private_data, struct nbtd_iface_name);
         struct nbtd_interface *iface = iname->iface;
-        struct nbt_name_refresh_wins io;
-        struct composite_context *c;
-        TALLOC_CTX *tmp_ctx = talloc_new(iname);
+        struct nbt_name_socket *nbtsock = wins_socket(iface);
+        struct tevent_req *subreq;
+        struct nbtd_wins_refresh_state *state;
+
+        state = talloc_zero(iname, struct nbtd_wins_refresh_state);
+        if (state == NULL) {
+                return;
+        }
+
+        state->iname = iname;
 
         /* setup a wins name refresh request */
-        io.in.name            = iname->name;
-        io.in.wins_servers    = (const char **)str_list_make_single(tmp_ctx, iname->wins_server);
-        io.in.wins_port       = lp_nbt_port(iface->nbtsrv->task->lp_ctx);
-        io.in.addresses       = nbtd_address_list(iface, tmp_ctx);
-        io.in.nb_flags        = iname->nb_flags;
-        io.in.ttl             = iname->ttl;
-
-        if (!io.in.addresses) {
-                talloc_free(tmp_ctx);
-                return;
-        }
-
-        c = nbt_name_refresh_wins_send(wins_socket(iface), &io);
-        if (c == NULL) {
-                talloc_free(tmp_ctx);
-                return;
-        }
-        talloc_steal(c, io.in.addresses);
-
-        c->async.fn = nbtd_wins_refresh_handler;
-        c->async.private_data = iname;
-
-        talloc_free(tmp_ctx);
-}
-
+        state->io.in.name            = iname->name;
+        state->io.in.wins_servers    = (const char **)str_list_make_single(state, iname->wins_server);
+        state->io.in.wins_port       = lpcfg_nbt_port(iface->nbtsrv->task->lp_ctx);
+        state->io.in.addresses       = nbtd_address_list(iface, state);
+        state->io.in.nb_flags        = iname->nb_flags;
+        state->io.in.ttl             = iname->ttl;
+
+        if (!state->io.in.addresses) {
+                talloc_free(state);
+                return;
+        }
+
+        subreq = nbt_name_refresh_wins_send(state, ev, nbtsock, &state->io);
+        if (subreq == NULL) {
+                talloc_free(state);
+                return;
+        }
+
+        tevent_req_set_callback(subreq, nbtd_wins_refresh_handler, state);
+}
+
+struct nbtd_wins_register_state {
+        struct nbtd_iface_name *iname;
+        struct nbt_name_register_wins io;
+};
 
 /*
   called when a wins name register has completed
 */
-static void nbtd_wins_register_handler(struct composite_context *c)
+static void nbtd_wins_register_handler(struct tevent_req *subreq)
 {
         NTSTATUS status;
-        struct nbt_name_register_wins io;
-        struct nbtd_iface_name *iname = talloc_get_type(c->async.private_data, 
-                                                        struct nbtd_iface_name);
-        TALLOC_CTX *tmp_ctx = talloc_new(iname);
-
-        status = nbt_name_register_wins_recv(c, tmp_ctx, &io);
+        struct nbtd_wins_register_state *state =
+                tevent_req_callback_data(subreq,
+                struct nbtd_wins_register_state);
+        struct nbtd_iface_name *iname = state->iname;
+
+        status = nbt_name_register_wins_recv(subreq, state, &state->io);
+        TALLOC_FREE(subreq);
         if (NT_STATUS_EQUAL(status, NT_STATUS_IO_TIMEOUT)) {
                 /* none of the WINS servers responded - try again 
                    periodically */
-                int wins_retry_time = lp_parm_int(iname->iface->nbtsrv->task->lp_ctx, NULL, "nbtd", "wins_retry", 300);
+                int wins_retry_time = lpcfg_parm_int(iname->iface->nbtsrv->task->lp_ctx, NULL, "nbtd", "wins_retry", 300);
                 event_add_timed(iname->iface->nbtsrv->task->event_ctx, 
                                 iname,
@@ -187 +200 @@
                                 nbtd_wins_register_retry,
                                 iname);
-                talloc_free(tmp_ctx);
+                talloc_free(state);
                 return;
         }
@@ -193 +206 @@
         if (!NT_STATUS_IS_OK(status)) {
                 DEBUG(1,("Name register failure with WINS for %s - %s\n", 
-                         nbt_name_string(tmp_ctx, &iname->name), nt_errstr(status)));
-                talloc_free(tmp_ctx);
+                         nbt_name_string(state, &iname->name), nt_errstr(status)));
+                talloc_free(state);
                 return;
         }       
 
-        if (io.out.rcode != 0) {
+        if (state->io.out.rcode != 0) {
                 DEBUG(1,("WINS server %s rejected name register of %s - %s\n", 
-                         io.out.wins_server, nbt_name_string(tmp_ctx, &iname->name), 
-                         nt_errstr(nbt_rcode_to_ntstatus(io.out.rcode))));
+                         state->io.out.wins_server,
+                         nbt_name_string(state, &iname->name),
+                         nt_errstr(nbt_rcode_to_ntstatus(state->io.out.rcode))));
                 iname->nb_flags |= NBT_NM_CONFLICT;
-                talloc_free(tmp_ctx);
+                talloc_free(state);
                 return;
         }       
@@ -214 +228 @@
                  * so steal it into the tmp context
                  */
-                talloc_steal(tmp_ctx, iname->wins_server);
-        }
-        iname->wins_server = talloc_steal(iname, io.out.wins_server);
+                talloc_steal(state, iname->wins_server);
+        }
+        iname->wins_server = talloc_move(iname, &state->io.out.wins_server);
 
         iname->registration_time = timeval_current();
+
+        DEBUG(3,("Registered %s with WINS server %s\n",
+                 nbt_name_string(state, &iname->name), iname->wins_server));
+
+        talloc_free(state);
+
         nbtd_wins_start_refresh_timer(iname);
-
-        DEBUG(3,("Registered %s with WINS server %s\n",
-                 nbt_name_string(tmp_ctx, &iname->name), iname->wins_server));
-
-        talloc_free(tmp_ctx);
 }
 
@@ -233 +248 @@
 {
         struct nbtd_interface *iface = iname->iface;
-        struct nbt_name_register_wins io;
-        struct composite_context *c;
+        struct nbt_name_socket *nbtsock = wins_socket(iface);
+        struct nbtd_wins_register_state *state;
+        struct tevent_req *subreq;
+
+        state = talloc_zero(iname, struct nbtd_wins_register_state);
+        if (state == NULL) {
+                return;
+        }
+
+        state->iname = iname;
 
         /* setup a wins name register request */
-        io.in.name            = iname->name;
-        io.in.wins_port       = lp_nbt_port(iname->iface->nbtsrv->task->lp_ctx);
-        io.in.wins_servers    = lp_wins_server_list(iname->iface->nbtsrv->task->lp_ctx);
-        io.in.addresses       = nbtd_address_list(iface, iname);
-        io.in.nb_flags        = iname->nb_flags;
-        io.in.ttl             = iname->ttl;
-
-        if (!io.in.addresses) {
-                return;
-        }
-
-        c = nbt_name_register_wins_send(wins_socket(iface), &io);
-        if (c == NULL) {
-                talloc_free(io.in.addresses);
-                return;
-        }
-        talloc_steal(c, io.in.addresses);
-
-        c->async.fn = nbtd_wins_register_handler;
-        c->async.private_data = iname;
-}
+        state->io.in.name         = iname->name;
+        state->io.in.wins_port    = lpcfg_nbt_port(iface->nbtsrv->task->lp_ctx);
+        state->io.in.wins_servers = lpcfg_wins_server_list(iface->nbtsrv->task->lp_ctx);
+        state->io.in.addresses    = nbtd_address_list(iface, state);
+        state->io.in.nb_flags     = iname->nb_flags;
+        state->io.in.ttl          = iname->ttl;
+
+        if (state->io.in.addresses == NULL) {
+                talloc_free(state);
+                return;
+        }
+
+        subreq = nbt_name_register_wins_send(state, iface->nbtsrv->task->event_ctx,
+                                             nbtsock, &state->io);
+        if (subreq == NULL) {
+                talloc_free(state);
+                return;
+        }
+
+        tevent_req_set_callback(subreq, nbtd_wins_register_handler, state);
+}

trunk/server/source4/nbt_server/wins/winsdb.c

@@ -24 +24 @@
 #include "nbt_server/nbt_server.h"
 #include "nbt_server/wins/winsdb.h"
-#include "lib/ldb/include/ldb.h"
-#include "lib/ldb/include/ldb_errors.h"
+#include <ldb.h>
+#include <ldb_errors.h>
 #include "librpc/gen_ndr/ndr_nbt.h"
 #include "system/time.h"
@@ -101 +101 @@
 
         ret = ldb_msg_add_empty(msg, "objectClass", LDB_FLAG_MOD_REPLACE, NULL);
-        if (ret != 0) goto failed;
+        if (ret != LDB_SUCCESS) goto failed;
         ret = ldb_msg_add_string(msg, "objectClass", "winsMaxVersion");
-        if (ret != 0) goto failed;
+        if (ret != LDB_SUCCESS) goto failed;
         ret = ldb_msg_add_empty(msg, "maxVersion", LDB_FLAG_MOD_REPLACE, NULL);
-        if (ret != 0) goto failed;
+        if (ret != LDB_SUCCESS) goto failed;
         ret = ldb_msg_add_fmt(msg, "maxVersion", "%llu", (long long)newMaxVersion);
-        if (ret != 0) goto failed;
+        if (ret != LDB_SUCCESS) goto failed;
 
         ret = ldb_modify(wins_db, msg);
-        if (ret != 0) ret = ldb_add(wins_db, msg);
-        if (ret != 0) goto failed;
+        if (ret != LDB_SUCCESS) ret = ldb_add(wins_db, msg);
+        if (ret != LDB_SUCCESS) goto failed;
 
         trans = ldb_transaction_commit(wins_db);
@@ -260 +260 @@
         }
 
-        *p = '\0';p++;
+        *p = '\0'; p++;
         addr->address = talloc_strdup(addr, address);
         if (!addr->address) {
@@ -320 +320 @@
                                    const char *attr_name, struct winsdb_addr *addr)
 {
-        struct ldb_val val;
         const char *str;
 
         if (rec->is_static) {
                 str = talloc_strdup(msg, addr->address);
-                if (!str) return -1;
+                if (!str) return LDB_ERR_OPERATIONS_ERROR;
         } else {
                 char *expire_time;
                 expire_time = ldb_timestring(msg, addr->expire_time);
-                if (!expire_time) return -1;
+                if (!expire_time) return LDB_ERR_OPERATIONS_ERROR;
                 str = talloc_asprintf(msg, "%s;winsOwner:%s;expireTime:%s;",
                                       addr->address, addr->wins_owner,
                                       expire_time);
                 talloc_free(expire_time);
-                if (!str) return -1;
-        }
-
-        val.data = discard_const_p(uint8_t, str);
-        val.length = strlen(str);
-
-        return ldb_msg_add_value(msg, attr_name, &val, NULL);
+                if (!str) return LDB_ERR_OPERATIONS_ERROR;
+        }
+
+        return ldb_msg_add_string(msg, attr_name, str);
 }
 
@@ -508 +504 @@
         addresses[len+1] = NULL;
 
-        ldb_qsort(addresses, len+1 , sizeof(addresses[0]), h, (ldb_qsort_cmp_fn_t)winsdb_addr_sort_list);
+        LDB_TYPESAFE_QSORT(addresses, len+1, h, winsdb_addr_sort_list);
 
         return addresses;
@@ -751 +747 @@
                                           TALLOC_CTX *mem_ctx)
 {
-        int i, ret=0;
+        int i, ret;
         size_t addr_count;
         const char *expire_time;
@@ -773 +769 @@
         msg->dn = winsdb_dn(msg, ldb, rec->name);
         if (msg->dn == NULL) goto failed;
-        ret |= ldb_msg_add_fmt(msg, "type", "0x%02X", rec->name->type);
+        ret = ldb_msg_add_fmt(msg, "type", "0x%02X", rec->name->type);
         if (rec->name->name && *rec->name->name) {
                 ret |= ldb_msg_add_string(msg, "name", rec->name->name);
@@ -795 +791 @@
                 ret |= ldb_msg_add_winsdb_addr(msg, rec, "address", rec->addresses[i]);
         }
-        ret |= ldb_msg_add_empty(msg, "registeredBy", 0, NULL);
         if (rec->registered_by) {
+                ret |= ldb_msg_add_empty(msg, "registeredBy", 0, NULL);
                 ret |= ldb_msg_add_string(msg, "registeredBy", rec->registered_by);
-                if (ret != 0) goto failed;
-        }
+        }
+        if (ret != LDB_SUCCESS) goto failed;
         return msg;
 
@@ -816 +812 @@
         TALLOC_CTX *tmp_ctx = talloc_new(wins_db);
         int trans = -1;
-        int ret = 0;
+        int ret;
 
         trans = ldb_transaction_start(wins_db);
@@ -833 +829 @@
         if (msg == NULL) goto failed;
         ret = ldb_add(wins_db, msg);
-        if (ret != 0) goto failed;
+        if (ret != LDB_SUCCESS) goto failed;
 
         trans = ldb_transaction_commit(wins_db);
@@ -860 +856 @@
         int trans;
         int ret;
-        int i;
+        unsigned int i;
 
         trans = ldb_transaction_start(wins_db);
@@ -882 +878 @@
 
         ret = ldb_modify(wins_db, msg);
-        if (ret != 0) goto failed;
+        if (ret != LDB_SUCCESS) goto failed;
 
         trans = ldb_transaction_commit(wins_db);
@@ -917 +913 @@
 
         ret = ldb_delete(wins_db, dn);
-        if (ret != 0) goto failed;
+        if (ret != LDB_SUCCESS) goto failed;
 
         trans = ldb_transaction_commit(wins_db);
@@ -963 +959 @@
 
         ret = ldb_msg_add_string(msg, "@LIST", "wins_ldb");
-        if (ret != 0) goto failed;
+        if (ret != LDB_SUCCESS) goto failed;
 
         ret = ldb_add(h->ldb, msg);
-        if (ret != 0) goto failed;
+        if (ret != LDB_SUCCESS) goto failed;
 
         trans = ldb_transaction_commit(h->ldb);
@@ -976 +972 @@
         h->ldb = NULL;
 
-        if (lp_parm_bool(lp_ctx, NULL,"winsdb", "nosync", false)) {
+        if (lpcfg_parm_bool(lp_ctx, NULL,"winsdb", "nosync", false)) {
                 flags |= LDB_FLG_NOSYNC;
         }
 
-        h->ldb = ldb_wrap_connect(h, ev_ctx, lp_ctx, lock_path(h, lp_ctx, lp_wins_url(lp_ctx)),
-                                  NULL, NULL, flags, NULL);
+        h->ldb = ldb_wrap_connect(h, ev_ctx, lp_ctx, lock_path(h, lp_ctx, lpcfg_wins_url(lp_ctx)),
+                                  NULL, NULL, flags);
         if (!h->ldb) goto failed;
 
@@ -1012 +1008 @@
         if (!h) return NULL;
 
-        if (lp_parm_bool(lp_ctx, NULL,"winsdb", "nosync", false)) {
+        if (lpcfg_parm_bool(lp_ctx, NULL,"winsdb", "nosync", false)) {
                 flags |= LDB_FLG_NOSYNC;
         }
 
-        h->ldb = ldb_wrap_connect(h, ev_ctx, lp_ctx, lock_path(h, lp_ctx, lp_wins_url(lp_ctx)),
-                                  NULL, NULL, flags, NULL);
-        if (!h->ldb) goto failed;       
+        h->ldb = ldb_wrap_connect(h, ev_ctx, lp_ctx, lock_path(h, lp_ctx, lpcfg_wins_url(lp_ctx)),
+                                  NULL, NULL, flags);
+        if (!h->ldb) goto failed;
 
         h->caller = caller;
-        h->hook_script = lp_wins_hook(lp_ctx);
+        h->hook_script = lpcfg_wins_hook(lp_ctx);
 
         h->local_owner = talloc_strdup(h, owner);
@@ -1038 +1034 @@
         return NULL;
 }
+

trunk/server/source4/nbt_server/wins/winsserver.c

@@ -33 +33 @@
 #include "lib/socket/socket.h"
 #include "lib/socket/netif.h"
-#include "lib/ldb/include/ldb.h"
+#include <ldb.h>
 #include "param/param.h"
 #include "libcli/resolve/resolve.h"
+#include "lib/util/util_net.h"
 
 /*
@@ -282 +283 @@
 
         /*
-         * now remove all addresses that're the client doesn't hold anymore
-         * and update the time stamp and owner for the ownes that are still there
+         * now remove all addresses that the client doesn't hold anymore
+         * and update the time stamp and owner for the ones that are still there
          */
         for (i=0; rec->addresses[i]; i++) {
@@ -415 +416 @@
 
         s->io.in.nbtd_server    = iface->nbtsrv;
-        s->io.in.nbt_port       = lp_nbt_port(iface->nbtsrv->task->lp_ctx);
+        s->io.in.nbt_port       = lpcfg_nbt_port(iface->nbtsrv->task->lp_ctx);
         s->io.in.event_ctx      = iface->nbtsrv->task->event_ctx;
         s->io.in.name           = rec->name;
@@ -497 +498 @@
         }
 
+        if (name->scope && strlen(name->scope) > 237) {
+                rcode = NBT_RCODE_SVR;
+                goto done;
+        }
+
         duplicate_packet = wins_check_wack_queue(iface, packet, src);
         if (duplicate_packet) {
@@ -665 +671 @@
 
         /* first sort the addresses depending on the matching to the client */
-        ldb_qsort(addresses, num_addrs , sizeof(addresses[0]),
-                  src, (ldb_qsort_cmp_fn_t)nbtd_wins_randomize1Clist_sort);
-
-        mask = lp_parm_string(lp_ctx, NULL, "nbtd", "wins_randomize1Clist_mask");
+        LDB_TYPESAFE_QSORT(addresses, num_addrs, src, nbtd_wins_randomize1Clist_sort);
+
+        mask = lpcfg_parm_string(lp_ctx, NULL, "nbtd", "wins_randomize1Clist_mask");
         if (!mask) {
                 mask = "255.255.255.0";
@@ -746 +751 @@
          */
         if (name->type == NBT_NAME_LOGON && 
-            lp_parm_bool(lp_ctx, NULL, "nbtd", "wins_prepend1Bto1Cqueries", true)) {
+            lpcfg_parm_bool(lp_ctx, NULL, "nbtd", "wins_prepend1Bto1Cqueries", true)) {
                 struct nbt_name name_1b;
 
@@ -760 +765 @@
         status = winsdb_lookup(winssrv->wins_db, name, packet, &rec);
         if (!NT_STATUS_IS_OK(status)) {
-                if (!lp_wins_dns_proxy(lp_ctx)) {
+                if (!lpcfg_wins_dns_proxy(lp_ctx)) {
                         goto notfound;
                 }
@@ -842 +847 @@
          */
         if (name->type == NBT_NAME_LOGON && 
-            lp_parm_bool(lp_ctx, NULL, "nbtd", "wins_randomize1Clist", false)) {
+            lpcfg_parm_bool(lp_ctx, NULL, "nbtd", "wins_randomize1Clist", false)) {
                 nbtd_wins_randomize1Clist(lp_ctx, addresses, src);
         }
@@ -872 +877 @@
 
         if (name->type == NBT_NAME_MASTER) {
+                goto done;
+        }
+
+        if (name->scope && strlen(name->scope) > 237) {
                 goto done;
         }
@@ -951 +960 @@
                         modify_flags = WINSDB_FLAG_ALLOC_VERSION | WINSDB_FLAG_TAKE_OWNERSHIP;
                 }
-                if (lp_parm_bool(iface->nbtsrv->task->lp_ctx, NULL, "wreplsrv", "propagate name releases", false)) {
+                if (lpcfg_parm_bool(iface->nbtsrv->task->lp_ctx, NULL, "wreplsrv", "propagate name releases", false)) {
                         /*
                          * We have an option to propagate every name release,
@@ -1030 +1039 @@
         const char *owner;
 
-        if (!lp_wins_support(nbtsrv->task->lp_ctx)) {
+        if (!lpcfg_wins_support(nbtsrv->task->lp_ctx)) {
                 nbtsrv->winssrv = NULL;
                 return NT_STATUS_OK;
@@ -1038 +1047 @@
         NT_STATUS_HAVE_NO_MEMORY(nbtsrv->winssrv);
 
-        nbtsrv->winssrv->config.max_renew_interval = lp_max_wins_ttl(nbtsrv->task->lp_ctx);
-        nbtsrv->winssrv->config.min_renew_interval = lp_min_wins_ttl(nbtsrv->task->lp_ctx);
-        tmp = lp_parm_int(nbtsrv->task->lp_ctx, NULL, "wreplsrv", "tombstone_interval", 6*24*60*60);
+        nbtsrv->winssrv->config.max_renew_interval = lpcfg_max_wins_ttl(nbtsrv->task->lp_ctx);
+        nbtsrv->winssrv->config.min_renew_interval = lpcfg_min_wins_ttl(nbtsrv->task->lp_ctx);
+        tmp = lpcfg_parm_int(nbtsrv->task->lp_ctx, NULL, "wreplsrv", "tombstone_interval", 6*24*60*60);
         nbtsrv->winssrv->config.tombstone_interval = tmp;
-        tmp = lp_parm_int(nbtsrv->task->lp_ctx, NULL, "wreplsrv"," tombstone_timeout", 1*24*60*60);
+        tmp = lpcfg_parm_int(nbtsrv->task->lp_ctx, NULL, "wreplsrv"," tombstone_timeout", 1*24*60*60);
         nbtsrv->winssrv->config.tombstone_timeout = tmp;
 
-        owner = lp_parm_string(nbtsrv->task->lp_ctx, NULL, "winsdb", "local_owner");
+        owner = lpcfg_parm_string(nbtsrv->task->lp_ctx, NULL, "winsdb", "local_owner");
 
         if (owner == NULL) {
                 struct interface *ifaces;
-                load_interfaces(nbtsrv->task, lp_interfaces(nbtsrv->task->lp_ctx), &ifaces);
+                load_interfaces(nbtsrv->task, lpcfg_interfaces(nbtsrv->task->lp_ctx), &ifaces);
                 owner = iface_n_ip(ifaces, 0);
         }

trunk/server/source4/nbt_server/wins/winsserver.h

@@ -64 +64 @@
 };
 
+struct composite_context;
 #include "nbt_server/wins/winsserver_proto.h"

trunk/server/source4/nbt_server/wins/winswack.c

@@ -164 +164 @@
                         struct nbtd_interface *iface;
 
-                        state->release.in.dest_port = lp_nbt_port(state->io->in.nbtd_server->task->lp_ctx);
+                        state->release.in.dest_port = lpcfg_nbt_port(state->io->in.nbtd_server->task->lp_ctx);
                         state->release.in.dest_addr = state->io->in.addresses[state->current_address];
                         state->release.in.address   = state->release.in.dest_addr;
@@ -224 +224 @@
          */
         state->release.in.name        = *state->io->in.name;
-        state->release.in.dest_port   = lp_nbt_port(state->io->in.nbtd_server->task->lp_ctx);
+        state->release.in.dest_port   = lpcfg_nbt_port(state->io->in.nbtd_server->task->lp_ctx);
         state->release.in.dest_addr   = state->io->in.addresses[state->current_address];
         state->release.in.address     = state->release.in.dest_addr;
@@ -307 +307 @@
 
         s->io.in.nbtd_server    = nbtd_server;
-        s->io.in.nbt_port       = lp_nbt_port(nbtd_server->task->lp_ctx);
+        s->io.in.nbt_port       = lpcfg_nbt_port(nbtd_server->task->lp_ctx);
         s->io.in.event_ctx      = msg->ev;
         s->io.in.name           = &req->in.name;