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