410 Commits

Author SHA1 Message Date
f6077da614 Merge branch 'master' into uikit 2021-01-25 17:59:14 +01:00
499db7e3eb fixed: session logger didn't have 'cur' and 'locale' pointers set
but this is a temporary fix, the session logger will be moved to Session class
2021-01-25 17:55:07 +01:00
50da49a3ed added uikit markup for adduser winix function 2021-01-25 17:17:54 +01:00
6afd5c637e added: in account winix function: links to locale and timezone 2021-01-25 16:23:13 +01:00
31a6aac9d3 added uikit markup for locale winix function 2021-01-25 16:15:55 +01:00
3c3660914f added uikit markup for timezone winix function 2021-01-25 16:10:42 +01:00
cd0ae231dc added uikit markup for account winix function 2021-01-25 15:57:37 +01:00
a8bc741883 added uikit markup for vim editor (wymeditor) 2021-01-25 14:34:35 +01:00
05b3525863 changed: version to 0.7.1 2021-01-25 13:14:16 +01:00
337f563bd4 changed html markup for tinymce and added support for 5.6.2 version 2021-01-22 16:56:51 +01:00
c9fe09ebe3 updated locale files 2021-01-22 14:18:50 +01:00
db1c63a350 added html/index_bottom_adder.html template - at the moment empty,
will be used at the bottom of an index template - before </body> tag
2021-01-22 11:50:37 +01:00
7cc2dcd1fc jquery-file-upload updated to 10.31.0 version 2021-01-22 11:50:28 +01:00
bcde392ce3 updated translations 2021-01-21 19:22:26 +01:00
8d046f6280 added UIkit markup for ckeditor winix function 2021-01-21 19:17:33 +01:00
9a6696699f added UIkit markup for emacs winix function 2021-01-21 19:17:06 +01:00
56f2eec597 CodeMirror editor updated to version 5.59.2 - it is used in emacs winix function 2021-01-21 19:08:48 +01:00
d29b33532d added UIkit markup for login winix function 2021-01-21 17:13:27 +01:00
a16e82bf54 updated .gitignore 2021-01-21 17:12:56 +01:00
46c17cc441 added UIkit https://getuikit.com front-end framework to index_head_functions_add.html and index.html 2021-01-21 17:10:04 +01:00
2099092e16 updated .gitignore 2021-01-21 17:08:05 +01:00
88b7517337 dodany plik .gitignore 2021-01-21 11:35:40 +01:00
619236329c Makefile.dep
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@1223 e52654a7-88a9-db11-a3e9-0013d4bc506e
2019-09-26 18:25:21 +00:00
76160a5ba6 Makefile deps
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@1219 e52654a7-88a9-db11-a3e9-0013d4bc506e
2019-09-25 16:25:44 +00:00
e95f32231a fixed: FileLog::get_local_date we need to synchronize when using time_zones pointer
(FileLog::get_local_date is used by Log::PrintDate() and Log of course can be used from different threads)



git-svn-id: svn://ttmath.org/publicrep/winix/trunk@1218 e52654a7-88a9-db11-a3e9-0013d4bc506e
2019-09-25 16:25:20 +00:00
be81307faa Makefiles deps
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@1199 e52654a7-88a9-db11-a3e9-0013d4bc506e
2019-08-20 12:24:22 +00:00
177e58da4e changed: if there is no body we do not parse application/json to space
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@1183 e52654a7-88a9-db11-a3e9-0013d4bc506e
2019-03-25 00:51:51 +00:00
4c2efc08fd fixed: permissions to symlinks and directories with redirect flag were incorrectly checked
(there was no session set and the request was treated the same as from a not logged user)
fixed: in BaseThread there was used 'log' in the main thread (this logger is only for the other thread)
added: in BaseThread we have a main_log now - logger which puts to the main log buffer from the main thread




git-svn-id: svn://ttmath.org/publicrep/winix/trunk@1182 e52654a7-88a9-db11-a3e9-0013d4bc506e
2019-03-19 18:08:09 +00:00
ae03922491 seo plugin: added calling WINIX_FILE_CHANGED
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@1180 e52654a7-88a9-db11-a3e9-0013d4bc506e
2019-03-14 13:46:40 +00:00
ab005118ba added: a new plugin: seo
new winix function: "seo", it allowes to edit subject, description and keywords for a page
description and keywords are stored in meta



git-svn-id: svn://ttmath.org/publicrep/winix/trunk@1179 e52654a7-88a9-db11-a3e9-0013d4bc506e
2019-03-14 13:33:40 +00:00
eec8635af4 changed: templates/item.cpp to use last_item instead of item
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@1178 e52654a7-88a9-db11-a3e9-0013d4bc506e
2019-03-14 13:31:35 +00:00
5060997d2a Makefile.dep
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@1176 e52654a7-88a9-db11-a3e9-0013d4bc506e
2019-03-07 18:02:52 +00:00
0ac5a21a14 Makefile.dep
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@1172 e52654a7-88a9-db11-a3e9-0013d4bc506e
2019-03-06 18:19:29 +00:00
def0f8d144 merge from branch 0.7.x:
- initial support for morm
- added: WinixBase, WinixModel, WinixSystem, WinixRequest
- logger moved to pikotools




git-svn-id: svn://ttmath.org/publicrep/winix/trunk@1171 e52654a7-88a9-db11-a3e9-0013d4bc506e
2019-03-06 11:53:28 +00:00
8895f0dcac - json_generic_serializer was not set when there was a redirect
- if there is a redirect and the json return answer is requested
  then we send 'redirect_to' field in 'info' space




git-svn-id: svn://ttmath.org/publicrep/winix/branches/0.7.x@1169 e52654a7-88a9-db11-a3e9-0013d4bc506e
2019-02-19 10:36:20 +00:00
4f8db81c85 added to Locale:
const std::wstring & GetReplace(const wchar_t * key, Types ... types)
key is a string pattern which has %0, %1 parameters which will be replaced with 'types'




git-svn-id: svn://ttmath.org/publicrep/winix/branches/0.7.x@1164 e52654a7-88a9-db11-a3e9-0013d4bc506e
2019-01-07 03:32:17 +00:00
aa388e248d fixed: crash in thread plugin
ThreadInfo was not correctly initialized (plugin pointer was null)
added to PluginInfo: set_dependency_for(WinixModel * winix_model)




git-svn-id: svn://ttmath.org/publicrep/winix/branches/0.7.x@1162 e52654a7-88a9-db11-a3e9-0013d4bc506e
2019-01-02 11:33:19 +00:00
e5d7403c54 Makefile.dep
git-svn-id: svn://ttmath.org/publicrep/winix/branches/0.7.x@1161 e52654a7-88a9-db11-a3e9-0013d4bc506e
2019-01-02 09:12:42 +00:00
4f57d6134c fixed: in Templates: TemplatesFunctions::plugin was not set
git-svn-id: svn://ttmath.org/publicrep/winix/branches/0.7.x@1160 e52654a7-88a9-db11-a3e9-0013d4bc506e
2019-01-02 04:36:24 +00:00
03f6b54a5b Makefile dep
git-svn-id: svn://ttmath.org/publicrep/winix/branches/0.7.x@1158 e52654a7-88a9-db11-a3e9-0013d4bc506e
2018-11-24 17:09:48 +00:00
63ef007ca1 changed: class Cur -> struct Cur in plugin.h
git-svn-id: svn://ttmath.org/publicrep/winix/branches/0.7.x@1154 e52654a7-88a9-db11-a3e9-0013d4bc506e
2018-11-23 18:34:01 +00:00
603e0679e7 Makefiles: added path to morm/src to -I flags
git-svn-id: svn://ttmath.org/publicrep/winix/branches/0.7.x@1152 e52654a7-88a9-db11-a3e9-0013d4bc506e
2018-11-23 18:28:15 +00:00
b90445de4a updated to the new pikotools api - we have a logger for morm and ezc
pikotools has now Log and FileLog classes
which are base classes for winix Log and FileLog classes




git-svn-id: svn://ttmath.org/publicrep/winix/branches/0.7.x@1151 e52654a7-88a9-db11-a3e9-0013d4bc506e
2018-11-23 17:53:43 +00:00
491dd27ebf some work in the new api:
- log_level and save_each_line moved from Log to FileLog
- other fixes in loggers
- DirContainer from Dirs and LoadAvg had no dependencies set




git-svn-id: svn://ttmath.org/publicrep/winix/branches/0.7.x@1148 e52654a7-88a9-db11-a3e9-0013d4bc506e
2018-11-21 22:53:24 +00:00
89d303f375 some work on dependency injection
git-svn-id: svn://ttmath.org/publicrep/winix/branches/0.7.x@1147 e52654a7-88a9-db11-a3e9-0013d4bc506e
2018-11-21 17:51:15 +00:00
a2ffc1e81c start working on 0.7.x branch
- added FileLog which stores content to the file log
- now Log is only a wrapper - it puts messages to the local buffer and when logsave is used then the buffer is put to FileLog
- new base classes:
  WinixBase (Log, Config*, Synchro*)
  WinixModel : public WinixBase (morm::ModelConnector*, Plugin*)
  WinixSystem : public WinixModel (System*)
  WinixRequest : public WinixSystem (SLog, Cur*)
- singletons: log, slog, plugin are depracated - now references to them are in base classses (WinixBase, WinixModel)
- DbBase,  DbConn and Db are depracated - now we are using Morm project (in WinixModel there is a model_connector pointer)
  each thread will have its own ModelConnector





git-svn-id: svn://ttmath.org/publicrep/winix/branches/0.7.x@1146 e52654a7-88a9-db11-a3e9-0013d4bc506e
2018-11-21 11:03:53 +00:00
a7c47140ae creating branch 0.7.x
git-svn-id: svn://ttmath.org/publicrep/winix/branches/0.7.x@1145 e52654a7-88a9-db11-a3e9-0013d4bc506e
2018-11-21 10:50:34 +00:00
ebd7f85fdb updated: html files for jquery-file-upload
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@1143 e52654a7-88a9-db11-a3e9-0013d4bc506e
2018-11-15 17:01:40 +00:00
833c04776f changed Makefile.dep
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@1141 e52654a7-88a9-db11-a3e9-0013d4bc506e
2018-11-14 17:15:03 +00:00
919c2f62f5 using PT::IsSubString* methods from pikotools
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@1138 e52654a7-88a9-db11-a3e9-0013d4bc506e
2018-11-01 00:46:44 +00:00
8f6004d444 removed some IsSubstring* functions
(they are in Pikotools in text/convert.h now)



git-svn-id: svn://ttmath.org/publicrep/winix/trunk@1135 e52654a7-88a9-db11-a3e9-0013d4bc506e
2018-10-29 23:51:11 +00:00
1b8f5dc673 added to HTMLFilter:
- possibility to remove html entities
  method: SkipEntity(bool)




git-svn-id: svn://ttmath.org/publicrep/winix/trunk@1132 e52654a7-88a9-db11-a3e9-0013d4bc506e
2018-10-24 16:31:42 +00:00
027a8ec428 added to HTMLFilter:
- now we can parse " and ' in html attributes
- we can skip html tags and commentaries, added method:
  void SkipAllTags(bool skip_all_tags, bool skip_commentaries);
- there is virtual method: virtual void ItemFound();
  which is called when a html tag is parsed




git-svn-id: svn://ttmath.org/publicrep/winix/trunk@1129 e52654a7-88a9-db11-a3e9-0013d4bc506e
2018-10-23 23:28:45 +00:00
d1e7765e98 backend winix
dodanie opisu strefy czasowej dla Warszawy na 2018 rok




git-svn-id: svn://ttmath.org/publicrep/winix/trunk@1128 e52654a7-88a9-db11-a3e9-0013d4bc506e
2018-10-23 21:00:36 +00:00
2d1b2e6b6e Makefile.dep
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@1123 e52654a7-88a9-db11-a3e9-0013d4bc506e
2018-07-05 11:15:42 +00:00
350fc551e5 fixed: a default winix function was selected before the mount point was calculated
also a mount point should be cleared (set to an empty mount point) at the
       end of a request




git-svn-id: svn://ttmath.org/publicrep/winix/trunk@1117 e52654a7-88a9-db11-a3e9-0013d4bc506e
2018-07-02 12:02:19 +00:00
1c05c31721 added: antispam mechanism
each html form has a hidden form_id and counter_id
counter_id on the client side is generated through javascript code
on the server the form_id and counter_id is stored in the session
after sending the html form the server checks the form_id and counter_id




git-svn-id: svn://ttmath.org/publicrep/winix/trunk@1116 e52654a7-88a9-db11-a3e9-0013d4bc506e
2018-07-02 11:16:36 +00:00
08123fe6ac changed the algorithm how sessions work:
- if the IP is banned or there is no a winix function then we set a temporary session
- else
  if there is a session's cookie sent by the client then:
   - if the cookie is a correct session's cookie then we set the session from the cookie
   - or if the cookie is not a correct session's cookie (e.g. session expired) and the winix function
     requires a cookie then we set a new session
   - or if there is no cookie sent then if a winix function requires a session we create a new session

  if there was an error creating a new session or event counters reach a ban limit then a temporary session will be used





git-svn-id: svn://ttmath.org/publicrep/winix/trunk@1115 e52654a7-88a9-db11-a3e9-0013d4bc506e
2018-06-20 15:00:02 +00:00
35b93b1655 changed: now we are parsing directories and functions before checking a session
added:   need_session to FunctionBase (true if the functions requires a session)
         default: true
         



git-svn-id: svn://ttmath.org/publicrep/winix/trunk@1114 e52654a7-88a9-db11-a3e9-0013d4bc506e
2018-06-19 13:52:08 +00:00
436a198c36 changed: using PT::ToLower instead of ToSmall
using PT::ToUpper instead of ToCapital
         using PT::EqualNoCase instead of EqualNoCase
         



git-svn-id: svn://ttmath.org/publicrep/winix/trunk@1112 e52654a7-88a9-db11-a3e9-0013d4bc506e
2018-05-25 17:22:12 +00:00
aa58faf145 some work on integrating ckeditor4
added ezc blocks: ckeditor_old_browsers_support, ckeditor, ckeditor_small
defined in ckeditor.html



git-svn-id: svn://ttmath.org/publicrep/winix/trunk@1109 e52654a7-88a9-db11-a3e9-0013d4bc506e
2018-05-10 17:21:39 +00:00
dcc6d35cba added: start integrating CKEditor4
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@1108 e52654a7-88a9-db11-a3e9-0013d4bc506e
2018-05-09 22:48:14 +00:00
3f29cdc01e changed: config parameters: log_check_proxy_ip_header -> check_proxy_ip_header and log_proxy_ip_header -> proxy_ip_header
added: Request::ip_str (std::wstring) (string of the client's IP address)



git-svn-id: svn://ttmath.org/publicrep/winix/trunk@1105 e52654a7-88a9-db11-a3e9-0013d4bc506e
2018-05-01 11:22:55 +00:00
ba7d55b7c1 added: config parameters:
bool log_check_proxy_ip_header;
       // check whether there is a 'log_proxy_ip_header' header
       // and if so then log the IP address from it
       // default: false

       std::wstring log_proxy_ip_header;
       // proxy header representing the real IP address of a client
       // default: X-Real-IP





git-svn-id: svn://ttmath.org/publicrep/winix/trunk@1104 e52654a7-88a9-db11-a3e9-0013d4bc506e
2018-05-01 10:43:20 +00:00
6252a0e732 added: Request::post_in (PT::Space) for input when application/json content type is used
from the client




git-svn-id: svn://ttmath.org/publicrep/winix/trunk@1102 e52654a7-88a9-db11-a3e9-0013d4bc506e
2018-04-26 18:56:31 +00:00
ca14b1a427 added: Request::header_in (Space) http input headers (without cookies)
added: config parameter: log_env_http_variables (bool) (for logging http headers)
added: support for DELETE http method, added method FunctionBase::MakeDelete()
changed: winix version incremented to 0.6.6




git-svn-id: svn://ttmath.org/publicrep/winix/trunk@1100 e52654a7-88a9-db11-a3e9-0013d4bc506e
2018-04-25 19:48:47 +00:00
b01db89942 added config parameter: db_postgresql_smaller_than_10
default false
if true then we are not using ROW() statements in sql queries




git-svn-id: svn://ttmath.org/publicrep/winix/trunk@1099 e52654a7-88a9-db11-a3e9-0013d4bc506e
2018-04-25 09:37:56 +00:00
fd421c54e3 changed: Makefile (added Logger from pikotools)
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@1096 e52654a7-88a9-db11-a3e9-0013d4bc506e
2018-04-23 14:29:58 +00:00
55992b5066 added: std::wstring * Request::ParamValuep(const wchar_t * param_name)
for taking a pointer (can be null) to a parameter value
added: bool System::IsSSLRequired(bool try_to_use_ssl)
       returns true if we should use ssl
       try_to_use_ssl is to be meant: config->use_ssl, config->use_ssl_static, config->use_ssl_common
       



git-svn-id: svn://ttmath.org/publicrep/winix/trunk@1094 e52654a7-88a9-db11-a3e9-0013d4bc506e
2018-04-22 21:26:56 +00:00
a5dfc9974f added: a virtual dctor() for BaseThread class
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@1080 e52654a7-88a9-db11-a3e9-0013d4bc506e
2018-04-16 22:44:59 +00:00
7b4a17c934 changed: makefile dep
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@1076 e52654a7-88a9-db11-a3e9-0013d4bc506e
2018-03-23 19:27:32 +00:00
c2a1097dd5 added: dependency on the morm project
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@1074 e52654a7-88a9-db11-a3e9-0013d4bc506e
2018-03-13 22:34:59 +00:00
ccf78dcb02 updated to the new Pikotools API
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@1071 e52654a7-88a9-db11-a3e9-0013d4bc506e
2018-01-06 18:12:53 +00:00
3eff400d88 added: "assume_connection_is_through_ssl" config parameter
winix is testing an environment variable "HTTPS" for the value "on"
       to think that the connection is made via SSL
       you can set assume_connection_is_through_ssl to true for the winix
       to not testing any environment variables but just think the connection
       was made by https (useful when using proxy)
       default: false




git-svn-id: svn://ttmath.org/publicrep/winix/trunk@1069 e52654a7-88a9-db11-a3e9-0013d4bc506e
2018-01-01 00:14:02 +00:00
5ab816b5be fixed: in progresql 10 we have to use ROW() expression to construct
a row where only one item is given



git-svn-id: svn://ttmath.org/publicrep/winix/trunk@1068 e52654a7-88a9-db11-a3e9-0013d4bc506e
2018-01-01 00:12:33 +00:00
e57840faed fixed: static files loaded to /var such as /var/ckeditor_winix.js were not properly returned
(html filter was used but they are mostly javascript files)
added: new Item::ContentType: ct_other
       if an item has ct_other then the html filter is not used for the content





git-svn-id: svn://ttmath.org/publicrep/winix/trunk@1040 e52654a7-88a9-db11-a3e9-0013d4bc506e
2016-07-13 13:13:56 +00:00
240bf4dc5d changed: the way how raw template is set
option for setting raw template from 'emacs' function has been removed
         now we have index_raw.html template and it can be set from 'template' function
removed: template index_fullscreen.html
changed: some work in miscspace (changed: space_list_tab, space_list_tab_value and space_list_tab_has_next)
fixed:   main index template could not be set through 'template' function





git-svn-id: svn://ttmath.org/publicrep/winix/trunk@1039 e52654a7-88a9-db11-a3e9-0013d4bc506e
2016-04-04 16:02:36 +00:00
abd1500f07 changed: some refactoring in miscspace
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@1036 e52654a7-88a9-db11-a3e9-0013d4bc506e
2016-03-23 15:20:42 +00:00
42144bb31c some refactoring in miscspace(.h|.cpp)
space() renamed to space_value() and takes a third parameter: escape (bool)
space_noescape() removed

space_tab() renamed to space_list_tab()
space_tab_value() renamed to space_list_tab_value()
space_tab_has_next() renamed to space_list_tab_has_next()





git-svn-id: svn://ttmath.org/publicrep/winix/trunk@1035 e52654a7-88a9-db11-a3e9-0013d4bc506e
2016-03-22 14:53:43 +00:00
7ed41a03ae fixed: some paths in Makefile.dep were not relative
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@1031 e52654a7-88a9-db11-a3e9-0013d4bc506e
2016-03-18 08:56:19 +00:00
1286ceeddf changed: winix project has been moved to 'winixd' subdirectory
in Makefiles we are caltulating relative paths now (by using relative_path program)
	 



git-svn-id: svn://ttmath.org/publicrep/winix/trunk@1030 e52654a7-88a9-db11-a3e9-0013d4bc506e
2016-03-17 13:46:20 +00:00
145efe937c moved winix directories to winixdsubdirectory
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@1028 e52654a7-88a9-db11-a3e9-0013d4bc506e
2016-03-17 08:26:02 +00:00
ed5adb3f23 moved winix directories to winixd subdirectory
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@1027 e52654a7-88a9-db11-a3e9-0013d4bc506e
2016-03-17 08:24:59 +00:00
7d0508961e added: log info about what html template is used
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@1026 e52654a7-88a9-db11-a3e9-0013d4bc506e
2016-03-16 14:11:47 +00:00
e53e2e6af9 added: some work in RegisterMail plugin
(added looking for files in a config directory)



git-svn-id: svn://ttmath.org/publicrep/winix/trunk@1024 e52654a7-88a9-db11-a3e9-0013d4bc506e
2016-02-03 18:10:40 +00:00
4fafd2a478 changed: Makefile
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@1023 e52654a7-88a9-db11-a3e9-0013d4bc506e
2016-02-01 11:12:54 +00:00
f15da4d049 fixed: in FunctionParser we do not treat '+' as a space
added: some work in MailRegister plugin
       (adding mails to db, showing mails)



git-svn-id: svn://ttmath.org/publicrep/winix/trunk@1021 e52654a7-88a9-db11-a3e9-0013d4bc506e
2016-02-01 10:15:23 +00:00
057607f9e5 start working on a new plugin: mailregister
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@1020 e52654a7-88a9-db11-a3e9-0013d4bc506e
2016-01-31 19:52:17 +00:00
c433b3fd41 updated to the new Ezc API
[ezc stream] has gone, now we have [ezc out] and [out]
the output streams have names now: it's a std::map, before we have a std::vector
and the streams are serialized to "out" space in json
Request::out_streams[] are split into Request::out_main_stream and Request::out_streams class



git-svn-id: svn://ttmath.org/publicrep/winix/trunk@1017 e52654a7-88a9-db11-a3e9-0013d4bc506e
2015-11-15 22:23:36 +00:00
632b49ab90 fixed: meta and admin meta information were not saved in memory (in system.dirs)
when 'meta' winix function was used
added: to DbItemsQuery
       sort_index_asc and sort_index_date
       different sort type can be made by 'index' and by 'date'
		     



git-svn-id: svn://ttmath.org/publicrep/winix/trunk@1013 e52654a7-88a9-db11-a3e9-0013d4bc506e
2015-06-16 02:37:07 +00:00
f54df8d600 updated: to the new EZC api (ezc functions can be methods of some special objects)
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@1012 e52654a7-88a9-db11-a3e9-0013d4bc506e
2015-06-14 18:24:08 +00:00
d8451ceaa0 fixed: checking for ssl redirect
we should take into account cur.request->function->need_ssl too



git-svn-id: svn://ttmath.org/publicrep/winix/trunk@1010 e52654a7-88a9-db11-a3e9-0013d4bc506e
2015-05-29 09:46:29 +00:00
62f178c2ee fixed: in App::CheckIfNeedSSLredirect()
winix made an incorrect redirect from/to SSL



git-svn-id: svn://ttmath.org/publicrep/winix/trunk@1009 e52654a7-88a9-db11-a3e9-0013d4bc506e
2015-05-29 09:24:43 +00:00
eb4e7343e7 changed: now 'emacs' winix function uses CodeMirror editor
currently only htmlmixed mode is implemented


git-svn-id: svn://ttmath.org/publicrep/winix/trunk@1008 e52654a7-88a9-db11-a3e9-0013d4bc506e
2015-04-18 18:50:39 +00:00
5274e8e8ff added: "server_mode" config option (std::wstring)
you can assign any string to it such as "production" "dev"
       this value is not used by winix itself
       you can refer to it from [server_mode] and [server_mode_is] ezc functions





git-svn-id: svn://ttmath.org/publicrep/winix/trunk@1007 e52654a7-88a9-db11-a3e9-0013d4bc506e
2015-04-16 14:43:52 +00:00
ae2a885d6c fixed: rm winix function returned incorrectly formated json when using jquery upload (delete file button)
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@1006 e52654a7-88a9-db11-a3e9-0013d4bc506e
2015-03-20 11:00:22 +00:00
901663b145 updated: to the new ezc api
added:   following ezc functions: ezc_and_not, ezc_any_not, ezc_or_not, ezc_one_not, is, is_not, is_empty, is_not_empty





git-svn-id: svn://ttmath.org/publicrep/winix/trunk@1005 e52654a7-88a9-db11-a3e9-0013d4bc506e
2015-03-08 23:22:05 +00:00
dc301d4c50 changed: editors (emacs, ckeditor...) doesn't set an item's title now (if it was empty)
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@1003 e52654a7-88a9-db11-a3e9-0013d4bc506e
2015-03-02 21:23:29 +00:00
34f0535a26 added: some ezc functions for displaying current date
current_sec, current_min, current_hour, current_year, ...



git-svn-id: svn://ttmath.org/publicrep/winix/trunk@1002 e52654a7-88a9-db11-a3e9-0013d4bc506e
2015-02-22 10:23:52 +00:00
af0e2a778d changed: some refactoring in System: in IsMemberOfGroup method
changed: some log messages at startup (about non existing empty group for uploads directory)




git-svn-id: svn://ttmath.org/publicrep/winix/trunk@1001 e52654a7-88a9-db11-a3e9-0013d4bc506e
2015-01-02 08:18:06 +00:00
904f1e70f2 fixed: compiling on Debian (it has no MSG_EOF flag)
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@1000 e52654a7-88a9-db11-a3e9-0013d4bc506e
2015-01-02 07:15:22 +00:00
ddf7ef30ad fixed: compiling od Debian
sockaddr_un has no sun_len member



git-svn-id: svn://ttmath.org/publicrep/winix/trunk@999 e52654a7-88a9-db11-a3e9-0013d4bc506e
2015-01-02 07:14:15 +00:00
0a43870e76 fixed: the way how winix is closing
beforehand we made a http connection from the special thread
       now we just send a fastcgi packet to the unix socket

       the old way was broken because it requires the http server to work
       and if the operating system is going to shutdown/reboot then the http server
       can be first closed and consequently the winix cannot wake up from
       the main thread (and will be terminated SIGKILL by the os)
       



git-svn-id: svn://ttmath.org/publicrep/winix/trunk@998 e52654a7-88a9-db11-a3e9-0013d4bc506e
2015-01-02 07:01:08 +00:00
f875bd2944 changed: when a client doesn't send a session cookie we can instead of ban just use a temporary session
added: config option:
	// the way we behave when no_session_cookie_treshold limit is exceeded
 	// 0 - if a client doesn't send a session cookie again then use a temporary session
 	//     (other sessions from this IP address are not affected)
 	// 1 - add this IP address to ban list and create a temporary session
 	//     (this will block other sessions from this IP address too)
 	// default: 0
 	int no_session_cookie_ban_mode;




git-svn-id: svn://ttmath.org/publicrep/winix/trunk@996 e52654a7-88a9-db11-a3e9-0013d4bc506e
2014-11-25 12:02:22 +00:00
c9bf20201b added: possibility to ban if a session cookie is incorrect (when we are using encoded cookies)
added:   possibility to ban if a client tries to hijack the session cookie
added:   possibility to ban if a client did not send a session cookie
renamed: ezc functions:
         login_cannot_login -> ipban_is_login_allowed_from_this_ip  (and the return value was changed)
         login_when_available_login -> ipban_current_ip_expires_time
added: config options:
       // after how many broken encoded cookie we should ban the current IP
       // default: 2 (value in the range <0 - 65535>)
       size_t broken_encoded_cookie_treshold;

       // after how many incorrect session identifiers (or session indices) we should ban the current IP
       // do not set this value too low, as people connecting from the same IP address (from behind a NAT)
       // would be banned if they have an old session cookie remembered in the browser
       // default: 128 (value in the range <0 - 65535>)
       size_t session_hijacking_treshold;

       // after how many times a client will be banned if it did not send a session cookie
       // default: 1000 (value in the range <0 - 65535>)
       size_t no_session_cookie_treshold;








git-svn-id: svn://ttmath.org/publicrep/winix/trunk@995 e52654a7-88a9-db11-a3e9-0013d4bc506e
2014-11-24 20:22:30 +00:00
76314aab10 added: possibility to encode the session cookie (added files core/sessionidmanager.h and core/sessionidmanager.cpp)
added: config options:
       // whether or not we should encode the session cookie
       // (we have a special algorithm)
       // default: false
       bool session_cookie_encode;

       // if session_cookie_encode is true then you should provide
       // a file where AES keys will be stored
       std::wstring session_keys_file;

       // each session has an index -- an unsigned int value
       // this value is sent in the cookie string (is encoded)
       // and is incremented when session_index_time_increment time is passed since the last incrementing
       // if a client sent the cookie back the difference between
       // current index and the index in the cookie should be less than or equal to session_allow_index_difference
       // default: 8
       size_t session_allow_index_difference;

       // the time which should pass after the session index is incremented
       // default: 30
       // (session_allow_index_difference + 1) * session_index_time_increment should be less than a time
       // load of a page and all elements on it such as images (of course it depends on client's download too)
       time_t session_index_time_increment;

       // time in seconds after a new AES key pair should be generated
       // we have 256 pairs of keys so this time multiplied by 256 should not be less than
       // the max time of a session (session_remember_max_idle),
       // by default: 256 * 2 days = 512 days = 1.4 year > 3 months (session_remember_max_idle)
       // default: 172800 = 2 days (max: 2678400 = 1 month, min: 10)
       size_t session_key_renew_time;

changed: when printing the time of a request we print only two non-zero digits






git-svn-id: svn://ttmath.org/publicrep/winix/trunk@994 e52654a7-88a9-db11-a3e9-0013d4bc506e
2014-11-22 15:30:56 +00:00
3547d326b8 define AR macro in the main Makefile
this is for pikotools and tito libraries



git-svn-id: svn://ttmath.org/publicrep/winix/trunk@993 e52654a7-88a9-db11-a3e9-0013d4bc506e
2014-11-12 04:14:16 +00:00
0ecb2ac70e added: to HtmlTextStream: Escape(bool) method
now the output html streams can be turn into no-escaping mode
       default true (set when a request is clearing)




git-svn-id: svn://ttmath.org/publicrep/winix/trunk@990 e52654a7-88a9-db11-a3e9-0013d4bc506e
2014-11-06 21:17:41 +00:00
8f8defe0de updated: to the new Ezc API
removed statements: [if-index ...] [is ...] [is-no ...]
added:   generic ezc functions:
         and, any (the same as and), or, one (the same as or), not, cmp, trim
         to_lower, to_upper, index
changed: in misc:
         added treat_new_line_as_white flag to IsWhite() SkipWhite() and TrimWhite()
         TrimWhite(), TrimFirst(), TrimLast(), Trim() are using only wide characters now
         (they were templates before)
         added: IsInt(), IsSize(), IsFloat()
changed: version to 0.6.4






git-svn-id: svn://ttmath.org/publicrep/winix/trunk@989 e52654a7-88a9-db11-a3e9-0013d4bc506e
2014-11-02 17:47:34 +00:00
db5572e864 removed: svn:executable attribute from files
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@984 e52654a7-88a9-db11-a3e9-0013d4bc506e
2014-11-01 17:05:20 +00:00
1100cf75d7 updated: to the new Ezc API
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@983 e52654a7-88a9-db11-a3e9-0013d4bc506e
2014-10-28 19:14:46 +00:00
4fda06b547 fixed: PatternCacher incorrectly rebuilt the cache
some new Ezc::Pattern objects were inserted
       the storage container is std::map<long,...>
       but we traverse it as a std::vector e.g.:
       for(size_t i=0 ; i<pattern_tab.size() ; ++i)
           RebuildCache(pattern_tab[i].pattern);
       so eventually new patterns were added to the map
       (operator [])




git-svn-id: svn://ttmath.org/publicrep/winix/trunk@980 e52654a7-88a9-db11-a3e9-0013d4bc506e
2014-10-21 07:27:21 +00:00
fb18b2238e added: two options to the config:
ezc_error_prefix (string)
        ezc_error_postfix (string)
        // prefix and postfix used when there is an error in Ezc patterns
        // default:
        // prefix:  "<!-- "
        // postfix: " -->"
added:  Ezc::Blocks to templates
added:  although patterns have pointers to functions and blocks cached
        the Ezc::Generator should use SetFunctions() and SetBlocks() method
        in order to correctly recognize variables (aliases)




git-svn-id: svn://ttmath.org/publicrep/winix/trunk@978 e52654a7-88a9-db11-a3e9-0013d4bc506e
2014-10-19 21:20:09 +00:00
5266a7e4e5 updated: to the new Ezc API
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@974 e52654a7-88a9-db11-a3e9-0013d4bc506e
2014-10-18 18:12:04 +00:00
8196fb77d1 changed: now we do not use std::string and char* in the Winix API
everywhere we are using std::wstring and wchar_t*
         (std::string and char* is used only locally in some places
         especially when creating a path to OS file system etc.)
added:   to the special thread when winix closes:
         a write function for curl: FetchPageOnExitCurlCallback()
         without this function the curl library will print
         the page's content to the standart output
changed: TextStream<> class from core can make
         UTF8<->wide strings conversions
removed: from config: utf8 option
         now winix expects UTF8 from the user's input (html forms, url-es)
         and outputs strings in the UTF8 format




git-svn-id: svn://ttmath.org/publicrep/winix/trunk@965 e52654a7-88a9-db11-a3e9-0013d4bc506e
2014-10-09 20:44:56 +00:00
4abf6642f7 setting a Winix Licence: 2 Clause BSD Licence
changed: version to 0.6.2



git-svn-id: svn://ttmath.org/publicrep/winix/trunk@963 e52654a7-88a9-db11-a3e9-0013d4bc506e
2014-10-04 18:04:03 +00:00
e3284dcfbc fixed: winix incorrectly used config options: upload_dirs_chmod and upload_files_chmod
added: to config: upload_group
       a group name for newly uploaded files (and created necessary directories in the file system)




git-svn-id: svn://ttmath.org/publicrep/winix/trunk@961 e52654a7-88a9-db11-a3e9-0013d4bc506e
2014-09-28 17:30:05 +00:00
f064ff6b3d added: htmltextstream escapes more characters now:
added characters:
          "  -> &#quot;
          '  -> &#39; (&apos; but IE8 has a problem with &apos;)
          10 -> &#10;
          13 -> &#13;
added: two ezc filters:
       fil_html_quote
          "  -> &#quot;
          '  -> &#39; (&apos; but IE8 has a problem with &apos;)
       fil_html_newline
          10 -> &#10;
          13 -> &#13;
changed: fun_subject.html uses <div class="winix_input_a"> now





git-svn-id: svn://ttmath.org/publicrep/winix/trunk@959 e52654a7-88a9-db11-a3e9-0013d4bc506e
2014-09-22 23:54:24 +00:00
bfa5d8cc05 changed: plugin jQuery File Upload has been updated to version 9.7.0
(changed 'upload' and 'rm' winix functions)



git-svn-id: svn://ttmath.org/publicrep/winix/trunk@958 e52654a7-88a9-db11-a3e9-0013d4bc506e
2014-08-06 20:14:10 +00:00
6614919c13 added: possibility to save a pid file
new config option: pid_file (a full path to a pid file)



git-svn-id: svn://ttmath.org/publicrep/winix/trunk@957 e52654a7-88a9-db11-a3e9-0013d4bc506e
2014-08-04 21:11:14 +00:00
8379acdb7f fixed: item content should not be escaped in 'raw' mode
(it was not escaped only when execute bits were set)



git-svn-id: svn://ttmath.org/publicrep/winix/trunk@956 e52654a7-88a9-db11-a3e9-0013d4bc506e
2014-08-03 18:33:07 +00:00
160ddc258d added: to htmlfilter: the filter is able to recognize a special tag, default called: <nofilter>
content between <nofilter>...</nofilter> will not be filtered



git-svn-id: svn://ttmath.org/publicrep/winix/trunk@955 e52654a7-88a9-db11-a3e9-0013d4bc506e
2014-06-18 23:18:28 +00:00
01892d2766 added: flag has_pass to User structure
if false that means the user has not set a password yet 
       (this can be used by a plugins to create a new account without a password set)
       in order to login the user first has to set a new password
       (this can be done from a some kind of activation link send via email etc)
       



git-svn-id: svn://ttmath.org/publicrep/winix/trunk@954 e52654a7-88a9-db11-a3e9-0013d4bc506e
2014-06-07 11:20:44 +00:00
222955a2e7 fixed: in Synchro: we should have a table (map) of reference counters
each one for each thread
fixed: on Linux: pthread mutexes by default behaves differently than on FreeBSD
       we have to set PTHREAD_MUTEX_ERRORCHECK attribute 
       when creating a mutex
       



git-svn-id: svn://ttmath.org/publicrep/winix/trunk@953 e52654a7-88a9-db11-a3e9-0013d4bc506e
2014-02-14 11:20:22 +00:00
37b22c3559 added: some debug logs to export plugin
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@952 e52654a7-88a9-db11-a3e9-0013d4bc506e
2014-02-12 22:32:06 +00:00
afbd522362 fixed: in Makefile: 'cp' in Linux behaves differently
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@951 e52654a7-88a9-db11-a3e9-0013d4bc506e
2014-02-12 20:49:50 +00:00
a4bed3ab14 fixed: compiling on Debian with GCC 4.8
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@950 e52654a7-88a9-db11-a3e9-0013d4bc506e
2014-02-12 17:21:42 +00:00
7468e7a36c added: namespace Winix over all *.h/*.cpp files
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@948 e52654a7-88a9-db11-a3e9-0013d4bc506e
2014-02-12 16:30:49 +00:00
145445c713 changed: now we use curl to fetch a page from the special thread when winix quits
(before we were using BSD's fetch)
fixed:   we didn't use FCGX_Finish_r() on the request made from the special thread
         so the thread hangs (now we can use pthread_join correctly from the main thread)



git-svn-id: svn://ttmath.org/publicrep/winix/trunk@947 e52654a7-88a9-db11-a3e9-0013d4bc506e
2014-02-11 21:00:32 +00:00
7fa9314c6b changed: in ClearOutputStreams() referencing 'config' only if not null
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@946 e52654a7-88a9-db11-a3e9-0013d4bc506e
2013-12-23 03:29:33 +00:00
5d37b6c6ae fixed: winix incorrectly sent the binary stream
headers and cookies were not sent
       (instead of headers the content was sent, so the client's browser was unable to open it correctly)
added: standard http headers are added by winix only if there are not such headers already
       e.g. if a plugin adds "Content-Type" header then winix will not overwrite it 
       (headers names are case sensitive)


git-svn-id: svn://ttmath.org/publicrep/winix/trunk@945 e52654a7-88a9-db11-a3e9-0013d4bc506e
2013-12-19 17:19:47 +00:00
fe1f84e29d added: -O0 -g for CXXFLAGS for temporarily debugging
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@944 e52654a7-88a9-db11-a3e9-0013d4bc506e
2013-12-18 12:13:28 +00:00
83e27a6653 fixed: problem with building
added #include <utility> to App (for std::move)



git-svn-id: svn://ttmath.org/publicrep/winix/trunk@943 e52654a7-88a9-db11-a3e9-0013d4bc506e
2013-12-09 16:03:45 +00:00
ee9c68b04e added: generating Content-Length header when text answer is sent to the client
added:   now we are able to use the html filter for the whole out_streams (when ajax is used the output is filtered too)
         splitted FilterCompressSend() function -- first we are making the filtering
         (after filtering we know the size of the content to send)
added:   to Compress:
         Compressing(const char * source, size_t source_len, BinaryPage & out_stream, int encoding);
changed: some refactoring in App




git-svn-id: svn://ttmath.org/publicrep/winix/trunk@942 e52654a7-88a9-db11-a3e9-0013d4bc506e
2013-12-04 01:21:57 +00:00
c04874397b fixed: security vulnerability in 'ln' winix function
a user could create a hardlink to any file and the new link 
       had user_id, group_id and permissions the same as for new generated files,
       this allowes to overwrite any existing file in the filesystem,
       now user_id, group_id, permissions are the same as from the oryginal file



git-svn-id: svn://ttmath.org/publicrep/winix/trunk@941 e52654a7-88a9-db11-a3e9-0013d4bc506e
2013-12-03 12:33:41 +00:00
375604edd6 removed: Request::debug all stream used for debugging info
some environment variables were put there
removed: config variable: debug_info
removed: Request::role (responder, authorizer)
         now we have only one role: responder
added:   new config variables:
         log_env_variables (default false) - when true then fastcgi environment
         variables are logged to the log file
         log_http_answer_headers (default false) - when true all http headers
         created by winix ale logged (note that the www server can add/adjust other headers)
changed: some refactoring in Request struct
changed: CookieTab to std::map<std::wstring, std::wstring>
         beforehand std::string was used
         (changed CookieParser as well)
changed: Request::SetCookie() to AddCookie()
added:   Request::out_headers (a PT::Space struct)
         http headers (without cookies) send back to the client
added:   Request::out_cookies (a PT::Space struct)
         cookies send to the client
changed: App class to use Request::out_headers and Request::out_cookies
         some SendHeaders...() methods were renamed to PrepareHeaders...()
         and they create output in Request::out_headers first (and out_cookies)
         and later it is sent
added:   two plugin messages:
         // http headers (without cookies) were created and are ready to send
         // here you can make some changes to them
         // in p1 you have a pointer to the PT::Space (Request::out_headers)
         #define WINIX_PREPARE_TO_SEND_HTTP_HEADERS		31070

         // http cookies were created and are ready to send
         // here you can make some changes to them
         // in p1 you have a pointer to the PT::Space (Request::out_cookies)
         #define WINIX_PREPARE_TO_SEND_HTTP_COOKIES		31080
added:   config variable:
         // how many output streams do we have in Request class
         // default: 16 (64 maximum)
         size_t ezc_out_streams_size;




git-svn-id: svn://ttmath.org/publicrep/winix/trunk@940 e52654a7-88a9-db11-a3e9-0013d4bc506e
2013-11-29 21:39:23 +00:00
3e32f3784f removed: -O0 -g from production Makefile
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@939 e52654a7-88a9-db11-a3e9-0013d4bc506e
2013-11-25 23:44:01 +00:00
5c4a54d998 added: -O0 -g to the production Makefile
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@938 e52654a7-88a9-db11-a3e9-0013d4bc506e
2013-11-25 23:37:52 +00:00
3af3ac3f6f removed: ezn patterns for rawcontent and ajaxcontent:
index_rawcontent.html, index_ajaxcontent.html
         now we have out_streams in Request and some special
         keyword in ezc templates for sending content to the 
         specified streams
changed: the way how winix answers to the client's browsers:
         info from Request class:
	                                   winix answer send to the client's browser
	                                                       |
	                                                       |
	                                          depending on send_bin_stream
	                               -------------------------------------------------
	                               |                                               |
	                          text answer                                     binary answer
	                               |                                               |
	                   depending on return_json                          sending out_bin_stream
	             ------------------------------------
	             |                                  |
	       normal request                     ajax request
	             |                                  |
	   sending out_streams[0]           depending on return_info_only
	                              ------------------------------------------------------
	                              |                                                    |
	                 generating JSON object from:                   generating JSON object only from info
	                 out_streams and info, e.g.:                    e.g.:
	                 {                                              { info object serialized here }
	                  "stream_1": "some html content",
	                  "stream_2": "some other html content",
	                  "info": { info object serialized here }
	                 }
	                 note that out_streams[0] is not sent
	                 in JSON answers
	
	




git-svn-id: svn://ttmath.org/publicrep/winix/trunk@937 e52654a7-88a9-db11-a3e9-0013d4bc506e
2013-11-14 20:59:23 +00:00
d801f53154 changed: now we are using the C++ 11 language (-std=c++11) and we are using
the clang compiler by default
changed: Makefile files have been a little cleaned
         the main Makefile now will not compile winix and winix.so if there
         were not any changes to source files (it's faster)
         (added Makefile.dep in the global directory with list of all source/header files)
changed: winix version to 0.5.5




git-svn-id: svn://ttmath.org/publicrep/winix/trunk@933 e52654a7-88a9-db11-a3e9-0013d4bc506e
2013-10-15 21:57:51 +00:00
a6b06f82e9 fixed: compiling in the clang (new version of c++ std lib)
(added some header files)
added: three messsages in ticket plugin:
       // send by showtickets winix function when tickets are loaded (and sorted)
       // in p1 you have a pointer to the ticket tab: std::vector<Ticket::Ticket> (include "ticket.h")
       // in p2 you have a pointer to the sort tab:   std::vector<Item*>
       // those tables don't have to be equal in size (in the case when there is no some tickets in the database)
       #define WINIX_PL_TICKET_TICKETS_LOADED                 4106
       
       // a new ticket has been added
       // in p1 you have a pointer to the Ticket::Ticket structure (include "ticket.h")
       // in p2 you have a pointer to the Item structure
       #define WINIX_PL_TICKET_ADDED_NEW                              4107
       
       // a ticket has been changed
       // in p1 you have a pointer to the Ticket::Ticket structure (include "ticket.h")
       // in p2 you have a pointer to the Item structure
       #define WINIX_PL_TICKET_CHANGED                                        4108

added: two ezc functions for tickets:
       ticket_does_param_id_have_value()
       tickets_tab_does_param_id_have_value()
       (they take two integer arguments -- testing whether a specified param_id has the given value)
changed: some more minor additions in tickets templates




git-svn-id: svn://ttmath.org/publicrep/winix/trunk@932 e52654a7-88a9-db11-a3e9-0013d4bc506e
2013-10-10 11:59:21 +00:00
b7f3f84080 changed: in 'showtickets' winix function
now tickets are sorted by the sort_index and then by date
changed: html in 'sort' winix function (added items' subjects to the item lists)



git-svn-id: svn://ttmath.org/publicrep/winix/trunk@931 e52654a7-88a9-db11-a3e9-0013d4bc506e
2013-07-08 14:42:14 +00:00
26715bdd4c changed: html for 'upload' winix function
all static files (css/js) are downloaded from our server now



git-svn-id: svn://ttmath.org/publicrep/winix/trunk@930 e52654a7-88a9-db11-a3e9-0013d4bc506e
2013-07-02 07:14:19 +00:00
083fa7857f fixed: in notify/notify.cpp: a correct locale id should be taken
(we were not able to send: a mail with an activation link and 
        a mail with the reset password link when we didn't have a locale with id 0 loaded)



git-svn-id: svn://ttmath.org/publicrep/winix/trunk@929 e52654a7-88a9-db11-a3e9-0013d4bc506e
2013-05-16 21:02:17 +00:00
9ffda3e070 changed: in passwd: a redirect make only if a password has been changed
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@928 e52654a7-88a9-db11-a3e9-0013d4bc506e
2013-05-16 20:11:27 +00:00
81160dbbe9 fixed: a passwd winix function should allow a non loged person to reset his password (permission fix)
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@927 e52654a7-88a9-db11-a3e9-0013d4bc506e
2013-05-16 20:08:07 +00:00
7c266b85e2 added: winix function 'account'
code for activating an account has been moved here from Pw
changed: the form for reseting a user's password has been moved
         to 'passwd' winix function (it was in Pw before)




git-svn-id: svn://ttmath.org/publicrep/winix/trunk@926 e52654a7-88a9-db11-a3e9-0013d4bc506e
2013-05-16 19:26:44 +00:00
48cdca7549 changed: in fun_gallery.html: added js code to get the proper image id from url
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@925 e52654a7-88a9-db11-a3e9-0013d4bc506e
2013-05-14 08:37:22 +00:00
1c401eae3b added: to Rm function:
bool Rm::RemoveFileOrSymlink(long item_id, bool check_access)
added: in ticket plugin: possibility to remove a file/image
       (not finished yet)




git-svn-id: svn://ttmath.org/publicrep/winix/trunk@924 e52654a7-88a9-db11-a3e9-0013d4bc506e
2013-05-06 07:23:44 +00:00
0e9eb30b5d added: some ezc function to ticket plugin:
ticket_param_value_for_param_id
       tickets_tab_param_value_for_param_id
       tickets_tab_conf_tab_param_name
       tickets_tab_conf_tab_file_tab
       tickets_tab_conf_tab_file_tab_index
       tickets_tab_conf_tab_file_tab_path
       tickets_tab_conf_tab_file_tab_itemid
       tickets_tab_conf_tab_file_tab_meta




git-svn-id: svn://ttmath.org/publicrep/winix/trunk@923 e52654a7-88a9-db11-a3e9-0013d4bc506e
2013-04-24 01:21:19 +00:00
c10c9393c0 changed: plugin 'export': export winix function
the checkbox is now selected when we want to export static files too 
         (default it is not checked)
         



git-svn-id: svn://ttmath.org/publicrep/winix/trunk@922 e52654a7-88a9-db11-a3e9-0013d4bc506e
2013-04-17 00:37:39 +00:00
8705b3437c fixed: imgcrop winix function should load only images
(when called in a directory)
added: to reload winix function:
       reloading (clearing) the cache from 'menu' plugin
added: to 'menu' plugin
       possibility to read 'meta' information from files 
       third argument 'withmeta' to menu_dir_tab ezc function
       e.g. [for menu_dir_tab "/directory" "..." "withmeta"]...[end]
       and some ezc functions to retrieve the meta values




git-svn-id: svn://ttmath.org/publicrep/winix/trunk@921 e52654a7-88a9-db11-a3e9-0013d4bc506e
2013-04-16 09:51:36 +00:00
aed891764a added: to config: HasValue() methods
for checking if a value exists (useful for checking lists -- they don't have to be copied out)




git-svn-id: svn://ttmath.org/publicrep/winix/trunk@920 e52654a7-88a9-db11-a3e9-0013d4bc506e
2013-04-02 22:24:30 +00:00
495499d12f added: a new winix function: imgcrop
for cropping images (and thumbnails)
       www.domain.com/dir/file.jpg/imgcrop  -- crop an image
       www.domain.com/dir/file.jpg/imgcrop/thumb  -- crop an image's thumbnail
       www.domain.com/dir/file.jpg/imgcrop/newthumb  -- crop and create a new thumbnail (from an original image)
       www.domain.com/dir/imgcrop -- show images' list with above options
added: to Image class: some methods for cropping




git-svn-id: svn://ttmath.org/publicrep/winix/trunk@919 e52654a7-88a9-db11-a3e9-0013d4bc506e
2013-03-29 22:03:28 +00:00
8d9a021eab changed: when there is reqtype:json parameter and there is not set request.ajax_serializer
then we are using a generic json serializer
changed: we are sending the application/json header when returning an json string
added:   to config: log_server_answer (default false)
         when true we put the whole string (server's answer) to the log file
added:   to Request: use_200_status_for_not_found_and_permission_denied
         if this is true then if the server http code would be 403 or 404
         then we return 200 OK (useful when using ajax)
changed: System::RedirectTo() methods take as the last parameter: use_reqtype
         if this is true (default) then reqtype:type parameter is automatically added to the redirecting path
         




git-svn-id: svn://ttmath.org/publicrep/winix/trunk@918 e52654a7-88a9-db11-a3e9-0013d4bc506e
2013-03-26 00:04:01 +00:00
be6e09c5af added: some ezc functions (item_tab_meta*)
added: some ezc functions (gallery_tab_meta*) to gallery plugin
added: to gallery plugin: a new gallery: Gallery version 1.2.9



git-svn-id: svn://ttmath.org/publicrep/winix/trunk@917 e52654a7-88a9-db11-a3e9-0013d4bc506e
2013-02-26 11:49:22 +00:00
293e426ed4 fixed: plugin 'group'
Groups::ReindexGroups incorrectly read a field from a PT::Space (it used 'table' object directly)
       but the value was in 'table_single' 
       now we are using GetValue method



git-svn-id: svn://ttmath.org/publicrep/winix/trunk@916 e52654a7-88a9-db11-a3e9-0013d4bc506e
2013-02-01 21:14:56 +00:00
60f2337b73 updated: paths in Makefile (prog subdirectory)
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@915 e52654a7-88a9-db11-a3e9-0013d4bc506e
2013-01-19 16:31:15 +00:00
ce8152de2f changed: added 'logsave' when we are waiting for the database to be ready
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@913 e52654a7-88a9-db11-a3e9-0013d4bc506e
2013-01-19 10:10:17 +00:00
496a1979d2 fixed: in ticket plugin: editticket incorrectly used ticket_info->Clear() method
it was called after some objects were set consequently we were not allowed to edit a ticket



git-svn-id: svn://ttmath.org/publicrep/winix/trunk@912 e52654a7-88a9-db11-a3e9-0013d4bc506e
2012-12-30 15:33:08 +00:00
fd698ca7b9 added: put the rebus answer into the log (when user has entered an incorrect answer)
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@911 e52654a7-88a9-db11-a3e9-0013d4bc506e
2012-12-26 23:08:57 +00:00
b4b368d324 changed: Makefile dep
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@910 e52654a7-88a9-db11-a3e9-0013d4bc506e
2012-11-17 01:10:00 +00:00
825694c880 changed: in editticket: closing ticket is better to do via POST request
added:   a new message sent by editticket when closing a ticket:
         #define WINIX_PL_TICKET_CLOSED                                 4105
         // a ticket has been closed (closed button pressed)
         // in p1 you have a pointer to the Item struct
         // in p2 you have a pointer to the Ticket struct





git-svn-id: svn://ttmath.org/publicrep/winix/trunk@909 e52654a7-88a9-db11-a3e9-0013d4bc506e
2012-11-05 23:13:52 +00:00
32750a7d50 changed: ticket plugin: redirect type in editticket winix function (when there is 'close' parameter)
fixed:   prototype doesn't work with jquery (in ticket winix function)
         (prototype was loaded for lightbox)



git-svn-id: svn://ttmath.org/publicrep/winix/trunk@908 e52654a7-88a9-db11-a3e9-0013d4bc506e
2012-11-04 22:39:02 +00:00
0045c6c72c added: to Item struct: ameta (PT::Space)
admin meta information
added: option "a" to meta winix function
       editing admin meta information
changed: now if you don't have write access to an item
         you can't see the meta information
         previous if you had read access you could have seen them
added: in plugin ticket and thread
       support for 'closing' (ticket, thread)
       (this is only logic, we need some html yet)
added: some ezc function for getting meta/admin meta information
       (for the current item and the last directory)




git-svn-id: svn://ttmath.org/publicrep/winix/trunk@907 e52654a7-88a9-db11-a3e9-0013d4bc506e
2012-11-04 21:01:02 +00:00
4809016b78 changed: html (slog.html)
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@906 e52654a7-88a9-db11-a3e9-0013d4bc506e
2012-11-01 17:56:00 +00:00
6e2ba65524 changed: added 'check_abuse' parameter to Login::LoginUser
bool Login::LoginUser(const std::wstring & login, const std::wstring & password, bool remember_me,
                               bool use_ses_log, bool check_abuse)
         default 'false' -- it test the time between GET and POST and the rebus (if exists)



git-svn-id: svn://ttmath.org/publicrep/winix/trunk@905 e52654a7-88a9-db11-a3e9-0013d4bc506e
2012-10-27 11:17:52 +00:00
8033ac66c4 added: locales to fun_ipban.html
changed: cosmetic changes in IPBanContainer




git-svn-id: svn://ttmath.org/publicrep/winix/trunk@904 e52654a7-88a9-db11-a3e9-0013d4bc506e
2012-10-27 10:14:07 +00:00
9ef3736989 added: to 'ipban' winix function:
possibility to remove a ban (or all bans)
added: to SessionManager: sorting of the ban list (in the second thread)



git-svn-id: svn://ttmath.org/publicrep/winix/trunk@903 e52654a7-88a9-db11-a3e9-0013d4bc506e
2012-10-27 09:03:49 +00:00
099dd55d0c added: IP ban mechanism (not finished yet -- we need a winix function to remove a ban)
now after some incorrent login attempts your IP can be banned or blocked
       (see new config variables)


git-svn-id: svn://ttmath.org/publicrep/winix/trunk@902 e52654a7-88a9-db11-a3e9-0013d4bc506e
2012-10-27 07:44:26 +00:00
53b4175d00 added: plugin message: WINIX_CHECK_PLUGIN_ACCESS
this message is sent before calling MakePost() or MakeGet()
       if you return false (which is default) you can prevent the access
       to the resource
       



git-svn-id: svn://ttmath.org/publicrep/winix/trunk@901 e52654a7-88a9-db11-a3e9-0013d4bc506e
2012-10-17 19:52:55 +00:00
8aa6f08e08 updated: html (login and passwd)
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@900 e52654a7-88a9-db11-a3e9-0013d4bc506e
2012-10-17 06:48:48 +00:00
c5024598cb updated: html/css (added div.winix to templates)
now we have winix.css in common/winix directory
         it is automatically loaded by index_head_functions_add.html


git-svn-id: svn://ttmath.org/publicrep/winix/trunk@898 e52654a7-88a9-db11-a3e9-0013d4bc506e
2012-10-17 06:00:00 +00:00
dfcf6b29c0 added: to misc:
bool IsWhite(const wchar_t * str, bool treat_new_line_as_white)
       bool IsWhite(const std::wstring & str, bool treat_new_line_as_white)
       return true if the whole string is white (or an empty string)
added: global variable in admin environment for an user: "display_name"
       if defined it is used to display an user's name instead of its login
       it is used in: void print_user_name(Info & i, User & user);
       (tickets, threads, cat function etc)





git-svn-id: svn://ttmath.org/publicrep/winix/trunk@895 e52654a7-88a9-db11-a3e9-0013d4bc506e
2012-09-26 07:18:32 +00:00
7f48d1eb2e fixed: the way we check whether we need make the redirect from SSL to non SSL (or vice versa)
beforehand we didn't take into accout default winix functions



git-svn-id: svn://ttmath.org/publicrep/winix/trunk@894 e52654a7-88a9-db11-a3e9-0013d4bc506e
2012-09-24 20:31:01 +00:00
eaa97995d2 fixed: we should check cur.request->function is not null (in5D app when testing ssl/nossl redirect)
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@893 e52654a7-88a9-db11-a3e9-0013d4bc506e
2012-09-24 18:59:08 +00:00
14f997b844 added: need_ssl flag to FunctionBase
// try to use SSL
       // if in the config 'use_ssl' is true and 'use_ssl_only_for_logged_users' is true
       // then ssl is used only for logged users but sometimes there is a need to use
       // SSL even if noone is logged (for example for such functions like 'login' or 'adduser')
       // default: false
       // (this option is ignored if 'use_ssl' in the config is false)
       bool need_ssl;




git-svn-id: svn://ttmath.org/publicrep/winix/trunk@892 e52654a7-88a9-db11-a3e9-0013d4bc506e
2012-09-24 18:38:35 +00:00
26e87b20b1 changed: in Crypt:
renamed Hash() -> HashBin()
         HashBin() is using a binary output from OpenSSL now
	 previously we are using the hex output and with the new OpenSSL version
         the text has additional characters and causes some problems
	 added: HashHex() - it is using the HashBin() and then converts the output
	 to hex format itself
	 



git-svn-id: svn://ttmath.org/publicrep/winix/trunk@891 e52654a7-88a9-db11-a3e9-0013d4bc506e
2012-09-19 23:17:10 +00:00
5cdf6eff36 added: to ticket plugin:
some messges:
// 
#define WINIX_PL_TICKET_PREPARE_TO_ADD_TICKET  4103

// a next ticket will be displayed
// in p1 you have a pointer to the Item struct
// this is call from tickets_tab ezc function
#define WINIX_PL_TICKET_TICKETS_TAB_IS_NEXT            4104

methods:
void ticket_meta_value(Info & i)
void tickets_tab_meta_value(Info & i)






git-svn-id: svn://ttmath.org/publicrep/winix/trunk@890 e52654a7-88a9-db11-a3e9-0013d4bc506e
2012-09-15 23:34:25 +00:00
4ed535a3b7 added: to plugin ticket: message WINIX_PL_TICKET_LOAD_TICKETS
someone can send this message with a directory id
       and tickets will be loaded from the directory
       (and to display them you can use ezc functions)



git-svn-id: svn://ttmath.org/publicrep/winix/trunk@889 e52654a7-88a9-db11-a3e9-0013d4bc506e
2012-09-14 23:48:39 +00:00
da15323c2f added: to plugin thread: message WINIX_PL_THREAD_CAN_MAKE_REDIRECT
(similar as for ticket)



git-svn-id: svn://ttmath.org/publicrep/winix/trunk@888 e52654a7-88a9-db11-a3e9-0013d4bc506e
2012-09-14 07:14:54 +00:00
bd1f717b4c added: some methods in Dystem::Dirs (takes wchar_t * as an argument, now only std::wstring were)
changed: in plugin ticket: added message: WINIX_PL_TICKET_CAN_MAKE_REDIRECT
         it is sent at the end of POST request (editticket, createticket)
         if we can make a redirect (useful with AJAX)





git-svn-id: svn://ttmath.org/publicrep/winix/trunk@887 e52654a7-88a9-db11-a3e9-0013d4bc506e
2012-09-13 23:12:48 +00:00
72013046fc added: Lock class -- locking resources by using Synchro object
the destructor automatically calls Unlock()



git-svn-id: svn://ttmath.org/publicrep/winix/trunk@886 e52654a7-88a9-db11-a3e9-0013d4bc506e
2012-09-11 23:46:00 +00:00
14ae19143f added: new ezc filter: fil_new_line_to_br
added: PutChar() methods to HtmlTextFilter and TexTextFilter



git-svn-id: svn://ttmath.org/publicrep/winix/trunk@885 e52654a7-88a9-db11-a3e9-0013d4bc506e
2012-09-11 21:41:10 +00:00
d8260d8383 added: a new way: HEX format to saving/reading from PostgreSQL bytea columns
added: to Request:
       // binary page
       BinaryPage binary_page;

       // a compressed page ready to send to the client
       BinaryPage compressed_page;

       // if true then either page or ajaxpage will be sent to the client
       // if false then binary_page is sent
       // default: true
       bool use_text_page;

       BinaryPage is defined as (in requesttypes.h):
       typedef PT::TextStreamBase<char, 1, 4096> BinaryPage;

added: to Compress: now it can gets BinaryPage as arguments (input, output)
changed: winix version to: 0.5.0
added: in templates: TexTextStream class
       for taking input to the TeX typesetting system





git-svn-id: svn://ttmath.org/publicrep/winix/trunk@884 e52654a7-88a9-db11-a3e9-0013d4bc506e
2012-09-11 05:19:45 +00:00
9174555ff8 added: to config: log_time_zone_id (size_t) identifier
this is the time zone identifier used in log messages



git-svn-id: svn://ttmath.org/publicrep/winix/trunk@882 e52654a7-88a9-db11-a3e9-0013d4bc506e
2012-09-06 17:50:14 +00:00
0c6ddc2218 added: 'subject' winix function is using WINIX_FILE_CHANGED message now (when changing a file's subject)
added: 'postredirect' global parameter (it can be a param or post value)
       you can use this parameter in a html POST form
       after processing the POST request winix will make a redirect to the value



git-svn-id: svn://ttmath.org/publicrep/winix/trunk@881 e52654a7-88a9-db11-a3e9-0013d4bc506e
2012-09-04 20:24:42 +00:00
43b4075b16 added: ezc functions:
void dir_tab_subject(Info & i);
       void dir_tab_is_root(Info & i);
changed: in dir_tab_link:
         now it doesn't print the proto and base address - you should use [doc_base_url]




git-svn-id: svn://ttmath.org/publicrep/winix/trunk@879 e52654a7-88a9-db11-a3e9-0013d4bc506e
2012-09-02 01:27:41 +00:00
8f8e44fee5 added: ezc functions:
void dir_is_no(Info & i)
       void dir_level_is(Info & i)
       void dir_last_url_is_no(Info & i)
       void item_no_is(Info & i)
       void item_url_is_no(Info & i)




git-svn-id: svn://ttmath.org/publicrep/winix/trunk@878 e52654a7-88a9-db11-a3e9-0013d4bc506e
2012-08-26 22:30:25 +00:00
260c12894d added: to Request options used by ezc generators:
bool gen_trim_white;
       bool gen_skip_new_line;
       bool gen_use_special_chars;
added: new ezc filter: fil_csv_escape
       for escaping csv fields





git-svn-id: svn://ttmath.org/publicrep/winix/trunk@877 e52654a7-88a9-db11-a3e9-0013d4bc506e
2012-08-26 19:53:47 +00:00
adf273479a fixed: WINIX_RAW_POST_STRING should have a different id
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@876 e52654a7-88a9-db11-a3e9-0013d4bc506e
2012-08-19 14:25:43 +00:00
54480da405 added: WINIX_RAW_POST_STRING plugin message
this is the raw string sent in POST method (in p1 pointer there is a pointer to std::string object)



git-svn-id: svn://ttmath.org/publicrep/winix/trunk@875 e52654a7-88a9-db11-a3e9-0013d4bc506e
2012-08-19 14:24:24 +00:00
90261b2005 added: a new plugin message: WINIX_POST_PARAMS
raw POST parameters
       in p1 there is a pointer to std::string meaning a parameter's name
       in p2 there is a pointer to std::string value
       this is sent only from PostParser
       PostMultiParser (multipart/form-data html forms) doesn't send this messsage
       there is no a session set (session pointer is null)




git-svn-id: svn://ttmath.org/publicrep/winix/trunk@874 e52654a7-88a9-db11-a3e9-0013d4bc506e
2012-08-19 13:50:58 +00:00
cc71c225a3 added: to DbBase:
bool EndTrans(bool everything_ok);



git-svn-id: svn://ttmath.org/publicrep/winix/trunk@873 e52654a7-88a9-db11-a3e9-0013d4bc506e
2012-08-15 19:33:20 +00:00
e739f30088 fixed: when using Request::ajax_serializer then we should not use html filter
(the filter can be used before we make the json answer -- not implemented yet)



git-svn-id: svn://ttmath.org/publicrep/winix/trunk@872 e52654a7-88a9-db11-a3e9-0013d4bc506e
2012-08-12 18:23:48 +00:00
51d95b49a0 added: to Request:
// used as a JSON output (when ajax_serializer is defined)
       // it will be serialized and have at least:
       // 'content' string - the whole html content
       // 'http_status' integer - http status code (e.g. 200)
       PT::Space ajax;
 
       // if not null then the request will have a JSON as an output
       PT::SpaceToJSON * ajax_serializer;




git-svn-id: svn://ttmath.org/publicrep/winix/trunk@871 e52654a7-88a9-db11-a3e9-0013d4bc506e
2012-08-08 16:04:48 +00:00
b5c155b927 added: export plugin
the possibility to export only non static files in a directory



git-svn-id: svn://ttmath.org/publicrep/winix/trunk@870 e52654a7-88a9-db11-a3e9-0013d4bc506e
2012-08-03 10:55:14 +00:00
5a5fe1b0cc fixed: export plugin
I forgotten to add exporting a directory



git-svn-id: svn://ttmath.org/publicrep/winix/trunk@869 e52654a7-88a9-db11-a3e9-0013d4bc506e
2012-08-03 10:24:24 +00:00
1c4e010fc1 I have forgotten to add: html/fun_export.html
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@868 e52654a7-88a9-db11-a3e9-0013d4bc506e
2012-08-03 09:39:25 +00:00
d8d523d983 added: 'export' winix function (export plugin)
exporting an item or the whole directory



git-svn-id: svn://ttmath.org/publicrep/winix/trunk@867 e52654a7-88a9-db11-a3e9-0013d4bc506e
2012-08-03 09:25:17 +00:00
1c2589a2f2 added: to Log:
void LogBinary(const char * blob, size_t blob_len);
       void LogBinary(const std::string & blob);
       int LogLevel();



git-svn-id: svn://ttmath.org/publicrep/winix/trunk@866 e52654a7-88a9-db11-a3e9-0013d4bc506e
2012-07-31 03:29:16 +00:00
1ec61ffa11 added: to Log:
operator<<(const PT::TextStreamBase<>())



git-svn-id: svn://ttmath.org/publicrep/winix/trunk@865 e52654a7-88a9-db11-a3e9-0013d4bc506e
2012-07-25 10:28:41 +00:00
ca0a5c9cbe changed: upload html
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@864 e52654a7-88a9-db11-a3e9-0013d4bc506e
2012-07-15 18:20:22 +00:00
8dd31e737f changed: css
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@862 e52654a7-88a9-db11-a3e9-0013d4bc506e
2012-07-15 15:57:45 +00:00
e98cca7fbc updated: jquery upload plugin (upload winix function)
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@861 e52654a7-88a9-db11-a3e9-0013d4bc506e
2012-07-15 15:49:48 +00:00
9830b0a50f added: to misc: UrlEncode which takes PT::TextStreamBase as an argument
added: to misc: QEncode which takes PT::TextStreamBase as an argument
added: to Locale: methods: IsKey, Get which takes PT::TextStreamBase as an argument




git-svn-id: svn://ttmath.org/publicrep/winix/trunk@860 e52654a7-88a9-db11-a3e9-0013d4bc506e
2012-07-10 16:50:59 +00:00
f76a0ca3e9 added: some ezc functions in menu plugin
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@859 e52654a7-88a9-db11-a3e9-0013d4bc506e
2012-07-02 19:15:50 +00:00
5a6d1991ac changed: config.space is available public now
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@858 e52654a7-88a9-db11-a3e9-0013d4bc506e
2012-06-30 23:20:18 +00:00
329e2d8001 fixed: when there is no option "locale_files" in the config
the "en" should be loaded by default
added: LDFLAGS option to Makefiles
added: compilation with CLANG (some const objects should have been created with default cctor)




git-svn-id: svn://ttmath.org/publicrep/winix/trunk@856 e52654a7-88a9-db11-a3e9-0013d4bc506e
2012-06-30 18:37:52 +00:00
403cca5aad rewritten: public interface in TemplatesFunctions::Locale
added a default parameter bool try_default_too = true to some methods: Get(), IsKey()
           added more methods for accessing by an internal index



git-svn-id: svn://ttmath.org/publicrep/winix/trunk@854 e52654a7-88a9-db11-a3e9-0013d4bc506e
2012-06-27 23:21:43 +00:00
b8ff5d4cfc added: winix functions: locale, timezone
changed: time zones -- now we have the daylight saving time
       different for each year (start, end)
added: config option: time_zone_id (size_t)
       time zone identifier for not logged users
       or for newly created accounts
       those identifiers you can see in etc/time_zones.conf file
       or by using timezone winix function with 'a' parameter (timezone/a) (!!IMPROVE ME NOT IMPLEMENTED YET)
       default: 34 (Coordinated Universal Time UTC+00:00)
added: config option: locale_default_id (size_t)
       locale for not logged users
       or for newly created accounts
added: config option: locale_max_id (size_t)
       a maximum value of a locale identifier
       default: 100 (maximum: 1000)
       each locale files should have its own identifier (in "winix_locale_id" field)
       from zero to this value
added: config option: time_zone_max_id (size_t)
       maximum value of a time zone identifier
       time zones with an id greater than this will be skipped
       default: 130 (maximum: 1000)
removed: config option: locale_default



git-svn-id: svn://ttmath.org/publicrep/winix/trunk@852 e52654a7-88a9-db11-a3e9-0013d4bc506e
2012-06-26 23:19:19 +00:00
54e6c07efc added: etc directory to Makefile install
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@850 e52654a7-88a9-db11-a3e9-0013d4bc506e
2012-06-22 23:41:12 +00:00
d11cda3577 added: a new directory "etc"
there'll be some generic config files for winix
added: a new file in etc directory: time_zones_file
       list of time zones (not finished yet -- daylight saving time is needed)
added: option to config: etc_dir
       a directory in which there are some config files
       used mainly when winix starts
       default: empty (means not for using)
added: option to config: time_zones_file
       a file in etc_dir with time zones info
       default: time_zones.conf
       this is a Space structure with all time zones
added: to system: TimeZones struct
       list of time zones read from etc/time_zones.conf



git-svn-id: svn://ttmath.org/publicrep/winix/trunk@849 e52654a7-88a9-db11-a3e9-0013d4bc506e
2012-06-22 23:34:33 +00:00
abafb80caf added: time zone's names to locales
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@848 e52654a7-88a9-db11-a3e9-0013d4bc506e
2012-06-22 19:18:03 +00:00
e0dd85ca99 changed: making a redirect from SSL connection to non SSL
if either use_ssl in the config if false
         or if use_ssl_only_for_logged_users is true
         and a user is not logged
added:   base url redirect HTTP codes to the config
         // if current connection is without SSL and should be made through SSL
         // or if is via SSL and should be done in plain text
         // then we make a redirect
         // default: 303
         int use_ssl_redirect_code;

         // when the HOST_HTTP environment variable is not equal to 'base_url'
         // (the part 'http://' and the last slash is removed)
         // the server will redirect into base_url + 'REQUEST_URI'
         // it's useful when you want to redirect from 'mydomain.tld' into 'www.mydomain.tld' etc.
         // set this option to false if you have multiple subdomains
         // default: false
         bool base_url_redirect;




git-svn-id: svn://ttmath.org/publicrep/winix/trunk@847 e52654a7-88a9-db11-a3e9-0013d4bc506e
2012-06-07 00:26:37 +00:00
2c38fe180e added: new function for ezc templating:
void space_value_noescape(Info & i, PT::Space & space)



git-svn-id: svn://ttmath.org/publicrep/winix/trunk@846 e52654a7-88a9-db11-a3e9-0013d4bc506e
2012-06-05 21:31:12 +00:00
0d0f12b394 added: to Requst:
std::wstring * PostVarp(const std::wstring & var);
added: to misc:
       template<class CharType>
       bool Toa(unsigned/signed long/int value, CharType * buffer);
       some Toa methods which don't get the buffer len
       (the buffer has to be sufficient big)




git-svn-id: svn://ttmath.org/publicrep/winix/trunk@845 e52654a7-88a9-db11-a3e9-0013d4bc506e
2012-06-04 17:51:43 +00:00
86d6c96aeb fixed: winix_subdomain ezc function
didn't print the subdomain
added: to rm winix function:
       bool Rm::RemoveItemByPath(const std::wstring & path, bool check_access)
fixed: in Upload winix function
       when uploading an image we have to get
       a mount point where the image is placed (parent dir)
       (it was cur->mount beforehand)



git-svn-id: svn://ttmath.org/publicrep/winix/trunk@844 e52654a7-88a9-db11-a3e9-0013d4bc506e
2012-06-03 02:14:33 +00:00
b605fb0a77 added: some ezc functions for subdomains:
void winix_subdomain(Info & i);
       void winix_subdomain_is_empty(Info & i);
       void winix_subdomain_is_not_empty(Info & i);
       void winix_subdomain_is(Info & i);




git-svn-id: svn://ttmath.org/publicrep/winix/trunk@843 e52654a7-88a9-db11-a3e9-0013d4bc506e
2012-05-30 21:14:03 +00:00
ec773e5f29 added: TimeZone struct (core)
this class has information about a time zone (utf offset, daylight saving time)
       and methods for converting between UTC and local time
       structs User and Config has a TimeZone object
       System::ToLocal() and System::ToUTC() uses it for converting
       (depending whether a user is logged or not)


git-svn-id: svn://ttmath.org/publicrep/winix/trunk@842 e52654a7-88a9-db11-a3e9-0013d4bc506e
2012-05-30 19:04:18 +00:00
9d5d088b4a removed: in some places a dependencies to tm struct has left
removed: operator<<(tm&) from streams: textstream, log, dbtextstream, htmltextstream



git-svn-id: svn://ttmath.org/publicrep/winix/trunk@840 e52654a7-88a9-db11-a3e9-0013d4bc506e
2012-05-27 18:11:34 +00:00
1b858f5782 removed: dependencies to 'tz' system structure
now we are using PT::Date from pikotools



git-svn-id: svn://ttmath.org/publicrep/winix/trunk@839 e52654a7-88a9-db11-a3e9-0013d4bc506e
2012-05-26 23:04:49 +00:00
5b845f1d03 changed: in Request:
removed start_tm
         added start_date (PT::Date)
changed: in Session:
         removed: tm_time
         added: start_date (PT::Date)
         renamed: time -> start_time
         the same is for last_time
         now we have (last_time and last_date)



git-svn-id: svn://ttmath.org/publicrep/winix/trunk@838 e52654a7-88a9-db11-a3e9-0013d4bc506e
2012-05-24 21:09:37 +00:00
db9d381a43 added: to thread manager: names of the threads
the names are shown in the log file


git-svn-id: svn://ttmath.org/publicrep/winix/trunk@837 e52654a7-88a9-db11-a3e9-0013d4bc506e
2012-05-19 17:04:33 +00:00
0df088e1e2 fixed: when demonizing there were some logs info put twice in the log file
now we first demonize (fork) and then open the log file
added: start adding support for PT::Date 
       we are using instead of tz system structure



git-svn-id: svn://ttmath.org/publicrep/winix/trunk@836 e52654a7-88a9-db11-a3e9-0013d4bc506e
2012-05-19 15:14:35 +00:00
67099d5d06 changed: misc::OnlyDigit()
a comma is changed to a dot


git-svn-id: svn://ttmath.org/publicrep/winix/trunk@835 e52654a7-88a9-db11-a3e9-0013d4bc506e
2012-05-12 20:30:34 +00:00
07e8e0c63c updated: to the new Space API (pikotools)
changed: in locale txt files:
         the '(' and ')' characters should be escaped '\(' and '\)'
         or the whole string should be quoted
added:   when parsing locale files we print the line number where there was a syntax error



git-svn-id: svn://ttmath.org/publicrep/winix/trunk@833 e52654a7-88a9-db11-a3e9-0013d4bc506e
2012-05-12 16:37:44 +00:00
ecc89d8596 added: two plugin's messages
// a session is going to be removed
// it is called from session manager's thread (with lock/unlock)
#define WINIX_PREPARE_SESSION_TO_REMOVE          30027

// a session has been removed
// it is called from session manager's thread (with lock/unlock)
// in l1 you have the old session id
#define WINIX_SESSION_REMOVED                    30029




git-svn-id: svn://ttmath.org/publicrep/winix/trunk@832 e52654a7-88a9-db11-a3e9-0013d4bc506e
2012-05-01 17:58:42 +00:00
c94b0311b6 updated: to the new Pikotools API
ConfParser is now SpaceParser
added:   to SessionManager
         Session * SessionManager::FindSession(long id)



git-svn-id: svn://ttmath.org/publicrep/winix/trunk@831 e52654a7-88a9-db11-a3e9-0013d4bc506e
2012-04-30 22:53:54 +00:00
fc33b4f882 added: a deadlock counter to Synchro class
now we can use Lock() more than one in the same thread
       and next Unlock() will recognize it
       sample:
       Lock(); // first lock -- resources locked
       Lock(); // second lock -- skipped (counter incremented)
       ...
       Unlock(); // first unlock -- skipped (because counter greater than zero)
       Unlock(); // second unlock -- actually unlocking


git-svn-id: svn://ttmath.org/publicrep/winix/trunk@830 e52654a7-88a9-db11-a3e9-0013d4bc506e
2012-04-28 20:57:57 +00:00
1da1eef768 fixed: ThreadMenager should use Lock/Unlock in StartAll() method
added: Job class (system->job object)
       a general mechanism for jobs (by using PT::Space as a job structure)
       WINIX_JOB plugin message will be sent with a pointer to PT::Space



git-svn-id: svn://ttmath.org/publicrep/winix/trunk@829 e52654a7-88a9-db11-a3e9-0013d4bc506e
2012-04-25 22:24:37 +00:00
baf10a9ba9 added: std::wstring Request::subdomain
support for subdomains



git-svn-id: svn://ttmath.org/publicrep/winix/trunk@828 e52654a7-88a9-db11-a3e9-0013d4bc506e
2012-04-22 18:23:44 +00:00
bcea4f9464 fixed: base_url_redirect config option was not read from the config file
and was not used when checking for base url redirect
fixed: return values from plugins should be given in a special structure
       they were remembered in plugin object (ret_false, ret_true)
       and consequently were not thread safe
       now all plugin.Call() methods return PluginRes structure 
       in which there are ret_false and ret_true variables       
changed: small refactoring in AddUser winix function



git-svn-id: svn://ttmath.org/publicrep/winix/trunk@827 e52654a7-88a9-db11-a3e9-0013d4bc506e
2012-04-22 13:30:07 +00:00
920290e9dc changed: permission to winix function 'who' and 'last'
(only logged users can use these functions)


git-svn-id: svn://ttmath.org/publicrep/winix/trunk@826 e52654a7-88a9-db11-a3e9-0013d4bc506e
2012-04-06 08:11:25 +00:00
1d83cf42a1 fixed: passwd winix funtion always changed a password for current user
(even if it was an administrator and has selected other people)


git-svn-id: svn://ttmath.org/publicrep/winix/trunk@825 e52654a7-88a9-db11-a3e9-0013d4bc506e
2012-03-30 06:44:38 +00:00
09bfdf9e77 added: two ezc functions:
void winix_postvar_value_is(Info & i);
       void winix_postvar_value_is_not(Info & i);



git-svn-id: svn://ttmath.org/publicrep/winix/trunk@824 e52654a7-88a9-db11-a3e9-0013d4bc506e
2012-03-28 00:09:27 +00:00
e83fd91423 rewritten: sessions management
(Session, SessionContainer, SessionManager)
           now a Session object don't copy all fields in its copy constructor (only id)
           the rest fields are set after the object is inserted in SessionContainer
added:     after successfully login a session id is changed
added:     plugin.Call() methods with a first argument a pointer to a Session object



git-svn-id: svn://ttmath.org/publicrep/winix/trunk@823 e52654a7-88a9-db11-a3e9-0013d4bc506e
2012-03-17 05:11:23 +00:00
70421b7bd1 reverted last commit (secure flag to cookie) with some info
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@822 e52654a7-88a9-db11-a3e9-0013d4bc506e
2012-03-15 17:50:19 +00:00
71ae70f670 added: to cookies: flag "; secure" if a connection is through SSL
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@821 e52654a7-88a9-db11-a3e9-0013d4bc506e
2012-03-15 10:43:29 +00:00
b1b3cea64e added: new plugin message: WINIX_PREPARE_USER_TO_LOGIN
a user will be logged in
        set PluginInfo::res to false (it is by default) to prevent logging the user
        directly after this message (if you do not return false)
        a WINIX_USER_LOGGED is sent
        in p1 you have a pointer to User struct
        (if at least one plugin returns false then the user will not be logged)



git-svn-id: svn://ttmath.org/publicrep/winix/trunk@820 e52654a7-88a9-db11-a3e9-0013d4bc506e
2012-03-14 20:25:30 +00:00
2712c57f15 changed: Makefile dep (dependencies from pikotools and tito were missing)
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@819 e52654a7-88a9-db11-a3e9-0013d4bc506e
2012-03-12 20:30:36 +00:00
0b528c7225 added: to misc:
void OnlyDigit(StringType & s, bool allow_comma = true)
       removes all non-digit characters from a string


git-svn-id: svn://ttmath.org/publicrep/winix/trunk@818 e52654a7-88a9-db11-a3e9-0013d4bc506e
2012-03-11 16:21:52 +00:00
b7007da5a9 fixed: misc: ValidateEmail() buffer overflow
added: notifications for resetting a user's password
       (there is no a winix function for this yet)



git-svn-id: svn://ttmath.org/publicrep/winix/trunk@817 e52654a7-88a9-db11-a3e9-0013d4bc506e
2012-03-09 22:56:54 +00:00
489310ba1c added: winix function: rmuser
changed: UGContainer<> now uses std::list as a storage
         (previously it was using std::vector with pointers)
removed: now we don't have the operator[] for UGContainer<>



git-svn-id: svn://ttmath.org/publicrep/winix/trunk@816 e52654a7-88a9-db11-a3e9-0013d4bc506e
2012-03-09 02:36:25 +00:00
6c2c12fe5e added: html/fun_pw.html
default view for pw winix function


git-svn-id: svn://ttmath.org/publicrep/winix/trunk@815 e52654a7-88a9-db11-a3e9-0013d4bc506e
2012-03-03 21:00:48 +00:00
e61f0db57e changed: export plugin:
password is stored as a string (in database)


git-svn-id: svn://ttmath.org/publicrep/winix/trunk@814 e52654a7-88a9-db11-a3e9-0013d4bc506e
2012-03-01 15:39:13 +00:00
3e3546a2fd fixed: plugin 'menu' incorrectly read directory items when the directory was en empty string
(the current directory should be used)


git-svn-id: svn://ttmath.org/publicrep/winix/trunk@813 e52654a7-88a9-db11-a3e9-0013d4bc506e
2012-03-01 15:14:46 +00:00
d2fa3b7171 corrected: in some places declarations of classes where mixed with struct (class/struct)
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@812 e52654a7-88a9-db11-a3e9-0013d4bc506e
2012-02-29 22:52:55 +00:00
0e9f587591 added: to IsWhite (core/misc)
other unicode white characters
       25 characters -- without a new line character (10)
added: config option: account_need_email_verification
       if true then when creating an account a user has to provide
       his email address and a message with an activation link will be sent 
       back to him
added: 'pw' winix function (not finished yet)
       at the moment only one parameter 'activate'



git-svn-id: svn://ttmath.org/publicrep/winix/trunk@810 e52654a7-88a9-db11-a3e9-0013d4bc506e
2012-02-28 21:09:44 +00:00
9208b15167 fixed: in winix function 'mv':
a recurrence loop - incorrect function was called (typo)
updated: to the new EZC api:
         templates from plugin menu
         templates from 'man' winix function


git-svn-id: svn://ttmath.org/publicrep/winix/trunk@809 e52654a7-88a9-db11-a3e9-0013d4bc506e
2012-02-27 17:43:59 +00:00
a45fb30e0a rewritten: plugin 'menu'
now we have a cache for the plugin
           (this limits the number of database requests)
added:     to plugin 'menu'
           menu_dir_tab can have a 'current' parameter (first argument)
           (it uses the last path from the previous menu_dir_tab) 
changed:   updated to the new EZC api
added:     new message to plugins: WINIX_DIR_ADDED


git-svn-id: svn://ttmath.org/publicrep/winix/trunk@808 e52654a7-88a9-db11-a3e9-0013d4bc506e
2012-02-24 12:09:38 +00:00
97c7edafd6 added: to misc:
UrlEncode() for char->wstring
         UrlEncode() for wstring->wstring
removed: Request::redirect_url_encoded flag
         the Request::redirect_to string should always be url-encoded
changed: in UrnEncode()
         now characters like '#' and '/' are not allowed in an url
         (will be url-encoded)
         


git-svn-id: svn://ttmath.org/publicrep/winix/trunk@807 e52654a7-88a9-db11-a3e9-0013d4bc506e
2012-02-19 00:59:08 +00:00
1a51b1adc7 added: to config:
parameter: ezc_max_elements
          maximum number for elements through the whole template (ezc)
          default: 50000
       parameter: ezc_max_loop_elements
          maximum number of each [for] loop
          default: 5000 (from ezc generator)
added: to Request class:
       time_t start_time;
       tm start_tm;
       they are set when a request starts
       


git-svn-id: svn://ttmath.org/publicrep/winix/trunk@806 e52654a7-88a9-db11-a3e9-0013d4bc506e
2012-02-17 05:19:24 +00:00
9d2be5c50d added: to misc:
void MaxSize(StringType & str, size_t max_size)
       if a string is larger than max_size then it is truncated to max_size characters


git-svn-id: svn://ttmath.org/publicrep/winix/trunk@805 e52654a7-88a9-db11-a3e9-0013d4bc506e
2012-02-14 20:35:35 +00:00
f381f24402 fixed: in DbBase: removed:
DbBase::AssertQuery(const std::wstring & q)
       there was a recurrence calling (the method called itself)
       we don't need a method which get a wstring as an argument
added: DbBase::AssertQuery(const char * q, ExecStatusType t)
       DbBase::AssertQuery(const DbTextStream & query, ExecStatusType t)
       (AssertQuery with a second argument -- the same as to AssertResult)
       we don't have to use AssertQuery and AssertResult
       only one AssertQuery now
added: to plugins: two messages:
       // preparing a current user to logout
       // send from 'logout' winix function
       // !! IMPROVE ME this message can be sent when winix is making the shutdown
       // (for sessions which are not mark as 'remember me')
       // and when the SessionManager deletes a session (from the special thread)
       #define WINIX_PREPARE_USER_LOGGED_OUT          30610

       // a user has been logged out
       // send from 'logout' winix function
       // in l1 you have the old user_id
       // !! IMPROVE ME this message can be sent when winix is making the shutdown
       // (for sessions which are not mark as 'remember me')
       // and when the SessionManager deletes a session (from the special thread)
       #define WINIX_USER_LOGGED_OUT                          30620



git-svn-id: svn://ttmath.org/publicrep/winix/trunk@804 e52654a7-88a9-db11-a3e9-0013d4bc506e
2012-02-12 14:52:52 +00:00
f6db85fcdb fixed: uninitialized variable in 'rm' winix function (in HasAccess method)
sometimes for directories the rm function could return 'access true' (even without 'r' parameter)



git-svn-id: svn://ttmath.org/publicrep/winix/trunk@803 e52654a7-88a9-db11-a3e9-0013d4bc506e
2012-02-10 00:50:05 +00:00
9687d5cd66 removed: operator<<(const PT::Space * space)
from textstream, log, dbtextstream, htmltextstream
added: compile option: -pthread



git-svn-id: svn://ttmath.org/publicrep/winix/trunk@802 e52654a7-88a9-db11-a3e9-0013d4bc506e
2012-02-10 00:29:54 +00:00
6e2d00bc5b added: now we have a fourth part in permissions (guests)
e.g.: 07555 means:
           7 for owner
           5 for group
           5 for others
           5 for guests (not logged users)
added:     the sticky bit for directories
           e.g. permissions to a directory with a sticky bit set
           can be set to: 017555
rewritten: rm/mv winix functions to correctly understand the sticky bit
added:     Dir::FollowLink() recognizes ".." and "." now
           consequently System::FollowAllLinks recognizes it too
added:     umask -- calculating privileges for new files/directories
           all users have their own umask (in meta)
           and there is one in the config
           (for guests and when a user has not definied its own one)
removed:   mount option: only_root_remove



git-svn-id: svn://ttmath.org/publicrep/winix/trunk@801 e52654a7-88a9-db11-a3e9-0013d4bc506e
2012-01-24 23:03:36 +00:00
5aaab89cd8 added: to locale: comparing lexicographically two characters/strings
int Compare(wchar_t c1, wchar_t c2);
       int Compare(const std::wstring & str1, const std::wstring & str2);
       
	   


git-svn-id: svn://ttmath.org/publicrep/winix/trunk@800 e52654a7-88a9-db11-a3e9-0013d4bc506e
2012-01-21 20:51:13 +00:00
7407d24586 added: new ezc filter: fil_first_wordup
first character in a word is capitalized


git-svn-id: svn://ttmath.org/publicrep/winix/trunk@799 e52654a7-88a9-db11-a3e9-0013d4bc506e
2012-01-21 17:13:00 +00:00
c9931da5ba fixed: plugin ticket: when a session expires all files from editticket were removed
it should be removed only those new added


git-svn-id: svn://ttmath.org/publicrep/winix/trunk@798 e52654a7-88a9-db11-a3e9-0013d4bc506e
2012-01-21 12:29:44 +00:00
4311f06ade added: to TextStream<> and Log:
operator<<(const tm & tm_)



git-svn-id: svn://ttmath.org/publicrep/winix/trunk@797 e52654a7-88a9-db11-a3e9-0013d4bc506e
2012-01-19 20:50:42 +00:00
8b64b5d372 updated plugins/ticket templates functions
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@796 e52654a7-88a9-db11-a3e9-0013d4bc506e
2012-01-18 17:55:28 +00:00
631ca4f8a3 plugin ticket: rewritten templates ezc functions
(now images/files are working fine)


git-svn-id: svn://ttmath.org/publicrep/winix/trunk@795 e52654a7-88a9-db11-a3e9-0013d4bc506e
2012-01-17 22:54:41 +00:00
424618de38 added: to templates: an interface for getting information from Space
miscspace.h, miscspace.cpp
changed: plugin ticket
         now as a config we use a PT::Space struct
         (not finished yet, only 'integer', 'select' and 'progress' are done)


git-svn-id: svn://ttmath.org/publicrep/winix/trunk@794 e52654a7-88a9-db11-a3e9-0013d4bc506e
2012-01-16 10:12:38 +00:00
b2d3ca9543 now winix is using 'pikotools' (confparser, utf8, mainparser)
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@792 e52654a7-88a9-db11-a3e9-0013d4bc506e
2012-01-12 02:24:08 +00:00
cb33f20a24 removing: confparser.h confparser.cpp
(moving to pikotools)


git-svn-id: svn://ttmath.org/publicrep/winix/trunk@791 e52654a7-88a9-db11-a3e9-0013d4bc506e
2012-01-11 11:32:01 +00:00
973d804db2 added: TextStream<> DbTextStream<> and HtmlTextStream<> have operator<<(Space&) now
added: to db: bool DbBase::AssertValueSpace(PGresult * r, int row, int col, Space & space, bool split_single)
added: environment variables for users
       User::env (of type Space) and
       User::aenv (of type Space) for admin variables (can be changed only by a super user)
added: winix function 'env'
       for changing User::env and User::aenv ('env' winix function with a 'a' parameter)



git-svn-id: svn://ttmath.org/publicrep/winix/trunk@790 e52654a7-88a9-db11-a3e9-0013d4bc506e
2012-01-08 03:59:51 +00:00
84eaa6b7b6 changed: rewritten templates/man
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@789 e52654a7-88a9-db11-a3e9-0013d4bc506e
2012-01-06 12:55:08 +00:00
f967a428ce added: winix function 'man'
displaying all winix functions and ezc templates functions


git-svn-id: svn://ttmath.org/publicrep/winix/trunk@787 e52654a7-88a9-db11-a3e9-0013d4bc506e
2012-01-06 12:07:23 +00:00
543d464cbc changed: plugin 'menu': ezc funtion: menu_dir_tab
now we have two parameters: first is a path and second is: "images", "dirs", "files" or empty
          


git-svn-id: svn://ttmath.org/publicrep/winix/trunk@786 e52654a7-88a9-db11-a3e9-0013d4bc506e
2012-01-02 02:05:12 +00:00
43470b2a41 forgotten to add html/index_rawcontent.html
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@785 e52654a7-88a9-db11-a3e9-0013d4bc506e
2011-12-17 22:02:49 +00:00
fa05e25a9d added: to config: 'content_type_header' parameter
the kind of "Content-Type" header send to the client
       if utf8 is enabled then 'charset=UTF-8' will also be appended
added: to templates: an index pattern for 'rawcontent'
       used when 'rawcontent' parameter is present
       by default the template has only one [content] ezc function
       useful in AJAX requests       


git-svn-id: svn://ttmath.org/publicrep/winix/trunk@784 e52654a7-88a9-db11-a3e9-0013d4bc506e
2011-12-17 21:59:22 +00:00
fe2f1605f1 changed: core/misc: date format in Time() methods
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@783 e52654a7-88a9-db11-a3e9-0013d4bc506e
2011-12-14 20:35:19 +00:00
48b5c167bf added to db stream: DbTextStream::operator<<(const std::vector<long> & tabid)
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@782 e52654a7-88a9-db11-a3e9-0013d4bc506e
2011-12-08 22:01:19 +00:00
08a0a36dfd changed: html (upload winix function)
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@781 e52654a7-88a9-db11-a3e9-0013d4bc506e
2011-12-05 18:20:48 +00:00
d135c31ca0 added: to htmlfilter: html "col" tag is a 'simple' tag
added: ezc functions: winix_function_param_value_is and winix_function_param_value_is_not
       they take two arguments: param_name and param_value



git-svn-id: svn://ttmath.org/publicrep/winix/trunk@780 e52654a7-88a9-db11-a3e9-0013d4bc506e
2011-12-04 19:34:39 +00:00
dce68221ad changed: plugin 'export'
rewritten changing of strings in html output
         (added support for https:// prefix)


git-svn-id: svn://ttmath.org/publicrep/winix/trunk@779 e52654a7-88a9-db11-a3e9-0013d4bc506e
2011-12-03 19:34:58 +00:00
93273bd470 changed: upload template
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@778 e52654a7-88a9-db11-a3e9-0013d4bc506e
2011-12-02 14:38:26 +00:00
92f7c11999 added: 'export' plugin can make use of some meta informations (from items)
additional export currently


git-svn-id: svn://ttmath.org/publicrep/winix/trunk@777 e52654a7-88a9-db11-a3e9-0013d4bc506e
2011-12-01 20:45:06 +00:00
024ce8e73c added: a new index template: index_fullscreen.html
is chosen automatically when 'fullscreen' parameter is passed


git-svn-id: svn://ttmath.org/publicrep/winix/trunk@776 e52654a7-88a9-db11-a3e9-0013d4bc506e
2011-12-01 18:54:09 +00:00
7902389ef1 changed: in plugin 'menu'
menu_dir_tab ezc functions can be nested now
         (not finished yet)
added:   'meta' winix function
         additional meta information for files and directories
         (not finished yet)



git-svn-id: svn://ttmath.org/publicrep/winix/trunk@775 e52654a7-88a9-db11-a3e9-0013d4bc506e
2011-11-25 04:51:55 +00:00
1e9ab2f805 added: to 'group' plugin: new ezc function: group_tab_is_current_link
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@774 e52654a7-88a9-db11-a3e9-0013d4bc506e
2011-10-30 23:47:43 +00:00
0550212b64 changed: GroupItem plugin has been renamed to Group
it's nearly finished
         now we are using three levels from Space (ConfParser)
         - group set
         - group
         - values
         


git-svn-id: svn://ttmath.org/publicrep/winix/trunk@773 e52654a7-88a9-db11-a3e9-0013d4bc506e
2011-10-16 21:33:45 +00:00
c7b6ca67a2 changed: plugin messages:
WINIX_FILE_REMOVED and WINIX_DIR_PREPARE_TO_REMOVE
         now as a parameter we have a pointer to the Item struct
changed: export plugin now exports all files from a directory
         (in the future there'll be an option how the plugin should behave)



git-svn-id: svn://ttmath.org/publicrep/winix/trunk@772 e52654a7-88a9-db11-a3e9-0013d4bc506e
2011-09-30 01:33:42 +00:00
9dae2de2fa fixed: FunctionParser skipped a function name after an item (file) if the name was not a name for a function
it should report a 404 in such a case


git-svn-id: svn://ttmath.org/publicrep/winix/trunk@771 e52654a7-88a9-db11-a3e9-0013d4bc506e
2011-09-28 22:24:24 +00:00
968593106e fixed: menu plugin: static files were not correctly skipped
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@770 e52654a7-88a9-db11-a3e9-0013d4bc506e
2011-09-26 06:56:35 +00:00
302cb0130d changed: menu plugin (static files are skipped)
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@769 e52654a7-88a9-db11-a3e9-0013d4bc506e
2011-09-26 06:39:05 +00:00
89efaa790f changed: ConfParser -- now we can have a tree (spaces can have more than one level)
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@768 e52654a7-88a9-db11-a3e9-0013d4bc506e
2011-09-26 05:40:26 +00:00
60f0e62c23 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
2011-09-16 22:46:42 +00:00
f113e2ef31 changed: we should use SSL connection for such functions as:
adduser, login


git-svn-id: svn://ttmath.org/publicrep/winix/trunk@766 e52654a7-88a9-db11-a3e9-0013d4bc506e
2011-09-14 09:56:00 +00:00
39923d6617 fixed: UGContainer<Type> used a std::vector<Type> and when a new item was inserted
then current iterators (and pointers) were invalidated
         now we are using std::vector<Type*>
         this caused some crashes when a new user was added by 'adduser' winix function
added:   plugin 'export' is able to upload files on a remote server now
         (not finished yet)
changed: Thumb class is now called: Image
         and we are able to resize images too
         (some new options in the config and in mount points)
added:   some new plugin messages



git-svn-id: svn://ttmath.org/publicrep/winix/trunk@764 e52654a7-88a9-db11-a3e9-0013d4bc506e
2011-09-13 06:08:34 +00:00
72be443414 added: new flag: Request::using_ssl
true if the connections is encrypted by using SSL
changed: in BaseUrlRedirect
         we also check if the connection should use SSL 
         and if so then we make a redirect to "https://.."
changed: in 'static' mount points:
         if the request was e.g. "/styles/default.js?t=B49E5BQ"
         we should return a file "/styles/default.js" (without the "?..." part)
         additionally '#' character is checked



git-svn-id: svn://ttmath.org/publicrep/winix/trunk@762 e52654a7-88a9-db11-a3e9-0013d4bc506e
2011-09-06 22:46:15 +00:00
392e8060ba added: some work in Export plugin
changed: in base redirect we are using 301 moved permanently status code now (was 303)


git-svn-id: svn://ttmath.org/publicrep/winix/trunk@761 e52654a7-88a9-db11-a3e9-0013d4bc506e
2011-09-05 15:38:09 +00:00
8c01b0f6c0 added: two tables to locales/substitute: smallleters, capitalics
added: locale.ToSmall(wchar_t), locale.ToCapital(wchar_t)
       now we are able to recognize other than ASCII characters
added: static/basic/winix.css with basic styles
removed: [include "item_options.html"] from html templates (fun_cat.html and others)




git-svn-id: svn://ttmath.org/publicrep/winix/trunk@760 e52654a7-88a9-db11-a3e9-0013d4bc506e
2011-08-29 22:23:54 +00:00
b984475e49 fixed: index templates and 'change' templates were not cleared when 'reload' function was called
so wrong indexes have been assigned


git-svn-id: svn://ttmath.org/publicrep/winix/trunk@759 e52654a7-88a9-db11-a3e9-0013d4bc506e
2011-08-27 03:12:33 +00:00
4f114ea33c added: ezc function: dir_has_parents
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@758 e52654a7-88a9-db11-a3e9-0013d4bc506e
2011-08-26 20:45:58 +00:00
5b8a9c0108 added: Patterns class (in templates)
ezc patterns are managed by this class
added: some work in groupitem plugin (not finished yet)
changed: ConfParser can read a string from memory now
         (need some testing yet)



git-svn-id: svn://ttmath.org/publicrep/winix/trunk@757 e52654a7-88a9-db11-a3e9-0013d4bc506e
2011-08-25 23:53:49 +00:00
ee6500ac65 added: some more orphans to polish default locale
added: new options to the config:
  url_proto: default: http://
  url_ssl_proto: default: https://
  use_ssl, use_ssl_static, use_ssl_common (whether or not to use SSL protocol)
  use_ssl_only_for_logged_users
  now we are able to use SSL encryption (https) together with normal connections
removed: config option: base_server




git-svn-id: svn://ttmath.org/publicrep/winix/trunk@755 e52654a7-88a9-db11-a3e9-0013d4bc506e
2011-08-17 23:09:47 +00:00
3b2a1c3f25 added: new winix function: "sort"
sorting items in a directory (Item::sort_index is used)


git-svn-id: svn://ttmath.org/publicrep/winix/trunk@754 e52654a7-88a9-db11-a3e9-0013d4bc506e
2011-08-02 00:10:45 +00:00
4d87359aca added: Export plugin (not finished yet)
added:   ThreadManager
         all threads are connected to the ThreadManager
         they are started/stopped by the manager
changed: FunctionParser
         now we are parsing directly what is in URI
         (we were using GetParser beforehand)
         we are able to recognize ordinary URI scheme (with '?' and '#' characters)
         sample:
         http://domain.com/dir1/dir2/item/function?par1=val2&par2=val2#htmlanchor
         is the same as:
         http://domain.com/dir1/dir2/item/function/par1:val2/par2:val2#htmlanchor
         'htmlanchor' is put in Request::anchor field,
         and the default function can be used like this:
         http://domain.com/dir1/dir2/item?par1=val2&par2=val2#htmlanchor
         but there is not an equivalent in winix form
         e.g. http://domain.com/dir1/dir2/item/par1:val2/par2:val2#htmlanchor
         because 'par1:val2' would be treated as a function name
removed: GetParser
         now we don't have Request::get_tab structure
removed: CKEditorGetParser
         it is not needed now



git-svn-id: svn://ttmath.org/publicrep/winix/trunk@752 e52654a7-88a9-db11-a3e9-0013d4bc506e
2011-07-28 22:18:10 +00:00
c37c1ff812 fixed: as we have insert_page ezc function now
we cannot delete ezc patterns when PatternCacher::GetPattern() method is called
       because we can delete a pattern which is in use
       now deleting is performed at the end of a request


git-svn-id: svn://ttmath.org/publicrep/winix/trunk@751 e52654a7-88a9-db11-a3e9-0013d4bc506e
2011-07-15 02:09:02 +00:00
1812a2e9ad added: new plugin: menu
fixed: System::FollowAllLinks didn't check permissions to a file (only to a simlink or a directory)
added: new ezc function: insert_page
       now we are able to nest pages in pages



git-svn-id: svn://ttmath.org/publicrep/winix/trunk@750 e52654a7-88a9-db11-a3e9-0013d4bc506e
2011-07-13 23:14:10 +00:00
ccc02f41bf added: we can use different redirect codes now
(int Request::redirect_type variable)
       we can set following integer values:
       300 - Multiple Choices
       301 - Moved Permanently
       302 - Found
       307 - Temporary Redirect
       303 - See Other
       default is 303 for all redirects



git-svn-id: svn://ttmath.org/publicrep/winix/trunk@749 e52654a7-88a9-db11-a3e9-0013d4bc506e
2011-07-07 17:02:14 +00:00
eaf10c70b7 added: a new winix function: passwd
for changing your password
       or if you are a super user you can
       change a password for anyone
added: uname prints available plugins now



git-svn-id: svn://ttmath.org/publicrep/winix/trunk@748 e52654a7-88a9-db11-a3e9-0013d4bc506e
2011-06-27 21:38:19 +00:00
06f42dd9cb changed: winix 'upload' function is a file manager now
we're using an jquery upload plugin
added:   Item struct has new rows: hash, hash_type, file_size, sort_index
added:   css mount parameter
         you can specify css files there, and javascript wysiwyg editors
         (ckeditor, tinymce) can make use of it
changed: post parsers can parse post variables with the same name
         (a postfix is added in such a case)
added:   common_dir parameter to the config
         this is a path to common directory (directory with common static files)
         it is needed to the 'css' mount parameter
         


git-svn-id: svn://ttmath.org/publicrep/winix/trunk@746 e52654a7-88a9-db11-a3e9-0013d4bc506e
2011-06-24 20:53:21 +00:00
1d6ff73aad added: new winix function: mount
displaying all mount points
changed: struct Cur has now 'mount' pointer
         we should not use system->mounts.pmount now
         (it will be removed in the future)
changed: all mount point parameters are now propagated to childs mount points
         (if not defined there)



git-svn-id: svn://ttmath.org/publicrep/winix/trunk@745 e52654a7-88a9-db11-a3e9-0013d4bc506e
2011-06-21 21:24:49 +00:00
700a6fe643 updated index.html
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@742 e52654a7-88a9-db11-a3e9-0013d4bc506e
2011-06-19 21:07:23 +00:00
0a7432b059 added: SLog class -- session logger
messages are displayed in the browser (with locales)
changed: MountParser
         now if there is an error in a line -- the line is simply skipped
         


git-svn-id: svn://ttmath.org/publicrep/winix/trunk@741 e52654a7-88a9-db11-a3e9-0013d4bc506e
2011-06-19 20:59:58 +00:00
b369fda1d9 deleted some log info
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@740 e52654a7-88a9-db11-a3e9-0013d4bc506e
2011-06-19 10:40:09 +00:00
c49c35cfbd added: a new mount type: static
some path in winix can be redirected to a specified static directory


git-svn-id: svn://ttmath.org/publicrep/winix/trunk@738 e52654a7-88a9-db11-a3e9-0013d4bc506e
2011-06-14 23:45:42 +00:00
fb4742e165 added: nicedit: a new wysiwyg javascript editor
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@737 e52654a7-88a9-db11-a3e9-0013d4bc506e
2011-06-13 01:06:10 +00:00
fce45b93a2 fixed: users: flag 'super_user' was not correctly read ftom the database
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@736 e52654a7-88a9-db11-a3e9-0013d4bc506e
2011-06-09 23:00:00 +00:00
18ecd46a01 changed: when winix demonizes it creates a three new descriptors (0, 1 and 3)
pointing to /dev/null
added:   DbBase::AssertValueBin(PGresult * r, int row, int col, std::string & result)
         it reads binary (bytea) data
added:   DbTextStream can handle 'bool' types now
         (is puts 'true' of 'false' to the stream)
changed: now passwords can be stored either as plain text, a hash or can be encrypted
         with RSA
         currently we have following hashes:
         md4, md5, sha1, sha224, sha256, sha384, sha512
         we are using openssl to manage them
         (look at config options for more info)
changed: winix version to 0.4.7         
added:   class Run - you can run any program from os and send a buffer to its standard input
         and read what the program put on its standard output
added:   class Crypt (in System) - calculating hashes, and crypting/decrypting




git-svn-id: svn://ttmath.org/publicrep/winix/trunk@734 e52654a7-88a9-db11-a3e9-0013d4bc506e
2011-06-09 21:22:08 +00:00
af8fbdae72 added: now winix will not log post parameters with 'pass' in names (at the beginning)
changed: only first few characters are logged (from POST)


git-svn-id: svn://ttmath.org/publicrep/winix/trunk@733 e52654a7-88a9-db11-a3e9-0013d4bc506e
2011-06-06 22:47:34 +00:00
c84997be30 small changes in Makefiles
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@731 e52654a7-88a9-db11-a3e9-0013d4bc506e
2011-06-06 20:35:56 +00:00
06551d6084 added: "str" "strnc" ezc functions
changed: ezc functions:
         "winix_false" to "false"
         "winix_true"  to "true"


git-svn-id: svn://ttmath.org/publicrep/winix/trunk@730 e52654a7-88a9-db11-a3e9-0013d4bc506e
2011-04-26 17:19:08 +00:00
84145d7cc8 fixed: BBCODEParser incorrectly worked with the latest changes in HTMLFilter
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@729 e52654a7-88a9-db11-a3e9-0013d4bc506e
2011-04-16 11:27:54 +00:00
426beae796 renamed: config option 'html_filter_break_lines' to 'html_filter_break_word'
added:   config option 'html_filter_wrap_line'
         this wraps the whole line (line calculated with html tags as well)
changed: orphans (for html filter) are read from locale files now
         ('language_orphans' value )



git-svn-id: svn://ttmath.org/publicrep/winix/trunk@728 e52654a7-88a9-db11-a3e9-0013d4bc506e
2011-04-16 08:42:22 +00:00
aadf12c7b3 added support for gzip compression
new config option: compression_encoding (integer)
 1  - use deflate if available (or raw deflate for Internet Explorer) or don't compress
 2  - use gzip if available or don't compress
 10 - prefer deflate -- use deflate (or raw deflate for IE) if both deflate and gzip are available
 20 - prefer gzip    -- use gzip if both deflate and gzip are available
 default: 20

		   


git-svn-id: svn://ttmath.org/publicrep/winix/trunk@727 e52654a7-88a9-db11-a3e9-0013d4bc506e
2011-04-02 00:10:16 +00:00
1b60935d08 updated 'galleria' js plugin
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@726 e52654a7-88a9-db11-a3e9-0013d4bc506e
2011-04-01 16:30:14 +00:00
d68731fd55 fixed: thread plugin didn't correctly set the last item and replies (in 'thread' table)
when deleting an answer
added: ThreadInfo::Repair() method
       will be used by 'fsck' winix function       
added: plugins/groupitem 
       directory for a new plugin: 'groupitem'
       


git-svn-id: svn://ttmath.org/publicrep/winix/trunk@725 e52654a7-88a9-db11-a3e9-0013d4bc506e
2011-03-23 17:54:53 +00:00
ba63c8c661 changed: removed Languages::Land enum
now we set the languages in the config file: option locale_files, sample:
  locale_files = ( en, pl )
it represents the name of locale files (those from locale_dir directory)
renamed config option: locale to locale_default


git-svn-id: svn://ttmath.org/publicrep/winix/trunk@722 e52654a7-88a9-db11-a3e9-0013d4bc506e
2011-02-24 17:06:12 +00:00
15487b347f added ezc function: winix_function_param_is_not
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@721 e52654a7-88a9-db11-a3e9-0013d4bc506e
2011-02-22 04:14:26 +00:00
e7e90c6527 txt templates (a new line was missing)
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@720 e52654a7-88a9-db11-a3e9-0013d4bc506e
2011-02-18 09:35:35 +00:00
ca5421347a fixed: a new created session doesn't have a correct time set
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@719 e52654a7-88a9-db11-a3e9-0013d4bc506e
2011-02-18 09:33:15 +00:00
c8a57f2046 added: to gallery plugin: gallery_theme() mount option
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@718 e52654a7-88a9-db11-a3e9-0013d4bc506e
2011-02-15 23:20:12 +00:00
583df13139 added: mount options: thumb_size(cx, cy)
size of a generated thumbnail (size in pixels)
added: plugin gallery: mount option gallery_type
       it can be:
       "lightbox"
       "galleria"
       "galleriathumb"


git-svn-id: svn://ttmath.org/publicrep/winix/trunk@717 e52654a7-88a9-db11-a3e9-0013d4bc506e
2011-02-11 21:37:28 +00:00
5049961e17 added a new plugin: "gallery"
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@716 e52654a7-88a9-db11-a3e9-0013d4bc506e
2011-01-31 15:51:53 +00:00
18492e5d61 changed templates
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@715 e52654a7-88a9-db11-a3e9-0013d4bc506e
2011-01-27 14:35:25 +00:00
d4d9f89d1d changed: ticket templates
added: new plugin message (WINIX_END_REQUEST)


git-svn-id: svn://ttmath.org/publicrep/winix/trunk@714 e52654a7-88a9-db11-a3e9-0013d4bc506e
2011-01-27 12:24:45 +00:00
ecf19034ae added: winix uses now [filter] statement from ezc
added: notifications to threads (were temporarily disabled)
changed: templates in notifications



git-svn-id: svn://ttmath.org/publicrep/winix/trunk@712 e52654a7-88a9-db11-a3e9-0013d4bc506e
2011-01-26 12:45:38 +00:00
00521c490e added: Q encoding in misc: QEncode()
for mails headers encoding



git-svn-id: svn://ttmath.org/publicrep/winix/trunk@711 e52654a7-88a9-db11-a3e9-0013d4bc506e
2011-01-25 11:54:46 +00:00
3071df227a fixed: find_ticket_value (in plugins/ticket/templates.cpp)
should find the first item (can be more than one item with the same 'param')

fixed: added sorting tickets params in ReadTicketParams() (in plugins/ticket/ticketinfo.cpp)

fixed: plugin should have its own 'PluginInfo info' struct
a plugin's function can call another plugin's functions

added: removing tickets files/images

added: removing threads

changed: rm function will call WINIX_FILE_REMOVED now when deleting directories





git-svn-id: svn://ttmath.org/publicrep/winix/trunk@710 e52654a7-88a9-db11-a3e9-0013d4bc506e
2011-01-23 23:23:24 +00:00
915cabdf97 changed: added Cur structure
we have there two pointers: 
 Request * request;
 Session * session;
these are the current request and the current session


the session GC was moved to SessionManager (was in SessionContainer)



git-svn-id: svn://ttmath.org/publicrep/winix/trunk@708 e52654a7-88a9-db11-a3e9-0013d4bc506e
2011-01-23 14:15:30 +00:00
61ac29b2de added in ticket/templates.cpp binary search for tickets and tickets parameters
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@707 e52654a7-88a9-db11-a3e9-0013d4bc506e
2011-01-21 16:16:52 +00:00
ab84a5169e 'tickets' can use 'threads' now
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@706 e52654a7-88a9-db11-a3e9-0013d4bc506e
2011-01-20 18:37:51 +00:00
3fad25b8c8 moved some thread files to plugins/thread
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@705 e52654a7-88a9-db11-a3e9-0013d4bc506e
2011-01-05 21:44:19 +00:00
8154c403d8 we can create links (hard links, symbolic links) now
added winix functions: ln

winix function 'default' can be used without redirecting now

added new tickets types: TypeProgress, TypeString, TypeMultistring, TypeImages, TypeFiles
now tickets are combined with files
added winix functions: showtickets

fixed mountpoints:
when the default root mount was created its parameter table was empty
and it caused accessing to a non-existing objects

fixed logger:
modifiers (log1, log2, log3) were incorrectly treated
added modifier: log4 (debug info)

now we are moving threads to a new plugin 'thread'
created directory: plugins/thread
(not finished yet)




git-svn-id: svn://ttmath.org/publicrep/winix/trunk@704 e52654a7-88a9-db11-a3e9-0013d4bc506e
2011-01-05 21:24:11 +00:00
bb83aed20d changed cat template
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@703 e52654a7-88a9-db11-a3e9-0013d4bc506e
2010-12-12 09:41:20 +00:00
600c9fc907 Thumb thread should check the exit signal
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@701 e52654a7-88a9-db11-a3e9-0013d4bc506e
2010-12-12 09:25:36 +00:00
5d09eb149c added a special thread for making thumbnails (thumb.h thumb.cpp)
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@700 e52654a7-88a9-db11-a3e9-0013d4bc506e
2010-12-11 22:55:48 +00:00
e854fe3681 changed makefile
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@698 e52654a7-88a9-db11-a3e9-0013d4bc506e
2010-12-10 21:20:01 +00:00
36c8822e6c changed organization of static files
removed: item.auth item.auth_path
added:   item.file_path, item.file_fs, item.file_type
now the path to a static file is a relative path
added: thumbnails (not finished yet)
fixed: db didn't correctly return the number of deleted items /DelItem() method/




git-svn-id: svn://ttmath.org/publicrep/winix/trunk@696 e52654a7-88a9-db11-a3e9-0013d4bc506e
2010-12-10 21:07:01 +00:00
9b29cce1a4 added a special default function: "-"
the proper default function will be selected automatically


git-svn-id: svn://ttmath.org/publicrep/winix/trunk@695 e52654a7-88a9-db11-a3e9-0013d4bc506e
2010-12-07 18:18:45 +00:00
508f06339e added to config: session_max
how many sessions can be: default 1000000 (one milion)


git-svn-id: svn://ttmath.org/publicrep/winix/trunk@694 e52654a7-88a9-db11-a3e9-0013d4bc506e
2010-12-07 17:41:28 +00:00
0a9cdd2f15 added: gc for sessions (another thread)
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@693 e52654a7-88a9-db11-a3e9-0013d4bc506e
2010-12-07 12:52:52 +00:00
7f77b6e3ec added ezc function: user_is_in_all_groups
changed: ezc function user_is_in_group (we can provide more than one group now)


git-svn-id: svn://ttmath.org/publicrep/winix/trunk@691 e52654a7-88a9-db11-a3e9-0013d4bc506e
2010-12-06 01:37:30 +00:00
9507b0b1ba changed Makefile
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@690 e52654a7-88a9-db11-a3e9-0013d4bc506e
2010-12-06 00:32:12 +00:00
ad9d6f4301 db: core/user table has only 'notify' column now (previous was cms_notify, thread_notify)
added: notifications for tickets (not finished yet)


git-svn-id: svn://ttmath.org/publicrep/winix/trunk@688 e52654a7-88a9-db11-a3e9-0013d4bc506e
2010-12-06 00:25:46 +00:00
b721fb6860 changed path templatesnotifiy/ to notify/
i forgot to add a file: notify/notify.cpp


git-svn-id: svn://ttmath.org/publicrep/winix/trunk@687 e52654a7-88a9-db11-a3e9-0013d4bc506e
2010-12-02 02:36:49 +00:00
5f46cd2ea5 moved: templatesnotify -> notify
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@686 e52654a7-88a9-db11-a3e9-0013d4bc506e
2010-12-02 02:16:11 +00:00
35efed9fef - now the mess with threads has gone away
- we have a class BaseThread -- this is a base class -- we can inherit from it when
  creating a new thread
- others treads are correctly stopped (when signal comes) -- pthread_join
- we have a special thread only for signals



git-svn-id: svn://ttmath.org/publicrep/winix/trunk@685 e52654a7-88a9-db11-a3e9-0013d4bc506e
2010-12-02 01:02:02 +00:00
08e53919e2 changed: updated to the new ezc api, this with O(1) when looking for a specific ezc function
changed: sessions are deleted at the end of a request (and only a few sessions)
         other sessions will be deleted after a next request


git-svn-id: svn://ttmath.org/publicrep/winix/trunk@684 e52654a7-88a9-db11-a3e9-0013d4bc506e
2010-11-25 22:42:24 +00:00
933c8841ff added: uptime winix function prints how many sessions there are
changed: functions for text/numbers conversions
         int Toi(const std::string & str,  int base = 10);
         int Toi(const std::wstring & str, int base = 10);
         int Toi(const char * str,         int base = 10);
         int Toi(const wchar_t * str,      int base = 10);

         long Tol(const std::string & str,  int base = 10);
         long Tol(const std::wstring & str, int base = 10);
         long Tol(const char * str,         int base = 10);
         long Tol(const wchar_t * str,      int base = 10);

         template<class CharType>
         bool Toa(unsigned long value, CharType * buffer, size_t buf_len, int base = 10);

         template<class CharType>
         bool Toa(long value, CharType * buffer, size_t buf_len, int base = 10);

         template<class CharType>
         bool Toa(unsigned int value, CharType * buffer, size_t buf_len, int base = 10);

         template<class CharType>
         bool Toa(int value, CharType * buffer, size_t buf_len, int base = 10);

         const wchar_t * Toa(unsigned int value,  int base = 10);
         const wchar_t * Toa(unsigned long value, int base = 10);
         const wchar_t * Toa(int value,  int base = 10);
         const wchar_t * Toa(long value, int base = 10);

         void Toa(int  value, std::string & res,  int base = 10, bool clear = true);
         void Toa(long value, std::string & res,  int base = 10, bool clear = true);
         void Toa(int  value, std::wstring & res, int base = 10, bool clear = true);
         void Toa(long value, std::wstring & res, int base = 10, bool clear = true);

added:   HtmlTextStream class (files htmltextstream.cpp htmltextstream.h in templates)
         this is a special stream for automatically escaping html tags
	     



git-svn-id: svn://ttmath.org/publicrep/winix/trunk@682 e52654a7-88a9-db11-a3e9-0013d4bc506e
2010-11-25 01:34:46 +00:00
518281e101 fixed: when signal comes winix properly exits
fixed:   when winix exits the session data were not properly destroyed (memory leak)
         we should set request.session pointer to each session when deleting sessions
         from session_container
         the session data were not properly destroyed when winix checked for 
         outdated sessions (and when it was removing them)
fixed:   performance (memcpy used too often)
         in some places there were reserve method used (on std::wstring/std::string objects)
         especially in AssignString() method and TextStream<> object
         if we add a new string we should check the new size
         and only call reserve() if the new size will be greater than existing one
         (plus some constant)
changed: fcgi objects moved to App class (from Request)
         now we use thread safe methods (e.g. FCGX_Accept_r)
added:   log_plugin_call option to the config
         default: false
         when true winix log when a plugin function is called
added:   winix parameter 'nostat' for not calculating statistics
         (useful when making performance tests)


git-svn-id: svn://ttmath.org/publicrep/winix/trunk@680 e52654a7-88a9-db11-a3e9-0013d4bc506e
2010-11-23 21:52:25 +00:00
515d4bab0d added ezc functions: winix_false, winix_true
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@679 e52654a7-88a9-db11-a3e9-0013d4bc506e
2010-11-22 01:12:46 +00:00
8e72a820dd added support for UTF-8
now the UTF-8 is a default charset


git-svn-id: svn://ttmath.org/publicrep/winix/trunk@677 e52654a7-88a9-db11-a3e9-0013d4bc506e
2010-11-21 00:19:17 +00:00
f1f0fa34cb fixed: didn't compile
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@676 e52654a7-88a9-db11-a3e9-0013d4bc506e
2010-11-04 17:13:13 +00:00
5010ef93e8 added temporary debug info to Notify::ItemChanged() method
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@674 e52654a7-88a9-db11-a3e9-0013d4bc506e
2010-11-04 17:05:59 +00:00
e6679a3192 added a new winix function "vim" - an editor based on the WYMeditor
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@673 e52654a7-88a9-db11-a3e9-0013d4bc506e
2010-11-04 16:46:19 +00:00
7cf8d5d2d3 added: to htmlfilter: param tag has not an ending tag
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@672 e52654a7-88a9-db11-a3e9-0013d4bc506e
2010-10-25 18:00:23 +00:00
14198eca41 fixed: some log problems
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@671 e52654a7-88a9-db11-a3e9-0013d4bc506e
2010-10-24 19:31:43 +00:00
c6473f20dc now winix can demonize itself
parameter in the config: demonize (default: true)
 


git-svn-id: svn://ttmath.org/publicrep/winix/trunk@669 e52654a7-88a9-db11-a3e9-0013d4bc506e
2010-10-24 19:26:54 +00:00
9c34cb5862 winix can drop privileges now (if started as the root)
added parameters to the config:
 user (string)
 group (string)
 additional_groups (bool)



git-svn-id: svn://ttmath.org/publicrep/winix/trunk@668 e52654a7-88a9-db11-a3e9-0013d4bc506e
2010-10-24 17:49:38 +00:00
149fd1629f rm function can remove tickets now
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@667 e52654a7-88a9-db11-a3e9-0013d4bc506e
2010-10-23 23:51:44 +00:00
c48241f78a fixed: there were mktime() used on some dirs Items
so sometimes the time of the dir was changed

now for converting tm into time_t use:
time_t Time(const tm & par);
time_t Time(const tm * par);
tm     Time(time_t par);
from core/misc.h

now winix internally use GMT time
only when printing it is converted to local user time
temporarily all users use the same local time (config: time_zone_offset)
(only logs are genereted with local system time)

added to system:
time_t LocalTime(time_t gmt_time);
tm     LocalTime(const tm * ptm);
tm     LocalTime(const tm & ptm);
they convert GMT time to local user time




git-svn-id: svn://ttmath.org/publicrep/winix/trunk@666 e52654a7-88a9-db11-a3e9-0013d4bc506e
2010-10-23 23:12:47 +00:00
a1bee81a5b added 'stat' winix function
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@665 e52654a7-88a9-db11-a3e9-0013d4bc506e
2010-10-23 14:54:44 +00:00
1b053c03ba added: now plugin ticket uses a new horizontal table (plugins.ticket)
columns: dir_id, param, value
we are able to build complicated tickets 



git-svn-id: svn://ttmath.org/publicrep/winix/trunk@664 e52654a7-88a9-db11-a3e9-0013d4bc506e
2010-10-19 00:31:20 +00:00
33057acd62 added ticket parser: plugins/ticket/ticketparser.h plugins/ticket/ticketparser.cpp
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@663 e52654a7-88a9-db11-a3e9-0013d4bc506e
2010-10-11 20:42:49 +00:00
07511a2eb0 fixed: DbBase::ConvertTime(tm) should not have been used in this way as it was
(it uses a static buffer)
       now DbTextStream can get tm struct so you don't have to use ConvertTime 


git-svn-id: svn://ttmath.org/publicrep/winix/trunk@662 e52654a7-88a9-db11-a3e9-0013d4bc506e
2010-10-09 20:27:45 +00:00
69c634d53f added to core/misc:
bool EqualNoCase(const std::string & str1, const std::string & str2)


git-svn-id: svn://ttmath.org/publicrep/winix/trunk@660 e52654a7-88a9-db11-a3e9-0013d4bc506e
2010-10-01 23:20:03 +00:00
7bc17a9202 fixed: ticket sets a default function only for directories
fixed: reading a new url and subject in Functions::ReadItem()
added: tickets are sorted now (by date)



git-svn-id: svn://ttmath.org/publicrep/winix/trunk@659 e52654a7-88a9-db11-a3e9-0013d4bc506e
2010-09-30 20:58:20 +00:00
d94a08b991 moved: plugins/ticket/ticket.cpp -> plugins/ticket/templates.cpp
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@658 e52654a7-88a9-db11-a3e9-0013d4bc506e
2010-09-29 22:41:34 +00:00
a8b8c1feec tickets has been moved to a new plugin 'ticket'
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@657 e52654a7-88a9-db11-a3e9-0013d4bc506e
2010-09-29 21:24:34 +00:00
a589e5a090 added: TextStream a class similar to std::ostringstream
but with a Clear() method
       the dynamic allocated buffer can be easily reused
added: DbTextStream a special version of a stream
       used to create a database string query
       everything is escaped by default
added: DbBase a base class with some basic methods for communicating
       with the database
added: DbConn a class for managing connection to the database
changed: some refactoring in Db class       



git-svn-id: svn://ttmath.org/publicrep/winix/trunk@655 e52654a7-88a9-db11-a3e9-0013d4bc506e
2010-09-18 00:51:12 +00:00
8b1db3304f creating winix/db directory (for the database class)
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@654 e52654a7-88a9-db11-a3e9-0013d4bc506e
2010-09-16 10:20:20 +00:00
23aedd68b0 changed: mount points
mount type and mount fs are of type 'int' now
they can be added by plugins


git-svn-id: svn://ttmath.org/publicrep/winix/trunk@652 e52654a7-88a9-db11-a3e9-0013d4bc506e
2010-09-12 23:33:27 +00:00
f48f08a98b changed: notification's template
added: notifications in tickets


git-svn-id: svn://ttmath.org/publicrep/winix/trunk@650 e52654a7-88a9-db11-a3e9-0013d4bc506e
2010-09-07 23:54:01 +00:00
81dd88d25a fixed: there was missing html/fun_editticket.html template
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@649 e52654a7-88a9-db11-a3e9-0013d4bc506e
2010-09-05 18:58:24 +00:00
c92081d6e1 added: to stats plugin: microsoft bing searcher
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@648 e52654a7-88a9-db11-a3e9-0013d4bc506e
2010-08-28 21:19:30 +00:00
d6e80f5a23 fixed: plugins path
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@647 e52654a7-88a9-db11-a3e9-0013d4bc506e
2010-08-17 23:48:42 +00:00
37cf71234c changed makefile
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@645 e52654a7-88a9-db11-a3e9-0013d4bc506e
2010-08-17 23:33:27 +00:00
3b655f39e1 added: plugins_dir to config
small changes in makefiles


git-svn-id: svn://ttmath.org/publicrep/winix/trunk@643 e52654a7-88a9-db11-a3e9-0013d4bc506e
2010-08-17 22:32:47 +00:00
eec0ddf466 added: method ConfParser::UseEscapeChar(bool escape)
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@642 e52654a7-88a9-db11-a3e9-0013d4bc506e
2010-08-16 14:15:37 +00:00
ca4e53bb0f html code in editors (emacs, ckeditor...) is filtered now for normal users
(root is allowed to use any html code)


git-svn-id: svn://ttmath.org/publicrep/winix/trunk@641 e52654a7-88a9-db11-a3e9-0013d4bc506e
2010-08-14 17:56:07 +00:00
d9f2e91806 removed some debug logs from emacs
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@640 e52654a7-88a9-db11-a3e9-0013d4bc506e
2010-08-14 17:07:13 +00:00
7bfed62526 emacs didn't correctly report errors from db
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@639 e52654a7-88a9-db11-a3e9-0013d4bc506e
2010-08-14 16:55:16 +00:00
b63ac98f40 now winix waites for the database to be ready (when the operating system starts)
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@638 e52654a7-88a9-db11-a3e9-0013d4bc506e
2010-08-14 16:23:18 +00:00
1e7d297c0e small changes in template winix function
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@637 e52654a7-88a9-db11-a3e9-0013d4bc506e
2010-08-14 14:45:25 +00:00
f3cd3b88b9 some improvement in templates
(now we have O(1) time for selecting the right html template)
added: winix function: template
for selecting a template for an item (file or dir)



git-svn-id: svn://ttmath.org/publicrep/winix/trunk@636 e52654a7-88a9-db11-a3e9-0013d4bc506e
2010-08-13 20:04:57 +00:00
9a199cd834 part II of rewriting
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@635 e52654a7-88a9-db11-a3e9-0013d4bc506e
2010-08-12 19:10:12 +00:00
c3fac2e83f changed method: void PostMultiParser::ReadContentToFileLoop()
previous version was not clean


git-svn-id: svn://ttmath.org/publicrep/winix/trunk@634 e52654a7-88a9-db11-a3e9-0013d4bc506e
2010-08-11 15:47:44 +00:00
c7f6d2727c fixed: PostMultiParser incorrectly logged the size of input items (those which were not files)
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@633 e52654a7-88a9-db11-a3e9-0013d4bc506e
2010-08-11 10:00:23 +00:00
9901c63ede removed some thread and ticket information from request
they are in FunThread and FunTicket classes now
added funtion FunUptime (I forgot about it)



git-svn-id: svn://ttmath.org/publicrep/winix/trunk@631 e52654a7-88a9-db11-a3e9-0013d4bc506e
2010-08-10 20:43:38 +00:00
76897b8a83 I have forgotten to create classes: Ckeditor and Tinymce (in functions)
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@630 e52654a7-88a9-db11-a3e9-0013d4bc506e
2010-08-10 17:05:19 +00:00
217cf1420b the first part of reimplementing has been done
now we have app object and singletons are only: log logn plugin and app



git-svn-id: svn://ttmath.org/publicrep/winix/trunk@628 e52654a7-88a9-db11-a3e9-0013d4bc506e
2010-08-10 16:12:50 +00:00
6897192364 added: [dir_last_url_is] to templates
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@626 e52654a7-88a9-db11-a3e9-0013d4bc506e
2010-08-02 18:36:17 +00:00
031ace3fe5 changed: the way how plugins work
all your plugin functions can have signature either:
void my_function(PluginInfo & info); or
void my_function();
only the main Init should have:
extern "C" void Init(PluginFunction & info);

added: directory 'plugins' for plugins
added: 'stats' plugin
		  


git-svn-id: svn://ttmath.org/publicrep/winix/trunk@624 e52654a7-88a9-db11-a3e9-0013d4bc506e
2010-07-27 20:41:56 +00:00
e4683b9a05 fixed: in htmlfilter: <area> should be treated as single tag
changed: ConfParser is abble to recognize lists


git-svn-id: svn://ttmath.org/publicrep/winix/trunk@623 e52654a7-88a9-db11-a3e9-0013d4bc506e
2010-07-21 17:24:16 +00:00
93da32cfb3 updated to the new version of ezc
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@621 e52654a7-88a9-db11-a3e9-0013d4bc506e
2010-07-19 23:07:34 +00:00
62a0e52092 added: progress bar (image) to tickets table
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@620 e52654a7-88a9-db11-a3e9-0013d4bc506e
2010-07-05 17:22:30 +00:00
262ba10443 small refactoring
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@619 e52654a7-88a9-db11-a3e9-0013d4bc506e
2010-07-05 15:21:06 +00:00
50cb88c5ed added: parameters consist of a name and a value now
sample: /dir/dir2/function/paramname:paramvalue
removed: TemplatesMisc namespace



git-svn-id: svn://ttmath.org/publicrep/winix/trunk@618 e52654a7-88a9-db11-a3e9-0013d4bc506e
2010-07-04 20:27:14 +00:00
76e32703ac fixed: a mount parameter html_template() was not properly read when mountpoints were reloaded
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@617 e52654a7-88a9-db11-a3e9-0013d4bc506e
2010-07-01 15:40:18 +00:00
d9f5fbaf04 added: "edit" button on threads
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@616 e52654a7-88a9-db11-a3e9-0013d4bc506e
2010-06-30 19:56:32 +00:00
16bb238518 added: bbcode
files: core/bbcodeparser.h core/bbcodeparser.cpp


git-svn-id: svn://ttmath.org/publicrep/winix/trunk@615 e52654a7-88a9-db11-a3e9-0013d4bc506e
2010-06-30 18:42:50 +00:00
759135fd7d struct Item has modification_user_id (long) now
this is the id of a user who has modified the item recently
this is only for information, persmissions don't use it


git-svn-id: svn://ttmath.org/publicrep/winix/trunk@614 e52654a7-88a9-db11-a3e9-0013d4bc506e
2010-06-22 21:09:37 +00:00
56075857f2 debug
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@613 e52654a7-88a9-db11-a3e9-0013d4bc506e
2010-06-22 13:05:49 +00:00
8d3c7500d8 debugging info
git-svn-id: svn://ttmath.org/publicrep/winix/trunk@612 e52654a7-88a9-db11-a3e9-0013d4bc506e
2010-06-22 13:01:56 +00:00
692 changed files with 100640 additions and 26625 deletions

6
.gitignore vendored Normal file
View File

@@ -0,0 +1,6 @@
.cproject
.project
.settings/
*.o
*.so
winixd/winix

View File

@@ -1,61 +0,0 @@
# Makefile for GNU make
ifndef CXX
CXX = g++
endif
ifndef CXXFLAGS
CXXFLAGS = -fPIC -Wall -pedantic -O2 -I/usr/local/include -I/home/tomek/roboczy/winix -I/home/tomek/roboczy/ezc/src -L/usr/local/lib -DEZC_USE_WINIX_LOGGER
endif
export CXX
export CXXFLAGS
all: winix
winix: FORCE
@cd core ; $(MAKE) -e
@cd content ; $(MAKE) -e
@cd confparser ; $(MAKE) -e
@cd templates ; $(MAKE) -e
@cd templatesnotify ; $(MAKE) -e
@cd ../ezc/src ; $(MAKE) -e
$(CXX) -shared -o winix.so $(CXXFLAGS) core/*.o content/*.o templates/*.o templatesnotify/*.o confparser/*.o ../ezc/src/ezc.a -lfcgi -lpq -lz -lpthread
@cd main ; $(MAKE) -e
# use the full path with winix.so
$(CXX) -o winix $(CXXFLAGS) main/*.o /home/tomek/roboczy/winix/winix.so
clean:
@cd core ; $(MAKE) -e clean
@cd content ; $(MAKE) -e clean
@cd confparser ; $(MAKE) -e clean
@cd templates ; $(MAKE) -e clean
@cd templatesnotify ; $(MAKE) -e clean
@cd ../ezc/src ; $(MAKE) -e clean
@cd main ; $(MAKE) -e clean
rm -f winix.so
rm -f winix
FORCE:
depend:
@cd core ; $(MAKE) -e depend
@cd content ; $(MAKE) -e depend
@cd confparser ; $(MAKE) -e depend
@cd templates ; $(MAKE) -e depend
@cd templatesnotify ; $(MAKE) -e depend
@cd ../ezc/src ; $(MAKE) -e depend
@cd main ; $(MAKE) -e depend
#install: all
# mkdir -p bin
# rm -f bin/winix.so
# rm -f bin/winix
# cp winix.so bin/
# cp winix bin/

View File

@@ -1,22 +0,0 @@
include Makefile.o.dep
all: $(o)
.SUFFIXES: .cpp .o
.cpp.o:
$(CXX) -c $(CXXFLAGS) $<
depend:
makedepend -Y. -f- *.cpp > Makefile.dep
echo -n "o = " > Makefile.o.dep
ls -1 *.cpp | xargs -I foo echo -n foo " " | sed -E "s/([^\.]*)\.cpp[ ]/\1\.o/g" >> Makefile.o.dep
clean:
rm -f *.o
include Makefile.dep

View File

@@ -1,3 +0,0 @@
# DO NOT DELETE
confparser.o: confparser.h

View File

@@ -1 +0,0 @@
o = confparser.o

View File

@@ -1,240 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2008-2010, Tomasz Sowa
* All rights reserved.
*
*/
#include "confparser.h"
ConfParser::ConfParser()
{
separator = '=';
commentary = '#';
}
ConfParser::Status ConfParser::Parse(const char * file_name)
{
line = 1;
table.clear();
file.clear();
file.open( file_name );
if( !file )
return cant_open_file;
ReadChar();
status = ParseFile();
file.close();
return status;
}
ConfParser::Status ConfParser::ParseFile()
{
while( lastc != -1 )
{
if( ReadVariable() )
{
if( lastc != separator )
return syntax_error;
ReadChar(); // skipping separator
if( !ReadValue() )
return syntax_error;
//table.insert( std::make_pair(variable, value) );
table[variable] = value;
}
if( lastc == commentary )
SkipLine();
if( lastc != -1 && lastc != '\n' )
return syntax_error;
ReadChar(); // skipping '\n' if was
}
return ok;
}
bool ConfParser::IsVariableChar(int c)
{
if( (c>='a' && c<='z') ||
(c>='A' && c<='Z') ||
(c>='0' && c<='9') ||
c=='.' || c==',' || c=='_' )
return true;
return false;
}
bool ConfParser::IsValueSimpleChar(int c)
{
//if( c==-1 || c=='\n' || IsWhite(c) || c==commentary )
if( c==-1 || c=='\n' || c==commentary )
return false;
return true;
}
bool ConfParser::ReadVariable()
{
variable.clear();
SkipWhite();
while( IsVariableChar(lastc) )
{
variable += lastc;
ReadChar();
}
SkipWhite();
return !variable.empty();
}
bool ConfParser::ReadValue()
{
value.clear();
SkipWhite();
if( lastc == '"' )
// quoted value
return ReadValueQuoted();
else
return ReadValueSimple();
}
bool ConfParser::ReadValueQuoted()
{
ReadChar(); // skipping the first quote
while( lastc != '\n' && lastc != '"' && lastc != -1 )
{
if( lastc == '\\' )
ReadChar();
value += lastc;
ReadChar();
}
if( lastc != '"' )
return false;
ReadChar(); // skipping the last quote
SkipWhite();
return true;
}
bool ConfParser::ReadValueSimple()
{
while( IsValueSimpleChar(lastc) )
{
value += lastc;
ReadChar();
}
Trim(value);
SkipWhite();
return true;
}
int ConfParser::ReadChar()
{
lastc = file.get();
if( lastc == '\n' )
++line;
return lastc;
}
bool ConfParser::IsWhite(int c)
{
if( c==' ' || c=='\t' || c==13 )
return true;
return false;
}
void ConfParser::SkipWhite()
{
while( IsWhite(lastc) )
ReadChar();
}
void ConfParser::SkipLine()
{
while( lastc != -1 && lastc != '\n' )
ReadChar();
}
void ConfParser::Trim(std::string & s)
{
std::string::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::string::npos);
// looking for white characters at the beginning
for(i=0 ; i<s.size() && IsWhite(s[i]) ; ++i);
// deleting white characters at the beginning
if( i != 0 )
s.erase(0, i);
}

View File

@@ -1,74 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2008-2010, Tomasz Sowa
* All rights reserved.
*
*/
#ifndef headerfileconfparser
#define headerfileconfparser
#include <fstream>
#include <string>
#include <map>
class ConfParser
{
public:
enum Status { ok, cant_open_file, syntax_error };
ConfParser();
Status Parse(const char * file_name);
// last status
Status status;
// line in which there is a syntax_error
int line;
typedef std::map<std::string, std::string> Table;
Table table;
private:
// last read variable, value
std::string variable, value;
// separator between a variable and a value, usually '='
int separator;
// commentary char
int commentary;
// last read char
int lastc;
// current file
std::ifstream file;
Status ParseFile();
bool IsVariableChar(int c);
bool IsValueSimpleChar(int c);
bool ReadVariable();
bool ReadValue();
bool ReadValueQuoted();
bool ReadValueSimple();
int ReadChar();
bool IsWhite(int c);
void SkipWhite();
void SkipLine();
void Trim(std::string & s);
};
#endif

View File

@@ -1,22 +0,0 @@
include Makefile.o.dep
all: $(o)
.SUFFIXES: .cpp .o
.cpp.o:
$(CXX) -c $(CXXFLAGS) $<
depend:
makedepend -Y. -f- *.cpp > Makefile.dep
echo -n "o = " > Makefile.o.dep
ls -1 *.cpp | xargs -I foo echo -n foo " " | sed -E "s/([^\.]*)\.cpp[ ]/\1\.o/g" >> Makefile.o.dep
clean:
rm -f *.o
include Makefile.dep

View File

@@ -1,454 +0,0 @@
# DO NOT DELETE
adduser.o: content.h ../core/item.h ../templates/templates.h
adduser.o: ../templates/patterncacher.h ../templates/misc.h
adduser.o: ../templates/localefilter.h ../core/locale.h
adduser.o: ../confparser/confparser.h ../templates/ckeditorgetparser.h
adduser.o: ../core/httpsimpleparser.h ../core/log.h
adduser.o: ../templates/indexpatterns.h ../core/thread.h ../core/ticket.h
adduser.o: ../core/db.h ../core/item.h ../core/user.h ../core/group.h
adduser.o: ../core/thread.h ../core/error.h ../core/log.h
adduser.o: ../core/dircontainer.h ../core/ugcontainer.h ../core/ticket.h
adduser.o: ../core/request.h ../core/requesttypes.h ../core/session.h
adduser.o: ../core/rebus.h ../core/plugindata.h ../core/function.h
adduser.o: ../core/compress.h ../core/acceptencodingparser.h
adduser.o: ../core/acceptbaseparser.h ../core/htmlfilter.h
adduser.o: ../core/postmultiparser.h ../core/data.h ../core/dirs.h
adduser.o: ../core/users.h ../core/groups.h ../core/functions.h
adduser.o: ../core/lastcontainer.h ../core/mounts.h ../core/mount.h
adduser.o: ../core/loadavg.h
cat.o: content.h ../core/item.h ../templates/templates.h
cat.o: ../templates/patterncacher.h ../templates/misc.h
cat.o: ../templates/localefilter.h ../core/locale.h
cat.o: ../confparser/confparser.h ../templates/ckeditorgetparser.h
cat.o: ../core/httpsimpleparser.h ../core/log.h ../templates/indexpatterns.h
cat.o: ../core/thread.h ../core/ticket.h ../core/db.h ../core/item.h
cat.o: ../core/user.h ../core/group.h ../core/thread.h ../core/error.h
cat.o: ../core/log.h ../core/dircontainer.h ../core/ugcontainer.h
cat.o: ../core/ticket.h ../core/request.h ../core/requesttypes.h
cat.o: ../core/session.h ../core/rebus.h ../core/plugindata.h
cat.o: ../core/function.h ../core/compress.h ../core/acceptencodingparser.h
cat.o: ../core/acceptbaseparser.h ../core/htmlfilter.h
cat.o: ../core/postmultiparser.h ../core/error.h ../core/data.h
cat.o: ../core/dirs.h ../core/users.h ../core/groups.h ../core/functions.h
cat.o: ../core/lastcontainer.h ../core/mounts.h ../core/mount.h
cat.o: ../core/loadavg.h
content.o: content.h ../core/item.h ../templates/templates.h
content.o: ../templates/patterncacher.h ../templates/misc.h
content.o: ../templates/localefilter.h ../core/locale.h
content.o: ../confparser/confparser.h ../templates/ckeditorgetparser.h
content.o: ../core/httpsimpleparser.h ../core/log.h
content.o: ../templates/indexpatterns.h ../core/thread.h ../core/ticket.h
content.o: ../core/db.h ../core/item.h ../core/user.h ../core/group.h
content.o: ../core/thread.h ../core/error.h ../core/log.h
content.o: ../core/dircontainer.h ../core/ugcontainer.h ../core/ticket.h
content.o: ../core/request.h ../core/requesttypes.h ../core/session.h
content.o: ../core/rebus.h ../core/plugindata.h ../core/function.h
content.o: ../core/compress.h ../core/acceptencodingparser.h
content.o: ../core/acceptbaseparser.h ../core/htmlfilter.h
content.o: ../core/postmultiparser.h ../core/error.h ../core/data.h
content.o: ../core/dirs.h ../core/users.h ../core/groups.h
content.o: ../core/functions.h ../core/lastcontainer.h ../core/mounts.h
content.o: ../core/mount.h ../core/loadavg.h ../core/misc.h ../core/plugin.h
content.o: ../core/request.h ../core/data.h ../core/pluginmsg.h
cp.o: content.h ../core/item.h ../templates/templates.h
cp.o: ../templates/patterncacher.h ../templates/misc.h
cp.o: ../templates/localefilter.h ../core/locale.h ../confparser/confparser.h
cp.o: ../templates/ckeditorgetparser.h ../core/httpsimpleparser.h
cp.o: ../core/log.h ../templates/indexpatterns.h ../core/thread.h
cp.o: ../core/ticket.h ../core/db.h ../core/item.h ../core/user.h
cp.o: ../core/group.h ../core/thread.h ../core/error.h ../core/log.h
cp.o: ../core/dircontainer.h ../core/ugcontainer.h ../core/ticket.h
cp.o: ../core/request.h ../core/requesttypes.h ../core/session.h
cp.o: ../core/rebus.h ../core/plugindata.h ../core/function.h
cp.o: ../core/compress.h ../core/acceptencodingparser.h
cp.o: ../core/acceptbaseparser.h ../core/htmlfilter.h
cp.o: ../core/postmultiparser.h ../core/data.h ../core/dirs.h ../core/users.h
cp.o: ../core/groups.h ../core/functions.h ../core/lastcontainer.h
cp.o: ../core/mounts.h ../core/mount.h ../core/loadavg.h ../core/misc.h
createthread.o: content.h ../core/item.h ../templates/templates.h
createthread.o: ../templates/patterncacher.h ../templates/misc.h
createthread.o: ../templates/localefilter.h ../core/locale.h
createthread.o: ../confparser/confparser.h ../templates/ckeditorgetparser.h
createthread.o: ../core/httpsimpleparser.h ../core/log.h
createthread.o: ../templates/indexpatterns.h ../core/thread.h
createthread.o: ../core/ticket.h ../core/db.h ../core/item.h ../core/user.h
createthread.o: ../core/group.h ../core/thread.h ../core/error.h
createthread.o: ../core/log.h ../core/dircontainer.h ../core/ugcontainer.h
createthread.o: ../core/ticket.h ../core/request.h ../core/requesttypes.h
createthread.o: ../core/session.h ../core/rebus.h ../core/plugindata.h
createthread.o: ../core/function.h ../core/compress.h
createthread.o: ../core/acceptencodingparser.h ../core/acceptbaseparser.h
createthread.o: ../core/htmlfilter.h ../core/postmultiparser.h
createthread.o: ../core/error.h ../core/mount.h ../core/data.h ../core/dirs.h
createthread.o: ../core/users.h ../core/groups.h ../core/functions.h
createthread.o: ../core/lastcontainer.h ../core/mounts.h ../core/mount.h
createthread.o: ../core/loadavg.h
createticket.o: content.h ../core/item.h ../templates/templates.h
createticket.o: ../templates/patterncacher.h ../templates/misc.h
createticket.o: ../templates/localefilter.h ../core/locale.h
createticket.o: ../confparser/confparser.h ../templates/ckeditorgetparser.h
createticket.o: ../core/httpsimpleparser.h ../core/log.h
createticket.o: ../templates/indexpatterns.h ../core/thread.h
createticket.o: ../core/ticket.h ../core/db.h ../core/item.h ../core/user.h
createticket.o: ../core/group.h ../core/thread.h ../core/error.h
createticket.o: ../core/log.h ../core/dircontainer.h ../core/ugcontainer.h
createticket.o: ../core/ticket.h ../core/request.h ../core/requesttypes.h
createticket.o: ../core/session.h ../core/rebus.h ../core/plugindata.h
createticket.o: ../core/function.h ../core/compress.h
createticket.o: ../core/acceptencodingparser.h ../core/acceptbaseparser.h
createticket.o: ../core/htmlfilter.h ../core/postmultiparser.h
createticket.o: ../core/error.h ../core/mount.h ../core/data.h ../core/dirs.h
createticket.o: ../core/users.h ../core/groups.h ../core/functions.h
createticket.o: ../core/lastcontainer.h ../core/mounts.h ../core/mount.h
createticket.o: ../core/loadavg.h
default.o: content.h ../core/item.h ../templates/templates.h
default.o: ../templates/patterncacher.h ../templates/misc.h
default.o: ../templates/localefilter.h ../core/locale.h
default.o: ../confparser/confparser.h ../templates/ckeditorgetparser.h
default.o: ../core/httpsimpleparser.h ../core/log.h
default.o: ../templates/indexpatterns.h ../core/thread.h ../core/ticket.h
default.o: ../core/db.h ../core/item.h ../core/user.h ../core/group.h
default.o: ../core/thread.h ../core/error.h ../core/log.h
default.o: ../core/dircontainer.h ../core/ugcontainer.h ../core/ticket.h
default.o: ../core/request.h ../core/requesttypes.h ../core/session.h
default.o: ../core/rebus.h ../core/plugindata.h ../core/function.h
default.o: ../core/compress.h ../core/acceptencodingparser.h
default.o: ../core/acceptbaseparser.h ../core/htmlfilter.h
default.o: ../core/postmultiparser.h ../core/error.h ../core/data.h
default.o: ../core/dirs.h ../core/users.h ../core/groups.h
default.o: ../core/functions.h ../core/lastcontainer.h ../core/mounts.h
default.o: ../core/mount.h ../core/loadavg.h
download.o: content.h ../core/item.h ../templates/templates.h
download.o: ../templates/patterncacher.h ../templates/misc.h
download.o: ../templates/localefilter.h ../core/locale.h
download.o: ../confparser/confparser.h ../templates/ckeditorgetparser.h
download.o: ../core/httpsimpleparser.h ../core/log.h
download.o: ../templates/indexpatterns.h ../core/thread.h ../core/ticket.h
download.o: ../core/db.h ../core/item.h ../core/user.h ../core/group.h
download.o: ../core/thread.h ../core/error.h ../core/log.h
download.o: ../core/dircontainer.h ../core/ugcontainer.h ../core/ticket.h
download.o: ../core/request.h ../core/requesttypes.h ../core/session.h
download.o: ../core/rebus.h ../core/plugindata.h ../core/function.h
download.o: ../core/compress.h ../core/acceptencodingparser.h
download.o: ../core/acceptbaseparser.h ../core/htmlfilter.h
download.o: ../core/postmultiparser.h ../core/data.h ../core/dirs.h
download.o: ../core/users.h ../core/groups.h ../core/functions.h
download.o: ../core/lastcontainer.h ../core/mounts.h ../core/mount.h
download.o: ../core/loadavg.h
editticket.o: content.h ../core/item.h ../templates/templates.h
editticket.o: ../templates/patterncacher.h ../templates/misc.h
editticket.o: ../templates/localefilter.h ../core/locale.h
editticket.o: ../confparser/confparser.h ../templates/ckeditorgetparser.h
editticket.o: ../core/httpsimpleparser.h ../core/log.h
editticket.o: ../templates/indexpatterns.h ../core/thread.h ../core/ticket.h
editticket.o: ../core/db.h ../core/item.h ../core/user.h ../core/group.h
editticket.o: ../core/thread.h ../core/error.h ../core/log.h
editticket.o: ../core/dircontainer.h ../core/ugcontainer.h ../core/ticket.h
editticket.o: ../core/request.h ../core/requesttypes.h ../core/session.h
editticket.o: ../core/rebus.h ../core/plugindata.h ../core/function.h
editticket.o: ../core/compress.h ../core/acceptencodingparser.h
editticket.o: ../core/acceptbaseparser.h ../core/htmlfilter.h
editticket.o: ../core/postmultiparser.h ../core/error.h ../core/mount.h
editticket.o: ../core/data.h ../core/dirs.h ../core/users.h ../core/groups.h
editticket.o: ../core/functions.h ../core/lastcontainer.h ../core/mounts.h
editticket.o: ../core/mount.h ../core/loadavg.h
emacs.o: content.h ../core/item.h ../templates/templates.h
emacs.o: ../templates/patterncacher.h ../templates/misc.h
emacs.o: ../templates/localefilter.h ../core/locale.h
emacs.o: ../confparser/confparser.h ../templates/ckeditorgetparser.h
emacs.o: ../core/httpsimpleparser.h ../core/log.h
emacs.o: ../templates/indexpatterns.h ../core/thread.h ../core/ticket.h
emacs.o: ../core/db.h ../core/item.h ../core/user.h ../core/group.h
emacs.o: ../core/thread.h ../core/error.h ../core/log.h
emacs.o: ../core/dircontainer.h ../core/ugcontainer.h ../core/ticket.h
emacs.o: ../core/request.h ../core/requesttypes.h ../core/session.h
emacs.o: ../core/rebus.h ../core/plugindata.h ../core/function.h
emacs.o: ../core/compress.h ../core/acceptencodingparser.h
emacs.o: ../core/acceptbaseparser.h ../core/htmlfilter.h
emacs.o: ../core/postmultiparser.h ../core/error.h ../core/data.h
emacs.o: ../core/dirs.h ../core/users.h ../core/groups.h ../core/functions.h
emacs.o: ../core/lastcontainer.h ../core/mounts.h ../core/mount.h
emacs.o: ../core/loadavg.h ../core/notify.h
emacs.o: ../templatesnotify/templatesnotify.h ../core/mount.h
emacs.o: ../templates/misc.h ../core/misc.h
last.o: content.h ../core/item.h ../templates/templates.h
last.o: ../templates/patterncacher.h ../templates/misc.h
last.o: ../templates/localefilter.h ../core/locale.h
last.o: ../confparser/confparser.h ../templates/ckeditorgetparser.h
last.o: ../core/httpsimpleparser.h ../core/log.h ../templates/indexpatterns.h
last.o: ../core/thread.h ../core/ticket.h ../core/db.h ../core/item.h
last.o: ../core/user.h ../core/group.h ../core/thread.h ../core/error.h
last.o: ../core/log.h ../core/dircontainer.h ../core/ugcontainer.h
last.o: ../core/ticket.h
login.o: content.h ../core/item.h ../templates/templates.h
login.o: ../templates/patterncacher.h ../templates/misc.h
login.o: ../templates/localefilter.h ../core/locale.h
login.o: ../confparser/confparser.h ../templates/ckeditorgetparser.h
login.o: ../core/httpsimpleparser.h ../core/log.h
login.o: ../templates/indexpatterns.h ../core/thread.h ../core/ticket.h
login.o: ../core/db.h ../core/item.h ../core/user.h ../core/group.h
login.o: ../core/thread.h ../core/error.h ../core/log.h
login.o: ../core/dircontainer.h ../core/ugcontainer.h ../core/ticket.h
login.o: ../core/request.h ../core/requesttypes.h ../core/session.h
login.o: ../core/rebus.h ../core/plugindata.h ../core/function.h
login.o: ../core/compress.h ../core/acceptencodingparser.h
login.o: ../core/acceptbaseparser.h ../core/htmlfilter.h
login.o: ../core/postmultiparser.h ../core/error.h ../core/data.h
login.o: ../core/dirs.h ../core/users.h ../core/groups.h ../core/functions.h
login.o: ../core/lastcontainer.h ../core/mounts.h ../core/mount.h
login.o: ../core/loadavg.h
logout.o: content.h ../core/item.h ../templates/templates.h
logout.o: ../templates/patterncacher.h ../templates/misc.h
logout.o: ../templates/localefilter.h ../core/locale.h
logout.o: ../confparser/confparser.h ../templates/ckeditorgetparser.h
logout.o: ../core/httpsimpleparser.h ../core/log.h
logout.o: ../templates/indexpatterns.h ../core/thread.h ../core/ticket.h
logout.o: ../core/db.h ../core/item.h ../core/user.h ../core/group.h
logout.o: ../core/thread.h ../core/error.h ../core/log.h
logout.o: ../core/dircontainer.h ../core/ugcontainer.h ../core/ticket.h
logout.o: ../core/request.h ../core/requesttypes.h ../core/session.h
logout.o: ../core/rebus.h ../core/plugindata.h ../core/function.h
logout.o: ../core/compress.h ../core/acceptencodingparser.h
logout.o: ../core/acceptbaseparser.h ../core/htmlfilter.h
logout.o: ../core/postmultiparser.h ../core/data.h ../core/dirs.h
logout.o: ../core/users.h ../core/groups.h ../core/functions.h
logout.o: ../core/lastcontainer.h ../core/mounts.h ../core/mount.h
logout.o: ../core/loadavg.h
ls.o: content.h ../core/item.h ../templates/templates.h
ls.o: ../templates/patterncacher.h ../templates/misc.h
ls.o: ../templates/localefilter.h ../core/locale.h ../confparser/confparser.h
ls.o: ../templates/ckeditorgetparser.h ../core/httpsimpleparser.h
ls.o: ../core/log.h ../templates/indexpatterns.h ../core/thread.h
ls.o: ../core/ticket.h ../core/db.h ../core/item.h ../core/user.h
ls.o: ../core/group.h ../core/thread.h ../core/error.h ../core/log.h
ls.o: ../core/dircontainer.h ../core/ugcontainer.h ../core/ticket.h
ls.o: ../core/request.h ../core/requesttypes.h ../core/session.h
ls.o: ../core/rebus.h ../core/plugindata.h ../core/function.h
ls.o: ../core/compress.h ../core/acceptencodingparser.h
ls.o: ../core/acceptbaseparser.h ../core/htmlfilter.h
ls.o: ../core/postmultiparser.h
misc_item.o: content.h ../core/item.h ../templates/templates.h
misc_item.o: ../templates/patterncacher.h ../templates/misc.h
misc_item.o: ../templates/localefilter.h ../core/locale.h
misc_item.o: ../confparser/confparser.h ../templates/ckeditorgetparser.h
misc_item.o: ../core/httpsimpleparser.h ../core/log.h
misc_item.o: ../templates/indexpatterns.h ../core/thread.h ../core/ticket.h
misc_item.o: ../core/db.h ../core/item.h ../core/user.h ../core/group.h
misc_item.o: ../core/thread.h ../core/error.h ../core/log.h
misc_item.o: ../core/dircontainer.h ../core/ugcontainer.h ../core/ticket.h
misc_item.o: ../core/request.h ../core/requesttypes.h ../core/session.h
misc_item.o: ../core/rebus.h ../core/plugindata.h ../core/function.h
misc_item.o: ../core/compress.h ../core/acceptencodingparser.h
misc_item.o: ../core/acceptbaseparser.h ../core/htmlfilter.h
misc_item.o: ../core/postmultiparser.h ../core/misc.h
misc_specialfile.o: content.h ../core/item.h ../templates/templates.h
misc_specialfile.o: ../templates/patterncacher.h ../templates/misc.h
misc_specialfile.o: ../templates/localefilter.h ../core/locale.h
misc_specialfile.o: ../confparser/confparser.h
misc_specialfile.o: ../templates/ckeditorgetparser.h
misc_specialfile.o: ../core/httpsimpleparser.h ../core/log.h
misc_specialfile.o: ../templates/indexpatterns.h ../core/thread.h
misc_specialfile.o: ../core/ticket.h ../core/db.h ../core/item.h
misc_specialfile.o: ../core/user.h ../core/group.h ../core/thread.h
misc_specialfile.o: ../core/error.h ../core/log.h ../core/dircontainer.h
misc_specialfile.o: ../core/ugcontainer.h ../core/ticket.h ../core/request.h
misc_specialfile.o: ../core/requesttypes.h ../core/session.h ../core/rebus.h
misc_specialfile.o: ../core/plugindata.h ../core/function.h
misc_specialfile.o: ../core/compress.h ../core/acceptencodingparser.h
misc_specialfile.o: ../core/acceptbaseparser.h ../core/htmlfilter.h
misc_specialfile.o: ../core/postmultiparser.h ../core/data.h ../core/dirs.h
misc_specialfile.o: ../core/users.h ../core/groups.h ../core/functions.h
misc_specialfile.o: ../core/lastcontainer.h ../core/mounts.h ../core/mount.h
misc_specialfile.o: ../core/loadavg.h
mkdir.o: content.h ../core/item.h ../templates/templates.h
mkdir.o: ../templates/patterncacher.h ../templates/misc.h
mkdir.o: ../templates/localefilter.h ../core/locale.h
mkdir.o: ../confparser/confparser.h ../templates/ckeditorgetparser.h
mkdir.o: ../core/httpsimpleparser.h ../core/log.h
mkdir.o: ../templates/indexpatterns.h ../core/thread.h ../core/ticket.h
mkdir.o: ../core/db.h ../core/item.h ../core/user.h ../core/group.h
mkdir.o: ../core/thread.h ../core/error.h ../core/log.h
mkdir.o: ../core/dircontainer.h ../core/ugcontainer.h ../core/ticket.h
mkdir.o: ../core/request.h ../core/requesttypes.h ../core/session.h
mkdir.o: ../core/rebus.h ../core/plugindata.h ../core/function.h
mkdir.o: ../core/compress.h ../core/acceptencodingparser.h
mkdir.o: ../core/acceptbaseparser.h ../core/htmlfilter.h
mkdir.o: ../core/postmultiparser.h ../core/error.h ../core/data.h
mkdir.o: ../core/dirs.h ../core/users.h ../core/groups.h ../core/functions.h
mkdir.o: ../core/lastcontainer.h ../core/mounts.h ../core/mount.h
mkdir.o: ../core/loadavg.h ../core/notify.h
mkdir.o: ../templatesnotify/templatesnotify.h ../core/mount.h
mkdir.o: ../templates/misc.h
mv.o: content.h ../core/item.h ../templates/templates.h
mv.o: ../templates/patterncacher.h ../templates/misc.h
mv.o: ../templates/localefilter.h ../core/locale.h ../confparser/confparser.h
mv.o: ../templates/ckeditorgetparser.h ../core/httpsimpleparser.h
mv.o: ../core/log.h ../templates/indexpatterns.h ../core/thread.h
mv.o: ../core/ticket.h ../core/db.h ../core/item.h ../core/user.h
mv.o: ../core/group.h ../core/thread.h ../core/error.h ../core/log.h
mv.o: ../core/dircontainer.h ../core/ugcontainer.h ../core/ticket.h
mv.o: ../core/request.h ../core/requesttypes.h ../core/session.h
mv.o: ../core/rebus.h ../core/plugindata.h ../core/function.h
mv.o: ../core/compress.h ../core/acceptencodingparser.h
mv.o: ../core/acceptbaseparser.h ../core/htmlfilter.h
mv.o: ../core/postmultiparser.h ../core/data.h ../core/dirs.h ../core/users.h
mv.o: ../core/groups.h ../core/functions.h ../core/lastcontainer.h
mv.o: ../core/mounts.h ../core/mount.h ../core/loadavg.h
node.o: content.h ../core/item.h ../templates/templates.h
node.o: ../templates/patterncacher.h ../templates/misc.h
node.o: ../templates/localefilter.h ../core/locale.h
node.o: ../confparser/confparser.h ../templates/ckeditorgetparser.h
node.o: ../core/httpsimpleparser.h ../core/log.h ../templates/indexpatterns.h
node.o: ../core/thread.h ../core/ticket.h ../core/db.h ../core/item.h
node.o: ../core/user.h ../core/group.h ../core/thread.h ../core/error.h
node.o: ../core/log.h ../core/dircontainer.h ../core/ugcontainer.h
node.o: ../core/ticket.h ../core/request.h ../core/requesttypes.h
node.o: ../core/session.h ../core/rebus.h ../core/plugindata.h
node.o: ../core/function.h ../core/compress.h ../core/acceptencodingparser.h
node.o: ../core/acceptbaseparser.h ../core/htmlfilter.h
node.o: ../core/postmultiparser.h
priv.o: content.h ../core/item.h ../templates/templates.h
priv.o: ../templates/patterncacher.h ../templates/misc.h
priv.o: ../templates/localefilter.h ../core/locale.h
priv.o: ../confparser/confparser.h ../templates/ckeditorgetparser.h
priv.o: ../core/httpsimpleparser.h ../core/log.h ../templates/indexpatterns.h
priv.o: ../core/thread.h ../core/ticket.h ../core/db.h ../core/item.h
priv.o: ../core/user.h ../core/group.h ../core/thread.h ../core/error.h
priv.o: ../core/log.h ../core/dircontainer.h ../core/ugcontainer.h
priv.o: ../core/ticket.h ../core/request.h ../core/requesttypes.h
priv.o: ../core/session.h ../core/rebus.h ../core/plugindata.h
priv.o: ../core/function.h ../core/compress.h ../core/acceptencodingparser.h
priv.o: ../core/acceptbaseparser.h ../core/htmlfilter.h
priv.o: ../core/postmultiparser.h ../core/error.h ../core/data.h
priv.o: ../core/dirs.h ../core/users.h ../core/groups.h ../core/functions.h
priv.o: ../core/lastcontainer.h ../core/mounts.h ../core/mount.h
priv.o: ../core/loadavg.h
reload.o: content.h ../core/item.h ../templates/templates.h
reload.o: ../templates/patterncacher.h ../templates/misc.h
reload.o: ../templates/localefilter.h ../core/locale.h
reload.o: ../confparser/confparser.h ../templates/ckeditorgetparser.h
reload.o: ../core/httpsimpleparser.h ../core/log.h
reload.o: ../templates/indexpatterns.h ../core/thread.h ../core/ticket.h
reload.o: ../core/db.h ../core/item.h ../core/user.h ../core/group.h
reload.o: ../core/thread.h ../core/error.h ../core/log.h
reload.o: ../core/dircontainer.h ../core/ugcontainer.h ../core/ticket.h
reload.o: ../core/request.h ../core/requesttypes.h ../core/session.h
reload.o: ../core/rebus.h ../core/plugindata.h ../core/function.h
reload.o: ../core/compress.h ../core/acceptencodingparser.h
reload.o: ../core/acceptbaseparser.h ../core/htmlfilter.h
reload.o: ../core/postmultiparser.h ../core/error.h ../core/notify.h
reload.o: ../templatesnotify/templatesnotify.h ../core/mount.h
reload.o: ../templates/misc.h
rm.o: content.h ../core/item.h ../templates/templates.h
rm.o: ../templates/patterncacher.h ../templates/misc.h
rm.o: ../templates/localefilter.h ../core/locale.h ../confparser/confparser.h
rm.o: ../templates/ckeditorgetparser.h ../core/httpsimpleparser.h
rm.o: ../core/log.h ../templates/indexpatterns.h ../core/thread.h
rm.o: ../core/ticket.h ../core/db.h ../core/item.h ../core/user.h
rm.o: ../core/group.h ../core/thread.h ../core/error.h ../core/log.h
rm.o: ../core/dircontainer.h ../core/ugcontainer.h ../core/ticket.h
rm.o: ../core/request.h ../core/requesttypes.h ../core/session.h
rm.o: ../core/rebus.h ../core/plugindata.h ../core/function.h
rm.o: ../core/compress.h ../core/acceptencodingparser.h
rm.o: ../core/acceptbaseparser.h ../core/htmlfilter.h
rm.o: ../core/postmultiparser.h ../core/error.h ../core/data.h ../core/dirs.h
rm.o: ../core/users.h ../core/groups.h ../core/functions.h
rm.o: ../core/lastcontainer.h ../core/mounts.h ../core/mount.h
rm.o: ../core/loadavg.h
run.o: content.h ../core/item.h ../templates/templates.h
run.o: ../templates/patterncacher.h ../templates/misc.h
run.o: ../templates/localefilter.h ../core/locale.h
run.o: ../confparser/confparser.h ../templates/ckeditorgetparser.h
run.o: ../core/httpsimpleparser.h ../core/log.h ../templates/indexpatterns.h
run.o: ../core/thread.h ../core/ticket.h ../core/db.h ../core/item.h
run.o: ../core/user.h ../core/group.h ../core/thread.h ../core/error.h
run.o: ../core/log.h ../core/dircontainer.h ../core/ugcontainer.h
run.o: ../core/ticket.h ../core/request.h ../core/requesttypes.h
run.o: ../core/session.h ../core/rebus.h ../core/plugindata.h
run.o: ../core/function.h ../core/compress.h ../core/acceptencodingparser.h
run.o: ../core/acceptbaseparser.h ../core/htmlfilter.h
run.o: ../core/postmultiparser.h ../core/error.h
subject.o: content.h ../core/item.h ../templates/templates.h
subject.o: ../templates/patterncacher.h ../templates/misc.h
subject.o: ../templates/localefilter.h ../core/locale.h
subject.o: ../confparser/confparser.h ../templates/ckeditorgetparser.h
subject.o: ../core/httpsimpleparser.h ../core/log.h
subject.o: ../templates/indexpatterns.h ../core/thread.h ../core/ticket.h
subject.o: ../core/db.h ../core/item.h ../core/user.h ../core/group.h
subject.o: ../core/thread.h ../core/error.h ../core/log.h
subject.o: ../core/dircontainer.h ../core/ugcontainer.h ../core/ticket.h
subject.o: ../core/request.h ../core/requesttypes.h ../core/session.h
subject.o: ../core/rebus.h ../core/plugindata.h ../core/function.h
subject.o: ../core/compress.h ../core/acceptencodingparser.h
subject.o: ../core/acceptbaseparser.h ../core/htmlfilter.h
subject.o: ../core/postmultiparser.h
thread.o: content.h ../core/item.h ../templates/templates.h
thread.o: ../templates/patterncacher.h ../templates/misc.h
thread.o: ../templates/localefilter.h ../core/locale.h
thread.o: ../confparser/confparser.h ../templates/ckeditorgetparser.h
thread.o: ../core/httpsimpleparser.h ../core/log.h
thread.o: ../templates/indexpatterns.h ../core/thread.h ../core/ticket.h
thread.o: ../core/db.h ../core/item.h ../core/user.h ../core/group.h
thread.o: ../core/thread.h ../core/error.h ../core/log.h
thread.o: ../core/dircontainer.h ../core/ugcontainer.h ../core/ticket.h
thread.o: ../core/request.h ../core/requesttypes.h ../core/session.h
thread.o: ../core/rebus.h ../core/plugindata.h ../core/function.h
thread.o: ../core/compress.h ../core/acceptencodingparser.h
thread.o: ../core/acceptbaseparser.h ../core/htmlfilter.h
thread.o: ../core/postmultiparser.h ../core/data.h ../core/dirs.h
thread.o: ../core/users.h ../core/groups.h ../core/functions.h
thread.o: ../core/lastcontainer.h ../core/mounts.h ../core/mount.h
thread.o: ../core/loadavg.h ../core/mount.h
ticket.o: content.h ../core/item.h ../templates/templates.h
ticket.o: ../templates/patterncacher.h ../templates/misc.h
ticket.o: ../templates/localefilter.h ../core/locale.h
ticket.o: ../confparser/confparser.h ../templates/ckeditorgetparser.h
ticket.o: ../core/httpsimpleparser.h ../core/log.h
ticket.o: ../templates/indexpatterns.h ../core/thread.h ../core/ticket.h
ticket.o: ../core/db.h ../core/item.h ../core/user.h ../core/group.h
ticket.o: ../core/thread.h ../core/error.h ../core/log.h
ticket.o: ../core/dircontainer.h ../core/ugcontainer.h ../core/ticket.h
ticket.o: ../core/request.h ../core/requesttypes.h ../core/session.h
ticket.o: ../core/rebus.h ../core/plugindata.h ../core/function.h
ticket.o: ../core/compress.h ../core/acceptencodingparser.h
ticket.o: ../core/acceptbaseparser.h ../core/htmlfilter.h
ticket.o: ../core/postmultiparser.h ../core/data.h ../core/dirs.h
ticket.o: ../core/users.h ../core/groups.h ../core/functions.h
ticket.o: ../core/lastcontainer.h ../core/mounts.h ../core/mount.h
ticket.o: ../core/loadavg.h ../core/mount.h
uname.o: content.h ../core/item.h ../templates/templates.h
uname.o: ../templates/patterncacher.h ../templates/misc.h
uname.o: ../templates/localefilter.h ../core/locale.h
uname.o: ../confparser/confparser.h ../templates/ckeditorgetparser.h
uname.o: ../core/httpsimpleparser.h ../core/log.h
uname.o: ../templates/indexpatterns.h ../core/thread.h ../core/ticket.h
uname.o: ../core/db.h ../core/item.h ../core/user.h ../core/group.h
uname.o: ../core/thread.h ../core/error.h ../core/log.h
uname.o: ../core/dircontainer.h ../core/ugcontainer.h ../core/ticket.h
upload.o: content.h ../core/item.h ../templates/templates.h
upload.o: ../templates/patterncacher.h ../templates/misc.h
upload.o: ../templates/localefilter.h ../core/locale.h
upload.o: ../confparser/confparser.h ../templates/ckeditorgetparser.h
upload.o: ../core/httpsimpleparser.h ../core/log.h
upload.o: ../templates/indexpatterns.h ../core/thread.h ../core/ticket.h
upload.o: ../core/db.h ../core/item.h ../core/user.h ../core/group.h
upload.o: ../core/thread.h ../core/error.h ../core/log.h
upload.o: ../core/dircontainer.h ../core/ugcontainer.h ../core/ticket.h
upload.o: ../core/request.h ../core/requesttypes.h ../core/session.h
upload.o: ../core/rebus.h ../core/plugindata.h ../core/function.h
upload.o: ../core/compress.h ../core/acceptencodingparser.h
upload.o: ../core/acceptbaseparser.h ../core/htmlfilter.h
upload.o: ../core/postmultiparser.h ../core/data.h ../core/dirs.h
upload.o: ../core/users.h ../core/groups.h ../core/functions.h
upload.o: ../core/lastcontainer.h ../core/mounts.h ../core/mount.h
upload.o: ../core/loadavg.h ../core/misc.h
who.o: content.h ../core/item.h ../templates/templates.h
who.o: ../templates/patterncacher.h ../templates/misc.h
who.o: ../templates/localefilter.h ../core/locale.h
who.o: ../confparser/confparser.h ../templates/ckeditorgetparser.h
who.o: ../core/httpsimpleparser.h ../core/log.h ../templates/indexpatterns.h
who.o: ../core/thread.h ../core/ticket.h ../core/db.h ../core/item.h
who.o: ../core/user.h ../core/group.h ../core/thread.h ../core/error.h
who.o: ../core/log.h ../core/dircontainer.h ../core/ugcontainer.h
who.o: ../core/ticket.h

View File

@@ -1 +0,0 @@
o = adduser.o cat.o content.o cp.o createthread.o createticket.o default.o download.o editticket.o emacs.o last.o login.o logout.o ls.o misc_item.o misc_specialfile.o mkdir.o mv.o node.o priv.o reload.o rm.o run.o subject.o thread.o ticket.o uname.o upload.o who.o

View File

@@ -1,111 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2008-2010, Tomasz Sowa
* All rights reserved.
*
*/
#include "content.h"
#include "../core/request.h"
#include "../core/data.h"
#include "../core/db.h"
bool Content::CheckAddUserVars(const std::string * login, const std::string * pass, const std::string * conf_pass)
{
if( !login || !pass || !conf_pass )
{
request.status = WINIX_ERR_PERMISSION_DENIED;
return false;
}
if( login->empty() )
{
request.status = WINIX_ERR_LOGIN_EMPTY;
return false;
}
if( *pass != *conf_pass )
{
request.status = WINIX_ERR_PASSWORDS_DIFFERENT;
return false;
}
if( pass->size() < 5 )
{
request.status = WINIX_ERR_PASSWORD_TOO_SHORT;
return false;
}
if( data.users.IsUser(*login) )
{
request.status = WINIX_ERR_USER_EXISTS;
return false;
}
return true;
}
void Content::PostFunAddUser()
{
User user;
std::string * login = request.PostVar("login");
std::string * pass = request.PostVar("password");
std::string * conf_pass = request.PostVar("confirmpassword");
std::string * email = request.PostVar("email");
if( !CheckAddUserVars(login, pass, conf_pass) )
return;
user.name = *login;
if( email )
user.email = *email;
request.status = db.AddUser(user, *pass);
if( request.status == WINIX_ERR_OK )
{
if( data.users.AddUser(user) )
{
if( !request.session->puser )
LoginUser(user.id, false);
log << log2 << "Content: added a new user: " << user.name << logend;
}
else
{
log << log1 << "Content: I can't add to data.users: " << user.name
<< " but the user was added to the db correctly" << logend;
}
if( request.is_item )
RedirectTo(request.item);
else
RedirectToLastDir();
}
}
void Content::FunAddUser()
{
}

View File

@@ -1,37 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2008-2010, Tomasz Sowa
* All rights reserved.
*
*/
#include "content.h"
#include "../core/request.h"
#include "../core/error.h"
#include "../core/data.h"
void Content::FunCat()
{
if( !request.is_item )
{
log << log1 << "Content: cat function requires an item" << logend;
request.status = WINIX_ERR_NO_ITEM;
return;
}
if( !request.HasReadAccess(request.item) )
{
request.status = WINIX_ERR_PERMISSION_DENIED;
return;
}
request.send_as_attachment = request.IsParam("attachment");
}

View File

@@ -1,579 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2008-2010, Tomasz Sowa
* All rights reserved.
*
*/
#include "content.h"
#include "../core/request.h"
#include "../core/error.h"
#include "../core/db.h"
#include "../core/data.h"
#include "../core/misc.h"
#include "../core/plugin.h"
bool Content::Init()
{
templates.ReadIndexFileNames();
templates.ReadTemplates();
templates.CreateFunctions();
return true;
}
bool Content::DirsHaveReadExecPerm()
{
std::vector<Item*>::iterator i;
for(i = request.dir_table.begin() ; i!=request.dir_table.end() ; ++i)
{
if( !request.HasReadExecAccess(**i) )
return false;
}
return true;
}
void Content::SetDefaultFunctionForFile()
{
if( request.item.auth != Item::auth_none )
request.pfunction = data.functions.GetFunction(FUN_DOWNLOAD);
else
if( request.HasReadExecAccess(request.item) )
request.pfunction = data.functions.GetFunction(FUN_RUN);
else
request.pfunction = data.functions.GetFunction(FUN_CAT);
if( request.pfunction )
log << log3 << "Content: default function: " << request.pfunction->item.url << logend;
}
void Content::SetDefaultFunctionForDir()
{
long default_item = request.dir_table.back()->default_item;
if( default_item != -1 )
{
log << log3 << "Content: Default item: id: " << default_item << logend;
RedirectTo(default_item);
return;
}
if( data.mounts.pmount->type == Mount::thread )
{
request.pfunction = data.functions.GetFunction(FUN_THREAD);
if( request.pfunction )
log << log3 << "Content: default function: " << request.pfunction->item.url << logend;
}
else
if( data.mounts.pmount->type == Mount::ticket )
{
request.pfunction = data.functions.GetFunction(FUN_TICKET);
if( request.pfunction )
log << log3 << "Content: default function: " << request.pfunction->item.url << logend;
}
else
{
// cms
request.pfunction = data.functions.GetFunction(FUN_LS);
if( request.pfunction )
log << log3 << "Content: default function: " << request.pfunction->item.url << logend;
}
}
void Content::SetDefaultFunction()
{
if( request.is_item )
{
SetDefaultFunctionForFile();
}
else
{
SetDefaultFunctionForDir();
}
}
void Content::FunNothing()
{
/* do nothing */
}
void Content::CallFunction()
{
static FunItem tab[] = {
{FUN_LOGOUT, &Content::FunLogout},
{FUN_CAT, &Content::FunCat},
{FUN_LS, &Content::FunLs},
{FUN_EMACS, &Content::FunEmacs},
{FUN_MKDIR, &Content::FunMkdir},
{FUN_DEFAULT, &Content::FunDefault},
{FUN_PRIV, &Content::FunPriv},
{FUN_RM, &Content::FunRm},
{FUN_RUN, &Content::FunRun},
{FUN_NODE, &Content::FunNode},
{FUN_WHO, &Content::FunWho},
{FUN_LAST, &Content::FunLast},
{FUN_THREAD, &Content::FunThread},
{FUN_RELOAD, &Content::FunReload},
{FUN_UPLOAD, &Content::FunUpload},
{FUN_TICKET, &Content::FunTicket},
{FUN_CKEDITOR, &Content::FunEmacs},
{FUN_TINYMCE, &Content::FunEmacs},
{FUN_LOGIN, &Content::FunLogin},
{FUN_MV, &Content::FunMv},
{FUN_UNAME, &Content::FunUname},
{FUN_CHMOD, &Content::FunPriv},
{FUN_CHOWN, &Content::FunPriv},
{FUN_DOWNLOAD, &Content::FunDownload},
{FUN_ADDUSER, &Content::FunAddUser},
{FUN_SUBJECT, &Content::FunSubject},
{FUN_CP, &Content::FunCp},
{FUN_UPTIME, &Content::FunNothing},
{FUN_EDITTICKET,&Content::FunEditTicket},
{FUN_CREATETHREAD, &Content::FunCreateThread},
{FUN_CREATETICKET, &Content::FunCreateTicket}
};
size_t len = sizeof(tab) / sizeof(FunItem);
size_t i;
for(i=0 ; i<len ; ++i)
{
if( tab[i].code == request.pfunction->code )
{
(this->*tab[i].fun)();
return;
}
}
request.status = WINIX_ERR_PERMISSION_DENIED;
}
void Content::MakeStandardFunction()
{
if( request.role == Request::authorizer )
{
// in authorizer mode only cat function is available
// (and must be default)
if( request.pfunction )
{
request.status = WINIX_ERR_NO_ITEM;
log << log1 << "Content: in authorizer mode only 'cat' funtion is available and must "
"be default (not in the url)" << logend;
return;
}
request.pfunction = data.functions.GetFunction(FUN_CAT);
}
if( !request.pfunction )
SetDefaultFunction();
if( !request.redirect_to.empty() )
return;
if( !request.pfunction )
{
request.status = WINIX_ERR_NO_FUNCTION;
log << log1 << "Content: no function (neither cat nor ls)" << logend;
return;
}
CallFunction();
}
void Content::CallPostFunction()
{
static FunItem tab[] = {
{FUN_RUN, &Content::PostFunRun},
{FUN_EMACS, &Content::PostFunEmacs},
{FUN_MKDIR, &Content::PostFunMkdir},
{FUN_DEFAULT, &Content::PostFunDefault},
{FUN_PRIV, &Content::PostFunPriv},
{FUN_CHMOD, &Content::PostFunPriv},
{FUN_CHOWN, &Content::PostFunPriv},
{FUN_LOGIN, &Content::PostFunLogin},
{FUN_UPLOAD, &Content::PostFunUpload},
{FUN_EDITTICKET,&Content::PostFunEditTicket},
{FUN_CKEDITOR, &Content::PostFunEmacs},
{FUN_TINYMCE, &Content::PostFunEmacs},
{FUN_ADDUSER, &Content::PostFunAddUser},
{FUN_MV, &Content::PostFunMv},
{FUN_SUBJECT, &Content::PostFunSubject},
{FUN_CP, &Content::PostFunCp},
{FUN_CREATETHREAD, &Content::PostFunCreateThread},
{FUN_CREATETICKET, &Content::PostFunCreateTicket}
};
size_t len = sizeof(tab) / sizeof(FunItem);
size_t i;
for(i=0 ; i<len ; ++i)
{
if( tab[i].code == request.pfunction->code )
{
(this->*tab[i].fun)();
return;
}
}
log << log1 << "Content: unknown post function" << logend;
request.status = WINIX_ERR_PERMISSION_DENIED;
}
void Content::MakePost()
{
if( request.role == Request::authorizer )
{
request.status = WINIX_ERR_PERMISSION_DENIED;
return;
}
if( !request.pfunction )
SetDefaultFunction();
if( !request.pfunction )
{
request.status = WINIX_ERR_NO_FUNCTION;
log << log1 << "Content: MakePost: no function" << logend;
return;
}
CallPostFunction();
}
void Content::MakePage()
{
bool sent = false;
if( !request.redirect_to.empty() ||
!request.x_sendfile.empty() )
return;
if( request.is_item && request.item.auth == Item::auth_none &&
request.item.content_type == Item::ct_raw && request.status == WINIX_ERR_OK && request.pfunction )
{
if( request.pfunction->code == FUN_CAT )
{
request.page << request.item.content;
sent = true;
}
else
if( request.pfunction->code == FUN_RUN )
{
templates.GenerateRunRaw();
sent = true;
}
}
if( !sent )
{
templates.Generate();
}
}
void Content::Make()
{
if( request.dir_table.empty() )
{
log << log1 << "Content: there is no a root dir (dir_table is empty)" << logend;
return;
}
// request.status can be changed by function_parser
if( request.status == WINIX_ERR_OK )
{
if( DirsHaveReadExecPerm() )
{
if( request.method == Request::post )
MakePost();
if( request.redirect_to.empty() && request.status == WINIX_ERR_OK )
MakeStandardFunction();
}
else
request.status = WINIX_ERR_PERMISSION_DENIED;
}
if( request.session->spam_score > 0 )
log << log1 << "Content: spam score: " << request.session->spam_score << logend;
if( request.IsParam("noredirect") )
request.redirect_to.clear();
if( !request.redirect_to.empty() )
return;
if( request.dir_table.empty() )
{
log << log1 << "Content: there is no a root dir (dir_table is empty -- after calling some standard functions)" << logend;
return;
}
plugin.Call(WINIX_CONTENT_MAKE);
MakePage();
//request.PrintGetTable();
//request.PrintEnv();
//request.PrintIn();
}
// !! mozna zrobic jakas obsluge kiedy nie mozemy sie redirectnac, np gdy wystapil blad
// !! moze zwracac jakas wartosc?
void Content::RedirectTo(const Item & item, const char * postfix)
{
std::string path;
request.redirect_to = data.base_url;
if( item.type == Item::dir )
{
// item_id is pointing to a directory
data.dirs.MakePath(item.id, path);
request.redirect_to += path;
}
else
{
if( !data.dirs.MakePath(item.parent_id, path) )
log << log1 << "Content: Can't redirect: no dirs for item id: " << item.id << logend;
request.redirect_to += path;
request.redirect_to += item.url;
}
if( postfix )
request.redirect_to += postfix;
}
void Content::RedirectTo(long item_id, const char * postfix)
{
std::string path;
Item * pdir;
request.redirect_to = data.base_url;
pdir = data.dirs.GetDir(item_id);
if( pdir )
{
// item_id is pointing to a directory
data.dirs.MakePath(pdir->id, path);
request.redirect_to += path;
}
else
{
// !! zrobic nowy interfejs
// !! GetItem pozamieniac na GetFile
db.GetItem(request.item_table, item_id);
if( !request.item_table.empty() )
{
if( !data.dirs.MakePath(request.item_table[0].parent_id, path) )
log << log1 << "Content: Can't redirect: no dirs for item id: " << request.item_table[0].id << ", requested directory id: " << request.item_table[0].parent_id << logend;
request.redirect_to += path + request.item_table[0].url;
}
else
{
log << log1 << "Content: Can't redirect: no such item: id: " << item_id << logend;
}
}
if( postfix )
request.redirect_to += postfix;
}
void Content::RedirectToLastDir()
{
RedirectTo( *request.dir_table.back() );
}
void Content::ReadAdditionalInfo()
{
if( request.dir_table.empty() )
return;
if( data.mounts.pmount->type == Mount::thread )
{
if( db.GetThreadByDirId(request.dir_table.back()->id, request.thread) == WINIX_ERR_OK )
request.is_thread = true;
}
else
if( data.mounts.pmount->type == Mount::ticket )
{
if( db.GetTicketByDirId(request.dir_table.back()->id, request.ticket) == WINIX_ERR_OK )
{
request.is_ticket = true;
if( !request.is_item && (!request.pfunction || request.pfunction->code == FUN_TICKET) )
{
db.GetItemById(request.ticket.item_id, request.item);
// don't set request.is_item here
}
}
}
}
void Content::PrepareUrl(Item & item)
{
TrimWhite(item.url);
if( item.url.empty() )
item.url = item.subject; // if the subject is empty then the url will be corrected by CorrectUrlOnlyAllowedChar()
CorrectUrlOnlyAllowedChar(item.url);
if( data.functions.GetFunction(item.url) )
{
// the name provided by an user is the same as a name of a function
// we add one underscore character at the beginning
// names of functions should not begin with an underscore '_'
// and we can simply add one '_' at the beginning
// and the name will be unique
item.url.insert(item.url.begin(), '_');
}
}
bool Content::CheckRebus()
{
if( request.session->puser )
// logged user don't have to use the rebus
return true;
if( request.session->rebus_checked )
return true;
request.session->rebus_checked = true;
if( !request.session->rebus_item )
{
log << log1 << "Content: rebus not set" << logend;
return false;
}
try
{
std::string * answer = request.PostVar("rebus");
if( answer && data.rebus.IsAnswerOk(request.session->rebus_item, *answer) )
return true;
}
catch(const Error &)
{
}
log << log1 << "Content: rebus has an incorrect answer" << logend;
// don't add request.session->spam_score when the rebus has incorrect answer
// a user could have made a mistake
return false;
}
void Content::SetUser(Item & item)
{
if( request.session->puser )
{
item.user_id = request.session->puser->id;
item.guest_name.clear();
}
else
{
item.user_id = -1;
request.PostVar("guestname", item.guest_name);
}
item.group_id = request.dir_table.back()->group_id;
}
void Content::CheckGetPostTimes(time_t difference)
{
time_t now = std::time(0);
if( request.session->puser )
return;
if( request.method != Request::post )
return;
if( now - request.session->last_time_get >= (time_t)difference )
return;
if( request.AllPostVarEmpty() )
return;
request.session->spam_score += 1;
log << log1 << "Content: spam +1: POST after GET sent too fast" << logend;
}
/*
bool Content::CreateFile(const std::string & path, const std::string & content)
{
std::ofstream file(path.c_str(), std::ios_base::binary | std::ios_base::out);
if( !file )
{
log << log1 << "Content: can't create file: " << path << logend;
return false;
}
file << content;
file.close();
// !! dodac sprawdzenie prawidlowosci zapisania pliku
return true;
}
*/

View File

@@ -1,295 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2008-2010, Tomasz Sowa
* All rights reserved.
*
*/
#ifndef headerfilecmslucontentcontent
#define headerfilecmslucontentcontent
#include <cstdlib>
#include <fcgiapp.h>
#include <ctime>
#include "../core/item.h"
#include "../templates/templates.h"
#include "../core/thread.h"
#include "../core/ticket.h"
#include "../core/db.h"
class Content
{
Templates templates;
std::string temp;
void FunDownload();
void CheckSpecialFile();
void PrepareUrl(Item & item);
bool CheckAddUserVars(const std::string * login, const std::string * pass, const std::string * conf_pass);
void PostFunAddUser();
void FunAddUser();
/*
mv
*/
bool MoveIsTheSameFile(const Item & item);
void MoveAuth(Item & item);
void MoveFile(Item & item, bool redirect = true);
void MoveDir(Item & item, bool redirect = true);
void MoveAuthPrepareQuery();
void MoveAuthContentOfDir(const Item & item);
bool MoveParseDir(long & dir_id, std::string & dir, std::string & file);
bool MoveCheckAccessFromToDir();
bool MoveCheckAccessFrom();
bool MoveCheckAccessTo(long dir_id);
bool MoveCheckMountPoints(long dir_id);
void MoveContentOfDir();
void PostFunMv();
void FunMv();
std::string mv_dir;
std::string mv_file;
std::string mv_new_path;
long mv_dir_id;
std::vector<Item> mv_auth;
Db::ItemQuery mv_auth_iq;
/*
cp
*/
bool CpCheckAccessFrom();
void CpAuth(Item & item);
void CpSetNewAttributes(Item & item);
void CpItem(Item & item, long dst_dir_id);
void CpFilesInDir(const Item & dir, long dst_dir_id);
void CpContentOfDir(const Item & item, long dst_dir_id);
long CpDir(const Item & item, long dst_dir_id);
void CpItemCheck(Item & item, bool redirect = true);
void CpContentOfDirCheck(const Item & item, bool redirect = true);
void CpDirCheck(const Item & item, bool redirect = true);
void PostFunCp();
void FunCp();
void CpPrepare();
Item cp_temp;
Db::ItemQuery cp_iq;
bool cp_remove_defaults;
bool cp_preserve_attr;
long cp_new_user;
long cp_new_group;
void SetDefaultFunctionForFile();
void SetDefaultFunctionForDir();
void SetDefaultFunction();
bool DirsHaveReadExecPerm();
/*
calling functions (standard, post)
*/
typedef void (Content::*Fun)();
struct FunItem
{
int code;
Fun fun;
};
void FunNothing();
void CallFunction();
void MakeStandardFunction();
void CallPostFunction();
void MakePost();
void SetUser(Item & item);
bool CheckRebus();
void FunCat();
void FunLogout();
void FunLs();
void FunEmacs();
void AddPathToAuth(std::string & path);
void FunCKEditor();
void FunUname();
bool SubjectCheckAccess();
void EditDirSubject();
void EditFileSubject();
void PostFunSubject();
void FunSubject();
/*
rm
*/
bool RemoveCheckAccess();
void RemoveAllDirs();
void RemoveAllDirs(long dir_id);
void RemoveDir();
void RemoveAuthPrepareQuery();
void RemoveAuth(Item & item);
void RemoveFile();
void FunRm();
Db::ItemQuery rm_auth_iq;
void FunNode();
void FunMkdir();
void FunDefault();
void FunRun();
void PostFunRun();
void FunWho();
void FunLast();
void FunReloadTemplates();
void FunReload();
static bool FunThreadSort(const Thread & t1, const Thread & t2);
void FunThread();
void FunCreateThread();
bool FunUploadCheckAccess();
void FunUpload();
bool ReadItemUrlSubject(Item & item, Item::Type item_type);
bool ReadItem(Item & item, Item::Type item_type);
void CheckAccessToItems();
void LoginUser(long user_id, bool remember_me);
void FunLogin();
void PostFunLogin();
void ReadItemContentWithType(Item & item);
bool FunEmacsCheckAccess();
void PostFunEmacsAdd(Item & item);
void PostFunEmacsEdit(bool with_url);
bool PostEmacsCheckAbuse(bool adding);
void PostFunEmacsModifyMountPoint(bool adding);
void PostFunEmacs();
bool FunMkdirCheckAccess();
void PostFunMkdir(bool add_to_dir_table, int privileges);
void PostFunMkdir();
void Mkdir(Item & item, bool add_to_dir_table);
long PostFunDefaultParsePath();
void PostFunDefault();
/*
function: priv, chmod, chown
*/
bool PrivCheckAccess();
void PrivLogStart(const char * what, long user, long group, int priv);
void PrivLog(const char * what, long id, const std::string & url);
bool ChangeOwner(Item & item, long user_id, long group_id);
bool ChangePrivileges(Item & item, int privileges);
void ChangePriv(Item & item, long user_id, long group_id, int privileges);
void PostFunPriv();
void PrivFilesInDir(long parent_id);
void PrivDir(long parent_id);
bool ReadPriv(const char * user_in, const char * group_in, const char * priv_in, long & user_id, long & group_id, int & priv);
void PrivDir();
void PrivOneItem();
void FunPriv();
long user_id_file, group_id_file, user_id_dir, group_id_dir;
int priv_file, priv_dir;
bool subdirectories;
bool change_owner, change_priv;
bool FunCreateThreadCheckAccess();
bool FunCreateThreadCheckAbuse();
void ReadThread(Thread & thread);
void AddThread();
void PostFunCreateThreadLogAndRedirect();
void PostFunCreateThread();
bool UploadCreatePath();
void UploadSaveFile(const std::string & tmp_filename, const std::string & destination);
void UploadMulti();
void UploadSingle();
bool FunUploadCheckAbuse();
void PostFunUpload();
bool FunCreateTicketCheckAccess();
void FunCreateTicket();
bool FunCreateTicketCheckAbuse();
void PostFunCreateTicketLogAndRedirect();
void PostFunCreateTicket();
void FunTicket();
void TicketDeleteFirst();
bool FunEditTicketCheckAccess();
void PostFunEditTicketLogAndRedirect();
void EditTicketCheckFirstItem();
void EditTicketModTicket();
void EditTicketModDir();
void EditTicketModFirstItem();
void PostFunEditTicket();
void FunEditTicket();
void AddTicket();
void ReadTicket(Ticket & ticket);
void ReadTicketType(Ticket & ticket);
void ReadTicketStatus(Ticket & ticket);
void ReadTicketPriority(Ticket & ticket);
void ReadTicketCategory(Ticket & ticket);
void ReadTicketExpected(Ticket & ticket);
void ReadTicketProgress(Ticket & ticket);
void RedirectTo(const Item & item, const char * postfix = 0);
void RedirectTo(long item_id, const char * postfix = 0);
void RedirectToLastDir();
void CheckGetPostTimes(time_t difference = 10);
// bool CreateFile(const std::string & path, const std::string & content);
void MakePage();
public:
bool Init();
void ReadAdditionalInfo();
void Make();
};
#endif

View File

@@ -1,261 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2008-2010, Tomasz Sowa
* All rights reserved.
*
*/
#include <errno.h>
#include "content.h"
#include "../core/request.h"
#include "../core/data.h"
#include "../core/misc.h"
bool Content::CpCheckAccessFrom()
{
if( request.is_item )
{
if( !request.HasReadAccess(request.item) )
{
request.status = WINIX_ERR_PERMISSION_DENIED;
return false;
}
}
else
if( !request.IsParam("r") )
{
// directories need 'r' parameter
request.status = WINIX_ERR_PERMISSION_DENIED;
}
return true;
}
void Content::CpAuth(Item & item)
{
if( !request.MakePath(item, mv_new_path, true) )
{
request.status = WINIX_ERR_PERMISSION_DENIED;
return;
}
if( CopyFile(item.auth_path, mv_new_path) )
{
log << log1 << "Content: copied static file from: " << item.auth_path << ", to: " << mv_new_path << logend;
item.auth_path = mv_new_path;
request.status = db.EditAuthById(item, item.id);
}
else
{
log << log1 << "Content: can't copy a file from: " << item.auth_path << ", to: " << mv_new_path << logend;
request.status = WINIX_ERR_PERMISSION_DENIED;
}
}
void Content::CpSetNewAttributes(Item & item)
{
item.user_id = cp_new_user;
item.group_id = cp_new_group;
item.SetDateModifyToNow();
}
void Content::CpItem(Item & item, long dst_dir_id)
{
if( !request.HasReadAccess(item) )
return; // !! w przyszlosci bedziemy dodawac komunikaty do specjalnej tablicy (narazie nie zaimplementowane)
item.parent_id = dst_dir_id;
if( !cp_preserve_attr )
CpSetNewAttributes(item);
PostFunEmacsAdd(item);
if( request.status == WINIX_ERR_OK )
{
if( item.auth != Item::auth_none )
CpAuth(item);
}
}
void Content::CpPrepare()
{
cp_iq.SetAll(true, false);
cp_iq.WhereType(Item::file);
cp_new_user = -1;
cp_new_group = -1;
if( request.session->puser )
cp_new_user = request.session->puser->id;
Item * pdir = data.dirs.GetDir(mv_dir_id);
if( pdir )
cp_new_group = pdir->group_id;
}
void Content::CpFilesInDir(const Item & dir, long dst_dir_id)
{
cp_iq.WhereParentId(dir.id);
db.GetItems(request.item_table, cp_iq);
for(size_t i=0 ; i<request.item_table.size() ; ++i)
CpItem(request.item_table[i], dst_dir_id);
}
void Content::CpContentOfDir(const Item & item, long dst_dir_id)
{
DirContainer::ParentIterator i = data.dirs.FindFirstParent(item.id);
// go through all directories
for( ; i != data.dirs.ParentEnd() ; i = data.dirs.NextParent(i) )
CpDir(*(i->second), dst_dir_id);
CpFilesInDir(item, dst_dir_id);
}
// we shouldn't change 'item' because we have references to our data.dirs objects
long Content::CpDir(const Item & item, long dst_dir_id)
{
cp_temp = item;
cp_temp.parent_id = dst_dir_id;
if( !mv_file.empty() )
{
cp_temp.url = mv_file;
mv_file.clear();
PrepareUrl(cp_temp);
}
if( !cp_preserve_attr )
CpSetNewAttributes(cp_temp);
if( cp_remove_defaults )
cp_temp.default_item = -1;
Mkdir(cp_temp, false);
long new_dir_id = cp_temp.id; // remember the new dir_id
if( request.HasReadExecAccess(item) )
CpContentOfDir(item, cp_temp.id);
return new_dir_id; // and return it
}
// here 'item' can be changed in place
void Content::CpItemCheck(Item & item, bool redirect)
{
if( MoveIsTheSameFile(item) )
return;
if( !mv_file.empty() )
{
item.url = mv_file;
PrepareUrl(item);
}
CpItem(item, mv_dir_id);
if( request.status==WINIX_ERR_OK && redirect )
RedirectTo(item);
}
void Content::CpContentOfDirCheck(const Item & item, bool redirect)
{
if( !mv_file.empty() )
{
request.status = WINIX_ERR_INCORRECT_DIR;
return;
}
if( mv_dir_id == item.id )
return; // nothing to do
if( data.dirs.HasParent(mv_dir_id, item.id) )
{
log << log1 << "Content: cannot copy directory to inside it" << logend;
request.status = WINIX_ERR_INCORRECT_DIR;
return;
}
CpContentOfDir(item, mv_dir_id);
if( request.status==WINIX_ERR_OK && redirect )
RedirectTo(mv_dir_id);
}
void Content::CpDirCheck(const Item & item, bool redirect)
{
if( mv_file.empty() && mv_dir_id == item.id )
return; // nothing to do
if( mv_dir_id == item.id || data.dirs.HasParent(mv_dir_id, item.id) )
{
log << log1 << "Content: cannot copy directory to inside it" << logend;
request.status = WINIX_ERR_INCORRECT_DIR;
return;
}
long new_dir_id = CpDir(item, mv_dir_id);
if( request.status==WINIX_ERR_OK && redirect )
RedirectTo(new_dir_id);
}
void Content::PostFunCp()
{
if( CpCheckAccessFrom() &&
MoveParseDir(mv_dir_id, mv_dir, mv_file) &&
MoveCheckAccessTo(mv_dir_id) )
{
CpPrepare();
cp_preserve_attr = request.IsPostVar("preserveattr");
if( request.is_item )
{
CpItemCheck(request.item);
}
else
{
cp_remove_defaults = request.IsPostVar("removedefaults");
if( request.IsPostVar("onlycontent") )
CpContentOfDirCheck(*request.dir_table.back());
else
CpDirCheck(*request.dir_table.back());
}
}
}
void Content::FunCp()
{
CpCheckAccessFrom();
}

View File

@@ -1,136 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2008-2010, Tomasz Sowa
* All rights reserved.
*
*/
#include "content.h"
#include "../core/request.h"
#include "../core/error.h"
#include "../core/db.h"
#include "../core/mount.h"
#include "../core/data.h"
bool Content::FunCreateThreadCheckAccess()
{
if( !request.CanCreateThread() )
{
request.status = WINIX_ERR_PERMISSION_DENIED;
return false;
}
return true;
}
bool Content::FunCreateThreadCheckAbuse()
{
if( !CheckRebus() )
{
request.status = WINIX_ERR_INCORRECT_REBUS;
return false;
}
CheckGetPostTimes();
if( request.session->spam_score > 0 )
{
request.status = WINIX_ERR_SPAM;
log << log1 << "Content: ignoring due to suspected spamming" << logend;
return false;
}
return true;
}
void Content::ReadThread(Thread & thread)
{
thread.parent_id = request.dir_table.back()->id;
}
void Content::AddThread()
{
request.thread.dir_id = request.dir_table.back()->id;
request.thread.closed = false;
request.thread.items = 1;
request.thread.last_item = request.item; // set by PostFunEmacsAdd()
request.status = db.AddThread(request.thread);
}
void Content::PostFunCreateThreadLogAndRedirect()
{
if( request.status == WINIX_ERR_OK )
{
log << log2 << "Content: added a new thread" << logend;
RedirectToLastDir();
}
else
{
log << log1 << "Content: problem with adding a new thread, error code: "
<< request.status << logend;
}
}
void Content::PostFunCreateThread()
{
if( !FunCreateThreadCheckAccess() )
return;
ReadItem(request.item, Item::dir);
ReadThread(request.thread);
request.item.privileges = 0777; // !! tymczasowo 777 aby wszyscy mogli wysylac posty
if( !FunCreateThreadCheckAbuse() )
{
ReadItemContentWithType(request.item); // for correctly displaying the form
return;
}
Mkdir(request.item, true);
if( request.status == WINIX_ERR_OK )
{
ReadItemContentWithType(request.item);
request.item.type = Item::file;
request.item.privileges = 0644; // !! tymczasowo
request.item.parent_id = request.dir_table.back()->id;
PostFunEmacsAdd(request.item);
if( request.status == WINIX_ERR_OK )
AddThread();
}
PostFunCreateThreadLogAndRedirect();
}
void Content::FunCreateThread()
{
FunCreateThreadCheckAccess();
}

View File

@@ -1,221 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2008-2010, Tomasz Sowa
* All rights reserved.
*
*/
#include "content.h"
#include "../core/request.h"
#include "../core/error.h"
#include "../core/db.h"
#include "../core/mount.h"
#include "../core/data.h"
bool Content::FunCreateTicketCheckAccess()
{
if( !request.CanCreateTicket() )
{
request.status = WINIX_ERR_PERMISSION_DENIED;
return false;
}
return true;
}
bool Content::FunCreateTicketCheckAbuse()
{
if( !CheckRebus() )
{
request.status = WINIX_ERR_INCORRECT_REBUS;
return false;
}
CheckGetPostTimes();
if( request.session->spam_score > 0 )
{
request.status = WINIX_ERR_SPAM;
log << log1 << "Content: ignoring due to suspected spamming" << logend;
return false;
}
return true;
}
void Content::ReadTicketType(Ticket & ticket)
{
static std::string temp;
request.PostVar("type", temp);
ticket.type = atoi(temp.c_str());
if( ticket.type >= data.mounts.pmount->param[Mount::par_ticket_type].arg.size() )
ticket.type = data.mounts.pmount->param[Mount::par_ticket_type].arg.size();
}
void Content::ReadTicketStatus(Ticket & ticket)
{
static std::string temp;
request.PostVar("status", temp);
ticket.status = atoi(temp.c_str());
if( ticket.status >= data.mounts.pmount->param[Mount::par_ticket_status].arg.size() )
ticket.status = data.mounts.pmount->param[Mount::par_ticket_status].arg.size();
}
void Content::ReadTicketPriority(Ticket & ticket)
{
static std::string temp;
request.PostVar("priority", temp);
ticket.priority = atoi(temp.c_str());
if( ticket.priority >= data.mounts.pmount->param[Mount::par_ticket_priority].arg.size() )
ticket.priority = data.mounts.pmount->param[Mount::par_ticket_priority].arg.size();
}
void Content::ReadTicketCategory(Ticket & ticket)
{
static std::string temp;
request.PostVar("category", temp);
ticket.category = atoi(temp.c_str());
if( ticket.category >= data.mounts.pmount->param[Mount::par_ticket_category].arg.size() )
ticket.category = data.mounts.pmount->param[Mount::par_ticket_category].arg.size();
}
void Content::ReadTicketExpected(Ticket & ticket)
{
static std::string temp;
request.PostVar("expected", temp);
ticket.expected = atoi(temp.c_str());
if( ticket.expected >= data.mounts.pmount->param[Mount::par_ticket_expected].arg.size() )
ticket.expected = data.mounts.pmount->param[Mount::par_ticket_expected].arg.size();
}
void Content::ReadTicketProgress(Ticket & ticket)
{
static std::string temp;
request.PostVar("progress", temp);
int p = atoi(temp.c_str());
if( p < 0 )
p = 0;
if( p > 100 )
p = 100;
ticket.progress = p;
}
void Content::ReadTicket(Ticket & ticket)
{
ticket.parent_id = request.dir_table.back()->id;
ReadTicketType(ticket);
ReadTicketStatus(ticket);
ReadTicketPriority(ticket);
ReadTicketCategory(ticket);
ReadTicketExpected(ticket);
ReadTicketProgress(ticket);
}
void Content::AddTicket()
{
static std::string temp;
request.ticket.dir_id = request.dir_table.back()->id; // a new directory created by Mkdir()
request.ticket.item_id = request.item.id; // this id is set by PostFunEmacsAdd()
request.status = db.AddTicket(request.ticket);
}
void Content::PostFunCreateTicketLogAndRedirect()
{
if( request.status == WINIX_ERR_OK )
{
log << log2 << "Content: added a new ticket" << logend;
RedirectToLastDir();
}
else
{
log << log1 << "Content: problem with adding a new ticket, error code: "
<< request.status << logend;
}
}
void Content::PostFunCreateTicket()
{
if( !FunCreateTicketCheckAccess() )
return;
ReadItem(request.item, Item::dir);
ReadTicket(request.ticket);
request.item.privileges = 0777; // !! tymczasowo 777 aby wszyscy mogli wysylac posty
if( !FunCreateTicketCheckAbuse() )
{
ReadItemContentWithType(request.item); // for correctly displaying the form
return;
}
Mkdir(request.item, true);
if( request.status == WINIX_ERR_OK )
{
ReadItemContentWithType(request.item);
request.item.type = Item::file;
request.item.privileges = 0644; // !! tymczasowo
request.item.parent_id = request.dir_table.back()->id;
PostFunEmacsAdd(request.item);
if( request.status == WINIX_ERR_OK )
AddTicket();
}
PostFunCreateTicketLogAndRedirect();
}
void Content::FunCreateTicket()
{
FunCreateTicketCheckAccess();
}

View File

@@ -1,110 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2008-2010, Tomasz Sowa
* All rights reserved.
*
*/
#include "content.h"
#include "../core/request.h"
#include "../core/error.h"
#include "../core/db.h"
#include "../core/data.h"
long Content::PostFunDefaultParsePath()
{
Item * pdir, * pdir2;
long defaultid = -1;
std::string * path = request.PostVar("defaultitem");
if( path && !path->empty() )
{
std::string dir, file;
Dirs::SplitPath(*path, dir, file);
pdir = data.dirs.GetDir(dir);
if( !pdir )
throw Error(WINIX_ERR_INCORRECT_DIR);
if( file.empty() )
{
defaultid = pdir->id;
}
else
{
// checking whether the file is a directory too (the method SplitPath does not check it)
pdir2 = data.dirs.GetDir(file, pdir->id);
if( !pdir2 )
{
defaultid = db.GetFileId(pdir->id, file);
if( defaultid == -1 )
throw Error(WINIX_ERR_NO_ITEM);
}
else
{
// file is a directory
defaultid = pdir2->id;
}
}
}
return defaultid;
}
void Content::PostFunDefault()
{
if( !request.HasWriteAccess(*request.dir_table.back()) )
{
request.status = WINIX_ERR_PERMISSION_DENIED;
return;
}
try
{
long defaultid = PostFunDefaultParsePath();
request.status = db.EditDefaultItem(request.dir_table.back()->id, defaultid);
if( request.status == WINIX_ERR_OK )
request.dir_table.back()->default_item = defaultid;
}
catch(const Error & e)
{
request.status = e;
}
if( request.status == WINIX_ERR_OK )
RedirectTo(*request.dir_table.back());
else
log << log1 << "Content: PostFunDefaultItem: Error: " << request.status << logend;
}
void Content::FunDefault()
{
if( !request.HasWriteAccess(*request.dir_table.back()) )
{
request.status = WINIX_ERR_PERMISSION_DENIED;
return;
}
}

View File

@@ -1,43 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2008-2010, Tomasz Sowa
* All rights reserved.
*
*/
#include "content.h"
#include "../core/request.h"
#include "../core/data.h"
void Content::FunDownload()
{
// !! moze wywalic to no_item i wszedzie w takich miejscach dac poprostu permission_denied?
if( !request.is_item )
{
log << log1 << "Content: download function requires an item" << logend;
request.status = WINIX_ERR_NO_ITEM;
return;
}
if( !request.HasReadAccess(request.item) ||
request.item.auth == Item::auth_none ||
request.item.auth_path.empty() )
{
request.status = WINIX_ERR_PERMISSION_DENIED;
return;
}
request.send_as_attachment = request.IsParam("attachment");
request.x_sendfile = request.item.auth_path;
}

View File

@@ -1,174 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2008-2010, Tomasz Sowa
* All rights reserved.
*
*/
#include "content.h"
#include "../core/request.h"
#include "../core/error.h"
#include "../core/db.h"
#include "../core/mount.h"
#include "../core/data.h"
bool Content::FunEditTicketCheckAccess()
{
if( !request.CanEditTicket() )
{
request.status = WINIX_ERR_PERMISSION_DENIED;
return false;
}
return true;
}
void Content::EditTicketCheckFirstItem()
{
if( request.status != WINIX_ERR_OK )
return;
if( request.ticket.item_id == -1 )
{
// creating a new item (the item was deleted by a user)
Item item;
item.parent_id = request.dir_table.back()->id;
item.subject = request.dir_table.back()->subject;
item.type = Item::file;
item.privileges = 0644; // !! tymczasowo
SetUser(item);
PrepareUrl(item);
request.status = db.AddItem(item);
if( request.status == WINIX_ERR_OK )
{
log << log2 << "Content: added the first item with content for the ticket, item.id: " << item.id << logend;
request.ticket.item_id = item.id;
}
}
}
void Content::EditTicketModTicket()
{
if( request.status != WINIX_ERR_OK )
return;
Ticket ticket;
ReadTicket(ticket);
request.ticket.type = ticket.type;
request.ticket.status = ticket.status;
request.ticket.priority = ticket.priority;
request.ticket.category = ticket.category;
request.ticket.expected = ticket.expected;
request.ticket.progress = ticket.progress;
request.status = db.EditTicketById(request.ticket);
}
void Content::EditTicketModDir()
{
if( request.status != WINIX_ERR_OK )
return;
// we don't modify the url
Item & dir = *request.dir_table.back();
bool edit_dir_subject = (dir.subject != request.item.subject);
if( edit_dir_subject )
{
dir.subject = request.item.subject;
request.status = db.EditItemById(dir, false);
}
}
void Content::EditTicketModFirstItem()
{
if( request.status != WINIX_ERR_OK )
return;
// modyfing the first item (the one with content)
ReadItemContentWithType(request.item);
Item item;
db.GetItemById(request.ticket.item_id, item);
item.subject = request.item.subject;
item.content = request.item.content;
item.content_type = request.item.content_type;
// the url doesn't matter
db.EditItemById(item, false);
}
void Content::PostFunEditTicketLogAndRedirect()
{
if( request.status == WINIX_ERR_OK )
{
log << log2 << "Content: edited a ticket" << logend;
RedirectToLastDir();
}
else
{
log << log1 << "Content: problem with editing a ticket, error code: "
<< request.status << logend;
}
}
void Content::PostFunEditTicket()
{
if( !FunEditTicketCheckAccess() )
return;
ReadItem(request.item, Item::dir);
if( !FunCreateTicketCheckAbuse() )
{
ReadItemContentWithType(request.item); // for correctly displaying the form
return;
}
if( db.GetTicketByDirId(request.dir_table.back()->id, request.ticket) != WINIX_ERR_OK )
{
request.status = WINIX_ERR_PERMISSION_DENIED;
return;
}
EditTicketCheckFirstItem();
EditTicketModTicket();
EditTicketModDir();
EditTicketModFirstItem();
PostFunEditTicketLogAndRedirect();
}
void Content::FunEditTicket()
{
FunEditTicketCheckAccess();
db.GetItemById(request.ticket.item_id, request.item);
// the subject we get from the last directory
request.item.subject = request.dir_table.back()->subject;
}

View File

@@ -1,164 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2008-2010, Tomasz Sowa
* All rights reserved.
*
*/
#include "content.h"
#include "../core/request.h"
#include "../core/error.h"
#include "../core/db.h"
#include "../core/data.h"
#include "../core/notify.h"
#include "../core/misc.h"
bool Content::FunEmacsCheckAccess()
{
if( !request.is_item )
{
// adding a new item
if( !request.CanUseEmacs(*request.dir_table.back()) )
{
request.status = WINIX_ERR_PERMISSION_DENIED;
return false;
}
}
else // editing an existing item
if( !request.CanUseEmacs(request.item) )
{
request.status = WINIX_ERR_PERMISSION_DENIED;
return false;
}
return true;
}
void Content::PostFunEmacsAdd(Item & item)
{
request.status = db.AddItem(item);
if( request.status == WINIX_ERR_OK )
{
log << log2 << "Content: added a new item, url: " << item.url << ", id: " << item.id
<< ", parent_id: " << item.parent_id << logend;
request.notify_code |= WINIX_NOTIFY_ITEM_ADD;
}
}
void Content::PostFunEmacsEdit(bool with_url)
{
request.item.SetDateModifyToNow();
request.status = db.EditItemById(request.item, with_url);
if( request.status == WINIX_ERR_OK )
{
TemplatesFunctions::pattern_cacher.UpdatePattern(request.item);
log << log2 << "Content: modified an item" << logend;
request.notify_code |= WINIX_NOTIFY_ITEM_EDIT;
}
}
bool Content::PostEmacsCheckAbuse(bool adding)
{
if( !CheckRebus() )
{
request.status = WINIX_ERR_INCORRECT_REBUS;
return false;
}
// !! is tested in createthread once
CheckGetPostTimes();
if( request.session->spam_score > 0 )
{
request.status = WINIX_ERR_SPAM;
log << log1 << "Content: ignoring due to suspected spamming" << logend;
return false;
}
return true;
}
void Content::PostFunEmacsModifyMountPoint(bool adding)
{
if( data.mounts.pmount->type == Mount::thread )
{
if( adding )
db.EditThreadAddItem(request.dir_table.back()->id, request.item.id);
RedirectToLastDir();
}
else
if( data.mounts.pmount->type == Mount::ticket )
{
RedirectToLastDir();
}
else
{
// Mount::cms
RedirectTo(request.item);
}
}
void Content::PostFunEmacs()
{
if( !FunEmacsCheckAccess() )
return;
bool adding = !request.is_item;
bool edit_with_url = ReadItem(request.item, Item::file);
if( !PostEmacsCheckAbuse(adding) )
return;
if( adding )
{
request.is_item = true;
request.item.privileges = 0644; // !! tymczasowo, bedzie uzyte umask
PostFunEmacsAdd(request.item);
}
else
{
PostFunEmacsEdit(edit_with_url);
}
if( request.status == WINIX_ERR_OK )
{
PostFunEmacsModifyMountPoint(adding);
CheckSpecialFile();
}
else
{
log << log1 << "Content: PostFunEmacs: Error: "
<< request.status << logend;
}
}
void Content::FunEmacs()
{
FunEmacsCheckAccess();
}

View File

@@ -1,24 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2008-2010, Tomasz Sowa
* All rights reserved.
*
*/
#include "content.h"
void Content::FunLast()
{
}

View File

@@ -1,71 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2008-2010, Tomasz Sowa
* All rights reserved.
*
*/
#include <arpa/inet.h>
#include "content.h"
#include "../core/request.h"
#include "../core/error.h"
#include "../core/db.h"
#include "../core/data.h"
void Content::LoginUser(long user_id, bool remember_me)
{
request.session->puser = data.users.GetUser(user_id);
request.session->spam_score = 0;
if( !request.session->puser )
{
log << log1 << "Content: user id: " << user_id << " is not in data.users" << logend;
return;
}
request.session->remember_me = remember_me;
data.last.UserLogin(user_id, request.session->puser->name, inet_addr(request.env_remote_addr), request.session->id);
data.how_many_logged += 1;
log << log2 << "User " << request.session->puser->name << " (id: " << user_id << ") logged" << logend;
}
void Content::PostFunLogin()
{
try
{
std::string * login = request.PostVar("login");
std::string * pass = request.PostVar("password");
std::string * remem = request.PostVar("rememberme");
long user_id;
if( login && pass && db.CheckUser(*login, *pass, user_id) )
LoginUser(user_id, remem != 0);
// !! moze zglosic komunikat o nie poprawnym logowaniu
}
catch(const Error &)
{
}
if( request.is_item )
RedirectTo(request.item);
else
RedirectTo(*request.dir_table.back());
}
void Content::FunLogin()
{
}

View File

@@ -1,49 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2008-2010, Tomasz Sowa
* All rights reserved.
*
*/
#include "content.h"
#include "../core/request.h"
#include "../core/data.h"
void Content::FunLogout()
{
if( request.session->puser )
{
log << log2 << "User: " << request.session->puser->name << ", id: " << request.session->puser->id << " logged out" << logend;
data.last.UserLogout(request.session->puser->id, request.session->id);
if( data.how_many_logged > 0 ) // for safety
data.how_many_logged -= 1;
request.session->puser = 0;
request.session->remember_me = 0;
}
std::string path;
data.dirs.MakePath(request.dir_table.back()->id, path);
request.redirect_to = data.base_url + path;
if( request.is_item )
request.redirect_to += request.item.url;
}

View File

@@ -1,45 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2008-2010, Tomasz Sowa
* All rights reserved.
*
*/
#include "content.h"
#include "../core/request.h"
#include "../core/db.h"
void Content::FunLs()
{
if( !request.is_item )
{
Db::ItemQuery iq;
iq.sel_content = false;
iq.WhereParentId(request.dir_table.back()->id);
iq.WhereType(Item::file);
if( request.IsParam("ckeditor_browse") )
{
iq.WhereAuth(Item::auth_image);
db.GetItems(request.item_table, iq);
}
else
{
db.GetItems(request.item_table, iq);
}
}
}

View File

@@ -1,143 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2008-2010, Tomasz Sowa
* All rights reserved.
*
*/
#include "content.h"
#include "../core/request.h"
#include "../core/misc.h"
#include "../core/db.h"
// returning true if the 'url' has to be changed
bool Content::ReadItemUrlSubject(Item & item, Item::Type item_type)
{
bool with_url = false;
std::string * new_url = request.PostVar("url");
std::string * new_subject = request.PostVar("subject");
if( item_type == Item::file )
{
if( !request.is_item || (new_url && *new_url != item.url) )
with_url = true;
}
else
{
with_url = true;
}
if( new_url )
item.url = *new_url;
if( new_subject )
item.subject = *new_subject;
if( item.subject.empty() )
{
item.subject = request.dir_table.back()->subject;
item.subject += "_msg_";
item.subject += ToStr(db.Size(request.dir_table.back()->id, Item::file));
}
// if item.url is empty then it will be set from item.subject
PrepareUrl(item);
return with_url;
}
void Content::ReadItemContentWithType(Item & item)
{
item.content_type = Item::ct_formatted_text; // default is formatted text
request.PostVar("itemcontent", request.item.content);
request.PostVar("contenttype", temp);
// ct_text and ct_formatted_text can use everyone
if( temp == "0" )
item.content_type = Item::ct_text;
else
if( temp == "1" )
item.content_type = Item::ct_formatted_text;
// those below need special privileges
if( !request.session->puser )
return;
long user_id = request.session->puser->id;
if( temp == "2" )
{
if( request.CanUseHtml(user_id) )
item.content_type = Item::ct_html;
}
else
if( temp == "3" )
{
if( request.CanUseBBCode(user_id) )
item.content_type = Item::ct_bbcode;
}
else
if( temp == "4" )
{
if( request.CanUseRaw(user_id) )
item.content_type = Item::ct_raw;
}
}
// item_type - the type of an item you are expecting to read
// returns true if the url has to be changed
// at the moment this is only checked for Item::file - for Item::dir it returns always true
bool Content::ReadItem(Item & item, Item::Type item_type)
{
if( item_type == Item::none )
return false;
item.type = item_type;
item.parent_id = request.dir_table.back()->id;
bool edit_with_url = ReadItemUrlSubject(item, item_type);
SetUser(item);
if( item_type == Item::file )
ReadItemContentWithType(item);
return edit_with_url;
}
// if we don't have access we only remove the item from the table
void Content::CheckAccessToItems()
{
size_t i = 0;
while( i < request.item_table.size() )
{
if( !request.HasReadAccess(request.item_table[i]) )
{
request.item_table.erase(request.item_table.begin() + i);
}
else
{
i += 1;
}
}
}

View File

@@ -1,36 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2008-2010, Tomasz Sowa
* All rights reserved.
*
*/
#include "content.h"
#include "../core/request.h"
#include "../core/data.h"
void Content::CheckSpecialFile()
{
static std::string fstab = "fstab";
Item * etc = data.dirs.GetEtcDir();
if( !etc )
return;
if( request.item.parent_id != etc->id )
return;
if( request.item.url == fstab )
{
log << log3 << "Content: reloading mount points" << logend;
request.status = data.mounts.ReadMounts(request.item.content);
templates.ReadNewIndexTemplates();
}
}

View File

@@ -1,84 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2008-2010, Tomasz Sowa
* All rights reserved.
*
*/
#include "content.h"
#include "../core/request.h"
#include "../core/error.h"
#include "../core/db.h"
#include "../core/data.h"
#include "../core/notify.h"
bool Content::FunMkdirCheckAccess()
{
if( request.is_item || !request.CanUseMkdir(*request.dir_table.back()) )
{
request.status = WINIX_ERR_PERMISSION_DENIED;
return false;
}
return true;
}
void Content::Mkdir(Item & item, bool add_to_dir_table)
{
request.status = db.AddItem(item);
if( request.status == WINIX_ERR_OK )
{
Item * pdir = data.dirs.AddDir(item);
if( add_to_dir_table )
request.dir_table.push_back(pdir);
}
}
void Content::PostFunMkdir(bool add_to_dir_table, int privileges)
{
if( !FunMkdirCheckAccess() )
return;
ReadItem(request.item, Item::dir);
request.item.privileges = privileges;
Mkdir(request.item, add_to_dir_table);
if( request.status == WINIX_ERR_OK )
{
request.notify_code |= WINIX_NOTIFY_DIR_ADD;
RedirectTo(request.item);
}
else
{
log << log1 << "Content: PostFunMkdir: Error: " << request.status << logend;
}
}
void Content::PostFunMkdir()
{
PostFunMkdir(false, 0755);
}
void Content::FunMkdir()
{
FunMkdirCheckAccess();
}

View File

@@ -1,364 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2008-2010, Tomasz Sowa
* All rights reserved.
*
*/
#include <errno.h>
#include "content.h"
#include "../core/request.h"
#include "../core/data.h"
bool Content::MoveCheckAccessFromToDir()
{
Item * last;
Item * last_but_one = 0;
last = request.dir_table[request.dir_table.size()-1];
if( request.dir_table.size() >= 2 )
last_but_one = request.dir_table[request.dir_table.size()-2];
if( request.method != Request::post )
{
// used in GET (HEAD in the future?)
if( !request.HasWriteAccess(*last) &&
(!last_but_one || !request.HasWriteAccess(*last_but_one)) )
return false;
}
else
{
// used in POST when the moving is performed
if( request.IsPostVar("onlycontent") )
return request.HasWriteAccess(*last);
else
if( last_but_one )
return request.HasWriteAccess(*last_but_one);
else
return false; // you cannot move the root directory
}
return true;
}
bool Content::MoveCheckAccessFrom()
{
if( request.is_item )
{
// moving a file
if( !request.HasWriteAccess(*request.dir_table.back()) )
{
request.status = WINIX_ERR_PERMISSION_DENIED;
return false;
}
}
else
{
if( !MoveCheckAccessFromToDir() )
{
request.status = WINIX_ERR_PERMISSION_DENIED;
return false;
}
}
return true;
}
bool Content::MoveCheckAccessTo(long dir_id)
{
Item * pdir = data.dirs.GetDir(dir_id);
if( !pdir )
{
request.status = WINIX_ERR_INCORRECT_DIR;
return false;
}
if( !request.HasReadExecAccessToPath(dir_id) || !request.HasWriteAccess(*pdir) )
{
request.status = WINIX_ERR_PERMISSION_DENIED;
return false;
}
return true;
}
bool Content::MoveCheckMountPoints(long dir_id)
{
/*
Mount * new_mount = data.mounts.CalcMount(dir_id);
if( !new_mount )
{
if( data.mounts.pmount->type != Mount::cms )
{
request.status = WINIX_DIFFERENT_MOUNT_POINTS;
return false;
}
return true;
}
if( new_mount->type != data.mounts.pmount->type )
{
request.status = WINIX_DIFFERENT_MOUNT_POINTS;
return false;
}
*/
return true;
}
bool Content::MoveParseDir(long & dir_id, std::string & dir, std::string & file)
{
std::string * move_to = request.PostVar("to");
if( !move_to )
{
request.status = WINIX_ERR_PERMISSION_DENIED;
return false;
}
int res = data.dirs.AnalyzePath(*move_to, dir_id, dir, file);
if( res == 1 )
request.status = WINIX_ERR_NO_ROOT_DIR;
else
if( res != 0 )
request.status = WINIX_ERR_INCORRECT_DIR;
return res == 0;
}
void Content::MoveAuth(Item & item)
{
if( !request.MakePath(item, mv_new_path, true) )
{
request.status = WINIX_ERR_PERMISSION_DENIED;
return;
}
if( rename(item.auth_path.c_str(), mv_new_path.c_str()) == 0 )
{
log << log1 << "Content: moved static file from: " << item.auth_path << ", to: " << mv_new_path << logend;
item.auth_path = mv_new_path;
request.status = db.EditAuthById(item, item.id);
}
else
{
int err = errno;
log << log1 << "Content: can't move a file from: " << item.auth_path << ", to: " << mv_new_path << ", ";
log.SystemErr(err);
log << logend;
request.status = WINIX_ERR_PERMISSION_DENIED;
}
}
bool Content::MoveIsTheSameFile(const Item & item)
{
if( mv_file.empty() )
{
if( item.parent_id == mv_dir_id )
return true; // nothing to do
}
else
{
if( item.parent_id == mv_dir_id && item.url == mv_file )
return true; // nothing to do
}
return false;
}
void Content::MoveFile(Item & item, bool redirect)
{
if( MoveIsTheSameFile(item) )
return;
if( !mv_file.empty() )
{
item.url = mv_file;
PrepareUrl(item);
}
item.parent_id = mv_dir_id;
request.status = db.EditParentUrlById(item, item.id);
if( request.status == WINIX_ERR_OK )
{
log << log2 << "Content: the file was moved to: " << mv_dir << item.url << logend;
if( item.auth != Item::auth_none )
MoveAuth(item);
if( redirect )
RedirectTo(item);
}
}
void Content::MoveContentOfDir()
{
Db::ItemQuery iq;
iq.sel_parent_id = true;
iq.sel_type = true;
iq.sel_url = true;
iq.sel_auth = true;
iq.WhereParentId(request.dir_table.back()->id);
db.GetItems(request.item_table, iq);
for(size_t i=0 ; i<request.item_table.size() ; ++i)
{
if( request.item_table[i].type == Item::dir )
MoveDir(request.item_table[i], false);
else
MoveFile(request.item_table[i], false);
}
RedirectToLastDir();
}
void Content::MoveAuthPrepareQuery()
{
mv_auth_iq.SetAll(false, false);
mv_auth_iq.sel_parent_id = true;
mv_auth_iq.sel_type = true;
mv_auth_iq.sel_url = true;
mv_auth_iq.sel_auth = true;
mv_auth_iq.WhereType(Item::file);
mv_auth_iq.WhereAuth(Item::auth_none, false);
}
void Content::MoveAuthContentOfDir(const Item & item)
{
DirContainer::ParentIterator i = data.dirs.FindFirstParent(item.id);
// go through all directories
for( ; i != data.dirs.ParentEnd() ; i = data.dirs.NextParent(i) )
MoveAuthContentOfDir(*(i->second));
mv_auth_iq.WhereParentId(item.id);
// don't use request.item here (is used in MoveContentOfDir())
db.GetItems(mv_auth, mv_auth_iq);
for(size_t i=0 ; i<mv_auth.size() ; ++i)
MoveAuth(mv_auth[i]);
mv_auth.clear();
}
void Content::MoveDir(Item & item, bool redirect)
{
if( mv_file.empty() && mv_dir_id == item.id )
return; // nothing to do
if( mv_dir_id == item.id || data.dirs.HasParent(mv_dir_id, item.id) )
{
log << log1 << "Content: cannot move directory to inside it" << logend;
request.status = WINIX_ERR_INCORRECT_DIR;
return;
}
if( !data.dirs.ChangeParent(item.id, mv_dir_id) )
{
request.status = WINIX_ERR_INCORRECT_DIR;
return;
}
item.parent_id = mv_dir_id;
if( !mv_file.empty() )
{
item.url = mv_file;
PrepareUrl(item);
}
request.status = db.EditParentUrlById(item, item.id);
if( request.status == WINIX_ERR_OK )
{
log << log2 << "Content: the directory was moved to: " << mv_dir << item.url << logend;
MoveAuthContentOfDir(item);
if( redirect )
RedirectToLastDir();
}
}
void Content::PostFunMv()
{
if( MoveCheckAccessFrom() &&
MoveParseDir(mv_dir_id, mv_dir, mv_file) &&
MoveCheckAccessTo(mv_dir_id) &&
MoveCheckMountPoints(mv_dir_id) )
{
if( request.is_item )
{
MoveFile(request.item);
}
else
{
MoveAuthPrepareQuery();
if( request.IsPostVar("onlycontent") )
{
if( mv_file.empty() )
MoveContentOfDir();
else
request.status = WINIX_ERR_INCORRECT_DIR;
}
else
{
MoveDir(*request.dir_table.back());
}
}
}
}
void Content::FunMv()
{
MoveCheckAccessFrom();
}

View File

@@ -1,30 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2008-2010, Tomasz Sowa
* All rights reserved.
*
*/
#include "content.h"
#include "../core/request.h"
void Content::FunNode()
{
if( request.param_table.empty() )
{
//request.status = Error
//!!zglosic 404
return;
}
long id = atol( request.param_table[0]->c_str() );
RedirectTo(id);
}

View File

@@ -1,311 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2008-2010, Tomasz Sowa
* All rights reserved.
*
*/
#include "content.h"
#include "../core/request.h"
#include "../core/error.h"
#include "../core/db.h"
#include "../core/data.h"
bool Content::PrivCheckAccess()
{
// we do not check permissions here
// permissions depends on the user, group, and privileges
// but we cannot use parameter 'r' on files
// and only logged users can change permissions
if( !request.session->puser || (request.is_item && request.IsParam("r")) )
{
request.status = WINIX_ERR_PERMISSION_DENIED;
return false;
}
return true;
}
bool Content::ChangeOwner(Item & item, long user_id, long group_id)
{
if( user_id!=item.user_id || group_id!=item.group_id )
{
if( !request.CanChangeUser(item, user_id) )
{
log << log3 << "Content: can't change the user" << logend;
return false;
}
if( !request.CanChangeGroup(item, group_id) )
{
log << log3 << "Content: can't change the group" << logend;
return false;
}
}
item.user_id = user_id;
item.group_id = group_id;
return true;
}
bool Content::ChangePrivileges(Item & item, int privileges)
{
if( privileges != item.privileges )
{
if( !request.CanChangePrivileges(item, privileges) )
{
log << log3 << "Content: can't change privileges" << logend;
return false;
}
}
item.privileges = privileges;
return true;
}
void Content::ChangePriv(Item & item, long user_id, long group_id, int privileges)
{
if( change_owner )
{
if( !ChangeOwner(item, user_id, group_id) )
return;
}
if( change_priv )
{
if( !ChangePrivileges(item, privileges) )
return;
}
request.status = db.EditPrivById(item, item.id);
}
void Content::PrivLogStart(const char * what, long user, long group, int priv)
{
log << log2 << what;
if( change_owner )
{
User * puser = data.users.GetUser(user);
Group * pgroup = data.groups.GetGroup(group);
log << "new user: ";
if( puser )
log << puser->name;
else
log << "id: " << user;
log << ", new group: ";
if( pgroup )
log << pgroup->name;
else
log << "id: " << group;
if( change_priv )
log << ", ";
}
if( change_priv )
{
char buf[30];
sprintf(buf, "0%o", priv);
log << "privileges: " << buf;
}
log << logend;
}
void Content::PrivLog(const char * what, long id, const std::string & url)
{
Item * root = 0;
if( id != -1 )
root = data.dirs.GetRootDir();
log << log3 << "Content: " << what;
if( root && root->id == id )
log << "(root)";
else
log << url;
log << logend;
}
void Content::PrivFilesInDir(long parent_id)
{
Db::ItemQuery iq;
iq.SetAll(false, false);
iq.sel_user_id = iq.sel_group_id = iq.sel_guest_name = iq.sel_privileges = true;
iq.WhereParentId(parent_id);
iq.WhereType(Item::file);
db.GetItems(request.item_table, iq);
std::vector<Item>::iterator i = request.item_table.begin();
for( ; i != request.item_table.end() ; ++i)
{
PrivLog("changed file: ", -1, i->url);
ChangePriv(*i, user_id_file, group_id_file, priv_file);
}
}
// recurrence
void Content::PrivDir(long parent_id)
{
PrivFilesInDir(parent_id);
DirContainer::ParentIterator i = data.dirs.FindFirstParent(parent_id);
for( ; i != data.dirs.ParentEnd() ; i = data.dirs.NextParent(i) )
{
PrivLog("changed dir: ", -1, i->second->url);
ChangePriv(*(i->second), user_id_dir, group_id_dir, priv_dir);
if( subdirectories )
PrivDir(i->second->id);
}
}
bool Content::ReadPriv(const char * user_in, const char * group_in, const char * priv_in,
long & user_id, long & group_id, int & priv)
{
std::string * user_str = request.PostVar(user_in);
std::string * group_str = request.PostVar(group_in);
std::string * priv_str = request.PostVar(priv_in);
if( change_owner && (!user_str || !group_str) )
{
log << log1 << "Content: PostFunPriv: there is no some post variables for changing the owner" << logend;
return false;
}
if( change_priv && !priv_str )
{
log << log1 << "Content: PostFunPriv: there is no some post variables for changing privileges" << logend;
return false;
}
if( change_owner )
{
user_id = data.users.GetUserId( *user_str );
group_id = data.groups.GetGroupId( *group_str );
}
if( change_priv )
priv = strtol( priv_str->c_str() , 0, 8);
return true;
}
void Content::PrivDir()
{
if( !ReadPriv("userfile", "groupfile", "privilegesfile", user_id_file, group_id_file, priv_file) )
return;
if( !ReadPriv("userdir", "groupdir", "privilegesdir", user_id_dir, group_id_dir, priv_dir) )
return;
PrivLogStart("Content: changes for files: ", user_id_file, group_id_file, priv_file);
PrivLogStart("Content: changes for dirs: ", user_id_dir, group_id_dir, priv_dir);
if( request.IsPostVar("changecurrentdir") )
{
Item & last_dir = *request.dir_table.back();
PrivLog("changed dir: ", last_dir.id, last_dir.url);
ChangePriv(*request.dir_table.back(), user_id_dir, group_id_dir, priv_dir);
}
subdirectories = request.IsPostVar("changesubdirs");
// go through all directories
PrivDir(request.dir_table.back()->id);
RedirectToLastDir();
}
// changing only one item (either a dir or file)
void Content::PrivOneItem()
{
if( !ReadPriv("user", "group", "privileges", user_id_file, group_id_file, priv_file) )
return;
PrivLogStart("Content: changes: ", user_id_file, group_id_file, priv_file);
if( request.is_item )
{
ChangePriv(request.item, user_id_file, group_id_file, priv_file);
RedirectTo(request.item);
}
else
{
ChangePriv(*request.dir_table.back(), user_id_file, group_id_file, priv_file);
RedirectToLastDir();
}
}
void Content::PostFunPriv()
{
if( !PrivCheckAccess() )
return;
change_owner = (request.pfunction->code == FUN_PRIV || request.pfunction->code == FUN_CHOWN);
change_priv = (request.pfunction->code == FUN_PRIV || request.pfunction->code == FUN_CHMOD);
if( request.IsParam("r") )
{
PrivDir();
}
else
{
PrivOneItem();
}
data.dirs.CheckRootDir();
}
void Content::FunPriv()
{
PrivCheckAccess();
}

View File

@@ -1,45 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2008-2010, Tomasz Sowa
* All rights reserved.
*
*/
#include "content.h"
#include "../core/request.h"
#include "../core/error.h"
#include "../core/notify.h"
void Content::FunReloadTemplates()
{
log << log1 << "Content: reloading html templates" << logend;
templates.ReadTemplates();
notify.ReadTemplates(); // make sure that ReadTemplates() is using some kind of locking
}
void Content::FunReload()
{
// !! temporarily only an admin has access
if( !request.session->puser || !request.session->puser->super_user )
{
log << log1 << "Content: Only an admin has access to reload function" << logend;
request.status = WINIX_ERR_PERMISSION_DENIED;
return;
}
if( request.IsParam("templates") )
FunReloadTemplates();
}

View File

@@ -1,204 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2008-2010, Tomasz Sowa
* All rights reserved.
*
*/
#include <cstdio>
#include <errno.h>
#include "content.h"
#include "../core/request.h"
#include "../core/error.h"
#include "../core/data.h"
bool Content::RemoveCheckAccess()
{
if( !request.is_item )
{
if( !request.CanRemove(*request.dir_table.back()) )
{
request.status = WINIX_ERR_PERMISSION_DENIED;
return false;
}
}
else
if( !request.CanRemove(request.item) )
{
request.status = WINIX_ERR_PERMISSION_DENIED;
return false;
}
return true;
}
void Content::RemoveAuthPrepareQuery()
{
rm_auth_iq.SetAll(true, false);
rm_auth_iq.sel_parent_id = true;
rm_auth_iq.sel_type = true;
rm_auth_iq.sel_auth = true;
rm_auth_iq.WhereType(Item::file);
rm_auth_iq.WhereAuth(Item::auth_none, false);
}
void Content::RemoveAllDirs(long dir_id)
{
DirContainer::ParentIterator pnext, p = data.dirs.FindFirstParent(dir_id);
for( ; p != data.dirs.ParentEnd() ; p = pnext )
{
// this iterator p will be deleted by the next DeleteDir(p->second->id)
// (the next iterator we must calculate beforehand)
pnext = data.dirs.NextParent(p);
RemoveAllDirs(p->second->id);
}
rm_auth_iq.WhereParentId(dir_id);
db.GetItems(request.item_table, rm_auth_iq);
for(size_t i=0 ; i<request.item_table.size() ; ++i)
RemoveAuth(request.item_table[i]);
if( db.DelDirById(dir_id) == WINIX_ERR_OK )
{
data.dirs.DelDir(dir_id);
db.RemoveThread(dir_id);
db.RemoveTicket(dir_id);
}
}
void Content::RemoveAllDirs()
{
RemoveAuthPrepareQuery();
// this method deletes recursively all directories
RemoveAllDirs(request.dir_table.back()->id);
request.dir_table.erase(--request.dir_table.end());
if( request.dir_table.empty() )
{
// we have deleted the root directory
data.dirs.CheckRootDir(); // adding a new root dir
Item * proot = data.dirs.GetRootDir();
if( proot )
request.dir_table.push_back(proot);
else
// there is no a root dir
// CheckRootDir() didn't add the root dir (probably problem with the database)
// make sure that Content::Make() will check that the dir_table is empty and returns
return;
}
RedirectToLastDir();
}
void Content::RemoveDir()
{
if( request.param_table.empty() )
request.status = WINIX_ERR_PERMISSION_DENIED; // use parameter "r" for removing a directory
else
if( request.IsParam("r") )
RemoveAllDirs();
else
request.status = WINIX_ERR_UNKNOWN_PARAM;
}
void Content::RemoveAuth(Item & item)
{
if( item.auth_path.empty() )
{
log << log1 << "Content: can't remove a static file: auth_path is empty" << logend;
return;
}
if( remove(item.auth_path.c_str()) == 0 )
{
log << log1 << "Content: removed static file: " << item.auth_path << logend;
item.auth_path.clear();
item.auth = Item::auth_none;
// we don't store it to db (will be removed or is removed already)
}
else
{
int err = errno;
log << log1 << "Content: can't remove a file: " << item.auth_path;
log.SystemErr(err);
log << logend;
request.status = WINIX_ERR_PERMISSION_DENIED;
}
}
void Content::RemoveFile()
{
// for safety we check if param_table is empty
// a user can use "confirm" but can make a mistake when typing
if( !request.param_table.empty() )
{
request.status = WINIX_ERR_UNKNOWN_PARAM;
return;
}
if( db.DelItem( request.item ) )
{
log << log2 << "Content: deleted item: subject: " << request.item.subject << ", id: " << request.item.id << logend;
TemplatesFunctions::pattern_cacher.DeletePattern(request.item);
if( data.mounts.pmount->type == Mount::thread )
db.EditThreadRemoveItem(request.item.parent_id);
else
if( data.mounts.pmount->type == Mount::ticket )
db.EditTicketRemoveItem(request.item.id);
if( request.item.auth != Item::auth_none )
RemoveAuth(request.item);
}
else
{
request.status = WINIX_ERR_NO_ITEM;
}
RedirectToLastDir();
}
void Content::FunRm()
{
if( !RemoveCheckAccess() )
return;
if( request.IsParam("confirm") )
return; // show confirmation dialog
if( request.is_item )
RemoveFile();
else
RemoveDir();
}

View File

@@ -1,38 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2008-2010, Tomasz Sowa
* All rights reserved.
*
*/
#include "content.h"
#include "../core/request.h"
#include "../core/error.h"
void Content::FunRun()
{
if( !request.is_item )
{
log << log1 << "Content: Run function requires an item" << logend;
request.status = WINIX_ERR_NO_ITEM;
return;
}
if( !request.HasReadExecAccess(request.item) )
{
request.status = WINIX_ERR_PERMISSION_DENIED;
return;
}
}
void Content::PostFunRun()
{
FunRun();
}

View File

@@ -1,81 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2008-2010, Tomasz Sowa
* All rights reserved.
*
*/
#include "content.h"
#include "../core/request.h"
#include "../core/db.h"
#include "../core/log.h"
bool Content::SubjectCheckAccess()
{
// super user can always
if( request.session->puser && request.session->puser->super_user )
return true;
bool access;
if( request.is_item )
access = request.HasWriteAccess(request.item);
else
access = request.HasWriteAccess(*request.dir_table.back());
if( !access )
request.status = WINIX_ERR_PERMISSION_DENIED;
return access;
}
void Content::EditDirSubject()
{
Item & dir = *request.dir_table.back();
request.PostVar("subject", dir.subject);
db.EditSubjectById(dir, dir.id);
RedirectToLastDir();
}
void Content::EditFileSubject()
{
request.PostVar("subject", request.item.subject);
db.EditSubjectById(request.item, request.item.id);
RedirectTo(request.item);
}
void Content::PostFunSubject()
{
if( !SubjectCheckAccess() )
return;
if( request.is_item )
EditFileSubject();
else
EditDirSubject();
}
void Content::FunSubject()
{
SubjectCheckAccess();
}

View File

@@ -1,61 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2008-2010, Tomasz Sowa
* All rights reserved.
*
*/
#include "content.h"
#include "../core/request.h"
#include "../core/db.h"
#include "../core/data.h"
#include "../core/mount.h"
#include <algorithm>
bool Content::FunThreadSort(const Thread & t1, const Thread & t2)
{
Item * pdir1 = data.dirs.GetDir(t1.dir_id);
Item * pdir2 = data.dirs.GetDir(t2.dir_id);
if( !pdir1 || !pdir2 )
return false;
time_t time1 = mktime(&pdir1->date_creation);
time_t time2 = mktime(&pdir2->date_creation);
return time1 > time2;
}
void Content::FunThread()
{
if( request.is_item )
{
request.status = WINIX_ERR_PERMISSION_DENIED;
return;
}
Db::ItemQuery iq;
if( data.mounts.pmount->IsArg(Mount::par_thread, "sort_desc") )
iq.sort_asc = false;
iq.WhereParentId(request.dir_table.back()->id);
iq.WhereType(Item::file);
iq.WhereAuth(Item::auth_none);
db.GetItems(request.item_table, iq);
db.GetThreads(request.dir_table.back()->id, request.thread_tab);
CheckAccessToItems();
std::sort(request.thread_tab.begin(), request.thread_tab.end(), FunThreadSort);
}

View File

@@ -1,68 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2008-2010, Tomasz Sowa
* All rights reserved.
*
*/
#include "content.h"
#include "../core/request.h"
#include "../core/db.h"
#include "../core/data.h"
#include "../core/mount.h"
void Content::TicketDeleteFirst()
{
if( !request.is_ticket )
return;
for(size_t i=0 ; i<request.item_table.size() ; ++i)
{
if( request.item_table[i].id == request.ticket.item_id )
{
// this is the first item with the content for the ticket
if( !request.HasReadAccess(request.item_table[i]) )
{
request.status = WINIX_ERR_PERMISSION_DENIED;
}
request.item_table.erase(request.item_table.begin() + i);
break;
}
}
}
void Content::FunTicket()
{
if( request.is_item || data.mounts.pmount->type != Mount::ticket )
{
request.status = WINIX_ERR_PERMISSION_DENIED;
return;
}
Db::ItemQuery iq;
iq.WhereParentId(request.dir_table.back()->id);
iq.WhereType(Item::file);
iq.WhereAuth(Item::auth_none);
db.GetItems(request.item_table, iq);
db.GetTickets(request.dir_table.back()->id, request.ticket_tab);
TicketDeleteFirst();
CheckAccessToItems();
}

View File

@@ -1,18 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2008-2010, Tomasz Sowa
* All rights reserved.
*
*/
#include "content.h"
void Content::FunUname()
{
}

View File

@@ -1,199 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2008-2010, Tomasz Sowa
* All rights reserved.
*
*/
#include <sys/types.h>
#include <sys/stat.h>
#include <cstdio>
#include <errno.h>
#include "content.h"
#include "../core/request.h"
#include "../core/data.h"
#include "../core/misc.h"
bool Content::FunUploadCheckAccess()
{
if( request.is_item || !request.CanUseUpload(*request.dir_table.back()) )
{
request.status = WINIX_ERR_PERMISSION_DENIED;
return false;
}
return true;
}
bool Content::UploadCreatePath()
{
if( !request.MakePath(request.item, true) )
{
request.status = WINIX_ERR_PERMISSION_DENIED;
return false;
}
return true;
}
void Content::UploadSaveFile(const std::string & tmp_filename, const std::string & destination)
{
if( rename(tmp_filename.c_str(), destination.c_str()) == 0 )
{
log << log1 << "Content: uploaded a new file: " << destination << logend;
}
else
{
int err = errno;
// !! skasowac takze plik z bazy danych?
log << log1 << "Content: can't move the tmp file from: " << tmp_filename << ", to: " << destination << ", ";
log.SystemErr(err);
log << logend;
request.status = WINIX_ERR_PERMISSION_DENIED;
}
}
bool Content::FunUploadCheckAbuse()
{
if( !CheckRebus() )
{
request.status = WINIX_ERR_INCORRECT_REBUS;
return false;
}
CheckGetPostTimes(4);
if( request.session->spam_score > 0 )
{
request.status = WINIX_ERR_SPAM;
log << log1 << "Content: ignoring due to suspected spamming" << logend;
return false;
}
return true;
}
void Content::UploadMulti()
{
request.item.Clear(); // clearing and setting date
request.item.parent_id = request.dir_table.back()->id;
request.item.type = Item::file;
request.item.privileges = 0644; // !! tymczasowo
SetUser(request.item);
PostFileTable::iterator i = request.post_file_table.begin();
for( ; i != request.post_file_table.end() ; ++i)
{
const char * file_name = i->second.filename.c_str();
request.item.subject = file_name;
request.item.url = file_name;
request.item.auth = SelectFileType(file_name);
PrepareUrl(request.item);
PostFunEmacsAdd(request.item); // always adding a new item
if( !UploadCreatePath() )
return;
if( request.status == WINIX_ERR_OK )
{
UploadSaveFile(i->second.tmp_filename, request.item.auth_path);
request.status = db.EditAuthById(request.item, request.item.id);
}
}
RedirectToLastDir();
}
void Content::UploadSingle()
{
std::string * new_subject = request.PostVar("subject");
std::string * new_url = request.PostVar("url");
bool has_subject = (new_subject && (*new_subject)[0] != 0 );
bool has_url = (new_url && (*new_url)[0] != 0 );
ReadItem(request.item, Item::file); // ReadItem() changes the url if it is empty
request.item.privileges = 0644; // !! tymczasowo
const char * file_name = request.post_file_table.begin()->second.filename.c_str();
request.item.auth = SelectFileType(file_name);
if( !has_subject )
request.item.subject = file_name;
if( !has_url )
{
request.item.url = file_name;
PrepareUrl(request.item);
}
PostFunEmacsAdd(request.item); // always adding a new item
// url can be changed by PostFunEmacsAdd()
if( !UploadCreatePath() )
return;
if( request.status == WINIX_ERR_OK )
{
const std::string & tmp_filename = request.post_file_table.begin()->second.tmp_filename;
UploadSaveFile(tmp_filename, request.item.auth_path);
request.status = db.EditAuthById(request.item, request.item.id);
}
if( request.status == WINIX_ERR_OK )
RedirectTo(request.item, "/cat");
}
// !! dodac usuwanie plikow statycznych przez rm
void Content::PostFunUpload()
{
if( !FunUploadCheckAccess() )
return;
if( request.post_file_table.empty() )
{
request.status = WINIX_ERR_PERMISSION_DENIED;
return;
}
if( !FunUploadCheckAbuse() )
return;
if( request.post_file_table.size() > 1 )
UploadMulti();
else
UploadSingle();
}
void Content::FunUpload()
{
FunUploadCheckAccess();
}

View File

@@ -1,24 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2008-2010, Tomasz Sowa
* All rights reserved.
*
*/
#include "content.h"
void Content::FunWho()
{
}

View File

@@ -1,22 +0,0 @@
include Makefile.o.dep
all: $(o)
.SUFFIXES: .cpp .o
.cpp.o:
$(CXX) -c $(CXXFLAGS) $<
depend:
makedepend -Y. -f- *.cpp > Makefile.dep
echo -n "o = " > Makefile.o.dep
ls -1 *.cpp | xargs -I foo echo -n foo " " | sed -E "s/([^\.]*)\.cpp[ ]/\1\.o/g" >> Makefile.o.dep
clean:
rm -f *.o
include Makefile.dep

View File

@@ -1,126 +0,0 @@
# DO NOT DELETE
acceptbaseparser.o: acceptbaseparser.h
compress.o: compress.h log.h
config.o: config.h ../confparser/confparser.h log.h data.h dirs.h item.h
config.o: dircontainer.h users.h user.h ugcontainer.h groups.h group.h
config.o: functions.h function.h lastcontainer.h mounts.h mount.h error.h
config.o: rebus.h loadavg.h plugin.h request.h requesttypes.h session.h
config.o: plugindata.h thread.h compress.h acceptencodingparser.h
config.o: acceptbaseparser.h htmlfilter.h postmultiparser.h ticket.h
config.o: pluginmsg.h misc.h
data.o: data.h dirs.h item.h dircontainer.h users.h user.h ugcontainer.h
data.o: log.h groups.h group.h functions.h function.h lastcontainer.h
data.o: mounts.h mount.h error.h rebus.h loadavg.h
db.o: db.h item.h user.h group.h thread.h error.h log.h dircontainer.h
db.o: ugcontainer.h ticket.h misc.h
db_itemcolumns.o: db.h item.h user.h group.h thread.h error.h log.h
db_itemcolumns.o: dircontainer.h ugcontainer.h ticket.h
dircontainer.o: dircontainer.h item.h log.h
dirs.o: dirs.h item.h dircontainer.h error.h log.h db.h user.h group.h
dirs.o: thread.h ugcontainer.h ticket.h data.h users.h groups.h functions.h
dirs.o: function.h lastcontainer.h mounts.h mount.h rebus.h loadavg.h
dirs.o: request.h requesttypes.h session.h plugindata.h compress.h
dirs.o: acceptencodingparser.h acceptbaseparser.h htmlfilter.h
dirs.o: postmultiparser.h
function.o: function.h item.h
functioncodeparser.o: functioncodeparser.h item.h function.h log.h
functionparser.o: functionparser.h requesttypes.h log.h item.h error.h data.h
functionparser.o: dirs.h dircontainer.h users.h user.h ugcontainer.h groups.h
functionparser.o: group.h functions.h function.h lastcontainer.h mounts.h
functionparser.o: mount.h rebus.h loadavg.h db.h thread.h ticket.h request.h
functionparser.o: session.h plugindata.h compress.h acceptencodingparser.h
functionparser.o: acceptbaseparser.h htmlfilter.h postmultiparser.h
functions.o: functions.h function.h item.h
groups.o: groups.h group.h ugcontainer.h log.h db.h item.h user.h thread.h
groups.o: error.h dircontainer.h ticket.h
htmlfilter.o: htmlfilter.h
httpsimpleparser.o: httpsimpleparser.h
lastcontainer.o: lastcontainer.h log.h
loadavg.o: loadavg.h log.h
locale.o: locale.h ../confparser/confparser.h log.h
log.o: log.h
misc.o: misc.h item.h log.h data.h dirs.h dircontainer.h users.h user.h
misc.o: ugcontainer.h groups.h group.h functions.h function.h lastcontainer.h
misc.o: mounts.h mount.h error.h rebus.h loadavg.h
mount.o: mount.h
mountparser.o: mountparser.h mount.h item.h error.h log.h data.h dirs.h
mountparser.o: dircontainer.h users.h user.h ugcontainer.h groups.h group.h
mountparser.o: functions.h function.h lastcontainer.h mounts.h rebus.h
mountparser.o: loadavg.h misc.h
mounts.o: mounts.h mount.h error.h log.h data.h dirs.h item.h dircontainer.h
mounts.o: users.h user.h ugcontainer.h groups.h group.h functions.h
mounts.o: function.h lastcontainer.h rebus.h loadavg.h request.h
mounts.o: requesttypes.h session.h plugindata.h thread.h compress.h
mounts.o: acceptencodingparser.h acceptbaseparser.h htmlfilter.h
mounts.o: postmultiparser.h ticket.h mountparser.h db.h
notify.o: log.h notify.h ../templatesnotify/templatesnotify.h ../core/mount.h
notify.o: ../core/locale.h ../confparser/confparser.h ../templates/misc.h
notify.o: ../templates/localefilter.h data.h dirs.h item.h dircontainer.h
notify.o: users.h user.h ugcontainer.h groups.h group.h functions.h
notify.o: function.h lastcontainer.h mounts.h mount.h error.h rebus.h
notify.o: loadavg.h misc.h request.h requesttypes.h session.h plugindata.h
notify.o: thread.h compress.h acceptencodingparser.h acceptbaseparser.h
notify.o: htmlfilter.h postmultiparser.h ticket.h
plugin.o: plugin.h request.h requesttypes.h session.h item.h error.h log.h
plugin.o: user.h rebus.h plugindata.h function.h thread.h compress.h
plugin.o: acceptencodingparser.h acceptbaseparser.h htmlfilter.h
plugin.o: postmultiparser.h ticket.h data.h dirs.h dircontainer.h users.h
plugin.o: ugcontainer.h groups.h group.h functions.h lastcontainer.h mounts.h
plugin.o: mount.h loadavg.h pluginmsg.h
plugindata.o: plugindata.h plugin.h request.h requesttypes.h session.h item.h
plugindata.o: error.h log.h user.h rebus.h function.h thread.h compress.h
plugindata.o: acceptencodingparser.h acceptbaseparser.h htmlfilter.h
plugindata.o: postmultiparser.h ticket.h data.h dirs.h dircontainer.h users.h
plugindata.o: ugcontainer.h groups.h group.h functions.h lastcontainer.h
plugindata.o: mounts.h mount.h loadavg.h pluginmsg.h
postmultiparser.o: postmultiparser.h error.h log.h requesttypes.h data.h
postmultiparser.o: dirs.h item.h dircontainer.h users.h user.h ugcontainer.h
postmultiparser.o: groups.h group.h functions.h function.h lastcontainer.h
postmultiparser.o: mounts.h mount.h rebus.h loadavg.h
rebus.o: log.h rebus.h misc.h item.h
request.o: request.h requesttypes.h session.h item.h error.h log.h user.h
request.o: rebus.h plugindata.h function.h thread.h compress.h
request.o: acceptencodingparser.h acceptbaseparser.h htmlfilter.h
request.o: postmultiparser.h ticket.h getparser.h httpsimpleparser.h
request.o: postparser.h cookieparser.h data.h dirs.h dircontainer.h users.h
request.o: ugcontainer.h groups.h group.h functions.h lastcontainer.h
request.o: mounts.h mount.h loadavg.h plugin.h pluginmsg.h misc.h db.h
requestcontroller.o: requestcontroller.h ../content/content.h ../core/item.h
requestcontroller.o: ../templates/templates.h ../templates/patterncacher.h
requestcontroller.o: misc.h item.h ../templates/ckeditorgetparser.h
requestcontroller.o: ../core/httpsimpleparser.h ../core/log.h
requestcontroller.o: ../core/locale.h ../confparser/confparser.h
requestcontroller.o: ../templates/indexpatterns.h ../templates/localefilter.h
requestcontroller.o: ../core/thread.h ../core/ticket.h ../core/db.h user.h
requestcontroller.o: group.h thread.h error.h log.h dircontainer.h
requestcontroller.o: ugcontainer.h ticket.h sessionmanager.h
requestcontroller.o: sessioncontainer.h session.h rebus.h plugindata.h
requestcontroller.o: functionparser.h requesttypes.h data.h dirs.h users.h
requestcontroller.o: groups.h functions.h function.h lastcontainer.h mounts.h
requestcontroller.o: mount.h loadavg.h request.h compress.h
requestcontroller.o: acceptencodingparser.h acceptbaseparser.h htmlfilter.h
requestcontroller.o: postmultiparser.h postparser.h httpsimpleparser.h
requestcontroller.o: cookieparser.h notify.h
requestcontroller.o: ../templatesnotify/templatesnotify.h ../core/mount.h
requestcontroller.o: ../templates/misc.h
session.o: session.h item.h error.h log.h user.h rebus.h plugindata.h
sessioncontainer.o: sessioncontainer.h session.h item.h error.h log.h user.h
sessioncontainer.o: rebus.h plugindata.h data.h dirs.h dircontainer.h users.h
sessioncontainer.o: ugcontainer.h groups.h group.h functions.h function.h
sessioncontainer.o: lastcontainer.h mounts.h mount.h loadavg.h
sessionmanager.o: sessionmanager.h sessioncontainer.h session.h item.h
sessionmanager.o: error.h log.h user.h rebus.h plugindata.h request.h
sessionmanager.o: requesttypes.h function.h thread.h compress.h
sessionmanager.o: acceptencodingparser.h acceptbaseparser.h htmlfilter.h
sessionmanager.o: postmultiparser.h ticket.h data.h dirs.h dircontainer.h
sessionmanager.o: users.h ugcontainer.h groups.h group.h functions.h
sessionmanager.o: lastcontainer.h mounts.h mount.h loadavg.h sessionparser.h
sessionmanager.o: plugin.h pluginmsg.h
sessionparser.o: sessionparser.h session.h item.h error.h log.h user.h
sessionparser.o: rebus.h plugindata.h sessioncontainer.h data.h dirs.h
sessionparser.o: dircontainer.h users.h ugcontainer.h groups.h group.h
sessionparser.o: functions.h function.h lastcontainer.h mounts.h mount.h
sessionparser.o: loadavg.h
users.o: users.h user.h ugcontainer.h log.h db.h item.h group.h thread.h
users.o: error.h dircontainer.h ticket.h

View File

@@ -1 +0,0 @@
o = acceptbaseparser.o compress.o config.o data.o db.o db_itemcolumns.o dircontainer.o dirs.o function.o functioncodeparser.o functionparser.o functions.o groups.o htmlfilter.o httpsimpleparser.o lastcontainer.o loadavg.o locale.o log.o misc.o mount.o mountparser.o mounts.o notify.o plugin.o plugindata.o postmultiparser.o rebus.o request.o requestcontroller.o session.o sessioncontainer.o sessionmanager.o sessionparser.o users.o

View File

@@ -1,113 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2008-2010, Tomasz Sowa
* All rights reserved.
*
*/
#include "acceptbaseparser.h"
bool AcceptBaseParser::IsWhite(int c)
{
if( c==' ' || c=='\t' )
return true;
return false;
}
void AcceptBaseParser::SkipWhite()
{
while( IsWhite(*text) )
++text;
}
void AcceptBaseParser::RemoveWhiteFromEnd(std::string & str)
{
if( str.empty() )
return;
size_t i = str.size() - 1;
for( ; i!=0 && IsWhite(str[i]) ; --i);
if( !IsWhite(str[i]) )
++i;
if( i < str.size() )
str.erase(i); // erasing until the end of the string
}
void AcceptBaseParser::ReadParameter()
{
param.clear();
SkipWhite();
while( *text!=0 && *text!=',' && *text!=';' )
{
param += *text;
++text;
}
RemoveWhiteFromEnd(param);
}
void AcceptBaseParser::ReadQ()
{
q = 1.0;
SkipWhite();
if( *text != ';' )
return;
++text; // skipping a semicolon
while( *text!=0 && *text!=',' && *text!='=' )
// skipping until ',' or '='
++text;
if( *text==0 || *text==',' )
return;
++text; // skipping '='
SkipWhite();
q = strtod(text, (char**)&text);
}
void AcceptBaseParser::SkipParam()
{
SkipWhite();
if( *text == ',' )
++text;
}
void AcceptBaseParser::Parse(const char * str)
{
text = str;
Init();
while( *text != 0 )
{
ReadParameter();
ReadQ();
SkipParam();
Param(param, q);
}
}

View File

@@ -1,47 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2008-2010, Tomasz Sowa
* All rights reserved.
*
*/
#ifndef headerfilecmslucoreacceptbaseparser
#define headerfilecmslucoreacceptbaseparser
#include <string>
// sample (you must create your own class derived from this one):
// object.Parse(" text/html ; , ; q = 45, application / xhtml+xml ; q = 0.4 , application/xml ; q = 0.9 , */* ; q = 0.8 ");
class AcceptBaseParser
{
public:
void Parse(const char * str);
private:
virtual void Init() {} ;
virtual void Param(const std::string & param, double q) = 0;
bool IsWhite(int c);
void SkipWhite();
void RemoveWhiteFromEnd(std::string & str);
void ReadParameter();
void ReadQ();
void SkipParam();
const char * text;
std::string param;
double q;
};
#endif

View File

@@ -1,49 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2008-2010, Tomasz Sowa
* All rights reserved.
*
*/
#ifndef headerfilecmslucoreacceptencodingparser
#define headerfilecmslucoreacceptencodingparser
#include "acceptbaseparser.h"
#include "log.h"
class AcceptEncodingParser : public AcceptBaseParser
{
public:
bool AcceptDeflate()
{
return accept_deflate;
}
private:
void Init()
{
accept_deflate = false;
}
void Param(const std::string & param, double q)
{
if( param=="deflate" && q!=0 )
{
accept_deflate = true;
log << log3 << "AEP: accept deflate" << logend;
}
}
bool accept_deflate;
};
#endif

View File

@@ -1,175 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2008-2010, Tomasz Sowa
* All rights reserved.
*
*/
#include "compress.h"
#include "log.h"
Compress::Compress()
{
buffer = 0;
buffer_max_len = 65536; // 64KB
ready_for_compress = false;
}
Compress::~Compress()
{
if( buffer )
delete [] buffer;
}
bool Compress::AllocateMemory()
{
if( buffer )
delete [] buffer;
try
{
buffer = new char[buffer_max_len];
}
catch(const std::bad_alloc &)
{
log << log1 << "Compress: can't allocate memory" << logend;
buffer = 0;
return false;
}
return true;
}
/*
return:
0 - ok;
1 - can't allocate memory
100 - unknown
*/
int Compress::Init(int compress_level)
{
if( buffer == 0 )
if( !AllocateMemory() )
return 1;
strm.zalloc = Z_NULL;
strm.zfree = Z_NULL;
strm.opaque = Z_NULL;
int ret = deflateInit(&strm, compress_level);
if( ret != Z_OK )
log << log1 << "Compress: problem with deflateInit()" << logend;
if( ret == Z_MEM_ERROR )
return 1;
if( ret != Z_OK )
return 100;
ready_for_compress = true;
return 0;
}
int Compress::MakeCompress(const char * source, size_t source_len, FCGX_Stream * out_stream)
{
int ret, flush;
size_t have;
do
{
strm.avail_in = (source_len > buffer_max_len) ? buffer_max_len : source_len;
source_len -= strm.avail_in;
flush = (source_len == 0) ? Z_FINISH : Z_NO_FLUSH;
strm.next_in = (Bytef*)source;
source += strm.avail_in;
do
{
strm.avail_out = buffer_max_len;
strm.next_out = (Bytef*)buffer;
ret = deflate(&strm, flush);
if( ret == Z_STREAM_ERROR || ret == Z_BUF_ERROR )
{
log << log1 << "Compress: problem with deflate()" << logend;
return 2;
}
have = buffer_max_len - strm.avail_out;
last_out_size += have;
FCGX_PutStr(buffer, have, out_stream);
}
while( strm.avail_out == 0 );
if( strm.avail_in != 0 )
{
log << log1 << "Compress: problem with deflate() - not all input is used" << logend;
return 2;
}
}
while( flush != Z_FINISH );
if( ret != Z_STREAM_END )
{
log << log1 << "Compress: problem with deflate() - stream not complete" << logend;
return 2;
}
return 0;
}
/*
return:
0 - ok;
1 - can't allocate memory
2 - error during compressing
3 - not inited (use Init() first)
100 - unknown
*/
int Compress::CompressAndPut(const char * source, size_t source_len, FCGX_Stream * out_stream, int level)
{
int ret;
last_out_size = 0;
if( !ready_for_compress )
{
log << log1 << "Compress: not ready yet" << logend;
return 3;
}
if( source_len == 0 )
return 0;
ret = MakeCompress(source, source_len, out_stream);
if( deflateReset(&strm) != Z_OK )
log << log1 << "Compress: problem with deflateReset()" << logend;
double ratio = 100.0 - (double(last_out_size) / double(source_len) * 100.0);
char buffer[30];
sprintf(buffer, "%.1f", ratio);
log << log2 << "Compress: original size: " << source_len << ", compress size: " << (int)last_out_size << ", ratio: " << buffer << "%" << logend;
return ret;
}

View File

@@ -1,43 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2008-2010, Tomasz Sowa
* All rights reserved.
*
*/
#ifndef headerfilecmslucorecompress
#define headerfilecmslucorecompress
#include <cstring>
#include <fcgiapp.h>
#include <zlib.h>
class Compress
{
public:
Compress();
~Compress();
int Init(int compress_level = 6);
int CompressAndPut(const char * source, size_t source_len, FCGX_Stream * out_stream, int level = 6);
size_t last_out_size;
private:
bool AllocateMemory();
int MakeCompress(const char * source, size_t source_len, FCGX_Stream * out_stream);
size_t buffer_max_len;
char * buffer;
z_stream strm;
bool ready_for_compress;
};
#endif

View File

@@ -1,285 +0,0 @@
/*
* 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 "data.h"
#include "plugin.h"
#include "misc.h"
Config::Config()
{
default_str.clear();
default_int = 0;
default_bool = false;
errors_to_stdout = true;
}
//!! czy tu w ogole mozemy uzywac log << ?
//!! przeciez jeszcze nie zostal przetworzony plik konfiguracyjny
void Config::ShowError()
{
switch( conf_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: " << data.config_file << std::endl;
log << log1 << "Config: cant open a config file: " << data.config_file << logend;
break;
case ConfParser::syntax_error:
if( errors_to_stdout )
std::cout << "Config: syntax error, line: " << conf_parser.line << std::endl;
log << log1 << "Config: syntax error, line: " << conf_parser.line << logend;
break;
}
}
bool Config::ReadConfig(bool errors_to_stdout_)
{
errors_to_stdout = errors_to_stdout_;
if( data.config_file.empty() )
{
log << log2 << "Config: name of the config file is empty" << logend;
return false;
}
log << log2 << "Config: reading a config file" << logend;
ConfParser::Status status = conf_parser.Parse( data.config_file.c_str() );
if( status == ConfParser::ok )
{
AssignValues();
data.SetAdditionalVariables();
return true;
}
else
{
ShowError();
return false;
}
}
void Config::AssignValues()
{
data.log_file = Text("log_file");
data.log_notify_file = Text("log_notify_file");
data.fcgi_socket = Text("fcgi_socket");
data.fcgi_socket_chmod = Int("fcgi_socket_chmod", 0770);
data.fcgi_socket_user = Text("fcgi_socket_user");
data.fcgi_socket_group = Text("fcgi_socket_group");
data.log_level = Int("log_level", 1);
data.log_request = Int("log_request", 1);
if( !data.stdout_is_closed )
data.log_stdout = Bool("log_stdout", false);
else
data.log_stdout = false;
data.post_file_max = Int("post_file_max", 8388608); // 8 MB
data.auth_simplefs_dir = Text("auth_simplefs_dir");
data.auth_hashfs_dir = Text("auth_hashfs_dir");
data.auth_tmp_dir = Text("auth_tmp_dir");
data.templates_dir = Text("templates_dir");
data.templates_dir_default = Text("templates_dir_default");
data.http_session_id_name = Text("http_session_id_name");
data.db_database = Text("db_database");
data.db_user = Text("db_user");
data.db_pass = Text("db_pass");
data.item_url_empty = Text("item_url_empty");
data.base_server = Text("base_server");
data.base_url = Text("base_url");
data.base_url_auth = Text("base_url_auth");
data.base_url_static = Text("base_url_static");
data.base_url_common = Text("base_url_common");
NoLastSlash(data.base_server);
NoLastSlash(data.base_url);
NoLastSlash(data.base_url_auth);
NoLastSlash(data.base_url_static);
NoLastSlash(data.base_url_common);
data.priv_no_user = Text("priv_no_user", "-- no user --");
data.priv_no_group = Text("priv_no_group", "-- no group --");
data.session_max_idle = Int("session_max_idle", 10800); // 3h
data.session_remember_max_idle = Int("session_remember_max_idle", 16070400); // 3 months
data.session_file = Text("session_file");
data.compression = Bool("compression", true);
std::string p = Text("plugin");
data.plugin_file.push_back(p);
data.html_filter = Bool("html_filter", true);
data.locale_str = Text("locale", "en");
data.locale_dir = Text("locale_dir");
data.locale_dir_default = Text("locale_dir_default");
data.title_separator = Text("title_separator", " / ");
}
std::string Config::Text(const char * name)
{
return Text(std::string(name), default_str);
}
std::string Config::Text(const char * name, const char * def)
{
return Text(std::string(name), std::string(def));
}
std::string Config::Text(const std::string & name, const std::string & def)
{
ConfParser::Table::iterator i = conf_parser.table.find(name);
if( i == conf_parser.table.end() )
return def;
return i->second;
}
int Config::Int(const char * name)
{
return Int(std::string(name), default_int);
}
int Config::Int(const char * name, int def)
{
return Int(std::string(name), def);
}
int Config::Int(const std::string & name, int def)
{
ConfParser::Table::iterator i = conf_parser.table.find(name);
if( i == conf_parser.table.end() || i->second.empty() )
return def;
long res = (i->second[0] == '0')? strtol(i->second.c_str() + 1, 0, 8) : strtol(i->second.c_str(), 0, 10);
return res;
}
bool Config::Bool(const char * name)
{
return Bool(std::string(name), default_bool);
}
bool Config::Bool(const char * name, bool def)
{
return Bool(std::string(name), def);
}
bool Config::Bool(const std::string & name, bool def)
{
ConfParser::Table::iterator i = conf_parser.table.find(name);
if( i == conf_parser.table.end() || i->second.empty() )
return def;
bool res = false;
if( EqualNoCase(i->second.c_str(), "true") ||
EqualNoCase(i->second.c_str(), "yes") ||
EqualNoCase(i->second.c_str(), "1")
)
res = true;
return res;
}
void Config::NoLastSlash(std::string & s)
{
if( s.empty() )
return;
size_t i = s.size();
for( ; i>0 && s[i-1]=='/' ; --i);
if( i < s.size() )
s.erase(i);
}
void Config::NoFirstHttp(std::string & s)
{
if( s.empty() )
return;
const char http[] = "http://";
const char https[] = "https://";
if( IsSubStringNoCase(http, s.c_str()) )
{
s.erase(0, sizeof(http)/sizeof(char));
}
else
if( IsSubStringNoCase(https, s.c_str()) )
{
s.erase(0, sizeof(https)/sizeof(char));
}
}

View File

@@ -1,60 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2008-2010, Tomasz Sowa
* All rights reserved.
*
*/
#ifndef headerfilecmslucoreconfig
#define headerfilecmslucoreconfig
#include <string>
#include "../confparser/confparser.h"
class Config
{
public:
Config();
bool ReadConfig(bool errors_to_stdout_);
private:
ConfParser conf_parser;
void ShowError();
void AssignValues();
std::string Text(const char * name);
std::string Text(const char * name, const char * def);
std::string Text(const std::string & name, const std::string & def);
int Int(const char *);
int Int(const char * name, int def);
int Int(const std::string & name, int def);
bool Bool(const char *);
bool Bool(const char * name, bool def);
bool Bool(const std::string & name, bool def);
std::string default_str;
int default_int;
bool default_bool;
bool errors_to_stdout;
void NoLastSlash(std::string & s);
void NoFirstHttp(std::string & s);
};
#endif

View File

@@ -1,73 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2008-2010, Tomasz Sowa
* All rights reserved.
*
*/
#ifndef headerfilecmslucorecookieparser
#define headerfilecmslucorecookieparser
#include <fcgiapp.h>
#include "httpsimpleparser.h"
#include "requesttypes.h"
#include "log.h"
class CookieParser : public HttpSimpleParser
{
const char * cookie_string;
CookieTable & cookie_table;
protected:
virtual int GetChar()
{
if( !cookie_string || *cookie_string == 0 )
return -1;
return (int)(unsigned char)*(cookie_string++);
}
virtual void Parameter(std::string & name, std::string & value)
{
// Cookie names are case insensitive according to section 3.1 of RFC 2965
ToLower(name);
std::pair<CookieTable::iterator, bool> res = cookie_table.insert( std::make_pair(name, value) );
log << log2 << "Cookie, name: \"" << name << "\", value: \"" << value << "\"";
if( res.second == false )
{
res.first->second = value;
log << " (overwritten)";
}
log << logend;
}
public:
CookieParser(const char * cookie_string_, CookieTable & cookie_table_) : cookie_string(cookie_string_), cookie_table(cookie_table_)
{
HttpSimpleParser::separator = ';';
HttpSimpleParser::value_can_be_quoted = true;
HttpSimpleParser::skip_white_chars = true;
HttpSimpleParser::recognize_special_chars = false;
}
};
#endif

View File

@@ -1,44 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2008-2010, Tomasz Sowa
* All rights reserved.
*
*/
#include "data.h"
Data::Data()
{
signal_hup = false;
stdout_is_closed = false;
how_many_logged = 0;
// the rest will be read from a config file
}
void Data::SetAdditionalVariables()
{
SetHttpHost(base_url, base_url_http_host);
SetHttpHost(base_url_auth, base_url_auth_http_host);
}
void Data::SetHttpHost(const std::string & in, std::string & out)
{
if( strncmp(in.c_str(), "http://", 7) == 0 )
out = in.substr(7);
else
if( strncmp(in.c_str(), "https://", 8) == 0 )
out = in.substr(8);
else
out.clear(); // if empty the RequestController::BaseUrlRedirect() returns false and no redirecting will be done
}

View File

@@ -1,213 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2008-2010, Tomasz Sowa
* All rights reserved.
*
*/
#ifndef headerfilecmslucoredata
#define headerfilecmslucoredata
#include <string>
#include <vector>
#include <map>
#include <string.h>
#include "dirs.h"
#include "users.h"
#include "groups.h"
#include "functions.h"
#include "lastcontainer.h"
#include "mounts.h"
#include "rebus.h"
#include "loadavg.h"
class Data
{
public:
// -----------------------------------------------------------------
// members read from a config file
// name of the config file (full path can be)
std::string config_file;
// log file name, log file name for notifications (sending emails, etc)
std::string log_file, log_notify_file;
// 1 - minimum
// 2 - (default)
// 3 - maximum - all logs
int log_level;
// logging to stdout too
bool log_stdout;
// how many requests should be logged in the same time
// default: 1
int log_request;
// fast cgi: socket (unix domain)
std::string fcgi_socket;
// fast cgi: socket permissions
int fcgi_socket_chmod;
// fast cgi: owner of the socket
std::string fcgi_socket_user;
// fast cgi: group of the socket
std::string fcgi_socket_group;
std::string templates_dir;
std::string templates_dir_default; // templates from winix
std::string db_database;
std::string db_user;
std::string db_pass;
std::string http_session_id_name;
// when the HOST_HTTP environment variable doesn't point into 'base_url' (the part 'http://' and the last slash is removed)
// the server will redirect into 'base_url' + 'REQUEST_URI'
// it's useful when you want to redirect from 'mydomain.tld' into 'www.mydomain.tld' etc.
bool base_url_redirect;
// string used in a place where is a user (or group) selected
std::string priv_no_user;
std::string priv_no_group;
// time in seconds when the user will be automatically logged out (iddle time)
int session_max_idle;
// time in seconds when the user will be automatically logged out (when he selected 'remember me' option)
// this time is usually greater than session_max_idle
int session_remember_max_idle;
// this file is used when the program is starting and ending
std::string session_file;
// allow the html ouput to be compressed
bool compression;
// plugins
std::vector<std::string> plugin_file;
// the html code is cleaned by our filter
bool html_filter;
// the url of a new empty item (if there is not the subject too)
std::string item_url_empty;
// maximum length of a file send by post multipart form
// 0 - not used
int post_file_max;
// directories for static files
std::string auth_simplefs_dir;
std::string auth_hashfs_dir;
// temporary directory for static content used by the upload function
// should be on the same partition as auth_simplefs_dir and auth_hashfs_dir
std::string auth_tmp_dir;
// default locale: en pl
std::string locale_str;
// directory with locale files
std::string locale_dir;
// directory with default locale files (those from winix)
std::string locale_dir_default;
// the main address of the server (e.g. someserver.com) (without the 'www' part etc)
std::string base_server;
// the main address of the site (e.g. http://www.someserver.com)
std::string base_url;
// static content authorized by winix
std::string base_url_auth;
// static content not authorized by winix
std::string base_url_static;
// additional static server for common content (not authorized)
std::string base_url_common;
// separator used in <title> html tag
std::string title_separator;
// end config members
// -----------------------------------------------------------------
// false at the beginning
bool stdout_is_closed;
// true if there was SIGHUP signal
volatile bool signal_hup;
// contains current directories tree
Dirs dirs;
// based on base_url
// set by SetAdditionalVariables()
// without the first part http:// (or https://) or the whole string is empty
std::string base_url_http_host;
std::string base_url_auth_http_host;
// call this method after the config file is read
void SetAdditionalVariables();
// users
Users users;
// groups
Groups groups;
// functions (ls, cat, etc)
Functions functions;
// for 'last' function
LastContainer last;
// mount points
Mounts mounts;
// rebus (captcha)
Rebus rebus;
// the time when the winix starts
time_t system_start;
// how many logged users
long how_many_logged;
// load averages
LoadAvg load_avg;
Data();
private:
void SetHttpHost(const std::string & in, std::string & out);
};
extern Data data;
#endif

File diff suppressed because it is too large Load Diff

248
core/db.h
View File

@@ -1,248 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2008-2010, Tomasz Sowa
* All rights reserved.
*
*/
#ifndef headerfilecmslucoredb
#define headerfilecmslucoredb
#include <string>
#include <vector>
#include <map>
#include <sstream>
#include <libpq-fe.h>
#include <cstdio>
#include <ctime>
#include <cstring>
#include "item.h"
#include "user.h"
#include "group.h"
#include "thread.h"
#include "error.h"
#include "dircontainer.h"
#include "ugcontainer.h"
#include "ticket.h"
class Db
{
public:
Db(bool close_at_end_ = true);
~Db();
// !! przerobic tak aby GetItem zwracalo wszystkie pozycja
// !! GetFile tylko dla plikow
// !! GetDir tylko dla katalogow
// !! GetFile i GetDir beda uzywac GetItem
void Init(const std::string & database, const std::string & user, const std::string & pass);
bool CheckUser(std::string & login, std::string & password, long & user_id);
Error AddUser(User & user, const std::string & password);
Error AddItem(Item & item);
Error EditItemById(Item & item, bool with_url = true);
Error EditItemByUrl(Item & item, bool with_url = true);
void CheckAllUrlSubject();
struct ItemQuery
{
// id is selected always
bool sel_parent_id; // parent_id
bool sel_user_id; // user_id
bool sel_group_id; // group_id
bool sel_guest_name; // guest_name
bool sel_privileges; // privileges
bool sel_date; // date_creation, date_modification
bool sel_subject; // subject
bool sel_content; // content, content_type, (content_id)
bool sel_url; // url
bool sel_type; // type (dir, file, none)
bool sel_default_item; // default_item
bool sel_auth; // auth, auth_path
bool where_id; //
bool where_parent_id; //
bool where_type;
bool where_auth;
long id; // if where_id is true
long parent_id; // if where_parent_id is true
Item::Type type;
Item::Auth auth;
bool auth_equal; // if true means auth should be equal
bool sort_asc;
void SetAll(bool sel, bool where_)
{
sel_parent_id = sel;
sel_user_id = sel;
sel_group_id = sel;
sel_guest_name = sel;
sel_privileges = sel;
sel_date = sel;
sel_subject = sel;
sel_content = sel;
sel_url = sel;
sel_type = sel;
sel_default_item= sel;
sel_auth = sel;
where_id = where_;
where_parent_id = where_;
where_type = where_;
where_auth = where_;
}
void WhereId(long id_) { where_id = true; id = id_; }
void WhereParentId(long parent_id_) { where_parent_id = true; parent_id = parent_id_; }
void WhereType(Item::Type type_) { where_type = true; type = type_; }
void WhereAuth(Item::Auth st,
bool equal = true) { where_auth = true; auth = st; auth_equal = equal; }
ItemQuery()
{
sort_asc = true;
auth_equal = true;
SetAll(true, false);
id = -1;
parent_id = -1;
type = Item::none;
auth = Item::auth_none;
}
};
void GetItems(std::vector<Item> & item_table, const ItemQuery & item_query);
// !! pobiera tylko jeden item (cos wymyslec innego z nazwa albo argumentem)
void GetItem(std::vector<Item> & item_table, long id);
bool GetPriv(Item & item, long id);
Error EditPrivById(Item & item, long id);
Error EditParentUrlById(Item & item, long id);
Error EditAuthById(Item & item, long id);
Error DelDirById(long id);
Error EditSubjectById(Item & item, long id);
bool DelItem(const Item & item);
void GetDirs(DirContainer & dir_table);
void GetUsers(UGContainer<User> & user_table);
void GetGroups(UGContainer<Group> & group_table);
// !! nowy interfejs
long Size(long parent_id, Item::Type type = Item::none);
Error GetItemById(long item_id, Item & item);
Error GetItem(long parent_id, const std::string & url, Item & item);
Error EditDefaultItem(long id, long new_default_item);
long GetItemId(long parent_id, const std::string & url, Item::Type type);
long GetFileId(long parent_id, const std::string & url);
long GetDirId(long parent_id, const std::string & url);
static tm ConvertTime(const char * str);
static const char * ConvertTime(const tm & t);
PGconn * GetPGconn();
virtual void Connect();
Error AddThread(Thread & thread);
Error GetThreadByDirId(long dir_id, Thread & thread);
Error GetThreads(long parent_id, std::vector<Thread> & thread_tab);
Error EditThreadAddItem(long dir_id, long item_id);
Error EditThreadRemoveItem(long dir_id);
Error RemoveThread(long dir_id);
Error GetTicketByDirId(long dir_id, Ticket & ticket);
Error GetTickets(long parent_id, std::vector<Ticket> & ticket_tab);
//bool IsTicket(long dir_id);
Error AddTicket(Ticket & ticket);
Error EditTicketById(Ticket & ticket);
Error EditTicketRemoveItem(long item_id);
Error RemoveTicket(long dir_id);
protected:
PGconn * pg_conn;
std::string db_database, db_user, db_pass;
bool close_at_end;
void SetDbParameters();
void Close();
void AssertConnection();
std::string Escape(const std::string & s);
std::string Escape(const char * s);
PGresult * AssertQuery(const std::string & q);
void AssertResultStatus(PGresult * r, ExecStatusType t);
static int AssertColumn(PGresult * r, const char * column_name);
static const char * AssertValue(PGresult * r, int row, int col);
void ClearResult(PGresult * r);
long AssertCurrval(const char * table);
bool AddItemCreateUrlSubject(Item & item);
Error AddItemIntoContent(Item & item);
Error AddItemIntoItem(Item & item);
Error EditItemInItem(Item & item, bool with_url);
Error EditItemInContent(Item & item);
Error EditItemGetId(Item & item);
Error EditItemGetContentId(Item & item);
void CheckAllUrlSubjectModifyItem(Item & item);
PGresult * GetItemsQuery(const ItemQuery & iq);
bool DelItemDelItem(const Item & item);
void DelItemDelContent(const Item & item);
Error DelItemCountContents(const Item & item, long & contents);
struct ItemColumns
{
int id, user_id, group_id, privileges, date_creation, date_modification, url, type, parent_id,
content_id, default_item, subject, content, content_type, guest_name, auth, auth_path;
void SetColumns(PGresult * r);
void SetItem(PGresult * r, long row, Item & item);
};
struct TicketColumns
{
int id, dir_id, parent_id, type, status, priority, category, expected, progress, item_id;
void SetColumns(PGresult * r);
void SetTicket(PGresult * r, long row, Ticket & ticket);
};
}; // class Db
extern Db db;
#endif

View File

@@ -1,95 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2008-2010, Tomasz Sowa
* All rights reserved.
*
*/
#include "db.h"
void Db::ItemColumns::SetColumns(PGresult * r)
{
// PQfnumber returns -1 if there is no such a column
id = PQfnumber(r, "id");
user_id = PQfnumber(r, "user_id");
group_id = PQfnumber(r, "group_id");
privileges = PQfnumber(r, "privileges");
date_creation = PQfnumber(r, "date_creation");
date_modification = PQfnumber(r, "date_modification");
url = PQfnumber(r, "url");
type = PQfnumber(r, "type");
parent_id = PQfnumber(r, "parent_id");
content_id = PQfnumber(r, "content_id");
default_item = PQfnumber(r, "default_item");
subject = PQfnumber(r, "subject");
content = PQfnumber(r, "content");
content_type = PQfnumber(r, "content_type");
guest_name = PQfnumber(r, "guest_name");
auth = PQfnumber(r, "auth");
auth_path = PQfnumber(r, "auth_path");
}
void Db::ItemColumns::SetItem(PGresult * r, long row, Item & item)
{
if( id != -1 ) item.id = atol( Db::AssertValue(r, row, id) );
if( user_id != -1 ) item.user_id = atol( Db::AssertValue(r, row, user_id) );
if( group_id != -1 ) item.group_id = atol( Db::AssertValue(r, row, group_id) );
if( privileges != -1 ) item.privileges = atoi( Db::AssertValue(r, row, privileges) );
if( date_creation != -1 ) item.date_creation = ConvertTime( Db::AssertValue(r, row, date_creation) );
if( date_modification != -1 ) item.date_modification = ConvertTime( Db::AssertValue(r, row, date_modification) );
if( url != -1 ) item.url = Db::AssertValue(r, row, url);
if( type != -1 ) item.type = static_cast<Item::Type>( atoi(Db::AssertValue(r, row, type)) );
if( parent_id != -1 ) item.parent_id = atol( Db::AssertValue(r, row, parent_id) );
if( content_id != -1 ) item.content_id = atol( Db::AssertValue(r, row, content_id) );
if( default_item != -1 ) item.default_item = atol( Db::AssertValue(r, row, default_item) );
if( subject != -1 ) item.subject = Db::AssertValue(r, row, subject);
if( content != -1 ) item.content = Db::AssertValue(r, row, content);
if( content_type != -1 ) item.content_type = static_cast<Item::ContentType>( atoi(Db::AssertValue(r, row, content_type)) );
if( guest_name != -1 ) item.guest_name = Db::AssertValue(r, row, guest_name);
if( auth != -1 ) item.auth = static_cast<Item::Auth>( atoi(Db::AssertValue(r, row, auth)) );
if( auth_path != -1 ) item.auth_path = Db::AssertValue(r, row, auth_path);
}
void Db::TicketColumns::SetColumns(PGresult * r)
{
// PQfnumber returns -1 if there is no such a column
id = PQfnumber(r, "id");
dir_id = PQfnumber(r, "dir_id");
parent_id = PQfnumber(r, "parent_id");
type = PQfnumber(r, "type");
status = PQfnumber(r, "status");
priority = PQfnumber(r, "priority");
category = PQfnumber(r, "category");
expected = PQfnumber(r, "expected");
progress = PQfnumber(r, "progress");
item_id = PQfnumber(r, "item_id");
}
void Db::TicketColumns::SetTicket(PGresult * r, long row, Ticket & ticket)
{
if( id != -1 ) ticket.id = atol( Db::AssertValue(r, row, id) );
if( dir_id != -1 ) ticket.dir_id = atol( Db::AssertValue(r, row, dir_id) );
if( parent_id != -1 ) ticket.parent_id = atol( Db::AssertValue(r, row, parent_id) );
if( type != -1 ) ticket.type = atoi( Db::AssertValue(r, row, type) );
if( status != -1 ) ticket.status = atoi( Db::AssertValue(r, row, status) );
if( priority != -1 ) ticket.priority = atoi( Db::AssertValue(r, row, priority) );
if( category != -1 ) ticket.category = atoi( Db::AssertValue(r, row, category) );
if( expected != -1 ) ticket.expected = atoi( Db::AssertValue(r, row, expected) );
if( progress != -1 ) ticket.progress = atoi( Db::AssertValue(r, row, progress) );
if( item_id != -1 ) ticket.item_id = atol( Db::AssertValue(r, row, item_id) );
}

View File

@@ -1,87 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2008-2010, Tomasz Sowa
* All rights reserved.
*
*/
#ifndef headerfilecmslucoredircontainer
#define headerfilecmslucoredircontainer
#include <list>
#include <map>
#include "item.h"
class DirContainer
{
public:
typedef std::list<Item> Table;
typedef Table::iterator Iterator;
typedef Table::size_type SizeType;
typedef std::map<long, Iterator> TableId;
typedef std::multimap<long, Iterator> TableParent;
typedef TableParent::iterator ParentIterator;
typedef TableParent::size_type ParentSizeType;
DirContainer();
Iterator GetRoot();
Iterator GetEtc();
Iterator Begin();
Iterator End();
SizeType Size();
bool Empty();
Iterator PushBack(const Item & item);
bool ChangeParent(long dir_id, long new_parent_id);
void Clear();
Iterator FindId(long id);
bool DelById(long id);
ParentIterator ParentBegin();
ParentIterator ParentEnd();
ParentSizeType ParentSize();
bool ParentEmpty();
ParentIterator FindFirstParent(long parent);
ParentIterator NextParent(ParentIterator pi);
void FindSpecialFolders();
private:
void CheckSpecialFolder(const Item & item, Iterator iter);
// main table with dirs
Table table;
// true if there is a root dir in the table
bool is_root;
// root
Iterator root_iter;
// true if there is a etc dir in the table
bool is_etc;
// etc
Iterator etc_iter;
// indexes
TableId table_id;
TableParent table_parent;
// names of folders
static std::string dir_etc;
};
#endif

View File

@@ -1,400 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2008-2010, Tomasz Sowa
* All rights reserved.
*
*/
#include "dirs.h"
#include "error.h"
#include "log.h"
#include "db.h"
#include "data.h"
#include "request.h"
void Dirs::Clear()
{
dir_table.Clear();
}
void Dirs::CheckRootDir()
{
DirContainer::Iterator i = dir_table.GetRoot();
if( i != dir_table.End() )
{
if( !request.HasReadExecAccessForRoot(*i) )
{
i->privileges = 0755;
log << log1 << "Dirs: there is no access for root (admin) to the root dir, setting 0755 for root dir" << logend;
db.EditPrivById(*i, i->id);
}
return;
}
log << log1 << "Dirs: there is no a root dir in the database (creating one)" << logend;
Item root;
root.type = Item::dir;
root.parent_id = -1;
root.user_id = -1;
root.group_id = -1;
root.privileges = 0755;
root.default_item = -1;
// !! upewnic sie ze baza nie zmieni url (gdyby wczesniej juz byl w bazie pusty url)
// !! zrobic jakis wyjatek do wprowadzania roota?
if( db.AddItem(root) == WINIX_ERR_OK )
{
dir_table.PushBack(root);
}
}
void Dirs::ReadDirs()
{
Clear();
db.GetDirs(dir_table);
CheckRootDir();
dir_table.FindSpecialFolders();
}
bool Dirs::ExtractName(const char * & s, std::string & name)
{
name.clear();
// skipping first slashes (can be more than one)
for( ; *s == '/' ; ++s);
for( ; *s != 0 && *s != '/' ; ++s)
name += *s;
return !name.empty();
}
bool Dirs::IsDir(long id)
{
DirContainer::Iterator i = dir_table.FindId(id);
if( i == dir_table.End() )
return false;
return true;
}
bool Dirs::GetDirChilds(long parent, std::vector<Item*> & childs_table)
{
if( parent != -1 && !IsDir(parent) )
return false;
DirContainer::ParentIterator i = dir_table.FindFirstParent(parent);
for( ; i != dir_table.ParentEnd() ; i = dir_table.NextParent(i) )
childs_table.push_back( &(*i->second) );
return true;
}
DirContainer::ParentIterator Dirs::FindFirstParent(long parent_id)
{
DirContainer::ParentIterator i = dir_table.FindFirstParent(parent_id);
return i;
}
DirContainer::ParentIterator Dirs::NextParent(DirContainer::ParentIterator i)
{
return dir_table.NextParent(i);
}
DirContainer::ParentIterator Dirs::ParentEnd()
{
return dir_table.ParentEnd();
}
// dodatkowo moze metoda AppendPath dodajaca sciezke do biezacego stringa?
// albo tutaj stringa nie czyscic?
// O(m * log n) (m- how many parts are in 'id')
// path with a slash at the end
bool Dirs::MakePath(long id, std::string & path)
{
DirContainer::Iterator i;
path = '/';
while( true )
{
i = dir_table.FindId(id);
if( i == dir_table.End() ||
i->parent_id == id ) // means a loop (something wrong in the db)
return false;
if( i->parent_id == -1 )
return true;
id = i->parent_id;
path.insert(0, i->url);
path.insert(path.begin(), '/');
}
}
bool Dirs::ChangeParent(long dir_id, long new_parent_id)
{
return dir_table.ChangeParent(dir_id, new_parent_id);
}
/*
checking whether dir_id has a parent parent_id (somewhere in the path)
*/
bool Dirs::HasParent(long dir_id, long parent_id)
{
DirContainer::Iterator i;
while( true )
{
i = dir_table.FindId(dir_id);
if( i==dir_table.End() || i->parent_id==-1 )
return false;
if( i->parent_id == parent_id )
return true;
dir_id = i->parent_id;
}
}
Item * Dirs::GetRootDir()
{
DirContainer::Iterator root = dir_table.GetRoot();
if( root == dir_table.End() )
return 0;
return &(*root);
}
Item * Dirs::GetEtcDir()
{
DirContainer::Iterator etc = dir_table.GetEtc();
if( etc == dir_table.End() )
return 0;
return &(*etc);
}
Item * Dirs::GetDir(const std::string & name, long parent)
{
DirContainer::ParentIterator i = dir_table.FindFirstParent(parent);
for( ; i!=dir_table.ParentEnd() ; i = dir_table.NextParent(i) )
if( i->second->url == name )
return &(*i->second);
return 0;
}
Item * Dirs::GetDir(const std::string & path)
{
DirContainer::Iterator root = dir_table.GetRoot();
if( root == dir_table.End() )
// ops, we do not have a root dir
return 0;
Item * pitem = &(*root);
std::string name;
const char * s = path.c_str();
while( ExtractName(s, name) )
{
pitem = GetDir(name, pitem->id);
if( !pitem )
return 0;
}
return pitem;
}
Item * Dirs::GetDir(long id)
{
DirContainer::Iterator i = dir_table.FindId(id);
if( i == dir_table.End() )
return 0;
return &(*i);
}
Item * Dirs::AddDir(const Item & item)
{
return &(*dir_table.PushBack(item));
}
size_t Dirs::AnalyzeDir(Item * pdir, const std::string & path, long & dir_id, std::string & dir)
{
size_t i = 0;
size_t old_i;
while( true )
{
dir_id = pdir->id;
// skipping slashes
for( ; i<path.size() && path[i] == '/' ; ++i );
if( i == path.size() )
return i; // end of the path
// creating a name
old_i = i;
analyze_temp.clear();
for( ; i<path.size() && path[i] != '/' ; ++i)
analyze_temp += path[i];
pdir = data.dirs.GetDir(analyze_temp, pdir->id);
if( !pdir )
return old_i; // analyze_temp is not a directory
dir += analyze_temp;
dir += '/';
}
}
/*
the path should begin with a slash
return values:
0 - directory exists
dir_id - id of the directory
dir - the path to the directory (with a slash at the end)
file - if not empty means a file name (we don't check if the file really exists)
1 - there is not a root dir
2 - the path is empty
3 - there is not such a directory
*/
int Dirs::AnalyzePath(const std::string & path, long & dir_id, std::string & dir, std::string & file)
{
Item * pdir = data.dirs.GetRootDir();
dir = '/';
file.clear();
if( !pdir )
return 1;
if( path.empty() )
return 2;
if( path[0] != '/' )
return 3;
size_t i = AnalyzeDir(pdir, path, dir_id, dir);
if( i < path.size() )
{
// checking if at least one slash has left
for(size_t a=i ; a < path.size() ; ++a)
if( path[a] == '/' )
return 3; // there is not such a directory
// the rest of the path is a file name
file = path.c_str() + i;
}
return 0;
}
void Dirs::SplitPath(const std::string & path, std::string & dir, std::string & file)
{
std::string::size_type i;
dir.clear();
file.clear();
if( path.empty() )
// !! moze dir ustawic na '/' ?
return;
for( i=path.size()-1 ; i>0 && path[i]!='/' ; --i);
if( path[i] != '/' )
{
// we do not have any slashes '/'
file = path;
return;
}
dir.assign(path, 0, i + 1); // +1 means with a slash at the end
if( i < path.size() - 1 )
file.assign(path, i+1, path.size() - i - 1);
}
bool Dirs::DelDir(long dir_id)
{
return dir_table.DelById(dir_id);
}

View File

@@ -1,73 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2008-2010, Tomasz Sowa
* All rights reserved.
*
*/
#ifndef headerfilecmslucoredirs
#define headerfilecmslucoredirs
#include <vector>
#include <map>
#include <string>
#include "item.h"
#include "dircontainer.h"
// we do not support '..' in a path (for simplicity and security reasons)
class Dirs
{
public:
void Clear();
void ReadDirs();
// these methods return false if there is no such a dir
bool IsDir(long dir_id);
bool GetDirChilds(long parent_id, std::vector<Item*> & childs_table);
bool MakePath(long dir_id, std::string & path);
bool ChangeParent(long dir_id, long new_parent_id);
bool HasParent(long dir_id, long parent_id);
bool DelDir(long dir_id);
int AnalyzePath(const std::string & path, long & dir_id, std::string & dir, std::string & file);
static void SplitPath(const std::string & path, std::string & dir, std::string & file);
DirContainer::ParentIterator FindFirstParent(long parent_id);
DirContainer::ParentIterator NextParent(DirContainer::ParentIterator i);
DirContainer::ParentIterator ParentEnd();
// these methods return null if there is no such a dir
Item * GetRootDir();
Item * GetEtcDir();
Item * GetDir(const std::string & name, long parent);
Item * GetDir(const std::string & path);
Item * GetDir(long id);
Item * AddDir(const Item & item);
void CheckRootDir();
private:
DirContainer dir_table;
size_t AnalyzeDir(Item * pdir, const std::string & path, long & dir_id, std::string & dir);
std::string analyze_temp;
bool ExtractName(const char * & s, std::string & name);
};
#endif

View File

@@ -1,75 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2008-2010, Tomasz Sowa
* All rights reserved.
*
*/
#ifndef headerfilecmslucoreerror
#define headerfilecmslucoreerror
#include <iostream>
#include "log.h"
#define WINIX_ERR_OK 0
//#define WINIX_ERR_INCORRECT_PATH 1
//#define WINIX_ERR_NO_POSTVAR 2
#define WINIX_ERR_INCORRECT_DIR 3
#define WINIX_ERR_CANT_CHANGE_USER 4
#define WINIX_ERR_CANT_CHANGE_GROUP 5
#define WINIX_ERR_CANT_CHANGE_PRIVILEGES 6
#define WINIX_ERR_PERMISSION_DENIED 7
#define WINIX_ERR_NO_ROOT_DIR 8
#define WINIX_ERR_NO_FUNCTION 9
#define WINIX_ERR_NO_ITEM 10
#define WINIX_ERR_UNKNOWN_PARAM 11
#define WINIX_ERR_MOUNT_UNKNOWN 12
#define WINIX_ERR_UNKNOWN_FILESYSTEM 13
#define WINIX_ERR_NO_MOUNTPOINT 14
//#define WINIX_ERR_MOUNT_NO_PARAM 15
#define WINIX_ERR_NO_THREAD 16
#define WINIX_ERR_EMPTY 17
#define WINIX_ERR_SPAM 18
#define WINIX_ERR_INCORRECT_REBUS 19
#define WINIX_ERR_NO_BOUNDARY 20
#define WINIX_ERR_BROKEN_INPUT 21
#define WINIX_ERR_INPUT_TOO_LARGE 22
#define WINIX_ERR_CANT_CREATE_FILE 23
#define WINIX_ERR_NO_TICKET 24
#define WINIX_ERR_PASSWORDS_DIFFERENT 25
#define WINIX_ERR_PASSWORD_TOO_SHORT 26
#define WINIX_ERR_USER_EXISTS 27
#define WINIX_ERR_LOGIN_EMPTY 28
#define WINIX_DIFFERENT_MOUNT_POINTS 29
#define WINIX_ERR_DB_FATAL_ERROR_DURING_CONNECTING 100
#define WINIX_ERR_DB_INCORRECT_QUERY 101
#define WINIX_ERR_DB_INCORRENT_RESULT_STATUS 102
#define WINIX_ERR_DB_NO_COLUMN 103
#define WINIX_ERR_DB_INCORRECT_LOGIN 104
#define WINIX_ERR_DB_MORE_THAN_ONE_LOGIN 105
#define WINIX_ERR_DB_ERR_CURRVAL 106
//#define WINIX_ERR_UNKNOWN 1000
typedef int Error;
#endif

View File

@@ -1,59 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2008-2010, Tomasz Sowa
* All rights reserved.
*
*/
#include "function.h"
Function::Function()
{
code = FUN_NONE;
}
void Function::Clear()
{
code = FUN_NONE;
item.Clear();
}
Function::Function(const Function & f)
{
code = f.code;
item = f.item;
}
Function & Function::operator=(const Function & f)
{
code = f.code;
item = f.item;
return *this;
}

View File

@@ -1,71 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2008-2010, Tomasz Sowa
* All rights reserved.
*
*/
#ifndef headerfilecmslucorefunction
#define headerfilecmslucorefunction
#include <iostream>
#include "item.h"
#define FUN_NONE 0
#define FUN_LS 1
#define FUN_CAT 2
#define FUN_NODE 3
#define FUN_EMACS 4
#define FUN_MKDIR 5
#define FUN_DEFAULT 6
#define FUN_PRIV 7
#define FUN_RM 8
#define FUN_LOGIN 9
#define FUN_LOGOUT 10
#define FUN_RUN 11
#define FUN_WHO 12
#define FUN_LAST 13
#define FUN_CREATETHREAD 14
#define FUN_THREAD 15
#define FUN_RELOAD 16
#define FUN_UPLOAD 17
#define FUN_CREATETICKET 18
#define FUN_EDITTICKET 19
#define FUN_TICKET 20
#define FUN_UPTIME 21
#define FUN_MV 23
#define FUN_UNAME 24
#define FUN_CHMOD 25
#define FUN_CHOWN 26
#define FUN_CKEDITOR 27
#define FUN_DOWNLOAD 28
#define FUN_ADDUSER 29
#define FUN_SUBJECT 30
#define FUN_CP 31
#define FUN_TINYMCE 32
class Function
{
public:
int code;
Item item;
void Clear();
Function();
Function(const Function & f);
Function & operator=(const Function & f);
};
#endif

View File

@@ -1,58 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2008-2010, Tomasz Sowa
* All rights reserved.
*
*/
#include "functioncodeparser.h"
#include "function.h"
#include "log.h"
bool FunctionCodeParser::ContentHasOneRow(const Item & item)
{
for(size_t i=0 ; i<item.content.size() ; ++i)
if( item.content[i] == '\n' )
return false;
return true;
}
int FunctionCodeParser::ParseValue(const char * s)
{
if( strncmp(s, "[fun:", 5) != 0 )
return FUN_NONE;
const char * send;
int result = strtol(s+5, (char**)&send, 10);
if( send==s+5 || strcmp(send, "]") != 0 )
return FUN_NONE;
log << log2 << "FCP: function code: " << result << logend;
return result;
}
int FunctionCodeParser::Parse(const Item & item)
{
// format: [fun:1]
// minimum size: 7 characters
if( item.content.size() < 7 )
return FUN_NONE;
if( !ContentHasOneRow(item) )
return FUN_NONE;
return ParseValue(item.content.c_str());
}

View File

@@ -1,34 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2008-2010, Tomasz Sowa
* All rights reserved.
*
*/
#ifndef headerfilecmslucorefunctioncodeparser
#define headerfilecmslucorefunctioncodeparser
#include <cstring>
#include <cstdlib>
#include "item.h"
class FunctionCodeParser
{
bool ContentHasOneRow(const Item & item);
int ParseValue(const char * s);
public:
int Parse(const Item & item);
};
#endif

View File

@@ -1,195 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2008-2010, Tomasz Sowa
* All rights reserved.
*
*/
#include "functionparser.h"
#include "log.h"
#include "item.h"
#include "error.h"
#include "data.h"
#include "db.h"
#include "request.h"
void FunctionParser::SkipEmptyString(const char * msg)
{
for( ; get_index != get_table_len && request.get_table[get_index].empty() ; ++get_index )
log << log3 << msg << logend;
}
void FunctionParser::ParseDirectories()
{
Item * pdir = data.dirs.GetRootDir();
if( !pdir )
{
// there is no the root dir
request.status = WINIX_ERR_NO_ROOT_DIR;
return;
}
while( true )
{
request.dir_table.push_back( pdir );
log << log3 << "FP: Directory: ";
if( pdir->parent_id == -1 )
log << "(root)" << logend;
else
log << pdir->url << logend;
SkipEmptyString("FP: Directory: skipped empty string");
if( get_index == get_table_len )
break;
pdir = data.dirs.GetDir(request.get_table[get_index], pdir->id);
if( !pdir )
break;
++get_index;
}
}
void FunctionParser::ParseItem()
{
SkipEmptyString("FP: Item: skipped empty string");
if( get_index == get_table_len )
return;
// request.dir_table has at least one element
long parent_id = request.dir_table.back()->id;
const std::string & url = request.get_table[get_index];
request.status = db.GetItem(parent_id, url, request.item);
if( request.status == WINIX_ERR_OK )
{
if( request.role == Request::authorizer && request.item.auth == Item::auth_none )
{
log << log1 << "FP: item.url: " << url << " exists but has not a static content (authorizer role)" << logend;
request.status = WINIX_ERR_NO_ITEM;
return;
}
++get_index;
request.is_item = true;
log << log3 << "FP: Item: id: " << request.item.id << ", url: " << request.item.url << logend;
}
else
{
log << log3 << "FP: No Item: url: " << url << logend;
}
}
void FunctionParser::ParseFunction()
{
SkipEmptyString("FP: Function: skipped empty string");
if( get_index == get_table_len )
return;
request.pfunction = data.functions.GetFunction(request.get_table[get_index]);
if( request.pfunction )
{
++get_index;
log << log3 << "FP: Function: " << request.pfunction->item.url << logend;
}
}
void FunctionParser::ParseParams()
{
while( true )
{
SkipEmptyString("FP: Params: skipped empty string");
if( get_index == get_table_len )
break;
request.param_table.push_back( &request.get_table[get_index] );
log << log3 << "FP: Params: " << request.get_table[get_index] << logend;
++get_index;
}
}
void FunctionParser::Parse()
{
request.status = WINIX_ERR_OK;
get_index = 0;
get_table_len = request.get_table.size();
request.pfunction = 0;
request.is_item = false;
ParseDirectories();
if( request.status != WINIX_ERR_OK )
return;
ParseFunction();
if( !request.pfunction )
{
ParseItem();
if( request.status != WINIX_ERR_OK )
return;
ParseFunction();
if( !request.pfunction && get_index != get_table_len )
{
request.status = WINIX_ERR_NO_FUNCTION;
log << log3 << "FP: Parse: unknown function: \"" << request.get_table[get_index] << "\"" << logend;
return;
}
}
ParseParams();
}

View File

@@ -1,38 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2008-2010, Tomasz Sowa
* All rights reserved.
*
*/
#ifndef headerfilecmslucorefunctionparser
#define headerfilecmslucorefunctionparser
#include "requesttypes.h"
class FunctionParser
{
GetTable::size_type get_index;
GetTable::size_type get_table_len;
void SkipEmptyString(const char * msg);
void ParseDirectories();
void ParseItem();
bool IsAppFunction();
void ParseFunction();
void ParseParams();
public:
void Parse();
};
#endif

View File

@@ -1,127 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2008-2010, Tomasz Sowa
* All rights reserved.
*
*/
#include "functions.h"
void Functions::Clear()
{
table.clear();
}
void Functions::AddFun(int code, const char * url)
{
fun.code = code;
fun.item.url = url;
table.insert( std::make_pair(fun.item.url, fun) );
}
// in the future we will read these functions from the database
void Functions::ReadFunctions()
{
Clear();
fun.item.user_id = -1;
fun.item.group_id = -1;
fun.item.privileges = 0755;
fun.item.parent_id = -1; // !! temporarily doesn't matter
fun.item.id = -1;
fun.item.type = Item::file;
AddFun(FUN_LS, "ls");
AddFun(FUN_CAT, "cat");
AddFun(FUN_NODE, "node");
AddFun(FUN_EMACS, "emacs");
AddFun(FUN_MKDIR, "mkdir");
AddFun(FUN_DEFAULT, "default");
AddFun(FUN_PRIV, "priv");
AddFun(FUN_RM, "rm");
AddFun(FUN_LOGOUT, "logout");
AddFun(FUN_LOGIN, "login");
AddFun(FUN_RUN, "run");
AddFun(FUN_WHO, "who");
AddFun(FUN_LAST, "last");
AddFun(FUN_CREATETHREAD, "createthread");
AddFun(FUN_THREAD, "thread");
AddFun(FUN_UPLOAD, "upload");
AddFun(FUN_CREATETICKET, "createticket");
AddFun(FUN_EDITTICKET, "editticket");
AddFun(FUN_TICKET, "ticket");
AddFun(FUN_UPTIME, "uptime");
AddFun(FUN_MV, "mv");
AddFun(FUN_UNAME, "uname");
AddFun(FUN_CHMOD, "chmod");
AddFun(FUN_CHOWN, "chown");
AddFun(FUN_CKEDITOR, "ckeditor");
AddFun(FUN_DOWNLOAD, "download");
AddFun(FUN_ADDUSER, "adduser");
AddFun(FUN_SUBJECT, "subject");
AddFun(FUN_CP, "cp");
AddFun(FUN_TINYMCE, "tinymce");
// functions which need more privileges
fun.item.privileges = 0700;
AddFun(FUN_RELOAD, "reload");
}
Function * Functions::GetFunction(const std::string & name)
{
Table::iterator i = table.find(name);
if( i == table.end() )
return 0;
return &(i->second);
}
// !! in the future there will be a special container where we can search through the Code object
Function * Functions::GetFunction(int code)
{
Table::iterator i = table.begin();
for( ; i != table.end() ; ++i )
{
if( i->second.code == code )
return &(i->second);
}
return 0;
}

View File

@@ -1,43 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2008-2010, Tomasz Sowa
* All rights reserved.
*
*/
#ifndef headerfilecmslucorefunctions
#define headerfilecmslucorefunctions
#include <map>
#include <string>
#include "function.h"
class Functions
{
typedef std::map<std::string, Function> Table;
Table table;
Function fun;
void AddFun(int code, const char * url);
public:
void Clear();
void ReadFunctions();
Function * GetFunction(const std::string & name);
Function * GetFunction(int code);
};
#endif

View File

@@ -1,57 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2008-2010, Tomasz Sowa
* All rights reserved.
*
*/
#ifndef headerfilecmslucoregetparser
#define headerfilecmslucoregetparser
#include "httpsimpleparser.h"
#include "requesttypes.h"
class GetParser : public HttpSimpleParser
{
const char * get_string;
GetTable & get_table;
protected:
virtual int GetChar()
{
if( !get_string || *get_string == 0 )
return -1;
return (int)(unsigned char)*(get_string++);
}
virtual void Parameter(std::string &, std::string & value)
{
get_table.push_back(value);
log << log2 << "Get, value: \"" << value << "\"" << logend;
}
public:
GetParser(const char * get_string_, GetTable & get_table_) : get_string(get_string_), get_table(get_table_)
{
HttpSimpleParser::separator = '/';
HttpSimpleParser::read_name = false;
if( get_string && *get_string == separator ) // one '/' at the beginning
++get_string;
}
};
#endif

View File

@@ -1,43 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2008-2010, Tomasz Sowa
* All rights reserved.
*
*/
#ifndef headerfilecmslucoregroup
#define headerfilecmslucoregroup
#include <string>
#include <vector>
struct Group
{
long id;
std::string name; // group name
std::vector<long> members; // users id
Group()
{
Clear();
}
void Clear()
{
id = -1;
name.clear();
members.clear();
}
};
#endif

View File

@@ -1,117 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2008-2010, Tomasz Sowa
* All rights reserved.
*
*/
#include "groups.h"
#include "db.h"
Groups::Groups()
{
Clear();
}
void Groups::Clear()
{
table.Clear();
}
void Groups::ReadGroups()
{
Clear();
db.GetGroups(table);
}
Group * Groups::GetGroup(long group_id)
{
Table::Iterator i = table.FindId(group_id);
if( i == table.End() )
return 0;
return &(*i);
}
Group * Groups::GetGroup(const std::string & name)
{
Table::Iterator i = table.FindName(name);
if( i == table.End() )
return 0;
return &(*i);
}
long Groups::GetGroupId(const std::string & name)
{
Group * pgroup = GetGroup(name);
if( !pgroup )
return -1;
return pgroup->id;
}
Groups::Iterator Groups::Begin()
{
return table.Begin();
}
Groups::Iterator Groups::End()
{
return table.End();
}
Groups::SizeType Groups::Size()
{
return table.Size();
}
Group & Groups::operator[](Groups::SizeType pos)
{
return table[pos];
}

View File

@@ -1,51 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2008-2010, Tomasz Sowa
* All rights reserved.
*
*/
#ifndef headerfilecmslucoregroups
#define headerfilecmslucoregroups
#include <map>
#include "group.h"
#include "ugcontainer.h"
class Groups
{
typedef UGContainer<Group> Table;
Table table;
public:
typedef Table::Iterator Iterator;
typedef Table::SizeType SizeType;
Groups();
void Clear();
void ReadGroups();
Group * GetGroup(long group_id);
Group * GetGroup(const std::string & name);
long GetGroupId(const std::string & name);
Iterator Begin();
Iterator End();
SizeType Size();
Group & operator[](SizeType pos);
};
#endif

File diff suppressed because it is too large Load Diff

View File

@@ -1,211 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2008-2010, Tomasz Sowa
* All rights reserved.
*
*/
#ifndef headerfilecmslucorehtmlfilter
#define headerfilecmslucorehtmlfilter
#include <string>
// max length of a name of a html tag (with terminating null)
#define WINIX_HTMLFILTER_ITEM_MAXLEN 30
// depth of the html tree
#define WINIX_HTMLFILTER_STACK_MAXLEN 100
// length of a buffer used for printing
// it should be at least: WINIX_HTMLFILTER_ITEM_MAXLEN+3
#define WINIX_HTMLFILTER_BUFFER_MAXLEN 2048
/*!
very lightweight filter for html
(without using any dynamic memory - some memory is allocated only at the beginning - in ctors)
this filter has O(n) complexity over the whole html string
such tags as: <script> <pre> <textarea> are treated in a special way
all characters between the opening and closing tag (<script>....</script>) are untouched
if the filter finds that there are not closed tags it will close them,
if the filter finds a closing tag which doesn't have an opening tag - it will skip it
tags which don't need to be closed: meta, input, br, img, link
look at CheckExceptions() method
the filter recognizes xml simple tags (with / at the end) such as: <br />
*/
class HTMLFilter
{
public:
// for checking orphans
enum Lang
{
lang_pl,
lang_cz,
lang_sk,
lang_none
};
enum OrphanMode
{
orphan_nbsp,
orphan_nbspace
};
HTMLFilter();
HTMLFilter(const HTMLFilter & f);
HTMLFilter & operator=(const HTMLFilter & f);
~HTMLFilter();
// main methods used for filtering
void Filter(const char * in, std::string & out);
void Filter(const std::string & in, std::string & out);
// insert a white space into long lines
// only between html tags
// skipped in such tags: script, pre, textarea
// break_after - after how many characters insert a space (0 - off)
void BreakLines(size_t break_after_);
// trimming white characters (with new lines)
// at the beginning, at the end and in the middle of a string
// only between html tags
// at the beginning and at the end only one space is left
// skipped in such tags: script, pre, textarea
// false by default
void TrimWhite(bool trim);
// first tabs in a tree
// default: 2 (spaces)
// set 0 to turn off
void InsertTabs(size_t tabsize);
// check 'orphans' for the specicic language
// if an orphans is detected then the non-break space (&nbsp;) will be put
// default disable: lang_none
void CheckOrphans(Lang lang_, OrphanMode mode = orphan_nbsp);
protected:
struct Item
{
char name[WINIX_HTMLFILTER_ITEM_MAXLEN];
size_t name_len;
enum Type
{
opening,
closing,
simple,
special,
none
} type;
// is there a new line after this tag
bool new_line;
void Clear();
Item();
};
// only this method have direct access to the output string
// you can easily change the output from a std::string to something else
void Put(const char * str, const char * end);
Item & GetItem(size_t i);
Item & LastItem();
int ToLower(int c);
bool IsNameEqual(const char * name1, const char * name2);
bool IsNameEqual(const char * name1, const char * name2, size_t len);
bool IsLastTag(const char * name);
public: // !!
int CheckOrphan(const char * str, const char * end, const char * orphan);
bool CheckOrphanTable(const char * str, const char * end, const char ** table, size_t o1, size_t o2);
bool CheckOrphanLangPl(const char * str, const char * end);
bool CheckOrphanLangCz(const char * str, const char * end);
bool CheckOrphan(const char * str, const char * end);
bool IsWhite(int c);
void SkipWhite();
void SkipWhiteLines();
void SkipWhiteWithFirstNewLine();
bool IsClosingTagForLastItem();
virtual bool IsOpeningTagMark();
virtual bool IsOpeningCommentaryTagMark();
size_t OpeningCommentaryTagMarkSize();
virtual bool IsClosingTagMark();
virtual bool IsClosingXmlSimpleTagMark();
bool SkipCommentaryTagIfExists();
const char * SkipItemCheckXmlSimple();
void PopStack();
bool PushStack();
virtual bool IsValidCharForName(int c);
void CheckNewLine();
void CheckExceptions();
void CheckStackPrintRest();
void AddForgottenTags();
void CheckClosingTags();
void ReadNormalTextSkipWhite(const char * & start, const char * & last_non_white);
void ReadNormalText();
bool PrintRest();
void PrintItem(const char * start, const char * end);
void ReadItemName();
bool ReadItem();
virtual void Init();
virtual void Deinit();
void Read();
size_t PutNormalTextTrimFillBuffer(const char * & str, const char * & end);
size_t PutNormalTextFillBuffer(const char * & str, const char * & end);
void PutNormalText(const char * str, const char * end);
void PutNormalTextTrim(const char * str, const char * end);
void PutLastTagWithClosingTag();
virtual void PutOpeningTagMark();
virtual void PutClosingTagMark();
virtual void PutTagName(const char * name);
virtual void PutOpeningTag(const char * start, const char * end);
virtual void PutClosingTag(const char * tag);
size_t PutTabsToBuffer(size_t index, size_t len);
size_t PutNonBreakSpaceToBuffer(size_t index);
void PutTabs(size_t len);
void PutNewLine();
const char * pchar;
Item empty;
Item * pstack; // stack pointer
size_t stack_len; // length of the stack
char * buffer; // buffer used when printing
std::string * out_string;
bool last_new_line;
size_t break_after; // insert a space into long lines after break_after characters
bool trim_white; // trimming white characters
size_t tab_size;
Lang lang; // current language for checking orphans
OrphanMode orphan_mode;
};
#endif

View File

@@ -1,235 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2008-2010, Tomasz Sowa
* All rights reserved.
*
*/
#include "httpsimpleparser.h"
void HttpSimpleParser::ToLower(std::string & s)
{
std::string::iterator i;
for(i=s.begin() ; i!= s.end() ; ++i)
{
if( *i>='A' && *i<='Z' )
*i = *i - 'A' + 'a';
}
}
bool HttpSimpleParser::IsWhite(int c)
{
if( c==' ' || c=='\t' )
return true;
return false;
}
void HttpSimpleParser::SkipWhiteChars()
{
while( IsWhite(last_c) )
last_c = GetChar();
}
void HttpSimpleParser::TrimWhiteChars(std::string & s)
{
if( s.empty() )
return;
std::string::size_type i;
for(i = 0 ; i<s.size() && IsWhite(s[i]) ; ++i);
if( i == s.size() )
{
// all characters are white
s.clear();
return;
}
if( i > 0 )
// there are some white characters at the beginning
s.erase(0, i);
// s is not empty now (i was not equal s.size())
// and we have some non white characters
// we stops at the last non white character
for(i = s.size()-1 ; i>0 && IsWhite(s[i]) ; --i);
if( i != s.size()-1 )
// there are some white characters at the end
// we're starting from i+1 even when i==0 (there are some non white characters)
s.erase(i+1, s.size() - i - 1);
}
int HttpSimpleParser::ParseHalfHex(int c)
{
if( c>='a' && c<='z' )
c += 'A' - 'a'; // to upper case
if( c >= 'A' )
c = c - 'A' + 10;
else
c = c - '0';
c &= 0xf;
return c;
}
void HttpSimpleParser::CheckSpecialChar()
{
if( last_c == '%' )
{
int c1 = GetChar();
int c2 = GetChar();
if( c1==-1 || c2==-1 )
{
last_c = -1;
}
else
{
c1 = ParseHalfHex(c1);
c2 = ParseHalfHex(c2);
last_c = (c1 << 4) + c2;
}
}
else
if( last_c == '+' )
{
last_c = ' ';
}
}
void HttpSimpleParser::ReadName()
{
// we're checking 'separator' and '=' because the string is allowed not having '=' (the value is optional)
for( ; last_c!=-1 && last_c!=separator && last_c!='=' ; last_c = GetChar() )
{
if( recognize_special_chars )
CheckSpecialChar();
if( last_c != -1 )
last_name += last_c;
}
if( last_c == '=' )
last_c = GetChar();
}
void HttpSimpleParser::ReadQuotedValue()
{
// skipping '"'
last_c = GetChar();
for( ; last_c!=-1 && last_c!='"' ; last_c = GetChar() )
{
if( recognize_special_chars )
CheckSpecialChar();
if( last_c != -1 )
last_value += last_c;
}
if( last_c == '"' )
last_c = GetChar();
// looking for a separator (skipping)
for( ; last_c!=-1 && last_c!=separator ; last_c = GetChar() );
}
void HttpSimpleParser::ReadValue()
{
if( skip_white_chars )
SkipWhiteChars();
if( value_can_be_quoted && last_c == '"' )
{
ReadQuotedValue();
}
else
{
for( ; last_c!=-1 && last_c!=separator ; last_c = GetChar() )
{
if( recognize_special_chars )
CheckSpecialChar();
if( last_c != -1 )
last_value += last_c;
}
}
if( last_c == separator )
last_c = GetChar();
}
void HttpSimpleParser::Parse()
{
for( last_c = GetChar() ; last_c != -1 ; )
{
last_name.clear();
last_value.clear();
if( read_name )
ReadName();
ReadValue();
if( skip_white_chars )
{
TrimWhiteChars(last_name);
TrimWhiteChars(last_value);
}
Parameter(last_name, last_value); // user definied function
}
}

View File

@@ -1,74 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2008-2010, Tomasz Sowa
* All rights reserved.
*
*/
#ifndef headerfilecmslucorehttpsimpleparser
#define headerfilecmslucorehttpsimpleparser
#include <string>
class HttpSimpleParser
{
protected:
bool read_name;
bool value_can_be_quoted;
bool skip_white_chars;
bool recognize_special_chars;
int ParseHalfHex(int c);
void ReadName();
void ReadQuotedValue();
void ReadValue();
std::string last_name;
std::string last_value;
int last_c;
int separator;
// '-1' means end (eof)
virtual int GetChar() = 0;
virtual void Parameter(std::string & last_name, std::string & last_value) = 0;
void ToLower(std::string & s);
bool IsWhite(int c);
void SkipWhiteChars();
void TrimWhiteChars(std::string & s);
void CheckSpecialChar();
public:
HttpSimpleParser()
{
separator = '&';
read_name = true;
value_can_be_quoted = false;
skip_white_chars = false;
recognize_special_chars = true;
}
void Parse();
};
#endif

View File

@@ -1,142 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2008-2010, Tomasz Sowa
* All rights reserved.
*
*/
#ifndef headerfilecmslucoreitem
#define headerfilecmslucoreitem
#include <string>
struct Item
{
long id;
long parent_id;
long user_id;
long group_id;
std::string guest_name; // used as a user name when user_id is equal -1
int privileges;
tm date_creation;
tm date_modification;
std::string subject;
std::string content;
long content_id; // used by the database
std::string url;
enum ContentType
{
ct_text = 0,
ct_formatted_text,
ct_html,
ct_bbcode,
ct_raw
};
ContentType content_type;
enum Type
{
dir = 0,
file = 1,
none = 1000 // !! pozbyc sie tego
};
Type type;
long default_item;
// external static file authorized by winix
enum Auth
{
auth_none = 0, /* there is not an external file */
auth_image = 1, /* png, gif, jpg - only types available to render by a web browser*/
auth_document = 2, /* pdf doc xls txt */
auth_other = 3 /* other file */
};
Auth auth;
std::string auth_path; // path to a file (if auth!=auth_none)
// methods
Item()
{
Clear();
}
void SetDateToNow()
{
time_t t = std::time(0);
date_creation = *std::localtime( &t );
date_modification = date_creation;
}
void SetDateModifyToNow()
{
time_t t = std::time(0);
date_modification = *std::localtime( &t );
}
void Clear()
{
id = -1;
user_id = -1;
group_id = -1;
privileges = 0;
guest_name.clear();
subject.clear();
content.clear();
url.clear();
content_type = ct_formatted_text;
type = none;
parent_id = -1;
default_item = -1;
content_id = -1;
auth = auth_none;
auth_path.clear();
SetDateToNow();
}
};
#endif

View File

@@ -1,115 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2009, Tomasz Sowa
* All rights reserved.
*
*/
#include "lastcontainer.h"
#include "log.h"
LastItem::LastItem()
{
user_id = 0;
ip = 0;
session_id = 0;
memset((char*)&start, 0, sizeof(start));
memset((char*)&end, 0, sizeof(end));
}
bool LastItem::IsLoggedOut()
{
if( end.tm_sec == 0 &&
end.tm_min == 0 &&
end.tm_hour == 0 &&
end.tm_mday == 0 &&
end.tm_mon == 0 &&
end.tm_year == 0 )
return false;
return true;
}
LastContainer::Iterator LastContainer::Begin()
{
return last_tab.begin();
}
LastContainer::Iterator LastContainer::End()
{
return last_tab.end();
}
LastContainer::Iterator LastContainer::FindNotLoggedOut(long user_id, long session_id)
{
LastTab::iterator i;
for(i=last_tab.begin() ; i!=last_tab.end() ; ++i)
{
if( i->user_id == user_id && i->session_id == session_id && !i->IsLoggedOut() )
return i;
}
return last_tab.end();
}
void LastContainer::UserLogin(long user_id, const std::string & name, unsigned int ip, long session_id)
{
LastTab::iterator i = FindNotLoggedOut(user_id, session_id);
if( i != last_tab.end() )
{
log << log1 << "LC: such a user and session_id exist, not added as a new one" << logend;
return;
}
if( last_tab.size() >= LAST_TABLE_SIZE )
last_tab.erase(last_tab.begin());
LastItem li;
li.user_id = user_id;
li.name = name;
li.ip = ip;
li.session_id = session_id;
time_t t = std::time(0);
li.start = *localtime(&t);
last_tab.insert(last_tab.end(), li);
log << log2 << "LC: added user: " << name << " into the last table" << logend;
}
void LastContainer::UserLogout(long user_id, long session_id)
{
LastTab::iterator i = FindNotLoggedOut(user_id, session_id);
if( i != last_tab.end() )
{
time_t t = std::time(0);
i->end = *localtime(&t);
}
else
{
log << log1 << "LC: there is no such a user to log out" << logend;
}
}

View File

@@ -1,77 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2009, Tomasz Sowa
* All rights reserved.
*
*/
#ifndef headerfilecmslucorelastcontainer
#define headerfilecmslucorelastcontainer
#include <string>
#include <list>
#include <cstring>
#include <ctime>
// how many items we store in the 'last' function
#define LAST_TABLE_SIZE 100
struct LastItem
{
long user_id;
// additional we store the whole string-name
// (you can delete a user from the database but we can still print the name)
std::string name;
// ip address
unsigned int ip;
// session id (used when logging out)
long session_id;
// start logging and end logging
tm start;
tm end;
LastItem();
bool IsLoggedOut();
};
class LastContainer
{
public:
typedef std::list<LastItem> LastTab;
typedef LastTab::iterator Iterator;
public:
Iterator Begin();
Iterator End();
void UserLogin(long user_id, const std::string & name, unsigned int ip, long session_id);
void UserLogout(long user_id, long session_id);
private:
LastTab last_tab;
Iterator FindNotLoggedOut(long user_id, long session_id);
};
#endif

View File

@@ -1,237 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2010, Tomasz Sowa
* All rights reserved.
*
*/
#include "locale.h"
#include "log.h"
Locale::Locale()
{
loc_tab.resize(lang_unknown);
default_lang = lang_en;
current_lang = lang_en;
}
void Locale::AddLocale(Lang lang)
{
ConfParser::Table::iterator i = loc_parser.table.begin();
for( ; i != loc_parser.table.end() ; ++i)
loc_tab[lang][i->first] = i->second;
}
void Locale::ReadFile(const char * dir, const char * dir_def, Lang lang, const char * file)
{
if( static_cast<size_t>(lang) >= loc_tab.size() )
{
// ops, something wrong
return;
}
loc_tab[lang].clear();
bool read = false;
if( dir_def )
{
file_name = dir_def;
file_name += '/';
file_name += file;
if( loc_parser.Parse(file_name.c_str()) == ConfParser::ok )
{
read = true;
AddLocale(lang);
log << log3 << "Locale: read locale from: " << file_name << logend;
}
}
if( dir )
{
file_name = dir;
file_name += '/';
file_name += file;
if( loc_parser.Parse(file_name.c_str()) == ConfParser::ok )
{
read = true;
AddLocale(lang);
log << log3 << "Locale: read locale from: " << file_name << logend;
}
}
if( !read )
log << log1 << "Locale: cant open file for locale: " << file << logend;
}
void Locale::Read(const char * dir, const char * dir_def)
{
ReadFile(dir, dir_def, lang_pl, "pl");
ReadFile(dir, dir_def, lang_en, "en");
}
void Locale::Read(const std::string & dir, const std::string & dir_def)
{
if( dir_def.empty() )
Read(dir.c_str());
else
Read(dir.c_str(), dir_def.c_str());
}
void Locale::SetLang(Lang lang)
{
current_lang = lang;
}
Locale::Lang Locale::GetLang()
{
return current_lang;
}
void Locale::SetLangDef(Lang lang)
{
default_lang = lang_en;
}
bool Locale::IsKey(const std::string & key) const
{
return IsKey(key, current_lang);
}
bool Locale::IsKey(const std::string & key, Lang lang) const
{
if( static_cast<size_t>(lang) >= loc_tab.size() )
{
// ops, something wrong
return false;
}
// looking in the lang language
ConfParser::Table::const_iterator i = loc_tab[lang].find(key);
if( i != loc_tab[lang].end() )
return true;
if( lang == default_lang )
return false;
if( static_cast<size_t>(default_lang) >= loc_tab.size() )
{
// ops, something wrong
return false;
}
// looking in a default language
i = loc_tab[default_lang].find(key);
if( i != loc_tab[default_lang].end() )
return true;
// there is no such a key
return false;
}
const std::string & Locale::Get(const std::string & key) const
{
return Get(key, current_lang);
}
const std::string & Locale::Get(const std::string & key, Lang lang) const
{
if( static_cast<size_t>(lang) >= loc_tab.size() )
{
// ops, something wrong
return empty;
}
// looking in the lang language
ConfParser::Table::const_iterator i = loc_tab[lang].find(key);
if( i != loc_tab[lang].end() )
return i->second;
if( lang == default_lang )
return empty;
if( static_cast<size_t>(default_lang) >= loc_tab.size() )
{
// ops, something wrong
return empty;
}
// looking in a default language
i = loc_tab[default_lang].find(key);
if( i != loc_tab[default_lang].end() )
return i->second;
// there is no such a key
return empty;
}
Locale::Lang Locale::StrToLang(const std::string & str)
{
if( str == "en" )
return lang_en;
else
if( str == "pl" )
return lang_pl;
return lang_unknown;
}
const char * Locale::LangToStr(Lang lang)
{
static char buffer[30];
switch(lang)
{
case lang_en:
sprintf(buffer, "en");
break;
case lang_pl:
sprintf(buffer, "pl");
break;
default:
sprintf(buffer, "unknown");
}
return buffer;
}
size_t Locale::Size()
{
return loc_tab.size();
}

View File

@@ -1,70 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2010, Tomasz Sowa
* All rights reserved.
*
*/
#ifndef headerfilecmslucorelocale
#define headerfilecmslucorelocale
#include "../confparser/confparser.h"
#include <vector>
#include <string>
class Locale
{
public:
enum Lang
{
lang_en = 0,
lang_pl,
lang_unknown // should be last
};
Locale();
void Read(const char * dir, const char * dir_def = 0);
void Read(const std::string & dir, const std::string & dir_def);
bool IsKey(const std::string & key) const;
bool IsKey(const std::string & key, Lang lang) const;
const std::string & Get(const std::string & key) const;
const std::string & Get(const std::string & key, Lang lang) const;
// default is english
void SetLang(Lang lang);
Lang GetLang();
// which language is used instead if there is no a key in an other language
// default: lang_en
void SetLangDef(Lang lang);
static Lang StrToLang(const std::string & str);
static const char * LangToStr(Lang lang);
size_t Size();
private:
void AddLocale(Lang lang);
void ReadFile(const char * dir, const char * dir_def, Lang lang, const char * file);
std::vector<ConfParser::Table> loc_tab;
ConfParser loc_parser;
std::string file_name;
std::string empty;
Lang default_lang;
Lang current_lang;
};
#endif

View File

@@ -1,259 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2008-2010, Tomasz Sowa
* All rights reserved.
*
*/
#include "log.h"
#include <ctime>
#include <string.h>
Log::Log()
{
log_level = 3;
current_level = 4; // nothing to log (call Init() first)
item = 0;
item_save = 1;
lines = 0;
}
void Log::Init(int log_l, const std::string & log_f, bool log_std, int log_request)
{
log_level = log_l;
log_file = log_f;
log_stdout = log_std;
item_save = log_request;
OpenFile();
}
void Log::OpenFile()
{
if( !log_file.empty() )
file.open( log_file.c_str(), std::ios_base::out | std::ios_base::app );
}
void Log::PutDate(Manipulators m)
{
time_t t = std::time(0);
std::tm * loct = std::localtime(&t);
char buffer[70];
sprintf(buffer, "%d.%02d.%02d %02d:%02d:%02d ", int(loct->tm_year + 1900),
int(loct->tm_mon + 1),
int(loct->tm_mday),
int(loct->tm_hour),
int(loct->tm_min),
int(loct->tm_sec));
(*this) << m << buffer;
}
Log & Log::operator<<(const char * s)
{
if( !s )
return *this;
buffer << s;
return *this;
}
Log & Log::operator<<(const std::string & s)
{
buffer << s;
return *this;
}
Log & Log::operator<<(const std::string * s)
{
buffer << *s;
return *this;
}
Log & Log::operator<<(const void * s)
{
buffer << s;
return *this;
}
Log & Log::operator<<(int s)
{
buffer << s;
return *this;
}
Log & Log::operator<<(long s)
{
buffer << s;
return *this;
}
Log & Log::operator<<(char s)
{
buffer << s;
return *this;
}
Log & Log::operator<<(size_t s)
{
buffer << s;
return *this;
}
Log & Log::operator<<(double s)
{
buffer << s;
return *this;
}
Log & Log::operator<<(Manipulators m)
{
switch(m)
{
case logend:
buffer << '\n';
lines += 1;
break;
case logsavenow:
SaveLog();
buffer.str( "" );
item = 0;
lines = 0;
break;
case logsave:
item += 1;
if( item >= item_save || lines > 3000 )
{
SaveLog();
buffer.str( "" );
item = 0;
lines = 0;
}
break;
case log1:
current_level = 1;
break;
case log2:
current_level = 2;
break;
case log3:
current_level = 3;
break;
}
return *this;
}
void Log::SystemErr(int err)
{
(*this) << "errno: " << err;
const char * err_msg = strerror(err);
if( err_msg )
(*this) << " (" << err_msg << ")";
}
void Log::SaveLog()
{
if( current_level > log_level )
return;
const std::string & source = buffer.str();
if( source.empty() )
return;
if( log_stdout )
std::cout << source;
if( log_file.empty() )
return;
if( !file )
{
file.close();
file.clear();
OpenFile();
if( !file )
return;
}
file << source << std::endl;
}

View File

@@ -1,69 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2008-2010, Tomasz Sowa
* All rights reserved.
*
*/
#ifndef headerfilecmslucorelog
#define headerfilecmslucorelog
#include <sstream>
#include <fstream>
#include <iostream>
#include <string>
// !! dodac manipulator logsave, logi zostana zapisane pod koniec wykonywania jednego requesta (albo po kilku w zaleznosci od jakiejs opcji w konfigu)
// logsave zostanie wywolane w requestcontroller.cpp przy konczeniu wykonywania requesta
enum Manipulators { logsave, logsavenow, logend, log1, log2, log3 };
class Log
{
std::ostringstream buffer;
int log_level, current_level;
int item, item_save;
std::string log_file;
bool log_stdout;
std::ofstream file;
int lines;
void OpenFile();
public:
Log();
void Init(int log_l, const std::string & log_f, bool log_std, int log_request);
void PutDate(Manipulators m);
Log & operator<<(const char * s);
Log & operator<<(const void * s);
Log & operator<<(const std::string * s);
Log & operator<<(const std::string & s);
Log & operator<<(int s);
Log & operator<<(long s);
Log & operator<<(char s);
Log & operator<<(size_t s);
Log & operator<<(double s);
Log & operator<<(Manipulators m);
void SystemErr(int err);
void SaveLog();
};
extern Log log;
extern Log nlog;
#endif

View File

@@ -1,769 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2008-2010, Tomasz Sowa
* All rights reserved.
*
*/
#include <sys/types.h>
#include <sys/stat.h>
#include "misc.h"
#include "log.h"
#include "data.h"
void ToString(std::string & s, int value)
{
static char buffer[50];
sprintf(buffer, "%d", value);
s = buffer;
}
void ToString(std::string & s, long value)
{
static char buffer[50];
sprintf(buffer, "%ld", value);
s = buffer;
}
bool CorrectUrlChar(char c)
{
if( (c >= 'a' && c <='z') ||
(c >= 'A' && c <='Z') ||
(c >= '0' && c <='9') ||
(c == '(' || c == ')' || c == '.' || c == ',' || c == '_' )
)
{
return true;
}
return false;
}
// this function checks how many dots there are in the url
// if there are more than one (last) dot then the first dots will be changed into '_'
void CorrectUrlDots(std::string & url)
{
size_t i = url.size();
bool was_dot = false;
while( i-- > 0 )
{
if( url[i] == '.' )
{
if( was_dot )
// only one dot is allowed
url[i] = '_';
was_dot = true;
}
}
}
void CorrectUrlChars(std::string & url)
{
std::string::iterator i;
for(i=url.begin(); i != url.end() ; ++i)
{
if( !CorrectUrlChar(*i) )
{
int c = ChangeLocalChar(*i);
if( CorrectUrlChar(c) )
*i = c;
else
*i = '_';
}
}
}
void CorrectUrlOnlyAllowedChar(std::string & url)
{
CorrectUrlDots(url);
CorrectUrlChars(url);
ToSmall(url);
Trim(url, '_');
if( url.empty() || url == "." )
{
if( data.item_url_empty.empty() )
url = "unnamed";
else
{
url = data.item_url_empty;
CorrectUrlDots(url);
CorrectUrlChars(url);
ToSmall(url);
// we don't trim here and the string will not be empty
}
}
if( url[0] >= '0' && url[0] <= '9' )
// url must begin with a letter
url.insert(url.begin(), '_');
}
int polish_letters_simple[] =
{ 'a', 'A',
'c', 'C',
's', 'S',
'e', 'E',
'l', 'L',
'o', 'O',
'z', 'Z',
'z', 'Z',
'n', 'N', 0 }; // 0 - terminating
int polish_letters_iso88592[] =
{ 0xb1, 0xa1,
0xe6, 0xc6,
0xb6, 0xa6,
0xea, 0xca,
0xb3, 0xa3,
0xf3, 0xd3,
0xbf, 0xaf,
0xbc, 0xac,
0xf1, 0xd1, 0 };
int ChangeLocalChar(unsigned char c)
{
// if( language == polish_iso88592 )
for(int i = 0 ; polish_letters_iso88592[i] ; ++i)
{
if( polish_letters_simple[i] == 0 )
{
log << log1 << "localization tables don't have the same size" << logend;
return c;
}
if( polish_letters_iso88592[i] == c )
return polish_letters_simple[i];
}
return c;
}
bool HtmlTryChar(std::ostringstream & out, int c)
{
if( c == '<' )
{
out << "&lt;";
return true;
}
else
if( c == '>' )
{
out << "&gt;";
return true;
}
else
if( c == '&' )
{
out << "&amp;";
return true;
}
return false;
}
void HtmlEscape(std::ostringstream & out, const std::string & in)
{
std::string::const_iterator i;
for(i = in.begin() ; i != in.end() ; ++i)
{
if( !HtmlTryChar(out, *i) )
out << *i;
}
}
std::string HtmlEscape(const std::string & in)
{
std::ostringstream out;
HtmlEscape(out, in);
return out.str();
}
void HtmlEscapeFormTxt(std::ostringstream & out, const std::string & in)
{
std::string::const_iterator i;
int was_enter = 0; // how many enteres there were before
if( in.empty() )
return;
out << "<p>";
// skipping first new line characters
for(i = in.begin() ; i != in.end() && (*i==13 || *i==10) ; ++i);
for( ; i != in.end() ; ++i )
{
if( *i == 13 ) // skipping stupid characters (\r\n\ in dos mode)
continue;
if( *i == 10 )
{
++was_enter;
}
else
{
if( was_enter == 1 )
out << "<br>\n";
else
if( was_enter > 1 )
out << "</p>\n<p>";
was_enter = 0;
}
if( !HtmlTryChar(out, *i) )
out << *i;
}
out << "</p>\n";
}
std::string HtmlEscapeFormTxt(const std::string & in)
{
std::ostringstream out;
HtmlEscapeFormTxt(out, in);
return out.str();
}
const char * DateToStr(int year, int month, int day)
{
static const char * month_letter[] = { "I", "II", "III", "IV", "V", "VI", "VII", "VIII", "IX", "X", "XI", "XII" };
static char buffer[100];
--month;
if( month < 0 )
month = 0;
if( month > 11 )
month = 11;
if( year == 0 )
sprintf(buffer, "%s %02d", month_letter[month], day);
else
sprintf(buffer, "%02d %s %02d", year, month_letter[month], day);
// warning: not thread safe (we do not use threads)
return buffer;
}
const char * DateToStr(int year, int month, int day, int hour, int min, int sec)
{
static const char * month_letter[] = { "I", "II", "III", "IV", "V", "VI", "VII", "VIII", "IX", "X", "XI", "XII" };
static char buffer[100];
--month;
if( month < 0 )
month = 0;
if( month > 11 )
month = 11;
if( year == 0 )
sprintf(buffer, "%s %02d %02d:%02d:%02d", month_letter[month], day, hour, min, sec);
else
sprintf(buffer, "%02d %s %02d %02d:%02d:%02d", year, month_letter[month], day, hour, min, sec);
// warning: not thread safe (we do not use threads)
return buffer;
}
const char * DateToStr(tm * ptm)
{
return DateToStr(ptm->tm_year + 1900, ptm->tm_mon+1, ptm->tm_mday, ptm->tm_hour, ptm->tm_min, ptm->tm_sec);
}
const char * DateToStr(time_t t)
{
tm * ptm = std::localtime(&t);
return DateToStr(ptm);
}
// this format is used with cookies
const char * DateToStrCookie(int year, int month, int day, int hour, int min, int sec)
{
static const char * month_str[]={ "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" };
static char buffer[100];
--month;
if( month < 0 )
month = 0;
if( month > 11 )
month = 11;
sprintf(buffer, "%02d-%s-%04d %02d:%02d:%02d", day, month_str[month], year, hour, min, sec);
return buffer;
}
const char * DateToStrCookie(tm * ptm)
{
return DateToStrCookie(ptm->tm_year + 1900, ptm->tm_mon+1, ptm->tm_mday, ptm->tm_hour, ptm->tm_min, ptm->tm_sec);
}
const char * DateToStrCookie(time_t t)
{
tm * ptm = std::localtime(&t);
return DateToStrCookie(ptm);
}
const char * IpToStr(unsigned int ip_)
{
static char buffer[100];
union
{
unsigned int ip;
unsigned char c[4];
} ip;
ip.ip = ip_;
sprintf(buffer, "%u.%u.%u.%u", (int)ip.c[0], (int)ip.c[1], (int)ip.c[2], (int)ip.c[3]);
return buffer;
}
const char * ToStr(int value)
{
static char buffer[100];
sprintf(buffer, "%d", value);
return buffer;
}
bool IsWhite(int s)
{
if( s==' ' || s=='\t' || s==13 )
return true;
return false;
}
void TrimWhite(std::string & s)
{
std::string::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::string::npos);
// looking for white characters at the beginning
for(i=0 ; i<s.size() && IsWhite(s[i]) ; ++i);
// deleting white characters at the beginning
if( i != 0 )
s.erase(0, i);
}
void Trim(std::string & s, char c)
{
std::string::size_type i;
if( s.empty() )
return;
// looking for the 'c' characters at the end
for(i=s.size()-1 ; i>0 && s[i]==c ; --i);
if( i==0 && s[i]==c )
{
// the whole string has the 'c' characters
s.clear();
return;
}
// deleting 'c' characters at the end
if( i != s.size() - 1 )
s.erase(i+1, std::string::npos);
// looking for the 'c' characters at the beginning
for(i=0 ; i<s.size() && s[i]==c ; ++i);
// deleting the 'c' characters at the beginning
if( i != 0 )
s.erase(0, i);
}
const char * SkipWhite(const char * s)
{
while( IsWhite(*s) )
++s;
return s;
}
int ToSmall(int c)
{
if( c>='A' && c<='Z' )
c = c - 'A' + 'a';
return c;
}
void ToSmall(std::string & s)
{
std::string::size_type i;
for(i=0 ; i<s.size() ; ++i)
s[i] = ToSmall(s[i]);
}
bool IsSubString(const char * short_str, const char * long_str)
{
while( *short_str && *long_str && *short_str == *long_str )
{
++short_str;
++long_str;
}
if( *short_str == 0 )
return true;
return false;
}
bool IsSubStringNoCase(const char * short_str, const char * long_str)
{
while( *short_str && *long_str && ToSmall(*short_str) == ToSmall(*long_str) )
{
++short_str;
++long_str;
}
if( *short_str == 0 )
return true;
return false;
}
bool EqualNoCase(const char * str1, const char * str2)
{
while( *str1 && *str2 && ToSmall(*str1) == ToSmall(*str2) )
{
++str1;
++str2;
}
if( *str1 == 0 && *str2 == 0 )
return true;
return false;
}
bool ValidateEmail(const std::string & email)
{
if( email.empty() )
return false;
bool correct = true;
size_t i;
char allowed_chars[] = "!#$%&'*+-/=?^_`{|}~.@";
int at = 0;
for(i=0 ; i<email.length() && correct ; ++i)
{
correct = false;
if( (email[i] >= 'A' && email[i]<='Z') ||
(email[i] >= 'a' && email[i]<='z') ||
(email[i] >= '0' && email[i]<='9') )
{
correct = true;
}
else
{
for(size_t a=0 ; a < sizeof(allowed_chars)-1 ; ++a)
{
if( email[i] == allowed_chars[a] )
{
correct = true;
break;
}
}
}
if( email[i] == '@' )
++at;
}
if( at != 1 )
return false;
return correct;
}
bool IsFile(const char * file)
{
struct stat sb;
return (stat(file, &sb) == 0);
}
bool IsFile(const std::string & file)
{
return IsFile(file.c_str());
}
bool CreateDir(const char * dir, int priv)
{
if( !IsFile(dir) )
{
if( mkdir(dir, priv) < 0 )
{
log << log1 << "Can't create a directory on fs: " << dir << logend;
return false;
}
}
return true;
}
bool CreateDir(const std::string & dir, int priv)
{
return CreateDir(dir.c_str(), priv);
}
// creating directories (can be more than one)
// 'dirs' can begin with a slash (will be skipped)
bool CreateDirs(const char * base_dir, const char * dirs, int priv)
{
static std::string temp;
const char * p = dirs;
temp = base_dir; // we start creating from 'base_dir'
if( temp.empty() )
return false;
if( temp[temp.size()-1] != '/' )
temp += '/';
while( true )
{
// skipping slashes
for( ; *p=='/' ; ++p );
if( *p == 0 )
break;
// taking the name
for( ; *p && *p!='/' ; ++p )
temp += *p;
if( !CreateDir(temp.c_str(), priv) )
return false;
temp += '/';
}
return true;
}
bool CreateDirs(const std::string & base_dir, const std::string & dirs, int priv)
{
return CreateDirs(base_dir.c_str(), dirs.c_str(), priv);
}
bool CopyFile(FILE * in, FILE * out)
{
char buf[1024];
size_t buflen = sizeof(buf)/sizeof(char);
size_t len;
do
{
len = fread(buf, 1, buflen, in);
if( len > 0 )
fwrite(buf, 1, len, out);
if( ferror(in) || ferror(out) )
return false;
}
while( !feof(in) );
return true;
}
bool CopyFile(const char * src, const char * dst)
{
FILE * in, * out;
in = fopen(src, "rb");
if( !in )
return false;
out = fopen(dst, "wb");
if( !out )
{
fclose(in);
return false;
}
bool res = CopyFile(in, out);
fclose(in);
fclose(out);
if( res && ferror(out) )
res = false;
if( !res )
remove(dst);
return res;
}
bool CopyFile(const std::string & src, const std::string & dst)
{
return CopyFile(src.c_str(), dst.c_str());
}
// if there is not an extension it returns a pointer to the last '\0' character
const char * GetFileExt(const char * name)
{
size_t i, ilast;
// looking for the end of the name
for(i=0 ; name[i] != 0 ; ++i);
if( i == 0 )
return name; // ops, the name is empty
// remember the end of the string
ilast = i;
// looking for the last dot
for(--i ; i>0 && name[i] != '.' ; --i);
if( name[i] != '.' )
return name + ilast; // ops, there is not a dot
// the extensions starts from i+1
// and can be empty (if the last character is a dot)
return name + i + 1;
}
Item::Auth SelectFileType(const char * file_name)
{
const char * ext = GetFileExt(file_name);
// as an image we're using only those types which can be rendered
// by a web browser
if( EqualNoCase(ext, "jpg") ||
EqualNoCase(ext, "jpeg") ||
EqualNoCase(ext, "jpe") ||
EqualNoCase(ext, "pic") ||
EqualNoCase(ext, "tga") ||
EqualNoCase(ext, "gif") ||
EqualNoCase(ext, "bmp") ||
EqualNoCase(ext, "png") )
return Item::auth_image;
if( EqualNoCase(ext, "pdf") ||
EqualNoCase(ext, "doc") ||
EqualNoCase(ext, "xls") ||
EqualNoCase(ext, "txt") ||
EqualNoCase(ext, "ods") ||
EqualNoCase(ext, "odt") )
return Item::auth_document;
return Item::auth_other;
}

View File

@@ -1,74 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2008-2010, Tomasz Sowa
* All rights reserved.
*
*/
#ifndef headerfilecmslucoremisc
#define headerfilecmslucoremisc
#include <string>
#include <sstream>
#include <ctime>
#include "item.h"
#include <cstdio>
void ToString(std::string & s, int value);
void ToString(std::string & s, long value);
int ChangeLocalChar(unsigned char c);
bool CorrectUrlChar(char c);
void CorrectUrlDots(std::string & url);
void CorrectUrlChars(std::string & url);
void CorrectUrlOnlyAllowedChar(std::string & url);
void HtmlEscape(std::ostringstream & out, const std::string & in);
void HtmlEscapeFormTxt(std::ostringstream & out, const std::string & in);
std::string HtmlEscape(const std::string & in);
std::string HtmlEscapeFormTxt(const std::string & in);
const char * DateToStr(int year, int month, int day);
const char * DateToStr(int year, int month, int day, int hour, int min, int sec);
const char * DateToStr(tm * ptm);
const char * DateToStr(time_t t);
const char * DateToStrCookie(int year, int month, int day, int hour, int min, int sec);
const char * DateToStrCookie(tm * ptm);
const char * DateToStrCookie(time_t t);
const char * IpToStr(unsigned int ip_);
bool IsWhite(int s);
void TrimWhite(std::string & s);
void Trim(std::string & s, char c);
int ToSmall(int c);
void ToSmall(std::string & s);
const char * SkipWhite(const char * s);
const char * ToStr(int value);
bool IsSubString(const char * short_str, const char * long_str);
bool IsSubStringNoCase(const char * short_str, const char * long_str);
bool EqualNoCase(const char * str1, const char * str2);
bool ValidateEmail(const std::string & email);
bool IsFile(const char * file);
bool IsFile(const std::string & file);
bool CreateDir(const char * dir, int priv);
bool CreateDir(const std::string & dir, int priv);
bool CreateDirs(const char * base_dir, const char * dirs, int priv);
bool CreateDirs(const std::string & base_dir, const std::string & dirs, int priv);
bool CopyFile(FILE * in, FILE * out);
bool CopyFile(const char * src, const char * dst);
bool CopyFile(const std::string & src, const std::string & dst);
const char * GetFileExt(const char * name);
Item::Auth SelectFileType(const char * file_name);
#endif

View File

@@ -1,191 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2009, Tomasz Sowa
* All rights reserved.
*
*/
#include "mount.h"
Mount::Mount()
{
type = cms;
dir_id = -1;
fs = simplefs;
param.resize(par_none);
}
const char * Mount::TypeToStr()
{
static char buffer[30];
switch( type )
{
case cms:
sprintf(buffer, "cms");
break;
case thread:
sprintf(buffer, "thread");
break;
case ticket:
sprintf(buffer, "ticket");
break;
default:
sprintf(buffer, "unknown");
break;
}
return buffer;
}
const char * Mount::FsToStr()
{
static char buffer[30];
switch( fs )
{
case simplefs:
sprintf(buffer, "simplefs");
break;
case hashfs:
sprintf(buffer, "hashfs");
break;
default:
sprintf(buffer, "unknown");
break;
}
return buffer;
}
Mount::ParamCode Mount::ParseParam(const char * param_name)
{
struct ParName
{
ParamCode param_code;
const char * name;
};
static ParName par_name_tab[] = {
{ par_page, "page" },
{ par_thread, "thread" },
{ par_ticket, "ticket" },
{ par_ticket_type, "ticket_type" },
{ par_ticket_type_default, "ticket_type_default" },
{ par_ticket_status, "ticket_status" },
{ par_ticket_status_default, "ticket_status_default" },
{ par_ticket_priority, "ticket_priority" },
{ par_ticket_priority_default, "ticket_priority_default" },
{ par_ticket_category, "ticket_category" },
{ par_ticket_category_default, "ticket_category_default" },
{ par_ticket_expected, "ticket_expected" },
{ par_ticket_expected_default, "ticket_expected_default" },
{ par_createthread_on, "createthread_on" },
{ par_createticket_on, "createticket_on" },
{ par_only_root_remove, "only_root_remove" },
{ par_emacs_on, "emacs_on" },
{ par_mkdir_on, "mkdir_on" },
{ par_app, "app" },
{ par_html_template, "html_template" },
};
size_t i, len = sizeof(par_name_tab) / sizeof(ParName);
for(i=0 ; i<len ; ++i)
{
if( strcmp(par_name_tab[i].name, param_name) == 0 )
return par_name_tab[i].param_code;
}
return par_none;
}
void Mount::ClearParams()
{
size_t i;
for(i=0 ; i<param.size() ; ++i)
param[i].Clear();
}
bool Mount::IsPar(Mount::ParamCode code)
{
if( !param[code].defined )
return false;
return true;
}
bool Mount::IsArg(Mount::ParamCode code, const char * arg)
{
ParamArg::iterator i;
if( !param[code].defined )
return false;
for(i=param[code].arg.begin() ; i!=param[code].arg.end() ; ++i)
{
if( *i == arg )
return true;
}
return false;
}
bool Mount::IsArg(Mount::ParamCode code, const std::string & arg)
{
return IsArg(code, arg.c_str());
}
bool Mount::IsArg(Mount::ParamCode code, int arg)
{
ParamArg::iterator i;
if( !param[code].defined )
return false;
for(i=param[code].arg.begin() ; i!=param[code].arg.end() ; ++i)
{
if( atoi(i->c_str()) == arg )
return true;
}
return false;
}
const std::string * Mount::HtmlTemplate() const
{
if( !param[par_html_template].defined )
return 0;
if( param[par_html_template].arg.size() != 1 )
return 0;
return & param[par_html_template].arg[0];
}

View File

@@ -1,111 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2009, Tomasz Sowa
* All rights reserved.
*
*/
#ifndef headerfilecmslucoremount
#define headerfilecmslucoremount
#include <map>
#include <string>
#include <vector>
class Mount
{
public:
enum Type
{
cms = 0,
thread,
ticket
};
enum Fs
{
simplefs = 0,
hashfs
};
// the first should be with 0 index
// the last should be 'none'
enum ParamCode
{
par_page = 0,
par_thread,
par_ticket,
par_ticket_type,
par_ticket_type_default,
par_ticket_status,
par_ticket_status_default,
par_ticket_priority,
par_ticket_priority_default,
par_ticket_category,
par_ticket_category_default,
par_ticket_expected,
par_ticket_expected_default,
par_createthread_on,
par_createticket_on,
par_only_root_remove,
par_emacs_on,
par_mkdir_on,
par_app,
par_html_template,
par_none
};
typedef std::vector<std::string> ParamArg;
struct ParamRow
{
bool defined;
ParamArg arg;
ParamRow() { defined = false; }
void Clear() { defined = false; arg.clear(); }
};
typedef std::vector<ParamRow> Param;
Param param;
long dir_id;
Type type;
Fs fs;
Mount();
const char * TypeToStr();
const char * FsToStr();
static ParamCode ParseParam(const char * param);
void ClearParams();
bool IsPar(Mount::ParamCode code);
bool IsArg(Mount::ParamCode code, const char * arg);
bool IsArg(Mount::ParamCode code, const std::string & arg);
bool IsArg(Mount::ParamCode code, int arg);
// returning a name to html template (can be null if not defined)
const std::string * HtmlTemplate() const;
};
#endif

View File

@@ -1,369 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2010, Tomasz Sowa
* All rights reserved.
*
*/
#include "mountparser.h"
#include "data.h"
#include "log.h"
#include "misc.h"
bool MountParser::IsWhite(int c)
{
if( c==' ' || c=='\t' || c==13 )
return true;
return false;
}
void MountParser::SkipWhite()
{
while( IsWhite(*pinput) )
++pinput;
}
void MountParser::SkipLine()
{
while( *pinput && *pinput != 10 )
++pinput;
if( *pinput == 10 )
++pinput;
}
void MountParser::ReadWordQuote(std::string & res)
{
++pinput;
while( *pinput && *pinput!=10 && *pinput!='\"' )
{
if( pinput[0]=='\\' && pinput[1]=='\"' )
{
res += '\"';
pinput += 2;
}
else
if( pinput[0]=='\\' && pinput[1]=='\\' )
{
res += '\\';
pinput += 2;
}
else
{
res += *pinput;
pinput += 1;
}
}
if( *pinput == '"' )
++pinput;
}
// a white character is the separator
void MountParser::ReadWordWhite(std::string & res)
{
while( *pinput && *pinput!=10 && !IsWhite(*pinput) )
{
res += *pinput;
++pinput;
}
}
// the comma or the second bracket ')' are the separators
void MountParser::ReadWordComma(std::string & res)
{
while( *pinput && *pinput!=10 && *pinput!=',' && *pinput!=')' )
{
res += *pinput;
++pinput;
}
// trimming last white characters
// (white characters can be in the middle of the string)
TrimWhite(res);
}
void MountParser::ReadWord(std::string & res, bool comma_bracket_separator)
{
res.clear();
SkipWhite();
if( *pinput == '"' )
{
ReadWordQuote(res);
}
else
if( comma_bracket_separator )
{
ReadWordComma(res);
}
else
{
ReadWordWhite(res);
}
}
void MountParser::ReadParamArgsLoop(Mount::ParamArg & args)
{
SkipWhite();
while( *pinput && *pinput!=10 && *pinput!=')' )
{
ReadWord(temp_arg, true);
if( !temp_arg.empty() )
args.push_back(temp_arg);
if( *pinput == ',' )
++pinput;
}
}
void MountParser::ReadParamArgs(Mount::ParamArg & args)
{
SkipWhite();
args.clear();
if( *pinput == '(' )
{
++pinput;
ReadParamArgsLoop(args);
if( *pinput != ')' )
{
// there should be ')' at the end
// temporarily we do nothing
}
else
{
++pinput;
}
}
}
void MountParser::ReadParamName(std::string & res)
{
SkipWhite();
res.clear();
while( *pinput && *pinput!=10 && *pinput!=',' && *pinput!='(' && !IsWhite(*pinput) )
{
res += *pinput;
++pinput;
}
}
void MountParser::ReadParam(std::string & res, Mount::ParamArg & args)
{
ReadParamName(res);
if( res.empty() )
return;
ReadParamArgs(args);
SkipWhite();
if( *pinput == ',' )
++pinput;
}
void MountParser::ReadMountType()
{
ReadWord(temp);
if( temp.empty() )
{
// an empty line (some white characters only)
err = WINIX_ERR_EMPTY;
}
else
if( temp == "cms" )
{
mount.type = Mount::cms;
log << log3 << "MP: mount type: cms" << logend;
}
else
if( temp == "thread" )
{
mount.type = Mount::thread;
log << log3 << "MP: mount type: thread" << logend;
}
else
if( temp == "ticket" )
{
mount.type = Mount::ticket;
log << log3 << "MP: mount type: ticket" << logend;
}
else
{
err = WINIX_ERR_MOUNT_UNKNOWN;
log << log1 << "MP: unknown mount type: " << temp << logend;
}
}
void MountParser::ReadMountPoint()
{
ReadWord(temp);
pdir = data.dirs.GetDir(temp);
if( pdir )
{
mount.dir_id = pdir->id;
log << log3 << "MP: mount point: " << temp << logend;
}
else
{
err = WINIX_ERR_NO_MOUNTPOINT;
log << log1 << "MP: there is no such a mount point: " << temp << logend;
}
}
void MountParser::ReadFs()
{
ReadWord(temp);
if( temp == "simplefs" )
{
mount.fs = Mount::simplefs;
log << log1 << "MP: file system: simplefs" << logend;
}
else
if( temp == "hashfs" )
{
mount.fs = Mount::hashfs;
log << log1 << "MP: file system: hashfs" << logend;
}
else
{
err = WINIX_ERR_UNKNOWN_FILESYSTEM;
log << log1 << "MP: unknown filesystem: " << temp << logend;
}
}
void MountParser::LogMountParams()
{
size_t i;
log << log3 << "MP: mount param: " << temp << "(";
for(i=0 ; i<param_args.size() ; ++i)
{
log << param_args[i];
if( i != param_args.size()-1 )
log << ",";
}
log << ")" << logend;
}
void MountParser::ReadMountParams()
{
mount.ClearParams();
for( ReadParam(temp, param_args) ; !temp.empty() ; ReadParam(temp, param_args) )
{
Mount::ParamCode p = Mount::ParseParam(temp.c_str());
if( p != Mount::par_none )
{
mount.param[p].defined = true;
mount.param[p].arg = param_args;
LogMountParams();
}
else
{
log << log1 << "MP: unknown mount param: " << temp << " (skipped)" << logend;
}
}
}
void MountParser::ReadRow(std::map<long, Mount> & output)
{
ReadMountType();
if( err == WINIX_ERR_EMPTY )
{
err = WINIX_ERR_OK;
SkipLine();
return;
}
if( err == WINIX_ERR_OK )
ReadMountPoint();
if( err == WINIX_ERR_OK )
ReadFs();
if( err == WINIX_ERR_OK )
ReadMountParams();
if( err == WINIX_ERR_OK )
{
std::pair<std::map<long, Mount>::iterator, bool> res = output.insert( std::make_pair(mount.dir_id, mount) );
if( !res.second )
log << log1 << "MP: this mount point exists (skipped)" << logend;
}
SkipLine();
}
Error MountParser::Parse(const std::string & input, std::map<long, Mount> & output)
{
pinput = input.c_str();
err = WINIX_ERR_OK;
output.clear();
while( *pinput && err == WINIX_ERR_OK )
ReadRow(output);
return err;
}

View File

@@ -1,65 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2010, Tomasz Sowa
* All rights reserved.
*
*/
#ifndef headerfilecmslucoremountparser
#define headerfilecmslucoremountparser
#include <map>
#include <string>
#include <vector>
#include <stdlib.h>
#include <limits.h>
#include "mount.h"
#include "item.h"
#include "error.h"
class MountParser
{
public:
Error Parse(const std::string & input, std::map<long, Mount> & output);
private:
bool IsWhite(int c);
void SkipWhite();
void SkipLine();
void ReadWordQuote(std::string & res);
void ReadWordWhite(std::string & res);
void ReadWordComma(std::string & res);
void ReadWord(std::string & res, bool comma_bracket_separator = false);
void ReadParamArgsLoop(Mount::ParamArg & args);
void ReadParamArgs(Mount::ParamArg & args);
void ReadParamName(std::string & res);
void ReadParam(std::string & res, Mount::ParamArg & args);
void ReadMountType();
void ReadMountPoint();
void ReadFs();
void LogMountParams();
void ReadMountParams();
void ReadRow(std::map<long, Mount> & output);
const char * pinput;
std::string temp;
std::string temp_arg;
Mount::ParamArg param_args;
Mount mount;
Item * pdir;
Error err;
};
#endif

View File

@@ -1,158 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2009, Tomasz Sowa
* All rights reserved.
*
*/
#include "mounts.h"
#include "data.h"
#include "request.h"
#include "log.h"
#include "mountparser.h"
#include "db.h"
Mounts::Mounts()
{
pmount = 0;
}
// reading from 'mounts'
Error Mounts::ReadMounts(const std::string & mounts)
{
MountParser mp;
Error err = mp.Parse(mounts, mount_tab);
if( err != WINIX_ERR_OK )
{
log << log1 << "M: some problems with mountpoints (mountpoints table will be empty)" << logend;
mount_tab.clear();
}
CalcCurMount();
return err;
}
// reading from /etc/fstab
Error Mounts::ReadMounts()
{
static std::string file = "fstab";
Item * etc = data.dirs.GetEtcDir();
if( !etc )
{
log << log1 << "M: there is no /etc directory" << logend;
return WINIX_ERR_NO_ITEM;
}
Item fstab;
Error err = db.GetItem(etc->id, file, fstab);
if( err == WINIX_ERR_NO_ITEM )
{
log << log1 << "M: there is no /etc/fstab file" << logend;
return err;
}
if( err != WINIX_ERR_OK )
{
log << log1 << "M: cannot read /etc/fstab" << logend;
return err;
}
return ReadMounts(fstab.content);
}
void Mounts::MountCmsForRoot()
{
Mount mount;
mount.type = Mount::cms;
mount.fs = Mount::simplefs;
Item * proot = data.dirs.GetRootDir();
if( proot )
mount.dir_id = proot->id;
else
{
mount.dir_id = -1;
log << log1 << "M: there is no a root dir" << logend;
}
std::pair<MountTab::iterator, bool> res = mount_tab.insert( std::make_pair(mount.dir_id, mount) );
pmount = &(res.first->second);
}
void Mounts::CalcCurMount()
{
std::vector<Item*>::reverse_iterator i;
// when the program starts (when the dir_table is empty()
// we don't want to call MountCmsForRoot()
if( request.dir_table.empty() )
return;
for(i = request.dir_table.rbegin() ; i!=request.dir_table.rend() ; ++i)
{
std::map<long, Mount>::iterator m = mount_tab.find( (*i)->id );
if( m != mount_tab.end() )
{
pmount = &(m->second);
log << log2 << "M: current mount point is: " << pmount->TypeToStr()
<< ", fs: " << pmount->FsToStr() << logend;
return;
}
}
// if nothing was found
// we assume that 'cms' mount point is used
MountCmsForRoot();
log << log2 << "M: current mount point is: " << pmount->TypeToStr() << " (default)"
<< ", fs: " << pmount->FsToStr() << logend;
}
// can return null pointer
// and we don't assume cms as a default mount point if nothing is found
Mount * Mounts::CalcMount(long dir_id)
{
while( true )
{
Item * pdir = data.dirs.GetDir(dir_id);
if( !pdir )
return 0;
std::map<long, Mount>::iterator m = mount_tab.find( pdir->id );
if( m != mount_tab.end() )
return &(m->second);
dir_id = pdir->parent_id;
}
}
const Mounts::MountTab * Mounts::GetMountTab()
{
return &mount_tab;
}

View File

@@ -1,51 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2009, Tomasz Sowa
* All rights reserved.
*
*/
#ifndef headerfilecmslucorecoremounts
#define headerfilecmslucorecoremounts
#include <map>
#include <string>
#include "mount.h"
#include "error.h"
class Mounts
{
public:
// dir_id, mount_point
typedef std::map<long, Mount> MountTab;
Mounts();
Error ReadMounts(const std::string & mounts);
Error ReadMounts();
void CalcCurMount();
Mount * CalcMount(long dir_id);
// current mount point
// will not be null after calling CalcCurMount() or ReadMounts([...])
Mount * pmount;
const MountTab * GetMountTab();
private:
MountTab mount_tab;
void MountCmsForRoot();
};
#endif

View File

@@ -1,265 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2008-2010, Tomasz Sowa
* All rights reserved.
*
*/
#include <pthread.h>
#include <unistd.h>
#include "log.h"
#include "notify.h"
#include "data.h"
#include "misc.h"
#include "request.h"
// the second thread uses this pointer to reference to 'this'
// (methods for the thread should be static)
Notify * Notify::obj;
/*
methods for the second thread
the thread can reference to 'this' by using 'obj' pointer
*/
void * Notify::ThreadRoutine(void * arg)
{
obj = (Notify*)arg;
while( true )
{
CheckQueue();
sleep(30);
}
}
void Notify::CheckQueue()
{
std::list<NotifyMsg>::iterator i = obj->notify_pool.begin();
while( i != obj->notify_pool.end() )
{
SendEmail(*i);
obj->Lock();
i = obj->notify_pool.erase(i);
obj->Unlock();
sleep(3);
}
}
void Notify::SendEmail(NotifyMsg & n)
{
TemplatesNotifyFunctions::notify_msg = &n;
obj->Lock(); // templates can be reloaded from the first thread
obj->templates_notify.Generate(n.lang);
obj->Unlock();
SendEmail(n.email, obj->templates_notify.notify_str.str());
}
void Notify::SendEmail(const std::string & email, const std::string & message)
{
nlog.PutDate(log1);
if( !ValidateEmail(email) )
{
nlog << "Notify: email: " << email << " is not correct" << logend;
return;
}
obj->command = "sendmail " + email;
FILE * sendmail = popen(obj->command.c_str(), "w");
if( !sendmail )
{
nlog << "Notify: can't run sendmail" << logend;
return;
}
SendMessage(sendmail, message);
pclose(sendmail);
nlog << "Notify: email to: " << email << " has been sent" << logend;
nlog << logsave;
}
void Notify::SendMessage(FILE * sendmail, const std::string & message)
{
for(size_t i=0 ; i<message.length() ; ++i)
{
if( message[i] == '\n' )
fprintf(sendmail, "\r\n");
else
fputc(message[i], sendmail);
}
}
/*
methods for main thread
*/
Notify::Notify() : mutex(PTHREAD_MUTEX_INITIALIZER)
{
}
Notify::~Notify()
{
}
void Notify::ReadTemplates()
{
// we are in the first thread here
// the second thread can use our templates and we must Lock()
// (the second thread is using Lock() too)
Lock();
templates_notify.Read();
Unlock();
}
bool Notify::Init()
{
templates_notify.CreateFunctions();
int t = pthread_create(&thread, 0, ThreadRoutine, (void*)this);
if( t != 0 )
{
// log (not nlog) here
log << log1 << "Notify: can't create a thread" << logend;
return false;
}
return true;
}
bool Notify::Lock()
{
if( pthread_mutex_lock(&mutex) != 0 )
return false;
return true;
}
void Notify::Unlock()
{
pthread_mutex_unlock(&mutex);
}
void Notify::CreateItemDir(std::string & dir, bool clear)
{
if( clear )
dir.clear();
for(size_t a=0 ; a<request.dir_table.size() ; ++a)
{
dir += request.dir_table[a]->url;
dir += '/';
}
}
void Notify::CreateItemLink(std::string & link)
{
link = data.base_url;
CreateItemDir(link, false);
link += request.item.url;
}
void Notify::ItemChanged(int notify_code)
{
bool sending;
Users::Iterator i;
if( notify_code == 0 )
return;
n.notify_code = notify_code;
n.current_mount_type = data.mounts.pmount->type;
n.doc_base_url = data.base_url;
CreateItemDir(n.item_dir);
CreateItemLink(n.item_link);
Lock();
try
{
// don't clear notify_pool here -- it is used (and will be cleared) by the second thread
for(i=data.users.Begin() ; i != data.users.End() ; ++i)
{
sending = false;
if( data.mounts.pmount->type == Mount::thread )
{
if( (i->thread_notify & notify_code) != 0 )
sending = true;
}
else
if( data.mounts.pmount->type == Mount::cms )
{
if( (i->cms_notify & notify_code) != 0 )
sending = true;
}
if( sending )
{
n.email = i->email;
n.lang = Locale::StrToLang(data.locale_str);// !! bedzie osobno dla kazdego uzytkownika
if( n.lang == Locale::lang_unknown )
n.lang = Locale::lang_en;
notify_pool.insert(notify_pool.end(), n);
}
}
}
catch(...)
{
Unlock();
throw;
}
Unlock();
}

View File

@@ -1,77 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2008-2010, Tomasz Sowa
* All rights reserved.
*
*/
#ifndef headerfilecmslunotify
#define headerfilecmslunotify
#include <list>
#include <string>
#include <cstdio>
#include "../templatesnotify/templatesnotify.h"
#define WINIX_NOTIFY_ITEM_ADD 1
#define WINIX_NOTIFY_ITEM_EDIT 2
#define WINIX_NOTIFY_ITEM_DELETE 4
#define WINIX_NOTIFY_DIR_ADD 8
class Notify
{
public:
Notify();
~Notify();
void ReadTemplates();
bool Init();
/*
this method addes an item to our special pool
the pool is used by a second thread
*/
void ItemChanged(int notify_code);
private:
static void * ThreadRoutine(void * arg);
bool Lock();
void Unlock();
static void CheckQueue();
static void SendEmail(NotifyMsg & n);
static void SendEmail(const std::string & email);
static void SendEmail(const std::string & email, const std::string & message);
static void SendMessage(FILE * sendmail, const std::string & message);
void CreateItemDir(std::string & dir, bool clear = true);
void CreateItemLink(std::string & link);
pthread_t thread;
pthread_mutex_t mutex;
NotifyMsg n;
/*
objects accessed by the second thread
*/
std::list<NotifyMsg> notify_pool;
static Notify * obj;
std::string command;
TemplatesNotify templates_notify;
};
extern Notify notify;
#endif

View File

@@ -1,156 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2008-2010, Tomasz Sowa
* All rights reserved.
*
*/
#include <dlfcn.h>
#include "plugin.h"
#include "pluginmsg.h"
void Plugin::UnloadPlugins()
{
size_t i;
slots.clear();
for(i=0 ; i<plugins.size() ; ++i)
dlclose(plugins[i]);
plugins.clear();
}
Plugin::Plugin()
{
current_plugin = -1;
}
Plugin::~Plugin()
{
UnloadPlugins();
}
void Plugin::LoadPlugins(const std::vector<std::string> & plugins)
{
size_t i;
for(i=0 ; i<plugins.size() ; ++i)
LoadPlugin(plugins[i]);
}
void Plugin::LoadPlugin(const std::string & filename)
{
LoadPlugin(filename.c_str());
}
void Plugin::LoadPlugin(const char * filename)
{
void * p = dlopen(filename, RTLD_NOW | RTLD_LOCAL);
if( !p )
{
log << log1 << "Pl: cannot load a plugin: " << filename << logend;
/*
const char * t = dlerror();
if( t )
log << log1 << t << logend;
*/
return;
}
Fun fun = (Fun)dlfunc(p, "Init");
if( !fun )
{
log << log1 << "Pl: cannot load a plugin: " << filename << " (there is no Init() function)" << logend;
dlclose(p);
return;
}
arg.Clear();
int old_current_plugin = current_plugin;
current_plugin = (int)plugins.size();
arg.plugin_id = current_plugin;
if( fun(&arg) )
{
log << log1 << "Pl: plugin loaded: " << filename << ", index: " << plugins.size() << logend;
plugins.push_back(p);
}
else
{
log << log1 << "Pl: plugin Init() returned false (" << filename << ") " << logend;
dlclose(p);
}
current_plugin = old_current_plugin;
}
Arg * Plugin::Call(int message, void * a, void * a2, void * a3)
{
Slots::iterator i = slots.lower_bound(message);
arg.Clear();
int old_current_plugin = current_plugin;
for( ; i!=slots.end() && i->first==message ; ++i )
{
arg.app = a;
arg.app2 = a2;
arg.app3 = a3;
current_plugin = i->second.index;
arg.plugin_id = current_plugin;
if( request.session && current_plugin != -1 )
arg.plugin_data_base = request.session->plugin_data.Get(current_plugin);
else
arg.plugin_data_base = 0;
if( i->second.fun(&arg) )
arg.ret_true++;
else
arg.ret_false++;
}
current_plugin = old_current_plugin;
return &arg;
}
size_t Plugin::Size()
{
return plugins.size();
}
void Plugin::Assign(int message, Fun fun)
{
Slot s;
s.fun = fun;
s.index = current_plugin;
slots.insert( std::make_pair(message, s) );
log << log3 << "Plugin: added function for message: " << message << ", plugin index: " << s.index << logend;
}

View File

@@ -1,109 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2008-2010, Tomasz Sowa
* All rights reserved.
*
*/
#ifndef headerfilecmsluplugin
#define headerfilecmsluplugin
#include <vector>
#include <string>
#include <map>
#include "request.h"
#include "data.h"
#include "pluginmsg.h"
#include "log.h"
#include "plugindata.h"
// plugin arguments
struct Arg
{
void * app; // used for some purposes
void * app2; // used for some purposes
void * app3; // used for some purposes
int plugin_id; // unique plugin identifier
PluginDataBase * plugin_data_base; // pointer to the plugin session
int ret_true; // how many plugins returned true
int ret_false; // how many plugins returned false
void Clear()
{
app = 0;
app2 = 0;
app3 = 0;
ret_true = 0;
ret_false = 0;
plugin_data_base = 0;
}
};
class Plugin
{
public:
// index of a plugin which is called by Call() method
// normally: -1
int current_plugin;
// !! zmienic sygnature funkcji (niech nie zwraca zadnej wartosci, bo to tylko wkurwia)
// albo dodac jeszcze inna sygnature (niech nie pobiera zadnego argumentu)
typedef bool (*Fun)(Arg *);
//typedef void (*Fun2)();
struct Slot
{
Fun fun;
// Fun2 fun2; // dla drugiej sygnatury
int index; // plugin index
};
Plugin();
~Plugin();
void LoadPlugin(const char * filename);
void LoadPlugin(const std::string & filename);
void LoadPlugins(const std::vector<std::string> & plugins);
void UnloadPlugins();
Arg * Call(int message, void * a=0, void * a2=0, void * a3=0);
size_t Size();
void Assign(int message, Fun);
private:
typedef std::vector<void*> Plugins;
Plugins plugins;
typedef std::multimap<int, Slot> Slots;
Slots slots;
Arg arg;
};
extern Plugin plugin;
#endif

View File

@@ -1,125 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2008-2010, Tomasz Sowa
* All rights reserved.
*
*/
#include "plugindata.h"
#include "plugin.h"
#include "log.h"
void PluginData::Assign(size_t index, PluginDataBase * data)
{
if( index >= table.size() )
Resize(index+1);
table[index] = data;
}
void PluginData::Assign(PluginDataBase * data)
{
if( plugin.current_plugin == -1 )
{
log << log1 << "PD: Assign(PluginDataBase*) should be called only from plugins" << logend;
return;
}
Assign(plugin.current_plugin, data);
}
PluginDataBase * PluginData::Get(size_t index)
{
if( index >= table.size() )
Resize(index+1);
return table[index];
}
PluginDataBase * PluginData::Get()
{
if( plugin.current_plugin == -1 )
{
log << log1 << "PD: Get() should be called only from plugins" << logend;
return 0;
}
return Get(plugin.current_plugin);
}
void PluginData::DeleteAll()
{
if( table.empty() )
return;
plugin.Call(WINIX_SESSION_REMOVE);
for(size_t i=0 ; i<table.size() ; ++i)
table[i] = 0;
}
PluginData::PluginData()
{
}
PluginData::PluginData(const PluginData & p)
{
operator=(p);
}
PluginData & PluginData::operator=(const PluginData & p)
{
// we don't copy all pointers - only resize the table
// pointers will be set to zero
Resize(p.Size());
return *this;
}
PluginData::~PluginData()
{
DeleteAll();
}
size_t PluginData::Size() const
{
return table.size();
}
void PluginData::Resize(size_t new_size)
{
size_t old_size = table.size();
if( old_size == new_size )
return;
table.resize(new_size);
for(size_t i = old_size ; i<new_size ; ++i)
table[i] = 0;
}

View File

@@ -1,56 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2008-2010, Tomasz Sowa
* All rights reserved.
*
*/
#ifndef headerfilecmslucoreplugindata
#define headerfilecmslucoreplugindata
#include <vector>
struct PluginDataBase
{
virtual ~PluginDataBase() {}
};
class PluginData
{
public:
void Assign(size_t index, PluginDataBase * data);
void Assign(PluginDataBase * data);
PluginDataBase * Get(size_t index);
PluginDataBase * Get();
void DeleteAll();
PluginData();
PluginData(const PluginData & p);
PluginData & operator=(const PluginData & p);
~PluginData();
size_t Size() const;
void Resize(size_t new_size);
private:
std::vector<PluginDataBase*> table;
};
#endif

View File

@@ -1,39 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2008-2010, Tomasz Sowa
* All rights reserved.
*
*/
#ifndef headerfilecmslupluginmsg
#define headerfilecmslupluginmsg
#define WINIX_TEMPLATES_CREATEFUNCTIONS 999
#define WINIX_REQUEST_CLEAR 1000
#define WINIX_CONTENT_MAKE 2000
// here you can attach your own session data (based on PluginDataBase class)
// call request.session->plugin_data.Assign(pointer)
#define WINIX_SESSION_CREATED 3000
// here you should remove your session data
#define WINIX_SESSION_REMOVE 3001
// when a session is changed (you can save a pointer to your data here)
#define WINIX_SESSION_CHANGED 3002
#endif

View File

@@ -1,93 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2008-2010, Tomasz Sowa
* All rights reserved.
*
*/
#ifndef headerfilecmslucorepostmultiparser
#define headerfilecmslucorepostmultiparser
#include <string>
#include <fcgiapp.h>
#include <fstream>
#include "error.h"
#include "requesttypes.h"
// 2 MB
#define WINIX_POSTMULTI_INPUT_BUFFER 2097152
#define WINIX_POSTMULTI_OUTPUT_BUFFER 2097152
class PostMultiParser
{
public:
PostMultiParser();
PostMultiParser(const PostMultiParser &);
PostMultiParser & operator=(const PostMultiParser &);
~PostMultiParser();
Error Parse(FCGX_Stream * in_, PostTable & post_table_, PostFileTable & post_file_table_);
private:
FCGX_Stream * in;
unsigned char * in_buffer;
std::ofstream tmp_file;
std::string tmp_filename;
int tmp_filename_postfix;
size_t in_buffer_ind;
size_t in_buffer_len;
PostTable * post_table;
PostFileTable * post_file_table;
int last; // last read character
bool line_end_dos;
std::string boundary;
std::string content;
size_t content_len;
std::string header_name, header_value;
Error err;
std::string name, filename;
PostFile post_file_temp;
void LogFirst(const std::string & to_log, size_t len);
bool IsWhite(int c);
void SkipWhite();
void AddNormalPostVar();
void AddFilePostVar();
void AddPostVar();
void ReadBoundary();
bool IsHeader();
void ReadHeaderName();
void ReadHeaderValue();
void ReadPartHeader();
void CreateTmpFile();
bool HasBoundary();
void ReadContentSkipBoundary(bool has_boundary);
void ReadContentToFileLoop();
void ReadContentToFile();
void ReadContentLoop();
void ReadContent();
void CheckBoundaryEnd();
void ReadPart();
void ReadChar();
};
#endif

View File

@@ -1,58 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2008-2010, Tomasz Sowa
* All rights reserved.
*
*/
#ifndef headerfilecmslucorepostparser
#define headerfilecmslucorepostparser
#include <fcgiapp.h>
#include <string>
#include "httpsimpleparser.h"
#include "requesttypes.h"
class PostParser : public HttpSimpleParser
{
FCGX_Stream * in;
PostTable & post_table;
protected:
virtual int GetChar()
{
return FCGX_GetChar(in);
}
virtual void Parameter(std::string & name, std::string & value)
{
std::pair<PostTable::iterator, bool> res = post_table.insert( std::make_pair(name, value) );
log << log2 << "Method POST, name: \"" << name << "\", value: \"" << value << "\"";
if( res.second == false )
log << log2 << " (skipped)";
log << log2 << logend;
}
public:
PostParser(FCGX_Stream * in_, PostTable & post_table_) : in(in_), post_table(post_table_)
{
}
};
#endif

Some files were not shown because too many files have changed in this diff Show More