129 Commits

Author SHA1 Message Date
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
727 changed files with 53679 additions and 26576 deletions

6
.gitignore vendored Normal file
View File

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

155
Makefile
View File

@@ -1,155 +0,0 @@
# Makefile for GNU make
include Makefile.dep
#ifndef CXX
# temporarily workaround: forcing using clang (CXX is defined by the OS and is equal to g++)
CXX = clang++
#endif
ifndef CXXFLAGS
CXXFLAGS = -Wall -O2 -fPIC -pthread -std=c++11 -I/usr/local/include -DEZC_USE_WINIX_LOGGER -DEZC_HAS_SPECIAL_STREAM
endif
ifndef CXXWINIXINCLUDEFLAGS
# these flags are used for compiling and making dependencies (make depend)
# it's better to not using any system directories like -I/usr/local/include here
CXXWINIXINCLUDEFLAGS = -I../../winix -I../../../winix -I../../ezc/src -I../../../ezc/src -I../../tito/src -I../../../tito/src -I../../pikotools -I../../../pikotools
endif
ifndef LDFLAGS
LDFLAGS = -L/usr/local/lib
endif
# this macro is used in ezc's Makefile
EZC_USE_WINIX_LOGGER = yes
# for make install
winix_install_dir = /usr/local/winix
export CXX
export CXXFLAGS
export CXXWINIXINCLUDEFLAGS
export LDFLAGS
export EZC_USE_WINIX_LOGGER
all: winix.so plugins winix
winix.so: $(winix.src.files)
@cd core ; $(MAKE) -e
@cd db ; $(MAKE) -e
@cd functions ; $(MAKE) -e
@cd notify ; $(MAKE) -e
@cd templates ; $(MAKE) -e
@cd ../ezc/src ; $(MAKE) -e
@cd ../tito/src ; $(MAKE) -e
@cd ../pikotools ; $(MAKE) -e
$(CXX) -shared -rdynamic -Wl,-whole-archive -o winix.so $(CXXFLAGS) $(CXXWINIXINCLUDEFLAGS) core/*.o db/*.o functions/*.o templates/*.o notify/*.o ../ezc/src/ezc.a ../tito/src/tito.a ../pikotools/utf8/utf8.a ../pikotools/space/space.a ../pikotools/mainparser/mainparser.a ../pikotools/date/date.a $(LDFLAGS) -lfcgi -lpq -lz -lfetch -lpthread -Wl,-no-whole-archive
winix: winix.so $(winix.src.files)
@cd main ; $(MAKE) -e
$(CXX) -o winix $(CXXFLAGS) $(LDFLAGS) main/*.o winix.so
plugins: FORCE
@cd plugins/stats ; $(MAKE) -e
@cd plugins/thread ; $(MAKE) -e
@cd plugins/ticket ; $(MAKE) -e
@cd plugins/gallery ; $(MAKE) -e
@cd plugins/group ; $(MAKE) -e
@cd plugins/menu ; $(MAKE) -e
@cd plugins/export ; $(MAKE) -e
FORCE:
clean:
@cd core ; $(MAKE) -e clean
@cd db ; $(MAKE) -e clean
@cd functions ; $(MAKE) -e clean
@cd templates ; $(MAKE) -e clean
@cd notify ; $(MAKE) -e clean
@cd plugins/stats ; $(MAKE) -e clean
@cd plugins/thread ; $(MAKE) -e clean
@cd plugins/ticket ; $(MAKE) -e clean
@cd plugins/gallery ; $(MAKE) -e clean
@cd plugins/group ; $(MAKE) -e clean
@cd plugins/menu ; $(MAKE) -e clean
@cd plugins/export ; $(MAKE) -e clean
@cd ../ezc/src ; $(MAKE) -e clean
@cd ../tito/src ; $(MAKE) -e clean
@cd ../pikotools ; $(MAKE) -e clean
@cd main ; $(MAKE) -e clean
rm -f winix.so
rm -f winix
depend:
@cd core ; $(MAKE) -e depend
@cd db ; $(MAKE) -e depend
@cd functions ; $(MAKE) -e depend
@cd templates ; $(MAKE) -e depend
@cd notify ; $(MAKE) -e depend
@cd plugins/stats ; $(MAKE) -e depend
@cd plugins/thread ; $(MAKE) -e depend
@cd plugins/ticket ; $(MAKE) -e depend
@cd plugins/gallery ; $(MAKE) -e depend
@cd plugins/group ; $(MAKE) -e depend
@cd plugins/menu ; $(MAKE) -e depend
@cd plugins/export ; $(MAKE) -e depend
@cd ../ezc/src ; $(MAKE) -e depend
@cd ../tito/src ; $(MAKE) -e depend
@cd ../pikotools ; $(MAKE) -e depend
@cd main ; $(MAKE) -e depend
echo -n "winix.src.files = " > Makefile.dep
find -E . -type f -regex ".*\.h|.*\.cpp" | xargs -I foo echo -n foo " " >> Makefile.dep
find -E ../ezc/src -type f -regex ".*\.h|.*\.cpp" | xargs -I foo echo -n foo " " >> Makefile.dep
find -E ../tito/src -type f -regex ".*\.h|.*\.cpp" | xargs -I foo echo -n foo " " >> Makefile.dep
find -E ../pikotools -type f -regex ".*\.h|.*\.cpp" | xargs -I foo echo -n foo " " >> Makefile.dep
install: all
# installing binaries
rm -Rf $(winix_install_dir)/bin
mkdir -p $(winix_install_dir)/bin
cp winix $(winix_install_dir)/bin
cp winix.so $(winix_install_dir)/bin
# etc configs
rm -Rf $(winix_install_dir)/etc
mkdir -p $(winix_install_dir)/etc
cp -rf etc/ $(winix_install_dir)/etc/
# html templates
rm -Rf $(winix_install_dir)/html
mkdir -p $(winix_install_dir)/html
cp -rf html/ $(winix_install_dir)/html/
# txt templates
rm -Rf $(winix_install_dir)/txt
mkdir -p $(winix_install_dir)/txt
cp -rf txt/ $(winix_install_dir)/txt/
# locales
rm -Rf $(winix_install_dir)/locale
mkdir -p $(winix_install_dir)/locale
cp -rf locale/ $(winix_install_dir)/locale/
# plugins
rm -Rf $(winix_install_dir)/plugins
mkdir -p $(winix_install_dir)/plugins
find plugins/ -name "*.so" | xargs -I foo cp foo $(winix_install_dir)/plugins/
# deleting subversion directories
find $(winix_install_dir) -type d -name ".svn" | xargs -I foo rm -fr foo
# removing privileges for others
find $(winix_install_dir) -exec chmod o-r,o-x,o-w "{}" "+"

File diff suppressed because one or more lines are too long

View File

@@ -1,19 +0,0 @@
include Makefile.o.dep
all: $(o)
%.o: %.cpp
$(CXX) -c $(CXXFLAGS) $(CXXWINIXINCLUDEFLAGS) $<
depend:
makedepend -Y. $(CXXWINIXINCLUDEFLAGS) -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

File diff suppressed because it is too large Load Diff

View File

@@ -1 +0,0 @@
o = acceptbaseparser.o app.o basethread.o bbcodeparser.o compress.o config.o crypt.o dircontainer.o dirs.o groups.o htmlfilter.o httpsimpleparser.o image.o ipbancontainer.o item.o job.o lastcontainer.o loadavg.o lock.o log.o misc.o mount.o mountparser.o mounts.o plugin.o plugindata.o postmultiparser.o rebus.o request.o run.o session.o sessioncontainer.o sessionmanager.o sessionparser.o slog.o synchro.o system.o threadmanager.o timezone.o timezones.o user.o users.o

View File

@@ -1,114 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2008-2013, Tomasz Sowa
* All rights reserved.
*
*/
#include <cstdlib>
#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-2011, Tomasz Sowa
* All rights reserved.
*
*/
#ifndef headerfile_winix_core_acceptbaseparser
#define headerfile_winix_core_acceptbaseparser
#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,85 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2008-2011, Tomasz Sowa
* All rights reserved.
*
*/
#ifndef headerfile_winix_core_acceptencodingparser
#define headerfile_winix_core_acceptencodingparser
#include "acceptbaseparser.h"
#include "log.h"
class AcceptEncodingParser : public AcceptBaseParser
{
public:
bool AcceptDeflate()
{
return accept_deflate;
}
bool AcceptGzip()
{
return accept_gzip;
}
void ParseAndLog(const char * str)
{
Parse(str);
if( accept_deflate || accept_gzip )
{
log << log3 << "AEP: ";
if( accept_deflate )
{
log << "accept deflate";
if( accept_gzip )
log << ", ";
}
if( accept_gzip )
log << "accept gzip";
log << logend;
}
}
private:
void Init()
{
accept_deflate = false;
accept_gzip = false;
}
void Param(const std::string & param, double q)
{
if( param=="deflate" && q!=0.0 )
{
accept_deflate = true;
}
if( param=="gzip" && q!=0.0 )
{
accept_gzip = true;
}
}
bool accept_deflate;
bool accept_gzip;
};
#endif

File diff suppressed because it is too large Load Diff

View File

@@ -1,197 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2010-2013, Tomasz Sowa
* All rights reserved.
*
*/
#ifndef headerfile_winix_core_app
#define headerfile_winix_core_app
#include <iostream>
#include <ctime>
#include <unistd.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <pwd.h>
#include <grp.h>
#include <errno.h>
#include <fcgiapp.h>
#include "config.h"
#include "system.h"
#include "mounts.h"
#include "request.h"
#include "synchro.h"
#include "sessionmanager.h"
#include "db/db.h"
#include "functions/functions.h"
#include "templates/templates.h"
#include "compress.h"
#include "postparser.h"
#include "cookieparser.h"
#include "postmultiparser.h"
#include "acceptencodingparser.h"
class App
{
public:
App();
bool InitFCGI();
bool DropPrivileges();
bool Init();
void Start();
void Close();
void LogUserGroups();
bool Demonize();
void SetStopSignal();
bool WasStopSignal();
bool Lock();
void Unlock();
void StartThreads();
void WaitForThreads();
// configuration read from a config file
Config config;
// pointers to the current request and a session
Cur cur;
// temporary one request object
// current request
Request req;
// users sessions
SessionManager session_manager;
// database
Db db;
DbConn db_conn;
/*
model
*/
// ...
System system;
// functions (ls, cat, emacs, ...)
Functions functions;
// false at the beginning
// !! moze to do loggera dac?
bool stdout_is_closed;
/*
view
*/
Templates templates;
private:
enum Header
{
h_200,
h_404,
h_403
};
PostParser post_parser;
PostMultiParser post_multi_parser;
CookieParser cookie_parser;
AcceptEncodingParser accept_encoding_parser;
Compress compress;
std::wstring clean_html, html_with_debug;
FCGX_Request fcgi_request;
int fcgi_socket;
Synchro synchro;
pthread_t signal_thread;
std::string url_to_fetch_on_exit;
std::string source_a;
std::string sendh_t, sendh_t2, sendh_t3;
std::string sendfilea, sendfile2a;
std::string send_data_buf;
PT::SpaceToJSON json_generic_serializer;
TextStream<std::wstring> json_out_stream;
BinaryPage out_bin_stream_compressed;
bool CheckAccessFromPlugins();
void ProcessRequestThrow();
void ProcessRequest();
void BaseUrlRedirect(int code, bool add_subdomain);
bool BaseUrlRedirect();
void CheckIfNeedSSLredirect();
void SetLocale();
void CheckPostRedirect();
void MakePage();
void Make();
void SaveSessionsIfNeeded(); // !! wywalic do menagera sesji??
void LogAccess();
void SendData(const BinaryPage & page, FCGX_Stream * out);
void CreateJSONAnswer();
void ReadRequest();
void SendTextAnswer();
void SendBinaryAnswer();
void SendAnswer();
void PrintEnv();
void SetEnv(const char * & env, const char * name);
void ReadEnvVariables();
void ReadGetPostVars();
void CheckIE();
void CheckKonqueror();
void CheckRequestMethod();
void CheckFCGIRole();
void CheckSSL();
void SetSubdomain();
void PrepareSessionCookie();
void AddDebugInfo(std::wstring & out);
void FilterCompressSend(bool compressing, int compress_encoding, const std::wstring & source_ref);
bool SendHeadersStaticCreateResource();
void SendHeadersStatic();
void SendHeaderContentType();
void SendHeadersForbidden();
void SendHeadersRedirect();
void SendHeadersSendFile();
void SendHeadersCompression(int compress_encoding);
void SendHeadersNormal(Header header);
void SendHeaders(bool compressing, int compress_encoding, Header header);
int SelectDeflateVersion();
void SelectCompression(size_t source_len, bool & compression_allowed, int & compression_encoding);
bool CanSendContent(Header header);
void LogUser(const char * msg, uid_t id);
void LogGroup(const char * msg, gid_t id, bool put_logend = true);
void LogUsers();
void LogEffectiveGroups(std::vector<gid_t> & tab);
void LogGroups();
bool DropPrivileges(const std::string & user, uid_t uid, gid_t gid, bool additional_groups);
static void * SpecialThreadForSignals(void*);
void FetchPageOnExit();
void CreateStaticTree();
// !! dodac do session managera?
time_t last_sessions_save;
};
#endif

View File

@@ -1,70 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2008-2012, Tomasz Sowa
* All rights reserved.
*
*/
#ifndef headerfile_winix_core_compress
#define headerfile_winix_core_compress
#include <cstring>
#include <fcgiapp.h>
#include <zlib.h>
#include "requesttypes.h"
class Compress
{
public:
Compress();
~Compress();
int Init(int compress_level_ = 6);
/*
encoding:
0 - raw deflate data with no zlib header or trailer, and will not compute an adler32 check value
(for Internet Explorer)
1 - deflate
2 - gzip
*/
int CompressAndPut(const char * source, size_t source_len, FCGX_Stream * out_stream, int encoding = 2);
int Compressing(const BinaryPage & in, BinaryPage & out, int encoding = 2);
private:
bool AllocateMemory();
bool InitRawDeflate();
bool InitDeflate();
bool InitGzip();
int MakeCompress(z_stream & strm, const char * source, size_t source_len, FCGX_Stream * out_stream, int encoding);
int MakeCompress(z_stream & strm, const BinaryPage & page, BinaryPage & out, int encoding);
z_stream * SelectStream(int encoding);
void ResetStream(z_stream * pstrm, int encoding);
void PutLog(size_t source_len, int encoding);
void CopyToInputBuffer(BinaryPage::const_iterator & i, size_t len);
int compress_level;
size_t buffer_max_len;
// size of the last compressed page
size_t last_out_size;
char * buffer_in;
char * buffer_out;
z_stream strm_raw_deflate, strm_deflate, strm_gzip;
bool raw_deflate_inited, deflate_inited, gzip_inited;
bool ready_for_compress;
};
#endif

