3b679ab133263de6520b50b457fdc88174736b0e
[samba.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
34 #include "common/logging.h"
35 #include "common/reqid.h"
36 #include "common/comm.h"
37 #include "common/pidfile.h"
38 #include "common/sock_daemon.h"
39
40 struct sock_socket {
41         struct sock_socket *prev, *next;
42
43         const char *sockpath;
44         struct sock_socket_funcs *funcs;
45         void *private_data;
46
47         int fd;
48         struct tevent_req *req;
49 };
50
51 struct sock_client {
52         struct sock_client *prev, *next;
53
54         struct tevent_req *req;
55         struct sock_client_context *client_ctx;
56 };
57
58 struct sock_client_context {
59         struct tevent_context *ev;
60         struct sock_socket *sock;
61         int fd;
62         struct comm_context *comm;
63
64         struct sock_client *client;
65 };
66
67 struct sock_daemon_context {
68         struct sock_daemon_funcs *funcs;
69         void *private_data;
70
71         struct pidfile_context *pid_ctx;
72         struct sock_socket *socket_list;
73         struct tevent_req *req;
74 };
75
76 /*
77  * Process a single client
78  */
79
80 static void sock_client_read_handler(uint8_t *buf, size_t buflen,
81                                      void *private_data);
82 static void sock_client_read_done(struct tevent_req *subreq);
83 static void sock_client_dead_handler(void *private_data);
84 static int sock_client_context_destructor(
85                                 struct sock_client_context *client_ctx);
86
87 static int sock_client_context_init(TALLOC_CTX *mem_ctx,
88                                     struct tevent_context *ev,
89                                     struct sock_socket *sock,
90                                     int client_fd,
91                                     struct sock_client *client,
92                                     struct sock_client_context **result)
93 {
94         struct sock_client_context *client_ctx;
95         int ret;
96
97         client_ctx = talloc_zero(mem_ctx, struct sock_client_context);
98         if (client_ctx == NULL) {
99                 return ENOMEM;
100         }
101
102         client_ctx->ev = ev;
103         client_ctx->sock = sock;
104         client_ctx->fd = client_fd;
105         client_ctx->client = client;
106
107         ret = comm_setup(client_ctx, ev, client_fd,
108                          sock_client_read_handler, client_ctx,
109                          sock_client_dead_handler, client_ctx,
110                          &client_ctx->comm);
111         if (ret != 0) {
112                 talloc_free(client_ctx);
113                 return ret;
114         }
115
116         if (sock->funcs->connect != NULL) {
117                 bool status;
118
119                 status = sock->funcs->connect(client_ctx, sock->private_data);
120                 if (! status) {
121                         talloc_free(client_ctx);
122                         close(client_fd);
123                         return 0;
124                 }
125         }
126
127         talloc_set_destructor(client_ctx, sock_client_context_destructor);
128
129         *result = client_ctx;
130         return 0;
131 }
132
133 static void sock_client_read_handler(uint8_t *buf, size_t buflen,
134                                      void *private_data)
135 {
136         struct sock_client_context *client_ctx = talloc_get_type_abort(
137                 private_data, struct sock_client_context);
138         struct sock_socket *sock = client_ctx->sock;
139         struct tevent_req *subreq;
140
141         subreq = sock->funcs->read_send(client_ctx, client_ctx->ev,
142                                         client_ctx, buf, buflen,
143                                         sock->private_data);
144         if (subreq == NULL) {
145                 talloc_free(client_ctx);
146                 return;
147         }
148         tevent_req_set_callback(subreq, sock_client_read_done, client_ctx);
149 }
150
151 static void sock_client_read_done(struct tevent_req *subreq)
152 {
153         struct sock_client_context *client_ctx = tevent_req_callback_data(
154                 subreq, struct sock_client_context);
155         struct sock_socket *sock = client_ctx->sock;
156         int ret;
157         bool status;
158
159         status = sock->funcs->read_recv(subreq, &ret);
160         if (! status) {
161                 D_ERR("client read failed with ret=%d\n", ret);
162                 talloc_free(client_ctx);
163         }
164 }
165
166 static void sock_client_dead_handler(void *private_data)
167 {
168         struct sock_client_context *client_ctx = talloc_get_type_abort(
169                 private_data, struct sock_client_context);
170         struct sock_socket *sock = client_ctx->sock;
171
172         if (sock->funcs->disconnect != NULL) {
173                 sock->funcs->disconnect(client_ctx, sock->private_data);
174         }
175
176         talloc_free(client_ctx);
177 }
178
179 static int sock_client_context_destructor(
180                                 struct sock_client_context *client_ctx)
181 {
182         TALLOC_FREE(client_ctx->client);
183         TALLOC_FREE(client_ctx->comm);
184         if (client_ctx->fd != -1) {
185                 close(client_ctx->fd);
186                 client_ctx->fd = -1;
187         }
188
189         return 0;
190 }
191
192 /*
193  * Process a single listening socket
194  */
195
196 static int socket_setup(const char *sockpath, bool remove_before_use)
197 {
198         struct sockaddr_un addr;
199         size_t len;
200         int ret, fd;
201
202         memset(&addr, 0, sizeof(addr));
203         addr.sun_family = AF_UNIX;
204
205         len = strlcpy(addr.sun_path, sockpath, sizeof(addr.sun_path));
206         if (len >= sizeof(addr.sun_path)) {
207                 D_ERR("socket path too long: %s\n", sockpath);
208                 return -1;
209         }
210
211         fd = socket(AF_UNIX, SOCK_STREAM, 0);
212         if (fd == -1) {
213                 D_ERR("socket create failed - %s\n", sockpath);
214                 return -1;
215         }
216
217         ret = set_blocking(fd, false);
218         if (ret != 0) {
219                 D_ERR("socket set nonblocking failed - %s\n", sockpath);
220                 close(fd);
221                 return -1;
222         }
223
224         if (remove_before_use) {
225                 unlink(sockpath);
226         }
227
228         ret = bind(fd, (struct sockaddr *)&addr, sizeof(addr));
229         if (ret != 0) {
230                 D_ERR("socket bind failed - %s\n", sockpath);
231                 close(fd);
232                 return -1;
233         }
234
235         ret = listen(fd, 10);
236         if (ret != 0) {
237                 D_ERR("socket listen failed - %s\n", sockpath);
238                 close(fd);
239                 return -1;
240         }
241
242         return fd;
243 }
244
245 static int sock_socket_destructor(struct sock_socket *sock);
246
247 static int sock_socket_init(TALLOC_CTX *mem_ctx, const char *sockpath,
248                             struct sock_socket_funcs *funcs,
249                             void *private_data,
250                             bool remove_before_use,
251                             struct sock_socket **result)
252 {
253         struct sock_socket *sock;
254
255         if (funcs == NULL) {
256                 return EINVAL;
257         }
258         if (funcs->read_send == NULL || funcs->read_recv == NULL) {
259                 return EINVAL;
260         }
261
262         sock = talloc_zero(mem_ctx, struct sock_socket);
263         if (sock == NULL) {
264                 return ENOMEM;
265         }
266
267         sock->sockpath = sockpath;
268         sock->funcs = funcs;
269         sock->private_data = private_data;
270
271         sock->fd = socket_setup(sockpath, remove_before_use);
272         if (sock->fd == -1) {
273                 talloc_free(sock);
274                 return EIO;
275         }
276
277         talloc_set_destructor(sock, sock_socket_destructor);
278
279         *result = sock;
280         return 0;
281 }
282
283 static int sock_socket_destructor(struct sock_socket *sock)
284 {
285         if (sock->fd != -1) {
286                 close(sock->fd);
287                 sock->fd = -1;
288         }
289
290         unlink(sock->sockpath);
291         return 0;
292 }
293
294
295 struct sock_socket_start_state {
296         struct tevent_context *ev;
297         struct sock_socket *sock;
298
299         struct sock_client *client_list;
300 };
301
302 static int sock_socket_start_state_destructor(
303                                 struct sock_socket_start_state *state);
304 static void sock_socket_start_new_client(struct tevent_req *subreq);
305 static int sock_socket_start_client_destructor(struct sock_client *client);
306
307 static struct tevent_req *sock_socket_start_send(TALLOC_CTX *mem_ctx,
308                                                  struct tevent_context *ev,
309                                                  struct sock_socket *sock)
310 {
311         struct tevent_req *req, *subreq;
312         struct sock_socket_start_state *state;
313
314         req = tevent_req_create(mem_ctx, &state,
315                                 struct sock_socket_start_state);
316         if (req == NULL) {
317                 return NULL;
318         }
319
320         state->ev = ev;
321         state->sock = sock;
322
323         talloc_set_destructor(state, sock_socket_start_state_destructor);
324
325         subreq = accept_send(state, ev, sock->fd);
326         if (tevent_req_nomem(subreq, req)) {
327                 return tevent_req_post(req, ev);
328         }
329         tevent_req_set_callback(subreq, sock_socket_start_new_client, req);
330
331         return req;
332 }
333
334 static int sock_socket_start_state_destructor(
335                                 struct sock_socket_start_state *state)
336 {
337         struct sock_client *client;
338
339         while ((client = state->client_list) != NULL) {
340                 talloc_free(client);
341         }
342
343         return 0;
344 }
345
346 static void sock_socket_start_new_client(struct tevent_req *subreq)
347 {
348         struct tevent_req *req = tevent_req_callback_data(
349                 subreq, struct tevent_req);
350         struct sock_socket_start_state *state = tevent_req_data(
351                 req, struct sock_socket_start_state);
352         struct sock_client *client;
353         int client_fd, ret;
354
355         client_fd = accept_recv(subreq, NULL, NULL, &ret);
356         TALLOC_FREE(subreq);
357         if (client_fd == -1) {
358                 D_ERR("failed to accept new connection\n");
359         }
360
361         subreq = accept_send(state, state->ev, state->sock->fd);
362         if (tevent_req_nomem(subreq, req)) {
363                 return;
364         }
365         tevent_req_set_callback(subreq, sock_socket_start_new_client, req);
366
367         if (client_fd == -1) {
368                 return;
369         }
370
371         client = talloc_zero(state, struct sock_client);
372         if (tevent_req_nomem(client, req)) {
373                 close(client_fd);
374                 return;
375         }
376
377         client->req = req;
378
379         ret = sock_client_context_init(client, state->ev, state->sock,
380                                        client_fd, client, &client->client_ctx);
381         if (ret != 0) {
382                 talloc_free(client);
383                 return;
384         }
385
386         talloc_set_destructor(client, sock_socket_start_client_destructor);
387         DLIST_ADD(state->client_list, client);
388 }
389
390 static int sock_socket_start_client_destructor(struct sock_client *client)
391 {
392         struct sock_socket_start_state *state = tevent_req_data(
393                 client->req, struct sock_socket_start_state);
394
395         DLIST_REMOVE(state->client_list, client);
396         TALLOC_FREE(client->client_ctx);
397
398         return 0;
399 }
400
401 static bool sock_socket_start_recv(struct tevent_req *req, int *perr)
402 {
403         struct sock_socket_start_state *state = tevent_req_data(
404                 req, struct sock_socket_start_state);
405         int ret;
406
407         state->sock->req = NULL;
408
409         if (tevent_req_is_unix_error(req, &ret)) {
410                 if (perr != NULL) {
411                         *perr = ret;
412                 }
413                 return false;
414         }
415
416         return true;
417 }
418
419 /*
420  * Send message to a client
421  */
422
423 struct tevent_req *sock_socket_write_send(TALLOC_CTX *mem_ctx,
424                                          struct tevent_context *ev,
425                                          struct sock_client_context *client_ctx,
426                                          uint8_t *buf, size_t buflen)
427 {
428         struct tevent_req *req;
429
430         req = comm_write_send(mem_ctx, ev, client_ctx->comm, buf, buflen);
431
432         return req;
433 }
434
435 bool sock_socket_write_recv(struct tevent_req *req, int *perr)
436 {
437         int ret;
438         bool status;
439
440         status = comm_write_recv(req, &ret);
441         if (! status) {
442                 if (perr != NULL) {
443                         *perr = ret;
444                 }
445         }
446
447         return status;
448 }
449
450 /*
451  * Socket daemon
452  */
453
454 static int sock_daemon_context_destructor(struct sock_daemon_context *sockd);
455
456 int sock_daemon_setup(TALLOC_CTX *mem_ctx, const char *daemon_name,
457                       const char *logging, const char *debug_level,
458                       const char *pidfile,
459                       struct sock_daemon_funcs *funcs,
460                       void *private_data,
461                       struct sock_daemon_context **out)
462 {
463         struct sock_daemon_context *sockd;
464         int ret;
465
466         sockd = talloc_zero(mem_ctx, struct sock_daemon_context);
467         if (sockd == NULL) {
468                 return ENOMEM;
469         }
470
471         sockd->funcs = funcs;
472         sockd->private_data = private_data;
473
474         ret = logging_init(sockd, logging, debug_level, daemon_name);
475         if (ret != 0) {
476                 fprintf(stderr,
477                         "Failed to initialize logging, logging=%s, debug=%s\n",
478                         logging, debug_level);
479                 return ret;
480         }
481
482         if (pidfile != NULL) {
483                 ret = pidfile_create(sockd, pidfile, &sockd->pid_ctx);
484                 if (ret != 0) {
485                         talloc_free(sockd);
486                         return EEXIST;
487                 }
488         }
489
490         talloc_set_destructor(sockd, sock_daemon_context_destructor);
491
492         *out = sockd;
493         return 0;
494 }
495
496 static int sock_daemon_context_destructor(struct sock_daemon_context *sockd)
497 {
498         if (sockd->req != NULL) {
499                 tevent_req_done(sockd->req);
500         }
501
502         return 0;
503 }
504
505 int sock_daemon_add_unix(struct sock_daemon_context *sockd,
506                          const char *sockpath,
507                          struct sock_socket_funcs *funcs,
508                          void *private_data)
509 {
510         struct sock_socket *sock;
511         int ret;
512         bool remove_before_use = false;
513
514         remove_before_use = (sockd->pid_ctx != NULL) ? true : false;
515
516         ret = sock_socket_init(sockd, sockpath, funcs, private_data,
517                                remove_before_use, &sock);
518         if (ret != 0) {
519                 return ret;
520         }
521
522         D_NOTICE("listening on %s\n", sockpath);
523
524         DLIST_ADD(sockd->socket_list, sock);
525         return 0;
526 }
527
528 /*
529  * Run socket daemon
530  */
531
532 struct sock_daemon_run_state {
533         struct tevent_context *ev;
534         struct sock_daemon_context *sockd;
535         pid_t pid_watch;
536
537         int fd;
538 };
539
540 static void sock_daemon_run_started(struct tevent_req *subreq);
541 static void sock_daemon_run_signal_handler(struct tevent_context *ev,
542                                            struct tevent_signal *se,
543                                            int signum, int count, void *siginfo,
544                                            void *private_data);
545 static void sock_daemon_run_reconfigure(struct tevent_req *req);
546 static void sock_daemon_run_shutdown(struct tevent_req *req);
547 static void sock_daemon_run_socket_fail(struct tevent_req *subreq);
548 static void sock_daemon_run_watch_pid(struct tevent_req *subreq);
549
550 struct tevent_req *sock_daemon_run_send(TALLOC_CTX *mem_ctx,
551                                         struct tevent_context *ev,
552                                         struct sock_daemon_context *sockd,
553                                         pid_t pid_watch)
554 {
555         struct tevent_req *req, *subreq;
556         struct sock_daemon_run_state *state;
557         struct tevent_signal *se;
558         struct sock_socket *sock;
559
560         req = tevent_req_create(mem_ctx, &state,
561                                 struct sock_daemon_run_state);
562         if (req == NULL) {
563                 return NULL;
564         }
565
566         state->ev = ev;
567         state->sockd = sockd;
568         state->pid_watch = pid_watch;
569         state->fd  = -1;
570
571         subreq = tevent_wakeup_send(state, ev,
572                                     tevent_timeval_current_ofs(0, 0));
573         if (tevent_req_nomem(subreq, req)) {
574                 return tevent_req_post(req, ev);
575         }
576         tevent_req_set_callback(subreq, sock_daemon_run_started, req);
577
578         se = tevent_add_signal(ev, state, SIGHUP, 0,
579                                sock_daemon_run_signal_handler, req);
580         if (tevent_req_nomem(se, req)) {
581                 return tevent_req_post(req, ev);
582         }
583
584         se = tevent_add_signal(ev, state, SIGUSR1, 0,
585                                sock_daemon_run_signal_handler, req);
586         if (tevent_req_nomem(se, req)) {
587                 return tevent_req_post(req, ev);
588         }
589
590         se = tevent_add_signal(ev, state, SIGINT, 0,
591                                sock_daemon_run_signal_handler, req);
592         if (tevent_req_nomem(se, req)) {
593                 return tevent_req_post(req, ev);
594         }
595
596         se = tevent_add_signal(ev, state, SIGTERM, 0,
597                                sock_daemon_run_signal_handler, req);
598         if (tevent_req_nomem(se, req)) {
599                 return tevent_req_post(req, ev);
600         }
601
602         for (sock = sockd->socket_list; sock != NULL; sock = sock->next) {
603                 subreq = sock_socket_start_send(state, ev, sock);
604                 if (tevent_req_nomem(subreq, req)) {
605                         return tevent_req_post(req, ev);
606                 }
607                 tevent_req_set_callback(subreq, sock_daemon_run_socket_fail,
608                                         req);
609
610                 sock->req = subreq;
611         }
612
613         if (pid_watch > 1) {
614                 subreq = tevent_wakeup_send(state, ev,
615                                             tevent_timeval_current_ofs(1,0));
616                 if (tevent_req_nomem(subreq, req)) {
617                         return tevent_req_post(req, ev);
618                 }
619                 tevent_req_set_callback(subreq, sock_daemon_run_watch_pid,
620                                         req);
621         }
622
623         sockd->req = req;
624
625         return req;
626 }
627
628 static void sock_daemon_run_started(struct tevent_req *subreq)
629 {
630         struct tevent_req *req = tevent_req_callback_data(
631                 subreq, struct tevent_req);
632         struct sock_daemon_run_state *state = tevent_req_data(
633                 req, struct sock_daemon_run_state);
634         struct sock_daemon_context *sockd = state->sockd;
635
636         D_NOTICE("daemon started, pid=%u\n", getpid());
637
638         if (sockd->funcs != NULL && sockd->funcs->startup != NULL) {
639                 sockd->funcs->startup(sockd->private_data);
640         }
641 }
642
643 static void sock_daemon_run_signal_handler(struct tevent_context *ev,
644                                            struct tevent_signal *se,
645                                            int signum, int count, void *siginfo,
646                                            void *private_data)
647 {
648         struct tevent_req *req = talloc_get_type_abort(
649                 private_data, struct tevent_req);
650
651         D_NOTICE("Received signal %d\n", signum);
652
653         if (signum == SIGHUP || signum == SIGUSR1) {
654                 sock_daemon_run_reconfigure(req);
655                 return;
656         }
657
658         if (signum == SIGINT || signum == SIGTERM) {
659                 sock_daemon_run_shutdown(req);
660                 tevent_req_error(req, EINTR);
661         }
662 }
663
664 static void sock_daemon_run_reconfigure(struct tevent_req *req)
665 {
666         struct sock_daemon_run_state *state = tevent_req_data(
667                 req, struct sock_daemon_run_state);
668         struct sock_daemon_context *sockd = state->sockd;
669
670         if (sockd->funcs != NULL && sockd->funcs->reconfigure != NULL) {
671                 sockd->funcs->reconfigure(sockd->private_data);
672         }
673 }
674
675 static void sock_daemon_run_shutdown(struct tevent_req *req)
676 {
677         struct sock_daemon_run_state *state = tevent_req_data(
678                 req, struct sock_daemon_run_state);
679         struct sock_daemon_context *sockd = state->sockd;
680         struct sock_socket *sock;
681
682         D_NOTICE("Shutting down\n");
683
684         while ((sock = sockd->socket_list) != NULL) {
685                 DLIST_REMOVE(sockd->socket_list, sock);
686                 TALLOC_FREE(sock->req);
687                 TALLOC_FREE(sock);
688         }
689
690         if (sockd->funcs != NULL && sockd->funcs->shutdown != NULL) {
691                 sockd->funcs->shutdown(sockd->private_data);
692         }
693
694         TALLOC_FREE(sockd->pid_ctx);
695 }
696
697 static void sock_daemon_run_socket_fail(struct tevent_req *subreq)
698 {
699         struct tevent_req *req = tevent_req_callback_data(
700                 subreq, struct tevent_req);
701         int ret = 0;
702         bool status;
703
704         status = sock_socket_start_recv(subreq, &ret);
705         TALLOC_FREE(subreq);
706         sock_daemon_run_shutdown(req);
707         if (! status) {
708                 tevent_req_error(req, ret);
709         } else {
710                 tevent_req_done(req);
711         }
712 }
713
714 static void sock_daemon_run_watch_pid(struct tevent_req *subreq)
715 {
716         struct tevent_req *req = tevent_req_callback_data(
717                 subreq, struct tevent_req);
718         struct sock_daemon_run_state *state = tevent_req_data(
719                 req, struct sock_daemon_run_state);
720         int ret;
721         bool status;
722
723         status = tevent_wakeup_recv(subreq);
724         TALLOC_FREE(subreq);
725         if (! status) {
726                 tevent_req_error(req, EIO);
727                 return;
728         }
729
730         ret = kill(state->pid_watch, 0);
731         if (ret == -1) {
732                 if (errno == ESRCH) {
733                         D_ERR("PID %d gone away, exiting\n", state->pid_watch);
734                         sock_daemon_run_shutdown(req);
735                         tevent_req_error(req, ESRCH);
736                         return;
737                 } else {
738                         D_ERR("Failed to check PID status %d, ret=%d\n",
739                               state->pid_watch, errno);
740                 }
741         }
742
743         subreq = tevent_wakeup_send(state, state->ev,
744                                     tevent_timeval_current_ofs(5,0));
745         if (tevent_req_nomem(subreq, req)) {
746                 return;
747         }
748         tevent_req_set_callback(subreq, sock_daemon_run_watch_pid, req);
749 }
750
751 bool sock_daemon_run_recv(struct tevent_req *req, int *perr)
752 {
753         int ret;
754
755         if (tevent_req_is_unix_error(req, &ret)) {
756                 if (perr != NULL) {
757                         *perr = ret;
758                 }
759                 return false;
760         }
761
762         return true;
763 }
764
765 int sock_daemon_run(struct tevent_context *ev,
766                     struct sock_daemon_context *sockd,
767                     pid_t pid_watch)
768 {
769         struct tevent_req *req;
770         int ret;
771         bool status;
772
773         req = sock_daemon_run_send(ev, ev, sockd, pid_watch);
774         if (req == NULL) {
775                 return ENOMEM;
776         }
777
778         tevent_req_poll(req, ev);
779
780         status = sock_daemon_run_recv(req, &ret);
781         sockd->req = NULL;
782         TALLOC_FREE(req);
783         if (! status) {
784                 return ret;
785         }
786
787         return 0;
788 }