2 Unix SMB/CIFS implementation.
4 Copyright (C) Andrew Tridgell 1994-1998
5 Copyright (C) Richard Sharpe 2001
6 Copyright (C) John Terpstra 2001
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 "librpc/gen_ndr/messaging.h"
24 #include "libsmb/clidgram.h"
25 #include "libsmb/nmblib.h"
29 * cli_send_mailslot, send a mailslot for client code ...
32 static bool cli_prep_mailslot(bool unique, const char *mailslot,
35 const char *srcname, int src_type,
36 const char *dstname, int dest_type,
37 const struct sockaddr_storage *dest_ss,
39 struct packet_struct *p)
41 struct dgram_packet *dgram = &p->packet.dgram;
44 char addr[INET6_ADDRSTRLEN];
49 * Next, build the DGRAM ...
52 /* DIRECT GROUP or UNIQUE datagram. */
53 dgram->header.msg_type = unique ? 0x10 : 0x11;
54 dgram->header.flags.node_type = M_NODE;
55 dgram->header.flags.first = True;
56 dgram->header.flags.more = False;
57 dgram->header.dgm_id = dgm_id;
58 /* source ip is filled by nmbd */
59 dgram->header.dgm_length = 0; /* Let build_dgram() handle this. */
60 dgram->header.packet_offset = 0;
62 make_nmb_name(&dgram->source_name,srcname,src_type);
63 make_nmb_name(&dgram->dest_name,dstname,dest_type);
65 ptr = &dgram->data[0];
67 /* Setup the smb part. */
68 ptr -= 4; /* XXX Ugliness because of handling of tcp SMB length. */
71 if (smb_size + 17*2 + strlen(mailslot) + 1 + len > MAX_DGRAM_SIZE) {
72 DEBUG(0, ("cli_send_mailslot: Cannot write beyond end of packet\n"));
76 cli_set_message(ptr,17,strlen(mailslot) + 1 + len,True);
79 SCVAL(ptr,smb_com,SMBtrans);
80 SSVAL(ptr,smb_vwv1,len);
81 SSVAL(ptr,smb_vwv11,len);
82 SSVAL(ptr,smb_vwv12,70 + strlen(mailslot));
83 SSVAL(ptr,smb_vwv13,3);
84 SSVAL(ptr,smb_vwv14,1);
85 SSVAL(ptr,smb_vwv15,priority);
86 SSVAL(ptr,smb_vwv16,2);
89 p2 = skip_string(ptr,MAX_DGRAM_SIZE,p2);
97 dgram->datasize = PTR_DIFF(p2,ptr+4); /* +4 for tcp length. */
99 p->packet_type = DGRAM_PACKET;
100 p->ip = ((const struct sockaddr_in *)dest_ss)->sin_addr;
101 p->timestamp = time(NULL);
103 DEBUG(4,("send_mailslot: Sending to mailslot %s from %s ",
104 mailslot, nmb_namestr(&dgram->source_name)));
105 print_sockaddr(addr, sizeof(addr), dest_ss);
107 DEBUGADD(4,("to %s IP %s\n", nmb_namestr(&dgram->dest_name), addr));
112 static char *mailslot_name(TALLOC_CTX *mem_ctx, struct in_addr dc_ip)
114 return talloc_asprintf(mem_ctx, "%s%X",
115 NBT_MAILSLOT_GETDC, dc_ip.s_addr);
118 static bool prep_getdc_request(const struct sockaddr_storage *dc_ss,
119 const char *domain_name,
120 const struct dom_sid *sid,
122 const char *my_mailslot,
124 struct packet_struct *p)
126 TALLOC_CTX *frame = talloc_stackframe();
127 const char *my_acct_name;
128 struct nbt_netlogon_packet packet;
129 struct NETLOGON_SAM_LOGON_REQUEST *s;
130 enum ndr_err_code ndr_err;
131 DATA_BLOB blob = data_blob_null;
132 struct dom_sid my_sid;
142 my_acct_name = talloc_asprintf(talloc_tos(), "%s$", global_myname());
143 if (my_acct_name == NULL) {
147 packet.command = LOGON_SAM_LOGON_REQUEST;
148 s = &packet.req.logon;
150 s->request_count = 0;
151 s->computer_name = global_myname();
152 s->user_name = my_acct_name;
153 s->mailslot_name = my_mailslot;
154 s->acct_control = ACB_WSTRUST;
156 s->nt_version = nt_version;
157 s->lmnt_token = 0xffff;
158 s->lm20_token = 0xffff;
160 if (DEBUGLEVEL >= 10) {
161 NDR_PRINT_DEBUG(nbt_netlogon_packet, &packet);
164 ndr_err = ndr_push_struct_blob(&blob, talloc_tos(), &packet,
165 (ndr_push_flags_fn_t)ndr_push_nbt_netlogon_packet);
166 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
170 ret = cli_prep_mailslot(false, NBT_MAILSLOT_NTLOGON, 0,
171 (char *)blob.data, blob.length,
172 global_myname(), 0, domain_name, 0x1c,
179 static bool parse_getdc_response(
180 struct packet_struct *packet,
182 const char *domain_name,
183 uint32_t *nt_version,
184 const char **dc_name,
185 struct netlogon_samlogon_response **samlogon_response)
188 struct netlogon_samlogon_response *r;
189 union dgram_message_body p;
190 enum ndr_err_code ndr_err;
193 const char *returned_dc = NULL;
194 const char *returned_domain = NULL;
196 blob = data_blob_const(packet->packet.dgram.data,
197 packet->packet.dgram.datasize);
198 if (blob.length < 4) {
199 DEBUG(1, ("invalid length: %d\n", (int)blob.length));
203 if (RIVAL(blob.data,0) != DGRAM_SMB) {
204 DEBUG(1, ("invalid packet\n"));
211 ndr_err = ndr_pull_union_blob_all(&blob, mem_ctx, &p, DGRAM_SMB,
212 (ndr_pull_flags_fn_t)ndr_pull_dgram_smb_packet);
213 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
214 DEBUG(1, ("failed to parse packet\n"));
218 if (p.smb.smb_command != SMB_TRANSACTION) {
219 DEBUG(1, ("invalid smb_command: %d\n", p.smb.smb_command));
223 if (DEBUGLEVEL >= 10) {
224 NDR_PRINT_DEBUG(dgram_smb_packet, &p);
227 blob = p.smb.body.trans.data;
229 r = TALLOC_ZERO_P(mem_ctx, struct netlogon_samlogon_response);
234 status = pull_netlogon_samlogon_response(&blob, r, r);
235 if (!NT_STATUS_IS_OK(status)) {
240 map_netlogon_samlogon_response(r);
242 /* do we still need this ? */
243 *nt_version = r->ntver;
245 returned_domain = r->data.nt5_ex.domain_name;
246 returned_dc = r->data.nt5_ex.pdc_name;
248 if (!strequal(returned_domain, domain_name)) {
249 DEBUG(3, ("GetDC: Expected domain %s, got %s\n",
250 domain_name, returned_domain));
255 if (*returned_dc == '\\') returned_dc += 1;
256 if (*returned_dc == '\\') returned_dc += 1;
258 *dc_name = talloc_strdup(mem_ctx, returned_dc);
264 if (samlogon_response) {
265 *samlogon_response = r;
270 DEBUG(10, ("GetDC gave name %s for domain %s\n",
271 *dc_name, returned_domain));
276 struct nbt_getdc_state {
277 struct tevent_context *ev;
278 struct messaging_context *msg_ctx;
279 struct nb_packet_reader *reader;
280 const char *my_mailslot;
283 const struct sockaddr_storage *dc_addr;
284 const char *domain_name;
285 const struct dom_sid *sid;
288 struct netlogon_samlogon_response *samlogon_response;
290 struct packet_struct p;
293 static void nbt_getdc_got_reader(struct tevent_req *subreq);
294 static void nbt_getdc_got_response(struct tevent_req *subreq);
296 struct tevent_req *nbt_getdc_send(TALLOC_CTX *mem_ctx,
297 struct tevent_context *ev,
298 struct messaging_context *msg_ctx,
299 const struct sockaddr_storage *dc_addr,
300 const char *domain_name,
301 const struct dom_sid *sid,
304 struct tevent_req *req, *subreq;
305 struct nbt_getdc_state *state;
308 req = tevent_req_create(mem_ctx, &state, struct nbt_getdc_state);
313 state->msg_ctx = msg_ctx;
314 state->dc_addr = dc_addr;
315 state->domain_name = domain_name;
317 state->nt_version = nt_version;
319 if (dc_addr->ss_family != AF_INET) {
320 tevent_req_nterror(req, NT_STATUS_NOT_SUPPORTED);
321 return tevent_req_post(req, ev);
323 state->my_mailslot = mailslot_name(
324 state, ((struct sockaddr_in *)dc_addr)->sin_addr);
325 if (tevent_req_nomem(state->my_mailslot, req)) {
326 return tevent_req_post(req, ev);
328 state->nmbd_pid = pidfile_pid("nmbd");
329 if (state->nmbd_pid == 0) {
330 DEBUG(3, ("No nmbd found\n"));
331 tevent_req_nterror(req, NT_STATUS_NOT_SUPPORTED);
332 return tevent_req_post(req, ev);
335 generate_random_buffer((uint8_t *)(void *)&dgm_id, sizeof(dgm_id));
337 if (!prep_getdc_request(dc_addr, domain_name, sid, nt_version,
338 state->my_mailslot, dgm_id & 0x7fff,
340 DEBUG(3, ("prep_getdc_request failed\n"));
341 tevent_req_nterror(req, NT_STATUS_INVALID_PARAMETER);
342 return tevent_req_post(req, ev);
345 subreq = nb_packet_reader_send(state, ev, DGRAM_PACKET, -1,
347 if (tevent_req_nomem(subreq, req)) {
348 return tevent_req_post(req, ev);
350 tevent_req_set_callback(subreq, nbt_getdc_got_reader, req);
354 static void nbt_getdc_got_reader(struct tevent_req *subreq)
356 struct tevent_req *req = tevent_req_callback_data(
357 subreq, struct tevent_req);
358 struct nbt_getdc_state *state = tevent_req_data(
359 req, struct nbt_getdc_state);
362 status = nb_packet_reader_recv(subreq, state, &state->reader);
364 if (tevent_req_nterror(req, status)) {
365 DEBUG(10, ("nb_packet_reader_recv returned %s\n",
370 status = messaging_send_buf(
371 state->msg_ctx, pid_to_procid(state->nmbd_pid),
372 MSG_SEND_PACKET, (uint8_t *)&state->p, sizeof(state->p));
374 if (tevent_req_nterror(req, status)) {
375 DEBUG(10, ("messaging_send_buf returned %s\n",
379 subreq = nb_packet_read_send(state, state->ev, state->reader);
380 if (tevent_req_nomem(subreq, req)) {
383 tevent_req_set_callback(subreq, nbt_getdc_got_response, req);
386 static void nbt_getdc_got_response(struct tevent_req *subreq)
388 struct tevent_req *req = tevent_req_callback_data(
389 subreq, struct tevent_req);
390 struct nbt_getdc_state *state = tevent_req_data(
391 req, struct nbt_getdc_state);
392 struct packet_struct *p;
396 status = nb_packet_read_recv(subreq, &p);
398 if (tevent_req_nterror(req, status)) {
402 ret = parse_getdc_response(p, state, state->domain_name,
403 &state->nt_version, &state->dc_name,
404 &state->samlogon_response);
407 tevent_req_nterror(req, NT_STATUS_INVALID_NETWORK_RESPONSE);
410 tevent_req_done(req);
413 NTSTATUS nbt_getdc_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx,
414 uint32_t *nt_version, const char **dc_name,
415 struct netlogon_samlogon_response **samlogon_response)
417 struct nbt_getdc_state *state = tevent_req_data(
418 req, struct nbt_getdc_state);
421 if (tevent_req_is_nterror(req, &status)) {
424 if (nt_version != NULL) {
425 *nt_version = state->nt_version;
427 if (dc_name != NULL) {
428 *dc_name = talloc_move(mem_ctx, &state->dc_name);
430 if (samlogon_response != NULL) {
431 *samlogon_response = talloc_move(
432 mem_ctx, &state->samlogon_response);
437 NTSTATUS nbt_getdc(struct messaging_context *msg_ctx,
438 const struct sockaddr_storage *dc_addr,
439 const char *domain_name,
440 const struct dom_sid *sid,
443 uint32_t *pnt_version,
444 const char **dc_name,
445 struct netlogon_samlogon_response **samlogon_response)
447 TALLOC_CTX *frame = talloc_stackframe();
448 struct tevent_context *ev;
449 struct tevent_req *req;
450 NTSTATUS status = NT_STATUS_NO_MEMORY;
452 ev = tevent_context_init(frame);
456 req = nbt_getdc_send(ev, ev, msg_ctx, dc_addr, domain_name,
461 if (!tevent_req_poll_ntstatus(req, ev, &status)) {
464 status = nbt_getdc_recv(req, mem_ctx, pnt_version, dc_name,