struct tcp_server_t* tcp_server_new(struct event_base* _base,
tcp_server_notifier_t _event_notifier,
int _port) {
struct tcp_server_t* res = (struct tcp_server_t*)malloc(sizeof(struct tcp_server_t));
if(res) {
memset(res, 0, sizeof(struct tcp_server_t));
res->base = _base;
res->event_notifier = _event_notifier;
res->sin.sin_family = AF_INET;
res->sin.sin_addr.s_addr = htonl(0);
res->sin.sin_port = htons(_port);
res->clients_counter = 0;
res->n_clients_limit = -1;
res->listener = evconnlistener_new_bind(res->base, accept_conn_cb, res,
LEV_OPT_CLOSE_ON_FREE|LEV_OPT_REUSEABLE, -1,
(struct sockaddr*)&res->sin, sizeof(struct sockaddr));
if(!res->listener) {
free(res);
return NULL;
}
evconnlistener_set_error_cb(res->listener, accept_error_cb);
}
return res;
}
//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;
}
void Conn::run()
{
if(conn_type & CONN_TYPE_LISTENER)
{
this->pEvbase = event_base_new();
struct evconnlistener* pEvConn = evconnlistener_new_bind(this->pEvbase,
OnConnListenerCb,
(void*)this,
LEV_OPT_CLOSE_ON_FREE | LEV_OPT_REUSEABLE,
-1,
(struct sockaddr*)&sAddrIn,
sizeof(struct sockaddr_in));
if(!pEvConn)
{
LOG_DEBUG("server on " << addr << ":" << ntohs(sAddrIn.sin_port) << " fail");
return;
}
LOG_DEBUG("server on " << addr << ":" << ntohs(sAddrIn.sin_port));
evconnlistener_set_error_cb(pEvConn, OnConnListenerErrCb);
event_base_dispatch(this->pEvbase);
return;
}
if(conn_type & CONN_TYPE_CONNECTER)
{
this->pEvbase = event_base_new();
this->pConnEvBuf = bufferevent_socket_new(this->pEvbase, -1, BEV_OPT_CLOSE_ON_FREE);
bufferevent_setcb(this->pConnEvBuf, OnReadCbAddr, NULL, OnConnEventCb, (void*)this);
if(bufferevent_socket_connect(this->pConnEvBuf, (struct sockaddr*)&sAddrIn, sizeof(struct sockaddr_in)) != 0)
{
LOG_DEBUG("conn on " << addr << ":" << ntohs(sAddrIn.sin_port) << " fail");
bufferevent_free(this->pConnEvBuf);
return;
}
LOG_DEBUG("conn on " << addr << ":" << ntohs(sAddrIn.sin_port));
struct event* pEvent = NULL;
evutil_socket_t fd = bufferevent_getfd(this->pConnEvBuf);
if(fd != -1 && OnTimingCbAddr != NULL)
{
pEvent = event_new(this->pEvbase, fd, EV_PERSIST, OnTimingEventCb, (void*)this);
event_add(pEvent, &this->tv);
}
bufferevent_enable(this->pConnEvBuf, EV_READ);
event_base_dispatch(this->pEvbase);
if(fd != -1 && OnTimingCbAddr != NULL)
{
event_del(pEvent);
}
return;
}
}
int
main(int argc, char *argv[])
{
// TODO: Make port configurable
int port = 1234;
struct event_base *base;
struct evconnlistener *listener;
struct sockaddr_in sin;
if ((base = event_base_new()) == NULL) {
err(1, "Failed to open base event");
}
memset(&sin, 0, sizeof(sin));
sin.sin_family = AF_INET;
sin.sin_addr.s_addr = htonl(0);
sin.sin_port = htons(port);
listener = evconnlistener_new_bind(base, accept_conn_cb, NULL,
LEV_OPT_CLOSE_ON_FREE|LEV_OPT_REUSEABLE, -1,
(struct sockaddr*)&sin, sizeof(sin));
if (!listener) {
perror("Couldn't create listener");
return 1;
}
evconnlistener_set_error_cb(listener, accept_error_cb);
event_base_dispatch(base);
return 0;
}
// Initializes event-driven connection listener on 127.0.0.1:port,
// with given accept and error callbacks.
// Returns pointer to listener or 0 on error
struct evconnlistener *listener_init_local(struct event_base *base, int port,
evconnlistener_cb accept_cb, void *state,
evconnlistener_errorcb error_cb /* optional */)
{
if (error_cb == NULL) {
error_cb = listener_default_error_cb;
}
struct sockaddr_in sin;
memset(&sin, 0, sizeof(sin));
sin.sin_family = AF_INET;
sin.sin_addr.s_addr = htonl(0x7f000001); // i.e., 127.0.0.1
sin.sin_port = htons(port);
struct evconnlistener *listener;
listener = evconnlistener_new_bind(base, accept_cb, state,
LEV_OPT_CLOSE_ON_FREE|LEV_OPT_REUSEABLE, -1,
(struct sockaddr*)&sin, sizeof(sin));
if (!listener) {
return 0;
}
evconnlistener_set_error_cb(listener, error_cb);
char addr[255];
address_to_string(&sin, addr, sizeof(addr));
LogInfo("listener", "Listening on %s", addr);
return listener;
}
CServer::CServer(unsigned int port)
{
std::cout << "init with port " << port << "\n";
base = event_base_new();
if (!base) {
std::cout << "Could not initialize libevent!\n";
assert(0);
}
memset(&sin, 0, sizeof(sin));
sin.sin_port = htons(port);
sin.sin_family = AF_INET;
listener = evconnlistener_new_bind(base, listener_cb, (void *)base,
LEV_OPT_REUSEABLE|LEV_OPT_CLOSE_ON_FREE, -1,
(struct sockaddr*)&sin,
sizeof(sin));
if (!listener) {
std::cout << "Could not create a listener!\n";
assert(0);
}
evconnlistener_set_error_cb(listener, accept_error_cb);
}
int main(int argc, char **argv)
{
printf("Server based on LibEvent PID -- %d.\n", getpid());
struct event_base *base = event_base_new();
// Set address
struct sockaddr_in serv_addr;
memset(&serv_addr, '\0', sizeof(serv_addr));
serv_addr.sin_family = AF_INET;
serv_addr.sin_addr.s_addr = htonl(INADDR_ANY); // 0.0.0.0 (INADDR_LOOPBACK - 127.0.0.1)
// Change bytes order to network'
int nport = htons((int)PORTNUM);
serv_addr.sin_port = nport;
struct evconnlistener *listener = evconnlistener_new_bind(
base,
accept_conn_callback,
NULL, // Parent context
LEV_OPT_CLOSE_ON_FREE | LEV_OPT_REUSEABLE,
-1, // Backlog => means SOMAXCONN
(struct sockaddr*) &serv_addr,
sizeof(serv_addr));
evconnlistener_set_error_cb(listener, accept_error_callback);
printf("Server is ready: %s\n", inet_ntoa(serv_addr.sin_addr));
event_base_dispatch(base);
return 0;
}
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;
}
bool CServer::Init( const char * ip, unsigned int port, IConnectorSink* sink ) {
// request socket
net_shutdown_listener_ = net_service_impl_->RegisterShutdownEventListener(std::bind(&IServer::Shutdown, shared_from_this()));
sink_ = sink;
// config address
struct sockaddr_in sin;
sin.sin_family = AF_INET;
sin.sin_addr.s_addr = INADDR_ANY;
sin.sin_port = htons(port);
evconn_listener_ = evconnlistener_new_bind(
net_service_impl_->ev_base(),
OnAccepted,
this,
LEV_OPT_THREADSAFE | LEV_OPT_REUSEABLE,
ACCEPTOR_LISTEN_BACKLOG,
(sockaddr*)&sin,
sizeof(sockaddr_in));
if(evconn_listener_ == 0) {
net_shutdown_listener_.Disconnect();
sLogError("server(%s:%d) evconnlistener_new_bind failed.", ip, port);
return false;
}
evconnlistener_set_error_cb(evconn_listener_, OnAcceptError);
local_ip_ = ip;
local_port_ = port;
sLogInfo("server(%s:%d) start", local_ip_.c_str(), local_port_);
return true;
}
static void
regress_listener_error(void *arg)
{
struct basic_test_data *data = arg;
struct event_base *base = data->base;
struct evconnlistener *listener = NULL;
int count = 1;
unsigned int flags = LEV_OPT_CLOSE_ON_FREE|LEV_OPT_REUSEABLE;
if (data->setup_data && strstr((char*)data->setup_data, "ts")) {
flags |= LEV_OPT_THREADSAFE;
}
/* send, so that pair[0] will look 'readable'*/
tt_int_op(send(data->pair[1], "hello", 5, 0), >, 0);
/* Start a listener with a bogus socket. */
listener = evconnlistener_new(base, acceptcb, &count,
flags, 0,
data->pair[0]);
tt_assert(listener);
evconnlistener_set_error_cb(listener, errorcb);
tt_assert(listener);
event_base_dispatch(base);
tt_int_op(count,==,1000); /* set by error cb */
end:
if (listener)
evconnlistener_free(listener);
}
static void* network_manager_thread_routine(void* context) {
if (NULL != context) {
printf("1\n");
struct network_manager* manager = (struct network_manager*)context;
if (NULL != manager->base && NULL == manager->listener) {
printf("2\n");
struct sockaddr_in address;
memset(&address, 0, sizeof(struct sockaddr_in));
address.sin_family = AF_INET;
address.sin_addr.s_addr = inet_addr("127.0.0.1");
address.sin_port = htons(1025);
manager->listener = evconnlistener_new_bind(manager->base,
network_manager_accept_handler, manager,
LEV_OPT_CLOSE_ON_FREE | LEV_OPT_REUSEABLE | LEV_OPT_THREADSAFE,
-1, (struct sockaddr*)&address, sizeof(struct sockaddr_in));
if (NULL != manager->listener) {
printf("3\n");
evconnlistener_set_error_cb(manager->listener, network_manager_accept_error_handler);
event_base_dispatch(manager->base);
printf("4\n");
}
}
}
return ((void*)0);
}
int main(int argc, char **argv) {
struct evconnlistener *listener;
struct event_base *base;
struct sockaddr_in srv_sin;
struct option long_options[] = { { "port", 1, 0, 0 } };
int32_t idx;
u_int16_t port = 0;
char c;
while (1) {
c = getopt_long(argc, argv, "", long_options, &idx);
if (c == -1)
break;
switch (c) {
case 0:
if (strcmp(long_options[idx].name, "port") == 0)
port = atoi(optarg);
break;
default:
return usage(argv[0]);
}
}
if (!port)
return usage(argv[0]);
signal(SIGPIPE, SIG_IGN);
base = event_base_new();
if (!base) {
perror("Couldn't open event base");
return -1;
}
memset(&srv_sin, 0, sizeof(srv_sin));
srv_sin.sin_family = AF_INET;
srv_sin.sin_addr.s_addr = htonl(0);
srv_sin.sin_port = htons(port);
listener = evconnlistener_new_bind(base, drone_srv_accept_success_cb,
NULL,
LEV_OPT_CLOSE_ON_FREE | LEV_OPT_REUSEABLE, -1, (struct sockaddr*) &srv_sin,
sizeof(srv_sin));
if (!listener) {
perror("Couldn't create listener");
return -1;
}
evconnlistener_set_error_cb(listener, drone_srv_accept_error_cb);
printf("Drone started, waiting for job...\n");
event_base_dispatch(base);
event_base_free(base);
return 0;
}
static void watch_service_cb(neuworker_t *nw, struct neuhandle *nh, void *data){
struct neuservice *ns = (struct neuservice *)data;
ASSERT((nw != NULL) && (ns != NULL));
ns->ns_listen = evconnlistener_new_bind(nw->base, neuservice_accept_cb,
ns, 0, -1, (struct sockaddr*)&ns->ns_addr, sizeof(ns->ns_addr));
evconnlistener_set_error_cb(ns->ns_listen, neuservice_shutdown_cb);
ns->ns_worker = nw;
}
int smpp_listener_start(SMPPServer *smpp_server) {
struct sockaddr_in sin;
/* Create new event base */
smpp_server->event_base = event_base_new();
if (!smpp_server->event_base) {
error(0, "Couldn't open event base");
return 1;
}
/* Clear the sockaddr before using it, in case there are extra
* platform-specific fields that can mess us up. */
memset(&sin, 0, sizeof (sin));
sin.sin_family = AF_INET;
sin.sin_port = htons(smpp_server->smpp_port);
sin.sin_addr.s_addr = htonl(INADDR_ANY);
/* Create a new listener */
info(0, "Starting SMPP server on port %ld", smpp_server->smpp_port);
smpp_server->event_listener = evconnlistener_new_bind(smpp_server->event_base, smpp_listener_connection_callback, smpp_server,
LEV_OPT_CLOSE_ON_FREE | LEV_OPT_REUSEABLE, -1,
(struct sockaddr *) &sin, sizeof (sin));
if (!smpp_server->event_listener) {
panic(0,"Couldn't create listener");
return 1;
}
smpp_server->ip_blocklist = dict_create(512, (void(*)(void *))smpp_blocked_ip_destroy);
smpp_bearerbox_init(smpp_server);
smpp_esme_init(smpp_server);
smpp_queues_init(smpp_server);
evconnlistener_set_error_cb(smpp_server->event_listener, smpp_listener_accept_error_callback);
event_base_dispatch(smpp_server->event_base);
smpp_queues_shutdown(smpp_server);
smpp_esme_shutdown(smpp_server);
smpp_bearerbox_shutdown(smpp_server);
dict_destroy(smpp_server->ip_blocklist);
evconnlistener_free(smpp_server->event_listener);
event_base_free(smpp_server->event_base);
return 0;
}
int
main(int argc, char **argv)
{
struct event_base *base;
struct evconnlistener *listener;
struct sockaddr_in sin;
int port = 9876;
if (argc > 1) {
port = atoi(argv[1]);
}
if (port<=0 || port>65535) {
puts("Invalid port");
return 1;
}
base = event_base_new();
if (!base) {
puts("Couldn't open event base");
return 1;
}
/* Clear the sockaddr before using it, in case there are extra
* platform-specific fields that can mess us up. */
memset(&sin, 0, sizeof(sin));
/* This is an INET address */
sin.sin_family = AF_INET;
/* Listen on 0.0.0.0 */
sin.sin_addr.s_addr = htonl(0);
/* Listen on the given port. */
sin.sin_port = htons(port);
listener = evconnlistener_new_bind(base, accept_conn_cb, base,
LEV_OPT_CLOSE_ON_FREE|LEV_OPT_REUSEABLE|LEV_OPT_DEFERRED_ACCEPT, -1,
(struct sockaddr*)&sin, sizeof(sin));
if (!listener) {
perror("Couldn't create listener");
return 1;
}
else
{
printf("create listener success, base:%p\n", base);
}
evconnlistener_set_error_cb(listener, accept_error_cb);
event_base_dispatch(base);
return 0;
}
//启动监听
bool MMaster::StartListen()
{
do
{
struct sockaddr_in sin;
server_base_ = event_base_new();
if (!server_base_)
break;
memset(&sin, 0, sizeof(sin));
sin.sin_family = AF_INET;
sin.sin_addr.s_addr = htonl(0);
sin.sin_port = htons(listen_port_);
//设置AcceptConn事件 监听连接信息
server_conn_listenner_ = evconnlistener_new_bind(server_base_,
AcceptConn, this, LEV_OPT_CLOSE_ON_FREE | LEV_OPT_REUSEABLE,
-1, (struct sockaddr*) &sin, sizeof(sin));
if (!server_conn_listenner_)
break;
evconnlistener_set_error_cb(server_conn_listenner_, AcceptError);
//每个线程都在跑server_base_的事件循环
try
{
main_listen_thread_.reset(
new std::thread([this]
{
//注册定时事件，定时调用
timeval tv;
int flags = 0;
event timeout;
event_assign(&timeout, server_base_, -1, flags, timeout_cb, (void*) &timeout);
evutil_timerclear(&tv);
tv.tv_sec = 0;
tv.tv_usec = micsec;
event_add(&timeout, &tv);
evutil_gettimeofday(&lasttime, NULL);
event_base_dispatch(server_base_);
}));
}
catch (...)
{
break;
}
return true;
}
while (0);
return false;
}
int NetworkWrapper::Init()
{
struct sockaddr_in sin;
gstEvtBase = event_base_new();
if (!gstEvtBase)
{
logerr("Could not initialize libevent!\n");
return -1;
}
memset(&sin, 0, sizeof(sin));
sin.sin_family = AF_INET;
sin.sin_port = htons(m_iPort);
m_stEvtlistener = evconnlistener_new_bind(gstEvtBase, accept_conn_cb, (void *)gstEvtBase,
LEV_OPT_REUSEABLE|LEV_OPT_CLOSE_ON_FREE, -1,
(struct sockaddr*)&sin,
sizeof(sin));
if (!m_stEvtlistener)
{
logerr("Could not create a listener!\n");
return -1;
}
evconnlistener_set_error_cb(m_stEvtlistener, accept_error_cb);
m_stSigEvt = evsignal_new(gstEvtBase, SIGINT, signal_cb, (void *)gstEvtBase);
if (!m_stSigEvt || event_add(m_stSigEvt, NULL)<0) {
logerr("Could not create/add a signal event!\n");
return -1;
}
/*add tick*/
struct timeval tv;
tv.tv_sec = 1;
tv.tv_usec = 0;
m_stTimeEvt = evtimer_new(gstEvtBase,timer_cb, (void *)this);
if (!m_stTimeEvt || event_add(m_stTimeEvt, &tv)<0)
{
logerr("Could not create/add a time event!\n");
return -1;
}
return 0;
}
int main(int argc, char **argv){
base = event_base_new();
storage_prepare();
struct sockaddr_in sin;
memset(&sin, 0, sizeof(sin));
sin.sin_family = AF_INET;
sin.sin_addr.s_addr = htonl(0);
sin.sin_port = htons(PORT);
listener = evconnlistener_new_bind(base, accept_conn_cb, NULL, LEV_OPT_CLOSE_ON_FREE|LEV_OPT_REUSEABLE, -1, (struct sockaddr*)&sin, sizeof(sin));
if (!listener) { perror("Couldn't create listener");return 1; }
evconnlistener_set_error_cb(listener, accept_error_cb);
event_base_dispatch(base);
return 0;
}
int main(int argc, char *argv[])
{
FLAGS_log_dir = "./log";
// FLAGS_logtostderr = true;
FLAGS_minloglevel = 1;
google::InitGoogleLogging(argv[0]);
int port = 8888;
if (argc > 1) {
port = atoi(argv[1]);
}
if (port <=0 || port > 65545) {
puts("Invaild port");
return -1;
}
struct event_base *base;
base = event_base_new();
if (!base) {
LOG(ERROR) << "Couldn't open event base";
return -1;
}
struct sockaddr_in sin;
memset(&sin, 0, sizeof(sin));
sin.sin_family = AF_INET;
sin.sin_addr.s_addr = htonl(0);
sin.sin_port = htons(port);
struct evconnlistener *listener;
listener = evconnlistener_new_bind(base, accept_conn_cb, NULL,
LEV_OPT_CLOSE_ON_FREE | LEV_OPT_REUSEABLE, -1,
(struct sockaddr*)&sin, sizeof(sin));
if (!listener) {
LOG(ERROR) << "Could't create listener";
return -1;
}
evconnlistener_set_error_cb(listener, accept_error_cb);
event_base_dispatch(base);
return 0;
}
static int init_server(arguments *args) {
printf("Starting server...\n");
if (evthread_use_pthreads() == -1) {
printf("Error occured while turning on pthreads using\n");
return -1;
}
signal(SIGINT, int_handler);
struct evconnlistener* listener;
struct sockaddr_in sin;
base = event_base_new();
if (!base) {
printf("Error while creating event base\n");
free(args);
return -1;
}
thread_pool* thpool = thread_pool_init(args->ncpu, args->doc_root);
memset(&sin, 0, sizeof(sin));
sin.sin_family = AF_INET;
sin.sin_addr.s_addr = htonl(INADDR_ANY);
sin.sin_port = htons((unsigned short)args->port);
listener = evconnlistener_new_bind(base, accept_connection_cb, (void*)thpool, (LEV_OPT_CLOSE_ON_FREE|LEV_OPT_REUSEABLE),
-1, (struct sockaddr*) &sin, sizeof(sin));
free(args);
if (!listener) {
printf("Error while creating listener\n");
thread_pool_destroy(thpool);
event_base_free(base);
return -1;
}
evconnlistener_set_error_cb(listener, accept_error_cb);
printf("Server is running\nUse Ctrl+C to stop server\n");
event_base_dispatch(base);
evconnlistener_free(listener);
thread_pool_destroy(thpool);
event_base_free(base);
return 0;
}
int main(int argc,char** argv){
evbase = event_base_new();
if(!evbase){
fprintf(stderr, "create evbase error!\n");
exit(0);
}
// 创建http server实例
ev_ssl = evhttp_new(evbase);
if(!ev_ssl){
exit(0);
}
// openssl 初始化
SSL_library_init();
ERR_load_crypto_strings();
SSL_load_error_strings();
OpenSSL_add_all_algorithms();
if (SSLeay() != OPENSSL_VERSION_NUMBER){
}
ev_ssl->ctx = get_ssl_ctx(certfile_url.c_str(),keyfile_url.c_str());
ev_ssl->ssl_cb = bufferevent_openssl_socket_new;
std::string ev_ssl_ip="192.168.1.10"; int ev_ssl_port = 8080;
// evhttp_bind_socket_with_handle这个函数在原基础上追加一个参数，标示http server知否支持ssl(0:不支持 1:支持)
struct evhttp_bound_socket *ssl_handle = evhttp_bind_socket_with_handle(ev_ssl, ev_ssl_ip.c_str(), ev_ssl_port,1);
if(!ssl_handle){
exit(0);
}
struct evconnlistener *ssl_listener = evhttp_bound_socket_get_listener(ssl_handle);
evconnlistener_set_error_cb(ssl_listener, ssl_accept_error_cb);
evhttp_set_cb(ev_ssl, "/ping", ping_handler, NULL);
event_base_dispatch(evbase);
evhttp_free(ev_ssl); event_base_free(evbase);
return 0;
}
int main( int argc, char **argv )
{
int port = 5001;
if (argc > 1) port = atoi(argv[1]);
if (port < 0 || port > 65535 )
{
std::cerr << "bad port" << std::endl;
return -1;
}
struct event_base *base = event_base_new();
if (!base)
{
std::cerr << "error to create event_loop base" << std::endl;
return -1;
}
struct sockaddr_in sin;
memset( &sin, 0, sizeof(sin) );
sin.sin_family = AF_INET; // работа с доменом IP-адресов
sin.sin_addr.s_addr = htonl(INADDR_ANY);
sin.sin_port = htons(port);
struct evconnlistener *listener =
evconnlistener_new_bind(base,
accept_connection_cb,
NULL,
(LEV_OPT_CLOSE_ON_FREE | LEV_OPT_REUSEABLE),
-1,
(struct sockaddr *)&sin,
sizeof(sin));
if (!listener)
{
std::cerr << "error to create event listener" << std::endl;
return -1;
}
std::cerr << "start listen on port: " << port << std::endl;
evconnlistener_set_error_cb(listener, accept_error_cb);
event_base_dispatch(base);
return 0;
}
void HttpServer::startServer(int port, int nCPU, char *rootDir) {
struct sockaddr_in listenAddr;
struct event_base *base;
struct evconnlistener *listener;
if (rootDir == nullptr) {
rootDir_ = Configuration::ROOT_DIR;
} else {
rootDir_ = rootDir;
}
base = event_base_new();
if (!base) {
throw std::runtime_error("Can't create base");
}
if (evthread_make_base_notifiable(base) < 0) {
event_base_free(base);
throw std::runtime_error("Couldn't make base notifiable!");
}
memset(&listenAddr, 0, sizeof(listenAddr));
listenAddr.sin_family = AF_INET;
listenAddr.sin_addr.s_addr = htonl(0);
if (port == 0) {
port = Configuration::PORT;
}
listenAddr.sin_port = htons(port);
if (nCPU == 0) {
nCPU = Configuration::nCPU;
}
WorkQueue::workqueue_init((workqueue_t *) &workqueue, nCPU);
listener = evconnlistener_new_bind(base, acceptConnCb, (void *) &workqueue,
LEV_OPT_CLOSE_ON_FREE | LEV_OPT_REUSEABLE | LEV_OPT_THREADSAFE, SOMAXCONN,
(struct sockaddr *) &listenAddr, sizeof(listenAddr));
if (listener == NULL) {
event_base_free(base);
WorkQueue::workqueue_shutdown(&workqueue);
throw std::runtime_error("Port is busy");
}
evconnlistener_set_error_cb(listener, acceptErrorCb);
event_base_dispatch(base);
event_base_free(base);
WorkQueue::workqueue_shutdown(&workqueue);
}
struct http_server * http_server_new(struct event_base *base, int port)
{
struct http_server *hs = NULL;
hs = (struct http_server *)malloc(sizeof(struct http_server));
if (!hs) {
printf("Could not create http server\n");
return NULL;
}
memset(hs, 0, sizeof(struct http_server));
hs->base = base;
struct sockaddr_in sin;
sin.sin_family=AF_INET;
sin.sin_port=htons(port);
sin.sin_addr.s_addr=INADDR_ANY;
/* init connection listener */
hs->listener = evconnlistener_new_bind(base, http_connect_cb, hs,
LEV_OPT_REUSEABLE | LEV_OPT_CLOSE_ON_EXEC,
100, (struct sockaddr*)(&sin), sizeof(struct sockaddr_in));
if (!hs->listener) {
printf("Could not bind a listener to port %d\n", port);
goto failed;
}
evconnlistener_set_error_cb(hs->listener, http_connect_error_cb);
/* init connection head node, for convinents */
hs->hc = http_connection_new(hs, -1, (struct sockaddr *)&sin);
if (!hs->hc) {
printf("Could not create a initial connection for http server\n");
goto failed;
}
/* init uris */
http_uris_init(hs);
return hs;
failed:
http_server_free(hs);
return NULL;
}
int main(int argc,char **argv)
{
struct event_base * base = event_base_new();
struct sockaddr_in addr ;
addr.sin_family = AF_INET;
addr.sin_addr.s_addr = htonl(0);
addr.sin_port = htons(3333);
set_timer(base);
struct evconnlistener * lev ;
lev = evconnlistener_new_bind(base,accept_conn_cb,NULL,
LEV_OPT_CLOSE_ON_FREE|LEV_OPT_REUSEABLE,
-1,(struct sockaddr*)&addr,sizeof(addr));
evconnlistener_set_error_cb(lev,listener_error_cb);
event_base_dispatch(base);
evconnlistener_free(lev);
event_base_free(base);
return 0;
}
void init_server(int port) {
fprintf(stderr, "Using port %d\n", port);
clients = NULL;
// Make it thread safe
int err = evthread_use_pthreads();
if (err != 0)
{
fprintf(stderr, "Unable to make libevent thread safe");
exit(EXIT_FAILURE);
}
struct sockaddr_in sin;
// Create a new event base
base = event_base_new();
if (!base)
{
fprintf(stderr, "Unable to open event base\n");
exit(EXIT_FAILURE);
}
// Set up the socket
memset(&sin, 0, sizeof(sin));
sin.sin_family = AF_INET;
sin.sin_addr.s_addr = 0;
sin.sin_port = htons(port);
// Create a new listener
listener = evconnlistener_new_bind(base, accept_connection, NULL,
LEV_OPT_CLOSE_ON_FREE | LEV_OPT_REUSEABLE, -1,
(struct sockaddr *) &sin, sizeof(sin));
if (!listener)
{
perror("Unable to create listener");
exit(EXIT_FAILURE);
}
evconnlistener_set_error_cb(listener, accept_error);
}
int main(int argc, char *argv[])
{
void *sighandle;
struct sockaddr_in addr;
server serv;
if(argc<2)
return 2;
serv.base = event_base_new();
assert(serv.base);
memset(&addr, 0, sizeof(addr));
addr.sin_family = AF_INET;
addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
addr.sin_port = htons(atoi(argv[1]));
serv.listener = evconnlistener_new_bind(serv.base, newconn, &serv,
LEV_OPT_CLOSE_ON_FREE | LEV_OPT_REUSEABLE,
4, (struct sockaddr*)&addr, sizeof(addr));
assert(serv.listener);
evconnlistener_set_error_cb(serv.listener, listenerr);
sighandle = setsighandle(serv.base);
printf("Running\n");
event_base_loop(serv.base, 0);
printf("Stopping\n");
evconnlistener_free(serv.listener);
cancelsighandle(sighandle);
event_base_free(serv.base);
memset(&serv, 0, sizeof(serv));
printf("Done\n");
return 0;
}
int tcp_start_up(){
WSADATA WSAData;
struct event_base *base;
struct evconnlistener *listener;
struct sockaddr_in sin;
int port = 22222;
WSAStartup(0x101, &WSAData);
base = event_base_new();
if (!base) {
puts("Couldn't open event base");
return 1;
}
/* Clear the sockaddr before using it, in case there are extra
* platform-specific fields that can mess us up. */
memset(&sin, 0, sizeof(sin));
/* This is an INET address */
sin.sin_family = AF_INET;
/* Listen on 0.0.0.0 */
sin.sin_addr.s_addr = htonl(0);
/* Listen on the given port. */
sin.sin_port = htons(port);
listener = evconnlistener_new_bind(base, accept_conn_cb, NULL,
LEV_OPT_CLOSE_ON_FREE|LEV_OPT_REUSEABLE, -1,
(struct sockaddr*)&sin, sizeof(sin));
if (!listener) {
perror("Couldn't create listener");
return 1;
}
evconnlistener_set_error_cb(listener, accept_error_cb);
printf("ready to dispatch...\n");
event_base_dispatch(base);
return 0;
}
int main(int argc, char** argv) {
struct event_base* base = event_base_new();
struct sockaddr_in sin;
memset(&sin, 0, sizeof(sin));
sin.sin_family = AF_INET;
sin.sin_addr.s_addr = htonl(0);
sin.sin_port = htons(80);
struct evwsconnlistener* levws = evwsconnlistener_new_bind(
base, new_wsconnection, NULL,
LEV_OPT_CLOSE_ON_FREE|LEV_OPT_REUSEABLE, -1, NULL,
(struct sockaddr*)&sin, sizeof(sin));
if (!levws) {
fprintf(stderr, "Error creating Web Socket listener: %s\n",
strerror(errno));
exit(-1);
}
evwsconnlistener_set_error_cb(levws, ws_listener_error);
memset(&sin, 0, sizeof(sin));
sin.sin_family = AF_INET;
sin.sin_addr.s_addr = htonl(0);
sin.sin_port = htons(8000);
struct evconnlistener *evlistener = evconnlistener_new_bind(
base, new_connection, NULL,
LEV_OPT_CLOSE_ON_FREE|LEV_OPT_REUSEABLE, -1,
(struct sockaddr*)&sin, sizeof(sin));
if (!evlistener) {
fprintf(stderr, "Error creating socket listener: %s\n",
strerror(errno));
exit(-1);
}
evconnlistener_set_error_cb(evlistener, listener_error);
event_base_dispatch(base);
return 0;
}
struct tcp_receiver* tcp_receiver_new(struct event_base* b, int port, bufferevent_data_cb cb, void* arg)
{
struct tcp_receiver* r;
struct sockaddr_in sin;
unsigned flags = LEV_OPT_CLOSE_ON_EXEC | LEV_OPT_CLOSE_ON_FREE | LEV_OPT_REUSEABLE;
r = malloc(sizeof(struct tcp_receiver));
set_sockaddr_in(&sin, port);
r->callback = cb;
r->arg = arg;
/*libevent listener和bind端口*/
r->listener = evconnlistener_new_bind(b, on_accept, r, flags, -1, (struct sockaddr*)&sin, sizeof(sin));
assert(r->listener != NULL);
/*设置listen error 回调处理*/
evconnlistener_set_error_cb(r->listener, on_listener_error);
r->bevs = carray_new(10);
paxos_log_info("Listening on port %d", port);
return r;
}
