?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Allow us to cope correctly with NT_STATUS_MORE_PROCESSING_REQUIRED when downgrading...
[Samba/ekacnet.git] / source4 / rpc_server / dcerpc_server.c
blob774309996dd7b2bb1a7465b894127f478cf19ed2
1 /*
2 Unix SMB/CIFS implementation.
3
4 server side dcerpc core code
5
6 Copyright (C) Andrew Tridgell 2003-2005
7 Copyright (C) Stefan (metze) Metzmacher 2004-2005
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 "includes.h"
24 #include "auth/auth.h"
25 #include "auth/gensec/gensec.h"
26 #include "../lib/util/dlinklist.h"
27 #include "rpc_server/dcerpc_server.h"
28 #include "rpc_server/dcerpc_server_proto.h"
29 #include "librpc/rpc/dcerpc_proto.h"
30 #include "system/filesys.h"
31 #include "libcli/security/security.h"
32 #include "param/param.h"
33
34 /* this is only used when the client asks for an unknown interface */
35 #define DUMMY_ASSOC_GROUP 0x0FFFFFFF
36
37 extern const struct dcesrv_interface dcesrv_mgmt_interface;
38
39
40 /*
41 find an association group given a assoc_group_id
42 */
43 static struct dcesrv_assoc_group *dcesrv_assoc_group_find(struct dcesrv_context *dce_ctx,
44 uint32_t id)
45 {
46 void *id_ptr;
47
48 id_ptr = idr_find(dce_ctx->assoc_groups_idr, id);
49 if (id_ptr == NULL) {
50 return NULL;
51 }
52 return talloc_get_type_abort(id_ptr, struct dcesrv_assoc_group);
53 }
54
55 /*
56 take a reference to an existing association group
57 */
58 static struct dcesrv_assoc_group *dcesrv_assoc_group_reference(TALLOC_CTX *mem_ctx,
59 struct dcesrv_context *dce_ctx,
60 uint32_t id)
61 {
62 struct dcesrv_assoc_group *assoc_group;
63
64 assoc_group = dcesrv_assoc_group_find(dce_ctx, id);
65 if (assoc_group == NULL) {
66 DEBUG(0,(__location__ ": Failed to find assoc_group 0x%08x\n", id));
67 return NULL;
68 }
69 return talloc_reference(mem_ctx, assoc_group);
70 }
71
72 static int dcesrv_assoc_group_destructor(struct dcesrv_assoc_group *assoc_group)
73 {
74 int ret;
75 ret = idr_remove(assoc_group->dce_ctx->assoc_groups_idr, assoc_group->id);
76 if (ret != 0) {
77 DEBUG(0,(__location__ ": Failed to remove assoc_group 0x%08x\n",
78 assoc_group->id));
79 }
80 return 0;
81 }
82
83 /*
84 allocate a new association group
85 */
86 static struct dcesrv_assoc_group *dcesrv_assoc_group_new(TALLOC_CTX *mem_ctx,
87 struct dcesrv_context *dce_ctx)
88 {
89 struct dcesrv_assoc_group *assoc_group;
90 int id;
91
92 assoc_group = talloc_zero(mem_ctx, struct dcesrv_assoc_group);
93 if (assoc_group == NULL) {
94 return NULL;
95 }
96
97 id = idr_get_new_random(dce_ctx->assoc_groups_idr, assoc_group, UINT16_MAX);
98 if (id == -1) {
99 talloc_free(assoc_group);
100 DEBUG(0,(__location__ ": Out of association groups!\n"));
101 return NULL;
102 }
103
104 assoc_group->id = id;
105 assoc_group->dce_ctx = dce_ctx;
106
107 talloc_set_destructor(assoc_group, dcesrv_assoc_group_destructor);
108
109 return assoc_group;
110 }
111
112
113 /*
114 see if two endpoints match
115 */
116 static bool endpoints_match(const struct dcerpc_binding *ep1,
117 const struct dcerpc_binding *ep2)
118 {
119 if (ep1->transport != ep2->transport) {
120 return false;
121 }
122
123 if (!ep1->endpoint || !ep2->endpoint) {
124 return ep1->endpoint == ep2->endpoint;
125 }
126
127 if (strcasecmp(ep1->endpoint, ep2->endpoint) != 0)
128 return false;
129
130 return true;
131 }
132
133 /*
134 find an endpoint in the dcesrv_context
135 */
136 static struct dcesrv_endpoint *find_endpoint(struct dcesrv_context *dce_ctx,
137 const struct dcerpc_binding *ep_description)
138 {
139 struct dcesrv_endpoint *ep;
140 for (ep=dce_ctx->endpoint_list; ep; ep=ep->next) {
141 if (endpoints_match(ep->ep_description, ep_description)) {
142 return ep;
143 }
144 }
145 return NULL;
146 }
147
148 /*
149 find a registered context_id from a bind or alter_context
150 */
151 static struct dcesrv_connection_context *dcesrv_find_context(struct dcesrv_connection *conn,
152 uint32_t context_id)
153 {
154 struct dcesrv_connection_context *c;
155 for (c=conn->contexts;c;c=c->next) {
156 if (c->context_id == context_id) return c;
157 }
158 return NULL;
159 }
160
161 /*
162 see if a uuid and if_version match to an interface
163 */
164 static bool interface_match(const struct dcesrv_interface *if1,
165 const struct dcesrv_interface *if2)
166 {
167 return (if1->syntax_id.if_version == if2->syntax_id.if_version &&
168 GUID_equal(&if1->syntax_id.uuid, &if2->syntax_id.uuid));
169 }
170
171 /*
172 find the interface operations on an endpoint
173 */
174 static const struct dcesrv_interface *find_interface(const struct dcesrv_endpoint *endpoint,
175 const struct dcesrv_interface *iface)
176 {
177 struct dcesrv_if_list *ifl;
178 for (ifl=endpoint->interface_list; ifl; ifl=ifl->next) {
179 if (interface_match(&(ifl->iface), iface)) {
180 return &(ifl->iface);
181 }
182 }
183 return NULL;
184 }
185
186 /*
187 see if a uuid and if_version match to an interface
188 */
189 static bool interface_match_by_uuid(const struct dcesrv_interface *iface,
190 const struct GUID *uuid, uint32_t if_version)
191 {
192 return (iface->syntax_id.if_version == if_version &&
193 GUID_equal(&iface->syntax_id.uuid, uuid));
194 }
195
196 /*
197 find the interface operations on an endpoint by uuid
198 */
199 static const struct dcesrv_interface *find_interface_by_uuid(const struct dcesrv_endpoint *endpoint,
200 const struct GUID *uuid, uint32_t if_version)
201 {
202 struct dcesrv_if_list *ifl;
203 for (ifl=endpoint->interface_list; ifl; ifl=ifl->next) {
204 if (interface_match_by_uuid(&(ifl->iface), uuid, if_version)) {
205 return &(ifl->iface);
206 }
207 }
208 return NULL;
209 }
210
211 /*
212 find the earlier parts of a fragmented call awaiting reassembily
213 */
214 static struct dcesrv_call_state *dcesrv_find_fragmented_call(struct dcesrv_connection *dce_conn, uint16_t call_id)
215 {
216 struct dcesrv_call_state *c;
217 for (c=dce_conn->incoming_fragmented_call_list;c;c=c->next) {
218 if (c->pkt.call_id == call_id) {
219 return c;
220 }
221 }
222 return NULL;
223 }
224
225 /*
226 register an interface on an endpoint
227 */
228 _PUBLIC_ NTSTATUS dcesrv_interface_register(struct dcesrv_context *dce_ctx,
229 const char *ep_name,
230 const struct dcesrv_interface *iface,
231 const struct security_descriptor *sd)
232 {
233 struct dcesrv_endpoint *ep;
234 struct dcesrv_if_list *ifl;
235 struct dcerpc_binding *binding;
236 bool add_ep = false;
237 NTSTATUS status;
238
239 status = dcerpc_parse_binding(dce_ctx, ep_name, &binding);
240
241 if (NT_STATUS_IS_ERR(status)) {
242 DEBUG(0, ("Trouble parsing binding string '%s'\n", ep_name));
243 return status;
244 }
245
246 /* check if this endpoint exists
247 */
248 if ((ep=find_endpoint(dce_ctx, binding))==NULL) {
249 ep = talloc(dce_ctx, struct dcesrv_endpoint);
250 if (!ep) {
251 return NT_STATUS_NO_MEMORY;
252 }
253 ZERO_STRUCTP(ep);
254 ep->ep_description = talloc_reference(ep, binding);
255 add_ep = true;
256
257 /* add mgmt interface */
258 ifl = talloc(dce_ctx, struct dcesrv_if_list);
259 if (!ifl) {
260 return NT_STATUS_NO_MEMORY;
261 }
262
263 memcpy(&(ifl->iface), &dcesrv_mgmt_interface,
264 sizeof(struct dcesrv_interface));
265
266 DLIST_ADD(ep->interface_list, ifl);
267 }
268
269 /* see if the interface is already registered on te endpoint */
270 if (find_interface(ep, iface)!=NULL) {
271 DEBUG(0,("dcesrv_interface_register: interface '%s' already registered on endpoint '%s'\n",
272 iface->name, ep_name));
273 return NT_STATUS_OBJECT_NAME_COLLISION;
274 }
275
276 /* talloc a new interface list element */
277 ifl = talloc(dce_ctx, struct dcesrv_if_list);
278 if (!ifl) {
279 return NT_STATUS_NO_MEMORY;
280 }
281
282 /* copy the given interface struct to the one on the endpoints interface list */
283 memcpy(&(ifl->iface),iface, sizeof(struct dcesrv_interface));
284
285 /* if we have a security descriptor given,
286 * we should see if we can set it up on the endpoint
287 */
288 if (sd != NULL) {
289 /* if there's currently no security descriptor given on the endpoint
290 * we try to set it
291 */
292 if (ep->sd == NULL) {
293 ep->sd = security_descriptor_copy(dce_ctx, sd);
294 }
295
296 /* if now there's no security descriptor given on the endpoint
297 * something goes wrong, either we failed to copy the security descriptor
298 * or there was already one on the endpoint
299 */
300 if (ep->sd != NULL) {
301 DEBUG(0,("dcesrv_interface_register: interface '%s' failed to setup a security descriptor\n"
302 " on endpoint '%s'\n",
303 iface->name, ep_name));
304 if (add_ep) free(ep);
305 free(ifl);
306 return NT_STATUS_OBJECT_NAME_COLLISION;
307 }
308 }
309
310 /* finally add the interface on the endpoint */
311 DLIST_ADD(ep->interface_list, ifl);
312
313 /* if it's a new endpoint add it to the dcesrv_context */
314 if (add_ep) {
315 DLIST_ADD(dce_ctx->endpoint_list, ep);
316 }
317
318 DEBUG(4,("dcesrv_interface_register: interface '%s' registered on endpoint '%s'\n",
319 iface->name, ep_name));
320
321 return NT_STATUS_OK;
322 }
323
324 NTSTATUS dcesrv_inherited_session_key(struct dcesrv_connection *p,
325 DATA_BLOB *session_key)
326 {
327 if (p->auth_state.session_info->session_key.length) {
328 *session_key = p->auth_state.session_info->session_key;
329 return NT_STATUS_OK;
330 }
331 return NT_STATUS_NO_USER_SESSION_KEY;
332 }
333
334 NTSTATUS dcesrv_generic_session_key(struct dcesrv_connection *c,
335 DATA_BLOB *session_key)
336 {
337 return dcerpc_generic_session_key(NULL, session_key);
338 }
339
340 /*
341 fetch the user session key - may be default (above) or the SMB session key
342
343 The key is always truncated to 16 bytes
344 */
345 _PUBLIC_ NTSTATUS dcesrv_fetch_session_key(struct dcesrv_connection *p,
346 DATA_BLOB *session_key)
347 {
348 NTSTATUS status = p->auth_state.session_key(p, session_key);
349 if (!NT_STATUS_IS_OK(status)) {
350 return status;
351 }
352
353 session_key->length = MIN(session_key->length, 16);
354
355 return NT_STATUS_OK;
356 }
357
358 /*
359 connect to a dcerpc endpoint
360 */
361 _PUBLIC_ NTSTATUS dcesrv_endpoint_connect(struct dcesrv_context *dce_ctx,
362 TALLOC_CTX *mem_ctx,
363 const struct dcesrv_endpoint *ep,
364 struct auth_session_info *session_info,
365 struct tevent_context *event_ctx,
366 struct messaging_context *msg_ctx,
367 struct server_id server_id,
368 uint32_t state_flags,
369 struct dcesrv_connection **_p)
370 {
371 struct dcesrv_connection *p;
372
373 if (!session_info) {
374 return NT_STATUS_ACCESS_DENIED;
375 }
376
377 p = talloc(mem_ctx, struct dcesrv_connection);
378 NT_STATUS_HAVE_NO_MEMORY(p);
379
380 if (!talloc_reference(p, session_info)) {
381 talloc_free(p);
382 return NT_STATUS_NO_MEMORY;
383 }
384
385 p->dce_ctx = dce_ctx;
386 p->endpoint = ep;
387 p->contexts = NULL;
388 p->call_list = NULL;
389 p->packet_log_dir = lp_lockdir(dce_ctx->lp_ctx);
390 p->incoming_fragmented_call_list = NULL;
391 p->pending_call_list = NULL;
392 p->cli_max_recv_frag = 0;
393 p->partial_input = data_blob(NULL, 0);
394 p->auth_state.auth_info = NULL;
395 p->auth_state.gensec_security = NULL;
396 p->auth_state.session_info = session_info;
397 p->auth_state.session_key = dcesrv_generic_session_key;
398 p->event_ctx = event_ctx;
399 p->msg_ctx = msg_ctx;
400 p->server_id = server_id;
401 p->processing = false;
402 p->state_flags = state_flags;
403 ZERO_STRUCT(p->transport);
404
405 *_p = p;
406 return NT_STATUS_OK;
407 }
408
409 static void dcesrv_init_hdr(struct ncacn_packet *pkt, bool bigendian)
410 {
411 pkt->rpc_vers = 5;
412 pkt->rpc_vers_minor = 0;
413 if (bigendian) {
414 pkt->drep[0] = 0;
415 } else {
416 pkt->drep[0] = DCERPC_DREP_LE;
417 }
418 pkt->drep[1] = 0;
419 pkt->drep[2] = 0;
420 pkt->drep[3] = 0;
421 }
422
423 /*
424 move a call from an existing linked list to the specified list. This
425 prevents bugs where we forget to remove the call from a previous
426 list when moving it.
427 */
428 static void dcesrv_call_set_list(struct dcesrv_call_state *call,
429 enum dcesrv_call_list list)
430 {
431 switch (call->list) {
432 case DCESRV_LIST_NONE:
433 break;
434 case DCESRV_LIST_CALL_LIST:
435 DLIST_REMOVE(call->conn->call_list, call);
436 break;
437 case DCESRV_LIST_FRAGMENTED_CALL_LIST:
438 DLIST_REMOVE(call->conn->incoming_fragmented_call_list, call);
439 break;
440 case DCESRV_LIST_PENDING_CALL_LIST:
441 DLIST_REMOVE(call->conn->pending_call_list, call);
442 break;
443 }
444 call->list = list;
445 switch (list) {
446 case DCESRV_LIST_NONE:
447 break;
448 case DCESRV_LIST_CALL_LIST:
449 DLIST_ADD_END(call->conn->call_list, call, struct dcesrv_call_state *);
450 break;
451 case DCESRV_LIST_FRAGMENTED_CALL_LIST:
452 DLIST_ADD_END(call->conn->incoming_fragmented_call_list, call, struct dcesrv_call_state *);
453 break;
454 case DCESRV_LIST_PENDING_CALL_LIST:
455 DLIST_ADD_END(call->conn->pending_call_list, call, struct dcesrv_call_state *);
456 break;
457 }
458 }
459
460 /*
461 return a dcerpc fault
462 */
463 static NTSTATUS dcesrv_fault(struct dcesrv_call_state *call, uint32_t fault_code)
464 {
465 struct ncacn_packet pkt;
466 struct data_blob_list_item *rep;
467 uint8_t zeros[4];
468 NTSTATUS status;
469
470 /* setup a bind_ack */
471 dcesrv_init_hdr(&pkt, lp_rpc_big_endian(call->conn->dce_ctx->lp_ctx));
472 pkt.auth_length = 0;
473 pkt.call_id = call->pkt.call_id;
474 pkt.ptype = DCERPC_PKT_FAULT;
475 pkt.pfc_flags = DCERPC_PFC_FLAG_FIRST | DCERPC_PFC_FLAG_LAST;
476 pkt.u.fault.alloc_hint = 0;
477 pkt.u.fault.context_id = 0;
478 pkt.u.fault.cancel_count = 0;
479 pkt.u.fault.status = fault_code;
480
481 ZERO_STRUCT(zeros);
482 pkt.u.fault._pad = data_blob_const(zeros, sizeof(zeros));
483
484 rep = talloc(call, struct data_blob_list_item);
485 if (!rep) {
486 return NT_STATUS_NO_MEMORY;
487 }
488
489 status = ncacn_push_auth(&rep->blob, call, &pkt, NULL);
490 if (!NT_STATUS_IS_OK(status)) {
491 return status;
492 }
493
494 dcerpc_set_frag_length(&rep->blob, rep->blob.length);
495
496 DLIST_ADD_END(call->replies, rep, struct data_blob_list_item *);
497 dcesrv_call_set_list(call, DCESRV_LIST_CALL_LIST);
498
499 if (call->conn->call_list && call->conn->call_list->replies) {
500 if (call->conn->transport.report_output_data) {
501 call->conn->transport.report_output_data(call->conn);
502 }
503 }
504
505 return NT_STATUS_OK;
506 }
507
508
509 /*
510 return a dcerpc bind_nak
511 */
512 static NTSTATUS dcesrv_bind_nak(struct dcesrv_call_state *call, uint32_t reason)
513 {
514 struct ncacn_packet pkt;
515 struct data_blob_list_item *rep;
516 NTSTATUS status;
517
518 /* setup a bind_nak */
519 dcesrv_init_hdr(&pkt, lp_rpc_big_endian(call->conn->dce_ctx->lp_ctx));
520 pkt.auth_length = 0;
521 pkt.call_id = call->pkt.call_id;
522 pkt.ptype = DCERPC_PKT_BIND_NAK;
523 pkt.pfc_flags = DCERPC_PFC_FLAG_FIRST | DCERPC_PFC_FLAG_LAST;
524 pkt.u.bind_nak.reject_reason = reason;
525 if (pkt.u.bind_nak.reject_reason == DECRPC_BIND_PROTOCOL_VERSION_NOT_SUPPORTED) {
526 pkt.u.bind_nak.versions.v.num_versions = 0;
527 }
528
529 rep = talloc(call, struct data_blob_list_item);
530 if (!rep) {
531 return NT_STATUS_NO_MEMORY;
532 }
533
534 status = ncacn_push_auth(&rep->blob, call, &pkt, NULL);
535 if (!NT_STATUS_IS_OK(status)) {
536 return status;
537 }
538
539 dcerpc_set_frag_length(&rep->blob, rep->blob.length);
540
541 DLIST_ADD_END(call->replies, rep, struct data_blob_list_item *);
542 dcesrv_call_set_list(call, DCESRV_LIST_CALL_LIST);
543
544 if (call->conn->call_list && call->conn->call_list->replies) {
545 if (call->conn->transport.report_output_data) {
546 call->conn->transport.report_output_data(call->conn);
547 }
548 }
549
550 return NT_STATUS_OK;
551 }
552
553 static int dcesrv_connection_context_destructor(struct dcesrv_connection_context *c)
554 {
555 DLIST_REMOVE(c->conn->contexts, c);
556
557 if (c->iface) {
558 c->iface->unbind(c, c->iface);
559 }
560
561 return 0;
562 }
563
564 /*
565 handle a bind request
566 */
567 static NTSTATUS dcesrv_bind(struct dcesrv_call_state *call)
568 {
569 uint32_t if_version, transfer_syntax_version;
570 struct GUID uuid, *transfer_syntax_uuid;
571 struct ncacn_packet pkt;
572 struct data_blob_list_item *rep;
573 NTSTATUS status;
574 uint32_t result=0, reason=0;
575 uint32_t context_id;
576 const struct dcesrv_interface *iface;
577 uint32_t extra_flags = 0;
578
579 /*
580 if provided, check the assoc_group is valid
581 */
582 if (call->pkt.u.bind.assoc_group_id != 0 &&
583 lp_parm_bool(call->conn->dce_ctx->lp_ctx, NULL, "dcesrv","assoc group checking", true) &&
584 dcesrv_assoc_group_find(call->conn->dce_ctx, call->pkt.u.bind.assoc_group_id) == NULL) {
585 return dcesrv_bind_nak(call, 0);
586 }
587
588 if (call->pkt.u.bind.num_contexts < 1 ||
589 call->pkt.u.bind.ctx_list[0].num_transfer_syntaxes < 1) {
590 return dcesrv_bind_nak(call, 0);
591 }
592
593 context_id = call->pkt.u.bind.ctx_list[0].context_id;
594
595 /* you can't bind twice on one context */
596 if (dcesrv_find_context(call->conn, context_id) != NULL) {
597 return dcesrv_bind_nak(call, 0);
598 }
599
600 if_version = call->pkt.u.bind.ctx_list[0].abstract_syntax.if_version;
601 uuid = call->pkt.u.bind.ctx_list[0].abstract_syntax.uuid;
602
603 transfer_syntax_version = call->pkt.u.bind.ctx_list[0].transfer_syntaxes[0].if_version;
604 transfer_syntax_uuid = &call->pkt.u.bind.ctx_list[0].transfer_syntaxes[0].uuid;
605 if (!GUID_equal(&ndr_transfer_syntax.uuid, transfer_syntax_uuid) != 0 ||
606 ndr_transfer_syntax.if_version != transfer_syntax_version) {
607 char *uuid_str = GUID_string(call, transfer_syntax_uuid);
608 /* we only do NDR encoded dcerpc */
609 DEBUG(0,("Non NDR transfer syntax requested - %s\n", uuid_str));
610 talloc_free(uuid_str);
611 return dcesrv_bind_nak(call, 0);
612 }
613
614 iface = find_interface_by_uuid(call->conn->endpoint, &uuid, if_version);
615 if (iface == NULL) {
616 char *uuid_str = GUID_string(call, &uuid);
617 DEBUG(2,("Request for unknown dcerpc interface %s/%d\n", uuid_str, if_version));
618 talloc_free(uuid_str);
619
620 /* we don't know about that interface */
621 result = DCERPC_BIND_PROVIDER_REJECT;
622 reason = DCERPC_BIND_REASON_ASYNTAX;
623 }
624
625 if (iface) {
626 /* add this context to the list of available context_ids */
627 struct dcesrv_connection_context *context = talloc(call->conn,
628 struct dcesrv_connection_context);
629 if (context == NULL) {
630 return dcesrv_bind_nak(call, 0);
631 }
632 context->conn = call->conn;
633 context->iface = iface;
634 context->context_id = context_id;
635 if (call->pkt.u.bind.assoc_group_id != 0) {
636 context->assoc_group = dcesrv_assoc_group_reference(context,
637 call->conn->dce_ctx,
638 call->pkt.u.bind.assoc_group_id);
639 } else {
640 context->assoc_group = dcesrv_assoc_group_new(context, call->conn->dce_ctx);
641 }
642 if (context->assoc_group == NULL) {
643 talloc_free(context);
644 return dcesrv_bind_nak(call, 0);
645 }
646 context->private_data = NULL;
647 DLIST_ADD(call->conn->contexts, context);
648 call->context = context;
649 talloc_set_destructor(context, dcesrv_connection_context_destructor);
650
651 status = iface->bind(call, iface, if_version);
652 if (!NT_STATUS_IS_OK(status)) {
653 char *uuid_str = GUID_string(call, &uuid);
654 DEBUG(2,("Request for dcerpc interface %s/%d rejected: %s\n",
655 uuid_str, if_version, nt_errstr(status)));
656 talloc_free(uuid_str);
657 /* we don't want to trigger the iface->unbind() hook */
658 context->iface = NULL;
659 talloc_free(call->context);
660 call->context = NULL;
661 return dcesrv_bind_nak(call, 0);
662 }
663 }
664
665 if (call->conn->cli_max_recv_frag == 0) {
666 call->conn->cli_max_recv_frag = MIN(0x2000, call->pkt.u.bind.max_recv_frag);
667 }
668
669 if ((call->pkt.pfc_flags & DCERPC_PFC_FLAG_SUPPORT_HEADER_SIGN) &&
670 lp_parm_bool(call->conn->dce_ctx->lp_ctx, NULL, "dcesrv","header signing", false)) {
671 call->conn->state_flags |= DCESRV_CALL_STATE_FLAG_HEADER_SIGNING;
672 extra_flags |= DCERPC_PFC_FLAG_SUPPORT_HEADER_SIGN;
673 }
674
675 /* handle any authentication that is being requested */
676 if (!dcesrv_auth_bind(call)) {
677 talloc_free(call->context);
678 call->context = NULL;
679 return dcesrv_bind_nak(call, DCERPC_BIND_REASON_INVALID_AUTH_TYPE);
680 }
681
682 /* setup a bind_ack */
683 dcesrv_init_hdr(&pkt, lp_rpc_big_endian(call->conn->dce_ctx->lp_ctx));
684 pkt.auth_length = 0;
685 pkt.call_id = call->pkt.call_id;
686 pkt.ptype = DCERPC_PKT_BIND_ACK;
687 pkt.pfc_flags = DCERPC_PFC_FLAG_FIRST | DCERPC_PFC_FLAG_LAST | extra_flags;
688 pkt.u.bind_ack.max_xmit_frag = call->conn->cli_max_recv_frag;
689 pkt.u.bind_ack.max_recv_frag = 0x2000;
690
691 /*
692 make it possible for iface->bind() to specify the assoc_group_id
693 This helps the openchange mapiproxy plugin to work correctly.
694
695 metze
696 */
697 if (call->context) {
698 pkt.u.bind_ack.assoc_group_id = call->context->assoc_group->id;
699 } else {
700 pkt.u.bind_ack.assoc_group_id = DUMMY_ASSOC_GROUP;
701 }
702
703 if (iface) {
704 /* FIXME: Use pipe name as specified by endpoint instead of interface name */
705 pkt.u.bind_ack.secondary_address = talloc_asprintf(call, "\\PIPE\\%s", iface->name);
706 } else {
707 pkt.u.bind_ack.secondary_address = "";
708 }
709 pkt.u.bind_ack.num_results = 1;
710 pkt.u.bind_ack.ctx_list = talloc(call, struct dcerpc_ack_ctx);
711 if (!pkt.u.bind_ack.ctx_list) {
712 talloc_free(call->context);
713 call->context = NULL;
714 return NT_STATUS_NO_MEMORY;
715 }
716 pkt.u.bind_ack.ctx_list[0].result = result;
717 pkt.u.bind_ack.ctx_list[0].reason = reason;
718 pkt.u.bind_ack.ctx_list[0].syntax = ndr_transfer_syntax;
719 pkt.u.bind_ack.auth_info = data_blob(NULL, 0);
720
721 status = dcesrv_auth_bind_ack(call, &pkt);
722 if (!NT_STATUS_IS_OK(status)) {
723 talloc_free(call->context);
724 call->context = NULL;
725 return dcesrv_bind_nak(call, 0);
726 }
727
728 rep = talloc(call, struct data_blob_list_item);
729 if (!rep) {
730 talloc_free(call->context);
731 call->context = NULL;
732 return NT_STATUS_NO_MEMORY;
733 }
734
735 status = ncacn_push_auth(&rep->blob, call, &pkt,
736 call->conn->auth_state.auth_info);
737 if (!NT_STATUS_IS_OK(status)) {
738 talloc_free(call->context);
739 call->context = NULL;
740 return status;
741 }
742
743 dcerpc_set_frag_length(&rep->blob, rep->blob.length);
744
745 DLIST_ADD_END(call->replies, rep, struct data_blob_list_item *);
746 dcesrv_call_set_list(call, DCESRV_LIST_CALL_LIST);
747
748 if (call->conn->call_list && call->conn->call_list->replies) {
749 if (call->conn->transport.report_output_data) {
750 call->conn->transport.report_output_data(call->conn);
751 }
752 }
753
754 return NT_STATUS_OK;
755 }
756
757
758 /*
759 handle a auth3 request
760 */
761 static NTSTATUS dcesrv_auth3(struct dcesrv_call_state *call)
762 {
763 /* handle the auth3 in the auth code */
764 if (!dcesrv_auth_auth3(call)) {
765 return dcesrv_fault(call, DCERPC_FAULT_OTHER);
766 }
767
768 talloc_free(call);
769
770 /* we don't send a reply to a auth3 request, except by a
771 fault */
772 return NT_STATUS_OK;
773 }
774
775
776 /*
777 handle a bind request
778 */
779 static NTSTATUS dcesrv_alter_new_context(struct dcesrv_call_state *call, uint32_t context_id)
780 {
781 uint32_t if_version, transfer_syntax_version;
782 struct dcesrv_connection_context *context;
783 const struct dcesrv_interface *iface;
784 struct GUID uuid, *transfer_syntax_uuid;
785 NTSTATUS status;
786
787 if_version = call->pkt.u.alter.ctx_list[0].abstract_syntax.if_version;
788 uuid = call->pkt.u.alter.ctx_list[0].abstract_syntax.uuid;
789
790 transfer_syntax_version = call->pkt.u.alter.ctx_list[0].transfer_syntaxes[0].if_version;
791 transfer_syntax_uuid = &call->pkt.u.alter.ctx_list[0].transfer_syntaxes[0].uuid;
792 if (!GUID_equal(transfer_syntax_uuid, &ndr_transfer_syntax.uuid) ||
793 ndr_transfer_syntax.if_version != transfer_syntax_version) {
794 /* we only do NDR encoded dcerpc */
795 return NT_STATUS_RPC_PROTSEQ_NOT_SUPPORTED;
796 }
797
798 iface = find_interface_by_uuid(call->conn->endpoint, &uuid, if_version);
799 if (iface == NULL) {
800 char *uuid_str = GUID_string(call, &uuid);
801 DEBUG(2,("Request for unknown dcerpc interface %s/%d\n", uuid_str, if_version));
802 talloc_free(uuid_str);
803 return NT_STATUS_RPC_PROTSEQ_NOT_SUPPORTED;
804 }
805
806 /* add this context to the list of available context_ids */
807 context = talloc(call->conn, struct dcesrv_connection_context);
808 if (context == NULL) {
809 return NT_STATUS_NO_MEMORY;
810 }
811 context->conn = call->conn;
812 context->iface = iface;
813 context->context_id = context_id;
814 if (call->pkt.u.alter.assoc_group_id != 0) {
815 context->assoc_group = dcesrv_assoc_group_reference(context,
816 call->conn->dce_ctx,
817 call->pkt.u.alter.assoc_group_id);
818 } else {
819 context->assoc_group = dcesrv_assoc_group_new(context, call->conn->dce_ctx);
820 }
821 if (context->assoc_group == NULL) {
822 talloc_free(context);
823 call->context = NULL;
824 return NT_STATUS_NO_MEMORY;
825 }
826 context->private_data = NULL;
827 DLIST_ADD(call->conn->contexts, context);
828 call->context = context;
829 talloc_set_destructor(context, dcesrv_connection_context_destructor);
830
831 status = iface->bind(call, iface, if_version);
832 if (!NT_STATUS_IS_OK(status)) {
833 /* we don't want to trigger the iface->unbind() hook */
834 context->iface = NULL;
835 talloc_free(context);
836 call->context = NULL;
837 return status;
838 }
839
840 return NT_STATUS_OK;
841 }
842
843
844 /*
845 handle a alter context request
846 */
847 static NTSTATUS dcesrv_alter(struct dcesrv_call_state *call)
848 {
849 struct ncacn_packet pkt;
850 struct data_blob_list_item *rep;
851 NTSTATUS status;
852 uint32_t result=0, reason=0;
853 uint32_t context_id;
854
855 /* handle any authentication that is being requested */
856 if (!dcesrv_auth_alter(call)) {
857 /* TODO: work out the right reject code */
858 result = DCERPC_BIND_PROVIDER_REJECT;
859 reason = DCERPC_BIND_REASON_ASYNTAX;
860 }
861
862 context_id = call->pkt.u.alter.ctx_list[0].context_id;
863
864 /* see if they are asking for a new interface */
865 if (result == 0) {
866 call->context = dcesrv_find_context(call->conn, context_id);
867 if (!call->context) {
868 status = dcesrv_alter_new_context(call, context_id);
869 if (!NT_STATUS_IS_OK(status)) {
870 result = DCERPC_BIND_PROVIDER_REJECT;
871 reason = DCERPC_BIND_REASON_ASYNTAX;
872 }
873 }
874 }
875
876 if (result == 0 &&
877 call->pkt.u.alter.assoc_group_id != 0 &&
878 lp_parm_bool(call->conn->dce_ctx->lp_ctx, NULL, "dcesrv","assoc group checking", true) &&
879 call->pkt.u.alter.assoc_group_id != call->context->assoc_group->id) {
880 DEBUG(0,(__location__ ": Failed attempt to use new assoc_group in alter context (0x%08x 0x%08x)\n",
881 call->context->assoc_group->id, call->pkt.u.alter.assoc_group_id));
882 /* TODO: can they ask for a new association group? */
883 result = DCERPC_BIND_PROVIDER_REJECT;
884 reason = DCERPC_BIND_REASON_ASYNTAX;
885 }
886
887 /* setup a alter_resp */
888 dcesrv_init_hdr(&pkt, lp_rpc_big_endian(call->conn->dce_ctx->lp_ctx));
889 pkt.auth_length = 0;
890 pkt.call_id = call->pkt.call_id;
891 pkt.ptype = DCERPC_PKT_ALTER_RESP;
892 pkt.pfc_flags = DCERPC_PFC_FLAG_FIRST | DCERPC_PFC_FLAG_LAST;
893 pkt.u.alter_resp.max_xmit_frag = 0x2000;
894 pkt.u.alter_resp.max_recv_frag = 0x2000;
895 if (result == 0) {
896 pkt.u.alter_resp.assoc_group_id = call->context->assoc_group->id;
897 } else {
898 pkt.u.alter_resp.assoc_group_id = 0;
899 }
900 pkt.u.alter_resp.num_results = 1;
901 pkt.u.alter_resp.ctx_list = talloc_array(call, struct dcerpc_ack_ctx, 1);
902 if (!pkt.u.alter_resp.ctx_list) {
903 return NT_STATUS_NO_MEMORY;
904 }
905 pkt.u.alter_resp.ctx_list[0].result = result;
906 pkt.u.alter_resp.ctx_list[0].reason = reason;
907 pkt.u.alter_resp.ctx_list[0].syntax = ndr_transfer_syntax;
908 pkt.u.alter_resp.auth_info = data_blob(NULL, 0);
909 pkt.u.alter_resp.secondary_address = "";
910
911 status = dcesrv_auth_alter_ack(call, &pkt);
912 if (!NT_STATUS_IS_OK(status)) {
913 if (NT_STATUS_EQUAL(status, NT_STATUS_ACCESS_DENIED)
914 || NT_STATUS_EQUAL(status, NT_STATUS_LOGON_FAILURE)
915 || NT_STATUS_EQUAL(status, NT_STATUS_NO_SUCH_USER)
916 || NT_STATUS_EQUAL(status, NT_STATUS_WRONG_PASSWORD)) {
917 return dcesrv_fault(call, DCERPC_FAULT_ACCESS_DENIED);
918 }
919 return dcesrv_fault(call, 0);
920 }
921
922 rep = talloc(call, struct data_blob_list_item);
923 if (!rep) {
924 return NT_STATUS_NO_MEMORY;
925 }
926
927 status = ncacn_push_auth(&rep->blob, call, &pkt, call->conn->auth_state.auth_info);
928 if (!NT_STATUS_IS_OK(status)) {
929 return status;
930 }
931
932 dcerpc_set_frag_length(&rep->blob, rep->blob.length);
933
934 DLIST_ADD_END(call->replies, rep, struct data_blob_list_item *);
935 dcesrv_call_set_list(call, DCESRV_LIST_CALL_LIST);
936
937 if (call->conn->call_list && call->conn->call_list->replies) {
938 if (call->conn->transport.report_output_data) {
939 call->conn->transport.report_output_data(call->conn);
940 }
941 }
942
943 return NT_STATUS_OK;
944 }
945
946 /*
947 handle a dcerpc request packet
948 */
949 static NTSTATUS dcesrv_request(struct dcesrv_call_state *call)
950 {
951 struct ndr_pull *pull;
952 NTSTATUS status;
953 struct dcesrv_connection_context *context;
954
955 /* if authenticated, and the mech we use can't do async replies, don't use them... */
956 if (call->conn->auth_state.gensec_security &&
957 !gensec_have_feature(call->conn->auth_state.gensec_security, GENSEC_FEATURE_ASYNC_REPLIES)) {
958 call->state_flags &= ~DCESRV_CALL_STATE_FLAG_MAY_ASYNC;
959 }
960
961 context = dcesrv_find_context(call->conn, call->pkt.u.request.context_id);
962 if (context == NULL) {
963 return dcesrv_fault(call, DCERPC_FAULT_UNK_IF);
964 }
965
966 pull = ndr_pull_init_blob(&call->pkt.u.request.stub_and_verifier, call);
967 NT_STATUS_HAVE_NO_MEMORY(pull);
968
969 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
970
971 call->context = context;
972 call->ndr_pull = pull;
973
974 if (!(call->pkt.drep[0] & DCERPC_DREP_LE)) {
975 pull->flags |= LIBNDR_FLAG_BIGENDIAN;
976 }
977
978 /* unravel the NDR for the packet */
979 status = context->iface->ndr_pull(call, call, pull, &call->r);
980 if (!NT_STATUS_IS_OK(status)) {
981 return dcesrv_fault(call, call->fault_code);
982 }
983
984 if (pull->offset != pull->data_size) {
985 DEBUG(3,("Warning: %d extra bytes in incoming RPC request\n",
986 pull->data_size - pull->offset));
987 dump_data(10, pull->data+pull->offset, pull->data_size - pull->offset);
988 }
989
990 /* call the dispatch function */
991 status = context->iface->dispatch(call, call, call->r);
992 if (!NT_STATUS_IS_OK(status)) {
993 DEBUG(5,("dcerpc fault in call %s:%02x - %s\n",
994 context->iface->name,
995 call->pkt.u.request.opnum,
996 dcerpc_errstr(pull, call->fault_code)));
997 return dcesrv_fault(call, call->fault_code);
998 }
999
1000 /* add the call to the pending list */
1001 dcesrv_call_set_list(call, DCESRV_LIST_PENDING_CALL_LIST);
1002
1003 if (call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
1004 return NT_STATUS_OK;
1005 }
1006
1007 return dcesrv_reply(call);
1008 }
1009
1010 _PUBLIC_ NTSTATUS dcesrv_reply(struct dcesrv_call_state *call)
1011 {
1012 struct ndr_push *push;
1013 NTSTATUS status;
1014 DATA_BLOB stub;
1015 uint32_t total_length, chunk_size;
1016 struct dcesrv_connection_context *context = call->context;
1017 size_t sig_size = 0;
1018
1019 /* call the reply function */
1020 status = context->iface->reply(call, call, call->r);
1021 if (!NT_STATUS_IS_OK(status)) {
1022 return dcesrv_fault(call, call->fault_code);
1023 }
1024
1025 /* form the reply NDR */
1026 push = ndr_push_init_ctx(call);
1027 NT_STATUS_HAVE_NO_MEMORY(push);
1028
1029 /* carry over the pointer count to the reply in case we are
1030 using full pointer. See NDR specification for full
1031 pointers */
1032 push->ptr_count = call->ndr_pull->ptr_count;
1033
1034 if (lp_rpc_big_endian(call->conn->dce_ctx->lp_ctx)) {
1035 push->flags |= LIBNDR_FLAG_BIGENDIAN;
1036 }
1037
1038 status = context->iface->ndr_push(call, call, push, call->r);
1039 if (!NT_STATUS_IS_OK(status)) {
1040 return dcesrv_fault(call, call->fault_code);
1041 }
1042
1043 stub = ndr_push_blob(push);
1044
1045 total_length = stub.length;
1046
1047 /* we can write a full max_recv_frag size, minus the dcerpc
1048 request header size */
1049 chunk_size = call->conn->cli_max_recv_frag;
1050 chunk_size -= DCERPC_REQUEST_LENGTH;
1051 if (call->conn->auth_state.auth_info &&
1052 call->conn->auth_state.gensec_security) {
1053 sig_size = gensec_sig_size(call->conn->auth_state.gensec_security,
1054 call->conn->cli_max_recv_frag);
1055 if (sig_size) {
1056 chunk_size -= DCERPC_AUTH_TRAILER_LENGTH;
1057 chunk_size -= sig_size;
1058 }
1059 }
1060 chunk_size -= (chunk_size % 16);
1061
1062 do {
1063 uint32_t length;
1064 struct data_blob_list_item *rep;
1065 struct ncacn_packet pkt;
1066
1067 rep = talloc(call, struct data_blob_list_item);
1068 NT_STATUS_HAVE_NO_MEMORY(rep);
1069
1070 length = MIN(chunk_size, stub.length);
1071
1072 /* form the dcerpc response packet */
1073 dcesrv_init_hdr(&pkt, lp_rpc_big_endian(call->conn->dce_ctx->lp_ctx));
1074 pkt.auth_length = 0;
1075 pkt.call_id = call->pkt.call_id;
1076 pkt.ptype = DCERPC_PKT_RESPONSE;
1077 pkt.pfc_flags = 0;
1078 if (stub.length == total_length) {
1079 pkt.pfc_flags |= DCERPC_PFC_FLAG_FIRST;
1080 }
1081 if (length == stub.length) {
1082 pkt.pfc_flags |= DCERPC_PFC_FLAG_LAST;
1083 }
1084 pkt.u.response.alloc_hint = stub.length;
1085 pkt.u.response.context_id = call->pkt.u.request.context_id;
1086 pkt.u.response.cancel_count = 0;
1087 pkt.u.response.stub_and_verifier.data = stub.data;
1088 pkt.u.response.stub_and_verifier.length = length;
1089
1090 if (!dcesrv_auth_response(call, &rep->blob, sig_size, &pkt)) {
1091 return dcesrv_fault(call, DCERPC_FAULT_OTHER);
1092 }
1093
1094 dcerpc_set_frag_length(&rep->blob, rep->blob.length);
1095
1096 DLIST_ADD_END(call->replies, rep, struct data_blob_list_item *);
1097
1098 stub.data += length;
1099 stub.length -= length;
1100 } while (stub.length != 0);
1101
1102 /* move the call from the pending to the finished calls list */
1103 dcesrv_call_set_list(call, DCESRV_LIST_CALL_LIST);
1104
1105 if (call->conn->call_list && call->conn->call_list->replies) {
1106 if (call->conn->transport.report_output_data) {
1107 call->conn->transport.report_output_data(call->conn);
1108 }
1109 }
1110
1111 return NT_STATUS_OK;
1112 }
1113
1114 /*
1115 remove the call from the right list when freed
1116 */
1117 static int dcesrv_call_dequeue(struct dcesrv_call_state *call)
1118 {
1119 dcesrv_call_set_list(call, DCESRV_LIST_NONE);
1120 return 0;
1121 }
1122
1123 _PUBLIC_ const struct tsocket_address *dcesrv_connection_get_local_address(struct dcesrv_connection *conn)
1124 {
1125 return conn->local_address;
1126 }
1127
1128 _PUBLIC_ const struct tsocket_address *dcesrv_connection_get_remote_address(struct dcesrv_connection *conn)
1129 {
1130 return conn->remote_address;
1131 }
1132
1133 /*
1134 process some input to a dcerpc endpoint server.
1135 */
1136 NTSTATUS dcesrv_process_ncacn_packet(struct dcesrv_connection *dce_conn,
1137 struct ncacn_packet *pkt,
1138 DATA_BLOB blob)
1139 {
1140 NTSTATUS status;
1141 struct dcesrv_call_state *call;
1142
1143 call = talloc_zero(dce_conn, struct dcesrv_call_state);
1144 if (!call) {
1145 data_blob_free(&blob);
1146 talloc_free(pkt);
1147 return NT_STATUS_NO_MEMORY;
1148 }
1149 call->conn = dce_conn;
1150 call->event_ctx = dce_conn->event_ctx;
1151 call->msg_ctx = dce_conn->msg_ctx;
1152 call->state_flags = call->conn->state_flags;
1153 call->time = timeval_current();
1154 call->list = DCESRV_LIST_NONE;
1155
1156 talloc_steal(call, pkt);
1157 talloc_steal(call, blob.data);
1158 call->pkt = *pkt;
1159
1160 talloc_set_destructor(call, dcesrv_call_dequeue);
1161
1162 /* we have to check the signing here, before combining the
1163 pdus */
1164 if (call->pkt.ptype == DCERPC_PKT_REQUEST &&
1165 !dcesrv_auth_request(call, &blob)) {
1166 return dcesrv_fault(call, DCERPC_FAULT_ACCESS_DENIED);
1167 }
1168
1169 /* see if this is a continued packet */
1170 if (call->pkt.ptype == DCERPC_PKT_REQUEST &&
1171 !(call->pkt.pfc_flags & DCERPC_PFC_FLAG_FIRST)) {
1172 struct dcesrv_call_state *call2 = call;
1173 uint32_t alloc_size;
1174
1175 /* we only allow fragmented requests, no other packet types */
1176 if (call->pkt.ptype != DCERPC_PKT_REQUEST) {
1177 return dcesrv_fault(call2, DCERPC_FAULT_OTHER);
1178 }
1179
1180 /* this is a continuation of an existing call - find the call then
1181 tack it on the end */
1182 call = dcesrv_find_fragmented_call(dce_conn, call2->pkt.call_id);
1183 if (!call) {
1184 return dcesrv_fault(call2, DCERPC_FAULT_OTHER);
1185 }
1186
1187 if (call->pkt.ptype != call2->pkt.ptype) {
1188 /* trying to play silly buggers are we? */
1189 return dcesrv_fault(call2, DCERPC_FAULT_OTHER);
1190 }
1191
1192 alloc_size = call->pkt.u.request.stub_and_verifier.length +
1193 call2->pkt.u.request.stub_and_verifier.length;
1194 if (call->pkt.u.request.alloc_hint > alloc_size) {
1195 alloc_size = call->pkt.u.request.alloc_hint;
1196 }
1197
1198 call->pkt.u.request.stub_and_verifier.data =
1199 talloc_realloc(call,
1200 call->pkt.u.request.stub_and_verifier.data,
1201 uint8_t, alloc_size);
1202 if (!call->pkt.u.request.stub_and_verifier.data) {
1203 return dcesrv_fault(call2, DCERPC_FAULT_OTHER);
1204 }
1205 memcpy(call->pkt.u.request.stub_and_verifier.data +
1206 call->pkt.u.request.stub_and_verifier.length,
1207 call2->pkt.u.request.stub_and_verifier.data,
1208 call2->pkt.u.request.stub_and_verifier.length);
1209 call->pkt.u.request.stub_and_verifier.length +=
1210 call2->pkt.u.request.stub_and_verifier.length;
1211
1212 call->pkt.pfc_flags |= (call2->pkt.pfc_flags & DCERPC_PFC_FLAG_LAST);
1213
1214 talloc_free(call2);
1215 }
1216
1217 /* this may not be the last pdu in the chain - if its isn't then
1218 just put it on the incoming_fragmented_call_list and wait for the rest */
1219 if (call->pkt.ptype == DCERPC_PKT_REQUEST &&
1220 !(call->pkt.pfc_flags & DCERPC_PFC_FLAG_LAST)) {
1221 dcesrv_call_set_list(call, DCESRV_LIST_FRAGMENTED_CALL_LIST);
1222 return NT_STATUS_OK;
1223 }
1224
1225 /* This removes any fragments we may have had stashed away */
1226 dcesrv_call_set_list(call, DCESRV_LIST_NONE);
1227
1228 switch (call->pkt.ptype) {
1229 case DCERPC_PKT_BIND:
1230 status = dcesrv_bind(call);
1231 break;
1232 case DCERPC_PKT_AUTH3:
1233 status = dcesrv_auth3(call);
1234 break;
1235 case DCERPC_PKT_ALTER:
1236 status = dcesrv_alter(call);
1237 break;
1238 case DCERPC_PKT_REQUEST:
1239 status = dcesrv_request(call);
1240 break;
1241 default:
1242 status = NT_STATUS_INVALID_PARAMETER;
1243 break;
1244 }
1245
1246 /* if we are going to be sending a reply then add
1247 it to the list of pending calls. We add it to the end to keep the call
1248 list in the order we will answer */
1249 if (!NT_STATUS_IS_OK(status)) {
1250 talloc_free(call);
1251 }
1252
1253 return status;
1254 }
1255
1256 _PUBLIC_ NTSTATUS dcesrv_init_context(TALLOC_CTX *mem_ctx,
1257 struct loadparm_context *lp_ctx,
1258 const char **endpoint_servers, struct dcesrv_context **_dce_ctx)
1259 {
1260 NTSTATUS status;
1261 struct dcesrv_context *dce_ctx;
1262 int i;
1263
1264 if (!endpoint_servers) {
1265 DEBUG(0,("dcesrv_init_context: no endpoint servers configured\n"));
1266 return NT_STATUS_INTERNAL_ERROR;
1267 }
1268
1269 dce_ctx = talloc(mem_ctx, struct dcesrv_context);
1270 NT_STATUS_HAVE_NO_MEMORY(dce_ctx);
1271 dce_ctx->endpoint_list = NULL;
1272 dce_ctx->lp_ctx = lp_ctx;
1273 dce_ctx->assoc_groups_idr = idr_init(dce_ctx);
1274 NT_STATUS_HAVE_NO_MEMORY(dce_ctx->assoc_groups_idr);
1275
1276 for (i=0;endpoint_servers[i];i++) {
1277 const struct dcesrv_endpoint_server *ep_server;
1278
1279 ep_server = dcesrv_ep_server_byname(endpoint_servers[i]);
1280 if (!ep_server) {
1281 DEBUG(0,("dcesrv_init_context: failed to find endpoint server = '%s'\n", endpoint_servers[i]));
1282 return NT_STATUS_INTERNAL_ERROR;
1283 }
1284
1285 status = ep_server->init_server(dce_ctx, ep_server);
1286 if (!NT_STATUS_IS_OK(status)) {
1287 DEBUG(0,("dcesrv_init_context: failed to init endpoint server = '%s': %s\n", endpoint_servers[i],
1288 nt_errstr(status)));
1289 return status;
1290 }
1291 }
1292
1293 *_dce_ctx = dce_ctx;
1294 return NT_STATUS_OK;
1295 }
1296
1297 /* the list of currently registered DCERPC endpoint servers.
1298 */
1299 static struct ep_server {
1300 struct dcesrv_endpoint_server *ep_server;
1301 } *ep_servers = NULL;
1302 static int num_ep_servers;
1303
1304 /*
1305 register a DCERPC endpoint server.
1306
1307 The 'name' can be later used by other backends to find the operations
1308 structure for this backend.
1309
1310 The 'type' is used to specify whether this is for a disk, printer or IPC$ share
1311 */
1312 _PUBLIC_ NTSTATUS dcerpc_register_ep_server(const void *_ep_server)
1313 {
1314 const struct dcesrv_endpoint_server *ep_server = _ep_server;
1315
1316 if (dcesrv_ep_server_byname(ep_server->name) != NULL) {
1317 /* its already registered! */
1318 DEBUG(0,("DCERPC endpoint server '%s' already registered\n",
1319 ep_server->name));
1320 return NT_STATUS_OBJECT_NAME_COLLISION;
1321 }
1322
1323 ep_servers = realloc_p(ep_servers, struct ep_server, num_ep_servers+1);
1324 if (!ep_servers) {
1325 smb_panic("out of memory in dcerpc_register");
1326 }
1327
1328 ep_servers[num_ep_servers].ep_server = smb_xmemdup(ep_server, sizeof(*ep_server));
1329 ep_servers[num_ep_servers].ep_server->name = smb_xstrdup(ep_server->name);
1330
1331 num_ep_servers++;
1332
1333 DEBUG(3,("DCERPC endpoint server '%s' registered\n",
1334 ep_server->name));
1335
1336 return NT_STATUS_OK;
1337 }
1338
1339 /*
1340 return the operations structure for a named backend of the specified type
1341 */
1342 const struct dcesrv_endpoint_server *dcesrv_ep_server_byname(const char *name)
1343 {
1344 int i;
1345
1346 for (i=0;i<num_ep_servers;i++) {
1347 if (strcmp(ep_servers[i].ep_server->name, name) == 0) {
1348 return ep_servers[i].ep_server;
1349 }
1350 }
1351
1352 return NULL;
1353 }
1354
1355 void dcerpc_server_init(struct loadparm_context *lp_ctx)
1356 {
1357 static bool initialized;
1358 extern NTSTATUS dcerpc_server_wkssvc_init(void);
1359 extern NTSTATUS dcerpc_server_drsuapi_init(void);
1360 extern NTSTATUS dcerpc_server_winreg_init(void);
1361 extern NTSTATUS dcerpc_server_spoolss_init(void);
1362 extern NTSTATUS dcerpc_server_epmapper_init(void);
1363 extern NTSTATUS dcerpc_server_srvsvc_init(void);
1364 extern NTSTATUS dcerpc_server_netlogon_init(void);
1365 extern NTSTATUS dcerpc_server_rpcecho_init(void);
1366 extern NTSTATUS dcerpc_server_unixinfo_init(void);
1367 extern NTSTATUS dcerpc_server_samr_init(void);
1368 extern NTSTATUS dcerpc_server_remote_init(void);
1369 extern NTSTATUS dcerpc_server_lsa_init(void);
1370 extern NTSTATUS dcerpc_server_browser_init(void);
1371 init_module_fn static_init[] = { STATIC_dcerpc_server_MODULES };
1372 init_module_fn *shared_init;
1373
1374 if (initialized) {
1375 return;
1376 }
1377 initialized = true;
1378
1379 shared_init = load_samba_modules(NULL, lp_ctx, "dcerpc_server");
1380
1381 run_init_functions(static_init);
1382 run_init_functions(shared_init);
1383
1384 talloc_free(shared_init);
1385 }
1386
1387 /*
1388 return the DCERPC module version, and the size of some critical types
1389 This can be used by endpoint server modules to either detect compilation errors, or provide
1390 multiple implementations for different smbd compilation options in one module
1391 */
1392 const struct dcesrv_critical_sizes *dcerpc_module_version(void)
1393 {
1394 static const struct dcesrv_critical_sizes critical_sizes = {
1395 DCERPC_MODULE_VERSION,
1396 sizeof(struct dcesrv_context),
1397 sizeof(struct dcesrv_endpoint),
1398 sizeof(struct dcesrv_endpoint_server),
1399 sizeof(struct dcesrv_interface),
1400 sizeof(struct dcesrv_if_list),
1401 sizeof(struct dcesrv_connection),
1402 sizeof(struct dcesrv_call_state),
1403 sizeof(struct dcesrv_auth),
1404 sizeof(struct dcesrv_handle)
1405 };
1406
1407 return &critical_sizes;
1408 }
1409