// @(#)root/proof:$Id$
// Author: Fons Rademakers   16/02/97

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/


#ifndef ROOT_TProofServ
#define ROOT_TProofServ

//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TProofServ                                                           //
//                                                                      //
// TProofServ is the PROOF server. It can act either as the master      //
// server or as a slave server, depending on its startup arguments. It  //
// receives and handles message coming from the client or from the      //
// master server.                                                       //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

#ifndef ROOT_TApplication
#include "TApplication.h"
#endif
#ifndef ROOT_TString
#include "TString.h"
#endif
#ifndef ROOT_TSysEvtHandler
#include "TSysEvtHandler.h"
#endif
#ifndef ROOT_TStopwatch
#include "TStopwatch.h"
#endif
#ifndef ROOT_TTimer
#include "TTimer.h"
#endif
#ifndef ROOT_TProofQueryResult
#include "TProofQueryResult.h"
#endif

class TDataSetManager;
class TDataSetManagerFile;
class TDSet;
class TDSetElement;
class TFileCollection;
class TFileHandler;
class THashList;
class TIdleTOTimer;
class TList;
class TMap;
class TMessage;
class TMonitor;
class TMutex;
class TProof;
class TProofLockPath;
class TQueryResultManager;
class TReaperTimer;
class TServerSocket;
class TShutdownTimer;
class TSocket;
class TVirtualProofPlayer;

// Hook to external function setting up authentication related stuff
// for old versions.
// For backward compatibility
typedef Int_t (*OldProofServAuthSetup_t)(TSocket *, Bool_t, Int_t,
                                         TString &, TString &, TString &);


class TProofServ : public TApplication {

friend class TProofServLite;
friend class TXProofServ;

public:
   enum EStatusBits { kHighMemory = BIT(16) };
   enum EQueryAction { kQueryOK, kQueryModify, kQueryStop, kQueryEnqueued };

private:
   TString       fService;          //service we are running, either "proofserv" or "proofslave"
   TString       fUser;             //user as which we run
   TString       fGroup;            //group the user belongs to
   TString       fConfDir;          //directory containing cluster config information
   TString       fConfFile;         //file containing config information
   TString       fWorkDir;          //directory containing all proof related info
   TString       fImage;            //image name of the session
   TString       fSessionTag;       //tag for the server session
   TString       fTopSessionTag;    //tag for the global session
   TString       fSessionDir;       //directory containing session dependent files
   TString       fPackageDir;       //directory containing packages and user libs
   THashList    *fGlobalPackageDirList;  //list of directories containing global packages libs
   TString       fCacheDir;         //directory containing cache of user files
   TString       fQueryDir;         //directory containing query results and status
   TString       fDataSetDir;       //directory containing info about known data sets
   TString       fDataDir;          //directory containing data files produced during queries
   TString       fDataDirOpts;      //Url type options for fDataDir
   TString       fAdminPath;        //admin path for this session
   TString       fOutputFile;       //path with the temporary results of the current or last query
   TProofLockPath *fPackageLock;    //package dir locker
   TProofLockPath *fCacheLock;      //cache dir locker
   TProofLockPath *fQueryLock;      //query dir locker
   TString       fArchivePath;      //default archive path
   TSocket      *fSocket;           //socket connection to client
   TProof       *fProof;            //PROOF talking to slave servers
   TVirtualProofPlayer *fPlayer;    //actual player
   FILE         *fLogFile;          //log file
   Int_t         fLogFileDes;       //log file descriptor
   Long64_t      fLogFileMaxSize;   //max size for log files (enabled if > 0)
   TList        *fEnabledPackages;  //list of enabled packages
   Int_t         fProtocol;         //protocol version number
   TString       fOrdinal;          //slave ordinal number
   Int_t         fGroupId;          //slave unique id in the active slave group
   Int_t         fGroupSize;        //size of the active slave group
   Int_t         fLogLevel;         //debug logging level
   Int_t         fNcmd;             //command history number
   Int_t         fGroupPriority;    //priority of group the user belongs to (0 - 100)
   Bool_t        fEndMaster;        //true for a master in direct contact only with workers
   Bool_t        fMasterServ;       //true if we are a master server
   Bool_t        fInterrupt;        //if true macro execution will be stopped
   Float_t       fRealTime;         //real time spent executing commands
   Float_t       fCpuTime;          //CPU time spent executing commands
   TStopwatch    fLatency;          //measures latency of packet requests
   TStopwatch    fCompute;          //measures time spent processing a packet
   TStopwatch    fSaveOutput;       //measures time spent saving the partial result
   Int_t         fQuerySeqNum;      //sequential number of the current or last query

