Ignore:
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:
9 edited

Legend:

Unmodified
Added
Removed

  • trunk/server

  • trunk/server/source4/torture/nbt/browse.c

    r414 r745  
    3636        bool ret = true;
    3737       
    38         name.name = lp_workgroup();
     38        name.name = lpcfg_workgroup();
    3939        name.type = NBT_NAME_BROWSER;
    4040        name.scope = NULL;

  • trunk/server/source4/torture/nbt/dgram.c

    r414 r745  
    2222#include "includes.h"
    2323#include "libcli/dgram/libdgram.h"
    24 #include "librpc/gen_ndr/samr.h"
    25 #include "librpc/gen_ndr/ndr_nbt.h"
    26 #include "librpc/gen_ndr/ndr_netlogon.h"
    2724#include "lib/socket/socket.h"
    2825#include "lib/events/events.h"
    29 #include "torture/rpc/rpc.h"
     26#include "torture/rpc/torture_rpc.h"
    3027#include "libcli/resolve/resolve.h"
    3128#include "system/network.h"
    … …  
    6865{
    6966        struct dgram_mailslot_handler *dgmslot;
    70         struct nbt_dgram_socket *dgmsock = nbt_dgram_socket_init(tctx, tctx->ev,
    71                                                                  lp_iconv_convenience(tctx->lp_ctx));
     67        struct nbt_dgram_socket *dgmsock = nbt_dgram_socket_init(tctx, tctx->ev);
    7268        struct socket_address *dest;
    7369        const char *myaddress;
    … …  
    8581        struct interface *ifaces;
    8682
    87         name.name = lp_workgroup(tctx->lp_ctx);
     83        name.name = lpcfg_workgroup(tctx->lp_ctx);
    8884        name.type = NBT_NAME_LOGON;
    8985        name.scope = NULL;
    … …  
    9187        /* do an initial name resolution to find its IP */
    9288        torture_assert_ntstatus_ok(tctx,
    93                                    resolve_name(lp_resolve_context(tctx->lp_ctx), &name, tctx, &address, tctx->ev),
     89                                   resolve_name(lpcfg_resolve_context(tctx->lp_ctx), &name, tctx, &address, tctx->ev),
    9490                                   talloc_asprintf(tctx, "Failed to resolve %s", name.name));
    9591
    96         load_interfaces(tctx, lp_interfaces(tctx->lp_ctx), &ifaces);
     92        load_interfaces(tctx, lpcfg_interfaces(tctx->lp_ctx), &ifaces);
    9793        myaddress = talloc_strdup(dgmsock, iface_best_ip(ifaces, address));
    9894
    9995
    10096        socket_address = socket_address_from_strings(dgmsock, dgmsock->sock->backend_name,
    101                                                      myaddress, lp_dgram_port(tctx->lp_ctx));
     97                                                     myaddress, lpcfg_dgram_port(tctx->lp_ctx));
    10298        torture_assert(tctx, socket_address != NULL, "Error getting address");
    10399
    … …  
    119115        dgmslot = dgram_mailslot_temp(dgmsock, NBT_MAILSLOT_GETDC,
    120116                                      netlogon_handler, NULL);
     117        torture_assert(tctx, dgmslot != NULL, "Error temporary mailslot for GetDC");
    121118
    122119        ZERO_STRUCT(logon);
    … …  
    132129
    133130        dest = socket_address_from_strings(dgmsock, dgmsock->sock->backend_name,
    134                                            address, lp_dgram_port(tctx->lp_ctx));
     131                                           address, lpcfg_dgram_port(tctx->lp_ctx));
    135132        torture_assert(tctx, dest != NULL, "Error getting address");
    136133
    … …  
    159156{
    160157        struct dgram_mailslot_handler *dgmslot;
    161         struct nbt_dgram_socket *dgmsock = nbt_dgram_socket_init(tctx, tctx->ev,
    162                                                                  lp_iconv_convenience(tctx->lp_ctx));
     158        struct nbt_dgram_socket *dgmsock = nbt_dgram_socket_init(tctx, tctx->ev);
    163159        struct socket_address *dest;
    164160        const char *myaddress;
    … …  
    179175        const struct dom_sid *dom_sid;
    180176       
    181         name.name = lp_workgroup(tctx->lp_ctx);
     177        name.name = lpcfg_workgroup(tctx->lp_ctx);
    182178        name.type = NBT_NAME_LOGON;
    183179        name.scope = NULL;
    … …  
    185181        /* do an initial name resolution to find its IP */
    186182        torture_assert_ntstatus_ok(tctx,
    187                                    resolve_name(lp_resolve_context(tctx->lp_ctx), &name, tctx, &address, tctx->ev),
     183                                   resolve_name(lpcfg_resolve_context(tctx->lp_ctx), &name, tctx, &address, tctx->ev),
    188184                                   talloc_asprintf(tctx, "Failed to resolve %s", name.name));
    189185
    190         load_interfaces(tctx, lp_interfaces(tctx->lp_ctx), &ifaces);
     186        load_interfaces(tctx, lpcfg_interfaces(tctx->lp_ctx), &ifaces);
    191187        myaddress = talloc_strdup(dgmsock, iface_best_ip(ifaces, address));
    192188
    193189        socket_address = socket_address_from_strings(dgmsock, dgmsock->sock->backend_name,
    194                                                      myaddress, lp_dgram_port(tctx->lp_ctx));
     190                                                     myaddress, lpcfg_dgram_port(tctx->lp_ctx));
    195191        torture_assert(tctx, socket_address != NULL, "Error getting address");
    196192
    … …  
    212208        dgmslot = dgram_mailslot_temp(dgmsock, NBT_MAILSLOT_GETDC,
    213209                                      netlogon_handler, NULL);
    214        
     210        torture_assert(tctx, dgmslot != NULL, "Error temporary mailslot for GetDC");
    215211
    216212        ZERO_STRUCT(logon);
    … …  
    227223
    228224        dest = socket_address_from_strings(dgmsock, dgmsock->sock->backend_name,
    229                                            address, lp_dgram_port(tctx->lp_ctx));
     225                                           address, lpcfg_dgram_port(tctx->lp_ctx));
    230226
    231227        torture_assert(tctx, dest != NULL, "Error getting address");
    … …  
    252248        dgmslot = dgram_mailslot_temp(dgmsock, NBT_MAILSLOT_GETDC,
    253249                                      netlogon_handler, NULL);
     250        torture_assert(tctx, dgmslot != NULL, "Error temporary mailslot for GetDC");
    254251       
    255252        ZERO_STRUCT(logon);
    … …  
    266263
    267264        dest = socket_address_from_strings(dgmsock, dgmsock->sock->backend_name,
    268                                            address, lp_dgram_port(tctx->lp_ctx));
     265                                           address, lpcfg_dgram_port(tctx->lp_ctx));
    269266
    270267        torture_assert(tctx, dest != NULL, "Error getting address");
    … …  
    294291        torture_assert(tctx, join_ctx != NULL,
    295292                       talloc_asprintf(tctx, "Failed to join domain %s as %s\n",
    296                                        lp_workgroup(tctx->lp_ctx), TEST_NAME));
     293                                       lpcfg_workgroup(tctx->lp_ctx), TEST_NAME));
    297294
    298295        dom_sid = torture_join_sid(join_ctx);
    … …  
    301298        dgmslot = dgram_mailslot_temp(dgmsock, NBT_MAILSLOT_GETDC,
    302299                                      netlogon_handler, NULL);
     300        torture_assert(tctx, dgmslot != NULL, "Error temporary mailslot for GetDC");
    303301       
    304302        ZERO_STRUCT(logon);
    … …  
    316314
    317315        dest = socket_address_from_strings(dgmsock, dgmsock->sock->backend_name,
    318                                            address, lp_dgram_port(tctx->lp_ctx));
     316                                           address, lpcfg_dgram_port(tctx->lp_ctx));
    319317
    320318        torture_assert(tctx, dest != NULL, "Error getting address");
    … …  
    341339        dgmslot = dgram_mailslot_temp(dgmsock, NBT_MAILSLOT_GETDC,
    342340                                      netlogon_handler, NULL);
    343        
    344341        torture_assert(tctx, dgmslot != NULL, "Error getting a Mailslot for GetDC reply");
    345342
    … …  
    359356
    360357        dest = socket_address_from_strings(dgmsock, dgmsock->sock->backend_name,
    361                                            address, lp_dgram_port(tctx->lp_ctx));
     358                                           address, lpcfg_dgram_port(tctx->lp_ctx));
    362359
    363360        torture_assert(tctx, dest != NULL, "Error getting address");
    … …  
    398395
    399396        dest = socket_address_from_strings(dgmsock, dgmsock->sock->backend_name,
    400                                            address, lp_dgram_port(tctx->lp_ctx));
     397                                           address, lpcfg_dgram_port(tctx->lp_ctx));
    401398
    402399        torture_assert(tctx, dest != NULL, "Error getting address");
    … …  
    429426{
    430427        struct dgram_mailslot_handler *dgmslot;
    431         struct nbt_dgram_socket *dgmsock = nbt_dgram_socket_init(tctx, tctx->ev,
    432                                                                  lp_iconv_convenience(tctx->lp_ctx));
     428        struct nbt_dgram_socket *dgmsock = nbt_dgram_socket_init(tctx, tctx->ev);
    433429        struct socket_address *dest;
    434430        struct test_join *join_ctx;
    … …  
    449445        struct interface *ifaces;
    450446       
    451         name.name = lp_workgroup(tctx->lp_ctx);
     447        name.name = lpcfg_workgroup(tctx->lp_ctx);
    452448        name.type = NBT_NAME_LOGON;
    453449        name.scope = NULL;
    … …  
    455451        /* do an initial name resolution to find its IP */
    456452        torture_assert_ntstatus_ok(tctx,
    457                                    resolve_name(lp_resolve_context(tctx->lp_ctx), &name, tctx, &address, tctx->ev),
     453                                   resolve_name(lpcfg_resolve_context(tctx->lp_ctx), &name, tctx, &address, tctx->ev),
    458454                                   talloc_asprintf(tctx, "Failed to resolve %s", name.name));
    459455
    460         load_interfaces(tctx, lp_interfaces(tctx->lp_ctx), &ifaces);
     456        load_interfaces(tctx, lpcfg_interfaces(tctx->lp_ctx), &ifaces);
    461457        myaddress = talloc_strdup(dgmsock, iface_best_ip(ifaces, address));
    462458
    463459        socket_address = socket_address_from_strings(dgmsock, dgmsock->sock->backend_name,
    464                                                      myaddress, lp_dgram_port(tctx->lp_ctx));
     460                                                     myaddress, lpcfg_dgram_port(tctx->lp_ctx));
    465461        torture_assert(tctx, socket_address != NULL, "Error getting address");
    466462
    … …  
    485481        torture_assert(tctx, join_ctx != NULL,
    486482                       talloc_asprintf(tctx, "Failed to join domain %s as %s\n",
    487                                        lp_workgroup(tctx->lp_ctx), TEST_NAME));
     483                                       lpcfg_workgroup(tctx->lp_ctx), TEST_NAME));
    488484
    489485        /* setup a temporary mailslot listener for replies */
    490486        dgmslot = dgram_mailslot_temp(dgmsock, NBT_MAILSLOT_GETDC,
    491487                                      netlogon_handler, NULL);
    492        
     488        torture_assert(tctx, dgmslot != NULL, "Error temporary mailslot for GetDC");
    493489
    494490        ZERO_STRUCT(logon);
    … …  
    508504
    509505        dest = socket_address_from_strings(dgmsock, dgmsock->sock->backend_name,
    510                                            address, lp_dgram_port(tctx->lp_ctx));
     506                                           address, lpcfg_dgram_port(tctx->lp_ctx));
    511507        torture_assert(tctx, dest != NULL, "Error getting address");
    512508        status = dgram_mailslot_netlogon_send(dgmsock,
    … …  
    535531        dgmslot = dgram_mailslot_temp(dgmsock, NBT_MAILSLOT_GETDC,
    536532                                      netlogon_handler, NULL);
    537        
     533        torture_assert(tctx, dgmslot != NULL, "Error temporary mailslot for GetDC");
    538534
    539535        ZERO_STRUCT(logon);
    … …  
    552548
    553549        dest = socket_address_from_strings(dgmsock, dgmsock->sock->backend_name,
    554                                            address, lp_dgram_port(tctx->lp_ctx));
     550                                           address, lpcfg_dgram_port(tctx->lp_ctx));
    555551        torture_assert(tctx, dest != NULL, "Error getting address");
    556552        status = dgram_mailslot_netlogon_send(dgmsock,
    … …  
    579575        dgmslot = dgram_mailslot_temp(dgmsock, NBT_MAILSLOT_GETDC,
    580576                                      netlogon_handler, NULL);
     577        torture_assert(tctx, dgmslot != NULL, "Error temporary mailslot for GetDC");
    581578       
    582579        ZERO_STRUCT(logon);
    … …  
    592589
    593590        dest = socket_address_from_strings(dgmsock, dgmsock->sock->backend_name,
    594                                            address, lp_dgram_port(tctx->lp_ctx));
     591                                           address, lpcfg_dgram_port(tctx->lp_ctx));
    595592        torture_assert(tctx, dest != NULL, "Error getting address");
    596593        status = dgram_mailslot_netlogon_send(dgmsock,
    … …  
    616613        dgmslot = dgram_mailslot_temp(dgmsock, NBT_MAILSLOT_GETDC,
    617614                                      netlogon_handler, NULL);
     615        torture_assert(tctx, dgmslot != NULL, "Error temporary mailslot for GetDC");
    618616       
    619617        ZERO_STRUCT(logon);
    … …  
    629627
    630628        dest = socket_address_from_strings(dgmsock, dgmsock->sock->backend_name,
    631                                            address, lp_dgram_port(tctx->lp_ctx));
     629                                           address, lpcfg_dgram_port(tctx->lp_ctx));
    632630        torture_assert(tctx, dest != NULL, "Error getting address");
    633631        status = dgram_mailslot_netlogon_send(dgmsock,
    … …  
    658656struct torture_suite *torture_nbt_dgram(TALLOC_CTX *mem_ctx)
    659657{
    660         struct torture_suite *suite = torture_suite_create(mem_ctx, "DGRAM");
     658        struct torture_suite *suite = torture_suite_create(mem_ctx, "dgram");
    661659
    662660        torture_suite_add_simple_test(suite, "netlogon", nbt_test_netlogon);

  • trunk/server/source4/torture/nbt/nbt.c

    r414 r745  
    2828struct nbt_name_socket *torture_init_nbt_socket(struct torture_context *tctx)
    2929{
    30         return nbt_name_socket_init(tctx, tctx->ev, lp_iconv_convenience(tctx->lp_ctx));
     30        return nbt_name_socket_init(tctx, tctx->ev);
    3131}
    3232
    … …  
    4040        /* do an initial name resolution to find its IP */
    4141        torture_assert_ntstatus_ok(tctx,
    42                                    resolve_name(lp_resolve_context(tctx->lp_ctx), name, tctx, address, tctx->ev),
     42                                   resolve_name(lpcfg_resolve_context(tctx->lp_ctx), name, tctx, address, tctx->ev),
    4343                                   talloc_asprintf(tctx,
    4444                                                   "Failed to resolve %s", name->name));
    … …  
    5050{
    5151        struct torture_suite *suite = torture_suite_create(
    52                 talloc_autofree_context(), "NBT");
     52                talloc_autofree_context(), "nbt");
    5353        /* nbt tests */
    5454        torture_suite_add_suite(suite, torture_nbt_register(suite));

  • trunk/server/source4/torture/nbt/query.c

    r414 r745  
    6363        io.in.name = name;
    6464        io.in.dest_addr = address;
    65         io.in.dest_port = lp_nbt_port(tctx->lp_ctx);
     65        io.in.dest_port = lpcfg_nbt_port(tctx->lp_ctx);
    6666        io.in.broadcast = false;
    6767        io.in.wins_lookup = false;
    … …  
    109109struct torture_suite *torture_bench_nbt(TALLOC_CTX *mem_ctx)
    110110{
    111         struct torture_suite *suite = torture_suite_create(mem_ctx, "BENCH");
     111        struct torture_suite *suite = torture_suite_create(mem_ctx, "bench");
    112112        torture_suite_add_simple_test(suite, "namequery", bench_namequery);
    113113

  • trunk/server/source4/torture/nbt/register.c

    r414 r745  
    5555                return false;
    5656
    57         load_interfaces(tctx, lp_interfaces(tctx->lp_ctx), &ifaces);
     57        load_interfaces(tctx, lpcfg_interfaces(tctx->lp_ctx), &ifaces);
    5858
    5959        myaddress = iface_best_ip(ifaces, address);
    … …  
    7171        io.in.name = name;
    7272        io.in.dest_addr = address;
    73         io.in.dest_port = lp_nbt_port(tctx->lp_ctx);
     73        io.in.dest_port = lpcfg_nbt_port(tctx->lp_ctx);
    7474        io.in.address = myaddress;
    7575        io.in.nb_flags = NBT_NODE_B | NBT_NM_ACTIVE;
    … …  
    124124                return false;
    125125       
    126         load_interfaces(tctx, lp_interfaces(tctx->lp_ctx), &ifaces);
     126        load_interfaces(tctx, lpcfg_interfaces(tctx->lp_ctx), &ifaces);
    127127
    128128        myaddress = iface_best_ip(ifaces, address);
    … …  
    141141        io.in.name = name;
    142142        io.in.dest_addr = address;
    143         io.in.dest_port = lp_nbt_port(tctx->lp_ctx);
     143        io.in.dest_port = lpcfg_nbt_port(tctx->lp_ctx);
    144144        io.in.address = myaddress;
    145145        io.in.nb_flags = NBT_NODE_B | NBT_NM_ACTIVE;
    … …  
    169169        struct torture_suite *suite;
    170170
    171         suite = torture_suite_create(mem_ctx, "REGISTER");
     171        suite = torture_suite_create(mem_ctx, "register");
    172172        torture_suite_add_simple_test(suite, "register_own", nbt_register_own);
    173173        torture_suite_add_simple_test(suite, "refresh_own", nbt_refresh_own);

  • trunk/server/source4/torture/nbt/wins.c

    r414 r745  
    5050static bool nbt_test_wins_name(struct torture_context *tctx, const char *address,
    5151                               struct nbt_name *name, uint16_t nb_flags,
    52                                bool try_low_port)
     52                               bool try_low_port,
     53                               uint8_t register_rcode)
    5354{
    5455        struct nbt_name_register_wins io;
    … …  
    6566        bool low_port = try_low_port;
    6667
    67         load_interfaces(tctx, lp_interfaces(tctx->lp_ctx), &ifaces);
     68        load_interfaces(tctx, lpcfg_interfaces(tctx->lp_ctx), &ifaces);
    6869
    6970        myaddress = talloc_strdup(tctx, iface_best_ip(ifaces, address));
    … …  
    7172        socket_address = socket_address_from_strings(tctx,
    7273                                                     nbtsock->sock->backend_name,
    73                                                      myaddress, lp_nbt_port(tctx->lp_ctx));
     74                                                     myaddress, lpcfg_nbt_port(tctx->lp_ctx));
    7475        torture_assert(tctx, socket_address != NULL,
    7576                                   "Error getting address");
    … …  
    9899        torture_comment(tctx, "release the name\n");
    99100        release.in.name = *name;
    100         release.in.dest_port = lp_nbt_port(tctx->lp_ctx);
     101        release.in.dest_port = lpcfg_nbt_port(tctx->lp_ctx);
    101102        release.in.dest_addr = address;
    102103        release.in.address = myaddress;
    … …  
    117118                torture_comment(tctx, "register the name with a wrong address (makes the next request slow!)\n");
    118119                io.in.name = *name;
    119                 io.in.wins_port = lp_nbt_port(tctx->lp_ctx);
    120                 io.in.wins_servers = str_list_make_single(tctx, address);
    121                 io.in.addresses = str_list_make_single(tctx, "127.64.64.1");
     120                io.in.wins_port = lpcfg_nbt_port(tctx->lp_ctx);
     121                io.in.wins_servers = const_str_list(
     122                        str_list_make_single(tctx, address));
     123                io.in.addresses = const_str_list(
     124                        str_list_make_single(tctx, "127.64.64.1"));
    122125                io.in.nb_flags = nb_flags;
    123126                io.in.ttl = 300000;
    … …  
    138141                torture_comment(tctx, "register the name correct address\n");
    139142                name_register.in.name           = *name;
    140                 name_register.in.dest_port      = lp_nbt_port(tctx->lp_ctx);
     143                name_register.in.dest_port      = lpcfg_nbt_port(tctx->lp_ctx);
    141144                name_register.in.dest_addr      = address;
    142145                name_register.in.address        = myaddress;
    … …  
    189192        torture_comment(tctx, "register the name correct address\n");
    190193        io.in.name = *name;
    191         io.in.wins_port = lp_nbt_port(tctx->lp_ctx);
     194        io.in.wins_port = lpcfg_nbt_port(tctx->lp_ctx);
    192195        io.in.wins_servers = (const char **)str_list_make_single(tctx, address);
    193196        io.in.addresses = (const char **)str_list_make_single(tctx, myaddress);
    … …  
    199202       
    200203        CHECK_STRING(tctx, io.out.wins_server, address);
    201         CHECK_VALUE(tctx, io.out.rcode, 0);
     204        CHECK_VALUE(tctx, io.out.rcode, register_rcode);
     205
     206        if (register_rcode != NBT_RCODE_OK) {
     207                return true;
     208        }
    202209
    203210        if (name->type != NBT_NAME_MASTER &&
    … …  
    216223        query.in.name = *name;
    217224        query.in.dest_addr = address;
    218         query.in.dest_port = lp_nbt_port(tctx->lp_ctx);
     225        query.in.dest_port = lpcfg_nbt_port(tctx->lp_ctx);
    219226        query.in.broadcast = false;
    220227        query.in.wins_lookup = true;
    … …  
    262269        torture_comment(tctx, "refresh the name\n");
    263270        refresh.in.name = *name;
    264         refresh.in.wins_port = lp_nbt_port(tctx->lp_ctx);
     271        refresh.in.wins_port = lpcfg_nbt_port(tctx->lp_ctx);
    265272        refresh.in.wins_servers = (const char **)str_list_make_single(tctx, address);
    266273        refresh.in.addresses = (const char **)str_list_make_single(tctx, myaddress);
    … …  
    283290        printf("release the name\n");
    284291        release.in.name = *name;
    285         release.in.dest_port = lp_nbt_port(tctx->lp_ctx);
     292        release.in.dest_port = lpcfg_nbt_port(tctx->lp_ctx);
    286293        release.in.dest_addr = address;
    287294        release.in.address = myaddress;
    … …  
    311318                torture_comment(tctx, "register the name with a wrong address (makes the next request slow!)\n");
    312319                io.in.name = *name;
    313                 io.in.wins_port = lp_nbt_port(tctx->lp_ctx);
    314                 io.in.wins_servers = str_list_make_single(tctx, address);
    315                 io.in.addresses = str_list_make_single(tctx, "127.64.64.1");
     320                io.in.wins_port = lpcfg_nbt_port(tctx->lp_ctx);
     321                io.in.wins_servers = const_str_list(
     322                        str_list_make_single(tctx, address));
     323                io.in.addresses = const_str_list(
     324                        str_list_make_single(tctx, "127.64.64.1"));
    316325                io.in.nb_flags = nb_flags;
    317326                io.in.ttl = 300000;
    … …  
    333342        torture_comment(tctx, "refresh the name with the correct address\n");
    334343        refresh.in.name = *name;
    335         refresh.in.wins_port = lp_nbt_port(tctx->lp_ctx);
    336         refresh.in.wins_servers = str_list_make_single(tctx, address);
    337         refresh.in.addresses = str_list_make_single(tctx, myaddress);
     344        refresh.in.wins_port = lpcfg_nbt_port(tctx->lp_ctx);
     345        refresh.in.wins_servers = const_str_list(
     346                        str_list_make_single(tctx, address));
     347        refresh.in.addresses = const_str_list(
     348                        str_list_make_single(tctx, myaddress));
    338349        refresh.in.nb_flags = nb_flags;
    339350        refresh.in.ttl = 12345;
    … …  
    354365        torture_comment(tctx, "release the name\n");
    355366        release.in.name = *name;
    356         release.in.dest_port = lp_nbt_port(tctx->lp_ctx);
     367        release.in.dest_port = lpcfg_nbt_port(tctx->lp_ctx);
    357368        release.in.dest_addr = address;
    358369        release.in.address = myaddress;
    … …  
    395406
    396407
     408static char *test_nbt_wins_scope_string(TALLOC_CTX *mem_ctx, uint8_t count)
     409{
     410        char *res;
     411        uint8_t i;
     412
     413        res = talloc_array(mem_ctx, char, count+1);
     414        if (res == NULL) {
     415                return NULL;
     416        }
     417
     418        for (i=0; i < count; i++) {
     419                switch (i) {
     420                case 63:
     421                case 63 + 1 + 63:
     422                case 63 + 1 + 63 + 1 + 63:
     423                        res[i] = '.';
     424                        break;
     425                default:
     426                        res[i] = '0' + (i%10);
     427                        break;
     428                }
     429        }
     430
     431        res[count] = '\0';
     432
     433        talloc_set_name_const(res, res);
     434
     435        return res;
     436}
    397437
    398438/*
    … …  
    413453        name.type = NBT_NAME_CLIENT;
    414454        name.scope = NULL;
    415         ret &= nbt_test_wins_name(tctx, address, &name, NBT_NODE_H, true);
     455        ret &= nbt_test_wins_name(tctx, address, &name,
     456                                  NBT_NODE_H, true, NBT_RCODE_OK);
    416457
    417458        name.type = NBT_NAME_MASTER;
    418         ret &= nbt_test_wins_name(tctx, address, &name, NBT_NODE_H, false);
    419 
    420         ret &= nbt_test_wins_name(tctx, address, &name, NBT_NODE_H | NBT_NM_GROUP, false);
     459        ret &= nbt_test_wins_name(tctx, address, &name,
     460                                  NBT_NODE_H, false, NBT_RCODE_OK);
     461
     462        ret &= nbt_test_wins_name(tctx, address, &name,
     463                                  NBT_NODE_H | NBT_NM_GROUP, false, NBT_RCODE_OK);
    421464
    422465        name.type = NBT_NAME_SERVER;
    423         ret &= nbt_test_wins_name(tctx, address, &name, NBT_NODE_H, true);
     466        ret &= nbt_test_wins_name(tctx, address, &name,
     467                                  NBT_NODE_H, true, NBT_RCODE_OK);
    424468
    425469        name.type = NBT_NAME_LOGON;
    426         ret &= nbt_test_wins_name(tctx, address, &name, NBT_NODE_H | NBT_NM_GROUP, false);
     470        ret &= nbt_test_wins_name(tctx, address, &name,
     471                                  NBT_NODE_H | NBT_NM_GROUP, false, NBT_RCODE_OK);
    427472
    428473        name.type = NBT_NAME_BROWSER;
    429         ret &= nbt_test_wins_name(tctx, address, &name, NBT_NODE_H | NBT_NM_GROUP, false);
     474        ret &= nbt_test_wins_name(tctx, address, &name,
     475                                  NBT_NODE_H | NBT_NM_GROUP, false, NBT_RCODE_OK);
    430476
    431477        name.type = NBT_NAME_PDC;
    432         ret &= nbt_test_wins_name(tctx, address, &name, NBT_NODE_H, true);
     478        ret &= nbt_test_wins_name(tctx, address, &name,
     479                                  NBT_NODE_H, true, NBT_RCODE_OK);
    433480
    434481        name.type = 0xBF;
    435         ret &= nbt_test_wins_name(tctx, address, &name, NBT_NODE_H, true);
     482        ret &= nbt_test_wins_name(tctx, address, &name,
     483                                  NBT_NODE_H, true, NBT_RCODE_OK);
    436484
    437485        name.type = 0xBE;
    438         ret &= nbt_test_wins_name(tctx, address, &name, NBT_NODE_H, false);
     486        ret &= nbt_test_wins_name(tctx, address, &name,
     487                                  NBT_NODE_H, false, NBT_RCODE_OK);
    439488
    440489        name.scope = "example";
    441490        name.type = 0x72;
    442         ret &= nbt_test_wins_name(tctx, address, &name, NBT_NODE_H, true);
     491        ret &= nbt_test_wins_name(tctx, address, &name,
     492                                  NBT_NODE_H, true, NBT_RCODE_OK);
    443493
    444494        name.scope = "example";
    445495        name.type = 0x71;
    446         ret &= nbt_test_wins_name(tctx, address, &name, NBT_NODE_H | NBT_NM_GROUP, false);
     496        ret &= nbt_test_wins_name(tctx, address, &name,
     497                                  NBT_NODE_H | NBT_NM_GROUP, false, NBT_RCODE_OK);
    447498
    448499        name.scope = "foo.example.com";
    449500        name.type = 0x72;
    450         ret &= nbt_test_wins_name(tctx, address, &name, NBT_NODE_H, false);
     501        ret &= nbt_test_wins_name(tctx, address, &name,
     502                                  NBT_NODE_H, false, NBT_RCODE_OK);
    451503
    452504        name.name = talloc_asprintf(tctx, "_T\01-%5u.foo", r);
    453         ret &= nbt_test_wins_name(tctx, address, &name, NBT_NODE_H, false);
     505        ret &= nbt_test_wins_name(tctx, address, &name,
     506                                  NBT_NODE_H, false, NBT_RCODE_OK);
    454507
    455508        name.name = "";
    456         ret &= nbt_test_wins_name(tctx, address, &name, NBT_NODE_H, false);
     509        ret &= nbt_test_wins_name(tctx, address, &name,
     510                                  NBT_NODE_H, false, NBT_RCODE_OK);
    457511
    458512        name.name = talloc_asprintf(tctx, ".");
    459         ret &= nbt_test_wins_name(tctx, address, &name, NBT_NODE_H, false);
     513        ret &= nbt_test_wins_name(tctx, address, &name,
     514                                  NBT_NODE_H, false, NBT_RCODE_OK);
    460515
    461516        name.name = talloc_asprintf(tctx, "%5u-\377\200\300FOO", r);
    462         ret &= nbt_test_wins_name(tctx, address, &name, NBT_NODE_H, false);
     517        ret &= nbt_test_wins_name(tctx, address, &name,
     518                                  NBT_NODE_H, false, NBT_RCODE_OK);
     519
     520        name.scope = test_nbt_wins_scope_string(tctx, 237);
     521        ret &= nbt_test_wins_name(tctx, address, &name,
     522                                  NBT_NODE_H, false, NBT_RCODE_OK);
     523
     524        name.scope = test_nbt_wins_scope_string(tctx, 238);
     525        ret &= nbt_test_wins_name(tctx, address, &name,
     526                                  NBT_NODE_H, false, NBT_RCODE_SVR);
    463527
    464528        return ret;
    … …  
    470534struct torture_suite *torture_nbt_wins(TALLOC_CTX *mem_ctx)
    471535{
    472         struct torture_suite *suite = torture_suite_create(mem_ctx, "WINS");
     536        struct torture_suite *suite = torture_suite_create(mem_ctx, "wins");
    473537
    474538        torture_suite_add_simple_test(suite, "wins", nbt_test_wins);

  • trunk/server/source4/torture/nbt/winsbench.c

    r414 r745  
    226226static bool bench_wins(struct torture_context *tctx)
    227227{
    228         struct nbt_name_socket *nbtsock = nbt_name_socket_init(tctx, tctx->ev, lp_iconv_convenience(tctx->lp_ctx));
     228        struct nbt_name_socket *nbtsock = nbt_name_socket_init(tctx, tctx->ev);
    229229        int num_sent=0;
    230230        struct timeval tv = timeval_current();
    … …  
    246246        state->registered = talloc_zero_array(state, bool, state->num_names);
    247247        state->wins_server = address;
    248         state->wins_port = lp_nbt_port(tctx->lp_ctx);
    249         load_interfaces(tctx, lp_interfaces(tctx->lp_ctx), &ifaces);
     248        state->wins_port = lpcfg_nbt_port(tctx->lp_ctx);
     249        load_interfaces(tctx, lpcfg_interfaces(tctx->lp_ctx), &ifaces);
    250250        state->my_ip = talloc_strdup(tctx, iface_best_ip(ifaces, address));
    251251        state->ttl = timelimit;
    … …  
    293293struct torture_suite *torture_bench_wins(TALLOC_CTX *mem_ctx)
    294294{
    295         struct torture_suite *suite = torture_suite_create(mem_ctx,
    296                                                            "BENCH-WINS");
     295        struct torture_suite *suite = torture_suite_create(mem_ctx, "bench-wins");
    297296
    298297        torture_suite_add_simple_test(suite, "wins", bench_wins);

  • trunk/server/source4/torture/nbt/winsreplication.c

    r414 r745  
    2525#include "lib/events/events.h"
    2626#include "lib/socket/socket.h"
    27 #include "libcli/resolve/resolve.h"
    2827#include "system/network.h"
    2928#include "lib/socket/netif.h"
    … …  
    8584{
    8685        bool ret = true;
    87         struct wrepl_request *req;
     86        struct tevent_req *subreq;
    8887        struct wrepl_socket *wrepl_socket1;
    8988        struct wrepl_associate associate1;
    9089        struct wrepl_socket *wrepl_socket2;
    9190        struct wrepl_associate associate2;
    92         struct wrepl_pull_table pull_table;
    9391        struct wrepl_packet packet;
    9492        struct wrepl_send_ctrl ctrl;
    … …  
    9896        struct nbt_name name;
    9997        const char *address;
     98        bool ok;
    10099
    101100        if (!torture_nbt_get_name(tctx, &name, &address))
    … …  
    104103        torture_comment(tctx, "Test if assoc_ctx is only valid on the conection it was created on\n");
    105104
    106         wrepl_socket1 = wrepl_socket_init(tctx, tctx->ev, lp_iconv_convenience(tctx->lp_ctx));
    107         wrepl_socket2 = wrepl_socket_init(tctx, tctx->ev, lp_iconv_convenience(tctx->lp_ctx));
     105        wrepl_socket1 = wrepl_socket_init(tctx, tctx->ev);
     106        wrepl_socket2 = wrepl_socket_init(tctx, tctx->ev);
    108107
    109108        torture_comment(tctx, "Setup 2 wrepl connections\n");
    … …  
    134133        ZERO_STRUCT(ctrl);
    135134        ctrl.send_only = true;
    136         req = wrepl_request_send(wrepl_socket2, &packet, &ctrl);
    137         status = wrepl_request_recv(req, tctx, &rep_packet);
     135        subreq = wrepl_request_send(tctx, tctx->ev, wrepl_socket2, &packet, &ctrl);
     136        ok = tevent_req_poll(subreq, tctx->ev);
     137        if (!ok) {
     138                CHECK_STATUS(tctx, NT_STATUS_INTERNAL_ERROR, NT_STATUS_OK);
     139        }
     140        status = wrepl_request_recv(subreq, tctx, &rep_packet);
     141        TALLOC_FREE(subreq);
    138142        CHECK_STATUS(tctx, status, NT_STATUS_OK);
    139143
    … …  
    143147
    144148        torture_comment(tctx, "Send a replication table query, with invalid assoc (conn1), receive answer from conn2\n");
    145         pull_table.in.assoc_ctx = 0;
    146         req = wrepl_pull_table_send(wrepl_socket1, &pull_table);
    147         status = wrepl_request_recv(req, tctx, &rep_packet);
     149        ZERO_STRUCT(packet);
     150        packet.opcode                           = WREPL_OPCODE_BITS;
     151        packet.assoc_ctx                        = 0;
     152        packet.mess_type                        = WREPL_REPLICATION;
     153        packet.message.replication.command      = WREPL_REPL_TABLE_QUERY;
     154        status = wrepl_request(wrepl_socket1, tctx, &packet, &rep_packet);
    148155        CHECK_STATUS(tctx, status, NT_STATUS_OK);
    149156
    … …  
    187194        torture_comment(tctx, "Test if we always get back the same assoc_ctx\n");
    188195
    189         wrepl_socket = wrepl_socket_init(tctx, tctx->ev, lp_iconv_convenience(tctx->lp_ctx));
     196        wrepl_socket = wrepl_socket_init(tctx, tctx->ev);
    190197       
    191198        torture_comment(tctx, "Setup wrepl connections\n");
    … …  
    256263        torture_comment(tctx, "Test one pull replication cycle\n");
    257264
    258         wrepl_socket = wrepl_socket_init(tctx, tctx->ev, lp_iconv_convenience(tctx->lp_ctx));
     265        wrepl_socket = wrepl_socket_init(tctx, tctx->ev);
    259266       
    260267        torture_comment(tctx, "Setup wrepl connections\n");
    … …  
    274281        status = wrepl_pull_table(wrepl_socket, tctx, &pull_table);
    275282        if (NT_STATUS_EQUAL(NT_STATUS_NETWORK_ACCESS_DENIED,status)) {
    276                 struct wrepl_packet packet;
    277                 struct wrepl_request *req;
    278 
    279                 ZERO_STRUCT(packet);
    280                 packet.opcode                      = WREPL_OPCODE_BITS;
    281                 packet.assoc_ctx                   = associate.out.assoc_ctx;
    282                 packet.mess_type                   = WREPL_STOP_ASSOCIATION;
    283                 packet.message.stop.reason         = 0;
    284 
    285                 req = wrepl_request_send(wrepl_socket, &packet, NULL);
    286                 talloc_free(req);
     283                struct wrepl_associate_stop assoc_stop;
     284
     285                assoc_stop.in.assoc_ctx = associate.out.assoc_ctx;
     286                assoc_stop.in.reason = 0;
     287
     288                wrepl_associate_stop(wrepl_socket, &assoc_stop);
    287289
    288290                torture_fail(tctx, "We are not a valid pull partner for the server");
    … …  
    554556
    555557        ctx->address    = address;
    556         ctx->pull       = wrepl_socket_init(ctx, tctx->ev, lp_iconv_convenience(tctx->lp_ctx));
     558        ctx->pull       = wrepl_socket_init(ctx, tctx->ev);
    557559        if (!ctx->pull) return NULL;
    558560
    … …  
    611613        talloc_free(pull_table.out.partners);
    612614
    613         ctx->nbtsock = nbt_name_socket_init(ctx, tctx->ev, lp_iconv_convenience(tctx->lp_ctx));
     615        ctx->nbtsock = nbt_name_socket_init(ctx, tctx->ev);
    614616        if (!ctx->nbtsock) return NULL;
    615617
    616         load_interfaces(tctx, lp_interfaces(tctx->lp_ctx), &ifaces);
     618        load_interfaces(tctx, lpcfg_interfaces(tctx->lp_ctx), &ifaces);
    617619
    618620        ctx->myaddr = socket_address_from_strings(tctx, ctx->nbtsock->sock->backend_name, iface_best_ip(ifaces, address), 0);
    … …  
    629631        if (!NT_STATUS_IS_OK(status)) return NULL;
    630632
    631         ctx->nbtsock_srv = nbt_name_socket_init(ctx, tctx->ev, lp_iconv_convenience(tctx->lp_ctx));
     633        ctx->nbtsock_srv = nbt_name_socket_init(ctx, tctx->ev);
    632634        if (!ctx->nbtsock_srv) return NULL;
    633635
    634636        /* Make a port 137 version of ctx->myaddr */
    635         nbt_srv_addr = socket_address_from_strings(tctx, ctx->nbtsock_srv->sock->backend_name, ctx->myaddr->addr, lp_nbt_port(tctx->lp_ctx));
     637        nbt_srv_addr = socket_address_from_strings(tctx, ctx->nbtsock_srv->sock->backend_name, ctx->myaddr->addr, lpcfg_nbt_port(tctx->lp_ctx));
    636638        if (!nbt_srv_addr) return NULL;
    637639
    … …  
    646648
    647649        if (ctx->myaddr2 && ctx->nbtsock_srv) {
    648                 ctx->nbtsock2 = nbt_name_socket_init(ctx, tctx->ev, lp_iconv_convenience(tctx->lp_ctx));
     650                ctx->nbtsock2 = nbt_name_socket_init(ctx, tctx->ev);
    649651                if (!ctx->nbtsock2) return NULL;
    650652
    … …  
    652654                if (!NT_STATUS_IS_OK(status)) return NULL;
    653655
    654                 ctx->nbtsock_srv2 = nbt_name_socket_init(ctx, ctx->nbtsock_srv->event_ctx, lp_iconv_convenience(tctx->lp_ctx));
     656                ctx->nbtsock_srv2 = nbt_name_socket_init(ctx, ctx->nbtsock_srv->event_ctx);
    655657                if (!ctx->nbtsock_srv2) return NULL;
    656658
    … …  
    659661                                                           ctx->nbtsock_srv->sock->backend_name,
    660662                                                           ctx->myaddr2->addr,
    661                                                            lp_nbt_port(tctx->lp_ctx));
     663                                                           lpcfg_nbt_port(tctx->lp_ctx));
    662664                if (!nbt_srv_addr) return NULL;
    663665
    … …  
    723725        NTSTATUS status;
    724726
    725         wrepl_socket = wrepl_socket_init(ctx, tctx->ev, lp_iconv_convenience(tctx->lp_ctx));
     727        wrepl_socket = wrepl_socket_init(ctx, tctx->ev);
    726728
    727729        status = wrepl_connect(wrepl_socket, wrepl_best_ip(tctx->lp_ctx, ctx->address), ctx->address);
    … …  
    801803                                                  names[0].node,
    802804                                                  names[0].is_static);
     805                char *expected_scope = NULL;
    803806                CHECK_VALUE(tctx, names[0].name.type, name->name->type);
    804807                CHECK_VALUE_STRING(tctx, names[0].name.name, name->name->name);
    805                 CHECK_VALUE_STRING(tctx, names[0].name.scope, name->name->scope);
     808
     809                if (names[0].name.scope) {
     810                        expected_scope = talloc_strndup(tctx,
     811                                                        name->name->scope,
     812                                                        237);
     813                }
     814                CHECK_VALUE_STRING(tctx, names[0].name.scope, expected_scope);
    806815                CHECK_VALUE(tctx, flags, name->flags);
    807816                CHECK_VALUE_UINT64(tctx, names[0].version_id, name->id);
    … …  
    10061015}
    10071016
     1017static char *test_nbt_winsrepl_scope_string(TALLOC_CTX *mem_ctx, uint8_t count)
     1018{
     1019        char *res;
     1020        uint8_t i;
     1021
     1022        res = talloc_array(mem_ctx, char, count+1);
     1023        if (res == NULL) {
     1024                return NULL;
     1025        }
     1026
     1027        for (i=0; i < count; i++) {
     1028                res[i] = '0' + (i%10);
     1029        }
     1030
     1031        res[count] = '\0';
     1032
     1033        talloc_set_name_const(res, res);
     1034
     1035        return res;
     1036}
     1037
    10081038static bool test_conflict_same_owner(struct torture_context *tctx,
    10091039                                                                         struct test_wrepl_conflict_conn *ctx)
    10101040{
    1011         static bool ret = true;
    1012         struct nbt_name name;
     1041        bool ret = true;
    10131042        struct wrepl_wins_name wins_name1;
    10141043        struct wrepl_wins_name wins_name2;
    … …  
    10171046        struct wrepl_wins_name *wins_name_cur;
    10181047        uint32_t i,j;
    1019         uint8_t types[] = { 0x00, 0x1C };
     1048        struct nbt_name names[] = {
     1049                _NBT_NAME("_SAME_OWNER_A", 0x00, NULL),
     1050                _NBT_NAME("_SAME_OWNER_A", 0x00,
     1051                          test_nbt_winsrepl_scope_string(tctx, 1)),
     1052                _NBT_NAME("_SAME_OWNER_A", 0x00,
     1053                          test_nbt_winsrepl_scope_string(tctx, 2)),
     1054                _NBT_NAME("_SAME_OWNER_A", 0x00,
     1055                          test_nbt_winsrepl_scope_string(tctx, 3)),
     1056                _NBT_NAME("_SAME_OWNER_A", 0x00,
     1057                          test_nbt_winsrepl_scope_string(tctx, 4)),
     1058                _NBT_NAME("_SAME_OWNER_A", 0x00,
     1059                          test_nbt_winsrepl_scope_string(tctx, 5)),
     1060                _NBT_NAME("_SAME_OWNER_A", 0x00,
     1061                          test_nbt_winsrepl_scope_string(tctx, 6)),
     1062                _NBT_NAME("_SAME_OWNER_A", 0x00,
     1063                          test_nbt_winsrepl_scope_string(tctx, 7)),
     1064                _NBT_NAME("_SAME_OWNER_A", 0x00,
     1065                          test_nbt_winsrepl_scope_string(tctx, 8)),
     1066                _NBT_NAME("_SAME_OWNER_A", 0x00,
     1067                          test_nbt_winsrepl_scope_string(tctx, 9)),
     1068                _NBT_NAME("_SAME_OWNER_A", 0x00,
     1069                          test_nbt_winsrepl_scope_string(tctx, 237)),
     1070                _NBT_NAME("_SAME_OWNER_A", 0x00,
     1071                          test_nbt_winsrepl_scope_string(tctx, 238)),
     1072                _NBT_NAME("_SAME_OWNER_A", 0x1C, NULL),
     1073        };
    10201074        struct {
    10211075                enum wrepl_name_type type;
    … …  
    11141168        };
    11151169
    1116         name.name       = "_SAME_OWNER_A";
    1117         name.type       = 0;
    1118         name.scope      = NULL;
    1119 
    11201170        wins_name_tmp   = NULL;
    11211171        wins_name_last  = &wins_name2;
    11221172        wins_name_cur   = &wins_name1;
    11231173
    1124         for (j=0; ret && j < ARRAY_SIZE(types); j++) {
    1125                 name.type = types[j];
     1174        for (j=0; ret && j < ARRAY_SIZE(names); j++) {
    11261175                torture_comment(tctx, "Test Replica Conflicts with same owner[%s] for %s\n",
    1127                         nbt_name_string(ctx, &name), ctx->a.address);
     1176                        nbt_name_string(ctx, &names[j]), ctx->a.address);
    11281177
    11291178                for(i=0; ret && i < ARRAY_SIZE(records); i++) {
    … …  
    11441193                        }
    11451194
    1146                         wins_name_cur->name     = &name;
     1195                        wins_name_cur->name     = &names[j];
    11471196                        wins_name_cur->flags    = WREPL_NAME_FLAGS(records[i].type,
    11481197                                                                   records[i].state,
    … …  
    11521201                        if (wins_name_cur->flags & 2) {
    11531202                                wins_name_cur->addresses.addresses.num_ips = records[i].num_ips;
    1154                                 wins_name_cur->addresses.addresses.ips     = discard_const(records[i].ips);
     1203                                wins_name_cur->addresses.addresses.ips     = discard_const_p(struct wrepl_ip,
     1204                                                                             records[i].ips);
    11551205                        } else {
    11561206                                wins_name_cur->addresses.ip = records[i].ips[0].ip;
    … …  
    48354885                if (wins_name_r1->flags & 2) {
    48364886                        wins_name_r1->addresses.addresses.num_ips = records[i].r1.num_ips;
    4837                         wins_name_r1->addresses.addresses.ips     = discard_const(records[i].r1.ips);
     4887                        wins_name_r1->addresses.addresses.ips     = discard_const_p(struct wrepl_ip,
     4888                                                                    records[i].r1.ips);
    48384889                } else {
    48394890                        wins_name_r1->addresses.ip = records[i].r1.ips[0].ip;
    … …  
    48574908                if (wins_name_r2->flags & 2) {
    48584909                        wins_name_r2->addresses.addresses.num_ips = records[i].r2.num_ips;
    4859                         wins_name_r2->addresses.addresses.ips     = discard_const(records[i].r2.ips);
     4910                        wins_name_r2->addresses.addresses.ips     = discard_const_p(struct wrepl_ip,
     4911                                                                    records[i].r2.ips);
    48604912                } else {
    48614913                        wins_name_r2->addresses.ip = records[i].r2.ips[0].ip;
    … …  
    49344986                        wins_name_r2->id        = ++records[i].r2.owner->max_version;
    49354987                        wins_name_r2->addresses.addresses.num_ips = ARRAY_SIZE(addresses_B_1);
    4936                         wins_name_r2->addresses.addresses.ips     = discard_const(addresses_B_1);
     4988                        wins_name_r2->addresses.addresses.ips     = discard_const_p(struct wrepl_ip,
     4989                                                                    addresses_B_1);
    49374990                        wins_name_r2->unknown   = "255.255.255.255";
    49384991                        ret &= test_wrepl_update_one(tctx, ctx, records[i].r2.owner, wins_name_r2);
    … …  
    49464999                        wins_name_r2->id        = ++records[i].r2.owner->max_version;
    49475000                        wins_name_r2->addresses.addresses.num_ips = ARRAY_SIZE(addresses_B_1);
    4948                         wins_name_r2->addresses.addresses.ips     = discard_const(addresses_B_1);
     5001                        wins_name_r2->addresses.addresses.ips     = discard_const_p(struct wrepl_ip,
     5002                                                                    addresses_B_1);
    49495003                        wins_name_r2->unknown   = "255.255.255.255";
    49505004                        ret &= test_wrepl_update_one(tctx, ctx, records[i].r2.owner, wins_name_r2);
    … …  
    65346588                name_register->in.name          = records[i].name;
    65356589                name_register->in.dest_addr     = ctx->address;
    6536                 name_register->in.dest_port     = lp_nbt_port(tctx->lp_ctx);
     6590                name_register->in.dest_port     = lpcfg_nbt_port(tctx->lp_ctx);
    65376591                name_register->in.address       = records[i].wins.ips[0].ip;
    65386592                name_register->in.nb_flags      = records[i].wins.nb_flags;
    … …  
    65636617                /* release the record */
    65646618                release->in.name        = records[i].name;
    6565                 release->in.dest_port   = lp_nbt_port(tctx->lp_ctx);
     6619                release->in.dest_port   = lpcfg_nbt_port(tctx->lp_ctx);
    65666620                release->in.dest_addr   = ctx->address;
    65676621                release->in.address     = records[i].wins.ips[0].ip;
    … …  
    65946648                if (wins_name->flags & 2) {
    65956649                        wins_name->addresses.addresses.num_ips = records[i].replica.num_ips;
    6596                         wins_name->addresses.addresses.ips     = discard_const(records[i].replica.ips);
     6650                        wins_name->addresses.addresses.ips     = discard_const_p(struct wrepl_ip,
     6651                                                                 records[i].replica.ips);
    65976652                } else {
    65986653                        wins_name->addresses.ip = records[i].replica.ips[0].ip;
    … …  
    66186673                        release->in.name        = records[i].name;
    66196674                        release->in.dest_addr   = ctx->address;
    6620                         release->in.dest_port   = lp_nbt_port(tctx->lp_ctx);
     6675                        release->in.dest_port   = lpcfg_nbt_port(tctx->lp_ctx);
    66216676                        release->in.address     = records[i].wins.ips[0].ip;
    66226677                        release->in.nb_flags    = records[i].wins.nb_flags;
    … …  
    91599214        if (!ctx->nbtsock_srv) {
    91609215                torture_comment(tctx, "SKIP: Test Replica records vs. owned active records: not bound to port[%d]\n",
    9161                         lp_nbt_port(tctx->lp_ctx));
     9216                        lpcfg_nbt_port(tctx->lp_ctx));
    91629217                return true;
    91639218        }
    … …  
    92219276                        name_register->in.name          = records[i].name;
    92229277                        name_register->in.dest_addr     = ctx->address;
    9223                         name_register->in.dest_port     = lp_nbt_port(tctx->lp_ctx);
     9278                        name_register->in.dest_port     = lpcfg_nbt_port(tctx->lp_ctx);
    92249279                        name_register->in.address       = records[i].wins.ips[j].ip;
    92259280                        name_register->in.nb_flags      = records[i].wins.nb_flags;
    … …  
    92919346                if (wins_name->flags & 2) {
    92929347                        wins_name->addresses.addresses.num_ips = records[i].replica.num_ips;
    9293                         wins_name->addresses.addresses.ips     = discard_const(records[i].replica.ips);
     9348                        wins_name->addresses.addresses.ips     = discard_const_p(struct wrepl_ip,
     9349                                                                 records[i].replica.ips);
    92949350                } else {
    92959351                        wins_name->addresses.ip = records[i].replica.ips[0].ip;
    … …  
    93679423                                release->in.name        = records[i].name;
    93689424                                release->in.dest_addr   = ctx->address;
    9369                                 release->in.dest_port   = lp_nbt_port(tctx->lp_ctx);
     9425                                release->in.dest_port   = lpcfg_nbt_port(tctx->lp_ctx);
    93709426                                release->in.address     = records[i].wins.ips[j].ip;
    93719427                                release->in.nb_flags    = records[i].wins.nb_flags;
    … …  
    94069462                                wins_name->id           = ++ctx->b.max_version;
    94079463                                wins_name->addresses.addresses.num_ips = ARRAY_SIZE(addresses_B_1);
    9408                                 wins_name->addresses.addresses.ips     = discard_const(addresses_B_1);
     9464                                wins_name->addresses.addresses.ips     = discard_const_p(struct wrepl_ip,
     9465                                                                         addresses_B_1);
    94099466                                wins_name->unknown      = "255.255.255.255";
    94109467                                ret &= test_wrepl_update_one(tctx, ctx, &ctx->b, wins_name);
    … …  
    94989555
    94999556                /* send a positive reply */
    9500                 rep_packet->operation   = 
    9501                                         NBT_FLAG_REPLY | 
    9502                                         NBT_OPCODE_QUERY | 
    9503                                         NBT_FLAG_AUTHORITIVE |
     9557                rep_packet->operation   =
     9558                                        NBT_FLAG_REPLY |
     9559                                        NBT_OPCODE_QUERY |
     9560                                        NBT_FLAG_AUTHORITATIVE |
    95049561                                        NBT_FLAG_RECURSION_DESIRED |
    95059562                                        NBT_FLAG_RECURSION_AVAIL;
    … …  
    95239580                /* send a negative reply */
    95249581                rep_packet->operation   =
    9525                                         NBT_FLAG_REPLY | 
    9526                                         NBT_OPCODE_QUERY | 
    9527                                         NBT_FLAG_AUTHORITIVE |
     9582                                        NBT_FLAG_REPLY |
     9583                                        NBT_OPCODE_QUERY |
     9584                                        NBT_FLAG_AUTHORITATIVE |
    95289585                                        NBT_RCODE_NAM;
    95299586
    … …  
    95439600                event_loop_once(nbtsock->event_ctx);
    95449601        }
    9545         msleep(1000);
     9602        smb_msleep(1000);
    95469603
    95479604        rec->defend.timeout     = 0;
    … …  
    95769633        rep_packet->name_trn_id = req_packet->name_trn_id;
    95779634        rep_packet->ancount     = 1;
    9578         rep_packet->operation   = 
    9579                                 NBT_FLAG_REPLY | 
     9635        rep_packet->operation   =
     9636                                NBT_FLAG_REPLY |
    95809637                                NBT_OPCODE_RELEASE |
    9581                                 NBT_FLAG_AUTHORITIVE;
     9638                                NBT_FLAG_AUTHORITATIVE;
    95829639
    95839640        rep_packet->answers     = talloc_array(rep_packet, struct nbt_res_rec, 1);
    … …  
    96009657                event_loop_once(nbtsock->event_ctx);
    96019658        }
    9602         msleep(1000);
     9659        smb_msleep(1000);
    96039660
    96049661        rec->defend.timeout     = 0;
    … …  
    96839740{
    96849741        struct torture_suite *suite = torture_suite_create(
    9685                 mem_ctx, "WINSREPLICATION");
     9742                mem_ctx, "winsreplication");
    96869743        struct torture_tcase *tcase;
    96879744
    … …  
    96909747        tcase->tests->dangerous = true;
    96919748
    9692         torture_suite_add_simple_test(suite, "assoc_ctx2",
    9693                                       test_assoc_ctx2);
     9749        torture_suite_add_simple_test(suite, "assoc_ctx2", test_assoc_ctx2);
    96949750       
    96959751        torture_suite_add_simple_test(suite, "wins_replication",
Note: See TracChangeset for help on using the changeset viewer.