EventBase::EventBase(const char* method)
{
// enable locking for libevent structure
if (evthread_use_pthreads())
{
throw std::exception();
}
#ifdef DEBUG
evthread_enable_lock_debuging();
event_enable_debug_mode();
#endif
struct event_config *config;
config = event_config_new();
int i = 0;
const char** availMethods = event_get_supported_methods();
for (i = 0; availMethods[i] != NULL; i++)
{
if (strcmp(availMethods[i], method)) {
event_config_avoid_method(config, availMethods[i]);
}
}
base_ = event_base_new_with_config(config);
if (!base_)
{
throw BadBaseException();
}
event_base_get_method(base_);
event_config_free(config);
}
int
main(int argc, const char **argv)
{
#ifdef _WIN32
WORD wVersionRequested;
WSADATA wsaData;
int err;
wVersionRequested = MAKEWORD(2, 2);
err = WSAStartup(wVersionRequested, &wsaData);
#endif
#ifndef _WIN32
if (signal(SIGPIPE, SIG_IGN) == SIG_ERR)
return 1;
#endif
#ifdef _WIN32
tinytest_skip(testgroups, "http/connection_retry");
#endif
#ifndef _EVENT_DISABLE_THREAD_SUPPORT
if (!getenv("EVENT_NO_DEBUG_LOCKS"))
evthread_enable_lock_debuging();
#endif
if (tinytest_main(argc,argv,testgroups))
return 1;
return 0;
}
int
main(int argc, char **argv)
{
int i,j;
double ratio;
#ifdef WIN32
WORD wVersionRequested = MAKEWORD(2,2);
WSADATA wsaData;
(void) WSAStartup(wVersionRequested, &wsaData);
#endif
#ifndef WIN32
if (signal(SIGPIPE, SIG_IGN) == SIG_ERR)
return 1;
#endif
for (i = 1; i < argc; ++i) {
for (j = 0; options[j].name; ++j) {
if (!strcmp(argv[i],options[j].name)) {
if (handle_option(argc,argv,&i,&options[j])<0)
return 1;
goto again;
}
}
fprintf(stderr, "Unknown option '%s'\n", argv[i]);
usage();
return 1;
again:
;
}
if (cfg_help) {
usage();
return 0;
}
cfg_tick.tv_sec = cfg_tick_msec / 1000;
cfg_tick.tv_usec = (cfg_tick_msec % 1000)*1000;
seconds_per_tick = ratio = cfg_tick_msec / 1000.0;
cfg_connlimit *= ratio;
cfg_grouplimit *= ratio;
{
struct timeval tv;
evutil_gettimeofday(&tv, NULL);
#ifdef WIN32
srand(tv.tv_usec);
#else
srandom(tv.tv_usec);
#endif
}
#ifndef _EVENT_DISABLE_THREAD_SUPPORT
evthread_enable_lock_debuging();
#endif
return test_ratelimiting();
}
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);
}
/*
* The actual main function.
*/
int
sntp_main (
int argc,
char **argv,
const char *sntpVersion
)
{
int i;
int exitcode;
int optct;
struct event_config * evcfg;
/* Initialize logging system - sets up progname */
sntp_init_logging(argv[0]);
if (!libevent_version_ok())
exit(EX_SOFTWARE);
init_lib();
init_auth();
optct = ntpOptionProcess(&sntpOptions, argc, argv);
argc -= optct;
argv += optct;
debug = OPT_VALUE_SET_DEBUG_LEVEL;
TRACE(2, ("init_lib() done, %s%s\n",
(ipv4_works)
? "ipv4_works "
: "",
(ipv6_works)
? "ipv6_works "
: ""));
ntpver = OPT_VALUE_NTPVERSION;
steplimit = OPT_VALUE_STEPLIMIT / 1e3;
gap.tv_usec = max(0, OPT_VALUE_GAP * 1000);
gap.tv_usec = min(gap.tv_usec, 999999);
if (HAVE_OPT(LOGFILE))
open_logfile(OPT_ARG(LOGFILE));
msyslog(LOG_INFO, "%s", sntpVersion);
if (0 == argc && !HAVE_OPT(BROADCAST) && !HAVE_OPT(CONCURRENT)) {
printf("%s: Must supply at least one of -b hostname, -c hostname, or hostname.\n",
progname);
exit(EX_USAGE);
}
/*
** Eventually, we probably want:
** - separate bcst and ucst timeouts (why?)
** - multiple --timeout values in the commandline
*/
response_timeout = OPT_VALUE_TIMEOUT;
response_tv.tv_sec = response_timeout;
response_tv.tv_usec = 0;
/* IPv6 available? */
if (isc_net_probeipv6() != ISC_R_SUCCESS) {
ai_fam_pref = AF_INET;
TRACE(1, ("No ipv6 support available, forcing ipv4\n"));
} else {
/* Check for options -4 and -6 */
if (HAVE_OPT(IPV4))
ai_fam_pref = AF_INET;
else if (HAVE_OPT(IPV6))
ai_fam_pref = AF_INET6;
}
/* TODO: Parse config file if declared */
/*
** Init the KOD system.
** For embedded systems with no writable filesystem,
** -K /dev/null can be used to disable KoD storage.
*/
kod_init_kod_db(OPT_ARG(KOD), FALSE);
// HMS: Should we use arg-defalt for this too?
if (HAVE_OPT(KEYFILE))
auth_init(OPT_ARG(KEYFILE), &keys);
/*
** Considering employing a variable that prevents functions of doing
** anything until everything is initialized properly
**
** HMS: What exactly does the above mean?
*/
event_set_log_callback(&sntp_libevent_log_cb);
if (debug > 0)
event_enable_debug_mode();
#ifdef WORK_THREAD
evthread_use_pthreads();
/* we use libevent from main thread only, locks should be academic */
if (debug > 0)
evthread_enable_lock_debuging();
#endif
evcfg = event_config_new();
if (NULL == evcfg) {
printf("%s: event_config_new() failed!\n", progname);
return -1;
}
#ifndef HAVE_SOCKETPAIR
event_config_require_features(evcfg, EV_FEATURE_FDS);
#endif
/* all libevent calls are from main thread */
/* event_config_set_flag(evcfg, EVENT_BASE_FLAG_NOLOCK); */
base = event_base_new_with_config(evcfg);
event_config_free(evcfg);
if (NULL == base) {
printf("%s: event_base_new() failed!\n", progname);
return -1;
}
/* wire into intres resolver */
worker_per_query = TRUE;
addremove_io_fd = &sntp_addremove_fd;
open_sockets();
if (HAVE_OPT(BROADCAST)) {
int cn = STACKCT_OPT( BROADCAST );
const char ** cp = STACKLST_OPT( BROADCAST );
while (cn-- > 0) {
handle_lookup(*cp, CTX_BCST);
cp++;
}
}
if (HAVE_OPT(CONCURRENT)) {
int cn = STACKCT_OPT( CONCURRENT );
const char ** cp = STACKLST_OPT( CONCURRENT );
while (cn-- > 0) {
handle_lookup(*cp, CTX_UCST | CTX_CONC);
cp++;
}
}
for (i = 0; i < argc; ++i)
handle_lookup(argv[i], CTX_UCST);
gettimeofday_cached(base, &start_tv);
event_base_dispatch(base);
event_base_free(base);
if (!time_adjusted &&
(ENABLED_OPT(STEP) || ENABLED_OPT(SLEW)))
exitcode = 1;
else
exitcode = 0;
return exitcode;
}
