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