View File

@@ -1,83 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2008-2010, Tomasz Sowa
* All rights reserved.
*
*/
#ifndef headerfile_winix_core_cookieparser
#define headerfile_winix_core_cookieparser
#include <fcgiapp.h>
#include "httpsimpleparser.h"
#include "requesttypes.h"
#include "log.h"
class CookieParser : public HttpSimpleParser
{
const char * cookie_string;
CookieTab * cookie_tab;
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<CookieTab::iterator, bool> res = cookie_tab->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()
{
HttpSimpleParser::separator = ';';
HttpSimpleParser::value_can_be_quoted = true;
HttpSimpleParser::skip_white_chars = true;
HttpSimpleParser::recognize_special_chars = false;
}
// cookie_string can be null
void Parse(const char * cookie_string_, CookieTab & cookie_tab_)
{
cookie_string = cookie_string_;
cookie_tab = &cookie_tab_;
HttpSimpleParser::Parse();
}
};
#endif

View File

@@ -1,36 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2010-2011, Tomasz Sowa
* All rights reserved.
*
*/
#ifndef headerfile_winix_core_cur
#define headerfile_winix_core_cur
#include "request.h"
#include "session.h"
#include "mount.h"
/*
current request and session
*/
struct Cur
{
Request * request;
Session * session;
Mount * mount;
// those pointers are never null, if there is no a session for the user
// the 'session' pointer pointers at a special temporary session
};
#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 headerfile_winix_core_group
#define headerfile_winix_core_group
#include <string>
#include <vector>
struct Group
{
long id;
std::wstring name; // group name
std::vector<long> members; // users id
Group()
{
Clear();
}
void Clear()
{
id = -1;
name.clear();
members.clear();
}
};
#endif

View File

@@ -1,116 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2008-2012, Tomasz Sowa
* All rights reserved.
*
*/
#include "groups.h"
Groups::Groups()
{
Clear();
}
void Groups::Clear()
{
table.Clear();
}
void Groups::ReadGroups(Db * db)
{
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::wstring & name)
{
Table::Iterator i = table.FindName(name);
if( i == table.End() )
return 0;
return &(*i);
}
long Groups::GetGroupId(const std::wstring & 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();
}
bool Groups::Remove(long group_id)
{
return table.Remove(group_id);
}

View File

@@ -1,53 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2008-2012, Tomasz Sowa
* All rights reserved.
*
*/
#ifndef headerfile_winix_core_groups
#define headerfile_winix_core_groups
#include <map>
#include "group.h"
#include "ugcontainer.h"
#include "db/db.h"
class Groups
{
typedef UGContainer<Group> Table;
Table table;
public:
typedef Table::Iterator Iterator;
typedef Table::SizeType SizeType;
Groups();
void Clear();
void ReadGroups(Db * db);
Group * GetGroup(long group_id);
Group * GetGroup(const std::wstring & name);
long GetGroupId(const std::wstring & name);
Iterator Begin();
Iterator End();
SizeType Size();
bool Remove(long group_id);
};
#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,68 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2008-2010, Tomasz Sowa
* All rights reserved.
*
*/
#ifndef headerfile_winix_core_httpsimpleparser
#define headerfile_winix_core_httpsimpleparser
#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();
void Parse();
public:
HttpSimpleParser()
{
separator = '&';
read_name = true;
value_can_be_quoted = false;
skip_white_chars = false;
recognize_special_chars = true;
}
};
#endif

View File

@@ -1,58 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2012, Tomasz Sowa
* All rights reserved.
*
*/
#ifndef headerfile_winix_core_ipbancontainer
#define headerfile_winix_core_ipbancontainer
#include <vector>
#include "ipban.h"
class IPBanContainer
{
public:
IPBanContainer();
IPBan & AddIP(int ip);
IPBan * FindIP(int ip);
void Sort();
size_t Size();
IPBan & GetIPBan(size_t index);
void SetMaxSize(size_t soft_size, size_t size);
void RemoveIP(int ip);
void Clear();
bool IsSorted();
private:
std::vector<IPBan> ipban_tab;
bool is_ipban_tab_sorted;
size_t soft_max_size, max_size;
std::vector<size_t> sort_helper_tab;
static bool SortIPBansFunction(const IPBan & ip1, const IPBan & ip2);
void RemoveOldRecords();
void PrintTab();
void PrintTab2();
struct SortByLastUsedHelper
{
IPBanContainer * container;
SortByLastUsedHelper(IPBanContainer * c) : container(c) {}
bool operator()(size_t index1, size_t index2);
};
};
#endif

View File

@@ -1,82 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2010-2012, Tomasz Sowa
* All rights reserved.
*
*/
#include "item.h"
#include "misc.h"
#include "crypt.h"
Item::Item()
{
Clear();
}
// !! IMPROVE ME
// now we have Request::start_time and Request::start_date
// we can somehow get the current time from the request
// may setting the date should be completetly removed from here?
void Item::SetDateToNow()
{
date_creation = std::time(0);
date_modification = date_creation;
}
void Item::SetDateModifyToNow()
{
date_modification = std::time(0);
}
void Item::Clear()
{
id = -1;
user_id = -1;
group_id = -1;
privileges = 0;
modification_user_id = -1;
guest_name.clear();
subject.clear();
content.clear();
modify_index = 0;
url.clear();
content_type = ct_formatted_text;
type = none;
parent_id = -1;
link_to.clear();
link_redirect = false;
content_id = -1;
ref = 1;
file_path.clear();
file_fs = -1;
file_type = WINIX_ITEM_FILETYPE_NONE;
hash.clear();
hash_type = WINIX_CRYPT_HASH_NONE;
file_size = 0;
has_thumb = false;
html_template.clear();
sort_index = 0;
meta.Clear();
ameta.Clear();
SetDateToNow();
}

View File

@@ -1,82 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2012, Tomasz Sowa
* All rights reserved.
*
*/
#ifndef headerfile_winix_core_jobs
#define headerfile_winix_core_jobs
#include <vector>
#include <queue>
#include "basethread.h"
#include "space/space.h"
#define WINIX_JOBS_HOW_MANY_PRIORITIES 32
class Job : public BaseThread
{
public:
Job();
/*
add a new job to the queue
priority: 0-31 (0 - the lowest priority, 31 - the highest priority)
*/
void Add(PT::Space & job, int priority = 0);
/*
queue size, and size of all jobs in any priority
*/
size_t Size(int priority) const;
size_t Size() const;
/*
true if specified queue is empty
or if all queues are empty
*/
bool Empty(int priority) const;
bool Empty() const;
private:
typedef std::queue<PT::Space> JobsQueue;
typedef std::vector<JobsQueue> JobsQueueTab;
JobsQueueTab jobs_queue_tab;
void CheckPriority(int & priority) const;
void SaveToFile();
void ReadFromFile();
/*
second thread
*/
// standard winix jobs
// Image image;
// sending emails
// etc.
bool SignalReceived();
void Do();
void DoQueue(JobsQueue & jobs_queue);
void DoJob(PT::Space & job);
void DoWinixJob(PT::Space & job);
};
#endif

View File

@@ -1,78 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2009, Tomasz Sowa
* All rights reserved.
*
*/
#ifndef headerfile_winix_core_lastcontainer
#define headerfile_winix_core_lastcontainer
#include <string>
#include <list>
#include <cstring>
#include <ctime>
#include "date/date.h"
// how many items we store in the 'last' function
#define WINIX_LASTCONTAINER_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::wstring name;
// ip address
unsigned int ip;
// session id (used when logging out)
long session_id;
// start logging and end logging
PT::Date start;
PT::Date 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::wstring & 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,49 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2012, Tomasz Sowa
* All rights reserved.
*
*/
#include "lock.h"
Lock::Lock()
{
synchro = 0;
}
Lock::Lock(Synchro * synchro_)
{
synchro = synchro_;
synchro->Lock();
}
Lock::Lock(Synchro & synchro_)
{
synchro = &synchro_;
synchro->Lock();
}
Lock::~Lock()
{
Unlock();
}
void Lock::Unlock()
{
if( synchro )
{
synchro->Unlock();
synchro = 0;
}
}

View File

@@ -1,37 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2012, Tomasz Sowa
* All rights reserved.
*
*/
#ifndef headerfile_winix_core_lock
#define headerfile_winix_core_lock
#include "synchro.h"
class Lock
{
public:
Lock(Synchro * synchro_);
Lock(Synchro & synchro_);
~Lock();
void Unlock();
private:
Synchro * synchro;
Lock();
};
#endif

View File

@@ -1,480 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2008-2012, Tomasz Sowa
* All rights reserved.
*
*/
#include "log.h"
#include <ctime>
#include <string.h>
#include "utf8/utf8.h"
#include "timezones.h"
Log::Log()
{
log_level = 1;
current_level = 100; // nothing to log (call Init() first)
request = 0;
max_requests = 1;
lines = 0;
max_lines = 5000;
log_file_open = false;
time_zones = 0;
}
Log::~Log()
{
SaveLogAndClear();
}
void Log::SetTimeZones(TimeZones * ptime_zones)
{
time_zones = ptime_zones;
}
int Log::LogLevel()
{
return log_level;
}
void Log::Init(int log_level_, bool save_each_line_, const std::string & log_file_, bool log_std, int log_max_requests)
{
log_level = log_level_;
log_file = log_file_;
log_stdout = log_std;
max_requests = log_max_requests;
save_each_line = save_each_line_;
// don't open the file here
// because it would be created with the root as an owner
}
void Log::OpenFile()
{
if( !log_file.empty() )
{
file.open( log_file.c_str(), std::ios_base::out | std::ios_base::app );
log_file_open = true;
}
}
void Log::PrintDate(const PT::Date & date, size_t time_zone_id)
{
if( time_zones )
{
TimeZone * tz = time_zones->GetZone(time_zone_id);
if( tz )
{
PT::Date local_date = tz->ToLocal(date);
log << local_date;
}
else
{
(*this) << date << " UTC"; // unknown time zone identifier
}
}
else
{
(*this) << date << " UTC"; // time_zones object was not set
}
}
Log & Log::operator<<(const void * s)
{
if( current_level > log_level )
return *this;
buffer << s;
return *this;
}
Log & Log::operator<<(const char * s)
{
if( current_level > log_level )
return *this;
if( !s )
return *this;
buffer << s;
return *this;
}
Log & Log::operator<<(const std::string & s)
{
if( current_level > log_level )
return *this;
buffer << s;
return *this;
}
Log & Log::operator<<(const std::string * s)
{
if( current_level > log_level )
return *this;
buffer << *s;
return *this;
}
Log & Log::operator<<(const wchar_t * s)
{
if( current_level <= log_level )
{
if( s )
buffer << s;
}
return *this;
}
Log & Log::operator<<(const std::wstring & s)
{
if( current_level <= log_level )
{
buffer << s;
}
return *this;
}
Log & Log::operator<<(const std::wstring * s)
{
if( current_level <= log_level )
{
buffer << *s;
}
return *this;
}
Log & Log::operator<<(int s)
{
if( current_level <= log_level )
{
buffer << s;
}
return *this;
}
Log & Log::operator<<(long s)
{
if( current_level <= log_level )
{
buffer << s;
}
return *this;
}
Log & Log::operator<<(char s)
{
if( current_level <= log_level )
{
buffer << s;
}
return *this;
}
Log & Log::operator<<(wchar_t s)
{
if( current_level <= log_level )
{
buffer << s;
}
return *this;
}
Log & Log::operator<<(size_t s)
{
if( current_level <= log_level )
{
buffer << s;
}
return *this;
}
Log & Log::operator<<(double s)
{
if( current_level <= log_level )
{
buffer << s;
}
return *this;
}
Log & Log::operator<<(const PT::Space & s)
{
if( current_level <= log_level )
{
buffer << s;
}
return *this;
}
Log & Log::operator<<(const PT::Date & date)
{
if( current_level <= log_level )
{
buffer << date;
}
return *this;
}
Log & Log::operator<<(LogManipulators m)
{
switch(m)
{
case logend:
if( current_level <= log_level )
{
buffer << '\n';
lines += 1;
if( save_each_line )
SaveLogAndClear();
}
break;
case logsave:
SaveLogAndClear();
break;
case logendrequest:
if( ++request >= max_requests || lines > max_lines )
SaveLogAndClear();
break;
case log1:
current_level = 1;
break;
case log2:
current_level = 2;
break;
case log3:
current_level = 3;
break;
case log4:
current_level = 4;
break;
default:
break;
}
return *this;
}
char Log::GetHEXdigit(unsigned char c)
{
if( c < 10 )
return c + '0';
return c - 10 + 'A';
}
void Log::ToHEX(char * buf, unsigned char c)
{
buf[0] = GetHEXdigit(c >> 4);
buf[1] = GetHEXdigit(c & 0xf);
buf[2] = 0;
}
void Log::LogBinary(const char * blob, size_t blob_len)
{
size_t i=0;
char buf[3];
while( i < blob_len )
{
size_t oldi = i;
for(size_t a=0 ; a<16 ; ++a)
{
if( i < blob_len )
{
ToHEX(buf, blob[i]);
buffer << buf << ' ';
++i;
}
else
{
buffer << " ";
}
if( a == 7 )
{
if( i < blob_len )
buffer << "- ";
else
buffer << " ";
}
}
i = oldi;
buffer << ' ';
for(size_t a=0 ; a<16 && i<blob_len ; ++a, ++i)
{
if( blob[i] > 31 && blob[i] < 127 )
buffer << blob[i];
else
buffer << '.';
}
(*this) << logend;
}
}
void Log::LogBinary(const std::string & blob)
{
LogBinary(blob.c_str(), blob.size());
}
void Log::SystemErr(int err)
{
(*this) << "errno: " << err;
const char * err_msg = strerror(err);
if( err_msg )
(*this) << " (" << err_msg << ")";
}
void Log::SaveLogAndClear()
{
SaveLog();
buffer.Clear();
request = 0;
lines = 0;
}
void Log::SaveLog()
{
if( buffer.Str().empty() )
return;
if( log_stdout )
PT::WideToUTF8(buffer.Str(), std::cout);
if( log_file.empty() )
return;
if( !log_file_open || !file )
{
file.close();
file.clear();
OpenFile();
if( !file )
return;
}
PT::WideToUTF8(buffer.Str(), file);
file.flush();
}

View File

