TNetSystem

class TNetSystem : public TSystem

    private:

      virtual void* GetDirPtr() const

    public:

                          TNetSystem()
                          TNetSystem(const char* url)
                          TNetSystem(const TNetSystem&)
                  virtual ~TNetSystem()
           virtual Bool_t AccessPathName(const char* path, EAccessMode mode)
           static TClass* Class()
           virtual Bool_t ConsistentWith(const char* path, void* dirptr)
             virtual void FreeDirectory(void* dirp = 0)
      virtual const char* GetDirEntry(void* dirp = 0) const
            virtual Int_t GetPathInfo(const char* path, Long_t* id, Long64_t* size, Long_t* flags, Long_t* modtime)
          virtual TClass* IsA() const
            virtual Int_t MakeDirectory(const char* name)
            virtual void* OpenDirectory(const char* name)
              TNetSystem& operator=(const TNetSystem&)
             virtual void ShowMembers(TMemberInspector& insp, char* parent)
             virtual void Streamer(TBuffer& b)
                     void StreamerNVirtual(TBuffer& b)

Data Members

    private:

       Bool_t fDir   true if a directory is open remotely
        void* fDirp  directory handler
        TFTP* fFTP   Connection to rootd
      TString fHost  Remote host
      TString fUser  Remote user

Class Description

                                                                      
 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:   
 

                                                             
 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:       
 

 Create helper class that allows directory access via rootd.

 Create helper class that allows directory access via rootd.

 Dtor

 Make a directory via rootd.

 Open a directory via rfiod. Returns an opaque pointer to a dir
 structure. Returns 0 in case of error.

 Free directory via rootd.

 Get directory entry via rootd. Returns 0 in case no more entries.

 Get info about a file: id, size, flags, modification time.
 Id      is 0 for RFIO file
 Size    is the file size
 Flags   is file type: 0 is regular file, bit 0 set executable,
                       bit 1 set directory, bit 2 set special file
                       (socket, fifo, pipe, etc.)
 Modtime is modification time.
 The function returns 0 in case of success and 1 if the file could
 not be stat'ed.

 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!!

 Check consistency of this helper with the one required
 by 'path' or 'dirptr'.

Inline Functions

              void* GetDirPtr() const
            TClass* Class()
            TClass* IsA() const
               void ShowMembers(TMemberInspector& insp, char* parent)
               void Streamer(TBuffer& b)
               void StreamerNVirtual(TBuffer& b)
         TNetSystem TNetSystem(const TNetSystem&)
        TNetSystem& operator=(const TNetSystem&)