   Int_t         fTotSessions;      //Total number of PROOF sessions on the cluster 
   Int_t         fActSessions;      //Total number of active PROOF sessions on the cluster 
   Float_t       fEffSessions;      //Effective Number of PROOF sessions on the assigned machines

   TFileHandler *fInputHandler;     //Input socket handler

   TQueryResultManager *fQMgr;      //Query-result manager

   TList        *fWaitingQueries;   //list of TProofQueryResult waiting to be processed
   Bool_t        fIdle;             //TRUE if idle
   TMutex       *fQMtx;             // To protect async msg queue

   TList        *fQueuedMsg;        //list of messages waiting to be processed

   TString       fPrefix;           //Prefix identifying the node

   Bool_t        fRealTimeLog;      //TRUE if log messages should be send back in real-time

   TShutdownTimer *fShutdownTimer;  // Timer used to shutdown out-of-control sessions
   TReaperTimer   *fReaperTimer;    // Timer used to control children state
   TIdleTOTimer   *fIdleTOTimer;    // Timer used to control children state

   Int_t         fCompressMsg;     // Compression level for messages

   TDataSetManager* fDataSetManager; // dataset manager
   TDataSetManagerFile *fDataSetStgRepo;  // repository for staging requests

   Bool_t        fSendLogToMaster; // On workers, controls logs sending to master

   TServerSocket *fMergingSocket;  // Socket used for merging outputs if submerger
   TMonitor      *fMergingMonitor; // Monitor for merging sockets
   Int_t          fMergedWorkers;  // Number of workers merged

   // Quotas (-1 to disable)
   Int_t         fMaxQueries;       //Max number of queries fully kept
   Long64_t      fMaxBoxSize;       //Max size of the sandbox
   Long64_t      fHWMBoxSize;       //High-Water-Mark on the sandbox size

   // Memory limits (-1 to disable) set by envs ROOTPROFOASHARD, PROOF_VIRTMEMMAX, PROOF_RESMEMMAX
   static Long_t fgVirtMemMax;       //Hard limit enforced by the system (in kB)
   static Long_t fgResMemMax;        //Hard limit on the resident memory checked
                                     //in TProofPlayer::Process (in kB)
   static Float_t fgMemHWM;          // Threshold fraction of max for warning and finer monitoring
   static Float_t fgMemStop;         // Fraction of max for stop processing

   // In bytes; default is 1MB
   Long64_t      fMsgSizeHWM;       //High-Water-Mark on the size of messages with results

   static FILE  *fgErrorHandlerFile; // File where to log
   static Int_t  fgRecursive;       // Keep track of recursive inputs during processing

   // Control sending information to syslog
   static Int_t  fgLogToSysLog;      // >0 sent to syslog too
   static TString fgSysLogService;   // name of the syslog service (eg: proofm-0, proofw-0.67)
   static TString fgSysLogEntity;   // logging entity (<user>:<group>)

   Int_t         GetCompressionLevel() const;

   void          RedirectOutput(const char *dir = 0, const char *mode = "w");
   Int_t         CatMotd();
   Int_t         UnloadPackage(const char *package);
   Int_t         UnloadPackages();
   Int_t         OldAuthSetup(TString &wconf);
   Int_t         GetPriority();

   // Query handlers
   TProofQueryResult *MakeQueryResult(Long64_t nentries, const char *opt,
                                      TList *inl, Long64_t first, TDSet *dset,
                                      const char *selec, TObject *elist);
   void          SetQueryRunning(TProofQueryResult *pq);

