static void
remote_recv_cb(uv_stream_t *stream, ssize_t nread, const uv_buf_t *buf) {
struct remote_context *remote;
struct client_context *client;
remote = stream->data;
client = remote->client;
if (nread > 0) {
reset_timer(remote);
uv_read_stop(&remote->handle.stream);
int clen = nread + PRIMITIVE_BYTES;
uint8_t *c = remote->buf + HEADER_BYTES;
int rc = crypto_encrypt(c, (uint8_t*)buf->base, nread);
if (!rc) {
forward_to_client(client, c, clen);
} else {
logger_log(LOG_ERR, "invalid tcp packet");
close_client(client);
close_remote(remote);
}
} else if (nread < 0){
if (nread != UV_EOF) {
logger_log(LOG_ERR, "receive from %s failed: %s", client->target_addr, uv_strerror(nread));
}
close_client(client);
close_remote(remote);
}
}
void *response_handler(void *arg) {
int nfd;
fd_set read_set;
struct timeval tv;
tv.tv_sec = 0;
tv.tv_usec = 100;
while (1) {
FD_ZERO(&read_set);
FD_SET(sock, &read_set);
nfd = select(sock + 1, &read_set, NULL, NULL, &tv);
if (nfd > 0) {
int len, recvIsDone = 0;
user->buf_len = 0;
while (!recvIsDone) {
if ((len = recv(sock, user->buf, 1, 0)) > 0) {
if(user->buf[0] == ',') {
user->type[user->buf_len++] = '\0';
// printf("%s\n", user->type);
serve_response();
recvIsDone = 1;
} else
user->type[user->buf_len++] = user->buf[0];
} else if (len == 0) {
puts("disconnected");
close_client();
} else if (len == -1) {
puts("recv failed");
close_client();
}
}
}
}
}
static void
client_recv_cb(uv_stream_t *stream, ssize_t nread, const uv_buf_t *buf) {
struct client_context *client = stream->data;
struct remote_context *remote = client->remote;
int clen;
if (nread > 0) {
reset_timer(remote);
uv_read_stop(&client->handle.stream);
switch (client->stage) {
case XSTAGE_HANDSHAKE:
if (verify_methods(buf->base, nread)) {
handshake(client);
} else {
logger_log(LOG_ERR, "invalid method packet");
close_client(client);
close_remote(remote);
}
break;
case XSTAGE_REQUEST:
if (verify_request(buf->base, nread)) {
request_start(client, buf->base);
} else {
logger_log(LOG_ERR, "invalid request packet");
close_client(client);
close_remote(remote);
}
break;
case XSTAGE_FORWARD:
clen = nread + PRIMITIVE_BYTES;
uint8_t *c = client->buf + HEADER_BYTES;
int rc = crypto_encrypt(c, (uint8_t*)buf->base, nread);
if (rc) {
logger_log(LOG_ERR, "encrypt failed");
close_client(client);
close_remote(remote);
}
forward_to_remote(remote, c, clen);
break;
default:
break;
}
} else if (nread < 0) {
if (nread != UV_EOF) {
char addrbuf[INET6_ADDRSTRLEN + 1] = {0};
uint16_t port = ip_name(&client->addr, addrbuf, sizeof addrbuf);
logger_log(LOG_ERR, "receive from %s:%d failed: %s", addrbuf, port, uv_strerror(nread));
}
close_client(client);
close_remote(remote);
}
}
void on_read( SP_TestClient * client, SP_TestEvent * event )
{
char buffer[ 4096 ] = { 0 };
int bytesTransferred = recv( (int)client->mFd, buffer, sizeof( buffer ), 0 );
if( bytesTransferred <= 0 ) {
if( bytesTransferred < 0 ) {
printf( "recv fail, errno %d\n", WSAGetLastError() );
gStat.mRecvFail++;
}
close_client( client );
return;
}
for( int i = 0; i < bytesTransferred; i++ ) {
if( '\n' == buffer[i] ) client->mRecvMsgs++;
}
memset( &( event->mOverlapped ), 0, sizeof( OVERLAPPED ) );
event->mType = SP_TestEvent::eEventRecv;
event->mWsaBuf.buf = NULL;
event->mWsaBuf.len = 0;
DWORD recvBytes = 0, flags = 0;
if( SOCKET_ERROR == WSARecv( (SOCKET)client->mFd, &( event->mWsaBuf ), 1,
&recvBytes, &flags, &( event->mOverlapped ), NULL ) ) {
if( ERROR_IO_PENDING != WSAGetLastError() ) {
gStat.mWSARecvFail++;
printf( "WSARecv fail, errno %d\n", WSAGetLastError() );
close_client( client );
}
}
}
void on_write( int fd, short events, void *arg )
{
SP_TestClient * client = ( SP_TestClient * ) arg;
if( EV_WRITE & events ) {
client->mSendMsgs++;
if( client->mSendMsgs >= gMsgs ) {
snprintf( client->mBuffer, sizeof( client->mBuffer ), "quit\n" );
} else {
snprintf( client->mBuffer, sizeof( client->mBuffer ),
"mail #%d, It's good to see how people hire; "
"that tells us how to market ourselves to them.\n", client->mSendMsgs );
}
int len = send( fd, client->mBuffer, strlen( client->mBuffer ), 0 );
if( len <= 0 && EAGAIN != errno ) {
fprintf( stderr, "#%d on_write error, errno %d, %s\n", fd, errno, strerror( errno ) );
close_client( client );
} else {
if( client->mSendMsgs >= gMsgs ) close_write( client );
}
} else {
fprintf( stderr, "#%d on_write timeout\n", fd );
close_client( client );
}
}
/**
* This function will be called by libevent when the client socket is
* ready for reading.
*/
void
on_read(int fd, short ev, void *arg)
{
struct client *client = (struct client *)arg;
int len;
len = recv(fd, client->buffer, sizeof( client->buffer ) - 1, 0);
if (len == 0) {
printf("Client(%d) disconnected.\n",fd);
close_client(client, fd);
return;
}
else if (len < 0 && WSAEWOULDBLOCK != WSAGetLastError() ) {
printf("recv(%d) fail, len %d, errno %d\n", fd, len, WSAGetLastError() );
}
if( len > 0 ) {
client->total = len;
client->wlen = 0;
if(0 != event_add( &( client->ev_write ), NULL ) ) {
close_client( client, fd );
}
} else {
if( 0!= event_add( &( client->ev_read ), NULL ) ) {
close_client( client, fd );
}
}
}
/**
* handle outstanding reads on the client socket
*/
static void on_buf_read(struct bufferevent *bev, void *arg) {
client_t *client = (client_t *)arg;
size_t buffer_left, bytes_read;
char *end;
assert(client);
assert(client->fd > 0);
assert(client->request);
if((!client) || (!client->request) || (client->fd < 1)) {
ERROR("Bad client struct in on_buf_read");
close_client(client);
return;
}
DEBUG("Read event (state %d) on fd %d", client->state, client->fd);
buffer_left = MAX_REQUEST_SIZE - strlen(client->request);
if(buffer_left <= 0) {
ERROR("Out of request space on fd %d. Aborting.", client->fd);
close_client(client);
}
bytes_read = bufferevent_read(client->buf_ev,
(void*)&client->request[strlen(client->request)],
buffer_left - 1);
if(bytes_read == -1) {
if (errno != EINTR) {
/* if EINTR, we'll just pick it back up on the next epoll */
ERROR("Read error on fd %d", client->fd);
close_client(client);
}
return;
}
DEBUG("Read %d bytes on fd %d", bytes_read, client->fd);
end = client->request;
while(*end && (*end != '\n') && (*end != '\r')) {
end++;
}
if(*end) {
*end = '\0';
client->state = CLIENT_STATE_WAITING_REPLY;
DEBUG("Got client request on fd %d: %s", client->fd, client->request);
/* hand this off to set up a response object */
handle_request(client);
} else {
DEBUG("Partial request read on fd %d", client->fd);
}
}
int _be_ssl_accept(se_ptr_t *ptr)
{
epdata_t *epd = ptr->data;
if(!epd) {
return 0;
}
if(!epd->ssl) {
epd->ssl = SSL_new(ssl_ctx);
if(epd->ssl == NULL) {
LOGF(ERR, "SSL_new");
close_client(epd);
return 0;
}
if(SSL_set_fd(epd->ssl, epd->fd) != 1) {
SSL_free(epd->ssl);
epd->ssl = NULL;
LOGF(ERR, "SSL_set_fd");
close_client(epd);
return 0;
}
if(ssl_epd_idx > -1) {
if(SSL_set_ex_data(epd->ssl, ssl_epd_idx, epd) != 1) {
SSL_free(epd->ssl);
LOGF(ERR, "SSL_set_ex_data");
int fd = epd->fd;
free(epd);
close(fd);
return 0;
}
}
}
int ret = SSL_accept(epd->ssl);
if(ret != 1) {
int ssl_err = SSL_get_error(epd->ssl, ret);
if(ssl_err != SSL_ERROR_WANT_READ && ssl_err != SSL_ERROR_WANT_WRITE) {
close_client(epd);
return 0;
}
return 0;
}
se_be_read(epd->se_ptr, network_be_read);
}
void respond(struct Client *c)
{
char *resp = "HTTP/1.1 200 OK\r\nContent-Length: 4\r\n\r\nCool\r\n\r\n";
char *resp400 = "HTTP/1.1 400 Bad Request\r\n\r\n";
if (c->pstate == ERROR) {
send(c->fd, resp400, strlen(resp400), 0);
close_client(c->fd);
} else if (c->pstate == SUCCESS) {
send(c->fd, resp, strlen(resp), 0);
close_client(c->fd);
}
}
static void
remote_recv_cb(uv_stream_t *stream, ssize_t nread, const uv_buf_t *buf) {
struct remote_context *remote;
struct client_context *client;
remote = stream->data;
client = remote->client;
if (nread > 0) {
reset_timer(remote);
struct packet *packet = &remote->packet;
int rc = packet_filter(packet, buf->base, nread);
if (rc == PACKET_COMPLETED) {
int clen = packet->size;
int mlen = packet->size - PRIMITIVE_BYTES;
uint8_t *c = packet->buf, *m = packet->buf;
assert(mlen > 0 && mlen <= MAX_PACKET_SIZE - PRIMITIVE_BYTES);
int err = crypto_decrypt(m, c, clen);
if (err) {
goto error;
}
uv_read_stop(&remote->handle.stream);
forward_to_client(client, m, mlen);
} else if (rc == PACKET_INVALID) {
goto error;
}
} else if (nread < 0){
if (nread != UV_EOF && verbose) {
char addrbuf[INET6_ADDRSTRLEN + 1];
int port = ip_name(&client->target_addr, addrbuf, sizeof(addrbuf));
logger_log(LOG_ERR, "receive from %s:%d failed: %s", addrbuf, port, uv_strerror(nread));
}
close_client(client);
close_remote(remote);
}
return;
error:
logger_log(LOG_ERR, "invalid tcp packet");
if (verbose) {
dump_hex(buf->base, nread, "invalid tcp Packet");
}
close_client(client);
close_remote(remote);
}
//
// Handles the IDA window messages for the hidden control window.
//
static LRESULT CALLBACK control_window_proc(HWND wnd, UINT msg,
WPARAM wp, LPARAM lp)
{
switch (msg)
{
case WM_NETEVENT:
{
switch (WSAGETSELECTEVENT(lp))
{
case FD_ACCEPT:
accept_client();
break;
case FD_READ:
process_client((SOCKET)wp);
break;
case FD_CLOSE:
close_client((SOCKET)wp);
break;
}
}
break;
default:
return DefWindowProc(wnd, msg, wp, lp);
}
return 0;
}
~jack_backend(void)
{
if (audio_is_active())
deactivate_audio();
close_client();
}
static void timeout_handle(void *ptr)
{
epdata_t *epd = ptr;
if(epd->status == STEP_READ) {
epd->keepalive = 0;
//LOGF(ERR, "Read Timeout!");
network_send_error(epd, 400, "Timeout!");
return;
//serv_status.reading_counts--;
} else if(epd->status == STEP_SEND) {
//LOGF(ERR, "Send Timeout!");
serv_status.sending_counts--;
}
if(epd->status == STEP_PROCESS && epd->L) {
LOGF(ERR, "Process Timeout(continue)");
update_timeout(epd->timeout_ptr, STEP_PROCESS_TIMEOUT);
return;
}
epd->status = STEP_WAIT;
close_client(epd);
}
void
client_accept_cb(uv_stream_t *server, int status) {
struct client_context *client = new_client();
struct remote_context *remote = new_remote(idle_timeout);
client->remote = remote;
remote->client = client;
uv_timer_init(server->loop, remote->timer);
uv_tcp_init(server->loop, &client->handle.tcp);
uv_tcp_init(server->loop, &remote->handle.tcp);
int rc = uv_accept(server, &client->handle.stream);
if (rc == 0) {
int namelen = sizeof client->addr;
uv_tcp_getpeername(&client->handle.tcp, &client->addr, &namelen);
reset_timer(remote); // start timer
connect_to_remote(remote);
} else {
logger_log(LOG_ERR, "accept error: %s", uv_strerror(rc));
close_client(client);
close_remote(remote);
}
}
void client_handler(client_t* client) {
int ret;
assert(client->fired_event != NULL);
// Two stages
// First, read HTTP request, interested in readable event
if (client->stage == CS_READ_REQUEST) {
if (client->fired_event->filter == EVFILT_READ) {
ret = parse_http_request(client);
if (ret) goto close;
ret = generate_http_response(client);
if (ret) goto close;
client->stage = CS_WRITE_RESPONSE;
}
}
// Then, write HTTP response, interested in writable event
else if (client->stage == CS_WRITE_RESPONSE) {
if (client->fired_event->filter == EVFILT_WRITE) {
ret = write_http_response(client,
client->fired_event->data);
// When it went wrong or just finished correctly,
// close the client
if (ret) goto close;
}
}
// Clear the event since it has been handled
client->fired_event = NULL;
return;
close:
close_client(client);
}
static void
client_send_cb(uv_write_t *req, int status) {
struct client_context *client = req->data;
struct remote_context *remote = client->remote;
if (status == 0) {
if (client->stage == XSTAGE_REQUEST) {
receive_from_client(client);
} else if (client->stage == XSTAGE_FORWARD) {
receive_from_remote(remote);
} else if (client->stage == XSTAGE_TERMINATE) {
close_client(client);
close_remote(remote);
}
} else {
char addrbuf[INET6_ADDRSTRLEN + 1] = {0};
int port = ip_name(&client->addr, addrbuf, sizeof addrbuf);
if (client->stage == XSTAGE_FORWARD) {
logger_log(LOG_ERR, "%s:%d <- %s failed: %s", addrbuf, port, client->target_addr, uv_strerror(status));
} else {
logger_log(LOG_ERR, "forward to %s:%d failed: %s", addrbuf, port, uv_strerror(status));
}
}
free(req);
}
static void close_bev(struct bufferevent *bev, struct conn_desc *conn)
{
if (IS_SERVER(bev, conn))
close_server(conn);
else
close_client(conn);
}
void eventLoop( HANDLE hIocp )
{
DWORD bytesTransferred = 0;
SP_TestClient * client = NULL;
SP_TestEvent * event = NULL;
BOOL isSuccess = GetQueuedCompletionStatus( hIocp, &bytesTransferred,
(DWORD*)&client, (OVERLAPPED**)&event, 100 );
DWORD lastError = WSAGetLastError();
if( ! isSuccess ) {
if( NULL != client ) {
gStat.mGQCSFail++;
close_client( client );
}
return;
}
if( SP_TestEvent::eEventRecv == event->mType ) {
on_read( client, event );
return;
}
if( SP_TestEvent::eEventSend == event->mType ) {
on_write( client, event );
return;
}
}
int main(int argc, char * argv[]) {
init_client();
start_transaction();
close_client();
fprintf(stderr, "closed.....\n");
return 0;
}
/**
* Set to a zero watermark, so gets called when all data for this
* socket is written out. In this case, we're done.
*/
static void on_buf_write(struct bufferevent *bev, void *arg) {
/* we finished our write. We done. */
client_t *client = (client_t *)arg;
DEBUG("Finished write on fd %d", client->fd);
close_client(client);
}
static void close_connect(int s)
{
rpc_client_s *c = rpc_client_by_socket(s);
if (c)
close_client(c);
else
close(s);
}
void network_end_process(epdata_t *epd)
{
epd->status = STEP_WAIT;
int i = 0;
int response_code = 0;
if(epd->iov[0].iov_base) {
char *hl = strtok(epd->iov[0].iov_base, "\n");
if(hl) {
hl = strtok(hl, " ");
hl = strtok(NULL, " ");
if(hl) {
response_code = atoi(hl);
}
}
}
free(epd->iov[0].iov_base);
epd->iov[0].iov_base = NULL;
for(i = 0; i < epd->iov_buf_count; i++) {
free(epd->iov[i].iov_base);
epd->iov[i].iov_base = NULL;
epd->iov[i].iov_len = 0;
}
epd->iov_buf_count = 0;
long ttime = longtime();
if(ACCESS_LOG) log_writef(ACCESS_LOG,
"%s - - [%s] %s \"%s %s %s\" %d %d %d \"%s\" \"%s\" %.3f\n",
inet_ntoa(epd->client_addr),
now_lc,
epd->host ? epd->host : "-",
epd->method ? epd->method : "-",
epd->uri ? epd->uri : "/",
epd->http_ver ? epd->http_ver : "-",
response_code,
epd->response_content_length,
epd->response_content_length - epd->response_header_length,
epd->referer ? epd->referer : "-",
epd->user_agent ? epd->user_agent : "-",
(float)(ttime - epd->start_time) / 1000);
if(epd->keepalive == 1 && !check_process_for_exit()) {
update_timeout(epd->timeout_ptr, STEP_WAIT_TIMEOUT);
free_epd_request(epd);
} else {
close_client(epd);
return;
}
}
static void
handle_invalid_packet(struct client_context *client) {
int port = 0;
char remote[INET_ADDRSTRLEN + 1];
port = ip_name(&client->addr, remote, sizeof(remote));
logger_log(LOG_ERR, "Invalid tcp packet from %s:%d", remote, port);
packet_reset(&client->packet);
close_client(client);
}
static void on_connection_ready(struct st_h2o_http1client_t *client)
{
h2o_iovec_t proxy_protocol = h2o_iovec_init(NULL, 0);
int chunked = 0;
h2o_iovec_t connection_header = h2o_iovec_init(NULL, 0);
h2o_httpclient_properties_t props = {
&proxy_protocol, &chunked, &connection_header,
};
h2o_iovec_t method;
h2o_url_t url;
h2o_header_t *headers;
size_t num_headers;
h2o_iovec_t body;
client->super._cb.on_head = client->super._cb.on_connect(&client->super, NULL, &method, &url, (const h2o_header_t **)&headers,
&num_headers, &body, &client->proceed_req, &props, client->_origin);
if (client->super._cb.on_head == NULL) {
close_client(client);
return;
}
h2o_iovec_t reqbufs[3];
size_t reqbufcnt = 0;
if (props.proxy_protocol->base != NULL)
reqbufs[reqbufcnt++] = *props.proxy_protocol;
reqbufs[reqbufcnt++] = build_request(client, method, url, *props.connection_header, headers, num_headers);
client->_is_chunked = *props.chunked;
client->_method_is_head = h2o_memis(method.base, method.len, H2O_STRLIT("HEAD"));
if (client->proceed_req != NULL) {
if (body.base != NULL) {
h2o_buffer_init(&client->_body_buf, &h2o_socket_buffer_prototype);
if (h2o_buffer_append(&client->_body_buf, body.base, body.len) == 0) {
on_send_request(client->sock, "Internal error");
return;
}
}
h2o_socket_write(client->sock, reqbufs, reqbufcnt, on_req_body_done);
} else {
if (client->_is_chunked) {
assert(body.base != NULL);
reqbufcnt += encode_chunk(client, reqbufs + reqbufcnt, body);
} else if (body.base != NULL) {
reqbufs[reqbufcnt++] = body;
}
h2o_socket_write(client->sock, reqbufs, reqbufcnt, on_send_request);
}
/* TODO no need to set the timeout if all data has been written into TCP sendbuf */
client->super._timeout.cb = on_send_timeout;
h2o_timer_link(client->super.ctx->loop, client->super.ctx->io_timeout, &client->super._timeout);
client->super.timings.request_begin_at = h2o_gettimeofday(client->super.ctx->loop);
}
int Game_Manager::process_drop_gate_cid(int gate_cid) {
for (Player_Cid_Map::iterator iter = player_cid_map_.begin(); iter != player_cid_map_.end(); ) {
if (iter->second->gate_cid() == gate_cid) {
//gate断开与game的连接，game上所有通过该gate连接进来的玩家数据回收
close_client(gate_cid, iter->second->player_cid(), 0);
player_cid_map_.erase(iter++);
}
}
return 0;
}
static void
remote_recv_cb(uv_stream_t *stream, ssize_t nread, const uv_buf_t *buf) {
struct remote_context *remote;
struct client_context *client;
remote = stream->data;
client = remote->client;
if (nread > 0) {
reset_timer(remote);
struct packet *packet = &remote->packet;
int rc = packet_filter(packet, buf->base, nread);
if (rc == PACKET_COMPLETED) {
uint8_t *m = packet->buf;
int mlen = packet->size - PRIMITIVE_BYTES;
int err = crypto_decrypt(m, packet->buf, packet->size);
if (err) {
goto error;
}
uv_read_stop(&remote->handle.stream);
forward_to_client(client, m, mlen);
} else if (rc == PACKET_INVALID) {
goto error;
}
} else if (nread < 0){
if (nread != UV_EOF) {
logger_log(LOG_ERR, "receive from %s failed: %s", dest_addr_buf, uv_strerror(nread));
}
close_client(client);
close_remote(remote);
}
return;
error:
logger_log(LOG_ERR, "invalid tcp packet");
close_client(client);
close_remote(remote);
}
void on_write( SP_TestClient * client, SP_TestEvent * event )
{
if( client->mSendMsgs < gMsgs ) {
client->mSendMsgs++;
char buffer[ 4096 ] = { 0 };
if( client->mSendMsgs >= gMsgs ) {
snprintf( buffer, sizeof( buffer ), "quit\n" );
} else {
snprintf( buffer, sizeof( buffer ),
"mail #%d, It's good to see how people hire; "
"that tells us how to market ourselves to them.\n", client->mSendMsgs );
}
int bytesTransferred = send( (SOCKET)client->mFd, buffer, strlen( buffer ), 0 );
if( bytesTransferred <= 0 ) {
if( bytesTransferred < 0 ) {
printf( "send fail, errno %d\n", WSAGetLastError() );
gStat.mSendFail++;
}
close_client( client );
return;
}
DWORD sendBytes = 0;
event->mType = SP_TestEvent::eEventSend;
memset( &( event->mOverlapped ), 0, sizeof( OVERLAPPED ) );
event->mWsaBuf.buf = NULL;
event->mWsaBuf.len = 0;
if( SOCKET_ERROR == WSASend( (SOCKET)client->mFd, &( event->mWsaBuf ), 1,
&sendBytes, 0, &( event->mOverlapped ), NULL ) ) {
if( ERROR_IO_PENDING != WSAGetLastError() ) {
gStat.mWSASendFail++;
printf( "WSASend fail, errno %d\n", WSAGetLastError() );
close_client( client );
}
}
} else {
// do nothing
}
}
void
connect_to_remote(struct remote_context *remote) {
remote->stage = XSTAGE_CONNECT;
remote->connect_req.data = remote;
int rc = uv_tcp_connect(&remote->connect_req, &remote->handle.tcp, &remote->addr, remote_connect_cb);
if (rc) {
logger_log(LOG_ERR, "connect to %s error: %s", remote->client->target_addr, uv_strerror(rc));
close_client(remote->client);
close_remote(remote);
}
}
static void on_body_content_length(h2o_socket_t *sock, const char *err)
{
struct st_h2o_http1client_t *client = sock->data;
h2o_timer_unlink(&client->super._timeout);
if (err != NULL) {
on_body_error(client, "I/O error (body; content-length)");
return;
}
if (sock->bytes_read != 0 || client->_body_decoder.content_length.bytesleft == 0) {
const char *errstr;
int ret;
if (client->_body_decoder.content_length.bytesleft <= sock->bytes_read) {
if (client->_body_decoder.content_length.bytesleft < sock->bytes_read) {
/* remove the trailing garbage from buf, and disable keepalive */
client->sock->input->size -= sock->bytes_read - client->_body_decoder.content_length.bytesleft;
client->_do_keepalive = 0;
}
client->_body_decoder.content_length.bytesleft = 0;
errstr = h2o_httpclient_error_is_eos;
client->super.timings.response_end_at = h2o_gettimeofday(client->super.ctx->loop);
} else {
client->_body_decoder.content_length.bytesleft -= sock->bytes_read;
errstr = NULL;
}
ret = client->super._cb.on_body(&client->super, errstr);
if (errstr == h2o_httpclient_error_is_eos) {
close_client(client);
return;
} else if (ret != 0) {
client->_do_keepalive = 0;
close_client(client);
return;
}
do_update_window(&client->super);
}
h2o_timer_link(client->super.ctx->loop, client->super.ctx->io_timeout, &client->super._timeout);
}
static void
remote_timer_expire(uv_timer_t *handle) {
struct remote_context *remote = handle->data;
struct client_context *client = remote->client;
if (verbose) {
char addrbuf[INET6_ADDRSTRLEN + 1] = {0};
uint16_t port = ip_name(&client->addr, addrbuf, sizeof addrbuf);
logger_log(LOG_WARNING, "%s:%d <-> %s connection timeout", addrbuf, port, client->target_addr);
}
close_client(remote->client);
close_remote(remote);
}
