?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
VERSION: Re-enable git snapshots.
[Samba.git] / source4 / libnet / libnet_rpc.c
blobec1931795b60d3927b4290cb1e74a6cd931170a9
1 /*
2 Unix SMB/CIFS implementation.
3
4 Copyright (C) Stefan Metzmacher 2004
5 Copyright (C) Rafal Szczesniak 2005
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>.
19 */
20
21 #include "includes.h"
22 #include "libnet/libnet.h"
23 #include "libcli/libcli.h"
24 #include "libcli/composite/composite.h"
25 #include "librpc/rpc/dcerpc_proto.h"
26 #include "librpc/gen_ndr/ndr_lsa_c.h"
27 #include "librpc/gen_ndr/ndr_samr.h"
28 #include "auth/credentials/credentials.h"
29
30 struct rpc_connect_srv_state {
31 struct libnet_context *ctx;
32 struct libnet_RpcConnect r;
33 const char *binding;
34
35 /* information about the progress */
36 void (*monitor_fn)(struct monitor_msg*);
37 };
38
39
40 static void continue_pipe_connect(struct composite_context *ctx);
41
42
43 /**
44 * Initiates connection to rpc pipe on remote server
45 *
46 * @param ctx initialised libnet context
47 * @param mem_ctx memory context of this call
48 * @param r data structure containing necessary parameters and return values
49 * @return composite context of this call
50 **/
51
52 static struct composite_context* libnet_RpcConnectSrv_send(struct libnet_context *ctx,
53 TALLOC_CTX *mem_ctx,
54 struct libnet_RpcConnect *r,
55 void (*monitor)(struct monitor_msg*))
56 {
57 struct composite_context *c;
58 struct rpc_connect_srv_state *s;
59 struct dcerpc_binding *b;
60 struct composite_context *pipe_connect_req;
61
62 /* composite context allocation and setup */
63 c = composite_create(ctx, ctx->event_ctx);
64 if (c == NULL) return c;
65
66 s = talloc_zero(c, struct rpc_connect_srv_state);
67 if (composite_nomem(s, c)) return c;
68
69 c->private_data = s;
70 s->monitor_fn = monitor;
71
72 s->ctx = ctx;
73 s->r = *r;
74 ZERO_STRUCT(s->r.out);
75
76 /* prepare binding string */
77 switch (r->level) {
78 case LIBNET_RPC_CONNECT_SERVER:
79 s->binding = talloc_asprintf(s, "ncacn_np:%s", r->in.name);
80 break;
81 case LIBNET_RPC_CONNECT_SERVER_ADDRESS:
82 s->binding = talloc_asprintf(s, "ncacn_np:%s[target_hostname=%s]",
83 r->in.address, r->in.name);
84 break;
85
86 case LIBNET_RPC_CONNECT_BINDING:
87 s->binding = talloc_strdup(s, r->in.binding);
88 break;
89
90 case LIBNET_RPC_CONNECT_DC:
91 case LIBNET_RPC_CONNECT_PDC:
92 /* this should never happen - DC and PDC level has a separate
93 composite function */
94 case LIBNET_RPC_CONNECT_DC_INFO:
95 /* this should never happen - DC_INFO level has a separate
96 composite function */
97 composite_error(c, NT_STATUS_INVALID_LEVEL);
98 return c;
99 }
100
101 /* parse binding string to the structure */
102 c->status = dcerpc_parse_binding(c, s->binding, &b);
103 if (!NT_STATUS_IS_OK(c->status)) {
104 DEBUG(0, ("Failed to parse dcerpc binding '%s'\n", s->binding));
105 composite_error(c, c->status);
106 return c;
107 }
108
109 switch (r->level) {
110 case LIBNET_RPC_CONNECT_SERVER:
111 case LIBNET_RPC_CONNECT_SERVER_ADDRESS:
112 c->status = dcerpc_binding_set_flags(b, r->in.dcerpc_flags, 0);
113 if (!composite_is_ok(c)) return c;
114 break;
115 default:
116 /* other types have already been checked before */
117 break;
118 }
119
120 if (DEBUGLEVEL >= 10) {
121 c->status = dcerpc_binding_set_flags(b, DCERPC_DEBUG_PRINT_BOTH, 0);
122 if (!composite_is_ok(c)) return c;
123 }
124
125 /* connect to remote dcerpc pipe */
126 pipe_connect_req = dcerpc_pipe_connect_b_send(c, b, r->in.dcerpc_iface,
127 ctx->cred, c->event_ctx,
128 ctx->lp_ctx);
129 if (composite_nomem(pipe_connect_req, c)) return c;
130
131 composite_continue(c, pipe_connect_req, continue_pipe_connect, c);
132 return c;
133 }
134
135
136 /*
137 Step 2 of RpcConnectSrv - get rpc connection
138 */
139 static void continue_pipe_connect(struct composite_context *ctx)
140 {
141 struct composite_context *c;
142 struct rpc_connect_srv_state *s;
143
144 c = talloc_get_type(ctx->async.private_data, struct composite_context);
145 s = talloc_get_type(c->private_data, struct rpc_connect_srv_state);
146
147 /* receive result of rpc pipe connection */
148 c->status = dcerpc_pipe_connect_b_recv(ctx, c, &s->r.out.dcerpc_pipe);
149
150 /* post monitor message */
151 if (s->monitor_fn) {
152 struct monitor_msg msg;
153 struct msg_net_rpc_connect data;
154 const struct dcerpc_binding *b = s->r.out.dcerpc_pipe->binding;
155
156 /* prepare monitor message and post it */
157 data.host = dcerpc_binding_get_string_option(b, "host");
158 data.endpoint = dcerpc_binding_get_string_option(b, "endpoint");
159 data.transport = dcerpc_binding_get_transport(b);
160 data.domain_name = dcerpc_binding_get_string_option(b, "target_hostname");
161
162 msg.type = mon_NetRpcConnect;
163 msg.data = (void*)&data;
164 msg.data_size = sizeof(data);
165 s->monitor_fn(&msg);
166 }
167
168 composite_done(c);
169 }
170
171
172 /**
173 * Receives result of connection to rpc pipe on remote server
174 *
175 * @param c composite context
176 * @param ctx initialised libnet context
177 * @param mem_ctx memory context of this call
178 * @param r data structure containing necessary parameters and return values
179 * @return nt status of rpc connection
180 **/
181
182 static NTSTATUS libnet_RpcConnectSrv_recv(struct composite_context *c,
183 struct libnet_context *ctx,
184 TALLOC_CTX *mem_ctx,
185 struct libnet_RpcConnect *r)
186 {
187 NTSTATUS status;
188
189 status = composite_wait(c);
190 if (NT_STATUS_IS_OK(status)) {
191 struct rpc_connect_srv_state *s;
192
193 /* move the returned rpc pipe between memory contexts */
194 s = talloc_get_type(c->private_data, struct rpc_connect_srv_state);
195 r->out.dcerpc_pipe = talloc_steal(mem_ctx, s->r.out.dcerpc_pipe);
196
197 /* reference created pipe structure to long-term libnet_context
198 so that it can be used by other api functions even after short-term
199 mem_ctx is freed */
200 if (r->in.dcerpc_iface == &ndr_table_samr) {
201 ctx->samr.pipe = talloc_reference(ctx, r->out.dcerpc_pipe);
202 ctx->samr.samr_handle = ctx->samr.pipe->binding_handle;
203
204 } else if (r->in.dcerpc_iface == &ndr_table_lsarpc) {
205 ctx->lsa.pipe = talloc_reference(ctx, r->out.dcerpc_pipe);
206 ctx->lsa.lsa_handle = ctx->lsa.pipe->binding_handle;
207 }
208
209 r->out.error_string = talloc_strdup(mem_ctx, "Success");
210
211 } else {
212 r->out.error_string = talloc_asprintf(mem_ctx, "Error: %s", nt_errstr(status));
213 }
214
215 talloc_free(c);
216 return status;
217 }
218
219
220 struct rpc_connect_dc_state {
221 struct libnet_context *ctx;
222 struct libnet_RpcConnect r;
223 struct libnet_RpcConnect r2;
224 struct libnet_LookupDCs f;
225 const char *connect_name;
226
227 /* information about the progress */
228 void (*monitor_fn)(struct monitor_msg *);
229 };
230
231
232 static void continue_lookup_dc(struct tevent_req *req);
233 static void continue_rpc_connect(struct composite_context *ctx);
234
235
236 /**
237 * Initiates connection to rpc pipe on domain pdc
238 *
239 * @param ctx initialised libnet context
240 * @param mem_ctx memory context of this call
241 * @param r data structure containing necessary parameters and return values
242 * @return composite context of this call
243 **/
244
245 static struct composite_context* libnet_RpcConnectDC_send(struct libnet_context *ctx,
246 TALLOC_CTX *mem_ctx,
247 struct libnet_RpcConnect *r,
248 void (*monitor)(struct monitor_msg *msg))
249 {
250 struct composite_context *c;
251 struct rpc_connect_dc_state *s;
252 struct tevent_req *lookup_dc_req;
253
254 /* composite context allocation and setup */
255 c = composite_create(ctx, ctx->event_ctx);
256 if (c == NULL) return c;
257
258 s = talloc_zero(c, struct rpc_connect_dc_state);
259 if (composite_nomem(s, c)) return c;
260
261 c->private_data = s;
262 s->monitor_fn = monitor;
263
264 s->ctx = ctx;
265 s->r = *r;
266 ZERO_STRUCT(s->r.out);
267
268 switch (r->level) {
269 case LIBNET_RPC_CONNECT_PDC:
270 s->f.in.name_type = NBT_NAME_PDC;
271 break;
272
273 case LIBNET_RPC_CONNECT_DC:
274 s->f.in.name_type = NBT_NAME_LOGON;
275 break;
276
277 default:
278 break;
279 }
280
281 s->f.in.domain_name = r->in.name;
282 s->f.out.num_dcs = 0;
283 s->f.out.dcs = NULL;
284
285 /* find the domain pdc first */
286 lookup_dc_req = libnet_LookupDCs_send(ctx, c, &s->f);
287 if (composite_nomem(lookup_dc_req, c)) return c;
288
289 tevent_req_set_callback(lookup_dc_req, continue_lookup_dc, c);
290 return c;
291 }
292
293
294 /*
295 Step 2 of RpcConnectDC: get domain controller name and
296 initiate RpcConnect to it
297 */
298 static void continue_lookup_dc(struct tevent_req *req)
299 {
300 struct composite_context *c;
301 struct rpc_connect_dc_state *s;
302 struct composite_context *rpc_connect_req;
303 struct monitor_msg msg;
304 struct msg_net_lookup_dc data;
305
306 c = tevent_req_callback_data(req, struct composite_context);
307 s = talloc_get_type_abort(c->private_data, struct rpc_connect_dc_state);
308
309 /* receive result of domain controller lookup */
310 c->status = libnet_LookupDCs_recv(req, c, &s->f);
311 if (!composite_is_ok(c)) return;
312
313 /* decide on preferred address type depending on DC type */
314 s->connect_name = s->f.out.dcs[0].name;
315
316 /* post monitor message */
317 if (s->monitor_fn) {
318 /* prepare a monitor message and post it */
319 data.domain_name = s->f.in.domain_name;
320 data.hostname = s->f.out.dcs[0].name;
321 data.address = s->f.out.dcs[0].address;
322
323 msg.type = mon_NetLookupDc;
324 msg.data = &data;
325 msg.data_size = sizeof(data);
326 s->monitor_fn(&msg);
327 }
328
329 /* ok, pdc has been found so do attempt to rpc connect */
330 s->r2.level = LIBNET_RPC_CONNECT_SERVER_ADDRESS;
331
332 /* this will cause yet another name resolution, but at least
333 * we pass the right name down the stack now */
334 s->r2.in.name = talloc_strdup(s, s->connect_name);
335 s->r2.in.address = talloc_steal(s, s->f.out.dcs[0].address);
336 s->r2.in.dcerpc_iface = s->r.in.dcerpc_iface;
337 s->r2.in.dcerpc_flags = s->r.in.dcerpc_flags;
338
339 /* send rpc connect request to the server */
340 rpc_connect_req = libnet_RpcConnectSrv_send(s->ctx, c, &s->r2, s->monitor_fn);
341 if (composite_nomem(rpc_connect_req, c)) return;
342
343 composite_continue(c, rpc_connect_req, continue_rpc_connect, c);
344 }
345
346
347 /*
348 Step 3 of RpcConnectDC: get rpc connection to the server
349 */
350 static void continue_rpc_connect(struct composite_context *ctx)
351 {
352 struct composite_context *c;
353 struct rpc_connect_dc_state *s;
354
355 c = talloc_get_type(ctx->async.private_data, struct composite_context);
356 s = talloc_get_type(c->private_data, struct rpc_connect_dc_state);
357
358 c->status = libnet_RpcConnectSrv_recv(ctx, s->ctx, c, &s->r2);
359
360 /* error string is to be passed anyway */
361 s->r.out.error_string = s->r2.out.error_string;
362 if (!composite_is_ok(c)) return;
363
364 s->r.out.dcerpc_pipe = s->r2.out.dcerpc_pipe;
365
366 /* post monitor message */
367 if (s->monitor_fn) {
368 struct monitor_msg msg;
369 struct msg_net_rpc_connect data;
370 const struct dcerpc_binding *b = s->r.out.dcerpc_pipe->binding;
371
372 data.host = dcerpc_binding_get_string_option(b, "host");
373 data.endpoint = dcerpc_binding_get_string_option(b, "endpoint");
374 data.transport = dcerpc_binding_get_transport(b);
375 data.domain_name = dcerpc_binding_get_string_option(b, "target_hostname");
376
377 msg.type = mon_NetRpcConnect;
378 msg.data = (void*)&data;
379 msg.data_size = sizeof(data);
380 s->monitor_fn(&msg);
381 }
382
383 composite_done(c);
384 }
385
386
387 /**
388 * Receives result of connection to rpc pipe on domain pdc
389 *
390 * @param c composite context
391 * @param ctx initialised libnet context
392 * @param mem_ctx memory context of this call
393 * @param r data structure containing necessary parameters and return values
394 * @return nt status of rpc connection
395 **/
396
397 static NTSTATUS libnet_RpcConnectDC_recv(struct composite_context *c,
398 struct libnet_context *ctx,
399 TALLOC_CTX *mem_ctx,
400 struct libnet_RpcConnect *r)
401 {
402 NTSTATUS status;
403 struct rpc_connect_dc_state *s = talloc_get_type(c->private_data,
404 struct rpc_connect_dc_state);
405
406 status = composite_wait(c);
407 if (NT_STATUS_IS_OK(status)) {
408 /* move connected rpc pipe between memory contexts
409
410 The use of talloc_reparent(talloc_parent(), ...) is
411 bizarre, but it is needed because of the absolutely
412 atrocious use of talloc in this code. We need to
413 force the original parent to change, but finding
414 the original parent is well nigh impossible at this
415 point in the code (yes, I tried).
416 */
417 r->out.dcerpc_pipe = talloc_reparent(talloc_parent(s->r.out.dcerpc_pipe),
418 mem_ctx, s->r.out.dcerpc_pipe);
419
420 /* reference created pipe structure to long-term libnet_context
421 so that it can be used by other api functions even after short-term
422 mem_ctx is freed */
423 if (r->in.dcerpc_iface == &ndr_table_samr) {
424 ctx->samr.pipe = talloc_reference(ctx, r->out.dcerpc_pipe);
425 ctx->samr.samr_handle = ctx->samr.pipe->binding_handle;
426 } else if (r->in.dcerpc_iface == &ndr_table_lsarpc) {
427 ctx->lsa.pipe = talloc_reference(ctx, r->out.dcerpc_pipe);
428 ctx->lsa.lsa_handle = ctx->lsa.pipe->binding_handle;
429 }
430
431 } else {
432 r->out.error_string = talloc_asprintf(mem_ctx,
433 "Failed to rpc connect: %s",
434 nt_errstr(status));
435 }
436
437 talloc_free(c);
438 return status;
439 }
440
441
442
443 struct rpc_connect_dci_state {
444 struct libnet_context *ctx;
445 struct libnet_RpcConnect r;
446 struct libnet_RpcConnect rpc_conn;
447 struct policy_handle lsa_handle;
448 struct lsa_QosInfo qos;
449 struct lsa_ObjectAttribute attr;
450 struct lsa_OpenPolicy2 lsa_open_policy;
451 struct dcerpc_pipe *lsa_pipe;
452 struct lsa_QueryInfoPolicy2 lsa_query_info2;
453 struct lsa_QueryInfoPolicy lsa_query_info;
454 struct dcerpc_binding *final_binding;
455 struct dcerpc_pipe *final_pipe;
456
457 /* information about the progress */
458 void (*monitor_fn)(struct monitor_msg*);
459 };
460
461
462 static void continue_dci_rpc_connect(struct composite_context *ctx);
463 static void continue_lsa_policy(struct tevent_req *subreq);
464 static void continue_lsa_query_info(struct tevent_req *subreq);
465 static void continue_lsa_query_info2(struct tevent_req *subreq);
466 static void continue_epm_map_binding(struct composite_context *ctx);
467 static void continue_secondary_conn(struct composite_context *ctx);
468 static void continue_epm_map_binding_send(struct composite_context *c);
469
470
471 /**
472 * Initiates connection to rpc pipe on remote server or pdc. Received result
473 * contains info on the domain name, domain sid and realm.
474 *
475 * @param ctx initialised libnet context
476 * @param mem_ctx memory context of this call
477 * @param r data structure containing necessary parameters and return values. Must be a talloc context
478 * @return composite context of this call
479 **/
480
481 static struct composite_context* libnet_RpcConnectDCInfo_send(struct libnet_context *ctx,
482 TALLOC_CTX *mem_ctx,
483 struct libnet_RpcConnect *r,
484 void (*monitor)(struct monitor_msg*))
485 {
486 struct composite_context *c, *conn_req;
487 struct rpc_connect_dci_state *s;
488
489 /* composite context allocation and setup */
490 c = composite_create(ctx, ctx->event_ctx);
491 if (c == NULL) return c;
492
493 s = talloc_zero(c, struct rpc_connect_dci_state);
494 if (composite_nomem(s, c)) return c;
495
496 c->private_data = s;
497 s->monitor_fn = monitor;
498
499 s->ctx = ctx;
500 s->r = *r;
501 ZERO_STRUCT(s->r.out);
502
503
504 /* proceed to pure rpc connection if the binding string is provided,
505 otherwise try to connect domain controller */
506 if (r->in.binding == NULL) {
507 /* Pass on any binding flags (such as anonymous fallback) that have been set */
508 s->rpc_conn.in.dcerpc_flags = r->in.dcerpc_flags;
509
510 s->rpc_conn.in.name = r->in.name;
511 s->rpc_conn.level = LIBNET_RPC_CONNECT_DC;
512 } else {
513 s->rpc_conn.in.binding = r->in.binding;
514 s->rpc_conn.level = LIBNET_RPC_CONNECT_BINDING;
515 }
516
517 /* we need to query information on lsarpc interface first */
518 s->rpc_conn.in.dcerpc_iface = &ndr_table_lsarpc;
519
520 /* request connection to the lsa pipe on the pdc */
521 conn_req = libnet_RpcConnect_send(ctx, c, &s->rpc_conn, s->monitor_fn);
522 if (composite_nomem(c, conn_req)) return c;
523
524 composite_continue(c, conn_req, continue_dci_rpc_connect, c);
525 return c;
526 }
527
528
529 /*
530 Step 2 of RpcConnectDCInfo: receive opened rpc pipe and open
531 lsa policy handle
532 */
533 static void continue_dci_rpc_connect(struct composite_context *ctx)
534 {
535 struct composite_context *c;
536 struct rpc_connect_dci_state *s;
537 struct tevent_req *subreq;
538 enum dcerpc_transport_t transport;
539
540 c = talloc_get_type(ctx->async.private_data, struct composite_context);
541 s = talloc_get_type(c->private_data, struct rpc_connect_dci_state);
542
543 c->status = libnet_RpcConnect_recv(ctx, s->ctx, c, &s->rpc_conn);
544 if (!NT_STATUS_IS_OK(c->status)) {
545 composite_error(c, c->status);
546 return;
547 }
548
549 /* post monitor message */
550 if (s->monitor_fn) {
551 struct monitor_msg msg;
552 struct msg_net_rpc_connect data;
553 const struct dcerpc_binding *b = s->r.out.dcerpc_pipe->binding;
554
555 data.host = dcerpc_binding_get_string_option(b, "host");
556 data.endpoint = dcerpc_binding_get_string_option(b, "endpoint");
557 data.transport = dcerpc_binding_get_transport(b);
558 data.domain_name = dcerpc_binding_get_string_option(b, "target_hostname");
559
560 msg.type = mon_NetRpcConnect;
561 msg.data = (void*)&data;
562 msg.data_size = sizeof(data);
563 s->monitor_fn(&msg);
564 }
565
566 /* prepare to open a policy handle on lsa pipe */
567 s->lsa_pipe = s->ctx->lsa.pipe;
568
569 s->qos.len = 0;
570 s->qos.impersonation_level = 2;
571 s->qos.context_mode = 1;
572 s->qos.effective_only = 0;
573
574 s->attr.sec_qos = &s->qos;
575
576 transport = dcerpc_binding_get_transport(s->lsa_pipe->binding);
577 if (transport == NCACN_IP_TCP) {
578 /*
579 * Skip to creating the actual connection. We can't open a
580 * policy handle over tcpip.
581 */
582 continue_epm_map_binding_send(c);
583 return;
584 }
585
586 s->lsa_open_policy.in.attr = &s->attr;
587 s->lsa_open_policy.in.system_name = talloc_asprintf(c, "\\");
588 if (composite_nomem(s->lsa_open_policy.in.system_name, c)) return;
589
590 s->lsa_open_policy.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
591 s->lsa_open_policy.out.handle = &s->lsa_handle;
592
593 subreq = dcerpc_lsa_OpenPolicy2_r_send(s, c->event_ctx,
594 s->lsa_pipe->binding_handle,
595 &s->lsa_open_policy);
596 if (composite_nomem(subreq, c)) return;
597
598 tevent_req_set_callback(subreq, continue_lsa_policy, c);
599 }
600
601
602 /*
603 Step 3 of RpcConnectDCInfo: Get policy handle and query lsa info
604 for kerberos realm (dns name) and guid. The query may fail.
605 */
606 static void continue_lsa_policy(struct tevent_req *subreq)
607 {
608 struct composite_context *c;
609 struct rpc_connect_dci_state *s;
610
611 c = tevent_req_callback_data(subreq, struct composite_context);
612 s = talloc_get_type(c->private_data, struct rpc_connect_dci_state);
613
614 c->status = dcerpc_lsa_OpenPolicy2_r_recv(subreq, s);
615 TALLOC_FREE(subreq);
616 if (!NT_STATUS_IS_OK(c->status)) {
617 composite_error(c, c->status);
618 return;
619 }
620
621 if (NT_STATUS_EQUAL(s->lsa_open_policy.out.result, NT_STATUS_RPC_PROTSEQ_NOT_SUPPORTED)) {
622 s->r.out.realm = NULL;
623 s->r.out.guid = NULL;
624 s->r.out.domain_name = NULL;
625 s->r.out.domain_sid = NULL;
626
627 /* Skip to the creating the actual connection, no info available on this transport */
628 continue_epm_map_binding_send(c);
629 return;
630
631 } else if (!NT_STATUS_IS_OK(s->lsa_open_policy.out.result)) {
632 composite_error(c, s->lsa_open_policy.out.result);
633 return;
634 }
635
636 /* post monitor message */
637 if (s->monitor_fn) {
638 struct monitor_msg msg;
639
640 msg.type = mon_LsaOpenPolicy;
641 msg.data = NULL;
642 msg.data_size = 0;
643 s->monitor_fn(&msg);
644 }
645
646 /* query lsa info for dns domain name and guid */
647 s->lsa_query_info2.in.handle = &s->lsa_handle;
648 s->lsa_query_info2.in.level = LSA_POLICY_INFO_DNS;
649 s->lsa_query_info2.out.info = talloc_zero(c, union lsa_PolicyInformation *);
650 if (composite_nomem(s->lsa_query_info2.out.info, c)) return;
651
652 subreq = dcerpc_lsa_QueryInfoPolicy2_r_send(s, c->event_ctx,
653 s->lsa_pipe->binding_handle,
654 &s->lsa_query_info2);
655 if (composite_nomem(subreq, c)) return;
656
657 tevent_req_set_callback(subreq, continue_lsa_query_info2, c);
658 }
659
660
661 /*
662 Step 4 of RpcConnectDCInfo: Get realm and guid if provided (rpc call
663 may result in failure) and query lsa info for domain name and sid.
664 */
665 static void continue_lsa_query_info2(struct tevent_req *subreq)
666 {
667 struct composite_context *c;
668 struct rpc_connect_dci_state *s;
669
670 c = tevent_req_callback_data(subreq, struct composite_context);
671 s = talloc_get_type(c->private_data, struct rpc_connect_dci_state);
672
673 c->status = dcerpc_lsa_QueryInfoPolicy2_r_recv(subreq, s);
674 TALLOC_FREE(subreq);
675
676 /* In case of error just null the realm and guid and proceed
677 to the next step. After all, it doesn't have to be AD domain
678 controller we talking to - NT-style PDC also counts */
679
680 if (NT_STATUS_EQUAL(c->status, NT_STATUS_RPC_PROCNUM_OUT_OF_RANGE)) {
681 s->r.out.realm = NULL;
682 s->r.out.guid = NULL;
683
684 } else {
685 if (!NT_STATUS_IS_OK(c->status)) {
686 s->r.out.error_string = talloc_asprintf(c,
687 "lsa_QueryInfoPolicy2 failed: %s",
688 nt_errstr(c->status));
689 composite_error(c, c->status);
690 return;
691 }
692
693 if (!NT_STATUS_IS_OK(s->lsa_query_info2.out.result)) {
694 s->r.out.error_string = talloc_asprintf(c,
695 "lsa_QueryInfoPolicy2 failed: %s",
696 nt_errstr(s->lsa_query_info2.out.result));
697 composite_error(c, s->lsa_query_info2.out.result);
698 return;
699 }
700
701 /* Copy the dns domain name and guid from the query result */
702
703 /* this should actually be a conversion from lsa_StringLarge */
704 s->r.out.realm = (*s->lsa_query_info2.out.info)->dns.dns_domain.string;
705 s->r.out.guid = talloc(c, struct GUID);
706 if (composite_nomem(s->r.out.guid, c)) {
707 s->r.out.error_string = NULL;
708 return;
709 }
710 *s->r.out.guid = (*s->lsa_query_info2.out.info)->dns.domain_guid;
711 }
712
713 /* post monitor message */
714 if (s->monitor_fn) {
715 struct monitor_msg msg;
716
717 msg.type = mon_LsaQueryPolicy;
718 msg.data = NULL;
719 msg.data_size = 0;
720 s->monitor_fn(&msg);
721 }
722
723 /* query lsa info for domain name and sid */
724 s->lsa_query_info.in.handle = &s->lsa_handle;
725 s->lsa_query_info.in.level = LSA_POLICY_INFO_DOMAIN;
726 s->lsa_query_info.out.info = talloc_zero(c, union lsa_PolicyInformation *);
727 if (composite_nomem(s->lsa_query_info.out.info, c)) return;
728
729 subreq = dcerpc_lsa_QueryInfoPolicy_r_send(s, c->event_ctx,
730 s->lsa_pipe->binding_handle,
731 &s->lsa_query_info);
732 if (composite_nomem(subreq, c)) return;
733
734 tevent_req_set_callback(subreq, continue_lsa_query_info, c);
735 }
736
737
738 /*
739 Step 5 of RpcConnectDCInfo: Get domain name and sid
740 */
741 static void continue_lsa_query_info(struct tevent_req *subreq)
742 {
743 struct composite_context *c;
744 struct rpc_connect_dci_state *s;
745
746 c = tevent_req_callback_data(subreq, struct composite_context);
747 s = talloc_get_type(c->private_data, struct rpc_connect_dci_state);
748
749 c->status = dcerpc_lsa_QueryInfoPolicy_r_recv(subreq, s);
750 TALLOC_FREE(subreq);
751 if (!NT_STATUS_IS_OK(c->status)) {
752 s->r.out.error_string = talloc_asprintf(c,
753 "lsa_QueryInfoPolicy failed: %s",
754 nt_errstr(c->status));
755 composite_error(c, c->status);
756 return;
757 }
758
759 /* post monitor message */
760 if (s->monitor_fn) {
761 struct monitor_msg msg;
762
763 msg.type = mon_LsaQueryPolicy;
764 msg.data = NULL;
765 msg.data_size = 0;
766 s->monitor_fn(&msg);
767 }
768
769 /* Copy the domain name and sid from the query result */
770 s->r.out.domain_sid = (*s->lsa_query_info.out.info)->domain.sid;
771 s->r.out.domain_name = (*s->lsa_query_info.out.info)->domain.name.string;
772
773 continue_epm_map_binding_send(c);
774 }
775
776 /*
777 Step 5 (continued) of RpcConnectDCInfo: request endpoint
778 map binding.
779
780 We may short-cut to this step if we don't support LSA OpenPolicy on this transport
781 */
782 static void continue_epm_map_binding_send(struct composite_context *c)
783 {
784 struct rpc_connect_dci_state *s;
785 struct composite_context *epm_map_req;
786 struct cli_credentials *epm_creds = NULL;
787
788 s = talloc_get_type(c->private_data, struct rpc_connect_dci_state);
789
790 /* prepare to get endpoint mapping for the requested interface */
791 s->final_binding = dcerpc_binding_dup(s, s->lsa_pipe->binding);
792 if (composite_nomem(s->final_binding, c)) return;
793
794 epm_creds = cli_credentials_init_anon(s);
795 if (composite_nomem(epm_creds, c)) return;
796
797 epm_map_req = dcerpc_epm_map_binding_send(c, s->final_binding, s->r.in.dcerpc_iface,
798 epm_creds,
799 s->ctx->event_ctx, s->ctx->lp_ctx);
800 if (composite_nomem(epm_map_req, c)) return;
801
802 composite_continue(c, epm_map_req, continue_epm_map_binding, c);
803 }
804
805 /*
806 Step 6 of RpcConnectDCInfo: Receive endpoint mapping and create secondary
807 rpc connection derived from already used pipe but connected to the requested
808 one (as specified in libnet_RpcConnect structure)
809 */
810 static void continue_epm_map_binding(struct composite_context *ctx)
811 {
812 struct composite_context *c, *sec_conn_req;
813 struct rpc_connect_dci_state *s;
814
815 c = talloc_get_type(ctx->async.private_data, struct composite_context);
816 s = talloc_get_type(c->private_data, struct rpc_connect_dci_state);
817
818 c->status = dcerpc_epm_map_binding_recv(ctx);
819 if (!NT_STATUS_IS_OK(c->status)) {
820 s->r.out.error_string = talloc_asprintf(c,
821 "failed to map pipe with endpoint mapper - %s",
822 nt_errstr(c->status));
823 composite_error(c, c->status);
824 return;
825 }
826
827 /* create secondary connection derived from lsa pipe */
828 sec_conn_req = dcerpc_secondary_connection_send(s->lsa_pipe, s->final_binding);
829 if (composite_nomem(sec_conn_req, c)) return;
830
831 composite_continue(c, sec_conn_req, continue_secondary_conn, c);
832 }
833
834
835 /*
836 Step 7 of RpcConnectDCInfo: Get actual pipe to be returned
837 and complete this composite call
838 */
839 static void continue_secondary_conn(struct composite_context *ctx)
840 {
841 struct composite_context *c;
842 struct rpc_connect_dci_state *s;
843
844 c = talloc_get_type(ctx->async.private_data, struct composite_context);
845 s = talloc_get_type(c->private_data, struct rpc_connect_dci_state);
846
847 c->status = dcerpc_secondary_connection_recv(ctx, &s->final_pipe);
848 if (!NT_STATUS_IS_OK(c->status)) {
849 s->r.out.error_string = talloc_asprintf(c,
850 "secondary connection failed: %s",
851 nt_errstr(c->status));
852
853 composite_error(c, c->status);
854 return;
855 }
856
857 s->r.out.dcerpc_pipe = s->final_pipe;
858
859 /* post monitor message */
860 if (s->monitor_fn) {
861 struct monitor_msg msg;
862 struct msg_net_rpc_connect data;
863 const struct dcerpc_binding *b = s->r.out.dcerpc_pipe->binding;
864
865 /* prepare monitor message and post it */
866 data.host = dcerpc_binding_get_string_option(b, "host");
867 data.endpoint = dcerpc_binding_get_string_option(b, "endpoint");
868 data.transport = dcerpc_binding_get_transport(b);
869 data.domain_name = dcerpc_binding_get_string_option(b, "target_hostname");
870
871 msg.type = mon_NetRpcConnect;
872 msg.data = (void*)&data;
873 msg.data_size = sizeof(data);
874 s->monitor_fn(&msg);
875 }
876
877 composite_done(c);
878 }
879
880
881 /**
882 * Receives result of connection to rpc pipe and gets basic
883 * domain info (name, sid, realm, guid)
884 *
885 * @param c composite context
886 * @param ctx initialised libnet context
887 * @param mem_ctx memory context of this call
888 * @param r data structure containing return values
889 * @return nt status of rpc connection
890 **/
891
892 static NTSTATUS libnet_RpcConnectDCInfo_recv(struct composite_context *c, struct libnet_context *ctx,
893 TALLOC_CTX *mem_ctx, struct libnet_RpcConnect *r)
894 {
895 NTSTATUS status;
896 struct rpc_connect_dci_state *s = talloc_get_type(c->private_data,
897 struct rpc_connect_dci_state);
898
899 status = composite_wait(c);
900 if (NT_STATUS_IS_OK(status)) {
901 r->out.realm = talloc_steal(mem_ctx, s->r.out.realm);
902 r->out.guid = talloc_steal(mem_ctx, s->r.out.guid);
903 r->out.domain_name = talloc_steal(mem_ctx, s->r.out.domain_name);
904 r->out.domain_sid = talloc_steal(mem_ctx, s->r.out.domain_sid);
905
906 r->out.dcerpc_pipe = talloc_steal(mem_ctx, s->r.out.dcerpc_pipe);
907
908 /* reference created pipe structure to long-term libnet_context
909 so that it can be used by other api functions even after short-term
910 mem_ctx is freed */
911 if (r->in.dcerpc_iface == &ndr_table_samr) {
912 ctx->samr.pipe = talloc_reference(ctx, r->out.dcerpc_pipe);
913 ctx->samr.samr_handle = ctx->samr.pipe->binding_handle;
914
915 } else if (r->in.dcerpc_iface == &ndr_table_lsarpc) {
916 ctx->lsa.pipe = talloc_reference(ctx, r->out.dcerpc_pipe);
917 ctx->lsa.lsa_handle = ctx->lsa.pipe->binding_handle;
918 }
919
920 } else {
921 if (s->r.out.error_string) {
922 r->out.error_string = talloc_steal(mem_ctx, s->r.out.error_string);
923 } else if (r->in.binding == NULL) {
924 r->out.error_string = talloc_asprintf(mem_ctx, "Connection to DC failed: %s", nt_errstr(status));
925 } else {
926 r->out.error_string = talloc_asprintf(mem_ctx, "Connection to DC %s failed: %s",
927 r->in.binding, nt_errstr(status));
928 }
929 }
930
931 talloc_free(c);
932 return status;
933 }
934
935
936 /**
937 * Initiates connection to rpc pipe on remote server or pdc, optionally
938 * providing domain info
939 *
940 * @param ctx initialised libnet context
941 * @param mem_ctx memory context of this call
942 * @param r data structure containing necessary parameters and return values
943 * @return composite context of this call
944 **/
945
946 struct composite_context* libnet_RpcConnect_send(struct libnet_context *ctx,
947 TALLOC_CTX *mem_ctx,
948 struct libnet_RpcConnect *r,
949 void (*monitor)(struct monitor_msg*))
950 {
951 struct composite_context *c;
952
953 switch (r->level) {
954 case LIBNET_RPC_CONNECT_SERVER:
955 case LIBNET_RPC_CONNECT_SERVER_ADDRESS:
956 case LIBNET_RPC_CONNECT_BINDING:
957 c = libnet_RpcConnectSrv_send(ctx, mem_ctx, r, monitor);
958 break;
959
960 case LIBNET_RPC_CONNECT_PDC:
961 case LIBNET_RPC_CONNECT_DC:
962 c = libnet_RpcConnectDC_send(ctx, mem_ctx, r, monitor);
963 break;
964
965 case LIBNET_RPC_CONNECT_DC_INFO:
966 c = libnet_RpcConnectDCInfo_send(ctx, mem_ctx, r, monitor);
967 break;
968
969 default:
970 c = talloc_zero(mem_ctx, struct composite_context);
971 composite_error(c, NT_STATUS_INVALID_LEVEL);
972 }
973
974 return c;
975 }
976
977
978 /**
979 * Receives result of connection to rpc pipe on remote server or pdc
980 *
981 * @param c composite context
982 * @param ctx initialised libnet context
983 * @param mem_ctx memory context of this call
984 * @param r data structure containing necessary parameters and return values
985 * @return nt status of rpc connection
986 **/
987
988 NTSTATUS libnet_RpcConnect_recv(struct composite_context *c, struct libnet_context *ctx,
989 TALLOC_CTX *mem_ctx, struct libnet_RpcConnect *r)
990 {
991 switch (r->level) {
992 case LIBNET_RPC_CONNECT_SERVER:
993 case LIBNET_RPC_CONNECT_BINDING:
994 return libnet_RpcConnectSrv_recv(c, ctx, mem_ctx, r);
995
996 case LIBNET_RPC_CONNECT_PDC:
997 case LIBNET_RPC_CONNECT_DC:
998 return libnet_RpcConnectDC_recv(c, ctx, mem_ctx, r);
999
1000 case LIBNET_RPC_CONNECT_DC_INFO:
1001 return libnet_RpcConnectDCInfo_recv(c, ctx, mem_ctx, r);
1002
1003 default:
1004 ZERO_STRUCT(r->out);
1005 return NT_STATUS_INVALID_LEVEL;
1006 }
1007 }
1008
1009
1010 /**
1011 * Connect to a rpc pipe on a remote server - sync version
1012 *
1013 * @param ctx initialised libnet context
1014 * @param mem_ctx memory context of this call
1015 * @param r data structure containing necessary parameters and return values
1016 * @return nt status of rpc connection
1017 **/
1018
1019 NTSTATUS libnet_RpcConnect(struct libnet_context *ctx, TALLOC_CTX *mem_ctx,
1020 struct libnet_RpcConnect *r)
1021 {
1022 struct composite_context *c;
1023
1024 c = libnet_RpcConnect_send(ctx, mem_ctx, r, NULL);
1025 return libnet_RpcConnect_recv(c, ctx, mem_ctx, r);
1026 }
Samba GIT mirror