sin/samba-mirror
1
0
Fork 0
mirror of https://github.com/samba-team/samba.git synced 2025-08-03 04:22:09 +03:00
Code Activity

r5185: make all the events data structures private to events.c. This will

Browse Source 
make it possible to add optimisations to the events code such as
keeping the next timed event in a sorted list, and using epoll for
file descriptor events.

I also removed the loop events code, as it wasn't being used anywhere,
and changed timed events to always be one-shot (as adding a new timed
event in the event handler is so easy to do if needed)
(This used to be commit d7b4b6de51)
This commit is contained in:
Andrew Tridgell
2005-02-03 02:35:52 +00:00
committed by Gerald (Jerry) Carter
parent 1774b36c14
commit 66170ef8b3
33 changed files with 299 additions and 351 deletions
Download Patch File Download Diff File Expand all files Collapse all files

98
source4/include/events.h
View File

@ -1,7 +1,9 @@
/* /*
Unix SMB/CIFS implementation. Unix SMB/CIFS implementation.
main select loop and event handling
Copyright (C) Andrew Tridgell 2003 generalised event loop handling
Copyright (C) Andrew Tridgell 2005
This program is free software; you can redistribute it and/or modify This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by it under the terms of the GNU General Public License as published by
@ -18,72 +20,44 @@
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/ */
/* struct event_context;
please read the comments in events.c before modifying struct fd_event;
*/ struct timed_event;
struct event_context { /* event handler types */
/* list of filedescriptor events */ typedef void (*event_fd_handler_t)(struct event_context *, struct fd_event *,
struct fd_event { struct timeval , uint16_t , void *);
struct event_context *event_ctx; typedef void (*event_timed_handler_t)(struct event_context *, struct timed_event *,
struct fd_event *next, *prev; struct timeval , void *);
int fd;
uint16_t flags; /* see EVENT_FD_* flags */
void (*handler)(struct event_context *ev, struct fd_event *fde,
struct timeval t, uint16_t flags);
void *private;
} *fd_events;
/* list of timed events */ struct event_context *event_context_init(TALLOC_CTX *mem_ctx);
struct timed_event {
struct event_context *event_ctx;
struct timed_event *next, *prev;
struct timeval next_event;
void (*handler)(struct event_context *ev, struct timed_event *te,
struct timeval t);
void *private;
} *timed_events;
/* list of loop events - called on each select() */ struct fd_event *event_add_fd(struct event_context *ev, TALLOC_CTX *mem_ctx,
struct loop_event { int fd, uint16_t flags, event_fd_handler_t handler,
struct event_context *event_ctx; void *private);
struct loop_event *next, *prev;
void (*handler)(struct event_context *ev, struct loop_event *le,
struct timeval t);
void *private;
} *loop_events;
/* list of signal events */ struct timed_event *event_add_timed(struct event_context *ev, TALLOC_CTX *mem_ctx,
struct signal_event { struct timeval next_event,
struct event_context *event_ctx; event_timed_handler_t handler,
struct signal_event *next, *prev; void *private);
int signum;
void (*handler)(struct event_context *ev, struct signal_event *se, int signum, void *sigarg);
void *private;
} *signal_events;
/* the maximum file descriptor number in fd_events */ int event_loop_once(struct event_context *ev);
int maxfd; int event_loop_wait(struct event_context *ev);
/* information for exiting from the event loop */ uint16_t event_fd_flags(struct fd_event *fde);
struct { void event_fd_setflags(struct fd_event *fde, uint16_t flags);
BOOL exit_now;
int code;
} exit;
/* This is the talloc parent for all concrete event structures in this /* bits for file descriptor event flags */
* event context. This makes merging easy. */
void *events;
/* this is changed by the destructors for any event type. It
is used to detect event destruction by event handlers,
which means the code that is calling all event handles
needs to assume that the linked list is no longer valid
*/
uint32_t destruction_count;
};
/* bits for fd_event.flags */
#define EVENT_FD_READ 1 #define EVENT_FD_READ 1
#define EVENT_FD_WRITE 2 #define EVENT_FD_WRITE 2
#define EVENT_FD_WRITEABLE(fde) \
event_fd_setflags(fde, event_fd_flags(fde) | EVENT_FD_WRITE)
#define EVENT_FD_READABLE(fde) \
event_fd_setflags(fde, event_fd_flags(fde) | EVENT_FD_READ)
#define EVENT_FD_NOT_WRITEABLE(fde) \
event_fd_setflags(fde, event_fd_flags(fde) & ~EVENT_FD_WRITE)
#define EVENT_FD_NOT_READABLE(fde) \
event_fd_setflags(fde, event_fd_flags(fde) & ~EVENT_FD_WRITE)

4
source4/ldap_server/ldap_server.c
View File

@ -415,7 +415,7 @@ static void ldapsrv_recv(struct stream_connection *conn, struct timeval t,
} }
if ((ldap_conn->out_buffer.length > 0)||(ldap_conn->sasl_out_buffer.length > 0)) { if ((ldap_conn->out_buffer.length > 0)||(ldap_conn->sasl_out_buffer.length > 0)) {
conn->event.fde->flags |= EVENT_FD_WRITE; EVENT_FD_WRITEABLE(conn->event.fde);
} }
return; return;
@ -437,7 +437,7 @@ static void ldapsrv_send(struct stream_connection *conn, struct timeval t,
} }
if (ldap_conn->out_buffer.length == 0 && ldap_conn->sasl_out_buffer.length == 0) { if (ldap_conn->out_buffer.length == 0 && ldap_conn->sasl_out_buffer.length == 0) {
conn->event.fde->flags &= ~EVENT_FD_WRITE; EVENT_FD_NOT_WRITEABLE(conn->event.fde);
} }
return; return;

10
source4/lib/basic.mk
View File

@ -32,6 +32,15 @@ ADD_OBJ_FILES = \
# End SUBSYSTEM LIBCRYPTO # End SUBSYSTEM LIBCRYPTO
############################## ##############################
##############################
# Start SUBSYSTEM LIBEVENTS
[SUBSYSTEM::LIBEVENTS]
NOPROTO = YES
INIT_OBJ_FILES = lib/events.o
REQUIRED_SUBSYSTEMS = LIBTALLOC
# End SUBSYSTEM LIBEVENTS
##############################
############################## ##############################
# Start SUBSYSTEM LIBBASIC # Start SUBSYSTEM LIBBASIC
[SUBSYSTEM::LIBBASIC] [SUBSYSTEM::LIBBASIC]
@ -62,7 +71,6 @@ ADD_OBJ_FILES = \
lib/pam_errors.o \ lib/pam_errors.o \
intl/lang_tdb.o \ intl/lang_tdb.o \
lib/mutex.o \ lib/mutex.o \
lib/events.o \
lib/server_mutex.o \ lib/server_mutex.o \
lib/idtree.o \ lib/idtree.o \
lib/unix_privs.o \ lib/unix_privs.o \

187
source4/lib/events.c
View File

