ROOT logo
ROOT » NET » NET » TNetSystem

class TNetSystem: public TSystem


TNetFile

A TNetFile is like a normal TFile except that it reads and writes
its data via a rootd server (for more on the rootd daemon see the
source files root/rootd/src/*.cxx). TNetFile file names are in
standard URL format with protocol "root" or "roots". The following
are valid TNetFile URL's:

roots://hpsalo/files/aap.root
root://hpbrun.cern.ch/root/hsimple.root
root://pcna49a:5151/~na49/data/run821.root
root://pcna49d.cern.ch:5050//v1/data/run810.root

The only difference with the well known httpd URL's is that the root
of the remote file tree is the user's home directory. Therefore an
absolute pathname requires a // after the host or port specifier
(see last example). Further the expansion of the standard shell
characters, like ~, $, .., are handled as expected.
TNetFile (actually TUrl) uses 1094 as default port for rootd.

Connecting to a rootd requires the remote user id and password.
TNetFile allows three ways for you to provide your login:
1) Setting it globally via the static functions:
TAuthenticate::SetGlobalUser() and
TAuthenticate::SetGlobalPasswd()
2) Getting it from the ~/.netrc file (same file as used by ftp)
3) Command line prompt
The different methods will be tried in the order given above.
On machines with AFS rootd will authenticate using AFS (if it was
compiled with AFS support).

If the protocol is specified as "roots" a secure authetication
method will be used. The secure method uses the SRP, Secure Remote
 Passwords, package. SRP uses a so called "asymmetric key exchange    //
 protocol" in which no passwords are ever send over the wire. This    //
protocol is safe against all known security attacks. For more see:

NetFile //
                                                             //
If the protocol is specified as "rootk" kerberos5 will be used for
authentication.

The rootd daemon lives in the directory $ROOTSYS/bin. It can be
started either via inetd or by hand from the command line (no need
to be super user). For more info about rootd see the web page:

NetFile //
                                                             //


Function Members (Methods)

public:
TNetSystem(Bool_t ftpowner = kTRUE)
TNetSystem(const char* url, Bool_t ftpowner = kTRUE)
virtual~TNetSystem()
virtual voidTSystem::Abort(int code = 0)
voidTObject::AbstractMethod(const char* method) const
virtual intTSystem::AcceptConnection(int sock)
virtual Bool_tAccessPathName(const char* path, EAccessMode mode)
virtual voidTSystem::AddDynamicPath(const char* pathname)
virtual voidTSystem::AddFileHandler(TFileHandler* fh)
virtual voidTSystem::AddIncludePath(const char* includePath)
virtual voidTSystem::AddLinkedLibs(const char* linkedLib)
virtual voidTSystem::AddSignalHandler(TSignalHandler* sh)
virtual voidTSystem::AddStdExceptionHandler(TStdExceptionHandler* eh)
virtual voidTSystem::AddTimer(TTimer* t)
virtual intTSystem::AnnounceTcpService(int port, Bool_t reuse, int backlog, int tcpwindowsize = -1)
virtual intTSystem::AnnounceUnixService(int port, int backlog)
virtual intTSystem::AnnounceUnixService(const char* sockpath, int backlog)
virtual voidTObject::AppendPad(Option_t* option = "")
virtual const char*TSystem::BaseName(const char* pathname)
voidTSystem::Beep(Int_t freq = -1, Int_t duration = -1, Bool_t setDefault = kFALSE)
virtual voidTObject::Browse(TBrowser* b)
Bool_tTSystem::cd(const char* path)
virtual Bool_tTSystem::ChangeDirectory(const char* path)
virtual intTSystem::Chmod(const char* file, UInt_t mode)
static TClass*Class()
virtual const char*TObject::ClassName() const
virtual voidTSystem::CleanCompiledMacros()
virtual voidTNamed::Clear(Option_t* option = "")
virtual TObject*TNamed::Clone(const char* newname = "") const
virtual voidTSystem::CloseConnection(int sock, Bool_t force = kFALSE)
virtual voidTSystem::Closelog()
virtual intTSystem::ClosePipe(FILE* pipe)
virtual Int_tTNamed::Compare(const TObject* obj) const
virtual intTSystem::CompileMacro(const char* filename, Option_t* opt = "", const char* library_name = "", const char* build_dir = "", UInt_t dirmode = 0)
virtual char*TSystem::ConcatFileName(const char* dir, const char* name)
virtual Bool_tConsistentWith(const char* path, void* dirptr)
virtual voidTNamed::Copy(TObject& named) const
virtual intTSystem::CopyFile(const char* from, const char* to, Bool_t overwrite = kFALSE)
virtual voidTObject::Delete(Option_t* option = "")MENU
virtual const char*TSystem::DirName(const char* pathname)
virtual voidTSystem::DispatchOneEvent(Bool_t pendingOnly = kFALSE)
virtual Int_tTObject::DistancetoPrimitive(Int_t px, Int_t py)
virtual voidTObject::Draw(Option_t* option = "")
virtual voidTObject::DrawClass() constMENU
virtual TObject*TObject::DrawClone(Option_t* option = "") constMENU
virtual voidTObject::Dump() constMENU
virtual char*TSystem::DynamicPathName(const char* lib, Bool_t quiet = kFALSE)
virtual Func_tTSystem::DynFindSymbol(const char* module, const char* entry)
virtual voidTObject::Error(const char* method, const char* msgfmt) const
virtual Int_tTSystem::Exec(const char* shellcmd)
virtual voidTObject::Execute(const char* method, const char* params, Int_t* error = 0)
virtual voidTObject::Execute(TMethod* method, TObjArray* params, Int_t* error = 0)
virtual voidTObject::ExecuteEvent(Int_t event, Int_t px, Int_t py)
virtual voidTSystem::Exit(int code, Bool_t mode = kTRUE)
virtual voidTSystem::ExitLoop()
virtual Bool_tTSystem::ExpandPathName(TString& path)
virtual char*TSystem::ExpandPathName(const char* path)
virtual voidTObject::Fatal(const char* method, const char* msgfmt) const
virtual voidTNamed::FillBuffer(char*& buffer)
virtual const char*TSystem::FindFile(const char* search, TString& file, EAccessMode mode = kFileExists)
virtual TObject*TObject::FindObject(const char* name) const
virtual TObject*TObject::FindObject(const TObject* obj) const
virtual voidFreeDirectory(void* dirp = 0)
virtual TSystem::EAclicModeTSystem::GetAclicMode() const
virtual Int_tTSystem::GetAclicProperties() const
voidTSystem::GetBeepDefaults(Int_t& freq, Int_t& duration) const
virtual const char*TSystem::GetBuildArch() const
virtual const char*TSystem::GetBuildCompiler() const
virtual const char*TSystem::GetBuildCompilerVersion() const
virtual const char*TSystem::GetBuildDir() const
virtual const char*TSystem::GetBuildNode() const
virtual intTSystem::GetCpuInfo(CpuInfo_t* info, Int_t sampleTime = 1000) const
virtual const char*GetDirEntry(void* dirp = 0)
virtual Option_t*TObject::GetDrawOption() const
static Long_tTObject::GetDtorOnly()
virtual const char*TSystem::GetDynamicPath()
virtual Int_tTSystem::GetEffectiveGid()
virtual Int_tTSystem::GetEffectiveUid()
virtual const char*TSystem::Getenv(const char* env)
static Int_tTSystem::GetErrno()
virtual const char*TSystem::GetError()
const char*TSystem::GetErrorStr() const
virtual const char*TSystem::GetFlagsDebug() const
virtual const char*TSystem::GetFlagsOpt() const
virtual Int_tTSystem::GetFPEMask()
virtual TStringTSystem::GetFromPipe(const char* command)
virtual intTSystem::GetFsInfo(const char* path, Long_t* id, Long_t* bsize, Long_t* blocks, Long_t* bfree)
virtual Int_tTSystem::GetGid(const char* group = 0)
virtual UserGroup_t*TSystem::GetGroupInfo(Int_t gid)
virtual UserGroup_t*TSystem::GetGroupInfo(const char* group = 0)
virtual TInetAddressTSystem::GetHostByName(const char* server)
virtual const char*TObject::GetIconName() const
virtual const char*TSystem::GetIncludePath()
virtual const char*TSystem::GetLibraries(const char* regexp = "", const char* option = "", Bool_t isRegexp = kTRUE)
virtual const char*TSystem::GetLinkdefSuffix() const
virtual const char*TSystem::GetLinkedLibs() const
virtual TSeqCollection*TSystem::GetListOfFileHandlers() const
virtual TSeqCollection*TSystem::GetListOfSignalHandlers() const
virtual TSeqCollection*TSystem::GetListOfStdExceptionHandlers() const
virtual TSeqCollection*TSystem::GetListOfTimers() const
virtual const char*TSystem::GetMakeExe() const
virtual const char*TSystem::GetMakeSharedLib() const
virtual intTSystem::GetMemInfo(MemInfo_t* info) const
virtual const char*TNamed::GetName() const
virtual char*TObject::GetObjectInfo(Int_t px, Int_t py) const
static Bool_tTObject::GetObjectStat()
virtual const char*TSystem::GetObjExt() const
virtual Option_t*TObject::GetOption() const
virtual Int_tGetPathInfo(const char* path, FileStat_t& buf)
virtual TInetAddressTSystem::GetPeerName(int sock)
virtual intTSystem::GetPid()
virtual intTSystem::GetProcInfo(ProcInfo_t* info) const
virtual intTSystem::GetServiceByName(const char* service)
virtual char*TSystem::GetServiceByPort(int port)
virtual TInetAddressTSystem::GetSockName(int sock)
virtual intTSystem::GetSockOpt(int sock, int kind, int* val)
virtual const char*TSystem::GetSoExt() const
virtual intTSystem::GetSysInfo(SysInfo_t* info) const
virtual const char*TNamed::GetTitle() const
virtual Int_tTSystem::GetUid(const char* user = 0)
virtual UInt_tTObject::GetUniqueID() const
virtual UserGroup_t*TSystem::GetUserInfo(Int_t uid)
virtual UserGroup_t*TSystem::GetUserInfo(const char* user = 0)
virtual TList*TSystem::GetVolumes(Option_t*) const
virtual Bool_tTObject::HandleTimer(TTimer* timer)
virtual ULong_tTNamed::Hash() const
virtual const char*TSystem::HomeDirectory(const char* userName = 0)
virtual const char*TSystem::HostName()
virtual voidTSystem::IgnoreInterrupt(Bool_t ignore = kTRUE)
virtual voidTSystem::IgnoreSignal(ESignals sig, Bool_t ignore = kTRUE)
Bool_tTSystem::InControl() const
virtual voidTObject::Info(const char* method, const char* msgfmt) const
virtual Bool_tTObject::InheritsFrom(const char* classname) const
virtual Bool_tTObject::InheritsFrom(const TClass* cl) const
virtual Bool_tTSystem::Init()
virtual voidTSystem::InnerLoop()
virtual voidTObject::Inspect() constMENU
voidTObject::InvertBit(UInt_t f)
virtual TClass*IsA() const
virtual Bool_tTSystem::IsAbsoluteFileName(const char* dir)
virtual Bool_tTObject::IsEqual(const TObject* obj) const
virtual Bool_tTSystem::IsFileInIncludePath(const char* name, char** fullpath = 0)
virtual Bool_tTObject::IsFolder() const
Bool_tTObject::IsOnHeap() const
virtual Bool_tTSystem::IsPathLocal(const char* path)
virtual Bool_tTNamed::IsSortable() const
Bool_tTObject::IsZombie() const
virtual intTSystem::Link(const char* from, const char* to)
virtual voidTSystem::ListLibraries(const char* regexp = "")
virtual voidTSystem::ListSymbols(const char* module, const char* re = "")
virtual intTSystem::Load(const char* module, const char* entry = "", Bool_t system = kFALSE)
virtual voidTNamed::ls(Option_t* option = "") const
virtual Int_tMakeDirectory(const char* name)
voidTObject::MayNotUse(const char* method) const
virtual intTSystem::mkdir(const char* name, Bool_t recursive = kFALSE)
virtual Long_tTSystem::NextTimeOut(Bool_t mode)
virtual Bool_tTObject::Notify()
virtual voidTSystem::NotifyApplicationCreated()
virtual TTimeTSystem::Now()
voidTObject::Obsolete(const char* method, const char* asOfVers, const char* removedFromVers) const
virtual intTSystem::OpenConnection(const char* server, int port, int tcpwindowsize = -1)
virtual void*OpenDirectory(const char* name)
virtual voidTSystem::Openlog(const char* name, Int_t options, ELogFacility facility)
virtual FILE*TSystem::OpenPipe(const char* command, const char* mode)
static voidTObject::operator delete(void* ptr)
static voidTObject::operator delete(void* ptr, void* vp)
static voidTObject::operator delete[](void* ptr)
static voidTObject::operator delete[](void* ptr, void* vp)
void*TObject::operator new(size_t sz)
void*TObject::operator new(size_t sz, void* vp)
void*TObject::operator new[](size_t sz)
void*TObject::operator new[](size_t sz, void* vp)
virtual voidTObject::Paint(Option_t* option = "")
virtual voidTObject::Pop()
virtual const char*TSystem::PrependPathName(const char* dir, TString& name)
virtual voidTNamed::Print(Option_t* option = "") const
virtual Bool_tTSystem::ProcessEvents()
const char*TSystem::pwd()
virtual Int_tTObject::Read(const char* name)
virtual voidTObject::RecursiveRemove(TObject* obj)
virtual intTSystem::RecvBuf(int sock, void* buffer, int length)
virtual intTSystem::RecvRaw(int sock, void* buffer, int length, int flag)
virtual Int_tTSystem::RedirectOutput(const char* name, const char* mode = "a", RedirectHandle_t* h = 0)
virtual TFileHandler*TSystem::RemoveFileHandler(TFileHandler* fh)
voidTSystem::RemoveOnExit(TObject* obj)
virtual TSignalHandler*TSystem::RemoveSignalHandler(TSignalHandler* sh)
virtual TStdExceptionHandler*TSystem::RemoveStdExceptionHandler(TStdExceptionHandler* eh)
virtual TTimer*TSystem::RemoveTimer(TTimer* t)
virtual intTSystem::Rename(const char* from, const char* to)
voidTObject::ResetBit(UInt_t f)
static voidTSystem::ResetErrno()
virtual voidTSystem::ResetSignal(ESignals sig, Bool_t reset = kTRUE)
virtual voidTSystem::ResetTimer(TTimer*)
virtual voidTSystem::Run()
virtual voidTObject::SaveAs(const char* filename = "", Option_t* option = "") constMENU
virtual voidTObject::SavePrimitive(ostream& out, Option_t* option = "")
virtual Int_tTSystem::Select(TList* active, Long_t timeout)
virtual Int_tTSystem::Select(TFileHandler* fh, Long_t timeout)
virtual intTSystem::SendBuf(int sock, const void* buffer, int length)
virtual intTSystem::SendRaw(int sock, const void* buffer, int length, int flag)
virtual voidTSystem::SetAclicMode(TSystem::EAclicMode mode)
voidTObject::SetBit(UInt_t f)
voidTObject::SetBit(UInt_t f, Bool_t set)
virtual voidTSystem::SetBuildDir(const char* build_dir, Bool_t isflat = kFALSE)
virtual voidTSystem::SetDisplay()
virtual voidTObject::SetDrawOption(Option_t* option = "")MENU
static voidTObject::SetDtorOnly(void* obj)
virtual voidTSystem::SetDynamicPath(const char* pathname)
virtual voidTSystem::Setenv(const char* name, const char* value)
voidTSystem::SetErrorStr(const char* errstr)
virtual voidTSystem::SetFlagsDebug(const char*)
virtual voidTSystem::SetFlagsOpt(const char*)
virtual Int_tTSystem::SetFPEMask(Int_t mask = kDefaultMask)
virtual voidTSystem::SetIncludePath(const char* includePath)
virtual voidTSystem::SetLinkdefSuffix(const char* suffix)
virtual voidTSystem::SetLinkedLibs(const char* linkedLibs)
virtual voidTSystem::SetMakeExe(const char* directives)
virtual voidTSystem::SetMakeSharedLib(const char* directives)
virtual voidTNamed::SetName(const char* name)MENU
virtual voidTNamed::SetNameTitle(const char* name, const char* title)
static voidTObject::SetObjectStat(Bool_t stat)
virtual voidTSystem::SetObjExt(const char* objExt)
virtual voidTSystem::SetProgname(const char* name)
virtual intTSystem::SetSockOpt(int sock, int kind, int val)
virtual voidTSystem::SetSoExt(const char* soExt)
virtual voidTNamed::SetTitle(const char* title = "")MENU
virtual voidTObject::SetUniqueID(UInt_t uid)
virtual voidShowMembers(TMemberInspector& insp)
virtual voidTSystem::ShowOutput(RedirectHandle_t* h)
virtual Int_tTNamed::Sizeof() const
virtual voidTSystem::Sleep(UInt_t milliSec)
virtual TStringTSystem::SplitAclicMode(const char* filename, TString& mode, TString& args, TString& io) const
virtual voidTSystem::StackTrace()
virtual voidStreamer(TBuffer& b)
voidStreamerNVirtual(TBuffer& b)
virtual intTSystem::Symlink(const char* from, const char* to)
virtual voidTObject::SysError(const char* method, const char* msgfmt) const
virtual voidTSystem::Syslog(ELogLevel level, const char* mess)
virtual const char*TSystem::TempDirectory() const
virtual FILE*TSystem::TempFileName(TString& base, const char* dir = 0)
Bool_tTObject::TestBit(UInt_t f) const
Int_tTObject::TestBits(UInt_t f) const
virtual intTSystem::Umask(Int_t mask)
virtual const char*TSystem::UnixPathName(const char* unixpathname)
virtual intUnlink(const char* path)
virtual voidTSystem::Unload(const char* module)
virtual voidTSystem::Unsetenv(const char* name)
virtual voidTObject::UseCurrentStyle()
virtual intTSystem::Utime(const char* file, Long_t modtime, Long_t actime)
virtual voidTObject::Warning(const char* method, const char* msgfmt) const
virtual char*TSystem::Which(const char* search, const char* file, EAccessMode mode = kFileExists)
virtual const char*TSystem::WorkingDirectory()
virtual Int_tTObject::Write(const char* name = 0, Int_t option = 0, Int_t bufsize = 0)
virtual Int_tTObject::Write(const char* name = 0, Int_t option = 0, Int_t bufsize = 0) const
protected:
voidCreate(const char* url, TSocket* sock = 0)
virtual voidTSystem::DoBeep(Int_t = -1, Int_t = -1) const
virtual voidTObject::DoError(int level, const char* location, const char* fmt, va_list va) const
virtual const char*TSystem::ExpandFileName(const char* fname)
TSystem*TSystem::FindHelper(const char* path, void* dirptr = 0)
virtual const char*TSystem::GetLinkedLibraries()
voidInitRemoteEntity(const char* url)
voidTObject::MakeZombie()
virtual voidTSystem::SigAlarmInterruptsSyscalls(Bool_t)
static const char*TSystem::StripOffProto(const char* path, const char* proto)
private:
TNetSystem(const TNetSystem&)
virtual void*GetDirPtr() const
TNetSystem&operator=(const TNetSystem&)

Data Members

public:
enum TSystem::EAclicMode { kDefault
kDebug
kOpt
};
enum TSystem::EAclicProperties { kFlatBuildDir
};
enum TObject::EStatusBits { kCanDelete
kMustCleanup
kObjInCanvas
kIsReferenced
kHasUUID
kCannotPick
kNoContextMenu
kInvalidObject
};
enum TObject::[unnamed] { kIsOnHeap
kNotDeleted
kZombie
kBitMask
kSingleKey
kOverwrite
kWriteDelete
};
protected:
TSystem::EAclicModeTSystem::fAclicModeWhether the compilation should be done debug or opt
Int_tTSystem::fAclicPropertiesVarious boolean flag for change ACLiC's behavior.
Int_tTSystem::fBeepDurationUsed by Beep()
Int_tTSystem::fBeepFreqUsed by Beep()
TStringTSystem::fBuildArchArchitecure for which ROOT was built (passed to ./configure)
TStringTSystem::fBuildCompilerCompiler used to build this ROOT
TStringTSystem::fBuildCompilerVersionCompiler version used to build this ROOT
TStringTSystem::fBuildDirLocation where to build ACLiC shared library and use as scratch area.
TStringTSystem::fBuildNodeDetailed information where ROOT was built
TSeqCollection*TSystem::fCompiledList of shared libs from compiled macros to be deleted
Bool_tTSystem::fDoneTrue if eventloop should be finished
TSeqCollection*TSystem::fFileHandlerList of file handlers
TStringTSystem::fFlagsDebugFlags for debug compilation
TStringTSystem::fFlagsOptFlags for optimized compilation
TSeqCollection*TSystem::fHelpersList of helper classes for alternative file/directory access
TStringTSystem::fHostnameHostname
Bool_tTSystem::fInControlTrue if in eventloop
TStringTSystem::fIncludePathUsed to expand $IncludePath in the directives given to SetMakeSharedLib and SetMakeExe
Bool_tTSystem::fInsideNotifyUsed by DispatchTimers()
Bool_tfIsLocalTRUE if the path points to this host
TStringTSystem::fLastErrorStringLast system error message
Int_tTSystem::fLevelLevel of nested eventloops
TStringTSystem::fLinkdefSuffixDefault suffix for linkdef files to be used by ACLiC (see EACLiCProperties)
TStringTSystem::fLinkedLibsUsed to expand $LinkedLibs in the directives given to SetMakeSharedLib and SetMakeExe
TStringTSystem::fListLibsList shared libraries, cache used by GetLibraries
TStringTSystem::fListPathsList of all include (fIncludePath + interpreter include path). Cache used by GetIncludePath
TStringfLocalPrefixif fIsLocal, prefix to be prepend locally
TStringTSystem::fMakeExeDirective used to build an executable
TStringTSystem::fMakeSharedLibDirective used to build a shared library
Int_tTSystem::fMaxrfdLargest fd in read mask
Int_tTSystem::fMaxwfdLargest fd in write mask
TStringTNamed::fNameobject identifier
Int_tTSystem::fNfdNumber of fd's in masks
TStringTSystem::fObjExtExtension of object files (.o, .obj, etc.)
TSeqCollection*TSystem::fOnExitListList of items to be cleaned-up on exit
TFdSet*TSystem::fReadmask!Files that should be checked for read events
TFdSet*TSystem::fReadready!Files with reads waiting
Int_tTSystem::fSigcntNumber of pending signals
TSeqCollection*TSystem::fSignalHandlerList of signal handlers
TFdSet*TSystem::fSignals!Signals that were trapped
TStringTSystem::fSoExtExtension of shared library (.so, .sl, .a, .dll, etc.)
TSeqCollection*TSystem::fStdExceptionHandlerList of std::exception handlers
TSeqCollection*TSystem::fTimersList of timers
TStringTNamed::fTitleobject title
TStringTSystem::fWdpathWorking directory
TFdSet*TSystem::fWritemask!Files that should be checked for write events
TFdSet*TSystem::fWriteready!Files with writes waiting
private:
Bool_tfDirtrue if a directory is open remotely
void*fDirpdirectory handler
TFTP*fFTPConnection to rootd
Bool_tfFTPOwnerTrue if owner of the FTP instance
TStringfHostRemote host
Int_tfPortRemote port
TStringfUserRemote user

Class Charts

Inheritance Inherited Members Includes Libraries
Class Charts

Function documentation

TNetSystem(Bool_t ftpowner = kTRUE)
 Create helper class that allows directory access via rootd.
 Use ftpowner = TRUE (default) if this instance is responsible
 for cleaning of the underlying TFTP connection; this allows
 to have control on the order of the final cleaning.
TNetSystem(const char* url, Bool_t ftpowner = kTRUE)
 Create helper class that allows directory access via rootd.
 Use ftpowner = TRUE (default) if this instance is responsible
 for cleaning of the underlying TFTP connection; this allows
 to have control on the order of the final cleaning.
void InitRemoteEntity(const char* url)
 Parse and save coordinates of the remote entity (user, host, port, ...)
void Create(const char* url, TSocket* sock = 0)
 Create a TNetSystem object.
~TNetSystem()
 Destructor
Int_t MakeDirectory(const char* name)
 Make a directory via rootd.
void * OpenDirectory(const char* name)
 Open a directory via rfiod. Returns an opaque pointer to a dir
 structure. Returns 0 in case of error.
void FreeDirectory(void* dirp = 0)
 Free directory via rootd.
const char * GetDirEntry(void* dirp = 0)
 Get directory entry via rootd. Returns 0 in case no more entries.
Int_t GetPathInfo(const char* path, FileStat_t& buf)
 Get info about a file. Info is returned in the form of a FileStat_t
 structure (see TSystem.h).
 The function returns 0 in case of success and 1 if the file could
 not be stat'ed.
Bool_t AccessPathName(const char* path, EAccessMode mode)
 Returns FALSE if one can access a file using the specified access mode.
 Mode is the same as for the Unix access(2) function.
 Attention, bizarre convention of return value!!
Bool_t ConsistentWith(const char* path, void* dirptr)
 Check consistency of this helper with the one required
 by 'path' or 'dirptr'.
Int_t Unlink(const char* path)
 Remove a path
TNetFile& operator=(const TNetSystem& )
TNetSystem(const TNetSystem& )
void * GetDirPtr() const
{ return fDirp; }