class TProofServ: public TApplication

 Main constructor. Create an application environment. The TProofServ
 environment provides an eventloop via inheritance of TApplication.
 Actual server creation work is done in CreateServer() to allow
 overloading.

 Finalize the server setup. If master, create the TProof instance to talk
 to the worker or submaster nodes.
 Return 0 on success, -1 on error

 Cleanup. Not really necessary since after this dtor there is no
 live anyway.

 Print message of the day (in the file pointed by the env PROOFMOTD
 or from fConfDir/etc/proof/motd). The motd is not shown more than
 once a day. If the file pointed by env PROOFNOPROOF exists (or the
 file fConfDir/etc/proof/noproof exists), show its contents and close
 the connection.

 Get object with name "name;cycle" (e.g. "aap;2") from master or client.
 This method is called by TDirectory::Get() in case the object can not
 be found locally.

 Get next range of entries to be processed on this server.

 Get and handle command line options. Fixed format:
 "proofserv"|"proofslave" <confdir>

 Handle input coming from the client or from the master server.

 Handle messages that might arrive during processing while being in
 HandleSocketInput(). This avoids recursive calls into HandleSocketInput().

 Handle Out-Of-Band data sent by the master or client.

 Called when the client is not alive anymore (i.e. when kKeepAlive
 has failed).

 True if in parallel mode.

 Print status of slave server.

 Redirect stdout to a log file. This log file will be flushed to the
 client or master after each command.

 Reset PROOF environment to be ready for execution of next command.

 Receive a file, either sent by a client or a master server.
 If bin is true it is a binary file, other wise it is an ASCII
 file and we need to check for Windows \r tokens. Returns -1 in
 case of error, 0 otherwise.

 Main server eventloop.

 Send log file to master.
 If start > -1 send only bytes in the range from start to end,
 if end <= start send everything from start.

 Send statistics of slave server to master or client.

 Send number of parallel nodes to master or client.

 Removes link to package in working directory,
 removes entry from include path,
 removes entry from enabled package list,
 does not currently remove entry from interpreter include path.
 Returns -1 in case of error, 0 otherwise.

 Unloads all enabled packages. Returns -1 in case of error, 0 otherwise.

 Print the ProofServ logo on standard output.
 Return 0 on success, -1 on failure

 Common part (between TProofServ and TXProofServ) of the setup phase.
 Return 0 on success, -1 on error

 Terminate the proof server.

 Static function that returns kTRUE in case we are a PROOF server.

 Static function returning pointer to global object gProofServ.
 Mainly for use via CINT, where the gProofServ symbol might be
 deleted from the symbol table.

 Setup authentication related stuff for old versions.
 Provided for backward compatibility.

 Create a TProofQueryResult instance for this query.

 Set query in running state.

 Add part of log file concerning TQueryResult pq to its macro
 container.

 Final steps after Process() to complete the TQueryResult instance.

 Remove all queries results referring to previous sessions

 Scan the queries directory for the results of previous queries.
 The headers of the query results found are loaded in fPreviousQueries.
 The full query result can be retrieved via TProof::Retrieve.

 Scan the queries directory and remove the oldest ones (and relative dirs,
 if empty) in such a way only fMaxQueries are kept.
 Return 0 on success, -1 in case of problems

 Try locking query area of session tagged sessiontag.
 The id of the locking file is returned in fid and must be
 unlocked via UnlockQueryFile(fid).

 Cleanup query dir qdir.

 Save current status of query 'qr' to file name fout.
 If fout == 0 (default) use the default name.

 Remove everything about query queryref.

 Remove everything about query qr. If soft = TRUE leave a track
 in memory with the relevant info

 Locate query referenced by queryref. Return pointer to instance
 in memory, if any, or 0. Fills qdir with the query specific directory
 and qry with the query number for queries processed by this session.

 Handle archive request.

 Handle processing request.

 Handle request for list of queries.

 Handle remove request.

 Handle retrieve request.

 Handle lib, inc search paths modification request

 Handle file checking request.

 Handle here all cache and package requests.

 Handle here all requests to modify worker lists

 The PROOF error handler function. It prints the message on stderr and
 if abort is set it aborts the application.

 Retrieve any files (source and binaries) related to 'macro' from the cache
 directory.
 Returns 0 on success, -1 otherwise

 Copy files related to 'macro' to the cache directory.
 Action depends on 'opt':

    opt = 0         copy 'macro' to cache and delete from cache any binary
                    related to name; e.g. if macro = bla.C, the binaries are
                    bla_C.so, bla_C.rootmap, ...
    opt = 1         copy the binaries related to macro to the cache

 Returns 0 on success, -1 otherwise

 Make player instance.

 Delete player instance.

 Get the processing priority for the group the user belongs too. This
 prioroty is a number (0 - 100) determined by a scheduler (third
 party process) based on some basic priority the group has, e.g.
 we might want to give users in a specific group (e.g. promptana)
 a higher priority than users in other groups, and on the analysis
 of historical logging data (i.e. usage of CPU by the group in a
 previous time slot, as recorded in TPerfStats::WriteQueryLog()).

 Currently the group priority is obtained by a query in a SQL DB
 table proofpriority, which has the format:
 CREATE TABLE proofpriority (
   id            INT NOT NULL PRIMARY KEY AUTO_INCREMENT,
   group         VARCHAR(32) NOT NULL,
   priority      INT
)

 Send an asychronous message to the master / client .
 Masters will forward up the message to the client.
 The client prints 'msg' of stderr and adds a '\n'/'\r' depending on
 'lf' being kTRUE (default) or kFALSE.
 Returns the return value from TSocket::Send(TMessage &) .

 Reposition the read pointer in the log file to the very end.
 This allows to "hide" useful debug messages durign normal operations
 while preserving the possibility to have them in case of problems.

 Exception handler: we do not try to recover here, just exit.

 Handle here requests about datasets.

 Disable / Enable read timeout