// Return the secure network port for the secure server.
int config_logic_https_network_port ()
{
int port = convert_to_int (config_logic_http_network_port ());
// The secure port is the plain http port plus one.
port++;
return port;
}
string Database_Config_General::getSiteURL ()
{
// The site URL is set upon login, normally.
// In a client setup, there is never a login.
// Consequently the site URL is never set.
#ifdef HAVE_CLIENT
// In case of a client, return a predefined URL.
string url = "http://localhost:";
url.append (config_logic_http_network_port ());
url.append ("/");
return url;
#else
// Get the URL that was set upon login.
return getValue ("site-url", "");
#endif
}
// Stop the library.
// Can be called multiple times during the lifetime of the app.
void bibledit_stop_library ()
{
// Repeating stop guard.
if (!bibledit_started) return;
bibledit_started = false;
// Clear running flag.
config_globals_webserver_running = false;
string url, error;
// Connect to the plain webserver to initiate its shutdown mechanism.
url = "http://localhost:";
url.append (config_logic_http_network_port ());
filter_url_http_get (url, error, false);
// Connect to the secure server to initiate its shutdown mechanism.
#ifndef HAVE_CLIENT
url = "https://localhost:";
url.append (convert_to_string (config_logic_https_network_port ()));
filter_url_http_get (url, error, false);
// Let the connection start, then close it.
// The server will then abort the TLS handshake, and shut down.
#endif
#ifndef HAVE_ANDROID
#ifndef HAVE_IOS
// Schedule a timer to exit(0) the program in case the network stack fails to exit the servers.
// This should not be done on devices like Android and iOS
// because then the app would quit when the user moves the app to the background,
// whereas the user expects the app to stay alive in the background.
new thread (bibledit_last_ditch_forced_exit);
#endif
#endif
// Wait till the servers and the timers shut down.
config_globals_http_worker->join ();
config_globals_https_worker->join ();
config_globals_timer->join ();
// Clear memory.
delete config_globals_http_worker;
delete config_globals_https_worker;
delete config_globals_timer;
}
string client_index (void * webserver_request)
{
Webserver_Request * request = (Webserver_Request *) webserver_request;
Assets_View view;
if (request->query.count ("disable")) {
client_logic_enable_client (false);
client_index_remove_all_users (request);
Database_Config_General::setRepeatSendReceive (0);
Database_Config_General::setUnsentBibleDataTime (0);
Database_Config_General::setUnreceivedBibleDataTime (0);
}
bool connect = request->post.count ("connect");
bool demo = request->query.count ("demo");
if (connect || demo) {
string address;
if (connect) address = request->post ["address"];
if (demo) address = demo_address ();
if (address.find ("http") == string::npos) address = filter_url_set_scheme (address, false);
Database_Config_General::setServerAddress (address);
int port = convert_to_int (config_logic_http_network_port ());
if (connect) port = convert_to_int (request->post ["port"]);
if (demo) port = demo_port ();
Database_Config_General::setServerPort (port);
string user;
if (connect) user = request->post ["user"];
if (demo) user = session_admin_credentials ();
string pass;
if (connect) pass = request->post ["pass"];
if (demo) pass = session_admin_credentials ();
string response = client_logic_connection_setup (user, md5 (pass));
int iresponse = convert_to_int (response);
if ((iresponse >= Filter_Roles::guest ()) && (iresponse <= Filter_Roles::admin ())) {
// Enable client mode upon a successful connection.
client_index_enable_client (request, user, pass, iresponse);
// Feedback.
view.set_variable ("success", translate("Connection is okay."));
} else {
view.set_variable ("error", translate ("Could not create a connection with Bibledit Cloud") + ": " + response);
}
}
if (client_logic_client_enabled ())
view.enable_zone ("clienton");
else
view.enable_zone ("clientoff");
string address = Database_Config_General::getServerAddress ();
view.set_variable ("address", address);
int port = Database_Config_General::getServerPort ();
view.set_variable ("port", convert_to_string (port));
view.set_variable ("url", client_logic_link_to_cloud ("", ""));
vector <string> users = request->database_users ()->getUsers ();
for (auto & user : users) {
int level = request->database_users()->get_level (user);
view.set_variable ("role", Filter_Roles::text (level));
}
view.set_variable ("demo", demo_client_warning ());
string page;
// Since the role of the user may change after a successful connection to the server,
// the menu generation in the header should be postponed till when the actual role is known.
page = Assets_Page::header (translate ("Server"), webserver_request);
page += view.render ("client", "index");
page += Assets_Page::footer ();
return page;
}
int main (int argc, char **argv)
{
if (argc) {};
if (argv[0]) {};
// Ctrl-C initiates a clean shutdown sequence, so there's no memory leak.
signal (SIGINT, sigint_handler);
#ifdef HAVE_EXECINFO
// Handler for logging segmentation fault.
signal (SIGSEGV, sigsegv_handler);
#endif
// Get the executable path and base the document root on it.
string webroot;
{
// The following works on Linux but not on Mac OS X:
char *linkname = (char *) malloc (256);
memset (linkname, 0, 256); // valgrind uninitialized value(s)
ssize_t r = readlink ("/proc/self/exe", linkname, 256);
if (r) {};
webroot = filter_url_dirname (linkname);
free (linkname);
}
{
#ifdef HAVE_LIBPROC
// The following works on Linux plus on Mac OS X:
int ret;
pid_t pid;
char pathbuf [2048];
pid = getpid ();
ret = proc_pidpath (pid, pathbuf, sizeof (pathbuf));
if (ret > 0 ) {
webroot = filter_url_dirname (pathbuf);
}
#endif
}
bibledit_initialize_library (webroot.c_str(), webroot.c_str());
// Start the Bibledit library.
bibledit_start_library ();
bibledit_log ("The server started");
cout << "Listening on http://localhost:" << config_logic_http_network_port () <<
" and https://localhost:" << config_logic_https_network_port () << endl;
cout << "Press Ctrl-C to quit" << endl;
// Log possible backtrace from a previous crash.
string backtrace = filter_url_file_get_contents (backtrace_path ());
filter_url_unlink (backtrace_path ());
if (!backtrace.empty ()) {
Database_Logs::log ("Backtrace of the last segmentation fault:");
vector <string> lines = filter_string_explode (backtrace, '\n');
for (auto & line : lines) {
Database_Logs::log (line);
}
}
// Bibledit Cloud should restart itself at midnight.
// This is to be sure that any memory leaks don't accumulate too much
// in case Bibledit Cloud runs for months and years.
bibledit_set_quit_at_midnight ();
// Keep running till Bibledit stops or gets interrupted.
while (bibledit_is_running ()) { };
bibledit_shutdown_library ();
return EXIT_SUCCESS;
}
const char * bibledit_get_network_port ()
{
library_bibledit_network_port = config_logic_http_network_port ();
return library_bibledit_network_port.c_str ();
}
