static void
accepted_socket_invoke_user_cb(struct deferred_cb *cb, void *arg)
{
struct accepting_socket *as = arg;
struct sockaddr *sa_local=NULL, *sa_remote=NULL;
int socklen_local=0, socklen_remote=0;
const struct win32_extension_fns *ext = event_get_win32_extension_fns();
EVUTIL_ASSERT(ext->GetAcceptExSockaddrs);
EnterCriticalSection(&as->lock);
if (as->free_on_cb) {
free_and_unlock_accepting_socket(as);
return;
}
ext->GetAcceptExSockaddrs(
as->addrbuf, 0, as->buflen/2, as->buflen/2,
&sa_local, &socklen_local, &sa_remote, &socklen_remote);
as->lev->base.cb(&as->lev->base, as->s, sa_remote,
socklen_remote, as->lev->base.user_data);
as->s = INVALID_SOCKET;
start_accepting(as); /* XXXX handle error */
LeaveCriticalSection(&as->lock);
}
static void init(void)
{
init_winsock();
create_io_completion_port();
create_listening_socket();
bind_listening_socket();
start_listening();
load_accept_ex();
start_accepting();
}
static void accept_completed(BOOL resultOk, DWORD length,
SocketState* socketState, WSAOVERLAPPED* ovl)
{
SocketState* newSocketState;
if (resultOk)
{
printf("* new connection created\n");
// "updates the context" (whatever that is...)
// for inheritting info of local and remote addresses
setsockopt(socketState->socket, SOL_SOCKET, SO_UPDATE_ACCEPT_CONTEXT,
(char *)&listener, sizeof(listener));
// associates new socket with completion port
newSocketState = new_socket_state();
newSocketState->socket = socketState->socket;
if (CreateIoCompletionPort((HANDLE)newSocketState->socket, cpl_port,
(ULONG_PTR)newSocketState, 0) != cpl_port)
{
int err = WSAGetLastError();
printf("* error %d in CreateIoCompletionPort in line %d\n", err, __LINE__);
exit(1);
}
// starts receiving from the new connection
start_reading(newSocketState, new_overlapped());
// starts waiting for another connection request
start_accepting();
}
else // !resultOk
{
int err = GetLastError();
printf("* error (%d,%d) in accept, cleaning up and retrying!!!", err,
length);
closesocket(socketState->socket);
start_accepting();
}
}
static int
iocp_listener_enable(struct evconnlistener *lev)
{
int i;
struct evconnlistener_iocp *lev_iocp =
EVUTIL_UPCAST(lev, struct evconnlistener_iocp, base);
EnterCriticalSection(&lev_iocp->lock);
for (i = 0; i < lev_iocp->n_accepting; ++i) {
struct accepting_socket *as = lev_iocp->accepting[i];
if (!as)
continue;
EnterCriticalSection(&as->lock);
if (!as->free_on_cb && as->s == INVALID_SOCKET)
start_accepting(as); /* XXXX handle error */
LeaveCriticalSection(&as->lock);
}
LeaveCriticalSection(&lev_iocp->lock);
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;
}
static void
accepted_socket_invoke_user_cb(struct deferred_cb *dcb, void *arg)
{
struct accepting_socket *as = arg;
struct sockaddr *sa_local=NULL, *sa_remote=NULL;
int socklen_local=0, socklen_remote=0;
const struct win32_extension_fns *ext = event_get_win32_extension_fns();
struct evconnlistener *lev = &as->lev->base;
evutil_socket_t sock=-1;
void *data;
evconnlistener_cb cb=NULL;
evconnlistener_errorcb errorcb=NULL;
int error;
EVUTIL_ASSERT(ext->GetAcceptExSockaddrs);
LOCK(lev);
EnterCriticalSection(&as->lock);
if (as->free_on_cb) {
free_and_unlock_accepting_socket(as);
listener_decref_and_unlock(lev);
return;
}
++lev->refcnt;
error = as->error;
if (error) {
as->error = 0;
errorcb = lev->errorcb;
} else {
ext->GetAcceptExSockaddrs(
as->addrbuf, 0, as->buflen/2, as->buflen/2,
&sa_local, &socklen_local, &sa_remote,
&socklen_remote);
sock = as->s;
cb = lev->cb;
as->s = INVALID_SOCKET;
/* We need to call this so getsockname, getpeername, and
* shutdown work correctly on the accepted socket. */
/* XXXX handle error? */
setsockopt(sock, SOL_SOCKET, SO_UPDATE_ACCEPT_CONTEXT,
(char *)&as->lev->fd, sizeof(&as->lev->fd));
}
data = lev->user_data;
LeaveCriticalSection(&as->lock);
UNLOCK(lev);
if (errorcb) {
WSASetLastError(error);
errorcb(lev, data);
} else if (cb) {
cb(lev, sock, sa_remote, socklen_remote, data);
}
LOCK(lev);
if (listener_decref_and_unlock(lev))
return;
EnterCriticalSection(&as->lock);
start_accepting(as);
LeaveCriticalSection(&as->lock);
}
