2 Unix SMB/CIFS implementation.
6 Copyright (C) Andrew Tridgell 2005
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.
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.
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/>.
23 #include "libcli/dgram/libdgram.h"
24 #include "lib/socket/socket.h"
25 #include "lib/events/events.h"
26 #include "torture/rpc/rpc.h"
27 #include "libcli/resolve/resolve.h"
28 #include "system/network.h"
29 #include "lib/socket/netif.h"
30 #include "param/param.h"
32 #define TEST_NAME "TORTURE_TEST"
35 reply handler for netlogon request
37 static void netlogon_handler(struct dgram_mailslot_handler *dgmslot,
38 struct nbt_dgram_packet *packet,
39 struct socket_address *src)
42 struct nbt_netlogon_response *netlogon = dgmslot->private_data;
44 dgmslot->private_data = netlogon = talloc(dgmslot, struct nbt_netlogon_response);
46 if (!dgmslot->private_data) {
50 printf("netlogon reply from %s:%d\n", src->addr, src->port);
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);
63 /* test UDP/138 netlogon requests */
64 static bool nbt_test_netlogon(struct torture_context *tctx)
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;
75 struct timeval tv = timeval_current();
77 struct socket_address *socket_address;
82 struct interface *ifaces;
84 name.name = lp_workgroup(tctx->lp_ctx);
85 name.type = NBT_NAME_LOGON;
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));
93 load_interfaces(tctx, lp_interfaces(tctx->lp_ctx), &ifaces);
94 myaddress = talloc_strdup(dgmsock, iface_best_ip(ifaces, address));
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");
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,
110 torture_assert(tctx, socket_address != NULL, "Error getting address");
112 socket_listen(dgmsock->sock, socket_address, 0, 0);
115 /* setup a temporary mailslot listener for replies */
116 dgmslot = dgram_mailslot_temp(dgmsock, NBT_MAILSLOT_GETDC,
117 netlogon_handler, NULL);
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;
128 make_nbt_name_client(&myname, TEST_NAME);
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");
134 status = dgram_mailslot_netlogon_send(dgmsock, &name, dest,
135 NBT_MAILSLOT_NETLOGON,
137 torture_assert_ntstatus_ok(tctx, status, "Failed to send netlogon request");
139 while (timeval_elapsed(&tv) < 5 && !dgmslot->private_data) {
140 event_loop_once(dgmsock->event_ctx);
143 response = talloc_get_type(dgmslot->private_data, struct nbt_netlogon_response);
145 torture_assert(tctx, response != NULL, "Failed to receive a netlogon reply packet");
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");
154 /* test UDP/138 netlogon requests */
155 static bool nbt_test_netlogon2(struct torture_context *tctx)
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;
166 struct timeval tv = timeval_current();
168 struct socket_address *socket_address;
171 struct nbt_name name;
173 struct interface *ifaces;
174 struct test_join *join_ctx;
175 struct cli_credentials *machine_credentials;
176 const struct dom_sid *dom_sid;
178 name.name = lp_workgroup(tctx->lp_ctx);
179 name.type = NBT_NAME_LOGON;
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));
187 load_interfaces(tctx, lp_interfaces(tctx->lp_ctx), &ifaces);
188 myaddress = talloc_strdup(dgmsock, iface_best_ip(ifaces, address));
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");
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,
203 torture_assert(tctx, socket_address != NULL, "Error getting address");
205 socket_listen(dgmsock->sock, socket_address, 0, 0);
208 /* setup a temporary mailslot listener for replies */
209 dgmslot = dgram_mailslot_temp(dgmsock, NBT_MAILSLOT_GETDC,
210 netlogon_handler, NULL);
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;
223 make_nbt_name_client(&myname, TEST_NAME);
225 dest = socket_address_from_strings(dgmsock, dgmsock->sock->backend_name,
226 address, lp_dgram_port(tctx->lp_ctx));
228 torture_assert(tctx, dest != NULL, "Error getting address");
229 status = dgram_mailslot_netlogon_send(dgmsock, &name, dest,
230 NBT_MAILSLOT_NETLOGON,
232 torture_assert_ntstatus_ok(tctx, status, "Failed to send netlogon request");
234 while (timeval_elapsed(&tv) < 5 && dgmslot->private_data == NULL) {
235 event_loop_once(dgmsock->event_ctx);
238 response = talloc_get_type(dgmslot->private_data, struct nbt_netlogon_response);
240 torture_assert(tctx, response != NULL, "Failed to receive a netlogon reply packet");
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);
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");
248 /* setup (another) temporary mailslot listener for replies */
249 dgmslot = dgram_mailslot_temp(dgmsock, NBT_MAILSLOT_GETDC,
250 netlogon_handler, NULL);
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;
262 make_nbt_name_client(&myname, TEST_NAME);
264 dest = socket_address_from_strings(dgmsock, dgmsock->sock->backend_name,
265 address, lp_dgram_port(tctx->lp_ctx));
267 torture_assert(tctx, dest != NULL, "Error getting address");
268 status = dgram_mailslot_netlogon_send(dgmsock, &name, dest,
269 NBT_MAILSLOT_NETLOGON,
271 torture_assert_ntstatus_ok(tctx, status, "Failed to send netlogon request");
273 while (timeval_elapsed(&tv) < 5 && dgmslot->private_data == NULL) {
274 event_loop_once(dgmsock->event_ctx);
277 response = talloc_get_type(dgmslot->private_data, struct nbt_netlogon_response);
279 torture_assert(tctx, response != NULL, "Failed to receive a netlogon reply packet");
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);
284 torture_assert_int_equal(tctx, response->data.samlogon.data.nt5_ex.command, LOGON_SAM_LOGON_USER_UNKNOWN, "Got incorrect netlogon response command");
286 torture_assert_str_equal(tctx, response->data.samlogon.data.nt5_ex.user_name, TEST_NAME"$", "Got incorrect user in netlogon response");
288 join_ctx = torture_join_domain(tctx, TEST_NAME,
289 ACB_WSTRUST, &machine_credentials);
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));
295 dom_sid = torture_join_sid(join_ctx);
297 /* setup (another) temporary mailslot listener for replies */
298 dgmslot = dgram_mailslot_temp(dgmsock, NBT_MAILSLOT_GETDC,
299 netlogon_handler, NULL);
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;
312 make_nbt_name_client(&myname, TEST_NAME);
314 dest = socket_address_from_strings(dgmsock, dgmsock->sock->backend_name,
315 address, lp_dgram_port(tctx->lp_ctx));
317 torture_assert(tctx, dest != NULL, "Error getting address");
318 status = dgram_mailslot_netlogon_send(dgmsock, &name, dest,
319 NBT_MAILSLOT_NETLOGON,
321 torture_assert_ntstatus_ok(tctx, status, "Failed to send netlogon request");
324 while (timeval_elapsed(&tv) < 5 && dgmslot->private_data == NULL) {
325 event_loop_once(dgmsock->event_ctx);
328 response = talloc_get_type(dgmslot->private_data, struct nbt_netlogon_response);
330 torture_assert(tctx, response != NULL, "Failed to receive a netlogon reply packet");
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);
335 torture_assert_int_equal(tctx, response->data.samlogon.data.nt5_ex.command, LOGON_SAM_LOGON_USER_UNKNOWN, "Got incorrect netlogon response command");
337 /* setup (another) temporary mailslot listener for replies */
338 dgmslot = dgram_mailslot_temp(dgmsock, NBT_MAILSLOT_GETDC,
339 netlogon_handler, NULL);
341 torture_assert(tctx, dgmslot != NULL, "Error getting a Mailslot for GetDC reply");
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;
355 make_nbt_name_client(&myname, TEST_NAME);
357 dest = socket_address_from_strings(dgmsock, dgmsock->sock->backend_name,
358 address, lp_dgram_port(tctx->lp_ctx));
360 torture_assert(tctx, dest != NULL, "Error getting address");
361 status = dgram_mailslot_netlogon_send(dgmsock, &name, dest,
362 NBT_MAILSLOT_NETLOGON,
364 torture_assert_ntstatus_ok(tctx, status, "Failed to send netlogon request");
367 while (timeval_elapsed(&tv) < 5 && dgmslot->private_data == NULL) {
368 event_loop_once(dgmsock->event_ctx);
371 response = talloc_get_type(dgmslot->private_data, struct nbt_netlogon_response);
373 torture_assert(tctx, response != NULL, "Failed to receive a netlogon reply packet");
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);
378 torture_assert_int_equal(tctx, response->data.samlogon.data.nt5_ex.command, LOGON_SAM_LOGON_RESPONSE, "Got incorrect netlogon response command");
380 dgmslot->private_data = NULL;
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;
394 make_nbt_name_client(&myname, TEST_NAME);
396 dest = socket_address_from_strings(dgmsock, dgmsock->sock->backend_name,
397 address, lp_dgram_port(tctx->lp_ctx));
399 torture_assert(tctx, dest != NULL, "Error getting address");
400 status = dgram_mailslot_netlogon_send(dgmsock, &name, dest,
401 NBT_MAILSLOT_NETLOGON,
403 torture_assert_ntstatus_ok(tctx, status, "Failed to send netlogon request");
406 while (timeval_elapsed(&tv) < 5 && dgmslot->private_data == NULL) {
407 event_loop_once(dgmsock->event_ctx);
410 response = talloc_get_type(dgmslot->private_data, struct nbt_netlogon_response);
412 torture_assert(tctx, response != NULL, "Failed to receive a netlogon reply packet");
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);
417 torture_assert_int_equal(tctx, response->data.samlogon.data.nt5_ex.command, LOGON_SAM_LOGON_USER_UNKNOWN, "Got incorrect netlogon response command");
419 torture_leave_domain(tctx, join_ctx);
424 /* test UDP/138 ntlogon requests */
425 static bool nbt_test_ntlogon(struct torture_context *tctx)
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;
435 const char *myaddress;
436 struct nbt_netlogon_packet logon;
437 struct nbt_netlogon_response *response;
438 struct nbt_name myname;
440 struct timeval tv = timeval_current();
442 struct socket_address *socket_address;
444 struct nbt_name name;
446 struct interface *ifaces;
448 name.name = lp_workgroup(tctx->lp_ctx);
449 name.type = NBT_NAME_LOGON;
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));
457 load_interfaces(tctx, lp_interfaces(tctx->lp_ctx), &ifaces);
458 myaddress = talloc_strdup(dgmsock, iface_best_ip(ifaces, address));
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");
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,
473 torture_assert(tctx, socket_address != NULL, "Error getting address");
475 socket_listen(dgmsock->sock, socket_address, 0, 0);
478 join_ctx = torture_join_domain(tctx, TEST_NAME,
479 ACB_WSTRUST, &machine_credentials);
480 dom_sid = torture_join_sid(join_ctx);
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));
486 /* setup a temporary mailslot listener for replies */
487 dgmslot = dgram_mailslot_temp(dgmsock, NBT_MAILSLOT_GETDC,
488 netlogon_handler, NULL);
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;
504 make_nbt_name_client(&myname, TEST_NAME);
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,
511 NBT_MAILSLOT_NTLOGON,
513 torture_assert_ntstatus_ok(tctx, status, "Failed to send ntlogon request");
515 while (timeval_elapsed(&tv) < 5 && dgmslot->private_data == NULL) {
516 event_loop_once(dgmsock->event_ctx);
519 response = talloc_get_type(dgmslot->private_data, struct nbt_netlogon_response);
521 torture_assert(tctx, response != NULL, "Failed to receive a netlogon reply packet");
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);
526 torture_assert_int_equal(tctx, response->data.samlogon.data.nt5_ex.command, LOGON_SAM_LOGON_RESPONSE, "Got incorrect netlogon response command");
528 torture_assert_str_equal(tctx, response->data.samlogon.data.nt5_ex.user_name, TEST_NAME"$", "Got incorrect user in netlogon response");
531 /* setup a temporary mailslot listener for replies */
532 dgmslot = dgram_mailslot_temp(dgmsock, NBT_MAILSLOT_GETDC,
533 netlogon_handler, NULL);
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;
548 make_nbt_name_client(&myname, TEST_NAME);
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,
555 NBT_MAILSLOT_NTLOGON,
557 torture_assert_ntstatus_ok(tctx, status, "Failed to send ntlogon request");
559 while (timeval_elapsed(&tv) < 5 && dgmslot->private_data == NULL) {
560 event_loop_once(dgmsock->event_ctx);
563 response = talloc_get_type(dgmslot->private_data, struct nbt_netlogon_response);
565 torture_assert(tctx, response != NULL, "Failed to receive a netlogon reply packet");
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);
570 torture_assert_int_equal(tctx, response->data.samlogon.data.nt5_ex.command, LOGON_SAM_LOGON_RESPONSE, "Got incorrect netlogon response command");
572 torture_assert_str_equal(tctx, response->data.samlogon.data.nt5_ex.user_name, TEST_NAME"$", "Got incorrect user in netlogon response");
575 /* setup (another) temporary mailslot listener for replies */
576 dgmslot = dgram_mailslot_temp(dgmsock, NBT_MAILSLOT_GETDC,
577 netlogon_handler, NULL);
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;
588 make_nbt_name_client(&myname, TEST_NAME);
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,
595 NBT_MAILSLOT_NTLOGON,
597 torture_assert_ntstatus_ok(tctx, status, "Failed to send ntlogon request");
599 while (timeval_elapsed(&tv) < 5 && !dgmslot->private_data) {
600 event_loop_once(dgmsock->event_ctx);
603 response = talloc_get_type(dgmslot->private_data, struct nbt_netlogon_response);
605 torture_assert(tctx, response != NULL, "Failed to receive a netlogon reply packet");
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");
610 torture_leave_domain(tctx, join_ctx);
612 /* setup (another) temporary mailslot listener for replies */
613 dgmslot = dgram_mailslot_temp(dgmsock, NBT_MAILSLOT_GETDC,
614 netlogon_handler, NULL);
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;
625 make_nbt_name_client(&myname, TEST_NAME);
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,
632 NBT_MAILSLOT_NTLOGON,
634 torture_assert_ntstatus_ok(tctx, status, "Failed to send ntlogon request");
636 while (timeval_elapsed(&tv) < 5 && !dgmslot->private_data) {
637 event_loop_once(dgmsock->event_ctx);
640 response = talloc_get_type(dgmslot->private_data, struct nbt_netlogon_response);
642 torture_assert(tctx, response != NULL, "Failed to receive a netlogon reply packet");
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");
653 test nbt dgram operations
655 struct torture_suite *torture_nbt_dgram(TALLOC_CTX *mem_ctx)
657 struct torture_suite *suite = torture_suite_create(mem_ctx, "DGRAM");
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);