sin/samba-mirror
1
0
Fork 0
mirror of https://github.com/samba-team/samba.git synced 2024-12-23 17:34:34 +03:00
Code

Convert async_connect to tevent_req

Browse Source
This commit is contained in:
Volker Lendecke 2009-02-22 19:49:18 +01:00
parent 70814474f5
commit 39976035eb
4 changed files with 93 additions and 63 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

54
lib/async_req/async_sock.c
View File

@ -22,6 +22,7 @@
#include "lib/tevent/tevent.h"
#include "lib/async_req/async_req.h"
#include "lib/async_req/async_sock.h"
#include "lib/util/tevent_unix.h"
#include <fcntl.h>
#ifndef TALLOC_FREE
@ -633,17 +634,18 @@ static void async_connect_connected(struct tevent_context *ev,
* connect in an async state. This will be reset when the request is finished.
*/
struct async_req *async_connect_send(TALLOC_CTX *mem_ctx,
struct tevent_context *ev,
int fd, const struct sockaddr *address,
socklen_t address_len)
struct tevent_req *async_connect_send(TALLOC_CTX *mem_ctx,
struct tevent_context *ev,
int fd, const struct sockaddr *address,
socklen_t address_len)
{
struct async_req *result;
struct tevent_req *result;
struct async_connect_state *state;
struct tevent_fd *fde;
if (!async_req_setup(mem_ctx, &result, &state,
struct async_connect_state)) {
result = tevent_req_create(
mem_ctx, &state, struct async_connect_state);
if (result == NULL) {
return NULL;
}
@ -664,8 +666,8 @@ struct async_req *async_connect_send(TALLOC_CTX *mem_ctx,
state->result = connect(fd, address, address_len);
if (state->result == 0) {
state->sys_errno = 0;
goto post_status;
errno = 0;
goto post_errno;
}
/**
@ -686,22 +688,20 @@ struct async_req *async_connect_send(TALLOC_CTX *mem_ctx,
fde = tevent_add_fd(ev, state, fd, TEVENT_FD_READ | TEVENT_FD_WRITE,
async_connect_connected, result);
if (fde == NULL) {
state->sys_errno = ENOMEM;
goto post_status;
errno = ENOMEM;
goto post_errno;
}
return result;
post_errno:
state->sys_errno = errno;
post_status:
fcntl(fd, F_SETFL, state->old_sockflags);
if (!async_post_error(result, ev, state->sys_errno)) {
goto fail;
if (state->sys_errno == 0) {
tevent_req_done(result);
} else {
tevent_req_error(result, state->sys_errno);
}
return result;
fail:
TALLOC_FREE(result);
return NULL;
return tevent_req_post(result, ev);
}
/**
@ -716,10 +716,10 @@ static void async_connect_connected(struct tevent_context *ev,
struct tevent_fd *fde, uint16_t flags,
void *priv)
{
struct async_req *req = talloc_get_type_abort(
priv, struct async_req);
struct tevent_req *req = talloc_get_type_abort(
priv, struct tevent_req);
struct async_connect_state *state = talloc_get_type_abort(
req->private_data, struct async_connect_state);
req->private_state, struct async_connect_state);
TALLOC_FREE(fde);
@ -743,27 +743,27 @@ static void async_connect_connected(struct tevent_context *ev,
DEBUG(10, ("connect returned %s\n", strerror(errno)));
fcntl(state->fd, F_SETFL, state->old_sockflags);
async_req_error(req, state->sys_errno);
tevent_req_error(req, state->sys_errno);
return;
}
state->sys_errno = 0;
async_req_done(req);
tevent_req_done(req);
}
int async_connect_recv(struct async_req *req, int *perrno)
int async_connect_recv(struct tevent_req *req, int *perrno)
{
struct async_connect_state *state = talloc_get_type_abort(
req->private_data, struct async_connect_state);
req->private_state, struct async_connect_state);
int err;
fcntl(state->fd, F_SETFL, state->old_sockflags);
if (async_req_is_errno(req, &err)) {
if (tevent_req_is_unix_error(req, &err)) {
*perrno = err;
return -1;
}
if (state->sys_errno == 0) {
return 0;
}

11
lib/async_req/async_sock.h
View File

@ -35,11 +35,12 @@ struct async_req *async_send(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
struct async_req *async_recv(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
int fd, void *buffer, size_t length,
int flags);
struct async_req *async_connect_send(TALLOC_CTX *mem_ctx,
struct tevent_context *ev,
int fd, const struct sockaddr *address,
socklen_t address_len);
int async_connect_recv(struct async_req *req, int *perrno);
struct tevent_req *async_connect_send(TALLOC_CTX *mem_ctx,
struct tevent_context *ev,
int fd, const struct sockaddr *address,
socklen_t address_len);
int async_connect_recv(struct tevent_req *req, int *perrno);
struct async_req *sendall_send(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
int fd, const void *buffer, size_t length,

29
source3/lib/util_sock.c
View File

@ -953,7 +953,7 @@ struct open_socket_out_state {
int wait_nsec;
};
static void open_socket_out_connected(struct async_req *subreq);
static void open_socket_out_connected(struct tevent_req *subreq);
static int open_socket_out_state_destructor(struct open_socket_out_state *s)
{
@ -974,7 +974,8 @@ struct async_req *open_socket_out_send(TALLOC_CTX *mem_ctx,
int timeout)
{
char addr[INET6_ADDRSTRLEN];
struct async_req *result, *subreq;
struct async_req *result;
struct tevent_req *subreq;
struct open_socket_out_state *state;
NTSTATUS status;
@ -1026,13 +1027,14 @@ struct async_req *open_socket_out_send(TALLOC_CTX *mem_ctx,
(struct sockaddr *)&state->ss,
state->salen);
if ((subreq == NULL)
|| !async_req_set_timeout(subreq, state->ev,
timeval_set(0, state->wait_nsec))) {
|| !tevent_req_set_endtime(
subreq, state->ev,
timeval_current_ofs(0, state->wait_nsec))) {
status = NT_STATUS_NO_MEMORY;
goto post_status;
}
subreq->async.fn = open_socket_out_connected;
subreq->async.priv = result;
subreq->async.private_data = result;
return result;
post_status:
@ -1045,18 +1047,18 @@ struct async_req *open_socket_out_send(TALLOC_CTX *mem_ctx,
return NULL;
}
static void open_socket_out_connected(struct async_req *subreq)
static void open_socket_out_connected(struct tevent_req *subreq)
{
struct async_req *req = talloc_get_type_abort(
subreq->async.priv, struct async_req);
subreq->async.private_data, struct async_req);
struct open_socket_out_state *state = talloc_get_type_abort(
req->private_data, struct open_socket_out_state);
int err;
int ret;
int sys_errno;
err = async_connect_recv(subreq, &sys_errno);
ret = async_connect_recv(subreq, &sys_errno);
TALLOC_FREE(subreq);
if (err == 0) {
if (ret == 0) {
async_req_done(req);
return;
}
@ -1083,13 +1085,14 @@ static void open_socket_out_connected(struct async_req *subreq)
if (async_req_nomem(subreq, req)) {
return;
}
if (!async_req_set_timeout(subreq, state->ev,
timeval_set(0, state->wait_nsec))) {
if (!tevent_req_set_endtime(
subreq, state->ev,
timeval_current_ofs(0, state->wait_nsec))) {
async_req_error(req, ENOMEM);
return;
}
subreq->async.fn = open_socket_out_connected;
subreq->async.priv = req;
subreq->async.private_data = req;
return;
}

62
source3/lib/wbclient.c
View File

@ -147,17 +147,30 @@ struct wb_context *wb_context_init(TALLOC_CTX *mem_ctx)
return result;
}
struct wb_connect_state {
int dummy;
};
static void wbc_connect_connected(struct tevent_req *subreq);
static struct async_req *wb_connect_send(TALLOC_CTX *mem_ctx,
struct tevent_context *ev,
struct wb_context *wb_ctx,
const char *dir)
struct tevent_context *ev,
struct wb_context *wb_ctx,
const char *dir)
{
struct async_req *req;
struct async_req *result;
struct tevent_req *subreq;
struct wb_connect_state *state;
struct sockaddr_un sunaddr;
struct stat st;
char *path = NULL;
wbcErr wbc_err;
if (!async_req_setup(mem_ctx, &result, &state,
struct wb_connect_state)) {
return NULL;
}
if (wb_ctx->fd != -1) {
close(wb_ctx->fd);
wb_ctx->fd = -1;
@ -205,33 +218,46 @@ static struct async_req *wb_connect_send(TALLOC_CTX *mem_ctx,
goto post_status;
}
req = async_connect_send(mem_ctx, ev, wb_ctx->fd,
(struct sockaddr *)&sunaddr,
sizeof(sunaddr));
if (req == NULL) {
subreq = async_connect_send(mem_ctx, ev, wb_ctx->fd,
(struct sockaddr *)&sunaddr,
sizeof(sunaddr));
if (subreq == NULL) {
goto nomem;
}
if (!async_req_set_timeout(req, ev, timeval_set(30, 0))) {
TALLOC_FREE(req);
subreq->async.fn = wbc_connect_connected;
subreq->async.private_data = result;
if (!tevent_req_set_endtime(subreq, ev, timeval_current_ofs(30, 0))) {
goto nomem;
}
return req;
return result;
nomem:
wbc_err = WBC_ERR_NO_MEMORY;
post_status:
req = async_req_new(mem_ctx);
if (req == NULL) {
return NULL;
if (async_post_error(result, ev, wbc_err)) {
return result;
}
if (async_post_error(req, ev, wbc_err)) {
return req;
}
TALLOC_FREE(req);
TALLOC_FREE(result);
return NULL;
}
static void wbc_connect_connected(struct tevent_req *subreq)
{
struct async_req *req = talloc_get_type_abort(
subreq->async.private_data, struct async_req);
int res, err;
res = async_connect_recv(subreq, &err);
TALLOC_FREE(subreq);
if (res == -1) {
async_req_error(req, map_wbc_err_from_errno(err));
return;
}
async_req_done(req);
}
static wbcErr wb_connect_recv(struct async_req *req)
{
return async_req_simple_recv_wbcerr(req);