{

std::ifstream file(fileName);

if ( ! file)

{

file.close();

std::cout << "Error: " << fileName << " - cannot be open;" << std::endl;

return false;

}

file.seekg(0, std::ifstream::end);

std::streamsize file_size = file.tellg();

file.seekg(0, std::ifstream::beg);

const std::streamsize file_size_max = 2048 * 1024;

if (file_size_max < file_size)

{

file.close();

std::cout << "Error: " << fileName << " - is too large; max include file size = " << file_size_max << " bytes;" << std::endl;

return false;

}

if (file_size)

{

std::vector<char> buf(file_size);

file.read(buf.data(), file_size);

strBuf.insert(strBuf.begin() + offset, buf.cbegin(), buf.cend() );

}

file.close();

return true;

const std::unordered_map<std::string, std::string> &app,

const ServerApplicationDefaultSettings &defaults,

std::vector<Module> &modules,

ServerApplicationsTree &apps_tree

)

{

auto it_name = app.find("server_name");

if (app.cend() == it_name)

{

std::cout << "Error: application parameter 'server_name' is not specified;" << std::endl;

return false;

}

std::vector<std::string> names;

const std::string whitespace(" \t\n\v\f\r");

const std::string &app_name = it_name->second;

size_t delimiter = app_name.find_first_of(whitespace);

if (delimiter)

{

size_t cur_pos = 0;

while (std::string::npos != delimiter)

{

std::string name = app_name.substr(cur_pos, delimiter - cur_pos);

names.emplace_back(std::move(name) );

cur_pos = app_name.find_first_not_of(whitespace, delimiter + 1);

delimiter = app_name.find_first_of(whitespace, cur_pos);

}

std::string name = app_name.substr(cur_pos);

names.emplace_back(std::move(name) );

}

auto it_port = app.find("listen");

if (app.cend() == it_port)

{

std::cout << "Error: application port is not set;" << std::endl;

return false;

}

auto it_root_dir = app.find("root_dir");

if (app.cend() == it_root_dir || it_root_dir->second.empty() )

{

std::cout << "Error: application parameter 'root_dir' is not specified;" << std::endl;

return false;

}

auto it_module = app.find("server_module");

if (app.cend() == it_module)

{

std::cout << "Error: application parameter 'server_module' is not specified;" << std::endl;

return false;

}

// TODO: get module realpath

Module module(it_module->second);

if (false == module.is_open() )

{

std::cout << "Error: module '" << it_module->second << "' cannot be open;" << std::endl;

return false;

}

void *(*addr)(void *) = nullptr;

if (false == module.find("application_call", &addr) )

{

std::cout << "Error: function 'application_call' not found in module '" << it_module->second << "';" << std::endl;

return false;

}

std::function<int(server_request *, server_response *)> app_call = reinterpret_cast<int(*)(server_request *, server_response *)>(addr);

if ( ! app_call)

{

std::cout << "Error: invalid function 'application_call' in module '" << it_module->second << "';" << std::endl;

return false;

}

if (false == module.find("application_clear", &addr) )

{

std::cout << "Error: function 'application_clear' not found in module '" << it_module->second << "';" << std::endl;

return false;

}

std::function<void(Utils::raw_pair [], const size_t)> app_clear = reinterpret_cast<void(*)(Utils::raw_pair [], const size_t)>(addr);

std::function<bool()> app_init = std::function<bool()>();

if (module.find("application_init", &addr) )

{

app_init = reinterpret_cast<bool(*)()>(addr);

}

std::function<void()> app_final = std::function<void()>();

if (module.find("application_final", &addr) )

{

app_final = reinterpret_cast<void(*)()>(addr);

}

bool success = true;

try

{

if (app_init)

{

success = app_init();

}

}

catch (...)

{

success = false;

}

if (false == success)

{

std::cout << "Warning: error when initializing application '" << it_module->second << "';" << std::endl;

return false;

}

auto it_temp_dir = app.find("temp_dir");

const std::string temp_dir = app.cend() != it_temp_dir ? it_temp_dir->second : defaults.temp_dir;

auto it_request_max_size = app.find("request_max_size");

const size_t request_max_size = app.cend() != it_request_max_size ? std::strtoull(it_request_max_size->second.c_str(), nullptr, 10) : defaults.request_max_size;

auto it_module_update = app.find("server_module_update");

const std::string module_update = app.cend() != it_module_update ? it_module_update->second : "";

// Calculate module index

size_t module_index = std::numeric_limits<size_t>::max();

for (size_t i = 0; i < modules.size(); ++i)

{

if (modules[i] == module)

{

module_index = i;

break;

}

}

if (std::numeric_limits<size_t>::max() == module_index)

{

module_index = modules.size();

modules.emplace_back(std::move(module) );

}

std::string root_dir = it_root_dir->second;

#ifdef WIN32

if ('\\' == root_dir.back() )

{

root_dir.pop_back();

}

#endif

// Remove back slash from root_dir

if ('/' == root_dir.back() )

{

root_dir.pop_back();

}

// Create application settings struct

ServerApplicationSettings *sets = new ServerApplicationSettings {

std::strtol(it_port->second.c_str(), nullptr, 10),

root_dir,

temp_dir,

request_max_size,

module_index,

it_module->second,

module_update,

app_call,

app_clear,

app_init,

app_final

};

// Add application names in tree

if (names.empty() )

{

apps_tree.addApplication(app_name, sets);

}

else

{

for (size_t i = 0; i < names.size(); ++i)

{

apps_tree.addApplication(names[i], sets);

}

}

return true;

{

std::ifstream file(fileName);

if ( ! file)

{

file.close();

std::cout << "Error: " << fileName << " - cannot be open;" << std::endl;

return false;

}

file.seekg(0, std::ifstream::end);

std::streamsize file_size = file.tellg();

file.seekg(0, std::ifstream::beg);

const std::streamsize file_size_max = 2048 * 1024;

if (file_size_max < file_size)

{

file.close();

std::cout << "Error: " << fileName << " - is too large; max file size = " << file_size_max << " bytes;" << std::endl;

return false;

}

const std::string whitespace(" \t\v\f\r");

std::vector<char> buf(file_size);

file.read(buf.data(), file_size);

const std::string str_buf(buf.cbegin(), buf.cend() );

size_t cur_pos = 0;

size_t end_pos = str_buf.find('\n', cur_pos);

while (std::string::npos != end_pos)

{

cur_pos = str_buf.find_first_not_of(whitespace, cur_pos);

size_t delimiter = str_buf.find_first_of(whitespace, cur_pos);

if (delimiter < end_pos)

{

std::string mime_type = str_buf.substr(cur_pos, delimiter - cur_pos);

if ('#' != mime_type.front() )

{

delimiter = str_buf.find_first_not_of(whitespace, delimiter);

if (delimiter < end_pos)

{

std::string ext = str_buf.substr(delimiter, end_pos - delimiter);

delimiter = ext.find_first_of(whitespace);

if (std::string::npos != delimiter)

{

for (size_t ext_pos = 0; std::string::npos != ext_pos; )

{

std::string ext_unit = ext.substr(ext_pos, std::string::npos != delimiter ? delimiter - ext_pos : std::string::npos);

if (false == ext_unit.empty() )

{

mimes_types.emplace(std::move(ext_unit), mime_type);

}

ext_pos = ext.find_first_not_of(whitespace, delimiter);

delimiter = ext.find_first_of(whitespace, ext_pos);

}

}

else

{

mimes_types.emplace(std::move(ext), std::move(mime_type) );

}

}

}

}

cur_pos = end_pos + 1;

end_pos = str_buf.find('\n', cur_pos);

}

return true;

const std::string &conf_file_name,

std::unordered_map<std::string, std::string> &settings,

std::unordered_map<std::string, std::string> &mimes_types,

std::vector<Module> &modules,

ServerApplicationsTree &apps_tree

)

{

std::string str_buf;

if (false == includeConfigFile(conf_file_name, str_buf) )

{

return false;

}

std::vector<std::unordered_map<std::string, std::string> > applications;

const std::string whitespace(" \t\n\v\f\r");

size_t cur_pos = 0;

size_t end_pos = str_buf.find(';', cur_pos);

size_t block_pos = 0;

while (std::string::npos != end_pos)

{

block_pos = str_buf.find('{', cur_pos);

if (end_pos < block_pos)

{

cur_pos = str_buf.find_first_not_of(whitespace, cur_pos);

size_t delimiter = str_buf.find_first_of(whitespace, cur_pos);

if (delimiter < end_pos)

{

std::string param_name = str_buf.substr(cur_pos, delimiter - cur_pos);

cur_pos = str_buf.find_first_not_of(whitespace, delimiter + 1);

delimiter = str_buf.find_last_not_of(whitespace, end_pos);

std::string param_value = str_buf.substr(cur_pos, delimiter - cur_pos);

if ("include" == param_name)

{

this->includeConfigFile(param_value, str_buf, end_pos + 1);

}

else

{

settings.emplace(std::move(param_name), std::move(param_value) );

}

}

cur_pos = end_pos + 1;

}

else if (std::string::npos != block_pos)

{

cur_pos = str_buf.find_first_not_of(whitespace, cur_pos);

size_t delimiter = str_buf.find_first_of(whitespace, cur_pos);

const std::string block_type_name = str_buf.substr(cur_pos, delimiter - cur_pos);

delimiter = str_buf.find_first_not_of(whitespace, delimiter);

cur_pos = block_pos + 1;

size_t block_end = str_buf.find('}', cur_pos);

if (delimiter == block_pos)

{

if ("server" == block_type_name)

{

std::unordered_map<std::string, std::string> app;

end_pos = str_buf.find(';', cur_pos);

while (block_end > end_pos)

{

cur_pos = str_buf.find_first_not_of(whitespace, cur_pos);

delimiter = str_buf.find_first_of(whitespace, cur_pos);

if (delimiter < end_pos)

{

std::string param_name = str_buf.substr(cur_pos, delimiter - cur_pos);

cur_pos = str_buf.find_first_not_of(whitespace, delimiter + 1);

delimiter = str_buf.find_last_not_of(whitespace, end_pos);

std::string param_value = str_buf.substr(cur_pos, delimiter - cur_pos);

if ("include" == param_name)

{

cur_pos = end_pos + 1;

this->includeConfigFile(param_value, str_buf, cur_pos);

block_end = str_buf.find('}', cur_pos);

}

else

{

app.emplace(std::move(param_name), std::move(param_value) );

}

}

cur_pos = end_pos + 1;

end_pos = str_buf.find(';', cur_pos);

}

applications.emplace_back(std::move(app) );

}

else

{

std::cout << "Warning: " << block_type_name << " - unknown block type;" << std::endl;

}

}

else

{

std::cout << "Warning: after " << block_type_name << " expected '{' ;" << std::endl;

}

cur_pos = block_end + 1;

}

end_pos = str_buf.find(';', cur_pos);

}

auto it_mimes = settings.find("mimes");

if (settings.cend() != it_mimes)

{

this->parseMimes(it_mimes->second, mimes_types);

}

else

{

std::cout << "Warning: mime types file is not set in configuration;" << std::endl;

}

if (false == applications.empty() )

{

auto it_default_temp_dir = settings.find("default_temp_dir");

const std::string default_temp_dir = settings.cend() != it_default_temp_dir ? it_default_temp_dir->second : System::getTempDir();

auto it_default_request_max_size = settings.find("request_max_size");

const size_t default_request_max_size = settings.cend() != it_default_request_max_size ? std::strtoull(it_default_request_max_size->second.c_str(), nullptr, 10) : 0;

ServerApplicationDefaultSettings defaults {

default_temp_dir,

default_request_max_size

};

for (auto &app : applications)

{

this->addApplication(app, defaults, modules, apps_tree);

}

}

if (apps_tree.empty() )

{

std::cout << "Notice: server does not contain applications;" << std::endl;

}

return true;