2 Unix SMB/CIFS implementation.
4 a composite API for finding a DC and its name via CLDAP
6 Copyright (C) Andrew Tridgell 2010
7 Copyright (C) Andrew Bartlett 2010
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>.
23 #include "include/includes.h"
25 #include "libcli/resolve/resolve.h"
26 #include "libcli/cldap/cldap.h"
27 #include "libcli/finddc.h"
28 #include "libcli/security/security.h"
29 #include "lib/util/tevent_ntstatus.h"
30 #include "lib/tsocket/tsocket.h"
31 #include "libcli/composite/composite.h"
33 struct finddcs_cldap_state
{
34 struct tevent_context
*ev
;
35 struct tevent_req
*req
;
36 const char *domain_name
;
37 struct dom_sid
*domain_sid
;
39 const char **srv_addresses
;
40 uint32_t minimum_dc_flags
;
41 uint32_t srv_address_index
;
42 struct cldap_socket
*cldap
;
43 struct cldap_netlogon
*netlogon
;
46 static void finddcs_cldap_srv_resolved(struct composite_context
*ctx
);
47 static void finddcs_cldap_netlogon_replied(struct tevent_req
*req
);
48 static bool finddcs_cldap_srv_lookup(struct finddcs_cldap_state
*state
,
50 struct resolve_context
*resolve_ctx
,
51 struct tevent_context
*event_ctx
);
52 static bool finddcs_cldap_nbt_lookup(struct finddcs_cldap_state
*state
,
54 struct resolve_context
*resolve_ctx
,
55 struct tevent_context
*event_ctx
);
56 static void finddcs_cldap_name_resolved(struct composite_context
*ctx
);
57 static void finddcs_cldap_next_server(struct finddcs_cldap_state
*state
);
58 static bool finddcs_cldap_ipaddress(struct finddcs_cldap_state
*state
, struct finddcs
*io
);
62 * find a list of DCs via DNS/CLDAP
65 struct tevent_req
*finddcs_cldap_send(TALLOC_CTX
*mem_ctx
,
67 struct resolve_context
*resolve_ctx
,
68 struct tevent_context
*event_ctx
)
70 struct finddcs_cldap_state
*state
;
71 struct tevent_req
*req
;
73 req
= tevent_req_create(mem_ctx
, &state
, struct finddcs_cldap_state
);
79 state
->ev
= event_ctx
;
80 state
->minimum_dc_flags
= io
->in
.minimum_dc_flags
;
81 state
->domain_name
= talloc_strdup(state
, io
->in
.domain_name
);
82 if (tevent_req_nomem(state
->domain_name
, req
)) {
83 return tevent_req_post(req
, event_ctx
);
86 if (io
->in
.domain_sid
) {
87 state
->domain_sid
= dom_sid_dup(state
, io
->in
.domain_sid
);
88 if (tevent_req_nomem(state
->domain_sid
, req
)) {
89 return tevent_req_post(req
, event_ctx
);
92 state
->domain_sid
= NULL
;
95 if (io
->in
.server_address
) {
96 DEBUG(4,("finddcs: searching for a DC by IP %s\n", io
->in
.server_address
));
97 if (!finddcs_cldap_ipaddress(state
, io
)) {
98 return tevent_req_post(req
, event_ctx
);
100 } else if (strchr(state
->domain_name
, '.')) {
101 /* looks like a DNS name */
102 DEBUG(4,("finddcs: searching for a DC by DNS domain %s\n", state
->domain_name
));
103 if (!finddcs_cldap_srv_lookup(state
, io
, resolve_ctx
, event_ctx
)) {
104 return tevent_req_post(req
, event_ctx
);
107 DEBUG(4,("finddcs: searching for a DC by NBT lookup %s\n", state
->domain_name
));
108 if (!finddcs_cldap_nbt_lookup(state
, io
, resolve_ctx
, event_ctx
)) {
109 return tevent_req_post(req
, event_ctx
);
118 we've been told the IP of the server, bypass name
119 resolution and go straight to CLDAP
121 static bool finddcs_cldap_ipaddress(struct finddcs_cldap_state
*state
, struct finddcs
*io
)
125 state
->srv_addresses
= talloc_array(state
, const char *, 2);
126 if (tevent_req_nomem(state
->srv_addresses
, state
->req
)) {
129 state
->srv_addresses
[0] = talloc_strdup(state
->srv_addresses
, io
->in
.server_address
);
130 if (tevent_req_nomem(state
->srv_addresses
[0], state
->req
)) {
133 state
->srv_addresses
[1] = NULL
;
134 state
->srv_address_index
= 0;
136 finddcs_cldap_next_server(state
);
137 return tevent_req_is_nterror(state
->req
, &status
);
141 start a SRV DNS lookup
143 static bool finddcs_cldap_srv_lookup(struct finddcs_cldap_state
*state
,
145 struct resolve_context
*resolve_ctx
,
146 struct tevent_context
*event_ctx
)
148 struct composite_context
*creq
;
149 struct nbt_name name
;
151 if (io
->in
.site_name
) {
152 state
->srv_name
= talloc_asprintf(state
, "_ldap._tcp.%s._sites.%s",
153 io
->in
.site_name
, io
->in
.domain_name
);
155 state
->srv_name
= talloc_asprintf(state
, "_ldap._tcp.%s", io
->in
.domain_name
);
158 DEBUG(4,("finddcs: looking for SRV records for %s\n", state
->srv_name
));
160 make_nbt_name(&name
, state
->srv_name
, 0);
162 creq
= resolve_name_ex_send(resolve_ctx
, state
,
163 RESOLVE_NAME_FLAG_FORCE_DNS
| RESOLVE_NAME_FLAG_DNS_SRV
,
164 0, &name
, event_ctx
);
165 if (tevent_req_nomem(creq
, state
->req
)) {
168 creq
->async
.fn
= finddcs_cldap_srv_resolved
;
169 creq
->async
.private_data
= state
;
175 start a NBT name lookup for domain<1C>
177 static bool finddcs_cldap_nbt_lookup(struct finddcs_cldap_state
*state
,
179 struct resolve_context
*resolve_ctx
,
180 struct tevent_context
*event_ctx
)
182 struct composite_context
*creq
;
183 struct nbt_name name
;
185 make_nbt_name(&name
, state
->domain_name
, NBT_NAME_LOGON
);
186 creq
= resolve_name_send(resolve_ctx
, state
, &name
, event_ctx
);
187 if (tevent_req_nomem(creq
, state
->req
)) {
190 creq
->async
.fn
= finddcs_cldap_name_resolved
;
191 creq
->async
.private_data
= state
;
196 fire off a CLDAP query to the next server
198 static void finddcs_cldap_next_server(struct finddcs_cldap_state
*state
)
200 struct tevent_req
*subreq
;
201 struct tsocket_address
*dest
;
205 if (state
->srv_addresses
[state
->srv_address_index
] == NULL
) {
206 tevent_req_nterror(state
->req
, NT_STATUS_OBJECT_NAME_NOT_FOUND
);
207 DEBUG(2,("finddcs: No matching CLDAP server found\n"));
211 /* we should get the port from the SRV response */
212 ret
= tsocket_address_inet_from_strings(state
, "ip",
213 state
->srv_addresses
[state
->srv_address_index
],
217 status
= NT_STATUS_OK
;
219 status
= map_nt_error_from_unix_common(errno
);
221 if (tevent_req_nterror(state
->req
, status
)) {
225 status
= cldap_socket_init(state
, NULL
, dest
, &state
->cldap
);
226 if (tevent_req_nterror(state
->req
, status
)) {
230 TALLOC_FREE(state
->netlogon
);
231 state
->netlogon
= talloc_zero(state
, struct cldap_netlogon
);
232 if (tevent_req_nomem(state
->netlogon
, state
->req
)) {
236 if (strchr(state
->domain_name
, '.')) {
237 state
->netlogon
->in
.realm
= state
->domain_name
;
239 if (state
->domain_sid
) {
240 state
->netlogon
->in
.domain_sid
= dom_sid_string(state
, state
->domain_sid
);
241 if (tevent_req_nomem(state
->netlogon
->in
.domain_sid
, state
->req
)) {
245 state
->netlogon
->in
.acct_control
= -1;
246 state
->netlogon
->in
.version
=
247 NETLOGON_NT_VERSION_5
|
248 NETLOGON_NT_VERSION_5EX
|
249 NETLOGON_NT_VERSION_IP
;
250 state
->netlogon
->in
.map_response
= true;
252 DEBUG(4,("finddcs: performing CLDAP query on %s\n",
253 state
->srv_addresses
[state
->srv_address_index
]));
255 subreq
= cldap_netlogon_send(state
, state
->ev
,
256 state
->cldap
, state
->netlogon
);
257 if (tevent_req_nomem(subreq
, state
->req
)) {
261 tevent_req_set_callback(subreq
, finddcs_cldap_netlogon_replied
, state
);
266 we have a response from a CLDAP server for a netlogon request
268 static void finddcs_cldap_netlogon_replied(struct tevent_req
*subreq
)
270 struct finddcs_cldap_state
*state
;
273 state
= tevent_req_callback_data(subreq
, struct finddcs_cldap_state
);
275 status
= cldap_netlogon_recv(subreq
, state
->netlogon
, state
->netlogon
);
277 TALLOC_FREE(state
->cldap
);
278 if (!NT_STATUS_IS_OK(status
)) {
279 state
->srv_address_index
++;
280 finddcs_cldap_next_server(state
);
283 if (state
->minimum_dc_flags
!=
284 (state
->minimum_dc_flags
& state
->netlogon
->out
.netlogon
.data
.nt5_ex
.server_type
)) {
285 /* the server didn't match the minimum requirements */
286 DEBUG(4,("finddcs: Skipping DC %s with server_type=0x%08x - required 0x%08x\n",
287 state
->srv_addresses
[state
->srv_address_index
],
288 state
->netlogon
->out
.netlogon
.data
.nt5_ex
.server_type
,
289 state
->minimum_dc_flags
));
290 state
->srv_address_index
++;
291 finddcs_cldap_next_server(state
);
295 DEBUG(4,("finddcs: Found matching DC %s with server_type=0x%08x\n",
296 state
->srv_addresses
[state
->srv_address_index
],
297 state
->netlogon
->out
.netlogon
.data
.nt5_ex
.server_type
));
299 tevent_req_done(state
->req
);
303 handle NBT name lookup reply
305 static void finddcs_cldap_name_resolved(struct composite_context
*ctx
)
307 struct finddcs_cldap_state
*state
=
308 talloc_get_type(ctx
->async
.private_data
, struct finddcs_cldap_state
);
312 status
= resolve_name_recv(ctx
, state
, &address
);
313 if (tevent_req_nterror(state
->req
, status
)) {
314 DEBUG(2,("finddcs: No matching NBT <1c> server found\n"));
318 DEBUG(4,("finddcs: Found NBT <1c> server at %s\n", address
));
320 state
->srv_addresses
= talloc_array(state
, const char *, 2);
321 if (tevent_req_nomem(state
->srv_addresses
, state
->req
)) {
324 state
->srv_addresses
[0] = address
;
325 state
->srv_addresses
[1] = NULL
;
327 state
->srv_address_index
= 0;
329 finddcs_cldap_next_server(state
);
334 * Having got a DNS SRV answer, fire off the first CLDAP request
336 static void finddcs_cldap_srv_resolved(struct composite_context
*ctx
)
338 struct finddcs_cldap_state
*state
=
339 talloc_get_type(ctx
->async
.private_data
, struct finddcs_cldap_state
);
343 status
= resolve_name_multiple_recv(ctx
, state
, &state
->srv_addresses
);
344 if (tevent_req_nterror(state
->req
, status
)) {
345 DEBUG(2,("finddcs: Failed to find SRV record for %s\n", state
->srv_name
));
349 for (i
=0; state
->srv_addresses
[i
]; i
++) {
350 DEBUG(4,("finddcs: DNS SRV response %u at '%s'\n", i
, state
->srv_addresses
[i
]));
353 state
->srv_address_index
= 0;
355 finddcs_cldap_next_server(state
);
359 NTSTATUS
finddcs_cldap_recv(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
, struct finddcs
*io
)
361 struct finddcs_cldap_state
*state
= tevent_req_data(req
, struct finddcs_cldap_state
);
365 ok
= tevent_req_poll(req
, state
->ev
);
368 return NT_STATUS_INTERNAL_ERROR
;
370 status
= tevent_req_simple_recv_ntstatus(req
);
371 if (NT_STATUS_IS_OK(status
)) {
372 talloc_steal(mem_ctx
, state
->netlogon
);
373 io
->out
.netlogon
= state
->netlogon
->out
.netlogon
;
374 io
->out
.address
= talloc_steal(mem_ctx
, state
->srv_addresses
[state
->srv_address_index
]);
376 tevent_req_received(req
);
380 NTSTATUS
finddcs_cldap(TALLOC_CTX
*mem_ctx
,
382 struct resolve_context
*resolve_ctx
,
383 struct tevent_context
*event_ctx
)
386 struct tevent_req
*req
= finddcs_cldap_send(mem_ctx
,
390 status
= finddcs_cldap_recv(req
, mem_ctx
, io
);