/*++ Copyright (c) 1989 Microsoft Corporation Module Name: mupstruc.h Abstract: This module defines the data structures that make up the major internal part of the MUP. Author: Manny Weiser (mannyw) 16-Dec-1991 Revision History: --*/ #ifndef _MUPSTRUC_ #define _MUPSTRUC_ typedef enum _BLOCK_TYPE { BlockTypeUndefined, BlockTypeVcb, BlockTypeUncProvider, BlockTypeKnownPrefix, BlockTypeFcb, BlockTypeCcb, BlockTypeMasterIoContext, BlockTypeIoContext, BlockTypeMasterQueryContext, BlockTypeQueryContext, BlockTypeBuffer } BLOCK_TYPE; typedef enum _BLOCK_STATE { BlockStateUnknown, BlockStateActive, BlockStateClosing } BLOCK_STATE; // // A block header starts every block // typedef struct _BLOCK_HEADER { BLOCK_TYPE BlockType; BLOCK_STATE BlockState; ULONG ReferenceCount; ULONG BlockSize; } BLOCK_HEADER, *PBLOCK_HEADER; // // The MUP volume control block. This structure is used to track access // the the MUP device object. // typedef struct _VCB { BLOCK_HEADER BlockHeader; // // The IO share access. // SHARE_ACCESS ShareAccess; } VCB, *PVCB; // // The MUP Device Object is an I/O system device object. // typedef struct _MUP_DEVICE_OBJECT { DEVICE_OBJECT DeviceObject; VCB Vcb; } MUP_DEVICE_OBJECT, *PMUP_DEVICE_OBJECT; // // A UNC provider. A UNC provider block corresponds to a registered UNC // provider device. // typedef struct _UNC_PROVIDER { BLOCK_HEADER BlockHeader; LIST_ENTRY ListEntry; // // The device name of the provider // UNICODE_STRING DeviceName; // // Our handle to the UNC device and the associated file and device objects // HANDLE Handle; PDEVICE_OBJECT DeviceObject; PFILE_OBJECT FileObject; // // The priority of the provider. // ULONG Priority; // // Indicate if the provider supports mailslots. // BOOLEAN MailslotsSupported; } UNC_PROVIDER, *PUNC_PROVIDER; // // A known prefix. A known prefix is a path prefix (like \\server\share) // that is "owned" by a specific UNC provider. // typedef struct _KNOWN_PREFIX { BLOCK_HEADER BlockHeader; UNICODE_PREFIX_TABLE_ENTRY TableEntry; // // The prefix string // UNICODE_STRING Prefix; // // The time the prefix was last used. // LARGE_INTEGER LastUsedTime; // // A referenced pointer to the owning UNC Provider // PUNC_PROVIDER UncProvider; // // If TRUE the Prefix string was allocated separately to this block. // BOOLEAN PrefixStringAllocated; // // If TRUE the Prefix string has been inserted in the prefix table // BOOLEAN InTable; } KNOWN_PREFIX, *PKNOWN_PREFIX; // // A File Control Block. The FCB corresponds to an open broadcast file, // i.e. a mailslot handle. We don't store any information about the FCB, // we let the various providers handle all of that. // typedef struct _FCB { BLOCK_HEADER BlockHeader; // // A pointer to the IO system's file object, that references this FCB. // PFILE_OBJECT FileObject; // // A list of CCBs for this FCB. The list is protected by MupCcbListLock. // LIST_ENTRY CcbList; } FCB, *PFCB; // // A CCB. The CCB is the per provider version of the FCB, all provider // specific information about an FCB is kept here. // typedef struct _CCB { BLOCK_HEADER BlockHeader; // // A referenced pointer to the FCB for this CCB. // PFCB Fcb; // // A list entry to keep this block on the FCB's CcbList. // LIST_ENTRY ListEntry; // // The file and device objects for this open file. // PDEVICE_OBJECT DeviceObject; PFILE_OBJECT FileObject; } CCB, *PCCB; // // The master and slave forward i/o context blocks are used to track // forward IRPs. Each forwarded IRP is tracked by the // Master Forwarded Io Context (which corresponds to our FCB) and a per // provider Io Context (which corresponse to our CCB). // // Since the Forwarded Io Context is never referenced or dereferenced it // doesn't get a block header. // typedef struct _MASTER_FORWARDED_IO_CONTEXT { BLOCK_HEADER BlockHeader; // // The original IRP (i.e. the one sent to the MUP) that is being handled. // PIRP OriginalIrp; // // The status that will be used to complete the Irp. If all the mailslot // writes fail (eg. a portable not in its docking station) then the status // from the last write will be returned. If one works then STATUS_SUCCESS. // // NTSTATUS SuccessStatus; NTSTATUS ErrorStatus; // // A referenced pointer to the FCB for this i/o. // PFCB Fcb; } MASTER_FORWARDED_IO_CONTEXT, *PMASTER_FORWARDED_IO_CONTEXT; typedef struct _FORWARDED_IO_CONTEXT { // // A referenced pointer to the CCB. // PCCB Ccb; // // A referenced pointer to the Master Context. // PMASTER_FORWARDED_IO_CONTEXT MasterContext; } FORWARDED_IO_CONTEXT, *PFORWARDED_IO_CONTEXT; // // The master and slave query path context blocks are used to track // create IRPs. Each forwarded IRP is tracked by the // Master query Path Context (which corresponds to our FCB) and a per // provider query path (which corresponse to our CCB). // // Since the query path context is never referenced or dereferenced it // doesn't get a block header. // typedef struct _MASTER_QUERY_PATH_CONTEXT { BLOCK_HEADER BlockHeader; // // A pointer to the original create IRP. // PIRP OriginalIrp; // // A pointer to the FileObject in the original create IRP. // PFILE_OBJECT FileObject; // // This is used to track the identity of the provider that will // receive the Create IRP. // PUNC_PROVIDER Provider; // // A lock to protect access to Provider // MUP_LOCK Lock; // // An unreferenced pointer to the newly allocated known prefix block. // PKNOWN_PREFIX KnownPrefix; // // The status code to be returned from this operation // NTSTATUS ErrorStatus; } MASTER_QUERY_PATH_CONTEXT, *PMASTER_QUERY_PATH_CONTEXT; typedef struct _QUERY_PATH_CONTEXT { // // A referenced poitner to the master query path context block. // PMASTER_QUERY_PATH_CONTEXT MasterContext; // // A referenced pointer to the UNC provider we are querying. // PUNC_PROVIDER Provider; // // A pointer to the Device Io Control buffer we allocated to query // the above provider. // PVOID Buffer; } QUERY_PATH_CONTEXT, *PQUERY_PATH_CONTEXT; #endif // _MUPSTRUC_