2 Unix SMB/CIFS implementation.
4 dcerpc connect functions
6 Copyright (C) Andrew Tridgell 2003
7 Copyright (C) Jelmer Vernooij 2004
8 Copyright (C) Andrew Bartlett <abartlet@samba.org> 2005-2007
9 Copyright (C) Rafal Szczesniak 2005
11 This program is free software; you can redistribute it and/or modify
12 it under the terms of the GNU General Public License as published by
13 the Free Software Foundation; either version 3 of the License, or
14 (at your option) any later version.
16 This program is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 GNU General Public License for more details.
21 You should have received a copy of the GNU General Public License
22 along with this program. If not, see <http://www.gnu.org/licenses/>.
27 #include "libcli/composite/composite.h"
28 #include "lib/events/events.h"
29 #include "librpc/rpc/dcerpc.h"
30 #include "librpc/rpc/dcerpc_proto.h"
31 #include "libcli/smb/smbXcli_base.h"
32 #include "auth/credentials/credentials.h"
33 #include "param/param.h"
34 #include "libcli/resolve/resolve.h"
35 #include "lib/util/util_net.h"
37 struct sec_conn_state {
38 struct dcerpc_pipe *pipe;
39 struct dcerpc_pipe *pipe2;
40 struct dcerpc_binding *binding;
42 struct smbXcli_conn *conn;
43 struct smbXcli_session *session;
44 struct smbXcli_tcon *tcon;
49 static void continue_open_smb(struct composite_context *ctx);
50 static void continue_open_tcp(struct composite_context *ctx);
51 static void continue_open_ncalrpc(struct composite_context *ctx);
52 static void continue_open_ncacn_unix(struct composite_context *ctx);
53 static void continue_pipe_open(struct composite_context *c);
57 Send request to create a secondary dcerpc connection from a primary
60 _PUBLIC_ struct composite_context* dcerpc_secondary_connection_send(struct dcerpc_pipe *p,
61 const struct dcerpc_binding *b)
63 struct composite_context *c;
64 struct sec_conn_state *s;
65 struct composite_context *pipe_smb_req;
66 struct composite_context *pipe_tcp_req;
67 const char *localaddress = NULL;
68 struct composite_context *pipe_ncalrpc_req;
69 const char *ncalrpc_dir = NULL;
70 struct composite_context *pipe_unix_req;
72 const char *target_hostname;
75 /* composite context allocation and setup */
76 c = composite_create(p, p->conn->event_ctx);
77 if (c == NULL) return NULL;
79 s = talloc_zero(c, struct sec_conn_state);
80 if (composite_nomem(s, c)) return c;
84 s->binding = dcerpc_binding_dup(s, b);
85 if (composite_nomem(s->binding, c)) return c;
87 /* initialise second dcerpc pipe based on primary pipe's event context */
88 s->pipe2 = dcerpc_pipe_init(c, s->pipe->conn->event_ctx);
89 if (composite_nomem(s->pipe2, c)) return c;
92 s->pipe2->conn->packet_log_dir = s->pipe->conn->packet_log_dir;
94 host = dcerpc_binding_get_string_option(s->binding, "host");
97 * We may fallback to the host of the given connection
99 host = dcerpc_binding_get_string_option(s->pipe->binding,
102 target_hostname = dcerpc_binding_get_string_option(s->binding, "target_hostname");
103 if (target_hostname == NULL) {
105 * We may fallback to the target_hostname of the given connection
107 target_hostname = dcerpc_binding_get_string_option(s->pipe->binding,
110 endpoint = dcerpc_binding_get_string_option(s->binding, "endpoint");
111 if (endpoint == NULL) {
113 * We may fallback to the endpoint of the given connection
115 endpoint = dcerpc_binding_get_string_option(s->pipe->binding, "endpoint");
117 if (endpoint == NULL) {
118 composite_error(c, NT_STATUS_INVALID_PARAMETER_MIX);
122 /* open second dcerpc pipe using the same transport as for primary pipe */
123 switch (s->pipe->conn->transport.transport) {
125 c->status = dcerpc_binding_get_smbXcli_pointers(s->pipe->binding,
129 if (!NT_STATUS_IS_OK(c->status)) {
130 composite_error(c, NT_STATUS_INVALID_PARAMETER_MIX);
134 pipe_smb_req = dcerpc_pipe_open_smb_send(s->pipe2->conn,
138 DCERPC_REQUEST_TIMEOUT * 1000,
140 composite_continue(c, pipe_smb_req, continue_open_smb, c);
145 composite_error(c, NT_STATUS_INVALID_PARAMETER_MIX);
149 if (!is_ipaddress(host)) {
151 * We may fallback to the host of the given connection
153 host = dcerpc_binding_get_string_option(s->pipe->binding,
156 composite_error(c, NT_STATUS_INVALID_PARAMETER_MIX);
159 if (!is_ipaddress(host)) {
160 composite_error(c, NT_STATUS_INVALID_PARAMETER_MIX);
165 localaddress = dcerpc_binding_get_string_option(s->binding,
167 if (localaddress == NULL) {
169 * We may fallback to the localaddress of the given connection
171 localaddress = dcerpc_binding_get_string_option(s->pipe->binding,
175 pipe_tcp_req = dcerpc_pipe_open_tcp_send(s->pipe2->conn,
180 resolve_context_init(s));
181 composite_continue(c, pipe_tcp_req, continue_open_tcp, c);
185 ncalrpc_dir = dcerpc_binding_get_string_option(s->binding,
187 if (ncalrpc_dir == NULL) {
188 ncalrpc_dir = dcerpc_binding_get_string_option(s->pipe->binding,
191 if (ncalrpc_dir == NULL) {
192 composite_error(c, NT_STATUS_INVALID_PARAMETER_MIX);
196 pipe_ncalrpc_req = dcerpc_pipe_open_pipe_send(s->pipe2->conn,
199 composite_continue(c, pipe_ncalrpc_req, continue_open_ncalrpc, c);
202 case NCACN_UNIX_STREAM:
203 pipe_unix_req = dcerpc_pipe_open_unix_stream_send(s->pipe2->conn,
205 composite_continue(c, pipe_unix_req, continue_open_ncacn_unix, c);
209 /* looks like a transport we don't support */
210 composite_error(c, NT_STATUS_NOT_SUPPORTED);
218 Stage 2 of secondary_connection: Receive result of pipe open request on smb
220 static void continue_open_smb(struct composite_context *ctx)
222 struct composite_context *c = talloc_get_type(ctx->async.private_data,
223 struct composite_context);
224 struct sec_conn_state *s = talloc_get_type_abort(c->private_data,
225 struct sec_conn_state);
227 c->status = dcerpc_pipe_open_smb_recv(ctx);
228 if (!composite_is_ok(c)) return;
230 c->status = dcerpc_binding_set_smbXcli_pointers(s->binding,
234 if (!composite_is_ok(c)) return;
236 continue_pipe_open(c);
241 Stage 2 of secondary_connection: Receive result of pipe open request on tcp/ip
243 static void continue_open_tcp(struct composite_context *ctx)
245 struct composite_context *c = talloc_get_type(ctx->async.private_data,
246 struct composite_context);
247 struct sec_conn_state *s = talloc_get_type_abort(c->private_data,
248 struct sec_conn_state);
249 char *localaddr = NULL;
250 char *remoteaddr = NULL;
252 c->status = dcerpc_pipe_open_tcp_recv(ctx, s, &localaddr, &remoteaddr);
253 if (!composite_is_ok(c)) return;
255 c->status = dcerpc_binding_set_string_option(s->binding,
258 if (!composite_is_ok(c)) return;
260 c->status = dcerpc_binding_set_string_option(s->binding,
263 if (!composite_is_ok(c)) return;
265 continue_pipe_open(c);
269 Stage 2 of secondary_connection: Receive result of pipe open request on ncalrpc
271 static void continue_open_ncalrpc(struct composite_context *ctx)
273 struct composite_context *c = talloc_get_type(ctx->async.private_data,
274 struct composite_context);
276 c->status = dcerpc_pipe_open_pipe_recv(ctx);
277 if (!composite_is_ok(c)) return;
279 continue_pipe_open(c);
283 Stage 2 of secondary_connection: Receive result of pipe open request on ncacn_unix
285 static void continue_open_ncacn_unix(struct composite_context *ctx)
287 struct composite_context *c = talloc_get_type(ctx->async.private_data,
288 struct composite_context);
290 c->status = dcerpc_pipe_open_unix_stream_recv(ctx);
291 if (!composite_is_ok(c)) return;
293 continue_pipe_open(c);
298 Stage 3 of secondary_connection: Get binding data and flags from primary pipe
299 and say if we're done ok.
301 static void continue_pipe_open(struct composite_context *c)
303 struct sec_conn_state *s;
305 s = talloc_get_type(c->private_data, struct sec_conn_state);
307 s->pipe2->conn->flags = s->pipe->conn->flags;
308 s->pipe2->binding = talloc_move(s->pipe2, &s->binding);
315 Receive result of secondary rpc connection request and return
318 _PUBLIC_ NTSTATUS dcerpc_secondary_connection_recv(struct composite_context *c,
319 struct dcerpc_pipe **p2)
321 NTSTATUS status = composite_wait(c);
322 struct sec_conn_state *s;
324 s = talloc_get_type(c->private_data, struct sec_conn_state);
326 if (NT_STATUS_IS_OK(status)) {
327 *p2 = talloc_steal(s->pipe, s->pipe2);
335 Create a secondary DCERPC connection, then bind (and possibly
336 authenticate) using the supplied credentials.
338 This creates a second connection, to the same host (and on ncacn_np on the same connection) as the first
340 struct sec_auth_conn_state {
341 struct dcerpc_pipe *pipe2;
342 const struct dcerpc_binding *binding;
343 const struct ndr_interface_table *table;
344 struct cli_credentials *credentials;
345 struct composite_context *ctx;
346 struct loadparm_context *lp_ctx;
349 static void dcerpc_secondary_auth_connection_bind(struct composite_context *ctx);
350 static void dcerpc_secondary_auth_connection_continue(struct composite_context *ctx);
352 _PUBLIC_ struct composite_context* dcerpc_secondary_auth_connection_send(struct dcerpc_pipe *p,
353 const struct dcerpc_binding *binding,
354 const struct ndr_interface_table *table,
355 struct cli_credentials *credentials,
356 struct loadparm_context *lp_ctx)
359 struct composite_context *c, *secondary_conn_ctx;
360 struct sec_auth_conn_state *s;
362 /* composite context allocation and setup */
363 c = composite_create(p, p->conn->event_ctx);
364 if (c == NULL) return NULL;
366 s = talloc_zero(c, struct sec_auth_conn_state);
367 if (composite_nomem(s, c)) return c;
371 s->binding = binding;
373 s->credentials = credentials;
376 secondary_conn_ctx = dcerpc_secondary_connection_send(p, binding);
378 if (composite_nomem(secondary_conn_ctx, s->ctx)) {
383 composite_continue(s->ctx, secondary_conn_ctx, dcerpc_secondary_auth_connection_bind,
389 Stage 2 of secondary_auth_connection:
390 Having made the secondary connection, we will need to do an (authenticated) bind
392 static void dcerpc_secondary_auth_connection_bind(struct composite_context *ctx)
394 struct composite_context *secondary_auth_ctx;
395 struct sec_auth_conn_state *s = talloc_get_type(ctx->async.private_data,
396 struct sec_auth_conn_state);
398 s->ctx->status = dcerpc_secondary_connection_recv(ctx, &s->pipe2);
399 if (!composite_is_ok(s->ctx)) return;
401 secondary_auth_ctx = dcerpc_pipe_auth_send(s->pipe2, s->binding, s->table, s->credentials,
403 composite_continue(s->ctx, secondary_auth_ctx, dcerpc_secondary_auth_connection_continue, s);
408 Stage 3 of secondary_auth_connection: Receive result of authenticated bind request
410 static void dcerpc_secondary_auth_connection_continue(struct composite_context *ctx)
412 struct sec_auth_conn_state *s = talloc_get_type(ctx->async.private_data,
413 struct sec_auth_conn_state);
415 s->ctx->status = dcerpc_pipe_auth_recv(ctx, s, &s->pipe2);
416 if (!composite_is_ok(s->ctx)) return;
418 composite_done(s->ctx);
422 Receive an authenticated pipe, created as a secondary connection
424 _PUBLIC_ NTSTATUS dcerpc_secondary_auth_connection_recv(struct composite_context *c,
426 struct dcerpc_pipe **p)
428 NTSTATUS status = composite_wait(c);
429 struct sec_auth_conn_state *s;
431 s = talloc_get_type(c->private_data, struct sec_auth_conn_state);
433 if (NT_STATUS_IS_OK(status)) {
434 *p = talloc_steal(mem_ctx, s->pipe2);
441 _PUBLIC_ NTSTATUS dcerpc_secondary_auth_connection(struct dcerpc_pipe *p,
442 const struct dcerpc_binding *binding,
443 const struct ndr_interface_table *table,
444 struct cli_credentials *credentials,
445 struct loadparm_context *lp_ctx,
447 struct dcerpc_pipe **p2)
449 struct composite_context *c;
451 c = dcerpc_secondary_auth_connection_send(p, binding, table,
452 credentials, lp_ctx);
453 return dcerpc_secondary_auth_connection_recv(c, mem_ctx, p2);