source/winbindd/winbindd_dual.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3
   4    Winbind child daemons
   5
   6    Copyright (C) Andrew Tridgell 2002
   7    Copyright (C) Volker Lendecke 2004,2005
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  21 */
  22
  23 /*
  24  * We fork a child per domain to be able to act non-blocking in the main
  25  * winbind daemon. A domain controller thousands of miles away being being
  26  * slow replying with a 10.000 user list should not hold up netlogon calls
  27  * that can be handled locally.
  28  */
  29
  30 #include "includes.h"
  31 #include "winbindd.h"
  32
  33 #undef DBGC_CLASS
  34 #define DBGC_CLASS DBGC_WINBIND
  35
  36 extern bool override_logfile;
  37 extern struct winbindd_methods cache_methods;
  38
  39 /* Read some data from a client connection */
  40
  41 static void child_read_request(struct winbindd_cli_state *state)
  42 {
  43         NTSTATUS status;
  44
  45         /* Read data */
  46
  47         status = read_data(state->sock, (char *)&state->request,
  48                            sizeof(state->request));
  49
  50         if (!NT_STATUS_IS_OK(status)) {
  51                 DEBUG(3, ("child_read_request: read_data failed: %s\n",
  52                           nt_errstr(status)));
  53                 state->finished = True;
  54                 return;
  55         }
  56
  57         if (state->request.extra_len == 0) {
  58                 state->request.extra_data.data = NULL;
  59                 return;
  60         }
  61
  62         DEBUG(10, ("Need to read %d extra bytes\n", (int)state->request.extra_len));
  63
  64         state->request.extra_data.data =
  65                 SMB_MALLOC_ARRAY(char, state->request.extra_len + 1);
  66
  67         if (state->request.extra_data.data == NULL) {
  68                 DEBUG(0, ("malloc failed\n"));
  69                 state->finished = True;
  70                 return;
  71         }
  72
  73         /* Ensure null termination */
  74         state->request.extra_data.data[state->request.extra_len] = '\0';
  75
  76         status= read_data(state->sock, state->request.extra_data.data,
  77                           state->request.extra_len);
  78
  79         if (!NT_STATUS_IS_OK(status)) {
  80                 DEBUG(0, ("Could not read extra data: %s\n",
  81                           nt_errstr(status)));
  82                 state->finished = True;
  83                 return;
  84         }
  85 }
  86
  87 /*
  88  * Machinery for async requests sent to children. You set up a
  89  * winbindd_request, select a child to query, and issue a async_request
  90  * call. When the request is completed, the callback function you specified is
  91  * called back with the private pointer you gave to async_request.
  92  */
  93
  94 struct winbindd_async_request {
  95         struct winbindd_async_request *next, *prev;
  96         TALLOC_CTX *mem_ctx;
  97         struct winbindd_child *child;
  98         struct winbindd_request *request;
  99         struct winbindd_response *response;
 100         void (*continuation)(void *private_data, bool success);
 101         struct timed_event *reply_timeout_event;
 102         pid_t child_pid; /* pid of the child we're waiting on. Used to detect
 103                             a restart of the child (child->pid != child_pid). */
 104         void *private_data;
 105 };
 106
 107 static void async_main_request_sent(void *private_data, bool success);
 108 static void async_request_sent(void *private_data, bool success);
 109 static void async_reply_recv(void *private_data, bool success);
 110 static void schedule_async_request(struct winbindd_child *child);
 111
 112 void async_request(TALLOC_CTX *mem_ctx, struct winbindd_child *child,
 113                    struct winbindd_request *request,
 114                    struct winbindd_response *response,
 115                    void (*continuation)(void *private_data, bool success),
 116                    void *private_data)
 117 {
 118         struct winbindd_async_request *state;
 119
 120         SMB_ASSERT(continuation != NULL);
 121
 122         state = TALLOC_P(mem_ctx, struct winbindd_async_request);
 123
 124         if (state == NULL) {
 125                 DEBUG(0, ("talloc failed\n"));
 126                 continuation(private_data, False);
 127                 return;
 128         }
 129
 130         state->mem_ctx = mem_ctx;
 131         state->child = child;
 132         state->request = request;
 133         state->response = response;
 134         state->continuation = continuation;
 135         state->private_data = private_data;
 136
 137         DLIST_ADD_END(child->requests, state, struct winbindd_async_request *);
 138
 139         schedule_async_request(child);
 140
 141         return;
 142 }
 143
 144 static void async_main_request_sent(void *private_data, bool success)
 145 {
 146         struct winbindd_async_request *state =
 147                 talloc_get_type_abort(private_data, struct winbindd_async_request);
 148
 149         if (!success) {
 150                 DEBUG(5, ("Could not send async request\n"));
 151
 152                 state->response->length = sizeof(struct winbindd_response);
 153                 state->response->result = WINBINDD_ERROR;
 154                 state->continuation(state->private_data, False);
 155                 return;
 156         }
 157
 158         if (state->request->extra_len == 0) {
 159                 async_request_sent(private_data, True);
 160                 return;
 161         }
 162
 163         setup_async_write(&state->child->event, state->request->extra_data.data,
 164                           state->request->extra_len,
 165                           async_request_sent, state);
 166 }
 167
 168 /****************************************************************
 169  Handler triggered if the child winbindd doesn't respond within
 170  a given timeout.
 171 ****************************************************************/
 172
 173 static void async_request_timeout_handler(struct event_context *ctx,
 174                                         struct timed_event *te,
 175                                         const struct timeval *now,
 176                                         void *private_data)
 177 {
 178         struct winbindd_async_request *state =
 179                 talloc_get_type_abort(private_data, struct winbindd_async_request);
 180
 181         DEBUG(0,("async_request_timeout_handler: child pid %u is not responding. "
 182                 "Closing connection to it.\n",
 183                 state->child_pid ));
 184
 185         /* Deal with the reply - set to error. */
 186         async_reply_recv(private_data, False);
 187 }
 188
 189 /**************************************************************
 190  Common function called on both async send and recv fail.
 191  Cleans up the child and schedules the next request.
 192 **************************************************************/
 193
 194 static void async_request_fail(struct winbindd_async_request *state)
 195 {
 196         DLIST_REMOVE(state->child->requests, state);
 197
 198         TALLOC_FREE(state->reply_timeout_event);
 199
 200         SMB_ASSERT(state->child_pid != (pid_t)0);
 201
 202         /* If not already reaped, send kill signal to child. */
 203         if (state->child->pid == state->child_pid) {
 204                 kill(state->child_pid, SIGTERM);
 205
 206                 /*
 207                  * Close the socket to the child.
 208                  */
 209                 winbind_child_died(state->child_pid);
 210         }
 211
 212         state->response->length = sizeof(struct winbindd_response);
 213         state->response->result = WINBINDD_ERROR;
 214         state->continuation(state->private_data, False);
 215 }
 216
 217 static void async_request_sent(void *private_data_data, bool success)
 218 {
 219         struct winbindd_async_request *state =
 220                 talloc_get_type_abort(private_data_data, struct winbindd_async_request);
 221
 222         if (!success) {
 223                 DEBUG(5, ("Could not send async request to child pid %u\n",
 224                         (unsigned int)state->child_pid ));
 225                 async_request_fail(state);
 226                 return;
 227         }
 228
 229         /* Request successfully sent to the child, setup the wait for reply */
 230
 231         setup_async_read(&state->child->event,
 232                          &state->response->result,
 233                          sizeof(state->response->result),
 234                          async_reply_recv, state);
 235
 236         /*
 237          * Set up a timeout of 300 seconds for the response.
 238          * If we don't get it close the child socket and
 239          * report failure.
 240          */
 241
 242         state->reply_timeout_event = event_add_timed(winbind_event_context(),
 243                                                         NULL,
 244                                                         timeval_current_ofs(300,0),
 245                                                         "async_request_timeout",
 246                                                         async_request_timeout_handler,
 247                                                         state);
 248         if (!state->reply_timeout_event) {
 249                 smb_panic("async_request_sent: failed to add timeout handler.\n");
 250         }
 251 }
 252
 253 static void async_reply_recv(void *private_data, bool success)
 254 {
 255         struct winbindd_async_request *state =
 256                 talloc_get_type_abort(private_data, struct winbindd_async_request);
 257         struct winbindd_child *child = state->child;
 258
 259         TALLOC_FREE(state->reply_timeout_event);
 260
 261         state->response->length = sizeof(struct winbindd_response);
 262
 263         if (!success) {
 264                 DEBUG(5, ("Could not receive async reply from child pid %u\n",
 265                         (unsigned int)state->child_pid ));
 266
 267                 cache_cleanup_response(state->child_pid);
 268                 async_request_fail(state);
 269                 return;
 270         }
 271
 272         SMB_ASSERT(cache_retrieve_response(state->child_pid,
 273                                            state->response));
 274
 275         cache_cleanup_response(state->child_pid);
 276
 277         DLIST_REMOVE(child->requests, state);
 278
 279         schedule_async_request(child);
 280
 281         state->continuation(state->private_data, True);
 282 }
 283
 284 static bool fork_domain_child(struct winbindd_child *child);
 285
 286 static void schedule_async_request(struct winbindd_child *child)
 287 {
 288         struct winbindd_async_request *request = child->requests;
 289
 290         if (request == NULL) {
 291                 return;
 292         }
 293
 294         if (child->event.flags != 0) {
 295                 return;         /* Busy */
 296         }
 297
 298         if ((child->pid == 0) && (!fork_domain_child(child))) {
 299                 /* Cancel all outstanding requests */
 300
 301                 while (request != NULL) {
 302                         /* request might be free'd in the continuation */
 303                         struct winbindd_async_request *next = request->next;
 304                         request->continuation(request->private_data, False);
 305                         request = next;
 306                 }
 307                 return;
 308         }
 309
 310         /* Now we know who we're sending to - remember the pid. */
 311         request->child_pid = child->pid;
 312
 313         setup_async_write(&child->event, request->request,
 314                           sizeof(*request->request),
 315                           async_main_request_sent, request);
 316
 317         return;
 318 }
 319
 320 struct domain_request_state {
 321         TALLOC_CTX *mem_ctx;
 322         struct winbindd_domain *domain;
 323         struct winbindd_request *request;
 324         struct winbindd_response *response;
 325         void (*continuation)(void *private_data_data, bool success);
 326         void *private_data_data;
 327 };
 328
 329 static void domain_init_recv(void *private_data_data, bool success);
 330
 331 void async_domain_request(TALLOC_CTX *mem_ctx,
 332                           struct winbindd_domain *domain,
 333                           struct winbindd_request *request,
 334                           struct winbindd_response *response,
 335                           void (*continuation)(void *private_data_data, bool success),
 336                           void *private_data_data)
 337 {
 338         struct domain_request_state *state;
 339
 340         if (domain->initialized) {
 341                 async_request(mem_ctx, &domain->child, request, response,
 342                               continuation, private_data_data);
 343                 return;
 344         }
 345
 346         state = TALLOC_P(mem_ctx, struct domain_request_state);
 347         if (state == NULL) {
 348                 DEBUG(0, ("talloc failed\n"));
 349                 continuation(private_data_data, False);
 350                 return;
 351         }
 352
 353         state->mem_ctx = mem_ctx;
 354         state->domain = domain;
 355         state->request = request;
 356         state->response = response;
 357         state->continuation = continuation;
 358         state->private_data_data = private_data_data;
 359
 360         init_child_connection(domain, domain_init_recv, state);
 361 }
 362
 363 static void domain_init_recv(void *private_data_data, bool success)
 364 {
 365         struct domain_request_state *state =
 366                 talloc_get_type_abort(private_data_data, struct domain_request_state);
 367
 368         if (!success) {
 369                 DEBUG(5, ("Domain init returned an error\n"));
 370                 state->continuation(state->private_data_data, False);
 371                 return;
 372         }
 373
 374         async_request(state->mem_ctx, &state->domain->child,
 375                       state->request, state->response,
 376                       state->continuation, state->private_data_data);
 377 }
 378
 379 static void recvfrom_child(void *private_data_data, bool success)
 380 {
 381         struct winbindd_cli_state *state =
 382                 talloc_get_type_abort(private_data_data, struct winbindd_cli_state);
 383         enum winbindd_result result = state->response.result;
 384
 385         /* This is an optimization: The child has written directly to the
 386          * response buffer. The request itself is still in pending state,
 387          * state that in the result code. */
 388
 389         state->response.result = WINBINDD_PENDING;
 390
 391         if ((!success) || (result != WINBINDD_OK)) {
 392                 request_error(state);
 393                 return;
 394         }
 395
 396         request_ok(state);
 397 }
 398
 399 void sendto_child(struct winbindd_cli_state *state,
 400                   struct winbindd_child *child)
 401 {
 402         async_request(state->mem_ctx, child, &state->request,
 403                       &state->response, recvfrom_child, state);
 404 }
 405
 406 void sendto_domain(struct winbindd_cli_state *state,
 407                    struct winbindd_domain *domain)
 408 {
 409         async_domain_request(state->mem_ctx, domain,
 410                              &state->request, &state->response,
 411                              recvfrom_child, state);
 412 }
 413
 414 static void child_process_request(struct winbindd_child *child,
 415                                   struct winbindd_cli_state *state)
 416 {
 417         struct winbindd_domain *domain = child->domain;
 418         const struct winbindd_child_dispatch_table *table = child->table;
 419
 420         /* Free response data - we may be interrupted and receive another
 421            command before being able to send this data off. */
 422
 423         state->response.result = WINBINDD_ERROR;
 424         state->response.length = sizeof(struct winbindd_response);
 425
 426         /* as all requests in the child are sync, we can use talloc_tos() */
 427         state->mem_ctx = talloc_tos();
 428
 429         /* Process command */
 430
 431         for (; table->name; table++) {
 432                 if (state->request.cmd == table->struct_cmd) {
 433                         DEBUG(10,("child_process_request: request fn %s\n",
 434                                   table->name));
 435                         state->response.result = table->struct_fn(domain, state);
 436                         return;
 437                 }
 438         }
 439
 440         DEBUG(1 ,("child_process_request: unknown request fn number %d\n",
 441                   (int)state->request.cmd));
 442         state->response.result = WINBINDD_ERROR;
 443 }
 444
 445 void setup_child(struct winbindd_child *child,
 446                  const struct winbindd_child_dispatch_table *table,
 447                  const char *logprefix,
 448                  const char *logname)
 449 {
 450         if (logprefix && logname) {
 451                 if (asprintf(&child->logfilename, "%s/%s-%s",
 452                              get_dyn_LOGFILEBASE(), logprefix, logname) < 0) {
 453                         smb_panic("Internal error: asprintf failed");
 454                 }
 455         } else {
 456                 smb_panic("Internal error: logprefix == NULL && "
 457                           "logname == NULL");
 458         }
 459
 460         child->domain = NULL;
 461         child->table = table;
 462 }
 463
 464 struct winbindd_child *children = NULL;
 465
 466 void winbind_child_died(pid_t pid)
 467 {
 468         struct winbindd_child *child;
 469
 470         for (child = children; child != NULL; child = child->next) {
 471                 if (child->pid == pid) {
 472                         break;
 473                 }
 474         }
 475
 476         if (child == NULL) {
 477                 DEBUG(5, ("Already reaped child %u died\n", (unsigned int)pid));
 478                 return;
 479         }
 480
 481         remove_fd_event(&child->event);
 482         close(child->event.fd);
 483         child->event.fd = 0;
 484         child->event.flags = 0;
 485         child->pid = 0;
 486
 487         schedule_async_request(child);
 488 }
 489
 490 /* Ensure any negative cache entries with the netbios or realm names are removed. */
 491
 492 void winbindd_flush_negative_conn_cache(struct winbindd_domain *domain)
 493 {
 494         flush_negative_conn_cache_for_domain(domain->name);
 495         if (*domain->alt_name) {
 496                 flush_negative_conn_cache_for_domain(domain->alt_name);
 497         }
 498 }
 499
 500 /* Set our domains as offline and forward the offline message to our children. */
 501
 502 void winbind_msg_offline(struct messaging_context *msg_ctx,
 503                          void *private_data,
 504                          uint32_t msg_type,
 505                          struct server_id server_id,
 506                          DATA_BLOB *data)
 507 {
 508         struct winbindd_child *child;
 509         struct winbindd_domain *domain;
 510
 511         DEBUG(10,("winbind_msg_offline: got offline message.\n"));
 512
 513         if (!lp_winbind_offline_logon()) {
 514                 DEBUG(10,("winbind_msg_offline: rejecting offline message.\n"));
 515                 return;
 516         }
 517
 518         /* Set our global state as offline. */
 519         if (!set_global_winbindd_state_offline()) {
 520                 DEBUG(10,("winbind_msg_offline: offline request failed.\n"));
 521                 return;
 522         }
 523
 524         /* Set all our domains as offline. */
 525         for (domain = domain_list(); domain; domain = domain->next) {
 526                 if (domain->internal) {
 527                         continue;
 528                 }
 529                 DEBUG(5,("winbind_msg_offline: marking %s offline.\n", domain->name));
 530                 set_domain_offline(domain);
 531         }
 532
 533         for (child = children; child != NULL; child = child->next) {
 534                 /* Don't send message to internal childs.  We've already
 535                    done so above. */
 536                 if (!child->domain || winbindd_internal_child(child)) {
 537                         continue;
 538                 }
 539
 540                 /* Or internal domains (this should not be possible....) */
 541                 if (child->domain->internal) {
 542                         continue;
 543                 }
 544
 545                 /* Each winbindd child should only process requests for one domain - make sure
 546                    we only set it online / offline for that domain. */
 547
 548                 DEBUG(10,("winbind_msg_offline: sending message to pid %u for domain %s.\n",
 549                         (unsigned int)child->pid, domain->name ));
 550
 551                 messaging_send_buf(msg_ctx, pid_to_procid(child->pid),
 552                                    MSG_WINBIND_OFFLINE,
 553                                    (uint8 *)child->domain->name,
 554                                    strlen(child->domain->name)+1);
 555         }
 556 }
 557
 558 /* Set our domains as online and forward the online message to our children. */
 559
 560 void winbind_msg_online(struct messaging_context *msg_ctx,
 561                         void *private_data,
 562                         uint32_t msg_type,
 563                         struct server_id server_id,
 564                         DATA_BLOB *data)
 565 {
 566         struct winbindd_child *child;
 567         struct winbindd_domain *domain;
 568
 569         DEBUG(10,("winbind_msg_online: got online message.\n"));
 570
 571         if (!lp_winbind_offline_logon()) {
 572                 DEBUG(10,("winbind_msg_online: rejecting online message.\n"));
 573                 return;
 574         }
 575
 576         /* Set our global state as online. */
 577         set_global_winbindd_state_online();
 578
 579         smb_nscd_flush_user_cache();
 580         smb_nscd_flush_group_cache();
 581
 582         /* Set all our domains as online. */
 583         for (domain = domain_list(); domain; domain = domain->next) {
 584                 if (domain->internal) {
 585                         continue;
 586                 }
 587                 DEBUG(5,("winbind_msg_online: requesting %s to go online.\n", domain->name));
 588
 589                 winbindd_flush_negative_conn_cache(domain);
 590                 set_domain_online_request(domain);
 591
 592                 /* Send an online message to the idmap child when our
 593                    primary domain comes back online */
 594
 595                 if ( domain->primary ) {
 596                         struct winbindd_child *idmap = idmap_child();
 597
 598                         if ( idmap->pid != 0 ) {
 599                                 messaging_send_buf(msg_ctx,
 600                                                    pid_to_procid(idmap->pid),
 601                                                    MSG_WINBIND_ONLINE,
 602                                                    (uint8 *)domain->name,
 603                                                    strlen(domain->name)+1);
 604                         }
 605
 606                 }
 607         }
 608
 609         for (child = children; child != NULL; child = child->next) {
 610                 /* Don't send message to internal childs. */
 611                 if (!child->domain || winbindd_internal_child(child)) {
 612                         continue;
 613                 }
 614
 615                 /* Or internal domains (this should not be possible....) */
 616                 if (child->domain->internal) {
 617                         continue;
 618                 }
 619
 620                 /* Each winbindd child should only process requests for one domain - make sure
 621                    we only set it online / offline for that domain. */
 622
 623                 DEBUG(10,("winbind_msg_online: sending message to pid %u for domain %s.\n",
 624                         (unsigned int)child->pid, child->domain->name ));
 625
 626                 messaging_send_buf(msg_ctx, pid_to_procid(child->pid),
 627                                    MSG_WINBIND_ONLINE,
 628                                    (uint8 *)child->domain->name,
 629                                    strlen(child->domain->name)+1);
 630         }
 631 }
 632
 633 /* Forward the online/offline messages to our children. */
 634 void winbind_msg_onlinestatus(struct messaging_context *msg_ctx,
 635                               void *private_data,
 636                               uint32_t msg_type,
 637                               struct server_id server_id,
 638                               DATA_BLOB *data)
 639 {
 640         struct winbindd_child *child;
 641
 642         DEBUG(10,("winbind_msg_onlinestatus: got onlinestatus message.\n"));
 643
 644         for (child = children; child != NULL; child = child->next) {
 645                 if (child->domain && child->domain->primary) {
 646                         DEBUG(10,("winbind_msg_onlinestatus: "
 647                                   "sending message to pid %u of primary domain.\n",
 648                                   (unsigned int)child->pid));
 649                         messaging_send_buf(msg_ctx, pid_to_procid(child->pid),
 650                                            MSG_WINBIND_ONLINESTATUS,
 651                                            (uint8 *)data->data,
 652                                            data->length);
 653                         break;
 654                 }
 655         }
 656 }
 657
 658 void winbind_msg_dump_event_list(struct messaging_context *msg_ctx,
 659                                  void *private_data,
 660                                  uint32_t msg_type,
 661                                  struct server_id server_id,
 662                                  DATA_BLOB *data)
 663 {
 664         struct winbindd_child *child;
 665
 666         DEBUG(10,("winbind_msg_dump_event_list received\n"));
 667
 668         dump_event_list(winbind_event_context());
 669
 670         for (child = children; child != NULL; child = child->next) {
 671
 672                 DEBUG(10,("winbind_msg_dump_event_list: sending message to pid %u\n",
 673                         (unsigned int)child->pid));
 674
 675                 messaging_send_buf(msg_ctx, pid_to_procid(child->pid),
 676                                    MSG_DUMP_EVENT_LIST,
 677                                    NULL, 0);
 678         }
 679
 680 }
 681
 682 void winbind_msg_dump_domain_list(struct messaging_context *msg_ctx,
 683                                   void *private_data,
 684                                   uint32_t msg_type,
 685                                   struct server_id server_id,
 686                                   DATA_BLOB *data)
 687 {
 688         TALLOC_CTX *mem_ctx;
 689         const char *message = NULL;
 690         struct server_id *sender = NULL;
 691         const char *domain = NULL;
 692         char *s = NULL;
 693         NTSTATUS status;
 694         struct winbindd_domain *dom = NULL;
 695
 696         DEBUG(5,("winbind_msg_dump_domain_list received.\n"));
 697
 698         if (!data || !data->data) {
 699                 return;
 700         }
 701
 702         if (data->length < sizeof(struct server_id)) {
 703                 return;
 704         }
 705
 706         mem_ctx = talloc_init("winbind_msg_dump_domain_list");
 707         if (!mem_ctx) {
 708                 return;
 709         }
 710
 711         sender = (struct server_id *)data->data;
 712         if (data->length > sizeof(struct server_id)) {
 713                 domain = (const char *)data->data+sizeof(struct server_id);
 714         }
 715
 716         if (domain) {
 717
 718                 DEBUG(5,("winbind_msg_dump_domain_list for domain: %s\n",
 719                         domain));
 720
 721                 message = NDR_PRINT_STRUCT_STRING(mem_ctx, winbindd_domain,
 722                                                   find_domain_from_name_noinit(domain));
 723                 if (!message) {
 724                         talloc_destroy(mem_ctx);
 725                         return;
 726                 }
 727
 728                 messaging_send_buf(msg_ctx, *sender,
 729                                    MSG_WINBIND_DUMP_DOMAIN_LIST,
 730                                    (uint8_t *)message, strlen(message) + 1);
 731
 732                 talloc_destroy(mem_ctx);
 733
 734                 return;
 735         }
 736
 737         DEBUG(5,("winbind_msg_dump_domain_list all domains\n"));
 738
 739         for (dom = domain_list(); dom; dom=dom->next) {
 740                 message = NDR_PRINT_STRUCT_STRING(mem_ctx, winbindd_domain, dom);
 741                 if (!message) {
 742                         talloc_destroy(mem_ctx);
 743                         return;
 744                 }
 745
 746                 s = talloc_asprintf_append(s, "%s\n", message);
 747                 if (!s) {
 748                         talloc_destroy(mem_ctx);
 749                         return;
 750                 }
 751         }
 752
 753         status = messaging_send_buf(msg_ctx, *sender,
 754                                     MSG_WINBIND_DUMP_DOMAIN_LIST,
 755                                     (uint8_t *)s, strlen(s) + 1);
 756         if (!NT_STATUS_IS_OK(status)) {
 757                 DEBUG(0,("failed to send message: %s\n",
 758                 nt_errstr(status)));
 759         }
 760
 761         talloc_destroy(mem_ctx);
 762 }
 763
 764 static void account_lockout_policy_handler(struct event_context *ctx,
 765                                            struct timed_event *te,
 766                                            const struct timeval *now,
 767                                            void *private_data)
 768 {
 769         struct winbindd_child *child =
 770                 (struct winbindd_child *)private_data;
 771         TALLOC_CTX *mem_ctx = NULL;
 772         struct winbindd_methods *methods;
 773         struct samr_DomInfo12 lockout_policy;
 774         NTSTATUS result;
 775
 776         DEBUG(10,("account_lockout_policy_handler called\n"));
 777
 778         TALLOC_FREE(child->lockout_policy_event);
 779
 780         if ( !winbindd_can_contact_domain( child->domain ) ) {
 781                 DEBUG(10,("account_lockout_policy_handler: Removing myself since I "
 782                           "do not have an incoming trust to domain %s\n",
 783                           child->domain->name));
 784
 785                 return;
 786         }
 787
 788         methods = child->domain->methods;
 789
 790         mem_ctx = talloc_init("account_lockout_policy_handler ctx");
 791         if (!mem_ctx) {
 792                 result = NT_STATUS_NO_MEMORY;
 793         } else {
 794                 result = methods->lockout_policy(child->domain, mem_ctx, &lockout_policy);
 795         }
 796         TALLOC_FREE(mem_ctx);
 797
 798         if (!NT_STATUS_IS_OK(result)) {
 799                 DEBUG(10,("account_lockout_policy_handler: lockout_policy failed error %s\n",
 800                          nt_errstr(result)));
 801         }
 802
 803         child->lockout_policy_event = event_add_timed(winbind_event_context(), NULL,
 804                                                       timeval_current_ofs(3600, 0),
 805                                                       "account_lockout_policy_handler",
 806                                                       account_lockout_policy_handler,
 807                                                       child);
 808 }
 809
 810 /* Deal with a request to go offline. */
 811
 812 static void child_msg_offline(struct messaging_context *msg,
 813                               void *private_data,
 814                               uint32_t msg_type,
 815                               struct server_id server_id,
 816                               DATA_BLOB *data)
 817 {
 818         struct winbindd_domain *domain;
 819         const char *domainname = (const char *)data->data;
 820
 821         if (data->data == NULL || data->length == 0) {
 822                 return;
 823         }
 824
 825         DEBUG(5,("child_msg_offline received for domain %s.\n", domainname));
 826
 827         if (!lp_winbind_offline_logon()) {
 828                 DEBUG(10,("child_msg_offline: rejecting offline message.\n"));
 829                 return;
 830         }
 831
 832         /* Mark the requested domain offline. */
 833
 834         for (domain = domain_list(); domain; domain = domain->next) {
 835                 if (domain->internal) {
 836                         continue;
 837                 }
 838                 if (strequal(domain->name, domainname)) {
 839                         DEBUG(5,("child_msg_offline: marking %s offline.\n", domain->name));
 840                         set_domain_offline(domain);
 841                 }
 842         }
 843 }
 844
 845 /* Deal with a request to go online. */
 846
 847 static void child_msg_online(struct messaging_context *msg,
 848                              void *private_data,
 849                              uint32_t msg_type,
 850                              struct server_id server_id,
 851                              DATA_BLOB *data)
 852 {
 853         struct winbindd_domain *domain;
 854         const char *domainname = (const char *)data->data;
 855
 856         if (data->data == NULL || data->length == 0) {
 857                 return;
 858         }
 859
 860         DEBUG(5,("child_msg_online received for domain %s.\n", domainname));
 861
 862         if (!lp_winbind_offline_logon()) {
 863                 DEBUG(10,("child_msg_online: rejecting online message.\n"));
 864                 return;
 865         }
 866
 867         /* Set our global state as online. */
 868         set_global_winbindd_state_online();
 869
 870         /* Try and mark everything online - delete any negative cache entries
 871            to force a reconnect now. */
 872
 873         for (domain = domain_list(); domain; domain = domain->next) {
 874                 if (domain->internal) {
 875                         continue;
 876                 }
 877                 if (strequal(domain->name, domainname)) {
 878                         DEBUG(5,("child_msg_online: requesting %s to go online.\n", domain->name));
 879                         winbindd_flush_negative_conn_cache(domain);
 880                         set_domain_online_request(domain);
 881                 }
 882         }
 883 }
 884
 885 static const char *collect_onlinestatus(TALLOC_CTX *mem_ctx)
 886 {
 887         struct winbindd_domain *domain;
 888         char *buf = NULL;
 889
 890         if ((buf = talloc_asprintf(mem_ctx, "global:%s ",
 891                                    get_global_winbindd_state_offline() ?
 892                                    "Offline":"Online")) == NULL) {
 893                 return NULL;
 894         }
 895
 896         for (domain = domain_list(); domain; domain = domain->next) {
 897                 if ((buf = talloc_asprintf_append_buffer(buf, "%s:%s ",
 898                                                   domain->name,
 899                                                   domain->online ?
 900                                                   "Online":"Offline")) == NULL) {
 901                         return NULL;
 902                 }
 903         }
 904
 905         buf = talloc_asprintf_append_buffer(buf, "\n");
 906
 907         DEBUG(5,("collect_onlinestatus: %s", buf));
 908
 909         return buf;
 910 }
 911
 912 static void child_msg_onlinestatus(struct messaging_context *msg_ctx,
 913                                    void *private_data,
 914                                    uint32_t msg_type,
 915                                    struct server_id server_id,
 916                                    DATA_BLOB *data)
 917 {
 918         TALLOC_CTX *mem_ctx;
 919         const char *message;
 920         struct server_id *sender;
 921
 922         DEBUG(5,("winbind_msg_onlinestatus received.\n"));
 923
 924         if (!data->data) {
 925                 return;
 926         }
 927
 928         sender = (struct server_id *)data->data;
 929
 930         mem_ctx = talloc_init("winbind_msg_onlinestatus");
 931         if (mem_ctx == NULL) {
 932                 return;
 933         }
 934
 935         message = collect_onlinestatus(mem_ctx);
 936         if (message == NULL) {
 937                 talloc_destroy(mem_ctx);
 938                 return;
 939         }
 940
 941         messaging_send_buf(msg_ctx, *sender, MSG_WINBIND_ONLINESTATUS,
 942                            (uint8 *)message, strlen(message) + 1);
 943
 944         talloc_destroy(mem_ctx);
 945 }
 946
 947 static void child_msg_dump_event_list(struct messaging_context *msg,
 948                                       void *private_data,
 949                                       uint32_t msg_type,
 950                                       struct server_id server_id,
 951                                       DATA_BLOB *data)
 952 {
 953         DEBUG(5,("child_msg_dump_event_list received\n"));
 954
 955         dump_event_list(winbind_event_context());
 956 }
 957
 958
 959 static bool fork_domain_child(struct winbindd_child *child)
 960 {
 961         int fdpair[2];
 962         struct winbindd_cli_state state;
 963         struct winbindd_domain *domain;
 964
 965         if (child->domain) {
 966                 DEBUG(10, ("fork_domain_child called for domain '%s'\n",
 967                            child->domain->name));
 968         } else {
 969                 DEBUG(10, ("fork_domain_child called without domain.\n"));
 970         }
 971
 972         if (socketpair(AF_UNIX, SOCK_STREAM, 0, fdpair) != 0) {
 973                 DEBUG(0, ("Could not open child pipe: %s\n",
 974                           strerror(errno)));
 975                 return False;
 976         }
 977
 978         ZERO_STRUCT(state);
 979         state.pid = sys_getpid();
 980
 981         /* Stop zombies */
 982         CatchChild();
 983
 984         child->pid = sys_fork();
 985
 986         if (child->pid == -1) {
 987                 DEBUG(0, ("Could not fork: %s\n", strerror(errno)));
 988                 return False;
 989         }
 990
 991         if (child->pid != 0) {
 992                 /* Parent */
 993                 close(fdpair[0]);
 994                 child->next = child->prev = NULL;
 995                 DLIST_ADD(children, child);
 996                 child->event.fd = fdpair[1];
 997                 child->event.flags = 0;
 998                 child->requests = NULL;
 999                 add_fd_event(&child->event);
1000                 return True;
1001         }
1002
1003         /* Child */
1004
1005         state.sock = fdpair[0];
1006         close(fdpair[1]);
1007
1008         /* tdb needs special fork handling */
1009         if (tdb_reopen_all(1) == -1) {
1010                 DEBUG(0,("tdb_reopen_all failed.\n"));
1011                 _exit(0);
1012         }
1013
1014         close_conns_after_fork();
1015
1016         if (!override_logfile) {
1017                 lp_set_logfile(child->logfilename);
1018                 reopen_logs();
1019         }
1020
1021         /*
1022          * For clustering, we need to re-init our ctdbd connection after the
1023          * fork
1024          */
1025         if (!NT_STATUS_IS_OK(messaging_reinit(winbind_messaging_context())))
1026                 exit(1);
1027
1028         /* Don't handle the same messages as our parent. */
1029         messaging_deregister(winbind_messaging_context(),
1030                              MSG_SMB_CONF_UPDATED, NULL);
1031         messaging_deregister(winbind_messaging_context(),
1032                              MSG_SHUTDOWN, NULL);
1033         messaging_deregister(winbind_messaging_context(),
1034                              MSG_WINBIND_OFFLINE, NULL);
1035         messaging_deregister(winbind_messaging_context(),
1036                              MSG_WINBIND_ONLINE, NULL);
1037         messaging_deregister(winbind_messaging_context(),
1038                              MSG_WINBIND_ONLINESTATUS, NULL);
1039         messaging_deregister(winbind_messaging_context(),
1040                              MSG_DUMP_EVENT_LIST, NULL);
1041         messaging_deregister(winbind_messaging_context(),
1042                              MSG_WINBIND_DUMP_DOMAIN_LIST, NULL);
1043
1044         /* Handle online/offline messages. */
1045         messaging_register(winbind_messaging_context(), NULL,
1046                            MSG_WINBIND_OFFLINE, child_msg_offline);
1047         messaging_register(winbind_messaging_context(), NULL,
1048                            MSG_WINBIND_ONLINE, child_msg_online);
1049         messaging_register(winbind_messaging_context(), NULL,
1050                            MSG_WINBIND_ONLINESTATUS, child_msg_onlinestatus);
1051         messaging_register(winbind_messaging_context(), NULL,
1052                            MSG_DUMP_EVENT_LIST, child_msg_dump_event_list);
1053
1054         if ( child->domain ) {
1055                 child->domain->startup = True;
1056                 child->domain->startup_time = time(NULL);
1057         }
1058
1059         /* Ensure we have no pending check_online events other
1060            than one for this domain. */
1061
1062         for (domain = domain_list(); domain; domain = domain->next) {
1063                 if (domain != child->domain) {
1064                         TALLOC_FREE(domain->check_online_event);
1065                 }
1066         }
1067
1068         /* Ensure we're not handling an event inherited from
1069            our parent. */
1070
1071         cancel_named_event(winbind_event_context(),
1072                            "krb5_ticket_refresh_handler");
1073
1074         /* We might be in the idmap child...*/
1075         if (child->domain && !(child->domain->internal) &&
1076             lp_winbind_offline_logon()) {
1077
1078                 set_domain_online_request(child->domain);
1079
1080                 child->lockout_policy_event = event_add_timed(
1081                         winbind_event_context(), NULL, timeval_zero(),
1082                         "account_lockout_policy_handler",
1083                         account_lockout_policy_handler,
1084                         child);
1085         }
1086
1087         /* Special case for Winbindd on a Samba DC,
1088          * We want to make sure the child can connect to smbd
1089          * but not the main daemon */
1090
1091         if (child->domain && child->domain->internal && IS_DC) {
1092                 child->domain->methods = &cache_methods;
1093                 child->domain->online = False;
1094         }
1095
1096         while (1) {
1097
1098                 int ret;
1099                 fd_set read_fds;
1100                 struct timeval t;
1101                 struct timeval *tp;
1102                 struct timeval now;
1103                 TALLOC_CTX *frame = talloc_stackframe();
1104
1105                 run_events(winbind_event_context(), 0, NULL, NULL);
1106
1107                 GetTimeOfDay(&now);
1108
1109                 if (child->domain && child->domain->startup &&
1110                                 (now.tv_sec > child->domain->startup_time + 30)) {
1111                         /* No longer in "startup" mode. */
1112                         DEBUG(10,("fork_domain_child: domain %s no longer in 'startup' mode.\n",
1113                                 child->domain->name ));
1114                         child->domain->startup = False;
1115                 }
1116
1117                 tp = get_timed_events_timeout(winbind_event_context(), &t);
1118                 if (tp) {
1119                         DEBUG(11,("select will use timeout of %u.%u seconds\n",
1120                                 (unsigned int)tp->tv_sec, (unsigned int)tp->tv_usec ));
1121                 }
1122
1123                 /* Handle messages */
1124
1125                 message_dispatch(winbind_messaging_context());
1126
1127                 FD_ZERO(&read_fds);
1128                 FD_SET(state.sock, &read_fds);
1129
1130                 ret = sys_select(state.sock + 1, &read_fds, NULL, NULL, tp);
1131
1132                 if (ret == 0) {
1133                         DEBUG(11,("nothing is ready yet, continue\n"));
1134                         TALLOC_FREE(frame);
1135                         continue;
1136                 }
1137
1138                 if (ret == -1 && errno == EINTR) {
1139                         /* We got a signal - continue. */
1140                         TALLOC_FREE(frame);
1141                         continue;
1142                 }
1143
1144                 if (ret == -1 && errno != EINTR) {
1145                         DEBUG(0,("select error occured\n"));
1146                         TALLOC_FREE(frame);
1147                         perror("select");
1148                         return False;
1149                 }
1150
1151                 /* fetch a request from the main daemon */
1152                 child_read_request(&state);
1153
1154                 if (state.finished) {
1155                         /* we lost contact with our parent */
1156                         exit(0);
1157                 }
1158
1159                 DEBUG(4,("child daemon request %d\n", (int)state.request.cmd));
1160
1161                 ZERO_STRUCT(state.response);
1162                 state.request.null_term = '\0';
1163                 child_process_request(child, &state);
1164
1165                 SAFE_FREE(state.request.extra_data.data);
1166
1167                 cache_store_response(sys_getpid(), &state.response);
1168
1169                 SAFE_FREE(state.response.extra_data.data);
1170
1171                 /* We just send the result code back, the result
1172                  * structure needs to be fetched via the
1173                  * winbindd_cache. Hmm. That needs fixing... */
1174
1175                 if (write_data(state.sock,
1176                                (const char *)&state.response.result,
1177                                sizeof(state.response.result)) !=
1178                     sizeof(state.response.result)) {
1179                         DEBUG(0, ("Could not write result\n"));
1180                         exit(1);
1181                 }
1182                 TALLOC_FREE(frame);
1183         }
1184 }