void bev_connect_cb(struct bufferevent* bev, short events, void* arg) { jsonrpc_server_t* server = (jsonrpc_server_t*)arg; if(!arg) { ERR("Trying to connect null server\n"); return; } if (events & (BEV_EVENT_ERROR|BEV_EVENT_EOF)) { WARN("Connection error for %.*s:%d\n", STR(server->addr), server->port); if (events & BEV_EVENT_ERROR) { int err = bufferevent_socket_get_dns_error(bev); if(err) { ERR("DNS error for %.*s: %s\n", STR(server->addr), evutil_gai_strerror(err)); } } goto failed; } else if(events & BEV_EVENT_CONNECTED) { if (server->status == JSONRPC_SERVER_CONNECTED) { return; } server->status = JSONRPC_SERVER_CONNECTED; INFO("Connected to host %.*s:%d\n", STR(server->addr), server->port); } return; failed: connect_failed(server); }
/* Bufferevent event callback for the connect_hostname test: remembers what * event we got. */ static void be_connect_hostname_event_cb(struct bufferevent *bev, short what, void *ctx) { struct be_conn_hostname_result *got = ctx; if (!got->what) { TT_BLATHER(("Got a bufferevent event %d", what)); got->what = what; if ((what & BEV_EVENT_CONNECTED) || (what & BEV_EVENT_ERROR)) { int r; ++total_connected_or_failed; TT_BLATHER(("Got %d connections or errors.", total_connected_or_failed)); if ((r = bufferevent_socket_get_dns_error(bev))) { got->dnserr = r; TT_BLATHER(("DNS error %d: %s", r, evutil_gai_strerror(r))); } if (total_connected_or_failed >= 5) event_base_loopexit(be_connect_hostname_base, NULL); } } else { TT_FAIL(("Two events on one bufferevent. %d,%d", got->what, (int)what)); } }
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); } }
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; }
static void _ws_error_event(struct bufferevent *bev, short events, void *ptr) { const char *err_msg; int err; ws_t ws = (ws_t)ptr; assert(ws); LIBWS_LOG(LIBWS_DEBUG, "Error raised"); if (ws->state == WS_STATE_DNS_LOOKUP) { err = bufferevent_socket_get_dns_error(ws->bev); err_msg = evutil_gai_strerror(err); LIBWS_LOG(LIBWS_ERR, "DNS error %d: %s", err, err_msg); } else { err = EVUTIL_SOCKET_ERROR(); err_msg = evutil_socket_error_to_string(err); LIBWS_LOG(LIBWS_ERR, "%s (%d)", err_msg, err); // See if the serve closed on us. _ws_read_websocket(ws, bufferevent_get_input(ws->bev)); if (!ws->received_close) { ws->server_close_status = WS_CLOSE_STATUS_ABNORMAL_1006; } if (ws->close_cb) { LIBWS_LOG(LIBWS_ERR, "Abnormal close by server"); ws->close_cb(ws, ws->server_close_status, err_msg, strlen(err_msg), ws->close_arg); } } // TODO: Should there even be an erro callback? if (ws->err_cb) { ws->err_cb(ws, err, err_msg, ws->err_arg); } else { _ws_shutdown(ws); } }
void eventcb(struct bufferevent *bev, short events, void *ptr) { if (events & BEV_EVENT_CONNECTED) { printf("Connect okay.\n"); } else if (events & (BEV_EVENT_ERROR|BEV_EVENT_EOF)) { struct event_base *base = ptr; if (events & BEV_EVENT_ERROR) { int err = bufferevent_socket_get_dns_error(bev); if (err) printf("DNS error: %s\n", evutil_gai_strerror(err)); } printf("Closing\n"); bufferevent_free(bev); event_base_loopexit(base, NULL); } }
void eventcb(struct bufferevent *bev, short events, void *ptr) { struct info *inf = ptr; if (events & BEV_EVENT_CONNECTED) { printf("Connect okay.\n"); bufferevent_enable(bev, EV_READ|EV_WRITE); submit(bev, inf->msg[0]); clock_gettime(CLOCK_REALTIME, &inf->start); } else if (events & (BEV_EVENT_ERROR|BEV_EVENT_EOF)) { if (events & BEV_EVENT_ERROR) { int err = bufferevent_socket_get_dns_error(bev); if (err) printf("DNS error: %s\n", evutil_gai_strerror(err)); } printf("Closing\n"); event_base_loopexit(inf->base, NULL); } }
void TS3::telnetEvent(bufferevent *bev, short event, void *parentPtr) { if (event & BEV_EVENT_CONNECTED) { LOG(INFO) << "Connected to TeamSpeak server"; } else if (event & BEV_EVENT_TIMEOUT) { bufferevent_enable(bev, EV_READ|EV_WRITE); evbuffer_add_printf(bufferevent_get_output(bev), "whoami\n"); } else if (event & (BEV_EVENT_ERROR|BEV_EVENT_EOF)) { auto parent = static_cast<TS3*>(parentPtr); if (event & BEV_EVENT_ERROR) { int err = bufferevent_socket_get_dns_error(bev); if (err) LOG(ERROR) << "Can't connect to TeamSpeak server, DNS error: " << evutil_gai_strerror(err); } LOG(ERROR) << "TeamSpeak connection closed"; // FIXME needs a reliable restart mechanism, see thread parent->SendMessage("TS3 ServerQuery connection closed, fix me please"); bufferevent_free(bev); event_base_loopexit(parent->_base, nullptr); } }
void eventcb(struct bufferevent * bev, short events, void * ptr) { if (events & BEV_EVENT_CONNECTED) { struct timeval tv; tv.tv_sec = sec; tv.tv_usec = usec; evtimer_add(sev, &tv); return; } else if (events & (BEV_EVENT_ERROR | BEV_EVENT_EOF)) { struct event_base * base = ptr; if (events & BEV_EVENT_ERROR) { int err = bufferevent_socket_get_dns_error(bev); if (err) { printf("DNS error: %s\n", evutil_gai_strerror(err)); } } printf("Closing\n"); bufferevent_free(bev); event_base_loopexit(base, NULL); } }
void cTCPLinkImpl::EventCallback(bufferevent * a_BufferEvent, short a_What, void * a_Self) { ASSERT(a_Self != nullptr); cTCPLinkImplPtr Self = static_cast<cTCPLinkImpl *>(a_Self)->m_Self; if (Self == nullptr) { // The link has already been freed return; } // If an error is reported, call the error callback: if (a_What & BEV_EVENT_ERROR) { // Choose the proper callback to call based on whether we were waiting for connection or not: int err = EVUTIL_SOCKET_ERROR(); if (Self->m_ConnectCallbacks != nullptr) { if (err == 0) { // This could be a DNS failure err = bufferevent_socket_get_dns_error(a_BufferEvent); } Self->m_ConnectCallbacks->OnError(err, evutil_socket_error_to_string(err)); } else { Self->m_Callbacks->OnError(err, evutil_socket_error_to_string(err)); if (Self->m_Server == nullptr) { cNetworkSingleton::Get().RemoveLink(Self.get()); } else { Self->m_Server->RemoveLink(Self.get()); } } Self->m_Self.reset(); return; } // Pending connection succeeded, call the connection callback: if (a_What & BEV_EVENT_CONNECTED) { Self->UpdateLocalAddress(); Self->UpdateRemoteAddress(); if (Self->m_ConnectCallbacks != nullptr) { Self->m_ConnectCallbacks->OnConnected(*Self); // Reset the connect callbacks so that later errors get reported through the link callbacks: Self->m_ConnectCallbacks.reset(); return; } } // If the connection has been closed, call the link callback and remove the connection: if (a_What & BEV_EVENT_EOF) { // If running in TLS mode and there's data left in the TLS contect, report it: auto tlsContext = Self->m_TlsContext; if (tlsContext != nullptr) { tlsContext->FlushBuffers(); } Self->m_Callbacks->OnRemoteClosed(); if (Self->m_Server != nullptr) { Self->m_Server->RemoveLink(Self.get()); } else { cNetworkSingleton::Get().RemoveLink(Self.get()); } Self->m_Self.reset(); return; } // Unknown event, report it: LOGWARNING("cTCPLinkImpl: Unhandled LibEvent event %d (0x%x)", a_What, a_What); ASSERT(!"cTCPLinkImpl: Unhandled LibEvent event"); }