source4/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_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)
  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)
 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)
 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)
 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 }