   // Results handling
   Int_t         SendResults(TSocket *sock, TList *outlist = 0, TQueryResult *pq = 0);
   Bool_t        AcceptResults(Int_t connections, TVirtualProofPlayer *mergerPlayer);

   // Waiting queries handlers
   void          SetIdle(Bool_t st = kTRUE);
   Bool_t        IsWaiting();
   Int_t         WaitingQueries();
   Int_t         QueueQuery(TProofQueryResult *pq);
   TProofQueryResult *NextQuery();
   Int_t         CleanupWaitingQueries(Bool_t del = kTRUE, TList *qls = 0);

protected:
   virtual void  HandleArchive(TMessage *mess, TString *slb = 0);
   virtual Int_t HandleCache(TMessage *mess, TString *slb = 0);
   virtual void  HandleCheckFile(TMessage *mess, TString *slb = 0);
   virtual Int_t HandleDataSets(TMessage *mess, TString *slb = 0);
   virtual void  HandleSubmerger(TMessage *mess);
   virtual void  HandleFork(TMessage *mess);
   virtual void  HandleLibIncPath(TMessage *mess);
   virtual void  HandleProcess(TMessage *mess, TString *slb = 0);
   virtual void  HandleQueryList(TMessage *mess);
   virtual void  HandleRemove(TMessage *mess, TString *slb = 0);
   virtual void  HandleRetrieve(TMessage *mess, TString *slb = 0);
   virtual Int_t HandleWorkerLists(TMessage *mess);

   virtual void  ProcessNext(TString *slb = 0);
   virtual Int_t Setup();
   Int_t         SetupCommon();
   virtual void  MakePlayer();
   virtual void  DeletePlayer();

   virtual Int_t Fork();
   Int_t         GetSessionStatus();
   Bool_t        IsIdle();
   Bool_t        UnlinkDataDir(const char *path);

   static TString fgLastMsg;    // Message about status before exception
   static Long64_t fgLastEntry;  // Last entry before exception

public:
   TProofServ(Int_t *argc, char **argv, FILE *flog = 0);
   virtual ~TProofServ();

   virtual Int_t  CreateServer();

   TProof        *GetProof()      const { return fProof; }
   const char    *GetService()    const { return fService; }
   const char    *GetConfDir()    const { return fConfDir; }
   const char    *GetConfFile()   const { return fConfFile; }
   const char    *GetUser()       const { return fUser; }
   const char    *GetGroup()      const { return fGroup; }
   const char    *GetWorkDir()    const { return fWorkDir; }
   const char    *GetImage()      const { return fImage; }
   const char    *GetSessionTag() const { return fSessionTag; }
   const char    *GetTopSessionTag() const { return fTopSessionTag; }
   const char    *GetSessionDir() const { return fSessionDir; }
   const char    *GetPackageDir() const { return fPackageDir; }
   const char    *GetDataDir()    const { return fDataDir; }
   const char    *GetDataDirOpts() const { return fDataDirOpts; }
   Int_t          GetProtocol()   const { return fProtocol; }
   const char    *GetOrdinal()    const { return fOrdinal; }
   Int_t          GetGroupId()    const { return fGroupId; }
   Int_t          GetGroupSize()  const { return fGroupSize; }
   Int_t          GetLogLevel()   const { return fLogLevel; }
   TSocket       *GetSocket()     const { return fSocket; }
   Float_t        GetRealTime()   const { return fRealTime; }
   Float_t        GetCpuTime()    const { return fCpuTime; }
   Int_t          GetQuerySeqNum() const { return fQuerySeqNum; }

   Int_t          GetTotSessions() const { return fTotSessions; }
   Int_t          GetActSessions() const { return fActSessions; }
   Float_t        GetEffSessions() const { return fEffSessions; }

   void           GetOptions(Int_t *argc, char **argv);
   TList         *GetEnabledPackages() const { return fEnabledPackages; }

   static Long_t  GetVirtMemMax();
   static Long_t  GetResMemMax();
   static Float_t GetMemHWM();
   static Float_t GetMemStop();

   Long64_t       GetMsgSizeHWM() const { return fMsgSizeHWM; }

   const char    *GetPrefix()     const { return fPrefix; }

