ctdb-scripts: Update statd-callout to try several configuration files
[vlendec/samba-autobuild/.git] / ctdb / common / sock_daemon.c
1 /*
2    A server based on unix domain socket
3
4    Copyright (C) Amitay Isaacs  2016
5
6    This program is free software; you can redistribute it and/or modify
7    it under the terms of the GNU General Public License as published by
8    the Free Software Foundation; either version 3 of the License, or
9    (at your option) any later version.
10
11    This program is distributed in the hope that it will be useful,
12    but WITHOUT ANY WARRANTY; without even the implied warranty of
13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14    GNU General Public License for more details.
15
16    You should have received a copy of the GNU General Public License
17    along with this program; if not, see <http://www.gnu.org/licenses/>.
18 */
19
20 #include "replace.h"
21 #include "system/filesys.h"
22 #include "system/network.h"
23 #include "system/wait.h"
24
25 #include <talloc.h>
26 #include <tevent.h>
27
28 #include "lib/async_req/async_sock.h"
29 #include "lib/util/debug.h"
30 #include "lib/util/blocking.h"
31 #include "lib/util/dlinklist.h"
32 #include "lib/util/tevent_unix.h"
33 #include "lib/util/become_daemon.h"
34 #include "lib/util/sys_rw.h"
35
36 #include "common/logging.h"
37 #include "common/reqid.h"
38 #include "common/comm.h"
39 #include "common/pidfile.h"
40 #include "common/system.h"
41 #include "common/sock_daemon.h"
42
43 struct sock_socket {
44         struct sock_socket *prev, *next;
45
46         const char *sockpath;
47         struct sock_socket_funcs *funcs;
48         void *private_data;
49
50         int fd;
51         struct tevent_req *req;
52 };
53
54 struct sock_client {
55         struct sock_client *prev, *next;
56
57         struct tevent_req *req;
58         struct sock_client_context *client_ctx;
59 };
60
61 struct sock_client_context {
62         struct tevent_context *ev;
63         struct sock_socket *sock;
64         int fd;
65         struct comm_context *comm;
66
67         struct sock_client *client;
68 };
69
70 struct sock_daemon_context {
71         struct sock_daemon_funcs *funcs;
72         void *private_data;
73
74         struct pidfile_context *pid_ctx;
75         struct sock_socket *socket_list;
76         int startup_fd;
77 };
78
79 /*
80  * Process a single client
81  */
82
83 static void sock_client_read_handler(uint8_t *buf, size_t buflen,
84                                      void *private_data);
85 static void sock_client_read_done(struct tevent_req *subreq);
86 static void sock_client_dead_handler(void *private_data);
87 static int sock_client_context_destructor(
88                                 struct sock_client_context *client_ctx);
89
90 static int sock_client_context_init(TALLOC_CTX *mem_ctx,
91                                     struct tevent_context *ev,
92                                     struct sock_socket *sock,
93                                     int client_fd,
94                                     struct sock_client *client,
95                                     struct sock_client_context **result)
96 {
97         struct sock_client_context *client_ctx;
98         int ret;
99
100         client_ctx = talloc_zero(mem_ctx, struct sock_client_context);
101         if (client_ctx == NULL) {
102                 return ENOMEM;
103         }
104
105         client_ctx->ev = ev;
106         client_ctx->sock = sock;
107         client_ctx->fd = client_fd;
108         client_ctx->client = client;
109
110         ret = comm_setup(client_ctx, ev, client_fd,
111                          sock_client_read_handler, client_ctx,
112                          sock_client_dead_handler, client_ctx,
113                          &client_ctx->comm);
114         if (ret != 0) {
115                 talloc_free(client_ctx);
116                 return ret;
117         }
118
119         if (sock->funcs->connect != NULL) {
120                 pid_t pid;
121                 bool status;
122
123                 (void) ctdb_get_peer_pid(client_fd, &pid);
124
125                 status = sock->funcs->connect(client_ctx,
126                                               pid,
127                                               sock->private_data);
128                 if (! status) {
129                         talloc_free(client_ctx);
130                         close(client_fd);
131                         return 0;
132                 }
133         }
134
135         talloc_set_destructor(client_ctx, sock_client_context_destructor);
136
137         *result = client_ctx;
138         return 0;
139 }
140
141 static void sock_client_read_handler(uint8_t *buf, size_t buflen,
142                                      void *private_data)
143 {
144         struct sock_client_context *client_ctx = talloc_get_type_abort(
145                 private_data, struct sock_client_context);
146         struct sock_socket *sock = client_ctx->sock;
147         struct tevent_req *subreq;
148
149         subreq = sock->funcs->read_send(client_ctx, client_ctx->ev,
150                                         client_ctx, buf, buflen,
151                                         sock->private_data);
152         if (subreq == NULL) {
153                 talloc_free(client_ctx);
154                 return;
155         }
156         tevent_req_set_callback(subreq, sock_client_read_done, client_ctx);
157 }
158
159 static void sock_client_read_done(struct tevent_req *subreq)
160 {
161         struct sock_client_context *client_ctx = tevent_req_callback_data(
162                 subreq, struct sock_client_context);
163         struct sock_socket *sock = client_ctx->sock;
164         int ret;
165         bool status;
166
167         status = sock->funcs->read_recv(subreq, &ret);
168         if (! status) {
169                 D_ERR("client read failed with ret=%d\n", ret);
170                 talloc_free(client_ctx);
171         }
172 }
173
174 static void sock_client_dead_handler(void *private_data)
175 {
176         struct sock_client_context *client_ctx = talloc_get_type_abort(
177                 private_data, struct sock_client_context);
178         struct sock_socket *sock = client_ctx->sock;
179
180         if (sock->funcs->disconnect != NULL) {
181                 sock->funcs->disconnect(client_ctx, sock->private_data);
182         }
183
184         talloc_free(client_ctx);
185 }
186
187 static int sock_client_context_destructor(
188                                 struct sock_client_context *client_ctx)
189 {
190         TALLOC_FREE(client_ctx->client);
191         TALLOC_FREE(client_ctx->comm);
192         if (client_ctx->fd != -1) {
193                 close(client_ctx->fd);
194                 client_ctx->fd = -1;
195         }
196
197         return 0;
198 }
199
200 /*
201  * Process a single listening socket
202  */
203
204 static int socket_setup(const char *sockpath, bool remove_before_use)
205 {
206         struct sockaddr_un addr;
207         size_t len;
208         int ret, fd;
209
210         memset(&addr, 0, sizeof(addr));
211         addr.sun_family = AF_UNIX;
212
213         len = strlcpy(addr.sun_path, sockpath, sizeof(addr.sun_path));
214         if (len >= sizeof(addr.sun_path)) {
215                 D_ERR("socket path too long: %s\n", sockpath);
216                 return -1;
217         }
218
219         fd = socket(AF_UNIX, SOCK_STREAM, 0);
220         if (fd == -1) {
221                 D_ERR("socket create failed - %s\n", sockpath);
222                 return -1;
223         }
224
225         ret = set_blocking(fd, false);
226         if (ret != 0) {
227                 D_ERR("socket set nonblocking failed - %s\n", sockpath);
228                 close(fd);
229                 return -1;
230         }
231
232         if (remove_before_use) {
233                 unlink(sockpath);
234         }
235
236         ret = bind(fd, (struct sockaddr *)&addr, sizeof(addr));
237         if (ret != 0) {
238                 D_ERR("socket bind failed - %s\n", sockpath);
239                 close(fd);
240                 return -1;
241         }
242
243         ret = listen(fd, 10);
244         if (ret != 0) {
245                 D_ERR("socket listen failed - %s\n", sockpath);
246                 close(fd);
247                 return -1;
248         }
249
250         D_NOTICE("listening on %s\n", sockpath);
251
252         return fd;
253 }
254
255 static int sock_socket_destructor(struct sock_socket *sock);
256
257 static int sock_socket_init(TALLOC_CTX *mem_ctx, const char *sockpath,
258                             struct sock_socket_funcs *funcs,
259                             void *private_data,
260                             struct sock_socket **result)
261 {
262         struct sock_socket *sock;
263
264         if (funcs == NULL) {
265                 return EINVAL;
266         }
267         if (funcs->read_send == NULL || funcs->read_recv == NULL) {
268                 return EINVAL;
269         }
270
271         sock = talloc_zero(mem_ctx, struct sock_socket);
272         if (sock == NULL) {
273                 return ENOMEM;
274         }
275
276         sock->sockpath = talloc_strdup(sock, sockpath);
277         if (sock->sockpath == NULL) {
278                 talloc_free(sock);
279                 return ENOMEM;
280         }
281         sock->funcs = funcs;
282         sock->private_data = private_data;
283         sock->fd = -1;
284
285         talloc_set_destructor(sock, sock_socket_destructor);
286
287         *result = sock;
288         return 0;
289 }
290
291 static int sock_socket_destructor(struct sock_socket *sock)
292 {
293         TALLOC_FREE(sock->req);
294
295         if (sock->fd != -1) {
296                 close(sock->fd);
297                 sock->fd = -1;
298         }
299
300         unlink(sock->sockpath);
301         return 0;
302 }
303
304
305 struct sock_socket_start_state {
306         struct tevent_context *ev;
307         struct sock_socket *sock;
308
309         struct sock_client *client_list;
310 };
311
312 static int sock_socket_start_state_destructor(
313                                 struct sock_socket_start_state *state);
314 static void sock_socket_start_new_client(struct tevent_req *subreq);
315 static int sock_socket_start_client_destructor(struct sock_client *client);
316
317 static struct tevent_req *sock_socket_start_send(TALLOC_CTX *mem_ctx,
318                                                  struct tevent_context *ev,
319                                                  struct sock_socket *sock,
320                                                  bool remove_before_use)
321 {
322         struct tevent_req *req, *subreq;
323         struct sock_socket_start_state *state;
324
325         req = tevent_req_create(mem_ctx, &state,
326                                 struct sock_socket_start_state);
327         if (req == NULL) {
328                 return NULL;
329         }
330
331         state->ev = ev;
332         state->sock = sock;
333
334         sock->fd = socket_setup(sock->sockpath, remove_before_use);
335         if (sock->fd == -1) {
336                 tevent_req_error(req, EIO);
337                 return tevent_req_post(req, ev);
338         }
339
340         talloc_set_destructor(state, sock_socket_start_state_destructor);
341
342         subreq = accept_send(state, ev, sock->fd);
343         if (tevent_req_nomem(subreq, req)) {
344                 return tevent_req_post(req, ev);
345         }
346         tevent_req_set_callback(subreq, sock_socket_start_new_client, req);
347
348         sock->req = req;
349
350         return req;
351 }
352
353 static int sock_socket_start_state_destructor(
354                                 struct sock_socket_start_state *state)
355 {
356         struct sock_client *client;
357
358         while ((client = state->client_list) != NULL) {
359                 talloc_free(client);
360         }
361
362         return 0;
363 }
364
365 static void sock_socket_start_new_client(struct tevent_req *subreq)
366 {
367         struct tevent_req *req = tevent_req_callback_data(
368                 subreq, struct tevent_req);
369         struct sock_socket_start_state *state = tevent_req_data(
370                 req, struct sock_socket_start_state);
371         struct sock_client *client;
372         int client_fd, ret;
373
374         client_fd = accept_recv(subreq, NULL, NULL, &ret);
375         TALLOC_FREE(subreq);
376         if (client_fd == -1) {
377                 D_ERR("failed to accept new connection\n");
378         }
379
380         subreq = accept_send(state, state->ev, state->sock->fd);
381         if (tevent_req_nomem(subreq, req)) {
382                 return;
383         }
384         tevent_req_set_callback(subreq, sock_socket_start_new_client, req);
385
386         if (client_fd == -1) {
387                 return;
388         }
389
390         client = talloc_zero(state, struct sock_client);
391         if (tevent_req_nomem(client, req)) {
392                 close(client_fd);
393                 return;
394         }
395
396         client->req = req;
397
398         ret = sock_client_context_init(client, state->ev, state->sock,
399                                        client_fd, client, &client->client_ctx);
400         if (ret != 0) {
401                 talloc_free(client);
402                 return;
403         }
404
405         talloc_set_destructor(client, sock_socket_start_client_destructor);
406         DLIST_ADD(state->client_list, client);
407 }
408
409 static int sock_socket_start_client_destructor(struct sock_client *client)
410 {
411         struct sock_socket_start_state *state = tevent_req_data(
412                 client->req, struct sock_socket_start_state);
413
414         DLIST_REMOVE(state->client_list, client);
415         TALLOC_FREE(client->client_ctx);
416
417         return 0;
418 }
419
420 static bool sock_socket_start_recv(struct tevent_req *req, int *perr,
421                                    TALLOC_CTX *mem_ctx, const char **sockpath)
422 {
423         struct sock_socket_start_state *state = tevent_req_data(
424                 req, struct sock_socket_start_state);
425         int ret;
426
427         state->sock->req = NULL;
428
429         if (tevent_req_is_unix_error(req, &ret)) {
430                 if (perr != NULL) {
431                         *perr = ret;
432                 }
433                 return false;
434         }
435
436         if (sockpath != NULL) {
437                 *sockpath = talloc_steal(mem_ctx, state->sock->sockpath);
438         }
439
440         return true;
441 }
442
443 /*
444  * Send message to a client
445  */
446
447 struct tevent_req *sock_socket_write_send(TALLOC_CTX *mem_ctx,
448                                          struct tevent_context *ev,
449                                          struct sock_client_context *client_ctx,
450                                          uint8_t *buf, size_t buflen)
451 {
452         struct tevent_req *req;
453
454         req = comm_write_send(mem_ctx, ev, client_ctx->comm, buf, buflen);
455
456         return req;
457 }
458
459 bool sock_socket_write_recv(struct tevent_req *req, int *perr)
460 {
461         int ret;
462         bool status;
463
464         status = comm_write_recv(req, &ret);
465         if (! status) {
466                 if (perr != NULL) {
467                         *perr = ret;
468                 }
469         }
470
471         return status;
472 }
473
474 /*
475  * Socket daemon
476  */
477
478 int sock_daemon_setup(TALLOC_CTX *mem_ctx, const char *daemon_name,
479                       const char *logging, const char *debug_level,
480                       struct sock_daemon_funcs *funcs,
481                       void *private_data,
482                       struct sock_daemon_context **out)
483 {
484         struct sock_daemon_context *sockd;
485         int ret;
486
487         sockd = talloc_zero(mem_ctx, struct sock_daemon_context);
488         if (sockd == NULL) {
489                 return ENOMEM;
490         }
491
492         sockd->funcs = funcs;
493         sockd->private_data = private_data;
494         sockd->startup_fd = -1;
495
496         ret = logging_init(sockd, logging, debug_level, daemon_name);
497         if (ret != 0) {
498                 fprintf(stderr,
499                         "Failed to initialize logging, logging=%s, debug=%s\n",
500                         logging, debug_level);
501                 return ret;
502         }
503
504         *out = sockd;
505         return 0;
506 }
507
508 int sock_daemon_add_unix(struct sock_daemon_context *sockd,
509                          const char *sockpath,
510                          struct sock_socket_funcs *funcs,
511                          void *private_data)
512 {
513         struct sock_socket *sock;
514         int ret;
515
516         ret = sock_socket_init(sockd, sockpath, funcs, private_data, &sock);
517         if (ret != 0) {
518                 return ret;
519         }
520
521
522         DLIST_ADD(sockd->socket_list, sock);
523         return 0;
524 }
525
526 bool sock_daemon_set_startup_fd(struct sock_daemon_context *sockd, int fd)
527 {
528         if (! set_close_on_exec(fd)) {
529                 D_ERR("Failed to set close-on-exec on startup fd\n");
530                 return false;
531         }
532
533         sockd->startup_fd = fd;
534         return true;
535 }
536
537 /*
538  * Run socket daemon
539  */
540
541 struct sock_daemon_run_state {
542         struct tevent_context *ev;
543         struct sock_daemon_context *sockd;
544         pid_t pid_watch;
545
546         int fd;
547         int exit_code;
548 };
549
550 static void sock_daemon_run_started(struct tevent_req *subreq);
551 static void sock_daemon_run_startup_done(struct tevent_req *subreq);
552 static void sock_daemon_run_signal_handler(struct tevent_context *ev,
553                                            struct tevent_signal *se,
554                                            int signum, int count, void *siginfo,
555                                            void *private_data);
556 static void sock_daemon_run_reconfigure(struct tevent_req *req);
557 static void sock_daemon_run_reconfigure_done(struct tevent_req *subreq);
558 static void sock_daemon_run_shutdown(struct tevent_req *req);
559 static void sock_daemon_run_shutdown_done(struct tevent_req *subreq);
560 static void sock_daemon_run_exit(struct tevent_req *req);
561 static bool sock_daemon_run_socket_listen(struct tevent_req *req);
562 static void sock_daemon_run_socket_fail(struct tevent_req *subreq);
563 static void sock_daemon_run_watch_pid(struct tevent_req *subreq);
564 static void sock_daemon_run_wait(struct tevent_req *req);
565 static void sock_daemon_run_wait_done(struct tevent_req *subreq);
566 static void sock_daemon_startup_notify(struct sock_daemon_context *sockd);
567
568 struct tevent_req *sock_daemon_run_send(TALLOC_CTX *mem_ctx,
569                                         struct tevent_context *ev,
570                                         struct sock_daemon_context *sockd,
571                                         const char *pidfile,
572                                         bool do_fork, bool create_session,
573                                         pid_t pid_watch)
574 {
575         struct tevent_req *req, *subreq;
576         struct sock_daemon_run_state *state;
577         struct tevent_signal *se;
578
579         req = tevent_req_create(mem_ctx, &state,
580                                 struct sock_daemon_run_state);
581         if (req == NULL) {
582                 return NULL;
583         }
584
585         become_daemon(do_fork, !create_session, false);
586
587         if (pidfile != NULL) {
588                 int ret = pidfile_context_create(sockd, pidfile,
589                                                  &sockd->pid_ctx);
590                 if (ret != 0) {
591                         tevent_req_error(req, EEXIST);
592                         return tevent_req_post(req, ev);
593                 }
594         }
595
596         state->ev = ev;
597         state->sockd = sockd;
598         state->pid_watch = pid_watch;
599         state->fd  = -1;
600
601         subreq = tevent_wakeup_send(state, ev,
602                                     tevent_timeval_current_ofs(0, 0));
603         if (tevent_req_nomem(subreq, req)) {
604                 return tevent_req_post(req, ev);
605         }
606         tevent_req_set_callback(subreq, sock_daemon_run_started, req);
607
608         se = tevent_add_signal(ev, state, SIGHUP, 0,
609                                sock_daemon_run_signal_handler, req);
610         if (tevent_req_nomem(se, req)) {
611                 return tevent_req_post(req, ev);
612         }
613
614         se = tevent_add_signal(ev, state, SIGUSR1, 0,
615                                sock_daemon_run_signal_handler, req);
616         if (tevent_req_nomem(se, req)) {
617                 return tevent_req_post(req, ev);
618         }
619
620         se = tevent_add_signal(ev, state, SIGINT, 0,
621                                sock_daemon_run_signal_handler, req);
622         if (tevent_req_nomem(se, req)) {
623                 return tevent_req_post(req, ev);
624         }
625
626         se = tevent_add_signal(ev, state, SIGTERM, 0,
627                                sock_daemon_run_signal_handler, req);
628         if (tevent_req_nomem(se, req)) {
629                 return tevent_req_post(req, ev);
630         }
631
632         if (pid_watch > 1) {
633                 subreq = tevent_wakeup_send(state, ev,
634                                             tevent_timeval_current_ofs(1,0));
635                 if (tevent_req_nomem(subreq, req)) {
636                         return tevent_req_post(req, ev);
637                 }
638                 tevent_req_set_callback(subreq, sock_daemon_run_watch_pid,
639                                         req);
640         }
641
642         return req;
643 }
644
645 static void sock_daemon_run_started(struct tevent_req *subreq)
646 {
647         struct tevent_req *req = tevent_req_callback_data(
648                 subreq, struct tevent_req);
649         struct sock_daemon_run_state *state = tevent_req_data(
650                 req, struct sock_daemon_run_state);
651         struct sock_daemon_context *sockd = state->sockd;
652         bool status;
653
654         status = tevent_wakeup_recv(subreq);
655         TALLOC_FREE(subreq);
656         if (! status) {
657                 tevent_req_error(req, EIO);
658                 return;
659         }
660
661         D_NOTICE("daemon started, pid=%u\n", getpid());
662
663         if (sockd->funcs != NULL && sockd->funcs->startup_send != NULL &&
664             sockd->funcs->startup_recv != NULL) {
665                 subreq = sockd->funcs->startup_send(state, state->ev,
666                                                     sockd->private_data);
667                 if (tevent_req_nomem(subreq, req)) {
668                         return;
669                 }
670                 tevent_req_set_callback(subreq, sock_daemon_run_startup_done,
671                                         req);
672                 return;
673         }
674
675         if (sockd->funcs != NULL && sockd->funcs->startup != NULL) {
676                 int ret;
677
678                 ret = sockd->funcs->startup(sockd->private_data);
679                 if (ret != 0) {
680                         D_ERR("startup failed, ret=%d\n", ret);
681                         tevent_req_error(req, EIO);
682                         return;
683                 }
684
685                 D_NOTICE("startup completed successfully\n");
686         }
687
688         status = sock_daemon_run_socket_listen(req);
689         if (! status) {
690                 return;
691         }
692         sock_daemon_run_wait(req);
693
694         sock_daemon_startup_notify(sockd);
695 }
696
697 static void sock_daemon_run_startup_done(struct tevent_req *subreq)
698 {
699         struct tevent_req *req = tevent_req_callback_data(
700                 subreq, struct tevent_req);
701         struct sock_daemon_run_state *state = tevent_req_data(
702                 req, struct sock_daemon_run_state);
703         struct sock_daemon_context *sockd = state->sockd;
704         int ret;
705         bool status;
706
707         status = sockd->funcs->startup_recv(subreq, &ret);
708         TALLOC_FREE(subreq);
709         if (! status) {
710                 D_ERR("startup failed, ret=%d\n", ret);
711                 tevent_req_error(req, EIO);
712                 return;
713         }
714
715         D_NOTICE("startup completed successfully\n");
716
717         status = sock_daemon_run_socket_listen(req);
718         if (! status) {
719                 return;
720         }
721         sock_daemon_run_wait(req);
722
723         sock_daemon_startup_notify(sockd);
724 }
725
726 static void sock_daemon_run_signal_handler(struct tevent_context *ev,
727                                            struct tevent_signal *se,
728                                            int signum, int count, void *siginfo,
729                                            void *private_data)
730 {
731         struct tevent_req *req = talloc_get_type_abort(
732                 private_data, struct tevent_req);
733         struct sock_daemon_run_state *state = tevent_req_data(
734                 req, struct sock_daemon_run_state);
735
736         D_NOTICE("Received signal %d\n", signum);
737
738         if (signum == SIGHUP || signum == SIGUSR1) {
739                 sock_daemon_run_reconfigure(req);
740                 return;
741         }
742
743         if (signum == SIGINT || signum == SIGTERM) {
744                 state->exit_code = EINTR;
745                 sock_daemon_run_shutdown(req);
746         }
747 }
748
749 static void sock_daemon_run_reconfigure(struct tevent_req *req)
750 {
751         struct tevent_req *subreq;
752         struct sock_daemon_run_state *state = tevent_req_data(
753                 req, struct sock_daemon_run_state);
754         struct sock_daemon_context *sockd = state->sockd;
755
756         if (sockd->funcs != NULL && sockd->funcs->reconfigure_send != NULL &&
757             sockd->funcs->reconfigure_recv != NULL) {
758                 subreq = sockd->funcs->reconfigure_send(state, state->ev,
759                                                         sockd->private_data);
760                 if (tevent_req_nomem(subreq, req)) {
761                         return;
762                 }
763                 tevent_req_set_callback(subreq,
764                                         sock_daemon_run_reconfigure_done, req);
765                 return;
766         }
767
768         if (sockd->funcs != NULL && sockd->funcs->reconfigure != NULL) {
769                 int ret;
770
771                 ret = sockd->funcs->reconfigure(sockd->private_data);
772                 if (ret != 0) {
773                         D_ERR("reconfigure failed, ret=%d\n", ret);
774                         return;
775                 }
776
777                 D_NOTICE("reconfigure completed successfully\n");
778         }
779 }
780
781 static void sock_daemon_run_reconfigure_done(struct tevent_req *subreq)
782 {
783         struct tevent_req *req = tevent_req_callback_data(
784                 subreq, struct tevent_req);
785         struct sock_daemon_run_state *state = tevent_req_data(
786                 req, struct sock_daemon_run_state);
787         struct sock_daemon_context *sockd = state->sockd;
788         int ret;
789         bool status;
790
791         status = sockd->funcs->reconfigure_recv(subreq, &ret);
792         TALLOC_FREE(subreq);
793         if (! status) {
794                 D_ERR("reconfigure failed, ret=%d\n", ret);
795                 return;
796         }
797
798         D_NOTICE("reconfigure completed successfully\n");
799 }
800
801 static void sock_daemon_run_shutdown(struct tevent_req *req)
802 {
803         struct tevent_req *subreq;
804         struct sock_daemon_run_state *state = tevent_req_data(
805                 req, struct sock_daemon_run_state);
806         struct sock_daemon_context *sockd = state->sockd;
807         struct sock_socket *sock;
808
809         D_NOTICE("Shutting down\n");
810
811         while ((sock = sockd->socket_list) != NULL) {
812                 DLIST_REMOVE(sockd->socket_list, sock);
813                 TALLOC_FREE(sock);
814         }
815
816         if (sockd->funcs != NULL && sockd->funcs->shutdown_send != NULL &&
817             sockd->funcs->shutdown_recv != NULL) {
818                 subreq = sockd->funcs->shutdown_send(state, state->ev,
819                                                      sockd->private_data);
820                 if (subreq == NULL) {
821                         sock_daemon_run_exit(req);
822                         return;
823                 }
824                 tevent_req_set_callback(subreq, sock_daemon_run_shutdown_done,
825                                                 req);
826                 return;
827         }
828
829         if (sockd->funcs != NULL && sockd->funcs->shutdown != NULL) {
830                 sockd->funcs->shutdown(sockd->private_data);
831         }
832
833         sock_daemon_run_exit(req);
834 }
835
836 static void sock_daemon_run_shutdown_done(struct tevent_req *subreq)
837 {
838         struct tevent_req *req = tevent_req_callback_data(
839                 subreq, struct tevent_req);
840         struct sock_daemon_run_state *state = tevent_req_data(
841                 req, struct sock_daemon_run_state);
842         struct sock_daemon_context *sockd = state->sockd;
843
844         sockd->funcs->shutdown_recv(subreq);
845         TALLOC_FREE(subreq);
846
847         sock_daemon_run_exit(req);
848 }
849
850 static void sock_daemon_run_exit(struct tevent_req *req)
851 {
852         struct sock_daemon_run_state *state = tevent_req_data(
853                 req, struct sock_daemon_run_state);
854         struct sock_daemon_context *sockd = state->sockd;
855
856         TALLOC_FREE(sockd->pid_ctx);
857
858         if (state->exit_code == 0) {
859                 tevent_req_done(req);
860         } else {
861                 tevent_req_error(req, state->exit_code);
862         }
863 }
864
865 static bool sock_daemon_run_socket_listen(struct tevent_req *req)
866 {
867         struct tevent_req *subreq;
868         struct sock_daemon_run_state *state = tevent_req_data(
869                 req, struct sock_daemon_run_state);
870         struct sock_daemon_context *sockd = state->sockd;
871         struct sock_socket *sock;
872         bool remove_before_use = false;
873
874         if (sockd->pid_ctx != NULL) {
875                 remove_before_use = true;
876         }
877         for (sock = sockd->socket_list; sock != NULL; sock = sock->next) {
878                 subreq = sock_socket_start_send(state, state->ev, sock,
879                                                 remove_before_use);
880                 if (tevent_req_nomem(subreq, req)) {
881                         return false;
882                 }
883                 tevent_req_set_callback(subreq, sock_daemon_run_socket_fail,
884                                         req);
885         }
886
887         return true;
888 }
889
890 static void sock_daemon_run_socket_fail(struct tevent_req *subreq)
891 {
892         struct tevent_req *req = tevent_req_callback_data(
893                 subreq, struct tevent_req);
894         struct sock_daemon_run_state *state = tevent_req_data(
895                 req, struct sock_daemon_run_state);
896         const char *sockpath = NULL;
897         int ret = 0;
898         bool status;
899
900         status = sock_socket_start_recv(subreq, &ret, state, &sockpath);
901         TALLOC_FREE(subreq);
902         if (! status) {
903                 D_ERR("socket %s closed unexpectedly\n", sockpath);
904                 state->exit_code = ret;
905         } else {
906                 state->exit_code = 0;
907         }
908
909         sock_daemon_run_shutdown(req);
910 }
911
912 static void sock_daemon_run_watch_pid(struct tevent_req *subreq)
913 {
914         struct tevent_req *req = tevent_req_callback_data(
915                 subreq, struct tevent_req);
916         struct sock_daemon_run_state *state = tevent_req_data(
917                 req, struct sock_daemon_run_state);
918         int ret;
919         bool status;
920
921         status = tevent_wakeup_recv(subreq);
922         TALLOC_FREE(subreq);
923         if (! status) {
924                 tevent_req_error(req, EIO);
925                 return;
926         }
927
928         ret = kill(state->pid_watch, 0);
929         if (ret == -1) {
930                 if (errno == ESRCH) {
931                         D_ERR("PID %d gone away, exiting\n", state->pid_watch);
932                         state->exit_code = ESRCH;
933                         sock_daemon_run_shutdown(req);
934                         return;
935                 } else {
936                         D_ERR("Failed to check PID status %d, ret=%d\n",
937                               state->pid_watch, errno);
938                 }
939         }
940
941         subreq = tevent_wakeup_send(state, state->ev,
942                                     tevent_timeval_current_ofs(5,0));
943         if (tevent_req_nomem(subreq, req)) {
944                 return;
945         }
946         tevent_req_set_callback(subreq, sock_daemon_run_watch_pid, req);
947 }
948
949 static void sock_daemon_run_wait(struct tevent_req *req)
950 {
951         struct tevent_req *subreq;
952         struct sock_daemon_run_state *state = tevent_req_data(
953                 req, struct sock_daemon_run_state);
954         struct sock_daemon_context *sockd = state->sockd;
955
956         if (sockd->funcs != NULL && sockd->funcs->wait_send != NULL &&
957             sockd->funcs->wait_recv != NULL) {
958                 subreq = sockd->funcs->wait_send(state, state->ev,
959                                                  sockd->private_data);
960                 if (tevent_req_nomem(subreq, req)) {
961                         return;
962                 }
963                 tevent_req_set_callback(subreq, sock_daemon_run_wait_done,
964                                         req);
965         }
966 }
967
968 static void sock_daemon_run_wait_done(struct tevent_req *subreq)
969 {
970         struct tevent_req *req = tevent_req_callback_data(
971                 subreq, struct tevent_req);
972         struct sock_daemon_run_state *state = tevent_req_data(
973                 req, struct sock_daemon_run_state);
974         struct sock_daemon_context *sockd = state->sockd;
975         int ret = 0;
976         bool status;
977
978         status = sockd->funcs->wait_recv(subreq, &ret);
979         TALLOC_FREE(subreq);
980         if (! status) {
981                 state->exit_code = ret;
982         } else {
983                 state->exit_code = 0;
984         }
985
986         sock_daemon_run_shutdown(req);
987 }
988
989 static void sock_daemon_startup_notify(struct sock_daemon_context *sockd)
990 {
991         if (sockd->startup_fd != -1) {
992                 unsigned int zero = 0;
993                 ssize_t num;
994
995                 num = sys_write(sockd->startup_fd, &zero, sizeof(zero));
996                 if (num != sizeof(zero)) {
997                         D_WARNING("Failed to write zero to pipe FD\n");
998                 }
999         }
1000 }
1001
1002 bool sock_daemon_run_recv(struct tevent_req *req, int *perr)
1003 {
1004         int ret;
1005
1006         if (tevent_req_is_unix_error(req, &ret)) {
1007                 if (perr != NULL) {
1008                         *perr = ret;
1009                 }
1010                 return false;
1011         }
1012
1013         return true;
1014 }
1015
1016 int sock_daemon_run(struct tevent_context *ev,
1017                     struct sock_daemon_context *sockd,
1018                     const char *pidfile,
1019                     bool do_fork, bool create_session,
1020                     pid_t pid_watch)
1021 {
1022         struct tevent_req *req;
1023         int ret;
1024         bool status;
1025
1026         req = sock_daemon_run_send(ev, ev, sockd,
1027                                    pidfile, do_fork, create_session, pid_watch);
1028         if (req == NULL) {
1029                 return ENOMEM;
1030         }
1031
1032         tevent_req_poll(req, ev);
1033
1034         status = sock_daemon_run_recv(req, &ret);
1035         TALLOC_FREE(req);
1036         if (! status) {
1037                 return ret;
1038         }
1039
1040         return 0;
1041 }