r23577: Fix winbindd (sorry). Ensure I set the new child_pid
[sfrench/samba-autobuild/.git] / source / nsswitch / winbindd_dual.c
index 26debd26745b9304e71dc7794c0eba360a8628e3..255577c58cfc62023317ef0cead6886b1776b1af 100644 (file)
@@ -96,6 +96,9 @@ struct winbindd_async_request {
        struct winbindd_request *request;
        struct winbindd_response *response;
        void (*continuation)(void *private_data, BOOL success);
+       struct timed_event *reply_timeout_event;
+       pid_t child_pid; /* pid of the child we're waiting on. Used to detect
+                           a restart of the child (child->pid != child_pid). */
        void *private_data;
 };
 
@@ -160,17 +163,64 @@ static void async_main_request_sent(void *private_data, BOOL success)
                          async_request_sent, state);
 }
 
+/****************************************************************
+ Handler triggered if the child winbindd doesn't respond within
+ a given timeout.
+****************************************************************/
+
+static void async_request_timeout_handler(struct event_context *ctx,
+                                       struct timed_event *te,
+                                       const struct timeval *now,
+                                       void *private_data)
+{
+       struct winbindd_async_request *state =
+               talloc_get_type_abort(private_data, struct winbindd_async_request);
+
+       DEBUG(0,("async_request_timeout_handler: child pid %u is not responding. "
+               "Closing connection to it.\n",
+               state->child_pid ));
+
+       /* Deal with the reply - set to error. */
+       async_reply_recv(private_data, False);
+}
+
+/**************************************************************
+ Common function called on both async send and recv fail.
+ Cleans up the child and schedules the next request.
+**************************************************************/
+
+static void async_request_fail(struct winbindd_async_request *state)
+{
+       DLIST_REMOVE(state->child->requests, state);
+
+       TALLOC_FREE(state->reply_timeout_event);
+
+       SMB_ASSERT(state->child_pid != (pid_t)0);
+
+       /* If not already reaped, send kill signal to child. */
+       if (state->child->pid == state->child_pid) {
+               kill(state->child_pid, SIGTERM);
+
+               /* 
+                * Close the socket to the child.
+                */
+               winbind_child_died(state->child_pid);
+       }
+
+       state->response->length = sizeof(struct winbindd_response);
+       state->response->result = WINBINDD_ERROR;
+       state->continuation(state->private_data, False);
+}
+
 static void async_request_sent(void *private_data_data, BOOL success)
 {
        struct winbindd_async_request *state =
                talloc_get_type_abort(private_data_data, struct winbindd_async_request);
 
        if (!success) {
-               DEBUG(5, ("Could not send async request\n"));
-
-               state->response->length = sizeof(struct winbindd_response);
-               state->response->result = WINBINDD_ERROR;
-               state->continuation(state->private_data, False);
+               DEBUG(5, ("Could not send async request to child pid %u\n",
+                       (unsigned int)state->child_pid ));
+               async_request_fail(state);
                return;
        }
 
@@ -180,6 +230,22 @@ static void async_request_sent(void *private_data_data, BOOL success)
                         &state->response->result,
                         sizeof(state->response->result),
                         async_reply_recv, state);
+
+       /* 
+        * Set up a timeout of 300 seconds for the response.
+        * If we don't get it close the child socket and
+        * report failure.
+        */
+
+       state->reply_timeout_event = event_add_timed(winbind_event_context(),
+                                                       NULL,
+                                                       timeval_current_ofs(300,0),
+                                                       "async_request_timeout",
+                                                       async_request_timeout_handler,
+                                                       state);
+       if (!state->reply_timeout_event) {
+               smb_panic("async_request_sent: failed to add timeout handler.\n");
+       }
 }
 
 static void async_reply_recv(void *private_data, BOOL success)
@@ -188,23 +254,23 @@ static void async_reply_recv(void *private_data, BOOL success)
                talloc_get_type_abort(private_data, struct winbindd_async_request);
        struct winbindd_child *child = state->child;
 
