nfp.inl

一个普通的mount工具,能过CIFS协议来挂载盘符

#ifndef NFP_INL_
#define	NFP_INL_

#include <stdlib.h>
#include <crit_sec.h>

#define	INVALID_FILE_OFFSET	0xFFFFFFFF

namespace namNFS
{

const int FILE_SYS_PORT = 5111;
const int FILE_AGENT_PORT = 5112;

const int TRANSACTION_ID_SIZE = sizeof(int);

struct St_FileSysRequest
{
    enum Eu_RequestType
    {
        enOpen,
        enClose,
        enCreate,
        enRemove,
        enRename,
    };

    Eu_RequestType eRequest;
    DWORD dwPara;
    TCHAR aryData[1];

    void *operator new (size_t n1, size_t n2)
    {
        return ::operator new( n1 + n2 );
    }
};

struct St_FileOperation
{
    enum Eu_OperationType
    {
        enRead,
        enWrite,
        enSeek,
		enGetSize
    };

	int nTransactionId;
    Eu_OperationType eOperation;
    NFS_REL_REMOTE_HANDLE hFileObject;
    ULARGE_INTEGER u64Data;

    St_FileOperation() {}

    St_FileOperation( Eu_OperationType eOperationType,
		NFS_REL_REMOTE_HANDLE hFile )
	{
        nTransactionId = ::rand();
        eOperation = eOperationType;
        hFileObject = hFile;
    }
};

struct St_IntegerHolder
{
    int nTransactionId;
    int nValue;
};

struct St_FileSizeHolder
{
    int nTransactionId;
    ULARGE_INTEGER u64Size;
};

class ClHostConnection;
class ClHostAgent
{
    friend class ClHostConnection;
protected:
    ClClientSocket m_FileSys;
    ClClientSocket m_FileAgent;
public:
    BOOL connect( struct sockaddr_in SocketAddr );
};

class ClHostConnection
{
protected:
    char m_szHostAddr[20];
    struct sockaddr_in m_HostAddr;

    ClHostAgent m_HostAgent;
    ClCriticalSection m_csLock;
	BOOL m_isCreated;

public:
    ClHostConnection( LPCSTR szHostIP );

	BOOL isCreated()
	{
		return m_isCreated;
	}

    operator LPCRITICAL_SECTION() const { return m_csLock; }
    BOOL operator == ( LPCSTR szHostIP ) const
    {
        return ::strcmp( m_szHostAddr, szHostIP ) == 0;
    }

    SOCKET getFileSysSocket() const { return m_HostAgent.m_FileSys; }
    SOCKET getFileSocket() const { return m_HostAgent.m_FileAgent; }
};

class ClClientFileObject
{
protected:
    enum
    {
        SIGNATURE = 'NFSO',
        DESTRUCTED = 0xC3C3
    };

    DWORD m_dwSignature;
public:
    ClHostConnection * m_pHost;
    NFS_REL_REMOTE_HANDLE m_Handle;

    ClClientFileObject(ClHostConnection * pHost, NFS_REL_REMOTE_HANDLE h) : 
      m_dwSignature( SIGNATURE ),
      m_pHost( pHost ),
      m_Handle(h) {}
    ~ClClientFileObject()
    {
        m_dwSignature = DESTRUCTED;
    }

    BOOL isValid() const 
	{ 
		if( this == NULL || 
            (PVOID)this == INVALID_HANDLE_VALUE ||
            ::IsBadReadPtr( this, sizeof(*this) ) )
		{
			return FALSE;
		}

		return m_dwSignature == SIGNATURE; 
	}
};

#ifndef WINNT

class ClServerFileObject
{
protected:
    enum
    {
        SIGNATURE = 'NFSO',
        DESTRUCTED = 0xC3C3
    };

    DWORD m_dwSignature;
    HANDLE m_hFile;
public:
    ClServerFileObject(HANDLE hFile) : 
      m_dwSignature( SIGNATURE ),
      m_hFile( hFile ) {}
    ~ClServerFileObject()
    {
        if( m_hFile != INVALID_HANDLE_VALUE )
        {
            ::CloseHandle( m_hFile );
            m_hFile = INVALID_HANDLE_VALUE;
        }
        m_dwSignature = DESTRUCTED;
    }

    BOOL isValid() const 
	{ 
		if( this == NULL || 
            (PVOID)this == INVALID_HANDLE_VALUE || 
            ::IsBadReadPtr( this, sizeof(*this) ) )
		{
			return FALSE;
		}

		return m_dwSignature == SIGNATURE; 
	}

    HANDLE getHandle() const 
    {
        if( isValid() )
        {
            return m_hFile;
        }

        return INVALID_HANDLE_VALUE;
    }
};

#endif

}   //  namespace namNFS

#endif