@@ -1,163 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2008-2012, Tomasz Sowa
* All rights reserved.
*
*/
#ifndef headerfile_winix_core_log
#define headerfile_winix_core_log
#include <sstream>
#include <fstream>
#include <iostream>
#include <string>
#include "textstream.h"
#include "logmanipulators.h"
#include "textstream/textstream.h"
class TimeZones;
class Log
{
public:
Log();
~Log();
void SetTimeZones(TimeZones * ptime_zones);
void Init(int log_level_, bool save_each_line_, const std::string & log_file_, bool log_std, int log_max_requests);
Log & operator<<(const void * s);
Log & operator<<(const char * s);
Log & operator<<(const std::string * s);
Log & operator<<(const std::string & s);
Log & operator<<(const wchar_t * s);
Log & operator<<(const std::wstring * s);
Log & operator<<(const std::wstring & s);
Log & operator<<(int s);
Log & operator<<(long s);
Log & operator<<(char s);
Log & operator<<(wchar_t s);
Log & operator<<(size_t s);
Log & operator<<(double s);
Log & operator<<(const PT::Space & space);
Log & operator<<(LogManipulators m);
Log & operator<<(const PT::Date & date);
void PrintDate(const PT::Date & date, size_t time_zone_id);
template<typename char_type, size_t stack_size, size_t heap_block_size>
Log & operator<<(const PT::TextStreamBase<char_type, stack_size, heap_block_size> & buf);
template<class StringType>
void LogString(const StringType & value, size_t max_size);
void LogBinary(const char * blob, size_t blob_len);
void LogBinary(const std::string & blob);
void SystemErr(int err);
void SaveLog();
void SaveLogAndClear();
int LogLevel();
private:
// time zones for printing the time in the log file
TimeZones * time_zones;
// buffer for the log
TextStream<std::wstring> buffer;
// log lovel from the config file
int log_level;
// current level set by a modifier (e.g. log << log3)
int current_level;
// current request for logging
// starts from zero and incremented after logendrequest modifier
int request;
// how many request to save at once
int max_requests;
// file log
std::string log_file;
std::ofstream file;
// logging to stdout
bool log_stdout;
// how many lines there are in the buffer
int lines;
// is the config file already open
bool log_file_open;
// how many lines can be in the config buffer
// default: 5000
int max_lines;
// whether to save each line (for debug)
bool save_each_line;
void OpenFile();
char GetHEXdigit(unsigned char c);
void ToHEX(char * buf, unsigned char c);
};
template<class StringType>
void Log::LogString(const StringType & value, size_t max_size)
{
size_t min_size = value.size() < max_size ? value.size() : max_size;
if( current_level <= log_level )
{
for(size_t i=0 ; i<min_size ; ++i)
{
if( value[i] < 32 )
buffer << '.';
else
buffer << value[i];
}
}
}
template<typename char_type, size_t stack_size, size_t heap_block_size>
Log & Log::operator<<(const PT::TextStreamBase<char_type, stack_size, heap_block_size> & buf)
{
if( current_level <= log_level )
buffer << buf;
return *this;
}
extern Log log;
extern Log nlog;
// for convenience, we have to use only #include "log.h" in the winix
#include "slog.h"
#endif

View File

@@ -1,48 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2011, Tomasz Sowa
* All rights reserved.
*
*/
#ifndef headerfile_winix_core_logmanipulators
#define headerfile_winix_core_logmanipulators
/*
log1 - the first level
log2
log3
log4 - the last level (debug level)
logend - the end of a line
logendrequest - end of a current request
logsave - current log buffer is saved and cleared
manipulators used by the session logger (SLog)
loginfo - normal info to a user
logerror - we are reporting an error
logwarning - we are reporting a warning
make sure that loginfo, logerror and logwarning have values less than 32 (space)
their are used as control codes in a string
*/
enum LogManipulators
{
log1,
log2,
log3,
log4,
logend,
logendrequest,
logsave,
loginfo,
logerror,
logwarning
};
#endif

View File

@@ -1,71 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2009-2010, Tomasz Sowa
* All rights reserved.
*
*/
#ifndef headerfile_winix_core_mount
#define headerfile_winix_core_mount
#include <map>
#include <string>
#include <vector>
class Mount
{
public:
struct ParamRow
{
typedef std::vector<std::wstring> ParamArg;
bool defined;
ParamArg arg;
ParamRow() { defined = false; }
void Clear() { defined = false; arg.clear(); }
};
typedef std::vector<ParamRow> Param;
long dir_id;
int type;
int fs;
Param param;
Mount();
void ClearParams();
bool IsPar(int code);
bool IsArg(int code, const wchar_t * arg);
bool IsArg(int code, const std::wstring & arg);
bool IsArg(int code, int arg);
// returning the arg argument if defined (or an empty string)
const std::wstring & Arg(int code, int arg) const;
// returning the first argument (arg=0) if defined (or an empty string)
const std::wstring & FirstArg(int code) const;
private:
// for Arg() methods when the argument is not defined
const std::wstring empty_str;
};
#endif

View File

@@ -1,155 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2008-2012, Tomasz Sowa
* All rights reserved.
*
*/
#include "plugindata.h"
#include "plugin.h"
#include "log.h"
#include "session.h"
PluginData::PluginData()
{
session = 0;
}
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());
session = 0;
return *this;
}
PluginData::~PluginData()
{
DeleteAll();
}
void PluginData::SetSession(Session * ses)
{
session = ses;
}
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()
{
bool all_null = true;
/*
when we copy a session's object (and this object then)
we resize the table and there are only null pointers there
consequently if all pointers are null there is no sens
to send WINIX_PLUGIN_SESSION_DATA_REMOVE
*/
for(size_t i=0 ; i<table.size() ; ++i)
{
if( table[i] != 0 )
{
all_null = false;
break;
}
}
/*
in the future this message may be removed
and we directly 'delete' the pointers
*/
if( !all_null )
plugin.Call(session, WINIX_PLUGIN_SESSION_DATA_REMOVE);
table.clear();
}
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,69 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2008-2012, Tomasz Sowa
* All rights reserved.
*
*/
#ifndef headerfile_winix_core_plugindata
#define headerfile_winix_core_plugindata
#include <vector>
struct Session;
struct PluginDataBase
{
virtual ~PluginDataBase() {}
/*
!! CHECK ME
it is still in use?
when deleting sessions we first call Clear() method
consequently the destructor has nothing to do
(and it does not throw an exception)
*/
virtual void Clear() {}
};
class PluginData
{
public:
PluginData();
PluginData(const PluginData & p);
PluginData & operator=(const PluginData & p);
~PluginData();
void SetSession(Session * ses);
void Assign(size_t index, PluginDataBase * data);
void Assign(PluginDataBase * data);
PluginDataBase * Get(size_t index);
PluginDataBase * Get();
void DeleteAll();
size_t Size() const;
void Resize(size_t new_size);
private:
Session * session;
std::vector<PluginDataBase*> table;
};
#endif

View File

@@ -1,151 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2008-2012, Tomasz Sowa
* All rights reserved.
*
*/
#ifndef headerfile_winix_core_postparser
#define headerfile_winix_core_postparser
#include <fcgiapp.h>
#include <string>
#include "httpsimpleparser.h"
#include "requesttypes.h"
#include "misc.h"
#include "utf8/utf8.h"
#include "log.h"
#include "config.h"
#include "plugin.h"
class PostParser : public HttpSimpleParser
{
FCGX_Stream * in;
PostTab * post_tab;
std::wstring temp_name, temp_value;
bool input_as_utf8;
size_t log_value_size;
int var_index;
bool has_winix_post_params_msg;
bool has_winix_raw_post_msg;
std::string raw_post;
protected:
virtual int GetChar()
{
int c = FCGX_GetChar(in);
if( c != -1 && has_winix_raw_post_msg )
raw_post += c;
return c;
}
void CreateLog(bool param_added)
{
log << log2 << "Method POST, name: \"" << temp_name << "\"";
if( log_value_size > 0 && !IsSubStringNoCase(L"pass", temp_name.c_str()) )
{
log << ", value: ";
if( temp_value.size() > log_value_size )
log << "(first " << log_value_size << " characters) ";
log << "\"";
log.LogString(temp_value, log_value_size);
log << "\" (size: " << temp_value.size() << ")";
}
if( param_added == false )
log << log2 << " (skipped)";
log << log2 << logend;
}
void ConvStr(const std::string & src, std::wstring & dst)
{
if( input_as_utf8 )
PT::UTF8ToWide(src, dst);
else
AssignString(src, dst);
}
virtual void Parameter(std::string & name, std::string & value)
{
bool added;
std::pair<PostTab::iterator, bool> res;
if( has_winix_post_params_msg )
plugin.Call(0, WINIX_POST_PARAMS, &name, &value);
ConvStr(name, temp_name);
ConvStr(value, temp_value);
res = post_tab->insert( std::make_pair(temp_name, temp_value) );
added = res.second;
if( !added )
{
temp_name += L"_inc";
temp_name += Toa(var_index);
res = post_tab->insert( std::make_pair(temp_name, temp_value) );
added = res.second;
var_index += 1;
}
CreateLog(added);
}
public:
PostParser()
{
input_as_utf8 = false;
log_value_size = 0;
}
void UTF8(bool utf)
{
input_as_utf8 = utf;
}
void LogValueSize(size_t s)
{
log_value_size = s;
}
void Parse(FCGX_Stream * in_, PostTab & post_tab_)
{
in = in_;
post_tab = &post_tab_;
var_index = 1;
raw_post.clear();
has_winix_post_params_msg = plugin.HasMessage(WINIX_POST_PARAMS);
has_winix_raw_post_msg = plugin.HasMessage(WINIX_RAW_POST_STRING);
HttpSimpleParser::Parse();
if( has_winix_raw_post_msg )
plugin.Call(0, WINIX_RAW_POST_STRING, &raw_post);
raw_post.clear();
}
};
#endif

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 headerfile_winix_core_rebus
#define headerfile_winix_core_rebus
#include <string>
#include <vector>
struct Cur;
class Rebus
{
public:
struct Item
{
int key;
std::wstring question;
int answer;
};
void SetCur(Cur * pcur);
void Init();
Item * Rand();
bool IsAnswerOk(Item * item, const std::wstring & answer);
bool CheckRebus();
private:
Cur * cur;
bool InitPair(int a, int b, Item & item);
std::vector<Item> table;
};
#endif

View File

@@ -1,310 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2008-2013, Tomasz Sowa
* All rights reserved.
*
*/
#ifndef headerfile_winix_core_request
#define headerfile_winix_core_request
#include <fcgiapp.h>
#include <sstream>
#include <vector>
#include "requesttypes.h"
#include "item.h"
#include "error.h"
#include "config.h"
#include "textstream.h"
#include "templates/htmltextstream.h"
#include "date/date.h"
#include "space/space.h"
#include "space/spacetojson.h"
class FunctionBase;
struct Request
{
// request id
// is incremented for each request and is never 0
// (from -1 will be incremented twice)
// it's used for some optimalizations e.g. in templates
size_t id;
// !! moze pozbyc sie tego none?
enum Method { get, post, head, none } method;
enum Role { responder, authorizer } role;
// headers, page and debug
//std::ostringstream headers, page, debug;
// !! IMPROVE ME change headers to some kind of a map, may PT::Space ?
TextStream<std::string> headers;
HtmlTextStream debug;
// winix can return either a text answer or a binary answer
// if send_bin_stream is true then the binary answer is sent (out_bin_stream)
// or if send_bin_stream is false then the text answer is sent
// default: false
//
//
//
// 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
//
//
bool send_bin_stream;
// -------------------------------------------------------------------------------------
// binary answer
//
// binary page sent to the client if send_bin_stream is true
BinaryPage out_bin_stream;
//
// -------------------------------------------------------------------------------------
// -------------------------------------------------------------------------------------
// text answer
//
// when returning the text answer we can either return the whole html page (normal requests)
// or a JSON object (for requests generated from AJAX)
// if return_json is false then we return the whole html page (which is in out_streams[0])
// if return_json is true we are creating an JSON object from out_streams
// (zero stream is ignored) and from info space (see above picture)
// (or just only from info if return_info_only is true)
// default: false
// return_json is set to true by App at the beginning of a request
// if reqtype:json parameter is present (in the url)
// note: return_json is only valid if send_bin_stream is false
bool return_json;
// main text output streams where the html otput is generated from ezc templates
// the zero stream (out_streams[0]) is used as the main stream
// to which the whole html page (with doctype, head, body) is generated
// the rest streams can be only used in ajax requests (send in JSON format to the client)
// in ezc templates you can use [ezc stream ...] keyword
// to switch between streams e.g. [ezc stream "0" "2"]
std::vector<HtmlTextStream> out_streams;
// if true the JSON object is generated only from info (out_streams are not used)
// default: false
bool return_info_only;
// additional info added when sending the JSON answer
PT::Space info;
// info serializer
// if not set then the json_generic_serializer from App will be used
// default: null (json_generic_serializer used)
PT::SpaceToJSON * info_serializer;
//
// -------------------------------------------------------------------------------------
// if set to true then the standard template system will not be generated
// default: false
bool page_generated;
// whether or not the html filter should be used
// default: true
bool use_html_filter;
// raw parameters
PostTab post_tab;
PostFileTab post_file_tab;
CookieTab cookie_tab;
// html anchor (those part of URI after '#' character)
std::wstring anchor;
// environment variables
// they are not null -- when the server doesn't have such a variable
// it will be pointing into 'char_empty' which is default '\0'
const char * env_request_method;
const char * env_request_uri;
const char * env_http_cookie;
const char * env_remote_addr;
const char * env_http_host;
const char * env_http_user_agent;
const char * env_http_accept_encoding;
const char * env_fcgi_role;
const char * env_content_type;
const char * env_https;
// current IP address of the remote host (read from REMOTE_ADDR environment variable)
// (at the moment only IPv4 are supported)
int ip;
// true if the browser is Microsoft Internet Explorer
bool browser_msie;
// true if the browser is Konqueror
bool browser_konqueror;
// true if we are using encrypted connection (SSL)
bool using_ssl;
// current directory
std::vector<Item*> dir_tab;
// true if a file exists
bool is_item;
// current file (if exists)
Item item;
// current winix function
// null if there is no a function
FunctionBase * function;
// parameters (name:value)
ParamTab param_tab;
// request status
Error status;
// usually items in the current directory (depends on the function)
std::vector<Item> item_tab;
// if not empty means an address for redirecting to
// it should be url-encoded
std::wstring redirect_to;
std::string aredirect_to;
// a redirect type
// following redirect types are supported:
// 300 Multiple Choices
// 301 Moved Permanently
// 302 Found
// 303 See Other (default)
// 307 Temporary Redirect
int redirect_type;
// send header X-LIGHTTPD-send-file with path to a file
std::wstring x_sendfile;
// send as attachment (causes header: content-disposition: attachment)
bool send_as_attachment;
// this is a pointer either to the item (if exists) or to the last directory
Item * last_item;
// request start time
// Time() methods are very slow so it is better to directly use those two values
// they are set when a request starts
time_t start_time;
PT::Date start_date;
// a subdomain
// subdomain = HTTP_HOST environment variable - config->base_url
std::wstring subdomain;
// if this variable is true then winix always return 200 OK header
// when the status would be 404 (not found) or 403 (permission denied)
// default: false
bool use_200_status_for_not_found_and_permission_denied;
// options used by ezc generators
bool gen_trim_white;
bool gen_skip_new_line;
bool gen_use_special_chars;
Request();
void SetConfig(Config * pconfig);
void RequestStarts();
void Clear();
bool IsParam(const wchar_t * param_name);
bool IsParam(const std::wstring & param_name);
const std::wstring & ParamValue(const wchar_t * param_name); // returns an empty string if there is no such a parameter
const std::wstring & ParamValue(const std::wstring & param_name); // returns an empty string if there is no such a parameter
void SetCookie(const char * name, const char * value, PT::Date * expires = 0);
void SetCookie(const char * name, long value, PT::Date * expires = 0);
bool IsPostVar(const wchar_t * var);
bool IsPostVar(const std::wstring & var);
const std::wstring & PostVar(const wchar_t * var); // returns an empty string if there is no such a parameter
const std::wstring & PostVar(const std::wstring & var); // returns an empty string if there is no such a parameter
bool PostVar(const wchar_t * var, std::wstring & result);
bool PostVar(const std::wstring & var, std::wstring & result);
std::wstring * PostVarp(const wchar_t * var);
std::wstring * PostVarp(const std::wstring & var);
bool AllPostVarEmpty(); // returning true if all post vars are empty
void SendAll();
private:
Config * config;
// contains '\0'
// used to set env_* pointers to the empty value
const char char_empty;
// used in ParamValue() and PostVar() when there is no such a param
const std::wstring str_empty;
void ClearOutputStreams();
};
#endif

