void eventcb(struct bufferevent *bev, short events, void *ptr) { int err = EVUTIL_SOCKET_ERROR(); evutil_socket_t fd =bufferevent_getfd(bev); printf("eventcb, fd=%d \n", fd); if (events & BEV_EVENT_CONNECTED) { /* We're connected to 127.0.0.1:8080. Ordinarily we'd do something here, like start reading or writing. */ printf("eventcb, BEV_EVENT_CONNECTED \n"); connected =1; } else if (events & BEV_EVENT_ERROR) { /* An error occured while connecting. */ printf("eventcb, BEV_EVENT_ERROR , %d,%s\n", err,evutil_socket_error_to_string(err)); int errdns = bufferevent_socket_get_dns_error(bev); if (errdns) printf("eventcb, DNS error: %d:%s\n", errdns, evutil_gai_strerror(errdns)); connected =-1; } else{ /* An error occured while connecting. */ printf("eventcb, Other ERROR , %d,%s\n", err,evutil_socket_error_to_string(err)); connected =-1; } if (connected==-1) { printf("---- eventcb, bufferevent_free %p \n", bev); bufferevent_free(bev); } }
static int send_handshake (evutil_socket_t data_fd, BlockTxInfo *info) { HandshakeRequest *req; if (sendn (data_fd, BLOCK_PROTOCOL_SIGNATURE, 37) < 0) { seaf_warning ("Failed to send protocol signature: %s.\n", evutil_socket_error_to_string(evutil_socket_geterror(data_fd))); info->result = BLOCK_CLIENT_NET_ERROR; return -1; } int req_size = sizeof(HandshakeRequest) + info->enc_key_len; req = (HandshakeRequest *) g_malloc (req_size); req->version = htonl(BLOCK_PROTOCOL_VERSION); req->key_len = htonl(info->enc_key_len); memcpy (req->enc_session_key, info->enc_session_key, info->enc_key_len); if (sendn (data_fd, req, req_size) < 0) { seaf_warning ("Failed to send handshake: %s.\n", evutil_socket_error_to_string(evutil_socket_geterror(data_fd))); info->result = BLOCK_CLIENT_NET_ERROR; g_free (req); return -1; } g_free (req); return 0; }
static void accept_error_cb(struct evconnlistener *listener, void *ctx) { struct event_base *base = evconnlistener_get_base(listener); int err = EVUTIL_SOCKET_ERROR(); fprintf(stderr, "Got an error %d (%s) on the listener. " "Shutting down.\n", err, evutil_socket_error_to_string(err)); event_base_loopexit(base, NULL); }
static void cdsurvivalproxy_ProxyErrorCallback (struct bufferevent* event, short error, CDClient* client) { assert(client); CDServer* server = client->server; assert(server); if (error & BEV_EVENT_CONNECTED) { SLOG(client->server, LOG_INFO, "proxy connected :D"); } if (!((error & BEV_EVENT_EOF) || (error & BEV_EVENT_ERROR) || (error & BEV_EVENT_TIMEOUT))) { //not an error return; } if (error & BEV_EVENT_ERROR) { SLOG(client->server, LOG_INFO, "libevent: ip %s - %s", client->ip, evutil_socket_error_to_string(EVUTIL_SOCKET_ERROR())); } else if (error & BEV_EVENT_TIMEOUT) { SERR(client->server, "A bufferevent timeout?"); } else if (error & BEV_EVENT_EOF) { SLOG(client->server, LOG_INFO, "remote EOF"); } CD_ServerKick(client->server, client, CD_CreateStringFromCString("remote connection died")); }
void CSockPairEvent::eventCB(struct bufferevent *, short event, void *arg) { CSockPairEvent *pParam = (CSockPairEvent*)arg; int iSockError = EVUTIL_SOCKET_ERROR(); if (event & BEV_EVENT_TIMEOUT) { return; } if (event & BEV_EVENT_ERROR) { #ifdef Q_OS_WIN if (WSA_IO_PENDING == iSockError) // WSAEWOULDBLOCK { return; } #else if (EAGAIN == iSockError) { return; } #endif } pParam->setRunStatus(RUNSTATUS_STOPPING); Q_Printf("an error happend, event is %d. error code %d, message %s exit loop", event, iSockError, evutil_socket_error_to_string(iSockError)); }
void eventcb(struct bufferevent *bev, short events, void *ctx) { fprintf(stderr, "eventcb,-------------------------- .\n"); struct evbuffer *input = bufferevent_get_input(bev); int finished = 0; if (events & BEV_EVENT_CONNECTED) { // 调用其他函数 /* We're connected to 127.0.0.1:8080. Ordinarily we'd do something here, like start reading or writing. */ fprintf(stderr, "Connect okay,-------------------------- .\n"); } if (events & BEV_EVENT_ERROR) { /* An error occured while connecting. */ fprintf(stderr, "Connect error++++--------------------------.\n"); printf("Got an error %s\n", evutil_socket_error_to_string(EVUTIL_SOCKET_ERROR())); finished = 1; } if (events & BEV_EVENT_EOF) { fprintf(stderr, "disConnect --------------------------.\n"); size_t len = evbuffer_get_length(input); printf("Got a close left :%lu bytes.\n", (unsigned long)len); finished = 1; } if (events & BEV_EVENT_TIMEOUT) { fprintf(stderr, "connect timeout--------------------------.\n"); finished = 1; } // 可以在这里调用回调函数销毁 if (finished) { bufferevent_free(bev); } }
static void accept_error_cb(struct evconnlistener *listener, void *arg) { struct event_base *base = evconnlistener_get_base(listener); int error = EVUTIL_SOCKET_ERROR(); fprintf(stderr, "Ошибка %d (%s) в мониторе соединений. Завершение работы.\n", error, evutil_socket_error_to_string(error)); event_base_loopexit(base, NULL); }
bool NetworkManager::init(int port) { memset(m_listenAddr,0,sizeof(sockaddr_in)); m_listenAddr->sin_family = AF_INET; m_listenAddr->sin_port = htons(port); m_eventBase = event_base_new(); if(!m_eventBase) { printf("Could not initialize libevent\n"); return false; } event_set_log_callback(&eventLog); m_listener = evconnlistener_new_bind(m_eventBase,evlistener,(void*)m_eventBase, LEV_OPT_REUSEABLE | LEV_OPT_CLOSE_ON_FREE,1,(struct sockaddr*)m_listenAddr ,sizeof(sockaddr_in)); if(!m_listener) { int errCode = EVUTIL_SOCKET_ERROR(); const char* reason = evutil_socket_error_to_string(errCode); event_base_free(m_eventBase); printf("Could not create a listener, msg : %s\n",reason); return false; } evutil_gettimeofday(&m_timeval, NULL); struct timeval tv = {1,0}; m_timer = event_new(m_eventBase,-1, EV_PERSIST, evtimer,this); event_add(m_timer, &tv); printf("network init secceed...\n"); return true; }
int v4c_srv_run(struct event_base *base, unsigned long port) { struct sockaddr_v4v sa = { .sa_family = AF_V4V, .sa_addr = { .domain = V4V_DOMID_ANY, .port = port } }; int rc; assert(!listener); assert(!client); assert(!input); assert(base); listener = evconnlistener_new_bind(base, v4c_srv_accept, NULL, LEV_OPT_CLOSE_ON_FREE | LEV_OPT_REUSEABLE, -1, (struct sockaddr *)&sa, sizeof (sa)); if (!listener) { rc = EVUTIL_SOCKET_ERROR(); WRN("Failed to initialized listener (%s).", evutil_socket_error_to_string(rc)); return -rc; } evconnlistener_set_error_cb(listener, v4c_srv_accept_error); event_base_dispatch(base); event_free(input); evconnlistener_free(listener); return 0; }
//server_t* server_init(struct sockaddr_in *listen_addr) server_t* server_init(int port) { log_debug(__FILE__, __LINE__, "Open server socket. Port : %d", port); server_t *server = calloc(sizeof(server_t), 1); // set address server->addr = calloc(sizeof(struct sockaddr_in), 1); server->addr->sin_family = AF_INET; server->addr->sin_addr.s_addr = INADDR_ANY; server->addr->sin_port = htons(port); server->evbase = event_base_new(); if(!server->evbase) { log_err(__FILE__, __LINE__, "Cannot init event base."); return NULL; } server->evlistener = evconnlistener_new_bind(server->evbase, server_event_accept, (void *)server, LEV_OPT_REUSEABLE | LEV_OPT_CLOSE_ON_FREE, -1, (struct sockaddr*)server->addr, sizeof(struct sockaddr_in)); if(!server->evlistener) { log_err(__FILE__, __LINE__, "Cannot init event listener. error : %s", evutil_socket_error_to_string(errno)); return NULL; } evconnlistener_set_error_cb(server->evlistener, server_event_error2); return server; }
zend_object * ion_stream_get_exception(ion_stream * stream, ion_buffer * bev) { zend_ulong error_ulong = 0; int error_int = 0; const char * error_message; zend_object * exception; void * exception_ce; zend_string * desc = ion_stream_describe(stream); if((error_ulong = bufferevent_get_openssl_error(bev))) { // problem with openssl connection error_message = ERR_error_string(error_ulong, NULL); exception_ce = ion_ce_ION_CryptoException; } else if((error_int = bufferevent_socket_get_dns_error(bev))) { // DNS problem error_message = evutil_gai_strerror(error_int); exception_ce = ion_ce_ION_DNSException; } else if((error_int = EVUTIL_SOCKET_ERROR())) { // socket problem error_message = evutil_socket_error_to_string(error_int); exception_ce = ion_ce_ION_StreamException; } else { // magic problem error_message = "stream corrupted"; exception_ce = ion_ce_ION_StreamException; } exception = pion_exception_new_ex( exception_ce, 0, "%s error: %s", desc->val, error_message ); zend_string_release(desc); return exception; }
void Conn::OnConnListenerErrCb(struct evconnlistener *evListener, void *arg) { Conn *cn = (Conn*)arg; int err = EVUTIL_SOCKET_ERROR(); LOG_DEBUG("Got an error " << err << "(" << evutil_socket_error_to_string(err) << ") on the listener! Program exit!"); event_base_loopexit(cn->pEvbase, NULL); }
void telex_accept_error_cb(struct evconnlistener *listener, void *ctx) { struct event_base *base = evconnlistener_get_base(listener); int err = EVUTIL_SOCKET_ERROR(); LogError("telex", "Accept error %d (%s)", err, evutil_socket_error_to_string(err)); }
static void accept_error_cb(struct evconnlistener *listener, void *arg) { struct event_base *base = evconnlistener_get_base(listener); int error = EVUTIL_SOCKET_ERROR(); std::cerr << "listener error: " << error << " (" << evutil_socket_error_to_string(error) << ")" << std::endl; event_base_loopexit(base, NULL); }
void event_cb(struct bufferevent* bev,short what,void *data) { if(what & BEV_EVENT_ERROR){ printf("socket error:%s\n",evutil_socket_error_to_string(EVUTIL_SOCKET_ERROR())); } connected -= 1; bufferevent_free(bev); }
void accept_error_cb(struct evconnlistener *listener, void *ctx) { struct event_base *base = evconnlistener_get_base(listener); int err = EVUTIL_SOCKET_ERROR();\ std::cout << "Got an error " << err << ": " << evutil_socket_error_to_string(err); event_base_loopexit(base, NULL); }
static void accept_error_cb(struct evconnlistener *listener, void *ctx) { struct event_base *base = evconnlistener_get_base(listener); int err = EVUTIL_SOCKET_ERROR(); log_err("Accept error: %d:%s", err, evutil_socket_error_to_string(err)); event_base_loopexit(base, NULL); }
static void on_listener_error(struct evconnlistener* l, void* arg) { int err = EVUTIL_SOCKET_ERROR(); struct event_base *base = evconnlistener_get_base(l); paxos_log_error("Listener error %d: %s. Shutting down event loop.", err, evutil_socket_error_to_string(err)); event_base_loopexit(base, NULL); }
/* * Client events. */ int v4c_cli_run(struct event_base *base, domid_t domid, unsigned long port) { struct sockaddr_v4v sa = { .sa_family = AF_V4V, .sa_addr = { .domain = domid, .port = port }, }; int rc; assert(!server); assert(!input); server = bufferevent_socket_new(base, -1, BEV_OPT_CLOSE_ON_FREE); if (!server) { rc = EVUTIL_SOCKET_ERROR(); WRN("Failed to open socket (%s).", evutil_socket_error_to_string(rc)); return -rc; } rc = bufferevent_socket_connect(server, (struct sockaddr*)&sa, sizeof (sa)); if (rc) { rc = EVUTIL_SOCKET_ERROR(); WRN("Failed to connect socket (%s).", evutil_socket_error_to_string(rc)); bufferevent_free(server); return -rc; } bufferevent_setcb(server, v4c_cli_recv, NULL, v4c_cli_event, NULL); bufferevent_enable(server, EV_READ | EV_WRITE); input = v4c_stdin_ev_new(base, server); if (!input) { bufferevent_free(server); } event_base_dispatch(base); event_free(input); /* v4c_cli_event will call bufferevent_free(server). */ return 0; }
/** * ################################################ * * Fun: * * Author: * * Date: Tue Dec 9 14:52:54 CST 2014 * * Purpose: * * * Params: * * Return: * * ################################################### */ void event_cb(struct bufferevent *bev,short events, void *ctx) { vLogErr(" the most recent error [%d] [%s]", EVUTIL_SOCKET_ERROR(), evutil_socket_error_to_string(EVUTIL_SOCKET_ERROR())); vLogErr("fd error is [%d] and error string [%s]", evutil_socket_geterror(bufferevent_getfd(bev)), evutil_socket_error_to_string(evutil_socket_geterror(bufferevent_getfd(bev)))); if(events & BEV_EVENT_CONNECTED) { vLogErr("connected!\n"); } else { if(events & BEV_EVENT_READING ) { vLogErr("error [%d] [%s]!",events,evutil_socket_error_to_string(events)); vLogErr("reading error!\n"); } if(events & BEV_EVENT_WRITING) { vLogErr("error [%d] [%s]!",events,evutil_socket_error_to_string(events)); vLogErr("writing error!\n"); } if((events & BEV_EVENT_READING) && (events & BEV_EVENT_TIMEOUT)) { vLogErr("error [%d] [%s]!",events,evutil_socket_error_to_string(events)); vLogErr("reading timeout error!\n"); } if((events & BEV_EVENT_WRITING) && (events & BEV_EVENT_TIMEOUT)) { vLogErr("error [%d] [%s]!",events,evutil_socket_error_to_string(events)); vLogErr("writing timeout error!\n"); } if(events & BEV_EVENT_EOF) { vLogErr("error [%d] [%s]!",events,evutil_socket_error_to_string(events)); vLogErr("eof file!\n"); } if(events & BEV_EVENT_ERROR) { vLogErr("error [%d] [%s]!",events,evutil_socket_error_to_string(events)); } if((events & BEV_EVENT_ERROR) && (events & BEV_EVENT_TIMEOUT)) { vLogErr("error [%d] [%s]!",events,evutil_socket_error_to_string(events)); vLogErr("timeout error!\n"); } bufferevent_free(bev); } }
void gated_error_cb(struct bufferevent *bev, short what, void *arg) { struct event_base *base = bufferevent_get_base(bev); fprintf(stdout, "gated error cb!!!\n"); int err = EVUTIL_SOCKET_ERROR(); fprintf(stderr, "Got an error %d (%s) on the gated_error_cb." "Shutting down.\n", err, evutil_socket_error_to_string(err)); event_base_loopexit(base, NULL); }
static void v4c_srv_accept_error(struct evconnlistener *listener, void *ctx) { struct event_base *base = evconnlistener_get_base(listener); int err = EVUTIL_SOCKET_ERROR(); unused(ctx); ERR("Error on listener: %s. Abort.", evutil_socket_error_to_string(err)); event_base_loopexit(base, NULL); /* Stop event loop. */ }
static void event_callback(struct bufferevent* bev, short events, void* arg) { if (events & BEV_EVENT_CONNECTED) { printf("Connected\n"); } else if (events & BEV_EVENT_ERROR) { printf("%s\n", evutil_socket_error_to_string(EVUTIL_SOCKET_ERROR())); } }
static evutil_socket_t connect_chunk_server (ChunkServer *cs) { struct sockaddr_in sa; ev_socklen_t sa_len; evutil_socket_t data_fd; ev_socklen_t optlen; if (dns_lookup (cs->addr, &sa, &sa_len) < 0) { return -1; } sa.sin_family = AF_INET; sa.sin_port = htons(cs->port); data_fd = socket (AF_INET, SOCK_STREAM, 0); if (data_fd < 0) { seaf_warning ("socket error: %s.\n", strerror(errno)); return -1; } #ifdef WIN32 /* Set large enough TCP buffer size. * This greatly enhances sync speed for high latency network. * Windows by default use 8KB buffers, which is too small for such case. * Linux has auto-tuning for TCP buffers, so don't need to set manually. * OSX is TBD. */ #define DEFAULT_SNDBUF_SIZE (1 << 16) /* 64KB */ /* Set send buffer size. */ int sndbuf_size; optlen = sizeof(int); getsockopt (data_fd, SOL_SOCKET, SO_SNDBUF, (char *)&sndbuf_size, &optlen); if (sndbuf_size < DEFAULT_SNDBUF_SIZE) { sndbuf_size = DEFAULT_SNDBUF_SIZE; optlen = sizeof(int); setsockopt (data_fd, SOL_SOCKET, SO_SNDBUF, (char *)&sndbuf_size, optlen); } #endif /* Disable Nagle's algorithm. */ int val = 1; optlen = sizeof(int); setsockopt (data_fd, IPPROTO_TCP, TCP_NODELAY, (char *)&val, optlen); if (connect (data_fd, (struct sockaddr *)&sa, sa_len) < 0) { seaf_warning ("connect error: %s.\n", evutil_socket_error_to_string(evutil_socket_geterror(data_fd))); evutil_closesocket (data_fd); return -1; } return data_fd; }
void event_sock_warn(evutil_socket_t sock, const char *fmt, ...) { va_list ap; int err = evutil_socket_geterror(sock); va_start(ap, fmt); _warn_helper(_EVENT_LOG_WARN, evutil_socket_error_to_string(err), fmt, ap); va_end(ap); }
// Shutdown on listener error static void listener_default_error_cb(struct evconnlistener *listener, void *ctx) { (void) ctx; // Avoid warning about unused parameter struct event_base *base = evconnlistener_get_base(listener); int err = EVUTIL_SOCKET_ERROR(); LogFatal("listener", "Got an error %d (%s) on the listener; shutting down", err, evutil_socket_error_to_string(err)); event_base_loopexit(base, NULL); }
static void error_on_tcp_peer_listener(struct evconnlistener *listener, void *_) { int error = EVUTIL_SOCKET_ERROR(); debug( "evconnlistener: %d %s\n", error, evutil_socket_error_to_string(error)); event_base_loopexit(context.events, NULL); return; }
static void sock_perror(const char *s) { #ifdef _WIN32 const char *err = evutil_socket_error_to_string(EVUTIL_SOCKET_ERROR()); fprintf(stderr, "%s: %s\n", s, err); #else perror(s); #endif }
static void do_store_request_error(struct request_ctx *req, int sock_err) { if (req->status != 0) { store_request_error(req, "%s hates me: %s", req->host, req->status_line); } else { store_request_error(req, "Socket error. errno %d (%s)", sock_err, evutil_socket_error_to_string(sock_err)); } }
void event_sock_err(int eval, evutil_socket_t sock, const char *fmt, ...) { va_list ap; int err = evutil_socket_geterror(sock); va_start(ap, fmt); warn_helper_(EVENT_LOG_ERR, evutil_socket_error_to_string(err), fmt, ap); va_end(ap); event_exit(eval); }