+       TALLOC_FREE(state->reply_timeout_event);
+
        state->response->length = sizeof(struct winbindd_response);
 
        if (!success) {
-               DEBUG(5, ("Could not receive async reply\n"));
+               DEBUG(5, ("Could not receive async reply from child pid %u\n",
+                       (unsigned int)state->child_pid ));
 
-               cache_cleanup_response(child->pid);
-               DLIST_REMOVE(child->requests, state);
-
-               state->response->result = WINBINDD_ERROR;
-               state->continuation(state->private_data, False);
+               cache_cleanup_response(state->child_pid);
+               async_request_fail(state);
                return;
        }
 
-       SMB_ASSERT(cache_retrieve_response(child->pid,
+       SMB_ASSERT(cache_retrieve_response(state->child_pid,
                                           state->response));
 
-       cache_cleanup_response(child->pid);
+       cache_cleanup_response(state->child_pid);
        
        DLIST_REMOVE(child->requests, state);
 
@@ -239,6 +305,9 @@ static void schedule_async_request(struct winbindd_child *child)
                return;
        }
 
+       /* Now we know who we're sending to - remember the pid. */
+       request->child_pid = child->pid;
+
        setup_async_write(&child->event, request->request,
                          sizeof(*request->request),
                          async_main_request_sent, request);
@@ -364,7 +433,9 @@ static struct winbindd_child_dispatch_table child_dispatch_table[] = {
        { WINBINDD_CHECK_MACHACC,        winbindd_dual_check_machine_acct,    "CHECK_MACHACC" },
        { WINBINDD_DUAL_SID2UID,         winbindd_dual_sid2uid,               "DUAL_SID2UID" },
        { WINBINDD_DUAL_SID2GID,         winbindd_dual_sid2gid,               "DUAL_SID2GID" },
+#if 0   /* DISABLED until we fix the interface in Samba 3.0.26 --jerry */
        { WINBINDD_DUAL_SIDS2XIDS,       winbindd_dual_sids2xids,             "DUAL_SIDS2XIDS" },
+#endif  /* end DISABLED */
        { WINBINDD_DUAL_UID2SID,         winbindd_dual_uid2sid,               "DUAL_UID2SID" },
        { WINBINDD_DUAL_GID2SID,         winbindd_dual_gid2sid,               "DUAL_GID2SID" },
        { WINBINDD_DUAL_UID2NAME,        winbindd_dual_uid2name,              "DUAL_UID2NAME" },
@@ -451,7 +522,7 @@ void winbind_child_died(pid_t pid)
        }
 
        if (child == NULL) {
-               DEBUG(0, ("Unknown child %d died!\n", pid));
+               DEBUG(5, ("Already reaped child %u died\n", (unsigned int)pid));
                return;
        }
 
@@ -476,8 +547,11 @@ void winbindd_flush_negative_conn_cache(struct winbindd_domain *domain)
 
 /* Set our domains as offline and forward the offline message to our children. */
 
-void winbind_msg_offline(int msg_type, struct process_id src,
-                        void *buf, size_t len, void *private_data)
+void winbind_msg_offline(struct messaging_context *msg_ctx,
+                        void *private_data,
+                        uint32_t msg_type,
+                        struct server_id server_id,
+                        DATA_BLOB *data)
 {
        struct winbindd_child *child;
        struct winbindd_domain *domain;
@@ -502,21 +576,6 @@ void winbind_msg_offline(int msg_type, struct process_id src,
                }
                DEBUG(5,("winbind_msg_offline: marking %s offline.\n", domain->name));
                set_domain_offline(domain);
-
-               /* Send an offline message to the idmap child when our
-                  primary domain goes offline */
-
-               if ( domain->primary ) {
-                       struct winbindd_child *idmap = idmap_child();
-
-                       if ( idmap->pid != 0 ) {
-                               message_send_pid(pid_to_procid(idmap->pid), 
-                                                MSG_WINBIND_OFFLINE, 
-                                                domain->name, 
-                                                strlen(domain->name)+1, 
-                                                False);
-                       }                       
-               }
        }
 
        for (child = children; child != NULL; child = child->next) {
@@ -537,15 +596,20 @@ void winbind_msg_offline(int msg_type, struct process_id src,
                DEBUG(10,("winbind_msg_offline: sending message to pid %u for domain %s.\n",
                        (unsigned int)child->pid, domain->name ));
 
-               message_send_pid(pid_to_procid(child->pid), MSG_WINBIND_OFFLINE, child->domain->name,
-                       strlen(child->domain->name)+1, False);
+               messaging_send_buf(msg_ctx, pid_to_procid(child->pid),
+                                  MSG_WINBIND_OFFLINE,
+                                  (uint8 *)child->domain->name,
+                                  strlen(child->domain->name)+1);
        }
 }
 
 /* Set our domains as online and forward the online message to our children. */
 
-void winbind_msg_online(int msg_type, struct process_id src,
-                       void *buf, size_t len, void *private_data)
+void winbind_msg_online(struct messaging_context *msg_ctx,
+                       void *private_data,
+                       uint32_t msg_type,
+                       struct server_id server_id,
+                       DATA_BLOB *data)
 {
        struct winbindd_child *child;
        struct winbindd_domain *domain;
@@ -580,11 +644,11 @@ void winbind_msg_online(int msg_type, struct process_id src,
                        struct winbindd_child *idmap = idmap_child();
                        
                        if ( idmap->pid != 0 ) {
-                               message_send_pid(pid_to_procid(idmap->pid), 
-                                                MSG_WINBIND_ONLINE,
-                                                domain->name,
-                                                strlen(domain->name)+1, 
-                                                False);
+                               messaging_send_buf(msg_ctx,
+                                                  pid_to_procid(idmap->pid), 
+                                                  MSG_WINBIND_ONLINE,
+                                                  (uint8 *)domain->name,
+                                                  strlen(domain->name)+1);
                        }
                        
                }
@@ -607,14 +671,19 @@ void winbind_msg_online(int msg_type, struct process_id src,
                DEBUG(10,("winbind_msg_online: sending message to pid %u for domain %s.\n",
                        (unsigned int)child->pid, child->domain->name ));
 
-               message_send_pid(pid_to_procid(child->pid), MSG_WINBIND_ONLINE, child->domain->name,
-                       strlen(child->domain->name)+1, False);
+               messaging_send_buf(msg_ctx, pid_to_procid(child->pid),
+                                  MSG_WINBIND_ONLINE,
+                                  (uint8 *)child->domain->name,
+                                  strlen(child->domain->name)+1);
        }
 }
 
 /* Forward the online/offline messages to our children. */
-void winbind_msg_onlinestatus(int msg_type, struct process_id src,
-                             void *buf, size_t len, void *private_data)
+void winbind_msg_onlinestatus(struct messaging_context *msg_ctx,
+                             void *private_data,
+                             uint32_t msg_type,
+                             struct server_id server_id,
+                             DATA_BLOB *data)
 {
        struct winbindd_child *child;
 
@@ -625,13 +694,38 @@ void winbind_msg_onlinestatus(int msg_type, struct process_id src,
                        DEBUG(10,("winbind_msg_onlinestatus: "
                                  "sending message to pid %u of primary domain.\n",
                                  (unsigned int)child->pid));
-                       message_send_pid(pid_to_procid(child->pid), 
-                                        MSG_WINBIND_ONLINESTATUS, buf, len, False);
+                       messaging_send_buf(msg_ctx, pid_to_procid(child->pid), 
+                                          MSG_WINBIND_ONLINESTATUS,
+                                          (uint8 *)data->data,
+                                          data->length);
                        break;
                }
        }
 }
 
