async_req: check for errors when monitoring socket for readability

[kai/samba-autobuild/.git] / source3 / winbindd / winbindd.c

diff --git a/source3/winbindd/winbindd.c b/source3/winbindd/winbindd.c
index 4978c97aaa89b00314c3b72b56084c69c9231b3b..07faadf7be1f822074504e53882e59a15c64149d 100644 (file)
--- a/source3/winbindd/winbindd.c
+++ b/source3/winbindd/winbindd.c
@@ -42,12 +42,14 @@
 #include "source4/lib/messaging/irpc.h"
 #include "source4/lib/messaging/messaging.h"
 #include "lib/param/param.h"
+#include "lib/async_req/async_sock.h"
 
 #undef DBGC_CLASS
 #define DBGC_CLASS DBGC_WINBIND
 
 static bool client_is_idle(struct winbindd_cli_state *state);
 static void remove_client(struct winbindd_cli_state *state);
+static void winbindd_setup_max_fds(void);
 
 static bool opt_nocache = False;
 static bool interactive = False;
@@ -145,6 +147,7 @@ static bool reload_services_file(const char *lfile)
 
        reopen_logs();
        load_interfaces();
+       winbindd_setup_max_fds();
 
        return(ret);
 }
@@ -496,7 +499,7 @@ static void winbind_msg_validate_cache(struct messaging_context *msg_ctx,
                                       struct server_id server_id,
                                       DATA_BLOB *data)
 {
-       uint8 ret;
+       uint8_t ret;
        pid_t child_pid;
        NTSTATUS status;
 
@@ -535,7 +538,7 @@ static void winbind_msg_validate_cache(struct messaging_context *msg_ctx,
        /* install default SIGCHLD handler: validation code uses fork/waitpid */
        CatchSignal(SIGCHLD, SIG_DFL);
 
-       ret = (uint8)winbindd_validate_cache_nobackup();
+       ret = (uint8_t)winbindd_validate_cache_nobackup();
        DEBUG(10, ("winbindd_msg_validata_cache: got return value %d\n", ret));
        messaging_send_buf(msg_ctx, server_id, MSG_WINBIND_VALIDATE_CACHE, &ret,
                           (size_t)1);
@@ -807,11 +810,15 @@ static void request_finished(struct winbindd_cli_state *state);
 
 static void winbind_client_request_read(struct tevent_req *req);
 static void winbind_client_response_written(struct tevent_req *req);
+static void winbind_client_activity(struct tevent_req *req);
 
 static void request_finished(struct winbindd_cli_state *state)
 {
        struct tevent_req *req;
 
+       /* free client socket monitoring request */
+       TALLOC_FREE(state->io_req);
+
        TALLOC_FREE(state->request);
 
        req = wb_resp_write_send(state, winbind_event_context(),
@@ -824,6 +831,7 @@ static void request_finished(struct winbindd_cli_state *state)
                return;
        }
        tevent_req_set_callback(req, winbind_client_response_written, state);
+       state->io_req = req;
 }
 
 static void winbind_client_response_written(struct tevent_req *req)
@@ -833,6 +841,8 @@ static void winbind_client_response_written(struct tevent_req *req)
        ssize_t ret;
        int err;
 
+       state->io_req = NULL;
+
        ret = wb_resp_write_recv(req, &err);
        TALLOC_FREE(req);
        if (ret == -1) {
@@ -859,6 +869,7 @@ static void winbind_client_response_written(struct tevent_req *req)
                return;
        }
        tevent_req_set_callback(req, winbind_client_request_read, state);
+       state->io_req = req;
 }
 
 void request_error(struct winbindd_cli_state *state)
@@ -929,6 +940,7 @@ static void new_connection(int listen_sock, bool privileged)
                return;
        }
        tevent_req_set_callback(req, winbind_client_request_read, state);
+       state->io_req = req;
 
        /* Add to connection list */
 
@@ -942,6 +954,8 @@ static void winbind_client_request_read(struct tevent_req *req)
        ssize_t ret;
        int err;
 
+       state->io_req = NULL;
+
        ret = wb_req_read_recv(req, state, &state->request, &err);
        TALLOC_FREE(req);
        if (ret == -1) {
@@ -957,9 +971,33 @@ static void winbind_client_request_read(struct tevent_req *req)
                remove_client(state);
                return;
        }
+
+       req = wait_for_read_send(state, winbind_event_context(), state->sock,
+                                false);
+       if (req == NULL) {
+               DEBUG(0, ("winbind_client_request_read[%d:%s]:"
+                         " wait_for_read_send failed - removing client\n",
+                         (int)state->pid, state->cmd_name));
+               remove_client(state);
+               return;
+       }
+       tevent_req_set_callback(req, winbind_client_activity, state);
+       state->io_req = req;
+
        process_request(state);
 }
 
+static void winbind_client_activity(struct tevent_req *req)
+{
+       struct winbindd_cli_state *state =
+           tevent_req_callback_data(req, struct winbindd_cli_state);
+       int err;
+
+       wait_for_read_recv(req, &err);
+
+       remove_client(state);
+}
+
 /* Remove a client connection from client connection list */
 
 static void remove_client(struct winbindd_cli_state *state)
@@ -973,6 +1011,25 @@ static void remove_client(struct winbindd_cli_state *state)
                return;
        }
 
+       /*
+        * We need to remove a pending wb_req_read_*
+        * or wb_resp_write_* request before closing the
+        * socket.
+        *
+        * This is important as they might have used tevent_add_fd() and we
+        * use the epoll * backend on linux. So we must remove the tevent_fd
+        * before closing the fd.
+        *
+        * Otherwise we might hit a race with close_conns_after_fork() (via
+        * winbindd_reinit_after_fork()) where a file description
+        * is still open in a child, which means it's still active in
+        * the parents epoll queue, but the related tevent_fd is already
+        * already gone in the parent.
+        *
+        * See bug #11141.
+        */
+       TALLOC_FREE(state->io_req);
+
        if (state->sock != -1) {
                /* tell client, we are closing ... */
                nwritten = write(state->sock, &c, sizeof(c));
@@ -1104,6 +1161,35 @@ char *get_winbind_priv_pipe_dir(void)
        return state_path(WINBINDD_PRIV_SOCKET_SUBDIR);
 }
 
+static void winbindd_setup_max_fds(void)
+{
+       int num_fds = MAX_OPEN_FUDGEFACTOR;
+       int actual_fds;
+
+       num_fds += lp_winbind_max_clients();
+       /* Add some more to account for 2 sockets open
+          when the client transitions from unprivileged
+          to privileged socket
+       */
+       num_fds += lp_winbind_max_clients() / 10;
+
+       /* Add one socket per child process
+          (yeah there are child processes other than the
+          domain children but only domain children can vary
+          with configuration
+       */
+       num_fds += lp_winbind_max_domain_connections() *
+                  (lp_allow_trusted_domains() ? WINBIND_MAX_DOMAINS_HINT : 1);
+
+       actual_fds = set_maxfiles(num_fds);
+
+       if (actual_fds < num_fds) {
+               DEBUG(1, ("winbindd_setup_max_fds: Information only: "
+                         "requested %d open files, %d are available.\n",
+                         num_fds, actual_fds));
+       }
+}
+
 static bool winbindd_setup_listeners(void)
 {
        struct winbindd_listen_state *pub_state = NULL;
@@ -1436,7 +1522,7 @@ int main(int argc, const char **argv)
        fault_setup();
        dump_core_setup("winbindd", lp_logfile(talloc_tos()));
 
-       load_case_tables();
+       smb_init_locale();
 
        /* Initialise for running in non-root mode */