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
}
int main(int argc, char* argv[]) {
#ifdef _WIN32
WORD wVersionRequested;
WSADATA wsaData;
wVersionRequested = MAKEWORD(2, 2);
WSAStartup(wVersionRequested, &wsaData);
evthread_use_windows_threads();
#else
evthread_use_pthreads();
#endif //_WIN32
ygo::Game _game;
ygo::mainGame = &_game;
if(!ygo::mainGame->Initialize())
return 0;
for(int i = 1; i < argc; ++i) {
/*command line args:
* -j: join host (host info from system.conf)
* -d: deck edit
* -r: replay */
if(argv[i][0] == '-' && argv[i][1] == 'e') {
ygo::dataManager.LoadDB(&argv[i][2]);
} else if(!strcmp(argv[i], "-j") || !strcmp(argv[i], "-d") || !strcmp(argv[i], "-r") || !strcmp(argv[i], "-s")) {
exit_on_return = true;
irr::SEvent event;
event.EventType = irr::EET_GUI_EVENT;
event.GUIEvent.EventType = irr::gui::EGET_BUTTON_CLICKED;
if(!strcmp(argv[i], "-j")) {
event.GUIEvent.Caller = ygo::mainGame->btnLanMode;
ygo::mainGame->device->postEventFromUser(event);
//TODO: wait for wLanWindow show. if network connection faster than wLanWindow, wLanWindow will still show on duel scene.
event.GUIEvent.Caller = ygo::mainGame->btnJoinHost;
ygo::mainGame->device->postEventFromUser(event);
} else if(!strcmp(argv[i], "-d")) {
event.GUIEvent.Caller = ygo::mainGame->btnDeckEdit;
ygo::mainGame->device->postEventFromUser(event);
} else if(!strcmp(argv[i], "-r")) {
event.GUIEvent.Caller = ygo::mainGame->btnReplayMode;
ygo::mainGame->device->postEventFromUser(event);
ygo::mainGame->lstReplayList->setSelected(0);
event.GUIEvent.Caller = ygo::mainGame->btnLoadReplay;
ygo::mainGame->device->postEventFromUser(event);
} else if(!strcmp(argv[i], "-s")) {
event.GUIEvent.Caller = ygo::mainGame->btnServerMode;
ygo::mainGame->device->postEventFromUser(event);
ygo::mainGame->lstSinglePlayList->setSelected(0);
event.GUIEvent.Caller = ygo::mainGame->btnLoadSinglePlay;
ygo::mainGame->device->postEventFromUser(event);
}
}
}
ygo::mainGame->MainLoop();
#ifdef _WIN32
WSACleanup();
#else
#endif //_WIN32
return EXIT_SUCCESS;
}
void EventLoop::initialize()
{
// We need to initialize Libevent differently depending on the
// operating system threading support.
#if defined(EVTHREAD_USE_PTHREADS_IMPLEMENTED)
if (evthread_use_pthreads() < 0) {
LOG(FATAL) << "Failed to initialize, evthread_use_pthreads";
}
#elif defined(EVTHREAD_USE_WINDOWS_THREADS_IMPLEMENTED)
if (evthread_use_windows_threads() < 0) {
LOG(FATAL) << "Failed to initialize, evthread_use_windows_threads";
}
#else
#error "Libevent must be compiled with either pthread or Windows thread support"
#endif
// This enables debugging of libevent calls. We can remove this
// when the implementation settles and after we gain confidence.
event_enable_debug_mode();
// TODO(jmlvanre): Allow support for 'epoll' once SSL related
// issues are resolved.
struct event_config* config = event_config_new();
event_config_avoid_method(config, "epoll");
base = event_base_new_with_config(config);
if (base == NULL) {
LOG(FATAL) << "Failed to initialize, event_base_new";
}
}
void initLibraries()
{
#ifdef _DEBUG
event_enable_debug_mode(); // may cause memory leak
#endif
event_set_fatal_callback(libeventError);
#ifdef _WIN32
#ifdef MEM_DEBUG
_CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF);
#endif
WSADATA data;
int err = WSAStartup(0, &data);
err = WSAStartup(data.wVersion, &data);
assert(err == 0);
#endif
#ifdef EVTHREAD_USE_WINDOWS_THREADS_IMPLEMENTED
evthread_use_windows_threads(); // may cause memory leak
#endif
#ifdef EVTHREAD_USE_PTHREADS_IMPLEMENTED
evthread_use_pthreads();
#endif
srand(static_cast<unsigned int>(time(NULL))); // stdlib :)
}
int main(int argc, const char** argv)
{
#ifdef WIN32
WSADATA WSAData;
WSAStartup(0x101, &WSAData);
#endif
evthread_use_windows_threads();
//event_enable_debug_mode();
//event_set_log_callback(libevent_log_cb);
ev_base = event_base_new();
#if 0
ev_timer = evtimer_new(ev_base, timer_cb, NULL);
struct timeval time;
time.tv_sec = 0;
time.tv_usec = 10*1000;
evtimer_add(ev_timer, &time);
#endif
evhttp = evh_client_init(ev_base);
evh_client_setopt(evhttp, EVHTTP_CLIENT_DEBUG, evhttp_log_cb);
evh_client_get(evhttp, "www.baidu.com", url_cb, NULL);
evh_client_get(evhttp, "www.163.com", url_cb, NULL);
event_base_dispatch(ev_base);
evh_client_release(evhttp);
return 0;
}
void TcpListener::Start(
std::function<void (bool success)> searchListenPortFinishedNotify)
{
canceled_ = false;
evthread_use_windows_threads();
event_set_log_callback(EventLogCallback);
base_ = event_base_new();
if (base_)
{
unsigned short port = ntohs(addr_.sin_port);
while ((listener_ = evconnlistener_new_bind(base_, OnAcceptCallabck,
this, LEV_OPT_CLOSE_ON_FREE |
LEV_OPT_LEAVE_SOCKETS_BLOCKING | LEV_OPT_CLOSE_ON_EXEC,
-1, (sockaddr*)&addr_, sizeof(addr_))) == nullptr)
{
addr_.sin_port = htons(++port);
Sleep(50);
if (canceled_)
return;
}
if (searchListenPortFinishedNotify)
searchListenPortFinishedNotify(true);
if (canceled_)
return;
event_base_dispatch(base_);
}
else
{
if (searchListenPortFinishedNotify)
searchListenPortFinishedNotify(false);
}
}
core::curl_handler::curl_handler()
{
#ifdef _WIN32
evthread_use_windows_threads();
#else
evthread_use_pthreads();
#endif
}
bool InitHTTPServer()
{
if (!InitHTTPAllowList())
return false;
if (gArgs.GetBoolArg("-rpcssl", false)) {
uiInterface.ThreadSafeMessageBox(
"SSL mode for RPC (-rpcssl) is no longer supported.",
"", CClientUIInterface::MSG_ERROR);
return false;
}
// Redirect libevent's logging to our own log
event_set_log_callback(&libevent_log_cb);
// Update libevent's log handling. Returns false if our version of
// libevent doesn't support debug logging, in which case we should
// clear the BCLog::LIBEVENT flag.
if (!UpdateHTTPServerLogging(g_logger->WillLogCategory(BCLog::LIBEVENT))) {
g_logger->DisableCategory(BCLog::LIBEVENT);
}
#ifdef WIN32
evthread_use_windows_threads();
#else
evthread_use_pthreads();
#endif
raii_event_base base_ctr = obtain_event_base();
/* Create a new evhttp object to handle requests. */
raii_evhttp http_ctr = obtain_evhttp(base_ctr.get());
struct evhttp* http = http_ctr.get();
if (!http) {
LogPrintf("couldn't create evhttp. Exiting.\n");
return false;
}
evhttp_set_timeout(http, gArgs.GetArg("-rpcservertimeout", DEFAULT_HTTP_SERVER_TIMEOUT));
evhttp_set_max_headers_size(http, MAX_HEADERS_SIZE);
evhttp_set_max_body_size(http, MAX_SIZE);
evhttp_set_gencb(http, http_request_cb, nullptr);
if (!HTTPBindAddresses(http)) {
LogPrintf("Unable to bind any endpoint for RPC server\n");
return false;
}
LogPrint(BCLog::HTTP, "Initialized HTTP server\n");
int workQueueDepth = std::max((long)gArgs.GetArg("-rpcworkqueue", DEFAULT_HTTP_WORKQUEUE), 1L);
LogPrintf("HTTP: creating work queue of depth %d\n", workQueueDepth);
workQueue = new WorkQueue<HTTPClosure>(workQueueDepth);
// transfer ownership to eventBase/HTTP via .release()
eventBase = base_ctr.release();
eventHTTP = http_ctr.release();
return true;
}
DelayedEventQueue::DelayedEventQueue() {
#ifndef _WIN32
evthread_use_pthreads();
#else
evthread_use_windows_threads();
#endif
_eventLoop = event_base_new();
_thread = NULL;
_isStarted = false;
}
void Loop::init()
{
#if (defined _WIN32) || (defined WIN32) || (defined _WIN64) || (defined WIN64)
WSADATA wsadata;
WSAStartup(MAKEWORD(2, 2), &wsadata);
evthread_use_windows_threads();
#else
evthread_use_pthreads();
#endif//_WIN32
}
//<!************************************************************************
TcpTransport::TcpTransport(TcpRemotingClient *pTcpRemointClient,
READ_CALLBACK handle /* = NULL */)
: m_tcpConnectStatus(e_connectInit),
m_ReadDatathread(NULL),
m_readcallback(handle),
m_tcpRemotingClient(pTcpRemointClient) {
m_startTime = UtilAll::currentTimeMillis();
#ifdef WIN32
evthread_use_windows_threads();
#else
evthread_use_pthreads();
#endif
m_eventBase = NULL;
m_bufferEvent = NULL;
}
LibEventInit::LibEventInit()
{
event_set_log_callback(my_libevent_log_cb);
#ifdef OS_WIN
evthread_use_windows_threads();
#else
evthread_use_pthreads();
#endif
evdns_set_log_fn(logfn);
if (CONFIG->enableEventDebug){
MYDEBUG("enable libevent debug");
event_enable_debug_mode();
}
}
void StartTorControl()
{
assert(!gBase);
#ifdef WIN32
evthread_use_windows_threads();
#else
evthread_use_pthreads();
#endif
gBase = event_base_new();
if (!gBase) {
LogPrintf("tor: Unable to create event_base\n");
return;
}
torControlThread = std::thread(std::bind(&TraceThread<void (*)()>, "torcontrol", &TorControlThread));
}
/*
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;
}
void StartTorControl(boost::thread_group& threadGroup, CScheduler& scheduler)
{
assert(!base);
#ifdef WIN32
evthread_use_windows_threads();
#else
evthread_use_pthreads();
#endif
base = event_base_new();
if (!base) {
LogPrintf("tor: Unable to create event_base\n");
return;
}
torControlThread = boost::thread(boost::bind(&TraceThread<void (*)()>, "torcontrol", &TorControlThread));
}
JtEventServer::JtEventServer() : base(NULL), m_Started(0)
{
#if (defined(WIN32) || defined(WIN64))
WSADATA wsa_data;
WSAStartup(0x0201, &wsa_data);
evthread_use_windows_threads();
tid = INVALID_HANDLE_VALUE;
#else
evthread_use_pthreads();
tid = -1;
#endif
pEventPairPipe = NULL;
m_Started = 0;
InHandling = 0;
}
void General::initThreads()
{
if ( s_initThreads )
{
return;
}
s_initThreads = true;
#ifdef WIN32
evthread_use_windows_threads();
#else
evthread_use_pthreads();
#endif
//event_enable_debug_logging(EVENT_DBG_ALL);
}
void cNetworkSingleton::Initialise(void)
{
// Start the lookup thread
m_LookupThread.Start();
// Windows: initialize networking:
#ifdef _WIN32
WSADATA wsaData;
memset(&wsaData, 0, sizeof(wsaData));
int res = WSAStartup (MAKEWORD(2, 2), &wsaData);
if (res != 0)
{
int err = WSAGetLastError();
LOGWARNING("WSAStartup failed: %d, WSAGLE = %d (%s)", res, err, evutil_socket_error_to_string(err));
exit(1);
}
#endif // _WIN32
// Initialize LibEvent logging:
event_set_log_callback(LogCallback);
// Initialize threading:
#if defined(EVTHREAD_USE_WINDOWS_THREADS_IMPLEMENTED)
evthread_use_windows_threads();
#elif defined(EVTHREAD_USE_PTHREADS_IMPLEMENTED)
evthread_use_pthreads();
#else
#error No threading implemented for EVTHREAD
#endif
// Create the main event_base:
m_EventBase = event_base_new();
if (m_EventBase == nullptr)
{
LOGERROR("Failed to initialize LibEvent. The server will now terminate.");
abort();
}
// Create the event loop thread:
m_HasTerminated = false;
m_EventLoopThread = std::thread(RunEventLoop, this);
m_StartupEvent.Wait(); // Wait for the LibEvent loop to actually start running (otherwise calling Terminate too soon would hang, see #3228)
}
void* TcpClient::ConnectThread(void *pParam)
{
TcpClient *pClient = (TcpClient *)pParam;
struct sockaddr_in sin;
sin.sin_family = AF_INET;
inet_pton(AF_INET, pClient->m_cIPAddr, (void*)&sin.sin_addr);
sin.sin_port = htons(pClient->m_nPort);
int nCycle = 15;
while (pClient->m_bConnecting)
{
if (nCycle < 15)
{
nCycle++;
Sleep(1000);
continue;
}
Tprintf(L"Connecting\n");
nCycle = 0;
struct event_base *base = event_base_new();
assert(base != NULL);
#if defined (WIN32)
evthread_use_windows_threads();
#else
evthread_use_pthreads();
#endif
evthread_make_base_notifiable(base);
struct bufferevent *bev = bufferevent_socket_new(base, -1, BEV_OPT_CLOSE_ON_FREE | BEV_OPT_THREADSAFE);
bufferevent_setcb(bev, read_cb, NULL, event_cb, pClient);
bufferevent_enable(bev, EV_READ | EV_WRITE | EV_PERSIST);
//连接
if (bufferevent_socket_connect(bev, (SOCKADDR*)&sin, sizeof(SOCKADDR)) < 0)
{
bufferevent_free(bev);
return NULL;
}
event_base_dispatch(base);
event_base_free(base);
}
return NULL;
}
int CXtReactor::IocpInit(void)
{
if ( m_pEvtBaseCfg == NULL )
{
new_event_base_cfg;
if ( m_pEvtBaseCfg == NULL )
{
return XT_REACT_ERR_MEM_FAIL;
}
}
evthread_use_windows_threads();
event_config_set_flag( m_pEvtBaseCfg, EVENT_BASE_FLAG_STARTUP_IOCP );
m_pEvtBase = event_base_new_with_config(m_pEvtBaseCfg);
event_config_free(m_pEvtBaseCfg);
return FUN_RET_OK;
}
BasicDelayedEventQueue::BasicDelayedEventQueue(DelayedEventQueueCallbacks* callbacks) {
_callbacks = callbacks;
#ifndef _WIN32
evthread_use_pthreads();
#else
evthread_use_windows_threads();
#endif
_eventLoop = event_base_new();
// see here: https://github.com/named-data/ndn.cxx/blob/master/scheduler/scheduler.cc
// and here: https://www.mail-archive.com/[email protected]/msg01676.html
timeval tv;
tv.tv_sec = 365 * 24 * 3600;
tv.tv_usec = 0;
_dummyEvent = evtimer_new(_eventLoop, dummyCallback, &_dummyEvent);
evtimer_add(_dummyEvent, &tv);
_thread = NULL;
_isStarted = false;
start();
}
int
main(int argc, char *argv[])
{
spotify_t *spotify;
int error;
int ret;
if (argc <= 2) {
fprintf(stderr, "Usage: %s <username> <password>\n", argv[0]);
return -1;
}
#if defined(EVTHREAD_USE_PTHREADS_IMPLEMENTED)
if (evthread_use_pthreads()) {
return -2;
}
#elif defined(EVTHREAD_USE_WINDOWS_THREADS_IMPLEMENTED)
if (evthread_use_windows_threads()) {
return -3;
}
#else
# error "The libevent threading support not available"
#endif
spotify = spotify_init(&error);
if (!spotify) {
fprintf(stderr, "Spotify failed to initialize\n");
return -4;
}
spotify_login(spotify, argv[1], argv[2]);
ret = spotify_run(spotify);
if (ret) {
fprintf(stderr, "Event loop returned %d\n", ret);
}
spotify_logout(spotify);
spotify_destroy(spotify);
return 0;
}
void socket_init(void)
{
addr_sock_init();
event_set_log_callback(event_log_print);
#ifdef SOCKET_LIBEVENT_ENABLE_THREAD
#ifdef EVTHREAD_USE_PTHREADS_IMPLEMENTED
#ifndef QJ_BOARD_ANDROID
evthread_use_pthreads();
#endif
#else
if(evthread_use_windows_threads()){
log_err("evthread_use_windows_threads failed!");
}
#endif
#endif
g_event_base = event_base_new();
if(NULL == g_event_base){
log_err("event base new failed!");
ex_assert(0);
}
addr_sock_set_event_base(g_event_base);
cli_add_quit_cb(socket_quit);
}
int
main(int argc, char **argv)
{
struct event_config *cfg = ld_event_config_new();
struct event_base *base;
struct evhttp *http;
int i;
int c;
int use_iocp = 0;
unsigned short port = 8080;
char *endptr = NULL;
#ifdef _WIN32
WSADATA WSAData;
WSAStartup(0x101, &WSAData);
#else
if (signal(SIGPIPE, SIG_IGN) == SIG_ERR)
return (1);
#endif
for (i = 1; i < argc; ++i) {
if (*argv[i] != '-')
continue;
c = argv[i][1];
if ((c == 'p' || c == 'l') && i + 1 >= argc) {
fprintf(stderr, "-%c requires argument.\n", c);
exit(1);
}
switch (c) {
case 'p':
if (i+1 >= argc || !argv[i+1]) {
fprintf(stderr, "Missing port\n");
exit(1);
}
port = (int)strtol(argv[i+1], &endptr, 10);
if (*endptr != '\0') {
fprintf(stderr, "Bad port\n");
exit(1);
}
break;
case 'l':
if (i+1 >= argc || !argv[i+1]) {
fprintf(stderr, "Missing content length\n");
exit(1);
}
content_len = (size_t)strtol(argv[i+1], &endptr, 10);
if (*endptr != '\0' || content_len == 0) {
fprintf(stderr, "Bad content length\n");
exit(1);
}
break;
#ifdef _WIN32
case 'i':
use_iocp = 1;
evthread_use_windows_threads();
ld_event_config_set_flag(cfg,EVENT_BASE_FLAG_STARTUP_IOCP);
break;
#endif
default:
fprintf(stderr, "Illegal argument \"%c\"\n", c);
exit(1);
}
}
base = ld_event_base_new_with_config(cfg);
if (!base) {
fprintf(stderr, "creating event_base failed. Exiting.\n");
return 1;
}
http = evhttp_new(base);
content = malloc(content_len);
if (content == NULL) {
fprintf(stderr, "Cannot allocate content\n");
exit(1);
} else {
int i = 0;
for (i = 0; i < (int)content_len; ++i)
content[i] = (i & 255);
}
evhttp_set_cb(http, "/ind", http_basic_cb, NULL);
fprintf(stderr, "/ind - basic content (memory copy)\n");
evhttp_set_cb(http, "/ref", http_ref_cb, NULL);
fprintf(stderr, "/ref - basic content (reference)\n");
fprintf(stderr, "Serving %d bytes on port %d using %s\n",
(int)content_len, port,
use_iocp? "IOCP" : ld_event_base_get_method(base));
evhttp_bind_socket(http, "0.0.0.0", port);
if (use_iocp) {
struct timeval tv={99999999,0};
ld_event_base_loopexit(base, &tv);
}
ld_event_base_dispatch(base);
/* NOTREACHED */
return (0);
}
int
main (int argc, char** argv)
{
CDServer* server;
int opt;
bool noFork = false;
bool debugging = false;
char* config = NULL;
static const char* configSearchPath[] = {
"%s/.craftd/craftd.conf", // %s is replaced with $HOME
"/etc/craftd/craftd.conf",
"/usr/local/etc/craftd/craftd.conf",
"craftd.conf", // Current working directory (for devs)
NULL
};
CDDefaultLogger = CDConsoleLogger;
LOG(LOG_INFO, "%s " CRAFTD_NOTICE_MESSAGE, argv[0]);
while ((opt = getopt(argc, argv, "c:dhnv")) != -1) {
switch (opt) {
case 'd': { // debugging mode
debugging = true;
} break;
case 'v': { // print version
exit(EXIT_SUCCESS); // Version header already printed
} break;
case 'n': { // don't fork or daemonize, use stdout for logging
noFork = true;
} break;
case 'c': { // use the specified config file
config = optarg;
} break;
case 'h': // print help message
default: {
fprintf(stderr, "\nUsage: %s [OPTION]...\n"
"-c <conf file> specify a conf file location\n"
"-d enable verbose debugging messages\n"
"-h display this help and exit\n"
"-n don't fork/daemonize (overrides config file)\n"
"-v output version information and exit\n"
"\n"
"For complete documentation, visit the wiki.\n\n", argv[0]);
exit((opt == 'h') ? EXIT_SUCCESS : EXIT_FAILURE);
}
}
}
if (!config) {
char path[FILENAME_MAX] = { 0 };
const char** current = configSearchPath;
do {
snprintf(path, FILENAME_MAX, *current, getenv("HOME"));
current++;
} while (*current != NULL && !CD_PathExists(path));
if (!CD_PathExists(path)) {
CD_abort("The config file could not be found");
}
else {
config = path;
}
}
if (!CD_IsReadable(config)) {
CD_abort("%s could not be read", config);
}
#ifdef WIN32
evthread_use_windows_threads();
#else
evthread_use_pthreads();
#endif
if (debugging) {
evthread_enable_lock_debuging();
}
CDMainServer = server = CD_CreateServer(config);
if (!server) {
CD_abort("Server couldn't be instantiated");
}
/* By default, mask debugging messages */
if (!debugging) {
server->logger.setlogmask(LOG_MASK(LOG_DEBUG));
}
CD_RunServer(server);
LOG(LOG_INFO, "Exiting.");
LOG_CLOSE();
CD_DestroyServer(server);
}
static int
test_ratelimiting(void)
{
struct event_base *base;
struct sockaddr_in sin;
struct evconnlistener *listener;
struct sockaddr_storage ss;
ev_socklen_t slen;
struct bufferevent **bevs;
struct client_state *states;
struct bufferevent_rate_limit_group *group = NULL;
int i;
struct timeval tv;
ev_uint64_t total_received;
double total_sq_persec, total_persec;
double variance;
double expected_total_persec = -1.0, expected_avg_persec = -1.0;
int ok = 1;
struct event_config *base_cfg;
memset(&sin, 0, sizeof(sin));
sin.sin_family = AF_INET;
sin.sin_addr.s_addr = htonl(0x7f000001); /* 127.0.0.1 */
sin.sin_port = 0; /* unspecified port */
if (0)
event_enable_debug_mode();
base_cfg = event_config_new();
#ifdef _WIN32
if (cfg_enable_iocp) {
evthread_use_windows_threads();
event_config_set_flag(base_cfg, EVENT_BASE_FLAG_STARTUP_IOCP);
}
#endif
base = event_base_new_with_config(base_cfg);
listener = evconnlistener_new_bind(base, echo_listenercb, base,
LEV_OPT_CLOSE_ON_FREE|LEV_OPT_REUSEABLE, -1,
(struct sockaddr *)&sin, sizeof(sin));
slen = sizeof(ss);
if (getsockname(evconnlistener_get_fd(listener), (struct sockaddr *)&ss,
&slen) < 0) {
perror("getsockname");
return 1;
}
if (cfg_connlimit > 0) {
conn_bucket_cfg = ev_token_bucket_cfg_new(
cfg_connlimit, cfg_connlimit * 4,
cfg_connlimit, cfg_connlimit * 4,
&cfg_tick);
assert(conn_bucket_cfg);
}
if (cfg_grouplimit > 0) {
group_bucket_cfg = ev_token_bucket_cfg_new(
cfg_grouplimit, cfg_grouplimit * 4,
cfg_grouplimit, cfg_grouplimit * 4,
&cfg_tick);
group = ratelim_group = bufferevent_rate_limit_group_new(
base, group_bucket_cfg);
expected_total_persec = cfg_grouplimit;
expected_avg_persec = cfg_grouplimit / cfg_n_connections;
if (cfg_connlimit > 0 && expected_avg_persec > cfg_connlimit)
expected_avg_persec = cfg_connlimit;
if (cfg_min_share >= 0)
bufferevent_rate_limit_group_set_min_share(
ratelim_group, cfg_min_share);
}
if (expected_avg_persec < 0 && cfg_connlimit > 0)
expected_avg_persec = cfg_connlimit;
if (expected_avg_persec > 0)
expected_avg_persec /= seconds_per_tick;
if (expected_total_persec > 0)
expected_total_persec /= seconds_per_tick;
bevs = calloc(cfg_n_connections, sizeof(struct bufferevent *));
states = calloc(cfg_n_connections, sizeof(struct client_state));
for (i = 0; i < cfg_n_connections; ++i) {
bevs[i] = bufferevent_socket_new(base, -1,
BEV_OPT_CLOSE_ON_FREE|BEV_OPT_THREADSAFE);
assert(bevs[i]);
bufferevent_setcb(bevs[i], discard_readcb, loud_writecb,
write_on_connectedcb, &states[i]);
bufferevent_enable(bevs[i], EV_READ|EV_WRITE);
bufferevent_socket_connect(bevs[i], (struct sockaddr *)&ss,
slen);
}
tv.tv_sec = cfg_duration - 1;
tv.tv_usec = 995000;
event_base_loopexit(base, &tv);
event_base_dispatch(base);
ratelim_group = NULL; /* So no more responders get added */
for (i = 0; i < cfg_n_connections; ++i) {
bufferevent_free(bevs[i]);
}
evconnlistener_free(listener);
/* Make sure no new echo_conns get added to the group. */
ratelim_group = NULL;
/* This should get _everybody_ freed */
while (n_echo_conns_open) {
printf("waiting for %d conns\n", n_echo_conns_open);
tv.tv_sec = 0;
tv.tv_usec = 300000;
event_base_loopexit(base, &tv);
event_base_dispatch(base);
}
if (group)
bufferevent_rate_limit_group_free(group);
total_received = 0;
total_persec = 0.0;
total_sq_persec = 0.0;
for (i=0; i < cfg_n_connections; ++i) {
double persec = states[i].received;
persec /= cfg_duration;
total_received += states[i].received;
total_persec += persec;
total_sq_persec += persec*persec;
printf("%d: %f per second\n", i+1, persec);
}
printf(" total: %f per second\n",
((double)total_received)/cfg_duration);
if (expected_total_persec > 0) {
double diff = expected_total_persec -
((double)total_received/cfg_duration);
printf(" [Off by %lf]\n", diff);
if (cfg_grouplimit_tolerance > 0 &&
fabs(diff) > cfg_grouplimit_tolerance) {
fprintf(stderr, "Group bandwidth out of bounds\n");
ok = 0;
}
}
printf(" average: %f per second\n",
(((double)total_received)/cfg_duration)/cfg_n_connections);
if (expected_avg_persec > 0) {
double diff = expected_avg_persec - (((double)total_received)/cfg_duration)/cfg_n_connections;
printf(" [Off by %lf]\n", diff);
if (cfg_connlimit_tolerance > 0 &&
fabs(diff) > cfg_connlimit_tolerance) {
fprintf(stderr, "Connection bandwidth out of bounds\n");
ok = 0;
}
}
variance = total_sq_persec/cfg_n_connections - total_persec*total_persec/(cfg_n_connections*cfg_n_connections);
printf(" stddev: %f per second\n", sqrt(variance));
if (cfg_stddev_tolerance > 0 &&
sqrt(variance) > cfg_stddev_tolerance) {
fprintf(stderr, "Connection variance out of bounds\n");
ok = 0;
}
event_base_free(base);
free(bevs);
free(states);
return ok ? 0 : 1;
}
int main(int argc, char* argv[]) {
#ifdef _WIN32
WORD wVersionRequested;
WSADATA wsaData;
wVersionRequested = MAKEWORD(2, 2);
WSAStartup(wVersionRequested, &wsaData);
evthread_use_windows_threads();
#else
evthread_use_pthreads();
#endif //_WIN32
ygo::Game _game;
ygo::mainGame = &_game;
_game.window_size = dimension2du(1024, 640);
if(!ygo::mainGame->Initialize())
return 0;
for(int i = 1; i < argc; ++i) {
/*command line args:
* -j: join host (host info from system.conf)
* -f: forced join host (host info from system.conf, immediately set ready)
* -d: deck edit
* -r: replay */
if(argv[i][0] == '-' && argv[i][1] == 'e') {
ygo::dataManager.LoadDB(&argv[i][2]);
} else if(!strcmp(argv[i], "-j") || !strcmp(argv[i], "-f") || !strcmp(argv[i], "-d") || !strcmp(argv[i], "-r") || !strcmp(argv[i], "-s")) {
exit_on_return = true;
irr::SEvent event;
event.EventType = irr::EET_GUI_EVENT;
event.GUIEvent.EventType = irr::gui::EGET_BUTTON_CLICKED;
if(!strcmp(argv[i], "-j")) {
ygo::mainGame->wMainMenu->setVisible(false);
ygo::mainGame->menuHandler.OnJoinHost();
} else if(!strcmp(argv[i], "-f")) {
ygo::mainGame->wMainMenu->setVisible(false);
ygo::mainGame->menuHandler.OnJoinHost(true);
} else if(!strcmp(argv[i], "-d")) {
event.GUIEvent.Caller = ygo::mainGame->btnDeckEdit;
ygo::mainGame->device->postEventFromUser(event);
} else if(!strcmp(argv[i], "-r")) {
event.GUIEvent.Caller = ygo::mainGame->btnReplayMode;
ygo::mainGame->device->postEventFromUser(event);
ygo::mainGame->lstReplayList->setSelected(ygo::mainGame->gameConf.lastreplay);
if(ygo::mainGame->lstReplayList->getSelected() != -1){
event.GUIEvent.Caller = ygo::mainGame->btnLoadReplay;
ygo::mainGame->device->postEventFromUser(event);
}
} else if(!strcmp(argv[i], "-s")) {
event.GUIEvent.Caller = ygo::mainGame->btnServerMode;
ygo::mainGame->device->postEventFromUser(event);
ygo::mainGame->lstSinglePlayList->setSelected(ygo::mainGame->gameConf.lastpuzzle);
if(ygo::mainGame->lstSinglePlayList->getSelected() != -1){
event.GUIEvent.Caller = ygo::mainGame->btnLoadSinglePlay;
ygo::mainGame->device->postEventFromUser(event);
}
}
}
}
ygo::mainGame->MainLoop();
#ifdef _WIN32
WSACleanup();
#else
#endif //_WIN32
return EXIT_SUCCESS;
}
/** 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;
#ifdef HAVE_EVENT2_EVENT_H
{
int attempts = 0;
int using_threads;
struct event_config *cfg;
retry:
++attempts;
using_threads = 0;
cfg = event_config_new();
tor_assert(cfg);
#if defined(_WIN32) && defined(USE_BUFFEREVENTS)
if (! torcfg->disable_iocp) {
evthread_use_windows_threads();
event_config_set_flag(cfg, EVENT_BASE_FLAG_STARTUP_IOCP);
using_iocp_bufferevents = 1;
using_threads = 1;
} else {
using_iocp_bufferevents = 0;
}
#elif defined(__COVERITY__)
/* Avoid a 'dead code' warning below. */
using_threads = ! torcfg->disable_iocp;
#endif
if (!using_threads) {
/* 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 defined(LIBEVENT_VERSION_NUMBER) && LIBEVENT_VERSION_NUMBER >= V(2,0,7)
if (torcfg->num_cpus > 0)
event_config_set_num_cpus_hint(cfg, torcfg->num_cpus);
#endif
#if LIBEVENT_VERSION_NUMBER >= V(2,0,9)
/* 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);
#endif
the_event_base = event_base_new_with_config(cfg);
event_config_free(cfg);
if (using_threads && the_event_base == NULL && attempts < 2) {
/* This could be a socketpair() failure, which can happen sometimes on
* windows boxes with obnoxious firewall rules. Downgrade and try
* again. */
#if defined(_WIN32) && defined(USE_BUFFEREVENTS)
if (torcfg->disable_iocp == 0) {
log_warn(LD_GENERAL, "Unable to initialize Libevent. Trying again "
"with IOCP disabled.");
} else
#endif
{
log_warn(LD_GENERAL, "Unable to initialize Libevent. Trying again.");
}
torcfg->disable_iocp = 1;
goto retry;
}
}
#else
the_event_base = event_init();
#endif
if (!the_event_base) {
log_err(LD_GENERAL, "Unable to initialize Libevent: cannot continue.");
exit(1);
}
/* Making this a NOTICE for now so we can link bugs to a libevent versions
* or methods better. */
log_info(LD_GENERAL,
"Initialized libevent version %s using method %s. Good.",
event_get_version(), tor_libevent_get_method());
#ifdef USE_BUFFEREVENTS
tor_libevent_set_tick_timeout(torcfg->msec_per_tick);
#endif
}
int main(int argc, char* argv[]) {
#ifdef _WIN32
WORD wVersionRequested;
WSADATA wsaData;
wVersionRequested = MAKEWORD(2, 2);
WSAStartup(wVersionRequested, &wsaData);
evthread_use_windows_threads();
#else
evthread_use_pthreads();
#endif //_WIN32
ygo::Game _game;
ygo::mainGame = &_game;
if(!ygo::mainGame->Initialize())
return 0;
for(int i = 1; i < argc; ++i) {
/*command line args:
* -j: join host (host info from system.conf)
* -d: deck edit
* -r: replay */
if(argv[i][0] == '-' && argv[i][1] == 'e') {
#ifdef _WIN32
wchar_t fname[260];
MultiByteToWideChar(CP_ACP, 0, &argv[i][2], -1, fname, 260);
char fname2[260];
BufferIO::EncodeUTF8(fname, fname2);
ygo::dataManager.LoadDB(fname2);
#else
ygo::dataManager.LoadDB(&argv[i][2]);
#endif
} else if(!strcmp(argv[i], "-j") || !strcmp(argv[i], "-d") || !strcmp(argv[i], "-r") || !strcmp(argv[i], "-s")) {
exit_on_return = true;
irr::SEvent event;
event.EventType = irr::EET_GUI_EVENT;
event.GUIEvent.EventType = irr::gui::EGET_BUTTON_CLICKED;
if(!strcmp(argv[i], "-j")) {
ygo::mainGame->HideElement(ygo::mainGame->wMainMenu);
event.GUIEvent.Caller = ygo::mainGame->btnJoinHost;
ygo::mainGame->device->postEventFromUser(event);
} else if(!strcmp(argv[i], "-d")) {
event.GUIEvent.Caller = ygo::mainGame->btnDeckEdit;
ygo::mainGame->device->postEventFromUser(event);
} else if(!strcmp(argv[i], "-r")) {
event.GUIEvent.Caller = ygo::mainGame->btnReplayMode;
ygo::mainGame->device->postEventFromUser(event);
ygo::mainGame->lstReplayList->setSelected(0);
event.GUIEvent.Caller = ygo::mainGame->btnLoadReplay;
ygo::mainGame->device->postEventFromUser(event);
} else if(!strcmp(argv[i], "-s")) {
event.GUIEvent.Caller = ygo::mainGame->btnServerMode;
ygo::mainGame->device->postEventFromUser(event);
ygo::mainGame->lstSinglePlayList->setSelected(0);
event.GUIEvent.Caller = ygo::mainGame->btnLoadSinglePlay;
ygo::mainGame->device->postEventFromUser(event);
}
}
}
ygo::mainGame->MainLoop();
#ifdef _WIN32
WSACleanup();
#else
#endif //_WIN32
return EXIT_SUCCESS;
}
int main( int argc, char *argv[] )
{
size_t i;
int ret, opt, longIndex = 0;
struct event *evsig_int;
#ifdef _WIN32
WSADATA WSAData;
#endif
pthread_t tcp_thread, *job_threads;
if ( evutil_secure_rng_init() < 0 ) {
ED2KD_LOGERR("failed to seed random number generator");
return EXIT_FAILURE;
}
/* parse command line arguments */
opt = getopt_long( argc, argv, optString, longOpts, &longIndex );
while( opt != -1 ) {
switch( opt ) {
case 'v':
display_version();
return EXIT_SUCCESS;
case 'g': {
unsigned char hash[ED2K_HASH_SIZE];
char hex_hash[sizeof(hash)*2+1];
get_random_user_hash(hash);
bin2hex(hash, hex_hash, sizeof(hex_hash));
puts(hex_hash);
return EXIT_SUCCESS;
}
case 'h':
display_usage();
return EXIT_SUCCESS;
default:
return EXIT_FAILURE;
}
opt = getopt_long( argc, argv, optString, longOpts, &longIndex );
}
#ifdef _WIN32
if ( 0 != WSAStartup(0x0201, &WSAData) ) {
ED2KD_LOGERR("WSAStartup failed!");
return EXIT_FAILURE;
}
#endif
if ( !server_load_config(NULL) ) {
ED2KD_LOGERR("failed to load configuration file");
return EXIT_FAILURE;
}
display_libevent_info();
#ifdef EVTHREAD_USE_WINDOWS_THREADS_IMPLEMENTED
ret = evthread_use_windows_threads();
#elif EVTHREAD_USE_PTHREADS_IMPLEMENTED
ret = evthread_use_pthreads();
#else
#error "unable to determine threading model"
#endif
if ( ret < 0 ) {
ED2KD_LOGERR("failed to init libevent threading model");
return EXIT_FAILURE;
}
g_srv.evbase_main = event_base_new();
if ( NULL == g_srv.evbase_main ) {
ED2KD_LOGERR("failed to create main event loop");
return EXIT_FAILURE;
}
g_srv.evbase_tcp = event_base_new();
if ( NULL == g_srv.evbase_tcp ) {
ED2KD_LOGERR("failed to create tcp event loop");
return EXIT_FAILURE;
}
evsig_int = evsignal_new(g_srv.evbase_main, SIGINT, sigint_cb, NULL);
evsignal_add(evsig_int, NULL);
// common timers timevals
g_srv.portcheck_timeout_tv = event_base_init_common_timeout(g_srv.evbase_tcp, &g_srv.cfg->portcheck_timeout_tv);
g_srv.status_notify_tv = event_base_init_common_timeout(g_srv.evbase_tcp, &g_srv.cfg->status_notify_tv);
if ( !db_create() ) {
ED2KD_LOGERR("failed to create database");
return EXIT_FAILURE;
}
g_srv.thread_count = omp_get_num_procs() + 1;
pthread_cond_init(&g_srv.job_cond, NULL);
pthread_mutex_init(&g_srv.job_mutex, NULL);
TAILQ_INIT(&g_srv.jqueue);
job_threads = (pthread_t *)malloc(g_srv.thread_count * sizeof(*job_threads));
// start tcp worker threads
for ( i=0; i<g_srv.thread_count; ++i ) {
pthread_create(&job_threads[i], NULL, server_job_worker, NULL);
}
// start tcp dispatch thread
pthread_create(&tcp_thread, NULL, server_base_worker, g_srv.evbase_tcp);
// start tcp listen loop
if ( !server_listen() ) {
ED2KD_LOGERR("failed to start server listener");
server_stop();
}
pthread_join(tcp_thread, NULL);
while ( EBUSY == pthread_cond_destroy(&g_srv.job_cond) ) {
pthread_cond_broadcast(&g_srv.job_cond);
//pthread_yield();
}
pthread_mutex_destroy(&g_srv.job_mutex);
for ( i=0; i<g_srv.thread_count; ++i ) {
pthread_join(job_threads[i], NULL);
}
free(job_threads);
// todo: free job queue items
evconnlistener_free(g_srv.tcp_listener);
event_free(evsig_int);
event_base_free(g_srv.evbase_tcp);
event_base_free(g_srv.evbase_main);
if ( db_destroy() < 0 ) {
ED2KD_LOGERR("failed to destroy database");
}
server_free_config();
return EXIT_SUCCESS;
}
