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