noexcept try

{

umask(077); // better safe than sorry --SRB

// '-' switched arguments come first; this function incs argv and decs argc

auto argc(_argc);

auto argv(_argv), envp(_envp);

const char *const progname(_argv[0]);

parseargs(&argc, &argv, opts);

matrix &= !nomatrix;

nomatrix |= !matrix;

// cores are not dumped without consent of the user to maintain the privacy

// of cryptographic key material in memory at the time of the crash. Note

// that on systems that support MADV_DONTDUMP such material will be excluded

// from the coredump. Nevertheless, other sensitive material such as user

// data may still be present in the core.

if(RB_DEBUG_LEVEL || ircd::debugmode)

enable_coredumps();

if(!startup_checks())

return EXIT_FAILURE;

if(printversion)

return print_version();

// Sets various other conf items based on the program options captured into

// the globals preceding this frame.

applyargs();

// The network name (matrix origin) is the first positional argument after

// any switched arguments. The matrix origin is the hostpart of MXID's for

// the server.

const ircd::string_view origin

{

// origin given on command line

argc > 0?

argv[0]:

// origin given by environment

construct_origin?

ircd::string_view{construct_origin}:

// origin not given, try server_name for origin.

construct_server_name?

ircd::string_view{construct_server_name}:

// invalid argument

nullptr

};

// The server_name is the unique name for this specific server. This is

// generally the same as origin; but if origin is example.org with an

// SRV record redirecting to matrix.example.org then server_name is

// matrix.example.org. In clusters serving a single origin, all

// server_names must be different.

const ircd::string_view server_name

{

// server_name given on command line

argc > 1?

argv[1]:

// server_name matches origin

argc > 0?

argv[0]:

// server_name given by environment

construct_server_name?

ircd::string_view{construct_server_name}:

// server_name not given, try origin for server_name.

construct_origin?

ircd::string_view{construct_server_name}:

// invalid argument

nullptr

};

// at least one server_name argument is required for now.

if(!server_name && matrix)

throw ircd::user_error

{

"usage :%s <origin> [servername]", progname

};

// Setup the matrix homeserver application. This will be executed on an

// ircd::context (dedicated stack). We construct several objects on the

// stack which are the basis for our matrix homeserver. When the stack

// unwinds, the homeserver will go out of service.

struct ircd::m::homeserver::opts opts;

opts.origin = origin;

opts.server_name = server_name;

opts.bootstrap_vector_path = bootstrap;

opts.backfill = !nobackfill;

opts.autoapps = !noautoapps;

const std::function<void (ircd::main_continuation)> homeserver

{

[&opts](const ircd::main_continuation &main)

{

// Construct the homeserver.

construct::homeserver homeserver

{

opts

};

// Bail for debug/testing purposes.

if(nomain)

return;

// Call main()'s continuation.

main();

}

};

// These callbacks are invoked at each ircd::run::level transition.

const ircd::run::changed runlevel_changed[]

{

{ smoketest_handler },

{ nobanner_handler },

{ muslexit_handler },

};

// This is the sole io_context for Construct, and the ios.run() below is the

// the only place where the program actually blocks.

boost::asio::io_context ios;

// libircd does no signal handling (or at least none that you ever have to

// care about); reaction to all signals happens out here instead. Handling

// is done properly through the io_context which registers the handler for

// the platform and then safely posts the received signal to the io_context

// event loop. This means we lose the true instant hardware-interrupt gratitude

// of signals but with the benefit of unconditional safety and cross-

// platformness with windows etc.

construct::signals signals{ios};

// Associates libircd with our io_context and posts the initial routines

// to that io_context. Execution of IRCd will then occur during ios::run()

ircd::init(ios.get_executor(), matrix? homeserver: nullptr);

// If the user wants to immediately drop to an interactive command line

// without having to send a ctrl-c for it, that is provided here. This does

// not actually take effect until it's processed in the ios.run() below.

if(cmdline || !execute.empty())

construct::console::interactive_when_done = cmdline,

construct::console::spawn();

// If the user wants to immediately process console commands

// non-interactively from a program argument input, that is enqueued here.

for(auto &&cmd : execute)

construct::console::queue.emplace_back(std::move(cmd));

// For developer debugging and testing this branch from a "-norun" argument

// will exit before committing to the ios.run().

if(norun)

return EXIT_SUCCESS;

// Execution.

// Loops until a clean exit from a quit() or an exception comes out of it.

// Alternatively, ios.run() could be otherwise used here.

size_t epoch{0};

if(likely(!megatest))

for(; !ios.stopped(); ++epoch)

{

ios.run_one();

if constexpr(ircd::ios::profile::logging)

ircd::log::logf

{

ircd::ios::log, ircd::log::DEBUG,

"EPOCH ----- construct:%zu ircd:%zu %zu",

epoch,

ircd::ios::epoch(),

};

}

// megatest is a mock execution which traps on every 1048576th tick.

if(megatest)

while(!ios.stopped())

{

ios.run_one();

if constexpr(ircd::ios::profile::logging)

ircd::log::logf

{

ircd::ios::log, ircd::log::DEBUG,

"EPOCH ----- construct:%zu ircd:%zu %zu",

epoch,

ircd::ios::epoch(),

};

if(++epoch % 1048576 == 0)

ircd::debugtrap();

}

// The smoketest is enabled if the first value is true; then all of the

// values must be true for the smoketest to pass.

if(smoketest[0])

return std::all_of(begin(smoketest), end(smoketest), ircd::identity())?

EXIT_SUCCESS:

EXIT_FAILURE;

// The restart flag can be set by the console command "restart" which

// calls ircd::quit() to clean break from the run() loop.

if(ircd::restart)

do_restart(_argv, _envp);

return EXIT_SUCCESS;

}

