ctdb/tests/src/sock_daemon_test.c

   1 /*
   2    sock daemon tests
   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 <assert.h>
  26
  27 #include "common/logging.c"
  28 #include "common/pkt_read.c"
  29 #include "common/pkt_write.c"
  30 #include "common/comm.c"
  31 #include "common/pidfile.c"
  32 #include "common/sock_daemon.c"
  33 #include "common/sock_io.c"
  34
  35 struct dummy_wait_state {
  36 };
  37
  38 static struct tevent_req *dummy_wait_send(TALLOC_CTX *mem_ctx,
  39                                           struct tevent_context *ev,
  40                                           void *private_data)
  41 {
  42         struct tevent_req *req;
  43         struct dummy_wait_state *state;
  44         const char *sockpath = (const char *)private_data;
  45         struct stat st;
  46         int ret;
  47
  48         ret = stat(sockpath, &st);
  49         assert(ret == 0);
  50         assert(S_ISSOCK(st.st_mode));
  51
  52         req = tevent_req_create(mem_ctx, &state, struct dummy_wait_state);
  53         if (req == NULL) {
  54                 return NULL;
  55         }
  56
  57         tevent_req_done(req);
  58         return tevent_req_post(req, ev);
  59 }
  60
  61 static bool dummy_wait_recv(struct tevent_req *req, int *perr)
  62 {
  63         return true;
  64 }
  65
  66 static int test1_startup_fail(void *private_data)
  67 {
  68         return 1;
  69 }
  70
  71 static int test1_startup(void *private_data)
  72 {
  73         const char *sockpath = (const char *)private_data;
  74         struct stat st;
  75         int ret;
  76
  77         ret = stat(sockpath, &st);
  78         assert(ret == -1);
  79
  80         return 0;
  81 }
  82
  83 struct test1_startup_state {
  84 };
  85
  86 static struct tevent_req *test1_startup_send(TALLOC_CTX *mem_ctx,
  87                                              struct tevent_context *ev,
  88                                              void *private_data)
  89 {
  90         struct tevent_req *req;
  91         struct test1_startup_state *state;
  92
  93         req = tevent_req_create(mem_ctx, &state, struct test1_startup_state);
  94         if (req == NULL) {
  95                 return NULL;
  96         }
  97
  98         tevent_req_error(req, 2);
  99         return tevent_req_post(req, ev);
 100 }
 101
 102 static bool test1_startup_recv(struct tevent_req *req, int *perr)
 103 {
 104         if (tevent_req_is_unix_error(req, perr)) {
 105                 return false;
 106         }
 107
 108         return true;
 109 }
 110
 111 static struct tevent_req *dummy_read_send(TALLOC_CTX *mem_ctx,
 112                                           struct tevent_context *ev,
 113                                           struct sock_client_context *client,
 114                                           uint8_t *buf, size_t buflen,
 115                                           void *private_data)
 116 {
 117         return NULL;
 118 }
 119
 120 static bool dummy_read_recv(struct tevent_req *req, int *perr)
 121 {
 122         if (perr != NULL) {
 123                 *perr = EINVAL;
 124         }
 125         return false;
 126 }
 127
 128 static struct sock_socket_funcs dummy_socket_funcs = {
 129         .read_send = dummy_read_send,
 130         .read_recv = dummy_read_recv,
 131 };
 132
 133 /*
 134  * test1
 135  *
 136  * Check setup without actually running daemon
 137  */
 138
 139 static void test1(TALLOC_CTX *mem_ctx, const char *pidfile,
 140                   const char *sockpath)
 141 {
 142         struct tevent_context *ev;
 143         struct sock_daemon_context *sockd;
 144         struct sock_daemon_funcs test1_funcs;
 145         struct stat st;
 146         int ret;
 147
 148         ev = tevent_context_init(mem_ctx);
 149         assert(ev != NULL);
 150
 151         test1_funcs = (struct sock_daemon_funcs){
 152                 .startup = test1_startup_fail,
 153         };
 154
 155         ret = sock_daemon_setup(mem_ctx, "test1", "file:", "NOTICE",
 156                                 &test1_funcs, NULL, &sockd);
 157         assert(ret == 0);
 158         assert(sockd != NULL);
 159
 160         ret = stat(pidfile, &st);
 161         assert(ret == -1);
 162
 163         ret = sock_daemon_run(ev, sockd, NULL, false, false, -1);
 164         assert(ret == EIO);
 165         talloc_free(sockd);
 166
 167         test1_funcs = (struct sock_daemon_funcs){
 168                 .startup_send = test1_startup_send,
 169                 .startup_recv = test1_startup_recv,
 170         };
 171
 172         ret = sock_daemon_setup(mem_ctx, "test1", "file:", "NOTICE",
 173                                 &test1_funcs, NULL, &sockd);
 174         assert(ret == 0);
 175         assert(sockd != NULL);
 176
 177         ret = stat(pidfile, &st);
 178         assert(ret == -1);
 179
 180         ret = sock_daemon_run(ev, sockd, NULL, false, false, -1);
 181         assert(ret == EIO);
 182         talloc_free(sockd);
 183
 184         test1_funcs = (struct sock_daemon_funcs){
 185                 .startup = test1_startup,
 186                 .wait_send = dummy_wait_send,
 187                 .wait_recv = dummy_wait_recv,
 188         };
 189
 190         ret = sock_daemon_setup(mem_ctx, "test1", "file:", "NOTICE",
 191                                 &test1_funcs, discard_const(sockpath), &sockd);
 192         assert(ret == 0);
 193         assert(sockd != NULL);
 194
 195         ret = sock_daemon_add_unix(sockd, sockpath, &dummy_socket_funcs, NULL);
 196         assert(ret == 0);
 197
 198         ret = stat(sockpath, &st);
 199         assert(ret == -1);
 200
 201         ret = sock_daemon_run(ev, sockd, NULL, false, false, -1);
 202         assert(ret == 0);
 203
 204         talloc_free(mem_ctx);
 205 }
 206
 207 /*
 208  * test2
 209  *
 210  * Start daemon, check PID file, sock daemon functions, termination,
 211  * exit code
 212  */
 213
 214 static int test2_startup(void *private_data)
 215 {
 216         int fd = *(int *)private_data;
 217         int ret = 1;
 218         ssize_t nwritten;
 219
 220         nwritten = write(fd, &ret, sizeof(ret));
 221         assert(nwritten == sizeof(ret));
 222         return 0;
 223 }
 224
 225 static int test2_reconfigure(void *private_data)
 226 {
 227         static bool first_time = true;
 228         int fd = *(int *)private_data;
 229         int ret = 2;
 230         ssize_t nwritten;
 231
 232         nwritten = write(fd, &ret, sizeof(ret));
 233         assert(nwritten == sizeof(ret));
 234
 235         if (first_time) {
 236                 first_time = false;
 237                 return 1;
 238         }
 239
 240         return 0;
 241 }
 242
 243 struct test2_reconfigure_state {
 244         int fd;
 245 };
 246
 247 static struct tevent_req *test2_reconfigure_send(TALLOC_CTX *mem_ctx,
 248                                                  struct tevent_context *ev,
 249                                                  void *private_data)
 250 {
 251         struct tevent_req *req;
 252         struct test2_reconfigure_state *state;
 253         static bool first_time = true;
 254
 255         req = tevent_req_create(mem_ctx, &state,
 256                                 struct test2_reconfigure_state);
 257         if (req == NULL) {
 258                 return NULL;
 259         }
 260
 261         state->fd = *(int *)private_data;
 262
 263         if (first_time) {
 264                 first_time = false;
 265                 tevent_req_error(req, 2);
 266         } else {
 267                 tevent_req_done(req);
 268         }
 269
 270         return tevent_req_post(req, ev);
 271 }
 272
 273 static bool test2_reconfigure_recv(struct tevent_req *req, int *perr)
 274 {
 275         struct test2_reconfigure_state *state = tevent_req_data(
 276                 req, struct test2_reconfigure_state);
 277         int ret = 2;
 278         ssize_t nwritten;
 279
 280         nwritten = write(state->fd, &ret, sizeof(ret));
 281         assert(nwritten == sizeof(ret));
 282
 283         if (tevent_req_is_unix_error(req, perr)) {
 284                 return false;
 285         }
 286
 287         return true;
 288 }
 289
 290 static void test2_shutdown(void *private_data)
 291 {
 292         int fd = *(int *)private_data;
 293         int ret = 3;
 294         ssize_t nwritten;
 295
 296         nwritten = write(fd, &ret, sizeof(ret));
 297         assert(nwritten == sizeof(ret));
 298 }
 299
 300 struct test2_shutdown_state {
 301         int fd;
 302 };
 303
 304 static struct tevent_req *test2_shutdown_send(TALLOC_CTX *mem_ctx,
 305                                               struct tevent_context *ev,
 306                                               void *private_data)
 307 {
 308         struct tevent_req *req;
 309         struct test2_shutdown_state *state;
 310
 311         req = tevent_req_create(mem_ctx, &state,
 312                                 struct test2_shutdown_state);
 313         if (req == NULL) {
 314                 return NULL;
 315         }
 316
 317         state->fd = *(int *)private_data;
 318
 319         tevent_req_done(req);
 320         return tevent_req_post(req, ev);
 321 }
 322
 323 static void test2_shutdown_recv(struct tevent_req *req)
 324 {
 325         struct test2_shutdown_state *state = tevent_req_data(
 326                 req, struct test2_shutdown_state);
 327         int ret = 3;
 328         ssize_t nwritten;
 329
 330         nwritten = write(state->fd, &ret, sizeof(ret));
 331         assert(nwritten == sizeof(ret));
 332 }
 333
 334 static void test2(TALLOC_CTX *mem_ctx, const char *pidfile,
 335                   const char *sockpath)
 336 {
 337         struct stat st;
 338         int fd[2];
 339         pid_t pid, pid2;
 340         int ret;
 341         ssize_t n;
 342         int pidfile_fd;
 343         char pidstr[20] = { 0 };
 344
 345         ret = pipe(fd);
 346         assert(ret == 0);
 347
 348         pid = fork();
 349         assert(pid != -1);
 350
 351         if (pid == 0) {
 352                 struct tevent_context *ev;
 353                 struct sock_daemon_context *sockd;
 354                 struct sock_daemon_funcs test2_funcs = {
 355                         .startup = test2_startup,
 356                         .reconfigure = test2_reconfigure,
 357                         .shutdown = test2_shutdown,
 358                 };
 359
 360                 close(fd[0]);
 361
 362                 ev = tevent_context_init(mem_ctx);
 363                 assert(ev != NULL);
 364
 365                 ret = sock_daemon_setup(mem_ctx, "test2", "file:", "NOTICE",
 366                                         &test2_funcs, &fd[1], &sockd);
 367                 assert(ret == 0);
 368
 369                 ret = sock_daemon_add_unix(sockd, sockpath,
 370                                            &dummy_socket_funcs, NULL);
 371                 assert(ret == 0);
 372
 373                 ret = sock_daemon_run(ev, sockd, pidfile, false, false, -1);
 374                 assert(ret == EINTR);
 375
 376                 exit(0);
 377         }
 378
 379         close(fd[1]);
 380
 381         n = read(fd[0], &ret, sizeof(ret));
 382         assert(n == sizeof(ret));
 383         assert(ret == 1);
 384
 385         pidfile_fd = open(pidfile, O_RDONLY, 0644);
 386         assert(pidfile_fd != -1);
 387         ret = fstat(pidfile_fd, &st);
 388         assert(ret == 0);
 389         assert(S_ISREG(st.st_mode));
 390         n = read(pidfile_fd, pidstr, sizeof(pidstr)-1);
 391         assert(n != -1);
 392         pid2 = (pid_t)atoi(pidstr);
 393         assert(pid == pid2);
 394         close(pidfile_fd);
 395
 396         ret = kill(pid, SIGHUP);
 397         assert(ret == 0);
 398
 399         n = read(fd[0], &ret, sizeof(ret));
 400         assert(n == sizeof(ret));
 401         assert(ret == 2);
 402
 403         ret = kill(pid, SIGUSR1);
 404         assert(ret == 0);
 405
 406         n = read(fd[0], &ret, sizeof(ret));
 407         assert(n == sizeof(ret));
 408         assert(ret == 2);
 409
 410         ret = kill(pid, SIGTERM);
 411         assert(ret == 0);
 412
 413         n = read(fd[0], &ret, sizeof(ret));
 414         assert(n == sizeof(ret));
 415         assert(ret == 3);
 416
 417         pid2 = waitpid(pid, &ret, 0);
 418         assert(pid2 == pid);
 419         assert(WEXITSTATUS(ret) == 0);
 420
 421         close(fd[0]);
 422
 423         ret = stat(pidfile, &st);
 424         assert(ret == -1);
 425
 426         ret = stat(sockpath, &st);
 427         assert(ret == -1);
 428
 429         ret = pipe(fd);
 430         assert(ret == 0);
 431
 432         pid = fork();
 433         assert(pid != -1);
 434
 435         if (pid == 0) {
 436                 struct tevent_context *ev;
 437                 struct sock_daemon_context *sockd;
 438                 struct sock_daemon_funcs test2_funcs = {
 439                         .startup = test2_startup,
 440                         .reconfigure_send = test2_reconfigure_send,
 441                         .reconfigure_recv = test2_reconfigure_recv,
 442                         .shutdown_send = test2_shutdown_send,
 443                         .shutdown_recv = test2_shutdown_recv,
 444                 };
 445
 446                 close(fd[0]);
 447
 448                 ev = tevent_context_init(mem_ctx);
 449                 assert(ev != NULL);
 450
 451                 ret = sock_daemon_setup(mem_ctx, "test2", "file:", "NOTICE",
 452                                         &test2_funcs, &fd[1], &sockd);
 453                 assert(ret == 0);
 454
 455                 ret = sock_daemon_add_unix(sockd, sockpath,
 456                                            &dummy_socket_funcs, NULL);
 457                 assert(ret == 0);
 458
 459                 ret = sock_daemon_run(ev, sockd, pidfile, false, false, -1);
 460                 assert(ret == EINTR);
 461
 462                 exit(0);
 463         }
 464
 465         close(fd[1]);
 466
 467         n = read(fd[0], &ret, sizeof(ret));
 468         assert(n == sizeof(ret));
 469         assert(ret == 1);
 470
 471         ret = kill(pid, SIGUSR1);
 472         assert(ret == 0);
 473
 474         n = read(fd[0], &ret, sizeof(ret));
 475         assert(n == sizeof(ret));
 476         assert(ret == 2);
 477
 478         ret = kill(pid, SIGHUP);
 479         assert(ret == 0);
 480
 481         n = read(fd[0], &ret, sizeof(ret));
 482         assert(n == sizeof(ret));
 483         assert(ret == 2);
 484
 485         ret = kill(pid, SIGTERM);
 486         assert(ret == 0);
 487
 488         n = read(fd[0], &ret, sizeof(ret));
 489         assert(n == sizeof(ret));
 490         assert(ret == 3);
 491
 492         pid2 = waitpid(pid, &ret, 0);
 493         assert(pid2 == pid);
 494         assert(WEXITSTATUS(ret) == 0);
 495
 496         close(fd[0]);
 497 }
 498
 499 /*
 500  * test3
 501  *
 502  * Start daemon, test watching of (parent) PID
 503  */
 504
 505 static void test3(TALLOC_CTX *mem_ctx, const char *pidfile,
 506                   const char *sockpath)
 507 {
 508         struct stat st;
 509         pid_t pid_watch, pid, pid2;
 510         int ret;
 511
 512         pid_watch = fork();
 513         assert(pid_watch != -1);
 514
 515         if (pid_watch == 0) {
 516                 sleep(10);
 517                 exit(0);
 518         }
 519
 520         pid = fork();
 521         assert(pid != -1);
 522
 523         if (pid == 0) {
 524                 struct tevent_context *ev;
 525                 struct sock_daemon_context *sockd;
 526
 527                 ev = tevent_context_init(mem_ctx);
 528                 assert(ev != NULL);
 529
 530                 ret = sock_daemon_setup(mem_ctx, "test3", "file:", "NOTICE",
 531                                         NULL, NULL, &sockd);
 532                 assert(ret == 0);
 533
 534                 ret = sock_daemon_add_unix(sockd, sockpath,
 535                                            &dummy_socket_funcs, NULL);
 536                 assert(ret == 0);
 537
 538                 ret = sock_daemon_run(ev, sockd, NULL, false, false, pid_watch);
 539                 assert(ret == ESRCH);
 540
 541                 exit(0);
 542         }
 543
 544         pid2 = waitpid(pid_watch, &ret, 0);
 545         assert(pid2 == pid_watch);
 546         assert(WEXITSTATUS(ret) == 0);
 547
 548         pid2 = waitpid(pid, &ret, 0);
 549         assert(pid2 == pid);
 550         assert(WEXITSTATUS(ret) == 0);
 551
 552         ret = stat(pidfile, &st);
 553         assert(ret == -1);
 554
 555         ret = stat(sockpath, &st);
 556         assert(ret == -1);
 557 }
 558
 559 /*
 560  * test4
 561  *
 562  * Start daemon, test termination via wait_send function
 563  */
 564
 565 struct test4_wait_state {
 566 };
 567
 568 static void test4_wait_done(struct tevent_req *subreq);
 569
 570 static struct tevent_req *test4_wait_send(TALLOC_CTX *mem_ctx,
 571                                           struct tevent_context *ev,
 572                                           void *private_data)
 573 {
 574         struct tevent_req *req, *subreq;
 575         struct test4_wait_state *state;
 576
 577         req = tevent_req_create(mem_ctx, &state, struct test4_wait_state);
 578         if (req == NULL) {
 579                 return NULL;
 580         }
 581
 582         subreq = tevent_wakeup_send(state, ev,
 583                                     tevent_timeval_current_ofs(10,0));
 584         if (tevent_req_nomem(subreq, req)) {
 585                 return tevent_req_post(req, ev);
 586         }
 587         tevent_req_set_callback(subreq, test4_wait_done, req);
 588
 589         return req;
 590 }
 591
 592 static void test4_wait_done(struct tevent_req *subreq)
 593 {
 594         struct tevent_req *req = tevent_req_callback_data(
 595                 subreq, struct tevent_req);
 596         bool status;
 597
 598         status = tevent_wakeup_recv(subreq);
 599         TALLOC_FREE(subreq);
 600
 601         if (! status) {
 602                 tevent_req_error(req, EIO);
 603         } else {
 604                 tevent_req_done(req);
 605         }
 606 }
 607
 608 static bool test4_wait_recv(struct tevent_req *req, int *perr)
 609 {
 610         int ret;
 611
 612         if (tevent_req_is_unix_error(req, &ret)) {
 613                 if (perr != NULL) {
 614                         *perr = ret;
 615                 }
 616                 return false;
 617         }
 618
 619         return true;
 620 }
 621
 622 static struct sock_daemon_funcs test4_funcs = {
 623         .wait_send = test4_wait_send,
 624         .wait_recv = test4_wait_recv,
 625 };
 626
 627 static void test4(TALLOC_CTX *mem_ctx, const char *pidfile,
 628                   const char *sockpath)
 629 {
 630         struct stat st;
 631         pid_t pid, pid2;
 632         int ret;
 633
 634         pid = fork();
 635         assert(pid != -1);
 636
 637         if (pid == 0) {
 638                 struct tevent_context *ev;
 639                 struct sock_daemon_context *sockd;
 640
 641                 ev = tevent_context_init(mem_ctx);
 642                 assert(ev != NULL);
 643
 644                 ret = sock_daemon_setup(mem_ctx, "test4", "file:", "NOTICE",
 645                                         &test4_funcs, NULL, &sockd);
 646                 assert(ret == 0);
 647
 648                 ret = sock_daemon_run(ev, sockd, pidfile, false, false, -1);
 649                 assert(ret == 0);
 650
 651                 exit(0);
 652         }
 653
 654         pid2 = waitpid(pid, &ret, 0);
 655         assert(pid2 == pid);
 656         assert(WEXITSTATUS(ret) == 0);
 657
 658         ret = stat(pidfile, &st);
 659         assert(ret == -1);
 660
 661         ret = stat(sockpath, &st);
 662         assert(ret == -1);
 663 }
 664
 665 /*
 666  * test5
 667  *
 668  * Start daemon, multiple client connects, requests, disconnects
 669  */
 670
 671 #define TEST5_MAX_CLIENTS       10
 672
 673 struct test5_pkt {
 674         uint32_t len;
 675         int data;
 676 };
 677
 678 struct test5_client_state {
 679         int id;
 680         int fd;
 681         bool done;
 682 };
 683
 684 static void test5_client_callback(uint8_t *buf, size_t buflen,
 685                                   void *private_data)
 686 {
 687         struct test5_client_state *state =
 688                 (struct test5_client_state *)private_data;
 689         struct test5_pkt *pkt;
 690         ssize_t n;
 691         int ret;
 692
 693         if (buf == NULL) {
 694                 assert(buflen == 0);
 695
 696                 ret = 0;
 697         } else {
 698                 assert(buflen == sizeof(struct test5_pkt));
 699                 pkt = (struct test5_pkt *)buf;
 700                 assert(pkt->len == sizeof(struct test5_pkt));
 701
 702                 ret = pkt->data;
 703         }
 704
 705         assert(state->fd != -1);
 706
 707         n = write(state->fd, (void *)&ret, sizeof(int));
 708         assert(n == sizeof(int));
 709
 710         state->done = true;
 711 }
 712
 713 static int test5_client(const char *sockpath, int id)
 714 {
 715         pid_t pid;
 716         int fd[2];
 717         int ret;
 718         ssize_t n;
 719
 720         ret = pipe(fd);
 721         assert(ret == 0);
 722
 723         pid = fork();
 724         assert(pid != -1);
 725
 726         if (pid == 0) {
 727                 struct tevent_context *ev;
 728                 struct test5_client_state state;
 729                 struct sock_queue *queue;
 730                 struct test5_pkt pkt;
 731                 int conn;
 732
 733                 close(fd[0]);
 734
 735                 ev = tevent_context_init(NULL);
 736                 assert(ev != NULL);
 737
 738                 conn = sock_connect(sockpath);
 739                 assert(conn != -1);
 740
 741                 state.id = id;
 742                 state.fd = fd[1];
 743                 state.done = false;
 744
 745                 queue = sock_queue_setup(ev, ev, conn,
 746                                          test5_client_callback, &state);
 747                 assert(queue != NULL);
 748
 749                 pkt.len = 8;
 750                 pkt.data = 0xbaba;
 751
 752                 ret = sock_queue_write(queue, (uint8_t *)&pkt,
 753                                        sizeof(struct test5_pkt));
 754                 assert(ret == 0);
 755
 756                 while (! state.done) {
 757                         tevent_loop_once(ev);
 758                 }
 759
 760                 close(fd[0]);
 761                 state.fd = -1;
 762
 763                 sleep(10);
 764                 exit(0);
 765         }
 766
 767         close(fd[1]);
 768
 769         ret = 0;
 770         n = read(fd[0], &ret, sizeof(ret));
 771         if (n == 0) {
 772                 fprintf(stderr, "client id %d read 0 bytes\n", id);
 773         }
 774         assert(n == 0 || n == sizeof(ret));
 775
 776         close(fd[0]);
 777
 778         return ret;
 779 }
 780
 781 struct test5_server_state {
 782         int num_clients;
 783 };
 784
 785 static bool test5_connect(struct sock_client_context *client,
 786                           void *private_data)
 787 {
 788         struct test5_server_state *state =
 789                 (struct test5_server_state *)private_data;
 790
 791         if (state->num_clients == TEST5_MAX_CLIENTS) {
 792                 return false;
 793         }
 794
 795         state->num_clients += 1;
 796         assert(state->num_clients <= TEST5_MAX_CLIENTS);
 797         return true;
 798 }
 799
 800 static void test5_disconnect(struct sock_client_context *client,
 801                              void *private_data)
 802 {
 803         struct test5_server_state *state =
 804                 (struct test5_server_state *)private_data;
 805
 806         state->num_clients -= 1;
 807         assert(state->num_clients >= 0);
 808 }
 809
 810 struct test5_read_state {
 811         struct test5_pkt reply;
 812 };
 813
 814 static void test5_read_done(struct tevent_req *subreq);
 815
 816 static struct tevent_req *test5_read_send(TALLOC_CTX *mem_ctx,
 817                                           struct tevent_context *ev,
 818                                           struct sock_client_context *client,
 819                                           uint8_t *buf, size_t buflen,
 820                                           void *private_data)
 821 {
 822         struct test5_server_state *server_state =
 823                 (struct test5_server_state *)private_data;
 824         struct tevent_req *req, *subreq;
 825         struct test5_read_state *state;
 826         struct test5_pkt *pkt;
 827
 828         req = tevent_req_create(mem_ctx, &state, struct test5_read_state);
 829         assert(req != NULL);
 830
 831         assert(buflen == sizeof(struct test5_pkt));
 832
 833         pkt = (struct test5_pkt *)buf;
 834         assert(pkt->data == 0xbaba);
 835
 836         state->reply.len = sizeof(struct test5_pkt);
 837         state->reply.data = server_state->num_clients;
 838
 839         subreq = sock_socket_write_send(state, ev, client,
 840                                         (uint8_t *)&state->reply,
 841                                         state->reply.len);
 842         assert(subreq != NULL);
 843
 844         tevent_req_set_callback(subreq, test5_read_done, req);
 845
 846         return req;
 847 }
 848
 849 static void test5_read_done(struct tevent_req *subreq)
 850 {
 851         struct tevent_req *req = tevent_req_callback_data(
 852                 subreq, struct tevent_req);
 853         int ret;
 854         bool status;
 855
 856         status = sock_socket_write_recv(subreq, &ret);
 857         TALLOC_FREE(subreq);
 858         if (! status) {
 859                 tevent_req_error(req, ret);
 860                 return;
 861         }
 862
 863         tevent_req_done(req);
 864 }
 865
 866 static bool test5_read_recv(struct tevent_req *req, int *perr)
 867 {
 868         int ret;
 869
 870         if (tevent_req_is_unix_error(req, &ret)) {
 871                 if (perr != NULL) {
 872                         *perr = ret;
 873                 }
 874                 return false;
 875         }
 876
 877         return true;
 878 }
 879
 880 static struct sock_socket_funcs test5_client_funcs = {
 881         .connect = test5_connect,
 882         .disconnect = test5_disconnect,
 883         .read_send = test5_read_send,
 884         .read_recv = test5_read_recv,
 885 };
 886
 887 struct test5_wait_state {
 888 };
 889
 890 static struct tevent_req *test5_wait_send(TALLOC_CTX *mem_ctx,
 891                                           struct tevent_context *ev,
 892                                           void *private_data)
 893 {
 894         struct tevent_req *req;
 895         struct test5_wait_state *state;
 896         int fd = *(int *)private_data;
 897         int ret = 1;
 898         ssize_t nwritten;
 899
 900         nwritten = write(fd, &ret, sizeof(ret));
 901         assert(nwritten == sizeof(ret));
 902         close(fd);
 903
 904         req = tevent_req_create(mem_ctx, &state, struct test5_wait_state);
 905         if (req == NULL) {
 906                 return NULL;
 907         }
 908
 909         return req;
 910 }
 911
 912 static bool test5_wait_recv(struct tevent_req *req, int *perr)
 913 {
 914         return true;
 915 }
 916
 917 static struct sock_daemon_funcs test5_funcs = {
 918         .wait_send = test5_wait_send,
 919         .wait_recv = test5_wait_recv,
 920 };
 921
 922 static void test5(TALLOC_CTX *mem_ctx, const char *pidfile,
 923                   const char *sockpath)
 924 {
 925         pid_t pid_server, pid;
 926         int fd[2], ret, i;
 927         ssize_t n;
 928
 929         pid = getpid();
 930
 931         ret = pipe(fd);
 932         assert(ret == 0);
 933
 934         pid_server = fork();
 935         assert(pid_server != -1);
 936
 937         if (pid_server == 0) {
 938                 struct tevent_context *ev;
 939                 struct sock_daemon_context *sockd;
 940                 struct test5_server_state state;
 941
 942                 close(fd[0]);
 943
 944                 ev = tevent_context_init(mem_ctx);
 945                 assert(ev != NULL);
 946
 947                 ret = sock_daemon_setup(mem_ctx, "test5", "file:", "NOTICE",
 948                                         &test5_funcs, &fd[1], &sockd);
 949                 assert(ret == 0);
 950
 951                 state.num_clients = 0;
 952
 953                 ret = sock_daemon_add_unix(sockd, sockpath,
 954                                            &test5_client_funcs, &state);
 955                 assert(ret == 0);
 956
 957                 ret = sock_daemon_run(ev, sockd, pidfile, false, false, pid);
 958                 assert(ret == EINTR);
 959
 960                 exit(0);
 961         }
 962
 963         close(fd[1]);
 964
 965         n = read(fd[0], &ret, sizeof(ret));
 966         assert(n == sizeof(ret));
 967         assert(ret == 1);
 968
 969         close(fd[0]);
 970
 971         for (i=0; i<100; i++) {
 972                 ret = test5_client(sockpath, i);
 973                 if (i < TEST5_MAX_CLIENTS) {
 974                         assert(ret == i+1);
 975                 } else {
 976                         assert(ret == 0);
 977                 }
 978         }
 979
 980         for (i=0; i<100; i++) {
 981                 pid = wait(&ret);
 982                 assert(pid != -1);
 983         }
 984
 985         ret = kill(pid_server, SIGTERM);
 986         assert(ret == 0);
 987
 988         pid = waitpid(pid_server, &ret, 0);
 989         assert(pid == pid_server);
 990         assert(WEXITSTATUS(ret) == 0);
 991 }
 992
 993 /*
 994  * test6
 995  *
 996  * Start daemon, test client connects, requests, replies, disconnects
 997  */
 998
 999 struct test6_pkt {
1000         uint32_t len;
1001         uint32_t data;
1002 };
1003
1004 struct test6_client_state {
1005         bool done;
1006 };
1007
1008 static void test6_client_callback(uint8_t *buf, size_t buflen,
1009                                   void *private_data)
1010 {
1011         struct test6_client_state *state =
1012                 (struct test6_client_state *)private_data;
1013         struct test6_pkt *pkt;
1014
1015         assert(buflen == sizeof(struct test6_pkt));
1016         pkt = (struct test6_pkt *)buf;
1017         assert(pkt->len == sizeof(struct test6_pkt));
1018         assert(pkt->data == 0xffeeddcc);
1019
1020         state->done = true;
1021 }
1022
1023 static void test6_client(const char *sockpath)
1024 {
1025         struct tevent_context *ev;
1026         struct test6_client_state state;
1027         struct sock_queue *queue;
1028         struct test6_pkt pkt;
1029         int conn, ret;
1030
1031         ev = tevent_context_init(NULL);
1032         assert(ev != NULL);
1033
1034         conn = sock_connect(sockpath);
1035         assert(conn != -1);
1036
1037         state.done = false;
1038
1039         queue = sock_queue_setup(ev, ev, conn,
1040                                  test6_client_callback, &state);
1041         assert(queue != NULL);
1042
1043         pkt.len = 8;
1044         pkt.data = 0xaabbccdd;
1045
1046         ret = sock_queue_write(queue, (uint8_t *)&pkt,
1047                                sizeof(struct test6_pkt));
1048         assert(ret == 0);
1049
1050         while (! state.done) {
1051                 tevent_loop_once(ev);
1052         }
1053
1054         talloc_free(ev);
1055 }
1056
1057 struct test6_server_state {
1058         struct sock_daemon_context *sockd;
1059         int fd, done;
1060 };
1061
1062 struct test6_read_state {
1063         struct test6_server_state *server_state;
1064         struct test6_pkt reply;
1065 };
1066
1067 static void test6_read_done(struct tevent_req *subreq);
1068
1069 static struct tevent_req *test6_read_send(TALLOC_CTX *mem_ctx,
1070                                           struct tevent_context *ev,
1071                                           struct sock_client_context *client,
1072                                           uint8_t *buf, size_t buflen,
1073                                           void *private_data)
1074 {
1075         struct test6_server_state *server_state =
1076                 (struct test6_server_state *)private_data;
1077         struct tevent_req *req, *subreq;
1078         struct test6_read_state *state;
1079         struct test6_pkt *pkt;
1080
1081         req = tevent_req_create(mem_ctx, &state, struct test6_read_state);
1082         assert(req != NULL);
1083
1084         state->server_state = server_state;
1085
1086         assert(buflen == sizeof(struct test6_pkt));
1087
1088         pkt = (struct test6_pkt *)buf;
1089         assert(pkt->data == 0xaabbccdd);
1090
1091         state->reply.len = sizeof(struct test6_pkt);
1092         state->reply.data = 0xffeeddcc;
1093
1094         subreq = sock_socket_write_send(state, ev, client,
1095                                         (uint8_t *)&state->reply,
1096                                         state->reply.len);
1097         assert(subreq != NULL);
1098
1099         tevent_req_set_callback(subreq, test6_read_done, req);
1100
1101         return req;
1102 }
1103
1104 static void test6_read_done(struct tevent_req *subreq)
1105 {
1106         struct tevent_req *req = tevent_req_callback_data(
1107                 subreq, struct tevent_req);
1108         struct test6_read_state *state = tevent_req_data(
1109                 req, struct test6_read_state);
1110         int ret;
1111         bool status;
1112
1113         status = sock_socket_write_recv(subreq, &ret);
1114         TALLOC_FREE(subreq);
1115         if (! status) {
1116                 tevent_req_error(req, ret);
1117                 return;
1118         }
1119
1120         state->server_state->done = 1;
1121         tevent_req_done(req);
1122 }
1123
1124 static bool test6_read_recv(struct tevent_req *req, int *perr)
1125 {
1126         int ret;
1127
1128         if (tevent_req_is_unix_error(req, &ret)) {
1129                 if (perr != NULL) {
1130                         *perr = ret;
1131                 }
1132                 return false;
1133         }
1134
1135         return true;
1136 }
1137
1138 static struct sock_socket_funcs test6_client_funcs = {
1139         .read_send = test6_read_send,
1140         .read_recv = test6_read_recv,
1141 };
1142
1143 struct test6_wait_state {
1144         struct test6_server_state *server_state;
1145 };
1146
1147 static void test6_wait_done(struct tevent_req *subreq);
1148
1149 static struct tevent_req *test6_wait_send(TALLOC_CTX *mem_ctx,
1150                                           struct tevent_context *ev,
1151                                           void *private_data)
1152 {
1153         struct test6_server_state *server_state =
1154                 (struct test6_server_state *)private_data;
1155         struct tevent_req *req, *subreq;
1156         struct test6_wait_state *state;
1157         ssize_t nwritten;
1158         int ret = 1;
1159
1160         nwritten = write(server_state->fd, &ret, sizeof(ret));
1161         assert(nwritten == sizeof(ret));
1162         close(server_state->fd);
1163         server_state->fd = -1;
1164
1165         req = tevent_req_create(mem_ctx, &state, struct test6_wait_state);
1166         if (req == NULL) {
1167                 return NULL;
1168         }
1169
1170         state->server_state = (struct test6_server_state *)private_data;
1171
1172         subreq = tevent_wakeup_send(state, ev,
1173                                     tevent_timeval_current_ofs(10,0));
1174         if (tevent_req_nomem(subreq, req)) {
1175                 return tevent_req_post(req, ev);
1176         }
1177         tevent_req_set_callback(subreq, test6_wait_done, req);
1178
1179         return req;
1180 }
1181
1182 static void test6_wait_done(struct tevent_req *subreq)
1183 {
1184         struct tevent_req *req = tevent_req_callback_data(
1185                 subreq, struct tevent_req);
1186         struct test6_wait_state *state = tevent_req_data(
1187                 req, struct test6_wait_state);
1188         bool status;
1189
1190         status = tevent_wakeup_recv(subreq);
1191         TALLOC_FREE(subreq);
1192         if (! status) {
1193                 tevent_req_error(req, EIO);
1194                 return;
1195         }
1196
1197         if (state->server_state->done == 0) {
1198                 tevent_req_error(req, EIO);
1199                 return;
1200         }
1201
1202         tevent_req_done(req);
1203 }
1204
1205 static bool test6_wait_recv(struct tevent_req *req, int *perr)
1206 {
1207         int ret;
1208
1209         if (tevent_req_is_unix_error(req, &ret)) {
1210                 if (perr != NULL) {
1211                         *perr = ret;
1212                 }
1213                 return false;
1214         }
1215
1216         return true;
1217 }
1218
1219 static struct sock_daemon_funcs test6_funcs = {
1220         .wait_send = test6_wait_send,
1221         .wait_recv = test6_wait_recv,
1222 };
1223
1224 static void test6(TALLOC_CTX *mem_ctx, const char *pidfile,
1225                   const char *sockpath)
1226 {
1227         pid_t pid_server, pid;
1228         int fd[2], ret;
1229         ssize_t n;
1230
1231         pid = getpid();
1232
1233         ret = pipe(fd);
1234         assert(ret == 0);
1235
1236         pid_server = fork();
1237         assert(pid_server != -1);
1238
1239         if (pid_server == 0) {
1240                 struct tevent_context *ev;
1241                 struct sock_daemon_context *sockd;
1242                 struct test6_server_state server_state = { 0 };
1243
1244                 close(fd[0]);
1245
1246                 ev = tevent_context_init(mem_ctx);
1247                 assert(ev != NULL);
1248
1249                 server_state.fd = fd[1];
1250
1251                 ret = sock_daemon_setup(mem_ctx, "test6", "file:", "NOTICE",
1252                                         &test6_funcs, &server_state,
1253                                         &sockd);
1254                 assert(ret == 0);
1255
1256                 server_state.sockd = sockd;
1257                 server_state.done = 0;
1258
1259                 ret = sock_daemon_add_unix(sockd, sockpath,
1260                                            &test6_client_funcs, &server_state);
1261                 assert(ret == 0);
1262
1263                 ret = sock_daemon_run(ev, sockd, pidfile, false, false, pid);
1264                 assert(ret == 0);
1265
1266                 exit(0);
1267         }
1268
1269         close(fd[1]);
1270
1271         n = read(fd[0], &ret, sizeof(ret));
1272         assert(n == sizeof(ret));
1273         assert(ret == 1);
1274
1275         close(fd[0]);
1276
1277         test6_client(sockpath);
1278
1279         pid = waitpid(pid_server, &ret, 0);
1280         assert(pid == pid_server);
1281         assert(WEXITSTATUS(ret) == 0);
1282 }
1283
1284 /*
1285  * test7
1286  *
1287  * Start daemon twice, confirm PID file contention
1288  */
1289
1290 static void test7(TALLOC_CTX *mem_ctx, const char *pidfile,
1291                   const char *sockpath)
1292 {
1293         struct sock_daemon_funcs test7_funcs;
1294         struct stat st;
1295         int fd[2];
1296         pid_t pid, pid2;
1297         int ret;
1298         struct tevent_context *ev;
1299         struct sock_daemon_context *sockd;
1300         ssize_t n;
1301
1302         /* Reuse test2 funcs for the startup synchronisation */
1303         test7_funcs = (struct sock_daemon_funcs) {
1304                 .startup = test2_startup,
1305                 .reconfigure = test2_reconfigure,
1306                 .shutdown = test2_shutdown,
1307         };
1308
1309         ret = pipe(fd);
1310         assert(ret == 0);
1311
1312         pid = fork();
1313         assert(pid != -1);
1314
1315         if (pid == 0) {
1316                 close(fd[0]);
1317
1318                 ev = tevent_context_init(mem_ctx);
1319                 assert(ev != NULL);
1320
1321                 ret = sock_daemon_setup(mem_ctx, "test7", "file:", "NOTICE",
1322                                         &test7_funcs, &fd[1], &sockd);
1323                 assert(ret == 0);
1324
1325                 ret = sock_daemon_run(ev, sockd, pidfile, false, false, -1);
1326                 assert(ret == EINTR);
1327
1328                 exit(0);
1329         }
1330
1331         close(fd[1]);
1332
1333         n = read(fd[0], &ret, sizeof(ret));
1334         assert(n == sizeof(ret));
1335         assert(ret == 1);
1336
1337         ret = stat(pidfile, &st);
1338         assert(ret == 0);
1339         assert(S_ISREG(st.st_mode));
1340
1341         ev = tevent_context_init(mem_ctx);
1342         assert(ev != NULL);
1343
1344         ret = sock_daemon_setup(mem_ctx, "test7-parent", "file:", "NOTICE",
1345                                 &test7_funcs, &fd[1], &sockd);
1346         assert(ret == 0);
1347
1348         ret = sock_daemon_run(ev, sockd, pidfile, false, false, -1);
1349         assert(ret == EEXIST);
1350
1351         ret = kill(pid, SIGTERM);
1352         assert(ret == 0);
1353
1354         n = read(fd[0], &ret, sizeof(ret));
1355         assert(n == sizeof(ret));
1356         assert(ret == 3);
1357
1358         pid2 = waitpid(pid, &ret, 0);
1359         assert(pid2 == pid);
1360         assert(WEXITSTATUS(ret) == 0);
1361
1362         close(fd[0]);
1363 }
1364
1365 /*
1366  * test8
1367  *
1368  * Start daemon, confirm that create_session argument works as expected
1369  */
1370
1371 static void test8(TALLOC_CTX *mem_ctx, const char *pidfile,
1372                   const char *sockpath)
1373 {
1374         int fd[2];
1375         pid_t pid, pid2, sid;
1376         int ret;
1377         struct tevent_context *ev;
1378         struct sock_daemon_context *sockd;
1379         ssize_t n;
1380
1381         ret = pipe(fd);
1382         assert(ret == 0);
1383
1384         pid = fork();
1385         assert(pid != -1);
1386
1387         if (pid == 0) {
1388                 /* Reuse test2 funcs for the startup synchronisation */
1389                 struct sock_daemon_funcs test8_funcs = {
1390                         .startup = test2_startup,
1391                 };
1392
1393                 close(fd[0]);
1394
1395                 ev = tevent_context_init(mem_ctx);
1396                 assert(ev != NULL);
1397
1398                 ret = sock_daemon_setup(mem_ctx, "test8", "file:", "NOTICE",
1399                                         &test8_funcs, &fd[1], &sockd);
1400                 assert(ret == 0);
1401
1402                 ret = sock_daemon_run(ev, sockd, pidfile, false, false, -1);
1403                 assert(ret == EINTR);
1404
1405                 exit(0);
1406         }
1407
1408         close(fd[1]);
1409
1410         n = read(fd[0], &ret, sizeof(ret));
1411         assert(n == sizeof(ret));
1412         assert(ret == 1);
1413
1414         /* create_session false above, so pid != sid */
1415         sid = getsid(pid);
1416         assert(pid != sid);
1417
1418         ret = kill(pid, SIGTERM);
1419         assert(ret == 0);
1420
1421         pid2 = waitpid(pid, &ret, 0);
1422         assert(pid2 == pid);
1423         assert(WEXITSTATUS(ret) == 0);
1424
1425         close(fd[0]);
1426
1427         ret = pipe(fd);
1428         assert(ret == 0);
1429
1430         pid = fork();
1431         assert(pid != -1);
1432
1433         if (pid == 0) {
1434                 /* Reuse test2 funcs for the startup synchronisation */
1435                 struct sock_daemon_funcs test8_funcs = {
1436                         .startup = test2_startup,
1437                 };
1438
1439                 close(fd[0]);
1440
1441                 ev = tevent_context_init(mem_ctx);
1442                 assert(ev != NULL);
1443
1444                 ret = sock_daemon_setup(mem_ctx, "test8", "file:", "NOTICE",
1445                                         &test8_funcs, &fd[1], &sockd);
1446                 assert(ret == 0);
1447
1448                 ret = sock_daemon_run(ev, sockd, pidfile, false, true, -1);
1449                 assert(ret == EINTR);
1450
1451                 exit(0);
1452         }
1453
1454         close(fd[1]);
1455
1456         n = read(fd[0], &ret, sizeof(ret));
1457         assert(n == sizeof(ret));
1458         assert(ret == 1);
1459
1460         /* create_session true above, so pid == sid */
1461         sid = getsid(pid);
1462         assert(pid == sid);
1463
1464         ret = kill(pid, SIGTERM);
1465         assert(ret == 0);
1466
1467         pid2 = waitpid(pid, &ret, 0);
1468         assert(pid2 == pid);
1469         assert(WEXITSTATUS(ret) == 0);
1470
1471         close(fd[0]);
1472 }
1473
1474 /*
1475  * test9
1476  *
1477  * Confirm that do_fork causes the daemon to be forked as a separate child
1478  */
1479
1480 static void test9(TALLOC_CTX *mem_ctx, const char *pidfile,
1481                   const char *sockpath)
1482 {
1483         int fd[2];
1484         pid_t pid, pid2;
1485         int ret;
1486         struct tevent_context *ev;
1487         struct sock_daemon_context *sockd;
1488         ssize_t n;
1489         int pidfile_fd;
1490         char pidstr[20] = { 0 };
1491         struct stat st;
1492
1493         ret = pipe(fd);
1494         assert(ret == 0);
1495
1496         pid = fork();
1497         assert(pid != -1);
1498
1499         if (pid == 0) {
1500                 /* Reuse test2 funcs for the startup synchronisation */
1501                 struct sock_daemon_funcs test9_funcs = {
1502                         .startup = test2_startup,
1503                 };
1504
1505                 close(fd[0]);
1506
1507                 ev = tevent_context_init(mem_ctx);
1508                 assert(ev != NULL);
1509
1510                 ret = sock_daemon_setup(mem_ctx, "test9", "file:", "NOTICE",
1511                                         &test9_funcs, &fd[1], &sockd);
1512                 assert(ret == 0);
1513
1514                 ret = sock_daemon_run(ev, sockd, pidfile, false, false, -1);
1515                 assert(ret == EINTR);
1516
1517                 exit(0);
1518         }
1519
1520         close(fd[1]);
1521
1522         n = read(fd[0], &ret, sizeof(ret));
1523         assert(n == sizeof(ret));
1524         assert(ret == 1);
1525
1526         /* do_fork false above, so pid should be active */
1527         ret = kill(pid, 0);
1528         assert(ret == 0);
1529
1530         ret = kill(pid, SIGTERM);
1531         assert(ret == 0);
1532
1533         pid2 = waitpid(pid, &ret, 0);
1534         assert(pid2 == pid);
1535         assert(WEXITSTATUS(ret) == 0);
1536
1537         close(fd[0]);
1538
1539         ret = pipe(fd);
1540         assert(ret == 0);
1541
1542         pid = fork();
1543         assert(pid != -1);
1544
1545         if (pid == 0) {
1546                 /* Reuse test2 funcs for the startup synchronisation */
1547                 struct sock_daemon_funcs test9_funcs = {
1548                         .startup = test2_startup,
1549                         .shutdown = test2_shutdown,
1550                 };
1551
1552                 close(fd[0]);
1553
1554                 ev = tevent_context_init(mem_ctx);
1555                 assert(ev != NULL);
1556
1557                 ret = sock_daemon_setup(mem_ctx, "test9", "file:", "NOTICE",
1558                                         &test9_funcs, &fd[1], &sockd);
1559                 assert(ret == 0);
1560
1561                 ret = sock_daemon_run(ev, sockd, pidfile, true, false, -1);
1562                 assert(ret == EINTR);
1563
1564                 exit(0);
1565         }
1566
1567         close(fd[1]);
1568
1569         n = read(fd[0], &ret, sizeof(ret));
1570         assert(n == sizeof(ret));
1571         assert(ret == 1);
1572
1573         /* do_fork true above, so pid should have exited */
1574         pid2 = waitpid(pid, &ret, 0);
1575         assert(pid2 == pid);
1576         assert(WEXITSTATUS(ret) == 0);
1577
1578         pidfile_fd = open(pidfile, O_RDONLY, 0644);
1579         assert(pidfile_fd != -1);
1580         n = read(pidfile_fd, pidstr, sizeof(pidstr)-1);
1581         assert(n != -1);
1582         pid2 = (pid_t)atoi(pidstr);
1583         assert(pid != pid2);
1584         close(pidfile_fd);
1585
1586         ret = kill(pid2, SIGTERM);
1587         assert(ret == 0);
1588
1589         n = read(fd[0], &ret, sizeof(ret));
1590         assert(n == sizeof(ret));
1591         assert(ret == 3);
1592
1593         /*
1594          * pid2 isn't our child, so can't call waitpid().  kill(pid2, 0)
1595          * is unreliable - pid2 may have been recycled.  Above indicates
1596          * that the shutdown function was called, so just do 1 final
1597          * check to see if pidfile has been removed.
1598          */
1599         ret = stat(sockpath, &st);
1600         assert(ret == -1);
1601
1602         close(fd[0]);
1603 }
1604
1605 static void test10_shutdown(void *private_data)
1606 {
1607         int fd = *(int *)private_data;
1608         int ret = 3;
1609         ssize_t nwritten;
1610
1611         nwritten = write(fd, &ret, sizeof(ret));
1612         assert(nwritten == sizeof(ret));
1613 }
1614
1615 struct test10_wait_state {
1616 };
1617
1618 static void test10_wait_done(struct tevent_req *subreq);
1619
1620 static struct tevent_req *test10_wait_send(TALLOC_CTX *mem_ctx,
1621                                            struct tevent_context *ev,
1622                                            void *private_data)
1623 {
1624         int fd = *(int *)private_data;
1625         struct tevent_req *req, *subreq;
1626         struct test10_wait_state *state;
1627         size_t nwritten;
1628         int ret = 1;
1629
1630         req = tevent_req_create(mem_ctx, &state, struct test10_wait_state);
1631         if (req == NULL) {
1632                 return NULL;
1633         }
1634
1635         subreq = tevent_wakeup_send(state, ev,
1636                                     tevent_timeval_current_ofs(10, 0));
1637         if (tevent_req_nomem(subreq, req)) {
1638                 return tevent_req_post(req, ev);
1639         }
1640         tevent_req_set_callback(subreq, test10_wait_done, req);
1641
1642         nwritten = write(fd, &ret, sizeof(ret));
1643         assert(nwritten == sizeof(ret));
1644
1645         return req;
1646 }
1647
1648 static void test10_wait_done(struct tevent_req *subreq)
1649 {
1650         struct tevent_req *req = tevent_req_callback_data(
1651                 subreq, struct tevent_req);
1652         bool status;
1653
1654         status = tevent_wakeup_recv(subreq);
1655         if (! status) {
1656                 tevent_req_error(req, EIO);
1657                 return;
1658         }
1659
1660         tevent_req_done(req);
1661 }
1662
1663 static bool test10_wait_recv(struct tevent_req *req, int *perr)
1664 {
1665         int ret;
1666
1667         if (tevent_req_is_unix_error(req, &ret)) {
1668                 if (perr != NULL) {
1669                         *perr = ret;
1670                 }
1671                 return false;
1672         }
1673
1674         return true;
1675 }
1676
1677 static struct sock_daemon_funcs test10_funcs = {
1678         .shutdown = test10_shutdown,
1679         .wait_send = test10_wait_send,
1680         .wait_recv = test10_wait_recv,
1681 };
1682
1683 /*
1684  * test10
1685  *
1686  * Confirm that the daemon starts successfully if there is a stale socket
1687  */
1688
1689 static void test10(TALLOC_CTX *mem_ctx, const char *pidfile,
1690                   const char *sockpath)
1691 {
1692         struct stat st;
1693         int fd[2];
1694         pid_t pid, pid2;
1695         int ret;
1696         ssize_t n;
1697         int pidfile_fd;
1698         char pidstr[20] = { 0 };
1699
1700         ret = pipe(fd);
1701         assert(ret == 0);
1702
1703         pid = fork();
1704         assert(pid != -1);
1705
1706         if (pid == 0) {
1707                 struct tevent_context *ev;
1708                 struct sock_daemon_context *sockd;
1709
1710                 close(fd[0]);
1711
1712                 ev = tevent_context_init(mem_ctx);
1713                 assert(ev != NULL);
1714
1715                 ret = sock_daemon_setup(mem_ctx, "test10", "file:", "NOTICE",
1716                                         &test10_funcs, &fd[1], &sockd);
1717                 assert(ret == 0);
1718
1719                 ret = sock_daemon_add_unix(sockd, sockpath,
1720                                            &dummy_socket_funcs, NULL);
1721                 assert(ret == 0);
1722
1723                 ret = sock_daemon_run(ev, sockd, pidfile, false, false, -1);
1724                 assert(ret == EINTR);
1725
1726                 exit(0);
1727         }
1728
1729         close(fd[1]);
1730
1731         n = read(fd[0], &ret, sizeof(ret));
1732         assert(n == sizeof(ret));
1733         assert(ret == 1);
1734
1735         /* KILL will leave PID file and socket behind */
1736         ret = kill (pid, SIGKILL);
1737         assert(ret == 0);
1738
1739         pid2 = waitpid(pid, &ret, 0);
1740         assert(pid2 == pid);
1741         assert(WEXITSTATUS(ret) == 0);
1742
1743         ret = stat(sockpath, &st);
1744         assert(ret == 0);
1745
1746         close(fd[0]);
1747
1748         ret = pipe(fd);
1749         assert(ret == 0);
1750
1751         pid = fork();
1752         assert(pid != -1);
1753
1754         if (pid == 0) {
1755                 struct tevent_context *ev;
1756                 struct sock_daemon_context *sockd;
1757
1758                 close(fd[0]);
1759
1760                 ev = tevent_context_init(mem_ctx);
1761                 assert(ev != NULL);
1762
1763                 ret = sock_daemon_setup(mem_ctx, "test10", "file:", "NOTICE",
1764                                         &test10_funcs, &fd[1], &sockd);
1765                 assert(ret == 0);
1766
1767                 ret = sock_daemon_add_unix(sockd, sockpath,
1768                                            &dummy_socket_funcs, NULL);
1769                 assert(ret == 0);
1770
1771                 ret = sock_daemon_run(ev, sockd, pidfile, false, false, -1);
1772                 assert(ret == EINTR);
1773
1774                 exit(0);
1775         }
1776
1777         close(fd[1]);
1778
1779         n = read(fd[0], &ret, sizeof(ret));
1780         assert(n == sizeof(ret));
1781         assert(ret == 1);
1782
1783         pidfile_fd = open(pidfile, O_RDONLY, 0644);
1784         assert(pidfile_fd != -1);
1785         n = read(pidfile_fd, pidstr, sizeof(pidstr)-1);
1786         assert(n != -1);
1787         pid2 = (pid_t)atoi(pidstr);
1788         assert(pid == pid2);
1789         close(pidfile_fd);
1790
1791         ret = kill(pid, SIGTERM);
1792         assert(ret == 0);
1793
1794         n = read(fd[0], &ret, sizeof(ret));
1795         assert(n == sizeof(ret));
1796         assert(ret == 3);
1797
1798         pid2 = waitpid(pid, &ret, 0);
1799         assert(pid2 == pid);
1800         assert(WEXITSTATUS(ret) == 0);
1801
1802         close(fd[0]);
1803
1804         ret = stat(pidfile, &st);
1805         assert(ret == -1);
1806
1807         ret = stat(sockpath, &st);
1808         assert(ret == -1);
1809 }
1810
1811 int main(int argc, const char **argv)
1812 {
1813         TALLOC_CTX *mem_ctx;
1814         const char *pidfile, *sockpath;
1815         int num;
1816
1817         if (argc != 4) {
1818                 fprintf(stderr, "%s <pidfile> <sockpath> <testnum>\n", argv[0]);
1819                 exit(1);
1820         }
1821
1822         pidfile = argv[1];
1823         sockpath = argv[2];
1824         num = atoi(argv[3]);
1825
1826         mem_ctx = talloc_new(NULL);
1827         assert(mem_ctx != NULL);
1828
1829         switch (num) {
1830         case 1:
1831                 test1(mem_ctx, pidfile, sockpath);
1832                 break;
1833
1834         case 2:
1835                 test2(mem_ctx, pidfile, sockpath);
1836                 break;
1837
1838         case 3:
1839                 test3(mem_ctx, pidfile, sockpath);
1840                 break;
1841
1842         case 4:
1843                 test4(mem_ctx, pidfile, sockpath);
1844                 break;
1845
1846         case 5:
1847                 test5(mem_ctx, pidfile, sockpath);
1848                 break;
1849
1850         case 6:
1851                 test6(mem_ctx, pidfile, sockpath);
1852                 break;
1853
1854         case 7:
1855                 test7(mem_ctx, pidfile, sockpath);
1856                 break;
1857
1858         case 8:
1859                 test8(mem_ctx, pidfile, sockpath);
1860                 break;
1861
1862         case 9:
1863                 test9(mem_ctx, pidfile, sockpath);
1864                 break;
1865
1866         case 10:
1867                 test10(mem_ctx, pidfile, sockpath);
1868                 break;
1869
1870         default:
1871                 fprintf(stderr, "Unknown test number %d\n", num);
1872         }
1873
1874         return 0;
1875 }