1c6bde6082e932b67bf4b9cbbcdf75d9e925a93f
[idra/samba.git] / source3 / rpc_server / lsasd.c
1 /*
2  *  Unix SMB/CIFS implementation.
3  *
4  *  LSA service daemon
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 "serverid.h"
24 #include "messages.h"
25 #include "ntdomain.h"
26
27 #include "../lib/tsocket/tsocket.h"
28 #include "lib/server_prefork.h"
29 #include "lib/server_prefork_util.h"
30 #include "librpc/rpc/dcerpc_ep.h"
31
32 #include "rpc_server/rpc_server.h"
33 #include "rpc_server/rpc_ep_register.h"
34 #include "rpc_server/rpc_sock_helper.h"
35
36 #include "librpc/gen_ndr/srv_lsa.h"
37 #include "librpc/gen_ndr/srv_samr.h"
38 #include "librpc/gen_ndr/srv_netlogon.h"
39
40 #define DAEMON_NAME "lsasd"
41 #define LSASD_MAX_SOCKETS 64
42
43 static struct server_id parent_id;
44 static struct prefork_pool *lsasd_pool = NULL;
45 static int lsasd_child_id = 0;
46
47 static struct pf_daemon_config default_pf_lsasd_cfg = {
48         .prefork_status = PFH_INIT,
49         .min_children = 5,
50         .max_children = 25,
51         .spawn_rate = 5,
52         .max_allowed_clients = 100,
53         .child_min_life = 60 /* 1 minute minimum life time */
54 };
55 static struct pf_daemon_config pf_lsasd_cfg = { 0 };
56
57 void start_lsasd(struct tevent_context *ev_ctx,
58                  struct messaging_context *msg_ctx);
59
60 static void lsasd_reopen_logs(int child_id)
61 {
62         char *lfile = lp_logfile();
63         char *extension;
64         int rc;
65
66         if (child_id) {
67                 rc = asprintf(&extension, "%s.%d", DAEMON_NAME, child_id);
68         } else {
69                 rc = asprintf(&extension, "%s", DAEMON_NAME);
70         }
71         if (rc == -1) {
72                 return;
73         }
74
75         rc = 0;
76         if (lfile == NULL || lfile[0] == '\0') {
77                 rc = asprintf(&lfile, "%s/log.%s",
78                               get_dyn_LOGFILEBASE(), extension);
79         } else {
80                 if (strstr(lfile, extension) == NULL) {
81                         if (child_id) {
82                                 rc = asprintf(&lfile, "%s.%d",
83                                                 lp_logfile(),
84                                                 child_id);
85                         } else {
86                                 rc = asprintf(&lfile, "%s.%s",
87                                                 lp_logfile(),
88                                                 extension);
89                         }
90                 }
91         }
92
93         if (rc > 0) {
94                 lp_set_logfile(lfile);
95                 SAFE_FREE(lfile);
96         }
97
98         SAFE_FREE(extension);
99
100         reopen_logs();
101 }
102
103 static void lsasd_smb_conf_updated(struct messaging_context *msg,
104                                   void *private_data,
105                                   uint32_t msg_type,
106                                   struct server_id server_id,
107                                   DATA_BLOB *data)
108 {
109         struct tevent_context *ev_ctx;
110
111         DEBUG(10, ("Got message saying smb.conf was updated. Reloading.\n"));
112         ev_ctx = talloc_get_type_abort(private_data, struct tevent_context);
113
114         change_to_root_user();
115         lp_load(get_dyn_CONFIGFILE(), true, false, false, true);
116
117         lsasd_reopen_logs(lsasd_child_id);
118         if (lsasd_child_id == 0) {
119                 pfh_daemon_config(DAEMON_NAME,
120                                   &pf_lsasd_cfg,
121                                   &default_pf_lsasd_cfg);
122                 pfh_manage_pool(ev_ctx, msg, &pf_lsasd_cfg, lsasd_pool);
123         }
124 }
125
126 static void lsasd_sig_term_handler(struct tevent_context *ev,
127                                   struct tevent_signal *se,
128                                   int signum,
129                                   int count,
130                                   void *siginfo,
131                                   void *private_data)
132 {
133         rpc_netlogon_shutdown();
134         rpc_samr_shutdown();
135         rpc_lsarpc_shutdown();
136
137         DEBUG(0, ("termination signal\n"));
138         exit(0);
139 }
140
141 static void lsasd_setup_sig_term_handler(struct tevent_context *ev_ctx)
142 {
143         struct tevent_signal *se;
144
145         se = tevent_add_signal(ev_ctx,
146                                ev_ctx,
147                                SIGTERM, 0,
148                                lsasd_sig_term_handler,
149                                NULL);
150         if (!se) {
151                 DEBUG(0, ("failed to setup SIGTERM handler\n"));
152                 exit(1);
153         }
154 }
155
156 static void lsasd_sig_hup_handler(struct tevent_context *ev,
157                                     struct tevent_signal *se,
158                                     int signum,
159                                     int count,
160                                     void *siginfo,
161                                     void *pvt)
162 {
163
164         change_to_root_user();
165         lp_load(get_dyn_CONFIGFILE(), true, false, false, true);
166
167         lsasd_reopen_logs(lsasd_child_id);
168         pfh_daemon_config(DAEMON_NAME,
169                           &pf_lsasd_cfg,
170                           &default_pf_lsasd_cfg);
171
172         /* relay to all children */
173         prefork_send_signal_to_all(lsasd_pool, SIGHUP);
174 }
175
176 static void lsasd_setup_sig_hup_handler(struct tevent_context *ev_ctx)
177 {
178         struct tevent_signal *se;
179
180         se = tevent_add_signal(ev_ctx,
181                                ev_ctx,
182                                SIGHUP, 0,
183                                lsasd_sig_hup_handler,
184                                NULL);
185         if (!se) {
186                 DEBUG(0, ("failed to setup SIGHUP handler\n"));
187                 exit(1);
188         }
189 }
190
191 /**********************************************************
192  * Children
193  **********************************************************/
194
195 static void lsasd_chld_sig_hup_handler(struct tevent_context *ev,
196                                          struct tevent_signal *se,
197                                          int signum,
198                                          int count,
199                                          void *siginfo,
200                                          void *pvt)
201 {
202         change_to_root_user();
203         lsasd_reopen_logs(lsasd_child_id);
204 }
205
206 static bool lsasd_setup_chld_hup_handler(struct tevent_context *ev_ctx)
207 {
208         struct tevent_signal *se;
209
210         se = tevent_add_signal(ev_ctx,
211                                ev_ctx,
212                                SIGHUP, 0,
213                                lsasd_chld_sig_hup_handler,
214                                NULL);
215         if (!se) {
216                 DEBUG(1, ("failed to setup SIGHUP handler"));
217                 return false;
218         }
219
220         return true;
221 }
222
223 static void parent_ping(struct messaging_context *msg_ctx,
224                         void *private_data,
225                         uint32_t msg_type,
226                         struct server_id server_id,
227                         DATA_BLOB *data)
228 {
229
230         /* The fact we received this message is enough to let make the event
231          * loop if it was idle. lsasd_children_main will cycle through
232          * lsasd_next_client at least once. That function will take whatever
233          * action is necessary */
234
235         DEBUG(10, ("Got message that the parent changed status.\n"));
236         return;
237 }
238
239 static bool lsasd_child_init(struct tevent_context *ev_ctx,
240                              int child_id,
241                              struct pf_worker_data *pf)
242 {
243         NTSTATUS status;
244         struct messaging_context *msg_ctx = server_messaging_context();
245         bool ok;
246
247         status = reinit_after_fork(msg_ctx, ev_ctx,
248                                    procid_self(), true);
249         if (!NT_STATUS_IS_OK(status)) {
250                 DEBUG(0,("reinit_after_fork() failed\n"));
251                 smb_panic("reinit_after_fork() failed");
252         }
253
254         lsasd_child_id = child_id;
255         lsasd_reopen_logs(child_id);
256
257         ok = lsasd_setup_chld_hup_handler(ev_ctx);
258         if (!ok) {
259                 return false;
260         }
261
262         if (!serverid_register(procid_self(), FLAG_MSG_GENERAL)) {
263                 return false;
264         }
265
266         messaging_register(msg_ctx, ev_ctx,
267                            MSG_SMB_CONF_UPDATED, lsasd_smb_conf_updated);
268         messaging_register(msg_ctx, ev_ctx,
269                            MSG_PREFORK_PARENT_EVENT, parent_ping);
270
271         status = rpc_lsarpc_init(NULL);
272         if (!NT_STATUS_IS_OK(status)) {
273                 DEBUG(0, ("Failed to register lsarpc rpc inteface! (%s)\n",
274                           nt_errstr(status)));
275                 return false;
276         }
277
278         status = rpc_samr_init(NULL);
279         if (!NT_STATUS_IS_OK(status)) {
280                 DEBUG(0, ("Failed to register samr rpc inteface! (%s)\n",
281                           nt_errstr(status)));
282                 return false;
283         }
284
285         status = rpc_netlogon_init(NULL);
286         if (!NT_STATUS_IS_OK(status)) {
287                 DEBUG(0, ("Failed to register netlogon rpc inteface! (%s)\n",
288                           nt_errstr(status)));
289                 return false;
290         }
291
292         return true;
293 }
294
295 struct lsasd_children_data {
296         struct tevent_context *ev_ctx;
297         struct messaging_context *msg_ctx;
298         struct pf_worker_data *pf;
299         int listen_fd_size;
300         int *listen_fds;
301 };
302
303 static void lsasd_next_client(void *pvt);
304
305 static int lsasd_children_main(struct tevent_context *ev_ctx,
306                                struct messaging_context *msg_ctx,
307                                struct pf_worker_data *pf,
308                                int child_id,
309                                int listen_fd_size,
310                                int *listen_fds,
311                                void *private_data)
312 {
313         struct lsasd_children_data *data;
314         bool ok;
315         int ret;
316
317         ok = lsasd_child_init(ev_ctx, child_id, pf);
318         if (!ok) {
319                 return 1;
320         }
321
322         data = talloc(ev_ctx, struct lsasd_children_data);
323         if (!data) {
324                 return 1;
325         }
326         data->pf = pf;
327         data->ev_ctx = ev_ctx;
328         data->msg_ctx = msg_ctx;
329         data->listen_fd_size = listen_fd_size;
330         data->listen_fds = listen_fds;
331
332         /* loop until it is time to exit */
333         while (pf->status != PF_WORKER_EXITING) {
334                 /* try to see if it is time to schedule the next client */
335                 lsasd_next_client(data);
336
337                 ret = tevent_loop_once(ev_ctx);
338                 if (ret != 0) {
339                         DEBUG(0, ("tevent_loop_once() exited with %d: %s\n",
340                                   ret, strerror(errno)));
341                         pf->status = PF_WORKER_EXITING;
342                 }
343         }
344
345         return ret;
346 }
347
348 static void lsasd_client_terminated(void *pvt)
349 {
350         struct lsasd_children_data *data;
351
352         data = talloc_get_type_abort(pvt, struct lsasd_children_data);
353
354         pfh_client_terminated(data->pf);
355
356         lsasd_next_client(pvt);
357 }
358
359 struct lsasd_new_client {
360         struct lsasd_children_data *data;
361 };
362
363 static void lsasd_handle_client(struct tevent_req *req);
364
365 static void lsasd_next_client(void *pvt)
366 {
367         struct tevent_req *req;
368         struct lsasd_children_data *data;
369         struct lsasd_new_client *next;
370
371         data = talloc_get_type_abort(pvt, struct lsasd_children_data);
372
373         if (!pfh_child_allowed_to_accept(data->pf)) {
374                 /* nothing to do for now we are already listening
375                  * or we are not allowed to listen further */
376                 return;
377         }
378
379         next = talloc_zero(data, struct lsasd_new_client);
380         if (!next) {
381                 DEBUG(1, ("Out of memory!?\n"));
382                 return;
383         }
384         next->data = data;
385
386         req = prefork_listen_send(next,
387                                   data->ev_ctx,
388                                   data->pf,
389                                   data->listen_fd_size,
390                                   data->listen_fds);
391         if (!req) {
392                 DEBUG(1, ("Failed to make listening request!?\n"));
393                 talloc_free(next);
394                 return;
395         }
396         tevent_req_set_callback(req, lsasd_handle_client, next);
397 }
398
399 static void lsasd_handle_client(struct tevent_req *req)
400 {
401         struct lsasd_children_data *data;
402         struct lsasd_new_client *client;
403         const DATA_BLOB ping = data_blob_null;
404         int rc;
405         int sd;
406         TALLOC_CTX *tmp_ctx;
407         struct tsocket_address *srv_addr;
408         struct tsocket_address *cli_addr;
409
410         client = tevent_req_callback_data(req, struct lsasd_new_client);
411         data = client->data;
412
413         tmp_ctx = talloc_stackframe();
414         if (tmp_ctx == NULL) {
415                 DEBUG(1, ("Failed to allocate stackframe!\n"));
416                 return;
417         }
418
419         rc = prefork_listen_recv(req,
420                                  tmp_ctx,
421                                  &sd,
422                                  &srv_addr,
423                                  &cli_addr);
424
425         /* this will free the request too */
426         talloc_free(client);
427
428         if (rc != 0) {
429                 DEBUG(6, ("No client connection was available after all!\n"));
430                 goto done;
431         }
432
433         /* Warn parent that our status changed */
434         messaging_send(data->msg_ctx, parent_id,
435                         MSG_PREFORK_CHILD_EVENT, &ping);
436
437         DEBUG(2, ("LSASD preforked child %d got client connection!\n",
438                   (int)(data->pf->pid)));
439
440         if (tsocket_address_is_inet(srv_addr, "ip")) {
441                 DEBUG(3, ("Got a tcpip client connection from %s on inteface %s\n",
442                            tsocket_address_string(cli_addr, tmp_ctx),
443                            tsocket_address_string(srv_addr, tmp_ctx)));
444
445                 dcerpc_ncacn_accept(data->ev_ctx,
446                                     data->msg_ctx,
447                                     NCACN_IP_TCP,
448                                     "IP",
449                                     cli_addr,
450                                     srv_addr,
451                                     sd,
452                                     NULL);
453         } else if (tsocket_address_is_unix(srv_addr)) {
454                 char *p;
455
456                 p = tsocket_address_unix_path(srv_addr, tmp_ctx);
457                 if (p == NULL) {
458                         talloc_free(tmp_ctx);
459                         return;
460                 }
461
462                 if (strstr(p, "/np/")) {
463                         p = basename(p);
464
465                         named_pipe_accept_function(data->ev_ctx,
466                                                    data->msg_ctx,
467                                                    p,
468                                                    sd,
469                                                    lsasd_client_terminated,
470                                                    data);
471                 } else {
472                         p = basename(p);
473
474                         dcerpc_ncacn_accept(data->ev_ctx,
475                                             data->msg_ctx,
476                                             NCALRPC,
477                                             p,
478                                             cli_addr,
479                                             srv_addr,
480                                             sd,
481                                             NULL);
482                 }
483         } else {
484                 DEBUG(0, ("ERROR: Unsupported socket!\n"));
485         }
486
487 done:
488         talloc_free(tmp_ctx);
489 }
490
491 /*
492  * MAIN
493  */
494
495 static void child_ping(struct messaging_context *msg_ctx,
496                         void *private_data,
497                         uint32_t msg_type,
498                         struct server_id server_id,
499                         DATA_BLOB *data)
500 {
501         struct tevent_context *ev_ctx;
502
503         ev_ctx = talloc_get_type_abort(private_data, struct tevent_context);
504
505         DEBUG(10, ("Got message that a child changed status.\n"));
506         pfh_manage_pool(ev_ctx, msg_ctx, &pf_lsasd_cfg, lsasd_pool);
507 }
508
509 static bool lsasd_schedule_check(struct tevent_context *ev_ctx,
510                                  struct messaging_context *msg_ctx,
511                                  struct timeval current_time);
512
513 static void lsasd_check_children(struct tevent_context *ev_ctx,
514                                     struct tevent_timer *te,
515                                     struct timeval current_time,
516                                     void *pvt);
517
518 static void lsasd_sigchld_handler(struct tevent_context *ev_ctx,
519                                   struct prefork_pool *pfp,
520                                   void *pvt)
521 {
522         struct messaging_context *msg_ctx;
523
524         msg_ctx = talloc_get_type_abort(pvt, struct messaging_context);
525
526         /* run pool management so we can fork/retire or increase
527          * the allowed connections per child based on load */
528         pfh_manage_pool(ev_ctx, msg_ctx, &pf_lsasd_cfg, lsasd_pool);
529 }
530
531 static bool lsasd_setup_children_monitor(struct tevent_context *ev_ctx,
532                                          struct messaging_context *msg_ctx)
533 {
534         bool ok;
535
536         /* add our oun sigchld callback */
537         prefork_set_sigchld_callback(lsasd_pool, lsasd_sigchld_handler, msg_ctx);
538
539         ok = lsasd_schedule_check(ev_ctx, msg_ctx, tevent_timeval_current());
540
541         return ok;
542 }
543
544 static bool lsasd_schedule_check(struct tevent_context *ev_ctx,
545                                  struct messaging_context *msg_ctx,
546                                  struct timeval current_time)
547 {
548         struct tevent_timer *te;
549         struct timeval next_event;
550
551         /* check situation again in 10 seconds */
552         next_event = tevent_timeval_current_ofs(10, 0);
553
554         /* TODO: check when the socket becomes readable, so that children
555          * are checked only when there is some activity ? */
556         te = tevent_add_timer(ev_ctx, lsasd_pool, next_event,
557                               lsasd_check_children, msg_ctx);
558         if (!te) {
559                 DEBUG(2, ("Failed to set up children monitoring!\n"));
560                 return false;
561         }
562
563         return true;
564 }
565
566 static void lsasd_check_children(struct tevent_context *ev_ctx,
567                                  struct tevent_timer *te,
568                                  struct timeval current_time,
569                                  void *pvt)
570 {
571         struct messaging_context *msg_ctx;
572
573         msg_ctx = talloc_get_type_abort(pvt, struct messaging_context);
574
575         pfh_manage_pool(ev_ctx, msg_ctx, &pf_lsasd_cfg, lsasd_pool);
576
577         lsasd_schedule_check(ev_ctx, msg_ctx, current_time);
578 }
579
580 /*
581  * start it up
582  */
583
584 static bool lsasd_create_sockets(struct tevent_context *ev_ctx,
585                                  struct messaging_context *msg_ctx,
586                                  int *listen_fd,
587                                  int *listen_fd_size)
588 {
589         struct dcerpc_binding_vector *v, *v_orig;
590         TALLOC_CTX *tmp_ctx;
591         NTSTATUS status;
592         uint32_t i;
593         int fd;
594         int rc;
595         bool ok = true;
596
597         tmp_ctx = talloc_stackframe();
598         if (tmp_ctx == NULL) {
599                 return false;
600         }
601
602         status = dcerpc_binding_vector_new(tmp_ctx, &v_orig);
603         if (!NT_STATUS_IS_OK(status)) {
604                 ok = false;
605                 goto done;
606         }
607
608         /* Create only one tcpip listener for all services */
609         status = rpc_create_tcpip_sockets(&ndr_table_lsarpc,
610                                           v_orig,
611                                           0,
612                                           listen_fd,
613                                           listen_fd_size);
614         if (!NT_STATUS_IS_OK(status)) {
615                 ok = false;
616                 goto done;
617         }
618
619         /* Start to listen on tcpip sockets */
620         for (i = 0; i < *listen_fd_size; i++) {
621                 rc = listen(listen_fd[i], pf_lsasd_cfg.max_allowed_clients);
622                 if (rc == -1) {
623                         DEBUG(0, ("Failed to listen on tcpip socket - %s\n",
624                                   strerror(errno)));
625                         ok = false;
626                         goto done;
627                 }
628         }
629
630         /* LSARPC */
631         fd = create_named_pipe_socket("lsarpc");
632         if (fd < 0) {
633                 ok = false;
634                 goto done;
635         }
636         listen_fd[*listen_fd_size] = fd;
637         (*listen_fd_size)++;
638
639         rc = listen(fd, pf_lsasd_cfg.max_allowed_clients);
640         if (rc == -1) {
641                 DEBUG(0, ("Failed to listen on lsarpc pipe - %s\n",
642                           strerror(errno)));
643                 ok = false;
644                 goto done;
645         }
646
647         fd = create_named_pipe_socket("lsass");
648         if (fd < 0) {
649                 ok = false;
650                 goto done;
651         }
652         listen_fd[*listen_fd_size] = fd;
653         (*listen_fd_size)++;
654
655         rc = listen(fd, pf_lsasd_cfg.max_allowed_clients);
656         if (rc == -1) {
657                 DEBUG(0, ("Failed to listen on lsass pipe - %s\n",
658                           strerror(errno)));
659                 ok = false;
660                 goto done;
661         }
662
663         fd = create_dcerpc_ncalrpc_socket("lsarpc");
664         if (fd < 0) {
665                 ok = false;
666                 goto done;
667         }
668         listen_fd[*listen_fd_size] = fd;
669         (*listen_fd_size)++;
670
671         rc = listen(fd, pf_lsasd_cfg.max_allowed_clients);
672         if (rc == -1) {
673                 DEBUG(0, ("Failed to listen on lsarpc ncalrpc - %s\n",
674                           strerror(errno)));
675                 ok = false;
676                 goto done;
677         }
678
679         v = dcerpc_binding_vector_dup(tmp_ctx, v_orig);
680         if (v == NULL) {
681                 ok = false;
682                 goto done;
683         }
684
685         status = dcerpc_binding_vector_replace_iface(&ndr_table_lsarpc, v);
686         if (!NT_STATUS_IS_OK(status)) {
687                 return false;
688         }
689
690         status = dcerpc_binding_vector_add_np_default(&ndr_table_lsarpc, v);
691         if (!NT_STATUS_IS_OK(status)) {
692                 ok = false;
693                 goto done;
694         }
695
696         status = dcerpc_binding_vector_add_unix(&ndr_table_lsarpc, v, "lsarpc");
697         if (!NT_STATUS_IS_OK(status)) {
698                 ok = false;
699                 goto done;
700         }
701
702         status = rpc_ep_register(ev_ctx, msg_ctx, &ndr_table_lsarpc, v);
703         if (!NT_STATUS_IS_OK(status)) {
704                 ok = false;
705                 goto done;
706         }
707
708         /* SAMR */
709         fd = create_named_pipe_socket("samr");
710         if (fd < 0) {
711                 ok = false;
712                 goto done;
713         }
714
715         rc = listen(fd, pf_lsasd_cfg.max_allowed_clients);
716         if (rc == -1) {
717                 DEBUG(0, ("Failed to listen on samr pipe - %s\n",
718                           strerror(errno)));
719                 ok = false;
720                 goto done;
721         }
722         listen_fd[*listen_fd_size] = fd;
723         (*listen_fd_size)++;
724
725         fd = create_dcerpc_ncalrpc_socket("samr");
726         if (fd < 0) {
727                 ok = false;
728                 goto done;
729         }
730         listen_fd[*listen_fd_size] = fd;
731         (*listen_fd_size)++;
732
733         rc = listen(fd, pf_lsasd_cfg.max_allowed_clients);
734         if (rc == -1) {
735                 DEBUG(0, ("Failed to listen on samr ncalrpc - %s\n",
736                           strerror(errno)));
737                 ok = false;
738                 goto done;
739         }
740
741         v = dcerpc_binding_vector_dup(tmp_ctx, v_orig);
742         if (v == NULL) {
743                 ok = false;
744                 goto done;
745         }
746
747         status = dcerpc_binding_vector_replace_iface(&ndr_table_samr, v);
748         if (!NT_STATUS_IS_OK(status)) {
749                 return false;
750         }
751
752         status = dcerpc_binding_vector_add_np_default(&ndr_table_samr, v);
753         if (!NT_STATUS_IS_OK(status)) {
754                 ok = false;
755                 goto done;
756         }
757
758         status = dcerpc_binding_vector_add_unix(&ndr_table_lsarpc, v, "samr");
759         if (!NT_STATUS_IS_OK(status)) {
760                 ok = false;
761                 goto done;
762         }
763
764         status = rpc_ep_register(ev_ctx, msg_ctx, &ndr_table_samr, v);
765         if (!NT_STATUS_IS_OK(status)) {
766                 ok = false;
767                 goto done;
768         }
769
770         /* NETLOGON */
771         fd = create_named_pipe_socket("netlogon");
772         if (fd < 0) {
773                 ok = false;
774                 goto done;
775         }
776
777         rc = listen(fd, pf_lsasd_cfg.max_allowed_clients);
778         if (rc == -1) {
779                 DEBUG(0, ("Failed to listen on samr pipe - %s\n",
780                           strerror(errno)));
781                 ok = false;
782                 goto done;
783         }
784         listen_fd[*listen_fd_size] = fd;
785         (*listen_fd_size)++;
786
787         fd = create_dcerpc_ncalrpc_socket("netlogon");
788         if (fd < 0) {
789                 ok = false;
790                 goto done;
791         }
792         listen_fd[*listen_fd_size] = fd;
793         (*listen_fd_size)++;
794
795         rc = listen(fd, pf_lsasd_cfg.max_allowed_clients);
796         if (rc == -1) {
797                 DEBUG(0, ("Failed to listen on netlogon ncalrpc - %s\n",
798                           strerror(errno)));
799                 ok = false;
800                 goto done;
801         }
802
803         v = dcerpc_binding_vector_dup(tmp_ctx, v_orig);
804         if (v == NULL) {
805                 ok = false;
806                 goto done;
807         }
808
809         status = dcerpc_binding_vector_replace_iface(&ndr_table_netlogon, v);
810         if (!NT_STATUS_IS_OK(status)) {
811                 return false;
812         }
813
814         status = dcerpc_binding_vector_add_np_default(&ndr_table_netlogon, v);
815         if (!NT_STATUS_IS_OK(status)) {
816                 ok = false;
817                 goto done;
818         }
819
820         status = dcerpc_binding_vector_add_unix(&ndr_table_lsarpc, v, "netlogon");
821         if (!NT_STATUS_IS_OK(status)) {
822                 ok = false;
823                 goto done;
824         }
825
826         status = rpc_ep_register(ev_ctx, msg_ctx, &ndr_table_netlogon, v);
827         if (!NT_STATUS_IS_OK(status)) {
828                 ok = false;
829                 goto done;
830         }
831
832 done:
833         talloc_free(tmp_ctx);
834         return ok;
835 }
836
837 void start_lsasd(struct tevent_context *ev_ctx,
838                  struct messaging_context *msg_ctx)
839 {
840         NTSTATUS status;
841         int listen_fd[LSASD_MAX_SOCKETS];
842         int listen_fd_size = 0;
843         pid_t pid;
844         int rc;
845         bool ok;
846
847         DEBUG(1, ("Forking LSA Service Daemon\n"));
848
849         /*
850          * Block signals before forking child as it will have to
851          * set its own handlers. Child will re-enable SIGHUP as
852          * soon as the handlers are set up.
853          */
854         BlockSignals(true, SIGTERM);
855         BlockSignals(true, SIGHUP);
856
857         pid = sys_fork();
858         if (pid == -1) {
859                 DEBUG(0, ("Failed to fork LSASD [%s], aborting ...\n",
860                            strerror(errno)));
861                 exit(1);
862         }
863
864         /* parent or error */
865         if (pid != 0) {
866
867                 /* Re-enable SIGHUP before returnig */
868                 BlockSignals(false, SIGTERM);
869                 BlockSignals(false, SIGHUP);
870
871                 return;
872         }
873
874         /* child */
875         close_low_fds(false);
876
877         /* save the parent process id so the children can use it later */
878         parent_id = procid_self();
879
880         status = reinit_after_fork(msg_ctx,
881                                    ev_ctx,
882                                    procid_self(), true);
883         if (!NT_STATUS_IS_OK(status)) {
884                 DEBUG(0,("reinit_after_fork() failed\n"));
885                 smb_panic("reinit_after_fork() failed");
886         }
887
888         lsasd_reopen_logs(0);
889         pfh_daemon_config(DAEMON_NAME,
890                           &pf_lsasd_cfg,
891                           &default_pf_lsasd_cfg);
892
893         lsasd_setup_sig_term_handler(ev_ctx);
894         lsasd_setup_sig_hup_handler(ev_ctx);
895
896         BlockSignals(false, SIGTERM);
897         BlockSignals(false, SIGHUP);
898
899         ok = lsasd_create_sockets(ev_ctx, msg_ctx, listen_fd, &listen_fd_size);
900         if (!ok) {
901                 exit(1);
902         }
903
904         /* start children before any more initialization is done */
905         ok = prefork_create_pool(ev_ctx, /* mem_ctx */
906                                  ev_ctx,
907                                  msg_ctx,
908                                  listen_fd_size,
909                                  listen_fd,
910                                  pf_lsasd_cfg.min_children,
911                                  pf_lsasd_cfg.max_children,
912                                  &lsasd_children_main,
913                                  NULL,
914                                  &lsasd_pool);
915         if (!ok) {
916                 exit(1);
917         }
918
919         if (!serverid_register(procid_self(), FLAG_MSG_GENERAL)) {
920                 exit(1);
921         }
922
923         messaging_register(msg_ctx,
924                            ev_ctx,
925                            MSG_SMB_CONF_UPDATED,
926                            lsasd_smb_conf_updated);
927         messaging_register(msg_ctx, ev_ctx,
928                            MSG_PREFORK_CHILD_EVENT, child_ping);
929
930         status = rpc_lsarpc_init(NULL);
931         if (!NT_STATUS_IS_OK(status)) {
932                 DEBUG(0, ("Failed to register winreg rpc inteface! (%s)\n",
933                           nt_errstr(status)));
934                 exit(1);
935         }
936
937         status = rpc_samr_init(NULL);
938         if (!NT_STATUS_IS_OK(status)) {
939                 DEBUG(0, ("Failed to register lsasd rpc inteface! (%s)\n",
940                           nt_errstr(status)));
941                 exit(1);
942         }
943
944         status = rpc_netlogon_init(NULL);
945         if (!NT_STATUS_IS_OK(status)) {
946                 DEBUG(0, ("Failed to register lsasd rpc inteface! (%s)\n",
947                           nt_errstr(status)));
948                 exit(1);
949         }
950
951         ok = lsasd_setup_children_monitor(ev_ctx, msg_ctx);
952         if (!ok) {
953                 DEBUG(0, ("Failed to setup children monitoring!\n"));
954                 exit(1);
955         }
956
957         DEBUG(1, ("LSASD Daemon Started (%d)\n", getpid()));
958
959         /* loop forever */
960         rc = tevent_loop_wait(ev_ctx);
961
962         /* should not be reached */
963         DEBUG(0,("lsasd: tevent_loop_wait() exited with %d - %s\n",
964                  rc, (rc == 0) ? "out of events" : strerror(errno)));
965         exit(1);
966 }