catch(const ircd::user_error &e)

{

if(ircd::debugmode)

ircd::terminate{e};

fprintf(stderr, usererrstr, e.what());

return EXIT_FAILURE;

}

catch(const std::exception &e)

{

if(ircd::debugmode)

ircd::terminate{e};

/*

fprintf(stderr, fatalerrstr, e.what());

return EXIT_FAILURE;

{

printf("VERSION :%s\n",

RB_VERSION);

#ifdef CUSTOM_BRANDING

printf("VERSION :based on %s-%s\n",

PACKAGE_NAME,

PACKAGE_VERSION);

#endif

return EXIT_SUCCESS;

try

{

if(RB_VERSION != ircd::info::version)

ircd::log::warning

{

"Header version '%s' mismatch library '%s'",

RB_VERSION,

ircd::info::version,

};

if(RB_VERSION_TAG != ircd::info::tag)

ircd::log::warning

{

"Header version tag '%s' mismatch library '%s'",

RB_VERSION_TAG,

ircd::info::tag,

};

if(RB_TIME_CONFIGURED != ircd::info::configured_time)

ircd::log::warning

{

"Header configuration time:%ld (%s) %s than library configuration time:%ld (%s).",

RB_TIME_CONFIGURED,

RB_VERSION_TAG,

RB_TIME_CONFIGURED > ircd::info::configured_time? "newer" : "older",

ircd::info::configured_time,

ircd::info::tag,

};

return true;

}

catch(const std::exception &e)

{

fprintf(stderr, usererrstr, e.what());

return false;

try

{

//

// Setup corefile size immediately after boot -kre

//

rlimit rlim; // resource limits

ircd::syscall(getrlimit, RLIMIT_CORE, &rlim);

// Set corefilesize to maximum

rlim.rlim_cur = rlim.rlim_max;

ircd::syscall(setrlimit, RLIMIT_CORE, &rlim);

}

catch(const std::exception &e)

{

std::cerr << "Failed to adjust rlimit: " << e.what() << std::endl;

char *const *const &_envp)

{

const auto args

{

ircd::replace(std::string(ircd::restart) + ' ', ' ', '\0')

};

std::vector<char *> argv{_argv[0]};

for(size_t i(0); i < args.size(); ++i)

{

argv.emplace_back(const_cast<char *>(args.data() + i));

for(; i < args.size() && args.at(i) != '\0'; ++i);

}

argv.emplace_back(nullptr);

ircd::syscall(::execve, _argv[0], argv.data(), _envp);

__builtin_unreachable();

{

smoketest.at(size_t(level) + 1) = true;

if(!smoketest[0])

return;

if(level != ircd::run::level::RUN)

return;

if(construct::console::active())

{

construct::console::quit_when_done = true;

return;

};

static ircd::ios::descriptor descriptor

{

"construct.smoketest"

};

ircd::dispatch

{

descriptor, ircd::ios::defer, ircd::quit

};

{

if(nobanner) switch(level)

{

case ircd::run::level::RUN:

ircd::log::console_enable();

break;

case ircd::run::level::QUIT:

ircd::log::console_disable();

break;

default:

break;

}

{

switch(level)

{

#if !defined(__GNU_LIBRARY__) //TODO: musl?

case ircd::run::level::HALT:

exit(0);

__builtin_unreachable();

#endif

default:

break;

}

{

if(diagnostic)

ircd::diagnostic.set(diagnostic);

if(safemode)

{

single = true;

nocompact = true;

noautoapps = true;

ircd::server::enable.set("false");

ircd::db::auto_deletion.set("false");

}

if(single)

{

ircd::maintenance.set("true");

cmdline = !debugmode;

nobackfill = true;

}

if(bootstrap)

ircd::maintenance.set("true");

if(defaults)

ircd::defaults.set("true");

if(slave)

{

ircd::slave.set("true");

read_only = true; // slave implies read_only

}

if(read_only)

ircd::read_only.set("true");

if(debugmode)

ircd::debugmode.set("true");

else

ircd::debugmode.set("false");

if(nolisten)

ircd::net::listen.set("false");

else

ircd::net::listen.set("true");

if(noautomod)

ircd::mods::autoload.set("false");

else

ircd::mods::autoload.set("true");

if(ircd::string_view(recoverdb) == "repair")

{

ircd::db::open_repair.set("true");

nocompact = true;

cmdline = true;

}

else if(recoverdb)

ircd::db::open_recover.set(recoverdb);

if(nocompact)

ircd::db::auto_compact.set("false");

if(nodirect)

ircd::fs::fd::opts::direct_io_enable.set("false");

else

ircd::fs::fd::opts::direct_io_enable.set("true");

if(noaio)

ircd::fs::aio::enable.set("false");

if(yes6)

ircd::net::enable_ipv6.set("true");

else if(no6)

ircd::net::enable_ipv6.set("false");

else

ircd::net::enable_ipv6.set("false");

if(soft_assert)

ircd::soft_assert.set("true");

if(quietmode || nobanner || silentmode)

ircd::log::console_disable();

if(silentmode)

construct::console::silent = true;

struct epoll_event *const __events,

int __maxevents,

int __timeout)

{

// see addl documentation in ircd/ios

return ircd::ios::epoll_wait<__real_epoll_wait>

(

__epfd,

__events,

__maxevents,

__timeout

);

struct io_uring *ring,

unsigned flags)

{

namespace info = ircd::info;

#if defined(IORING_SETUP_COOP_TASKRUN)

const bool have_coop_taskrun

{

info::kernel_version[0] > 5 ||

(info::kernel_version[0] >= 5 && info::kernel_version[1] >= 19)

};

if(have_coop_taskrun && !noiouct)

flags |= IORING_SETUP_COOP_TASKRUN;

#endif

#if defined(IORING_SETUP_SINGLE_ISSUER)

const bool have_single_issuer

{

info::kernel_version[0] > 6 ||

(info::kernel_version[0] >= 6 && info::kernel_version[1] >= 0)

};

if(have_single_issuer && !noioust)

flags |= IORING_SETUP_SINGLE_ISSUER;

#endif

struct io_uring_params params

{

.flags = flags,

};

int ret;

if constexpr((true))

ret = ::io_uring_queue_init_params

(

entries,

ring,

&params

);

else

ret = __real_io_uring_queue_init

(

entries,

ring,

flags

);

return ret;