Changeset 745 for trunk/server/source3/winbindd/winbindd_dual.c

Timestamp:

Nov 27, 2012, 4:43:17 PM (13 years ago)

Author:

Silvan Scherrer

Message:

Samba Server: updated trunk to 3.6.0

Location:

trunk/server

Files:

• . (modified) (1 prop)
• source3/winbindd/winbindd_dual.c (modified) (39 diffs)

trunk/server/source3/winbindd/winbindd_dual.c

@@ -30 +30 @@
 #include "includes.h"
 #include "winbindd.h"
-#include "../../nsswitch/libwbclient/wbc_async.h"
+#include "nsswitch/wb_reqtrans.h"
+#include "secrets.h"
+#include "../lib/util/select.h"
+#include "../libcli/security/security.h"
+#include "system/select.h"
+#include "messages.h"
+#include "../lib/util/tevent_unix.h"
 
 #undef DBGC_CLASS
@@ -135 +141 @@
         struct tevent_req *subreq;
 
-        if ((state->child->pid == 0) && (!fork_domain_child(state->child))) {
+        if ((state->child->sock == -1) && (!fork_domain_child(state->child))) {
                 tevent_req_error(req, errno);
                 return;
@@ -146 +152 @@
         }
         tevent_req_set_callback(subreq, wb_child_request_done, req);
-
-        if (!tevent_req_set_endtime(req, state->ev,
-                                    timeval_current_ofs(300, 0))) {
-                tevent_req_nomem(NULL, req);
-                return;
-        }
+        tevent_req_set_endtime(req, state->ev, timeval_current_ofs(300, 0));
 }
 
@@ -165 +166 @@
         TALLOC_FREE(subreq);
         if (ret == -1) {
+                /*
+                 * The basic parent/child communication broke, close
+                 * our socket
+                 */
+                close(state->child->sock);
+                state->child->sock = -1;
                 tevent_req_error(req, err);
                 return;
@@ -182 +189 @@
         *presponse = talloc_move(mem_ctx, &state->response);
         return 0;
+}
+
+static bool winbindd_child_busy(struct winbindd_child *child)
+{
+        return tevent_queue_length(child->queue) > 0;
+}
+
+static struct winbindd_child *find_idle_child(struct winbindd_domain *domain)
+{
+        int i;
+
+        for (i=0; i<lp_winbind_max_domain_connections(); i++) {
+                if (!winbindd_child_busy(&domain->children[i])) {
+                        return &domain->children[i];
+                }
+        }
+
+        return NULL;
+}
+
+struct winbindd_child *choose_domain_child(struct winbindd_domain *domain)
+{
+        struct winbindd_child *result;
+
+        result = find_idle_child(domain);
+        if (result != NULL) {
+                return result;
+        }
+        return &domain->children[rand() % lp_winbind_max_domain_connections()];
+}
+
+struct dcerpc_binding_handle *dom_child_handle(struct winbindd_domain *domain)
+{
+        struct winbindd_child *child;
+
+        child = choose_domain_child(domain);
+        return child->binding_handle;
 }
 
@@ -187 +231 @@
         struct tevent_context *ev;
         struct winbindd_domain *domain;
+        struct winbindd_child *child;
         struct winbindd_request *request;
         struct winbindd_request *init_req;
@@ -210 +255 @@
         }
 
