/**

httpserver

main.cpp

Copyright 2011-2025 Ramsey Kant

Licensed under the Apache License, Version 2.0 (the "License");

you may not use this file except in compliance with the License.

You may obtain a copy of the License at

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software

distributed under the License is distributed on an "AS IS" BASIS,

WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

See the License for the specific language governing permissions and

limitations under the License.

*/

#include <charconv>

#include <map>

#include <optional>

#include <print>

#include <string>

#include <string_view>

#include <fstream>

#include <csignal>

#include <sys/stat.h>

#include "HTTPServer.h"

static std::unique_ptr<HTTPServer> svr;

void handleSigPipe([[maybe_unused]] int snum) {

// Intentionally empty — suppress SIGPIPE without side effects

}

void handleTermSig([[maybe_unused]] int snum) {

// canRun is volatile bool — the write is visible to the process() loop.

// No std::print or non-trivial calls here; only the flag write.

if (svr) svr->canRun = false;

}

int main()

{

// Parse config file

std::map<std::string, std::string, std::less<>> config;

std::fstream cfile;

std::string line;

std::string key;

std::string val;

int32_t epos = 0;

cfile.open("server.config");

if (!cfile.is_open()) {

std::print("Unable to open server.config file in working directory\n");

return -1;

}

while (getline(cfile, line)) {

// Skip empty lines or those beginning with a #

if (line.length() == 0 || line.rfind("#", 0) == 0)

continue;

epos = line.find("=");

key = line.substr(0, epos);

val = line.substr(epos + 1, line.length());

config.try_emplace(key, val);

}

cfile.close();

// Validate at least vhost, port, and diskpath are present

if (!config.contains("vhost") || !config.contains("port") || !config.contains("diskpath")) {

std::print("vhost, port, and diskpath must be supplied in the config, at a minimum\n");

return -1;

}

if (struct stat sb = {0}; stat(config["diskpath"].c_str(), &sb) != 0) {

std::print("diskpath must exist: {}\n", config["diskpath"]);

return -1;

}

// Break vhost into a comma separated list (if there are multiple vhost aliases)

std::vector<std::string> vhosts;

std::string vhost_alias_str = config["vhost"];

std::string delimiter = ",";

std::string token;

size_t pos = 0;

do {

pos = vhost_alias_str.find(delimiter);

token = vhost_alias_str.substr(0, pos);

vhosts.push_back(token);

vhost_alias_str.erase(0, pos + delimiter.length());

} while (pos != std::string::npos);

// Helper: parse a decimal integer from a string, returns nullopt on any error

auto parse_int = [](std::string_view s) -> std::optional<int32_t> {

int32_t val = 0;

auto [ptr, ec] = std::from_chars(s.data(), s.data() + s.size(), val);

if (ec != std::errc{} || ptr != s.data() + s.size())

return std::nullopt;

return val;

};

// Check for optional drop_uid, drop_gid. Ensure both are set

int32_t drop_uid = 0;

int32_t drop_gid = 0;

if (config.contains("drop_uid") && config.contains("drop_gid")) {

auto uid_opt = parse_int(config["drop_uid"]);

auto gid_opt = parse_int(config["drop_gid"]);

// Only drop UID/GID if it's set and not 0

if (uid_opt && gid_opt && (*uid_opt > 0) && (*gid_opt > 0)) {

drop_uid = *uid_opt;

drop_gid = *gid_opt;

}

}

// Ignore SIGPIPE "Broken pipe" signals when socket connections are broken.

signal(SIGPIPE, handleSigPipe);

// Register termination signals

signal(SIGABRT, &handleTermSig);

signal(SIGINT, &handleTermSig);

signal(SIGTERM, &handleTermSig);

auto port_opt = parse_int(config["port"]);

if (!port_opt || *port_opt <= 0 || *port_opt > 65535) {

std::print("port must be a valid integer between 1 and 65535\n");

return -1;

}

// Instantiate and start the server

svr = std::make_unique<HTTPServer>(vhosts, *port_opt, config["diskpath"], drop_uid, drop_gid);

if (!svr->start()) {

svr->stop();

return -1;

}

// Run main event loop

svr->process();

// Stop the server

svr->stop();

return 0;

}