windows-xp/Source/XPSP1/NT/base/fs/srv/srvblock.h


								/*++ BUILD Version: 0003    // Increment this if a change has global effects


								Copyright (c) 1989  Microsoft Corporation


								Module Name:


								    srvblock.h


								Abstract:


								    This module defines the standard header for data blocks maintained

								    by the LAN Manager server.


								Author:


								    Chuck Lenzmeier (chuckl) 1-Dec-1989

								    David Treadwell (davidtr)


								Revision History:


								--*/


								#ifndef _SRVBLOCK_

								#define _SRVBLOCK_


								//#include "srvtypes.h"


								//

								// The following define the various types of data blocks used by the

								// server.

								//

								// *** The pool tag array in heapmgr.c must be maintained in concert

								//     with these definitions.

								//


								#define BlockTypeGarbage            0x00

								#define BlockTypeBuffer             0x01

								#define BlockTypeConnection         0x02

								#define BlockTypeEndpoint           0x03

								#define BlockTypeLfcb               0x04

								#define BlockTypeMfcb               0x05

								#define BlockTypeRfcb               0x06

								#define BlockTypeSearch             0x07

								#define BlockTypeSearchCore         0x08

								#ifdef INCLUDE_SMB_PERSISTENT

								#define BlockTypeByteRangeLock      0x09

								#endif

								#define BlockTypeSession            0x0A

								#define BlockTypeShare              0x0B

								#define BlockTypeTransaction        0x0C

								#define BlockTypeTreeConnect        0x0D

								#define BlockTypeWaitForOplockBreak 0x0E

								#define BlockTypeCommDevice         0x0F

								#define BlockTypeWorkContextInitial 0x10

								#define BlockTypeWorkContextNormal  0x11

								#define BlockTypeWorkContextRaw     0x12

								#define BlockTypeWorkContextSpecial 0x13

								#define BlockTypeCachedDirectory    0x14


								// The following "blocks" do NOT have block headers.


								#define BlockTypeDataBuffer         0x15

								#define BlockTypeTable              0x16

								#define BlockTypeNonpagedHeader     0x17

								#define BlockTypePagedConnection    0x18

								#define BlockTypePagedRfcb          0x19

								#define BlockTypeNonpagedMfcb       0x1A

								#define BlockTypeTimer              0x1B

								#define BlockTypeAdminCheck         0x1C

								#define BlockTypeWorkQueue          0x1D

								#define BlockTypeDfs                0x1E

								#define BlockTypeLargeReadX         0x1F

								#define BlockTypeAdapterStatus      0x20

								#define BlockTypeShareRemark        0x21

								#define BlockTypeShareSecurityDescriptor    0x22

								#define BlockTypeVolumeInformation  0x23

								#define BlockTypeFSName             0x24

								#define BlockTypeNameInfo           0x25

								#define BlockTypeDirectoryInfo      0x26

								#define BlockTypeDirCache           0x27

								#define BlockTypeMisc               0x28

								#define BlockTypeSnapShot           0x29

								#ifdef INCLUDE_SMB_PERSISTENT

								#define BlockTypePersistentState    0x2A

								#define BlockTypePersistentBitMap   0x2B

								#define BlockTypePersistShareState  0x2C


								// The following is defined just to know how many types there are.


								#define BlockTypeMax                0x2D


								#else


								// The following is defined just to know how many types there are.


								#define BlockTypeMax                0x2A

								#endif


								//

								// The following define the various states that blocks can be in.

								// Initializing is used (relatively rarely) to indicate that

								// creation/initialization of a block is in progress.  Active is the

								// state blocks are usually in.  Closing is used to indicate that a

								// block is being prepared for deletion; when the reference count on the

								// block reaches 0, the block will be deleted.  Dead is used when

								// debugging code is enabled to indicate that the block has been

								// deleted.

								//


								#define BlockStateDead          0x00

								#define BlockStateInitializing  0x01

								#define BlockStateActive        0x02

								#define BlockStateClosing       0x03


								// The following is defined just to know how many states there are.


								#define BlockStateMax           0x04


								//

								// ALLOCATE_NONPAGED_POOL is a macro that translates to a call to

								// SrvAllocateNonPagedPool if debugging is not enabled or to

								// SrvAllocateNonPagedPoolDebug if it is enabled.

								// DEALLOCATE_NONPAGED_POOL translates to SrvFreeNonPagedPool or

								// SrvFreeNonPagedPoolDebug.  The Srv routines are used to track pool

								// usage by the server.

								//


								//

								// When POOL_TAGGING is on, we pass the block type through to

								// SrvAllocateNonPagedPool so that it can pass a tag to the pool

								// allocator.

								//


								#ifdef POOL_TAGGING

								#define ALLOCATE_NONPAGED_POOL(size,type) \

								            SrvAllocateNonPagedPool( (size), (type) )

								#else

								#define ALLOCATE_NONPAGED_POOL(size,type) \

								            SrvAllocateNonPagedPool( (size) )

								#endif


								#define DEALLOCATE_NONPAGED_POOL(addr) SrvFreeNonPagedPool( (addr) )


								//

								// Routines that track server nonpaged pool usage in order to support the

								// "maxnonpagedmemoryusage" configuration parameter.

								//


								PVOID SRVFASTCALL

								SrvAllocateNonPagedPool (

								    IN CLONG NumberOfBytes

								#ifdef POOL_TAGGING

								    ,IN CLONG BlockType

								#endif

								    );


								VOID SRVFASTCALL

								SrvFreeNonPagedPool (

								    IN PVOID Address

								    );


								VOID SRVFASTCALL

								SrvClearLookAsideList(

								    PLOOK_ASIDE_LIST l,

								    VOID (SRVFASTCALL *FreeRoutine )( PVOID )

								    );


								//

								// The _HEAP macros are like the _NONPAGED_POOL macros, except they

								// operate on paged pool.  The "HEAP" name is historical, from the

								// days when the server used process heap instead of paged pool.

								//

								// *** When SRVDBG2 is enabled, all server control blocks and all

								//     reference history blocks must be allocated from nonpaged pool,

								//     because SrvUpdateReferenceHistory touches these thing while

								//     holding a spin lock (i.e., at raised IRQL).  To make this easy,

								//     the ALLOCATE_HEAP and FREE_HEAP macros are modified to use

								//     nonpaged pool.  This means that ALL memory allocated by the

								//     server comes out of nonpaged pool when SRVDBG2 is on.

								//


								#if SRVDBG2


								#define ALLOCATE_HEAP(size,type) ALLOCATE_NONPAGED_POOL( (size), (type) )

								#define ALLOCATE_HEAP_COLD(size,type) ALLOCATE_NONPAGED_POOL( (size), (type) )

								#define FREE_HEAP(addr) DEALLOCATE_NONPAGED_POOL( (addr) )


								#else // SRVDBG2


								//

								// When POOL_TAGGING is on, we pass the block type through to

								// SrvAllocateNonPagedPool so that it can pass a tag to the pool

								// allocator.

								//


								#ifdef POOL_TAGGING

								#define ALLOCATE_HEAP(size,type) SrvAllocatePagedPool( PagedPool, (size), (type) )

								#define ALLOCATE_HEAP_COLD(size,type) SrvAllocatePagedPool( (PagedPool | POOL_COLD_ALLOCATION), (size), (type) )

								#else

								#define ALLOCATE_HEAP(size,type) SrvAllocatePagedPool( PagedPool, (size) )

								#define ALLOCATE_HEAP_COLD(size,type) SrvAllocatePagedPool( (PagedPool | POOL_COLD_ALLOCATION), (size) )

								#endif


								#define FREE_HEAP(addr) SrvFreePagedPool( (addr) )


								#endif // else SRVDBG2


								//

								// Routines that track server paged pool usage in order to support the

								// "maxpagedmemoryusage" configuration parameter.

								//


								PVOID SRVFASTCALL

								SrvAllocatePagedPool (

								    IN POOL_TYPE PoolType,

								    IN CLONG NumberOfBytes

								#ifdef POOL_TAGGING

								    ,IN CLONG BlockType

								#endif

								    );


								VOID SRVFASTCALL

								SrvFreePagedPool (

								    IN PVOID Address

								    );


								//

								// SHARE_TYPE is an enumerated type used to indicate what type of

								// resource is being shared.  This type corresponds to the server

								// table StrShareTypeNames.  Keep the two in sync.

								//


								typedef enum _SHARE_TYPE {

								    ShareTypeDisk,

								    ShareTypePrint,

								    ShareTypePipe,

								    ShareTypeWild   // not a real share type, but can be specified in tcon

								} SHARE_TYPE, *PSHARE_TYPE;


								//

								// SHARE_SNAPSHOT represents a snapshot availible for this share.

								//

								typedef struct _SHARE_SNAPSHOT

								{

								    LIST_ENTRY SnapShotList;

								    ULONG Flags;

								    HANDLE SnapShotRootDirectoryHandle;

								    LARGE_INTEGER Timestamp;

								    UNICODE_STRING SnapShotName;    // "[email protected]"

								    UNICODE_STRING SnapShotPath;

								} SHARE_SNAPSHOT, *PSHARE_SNAPSHOT;


								#define SNAPSHOT_NAME_LENGTH (strlen("@GMT-YYYY.MM.DD-HH.MM.SS")+1)*sizeof(WCHAR)

								#define SNAPSHOT_NAME_FORMAT L"@GMT-%04d.%02d.%02d-%02d.%02d.%02d"

								#define SRV_SNAP_SHARE_NOT_FOUND 1


								//

								// For each resource that the server shares, a Share Block is

								// maintained.  The global share list is anchored at SrvShareHashTable.  A

								// list of active tree connections using a resource is anchored in the

								// Share Block.

								//


								typedef struct _SHARE {

								    BLOCK_HEADER BlockHeader;   // must be first element


								    LIST_ENTRY TreeConnectList;

								    LIST_ENTRY GlobalShareList;


								    HANDLE RootDirectoryHandle;


								    UNICODE_STRING ShareName;

								    UNICODE_STRING NtPathName;

								    UNICODE_STRING DosPathName;

								    UNICODE_STRING Remark;


								    ULONG ShareNameHashValue;


								    union {

								        struct {

								            UNICODE_STRING Name;

								            OEM_STRING OemName;

								        } FileSystem;

								        HANDLE hPrinter;

								    } Type;


								    ULONG MaxUses;

								    ULONG CurrentUses;

								    ULONG CurrentRootHandleReferences;              // used for removable devices

								    LONG QueryNamePrefixLength;


								    PSECURITY_DESCRIPTOR SecurityDescriptor;        // for tree connects

								    PSECURITY_DESCRIPTOR FileSecurityDescriptor;    // file acls on shares


								    SHARE_TYPE ShareType;

								    BOOLEAN Removable;                              // Is the share storage removable?

								    BOOLEAN SpecialShare;

								    BOOLEAN IsDfs;                                  // Is this share in the Dfs?

								    BOOLEAN IsDfsRoot;                              // Is this share the root of a Dfs?

								    BOOLEAN PotentialSystemFile;                    // Are files in this share potentially

								                                                    //   system files?

								    BOOLEAN IsCatchShare;                           // Should the SRVCATCH code be active

								    BOOLEAN UniqueNames;                            // Are all names unique or are shortnames used?


								#ifdef INCLUDE_SMB_IFMODIFIED

								    BOOLEAN UsnCapable;                             // does this volume have a USN journal?

								#endif

								    //

								    // These flags are returned to the client on a tree connect to instruct the client

								    //  how it can cache the files on this share.  The server does not interpret these

								    //  flags -- it is the client's responsibility to do the right thing.

								    //

								    ULONG CSCState;


								#ifdef INCLUDE_SMB_PERSISTENT

								    BOOLEAN AllowPersistentHandles;                 // allow persistent handles on this volume?

								    PERSISTENT_INFO;                                // persistent info

								    PVOID   PersistentStateFile;

								#endif


								    PSRV_LOCK SecurityDescriptorLock;


								    LIST_ENTRY SnapShots;

								    PSRV_LOCK  SnapShotLock;


								    // WCHAR ShareNameData[ShareName.MaximumLength];

								    // WCHAR NtPathNameData[PathName.MaximumLength];

								    // WCHAR DosPathNameData[PathName.MaximumLength];

								    // SECURITY_DESCRIPTOR SecurityDescriptor;


								} SHARE, *PSHARE;


								//

								// For each network that the server uses, an Endpoint Block is

								// maintained.  An ENDPOINT contains the network name (for

								// administrative purposes), the endpoint name (server address), the

								// endpoint (file) handle, a pointer to the endpoint object, a pointer

								// to the transport provider's device object, and state information.

								// The global endpoint list is anchored at SrvEndpointList.  A list of

								// active connections created using an endpoint is anchored in the

								// Endpoint Block.

								//


								#if SRVDBG29

								#define HISTORY_LENGTH 256

								typedef struct {

								    ULONG Operation;

								    PVOID Connection;

								    BLOCK_HEADER ConnectionHeader;

								} HISTORY, *PHISTORY;

								#define UpdateConnectionHistory(_op,_endp,_conn) {                          \

								    PHISTORY history = &(_endp)->History[(_endp)->NextHistoryLocation++];   \

								    if ((_endp)->NextHistoryLocation >= HISTORY_LENGTH) {                   \

								        (_endp)->NextHistoryLocation = 0;                                   \

								    }                                                                       \

								    history->Operation = *(PULONG)(_op);                                    \

								    history->Connection = (_conn);                                          \

								    if (_conn) {                                                            \

								        history->ConnectionHeader = *(PBLOCK_HEADER)(_conn);                \

								    }                                                                       \

								}

								#endif


								struct _CONNECTION;


								typedef struct _ENDPOINT {

								    BLOCK_HEADER BlockHeader;   // must be first element


								    //

								    // List of free connections.

								    //


								    LIST_ENTRY FreeConnectionList;


								    //

								    // Table of connections.  We use a table instead of a list in order

								    // to speed up lookup of IPX connections based on the SID stored in

								    // the SMB header.

								    //


								    TABLE_HEADER ConnectionTable;


								    ORDERED_LIST_ENTRY GlobalEndpointListEntry;


								    //

								    // Handle and file/device objects for connection-oriented endpoint

								    // or for connectionless server data socket.

								    //


								    HANDLE EndpointHandle;

								    PFILE_OBJECT FileObject;

								    PDEVICE_OBJECT DeviceObject;

								    PULONG IpxMaxPacketSizeArray;

								    ULONG MaxAdapters;


								    //

								    // Handle and file/device objects for connectionless NetBIOS name

								    // socket.

								    //


								    HANDLE NameSocketHandle;

								    PFILE_OBJECT NameSocketFileObject;

								    PDEVICE_OBJECT NameSocketDeviceObject;


								    PDRIVER_DISPATCH FastTdiSend;

								    PDRIVER_DISPATCH FastTdiSendDatagram;


								    TDI_ADDRESS_IPX LocalAddress;


								    ULONG FreeConnectionCount;

								    ULONG TotalConnectionCount;


								    //

								    // Various flags

								    //

								    struct {

								        ULONG IsConnectionless  : 1;    // connectionless transport?

								        ULONG NameInConflict    : 1;    // unable to claim name?

								        ULONG IsPrimaryName     : 1;    // set if not an alternate name

								        ULONG IsNoNetBios       : 1;    // set if we are direct hosting on a VC

								        ULONG RemapPipeNames    : 1;    // set if we are remapping pipe names for clusters

								    };


								    WCHAR NetworkAddressData[12 + 1];


								    UNICODE_STRING NetworkName;         // administrative name

								    UNICODE_STRING TransportName;       // e.g., "\Device\Nbf_Elnkii01"

								    UNICODE_STRING ServerName;          // e.g., L"NTSERVER"

								    ANSI_STRING TransportAddress;       // e.g., "NTSERVER        "

								    UNICODE_STRING NetworkAddress;

								    UNICODE_STRING DomainName;          // domain being served by this endpoint

								    OEM_STRING     OemDomainName;       // oem version of domain name


								    // WCHAR NetworkNameData[NetworkName.MaximumLength/2];

								    // WCHAR TransportNameData[TransportName.MaximumLength/2];

								    // WCHAR ServerName[ ServerName.MaximumLength/2 ];

								    // CHAR TransportAddressData[TransportAddress.MaximumLength];

								    // WCHAR DomainNameData[ DNLEN + 1];

								    // CHAR  OemDomainNameData[ DNLEN+1 ]


								    BOOLEAN AlternateAddressFormat;     // should this endpoint be included when

								                                        // enumerating?

								#if SRVDBG29

								    ULONG NextHistoryLocation;

								    HISTORY History[HISTORY_LENGTH];

								#endif


								} ENDPOINT, *PENDPOINT;


								//

								// Size of search hash table (must be a power of 2)

								//


								#define SEARCH_HASH_TABLE_SIZE      4


								typedef struct _HASH_TABLE_ENTRY {


								    LIST_ENTRY ListHead;

								    BOOLEAN Dirty;


								} HASH_TABLE_ENTRY, *PHASH_TABLE_ENTRY;


								//

								// When we discover something which is a directory, we place the name

								//  in this per-connection cache for quick re-use for CheckPath.

								//

								typedef struct {

								    BLOCK_HEADER;

								    LIST_ENTRY      ListEntry;                  // list is linked through this element

								    UNICODE_STRING  DirectoryName;              // canonicalized name of this directory

								    USHORT          Tid;                        // DirectoryName is relative to this tid

								    ULONG           TimeStamp;                  // Tick count when this element was cached


								} CACHED_DIRECTORY, *PCACHED_DIRECTORY;


								//

								// For each connection (virtual circuit) that is created, a Connection

								// Block is maintained.  All connections made over a single endpoint are

								// linked through that endpoint.  Tables of sessions, tree connects, and

								// files created using a connection are anchored in the connection

								// block.

								//

								// The Lock field in the connection protects the data in the connection

								// and the data structures associated with the connection, such as

								// the tree connects and sessions.  However, the list of connections

								// linked off the endpoint is protected by the endpoint lock, and

								// LFCBs and RFCBs associated with a connection are protected by

								// the MFCB's lock.

								//


								typedef struct _PAGED_CONNECTION {


								    PAGED_HEADER PagedHeader;


								    //

								    // List of active transactions

								    //


								    LIST_ENTRY TransactionList;


								    //

								    // This list is maintained in order of access, so the entry at the top

								    // of the list is the oldest, the entry at the bottom is the youngest.

								    //


								    LIST_ENTRY CoreSearchList;


								    //

								    // This information is used to determine whether oplocks and Raw

								    // I/O's are allowed.  This is determined by information obtained by

								    // querying the transport provider using TDI_QUERY_CONNECTION_INFO.

								    //


								    LARGE_INTEGER LinkInfoValidTime;

								    LARGE_INTEGER Throughput;

								    LARGE_INTEGER Delay;


								    //

								    // Table headers for session, tree connect, and search tables.

								    //


								    TABLE_HEADER SessionTable;

								    TABLE_HEADER TreeConnectTable;

								    TABLE_HEADER SearchTable;


								    HANDLE ConnectionHandle;


								    //

								    // The number of sessions active on the connection.

								    //


								    USHORT CurrentNumberOfSessions;

								    USHORT CurrentNumberOfCoreSearches;


								    //

								    // Hash table for picking out duplicate core searches

								    //


								    HASH_TABLE_ENTRY SearchHashTable[SEARCH_HASH_TABLE_SIZE];


								    //

								    // A string for the client's name.  The Buffer field points to the

								    // leading slashes (below), the MaximumLength is

								    // (COMPUTER_NAME_LENGTH + 3) * sizeof(WCHAR), and Length is the

								    // number of characters in the name that are not blanks *

								    // sizeof(WHCAR).

								    //


								    UNICODE_STRING ClientMachineNameString;


								    //

								    // The following two fields make up the client's name in the form

								    // "\\client              ", including a trailing NULL.

								    //


								    WCHAR LeadingSlashes[2];

								    WCHAR ClientMachineName[COMPUTER_NAME_LENGTH+1];


								    //

								    // The encryption key obtained from LsaCallAuthenticationPackage.

								    // This is a per-VC value--any logon on a given VC uses this

								    // encryption key.

								    //


								    UCHAR EncryptionKey[MSV1_0_CHALLENGE_LENGTH];


								    //

								    // If we have an NT5 client, this is its build number (if non-zero)

								    //

								    ULONG ClientBuildNumber;


								    //

								    //  If the client has a persistent connection, here's the info for this

								    //  record in the state file.

								    //

								#ifdef INCLUDE_SMB_PERSISTENT

								    PERSISTENT_INFO;                                // persistent info

								#endif


								    //

								    // Have we logged an invalid SMB for this client yet?  We use this

								    //  flag to keep a single client from flooding the event log

								    //

								    BOOLEAN LoggedInvalidSmb;


								#if SRVNTVERCHK

								    //

								    // Have we determined that the client's NT build number is too old to

								    //  allow it to connect to this server?

								    //

								    BOOLEAN ClientTooOld;

								#endif


								} PAGED_CONNECTION, *PPAGED_CONNECTION;


								#define MAX_SAVED_RESPONSE_LENGTH 100


								typedef struct _CONNECTION {


								    QUEUEABLE_BLOCK_HEADER ;    // must be first element


								/* start of spin lock cache line */


								    //

								    // Per-connection spin lock.

								    //


								    KSPIN_LOCK SpinLock;


								    //

								    // Points to the endpoint spinlock that guards this connection's

								    // entry in the endpoint connection table.

								    //


								    PKSPIN_LOCK EndpointSpinLock;


								    //

								    // This is the WORK_QUEUE we are queueing on, which may not be the

								    //  same as PreferredWorkQueue due to load balancing

								    //

								    PWORK_QUEUE CurrentWorkQueue;


								    //

								    // A countdown for the number of operations we'll do before we try

								    //  to pick a better processor for this connection

								    //

								    ULONG BalanceCount;


								    //

								    // Cached Rfcb

								    //


								    struct _RFCB *CachedRfcb;

								    ULONG CachedFid;


								    //

								    // BreakIIToNoneJustSent is set when a oplock break II to none is

								    // sent, and reset whenever an SMB is received.  If a raw read

								    // arrives while this is set, the raw read is rejected.

								    //


								    BOOLEAN BreakIIToNoneJustSent;


								    //

								    // Raw io enabled

								    //


								    BOOLEAN EnableRawIo;


								    //

								    // Sid represents the connection's location in the endpoint's

								    // connection table.

								    //


								    USHORT Sid;


								    // The SidIndex allows us to use all the 16 bits for the index. For

								    // regular connections this prevents the aliasing problem that can occur

								    // in using the IXPSID index since the IPX sequence number takes up 4 bits


								    USHORT  SidIndex;


								    // additional USHORT to satisfy alignment on dword boundaries

								    USHORT  Pad;


								    //

								    // Pointer to the endpoint, fileobject, and deviceobject

								    //


								    PENDPOINT Endpoint;

								    PFILE_OBJECT FileObject;


								    PDEVICE_OBJECT DeviceObject;


								    //

								    // The maximum message size we can send over this connection.

								    //


								    ULONG   MaximumSendSize;


								    //

								    // This is the WORK_QUEUE we would prefer to be on, because this

								    //  queue assigns work to the same procesor that is handling the

								    //  adaptor's DPCs

								    //


								    PWORK_QUEUE PreferredWorkQueue;


								    //

								    // Table header for file table.

								    //


								    TABLE_HEADER FileTable;


								    //

								    // The SMB dialect chosen for this connection.  Used in fsd.

								    //


								    SMB_DIALECT SmbDialect;


								    //

								    // List of active work items associated with the connection.

								    //


								    LIST_ENTRY InProgressWorkItemList;


								    //

								    // Stores the time of the last oplock break resp processed.  This is

								    // used to synchronize readraw processing with the oplock break

								    // processing.

								    //


								    ULONG LatestOplockBreakResponse;


								    //

								    // The following two fields descibe operations in progress on this

								    // connection.  It is possible that there are multiple oplock breaks

								    // in progress.  Also, there is a brief window when multiple raw

								    // reads can be active -- after we've sent the response to one raw

								    // read, but before we've done postprocessing (so it looks like the

								    // first one is still in progress), we could receive another raw

								    // read request.

								    //

								    // Interaction between the two fields are controlled using

								    // SrvFsdSpinLock (see the block comment in oplock.c for details).

								    //


								    LONG OplockBreaksInProgress;

								    ULONG RawReadsInProgress;


								    //

								    // Are oplocks allowed?

								    //


								    BOOLEAN OplocksAlwaysDisabled;

								    BOOLEAN EnableOplocks;


								    //

								    // Is the client coming in over IPX?

								    //

								    BOOLEAN DirectHostIpx;


								    //

								    // Are security signatures currently active for this connection?

								    //  Security signatures are not supported for Direct Host IPX connections

								    //  and some W9x clients

								    //

								    BOOLEAN SmbSecuritySignatureActive;


								    union {

								        //

								        //  The following struct of this union holds relevant state

								        //   when the client is connecting over direct host IPX.

								        //   IpxAddress holds the client's IPX address, when the client

								        //   'connects' over IPX.

								        //

								        struct {

								            USHORT SequenceNumber;

								            USHORT LastResponseLength;

								            USHORT LastResponseBufferLength;

								            USHORT LastUid;

								            USHORT LastTid;

								            NTSTATUS LastResponseStatus;

								            ULONG IpxDuplicateCount;

								            ULONG IpxDropDuplicateCount;

								            ULONG StartupTime;

								            TDI_ADDRESS_IPX IpxAddress;

								            PVOID LastResponse;

								        };


								        //

								        // This struct holds relevant state when the client is using

								        //  a virtual circuit.

								        //

								        struct {


								            //

								            // The following fields are used for security signatures.

								            //

								            MD5_CTX Md5Context;


								            ULONG SmbSecuritySignatureIndex;


								            // If we are unable to allocate a WORK_CONTEXT

								            // at receive indicate time, the receive is done

								            // in SrvFsdServiceNeedResourceQueue.  Depending

								            // on the received SMB, we sometimes do not send

								            // a response SMB.  Since the Tdi lookahead data

								            // is not available when SrvFsdServiceNeedResourceQueue

								            // is run, we have to remember not to advance the signature

								            // index for the response.


								            BOOLEAN NoResponseSignatureIndex;


								            //

								            // The following field, if non-zero is the IP address of the client

								            //

								            ULONG ClientIPAddress;


								        };

								    };


								    //

								    // Pointer to paged part of connection block.

								    //


								    PPAGED_CONNECTION PagedConnection;


								    //

								    // Per-connection interlock.

								    //


								    KSPIN_LOCK Interlock;


								    //

								    // Quadword align list entries and large ints

								    //


								    LIST_ENTRY EndpointFreeListEntry;


								    //

								    // A list of deferred oplock work break items.  Oplock breaks are

								    // deferred if a read raw is in progress, or if the server runs

								    // out of work context blocks, and cannot send the oplock break

								    // request.

								    //


								    LIST_ENTRY OplockWorkList;


								    //

								    // List of RFCBs with batch oplocks that have been cached after

								    // being closed by the client.  Count of such RFCBs.

								    //


								    LIST_ENTRY CachedOpenList;

								    ULONG CachedOpenCount;


								    //

								    // List of directories which have been recently identified.  This is a list of

								    //  CACHED_DIRECTORY entries.

								    //

								    LIST_ENTRY CachedDirectoryList;

								    ULONG      CachedDirectoryCount;


								    //

								    // Security context handle for the extensible security negotiate buffer.

								    //


								    CtxtHandle NegotiateHandle;


								    //

								    // The following represent consumer capabilities.

								    //


								    ULONG ClientCapabilities;


								    //

								    // Per-connection resource.

								    //


								    SRV_LOCK Lock;


								    //

								    // Lock for dealing with the license server

								    //


								    SRV_LOCK LicenseLock;


								    //

								    // Oem version of the client machine name string.

								    //


								    OEM_STRING OemClientMachineNameString;


								    //

								    // Head of singly linked list of cached transactions.

								    //


								    SLIST_HEADER CachedTransactionList;

								    LONG CachedTransactionCount;


								    //

								    // The time when the last message was received for this connection

								    //

								    ULONG LastRequestTime;


								    //

								    // If we are on the OnNeedResourceQueue for a pending recieve, this

								    //  is the amount of data that was indicated to us.

								    //

								    ULONG BytesAvailable;


								    //

								    // OnNeedResource is true if this connection is on the global need

								    // recource queue.  This happens if it is waiting for a work context

								    // block to complete a pending receive or an oplock break request.

								    //


								    BOOLEAN OnNeedResourceQueue;


								    //

								    // NotReusable is set when an operation fails in such a way that the

								    // server's idea of the connection state may be different than the

								    // transport's.  For example, a server-initiated disconnect failed.

								    // If we tried to reuse the connection (by returning it from a

								    // connect indication), the transport would get confused.  When

								    // NotReusable is set, SrvDereferenceConnection frees the connection

								    // instead of putting it on the endpoint's free list.

								    //


								    BOOLEAN NotReusable;


								    //

								    // DisconnectPending indicates that a disconect indication has been

								    // received from the transport.  ReceivePending indicates that the

								    // server could not assign a work item to handle a receive indication.

								    //


								    BOOLEAN DisconnectPending;

								    BOOLEAN ReceivePending;


								    //

								    // Oem version of the client name.  We need this because we could

								    // not do unicode operations in the fsd, where we initially get our

								    // computer name.

								    //


								    CHAR OemClientMachineName[COMPUTER_NAME_LENGTH+1];


								    //

								    // Information about the client context.

								    //


								    UNICODE_STRING ClientOSType;

								    UNICODE_STRING ClientLanManType;


								    UCHAR BuiltinSavedResponse[MAX_SAVED_RESPONSE_LENGTH];


								    // Used to monitor how many work contexts a client is using up

								    LONG InProgressWorkContextCount;

								    LONG OperationsPendingOnTransport;

								    BOOLEAN IsConnectionSuspect;

								    DISCONNECT_REASON DisconnectReason;


								} CONNECTION, *PCONNECTION;


								//

								// For each session that is created, a Session Block is maintained.  All

								// sessions created over a single connection are linked through a table

								// owned by that connection.  A list of files opened using a session can

								// be obtained by searching the file table owned by the connection

								// block.

								//


								// This is copied from ntmsv1_0.h


								#define MSV1_0_USER_SESSION_KEY_LENGTH 16


								typedef struct _SESSION {

								    //

								    // *** NOTE:  The reference count field in the session block

								    //            header is not used!  Instead, the reference count is

								    //            in the NonpagedHeader structure.

								    //


								    BLOCK_HEADER BlockHeader;


								    PNONPAGED_HEADER NonpagedHeader;


								    ULONG CurrentFileOpenCount;          // count of files open on the session

								    ULONG CurrentSearchOpenCount;        // count of searches open on the session


								    ORDERED_LIST_ENTRY GlobalSessionListEntry;


								    PCONNECTION Connection;


								    //

								    // If clients are using the GSS-style authentication, we query the

								    //  UserHandle for the user and domain names.  If they are using

								    //  old-style authentication, we store the names here.  In any case,

								    //  code that needs access to the user and/or domain names should

								    //  call SrvGetUserAndDomainName() and SrvReleaseUserAndDomainName()

								    //

								    UNICODE_STRING NtUserName;

								    UNICODE_STRING NtUserDomain;


								    LARGE_INTEGER StartTime;

								    LARGE_INTEGER LastUseTime;           // for autologoff

								    LARGE_INTEGER LogOffTime;            // for forced logoff

								    LARGE_INTEGER KickOffTime;           // for forced logoff

								    LARGE_INTEGER LastExpirationMessage; // for forced logoff


								    LUID LogonId;

								    CHAR NtUserSessionKey[MSV1_0_USER_SESSION_KEY_LENGTH];

								    CHAR LanManSessionKey[MSV1_0_LANMAN_SESSION_KEY_LENGTH];


								    CtxtHandle UserHandle;               // Security handle to this user


								    USHORT MaxBufferSize;                // Consumer's maximum buffer size

								    USHORT MaxMpxCount;                  // Actual max multiplexed pending requests

								    USHORT Uid;


								    BOOLEAN UsingUppercasePaths;         // Must paths be uppercased?

								    BOOLEAN GuestLogon;                  // Is the client logged on as a guest?

								    BOOLEAN EncryptedLogon;              // Was an encrypted password sent?

								    BOOLEAN LogoffAlertSent;

								    BOOLEAN TwoMinuteWarningSent;

								    BOOLEAN FiveMinuteWarningSent;

								    BOOLEAN IsNullSession;               // Is client using a null session?

								    BOOLEAN IsAdmin;                     // Is this an administrative user?

								    BOOLEAN IsLSNotified;                // Does license server know about this user?

								    BOOLEAN LogonSequenceInProgress;     // Are we in the middle of an extended logon sequence?

								    BOOLEAN IsSessionExpired;            // Do we need to reauthenticate?

								    HANDLE  hLicense;                    // if( IsLSNotified ) this is License handle


								    //

								    //  If the client has a persistent connection, here's the info for this

								    //  record in the state file.

								    //

								#ifdef INCLUDE_SMB_PERSISTENT

								    PERSISTENT_INFO;                                // persistent info

								#endif


								#if SRVNTVERCHK

								    //

								    // Have we determined that we don't like this client's domain?

								    //

								    BOOLEAN ClientBadDomain;

								#endif


								    //CHAR UserNameBuffer[UserName.MaximumLength];


								} SESSION, *PSESSION;


								//

								// For each tree connect that is made, a Tree Connect Block is

								// maintained.  All tree connects made over a single connection are

								// linked through a table owned by that connection.  All tree connects

								// made to a single shared resource are linked through that share block.

								// A list of files opened using a tree connect can be obtained by

								// searching the file table owned by the connection block.

								//


								typedef struct _TREE_CONNECT {

								    //

								    // *** NOTE:  The reference count field in the tree connect block

								    //            header is not used!  Instead, the reference count is

								    //            in the NonpagedHeader structure.

								    //


								    BLOCK_HEADER BlockHeader;


								    PNONPAGED_HEADER NonpagedHeader;


								    PCONNECTION Connection;

								    PSESSION Session;

								    PSHARE Share;


								    ORDERED_LIST_ENTRY GlobalTreeConnectListEntry;


								    ULONG CurrentFileOpenCount;


								    LIST_ENTRY ShareListEntry;

								    LIST_ENTRY PrintFileList;                // only if print share


								    LARGE_INTEGER StartTime;


								    UNICODE_STRING ServerName;


								    BOOLEAN RemapPipeNames;


								    USHORT Tid;


								} TREE_CONNECT, *PTREE_CONNECT;


								//

								// Master File Control Block (MFCB) -- one per named file that is open

								//      at least once.  Used to support compatibility mode and oplocks.

								//

								// Local File Control Block (LFCB) -- one for each local open instance.

								//      Represents local file object/handle.  There may be multiple

								//      LFCBs linked to a single MFCB.

								//

								// Remote File Control Block (RFCB) -- one for each remote open instance.

								//      Represents remote FID.  There is usually one RFCB per LFCB, but

								//      multiple compatibility mode RFCBs may be linked to a single LFCB.

								//      Multiple remote FCB opens for a single file from a single session

								//      are folded into one RFCB, because old DOS redirectors only send

								//      one close.

								//


								//

								// For each disk file that is open, a Master File Control Block (MFCB)

								// is maintained.  If a given file is open multiple times, there is one

								// MFCB for the file and multiple LFCBs, one for each local open

								// instance.  All MFCBs are linked into the global Master File Table.

								// The MFCB has a list of the LFCBs representing open instances for the

								// file.

								//


								typedef struct _NONPAGED_MFCB {


								    union {


								        //

								        // When NONPAGED_MFCB structures are freed, they may be placed

								        // on the WORK_QUEUE's MfcbFreeList to avoid unnecessary Nonpaged

								        // pool activity.  SingleListEntry is used for the linkage.

								        //


								        SINGLE_LIST_ENTRY SingleListEntry;


								        struct {

								            ULONG Type;

								            PVOID PagedBlock;


								            //

								            // We must serialize opens to the same file, since 2 concurrent opens

								            // may be compatibility mode opens.  This lock also protects all data

								            // in this MFCB and the LFCBs and RFCBs associated with this MFCB.

								            //


								            SRV_LOCK Lock;

								        };

								    };


								    LARGE_INTEGER OpenFileSize;

								    ULONG OpenFileAttributes;


								} NONPAGED_MFCB, *PNONPAGED_MFCB;


								typedef struct _MFCB {


								    //

								    // *** NOTE:  The reference count field in the mfcb block

								    //            header is not used!  Instead, the reference count is

								    //            in the NonpagedHeader structure.

								    //


								    BLOCK_HEADER BlockHeader;   // must be first element


								    PNONPAGED_MFCB NonpagedMfcb;


								    //

								    // All LFCBs for a given named file are linked to the parent MFCB.

								    //


								    LIST_ENTRY LfcbList;


								    //

								    // The count of active RFCB for this MFCB.  This is used to coordinate

								    // compatibility opens with non-compatibility mode opens.

								    //


								    ULONG ActiveRfcbCount;


								    //

								    // The fully qualified name of the file is appended to the MFCB.

								    // The FileName field is a descriptor for the name.

								    //

								    UNICODE_STRING FileName;


								    //

								    // Mfcbs are linked into the MfcbHashTable by MfcbHashTableEntry

								    //

								    LIST_ENTRY MfcbHashTableEntry;


								    //

								    // FileNameHashValue is a hash value derived from the upper case

								    //  version of FileName.  It is used to speed up name comparisons, and to

								    //  locate the hash entry

								    //

								    ULONG FileNameHashValue;


								    //

								    // CompatibilityOpen indicates whether the file is open in

								    // compatibility mode.

								    //

								    BOOLEAN CompatibilityOpen;


								    //

								    // Timestamp for SnapShot opens

								    //

								    LARGE_INTEGER SnapShotTime;


								#if SRVCATCH

								    BOOLEAN SrvCatch;

								#endif


								    // WCHAR FileNameData[FileName.MaximumLength/2];


								} MFCB, *PMFCB;


								//

								// The MFCBs are all linked into the master MFCB hash table.

								//

								typedef struct {

								    LIST_ENTRY  List;           // the list of MFCBs in this bucket

								    PSRV_LOCK   Lock;           // protects this bucket's list

								} MFCBHASH, *PMFCBHASH;


								//

								// For each instance of a local file open, a Local File Control Block

								// (LFCB) is maintained.  All LFCBs for a particular named file are

								// linked through the MFCB for that file.

								//

								// LFCBs contain information that is specific to the local open, such

								// as the file handle and a pointer to the file object.  The LFCB also

								// contains other information that is common to all child RFCBs, such

								// as pointers to the owning connection and tree connect.

								//

								//


								typedef struct _LFCB {


								    union {

								        BLOCK_HEADER BlockHeader;           // must be first element

								        SINGLE_LIST_ENTRY SingleListEntry;  // used when LFCB is freed

								    };


								    //

								    // Multiple remote opens of a file are folded into a single local

								    // open by linking the RFCBs to the parent LFCB.

								    //


								    LIST_ENTRY RfcbList;


								    //

								    // The number of associated active RFCBs.

								    //


								    ULONG HandleCount;


								    //

								    // LFCBs are linked into their MFCB's open file list.

								    //


								    PMFCB Mfcb;

								    LIST_ENTRY MfcbListEntry;


								    //

								    // Connection, Session, and TreeConnect are referenced pointers to

								    // the respective "owning" blocks.

								    //


								    PCONNECTION Connection;

								    PSESSION Session;

								    PTREE_CONNECT TreeConnect;


								    //

								    // GrantedAccess is the access obtained when the file was opened.

								    // For a compatibility mode open, this is the maximum access

								    // available to the client; individual opens may have less access.

								    //


								    ACCESS_MASK GrantedAccess;


								    //

								    // FileHandle is a handle to the open file.  FileObject is a

								    // referenced pointer.  DeviceObject is NOT a referenced pointer;

								    // the reference to the file object prevents the device object from

								    // going away.

								    //


								    HANDLE FileHandle;

								    PFILE_OBJECT FileObject;

								    PDEVICE_OBJECT DeviceObject;


								    //

								    // FileMode tracks whether writethrough is enabled for this file

								    // object.


								    ULONG FileMode;


								    //

								    // The job ID of a print job corresponding to the opened file.

								    // This is only used for print file opens.

								    //


								    ULONG JobId;


								    //

								    // Cache these hot-path entry points.

								    //


								    PFAST_IO_READ FastIoRead;

								    PFAST_IO_WRITE FastIoWrite;

								    PFAST_IO_LOCK FastIoLock;

								    PFAST_IO_UNLOCK_SINGLE FastIoUnlockSingle;

								    PFAST_IO_MDL_READ MdlRead;

								    PFAST_IO_MDL_READ_COMPLETE MdlReadComplete;

								    PFAST_IO_PREPARE_MDL_WRITE PrepareMdlWrite;

								    PFAST_IO_MDL_WRITE_COMPLETE MdlWriteComplete;

								    PFAST_IO_READ_COMPRESSED FastIoReadCompressed;

								    PFAST_IO_WRITE_COMPRESSED FastIoWriteCompressed;

								    PFAST_IO_MDL_READ_COMPLETE_COMPRESSED MdlReadCompleteCompressed;

								    PFAST_IO_MDL_WRITE_COMPLETE_COMPRESSED MdlWriteCompleteCompressed;


								    //

								    // CompatibilityOpen indicates whether the file is open in

								    // compatibility mode.

								    //


								    BOOLEAN CompatibilityOpen;


								    //

								    //  Has this file been modified by any clients?  Used to determine when

								    //  we should write out USN close records on file close.

								    //


								#ifdef INCLUDE_SMB_IFMODIFIED

								    BOOLEAN FileUpdated;

								#endif


								} LFCB, *PLFCB;


								//

								// For each instance of a remote file open, a Remote File Control Block

								// (RFCB) is maintained.  The RFCB points to the LFCB that contains the

								// local file handle.  Normally RFCBs and LFCBs exist in one-to-one

								// correspondence, but multiple compatibility mode opens are folded into

								// a single local open, so that the server can enforce the appropriate

								// sharing rules.

								//

								// RFCBs contain information that is specific to the remote open, such

								// as the assigned FID, the PID of the creator, the granted access mask,

								// and the current file position.

								//

								// All RFCBs for a single connection are linked through a table owned by

								// that connection; the FID assigned to the RFCB represents an index

								// into the file table.  Pointers to the owning connection and tree

								// connect can be found in the LFCB, which is pointed to by the RFCB.  A

								// list of files opened through a given tree connect can be obtained by

								// searching the owning connection's file table for RFCBs whose parent

								// LFCBs point to the tree connect.

								//


								#ifdef SLMDBG


								#define SLMDBG_CLOSE 1

								#define SLMDBG_RENAME 2


								#define SLMDBG_TRACE_COUNT 32

								#define SLMDBG_TRACE_DATA  32


								typedef struct _RFCB_TRACE {

								    UCHAR Command;

								    UCHAR Flags;

								    TIME Time;

								    union {

								        struct {

								            ULONG Offset;

								            ULONG Length;

								        } ReadWrite;

								        struct {

								            ULONG Offset;

								            ULONG Length;

								        } LockUnlock;

								    } Data;

								} RFCB_TRACE, *PRFCB_TRACE;


								#endif


								//

								// WRITE_MPX_CONTEXT holds context associated with an active Write Block

								// Multiplexed sequence.

								//

								// !!! This structure is probably big enough to be worth putting

								//     outside the RFCB.

								//


								#define MAX_GLOM_RUN_COUNT 8


								typedef struct _WRITE_MPX_RUN {

								    USHORT Offset;

								    USHORT Length;

								} WRITE_MPX_RUN, *PWRITE_MPX_RUN;


								typedef struct _WRITE_MPX_CONTEXT {


								    //

								    // ReferenceCount counts the number of Write Mpx SMBs that are

								    // currently being processed.  When this count goes to zero, and

								    // we have received the sequenced command that ends the current

								    // mux, we send the response.  This method is needed to ensure

								    // that we don't process the mux SMBs out-of-order, which leads

								    // to performance problems, and even worse, data corruption,

								    // thanks to the mask-shifting method used by the Snowball redir.

								    //


								    ULONG ReferenceCount;


								    //

								    // Mask holds the logical OR of the masks received in multiplexed

								    // write requests.  When an IPX client sends the last block of write

								    // mpx data, we send back MpxMask to indicate whether we lost any

								    // frames.

								    //


								    ULONG Mask;


								    //

								    // FileObject is a copy of the file object pointer from the LFCB.

								    //


								    PFILE_OBJECT FileObject;


								    //

								    // Mid holds the MID of the current multiplexed write.  PreviousMid

								    // hold the MID of the previous one.  This needs to be retained in

								    // order to deal with duplicated write mux SMBs -- if a duplicate

								    // SMB arrives AFTER the first SMB of the next write mux (with a new

								    // MID), we need to know to toss it, not kill the new write mux.

								    //


								    USHORT Mid;

								    USHORT PreviousMid;


								    //

								    // SequenceNumber holds the sequence number given in the last

								    // request of the mux.  This needs to be retained because we

								    // may be simultaneously processing previous parts of the mux

								    // when we detect that we've received the sequenced comand.

								    //


								    USHORT SequenceNumber;


								    //

								    // Glomming is set if the current write mux series is being glommed

								    // into one large write.

								    //

								    // GlomPending is set when the indication for the first packet of

								    // a new write mux occurs.  It is cleared when the FSP is done

								    // preparing the glomming operation.  While GlomPending is set,

								    // subsequent packets of the write mux are queued to GlomDelayList.

								    //


								    BOOLEAN Glomming;

								    BOOLEAN GlomPending;

								    LIST_ENTRY GlomDelayList;


								    ULONG StartOffset;

								    USHORT Length;

								    BOOLEAN GlomComplete;


								    //

								    // MpxGlommingAllowed is set when the underlying file system

								    // supports MDL write.

								    //


								    BOOLEAN MpxGlommingAllowed;


								    PMDL MdlChain;


								    ULONG NumberOfRuns;

								    WRITE_MPX_RUN RunList[MAX_GLOM_RUN_COUNT];


								} WRITE_MPX_CONTEXT, *PWRITE_MPX_CONTEXT;


								#define NO_OPLOCK_BREAK_IN_PROGRESS     ((UCHAR)-1)


								typedef struct _PAGED_RFCB {


								    PAGED_HEADER PagedHeader;


								    //

								    // RFCBs are linked into their parent LFCB's compatibility open

								    // list.

								    //


								    LIST_ENTRY LfcbListEntry;


								    //

								    // Information about the last lock attempt by the client that failed.

								    //


								    LARGE_INTEGER LastFailingLockOffset;


								    //

								    // Current oplock break timeout.

								    //


								    LARGE_INTEGER OplockBreakTimeoutTime;


								    //

								    // FcbOpenCount indicates how many remote FCB opens this RFCB

								    // represents.  (Whether an RFCB represents a compatibility mode

								    // open can be determined by looking at the LFCB.)

								    //

								    // *** Note that FCB opens are treated similarly to compatibility

								    //     mode opens.  However, soft compatibility maps compatibility

								    //     opens into regular opens, but it does not change an FCB open

								    //     into a non-FCB open.  So it is possible to have an FCB open

								    //     that is not a compatibility mode open.

								    //


								    CLONG FcbOpenCount;


								    //

								    // Per-file context for a direct host IPX smart card, if we have one.

								    //  The smart card is willing to handle the read operations for this file if

								    //  IpxSmartCardContext is not NULL.

								    //

								    PVOID   IpxSmartCardContext;


								    //

								    //  list of outstanding byte locks we have for this RFCB

								    //


								#ifdef INCLUDE_SMB_PERSISTENT

								    LIST_ENTRY ByteRangeLocks;


								    //

								    //  If the client has a persistent connection, here's the info for this

								    //  record in the state file.

								    //

								    PERSISTENT_INFO;                                // persistent info

								#endif


								} PAGED_RFCB, *PPAGED_RFCB;


								typedef struct _RFCB {


								    //

								    // The list entry in the RFCB's block header is used to queue the

								    // RFCB for oplock processing to the nonblocking worker thread work

								    // queue, which also contains work context blocks.

								    //

								    // *** Note that this is an unnamed field, so that its elements can

								    //     can be referenced directly.  The field names defined in

								    //     QUEUEABLE_BLOCK_HEADER cannot be used elsewhere in this

								    //     block.

								    //


								    QUEUEABLE_BLOCK_HEADER ;   // must be first element


								/* start of spin lock cache line */


								    //

								    // These booleans indicate whether we've already been granted

								    // read/write/lock access, thus saving a few instructions on every

								    // read/write/lock.  These are checked during the file open.

								    //


								    BOOLEAN ReadAccessGranted;   // TRUE, if read access in granted

								    BOOLEAN WriteAccessGranted;  // TRUE, if write access is granted

								    BOOLEAN LockAccessGranted;   // TRUE, if lock access is granted

								    BOOLEAN UnlockAccessGranted; // TRUE, if unlock access is granted

								    BOOLEAN AppendAccessGranted; // TRUE, if append access is granted


								    //

								    // CurrentPosition maintains the file position after the last Read,

								    // Write, or Seek by the client.  This field is needed only to

								    // support relative Seeks.  Since clients that use relative seeks only

								    // need 32-bits of file position, this field is maintained as a ULONG.

								    //


								    ULONG CurrentPosition;


								    //

								    // Type of this share.  Accessed in the fsd.

								    //


								    SHARE_TYPE ShareType;


								    //

								    // The connection pointer is copied from the LFCB so that we can

								    // find the connection at DPC level (the LFCB is paged, as is the

								    // pointer to the LFCB in PagedRfcb).

								    //


								    PCONNECTION Connection;


								    //

								    // The LFCB is used to find the file handle, file object, etc.

								    //


								    PLFCB Lfcb;


								    //

								    // MpxGlommingAllowed is set when the underlying file system

								    // supports MDL write.

								    //


								    BOOLEAN MpxGlommingAllowed;


								    //

								    // The following two booleans describe the read mode, and blocking

								    // mode of a named pipe.

								    //


								    BOOLEAN BlockingModePipe;  // TRUE = Blocking, FALSE = Nonblocking

								    BOOLEAN ByteModePipe;      // TRUE = Byte mode, FALSE = Message mode


								    //

								    // Indicates whether this file has been written to.

								    //


								    BOOLEAN WrittenTo;


								/* end of spin lock cache line */


								    //

								    // RawWriteSerializationList holds works items that have been queued

								    // pending completion of a raw write.  When the raw write count is

								    // decremented to 0, this list is flushed by restarting all queued

								    // work items.

								    //


								    LIST_ENTRY RawWriteSerializationList;


								    //

								    // fid << 16.  Used for key computations.

								    //


								    ULONG ShiftedFid;


								    //

								    // RawWriteCount counts the number of active raw writes.  This is

								    // used to prevent the file handle from being closed while raw

								    // writes are in progress.  If Raw writes are in progress when the

								    // close happens, we defer the cleanup until the rawwritecount goes

								    // to zero.

								    //


								    ULONG RawWriteCount;


								    //

								    // SavedError retains the error code when a raw read or a raw write

								    // in writebehind mode gets an error.  The next access to the file

								    // will receive an error indication.

								    //


								    NTSTATUS SavedError;


								    //

								    // NumberOfLocks is the count of locks currently on the file.

								    // It is here to support the File APis and RFCB cacheing -- you can't

								    //   cache an RFCB if it has locks in it.

								    //


								    LONG NumberOfLocks;


								    //

								    // Fid is the file ID assigned to the file and returned to the

								    // client.  Pid is the process ID given by the client when the file

								    // was opened.  Tid is a copy of the parent tree connect's Tid

								    // field.  Uid is used to ensure that the client using a file handle

								    // is the same one that opened the file.

								    //


								    USHORT Fid;

								    USHORT Pid;

								    USHORT Tid;

								    USHORT Uid;


								    //

								    // WriteMpx is a WRITE_MPX_CONTEXT structure.  It retains context

								    // about multiplexed write operations.  This structure is not used

								    // on connectionless sessions.

								    //


								    WRITE_MPX_CONTEXT WriteMpx;


								    //

								    // FileMode tracks whether writethrough is enabled for this file

								    // object.


								    ULONG FileMode;


								    //

								    // MFCB points to the Master File Control Block for this file.

								    //


								    PMFCB Mfcb;


								    //

								    // Oplock information.  The oplock IRP currently in progress, etc.

								    // The list entry for queueing the RFCB for oplock break processing

								    // is located in the block header.

								    //


								    PIRP Irp;

								    BOOLEAN OnOplockBreaksInProgressList;


								    //

								    // The oplock level to change to, if there is an oplock break

								    // in progress.  Otherwise it is always NO_OPLOCK_BREAK_IN_PROGRESS.

								    //


								    UCHAR NewOplockLevel;


								    //

								    // This boolean indicates whether or an oplock granted open response

								    // need to be sent for this RFCB.  If it is FALSE, and an oplock break

								    // request needs to be sent, the request must be deferred until after

								    // sending the open response.

								    //

								    // Access to these fields is synchronized using the MFCB lock.

								    //


								    BOOLEAN OpenResponseSent;

								    BOOLEAN DeferredOplockBreak;


								    //

								    // Pointer to the paged portion of the rfcb

								    //


								    PPAGED_RFCB PagedRfcb;


								    //

								    // CachedOpen is set if the RFCB has been cached after being

								    // closed by the client.

								    //


								    LIST_ENTRY CachedOpenListEntry;

								    BOOLEAN CachedOpen;


								    //

								    // See if this rfcb can be cached.

								    //


								    BOOLEAN IsCacheable;


								    //

								    // See if the file was accessed in the last scavenger update period.

								    // (This is used to update the session last access time).

								    //


								    BOOLEAN IsActive;


								    //

								    // Is it ok for us to do MPX writes to this RFCB?

								    //

								    BOOLEAN MpxWritesOk;


								    //

								    // Is this file a persistent handle?

								    //

								#ifdef INCLUDE_SMB_PERSISTENT

								    BOOLEAN PersistentHandle;

								#endif


								    //

								    //  This event is used when the server needs to request an oplock II

								    //  when the initial oplock request fails.

								    //


								    PKEVENT RetryOplockRequest;


								    //

								    // All RFCBs in the server are stored in a global list to support

								    // NetFileEnum.  This field contains the LIST_ENTRY for the RFCB in

								    // the global list and a resume handle to support resuming

								    // enumerations.

								    //


								    ORDERED_LIST_ENTRY GlobalRfcbListEntry;


								    //

								    // GrantedAccess is the access allowed through this open.  This

								    // GrantedAccess may allow less access than that given in the parent

								    // LFCB for compatibility mode opens.

								    //


								    ACCESS_MASK GrantedAccess;


								    //

								    // ShareAccess is the file sharing access specified when the file

								    // was opened.

								    //


								    ULONG ShareAccess;


								    //

								    // Current oplock state.

								    //


								    OPLOCK_STATE OplockState;


								    //

								    // Is it ok for us to do MPX reads to this RFCB?

								    //

								    BOOLEAN MpxReadsOk;

								#ifdef SRVCATCH

								    BOOLEAN SrvCatch;

								#endif


								#ifdef SRVDBG_RFCBHIST

								    UCHAR HistoryIndex;

								    ULONG History[256];

								#endif


								#ifdef SLMDBG

								    ULONG NextTrace;

								    ULONG TraceWrapped;

								    ULONG WriteCount;

								    ULONG OperationCount;

								    RFCB_TRACE Trace[SLMDBG_TRACE_COUNT];

								#endif


								} RFCB, *PRFCB;


								#ifdef SRVDBG_RFCBHIST

								VOID UpdateRfcbHistory( PRFCB Rfcb, ULONG Event );

								#else

								#define UpdateRfcbHistory(_rfcb,_event)

								#endif


								#ifdef INCLUDE_SMB_PERSISTENT

								typedef struct _BYTELOCK {


								    BLOCK_HEADER BlockHeader;


								    //

								    // Locks are linked into their parent RFCB's open list.

								    //


								    LIST_ENTRY RfcbListEntry;


								    PRFCB   Rfcb;


								    //

								    // Information about the lock.

								    //


								    LARGE_INTEGER LockOffset;

								    LARGE_INTEGER LockLength;


								    BOOLEAN Exclusive;


								    //

								    //  If the client has a persistent connection, here's the info for this

								    //  record in the state file.

								    //

								    PERSISTENT_INFO;                                // persistent info


								} BYTELOCK, *PBYTELOCK;

								#endif


								#ifdef SLMDBG


								NTSTATUS

								SrvValidateSlmStatus (

								    IN HANDLE StatusFile,

								    IN struct _WORK_CONTEXT *WorkContext,

								    OUT PULONG FileOffsetOfInvalidData

								    );


								VOID

								SrvReportCorruptSlmStatus (

								    IN PUNICODE_STRING StatusFile,

								    IN NTSTATUS Status,

								    IN ULONG Offset,

								    IN ULONG Operation,

								    IN PSESSION Session

								    );


								VOID

								SrvReportSlmStatusOperations (

								    IN PRFCB Rfcb,

								    IN BOOLEAN Force

								    );


								VOID

								SrvDisallowSlmAccess (

								    IN PUNICODE_STRING StatusFile,

								    IN HANDLE RootDirectory

								    );


								VOID

								SrvDisallowSlmAccessA (

								    IN PANSI_STRING StatusFile,

								    IN HANDLE RootDirectory

								    );


								BOOLEAN

								SrvIsSlmAccessDisallowed (

								    IN PUNICODE_STRING StatusFile,

								    IN HANDLE RootDirectory

								    );


								BOOLEAN

								SrvIsSlmStatus (

								    IN PUNICODE_STRING StatusFile

								    );


								BOOLEAN

								SrvIsTempSlmStatus (

								    IN PUNICODE_STRING StatusFile

								    );


								#endif


								//

								// Each incoming (request) and outgoing (response) buffer is represented

								// by a BUFFER structure.  This descriptor describes the size of the

								// buffer, its address, and a full and partial MDL that may be used

								// to describe the buffer.

								//

								// *** The descriptor contains a pointer to the real buffer, which is

								//     normally allocated out of nonpaged pool.  The descriptor itself

								//     may be allocated out of the FSP heap, although receive buffer

								//     descriptors are allocated from nonpaged pool, so the FSD

								//     read/write code can access them.

								//


								typedef struct _BUFFER {

								    PVOID Buffer;

								    CLONG BufferLength;             // Length allocated to buffer

								    PMDL Mdl;                       // MDL describing entire buffer

								    PMDL PartialMdl;                // Partial MDL for read/write/etc.

								    CLONG DataLength;               // Length of data currently in buffer

								    ULONG Reserved;                 // Pad to quadword

								} BUFFER, *PBUFFER;


								#define MIN_SEND_SIZE               512

								#define MAX_PARTIAL_BUFFER_SIZE     65535


								//

								// For each search request that is started (Find First or core Search),

								// a search block is allocated.  This is used to hold enough information

								// that the search may be quickly restarted or rewound.

								//

								// Ths InUse field is protected by Connection->Lock--this lock must be

								// held when accessing this field of the search block.

								//


								typedef struct _SEARCH {

								    BLOCK_HEADER BlockHeader;


								    HANDLE DirectoryHandle;


								    ULONG LastFileIndexReturned;

								    UNICODE_STRING SearchName;

								    UNICODE_STRING LastFileNameReturned;


								    LARGE_INTEGER LastUseTime;

								    LIST_ENTRY LastUseListEntry;

								    LIST_ENTRY HashTableEntry;


								    PSESSION Session;

								    PTREE_CONNECT TreeConnect;

								    ULONG SearchStorageType;


								    struct _DIRECTORY_CACHE *DirectoryCache;

								    USHORT NumberOfCachedFiles;


								    USHORT SearchAttributes;

								    SHORT CoreSequence;

								    SHORT TableIndex;

								    USHORT HashTableIndex;


								    USHORT Pid;

								    USHORT Flags2;


								    BOOLEAN Wildcards;

								    BOOLEAN InUse;


								    // WCHAR SearchNameData[SearchName.MaximumLength/2];


								} SEARCH, *PSEARCH;


								//

								// Each pending transaction request (Transaction, Transaction2, and

								// Ioctl) has a transaction block.  It records information that is

								// needed to stage input and output data across multiple SMBs.

								//

								// *******************************************************************

								// *                                                                 *

								// * DO NOT CHANGE THIS STRUCTURE WITHOUT CHANGING THE CORRESPONDING *

								// * STRUCTURE IN net\inc\xstypes.h!                                 *

								// *                                                                 *

								// *******************************************************************

								//


								typedef struct _TRANSACTION {


								    //

								    // *** NOTE:  The reference count field in the transaction block

								    //            header is not used!  Instead, the reference count is

								    //            in the NonpagedHeader structure.

								    //


								    BLOCK_HEADER BlockHeader;


								    PNONPAGED_HEADER NonpagedHeader;


								    //

								    // The connection, session, and tree connect pointers are referenced

								    // pointers if and only if Inserted is TRUE.  Otherwise, they are

								    // simply copies of the work context block's pointers.

								    //


								    PCONNECTION Connection;

								    PSESSION Session;

								    PTREE_CONNECT TreeConnect;


								    LIST_ENTRY ConnectionListEntry;


								    UNICODE_STRING TransactionName; // not used if Transaction2


								    ULONG StartTime;

								    ULONG Timeout;

								    CLONG cMaxBufferSize;        // if needed we stash this here


								    //

								    // The following pointers point into either the trailing portion

								    // of the transaction block or the last received SMB.

								    //

								    // *** ALL information in buffers pointed to by these parameters

								    //     should ALWAYS be in little-endian format.  Always use the

								    //     macros defined in srvmacro.h (SmbGetAlignedUshort, etc.) to

								    //     read from or write into these buffers.

								    //


								    PSMB_USHORT InSetup;

								    PSMB_USHORT OutSetup;

								    PCHAR InParameters;

								    PCHAR OutParameters;

								    PCHAR InData;

								    PCHAR OutData;


								    //

								    // *** Data in all the remaining fields of the transaction block are

								    //     in native format, so no special macros should be used, except

								    //     when copying data to/from the actual SMB.

								    //


								    CLONG SetupCount;               // amount received (all in first buffer)

								    CLONG MaxSetupCount;            // max that can be sent back

								    CLONG ParameterCount;           // amount received or sent

								    CLONG TotalParameterCount;      // amount expected

								    CLONG MaxParameterCount;        // max that can be sent back

								    CLONG DataCount;                // amount received or sent

								    CLONG TotalDataCount;           // amount expected

								    CLONG MaxDataCount;             // max that can be sent back


								    USHORT Category;                // Ioctl function category

								    USHORT Function;                // Nt Transaction or ioctl function code


								    //

								    // The SMB data and paramters may or may not be copied to the

								    // transaction buffer.  If they are not copied, they are read

								    // and/or written directly into an SMB buffer.

								    //

								    // Setup words are never copied.

								    //


								    BOOLEAN InputBufferCopied;       // if FALSE input buffer is in SMB

								    BOOLEAN OutputBufferCopied;      // if FALSE output buffer is in SMB

								    BOOLEAN OutDataAllocated;        // if TRUE OutData buffer has been separately allocated


								    USHORT Flags;


								    USHORT Tid;

								    USHORT Pid;

								    USHORT Uid;

								    USHORT OtherInfo;


								    HANDLE FileHandle;              // Used only for CallNamedPipe processing

								    PFILE_OBJECT FileObject;        // Used only for CallNamedPipe processing


								    //

								    // The following fields are used while the response is being sent.

								    //


								    CLONG ParameterDisplacement;

								    CLONG DataDisplacement;


								    //

								    // PipeRequest is set for named pipe transactions.  RemoteApiRequest

								    // is set for remote API requests.

								    //


								    BOOLEAN PipeRequest;

								    BOOLEAN RemoteApiRequest;


								    //

								    // The following boolean is TRUE if the transaction has been inserted

								    // on the connection's transaction list.  It will be FALSE when the

								    // transaction can be handled using a single SMB exchange.

								    //


								    BOOLEAN Inserted;


								    //

								    // This boolean is TRUE if the transaction is in the state where

								    // it is waiting for a transaction secondary request to come in

								    // to acknowledge the receipt of the previous piece of a multipiece

								    // transaction response.

								    //


								    BOOLEAN MultipieceIpxSend;


								    //

								    // This boolean is TRUE if all of the transaction data has been received

								    //  and the transaction has been scheduled for execution.

								    //

								    BOOLEAN Executing;


								    //

								    // The main part of the transaction block is trailed by transaction

								    // name data and possibly setup words and parameter and data bytes.

								    //


								} TRANSACTION, *PTRANSACTION;


								//

								// Each pending blocking open request has a BLOCKING_OPEN block.  This

								// block contains all the info needed to make the call into the file

								// system.


								typedef struct _BLOCKING_OPEN {

								    BLOCK_HEADER BlockHeader;


								    PMFCB Mfcb;


								    PIO_STATUS_BLOCK IoStatusBlock;


								    OBJECT_ATTRIBUTES ObjectAttributes;


								    UNICODE_STRING RelativeName;


								    PVOID EaBuffer;

								    CLONG EaLength;


								    LARGE_INTEGER AllocationSize;

								    ULONG DesiredAccess;

								    ULONG FileAttributes;

								    ULONG ShareAccess;

								    ULONG CreateDisposition;

								    ULONG CreateOptions;


								    BOOLEAN CaseInsensitive;


								} BLOCKING_OPEN, *PBLOCKING_OPEN;


								//

								// SRV_TIMER is used for timed operations.  The server maintains a pool

								// of these structures.

								//


								typedef struct _SRV_TIMER {

								    SINGLE_LIST_ENTRY Next;

								    KEVENT Event;

								    KTIMER Timer;

								    KDPC Dpc;

								} SRV_TIMER, *PSRV_TIMER;


								typedef struct _IPX_CLIENT_ADDRESS {

								    TA_IPX_ADDRESS IpxAddress;

								    TDI_CONNECTION_INFORMATION Descriptor;

								    IPX_DATAGRAM_OPTIONS DatagramOptions;

								} IPX_CLIENT_ADDRESS, *PIPX_CLIENT_ADDRESS;


								//

								// The state for an I/O request is maintained in a Work Context Block.

								// Various fields in the block are filled in or not depending upon the

								// request.  When a worker thread removes a work item from the FSP work

								// queue, it uses the context block, and items pointed to by the

								// context block, to determine what to do.

								//

								// *** Not all of the back pointers have to be here, because a tree

								//     connect points to a session, which points to a connection, which

								//     points to an endpoint, etc.  However, depending on the operation

								//     and the state of the operation, we may have a connection pointer

								//     but no session pointer, etc.  So we maintain all of the

								//     pointers.

								//

								// *** Any changes to the first 2 elements of this structure must be

								//     made in concert with the SPECIAL_WORK_ITEM structure in srvtypes.h

								//


								typedef struct _WORK_CONTEXT {


								    //

								    // The list entry in the block header is used to queue the WC for to

								    // the nonblocking or blocking worker thread work queue.  The

								    // nonblocking work queue also contains RFCBs.

								    //

								    // *** Note that this is an unnamed field, so that its elements can

								    //     can be referenced directly.  The field names defined in

								    //     QUEUEABLE_BLOCK_HEADER cannot be used elsewhere in this

								    //     block.

								    //

								    // Timestamp (in the block header) is used to calculate the total

								    // time this work context block was on the work queue.

								    //

								    // When the work context block is not in use, Timestamp is used to

								    // record the time at which the block was inserted on the free list.

								    // This is used to determine when dynamically-allocated work context

								    // blocks have been idle long enough justify their deletion.

								    //

								    // FspRestartRoutine (in the block header) is the routine that is to

								    // be called by worker thread when the work item is dequeued from

								    // the work queue.

								    //


								    QUEUEABLE_BLOCK_HEADER ;   // must be first element


								    //

								    // This is the WORK_QUEUE to queue on if we're doing nonblocking work

								    //   It will always point to a valid WORK_QUEUE, even if we're doing

								    //   blocking work.

								    //

								    PWORK_QUEUE CurrentWorkQueue;


								    //

								    // The free list this should be returned to when work is done

								    //

								    PSLIST_HEADER FreeList;


								    //

								    // FsdRestartRoutine is the routine that is to be called by the

								    // FSD's I/O completion routine.  This routine can do more

								    // processing or queue the work item to the FSP.  In this case, when

								    // a worker thread removes the item from the work queue, it calls

								    // FspRestartRoutine.

								    //


								    PRESTART_ROUTINE FsdRestartRoutine;


								    //

								    // Linkage field for the in-progress work item list.

								    //


								    LIST_ENTRY InProgressListEntry;


								    //

								    // Pointers to various structures that might be used.

								    // These pointers are all referenced pointers.  It is

								    // the responsibility of the SMB processing routines to

								    // dereference and clear these pointers when they are no

								    // longer needed.

								    //

								    PRFCB Rfcb;

								    PSHARE Share;

								    PSESSION Session;

								    PTREE_CONNECT TreeConnect;


								    //

								    // These are gathered in one place to facilitate quick zeroing

								    // of their values when the work context is finished

								    //

								    struct _WorkContextZeroBeforeReuse {

								        //

								        // unreferenced pointer to the endpoint structure for

								        //  this work context.  Filled in by SrvRestartReceive and

								        //  available to all SMB processing routines.

								        //

								        //  Endpoint must be the first element in this structure.  See

								        //   INITIALIZE_WORK_CONTEXT in srvmacro.h if changed.

								        //

								        PENDPOINT Endpoint;         // not a referenced pointer


								        //

								        // referenced pointer to the connection structure for this

								        //  this work context.  Filled in by SrvRestartReceive and

								        //  available to all SMB processing routines.

								        //

								        PCONNECTION Connection;     // a reference pointer


								        //

								        // The number of times this SMB has been queued to a worker thread

								        // for processing.

								        //

								        ULONG ProcessingCount;


								        //

								        // This is a random collection of flags that are needed to steer

								        // the WorkItem

								        //

								        struct {


								            //

								            // Can the processing of the current SMB block?

								            //


								            ULONG BlockingOperation : 1;


								            //

								            // UsingExtraSmbBuffer is TRUE if this work context uses the an extra SMB

								            // buffer.

								            //


								            ULONG UsingExtraSmbBuffer : 1;


								            //

								            // Did this Work Item cause a successful oplock open to occur?

								            //


								            ULONG OplockOpen : 1;


								            //

								            // If we got an ACCESS_DENIED error when opening a file, was it because

								            // of share ACL checking?


								            ULONG ShareAclFailure : 1;


								            //

								            // Should the WorkContext be queued to the head of the list?

								            //

								            ULONG QueueToHead : 1;


								            //

								            //  Even if security signatures are enabled, do not generate a signature for

								            //   this response.

								            //

								            ULONG NoResponseSmbSecuritySignature : 1;


								            //

								            // The indicated message exceeds the SMB buffer size.  This is allowed

								            //  only for specific SMB(s)

								            //

								            ULONG LargeIndication: 1;


								#if DBG_STUCK

								            //

								            // Do not include this operation in the StuckOperation catching logic

								            //  which is in the scavenger

								            //

								            ULONG IsNotStuck : 1;

								#endif


								        };


								        // For SnapShot usage

								        LARGE_INTEGER SnapShotTime;


								    };


								    //

								    // Pointers to allocated buffers.  RequestBuffer is the buffer into

								    // which the SMB is read.  ResponseBuffer is the buffer into which

								    // the response is written.

								    //

								    // *** Currently, ResponseBuffer is always the same as

								    //     RequestBuffer.  We have separate pointers in order to reduce

								    //     dependence on this being the case.

								    //


								    PBUFFER RequestBuffer;

								    PBUFFER ResponseBuffer;


								    //

								    // SMB processing pointers.  These are pointers into the request

								    // buffer.  They are maintained in the work context block in support

								    // of SMB processors that do asynchronous I/O.

								    //

								    // Separate request and response parameter pointers are maintained

								    // to make AndX processing simpler and more efficient.  RequestHeader

								    // is normally the same as ResponseHeader -- both are normally the

								    // same as RequestBuffer.Buffer.  SMB processing code must not depend

								    // on this -- it must not assume the the request and response buffers

								    // are the same, nor can it assume that they are different.  Special

								    // rules around AndX SMBs do allow them to assume that the response

								    // to one command will not overwrite the next request.

								    //


								    PSMB_HEADER RequestHeader;

								    PVOID RequestParameters;

								    PSMB_HEADER ResponseHeader;

								    PVOID ResponseParameters;


								    //

								    // Pointer to the IRP associated with this work item.

								    //


								    PIRP Irp;


								    //

								    // StartTime stores the time at which processing of the current

								    // request began so that the turnaround time may be calculated.

								    //


								    ULONG StartTime;


								    //

								    // The PartOfInitialAllocation boolean indicates whether this work

								    // item is part of the block of work items allocated at server

								    // startup (see blkwork.c\SrvAllocateInitialWorkItems).  Such work

								    // items cannot be deleted during server operation.  A work item

								    // that is dynamically allocated in response to server load does not

								    // have this bit set, and is a candidate for deletion when the

								    // server's load decreases.

								    //


								    ULONG PartOfInitialAllocation;


								    //

								    // The following field contadins the command code of the next

								    // command to be processed in an SMB.  The SMB processing

								    // initializer and chained (AndX) SMB command processors load this

								    // field prior to calling or returning to SrvProcessSmb.

								    //


								    UCHAR NextCommand;


								    //

								    // ClientAddress is used when receiving or sending over IPX.

								    //


								    PIPX_CLIENT_ADDRESS ClientAddress;


								    //

								    // Spin lock protecting reference count.

								    //


								    KSPIN_LOCK SpinLock;


								    //

								    // The security signature index for the request

								    //

								    ULONG SmbSecuritySignatureIndex;


								    //

								    // The security signature index for the response

								    //

								    ULONG ResponseSmbSecuritySignatureIndex;


								    //

								    // The following union is used to hold request-specific state while

								    // a response is being sent or while waiting for more data.

								    //


								    union {


								        //

								        // RemainingEchoCount is used when processing the Echo SMB.

								        //


								        USHORT RemainingEchoCount;


								        //

								        // Structure used for lock processing.  This structure is

								        // currently used when processing the Lock, LockingAndX, and the

								        // LockAndRead SMBs.

								        //


								        struct {


								            //

								            // LockRange is used when processing the LockingAndX SMB.  It is

								            // really either a PLOCKING_ANDX_RANGE, or a PNTLOCKING_ANDX_RANGE

								            // not just a PVOID.

								            //


								            PVOID LockRange;


								            //

								            // Timer is a timer and DPC used to timeout lock requests.

								            //


								            PSRV_TIMER Timer;


								#ifdef INCLUDE_SMB_PERSISTENT

								            LARGE_INTEGER Offset;           // offset for this lock

								            LARGE_INTEGER Length;           // length of this lock

								            BOOLEAN Exclusive;              // is this lock exclusive?

								#endif


								        } Lock;


								        //

								        // Transaction is used when processing the Transaction[2] SMBs.

								        // Or when processing a write and X SMB.

								        //


								        PTRANSACTION Transaction;


								        //

								        // MdlIo is used when processing the ReadRaw or WriteRaw

								        // SMBs when "MDL read" or "MDL write" is used.  It

								        // retains the status of the response send while the MDL is

								        // returned to the file system.

								        //


								        struct {

								            IO_STATUS_BLOCK IoStatus;

								            ULONG IrpFlags;

								        } MdlIo;


								        //

								        // LastWriteTime is used when processing any Read or Write SMB

								        // that uses RestartChainedClose as a restart routine.  This

								        // field contains the new last write time to set for the file.

								        //


								        ULONG LastWriteTime;


								        //

								        // CurrentTableIndex is used when processing the Flush SMB.  It

								        // retains the current index into the connection's file table

								        // when an asynchronous flush is in progress.

								        //


								        LONG CurrentTableIndex;


								        //

								        // ReadRaw is used when processing the Read Block Raw SMB.

								        // Offset is the file offset of the read.  SavedResponseBuffer

								        // points to the original SMB response buffer descriptor, which

								        // is temporarily replaced by a descriptor for the raw read

								        // buffer.  MdlRead indicates whether an MDL read was used,

								        // rather than a Copy read.

								        //


								        struct {


								            union {


								                //

								                // Used for non named pipe reads

								                //


								                LARGE_INTEGER Offset;

								                ULONG Length;


								                //

								                // Used only for named pipe reads

								                //


								                PFILE_PIPE_PEEK_BUFFER PipePeekBuffer;


								            } ReadRawOtherInfo;


								            PBUFFER SavedResponseBuffer;


								            BOOLEAN MdlRead;


								        } ReadRaw;


								        //

								        // WriteRaw is used when processing the Write Block Raw SMB.

								        // FinalResponseBuffer points to the buffer allocated to contain

								        // the final response SMB, if writethrough mode was specified.

								        // Offset is the file offset of the write.  ImmediateLength is

								        // the amount of write data that was sent with the request SMB.

								        // Pid is the PID of the writer, used to form the lock key on

								        // the write.  FileObject is a pointer to the file object copied

								        // from the LFCB.  (Pid is not used when MDL write is used;

								        // FileObject is not used when copy write is used.)

								        //


								        struct {

								            struct _WORK_CONTEXT *RawWorkContext;

								        } WriteRawPhase1;


								        struct {

								            LARGE_INTEGER Offset;

								            ULONG Length;

								            PVOID FinalResponseBuffer;

								            CLONG ImmediateLength;

								            PMDL FirstMdl;

								            //PFILE_OBJECT FileObject;

								            USHORT Pid;

								            BOOLEAN MdlWrite;

								            BOOLEAN ImmediateWriteDone;

								        } WriteRaw;


								        //

								        // ReadAndXCompressed is the structure used when handling

								        //  compressed ReadAndX

								        //

								        struct {

								            LARGE_INTEGER ReadOffset;   // original read offset

								            ULONG ReadLength;           // original read length

								            ULONG CompressedInfoLength;

								            FSRTL_AUXILIARY_BUFFER Aux;

								        } ReadAndXCompressed;


								        //

								        // ReadAndX is the structure used when handling the ReadAndX

								        // SMB.

								        //


								        struct {

								            LARGE_INTEGER ReadOffset;

								            ULONG ReadLength;

								            PCHAR ReadAddress;

								            union {

								                struct {

								                    PFILE_PIPE_PEEK_BUFFER PipePeekBuffer;

								                    ULONG LastWriteTimeInSeconds;   // used if Close is chained

								                };

								                struct {                        // used for ReadLength > negotiated size

								                    PBYTE   Buffer;             // allocated paged pool, if copy read

								                    PMDL    SavedMdl;

								                    PMDL    CacheMdl;

								                    USHORT  PadCount;

								                    BOOLEAN MdlRead;

								                };

								            };

								        } ReadAndX;


								#define READX_BUFFER_OFFSET (sizeof(SMB_HEADER) + FIELD_OFFSET(RESP_READ_ANDX, Buffer) )


								        //

								        // WriteAndX is the structure used when handling the flavor of WriteAndX that

								        //  exceeds the negotiated buffer size

								        //

								        struct {

								            ULONG CurrentWriteLength;       // amount of data that was written this time

								            LARGE_INTEGER Offset;           // file offset for this piece of the write

								            ULONG RemainingWriteLength;     // amount of data remaining to be read from xport

								            ULONG Key;                      // lock key for the operation

								            PCHAR WriteAddress;             // address in buffer for the data

								            ULONG BufferLength;             // Maximum buffer length in this WorkContext

								            NTSTATUS FinalStatus;           // Final status of the operation

								            PMDL MdlAddress;                // File MDL if MdlWrite == TRUE

								            BOOLEAN InitialComplete;        // TRUE if we have written first part to the file

								        } WriteAndX;


								        //

								        // WriteC is used when we are doing compressed writes

								        //

								        struct {

								            LARGE_INTEGER Offset;           // File offset for this piece of the write

								            ULONG Key;                      // Lock key for the operation

								            ULONG CdiLength;                // COMPRESSED_DATA_INFO length if compressed write

								            ULONG CompressedDataLength;     // Length of compressed data

								            ULONG UncompressedDataLength;   // Uncompressed length of the write

								            PCOMPRESSED_DATA_INFO Cdi;      // The compressed data info descriptor for this write

								            ULONG InitialFragmentSize;      // Amount of CompressedData in initial receive

								            FSRTL_AUXILIARY_BUFFER Aux;

								            PMDL    Mdl;                    // Mdl we are using for compressed writes

								            BOOLEAN MdlCompleted;           // Have we called MdlWriteCompleteCompressed yet?

								            PFAST_IO_MDL_WRITE_COMPLETE_COMPRESSED MdlWriteCompleteCompressed;

								            PFILE_OBJECT FileObject;

								            PDEVICE_OBJECT DeviceObject;

								            PBYTE CompressedBuffer;         // In case the PrepareMdlWrite failed!

								            PBYTE UncompressedBuffer;

								        } WriteC;


								        //

								        // ReadMpx is the structure used when handling the ReadMpx SMB, unless

								        //  we have a SmartCard accelerating our reads.  In this case,

								        //  SmartCardRead is used.

								        //


								        struct {

								            ULONG Offset;

								            USHORT FragmentSize;

								            USHORT RemainingLength;

								            ULONG ReadLength;

								            BOOLEAN MdlRead;

								            UCHAR Unused;

								            USHORT CurrentMdlOffset; // logically part of MDL read struct below

								            union {

								                struct {

								                    PVOID MpxBuffer;

								                    PMDL MpxBufferMdl;

								                    PCHAR NextFragmentAddress;

								                } ;

								                struct {

								                    PMDL FirstMdl;

								                    PMDL CurrentMdl;

								                } ;

								            } ;

								        } ReadMpx;


								        //

								        // SmartCardRead is used to handle direct host read requests if we have

								        //   a Smart Card accelerating the particular request.

								        //

								        struct {

								            PDEVICE_OBJECT DeviceObject;

								            PFAST_IO_MDL_READ_COMPLETE MdlReadComplete;

								        } SmartCardRead;


								        //

								        // WriteMpx is the structure used when handling the WriteMpx SMB.

								        //


								        struct {

								            ULONG Offset;

								            USHORT WriteLength;

								            USHORT Mid;

								            BOOLEAN FirstPacketOfGlom;

								            PVOID Buffer;

								            ULONG ReceiveDatagramFlags;

								            PVOID TransportContext;

								            PMDL DataMdl;

								        } WriteMpx;


								        struct {

								            LARGE_INTEGER   CacheOffset;

								            ULONG           WriteLength;

								            PMDL            CacheMdl;

								        } WriteMpxMdlWriteComplete;


								        //

								        // FastTransactNamedPipe is used when handling a small named pipe

								        // transaction.

								        //


								        struct {

								            PSMB_USHORT OutSetup;

								            PCHAR OutParam;

								            PCHAR OutData;

								        } FastTransactNamedPipe;


								#ifdef INCLUDE_SMB_PERSISTENT

								        struct {


								            ULONG            ResumeSmbStatus;

								            PRESTART_ROUTINE FsdRestartRoutine;

								            PRESTART_ROUTINE FspRestartRoutine;


								        } MakePersistent;

								#endif


								    } Parameters;


								    // !!! check whether the compiler leaves a dword gap here!


								    //

								    // The following union holds state information about SMBs in progress

								    // waiting for an oplock break.  It is kept separate from the Parameters

								    // union, since information from both is needed to process some SMBs.

								    //


								    union {


								        //

								        // Open is the structure used when handling the Open,

								        // OpenAndX, Open2, Create, or CreateTemporary SMB.

								        //


								        struct {

								            PRFCB Rfcb;

								            PFILE_FULL_EA_INFORMATION NtFullEa;

								            ULONG EaErrorOffset;


								            //

								            // The Irp used to open the file is the same Irp used to handle

								            //  the oplock processing.  This can cause us to lose the original

								            //  iosb->Information.  Save it here.

								            //

								            ULONG_PTR IosbInformation;


								            //

								            // If TRUE, the file was opened only in order to get a handle

								            // so that we can wait for an oplock to break.  This handle will

								            // be immediately closed, and the open will be retried with the

								            // user requested access.

								            //


								            BOOLEAN TemporaryOpen;

								        } Open;


								        //

								        // FileInformation is the structure used when handling the

								        // QueryInformation, SetInformation, QueryPathInformation,

								        // or SetPathInformation SMB.

								        //


								        struct {

								            HANDLE FileHandle;

								        } FileInformation;


								        //

								        // LockLength is used to contain the length of a byte range

								        // lock since the IRP stack location has no room to hold it.


								        LARGE_INTEGER LockLength;


								        //

								        // StartSend is used by SrvStartSend when queueing a work item

								        // to the FSP for handling by the SmbTrace logic.

								        //


								        struct {

								            PRESTART_ROUTINE FspRestartRoutine;

								            ULONG SendLength;

								        } StartSend;


								    } Parameters2;


								    //

								    // This field is used when the current operation is blocked waiting

								    // for an oplock break to occur.

								    //


								    struct _WAIT_FOR_OPLOCK_BREAK *WaitForOplockBreak;


								    union {

								        //

								        // where we keep the actual client address data.

								        //

								        IPX_CLIENT_ADDRESS ClientAddressData;


								        //

								        // For a VC-based client, this is the amount of available data if

								        //  LargeIndication is set (above)

								        //

								        ULONG BytesAvailable;

								    };


								    struct {

								        LARGE_INTEGER G_StartTime;

								        ULONG         ElapseKCPU;

								        ULONG         ElapseUCPU;

								        ULONG         ClientAddr;

								        PFILE_OBJECT  FileObject;

								    };


								    ULONG         KCPUStart;

								    ULONG         UCPUStart;

								    UCHAR         PreviousSMB;

								    UCHAR         bAlreadyTrace;

								    USHORT        FileNameSize;

								    WCHAR         strFileName[1024];


								#if DBG_STUCK

								    //

								    // Time at which this work context was allocated for this current

								    //  unit of work.  This time is examined by debugging code in the

								    //  scavenger to help find operations which are taking too long

								    //  to complete.

								    //

								    LARGE_INTEGER OpStartTime;

								#endif

								} WORK_CONTEXT, *PWORK_CONTEXT;


								//

								// Structure used to maintain information about a thread waiting for

								// an oplock break.

								//


								typedef struct _WAIT_FOR_OPLOCK_BREAK {

								    BLOCK_HEADER BlockHeader;

								    LIST_ENTRY ListEntry;

								    LARGE_INTEGER TimeoutTime;

								    PIRP Irp;

								    WAIT_STATE WaitState;

								} WAIT_FOR_OPLOCK_BREAK, *PWAIT_FOR_OPLOCK_BREAK;


								//

								// Block manager routines

								//


								//

								// Buffer routines

								//


								VOID

								SrvAllocateBuffer (

								    OUT PBUFFER *Buffer,

								    IN CLONG BufferLength

								    );


								VOID

								SrvFreeBuffer (

								    IN PBUFFER Buffer

								    );


								//

								// Connection routines

								//


								VOID

								SrvAllocateConnection (

								    OUT PCONNECTION *Connection

								    );


								VOID

								SrvCloseConnection (

								    IN PCONNECTION Connection,

								    IN BOOLEAN RemoteDisconnect

								    );


								VOID

								SrvCloseConnectionsFromClient(

								    IN PCONNECTION Connection,

								    IN BOOLEAN OnlyIfNoSessions

								    );


								VOID

								SrvCloseFreeConnection (

								    IN PCONNECTION Connection

								    );


								VOID

								SrvDereferenceConnection (

								    IN PCONNECTION Connection

								    );


								VOID

								SrvFreeConnection (

								    IN PCONNECTION Connection

								    );


								#if DBG

								NTSTATUS

								SrvQueryConnections (

								    OUT PVOID Buffer,

								    IN ULONG BufferLength,

								    OUT PULONG BytesWritten

								    );

								#endif


								//

								// Endpoint routines

								//


								VOID

								SrvAllocateEndpoint (

								    OUT PENDPOINT *Endpoint,

								    IN PUNICODE_STRING NetworkName,

								    IN PUNICODE_STRING TransportName,

								    IN PANSI_STRING TransportAddress,

								    IN PUNICODE_STRING DomainName

								    );


								BOOLEAN SRVFASTCALL

								SrvCheckAndReferenceEndpoint (

								    IN PENDPOINT Endpoint

								    );


								VOID

								SrvCloseEndpoint (

								    IN PENDPOINT Endpoint

								    );


								VOID SRVFASTCALL

								SrvDereferenceEndpoint (

								    IN PENDPOINT Endpoint

								    );


								VOID

								SrvFreeEndpoint (

								    IN PENDPOINT Endpoint

								    );


								VOID

								SrvReferenceEndpoint (

								    IN PENDPOINT Endpoint

								    );


								BOOLEAN

								SrvFindNamedEndpoint (

								    IN PUNICODE_STRING ServerName,

								    IN PBOOLEAN RemapPipeNames OPTIONAL

								    );


								VOID

								EmptyFreeConnectionList (

								    IN PENDPOINT Endpoint

								    );


								PCONNECTION

								WalkConnectionTable (

								    IN PENDPOINT Endpoint,

								    IN PUSHORT Index

								    );


								//

								// Local File Control Block routines

								//


								VOID

								SrvAllocateLfcb (

								    OUT PLFCB *Lfcb,

								    IN PWORK_CONTEXT WorkContext

								    );


								VOID

								SrvCloseLfcb (

								    IN PLFCB Lfcb

								    );


								VOID

								SrvDereferenceLfcb (

								    IN PLFCB Lfcb

								    );


								VOID

								SrvFreeLfcb (

								    IN PLFCB Lfcb,

								    IN PWORK_QUEUE queue

								    );


								VOID

								SrvReferenceLfcb (

								    IN PLFCB Lfcb

								    );


								//

								// Master File Control Block routines

								//


								PMFCB

								SrvCreateMfcb(

								    IN PUNICODE_STRING FileName,

								    IN PWORK_CONTEXT WorkContext,

								    IN ULONG HashValue

								    );


								PMFCB

								SrvFindMfcb(

								    IN PUNICODE_STRING FileName,

								    IN BOOLEAN CaseInsensitive,

								    OUT PSRV_LOCK *Lock,

								    OUT PULONG HashValue,

								    IN PWORK_CONTEXT WorkContext

								    );


								VOID

								SrvDereferenceMfcb (

								    IN PMFCB Mfcb

								    );


								VOID

								SrvFreeMfcb (

								    IN PMFCB Mfcb

								    );


								VOID

								SrvUnlinkLfcbFromMfcb (

								    IN PLFCB Lfcb

								    );


								//

								// Remote File Control Block routines

								//


								VOID SRVFASTCALL

								SrvAllocateRfcb (

								    OUT PRFCB *Rfcb,

								    IN PWORK_CONTEXT WorkContext

								    );


								BOOLEAN SRVFASTCALL

								SrvCheckAndReferenceRfcb (

								    IN PRFCB Rfcb

								    );


								VOID SRVFASTCALL

								SrvCloseRfcb (

								    IN PRFCB Rfcb

								    );


								VOID

								SrvCloseRfcbsOnLfcb (

								    PLFCB Lfcb

								    );


								VOID

								SrvCloseRfcbsOnSessionOrPid (

								    IN PSESSION Session,

								    IN PUSHORT Pid OPTIONAL

								    );


								VOID

								SrvCloseRfcbsOnTree (

								    PTREE_CONNECT TreeConnect

								    );


								VOID

								SrvCompleteRfcbClose (

								    IN PRFCB Rfcb

								    );


								VOID SRVFASTCALL

								SrvDereferenceRfcb (

								    IN PRFCB Rfcb

								    );


								VOID SRVFASTCALL

								SrvFreeRfcb (

								    IN PRFCB Rfcb,

								    IN PWORK_QUEUE queue

								    );


								VOID SRVFASTCALL

								SrvReferenceRfcb (

								    IN PRFCB Rfcb

								    );


								BOOLEAN

								SrvFindCachedRfcb (

								    IN PWORK_CONTEXT WorkContext,

								    IN PMFCB Mfcb,

								    IN ACCESS_MASK DesiredAccess,

								    IN ULONG ShareAccess,

								    IN ULONG CreateDisposition,

								    IN ULONG CreateOptions,

								    IN OPLOCK_TYPE RequestedOplockType,

								    OUT PNTSTATUS Status

								    );


								VOID

								SrvCloseCachedRfcb (

								    IN PRFCB Rfcb,

								    IN KIRQL OldIrql

								    );


								VOID

								SrvCloseCachedRfcbsOnConnection (

								    IN PCONNECTION Connection

								    );


								VOID

								SrvCloseCachedRfcbsOnLfcb (

								    IN PLFCB Lfcb

								    );


								ULONG

								SrvCountCachedRfcbsForTid(

								    PCONNECTION connection,

								    USHORT Tid

								);


								ULONG

								SrvCountCachedRfcbsForUid(

								    PCONNECTION connection,

								    USHORT Uid

								);


								//

								// Search Block routines

								//


								typedef

								BOOLEAN

								(*PSEARCH_FILTER_ROUTINE) (

								    IN PSEARCH Search,

								    IN PVOID FunctionParameter1,

								    IN PVOID FunctionParameter2

								    );


								VOID

								SrvAllocateSearch (

								    OUT PSEARCH *Search,

								    IN PUNICODE_STRING SearchName,

								    IN BOOLEAN IsCoreSearch

								    );


								VOID

								SrvCloseSearch (

								    IN PSEARCH Search

								    );


								VOID

								SrvCloseSearches (

								    IN PCONNECTION Connection,

								    IN PSEARCH_FILTER_ROUTINE SearchFilterRoutine,

								    IN PVOID FunctionParameter1,

								    IN PVOID FunctionParameter2

								    );


								VOID

								SrvDereferenceSearch (

								    IN PSEARCH Search

								    );


								VOID

								SrvFreeSearch (

								    IN PSEARCH Search

								    );


								VOID

								SrvReferenceSearch (

								    IN PSEARCH Search

								    );


								BOOLEAN

								SrvSearchOnDelete(

								    IN PSEARCH Search,

								    IN PUNICODE_STRING DirectoryName,

								    IN PTREE_CONNECT TreeConnect

								    );


								BOOLEAN

								SrvSearchOnPid(

								    IN PSEARCH Search,

								    IN USHORT Pid,

								    IN PVOID Dummy

								    );


								BOOLEAN

								SrvSearchOnSession(

								    IN PSEARCH Search,

								    IN PSESSION Session,

								    IN PVOID Dummy

								    );


								BOOLEAN

								SrvSearchOnTreeConnect(

								    IN PSEARCH Search,

								    IN PTREE_CONNECT TreeConnect,

								    IN PVOID Dummy

								    );


								VOID

								SrvForceTimeoutSearches(

								    IN PCONNECTION Connection

								    );


								ULONG

								SrvTimeoutSearches(

								    IN PLARGE_INTEGER SearchCutoffTime OPTIONAL,

								    IN PCONNECTION Connection,

								    IN BOOLEAN OnlyTimeoutOneBlock

								    );


								VOID

								RemoveDuplicateCoreSearches(

								    IN PPAGED_CONNECTION PagedConnection

								    );


								VOID

								SrvAddToSearchHashTable(

								    IN PPAGED_CONNECTION PagedConnection,

								    IN PSEARCH Search

								    );


								//

								// Cached directory routines

								//

								BOOLEAN

								SrvIsDirectoryCached (

								    IN PWORK_CONTEXT    WorkContext,

								    IN PUNICODE_STRING  DirectoryName

								    );


								VOID

								SrvCacheDirectoryName (

								    IN PWORK_CONTEXT    WorkContext,

								    IN PUNICODE_STRING  DirectoryName

								    );


								VOID

								SrvRemoveCachedDirectoryName (

								    IN PWORK_CONTEXT    WorkContext,

								    IN PUNICODE_STRING  DirectoryName

								    );


								VOID

								SrvCloseCachedDirectoryEntries (

								    IN PCONNECTION      Connection

								    );


								//

								// Session routines

								//


								VOID

								SrvAllocateSession (

								    OUT PSESSION *Session,

								    IN PUNICODE_STRING UserName,

								    IN PUNICODE_STRING Domain

								    );


								BOOLEAN SRVFASTCALL

								SrvCheckAndReferenceSession (

								    IN PSESSION Session

								    );


								VOID

								SrvCloseSession (

								    IN PSESSION Session

								    );


								VOID

								SrvCloseSessionsOnConnection (

								    IN PCONNECTION Connection,

								    IN PUNICODE_STRING UserName OPTIONAL

								    );


								VOID SRVFASTCALL

								SrvDereferenceSession (

								    IN PSESSION Session

								    );


								VOID

								SrvFreeSession (

								    IN PSESSION Session

								    );


								//

								// Smb Security Signature Routines

								//

								BOOLEAN SRVFASTCALL

								SrvCheckSmbSecuritySignature(

								    IN PWORK_CONTEXT WorkContext

								    );


								VOID SRVFASTCALL

								SrvAddSmbSecuritySignature(

								    IN OUT PWORK_CONTEXT WorkContext,

								    IN PMDL Mdl,

								    IN ULONG SendLength

								    );


								VOID SRVFASTCALL

								SrvInitializeSmbSecuritySignature(

								    IN OUT PCONNECTION Connection,

								    IN PUCHAR SessionKey,

								    IN PUCHAR ChallengeResponse,

								    IN ULONG ChallengeResponseLength

								    );


								//

								// Share routines

								//


								VOID

								SrvAllocateShare (

								    OUT PSHARE *Share,

								    IN PUNICODE_STRING ShareName,

								    IN PUNICODE_STRING NtPathName,

								    IN PUNICODE_STRING DosPathName,

								    IN PUNICODE_STRING Remark,

								    IN PSECURITY_DESCRIPTOR SecurityDescriptor,

								    IN PSECURITY_DESCRIPTOR FileSecurityDescriptor OPTIONAL,

								    IN SHARE_TYPE ShareType

								    );


								VOID

								SrvCloseShare (

								    IN PSHARE Share

								    );


								VOID

								SrvDereferenceShare (

								    IN PSHARE Share

								    );


								VOID

								SrvDereferenceShareForTreeConnect (

								    PSHARE Share

								    );


								VOID

								SrvFreeShare (

								    IN PSHARE Share

								    );


								VOID

								SrvReferenceShare (

								    IN PSHARE Share

								    );


								NTSTATUS

								SrvReferenceShareForTreeConnect (

								    PSHARE Share

								    );


								//

								// Table routines

								//


								VOID

								SrvAllocateTable (

								    IN PTABLE_HEADER TableHeader,

								    IN ULONG NumberOfEntries,

								    IN BOOLEAN Nonpaged

								    );


								#define SrvFreeTable( _table ) {                                    \

								        if ( (_table)->Nonpaged ) {                                 \

								            DEALLOCATE_NONPAGED_POOL( (_table)->Table );            \

								        } else {                                                    \

								            FREE_HEAP( (_table)->Table );                           \

								        }                                                           \

								        DEBUG (_table)->Table = NULL;                               \

								        DEBUG (_table)->TableSize = -1;                             \

								        DEBUG (_table)->FirstFreeEntry = -1;                        \

								        DEBUG (_table)->LastFreeEntry = -1;                         \

								    }


								BOOLEAN

								SrvGrowTable (

								    IN PTABLE_HEADER TableHeader,

								    IN ULONG NumberOfNewEntries,

								    IN ULONG MaxNumberOfEntries,

								    OUT NTSTATUS* pStatus

								    );


								VOID

								SrvRemoveEntryTable (

								    IN PTABLE_HEADER TableHeader,

								    IN USHORT Index

								    );


								//

								// Transaction routines

								//


								VOID

								SrvAllocateTransaction (

								    OUT PTRANSACTION *Transaction,

								    OUT PVOID *TrailingBytes,

								    IN PCONNECTION Connection,

								    IN CLONG TrailingByteCount,

								    IN PVOID TransactionName,

								    IN PVOID EndOfSourceBuffer OPTIONAL,

								    IN BOOLEAN SourceIsUnicode,

								    IN BOOLEAN RemoteApiRequest

								    );


								VOID

								SrvCloseTransaction (

								    IN PTRANSACTION Transaction

								    );


								VOID

								SrvCloseTransactionsOnSession (

								    PSESSION Session

								    );


								VOID

								SrvCloseTransactionsOnTree (

								    PTREE_CONNECT TreeConnect

								    );


								VOID

								SrvDereferenceTransaction (

								    IN PTRANSACTION Transaction

								    );


								VOID

								SrvFreeTransaction (

								    IN PTRANSACTION Transaction

								    );


								PTRANSACTION

								SrvFindTransaction (

								    IN PCONNECTION Connection,

								    IN PSMB_HEADER Header,

								    IN USHORT Fid OPTIONAL

								    );


								BOOLEAN

								SrvInsertTransaction (

								    IN PTRANSACTION Transaction

								    );


								//

								// Tree connect routines

								//


								VOID

								SrvAllocateTreeConnect (

								    OUT PTREE_CONNECT *TreeConnect,

								    IN PUNICODE_STRING ServerName OPTIONAL

								    );


								BOOLEAN SRVFASTCALL

								SrvCheckAndReferenceTreeConnect (

								    IN PTREE_CONNECT TreeConnect

								    );


								VOID

								SrvCloseTreeConnect (

								    IN PTREE_CONNECT TreeConnect

								    );


								VOID SRVFASTCALL

								SrvDereferenceTreeConnect (

								    IN PTREE_CONNECT TreeConnect

								    );


								VOID

								SrvFreeTreeConnect (

								    IN PTREE_CONNECT TreeConnect

								    );


								VOID

								SrvDisconnectTreeConnectsFromSession (

								    PCONNECTION connection,

								    PSESSION Session

								    );


								VOID

								SrvCloseTreeConnectsOnShare (

								    IN PSHARE Share

								    );


								//

								// Work item routines (includes work contexts, buffers, MDLs, IRPs, etc)

								//


								NTSTATUS

								SrvAllocateInitialWorkItems (

								    VOID

								    );


								NTSTATUS

								SrvAllocateNormalWorkItem (

								    OUT PWORK_CONTEXT *WorkContext,

								    IN  PWORK_QUEUE queue

								    );


								VOID

								SrvAllocateRawModeWorkItem (

								    OUT PWORK_CONTEXT *WorkContext,

								    IN PWORK_QUEUE queue

								);


								PWORK_CONTEXT

								SrvGetRawModeWorkItem (

								    VOID

								    );


								VOID

								SrvRequeueRawModeWorkItem (

								    IN PWORK_CONTEXT WorkContext

								    );


								VOID SRVFASTCALL

								SrvDereferenceWorkItem (

								    IN PWORK_CONTEXT WorkContext

								    );


								VOID

								SrvFsdDereferenceWorkItem (

								    IN PWORK_CONTEXT WorkContext

								    );


								NTSTATUS

								SrvAllocateExtraSmbBuffer (

								    IN OUT PWORK_CONTEXT WorkContext

								    );


								VOID

								SrvAllocateWaitForOplockBreak (

								    OUT PWAIT_FOR_OPLOCK_BREAK *WaitForOplockBreak

								    );


								VOID

								SrvDereferenceWaitForOplockBreak (

								    IN PWAIT_FOR_OPLOCK_BREAK WaitForOplockBreak

								    );


								VOID

								SrvFreeWaitForOplockBreak (

								    IN PWAIT_FOR_OPLOCK_BREAK WaitForOplockBreak

								    );


								VOID

								SrvOplockWaitTimeout(

								    IN PWAIT_FOR_OPLOCK_BREAK WaitForOplockBreak

								    );


								NTSTATUS

								SrvCheckOplockWaitState(

								    IN PWAIT_FOR_OPLOCK_BREAK WaitForOplockBreak

								    );


								NTSTATUS

								SrvWaitForOplockBreak (

								    IN PWORK_CONTEXT WorkContext,

								    IN HANDLE FileHandle

								    );


								NTSTATUS

								SrvStartWaitForOplockBreak (

								    IN PWORK_CONTEXT WorkContext,

								    IN PRESTART_ROUTINE RestartRoutine,

								    IN HANDLE Handle OPTIONAL,

								    IN PFILE_OBJECT FileObject OPTIONAL

								    );


								VOID

								SrvSendDelayedOplockBreak (

								    IN PCONNECTION Connection

								    );


								VOID

								SrvFreeInitialWorkItems (

								    VOID

								    );


								VOID

								SrvFreeNormalWorkItem (

								    IN PWORK_CONTEXT WorkContext

								    );


								VOID

								SrvFreeRawModeWorkItem (

								    IN PWORK_CONTEXT WorkContext

								    );


								//

								//  Byte range lock routines

								//


								#ifdef INCLUDE_SMB_PERSISTENT

								VOID

								SrvAllocateLock (

								    OUT PBYTELOCK *Lock,

								    IN PRFCB Rfcb,

								    IN LARGE_INTEGER Offset,

								    IN LARGE_INTEGER Length,

								    IN BOOLEAN Exclusive

								    );


								PBYTELOCK

								SrvFindAndReferenceLock (

								    IN PRFCB Rfcb,

								    IN LARGE_INTEGER Offset,

								    IN LARGE_INTEGER Length,

								    IN BOOLEAN Exclusive

								    );


								VOID

								SrvCloseLock (

								    IN PBYTELOCK Lock,

								    IN BOOLEAN HaveMfcbLock

								    );


								VOID

								SrvCloseLocksOnRfcb (

								    IN PRFCB Rfcb

								    );


								VOID SRVFASTCALL

								SrvDereferenceLock (

								    IN PBYTELOCK Lock

								    );

								#endif


								//

								// Timer routines

								//


								PSRV_TIMER

								SrvAllocateTimer (

								    VOID

								    );


								VOID

								SrvCancelTimer (

								    IN PSRV_TIMER Timer

								    );


								#define SrvDeleteTimer(_timer) DEALLOCATE_NONPAGED_POOL(_timer)


								#define SrvFreeTimer(_timer) \

								        ExInterlockedPushEntrySList(&SrvTimerList, &(_timer)->Next, &GLOBAL_SPIN_LOCK(Timer))


								VOID

								SrvSetTimer (

								    IN PSRV_TIMER Timer,

								    IN PLARGE_INTEGER Timeout,

								    IN PKDEFERRED_ROUTINE TimeoutHandler,

								    IN PVOID Context

								    );


								#if SRVDBG2


								VOID

								SrvInitializeReferenceHistory (

								    IN PBLOCK_HEADER Block,

								    IN LONG InitialReferenceCount

								    );


								VOID

								SrvUpdateReferenceHistory (

								    IN PBLOCK_HEADER Block,

								    IN PVOID Caller,

								    IN PVOID CallersCaller,

								    IN BOOLEAN IsDereference

								    );


								VOID

								SrvTerminateReferenceHistory (

								    IN PBLOCK_HEADER Block

								    );


								#define INITIALIZE_REFERENCE_HISTORY(block)                        \

								            SrvInitializeReferenceHistory(                         \

								                &(block)->BlockHeader,                             \

								                ((PBLOCK_HEADER)(block))->ReferenceCount           \

								                )


								#define UPDATE_REFERENCE_HISTORY(block,isdereference)              \

								        {                                                          \

								            PVOID caller, callerscaller;                           \

								            RtlGetCallersAddress( &caller, &callerscaller );       \

								            SrvUpdateReferenceHistory(                             \

								                &(block)->BlockHeader,                             \

								                caller,                                            \

								                callerscaller,                                     \

								                isdereference                                      \

								                );                                                 \

								        }


								#define TERMINATE_REFERENCE_HISTORY(block) \

								            SrvTerminateReferenceHistory( &(block)->BlockHeader )


								#else


								#define INITIALIZE_REFERENCE_HISTORY(block)

								#define UPDATE_REFERENCE_HISTORY(block,isdereference)

								#define TERMINATE_REFERENCE_HISTORY(block)


								#endif // if SRVDBG2


								#endif // ndef _SRVBLOCK