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 = "INVALID";
 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 }