249 lines
6.3 KiB
C
249 lines
6.3 KiB
C
/*
|
|
* libwebsockets - small server side websockets and web server implementation
|
|
*
|
|
* Copyright (C) 2010-2014 Andy Green <andy@warmcat.com>
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation:
|
|
* version 2.1 of the License.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
|
|
* MA 02110-1301 USA
|
|
*/
|
|
|
|
#include "private-libwebsockets.h"
|
|
|
|
void lws_feature_status_libevent(struct lws_context_creation_info *info)
|
|
{
|
|
if (lws_check_opt(info->options, LWS_SERVER_OPTION_LIBEVENT))
|
|
lwsl_notice("libevent support compiled in and enabled\n");
|
|
else
|
|
lwsl_notice("libevent support compiled in but disabled\n");
|
|
}
|
|
|
|
static void
|
|
lws_event_cb(evutil_socket_t sock_fd, short revents, void *ctx)
|
|
{
|
|
struct lws_io_watcher *lws_io = (struct lws_io_watcher *)ctx;
|
|
struct lws_context *context = lws_io->context;
|
|
struct lws_pollfd eventfd;
|
|
|
|
if (revents & EV_TIMEOUT)
|
|
return;
|
|
|
|
/* !!! EV_CLOSED doesn't exist in libevent2 */
|
|
#if LIBEVENT_VERSION_NUMBER < 0x02000000
|
|
if (revents & EV_CLOSED)
|
|
{
|
|
event_del(lws_io->event_watcher);
|
|
event_free(lws_io->event_watcher);
|
|
return;
|
|
}
|
|
#endif
|
|
|
|
eventfd.fd = sock_fd;
|
|
eventfd.events = 0;
|
|
eventfd.revents = 0;
|
|
if (revents & EV_READ)
|
|
{
|
|
eventfd.events |= LWS_POLLIN;
|
|
eventfd.revents |= LWS_POLLIN;
|
|
}
|
|
if (revents & EV_WRITE)
|
|
{
|
|
eventfd.events |= LWS_POLLOUT;
|
|
eventfd.revents |= LWS_POLLOUT;
|
|
}
|
|
lws_service_fd(context, &eventfd);
|
|
}
|
|
|
|
LWS_VISIBLE void
|
|
lws_event_sigint_cb(evutil_socket_t sock_fd, short revents, void *ctx)
|
|
{
|
|
struct lws_context_per_thread *pt = ctx;
|
|
if (!pt->ev_loop_foreign)
|
|
event_base_loopbreak(pt->io_loop_event_base);
|
|
}
|
|
|
|
LWS_VISIBLE int
|
|
lws_event_sigint_cfg(struct lws_context *context, int use_event_sigint,
|
|
lws_event_signal_cb_t *cb)
|
|
{
|
|
context->use_ev_sigint = use_event_sigint;
|
|
if (cb)
|
|
context->lws_event_sigint_cb = cb;
|
|
else
|
|
context->lws_event_sigint_cb = &lws_event_sigint_cb;
|
|
|
|
return 0;
|
|
}
|
|
|
|
LWS_VISIBLE int
|
|
lws_event_initloop(struct lws_context *context, struct event_base *loop,
|
|
int tsi)
|
|
{
|
|
if (!loop)
|
|
{
|
|
context->pt[tsi].io_loop_event_base = event_base_new();
|
|
}
|
|
else
|
|
{
|
|
context->pt[tsi].ev_loop_foreign = 1;
|
|
context->pt[tsi].io_loop_event_base = loop;
|
|
}
|
|
|
|
/*
|
|
* Initialize all events with the listening sockets
|
|
* and register a callback for read operations
|
|
*/
|
|
struct lws_vhost *vh = context->vhost_list;
|
|
while (vh)
|
|
{
|
|
if (vh->lserv_wsi)
|
|
{
|
|
vh->lserv_wsi->w_read.context = context;
|
|
vh->lserv_wsi->w_read.event_watcher = event_new(
|
|
loop,
|
|
vh->lserv_wsi->desc.sockfd,
|
|
(EV_READ | EV_PERSIST),
|
|
lws_event_cb,
|
|
&vh->lserv_wsi->w_read);
|
|
event_add(vh->lserv_wsi->w_read.event_watcher, NULL);
|
|
}
|
|
vh = vh->vhost_next;
|
|
}
|
|
|
|
/* Register the signal watcher unless the user says not to */
|
|
if (context->use_ev_sigint)
|
|
{
|
|
struct event *w_sigint = evsignal_new(loop, SIGINT,
|
|
context->lws_event_sigint_cb, &context->pt[tsi]);
|
|
context->pt[tsi].w_sigint.event_watcher = w_sigint;
|
|
event_add(w_sigint, NULL);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
void
|
|
lws_libevent_destroyloop(struct lws_context *context, int tsi)
|
|
{
|
|
if (!lws_check_opt(context->options, LWS_SERVER_OPTION_LIBEVENT))
|
|
return;
|
|
|
|
struct lws_context_per_thread *pt = &context->pt[tsi];
|
|
if (!pt->io_loop_event_base)
|
|
return;
|
|
|
|
/*
|
|
* Free all events with the listening sockets
|
|
*/
|
|
struct lws_vhost *vh = context->vhost_list;
|
|
while (vh)
|
|
{
|
|
if (vh->lserv_wsi)
|
|
{
|
|
event_free(vh->lserv_wsi->w_read.event_watcher);
|
|
vh->lserv_wsi->w_read.event_watcher = NULL;
|
|
}
|
|
vh = vh->vhost_next;
|
|
}
|
|
|
|
if (context->use_ev_sigint)
|
|
event_free(pt->w_sigint.event_watcher);
|
|
if (!pt->ev_loop_foreign)
|
|
event_base_free(pt->io_loop_event_base);
|
|
}
|
|
|
|
LWS_VISIBLE void
|
|
lws_libevent_accept(struct lws *new_wsi, lws_sock_file_fd_type desc)
|
|
{
|
|
struct lws_context *context = lws_get_context(new_wsi);
|
|
if (!LWS_LIBEVENT_ENABLED(context))
|
|
return;
|
|
|
|
new_wsi->w_read.context = context;
|
|
new_wsi->w_write.context = context;
|
|
|
|
// Initialize the event
|
|
struct lws_context_per_thread *pt = &context->pt[(int)new_wsi->tsi];
|
|
int fd;
|
|
if (new_wsi->mode == LWSCM_RAW_FILEDESC)
|
|
fd = desc.filefd;
|
|
else
|
|
fd = desc.sockfd;
|
|
new_wsi->w_read.event_watcher = event_new(pt->io_loop_event_base, fd,
|
|
(EV_READ | EV_PERSIST), lws_event_cb, &new_wsi->w_read);
|
|
new_wsi->w_write.event_watcher = event_new(pt->io_loop_event_base, fd,
|
|
(EV_WRITE | EV_PERSIST), lws_event_cb, &new_wsi->w_write);
|
|
}
|
|
|
|
LWS_VISIBLE void
|
|
lws_libevent_io(struct lws *wsi, int flags)
|
|
{
|
|
struct lws_context *context = lws_get_context(wsi);
|
|
|
|
if (!LWS_LIBEVENT_ENABLED(context))
|
|
return;
|
|
|
|
struct lws_context_per_thread *pt = &wsi->context->pt[(int)wsi->tsi];
|
|
if (!pt->io_loop_event_base || context->being_destroyed)
|
|
return;
|
|
|
|
assert((flags & (LWS_EV_START | LWS_EV_STOP)) &&
|
|
(flags & (LWS_EV_READ | LWS_EV_WRITE)));
|
|
|
|
if (flags & LWS_EV_START)
|
|
{
|
|
if (flags & LWS_EV_WRITE)
|
|
{
|
|
event_add(wsi->w_write.event_watcher, NULL);
|
|
}
|
|
if (flags & LWS_EV_READ)
|
|
{
|
|
event_add(wsi->w_read.event_watcher, NULL);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (flags & LWS_EV_WRITE)
|
|
{
|
|
event_del(wsi->w_write.event_watcher);
|
|
}
|
|
if (flags & LWS_EV_READ)
|
|
{
|
|
event_del(wsi->w_read.event_watcher);
|
|
}
|
|
}
|
|
}
|
|
|
|
LWS_VISIBLE int
|
|
lws_libevent_init_fd_table(struct lws_context *context)
|
|
{
|
|
if (!LWS_LIBEVENT_ENABLED(context))
|
|
return 0;
|
|
|
|
int n;
|
|
for (n = 0; n < context->count_threads; n++)
|
|
{
|
|
context->pt[n].w_sigint.context = context;
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
LWS_VISIBLE void
|
|
lws_libevent_run(const struct lws_context *context, int tsi)
|
|
{
|
|
// Run/Dispatch the event_base loop
|
|
if (context->pt[tsi].io_loop_event_base && LWS_LIBEVENT_ENABLED(context))
|
|
event_base_dispatch(context->pt[tsi].io_loop_event_base);
|
|
}
|