static PyObject *py_tevent_context_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
const char * const kwnames[] = { "name", NULL };
char *name = NULL;
struct tevent_context *ev;
TeventContext_Object *ret;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|s", kwnames, &name))
return NULL;
if (name == NULL) {
ev = tevent_context_init(NULL);
} else {
ev = tevent_context_init_byname(NULL, name);
}
if (ev == NULL) {
PyErr_SetNone(PyExc_RuntimeError);
return NULL;
}
ret = PyObject_New(TeventContext_Object, type);
if (ret == NULL) {
PyErr_NoMemory();
talloc_free(ev);
return NULL;
}
ret->ev = ev;
return (PyObject *)ret;
}
static bool py_cli_state_setup_ev(struct py_cli_state *self)
{
struct py_cli_thread *t = NULL;
int ret;
self->ev = tevent_context_init_byname(NULL, "poll_mt");
if (self->ev == NULL) {
goto fail;
}
samba_tevent_set_debug(self->ev, "pylibsmb_tevent_mt");
tevent_set_trace_callback(self->ev, py_cli_state_trace_callback, self);
self->thread_state = talloc_zero(NULL, struct py_cli_thread);
if (self->thread_state == NULL) {
goto fail;
}
t = self->thread_state;
ret = pipe(t->shutdown_pipe);
if (ret == -1) {
goto fail;
}
t->shutdown_fde = tevent_add_fd(
self->ev, self->ev, t->shutdown_pipe[0], TEVENT_FD_READ,
py_cli_state_shutdown_handler, self);
if (t->shutdown_fde == NULL) {
goto fail;
}
PyEval_InitThreads();
ret = pthread_create(&t->id, NULL, py_cli_state_poll_thread, self);
if (ret != 0) {
goto fail;
}
talloc_set_destructor(self->thread_state, py_cli_thread_destructor);
return true;
fail:
if (t != NULL) {
TALLOC_FREE(t->shutdown_fde);
if (t->shutdown_pipe[0] != -1) {
close(t->shutdown_pipe[0]);
t->shutdown_pipe[0] = -1;
}
if (t->shutdown_pipe[1] != -1) {
close(t->shutdown_pipe[1]);
t->shutdown_pipe[1] = -1;
}
}
TALLOC_FREE(self->thread_state);
TALLOC_FREE(self->ev);
return false;
}
/*
create a event_context structure. This must be the first events
call, and all subsequent calls pass this event_context as the first
element. Event handlers also receive this as their first argument.
This samba4 specific call sets the samba4 debug handler.
*/
struct tevent_context *s4_event_context_init(TALLOC_CTX *mem_ctx)
{
struct tevent_context *ev;
ev = tevent_context_init_byname(mem_ctx, NULL);
if (ev) {
samba_tevent_set_debug(ev, "s4_tevent");
tevent_loop_allow_nesting(ev);
}
return ev;
}
static bool test_event_context_threaded(struct torture_context *test,
const void *test_data)
{
struct tevent_context *ev;
struct tevent_timer *te;
struct tevent_fd *fde;
pthread_t poll_thread;
int fds[2];
int ret;
char c = 0;
ev = tevent_context_init_byname(test, "poll_mt");
torture_assert(test, ev != NULL, "poll_mt not supported");
tevent_set_trace_callback(ev, test_event_threaded_trace, NULL);
te = tevent_add_timer(ev, ev, timeval_current_ofs(5, 0),
test_event_threaded_timer, NULL);
torture_assert(test, te != NULL, "Could not add timer");
ret = pthread_create(&poll_thread, NULL, test_event_poll_thread, ev);
torture_assert(test, ret == 0, "Could not create poll thread");
ret = pipe(fds);
torture_assert(test, ret == 0, "Could not create pipe");
poll(NULL, 0, 100);
test_event_threaded_lock();
fde = tevent_add_fd(ev, ev, fds[0], TEVENT_FD_READ,
test_event_threaded_read_handler, &fds[0]);
torture_assert(test, fde != NULL, "Could not add fd event");
test_event_threaded_unlock();
poll(NULL, 0, 100);
write(fds[1], &c, 1);
poll(NULL, 0, 100);
test_event_threaded_lock();
do_shutdown = true;
test_event_threaded_unlock();
write(fds[1], &c, 1);
ret = pthread_join(poll_thread, NULL);
torture_assert(test, ret == 0, "pthread_join failed");
return true;
}
static bool test_event_fd2(struct torture_context *tctx,
const void *test_data)
{
struct test_event_fd2_state state;
int sock[2];
uint8_t c = 0;
ZERO_STRUCT(state);
state.tctx = tctx;
state.backend = (const char *)test_data;
state.ev = tevent_context_init_byname(tctx, state.backend);
if (state.ev == NULL) {
torture_skip(tctx, talloc_asprintf(tctx,
"event backend '%s' not supported\n",
state.backend));
return true;
}
tevent_set_debug_stderr(state.ev);
torture_comment(tctx, "backend '%s' - %s\n",
state.backend, __FUNCTION__);
/*
* This tests the following
*
* - We write 1 byte to each socket
* - We wait for TEVENT_FD_READ/WRITE on both sockets
* - When we get TEVENT_FD_WRITE we write 1 byte
* until both socket buffers are full, which
* means both sockets only get TEVENT_FD_READ.
* - Then we read 1 byte until we have consumed
* all bytes the other end has written.
*/
sock[0] = -1;
sock[1] = -1;
socketpair(AF_UNIX, SOCK_STREAM, 0, sock);
/*
* the timer should never expire
*/
state.te = tevent_add_timer(state.ev, state.ev,
timeval_current_ofs(600, 0),
test_event_fd2_finished, &state);
state.sock0.state = &state;
state.sock0.fd = sock[0];
state.sock0.fde = tevent_add_fd(state.ev, state.ev,
state.sock0.fd,
TEVENT_FD_READ | TEVENT_FD_WRITE,
test_event_fd2_sock_handler,
&state.sock0);
state.sock1.state = &state;
state.sock1.fd = sock[1];
state.sock1.fde = tevent_add_fd(state.ev, state.ev,
state.sock1.fd,
TEVENT_FD_READ | TEVENT_FD_WRITE,
test_event_fd2_sock_handler,
&state.sock1);
tevent_fd_set_auto_close(state.sock0.fde);
tevent_fd_set_auto_close(state.sock1.fde);
write(state.sock0.fd, &c, 1);
state.sock0.num_written++;
write(state.sock1.fd, &c, 1);
state.sock1.num_written++;
while (!state.finished) {
errno = 0;
if (tevent_loop_once(state.ev) == -1) {
talloc_free(state.ev);
torture_fail(tctx, talloc_asprintf(tctx,
"Failed event loop %s\n",
strerror(errno)));
}
}
talloc_free(state.ev);
torture_assert(tctx, state.error == NULL, talloc_asprintf(tctx,
"%s", state.error));
return true;
}
static bool test_event_fd1(struct torture_context *tctx,
const void *test_data)
{
struct test_event_fd1_state state;
ZERO_STRUCT(state);
state.tctx = tctx;
state.backend = (const char *)test_data;
state.ev = tevent_context_init_byname(tctx, state.backend);
if (state.ev == NULL) {
torture_skip(tctx, talloc_asprintf(tctx,
"event backend '%s' not supported\n",
state.backend));
return true;
}
tevent_set_debug_stderr(state.ev);
torture_comment(tctx, "backend '%s' - %s\n",
state.backend, __FUNCTION__);
/*
* This tests the following:
*
* It monitors the state of state.sock[0]
* with tevent_fd, but we never read/write on state.sock[0]
* while state.sock[1] * is only used to write a few bytes.
*
* We have a loop:
* - we wait only for TEVENT_FD_WRITE on state.sock[0]
* - we write 1 byte to state.sock[1]
* - we wait only for TEVENT_FD_READ on state.sock[0]
* - we disable events on state.sock[0]
* - the timer event restarts the loop
* Then we close state.sock[1]
* We have a loop:
* - we wait for TEVENT_FD_READ/WRITE on state.sock[0]
* - we try to read 1 byte
* - if the read gets an error of returns 0
* we disable the event handler
* - the timer finishes the test
*/
state.sock[0] = -1;
state.sock[1] = -1;
socketpair(AF_UNIX, SOCK_STREAM, 0, state.sock);
state.te = tevent_add_timer(state.ev, state.ev,
timeval_current_ofs(0,1000),
test_event_fd1_finished, &state);
state.fde0 = tevent_add_fd(state.ev, state.ev,
state.sock[0], TEVENT_FD_WRITE,
test_event_fd1_fde_handler, &state);
/* state.fde1 is only used to auto close */
state.fde1 = tevent_add_fd(state.ev, state.ev,
state.sock[1], 0,
test_event_fd1_fde_handler, &state);
tevent_fd_set_auto_close(state.fde0);
tevent_fd_set_auto_close(state.fde1);
while (!state.finished) {
errno = 0;
if (tevent_loop_once(state.ev) == -1) {
talloc_free(state.ev);
torture_fail(tctx, talloc_asprintf(tctx,
"Failed event loop %s\n",
strerror(errno)));
}
}
talloc_free(state.ev);
torture_assert(tctx, state.error == NULL, talloc_asprintf(tctx,
"%s", state.error));
return true;
}
static bool test_event_context(struct torture_context *test,
const void *test_data)
{
struct tevent_context *ev_ctx;
int fd[2] = { -1, -1 };
const char *backend = (const char *)test_data;
int alarm_count=0, info_count=0;
struct tevent_fd *fde_read;
struct tevent_fd *fde_read_1;
struct tevent_fd *fde_write;
struct tevent_fd *fde_write_1;
#ifdef SA_RESTART
struct tevent_signal *se1 = NULL;
#endif
#ifdef SA_RESETHAND
struct tevent_signal *se2 = NULL;
#endif
#ifdef SA_SIGINFO
struct tevent_signal *se3 = NULL;
#endif
int finished=0;
struct timeval t;
int ret;
ev_ctx = tevent_context_init_byname(test, backend);
if (ev_ctx == NULL) {
torture_comment(test, "event backend '%s' not supported\n", backend);
return true;
}
torture_comment(test, "backend '%s' - %s\n",
backend, __FUNCTION__);
/* reset globals */
fde_count = 0;
/* create a pipe */
ret = pipe(fd);
torture_assert_int_equal(test, ret, 0, "pipe failed");
fde_read = tevent_add_fd(ev_ctx, ev_ctx, fd[0], TEVENT_FD_READ,
fde_handler_read, fd);
fde_write_1 = tevent_add_fd(ev_ctx, ev_ctx, fd[0], TEVENT_FD_WRITE,
fde_handler_write_1, fd);
fde_write = tevent_add_fd(ev_ctx, ev_ctx, fd[1], TEVENT_FD_WRITE,
fde_handler_write, fd);
fde_read_1 = tevent_add_fd(ev_ctx, ev_ctx, fd[1], TEVENT_FD_READ,
fde_handler_read_1, fd);
tevent_fd_set_auto_close(fde_read);
tevent_fd_set_auto_close(fde_write);
tevent_add_timer(ev_ctx, ev_ctx, timeval_current_ofs(2,0),
finished_handler, &finished);
#ifdef SA_RESTART
se1 = tevent_add_signal(ev_ctx, ev_ctx, SIGALRM, SA_RESTART, count_handler, &alarm_count);
torture_assert(test, se1 != NULL, "failed to setup se1");
#endif
#ifdef SA_RESETHAND
se2 = tevent_add_signal(ev_ctx, ev_ctx, SIGALRM, SA_RESETHAND, count_handler, &alarm_count);
torture_assert(test, se2 != NULL, "failed to setup se2");
#endif
#ifdef SA_SIGINFO
se3 = tevent_add_signal(ev_ctx, ev_ctx, SIGUSR1, SA_SIGINFO, count_handler, &info_count);
torture_assert(test, se3 != NULL, "failed to setup se3");
#endif
t = timeval_current();
while (!finished) {
errno = 0;
if (tevent_loop_once(ev_ctx) == -1) {
talloc_free(ev_ctx);
torture_fail(test, talloc_asprintf(test, "Failed event loop %s\n", strerror(errno)));
}
}
talloc_free(fde_read_1);
talloc_free(fde_write_1);
talloc_free(fde_read);
talloc_free(fde_write);
while (alarm_count < fde_count+1) {
if (tevent_loop_once(ev_ctx) == -1) {
break;
}
}
torture_comment(test, "Got %.2f pipe events/sec\n", fde_count/timeval_elapsed(&t));
#ifdef SA_RESTART
talloc_free(se1);
#endif
torture_assert_int_equal(test, alarm_count, 1+fde_count, "alarm count mismatch");
#ifdef SA_RESETHAND
/*
* we do not call talloc_free(se2)
* because it is already gone,
* after triggering the event handler.
*/
#endif
#ifdef SA_SIGINFO
talloc_free(se3);
torture_assert_int_equal(test, info_count, fde_count, "info count mismatch");
#endif
talloc_free(ev_ctx);
return true;
}
