343 lines
8.2 KiB
C++
Executable File
343 lines
8.2 KiB
C++
Executable File
/*
|
|
* This file is a part of Winix
|
|
* and is not publicly distributed
|
|
*
|
|
* Copyright (c) 2008-2010, Tomasz Sowa
|
|
* All rights reserved.
|
|
*
|
|
*/
|
|
|
|
#include "config.h"
|
|
#include "log.h"
|
|
#include "plugin.h"
|
|
#include "misc.h"
|
|
|
|
|
|
|
|
Config::Config()
|
|
{
|
|
errors_to_stdout = true;
|
|
}
|
|
|
|
|
|
|
|
//!! czy tu w ogole mozemy uzywac log << ?
|
|
//!! przeciez jeszcze nie zostal przetworzony plik konfiguracyjny
|
|
|
|
|
|
void Config::ShowError()
|
|
{
|
|
|
|
switch( parser.status )
|
|
{
|
|
case ConfParser::ok:
|
|
log << log2 << "Config: syntax ok" << logend;
|
|
break;
|
|
|
|
case ConfParser::cant_open_file:
|
|
if( errors_to_stdout )
|
|
std::cout << "Config: cant open a config file: " << config_file << std::endl;
|
|
|
|
log << log1 << "Config: cant open a config file: " << config_file << logend;
|
|
break;
|
|
|
|
case ConfParser::syntax_error:
|
|
if( errors_to_stdout )
|
|
std::cout << "Config: syntax error, line: " << parser.line << std::endl;
|
|
|
|
log << log1 << "Config: syntax error, line: " << parser.line << logend;
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
bool Config::ReadConfig(bool errors_to_stdout_, bool stdout_is_closed)
|
|
{
|
|
errors_to_stdout = errors_to_stdout_;
|
|
|
|
if( config_file.empty() )
|
|
{
|
|
log << log2 << "Config: name of the config file is empty" << logend;
|
|
return false;
|
|
}
|
|
|
|
log << log2 << "Config: reading a config file" << logend;
|
|
|
|
parser.SplitSingle(true);
|
|
parser.UTF8(true); // config is always read in UTF-8
|
|
ConfParser::Status status = parser.Parse( config_file );
|
|
|
|
|
|
if( status == ConfParser::ok )
|
|
{
|
|
AssignValues(stdout_is_closed);
|
|
SetAdditionalVariables();
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
ShowError();
|
|
return false;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
void Config::AssignValues(bool stdout_is_closed)
|
|
{
|
|
demonize = Bool(L"demonize", true);
|
|
|
|
user = AText(L"user");
|
|
group = AText(L"group");
|
|
additional_groups = Bool(L"additional_groups", true);
|
|
|
|
log_file = AText(L"log_file");
|
|
log_notify_file = AText(L"log_notify_file");
|
|
log_delimiter = Text(L"log_delimiter", L"---------------------------------------------------------------------------------");
|
|
fcgi_socket = AText(L"fcgi_socket");
|
|
fcgi_socket_chmod = Int(L"fcgi_socket_chmod", 0770);
|
|
fcgi_socket_user = AText(L"fcgi_socket_user");
|
|
fcgi_socket_group = AText(L"fcgi_socket_group");
|
|
log_level = Int(L"log_level", 1);
|
|
log_request = Int(L"log_request", 1);
|
|
log_stdout = Bool(L"log_stdout", false);
|
|
log_db_query = Bool(L"log_db_query", false);
|
|
log_plugin_call = Bool(L"log_plugin_call", false);
|
|
|
|
post_file_max = Size(L"post_file_max", 8388608); // 8 MB
|
|
auth_simplefs_dir = Text(L"auth_simplefs_dir");
|
|
auth_hashfs_dir = Text(L"auth_hashfs_dir");
|
|
auth_tmp_dir = Text(L"auth_tmp_dir");
|
|
|
|
templates_dir = Text(L"templates_dir");
|
|
templates_dir_default = Text(L"templates_dir_default");
|
|
txt_templates_dir = Text(L"txt_templates_dir");
|
|
txt_templates_dir_default = Text(L"txt_templates_dir_default");
|
|
templates_fun_prefix = Text(L"templates_fun_prefix", L"fun_");
|
|
templates_fun_postfix = Text(L"templates_fun_postfix", L".html");
|
|
templates_index = Text(L"templates_index", L"index.html");
|
|
template_only_root_use_template_fun = Bool(L"template_only_root_use_template_fun", false);
|
|
|
|
http_session_id_name = AText(L"http_session_id_name");
|
|
db_database = AText(L"db_database");
|
|
db_user = AText(L"db_user");
|
|
db_pass = AText(L"db_pass");
|
|
item_url_empty = Text(L"item_url_empty");
|
|
|
|
base_server = Text(L"base_server");
|
|
base_url = Text(L"base_url");
|
|
base_url_auth = Text(L"base_url_auth");
|
|
base_url_static = Text(L"base_url_static");
|
|
base_url_common = Text(L"base_url_common");
|
|
|
|
NoLastSlash(base_server);
|
|
NoLastSlash(base_url);
|
|
NoLastSlash(base_url_auth);
|
|
NoLastSlash(base_url_static);
|
|
NoLastSlash(base_url_common);
|
|
|
|
priv_no_user = Text(L"priv_no_user", L"-- no user --");
|
|
priv_no_group = Text(L"priv_no_group", L"-- no group --");
|
|
|
|
session_max_idle = Int(L"session_max_idle", 10800); // 3h
|
|
session_remember_max_idle = Int(L"session_remember_max_idle", 16070400); // 3 months
|
|
session_file = AText(L"session_file");
|
|
|
|
compression = Bool(L"compression", true);
|
|
compression_page_min_size = Int(L"compression_page_min_size", 512);
|
|
|
|
html_filter = Bool(L"html_filter", true);
|
|
html_filter_trim_white = Bool(L"html_filter_trim_white", true);
|
|
html_filter_break_lines = Int(L"html_filter_break_lines", 60);
|
|
html_filter_tabs = Size(L"html_filter_tabs", 2);
|
|
html_filter_orphans = Bool(L"html_filter_orphans", false);
|
|
html_filter_orphans_lang_str = AText(L"html_filter_orphans_lang", L"pl");
|
|
html_filter_orphans_mode_str = AText(L"html_filter_orphans_mode_str", L"nbsp");
|
|
|
|
locale_str = Text(L"locale", L"en");
|
|
locale_dir = Text(L"locale_dir");
|
|
locale_dir_default = Text(L"locale_dir_default");
|
|
|
|
title_separator = Text(L"title_separator", L" / ");
|
|
|
|
http_header_send_file = Text(L"http_header_send_file", L"X-LIGHTTPD-send-file");
|
|
password_min_size = Size(L"password_min_size", 5);
|
|
debug_info = Bool(L"debug_info", false);
|
|
|
|
editors_html_safe_mode = Bool(L"editors_html_safe_mode", true);
|
|
editors_html_safe_mode_skip_root = Bool(L"editors_html_safe_mode_skip_root", true);
|
|
|
|
plugins_dir = Text(L"plugins_dir", L"/usr/local/winix/plugins");
|
|
NoLastSlash(plugins_dir);
|
|
parser.ListText(L"plugins", plugin_file);
|
|
|
|
time_zone_offset = Int(L"time_zone_offset", 0);
|
|
time_zone_offset_guest = Int(L"time_zone_offset_guest", 0);
|
|
|
|
utf8 = Bool(L"utf8", true);
|
|
}
|
|
|
|
|
|
void Config::SetAdditionalVariables()
|
|
{
|
|
SetHttpHost(base_url, base_url_http_host);
|
|
SetHttpHost(base_url_auth, base_url_auth_http_host);
|
|
|
|
if( html_filter_orphans_lang_str == "pl" )
|
|
html_filter_orphans_lang = HTMLFilter::lang_pl;
|
|
else
|
|
if( html_filter_orphans_lang_str == "cz" )
|
|
html_filter_orphans_lang = HTMLFilter::lang_cz;
|
|
else
|
|
if( html_filter_orphans_lang_str == "sk" )
|
|
html_filter_orphans_lang = HTMLFilter::lang_sk;
|
|
else
|
|
html_filter_orphans_lang = HTMLFilter::lang_none;
|
|
|
|
if( html_filter_orphans_mode_str == "160" )
|
|
html_filter_orphans_mode = HTMLFilter::orphan_160space;
|
|
else
|
|
html_filter_orphans_mode = HTMLFilter::orphan_nbsp;
|
|
}
|
|
|
|
|
|
|
|
|
|
void Config::SetHttpHost(const std::wstring & in, std::wstring & out)
|
|
{
|
|
const char http[] = "http://";
|
|
const char https[] = "https://";
|
|
size_t http_len = sizeof(http) / sizeof(char) - 1;
|
|
size_t https_len = sizeof(https) / sizeof(char) - 1;
|
|
|
|
if( IsSubString(http, in.c_str()) )
|
|
out = in.substr(http_len);
|
|
else
|
|
if( IsSubString(https, in.c_str()) )
|
|
out = in.substr(https_len);
|
|
else
|
|
out.clear(); // if empty the RequestController::BaseUrlRedirect() returns false and no redirecting will be done
|
|
}
|
|
|
|
|
|
std::wstring Config::Text(const wchar_t * name)
|
|
{
|
|
return parser.Text(name);
|
|
}
|
|
|
|
|
|
std::wstring Config::Text(const wchar_t * name, const wchar_t * def)
|
|
{
|
|
return parser.Text(name, def);
|
|
}
|
|
|
|
|
|
std::wstring Config::Text(const std::wstring & name, const std::wstring & def)
|
|
{
|
|
return parser.Text(name, def);
|
|
}
|
|
|
|
|
|
std::string Config::AText(const wchar_t * name)
|
|
{
|
|
return parser.AText(name);
|
|
}
|
|
|
|
|
|
std::string Config::AText(const wchar_t * name, const wchar_t * def)
|
|
{
|
|
return parser.AText(name, def);
|
|
}
|
|
|
|
|
|
std::string Config::AText(const std::wstring & name, const std::wstring & def)
|
|
{
|
|
return parser.AText(name, def);
|
|
}
|
|
|
|
|
|
|
|
int Config::Int(const wchar_t * name)
|
|
{
|
|
return parser.Int(name);
|
|
}
|
|
|
|
|
|
int Config::Int(const wchar_t * name, int def)
|
|
{
|
|
return parser.Int(name, def);
|
|
}
|
|
|
|
|
|
int Config::Int(const std::wstring & name, int def)
|
|
{
|
|
return parser.Int(name, def);
|
|
}
|
|
|
|
|
|
size_t Config::Size(const wchar_t * name)
|
|
{
|
|
return parser.Size(name);
|
|
}
|
|
|
|
|
|
size_t Config::Size(const wchar_t * name, size_t def)
|
|
{
|
|
return parser.Size(name, def);
|
|
}
|
|
|
|
|
|
size_t Config::Size(const std::wstring & name, size_t def)
|
|
{
|
|
return parser.Size(name, def);
|
|
}
|
|
|
|
|
|
bool Config::Bool(const wchar_t * name)
|
|
{
|
|
return parser.Bool(name);
|
|
}
|
|
|
|
|
|
bool Config::Bool(const wchar_t * name, bool def)
|
|
{
|
|
return parser.Bool(name, def);
|
|
}
|
|
|
|
|
|
bool Config::Bool(const std::wstring & name, bool def)
|
|
{
|
|
return parser.Bool(name, def);
|
|
}
|
|
|
|
|
|
|
|
void Config::ListText(const wchar_t * name, std::vector<std::wstring> & list)
|
|
{
|
|
parser.ListText(name, list);
|
|
}
|
|
|
|
|
|
void Config::ListText(const std::wstring & name, std::vector<std::wstring> & list)
|
|
{
|
|
parser.ListText(name, list);
|
|
}
|
|
|
|
|
|
void Config::Print(std::ostream & out)
|
|
{
|
|
parser.Print(out);
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|