s3-rpc_server: Do not setup ncalrpc pipes and TCP for embedded rpc servers
[nivanova/samba-autobuild/.git] / source3 / rpc_server / rpc_service_setup.c
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_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"
41
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"
47
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"
55
56 /* Common routine for embedded RPC servers */
57 static bool rpc_setup_embedded(struct tevent_context *ev_ctx,
58                                struct messaging_context *msg_ctx,
59                                const struct ndr_interface_table *t,
60                                const char *pipe_name)
61 {
62         struct dcerpc_binding_vector *v;
63         enum rpc_service_mode_e epm_mode = rpc_epmapper_mode();
64         NTSTATUS status;
65
66         if (epm_mode != RPC_SERVICE_MODE_DISABLED) {
67                 status = dcerpc_binding_vector_new(talloc_tos(), &v);
68                 if (!NT_STATUS_IS_OK(status)) {
69                         return false;
70                 }
71
72                 status = dcerpc_binding_vector_add_np_default(t, v);
73                 if (!NT_STATUS_IS_OK(status)) {
74                         return false;
75                 }
76
77                 status = rpc_ep_register(ev_ctx,
78                                          msg_ctx,
79                                          t,
80                                          v);
81                 if (!NT_STATUS_IS_OK(status)) {
82                         return false;
83                 }
84         }
85
86         return true;
87 }
88
89 static bool rpc_setup_winreg(struct tevent_context *ev_ctx,
90                              struct messaging_context *msg_ctx)
91 {
92         const struct ndr_interface_table *t = &ndr_table_winreg;
93         const char *pipe_name = "winreg";
94         NTSTATUS status;
95         enum rpc_service_mode_e service_mode = rpc_service_mode(t->name);
96         if (service_mode != RPC_SERVICE_MODE_EMBEDDED) {
97                 return true;
98         }
99
100         status = rpc_winreg_init(NULL);
101         if (!NT_STATUS_IS_OK(status)) {
102                 return false;
103         }
104
105         return rpc_setup_embedded(ev_ctx, msg_ctx, t, pipe_name);
106 }
107
108 static bool rpc_setup_srvsvc(struct tevent_context *ev_ctx,
109                              struct messaging_context *msg_ctx)
110 {
111         const struct ndr_interface_table *t = &ndr_table_srvsvc;
112         const char *pipe_name = "srvsvc";
113         NTSTATUS status;
114         enum rpc_service_mode_e service_mode = rpc_service_mode(t->name);
115         if (service_mode != RPC_SERVICE_MODE_EMBEDDED) {
116                 return true;
117         }
118
119         status = rpc_srvsvc_init(NULL);
120         if (!NT_STATUS_IS_OK(status)) {
121                 return false;
122         }
123
124         return rpc_setup_embedded(ev_ctx, msg_ctx, t, pipe_name);
125 }
126
127 static bool rpc_setup_lsarpc(struct tevent_context *ev_ctx,
128                              struct messaging_context *msg_ctx)
129 {
130         const struct ndr_interface_table *t = &ndr_table_lsarpc;
131         const char *pipe_name = "lsarpc";
132         enum rpc_daemon_type_e lsasd_type = rpc_lsasd_daemon();
133         NTSTATUS status;
134         enum rpc_service_mode_e service_mode = rpc_service_mode(t->name);
135         if (service_mode != RPC_SERVICE_MODE_EMBEDDED || lsasd_type != RPC_DAEMON_EMBEDDED) {
136                 return true;
137         }
138
139         status = rpc_lsarpc_init(NULL);
140         if (!NT_STATUS_IS_OK(status)) {
141                 return false;
142         }
143
144         return rpc_setup_embedded(ev_ctx, msg_ctx, t, pipe_name);
145 }
146
147 static bool rpc_setup_samr(struct tevent_context *ev_ctx,
148                            struct messaging_context *msg_ctx)
149 {
150         const struct ndr_interface_table *t = &ndr_table_samr;
151         const char *pipe_name = "samr";
152         enum rpc_daemon_type_e lsasd_type = rpc_lsasd_daemon();
153         NTSTATUS status;
154         enum rpc_service_mode_e service_mode = rpc_service_mode(t->name);
155         if (service_mode != RPC_SERVICE_MODE_EMBEDDED || lsasd_type != RPC_DAEMON_EMBEDDED) {
156                 return true;
157         }
158
159         status = rpc_samr_init(NULL);
160         if (!NT_STATUS_IS_OK(status)) {
161                 return false;
162         }
163
164         return rpc_setup_embedded(ev_ctx, msg_ctx, t, pipe_name);
165 }
166
167 static bool rpc_setup_netlogon(struct tevent_context *ev_ctx,
168                                struct messaging_context *msg_ctx)
169 {
170         const struct ndr_interface_table *t = &ndr_table_netlogon;
171         const char *pipe_name = "netlogon";
172         enum rpc_daemon_type_e lsasd_type = rpc_lsasd_daemon();
173         NTSTATUS status;
174         enum rpc_service_mode_e service_mode = rpc_service_mode(t->name);
175         if (service_mode != RPC_SERVICE_MODE_EMBEDDED || lsasd_type != RPC_DAEMON_EMBEDDED) {
176                 return true;
177         }
178
179         status = rpc_netlogon_init(NULL);
180         if (!NT_STATUS_IS_OK(status)) {
181                 return false;
182         }
183
184         return rpc_setup_embedded(ev_ctx, msg_ctx, t, pipe_name);
185 }
186
187 static bool rpc_setup_netdfs(struct tevent_context *ev_ctx,
188                              struct messaging_context *msg_ctx)
189 {
190         const struct ndr_interface_table *t = &ndr_table_netdfs;
191         const char *pipe_name = "netdfs";
192         NTSTATUS status;
193         enum rpc_service_mode_e service_mode = rpc_service_mode(t->name);
194         if (service_mode != RPC_SERVICE_MODE_EMBEDDED) {
195                 return true;
196         }
197
198         status = rpc_netdfs_init(NULL);
199         if (!NT_STATUS_IS_OK(status)) {
200                 return false;
201         }
202
203         return rpc_setup_embedded(ev_ctx, msg_ctx, t, pipe_name);
204 }
205
206 #ifdef DEVELOPER
207 static bool rpc_setup_rpcecho(struct tevent_context *ev_ctx,
208                               struct messaging_context *msg_ctx)
209 {
210         const struct ndr_interface_table *t = &ndr_table_rpcecho;
211         const char *pipe_name = "rpcecho";
212         NTSTATUS status;
213         enum rpc_service_mode_e service_mode = rpc_service_mode(t->name);
214         if (service_mode != RPC_SERVICE_MODE_EMBEDDED) {
215                 return true;
216         }
217
218         status = rpc_rpcecho_init(NULL);
219         if (!NT_STATUS_IS_OK(status)) {
220                 return false;
221         }
222
223         return rpc_setup_embedded(ev_ctx, msg_ctx, t, pipe_name);
224 }
225 #endif
226
227 static bool rpc_setup_dssetup(struct tevent_context *ev_ctx,
228                               struct messaging_context *msg_ctx)
229 {
230         const struct ndr_interface_table *t = &ndr_table_dssetup;
231         const char *pipe_name = "dssetup";
232         NTSTATUS status;
233         enum rpc_service_mode_e service_mode = rpc_service_mode(t->name);
234         if (service_mode != RPC_SERVICE_MODE_EMBEDDED) {
235                 return true;
236         }
237
238         status = rpc_dssetup_init(NULL);
239         if (!NT_STATUS_IS_OK(status)) {
240                 return false;
241         }
242
243         return rpc_setup_embedded(ev_ctx, msg_ctx, t, pipe_name);
244 }
245
246 static bool rpc_setup_wkssvc(struct tevent_context *ev_ctx,
247                              struct messaging_context *msg_ctx)
248 {
249         const struct ndr_interface_table *t = &ndr_table_wkssvc;
250         const char *pipe_name = "wkssvc";
251         NTSTATUS status;
252         enum rpc_service_mode_e service_mode = rpc_service_mode(t->name);
253         if (service_mode != RPC_SERVICE_MODE_EMBEDDED) {
254                 return true;
255         }
256
257         status = rpc_wkssvc_init(NULL);
258         if (!NT_STATUS_IS_OK(status)) {
259                 return false;
260         }
261
262         return rpc_setup_embedded(ev_ctx, msg_ctx, t, pipe_name);
263 }
264
265 static bool spoolss_init_cb(void *ptr)
266 {
267         struct messaging_context *msg_ctx =
268                 talloc_get_type_abort(ptr, struct messaging_context);
269         bool ok;
270
271         /*
272          * Migrate the printers first.
273          */
274         ok = nt_printing_tdb_migrate(msg_ctx);
275         if (!ok) {
276                 return false;
277         }
278
279         return true;
280 }
281
282 static bool spoolss_shutdown_cb(void *ptr)
283 {
284         srv_spoolss_cleanup();
285
286         return true;
287 }
288
289 static bool rpc_setup_spoolss(struct tevent_context *ev_ctx,
290                               struct messaging_context *msg_ctx)
291 {
292         const struct ndr_interface_table *t = &ndr_table_spoolss;
293         struct rpc_srv_callbacks spoolss_cb;
294         enum rpc_daemon_type_e spoolss_type = rpc_spoolss_daemon();
295         NTSTATUS status = NT_STATUS_UNSUCCESSFUL;
296         enum rpc_service_mode_e service_mode = rpc_service_mode(t->name);
297
298         if (_lp_disable_spoolss()) {
299                 return true;
300         }
301
302         if (service_mode != RPC_SERVICE_MODE_EMBEDDED || spoolss_type != RPC_DAEMON_EMBEDDED) {
303                 return true;
304         }
305
306         spoolss_cb.init         = spoolss_init_cb;
307         spoolss_cb.shutdown     = spoolss_shutdown_cb;
308         spoolss_cb.private_data = msg_ctx;
309
310         status = rpc_spoolss_init(&spoolss_cb);
311         if (!NT_STATUS_IS_OK(status)) {
312                 return false;
313         }
314
315         return rpc_setup_embedded(ev_ctx, msg_ctx, t, NULL);
316 }
317
318 static bool svcctl_init_cb(void *ptr)
319 {
320         struct messaging_context *msg_ctx =
321                 talloc_get_type_abort(ptr, struct messaging_context);
322         bool ok;
323
324         /* initialize the control hooks */
325         init_service_op_table();
326
327         ok = svcctl_init_winreg(msg_ctx);
328         if (!ok) {
329                 return false;
330         }
331
332         return true;
333 }
334
335 static bool svcctl_shutdown_cb(void *ptr)
336 {
337         shutdown_service_op_table();
338
339         return true;
340 }
341
342 static bool rpc_setup_svcctl(struct tevent_context *ev_ctx,
343                              struct messaging_context *msg_ctx)
344 {
345         const struct ndr_interface_table *t = &ndr_table_svcctl;
346         const char *pipe_name = "svcctl";
347         struct rpc_srv_callbacks svcctl_cb;
348         NTSTATUS status;
349         enum rpc_service_mode_e service_mode = rpc_service_mode(t->name);
350         if (service_mode != RPC_SERVICE_MODE_EMBEDDED) {
351                 return true;
352         }
353
354         svcctl_cb.init         = svcctl_init_cb;
355         svcctl_cb.shutdown     = svcctl_shutdown_cb;
356         svcctl_cb.private_data = msg_ctx;
357
358         status = rpc_svcctl_init(&svcctl_cb);
359         if (!NT_STATUS_IS_OK(status)) {
360                 return false;
361         }
362
363         return rpc_setup_embedded(ev_ctx, msg_ctx, t, pipe_name);
364 }
365
366 static bool rpc_setup_ntsvcs(struct tevent_context *ev_ctx,
367                              struct messaging_context *msg_ctx)
368 {
369         const struct ndr_interface_table *t = &ndr_table_ntsvcs;
370         NTSTATUS status;
371         enum rpc_service_mode_e service_mode = rpc_service_mode(t->name);
372         if (service_mode != RPC_SERVICE_MODE_EMBEDDED) {
373                 return true;
374         }
375
376         status = rpc_ntsvcs_init(NULL);
377         if (!NT_STATUS_IS_OK(status)) {
378                 return false;
379         }
380
381         return rpc_setup_embedded(ev_ctx, msg_ctx, t, NULL);
382 }
383
384 static bool eventlog_init_cb(void *ptr)
385 {
386         struct messaging_context *msg_ctx =
387                 talloc_get_type_abort(ptr, struct messaging_context);
388         bool ok;
389
390         ok = eventlog_init_winreg(msg_ctx);
391         if (!ok) {
392                 return false;
393         }
394
395         return true;
396 }
397
398 static bool rpc_setup_eventlog(struct tevent_context *ev_ctx,
399                                struct messaging_context *msg_ctx)
400 {
401         const struct ndr_interface_table *t = &ndr_table_eventlog;
402         struct rpc_srv_callbacks eventlog_cb;
403         NTSTATUS status;
404         enum rpc_service_mode_e service_mode = rpc_service_mode(t->name);
405         if (service_mode != RPC_SERVICE_MODE_EMBEDDED) {
406                 return true;
407         }
408
409         eventlog_cb.init         = eventlog_init_cb;
410         eventlog_cb.shutdown     = NULL;
411         eventlog_cb.private_data = msg_ctx;
412
413         status = rpc_eventlog_init(&eventlog_cb);
414         if (!NT_STATUS_IS_OK(status)) {
415                 return false;
416         }
417
418         return rpc_setup_embedded(ev_ctx, msg_ctx, t, NULL);
419 }
420
421 static bool rpc_setup_initshutdown(struct tevent_context *ev_ctx,
422                                    struct messaging_context *msg_ctx)
423 {
424         const struct ndr_interface_table *t = &ndr_table_initshutdown;
425         NTSTATUS status;
426         enum rpc_service_mode_e service_mode = rpc_service_mode(t->name);
427         if (service_mode != RPC_SERVICE_MODE_EMBEDDED) {
428                 return true;
429         }
430
431         status = rpc_initshutdown_init(NULL);
432         if (!NT_STATUS_IS_OK(status)) {
433                 return false;
434         }
435
436         return rpc_setup_embedded(ev_ctx, msg_ctx, t, NULL);
437 }
438
439 bool dcesrv_ep_setup(struct tevent_context *ev_ctx,
440                      struct messaging_context *msg_ctx)
441 {
442         TALLOC_CTX *tmp_ctx;
443         bool ok;
444
445         tmp_ctx = talloc_stackframe();
446         if (tmp_ctx == NULL) {
447                 return false;
448         }
449
450         ok = rpc_setup_winreg(ev_ctx, msg_ctx);
451         if (!ok) {
452                 goto done;
453         }
454
455         ok = rpc_setup_srvsvc(ev_ctx, msg_ctx);
456         if (!ok) {
457                 goto done;
458         }
459
460         ok = rpc_setup_lsarpc(ev_ctx, msg_ctx);
461         if (!ok) {
462                 goto done;
463         }
464
465         ok = rpc_setup_samr(ev_ctx, msg_ctx);
466         if (!ok) {
467                 goto done;
468         }
469
470         ok = rpc_setup_netlogon(ev_ctx, msg_ctx);
471         if (!ok) {
472                 goto done;
473         }
474
475         ok = rpc_setup_netdfs(ev_ctx, msg_ctx);
476         if (!ok) {
477                 goto done;
478         }
479
480 #ifdef DEVELOPER
481         ok = rpc_setup_rpcecho(ev_ctx, msg_ctx);
482         if (!ok) {
483                 goto done;
484         }
485 #endif
486
487         ok = rpc_setup_dssetup(ev_ctx, msg_ctx);
488         if (!ok) {
489                 goto done;
490         }
491
492         ok = rpc_setup_wkssvc(ev_ctx, msg_ctx);
493         if (!ok) {
494                 goto done;
495         }
496
497         ok = rpc_setup_spoolss(ev_ctx, msg_ctx);
498         if (!ok) {
499                 goto done;
500         }
501
502         ok = rpc_setup_svcctl(ev_ctx, msg_ctx);
503         if (!ok) {
504                 goto done;
505         }
506
507         ok = rpc_setup_ntsvcs(ev_ctx, msg_ctx);
508         if (!ok) {
509                 goto done;
510         }
511
512         ok = rpc_setup_eventlog(ev_ctx, msg_ctx);
513         if (!ok) {
514                 goto done;
515         }
516
517         ok = rpc_setup_initshutdown(ev_ctx, msg_ctx);
518         if (!ok) {
519                 goto done;
520         }
521
522 done:
523         talloc_free(tmp_ctx);
524         return ok;
525 }
526
527 /* vim: set ts=8 sw=8 noet cindent ft=c.doxygen: */