int
create_pidfile(char *pidfile_location, int shm_id)
{
FILE *fp;
pid_t pid;
if(!pidfile_location)
return(-1);
/*
first check if the pidfile already exists
*/
if(check_pidfile(pidfile_location, "createsvc", &pid) == -1)
return(-1);
pid = getpid();
fp = fopen(pidfile_location, "w+");
if(!fp)
{
(void)vrprint.error(-1, "Error", "opening pid-file '%s' for writing failed: %s.", pidfile_location, strerror(errno));
return(-1);
}
if(fprintf(fp, "%ld %d\n", (long)pid, shm_id) < 0)
{
(void)vrprint.error(-1, "Error", "writing pid-file '%s' failed: %s.", pidfile_location, strerror(errno));
return(-1);
}
if(fclose(fp) < 0)
{
(void)vrprint.error(-1, "Error", "closing pid-file '%s' failed: %s.", pidfile_location, strerror(errno));
return(-1);
}
return(0);
}
/*
* main
*
*/
int
main (int argc, char *argv[])
{
GOptionContext *opt_ctx = NULL;
gboolean become_daemon = FALSE;
gboolean g_fatal_warnings = FALSE;
char *pidfile = NULL, *state_file = NULL, *dhcp = NULL;
char *config = NULL, *plugins = NULL, *conf_plugins = NULL;
char *log_level = NULL, *log_domains = NULL;
char **dns = NULL;
gboolean success;
BMPolicy *policy = NULL;
BMDBusManager *dbus_mgr = NULL;
GError *error = NULL;
gboolean wrote_pidfile = FALSE;
char *cfg_log_level = NULL, *cfg_log_domains = NULL;
GOptionEntry options[] = {
{ "no-daemon", 0, 0, G_OPTION_ARG_NONE, &become_daemon, "Don't become a daemon", NULL },
{ "g-fatal-warnings", 0, 0, G_OPTION_ARG_NONE, &g_fatal_warnings, "Make all warnings fatal", NULL },
{ "pid-file", 0, 0, G_OPTION_ARG_FILENAME, &pidfile, "Specify the location of a PID file", "filename" },
{ "state-file", 0, 0, G_OPTION_ARG_FILENAME, &state_file, "State file location", "/path/to/state.file" },
{ "config", 0, 0, G_OPTION_ARG_FILENAME, &config, "Config file location", "/path/to/config.file" },
{ "plugins", 0, 0, G_OPTION_ARG_STRING, &plugins, "List of plugins separated by ','", "plugin1,plugin2" },
{ "log-level", 0, 0, G_OPTION_ARG_STRING, &log_level, "Log level: one of [ERR, WARN, INFO, DEBUG]", "INFO" },
{ "log-domains", 0, 0, G_OPTION_ARG_STRING, &log_domains,
"Log domains separated by ',': any combination of [NONE,HW,BT,USER_SET,SYS_SET,SUSPEND,CORE,DEVICE]",
"HW" },
{NULL}
};
if (getuid () != 0) {
fprintf (stderr, "You must be root to run BarcodeManager!\n");
exit (1);
}
if (!g_module_supported ()) {
fprintf (stderr, "GModules are not supported on your platform!\n");
exit (1);
}
bindtextdomain (GETTEXT_PACKAGE, BMLOCALEDIR);
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
textdomain (GETTEXT_PACKAGE);
/* Parse options */
opt_ctx = g_option_context_new ("");
g_option_context_set_translation_domain (opt_ctx, "UTF-8");
g_option_context_set_ignore_unknown_options (opt_ctx, FALSE);
g_option_context_set_help_enabled (opt_ctx, TRUE);
g_option_context_add_main_entries (opt_ctx, options, NULL);
g_option_context_set_summary (opt_ctx,
"BarcodeManager monitors all barcode scanners automatically.");
success = g_option_context_parse (opt_ctx, &argc, &argv, NULL);
g_option_context_free (opt_ctx);
if (!success) {
fprintf (stderr, _("Invalid option. Please use --help to see a list of valid options.\n"));
exit (1);
}
/* Make GIO ignore the remote VFS service; otherwise it tries to use the
* session bus to contact the remote service, and NM shouldn't ever be
* talking on the session bus. See rh #588745
*/
setenv ("GIO_USE_VFS", "local", 1);
pidfile = pidfile ? pidfile : g_strdup (BM_DEFAULT_PID_FILE);
state_file = state_file ? state_file : g_strdup (BM_DEFAULT_SYSTEM_STATE_FILE);
/* check pid file */
if (check_pidfile (pidfile))
exit (1);
/* Parse the config file */
if (config) {
if (!parse_config_file (config, &conf_plugins, &dhcp, &dns, &cfg_log_level, &cfg_log_domains, &error)) {
fprintf (stderr, "Config file %s invalid: (%d) %s\n",
config,
error ? error->code : -1,
(error && error->message) ? error->message : "unknown");
exit (1);
}
} else {
gboolean parsed = FALSE;
/* Even though we prefer BarcodeManager.conf, we need to check the
* old bm-system-settings.conf first to preserve compat with older
* setups. In package managed systems dropping a BarcodeManager.conf
* onto the system would make NM use it instead of bm-system-settings.conf,
* changing behavior during an upgrade. We don't want that.
*/
/* Try deprecated bm-system-settings.conf first */
if (g_file_test (BM_OLD_SYSTEM_CONF_FILE, G_FILE_TEST_EXISTS)) {
config = g_strdup (BM_OLD_SYSTEM_CONF_FILE);
parsed = parse_config_file (config, &conf_plugins, &dhcp, &dns, &cfg_log_level, &cfg_log_domains, &error);
if (!parsed) {
fprintf (stderr, "Default config file %s invalid: (%d) %s\n",
config,
error ? error->code : -1,
(error && error->message) ? error->message : "unknown");
g_free (config);
config = NULL;
g_clear_error (&error);
}
}
/* Try the preferred BarcodeManager.conf last */
if (!parsed && g_file_test (BM_DEFAULT_SYSTEM_CONF_FILE, G_FILE_TEST_EXISTS)) {
config = g_strdup (BM_DEFAULT_SYSTEM_CONF_FILE);
parsed = parse_config_file (config, &conf_plugins, &dhcp, &dns, &cfg_log_level, &cfg_log_domains, &error);
if (!parsed) {
fprintf (stderr, "Default config file %s invalid: (%d) %s\n",
config,
error ? error->code : -1,
(error && error->message) ? error->message : "unknown");
g_free (config);
config = NULL;
g_clear_error (&error);
}
}
}
/* Logging setup */
if (!bm_logging_setup (log_level ? log_level : cfg_log_level,
log_domains ? log_domains : cfg_log_domains,
&error)) {
fprintf (stderr,
_("%s. Please use --help to see a list of valid options.\n"),
error->message);
exit (1);
}
/* Plugins specified with '--plugins' override those of config file */
plugins = plugins ? plugins : g_strdup (conf_plugins);
g_free (conf_plugins);
/* Parse the state file */
if (!parse_state_file (state_file, &error)) {
fprintf (stderr, "State file %s parsing failed: (%d) %s\n",
state_file,
error ? error->code : -1,
(error && error->message) ? error->message : "unknown");
/* Not a hard failure */
}
g_clear_error (&error);
/* Tricky: become_daemon is FALSE by default, so unless it's TRUE because
* of a CLI option, it'll become TRUE after this
*/
become_daemon = !become_daemon;
if (become_daemon) {
if (daemon (0, 0) < 0) {
int saved_errno;
saved_errno = errno;
fprintf (stderr, "Could not daemonize: %s [error %u]\n",
g_strerror (saved_errno),
saved_errno);
exit (1);
}
if (write_pidfile (pidfile))
wrote_pidfile = TRUE;
}
if (g_fatal_warnings) {
GLogLevelFlags fatal_mask;
fatal_mask = g_log_set_always_fatal (G_LOG_FATAL_MASK);
fatal_mask |= G_LOG_LEVEL_WARNING | G_LOG_LEVEL_CRITICAL;
g_log_set_always_fatal (fatal_mask);
}
/*
* Set the umask to 0022, which results in 0666 & ~0022 = 0644.
* Otherwise, if root (or an su'ing user) has a wacky umask, we could
* write out an unreadable resolv.conf.
*/
umask (022);
g_type_init ();
if (!g_thread_supported ())
g_thread_init (NULL);
dbus_g_thread_init ();
#ifndef HAVE_DBUS_GLIB_DISABLE_LEGACY_PROP_ACCESS
#error HAVE_DBUS_GLIB_DISABLE_LEGACY_PROP_ACCESS not defined
#endif
#if HAVE_DBUS_GLIB_DISABLE_LEGACY_PROP_ACCESS
/* Ensure that non-exported properties don't leak out, and that the
* introspection 'access' permissions are respected.
*/
dbus_glib_global_set_disable_legacy_property_access ();
#endif
setup_signals ();
bm_logging_start (become_daemon);
bm_log_info (LOGD_CORE, "BarcodeManager (version " BM_DIST_VERSION ") is starting...");
success = FALSE;
if (config)
bm_log_info (LOGD_CORE, "Read config file %s", config);
main_loop = g_main_loop_new (NULL, FALSE);
/* Initialize our DBus service & connection */
dbus_mgr = bm_dbus_manager_get ();
manager = bm_manager_get (config, plugins, state_file, &error);
if (manager == NULL) {
bm_log_err (LOGD_CORE, "failed to initialize the barcode manager: %s",
error && error->message ? error->message : "(unknown)");
goto done;
}
policy = bm_policy_new (manager);
if (policy == NULL) {
bm_log_err (LOGD_CORE, "failed to initialize the policy.");
goto done;
}
/* Start our DBus service */
if (!bm_dbus_manager_start_service (dbus_mgr)) {
bm_log_err (LOGD_CORE, "failed to start the dbus service.");
goto done;
}
bm_manager_start (manager);
success = TRUE;
/* Told to quit before getting to the mainloop by the signal handler */
if (quit_early == TRUE)
goto done;
g_main_loop_run (main_loop);
done:
if (policy)
bm_policy_destroy (policy);
if (manager)
g_object_unref (manager);
bm_logging_shutdown ();
if (pidfile && wrote_pidfile)
unlink (pidfile);
/* Free options */
g_free (pidfile);
g_free (state_file);
g_free (config);
g_free (plugins);
g_free (dhcp);
g_strfreev (dns);
g_free (log_level);
g_free (log_domains);
g_free (cfg_log_level);
g_free (cfg_log_domains);
bm_log_info (LOGD_CORE, "exiting (%s)", success ? "success" : "error");
exit (success ? 0 : 1);
}
int main(int argc, char *argv[])
{
time_t delay = 0;
aConfItem* aconf;
if(geteuid() == 0)
{
fprintf(stderr, "ERROR: Don't run ircd as root!\n");
return -1;
}
/*
* save server boot time right away, so getrusage works correctly
*/
if ((CurrentTime = time(0)) == -1)
{
fprintf(stderr, "ERROR: Clock Failure: %s\n", strerror(errno));
exit(errno);
}
/*
* Setup corefile size immediately after boot
*/
setup_corefile();
/*
* set initialVMTop before we allocate any memory
*/
initialVMTop = get_vm_top();
/*
* Initialize the Blockheap allocator
*/
initBlockHeap();
ServerRunning = 0;
memset(&me, 0, sizeof(me));
GlobalClientList = &me; /* Pointer to beginning of Client list */
cold_start = YES; /* set when server first starts up */
memset(&Count, 0, sizeof(Count));
Count.server = 1; /* us */
initialize_global_set_options();
#ifdef REJECT_HOLD
reject_held_fds = 0;
#endif
ConfigFileEntry.dpath = DPATH;
ConfigFileEntry.configfile = CPATH; /* Server configuration file */
#ifdef KPATH
ConfigFileEntry.klinefile = KPATH; /* Server kline file */
#else
ConfigFileEntry.klinefile = CPATH;
#endif /* KPATH */
#ifdef DLPATH
ConfigFileEntry.dlinefile = DLPATH;
#else
ConfigFileEntry.dlinefile = CPATH;
#endif /* DLPATH */
#ifdef GLINES
ConfigFileEntry.glinefile = GLINEFILE;
#endif
#ifdef ZIP_LINKS
/* Make sure the include files match the library version number. */
/* configure takes care of looking for zlib and zlibVersion(). */
if (strcmp(zlibVersion(), ZLIB_VERSION) != 0)
{
fprintf(stderr, "WARNING: zlib include files differ from library.\n");
fprintf(stderr, "WARNING: ZIPLINKS may fail!\n");
fprintf(stderr, "WARNING: library %s, include files %s\n",
zlibVersion(), ZLIB_VERSION);
}
#endif
myargv = argv;
umask(077); /* better safe than sorry --SRB */
parse_command_line(argc, argv);
if (chdir(ConfigFileEntry.dpath))
{
perror("chdir");
exit(-1);
}
/*
* Check if daemon is already running
*/
check_pidfile();
init_sys(bootDaemon);
init_log(logFileName);
setup_signals();
initialize_message_files();
isupport = make_isupport();
dbuf_init(); /* set up some dbuf stuff to control paging */
init_hash();
clear_scache_hash_table(); /* server cache name table */
clear_ip_hash_table(); /* client host ip hash table */
clear_Dline_table(); /* d line tree */
initlists();
initclass();
initwhowas();
init_stats();
init_tree_parse(msgtab); /* tree parse code (orabidoo) */
fdlist_init();
init_netio();
read_conf_files(YES); /* cold start init conf files */
aconf = find_me();
if (EmptyString(me.name))
strncpy_irc(me.name, aconf->host, HOSTLEN);
strncpy_irc(me.host, aconf->host, HOSTLEN);
me.fd = -1;
me.from = &me;
me.servptr = &me;
SetMe(&me);
make_server(&me);
me.serv->up = me.name;
me.lasttime = me.since = me.firsttime = CurrentTime;
add_to_client_hash_table(me.name, &me);
check_class();
write_pidfile();
log(L_NOTICE, "Server Ready");
ServerRunning = 1;
while (ServerRunning) {
usleep(100000);
do_adns_io();
delay = io_loop(delay);
do_adns_io();
}
return 0;
}
/**
* Main function, starts the daemon.
*/
int main(int argc, char *argv[])
{
struct sigaction action;
int group, status = SS_RC_INITIALIZATION_FAILED;
struct utsname utsname;
/* logging for library during initialization, as we have no bus yet */
dbg = dbg_stderr;
/* initialize library */
if (!library_init(NULL, "charon"))
{
library_deinit();
exit(SS_RC_LIBSTRONGSWAN_INTEGRITY);
}
if (lib->integrity &&
!lib->integrity->check_file(lib->integrity, "charon", argv[0]))
{
dbg_stderr(DBG_DMN, 1, "integrity check of charon failed");
library_deinit();
exit(SS_RC_DAEMON_INTEGRITY);
}
if (!libhydra_init())
{
dbg_stderr(DBG_DMN, 1, "initialization failed - aborting charon");
libhydra_deinit();
library_deinit();
exit(SS_RC_INITIALIZATION_FAILED);
}
if (!libcharon_init())
{
dbg_stderr(DBG_DMN, 1, "initialization failed - aborting charon");
goto deinit;
}
/* use CTRL loglevel for default */
for (group = 0; group < DBG_MAX; group++)
{
levels[group] = LEVEL_CTRL;
}
/* handle arguments */
for (;;)
{
struct option long_opts[] = {
{ "help", no_argument, NULL, 'h' },
{ "version", no_argument, NULL, 'v' },
{ "use-syslog", no_argument, NULL, 'l' },
/* TODO: handle "debug-all" */
{ "debug-dmn", required_argument, &group, DBG_DMN },
{ "debug-mgr", required_argument, &group, DBG_MGR },
{ "debug-ike", required_argument, &group, DBG_IKE },
{ "debug-chd", required_argument, &group, DBG_CHD },
{ "debug-job", required_argument, &group, DBG_JOB },
{ "debug-cfg", required_argument, &group, DBG_CFG },
{ "debug-knl", required_argument, &group, DBG_KNL },
{ "debug-net", required_argument, &group, DBG_NET },
{ "debug-asn", required_argument, &group, DBG_ASN },
{ "debug-enc", required_argument, &group, DBG_ENC },
{ "debug-tnc", required_argument, &group, DBG_TNC },
{ "debug-imc", required_argument, &group, DBG_IMC },
{ "debug-imv", required_argument, &group, DBG_IMV },
{ "debug-pts", required_argument, &group, DBG_PTS },
{ "debug-tls", required_argument, &group, DBG_TLS },
{ "debug-esp", required_argument, &group, DBG_ESP },
{ "debug-lib", required_argument, &group, DBG_LIB },
{ 0,0,0,0 }
};
int c = getopt_long(argc, argv, "", long_opts, NULL);
switch (c)
{
case EOF:
break;
case 'h':
usage(NULL);
status = 0;
goto deinit;
case 'v':
printf("Linux strongSwan %s\n", VERSION);
status = 0;
goto deinit;
case 'l':
use_syslog = TRUE;
continue;
case 0:
/* option is in group */
levels[group] = atoi(optarg);
continue;
default:
usage("");
status = 1;
goto deinit;
}
break;
}
if (!lookup_uid_gid())
{
dbg_stderr(DBG_DMN, 1, "invalid uid/gid - aborting charon");
goto deinit;
}
charon->load_loggers(charon, levels, !use_syslog);
if (uname(&utsname) != 0)
{
memset(&utsname, 0, sizeof(utsname));
}
DBG1(DBG_DMN, "Starting IKE charon daemon (strongSwan "VERSION", %s %s, %s)",
utsname.sysname, utsname.release, utsname.machine);
if (lib->integrity)
{
DBG1(DBG_DMN, "integrity tests enabled:");
DBG1(DBG_DMN, "lib 'libstrongswan': passed file and segment integrity tests");
DBG1(DBG_DMN, "lib 'libhydra': passed file and segment integrity tests");
DBG1(DBG_DMN, "lib 'libcharon': passed file and segment integrity tests");
DBG1(DBG_DMN, "daemon 'charon': passed file integrity test");
}
/* initialize daemon */
if (!charon->initialize(charon,
lib->settings->get_str(lib->settings, "charon.load", PLUGINS)))
{
DBG1(DBG_DMN, "initialization failed - aborting charon");
goto deinit;
}
lib->plugins->status(lib->plugins, LEVEL_CTRL);
if (check_pidfile())
{
DBG1(DBG_DMN, "charon already running (\""PID_FILE"\" exists)");
goto deinit;
}
if (!lib->caps->drop(lib->caps))
{
DBG1(DBG_DMN, "capability dropping failed - aborting charon");
goto deinit;
}
/* add handler for SEGV and ILL,
* INT, TERM and HUP are handled by sigwaitinfo() in run() */
action.sa_handler = segv_handler;
action.sa_flags = 0;
sigemptyset(&action.sa_mask);
sigaddset(&action.sa_mask, SIGINT);
sigaddset(&action.sa_mask, SIGTERM);
sigaddset(&action.sa_mask, SIGHUP);
sigaction(SIGSEGV, &action, NULL);
sigaction(SIGILL, &action, NULL);
sigaction(SIGBUS, &action, NULL);
action.sa_handler = SIG_IGN;
sigaction(SIGPIPE, &action, NULL);
pthread_sigmask(SIG_SETMASK, &action.sa_mask, NULL);
/* start daemon (i.e. the threads in the thread-pool) */
charon->start(charon);
/* main thread goes to run loop */
run();
/* normal termination, cleanup and exit */
unlink_pidfile();
status = 0;
deinit:
libcharon_deinit();
libhydra_deinit();
library_deinit();
return status;
}
/**
* Main function, starts TKM backend.
*/
int main(int argc, char *argv[])
{
char *dmn_name;
if (argc > 0 && strlen(argv[0]) > 0)
{
dmn_name = basename(argv[0]);
}
else
{
dmn_name = "charon-tkm";
}
/* TKM credential set */
tkm_cred_t *creds;
struct sigaction action;
int status = SS_RC_INITIALIZATION_FAILED;
/* logging for library during initialization, as we have no bus yet */
dbg = dbg_syslog;
/* initialize library */
if (!library_init(NULL, dmn_name))
{
library_deinit();
exit(status);
}
if (!libhydra_init())
{
dbg_syslog(DBG_DMN, 1, "initialization failed - aborting %s", dmn_name);
libhydra_deinit();
library_deinit();
exit(status);
}
if (!libcharon_init())
{
dbg_syslog(DBG_DMN, 1, "initialization failed - aborting %s", dmn_name);
goto deinit;
}
if (!lookup_uid_gid())
{
dbg_syslog(DBG_DMN, 1, "invalid uid/gid - aborting %s", dmn_name);
goto deinit;
}
/* make sure we log to the DAEMON facility by default */
lib->settings->set_int(lib->settings, "%s.syslog.daemon.default",
lib->settings->get_int(lib->settings, "%s.syslog.daemon.default", 1,
dmn_name), dmn_name);
charon->load_loggers(charon, NULL, FALSE);
DBG1(DBG_DMN, "Starting charon with TKM backend (strongSwan "VERSION")");
/* register TKM specific plugins */
static plugin_feature_t features[] = {
PLUGIN_REGISTER(NONCE_GEN, tkm_nonceg_create),
PLUGIN_PROVIDE(NONCE_GEN),
PLUGIN_REGISTER(PUBKEY, tkm_public_key_load, TRUE),
PLUGIN_PROVIDE(PUBKEY, KEY_RSA),
PLUGIN_PROVIDE(PUBKEY_VERIFY, SIGN_RSA_EMSA_PKCS1_SHA1),
PLUGIN_PROVIDE(PUBKEY_VERIFY, SIGN_RSA_EMSA_PKCS1_SHA256),
PLUGIN_CALLBACK(kernel_ipsec_register, tkm_kernel_ipsec_create),
PLUGIN_PROVIDE(CUSTOM, "kernel-ipsec"),
};
lib->plugins->add_static_features(lib->plugins, "tkm-backend", features,
countof(features), TRUE);
if (!register_dh_mapping())
{
DBG1(DBG_DMN, "no DH group mapping defined - aborting %s", dmn_name);
goto deinit;
}
/* register TKM keymat variant */
keymat_register_constructor(IKEV2, (keymat_constructor_t)tkm_keymat_create);
/* initialize daemon */
if (!charon->initialize(charon, PLUGINS))
{
DBG1(DBG_DMN, "initialization failed - aborting %s", dmn_name);
goto deinit;
}
lib->plugins->status(lib->plugins, LEVEL_CTRL);
/* set global pidfile name depending on daemon name */
if (asprintf(&pidfile_name, IPSEC_PIDDIR"/%s.pid", dmn_name) < 0)
{
DBG1(DBG_DMN, "unable to set pidfile name - aborting %s", dmn_name);
goto deinit;
};
if (check_pidfile())
{
DBG1(DBG_DMN, "%s already running (\"%s\" exists)", dmn_name,
pidfile_name);
goto deinit;
}
if (!lib->caps->drop(lib->caps))
{
DBG1(DBG_DMN, "capability dropping failed - aborting %s", dmn_name);
goto deinit;
}
/* initialize TKM client */
if (!tkm_init())
{
DBG1(DBG_DMN, "init of TKM client failed - aborting %s", dmn_name);
goto deinit;
}
/* register TKM authorization hook */
listener = tkm_listener_create();
charon->bus->add_listener(charon->bus, &listener->listener);
/* register TKM credential set */
creds = tkm_cred_create();
lib->credmgr->add_set(lib->credmgr, (credential_set_t*)creds);
/* register TKM credential encoder */
lib->encoding->add_encoder(lib->encoding, tkm_encoder_encode);
/* add handler for SEGV and ILL,
* INT and TERM are handled by sigwait() in run() */
action.sa_handler = segv_handler;
action.sa_flags = 0;
sigemptyset(&action.sa_mask);
sigaddset(&action.sa_mask, SIGINT);
sigaddset(&action.sa_mask, SIGTERM);
sigaction(SIGSEGV, &action, NULL);
sigaction(SIGILL, &action, NULL);
sigaction(SIGBUS, &action, NULL);
action.sa_handler = SIG_IGN;
sigaction(SIGPIPE, &action, NULL);
pthread_sigmask(SIG_SETMASK, &action.sa_mask, NULL);
/* start daemon (i.e. the threads in the thread-pool) */
charon->start(charon);
/* main thread goes to run loop */
run();
unlink_pidfile();
status = 0;
charon->bus->remove_listener(charon->bus, &listener->listener);
listener->destroy(listener);
creds->destroy(creds);
lib->encoding->remove_encoder(lib->encoding, tkm_encoder_encode);
deinit:
destroy_dh_mapping();
libcharon_deinit();
libhydra_deinit();
library_deinit();
tkm_deinit();
return status;
}
void init(int argc, char **argv){
if(argc < 2){
usage(argc, argv);
exit(0);
}
signal(SIGPIPE, SIG_IGN);
{
struct timeval tv;
if(gettimeofday(&tv, NULL) == -1){
srand(time(NULL) + getpid());
}else{
srand(tv.tv_sec + tv.tv_usec + getpid());
}
}
bool is_daemon = false;
const char *conf_file = NULL;
for(int i=1; i<argc; i++){
if(strcmp(argv[i], "-d") == 0){
is_daemon = true;
}else{
conf_file = argv[i];
}
}
if(conf_file == NULL){
usage(argc, argv);
exit(0);
}
if(!is_file(conf_file)){
fprintf(stderr, "'%s' is not a file or not exists!\n", conf_file);
exit(0);
}
conf = Config::load(conf_file);
if(!conf){
fprintf(stderr, "error loading conf file: '%s'\n", conf_file);
exit(0);
}
{
std::string conf_dir = real_dirname(conf_file);
if(chdir(conf_dir.c_str()) == -1){
fprintf(stderr, "error chdir: %s\n", conf_dir.c_str());
exit(0);
}
}
std::string log_output;
int log_rotate_size = 0;
{ // logger
int log_level = Logger::get_level(conf->get_str("logger.level"));
log_rotate_size = conf->get_num("logger.rotate.size");
if(log_rotate_size < 1024 * 1024){
log_rotate_size = 1024 * 1024;
}
log_output = conf->get_str("logger.output");
if(log_output == ""){
log_output = "stdout";
}
if(log_open(log_output.c_str(), log_level, true, log_rotate_size) == -1){
fprintf(stderr, "error open log file: %s\n", log_output.c_str());
exit(0);
}
}
check_pidfile();
if(is_daemon){
daemonize();
}
log_info("starting icomet %s...", ICOMET_VERSION);
log_info("config file: %s", conf_file);
log_info("log_level : %s", conf->get_str("logger.level"));
log_info("log_output : %s", log_output.c_str());
log_info("log_rotate_size : %d", log_rotate_size);
evbase = event_base_new();
if(!evbase){
fprintf(stderr, "create evbase error!\n");
exit(0);
}
admin_http = evhttp_new(evbase);
if(!admin_http){
fprintf(stderr, "create admin_http error!\n");
exit(0);
}
front_http = evhttp_new(evbase);
if(!front_http){
fprintf(stderr, "create front_http error!\n");
exit(0);
}
sigint_event = evsignal_new(evbase, SIGINT, signal_cb, NULL);
if(!sigint_event || event_add(sigint_event, NULL)<0){
fprintf(stderr, "Could not create/add a signal event!\n");
exit(0);
}
sigterm_event = evsignal_new(evbase, SIGTERM, signal_cb, NULL);
if(!sigterm_event || event_add(sigterm_event, NULL)<0){
fprintf(stderr, "Could not create/add a signal event!\n");
exit(0);
}
timer_event = event_new(evbase, -1, EV_PERSIST, timer_cb, NULL);
{
struct timeval tv;
tv.tv_sec = CHANNEL_CHECK_INTERVAL;
tv.tv_usec = 0;
if(!timer_event || evtimer_add(timer_event, &tv)<0){
fprintf(stderr, "Could not create/add a timer event!\n");
exit(0);
}
}
}
int main(int argc, char * const argv[]){
/* Parse the command line arguments */
MFC.fork = TRUE;
parse_options(argc, argv);
signal(SIGHUP,Signal_Handler); /* hangup signal */
signal(SIGTERM,Signal_Handler); /* software termination signal from kill */
struct timespec timx,tim1;
openlog("mfc-daemon", LOG_PID, LOG_DAEMON);
MFC.syslog = TRUE;
/* check machine and pidfile*/
MFC.total_cpus = check_cpu();
MFC.total_fans = check_fan();
check_pidfile();
write_pidfile();
MFC.pidfile = TRUE;
if (MFC.fork) {
start_daemon();
}
int fan;
for (fan = 1; fan <= MFC.total_fans; ++fan) {
write_fan_manual(fan, 1);
}
tim1.tv_sec = TV_SEC;
tim1.tv_nsec = TV_NSEC;
//init
int wr_manual=0;
int change_number=0;
int old_fan_speed=-1;
INFO("Start");
int temp = get_cpu_temperature();
int old_temp_change = 0;
int fan_speed=GET_FAN_SPEED(temp);
fan_speed=set_min_max_fan_speed(fan_speed);
for (fan = 1; fan <= MFC.total_fans; ++fan) {
write_fan_speed(fan, fan_speed);
}
while (1){
wr_manual++;
if (wr_manual==9){
for (fan = 1; fan <= MFC.total_fans; ++fan) {
write_fan_manual(fan, 1);
}
wr_manual=0;
}
temp = get_cpu_temperature();
int diff = abs(temp - old_temp_change);
if (diff >= 2){
// temp = average of both cpu's
fan_speed=GET_FAN_SPEED(temp);
fan_speed=set_min_max_fan_speed(fan_speed);
if (fan_speed!=old_fan_speed){
for (fan = 1; fan <= MFC.total_fans; ++fan) {
write_fan_speed(fan, fan_speed);
}
change_number=log_fan_speed(fan_speed,change_number,temp);
old_fan_speed=fan_speed;
}
old_temp_change = temp;
}
if (nanosleep(&tim1,&timx) == -1){
QUIT_DAEMON("Error nanosleep");
}
}
}
void init(int argc, char **argv){
if(argc < 2){
usage(argc, argv);
exit(0);
}
bool is_daemon = false;
const char *conf_file = NULL;
for(int i=1; i<argc; i++){
if(strcmp(argv[i], "-d") == 0){
is_daemon = true;
}else{
conf_file = argv[i];
}
}
if(conf_file == NULL){
usage(argc, argv);
exit(0);
}
if(!is_file(conf_file)){
fprintf(stderr, "'%s' is not a file or not exists!\n", conf_file);
exit(0);
}
conf = Config::load(conf_file);
if(!conf){
fprintf(stderr, "error loading conf file: '%s'", conf_file);
exit(0);
}
{
std::string conf_dir = real_dirname(conf_file);
if(chdir(conf_dir.c_str()) == -1){
fprintf(stderr, "error chdir: %s\n", conf_dir.c_str());
exit(0);
}
}
std::string work_dir;
{
work_dir = conf->get_str("work_dir");
if(work_dir.empty()){
work_dir = ".";
}
if(!is_dir(work_dir.c_str())){
fprintf(stderr, "'%s' is not a directory or not exists!\n", work_dir.c_str());
exit(0);
}
/*
if(chdir(work_dir.c_str()) == -1){
fprintf(stderr, "error chdir: %s\n", work_dir.c_str());
exit(0);
}
*/
}
check_pidfile();
std::string log_output;
int log_rotate_size = 0;
{ // logger
int log_level = Logger::get_level(conf->get_str("logger.level"));
log_rotate_size = conf->get_num("logger.rotate.size");
log_output = conf->get_str("logger.output");
if(log_output == ""){
log_output = "stdout";
}
if(log_open(log_output.c_str(), log_level, true, log_rotate_size) == -1){
fprintf(stderr, "error open log file: %s", log_output.c_str());
exit(0);
}
}
log_info("ssdb-server %s", SSDB_VERSION);
log_info("conf_file : %s", conf_file);
log_info("work_dir : %s", work_dir.c_str());
log_info("log_level : %s", conf->get_str("logger.level"));
log_info("log_output : %s", log_output.c_str());
log_info("log_rotate_size : %d", log_rotate_size);
if(is_daemon){
daemonize();
}
{ // ssdb
ssdb = SSDB::open(*conf, work_dir);
if(!ssdb){
log_fatal("could not open SSDB!");
exit(0);
}
}
{ // server
const char *ip = conf->get_str("server.ip");
short port = (short)conf->get_num("server.port");
serv_link = Link::listen(ip, port);
if(serv_link == NULL){
log_fatal("error opening server socket! %s", strerror(errno));
exit(0);
}
log_info("server listen on: %s:%d", ip, port);
}
write_pidfile();
log_info("ssdb server started.");
}
int
svc_transition_if_necessary(int *kq, struct kevent *ke, Service *svc)
{
// if Svc Wants To Be Online
// and State is inactive, startpre, start
// then (either advance to startpre or, if startpre has exited, advance
// to start. If start and type=simple, and PID runs, -> online. If
// type = forking AND pidfile found, -> online. If MainPIDExited, kill
if(svc->PIDsPurged)
{
if(svc->Want == S_ONLINE && (svc->State == S_INACTIVE ||
svc->State == S_EXITED || svc->State == S_STOP_POST))
{
if(svc->State == S_EXITED) /* not doing poststop */
return svc_stop_post(kq, ke, svc);
else if((svc->State == S_STOP_POST && svc->MainPIDExited) ||
svc->State == S_INACTIVE)
return svc_start_pre(kq, ke, svc);
}
if(svc->Want == S_ONLINE && svc->State == S_START_PRE)
{
// check timeout ?
// check if ExecStartPre exited cleanly too
if (svc->MainPIDExited)
return svc_start(kq, ke, svc);
}
}
if ((! svc->PIDFileRead) && svc->PIDFile && svc->State == S_START)
{
int res =check_pidfile(svc);
if(svc->MainPID && !res)
{
dbg("entering state S_ONLINE\n");
//svc->
svc->State =S_ONLINE;
svc->AuxWant =S_START_POST;
return 0;
}
}
if ((svc->State == S_START || svc->State == S_ONLINE) &&
svc->PIDsPurged == 1 && svc->Type != T_ONESHOT)
{
// IF CLEAN
dbg("entering state S_EXITED\n");
svc->State =S_EXITED;
svc->DoubleTransition =1;
if (svc->PIDFile)
remove(svc->PIDFile);
svc->MainPID =0;
// IF DODGY
// Set a 'failed' flag, and when we finish off the S_STOP_POST lark,
// enter S_FAILED
return 0;
}
if(svc->Type == T_ONESHOT)
{
if (svc->State == S_START)
{
svc_start_post_oneshot(kq, ke, svc);
}
else if (svc->State == S_START_POST)/* oneshot still executing at last pass */
{
// Check if exit status was 0 before doing this
dbg ("entering state S_ONLINE\n");
svc->State =S_ONLINE;
return 0;
}
}
if (svc->AuxWant == S_START_POST)
{
svc_start_post(kq, ke, svc);
}
return 0;
}
void Application::init(){
if(!is_file(app_args.conf_file.c_str())){
fprintf(stderr, "'%s' is not a file or not exists!\n", app_args.conf_file.c_str());
exit(1);
}
conf = Config::load(app_args.conf_file.c_str());
if(!conf){
fprintf(stderr, "error loading conf file: '%s'\n", app_args.conf_file.c_str());
exit(1);
}
{
std::string conf_dir = real_dirname(app_args.conf_file.c_str());
if(chdir(conf_dir.c_str()) == -1){
fprintf(stderr, "error chdir: %s\n", conf_dir.c_str());
exit(1);
}
}
app_args.pidfile = conf->get_str("pidfile");
if(app_args.start_opt == "stop"){
kill_process();
exit(0);
}
if(app_args.start_opt == "restart"){
if(file_exists(app_args.pidfile)){
kill_process();
}
}
check_pidfile();
{ // logger
std::string log_output;
std::string log_level_;
int64_t log_rotate_size;
log_level_ = conf->get_str("logger.level");
strtolower(&log_level_);
if(log_level_.empty()){
log_level_ = "debug";
}
int level = Logger::get_level(log_level_.c_str());
log_rotate_size = conf->get_int64("logger.rotate.size");
log_output = conf->get_str("logger.output");
if(log_output == ""){
log_output = "stdout";
}
if(log_open(log_output.c_str(), level, true, log_rotate_size) == -1){
fprintf(stderr, "error opening log file: %s\n", log_output.c_str());
exit(1);
}
}
app_args.work_dir = conf->get_str("work_dir");
if(app_args.work_dir.empty()){
app_args.work_dir = ".";
}
if(!is_dir(app_args.work_dir.c_str())){
fprintf(stderr, "'%s' is not a directory or not exists!\n", app_args.work_dir.c_str());
exit(1);
}
// WARN!!!
// deamonize() MUST be called before any thread is created!
if(app_args.is_daemon){
daemonize();
}
}
int
main(int argc, char *argv[])
{
/* Check to see if the user is running us as root, which is a nono */
if (!geteuid())
{
fprintf(stderr, "ERROR: This server won't run as root/superuser\n");
return -1;
}
/* Setup corefile size immediately after boot -kre */
setup_corefile();
/* Save server boot time right away, so getrusage works correctly */
set_time();
/* It's not random, but it ought to be a little harder to guess */
init_genrand(SystemTime.tv_sec ^ (SystemTime.tv_usec | (getpid() << 20)));
dlinkAdd(&me, &me.node, &global_client_list);
ConfigGeneral.dpath = DPATH;
ConfigGeneral.spath = SPATH;
ConfigGeneral.mpath = MPATH;
ConfigGeneral.configfile = CPATH; /* Server configuration file */
ConfigGeneral.klinefile = KPATH; /* Server kline file */
ConfigGeneral.glinefile = GPATH; /* Server gline file */
ConfigGeneral.xlinefile = XPATH; /* Server xline file */
ConfigGeneral.dlinefile = DLPATH; /* dline file */
ConfigGeneral.resvfile = RESVPATH; /* resv file */
myargv = argv;
umask(077); /* umask 077: u=rwx,g=,o= */
parseargs(&argc, &argv, myopts);
if (printVersion)
{
printf("ircd: version %s(%s)\n", ircd_version, serno);
exit(EXIT_SUCCESS);
}
if (chdir(ConfigGeneral.dpath))
{
perror("chdir");
exit(EXIT_FAILURE);
}
ssl_init();
if (!server_state.foreground)
{
make_daemon();
close_standard_fds(); /* this needs to be before init_netio()! */
}
else
print_startup(getpid());
setup_signals();
/* We need this to initialise the fd array before anything else */
fdlist_init();
log_set_file(LOG_TYPE_IRCD, 0, logFileName);
init_netio(); /* This needs to be setup early ! -- adrian */
/* Check if there is pidfile and daemon already running */
check_pidfile(pidFileName);
mp_pool_init();
init_dlink_nodes();
init_isupport();
dbuf_init();
hash_init();
ipcache_init();
client_init();
class_init();
whowas_init();
watch_init();
auth_init(); /* Initialise the auth code */
init_resolver(); /* Needs to be setup before the io loop */
modules_init();
read_conf_files(1); /* cold start init conf files */
init_uid();
initialize_server_capabs(); /* Set up default_server_capabs */
initialize_global_set_options(); /* Has to be called after read_conf_files() */
channel_init();
read_links_file();
motd_init();
user_usermodes_init();
#ifdef HAVE_LIBGEOIP
geoip_ctx = GeoIP_new(GEOIP_MEMORY_CACHE);
#endif
if (EmptyString(ConfigServerInfo.sid))
{
ilog(LOG_TYPE_IRCD, "ERROR: No server id specified in serverinfo block.");
exit(EXIT_FAILURE);
}
strlcpy(me.id, ConfigServerInfo.sid, sizeof(me.id));
if (EmptyString(ConfigServerInfo.name))
{
ilog(LOG_TYPE_IRCD, "ERROR: No server name specified in serverinfo block.");
exit(EXIT_FAILURE);
}
strlcpy(me.name, ConfigServerInfo.name, sizeof(me.name));
/* serverinfo{} description must exist. If not, error out.*/
if (EmptyString(ConfigServerInfo.description))
{
ilog(LOG_TYPE_IRCD, "ERROR: No server description specified in serverinfo block.");
exit(EXIT_FAILURE);
}
strlcpy(me.info, ConfigServerInfo.description, sizeof(me.info));
me.from = &me;
me.servptr = &me;
me.connection->lasttime = CurrentTime;
me.connection->since = CurrentTime;
me.connection->firsttime = CurrentTime;
SetMe(&me);
make_server(&me);
hash_add_id(&me);
hash_add_client(&me);
dlinkAdd(&me, make_dlink_node(), &global_server_list);
load_kline_database();
load_dline_database();
load_gline_database();
load_xline_database();
load_resv_database();
load_all_modules(1);
load_conf_modules();
load_core_modules(1);
write_pidfile(pidFileName);
ilog(LOG_TYPE_IRCD, "Server Ready");
event_addish(&event_cleanup_glines, NULL);
event_addish(&event_cleanup_tklines, NULL);
/* We want try_connections to be called as soon as possible now! -- adrian */
/* No, 'cause after a restart it would cause all sorts of nick collides */
event_addish(&event_try_connections, NULL);
/* Setup the timeout check. I'll shift it later :) -- adrian */
event_add(&event_comm_checktimeouts, NULL);
event_addish(&event_save_all_databases, NULL);
if (ConfigServerHide.links_delay > 0)
{
event_write_links_file.when = ConfigServerHide.links_delay;
event_addish(&event_write_links_file, NULL);
}
else
ConfigServerHide.links_disabled = 1;
if (splitmode)
event_addish(&splitmode_event, NULL);
io_loop();
return 0;
}
int main(int argc, char *argv[])
{
#ifndef _WIN32
if (geteuid() == 0)
{
fprintf(stderr, "Running IRC services is root is not recommended.");
return 1;
}
setup_corefile();
#endif
memset(&ServicesInfo, 0, sizeof(ServicesInfo));
memset(&ServicesState, 0, sizeof(ServicesState));
ServicesState.configfile = CPATH;
ServicesState.logfile = LPATH;
ServicesState.pidfile = PPATH;
ServicesState.fully_connected = 0;
parseargs(&argc, &argv, myopts);
if(ServicesState.printversion)
{
printf("oftc-ircservices: version: %s\n", VERSION);
exit(EXIT_SUCCESS);
}
if(chdir(DPATH))
{
perror("chdir");
exit(EXIT_FAILURE);
}
#ifndef _WIN32
if(!ServicesState.foreground)
make_daemon();
else
print_startup(getpid());
#endif
setup_signals();
memset(&me, 0, sizeof(me));
libio_init(!ServicesState.foreground);
init_events();
iorecv_cb = register_callback("iorecv", iorecv_default);
connected_cb = register_callback("server connected", server_connected);
iosend_cb = register_callback("iosend", iosend_default);
OpenSSL_add_all_digests();
init_interface();
check_pidfile(ServicesState.pidfile);
init_log(ServicesState.logfile);
#ifdef HAVE_RUBY
init_ruby();
signal(SIGSEGV, SIG_DFL);
#endif
init_channel();
init_conf();
init_client();
init_parser();
init_channel_modes();
init_mqueue();
init_tor();
me.from = me.servptr = &me;
SetServer(&me);
SetMe(&me);
dlinkAdd(&me, &me.node, &global_client_list);
read_services_conf(TRUE);
init_db();
init_uid();
#ifdef HAVE_PYTHON
init_python();
#endif
init_kill();
write_pidfile(ServicesState.pidfile);
ilog(L_NOTICE, "Services Ready");
db_load_driver();
#ifdef USE_SHARED_MODULES
if(chdir(MODPATH))
{
ilog(L_ERROR, "Could not load core modules from %s: %s",
MODPATH, strerror(errno));
exit(EXIT_FAILURE);
}
/* Go back to DPATH after checking to see if we can chdir to MODPATH */
chdir(DPATH);
#else
load_all_modules(1);
#endif
boot_modules(1);
connect_server();
for(;;)
{
while (eventNextTime() <= CurrentTime)
eventRun();
execute_callback(do_event_cb);
if(events_loop() == -1)
{
ilog(L_CRIT, "libevent returned error %d", errno);
services_die("Libevent returned some sort of error", NO);
break;
}
comm_select();
send_queued_all();
if(dorehash)
{
ilog(L_INFO, "Got SIGHUP, reloading configuration");
read_services_conf(NO);
dorehash = 0;
}
}
return 0;
}
int
main(int argc, char *argv[])
{
/* Check to see if the user is running us as root, which is a nono */
if(geteuid() == 0)
{
fprintf(stderr, "Don't run ircd as root!!!\n");
return -1;
}
/*
* save server boot time right away, so getrusage works correctly
*/
set_time();
/*
* Setup corefile size immediately after boot -kre
*/
setup_corefile();
/*
* set initialVMTop before we allocate any memory
*/
initialVMTop = get_vm_top();
ServerRunning = 0;
/* It ain't random, but it ought to be a little harder to guess */
srand(SystemTime.tv_sec ^ (SystemTime.tv_usec | (getpid() << 20)));
memset(&me, 0, sizeof(me));
memset(&meLocalUser, 0, sizeof(meLocalUser));
me.localClient = &meLocalUser;
/* Make sure all lists are zeroed */
memset(&unknown_list, 0, sizeof(unknown_list));
memset(&lclient_list, 0, sizeof(lclient_list));
memset(&serv_list, 0, sizeof(serv_list));
memset(&global_serv_list, 0, sizeof(global_serv_list));
memset(&oper_list, 0, sizeof(oper_list));
dlinkAddTail(&me, &me.node, &global_client_list);
memset((void *) &Count, 0, sizeof(Count));
memset((void *) &ServerInfo, 0, sizeof(ServerInfo));
memset((void *) &AdminInfo, 0, sizeof(AdminInfo));
/* Initialise the channel capability usage counts... */
init_chcap_usage_counts();
ConfigFileEntry.dpath = DPATH;
ConfigFileEntry.configfile = CPATH; /* Server configuration file */
ConfigFileEntry.klinefile = KPATH; /* Server kline file */
ConfigFileEntry.dlinefile = DLPATH; /* dline file */
ConfigFileEntry.xlinefile = XPATH;
ConfigFileEntry.resvfile = RESVPATH;
ConfigFileEntry.connect_timeout = 30; /* Default to 30 */
myargv = argv;
umask(077); /* better safe than sorry --SRB */
parseargs(&argc, &argv, myopts);
if(printVersion)
{
printf("ircd: version %s\n", ircd_version);
exit(EXIT_SUCCESS);
}
if(chdir(ConfigFileEntry.dpath))
{
fprintf(stderr, "Unable to chdir to %s: %s\n", ConfigFileEntry.dpath, strerror(errno));
exit(EXIT_FAILURE);
}
setup_signals();
#ifdef __CYGWIN__
server_state_foreground = 1;
#endif
if (testing_conf)
server_state_foreground = 1;
/* We need this to initialise the fd array before anything else */
fdlist_init();
if(!server_state_foreground)
{
comm_close_all();
}
/* Check if there is pidfile and daemon already running */
if(!testing_conf)
{
check_pidfile(pidFileName);
if(!server_state_foreground)
make_daemon();
else
print_startup(getpid());
}
init_netio(); /* This needs to be setup early ! -- adrian */
/* Init the event subsystem */
eventInit();
init_sys();
init_main_logfile();
initBlockHeap();
init_dlink_nodes();
init_patricia();
newconf_init();
init_s_conf();
init_s_newconf();
linebuf_init(); /* set up some linebuf stuff to control paging */
init_hash();
clear_scache_hash_table(); /* server cache name table */
init_host_hash();
clear_hash_parse();
init_client();
initUser();
init_channels();
initclass();
initwhowas();
init_stats();
init_hook();
init_reject();
init_cache();
init_monitor();
load_all_modules(1);
#ifndef STATIC_MODULES
load_core_modules(1);
#endif
init_auth(); /* Initialise the auth code */
init_resolver(); /* Needs to be setup before the io loop */
if (testing_conf)
fprintf(stderr, "\nBeginning config test\n");
read_conf_files(YES); /* cold start init conf files */
rehash_bans(0);
#ifndef STATIC_MODULES
mod_add_path(MODULE_DIR);
mod_add_path(MODULE_DIR "/autoload");
#endif
initialize_server_capabs(); /* Set up default_server_capabs */
initialize_global_set_options();
if(ServerInfo.name == NULL)
{
fprintf(stderr, "ERROR: No server name specified in serverinfo block.\n");
ilog(L_MAIN, "No server name specified in serverinfo block.");
exit(EXIT_FAILURE);
}
strlcpy(me.name, ServerInfo.name, sizeof(me.name));
if(ServerInfo.sid[0] == '\0')
{
fprintf(stderr, "ERROR: No server sid specified in serverinfo block.\n");
ilog(L_MAIN, "No server sid specified in serverinfo block.");
exit(EXIT_FAILURE);
}
strcpy(me.id, ServerInfo.sid);
init_uid();
/* serverinfo{} description must exist. If not, error out. */
if(ServerInfo.description == NULL)
{
fprintf(stderr, "ERROR: No server description specified in serverinfo block.\n");
ilog(L_MAIN, "ERROR: No server description specified in serverinfo block.");
exit(EXIT_FAILURE);
}
strlcpy(me.info, ServerInfo.description, sizeof(me.info));
if (testing_conf)
{
fprintf(stderr, "\nConfig testing complete.\n");
fflush(stderr);
exit(EXIT_SUCCESS);
}
me.from = &me;
me.servptr = &me;
SetMe(&me);
make_server(&me);
me.serv->up = me.name;
startup_time = CurrentTime;
add_to_client_hash(me.name, &me);
add_to_id_hash(me.id, &me);
dlinkAddAlloc(&me, &global_serv_list);
check_class();
write_pidfile(pidFileName);
load_help();
open_logfiles();
ilog(L_MAIN, "Server Ready");
eventAddIsh("cleanup_glines", cleanup_glines, NULL, CLEANUP_GLINES_TIME);
/* We want try_connections to be called as soon as possible now! -- adrian */
/* No, 'cause after a restart it would cause all sorts of nick collides */
/* um. by waiting even longer, that just means we have even *more*
* nick collisions. what a stupid idea. set an event for the IO loop --fl
*/
eventAddIsh("try_connections", try_connections, NULL, STARTUP_CONNECTIONS_TIME);
eventAddOnce("try_connections_startup", try_connections, NULL, 0);
eventAddIsh("collect_zipstats", collect_zipstats, NULL, ZIPSTATS_TIME);
/* Setup the timeout check. I'll shift it later :) -- adrian */
eventAddIsh("comm_checktimeouts", comm_checktimeouts, NULL, 1);
if(ConfigServerHide.links_delay > 0)
eventAddIsh("cache_links", cache_links, NULL,
ConfigServerHide.links_delay);
else
ConfigServerHide.links_disabled = 1;
if(splitmode)
eventAdd("check_splitmode", check_splitmode, NULL, 2);
ServerRunning = 1;
io_loop();
return 0;
}
int main(int argc, char* argv[])
{
setup_corefile(); /* we wan't core files for debug */
setup_signals();
srandom(time(NULL)); /* random seed */
/* check if we are just doing a configuration change */
if((argc > 1) && (strcasecmp(argv[1], "conf")==0))
return cmd_conf(argc-2, &argv[2]);
parse_command_line(argc, argv); /* parse command line options */
printf("Starting %s, CopyRight PTlink IRC Software 1999-2005\n", svs_version);
printf("Setting ircsvs log file to "LOGPATH "/ircsvs.log\n");
/* rotate the logsize if required */
check_logsize();
if(init_log(LOGPATH "/ircsvs.log") == 0)
{
fprintf(stderr,"ERROR: Could not create log file\n");
return 3;
}
slog(L_INFO, "Starting %s", svs_version);
#if 0
if(TimeZone)
{
#ifdef HAVE_SETENV
setenv("TZ",TimeZone,1);
tzset();
#else
fprintf(stderr, "TimeZone defined but setenv() is not supported on this OS!");
#endif
}
#endif
/* Let's init the irc functions first, we may use them on modules */
e_expire = mod_register_event("e_expire");
e_complete = mod_register_event("e_complete");
if(load_modules_file("ircsvs") < 0)
{
fprintf(stderr,"ERROR: Error loading modules\n");
return -3;
}
stdlog(L_INFO, "All modules succesfully loaded");
/* check it here to avoid "Server already exists" uppon connection */
if( nofork == 0 )
check_pidfile();
#if 0
#warning need to move ExpireInterval to the module
if(ExpireInterval)
{
stdlog(L_INFO, "Running expire routines...");
ev_expire(NULL, NULL);
stdlog(L_INFO,"Expire interval set to %d minute(s)", ExpireInterval / 60);
irc_AddEvent(ET_LOOP, ev_expire); /* set the expire routines */
}
else
stdlog(L_WARN, "Data expiration is disabled");
#endif
stdlog(L_INFO, "Services startup completed.");
mod_do_event(e_complete, NULL, NULL);
return 0;
}
int
main (int argc, char *argv[])
{
/* Check to see if the user is running
* us as root, which is a nono
*/
if (geteuid () == 0)
{
fprintf (stderr, "Don't run ircd as root!!!\n");
return (-1);
}
/* save server boot time right away, so getrusage works correctly */
set_time ();
/* Setup corefile size immediately after boot -kre */
setup_corefile ();
/* set initialVMTop before we allocate any memory */
initialVMTop = get_vm_top ();
ServerRunning = 0;
/* It ain't random, but it ought to be a little harder to guess */
srand (SystemTime.tv_sec ^ (SystemTime.tv_usec | (getpid () << 20)));
memset (&me, 0, sizeof (me));
memset (&meLocalUser, 0, sizeof (meLocalUser));
me.localClient = &meLocalUser;
dlinkAdd (&me, &me.node, &global_client_list); /* Pointer to beginning
of Client list */
memset (&ServerInfo, 0, sizeof (ServerInfo));
/* Initialise the channel capability usage counts... */
init_chcap_usage_counts ();
ConfigFileEntry.dpath = DPATH;
ConfigFileEntry.configfile = CPATH; /* Server configuration file */
ConfigFileEntry.klinefile = KPATH; /* Server kline file */
ConfigFileEntry.xlinefile = XPATH; /* Server xline file */
ConfigFileEntry.dlinefile = DLPATH; /* dline file */
ConfigFileEntry.cresvfile = CRESVPATH; /* channel resv file */
ConfigFileEntry.nresvfile = NRESVPATH; /* nick resv file */
myargv = argv;
umask (077); /* better safe than sorry --SRB */
parseargs (&argc, &argv, myopts);
build_version ();
if (printVersion)
{
printf ("ircd: version %s\n", ircd_version);
exit (EXIT_SUCCESS);
}
if (chdir (ConfigFileEntry.dpath))
{
perror ("chdir");
exit (EXIT_FAILURE);
}
if (!server_state.foreground)
make_daemon ();
else
print_startup (getpid ());
#ifdef HAVE_LIBCRYPTO
dh_init();
fprintf(stderr, "SSL: Initialize\n");
SSL_load_error_strings();
SSLeay_add_ssl_algorithms();
ServerInfo.ctx = SSL_CTX_new(SSLv23_server_method());
if (!ServerInfo.ctx) {
ERR_print_errors_fp(stderr);
return 0;
}
fprintf(stderr, "SSL: Client based SSL connections are enabled.\n");
#endif
setup_signals ();
/* We need this to initialise the fd array before anything else */
fdlist_init ();
if (!server_state.foreground)
close_all_connections (); /* this needs to be before init_netio()! */
else
check_can_use_v6 (); /* Done in close_all_connections normally */
init_log (logFileName);
init_netio (); /* This needs to be setup early ! -- adrian */
/* Check if there is pidfile and daemon already running */
check_pidfile (pidFileName);
/* Init the event subsystem */
eventInit ();
init_sys ();
#ifndef NOBALLOC
initBlockHeap ();
#endif
init_dlink_nodes ();
init_slink_nodes ();
initialize_message_files ();
dbuf_init ();
init_hash ();
init_ip_hash_table (); /* client host ip hash table */
init_host_hash (); /* Host-hashtable. */
clear_hash_parse ();
init_client ();
init_user ();
init_channels ();
init_class ();
init_whowas ();
init_stats ();
init_hooks ();
read_conf_files (1); /* cold start init conf files */
initServerMask ();
init_uid ();
init_auth (); /* Initialise the auth code */
init_resolver (); /* Needs to be setup before the io loop */
init_reject (); /* Set up the reject code. */
init_umodes (); /* Set up the usermode system. */
initialize_foundation_signals(); /* register things that modules need */
#ifdef HAVE_LIBCRYPTO
bio_spare_fd = save_spare_fd ("SSL private key validation");
#endif /* HAVE_LIBCRYPTO */
initialize_server_capabs (); /* Set up default_server_capabs */
initialize_global_set_options ();
if (ServerInfo.name == NULL)
{
fprintf (stderr,
"ERROR: No server name specified in serverinfo block.\n");
ilog (L_CRIT, "No server name specified in serverinfo block.");
exit (EXIT_FAILURE);
}
strlcpy (me.name, ServerInfo.name, sizeof (me.name));
/* serverinfo{} description must exist. If not, error out. */
if (ServerInfo.description == NULL)
{
fprintf (stderr,
"ERROR: No server description specified in serverinfo block.\n");
ilog (L_CRIT,
"ERROR: No server description specified in serverinfo block.");
exit (EXIT_FAILURE);
}
strlcpy (me.info, ServerInfo.description, sizeof (me.info));
me.from = &me;
me.servptr = &me;
SetMe (&me);
make_server (&me);
strlcpy (me.serv->up, me.name, sizeof (me.serv->up));
me.lasttime = me.since = me.firsttime = CurrentTime;
hash_add_client (&me);
/* add ourselves to global_serv_list */
dlinkAdd (&me, make_dlink_node (), &global_serv_list);
check_class ();
#ifndef STATIC_MODULES
if (chdir (MODPATH))
{
ilog (L_CRIT, "Could not load core modules. Terminating!");
exit (EXIT_FAILURE);
}
mod_set_base ();
load_all_modules (1);
load_core_modules (1);
/* Go back to DPATH after checking to see if we can chdir to MODPATH */
chdir (ConfigFileEntry.dpath);
#else
load_all_modules (1);
#endif
write_pidfile (pidFileName);
ilog (L_NOTICE, "Server Ready");
eventAddIsh ("cleanup_tklines", cleanup_tklines, NULL,
CLEANUP_TKLINES_TIME);
/* We want try_connections to be called as soon as possible now! -- adrian */
/* No, 'cause after a restart it would cause all sorts of nick collides */
eventAddIsh ("try_connections", try_connections, NULL,
STARTUP_CONNECTIONS_TIME);
eventAddIsh ("collect_zipstats", collect_zipstats, NULL, ZIPSTATS_TIME);
/* Setup the timeout check. I'll shift it later :) -- adrian */
eventAddIsh ("comm_checktimeouts", comm_checktimeouts, NULL, 1);
if (splitmode)
eventAddIsh ("check_splitmode", check_splitmode, NULL, 60);
ServerRunning = 1;
io_loop ();
return (0);
}
