initial commit
This commit is contained in:
613
third_party/libhv/event/nio.c
vendored
Executable file
613
third_party/libhv/event/nio.c
vendored
Executable file
@@ -0,0 +1,613 @@
|
||||
#include "iowatcher.h"
|
||||
#ifndef EVENT_IOCP
|
||||
#include "hevent.h"
|
||||
#include "hsocket.h"
|
||||
#include "hssl.h"
|
||||
#include "hlog.h"
|
||||
#include "herr.h"
|
||||
#include "hthread.h"
|
||||
|
||||
static void __connect_timeout_cb(htimer_t* timer) {
|
||||
hio_t* io = (hio_t*)timer->privdata;
|
||||
if (io) {
|
||||
char localaddrstr[SOCKADDR_STRLEN] = {0};
|
||||
char peeraddrstr[SOCKADDR_STRLEN] = {0};
|
||||
hlogw("connect timeout [%s] <=> [%s]",
|
||||
SOCKADDR_STR(io->localaddr, localaddrstr),
|
||||
SOCKADDR_STR(io->peeraddr, peeraddrstr));
|
||||
io->error = ETIMEDOUT;
|
||||
hio_close(io);
|
||||
}
|
||||
}
|
||||
|
||||
static void __close_timeout_cb(htimer_t* timer) {
|
||||
hio_t* io = (hio_t*)timer->privdata;
|
||||
if (io) {
|
||||
char localaddrstr[SOCKADDR_STRLEN] = {0};
|
||||
char peeraddrstr[SOCKADDR_STRLEN] = {0};
|
||||
hlogw("close timeout [%s] <=> [%s]",
|
||||
SOCKADDR_STR(io->localaddr, localaddrstr),
|
||||
SOCKADDR_STR(io->peeraddr, peeraddrstr));
|
||||
io->error = ETIMEDOUT;
|
||||
hio_close(io);
|
||||
}
|
||||
}
|
||||
|
||||
static void __accept_cb(hio_t* io) {
|
||||
hio_accept_cb(io);
|
||||
}
|
||||
|
||||
static void __connect_cb(hio_t* io) {
|
||||
hio_del_connect_timer(io);
|
||||
hio_connect_cb(io);
|
||||
}
|
||||
|
||||
static void __read_cb(hio_t* io, void* buf, int readbytes) {
|
||||
// printd("> %.*s\n", readbytes, buf);
|
||||
io->last_read_hrtime = io->loop->cur_hrtime;
|
||||
hio_handle_read(io, buf, readbytes);
|
||||
}
|
||||
|
||||
static void __write_cb(hio_t* io, const void* buf, int writebytes) {
|
||||
// printd("< %.*s\n", writebytes, buf);
|
||||
io->last_write_hrtime = io->loop->cur_hrtime;
|
||||
hio_write_cb(io, buf, writebytes);
|
||||
}
|
||||
|
||||
static void __close_cb(hio_t* io) {
|
||||
// printd("close fd=%d\n", io->fd);
|
||||
hio_del_connect_timer(io);
|
||||
hio_del_close_timer(io);
|
||||
hio_del_read_timer(io);
|
||||
hio_del_write_timer(io);
|
||||
hio_del_keepalive_timer(io);
|
||||
hio_del_heartbeat_timer(io);
|
||||
hio_close_cb(io);
|
||||
}
|
||||
|
||||
static void ssl_server_handshake(hio_t* io) {
|
||||
printd("ssl server handshake...\n");
|
||||
int ret = hssl_accept(io->ssl);
|
||||
if (ret == 0) {
|
||||
// handshake finish
|
||||
hio_del(io, HV_READ);
|
||||
printd("ssl handshake finished.\n");
|
||||
__accept_cb(io);
|
||||
}
|
||||
else if (ret == HSSL_WANT_READ) {
|
||||
if ((io->events & HV_READ) == 0) {
|
||||
hio_add(io, ssl_server_handshake, HV_READ);
|
||||
}
|
||||
}
|
||||
else {
|
||||
hloge("ssl handshake failed: %d", ret);
|
||||
io->error = ERR_SSL_HANDSHAKE;
|
||||
hio_close(io);
|
||||
}
|
||||
}
|
||||
|
||||
static void ssl_client_handshake(hio_t* io) {
|
||||
printd("ssl client handshake...\n");
|
||||
int ret = hssl_connect(io->ssl);
|
||||
if (ret == 0) {
|
||||
// handshake finish
|
||||
hio_del(io, HV_READ);
|
||||
printd("ssl handshake finished.\n");
|
||||
__connect_cb(io);
|
||||
}
|
||||
else if (ret == HSSL_WANT_READ) {
|
||||
if ((io->events & HV_READ) == 0) {
|
||||
hio_add(io, ssl_client_handshake, HV_READ);
|
||||
}
|
||||
}
|
||||
else {
|
||||
hloge("ssl handshake failed: %d", ret);
|
||||
io->error = ERR_SSL_HANDSHAKE;
|
||||
hio_close(io);
|
||||
}
|
||||
}
|
||||
|
||||
static void nio_accept(hio_t* io) {
|
||||
// printd("nio_accept listenfd=%d\n", io->fd);
|
||||
int connfd = 0, err = 0, accept_cnt = 0;
|
||||
socklen_t addrlen;
|
||||
hio_t* connio = NULL;
|
||||
while (accept_cnt++ < 3) {
|
||||
addrlen = sizeof(sockaddr_u);
|
||||
connfd = accept(io->fd, io->peeraddr, &addrlen);
|
||||
if (connfd < 0) {
|
||||
err = socket_errno();
|
||||
if (err == EAGAIN || err == EINTR) {
|
||||
return;
|
||||
} else {
|
||||
perror("accept");
|
||||
io->error = err;
|
||||
goto accept_error;
|
||||
}
|
||||
}
|
||||
addrlen = sizeof(sockaddr_u);
|
||||
getsockname(connfd, io->localaddr, &addrlen);
|
||||
connio = hio_get(io->loop, connfd);
|
||||
// NOTE: inherit from listenio
|
||||
connio->accept_cb = io->accept_cb;
|
||||
connio->userdata = io->userdata;
|
||||
if (io->unpack_setting) {
|
||||
hio_set_unpack(connio, io->unpack_setting);
|
||||
}
|
||||
|
||||
if (io->io_type == HIO_TYPE_SSL) {
|
||||
if (connio->ssl == NULL) {
|
||||
// io->ssl_ctx > g_ssl_ctx > hssl_ctx_new
|
||||
hssl_ctx_t ssl_ctx = NULL;
|
||||
if (io->ssl_ctx) {
|
||||
ssl_ctx = io->ssl_ctx;
|
||||
} else if (g_ssl_ctx) {
|
||||
ssl_ctx = g_ssl_ctx;
|
||||
} else {
|
||||
io->ssl_ctx = ssl_ctx = hssl_ctx_new(NULL);
|
||||
io->alloced_ssl_ctx = 1;
|
||||
}
|
||||
if (ssl_ctx == NULL) {
|
||||
io->error = ERR_NEW_SSL_CTX;
|
||||
goto accept_error;
|
||||
}
|
||||
hssl_t ssl = hssl_new(ssl_ctx, connfd);
|
||||
if (ssl == NULL) {
|
||||
io->error = ERR_NEW_SSL;
|
||||
goto accept_error;
|
||||
}
|
||||
connio->ssl = ssl;
|
||||
}
|
||||
hio_enable_ssl(connio);
|
||||
ssl_server_handshake(connio);
|
||||
}
|
||||
else {
|
||||
// NOTE: SSL call accept_cb after handshake finished
|
||||
__accept_cb(connio);
|
||||
}
|
||||
}
|
||||
return;
|
||||
|
||||
accept_error:
|
||||
hloge("listenfd=%d accept error: %s:%d", io->fd, socket_strerror(io->error), io->error);
|
||||
// NOTE: Don't close listen fd automatically anyway.
|
||||
// hio_close(io);
|
||||
}
|
||||
|
||||
static void nio_connect(hio_t* io) {
|
||||
// printd("nio_connect connfd=%d\n", io->fd);
|
||||
socklen_t addrlen = sizeof(sockaddr_u);
|
||||
int ret = getpeername(io->fd, io->peeraddr, &addrlen);
|
||||
if (ret < 0) {
|
||||
io->error = socket_errno();
|
||||
goto connect_error;
|
||||
}
|
||||
else {
|
||||
addrlen = sizeof(sockaddr_u);
|
||||
getsockname(io->fd, io->localaddr, &addrlen);
|
||||
|
||||
if (io->io_type == HIO_TYPE_SSL) {
|
||||
if (io->ssl == NULL) {
|
||||
// io->ssl_ctx > g_ssl_ctx > hssl_ctx_new
|
||||
hssl_ctx_t ssl_ctx = NULL;
|
||||
if (io->ssl_ctx) {
|
||||
ssl_ctx = io->ssl_ctx;
|
||||
} else if (g_ssl_ctx) {
|
||||
ssl_ctx = g_ssl_ctx;
|
||||
} else {
|
||||
io->ssl_ctx = ssl_ctx = hssl_ctx_new(NULL);
|
||||
io->alloced_ssl_ctx = 1;
|
||||
}
|
||||
if (ssl_ctx == NULL) {
|
||||
io->error = ERR_NEW_SSL_CTX;
|
||||
goto connect_error;
|
||||
}
|
||||
hssl_t ssl = hssl_new(ssl_ctx, io->fd);
|
||||
if (ssl == NULL) {
|
||||
io->error = ERR_NEW_SSL;
|
||||
goto connect_error;
|
||||
}
|
||||
io->ssl = ssl;
|
||||
}
|
||||
if (io->hostname) {
|
||||
hssl_set_sni_hostname(io->ssl, io->hostname);
|
||||
}
|
||||
ssl_client_handshake(io);
|
||||
}
|
||||
else {
|
||||
// NOTE: SSL call connect_cb after handshake finished
|
||||
__connect_cb(io);
|
||||
}
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
connect_error:
|
||||
hlogw("connfd=%d connect error: %s:%d", io->fd, socket_strerror(io->error), io->error);
|
||||
hio_close(io);
|
||||
}
|
||||
|
||||
static void nio_connect_event_cb(hevent_t* ev) {
|
||||
hio_t* io = (hio_t*)ev->userdata;
|
||||
uint32_t id = (uintptr_t)ev->privdata;
|
||||
if (io->id != id) return;
|
||||
nio_connect(io);
|
||||
}
|
||||
|
||||
static int nio_connect_async(hio_t* io) {
|
||||
hevent_t ev;
|
||||
memset(&ev, 0, sizeof(ev));
|
||||
ev.cb = nio_connect_event_cb;
|
||||
ev.userdata = io;
|
||||
ev.privdata = (void*)(uintptr_t)io->id;
|
||||
hloop_post_event(io->loop, &ev);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int __nio_read(hio_t* io, void* buf, int len) {
|
||||
int nread = 0;
|
||||
switch (io->io_type) {
|
||||
case HIO_TYPE_SSL:
|
||||
nread = hssl_read(io->ssl, buf, len);
|
||||
break;
|
||||
case HIO_TYPE_TCP:
|
||||
nread = recv(io->fd, buf, len, 0);
|
||||
break;
|
||||
case HIO_TYPE_UDP:
|
||||
case HIO_TYPE_KCP:
|
||||
case HIO_TYPE_IP:
|
||||
{
|
||||
socklen_t addrlen = sizeof(sockaddr_u);
|
||||
nread = recvfrom(io->fd, buf, len, 0, io->peeraddr, &addrlen);
|
||||
}
|
||||
break;
|
||||
default:
|
||||
nread = read(io->fd, buf, len);
|
||||
break;
|
||||
}
|
||||
// hlogd("read retval=%d", nread);
|
||||
return nread;
|
||||
}
|
||||
|
||||
static int __nio_write(hio_t* io, const void* buf, int len) {
|
||||
int nwrite = 0;
|
||||
switch (io->io_type) {
|
||||
case HIO_TYPE_SSL:
|
||||
nwrite = hssl_write(io->ssl, buf, len);
|
||||
break;
|
||||
case HIO_TYPE_TCP:
|
||||
{
|
||||
int flag = 0;
|
||||
#ifdef MSG_NOSIGNAL
|
||||
flag |= MSG_NOSIGNAL;
|
||||
#endif
|
||||
nwrite = send(io->fd, buf, len, flag);
|
||||
}
|
||||
break;
|
||||
case HIO_TYPE_UDP:
|
||||
case HIO_TYPE_KCP:
|
||||
case HIO_TYPE_IP:
|
||||
{
|
||||
nwrite = sendto(io->fd, buf, len, 0, io->peeraddr, SOCKADDR_LEN(io->peeraddr));
|
||||
if (((sockaddr_u*)io->localaddr)->sin.sin_port == 0) {
|
||||
socklen_t addrlen = sizeof(sockaddr_u);
|
||||
getsockname(io->fd, io->localaddr, &addrlen);
|
||||
}
|
||||
}
|
||||
break;
|
||||
default:
|
||||
nwrite = write(io->fd, buf, len);
|
||||
break;
|
||||
}
|
||||
// hlogd("write retval=%d", nwrite);
|
||||
return nwrite;
|
||||
}
|
||||
|
||||
static void nio_read(hio_t* io) {
|
||||
// printd("nio_read fd=%d\n", io->fd);
|
||||
void* buf;
|
||||
int len = 0, nread = 0, err = 0;
|
||||
read:
|
||||
buf = io->readbuf.base + io->readbuf.tail;
|
||||
if (io->read_flags & HIO_READ_UNTIL_LENGTH) {
|
||||
len = io->read_until_length - (io->readbuf.tail - io->readbuf.head);
|
||||
} else {
|
||||
len = io->readbuf.len - io->readbuf.tail;
|
||||
}
|
||||
assert(len > 0);
|
||||
nread = __nio_read(io, buf, len);
|
||||
// printd("read retval=%d\n", nread);
|
||||
if (nread < 0) {
|
||||
err = socket_errno();
|
||||
if (err == EAGAIN || err == EINTR) {
|
||||
// goto read_done;
|
||||
return;
|
||||
} else if (err == EMSGSIZE) {
|
||||
nread = len;
|
||||
} else {
|
||||
// perror("read");
|
||||
io->error = err;
|
||||
goto read_error;
|
||||
}
|
||||
}
|
||||
if (nread == 0 && (io->io_type & HIO_TYPE_SOCK_STREAM)) {
|
||||
goto disconnect;
|
||||
}
|
||||
if (nread < len) {
|
||||
// NOTE: make string friendly
|
||||
((char*)buf)[nread] = '\0';
|
||||
}
|
||||
io->readbuf.tail += nread;
|
||||
__read_cb(io, buf, nread);
|
||||
if (nread == len && !io->closed) {
|
||||
// NOTE: ssl may have own cache
|
||||
if (io->io_type == HIO_TYPE_SSL) {
|
||||
// read continue
|
||||
goto read;
|
||||
}
|
||||
}
|
||||
return;
|
||||
read_error:
|
||||
disconnect:
|
||||
if (io->io_type & HIO_TYPE_SOCK_STREAM) {
|
||||
hio_close(io);
|
||||
}
|
||||
}
|
||||
|
||||
static void nio_write(hio_t* io) {
|
||||
// printd("nio_write fd=%d\n", io->fd);
|
||||
int nwrite = 0, err = 0;
|
||||
hrecursive_mutex_lock(&io->write_mutex);
|
||||
write:
|
||||
if (write_queue_empty(&io->write_queue)) {
|
||||
hrecursive_mutex_unlock(&io->write_mutex);
|
||||
if (io->close) {
|
||||
io->close = 0;
|
||||
hio_close(io);
|
||||
}
|
||||
return;
|
||||
}
|
||||
offset_buf_t* pbuf = write_queue_front(&io->write_queue);
|
||||
char* base = pbuf->base;
|
||||
char* buf = base + pbuf->offset;
|
||||
int len = pbuf->len - pbuf->offset;
|
||||
nwrite = __nio_write(io, buf, len);
|
||||
// printd("write retval=%d\n", nwrite);
|
||||
if (nwrite < 0) {
|
||||
err = socket_errno();
|
||||
if (err == EAGAIN || err == EINTR) {
|
||||
hrecursive_mutex_unlock(&io->write_mutex);
|
||||
return;
|
||||
} else {
|
||||
// perror("write");
|
||||
io->error = err;
|
||||
goto write_error;
|
||||
}
|
||||
}
|
||||
if (nwrite == 0 && (io->io_type & HIO_TYPE_SOCK_STREAM)) {
|
||||
goto disconnect;
|
||||
}
|
||||
pbuf->offset += nwrite;
|
||||
io->write_bufsize -= nwrite;
|
||||
__write_cb(io, buf, nwrite);
|
||||
if (nwrite == len) {
|
||||
// NOTE: after write_cb, pbuf maybe invalid.
|
||||
// HV_FREE(pbuf->base);
|
||||
HV_FREE(base);
|
||||
write_queue_pop_front(&io->write_queue);
|
||||
if (!io->closed) {
|
||||
// write continue
|
||||
goto write;
|
||||
}
|
||||
}
|
||||
hrecursive_mutex_unlock(&io->write_mutex);
|
||||
return;
|
||||
write_error:
|
||||
disconnect:
|
||||
hrecursive_mutex_unlock(&io->write_mutex);
|
||||
if (io->io_type & HIO_TYPE_SOCK_STREAM) {
|
||||
hio_close(io);
|
||||
}
|
||||
}
|
||||
|
||||
static void hio_handle_events(hio_t* io) {
|
||||
if ((io->events & HV_READ) && (io->revents & HV_READ)) {
|
||||
if (io->accept) {
|
||||
nio_accept(io);
|
||||
}
|
||||
else {
|
||||
nio_read(io);
|
||||
}
|
||||
}
|
||||
|
||||
if ((io->events & HV_WRITE) && (io->revents & HV_WRITE)) {
|
||||
// NOTE: del HV_WRITE, if write_queue empty
|
||||
hrecursive_mutex_lock(&io->write_mutex);
|
||||
if (write_queue_empty(&io->write_queue)) {
|
||||
hio_del(io, HV_WRITE);
|
||||
}
|
||||
hrecursive_mutex_unlock(&io->write_mutex);
|
||||
if (io->connect) {
|
||||
// NOTE: connect just do once
|
||||
// ONESHOT
|
||||
io->connect = 0;
|
||||
|
||||
nio_connect(io);
|
||||
}
|
||||
else {
|
||||
nio_write(io);
|
||||
}
|
||||
}
|
||||
|
||||
io->revents = 0;
|
||||
}
|
||||
|
||||
int hio_accept(hio_t* io) {
|
||||
io->accept = 1;
|
||||
return hio_add(io, hio_handle_events, HV_READ);
|
||||
}
|
||||
|
||||
int hio_connect(hio_t* io) {
|
||||
int ret = connect(io->fd, io->peeraddr, SOCKADDR_LEN(io->peeraddr));
|
||||
#ifdef OS_WIN
|
||||
if (ret < 0 && socket_errno() != WSAEWOULDBLOCK) {
|
||||
#else
|
||||
if (ret < 0 && socket_errno() != EINPROGRESS) {
|
||||
#endif
|
||||
perror("connect");
|
||||
io->error = socket_errno();
|
||||
hio_close_async(io);
|
||||
return ret;
|
||||
}
|
||||
if (ret == 0) {
|
||||
// connect ok
|
||||
nio_connect_async(io);
|
||||
return 0;
|
||||
}
|
||||
int timeout = io->connect_timeout ? io->connect_timeout : HIO_DEFAULT_CONNECT_TIMEOUT;
|
||||
io->connect_timer = htimer_add(io->loop, __connect_timeout_cb, timeout, 1);
|
||||
io->connect_timer->privdata = io;
|
||||
io->connect = 1;
|
||||
return hio_add(io, hio_handle_events, HV_WRITE);
|
||||
}
|
||||
|
||||
int hio_read (hio_t* io) {
|
||||
if (io->closed) {
|
||||
hloge("hio_read called but fd[%d] already closed!", io->fd);
|
||||
return -1;
|
||||
}
|
||||
hio_add(io, hio_handle_events, HV_READ);
|
||||
if (io->readbuf.tail > io->readbuf.head &&
|
||||
io->unpack_setting == NULL &&
|
||||
io->read_flags == 0) {
|
||||
hio_read_remain(io);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
int hio_write (hio_t* io, const void* buf, size_t len) {
|
||||
if (io->closed) {
|
||||
hloge("hio_write called but fd[%d] already closed!", io->fd);
|
||||
return -1;
|
||||
}
|
||||
int nwrite = 0, err = 0;
|
||||
hrecursive_mutex_lock(&io->write_mutex);
|
||||
#if WITH_KCP
|
||||
if (io->io_type == HIO_TYPE_KCP) {
|
||||
nwrite = hio_write_kcp(io, buf, len);
|
||||
// if (nwrite < 0) goto write_error;
|
||||
goto write_done;
|
||||
}
|
||||
#endif
|
||||
if (write_queue_empty(&io->write_queue)) {
|
||||
try_write:
|
||||
nwrite = __nio_write(io, buf, len);
|
||||
// printd("write retval=%d\n", nwrite);
|
||||
if (nwrite < 0) {
|
||||
err = socket_errno();
|
||||
if (err == EAGAIN || err == EINTR) {
|
||||
nwrite = 0;
|
||||
hlogw("try_write failed, enqueue!");
|
||||
goto enqueue;
|
||||
} else {
|
||||
// perror("write");
|
||||
io->error = err;
|
||||
goto write_error;
|
||||
}
|
||||
}
|
||||
if (nwrite == len) {
|
||||
goto write_done;
|
||||
}
|
||||
if (nwrite == 0 && (io->io_type & HIO_TYPE_SOCK_STREAM)) {
|
||||
goto disconnect;
|
||||
}
|
||||
enqueue:
|
||||
hio_add(io, hio_handle_events, HV_WRITE);
|
||||
}
|
||||
if (nwrite < len) {
|
||||
if (io->write_bufsize + len - nwrite > io->max_write_bufsize) {
|
||||
hloge("write bufsize > %u, close it!", io->max_write_bufsize);
|
||||
io->error = ERR_OVER_LIMIT;
|
||||
goto write_error;
|
||||
}
|
||||
offset_buf_t remain;
|
||||
remain.len = len - nwrite;
|
||||
remain.offset = 0;
|
||||
// NOTE: free in nio_write
|
||||
HV_ALLOC(remain.base, remain.len);
|
||||
memcpy(remain.base, ((char*)buf) + nwrite, remain.len);
|
||||
if (io->write_queue.maxsize == 0) {
|
||||
write_queue_init(&io->write_queue, 4);
|
||||
}
|
||||
write_queue_push_back(&io->write_queue, &remain);
|
||||
io->write_bufsize += remain.len;
|
||||
if (io->write_bufsize > WRITE_BUFSIZE_HIGH_WATER) {
|
||||
hlogw("write len=%u enqueue %u, bufsize=%u over high water %u",
|
||||
(unsigned int)len,
|
||||
(unsigned int)(remain.len - remain.offset),
|
||||
(unsigned int)io->write_bufsize,
|
||||
(unsigned int)WRITE_BUFSIZE_HIGH_WATER);
|
||||
}
|
||||
}
|
||||
write_done:
|
||||
hrecursive_mutex_unlock(&io->write_mutex);
|
||||
if (nwrite > 0) {
|
||||
__write_cb(io, buf, nwrite);
|
||||
}
|
||||
return nwrite;
|
||||
write_error:
|
||||
disconnect:
|
||||
hrecursive_mutex_unlock(&io->write_mutex);
|
||||
/* NOTE:
|
||||
* We usually free resources in hclose_cb,
|
||||
* if hio_close_sync, we have to be very careful to avoid using freed resources.
|
||||
* But if hio_close_async, we do not have to worry about this.
|
||||
*/
|
||||
if (io->io_type & HIO_TYPE_SOCK_STREAM) {
|
||||
hio_close_async(io);
|
||||
}
|
||||
return nwrite < 0 ? nwrite : -1;
|
||||
}
|
||||
|
||||
int hio_close (hio_t* io) {
|
||||
if (io->closed) return 0;
|
||||
if (io->destroy == 0 && hv_gettid() != io->loop->tid) {
|
||||
return hio_close_async(io);
|
||||
}
|
||||
|
||||
hrecursive_mutex_lock(&io->write_mutex);
|
||||
if (io->closed) {
|
||||
hrecursive_mutex_unlock(&io->write_mutex);
|
||||
return 0;
|
||||
}
|
||||
if (!write_queue_empty(&io->write_queue) && io->error == 0 && io->close == 0 && io->destroy == 0) {
|
||||
io->close = 1;
|
||||
hrecursive_mutex_unlock(&io->write_mutex);
|
||||
hlogw("write_queue not empty, close later.");
|
||||
int timeout_ms = io->close_timeout ? io->close_timeout : HIO_DEFAULT_CLOSE_TIMEOUT;
|
||||
io->close_timer = htimer_add(io->loop, __close_timeout_cb, timeout_ms, 1);
|
||||
io->close_timer->privdata = io;
|
||||
return 0;
|
||||
}
|
||||
io->closed = 1;
|
||||
hrecursive_mutex_unlock(&io->write_mutex);
|
||||
|
||||
hio_done(io);
|
||||
__close_cb(io);
|
||||
if (io->ssl) {
|
||||
hssl_free(io->ssl);
|
||||
io->ssl = NULL;
|
||||
}
|
||||
if (io->ssl_ctx && io->alloced_ssl_ctx) {
|
||||
hssl_ctx_free(io->ssl_ctx);
|
||||
io->ssl_ctx = NULL;
|
||||
}
|
||||
SAFE_FREE(io->hostname);
|
||||
if (io->io_type & HIO_TYPE_SOCKET) {
|
||||
closesocket(io->fd);
|
||||
} else if (io->io_type == HIO_TYPE_PIPE) {
|
||||
close(io->fd);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
#endif
|
||||
Reference in New Issue
Block a user