5726e684715f2a723207b08e88e94d05b01e34ca
[samba.git] / source / 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 2 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, write to the Free Software
20    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21 */
22
23 #include "includes.h"
24 #include "libcli/nbt/libnbt.h"
25 #include "libcli/dgram/libdgram.h"
26 #include "librpc/gen_ndr/ndr_nbt.h"
27 #include "librpc/gen_ndr/ndr_samr.h"
28 #include "lib/socket/socket.h"
29 #include "lib/events/events.h"
30
31 #define TEST_NAME "TORTURE_TEST"
32
33 /*
34   reply handler for netlogon request
35 */
36 static void netlogon_handler(struct dgram_mailslot_handler *dgmslot, 
37                              struct nbt_dgram_packet *packet, 
38                              const char *src_address, int src_port)
39 {
40         NTSTATUS status;
41         struct nbt_netlogon_packet netlogon;
42         int *replies = dgmslot->private;
43
44         printf("netlogon reply from %s:%d\n", src_address, src_port);
45
46         status = dgram_mailslot_netlogon_parse(dgmslot, dgmslot, packet, &netlogon);
47         if (!NT_STATUS_IS_OK(status)) {
48                 printf("Failed to parse netlogon packet from %s:%d\n",
49                        src_address, src_port);
50                 return;
51         }
52
53         NDR_PRINT_DEBUG(nbt_netlogon_packet, &netlogon);
54
55         (*replies)++;
56 }
57
58
59 /* test UDP/138 netlogon requests */
60 static BOOL nbt_test_netlogon(TALLOC_CTX *mem_ctx, 
61                               struct nbt_name name, const char *address)
62 {
63         struct dgram_mailslot_handler *dgmslot;
64         struct nbt_dgram_socket *dgmsock = nbt_dgram_socket_init(mem_ctx, NULL);
65         const char *myaddress = talloc_strdup(dgmsock, iface_best_ip(address));
66         struct nbt_netlogon_packet logon;
67         struct nbt_name myname;
68         NTSTATUS status;
69         struct timeval tv = timeval_current();
70         int replies = 0;
71
72         /* try receiving replies on port 138 first, which will only
73            work if we are root and smbd/nmbd are not running - fall
74            back to listening on any port, which means replies from
75            some windows versions won't be seen */
76         status = socket_listen(dgmsock->sock, myaddress, lp_dgram_port(), 0, 0);
77         if (!NT_STATUS_IS_OK(status)) {
78                 socket_listen(dgmsock->sock, myaddress, 0, 0, 0);
79         }
80
81         /* setup a temporary mailslot listener for replies */
82         dgmslot = dgram_mailslot_temp(dgmsock, NBT_MAILSLOT_GETDC,
83                                       netlogon_handler, &replies);
84         
85
86         ZERO_STRUCT(logon);
87         logon.command = NETLOGON_QUERY_FOR_PDC;
88         logon.req.pdc.computer_name = TEST_NAME;
89         logon.req.pdc.mailslot_name = dgmslot->mailslot_name;
90         logon.req.pdc.unicode_name  = TEST_NAME;
91         logon.req.pdc.nt_version    = 1;
92         logon.req.pdc.lmnt_token    = 0xFFFF;
93         logon.req.pdc.lm20_token    = 0xFFFF;
94
95         myname.name = TEST_NAME;
96         myname.type = NBT_NAME_CLIENT;
97         myname.scope = NULL;
98
99         status = dgram_mailslot_netlogon_send(dgmsock, &name, address, 
100                                               0, &myname, &logon);
101         if (!NT_STATUS_IS_OK(status)) {
102                 printf("Failed to send netlogon request - %s\n", nt_errstr(status));
103                 goto failed;
104         }
105
106
107         while (timeval_elapsed(&tv) < 5 && replies == 0) {
108                 event_loop_once(dgmsock->event_ctx);
109         }
110
111         talloc_free(dgmsock);
112         return True;
113
114 failed:
115         talloc_free(dgmsock);
116         return False;
117 }
118
119
120 /* test UDP/138 netlogon requests */
121 static BOOL nbt_test_netlogon2(TALLOC_CTX *mem_ctx, 
122                               struct nbt_name name, const char *address)
123 {
124         struct dgram_mailslot_handler *dgmslot;
125         struct nbt_dgram_socket *dgmsock = nbt_dgram_socket_init(mem_ctx, NULL);
126         const char *myaddress = talloc_strdup(dgmsock, iface_best_ip(address));
127         struct nbt_netlogon_packet logon;
128         struct nbt_name myname;
129         NTSTATUS status;
130         struct timeval tv = timeval_current();
131         int replies = 0;
132
133         /* try receiving replies on port 138 first, which will only
134            work if we are root and smbd/nmbd are not running - fall
135            back to listening on any port, which means replies from
136            some windows versions won't be seen */
137         status = socket_listen(dgmsock->sock, myaddress, lp_dgram_port(), 0, 0);
138         if (!NT_STATUS_IS_OK(status)) {
139                 socket_listen(dgmsock->sock, myaddress, 0, 0, 0);
140         }
141
142         /* setup a temporary mailslot listener for replies */
143         dgmslot = dgram_mailslot_temp(dgmsock, NBT_MAILSLOT_GETDC,
144                                       netlogon_handler, &replies);
145         
146
147         ZERO_STRUCT(logon);
148         logon.command = NETLOGON_QUERY_FOR_PDC2;
149         logon.req.pdc2.request_count = 0;
150         logon.req.pdc2.computer_name = TEST_NAME;
151         logon.req.pdc2.user_name     = "";
152         logon.req.pdc2.mailslot_name = dgmslot->mailslot_name;
153         logon.req.pdc2.nt_version    = 11;
154         logon.req.pdc2.lmnt_token    = 0xFFFF;
155         logon.req.pdc2.lm20_token    = 0xFFFF;
156
157         myname.name = TEST_NAME;
158         myname.type = NBT_NAME_CLIENT;
159         myname.scope = NULL;
160
161         status = dgram_mailslot_netlogon_send(dgmsock, &name, address, 
162                                               0, &myname, &logon);
163         if (!NT_STATUS_IS_OK(status)) {
164                 printf("Failed to send netlogon request - %s\n", nt_errstr(status));
165                 goto failed;
166         }
167
168
169         while (timeval_elapsed(&tv) < 5 && replies == 0) {
170                 event_loop_once(dgmsock->event_ctx);
171         }
172
173         talloc_free(dgmsock);
174         return True;
175
176 failed:
177         talloc_free(dgmsock);
178         return False;
179 }
180
181
182 /*
183   reply handler for ntlogon request
184 */
185 static void ntlogon_handler(struct dgram_mailslot_handler *dgmslot, 
186                              struct nbt_dgram_packet *packet, 
187                              const char *src_address, int src_port)
188 {
189         NTSTATUS status;
190         struct nbt_ntlogon_packet ntlogon;
191         int *replies = dgmslot->private;
192
193         printf("ntlogon reply from %s:%d\n", src_address, src_port);
194
195         status = dgram_mailslot_ntlogon_parse(dgmslot, dgmslot, packet, &ntlogon);
196         if (!NT_STATUS_IS_OK(status)) {
197                 printf("Failed to parse ntlogon packet from %s:%d\n",
198                        src_address, src_port);
199                 return;
200         }
201
202         NDR_PRINT_DEBUG(nbt_ntlogon_packet, &ntlogon);
203
204         (*replies)++;
205 }
206
207
208 /* test UDP/138 ntlogon requests */
209 static BOOL nbt_test_ntlogon(TALLOC_CTX *mem_ctx, 
210                              struct nbt_name name, const char *address)
211 {
212         struct dgram_mailslot_handler *dgmslot;
213         struct nbt_dgram_socket *dgmsock = nbt_dgram_socket_init(mem_ctx, NULL);
214         const char *myaddress = talloc_strdup(dgmsock, iface_best_ip(address));
215         struct nbt_ntlogon_packet logon;
216         struct nbt_name myname;
217         NTSTATUS status;
218         struct timeval tv = timeval_current();
219         int replies = 0;
220         struct test_join *join_ctx;
221         const char *password;
222         const char *dom_sid;
223
224         join_ctx = torture_join_domain(TEST_NAME, lp_workgroup(), 
225                                        ACB_WSTRUST, &password);
226         if (join_ctx == NULL) {
227                 printf("Failed to join domain %s as %s\n", lp_workgroup(), TEST_NAME);
228                 talloc_free(dgmsock);
229                 return False;
230         }
231
232         dom_sid = torture_join_sid(join_ctx);
233
234         /* try receiving replies on port 138 first, which will only
235            work if we are root and smbd/nmbd are not running - fall
236            back to listening on any port, which means replies from
237            some windows versions won't be seen */
238         status = socket_listen(dgmsock->sock, myaddress, lp_dgram_port(), 0, 0);
239         if (!NT_STATUS_IS_OK(status)) {
240                 socket_listen(dgmsock->sock, myaddress, 0, 0, 0);
241         }
242
243         /* setup a temporary mailslot listener for replies */
244         dgmslot = dgram_mailslot_temp(dgmsock, NBT_MAILSLOT_GETDC,
245                                       ntlogon_handler, &replies);
246         
247
248         ZERO_STRUCT(logon);
249         logon.command = NTLOGON_SAM_LOGON;
250         logon.req.logon.request_count = 0;
251         logon.req.logon.computer_name = TEST_NAME;
252         logon.req.logon.user_name     = TEST_NAME"$";
253         logon.req.logon.mailslot_name = dgmslot->mailslot_name;
254         logon.req.logon.acct_control  = ACB_WSTRUST;
255         logon.req.logon.sid           = *dom_sid_parse_talloc(dgmslot, dom_sid);
256         logon.req.logon.nt_version    = 1;
257         logon.req.logon.lmnt_token    = 0xFFFF;
258         logon.req.logon.lm20_token    = 0xFFFF;
259
260
261         myname.name = TEST_NAME;
262         myname.type = NBT_NAME_CLIENT;
263         myname.scope = NULL;
264
265         status = dgram_mailslot_ntlogon_send(dgmsock, &name, address, 
266                                               0, &myname, &logon);
267         if (!NT_STATUS_IS_OK(status)) {
268                 printf("Failed to send ntlogon request - %s\n", nt_errstr(status));
269                 goto failed;
270         }
271
272
273         while (timeval_elapsed(&tv) < 5 && replies == 0) {
274                 event_loop_once(dgmsock->event_ctx);
275         }
276
277         torture_leave_domain(join_ctx);
278         talloc_free(dgmsock);
279         return True;
280
281 failed:
282         torture_leave_domain(join_ctx);
283         talloc_free(dgmsock);
284         return False;
285 }
286
287
288 /*
289   test nbt dgram operations
290 */
291 BOOL torture_nbt_dgram(void)
292 {
293         const char *address;
294         struct nbt_name name;
295         TALLOC_CTX *mem_ctx = talloc_new(NULL);
296         NTSTATUS status;
297         BOOL ret = True;
298         
299         name.name = lp_workgroup();
300         name.type = NBT_NAME_LOGON;
301         name.scope = NULL;
302
303         /* do an initial name resolution to find its IP */
304         status = resolve_name(&name, mem_ctx, &address);
305         if (!NT_STATUS_IS_OK(status)) {
306                 printf("Failed to resolve %s - %s\n",
307                        name.name, nt_errstr(status));
308                 talloc_free(mem_ctx);
309                 return False;
310         }
311
312         ret &= nbt_test_netlogon(mem_ctx, name, address);
313         ret &= nbt_test_netlogon2(mem_ctx, name, address);
314         ret &= nbt_test_ntlogon(mem_ctx, name, address);
315
316         talloc_free(mem_ctx);
317
318         return ret;
319 }