View File

@@ -1,52 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2008-2011, Tomasz Sowa
* All rights reserved.
*
*/
#ifndef headerfile_winix_core_requesttypes
#define headerfile_winix_core_requesttypes
#include <string>
#include <vector>
#include <map>
#include "textstream/textstream.h"
// !! narazie uzywane tylko w post multi parserze
// dodac do zwyklego parsera post
#define WINIX_POSTTABLE_MAXSIZE 50
struct PostFile
{
std::wstring filename; // original file name
std::wstring tmp_filename; // file with content (in /tmp)
size_t file_size;
};
// parameters from get name:value
struct Param
{
std::wstring name;
std::wstring value;
};
// some global types used by Request class
typedef std::map<std::wstring, std::wstring> PostTab;
typedef std::map<std::wstring, PostFile> PostFileTab;
typedef std::vector<Param> ParamTab;
typedef std::map<std::string, std::string> CookieTab;
typedef PT::TextStreamBase<char, 1, 4096> BinaryPage;
#endif

View File

@@ -1,94 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2008-2012, Tomasz Sowa
* All rights reserved.
*
*/
#include "session.h"
#include "misc.h"
Session::Session()
{
Clear();
plugin_data.SetSession(this);
}
Session::Session(const Session & ses)
{
operator=(ses);
}
Session & Session::operator=(const Session & ses)
{
/*
we can only copy ses.id because it is needen in SessionContainer
it have indexes to id
*/
Clear();
id = ses.id;
plugin_data.SetSession(this);
return *this;
}
void Session::SetTimesTo(time_t time)
{
start_time = time;
start_date = time;
last_time = start_time;
last_date = start_date;
// the first request can be a POST (it doesn't matter)
last_time_get = start_time;
}
// clear_plugin_data is used when clearing the temporary session
void Session::Clear(bool clear_plugin_data)
{
id = 0;
puser = 0;
rebus_item = 0;
rebus_checked = false;
remember_me = false;
new_session = true;
spam_score = 0;
remove_me = false;
start_time = 0;
last_time = 0;
last_time_get = 0;
start_date.Clear();
last_date.Clear();
log_buffer.Clear();
last_css.clear();
ip_ban = 0;
if( clear_plugin_data )
plugin_data.Resize(0);
}
// clearing some variables when a request is ended (just for safety)
void Session::ClearOnEndRequest()
{
// ip_ban list can be sorted by SessionManager (in the special thread)
ip_ban = 0;
}

View File

@@ -1,74 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2008-2012, Tomasz Sowa
* All rights reserved.
*
*/
#ifndef headerfile_winix_core_sessioncontainer
#define headerfile_winix_core_sessioncontainer
#include <list>
#include <map>
#include <ctime>
#include "session.h"
#include "cur.h"
#include "config.h"
class SessionContainer
{
public:
typedef std::list<Session> Table;
typedef Table::iterator Iterator;
typedef std::map<long, Iterator> IndexId;
typedef IndexId::iterator IdIterator;
SessionContainer();
void SetCur(Cur * pcur);
void SetConfig(Config * pconfig);
void SetTmpSession(Session * psession);
void Clear();
size_t Size();
Iterator Begin();
Iterator End();
Session & Back();
Iterator AddSession(long id);
Iterator FindById(long);
IdIterator IdBegin();
IdIterator IdEnd();
void EraseById(long id);
bool ChangeSessionId(Iterator ses, long new_id);
bool ChangeSessionId(long old_id, long new_id);
private:
Table table;
IndexId index_id;
Cur * cur;
Config * config;
Session * tmp_session;
Session empty_session;
// in FreeBSD implementation (GCC) list::size() has linear complexity
// so we use our own table_size with O(1)
size_t table_size;
};
#endif

View File

@@ -1,605 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2008-2013, Tomasz Sowa
* All rights reserved.
*
*/
#include <sys/stat.h>
#include "sessionmanager.h"
#include "request.h"
#include "log.h"
#include "session.h"
#include "sessionparser.h"
#include "plugin.h"
SessionManager::SessionManager()
{
temporary_session.id = 0;
session = &temporary_session;
session_tab.SetTmpSession(&temporary_session);
// thread work mode
work_mode = 1;
}
void SessionManager::SetCur(Cur * pcur)
{
cur = pcur;
session_tab.SetCur(pcur);
}
void SessionManager::SetConfig(Config * pconfig)
{
config = pconfig;
session_tab.SetConfig(pconfig);
}
void SessionManager::SetSystem(System * psystem)
{
system = psystem;
}
void SessionManager::SetLastContainer(LastContainer * plast_container)
{
last_container = plast_container;
}
void SessionManager::InitBanList()
{
ban_tab.SetMaxSize(config->ban_list_soft_max_size, config->ban_list_max_size);
}
size_t SessionManager::Size()
{
return session_tab.Size();
}
bool SessionManager::IsSession(long id)
{
if( session_tab.FindById(id) == session_tab.End() )
return false;
return true;
}
long SessionManager::CreateSessionId()
{
long id;
// make sure to call std::srand() somewhere at the beginning
// id must be != 0 (0 is reserved)
do
{
if( sizeof(long) == 8 )
{
id = (((unsigned long)std::rand()) << 32) + std::rand();
}
else
{
id = std::rand();
}
id += std::time(0);
if( id < 0 )
id = -id;
}
while( id == 0 ); // 0 reserved for a temporary session
return id;
}
void SessionManager::CreateSession()
{
int attempts = 100;
SessionContainer::Iterator i = session_tab.End();
if( config->session_max == 0 || session_tab.Size() < config->session_max )
{
for( ; i == session_tab.End() && attempts > 0 ; --attempts )
{
long id = CreateSessionId();
i = session_tab.AddSession(id);
}
}
else
{
log << log2 << "SM: sessions limit exceeded (" << config->session_max << ")" << logend;
}
if( i != session_tab.End() )
{
session = &(*i);
session->new_session = true;
session->SetTimesTo(cur->request->start_time);
log << log2 << "SM: created a new session: " << session->id << logend;
}
else
{
// there is a problem with generating a new session id
// we do not set a session cookie
log << log1 << "SM: cannot create a session id (temporary used: with id 0)" << logend;
SetTemporarySession();
}
}
void SessionManager::SetTemporarySession()
{
session = &temporary_session;
session->Clear(false);
session->SetTimesTo(cur->request->start_time);
session->new_session = false; // temporary session was initialized at the beginning
}
bool SessionManager::SetSessionFromCookie(const std::string & cookie)
{
long id = Tol(cookie.c_str());
SessionContainer::Iterator s = session_tab.FindById(id);
if( s == session_tab.End() || s->remove_me )
return false;
// that session is in the table
session = &(*s);
session->new_session = false;
session->last_time = cur->request->start_time;
session->last_date = cur->request->start_time;
if( cur->request->method == Request::get )
session->last_time_get = cur->request->start_time;
log << log2 << "SM: session: " << session->id;
if( session->puser )
log << log2 << ", user: " << session->puser->name << ", id: " << session->puser->id;
log << log2 << logend;
return true;
}
void SessionManager::SetSession()
{
current_ip_ban = ban_tab.FindIP(cur->request->ip);
if( current_ip_ban && current_ip_ban->IsIPBanned() )
{
if( current_ip_ban->expires != 0 && cur->request->start_time >= current_ip_ban->expires )
{
log << log2 << "SM: removing a ban from this IP and resetting events counter" << logend;
current_ip_ban->ClearAfterRemovingBan();
}
else
{
log << log2 << "SM: this ip is bannned, using a temporary session" << logend;
SetTemporarySession();
session->ip_ban = current_ip_ban;
return;
}
}
CookieTab::iterator i = cur->request->cookie_tab.find(config->http_session_id_name);
if( i == cur->request->cookie_tab.end() )
{
CreateSession();
}
else
{
if( !SetSessionFromCookie(i->second) )
{
// there is no such a session
// deleting the old cookie
cur->request->cookie_tab.erase(i);
// and creating a new one
CreateSession();
}
}
session->ip_ban = current_ip_ban;
}
Session * SessionManager::FindSession(long id)
{
SessionContainer::Iterator i = session_tab.FindById(id);
if( i != session_tab.End() )
return &*i;
return 0;
}
SessionContainer::Iterator SessionManager::SessionBegin()
{
return session_tab.Begin();
}
SessionContainer::Iterator SessionManager::SessionEnd()
{
return session_tab.End();
}
void SessionManager::DeleteSessions()
{
SessionContainer::Iterator i;
for(i=session_tab.Begin() ; i!=session_tab.End() ; ++i)
{
if( i->puser && !i->remember_me )
{
plugin.Call(&(*i), WINIX_PREPARE_USER_TO_LOGOUT, i->puser);
last_container->UserLogout(i->puser->id, i->id);
}
}
session_tab.Clear();
}
/*
don't change a session's id when a user is logged
the session id is in last_container and the user would not be
correctly removed from the container
*/
bool SessionManager::ChangeSessionId(long old_id)
{
int attempts = 100;
bool changed = false;
long new_id;
SessionContainer::Iterator i = session_tab.FindById(old_id);
if( i != session_tab.End() )
{
for( ; !changed && attempts > 0 ; --attempts )
{
new_id = CreateSessionId();
changed = session_tab.ChangeSessionId(i, new_id);
}
if( changed )
plugin.Call(&(*i), WINIX_SESSION_CHANGED_ID, old_id, new_id);
else
log << log1 << "SM: I cannot create a new session id (still uses old one)" << logend;
}
else
{
log << log2 << "SM: there is no a session with id: " << old_id << logend;
}
return changed;
}
void SessionManager::InitTmpSession()
{
Session * old_session = cur->session;
log << log4 << "SM: initializing temporary session" << logend;
cur->session = &temporary_session;
plugin.Call(WINIX_SESSION_CREATED);
cur->session = old_session;
}
void SessionManager::UninitTmpSession()
{
Session * old_session = cur->session;
log << log4 << "SM: uninitializing temporary session" << logend;
cur->session = &temporary_session;
cur->session->plugin_data.DeleteAll(); // this will call plugin.Call(WINIX_PLUGIN_SESSION_DATA_REMOVE);
cur->session->plugin_data.Resize(0);
cur->session = old_session;
}
void SessionManager::LoadSessions()
{
SessionParser sp;
SessionContainer::Iterator i;
// sessions will be overwritten (pointers are invalidated)
cur->session = &temporary_session;
sp.SetUsers(&system->users);
sp.Parse(config->session_file, session_tab);
for(i=session_tab.Begin() ; i != session_tab.End() ; ++i)
{
i->plugin_data.Resize(plugin.Size());
plugin.Call(&(*i), WINIX_SESSION_CREATED);
/*
!! IMPROVE ME
we do not add it to the last_container (we don't have IP address stored yet)
*/
if( i->puser )
plugin.Call(&(*i), WINIX_USER_LOGGED);
}
cur->session = &temporary_session;
}
void SessionManager::SaveSessions()
{
if( config->session_file.empty() )
return;
std::ofstream file(config->session_file.c_str());
if( !file )
{
log << log1 << "SM: cannot open the session file for writing - sessions lost" << logend;
return;
}
log << log2 << "SM: saving sessions" << logend;
long len = 0;
SessionContainer::Iterator i = session_tab.Begin();
for( ; i!=session_tab.End() ; ++i )
{
if( i->id != 0 && i->puser && !i->remove_me )
{
file << i->id << ' ' << i->puser->id << ' ' << i->remember_me << ' ';
file << (long)i->start_time << ' ' << (long)i->last_time << std::endl;
++len;
}
}
file.close();
chmod(config->session_file.c_str(), 0600);
log << log2 << "SM: saved " << len << " session(s)" << logend;
}
Session * SessionManager::GetTmpSession()
{
return &temporary_session;
}
Session * SessionManager::GetCurSession()
{
return session;
}
// returns how many sessions was marked to remove
size_t SessionManager::MarkAllSessionsToRemove(long user_id)
{
size_t how_many = 0;
SessionContainer::Iterator i;
for(i=session_tab.Begin() ; i!=session_tab.End() ; ++i)
{
if( i->puser && i->puser->id == user_id )
{
plugin.Call(&(*i), WINIX_PREPARE_USER_TO_LOGOUT, i->puser);
last_container->UserLogout(i->puser->id, i->id);
i->remove_me = true;
i->puser = 0;
how_many += 1;
}
}
return how_many;
}
IPBan & SessionManager::AddIPToBanList(int ip)
{
return ban_tab.AddIP(ip);
}
size_t SessionManager::BanListSize()
{
return ban_tab.Size();
}
IPBan & SessionManager::GetIPBan(size_t index)
{
return ban_tab.GetIPBan(index);
}
void SessionManager::RemoveIPBan(int ip)
{
ban_tab.RemoveIP(ip);
}
void SessionManager::ClearIPBanList()
{
ban_tab.Clear();
}
/*
*
*
* sessions gc (second thread)
* sessions are only removed here
* SessionContainer::IndexId can be removed from the other thread
* (when ChangeSessionId() method is called)
*
*/
void SessionManager::Work()
{
bool exit = false;
SessionContainer::Iterator i;
deleted = 0;
Lock();
i = session_tab.Begin();
Unlock();
while( !exit )
{
Lock();
CheckWheterIPListIsSorted();
CheckSession(i);
exit = synchro->was_stop_signal;
Unlock();
}
}
// objects locked
void SessionManager::CheckWheterIPListIsSorted()
{
if( !ban_tab.IsSorted() )
{
log << log4 << "SM: sorting the ban list" << logend;
ban_tab.Sort();
}
}
// it's called from the other thread (with Lock and Unlock)
void SessionManager::CheckSession(SessionContainer::Iterator & i)
{
const int deleted_max_at_once = 10;
if( i == session_tab.End() )
{
if( deleted > 0 )
{
deleted = 0;
log << logsave;
}
i = session_tab.Begin();
WaitForSignalSleep(10);
}
else
{
if( i->remove_me || IsSessionOutdated(*i) )
{
Session * ses = &(*i);
++i;
DeleteSession(ses);
++deleted;
}
else
{
++i;
}
if( deleted >= deleted_max_at_once )
{
log << logsave;
WaitForSignalSleep(1);
deleted = 0;
}
}
}
// it's called from the other thread (with Lock and Unlock)
bool SessionManager::IsSessionOutdated(const Session & s) const
{
bool outdated;
if( s.remember_me )
{
outdated = s.last_time < std::time(0) - config->session_remember_max_idle;
}
else
{
outdated = s.last_time < std::time(0) - config->session_max_idle;
}
return outdated;
}
// it's called from the other thread (with Lock and Unlock)
void SessionManager::DeleteSession(Session * del_session)
{
if( del_session->puser )
{
plugin.Call(del_session, WINIX_PREPARE_USER_TO_LOGOUT, del_session->puser);
last_container->UserLogout(del_session->puser->id, del_session->id);
del_session->puser = 0;
}
long id = del_session->id;
plugin.Call(del_session, WINIX_PREPARE_SESSION_TO_REMOVE);
session_tab.EraseById(del_session->id);
plugin.Call((Session*)0, WINIX_SESSION_REMOVED, id);
}
/*
*
*
* end of sessions gc
*
*
*/

