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 "libsmb/libsmb.h"
24 #include "../lib/util/tevent_ntstatus.h"
25 #include "libsmb/clidgram.h"
26 #include "libsmb/nmblib.h"
27 #include "libsmb/unexpected.h"
29 #include "librpc/gen_ndr/samr.h"
30 #include "../lib/util/pidfile.h"
33 * cli_send_mailslot, send a mailslot for client code ...
36 static bool cli_prep_mailslot(bool unique
, const char *mailslot
,
39 const char *srcname
, int src_type
,
40 const char *dstname
, int dest_type
,
41 const struct sockaddr_storage
*dest_ss
,
43 struct packet_struct
*p
)
45 struct dgram_packet
*dgram
= &p
->packet
.dgram
;
48 char addr
[INET6_ADDRSTRLEN
];
53 * Next, build the DGRAM ...
56 /* DIRECT GROUP or UNIQUE datagram. */
57 dgram
->header
.msg_type
= unique
? 0x10 : 0x11;
58 dgram
->header
.flags
.node_type
= M_NODE
;
59 dgram
->header
.flags
.first
= True
;
60 dgram
->header
.flags
.more
= False
;
61 dgram
->header
.dgm_id
= dgm_id
;
62 /* source ip is filled by nmbd */
63 dgram
->header
.dgm_length
= 0; /* Let build_dgram() handle this. */
64 dgram
->header
.packet_offset
= 0;
66 make_nmb_name(&dgram
->source_name
,srcname
,src_type
);
67 make_nmb_name(&dgram
->dest_name
,dstname
,dest_type
);
69 ptr
= &dgram
->data
[0];
71 /* Setup the smb part. */
72 ptr
-= 4; /* XXX Ugliness because of handling of tcp SMB length. */
75 if (smb_size
+ 17*2 + strlen(mailslot
) + 1 + len
> MAX_DGRAM_SIZE
) {
76 DEBUG(0, ("cli_send_mailslot: Cannot write beyond end of packet\n"));
80 cli_set_message(ptr
,17,strlen(mailslot
) + 1 + len
,True
);
83 SCVAL(ptr
,smb_com
,SMBtrans
);
84 SSVAL(ptr
,smb_vwv1
,len
);
85 SSVAL(ptr
,smb_vwv11
,len
);
86 SSVAL(ptr
,smb_vwv12
,70 + strlen(mailslot
));
87 SSVAL(ptr
,smb_vwv13
,3);
88 SSVAL(ptr
,smb_vwv14
,1);
89 SSVAL(ptr
,smb_vwv15
,priority
);
90 SSVAL(ptr
,smb_vwv16
,2);
93 p2
= skip_string(ptr
,MAX_DGRAM_SIZE
,p2
);
101 dgram
->datasize
= PTR_DIFF(p2
,ptr
+4); /* +4 for tcp length. */
103 p
->packet_type
= DGRAM_PACKET
;
104 p
->ip
= ((const struct sockaddr_in
*)dest_ss
)->sin_addr
;
105 p
->timestamp
= time(NULL
);
107 DEBUG(4,("send_mailslot: Sending to mailslot %s from %s ",
108 mailslot
, nmb_namestr(&dgram
->source_name
)));
109 print_sockaddr(addr
, sizeof(addr
), dest_ss
);
111 DEBUGADD(4,("to %s IP %s\n", nmb_namestr(&dgram
->dest_name
), addr
));
116 static char *mailslot_name(TALLOC_CTX
*mem_ctx
, struct in_addr dc_ip
)
118 return talloc_asprintf(mem_ctx
, "%s%X",
119 NBT_MAILSLOT_GETDC
, dc_ip
.s_addr
);
122 static bool prep_getdc_request(const struct sockaddr_storage
*dc_ss
,
123 const char *account_name
,
124 uint32_t account_flags
,
125 const char *domain_name
,
126 const struct dom_sid
*sid
,
128 const char *my_mailslot
,
130 struct packet_struct
*p
)
132 TALLOC_CTX
*frame
= talloc_stackframe();
133 struct nbt_netlogon_packet packet
;
134 struct NETLOGON_SAM_LOGON_REQUEST
*s
;
135 enum ndr_err_code ndr_err
;
136 DATA_BLOB blob
= data_blob_null
;
137 struct dom_sid my_sid
;
147 packet
.command
= LOGON_SAM_LOGON_REQUEST
;
148 s
= &packet
.req
.logon
;
150 s
->request_count
= 0;
151 s
->computer_name
= lp_netbios_name();
152 s
->user_name
= account_name
;
153 s
->mailslot_name
= my_mailslot
;
154 s
->acct_control
= account_flags
;
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 lp_netbios_name(), 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(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
,
302 const char *account_name
,
303 uint32_t account_flags
,
306 struct tevent_req
*req
, *subreq
;
307 struct nbt_getdc_state
*state
;
311 req
= tevent_req_create(mem_ctx
, &state
, struct nbt_getdc_state
);
316 state
->msg_ctx
= msg_ctx
;
317 state
->dc_addr
= dc_addr
;
318 state
->domain_name
= domain_name
;
320 state
->nt_version
= nt_version
;
322 if (dc_addr
->ss_family
!= AF_INET
) {
323 tevent_req_nterror(req
, NT_STATUS_NOT_SUPPORTED
);
324 return tevent_req_post(req
, ev
);
326 state
->my_mailslot
= mailslot_name(
327 state
, ((const struct sockaddr_in
*)dc_addr
)->sin_addr
);
328 if (tevent_req_nomem(state
->my_mailslot
, req
)) {
329 return tevent_req_post(req
, ev
);
331 state
->nmbd_pid
= pidfile_pid(lp_pid_directory(), "nmbd");
332 if (state
->nmbd_pid
== 0) {
333 DEBUG(3, ("No nmbd found\n"));
334 tevent_req_nterror(req
, NT_STATUS_NOT_SUPPORTED
);
335 return tevent_req_post(req
, ev
);
338 generate_random_buffer((uint8_t *)(void *)&dgm_id
, sizeof(dgm_id
));
340 ok
= prep_getdc_request(dc_addr
, account_name
, account_flags
,
341 domain_name
, sid
, nt_version
,
342 state
->my_mailslot
, dgm_id
& 0x7fff,
346 DEBUG(3, ("prep_getdc_request failed\n"));
347 tevent_req_nterror(req
, NT_STATUS_INVALID_PARAMETER
);
348 return tevent_req_post(req
, ev
);
351 subreq
= nb_packet_reader_send(state
, ev
, DGRAM_PACKET
, -1,
353 if (tevent_req_nomem(subreq
, req
)) {
354 return tevent_req_post(req
, ev
);
356 tevent_req_set_callback(subreq
, nbt_getdc_got_reader
, req
);
360 static void nbt_getdc_got_reader(struct tevent_req
*subreq
)
362 struct tevent_req
*req
= tevent_req_callback_data(
363 subreq
, struct tevent_req
);
364 struct nbt_getdc_state
*state
= tevent_req_data(
365 req
, struct nbt_getdc_state
);
368 status
= nb_packet_reader_recv(subreq
, state
, &state
->reader
);
370 if (tevent_req_nterror(req
, status
)) {
371 DEBUG(10, ("nb_packet_reader_recv returned %s\n",
376 status
= messaging_send_buf(
377 state
->msg_ctx
, pid_to_procid(state
->nmbd_pid
),
378 MSG_SEND_PACKET
, (uint8_t *)&state
->p
, sizeof(state
->p
));
380 if (tevent_req_nterror(req
, status
)) {
381 DEBUG(10, ("messaging_send_buf returned %s\n",
385 subreq
= nb_packet_read_send(state
, state
->ev
, state
->reader
);
386 if (tevent_req_nomem(subreq
, req
)) {
389 tevent_req_set_callback(subreq
, nbt_getdc_got_response
, req
);
392 static void nbt_getdc_got_response(struct tevent_req
*subreq
)
394 struct tevent_req
*req
= tevent_req_callback_data(
395 subreq
, struct tevent_req
);
396 struct nbt_getdc_state
*state
= tevent_req_data(
397 req
, struct nbt_getdc_state
);
398 struct packet_struct
*p
;
402 status
= nb_packet_read_recv(subreq
, state
, &p
);
404 if (tevent_req_nterror(req
, status
)) {
408 ret
= parse_getdc_response(p
, state
, state
->domain_name
,
409 &state
->nt_version
, &state
->dc_name
,
410 &state
->samlogon_response
);
412 tevent_req_nterror(req
, NT_STATUS_INVALID_NETWORK_RESPONSE
);
415 tevent_req_done(req
);
418 NTSTATUS
nbt_getdc_recv(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
,
419 uint32_t *nt_version
, const char **dc_name
,
420 struct netlogon_samlogon_response
**samlogon_response
)
422 struct nbt_getdc_state
*state
= tevent_req_data(
423 req
, struct nbt_getdc_state
);
426 if (tevent_req_is_nterror(req
, &status
)) {
429 if (nt_version
!= NULL
) {
430 *nt_version
= state
->nt_version
;
432 if (dc_name
!= NULL
) {
433 *dc_name
= talloc_move(mem_ctx
, &state
->dc_name
);
435 if (samlogon_response
!= NULL
) {
436 *samlogon_response
= talloc_move(
437 mem_ctx
, &state
->samlogon_response
);
442 NTSTATUS
nbt_getdc(struct messaging_context
*msg_ctx
,
443 uint32_t timeout_in_seconds
,
444 const struct sockaddr_storage
*dc_addr
,
445 const char *domain_name
,
446 const struct dom_sid
*sid
,
447 const char *account_name
,
448 uint32_t account_flags
,
451 uint32_t *pnt_version
,
452 const char **dc_name
,
453 struct netlogon_samlogon_response
**samlogon_response
)
455 TALLOC_CTX
*frame
= talloc_stackframe();
456 struct tevent_context
*ev
;
457 struct tevent_req
*req
;
458 NTSTATUS status
= NT_STATUS_NO_MEMORY
;
460 ev
= samba_tevent_context_init(frame
);
464 req
= nbt_getdc_send(ev
, ev
, msg_ctx
, dc_addr
, domain_name
,
465 sid
, account_name
, account_flags
, nt_version
);
469 if (!tevent_req_set_endtime(req
, ev
,
470 timeval_current_ofs(timeout_in_seconds
, 0))) {
473 if (!tevent_req_poll_ntstatus(req
, ev
, &status
)) {
476 status
= nbt_getdc_recv(req
, mem_ctx
, pnt_version
, dc_name
,