   void           FlushLogFile();
   void           TruncateLogFile();  // Called also by TDSetProxy::Next()

   TProofLockPath *GetCacheLock() { return fCacheLock; }      //cache dir locker; used by TProofPlayer
   Int_t          CopyFromCache(const char *name, Bool_t cpbin);
   Int_t          CopyToCache(const char *name, Int_t opt = 0);

   virtual EQueryAction GetWorkers(TList *workers, Int_t &prioritychange,
                                   Bool_t resume = kFALSE);
   virtual void   HandleException(Int_t sig);
   virtual Int_t  HandleSocketInput(TMessage *mess, Bool_t all);
   virtual void   HandleSocketInput();
   virtual void   HandleUrgentData();
   virtual void   HandleSigPipe();
   virtual void   HandleTermination() { Terminate(0); }
   void           Interrupt() { fInterrupt = kTRUE; }
   Bool_t         IsEndMaster() const { return fEndMaster; }
   Bool_t         IsMaster() const { return fMasterServ; }
   Bool_t         IsParallel() const;
   Bool_t         IsTopMaster() const { return fOrdinal == "0"; }

   void           Run(Bool_t retrn = kFALSE);

   void           Print(Option_t *option="") const;

   void           RestartComputeTime();

   TObject       *Get(const char *namecycle);
   TDSetElement  *GetNextPacket(Long64_t totalEntries = -1);
   virtual void   ReleaseWorker(const char *) { }
   void           Reset(const char *dir);
   Int_t          ReceiveFile(const char *file, Bool_t bin, Long64_t size);
   virtual Int_t  SendAsynMessage(const char *msg, Bool_t lf = kTRUE);
   virtual void   SendLogFile(Int_t status = 0, Int_t start = -1, Int_t end = -1);
   void           SendStatistics();
   void           SendParallel(Bool_t async = kFALSE);

   Int_t          UpdateSessionStatus(Int_t xst = -1);

   // Disable / Enable read timeout
   virtual void   DisableTimeout() { }
   virtual void   EnableTimeout() { }

   virtual void   Terminate(Int_t status);

   // Log control
   void           LogToMaster(Bool_t on = kTRUE) { fSendLogToMaster = on; }

   static FILE   *SetErrorHandlerFile(FILE *ferr);
   static void    ErrorHandler(Int_t level, Bool_t abort, const char *location,
                               const char *msg);

   static void    ResolveKeywords(TString &fname, const char *path = 0);

   static void    SetLastMsg(const char *lastmsg);
   static void    SetLastEntry(Long64_t lastentry);

   // To handle local data server related paths
   static void    FilterLocalroot(TString &path, const char *url = "root://dum/");
   static void    GetLocalServer(TString &dsrv);

   // To prepara ethe map of files to process
   static TMap   *GetDataSetNodeMap(TFileCollection *fc, TString &emsg);
   static Int_t   RegisterDataSets(TList *in, TList *out, TDataSetManager *dsm, TString &e);

   static Bool_t      IsActive();
   static TProofServ *This();

   ClassDef(TProofServ,0)  //PROOF Server Application Interface
};

R__EXTERN TProofServ *gProofServ;

class TProofLockPath : public TNamed {
private:
   Int_t         fLockId;        //file id of dir lock

public:
   TProofLockPath(const char *path) : TNamed(path,path), fLockId(-1) { }
   ~TProofLockPath() { if (IsLocked()) Unlock(); }

   Int_t         Lock();
   Int_t         Unlock();

   Bool_t        IsLocked() const { return (fLockId > -1); }
};

class TProofLockPathGuard {
private:
   TProofLockPath  *fLocker; //locker instance

public:
   TProofLockPathGuard(TProofLockPath *l) { fLocker = l; if (fLocker) fLocker->Lock(); }
   ~TProofLockPathGuard() { if (fLocker) fLocker->Unlock(); }
};

//----- Handles output from commands executed externally via a pipe. ---------//
//----- The output is redirected one level up (i.e., to master or client). ---//
//______________________________________________________________________________
class TProofServLogHandler : public TFileHandler {
private:
   TSocket     *fSocket; // Socket where to redirect the message
   FILE        *fFile;   // File connected with the open pipe
   TString      fPfx;    // Prefix to be prepended to messages

