2015-04-13 04:09:02 -05:00
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; fill-column: 100 -*- */
2015-03-17 18:56:15 -05:00
/*
* This Source Code Form is subject to the terms of the Mozilla Public
* License , v . 2.0 . If a copy of the MPL was not distributed with this
* file , You can obtain one at http : //mozilla.org/MPL/2.0/.
*/
2020-04-18 03:39:50 -05:00
# pragma once
2015-03-17 18:56:15 -05:00
2018-02-16 10:23:25 -06:00
# include <algorithm>
2015-12-27 21:47:39 -06:00
# include <atomic>
2019-07-19 05:39:59 -05:00
# include <chrono>
2021-04-15 10:43:44 -05:00
# include <cstdio>
2016-12-21 14:37:22 -06:00
# include <map>
2017-11-07 07:12:18 -06:00
# include <set>
2020-07-27 04:27:00 -05:00
# include <unordered_set>
2016-03-08 01:31:29 -06:00
# include <string>
2020-06-01 21:46:49 -05:00
# include <utility>
2015-03-17 18:56:15 -05:00
2020-04-02 10:11:36 -05:00
# include <signal.h>
2015-07-13 09:13:06 -05:00
# include <Poco/Path.h>
2017-11-07 07:12:18 -06:00
# include <Poco/Util/AbstractConfiguration.h>
2016-03-08 01:31:29 -06:00
# include <Poco/Util/OptionSet.h>
# include <Poco/Util/ServerApplication.h>
2015-03-17 18:56:15 -05:00
2015-12-27 21:47:39 -06:00
# include "Util.hpp"
2020-01-17 16:31:41 -06:00
# include "FileUtil.hpp"
2020-05-12 10:19:41 -05:00
# include "RequestDetails.hpp"
2020-04-02 10:11:36 -05:00
# include "WebSocketHandler.hpp"
2015-12-27 21:47:39 -06:00
2017-03-04 17:07:17 -06:00
class ChildProcess ;
2016-08-17 18:57:38 -05:00
class TraceFileWriter ;
2017-03-30 04:15:28 -05:00
class DocumentBroker ;
2019-07-04 04:50:33 -05:00
class ClipboardCache ;
2016-08-17 18:57:38 -05:00
2020-04-24 02:46:54 -05:00
std : : shared_ptr < ChildProcess > getNewChild_Blocks ( unsigned mobileAppDocId = 0 ) ;
2020-05-02 13:14:05 -05:00
2020-04-18 08:44:50 -05:00
// A WSProcess object in the WSD process represents a descendant process, either the direct child
// process FORKIT or a grandchild KIT process, with which the WSD process communicates through a
// WebSocket.
2020-04-02 10:11:36 -05:00
class WSProcess
{
public :
/// @param pid is the process ID.
2020-10-31 14:08:08 -05:00
/// @param socket is the underlying Socket to the process.
2020-04-10 08:37:29 -05:00
WSProcess ( const std : : string & name ,
2019-11-26 07:15:38 -06:00
const pid_t pid ,
2020-04-02 10:11:36 -05:00
const std : : shared_ptr < StreamSocket > & socket ,
std : : shared_ptr < WebSocketHandler > handler ) :
_name ( name ) ,
_pid ( pid ) ,
2020-06-01 21:46:49 -05:00
_ws ( std : : move ( handler ) ) ,
2020-04-02 10:11:36 -05:00
_socket ( socket )
{
LOG_INF ( _name < < " ctor [ " < < _pid < < " ]. " ) ;
}
WSProcess ( WSProcess & & other ) = delete ;
const WSProcess & operator = ( WSProcess & & other ) = delete ;
virtual ~ WSProcess ( )
{
2020-05-24 08:10:18 -05:00
LOG_DBG ( ' ~ ' < < _name < < " dtor [ " < < _pid < < " ]. " ) ;
2020-04-02 10:11:36 -05:00
if ( _pid < = 0 )
return ;
terminate ( ) ;
// No need for the socket anymore.
_ws . reset ( ) ;
_socket . reset ( ) ;
}
/// Let the child close a nice way.
void close ( )
{
if ( _pid < 0 )
return ;
try
{
LOG_DBG ( " Closing ChildProcess [ " < < _pid < < " ]. " ) ;
// Request the child to exit
if ( isAlive ( ) )
{
LOG_DBG ( " Stopping ChildProcess [ " < < _pid < < " ] by sending 'exit' command. " ) ;
sendTextFrame ( " exit " ) ;
}
// Shutdown the socket.
if ( _ws )
_ws - > shutdown ( ) ;
}
catch ( const std : : exception & ex )
{
LOG_ERR ( " Error while closing child process: " < < ex . what ( ) ) ;
}
_pid = - 1 ; // Detach from child.
}
/// Kill or abandon the child.
void terminate ( )
{
if ( _pid < 0 )
return ;
# if !MOBILEAPP
if ( : : kill ( _pid , 0 ) = = 0 )
{
LOG_INF ( " Killing child [ " < < _pid < < " ]. " ) ;
if ( ! SigUtil : : killChild ( _pid ) )
{
LOG_ERR ( " Cannot terminate lokit [ " < < _pid < < " ]. Abandoning. " ) ;
}
}
# else
// What to do? Throw some unique exception that the outermost call in the thread catches and
// exits from the thread?
# endif
_pid = - 1 ;
}
2019-11-26 07:15:38 -06:00
pid_t getPid ( ) const { return _pid ; }
2020-04-02 10:11:36 -05:00
/// Send a text payload to the child-process WS.
virtual bool sendTextFrame ( const std : : string & data )
{
try
{
if ( _ws )
{
LOG_TRC ( " Send to " < < _name < < " message: [ " < < LOOLProtocol : : getAbbreviatedMessage ( data ) < < " ]. " ) ;
_ws - > sendMessage ( data ) ;
return true ;
}
}
catch ( const std : : exception & exc )
{
LOG_ERR ( " Failed to send " < < _name < < " [ " < < _pid < < " ] data [ " < <
LOOLProtocol : : getAbbreviatedMessage ( data ) < < " ] due to: " < < exc . what ( ) ) ;
throw ;
}
2020-05-24 08:10:18 -05:00
LOG_WRN ( " No socket to " < < _name < < " to send [ " < < LOOLProtocol : : getAbbreviatedMessage ( data ) < < ' ] ' ) ;
2020-04-02 10:11:36 -05:00
return false ;
}
/// Check whether this child is alive and socket not in error.
/// Note: zombies will show as alive, and sockets have waiting
/// time after the other end-point closes. So this isn't accurate.
virtual bool isAlive ( ) const
{
# if !MOBILEAPP
try
{
return _pid > 1 & & _ws & & : : kill ( _pid , 0 ) = = 0 ;
}
catch ( const std : : exception & )
{
}
return false ;
# else
return _pid > 1 ;
# endif
}
2020-10-31 12:45:52 -05:00
protected :
std : : shared_ptr < WebSocketHandler > getWSHandler ( ) const { return _ws ; }
std : : shared_ptr < Socket > getSocket ( ) const { return _socket ; } ;
private :
2020-04-02 10:11:36 -05:00
std : : string _name ;
2019-11-26 07:15:38 -06:00
pid_t _pid ;
2020-04-02 10:11:36 -05:00
std : : shared_ptr < WebSocketHandler > _ws ;
std : : shared_ptr < Socket > _socket ;
} ;
2020-04-20 03:47:50 -05:00
# if !MOBILEAPP
2021-03-21 14:58:10 -05:00
class ForKitProcWSHandler : public WebSocketHandler
2020-04-02 10:11:36 -05:00
{
public :
2021-03-21 14:58:10 -05:00
ForKitProcWSHandler ( const std : : weak_ptr < StreamSocket > & socket ,
const Poco : : Net : : HTTPRequest & request )
: WebSocketHandler ( socket . lock ( ) , request )
2020-04-02 10:11:36 -05:00
{
}
2021-03-21 14:58:10 -05:00
virtual void handleMessage ( const std : : vector < char > & data ) override ;
2020-04-02 10:11:36 -05:00
} ;
class ForKitProcess : public WSProcess
{
public :
ForKitProcess ( int pid , std : : shared_ptr < StreamSocket > & socket , const Poco : : Net : : HTTPRequest & request )
: WSProcess ( " ForKit " , pid , socket , std : : make_shared < ForKitProcWSHandler > ( socket , request ) )
{
2020-10-31 12:45:52 -05:00
socket - > setHandler ( getWSHandler ( ) ) ;
2020-04-02 10:11:36 -05:00
}
} ;
2017-03-04 17:07:17 -06:00
2020-04-20 03:47:50 -05:00
# endif
2021-03-13 13:32:52 -06:00
// Forward declarations for classes defined in LOOLWSD.cpp.
2021-03-13 13:20:46 -06:00
class PrisonPoll ;
2021-03-13 13:32:52 -06:00
class LOOLWSDServer ;
2021-03-13 13:20:46 -06:00
2016-08-13 23:01:13 -05:00
/// The Server class which is responsible for all
/// external interactions.
2016-10-29 20:15:00 -05:00
class LOOLWSD : public Poco : : Util : : ServerApplication
2015-03-17 18:56:15 -05:00
{
public :
LOOLWSD ( ) ;
~ LOOLWSD ( ) ;
2016-03-10 21:33:03 -06:00
// An Application is a singleton anyway,
// so just keep these as statics.
2019-09-21 13:15:37 -05:00
static std : : atomic < uint64_t > NextConnectionId ;
2016-04-06 22:51:58 -05:00
static unsigned int NumPreSpawnedChildren ;
2020-02-28 07:55:42 -06:00
# if !MOBILEAPP
2016-08-01 03:05:37 -05:00
static bool NoCapsForKit ;
2018-03-19 10:20:10 -05:00
static bool NoSeccomp ;
2018-04-17 14:47:17 -05:00
static bool AdminEnabled ;
2020-03-04 13:38:17 -06:00
# if ENABLE_DEBUG
static bool SingleKit ;
2020-02-28 07:55:42 -06:00
# endif
2020-04-02 10:11:36 -05:00
static std : : shared_ptr < ForKitProcess > ForKitProc ;
2017-01-15 16:54:55 -06:00
static std : : atomic < int > ForKitProcId ;
2020-04-20 03:47:50 -05:00
# endif
2020-04-20 05:26:14 -05:00
# ifdef FUZZER
2017-02-08 05:34:16 -06:00
static bool DummyLOK ;
2017-02-07 14:00:23 -06:00
static std : : string FuzzFileName ;
2020-04-20 05:26:14 -05:00
# endif
2020-06-26 05:58:09 -05:00
static std : : string UserInterface ;
2017-01-26 02:19:50 -06:00
static std : : string ConfigFile ;
2017-11-07 07:12:18 -06:00
static std : : string ConfigDir ;
2016-01-15 02:40:54 -06:00
static std : : string SysTemplate ;
static std : : string LoTemplate ;
static std : : string ChildRoot ;
2016-04-14 04:13:30 -05:00
static std : : string ServerName ;
2016-03-20 09:07:24 -05:00
static std : : string FileServerRoot ;
2020-04-14 12:50:04 -05:00
static std : : string WelcomeFilesRoot ; ///< From where we should serve the release notes (or otherwise useful content) that is shown on first install or version update.
2018-09-06 17:25:50 -05:00
static std : : string ServiceRoot ; ///< There are installations that need prefixing every page with some path.
2016-06-20 13:58:00 -05:00
static std : : string LOKitVersion ;
2021-04-15 10:43:44 -05:00
static FILE * EventTraceFile ;
2018-01-07 21:34:28 -06:00
static std : : string LogLevel ;
2019-04-14 11:24:45 -05:00
static bool AnonymizeUserData ;
2020-04-23 13:01:04 -05:00
static bool CheckLoolUser ;
2020-06-28 10:30:22 -05:00
static bool CleanupOnly ;
2020-05-07 15:11:38 -05:00
static bool IsProxyPrefixEnabled ;
2016-07-13 21:01:23 -05:00
static std : : atomic < unsigned > NumConnections ;
2016-07-31 12:56:57 -05:00
static std : : unique_ptr < TraceFileWriter > TraceDumper ;
2019-08-12 04:04:10 -05:00
# if !MOBILEAPP
2019-07-04 04:50:33 -05:00
static std : : unique_ptr < ClipboardCache > SavedClipboards ;
2019-08-12 04:04:10 -05:00
# endif
2021-03-13 13:20:46 -06:00
/// This thread polls basic web serving, and handling of
/// websockets before upgrade: when upgraded they go to the
/// relevant DocumentBroker poll instead.
static std : : unique_ptr < TerminatingPoll > WebServerPoll ;
/// This thread listens for and accepts prisoner kit processes.
/// And also cleans up and balances the correct number of children.
static std : : unique_ptr < PrisonPoll > PrisonerPoll ;
2021-03-13 13:32:52 -06:00
static std : : unique_ptr < LOOLWSDServer > Server ;
2020-07-27 04:27:00 -05:00
static std : : unordered_set < std : : string > EditFileExtensions ;
static std : : unordered_set < std : : string > ViewWithCommentsFileExtensions ;
2017-10-03 14:48:28 -05:00
static unsigned MaxConnections ;
static unsigned MaxDocuments ;
2017-10-03 22:54:05 -05:00
static std : : string OverrideWatermark ;
2017-11-07 07:12:18 -06:00
static std : : set < const Poco : : Util : : AbstractConfiguration * > PluginConfigurations ;
2020-12-06 13:51:54 -06:00
static std : : chrono : : steady_clock : : time_point StartTime ;
2019-12-05 15:27:16 -06:00
# if MOBILEAPP
2020-04-24 02:46:54 -05:00
# ifndef IOS
2019-12-05 15:27:16 -06:00
/// This is used to be able to wait until the lokit main thread has finished (and it is safe to load a new document).
static std : : mutex lokit_main_mutex ;
2020-04-24 02:46:54 -05:00
# endif
2019-12-05 15:27:16 -06:00
# endif
2015-04-08 09:22:42 -05:00
2020-01-17 15:18:42 -06:00
/// For testing only [!]
static int getClientPortNumber ( ) ;
2019-06-21 05:47:07 -05:00
/// For testing only [!] DocumentBrokers are mostly single-threaded with their own thread
static std : : vector < std : : shared_ptr < DocumentBroker > > getBrokersTestOnly ( ) ;
2017-09-19 13:06:46 -05:00
2021-03-26 11:57:08 -05:00
// Return a map for fast searches. Used in testing and in admin for cleanup
static std : : set < pid_t > getKitPids ( ) ;
2019-09-21 13:15:37 -05:00
static std : : string GetConnectionId ( )
2015-12-27 21:47:39 -06:00
{
2019-09-21 13:15:37 -05:00
return Util : : encodeId ( NextConnectionId + + , 3 ) ;
2015-12-27 21:47:39 -06:00
}
2016-10-29 20:15:00 -05:00
static bool isSSLEnabled ( )
2016-07-18 06:45:36 -05:00
{
2019-08-20 03:20:22 -05:00
# if ENABLE_SSL
2020-05-07 03:26:38 -05:00
return ! Util : : isFuzzing ( ) & & LOOLWSD : : SSLEnabled . get ( ) ;
2019-08-20 03:20:22 -05:00
# else
return false ;
# endif
2016-07-18 06:45:36 -05:00
}
2016-10-29 20:15:00 -05:00
static bool isSSLTermination ( )
2016-08-28 14:41:28 -05:00
{
2019-08-20 03:20:22 -05:00
# if ENABLE_SSL
2020-05-07 03:26:38 -05:00
return ! Util : : isFuzzing ( ) & & LOOLWSD : : SSLTermination . get ( ) ;
2019-08-20 03:20:22 -05:00
# else
return false ;
# endif
2016-08-28 14:41:28 -05:00
}
2017-05-07 12:28:57 -05:00
2020-07-27 04:27:00 -05:00
/// Return true if extension is marked as view action in discovery.xml.
2017-06-06 22:43:48 -05:00
static bool IsViewFileExtension ( const std : : string & extension )
{
2019-02-13 10:34:59 -06:00
# if MOBILEAPP
( void ) extension ;
return false ; // mark everything editable on mobile
# else
2018-02-16 10:23:25 -06:00
std : : string lowerCaseExtension = extension ;
std : : transform ( lowerCaseExtension . begin ( ) , lowerCaseExtension . end ( ) , lowerCaseExtension . begin ( ) , : : tolower ) ;
return EditFileExtensions . find ( lowerCaseExtension ) = = EditFileExtensions . end ( ) ;
2019-02-13 10:34:59 -06:00
# endif
2017-06-06 22:43:48 -05:00
}
2020-07-27 04:27:00 -05:00
/// Return true if extension is marked as view_comment action in discovery.xml.
static bool IsViewWithCommentsFileExtension ( const std : : string & extension )
{
# if MOBILEAPP
( void ) extension ;
return false ; // mark everything editable on mobile
# else
std : : string lowerCaseExtension = extension ;
std : : transform ( lowerCaseExtension . begin ( ) , lowerCaseExtension . end ( ) , lowerCaseExtension . begin ( ) , : : tolower ) ;
return ViewWithCommentsFileExtensions . find ( lowerCaseExtension ) ! = ViewWithCommentsFileExtensions . end ( ) ;
# endif
}
2017-05-07 12:28:57 -05:00
/// Returns the value of the specified application configuration,
2019-08-26 15:22:01 -05:00
/// or the default, if one doesn't exist.
2017-05-07 12:28:57 -05:00
template < typename T >
static
T getConfigValue ( const std : : string & name , const T def )
{
Add an initial libfuzzer based fuzzer
- target ClientSession::_handleInput(), since crashing there would bring
down the whole loolwsd (not just a kit process), and it deals with
input from untrusted users (browsers)
- add a --enable-fuzzers configure switch to build with
-fsanitize=fuzzer (compared to normal sanitizers build, this is the only
special flag needed)
- configuring other sanitizers is not done automatically, either use
--with-sanitizer=... or the environment variables from LODE's sanitizer
config
- run the actual fuzzer like this:
./clientsession_fuzzer -max_len=16384 fuzzer/data/
- note that at least openSUSE Leap 15.1 sadly ships with a clang with
libfuzzer static libs removed from the package, so you need a
self-built clang to run the fuzzer (either manual build or one from
LODE)
- <https://chromium.googlesource.com/chromium/src/testing/libfuzzer/+/refs/heads/master/efficient_fuzzing.md#execution-speed>
suggests that "You should aim for at least 1,000 exec/s from your fuzz
target locally" (i.e. one run should not take more than 1 ms), so try
this minimal approach first. The alternative would be to start from the
existing loolwsd_fuzzer binary, then step by step cut it down to not
fork(), not do any network traffic, etc -- till it's fast enough that
the fuzzer can find interesting input
- the various configurations start to be really complex (the matrix is
just very large), so try to use Util::isFuzzing() for fuzzer-specific
changes (this is what core.git does as well), and only resort to ifdefs
for the Util::isFuzzing() itself
Change-Id: I72dc1193b34c93eacb5d8e39cef42387d42bd72f
Reviewed-on: https://gerrit.libreoffice.org/c/online/+/89226
Tested-by: Jenkins CollaboraOffice <jenkinscollaboraoffice@gmail.com>
Reviewed-by: Michael Meeks <michael.meeks@collabora.com>
2020-02-21 08:52:20 -06:00
if ( Util : : isFuzzing ( ) )
{
return def ;
}
2017-05-07 12:28:57 -05:00
return getConfigValue ( Application : : instance ( ) . config ( ) , name , def ) ;
}
2016-08-28 14:41:28 -05:00
2019-10-07 06:51:30 -05:00
/// Reads and processes path entries with the given property
/// from the configuration.
/// Converts relative paths to absolute.
static
std : : string getPathFromConfig ( const std : : string & name )
{
return getPathFromConfig ( Application : : instance ( ) . config ( ) , name ) ;
}
/// Reads and processes path entries with the given property
/// from the configuration. If value is empty then it reads from fallback
/// Converts relative paths to absolute.
static
std : : string getPathFromConfigWithFallback ( const std : : string & name , const std : : string & fallbackName )
{
2020-09-08 07:06:47 -05:00
std : : string value ;
// the expected path might not exist, in which case Poco throws an exception
try
{
value = LOOLWSD : : getPathFromConfig ( name ) ;
}
catch ( . . . )
{
}
2019-10-07 06:51:30 -05:00
if ( value . empty ( ) )
return LOOLWSD : : getPathFromConfig ( fallbackName ) ;
return value ;
}
2021-03-05 14:19:36 -06:00
/// Returns true if and only if the property with the given key exists.
static
bool hasProperty ( const std : : string & key )
{
return Application : : instance ( ) . config ( ) . hasProperty ( key ) ;
}
2017-02-05 18:35:54 -06:00
/// Trace a new session and take a snapshot of the file.
static void dumpNewSessionTrace ( const std : : string & id , const std : : string & sessionId , const std : : string & uri , const std : : string & path ) ;
/// Trace the end of a session.
static void dumpEndSessionTrace ( const std : : string & id , const std : : string & sessionId , const std : : string & uri ) ;
2017-01-13 06:52:08 -06:00
static void dumpEventTrace ( const std : : string & id , const std : : string & sessionId , const std : : string & data ) ;
2016-08-02 20:09:01 -05:00
2017-01-13 06:52:08 -06:00
static void dumpIncomingTrace ( const std : : string & id , const std : : string & sessionId , const std : : string & data ) ;
2016-07-30 21:22:28 -05:00
2017-01-13 06:52:08 -06:00
static void dumpOutgoingTrace ( const std : : string & id , const std : : string & sessionId , const std : : string & data ) ;
2016-07-31 06:54:47 -05:00
2017-01-15 19:12:10 -06:00
/// Waits on Forkit and reaps if it dies, then restores.
/// Return true if wait succeeds.
static bool checkAndRestoreForKit ( ) ;
2017-01-15 16:54:55 -06:00
/// Creates a new instance of Forkit.
2020-04-26 15:55:16 -05:00
/// Return true when successful.
2017-01-15 16:54:55 -06:00
static bool createForKit ( ) ;
2020-04-02 10:11:36 -05:00
/// Sends a message to ForKit through PrisonerPoll.
static void sendMessageToForKit ( const std : : string & message ) ;
2017-04-02 18:56:42 -05:00
/// Checks forkit (and respawns), rebalances
/// child kit processes and cleans up DocBrokers.
static void doHousekeeping ( ) ;
2017-03-27 20:46:16 -05:00
2020-03-16 11:19:37 -05:00
static void checkDiskSpaceAndWarnClients ( const bool cacheLastCheck ) ;
static void checkSessionLimitsAndWarnClients ( ) ;
2017-07-07 06:42:19 -05:00
/// Close document with @docKey and a @message
static void closeDocument ( const std : : string & docKey , const std : : string & message ) ;
2020-04-10 08:37:29 -05:00
/// Autosave a given document (currently only called from Admin).
2017-07-10 12:15:04 -05:00
static void autoSave ( const std : : string & docKey ) ;
2020-11-23 05:07:44 -06:00
/// Sets the log level of current kits.
2020-11-15 06:23:54 -06:00
static void setLogLevelsOfKits ( const std : : string & level ) ;
2018-06-10 10:35:59 -05:00
/// Anonymize the basename of filenames, preserving the path and extension.
static std : : string anonymizeUrl ( const std : : string & url )
{
2020-01-17 16:31:41 -06:00
return FileUtil : : anonymizeUrl ( url ) ;
2018-06-10 10:35:59 -05:00
}
2018-07-08 21:50:09 -05:00
/// Anonymize user names and IDs.
2020-04-26 15:55:16 -05:00
/// Will use the Obfuscated User ID if one is provided via WOPI.
2018-06-10 10:35:59 -05:00
static std : : string anonymizeUsername ( const std : : string & username )
{
2020-01-17 16:31:41 -06:00
return FileUtil : : anonymizeUsername ( username ) ;
2018-06-10 10:35:59 -05:00
}
2019-02-13 11:01:08 -06:00
/// get correct server URL with protocol + port number for this running server
static std : : string getServerURL ( ) ;
2015-03-17 18:56:15 -05:00
protected :
2021-03-11 21:46:14 -06:00
void initialize ( Poco : : Util : : Application & self ) override
{
try
{
innerInitialize ( self ) ;
}
2021-04-15 16:37:46 -05:00
catch ( const Poco : : Exception & ex )
{
LOG_FTL ( " Failed to initialize LOOLWSD: "
< < ex . displayText ( )
< < ( ex . nested ( ) ? " ( " + ex . nested ( ) - > displayText ( ) + ' ) ' : " " ) ) ;
throw ; // Nothing further to do.
}
2021-03-11 21:46:14 -06:00
catch ( const std : : exception & ex )
{
LOG_FTL ( " Failed to initialize LOOLWSD: " < < ex . what ( ) ) ;
throw ; // Nothing further to do.
}
}
2015-03-17 18:56:15 -05:00
void defineOptions ( Poco : : Util : : OptionSet & options ) override ;
void handleOption ( const std : : string & name , const std : : string & value ) override ;
int main ( const std : : vector < std : : string > & args ) override ;
2017-03-27 14:14:16 -05:00
/// Handle various global static destructors.
2020-09-18 04:03:17 -05:00
static void cleanup ( ) ;
2017-03-27 14:14:16 -05:00
2015-03-17 18:56:15 -05:00
private :
2019-08-20 03:20:22 -05:00
# if ENABLE_SSL
2016-07-19 04:07:07 -05:00
static Util : : RuntimeConstant < bool > SSLEnabled ;
2016-08-28 14:41:28 -05:00
static Util : : RuntimeConstant < bool > SSLTermination ;
2019-08-20 03:20:22 -05:00
# endif
2016-07-18 06:45:36 -05:00
2016-03-23 06:08:01 -05:00
void initializeSSL ( ) ;
2015-03-17 18:56:15 -05:00
void displayHelp ( ) ;
2016-04-06 17:17:59 -05:00
2021-03-11 21:46:14 -06:00
/// The actual initialize implementation.
void innerInitialize ( Application & self ) ;
/// The actual main implementation.
int innerMain ( ) ;
2016-07-18 06:45:36 -05:00
class ConfigValueGetter
{
2016-07-28 01:39:03 -05:00
Poco : : Util : : LayeredConfiguration & _config ;
const std : : string & _name ;
2016-07-18 06:45:36 -05:00
public :
ConfigValueGetter ( Poco : : Util : : LayeredConfiguration & config ,
const std : : string & name )
2016-07-28 01:39:03 -05:00
: _config ( config )
, _name ( name )
2016-10-29 20:15:00 -05:00
{
}
2016-07-18 06:45:36 -05:00
2017-01-28 16:25:14 -06:00
void operator ( ) ( int & value ) { value = _config . getInt ( _name ) ; }
2016-07-28 01:39:03 -05:00
void operator ( ) ( unsigned int & value ) { value = _config . getUInt ( _name ) ; }
2019-11-22 09:50:49 -06:00
void operator ( ) ( uint64_t & value ) { value = _config . getUInt64 ( _name ) ; }
2016-07-28 01:39:03 -05:00
void operator ( ) ( bool & value ) { value = _config . getBool ( _name ) ; }
2016-07-30 21:19:31 -05:00
void operator ( ) ( std : : string & value ) { value = _config . getString ( _name ) ; }
2017-07-07 06:42:19 -05:00
void operator ( ) ( double & value ) { value = _config . getDouble ( _name ) ; }
2016-07-18 06:45:36 -05:00
} ;
2016-10-29 20:15:00 -05:00
template < typename T >
static bool getSafeConfig ( Poco : : Util : : LayeredConfiguration & config ,
const std : : string & name , T & value )
2016-06-25 11:31:22 -05:00
{
try
{
2016-07-18 06:45:36 -05:00
ConfigValueGetter ( config , name ) ( value ) ;
2016-06-25 11:31:22 -05:00
return true ;
}
2020-02-28 07:58:32 -06:00
catch ( . . . )
2016-06-25 11:31:22 -05:00
{
}
return false ;
}
2016-07-18 06:45:36 -05:00
template < typename T >
2016-06-25 11:31:22 -05:00
static
2016-07-18 06:45:36 -05:00
T getConfigValue ( Poco : : Util : : LayeredConfiguration & config ,
const std : : string & name , const T def )
2016-06-25 11:31:22 -05:00
{
2016-07-18 06:45:36 -05:00
T value = def ;
if ( getSafeConfig ( config , name , value ) | |
getSafeConfig ( config , name + " [@default] " , value ) )
2016-06-25 11:31:22 -05:00
{
return value ;
}
return def ;
}
2016-04-06 17:17:59 -05:00
/// Reads and processes path entries with the given property
/// from the configuration.
/// Converts relative paths to absolute.
2019-10-07 06:51:30 -05:00
static
std : : string getPathFromConfig ( Poco : : Util : : LayeredConfiguration & config , const std : : string & property )
2016-04-06 17:17:59 -05:00
{
2019-10-07 06:51:30 -05:00
std : : string path = config . getString ( property ) ;
if ( path . empty ( ) & & config . hasProperty ( property + " [@default] " ) )
2016-04-06 22:51:58 -05:00
{
// Use the default value if empty and a default provided.
2019-10-07 06:51:30 -05:00
path = config . getString ( property + " [@default] " ) ;
2016-04-06 22:51:58 -05:00
}
// Reconstruct absolute path if relative.
2016-06-25 17:03:41 -05:00
if ( ! Poco : : Path ( path ) . isAbsolute ( ) & &
2019-10-07 06:51:30 -05:00
config . hasProperty ( property + " [@relative] " ) & &
config . getBool ( property + " [@relative] " ) )
2016-04-06 17:17:59 -05:00
{
path = Poco : : Path ( Application : : instance ( ) . commandPath ( ) ) . parent ( ) . append ( path ) . toString ( ) ;
}
return path ;
}
2016-06-25 11:31:22 -05:00
private :
/// Settings passed from the command-line to override those in the config file.
std : : map < std : : string , std : : string > _overrideSettings ;
2018-09-13 11:16:00 -05:00
2019-02-12 05:16:40 -06:00
# if MOBILEAPP
2018-09-13 11:16:00 -05:00
public :
static int prisonerServerSocketFD ;
# endif
2015-03-17 18:56:15 -05:00
} ;
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */