2 Unix SMB/CIFS implementation.
4 a composite API for finding a DC and its name
6 Copyright (C) Volker Lendecke 2005
7 Copyright (C) Andrew Bartlett <abartlet@samba.org> 2006
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"
24 #include "lib/messaging/irpc.h"
25 #include "librpc/gen_ndr/ndr_irpc.h"
26 #include "librpc/gen_ndr/samr.h"
27 #include "libcli/composite/composite.h"
28 #include "libcli/libcli.h"
29 #include "libcli/resolve/resolve.h"
30 #include "libcli/finddcs.h"
32 struct finddcs_state
{
33 struct composite_context
*ctx
;
34 struct messaging_context
*msg_ctx
;
36 const char *my_netbios_name
;
37 const char *domain_name
;
38 struct dom_sid
*domain_sid
;
40 struct nbtd_getdcname r
;
41 struct nbt_name_status node_status
;
43 struct smb_iconv_convenience
*iconv_convenience
;
46 struct nbt_dc_name
*dcs
;
50 static void finddcs_name_resolved(struct composite_context
*ctx
);
51 static void finddcs_getdc_replied(struct irpc_request
*ireq
);
52 static void fallback_node_status(struct finddcs_state
*state
);
53 static void fallback_node_status_replied(struct nbt_name_request
*name_req
);
56 * Setup and send off the a normal name resolution for the target name.
58 * The domain_sid parameter is optional, and is used in the subsequent getdc request.
60 * This will try a GetDC request, but this may not work. It will try
61 * a node status as a fallback, then return no name (but still include
65 struct composite_context
*finddcs_send(TALLOC_CTX
*mem_ctx
,
66 const char *my_netbios_name
,
68 const char *domain_name
,
70 struct dom_sid
*domain_sid
,
71 struct smb_iconv_convenience
*iconv_convenience
,
72 struct resolve_context
*resolve_ctx
,
73 struct event_context
*event_ctx
,
74 struct messaging_context
*msg_ctx
)
76 struct composite_context
*c
, *creq
;
77 struct finddcs_state
*state
;
80 c
= composite_create(mem_ctx
, event_ctx
);
81 if (c
== NULL
) return NULL
;
83 state
= talloc(c
, struct finddcs_state
);
84 if (composite_nomem(state
, c
)) return c
;
85 c
->private_data
= state
;
89 state
->nbt_port
= nbt_port
;
90 state
->my_netbios_name
= talloc_strdup(state
, my_netbios_name
);
91 state
->domain_name
= talloc_strdup(state
, domain_name
);
92 state
->iconv_convenience
= iconv_convenience
;
93 if (composite_nomem(state
->domain_name
, c
)) return c
;
96 state
->domain_sid
= talloc_reference(state
, domain_sid
);
97 if (composite_nomem(state
->domain_sid
, c
)) return c
;
99 state
->domain_sid
= NULL
;
102 state
->msg_ctx
= msg_ctx
;
104 make_nbt_name(&name
, state
->domain_name
, name_type
);
105 creq
= resolve_name_send(resolve_ctx
, &name
, event_ctx
);
106 composite_continue(c
, creq
, finddcs_name_resolved
, state
);
110 /* Having got an name query answer, fire off a GetDC request, so we
111 * can find the target's all-important name. (Kerberos and some
112 * netlogon operations are quite picky about names)
114 * The name is a courtesy, if we don't find it, don't completely fail.
116 * However, if the nbt server is down, fall back to a node status
119 static void finddcs_name_resolved(struct composite_context
*ctx
)
121 struct finddcs_state
*state
=
122 talloc_get_type(ctx
->async
.private_data
, struct finddcs_state
);
123 struct irpc_request
*ireq
;
124 struct server_id
*nbt_servers
;
127 state
->ctx
->status
= resolve_name_recv(ctx
, state
, &address
);
128 if (!composite_is_ok(state
->ctx
)) return;
130 /* TODO: This should try and find all the DCs, and give the
131 * caller them in the order they responded */
134 state
->dcs
= talloc_array(state
, struct nbt_dc_name
, state
->num_dcs
);
135 if (composite_nomem(state
->dcs
, state
->ctx
)) return;
137 state
->dcs
[0].address
= talloc_steal(state
->dcs
, address
);
139 /* Try and find the nbt server. Fallback to a node status
140 * request if we can't make this happen The nbt server just
141 * might not be running, or we may not have a messaging
142 * context (not root etc) */
143 if (!state
->msg_ctx
) {
144 fallback_node_status(state
);
148 nbt_servers
= irpc_servers_byname(state
->msg_ctx
, state
, "nbt_server");
149 if ((nbt_servers
== NULL
) || (nbt_servers
[0].id
== 0)) {
150 fallback_node_status(state
);
154 state
->r
.in
.domainname
= state
->domain_name
;
155 state
->r
.in
.ip_address
= state
->dcs
[0].address
;
156 state
->r
.in
.my_computername
= state
->my_netbios_name
;
157 state
->r
.in
.my_accountname
= talloc_asprintf(state
, "%s$", state
->my_netbios_name
);
158 if (composite_nomem(state
->r
.in
.my_accountname
, state
->ctx
)) return;
159 state
->r
.in
.account_control
= ACB_WSTRUST
;
160 state
->r
.in
.domain_sid
= state
->domain_sid
;
162 ireq
= irpc_call_send(state
->msg_ctx
, nbt_servers
[0],
163 &ndr_table_irpc
, NDR_NBTD_GETDCNAME
,
166 fallback_node_status(state
);
170 composite_continue_irpc(state
->ctx
, ireq
, finddcs_getdc_replied
, state
);
173 /* Called when the GetDC request returns */
174 static void finddcs_getdc_replied(struct irpc_request
*ireq
)
176 struct finddcs_state
*state
=
177 talloc_get_type(ireq
->async
.private, struct finddcs_state
);
179 state
->ctx
->status
= irpc_call_recv(ireq
);
180 if (!composite_is_ok(state
->ctx
)) return;
182 state
->dcs
[0].name
= talloc_steal(state
->dcs
, state
->r
.out
.dcname
);
183 composite_done(state
->ctx
);
186 /* The GetDC request might not be available (such as occours when the
187 * NBT server is down). Fallback to a node status. It is the best
189 static void fallback_node_status(struct finddcs_state
*state
)
191 struct nbt_name_socket
*nbtsock
;
192 struct nbt_name_request
*name_req
;
194 state
->node_status
.in
.name
.name
= "*";
195 state
->node_status
.in
.name
.type
= NBT_NAME_CLIENT
;
196 state
->node_status
.in
.name
.scope
= NULL
;
197 state
->node_status
.in
.dest_addr
= state
->dcs
[0].address
;
198 state
->node_status
.in
.dest_port
= state
->nbt_port
;
199 state
->node_status
.in
.timeout
= 1;
200 state
->node_status
.in
.retries
= 2;
202 nbtsock
= nbt_name_socket_init(state
, state
->ctx
->event_ctx
,
203 state
->iconv_convenience
);
204 if (composite_nomem(nbtsock
, state
->ctx
)) return;
206 name_req
= nbt_name_status_send(nbtsock
, &state
->node_status
);
207 if (composite_nomem(name_req
, state
->ctx
)) return;
209 composite_continue_nbt(state
->ctx
,
211 fallback_node_status_replied
,
215 /* We have a node status reply (or perhaps a timeout) */
216 static void fallback_node_status_replied(struct nbt_name_request
*name_req
)
219 struct finddcs_state
*state
= talloc_get_type(name_req
->async
.private_data
, struct finddcs_state
);
220 state
->ctx
->status
= nbt_name_status_recv(name_req
, state
, &state
->node_status
);
221 if (!composite_is_ok(state
->ctx
)) return;
223 for (i
=0; i
< state
->node_status
.out
.status
.num_names
; i
++) {
225 if (state
->node_status
.out
.status
.names
[i
].type
== NBT_NAME_SERVER
) {
226 char *name
= talloc_strndup(state
->dcs
, state
->node_status
.out
.status
.names
[0].name
, 15);
227 /* Strip space padding */
229 j
= MIN(strlen(name
), 15);
230 for (; j
> 0 && name
[j
- 1] == ' '; j
--) {
234 state
->dcs
[0].name
= name
;
235 composite_done(state
->ctx
);
239 composite_error(state
->ctx
, NT_STATUS_NO_LOGON_SERVERS
);
242 NTSTATUS
finddcs_recv(struct composite_context
*c
, TALLOC_CTX
*mem_ctx
,
243 int *num_dcs
, struct nbt_dc_name
**dcs
)
245 NTSTATUS status
= composite_wait(c
);
246 if (NT_STATUS_IS_OK(status
)) {
247 struct finddcs_state
*state
=
248 talloc_get_type(c
->private_data
, struct finddcs_state
);
249 *num_dcs
= state
->num_dcs
;
250 *dcs
= talloc_steal(mem_ctx
, state
->dcs
);
256 NTSTATUS
finddcs(TALLOC_CTX
*mem_ctx
,
257 const char *my_netbios_name
,
259 const char *domain_name
, int name_type
,
260 struct dom_sid
*domain_sid
,
261 struct smb_iconv_convenience
*iconv_convenience
,
262 struct resolve_context
*resolve_ctx
,
263 struct event_context
*event_ctx
,
264 struct messaging_context
*msg_ctx
,
265 int *num_dcs
, struct nbt_dc_name
**dcs
)
267 struct composite_context
*c
= finddcs_send(mem_ctx
,
270 domain_name
, name_type
,
275 return finddcs_recv(c
, mem_ctx
, num_dcs
, dcs
);