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