+        state->child = choose_domain_child(domain);
+
         if (domain->initialized) {
-                subreq = wb_child_request_send(state, ev, &domain->child,
+                subreq = wb_child_request_send(state, ev, state->child,
                                                request);
                 if (tevent_req_nomem(subreq, req)) {
@@ -233 +280 @@
                 state->init_req->cmd = WINBINDD_INIT_CONNECTION;
                 fstrcpy(state->init_req->domain_name, domain->name);
-                state->init_req->data.init_conn.is_primary =
-                        domain->primary ? true : false;
+                state->init_req->data.init_conn.is_primary = domain->primary;
                 fstrcpy(state->init_req->data.init_conn.dcname, "");
 
-                subreq = wb_child_request_send(state, ev, &domain->child,
+                subreq = wb_child_request_send(state, ev, state->child,
                                                state->init_req);
                 if (tevent_req_nomem(subreq, req)) {
@@ -258 +304 @@
         fstrcpy(state->init_req->domain_name, domain->name);
 
-        subreq = wb_child_request_send(state, ev, &domain->child, request);
+        subreq = wb_child_request_send(state, ev, state->child, request);
         if (tevent_req_nomem(subreq, req)) {
                 return tevent_req_post(req, ev);
@@ -289 +335 @@
         TALLOC_FREE(response);
 
-        subreq = wb_child_request_send(state, state->ev, &state->domain->child,
+        subreq = wb_child_request_send(state, state->ev, state->child,
                                        state->init_req);
         if (tevent_req_nomem(subreq, req)) {
@@ -329 +375 @@
         TALLOC_FREE(response);
 
-        subreq = wb_child_request_send(state, state->ev, &state->domain->child,
+        subreq = wb_child_request_send(state, state->ev, state->child,
                                        state->request);
         if (tevent_req_nomem(subreq, req)) {
@@ -366 +412 @@
         *presponse = talloc_move(mem_ctx, &state->response);
         return 0;
-}
-
-struct domain_request_state {
-        struct winbindd_domain *domain;
-        struct winbindd_request *request;
-        struct winbindd_response *response;
-        void (*continuation)(void *private_data_data, bool success);
-        void *private_data_data;
-};
-
-static void async_domain_request_done(struct tevent_req *req);
-
-void async_domain_request(TALLOC_CTX *mem_ctx,
-                          struct winbindd_domain *domain,
-                          struct winbindd_request *request,
-                          struct winbindd_response *response,
-                          void (*continuation)(void *private_data_data, bool success),
-                          void *private_data_data)
-{
-        struct tevent_req *subreq;
-        struct domain_request_state *state;
-
-        state = TALLOC_P(mem_ctx, struct domain_request_state);
-        if (state == NULL) {
-                DEBUG(0, ("talloc failed\n"));
-                continuation(private_data_data, False);
-                return;
-        }
-
-        state->domain = domain;
-        state->request = request;
-        state->response = response;
-        state->continuation = continuation;
-        state->private_data_data = private_data_data;
-
-        subreq = wb_domain_request_send(state, winbind_event_context(),
-                                        domain, request);
-        if (subreq == NULL) {
-                DEBUG(5, ("wb_domain_request_send failed\n"));
-                continuation(private_data_data, false);
-                return;
-        }
-        tevent_req_set_callback(subreq, async_domain_request_done, state);
-}
-
-static void async_domain_request_done(struct tevent_req *req)
-{
-        struct domain_request_state *state = tevent_req_callback_data(
-                req, struct domain_request_state);
-        struct winbindd_response *response;
-        int ret, err;
-
-        ret = wb_domain_request_recv(req, state, &response, &err);
-        TALLOC_FREE(req);
-        if (ret == -1) {
-                DEBUG(5, ("wb_domain_request returned %s\n", strerror(err)));
-                state->continuation(state->private_data_data, false);
-                return;
-        }
-        *(state->response) = *response;
-        state->continuation(state->private_data_data, true);
-}
-
-static void recvfrom_child(void *private_data_data, bool success)
-{
-        struct winbindd_cli_state *state =
-                talloc_get_type_abort(private_data_data, struct winbindd_cli_state);
-        enum winbindd_result result = state->response->result;
-
-        /* This is an optimization: The child has written directly to the
-         * response buffer. The request itself is still in pending state,
-         * state that in the result code. */
-
-        state->response->result = WINBINDD_PENDING;
-
-        if ((!success) || (result != WINBINDD_OK)) {
-                request_error(state);
-                return;
-        }
-
-        request_ok(state);
-}
-
-void sendto_domain(struct winbindd_cli_state *state,
-                   struct winbindd_domain *domain)
-{
-        async_domain_request(state->mem_ctx, domain,
-                             state->request, state->response,
-                             recvfrom_child, state);
 }
 
@@ -483 +440 @@
         }
 
-        DEBUG(1 ,("child_process_request: unknown request fn number %d\n",
+        DEBUG(1, ("child_process_request: unknown request fn number %d\n",
                   (int)state->request->cmd));
         state->response->result = WINBINDD_ERROR;
@@ -494 +451 @@
 {
         if (logprefix && logname) {
+                char *logbase = NULL;
+
+                if (*lp_logfile()) {
+                        char *end = NULL;
+
+                        if (asprintf(&logbase, "%s", lp_logfile()) < 0) {
+                                smb_panic("Internal error: asprintf failed");
+                        }
+
+                        if ((end = strrchr_m(logbase, '/'))) {
+                                *end = '\0';
+                        }
+                } else {
+                        if (asprintf(&logbase, "%s", get_dyn_LOGFILEBASE()) < 0) {
+                                smb_panic("Internal error: asprintf failed");
+                        }
+                }
+
                 if (asprintf(&child->logfilename, "%s/%s-%s",
-                             get_dyn_LOGFILEBASE(), logprefix, logname) < 0) {
+                             logbase, logprefix, logname) < 0) {
+                        SAFE_FREE(logbase);
                         smb_panic("Internal error: asprintf failed");
                 }
+
+                SAFE_FREE(logbase);
         } else {
                 smb_panic("Internal error: logprefix == NULL && "
@@ -503 +481 @@
         }
 
+        child->sock = -1;
         child->domain = domain;
         child->table = table;
         child->queue = tevent_queue_create(NULL, "winbind_child");
         SMB_ASSERT(child->queue != NULL);
-        child->rpccli = wbint_rpccli_create(NULL, domain, child);
-        SMB_ASSERT(child->rpccli != NULL);
-}
-
-struct winbindd_child *children = NULL;
+        child->binding_handle = wbint_binding_handle(NULL, domain, child);
+        SMB_ASSERT(child->binding_handle != NULL);
+}
+
+static struct winbindd_child *winbindd_children = NULL;
 
 void winbind_child_died(pid_t pid)
@@ -517 +496 @@
         struct winbindd_child *child;
 
-        for (child = children; child != NULL; child = child->next) {
+        for (child = winbindd_children; child != NULL; child = child->next) {
                 if (child->pid == pid) {
                         break;
@@ -530 +509 @@
         /* This will be re-added in fork_domain_child() */
 
-        DLIST_REMOVE(children, child);
-
-        close(child->sock);
-        child->sock = -1;
+        DLIST_REMOVE(winbindd_children, child);
         child->pid = 0;
+
+        if (child->sock != -1) {
+                close(child->sock);
+                child->sock = -1;
+        }
 }
 
@@ -565 +546 @@
         debug_message(msg_ctx, private_data, MSG_DEBUG, server_id, data);
 
-        for (child = children; child != NULL; child = child->next) {
+        for (child = winbindd_children; child != NULL; child = child->next) {
 
                 DEBUG(10,("winbind_msg_debug: sending message to pid %u.\n",
@@ -610 +591 @@
         }
 
-        for (child = children; child != NULL; child = child->next) {
-                /* Don't send message to internal childs.  We've already
+        for (child = winbindd_children; child != NULL; child = child->next) {
+                /* Don't send message to internal children.  We've already
                    done so above. */
                 if (!child->domain || winbindd_internal_child(child)) {
@@ -685 +666 @@
         }
 
-        for (child = children; child != NULL; child = child->next) {
+        for (child = winbindd_children; child != NULL; child = child->next) {
                 /* Don't send message to internal childs. */
                 if (!child->domain || winbindd_internal_child(child)) {
@@ -783 +764 @@
         dump_event_list(winbind_event_context());
 
-        for (child = children; child != NULL; child = child->next) {
+        for (child = winbindd_children; child != NULL; child = child->next) {
 
                 DEBUG(10,("winbind_msg_dump_event_list: sending message to pid %u\n",
@@ -1191 +1172 @@
 }
 
-bool winbindd_reinit_after_fork(const char *logfilename)
+NTSTATUS winbindd_reinit_after_fork(const struct winbindd_child *myself,
+                                    const char *logfilename)
 {
         struct winbindd_domain *domain;
         struct winbindd_child *cl;
-
-        if (!NT_STATUS_IS_OK(reinit_after_fork(winbind_messaging_context(),
-                                               winbind_event_context(),
-                                               true))) {
+        NTSTATUS status;
+
+        status = reinit_after_fork(
+                winbind_messaging_context(),
+                winbind_event_context(),
+                procid_self(),
+                true);
+        if (!NT_STATUS_IS_OK(status)) {
                 DEBUG(0,("reinit_after_fork() failed\n"));
-                return false;
+                return status;
         }
 
@@ -1211 +1197 @@
 
         if (!winbindd_setup_sig_term_handler(false))
-                return false;
+                return NT_STATUS_NO_MEMORY;
         if (!winbindd_setup_sig_hup_handler(override_logfile ? NULL :
                                             logfilename))
-                return false;
+                return NT_STATUS_NO_MEMORY;
 
         /* Stop zombies in children */
@@ -1253 +1239 @@
 
         /* Destroy all possible events in child list. */
-        for (cl = children; cl != NULL; cl = cl->next) {
+        for (cl = winbindd_children; cl != NULL; cl = cl->next) {
                 TALLOC_FREE(cl->lockout_policy_event);
                 TALLOC_FREE(cl->machine_password_change_event);
@@ -1262 +1248 @@
                  */
                 cl->pid = (pid_t)0;
+
+                /*
+                 * Close service sockets to all other children
+                 */
+                if ((cl != myself) && (cl->sock != -1)) {
+                        close(cl->sock);
+                        cl->sock = -1;
+                }
         }
         /*
@@ -1282 +1276 @@
         cl->pid = (pid_t)0;
 
-        return true;
+        return NT_STATUS_OK;
 }
 
@@ -1302 +1296 @@
         struct winbindd_response response;
         struct winbindd_domain *primary_domain = NULL;
+        NTSTATUS status;
+        ssize_t nwritten;
 
         if (child->domain) {
@@ -1309 +1305 @@
                 DEBUG(10, ("fork_domain_child called without domain.\n"));
         }
-        child_domain = child->domain;
 
         if (socketpair(AF_UNIX, SOCK_STREAM, 0, fdpair) != 0) {
@@ -1331 +1326 @@
         if (child->pid != 0) {
                 /* Parent */
+                ssize_t nread;
+
                 close(fdpair[0]);
+
+                nread = read(fdpair[1], &status, sizeof(status));
+                if (nread != sizeof(status)) {
+                        DEBUG(1, ("fork_domain_child: Could not read child status: "
+                                  "nread=%d, error=%s\n", (int)nread,
+                                  strerror(errno)));
+                        close(fdpair[1]);
+                        return false;
+                }
+                if (!NT_STATUS_IS_OK(status)) {
+                        DEBUG(1, ("fork_domain_child: Child status is %s\n",
+                                  nt_errstr(status)));
+                        close(fdpair[1]);
+                        return false;
+                }
+
                 child->next = child->prev = NULL;
-                DLIST_ADD(children, child);
+                DLIST_ADD(winbindd_children, child);
                 child->sock = fdpair[1];
                 return True;
@@ -1339 +1352 @@
 
         /* Child */
+        child_domain = child->domain;
 
         DEBUG(10, ("Child process %d\n", (int)sys_getpid()));
@@ -1345 +1359 @@
         close(fdpair[1]);
 
-        if (!winbindd_reinit_after_fork(child->logfilename)) {
+        status = winbindd_reinit_after_fork(child, child->logfilename);
+
+        nwritten = write(state.sock, &status, sizeof(status));
+        if (nwritten != sizeof(status)) {
+                DEBUG(1, ("fork_domain_child: Could not write status: "
+                          "nwritten=%d, error=%s\n", (int)nwritten,
+                          strerror(errno)));
+                _exit(0);
+        }
+        if (!NT_STATUS_IS_OK(status)) {
+                DEBUG(1, ("winbindd_reinit_after_fork failed: %s\n",
+                          nt_errstr(status)));
                 _exit(0);
         }
@@ -1358 +1383 @@
         messaging_register(winbind_messaging_context(), NULL,
                            MSG_DEBUG, debug_message);
+        messaging_register(winbind_messaging_context(), NULL,
+                           MSG_WINBIND_IP_DROPPED,
+                           winbind_msg_ip_dropped);
+
 
         primary_domain = find_our_domain();
@@ -1369 +1398 @@
         if ( child->domain ) {
                 child->domain->startup = True;
-                child->domain->startup_time = time(NULL);
+                child->domain->startup_time = time_mono(NULL);
                 /* we can be in primary domain or in trusted domain
                  * If we are in trusted domain, set the primary domain
@@ -1377 +1406 @@
                         if (!(child->domain->primary)) {
                                 primary_domain->startup = True;
-                                primary_domain->startup_time = time(NULL);
+                                primary_domain->startup_time = time_mono(NULL);
                                 set_domain_online_request(primary_domain);
                         }
@@ -1433 +1462 @@
 
                 int ret;
-                fd_set r_fds;
-                fd_set w_fds;
-                int maxfd;
+                struct pollfd *pfds;
+                int num_pfds;
+                int timeout;
                 struct timeval t;
                 struct timeval *tp;
-                struct timeval now;
                 TALLOC_CTX *frame = talloc_stackframe();
                 struct iovec iov[2];
                 int iov_count;
-                NTSTATUS status;
-
-                if (run_events(winbind_event_context(), 0, NULL, NULL)) {
+
+                if (run_events_poll(winbind_event_context(), 0, NULL, 0)) {
                         TALLOC_FREE(frame);
                         continue;
                 }
 
-                GetTimeOfDay(&now);
-
                 if (child->domain && child->domain->startup &&
-                                (now.tv_sec > child->domain->startup_time + 30)) {
+                                (time_mono(NULL) > child->domain->startup_time + 30)) {
                         /* No longer in "startup" mode. */
                         DEBUG(10,("fork_domain_child: domain %s no longer in 'startup' mode.\n",
@@ -1459 +1484 @@
                 }
 
-                FD_ZERO(&r_fds);
-                FD_ZERO(&w_fds);
-
-                if (state.sock < 0 || state.sock >= FD_SETSIZE) {
-                        TALLOC_FREE(frame);
-                        perror("EBADF");
+                pfds = TALLOC_ZERO_P(talloc_tos(), struct pollfd);
+                if (pfds == NULL) {
+                        DEBUG(1, ("talloc failed\n"));
                         _exit(1);
                 }
 
-                FD_SET(state.sock, &r_fds);
-                maxfd = state.sock;
-
-                /*
-                 * Initialize this high as event_add_to_select_args()
-                 * uses a timeval_min() on this and next_event. Fix
-                 * from Roel van Meer <rolek@alt001.com>.
-                 */
-                t.tv_sec = 999999;
-                t.tv_usec = 0;
-
-                event_add_to_select_args(winbind_event_context(), &now,
-                                         &r_fds, &w_fds, &t, &maxfd);
+                pfds->fd = state.sock;
+                pfds->events = POLLIN|POLLHUP;
+                num_pfds = 1;
+
+                timeout = INT_MAX;
+
+                if (!event_add_to_poll_args(
+                            winbind_event_context(), talloc_tos(),
+                            &pfds, &num_pfds, &timeout)) {
+                        DEBUG(1, ("event_add_to_poll_args failed\n"));
+                        _exit(1);
+                }
                 tp = get_timed_events_timeout(winbind_event_context(), &t);
                 if (tp) {
@@ -1487 +1508 @@
                 }
 
-                ret = sys_select(maxfd + 1, &r_fds, &w_fds, NULL, tp);
-
-                if (run_events(winbind_event_context(), ret, &r_fds, &w_fds)) {
+                ret = sys_poll(pfds, num_pfds, timeout);
+
+                if (run_events_poll(winbind_event_context(), ret,
+                                    pfds, num_pfds)) {
                         /* We got a signal - continue. */
                         TALLOC_FREE(frame);
                         continue;
                 }
+
+                TALLOC_FREE(pfds);
 
                 if (ret == 0) {
@@ -1508 +1532 @@
 
                 if (ret == -1 && errno != EINTR) {
-                        DEBUG(0,("select error occured\n"));
+                        DEBUG(0,("poll error occured\n"));
                         TALLOC_FREE(frame);
-                        perror("select");
+                        perror("poll");
                         _exit(1);
                 }
@@ -1556 +1580 @@
         }
 }
+
+void winbind_msg_ip_dropped_parent(struct messaging_context *msg_ctx,
+                                   void *private_data,
+                                   uint32_t msg_type,
+                                   struct server_id server_id,
+                                   DATA_BLOB *data)
+{
+        struct winbindd_child *child;
+
+        winbind_msg_ip_dropped(msg_ctx, private_data, msg_type,
+                               server_id, data);
+
+
+        for (child = winbindd_children; child != NULL; child = child->next) {
+                messaging_send_buf(msg_ctx, pid_to_procid(child->pid),
+                                   msg_type, data->data, data->length);
+        }
+}