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