From 60f0e62c23dd2e1bd84fdaac2f47c40535e91d60 Mon Sep 17 00:00:00 2001 From: Tomasz Sowa Date: Fri, 16 Sep 2011 22:46:42 +0000 Subject: [PATCH] changed: we do not make a 'base redirect' when the request method is POST changed: ConfParser -- now we have spaces (only one level) git-svn-id: svn://ttmath.org/publicrep/winix/trunk@767 e52654a7-88a9-db11-a3e9-0013d4bc506e --- core/app.cpp | 6 + core/config.cpp | 12 +- core/config.h | 12 +- core/confparser.cpp | 590 ++++++++++++++++++++------------ core/confparser.h | 206 +++++++---- core/pluginmsg.h | 3 +- core/users.cpp | 2 + functions/login.cpp | 5 +- functions/login.h | 1 - plugins/groupitem/groupinfo.cpp | 2 +- templates/locale.cpp | 14 +- 11 files changed, 546 insertions(+), 307 deletions(-) diff --git a/core/app.cpp b/core/app.cpp index ff68c13..5303e65 100755 --- a/core/app.cpp +++ b/core/app.cpp @@ -189,6 +189,9 @@ bool App::BaseUrlRedirect() { if( config.base_url.empty() ) return false; + + if( cur.request->method == Request::post ) + return false; if( Equal(config.base_url.c_str(), cur.request->env_http_host) ) return false; @@ -202,6 +205,9 @@ return true; bool App::ShouldChangeToSSL() { + if( cur.request->method == Request::post ) + return false; + if( !config.use_ssl || cur.request->using_ssl ) return false; diff --git a/core/config.cpp b/core/config.cpp index 8391295..8c79124 100755 --- a/core/config.cpp +++ b/core/config.cpp @@ -295,37 +295,37 @@ void Config::CheckPasswd() -std::wstring Config::Text(const wchar_t * name) +std::wstring & Config::Text(const wchar_t * name) { return parser.Text(name); } -std::wstring Config::Text(const wchar_t * name, const wchar_t * def) +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) +std::wstring & Config::Text(const std::wstring & name, const wchar_t * def) { return parser.Text(name, def); } -std::string Config::AText(const wchar_t * name) +std::string & Config::AText(const wchar_t * name) { return parser.AText(name); } -std::string Config::AText(const wchar_t * name, const wchar_t * def) +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) +std::string & Config::AText(const std::wstring & name, const wchar_t * def) { return parser.AText(name, def); } diff --git a/core/config.h b/core/config.h index 90ab28f..55da76b 100755 --- a/core/config.h +++ b/core/config.h @@ -455,12 +455,12 @@ public: Config(); bool ReadConfig(bool errors_to_stdout_, bool stdout_is_closed = true); - std::wstring Text(const wchar_t * name); - std::wstring Text(const wchar_t * name, const wchar_t * def); - std::wstring Text(const std::wstring & name, const std::wstring & def); - std::string AText(const wchar_t * name); - std::string AText(const wchar_t * name, const wchar_t * def); - std::string AText(const std::wstring & name, const std::wstring & def); + std::wstring & Text(const wchar_t * name); + std::wstring & Text(const wchar_t * name, const wchar_t * def); + std::wstring & Text(const std::wstring & name, const wchar_t * def); + std::string & AText(const wchar_t * name); + std::string & AText(const wchar_t * name, const wchar_t * def); + std::string & AText(const std::wstring & name, const wchar_t * def); int Int(const wchar_t *); int Int(const wchar_t * name, int def); diff --git a/core/confparser.cpp b/core/confparser.cpp index 4f56000..04b39e3 100755 --- a/core/confparser.cpp +++ b/core/confparser.cpp @@ -2,7 +2,7 @@ * This file is a part of Winix * and is not publicly distributed * - * Copyright (c) 2008-2010, Tomasz Sowa + * Copyright (c) 2008-2011, Tomasz Sowa * All rights reserved. * */ @@ -10,30 +10,35 @@ #include #include #include "confparser.h" -#include "misc.h" #include "utf8.h" ConfParser::ConfParser() +{ + SetDefault(); +} + + +void ConfParser::SetDefault() { // you can change this separators to what you want // you shoud not use only white characters here (as expected by IsWhite() method) // and new line characters ('\n') - separator = '='; - commentary = '#'; - list_start = '('; - list_end = ')'; - list_delimiter = ','; - split_single = false; - skip_empty = false; + separator = '='; + commentary = '#'; + list_start = '('; + list_end = ')'; + list_delimiter = ','; + split_single = false; + skip_empty = false; use_escape_char = true; - input_as_utf8 = false; + input_as_utf8 = false; - default_str = L""; - default_int = 0; - default_size = 0; - default_bool = false; + default_str = L""; + default_int = 0; + default_size = 0; + default_bool = false; } @@ -55,22 +60,38 @@ void ConfParser::UseEscapeChar(bool escape) } +void ConfParser::UTF8(bool utf) +{ + input_as_utf8 = utf; +} +void ConfParser::Clear() +{ + space.table.clear(); + space.table_single.clear(); + spaces.clear(); + + line = 1; + using_global_space = true; + pchar_ascii = 0; + pchar_unicode = 0; + status = ok; +} + + ConfParser::Status ConfParser::Parse(const char * file_name) { + Clear(); reading_from_file = true; - line = 1; - table.clear(); - table_single.clear(); file.clear(); file.open( file_name ); if( file ) { - status = ParseFile(); + Parse(); file.close(); } else @@ -108,15 +129,12 @@ ConfParser::Status ConfParser::Parse(const std::wstring & file_name) ConfParser::Status ConfParser::ParseString(const char * str) { + Clear(); reading_from_file = false; reading_from_wchar_string = false; - line = 1; - table.clear(); - table_single.clear(); - pchar_ascii = str; - pchar_unicode = 0; + pchar_ascii = str; - status = ParseFile(); + Parse(); return status; } @@ -130,15 +148,12 @@ ConfParser::Status ConfParser::ParseString(const std::string & str) ConfParser::Status ConfParser::ParseString(const wchar_t * str) { + Clear(); reading_from_file = false; reading_from_wchar_string = true; - line = 1; - table.clear(); - table_single.clear(); - pchar_ascii = 0; - pchar_unicode = str; + pchar_unicode = str; - status = ParseFile(); + Parse(); return status; } @@ -150,35 +165,89 @@ ConfParser::Status ConfParser::ParseString(const std::wstring & str) } -ConfParser::Status ConfParser::ParseFile() +void ConfParser::Parse() { + status = ok; ReadChar(); SkipWhiteLines(); - while( lastc != -1 ) + while( status == ok && lastc != -1 ) { - if( !ReadVariable() ) - return syntax_error; + if( lastc == list_end ) + { + TestListEnd(); + } + else + { + ReadVariable(); - if( lastc != separator ) - return syntax_error; - - if( !ReadValue() ) - return syntax_error; + if( lastc == list_start ) + { + TestListStart(); + } + else + if( lastc == separator && !variable.empty() ) + { + ReadAddValue(); + } + else + { + status = syntax_error; + } + } - AddOption(); - SkipWhite(); - - if( lastc != -1 && lastc != '\n' ) - return syntax_error; // some characters have left at the end of an option - - SkipWhiteLines(); + if( status == ok ) + SkipWhiteLines(); } - -return ok; } +void ConfParser::TestListEnd() +{ + if( using_global_space ) + { + // there cannot be a loose list end character in the global space + status = syntax_error; + } + else + { + using_global_space = true; + ReadChar(); + } +} + + +void ConfParser::TestListStart() +{ + if( using_global_space ) + { + spaces.insert(spaces.end(), Space()); + spaces.back().name = variable; + using_global_space = false; + ReadChar(); + } + else + { + // only one additional level of spaces is allowed + status = syntax_error; + } +} + + +void ConfParser::ReadAddValue() +{ + ReadChar(); // skipping separator '=' + + if( ReadValue() ) + { + AddOption(); + } + else + { + status = syntax_error; + } +} + bool ConfParser::IsVariableChar(int c) { @@ -192,6 +261,105 @@ return false; } +bool ConfParser::IsWhite(int c) +{ + // dont use '\n' here + // 13 (\r) is at the end of a line in a dos file \r\n + // 160 is an unbreakable space + if( c==' ' || c=='\t' || c==13 || c==160 ) + return true; + +return false; +} + + + +void ConfParser::SkipWhite() +{ + while( IsWhite(lastc) || lastc == commentary ) + { + if( lastc == commentary ) + SkipLine(); + else + ReadChar(); + } +} + + +void ConfParser::SkipWhiteLines() +{ + while( IsWhite(lastc) || lastc == commentary || lastc=='\n' ) + { + if( lastc == commentary ) + SkipLine(); + else + ReadChar(); + } +} + + +void ConfParser::SkipLine() +{ + while( lastc != -1 && lastc != '\n' ) + ReadChar(); +} + + + +void ConfParser::Trim(std::wstring & s) +{ +std::wstring::size_type i; + + if( s.empty() ) + return; + + // looking for white characters at the end + for(i=s.size()-1 ; i>0 && IsWhite(s[i]) ; --i); + + if( i==0 && IsWhite(s[i]) ) + { + // the whole string has white characters + s.clear(); + return; + } + + // deleting white characters at the end + if( i != s.size() - 1 ) + s.erase(i+1, std::wstring::npos); + + // looking for white characters at the beginning + for(i=0 ; i='A' && c<='Z' ) + c = c - 'A' + 'a'; + +return c; +} + + +bool ConfParser::EqualNoCase(const wchar_t * str1, const wchar_t * str2) +{ + while( *str1 && *str2 && ToSmall(*str1) == ToSmall(*str2) ) + { + ++str1; + ++str2; + } + + if( *str1 == 0 && *str2 == 0 ) + return true; + +return false; +} + + void ConfParser::AddOption() { @@ -202,14 +370,19 @@ void ConfParser::AddOption() return; } + Space * ps = &space; + + if( !using_global_space && !spaces.empty() ) + ps = &spaces.back(); + if( split_single && value.size() == 1 ) { - table_single[variable] = value[0]; + ps->table_single[variable] = value[0]; DeleteFromTable(variable); } else { - table[variable] = value; + ps->table[variable] = value; DeleteFromTableSingle(variable); } } @@ -218,25 +391,35 @@ void ConfParser::AddOption() void ConfParser::DeleteFromTable(const std::wstring & var) { - Table::iterator i = table.find(var); + Space * ps = &space; - if( i != table.end() ) - table.erase(i); + if( !using_global_space && !spaces.empty() ) + ps = &spaces.back(); + + Table::iterator i = ps->table.find(var); + + if( i != ps->table.end() ) + ps->table.erase(i); } void ConfParser::DeleteFromTableSingle(const std::wstring & var) { - TableSingle::iterator i = table_single.find(var); + Space * ps = &space; - if( i != table_single.end() ) - table_single.erase(i); + if( !using_global_space && !spaces.empty() ) + ps = &spaces.back(); + + TableSingle::iterator i = ps->table_single.find(var); + + if( i != ps->table_single.end() ) + ps->table_single.erase(i); } -bool ConfParser::ReadVariable() +void ConfParser::ReadVariable() { variable.clear(); SkipWhite(); @@ -248,8 +431,6 @@ bool ConfParser::ReadVariable() } SkipWhite(); - -return !variable.empty(); } @@ -257,7 +438,6 @@ return !variable.empty(); bool ConfParser::ReadValue() { value.clear(); - ReadChar(); // skipping separator '=' SkipWhite(); if( lastc == list_start ) @@ -351,10 +531,10 @@ bool ConfParser::ReadValueSimple(bool use_list_delimiter) int list_delimiter2 = -1; if( use_list_delimiter ) - { list_delimiter1 = list_delimiter; + + if( use_list_delimiter || !using_global_space ) list_delimiter2 = list_end; - } while( lastc!=-1 && lastc!='\n' && lastc!=commentary && lastc!=list_delimiter1 && lastc!=list_delimiter2 ) @@ -490,148 +670,128 @@ int ConfParser::ReadChar() } -bool ConfParser::IsWhite(int c) + + + +bool ConfParser::Space::GetValue(const wchar_t * name, std::wstring & out) { - // dont use '\n' here - // 13 (\r) is at the end of a line in a dos file \r\n - // 160 is an unbreakable space - if( c==' ' || c=='\t' || c==13 || c==160 ) - return true; - -return false; + tmp_name = name; + return GetValue(tmp_name, out, L""); } - -void ConfParser::SkipWhite() +bool ConfParser::Space::GetValue(const wchar_t * name, std::wstring & out, const wchar_t * def) { - while( IsWhite(lastc) || lastc == commentary ) - { - if( lastc == commentary ) - SkipLine(); - else - ReadChar(); - } + tmp_name = name; + return GetValue(tmp_name, out, def); } -void ConfParser::SkipWhiteLines() +bool ConfParser::Space::GetValue(const std::wstring & name, std::wstring & out) { - while( IsWhite(lastc) || lastc == commentary || lastc=='\n' ) - { - if( lastc == commentary ) - SkipLine(); - else - ReadChar(); - } + return GetValue(name, out, L""); } -void ConfParser::SkipLine() -{ - while( lastc != -1 && lastc != '\n' ) - ReadChar(); -} - - - -void ConfParser::Trim(std::wstring & s) -{ -std::wstring::size_type i; - - if( s.empty() ) - return; - - // looking for white characters at the end - for(i=s.size()-1 ; i>0 && IsWhite(s[i]) ; --i); - - if( i==0 && IsWhite(s[i]) ) - { - // the whole string has white characters - s.clear(); - return; - } - - // deleting white characters at the end - if( i != s.size() - 1 ) - s.erase(i+1, std::wstring::npos); - - // looking for white characters at the beginning - for(i=0 ; isecond; + return true; + } + else { Table::iterator t = table.find(name); if( t == table.end() || t->second.empty() ) - return def; - - return t->second[0]; + { + out = def; + return false; + } + else + { + out = t->second[0]; + return true; + } } - -return i->second; } -std::string ConfParser::AText(const wchar_t * name) + +void ConfParser::ToText(const wchar_t * name, std::wstring & out) { -std::wstring res = Text(name); -std::string ares; + tmp_name = name; + return ToText(tmp_name, out, default_str.c_str()); +} - Ezc::WideToUTF8(res, ares); -return ares; +void ConfParser::ToText(const wchar_t * name, std::wstring & out, const wchar_t * def) +{ + tmp_name = name; + return ToText(tmp_name, out, def); +} + + +void ConfParser::ToText(const std::wstring & name, std::wstring & out, const wchar_t * def) +{ + space.GetValue(name, out, def); } -std::string ConfParser::AText(const wchar_t * name, const wchar_t * def) + +std::wstring & ConfParser::Text(const wchar_t * name) { -std::wstring res = Text(name, def); -std::string ares; - - Ezc::WideToUTF8(res, ares); - -return ares; + ToText(name, tmp_value_text); + return tmp_value_text; } -std::string ConfParser::AText(const std::wstring & name, const std::wstring & def) + +std::wstring & ConfParser::Text(const wchar_t * name, const wchar_t * def) { -std::wstring res = Text(name, def); -std::string ares; + ToText(name, tmp_value_text, def); + return tmp_value_text; +} - Ezc::WideToUTF8(res, ares); -return ares; +std::wstring & ConfParser::Text(const std::wstring & name, const wchar_t * def) +{ + ToText(name, tmp_value_text, def); + return tmp_value_text; +} + + + +std::string & ConfParser::AText(const wchar_t * name) +{ + ToText(name, tmp_value_text); + Ezc::WideToUTF8(tmp_value_text, tmp_value_text_ascii); + +return tmp_value_text_ascii; +} + + + +std::string & ConfParser::AText(const wchar_t * name, const wchar_t * def) +{ + ToText(name, tmp_value_text, def); + Ezc::WideToUTF8(tmp_value_text, tmp_value_text_ascii); + +return tmp_value_text_ascii; +} + + +std::string & ConfParser::AText(const std::wstring & name, const wchar_t * def) +{ + ToText(name, tmp_value_text, def); + Ezc::WideToUTF8(tmp_value_text, tmp_value_text_ascii); + +return tmp_value_text_ascii; } @@ -639,13 +799,15 @@ return ares; int ConfParser::Int(const wchar_t * name) { - return Int(std::wstring(name), default_int); + tmp_name = name; + return Int(tmp_name, default_int); } int ConfParser::Int(const wchar_t * name, int def) { - return Int(std::wstring(name), def); + tmp_name = name; + return Int(tmp_name, def); } @@ -659,32 +821,25 @@ return static_cast(res); int ConfParser::Int(const std::wstring & name, int def) { - TableSingle::iterator i = table_single.find(name); - - if( i == table_single.end() ) - { - Table::iterator t = table.find(name); + if( space.GetValue(name, tmp_value_text) ) + return ToInt(tmp_value_text); - if( t == table.end() || t->second.empty() ) - return def; - - return ToInt(t->second[0]); - } - -return ToInt(i->second); +return def; } size_t ConfParser::Size(const wchar_t * name) { - return Size(std::wstring(name), default_size); + tmp_name = name; + return Size(tmp_name, default_size); } size_t ConfParser::Size(const wchar_t * name, size_t def) { - return Size(std::wstring(name), def); + tmp_name = name; + return Size(tmp_name, def); } @@ -699,19 +854,10 @@ return static_cast(res); size_t ConfParser::Size(const std::wstring & name, size_t def) { - TableSingle::iterator i = table_single.find(name); - - if( i == table_single.end() ) - { - Table::iterator t = table.find(name); + if( space.GetValue(name, tmp_value_text) ) + return ToSize(tmp_value_text); - if( t == table.end() || t->second.empty() ) - return def; - - return ToSize(t->second[0]); - } - -return ToSize(i->second); +return def; } @@ -719,16 +865,19 @@ return ToSize(i->second); bool ConfParser::Bool(const wchar_t * name) { - return Bool(std::wstring(name), default_bool); + tmp_name = name; + return Bool(tmp_name, default_bool); } bool ConfParser::Bool(const wchar_t * name, bool def) { - return Bool(std::wstring(name), def); + tmp_name = name; + return Bool(tmp_name, def); } + bool ConfParser::ToBool(const std::wstring & value) { return ( EqualNoCase(value.c_str(), L"true") || @@ -740,22 +889,18 @@ bool ConfParser::ToBool(const std::wstring & value) bool ConfParser::Bool(const std::wstring & name, bool def) { - TableSingle::iterator i = table_single.find(name); - - if( i == table_single.end() ) - { - Table::iterator t = table.find(name); + if( space.GetValue(name, tmp_value_text) ) + return ToBool(tmp_value_text); - if( t == table.end() || t->second.empty() ) - return def; - - return ToBool(t->second[0]); - } - -return ToBool(i->second); +return def; } +void ConfParser::SetDefaultText(const wchar_t * def) +{ + default_str = def; +} + void ConfParser::SetDefaultText(const std::wstring & def) { default_str = def; @@ -782,45 +927,38 @@ void ConfParser::SetDefaultBool(bool def) // in lists we don't use default values void ConfParser::ListText(const wchar_t * name, std::vector & list) { - ListText(std::wstring(name), list); + tmp_name = name; + ListText(tmp_name, list); } void ConfParser::ListText(const std::wstring & name, std::vector & list) { list.clear(); - - ConfParser::TableSingle::iterator i = table_single.find(name); + ConfParser::TableSingle::iterator i = space.table_single.find(name); - if( i != table_single.end() ) + if( i != space.table_single.end() ) { list.push_back(i->second); - return; } - - ConfParser::Table::iterator z = table.find(name); - - if( z != table.end() ) + else { - list = z->second; - return; + ConfParser::Table::iterator z = space.table.find(name); + + if( z != space.table.end() ) + list = z->second; } } -void ConfParser::UTF8(bool utf) -{ - input_as_utf8 = utf; -} - void ConfParser::Print(std::ostream & out) { TableSingle::iterator i1; - for(i1 = table_single.begin() ; i1 != table_single.end() ; ++i1) + for(i1 = space.table_single.begin() ; i1 != space.table_single.end() ; ++i1) { Ezc::WideToUTF8(i1->first, out); out << '='; @@ -831,7 +969,7 @@ void ConfParser::Print(std::ostream & out) Table::iterator i2; Value::iterator i3; - for(i2 = table.begin() ; i2 != table.end() ; ++i2) + for(i2 = space.table.begin() ; i2 != space.table.end() ; ++i2) { Ezc::WideToUTF8(i2->first, out); out << '='; diff --git a/core/confparser.h b/core/confparser.h index 5c0ff0c..5435f91 100755 --- a/core/confparser.h +++ b/core/confparser.h @@ -2,7 +2,7 @@ * This file is a part of Winix * and is not publicly distributed * - * Copyright (c) 2008-2010, Tomasz Sowa + * Copyright (c) 2008-2011, Tomasz Sowa * All rights reserved. * */ @@ -13,6 +13,7 @@ #include #include #include +#include #include @@ -130,9 +131,28 @@ class ConfParser { public: + + /* + ctor -- setting default values (SetDefault() method) + */ ConfParser(); + /* + setting options of the parser to the default values + utf8, split single etc. + */ + void SetDefault(); + + + /* + clearing + this method doesn't call SetDefault() only those parsed values are cleared + and the status is set to 'ok' + */ + void Clear(); + + /* status of parsing */ @@ -146,7 +166,13 @@ public: /* - the main methods used to parse + a number of a line in which there is a syntax_error + */ + int line; + + + /* + main methods used to parse file_name is the path to a file */ Status Parse(const char * file_name); @@ -154,47 +180,23 @@ public: Status Parse(const wchar_t * file_name); Status Parse(const std::wstring & file_name); + /* - the main methods used to parse - str - input string (either 8bit ascii or UTF-8) + main methods used to parse + str - input string (either 8bit ascii or UTF-8 -- see UTF8() method) */ Status ParseString(const char * str); Status ParseString(const std::string & str); - // here input string is always in unicode + + /* + main methods used to parse + here input string is always in unicode (wide characters) + */ Status ParseString(const wchar_t * str); Status ParseString(const std::wstring & str); - - /* - a number of a line in which there is a syntax_error - */ - int line; - - - /* - this is the table which represents your config file - in the Table map: the first (key) is your 'option' and the second is 'list' - */ - typedef std::vector Value; - typedef std::map Table; - Table table; - - - /* - if your config file consists mainly of single forms such as: - option = value - option2 = value2 - then you can call SplitSingle(true) for not inserting single values to - previous 'table' but instead to 'table_single' - table_single as the second parameter takes only std::wstring (instead of the whole std::vector) - so you can save a little memory from not using std::vector - */ - typedef std::map TableSingle; - TableSingle table_single; - - /* if your list consists of only one item, e.g: option1 = value 1 @@ -208,7 +210,7 @@ public: /* - if true then empty lists, e.g: + if true then empty values and lists, e.g: option = option2 = () will be omitted (not inserted to 'table' or 'table_single') @@ -227,27 +229,42 @@ public: /* - those methods are used to extract information from table or table_single + if true then the input file or string (char* or std::string) is treated as UTF-8 + */ + void UTF8(bool utf); + + + + /* + those methods are used to extract information from space.table or space.table_single as a parameter they take the name of an option and a default value (if there is no such a parameter), they return appropriate value (either text, int or boolean) (in lists they return the first item if exists) + + when calling Text(...) and AText(...) you should copy the object to whom a reference is returned + it will be cleared in a next call to one of these methods (as well to Int() Size() and Bool()) + + AText(...) always returns a reference to UTF-8 string */ - std::wstring Text(const wchar_t * name); - std::wstring Text(const wchar_t * name, const wchar_t * def); - std::wstring Text(const std::wstring & name, const std::wstring & def); - std::string AText(const wchar_t * name); - std::string AText(const wchar_t * name, const wchar_t * def); - std::string AText(const std::wstring & name, const std::wstring & def); + void ToText(const wchar_t * name, std::wstring & out); + void ToText(const wchar_t * name, std::wstring & out, const wchar_t * def); + void ToText(const std::wstring & name, std::wstring & out, const wchar_t * def); + std::wstring & Text(const wchar_t * name); + std::wstring & Text(const wchar_t * name, const wchar_t * def); + std::wstring & Text(const std::wstring & name, const wchar_t * def); + std::string & AText(const wchar_t * name); + std::string & AText(const wchar_t * name, const wchar_t * def); + std::string & AText(const std::wstring & name, const wchar_t * def); int Int(const wchar_t *); - int Int(const wchar_t * name, int def); - int Int(const std::wstring & name, int def); + int Int(const wchar_t * name, int def); + int Int(const std::wstring & name, int def); size_t Size(const wchar_t *); - size_t Size(const wchar_t * name, size_t def); - size_t Size(const std::wstring & name, size_t def); + size_t Size(const wchar_t * name, size_t def); + size_t Size(const std::wstring & name, size_t def); bool Bool(const wchar_t *); - bool Bool(const wchar_t * name, bool def); - bool Bool(const std::wstring & name, bool def); + bool Bool(const wchar_t * name, bool def); + bool Bool(const std::wstring & name, bool def); /* @@ -259,6 +276,7 @@ public: default int or size is: 0 default bool is: false */ + void SetDefaultText(const wchar_t * def); void SetDefaultText(const std::wstring & def); void SetDefaultInt(int def); void SetDefaultSize(size_t def); @@ -273,12 +291,6 @@ public: void ListText(const std::wstring & name, std::vector & list); - /* - if true then the input file is treated as UTF-8 - */ - void UTF8(bool utf); - - /* printing the content (for debug purposes) @@ -286,6 +298,67 @@ public: void Print(std::ostream & out); + /* + * + * + raw access to the parsed values + * + * + */ + + /* + this is the table which represents your config file + in the Table map: the first (key) is your 'option' and the second is 'list' + */ + typedef std::vector Value; + typedef std::map Table; + + + + /* + if your config file consists mainly of single forms such as: + option = value + option2 = value2 + then you can call SplitSingle(true) for not inserting single values to + previous 'table' but instead to 'table_single' + table_single as the second parameter takes only std::wstring (instead of the whole std::vector) + so you can save a little memory from not using std::vector + */ + typedef std::map TableSingle; + + + + class Space + { + public: + std::wstring name; // space name + TableSingle table_single; // std::map + Table table; // std::map > + + // first we are searching in 'table_single' and if there is not + // such a 'name' there then we are looking in 'table' (for the first item in the vector) + // these methods return true if 'name' was found + // in other case they return false and 'out' will be equal 'def' + bool GetValue(const wchar_t * name, std::wstring & out); + bool GetValue(const wchar_t * name, std::wstring & out, const wchar_t * def); + bool GetValue(const std::wstring & name, std::wstring & out); + bool GetValue(const std::wstring & name, std::wstring & out, const wchar_t * def); + + private: + std::wstring tmp_name; + std::wstring tmp_value; + }; + + // one global space (without a name) + Space space; + + // first namespace + typedef std::list Spaces; + Spaces spaces; + + + + private: @@ -295,6 +368,7 @@ private: */ bool reading_from_file; + /* pointers to the current character if ParseString() is in used @@ -304,10 +378,11 @@ private: /* - true if ParseString(wchar_t *) or ParseString(std::wstring&) is used + true if ParseString(wchar_t *) or ParseString(std::wstring&) was called */ bool reading_from_wchar_string; + /* last read variable (option) */ @@ -398,6 +473,12 @@ private: */ bool use_escape_char; + /* + if true we are parsing the global space + if false we are adding to the last item from spaces tab + */ + bool using_global_space; + std::string afile_name; std::wstring default_str; @@ -405,17 +486,24 @@ private: size_t default_size; bool default_bool; + std::wstring tmp_name; + std::wstring tmp_value_text; + std::string tmp_value_text_ascii; + int ToInt(const std::wstring & value); size_t ToSize(const std::wstring & value); bool ToBool(const std::wstring & value); - Status ParseFile(); + void Parse(); + void TestListEnd(); + void TestListStart(); + void ReadAddValue(); void AddOption(); void DeleteFromTable(const std::wstring & var); void DeleteFromTableSingle(const std::wstring & var); - bool ReadVariable(); + void ReadVariable(); bool ReadValue(); bool ReadValueList(); bool ReadValueNoList(bool use_list_delimiter = false); @@ -433,7 +521,9 @@ private: void SkipWhite(); void SkipWhiteLines(); void SkipLine(); - void Trim(std::wstring & s); + void Trim(std::wstring & s); + wchar_t ToSmall(wchar_t c); + bool EqualNoCase(const wchar_t * str1, const wchar_t * str2); }; diff --git a/core/pluginmsg.h b/core/pluginmsg.h index 0a6222a..a27d84f 100755 --- a/core/pluginmsg.h +++ b/core/pluginmsg.h @@ -77,7 +77,8 @@ // for adding a new mount type call: system->mounts.AddMountType("new_mount_name") #define WINIX_ADD_MOUNTS 3009 -// add plugin functions here +// add plugin functions (winix functions) here +// call info.functions->Add() to add a function #define WINIX_CREATE_FUNCTIONS 3010 // choose a default function diff --git a/core/users.cpp b/core/users.cpp index 3c346f6..1965490 100755 --- a/core/users.cpp +++ b/core/users.cpp @@ -149,6 +149,8 @@ void Users::LoginUser(long user_id, bool remember_me) cur->session->remember_me = remember_me; last.UserLogin(user_id, cur->session->puser->name, inet_addr(cur->request->env_remote_addr), cur->session->id); + + // !! jesli uzytkownik ponownie sie loguje ten sam na ta sama sesje to mozna nie zwiekszac licznika how_many_logged += 1; log << log2 << "User " << cur->session->puser->name << " (id: " << user_id << ") logged" << logend; diff --git a/functions/login.cpp b/functions/login.cpp index bb1f8ff..eab02e3 100755 --- a/functions/login.cpp +++ b/functions/login.cpp @@ -103,6 +103,9 @@ void Login::MakePost() return; } + if( cur->session->puser ) + system->users.LogoutCurrentUser(); + const std::wstring & login = cur->request->PostVar(L"login"); const std::wstring & pass = cur->request->PostVar(L"password"); const std::wstring & remem = cur->request->PostVar(L"rememberme"); @@ -114,7 +117,7 @@ void Login::MakePost() } else { - // !! moze zglosic komunikat o nie poprawnym logowaniu + log << log2 << "Login: incorrect login/password" << logend; } system->RedirectToLastItem(); diff --git a/functions/login.h b/functions/login.h index 48885a5..e117626 100755 --- a/functions/login.h +++ b/functions/login.h @@ -29,7 +29,6 @@ public: private: - void LoginUser(long user_id, bool remember_me); void ClearTmpStruct(); bool CheckPasswords(const std::wstring & password); diff --git a/plugins/groupitem/groupinfo.cpp b/plugins/groupitem/groupinfo.cpp index 222728f..ebd0fd1 100755 --- a/plugins/groupitem/groupinfo.cpp +++ b/plugins/groupitem/groupinfo.cpp @@ -50,7 +50,7 @@ bool GroupInfo::ParseGroups(const std::wstring & str, Groups & groups) { ConfParser::Table::iterator i; - for(i=conf_parser.table.begin() ; i!=conf_parser.table.end() ; ++i) + for(i=conf_parser.space.table.begin() ; i!=conf_parser.space.table.end() ; ++i) { groups.AddGroup(); log << log1 << "stworzylem nowa grupe" << logend; diff --git a/templates/locale.cpp b/templates/locale.cpp index 01b50d2..6d36bf0 100755 --- a/templates/locale.cpp +++ b/templates/locale.cpp @@ -85,16 +85,16 @@ return read; void Locale::AddLocale(size_t lang) { - ConfParser::TableSingle::iterator i = loc_parser.table_single.begin(); + ConfParser::TableSingle::iterator i = loc_parser.space.table_single.begin(); - for( ; i != loc_parser.table_single.end() ; ++i) + for( ; i != loc_parser.space.table_single.end() ; ++i) loc_tab[lang][i->first] = i->second; // lists - ConfParser::Table::iterator i2 = loc_parser.table.begin(); + ConfParser::Table::iterator i2 = loc_parser.space.table.begin(); - for( ; i2 != loc_parser.table.end() ; ++i2) + for( ; i2 != loc_parser.space.table.end() ; ++i2) loc_tab_multi[lang][i2->first] = i2->second; } @@ -132,9 +132,9 @@ bool read = false; if( loc_parser.Parse(file_name) == ConfParser::ok ) { read = true; - CreateSubstVector(subst_url, loc_parser.table_single[L"url_original"], loc_parser.table_single[L"url_changeto"]); - CreateSubstVector(subst_smalllet, loc_parser.table_single[L"smallleters"], loc_parser.table_single[L"capitalics"]); - CreateSubstVector(subst_capitallet, loc_parser.table_single[L"capitalics"], loc_parser.table_single[L"smallleters"]); + CreateSubstVector(subst_url, loc_parser.space.table_single[L"url_original"], loc_parser.space.table_single[L"url_changeto"]); + CreateSubstVector(subst_smalllet, loc_parser.space.table_single[L"smallleters"], loc_parser.space.table_single[L"capitalics"]); + CreateSubstVector(subst_capitallet, loc_parser.space.table_single[L"capitalics"], loc_parser.space.table_single[L"smallleters"]); log << log3 << "Locale: read characters substitution tables from: " << file_name << logend; }