Add header files for secace and secacl.
[amitay/samba.git] / source4 / libcli / finddcs.c
1 /* 
2    Unix SMB/CIFS implementation.
3
4    a composite API for finding a DC and its name
5
6    Copyright (C) Volker Lendecke 2005
7    Copyright (C) Andrew Bartlett <abartlet@samba.org> 2006
8    
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.
13    
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.
18    
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/>.
21 */
22
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"
31
32 struct finddcs_state {
33         struct composite_context *ctx;
34         struct messaging_context *msg_ctx;
35
36         const char *my_netbios_name;
37         const char *domain_name;
38         struct dom_sid *domain_sid;
39
40         struct nbtd_getdcname r;
41         struct nbt_name_status node_status;
42
43         struct smb_iconv_convenience *iconv_convenience;
44
45         int num_dcs;
46         struct nbt_dc_name *dcs;
47         uint16_t nbt_port;
48 };
49
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);
54
55 /* 
56  * Setup and send off the a normal name resolution for the target name.
57  *
58  * The domain_sid parameter is optional, and is used in the subsequent getdc request.
59  *
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
62  * the IP)
63  */
64
65 struct composite_context *finddcs_send(TALLOC_CTX *mem_ctx,
66                                        const char *my_netbios_name,
67                                        uint16_t nbt_port,
68                                        const char *domain_name,
69                                        int name_type,
70                                        struct dom_sid *domain_sid,
71                                        struct smb_iconv_convenience *iconv_convenience,
72                                        struct resolve_context *resolve_ctx,
73                                        struct tevent_context *event_ctx,
74                                        struct messaging_context *msg_ctx)
75 {
76         struct composite_context *c, *creq;
77         struct finddcs_state *state;
78         struct nbt_name name;
79
80         c = composite_create(mem_ctx, event_ctx);
81         if (c == NULL) return NULL;
82
83         state = talloc(c, struct finddcs_state);
84         if (composite_nomem(state, c)) return c;
85         c->private_data = state;
86
87         state->ctx = c;
88
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;
94
95         if (domain_sid) {
96                 state->domain_sid = talloc_reference(state, domain_sid);
97                 if (composite_nomem(state->domain_sid, c)) return c;
98         } else {
99                 state->domain_sid = NULL;
100         }
101
102         state->msg_ctx = msg_ctx;
103
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);
107         return c;
108 }
109
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) 
113  *
114  * The name is a courtesy, if we don't find it, don't completely fail.
115  *
116  * However, if the nbt server is down, fall back to a node status
117  * request
118  */
119 static void finddcs_name_resolved(struct composite_context *ctx)
120 {
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;
125         const char *address;
126
127         state->ctx->status = resolve_name_recv(ctx, state, &address);
128         if (!composite_is_ok(state->ctx)) return;
129
130         /* TODO: This should try and find all the DCs, and give the
131          * caller them in the order they responded */
132
133         state->num_dcs = 1;
134         state->dcs = talloc_array(state, struct nbt_dc_name, state->num_dcs);
135         if (composite_nomem(state->dcs, state->ctx)) return;
136
137         state->dcs[0].address = talloc_steal(state->dcs, address);
138
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);
145                 return;
146         }
147
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);
151                 return;
152         }
153
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;
161
162         ireq = irpc_call_send(state->msg_ctx, nbt_servers[0],
163                               &ndr_table_irpc, NDR_NBTD_GETDCNAME,
164                               &state->r, state);
165         if (!ireq) {
166                 fallback_node_status(state);
167                 return;
168         }
169
170         composite_continue_irpc(state->ctx, ireq, finddcs_getdc_replied, state);
171 }
172
173 /* Called when the GetDC request returns */
174 static void finddcs_getdc_replied(struct irpc_request *ireq)
175 {
176         struct finddcs_state *state =
177                 talloc_get_type(ireq->async.private_data, struct finddcs_state);
178
179         state->ctx->status = irpc_call_recv(ireq);
180         if (!composite_is_ok(state->ctx)) return;
181
182         state->dcs[0].name = talloc_steal(state->dcs, state->r.out.dcname);
183         composite_done(state->ctx);
184 }
185
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
188  * hope we have... */
189 static void fallback_node_status(struct finddcs_state *state) 
190 {
191         struct nbt_name_socket *nbtsock;
192         struct nbt_name_request *name_req;
193
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;
201
202         nbtsock = nbt_name_socket_init(state, state->ctx->event_ctx, 
203                                        state->iconv_convenience);
204         if (composite_nomem(nbtsock, state->ctx)) return;
205         
206         name_req = nbt_name_status_send(nbtsock, &state->node_status);
207         if (composite_nomem(name_req, state->ctx)) return;
208
209         composite_continue_nbt(state->ctx, 
210                                name_req, 
211                                fallback_node_status_replied,
212                                state);
213 }
214
215 /* We have a node status reply (or perhaps a timeout) */
216 static void fallback_node_status_replied(struct nbt_name_request *name_req) 
217 {
218         int i;
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;
222
223         for (i=0; i < state->node_status.out.status.num_names; i++) {
224                 int j;
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 */
228                         if (name) {
229                                 j = MIN(strlen(name), 15);
230                                 for (; j > 0 && name[j - 1] == ' '; j--) {
231                                         name[j - 1] = '\0';
232                                 }
233                         }
234                         state->dcs[0].name = name;
235                         composite_done(state->ctx);
236                         return;
237                 }
238         }
239         composite_error(state->ctx, NT_STATUS_NO_LOGON_SERVERS);
240 }
241
242 NTSTATUS finddcs_recv(struct composite_context *c, TALLOC_CTX *mem_ctx,
243                       int *num_dcs, struct nbt_dc_name **dcs)
244 {
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);
251         }
252         talloc_free(c);
253         return status;
254 }
255
256 NTSTATUS finddcs(TALLOC_CTX *mem_ctx,
257                  const char *my_netbios_name,
258                  uint16_t nbt_port,
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 tevent_context *event_ctx,
264                  struct messaging_context *msg_ctx,
265                  int *num_dcs, struct nbt_dc_name **dcs)
266 {
267         struct composite_context *c = finddcs_send(mem_ctx,
268                                                    my_netbios_name,
269                                                    nbt_port,
270                                                    domain_name, name_type,
271                                                    domain_sid, 
272                                                    iconv_convenience,
273                                                    resolve_ctx,
274                                                    event_ctx, msg_ctx);
275         return finddcs_recv(c, mem_ctx, num_dcs, dcs);
276 }