2 * Unix SMB/CIFS implementation.
4 * SMBD RPC service callbacks
6 * Copyright (c) 2011 Andreas Schneider <asn@samba.org>
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.
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.
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/>.
25 #include "../librpc/gen_ndr/ndr_epmapper_c.h"
26 #include "../librpc/gen_ndr/srv_epmapper.h"
27 #include "../librpc/gen_ndr/srv_srvsvc.h"
28 #include "../librpc/gen_ndr/srv_winreg.h"
29 #include "../librpc/gen_ndr/srv_dfs.h"
30 #include "../librpc/gen_ndr/srv_dssetup.h"
31 #include "../librpc/gen_ndr/srv_echo.h"
32 #include "../librpc/gen_ndr/srv_eventlog.h"
33 #include "../librpc/gen_ndr/srv_initshutdown.h"
34 #include "../librpc/gen_ndr/srv_lsa.h"
35 #include "../librpc/gen_ndr/srv_netlogon.h"
36 #include "../librpc/gen_ndr/srv_ntsvcs.h"
37 #include "../librpc/gen_ndr/srv_samr.h"
38 #include "../librpc/gen_ndr/srv_spoolss.h"
39 #include "../librpc/gen_ndr/srv_svcctl.h"
40 #include "../librpc/gen_ndr/srv_wkssvc.h"
42 #include "printing/nt_printing_migrate_internal.h"
43 #include "rpc_server/eventlog/srv_eventlog_reg.h"
44 #include "rpc_server/svcctl/srv_svcctl_reg.h"
45 #include "rpc_server/spoolss/srv_spoolss_nt.h"
46 #include "rpc_server/svcctl/srv_svcctl_nt.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/epmapper/srv_epmapper.h"
56 static bool rpc_setup_epmapper(struct tevent_context
*ev_ctx
,
57 struct messaging_context
*msg_ctx
)
59 enum rpc_service_mode_e epm_mode
= rpc_epmapper_mode();
60 enum rpc_daemon_type_e epm_type
= rpc_epmapper_daemon();
63 if (epm_mode
!= RPC_SERVICE_MODE_DISABLED
&&
64 epm_type
!= RPC_DAEMON_DISABLED
) {
65 status
= rpc_epmapper_init(NULL
);
66 if (!NT_STATUS_IS_OK(status
)) {
74 static bool rpc_setup_winreg(struct tevent_context
*ev_ctx
,
75 struct messaging_context
*msg_ctx
,
76 const struct dcerpc_binding_vector
*v
)
78 const struct ndr_interface_table
*t
= &ndr_table_winreg
;
79 const char *pipe_name
= "winreg";
80 struct dcerpc_binding_vector
*v2
;
81 enum rpc_service_mode_e epm_mode
= rpc_epmapper_mode();
85 status
= rpc_winreg_init(NULL
);
86 if (!NT_STATUS_IS_OK(status
)) {
90 if (epm_mode
!= RPC_SERVICE_MODE_DISABLED
) {
91 v2
= dcerpc_binding_vector_dup(talloc_tos(), v
);
96 status
= dcerpc_binding_vector_replace_iface(t
, v2
);
97 if (!NT_STATUS_IS_OK(status
)) {
101 status
= dcerpc_binding_vector_add_np_default(t
, v2
);
102 if (!NT_STATUS_IS_OK(status
)) {
106 ok
= setup_dcerpc_ncalrpc_socket(ev_ctx
,
114 status
= dcerpc_binding_vector_add_unix(t
, v2
, pipe_name
);
115 if (!NT_STATUS_IS_OK(status
)) {
119 status
= rpc_ep_register(ev_ctx
,
123 if (!NT_STATUS_IS_OK(status
)) {
131 static bool rpc_setup_srvsvc(struct tevent_context
*ev_ctx
,
132 struct messaging_context
*msg_ctx
,
133 const struct dcerpc_binding_vector
*v
)
135 const struct ndr_interface_table
*t
= &ndr_table_srvsvc
;
136 const char *pipe_name
= "srvsvc";
137 struct dcerpc_binding_vector
*v2
;
138 enum rpc_service_mode_e epm_mode
= rpc_epmapper_mode();
142 status
= rpc_srvsvc_init(NULL
);
143 if (!NT_STATUS_IS_OK(status
)) {
147 if (epm_mode
!= RPC_SERVICE_MODE_DISABLED
) {
148 v2
= dcerpc_binding_vector_dup(talloc_tos(), v
);
153 status
= dcerpc_binding_vector_replace_iface(t
, v2
);
154 if (!NT_STATUS_IS_OK(status
)) {
158 status
= dcerpc_binding_vector_add_np_default(t
, v2
);
159 if (!NT_STATUS_IS_OK(status
)) {
163 ok
= setup_dcerpc_ncalrpc_socket(ev_ctx
,
171 status
= dcerpc_binding_vector_add_unix(t
, v2
, pipe_name
);
172 if (!NT_STATUS_IS_OK(status
)) {
176 status
= rpc_ep_register(ev_ctx
,
180 if (!NT_STATUS_IS_OK(status
)) {
188 static bool rpc_setup_lsarpc(struct tevent_context
*ev_ctx
,
189 struct messaging_context
*msg_ctx
,
190 const struct dcerpc_binding_vector
*v
)
192 const struct ndr_interface_table
*t
= &ndr_table_lsarpc
;
193 const char *pipe_name
= "lsarpc";
194 struct dcerpc_binding_vector
*v2
;
195 enum rpc_service_mode_e epm_mode
= rpc_epmapper_mode();
196 enum rpc_service_mode_e lsarpc_mode
= rpc_lsarpc_mode();
197 enum rpc_daemon_type_e lsasd_type
= rpc_lsasd_daemon();
201 status
= rpc_lsarpc_init(NULL
);
202 if (!NT_STATUS_IS_OK(status
)) {
206 if (lsarpc_mode
== RPC_SERVICE_MODE_EMBEDDED
&&
207 lsasd_type
!= RPC_DAEMON_DISABLED
&&
208 epm_mode
!= RPC_SERVICE_MODE_DISABLED
) {
209 v2
= dcerpc_binding_vector_dup(talloc_tos(), v
);
214 status
= dcerpc_binding_vector_replace_iface(t
, v2
);
215 if (!NT_STATUS_IS_OK(status
)) {
219 status
= dcerpc_binding_vector_add_np_default(t
, v2
);
220 if (!NT_STATUS_IS_OK(status
)) {
224 ok
= setup_dcerpc_ncalrpc_socket(ev_ctx
,
232 status
= dcerpc_binding_vector_add_unix(t
, v2
, pipe_name
);
233 if (!NT_STATUS_IS_OK(status
)) {
237 status
= rpc_ep_register(ev_ctx
,
241 if (!NT_STATUS_IS_OK(status
)) {
249 static bool rpc_setup_samr(struct tevent_context
*ev_ctx
,
250 struct messaging_context
*msg_ctx
,
251 const struct dcerpc_binding_vector
*v
)
253 const struct ndr_interface_table
*t
= &ndr_table_samr
;
254 const char *pipe_name
= "samr";
255 struct dcerpc_binding_vector
*v2
;
256 enum rpc_service_mode_e epm_mode
= rpc_epmapper_mode();
257 enum rpc_service_mode_e samr_mode
= rpc_samr_mode();
258 enum rpc_daemon_type_e lsasd_type
= rpc_lsasd_daemon();
262 status
= rpc_samr_init(NULL
);
263 if (!NT_STATUS_IS_OK(status
)) {
267 if (samr_mode
== RPC_SERVICE_MODE_EMBEDDED
&&
268 lsasd_type
!= RPC_DAEMON_DISABLED
&&
269 epm_mode
!= RPC_SERVICE_MODE_DISABLED
) {
270 v2
= dcerpc_binding_vector_dup(talloc_tos(), v
);
275 status
= dcerpc_binding_vector_replace_iface(t
, v2
);
276 if (!NT_STATUS_IS_OK(status
)) {
280 status
= dcerpc_binding_vector_add_np_default(t
, v2
);
281 if (!NT_STATUS_IS_OK(status
)) {
285 ok
= setup_dcerpc_ncalrpc_socket(ev_ctx
,
293 status
= dcerpc_binding_vector_add_unix(t
, v2
, pipe_name
);
294 if (!NT_STATUS_IS_OK(status
)) {
298 status
= rpc_ep_register(ev_ctx
,
302 if (!NT_STATUS_IS_OK(status
)) {
310 static bool rpc_setup_netlogon(struct tevent_context
*ev_ctx
,
311 struct messaging_context
*msg_ctx
,
312 const struct dcerpc_binding_vector
*v
)
314 const struct ndr_interface_table
*t
= &ndr_table_netlogon
;
315 const char *pipe_name
= "netlogon";
316 struct dcerpc_binding_vector
*v2
;
317 enum rpc_service_mode_e epm_mode
= rpc_epmapper_mode();
318 enum rpc_service_mode_e netlogon_mode
= rpc_netlogon_mode();
319 enum rpc_daemon_type_e lsasd_type
= rpc_lsasd_daemon();
323 status
= rpc_netlogon_init(NULL
);
324 if (!NT_STATUS_IS_OK(status
)) {
328 if (netlogon_mode
== RPC_SERVICE_MODE_EMBEDDED
&&
329 lsasd_type
!= RPC_DAEMON_DISABLED
&&
330 epm_mode
!= RPC_SERVICE_MODE_DISABLED
) {
331 v2
= dcerpc_binding_vector_dup(talloc_tos(), v
);
336 status
= dcerpc_binding_vector_replace_iface(t
, v2
);
337 if (!NT_STATUS_IS_OK(status
)) {
341 status
= dcerpc_binding_vector_add_np_default(t
, v2
);
342 if (!NT_STATUS_IS_OK(status
)) {
346 ok
= setup_dcerpc_ncalrpc_socket(ev_ctx
,
354 status
= dcerpc_binding_vector_add_unix(t
, v2
, pipe_name
);
355 if (!NT_STATUS_IS_OK(status
)) {
359 status
= rpc_ep_register(ev_ctx
,
363 if (!NT_STATUS_IS_OK(status
)) {
371 static bool rpc_setup_netdfs(struct tevent_context
*ev_ctx
,
372 struct messaging_context
*msg_ctx
,
373 const struct dcerpc_binding_vector
*v
)
375 const struct ndr_interface_table
*t
= &ndr_table_netdfs
;
376 const char *pipe_name
= "netdfs";
377 struct dcerpc_binding_vector
*v2
;
378 enum rpc_service_mode_e epm_mode
= rpc_epmapper_mode();
382 status
= rpc_netdfs_init(NULL
);
383 if (!NT_STATUS_IS_OK(status
)) {
387 if (epm_mode
!= RPC_SERVICE_MODE_DISABLED
) {
388 v2
= dcerpc_binding_vector_dup(talloc_tos(), v
);
393 status
= dcerpc_binding_vector_replace_iface(t
, v2
);
394 if (!NT_STATUS_IS_OK(status
)) {
398 status
= dcerpc_binding_vector_add_np_default(t
, v2
);
399 if (!NT_STATUS_IS_OK(status
)) {
403 ok
= setup_dcerpc_ncalrpc_socket(ev_ctx
,
411 status
= dcerpc_binding_vector_add_unix(t
, v2
, pipe_name
);
412 if (!NT_STATUS_IS_OK(status
)) {
416 status
= rpc_ep_register(ev_ctx
,
420 if (!NT_STATUS_IS_OK(status
)) {
429 static bool rpc_setup_rpcecho(struct tevent_context
*ev_ctx
,
430 struct messaging_context
*msg_ctx
,
431 const struct dcerpc_binding_vector
*v
)
433 const struct ndr_interface_table
*t
= &ndr_table_rpcecho
;
434 const char *pipe_name
= "rpcecho";
435 struct dcerpc_binding_vector
*v2
;
436 enum rpc_service_mode_e epm_mode
= rpc_epmapper_mode();
440 status
= rpc_rpcecho_init(NULL
);
441 if (!NT_STATUS_IS_OK(status
)) {
445 if (epm_mode
!= RPC_SERVICE_MODE_DISABLED
) {
446 v2
= dcerpc_binding_vector_dup(talloc_tos(), v
);
451 status
= dcerpc_binding_vector_replace_iface(t
, v2
);
452 if (!NT_STATUS_IS_OK(status
)) {
456 status
= dcerpc_binding_vector_add_np_default(t
, v2
);
457 if (!NT_STATUS_IS_OK(status
)) {
461 ok
= setup_dcerpc_ncalrpc_socket(ev_ctx
,
469 status
= dcerpc_binding_vector_add_unix(t
, v2
, pipe_name
);
470 if (!NT_STATUS_IS_OK(status
)) {
474 status
= rpc_ep_register(ev_ctx
,
478 if (!NT_STATUS_IS_OK(status
)) {
487 static bool rpc_setup_dssetup(struct tevent_context
*ev_ctx
,
488 struct messaging_context
*msg_ctx
,
489 const struct dcerpc_binding_vector
*v
)
491 const struct ndr_interface_table
*t
= &ndr_table_dssetup
;
492 const char *pipe_name
= "dssetup";
493 struct dcerpc_binding_vector
*v2
;
494 enum rpc_service_mode_e epm_mode
= rpc_epmapper_mode();
498 status
= rpc_dssetup_init(NULL
);
499 if (!NT_STATUS_IS_OK(status
)) {
503 if (epm_mode
!= RPC_SERVICE_MODE_DISABLED
) {
504 v2
= dcerpc_binding_vector_dup(talloc_tos(), v
);
509 status
= dcerpc_binding_vector_replace_iface(t
, v2
);
510 if (!NT_STATUS_IS_OK(status
)) {
514 status
= dcerpc_binding_vector_add_np_default(t
, v2
);
515 if (!NT_STATUS_IS_OK(status
)) {
519 ok
= setup_dcerpc_ncalrpc_socket(ev_ctx
,
527 status
= dcerpc_binding_vector_add_unix(t
, v2
, pipe_name
);
528 if (!NT_STATUS_IS_OK(status
)) {
532 status
= rpc_ep_register(ev_ctx
,
536 if (!NT_STATUS_IS_OK(status
)) {
544 static bool rpc_setup_wkssvc(struct tevent_context
*ev_ctx
,
545 struct messaging_context
*msg_ctx
,
546 const struct dcerpc_binding_vector
*v
)
548 const struct ndr_interface_table
*t
= &ndr_table_wkssvc
;
549 const char *pipe_name
= "wkssvc";
550 struct dcerpc_binding_vector
*v2
;
551 enum rpc_service_mode_e epm_mode
= rpc_epmapper_mode();
555 status
= rpc_wkssvc_init(NULL
);
556 if (!NT_STATUS_IS_OK(status
)) {
560 if (epm_mode
!= RPC_SERVICE_MODE_DISABLED
) {
561 v2
= dcerpc_binding_vector_dup(talloc_tos(), v
);
566 status
= dcerpc_binding_vector_replace_iface(t
, v2
);
567 if (!NT_STATUS_IS_OK(status
)) {
571 status
= dcerpc_binding_vector_add_np_default(t
, v2
);
572 if (!NT_STATUS_IS_OK(status
)) {
576 ok
= setup_dcerpc_ncalrpc_socket(ev_ctx
,
584 status
= dcerpc_binding_vector_add_unix(t
, v2
, pipe_name
);
585 if (!NT_STATUS_IS_OK(status
)) {
589 status
= rpc_ep_register(ev_ctx
,
593 if (!NT_STATUS_IS_OK(status
)) {
601 static bool spoolss_init_cb(void *ptr
)
603 struct messaging_context
*msg_ctx
=
604 talloc_get_type_abort(ptr
, struct messaging_context
);
608 * Migrate the printers first.
610 ok
= nt_printing_tdb_migrate(msg_ctx
);
618 static bool spoolss_shutdown_cb(void *ptr
)
620 srv_spoolss_cleanup();
625 static bool rpc_setup_spoolss(struct tevent_context
*ev_ctx
,
626 struct messaging_context
*msg_ctx
)
628 const struct ndr_interface_table
*t
= &ndr_table_spoolss
;
629 struct rpc_srv_callbacks spoolss_cb
;
630 struct dcerpc_binding_vector
*v
;
631 enum rpc_service_mode_e spoolss_mode
= rpc_spoolss_mode();
632 enum rpc_daemon_type_e spoolss_type
= rpc_spoolss_daemon();
633 NTSTATUS status
= NT_STATUS_UNSUCCESSFUL
;
635 if (_lp_disable_spoolss() ||
636 spoolss_type
== RPC_DAEMON_DISABLED
||
637 spoolss_mode
== RPC_SERVICE_MODE_DISABLED
) {
641 if (spoolss_type
== RPC_DAEMON_EMBEDDED
) {
642 spoolss_cb
.init
= spoolss_init_cb
;
643 spoolss_cb
.shutdown
= spoolss_shutdown_cb
;
644 spoolss_cb
.private_data
= msg_ctx
;
646 status
= rpc_spoolss_init(&spoolss_cb
);
647 } else if (spoolss_type
== RPC_DAEMON_FORK
) {
648 status
= rpc_spoolss_init(NULL
);
650 if (!NT_STATUS_IS_OK(status
)) {
654 if (spoolss_type
== RPC_DAEMON_EMBEDDED
) {
655 enum rpc_service_mode_e epm_mode
= rpc_epmapper_mode();
657 if (epm_mode
!= RPC_SERVICE_MODE_DISABLED
) {
658 status
= dcerpc_binding_vector_new(talloc_tos(), &v
);
659 if (!NT_STATUS_IS_OK(status
)) {
663 status
= dcerpc_binding_vector_add_np_default(t
, v
);
664 if (!NT_STATUS_IS_OK(status
)) {
668 status
= rpc_ep_register(ev_ctx
,
672 if (!NT_STATUS_IS_OK(status
)) {
681 static bool svcctl_init_cb(void *ptr
)
683 struct messaging_context
*msg_ctx
=
684 talloc_get_type_abort(ptr
, struct messaging_context
);
687 /* initialize the control hooks */
688 init_service_op_table();
690 ok
= svcctl_init_winreg(msg_ctx
);
698 static bool svcctl_shutdown_cb(void *ptr
)
700 shutdown_service_op_table();
705 static bool rpc_setup_svcctl(struct tevent_context
*ev_ctx
,
706 struct messaging_context
*msg_ctx
)
708 const struct ndr_interface_table
*t
= &ndr_table_svcctl
;
709 const char *pipe_name
= "svcctl";
710 struct dcerpc_binding_vector
*v
;
711 enum rpc_service_mode_e epm_mode
= rpc_epmapper_mode();
712 struct rpc_srv_callbacks svcctl_cb
;
716 svcctl_cb
.init
= svcctl_init_cb
;
717 svcctl_cb
.shutdown
= svcctl_shutdown_cb
;
718 svcctl_cb
.private_data
= msg_ctx
;
720 status
= rpc_svcctl_init(&svcctl_cb
);
721 if (!NT_STATUS_IS_OK(status
)) {
725 if (epm_mode
!= RPC_SERVICE_MODE_DISABLED
) {
726 status
= dcerpc_binding_vector_new(talloc_tos(), &v
);
727 if (!NT_STATUS_IS_OK(status
)) {
731 status
= dcerpc_binding_vector_add_np_default(t
, v
);
732 if (!NT_STATUS_IS_OK(status
)) {
736 ok
= setup_dcerpc_ncalrpc_socket(ev_ctx
,
744 status
= dcerpc_binding_vector_add_unix(t
, v
, pipe_name
);
745 if (!NT_STATUS_IS_OK(status
)) {
749 status
= rpc_ep_register(ev_ctx
,
753 if (!NT_STATUS_IS_OK(status
)) {
761 static bool rpc_setup_ntsvcs(struct tevent_context
*ev_ctx
,
762 struct messaging_context
*msg_ctx
)
764 const struct ndr_interface_table
*t
= &ndr_table_ntsvcs
;
765 struct dcerpc_binding_vector
*v
;
766 enum rpc_service_mode_e epm_mode
= rpc_epmapper_mode();
769 status
= rpc_ntsvcs_init(NULL
);
770 if (!NT_STATUS_IS_OK(status
)) {
774 if (epm_mode
!= RPC_SERVICE_MODE_DISABLED
) {
775 status
= dcerpc_binding_vector_new(talloc_tos(), &v
);
776 if (!NT_STATUS_IS_OK(status
)) {
780 status
= dcerpc_binding_vector_add_np_default(t
, v
);
781 if (!NT_STATUS_IS_OK(status
)) {
785 status
= rpc_ep_register(ev_ctx
,
789 if (!NT_STATUS_IS_OK(status
)) {
797 static bool eventlog_init_cb(void *ptr
)
799 struct messaging_context
*msg_ctx
=
800 talloc_get_type_abort(ptr
, struct messaging_context
);
803 ok
= eventlog_init_winreg(msg_ctx
);
811 static bool rpc_setup_eventlog(struct tevent_context
*ev_ctx
,
812 struct messaging_context
*msg_ctx
)
814 const struct ndr_interface_table
*t
= &ndr_table_eventlog
;
815 struct rpc_srv_callbacks eventlog_cb
;
816 struct dcerpc_binding_vector
*v
;
817 enum rpc_service_mode_e epm_mode
= rpc_epmapper_mode();
820 eventlog_cb
.init
= eventlog_init_cb
;
821 eventlog_cb
.shutdown
= NULL
;
822 eventlog_cb
.private_data
= msg_ctx
;
824 status
= rpc_eventlog_init(&eventlog_cb
);
825 if (!NT_STATUS_IS_OK(status
)) {
829 if (epm_mode
!= RPC_SERVICE_MODE_DISABLED
) {
830 status
= dcerpc_binding_vector_new(talloc_tos(), &v
);
831 if (!NT_STATUS_IS_OK(status
)) {
835 status
= dcerpc_binding_vector_add_np_default(t
, v
);
836 if (!NT_STATUS_IS_OK(status
)) {
840 status
= rpc_ep_register(ev_ctx
,
844 if (!NT_STATUS_IS_OK(status
)) {
852 static bool rpc_setup_initshutdown(struct tevent_context
*ev_ctx
,
853 struct messaging_context
*msg_ctx
)
855 const struct ndr_interface_table
*t
= &ndr_table_initshutdown
;
856 struct dcerpc_binding_vector
*v
;
857 enum rpc_service_mode_e epm_mode
= rpc_epmapper_mode();
860 status
= rpc_initshutdown_init(NULL
);
861 if (!NT_STATUS_IS_OK(status
)) {
865 if (epm_mode
!= RPC_SERVICE_MODE_DISABLED
) {
866 status
= dcerpc_binding_vector_new(talloc_tos(), &v
);
867 if (!NT_STATUS_IS_OK(status
)) {
871 status
= dcerpc_binding_vector_add_np_default(t
, v
);
872 if (!NT_STATUS_IS_OK(status
)) {
876 status
= rpc_ep_register(ev_ctx
,
880 if (!NT_STATUS_IS_OK(status
)) {
888 bool dcesrv_ep_setup(struct tevent_context
*ev_ctx
,
889 struct messaging_context
*msg_ctx
)
891 enum rpc_service_mode_e epm_mode
= rpc_epmapper_mode();
892 struct dcerpc_binding_vector
*v
;
893 const char *rpcsrv_type
;
898 tmp_ctx
= talloc_stackframe();
899 if (tmp_ctx
== NULL
) {
903 status
= dcerpc_binding_vector_new(tmp_ctx
,
905 if (!NT_STATUS_IS_OK(status
)) {
910 ok
= rpc_setup_epmapper(ev_ctx
, msg_ctx
);
915 rpcsrv_type
= lp_parm_const_string(GLOBAL_SECTION_SNUM
,
920 if ((strcasecmp_m(rpcsrv_type
, "yes") == 0 ||
921 strcasecmp_m(rpcsrv_type
, "true") == 0)
922 && epm_mode
!= RPC_SERVICE_MODE_DISABLED
) {
923 status
= rpc_setup_tcpip_sockets(ev_ctx
,
928 if (!NT_STATUS_IS_OK(status
)) {
934 ok
= rpc_setup_winreg(ev_ctx
, msg_ctx
, v
);
939 ok
= rpc_setup_srvsvc(ev_ctx
, msg_ctx
, v
);
944 ok
= rpc_setup_lsarpc(ev_ctx
, msg_ctx
, v
);
949 ok
= rpc_setup_samr(ev_ctx
, msg_ctx
, v
);
954 ok
= rpc_setup_netlogon(ev_ctx
, msg_ctx
, v
);
959 ok
= rpc_setup_netdfs(ev_ctx
, msg_ctx
, v
);
965 ok
= rpc_setup_rpcecho(ev_ctx
, msg_ctx
, v
);
971 ok
= rpc_setup_dssetup(ev_ctx
, msg_ctx
, v
);
976 ok
= rpc_setup_wkssvc(ev_ctx
, msg_ctx
, v
);
981 ok
= rpc_setup_spoolss(ev_ctx
, msg_ctx
);
986 ok
= rpc_setup_svcctl(ev_ctx
, msg_ctx
);
991 ok
= rpc_setup_ntsvcs(ev_ctx
, msg_ctx
);
996 ok
= rpc_setup_eventlog(ev_ctx
, msg_ctx
);
1001 ok
= rpc_setup_initshutdown(ev_ctx
, msg_ctx
);
1007 talloc_free(tmp_ctx
);
1011 /* vim: set ts=8 sw=8 noet cindent ft=c.doxygen: */