fileserver.h

Windows CE 6.0 Server 源码

             UINT *puiUsed,
             SMB_PACKET *pSMB);
    DWORD SMB_Com_Seek(SMB_PROCESS_CMD *_pRawRequest,
                 SMB_PROCESS_CMD *_pRawResponse,
                 UINT *puiUsed,
                 SMB_PACKET *pSMB);
};




//
// Forward declar classes here
class FileObject;

struct FID_INFO {
    USHORT FID;
    BOOL fHasExclusiveRead;
    BOOL fHasExclusiveWrite;
};

//
// Abstraction used for all file operations -- mainly here to implement range
//    locking
class FileObject
{
    public:
        FileObject(USHORT usFID);
        ~FileObject();

        HRESULT Close();
        HRESULT Delete();
        HRESULT Open(const WCHAR *pFile,
                                DWORD dwDisposition,
                                DWORD dwAttributes,
                                DWORD dwAccess,
                                DWORD dwShareMode,
                                DWORD *pdwActionTaken = NULL);
        HRESULT Read(USHORT usFID,
                                BYTE *pDest,
                                LONG lOffset,
                                DWORD dwReqSize,
                                DWORD *pdwRead);
        HRESULT Write(USHORT usFID,
                                BYTE *pSrc,
                                LONG lOffset,
                                DWORD dwReqSize,
                                DWORD *pdwWritten);
        HRESULT SetFileTime(FILETIME *pCreation,
                                FILETIME *pAccess,
                                FILETIME *pWrite);

        HRESULT GetFileTime(FILETIME *lpCreationTime,
                                FILETIME *lpLastAccessTime,
                                FILETIME *lpLastWriteTime);

        HRESULT GetFileInformation(DWORD* pdwFileAttributes,
                                FILETIME* lpCreationTime,
                                FILETIME* lpLastAccessTime,
                                FILETIME* lpLastWriteTime,
                                DWORD* pdwFileSizeHigh,
                                DWORD* pdwFileSizeLow,
                                DWORD* pdwNumberOfLinks,
                                DWORD* pdwFileIndexHigh,
                                DWORD* pdwFileIndexLow);

        HRESULT SetEndOfStream(DWORD dwOffset);
        HRESULT GetFileSize(DWORD *pdwSize);
        USHORT  FID();
        const WCHAR  *FileName();
        HRESULT Flush();

        VOID SetPerFileState(ce::smart_ptr<PerFileState> &pNode);
        ce::smart_ptr<PerFileState> GetPerFileState();
        HRESULT IsLocked(SMB_LARGELOCK_RANGE *pRangeLock, BOOL *pfLocked);
        HRESULT Lock(SMB_LARGELOCK_RANGE *pRangeLock);
        HRESULT UnLock(SMB_LARGELOCK_RANGE *pRangeLock);
        BOOL   IsShareDelete() {return m_fShareDelete;}
        VOID    SetShareDelete(BOOL fVal) {m_fShareDelete = fVal;}
        const WCHAR *GetFileName();
    private:
        HANDLE m_hFile;
        USHORT m_usFID;
        BOOL m_fShareDelete;

        StringConverter m_FileName;
        RangeLock *m_LockNode;
        ce::smart_ptr<PerFileState> m_PerFileState;
        CRITICAL_SECTION m_csFileLock;
};


class PerFileState {
    public:
        StringConverter m_FileName;
        RangeLock       m_RangeLock;
        UINT            m_uiRefCnt;
        BOOL            m_fDeleteOnClose;
        UINT            m_uiNonShareDeleteOpens;

        BOOL            m_fOpBreakSent;
        BOOL            m_fBatchOpLock;
        USHORT          m_usLockTID;
        USHORT          m_usLockFID;
        ULONG           m_ulLockConnectionID;
        QueuePacketToBeSent m_pfnQueueFunction;
        DeleteTransportToken m_pfnDeleteToken;
        VOID           *m_pTransToken;
        ce::list<HANDLE, BLOCKED_HANDLES_ALLOC > m_BlockedOnOpLockList;
};