@ -26,7 +26,7 @@
register one of the possible event types and implement that event register one of the possible event types and implement that event
somewhere else. somewhere else.
There are 4 types of event handling that are handled in this module: There are 2 types of event handling that are handled in this module:
1) a file descriptor becoming readable or writeable. This is mostly 1) a file descriptor becoming readable or writeable. This is mostly
used for network sockets, but can be used for any type of file used for network sockets, but can be used for any type of file
@ -41,15 +41,6 @@
like. When they are called the handler can choose to set the time like. When they are called the handler can choose to set the time
for the next event. If next_event is not set then the event is removed. for the next event. If next_event is not set then the event is removed.
3) an event that happens every time through the select loop. These
sorts of events should be very fast, as they will occur a
lot. Mostly used for things like destroying a talloc context or
checking a signal flag.
4) an event triggered by a signal. These can be one shot or
repeated. You can have more than one handler registered for a
single signal if you want to.
To setup a set of events you first need to create a event_context To setup a set of events you first need to create a event_context
structure using the function event_context_init(); This returns a structure using the function event_context_init(); This returns a
'struct event_context' that you use in all subsequent calls. 'struct event_context' that you use in all subsequent calls.
@ -59,8 +50,7 @@
Finally, you call event_loop_wait() to block waiting for one of the Finally, you call event_loop_wait() to block waiting for one of the
events to occor. In normal operation event_loop_wait() will loop events to occor. In normal operation event_loop_wait() will loop
forever, unless you call event_loop_exit() from inside one of your forever.
handler functions.
*/ */
@ -70,6 +60,46 @@
#include "dlinklist.h" #include "dlinklist.h"
#include "events.h" #include "events.h"
/*
please read the comments in events.c before modifying
*/
struct event_context {
/* list of filedescriptor events */
struct fd_event {
struct event_context *event_ctx;
struct fd_event *next, *prev;
int fd;
uint16_t flags; /* see EVENT_FD_* flags */
event_fd_handler_t handler;
void *private;
} *fd_events;
/* list of timed events */
struct timed_event {
struct event_context *event_ctx;
struct timed_event *next, *prev;
struct timeval next_event;
event_timed_handler_t handler;
void *private;
} *timed_events;
/* the maximum file descriptor number in fd_events */
int maxfd;
/* information for exiting from the event loop */
int exit_code;
/* this is changed by the destructors for any event type. It
is used to detect event destruction by event handlers,
which means the code that is calling all event handles
needs to assume that the linked list is no longer valid
*/
uint32_t destruction_count;
};
/* /*
create a event_context structure. This must be the first events create a event_context structure. This must be the first events
call, and all subsequent calls pass this event_context as the first call, and all subsequent calls pass this event_context as the first
@ -82,20 +112,9 @@ struct event_context *event_context_init(TALLOC_CTX *mem_ctx)
ev = talloc_zero(mem_ctx, struct event_context); ev = talloc_zero(mem_ctx, struct event_context);
if (!ev) return NULL; if (!ev) return NULL;
ev->events = talloc_new(ev);
return ev; return ev;
} }
/*
destroy an events context, also destroying any remaining events
*/
void event_context_destroy(struct event_context *ev)
{
talloc_free(ev);
}
/* /*
recalculate the maxfd recalculate the maxfd
*/ */
@ -131,17 +150,25 @@ static int event_fd_destructor(void *ptr)
add a fd based event add a fd based event
return NULL on failure (memory allocation error) return NULL on failure (memory allocation error)
*/ */
struct fd_event *event_add_fd(struct event_context *ev, struct fd_event *e0, struct fd_event *event_add_fd(struct event_context *ev, TALLOC_CTX *mem_ctx,
TALLOC_CTX *mem_ctx) int fd, uint16_t flags, event_fd_handler_t handler,
void *private)
{ {
struct fd_event *e = talloc(ev->events, struct fd_event); struct fd_event *e = talloc(ev, struct fd_event);
if (!e) return NULL; if (!e) return NULL;
*e = *e0;
DLIST_ADD(ev->fd_events, e);
e->event_ctx = ev; e->event_ctx = ev;
e->fd = fd;
e->flags = flags;
e->handler = handler;
e->private = private;
DLIST_ADD(ev->fd_events, e);
if (e->fd > ev->maxfd) { if (e->fd > ev->maxfd) {
ev->maxfd = e->fd; ev->maxfd = e->fd;
} }
talloc_set_destructor(e, event_fd_destructor); talloc_set_destructor(e, event_fd_destructor);
if (mem_ctx) { if (mem_ctx) {
talloc_steal(mem_ctx, e); talloc_steal(mem_ctx, e);
@ -150,6 +177,25 @@ struct fd_event *event_add_fd(struct event_context *ev, struct fd_event *e0,
} }
/*
return the fd event flags
*/
uint16_t event_fd_flags(struct fd_event *fde)
{
return fde->flags;
}
/*
set the fd event flags
*/
void event_fd_setflags(struct fd_event *fde, uint16_t flags)
{
fde->flags = flags;
}
/*
destroy a timed event
*/
static int event_timed_destructor(void *ptr) static int event_timed_destructor(void *ptr)
{ {
struct timed_event *te = talloc_get_type(ptr, struct timed_event); struct timed_event *te = talloc_get_type(ptr, struct timed_event);
@ -162,13 +208,19 @@ static int event_timed_destructor(void *ptr)
add a timed event add a timed event
return NULL on failure (memory allocation error) return NULL on failure (memory allocation error)
*/ */
struct timed_event *event_add_timed(struct event_context *ev, struct timed_event *e0, struct timed_event *event_add_timed(struct event_context *ev, TALLOC_CTX *mem_ctx,
TALLOC_CTX *mem_ctx) struct timeval next_event,
event_timed_handler_t handler,
void *private)
{ {
struct timed_event *e = talloc(ev->events, struct timed_event); struct timed_event *e = talloc(ev, struct timed_event);
if (!e) return NULL; if (!e) return NULL;
*e = *e0;
e->event_ctx = ev; e->event_ctx = ev;
e->next_event = next_event;
e->handler = handler;
e->private = private;
DLIST_ADD(ev->timed_events, e); DLIST_ADD(ev->timed_events, e);
talloc_set_destructor(e, event_timed_destructor); talloc_set_destructor(e, event_timed_destructor);
if (mem_ctx) { if (mem_ctx) {
@ -177,42 +229,6 @@ struct timed_event *event_add_timed(struct event_context *ev, struct timed_event
return e; return e;
} }
static int event_loop_destructor(void *ptr)
{
struct loop_event *le = talloc_get_type(ptr, struct loop_event);
DLIST_REMOVE(le->event_ctx->loop_events, le);
le->event_ctx->destruction_count++;
return 0;
}
/*
add a loop event
return NULL on failure (memory allocation error)
*/
struct loop_event *event_add_loop(struct event_context *ev, struct loop_event *e0,
TALLOC_CTX *mem_ctx)
{
struct loop_event *e = talloc(ev->events, struct loop_event);
if (!e) return NULL;
*e = *e0;
e->event_ctx = ev;
DLIST_ADD(ev->loop_events, e);
talloc_set_destructor(e, event_loop_destructor);
if (mem_ctx) {
talloc_steal(mem_ctx, e);
}
return e;
}
/*
tell the event loop to exit with the specified code
*/
void event_loop_exit(struct event_context *ev, int code)
{
ev->exit.exit_now = True;
ev->exit.code = code;
}
/* /*
do a single event loop using the events defined in ev this function do a single event loop using the events defined in ev this function
*/ */
@ -220,23 +236,11 @@ int event_loop_once(struct event_context *ev)
{ {
fd_set r_fds, w_fds; fd_set r_fds, w_fds;
struct fd_event *fe; struct fd_event *fe;
struct loop_event *le;
struct timed_event *te, *te_next; struct timed_event *te, *te_next;
int selrtn; int selrtn;
struct timeval tval, t, *tvalp=NULL; struct timeval tval, t, *tvalp;
uint32_t destruction_count = ev->destruction_count; uint32_t destruction_count = ev->destruction_count;
t = timeval_current();
/* the loop events are called on each loop. Be careful to allow the
event to remove itself */
for (le=ev->loop_events;le;) {
struct loop_event *next = le->next;
le->handler(ev, le, t);
if (destruction_count != ev->destruction_count) break;
le = next;
}
FD_ZERO(&r_fds); FD_ZERO(&r_fds);
FD_ZERO(&w_fds); FD_ZERO(&w_fds);
@ -252,9 +256,8 @@ int event_loop_once(struct event_context *ev)
fe = next; fe = next;
} }
/* start with a reasonable max timeout */ tvalp = NULL;
tval.tv_sec = 0; t = timeval_current();
tval.tv_usec = 0;
/* work out the right timeout for all timed events */ /* work out the right timeout for all timed events */
for (te=ev->timed_events;te;te=te_next) { for (te=ev->timed_events;te;te=te_next) {
@ -301,7 +304,7 @@ int event_loop_once(struct event_context *ev)
the event, so this must be a bug. This is a the event, so this must be a bug. This is a
fatal error. */ fatal error. */
DEBUG(0,("EBADF on event_loop_once - exiting\n")); DEBUG(0,("EBADF on event_loop_once - exiting\n"));
ev->exit.code = EBADF; ev->exit_code = EBADF;
return -1; return -1;
} }
@ -314,7 +317,7 @@ int event_loop_once(struct event_context *ev)
if (FD_ISSET(fe->fd, &r_fds)) flags |= EVENT_FD_READ; if (FD_ISSET(fe->fd, &r_fds)) flags |= EVENT_FD_READ;
if (FD_ISSET(fe->fd, &w_fds)) flags |= EVENT_FD_WRITE; if (FD_ISSET(fe->fd, &w_fds)) flags |= EVENT_FD_WRITE;
if (flags) { if (flags) {
fe->handler(ev, fe, t, flags); fe->handler(ev, fe, t, flags, fe->private);
if (destruction_count != ev->destruction_count) { if (destruction_count != ev->destruction_count) {
break; break;
} }
@ -328,7 +331,7 @@ int event_loop_once(struct event_context *ev)
struct timed_event *next = te->next; struct timed_event *next = te->next;
if (timeval_compare(&te->next_event, &t) >= 0) { if (timeval_compare(&te->next_event, &t) >= 0) {
te->next_event = timeval_zero(); te->next_event = timeval_zero();
te->handler(ev, te, t); te->handler(ev, te, t, te->private);
if (destruction_count != ev->destruction_count) { if (destruction_count != ev->destruction_count) {
break; break;
} }
@ -348,16 +351,14 @@ int event_loop_once(struct event_context *ev)
*/ */
int event_loop_wait(struct event_context *ev) int event_loop_wait(struct event_context *ev)
{ {
ZERO_STRUCT(ev->exit); ev->exit_code = 0;
ev->maxfd = EVENT_INVALID_MAXFD; ev->maxfd = EVENT_INVALID_MAXFD;
ev->exit.exit_now = False; while (ev->fd_events && ev->exit_code == 0) {
while (ev->fd_events && !ev->exit.exit_now) {
if (event_loop_once(ev) != 0) { if (event_loop_once(ev) != 0) {
break; break;
} }
} }
return ev->exit.code; return ev->exit_code;
} }

76
source4/lib/messaging/messaging.c
View File

@ -122,9 +122,9 @@ static void messaging_dispatch(struct messaging_context *msg, struct messaging_r
handle IO for a single message handle IO for a single message
*/ */
static void messaging_recv_handler(struct event_context *ev, struct fd_event *fde, static void messaging_recv_handler(struct event_context *ev, struct fd_event *fde,
struct timeval t, uint16_t flags) struct timeval t, uint16_t flags, void *private)
{ {
struct messaging_rec *rec = fde->private; struct messaging_rec *rec = talloc_get_type(private, struct messaging_rec);
struct messaging_context *msg = rec->msg; struct messaging_context *msg = rec->msg;
NTSTATUS status; NTSTATUS status;
@ -192,12 +192,12 @@ static void messaging_recv_handler(struct event_context *ev, struct fd_event *fd
handle a new incoming connection handle a new incoming connection
*/ */
static void messaging_listen_handler(struct event_context *ev, struct fd_event *fde, static void messaging_listen_handler(struct event_context *ev, struct fd_event *fde,
struct timeval t, uint16_t flags) struct timeval t, uint16_t flags, void *private)
{ {
struct messaging_context *msg = fde->private; struct messaging_context *msg = talloc_get_type(private,
struct messaging_context);
struct messaging_rec *rec; struct messaging_rec *rec;
NTSTATUS status; NTSTATUS status;
struct fd_event fde2;
rec = talloc(msg, struct messaging_rec); rec = talloc(msg, struct messaging_rec);
if (rec == NULL) { if (rec == NULL) {
@ -210,17 +210,12 @@ static void messaging_listen_handler(struct event_context *ev, struct fd_event *
} }
talloc_steal(rec, rec->sock); talloc_steal(rec, rec->sock);
rec->msg = msg; rec->msg = msg;
rec->ndone = 0; rec->ndone = 0;
rec->header.length = 0; rec->header.length = 0;
rec->path = msg->path; rec->path = msg->path;
rec->fde = event_add_fd(msg->event.ev, rec, socket_get_fd(rec->sock),
fde2.private = rec; EVENT_FD_READ, messaging_recv_handler, rec);
fde2.fd = socket_get_fd(rec->sock);
fde2.flags = EVENT_FD_READ;
fde2.handler = messaging_recv_handler;
rec->fde = event_add_fd(msg->event.ev, &fde2, rec);
} }
/* /*
@ -262,9 +257,9 @@ void messaging_deregister(struct messaging_context *msg, uint32_t msg_type, void
handle IO for sending a message handle IO for sending a message
*/ */
static void messaging_send_handler(struct event_context *ev, struct fd_event *fde, static void messaging_send_handler(struct event_context *ev, struct fd_event *fde,
struct timeval t, uint16_t flags) struct timeval t, uint16_t flags, void *private)
{ {
struct messaging_rec *rec = fde->private; struct messaging_rec *rec = talloc_get_type(private, struct messaging_rec);
NTSTATUS status; NTSTATUS status;
if (rec->ndone < sizeof(rec->header)) { if (rec->ndone < sizeof(rec->header)) {
@ -330,17 +325,18 @@ static NTSTATUS try_connect(struct messaging_rec *rec)
when the servers listen queue is full we use this to backoff the message when the servers listen queue is full we use this to backoff the message
*/ */
static void messaging_backoff_handler(struct event_context *ev, struct timed_event *te, static void messaging_backoff_handler(struct event_context *ev, struct timed_event *te,
struct timeval t) struct timeval t, void *private)
{ {
struct messaging_rec *rec = te->private; struct messaging_rec *rec = talloc_get_type(private, struct messaging_rec);
struct messaging_context *msg = rec->msg; struct messaging_context *msg = rec->msg;
NTSTATUS status; NTSTATUS status;
struct fd_event fde;
status = try_connect(rec); status = try_connect(rec);
if (NT_STATUS_EQUAL(status, STATUS_MORE_ENTRIES)) { if (NT_STATUS_EQUAL(status, STATUS_MORE_ENTRIES)) {
/* backoff again */ /* backoff again */
te->next_event = timeval_add(&t, 0, MESSAGING_BACKOFF); event_add_timed(msg->event.ev, rec,
timeval_add(&t, 0, MESSAGING_BACKOFF),
messaging_backoff_handler, rec);
return; return;
} }
@ -351,14 +347,8 @@ static void messaging_backoff_handler(struct event_context *ev, struct timed_eve
return; return;
} }
fde.private = rec; rec->fde = event_add_fd(msg->event.ev, rec, socket_get_fd(rec->sock),
fde.fd = socket_get_fd(rec->sock); EVENT_FD_WRITE, messaging_send_handler, rec);
fde.flags = EVENT_FD_WRITE;
fde.handler = messaging_send_handler;
rec->fde = event_add_fd(msg->event.ev, &fde, rec);
messaging_send_handler(msg->event.ev, rec->fde, timeval_zero(), EVENT_FD_WRITE);
} }
@ -369,7 +359,6 @@ NTSTATUS messaging_send(struct messaging_context *msg, uint32_t server, uint32_t
{ {
struct messaging_rec *rec; struct messaging_rec *rec;
NTSTATUS status; NTSTATUS status;
struct fd_event fde;
rec = talloc(msg, struct messaging_rec); rec = talloc(msg, struct messaging_rec);
if (rec == NULL) { if (rec == NULL) {
@ -401,11 +390,9 @@ NTSTATUS messaging_send(struct messaging_context *msg, uint32_t server, uint32_t
status = try_connect(rec); status = try_connect(rec);
if (NT_STATUS_EQUAL(status, STATUS_MORE_ENTRIES)) { if (NT_STATUS_EQUAL(status, STATUS_MORE_ENTRIES)) {
/* backoff on this message - the servers listen queue is full */ /* backoff on this message - the servers listen queue is full */
struct timed_event te; event_add_timed(msg->event.ev, rec,
te.next_event = timeval_current_ofs(0, MESSAGING_BACKOFF); timeval_current_ofs(0, MESSAGING_BACKOFF),
te.handler = messaging_backoff_handler; messaging_backoff_handler, rec);
te.private = rec;
event_add_timed(msg->event.ev, &te, rec);
return NT_STATUS_OK; return NT_STATUS_OK;
} }
@ -414,14 +401,8 @@ NTSTATUS messaging_send(struct messaging_context *msg, uint32_t server, uint32_t
return status; return status;
} }
fde.private = rec; rec->fde = event_add_fd(msg->event.ev, rec, socket_get_fd(rec->sock),
fde.fd = socket_get_fd(rec->sock); EVENT_FD_WRITE, messaging_send_handler, rec);
fde.flags = EVENT_FD_WRITE;
fde.handler = messaging_send_handler;
rec->fde = event_add_fd(msg->event.ev, &fde, rec);
messaging_send_handler(msg->event.ev, rec->fde, timeval_zero(), EVENT_FD_WRITE);
return NT_STATUS_OK; return NT_STATUS_OK;
} }
@ -458,7 +439,6 @@ struct messaging_context *messaging_init(TALLOC_CTX *mem_ctx, uint32_t server_id
{ {
struct messaging_context *msg; struct messaging_context *msg;
NTSTATUS status; NTSTATUS status;
struct fd_event fde;
msg = talloc(mem_ctx, struct messaging_context); msg = talloc(mem_ctx, struct messaging_context);
if (msg == NULL) { if (msg == NULL) {
@ -491,13 +471,9 @@ struct messaging_context *messaging_init(TALLOC_CTX *mem_ctx, uint32_t server_id
return NULL; return NULL;
} }
fde.private = msg;
fde.fd = socket_get_fd(msg->sock);
fde.flags = EVENT_FD_READ;
fde.handler = messaging_listen_handler;
msg->event.ev = talloc_reference(msg, ev); msg->event.ev = talloc_reference(msg, ev);
msg->event.fde = event_add_fd(ev, &fde, msg); msg->event.fde = event_add_fd(ev, msg, socket_get_fd(msg->sock),
EVENT_FD_READ, messaging_listen_handler, msg);
talloc_set_destructor(msg, messaging_destructor); talloc_set_destructor(msg, messaging_destructor);

1
source4/libcli/composite/composite.c
View File

@ -22,6 +22,7 @@
*/ */
#include "includes.h" #include "includes.h"
#include "events.h"
#include "libcli/raw/libcliraw.h" #include "libcli/raw/libcliraw.h"
#include "libcli/composite/composite.h" #include "libcli/composite/composite.h"

3
source4/libcli/config.mk
View File

@ -14,6 +14,7 @@ REQUIRED_SUBSYSTEMS = RPC_NDR_LSA
[SUBSYSTEM::LIBCLI_COMPOSITE_BASE] [SUBSYSTEM::LIBCLI_COMPOSITE_BASE]
ADD_OBJ_FILES = \ ADD_OBJ_FILES = \
libcli/composite/composite.o libcli/composite/composite.o
REQUIRED_SUBSYSTEMS = LIBEVENTS
[SUBSYSTEM::LIBCLI_COMPOSITE] [SUBSYSTEM::LIBCLI_COMPOSITE]
ADD_OBJ_FILES = \ ADD_OBJ_FILES = \
@ -31,7 +32,7 @@ ADD_OBJ_FILES = \
libcli/nbt/namequery.o \ libcli/nbt/namequery.o \
libcli/nbt/nameregister.o \ libcli/nbt/nameregister.o \
libcli/nbt/namerefresh.o libcli/nbt/namerefresh.o
REQUIRED_SUBSYSTEMS = LIBNDR_RAW NDR_NBT SOCKET LIBCLI_COMPOSITE_BASE REQUIRED_SUBSYSTEMS = LIBNDR_RAW NDR_NBT SOCKET LIBCLI_COMPOSITE_BASE LIBEVENTS
[SUBSYSTEM::LIBCLI_RESOLVE] [SUBSYSTEM::LIBCLI_RESOLVE]
ADD_OBJ_FILES = \ ADD_OBJ_FILES = \

38
source4/libcli/nbt/nbtsocket.c
View File

@ -49,11 +49,11 @@ static int nbt_name_request_destructor(void *ptr)
req->te = NULL; req->te = NULL;
} }
if (req->nbtsock->send_queue == NULL) { if (req->nbtsock->send_queue == NULL) {
req->nbtsock->fde->flags &= ~EVENT_FD_WRITE; EVENT_FD_NOT_WRITEABLE(req->nbtsock->fde);
} }
if (req->nbtsock->num_pending == 0 && if (req->nbtsock->num_pending == 0 &&
req->nbtsock->incoming.handler == NULL) { req->nbtsock->incoming.handler == NULL) {
req->nbtsock->fde->flags &= ~EVENT_FD_READ; EVENT_FD_NOT_READABLE(req->nbtsock->fde);
} }
return 0; return 0;
} }
@ -86,12 +86,12 @@ static void nbt_name_socket_send(struct nbt_name_socket *nbtsock)
talloc_free(req); talloc_free(req);
} else { } else {
req->state = NBT_REQUEST_WAIT; req->state = NBT_REQUEST_WAIT;
nbtsock->fde->flags |= EVENT_FD_READ; EVENT_FD_READABLE(nbtsock->fde);
nbtsock->num_pending++; nbtsock->num_pending++;
} }
} }
nbtsock->fde->flags &= ~EVENT_FD_WRITE; EVENT_FD_NOT_WRITEABLE(nbtsock->fde);
talloc_free(tmp_ctx); talloc_free(tmp_ctx);
return; return;
@ -210,9 +210,9 @@ static void nbt_name_socket_recv(struct nbt_name_socket *nbtsock)
handle fd events on a nbt_name_socket handle fd events on a nbt_name_socket
*/ */
static void nbt_name_socket_handler(struct event_context *ev, struct fd_event *fde, static void nbt_name_socket_handler(struct event_context *ev, struct fd_event *fde,
struct timeval t, uint16_t flags) struct timeval t, uint16_t flags, void *private)
{ {
struct nbt_name_socket *nbtsock = talloc_get_type(fde->private, struct nbt_name_socket *nbtsock = talloc_get_type(private,
struct nbt_name_socket); struct nbt_name_socket);
if (flags & EVENT_FD_WRITE) { if (flags & EVENT_FD_WRITE) {
nbt_name_socket_send(nbtsock); nbt_name_socket_send(nbtsock);
@ -231,7 +231,6 @@ struct nbt_name_socket *nbt_name_socket_init(TALLOC_CTX *mem_ctx,
{ {
struct nbt_name_socket *nbtsock; struct nbt_name_socket *nbtsock;
NTSTATUS status; NTSTATUS status;
struct fd_event fde;
nbtsock = talloc(mem_ctx, struct nbt_name_socket); nbtsock = talloc(mem_ctx, struct nbt_name_socket);
if (nbtsock == NULL) goto failed; if (nbtsock == NULL) goto failed;
@ -255,11 +254,9 @@ struct nbt_name_socket *nbt_name_socket_init(TALLOC_CTX *mem_ctx,
nbtsock->num_pending = 0; nbtsock->num_pending = 0;
nbtsock->incoming.handler = NULL; nbtsock->incoming.handler = NULL;
fde.fd = socket_get_fd(nbtsock->sock); nbtsock->fde = event_add_fd(nbtsock->event_ctx, nbtsock,
fde.flags = 0; socket_get_fd(nbtsock->sock), 0,
fde.handler = nbt_name_socket_handler; nbt_name_socket_handler, nbtsock);
fde.private = nbtsock;
nbtsock->fde = event_add_fd(nbtsock->event_ctx, &fde, nbtsock);
return nbtsock; return nbtsock;
@ -272,9 +269,9 @@ failed:
handle a request timeout handle a request timeout
*/ */
static void nbt_name_socket_timeout(struct event_context *ev, struct timed_event *te, static void nbt_name_socket_timeout(struct event_context *ev, struct timed_event *te,
struct timeval t) struct timeval t, void *private)
{ {
struct nbt_name_request *req = talloc_get_type(te->private, struct nbt_name_request *req = talloc_get_type(private,
struct nbt_name_request); struct nbt_name_request);
nbt_name_request_destructor(req); nbt_name_request_destructor(req);
if (req->num_replies == 0) { if (req->num_replies == 0) {
@ -299,7 +296,6 @@ struct nbt_name_request *nbt_name_request_send(struct nbt_name_socket *nbtsock,
BOOL allow_multiple_replies) BOOL allow_multiple_replies)
{ {
struct nbt_name_request *req; struct nbt_name_request *req;
struct timed_event te;
int id; int id;
NTSTATUS status; NTSTATUS status;
@ -335,10 +331,8 @@ struct nbt_name_request *nbt_name_request_send(struct nbt_name_socket *nbtsock,
request->name_trn_id = id; request->name_trn_id = id;
req->name_trn_id = id; req->name_trn_id = id;
te.next_event = timeout; req->te = event_add_timed(nbtsock->event_ctx, req, timeout,
te.handler = nbt_name_socket_timeout; nbt_name_socket_timeout, req);
te.private = req;
req->te = event_add_timed(nbtsock->event_ctx, &te, req);
talloc_set_destructor(req, nbt_name_request_destructor); talloc_set_destructor(req, nbt_name_request_destructor);
@ -358,7 +352,7 @@ struct nbt_name_request *nbt_name_request_send(struct nbt_name_socket *nbtsock,
NDR_PRINT_DEBUG(nbt_name_packet, request); NDR_PRINT_DEBUG(nbt_name_packet, request);
} }
nbtsock->fde->flags |= EVENT_FD_WRITE; EVENT_FD_WRITEABLE(nbtsock->fde);
return req; return req;
@ -403,7 +397,7 @@ NTSTATUS nbt_name_reply_send(struct nbt_name_socket *nbtsock,
DLIST_ADD_END(nbtsock->send_queue, req, struct nbt_name_request *); DLIST_ADD_END(nbtsock->send_queue, req, struct nbt_name_request *);
nbtsock->fde->flags |= EVENT_FD_WRITE; EVENT_FD_WRITEABLE(nbtsock->fde);
return NT_STATUS_OK; return NT_STATUS_OK;
@ -442,7 +436,7 @@ NTSTATUS nbt_set_incoming_handler(struct nbt_name_socket *nbtsock,
{ {
nbtsock->incoming.handler = handler; nbtsock->incoming.handler = handler;
nbtsock->incoming.private = private; nbtsock->incoming.private = private;
nbtsock->fde->flags |= EVENT_FD_READ; EVENT_FD_READABLE(nbtsock->fde);
return NT_STATUS_OK; return NT_STATUS_OK;
} }

27
source4/libcli/raw/clisocket.c
View File

@ -65,16 +65,17 @@ struct smbcli_socket *smbcli_sock_init(TALLOC_CTX *mem_ctx,
} }
static NTSTATUS smbcli_sock_connect_one(struct smbcli_socket *sock, static NTSTATUS smbcli_sock_connect_one(struct smbcli_socket *sock,
const char *hostaddr, int port); const char *hostaddr, int port,
struct composite_context *c);
/* /*
handle socket write events during an async connect. These happen when the OS handle socket write events during an async connect. These happen when the OS
has either completed the connect() or has returned an error has either completed the connect() or has returned an error
*/ */
static void smbcli_sock_connect_handler(struct event_context *ev, struct fd_event *fde, static void smbcli_sock_connect_handler(struct event_context *ev, struct fd_event *fde,
struct timeval t, uint16_t flags) struct timeval t, uint16_t flags, void *private)
{ {
struct composite_context *c = talloc_get_type(fde->private, struct composite_context); struct composite_context *c = talloc_get_type(private, struct composite_context);
struct clisocket_connect *conn = talloc_get_type(c->private, struct clisocket_connect); struct clisocket_connect *conn = talloc_get_type(c->private, struct clisocket_connect);
int i; int i;
@ -94,10 +95,9 @@ static void smbcli_sock_connect_handler(struct event_context *ev, struct fd_even
conn->port_num = i; conn->port_num = i;
c->status = smbcli_sock_connect_one(conn->sock, c->status = smbcli_sock_connect_one(conn->sock,
conn->dest_host, conn->dest_host,
conn->iports[i]); conn->iports[i], c);
if (NT_STATUS_IS_OK(c->status) || if (NT_STATUS_IS_OK(c->status) ||
NT_STATUS_EQUAL(c->status, NT_STATUS_MORE_PROCESSING_REQUIRED)) { NT_STATUS_EQUAL(c->status, NT_STATUS_MORE_PROCESSING_REQUIRED)) {
conn->sock->event.fde->private = c;
return; return;
} }
} }
@ -113,9 +113,9 @@ static void smbcli_sock_connect_handler(struct event_context *ev, struct fd_even
try to connect to the given address/port try to connect to the given address/port
*/ */
static NTSTATUS smbcli_sock_connect_one(struct smbcli_socket *sock, static NTSTATUS smbcli_sock_connect_one(struct smbcli_socket *sock,
const char *hostaddr, int port) const char *hostaddr, int port,
struct composite_context *c)
{ {
struct fd_event fde;
NTSTATUS status; NTSTATUS status;
if (sock->sock) { if (sock->sock) {
@ -133,15 +133,11 @@ static NTSTATUS smbcli_sock_connect_one(struct smbcli_socket *sock,
/* we initially look for write - see the man page on /* we initially look for write - see the man page on
non-blocking connect */ non-blocking connect */
fde.fd = socket_get_fd(sock->sock); sock->event.fde = event_add_fd(sock->event.ctx, sock, socket_get_fd(sock->sock),
fde.flags = EVENT_FD_WRITE; EVENT_FD_WRITE, smbcli_sock_connect_handler, c);
fde.handler = smbcli_sock_connect_handler;
fde.private = sock;
sock->event.fde = event_add_fd(sock->event.ctx, &fde, sock);
sock->port = port; sock->port = port;
set_blocking(fde.fd, False); set_blocking(socket_get_fd(sock->sock), False);
return socket_connect(sock->sock, NULL, 0, hostaddr, port, 0); return socket_connect(sock->sock, NULL, 0, hostaddr, port, 0);
} }
@ -200,10 +196,9 @@ struct composite_context *smbcli_sock_connect_send(struct smbcli_socket *sock,
conn->sock->port = conn->iports[i]; conn->sock->port = conn->iports[i];
c->status = smbcli_sock_connect_one(sock, c->status = smbcli_sock_connect_one(sock,
conn->dest_host, conn->dest_host,
conn->iports[i]); conn->iports[i], c);
if (NT_STATUS_IS_OK(c->status) || if (NT_STATUS_IS_OK(c->status) ||
NT_STATUS_EQUAL(c->status, NT_STATUS_MORE_PROCESSING_REQUIRED)) { NT_STATUS_EQUAL(c->status, NT_STATUS_MORE_PROCESSING_REQUIRED)) {
sock->event.fde->private = c;
return c; return c;
} }
} }

45
source4/libcli/raw/clitransport.c
View File

@ -33,11 +33,13 @@ static void smbcli_transport_process_send(struct smbcli_transport *transport);
/* /*
an event has happened on the socket an event has happened on the socket
*/ */
static void smbcli_transport_event_handler(struct event_context *ev, struct fd_event *fde, static void smbcli_transport_event_handler(struct event_context *ev,
struct timeval t, uint16_t flags) struct fd_event *fde,
struct timeval t,
uint16_t flags, void *private)
{ {
struct smbcli_transport *transport = fde->private; struct smbcli_transport *transport = talloc_get_type(private,
struct smbcli_transport);
if (flags & EVENT_FD_READ) { if (flags & EVENT_FD_READ) {
smbcli_transport_process_recv(transport); smbcli_transport_process_recv(transport);
return; return;
@ -87,9 +89,13 @@ struct smbcli_transport *smbcli_transport_init(struct smbcli_socket *sock,
/* take over event handling from the socket layer - it only /* take over event handling from the socket layer - it only
handles events up until we are connected */ handles events up until we are connected */
transport->socket->event.fde->handler = smbcli_transport_event_handler; talloc_free(transport->socket->event.fde);
transport->socket->event.fde->private = transport; transport->socket->event.fde = event_add_fd(transport->socket->event.ctx,
transport->socket->event.fde->flags = EVENT_FD_READ; transport->socket,
socket_get_fd(transport->socket->sock),
EVENT_FD_READ,
smbcli_transport_event_handler,
transport);
talloc_set_destructor(transport, transport_destructor); talloc_set_destructor(transport, transport_destructor);
@ -132,7 +138,8 @@ void smbcli_transport_dead(struct smbcli_transport *transport)
*/ */
static void smbcli_transport_write_enable(struct smbcli_transport *transport) static void smbcli_transport_write_enable(struct smbcli_transport *transport)
{ {
transport->socket->event.fde->flags |= EVENT_FD_WRITE; struct fd_event *fde = transport->socket->event.fde;
EVENT_FD_WRITEABLE(fde);
} }
/* /*
@ -140,7 +147,8 @@ static void smbcli_transport_write_enable(struct smbcli_transport *transport)
*/ */
static void smbcli_transport_write_disable(struct smbcli_transport *transport) static void smbcli_transport_write_disable(struct smbcli_transport *transport)
{ {
transport->socket->event.fde->flags &= ~EVENT_FD_WRITE; struct fd_event *fde = transport->socket->event.fde;
EVENT_FD_NOT_WRITEABLE(fde);
} }
/* /*
@ -296,10 +304,15 @@ again:
} }
static void idle_handler(struct event_context *ev, static void idle_handler(struct event_context *ev,
struct timed_event *te, struct timeval t) struct timed_event *te, struct timeval t, void *private)
{ {
struct smbcli_transport *transport = te->private; struct smbcli_transport *transport = talloc_get_type(private,
te->next_event = timeval_add(&te->next_event, 0, transport->idle.period); struct smbcli_transport);
struct timeval next = timeval_add(&t, 0, transport->idle.period);
transport->socket->event.te = event_add_timed(transport->socket->event.ctx,
transport,
next,
idle_handler, transport);
transport->idle.func(transport, transport->idle.private); transport->idle.func(transport, transport->idle.private);
} }
@ -312,7 +325,6 @@ void smbcli_transport_idle_handler(struct smbcli_transport *transport,
uint64_t period, uint64_t period,
void *private) void *private)
{ {
struct timed_event te;
transport->idle.func = idle_func; transport->idle.func = idle_func;
transport->idle.private = private; transport->idle.private = private;
transport->idle.period = period; transport->idle.period = period;
@ -321,11 +333,10 @@ void smbcli_transport_idle_handler(struct smbcli_transport *transport,
talloc_free(transport->socket->event.te); talloc_free(transport->socket->event.te);
} }
te.next_event = timeval_current_ofs(0, period);
te.handler = idle_handler;
te.private = transport;
transport->socket->event.te = event_add_timed(transport->socket->event.ctx, transport->socket->event.te = event_add_timed(transport->socket->event.ctx,
&te, transport); transport,
timeval_current_ofs(0, period),
idle_handler, transport);
} }
/* /*

1
source4/libcli/raw/rawrequest.c
View File

@ -26,6 +26,7 @@
#include "includes.h" #include "includes.h"
#include "libcli/raw/libcliraw.h" #include "libcli/raw/libcliraw.h"
#include "dlinklist.h" #include "dlinklist.h"
#include "events.h"
/* we over allocate the data buffer to prevent too many realloc calls */ /* we over allocate the data buffer to prevent too many realloc calls */
#define REQ_OVER_ALLOCATION 0 #define REQ_OVER_ALLOCATION 0

12
source4/libcli/resolve/host.c
View File

@ -83,9 +83,9 @@ static void run_child(struct composite_context *c, int fd)
handle a read event on the pipe handle a read event on the pipe
*/ */
static void pipe_handler(struct event_context *ev, struct fd_event *fde, static void pipe_handler(struct event_context *ev, struct fd_event *fde,
struct timeval t, uint16_t flags) struct timeval t, uint16_t flags, void *private)
{ {
struct composite_context *c = talloc_get_type(fde->private, struct composite_context); struct composite_context *c = talloc_get_type(private, struct composite_context);
struct host_state *state = talloc_get_type(c->private, struct host_state); struct host_state *state = talloc_get_type(c->private, struct host_state);
char address[128]; char address[128];
int ret; int ret;
@ -136,7 +136,6 @@ struct composite_context *resolve_name_host_send(struct nbt_name *name,
struct host_state *state; struct host_state *state;
NTSTATUS status; NTSTATUS status;
int fd[2] = { -1, -1 }; int fd[2] = { -1, -1 };
struct fd_event fde;
int ret; int ret;
c = talloc_zero(NULL, struct composite_context); c = talloc_zero(NULL, struct composite_context);
@ -161,11 +160,8 @@ struct composite_context *resolve_name_host_send(struct nbt_name *name,
/* we need to put the child in our event context so /* we need to put the child in our event context so
we know when the gethostbyname() has finished */ we know when the gethostbyname() has finished */
fde.fd = state->child_fd; state->fde = event_add_fd(c->event_ctx, state, state->child_fd, EVENT_FD_READ,
fde.flags = EVENT_FD_READ; pipe_handler, c);
fde.handler = pipe_handler;
fde.private = c;
state->fde = event_add_fd(c->event_ctx, &fde, state);
if (state->fde == NULL) { if (state->fde == NULL) {
close(fd[0]); close(fd[0]);
close(fd[1]); close(fd[1]);

1
source4/libcli/resolve/resolve.c
View File

@ -21,6 +21,7 @@
*/ */
#include "includes.h" #include "includes.h"
#include "events.h"
#include "libcli/raw/libcliraw.h" #include "libcli/raw/libcliraw.h"
#include "libcli/composite/composite.h" #include "libcli/composite/composite.h"

1
source4/librpc/rpc/dcerpc.c
View File

@ -23,6 +23,7 @@
#include "includes.h" #include "includes.h"
#include "dlinklist.h" #include "dlinklist.h"
#include "events.h"
#include "librpc/gen_ndr/ndr_epmapper.h" #include "librpc/gen_ndr/ndr_epmapper.h"
#include "librpc/gen_ndr/ndr_dcerpc.h" #include "librpc/gen_ndr/ndr_dcerpc.h"

23
source4/librpc/rpc/dcerpc_sock.c
View File

@ -74,7 +74,7 @@ static void sock_dead(struct dcerpc_connection *p, NTSTATUS status)
p->transport.recv_data(p, NULL, status); p->transport.recv_data(p, NULL, status);
} }
sock->fde->flags &= ~(EVENT_FD_WRITE | EVENT_FD_READ); talloc_free(sock->fde);
} }
/* /*
@ -109,7 +109,7 @@ static void sock_process_send(struct dcerpc_connection *p)
} }
if (sock->pending_send == NULL) { if (sock->pending_send == NULL) {
sock->fde->flags &= ~EVENT_FD_WRITE; EVENT_FD_NOT_WRITEABLE(sock->fde);
} }
} }
@ -184,7 +184,7 @@ static void sock_process_recv(struct dcerpc_connection *p)
sock->recv.received = 0; sock->recv.received = 0;
sock->recv.pending_count--; sock->recv.pending_count--;
if (sock->recv.pending_count == 0) { if (sock->recv.pending_count == 0) {
sock->fde->flags &= ~EVENT_FD_READ; EVENT_FD_NOT_READABLE(sock->fde);
} }
} }
@ -192,9 +192,9 @@ static void sock_process_recv(struct dcerpc_connection *p)
called when a IO is triggered by the events system called when a IO is triggered by the events system
*/ */
static void sock_io_handler(struct event_context *ev, struct fd_event *fde, static void sock_io_handler(struct event_context *ev, struct fd_event *fde,
struct timeval t, uint16_t flags) struct timeval t, uint16_t flags, void *private)
{ {
struct dcerpc_connection *p = fde->private; struct dcerpc_connection *p = talloc_get_type(private, struct dcerpc_connection);
struct sock_private *sock = p->transport.private; struct sock_private *sock = p->transport.private;
if (flags & EVENT_FD_WRITE) { if (flags & EVENT_FD_WRITE) {
@ -220,7 +220,7 @@ static NTSTATUS sock_send_read(struct dcerpc_connection *p)
sock->recv.pending_count++; sock->recv.pending_count++;
if (sock->recv.pending_count == 1) { if (sock->recv.pending_count == 1) {
sock->fde->flags |= EVENT_FD_READ; EVENT_FD_READABLE(sock->fde);
} }
return NT_STATUS_OK; return NT_STATUS_OK;
} }
@ -250,7 +250,7 @@ static NTSTATUS sock_send_request(struct dcerpc_connection *p, DATA_BLOB *data,
DLIST_ADD_END(sock->pending_send, blob, struct sock_blob *); DLIST_ADD_END(sock->pending_send, blob, struct sock_blob *);
sock->fde->flags |= EVENT_FD_WRITE; EVENT_FD_WRITEABLE(sock->fde);
if (trigger_read) { if (trigger_read) {
sock_send_read(p); sock_send_read(p);
@ -299,7 +299,6 @@ static NTSTATUS dcerpc_pipe_open_socket(struct dcerpc_connection *c,
{ {
struct sock_private *sock; struct sock_private *sock;
struct socket_context *socket_ctx; struct socket_context *socket_ctx;
struct fd_event fde;
NTSTATUS status; NTSTATUS status;
sock = talloc(c, struct sock_private); sock = talloc(c, struct sock_private);
@ -342,12 +341,8 @@ static NTSTATUS dcerpc_pipe_open_socket(struct dcerpc_connection *c,
sock->recv.data = data_blob(NULL, 0); sock->recv.data = data_blob(NULL, 0);
sock->recv.pending_count = 0; sock->recv.pending_count = 0;
fde.fd = socket_get_fd(sock->sock); sock->fde = event_add_fd(sock->event_ctx, sock, socket_get_fd(sock->sock),
fde.flags = 0; 0, sock_io_handler, c);
fde.handler = sock_io_handler;
fde.private = c;
sock->fde = event_add_fd(sock->event_ctx, &fde, sock);
c->transport.private = sock; c->transport.private = sock;

14
source4/nbt_server/register.c
View File

@ -72,9 +72,9 @@ static void refresh_completion_handler(struct nbt_name_request *req)
handle name refresh timer events handle name refresh timer events
*/ */
static void name_refresh_handler(struct event_context *ev, struct timed_event *te, static void name_refresh_handler(struct event_context *ev, struct timed_event *te,
struct timeval t) struct timeval t, void *private)
{ {
struct nbt_iface_name *iname = talloc_get_type(te->private, struct nbt_iface_name); struct nbt_iface_name *iname = talloc_get_type(private, struct nbt_iface_name);
struct nbt_interface *iface = iname->iface; struct nbt_interface *iface = iname->iface;
struct nbt_name_refresh io; struct nbt_name_refresh io;
struct nbt_name_request *req; struct nbt_name_request *req;
@ -101,17 +101,15 @@ static void name_refresh_handler(struct event_context *ev, struct timed_event *t
*/ */
static void nbt_start_refresh_timer(struct nbt_iface_name *iname) static void nbt_start_refresh_timer(struct nbt_iface_name *iname)
{ {
struct timed_event te;
uint32_t refresh_time; uint32_t refresh_time;
uint32_t max_refresh_time = lp_parm_int(-1, "nbtd", "max_refresh_time", 7200); uint32_t max_refresh_time = lp_parm_int(-1, "nbtd", "max_refresh_time", 7200);
refresh_time = MIN(max_refresh_time, iname->ttl/2); refresh_time = MIN(max_refresh_time, iname->ttl/2);
te.next_event = timeval_current_ofs(refresh_time, 0); event_add_timed(iname->iface->nbtsrv->task->event_ctx,
te.handler = name_refresh_handler; iname,
te.private = iname; timeval_current_ofs(refresh_time, 0),
name_refresh_handler, iname);
event_add_timed(iname->iface->nbtsrv->task->event_ctx, &te, iname);
} }

23
source4/ntvfs/cifs/vfs_cifs.c
View File

@ -65,14 +65,12 @@ static BOOL oplock_handler(struct smbcli_transport *transport, uint16_t tid, uin
a handler for read events on a connection to a backend server a handler for read events on a connection to a backend server
*/ */
static void cifs_socket_handler(struct event_context *ev, struct fd_event *fde, static void cifs_socket_handler(struct event_context *ev, struct fd_event *fde,
struct timeval t, uint16_t flags) struct timeval t, uint16_t flags, void *private)
{ {
struct cvfs_private *private = fde->private; struct cvfs_private *cvfs = talloc_get_type(private, struct cvfs_private);
struct smbsrv_tcon *tcon = private->tcon; struct smbsrv_tcon *tcon = cvfs->tcon;
DEBUG(5,("cifs_socket_handler event on fd %d\n", fde->fd)); if (!smbcli_transport_process(cvfs->transport)) {
if (!smbcli_transport_process(private->transport)) {
/* the connection to our server is dead */ /* the connection to our server is dead */
talloc_free(tcon); talloc_free(tcon);
} }
@ -90,6 +88,7 @@ static NTSTATUS cvfs_connect(struct ntvfs_module_context *ntvfs,
const char *host, *user, *pass, *domain, *remote_share; const char *host, *user, *pass, *domain, *remote_share;
struct smb_composite_connect io; struct smb_composite_connect io;
struct composite_context *creq; struct composite_context *creq;
struct fd_event *fde;
/* Here we need to determine which server to connect to. /* Here we need to determine which server to connect to.
* For now we use parametric options, type cifs. * For now we use parametric options, type cifs.
@ -144,8 +143,16 @@ static NTSTATUS cvfs_connect(struct ntvfs_module_context *ntvfs,
/* we need to receive oplock break requests from the server */ /* we need to receive oplock break requests from the server */
smbcli_oplock_handler(private->transport, oplock_handler, private); smbcli_oplock_handler(private->transport, oplock_handler, private);
private->transport->socket->event.fde->handler = cifs_socket_handler; /* take over event handling for this socket */
private->transport->socket->event.fde->private = private; talloc_free(private->transport->socket->event.fde);
fde = event_add_fd(private->transport->socket->event.ctx,
private,
socket_get_fd(private->transport->socket->sock),
EVENT_FD_READ | EVENT_FD_WRITE,
cifs_socket_handler,
private);
private->transport->socket->event.fde = fde;
private->map_generic = lp_parm_bool(req->tcon->service, private->map_generic = lp_parm_bool(req->tcon->service,
"cifs", "mapgeneric", False); "cifs", "mapgeneric", False);

11
source4/ntvfs/posix/pvfs_wait.c
View File

@ -86,9 +86,9 @@ static void pvfs_wait_dispatch(struct messaging_context *msg, void *private, uin
receive a timeout on a message wait receive a timeout on a message wait
*/ */
static void pvfs_wait_timeout(struct event_context *ev, static void pvfs_wait_timeout(struct event_context *ev,
struct timed_event *te, struct timeval t) struct timed_event *te, struct timeval t, void *private)
{ {
struct pvfs_wait *pwait = te->private; struct pvfs_wait *pwait = talloc_get_type(private, struct pvfs_wait);
struct smbsrv_request *req = pwait->req; struct smbsrv_request *req = pwait->req;
pwait->reason = PVFS_WAIT_TIMEOUT; pwait->reason = PVFS_WAIT_TIMEOUT;
@ -124,7 +124,6 @@ static int pvfs_wait_destructor(void *ptr)
void (*fn)(void *, enum pvfs_wait_notice), void (*fn)(void *, enum pvfs_wait_notice),
void *private) void *private)
{ {
struct timed_event te;
struct pvfs_wait *pwait; struct pvfs_wait *pwait;
pwait = talloc(pvfs, struct pvfs_wait); pwait = talloc(pvfs, struct pvfs_wait);
@ -141,10 +140,8 @@ static int pvfs_wait_destructor(void *ptr)
pwait->pvfs = pvfs; pwait->pvfs = pvfs;
/* setup a timer */ /* setup a timer */
te.next_event = end_time; pwait->te = event_add_timed(pwait->ev, pwait, end_time,
te.handler = pvfs_wait_timeout; pvfs_wait_timeout, pwait);
te.private = pwait;
pwait->te = event_add_timed(pwait->ev, &te, pwait);
/* register with the messaging subsystem for this message /* register with the messaging subsystem for this message
type */ type */

2
source4/rpc_server/dcerpc_server.c
View File

@ -878,7 +878,7 @@ NTSTATUS dcesrv_reply(struct dcesrv_call_state *call)
if (call->conn->call_list && call->conn->call_list->replies) { if (call->conn->call_list && call->conn->call_list->replies) {
if (call->conn->srv_conn && if (call->conn->srv_conn &&
call->conn->srv_conn->event.fde) { call->conn->srv_conn->event.fde) {
call->conn->srv_conn->event.fde->flags |= EVENT_FD_WRITE; EVENT_FD_WRITEABLE(call->conn->srv_conn->event.fde);
} }
} }

4
source4/rpc_server/dcerpc_sock.c
View File

@ -112,7 +112,7 @@ void dcesrv_sock_recv(struct stream_connection *conn, struct timeval t, uint16_t
} }
if (dce_conn->call_list && dce_conn->call_list->replies) { if (dce_conn->call_list && dce_conn->call_list->replies) {
conn->event.fde->flags |= EVENT_FD_WRITE; EVENT_FD_WRITEABLE(conn->event.fde);
} }
} }
@ -128,7 +128,7 @@ void dcesrv_sock_send(struct stream_connection *conn, struct timeval t, uint16_t
} }
if (!dce_conn->call_list || !dce_conn->call_list->replies) { if (!dce_conn->call_list || !dce_conn->call_list->replies) {
conn->event.fde->flags &= ~EVENT_FD_WRITE; EVENT_FD_NOT_WRITEABLE(conn->event.fde);
} }
} }

15
source4/rpc_server/echo/rpc_echo.c
View File

@ -119,9 +119,11 @@ struct echo_TestSleep_private {
struct echo_TestSleep *r; struct echo_TestSleep *r;
}; };
static void echo_TestSleep_handler(struct event_context *ev, struct timed_event *te, struct timeval t) static void echo_TestSleep_handler(struct event_context *ev, struct timed_event *te,
struct timeval t, void *private)
{ {
struct echo_TestSleep_private *p = te->private; struct echo_TestSleep_private *p = talloc_get_type(private,
struct echo_TestSleep_private);
struct echo_TestSleep *r = p->r; struct echo_TestSleep *r = p->r;
NTSTATUS status; NTSTATUS status;
@ -136,7 +138,6 @@ static void echo_TestSleep_handler(struct event_context *ev, struct timed_event
static long echo_TestSleep(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, struct echo_TestSleep *r) static long echo_TestSleep(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, struct echo_TestSleep *r)
{ {
struct timed_event te;
struct echo_TestSleep_private *p; struct echo_TestSleep_private *p;
if (!(dce_call->state_flags & DCESRV_CALL_STATE_FLAG_MAY_ASYNC)) { if (!(dce_call->state_flags & DCESRV_CALL_STATE_FLAG_MAY_ASYNC)) {
@ -154,11 +155,9 @@ static long echo_TestSleep(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_c
p->dce_call = dce_call; p->dce_call = dce_call;
p->r = r; p->r = r;
te.handler = echo_TestSleep_handler; event_add_timed(dce_call->event_ctx, p,
te.private = p; timeval_add(&dce_call->time, r->in.seconds, 0),
te.next_event = timeval_add(&dce_call->time, r->in.seconds, 0); echo_TestSleep_handler, p);
event_add_timed(dce_call->event_ctx, &te, p);
dce_call->state_flags |= DCESRV_CALL_STATE_FLAG_ASYNC; dce_call->state_flags |= DCESRV_CALL_STATE_FLAG_ASYNC;
return 0; return 0;

2
source4/smb_server/request.c
View File

@ -300,7 +300,7 @@ void req_send_reply_nosign(struct smbsrv_request *req)
ready for write events */ ready for write events */
DLIST_ADD_END(req->smb_conn->pending_send, req, struct smbsrv_request *); DLIST_ADD_END(req->smb_conn->pending_send, req, struct smbsrv_request *);
req->smb_conn->connection->event.fde->flags |= EVENT_FD_WRITE; EVENT_FD_WRITEABLE(req->smb_conn->connection->event.fde);
} }
/* /*

4
source4/smb_server/smb_server.c
View File

@ -662,7 +662,7 @@ static void smbsrv_recv(struct stream_connection *conn, struct timeval t, uint16
status = receive_smb_request(smb_conn, t); status = receive_smb_request(smb_conn, t);
if (NT_STATUS_IS_ERR(status)) { if (NT_STATUS_IS_ERR(status)) {
conn->event.fde->flags = 0; talloc_free(conn->event.fde);
smbsrv_terminate_connection(smb_conn, nt_errstr(status)); smbsrv_terminate_connection(smb_conn, nt_errstr(status));
return; return;
} }
@ -710,7 +710,7 @@ static void smbsrv_send(struct stream_connection *conn, struct timeval t, uint16
/* if no more requests are pending to be sent then /* if no more requests are pending to be sent then
we should stop select for write */ we should stop select for write */
if (smb_conn->pending_send == NULL) { if (smb_conn->pending_send == NULL) {
conn->event.fde->flags &= ~EVENT_FD_WRITE; EVENT_FD_NOT_WRITEABLE(conn->event.fde);
} }
} }

4
source4/smbd/process_model.c
View File

@ -105,9 +105,7 @@ const struct process_model_critical_sizes *process_model_version(void)
{ {
static const struct process_model_critical_sizes critical_sizes = { static const struct process_model_critical_sizes critical_sizes = {
PROCESS_MODEL_VERSION, PROCESS_MODEL_VERSION,
sizeof(struct model_ops), sizeof(struct model_ops)
sizeof(struct event_context),
sizeof(struct fd_event)
}; };
return &critical_sizes; return &critical_sizes;

2
source4/smbd/process_model.h
View File

@ -58,6 +58,4 @@ struct model_ops {
struct process_model_critical_sizes { struct process_model_critical_sizes {
int interface_version; int interface_version;
int sizeof_model_ops; int sizeof_model_ops;
int sizeof_event_context;
int sizeof_fd_event;
}; };

1
source4/smbd/server.c
View File

@ -24,6 +24,7 @@
*/ */
#include "includes.h" #include "includes.h"
#include "events.h"
#include "version.h" #include "version.h"
#include "dynconfig.h" #include "dynconfig.h"
#include "lib/cmdline/popt_common.h" #include "lib/cmdline/popt_common.h"

30
source4/smbd/service_stream.c
View File

@ -61,9 +61,9 @@ void stream_terminate_connection(struct stream_connection *srv_conn, const char
the select loop has indicated that a stream is ready for IO the select loop has indicated that a stream is ready for IO
*/ */
static void stream_io_handler(struct event_context *ev, struct fd_event *fde, static void stream_io_handler(struct event_context *ev, struct fd_event *fde,
struct timeval t, uint16_t flags) struct timeval t, uint16_t flags, void *private)
{ {
struct stream_connection *conn = talloc_get_type(fde->private, struct stream_connection *conn = talloc_get_type(private,
struct stream_connection); struct stream_connection);
if (flags & EVENT_FD_WRITE) { if (flags & EVENT_FD_WRITE) {
conn->ops->send_handler(conn, t, flags); conn->ops->send_handler(conn, t, flags);
@ -85,7 +85,6 @@ static void stream_new_connection(struct event_context *ev,
uint32_t server_id, void *private) uint32_t server_id, void *private)
{ {
struct stream_socket *stream_socket = talloc_get_type(private, struct stream_socket); struct stream_socket *stream_socket = talloc_get_type(private, struct stream_socket);
struct fd_event fde;
struct stream_connection *srv_conn; struct stream_connection *srv_conn;
srv_conn = talloc_zero(ev, struct stream_connection); srv_conn = talloc_zero(ev, struct stream_connection);
@ -96,19 +95,15 @@ static void stream_new_connection(struct event_context *ev,
talloc_steal(srv_conn, sock); talloc_steal(srv_conn, sock);
fde.private = srv_conn;
fde.fd = socket_get_fd(sock);
fde.flags = EVENT_FD_READ;
fde.handler = stream_io_handler;
srv_conn->private = stream_socket->private; srv_conn->private = stream_socket->private;
srv_conn->model_ops = stream_socket->model_ops; srv_conn->model_ops = stream_socket->model_ops;
srv_conn->event.ctx = ev; srv_conn->event.ctx = ev;
srv_conn->event.fde = &fde;
srv_conn->socket = sock; srv_conn->socket = sock;
srv_conn->server_id = server_id; srv_conn->server_id = server_id;
srv_conn->ops = stream_socket->ops; srv_conn->ops = stream_socket->ops;
srv_conn->event.fde = event_add_fd(ev, &fde, srv_conn); srv_conn->event.fde = event_add_fd(ev, srv_conn, socket_get_fd(sock),
EVENT_FD_READ,
stream_io_handler, srv_conn);
if (!socket_check_access(sock, "smbd", lp_hostsallow(-1), lp_hostsdeny(-1))) { if (!socket_check_access(sock, "smbd", lp_hostsallow(-1), lp_hostsdeny(-1))) {
stream_terminate_connection(srv_conn, "denied by access rules"); stream_terminate_connection(srv_conn, "denied by access rules");
@ -131,9 +126,9 @@ static void stream_new_connection(struct event_context *ev,
called when someone opens a connection to one of our listening ports called when someone opens a connection to one of our listening ports
*/ */
static void stream_accept_handler(struct event_context *ev, struct fd_event *fde, static void stream_accept_handler(struct event_context *ev, struct fd_event *fde,
struct timeval t, uint16_t flags) struct timeval t, uint16_t flags, void *private)
{ {
struct stream_socket *stream_socket = talloc_get_type(fde->private, struct stream_socket); struct stream_socket *stream_socket = talloc_get_type(private, struct stream_socket);
/* ask the process model to create us a process for this new /* ask the process model to create us a process for this new
connection. When done, it calls stream_new_connection() connection. When done, it calls stream_new_connection()
@ -158,7 +153,6 @@ NTSTATUS stream_setup_socket(struct event_context *event_context,
{ {
NTSTATUS status; NTSTATUS status;
struct stream_socket *stream_socket; struct stream_socket *stream_socket;
struct fd_event fde;
int i; int i;
stream_socket = talloc_zero(event_context, struct stream_socket); stream_socket = talloc_zero(event_context, struct stream_socket);
@ -198,13 +192,9 @@ NTSTATUS stream_setup_socket(struct event_context *event_context,
return status; return status;
} }
/* we are only interested in read events on the listen socket */ event_add_fd(event_context, stream_socket->sock,
fde.fd = socket_get_fd(stream_socket->sock); socket_get_fd(stream_socket->sock),
fde.flags = EVENT_FD_READ; EVENT_FD_READ, stream_accept_handler, stream_socket);
fde.private = stream_socket;
fde.handler = stream_accept_handler;
event_add_fd(event_context, &fde, stream_socket->sock);
stream_socket->private = talloc_reference(stream_socket, private); stream_socket->private = talloc_reference(stream_socket, private);
stream_socket->ops = stream_ops; stream_socket->ops = stream_ops;

3
source4/torture/local/messaging.c
View File

@ -21,6 +21,7 @@
*/ */
#include "includes.h" #include "includes.h"
#include "events.h"
enum {MY_PING=1000, MY_PONG, MY_EXIT}; enum {MY_PING=1000, MY_PONG, MY_EXIT};
@ -131,7 +132,7 @@ static BOOL test_ping_speed(TALLOC_CTX *mem_ctx)
talloc_free(msg_ctx); talloc_free(msg_ctx);
event_context_destroy(ev); talloc_free(ev);
return ret; return ret;
} }

1
source4/torture/nbt/query.c
View File

@ -21,6 +21,7 @@
*/ */
#include "includes.h" #include "includes.h"
#include "events.h"
#include "libcli/nbt/libnbt.h" #include "libcli/nbt/libnbt.h"
#include "librpc/gen_ndr/ndr_nbt.h" #include "librpc/gen_ndr/ndr_nbt.h"

1
source4/torture/raw/composite.c
View File

@ -21,6 +21,7 @@
*/ */
#include "includes.h" #include "includes.h"
#include "events.h"
#include "libcli/raw/libcliraw.h" #include "libcli/raw/libcliraw.h"
#include "libcli/composite/composite.h" #include "libcli/composite/composite.h"

1
source4/torture/rpc/echo.c
View File

@ -21,6 +21,7 @@
*/ */
#include "includes.h" #include "includes.h"
#include "events.h"
#include "librpc/gen_ndr/ndr_echo.h" #include "librpc/gen_ndr/ndr_echo.h"

1
source4/torture/rpc/netlogon.c
View File

@ -23,6 +23,7 @@
*/ */
#include "includes.h" #include "includes.h"
#include "events.h"
#include "librpc/gen_ndr/ndr_netlogon.h" #include "librpc/gen_ndr/ndr_netlogon.h"
#include "auth/auth.h" #include "auth/auth.h"

4
source4/winbind/wb_server.c
View File

@ -89,7 +89,7 @@ static void winbind_recv(struct stream_connection *conn, struct timeval t, uint1
DLIST_ADD_END(wbconn->queue, q, struct send_queue *); DLIST_ADD_END(wbconn->queue, q, struct send_queue *);
conn->event.fde->flags |= EVENT_FD_WRITE; EVENT_FD_WRITEABLE(conn->event.fde);
} }
/* /*
@ -123,7 +123,7 @@ static void winbind_send(struct stream_connection *conn, struct timeval t, uint1
} }
} }
conn->event.fde->flags &= ~EVENT_FD_WRITE; EVENT_FD_NOT_WRITEABLE(conn->event.fde);
} }
static const struct stream_server_ops winbind_stream_ops = { static const struct stream_server_ops winbind_stream_ops = {