#include "messages.h"
#include "../lib/util/tevent_unix.h"
#include "lib/param/loadparm.h"
-#include "lib/sys_rw.h"
-#include "lib/sys_rw_data.h"
+#include "lib/util/sys_rw.h"
+#include "lib/util/sys_rw_data.h"
#undef DBGC_CLASS
#define DBGC_CLASS DBGC_WINBIND
struct wb_child_request_state {
struct tevent_context *ev;
+ struct tevent_req *queue_subreq;
struct tevent_req *subreq;
struct winbindd_child *child;
struct winbindd_request *request;
static bool fork_domain_child(struct winbindd_child *child);
-static void wb_child_request_trigger(struct tevent_req *req,
- void *private_data);
+static void wb_child_request_waited(struct tevent_req *subreq);
static void wb_child_request_done(struct tevent_req *subreq);
+static void wb_child_request_orphaned(struct tevent_req *subreq);
static void wb_child_request_cleanup(struct tevent_req *req,
enum tevent_req_state req_state);
{
struct tevent_req *req;
struct wb_child_request_state *state;
+ struct tevent_req *subreq;
req = tevent_req_create(mem_ctx, &state,
struct wb_child_request_state);
state->child = child;
state->request = request;
- if (!tevent_queue_add(child->queue, ev, req,
- wb_child_request_trigger, NULL)) {
- tevent_req_oom(req);
+ subreq = tevent_queue_wait_send(state, ev, child->queue);
+ if (tevent_req_nomem(subreq, req)) {
return tevent_req_post(req, ev);
}
+ tevent_req_set_callback(subreq, wb_child_request_waited, req);
+ state->queue_subreq = subreq;
tevent_req_set_cleanup_fn(req, wb_child_request_cleanup);
return req;
}
-static void wb_child_request_trigger(struct tevent_req *req,
- void *private_data)
+static void wb_child_request_waited(struct tevent_req *subreq)
{
+ struct tevent_req *req = tevent_req_callback_data(
+ subreq, struct tevent_req);
struct wb_child_request_state *state = tevent_req_data(
req, struct wb_child_request_state);
- struct tevent_req *subreq;
+ bool ok;
+
+ ok = tevent_queue_wait_recv(subreq);
+ if (!ok) {
+ tevent_req_oom(req);
+ return;
+ }
+ /*
+ * We need to keep state->queue_subreq
+ * in order to block the queue.
+ */
+ subreq = NULL;
if ((state->child->sock == -1) && (!fork_domain_child(state->child))) {
tevent_req_error(req, errno);
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;
tevent_req_done(req);
}
+static void wb_child_request_orphaned(struct tevent_req *subreq)
+{
+ DBG_WARNING("cleanup orphaned subreq[%p]\n", subreq);
+ TALLOC_FREE(subreq);
+}
+
int wb_child_request_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx,
struct winbindd_response **presponse, int *err)
{
return;
}
+ if (req_state == TEVENT_REQ_RECEIVED) {
+ struct tevent_req *subreq = NULL;
+
+ /*
+ * Our caller gave up, but we need to keep
+ * the low level request (wb_simple_trans)
+ * in order to maintain the parent child protocol.
+ *
+ * We also need to keep the child queue blocked
+ * until we got the response from the child.
+ */
+
+ subreq = talloc_move(state->child->queue, &state->subreq);
+ talloc_move(subreq, &state->queue_subreq);
+ tevent_req_set_callback(subreq,
+ wb_child_request_orphaned,
+ NULL);
+
+ DBG_WARNING("keep orphaned subreq[%p]\n", subreq);
+ return;
+ }
+
TALLOC_FREE(state->subreq);
+ TALLOC_FREE(state->queue_subreq);
if (req_state == TEVENT_REQ_DONE) {
/* transmitted request and got response */
DLIST_REMOVE(winbindd_children, state->child);
}
-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)
+struct winbindd_child *choose_domain_child(struct winbindd_domain *domain)
{
+ struct winbindd_child *shortest = &domain->children[0];
+ struct winbindd_child *current;
int i;
for (i=0; i<lp_winbind_max_domain_connections(); i++) {
- if (!winbindd_child_busy(&domain->children[i])) {
- return &domain->children[i];
- }
- }
+ size_t shortest_len, current_len;
- return NULL;
-}
+ current = &domain->children[i];
+ current_len = tevent_queue_length(current->queue);
-struct winbindd_child *choose_domain_child(struct winbindd_domain *domain)
-{
- struct winbindd_child *result;
+ if (current_len == 0) {
+ /* idle child */
+ return current;
+ }
+
+ shortest_len = tevent_queue_length(shortest->queue);
- result = find_idle_child(domain);
- if (result != NULL) {
- return result;
+ 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)
{
TALLOC_CTX *mem_ctx;
const char *message;
- struct server_id *sender;
DEBUG(5,("winbind_msg_onlinestatus received.\n"));
- if (!data->data) {
- return;
- }
-
- sender = (struct server_id *)data->data;
-
mem_ctx = talloc_init("winbind_msg_onlinestatus");
if (mem_ctx == NULL) {
return;
return;
}
- messaging_send_buf(msg_ctx, *sender, MSG_WINBIND_ONLINESTATUS,
+ messaging_send_buf(msg_ctx, server_id, MSG_WINBIND_ONLINESTATUS,
(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) {
{
TALLOC_CTX *mem_ctx;
const char *message = NULL;
- struct server_id *sender = NULL;
const char *domain = NULL;
char *s = NULL;
NTSTATUS status;
DEBUG(5,("winbind_msg_dump_domain_list received.\n"));
- if (!data || !data->data) {
- return;
- }
-
- if (data->length < sizeof(struct server_id)) {
- return;
- }
-
mem_ctx = talloc_init("winbind_msg_dump_domain_list");
if (!mem_ctx) {
return;
}
- sender = (struct server_id *)data->data;
- if (data->length > sizeof(struct server_id)) {
- domain = (const char *)data->data+sizeof(struct server_id);
+ if (data->length > 0) {
+ domain = (const char *)data->data;
}
if (domain) {
return;
}
- messaging_send_buf(msg_ctx, *sender,
+ messaging_send_buf(msg_ctx, server_id,
MSG_WINBIND_DUMP_DOMAIN_LIST,
(const uint8_t *)message, strlen(message) + 1);
}
}
- status = messaging_send_buf(msg_ctx, *sender,
+ status = messaging_send_buf(msg_ctx, server_id,
MSG_WINBIND_DUMP_DOMAIN_LIST,
(uint8_t *)s, strlen(s) + 1);
if (!NT_STATUS_IS_OK(status)) {
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: "
}
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
_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)));