Fix wbinfo -a trusted\\user%password on a Samba DC with trusts
[ira/wip.git] / 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 }