/**
* create a global context
*/
chassis *chassis_new() {
chassis *chas;
if (0 != chassis_check_version(event_get_version(), _EVENT_VERSION)) {
g_critical("%s: chassis is build against libevent %s, but now runs against %s",
G_STRLOC, _EVENT_VERSION, event_get_version());
return NULL;
}
chas = g_new0(chassis, 1);
chas->modules = g_ptr_array_new();
chas->stats = chassis_stats_new();
/* create a new global timer info */
chassis_timestamps_global_init(NULL);
chas->threads = chassis_event_threads_new();
chas->event_hdr_version = g_strdup(_EVENT_VERSION);
chas->shutdown_hooks = chassis_shutdown_hooks_new();
return chas;
}
void CInitBase::Init(void)
{
m_pCfg = event_config_new();
if (NULL == m_pCfg)
{
Q_EXCEPTION(Q_RTN_FAILE, "%s", "event_config_new error.");
}
#ifdef Q_IOCP
evthread_use_windows_threads();
event_config_set_flag(m_pCfg, EVENT_BASE_FLAG_STARTUP_IOCP);
#endif
m_pBase = event_base_new_with_config(m_pCfg);
if (NULL == m_pBase)
{
Q_EXCEPTION(Q_RTN_FAILE, "%s", "event_base_new error.");
}
#ifdef Q_IOCP
Q_Printf("event version %s, using %s", event_get_version(), "IOCP");
#else
Q_Printf("event version %s, using %s", event_get_version(), event_base_get_method(m_pBase));
#endif
}
/**
* create a global context
*/
chassis *chassis_new() {
chassis *chas;
int i;
GTimeVal now;
if (0 != chassis_check_version(event_get_version(), _EVENT_VERSION)) {
g_critical("%s: chassis is build against libevent %s, but now runs against %s",
G_STRLOC, _EVENT_VERSION, event_get_version());
return NULL;
}
/* add by vinchen/CFR£¬init libevent to be thread_safe */
if (0 != chassis_libevent_init()){
g_critical("%s: chassis_libevent_init error, libevent version : %s",
G_STRLOC, event_get_version());
return NULL;
}
chas = g_new0(chassis, 1);
chas->modules = g_ptr_array_new();
chas->stats = chassis_stats_new();
/* create a new global timer info */
chassis_timestamps_global_init(NULL);
chas->threads = chassis_event_threads_new();
chas->event_hdr_version = g_strdup(_EVENT_VERSION);
chas->shutdown_hooks = chassis_shutdown_hooks_new();
/*
* Init for query_response_time
*/
for (i = 0; i < OVERALL_POWER_COUNT; i++){
chas->counter[i] = 0;
chas->total[i] = 0;
}
for (i = 0; i < OVERALL_POWER_COUNT; i++){
if (i < OVERALL_POWER_HALF)
/* 2^(-15) ~ 2^(-1) */
chas->time[i] = 1.00/(1 << (OVERALL_POWER_HALF - i)) * MILLION;
else
/* 2^0 ~ 2^15 */
chas->time[i] = (guint64)(1 << (i - OVERALL_POWER_HALF)) * MILLION;
}
g_get_current_time(&now);
chas->start_time = now;
chas->query_mutex = g_mutex_new();
return chas;
}
main() {
// daemon ( 1, 0 );
printf ( "%s\n", event_get_version() );
event_init();
int sock = socket( AF_INET, SOCK_STREAM, 0 );
(void) fcntl( sock, F_SETFD, 1 );
int i = 1;
if ( setsockopt( sock, SOL_SOCKET, SO_REUSEADDR, (void*) &i, sizeof(i) ) < 0 ) {
exit ( -1 );
}
struct sockaddr_in server_addr;
uint32_t ip;
inet_pton ( AF_INET, localhost, &ip );
server_addr.sin_addr.s_addr = ip;
server_addr.sin_port = htons ( localport );
server_addr.sin_family = AF_INET;
if ( bind( sock, (struct sockaddr*)&server_addr, sizeof(struct sockaddr) ) < 0 ) {
fprintf ( stderr, "bind\n" );
exit ( -1 );
}
if ( listen( sock, 1024 ) < 0 ) {
exit ( -1 );
}
struct event listen_read_event;
event_set ( &listen_read_event, sock, EV_READ|EV_PERSIST, listener_accept, NULL );
event_add ( &listen_read_event, NULL );
event_dispatch();
}
void
show_version(void)
{
struct utsname u;
const char *fmt = " %s: %s\n";
fprintf(stderr, "%s %s\n", __progname, vertag);
fprintf(stderr, "Run-time versions:\n");
fprintf(stderr, fmt, "assl", assl_verstring());
#ifdef NEED_LIBCLENS
fprintf(stderr, fmt, "clens", clens_verstring());
#endif /* NEED_LIBCLENS */
fprintf(stderr, fmt, "clog", clog_verstring());
fprintf(stderr, fmt, "curl", curl_version());
fprintf(stderr, fmt, "event", event_get_version());
fprintf(stderr, fmt, "exude", exude_verstring());
fprintf(stderr, fmt, "openssl", SSLeay_version(SSLEAY_VERSION));
fprintf(stderr, fmt, "shrink", shrink_verstring());
fprintf(stderr, fmt, "xmlsd", xmlsd_verstring());
fprintf(stderr, "O/S identification: ");
if (uname(&u) == -1)
fprintf(stderr, "INVALID\n");
else
fprintf(stderr, "%s-%s-%s %s\n", u.sysname, u.machine, u.release, u.version);
}
/** get the event system in use */
static void get_event_sys(const char** n, const char** s, const char** m)
{
#ifdef USE_WINSOCK
*n = "event";
*s = "winsock";
*m = "WSAWaitForMultipleEvents";
#elif defined(USE_MINI_EVENT)
*n = "mini-event";
*s = "internal";
*m = "select";
#else
struct event_base* b;
*s = event_get_version();
# ifdef HAVE_EVENT_BASE_GET_METHOD
*n = "libevent";
b = event_base_new();
*m = event_base_get_method(b);
# elif defined(HAVE_EV_LOOP) || defined(HAVE_EV_DEFAULT_LOOP)
*n = "libev";
b = (struct event_base*)ev_default_loop(EVFLAG_AUTO);
*m = ev_backend2str(ev_backend((struct ev_loop*)b));
# else
*n = "unknown";
*m = "not obtainable";
b = NULL;
# endif
# ifdef HAVE_EVENT_BASE_FREE
event_base_free(b);
# endif
#endif
}
int setupListeners()
{
evthread_use_pthreads();
evBase = event_base_new();
const char **methods = event_get_supported_methods();
lprintf("Starting Libevent %s. Supported methods are:\n",
event_get_version());
for (int i=0;methods[i] != NULL; i++){
lprintf("\t%s\n",methods[i]);
}
free((char**)methods);
lprintf("Using %s.\n",event_base_get_method(evBase));
struct event *signalEvent;
signalEvent = evsignal_new(evBase, SIGINT, signalCallback, (void*) evBase);
if (!signalEvent || event_add(signalEvent, NULL) < 0){
lprintf("Could not create / add a signal event!\n");
return -1;
}
lprintf("done\n");
try{
contConnection = new ControllerLink();
mtc = new MTCModel();
for (int i=0;i<MAX_XL3_CON;i++){
xl3s[i] = new XL3Model(i);
}
tubii = new TUBIIModel();
}
catch(int e){
return -1;
}
return 0;
}
static void
levent_init(struct lldpd *cfg)
{
/* Setup libevent */
log_debug("event", "initialize libevent");
event_set_log_callback(levent_log_cb);
if (!(cfg->g_base = event_base_new()))
fatalx("unable to create a new libevent base");
log_info("event", "libevent %s initialized with %s method",
event_get_version(),
event_base_get_method(cfg->g_base));
/* Setup SNMP */
#ifdef USE_SNMP
if (cfg->g_snmp) {
agent_init(cfg, cfg->g_snmp_agentx);
cfg->g_snmp_timeout = evtimer_new(cfg->g_base,
levent_snmp_timeout,
cfg);
if (!cfg->g_snmp_timeout)
fatalx("unable to setup timeout function for SNMP");
if ((cfg->g_snmp_fds =
malloc(sizeof(struct ev_l))) == NULL)
fatalx("unable to allocate memory for SNMP events");
TAILQ_INIT(levent_snmp_fds(cfg));
}
#endif
/* Setup loop that will run every X seconds. */
log_debug("event", "register loop timer");
if (!(cfg->g_main_loop = event_new(cfg->g_base, -1, 0,
levent_update_and_send,
cfg)))
fatalx("unable to setup main timer");
event_active(cfg->g_main_loop, EV_TIMEOUT, 1);
/* Setup unix socket */
log_debug("event", "register Unix socket");
TAILQ_INIT(&lldpd_clients);
evutil_make_socket_nonblocking(cfg->g_ctl);
if ((cfg->g_ctl_event = event_new(cfg->g_base, cfg->g_ctl,
EV_READ|EV_PERSIST, levent_ctl_accept, cfg)) == NULL)
fatalx("unable to setup control socket event");
event_add(cfg->g_ctl_event, NULL);
/* Signals */
log_debug("event", "register signals");
signal(SIGHUP, SIG_IGN);
evsignal_add(evsignal_new(cfg->g_base, SIGUSR1,
levent_dump, cfg->g_base),
NULL);
evsignal_add(evsignal_new(cfg->g_base, SIGINT,
levent_stop, cfg->g_base),
NULL);
evsignal_add(evsignal_new(cfg->g_base, SIGTERM,
levent_stop, cfg->g_base),
NULL);
}
static void print_version(void)
{
fprintf(stdout, "ucmq :\n");
fprintf(stdout, "\tversion - v%s\n", VERSION);
fprintf(stdout, "\tstorage mode - file\n");
fprintf(stdout, "\tbuild date - %s %s\n", __DATE__, __TIME__);
fprintf(stdout, "dependency packages :\n");
fprintf(stdout, "\tlibevent - v%s\n", event_get_version());
}
/** Return a string representation of the version of the currently running
* version of Libevent. */
const char *
tor_libevent_get_version_str(void)
{
#ifdef HAVE_EVENT_GET_VERSION
return event_get_version();
#else
return "pre-1.0c";
#endif
}
/** Return the version number of the currently running version of Libevent.
* See le_version_t for info on the format.
*/
static le_version_t
tor_get_libevent_version(const char **v_out)
{
const char *v;
le_version_t r;
#if defined(HAVE_EVENT_GET_VERSION_NUMBER)
v = event_get_version();
r = event_get_version_number();
#elif defined (HAVE_EVENT_GET_VERSION)
v = event_get_version();
r = tor_decode_libevent_version(v);
#else
v = "pre-1.0c";
r = LE_OLD;
#endif
if (v_out)
*v_out = v;
return r;
}
options::STATUS options::process_command_line(int argc, char *argv[])
{
namespace po = boost::program_options;
po::options_description desc("Allowed options");
desc.add_options()
("help", "display help message")
("version", "display sfrp version and exit")
("fullversion", "display sfrp and libevent version and exit")
("copyright", "display copyright and exit")
("file,f", po::value<std::string>(), "configuration file");
try{
po::variables_map vm;
po::store(po::parse_command_line(argc, argv, desc), vm);
po::notify(vm);
if(vm.count("version")){
std::cout<<SFRP_VERSION<<std::endl;
return INFO;
}
if(vm.count("fullversion")){
std::cout<<"sfrp version: "<<SFRP_VERSION<<"_"<<std::endl;
std::cout<<"libevent version: "<<event_get_version()<<std::endl;
return INFO;
}
//
// Don't print the copyright when showing the version
print_short_copyright();
if(vm.count("help")) {
std::cout<<desc<<std::endl;
return INFO;
}
if(vm.count("copyright")){
print_copyright();
return INFO;
}
if(vm.count("file")) {
config_file_ = vm["file"].as<std::string>();
}
}
catch(po::error e){
std::cout<<e.what()<<std::endl<<std::endl;
std::cout<<desc<<std::endl;
return ERROR;
}
return RUN;
}
int chassis_frontend_print_version() {
/* allow to pass down a build-tag at build-time which gets hard-coded into the binary */
#ifndef CHASSIS_BUILD_TAG
#define CHASSIS_BUILD_TAG PACKAGE_STRING
#endif
g_print(" chassis: %s" CHASSIS_NEWLINE, CHASSIS_BUILD_TAG);
g_print(" glib2: %d.%d.%d" CHASSIS_NEWLINE, GLIB_MAJOR_VERSION, GLIB_MINOR_VERSION, GLIB_MICRO_VERSION);
g_print(" libevent: %s" CHASSIS_NEWLINE, event_get_version());
return 0;
}
/**
* create a global context
*/
chassis *chassis_new() {
chassis *chas;
gint ret = 0;
if (0 != chassis_check_version(event_get_version(), _EVENT_VERSION)) {
g_critical("%s: chassis is build against libevent %s, but now runs against %s",
G_STRLOC, _EVENT_VERSION, event_get_version());
return NULL;
}
chas = g_new0(chassis, 1);
chas->modules = g_ptr_array_new();
chas->stats = chassis_stats_new();
/* create a new global timer info */
chassis_timestamps_global_init(NULL);
chas->threads = g_ptr_array_new();
chas->event_hdr_version = g_strdup(_EVENT_VERSION);
chas->shutdown_hooks = chassis_shutdown_hooks_new();
chas->proxy_filter = sql_filter_new(0);
chas->proxy_reserved = sql_reserved_query_new();
chas->daemon_mode = 0;
chas->max_files_number = 0;
chas->auto_restart = 0;
chas->opts = NULL;//need to free
if (0 != ret) {
g_critical("create thread exit semphore failed. %s", G_STRLOC);
return NULL;
}
return chas;
}
struct tmuxproc *
proc_start(const char *name, struct event_base *base, int forkflag,
void (*signalcb)(int))
{
struct tmuxproc *tp;
struct utsname u;
#ifdef TMATE_SLAVE
if (forkflag)
fatal("can't fork");
#else
if (forkflag) {
switch (fork()) {
case -1:
fatal("fork failed");
case 0:
break;
default:
return (NULL);
}
if (daemon(1, 0) != 0)
fatal("daemon failed");
clear_signals(0);
if (event_reinit(base) != 0)
fatalx("event_reinit failed");
}
log_open(name);
#endif
#ifdef HAVE_SETPROCTITLE
setproctitle("%s (%s)", name, socket_path);
#endif
if (uname(&u) < 0)
memset(&u, 0, sizeof u);
log_debug("%s started (%ld): socket %s, protocol %d", name,
(long)getpid(), socket_path, PROTOCOL_VERSION);
log_debug("on %s %s %s; libevent %s (%s)", u.sysname, u.release,
u.version, event_get_version(), event_get_method());
tp = xcalloc(1, sizeof *tp);
tp->name = xstrdup(name);
#ifndef TMATE_SLAVE
tp->signalcb = signalcb;
set_signals(proc_signal_cb, tp);
#endif
return (tp);
}
static void display_libevent_info( void )
{
int i;
const char **methods = event_get_supported_methods();
if ( NULL == methods ) {
ED2KD_LOGERR("failed to get supported libevent methods");
return;
}
ED2KD_LOGNFO("using libevent %s. available methods are:", event_get_version());
for ( i=0; methods[i] != NULL; ++i ) {
ED2KD_LOGNFO(" %s", methods[i]);
}
}
/** Initialize the Libevent library and set up the event base. */
void
tor_libevent_initialize(void)
{
tor_assert(the_event_base == NULL);
#ifdef __APPLE__
if (MACOSX_KQUEUE_IS_BROKEN ||
tor_get_libevent_version(NULL) < V_OLD(1,1,'b')) {
setenv("EVENT_NOKQUEUE","1",1);
}
#endif
#ifdef HAVE_EVENT2_EVENT_H
{
struct event_config *cfg = event_config_new();
tor_assert(cfg);
/* In 0.2.2, we don't use locking at all. Telling Libevent not to try to
* turn it on can avoid a needless socketpair() attempt.
*/
event_config_set_flag(cfg, EVENT_BASE_FLAG_NOLOCK);
the_event_base = event_base_new_with_config(cfg);
event_config_free(cfg);
}
#else
the_event_base = event_init();
#endif
if (!the_event_base) {
log_err(LD_GENERAL, "Unable to initialize Libevent: cannot continue.");
exit(1);
}
#if defined(HAVE_EVENT_GET_VERSION) && defined(HAVE_EVENT_GET_METHOD)
/* Making this a NOTICE for now so we can link bugs to a libevent versions
* or methods better. */
log(LOG_NOTICE, LD_GENERAL,
"Initialized libevent version %s using method %s. Good.",
event_get_version(), tor_libevent_get_method());
#else
log(LOG_NOTICE, LD_GENERAL,
"Initialized old libevent (version 1.0b or earlier).");
log(LOG_WARN, LD_GENERAL,
"You have a *VERY* old version of libevent. It is likely to be buggy; "
"please build Tor with a more recent version.");
#endif
}
/*
add by vinchen/CFR
libevent to be thread_safe
https://raw.github.com/libevent/libevent/patches-2.0/whatsnew-2.0.txt
*/
int chassis_libevent_init()
{
int ret;
#ifdef WIN32
ret = evthread_use_windows_threads();
#else
ret = evthread_use_pthreads();
#endif
#ifdef _VINCHEN_TEST
g_message("libevent version is %s\n", event_get_version());
#endif // _VINCHEN_TEST
return ret;
}
/*
* Print version information to stderr.
*/
static void
main_version(void)
{
fprintf(stderr, "%s %s (built %s)\n", PNAME, version, build_date);
fprintf(stderr, "Copyright (c) 2009-2012, "
"Daniel Roethlisberger <*****@*****.**>\n");
fprintf(stderr, "http://www.roe.ch/SSLsplit\n");
if (features[0]) {
fprintf(stderr, "Features: %s\n", features);
}
nat_version();
ssl_openssl_version();
fprintf(stderr, "compiled against libevent %s\n", LIBEVENT_VERSION);
fprintf(stderr, "rtlinked against libevent %s\n", event_get_version());
fprintf(stderr, "%d CPU cores detected\n", sys_get_cpu_cores());
}
int
libevent_version_ok(void)
{
ev_uint32_t v_compile_maj;
ev_uint32_t v_run_maj;
v_compile_maj = LIBEVENT_VERSION_NUMBER & 0xffff0000;
v_run_maj = event_get_version_number() & 0xffff0000;
if (v_compile_maj != v_run_maj) {
fprintf(stderr,
"Incompatible libevent versions: have %s, built with %s\n",
event_get_version(),
LIBEVENT_VERSION);
return 0;
}
return 1;
}
int
main(int argc, char **argv)
{
struct event ev;
struct event *t1;
event_enable_debug_mode();
fprintf(stderr, "Libevent %s\n", event_get_version());
fflush(stderr);
if (!(base = event_base_new()))
die("event_base_new");
if (event_base_priority_init(base, 8) < 0)
die("event_base_priority_init");
if (event_assign(&ev, base, SIGTERM, EV_SIGNAL|EV_PERSIST, cbfunc, NULL)<0)
die("event_assign");
if (event_priority_set(&ev, SIGPRI) < 0)
die("event_priority_set");
if (event_add(&ev, NULL) < 0)
die("event_add");
fprintf(stderr, "SIGNAL EVENT DEFINED\n");
fflush(stderr);
t1 = (struct event*)malloc(sizeof(struct event));
if (event_assign(t1, base, -1, EV_WRITE, t1func, t1) < 0) {
die("event_assign_term");
}
if (event_priority_set(t1, TERMPRI) < 0) {
die("event_priority_set_term");
}
event_active(t1, EV_WRITE, 1);
fprintf(stderr, "FIRST TERMINATION EVENT DEFINED\n");
fflush(stderr);
/* event_dispatch(base); */
while (run) {
event_base_loop(base, EVLOOP_ONCE);
}
fprintf(stderr, "EXITED LOOP - FREEING BASE\n");
fflush(stderr);
event_base_free(base);
return 0;
}
/** Initialize the Libevent library and set up the event base. */
void
tor_libevent_initialize(tor_libevent_cfg *torcfg)
{
tor_assert(the_event_base == NULL);
/* some paths below don't use torcfg, so avoid unused variable warnings */
(void)torcfg;
{
int attempts = 0;
struct event_config *cfg;
++attempts;
cfg = event_config_new();
tor_assert(cfg);
/* Telling Libevent not to try to turn locking on can avoid a needless
* socketpair() attempt. */
event_config_set_flag(cfg, EVENT_BASE_FLAG_NOLOCK);
if (torcfg->num_cpus > 0)
event_config_set_num_cpus_hint(cfg, torcfg->num_cpus);
/* We can enable changelist support with epoll, since we don't give
* Libevent any dup'd fds. This lets us avoid some syscalls. */
event_config_set_flag(cfg, EVENT_BASE_FLAG_EPOLL_USE_CHANGELIST);
the_event_base = event_base_new_with_config(cfg);
event_config_free(cfg);
}
if (!the_event_base) {
/* LCOV_EXCL_START */
log_err(LD_GENERAL, "Unable to initialize Libevent: cannot continue.");
exit(1); // exit ok: libevent is broken.
/* LCOV_EXCL_STOP */
}
log_info(LD_GENERAL,
"Initialized libevent version %s using method %s. Good.",
event_get_version(), tor_libevent_get_method());
}
void
ub_get_event_sys(struct ub_event_base* base, const char** n, const char** s,
const char** m)
{
#ifdef USE_WINSOCK
(void)base;
*n = "event";
*s = "winsock";
*m = "WSAWaitForMultipleEvents";
#elif defined(USE_MINI_EVENT)
(void)base;
*n = "mini-event";
*s = "internal";
*m = "select";
#else
struct event_base* b = AS_EVENT_BASE(base);
*s = event_get_version();
# if defined(HAVE_EV_LOOP) || defined(HAVE_EV_DEFAULT_LOOP)
*n = "libev";
if (!b)
b = (struct event_base*)ev_default_loop(EVFLAG_AUTO);
# ifdef EVBACKEND_SELECT
*m = ub_ev_backend2str(ev_backend((struct ev_loop*)b));
# else
*m = "not obtainable";
# endif
# elif defined(HAVE_EVENT_BASE_GET_METHOD)
*n = "libevent";
if (!b)
b = event_base_new();
*m = event_base_get_method(b);
# else
*n = "unknown";
*m = "not obtainable";
(void)b;
# endif
# ifdef HAVE_EVENT_BASE_FREE
if (b && b != AS_EVENT_BASE(base))
event_base_free(b);
# endif
#endif
}
int _tmain(int argc, _TCHAR* argv[])
{
//
#ifdef WIN32
WSADATA wsa_data;
WSAStartup(0x0202, &wsa_data);
#endif
MediaCreateSdp::GetInstance("\\test.h264");
struct sockaddr_in sa;
memset(&sa, 0, sizeof(sa));
sa.sin_family = AF_INET;
sa.sin_port = htons(1000);
sa.sin_addr.s_addr = htonl(0);
const char* ver = event_get_version();
printf("%s\n", ver);
Network* work = new Network(sa);
work->NetPrepare(TCP);
work->StartServer(MediaSession::Recv, MediaSession::Send);
//_CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF|_CRTDBG_LEAK_CHECK_DF);
return 0;
}
struct tmuxproc *
proc_start(const char *name)
{
struct tmuxproc *tp;
struct utsname u;
log_open(name);
setproctitle("%s (%s)", name, socket_path);
if (uname(&u) < 0)
memset(&u, 0, sizeof u);
log_debug("%s started (%ld): version %s, socket %s, protocol %d", name,
(long)getpid(), VERSION, socket_path, PROTOCOL_VERSION);
log_debug("on %s %s %s; libevent %s (%s)", u.sysname, u.release,
u.version, event_get_version(), event_get_method());
tp = xcalloc(1, sizeof *tp);
tp->name = xstrdup(name);
return (tp);
}
/**
* create a global context
*/
chassis *chassis_new() {
chassis *chas;
if (0 != chassis_check_version(event_get_version(), _EVENT_VERSION)) {
g_log_dbproxy(g_critical, "chassis is build against libevent %s, but now runs against %s", _EVENT_VERSION, event_get_version());
return NULL;
}
chas = g_new0(chassis, 1);
chas->modules = g_ptr_array_new();
chas->stats = chassis_stats_new();
/* create a new global timer info */
chassis_timestamps_global_init(NULL);
chas->threads = g_ptr_array_new();
chas->event_hdr_version = g_strdup(_EVENT_VERSION);
chas->shutdown_hooks = chassis_shutdown_hooks_new();
chas->proxy_filter = sql_filter_new(0);
chas->proxy_reserved = sql_reserved_query_new();
chas->daemon_mode = 0;
chas->max_files_number = 0;
chas->auto_restart = 0;
chas->opts = NULL;//need to free
chas->db_connect_timeout = 3.0;//default timeout 3.0s
return chas;
}
void TNonblockingIOThread::run() {
threadId_ = Thread::get_current();
assert(eventBase_ == 0);
eventBase_ = event_base_new();
// Print some libevent stats
if (number_ == 0) {
GlobalOutput.printf("TNonblockingServer: using libevent %s method %s",
event_get_version(),
event_base_get_method(eventBase_));
}
registerEvents();
GlobalOutput.printf("TNonblockingServer: IO thread #%d entering loop...",
number_);
if (useHighPriority_) {
setCurrentThreadHighPriority(true);
}
// Run libevent engine, never returns, invokes calls to eventHandler
event_base_loop(eventBase_, 0);
if (useHighPriority_) {
setCurrentThreadHighPriority(false);
}
// cleans up our registered events
cleanupEvents();
GlobalOutput.printf("TNonblockingServer: IO thread #%d run() done!",
number_);
}
void
internal_parc_initializeLibevent(void)
{
if (_libeventInitialized) {
return;
}
_libeventInitialized = 1;
// 0x AA BB CC XX
// AA = major
// BB = minor
// CC = patchlevel
//
uint32_t version = event_get_version_number();
trapIllegalValueIf(version < 0x02001000UL,
"Libevent version must be at least 2.0.16, got %s",
event_get_version());
// Make sure libevent uses our memory allocator.
// Libevent allocates an internal object the first time a base is allocated
// that it never releases. In order to ensure our outstanding memory counters
// start at zero we trigger this allocation before interposing our memory allocator.
//
// Create a scheduler event base, an event, then free both of them.
//
struct event_base *evbase = event_base_new();
assertNotNull(evbase, "Libevent event_base_new returned NULL");
struct event *event = event_new(evbase, -1, 0, NULL, NULL);
assertNotNull(event, "Libevent event_new returned NULL");
event_del(event);
event_base_free(evbase);
event_set_mem_functions(internal_parc_alloc,
internal_parc_realloc,
internal_parc_free);
}
bool BnxDriver::ParseArgs(int argc, char *argv[]) {
int c;
while ((c = getopt(argc, argv, "c:hv")) != -1) {
switch (c) {
case 'c':
SetConfigFile(optarg);
break;
case 'v':
BnxOutStream << BnxBot::GetVersionString() << "\n\n";
BnxOutStream << "libevent: " << event_get_version() << '\n';
#ifdef USE_PCRE
BnxOutStream << "pcre: " << pcre_version() << BnxEndl;
#endif // USE_PCRE
return false;
case 'h':
default:
Usage();
return false;
}
}
return true;
}
/**
* free the global scope
*
* closes all open connections, cleans up all plugins
*
* @param chas global context
*/
void chassis_free(chassis *chas) {
guint i;
#ifdef HAVE_EVENT_BASE_FREE
const char *version;
#endif
if (!chas) return;
/* call the destructor for all plugins */
for (i = 0; i < chas->modules->len; i++) {
chassis_plugin *p = chas->modules->pdata[i];
g_assert(p->destroy);
p->destroy(p->config);
}
chassis_shutdown_hooks_call(chas->shutdown_hooks); /* cleanup the global 3rd party stuff before we unload the modules */
for (i = 0; i < chas->modules->len; i++) {
chassis_plugin *p = chas->modules->pdata[i];
chassis_plugin_free(p);
}
g_ptr_array_free(chas->modules, TRUE);
if (chas->base_dir) g_free(chas->base_dir);
if (chas->log_path) g_free(chas->log_path);
if (chas->user) g_free(chas->user);
if (chas->stats) chassis_stats_free(chas->stats);
chassis_timestamps_global_free(NULL);
GPtrArray *threads = chas->threads;
if (threads) {
for (i = 0; i < threads->len; ++i) {
chassis_event_thread_free(threads->pdata[i]);
}
g_ptr_array_free(threads, TRUE);
}
if (chas->instance_name) g_free(chas->instance_name);
#ifdef HAVE_EVENT_BASE_FREE
/* only recent versions have this call */
version = event_get_version();
/* libevent < 1.3e doesn't cleanup its own fds from the event-queue in signal_init()
* calling event_base_free() would cause a assert() on shutdown
*/
if (version && (strcmp(version, "1.3e") >= 0)) {
if (chas->event_base) event_base_free(chas->event_base);
}
#endif
g_free(chas->event_hdr_version);
chassis_shutdown_hooks_free(chas->shutdown_hooks);
lua_scope_free(chas->sc);
network_backends_free(chas->backends);
if (chas->proxy_filter != NULL) { sql_filter_free(chas->proxy_filter); }
if (chas->proxy_reserved != NULL) { sql_reserved_query_free(chas->proxy_reserved); }
g_free(chas);
}
