source/torture/nbt/dgram.c

   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,
  41                              struct nbt_dgram_packet *packet,
  42                              struct socket_address *src)
  43 {
  44         NTSTATUS status;
  45         struct nbt_netlogon_response *netlogon = dgmslot->private;
  46
  47         dgmslot->private = netlogon = talloc(dgmslot, struct nbt_netlogon_response);
  48
  49         if (!dgmslot->private) {
  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)
  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) {
 143                 event_loop_once(dgmsock->event_ctx);
 144         }
 145
 146         response = talloc_get_type(dgmslot->private, 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->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)
 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 == NULL) {
 238                 event_loop_once(dgmsock->event_ctx);
 239         }
 240
 241         response = talloc_get_type(dgmslot->private, 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->samlogon);
 247
 248         torture_assert_int_equal(tctx, response->samlogon.nt5_ex.command, LOGON_SAM_LOGON_RESPONSE_EX, "Got incorrect netlogon response command");
 249         torture_assert_int_equal(tctx, response->samlogon.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 == NULL) {
 277                 event_loop_once(dgmsock->event_ctx);
 278         }
 279
 280         response = talloc_get_type(dgmslot->private, 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->samlogon);
 286
 287         torture_assert_int_equal(tctx, response->samlogon.nt5_ex.command, LOGON_SAM_LOGON_USER_UNKNOWN, "Got incorrect netlogon response command");
 288
 289         torture_assert_str_equal(tctx, response->samlogon.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         dom_sid = torture_join_sid(join_ctx);
 295
 296         /* setup (another) temporary mailslot listener for replies */
 297         dgmslot = dgram_mailslot_temp(dgmsock, NBT_MAILSLOT_GETDC,
 298                                       netlogon_handler, NULL);
 299
 300         ZERO_STRUCT(logon);
 301         logon.command = LOGON_SAM_LOGON_REQUEST;
 302         logon.req.logon.request_count = 0;
 303         logon.req.logon.computer_name = TEST_NAME;
 304         logon.req.logon.user_name     = TEST_NAME"$";
 305         logon.req.logon.mailslot_name = dgmslot->mailslot_name;
 306         logon.req.logon.sid           = *dom_sid;
 307         logon.req.logon.nt_version    = 1;
 308         logon.req.logon.lmnt_token    = 0xFFFF;
 309         logon.req.logon.lm20_token    = 0xFFFF;
 310
 311         make_nbt_name_client(&myname, TEST_NAME);
 312
 313         dest = socket_address_from_strings(dgmsock, dgmsock->sock->backend_name,
 314                                            address, lp_dgram_port(tctx->lp_ctx));
 315
 316         torture_assert(tctx, dest != NULL, "Error getting address");
 317         status = dgram_mailslot_netlogon_send(dgmsock, &name, dest,
 318                                               NBT_MAILSLOT_NETLOGON,
 319                                               &myname, &logon);
 320         torture_assert_ntstatus_ok(tctx, status, "Failed to send netlogon request");
 321
 322
 323         while (timeval_elapsed(&tv) < 5 && dgmslot->private == NULL) {
 324                 event_loop_once(dgmsock->event_ctx);
 325         }
 326
 327         response = talloc_get_type(dgmslot->private, struct nbt_netlogon_response);
 328
 329         torture_assert(tctx, response != NULL, "Failed to receive a netlogon reply packet");
 330
 331         torture_assert_int_equal(tctx, response->response_type, NETLOGON_SAMLOGON, "Got incorrect type of netlogon response");
 332         map_netlogon_samlogon_response(&response->samlogon);
 333
 334         torture_assert_int_equal(tctx, response->samlogon.nt5_ex.command, LOGON_SAM_LOGON_USER_UNKNOWN, "Got incorrect netlogon response command");
 335
 336         /* setup (another) temporary mailslot listener for replies */
 337         dgmslot = dgram_mailslot_temp(dgmsock, NBT_MAILSLOT_GETDC,
 338                                       netlogon_handler, NULL);
 339
 340         ZERO_STRUCT(logon);
 341         logon.command = LOGON_SAM_LOGON_REQUEST;
 342         logon.req.logon.request_count = 0;
 343         logon.req.logon.computer_name = TEST_NAME;
 344         logon.req.logon.user_name     = TEST_NAME"$";
 345         logon.req.logon.mailslot_name = dgmslot->mailslot_name;
 346         logon.req.logon.sid           = *dom_sid;
 347         logon.req.logon.acct_control  = ACB_WSTRUST;
 348         logon.req.logon.nt_version    = 1;
 349         logon.req.logon.lmnt_token    = 0xFFFF;
 350         logon.req.logon.lm20_token    = 0xFFFF;
 351
 352         make_nbt_name_client(&myname, TEST_NAME);
 353
 354         dest = socket_address_from_strings(dgmsock, dgmsock->sock->backend_name,
 355                                            address, lp_dgram_port(tctx->lp_ctx));
 356
 357         torture_assert(tctx, dest != NULL, "Error getting address");
 358         status = dgram_mailslot_netlogon_send(dgmsock, &name, dest,
 359                                               NBT_MAILSLOT_NETLOGON,
 360                                               &myname, &logon);
 361         torture_assert_ntstatus_ok(tctx, status, "Failed to send netlogon request");
 362
 363
 364         while (timeval_elapsed(&tv) < 5 && dgmslot->private == NULL) {
 365                 event_loop_once(dgmsock->event_ctx);
 366         }
 367
 368         response = talloc_get_type(dgmslot->private, struct nbt_netlogon_response);
 369
 370         torture_assert(tctx, response != NULL, "Failed to receive a netlogon reply packet");
 371
 372         torture_assert_int_equal(tctx, response->response_type, NETLOGON_SAMLOGON, "Got incorrect type of netlogon response");
 373         map_netlogon_samlogon_response(&response->samlogon);
 374
 375         torture_assert_int_equal(tctx, response->samlogon.nt5_ex.command, LOGON_SAM_LOGON_RESPONSE, "Got incorrect netlogon response command");
 376
 377         dgmslot->private = NULL;
 378
 379         ZERO_STRUCT(logon);
 380         logon.command = LOGON_SAM_LOGON_REQUEST;
 381         logon.req.logon.request_count = 0;
 382         logon.req.logon.computer_name = TEST_NAME;
 383         logon.req.logon.user_name     = TEST_NAME"$";
 384         logon.req.logon.mailslot_name = dgmslot->mailslot_name;
 385         logon.req.logon.sid           = *dom_sid;
 386         logon.req.logon.acct_control  = ACB_NORMAL;
 387         logon.req.logon.nt_version    = 1;
 388         logon.req.logon.lmnt_token    = 0xFFFF;
 389         logon.req.logon.lm20_token    = 0xFFFF;
 390
 391         make_nbt_name_client(&myname, TEST_NAME);
 392
 393         dest = socket_address_from_strings(dgmsock, dgmsock->sock->backend_name,
 394                                            address, lp_dgram_port(tctx->lp_ctx));
 395
 396         torture_assert(tctx, dest != NULL, "Error getting address");
 397         status = dgram_mailslot_netlogon_send(dgmsock, &name, dest,
 398                                               NBT_MAILSLOT_NETLOGON,
 399                                               &myname, &logon);
 400         torture_assert_ntstatus_ok(tctx, status, "Failed to send netlogon request");
 401
 402
 403         while (timeval_elapsed(&tv) < 5 && dgmslot->private == NULL) {
 404                 event_loop_once(dgmsock->event_ctx);
 405         }
 406
 407         response = talloc_get_type(dgmslot->private, struct nbt_netlogon_response);
 408
 409         torture_assert(tctx, response != NULL, "Failed to receive a netlogon reply packet");
 410
 411         torture_assert_int_equal(tctx, response->response_type, NETLOGON_SAMLOGON, "Got incorrect type of netlogon response");
 412         map_netlogon_samlogon_response(&response->samlogon);
 413
 414         torture_assert_int_equal(tctx, response->samlogon.nt5_ex.command, LOGON_SAM_LOGON_USER_UNKNOWN, "Got incorrect netlogon response command");
 415
 416         torture_leave_domain(join_ctx);
 417         return true;
 418 }
 419
 420
 421 /* test UDP/138 ntlogon requests */
 422 static bool nbt_test_ntlogon(struct torture_context *tctx)
 423 {
 424         struct dgram_mailslot_handler *dgmslot;
 425         struct nbt_dgram_socket *dgmsock = nbt_dgram_socket_init(tctx, tctx->ev,
 426                                                                  lp_iconv_convenience(tctx->lp_ctx));
 427         struct socket_address *dest;
 428         struct test_join *join_ctx;
 429         const struct dom_sid *dom_sid;
 430         struct cli_credentials *machine_credentials;
 431
 432         const char *myaddress;
 433         struct nbt_netlogon_packet logon;
 434         struct nbt_netlogon_response *response;
 435         struct nbt_name myname;
 436         NTSTATUS status;
 437         struct timeval tv = timeval_current();
 438
 439         struct socket_address *socket_address;
 440         const char *address;
 441         struct nbt_name name;
 442
 443         struct interface *ifaces;
 444
 445         name.name = lp_workgroup(tctx->lp_ctx);
 446         name.type = NBT_NAME_LOGON;
 447         name.scope = NULL;
 448
 449         /* do an initial name resolution to find its IP */
 450         torture_assert_ntstatus_ok(tctx,
 451                                    resolve_name(lp_resolve_context(tctx->lp_ctx), &name, tctx, &address, tctx->ev),
 452                                    talloc_asprintf(tctx, "Failed to resolve %s", name.name));
 453
 454         load_interfaces(tctx, lp_interfaces(tctx->lp_ctx), &ifaces);
 455         myaddress = talloc_strdup(dgmsock, iface_best_ip(ifaces, address));
 456
 457         socket_address = socket_address_from_strings(dgmsock, dgmsock->sock->backend_name,
 458                                                      myaddress, lp_dgram_port(tctx->lp_ctx));
 459         torture_assert(tctx, socket_address != NULL, "Error getting address");
 460
 461         /* try receiving replies on port 138 first, which will only
 462            work if we are root and smbd/nmbd are not running - fall
 463            back to listening on any port, which means replies from
 464            most windows versions won't be seen */
 465         status = socket_listen(dgmsock->sock, socket_address, 0, 0);
 466         if (!NT_STATUS_IS_OK(status)) {
 467                 talloc_free(socket_address);
 468                 socket_address = socket_address_from_strings(dgmsock, dgmsock->sock->backend_name,
 469                                                              myaddress, 0);
 470                 torture_assert(tctx, socket_address != NULL, "Error getting address");
 471
 472                 socket_listen(dgmsock->sock, socket_address, 0, 0);
 473         }
 474
 475         join_ctx = torture_join_domain(tctx, TEST_NAME,
 476                                        ACB_WSTRUST, &machine_credentials);
 477         dom_sid = torture_join_sid(join_ctx);
 478
 479         torture_assert(tctx, join_ctx != NULL,
 480                        talloc_asprintf(tctx, "Failed to join domain %s as %s\n",
 481                                        lp_workgroup(tctx->lp_ctx), TEST_NAME));
 482
 483         /* setup a temporary mailslot listener for replies */
 484         dgmslot = dgram_mailslot_temp(dgmsock, NBT_MAILSLOT_GETDC,
 485                                       netlogon_handler, NULL);
 486
 487
 488         ZERO_STRUCT(logon);
 489         logon.command = LOGON_SAM_LOGON_REQUEST;
 490         logon.req.logon.request_count = 0;
 491         logon.req.logon.computer_name = TEST_NAME;
 492         logon.req.logon.user_name     = TEST_NAME"$";
 493         logon.req.logon.mailslot_name = dgmslot->mailslot_name;
 494         logon.req.logon.acct_control  = ACB_WSTRUST;
 495         /* Try with a SID this time */
 496         logon.req.logon.sid           = *dom_sid;
 497         logon.req.logon.nt_version    = 1;
 498         logon.req.logon.lmnt_token    = 0xFFFF;
 499         logon.req.logon.lm20_token    = 0xFFFF;
 500
 501         make_nbt_name_client(&myname, TEST_NAME);
 502
 503         dest = socket_address_from_strings(dgmsock, dgmsock->sock->backend_name,
 504                                            address, lp_dgram_port(tctx->lp_ctx));
 505         torture_assert(tctx, dest != NULL, "Error getting address");
 506         status = dgram_mailslot_netlogon_send(dgmsock,
 507                                               &name, dest,
 508                                               NBT_MAILSLOT_NTLOGON,
 509                                               &myname, &logon);
 510         torture_assert_ntstatus_ok(tctx, status, "Failed to send ntlogon request");
 511
 512         while (timeval_elapsed(&tv) < 5 && dgmslot->private == NULL) {
 513                 event_loop_once(dgmsock->event_ctx);
 514         }
 515
 516         response = talloc_get_type(dgmslot->private, struct nbt_netlogon_response);
 517
 518         torture_assert(tctx, response != NULL, "Failed to receive a netlogon reply packet");
 519
 520         torture_assert_int_equal(tctx, response->response_type, NETLOGON_SAMLOGON, "Got incorrect type of netlogon response");
 521         map_netlogon_samlogon_response(&response->samlogon);
 522
 523         torture_assert_int_equal(tctx, response->samlogon.nt5_ex.command, LOGON_SAM_LOGON_RESPONSE, "Got incorrect netlogon response command");
 524
 525         torture_assert_str_equal(tctx, response->samlogon.nt5_ex.user_name, TEST_NAME"$", "Got incorrect user in netlogon response");
 526
 527
 528         /* setup a temporary mailslot listener for replies */
 529         dgmslot = dgram_mailslot_temp(dgmsock, NBT_MAILSLOT_GETDC,
 530                                       netlogon_handler, NULL);
 531
 532
 533         ZERO_STRUCT(logon);
 534         logon.command = LOGON_SAM_LOGON_REQUEST;
 535         logon.req.logon.request_count = 0;
 536         logon.req.logon.computer_name = TEST_NAME;
 537         logon.req.logon.user_name     = TEST_NAME"$";
 538         logon.req.logon.mailslot_name = dgmslot->mailslot_name;
 539         logon.req.logon.acct_control  = ACB_WSTRUST;
 540         /* Leave sid as all zero */
 541         logon.req.logon.nt_version    = 1;
 542         logon.req.logon.lmnt_token    = 0xFFFF;
 543         logon.req.logon.lm20_token    = 0xFFFF;
 544
 545         make_nbt_name_client(&myname, TEST_NAME);
 546
 547         dest = socket_address_from_strings(dgmsock, dgmsock->sock->backend_name,
 548                                            address, lp_dgram_port(tctx->lp_ctx));
 549         torture_assert(tctx, dest != NULL, "Error getting address");
 550         status = dgram_mailslot_netlogon_send(dgmsock,
 551                                               &name, dest,
 552                                               NBT_MAILSLOT_NTLOGON,
 553                                               &myname, &logon);
 554         torture_assert_ntstatus_ok(tctx, status, "Failed to send ntlogon request");
 555
 556         while (timeval_elapsed(&tv) < 5 && dgmslot->private == NULL) {
 557                 event_loop_once(dgmsock->event_ctx);
 558         }
 559
 560         response = talloc_get_type(dgmslot->private, struct nbt_netlogon_response);
 561
 562         torture_assert(tctx, response != NULL, "Failed to receive a netlogon reply packet");
 563
 564         torture_assert_int_equal(tctx, response->response_type, NETLOGON_SAMLOGON, "Got incorrect type of netlogon response");
 565         map_netlogon_samlogon_response(&response->samlogon);
 566
 567         torture_assert_int_equal(tctx, response->samlogon.nt5_ex.command, LOGON_SAM_LOGON_RESPONSE, "Got incorrect netlogon response command");
 568
 569         torture_assert_str_equal(tctx, response->samlogon.nt5_ex.user_name, TEST_NAME"$", "Got incorrect user in netlogon response");
 570
 571
 572         /* setup (another) temporary mailslot listener for replies */
 573         dgmslot = dgram_mailslot_temp(dgmsock, NBT_MAILSLOT_GETDC,
 574                                       netlogon_handler, NULL);
 575
 576         ZERO_STRUCT(logon);
 577         logon.command = LOGON_PRIMARY_QUERY;
 578         logon.req.pdc.computer_name = TEST_NAME;
 579         logon.req.pdc.mailslot_name = dgmslot->mailslot_name;
 580         logon.req.pdc.unicode_name  = TEST_NAME;
 581         logon.req.pdc.nt_version    = 1;
 582         logon.req.pdc.lmnt_token    = 0xFFFF;
 583         logon.req.pdc.lm20_token    = 0xFFFF;
 584
 585         make_nbt_name_client(&myname, TEST_NAME);
 586
 587         dest = socket_address_from_strings(dgmsock, dgmsock->sock->backend_name,
 588                                            address, lp_dgram_port(tctx->lp_ctx));
 589         torture_assert(tctx, dest != NULL, "Error getting address");
 590         status = dgram_mailslot_netlogon_send(dgmsock,
 591                                               &name, dest,
 592                                               NBT_MAILSLOT_NTLOGON,
 593                                               &myname, &logon);
 594         torture_assert_ntstatus_ok(tctx, status, "Failed to send ntlogon request");
 595
 596         while (timeval_elapsed(&tv) < 5 && !dgmslot->private) {
 597                 event_loop_once(dgmsock->event_ctx);
 598         }
 599
 600         response = talloc_get_type(dgmslot->private, struct nbt_netlogon_response);
 601
 602         torture_assert(tctx, response != NULL, "Failed to receive a netlogon reply packet");
 603
 604         torture_assert_int_equal(tctx, response->response_type, NETLOGON_GET_PDC, "Got incorrect type of ntlogon response");
 605         torture_assert_int_equal(tctx, response->get_pdc.command, NETLOGON_RESPONSE_FROM_PDC, "Got incorrect ntlogon response command");
 606
 607         torture_leave_domain(join_ctx);
 608
 609         /* setup (another) temporary mailslot listener for replies */
 610         dgmslot = dgram_mailslot_temp(dgmsock, NBT_MAILSLOT_GETDC,
 611                                       netlogon_handler, NULL);
 612
 613         ZERO_STRUCT(logon);
 614         logon.command = LOGON_PRIMARY_QUERY;
 615         logon.req.pdc.computer_name = TEST_NAME;
 616         logon.req.pdc.mailslot_name = dgmslot->mailslot_name;
 617         logon.req.pdc.unicode_name  = TEST_NAME;
 618         logon.req.pdc.nt_version    = 1;
 619         logon.req.pdc.lmnt_token    = 0xFFFF;
 620         logon.req.pdc.lm20_token    = 0xFFFF;
 621
 622         make_nbt_name_client(&myname, TEST_NAME);
 623
 624         dest = socket_address_from_strings(dgmsock, dgmsock->sock->backend_name,
 625                                            address, lp_dgram_port(tctx->lp_ctx));
 626         torture_assert(tctx, dest != NULL, "Error getting address");
 627         status = dgram_mailslot_netlogon_send(dgmsock,
 628                                               &name, dest,
 629                                               NBT_MAILSLOT_NTLOGON,
 630                                               &myname, &logon);
 631         torture_assert_ntstatus_ok(tctx, status, "Failed to send ntlogon request");
 632
 633         while (timeval_elapsed(&tv) < 5 && !dgmslot->private) {
 634                 event_loop_once(dgmsock->event_ctx);
 635         }
 636
 637         response = talloc_get_type(dgmslot->private, struct nbt_netlogon_response);
 638
 639         torture_assert(tctx, response != NULL, "Failed to receive a netlogon reply packet");
 640
 641         torture_assert_int_equal(tctx, response->response_type, NETLOGON_GET_PDC, "Got incorrect type of ntlogon response");
 642         torture_assert_int_equal(tctx, response->get_pdc.command, NETLOGON_RESPONSE_FROM_PDC, "Got incorrect ntlogon response command");
 643
 644
 645         return true;
 646 }
 647
 648
 649 /*
 650   test nbt dgram operations
 651 */
 652 struct torture_suite *torture_nbt_dgram(TALLOC_CTX *mem_ctx)
 653 {
 654         struct torture_suite *suite = torture_suite_create(mem_ctx, "DGRAM");
 655
 656         torture_suite_add_simple_test(suite, "netlogon", nbt_test_netlogon);
 657         torture_suite_add_simple_test(suite, "netlogon2", nbt_test_netlogon2);
 658         torture_suite_add_simple_test(suite, "ntlogon", nbt_test_ntlogon);
 659
 660         return suite;
 661 }