#include "messages.h"
#include "../lib/util/tevent_unix.h"
#include "lib/param/loadparm.h"
+#include "lib/util/sys_rw.h"
+#include "lib/util/sys_rw_data.h"
#undef DBGC_CLASS
#define DBGC_CLASS DBGC_WINBIND
extern bool override_logfile;
-extern struct winbindd_methods cache_methods;
static struct winbindd_child *winbindd_children = NULL;
/* Read some data from a client connection */
-static NTSTATUS child_read_request(struct winbindd_cli_state *state)
+static NTSTATUS child_read_request(int sock, struct winbindd_request *wreq)
{
NTSTATUS status;
- /* Read data */
-
- status = read_data(state->sock, (char *)state->request,
- sizeof(*state->request));
-
+ status = read_data_ntstatus(sock, (char *)wreq, sizeof(*wreq));
if (!NT_STATUS_IS_OK(status)) {
DEBUG(3, ("child_read_request: read_data failed: %s\n",
nt_errstr(status)));
return status;
}
- if (state->request->extra_len == 0) {
- state->request->extra_data.data = NULL;
+ if (wreq->extra_len == 0) {
+ wreq->extra_data.data = NULL;
return NT_STATUS_OK;
}
- DEBUG(10, ("Need to read %d extra bytes\n", (int)state->request->extra_len));
-
- state->request->extra_data.data =
- SMB_MALLOC_ARRAY(char, state->request->extra_len + 1);
+ DEBUG(10, ("Need to read %d extra bytes\n", (int)wreq->extra_len));
- if (state->request->extra_data.data == NULL) {
+ wreq->extra_data.data = SMB_MALLOC_ARRAY(char, wreq->extra_len + 1);
+ if (wreq->extra_data.data == NULL) {
DEBUG(0, ("malloc failed\n"));
return NT_STATUS_NO_MEMORY;
}
/* Ensure null termination */
- state->request->extra_data.data[state->request->extra_len] = '\0';
-
- status= read_data(state->sock, state->request->extra_data.data,
- state->request->extra_len);
+ wreq->extra_data.data[wreq->extra_len] = '\0';
+ status = read_data_ntstatus(sock, wreq->extra_data.data,
+ wreq->extra_len);
if (!NT_STATUS_IS_OK(status)) {
DEBUG(0, ("Could not read extra data: %s\n",
nt_errstr(status)));
return status;
}
+static NTSTATUS child_write_response(int sock, struct winbindd_response *wrsp)
+{
+ struct iovec iov[2];
+ int iov_count;
+
+ iov[0].iov_base = (void *)wrsp;
+ iov[0].iov_len = sizeof(struct winbindd_response);
+ iov_count = 1;
+
+ if (wrsp->length > sizeof(struct winbindd_response)) {
+ iov[1].iov_base = (void *)wrsp->extra_data.data;
+ iov[1].iov_len = wrsp->length-iov[0].iov_len;
+ iov_count = 2;
+ }
+
+ DEBUG(10, ("Writing %d bytes to parent\n", (int)wrsp->length));
+
+ if (write_data_iov(sock, iov, iov_count) != wrsp->length) {
+ DEBUG(0, ("Could not write result\n"));
+ return NT_STATUS_INVALID_HANDLE;
+ }
+
+ return NT_STATUS_OK;
+}
+
/*
* Do winbind child async request. This is not simply wb_simple_trans. We have
* to do the queueing ourselves because while a request is queued, the child
struct wb_child_request_state {
struct tevent_context *ev;
+ struct tevent_req *subreq;
struct winbindd_child *child;
struct winbindd_request *request;
struct winbindd_response *response;
void *private_data);
static void wb_child_request_done(struct tevent_req *subreq);
+static void wb_child_request_cleanup(struct tevent_req *req,
+ enum tevent_req_state req_state);
+
struct tevent_req *wb_child_request_send(TALLOC_CTX *mem_ctx,
struct tevent_context *ev,
struct winbindd_child *child,
tevent_req_oom(req);
return tevent_req_post(req, ev);
}
+
+ tevent_req_set_cleanup_fn(req, wb_child_request_cleanup);
+
return req;
}
return;
}
- subreq = wb_simple_trans_send(state, winbind_event_context(), NULL,
+ subreq = wb_simple_trans_send(state, server_event_context(), NULL,
state->child->sock, state->request);
if (tevent_req_nomem(subreq, req)) {
return;
}
+
+ state->subreq = subreq;
tevent_req_set_callback(subreq, wb_child_request_done, req);
tevent_req_set_endtime(req, state->ev, timeval_current_ofs(300, 0));
}
int ret, err;
ret = wb_simple_trans_recv(subreq, state, &state->response, &err);
- TALLOC_FREE(subreq);
+ /* Freeing the subrequest is deferred until the cleanup function,
+ * which has to know whether a subrequest exists, and consequently
+ * decide whether to shut down the pipe to the child process.
+ */
if (ret == -1) {
- /*
- * The basic parent/child communication broke, close
- * our socket
- */
- close(state->child->sock);
- state->child->sock = -1;
- DLIST_REMOVE(winbindd_children, state->child);
tevent_req_error(req, err);
return;
}
return 0;
}
-static bool winbindd_child_busy(struct winbindd_child *child)
+static void wb_child_request_cleanup(struct tevent_req *req,
+ enum tevent_req_state req_state)
{
- return tevent_queue_length(child->queue) > 0;
-}
+ struct wb_child_request_state *state =
+ tevent_req_data(req, struct wb_child_request_state);
-static struct winbindd_child *find_idle_child(struct winbindd_domain *domain)
-{
- int i;
+ if (state->subreq == NULL) {
+ /* nothing to cleanup */
+ return;
+ }
- for (i=0; i<lp_winbind_max_domain_connections(); i++) {
- if (!winbindd_child_busy(&domain->children[i])) {
- return &domain->children[i];
- }
+ TALLOC_FREE(state->subreq);
+
+ if (req_state == TEVENT_REQ_DONE) {
+ /* transmitted request and got response */
+ return;
}
- return NULL;
+ /*
+ * Failed to transmit and receive response, or request
+ * cancelled while being serviced.
+ * The basic parent/child communication broke, close
+ * our socket
+ */
+ close(state->child->sock);
+ state->child->sock = -1;
+ DLIST_REMOVE(winbindd_children, state->child);
}
struct winbindd_child *choose_domain_child(struct winbindd_domain *domain)
{
- struct winbindd_child *result;
+ struct winbindd_child *shortest = &domain->children[0];
+ struct winbindd_child *current;
+ int i;
+
+ for (i=0; i<lp_winbind_max_domain_connections(); i++) {
+ size_t shortest_len, current_len;
+
+ current = &domain->children[i];
+ current_len = tevent_queue_length(current->queue);
- result = find_idle_child(domain);
- if (result != NULL) {
- return result;
+ if (current_len == 0) {
+ /* idle child */
+ return current;
+ }
+
+ shortest_len = tevent_queue_length(shortest->queue);
+
+ if (current_len < shortest_len) {
+ shortest = current;
+ }
}
- return &domain->children[rand() % lp_winbind_max_domain_connections()];
+
+ return shortest;
}
struct dcerpc_binding_handle *dom_child_handle(struct winbindd_domain *domain)
}
messaging_send_buf(msg_ctx, *sender, MSG_WINBIND_ONLINESTATUS,
- (const uint8 *)message, strlen(message) + 1);
+ (const uint8_t *)message, strlen(message) + 1);
talloc_destroy(mem_ctx);
}
DEBUG(10,("winbind_msg_dump_event_list received\n"));
- dump_event_list(winbind_event_context());
+ DBG_WARNING("dump event list no longer implemented\n");
for (child = winbindd_children; child != NULL; child = child->next) {
struct winbindd_child *child =
(struct winbindd_child *)private_data;
TALLOC_CTX *mem_ctx = NULL;
- struct winbindd_methods *methods;
struct samr_DomInfo12 lockout_policy;
NTSTATUS result;
return;
}
- methods = child->domain->methods;
-
mem_ctx = talloc_init("account_lockout_policy_handler ctx");
if (!mem_ctx) {
result = NT_STATUS_NO_MEMORY;
} else {
- result = methods->lockout_policy(child->domain, mem_ctx, &lockout_policy);
+ result = wb_cache_lockout_policy(child->domain, mem_ctx,
+ &lockout_policy);
}
TALLOC_FREE(mem_ctx);
nt_errstr(result)));
}
- child->lockout_policy_event = tevent_add_timer(winbind_event_context(), NULL,
+ child->lockout_policy_event = tevent_add_timer(server_event_context(), NULL,
timeval_current_ofs(3600, 0),
account_lockout_policy_handler,
child);
struct timeval now,
void *private_data)
{
- struct messaging_context *msg_ctx = winbind_messaging_context();
+ struct messaging_context *msg_ctx = server_messaging_context();
struct winbindd_child *child =
(struct winbindd_child *)private_data;
struct rpc_pipe_client *netlogon_pipe = NULL;
+ struct netlogon_creds_cli_context *netlogon_creds_ctx = NULL;
NTSTATUS result;
struct timeval next_change;
return;
}
- result = cm_connect_netlogon(child->domain, &netlogon_pipe);
+ result = cm_connect_netlogon_secure(child->domain,
+ &netlogon_pipe,
+ &netlogon_creds_ctx);
if (!NT_STATUS_IS_OK(result)) {
DEBUG(10,("machine_password_change_handler: "
"failed to connect netlogon pipe: %s\n",
return;
}
- result = trust_pw_change(child->domain->conn.netlogon_creds,
+ result = trust_pw_change(netlogon_creds_ctx,
msg_ctx,
netlogon_pipe->binding_handle,
child->domain->name,
+ child->domain->dcname,
false); /* force */
DEBUG(10, ("machine_password_change_handler: "
"password was changed and we didn't know it. "
"Killing connections to domain %s\n",
child->domain->name));
- invalidate_cm_connection(&child->domain->conn);
+ invalidate_cm_connection(child->domain);
}
if (!calculate_next_machine_pwd_change(child->domain->name,
}
done:
- child->machine_password_change_event = tevent_add_timer(winbind_event_context(), NULL,
+ child->machine_password_change_event = tevent_add_timer(server_event_context(), NULL,
next_change,
machine_password_change_handler,
child);
DATA_BLOB *data)
{
DEBUG(5,("child_msg_dump_event_list received\n"));
-
- dump_event_list(winbind_event_context());
+ DBG_WARNING("dump_event_list no longer implemented\n");
}
NTSTATUS winbindd_reinit_after_fork(const struct winbindd_child *myself,
NTSTATUS status;
status = reinit_after_fork(
- winbind_messaging_context(),
- winbind_event_context(),
- true);
+ server_messaging_context(),
+ server_event_context(),
+ true, NULL);
if (!NT_STATUS_IS_OK(status)) {
DEBUG(0,("reinit_after_fork() failed\n"));
return status;
CatchChild();
/* Don't handle the same messages as our parent. */
- messaging_deregister(winbind_messaging_context(),
+ messaging_deregister(server_messaging_context(),
MSG_SMB_CONF_UPDATED, NULL);
- messaging_deregister(winbind_messaging_context(),
+ messaging_deregister(server_messaging_context(),
MSG_SHUTDOWN, NULL);
- messaging_deregister(winbind_messaging_context(),
+ messaging_deregister(server_messaging_context(),
MSG_WINBIND_OFFLINE, NULL);
- messaging_deregister(winbind_messaging_context(),
+ messaging_deregister(server_messaging_context(),
MSG_WINBIND_ONLINE, NULL);
- messaging_deregister(winbind_messaging_context(),
+ messaging_deregister(server_messaging_context(),
MSG_WINBIND_ONLINESTATUS, NULL);
- messaging_deregister(winbind_messaging_context(),
+ messaging_deregister(server_messaging_context(),
MSG_DUMP_EVENT_LIST, NULL);
- messaging_deregister(winbind_messaging_context(),
+ messaging_deregister(server_messaging_context(),
MSG_WINBIND_DUMP_DOMAIN_LIST, NULL);
- messaging_deregister(winbind_messaging_context(),
+ messaging_deregister(server_messaging_context(),
MSG_DEBUG, NULL);
- messaging_deregister(winbind_messaging_context(),
+ messaging_deregister(server_messaging_context(),
MSG_WINBIND_DOMAIN_OFFLINE, NULL);
- messaging_deregister(winbind_messaging_context(),
+ messaging_deregister(server_messaging_context(),
MSG_WINBIND_DOMAIN_ONLINE, NULL);
/* We have destroyed all events in the winbindd_event_context
struct child_handler_state *state =
(struct child_handler_state *)private_data;
NTSTATUS status;
- struct iovec iov[2];
- int iov_count;
/* fetch a request from the main daemon */
- status = child_read_request(&state->cli);
+ status = child_read_request(state->cli.sock, state->cli.request);
if (!NT_STATUS_IS_OK(status)) {
/* we lost contact with our parent */
SAFE_FREE(state->cli.request->extra_data.data);
- iov[0].iov_base = (void *)state->cli.response;
- iov[0].iov_len = sizeof(struct winbindd_response);
- iov_count = 1;
-
- if (state->cli.response->length >
- sizeof(struct winbindd_response)) {
- iov[1].iov_base =
- (void *)state->cli.response->extra_data.data;
- iov[1].iov_len = state->cli.response->length-iov[0].iov_len;
- iov_count = 2;
- }
-
- DEBUG(10, ("Writing %d bytes to parent\n",
- (int)state->cli.response->length));
-
- if (write_data_iov(state->cli.sock, iov, iov_count) !=
- state->cli.response->length) {
- DEBUG(0, ("Could not write result\n"));
+ status = child_write_response(state->cli.sock, state->cli.response);
+ if (!NT_STATUS_IS_OK(status)) {
exit(1);
}
}
_exit(0);
}
+ if (child_domain != NULL) {
+ setproctitle("domain child [%s]", child_domain->name);
+ } else if (child == idmap_child()) {
+ setproctitle("idmap child");
+ }
+
/* Handle online/offline messages. */
- messaging_register(winbind_messaging_context(), NULL,
+ messaging_register(server_messaging_context(), NULL,
MSG_WINBIND_OFFLINE, child_msg_offline);
- messaging_register(winbind_messaging_context(), NULL,
+ messaging_register(server_messaging_context(), NULL,
MSG_WINBIND_ONLINE, child_msg_online);
- messaging_register(winbind_messaging_context(), NULL,
+ messaging_register(server_messaging_context(), NULL,
MSG_DUMP_EVENT_LIST, child_msg_dump_event_list);
- messaging_register(winbind_messaging_context(), NULL,
+ messaging_register(server_messaging_context(), NULL,
MSG_DEBUG, debug_message);
- messaging_register(winbind_messaging_context(), NULL,
+ messaging_register(server_messaging_context(), NULL,
MSG_WINBIND_IP_DROPPED,
winbind_msg_ip_dropped);
}
child->lockout_policy_event = tevent_add_timer(
- winbind_event_context(), NULL, timeval_zero(),
+ server_event_context(), NULL, timeval_zero(),
account_lockout_policy_handler,
child);
}
if (calculate_next_machine_pwd_change(child->domain->name,
&next_change)) {
child->machine_password_change_event = tevent_add_timer(
- winbind_event_context(), NULL, next_change,
+ server_event_context(), NULL, next_change,
machine_password_change_handler,
child);
}
}
- fde = tevent_add_fd(winbind_event_context(), NULL, state.cli.sock,
+ fde = tevent_add_fd(server_event_context(), NULL, state.cli.sock,
TEVENT_FD_READ, child_handler, &state);
if (fde == NULL) {
DEBUG(1, ("tevent_add_fd failed\n"));
int ret;
TALLOC_CTX *frame = talloc_stackframe();
- ret = tevent_loop_once(winbind_event_context());
+ ret = tevent_loop_once(server_event_context());
if (ret != 0) {
DEBUG(1, ("tevent_loop_once failed: %s\n",
strerror(errno)));