/*++ Copyright (c) 1999 Microsoft Corporation Module Name: webdav.h Abstract: This module defines the data structures and functions related to the WebDav protocol. Author: Rohan Kumar [rohank] 17-Mar-1999 Revision History: --*/ #ifndef _WEBDAV_H #define _WEBDAV_H #ifdef RX_PRIVATE_BUILD #undef IoGetTopLevelIrp #undef IoSetTopLevelIrp #endif // // The miniredir dipatch vector used by RDBSS. // extern struct _MINIRDR_DISPATCH MRxDAVDispatch; // // A serialization mutex used for various things. // extern FAST_MUTEX MRxDAVSerializationMutex; // // A pointer to the process that the RDBSS posts to. This is a non disappearing // process! // extern PEPROCESS MRxDAVSystemProcess; // // The DavWinInetCachePath which is used in satisfying volume related queries. // extern WCHAR DavWinInetCachePath[MAX_PATH]; // // The ProcessId of the svchost.exe process that loads the webclnt.dll. // extern ULONG DavSvcHostProcessId; // // The exchange device name will be stored in this KEY_VALUE_PARTIAL_INFORMATION // structure. // extern PBYTE DavExchangeDeviceName; // // Name cache stuff. These values are read from the registry during init time. // extern ULONG FileInformationCacheLifeTimeInSec; extern ULONG FileNotFoundCacheLifeTimeInSec; extern ULONG NameCacheMaxEntries; // // The timeout values for various operations used by the MiniRedir. If an // operation is not completed within the timeout value specified for it, is // cancelled. The user can set the value to 0xffffffff to disable the // timeout/cancel logic. In other words, if the timeout value is 0xffffffff, // the requests will never timeout. // extern ULONG CreateRequestTimeoutValueInSec; extern ULONG CreateVNetRootRequestTimeoutValueInSec; extern ULONG QueryDirectoryRequestTimeoutValueInSec; extern ULONG CloseRequestTimeoutValueInSec; extern ULONG CreateSrvCallRequestTimeoutValueInSec; extern ULONG FinalizeSrvCallRequestTimeoutValueInSec; extern ULONG FinalizeFobxRequestTimeoutValueInSec; extern ULONG FinalizeVNetRootRequestTimeoutValueInSec; extern ULONG ReNameRequestTimeoutValueInSec; extern ULONG SetFileInfoRequestTimeoutValueInSec; extern ULONG QueryFileInfoRequestTimeoutValueInSec; extern ULONG QueryVolumeInfoRequestTimeoutValueInSec; extern ULONG LockRefreshRequestTimeoutValueInSec; // // The timer thread wakes up every "TimerThreadSleepTimeInSec" and cancels all // the requests which haven't completed in their specified timeout value. This // value is set to the min of the timeout values of all the requests mentioned // above. // extern ULONG TimerThreadSleepTimeInSec; // // The timer object used by the timer thread that cancels the requests which // have not completed in a specified time. // extern KTIMER DavTimerObject; // // This is used to indicate the timer thread to shutdown. When the system is // being shutdown this is set to TRUE. MRxDAVTimerThreadLock is the resource // used to gain access to this variable. // extern BOOL TimerThreadShutDown; extern ERESOURCE MRxDAVTimerThreadLock; // // The handle of the timer thread that is created using PsCreateSystemThread // is stored this global. // extern HANDLE TimerThreadHandle; // // This event is signalled by the timer thread right before its going to // terminate itself. // extern KEVENT TimerThreadEvent; // // If QueueLockRefreshWorkItem is TRUE, the TimerThread (which cancels all the // AsyncEngineContexts that haven't completed in a specified time) queues a // WorkItem to refresh the locks. After the WorkItem has been queued the value // of QueueLockRefreshWorkItem is set to FALSE. Once the worker thread is // done refreshing all the locks, it resets this value to TRUE. We have a // corresponding lock QueueLockRefreshWorkItemLock to synchronize access to // QueueLockRefreshWorkItem. // extern BOOL QueueLockRefreshWorkItem; extern ERESOURCE QueueLockRefreshWorkItemLock; // // The WorkQueueItem used in the MRxDAVContextTimerThread function to refresh // the LOCKs taken by this client. // extern RX_WORK_QUEUE_ITEM LockRefreshWorkQueueItem; #define DAV_MJ_READ 0 #define DAV_MJ_WRITE 1 // // Pool tags used by the reflector library. All the DAV MiniRedir pool tags // have "DV" as the first two characters. // #define DAV_SRVCALL_POOLTAG ('cSVD') #define DAV_NETROOT_POOLTAG ('tNVD') #define DAV_FILEINFO_POOLTAG ('iFVD') #define DAV_FILENAME_POOLTAG ('nFVD') #define DAV_EXCHANGE_POOLTAG ('xEVD') #define DAV_READWRITE_POOLTAG ('wRVD') #define DAV_QUERYDIR_POOLTAG ('dQVD') #define DAV_SRVOPEN_POOLTAG ('oSVD') #define DAV_LOCKTOKENENTRY_POOLTAG ('tLVD') #define DAV_LOCKCONFLICTENTRY_POOLTAG ('cLVD') // // Use the DavDbgTrace macro for logging Mini-Redir stuff in the kernel // debugger. // #if DBG extern ULONG MRxDavDebugVector; #define DAV_TRACE_ERROR 0x00000001 #define DAV_TRACE_DEBUG 0x00000002 #define DAV_TRACE_CONTEXT 0x00000004 #define DAV_TRACE_DETAIL 0x00000008 #define DAV_TRACE_ENTRYEXIT 0x00000010 #define DAV_TRACE_QUERYDIR 0x00000020 #define DAV_TRACE_OPENCLOSE 0x00000040 #define DAV_TRACE_READ 0x00000080 #define DAV_TRACE_WRITE 0x00000100 #define DAV_TRACE_SRVCALL 0x00000200 #define DAV_TRACE_FCBFOBX 0x00000400 #define DAV_TRACE_DAVNETROOT 0x00000800 #define DAV_TRACE_INFOCACHE 0x00001000 #define DAV_TRACE_ALL 0xffffffff #define DavDbgTrace(_x_, _y_) { \ if (_x_ & MRxDavDebugVector) { \ DbgPrint _y_; \ } \ } #else #define DavDbgTrace(_x_, _y_) #endif // // The initialization states of the miniredir. // typedef enum _WEBDAV_INIT_STATES { MRxDAVINIT_START, MRxDAVINIT_MINIRDR_REGISTERED } WEBDAV_INIT_STATES; // // These are used by the entry point routines to specify what entrypoint was // called. This facilitates common continuation routines. // typedef enum _WEBDAV_MINIRDR_ENTRYPOINTS { DAV_MINIRDR_ENTRY_FROM_CREATE = 0, DAV_MINIRDR_ENTRY_FROM_CLEANUPFOBX, DAV_MINIRDR_ENTRY_FROM_CREATESRVCALL, DAV_MINIRDR_ENTRY_FROM_CREATEVNETROOT, DAV_MINIRDR_ENTRY_FROM_FINALIZESRVCALL, DAV_MINIRDR_ENTRY_FROM_FINALIZEVNETROOT, DAV_MINIRDR_ENTRY_FROM_CLOSESRVOPEN, DAV_MINIRDR_ENTRY_FROM_RENAME, DAV_MINIRDR_ENTRY_FROM_READ, DAV_MINIRDR_ENTRY_FROM_WRITE, DAV_MINIRDR_ENTRY_FROM_QUERYDIR, DAV_MINIRDR_ENTRY_FROM_SETFILEINFORMATION, DAV_MINIRDR_ENTRY_FROM_QUERYFILEINFORMATION, DAV_MINIRDR_ENTRY_FROM_QUERYVOLUMEINFORMATION, DAV_MINIRDR_ENTRY_FROM_REFRESHTHELOCK, DAV_MINIRDR_ENTRY_FROM_MAXIMUM } WEBDAV_MINIRDR_ENTRYPOINTS; // // The states of the I/O operation(s). // typedef enum _WEBDAV_INNERIO_STATE { MRxDAVInnerIoStates_Initial = 0, MRxDAVInnerIoStates_ReadyToSend, MRxDAVInnerIoStates_OperationOutstanding } WEBDAV_INNERIO_STATE; // // The WebDav context structure that encapsulates the AsyncEngineCtx structure // and has the miniredir specific fields. // typedef struct _WEBDAV_CONTEXT { // // The AsyncEngineCtx Structure used by the Reflector library. // union { UMRX_ASYNCENGINE_CONTEXT; UMRX_ASYNCENGINE_CONTEXT AsyncEngineContext; }; // // This is used by the entry point routines to specify what entrypoint was // called. This facilitates common continuation routines. // WEBDAV_MINIRDR_ENTRYPOINTS EntryPoint; // // These describe the inner state of the I/O operation. These states are // described in the MRxDAV_INNERIO_STATE data structure. // UCHAR OpSpecificState; // // Pointer to the information strucutre for the Create request. // PDAV_USERMODE_CREATE_RETURNED_FILEINFO CreateReturnedFileInfo; // // This is used in the Continuation functions for the read, write and // querydir calls. It keeps track of the number of times the Continuation // routine has been called. // ULONG ContinueEntryCount; } WEBDAV_CONTEXT, *PWEBDAV_CONTEXT; // // While creating the AsyncEngineContext, the extra space needed for the // miniredir specific fields is also allocated. Thus, one doesn't need to // allocate twice. // #define SIZEOF_DAV_SPECIFIC_CONTEXT \ sizeof(WEBDAV_CONTEXT) - sizeof(UMRX_ASYNCENGINE_CONTEXT) // // The WebDav device object structure that encapsulates the UMRX_DEVICE_OBJECT // structure and has the miniredir specific fields. // typedef struct _WEBDAV_DEVICE_OBJECT { // // The UMRX_DEVICE_OBJECT structure. // union { UMRX_DEVICE_OBJECT; UMRX_DEVICE_OBJECT UMRefDeviceObject; }; // // TRUE => miniredir has been started. // BOOLEAN IsStarted; // // The FCB of the device object. // PVOID CachedRxDeviceFcb; // // The process registering this device object. // PEPROCESS RegisteringProcess; } WEBDAV_DEVICE_OBJECT, *PWEBDAV_DEVICE_OBJECT; // // The Dav device object. // extern PWEBDAV_DEVICE_OBJECT MRxDAVDeviceObject; // // The extra number of bytes needed for the device object. This info is used // when the device object gets created. // #define WEBDAV_DEVICE_OBJECT_EXTENSION_SIZE \ (sizeof(WEBDAV_DEVICE_OBJECT) - sizeof(RDBSS_DEVICE_OBJECT)) // // For every LOCK that is taken for a file, the following entry is created and // added to the global LockTokenEntryList. // typedef struct _WEBDAV_LOCK_TOKEN_ENTRY { LIST_ENTRY listEntry; // // The LockToken that was returned by the server on a successful LOCK // request. // PWCHAR OpaqueLockToken; // // The server on which the file is shared. // PWCHAR ServerName; // // The path of the file on the server. // PWCHAR PathName; // // The ServerHashTable ServerId of this server. // ULONG ServerID; // // The LogonId of this user. // LUID LogonID; // // If this is set to FALSE, this LockEntry is not refreshed. // BOOL ShouldThisEntryBeRefreshed; // // The SecurityClientContext of the client in whose context the LOCK was // taken. This is needed to impersonate the client when refreshing the // LOCK. // PSECURITY_CLIENT_CONTEXT SecurityClientContext; // // The timeout value of the LOCK taken on the server. If the client wants // to hold the LOCK beyond this timeout then it needs to refresh the LOCK // before the timeout expires. // ULONG LockTimeOutValueInSec; // // The system tick count when this LOCK entry was created. This value is // used in sending out LOCK refresh requests. // LARGE_INTEGER CreationTimeInTickCount; } WEBDAV_LOCK_TOKEN_ENTRY, *PWEBDAV_LOCK_TOKEN_ENTRY; // // The global list of all the active LOCK tokens (one for every LOCK taken) and // the resource that is used to synchronize access to it. // extern LIST_ENTRY LockTokenEntryList; extern ERESOURCE LockTokenEntryListLock; #define WEBDAV_LOCKCONFLICTENTRY_LIFETIMEINSEC 10 // // For every LOCK request that fails, we create an entry below and add it to // the global LockConflictEntryList. // typedef struct _WEBDAV_LOCK_CONFLICT_ENTRY { LIST_ENTRY listEntry; // // The complete path name of the file that has already been locked on the // server. // PWCHAR CompletePathName; // // The owner of the LOCK on the file as returned by the server. // PWCHAR LockOwner; // // The system tick count when this entry was created. This entry is kept // alive for WEBDAV_LOCKCONFLICTENTRY_LIFETIMEINSEC seconds. // LARGE_INTEGER CreationTimeInTickCount; } WEBDAV_LOCK_CONFLICT_ENTRY, *PWEBDAV_LOCK_CONFLICT_ENTRY; // // The global list of all the LOCK conflict entries and the resource that is // used to synchronize access to it. // extern LIST_ENTRY LockConflictEntryList; extern ERESOURCE LockConflictEntryListLock; // // The WEBDAV specific FOBX structure. // typedef struct _WEBDAV_FOBX { // // The pointer to the DavFileAttribute list for this directory. This list // is created on the first call to Enumerate files in the directory. // PDAV_FILE_ATTRIBUTES DavFileAttributes; // // Number of DavFileAttribute entries. // ULONG NumOfFileEntries; // // The index of the next file to be returned to the user. The file index // starts from zero, hence file index = 0 => the first file entry etc. // ULONG CurrentFileIndex; // // Pointer to the next entry. // PLIST_ENTRY listEntry; } WEBDAV_FOBX, *PWEBDAV_FOBX; // // A pointer to an instance of WEBDAV_SRV_OPEN is stored in the context field // of MRX_SRV_OPEN strucutre. // #define MRxDAVGetFobxExtension(pFobx) \ (((pFobx) == NULL) ? NULL : (PWEBDAV_FOBX)((pFobx)->Context)) // // The WEBDAV specific SRV_OPEN structure. // typedef struct _WEBDAV_SRV_OPEN { // // The file handle associated with this SrvOpen. // HANDLE UnderlyingHandle; // // This also is the handle got from the usermode. Its used for debugging // purposes. // PVOID UserModeKey; // // Pointer to the file object associated with the handle. This is set // after the handle is successfully created in the usermode. // PFILE_OBJECT UnderlyingFileObject; // // Pointer to the device object represented by the file object mentioned // above. // PDEVICE_OBJECT UnderlyingDeviceObject; // // This indicates whether we need to call IoRaiseInformationalHardError // when the close fails. We need to do this if the PUT or DELETE failed and // the operation which the user expects has succeeded actually failed. // BOOL RaiseHardErrorIfCloseFails; // // Created In Kernel. // BOOL createdInKernel; // // The OpaqueLockToken returned by the server if the file was LOCKed on // Create. This token has to be sent with every request that modifies the // data or the properties of this file. // PWCHAR OpaqueLockToken; // // The LockTokenEntry created for the OpaqueLockToken above. // PWEBDAV_LOCK_TOKEN_ENTRY LockTokenEntry; } WEBDAV_SRV_OPEN, *PWEBDAV_SRV_OPEN; // // A pointer to an instance of WEBDAV_SRV_OPEN is stored in the context field // of MRX_SRV_OPEN strucutre. // #define MRxDAVGetSrvOpenExtension(pSrvOpen) \ (((pSrvOpen) == NULL) ? NULL : (PWEBDAV_SRV_OPEN)((pSrvOpen)->Context)) // // The WEBDAV specific FCB structure. // typedef struct _WEBDAV_FCB { // // Is this FCB for a directory ? // BOOL isDirectory; // // Does the File exist in the WinInet cache ?? // BOOL isFileCached; // // Should this file be deleted on Close ? // BOOL DeleteOnClose; // // Was this file written to ? // ULONG FileWasModified; // // Did we reset the FileWasModified in the DavFcb to FALSE? If we did and // the PUT failed, we need to reset the FileWasModified field in the FCB to // TRUE. // BOOL FileModifiedBitReset; // // If we happen to LOCK the file on the server on Create we set this to // TRUE. On CloseSrvOpen we check if this value is TRUE. If it is and the // file has been modified, we only go to the usermode to do the PUT, DELETE, // PROPPATCH etc, if the SrvOpen contains the OpaqueLockToken. If it does // not then any request that modifies the file is going to fail with a // 423. // BOOL FileIsLockedOnTheServer; // // On Close, if the file has been modified, we PROPPATCH the time values // as well. We take the current time as the value of the "Last Modified Time" // (LMT). If the SetFileInformation of the LMT happens after the file has // been modifed, then we should use what ever LMT is already in the FCB as // the LMT. For example, // Create, Write, Close - Use the CurrentTime in close as the LMT. // Create, Write, SetFileInfo(LMT), Close - Use the LMT in the FCB. // BOOL DoNotTakeTheCurrentTimeAsLMT; // // This resource is used to synchronize the "Read-Modify-Write" routine // in the Write path of the DAV Redir. This is because when we get non-cached // writes to the MiniRedir which do not extend the VaildDataLength, RDBSS, // acquires the FCB resource shared. This means that multiple threads could // be writing data to the local file (in the DAV Redir case) in which case // they can overwrite each others changes since we do Read-Modify-Write. // Hence we need to protect this code using a resource which we acqiure // in an exclusive fashion when we do these writes. We allocate memory for // this resource and initialize it the first time we need to acquire the // lock. If allocated and initialized, it will be uninitialized and // deallocated when the FCB is being deallocated. // PERESOURCE DavReadModifyWriteLock; // // We store the file name information on create. This is used if the delayed // write failed to pop up the dialogue box and write an eventlog entry. // UNICODE_STRING FileNameInfo; BOOL FileNameInfoAllocated; // // Changes in directory entry. // BOOLEAN fCreationTimeChanged; BOOLEAN fLastAccessTimeChanged; BOOLEAN fLastModifiedTimeChanged; BOOLEAN fFileAttributesChanged; // // Was this file renamed ? // BOOL FileWasRenamed; BOOL LocalFileIsEncrypted; SECURITY_CLIENT_CONTEXT SecurityClientContext; // // If the file gets renamed, the new name is copied into this buffer. // WCHAR NewFileName[MAX_PATH]; // // Length of the new file name. // ULONG NewFileNameLength; // // The file name of the local file that represents the file on the DAV // server which has been created. // WCHAR FileName[MAX_PATH]; WCHAR Url[MAX_PATH * 2]; } WEBDAV_FCB, *PWEBDAV_FCB; // // A pointer to an instance of WEBDAV_FCB is stored in the context field // of MRX_FCB strucutre. // #define MRxDAVGetFcbExtension(pFcb) \ (((pFcb) == NULL) ? NULL : (PWEBDAV_FCB)((pFcb)->Context)) // // The WEBDAV specific V_NET_ROOT structure. // typedef struct _WEBDAV_V_NET_ROOT { // // The client's security context. This is set during the create call. // SECURITY_CLIENT_CONTEXT SecurityClientContext; // // Is set to true after the above context is set. This is used to avoid // initialization of the SecurityContext. // BOOLEAN SCAlreadyInitialized; // // Has the LogonID of this V_NET_ROOT been set ? // BOOL LogonIDSet; // // The LogonID for this session. // LUID LogonID; // // Is this an Office Web Server share? // BOOL isOfficeShare; // // Is this a TAHOE share? // BOOL isTahoeShare; // // Is PROPATCH method allowed? // BOOL fAllowsProppatch; // // Was this VNetRoot "NOT" created successfully in the usermode? We keep this // info because when a finalize VNetRoot request comes, we need to know // whether need to go upto the usermode to finalize the PerUserEntry. If the // create failed then this BOOL is set to TRUE. If this is TRUE, then we // don't go to the usermode to finalize the PerUserEntry. // BOOL createVNetRootUnSuccessful; // does he report available space? BOOL fReportsAvailableSpace; } WEBDAV_V_NET_ROOT, *PWEBDAV_V_NET_ROOT; // // The WEBDAV specific V_NET_ROOT structure. // typedef struct _WEBDAV_NET_ROOT { ULONG RefCount; PMRX_NET_ROOT pRdbssNetRoot; // The Rdbss NetRoot it belongs to NAME_CACHE_CONTROL NameCacheCtlGFABasic; // The basic file information name cache control. NAME_CACHE_CONTROL NameCacheCtlGFAStandard; // The standard file information name cache control. NAME_CACHE_CONTROL NameCacheCtlFNF; // The File not found name cache control. } WEBDAV_NET_ROOT, *PWEBDAV_NET_ROOT; // // A pointer to an instance of WEBDAV_V_NET_ROOT is stored in the context field // of MRX_V_NET_ROOT strucutre. // #define MRxDAVGetVNetRootExtension(pVNetRoot) \ (((pVNetRoot) == NULL) ? NULL : (PWEBDAV_V_NET_ROOT)((pVNetRoot)->Context)) // // The WEBDAV specific V_NET_ROOT structure. // typedef struct _WEBDAV_SRV_CALL { // // The Unique ServerID. // ULONG ServerID; // // Is set to true after the above context is set. Used to check whether we // need to delete the SecurityClientContext when we are completing the // request. // BOOLEAN SCAlreadyInitialized; } WEBDAV_SRV_CALL, *PWEBDAV_SRV_CALL; // // A pointer to an instance of WEBDAV_SRV_CALL is stored in the context field // of MRX_SRV_CALL strucutre. // #define MRxDAVGetSrvCallExtension(pSrvCall) \ (((pSrvCall) == NULL) ? NULL : (PWEBDAV_SRV_CALL)((pSrvCall)->Context)) // // Get the Security client context associated with this request. // #define MRxDAVGetSecurityClientContext() { \ if (RxContext != NULL && RxContext->pRelevantSrvOpen != NULL) { \ if (RxContext->pRelevantSrvOpen->pVNetRoot != NULL) { \ if (RxContext->pRelevantSrvOpen->pVNetRoot->Context != NULL) { \ DavVNetRoot = (PWEBDAV_V_NET_ROOT) \ RxContext->pRelevantSrvOpen->pVNetRoot->Context; \ SecurityClientContext = &(DavVNetRoot->SecurityClientContext); \ } \ } \ } \ } // // We turn away async operations that are not wait by posting. If we can wait // then we turn off the sync flag so that things will just act synchronous. // #define TURN_BACK_ASYNCHRONOUS_OPERATIONS() { \ if (FlagOn(RxContext->Flags, RX_CONTEXT_FLAG_ASYNC_OPERATION)) { \ if (FlagOn(RxContext->Flags, RX_CONTEXT_FLAG_WAIT)) { \ ClearFlag(RxContext->Flags, RX_CONTEXT_FLAG_ASYNC_OPERATION) \ } else { \ RxContext->PostRequest = TRUE; \ return STATUS_PENDING; \ } \ } \ } // // Global locking variables and macros. // extern RX_SPIN_LOCK MRxDAVGlobalSpinLock; extern KIRQL MRxDAVGlobalSpinLockSavedIrql; extern BOOLEAN MRxDAVGlobalSpinLockAcquired; #define MRxDAVAcquireGlobalSpinLock() \ KeAcquireSpinLock(&MRxDAVGlobalSpinLock,&MRxDAVGlobalSpinLockSavedIrql); \ MRxDAVGlobalSpinLockAcquired = TRUE #define MRxDAVReleaseGlobalSpinLock() \ MRxDAVGlobalSpinLockAcquired = FALSE; \ KeReleaseSpinLock(&MRxDAVGlobalSpinLock,MRxDAVGlobalSpinLockSavedIrql) #define MRxDAVGlobalSpinLockAcquired() \ (MRxDAVGlobalSpinLockAcquired == TRUE) // // The IrpCompletionContext structure that is used in the read/write operations. // All we need is an event on which we will wait till the underlying file system // completes the request. This event gets signalled in the Completion routine // that we specify. // typedef struct _WEBDAV_READ_WRITE_IRP_COMPLETION_CONTEXT { // // The event which is signalled in the Completion routine that is passed // to IoCallDriver in the read and write requests. // KEVENT DavReadWriteEvent; } WEBDAV_READ_WRITE_IRP_COMPLETION_CONTEXT, *PWEBDAV_READ_WRITE_IRP_COMPLETION_CONTEXT; // // The prototypes of functions defined for various I/O requests by the DAV // miniredir are mentioned below. // // // Create/Open/Cleanup/Close Request function prototypes. // NTSTATUS MRxDAVCreate( IN PRX_CONTEXT RxContext ); NTSTATUS MRxDAVCleanupFobx ( IN OUT PRX_CONTEXT RxContext ); NTSTATUS MRxDAVCloseSrvOpen ( IN OUT PRX_CONTEXT RxContext ); NTSTATUS MRxDAVCollapseOpen ( IN OUT PRX_CONTEXT RxContext ); NTSTATUS MRxDAVComputeNewBufferingState( IN OUT PMRX_SRV_OPEN pSrvOpen, IN PVOID pMRxContext, OUT ULONG *pNewBufferingState ); NTSTATUS MRxDAVForcedClose ( IN OUT PMRX_SRV_OPEN SrvOpen ); NTSTATUS MRxDAVShouldTryToCollapseThisOpen ( IN PRX_CONTEXT RxContext ); NTSTATUS MRxDAVTruncate ( IN OUT PRX_CONTEXT RxContext ); VOID MRxDAVSetLoud( IN PBYTE Msg, IN PRX_CONTEXT RxContext, IN PUNICODE_STRING s ); NTSTATUS MRxDAVFlush ( IN OUT PRX_CONTEXT RxContext ); // // Read prototypes. // NTSTATUS MRxDAVRead ( IN OUT PRX_CONTEXT RxContext ); // // Write prototypes. // NTSTATUS MRxDAVWrite( IN PRX_CONTEXT RxContext ); ULONG MRxDAVExtendForCache( IN OUT PRX_CONTEXT RxContext, IN OUT PLARGE_INTEGER NewFileSize, OUT PLARGE_INTEGER NewAllocationSize ); ULONG MRxDAVExtendForNonCache( IN OUT PRX_CONTEXT RxContext, IN OUT PLARGE_INTEGER NewFileSize, OUT PLARGE_INTEGER NewAllocationSize ); // // SrvCall function prototypes. // NTSTATUS MRxDAVCreateSrvCall( PMRX_SRV_CALL pSrvCall, PMRX_SRVCALL_CALLBACK_CONTEXT pCallbackContext ); NTSTATUS MRxDAVFinalizeSrvCall( PMRX_SRV_CALL pSrvCall, BOOLEAN Force ); NTSTATUS MRxDAVSrvCallWinnerNotify( IN PMRX_SRV_CALL pSrvCall, IN BOOLEAN ThisMinirdrIsTheWinner, IN OUT PVOID pSrvCallContext ); // // NetRoot/VNetRoot function prototypes. // NTSTATUS MRxDAVUpdateNetRootState( IN OUT PMRX_NET_ROOT pNetRoot ); NTSTATUS MRxDAVCreateVNetRoot( IN PMRX_CREATENETROOT_CONTEXT pCreateNetRootContext ); NTSTATUS MRxDAVFinalizeVNetRoot( IN PMRX_V_NET_ROOT pVNetRoot, IN PBOOLEAN ForceDisconnect ); NTSTATUS MRxDAVFinalizeNetRoot( IN PMRX_NET_ROOT pNetRoot, IN PBOOLEAN ForceDisconnect ); VOID MRxDAVExtractNetRootName( IN PUNICODE_STRING FilePathName, IN PMRX_SRV_CALL SrvCall, OUT PUNICODE_STRING NetRootName, OUT PUNICODE_STRING RestOfName OPTIONAL ); // // Query Directory prototypes. // NTSTATUS MRxDAVQueryDirectory( IN PRX_CONTEXT RxContext ); // // Query volume. // NTSTATUS MRxDAVQueryVolumeInformation( IN PRX_CONTEXT RxContext ); // // File Information. // NTSTATUS MRxDAVQueryFileInformation( IN PRX_CONTEXT RxContext ); NTSTATUS MRxDAVSetFileInformation( IN PRX_CONTEXT RxContext ); // // DevFcb prototypes. // NTSTATUS MRxDAVDevFcbXXXControlFile ( IN OUT PRX_CONTEXT RxContext ); NTSTATUS MRxDAVStart ( IN OUT struct _RX_CONTEXT * RxContext, IN OUT PRDBSS_DEVICE_OBJECT RxDeviceObject ); NTSTATUS MRxDAVStop ( IN OUT struct _RX_CONTEXT * RxContext, IN OUT PRDBSS_DEVICE_OBJECT RxDeviceObject ); BOOLEAN MRxDAVFastIoDeviceControl ( IN struct _FILE_OBJECT *FileObject, IN BOOLEAN Wait, IN PVOID InputBuffer OPTIONAL, IN ULONG InputBufferLength, OUT PVOID OutputBuffer OPTIONAL, IN ULONG OutputBufferLength, IN ULONG IoControlCode, OUT PIO_STATUS_BLOCK IoStatus, IN struct _DEVICE_OBJECT *DeviceObject ); BOOLEAN MRxDAVFastIoRead( IN PFILE_OBJECT FileObject, IN PLARGE_INTEGER FileOffset, IN ULONG Length, IN BOOLEAN Wait, IN ULONG LockKey, OUT PVOID Buffer, OUT PIO_STATUS_BLOCK IoStatus, IN PDEVICE_OBJECT DeviceObject ); BOOLEAN MRxDAVFastIoWrite( IN PFILE_OBJECT FileObject, IN PLARGE_INTEGER FileOffset, IN ULONG Length, IN BOOLEAN Wait, IN ULONG LockKey, OUT PVOID Buffer, OUT PIO_STATUS_BLOCK IoStatus, IN PDEVICE_OBJECT DeviceObject ); // // Other Misc prototypes. // NTSTATUS MRxDAVSyncXxxInformation( IN OUT PRX_CONTEXT RxContext, IN UCHAR MajorFunction, IN PFILE_OBJECT FileObject, IN ULONG InformationClass, IN ULONG Length, OUT PVOID Information, OUT PULONG_PTR ReturnedLength OPTIONAL ); NTSTATUS MRxDAVDeallocateForFcb ( IN OUT PMRX_FCB pFcb ); NTSTATUS MRxDAVDeallocateForFobx ( IN OUT PMRX_FOBX pFobx ); // // The prototype of the routine that formats the DAV specific portion of the // context. // NTSTATUS MRxDAVFormatTheDAVContext( PUMRX_ASYNCENGINE_CONTEXT AsyncEngineContext, USHORT EntryPoint ); NTSTATUS DavXxxInformation( IN const int xMajorFunction, IN PFILE_OBJECT FileObject, IN ULONG InformationClass, IN ULONG Length, OUT PVOID Information, OUT PULONG ReturnedLength ); ULONG DavReadWriteFileEx( IN USHORT Operation, IN BOOL NonPagedBuffer, IN BOOL UseOriginalIrpsMDL, IN PMDL OriginalIrpsMdl, IN PDEVICE_OBJECT DeviceObject, IN PFILE_OBJECT FileObject, IN ULONGLONG FileOffset, IN OUT PVOID DataBuffer, IN ULONG SizeInBytes, OUT PIO_STATUS_BLOCK IoStatusBlock ); NTSTATUS DavReadWriteIrpCompletionRoutine( IN PDEVICE_OBJECT DeviceObject, IN PIRP CalldownIrp, IN PVOID Context ); NTSTATUS MRxDAVProbeForReadWrite( IN PBYTE BufferToBeValidated, IN DWORD BufferSize, IN BOOL doProbeForRead, IN BOOL doProbeForWrite ); NTSTATUS MRxDAVFsCtl( IN OUT PRX_CONTEXT RxContext ); NTSTATUS MRxDAVIsValidDirectory( IN OUT PRX_CONTEXT RxContext, IN PUNICODE_STRING DirectoryName ); NTSTATUS MRxDAVCancelRoutine( PRX_CONTEXT RxContext ); VOID MRxDAVTimeOutTheContexts( BOOL WindDownAllContexts ); VOID MRxDAVContextTimerThread( PVOID DummyContext ); NTSTATUS MRxDAVQueryEaInformation ( IN OUT PRX_CONTEXT RxContext ); NTSTATUS MRxDAVSetEaInformation ( IN OUT PRX_CONTEXT RxContext ); NTSTATUS MRxDAVGetFullParentDirectoryPath( PRX_CONTEXT RxContext, PUNICODE_STRING ParentDirName ); NTSTATUS MRxDAVGetFullDirectoryPath( PRX_CONTEXT RxContext, PUNICODE_STRING FileName, PUNICODE_STRING DirName ); NTSTATUS MRxDAVCreateEncryptedDirectoryKey( PUNICODE_STRING DirName ); NTSTATUS MRxDAVRemoveEncryptedDirectoryKey( PUNICODE_STRING DirName ); NTSTATUS MRxDAVQueryEncryptedDirectoryKey( PUNICODE_STRING DirName ); VOID MRxDAVCleanUpTheLockConflictList( BOOL CleanUpAllEntries ); #endif //_WEBDAV_H