View File

@@ -1,105 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2008-2012, Tomasz Sowa
* All rights reserved.
*
*/
#ifndef headerfile_winix_core_sessionmanager
#define headerfile_winix_core_sessionmanager
#include <set>
#include <ctime>
#include "sessioncontainer.h"
#include "ipbancontainer.h"
#include "config.h"
#include "request.h"
#include "lastcontainer.h"
#include "system.h"
#include "synchro.h"
#include "basethread.h"
class SessionManager : public BaseThread
{
public:
SessionManager();
void SetCur(Cur * pcur);
void SetConfig(Config * pconfig);
void SetSystem(System * psystem);
void SetLastContainer(LastContainer * plast_container);
// can return a null pointer
Session * FindSession(long id);
void SetSession();
void DeleteSessions(); // deleting all sessions
bool ChangeSessionId(long old_id);
void InitBanList();
void InitTmpSession();
void UninitTmpSession();
Session * GetTmpSession();
Session * GetCurSession();
void LoadSessions();
void SaveSessions();
SessionContainer::Iterator SessionBegin();
SessionContainer::Iterator SessionEnd();
size_t Size();
size_t MarkAllSessionsToRemove(long user_id);
IPBan & AddIPToBanList(int ip);
size_t BanListSize();
IPBan & GetIPBan(size_t index);
void RemoveIPBan(int ip);
void ClearIPBanList();
private:
Config * config;
Cur * cur;
System * system;
LastContainer * last_container;
// current session - set by SetSession()
Session * session;
SessionContainer session_tab;
IPBanContainer ban_tab;
IPBan * current_ip_ban;
// session with id 0
Session temporary_session;
bool IsSession(long s);
long CreateSessionId();
void CreateSession();
bool SetSessionFromCookie(const std::string & cookie);
void SetTemporarySession();
// second thread
int deleted;
virtual void Work();
void CheckSession(SessionContainer::Iterator & i);
bool IsSessionOutdated(const Session & s) const;
void DeleteSession(Session * del_session);
void CheckWheterIPListIsSorted();
};
#endif

View File

@@ -1,50 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2008-2010, Tomasz Sowa
* All rights reserved.
*
*/
#ifndef headerfile_winix_core_sessionparser
#define headerfile_winix_core_sessionparser
#include <fstream>
#include <string>
#include "session.h"
#include "sessioncontainer.h"
#include "users.h"
class SessionParser
{
public:
bool Parse(const char * path, SessionContainer & container);
bool Parse(const std::string & path, SessionContainer & container);
void SetUsers(Users * pusers);
private:
Users * users;
bool Parse(SessionContainer & container);
void MakeSession(long id, long user_id, SessionContainer & container);
bool IsWhite(int c);
bool IsDigit(int c);
void SkipWhite();
void SkipLine();
long ReadLong();
std::ifstream file;
int last; // last character
};
#endif

View File

@@ -1,57 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2010-2012, Tomasz Sowa
* All rights reserved.
*
*/
#include <errno.h>
#include "synchro.h"
Synchro::Synchro() : mutex(PTHREAD_MUTEX_INITIALIZER)
{
was_stop_signal = false;
ref = 0;
}
bool Synchro::Lock()
{
int res = pthread_mutex_lock(&mutex);
if( res == EDEADLK )
{
// Lock() method in this thread was called before
ref += 1;
return true;
}
else
{
ref = 0;
}
return res == 0;
}
void Synchro::Unlock()
{
if( ref > 0 )
{
ref -= 1;
}
else
{
pthread_mutex_unlock(&mutex);
}
}

View File

@@ -1,43 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2010-2012, Tomasz Sowa
* All rights reserved.
*
*/
#ifndef headerfile_winix_core_synchro
#define headerfile_winix_core_synchro
#include <pthread.h>
struct Synchro
{
// one global mutex
pthread_mutex_t mutex;
// true when winix is closing
volatile bool was_stop_signal;
Synchro();
bool Lock();
void Unlock();
private:
// deadlock counter
// we can call Lock() more than one in the same thread
int ref;
};
#endif

View File

@@ -1,136 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2011-2012, Tomasz Sowa
* All rights reserved.
*
*/
#include <signal.h>
#include "threadmanager.h"
#include "log.h"
ThreadManager::ThreadManager()
{
were_started = false;
}
void ThreadManager::SetSynchro(Synchro * psynchro)
{
synchro = psynchro;
}
void ThreadManager::Init()
{
sigset_t set;
sigemptyset(&set);
sigaddset(&set, SIGTERM);
sigaddset(&set, SIGINT);
// blocking SIGTERM and SIGINT
// new threads will have the signals blocked too
pthread_sigmask(SIG_BLOCK, &set, 0);
}
void ThreadManager::Add(BaseThread * pbase, const wchar_t * thread_name)
{
ThreadItem item;
item.object = pbase;
item.name = thread_name;
thread_tab.push_back(item);
if( were_started )
Start(thread_tab.size() - 1);
else
log << log4 << "TM: added a thread to the queue, number: " << (thread_tab.size()-1)
<< ", name: " << thread_name << logend;
}
void ThreadManager::Add(BaseThread & pbase, const wchar_t * thread_name)
{
Add(&pbase, thread_name);
}
void ThreadManager::Add(BaseThread * pbase, const std::wstring & thread_name)
{
Add(pbase, thread_name.c_str());
}
void ThreadManager::Add(BaseThread & pbase, const std::wstring & thread_name)
{
Add(&pbase, thread_name.c_str());
}
void ThreadManager::StartAll()
{
synchro->Lock();
for(size_t i=0 ; i<thread_tab.size() ; ++i)
Start(i);
synchro->Unlock();
were_started = true;
}
void ThreadManager::Start(size_t i)
{
if( i < thread_tab.size() )
{
thread_tab[i].object->SetSynchro(synchro);
if( thread_tab[i].object->StartThread() )
{
log << log4 << "TM: thread " << i << " (" << thread_tab[i].object->ThreadId() << ", name: "
<< thread_tab[i].name << ") started" << logend;
}
else
{
log << log4 << "TM: cannot run a thread, thread number: " << i
<< ", name: " << thread_tab[i].name << logend;
}
}
}
void ThreadManager::StopAll()
{
if( !were_started )
return;
// WakeUpThread() should be used with Lock/Unlock
synchro->Lock();
for(size_t i=0 ; i<thread_tab.size() ; ++i)
thread_tab[i].object->WakeUpThread();
synchro->Unlock();
for(size_t i=0 ; i<thread_tab.size() ; ++i)
{
log << log4 << "TM: waiting for thread " << i << " (" << thread_tab[i].object->ThreadId()
<< ", name: " << thread_tab[i].name << ")" << logend;
thread_tab[i].object->WaitForThread();
log << log4 << "TM: thread " << i << " terminated" << logend;
}
}

View File

@@ -1,65 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2011-2012, Tomasz Sowa
* All rights reserved.
*
*/
#ifndef headerfile_winix_core_threadmanager
#define headerfile_winix_core_threadmanager
#include <string>
#include <vector>
#include "basethread.h"
#include "synchro.h"
class ThreadManager
{
public:
ThreadManager();
// synchro object
void SetSynchro(Synchro * psynchro);
// initializing
void Init();
// adding a new thread to the queue
// the thread will be running only if we call StartAll() before
// otherwise the thread will be waiting for StartAll()
void Add(BaseThread * pbase, const wchar_t * thread_name);
void Add(BaseThread & pbase, const wchar_t * thread_name);
void Add(BaseThread * pbase, const std::wstring & thread_name);
void Add(BaseThread & pbase, const std::wstring & thread_name);
// starting all threads
void StartAll();
// sending a stop signal to all threads
// and waiting until they finish
void StopAll();
private:
struct ThreadItem
{
BaseThread * object;
std::wstring name;
};
Synchro * synchro;
typedef std::vector<ThreadItem> ThreadTab;
ThreadTab thread_tab;
bool were_started;
void Start(size_t i);
};
#endif

View File

@@ -1,65 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2012, Tomasz Sowa
* All rights reserved.
*
*/
#include "user.h"
User::User()
{
Clear();
}
void User::Clear()
{
id = -1;
name.clear();
super_user = false;
groups.clear();
email.clear();
notify = 0;
env.Clear();
aenv.Clear();
status = WINIX_ACCOUNT_BLOCKED;
locale_id = 0;
time_zone_id = 0;
}
bool User::IsMemberOf(long group)
{
std::vector<long>::iterator i;
for(i=groups.begin() ; i!=groups.end() ; ++i)
if( *i == group )
return true;
return false;
}

View File

@@ -1,78 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2008-2012, Tomasz Sowa
* All rights reserved.
*
*/
#ifndef headerfile_winix_core_users
#define headerfile_winix_core_users
#include <map>
#include "user.h"
#include "ugcontainer.h"
#include "lastcontainer.h"
#include "cur.h"
#include "db/db.h"
class SessionManager;
class Users
{
typedef UGContainer<User> Table;
public:
typedef Table::Iterator Iterator;
typedef Table::SizeType SizeType;
LastContainer last;
Users();
void SetCur(Cur * pcur);
void SetSessionManager(SessionManager * sm);
void Clear();
void ReadUsers(Db * db);
bool AddUser(const User & user);
bool IsUser(const std::wstring & name);
User * GetUser(long user_id);
User * GetUser(const std::wstring & name);
long GetUserId(const std::wstring & name);
Iterator Begin();
Iterator End();
SizeType Size();
bool Remove(long user_id);
bool LoginUser(long user_id, bool remember_me, bool use_ses_log = false);
size_t LogoutUser(long user_id);
void LogoutCurrentUser();
void IncrementLoggedUsers();
long HowManyLogged();
private:
Table table;
Cur * cur;
SessionManager * session_manager;
long how_many_logged;
bool LoginUserCheckSession(bool use_ses_log);
User * LoginUserCheckStatus(long user_id, bool use_ses_log);
};
#endif

View File

@@ -1,19 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2008-2013, Tomasz Sowa
* All rights reserved.
*
*/
#ifndef headerfile_winix_core_version
#define headerfile_winix_core_version
#define WINIX_VER_MAJOR 0
#define WINIX_VER_MINOR 5
#define WINIX_VER_REVISION 6
#endif

View File

