static void
accept_cb(struct ev_loop *loop, ev_uinet *w, int revents)
{
struct passive_context *passive = w->data;
struct uinet_socket *newso = NULL;
struct uinet_socket *newpeerso = NULL;
struct connection_context *conn = NULL;
struct connection_context *peerconn = NULL;
int error;
int batch_limit = 32;
int processed = 0;
while ((processed < batch_limit) &&
(UINET_EWOULDBLOCK != (error = uinet_soaccept(w->so, NULL, &newso)))) {
processed++;
if (0 == error) {
newpeerso = NULL;
conn = NULL;
peerconn = NULL;
if (passive->verbose)
printf("accept succeeded\n");
conn = create_conn(passive, newso, 1);
if (NULL == conn)
goto fail;
newpeerso = uinet_sogetpassivepeer(newso);
peerconn = create_conn(passive, newpeerso, 0);
if (NULL == peerconn)
goto fail;
conn->peer = peerconn;
peerconn->peer = conn;
ev_uinet_start(loop, &conn->watcher);
if (!passive->extract)
ev_uinet_start(loop, &peerconn->watcher);
passive->interface->num_sockets += 2;
continue;
fail:
if (conn) destroy_conn(conn);
if (newso) uinet_soclose(newso);
if (newpeerso) uinet_soclose(newpeerso);
}
}
if (processed > passive->interface->max_accept_batch)
passive->interface->max_accept_batch = processed;
}
static void
echo_accept_cb(struct ev_loop *loop, ev_uinet *w, int revents)
{
struct uinet_demo_echo *echo = w->data;
struct uinet_socket *newso = NULL;
struct ev_uinet_ctx *soctx = NULL;
struct echo_connection *conn = NULL;
int error;
if (0 != (error = uinet_soaccept(w->so, NULL, &newso))) {
printf("%s: Accept failed (%d)\n", echo->cfg.name, error);
} else {
if (echo->cfg.verbose)
printf("%s: Accept succeeded\n", echo->cfg.name);
soctx = ev_uinet_attach(newso);
if (NULL == soctx) {
printf("%s: Failed to alloc libev context for new connection\n",
echo->cfg.name);
goto fail;
}
conn = malloc(sizeof(*conn));
if (NULL == conn) {
printf("%s: Failed to alloc new connection context\n",
echo->cfg.name);
goto fail;
}
conn->echo = echo;
conn->id = echo->next_id++;
conn->verbose = echo->cfg.verbose;
ev_init(&conn->connected_watcher, echo_connected_cb);
ev_uinet_set(&conn->connected_watcher, soctx, EV_WRITE);
conn->connected_watcher.data = conn;
if (conn->verbose || (echo->cfg.copy_mode & UINET_IP_COPY_MODE_MAYBE))
ev_uinet_start(loop, &conn->connected_watcher);
ev_init(&conn->watcher, echo_cb);
ev_uinet_set(&conn->watcher, soctx, EV_READ);
conn->watcher.data = conn;
ev_uinet_start(loop, &conn->watcher);
}
return;
fail:
if (conn) free(conn);
if (soctx) ev_uinet_detach(soctx);
if (newso) uinet_soclose(newso);
}
static void
accept_cb(struct ev_loop *loop, ev_uinet *w, int revents)
{
struct echo_context *echo = w->data;
struct uinet_socket *newso = NULL;
struct connection_context *conn = NULL;
struct ev_uinet_ctx *soctx = NULL;
int error;
if (0 != (error = uinet_soaccept(w->so, NULL, &newso))) {
printf("accept failed (%d)\n", error);
} else {
printf("accept succeeded\n");
soctx = ev_uinet_attach(newso);
if (NULL == soctx) {
printf("Failed to alloc libev context for new connection socket\n");
goto fail;
}
conn = malloc(sizeof(*conn));
if (NULL == conn) {
printf("Failed to alloc connection context for new connection\n");
goto fail;
}
ev_init(&conn->watcher, echo_cb);
ev_uinet_set(&conn->watcher, soctx, EV_READ);
conn->watcher.data = conn;
ev_uinet_start(loop, &conn->watcher);
}
return;
fail:
if (conn) free(conn);
if (soctx) ev_uinet_detach(soctx);
if (newso) uinet_soclose(newso);
}
static void
passive_accept_cb(struct ev_loop *loop, ev_uinet *w, int revents)
{
struct uinet_demo_passive *passive = w->data;
struct uinet_socket *newso = NULL;
struct uinet_socket *newpeerso = NULL;
struct passive_connection *conn = NULL;
struct passive_connection *peerconn = NULL;
int error;
unsigned int batch_limit = 32;
unsigned int processed = 0;
while ((processed < batch_limit) &&
(UINET_EWOULDBLOCK != (error = uinet_soaccept(w->so, NULL, &newso)))) {
processed++;
if (0 == error) {
newpeerso = NULL;
conn = NULL;
peerconn = NULL;
if (passive->cfg.verbose)
printf("%s: Accept succeeded\n", passive->cfg.name);
conn = create_conn(passive, newso, 1);
if (NULL == conn) {
printf("%s: Failed to alloc new connection context\n",
passive->cfg.name);
goto fail;
}
newpeerso = uinet_sogetpassivepeer(newso);
peerconn = create_conn(passive, newpeerso, 0);
if (NULL == peerconn) {
printf("%s: Failed to alloc new peer connection context\n",
passive->cfg.name);
goto fail;
}
conn->peer = peerconn;
peerconn->peer = conn;
ev_uinet_start(loop, &conn->watcher);
ev_uinet_start(loop, &peerconn->watcher);
if (conn->verbose || (passive->cfg.copy_mode & UINET_IP_COPY_MODE_MAYBE))
ev_uinet_start(loop, &conn->connected_watcher);
if (peerconn->verbose || (passive->cfg.copy_mode & UINET_IP_COPY_MODE_MAYBE))
ev_uinet_start(loop, &peerconn->connected_watcher);
passive->num_sockets += 2;
continue;
fail:
if (conn) destroy_conn(conn);
if (newso) uinet_soclose(newso);
if (newpeerso) uinet_soclose(newpeerso);
}
}
if (processed > passive->max_accept_batch)
passive->max_accept_batch = processed;
}
static void
nproxy_accept_cb(struct ev_loop *loop, ev_uinet *w, int revents)
{
struct uinet_demo_nproxy *nproxy = w->data;
struct uinet_socket *newso = NULL;
struct ev_uinet_ctx *soctx = NULL;
struct nproxy_splice *splice = NULL;
int error;
if (0 != (error = uinet_soaccept(w->so, NULL, &newso))) {
printf("%s: Accept failed (%d)\n", nproxy->cfg.name, error);
} else {
if (nproxy->cfg.verbose)
printf("%s: Accept succeeded\n", nproxy->cfg.name);
soctx = ev_uinet_attach(newso);
if (NULL == soctx) {
printf("%s: Failed to alloc libev context for new splice\n",
nproxy->cfg.name);
goto fail;
}
splice = malloc(sizeof(*splice));
if (NULL == splice) {
printf("%s: Failed to alloc new splice context\n",
nproxy->cfg.name);
goto fail;
}
splice->nproxy = nproxy;
splice->id = nproxy->next_id++;
splice->verbose = nproxy->cfg.verbose;
splice->inbound.name = "inbound";
splice->inbound.splice = splice;
splice->inbound.other_side = &splice->outbound;
splice->outbound.name = "outbound";
splice->outbound.splice = splice;
splice->outbound.other_side = &splice->inbound;
ev_init(&splice->inbound.connected_watcher, nproxy_inbound_connected_cb);
ev_uinet_set(&splice->inbound.connected_watcher, soctx, EV_WRITE);
splice->inbound.connected_watcher.data = splice;
ev_uinet_start(loop, &splice->inbound.connected_watcher);
ev_init(&splice->inbound.writable_watcher, nproxy_writable_cb);
ev_uinet_set(&splice->inbound.writable_watcher, soctx, EV_WRITE);
splice->inbound.writable_watcher.data = &splice->inbound;
/* will be started as necessary by the outbound copy watcher */
ev_init(&splice->inbound.copy_watcher, nproxy_copy_cb);
ev_uinet_set(&splice->inbound.copy_watcher, soctx, EV_READ);
splice->inbound.copy_watcher.data = &splice->inbound;
/* will be started when the outbound connection is established */
}
return;
fail:
if (splice) free(splice);
if (soctx) ev_uinet_detach(soctx);
if (newso) uinet_soclose(newso);
}