   static TString fgPfx; // Default prefix to be prepended to messages
   static Int_t   fgCmdRtn; // Return code of the command execution (available only
                            // after closing the pipe)
public:
   enum EStatusBits { kFileIsPipe = BIT(23) };
   TProofServLogHandler(const char *cmd, TSocket *s, const char *pfx = "");
   TProofServLogHandler(FILE *f, TSocket *s, const char *pfx = "");
   virtual ~TProofServLogHandler();

   Bool_t IsValid() { return ((fFile && fSocket) ? kTRUE : kFALSE); }

   Bool_t Notify();
   Bool_t ReadNotify() { return Notify(); }

   static void SetDefaultPrefix(const char *pfx);
   static Int_t GetCmdRtn();
};

//--- Guard class: close pipe, deactivatethe related descriptor --------------//
//______________________________________________________________________________
class TProofServLogHandlerGuard {

private:
   TProofServLogHandler   *fExecHandler;

public:
   TProofServLogHandlerGuard(const char *cmd, TSocket *s,
                             const char *pfx = "", Bool_t on = kTRUE);
   TProofServLogHandlerGuard(FILE *f, TSocket *s,
                             const char *pfx = "", Bool_t on = kTRUE);
   virtual ~TProofServLogHandlerGuard();
};

//--- Special timer to control delayed shutdowns
//______________________________________________________________________________
class TShutdownTimer : public TTimer {
private:
   TProofServ    *fProofServ;
   Int_t          fTimeout;

public:
   TShutdownTimer(TProofServ *p, Int_t delay);

   Bool_t Notify();
};

//--- Synchronous timer used to reap children processes change of state
//______________________________________________________________________________
class TReaperTimer : public TTimer {
private:
   TList  *fChildren;   // List of children (forked) processes

public:
   TReaperTimer(Long_t frequency = 1000) : TTimer(frequency, kTRUE), fChildren(0) { }
   virtual ~TReaperTimer();

   void AddPid(Int_t pid);
   Bool_t Notify();
};

//--- Special timer to terminate idle sessions
//______________________________________________________________________________
class TIdleTOTimer : public TTimer {
private:
   TProofServ    *fProofServ;

public:
   TIdleTOTimer(TProofServ *p, Int_t delay) : TTimer(delay, kTRUE), fProofServ(p) { }

   Bool_t Notify();
};
//______________________________________________________________________________
class TIdleTOTimerGuard {

private:
   TIdleTOTimer *fIdleTOTimer;

public:
   TIdleTOTimerGuard(TIdleTOTimer *t) : fIdleTOTimer(t) { if (fIdleTOTimer) fIdleTOTimer->Stop(); }
   virtual ~TIdleTOTimerGuard() { if (fIdleTOTimer) fIdleTOTimer->Start(-1, kTRUE); }
};

//______________________________________________________________________________
inline Int_t TProofServ::GetCompressionLevel() const
{
   return (fCompressMsg < 0) ? -1 : fCompressMsg % 100;
}