@@ -1,19 +0,0 @@
include Makefile.o.dep
all: $(o)
%.o: %.cpp
$(CXX) -c $(CXXFLAGS) $(CXXWINIXINCLUDEFLAGS) $<
depend:
makedepend -Y. $(CXXWINIXINCLUDEFLAGS) -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,72 +0,0 @@
# DO NOT DELETE
db.o: db.h dbbase.h dbconn.h dbtextstream.h ../../winix/core/textstream.h
db.o: ../../winix/core/misc.h ../../winix/core/item.h
db.o: ../../pikotools/space/space.h ../../pikotools/textstream/types.h
db.o: ../../pikotools/date/date.h ../../winix/core/requesttypes.h
db.o: ../../pikotools/textstream/textstream.h
db.o: ../../pikotools/convert/convert.h ../../pikotools/convert/inttostr.h
db.o: ../../pikotools/membuffer/membuffer.h
db.o: ../../pikotools/textstream/types.h ../../pikotools/utf8/utf8.h
db.o: ../../winix/core/error.h ../../pikotools/space/spaceparser.h
db.o: ../../pikotools/space/space.h dbitemquery.h ../../winix/core/item.h
db.o: dbitemcolumns.h ../../winix/core/user.h ../../winix/core/group.h
db.o: ../../winix/core/dircontainer.h ../../winix/core/ugcontainer.h
db.o: ../../winix/core/log.h ../../winix/core/textstream.h
db.o: ../../winix/core/logmanipulators.h ../../winix/core/slog.h
db.o: ../../winix/core/cur.h ../../winix/core/request.h
db.o: ../../winix/core/error.h ../../winix/core/config.h
db.o: ../../winix/core/htmlfilter.h ../../winix/templates/htmltextstream.h
db.o: ../../pikotools/space/spacetojson.h ../../winix/core/session.h
db.o: ../../winix/core/user.h ../../winix/core/plugindata.h
db.o: ../../winix/core/rebus.h ../../winix/core/ipban.h
db.o: ../../winix/core/mount.h ../../winix/templates/locale.h
db.o: ../../winix/core/log.h ../../winix/core/misc.h
dbbase.o: dbbase.h dbconn.h dbtextstream.h ../../winix/core/textstream.h
dbbase.o: ../../winix/core/misc.h ../../winix/core/item.h
dbbase.o: ../../pikotools/space/space.h ../../pikotools/textstream/types.h
dbbase.o: ../../pikotools/date/date.h ../../winix/core/requesttypes.h
dbbase.o: ../../pikotools/textstream/textstream.h
dbbase.o: ../../pikotools/convert/convert.h
dbbase.o: ../../pikotools/convert/inttostr.h
dbbase.o: ../../pikotools/membuffer/membuffer.h
dbbase.o: ../../pikotools/textstream/types.h ../../pikotools/utf8/utf8.h
dbbase.o: ../../winix/core/error.h ../../pikotools/space/spaceparser.h
dbbase.o: ../../pikotools/space/space.h ../../winix/core/log.h
dbbase.o: ../../winix/core/misc.h
dbconn.o: dbconn.h dbtextstream.h ../../winix/core/textstream.h
dbconn.o: ../../winix/core/misc.h ../../winix/core/item.h
dbconn.o: ../../pikotools/space/space.h ../../pikotools/textstream/types.h
dbconn.o: ../../pikotools/date/date.h ../../winix/core/requesttypes.h
dbconn.o: ../../pikotools/textstream/textstream.h
dbconn.o: ../../pikotools/convert/convert.h
dbconn.o: ../../pikotools/convert/inttostr.h
dbconn.o: ../../pikotools/membuffer/membuffer.h
dbconn.o: ../../pikotools/textstream/types.h ../../pikotools/utf8/utf8.h
dbconn.o: ../../winix/core/log.h ../../winix/core/error.h
dbitemcolumns.o: dbitemcolumns.h ../../winix/core/item.h dbbase.h dbconn.h
dbitemcolumns.o: dbtextstream.h ../../winix/core/textstream.h
dbitemcolumns.o: ../../winix/core/misc.h ../../winix/core/item.h
dbitemcolumns.o: ../../pikotools/space/space.h
dbitemcolumns.o: ../../pikotools/textstream/types.h
dbitemcolumns.o: ../../pikotools/date/date.h ../../winix/core/requesttypes.h
dbitemcolumns.o: ../../pikotools/textstream/textstream.h
dbitemcolumns.o: ../../pikotools/convert/convert.h
dbitemcolumns.o: ../../pikotools/convert/inttostr.h
dbitemcolumns.o: ../../pikotools/membuffer/membuffer.h
dbitemcolumns.o: ../../pikotools/textstream/types.h
dbitemcolumns.o: ../../pikotools/utf8/utf8.h ../../winix/core/error.h
dbitemcolumns.o: ../../pikotools/space/spaceparser.h
dbitemcolumns.o: ../../pikotools/space/space.h ../../winix/core/log.h
dbitemquery.o: dbitemquery.h ../../winix/core/item.h
dbtextstream.o: dbtextstream.h ../../winix/core/textstream.h
dbtextstream.o: ../../winix/core/misc.h ../../winix/core/item.h
dbtextstream.o: ../../pikotools/space/space.h
dbtextstream.o: ../../pikotools/textstream/types.h
dbtextstream.o: ../../pikotools/date/date.h ../../winix/core/requesttypes.h
dbtextstream.o: ../../pikotools/textstream/textstream.h
dbtextstream.o: ../../pikotools/convert/convert.h
dbtextstream.o: ../../pikotools/convert/inttostr.h
dbtextstream.o: ../../pikotools/membuffer/membuffer.h
dbtextstream.o: ../../pikotools/textstream/types.h
dbtextstream.o: ../../pikotools/utf8/utf8.h

View File

@@ -1,111 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2010-2012, Tomasz Sowa
* All rights reserved.
*
*/
#ifndef headerfile_winix_db_dbbase
#define headerfile_winix_db_dbbase
#include "dbconn.h"
#include "dbtextstream.h"
#include <vector>
#include <string>
#include "core/error.h"
#include "space/spaceparser.h"
#include "date/date.h"
class DbBase
{
public:
DbBase();
void SetConn(DbConn * conn);
void SetConn(DbConn & conn);
DbConn * GetConn();
void LogQueries(bool log_q);
PGresult * AssertQuery(const char * query);
PGresult * AssertQuery(const DbTextStream & query);
PGresult * AssertQuery(const char * q, ExecStatusType t);
PGresult * AssertQuery(const DbTextStream & query, ExecStatusType t);
void AssertResult(PGresult * r, ExecStatusType t);
static int AssertColumn(PGresult * r, const char * column_name);
// static assignments
static const char * AssertValue(PGresult * r, int row, int col);
static const std::wstring & AssertValueWide(PGresult * r, int row, int col); // warning: this method uses a static buffer
static void AssertValueWide(PGresult * r, int row, int col, std::wstring & result);
static void AssertValueBin(PGresult * r, int row, int col, std::string & result);
static long AssertValueLong(PGresult * r, int row, int col);
static int AssertValueInt(PGresult * r, int row, int col);
static bool AssertValueBool(PGresult * r, int row, int col);
static unsigned long AssertValueULong(PGresult * r, int row, int col);
static unsigned int AssertValueUInt(PGresult * r, int row, int col);
static PT::Date AssertValueDate(PGresult * r, int row, int col);
// non static assignments
bool AssertValueSpace(PGresult * r, int row, int col, PT::Space & space, bool split_single = true);
void ClearResult(PGresult * r);
long AssertCurrval(const char * table);
bool IsNull(PGresult * r, int row, int col);
int Rows(PGresult * r);
int Cols(PGresult * r);
long AffectedRows(PGresult * r);
void CreateIdList(const std::vector<long> & id_tab, std::wstring & list, bool add_parentheses = true);
Error DoCommand(const DbTextStream & command);
Error DoCommand(const char * command);
Error BeginTrans();
Error RollbackTrans();
Error CommitTrans();
Error EndTrans(Error err);
// new API (returns only bool)
bool EndTrans(bool everything_ok);
static void UnescapeBin(const char * str, size_t len, std::string & out, bool clear_out = true);
protected:
// a helper method for escaping strings
template<class RawType>
DbTextStream::RawText<RawType> R(const RawType & par)
{
return DbTextStream::RawText<RawType>(par);
}
DbConn * db_conn;
bool log_queries;
private:
// static int CharToInt(char c);
// static bool IsCorrectOctalDigit(char c);
// static int UnescapeBin(const char * str, size_t & i, size_t len);
static char UnescapeBinHexToDigit(char hex);
DbTextStream bquery;
PT::SpaceParser conf_parser;
};
#endif

View File

@@ -1,55 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2010, Tomasz Sowa
* All rights reserved.
*
*/
#ifndef headerfile_winix_db_dbconn
#define headerfile_winix_db_dbconn
#include <string>
#include <libpq-fe.h>
#include "dbtextstream.h"
class DbConn
{
public:
DbConn();
~DbConn();
void SetConnParam(const std::string & database, const std::string & user, const std::string & pass);
void Connect();
void WaitForConnection();
void Close();
bool AssertConnection(bool put_log = true, bool throw_if_no_connection = true);
void SetDbParameters();
PGconn * GetPgConn();
private:
void LogConnectionSocket();
PGconn * pg_conn;
std::string db_database, db_user, db_pass;
DbTextStream conn_info;
// a helper method for escaping strings
template<class RawType>
DbTextStream::RawText<RawType> R(const RawType & par)
{
return DbTextStream::RawText<RawType>(par);
}
};
#endif

View File

@@ -1,92 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2008-2012, Tomasz Sowa
* All rights reserved.
*
*/
#include "dbitemcolumns.h"
#include "dbbase.h"
#include "core/log.h"
void DbItemColumns::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");
link_to = PQfnumber(r, "link_to");
link_redirect = PQfnumber(r, "link_redirect");
subject = PQfnumber(r, "subject");
content = PQfnumber(r, "content");
content_type = PQfnumber(r, "content_type");
guest_name = PQfnumber(r, "guest_name");
html_template = PQfnumber(r, "template");
modification_user_id = PQfnumber(r, "modification_user_id");
file_path = PQfnumber(r, "file_path");
file_fs = PQfnumber(r, "file_fs");
file_type = PQfnumber(r, "file_type");
has_thumb = PQfnumber(r, "has_thumb");
hash = PQfnumber(r, "hash");
hash_type = PQfnumber(r, "hash_type");
file_size = PQfnumber(r, "file_size");
ref = PQfnumber(r, "ref");
modify_index = PQfnumber(r, "modify_index");
sort_index = PQfnumber(r, "sort_index");
meta = PQfnumber(r, "meta");
ameta = PQfnumber(r, "ameta");
}
void DbItemColumns::SetItem(PGresult * r, long row, Item & item)
{
if( id != -1 ) item.id = DbBase::AssertValueLong(r, row, id);
if( user_id != -1 ) item.user_id = DbBase::AssertValueLong(r, row, user_id);
if( group_id != -1 ) item.group_id = DbBase::AssertValueLong(r, row, group_id);
if( privileges != -1 ) item.privileges = DbBase::AssertValueInt(r, row, privileges);
if( date_creation != -1 ) item.date_creation = DbBase::AssertValueDate(r, row, date_creation);
if( date_modification != -1 ) item.date_modification = DbBase::AssertValueDate(r, row, date_modification);
if( type != -1 ) item.type = static_cast<Item::Type>( DbBase::AssertValueInt(r, row, type) );
if( parent_id != -1 ) item.parent_id = DbBase::AssertValueLong(r, row, parent_id);
if( content_id != -1 ) item.content_id = DbBase::AssertValueLong(r, row, content_id);
if( link_redirect != -1 ) item.link_redirect = DbBase::AssertValueInt(r, row, link_redirect);
if( content_type != -1 ) item.content_type = static_cast<Item::ContentType>( DbBase::AssertValueInt(r, row, content_type) );
if( modification_user_id != -1 ) item.modification_user_id = DbBase::AssertValueLong(r, row, modification_user_id);
if( file_fs != -1 ) item.file_fs = DbBase::AssertValueInt(r, row, file_fs);
if( file_type != -1 ) item.file_type = DbBase::AssertValueInt(r, row, file_type);
if( has_thumb != -1 ) item.has_thumb = DbBase::AssertValueBool(r, row, has_thumb);
if( hash != -1 ) DbBase::AssertValueWide(r, row, hash, item.hash);
if( hash_type != -1 ) item.hash_type = DbBase::AssertValueInt(r, row, hash_type);
if( file_size != -1 ) item.file_size = DbBase::AssertValueLong(r, row, file_size);
if( ref != -1 ) item.ref = DbBase::AssertValueInt(r, row, ref);
if( modify_index != -1 ) item.modify_index = DbBase::AssertValueInt(r, row, modify_index);
if( url != -1 ) DbBase::AssertValueWide(r, row, url, item.url);
if( content != -1 ) DbBase::AssertValueWide(r, row, content, item.content);
if( subject != -1 ) DbBase::AssertValueWide(r, row, subject, item.subject);
if( file_path != -1 ) DbBase::AssertValueWide(r, row, file_path, item.file_path);
if( link_to != -1 ) DbBase::AssertValueWide(r, row, link_to, item.link_to);
if( guest_name != -1 ) DbBase::AssertValueWide(r, row, guest_name, item.guest_name);
if( html_template != -1 ) DbBase::AssertValueWide(r, row, html_template, item.html_template);
if( sort_index != -1 ) item.sort_index = DbBase::AssertValueInt(r, row, sort_index);
if( meta != -1 ) db_base.AssertValueSpace(r, row, meta, item.meta);
if( ameta != -1 ) db_base.AssertValueSpace(r, row, ameta, item.ameta);
}

View File

@@ -1,70 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2010-2012, Tomasz Sowa
* All rights reserved.
*
*/
#ifndef headerfile_winix_db_dbitemcolumns
#define headerfile_winix_db_dbitemcolumns
#include <libpq-fe.h>
#include "core/item.h"
#include "dbbase.h"
struct DbItemColumns
{
int id;
int user_id;
int group_id;
int privileges;
int date_creation;
int date_modification;
int url;
int type;
int parent_id;
int content_id;
int link_to;
int link_redirect;
int subject;
int content;
int content_type;
int guest_name;
int modification_user_id;
int html_template;
int file_path;
int file_fs;
int file_type;
int has_thumb;
int hash;
int hash_type;
int file_size;
int ref;
int modify_index;
int sort_index;
int meta;
int ameta;
DbItemColumns(DbBase & db_base_) : db_base(db_base_)
{
}
void SetColumns(PGresult * r);
void SetItem(PGresult * r, long row, Item & item);
private:
DbBase & db_base;
};
#endif

View File

@@ -1,19 +0,0 @@
include Makefile.o.dep
all: $(o)
%.o: %.cpp
$(CXX) -c $(CXXFLAGS) $(CXXWINIXINCLUDEFLAGS) $<
depend:
makedepend -Y. $(CXXWINIXINCLUDEFLAGS) -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

File diff suppressed because it is too large Load Diff

View File

@@ -1,41 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2013, Tomasz Sowa
* All rights reserved.
*
*/
#ifndef headerfile_winix_functions_account
#define headerfile_winix_functions_account
#include "functionbase.h"
namespace Fun
{
class Account : public FunctionBase
{
public:
Account();
void MakeGet();
void MakePost();
bool ActivateAccount(const std::wstring & login, long code, bool use_ses_log = false);
private:
bool ActivateAccount(User * puser, long code, bool use_ses_log);
void ActivateAccount();
};
} // namespace
#endif

View File

