source3/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 #include "rpc_client/rpc_client.h"
  33 #include "nsswitch/wb_reqtrans.h"
  34 #include "secrets.h"
  35 #include "../lib/util/select.h"
  36 #include "../libcli/security/security.h"
  37 #include "system/select.h"
  38 #include "messages.h"
  39 #include "../lib/util/tevent_unix.h"
  40 #include "lib/param/loadparm.h"
  41 #include "lib/util/sys_rw.h"
  42 #include "lib/util/sys_rw_data.h"
  43 #include "passdb.h"
  44 #include "lib/util/string_wrappers.h"
  45 #include "lib/global_contexts.h"
  46
  47 #undef DBGC_CLASS
  48 #define DBGC_CLASS DBGC_WINBIND
  49
  50 extern bool override_logfile;
  51
  52 static void forall_domain_children(bool (*fn)(struct winbindd_child *c,
  53                                               void *private_data),
  54                                    void *private_data)
  55 {
  56         struct winbindd_domain *d;
  57
  58         for (d = domain_list(); d != NULL; d = d->next) {
  59                 int i;
  60
  61                 for (i = 0; i < lp_winbind_max_domain_connections(); i++) {
  62                         struct winbindd_child *c = &d->children[i];
  63                         bool ok;
  64
  65                         if (c->pid == 0) {
  66                                 continue;
  67                         }
  68
  69                         ok = fn(c, private_data);
  70                         if (!ok) {
  71                                 return;
  72                         }
  73                 }
  74         }
  75 }
  76
  77 static void forall_children(bool (*fn)(struct winbindd_child *c,
  78                                        void *private_data),
  79                             void *private_data)
  80 {
  81         struct winbindd_child *c;
  82         bool ok;
  83
  84         c = idmap_child();
  85         if (c->pid != 0) {
  86                 ok = fn(c, private_data);
  87                 if (!ok) {
  88                         return;
  89                 }
  90         }
  91
  92         c = locator_child();
  93         if (c->pid != 0) {
  94                 ok = fn(c, private_data);
  95                 if (!ok) {
  96                         return;
  97                 }
  98         }
  99
 100         forall_domain_children(fn, private_data);
 101 }
 102
 103 /* Read some data from a client connection */
 104
 105 static NTSTATUS child_read_request(int sock, struct winbindd_request *wreq)
 106 {
 107         NTSTATUS status;
 108
 109         status = read_data_ntstatus(sock, (char *)wreq, sizeof(*wreq));
 110         if (!NT_STATUS_IS_OK(status)) {
 111                 DEBUG(3, ("child_read_request: read_data failed: %s\n",
 112                           nt_errstr(status)));
 113                 return status;
 114         }
 115
 116         if (wreq->extra_len == 0) {
 117                 wreq->extra_data.data = NULL;
 118                 return NT_STATUS_OK;
 119         }
 120
 121         DEBUG(10, ("Need to read %d extra bytes\n", (int)wreq->extra_len));
 122
 123         wreq->extra_data.data = SMB_MALLOC_ARRAY(char, wreq->extra_len + 1);
 124         if (wreq->extra_data.data == NULL) {
 125                 DEBUG(0, ("malloc failed\n"));
 126                 return NT_STATUS_NO_MEMORY;
 127         }
 128
 129         /* Ensure null termination */
 130         wreq->extra_data.data[wreq->extra_len] = '\0';
 131
 132         status = read_data_ntstatus(sock, wreq->extra_data.data,
 133                                     wreq->extra_len);
 134         if (!NT_STATUS_IS_OK(status)) {
 135                 DEBUG(0, ("Could not read extra data: %s\n",
 136                           nt_errstr(status)));
 137         }
 138         return status;
 139 }
 140
 141 static NTSTATUS child_write_response(int sock, struct winbindd_response *wrsp)
 142 {
 143         struct iovec iov[2];
 144         int iov_count;
 145
 146         iov[0].iov_base = (void *)wrsp;
 147         iov[0].iov_len = sizeof(struct winbindd_response);
 148         iov_count = 1;
 149
 150         if (wrsp->length > sizeof(struct winbindd_response)) {
 151                 iov[1].iov_base = (void *)wrsp->extra_data.data;
 152                 iov[1].iov_len = wrsp->length-iov[0].iov_len;
 153                 iov_count = 2;
 154         }
 155
 156         DEBUG(10, ("Writing %d bytes to parent\n", (int)wrsp->length));
 157
 158         if (write_data_iov(sock, iov, iov_count) != wrsp->length) {
 159                 DEBUG(0, ("Could not write result\n"));
 160                 return NT_STATUS_INVALID_HANDLE;
 161         }
 162
 163         return NT_STATUS_OK;
 164 }
 165
 166 /*
 167  * Do winbind child async request. This is not simply wb_simple_trans. We have
 168  * to do the queueing ourselves because while a request is queued, the child
 169  * might have crashed, and we have to re-fork it in the _trigger function.
 170  */
 171
 172 struct wb_child_request_state {
 173         struct tevent_context *ev;
 174         struct tevent_req *queue_subreq;
 175         struct tevent_req *subreq;
 176         struct winbindd_child *child;
 177         struct winbindd_request *request;
 178         struct winbindd_response *response;
 179 };
 180
 181 static bool fork_domain_child(struct winbindd_child *child);
 182
 183 static void wb_child_request_waited(struct tevent_req *subreq);
 184 static void wb_child_request_done(struct tevent_req *subreq);
 185 static void wb_child_request_orphaned(struct tevent_req *subreq);
 186
 187 static void wb_child_request_cleanup(struct tevent_req *req,
 188                                      enum tevent_req_state req_state);
 189
 190 struct tevent_req *wb_child_request_send(TALLOC_CTX *mem_ctx,
 191                                          struct tevent_context *ev,
 192                                          struct winbindd_child *child,
 193                                          struct winbindd_request *request)
 194 {
 195         struct tevent_req *req;
 196         struct wb_child_request_state *state;
 197         struct tevent_req *subreq;
 198
 199         req = tevent_req_create(mem_ctx, &state,
 200                                 struct wb_child_request_state);
 201         if (req == NULL) {
 202                 return NULL;
 203         }
 204
 205         state->ev = ev;
 206         state->child = child;
 207
 208         /*
 209          * We have to make a copy of "request", because our caller
 210          * might drop us via talloc_free().
 211          *
 212          * The talloc_move() magic in wb_child_request_cleanup() keeps
 213          * all the requests, but if we are sitting deep within
 214          * writev_send() down to the client, we have given it the
 215          * pointer to "request". As our caller lost interest, it will
 216          * just free "request", while writev_send still references it.
 217          */
 218
 219         state->request = talloc_memdup(state, request, sizeof(*request));
 220         if (tevent_req_nomem(state->request, req)) {
 221                 return tevent_req_post(req, ev);
 222         }
 223
 224         if (request->extra_data.data != NULL) {
 225                 state->request->extra_data.data = talloc_memdup(
 226                         state->request,
 227                         request->extra_data.data,
 228                         request->extra_len);
 229                 if (tevent_req_nomem(state->request->extra_data.data, req)) {
 230                         return tevent_req_post(req, ev);
 231                 }
 232         }
 233
 234         subreq = tevent_queue_wait_send(state, ev, child->queue);
 235         if (tevent_req_nomem(subreq, req)) {
 236                 return tevent_req_post(req, ev);
 237         }
 238         tevent_req_set_callback(subreq, wb_child_request_waited, req);
 239         state->queue_subreq = subreq;
 240
 241         tevent_req_set_cleanup_fn(req, wb_child_request_cleanup);
 242
 243         return req;
 244 }
 245
 246 static void wb_child_request_waited(struct tevent_req *subreq)
 247 {
 248         struct tevent_req *req = tevent_req_callback_data(
 249                 subreq, struct tevent_req);
 250         struct wb_child_request_state *state = tevent_req_data(
 251                 req, struct wb_child_request_state);
 252         bool ok;
 253
 254         ok = tevent_queue_wait_recv(subreq);
 255         if (!ok) {
 256                 tevent_req_oom(req);
 257                 return;
 258         }
 259         /*
 260          * We need to keep state->queue_subreq
 261          * in order to block the queue.
 262          */
 263         subreq = NULL;
 264
 265         if ((state->child->sock == -1) && (!fork_domain_child(state->child))) {
 266                 tevent_req_error(req, errno);
 267                 return;
 268         }
 269
 270         tevent_fd_set_flags(state->child->monitor_fde, 0);
 271
 272         subreq = wb_simple_trans_send(state, global_event_context(), NULL,
 273                                       state->child->sock, state->request);
 274         if (tevent_req_nomem(subreq, req)) {
 275                 return;
 276         }
 277
 278         state->subreq = subreq;
 279         tevent_req_set_callback(subreq, wb_child_request_done, req);
 280         tevent_req_set_endtime(req, state->ev, timeval_current_ofs(300, 0));
 281 }
 282
 283 static void wb_child_request_done(struct tevent_req *subreq)
 284 {
 285         struct tevent_req *req = tevent_req_callback_data(
 286                 subreq, struct tevent_req);
 287         struct wb_child_request_state *state = tevent_req_data(
 288                 req, struct wb_child_request_state);
 289         int ret, err;
 290
 291         ret = wb_simple_trans_recv(subreq, state, &state->response, &err);
 292         /* Freeing the subrequest is deferred until the cleanup function,
 293          * which has to know whether a subrequest exists, and consequently
 294          * decide whether to shut down the pipe to the child process.
 295          */
 296         if (ret == -1) {
 297                 tevent_req_error(req, err);
 298                 return;
 299         }
 300         tevent_req_done(req);
 301 }
 302
 303 static void wb_child_request_orphaned(struct tevent_req *subreq)
 304 {
 305         struct winbindd_child *child =
 306                 (struct winbindd_child *)tevent_req_callback_data_void(subreq);
 307
 308         DBG_WARNING("cleanup orphaned subreq[%p]\n", subreq);
 309         TALLOC_FREE(subreq);
 310
 311         if (child->domain != NULL) {
 312                 /*
 313                  * If the child is attached to a domain,
 314                  * we need to make sure the domain queue
 315                  * can move forward, after the orphaned
 316                  * request is done.
 317                  */
 318                 tevent_queue_start(child->domain->queue);
 319         }
 320 }
 321
 322 int wb_child_request_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx,
 323                           struct winbindd_response **presponse, int *err)
 324 {
 325         struct wb_child_request_state *state = tevent_req_data(
 326                 req, struct wb_child_request_state);
 327
 328         if (tevent_req_is_unix_error(req, err)) {
 329                 return -1;
 330         }
 331         *presponse = talloc_move(mem_ctx, &state->response);
 332         return 0;
 333 }
 334
 335 static void wb_child_request_cleanup(struct tevent_req *req,
 336                                      enum tevent_req_state req_state)
 337 {
 338         struct wb_child_request_state *state =
 339             tevent_req_data(req, struct wb_child_request_state);
 340
 341         if (state->subreq == NULL) {
 342                 /* nothing to cleanup */
 343                 return;
 344         }
 345
 346         if (req_state == TEVENT_REQ_RECEIVED) {
 347                 struct tevent_req *subreq = NULL;
 348
 349                 /*
 350                  * Our caller gave up, but we need to keep
 351                  * the low level request (wb_simple_trans)
 352                  * in order to maintain the parent child protocol.
 353                  *
 354                  * We also need to keep the child queue blocked
 355                  * until we got the response from the child.
 356                  */
 357
 358                 subreq = talloc_move(state->child->queue, &state->subreq);
 359                 talloc_move(subreq, &state->queue_subreq);
 360                 talloc_move(subreq, &state->request);
 361                 tevent_req_set_callback(subreq,
 362                                         wb_child_request_orphaned,
 363                                         state->child);
 364
 365                 DBG_WARNING("keep orphaned subreq[%p]\n", subreq);
 366                 return;
 367         }
 368
 369         TALLOC_FREE(state->subreq);
 370         TALLOC_FREE(state->queue_subreq);
 371
 372         tevent_fd_set_flags(state->child->monitor_fde, TEVENT_FD_READ);
 373
 374         if (state->child->domain != NULL) {
 375                 /*
 376                  * If the child is attached to a domain,
 377                  * we need to make sure the domain queue
 378                  * can move forward, after the request
 379                  * is done.
 380                  */
 381                 tevent_queue_start(state->child->domain->queue);
 382         }
 383
 384         if (req_state == TEVENT_REQ_DONE) {
 385                 /* transmitted request and got response */
 386                 return;
 387         }
 388
 389         /*
 390          * Failed to transmit and receive response, or request
 391          * cancelled while being serviced.
 392          * The basic parent/child communication broke, close
 393          * our socket
 394          */
 395         TALLOC_FREE(state->child->monitor_fde);
 396         close(state->child->sock);
 397         state->child->sock = -1;
 398 }
 399
 400 static void child_socket_readable(struct tevent_context *ev,
 401                                   struct tevent_fd *fde,
 402                                   uint16_t flags,
 403                                   void *private_data)
 404 {
 405         struct winbindd_child *child = private_data;
 406
 407         if ((flags & TEVENT_FD_READ) == 0) {
 408                 return;
 409         }
 410
 411         TALLOC_FREE(child->monitor_fde);
 412
 413         /*
 414          * We're only active when there is no outstanding child
 415          * request. Arriving here means the child closed its socket,
 416          * it died. Do the same here.
 417          */
 418
 419         SMB_ASSERT(child->sock != -1);
 420
 421         close(child->sock);
 422         child->sock = -1;
 423 }
 424
 425 static struct winbindd_child *choose_domain_child(struct winbindd_domain *domain)
 426 {
 427         struct winbindd_child *shortest = &domain->children[0];
 428         struct winbindd_child *current;
 429         int i;
 430
 431         for (i=0; i<lp_winbind_max_domain_connections(); i++) {
 432                 size_t shortest_len, current_len;
 433
 434                 current = &domain->children[i];
 435                 current_len = tevent_queue_length(current->queue);
 436
 437                 if (current_len == 0) {
 438                         /* idle child */
 439                         return current;
 440                 }
 441
 442                 shortest_len = tevent_queue_length(shortest->queue);
 443
 444                 if (current_len < shortest_len) {
 445                         shortest = current;
 446                 }
 447         }
 448
 449         return shortest;
 450 }
 451
 452 struct dcerpc_binding_handle *dom_child_handle(struct winbindd_domain *domain)
 453 {
 454         return domain->binding_handle;
 455 }
 456
 457 struct wb_domain_request_state {
 458         struct tevent_context *ev;
 459         struct tevent_queue_entry *queue_entry;
 460         struct winbindd_domain *domain;
 461         struct winbindd_child *child;
 462         struct winbindd_request *request;
 463         struct winbindd_request *init_req;
 464         struct winbindd_response *response;
 465         struct tevent_req *pending_subreq;
 466 };
 467
 468 static void wb_domain_request_cleanup(struct tevent_req *req,
 469                                       enum tevent_req_state req_state)
 470 {
 471         struct wb_domain_request_state *state = tevent_req_data(
 472                 req, struct wb_domain_request_state);
 473
 474         /*
 475          * If we're completely done or got a failure.
 476          * we should remove ourself from the domain queue,
 477          * after removing the child subreq from the child queue
 478          * and give the next one in the queue the chance
 479          * to check for an idle child.
 480          */
 481         TALLOC_FREE(state->pending_subreq);
 482         TALLOC_FREE(state->queue_entry);
 483         tevent_queue_start(state->domain->queue);
 484 }
 485
 486 static void wb_domain_request_trigger(struct tevent_req *req,
 487                                       void *private_data);
 488 static void wb_domain_request_gotdc(struct tevent_req *subreq);
 489 static void wb_domain_request_initialized(struct tevent_req *subreq);
 490 static void wb_domain_request_done(struct tevent_req *subreq);
 491
 492 struct tevent_req *wb_domain_request_send(TALLOC_CTX *mem_ctx,
 493                                           struct tevent_context *ev,
 494                                           struct winbindd_domain *domain,
 495                                           struct winbindd_request *request)
 496 {
 497         struct tevent_req *req;
 498         struct wb_domain_request_state *state;
 499
 500         req = tevent_req_create(mem_ctx, &state,
 501                                 struct wb_domain_request_state);
 502         if (req == NULL) {
 503                 return NULL;
 504         }
 505
 506         state->domain = domain;
 507         state->ev = ev;
 508         state->request = request;
 509
 510         tevent_req_set_cleanup_fn(req, wb_domain_request_cleanup);
 511
 512         state->queue_entry = tevent_queue_add_entry(
 513                         domain->queue, state->ev, req,
 514                         wb_domain_request_trigger, NULL);
 515         if (tevent_req_nomem(state->queue_entry, req)) {
 516                 return tevent_req_post(req, ev);
 517         }
 518
 519         return req;
 520 }
 521
 522 static void wb_domain_request_trigger(struct tevent_req *req,
 523                                       void *private_data)
 524 {
 525         struct wb_domain_request_state *state = tevent_req_data(
 526                 req, struct wb_domain_request_state);
 527         struct winbindd_domain *domain = state->domain;
 528         struct tevent_req *subreq = NULL;
 529         size_t shortest_queue_length;
 530
 531         state->child = choose_domain_child(domain);
 532         shortest_queue_length = tevent_queue_length(state->child->queue);
 533         if (shortest_queue_length > 0) {
 534                 /*
 535                  * All children are busy, we need to stop
 536                  * the queue and untrigger our own queue
 537                  * entry. Once a pending request
 538                  * is done it calls tevent_queue_start
 539                  * and we get retriggered.
 540                  */
 541                 state->child = NULL;
 542                 tevent_queue_stop(state->domain->queue);
 543                 tevent_queue_entry_untrigger(state->queue_entry);
 544                 return;
 545         }
 546
 547         if (domain->initialized) {
 548                 subreq = wb_child_request_send(state, state->ev, state->child,
 549                                                state->request);
 550                 if (tevent_req_nomem(subreq, req)) {
 551                         return;
 552                 }
 553                 tevent_req_set_callback(subreq, wb_domain_request_done, req);
 554                 state->pending_subreq = subreq;
 555
 556                 /*
 557                  * Once the domain is initialized and
 558                  * once we placed our real request into the child queue,
 559                  * we can remove ourself from the domain queue
 560                  * and give the next one in the queue the chance
 561                  * to check for an idle child.
 562                  */
 563                 TALLOC_FREE(state->queue_entry);
 564                 return;
 565         }
 566
 567         state->init_req = talloc_zero(state, struct winbindd_request);
 568         if (tevent_req_nomem(state->init_req, req)) {
 569                 return;
 570         }
 571
 572         if (IS_DC || domain->primary || domain->internal) {
 573                 /* The primary domain has to find the DC name itself */
 574                 state->init_req->cmd = WINBINDD_INIT_CONNECTION;
 575                 fstrcpy(state->init_req->domain_name, domain->name);
 576                 state->init_req->data.init_conn.is_primary = domain->primary;
 577                 fstrcpy(state->init_req->data.init_conn.dcname, "");
 578
 579                 subreq = wb_child_request_send(state, state->ev, state->child,
 580                                                state->init_req);
 581                 if (tevent_req_nomem(subreq, req)) {
 582                         return;
 583                 }
 584                 tevent_req_set_callback(subreq, wb_domain_request_initialized,
 585                                         req);
 586                 state->pending_subreq = subreq;
 587                 return;
 588         }
 589
 590         /*
 591          * This is *not* the primary domain,
 592          * let's ask our DC about a DC name.
 593          *
 594          * We prefer getting a dns name in dc_unc,
 595          * which is indicated by DS_RETURN_DNS_NAME.
 596          * For NT4 domains we still get the netbios name.
 597          */
 598         subreq = wb_dsgetdcname_send(state, state->ev,
 599                                      state->domain->name,
 600                                      NULL, /* domain_guid */
 601                                      NULL, /* site_name */
 602                                      DS_RETURN_DNS_NAME); /* flags */
 603         if (tevent_req_nomem(subreq, req)) {
 604                 return;
 605         }
 606         tevent_req_set_callback(subreq, wb_domain_request_gotdc, req);
 607         state->pending_subreq = subreq;
 608         return;
 609 }
 610
 611 static void wb_domain_request_gotdc(struct tevent_req *subreq)
 612 {
 613         struct tevent_req *req = tevent_req_callback_data(
 614                 subreq, struct tevent_req);
 615         struct wb_domain_request_state *state = tevent_req_data(
 616                 req, struct wb_domain_request_state);
 617         struct netr_DsRGetDCNameInfo *dcinfo = NULL;
 618         NTSTATUS status;
 619         const char *dcname = NULL;
 620
 621         state->pending_subreq = NULL;
 622
 623         status = wb_dsgetdcname_recv(subreq, state, &dcinfo);
 624         TALLOC_FREE(subreq);
 625         if (tevent_req_nterror(req, status)) {
 626                 return;
 627         }
 628         dcname = dcinfo->dc_unc;
 629         while (dcname != NULL && *dcname == '\\') {
 630                 dcname++;
 631         }
 632         state->init_req->cmd = WINBINDD_INIT_CONNECTION;
 633         fstrcpy(state->init_req->domain_name, state->domain->name);
 634         state->init_req->data.init_conn.is_primary = False;
 635         fstrcpy(state->init_req->data.init_conn.dcname,
 636                 dcname);
 637
 638         TALLOC_FREE(dcinfo);
 639
 640         subreq = wb_child_request_send(state, state->ev, state->child,
 641                                        state->init_req);
 642         if (tevent_req_nomem(subreq, req)) {
 643                 return;
 644         }
 645         tevent_req_set_callback(subreq, wb_domain_request_initialized, req);
 646         state->pending_subreq = subreq;
 647 }
 648
 649 static void wb_domain_request_initialized(struct tevent_req *subreq)
 650 {
 651         struct tevent_req *req = tevent_req_callback_data(
 652                 subreq, struct tevent_req);
 653         struct wb_domain_request_state *state = tevent_req_data(
 654                 req, struct wb_domain_request_state);
 655         struct winbindd_response *response;
 656         int ret, err;
 657
 658         state->pending_subreq = NULL;
 659
 660         ret = wb_child_request_recv(subreq, talloc_tos(), &response, &err);
 661         TALLOC_FREE(subreq);
 662         if (ret == -1) {
 663                 tevent_req_error(req, err);
 664                 return;
 665         }
 666
 667         if (!string_to_sid(&state->domain->sid,
 668                            response->data.domain_info.sid)) {
 669                 DEBUG(1,("init_child_recv: Could not convert sid %s "
 670                         "from string\n", response->data.domain_info.sid));
 671                 tevent_req_error(req, EINVAL);
 672                 return;
 673         }
 674
 675         talloc_free(state->domain->name);
 676         state->domain->name = talloc_strdup(state->domain,
 677                                             response->data.domain_info.name);
 678         if (state->domain->name == NULL) {
 679                 tevent_req_error(req, ENOMEM);
 680                 return;
 681         }
 682
 683         if (response->data.domain_info.alt_name[0] != '\0') {
 684                 talloc_free(state->domain->alt_name);
 685
 686                 state->domain->alt_name = talloc_strdup(state->domain,
 687                                 response->data.domain_info.alt_name);
 688                 if (state->domain->alt_name == NULL) {
 689                         tevent_req_error(req, ENOMEM);
 690                         return;
 691                 }
 692         }
 693
 694         state->domain->native_mode = response->data.domain_info.native_mode;
 695         state->domain->active_directory =
 696                 response->data.domain_info.active_directory;
 697         state->domain->initialized = true;
 698
 699         TALLOC_FREE(response);
 700
 701         subreq = wb_child_request_send(state, state->ev, state->child,
 702                                        state->request);
 703         if (tevent_req_nomem(subreq, req)) {
 704                 return;
 705         }
 706         tevent_req_set_callback(subreq, wb_domain_request_done, req);
 707         state->pending_subreq = subreq;
 708
 709         /*
 710          * Once the domain is initialized and
 711          * once we placed our real request into the child queue,
 712          * we can remove ourself from the domain queue
 713          * and give the next one in the queue the chance
 714          * to check for an idle child.
 715          */
 716         TALLOC_FREE(state->queue_entry);
 717 }
 718
 719 static void wb_domain_request_done(struct tevent_req *subreq)
 720 {
 721         struct tevent_req *req = tevent_req_callback_data(
 722                 subreq, struct tevent_req);
 723         struct wb_domain_request_state *state = tevent_req_data(
 724                 req, struct wb_domain_request_state);
 725         int ret, err;
 726
 727         state->pending_subreq = NULL;
 728
 729         ret = wb_child_request_recv(subreq, talloc_tos(), &state->response,
 730                                     &err);
 731         TALLOC_FREE(subreq);
 732         if (ret == -1) {
 733                 tevent_req_error(req, err);
 734                 return;
 735         }
 736         tevent_req_done(req);
 737 }
 738
 739 int wb_domain_request_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx,
 740                            struct winbindd_response **presponse, int *err)
 741 {
 742         struct wb_domain_request_state *state = tevent_req_data(
 743                 req, struct wb_domain_request_state);
 744
 745         if (tevent_req_is_unix_error(req, err)) {
 746                 return -1;
 747         }
 748         *presponse = talloc_move(mem_ctx, &state->response);
 749         return 0;
 750 }
 751
 752 static void child_process_request(struct winbindd_child *child,
 753                                   struct winbindd_cli_state *state)
 754 {
 755         struct winbindd_domain *domain = child->domain;
 756         const struct winbindd_child_dispatch_table *table = child->table;
 757
 758         /* Free response data - we may be interrupted and receive another
 759            command before being able to send this data off. */
 760
 761         state->response->result = WINBINDD_ERROR;
 762         state->response->length = sizeof(struct winbindd_response);
 763
 764         /* as all requests in the child are sync, we can use talloc_tos() */
 765         state->mem_ctx = talloc_tos();
 766
 767         /* Process command */
 768
 769         for (; table->name; table++) {
 770                 if (state->request->cmd == table->struct_cmd) {
 771                         DEBUG(10,("child_process_request: request fn %s\n",
 772                                   table->name));
 773                         state->response->result = table->struct_fn(domain, state);
 774                         return;
 775                 }
 776         }
 777
 778         DEBUG(1, ("child_process_request: unknown request fn number %d\n",
 779                   (int)state->request->cmd));
 780         state->response->result = WINBINDD_ERROR;
 781 }
 782
 783 void setup_child(struct winbindd_domain *domain, struct winbindd_child *child,
 784                  const struct winbindd_child_dispatch_table *table,
 785                  const char *logprefix,
 786                  const char *logname)
 787 {
 788         const struct loadparm_substitution *lp_sub =
 789                 loadparm_s3_global_substitution();
 790
 791         if (logprefix && logname) {
 792                 char *logbase = NULL;
 793
 794                 if (*lp_logfile(talloc_tos(), lp_sub)) {
 795                         char *end = NULL;
 796
 797                         if (asprintf(&logbase, "%s", lp_logfile(talloc_tos(), lp_sub)) < 0) {
 798                                 smb_panic("Internal error: asprintf failed");
 799                         }
 800
 801                         if ((end = strrchr_m(logbase, '/'))) {
 802                                 *end = '\0';
 803                         }
 804                 } else {
 805                         if (asprintf(&logbase, "%s", get_dyn_LOGFILEBASE()) < 0) {
 806                                 smb_panic("Internal error: asprintf failed");
 807                         }
 808                 }
 809
 810                 if (asprintf(&child->logfilename, "%s/%s-%s",
 811                              logbase, logprefix, logname) < 0) {
 812                         SAFE_FREE(logbase);
 813                         smb_panic("Internal error: asprintf failed");
 814                 }
 815
 816                 SAFE_FREE(logbase);
 817         } else {
 818                 smb_panic("Internal error: logprefix == NULL && "
 819                           "logname == NULL");
 820         }
 821
 822         child->pid = 0;
 823         child->sock = -1;
 824         child->domain = domain;
 825         child->table = table;
 826         child->queue = tevent_queue_create(NULL, "winbind_child");
 827         SMB_ASSERT(child->queue != NULL);
 828         if (domain == NULL) {
 829                 child->binding_handle = wbint_binding_handle(NULL, NULL, child);
 830                 SMB_ASSERT(child->binding_handle != NULL);
 831         }
 832 }
 833
 834 struct winbind_child_died_state {
 835         pid_t pid;
 836         struct winbindd_child *child;
 837 };
 838
 839 static bool winbind_child_died_fn(struct winbindd_child *child,
 840                                   void *private_data)
 841 {
 842         struct winbind_child_died_state *state = private_data;
 843
 844         if (child->pid == state->pid) {
 845                 state->child = child;
 846                 return false;
 847         }
 848         return true;
 849 }
 850
 851 void winbind_child_died(pid_t pid)
 852 {
 853         struct winbind_child_died_state state = { .pid = pid };
 854
 855         forall_children(winbind_child_died_fn, &state);
 856
 857         if (state.child == NULL) {
 858                 DEBUG(5, ("Already reaped child %u died\n", (unsigned int)pid));
 859                 return;
 860         }
 861
 862         state.child->pid = 0;
 863 }
 864
 865 /* Ensure any negative cache entries with the netbios or realm names are removed. */
 866
 867 void winbindd_flush_negative_conn_cache(struct winbindd_domain *domain)
 868 {
 869         flush_negative_conn_cache_for_domain(domain->name);
 870         if (domain->alt_name != NULL) {
 871                 flush_negative_conn_cache_for_domain(domain->alt_name);
 872         }
 873 }
 874
 875 /*
 876  * Parent winbindd process sets its own debug level first and then
 877  * sends a message to all the winbindd children to adjust their debug
 878  * level to that of parents.
 879  */
 880
 881 struct winbind_msg_relay_state {
 882         struct messaging_context *msg_ctx;
 883         uint32_t msg_type;
 884         DATA_BLOB *data;
 885 };
 886
 887 static bool winbind_msg_relay_fn(struct winbindd_child *child,
 888                                  void *private_data)
 889 {
 890         struct winbind_msg_relay_state *state = private_data;
 891
 892         DBG_DEBUG("sending message to pid %u.\n",
 893                   (unsigned int)child->pid);
 894
 895         messaging_send(state->msg_ctx, pid_to_procid(child->pid),
 896                        state->msg_type, state->data);
 897         return true;
 898 }
 899
 900 void winbind_msg_debug(struct messaging_context *msg_ctx,
 901                          void *private_data,
 902                          uint32_t msg_type,
 903                          struct server_id server_id,
 904                          DATA_BLOB *data)
 905 {
 906         struct winbind_msg_relay_state state = {
 907                 .msg_ctx = msg_ctx, .msg_type = msg_type, .data = data
 908         };
 909
 910         DEBUG(10,("winbind_msg_debug: got debug message.\n"));
 911
 912         debug_message(msg_ctx, private_data, MSG_DEBUG, server_id, data);
 913
 914         forall_children(winbind_msg_relay_fn, &state);
 915 }
 916
 917 void winbind_disconnect_dc_parent(struct messaging_context *msg_ctx,
 918                                   void *private_data,
 919                                   uint32_t msg_type,
 920                                   struct server_id server_id,
 921                                   DATA_BLOB *data)
 922 {
 923         struct winbind_msg_relay_state state = {
 924                 .msg_ctx = msg_ctx, .msg_type = msg_type, .data = data
 925         };
 926
 927         DBG_DEBUG("Got disconnect_dc message\n");
 928
 929         forall_children(winbind_msg_relay_fn, &state);
 930 }
 931
 932 /* Set our domains as offline and forward the offline message to our children. */
 933
 934 struct winbind_msg_on_offline_state {
 935         struct messaging_context *msg_ctx;
 936         uint32_t msg_type;
 937 };
 938
 939 static bool winbind_msg_on_offline_fn(struct winbindd_child *child,
 940                                       void *private_data)
 941 {
 942         struct winbind_msg_on_offline_state *state = private_data;
 943
 944         if (child->domain->internal) {
 945                 return true;
 946         }
 947
 948         /*
 949          * Each winbindd child should only process requests for one
 950          * domain - make sure we only set it online / offline for that
 951          * domain.
 952          */
 953         DBG_DEBUG("sending message to pid %u for domain %s.\n",
 954                   (unsigned int)child->pid, child->domain->name);
 955
 956         messaging_send_buf(state->msg_ctx,
 957                            pid_to_procid(child->pid),
 958                            state->msg_type,
 959                            (const uint8_t *)child->domain->name,
 960                            strlen(child->domain->name)+1);
 961
 962         return true;
 963 }
 964
 965 void winbind_msg_offline(struct messaging_context *msg_ctx,
 966                          void *private_data,
 967                          uint32_t msg_type,
 968                          struct server_id server_id,
 969                          DATA_BLOB *data)
 970 {
 971         struct winbind_msg_on_offline_state state = {
 972                 .msg_ctx = msg_ctx,
 973                 .msg_type = MSG_WINBIND_OFFLINE,
 974         };
 975         struct winbindd_domain *domain;
 976
 977         DEBUG(10,("winbind_msg_offline: got offline message.\n"));
 978
 979         if (!lp_winbind_offline_logon()) {
 980                 DEBUG(10,("winbind_msg_offline: rejecting offline message.\n"));
 981                 return;
 982         }
 983
 984         /* Set our global state as offline. */
 985         if (!set_global_winbindd_state_offline()) {
 986                 DEBUG(10,("winbind_msg_offline: offline request failed.\n"));
 987                 return;
 988         }
 989
 990         /* Set all our domains as offline. */
 991         for (domain = domain_list(); domain; domain = domain->next) {
 992                 if (domain->internal) {
 993                         continue;
 994                 }
 995                 DEBUG(5,("winbind_msg_offline: marking %s offline.\n", domain->name));
 996                 set_domain_offline(domain);
 997         }
 998
 999         forall_domain_children(winbind_msg_on_offline_fn, &state);
1000 }
1001
1002 /* Set our domains as online and forward the online message to our children. */
1003
1004 void winbind_msg_online(struct messaging_context *msg_ctx,
1005                         void *private_data,
1006                         uint32_t msg_type,
1007                         struct server_id server_id,
1008                         DATA_BLOB *data)
1009 {
1010         struct winbind_msg_on_offline_state state = {
1011                 .msg_ctx = msg_ctx,
1012                 .msg_type = MSG_WINBIND_ONLINE,
1013         };
1014         struct winbindd_domain *domain;
1015
1016         DEBUG(10,("winbind_msg_online: got online message.\n"));
1017
1018         if (!lp_winbind_offline_logon()) {
1019                 DEBUG(10,("winbind_msg_online: rejecting online message.\n"));
1020                 return;
1021         }
1022
1023         /* Set our global state as online. */
1024         set_global_winbindd_state_online();
1025
1026         smb_nscd_flush_user_cache();
1027         smb_nscd_flush_group_cache();
1028
1029         /* Set all our domains as online. */
1030         for (domain = domain_list(); domain; domain = domain->next) {
1031                 if (domain->internal) {
1032                         continue;
1033                 }
1034                 DEBUG(5,("winbind_msg_online: requesting %s to go online.\n", domain->name));
1035
1036                 winbindd_flush_negative_conn_cache(domain);
1037                 set_domain_online_request(domain);
1038
1039                 /* Send an online message to the idmap child when our
1040                    primary domain comes back online */
1041
1042                 if ( domain->primary ) {
1043                         pid_t idmap_pid = idmap_child_pid();
1044
1045                         if (idmap_pid != 0) {
1046                                 messaging_send_buf(msg_ctx,
1047                                                    pid_to_procid(idmap_pid),
1048                                                    MSG_WINBIND_ONLINE,
1049                                                    (const uint8_t *)domain->name,
1050                                                    strlen(domain->name)+1);
1051                         }
1052                 }
1053         }
1054
1055         forall_domain_children(winbind_msg_on_offline_fn, &state);
1056 }
1057
1058 static const char *collect_onlinestatus(TALLOC_CTX *mem_ctx)
1059 {
1060         struct winbindd_domain *domain;
1061         char *buf = NULL;
1062
1063         if ((buf = talloc_asprintf(mem_ctx, "global:%s ",
1064                                    get_global_winbindd_state_offline() ?
1065                                    "Offline":"Online")) == NULL) {
1066                 return NULL;
1067         }
1068
1069         for (domain = domain_list(); domain; domain = domain->next) {
1070                 if ((buf = talloc_asprintf_append_buffer(buf, "%s:%s ",
1071                                                   domain->name,
1072                                                   domain->online ?
1073                                                   "Online":"Offline")) == NULL) {
1074                         return NULL;
1075                 }
1076         }
1077
1078         buf = talloc_asprintf_append_buffer(buf, "\n");
1079
1080         DEBUG(5,("collect_onlinestatus: %s", buf));
1081
1082         return buf;
1083 }
1084
1085 void winbind_msg_onlinestatus(struct messaging_context *msg_ctx,
1086                               void *private_data,
1087                               uint32_t msg_type,
1088                               struct server_id server_id,
1089                               DATA_BLOB *data)
1090 {
1091         TALLOC_CTX *mem_ctx;
1092         const char *message;
1093
1094         DEBUG(5,("winbind_msg_onlinestatus received.\n"));
1095
1096         mem_ctx = talloc_init("winbind_msg_onlinestatus");
1097         if (mem_ctx == NULL) {
1098                 return;
1099         }
1100
1101         message = collect_onlinestatus(mem_ctx);
1102         if (message == NULL) {
1103                 talloc_destroy(mem_ctx);
1104                 return;
1105         }
1106
1107         messaging_send_buf(msg_ctx, server_id, MSG_WINBIND_ONLINESTATUS,
1108                            (const uint8_t *)message, strlen(message) + 1);
1109
1110         talloc_destroy(mem_ctx);
1111 }
1112
1113 void winbind_msg_dump_domain_list(struct messaging_context *msg_ctx,
1114                                   void *private_data,
1115                                   uint32_t msg_type,
1116                                   struct server_id server_id,
1117                                   DATA_BLOB *data)
1118 {
1119         TALLOC_CTX *mem_ctx;
1120         const char *message = NULL;
1121         const char *domain = NULL;
1122         char *s = NULL;
1123         NTSTATUS status;
1124         struct winbindd_domain *dom = NULL;
1125
1126         DEBUG(5,("winbind_msg_dump_domain_list received.\n"));
1127
1128         mem_ctx = talloc_init("winbind_msg_dump_domain_list");
1129         if (!mem_ctx) {
1130                 return;
1131         }
1132
1133         if (data->length > 0) {
1134                 domain = (const char *)data->data;
1135         }
1136
1137         if (domain) {
1138
1139                 DEBUG(5,("winbind_msg_dump_domain_list for domain: %s\n",
1140                         domain));
1141
1142                 message = NDR_PRINT_STRUCT_STRING(mem_ctx, winbindd_domain,
1143                                                   find_domain_from_name_noinit(domain));
1144                 if (!message) {
1145                         talloc_destroy(mem_ctx);
1146                         return;
1147                 }
1148
1149                 messaging_send_buf(msg_ctx, server_id,
1150                                    MSG_WINBIND_DUMP_DOMAIN_LIST,
1151                                    (const uint8_t *)message, strlen(message) + 1);
1152
1153                 talloc_destroy(mem_ctx);
1154
1155                 return;
1156         }
1157
1158         DEBUG(5,("winbind_msg_dump_domain_list all domains\n"));
1159
1160         for (dom = domain_list(); dom; dom=dom->next) {
1161                 message = NDR_PRINT_STRUCT_STRING(mem_ctx, winbindd_domain, dom);
1162                 if (!message) {
1163                         talloc_destroy(mem_ctx);
1164                         return;
1165                 }
1166
1167                 s = talloc_asprintf_append(s, "%s\n", message);
1168                 if (!s) {
1169                         talloc_destroy(mem_ctx);
1170                         return;
1171                 }
1172         }
1173
1174         status = messaging_send_buf(msg_ctx, server_id,
1175                                     MSG_WINBIND_DUMP_DOMAIN_LIST,
1176                                     (uint8_t *)s, strlen(s) + 1);
1177         if (!NT_STATUS_IS_OK(status)) {
1178                 DEBUG(0,("failed to send message: %s\n",
1179                 nt_errstr(status)));
1180         }
1181
1182         talloc_destroy(mem_ctx);
1183 }
1184
1185 static void account_lockout_policy_handler(struct tevent_context *ctx,
1186                                            struct tevent_timer *te,
1187                                            struct timeval now,
1188                                            void *private_data)
1189 {
1190         struct winbindd_child *child =
1191                 (struct winbindd_child *)private_data;
1192         TALLOC_CTX *mem_ctx = NULL;
1193         struct samr_DomInfo12 lockout_policy;
1194         NTSTATUS result;
1195
1196         DEBUG(10,("account_lockout_policy_handler called\n"));
1197
1198         TALLOC_FREE(child->lockout_policy_event);
1199
1200         if ( !winbindd_can_contact_domain( child->domain ) ) {
1201                 DEBUG(10,("account_lockout_policy_handler: Removing myself since I "
1202                           "do not have an incoming trust to domain %s\n",
1203                           child->domain->name));
1204
1205                 return;
1206         }
1207
1208         mem_ctx = talloc_init("account_lockout_policy_handler ctx");
1209         if (!mem_ctx) {
1210                 result = NT_STATUS_NO_MEMORY;
1211         } else {
1212                 result = wb_cache_lockout_policy(child->domain, mem_ctx,
1213                                                  &lockout_policy);
1214         }
1215         TALLOC_FREE(mem_ctx);
1216
1217         if (!NT_STATUS_IS_OK(result)) {
1218                 DEBUG(10,("account_lockout_policy_handler: lockout_policy failed error %s\n",
1219                          nt_errstr(result)));
1220         }
1221
1222         child->lockout_policy_event = tevent_add_timer(global_event_context(), NULL,
1223                                                       timeval_current_ofs(3600, 0),
1224                                                       account_lockout_policy_handler,
1225                                                       child);
1226 }
1227
1228 static time_t get_machine_password_timeout(void)
1229 {
1230         /* until we have gpo support use lp setting */
1231         return lp_machine_password_timeout();
1232 }
1233
1234 static bool calculate_next_machine_pwd_change(const char *domain,
1235                                               struct timeval *t)
1236 {
1237         time_t pass_last_set_time;
1238         time_t timeout;
1239         time_t next_change;
1240         struct timeval tv;
1241         char *pw;
1242
1243         pw = secrets_fetch_machine_password(domain,
1244                                             &pass_last_set_time,
1245                                             NULL);
1246
1247         if (pw == NULL) {
1248                 DEBUG(0,("cannot fetch own machine password ????"));
1249                 return false;
1250         }
1251
1252         SAFE_FREE(pw);
1253
1254         timeout = get_machine_password_timeout();
1255         if (timeout == 0) {
1256                 DEBUG(10,("machine password never expires\n"));
1257                 return false;
1258         }
1259
1260         tv.tv_sec = pass_last_set_time;
1261         DEBUG(10, ("password last changed %s\n",
1262                    timeval_string(talloc_tos(), &tv, false)));
1263         tv.tv_sec += timeout;
1264         DEBUGADD(10, ("password valid until %s\n",
1265                       timeval_string(talloc_tos(), &tv, false)));
1266
1267         if (time(NULL) < (pass_last_set_time + timeout)) {
1268                 next_change = pass_last_set_time + timeout;
1269                 DEBUG(10,("machine password still valid until: %s\n",
1270                         http_timestring(talloc_tos(), next_change)));
1271                 *t = timeval_set(next_change, 0);
1272
1273                 if (lp_clustering()) {
1274                         uint8_t randbuf;
1275                         /*
1276                          * When having a cluster, we have several
1277                          * winbinds racing for the password change. In
1278                          * the machine_password_change_handler()
1279                          * function we check if someone else was
1280                          * faster when the event triggers. We add a
1281                          * 255-second random delay here, so that we
1282                          * don't run to change the password at the
1283                          * exact same moment.
1284                          */
1285                         generate_random_buffer(&randbuf, sizeof(randbuf));
1286                         DEBUG(10, ("adding %d seconds randomness\n",
1287                                    (int)randbuf));
1288                         t->tv_sec += randbuf;
1289                 }
1290                 return true;
1291         }
1292
1293         DEBUG(10,("machine password expired, needs immediate change\n"));
1294
1295         *t = timeval_zero();
1296
1297         return true;
1298 }
1299
1300 static void machine_password_change_handler(struct tevent_context *ctx,
1301                                             struct tevent_timer *te,
1302                                             struct timeval now,
1303                                             void *private_data)
1304 {
1305         struct messaging_context *msg_ctx = global_messaging_context();
1306         struct winbindd_child *child =
1307                 (struct winbindd_child *)private_data;
1308         struct rpc_pipe_client *netlogon_pipe = NULL;
1309         struct netlogon_creds_cli_context *netlogon_creds_ctx = NULL;
1310         NTSTATUS result;
1311         struct timeval next_change;
1312
1313         DEBUG(10,("machine_password_change_handler called\n"));
1314
1315         TALLOC_FREE(child->machine_password_change_event);
1316
1317         if (!calculate_next_machine_pwd_change(child->domain->name,
1318                                                &next_change)) {
1319                 DEBUG(10, ("calculate_next_machine_pwd_change failed\n"));
1320                 return;
1321         }
1322
1323         DEBUG(10, ("calculate_next_machine_pwd_change returned %s\n",
1324                    timeval_string(talloc_tos(), &next_change, false)));
1325
1326         if (!timeval_expired(&next_change)) {
1327                 DEBUG(10, ("Someone else has already changed the pw\n"));
1328                 goto done;
1329         }
1330
1331         if (!winbindd_can_contact_domain(child->domain)) {
1332                 DEBUG(10,("machine_password_change_handler: Removing myself since I "
1333                           "do not have an incoming trust to domain %s\n",
1334                           child->domain->name));
1335                 return;
1336         }
1337
1338         result = cm_connect_netlogon_secure(child->domain,
1339                                             &netlogon_pipe,
1340                                             &netlogon_creds_ctx);
1341         if (!NT_STATUS_IS_OK(result)) {
1342                 DEBUG(10,("machine_password_change_handler: "
1343                         "failed to connect netlogon pipe: %s\n",
1344                          nt_errstr(result)));
1345                 return;
1346         }
1347
1348         result = trust_pw_change(netlogon_creds_ctx,
1349                                  msg_ctx,
1350                                  netlogon_pipe->binding_handle,
1351                                  child->domain->name,
1352                                  child->domain->dcname,
1353                                  false); /* force */
1354
1355         DEBUG(10, ("machine_password_change_handler: "
1356                    "trust_pw_change returned %s\n",
1357                    nt_errstr(result)));
1358
1359         if (NT_STATUS_EQUAL(result, NT_STATUS_ACCESS_DENIED) ) {
1360                 DEBUG(3,("machine_password_change_handler: password set returned "
1361                          "ACCESS_DENIED.  Maybe the trust account "
1362                          "password was changed and we didn't know it. "
1363                          "Killing connections to domain %s\n",
1364                          child->domain->name));
1365                 invalidate_cm_connection(child->domain);
1366         }
1367
1368         if (!calculate_next_machine_pwd_change(child->domain->name,
1369                                                &next_change)) {
1370                 DEBUG(10, ("calculate_next_machine_pwd_change failed\n"));
1371                 return;
1372         }
1373
1374         DEBUG(10, ("calculate_next_machine_pwd_change returned %s\n",
1375                    timeval_string(talloc_tos(), &next_change, false)));
1376
1377         if (!NT_STATUS_IS_OK(result)) {
1378                 struct timeval tmp;
1379                 /*
1380                  * In case of failure, give the DC a minute to recover
1381                  */
1382                 tmp = timeval_current_ofs(60, 0);
1383                 next_change = timeval_max(&next_change, &tmp);
1384         }
1385
1386 done:
1387         child->machine_password_change_event = tevent_add_timer(global_event_context(), NULL,
1388                                                               next_change,
1389                                                               machine_password_change_handler,
1390                                                               child);
1391 }
1392
1393 /* Deal with a request to go offline. */
1394
1395 static void child_msg_offline(struct messaging_context *msg,
1396                               void *private_data,
1397                               uint32_t msg_type,
1398                               struct server_id server_id,
1399                               DATA_BLOB *data)
1400 {
1401         struct winbindd_domain *domain;
1402         struct winbindd_domain *primary_domain = NULL;
1403         const char *domainname = (const char *)data->data;
1404
1405         if (data->data == NULL || data->length == 0) {
1406                 return;
1407         }
1408
1409         DEBUG(5,("child_msg_offline received for domain %s.\n", domainname));
1410
1411         if (!lp_winbind_offline_logon()) {
1412                 DEBUG(10,("child_msg_offline: rejecting offline message.\n"));
1413                 return;
1414         }
1415
1416         primary_domain = find_our_domain();
1417
1418         /* Mark the requested domain offline. */
1419
1420         for (domain = domain_list(); domain; domain = domain->next) {
1421                 if (domain->internal) {
1422                         continue;
1423                 }
1424                 if (strequal(domain->name, domainname)) {
1425                         DEBUG(5,("child_msg_offline: marking %s offline.\n", domain->name));
1426                         set_domain_offline(domain);
1427                         /* we are in the trusted domain, set the primary domain
1428                          * offline too */
1429                         if (domain != primary_domain) {
1430                                 set_domain_offline(primary_domain);
1431                         }
1432                 }
1433         }
1434 }
1435
1436 /* Deal with a request to go online. */
1437
1438 static void child_msg_online(struct messaging_context *msg,
1439                              void *private_data,
1440                              uint32_t msg_type,
1441                              struct server_id server_id,
1442                              DATA_BLOB *data)
1443 {
1444         struct winbindd_domain *domain;
1445         struct winbindd_domain *primary_domain = NULL;
1446         const char *domainname = (const char *)data->data;
1447
1448         if (data->data == NULL || data->length == 0) {
1449                 return;
1450         }
1451
1452         DEBUG(5,("child_msg_online received for domain %s.\n", domainname));
1453
1454         if (!lp_winbind_offline_logon()) {
1455                 DEBUG(10,("child_msg_online: rejecting online message.\n"));
1456                 return;
1457         }
1458
1459         primary_domain = find_our_domain();
1460
1461         /* Set our global state as online. */
1462         set_global_winbindd_state_online();
1463
1464         /* Try and mark everything online - delete any negative cache entries
1465            to force a reconnect now. */
1466
1467         for (domain = domain_list(); domain; domain = domain->next) {
1468                 if (domain->internal) {
1469                         continue;
1470                 }
1471                 if (strequal(domain->name, domainname)) {
1472                         DEBUG(5,("child_msg_online: requesting %s to go online.\n", domain->name));
1473                         winbindd_flush_negative_conn_cache(domain);
1474                         set_domain_online_request(domain);
1475
1476                         /* we can be in trusted domain, which will contact primary domain
1477                          * we have to bring primary domain online in trusted domain process
1478                          * see, winbindd_dual_pam_auth() --> winbindd_dual_pam_auth_samlogon()
1479                          * --> contact_domain = find_our_domain()
1480                          * */
1481                         if (domain != primary_domain) {
1482                                 winbindd_flush_negative_conn_cache(primary_domain);
1483                                 set_domain_online_request(primary_domain);
1484                         }
1485                 }
1486         }
1487 }
1488
1489 struct winbindd_reinit_after_fork_state {
1490         const struct winbindd_child *myself;
1491 };
1492
1493 static bool winbindd_reinit_after_fork_fn(struct winbindd_child *child,
1494                                           void *private_data)
1495 {
1496         struct winbindd_reinit_after_fork_state *state = private_data;
1497
1498         if (child == state->myself) {
1499                 return true;
1500         }
1501
1502         /* Destroy all possible events in child list. */
1503         TALLOC_FREE(child->lockout_policy_event);
1504         TALLOC_FREE(child->machine_password_change_event);
1505
1506         /*
1507          * Children should never be able to send each other messages,
1508          * all messages must go through the parent.
1509          */
1510         child->pid = (pid_t)0;
1511
1512         /*
1513          * Close service sockets to all other children
1514          */
1515         if (child->sock != -1) {
1516                 close(child->sock);
1517                 child->sock = -1;
1518         }
1519
1520         return true;
1521 }
1522
1523 NTSTATUS winbindd_reinit_after_fork(const struct winbindd_child *myself,
1524                                     const char *logfilename)
1525 {
1526         struct winbindd_reinit_after_fork_state state = { .myself = myself };
1527         struct winbindd_domain *domain;
1528         NTSTATUS status;
1529
1530         status = reinit_after_fork(
1531                 global_messaging_context(),
1532                 global_event_context(),
1533                 true, NULL);
1534         if (!NT_STATUS_IS_OK(status)) {
1535                 DEBUG(0,("reinit_after_fork() failed\n"));
1536                 return status;
1537         }
1538         initialize_password_db(true, global_event_context());
1539
1540         close_conns_after_fork();
1541
1542         if (!override_logfile && logfilename) {
1543                 lp_set_logfile(logfilename);
1544                 reopen_logs();
1545         }
1546
1547         if (!winbindd_setup_sig_term_handler(false))
1548                 return NT_STATUS_NO_MEMORY;
1549         if (!winbindd_setup_sig_hup_handler(override_logfile ? NULL :
1550                                             logfilename))
1551                 return NT_STATUS_NO_MEMORY;
1552
1553         /* Stop zombies in children */
1554         CatchChild();
1555
1556         /* Don't handle the same messages as our parent. */
1557         messaging_deregister(global_messaging_context(),
1558                              MSG_SMB_CONF_UPDATED, NULL);
1559         messaging_deregister(global_messaging_context(),
1560                              MSG_SHUTDOWN, NULL);
1561         messaging_deregister(global_messaging_context(),
1562                              MSG_WINBIND_OFFLINE, NULL);
1563         messaging_deregister(global_messaging_context(),
1564                              MSG_WINBIND_ONLINE, NULL);
1565         messaging_deregister(global_messaging_context(),
1566                              MSG_WINBIND_ONLINESTATUS, NULL);
1567         messaging_deregister(global_messaging_context(),
1568                              MSG_WINBIND_DUMP_DOMAIN_LIST, NULL);
1569         messaging_deregister(global_messaging_context(),
1570                              MSG_DEBUG, NULL);
1571
1572         messaging_deregister(global_messaging_context(),
1573                              MSG_WINBIND_DOMAIN_OFFLINE, NULL);
1574         messaging_deregister(global_messaging_context(),
1575                              MSG_WINBIND_DOMAIN_ONLINE, NULL);
1576
1577         /* We have destroyed all events in the winbindd_event_context
1578          * in reinit_after_fork(), so clean out all possible pending
1579          * event pointers. */
1580
1581         /* Deal with check_online_events. */
1582
1583         for (domain = domain_list(); domain; domain = domain->next) {
1584                 TALLOC_FREE(domain->check_online_event);
1585         }
1586
1587         /* Ensure we're not handling a credential cache event inherited
1588          * from our parent. */
1589
1590         ccache_remove_all_after_fork();
1591
1592         forall_children(winbindd_reinit_after_fork_fn, &state);
1593
1594         return NT_STATUS_OK;
1595 }
1596
1597 /*
1598  * In a child there will be only one domain, reference that here.
1599  */
1600 static struct winbindd_domain *child_domain;
1601
1602 struct winbindd_domain *wb_child_domain(void)
1603 {
1604         return child_domain;
1605 }
1606
1607 struct child_handler_state {
1608         struct winbindd_child *child;
1609         struct winbindd_cli_state cli;
1610 };
1611
1612 static void child_handler(struct tevent_context *ev, struct tevent_fd *fde,
1613                           uint16_t flags, void *private_data)
1614 {
1615         struct child_handler_state *state =
1616                 (struct child_handler_state *)private_data;
1617         NTSTATUS status;
1618
1619         /* fetch a request from the main daemon */
1620         status = child_read_request(state->cli.sock, state->cli.request);
1621
1622         if (!NT_STATUS_IS_OK(status)) {
1623                 /* we lost contact with our parent */
1624                 _exit(0);
1625         }
1626
1627         DEBUG(4,("child daemon request %d\n",
1628                  (int)state->cli.request->cmd));
1629
1630         ZERO_STRUCTP(state->cli.response);
1631         state->cli.request->null_term = '\0';
1632         state->cli.mem_ctx = talloc_tos();
1633         child_process_request(state->child, &state->cli);
1634
1635         DEBUG(4, ("Finished processing child request %d\n",
1636                   (int)state->cli.request->cmd));
1637
1638         SAFE_FREE(state->cli.request->extra_data.data);
1639
1640         status = child_write_response(state->cli.sock, state->cli.response);
1641         if (!NT_STATUS_IS_OK(status)) {
1642                 exit(1);
1643         }
1644 }
1645
1646 static bool fork_domain_child(struct winbindd_child *child)
1647 {
1648         int fdpair[2];
1649         struct child_handler_state state;
1650         struct winbindd_request request;
1651         struct winbindd_response response;
1652         struct winbindd_domain *primary_domain = NULL;
1653         NTSTATUS status;
1654         ssize_t nwritten;
1655         struct tevent_fd *fde;
1656
1657         if (child->domain) {
1658                 DEBUG(10, ("fork_domain_child called for domain '%s'\n",
1659                            child->domain->name));
1660         } else {
1661                 DEBUG(10, ("fork_domain_child called without domain.\n"));
1662         }
1663
1664         if (socketpair(AF_UNIX, SOCK_STREAM, 0, fdpair) != 0) {
1665                 DEBUG(0, ("Could not open child pipe: %s\n",
1666                           strerror(errno)));
1667                 return False;
1668         }
1669
1670         ZERO_STRUCT(state);
1671         state.child = child;
1672         state.cli.pid = getpid();
1673         state.cli.request = &request;
1674         state.cli.response = &response;
1675
1676         child->pid = fork();
1677
1678         if (child->pid == -1) {
1679                 DEBUG(0, ("Could not fork: %s\n", strerror(errno)));
1680                 close(fdpair[0]);
1681                 close(fdpair[1]);
1682                 return False;
1683         }
1684
1685         if (child->pid != 0) {
1686                 /* Parent */
1687                 ssize_t nread;
1688                 int rc;
1689
1690                 close(fdpair[0]);
1691
1692                 nread = sys_read(fdpair[1], &status, sizeof(status));
1693                 if (nread != sizeof(status)) {
1694                         DEBUG(1, ("fork_domain_child: Could not read child status: "
1695                                   "nread=%d, error=%s\n", (int)nread,
1696                                   strerror(errno)));
1697                         close(fdpair[1]);
1698                         return false;
1699                 }
1700                 if (!NT_STATUS_IS_OK(status)) {
1701                         DEBUG(1, ("fork_domain_child: Child status is %s\n",
1702                                   nt_errstr(status)));
1703                         close(fdpair[1]);
1704                         return false;
1705                 }
1706
1707                 child->monitor_fde = tevent_add_fd(global_event_context(),
1708                                                    global_event_context(),
1709                                                    fdpair[1],
1710                                                    TEVENT_FD_READ,
1711                                                    child_socket_readable,
1712                                                    child);
1713                 if (child->monitor_fde == NULL) {
1714                         DBG_WARNING("tevent_add_fd failed\n");
1715                         close(fdpair[1]);
1716                         return false;
1717                 }
1718
1719                 rc = set_blocking(fdpair[1], false);
1720                 if (rc < 0) {
1721                         close(fdpair[1]);
1722                         return false;
1723                 }
1724
1725                 child->sock = fdpair[1];
1726
1727                 return true;
1728         }
1729
1730         /* Child */
1731         child_domain = child->domain;
1732
1733         DEBUG(10, ("Child process %d\n", (int)getpid()));
1734
1735         state.cli.sock = fdpair[0];
1736         close(fdpair[1]);
1737
1738         status = winbindd_reinit_after_fork(child, child->logfilename);
1739
1740         nwritten = sys_write(state.cli.sock, &status, sizeof(status));
1741         if (nwritten != sizeof(status)) {
1742                 DEBUG(1, ("fork_domain_child: Could not write status: "
1743                           "nwritten=%d, error=%s\n", (int)nwritten,
1744                           strerror(errno)));
1745                 _exit(0);
1746         }
1747         if (!NT_STATUS_IS_OK(status)) {
1748                 DEBUG(1, ("winbindd_reinit_after_fork failed: %s\n",
1749                           nt_errstr(status)));
1750                 _exit(0);
1751         }
1752
1753         if (child_domain != NULL) {
1754                 setproctitle("domain child [%s]", child_domain->name);
1755         } else if (is_idmap_child(child)) {
1756                 setproctitle("idmap child");
1757         }
1758
1759         /* Handle online/offline messages. */
1760         messaging_register(global_messaging_context(), NULL,
1761                            MSG_WINBIND_OFFLINE, child_msg_offline);
1762         messaging_register(global_messaging_context(), NULL,
1763                            MSG_WINBIND_ONLINE, child_msg_online);
1764         messaging_register(global_messaging_context(), NULL,
1765                            MSG_DEBUG, debug_message);
1766         messaging_register(global_messaging_context(), NULL,
1767                            MSG_WINBIND_IP_DROPPED,
1768                            winbind_msg_ip_dropped);
1769         messaging_register(global_messaging_context(), NULL,
1770                            MSG_WINBIND_DISCONNECT_DC,
1771                            winbind_msg_disconnect_dc);
1772
1773         primary_domain = find_our_domain();
1774
1775         if (primary_domain == NULL) {
1776                 smb_panic("no primary domain found");
1777         }
1778
1779         /* It doesn't matter if we allow cache login,
1780          * try to bring domain online after fork. */
1781         if ( child->domain ) {
1782                 child->domain->startup = True;
1783                 child->domain->startup_time = time_mono(NULL);
1784                 /* we can be in primary domain or in trusted domain
1785                  * If we are in trusted domain, set the primary domain
1786                  * in start-up mode */
1787                 if (!(child->domain->internal)) {
1788                         set_domain_online_request(child->domain);
1789                         if (!(child->domain->primary)) {
1790                                 primary_domain->startup = True;
1791                                 primary_domain->startup_time = time_mono(NULL);
1792                                 set_domain_online_request(primary_domain);
1793                         }
1794                 }
1795         }
1796
1797         /*
1798          * We are in idmap child, make sure that we set the
1799          * check_online_event to bring primary domain online.
1800          */
1801         if (is_idmap_child(child)) {
1802                 set_domain_online_request(primary_domain);
1803         }
1804
1805         /* We might be in the idmap child...*/
1806         if (child->domain && !(child->domain->internal) &&
1807             lp_winbind_offline_logon()) {
1808
1809                 set_domain_online_request(child->domain);
1810
1811                 if (primary_domain && (primary_domain != child->domain)) {
1812                         /* We need to talk to the primary
1813                          * domain as well as the trusted
1814                          * domain inside a trusted domain
1815                          * child.
1816                          * See the code in :
1817                          * set_dc_type_and_flags_trustinfo()
1818                          * for details.
1819                          */
1820                         set_domain_online_request(primary_domain);
1821                 }
1822
1823                 child->lockout_policy_event = tevent_add_timer(
1824                         global_event_context(), NULL, timeval_zero(),
1825                         account_lockout_policy_handler,
1826                         child);
1827         }
1828
1829         if (child->domain && child->domain->primary &&
1830             !USE_KERBEROS_KEYTAB &&
1831             lp_server_role() == ROLE_DOMAIN_MEMBER) {
1832
1833                 struct timeval next_change;
1834
1835                 if (calculate_next_machine_pwd_change(child->domain->name,
1836                                                        &next_change)) {
1837                         child->machine_password_change_event = tevent_add_timer(
1838                                 global_event_context(), NULL, next_change,
1839                                 machine_password_change_handler,
1840                                 child);
1841                 }
1842         }
1843
1844         fde = tevent_add_fd(global_event_context(), NULL, state.cli.sock,
1845                             TEVENT_FD_READ, child_handler, &state);
1846         if (fde == NULL) {
1847                 DEBUG(1, ("tevent_add_fd failed\n"));
1848                 _exit(1);
1849         }
1850
1851         while (1) {
1852
1853                 int ret;
1854                 TALLOC_CTX *frame = talloc_stackframe();
1855
1856                 ret = tevent_loop_once(global_event_context());
1857                 if (ret != 0) {
1858                         DEBUG(1, ("tevent_loop_once failed: %s\n",
1859                                   strerror(errno)));
1860                         _exit(1);
1861                 }
1862
1863                 if (child->domain && child->domain->startup &&
1864                                 (time_mono(NULL) > child->domain->startup_time + 30)) {
1865                         /* No longer in "startup" mode. */
1866                         DEBUG(10,("fork_domain_child: domain %s no longer in 'startup' mode.\n",
1867                                 child->domain->name ));
1868                         child->domain->startup = False;
1869                 }
1870
1871                 TALLOC_FREE(frame);
1872         }
1873 }
1874
1875 void winbind_msg_ip_dropped_parent(struct messaging_context *msg_ctx,
1876                                    void *private_data,
1877                                    uint32_t msg_type,
1878                                    struct server_id server_id,
1879                                    DATA_BLOB *data)
1880 {
1881         struct winbind_msg_relay_state state = {
1882                 .msg_ctx = msg_ctx,
1883                 .msg_type = msg_type,
1884                 .data = data,
1885         };
1886
1887         winbind_msg_ip_dropped(msg_ctx, private_data, msg_type,
1888                                server_id, data);
1889
1890         forall_children(winbind_msg_relay_fn, &state);
1891 }