1 files changed, 629 insertions, 0 deletions

diff --git a/private/inc/srvfsctl.h b/private/inc/srvfsctl.h
new file mode 100644
index 000000000..6144a6cd1
--- /dev/null
+++ b/private/inc/srvfsctl.h
@@ -0,0 +1,629 @@
+/*++ BUILD Version: 0001    // Increment this if a change has global effects
+
+Copyright (c) 1990  Microsoft Corporation
+
+Module Name:
+
+    srvfsctl.h
+
+Abstract:
+
+    This module defines I/O control codes and structures for the File
+    System Driver of the LAN Manager server.
+
+Author:
+
+    David Treadwell (davidtr) 22-May-1990
+
+Revision History:
+
+--*/
+
+#ifndef _SRVFSCTL_
+#define _SRVFSCTL_
+
+
+//
+// The name of the server device.
+//
+
+#define SERVER_DEVICE_NAME TEXT("\\Device\\LanmanServer")
+
+//
+// IRP control codes used to send requests to the server.  These are
+// used as parameters to NtFsControlFile, and may be found in
+// Irp->Parameters.FsControl.FsControlCode in the server dispatch
+// routine.
+//
+// Note that the low two bits of this code indicate the "method" in
+// which the IO system uses the buffers passed by the user to
+// NtFsControlFile.  We use method 0--normal, buffered output (not
+// DMA)--for non-API requests, and method 3--"neither" IO--for API
+// requests that get processed in the server FSD.  For the APIs
+// that are processed in the server FSP, use method 0.
+//
+// !!! Add more as necessary.
+
+#define FSCTL_SRV_BASE                  FILE_DEVICE_NETWORK
+#define FSCTL_SRV_API                   1 << 11
+
+#define _SRV_CONTROL_CODE(request,method) \
+                ((FSCTL_SRV_BASE)<<12 | (request<<2) | method)
+
+#define _SRV_API_CONTROL_CODE(request) \
+                ((FSCTL_SRV_BASE)<<12 | FSCTL_SRV_API | (request<<2) | METHOD_NEITHER )
+
+#define SRV_API_INDEX(code) \
+                ((code & ~(0xFFFFF000 | FSCTL_SRV_API)) >> 2)
+
+//
+// Standard FSCTLs.
+//
+
+#define FSCTL_SRV_STARTUP               _SRV_CONTROL_CODE(  0, METHOD_NEITHER )
+#define FSCTL_SRV_SHUTDOWN              _SRV_CONTROL_CODE(  1, METHOD_NEITHER )
+#define FSCTL_SRV_CLEAR_STATISTICS      _SRV_CONTROL_CODE(  2, METHOD_BUFFERED )
+#define FSCTL_SRV_GET_STATISTICS        _SRV_CONTROL_CODE(  3, METHOD_BUFFERED )
+#define FSCTL_SRV_SET_DEBUG             _SRV_CONTROL_CODE(  4, METHOD_BUFFERED )
+#define FSCTL_SRV_XACTSRV_CONNECT       _SRV_CONTROL_CODE(  5, METHOD_BUFFERED )
+#define FSCTL_SRV_SEND_DATAGRAM         _SRV_CONTROL_CODE(  6, METHOD_NEITHER )
+#define FSCTL_SRV_SET_PASSWORD_SERVER   _SRV_CONTROL_CODE(  7, METHOD_BUFFERED )
+#define FSCTL_SRV_START_SMBTRACE        _SRV_CONTROL_CODE(  8, METHOD_BUFFERED )
+#define FSCTL_SRV_SMBTRACE_FREE_SMB     _SRV_CONTROL_CODE(  9, METHOD_BUFFERED )
+#define FSCTL_SRV_END_SMBTRACE          _SRV_CONTROL_CODE( 10, METHOD_BUFFERED )
+#define FSCTL_SRV_QUERY_CONNECTIONS     _SRV_CONTROL_CODE( 11, METHOD_BUFFERED )
+#define FSCTL_SRV_PAUSE                 _SRV_CONTROL_CODE( 12, METHOD_NEITHER )
+#define FSCTL_SRV_CONTINUE              _SRV_CONTROL_CODE( 13, METHOD_NEITHER )
+#define FSCTL_SRV_GET_CHALLENGE         _SRV_CONTROL_CODE( 14, METHOD_BUFFERED )
+#define FSCTL_SRV_GET_DEBUG_STATISTICS  _SRV_CONTROL_CODE( 15, METHOD_BUFFERED )
+#define FSCTL_SRV_XACTSRV_DISCONNECT    _SRV_CONTROL_CODE( 16, METHOD_BUFFERED )
+#define FSCTL_SRV_REGISTRY_CHANGE       _SRV_CONTROL_CODE( 17, METHOD_NEITHER )
+#define FSCTL_SRV_GET_QUEUE_STATISTICS  _SRV_CONTROL_CODE( 18, METHOD_BUFFERED )
+#define FSCTL_SRV_SHARE_STATE_CHANGE    _SRV_CONTROL_CODE( 19, METHOD_BUFFERED )
+#define FSCTL_SRV_BEGIN_PNP_NOTIFICATIONS _SRV_CONTROL_CODE(20, METHOD_BUFFERED )
+
+//
+// The following FSCTL can be issued by a kernel driver to hook into the server
+//   for accelerated direct host IPX performance.  A pointer to an SRV_IPX_SMART_CARD
+//   structure is given for the START fsctl as the InputBuffer.
+
+#define FSCTL_SRV_IPX_SMART_CARD_START  _SRV_CONTROL_CODE( 21, METHOD_NEITHER )
+
+//
+// API FSCTLs.
+//
+// *** The order of these must match the order of API processors in
+//     the SrvApiDispatchTable jump table defined in ntos\srv\srvdata.c!
+
+#define FSCTL_SRV_NET_CHARDEV_CONTROL   _SRV_API_CONTROL_CODE(  0 )
+#define FSCTL_SRV_NET_CHARDEV_ENUM      _SRV_API_CONTROL_CODE(  1 )
+#define FSCTL_SRV_NET_CHARDEVQ_ENUM     _SRV_API_CONTROL_CODE(  2 )
+#define FSCTL_SRV_NET_CHARDEVQ_PURGE    _SRV_API_CONTROL_CODE(  3 )
+#define FSCTL_SRV_NET_CHARDEVQ_SET_INFO _SRV_API_CONTROL_CODE(  4 )
+#define FSCTL_SRV_NET_CONNECTION_ENUM   _SRV_API_CONTROL_CODE(  5 )
+#define FSCTL_SRV_NET_FILE_CLOSE        _SRV_API_CONTROL_CODE(  6 )
+#define FSCTL_SRV_NET_FILE_ENUM         _SRV_API_CONTROL_CODE(  7 )
+#define FSCTL_SRV_NET_SERVER_DISK_ENUM  _SRV_API_CONTROL_CODE(  8 )
+#define FSCTL_SRV_NET_SERVER_SET_INFO   _SRV_API_CONTROL_CODE(  9 )
+#define FSCTL_SRV_NET_SERVER_XPORT_ADD  _SRV_API_CONTROL_CODE( 10 )
+#define FSCTL_SRV_NET_SERVER_XPORT_DEL  _SRV_API_CONTROL_CODE( 11 )
+#define FSCTL_SRV_NET_SERVER_XPORT_ENUM _SRV_API_CONTROL_CODE( 12 )
+#define FSCTL_SRV_NET_SESSION_DEL       _SRV_API_CONTROL_CODE( 13 )
+#define FSCTL_SRV_NET_SESSION_ENUM      _SRV_API_CONTROL_CODE( 14 )
+#define FSCTL_SRV_NET_SHARE_ADD         _SRV_API_CONTROL_CODE( 15 )
+#define FSCTL_SRV_NET_SHARE_DEL         _SRV_API_CONTROL_CODE( 16 )
+#define FSCTL_SRV_NET_SHARE_ENUM        _SRV_API_CONTROL_CODE( 17 )
+#define FSCTL_SRV_NET_SHARE_SET_INFO    _SRV_API_CONTROL_CODE( 18 )
+#define FSCTL_SRV_NET_STATISTICS_GET    _SRV_API_CONTROL_CODE( 19 )
+#define FSCTL_SRV_MAX_API_CODE FSCTL_SRV_NET_STATISTICS_GET
+
+//
+// Startup information level
+//
+
+#define SS_STARTUP_LEVEL    -1L
+
+#ifdef  INCLUDE_SRV_IPX_SMART_CARD_INTERFACE
+
+//
+// Structure passed to the srv via the FSCTL_SRV_IPX_SMART_CARD_START call by an
+//  intelligent direct host IPX card.  The Smart card fills in its own
+//  Open, Close, Read, and DeRegister entry points - which the server
+//  calls at the appropriate times.  The server fills in its own
+//  ReadComplete entry point which the smart card calls when it is done
+//  transferring the data to the client.
+//
+typedef struct {
+    //
+    // This routine is called by the server when it is opening a file on
+    //  behalf of a direct host IPX client.  It gives the smart card a chance
+    //  to decide it it wants to help with file access.  If the smart card is
+    //  interested, it should return TRUE and set SmartCardContext to a
+    //  non-zero value of its choice.
+    //
+    BOOLEAN (* Open)(
+        IN PVOID SmbHeader,             // Points to request PNT_SMB_HEADER
+        IN PFILE_OBJECT FileObject,     // FileObject opened by the client
+        IN PUNICODE_STRING FileName,    // Name of the file opened by the client
+        IN PTDI_ADDRESS_IPX IpxAddress, // Address of the client
+        IN ULONG Flags,                 // FO_CACHE_SUPPORTED (for now)
+        OUT PVOID *SmartCardContext     // Context value returned by this routine
+        );
+
+    //
+    // This is called by the server when the file is being closed.  The context
+    //  value received at Open time is passed to this routine.
+    //
+    VOID ( * Close )(
+        IN PVOID SmartCardContext       // Same context returned by Open() above
+        );
+
+    //
+    // This is called by the server to see if the smart card wishes to handle the
+    //  client's read request.  If the card is handling the read, it should return
+    //  TRUE and the server will discontinue processing the read.  When the card is
+    //  finished handling the read, it must call ReadComplete (below) to inform the
+    //  server. If Read returns FALSE, the server handles the read as usual.  
+    //
+    BOOLEAN ( * Read )(
+        IN PVOID SmbHeader,             // Points to request PNT_SMB_HEADER
+        IN PVOID SmartCardContext,      // Same context returned by Open() above
+        IN ULONG Key,                   // Key value needed to read through locks
+        IN PVOID SrvContext             // Opaque value provided by the server
+        );
+
+    //
+    // This is the server's entry point which the smart card must call when it is
+    //  finished handling the Read request (above).
+    //
+    VOID ( * ReadComplete )(
+        IN PVOID SrvContext,            // Same as SrvContext in Read() above
+        IN PFILE_OBJECT FileObject,     // Client FileObject to which this applies
+        IN PMDL Mdl OPTIONAL,           // Mdl smart card is now finished with
+        IN ULONG Length                 // Length of data indicated by the MDL
+        );
+
+    //
+    // This is called by the server when the server wishes to disconnect from the
+    //  card.  Once this returns, the card should not call back into the server.
+    //
+    VOID ( *DeRegister )(
+        VOID
+        );
+
+
+} SRV_IPX_SMART_CARD, *PSRV_IPX_SMART_CARD;
+
+#endif
+        
+//
+// SMB_STATISTICS holds the count of SMBs and total turn around for a
+// class of SMBs.  For example, a single SMB_STATISTIC structure could
+// hold information about all read SMBs: Read, ReadAndX, ReadRaw,
+// and ReadMultiplexed.
+//
+
+typedef struct _SMB_STATISTICS {
+    LARGE_INTEGER TotalTurnaroundTime;
+    ULONG SmbCount;
+} SMB_STATISTICS, *PSMB_STATISTICS;
+
+//
+// Used to record the number of times something happened and some
+// pertinent time measure.
+//
+
+typedef struct _SRV_TIMED_COUNTER {
+    LARGE_INTEGER Time;
+    ULONG Count;
+} SRV_TIMED_COUNTER, *PSRV_TIMED_COUNTER;
+
+//
+// SRV_POOL_STATISTICS is used for tracking server pool usage, paged and
+// nonpaged.  It is only enabled with SRVDBG2 and is controlled in the
+// server module heapmgr.c.
+//
+
+typedef struct _SRV_POOL_STATISTICS {
+    ULONG TotalBlocksAllocated;
+    ULONG TotalBytesAllocated;
+    ULONG TotalBlocksFreed;
+    ULONG TotalBytesFreed;
+    ULONG BlocksInUse;
+    ULONG BytesInUse;
+    ULONG MaxBlocksInUse;
+    ULONG MaxBytesInUse;
+} SRV_POOL_STATISTICS, *PSRV_POOL_STATISTICS;
+
+//
+// BLOCK_COUNTS is used to maintain statistics on server block types
+//
+
+typedef struct _BLOCK_COUNTS {
+    ULONG Allocations;
+    ULONG Closes;
+    ULONG Frees;
+} BLOCK_COUNTS, *PBLOCK_COUNTS;
+
+#define MAX_NON_TRANS_SMB 0x84
+
+#ifndef TRANS2_MAX_FUNCTION
+#define TRANS2_MAX_FUNCTION 0x11
+#endif
+
+#define MAX_STATISTICS_SMB MAX_NON_TRANS_SMB + TRANS2_MAX_FUNCTION + 1
+
+//
+// SRV_STATISTICS is the structure returned to the FSCTL_GET_STATISTICS
+// fsctl.
+//
+
+typedef struct _SRV_STATISTICS {
+
+    //
+    // The time at which statistics gathering began (or stats were last
+    // cleared).
+    //
+
+    TIME StatisticsStartTime;
+
+    //
+    // Large integer counts of bytes received and sent
+    //
+
+    LARGE_INTEGER TotalBytesReceived;
+    LARGE_INTEGER TotalBytesSent;
+
+    //
+    // Causes of session termination
+    //
+
+    ULONG SessionLogonAttempts;
+    ULONG SessionsTimedOut;
+    ULONG SessionsErroredOut;
+    ULONG SessionsLoggedOff;
+    ULONG SessionsForcedLogOff;
+
+    //
+    // Misc. Errors
+    //
+
+    ULONG LogonErrors;
+    ULONG AccessPermissionErrors;
+    ULONG GrantedAccessErrors;
+    ULONG SystemErrors;
+    ULONG BlockingSmbsRejected;
+    ULONG WorkItemShortages;
+
+    //
+    // Cumulative counts of various statistics.  Note that when stats are
+    // cleared, those "Total" fields which have a "Current" equivalent
+    // are set to the "Current" value to avoid situations where the
+    // current count is greater than the total.
+    //
+
+    ULONG TotalFilesOpened;
+
+    ULONG CurrentNumberOfOpenFiles;
+    ULONG CurrentNumberOfSessions;
+    ULONG CurrentNumberOfOpenSearches;
+
+    //
+    // Memory usage stats we want to xport
+    //
+
+    ULONG CurrentNonPagedPoolUsage;
+    ULONG NonPagedPoolFailures;
+    ULONG PeakNonPagedPoolUsage;
+
+    ULONG CurrentPagedPoolUsage;
+    ULONG PagedPoolFailures;
+    ULONG PeakPagedPoolUsage;
+
+
+    //
+    // Used to record the number of times work context blocks were placed
+    // on the server's FSP queue and the total amount of time they spent
+    // there.
+    //
+
+    SRV_TIMED_COUNTER TotalWorkContextBlocksQueued;
+
+
+} SRV_STATISTICS, *PSRV_STATISTICS;
+
+//
+// Per work-queue statistics for the server.  There is a workqueue for each
+// processor in the system for nonblocking work, and a single workqueue for
+// blocking work.
+//
+// These statistics are retrieved via FSCTL_SRV_GET_QUEUE_STATISTICS to the
+// server driver.  For an N-processor system, the first N structs are per-processor,
+// the N+1'th struct is for the blocking work queue.
+//
+typedef struct _SRV_QUEUE_STATISTICS {
+    ULONG   QueueLength;           // current length of the workitem queue
+    ULONG   ActiveThreads;         // # of threads currently servicing requests
+    ULONG   AvailableThreads;      // # of threads waiting for work
+    ULONG   FreeWorkItems;         // # of free work items
+    ULONG   StolenWorkItems;       // # of work items taken from this free list
+                                   //   by another queue
+    ULONG   NeedWorkItem;          // # of work items we are currently short for this queue
+    ULONG   CurrentClients;        // # of clients being serviced by this queue
+    LARGE_INTEGER BytesReceived;   // # of bytes in from the network to clients on this queue
+    LARGE_INTEGER BytesSent;       // # of bytes sent to the network from clients on this queue
+    LARGE_INTEGER ReadOperations;  // # file read operations by clients on this queue
+    LARGE_INTEGER BytesRead;       // # of data bytes read from files by clients on this queue
+    LARGE_INTEGER WriteOperations; // # of file write ops by clients on this queue
+    LARGE_INTEGER BytesWritten;    // # of data bytes written to files by clients on this queue
+    SRV_TIMED_COUNTER TotalWorkContextBlocksQueued; // as above, but per-queue
+
+} SRV_QUEUE_STATISTICS, *PSRV_QUEUE_STATISTICS;
+
+//
+// SRV_STATISTICS_DEBUG is the structure used for the
+// FSCTL_SRV_GET_DEBUG_STATISTICS fsctl. This structure is valid
+// only when SRVDBG3 is set.
+//
+
+typedef struct _SRV_STATISTICS_DEBUG {
+
+    //
+    // Large integer counts of bytes read and written.
+    //
+
+    LARGE_INTEGER TotalBytesRead;
+    LARGE_INTEGER TotalBytesWritten;
+
+    //
+    // Raw reads and writes statistics
+    //
+
+    ULONG RawWritesAttempted;
+    ULONG RawWritesRejected;
+    ULONG RawReadsAttempted;
+    ULONG RawReadsRejected;
+
+    //
+    // Cumulative count of time spent opening files and closing handles.
+    //
+
+    LARGE_INTEGER TotalIoCreateFileTime;
+    LARGE_INTEGER TotalNtCloseTime;
+
+    ULONG TotalHandlesClosed;
+    ULONG TotalOpenAttempts;
+    ULONG TotalOpensForPathOperations;
+    ULONG TotalOplocksGranted;
+    ULONG TotalOplocksDenied;
+    ULONG TotalOplocksBroken;
+    ULONG OpensSatisfiedWithCachedRfcb;
+
+    ULONG FastLocksAttempted;
+    ULONG FastLocksFailed;
+    ULONG FastReadsAttempted;
+    ULONG FastReadsFailed;
+    ULONG FastUnlocksAttempted;
+    ULONG FastUnlocksFailed;
+    ULONG FastWritesAttempted;
+    ULONG FastWritesFailed;
+
+    ULONG DirectSendsAttempted;
+
+    ULONG LockViolations;
+    ULONG LockDelays;
+
+    ULONG CoreSearches;
+    ULONG CompleteCoreSearches;
+
+    //
+    // information about block types
+    //
+
+    BLOCK_COUNTS ConnectionInfo;
+    BLOCK_COUNTS EndpointInfo;
+    BLOCK_COUNTS LfcbInfo;
+    BLOCK_COUNTS MfcbInfo;
+    BLOCK_COUNTS RfcbInfo;
+    BLOCK_COUNTS SearchInfo;
+    BLOCK_COUNTS SessionInfo;
+    BLOCK_COUNTS ShareInfo;
+    BLOCK_COUNTS TransactionInfo;
+    BLOCK_COUNTS TreeConnectInfo;
+    BLOCK_COUNTS WorkContextInfo;
+    BLOCK_COUNTS WaitForOplockBreakInfo;
+
+    //
+    // Statistics for different read and write sizes.  Each element of
+    // the array corresponds to a range of IO sizes; see srv\smbsupp.c
+    // for exact correspondences.
+    //
+
+    SMB_STATISTICS ReadSize[17];
+    SMB_STATISTICS WriteSize[17];
+
+    //
+    // Statistics for each SMB type by command code.
+    //
+
+    SMB_STATISTICS Smb[MAX_STATISTICS_SMB+2+TRANS2_MAX_FUNCTION+1];
+
+    struct {
+        ULONG Depth;
+        ULONG Threads;
+        ULONG ItemsQueued;
+        ULONG MaximumDepth;
+    } QueueStatistics[3];
+
+} SRV_STATISTICS_DEBUG, *PSRV_STATISTICS_DEBUG;
+
+//
+// SET DEBUG input and output structure.  Contains off/on masks for SrvDebug
+// and SmbDebug.  The off mask is applied first, then the on mask is
+// applied.  To set the entire mask to a specific value, set the off
+// mask to all ones, and set the on mask to the desired value.  To leave
+// a mask unchanged, set both masks to 0.  SET DEBUG is also used
+// to modify other server heuristics.  HeuristicsChangeMask is used to
+// indicate which heuristics are being changed.
+//
+// On output, the structure is presented in such a way as to allow the
+// original values to be restored easily.  The output data is simply
+// passed back as input data.
+//
+
+typedef struct _FSCTL_SRV_SET_DEBUG_IN_OUT {
+    ULONG SrvDebugOff;
+    ULONG SrvDebugOn;
+    ULONG SmbDebugOff;
+    ULONG SmbDebugOn;
+    ULONG CcDebugOff;
+    ULONG CcDebugOn;
+    ULONG PbDebugOff;
+    ULONG PbDebugOn;
+    ULONG FatDebugOff;
+    ULONG FatDebugOn;
+    ULONG HeuristicsChangeMask;
+    ULONG MaxCopyReadLength;
+    ULONG MaxCopyWriteLength;
+    ULONG DumpVerbosity;
+    ULONG DumpRawLength;
+    BOOLEAN EnableOplocks;
+    BOOLEAN EnableFcbOpens;
+    BOOLEAN EnableSoftCompatibility;
+    BOOLEAN EnableRawMode;
+    BOOLEAN EnableDpcLevelProcessing;
+    BOOLEAN EnableMdlIo;
+    BOOLEAN EnableFastIo;
+    BOOLEAN DumpRequests;
+    BOOLEAN DumpResponses;
+} FSCTL_SRV_SET_DEBUG_IN_OUT, *PFSCTL_SRV_SET_DEBUG_IN_OUT;
+
+//
+// Bit assignments for server heuristics change mask.  The first group
+// contains those that are values, while the second group contains those
+// that are booleans.
+//
+
+#define SRV_HEUR_MAX_COPY_READ          0x00000001
+#define SRV_HEUR_MAX_COPY_WRITE         0x00000002
+#define SRV_HEUR_DUMP_VERBOSITY         0x00000004
+#define SRV_HEUR_DUMP_RAW_LENGTH        0x00000008
+
+#define SRV_HEUR_OPLOCKS                0x00010000
+#define SRV_HEUR_FCB_OPENS              0x00020000
+#define SRV_HEUR_SOFT_COMPATIBILITY     0x00040000
+#define SRV_HEUR_RAW_MODE               0x00080000
+#define SRV_HEUR_DPC_LEVEL_PROCESSING   0x00100000
+#define SRV_HEUR_MDL_IO                 0x00200000
+#define SRV_HEUR_FAST_IO                0x00400000
+#define SRV_HEUR_DUMP_REQUESTS          0x00800000
+#define SRV_HEUR_DUMP_RESPONSES         0x01000000
+
+//
+// Structure returned in response to FSCTL_SRV_QUERY_CONNECTIONS.
+//
+
+typedef struct _BLOCK_INFORMATION {
+    PVOID Block;
+    ULONG BlockType;
+    ULONG BlockState;
+    ULONG ReferenceCount;
+} BLOCK_INFORMATION, *PBLOCK_INFORMATION;
+
+//
+// Structure for communication between the file server and the server
+// service.
+//
+
+typedef struct _SERVER_REQUEST_PACKET {
+
+    UNICODE_STRING Name1;
+    UNICODE_STRING Name2;
+    ULONG Level;
+    ULONG ErrorCode;
+    ULONG Flags;
+
+    union {
+
+        struct {
+
+            ULONG EntriesRead;
+            ULONG TotalEntries;
+            ULONG TotalBytesNeeded;
+            ULONG ResumeHandle;
+
+        } Get;
+
+        struct {
+
+            ULONG ErrorParameter;
+
+            union {
+
+                struct {
+                    ULONG MaxUses;
+                } ShareInfo;
+
+            } Api;
+
+        } Set;
+
+    } Parameters;
+
+} SERVER_REQUEST_PACKET, *PSERVER_REQUEST_PACKET;
+
+//
+// Flags for the Flags field of the server request packet.
+//
+
+#define SRP_RETURN_SINGLE_ENTRY 0x01
+#define SRP_CLEAR_STATISTICS    0x02
+#define SRP_SET_SHARE_IN_DFS    0x04
+#define SRP_CLEAR_SHARE_IN_DFS  0x08
+
+//
+// Flag used in the XPORT_ADD function
+//
+
+#define SRP_XADD_PRIMARY_MACHINE 0x1    // this is the primary machine name
+
+//
+// #defines for the share GENERIC_MAPPING structure, which must be available
+// to both the server and the server service.
+//
+
+#define SRVSVC_SHARE_CONNECT           0x0001
+#define SRVSVC_PAUSED_SHARE_CONNECT    0x0002
+
+#define SRVSVC_SHARE_CONNECT_ALL_ACCESS ( STANDARD_RIGHTS_REQUIRED        |  \
+                                            SRVSVC_SHARE_CONNECT          |  \
+                                            SRVSVC_PAUSED_SHARE_CONNECT )
+
+#define GENERIC_SHARE_CONNECT_MAPPING { \
+    STANDARD_RIGHTS_READ |              \
+        SRVSVC_SHARE_CONNECT,           \
+    STANDARD_RIGHTS_WRITE |             \
+        SRVSVC_PAUSED_SHARE_CONNECT,    \
+    STANDARD_RIGHTS_EXECUTE,            \
+    SRVSVC_SHARE_CONNECT_ALL_ACCESS }
+
+//
+// #defines for the file GENERIC_MAPPING structure, which must be available
+// to both the server and the server service.  This structure is identical
+// to the io file generic mapping "IopFileMapping" defined in io\ioinit.c
+//
+
+#define GENERIC_SHARE_FILE_ACCESS_MAPPING {             \
+    FILE_GENERIC_READ,                                  \
+    FILE_GENERIC_WRITE,                                 \
+    FILE_GENERIC_EXECUTE,                               \
+    FILE_ALL_ACCESS }
+
+//
+// Special cases of STYPE_DISKTREE
+//
+
+#define STYPE_CDROM             104
+#define STYPE_REMOVABLE         105
+
+#endif // ndef _SRVFSCTL_