@@ -1,52 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2010-2012, Tomasz Sowa
* All rights reserved.
*
*/
#ifndef headerfile_winix_functions_adduser
#define headerfile_winix_functions_adduser
#include "functionbase.h"
#include "core/user.h"
namespace Fun
{
class AddUser : public FunctionBase
{
public:
AddUser();
void MakePost();
void MakeGet();
bool IsLoginCorrect(const std::wstring & login, bool use_ses_log = false);
bool IsEmailCorrect(const std::wstring & email, bool use_ses_log = false);
bool HasLoginCorrectChars(const std::wstring & login);
bool AddNewUser(User & user, const std::wstring & pass);
bool AddNewUser(const std::wstring & login,
const std::wstring & pass,
const std::wstring & email,
bool autoactivate,
bool try_login,
bool use_ses_log = false);
private:
UserPass up;
User user;
};
} // namespace
#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.
*
*/
#include "cat.h"
namespace Fun
{
Cat::Cat()
{
fun.url = L"cat";
}
void Cat::MakeGet()
{
if( !cur->request->is_item )
{
log << log1 << "Content: cat function requires an item" << logend;
cur->request->status = WINIX_ERR_NO_ITEM;
return;
}
if( !system->HasReadAccess(cur->request->item) )
{
cur->request->status = WINIX_ERR_PERMISSION_DENIED;
return;
}
cur->request->send_as_attachment = cur->request->IsParam(L"attachment");
}
} // namespace

View File

@@ -1,33 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2010, Tomasz Sowa
* All rights reserved.
*
*/
#ifndef headerfile_winix_functions_cat
#define headerfile_winix_functions_cat
#include "functionbase.h"
namespace Fun
{
class Cat : public FunctionBase
{
public:
Cat();
void MakeGet();
};
} // namespace Fun
#endif

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 "chmod.h"
namespace Fun
{
Chmod::Chmod()
{
fun.url = L"chmod";
}
void Chmod::MakePost()
{
priv_changer.SetCur(cur);
priv_changer.SetSystem(system);
priv_changer.SetDb(db);
priv_changer.Change(false, true);
}
void Chmod::MakeGet()
{
priv_changer.SetCur(cur);
priv_changer.SetSystem(system);
priv_changer.SetDb(db);
priv_changer.CheckAccess();
}
} // namespace

View File

@@ -1,38 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2010, Tomasz Sowa
* All rights reserved.
*
*/
#ifndef headerfile_winix_functions_chmod
#define headerfile_winix_functions_chmod
#include "functionbase.h"
#include "privchanger.h"
namespace Fun
{
class Chmod : public FunctionBase
{
public:
Chmod();
void MakePost();
void MakeGet();
private:
PrivChanger priv_changer;
};
} // namespace
#endif

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 "chown.h"
namespace Fun
{
Chown::Chown()
{
fun.url = L"chown";
}
void Chown::MakePost()
{
priv_changer.SetCur(cur);
priv_changer.SetSystem(system);
priv_changer.SetDb(db);
priv_changer.Change(true, false);
}
void Chown::MakeGet()
{
priv_changer.SetCur(cur);
priv_changer.SetSystem(system);
priv_changer.SetDb(db);
priv_changer.CheckAccess();
}
} // namespace

View File

@@ -1,38 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2010, Tomasz Sowa
* All rights reserved.
*
*/
#ifndef headerfile_winix_functions_chown
#define headerfile_winix_functions_chown
#include "functionbase.h"
#include "privchanger.h"
namespace Fun
{
class Chown : public FunctionBase
{
public:
Chown();
void MakePost();
void MakeGet();
private:
PrivChanger priv_changer;
};
} // namespace
#endif

View File

@@ -1,53 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2008-2011, Tomasz Sowa
* All rights reserved.
*
*/
#include "ckeditor.h"
#include "functions.h"
namespace Fun
{
Ckeditor::Ckeditor()
{
fun.url = L"ckeditor";
}
void Ckeditor::Init()
{
system->AddCommonFileToVar(L"winix/ckeditor_full.js", L"ckeditor_full.js");
system->AddCommonFileToVar(L"winix/ckeditor_winix.js", L"ckeditor_winix.js");
}
bool Ckeditor::HasAccess()
{
return functions->fun_emacs.HasAccess();
}
void Ckeditor::MakeGet()
{
cur->session->last_css.clear();
int parcss = system->mounts.MountParCss();
if( cur->mount->param[parcss].defined )
cur->session->last_css = cur->mount->param[parcss].arg;
}
void Ckeditor::MakePost()
{
functions->fun_emacs.MakePost();
}
} // namespace

View File

@@ -1,36 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2011, Tomasz Sowa
* All rights reserved.
*
*/
#ifndef headerfile_winix_functions_ckeditor
#define headerfile_winix_functions_ckeditor
#include "functionbase.h"
namespace Fun
{
class Ckeditor : public FunctionBase
{
public:
Ckeditor();
void Init();
bool HasAccess();
void MakeGet();
void MakePost();
};
} // namespace
#endif

View File

@@ -1,52 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2008-2010, Tomasz Sowa
* All rights reserved.
*
*/
#include "default.h"
namespace Fun
{
Default::Default()
{
fun.url = L"default";
}
bool Default::HasAccess()
{
return !cur->request->is_item && system->HasWriteAccess(*cur->request->dir_tab.back());
}
void Default::MakePost()
{
Item & dir = *cur->request->dir_tab.back();
dir.link_to = cur->request->PostVar(L"linkto");
dir.link_redirect = cur->request->IsPostVar(L"makeredirect") ? 1 : 0;
TrimWhite(dir.link_to);
// !! dodac sprawdzenie czy link_to jest pusty teraz
cur->request->status = db->EditLinkItem(dir.id, dir.link_to, dir.link_redirect);
if( cur->request->status == WINIX_ERR_OK )
{
log << log2 << "Default: changed link_to: " << dir.link_to << ", for dir_id: " << dir.id << logend;
system->RedirectToLastDir();
}
}
} // namespace

View File

@@ -1,34 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2010, Tomasz Sowa
* All rights reserved.
*
*/
#ifndef headerfile_winix_functions_default
#define headerfile_winix_functions_default
#include "functionbase.h"
namespace Fun
{
class Default : public FunctionBase
{
public:
Default();
bool HasAccess();
void MakePost();
};
} // namespace
#endif

View File

@@ -1,54 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2008-2010, Tomasz Sowa
* All rights reserved.
*
*/
#include "download.h"
namespace Fun
{
Download::Download()
{
fun.url = L"download";
}
void Download::MakeGet()
{
// !! moze wywalic to no_item i wszedzie w takich miejscach dac poprostu permission_denied?
if( !cur->request->is_item )
{
log << log1 << "Content: download function requires an item" << logend;
cur->request->status = WINIX_ERR_NO_ITEM;
return;
}
if( !system->HasReadAccess(cur->request->item) ||
cur->request->item.file_type == WINIX_ITEM_FILETYPE_NONE ||
cur->request->item.file_path.empty() )
{
cur->request->status = WINIX_ERR_PERMISSION_DENIED;
return;
}
cur->request->send_as_attachment = cur->request->IsParam(L"attachment");
if( cur->request->item.has_thumb && cur->request->IsParam(L"thumb") )
system->MakeFilePath(cur->request->item, cur->request->x_sendfile, true);
else
system->MakeFilePath(cur->request->item, cur->request->x_sendfile);
}
} // namespace

View File

@@ -1,35 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2010, Tomasz Sowa
* All rights reserved.
*
*/
#ifndef headerfile_winix_functions_download
#define headerfile_winix_functions_download
#include "functionbase.h"
namespace Fun
{
class Download : public FunctionBase
{
public:
Download();
void MakeGet();
private:
};
} // namespace
#endif

View File

@@ -1,43 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2010, Tomasz Sowa
* All rights reserved.
*
*/
#ifndef headerfile_winix_functions_emacs
#define headerfile_winix_functions_emacs
#include "functionbase.h"
namespace Fun
{
class Emacs : public FunctionBase
{
public:
Emacs();
bool HasAccess();
void MakePost();
private:
bool HasAccess(const Item & item); // !! takie funkcje to nie powinny byc skladowe modelu?
bool PostEmacsCheckAbuse(bool adding);
void PostFunEmacsModifyMountPoint(bool adding);
int NotifyCodeEdit();
int NotifyCodeAdd();
std::wstring old_url;
};
} // namespace
#endif

View File

@@ -1,53 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2012, Tomasz Sowa
* All rights reserved.
*
*/
#ifndef headerfile_winix_functions_env
#define headerfile_winix_functions_env
#include "functionbase.h"
#include "space/spaceparser.h"
namespace Fun
{
class Env : public FunctionBase
{
public:
Env();
bool EditAdminEnv(long user_id, const std::wstring & env_str, bool use_ses_log = false);
bool EditEnv(long user_id, const std::wstring & env_str, bool use_ses_log = false);
bool HasAccess();
void MakePost();
// used mainly by templates
// can return a null pointer
User * GetUser();
private:
PT::SpaceParser conf_parser;
PT::Space space;
User * puser;
size_t req_id;
bool Parse(const std::wstring & env_str);
void SaveEnv();
};
} // namespace
#endif

View File

@@ -1,108 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2010-2012, Tomasz Sowa
* All rights reserved.
*
*/
#include "functionbase.h"
#include "functions.h"
FunctionBase::FunctionBase()
{
follow_symlinks = true;
template_index = size_t(-1);
need_ssl = false;
fun.user_id = -1;
fun.group_id = -1;
fun.privileges = 07555;
fun.parent_id = -1;
fun.id = -1;
fun.type = Item::file;
}
void FunctionBase::SetConfig(Config * pconfig)
{
config = pconfig;
}
void FunctionBase::SetCur(Cur * pcur)
{
cur = pcur;
}
void FunctionBase::SetDb(Db * pdb)
{
db = pdb;
}
void FunctionBase::SetSystem(System * psystem)
{
system = psystem;
}
void FunctionBase::SetFunctions(Functions * pfunctions)
{
functions = pfunctions;
}
void FunctionBase::SetTemplates(Templates * ptemplates)
{
templates = ptemplates;
}
void FunctionBase::SetSynchro(Synchro * psynchro)
{
synchro = psynchro;
}
void FunctionBase::SetSessionManager(SessionManager * pmanager)
{
session_manager = pmanager;
}
void FunctionBase::Init()
{
// this method is called only once at the beginning
// when winix starts
}
bool FunctionBase::HasAccess()
{
// true by default
return true;
}
void FunctionBase::MakePost()
{
// do nothing by default
}
void FunctionBase::MakeGet()
{
// do nothing by default
}

View File

@@ -1,81 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2010-2012, Tomasz Sowa
* All rights reserved.
*
*/
#ifndef headerfile_winix_functions_functionbase
#define headerfile_winix_functions_functionbase
#include <string>
#include <vector>
#include "core/item.h"
#include "db/db.h"
#include "core/request.h"
#include "core/config.h"
#include "core/system.h"
#include "core/synchro.h"
#include "notify/notify.h"
class Functions;
class Templates;
class FunctionBase
{
public:
FunctionBase();
// user, group, permissions, url (function name)
Item fun;
// auto follow sym links, default: true
bool follow_symlinks;
// html template index (for using with 'patterns' object)
size_t template_index;
// 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;
virtual void Init();
virtual bool HasAccess();
virtual void MakePost();
virtual void MakeGet();
void SetConfig(Config * pconfig);
void SetCur(Cur * pcur);
void SetDb(Db * pdb);
void SetSystem(System * psystem);
void SetFunctions(Functions * pfunctions);
void SetTemplates(Templates * ptemplates);
void SetSynchro(Synchro * psynchro);
void SetSessionManager(SessionManager * pmanager);
protected:
Config * config;
Cur * cur;
Db * db;
System * system;
Functions * functions;
Templates * templates;
Synchro * synchro;
SessionManager * session_manager;
};
#endif

View File

@@ -1,75 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2008-2011, Tomasz Sowa
* All rights reserved.
*
*/
#ifndef headerfile_winix_functions_functionparser
#define headerfile_winix_functions_functionparser
#include <string>
#include "db/db.h"
#include "core/cur.h"
#include "core/system.h"
class Functions;
class FunctionParser
{
public:
FunctionParser();
bool Parse(Cur * pcur, Db * pdb, Functions * pfunctions, System * psystem);
void UTF8(bool use_utf8);
private:
Db * db;
Cur * cur;
System * system;
Functions * functions;
const char * path;
std::string name_ascii, value_ascii;
std::wstring name, value;
Item * last_dir;
Param param;
bool utf8;
void SkipSlashes();
void ParseDirsItemFunction();
void ParseParams();
void ParseAnchor();
bool IsDir();
bool CheckAddItem();
bool CheckAddFunction();
bool AddRootDir();
void AddDir();
void AddParam();
void ParseOrdinaryParams();
void ParseWinixParams();
void ToWide(const std::string & src, std::wstring & dst);
int FromHex(int c);
int GetChar();
void ReadName();
void ReadOrdinaryParName();
void ReadOrdinaryParValue();
void ReadWinixParName();
void ReadWinixParValue();
};
#endif

View File

@@ -1,42 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2013, Tomasz Sowa
* All rights reserved.
*
*/
#ifndef headerfile_winix_functions_imgcrop
#define headerfile_winix_functions_imgcrop
#include "functionbase.h"
namespace Fun
{
class ImgCrop : public FunctionBase
{
public:
ImgCrop();
bool HasAccess();
void MakeGet();
void MakePost();
private:
DbItemQuery iq;
void GetDirContent();
};
} // namespace
#endif

View File

@@ -1,73 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2012, Tomasz Sowa
* All rights reserved.
*
*/
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include "ipban.h"
#include "functions.h"
#include "core/sessionmanager.h"
namespace Fun
{
IPBanFun::IPBanFun()
{
fun.url = L"ipban";
}
bool IPBanFun::HasAccess()
{
return cur->session->puser && cur->session->puser->super_user;
}
void IPBanFun::MakePost()
{
}
void IPBanFun::MakeGet()
{
if( cur->request->IsParam(L"removeip") )
{
if( cur->request->ParamValue(L"removeip") == L"all" )
{
session_manager->ClearIPBanList();
cur->session->ip_ban = 0;
}
else
{
int cur_ip = 0;
if( cur->session->ip_ban )
cur_ip = cur->session->ip_ban->ip;
AssignString(cur->request->ParamValue(L"removeip"), tmp_ip_str);
int ip = (int)inet_addr(tmp_ip_str.c_str());
session_manager->RemoveIPBan(ip);
if( cur->session->ip_ban && cur_ip == ip )
cur->session->ip_ban = 0;
}
system->RedirectToLastFunction();
}
}
} // namespace

View File

@@ -1,40 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2012, Tomasz Sowa
* All rights reserved.
*
*/
#ifndef headerfile_winix_functions_ipban
#define headerfile_winix_functions_ipban
#include "functionbase.h"
namespace Fun
{
// IPBanFun in order to not confused with IPBan from core winix
class IPBanFun : public FunctionBase
{
public:
IPBanFun();
bool HasAccess();
void MakePost();
void MakeGet();
private:
std::string tmp_ip_str;
};
} // namespace
#endif

View File

