root/source4/torture/nbt/dgram.c

/* [<][>][^][v][top][bottom][index][help] */

DEFINITIONS

This source file includes following definitions.
  1. netlogon_handler
  2. nbt_test_netlogon
  3. nbt_test_netlogon2
  4. nbt_test_ntlogon
  5. torture_nbt_dgram

   1 /* 
   2    Unix SMB/CIFS implementation.
   3 
   4    NBT dgram testing
   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 3 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, see <http://www.gnu.org/licenses/>.
  20 */
  21 
  22 #include "includes.h"
  23 #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"
  27 #include "lib/socket/socket.h"
  28 #include "lib/events/events.h"
  29 #include "torture/rpc/rpc.h"
  30 #include "libcli/resolve/resolve.h"
  31 #include "system/network.h"
  32 #include "lib/socket/netif.h"
  33 #include "param/param.h"
  34 
  35 #define TEST_NAME "TORTURE_TEST"
  36 
  37 /*
  38   reply handler for netlogon request
  39 */
  40 static void netlogon_handler(struct dgram_mailslot_handler *dgmslot, 
     /* [<][>][^][v][top][bottom][index][help] */
  41                              struct nbt_dgram_packet *packet, 
  42                              struct socket_address *src)
  43 {
  44         NTSTATUS status;
  45         struct nbt_netlogon_response *netlogon = dgmslot->private_data;
  46 
  47         dgmslot->private_data = netlogon = talloc(dgmslot, struct nbt_netlogon_response);
  48 
  49         if (!dgmslot->private_data) {
  50                 return;
  51         }
  52        
  53         printf("netlogon reply from %s:%d\n", src->addr, src->port);
  54 
  55         /* Fills in the netlogon pointer */
  56         status = dgram_mailslot_netlogon_parse_response(dgmslot, netlogon, packet, netlogon);
  57         if (!NT_STATUS_IS_OK(status)) {
  58                 printf("Failed to parse netlogon packet from %s:%d\n",
  59                        src->addr, src->port);
  60                 return;
  61         }
  62 
  63 }
  64 
  65 
  66 /* test UDP/138 netlogon requests */
  67 static bool nbt_test_netlogon(struct torture_context *tctx)
     /* [<][>][^][v][top][bottom][index][help] */
  68 {
  69         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));
  72         struct socket_address *dest;
  73         const char *myaddress;
  74         struct nbt_netlogon_packet logon;
  75         struct nbt_netlogon_response *response;
  76         struct nbt_name myname;
  77         NTSTATUS status;
  78         struct timeval tv = timeval_current();
  79 
  80         struct socket_address *socket_address;
  81 
  82         const char *address;
  83         struct nbt_name name;
  84 
  85         struct interface *ifaces;
  86 
  87         name.name = lp_workgroup(tctx->lp_ctx);
  88         name.type = NBT_NAME_LOGON;
  89         name.scope = NULL;
  90 
  91         /* do an initial name resolution to find its IP */
  92         torture_assert_ntstatus_ok(tctx, 
  93                                    resolve_name(lp_resolve_context(tctx->lp_ctx), &name, tctx, &address, tctx->ev),
  94                                    talloc_asprintf(tctx, "Failed to resolve %s", name.name));
  95 
  96         load_interfaces(tctx, lp_interfaces(tctx->lp_ctx), &ifaces);
  97         myaddress = talloc_strdup(dgmsock, iface_best_ip(ifaces, address));
  98 
  99 
 100         socket_address = socket_address_from_strings(dgmsock, dgmsock->sock->backend_name,
 101                                                      myaddress, lp_dgram_port(tctx->lp_ctx));
 102         torture_assert(tctx, socket_address != NULL, "Error getting address");
 103 
 104         /* try receiving replies on port 138 first, which will only
 105            work if we are root and smbd/nmbd are not running - fall
 106            back to listening on any port, which means replies from
 107            most windows versions won't be seen */
 108         status = socket_listen(dgmsock->sock, socket_address, 0, 0);
 109         if (!NT_STATUS_IS_OK(status)) {
 110                 talloc_free(socket_address);
 111                 socket_address = socket_address_from_strings(dgmsock, dgmsock->sock->backend_name,
 112                                                              myaddress, 0);
 113                 torture_assert(tctx, socket_address != NULL, "Error getting address");
 114 
 115                 socket_listen(dgmsock->sock, socket_address, 0, 0);
 116         }
 117 
 118         /* setup a temporary mailslot listener for replies */
 119         dgmslot = dgram_mailslot_temp(dgmsock, NBT_MAILSLOT_GETDC,
 120                                       netlogon_handler, NULL);
 121 
 122         ZERO_STRUCT(logon);
 123         logon.command = LOGON_PRIMARY_QUERY;
 124         logon.req.pdc.computer_name = TEST_NAME;
 125         logon.req.pdc.mailslot_name = dgmslot->mailslot_name;
 126         logon.req.pdc.unicode_name  = TEST_NAME;
 127         logon.req.pdc.nt_version    = 1;
 128         logon.req.pdc.lmnt_token    = 0xFFFF;
 129         logon.req.pdc.lm20_token    = 0xFFFF;
 130 
 131         make_nbt_name_client(&myname, TEST_NAME);
 132 
 133         dest = socket_address_from_strings(dgmsock, dgmsock->sock->backend_name, 
 134                                            address, lp_dgram_port(tctx->lp_ctx));
 135         torture_assert(tctx, dest != NULL, "Error getting address");
 136 
 137         status = dgram_mailslot_netlogon_send(dgmsock, &name, dest,
 138                                               NBT_MAILSLOT_NETLOGON, 
 139                                               &myname, &logon);
 140         torture_assert_ntstatus_ok(tctx, status, "Failed to send netlogon request");
 141 
 142         while (timeval_elapsed(&tv) < 5 && !dgmslot->private_data) {
 143                 event_loop_once(dgmsock->event_ctx);
 144         }
 145 
 146         response = talloc_get_type(dgmslot->private_data, struct nbt_netlogon_response);
 147 
 148         torture_assert(tctx, response != NULL, "Failed to receive a netlogon reply packet");
 149 
 150         torture_assert(tctx, response->response_type == NETLOGON_GET_PDC, "Got incorrect type of netlogon response");
 151         torture_assert(tctx, response->data.get_pdc.command == NETLOGON_RESPONSE_FROM_PDC, "Got incorrect netlogon response command");
 152 
 153         return true;
 154 }
 155 
 156 
 157 /* test UDP/138 netlogon requests */
 158 static bool nbt_test_netlogon2(struct torture_context *tctx)
     /* [<][>][^][v][top][bottom][index][help] */
 159 {
 160         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));
 163         struct socket_address *dest;
 164         const char *myaddress;
 165         struct nbt_netlogon_packet logon;
 166         struct nbt_netlogon_response *response;
 167         struct nbt_name myname;
 168         NTSTATUS status;
 169         struct timeval tv = timeval_current();
 170 
 171         struct socket_address *socket_address;
 172 
 173         const char *address;
 174         struct nbt_name name;
 175 
 176         struct interface *ifaces;
 177         struct test_join *join_ctx;
 178         struct cli_credentials *machine_credentials;
 179         const struct dom_sid *dom_sid;
 180         
 181         name.name = lp_workgroup(tctx->lp_ctx);
 182         name.type = NBT_NAME_LOGON;
 183         name.scope = NULL;
 184 
 185         /* do an initial name resolution to find its IP */
 186         torture_assert_ntstatus_ok(tctx, 
 187                                    resolve_name(lp_resolve_context(tctx->lp_ctx), &name, tctx, &address, tctx->ev),
 188                                    talloc_asprintf(tctx, "Failed to resolve %s", name.name));
 189 
 190         load_interfaces(tctx, lp_interfaces(tctx->lp_ctx), &ifaces);
 191         myaddress = talloc_strdup(dgmsock, iface_best_ip(ifaces, address));
 192 
 193         socket_address = socket_address_from_strings(dgmsock, dgmsock->sock->backend_name,
 194                                                      myaddress, lp_dgram_port(tctx->lp_ctx));
 195         torture_assert(tctx, socket_address != NULL, "Error getting address");
 196 
 197         /* try receiving replies on port 138 first, which will only
 198            work if we are root and smbd/nmbd are not running - fall
 199            back to listening on any port, which means replies from
 200            some windows versions won't be seen */
 201         status = socket_listen(dgmsock->sock, socket_address, 0, 0);
 202         if (!NT_STATUS_IS_OK(status)) {
 203                 talloc_free(socket_address);
 204                 socket_address = socket_address_from_strings(dgmsock, dgmsock->sock->backend_name,
 205                                                              myaddress, 0);
 206                 torture_assert(tctx, socket_address != NULL, "Error getting address");
 207 
 208                 socket_listen(dgmsock->sock, socket_address, 0, 0);
 209         }
 210 
 211         /* setup a temporary mailslot listener for replies */
 212         dgmslot = dgram_mailslot_temp(dgmsock, NBT_MAILSLOT_GETDC,
 213                                       netlogon_handler, NULL);
 214         
 215 
 216         ZERO_STRUCT(logon);
 217         logon.command = LOGON_SAM_LOGON_REQUEST;
 218         logon.req.logon.request_count = 0;
 219         logon.req.logon.computer_name = TEST_NAME;
 220         logon.req.logon.user_name     = "";
 221         logon.req.logon.mailslot_name = dgmslot->mailslot_name;
 222         logon.req.logon.nt_version    = NETLOGON_NT_VERSION_5EX_WITH_IP|NETLOGON_NT_VERSION_5|NETLOGON_NT_VERSION_1;
 223         logon.req.logon.lmnt_token    = 0xFFFF;
 224         logon.req.logon.lm20_token    = 0xFFFF;
 225 
 226         make_nbt_name_client(&myname, TEST_NAME);
 227 
 228         dest = socket_address_from_strings(dgmsock, dgmsock->sock->backend_name, 
 229                                            address, lp_dgram_port(tctx->lp_ctx));
 230 
 231         torture_assert(tctx, dest != NULL, "Error getting address");
 232         status = dgram_mailslot_netlogon_send(dgmsock, &name, dest,
 233                                               NBT_MAILSLOT_NETLOGON, 
 234                                               &myname, &logon);
 235         torture_assert_ntstatus_ok(tctx, status, "Failed to send netlogon request");
 236 
 237         while (timeval_elapsed(&tv) < 5 && dgmslot->private_data == NULL) {
 238                 event_loop_once(dgmsock->event_ctx);
 239         }
 240 
 241         response = talloc_get_type(dgmslot->private_data, struct nbt_netlogon_response);
 242 
 243         torture_assert(tctx, response != NULL, "Failed to receive a netlogon reply packet");
 244 
 245         torture_assert_int_equal(tctx, response->response_type, NETLOGON_SAMLOGON, "Got incorrect type of netlogon response");
 246         map_netlogon_samlogon_response(&response->data.samlogon);
 247 
 248         torture_assert_int_equal(tctx, response->data.samlogon.data.nt5_ex.command, LOGON_SAM_LOGON_RESPONSE_EX, "Got incorrect netlogon response command");
 249         torture_assert_int_equal(tctx, response->data.samlogon.data.nt5_ex.nt_version, NETLOGON_NT_VERSION_5EX_WITH_IP|NETLOGON_NT_VERSION_5EX|NETLOGON_NT_VERSION_1, "Got incorrect netlogon response command");
 250 
 251         /* setup (another) temporary mailslot listener for replies */
 252         dgmslot = dgram_mailslot_temp(dgmsock, NBT_MAILSLOT_GETDC,
 253                                       netlogon_handler, NULL);
 254         
 255         ZERO_STRUCT(logon);
 256         logon.command = LOGON_SAM_LOGON_REQUEST;
 257         logon.req.logon.request_count = 0;
 258         logon.req.logon.computer_name = TEST_NAME;
 259         logon.req.logon.user_name     = TEST_NAME"$";
 260         logon.req.logon.mailslot_name = dgmslot->mailslot_name;
 261         logon.req.logon.nt_version    = 1;
 262         logon.req.logon.lmnt_token    = 0xFFFF;
 263         logon.req.logon.lm20_token    = 0xFFFF;
 264 
 265         make_nbt_name_client(&myname, TEST_NAME);
 266 
 267         dest = socket_address_from_strings(dgmsock, dgmsock->sock->backend_name, 
 268                                            address, lp_dgram_port(tctx->lp_ctx));
 269 
 270         torture_assert(tctx, dest != NULL, "Error getting address");
 271         status = dgram_mailslot_netlogon_send(dgmsock, &name, dest,
 272                                               NBT_MAILSLOT_NETLOGON, 
 273                                               &myname, &logon);
 274         torture_assert_ntstatus_ok(tctx, status, "Failed to send netlogon request");
 275 
 276         while (timeval_elapsed(&tv) < 5 && dgmslot->private_data == NULL) {
 277                 event_loop_once(dgmsock->event_ctx);
 278         }
 279 
 280         response = talloc_get_type(dgmslot->private_data, struct nbt_netlogon_response);
 281 
 282         torture_assert(tctx, response != NULL, "Failed to receive a netlogon reply packet");
 283 
 284         torture_assert_int_equal(tctx, response->response_type, NETLOGON_SAMLOGON, "Got incorrect type of netlogon response");
 285         map_netlogon_samlogon_response(&response->data.samlogon);
 286 
 287         torture_assert_int_equal(tctx, response->data.samlogon.data.nt5_ex.command, LOGON_SAM_LOGON_USER_UNKNOWN, "Got incorrect netlogon response command");
 288 
 289         torture_assert_str_equal(tctx, response->data.samlogon.data.nt5_ex.user_name, TEST_NAME"$", "Got incorrect user in netlogon response");
 290 
 291         join_ctx = torture_join_domain(tctx, TEST_NAME, 
 292                                        ACB_WSTRUST, &machine_credentials);
 293 
 294         torture_assert(tctx, join_ctx != NULL,
 295                        talloc_asprintf(tctx, "Failed to join domain %s as %s\n",
 296                                        lp_workgroup(tctx->lp_ctx), TEST_NAME));
 297 
 298         dom_sid = torture_join_sid(join_ctx);
 299 
 300         /* setup (another) temporary mailslot listener for replies */
 301         dgmslot = dgram_mailslot_temp(dgmsock, NBT_MAILSLOT_GETDC,
 302                                       netlogon_handler, NULL);
 303         
 304         ZERO_STRUCT(logon);
 305         logon.command = LOGON_SAM_LOGON_REQUEST;
 306         logon.req.logon.request_count = 0;
 307         logon.req.logon.computer_name = TEST_NAME;
 308         logon.req.logon.user_name     = TEST_NAME"$";
 309         logon.req.logon.mailslot_name = dgmslot->mailslot_name;
 310         logon.req.logon.sid           = *dom_sid;
 311         logon.req.logon.nt_version    = 1;
 312         logon.req.logon.lmnt_token    = 0xFFFF;
 313         logon.req.logon.lm20_token    = 0xFFFF;
 314 
 315         make_nbt_name_client(&myname, TEST_NAME);
 316 
 317         dest = socket_address_from_strings(dgmsock, dgmsock->sock->backend_name, 
 318                                            address, lp_dgram_port(tctx->lp_ctx));
 319 
 320         torture_assert(tctx, dest != NULL, "Error getting address");
 321         status = dgram_mailslot_netlogon_send(dgmsock, &name, dest,
 322                                               NBT_MAILSLOT_NETLOGON, 
 323                                               &myname, &logon);
 324         torture_assert_ntstatus_ok(tctx, status, "Failed to send netlogon request");
 325 
 326 
 327         while (timeval_elapsed(&tv) < 5 && dgmslot->private_data == NULL) {
 328                 event_loop_once(dgmsock->event_ctx);
 329         }
 330 
 331         response = talloc_get_type(dgmslot->private_data, struct nbt_netlogon_response);
 332 
 333         torture_assert(tctx, response != NULL, "Failed to receive a netlogon reply packet");
 334 
 335         torture_assert_int_equal(tctx, response->response_type, NETLOGON_SAMLOGON, "Got incorrect type of netlogon response");
 336         map_netlogon_samlogon_response(&response->data.samlogon);
 337 
 338         torture_assert_int_equal(tctx, response->data.samlogon.data.nt5_ex.command, LOGON_SAM_LOGON_USER_UNKNOWN, "Got incorrect netlogon response command");
 339 
 340         /* setup (another) temporary mailslot listener for replies */
 341         dgmslot = dgram_mailslot_temp(dgmsock, NBT_MAILSLOT_GETDC,
 342                                       netlogon_handler, NULL);
 343         
 344         ZERO_STRUCT(logon);
 345         logon.command = LOGON_SAM_LOGON_REQUEST;
 346         logon.req.logon.request_count = 0;
 347         logon.req.logon.computer_name = TEST_NAME;
 348         logon.req.logon.user_name     = TEST_NAME"$";
 349         logon.req.logon.mailslot_name = dgmslot->mailslot_name;
 350         logon.req.logon.sid           = *dom_sid;
 351         logon.req.logon.acct_control  = ACB_WSTRUST;
 352         logon.req.logon.nt_version    = 1;
 353         logon.req.logon.lmnt_token    = 0xFFFF;
 354         logon.req.logon.lm20_token    = 0xFFFF;
 355 
 356         make_nbt_name_client(&myname, TEST_NAME);
 357 
 358         dest = socket_address_from_strings(dgmsock, dgmsock->sock->backend_name, 
 359                                            address, lp_dgram_port(tctx->lp_ctx));
 360 
 361         torture_assert(tctx, dest != NULL, "Error getting address");
 362         status = dgram_mailslot_netlogon_send(dgmsock, &name, dest,
 363                                               NBT_MAILSLOT_NETLOGON, 
 364                                               &myname, &logon);
 365         torture_assert_ntstatus_ok(tctx, status, "Failed to send netlogon request");
 366 
 367 
 368         while (timeval_elapsed(&tv) < 5 && dgmslot->private_data == NULL) {
 369                 event_loop_once(dgmsock->event_ctx);
 370         }
 371 
 372         response = talloc_get_type(dgmslot->private_data, struct nbt_netlogon_response);
 373 
 374         torture_assert(tctx, response != NULL, "Failed to receive a netlogon reply packet");
 375 
 376         torture_assert_int_equal(tctx, response->response_type, NETLOGON_SAMLOGON, "Got incorrect type of netlogon response");
 377         map_netlogon_samlogon_response(&response->data.samlogon);
 378 
 379         torture_assert_int_equal(tctx, response->data.samlogon.data.nt5_ex.command, LOGON_SAM_LOGON_RESPONSE, "Got incorrect netlogon response command");
 380 
 381         dgmslot->private_data = NULL;
 382 
 383         ZERO_STRUCT(logon);
 384         logon.command = LOGON_SAM_LOGON_REQUEST;
 385         logon.req.logon.request_count = 0;
 386         logon.req.logon.computer_name = TEST_NAME;
 387         logon.req.logon.user_name     = TEST_NAME"$";
 388         logon.req.logon.mailslot_name = dgmslot->mailslot_name;
 389         logon.req.logon.sid           = *dom_sid;
 390         logon.req.logon.acct_control  = ACB_NORMAL;
 391         logon.req.logon.nt_version    = 1;
 392         logon.req.logon.lmnt_token    = 0xFFFF;
 393         logon.req.logon.lm20_token    = 0xFFFF;
 394 
 395         make_nbt_name_client(&myname, TEST_NAME);
 396 
 397         dest = socket_address_from_strings(dgmsock, dgmsock->sock->backend_name, 
 398                                            address, lp_dgram_port(tctx->lp_ctx));
 399 
 400         torture_assert(tctx, dest != NULL, "Error getting address");
 401         status = dgram_mailslot_netlogon_send(dgmsock, &name, dest,
 402                                               NBT_MAILSLOT_NETLOGON, 
 403                                               &myname, &logon);
 404         torture_assert_ntstatus_ok(tctx, status, "Failed to send netlogon request");
 405 
 406 
 407         while (timeval_elapsed(&tv) < 5 && dgmslot->private_data == NULL) {
 408                 event_loop_once(dgmsock->event_ctx);
 409         }
 410 
 411         response = talloc_get_type(dgmslot->private_data, struct nbt_netlogon_response);
 412 
 413         torture_assert(tctx, response != NULL, "Failed to receive a netlogon reply packet");
 414 
 415         torture_assert_int_equal(tctx, response->response_type, NETLOGON_SAMLOGON, "Got incorrect type of netlogon response");
 416         map_netlogon_samlogon_response(&response->data.samlogon);
 417 
 418         torture_assert_int_equal(tctx, response->data.samlogon.data.nt5_ex.command, LOGON_SAM_LOGON_USER_UNKNOWN, "Got incorrect netlogon response command");
 419 
 420         torture_leave_domain(tctx, join_ctx);
 421         return true;
 422 }
 423 
 424 
 425 /* test UDP/138 ntlogon requests */
 426 static bool nbt_test_ntlogon(struct torture_context *tctx)
     /* [<][>][^][v][top][bottom][index][help] */
 427 {
 428         struct dgram_mailslot_handler *dgmslot;
 429         struct nbt_dgram_socket *dgmsock = nbt_dgram_socket_init(tctx, tctx->ev,
 430                                                                  lp_iconv_convenience(tctx->lp_ctx));
 431         struct socket_address *dest;
 432         struct test_join *join_ctx;
 433         const struct dom_sid *dom_sid;
 434         struct cli_credentials *machine_credentials;
 435 
 436         const char *myaddress;
 437         struct nbt_netlogon_packet logon;
 438         struct nbt_netlogon_response *response;
 439         struct nbt_name myname;
 440         NTSTATUS status;
 441         struct timeval tv = timeval_current();
 442 
 443         struct socket_address *socket_address;
 444         const char *address;
 445         struct nbt_name name;
 446 
 447         struct interface *ifaces;
 448         
 449         name.name = lp_workgroup(tctx->lp_ctx);
 450         name.type = NBT_NAME_LOGON;
 451         name.scope = NULL;
 452 
 453         /* do an initial name resolution to find its IP */
 454         torture_assert_ntstatus_ok(tctx, 
 455                                    resolve_name(lp_resolve_context(tctx->lp_ctx), &name, tctx, &address, tctx->ev),
 456                                    talloc_asprintf(tctx, "Failed to resolve %s", name.name));
 457 
 458         load_interfaces(tctx, lp_interfaces(tctx->lp_ctx), &ifaces);
 459         myaddress = talloc_strdup(dgmsock, iface_best_ip(ifaces, address));
 460 
 461         socket_address = socket_address_from_strings(dgmsock, dgmsock->sock->backend_name,
 462                                                      myaddress, lp_dgram_port(tctx->lp_ctx));
 463         torture_assert(tctx, socket_address != NULL, "Error getting address");
 464 
 465         /* try receiving replies on port 138 first, which will only
 466            work if we are root and smbd/nmbd are not running - fall
 467            back to listening on any port, which means replies from
 468            most windows versions won't be seen */
 469         status = socket_listen(dgmsock->sock, socket_address, 0, 0);
 470         if (!NT_STATUS_IS_OK(status)) {
 471                 talloc_free(socket_address);
 472                 socket_address = socket_address_from_strings(dgmsock, dgmsock->sock->backend_name,
 473                                                              myaddress, 0);
 474                 torture_assert(tctx, socket_address != NULL, "Error getting address");
 475 
 476                 socket_listen(dgmsock->sock, socket_address, 0, 0);
 477         }
 478 
 479         join_ctx = torture_join_domain(tctx, TEST_NAME, 
 480                                        ACB_WSTRUST, &machine_credentials);
 481         dom_sid = torture_join_sid(join_ctx);
 482 
 483         torture_assert(tctx, join_ctx != NULL,
 484                        talloc_asprintf(tctx, "Failed to join domain %s as %s\n",
 485                                        lp_workgroup(tctx->lp_ctx), TEST_NAME));
 486 
 487         /* setup a temporary mailslot listener for replies */
 488         dgmslot = dgram_mailslot_temp(dgmsock, NBT_MAILSLOT_GETDC,
 489                                       netlogon_handler, NULL);
 490         
 491 
 492         ZERO_STRUCT(logon);
 493         logon.command = LOGON_SAM_LOGON_REQUEST;
 494         logon.req.logon.request_count = 0;
 495         logon.req.logon.computer_name = TEST_NAME;
 496         logon.req.logon.user_name     = TEST_NAME"$";
 497         logon.req.logon.mailslot_name = dgmslot->mailslot_name;
 498         logon.req.logon.acct_control  = ACB_WSTRUST;
 499         /* Try with a SID this time */
 500         logon.req.logon.sid           = *dom_sid;
 501         logon.req.logon.nt_version    = 1;
 502         logon.req.logon.lmnt_token    = 0xFFFF;
 503         logon.req.logon.lm20_token    = 0xFFFF;
 504 
 505         make_nbt_name_client(&myname, TEST_NAME);
 506 
 507         dest = socket_address_from_strings(dgmsock, dgmsock->sock->backend_name, 
 508                                            address, lp_dgram_port(tctx->lp_ctx));
 509         torture_assert(tctx, dest != NULL, "Error getting address");
 510         status = dgram_mailslot_netlogon_send(dgmsock, 
 511                                               &name, dest, 
 512                                               NBT_MAILSLOT_NTLOGON, 
 513                                               &myname, &logon);
 514         torture_assert_ntstatus_ok(tctx, status, "Failed to send ntlogon request");
 515 
 516         while (timeval_elapsed(&tv) < 5 && dgmslot->private_data == NULL) {
 517                 event_loop_once(dgmsock->event_ctx);
 518         }
 519 
 520         response = talloc_get_type(dgmslot->private_data, struct nbt_netlogon_response);
 521 
 522         torture_assert(tctx, response != NULL, "Failed to receive a netlogon reply packet");
 523 
 524         torture_assert_int_equal(tctx, response->response_type, NETLOGON_SAMLOGON, "Got incorrect type of netlogon response");
 525         map_netlogon_samlogon_response(&response->data.samlogon);
 526 
 527         torture_assert_int_equal(tctx, response->data.samlogon.data.nt5_ex.command, LOGON_SAM_LOGON_RESPONSE, "Got incorrect netlogon response command");
 528 
 529         torture_assert_str_equal(tctx, response->data.samlogon.data.nt5_ex.user_name, TEST_NAME"$", "Got incorrect user in netlogon response");
 530 
 531 
 532         /* setup a temporary mailslot listener for replies */
 533         dgmslot = dgram_mailslot_temp(dgmsock, NBT_MAILSLOT_GETDC,
 534                                       netlogon_handler, NULL);
 535         
 536 
 537         ZERO_STRUCT(logon);
 538         logon.command = LOGON_SAM_LOGON_REQUEST;
 539         logon.req.logon.request_count = 0;
 540         logon.req.logon.computer_name = TEST_NAME;
 541         logon.req.logon.user_name     = TEST_NAME"$";
 542         logon.req.logon.mailslot_name = dgmslot->mailslot_name;
 543         logon.req.logon.acct_control  = ACB_WSTRUST;
 544         /* Leave sid as all zero */
 545         logon.req.logon.nt_version    = 1;
 546         logon.req.logon.lmnt_token    = 0xFFFF;
 547         logon.req.logon.lm20_token    = 0xFFFF;
 548 
 549         make_nbt_name_client(&myname, TEST_NAME);
 550 
 551         dest = socket_address_from_strings(dgmsock, dgmsock->sock->backend_name, 
 552                                            address, lp_dgram_port(tctx->lp_ctx));
 553         torture_assert(tctx, dest != NULL, "Error getting address");
 554         status = dgram_mailslot_netlogon_send(dgmsock, 
 555                                               &name, dest, 
 556                                               NBT_MAILSLOT_NTLOGON, 
 557                                               &myname, &logon);
 558         torture_assert_ntstatus_ok(tctx, status, "Failed to send ntlogon request");
 559 
 560         while (timeval_elapsed(&tv) < 5 && dgmslot->private_data == NULL) {
 561                 event_loop_once(dgmsock->event_ctx);
 562         }
 563 
 564         response = talloc_get_type(dgmslot->private_data, struct nbt_netlogon_response);
 565 
 566         torture_assert(tctx, response != NULL, "Failed to receive a netlogon reply packet");
 567 
 568         torture_assert_int_equal(tctx, response->response_type, NETLOGON_SAMLOGON, "Got incorrect type of netlogon response");
 569         map_netlogon_samlogon_response(&response->data.samlogon);
 570 
 571         torture_assert_int_equal(tctx, response->data.samlogon.data.nt5_ex.command, LOGON_SAM_LOGON_RESPONSE, "Got incorrect netlogon response command");
 572 
 573         torture_assert_str_equal(tctx, response->data.samlogon.data.nt5_ex.user_name, TEST_NAME"$", "Got incorrect user in netlogon response");
 574 
 575 
 576         /* setup (another) temporary mailslot listener for replies */
 577         dgmslot = dgram_mailslot_temp(dgmsock, NBT_MAILSLOT_GETDC,
 578                                       netlogon_handler, NULL);
 579         
 580         ZERO_STRUCT(logon);
 581         logon.command = LOGON_PRIMARY_QUERY;
 582         logon.req.pdc.computer_name = TEST_NAME;
 583         logon.req.pdc.mailslot_name = dgmslot->mailslot_name;
 584         logon.req.pdc.unicode_name  = TEST_NAME;
 585         logon.req.pdc.nt_version    = 1;
 586         logon.req.pdc.lmnt_token    = 0xFFFF;
 587         logon.req.pdc.lm20_token    = 0xFFFF;
 588 
 589         make_nbt_name_client(&myname, TEST_NAME);
 590 
 591         dest = socket_address_from_strings(dgmsock, dgmsock->sock->backend_name, 
 592                                            address, lp_dgram_port(tctx->lp_ctx));
 593         torture_assert(tctx, dest != NULL, "Error getting address");
 594         status = dgram_mailslot_netlogon_send(dgmsock, 
 595                                               &name, dest, 
 596                                               NBT_MAILSLOT_NTLOGON, 
 597                                               &myname, &logon);
 598         torture_assert_ntstatus_ok(tctx, status, "Failed to send ntlogon request");
 599 
 600         while (timeval_elapsed(&tv) < 5 && !dgmslot->private_data) {
 601                 event_loop_once(dgmsock->event_ctx);
 602         }
 603 
 604         response = talloc_get_type(dgmslot->private_data, struct nbt_netlogon_response);
 605 
 606         torture_assert(tctx, response != NULL, "Failed to receive a netlogon reply packet");
 607 
 608         torture_assert_int_equal(tctx, response->response_type, NETLOGON_GET_PDC, "Got incorrect type of ntlogon response");
 609         torture_assert_int_equal(tctx, response->data.get_pdc.command, NETLOGON_RESPONSE_FROM_PDC, "Got incorrect ntlogon response command");
 610 
 611         torture_leave_domain(tctx, join_ctx);
 612 
 613         /* setup (another) temporary mailslot listener for replies */
 614         dgmslot = dgram_mailslot_temp(dgmsock, NBT_MAILSLOT_GETDC,
 615                                       netlogon_handler, NULL);
 616         
 617         ZERO_STRUCT(logon);
 618         logon.command = LOGON_PRIMARY_QUERY;
 619         logon.req.pdc.computer_name = TEST_NAME;
 620         logon.req.pdc.mailslot_name = dgmslot->mailslot_name;
 621         logon.req.pdc.unicode_name  = TEST_NAME;
 622         logon.req.pdc.nt_version    = 1;
 623         logon.req.pdc.lmnt_token    = 0xFFFF;
 624         logon.req.pdc.lm20_token    = 0xFFFF;
 625 
 626         make_nbt_name_client(&myname, TEST_NAME);
 627 
 628         dest = socket_address_from_strings(dgmsock, dgmsock->sock->backend_name, 
 629                                            address, lp_dgram_port(tctx->lp_ctx));
 630         torture_assert(tctx, dest != NULL, "Error getting address");
 631         status = dgram_mailslot_netlogon_send(dgmsock, 
 632                                               &name, dest, 
 633                                               NBT_MAILSLOT_NTLOGON, 
 634                                               &myname, &logon);
 635         torture_assert_ntstatus_ok(tctx, status, "Failed to send ntlogon request");
 636 
 637         while (timeval_elapsed(&tv) < 5 && !dgmslot->private_data) {
 638                 event_loop_once(dgmsock->event_ctx);
 639         }
 640 
 641         response = talloc_get_type(dgmslot->private_data, struct nbt_netlogon_response);
 642 
 643         torture_assert(tctx, response != NULL, "Failed to receive a netlogon reply packet");
 644 
 645         torture_assert_int_equal(tctx, response->response_type, NETLOGON_GET_PDC, "Got incorrect type of ntlogon response");
 646         torture_assert_int_equal(tctx, response->data.get_pdc.command, NETLOGON_RESPONSE_FROM_PDC, "Got incorrect ntlogon response command");
 647 
 648 
 649         return true;
 650 }
 651 
 652 
 653 /*
 654   test nbt dgram operations
 655 */
 656 struct torture_suite *torture_nbt_dgram(TALLOC_CTX *mem_ctx)
     /* [<][>][^][v][top][bottom][index][help] */
 657 {
 658         struct torture_suite *suite = torture_suite_create(mem_ctx, "DGRAM");
 659 
 660         torture_suite_add_simple_test(suite, "netlogon", nbt_test_netlogon);
 661         torture_suite_add_simple_test(suite, "netlogon2", nbt_test_netlogon2);
 662         torture_suite_add_simple_test(suite, "ntlogon", nbt_test_ntlogon);
 663 
 664         return suite;
 665 }

/* [<][>][^][v][top][bottom][index][help] */