//
// Abstraction for file system (it adds functionality for things the CE filesystem doesnt support)
class AbstractFileSystem
{
    public:
        AbstractFileSystem();
        ~AbstractFileSystem();

        //NOTE:  this API must call SetLastError!!!
        HRESULT AFSDeleteFile(const WCHAR *pFile);
        HRESULT Open(const WCHAR *pFileName,
                     USHORT usFID,
                     DWORD dwAccess,
                     DWORD dwDisposition,
                     DWORD dwAttributes,
                     DWORD dwShareMode,
                     DWORD *pdwActionTaken = NULL,
                     SMBFile_OpLock_PassStruct *pOpLock = NULL);
        HRESULT Close(USHORT usFID);
        HRESULT FindFile(USHORT usFID, ce::smart_ptr<FileObject> &pFileObject);
        HRESULT BreakOpLock(PerFileState *pFileState);
    private:
        ce::list<ce::smart_ptr<FileObject>, AFS_FILEOBJECT_ALLOC >        m_FileObjectList;  //Use only under AFSLock!
        ce::list<ce::smart_ptr<PerFileState>,  AFS_PERFILESTATE_ALLOC >   m_PerFileState;   //Use only under AFSLock!
        CRITICAL_SECTION AFSLock;
};

//
// A FileStream is the generic abstraction for a SMBFileStream.
class FileStream : public SMBFileStream
{
    public:
        FileStream(TIDState *pMyState, USHORT usFID);
        ~FileStream();

        void * operator new(size_t size) {
             return SMB_Globals::g_FileStreamAllocator.allocate(size);
        }
        void   operator delete(void *mem, size_t size) {
            SMB_Globals::g_FileStreamAllocator.deallocate(mem, size);
        }

        //
        // Functions required by SMBFileStream
        HRESULT Read(BYTE *pDest,
                     DWORD dwOffset,
                     DWORD dwReqSize,
                     DWORD *pdwRead);
        HRESULT Write(BYTE *pSrc,
                     DWORD dwOffset,
                     DWORD dwReqSize,
                     DWORD *pdwWritten);
        HRESULT Open(const WCHAR *pFileName,
                     DWORD dwAccess,
                     DWORD dwDisposition,
                     DWORD dwAttributes,
                     DWORD dwShareMode,
                     DWORD *pdwActionTaken = NULL,
                     SMBFile_OpLock_PassStruct *pdwOpLock = NULL);
        HRESULT SetEndOfStream(DWORD dwOffset);
        HRESULT SetFilePointer(LONG lDistance,
                            DWORD dwMoveMethod,
                            ULONG *pOffset);
        HRESULT GetFileSize(DWORD *pdwSize);
        HRESULT SetFileTime(FILETIME *pCreation,
                            FILETIME *pAccess,
                            FILETIME *pWrite);
        HRESULT GetFileTime(LPFILETIME lpCreationTime,
                           LPFILETIME lpLastAccessTime,
                           LPFILETIME lpLastWriteTime);
        HRESULT Flush();
        HRESULT Close();
        HRESULT QueryFileInformation(WIN32_FIND_DATA *fd, DWORD *pdwNumberOfLinks);
        BOOL    CanRead();
        BOOL    CanWrite();

        HRESULT IsLocked(SMB_LARGELOCK_RANGE *pRangeLock, BOOL *pfLocked);
        HRESULT Lock(SMB_LARGELOCK_RANGE *pRangeLock);
        HRESULT UnLock(SMB_LARGELOCK_RANGE *pRangeLock);
        HRESULT BreakOpLock();
        HRESULT Delete();
        const WCHAR *GetFileName();

        HRESULT GetChangeNotification(HANDLE *pHand, const WCHAR **pListenOn);
        HRESULT SetChangeNotification(HANDLE h, const WCHAR *pListenOn);

    private:
        HANDLE m_hChangeNotification;
        StringConverter m_ChangeListeningTo;

        BOOL m_fOpened;
        DWORD m_dwAccess;
        DWORD m_dwCurrentOffset;
};

//
// Stubbing function for SMB file
FileStream *GetNewFileStream(TIDState *pMyState, USHORT usFID);