+void winbind_msg_dump_event_list(struct messaging_context *msg_ctx,
+                                void *private_data,
+                                uint32_t msg_type,
+                                struct server_id server_id,
+                                DATA_BLOB *data)
+{
+       struct winbindd_child *child;
+
+       DEBUG(10,("winbind_msg_dump_event_list received\n"));
+
+       dump_event_list(winbind_event_context());
+
+       for (child = children; child != NULL; child = child->next) {
+
+               DEBUG(10,("winbind_msg_dump_event_list: sending message to pid %u\n",
+                       (unsigned int)child->pid));
+
+               messaging_send_buf(msg_ctx, pid_to_procid(child->pid),
+                                  MSG_DUMP_EVENT_LIST,
+                                  NULL, 0);
+       }
+
+}
 
 static void account_lockout_policy_handler(struct event_context *ctx,
                                           struct timed_event *te,
@@ -647,8 +741,14 @@ static void account_lockout_policy_handler(struct event_context *ctx,
 
        DEBUG(10,("account_lockout_policy_handler called\n"));
 
-       if (child->lockout_policy_event) {
-               TALLOC_FREE(child->lockout_policy_event);
+       TALLOC_FREE(child->lockout_policy_event);
+
+       if ( !winbindd_can_contact_domain( child->domain ) ) {
+               DEBUG(10,("account_lockout_policy_handler: Removing myself since I "
+                         "do not have an incoming trust to domain %s\n", 
+                         child->domain->name));
+
+               return;         
        }
 
        methods = child->domain->methods;
@@ -676,13 +776,16 @@ static void account_lockout_policy_handler(struct event_context *ctx,
 
 /* Deal with a request to go offline. */
 
-static void child_msg_offline(int msg_type, struct process_id src,
-                             void *buf, size_t len, void *private_data)
+static void child_msg_offline(struct messaging_context *msg,
+                             void *private_data,
+                             uint32_t msg_type,
+                             struct server_id server_id,
+                             DATA_BLOB *data)
 {
        struct winbindd_domain *domain;
-       const char *domainname = (const char *)buf;
+       const char *domainname = (const char *)data->data;
 
-       if (buf == NULL || len == 0) {
+       if (data->data == NULL || data->length == 0) {
                return;
        }
 
@@ -693,12 +796,6 @@ static void child_msg_offline(int msg_type, struct process_id src,
                return;
        }
 
-       /* Set our global state as offline. */
-       if (!set_global_winbindd_state_offline()) {
-               DEBUG(10,("child_msg_offline: offline request failed.\n"));
-               return;
-       }
-
        /* Mark the requested domain offline. */
 
        for (domain = domain_list(); domain; domain = domain->next) {
@@ -714,13 +811,16 @@ static void child_msg_offline(int msg_type, struct process_id src,
 
 /* Deal with a request to go online. */
 
-static void child_msg_online(int msg_type, struct process_id src,
-                            void *buf, size_t len, void *private_data)
+static void child_msg_online(struct messaging_context *msg,
+                            void *private_data,
+                            uint32_t msg_type,
+                            struct server_id server_id,
+                            DATA_BLOB *data)
 {
        struct winbindd_domain *domain;
-       const char *domainname = (const char *)buf;
+       const char *domainname = (const char *)data->data;
 
-       if (buf == NULL || len == 0) {
+       if (data->data == NULL || data->length == 0) {
                return;
        }
 
@@ -776,20 +876,23 @@ static const char *collect_onlinestatus(TALLOC_CTX *mem_ctx)
        return buf;
 }
 
-static void child_msg_onlinestatus(int msg_type, struct process_id src,
-                                  void *buf, size_t len, void *private_data)
+static void child_msg_onlinestatus(struct messaging_context *msg_ctx,
+                                  void *private_data,
+                                  uint32_t msg_type,
+                                  struct server_id server_id,
+                                  DATA_BLOB *data)
 {
        TALLOC_CTX *mem_ctx;
        const char *message;
-       struct process_id *sender;
+       struct server_id *sender;
        
        DEBUG(5,("winbind_msg_onlinestatus received.\n"));
 
-       if (!buf) {
+       if (!data->data) {
                return;
        }
 
-       sender = (struct process_id *)buf;
+       sender = (struct server_id *)data->data;
 
        mem_ctx = talloc_init("winbind_msg_onlinestatus");
        if (mem_ctx == NULL) {
@@ -802,12 +905,24 @@ static void child_msg_onlinestatus(int msg_type, struct process_id src,
                return;
        }
 
-       message_send_pid(*sender, MSG_WINBIND_ONLINESTATUS, 
-                        message, strlen(message) + 1, True);
+       messaging_send_buf(msg_ctx, *sender, MSG_WINBIND_ONLINESTATUS, 
+                          (uint8 *)message, strlen(message) + 1);
 
        talloc_destroy(mem_ctx);
 }
 
+static void child_msg_dump_event_list(struct messaging_context *msg,
+                                     void *private_data,
+                                     uint32_t msg_type,
+                                     struct server_id server_id,
+                                     DATA_BLOB *data)
+{
+       DEBUG(5,("child_msg_dump_event_list received\n"));
+
+       dump_event_list(winbind_event_context());
+}
+
+
 static BOOL fork_domain_child(struct winbindd_child *child)
 {
        int fdpair[2];
@@ -826,15 +941,10 @@ static BOOL fork_domain_child(struct winbindd_child *child)
        /* Stop zombies */
        CatchChild();
 
-       /* Ensure we don't process messages whilst we're
-          changing the disposition for the child. */
-       message_block();
-
        child->pid = sys_fork();
 
        if (child->pid == -1) {
                DEBUG(0, ("Could not fork: %s\n", strerror(errno)));
-               message_unblock();
                return False;
        }
 
@@ -847,8 +957,6 @@ static BOOL fork_domain_child(struct winbindd_child *child)
                child->event.flags = 0;
                child->requests = NULL;
                add_fd_event(&child->event);
-               /* We're ok with online/offline messages now. */
-               message_unblock();
                return True;
        }
 
@@ -870,21 +978,36 @@ static BOOL fork_domain_child(struct winbindd_child *child)
                reopen_logs();
        }
 
-       /* Don't handle the same messages as our parent. */
-       message_deregister(MSG_SMB_CONF_UPDATED);
-       message_deregister(MSG_SHUTDOWN);
-       message_deregister(MSG_WINBIND_OFFLINE);
-       message_deregister(MSG_WINBIND_ONLINE);
-       message_deregister(MSG_WINBIND_ONLINESTATUS);
+       /*
+        * For clustering, we need to re-init our ctdbd connection after the
+        * fork
+        */
+       if (!NT_STATUS_IS_OK(messaging_reinit(winbind_messaging_context())))
+               exit(1);
 
-       /* The child is ok with online/offline messages now. */
-       message_unblock();
+       /* Don't handle the same messages as our parent. */
+       messaging_deregister(winbind_messaging_context(),
+                            MSG_SMB_CONF_UPDATED, NULL);
+       messaging_deregister(winbind_messaging_context(),
+                            MSG_SHUTDOWN, NULL);
+       messaging_deregister(winbind_messaging_context(),
+                            MSG_WINBIND_OFFLINE, NULL);
+       messaging_deregister(winbind_messaging_context(),
+                            MSG_WINBIND_ONLINE, NULL);
+       messaging_deregister(winbind_messaging_context(),
+                            MSG_WINBIND_ONLINESTATUS, NULL);
+       messaging_deregister(winbind_messaging_context(),
+                            MSG_DUMP_EVENT_LIST, NULL);
 
        /* Handle online/offline messages. */
-       message_register(MSG_WINBIND_OFFLINE, child_msg_offline, NULL);
-       message_register(MSG_WINBIND_ONLINE, child_msg_online, NULL);
-       message_register(MSG_WINBIND_ONLINESTATUS, child_msg_onlinestatus,
-                        NULL);
+       messaging_register(winbind_messaging_context(), NULL,
+                          MSG_WINBIND_OFFLINE, child_msg_offline);
+       messaging_register(winbind_messaging_context(), NULL,
+                          MSG_WINBIND_ONLINE, child_msg_online);
+       messaging_register(winbind_messaging_context(), NULL,
+                          MSG_WINBIND_ONLINESTATUS, child_msg_onlinestatus);
+       messaging_register(winbind_messaging_context(), NULL,
+                          MSG_DUMP_EVENT_LIST, child_msg_dump_event_list);
 
        if ( child->domain ) {
                child->domain->startup = True;
@@ -896,9 +1019,7 @@ static BOOL fork_domain_child(struct winbindd_child *child)
 
        for (domain = domain_list(); domain; domain = domain->next) {
                if (domain != child->domain) {
-                       if (domain->check_online_event) {
-                               TALLOC_FREE(domain->check_online_event);
-                       }
+                       TALLOC_FREE(domain->check_online_event);
                }
        }
 
@@ -953,7 +1074,7 @@ static BOOL fork_domain_child(struct winbindd_child *child)
 
                /* Handle messages */
 
-               message_dispatch();
+               message_dispatch(winbind_messaging_context());
 
                FD_ZERO(&read_fds);
                FD_SET(state.sock, &read_fds);