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 2 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, write to the Free Software
21 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
24 #include "include/includes.h"
25 #include "lib/messaging/irpc.h"
26 #include "librpc/gen_ndr/ndr_irpc.h"
27 #include "librpc/gen_ndr/samr.h"
28 #include "libcli/composite/composite.h"
29 #include "libcli/libcli.h"
30 #include "libcli/resolve/resolve.h"
32 struct finddcs_state
{
33 struct composite_context
*ctx
;
34 struct messaging_context
*msg_ctx
;
36 const char *domain_name
;
37 struct dom_sid
*domain_sid
;
39 struct nbtd_getdcname r
;
40 struct nbt_name_status node_status
;
43 struct nbt_dc_name
*dcs
;
46 static void finddcs_name_resolved(struct composite_context
*ctx
);
47 static void finddcs_getdc_replied(struct irpc_request
*ireq
);
48 static void fallback_node_status(struct finddcs_state
*state
);
49 static void fallback_node_status_replied(struct nbt_name_request
*name_req
);
52 * Setup and send off the a normal name resolution for the target name.
54 * The domain_sid parameter is optional, and is used in the subsequent getdc request.
56 * This will try a GetDC request, but this may not work. It will try
57 * a node status as a fallback, then return no name (but still include
61 struct composite_context
*finddcs_send(TALLOC_CTX
*mem_ctx
,
62 const char *domain_name
,
64 struct dom_sid
*domain_sid
,
66 struct event_context
*event_ctx
,
67 struct messaging_context
*msg_ctx
)
69 struct composite_context
*c
, *creq
;
70 struct finddcs_state
*state
;
73 c
= composite_create(mem_ctx
, event_ctx
);
74 if (c
== NULL
) return NULL
;
76 state
= talloc(c
, struct finddcs_state
);
77 if (composite_nomem(state
, c
)) return c
;
78 c
->private_data
= state
;
82 state
->domain_name
= talloc_strdup(state
, domain_name
);
83 if (composite_nomem(state
->domain_name
, c
)) return c
;
86 state
->domain_sid
= talloc_reference(state
, domain_sid
);
87 if (composite_nomem(state
->domain_sid
, c
)) return c
;
89 state
->domain_sid
= NULL
;
92 state
->msg_ctx
= msg_ctx
;
94 make_nbt_name(&name
, state
->domain_name
, name_type
);
95 creq
= resolve_name_send(&name
, event_ctx
,
97 composite_continue(c
, creq
, finddcs_name_resolved
, state
);
101 /* Having got an name query answer, fire off a GetDC request, so we
102 * can find the target's all-important name. (Kerberos and some
103 * netlogon operations are quite picky about names)
105 * The name is a courtesy, if we don't find it, don't completely fail.
107 * However, if the nbt server is down, fall back to a node status
110 static void finddcs_name_resolved(struct composite_context
*ctx
)
112 struct finddcs_state
*state
=
113 talloc_get_type(ctx
->async
.private_data
, struct finddcs_state
);
114 struct irpc_request
*ireq
;
115 struct server_id
*nbt_servers
;
118 state
->ctx
->status
= resolve_name_recv(ctx
, state
, &address
);
119 if (!composite_is_ok(state
->ctx
)) return;
122 state
->dcs
= talloc_array(state
, struct nbt_dc_name
, state
->num_dcs
);
123 if (composite_nomem(state
->dcs
, state
->ctx
)) return;
125 state
->dcs
[0].address
= talloc_steal(state
->dcs
, address
);
127 /* Try and find the nbt server. Fallback to a node status
128 * request if we can't make this happen The nbt server just
129 * might not be running, or we may not have a messaging
130 * context (not root etc) */
131 if (!state
->msg_ctx
) {
132 fallback_node_status(state
);
136 nbt_servers
= irpc_servers_byname(state
->msg_ctx
, state
, "nbt_server");
137 if ((nbt_servers
== NULL
) || (nbt_servers
[0].id
== 0)) {
138 fallback_node_status(state
);
142 state
->r
.in
.domainname
= state
->domain_name
;
143 state
->r
.in
.ip_address
= state
->dcs
[0].address
;
144 state
->r
.in
.my_computername
= lp_netbios_name();
145 state
->r
.in
.my_accountname
= talloc_asprintf(state
, "%s$",
147 if (composite_nomem(state
->r
.in
.my_accountname
, state
->ctx
)) return;
148 state
->r
.in
.account_control
= ACB_WSTRUST
;
149 state
->r
.in
.domain_sid
= state
->domain_sid
;
151 ireq
= irpc_call_send(state
->msg_ctx
, nbt_servers
[0],
152 &dcerpc_table_irpc
, DCERPC_NBTD_GETDCNAME
,
155 fallback_node_status(state
);
159 composite_continue_irpc(state
->ctx
, ireq
, finddcs_getdc_replied
, state
);
162 /* Called when the GetDC request returns */
163 static void finddcs_getdc_replied(struct irpc_request
*ireq
)
165 struct finddcs_state
*state
=
166 talloc_get_type(ireq
->async
.private, struct finddcs_state
);
168 state
->ctx
->status
= irpc_call_recv(ireq
);
169 if (!composite_is_ok(state
->ctx
)) return;
171 state
->dcs
[0].name
= talloc_steal(state
->dcs
, state
->r
.out
.dcname
);
172 composite_done(state
->ctx
);
175 /* The GetDC request might not be availible (such as occours when the
176 * NBT server is down). Fallback to a node status. It is the best
178 static void fallback_node_status(struct finddcs_state
*state
)
180 struct nbt_name_socket
*nbtsock
;
181 struct nbt_name_request
*name_req
;
183 state
->node_status
.in
.name
.name
= "*";
184 state
->node_status
.in
.name
.type
= NBT_NAME_CLIENT
;
185 state
->node_status
.in
.name
.scope
= NULL
;
186 state
->node_status
.in
.dest_addr
= state
->dcs
[0].address
;
187 state
->node_status
.in
.timeout
= 1;
188 state
->node_status
.in
.retries
= 2;
190 nbtsock
= nbt_name_socket_init(state
, state
->ctx
->event_ctx
);
191 if (composite_nomem(nbtsock
, state
->ctx
)) return;
193 name_req
= nbt_name_status_send(nbtsock
, &state
->node_status
);
194 if (composite_nomem(name_req
, state
->ctx
)) return;
196 composite_continue_nbt(state
->ctx
,
198 fallback_node_status_replied
,
202 /* We have a node status reply (or perhaps a timeout) */
203 static void fallback_node_status_replied(struct nbt_name_request
*name_req
)
206 struct finddcs_state
*state
= talloc_get_type(name_req
->async
.private, struct finddcs_state
);
207 state
->ctx
->status
= nbt_name_status_recv(name_req
, state
, &state
->node_status
);
208 if (!composite_is_ok(state
->ctx
)) return;
210 for (i
=0; i
< state
->node_status
.out
.status
.num_names
; i
++) {
212 if (state
->node_status
.out
.status
.names
[i
].type
== NBT_NAME_SERVER
) {
213 char *name
= talloc_strndup(state
->dcs
, state
->node_status
.out
.status
.names
[0].name
, 15);
214 /* Strip space padding */
216 j
= MIN(strlen(name
), 15);
217 for (; j
> 0 && name
[j
- 1] == ' '; j
--) {
221 state
->dcs
[0].name
= name
;
222 composite_done(state
->ctx
);
226 composite_error(state
->ctx
, NT_STATUS_NO_LOGON_SERVERS
);
229 NTSTATUS
finddcs_recv(struct composite_context
*c
, TALLOC_CTX
*mem_ctx
,
230 int *num_dcs
, struct nbt_dc_name
**dcs
)
232 NTSTATUS status
= composite_wait(c
);
233 if (NT_STATUS_IS_OK(status
)) {
234 struct finddcs_state
*state
=
235 talloc_get_type(c
->private_data
, struct finddcs_state
);
236 *num_dcs
= state
->num_dcs
;
237 *dcs
= talloc_steal(mem_ctx
, state
->dcs
);
243 NTSTATUS
finddcs(TALLOC_CTX
*mem_ctx
,
244 const char *domain_name
, int name_type
,
245 struct dom_sid
*domain_sid
,
246 const char **methods
,
247 struct event_context
*event_ctx
,
248 struct messaging_context
*msg_ctx
,
249 int *num_dcs
, struct nbt_dc_name
**dcs
)
251 struct composite_context
*c
= finddcs_send(mem_ctx
,
252 domain_name
, name_type
,
255 return finddcs_recv(c
, mem_ctx
, num_dcs
, dcs
);