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