int
evthread_set_lock_callbacks(const struct evthread_lock_callbacks *cbs)
{
struct evthread_lock_callbacks *target =
_evthread_lock_debugging_enabled
? &_original_lock_fns : &_evthread_lock_fns;
if (!cbs) {
if (target->alloc)
event_warnx("Trying to disable lock functions after "
"they have been set up will probaby not work.");
memset(target, 0, sizeof(_evthread_lock_fns));
return 0;
}
if (target->alloc) {
/* Uh oh; we already had locking callbacks set up.*/
if (!memcmp(target, cbs, sizeof(_evthread_lock_fns))) {
/* no change -- allow this. */
return 0;
}
event_warnx("Can't change lock callbacks once they have been "
"initialized.");
return -1;
}
if (cbs->alloc && cbs->free && cbs->lock && cbs->unlock) {
memcpy(target, cbs, sizeof(_evthread_lock_fns));
return event_global_setup_locks_(1);
} else {
return -1;
}
}
int
run_unmarshal(struct run *tmp, struct evbuffer *evbuf)
{
ev_uint32_t tag;
while (EVBUFFER_LENGTH(evbuf) > 0) {
if (evtag_peek(evbuf, &tag) == -1)
return (-1);
switch (tag) {
case RUN_HOW:
if (tmp->how_set)
return (-1);
if (evtag_unmarshal_string(evbuf, RUN_HOW, &tmp->how_data) == -1) {
event_warnx("%s: failed to unmarshal how", __func__);
return (-1);
}
tmp->how_set = 1;
break;
case RUN_SOME_BYTES:
if (tmp->some_bytes_set)
return (-1);
if (evtag_payload_length(evbuf, &tmp->some_bytes_length) == -1)
return (-1);
if (tmp->some_bytes_length > EVBUFFER_LENGTH(evbuf))
return (-1);
if ((tmp->some_bytes_data = malloc(tmp->some_bytes_length)) == NULL)
return (-1);
if (evtag_unmarshal_fixed(evbuf, RUN_SOME_BYTES, tmp->some_bytes_data, tmp->some_bytes_length) == -1) {
event_warnx("%s: failed to unmarshal some_bytes", __func__);
return (-1);
}
tmp->some_bytes_set = 1;
break;
case RUN_FIXED_BYTES:
if (tmp->fixed_bytes_set)
return (-1);
if (evtag_unmarshal_fixed(evbuf, RUN_FIXED_BYTES, tmp->fixed_bytes_data, sizeof(tmp->fixed_bytes_data)) == -1) {
event_warnx("%s: failed to unmarshal fixed_bytes", __func__);
return (-1);
}
tmp->fixed_bytes_set = 1;
break;
default:
return -1;
}
}
if (run_complete(tmp) == -1)
return (-1);
return (0);
}
int
kill_unmarshal(struct kill *tmp, struct evbuffer *evbuf)
{
ev_uint32_t tag;
while (evbuffer_get_length(evbuf) > 0) {
if (evtag_peek(evbuf, &tag) == -1)
return (-1);
switch (tag) {
case KILL_WEAPON:
if (tmp->weapon_set)
return (-1);
if (evtag_unmarshal_string(evbuf, KILL_WEAPON, &tmp->weapon_data) == -1) {
event_warnx("%s: failed to unmarshal weapon", __func__);
return (-1);
}
tmp->weapon_set = 1;
break;
case KILL_ACTION:
if (tmp->action_set)
return (-1);
if (evtag_unmarshal_string(evbuf, KILL_ACTION, &tmp->action_data) == -1) {
event_warnx("%s: failed to unmarshal action", __func__);
return (-1);
}
tmp->action_set = 1;
break;
case KILL_HOW_OFTEN:
if (tmp->how_often_length >= tmp->how_often_num_allocated &&
kill_how_often_expand_to_hold_more(tmp) < 0) {
puts("HEY NOW");
return (-1);
}
if (evtag_unmarshal_int(evbuf, KILL_HOW_OFTEN, &tmp->how_often_data[tmp->how_often_length]) == -1) {
event_warnx("%s: failed to unmarshal how_often", __func__);
return (-1);
}
++tmp->how_often_length;
tmp->how_often_set = 1;
break;
default:
return -1;
}
}
if (kill_complete(tmp) == -1)
return (-1);
return (0);
}
int
kill_unmarshal(struct kill *tmp, struct evbuffer *evbuf)
{
ev_uint32_t tag;
while (EVBUFFER_LENGTH(evbuf) > 0) {
if (evtag_peek(evbuf, &tag) == -1)
return (-1);
switch (tag) {
case KILL_WEAPON:
if (tmp->weapon_set)
return (-1);
if (evtag_unmarshal_string(evbuf, KILL_WEAPON, &tmp->weapon_data) == -1) {
event_warnx("%s: failed to unmarshal weapon", __func__);
return (-1);
}
tmp->weapon_set = 1;
break;
case KILL_ACTION:
if (tmp->action_set)
return (-1);
if (evtag_unmarshal_string(evbuf, KILL_ACTION, &tmp->action_data) == -1) {
event_warnx("%s: failed to unmarshal action", __func__);
return (-1);
}
tmp->action_set = 1;
break;
case KILL_HOW_OFTEN:
if (tmp->how_often_set)
return (-1);
if (evtag_unmarshal_int(evbuf, KILL_HOW_OFTEN, &tmp->how_often_data) == -1) {
event_warnx("%s: failed to unmarshal how_often", __func__);
return (-1);
}
tmp->how_often_set = 1;
break;
default:
return -1;
}
}
if (kill_complete(tmp) == -1)
return (-1);
return (0);
}
int
msg_run_assign(struct msg *msg, int off,
const struct run* value)
{
if (!msg->run_set || off < 0 || off >= msg->run_length)
return (-1);
{
int had_error = 0;
struct evbuffer *tmp = NULL;
run_clear(msg->run_data[off]);
if ((tmp = evbuffer_new()) == NULL) {
event_warn("%s: evbuffer_new()", __func__);
had_error = 1;
goto done;
}
run_marshal(tmp, value);
if (run_unmarshal(msg->run_data[off], tmp) == -1) {
event_warnx("%s: run_unmarshal", __func__);
had_error = 1;
goto done;
}
done:if (tmp != NULL)
evbuffer_free(tmp);
if (had_error) {
run_clear(msg->run_data[off]);
return (-1);
}
}
return (0);
}
static void __cdecl
evsig_handler(int sig)
{
int save_errno = errno;
#ifdef _WIN32
int socket_errno = EVUTIL_SOCKET_ERROR();
#endif
ev_uint8_t msg;
if (evsig_base == NULL) {
event_warnx(
"%s: received signal %d, but have no base configured",
__func__, sig);
return;
}
#ifndef EVENT__HAVE_SIGACTION
signal(sig, evsig_handler);
#endif
/* Wake up our notification mechanism */
msg = sig;
#ifdef _WIN32
send(evsig_base_fd, (char*)&msg, 1, 0);
#else
{
int r = write(evsig_base_fd, (char*)&msg, 1);
(void)r; /* Suppress 'unused return value' and 'unused var' */
}
#endif
errno = save_errno;
#ifdef _WIN32
EVUTIL_SET_SOCKET_ERROR(socket_errno);
#endif
}
//信号处理函数
static void __cdecl
evsig_handler(int sig)
{
int save_errno = errno;
#ifdef WIN32
int socket_errno = EVUTIL_SOCKET_ERROR();
#endif
ev_uint8_t msg;
if (evsig_base == NULL) {
event_warnx(
"%s: received signal %d, but have no base configured",
__func__, sig);
return;
}
#ifndef _EVENT_HAVE_SIGACTION
signal(sig, evsig_handler);
#endif
/* Wake up our notification mechanism */
msg = sig;
send(evsig_base_fd, (char*)&msg, 1, 0);//将激活的信号发送给base
errno = save_errno;
#ifdef WIN32
EVUTIL_SET_SOCKET_ERROR(socket_errno);
#endif
}
int
evthread_set_condition_callbacks(const struct evthread_condition_callbacks *cbs)
{
struct evthread_condition_callbacks *target = evthread_get_condition_callbacks();
#ifndef EVENT__DISABLE_DEBUG_MODE
if (event_debug_mode_on_) {
if (event_debug_created_threadable_ctx_) {
event_errx(1, "evthread initialization must be called BEFORE anything else!");
}
}
#endif
if (!cbs) {
if (target->alloc_condition)
event_warnx("Trying to disable condition functions "
"after they have been set up will probably not "
"work.");
memset(target, 0, sizeof(evthread_cond_fns_));
return 0;
}
if (target->alloc_condition) {
/* Uh oh; we already had condition callbacks set up.*/
if (target->condition_api_version == cbs->condition_api_version &&
target->alloc_condition == cbs->alloc_condition &&
target->free_condition == cbs->free_condition &&
target->signal_condition == cbs->signal_condition &&
target->wait_condition == cbs->wait_condition) {
/* no change -- allow this. */
return 0;
}
event_warnx("Can't change condition callbacks once they "
"have been initialized.");
return -1;
}
if (cbs->alloc_condition && cbs->free_condition &&
cbs->signal_condition && cbs->wait_condition) {
memcpy(target, cbs, sizeof(evthread_cond_fns_));
}
if (evthread_lock_debugging_enabled_) {
evthread_cond_fns_.alloc_condition = cbs->alloc_condition;
evthread_cond_fns_.free_condition = cbs->free_condition;
evthread_cond_fns_.signal_condition = cbs->signal_condition;
}
return 0;
}
int
evthread_set_lock_callbacks(const struct evthread_lock_callbacks *cbs)
{
struct evthread_lock_callbacks *target = evthread_get_lock_callbacks();
#ifndef EVENT__DISABLE_DEBUG_MODE
if (event_debug_mode_on_) {
if (event_debug_created_threadable_ctx_) {
event_errx(1, "evthread initialization must be called BEFORE anything else!");
}
}
#endif
if (!cbs) {
if (target->alloc)
event_warnx("Trying to disable lock functions after "
"they have been set up will probably not work.");
memset(target, 0, sizeof(evthread_lock_fns_));
return 0;
}
if (target->alloc) {
/* Uh oh; we already had locking callbacks set up.*/
if (target->lock_api_version == cbs->lock_api_version &&
target->supported_locktypes == cbs->supported_locktypes &&
target->alloc == cbs->alloc &&
target->free == cbs->free &&
target->lock == cbs->lock &&
target->unlock == cbs->unlock) {
/* no change -- allow this. */
return 0;
}
event_warnx("Can't change lock callbacks once they have been "
"initialized.");
return -1;
}
if (cbs->alloc && cbs->free && cbs->lock && cbs->unlock) {
memcpy(target, cbs, sizeof(evthread_lock_fns_));
return event_global_setup_locks_(1);
} else {
return -1;
}
}
int
evthread_set_condition_callbacks(const struct evthread_condition_callbacks *cbs)
{
struct evthread_condition_callbacks *target =
ompi__evthread_lock_debugging_enabled
? &_original_cond_fns : &ompi__evthread_cond_fns;
if (!cbs) {
if (target->alloc_condition)
event_warnx("Trying to disable condition functions "
"after they have been set up will probaby not "
"work.");
memset(target, 0, sizeof(ompi__evthread_cond_fns));
return 0;
}
if (target->alloc_condition) {
/* Uh oh; we already had condition callbacks set up.*/
if (target->condition_api_version == cbs->condition_api_version &&
target->alloc_condition == cbs->alloc_condition &&
target->free_condition == cbs->free_condition &&
target->signal_condition == cbs->signal_condition &&
target->wait_condition == cbs->wait_condition) {
/* no change -- allow this. */
return 0;
}
event_warnx("Can't change condition callbacks once they "
"have been initialized.");
return -1;
}
if (cbs->alloc_condition && cbs->free_condition &&
cbs->signal_condition && cbs->wait_condition) {
memcpy(target, cbs, sizeof(ompi__evthread_cond_fns));
}
if (ompi__evthread_lock_debugging_enabled) {
ompi__evthread_cond_fns.alloc_condition = cbs->alloc_condition;
ompi__evthread_cond_fns.free_condition = cbs->free_condition;
ompi__evthread_cond_fns.signal_condition = cbs->signal_condition;
}
return 0;
}
static int
evsig_add(struct event_base *base, evutil_socket_t evsignal, short old, short events, void *p)
{
struct evsig_info *sig = &base->sig;
(void)p;
EVUTIL_ASSERT(evsignal >= 0 && evsignal < NSIG);
/* catch signals if they happen quickly */
EVSIGBASE_LOCK();
if (evsig_base != base && evsig_base_n_signals_added) {
event_warnx("Added a signal to event base %p with signals "
"already added to event_base %p. Only one can have "
"signals at a time with the %s backend. The base with "
"the most recently added signal or the most recent "
"event_base_loop() call gets preference; do "
"not rely on this behavior in future Libevent versions.",
base, evsig_base, base->evsel->name);
}
evsig_base = base;
evsig_base_n_signals_added = ++sig->ev_n_signals_added;
evsig_base_fd = base->sig.ev_signal_pair[1];
EVSIGBASE_UNLOCK();
event_debug(("%s: %d: changing signal handler", __func__, (int)evsignal));
if (evsig_set_handler_(base, (int)evsignal, evsig_handler) == -1) {
goto err;
}
if (!sig->ev_signal_added) {
if (event_add(&sig->ev_signal, NULL))
goto err;
sig->ev_signal_added = 1;
}
return (0);
err:
EVSIGBASE_LOCK();
--evsig_base_n_signals_added;
--sig->ev_n_signals_added;
EVSIGBASE_UNLOCK();
return (-1);
}
int
run_notes_assign(struct run *msg, int off,
const char * value)
{
if (!msg->notes_set || off < 0 || off >= msg->notes_length)
return (-1);
{
if (msg->notes_data[off] != NULL)
free(msg->notes_data[off]);
msg->notes_data[off] = strdup(value);
if (msg->notes_data[off] == NULL) {
event_warnx("%s: strdup", __func__);
return (-1);
}
}
return (0);
}
static int
start_accepting(struct accepting_socket *as)
{
/* requires lock */
const struct win32_extension_fns *ext = event_get_win32_extension_fns();
DWORD pending = 0;
SOCKET s = socket(as->family, SOCK_STREAM, 0);
if (s == INVALID_SOCKET)
return -1;
setsockopt(s, SOL_SOCKET, SO_UPDATE_ACCEPT_CONTEXT,
(char *)&as->lev->fd, sizeof(&as->lev->fd));
if (!(as->lev->base.flags & LEV_OPT_LEAVE_SOCKETS_BLOCKING))
evutil_make_socket_nonblocking(s);
if (event_iocp_port_associate(as->lev->port, s, 1) < 0) {
closesocket(s);
return -1;
}
as->s = s;
if (ext->AcceptEx(as->lev->fd, s, as->addrbuf, 0,
as->buflen/2, as->buflen/2, &pending, &as->overlapped.overlapped))
{
/* Immediate success! */
accepted_socket_cb(&as->overlapped, 1, 0, 1);
} else {
int err = WSAGetLastError();
if (err != ERROR_IO_PENDING) {
event_warnx("AcceptEx: %s", evutil_socket_error_to_string(err));
return -1;
}
}
return 0;
}
static void
loop(void *_port)
{
struct event_iocp_port *port = _port;
long ms = port->ms;
HANDLE p = port->port;
if (ms <= 0)
ms = INFINITE;
while (1) {
OVERLAPPED *overlapped=NULL;
ULONG_PTR key=0;
DWORD bytes=0;
int ok = GetQueuedCompletionStatus(p, &bytes, &key,
&overlapped, ms);
EnterCriticalSection(&port->lock);
if (port->shutdown) {
if (--port->n_live_threads == 0)
ReleaseSemaphore(port->shutdownSemaphore, 1,
NULL);
LeaveCriticalSection(&port->lock);
return;
}
LeaveCriticalSection(&port->lock);
if (key != NOTIFICATION_KEY && overlapped)
handle_entry(overlapped, key, bytes, ok);
else if (!overlapped)
break;
}
event_warnx("GetQueuedCompletionStatus exited with no event.");
EnterCriticalSection(&port->lock);
if (--port->n_live_threads == 0)
ReleaseSemaphore(port->shutdownSemaphore, 1, NULL);
LeaveCriticalSection(&port->lock);
}
int
msg_attack_assign(struct msg *msg,
const struct kill* value)
{
struct evbuffer *tmp = NULL;
if (msg->attack_set) {
kill_clear(msg->attack_data);
msg->attack_set = 0;
} else {
msg->attack_data = kill_new();
if (msg->attack_data == NULL) {
event_warn("%s: kill_new()", __func__);
goto error;
}
}
if ((tmp = evbuffer_new()) == NULL) {
event_warn("%s: evbuffer_new()", __func__);
goto error;
}
kill_marshal(tmp, value);
if (kill_unmarshal(msg->attack_data, tmp) == -1) {
event_warnx("%s: kill_unmarshal", __func__);
goto error;
}
msg->attack_set = 1;
evbuffer_free(tmp);
return (0);
error:
if (tmp != NULL)
evbuffer_free(tmp);
if (msg->attack_data != NULL) {
kill_free(msg->attack_data);
msg->attack_data = NULL;
}
return (-1);
}
static void
test_evutil_log(void *ptr)
{
evutil_socket_t fd = -1;
char buf[128];
event_set_log_callback(logfn);
event_set_fatal_callback(fatalfn);
#define RESET() do { \
logsev = 0; \
if (logmsg) free(logmsg); \
logmsg = NULL; \
} while (0)
#define LOGEQ(sev,msg) do { \
tt_int_op(logsev,==,sev); \
tt_assert(logmsg != NULL); \
tt_str_op(logmsg,==,msg); \
} while (0)
#ifdef CAN_CHECK_ERR
/* We need to disable these tests for now. Previously, the logging
* module didn't enforce the requirement that a fatal callback
* actually exit. Now, it exits no matter what, so if we wan to
* reinstate these tests, we'll need to fork for each one. */
check_error_logging(errx_fn, 2, EVENT_LOG_ERR,
"Fatal error; too many kumquats (5)");
RESET();
#endif
event_warnx("Far too many %s (%d)", "wombats", 99);
LOGEQ(EVENT_LOG_WARN, "Far too many wombats (99)");
RESET();
event_msgx("Connecting lime to coconut");
LOGEQ(EVENT_LOG_MSG, "Connecting lime to coconut");
RESET();
event_debug(("A millisecond passed! We should log that!"));
#ifdef USE_DEBUG
LOGEQ(EVENT_LOG_DEBUG, "A millisecond passed! We should log that!");
#else
tt_int_op(logsev,==,0);
tt_ptr_op(logmsg,==,NULL);
#endif
RESET();
/* Try with an errno. */
errno = ENOENT;
event_warn("Couldn't open %s", "/bad/file");
evutil_snprintf(buf, sizeof(buf),
"Couldn't open /bad/file: %s",strerror(ENOENT));
LOGEQ(EVENT_LOG_WARN,buf);
RESET();
#ifdef CAN_CHECK_ERR
evutil_snprintf(buf, sizeof(buf),
"Couldn't open /very/bad/file: %s",strerror(ENOENT));
check_error_logging(err_fn, 5, EVENT_LOG_ERR, buf);
RESET();
#endif
/* Try with a socket errno. */
fd = socket(AF_INET, SOCK_STREAM, 0);
#ifdef _WIN32
evutil_snprintf(buf, sizeof(buf),
"Unhappy socket: %s",
evutil_socket_error_to_string(WSAEWOULDBLOCK));
EVUTIL_SET_SOCKET_ERROR(WSAEWOULDBLOCK);
#else
evutil_snprintf(buf, sizeof(buf),
"Unhappy socket: %s", strerror(EAGAIN));
errno = EAGAIN;
#endif
event_sock_warn(fd, "Unhappy socket");
LOGEQ(EVENT_LOG_WARN, buf);
RESET();
#ifdef CAN_CHECK_ERR
check_error_logging(sock_err_fn, 20, EVENT_LOG_ERR, buf);
RESET();
#endif
#undef RESET
#undef LOGEQ
end:
if (logmsg)
free(logmsg);
if (fd >= 0)
evutil_closesocket(fd);
}
int
bufferevent_init_common(struct bufferevent_private *bufev_private,
struct event_base *base,
const struct bufferevent_ops *ops,
enum bufferevent_options options)
{
struct bufferevent *bufev = &bufev_private->bev;
if (!bufev->input) {
if ((bufev->input = evbuffer_new()) == NULL)
return -1;
}
if (!bufev->output) {
if ((bufev->output = evbuffer_new()) == NULL) {
evbuffer_free(bufev->input);
return -1;
}
}
bufev_private->refcnt = 1;
bufev->ev_base = base;
/* Disable timeouts. */
evutil_timerclear(&bufev->timeout_read);
evutil_timerclear(&bufev->timeout_write);
bufev->be_ops = ops;
_bufferevent_ratelim_init(bufev_private);
/*
* Set to EV_WRITE so that using bufferevent_write is going to
* trigger a callback. Reading needs to be explicitly enabled
* because otherwise no data will be available.
*/
bufev->enabled = EV_WRITE;
#ifndef _EVENT_DISABLE_THREAD_SUPPORT
if (options & BEV_OPT_THREADSAFE) {
if (bufferevent_enable_locking(bufev, NULL) < 0) {
/* cleanup */
evbuffer_free(bufev->input);
evbuffer_free(bufev->output);
bufev->input = NULL;
bufev->output = NULL;
return -1;
}
}
#endif
if ((options & (BEV_OPT_DEFER_CALLBACKS|BEV_OPT_UNLOCK_CALLBACKS))
== BEV_OPT_UNLOCK_CALLBACKS) {
event_warnx("UNLOCK_CALLBACKS requires DEFER_CALLBACKS");
return -1;
}
if (options & BEV_OPT_DEFER_CALLBACKS) {
if (options & BEV_OPT_UNLOCK_CALLBACKS)
event_deferred_cb_init(&bufev_private->deferred,
bufferevent_run_deferred_callbacks_unlocked,
bufev_private);
else
event_deferred_cb_init(&bufev_private->deferred,
bufferevent_run_deferred_callbacks_locked,
bufev_private);
}
bufev_private->options = options;
evbuffer_set_parent(bufev->input, bufev);
evbuffer_set_parent(bufev->output, bufev);
return 0;
}
static void
test_evutil_log(void *ptr)
{
evutil_socket_t fd = -1;
char buf[128];
event_set_log_callback(logfn);
event_set_fatal_callback(fatalfn);
#define RESET() do { \
logsev = exited = exitcode = 0; \
if (logmsg) free(logmsg); \
logmsg = NULL; \
} while (0)
#define LOGEQ(sev,msg) do { \
tt_int_op(logsev,==,sev); \
tt_assert(logmsg != NULL); \
tt_str_op(logmsg,==,msg); \
} while (0)
event_errx(2, "Fatal error; too many kumquats (%d)", 5);
LOGEQ(_EVENT_LOG_ERR, "Fatal error; too many kumquats (5)");
tt_int_op(exitcode,==,2);
RESET();
event_warnx("Far too many %s (%d)", "wombats", 99);
LOGEQ(_EVENT_LOG_WARN, "Far too many wombats (99)");
tt_int_op(exited,==,0);
RESET();
event_msgx("Connecting lime to coconut");
LOGEQ(_EVENT_LOG_MSG, "Connecting lime to coconut");
tt_int_op(exited,==,0);
RESET();
event_debug(("A millisecond passed! We should log that!"));
#ifdef USE_DEBUG
LOGEQ(_EVENT_LOG_DEBUG, "A millisecond passed! We should log that!");
#else
tt_int_op(logsev,==,0);
tt_ptr_op(logmsg,==,NULL);
#endif
RESET();
/* Try with an errno. */
errno = ENOENT;
event_warn("Couldn't open %s", "/bad/file");
evutil_snprintf(buf, sizeof(buf),
"Couldn't open /bad/file: %s",strerror(ENOENT));
LOGEQ(_EVENT_LOG_WARN,buf);
tt_int_op(exited, ==, 0);
RESET();
errno = ENOENT;
event_err(5,"Couldn't open %s", "/very/bad/file");
evutil_snprintf(buf, sizeof(buf),
"Couldn't open /very/bad/file: %s",strerror(ENOENT));
LOGEQ(_EVENT_LOG_ERR,buf);
tt_int_op(exitcode, ==, 5);
RESET();
/* Try with a socket errno. */
fd = socket(AF_INET, SOCK_STREAM, 0);
#ifdef WIN32
evutil_snprintf(buf, sizeof(buf),
"Unhappy socket: %s",
evutil_socket_error_to_string(WSAEWOULDBLOCK));
EVUTIL_SET_SOCKET_ERROR(WSAEWOULDBLOCK);
#else
evutil_snprintf(buf, sizeof(buf),
"Unhappy socket: %s", strerror(EAGAIN));
errno = EAGAIN;
#endif
event_sock_warn(fd, "Unhappy socket");
LOGEQ(_EVENT_LOG_WARN, buf);
tt_int_op(exited,==,0);
RESET();
#ifdef WIN32
EVUTIL_SET_SOCKET_ERROR(WSAEWOULDBLOCK);
#else
errno = EAGAIN;
#endif
event_sock_err(200, fd, "Unhappy socket");
LOGEQ(_EVENT_LOG_ERR, buf);
tt_int_op(exitcode,==,200);
RESET();
#undef RESET
#undef LOGEQ
end:
if (logmsg)
free(logmsg);
if (fd >= 0)
EVUTIL_CLOSESOCKET(fd);
}
int
run_unmarshal(struct run *tmp, struct evbuffer *evbuf)
{
ev_uint32_t tag;
while (evbuffer_get_length(evbuf) > 0) {
if (evtag_peek(evbuf, &tag) == -1)
return (-1);
switch (tag) {
case RUN_HOW:
if (tmp->how_set)
return (-1);
if (evtag_unmarshal_string(evbuf, RUN_HOW, &tmp->how_data) == -1) {
event_warnx("%s: failed to unmarshal how", __func__);
return (-1);
}
tmp->how_set = 1;
break;
case RUN_SOME_BYTES:
if (tmp->some_bytes_set)
return (-1);
if (evtag_payload_length(evbuf, &tmp->some_bytes_length) == -1)
return (-1);
if (tmp->some_bytes_length > evbuffer_get_length(evbuf))
return (-1);
if ((tmp->some_bytes_data = malloc(tmp->some_bytes_length)) == NULL)
return (-1);
if (evtag_unmarshal_fixed(evbuf, RUN_SOME_BYTES, tmp->some_bytes_data, tmp->some_bytes_length) == -1) {
event_warnx("%s: failed to unmarshal some_bytes", __func__);
return (-1);
}
tmp->some_bytes_set = 1;
break;
case RUN_FIXED_BYTES:
if (tmp->fixed_bytes_set)
return (-1);
if (evtag_unmarshal_fixed(evbuf, RUN_FIXED_BYTES, tmp->fixed_bytes_data, (24)) == -1) {
event_warnx("%s: failed to unmarshal fixed_bytes", __func__);
return (-1);
}
tmp->fixed_bytes_set = 1;
break;
case RUN_NOTES:
if (tmp->notes_length >= tmp->notes_num_allocated &&
run_notes_expand_to_hold_more(tmp) < 0) {
puts("HEY NOW");
return (-1);
}
if (evtag_unmarshal_string(evbuf, RUN_NOTES, &tmp->notes_data[tmp->notes_length]) == -1) {
event_warnx("%s: failed to unmarshal notes", __func__);
return (-1);
}
++tmp->notes_length;
tmp->notes_set = 1;
break;
case RUN_LARGE_NUMBER:
if (tmp->large_number_set)
return (-1);
if (evtag_unmarshal_int64(evbuf, RUN_LARGE_NUMBER, &tmp->large_number_data) == -1) {
event_warnx("%s: failed to unmarshal large_number", __func__);
return (-1);
}
tmp->large_number_set = 1;
break;
case RUN_OTHER_NUMBERS:
if (tmp->other_numbers_length >= tmp->other_numbers_num_allocated &&
run_other_numbers_expand_to_hold_more(tmp) < 0) {
puts("HEY NOW");
return (-1);
}
if (evtag_unmarshal_int(evbuf, RUN_OTHER_NUMBERS, &tmp->other_numbers_data[tmp->other_numbers_length]) == -1) {
event_warnx("%s: failed to unmarshal other_numbers", __func__);
return (-1);
}
++tmp->other_numbers_length;
tmp->other_numbers_set = 1;
break;
default:
return -1;
}
}
if (run_complete(tmp) == -1)
return (-1);
return (0);
}
int
msg_unmarshal(struct msg *tmp, struct evbuffer *evbuf)
{
ev_uint32_t tag;
while (EVBUFFER_LENGTH(evbuf) > 0) {
if (evtag_peek(evbuf, &tag) == -1)
return (-1);
switch (tag) {
case MSG_FROM_NAME:
if (tmp->from_name_set)
return (-1);
if (evtag_unmarshal_string(evbuf, MSG_FROM_NAME, &tmp->from_name_data) == -1) {
event_warnx("%s: failed to unmarshal from_name", __func__);
return (-1);
}
tmp->from_name_set = 1;
break;
case MSG_TO_NAME:
if (tmp->to_name_set)
return (-1);
if (evtag_unmarshal_string(evbuf, MSG_TO_NAME, &tmp->to_name_data) == -1) {
event_warnx("%s: failed to unmarshal to_name", __func__);
return (-1);
}
tmp->to_name_set = 1;
break;
case MSG_ATTACK:
if (tmp->attack_set)
return (-1);
tmp->attack_data = kill_new();
if (tmp->attack_data == NULL)
return (-1);
if (evtag_unmarshal_kill(evbuf, MSG_ATTACK, tmp->attack_data) == -1) {
event_warnx("%s: failed to unmarshal attack", __func__);
return (-1);
}
tmp->attack_set = 1;
break;
case MSG_RUN:
if (msg_run_add(tmp) == NULL)
return (-1);
if (evtag_unmarshal_run(evbuf, MSG_RUN,
tmp->run_data[tmp->run_length - 1]) == -1) {
--tmp->run_length;
event_warnx("%s: failed to unmarshal run", __func__);
return (-1);
}
tmp->run_set = 1;
break;
default:
return -1;
}
}
if (msg_complete(tmp) == -1)
return (-1);
return (0);
}
struct evconnlistener *
evconnlistener_new_async(struct event_base *base,
evconnlistener_cb cb, void *ptr, unsigned flags, int backlog,
evutil_socket_t fd)
{
struct sockaddr_storage ss;
int socklen = sizeof(ss);
struct evconnlistener_iocp *lev;
int i;
flags |= LEV_OPT_THREADSAFE;
if (!base || !event_base_get_iocp(base))
goto err;
/* XXXX duplicate code */
if (backlog > 0) {
if (listen(fd, backlog) < 0)
goto err;
} else if (backlog < 0) {
if (listen(fd, 128) < 0)
goto err;
}
if (getsockname(fd, (struct sockaddr*)&ss, &socklen)) {
event_sock_warn(fd, "getsockname");
goto err;
}
lev = mm_calloc(1, sizeof(struct evconnlistener_iocp));
if (!lev) {
event_warn("calloc");
goto err;
}
lev->base.ops = &evconnlistener_iocp_ops;
lev->base.cb = cb;
lev->base.user_data = ptr;
lev->base.flags = flags;
lev->base.refcnt = 1;
lev->base.enabled = 1;
lev->port = event_base_get_iocp(base);
lev->fd = fd;
lev->event_base = base;
if (event_iocp_port_associate(lev->port, fd, 1) < 0)
goto err_free_lev;
EVTHREAD_ALLOC_LOCK(lev->base.lock, EVTHREAD_LOCKTYPE_RECURSIVE);
lev->n_accepting = N_SOCKETS_PER_LISTENER;
lev->accepting = mm_calloc(lev->n_accepting,
sizeof(struct accepting_socket *));
if (!lev->accepting) {
event_warn("calloc");
goto err_delete_lock;
}
for (i = 0; i < lev->n_accepting; ++i) {
lev->accepting[i] = new_accepting_socket(lev, ss.ss_family);
if (!lev->accepting[i]) {
event_warnx("Couldn't create accepting socket");
goto err_free_accepting;
}
if (cb && start_accepting(lev->accepting[i]) < 0) {
event_warnx("Couldn't start accepting on socket");
EnterCriticalSection(&lev->accepting[i]->lock);
free_and_unlock_accepting_socket(lev->accepting[i]);
goto err_free_accepting;
}
++lev->base.refcnt;
}
iocp_listener_event_add(lev);
return &lev->base;
err_free_accepting:
mm_free(lev->accepting);
/* XXXX free the other elements. */
err_delete_lock:
EVTHREAD_FREE_LOCK(lev->base.lock, EVTHREAD_LOCKTYPE_RECURSIVE);
err_free_lev:
mm_free(lev);
err:
/* Don't close the fd, it is caller's responsibility. */
return NULL;
}
int
msg_unmarshal(struct msg *tmp, struct evbuffer *evbuf)
{
ev_uint32_t tag;
while (evbuffer_get_length(evbuf) > 0) {
if (evtag_peek(evbuf, &tag) == -1)
return (-1);
switch (tag) {
case MSG_FROM_NAME:
if (tmp->from_name_set)
return (-1);
if (evtag_unmarshal_string(evbuf, MSG_FROM_NAME, &tmp->from_name_data) == -1) {
event_warnx("%s: failed to unmarshal from_name", __func__);
return (-1);
}
tmp->from_name_set = 1;
break;
case MSG_TO_NAME:
if (tmp->to_name_set)
return (-1);
if (evtag_unmarshal_string(evbuf, MSG_TO_NAME, &tmp->to_name_data) == -1) {
event_warnx("%s: failed to unmarshal to_name", __func__);
return (-1);
}
tmp->to_name_set = 1;
break;
case MSG_ATTACK:
if (tmp->attack_set)
return (-1);
tmp->attack_data = kill_new();
if (tmp->attack_data == NULL)
return (-1);
if (evtag_unmarshal_kill(evbuf, MSG_ATTACK, tmp->attack_data) == -1) {
event_warnx("%s: failed to unmarshal attack", __func__);
return (-1);
}
tmp->attack_set = 1;
break;
case MSG_RUN:
if (tmp->run_length >= tmp->run_num_allocated &&
msg_run_expand_to_hold_more(tmp) < 0) {
puts("HEY NOW");
return (-1);
}
tmp->run_data[tmp->run_length] = run_new();
if (tmp->run_data[tmp->run_length] == NULL)
return (-1);
if (evtag_unmarshal_run(evbuf, MSG_RUN, tmp->run_data[tmp->run_length]) == -1) {
event_warnx("%s: failed to unmarshal run", __func__);
return (-1);
}
++tmp->run_length;
tmp->run_set = 1;
break;
default:
return -1;
}
}
if (msg_complete(tmp) == -1)
return (-1);
return (0);
}