#endif
 TProofServ.h:1
 TProofServ.h:2
 TProofServ.h:3
 TProofServ.h:4
 TProofServ.h:5
 TProofServ.h:6
 TProofServ.h:7
 TProofServ.h:8
 TProofServ.h:9
 TProofServ.h:10
 TProofServ.h:11
 TProofServ.h:12
 TProofServ.h:13
 TProofServ.h:14
 TProofServ.h:15
 TProofServ.h:16
 TProofServ.h:17
 TProofServ.h:18
 TProofServ.h:19
 TProofServ.h:20
 TProofServ.h:21
 TProofServ.h:22
 TProofServ.h:23
 TProofServ.h:24
 TProofServ.h:25
 TProofServ.h:26
 TProofServ.h:27
 TProofServ.h:28
 TProofServ.h:29
 TProofServ.h:30
 TProofServ.h:31
 TProofServ.h:32
 TProofServ.h:33
 TProofServ.h:34
 TProofServ.h:35
 TProofServ.h:36
 TProofServ.h:37
 TProofServ.h:38
 TProofServ.h:39
 TProofServ.h:40
 TProofServ.h:41
 TProofServ.h:42
 TProofServ.h:43
 TProofServ.h:44
 TProofServ.h:45
 TProofServ.h:46
 TProofServ.h:47
 TProofServ.h:48
 TProofServ.h:49
 TProofServ.h:50
 TProofServ.h:51
 TProofServ.h:52
 TProofServ.h:53
 TProofServ.h:54
 TProofServ.h:55
 TProofServ.h:56
 TProofServ.h:57
 TProofServ.h:58
 TProofServ.h:59
 TProofServ.h:60
 TProofServ.h:61
 TProofServ.h:62
 TProofServ.h:63
 TProofServ.h:64
 TProofServ.h:65
 TProofServ.h:66
 TProofServ.h:67
 TProofServ.h:68
 TProofServ.h:69
 TProofServ.h:70
 TProofServ.h:71
 TProofServ.h:72
 TProofServ.h:73
 TProofServ.h:74
 TProofServ.h:75
 TProofServ.h:76
 TProofServ.h:77
 TProofServ.h:78
 TProofServ.h:79
 TProofServ.h:80
 TProofServ.h:81
 TProofServ.h:82
 TProofServ.h:83
 TProofServ.h:84
 TProofServ.h:85
 TProofServ.h:86
 TProofServ.h:87
 TProofServ.h:88
 TProofServ.h:89
 TProofServ.h:90
 TProofServ.h:91
 TProofServ.h:92
 TProofServ.h:93
 TProofServ.h:94
 TProofServ.h:95
 TProofServ.h:96
 TProofServ.h:97
 TProofServ.h:98
 TProofServ.h:99
 TProofServ.h:100
 TProofServ.h:101
 TProofServ.h:102
 TProofServ.h:103
 TProofServ.h:104
 TProofServ.h:105
 TProofServ.h:106
 TProofServ.h:107
 TProofServ.h:108
 TProofServ.h:109
 TProofServ.h:110
 TProofServ.h:111
 TProofServ.h:112
 TProofServ.h:113
 TProofServ.h:114
 TProofServ.h:115
 TProofServ.h:116
 TProofServ.h:117
 TProofServ.h:118
 TProofServ.h:119
 TProofServ.h:120
 TProofServ.h:121
 TProofServ.h:122
 TProofServ.h:123
 TProofServ.h:124
 TProofServ.h:125
 TProofServ.h:126
 TProofServ.h:127
 TProofServ.h:128
 TProofServ.h:129
 TProofServ.h:130
 TProofServ.h:131
 TProofServ.h:132
 TProofServ.h:133
 TProofServ.h:134
 TProofServ.h:135
 TProofServ.h:136
 TProofServ.h:137
 TProofServ.h:138
 TProofServ.h:139
 TProofServ.h:140
 TProofServ.h:141
 TProofServ.h:142
 TProofServ.h:143
 TProofServ.h:144
 TProofServ.h:145
 TProofServ.h:146
 TProofServ.h:147
 TProofServ.h:148
 TProofServ.h:149
 TProofServ.h:150
 TProofServ.h:151
 TProofServ.h:152
 TProofServ.h:153
 TProofServ.h:154
 TProofServ.h:155
 TProofServ.h:156
 TProofServ.h:157
 TProofServ.h:158
 TProofServ.h:159
 TProofServ.h:160
 TProofServ.h:161
 TProofServ.h:162
 TProofServ.h:163
 TProofServ.h:164
 TProofServ.h:165
 TProofServ.h:166
 TProofServ.h:167
 TProofServ.h:168
 TProofServ.h:169
 TProofServ.h:170
 TProofServ.h:171
 TProofServ.h:172
 TProofServ.h:173
 TProofServ.h:174
 TProofServ.h:175
 TProofServ.h:176
 TProofServ.h:177
 TProofServ.h:178
 TProofServ.h:179
 TProofServ.h:180
 TProofServ.h:181
 TProofServ.h:182
 TProofServ.h:183
 TProofServ.h:184
 TProofServ.h:185
 TProofServ.h:186
 TProofServ.h:187
 TProofServ.h:188
 TProofServ.h:189
 TProofServ.h:190
 TProofServ.h:191
 TProofServ.h:192
 TProofServ.h:193
 TProofServ.h:194
 TProofServ.h:195
 TProofServ.h:196
 TProofServ.h:197
 TProofServ.h:198
 TProofServ.h:199
 TProofServ.h:200
 TProofServ.h:201
 TProofServ.h:202
 TProofServ.h:203
 TProofServ.h:204
 TProofServ.h:205
 TProofServ.h:206
 TProofServ.h:207
 TProofServ.h:208
 TProofServ.h:209
 TProofServ.h:210
 TProofServ.h:211
 TProofServ.h:212
 TProofServ.h:213
 TProofServ.h:214
 TProofServ.h:215
 TProofServ.h:216
 TProofServ.h:217
 TProofServ.h:218
 TProofServ.h:219
 TProofServ.h:220
 TProofServ.h:221
 TProofServ.h:222
 TProofServ.h:223
 TProofServ.h:224
 TProofServ.h:225
 TProofServ.h:226
 TProofServ.h:227
 TProofServ.h:228
 TProofServ.h:229
 TProofServ.h:230
 TProofServ.h:231
 TProofServ.h:232
 TProofServ.h:233
 TProofServ.h:234
 TProofServ.h:235
 TProofServ.h:236
 TProofServ.h:237
 TProofServ.h:238
 TProofServ.h:239
 TProofServ.h:240
 TProofServ.h:241
 TProofServ.h:242
 TProofServ.h:243
 TProofServ.h:244
 TProofServ.h:245
 TProofServ.h:246
 TProofServ.h:247
 TProofServ.h:248
 TProofServ.h:249
 TProofServ.h:250
 TProofServ.h:251
 TProofServ.h:252
 TProofServ.h:253
 TProofServ.h:254
 TProofServ.h:255
 TProofServ.h:256
 TProofServ.h:257
 TProofServ.h:258
 TProofServ.h:259
 TProofServ.h:260
 TProofServ.h:261
 TProofServ.h:262
 TProofServ.h:263
 TProofServ.h:264
 TProofServ.h:265
 TProofServ.h:266
 TProofServ.h:267
 TProofServ.h:268
 TProofServ.h:269
 TProofServ.h:270
 TProofServ.h:271
 TProofServ.h:272
 TProofServ.h:273
 TProofServ.h:274
 TProofServ.h:275
 TProofServ.h:276
 TProofServ.h:277
 TProofServ.h:278
 TProofServ.h:279
 TProofServ.h:280
 TProofServ.h:281
 TProofServ.h:282
 TProofServ.h:283
 TProofServ.h:284
 TProofServ.h:285
 TProofServ.h:286
 TProofServ.h:287
 TProofServ.h:288
 TProofServ.h:289
 TProofServ.h:290
 TProofServ.h:291
 TProofServ.h:292
 TProofServ.h:293
 TProofServ.h:294
 TProofServ.h:295
 TProofServ.h:296
 TProofServ.h:297
 TProofServ.h:298
 TProofServ.h:299
 TProofServ.h:300
 TProofServ.h:301
 TProofServ.h:302
 TProofServ.h:303
 TProofServ.h:304
 TProofServ.h:305
 TProofServ.h:306
 TProofServ.h:307
 TProofServ.h:308
 TProofServ.h:309
 TProofServ.h:310
 TProofServ.h:311
 TProofServ.h:312
 TProofServ.h:313
 TProofServ.h:314
 TProofServ.h:315
 TProofServ.h:316
 TProofServ.h:317
 TProofServ.h:318
 TProofServ.h:319
 TProofServ.h:320
 TProofServ.h:321
 TProofServ.h:322
 TProofServ.h:323
 TProofServ.h:324
 TProofServ.h:325
 TProofServ.h:326
 TProofServ.h:327
 TProofServ.h:328
 TProofServ.h:329
 TProofServ.h:330
 TProofServ.h:331
 TProofServ.h:332
 TProofServ.h:333
 TProofServ.h:334
 TProofServ.h:335
 TProofServ.h:336
 TProofServ.h:337
 TProofServ.h:338
 TProofServ.h:339
 TProofServ.h:340
 TProofServ.h:341
 TProofServ.h:342
 TProofServ.h:343
 TProofServ.h:344
 TProofServ.h:345
 TProofServ.h:346
 TProofServ.h:347
 TProofServ.h:348
 TProofServ.h:349
 TProofServ.h:350
 TProofServ.h:351
 TProofServ.h:352
 TProofServ.h:353
 TProofServ.h:354
 TProofServ.h:355
 TProofServ.h:356
 TProofServ.h:357
 TProofServ.h:358
 TProofServ.h:359
 TProofServ.h:360
 TProofServ.h:361
 TProofServ.h:362
 TProofServ.h:363
 TProofServ.h:364
 TProofServ.h:365
 TProofServ.h:366
 TProofServ.h:367
 TProofServ.h:368
 TProofServ.h:369
 TProofServ.h:370
 TProofServ.h:371
 TProofServ.h:372
 TProofServ.h:373
 TProofServ.h:374
 TProofServ.h:375
 TProofServ.h:376
 TProofServ.h:377
 TProofServ.h:378
 TProofServ.h:379
 TProofServ.h:380
 TProofServ.h:381
 TProofServ.h:382
 TProofServ.h:383
 TProofServ.h:384
 TProofServ.h:385
 TProofServ.h:386
 TProofServ.h:387
 TProofServ.h:388
 TProofServ.h:389
 TProofServ.h:390
 TProofServ.h:391
 TProofServ.h:392
 TProofServ.h:393
 TProofServ.h:394
 TProofServ.h:395
 TProofServ.h:396
 TProofServ.h:397
 TProofServ.h:398
 TProofServ.h:399
 TProofServ.h:400
 TProofServ.h:401
 TProofServ.h:402
 TProofServ.h:403
 TProofServ.h:404
 TProofServ.h:405
 TProofServ.h:406
 TProofServ.h:407
 TProofServ.h:408
 TProofServ.h:409
 TProofServ.h:410
 TProofServ.h:411
 TProofServ.h:412
 TProofServ.h:413
 TProofServ.h:414
 TProofServ.h:415
 TProofServ.h:416
 TProofServ.h:417
 TProofServ.h:418
 TProofServ.h:419
 TProofServ.h:420
 TProofServ.h:421
 TProofServ.h:422
 TProofServ.h:423
 TProofServ.h:424
 TProofServ.h:425
 TProofServ.h:426
 TProofServ.h:427
 TProofServ.h:428
 TProofServ.h:429
 TProofServ.h:430
 TProofServ.h:431
 TProofServ.h:432
 TProofServ.h:433
 TProofServ.h:434
 TProofServ.h:435
 TProofServ.h:436
 TProofServ.h:437
 TProofServ.h:438
 TProofServ.h:439
 TProofServ.h:440
 TProofServ.h:441
 TProofServ.h:442
 TProofServ.h:443
 TProofServ.h:444
 TProofServ.h:445
 TProofServ.h:446
 TProofServ.h:447
 TProofServ.h:448
 TProofServ.h:449
 TProofServ.h:450
 TProofServ.h:451
 TProofServ.h:452
 TProofServ.h:453
 TProofServ.h:454
 TProofServ.h:455
 TProofServ.h:456
 TProofServ.h:457
 TProofServ.h:458
 TProofServ.h:459
 TProofServ.h:460
 TProofServ.h:461
 TProofServ.h:462
 TProofServ.h:463
 TProofServ.h:464
 TProofServ.h:465
 TProofServ.h:466
 TProofServ.h:467
 TProofServ.h:468
 TProofServ.h:469
 TProofServ.h:470
 TProofServ.h:471
 TProofServ.h:472
 TProofServ.h:473
 TProofServ.h:474
 TProofServ.h:475
 TProofServ.h:476
 TProofServ.h:477
 TProofServ.h:478
 TProofServ.h:479
 TProofServ.h:480
 TProofServ.h:481
 TProofServ.h:482