*/
bool connected;
- /*
- * we allow sync requests only, if the caller
- * did not pass an event context to cldap_socket_init()
- */
- struct {
- bool allow_poll;
- struct tevent_context *ctx;
- } event;
-
/* the queue for outgoing dgrams */
struct tevent_queue *send_queue;
/* what to do with incoming request packets */
struct {
+ struct tevent_context *ev;
void (*handler)(struct cldap_socket *,
void *private_data,
struct cldap_incoming *);
struct cldap_search_state *prev, *next;
struct {
+ struct tevent_context *ev;
struct cldap_socket *cldap;
} caller;
static bool cldap_recvfrom_setup(struct cldap_socket *c)
{
+ struct tevent_context *ev;
+
if (c->recv_subreq) {
return true;
}
return true;
}
- c->recv_subreq = tdgram_recvfrom_send(c, c->event.ctx, c->sock);
+ ev = c->incoming.ev;
+ if (ev == NULL) {
+ ev = c->searches.list->caller.ev;
+ }
+
+ c->recv_subreq = tdgram_recvfrom_send(c, ev, c->sock);
if (!c->recv_subreq) {
return false;
}
nomem:
in->recv_errno = ENOMEM;
error:
- status = map_nt_error_from_unix(in->recv_errno);
+ status = map_nt_error_from_unix_common(in->recv_errno);
nterror:
/* in connected mode the first pending search gets the error */
if (!c->connected) {
initialise a cldap_sock
*/
NTSTATUS cldap_socket_init(TALLOC_CTX *mem_ctx,
- struct tevent_context *ev,
const struct tsocket_address *local_addr,
const struct tsocket_address *remote_addr,
struct cldap_socket **_cldap)
struct tsocket_address *any = NULL;
NTSTATUS status;
int ret;
+ const char *fam = NULL;
+
+ if (local_addr == NULL && remote_addr == NULL) {
+ return NT_STATUS_INVALID_PARAMETER_MIX;
+ }
+
+ if (remote_addr) {
+ bool is_ipv4;
+ bool is_ipv6;
+
+ is_ipv4 = tsocket_address_is_inet(remote_addr, "ipv4");
+ is_ipv6 = tsocket_address_is_inet(remote_addr, "ipv6");
+
+ if (is_ipv4) {
+ fam = "ipv4";
+ } else if (is_ipv6) {
+ fam = "ipv6";
+ } else {
+ return NT_STATUS_INVALID_ADDRESS;
+ }
+ }
c = talloc_zero(mem_ctx, struct cldap_socket);
if (!c) {
goto nomem;
}
- if (!ev) {
- ev = tevent_context_init(c);
- if (!ev) {
- goto nomem;
+ if (!local_addr) {
+ /*
+ * Here we know the address family of the remote address.
+ */
+ if (fam == NULL) {
+ return NT_STATUS_INVALID_PARAMETER_MIX;
}
- c->event.allow_poll = true;
- }
- c->event.ctx = ev;
- if (!local_addr) {
- /* we use ipv4 here instead of ip, as otherwise we end
- up with a PF_INET6 socket, and sendto() for ipv4
- addresses will fail. That breaks cldap name
- resolution for winbind to IPv4 hosts. */
- ret = tsocket_address_inet_from_strings(c, "ipv4",
+ ret = tsocket_address_inet_from_strings(c, fam,
NULL, 0,
&any);
if (ret != 0) {
- status = map_nt_error_from_unix(errno);
+ status = map_nt_error_from_unix_common(errno);
goto nterror;
}
local_addr = any;
ret = tdgram_inet_udp_socket(local_addr, remote_addr,
c, &c->sock);
if (ret != 0) {
- status = map_nt_error_from_unix(errno);
+ status = map_nt_error_from_unix_common(errno);
goto nterror;
}
talloc_free(any);
setup a handler for incoming requests
*/
NTSTATUS cldap_set_incoming_handler(struct cldap_socket *c,
+ struct tevent_context *ev,
void (*handler)(struct cldap_socket *,
void *private_data,
struct cldap_incoming *),
return NT_STATUS_PIPE_CONNECTED;
}
- /* if sync requests are allowed, we don't allow an incoming handler */
- if (c->event.allow_poll) {
- return NT_STATUS_INVALID_PIPE_STATE;
- }
-
+ c->incoming.ev = ev;
c->incoming.handler = handler;
c->incoming.private_data = private_data;
return NT_STATUS_PIPE_CONNECTED;
}
+ if (cldap->incoming.ev == NULL) {
+ return NT_STATUS_INVALID_PIPE_STATE;
+ }
+
if (!io->dest) {
return NT_STATUS_INVALID_ADDRESS;
}
data_blob_free(&blob2);
subreq = tdgram_sendto_queue_send(state,
- cldap->event.ctx,
+ cldap->incoming.ev,
cldap->sock,
cldap->send_queue,
state->blob.data,
queue a cldap reply for send
*/
struct tevent_req *cldap_search_send(TALLOC_CTX *mem_ctx,
- struct cldap_socket *cldap,
- const struct cldap_search *io)
+ struct tevent_context *ev,
+ struct cldap_socket *cldap,
+ const struct cldap_search *io)
{
struct tevent_req *req, *subreq;
struct cldap_search_state *state = NULL;
return NULL;
}
ZERO_STRUCTP(state);
+ state->caller.ev = ev;
state->req = req;
state->caller.cldap = cldap;
state->message_id = -1;
state->request.delay % 1000000);
}
- if (!tevent_req_set_endtime(req, state->caller.cldap->event.ctx, end)) {
- tevent_req_nomem(NULL, req);
+ if (!tevent_req_set_endtime(req, state->caller.ev, end)) {
+ tevent_req_oom(req);
goto post;
}
subreq = tdgram_sendto_queue_send(state,
- state->caller.cldap->event.ctx,
+ state->caller.ev,
state->caller.cldap->sock,
state->caller.cldap->send_queue,
state->request.blob.data,
return req;
post:
- return tevent_req_post(req, cldap->event.ctx);
+ return tevent_req_post(req, state->caller.ev);
}
static void cldap_search_state_queue_done(struct tevent_req *subreq)
talloc_free(subreq);
if (ret == -1) {
NTSTATUS status;
- status = map_nt_error_from_unix(sys_errno);
+ status = map_nt_error_from_unix_common(sys_errno);
DLIST_REMOVE(state->caller.cldap->searches.list, state);
ZERO_STRUCT(state->caller.cldap);
tevent_req_nterror(req, status);
/* wait for incoming traffic */
if (!cldap_recvfrom_setup(state->caller.cldap)) {
- tevent_req_nomem(NULL, req);
+ tevent_req_oom(req);
return;
}
next = tevent_timeval_current_ofs(state->request.delay / 1000000,
state->request.delay % 1000000);
subreq = tevent_wakeup_send(state,
- state->caller.cldap->event.ctx,
+ state->caller.ev,
next);
if (tevent_req_nomem(subreq, req)) {
return;
}
subreq = tdgram_sendto_queue_send(state,
- state->caller.cldap->event.ctx,
+ state->caller.ev,
state->caller.cldap->sock,
state->caller.cldap->send_queue,
state->request.blob.data,
TALLOC_CTX *mem_ctx,
struct cldap_search *io)
{
+ TALLOC_CTX *frame;
struct tevent_req *req;
+ struct tevent_context *ev;
NTSTATUS status;
- if (!cldap->event.allow_poll) {
+ if (cldap->searches.list) {
+ return NT_STATUS_PIPE_BUSY;
+ }
+
+ if (cldap->incoming.handler) {
return NT_STATUS_INVALID_PIPE_STATE;
}
- if (cldap->searches.list) {
- return NT_STATUS_PIPE_BUSY;
+ frame = talloc_stackframe();
+
+ ev = tevent_context_init(frame);
+ if (ev == NULL) {
+ TALLOC_FREE(frame);
+ return NT_STATUS_NO_MEMORY;
}
- req = cldap_search_send(mem_ctx, cldap, io);
- NT_STATUS_HAVE_NO_MEMORY(req);
+ req = cldap_search_send(mem_ctx, ev, cldap, io);
+ if (req == NULL) {
+ TALLOC_FREE(frame);
+ return NT_STATUS_NO_MEMORY;
+ }
- if (!tevent_req_poll(req, cldap->event.ctx)) {
- talloc_free(req);
- return NT_STATUS_INTERNAL_ERROR;
+ if (!tevent_req_poll(req, ev)) {
+ status = map_nt_error_from_unix_common(errno);
+ TALLOC_FREE(frame);
+ return status;
}
status = cldap_search_recv(req, mem_ctx, io);
- talloc_free(req);
+ if (!NT_STATUS_IS_OK(status)) {
+ TALLOC_FREE(frame);
+ return status;
+ }
- return status;
+ TALLOC_FREE(frame);
+ return NT_STATUS_OK;
}
struct cldap_netlogon_state {
queue a cldap netlogon for send
*/
struct tevent_req *cldap_netlogon_send(TALLOC_CTX *mem_ctx,
- struct cldap_socket *cldap,
- const struct cldap_netlogon *io)
+ struct tevent_context *ev,
+ struct cldap_socket *cldap,
+ const struct cldap_netlogon *io)
{
struct tevent_req *req, *subreq;
struct cldap_netlogon_state *state;
state->search.in.timeout = 2;
state->search.in.retries = 2;
- subreq = cldap_search_send(state, cldap, &state->search);
+ subreq = cldap_search_send(state, ev, cldap, &state->search);
if (tevent_req_nomem(subreq, req)) {
goto post;
}
return req;
post:
- return tevent_req_post(req, cldap->event.ctx);
+ return tevent_req_post(req, ev);
}
static void cldap_netlogon_state_done(struct tevent_req *subreq)
TALLOC_CTX *mem_ctx,
struct cldap_netlogon *io)
{
+ TALLOC_CTX *frame;
struct tevent_req *req;
+ struct tevent_context *ev;
NTSTATUS status;
- if (!cldap->event.allow_poll) {
+ if (cldap->searches.list) {
+ return NT_STATUS_PIPE_BUSY;
+ }
+
+ if (cldap->incoming.handler) {
return NT_STATUS_INVALID_PIPE_STATE;
}
- if (cldap->searches.list) {
- return NT_STATUS_PIPE_BUSY;
+ frame = talloc_stackframe();
+
+ ev = tevent_context_init(frame);
+ if (ev == NULL) {
+ TALLOC_FREE(frame);
+ return NT_STATUS_NO_MEMORY;
}
- req = cldap_netlogon_send(mem_ctx, cldap, io);
- NT_STATUS_HAVE_NO_MEMORY(req);
+ req = cldap_netlogon_send(mem_ctx, ev, cldap, io);
+ if (req == NULL) {
+ TALLOC_FREE(frame);
+ return NT_STATUS_NO_MEMORY;
+ }
- if (!tevent_req_poll(req, cldap->event.ctx)) {
- talloc_free(req);
- return NT_STATUS_INTERNAL_ERROR;
+ if (!tevent_req_poll(req, ev)) {
+ status = map_nt_error_from_unix_common(errno);
+ TALLOC_FREE(frame);
+ return status;
}
status = cldap_netlogon_recv(req, mem_ctx, io);
- talloc_free(req);
+ if (!NT_STATUS_IS_OK(status)) {
+ TALLOC_FREE(frame);
+ return status;
+ }
- return status;
+ TALLOC_FREE(frame);
+ return NT_STATUS_OK;
}
git.samba.org / sfrench / samba-autobuild / .git / blobdiff