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); }