Line data Source code
1 : /*
2 : * Unix SMB/CIFS implementation.
3 : *
4 : * SMBD RPC service callbacks
5 : *
6 : * Copyright (c) 2011 Andreas Schneider <asn@samba.org>
7 : *
8 : * This program is free software; you can redistribute it and/or modify
9 : * it under the terms of the GNU General Public License as published by
10 : * the Free Software Foundation; either version 3 of the License, or
11 : * (at your option) any later version.
12 : *
13 : * This program is distributed in the hope that it will be useful,
14 : * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 : * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 : * GNU General Public License for more details.
17 : *
18 : * You should have received a copy of the GNU General Public License
19 : * along with this program; if not, see <http://www.gnu.org/licenses/>.
20 : */
21 :
22 : #include "includes.h"
23 : #include "ntdomain.h"
24 :
25 : #include "librpc/gen_ndr/ndr_winreg_scompat.h"
26 : #include "librpc/gen_ndr/ndr_srvsvc_scompat.h"
27 : #include "librpc/gen_ndr/ndr_lsa_scompat.h"
28 : #include "librpc/gen_ndr/ndr_samr_scompat.h"
29 : #include "librpc/gen_ndr/ndr_netlogon_scompat.h"
30 : #include "librpc/gen_ndr/ndr_dfs_scompat.h"
31 : #include "librpc/gen_ndr/ndr_echo_scompat.h"
32 : #include "librpc/gen_ndr/ndr_dssetup_scompat.h"
33 : #include "librpc/gen_ndr/ndr_wkssvc_scompat.h"
34 : #include "librpc/gen_ndr/ndr_spoolss_scompat.h"
35 : #include "librpc/gen_ndr/ndr_svcctl_scompat.h"
36 : #include "librpc/gen_ndr/ndr_ntsvcs_scompat.h"
37 : #include "librpc/gen_ndr/ndr_eventlog_scompat.h"
38 : #include "librpc/gen_ndr/ndr_initshutdown_scompat.h"
39 :
40 : #include "printing/nt_printing_migrate_internal.h"
41 : #include "rpc_server/eventlog/srv_eventlog_reg.h"
42 : #include "rpc_server/svcctl/srv_svcctl_reg.h"
43 : #include "rpc_server/spoolss/srv_spoolss_nt.h"
44 : #include "rpc_server/svcctl/srv_svcctl_nt.h"
45 :
46 : #include "lib/server_prefork.h"
47 : #include "librpc/rpc/dcesrv_core.h"
48 : #include "librpc/rpc/dcerpc_ep.h"
49 : #include "rpc_server/rpc_sock_helper.h"
50 : #include "rpc_server/rpc_service_setup.h"
51 : #include "rpc_server/rpc_ep_register.h"
52 : #include "rpc_server/rpc_server.h"
53 : #include "rpc_server/rpc_config.h"
54 : #include "rpc_server/rpc_modules.h"
55 : #include "rpc_server/epmapper/srv_epmapper.h"
56 :
57 : #undef DBGC_CLASS
58 : #define DBGC_CLASS DBGC_RPC_SRV
59 :
60 : static_decl_rpc;
61 :
62 : /* Common routine for embedded RPC servers */
63 1330 : NTSTATUS rpc_setup_embedded(struct tevent_context *ev_ctx,
64 : struct messaging_context *msg_ctx,
65 : struct dcesrv_context *dce_ctx,
66 : const struct dcesrv_interface *iface)
67 : {
68 1330 : enum rpc_service_mode_e epm_mode = rpc_epmapper_mode();
69 : NTSTATUS status;
70 :
71 : /* Registration of ncacn_np services is problematic. The
72 : * ev_ctx passed in here is passed down to all children of the
73 : * smbd process, and if the end point mapper ever goes away,
74 : * they will all attempt to re-register. But we want to test
75 : * the code for now, so it is enabled in on environment in
76 : * make test */
77 2014 : if (epm_mode != RPC_SERVICE_MODE_DISABLED &&
78 684 : (lp_parm_bool(-1, "rpc_server", "register_embedded_np", false))) {
79 236 : status = rpc_ep_register(ev_ctx, msg_ctx, dce_ctx, iface);
80 236 : if (!NT_STATUS_IS_OK(status)) {
81 0 : return status;
82 : }
83 : }
84 :
85 1330 : return NT_STATUS_OK;
86 : }
87 :
88 103 : NTSTATUS dcesrv_create_endpoint_sockets(struct tevent_context *ev_ctx,
89 : struct messaging_context *msg_ctx,
90 : struct dcesrv_endpoint *e,
91 : TALLOC_CTX *mem_ctx,
92 : size_t *pnum_fds,
93 : int **pfds)
94 : {
95 103 : struct dcerpc_binding *b = e->ep_description;
96 103 : char *binding = NULL;
97 103 : int *fds = NULL;
98 : size_t num_fds;
99 : NTSTATUS status;
100 :
101 103 : binding = dcerpc_binding_string(mem_ctx, b);
102 103 : if (binding == NULL) {
103 0 : return NT_STATUS_NO_MEMORY;
104 : }
105 103 : DBG_DEBUG("Creating endpoint '%s'\n", binding);
106 103 : TALLOC_FREE(binding);
107 :
108 103 : status = dcesrv_create_binding_sockets(b, mem_ctx, &num_fds, &fds);
109 :
110 : /* Build binding string again as the endpoint may have changed by
111 : * dcesrv_create_<transport>_socket functions */
112 103 : binding = dcerpc_binding_string(mem_ctx, b);
113 103 : if (binding == NULL) {
114 0 : return NT_STATUS_NO_MEMORY;
115 : }
116 :
117 103 : if (!NT_STATUS_IS_OK(status)) {
118 0 : struct dcesrv_if_list *iface = NULL;
119 0 : DBG_ERR("Failed to create '%s' sockets for ", binding);
120 0 : for (iface = e->interface_list; iface; iface = iface->next) {
121 0 : DEBUGADD(DBGLVL_ERR, ("'%s' ", iface->iface->name));
122 : }
123 0 : DEBUGADD(DBGLVL_ERR, (": %s\n", nt_errstr(status)));
124 0 : return status;
125 : } else {
126 103 : struct dcesrv_if_list *iface = NULL;
127 103 : DBG_INFO("Successfully listening on '%s' for ", binding);
128 334 : for (iface = e->interface_list; iface; iface = iface->next) {
129 231 : DEBUGADD(DBGLVL_INFO, ("'%s' ", iface->iface->name));
130 : }
131 103 : DEBUGADD(DBGLVL_INFO, ("\n"));
132 : }
133 :
134 103 : TALLOC_FREE(binding);
135 :
136 103 : *pnum_fds = num_fds;
137 103 : *pfds = fds;
138 :
139 103 : return status;
140 : }
141 :
142 17 : NTSTATUS dcesrv_create_endpoint_list_pf_listen_fds(
143 : struct tevent_context *ev_ctx,
144 : struct messaging_context *msg_ctx,
145 : struct dcesrv_context *dce_ctx,
146 : struct dcesrv_endpoint *e,
147 : TALLOC_CTX *mem_ctx,
148 : size_t *pnum_fds,
149 : struct pf_listen_fd **pfds)
150 : {
151 17 : struct pf_listen_fd *fds = NULL;
152 17 : size_t num_fds = 0;
153 : NTSTATUS status;
154 :
155 240 : for (; e != NULL; e = e->next) {
156 103 : int *ep_fds = NULL;
157 103 : struct pf_listen_fd *tmp = NULL;
158 : size_t i, num_ep_fds;
159 :
160 103 : status = dcesrv_create_endpoint_sockets(
161 : ev_ctx,
162 : msg_ctx,
163 : e,
164 : mem_ctx,
165 : &num_ep_fds,
166 : &ep_fds);
167 103 : if (!NT_STATUS_IS_OK(status)) {
168 0 : char *ep_string = dcerpc_binding_string(
169 0 : dce_ctx, e->ep_description);
170 0 : DBG_ERR("Failed to create endpoint '%s': %s\n",
171 : ep_string, nt_errstr(status));
172 0 : TALLOC_FREE(ep_string);
173 0 : goto fail;
174 : }
175 :
176 103 : if (num_fds + num_ep_fds < num_fds) {
177 : /* overflow */
178 0 : status = NT_STATUS_INTEGER_OVERFLOW;
179 0 : goto fail;
180 : }
181 :
182 103 : tmp = talloc_realloc(
183 : mem_ctx,
184 : fds,
185 : struct pf_listen_fd,
186 : num_fds + num_ep_fds);
187 103 : if (tmp == NULL) {
188 0 : status = NT_STATUS_NO_MEMORY;
189 0 : goto fail;
190 : }
191 103 : fds = tmp;
192 :
193 215 : for (i=0; i<num_ep_fds; i++) {
194 112 : fds[num_fds].fd = ep_fds[i];
195 112 : fds[num_fds].fd_data = e;
196 112 : num_fds += 1;
197 : }
198 :
199 103 : TALLOC_FREE(ep_fds);
200 : }
201 :
202 17 : *pnum_fds = num_fds;
203 17 : *pfds = fds;
204 17 : return NT_STATUS_OK;
205 :
206 0 : fail:
207 : {
208 : size_t i;
209 0 : for (i=0; i<num_fds; i++) {
210 0 : close(fds[i].fd);
211 : }
212 : }
213 :
214 0 : TALLOC_FREE(fds);
215 0 : return status;
216 : }
217 :
218 708 : NTSTATUS dcesrv_setup_endpoint_sockets(struct tevent_context *ev_ctx,
219 : struct messaging_context *msg_ctx,
220 : struct dcesrv_context *dce_ctx,
221 : struct dcesrv_endpoint *e,
222 : dcerpc_ncacn_termination_fn term_fn,
223 : void *term_data)
224 : {
225 708 : TALLOC_CTX *frame = talloc_stackframe();
226 708 : struct dcerpc_binding *b = e->ep_description;
227 708 : char *binding = NULL;
228 708 : NTSTATUS status = NT_STATUS_NO_MEMORY;
229 708 : struct dcesrv_if_list *iface = NULL;
230 708 : int *fds = NULL;
231 708 : size_t i, num_fds = 0;
232 708 : struct dcerpc_ncacn_listen_state **listen_states = NULL;
233 :
234 708 : binding = dcerpc_binding_string(frame, b);
235 708 : if (binding == NULL) {
236 0 : goto fail;
237 : }
238 :
239 708 : DBG_DEBUG("Setting up endpoint '%s'\n", binding);
240 708 : TALLOC_FREE(binding);
241 :
242 708 : status = dcesrv_create_binding_sockets(b, frame, &num_fds, &fds);
243 :
244 : /* Build binding string again as the endpoint may have changed by
245 : * dcesrv_create_<transport>_socket functions */
246 708 : binding = dcerpc_binding_string(frame, b);
247 708 : if (binding == NULL) {
248 0 : status = NT_STATUS_NO_MEMORY;
249 0 : goto fail;
250 : }
251 :
252 708 : if (!NT_STATUS_IS_OK(status)) {
253 0 : DBG_ERR("Failed to setup '%s' sockets for ", binding);
254 0 : for (iface = e->interface_list; iface; iface = iface->next) {
255 0 : DEBUGADD(DBGLVL_ERR, ("'%s' ", iface->iface->name));
256 : }
257 0 : DEBUGADD(DBGLVL_ERR, (": %s\n", nt_errstr(status)));
258 0 : goto fail;
259 : }
260 :
261 708 : listen_states = talloc_array(
262 : frame, struct dcerpc_ncacn_listen_state *, num_fds);
263 708 : if (listen_states == NULL) {
264 0 : status = NT_STATUS_NO_MEMORY;
265 0 : goto fail;
266 : }
267 :
268 1400 : for (i=0; i<num_fds; i++) {
269 1416 : int ret = dcesrv_setup_ncacn_listener(
270 : listen_states,
271 : dce_ctx,
272 : ev_ctx,
273 : msg_ctx,
274 : e,
275 708 : &fds[i],
276 : term_fn,
277 : term_data,
278 708 : &listen_states[i]);
279 708 : if (ret != 0) {
280 0 : DBG_ERR("dcesrv_setup_ncacn_listener failed for "
281 : "socket %d: %s\n",
282 : fds[i],
283 : strerror(ret));
284 0 : break;
285 : }
286 : }
287 :
288 708 : if (i < num_fds) {
289 0 : goto fail;
290 : }
291 :
292 1400 : for (i=0; i<num_fds; i++) {
293 : /*
294 : * Make the listener states including the tevent_fd's
295 : * talloc children of the endpoint. If the endpoint is
296 : * freed (for example when forked daemons reinit) the
297 : * dcesrv_context, the tevent_fd listener will be
298 : * stopped and the socket closed.
299 : *
300 : * Do this in a loop separate from the one doing the
301 : * dcesrv_setup_ncacn_listener() that can't fail
302 : * anymore.
303 : */
304 708 : talloc_move(e, &listen_states[i]);
305 : }
306 :
307 708 : DBG_INFO("Successfully listening on '%s' for ", binding);
308 2512 : for (iface = e->interface_list; iface; iface = iface->next) {
309 1804 : DEBUGADD(DBGLVL_INFO, ("'%s' ", iface->iface->name));
310 : }
311 708 : DEBUGADD(DBGLVL_INFO, ("\n"));
312 :
313 708 : TALLOC_FREE(frame);
314 708 : return NT_STATUS_OK;
315 :
316 0 : fail:
317 0 : for (i=0; i<num_fds; i++) {
318 0 : if (fds[i] != -1) {
319 0 : close(fds[i]);
320 : }
321 : }
322 0 : TALLOC_FREE(frame);
323 0 : return status;
324 : }
325 :
326 60 : static NTSTATUS dcesrv_init_endpoints(struct tevent_context *ev_ctx,
327 : struct messaging_context *msg_ctx,
328 : struct dcesrv_context *dce_ctx)
329 : {
330 60 : struct dcesrv_endpoint *e = NULL;
331 : NTSTATUS status;
332 :
333 766 : for (e = dce_ctx->endpoint_list; e; e = e->next) {
334 706 : enum dcerpc_transport_t transport =
335 706 : dcerpc_binding_get_transport(e->ep_description);
336 :
337 706 : if (transport == NCACN_HTTP) {
338 : /*
339 : * We don't support ncacn_http yet
340 : */
341 0 : continue;
342 : }
343 :
344 706 : status = dcesrv_setup_endpoint_sockets(ev_ctx,
345 : msg_ctx,
346 : dce_ctx,
347 : e,
348 : NULL,
349 : NULL);
350 706 : if (!NT_STATUS_IS_OK(status)) {
351 0 : return status;
352 : }
353 :
354 : /* Register only NCACN_NP for embedded services */
355 706 : if (transport == NCACN_NP) {
356 646 : struct dcesrv_if_list *ifl = NULL;
357 1976 : for (ifl = e->interface_list; ifl; ifl = ifl->next) {
358 1330 : status = rpc_setup_embedded(ev_ctx,
359 : msg_ctx,
360 : dce_ctx,
361 1330 : ifl->iface);
362 1330 : if (!NT_STATUS_IS_OK(status)) {
363 0 : DBG_ERR("Failed to register embedded "
364 : "interface in endpoint mapper "
365 : ": %s", nt_errstr(status));
366 0 : return status;
367 : }
368 : }
369 : }
370 : }
371 :
372 60 : return NT_STATUS_OK;
373 : }
374 :
375 60 : static NTSTATUS rpc_setup_winreg(struct tevent_context *ev_ctx,
376 : struct messaging_context *msg_ctx)
377 : {
378 : NTSTATUS status;
379 : enum rpc_service_mode_e service_mode;
380 60 : const struct dcesrv_endpoint_server *ep_server = NULL;
381 :
382 : /* Register the endpoint server in DCERPC core */
383 60 : ep_server = winreg_get_ep_server();
384 60 : if (ep_server == NULL) {
385 0 : DBG_ERR("Failed to get 'winreg' endpoint server\n");
386 0 : return NT_STATUS_UNSUCCESSFUL;
387 : }
388 :
389 60 : service_mode = rpc_service_mode(ep_server->name);
390 60 : if (service_mode != RPC_SERVICE_MODE_EMBEDDED) {
391 0 : return NT_STATUS_OK;
392 : }
393 :
394 60 : status = dcerpc_register_ep_server(ep_server);
395 60 : if (!NT_STATUS_IS_OK(status)) {
396 0 : DBG_ERR("Failed to register '%s' endpoint server: "
397 : "%s\n", ep_server->name, nt_errstr(status));
398 0 : return status;
399 : }
400 :
401 60 : return NT_STATUS_OK;
402 : }
403 :
404 60 : static NTSTATUS rpc_setup_srvsvc(struct tevent_context *ev_ctx,
405 : struct messaging_context *msg_ctx)
406 : {
407 : NTSTATUS status;
408 : enum rpc_service_mode_e service_mode;
409 60 : const struct dcesrv_endpoint_server *ep_server = NULL;
410 :
411 : /* Register the endpoint server in DCERPC core */
412 60 : ep_server = srvsvc_get_ep_server();
413 60 : if (ep_server == NULL) {
414 0 : DBG_ERR("Failed to get 'srvsvc' endpoint server\n");
415 0 : return NT_STATUS_UNSUCCESSFUL;
416 : }
417 :
418 60 : service_mode = rpc_service_mode(ep_server->name);
419 60 : if (service_mode != RPC_SERVICE_MODE_EMBEDDED) {
420 0 : return NT_STATUS_OK;
421 : }
422 :
423 60 : status = dcerpc_register_ep_server(ep_server);
424 60 : if (!NT_STATUS_IS_OK(status)) {
425 0 : DBG_ERR("Failed to register '%s' endpoint server: "
426 : "%s\n", ep_server->name, nt_errstr(status));
427 0 : return status;
428 : }
429 :
430 60 : return NT_STATUS_OK;
431 : }
432 :
433 60 : static NTSTATUS rpc_setup_lsarpc(struct tevent_context *ev_ctx,
434 : struct messaging_context *msg_ctx)
435 : {
436 60 : enum rpc_daemon_type_e lsasd_type = rpc_lsasd_daemon();
437 : NTSTATUS status;
438 : enum rpc_service_mode_e service_mode;
439 60 : const struct dcesrv_endpoint_server *ep_server = NULL;
440 :
441 : /* Register the endpoint server in DCERPC core */
442 60 : ep_server = lsarpc_get_ep_server();
443 60 : if (ep_server == NULL) {
444 0 : DBG_ERR("Failed to get 'lsarpc' endpoint server\n");
445 0 : return NT_STATUS_UNSUCCESSFUL;
446 : }
447 :
448 60 : service_mode = rpc_service_mode(ep_server->name);
449 62 : if (service_mode != RPC_SERVICE_MODE_EMBEDDED ||
450 2 : lsasd_type != RPC_DAEMON_EMBEDDED) {
451 41 : return NT_STATUS_OK;
452 : }
453 :
454 19 : status = dcerpc_register_ep_server(ep_server);
455 19 : if (!NT_STATUS_IS_OK(status)) {
456 0 : DBG_ERR("Failed to register '%s' endpoint server: "
457 : "%s\n", ep_server->name, nt_errstr(status));
458 0 : return status;
459 : }
460 :
461 19 : return NT_STATUS_OK;
462 : }
463 :
464 60 : static NTSTATUS rpc_setup_samr(struct tevent_context *ev_ctx,
465 : struct messaging_context *msg_ctx)
466 : {
467 60 : enum rpc_daemon_type_e lsasd_type = rpc_lsasd_daemon();
468 : NTSTATUS status;
469 : enum rpc_service_mode_e service_mode;
470 60 : const struct dcesrv_endpoint_server *ep_server = NULL;
471 :
472 : /* Register the endpoint server in DCERPC core */
473 60 : ep_server = samr_get_ep_server();
474 60 : if (ep_server == NULL) {
475 0 : DBG_ERR("Failed to get 'samr' endpoint server\n");
476 0 : return NT_STATUS_UNSUCCESSFUL;
477 : }
478 :
479 60 : service_mode = rpc_service_mode(ep_server->name);
480 62 : if (service_mode != RPC_SERVICE_MODE_EMBEDDED ||
481 2 : lsasd_type != RPC_DAEMON_EMBEDDED) {
482 41 : return NT_STATUS_OK;
483 : }
484 :
485 19 : status = dcerpc_register_ep_server(ep_server);
486 19 : if (!NT_STATUS_IS_OK(status)) {
487 0 : DBG_ERR("Failed to register '%s' endpoint server: "
488 : "%s\n", ep_server->name, nt_errstr(status));
489 0 : return status;
490 : }
491 :
492 19 : return NT_STATUS_OK;
493 : }
494 :
495 60 : static NTSTATUS rpc_setup_netlogon(struct tevent_context *ev_ctx,
496 : struct messaging_context *msg_ctx)
497 : {
498 60 : enum rpc_daemon_type_e lsasd_type = rpc_lsasd_daemon();
499 : NTSTATUS status;
500 : enum rpc_service_mode_e service_mode;
501 60 : const struct dcesrv_endpoint_server *ep_server = NULL;
502 :
503 : /* Register the endpoint server in DCERPC core */
504 60 : ep_server = netlogon_get_ep_server();
505 60 : if (ep_server == NULL) {
506 0 : DBG_ERR("Failed to get 'netlogon' endpoint server\n");
507 0 : return NT_STATUS_UNSUCCESSFUL;
508 : }
509 :
510 60 : service_mode = rpc_service_mode(ep_server->name);
511 62 : if (service_mode != RPC_SERVICE_MODE_EMBEDDED ||
512 2 : lsasd_type != RPC_DAEMON_EMBEDDED) {
513 60 : return NT_STATUS_OK;
514 : }
515 :
516 0 : status = dcerpc_register_ep_server(ep_server);
517 0 : if (!NT_STATUS_IS_OK(status)) {
518 0 : DBG_ERR("Failed to register '%s' endpoint server: "
519 : "%s\n", ep_server->name, nt_errstr(status));
520 0 : return status;
521 : }
522 :
523 0 : return NT_STATUS_OK;
524 : }
525 :
526 60 : static NTSTATUS rpc_setup_netdfs(struct tevent_context *ev_ctx,
527 : struct messaging_context *msg_ctx)
528 : {
529 : NTSTATUS status;
530 : enum rpc_service_mode_e service_mode;
531 60 : const struct dcesrv_endpoint_server *ep_server = NULL;
532 :
533 : /* Register the endpoint server in DCERPC core */
534 60 : ep_server = netdfs_get_ep_server();
535 60 : if (ep_server == NULL) {
536 0 : DBG_ERR("Failed to get 'netdfs' endpoint server\n");
537 0 : return NT_STATUS_UNSUCCESSFUL;
538 : }
539 :
540 60 : service_mode = rpc_service_mode(ep_server->name);
541 60 : if (service_mode != RPC_SERVICE_MODE_EMBEDDED) {
542 32 : return NT_STATUS_OK;
543 : }
544 :
545 28 : status = dcerpc_register_ep_server(ep_server);
546 28 : if (!NT_STATUS_IS_OK(status)) {
547 0 : DBG_ERR("Failed to register '%s' endpoint server: "
548 : "%s\n", ep_server->name, nt_errstr(status));
549 0 : return status;
550 : }
551 :
552 28 : return NT_STATUS_OK;
553 : }
554 :
555 : #ifdef DEVELOPER
556 60 : static NTSTATUS rpc_setup_rpcecho(struct tevent_context *ev_ctx,
557 : struct messaging_context *msg_ctx)
558 : {
559 : NTSTATUS status;
560 : enum rpc_service_mode_e service_mode;
561 60 : const struct dcesrv_endpoint_server *ep_server = NULL;
562 :
563 : /* Register the endpoint server in DCERPC core */
564 60 : ep_server = rpcecho_get_ep_server();
565 60 : if (ep_server == NULL) {
566 0 : DBG_ERR("Failed to get 'rpcecho' endpoint server\n");
567 0 : return NT_STATUS_UNSUCCESSFUL;
568 : }
569 :
570 60 : service_mode = rpc_service_mode(ep_server->name);
571 60 : if (service_mode != RPC_SERVICE_MODE_EMBEDDED) {
572 32 : return NT_STATUS_OK;
573 : }
574 :
575 28 : status = dcerpc_register_ep_server(ep_server);
576 28 : if (!NT_STATUS_IS_OK(status)) {
577 0 : DBG_ERR("Failed to register '%s' endpoint server: "
578 : "%s\n", ep_server->name, nt_errstr(status));
579 0 : return status;
580 : }
581 :
582 28 : return NT_STATUS_OK;
583 : }
584 : #endif
585 :
586 60 : static NTSTATUS rpc_setup_dssetup(struct tevent_context *ev_ctx,
587 : struct messaging_context *msg_ctx)
588 : {
589 : NTSTATUS status;
590 : enum rpc_service_mode_e service_mode;
591 60 : const struct dcesrv_endpoint_server *ep_server = NULL;
592 :
593 : /* Register the endpoint server in DCERPC core */
594 60 : ep_server = dssetup_get_ep_server();
595 60 : if (ep_server == NULL) {
596 0 : DBG_ERR("Failed to get 'dssetup' endpoint server\n");
597 0 : return NT_STATUS_UNSUCCESSFUL;
598 : }
599 :
600 60 : service_mode = rpc_service_mode(ep_server->name);
601 60 : if (service_mode != RPC_SERVICE_MODE_EMBEDDED) {
602 32 : return NT_STATUS_OK;
603 : }
604 :
605 28 : status = dcerpc_register_ep_server(ep_server);
606 28 : if (!NT_STATUS_IS_OK(status)) {
607 0 : DBG_ERR("Failed to register '%s' endpoint server: "
608 : "%s\n", ep_server->name, nt_errstr(status));
609 0 : return status;
610 : }
611 :
612 28 : return NT_STATUS_OK;
613 : }
614 :
615 60 : static NTSTATUS rpc_setup_wkssvc(struct tevent_context *ev_ctx,
616 : struct messaging_context *msg_ctx)
617 : {
618 : NTSTATUS status;
619 : enum rpc_service_mode_e service_mode;
620 60 : const struct dcesrv_endpoint_server *ep_server = NULL;
621 :
622 : /* Register the endpoint server in DCERPC core */
623 60 : ep_server = wkssvc_get_ep_server();
624 60 : if (ep_server == NULL) {
625 0 : DBG_ERR("Failed to get 'wkssvc' endpoint server\n");
626 0 : return NT_STATUS_UNSUCCESSFUL;
627 : }
628 :
629 60 : service_mode = rpc_service_mode(ep_server->name);
630 60 : if (service_mode != RPC_SERVICE_MODE_EMBEDDED) {
631 32 : return NT_STATUS_OK;
632 : }
633 :
634 28 : status = dcerpc_register_ep_server(ep_server);
635 28 : if (!NT_STATUS_IS_OK(status)) {
636 0 : DBG_ERR("Failed to register '%s' endpoint server: "
637 : "%s\n", ep_server->name, nt_errstr(status));
638 0 : return status;
639 : }
640 :
641 28 : return NT_STATUS_OK;
642 : }
643 :
644 60 : static NTSTATUS rpc_setup_spoolss(struct tevent_context *ev_ctx,
645 : struct messaging_context *msg_ctx)
646 : {
647 60 : enum rpc_daemon_type_e spoolss_type = rpc_spoolss_daemon();
648 60 : NTSTATUS status = NT_STATUS_UNSUCCESSFUL;
649 : enum rpc_service_mode_e service_mode;
650 60 : const struct dcesrv_endpoint_server *ep_server = NULL;
651 :
652 60 : if (lp__disable_spoolss()) {
653 0 : return NT_STATUS_OK;
654 : }
655 :
656 : /* Register the endpoint server in DCERPC core */
657 60 : ep_server = spoolss_get_ep_server();
658 60 : if (ep_server == NULL) {
659 0 : DBG_ERR("Failed to get 'spoolss' endpoint server\n");
660 0 : return NT_STATUS_UNSUCCESSFUL;
661 : }
662 :
663 60 : service_mode = rpc_service_mode(ep_server->name);
664 62 : if (service_mode != RPC_SERVICE_MODE_EMBEDDED ||
665 2 : spoolss_type != RPC_DAEMON_EMBEDDED) {
666 8 : return NT_STATUS_OK;
667 : }
668 :
669 52 : status = dcerpc_register_ep_server(ep_server);
670 52 : if (!NT_STATUS_IS_OK(status)) {
671 0 : DBG_ERR("Failed to register '%s' endpoint server"
672 : ": %s\n", ep_server->name, nt_errstr(status));
673 0 : return status;
674 : }
675 :
676 52 : return NT_STATUS_OK;
677 : }
678 :
679 60 : static NTSTATUS rpc_setup_svcctl(struct tevent_context *ev_ctx,
680 : struct messaging_context *msg_ctx)
681 : {
682 : NTSTATUS status;
683 : enum rpc_service_mode_e service_mode;
684 60 : const struct dcesrv_endpoint_server *ep_server = NULL;
685 :
686 : /* Register the endpoint server in DCERPC core */
687 60 : ep_server = svcctl_get_ep_server();
688 60 : if (ep_server == NULL) {
689 0 : DBG_ERR("Failed to get 'svcctl' endpoint server\n");
690 0 : return NT_STATUS_UNSUCCESSFUL;
691 : }
692 :
693 60 : service_mode = rpc_service_mode(ep_server->name);
694 60 : if (service_mode != RPC_SERVICE_MODE_EMBEDDED) {
695 0 : return NT_STATUS_OK;
696 : }
697 :
698 60 : status = dcerpc_register_ep_server(ep_server);
699 60 : if (!NT_STATUS_IS_OK(status)) {
700 0 : DBG_ERR("Failed to register '%s' endpoint server"
701 : ": %s\n", ep_server->name, nt_errstr(status));
702 0 : return status;
703 : }
704 :
705 60 : return NT_STATUS_OK;
706 : }
707 :
708 60 : static NTSTATUS rpc_setup_ntsvcs(struct tevent_context *ev_ctx,
709 : struct messaging_context *msg_ctx)
710 : {
711 : NTSTATUS status;
712 : enum rpc_service_mode_e service_mode;
713 60 : const struct dcesrv_endpoint_server *ep_server = NULL;
714 :
715 : /* Register the endpoint server in DCERPC core */
716 60 : ep_server = ntsvcs_get_ep_server();
717 60 : if (ep_server == NULL) {
718 0 : DBG_ERR("Failed to get 'ntsvcs' endpoint server\n");
719 0 : return NT_STATUS_UNSUCCESSFUL;
720 : }
721 :
722 60 : service_mode = rpc_service_mode(ep_server->name);
723 60 : if (service_mode != RPC_SERVICE_MODE_EMBEDDED) {
724 0 : return NT_STATUS_OK;
725 : }
726 :
727 60 : status = dcerpc_register_ep_server(ep_server);
728 60 : if (!NT_STATUS_IS_OK(status)) {
729 0 : DBG_ERR("Failed to register '%s' endpoint server"
730 : ": %s\n", ep_server->name, nt_errstr(status));
731 0 : return status;
732 : }
733 :
734 60 : return NT_STATUS_OK;
735 : }
736 :
737 60 : static NTSTATUS rpc_setup_eventlog(struct tevent_context *ev_ctx,
738 : struct messaging_context *msg_ctx)
739 : {
740 : NTSTATUS status;
741 : enum rpc_service_mode_e service_mode;
742 60 : const struct dcesrv_endpoint_server *ep_server = NULL;
743 :
744 : /* Register the endpoint server in DCERPC core */
745 60 : ep_server = eventlog_get_ep_server();
746 60 : if (ep_server == NULL) {
747 0 : DBG_ERR("Failed to get 'eventlog' endpoint server\n");
748 0 : return NT_STATUS_UNSUCCESSFUL;
749 : }
750 :
751 60 : service_mode = rpc_service_mode(ep_server->name);
752 60 : if (service_mode != RPC_SERVICE_MODE_EMBEDDED) {
753 0 : return NT_STATUS_OK;
754 : }
755 :
756 60 : status = dcerpc_register_ep_server(ep_server);
757 60 : if (!NT_STATUS_IS_OK(status)) {
758 0 : DBG_ERR("Failed to register '%s' endpoint server"
759 : ": %s\n", ep_server->name, nt_errstr(status));
760 0 : return status;
761 : }
762 :
763 60 : return NT_STATUS_OK;
764 : }
765 :
766 60 : static NTSTATUS rpc_setup_initshutdown(struct tevent_context *ev_ctx,
767 : struct messaging_context *msg_ctx)
768 : {
769 : NTSTATUS status;
770 : enum rpc_service_mode_e service_mode;
771 60 : const struct dcesrv_endpoint_server *ep_server = NULL;
772 :
773 : /* Register the endpoint server in DCERPC core */
774 60 : ep_server = initshutdown_get_ep_server();
775 60 : if (ep_server == NULL) {
776 0 : DBG_ERR("Failed to get 'initshutdown' endpoint server\n");
777 0 : return NT_STATUS_UNSUCCESSFUL;
778 : }
779 :
780 60 : service_mode = rpc_service_mode(ep_server->name);
781 60 : if (service_mode != RPC_SERVICE_MODE_EMBEDDED) {
782 32 : return NT_STATUS_OK;
783 : }
784 :
785 28 : status = dcerpc_register_ep_server(ep_server);
786 28 : if (!NT_STATUS_IS_OK(status)) {
787 0 : DBG_ERR("Failed to register '%s' endpoint "
788 : "server: %s\n", ep_server->name, nt_errstr(status));
789 0 : return status;
790 : }
791 :
792 28 : return NT_STATUS_OK;
793 : }
794 :
795 60 : NTSTATUS dcesrv_init(TALLOC_CTX *mem_ctx,
796 : struct tevent_context *ev_ctx,
797 : struct messaging_context *msg_ctx,
798 : struct dcesrv_context *dce_ctx)
799 : {
800 : TALLOC_CTX *tmp_ctx;
801 : bool ok;
802 60 : init_module_fn *mod_init_fns = NULL;
803 : NTSTATUS status;
804 :
805 60 : tmp_ctx = talloc_stackframe();
806 60 : if (tmp_ctx == NULL) {
807 0 : return NT_STATUS_NO_MEMORY;
808 : }
809 :
810 60 : DBG_INFO("Registering DCE/RPC endpoint servers\n");
811 :
812 60 : status = rpc_setup_winreg(ev_ctx, msg_ctx);
813 60 : if (!NT_STATUS_IS_OK(status)) {
814 0 : goto done;
815 : }
816 :
817 60 : status = rpc_setup_srvsvc(ev_ctx, msg_ctx);
818 60 : if (!NT_STATUS_IS_OK(status)) {
819 0 : goto done;
820 : }
821 :
822 60 : status = rpc_setup_lsarpc(ev_ctx, msg_ctx);
823 60 : if (!NT_STATUS_IS_OK(status)) {
824 0 : goto done;
825 : }
826 :
827 60 : status = rpc_setup_samr(ev_ctx, msg_ctx);
828 60 : if (!NT_STATUS_IS_OK(status)) {
829 0 : goto done;
830 : }
831 :
832 60 : status = rpc_setup_netlogon(ev_ctx, msg_ctx);
833 60 : if (!NT_STATUS_IS_OK(status)) {
834 0 : goto done;
835 : }
836 :
837 60 : status = rpc_setup_netdfs(ev_ctx, msg_ctx);
838 60 : if (!NT_STATUS_IS_OK(status)) {
839 0 : goto done;
840 : }
841 :
842 : #ifdef DEVELOPER
843 60 : status = rpc_setup_rpcecho(ev_ctx, msg_ctx);
844 60 : if (!NT_STATUS_IS_OK(status)) {
845 0 : goto done;
846 : }
847 : #endif
848 :
849 60 : status = rpc_setup_dssetup(ev_ctx, msg_ctx);
850 60 : if (!NT_STATUS_IS_OK(status)) {
851 0 : goto done;
852 : }
853 :
854 60 : status = rpc_setup_wkssvc(ev_ctx, msg_ctx);
855 60 : if (!NT_STATUS_IS_OK(status)) {
856 0 : goto done;
857 : }
858 :
859 60 : status = rpc_setup_spoolss(ev_ctx, msg_ctx);
860 60 : if (!NT_STATUS_IS_OK(status)) {
861 0 : goto done;
862 : }
863 :
864 60 : status = rpc_setup_svcctl(ev_ctx, msg_ctx);
865 60 : if (!NT_STATUS_IS_OK(status)) {
866 0 : goto done;
867 : }
868 :
869 60 : status = rpc_setup_ntsvcs(ev_ctx, msg_ctx);
870 60 : if (!NT_STATUS_IS_OK(status)) {
871 0 : goto done;
872 : }
873 :
874 60 : status = rpc_setup_eventlog(ev_ctx, msg_ctx);
875 60 : if (!NT_STATUS_IS_OK(status)) {
876 0 : goto done;
877 : }
878 :
879 60 : status = rpc_setup_initshutdown(ev_ctx, msg_ctx);
880 60 : if (!NT_STATUS_IS_OK(status)) {
881 0 : goto done;
882 : }
883 :
884 60 : DBG_INFO("Initializing DCE/RPC modules\n");
885 :
886 : /* Initialize static subsystems */
887 60 : static_init_rpc(NULL);
888 :
889 : /* Initialize shared modules */
890 60 : mod_init_fns = load_samba_modules(tmp_ctx, "rpc");
891 60 : if ((mod_init_fns == NULL) && (errno != ENOENT)) {
892 : /*
893 : * ENOENT means the directory doesn't exist which can happen if
894 : * all modules are static. So ENOENT is ok, everything else is
895 : * not ok.
896 : */
897 0 : DBG_ERR("Loading shared DCE/RPC modules failed [%s]\n",
898 : strerror(errno));
899 0 : status = NT_STATUS_UNSUCCESSFUL;
900 0 : goto done;
901 : }
902 :
903 60 : ok = run_init_functions(NULL, mod_init_fns);
904 60 : if (!ok) {
905 0 : DBG_ERR("Initializing shared DCE/RPC modules failed\n");
906 0 : status = NT_STATUS_UNSUCCESSFUL;
907 0 : goto done;
908 : }
909 :
910 : /* The RPC module setup function has to register the endpoint server */
911 60 : ok = setup_rpc_modules(ev_ctx, msg_ctx);
912 60 : if (!ok) {
913 0 : DBG_ERR("Shared DCE/RPC modules setup failed\n");
914 0 : status = NT_STATUS_UNSUCCESSFUL;
915 0 : goto done;
916 : }
917 :
918 60 : DBG_INFO("Initializing DCE/RPC registered endpoint servers\n");
919 :
920 60 : status = dcesrv_init_registered_ep_servers(dce_ctx);
921 60 : if (!NT_STATUS_IS_OK(status)) {
922 0 : DBG_ERR("Failed to init DCE/RPC endpoint servers: %s\n",
923 : nt_errstr(status));
924 0 : goto done;
925 : }
926 :
927 60 : DBG_INFO("Initializing DCE/RPC connection endpoints\n");
928 :
929 60 : status = dcesrv_init_endpoints(ev_ctx, msg_ctx, dce_ctx);
930 60 : if (!NT_STATUS_IS_OK(status)) {
931 0 : DBG_ERR("Failed to init DCE/RPC endpoints: %s\n",
932 : nt_errstr(status));
933 0 : goto done;
934 : }
935 :
936 58 : status = NT_STATUS_OK;
937 60 : done:
938 60 : talloc_free(tmp_ctx);
939 60 : return status;
940 : }
941 :
942 : /* vim: set ts=8 sw=8 noet cindent ft=c.doxygen: */
|