@@ -1,29 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2008-2012, Tomasz Sowa
* All rights reserved.
*
*/
#include "last.h"
namespace Fun
{
Last::Last()
{
fun.url = L"last";
}
bool Last::HasAccess()
{
return cur->session->puser != 0;
}
} // namespace

View File

@@ -1,36 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2010-2012, Tomasz Sowa
* All rights reserved.
*
*/
#ifndef headerfile_winix_functions_last
#define headerfile_winix_functions_last
#include "functionbase.h"
namespace Fun
{
class Last : public FunctionBase
{
public:
Last();
bool HasAccess();
private:
};
} // namespace
#endif

View File

@@ -1,111 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2010-2012, Tomasz Sowa
* All rights reserved.
*
*/
#include "ln.h"
#include "core/misc.h"
#include "functions/functions.h"
namespace Fun
{
Ln::Ln()
{
fun.url = L"ln";
}
bool Ln::HasAccess()
{
return system->HasWriteAccess(*cur->request->dir_tab.back());
}
void Ln::CreateSymbolicLink(const std::wstring & link_to)
{
item.Clear(); // setting the date to now
item.type = Item::symlink;
item.parent_id = cur->request->dir_tab.back()->id;
item.url = cur->request->PostVar(L"url");
item.link_to = link_to;
item.link_redirect = cur->request->IsPostVar(L"makeredirect") ? 1 : 0;
item.privileges = system->NewFilePrivileges();
functions->SetUser(item);
functions->PrepareUrl(item);
cur->request->status = db->AddItem(item);
if( cur->request->status == WINIX_ERR_OK )
log << log3 << "Ln: created a symbolic link to: " << link_to << logend;
}
void Ln::CreateHardLink(const std::wstring & link_to)
{
int res = system->FollowAllLinks(cur->request->dir_tab, link_to, dir_tab, item, false, false);
if( res == 0 )
{
log << log2 << "Ln: " << link_to << " is a directory (can't create a hard link)" << logend;
cur->request->status = WINIX_ERR_PERMISSION_DENIED;
}
else
if( res == 1 )
{
item.SetDateToNow();
item.type = Item::file;
item.parent_id = cur->request->dir_tab.back()->id;
item.url = cur->request->PostVar(L"url");
item.privileges = system->NewFilePrivileges();
functions->SetUser(item);
functions->PrepareUrl(item);
cur->request->status = db->AddHardLink(item);
if( cur->request->status == WINIX_ERR_OK )
log << log3 << "Ln: created a hard link to: " << link_to << logend;
}
else
if( res == 5 || res == 6 )
{
cur->request->status = WINIX_ERR_PERMISSION_DENIED;
}
else
{
cur->request->status = WINIX_ERR_NO_ITEM;
}
}
// we do not use notifications for links
void Ln::MakePost()
{
link_to = cur->request->PostVar(L"linkto");
TrimWhite(link_to);
if( link_to.empty() )
return;
int type = Toi(cur->request->PostVar(L"linktype"));
if( type == 0 )
CreateHardLink(link_to);
else
CreateSymbolicLink(link_to);
if( cur->request->status == WINIX_ERR_OK )
system->RedirectTo(item);
}
} // namespace

View File

@@ -1,42 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2010, Tomasz Sowa
* All rights reserved.
*
*/
#ifndef headerfile_winix_functions_ln
#define headerfile_winix_functions_ln
#include "functionbase.h"
namespace Fun
{
class Ln : public FunctionBase
{
public:
Ln();
bool HasAccess();
void CreateSymbolicLink(const std::wstring & link_to);
void CreateHardLink(const std::wstring & link_to);
void MakePost();
private:
Item item;
std::wstring link_to;
std::vector<Item*> dir_tab;
};
} // namespace
#endif

View File

@@ -1,60 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2012, Tomasz Sowa
* All rights reserved.
*
*/
#include "locale.h"
#include "templates/templates.h"
namespace Fun
{
Locale::Locale()
{
fun.url = L"locale";
}
bool Locale::HasAccess()
{
return cur->session->puser != 0;
}
void Locale::MakePost()
{
if( cur->session->puser )
{
size_t locale_id = size_t(Toi(cur->request->PostVar(L"localeid")));
if( TemplatesFunctions::locale.HasLanguage(locale_id) )
{
cur->session->puser->locale_id = locale_id;
db->ChangeUserLocale(cur->session->puser->id, locale_id);
TemplatesFunctions::locale.SetCurLang(locale_id);
}
else
{
log << log1 << "Locale: incorrect locale id: " << locale_id << logend;
}
}
}
void Locale::MakeGet()
{
}
} // namespace

View File

@@ -1,38 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2012, Tomasz Sowa
* All rights reserved.
*
*/
#ifndef headerfile_winix_functions_locale
#define headerfile_winix_functions_locale
#include "functionbase.h"
namespace Fun
{
class Locale : public FunctionBase
{
public:
Locale();
bool HasAccess();
void MakePost();
void MakeGet();
private:
};
} // namespace
#endif

View File

@@ -1,59 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2010-2012, Tomasz Sowa
* All rights reserved.
*
*/
#ifndef headerfile_winix_functions_login
#define headerfile_winix_functions_login
#include "functionbase.h"
#include "core/user.h"
namespace Fun
{
class Login : public FunctionBase
{
public:
Login();
void MakePost();
void MakeGet();
bool ShouldUseCaptchaForCurrentIP();
bool ShouldUseCaptchaFor(const IPBan & ipban);
bool CannotLoginFromCurrentIP();
bool CannotLoginFrom(const IPBan & ipban);
bool CheckUserPass(const std::wstring & login, const std::wstring & password, long & user_id);
bool LoginUser(const std::wstring & login, const std::wstring & password, bool remember_me,
bool use_ses_log = false, bool check_abuse = false);
private:
void ClearTmpStruct();
bool CheckPasswords(const std::wstring & password);
void AddBanInfo();
bool CheckAbuse();
UserPass up, up2;
std::string pass_decrypted;
std::wstring pass_hashed;
std::wstring salt;
};
} // namespace
#endif

View File

@@ -1,35 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2008-2012, Tomasz Sowa
* All rights reserved.
*
*/
#include "logout.h"
namespace Fun
{
Logout::Logout()
{
fun.url = L"logout";
}
void Logout::MakeGet()
{
if( cur->session->puser )
{
system->users.LogoutCurrentUser();
system->RedirectToLastItem();
}
}
} // namespace

View File

@@ -1,35 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2010-2012, Tomasz Sowa
* All rights reserved.
*
*/
#ifndef headerfile_winix_functions_logout
#define headerfile_winix_functions_logout
#include "functionbase.h"
namespace Fun
{
class Logout : public FunctionBase
{
public:
Logout();
void MakeGet();
private:
};
} // namespace
#endif

View File

@@ -1,54 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2008-2010, Tomasz Sowa
* All rights reserved.
*
*/
#include "ls.h"
namespace Fun
{
Ls::Ls()
{
fun.url = L"ls";
}
void Ls::MakeGet()
{
if( !cur->request->is_item )
{
DbItemQuery iq;
iq.sel_content = false;
iq.WhereParentId(cur->request->dir_tab.back()->id);
iq.WhereType(Item::dir, false);
if( cur->request->IsParam(L"ckeditor_browse") )
{
iq.WhereFileType(WINIX_ITEM_FILETYPE_IMAGE);
db->GetItems(cur->request->item_tab, iq);
}
else
{
db->GetItems(cur->request->item_tab, iq);
}
}
}
} // namespace

View File

@@ -1,37 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2010, Tomasz Sowa
* All rights reserved.
*
*/
#ifndef headerfile_winix_functions_ls
#define headerfile_winix_functions_ls
#include "functionbase.h"
namespace Fun
{
class Ls : public FunctionBase
{
public:
Ls();
void MakeGet();
private:
};
} // namespace
#endif

View File

@@ -1,27 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2012, Tomasz Sowa
* All rights reserved.
*
*/
#include "man.h"
#include "functions.h"
namespace Fun
{
Man::Man()
{
fun.url = L"man";
}
} // namespace

View File

@@ -1,32 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2012, Tomasz Sowa
* All rights reserved.
*
*/
#ifndef headerfile_winix_functions_man
#define headerfile_winix_functions_man
#include "functionbase.h"
namespace Fun
{
class Man : public FunctionBase
{
public:
Man();
};
} // namespace
#endif

View File

@@ -1,47 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2011-2012, Tomasz Sowa
* All rights reserved.
*
*/
#ifndef headerfile_winix_functions_meta
#define headerfile_winix_functions_meta
#include "functionbase.h"
#include "space/spaceparser.h"
namespace Fun
{
class Meta : public FunctionBase
{
public:
Meta();
bool HasAccess();
void MakePost();
bool EditAdminMeta(long item_id, const std::wstring & meta_str, bool use_ses_log = false);
bool EditMeta(long item_id, const std::wstring & meta_str, bool use_ses_log = false);
private:
PT::SpaceParser conf_parser;
PT::Space space;
bool Parse(const std::wstring & meta_str);
void ChangeAdminMeta();
void ChangeMeta();
};
} // namespace
#endif

View File

@@ -1,96 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2008-2012, Tomasz Sowa
* All rights reserved.
*
*/
#include "mkdir.h"
#include "functions.h"
#include "core/plugin.h"
namespace Fun
{
Mkdir::Mkdir()
{
fun.url = L"mkdir";
}
bool Mkdir::HasAccess(const Item & item)
{
// you can create a directory only in a directory
if( item.type != Item::dir )
return false;
if( cur->session->puser && cur->session->puser->super_user )
// super user can use mkdir everywhere
return true;
if( !system->HasWriteAccess(item) )
return false;
if( !system->mounts.pmount->IsPar(system->mounts.MountParMkdirOn()) )
return true;
if( system->mounts.pmount->IsArg(system->mounts.MountParMkdirOn(), cur->request->dir_tab.size()) )
return true;
return false;
}
bool Mkdir::HasAccess()
{
if( cur->request->is_item || !HasAccess(*cur->request->dir_tab.back()) )
return false;
return true;
}
void Mkdir::PostFunMkdir(bool add_to_dir_tab, int privileges)
{
functions->ReadItem(cur->request->item, Item::dir);
functions->SetUser(cur->request->item);
cur->request->item.privileges = privileges;
Item * pdir;
cur->request->status = system->dirs.AddDirectory(cur->request->item, add_to_dir_tab, &pdir);
if( cur->request->status == WINIX_ERR_OK )
{
if( pdir )
plugin.Call(WINIX_DIR_ADDED, pdir);
system->RedirectTo(cur->request->item);
}
else
{
log << log1 << "Content: PostFunMkdir: Error: " << cur->request->status << logend;
}
}
void Mkdir::MakePost()
{
PostFunMkdir(false, system->NewDirPrivileges());
}
} // namespace

View File

@@ -1,39 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2010, Tomasz Sowa
* All rights reserved.
*
*/
#ifndef headerfile_winix_functions_mkdir
#define headerfile_winix_functions_mkdir
#include "functionbase.h"
namespace Fun
{
class Mkdir : public FunctionBase
{
public:
Mkdir();
bool HasAccess();
void MakePost();
private:
bool HasAccess(const Item & item); // !! moze to powinien byc skladnik modelu?
bool FunMkdirCheckAccess();
void PostFunMkdir(bool add_to_dir_tab, int privileges);
};
} // namespace
#endif

View File

@@ -1,41 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2011, Tomasz Sowa
* All rights reserved.
*
*/
#include "mount.h"
#include "functions.h"
namespace Fun
{
Mount::Mount()
{
fun.url = L"mount";
}
bool Mount::HasAccess()
{
if( cur->session->puser && cur->session->puser->super_user )
return true;
return false;
}
void Mount::MakeGet()
{
}
} // namespace

View File

@@ -1,34 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2011, Tomasz Sowa
* All rights reserved.
*
*/
#ifndef headerfile_winix_functions_mount
#define headerfile_winix_functions_mount
#include "functionbase.h"
namespace Fun
{
class Mount : public FunctionBase
{
public:
Mount();
bool HasAccess();
void MakeGet();
};
} // namespace
#endif

View File

@@ -1,38 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2011, Tomasz Sowa
* All rights reserved.
*
*/
#include "nicedit.h"
#include "functions.h"
namespace Fun
{
Nicedit::Nicedit()
{
fun.url = L"nicedit";
}
bool Nicedit::HasAccess()
{
return functions->fun_emacs.HasAccess();
}
void Nicedit::MakePost()
{
functions->fun_emacs.MakePost();
}
} // namespace

View File

@@ -1,34 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2011, Tomasz Sowa
* All rights reserved.
*
*/
#ifndef headerfile_winix_functions_nicedit
#define headerfile_winix_functions_nicedit
#include "functionbase.h"
namespace Fun
{
class Nicedit : public FunctionBase
{
public:
Nicedit();
bool HasAccess();
void MakePost();
};
} // namespace
#endif

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 "node.h"
namespace Fun
{
Node::Node()
{
fun.url = L"node";
}
void Node::MakeGet()
{
if( cur->request->param_tab.empty() )
{
//cur->request->status = Error
//!!zglosic 404
return;
}
long id = Tol(cur->request->param_tab[0].name);
system->RedirectTo(id);
}
} // namespace

View File

@@ -1,36 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2010, Tomasz Sowa
* All rights reserved.
*
*/
#ifndef headerfile_winix_functions_node
#define headerfile_winix_functions_node
#include "functionbase.h"
namespace Fun
{
class Node : public FunctionBase
{
public:
Node();
void MakeGet();
private:
};
} // namespace
#endif

View File

@@ -1,51 +0,0 @@
/*
* This file is a part of Winix
* and is not publicly distributed
*
* Copyright (c) 2011-2013, Tomasz Sowa
* All rights reserved.
*
*/
#ifndef headerfile_winix_functions_passwd
#define headerfile_winix_functions_passwd
#include "functionbase.h"
#include "core/user.h"
namespace Fun
{
class Passwd : public FunctionBase
{
public:
Passwd();
bool HasAccess();
void MakeGet();
void MakePost();
bool IsPasswordCorrect(const std::wstring & pass, const std::wstring & conf_pass, bool use_ses_log = false);
bool ChangePassword(long user_id, const std::wstring & new_password);
bool ResetPassword(const std::wstring & login, long code, bool use_ses_log = false, bool only_check_access = false);
private:
UserPass up;
void ChangePassword(User * puser);
bool ResetPassword(User * puser, long code, bool use_ses_log);
bool SetNewPassword(User * puser, bool use_ses_log);
bool ResetPassword(User * puser, long code, bool use_ses_log, bool only_check_access);
void ResetPassword();
void ShowResetPasswordForm();
};
} // namespace
#endif

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