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