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/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"
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 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
;
74 struct timeval tv
= timeval_current();
76 struct socket_address
*socket_address
;
81 struct interface
*ifaces
;
83 name
.name
= lpcfg_workgroup(tctx
->lp_ctx
);
84 name
.type
= NBT_NAME_LOGON
;
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
),
91 &name
, tctx
, &address
, tctx
->ev
),
92 talloc_asprintf(tctx
, "Failed to resolve %s", name
.name
));
94 load_interface_list(tctx
, tctx
->lp_ctx
, &ifaces
);
95 myaddress
= talloc_strdup(dgmsock
, iface_list_best_ip(ifaces
, address
));
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");
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
,
111 torture_assert(tctx
, socket_address
!= NULL
, "Error getting address");
113 socket_listen(dgmsock
->sock
, socket_address
, 0, 0);
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");
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;
130 make_nbt_name_client(&myname
, TEST_NAME
);
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");
136 status
= dgram_mailslot_netlogon_send(dgmsock
, &name
, dest
,
137 NBT_MAILSLOT_NETLOGON
,
139 torture_assert_ntstatus_ok(tctx
, status
, "Failed to send netlogon request");
141 while (timeval_elapsed(&tv
) < 5 && !dgmslot
->private_data
) {
142 tevent_loop_once(dgmsock
->event_ctx
);
145 response
= talloc_get_type(dgmslot
->private_data
, struct nbt_netlogon_response
);
147 torture_assert(tctx
, response
!= NULL
, "Failed to receive a netlogon reply packet");
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");
156 /* test UDP/138 netlogon requests */
157 static bool nbt_test_netlogon2(struct torture_context
*tctx
)
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
;
167 struct timeval tv
= timeval_current();
169 struct socket_address
*socket_address
;
172 struct nbt_name name
;
174 struct interface
*ifaces
;
175 struct test_join
*join_ctx
;
176 struct cli_credentials
*machine_credentials
;
177 const struct dom_sid
*dom_sid
;
179 name
.name
= lpcfg_workgroup(tctx
->lp_ctx
);
180 name
.type
= NBT_NAME_LOGON
;
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
),
187 &name
, tctx
, &address
, tctx
->ev
),
188 talloc_asprintf(tctx
, "Failed to resolve %s", name
.name
));
190 load_interface_list(tctx
, tctx
->lp_ctx
, &ifaces
);
191 myaddress
= talloc_strdup(dgmsock
, iface_list_best_ip(ifaces
, address
));
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");
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
,
206 torture_assert(tctx
, socket_address
!= NULL
, "Error getting address");
208 socket_listen(dgmsock
->sock
, socket_address
, 0, 0);
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");
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;
226 make_nbt_name_client(&myname
, TEST_NAME
);
228 dest
= socket_address_from_strings(dgmsock
, dgmsock
->sock
->backend_name
,
229 address
, lpcfg_dgram_port(tctx
->lp_ctx
));
231 torture_assert(tctx
, dest
!= NULL
, "Error getting address");
232 status
= dgram_mailslot_netlogon_send(dgmsock
, &name
, dest
,
233 NBT_MAILSLOT_NETLOGON
,
235 torture_assert_ntstatus_ok(tctx
, status
, "Failed to send netlogon request");
237 while (timeval_elapsed(&tv
) < 5 && dgmslot
->private_data
== NULL
) {
238 tevent_loop_once(dgmsock
->event_ctx
);
241 response
= talloc_get_type(dgmslot
->private_data
, struct nbt_netlogon_response
);
243 torture_assert(tctx
, response
!= NULL
, "Failed to receive a netlogon reply packet");
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
);
248 torture_assert_int_equal(tctx
, response
->data
.samlogon
.data
.nt5_ex
.command
, LOGON_SAM_LOGON_RESPONSE_EX
, "Got incorrect netlogon response command");
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");
253 strstr(response
->data
.samlogon
.data
.nt5_ex
.pdc_name
, "\\\\") == NULL
,
254 "PDC name should not be in UNC form");
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");
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;
271 make_nbt_name_client(&myname
, TEST_NAME
);
273 dest
= socket_address_from_strings(dgmsock
, dgmsock
->sock
->backend_name
,
274 address
, lpcfg_dgram_port(tctx
->lp_ctx
));
276 torture_assert(tctx
, dest
!= NULL
, "Error getting address");
277 status
= dgram_mailslot_netlogon_send(dgmsock
, &name
, dest
,
278 NBT_MAILSLOT_NETLOGON
,
280 torture_assert_ntstatus_ok(tctx
, status
, "Failed to send netlogon request");
282 while (timeval_elapsed(&tv
) < 5 && dgmslot
->private_data
== NULL
) {
283 tevent_loop_once(dgmsock
->event_ctx
);
286 response
= talloc_get_type(dgmslot
->private_data
, struct nbt_netlogon_response
);
288 torture_assert(tctx
, response
!= NULL
, "Failed to receive a netlogon reply packet");
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
);
293 torture_assert_int_equal(tctx
, response
->data
.samlogon
.data
.nt5_ex
.command
, LOGON_SAM_LOGON_USER_UNKNOWN
, "Got incorrect netlogon response command");
295 torture_assert_str_equal(tctx
, response
->data
.samlogon
.data
.nt5_ex
.user_name
, TEST_NAME
"$", "Got incorrect user in netlogon response");
298 strstr(response
->data
.samlogon
.data
.nt5_ex
.pdc_name
, "\\\\") != NULL
,
299 "PDC name should be in UNC form");
301 join_ctx
= torture_join_domain(tctx
, TEST_NAME
,
302 ACB_WSTRUST
, &machine_credentials
);
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
));
308 dom_sid
= torture_join_sid(join_ctx
);
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");
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;
326 make_nbt_name_client(&myname
, TEST_NAME
);
328 dest
= socket_address_from_strings(dgmsock
, dgmsock
->sock
->backend_name
,
329 address
, lpcfg_dgram_port(tctx
->lp_ctx
));
331 torture_assert(tctx
, dest
!= NULL
, "Error getting address");
332 status
= dgram_mailslot_netlogon_send(dgmsock
, &name
, dest
,
333 NBT_MAILSLOT_NETLOGON
,
335 torture_assert_ntstatus_ok(tctx
, status
, "Failed to send netlogon request");
338 while (timeval_elapsed(&tv
) < 5 && dgmslot
->private_data
== NULL
) {
339 tevent_loop_once(dgmsock
->event_ctx
);
342 response
= talloc_get_type(dgmslot
->private_data
, struct nbt_netlogon_response
);
344 torture_assert(tctx
, response
!= NULL
, "Failed to receive a netlogon reply packet");
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
);
349 torture_assert_int_equal(tctx
, response
->data
.samlogon
.data
.nt5_ex
.command
, LOGON_SAM_LOGON_USER_UNKNOWN
, "Got incorrect netlogon response command");
352 strstr(response
->data
.samlogon
.data
.nt5_ex
.pdc_name
, "\\\\") != NULL
,
353 "PDC name should be in UNC form");
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");
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;
372 make_nbt_name_client(&myname
, TEST_NAME
);
374 dest
= socket_address_from_strings(dgmsock
, dgmsock
->sock
->backend_name
,
375 address
, lpcfg_dgram_port(tctx
->lp_ctx
));
377 torture_assert(tctx
, dest
!= NULL
, "Error getting address");
378 status
= dgram_mailslot_netlogon_send(dgmsock
, &name
, dest
,
379 NBT_MAILSLOT_NETLOGON
,
381 torture_assert_ntstatus_ok(tctx
, status
, "Failed to send netlogon request");
384 while (timeval_elapsed(&tv
) < 5 && dgmslot
->private_data
== NULL
) {
385 tevent_loop_once(dgmsock
->event_ctx
);
388 response
= talloc_get_type(dgmslot
->private_data
, struct nbt_netlogon_response
);
390 torture_assert(tctx
, response
!= NULL
, "Failed to receive a netlogon reply packet");
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
);
395 torture_assert_int_equal(tctx
, response
->data
.samlogon
.data
.nt5_ex
.command
, LOGON_SAM_LOGON_RESPONSE
, "Got incorrect netlogon response command");
398 strstr(response
->data
.samlogon
.data
.nt5_ex
.pdc_name
, "\\\\") != NULL
,
399 "PDC name should be in UNC form");
401 dgmslot
->private_data
= NULL
;
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;
415 make_nbt_name_client(&myname
, TEST_NAME
);
417 dest
= socket_address_from_strings(dgmsock
, dgmsock
->sock
->backend_name
,
418 address
, lpcfg_dgram_port(tctx
->lp_ctx
));
420 torture_assert(tctx
, dest
!= NULL
, "Error getting address");
421 status
= dgram_mailslot_netlogon_send(dgmsock
, &name
, dest
,
422 NBT_MAILSLOT_NETLOGON
,
424 torture_assert_ntstatus_ok(tctx
, status
, "Failed to send netlogon request");
427 while (timeval_elapsed(&tv
) < 5 && dgmslot
->private_data
== NULL
) {
428 tevent_loop_once(dgmsock
->event_ctx
);
431 response
= talloc_get_type(dgmslot
->private_data
, struct nbt_netlogon_response
);
433 torture_assert(tctx
, response
!= NULL
, "Failed to receive a netlogon reply packet");
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
);
438 torture_assert_int_equal(tctx
, response
->data
.samlogon
.data
.nt5_ex
.command
, LOGON_SAM_LOGON_USER_UNKNOWN
, "Got incorrect netlogon response command");
441 strstr(response
->data
.samlogon
.data
.nt5_ex
.pdc_name
, "\\\\") != NULL
,
442 "PDC name should be in UNC form");
444 torture_leave_domain(tctx
, join_ctx
);
449 /* test UDP/138 ntlogon requests */
450 static bool nbt_test_ntlogon(struct torture_context
*tctx
)
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
;
459 const char *myaddress
;
460 struct nbt_netlogon_packet logon
;
461 struct nbt_netlogon_response
*response
;
462 struct nbt_name myname
;
464 struct timeval tv
= timeval_current();
466 struct socket_address
*socket_address
;
468 struct nbt_name name
;
470 struct interface
*ifaces
;
472 name
.name
= lpcfg_workgroup(tctx
->lp_ctx
);
473 name
.type
= NBT_NAME_LOGON
;
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
));
482 load_interface_list(tctx
, tctx
->lp_ctx
, &ifaces
);
483 myaddress
= talloc_strdup(dgmsock
, iface_list_best_ip(ifaces
, address
));
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");
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
,
498 torture_assert(tctx
, socket_address
!= NULL
, "Error getting address");
500 socket_listen(dgmsock
->sock
, socket_address
, 0, 0);
503 join_ctx
= torture_join_domain(tctx
, TEST_NAME
,
504 ACB_WSTRUST
, &machine_credentials
);
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
);
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");
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;
529 make_nbt_name_client(&myname
, TEST_NAME
);
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
,
536 NBT_MAILSLOT_NTLOGON
,
538 torture_assert_ntstatus_ok(tctx
, status
, "Failed to send ntlogon request");
540 while (timeval_elapsed(&tv
) < 5 && dgmslot
->private_data
== NULL
) {
541 tevent_loop_once(dgmsock
->event_ctx
);
544 response
= talloc_get_type(dgmslot
->private_data
, struct nbt_netlogon_response
);
546 torture_assert(tctx
, response
!= NULL
, "Failed to receive a netlogon reply packet");
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
);
551 torture_assert_int_equal(tctx
, response
->data
.samlogon
.data
.nt5_ex
.command
, LOGON_SAM_LOGON_RESPONSE
, "Got incorrect netlogon response command");
553 torture_assert_str_equal(tctx
, response
->data
.samlogon
.data
.nt5_ex
.user_name
, TEST_NAME
"$", "Got incorrect user in netlogon response");
556 strstr(response
->data
.samlogon
.data
.nt5_ex
.pdc_name
, "\\\\") != NULL
,
557 "PDC name should be in UNC form");
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");
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;
576 make_nbt_name_client(&myname
, TEST_NAME
);
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
,
583 NBT_MAILSLOT_NTLOGON
,
585 torture_assert_ntstatus_ok(tctx
, status
, "Failed to send ntlogon request");
587 while (timeval_elapsed(&tv
) < 5 && dgmslot
->private_data
== NULL
) {
588 tevent_loop_once(dgmsock
->event_ctx
);
591 response
= talloc_get_type(dgmslot
->private_data
, struct nbt_netlogon_response
);
593 torture_assert(tctx
, response
!= NULL
, "Failed to receive a netlogon reply packet");
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
);
598 torture_assert_int_equal(tctx
, response
->data
.samlogon
.data
.nt5_ex
.command
, LOGON_SAM_LOGON_RESPONSE
, "Got incorrect netlogon response command");
600 torture_assert_str_equal(tctx
, response
->data
.samlogon
.data
.nt5_ex
.user_name
, TEST_NAME
"$", "Got incorrect user in netlogon response");
603 strstr(response
->data
.samlogon
.data
.nt5_ex
.pdc_name
, "\\\\") != NULL
,
604 "PDC name should be in UNC form");
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");
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;
620 make_nbt_name_client(&myname
, TEST_NAME
);
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
,
627 NBT_MAILSLOT_NTLOGON
,
629 torture_assert_ntstatus_ok(tctx
, status
, "Failed to send ntlogon request");
631 while (timeval_elapsed(&tv
) < 5 && !dgmslot
->private_data
) {
632 tevent_loop_once(dgmsock
->event_ctx
);
635 response
= talloc_get_type(dgmslot
->private_data
, struct nbt_netlogon_response
);
637 torture_assert(tctx
, response
!= NULL
, "Failed to receive a netlogon reply packet");
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");
642 torture_leave_domain(tctx
, join_ctx
);
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");
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;
658 make_nbt_name_client(&myname
, TEST_NAME
);
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
,
665 NBT_MAILSLOT_NTLOGON
,
667 torture_assert_ntstatus_ok(tctx
, status
, "Failed to send ntlogon request");
669 while (timeval_elapsed(&tv
) < 5 && !dgmslot
->private_data
) {
670 tevent_loop_once(dgmsock
->event_ctx
);
673 response
= talloc_get_type(dgmslot
->private_data
, struct nbt_netlogon_response
);
675 torture_assert(tctx
, response
!= NULL
, "Failed to receive a netlogon reply packet");
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");
686 test nbt dgram operations
688 struct torture_suite
*torture_nbt_dgram(TALLOC_CTX
*mem_ctx
)
690 struct torture_suite
*suite
= torture_suite_create(mem_ctx
, "dgram");
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
);