void Client::UnsetWriteEvent()
{
short event = event_get_events(m_event);
event_del(m_event);
event_assign(m_event, m_server->m_server_base, m_sockfd, event & (~EV_WRITE), Client::ClientEventCallback, this);
event_add(m_event, NULL);
}
static int lcb_io_update_timer(struct lcb_io_opt_st *iops,
void *timer,
lcb_uint32_t usec,
void *cb_data,
void (*handler)(lcb_socket_t sock,
short which,
void *cb_data))
{
short flags = EV_TIMEOUT | EV_PERSIST;
struct timeval tmo;
if (flags == event_get_events(timer) &&
handler == event_get_callback(timer)) {
/* no change! */
return 0;
}
if (event_pending(timer, EV_TIMEOUT, 0)) {
event_del(timer);
}
event_assign(timer, ((struct libevent_cookie *)iops->v.v2.cookie)->base, -1, flags, handler, cb_data);
tmo.tv_sec = usec / 1000000;
tmo.tv_usec = usec % 1000000;
return event_add(timer, &tmo);
}
int
main() {
pipe(pp);
struct event_base *base = event_base_new();
evr = event_new(base, pp[0], EV_READ, read_cb, NULL);
evw = event_new(base, pp[1], EV_WRITE | EV_TIMEOUT, write_cb, NULL);
event_add(evw, NULL);
event_add(evr, NULL);
struct event_base *outbase;
int fdout;
event_get_assignment(evw, NULL, &fdout, NULL, NULL, NULL); /* Note fdout. */
outbase = event_get_base(evw); /* outbase == base */
event_callback_fn cb = event_get_callback(evw);
assert(write_cb == cb);
assert(NULL == event_get_callback_arg(evw));
assert(EV_WRITE|EV_TIMEOUT == event_get_events(evw));
assert(pp[1] == event_get_fd(evw));
assert(event_initialized(evw) == 1);
test_num_events();
event_base_dispatch(base);
return 0;
}
void send_reply_to_subcli(sub_client *c)
{
int nwritelen, sentlen = 0;
while (c->wbufpos > 0) {
nwritelen = write(c->fd, c->wbuf+sentlen, c->wbufpos-sentlen);
if (nwritelen <= 0) {
break;
}
sentlen += nwritelen;
if (sentlen == c->wbufpos) {
c->wbufpos = 0;
}
}
if (nwritelen == -1) {
if (errno == EAGAIN) {
return;
} else {
srv_log(LOG_ERROR, "Error writing to client: %s", strerror(errno));
sub_cli_release(c);
return;
}
}
subcli_event_update(c, event_get_events(c->ev) & ~EV_WRITE);
}
void Client::NotWantRead()
{
m_want_read = false;
short event = event_get_events(m_event);
event_del(m_event);
event_assign(m_event, m_server->m_server_base, m_sockfd, event & (~EV_READ), Client::ClientEventCallback, this);
event_add(m_event, NULL);
}
static int prepare_to_write(sub_client *c)
{
short event = event_get_events(c->ev);
if (!(event & EV_WRITE)) {
return subcli_event_update(c, event | EV_WRITE);
}
return SUBCLI_OK;
}
static int lcb_io_update_event(struct lcb_io_opt_st *iops,
lcb_socket_t sock,
void *event,
short flags,
void *cb_data,
void (*handler)(lcb_socket_t sock,
short which,
void *cb_data))
{
flags |= EV_PERSIST;
if (flags == event_get_events(event) &&
handler == event_get_callback(event)) {
/* no change! */
return 0;
}
if (event_pending(event, EV_READ | EV_WRITE, 0)) {
event_del(event);
}
event_assign(event, ((struct libevent_cookie *)iops->v.v2.cookie)->base, sock, flags, handler, cb_data);
return event_add(event, NULL);
}
int
cleanup_main (struct state *state)
{
int i;
for (i = 0; i < E_MAX; ++i)
{
struct event *e = state->events[i];
if (e)
{
int fd = event_get_fd (e);
if (fd >= 0 && ! (event_get_events (e) & EV_SIGNAL))
close (fd);
event_free (e);
}
}
/* The other half was closed above. */
platform->file_close (state->tlsdate_monitor_fd);
if (state->tlsdate_pid)
{
platform->process_signal (state->tlsdate_pid, SIGKILL);
platform->process_wait (state->tlsdate_pid, NULL, 0 /* !forever */);
}
/* Best effort to tear it down if it is still alive. */
close(state->setter_notify_fd);
close(state->setter_save_fd);
if (state->setter_pid)
{
platform->process_signal (state->setter_pid, SIGKILL);
platform->process_wait (state->setter_pid, NULL, 0 /* !forever */);
}
/* TODO(wad) Add dbus_cleanup() */
if (state->base)
event_base_free (state->base);
memset(state, 0, sizeof(*state));
return 0;
}
