able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/base/published/smb.w
CryptoAlgo Inc b3cac27891 Add source files
2020-09-26 16:20:57 +08:00

3928 lines
159 KiB
OpenEdge ABL
Raw Blame History

This file contains invisible Unicode characters

This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

/*++
Copyright (c) Microsoft Corporation. All rights reserved.
Module Name:
smb.h
Abstract:
This file contains request and response structure definitions
for the specific parameters of each SMB command, as well as codes
for SMB commands and errors.
Author:
David R. Treadwell (davidtr) 27-Sept-1989 (from LanMan 1.2 code)
Revision History:
--*/
#ifndef _SMB_
#define _SMB_
//#include <nt.h>
//#include <smbtypes.h>
/*
Inclusion of SMB request/response structures in this file is
conditionalized in the following way:
If INCLUDE_SMB_ALL is defined, all of the structures are defined.
Otherwise, the following names, if defined, cause inclusion of the
corresponding SMB categories:
INCLUDE_SMB_ADMIN Administrative requests:
PROCESS_EXIT
NEGOTIATE
SESSION_SETUP_ANDX
LOGOFF_ANDX
INCLUDE_SMB_TREE Tree connect requests:
TREE_CONNECT
TREE_DISCONNECT
TREE_CONNECT_ANDX
INCLUDE_SMB_DIRECTORY Directory-related requests:
CREATE_DIRECTORY
DELETE_DIRECTORY
CHECK_DIRECTORY
INCLUDE_SMB_OPEN_CLOSE File open and close requests:
OPEN
CREATE
CLOSE
CREATE_TEMPORARY
CREATE_NEW
OPEN_ANDX
CLOSE_AND_TREE_DISC
INCLUDE_SMB_READ_WRITE Read and write requests:
READ
WRITE
SEEK
LOCK_AND_READ
WRITE_AND_UNLOCK
WRITE_AND_CLOSE
READ_ANDX
WRITE_ANDX
INCLUDE_SMB_FILE_CONTROL File control requests:
FLUSH
DELETE
RENAME
COPY
MOVE
INCLUDE_SMB_QUERY_SET File query/set requests:
QUERY_INFORMATION
SET_INFORMATION
QUERY_INFORMATION2
SET_INFORMATION2
QUERY_PATH_INFORMATION
SET_PATH_INFORMATION
QUERY_FILE_INFORMATION
SET_FILE_INFORMATION
INCLUDE_SMB_LOCK Lock requests (not LOCK_AND_READ)
LOCK_BYTE_RANGE
UNLOCK_BYTE_RANGE
LOCKING_ANDX
INCLUDE_SMB_RAW Raw read/write requests:
READ_RAW
WRITE_RAW
INCLUDE_SMB_MPX Multiplexed requests:
READ_MPX
WRITE_MPX
INCLUDE_SMB_SEARCH Search requests:
FIND_CLOSE2
FIND_NOTIFY_CLOSE
SEARCH
FIND
FIND_UNIQUE
FIND_CLOSE
INCLUDE_SMB_TRANSACTION Transaction and IOCTL requests:
TRANSACTION
IOCTL
TRANSACTION2
NTTRANSACTION
INCLUDE_SMB_PRINT Printer requests:
OPEN_PRINT_FILE
WRITE_PRINT_FILE
CLOSE_PRINT_FILE
GET_PRINT_QUEUE
INCLUDE_SMB_MESSAGE Message requests:
SEND_MESSAGE
SEND_BROADCAST_MESSAGE
FORWARD_USER_NAME
CANCEL_FORWARD
GET_MACHINE_NAME
SEND_START_MB_MESSAGE
SEND_END_MB_MESSAGE
SEND_TEXT_MB_MESSAGE
INCLUDE_SMB_MISC Miscellaneous requests:
QUERY_INFORMATION_SRV
ECHO
QUERY_INFORMATION_DISK
*/
#ifdef INCLUDE_SMB_ALL
#define INCLUDE_SMB_ADMIN
#define INCLUDE_SMB_TREE
#define INCLUDE_SMB_DIRECTORY
#define INCLUDE_SMB_OPEN_CLOSE
#define INCLUDE_SMB_FILE_CONTROL
#define INCLUDE_SMB_READ_WRITE
#define INCLUDE_SMB_LOCK
#define INCLUDE_SMB_RAW
#define INCLUDE_SMB_MPX
#define INCLUDE_SMB_QUERY_SET
#define INCLUDE_SMB_SEARCH
#define INCLUDE_SMB_TRANSACTION
#define INCLUDE_SMB_PRINT
#define INCLUDE_SMB_MESSAGE
#define INCLUDE_SMB_MISC
#endif // def INCLUDE_SMB_ALL
//
// Force misalignment of the following structures
//
#ifndef NO_PACKING
#include <packon.h>
#endif // ndef NO_PACKING
//
// SMB servers listen on two NETBIOS addresses to facilitate connections. The
// first one is a name formulated from the computer name by padding it with
// a number of blanks ( upto NETBIOS_NAME_LEN ). This name is registered and
// resolved using the NETBIOS name registration/resolution mechanism. They also
// register under a second name *SMBSERVER which is not a valuid netbios name
// but provides a name which can be used in NETBT session setup. This eliminates
// the need for querying the remote adapter status to obtain the name.
//
#define SMBSERVER_LOCAL_ENDPOINT_NAME "*SMBSERVER "
#define SMBSERVER_LOCAL_ENDPOINT_NAME_UNICODE L"*SMBSERVER "
//
// SMB Command code definitions:
//
// *** Start of SMB commands
#define SMB_COM_CREATE_DIRECTORY (UCHAR)0x00
#define SMB_COM_DELETE_DIRECTORY (UCHAR)0x01
#define SMB_COM_OPEN (UCHAR)0x02
#define SMB_COM_CREATE (UCHAR)0x03
#define SMB_COM_CLOSE (UCHAR)0x04
#define SMB_COM_FLUSH (UCHAR)0x05
#define SMB_COM_DELETE (UCHAR)0x06
#define SMB_COM_RENAME (UCHAR)0x07
#define SMB_COM_QUERY_INFORMATION (UCHAR)0x08
#define SMB_COM_SET_INFORMATION (UCHAR)0x09
#define SMB_COM_READ (UCHAR)0x0A
#define SMB_COM_WRITE (UCHAR)0x0B
#define SMB_COM_LOCK_BYTE_RANGE (UCHAR)0x0C
#define SMB_COM_UNLOCK_BYTE_RANGE (UCHAR)0x0D
#define SMB_COM_CREATE_TEMPORARY (UCHAR)0x0E
#define SMB_COM_CREATE_NEW (UCHAR)0x0F
#define SMB_COM_CHECK_DIRECTORY (UCHAR)0x10
#define SMB_COM_PROCESS_EXIT (UCHAR)0x11
#define SMB_COM_SEEK (UCHAR)0x12
#define SMB_COM_LOCK_AND_READ (UCHAR)0x13
#define SMB_COM_WRITE_AND_UNLOCK (UCHAR)0x14
#define SMB_COM_READ_RAW (UCHAR)0x1A
#define SMB_COM_READ_MPX (UCHAR)0x1B
#define SMB_COM_READ_MPX_SECONDARY (UCHAR)0x1C // server to redir only
#define SMB_COM_WRITE_RAW (UCHAR)0x1D
#define SMB_COM_WRITE_MPX (UCHAR)0x1E
#define SMB_COM_WRITE_MPX_SECONDARY (UCHAR)0x1F
#define SMB_COM_WRITE_COMPLETE (UCHAR)0x20 // server to redir only
#define SMB_COM_QUERY_INFORMATION_SRV (UCHAR)0x21
#define SMB_COM_SET_INFORMATION2 (UCHAR)0x22
#define SMB_COM_QUERY_INFORMATION2 (UCHAR)0x23
#define SMB_COM_LOCKING_ANDX (UCHAR)0x24
#define SMB_COM_TRANSACTION (UCHAR)0x25
#define SMB_COM_TRANSACTION_SECONDARY (UCHAR)0x26
#define SMB_COM_IOCTL (UCHAR)0x27
#define SMB_COM_IOCTL_SECONDARY (UCHAR)0x28
#define SMB_COM_COPY (UCHAR)0x29
#define SMB_COM_MOVE (UCHAR)0x2A
#define SMB_COM_ECHO (UCHAR)0x2B
#define SMB_COM_WRITE_AND_CLOSE (UCHAR)0x2C
#define SMB_COM_OPEN_ANDX (UCHAR)0x2D
#define SMB_COM_READ_ANDX (UCHAR)0x2E
#define SMB_COM_WRITE_ANDX (UCHAR)0x2F
#define SMB_COM_CLOSE_AND_TREE_DISC (UCHAR)0x31
#define SMB_COM_TRANSACTION2 (UCHAR)0x32
#define SMB_COM_TRANSACTION2_SECONDARY (UCHAR)0x33
#define SMB_COM_FIND_CLOSE2 (UCHAR)0x34
#define SMB_COM_FIND_NOTIFY_CLOSE (UCHAR)0x35
#define SMB_COM_TREE_CONNECT (UCHAR)0x70
#define SMB_COM_TREE_DISCONNECT (UCHAR)0x71
#define SMB_COM_NEGOTIATE (UCHAR)0x72
#define SMB_COM_SESSION_SETUP_ANDX (UCHAR)0x73
#define SMB_COM_LOGOFF_ANDX (UCHAR)0x74
#define SMB_COM_TREE_CONNECT_ANDX (UCHAR)0x75
#define SMB_COM_QUERY_INFORMATION_DISK (UCHAR)0x80
#define SMB_COM_SEARCH (UCHAR)0x81
#define SMB_COM_FIND (UCHAR)0x82
#define SMB_COM_FIND_UNIQUE (UCHAR)0x83
#define SMB_COM_FIND_CLOSE (UCHAR)0x84
#define SMB_COM_NT_TRANSACT (UCHAR)0xA0
#define SMB_COM_NT_TRANSACT_SECONDARY (UCHAR)0xA1
#define SMB_COM_NT_CREATE_ANDX (UCHAR)0xA2
#define SMB_COM_NT_CANCEL (UCHAR)0xA4
#define SMB_COM_NT_RENAME (UCHAR)0xA5
#define SMB_COM_OPEN_PRINT_FILE (UCHAR)0xC0
#define SMB_COM_WRITE_PRINT_FILE (UCHAR)0xC1
#define SMB_COM_CLOSE_PRINT_FILE (UCHAR)0xC2
#define SMB_COM_GET_PRINT_QUEUE (UCHAR)0xC3
#define SMB_COM_SEND_MESSAGE (UCHAR)0xD0
#define SMB_COM_SEND_BROADCAST_MESSAGE (UCHAR)0xD1
#define SMB_COM_FORWARD_USER_NAME (UCHAR)0xD2
#define SMB_COM_CANCEL_FORWARD (UCHAR)0xD3
#define SMB_COM_GET_MACHINE_NAME (UCHAR)0xD4
#define SMB_COM_SEND_START_MB_MESSAGE (UCHAR)0xD5
#define SMB_COM_SEND_END_MB_MESSAGE (UCHAR)0xD6
#define SMB_COM_SEND_TEXT_MB_MESSAGE (UCHAR)0xD7
// *** End of SMB commands
#define SMB_COM_NO_ANDX_COMMAND (UCHAR)0xFF
//
// Header for SMBs, see #4 page 10
//
// *** Note that we do NOT define PSMB_HEADER as SMB_UNALIGNED! This is
// done on the assumption that the SMB header, at least, will always
// be properly aligned. If you need to access an unaligned header,
// declare the pointer as SMB_UNALIGNED *SMB_HEADER.
//
#define SMB_SECURITY_SIGNATURE_LENGTH 8
typedef struct _SMB_HEADER {
UCHAR Protocol[4]; // Contains 0xFF,'SMB'
UCHAR Command; // Command code
UCHAR ErrorClass; // Error class
UCHAR Reserved; // Reserved for future use
_USHORT( Error ); // Error code
UCHAR Flags; // Flags
_USHORT( Flags2 ); // More flags
union {
_USHORT( Reserved2 )[6]; // Reserved for future use
struct {
_USHORT( PidHigh ); // High part of PID (NT Create And X)
union {
struct {
_ULONG( Key ); // Encryption key (IPX)
_USHORT( Sid ); // Session ID (IPX)
_USHORT( SequenceNumber ); // Sequence number (IPX)
_USHORT( Gid ); // Group ID (unused?)
};
UCHAR SecuritySignature[SMB_SECURITY_SIGNATURE_LENGTH];
// Client must send the correct Signature
// for this SMB to be accepted.
};
};
};
_USHORT( Tid ); // Authenticated user/group
_USHORT( Pid ); // Caller's process id
_USHORT( Uid ); // Unauthenticated user id
_USHORT( Mid ); // multiplex id
#ifdef NO_PACKING // ***
_USHORT( Kludge ); // *** make sure parameter structs
#endif // *** are longword aligned
} SMB_HEADER;
typedef SMB_HEADER *PSMB_HEADER;
typedef struct _NT_SMB_HEADER {
UCHAR Protocol[4]; // Contains 0xFF,'SMB'
UCHAR Command; // Command code
union {
struct {
UCHAR ErrorClass; // Error class
UCHAR Reserved; // Reserved for future use
_USHORT( Error ); // Error code
} DosError;
ULONG NtStatus; // NT-style 32-bit error code
} Status;
UCHAR Flags; // Flags
_USHORT( Flags2 ); // More flags
union {
_USHORT( Reserved2 )[6]; // Reserved for future use
struct {
_USHORT( PidHigh ); // High part of PID (NT Create And X)
union {
struct {
_ULONG( Key ); // Encryption key (IPX)
_USHORT( Sid ); // Session ID (IPX)
_USHORT( SequenceNumber ); // Sequence number (IPX)
_USHORT( Gid ); // Group ID (unused?)
};
UCHAR SecuritySignature[SMB_SECURITY_SIGNATURE_LENGTH];
// Client must send the correct Signature
// for this SMB to be accepted.
};
};
};
_USHORT( Tid ); // Authenticated user/group
_USHORT( Pid ); // Caller's process id
_USHORT( Uid ); // Unauthenticated user id
_USHORT( Mid ); // multiplex id
#ifdef NO_PACKING // ***
_USHORT( Kludge ); // *** make sure parameter structs
#endif // *** are longword aligned
} NT_SMB_HEADER;
typedef NT_SMB_HEADER *PNT_SMB_HEADER;
//
// The SMB header, protocol field, as a long.
//
#define SMB_HEADER_PROTOCOL (0xFF + ('S' << 8) + ('M' << 16) + ('B' << 24))
//
// Minimum parameter structure that can be returned. Used in returning
// error SMBs.
//
// *** Note that this structure does NOT have a Buffer field!
//
typedef struct _SMB_PARAMS {
UCHAR WordCount; // Count of parameter words = 0
_USHORT( ByteCount ); // Count of bytes that follow; min = 0
} SMB_PARAMS;
typedef SMB_PARAMS SMB_UNALIGNED *PSMB_PARAMS;
//
// Generic header for AndX commands.
//
typedef struct _GENERIC_ANDX {
UCHAR WordCount; // Count of parameter words
UCHAR AndXCommand; // Secondary (X) command; 0xFF = none
UCHAR AndXReserved; // Reserved
_USHORT( AndXOffset ); // Offset (from SMB header start)
} GENERIC_ANDX;
typedef GENERIC_ANDX SMB_UNALIGNED *PGENERIC_ANDX;
#ifdef INCLUDE_SMB_MESSAGE
//
// Cancel Forward SMB, see #1 page 35
// Function is SrvSmbCancelForward()
// SMB_COM_CANCEL_FORWARD 0xD3
//
typedef struct _REQ_CANCEL_FORWARD {
UCHAR WordCount; // Count of parameter words = 0
_USHORT( ByteCount ); // Count of data bytes; min = 2
UCHAR Buffer[1]; // Buffer containing:
//UCHAR BufferFormat; // 0x04 -- ASCII
//UCHAR ForwardedName[]; // Forwarded name
} REQ_CANCEL_FORWARD;
typedef REQ_CANCEL_FORWARD SMB_UNALIGNED *PREQ_CANCEL_FORWARD;
typedef struct _RESP_CANCEL_FORWARD {
UCHAR WordCount; // Count of parameter words = 0
_USHORT( ByteCount ); // Count of data bytes = 0
UCHAR Buffer[1]; // empty
} RESP_CANCEL_FORWARD;
typedef RESP_CANCEL_FORWARD SMB_UNALIGNED *PRESP_CANCEL_FORWARD;
#endif // def INCLUDE_SMB_MESSAGE
#ifdef INCLUDE_SMB_DIRECTORY
//
// Check Directory SMB, see #1 page 23
// Function is SrvSmbCheckDirectory()
// SMB_COM_CHECK_DIRECTORY 0x10
//
typedef struct _REQ_CHECK_DIRECTORY {
UCHAR WordCount; // Count of parameter words = 0
_USHORT( ByteCount ); // Count of data bytes; min = 2
UCHAR Buffer[1]; // Buffer containing:
//UCHAR BufferFormat; // 0x04 -- ASCII
//UCHAR DirectoryPath[]; // Directory path
} REQ_CHECK_DIRECTORY;
typedef REQ_CHECK_DIRECTORY SMB_UNALIGNED *PREQ_CHECK_DIRECTORY;
typedef struct _RESP_CHECK_DIRECTORY {
UCHAR WordCount; // Count of parameter words = 0
_USHORT( ByteCount ); // Count of data bytes = 0
UCHAR Buffer[1]; // empty
} RESP_CHECK_DIRECTORY;
typedef RESP_CHECK_DIRECTORY SMB_UNALIGNED *PRESP_CHECK_DIRECTORY;
#endif // def INCLUDE_SMB_DIRECTORY
#ifdef INCLUDE_SMB_OPEN_CLOSE
//
// Close SMB, see #1 page 10
// Function is SrvSmbClose()
// SMB_COM_CLOSE 0x04
//
typedef struct _REQ_CLOSE {
UCHAR WordCount; // Count of parameter words = 3
_USHORT( Fid ); // File handle
_ULONG( LastWriteTimeInSeconds ); // Time of last write, low and high
_USHORT( ByteCount ); // Count of data bytes = 0
UCHAR Buffer[1]; // empty
} REQ_CLOSE;
typedef REQ_CLOSE SMB_UNALIGNED *PREQ_CLOSE;
typedef struct _RESP_CLOSE {
UCHAR WordCount; // Count of parameter words = 0
_USHORT( ByteCount ); // Count of data bytes = 0
UCHAR Buffer[1]; // empty
} RESP_CLOSE;
typedef RESP_CLOSE SMB_UNALIGNED *PRESP_CLOSE;
#ifdef INCLUDE_SMB_IFMODIFIED
typedef struct _REQ_EXTENDED_CLOSE {
UCHAR WordCount; // Count of parameter words = 5
_USHORT( Fid ); // File handle
_ULONG( LastWriteTimeInSeconds ); // Time of last write, low and high
_ULONG( Flags ); // NT_CREATE_xxx
_USHORT( ByteCount ); // Count of data bytes = 0
UCHAR Buffer[1]; // empty
} REQ_EXTENDED_CLOSE;
typedef REQ_EXTENDED_CLOSE SMB_UNALIGNED *PREQ_EXTENDED_CLOSE;
#define SMB_RESP_EXTENDED_CLOSE_WORK_COUNT 32
typedef struct _RESP_EXTENDED_CLOSE {
UCHAR WordCount; // Count of parameter words = 32
_ULONG( FileAttributes ); // File attributes for creation
_ULONG( Flags ); // NT_CREATE_xxx
TIME CreationTime; // The time the file was created
TIME LastWriteTime; // The time the file was last written
TIME ChangeTime; // The time the file was last changed
LARGE_INTEGER AllocationSize; // Initial allocation size
LARGE_INTEGER EndOfFile; // The end of file offset
LARGE_INTEGER UsnValue; // The file's USN # in NTFS
LARGE_INTEGER FileReferenceNumber; //
_USHORT( ByteCount ); // Count of data bytes = 0
UCHAR Buffer[1]; // empty
} RESP_EXTENDED_CLOSE;
typedef RESP_EXTENDED_CLOSE SMB_UNALIGNED *PRESP_EXTENDED_CLOSE;
#endif // def INCLUDE_SMB_IFMODIFIED
#endif // def INCLUDE_SMB_OPEN_CLOSE
#ifdef INCLUDE_SMB_OPEN_CLOSE
//
// Close and Tree Disconnect SMB, see #? page ??
// Function is SrvSmbCloseAndTreeDisc
// SMB_COM_CLOSE_AND_TREE_DISC 0x31
//
typedef struct _REQ_CLOSE_AND_TREE_DISC {
UCHAR WordCount; // Count of parameter words
_USHORT( Fid ); // File handle
_ULONG( LastWriteTimeInSeconds );
_USHORT( ByteCount ); // Count of data bytes = 0
UCHAR Buffer[1]; // empty
} REQ_CLOSE_AND_TREE_DISC;
typedef REQ_CLOSE_AND_TREE_DISC SMB_UNALIGNED *PREQ_CLOSE_AND_TREE_DISC;
typedef struct _RESP_CLOSE_AND_TREE_DISC {
UCHAR WordCount; // Count of parameter words = 0
_USHORT( ByteCount ); // Count of data bytes = 0
UCHAR Buffer[1]; // empty
} RESP_CLOSE_AND_TREE_DISC;
typedef RESP_CLOSE_AND_TREE_DISC SMB_UNALIGNED *PRESP_CLOSE_AND_TREE_DISC;
#endif // def INCLUDE_SMB_OPEN_CLOSE
#ifdef INCLUDE_SMB_PRINT
//
// Close Print Spool File SMB, see #1 page 29
// Function is SrvSmbClosePrintSpoolFile()
// SMB_COM_CLOSE_PRINT_FILE 0xC2
//
typedef struct _REQ_CLOSE_PRINT_FILE {
UCHAR WordCount; // Count of parameter words = 1
_USHORT( Fid ); // File handle
_USHORT( ByteCount ); // Count of data bytes = 0
UCHAR Buffer[1]; // empty
} REQ_CLOSE_PRINT_FILE;
typedef REQ_CLOSE_PRINT_FILE SMB_UNALIGNED *PREQ_CLOSE_PRINT_FILE;
typedef struct _RESP_CLOSE_PRINT_FILE {
UCHAR WordCount; // Count of parameter words = 0
_USHORT( ByteCount ); // Count of data bytes = 0
UCHAR Buffer[1]; // empty
} RESP_CLOSE_PRINT_FILE;
typedef RESP_CLOSE_PRINT_FILE SMB_UNALIGNED *PRESP_CLOSE_PRINT_FILE;
#endif // def INCLUDE_SMB_PRINT
#ifdef INCLUDE_SMB_FILE_CONTROL
//
// Copy SMB, see #2 page 23
// Function is SrvSmbCopy()
// SMB_COM_COPY 0x29
//
typedef struct _REQ_COPY {
UCHAR WordCount; // Count of parameter words = 3
_USHORT( Tid2 ); // Second (target) path TID
_USHORT( OpenFunction ); // What to do if target file exists
_USHORT( Flags ); // Flags to control copy operation:
// bit 0 - target must be a file
// bit 1 - target must ba a dir.
// bit 2 - copy target mode:
// 0 = binary, 1 = ASCII
// bit 3 - copy source mode:
// 0 = binary, 1 = ASCII
// bit 4 - verify all writes
// bit 5 - tree copy
_USHORT( ByteCount ); // Count of data bytes; min = 2
UCHAR Buffer[1]; // Buffer containing:
//UCHAR SourceFileName[]; // pathname of source file
//UCHAR TargetFileName[]; // pathname of target file
} REQ_COPY;
typedef REQ_COPY SMB_UNALIGNED *PREQ_COPY;
typedef struct _RESP_COPY {
UCHAR WordCount; // Count of parameter words = 1
_USHORT( Count ); // Number of files copied
_USHORT( ByteCount ); // Count of data bytes; min = 0
UCHAR Buffer[1]; // ASCIIZ pathname of file with error
} RESP_COPY;
typedef RESP_COPY SMB_UNALIGNED *PRESP_COPY;
#endif // def INCLUDE_SMB_FILE_CONTROL
#ifdef INCLUDE_SMB_OPEN_CLOSE
//
// Create SMB, see #1 page 9
// Create New SMB, see #1 page 23
// Function is SrvSmbCreate()
// SMB_COM_CREATE 0x03
// SMB_COM_CREATE_NEW 0x0F
//
typedef struct _REQ_CREATE {
UCHAR WordCount; // Count of parameter words = 3
_USHORT( FileAttributes ); // New file attributes
_ULONG( CreationTimeInSeconds ); // Creation time
_USHORT( ByteCount ); // Count of data bytes; min = 2
UCHAR Buffer[1]; // Buffer containing:
//UCHAR BufferFormat; // 0x04 -- ASCII
//UCHAR FileName[]; // File name
} REQ_CREATE;
typedef REQ_CREATE SMB_UNALIGNED *PREQ_CREATE;
typedef struct _RESP_CREATE {
UCHAR WordCount; // Count of parameter words = 1
_USHORT( Fid ); // File handle
_USHORT( ByteCount ); // Count of data bytes = 0
UCHAR Buffer[1]; // empty
} RESP_CREATE;
typedef RESP_CREATE SMB_UNALIGNED *PRESP_CREATE;
#endif // def INCLUDE_SMB_OPEN_CLOSE
#ifdef INCLUDE_SMB_DIRECTORY
//
// Create Directory SMB, see #1 page 14
// Function is SrvSmbCreateDirectory
// SMB_COM_CREATE_DIRECTORY 0x00
//
typedef struct _REQ_CREATE_DIRECTORY {
UCHAR WordCount; // Count of parameter words = 0
_USHORT( ByteCount ); // Count of data bytes; min = 2
UCHAR Buffer[1]; // Buffer containing:
//UCHAR BufferFormat; // 0x04 -- ASCII
//UCHAR DirectoryName[]; // Directory name
} REQ_CREATE_DIRECTORY;
typedef REQ_CREATE_DIRECTORY SMB_UNALIGNED *PREQ_CREATE_DIRECTORY;
typedef struct _RESP_CREATE_DIRECTORY {
UCHAR WordCount; // Count of parameter words = 0
_USHORT( ByteCount ); // Count of data bytes = 0
UCHAR Buffer[1]; // empty
} RESP_CREATE_DIRECTORY;
typedef RESP_CREATE_DIRECTORY SMB_UNALIGNED *PRESP_CREATE_DIRECTORY;
#endif // def INCLUDE_SMB_DIRECTORY
#ifdef INCLUDE_SMB_OPEN_CLOSE
//
// Create Temporary SMB, see #1 page 21
// Function is SrvSmbCreateTemporary()
// SMB_COM_CREATE_TEMPORARY 0x0E
//
typedef struct _REQ_CREATE_TEMPORARY {
UCHAR WordCount; // Count of parameter words = 3
_USHORT( FileAttributes );
_ULONG( CreationTimeInSeconds );
_USHORT( ByteCount ); // Count of data bytes; min = 2
UCHAR Buffer[1]; // Buffer containing:
//UCHAR BufferFormat; // 0x04 -- ASCII
//UCHAR DirectoryName[]; // Directory name
} REQ_CREATE_TEMPORARY;
typedef REQ_CREATE_TEMPORARY SMB_UNALIGNED *PREQ_CREATE_TEMPORARY;
typedef struct _RESP_CREATE_TEMPORARY {
UCHAR WordCount; // Count of parameter words = 1
_USHORT( Fid ); // File handle
_USHORT( ByteCount ); // Count of data bytes; min = 2
UCHAR Buffer[1]; // Buffer containing:
//UCHAR BufferFormat; // 0x04 -- ASCII
//UCHAR FileName[]; // File name
} RESP_CREATE_TEMPORARY;
typedef RESP_CREATE_TEMPORARY SMB_UNALIGNED *PRESP_CREATE_TEMPORARY;
#endif // def INCLUDE_SMB_OPEN_CLOSE
#ifdef INCLUDE_SMB_FILE_CONTROL
//
// Delete SMB, see #1 page 16
// Function is SrvSmbDelete()
// SMB_COM_DELETE 0x06
//
typedef struct _REQ_DELETE {
UCHAR WordCount; // Count of parameter words = 1
_USHORT( SearchAttributes );
_USHORT( ByteCount ); // Count of data bytes; min = 2
UCHAR Buffer[1]; // Buffer containing:
//UCHAR BufferFormat; // 0x04 -- ASCII
//UCHAR FileName[]; // File name
} REQ_DELETE;
typedef REQ_DELETE SMB_UNALIGNED *PREQ_DELETE;
typedef struct _RESP_DELETE {
UCHAR WordCount; // Count of parameter words = 0
_USHORT( ByteCount ); // Count of data bytes = 0
UCHAR Buffer[1]; // empty
} RESP_DELETE;
typedef RESP_DELETE SMB_UNALIGNED *PRESP_DELETE;
#endif // def INCLUDE_SMB_FILE_CONTROL
#ifdef INCLUDE_SMB_DIRECTORY
//
// Delete Directory SMB, see #1 page 15
// Function is SrvSmbDeleteDirectory()
// SMB_COM_DELETE_DIRECTORY 0x01
//
typedef struct _REQ_DELETE_DIRECTORY {
UCHAR WordCount; // Count of parameter words = 0
_USHORT( ByteCount ); // Count of data bytes; min = 2
UCHAR Buffer[1]; // Buffer containing:
//UCHAR BufferFormat; // 0x04 -- ASCII
//UCHAR DirectoryName[]; // Directory name
} REQ_DELETE_DIRECTORY;
typedef REQ_DELETE_DIRECTORY SMB_UNALIGNED *PREQ_DELETE_DIRECTORY;
typedef struct _RESP_DELETE_DIRECTORY {
UCHAR WordCount; // Count of parameter words = 0
_USHORT( ByteCount ); // Count of data bytes = 0
UCHAR Buffer[1]; // empty
} RESP_DELETE_DIRECTORY;
typedef RESP_DELETE_DIRECTORY SMB_UNALIGNED *PRESP_DELETE_DIRECTORY;
#endif // def INCLUDE_SMB_DIRECTORY
#ifdef INCLUDE_SMB_MISC
//
// Echo SMB, see #2 page 25
// Function is SrvSmbEcho()
// SMB_COM_ECHO 0x2B
//
typedef struct _REQ_ECHO {
UCHAR WordCount; // Count of parameter words = 1
_USHORT( EchoCount ); // Number of times to echo data back
_USHORT( ByteCount ); // Count of data bytes; min = 4
UCHAR Buffer[1]; // Data to echo
} REQ_ECHO;
typedef REQ_ECHO SMB_UNALIGNED *PREQ_ECHO;
typedef struct _RESP_ECHO {
UCHAR WordCount; // Count of parameter words = 1
_USHORT( SequenceNumber ); // Sequence number of this echo
_USHORT( ByteCount ); // Count of data bytes; min = 4
UCHAR Buffer[1]; // Echoed data
} RESP_ECHO;
typedef RESP_ECHO SMB_UNALIGNED *PRESP_ECHO;
#endif // def INCLUDE_SMB_MISC
#ifdef INCLUDE_SMB_SEARCH
//
// Find Close2 SMB, see #3 page 54
// Function is SrvFindClose2()
// SMB_COM_FIND_CLOSE2 0x34
//
typedef struct _REQ_FIND_CLOSE2 {
UCHAR WordCount; // Count of parameter words = 1
_USHORT( Sid ); // Find handle
_USHORT( ByteCount ); // Count of data bytes = 0
UCHAR Buffer[1]; // empty
} REQ_FIND_CLOSE2;
typedef REQ_FIND_CLOSE2 SMB_UNALIGNED *PREQ_FIND_CLOSE2;
typedef struct _RESP_FIND_CLOSE2 {
UCHAR WordCount; // Count of parameter words = 0
_USHORT( ByteCount ); // Count of data bytes = 0
UCHAR Buffer[1]; // empty
} RESP_FIND_CLOSE2;
typedef RESP_FIND_CLOSE2 SMB_UNALIGNED *PRESP_FIND_CLOSE2;
#endif // def INCLUDE_SMB_SEARCH
#ifdef INCLUDE_SMB_SEARCH
//
// Find Notify Close SMB, see #3 page 53
// Function is SrvSmbFindNotifyClose()
// SMB_COM_FIND_NOTIFY_CLOSE 0x35
//
typedef struct _REQ_FIND_NOTIFY_CLOSE {
UCHAR WordCount; // Count of parameter words = 1
_USHORT( Handle ); // Find notify handle
_USHORT( ByteCount ); // Count of data bytes = 0
UCHAR Buffer[1]; // empty
} REQ_FIND_NOTIFY_CLOSE;
typedef REQ_FIND_NOTIFY_CLOSE SMB_UNALIGNED *PREQ_FIND_NOTIFY_CLOSE;
typedef struct _RESP_FIND_NOTIFY_CLOSE {
UCHAR WordCount; // Count of parameter words = 0
_USHORT( ByteCount ); // Count of data bytes = 0
UCHAR Buffer[1]; // empty
} RESP_FIND_NOTIFY_CLOSE;
typedef RESP_FIND_NOTIFY_CLOSE SMB_UNALIGNED *PRESP_FIND_NOTIFY_CLOSE;
#endif // def INCLUDE_SMB_SEARCH
#ifdef INCLUDE_SMB_FILE_CONTROL
//
// Flush SMB, see #1 page 11
// Function is SrvSmbFlush()
// SMB_COM_FLUSH 0x05
//
typedef struct _REQ_FLUSH {
UCHAR WordCount; // Count of parameter words = 1
_USHORT( Fid ); // File handle
_USHORT( ByteCount ); // Count of data bytes = 0
UCHAR Buffer[1]; // empty
} REQ_FLUSH;
typedef REQ_FLUSH SMB_UNALIGNED *PREQ_FLUSH;
typedef struct _RESP_FLUSH {
UCHAR WordCount; // Count of parameter words = 0
_USHORT( ByteCount ); // Count of data bytes = 0
UCHAR Buffer[1]; // empty
} RESP_FLUSH;
typedef RESP_FLUSH SMB_UNALIGNED *PRESP_FLUSH;
#endif // def INCLUDE_SMB_FILE_CONTROL
#ifdef INCLUDE_SMB_MESSAGE
//
// Forward User Name SMB, see #1 page 34
// Function is SrvSmbForwardUserName()
// SMB_COM_FORWARD_USER_NAME 0xD2
//
typedef struct _REQ_FORWARD_USER_NAME {
UCHAR WordCount; // Count of parameter words = 0
_USHORT( ByteCount ); // Count of data bytes; min = 2
UCHAR Buffer[1]; // Buffer containing:
//UCHAR BufferFormat; // 0x04 -- ASCII
//UCHAR ForwardedName[]; // Forwarded name
} REQ_FORWARD_USER_NAME;
typedef REQ_FORWARD_USER_NAME SMB_UNALIGNED *PREQ_FORWARD_USER_NAME;
typedef struct _RESP_FORWARD_USER_NAME {
UCHAR WordCount; // Count of parameter words = 0
_USHORT( ByteCount ); // Count of data bytes = 0
UCHAR Buffer[1]; // empty
} RESP_FORWARD_USER_NAME;
typedef RESP_FORWARD_USER_NAME SMB_UNALIGNED *PRESP_FORWARD_USER_NAME;
#endif // def INCLUDE_SMB_MESSAGE
#ifdef INCLUDE_SMB_MESSAGE
//
// Get Machine Name SMB, see #1 page 35
// Function is SrvSmbGetMachineName()
// SMB_COM_GET_MACHINE_NAME 0xD4
//
typedef struct _REQ_GET_MACHINE_NAME {
UCHAR WordCount; // Count of parameter words = 0
_USHORT( ByteCount ); // Count of data bytes = 0
UCHAR Buffer[1]; // empty
} REQ_GET_MACHINE_NAME;
typedef REQ_GET_MACHINE_NAME SMB_UNALIGNED *PREQ_GET_MACHINE_NAME;
typedef struct _RESP_GET_MACHINE_NAME {
UCHAR WordCount; // Count of parameter words = 0
_USHORT( ByteCount ); // Count of data bytes; min = 2
UCHAR Buffer[1]; // Buffer containing:
//UCHAR BufferFormat; // 0x04 -- ASCII
//UCHAR MachineName[]; // Machine name
} RESP_GET_MACHINE_NAME;
typedef RESP_GET_MACHINE_NAME SMB_UNALIGNED *PRESP_GET_MACHINE_NAME;
#endif // def INCLUDE_SMB_MESSAGE
#ifdef INCLUDE_SMB_PRINT
//
// Get Print Queue SMB, see #1 page 29
// Function is SrvSmbGetPrintQueue()
// SMB_COM_GET_PRINT_QUEUE 0xC3
//
typedef struct _REQ_GET_PRINT_QUEUE {
UCHAR WordCount; // Count of parameter words = 2
_USHORT( MaxCount ); // Max number of entries to return
_USHORT( StartIndex ); // First queue entry to return
_USHORT( ByteCount ); // Count of data bytes = 0
UCHAR Buffer[1]; // empty
} REQ_GET_PRINT_QUEUE;
typedef REQ_GET_PRINT_QUEUE SMB_UNALIGNED *PREQ_GET_PRINT_QUEUE;
typedef struct _RESP_GET_PRINT_QUEUE {
UCHAR WordCount; // Count of parameter words = 2
_USHORT( Count ); // Number of entries returned
_USHORT( RestartIndex ); // Index of entry after last returned
_USHORT( ByteCount ); // Count of data bytes; min = 3
UCHAR Buffer[1]; // Buffer containing:
//UCHAR BufferFormat; // 0x01 -- Data block
//USHORT DataLength; // Length of data
//UCHAR Data[]; // Queue elements
} RESP_GET_PRINT_QUEUE;
typedef RESP_GET_PRINT_QUEUE SMB_UNALIGNED *PRESP_GET_PRINT_QUEUE;
#endif // def INCLUDE_SMB_PRINT
#ifdef INCLUDE_SMB_TRANSACTION
//
// Ioctl SMB, see #2 page 39
// Function is SrvSmbIoctl()
// SMB_COM_IOCTL 0x27
// SMB_COM_IOCTL_SECONDARY 0x28
//
typedef struct _REQ_IOCTL {
UCHAR WordCount; // Count of parameter words = 14
_USHORT( Fid ); // File handle
_USHORT( Category ); // Device category
_USHORT( Function ); // Device function
_USHORT( TotalParameterCount ); // Total parameter bytes being sent
_USHORT( TotalDataCount ); // Total data bytes being sent
_USHORT( MaxParameterCount ); // Max parameter bytes to return
_USHORT( MaxDataCount ); // Max data bytes to return
_ULONG( Timeout );
_USHORT( Reserved );
_USHORT( ParameterCount ); // Parameter bytes sent this buffer
_USHORT( ParameterOffset ); // Offset (from header start) to params
_USHORT( DataCount ); // Data bytes sent this buffer
_USHORT( DataOffset ); // Offset (from header start) to data
_USHORT( ByteCount ); // Count of data bytes
UCHAR Buffer[1]; // Buffer containing:
//UCHAR Pad[]; // Pad to SHORT or LONG
//UCHAR Parameters[]; // Parameter bytes (# = ParameterCount)
//UCHAR Pad1[]; // Pad to SHORT or LONG
//UCHAR Data[]; // Data bytes (# = DataCount)
} REQ_IOCTL;
typedef REQ_IOCTL SMB_UNALIGNED *PREQ_IOCTL;
typedef struct _RESP_IOCTL_INTERIM {
UCHAR WordCount; // Count of parameter words = 0
_USHORT( ByteCount ); // Count of data bytes = 0
UCHAR Buffer[1]; // empty
} RESP_IOCTL_INTERIM;
typedef RESP_IOCTL_INTERIM SMB_UNALIGNED *PRESP_IOCTL_INTERIM;
typedef struct _REQ_IOCTL_SECONDARY {
UCHAR WordCount; // Count of parameter words = 8
_USHORT( TotalParameterCount ); // Total parameter bytes being sent
_USHORT( TotalDataCount ); // Total data bytes being sent
_USHORT( ParameterCount ); // Parameter bytes sent this buffer
_USHORT( ParameterOffset ); // Offset (from header start) to params
_USHORT( ParameterDisplacement ); // Displacement of these param bytes
_USHORT( DataCount ); // Data bytes sent this buffer
_USHORT( DataOffset ); // Offset (from header start) to data
_USHORT( DataDisplacement ); // Displacement of these data bytes
_USHORT( ByteCount ); // Count of data bytes
UCHAR Buffer[1]; // Buffer containing:
//UCHAR Pad[]; // Pad to SHORT or LONG
//UCHAR Parameters[]; // Parameter bytes (# = ParameterCount)
//UCHAR Pad1[]; // Pad to SHORT or LONG
//UCHAR Data[]; // Data bytes (# = DataCount)
} REQ_IOCTL_SECONDARY;
typedef REQ_IOCTL_SECONDARY SMB_UNALIGNED *PREQ_IOCTL_SECONDARY;
typedef struct _RESP_IOCTL {
UCHAR WordCount; // Count of parameter words = 8
_USHORT( TotalParameterCount ); // Total parameter bytes being sent
_USHORT( TotalDataCount ); // Total data bytes being sent
_USHORT( ParameterCount ); // Parameter bytes sent this buffer
_USHORT( ParameterOffset ); // Offset (from header start) to params
_USHORT( ParameterDisplacement ); // Displacement of these param bytes
_USHORT( DataCount ); // Data bytes sent this buffer
_USHORT( DataOffset ); // Offset (from header start) to data
_USHORT( DataDisplacement ); // Displacement of these data bytes
_USHORT( ByteCount ); // Count of data bytes
UCHAR Buffer[1]; // Buffer containing:
//UCHAR Pad[]; // Pad to SHORT or LONG
//UCHAR Parameters[]; // Parameter bytes (# = ParameterCount)
//UCHAR Pad1[]; // Pad to SHORT or LONG
//UCHAR Data[]; // Data bytes (# = DataCount)
} RESP_IOCTL;
typedef RESP_IOCTL SMB_UNALIGNED *PRESP_IOCTL;
#endif // def INCLUDE_SMB_TRANSACTION
#ifdef INCLUDE_SMB_LOCK
//
// Lock Byte Range SMB, see #1 page 20
// Function is SrvSmbLockByteRange()
// SMB_COM_LOCK_BYTE_RANGE 0x0C
//
typedef struct _REQ_LOCK_BYTE_RANGE {
UCHAR WordCount; // Count of parameter words = 5
_USHORT( Fid ); // File handle
_ULONG( Count ); // Count of bytes to lock
_ULONG( Offset ); // Offset from start of file
_USHORT( ByteCount ); // Count of data bytes = 0
UCHAR Buffer[1]; // empty
} REQ_LOCK_BYTE_RANGE;
typedef REQ_LOCK_BYTE_RANGE SMB_UNALIGNED *PREQ_LOCK_BYTE_RANGE;
typedef struct _RESP_LOCK_BYTE_RANGE {
UCHAR WordCount; // Count of parameter words = 0
_USHORT( ByteCount ); // Count of data bytes = 0
UCHAR Buffer[1]; // empty
} RESP_LOCK_BYTE_RANGE;
typedef RESP_LOCK_BYTE_RANGE SMB_UNALIGNED *PRESP_LOCK_BYTE_RANGE;
#endif // def INCLUDE_SMB_LOCK
#ifdef INCLUDE_SMB_LOCK
//
// Locking and X SMB, see #2 page 46
// Function is SrvLockingAndX()
// SMB_COM_LOCKING_ANDX 0x24
//
typedef struct _REQ_LOCKING_ANDX {
UCHAR WordCount; // Count of parameter words = 8
UCHAR AndXCommand; // Secondary (X) command; 0xFF = none
UCHAR AndXReserved; // Reserved (must be 0)
_USHORT( AndXOffset ); // Offset to next command WordCount
_USHORT( Fid ); // File handle
//
// When NT protocol is not negotiated the OplockLevel field is
// omitted, and LockType field is a full word. Since the upper
// bits of LockType are never used, this definition works for
// all protocols.
//
UCHAR( LockType ); // Locking mode:
// bit 0: 0 = lock out all access
// 1 = read OK while locked
// bit 1: 1 = 1 user total file unlock
UCHAR( OplockLevel ); // The new oplock level
_ULONG( Timeout );
_USHORT( NumberOfUnlocks ); // Num. unlock range structs following
_USHORT( NumberOfLocks ); // Num. lock range structs following
_USHORT( ByteCount ); // Count of data bytes
UCHAR Buffer[1]; // Buffer containing:
//LOCKING_ANDX_RANGE Unlocks[]; // Unlock ranges
//LOCKING_ANDX_RANGE Locks[]; // Lock ranges
} REQ_LOCKING_ANDX;
typedef REQ_LOCKING_ANDX SMB_UNALIGNED *PREQ_LOCKING_ANDX;
#define LOCKING_ANDX_SHARED_LOCK 0x01
#define LOCKING_ANDX_OPLOCK_RELEASE 0x02
#define LOCKING_ANDX_CHANGE_LOCKTYPE 0x04
#define LOCKING_ANDX_CANCEL_LOCK 0x08
#define LOCKING_ANDX_LARGE_FILES 0x10
#define OPLOCK_BROKEN_TO_NONE 0
#define OPLOCK_BROKEN_TO_II 1
typedef struct _LOCKING_ANDX_RANGE {
_USHORT( Pid ); // PID of process "owning" lock
_ULONG( Offset ); // Ofset to bytes to [un]lock
_ULONG( Length ); // Number of bytes to [un]lock
} LOCKING_ANDX_RANGE;
typedef LOCKING_ANDX_RANGE SMB_UNALIGNED *PLOCKING_ANDX_RANGE;
typedef struct _NT_LOCKING_ANDX_RANGE {
_USHORT( Pid ); // PID of process "owning" lock
_USHORT( Pad ); // Pad to DWORD align (mbz)
_ULONG( OffsetHigh ); // Ofset to bytes to [un]lock (high)
_ULONG( OffsetLow ); // Ofset to bytes to [un]lock (low)
_ULONG( LengthHigh ); // Number of bytes to [un]lock (high)
_ULONG( LengthLow ); // Number of bytes to [un]lock (low)
} NTLOCKING_ANDX_RANGE;
typedef NTLOCKING_ANDX_RANGE SMB_UNALIGNED *PNTLOCKING_ANDX_RANGE;
//
typedef struct _RESP_LOCKING_ANDX {
UCHAR WordCount; // Count of parameter words = 2
UCHAR AndXCommand; // Secondary (X) command; 0xFF = none
UCHAR AndXReserved; // Reserved (must be 0)
_USHORT( AndXOffset ); // Offset to next command WordCount
_USHORT( ByteCount ); // Count of data bytes = 0
UCHAR Buffer[1]; // empty
} RESP_LOCKING_ANDX;
typedef RESP_LOCKING_ANDX SMB_UNALIGNED *PRESP_LOCKING_ANDX;
#define LOCK_BROKEN_SIZE 51 // # of bytes in lock broken notify
#endif // def INCLUDE_SMB_LOCK
#ifdef INCLUDE_SMB_ADMIN
//
// Logoff and X SMB, see #3, page 55
// SMB_COM_LOGOFF_ANDX 0x74
//
typedef struct _REQ_LOGOFF_ANDX {
UCHAR WordCount; // Count of parameter words = 2
UCHAR AndXCommand; // Secondary (X) command; 0xFF = none
UCHAR AndXReserved; // Reserved (must be 0)
_USHORT( AndXOffset ); // Offset to next command WordCount
_USHORT( ByteCount ); // Count of data bytes = 0
UCHAR Buffer[1]; // empty
} REQ_LOGOFF_ANDX;
typedef REQ_LOGOFF_ANDX SMB_UNALIGNED *PREQ_LOGOFF_ANDX;
typedef struct _RESP_LOGOFF_ANDX {
UCHAR WordCount; // Count of parameter words = 2
UCHAR AndXCommand; // Secondary (X) command; 0xFF = none
UCHAR AndXReserved; // Reserved (must be 0)
_USHORT( AndXOffset ); // Offset to next command WordCount
_USHORT( ByteCount ); // Count of data bytes = 0
UCHAR Buffer[1]; // empty
} RESP_LOGOFF_ANDX;
typedef RESP_LOGOFF_ANDX SMB_UNALIGNED *PRESP_LOGOFF_ANDX;
#endif // def INCLUDE_SMB_ADMIN
#ifdef INCLUDE_SMB_FILE_CONTROL
//
// Move SMB, see #2 page 49
// Funcion is SrvSmbMove()
// SMB_COM_MOVE 0x2A
//
typedef struct _REQ_MOVE {
UCHAR WordCount; // Count of parameter words = 3
_USHORT( Tid2 ); // Second (target) file id
_USHORT( OpenFunction ); // what to do if target file exists
_USHORT( Flags ); // Flags to control move operations:
// 0 - target must be a file
// 1 - target must be a directory
// 2 - reserved (must be 0)
// 3 - reserved (must be 0)
// 4 - verify all writes
_USHORT( ByteCount ); // Count of data bytes; min = 2
UCHAR Buffer[1]; // Buffer containing:
//UCHAR OldFileName[]; // Old file name
//UCHAR NewFileName[]; // New file name
} REQ_MOVE;
typedef REQ_MOVE SMB_UNALIGNED *PREQ_MOVE;
typedef struct _RESP_MOVE {
UCHAR WordCount; // Count of parameter words = 1
_USHORT( Count ); // Number of files moved
_USHORT( ByteCount ); // Count of data bytes; min = 0
UCHAR Buffer[1]; // Pathname of file where error occurred
} RESP_MOVE;
typedef RESP_MOVE SMB_UNALIGNED *PRESP_MOVE;
#endif // def INCLUDE_SMB_FILE_CONTROL
#ifdef INCLUDE_SMB_ADMIN
//
// Negotiate SMB's for Net 1 and Net 3, see #1 page 25 and #2 page 20
// Function is SrvSmbNegotiate()
// SMB_COM_NEGOTIATE 0x72
//
typedef struct _REQ_NEGOTIATE {
UCHAR WordCount; // Count of parameter words = 0
_USHORT( ByteCount ); // Count of data bytes; min = 2
UCHAR Buffer[1]; // Buffer containing:
//struct {
// UCHAR BufferFormat; // 0x02 -- Dialect
// UCHAR DialectName[]; // ASCIIZ
//} Dialects[];
} REQ_NEGOTIATE;
typedef REQ_NEGOTIATE *PREQ_NEGOTIATE; // *** NOT SMB_UNALIGNED!
typedef struct _RESP_NEGOTIATE {
UCHAR WordCount; // Count of parameter words = 13
_USHORT( DialectIndex ); // Index of selected dialect
_USHORT( SecurityMode ); // Security mode:
// bit 0: 0 = share, 1 = user
// bit 1: 1 = encrypt passwords
// bit 2: 1 = SMB security signatures enabled
// bit 3: 1 = SMB security signatures required
_USHORT( MaxBufferSize ); // Max transmit buffer size
_USHORT( MaxMpxCount ); // Max pending multiplexed requests
_USHORT( MaxNumberVcs ); // Max VCs between client and server
_USHORT( RawMode ); // Raw modes supported:
// bit 0: 1 = Read Raw supported
// bit 1: 1 = Write Raw supported
_ULONG( SessionKey );
SMB_TIME ServerTime; // Current time at server
SMB_DATE ServerDate; // Current date at server
_USHORT( ServerTimeZone ); // Current time zone at server
_USHORT( EncryptionKeyLength ); // MBZ if this is not LM2.1
_USHORT( Reserved ); // MBZ
_USHORT( ByteCount ); // Count of data bytes
UCHAR Buffer[1]; // Password encryption key
//UCHAR EncryptionKey[]; // The challenge encryption key
//UCHAR PrimaryDomain[]; // The server's primary domain (2.1 only)
} RESP_NEGOTIATE;
typedef RESP_NEGOTIATE *PRESP_NEGOTIATE; // *** NOT SMB_UNALIGNED!
// Macros for SecurityMode field, above
#define NEGOTIATE_USER_SECURITY 0x01
#define NEGOTIATE_ENCRYPT_PASSWORDS 0x02
#define NEGOTIATE_SECURITY_SIGNATURES_ENABLED 0x04
#define NEGOTIATE_SECURITY_SIGNATURES_REQUIRED 0x08
// Macros for RawMode field, above
#define NEGOTIATE_READ_RAW_SUPPORTED 1
#define NEGOTIATE_WRITE_RAW_SUPPORTED 2
typedef struct _RESP_OLD_NEGOTIATE {
UCHAR WordCount; // Count of parameter words = 1
_USHORT( DialectIndex ); // Index of selected dialect
_USHORT( ByteCount ); // Count of data bytes = 0
UCHAR Buffer[1]; // empty
} RESP_OLD_NEGOTIATE;
typedef RESP_OLD_NEGOTIATE *PRESP_OLD_NEGOTIATE; // *** NOT SMB_UNALIGNED!
typedef struct _RESP_NT_NEGOTIATE {
UCHAR WordCount; // Count of parameter words = 17
_USHORT( DialectIndex ); // Index of selected dialect
UCHAR( SecurityMode ); // Security mode:
// bit 0: 0 = share, 1 = user
// bit 1: 1 = encrypt passwords
// bit 2: 1 = SMB sequence numbers enabled
// bit 3: 1 = SMB sequence numbers required
_USHORT( MaxMpxCount ); // Max pending multiplexed requests
_USHORT( MaxNumberVcs ); // Max VCs between client and server
_ULONG( MaxBufferSize ); // Max transmit buffer size
_ULONG( MaxRawSize ); // Maximum raw buffer size
_ULONG( SessionKey );
_ULONG( Capabilities ); // Server capabilities
_ULONG( SystemTimeLow ); // System (UTC) time of the server (low).
_ULONG( SystemTimeHigh ); // System (UTC) time of the server (high).
_USHORT( ServerTimeZone ); // Time zone of server (min from UTC)
UCHAR( EncryptionKeyLength ); // Length of encryption key.
_USHORT( ByteCount ); // Count of data bytes
UCHAR Buffer[1]; // Password encryption key
//for nonExtendedSecurity...
//UCHAR EncryptionKey[]; // The challenge encryption key
//UCHAR OemDomainName[]; // The name of the domain (in OEM chars)
//for ExtendedSecurity...
//UCHAR GUID[16]; // The server's GUID
//UCHAR SecurityBlob[]; // The blob
} RESP_NT_NEGOTIATE;
typedef RESP_NT_NEGOTIATE *PRESP_NT_NEGOTIATE; // *** NOT SMB_UNALIGNED!
#endif // def INCLUDE_SMB_ADMIN
//
// Server / workstation capabilities
// N.B. Most messages use a ULONG for this, so there are many more
// bits available.
//
#define CAP_RAW_MODE 0x0001
#define CAP_MPX_MODE 0x0002
#define CAP_UNICODE 0x0004
#define CAP_LARGE_FILES 0x0008
#define CAP_NT_SMBS 0x0010
#define CAP_RPC_REMOTE_APIS 0x0020
#define CAP_NT_STATUS 0x0040
#define CAP_LEVEL_II_OPLOCKS 0x0080
#define CAP_LOCK_AND_READ 0x0100
#define CAP_NT_FIND 0x0200
#define CAP_DFS 0x1000 // This server is DFS aware
#define CAP_INFOLEVEL_PASSTHRU 0x2000 // NT information level requests can pass through
#define CAP_LARGE_READX 0x4000 // Server supports oversized READ&X on files
#define CAP_LARGE_WRITEX 0x8000
#define CAP_RESERVED1 0x00100000 // Reserved for third party SMB server
#define CAP_RESERVED2 0x00200000 // Reserved for third party SMB server
#define CAP_RESERVED3 0x00400000 // Reserved for third party SMB server
#define CAP_UNIX 0x00800000 // This is a Unix SMB server
#define CAP_COMPRESSED_DATA 0x02000000
#define CAP_DYNAMIC_REAUTH 0x20000000
#ifdef INCLUDE_SMB_PERSISTENT
#define CAP_PERSISTENT_HANDLES 0x40000000 // Server supports persistent handles
#endif
#define CAP_EXTENDED_SECURITY 0x80000000 // Server supports extended
// validation.
#ifdef INCLUDE_SMB_OPEN_CLOSE
//
// Open SMB, see #1, page 7
// Function is SrvSmbOpen()
// SMB_COM_OPEN 0x02
//
typedef struct _REQ_OPEN {
UCHAR WordCount; // Count of parameter words = 2
_USHORT( DesiredAccess ); // Mode - read/write/share
_USHORT( SearchAttributes );
_USHORT( ByteCount ); // Count of data bytes; min = 2
UCHAR Buffer[1]; // Buffer containing:
//UCHAR BufferFormat; // 0x04 -- ASCII
//UCHAR FileName[]; // File name
} REQ_OPEN;
typedef REQ_OPEN SMB_UNALIGNED *PREQ_OPEN;
typedef struct _RESP_OPEN {
UCHAR WordCount; // Count of parameter words = 7
_USHORT( Fid ); // File handle
_USHORT( FileAttributes );
_ULONG( LastWriteTimeInSeconds );
_ULONG( DataSize ); // File size
_USHORT( GrantedAccess ); // Access allowed
_USHORT( ByteCount ); // Count of data bytes = 0
UCHAR Buffer[1]; // empty
} RESP_OPEN;
typedef RESP_OPEN SMB_UNALIGNED *PRESP_OPEN;
#endif // def INCLUDE_SMB_OPEN_CLOSE
#ifdef INCLUDE_SMB_OPEN_CLOSE
//
// Open and X SMB, see #2 page 51
// Function is SrvOpenAndX()
// SMB_COM_OPEN_ANDX 0x2D
//
typedef struct _REQ_OPEN_ANDX {
UCHAR WordCount; // Count of parameter words = 15
UCHAR AndXCommand; // Secondary (X) command; 0xFF = none
UCHAR AndXReserved; // Reserved (must be 0)
_USHORT( AndXOffset ); // Offset to next command WordCount
_USHORT( Flags ); // Additional information: bit set-
// 0 - return additional info
// 1 - set single user total file lock
// 2 - server notifies consumer of
// actions which may change file
// 4 - return extended response
_USHORT( DesiredAccess ); // File open mode
_USHORT( SearchAttributes );
_USHORT( FileAttributes );
_ULONG( CreationTimeInSeconds );
_USHORT( OpenFunction );
_ULONG( AllocationSize ); // Bytes to reserve on create or truncate
_ULONG( Timeout ); // Max milliseconds to wait for resource
_ULONG( Reserved ); // Reserved (must be 0)
_USHORT( ByteCount ); // Count of data bytes; min = 1
UCHAR Buffer[1]; // File name
} REQ_OPEN_ANDX;
typedef REQ_OPEN_ANDX SMB_UNALIGNED *PREQ_OPEN_ANDX;
typedef struct _RESP_OPEN_ANDX {
UCHAR WordCount; // Count of parameter words = 15
UCHAR AndXCommand; // Secondary (X) command; 0xFF = none
UCHAR AndXReserved; // Reserved (must be 0)
_USHORT( AndXOffset ); // Offset to next command WordCount
_USHORT( Fid ); // File handle
_USHORT( FileAttributes );
_ULONG( LastWriteTimeInSeconds );
_ULONG( DataSize ); // Current file size
_USHORT( GrantedAccess ); // Access permissions actually allowed
_USHORT( FileType );
_USHORT( DeviceState ); // state of IPC device (e.g. pipe)
_USHORT( Action ); // Action taken
_ULONG( ServerFid ); // Server unique file id
_USHORT( Reserved ); // Reserved (must be 0)
_USHORT( ByteCount ); // Count of data bytes = 0
UCHAR Buffer[1]; // empty
} RESP_OPEN_ANDX;
typedef RESP_OPEN_ANDX SMB_UNALIGNED *PRESP_OPEN_ANDX;
typedef struct _RESP_EXTENDED_OPEN_ANDX {
UCHAR WordCount; // Count of parameter words = 15
UCHAR AndXCommand; // Secondary (X) command; 0xFF = none
UCHAR AndXReserved; // Reserved (must be 0)
_USHORT( AndXOffset ); // Offset to next command WordCount
_USHORT( Fid ); // File handle
_USHORT( FileAttributes );
_ULONG( LastWriteTimeInSeconds );
_ULONG( DataSize ); // Current file size
_USHORT( GrantedAccess ); // Access permissions actually allowed
_USHORT( FileType );
_USHORT( DeviceState ); // state of IPC device (e.g. pipe)
_USHORT( Action ); // Action taken
_ULONG( ServerFid ); // Server unique file id
_USHORT( Reserved ); // Reserved (must be 0)
_ULONG( MaximalAccessRights ); // maximal access rights for user
_ULONG( GuestMaximalAccessRights ); // maximal access rights for guest
_USHORT( ByteCount ); // Count of data bytes = 0
UCHAR Buffer[1]; // empty
} RESP_EXTENDED_OPEN_ANDX;
typedef RESP_EXTENDED_OPEN_ANDX SMB_UNALIGNED *PRESP_EXTENDED_OPEN_ANDX;
typedef struct _REQ_NT_CREATE_ANDX {
UCHAR WordCount; // Count of parameter words = 24
UCHAR AndXCommand; // Secondary command; 0xFF = None
UCHAR AndXReserved; // MBZ
_USHORT( AndXOffset ); // Offset to next command wordcount
UCHAR Reserved; // MBZ
_USHORT( NameLength ); // Length of Name[] in bytes
_ULONG( Flags ); // Create flags NT_CREATE_xxx
_ULONG( RootDirectoryFid ); // If non-zero, open is relative to this directory
ACCESS_MASK DesiredAccess; // NT access desired
LARGE_INTEGER AllocationSize; // Initial allocation size
_ULONG( FileAttributes ); // File attributes for creation
_ULONG( ShareAccess ); // Type of share access
_ULONG( CreateDisposition ); // Action to take if file exists or not
_ULONG( CreateOptions ); // Options to use if creating a file
_ULONG( ImpersonationLevel ); // Security QOS information
UCHAR SecurityFlags; // Security QOS information
_USHORT( ByteCount ); // Length of byte parameters
UCHAR Buffer[1];
//UCHAR Name[]; // File to open or create
} REQ_NT_CREATE_ANDX;
typedef REQ_NT_CREATE_ANDX SMB_UNALIGNED *PREQ_NT_CREATE_ANDX;
// Flag bit for Security flags
#define SMB_SECURITY_DYNAMIC_TRACKING 0x01
#define SMB_SECURITY_EFFECTIVE_ONLY 0x02
typedef struct _RESP_NT_CREATE_ANDX {
UCHAR WordCount; // Count of parameter words = 26
UCHAR AndXCommand; // Secondary command; 0xFF = None
UCHAR AndXReserved; // MBZ
_USHORT( AndXOffset ); // Offset to next command wordcount
UCHAR OplockLevel; // The oplock level granted
_USHORT( Fid ); // The file ID
_ULONG( CreateAction ); // The action taken
TIME CreationTime; // The time the file was created
TIME LastAccessTime; // The time the file was accessed
TIME LastWriteTime; // The time the file was last written
TIME ChangeTime; // The time the file was last changed
_ULONG( FileAttributes ); // The file attributes
LARGE_INTEGER AllocationSize; // The number of byes allocated
LARGE_INTEGER EndOfFile; // The end of file offset
_USHORT( FileType );
union {
_USHORT( DeviceState ); // state of IPC device (e.g. pipe)
_USHORT( FileStatusFlags ); // if a file or directory. See below.
};
BOOLEAN Directory; // TRUE if this is a directory
_USHORT( ByteCount ); // = 0
UCHAR Buffer[1];
} RESP_NT_CREATE_ANDX;
typedef RESP_NT_CREATE_ANDX SMB_UNALIGNED *PRESP_NT_CREATE_ANDX;
typedef struct _RESP_EXTENDED_NT_CREATE_ANDX {
UCHAR WordCount; // Count of parameter words = 42
UCHAR AndXCommand; // Secondary command; 0xFF = None
UCHAR AndXReserved; // MBZ
_USHORT( AndXOffset ); // Offset to next command wordcount
UCHAR OplockLevel; // The oplock level granted
_USHORT( Fid ); // The file ID
_ULONG( CreateAction ); // The action taken
TIME CreationTime; // The time the file was created
TIME LastAccessTime; // The time the file was accessed
TIME LastWriteTime; // The time the file was last written
TIME ChangeTime; // The time the file was last changed
_ULONG( FileAttributes ); // The file attributes
LARGE_INTEGER AllocationSize; // The number of byes allocated
LARGE_INTEGER EndOfFile; // The end of file offset
_USHORT( FileType );
union {
_USHORT( DeviceState ); // state of the pipe
_USHORT( FileStatusFlags ); // if a file or directory. See below.
};
BOOLEAN Directory; // TRUE if this is a directory
UCHAR VolumeGuid[16]; // the volume GUID
UCHAR FileId[8]; // the file id
_ULONG ( MaximalAccessRights ); // the access rights for the session owner
_ULONG ( GuestMaximalAccessRights ); // the maximal access rights for guest
_USHORT( ByteCount ); // = 0
UCHAR Buffer[1];
} RESP_EXTENDED_NT_CREATE_ANDX;
typedef RESP_EXTENDED_NT_CREATE_ANDX SMB_UNALIGNED *PRESP_EXTENDED_NT_CREATE_ANDX;
//
// This request is identical to REQ_NT_CREATE_ANDX up to CreationTime.
// The SMB command code is the same, Flags has NT_CREATE_IFMODIFIED_REQUEST
// ORed in.
//
#ifdef INCLUDE_SMB_IFMODIFIED
#define SMB_REQ_EXTENDED_NT_CREATE_ANDX2_WORK_COUNT 48
typedef struct _REQ_NT_CREATE_IF_MODIFIED_ANDX {
UCHAR WordCount; // Count of parameter words = 48
UCHAR AndXCommand; // Secondary command; 0xFF = None
UCHAR AndXReserved; // MBZ
_USHORT( AndXOffset ); // Offset to next command wordcount
UCHAR Reserved; // MBZ
_USHORT( NameLength ); // Length of Name[] in bytes
_ULONG( Flags ); // Create flags NT_CREATE_xxx
_ULONG( RootDirectoryFid ); // If non-zero, open is relative to this directory
ACCESS_MASK DesiredAccess; // NT access desired
LARGE_INTEGER AllocationSize; // Initial allocation size
_ULONG( FileAttributes ); // File attributes for creation
_ULONG( ShareAccess ); // Type of share access
_ULONG( CreateDisposition ); // Action to take if file exists or not
_ULONG( CreateOptions ); // Options to use if creating a file
_ULONG( ImpersonationLevel ); // Security QOS information
UCHAR SecurityFlags; // Security QOS information
// the following fields are filled in by the client, if they all match the
// current file (and attributes also matches), the file is closed
// automatically and returns with status code of STATUS_FILE_CLOSED.
TIME CreationTime; // The time the file was created
TIME LastWriteTime; // The time the file was last written
TIME ChangeTime; // The time the file was last changed
LARGE_INTEGER EndOfFile; // The end of file offset
LARGE_INTEGER UsnValue; // The file's USN # in NTFS
LARGE_INTEGER FileReferenceNumber; //
_USHORT( ByteCount ); // Length of byte parameters
UCHAR Buffer[1];
//UCHAR Name[]; // File to open or create
} REQ_NT_CREATE_IF_MODIFIED_ANDX;
typedef REQ_NT_CREATE_IF_MODIFIED_ANDX SMB_UNALIGNED *PREQ_NT_CREATE_IF_MODIFIED_ANDX;
#define SMB_SHORT_NAME_LENGTH 13
#define SMB_RESP_EXTENDED_NT_CREATE_ANDX2_WORK_COUNT 71
typedef struct _RESP_EXTENDED_NT_CREATE_ANDX2 {
UCHAR WordCount; // Count of parameter words = 71
UCHAR AndXCommand; // Secondary command; 0xFF = None
UCHAR AndXReserved; // MBZ
_USHORT( AndXOffset ); // Offset to next command wordcount
UCHAR OplockLevel; // The oplock level granted
_USHORT( Fid ); // The file ID
_ULONG( CreateAction ); // The action taken
TIME CreationTime; // The time the file was created
TIME LastAccessTime; // The time the file was accessed
TIME LastWriteTime; // The time the file was last written
TIME ChangeTime; // The time the file was last changed
_ULONG( FileAttributes ); // The file attributes
LARGE_INTEGER AllocationSize; // The number of byes allocated
LARGE_INTEGER EndOfFile; // The end of file offset
_USHORT( FileType );
union {
_USHORT( DeviceState ); // state of the pipe
_USHORT( FileStatusFlags ); // if a file or directory. See below.
};
BOOLEAN Directory; // TRUE if this is a directory
UCHAR VolumeGuid[16]; // the volume GUID
UCHAR FileId[8]; // the file id
_ULONG ( MaximalAccessRights ); // the access rights for the session owner
_ULONG ( GuestMaximalAccessRights ); // the maximal access rights for guest
// below here is where it differs from RESP_EXTENDED_NT_CREATE_ANDX
LARGE_INTEGER UsnValue; // The file's USN # in NTFS
LARGE_INTEGER FileReferenceNumber; //
WCHAR ShortName[SMB_SHORT_NAME_LENGTH]; // null terminated. if not present, empty string.
_USHORT( ByteCount ); // length of long name
WCHAR Buffer[1]; // long name goes here in unicode
} RESP_EXTENDED_NT_CREATE_ANDX2;
typedef RESP_EXTENDED_NT_CREATE_ANDX2 SMB_UNALIGNED *PRESP_EXTENDED_NT_CREATE_ANDX2;
#endif // def INCLUDE_SMB_IFMODIFIED
//
// Values for FileStatusFlags, if the opened resource is a file or directory
//
#define SMB_FSF_NO_EAS 0x0001 // file/dir has no extended attributes
#define SMB_FSF_NO_SUBSTREAMS 0x0002 // file/dir has no substreams
#define SMB_FSF_NO_REPARSETAG 0x0004 // file/dir is not a reparse point
#define SMB_OPLOCK_LEVEL_NONE 0
#define SMB_OPLOCK_LEVEL_EXCLUSIVE 1
#define SMB_OPLOCK_LEVEL_BATCH 2
#define SMB_OPLOCK_LEVEL_II 3
#endif // def INCLUDE_SMB_OPEN_CLOSE
#ifdef INCLUDE_SMB_PRINT
//
// Open Print File SMB, see #1 page 27
// Function is SrvSmbOpenPrintFile()
// SMB_COM_OPEN_PRINT_FILE 0xC0
//
typedef struct _REQ_OPEN_PRINT_FILE {
UCHAR WordCount; // Count of parameter words = 2
_USHORT( SetupLength ); // Length of printer setup data
_USHORT( Mode ); // 0 = Text mode (DOS expands TABs)
// 1 = Graphics mode
_USHORT( ByteCount ); // Count of data bytes; min = 2
UCHAR Buffer[1]; // Buffer containing:
//UCHAR BufferFormat; // 0x04 -- ASCII
//UCHAR IdentifierString[]; // Identifier string
} REQ_OPEN_PRINT_FILE;
typedef REQ_OPEN_PRINT_FILE SMB_UNALIGNED *PREQ_OPEN_PRINT_FILE;
typedef struct _RESP_OPEN_PRINT_FILE {
UCHAR WordCount; // Count of parameter words = 1
_USHORT( Fid ); // File handle
_USHORT( ByteCount ); // Count of data bytes = 0
UCHAR Buffer[1]; // empty
} RESP_OPEN_PRINT_FILE;
typedef RESP_OPEN_PRINT_FILE SMB_UNALIGNED *PRESP_OPEN_PRINT_FILE;
#endif // def INCLUDE_SMB_PRINT
#ifdef INCLUDE_SMB_ADMIN
//
// Process Exit SMB, see #1 page 22
// Function is SrvSmbProcessExit()
// SMB_COM_PROCESS_EXIT 0x11
//
typedef struct _REQ_PROCESS_EXIT {
UCHAR WordCount; // Count of parameter words = 0
_USHORT( ByteCount ); // Count of data bytes = 0
UCHAR Buffer[1]; // empty
} REQ_PROCESS_EXIT;
typedef REQ_PROCESS_EXIT SMB_UNALIGNED *PREQ_PROCESS_EXIT;
typedef struct _RESP_PROCESS_EXIT {
UCHAR WordCount; // Count of parameter words = 0
_USHORT( ByteCount ); // Count of data bytes = 0
UCHAR Buffer[1]; // empty
} RESP_PROCESS_EXIT;
typedef RESP_PROCESS_EXIT SMB_UNALIGNED *PRESP_PROCESS_EXIT;
#endif // def INCLUDE_SMB_ADMIN
#ifdef INCLUDE_SMB_QUERY_SET
//
// Query Information SMB, see #1 page 18
// Function is SrvSmbQueryInformation()
// SMB_COM_QUERY_INFORMATION 0x08
//
typedef struct _REQ_QUERY_INFORMATION {
UCHAR WordCount; // Count of parameter words = 0
_USHORT( ByteCount ); // Count of data bytes; min = 2
UCHAR Buffer[1]; // Buffer containing:
//UCHAR BufferFormat; // 0x04 -- ASCII
//UCHAR FileName[]; // File name
} REQ_QUERY_INFORMATION;
typedef REQ_QUERY_INFORMATION SMB_UNALIGNED *PREQ_QUERY_INFORMATION;
typedef struct _RESP_QUERY_INFORMATION {
UCHAR WordCount; // Count of parameter words = 10
_USHORT( FileAttributes );
_ULONG( LastWriteTimeInSeconds );
_ULONG( FileSize ); // File size
_USHORT( Reserved )[5]; // Reserved (must be 0)
_USHORT( ByteCount ); // Count of data bytes = 0
UCHAR Buffer[1]; // empty
} RESP_QUERY_INFORMATION;
typedef RESP_QUERY_INFORMATION SMB_UNALIGNED *PRESP_QUERY_INFORMATION;
#endif // def INCLUDE_SMB_QUERY_SET
#ifdef INCLUDE_SMB_QUERY_SET
//
// Query Information2 SMB, see #2 page 37
// Function is SrvSmbQueryInformation2()
// SMB_COM_QUERY_INFORMATION2 0x23
//
typedef struct _REQ_QUERY_INFORMATION2 {
UCHAR WordCount; // Count of parameter words = 2
_USHORT( Fid ); // File handle
_USHORT( ByteCount ); // Count of data bytes = 0
UCHAR Buffer[1]; // empty
} REQ_QUERY_INFORMATION2;
typedef REQ_QUERY_INFORMATION2 SMB_UNALIGNED *PREQ_QUERY_INFORMATION2;
typedef struct _RESP_QUERY_INFORMATION2 {
UCHAR WordCount; // Count of parameter words = 11
SMB_DATE CreationDate;
SMB_TIME CreationTime;
SMB_DATE LastAccessDate;
SMB_TIME LastAccessTime;
SMB_DATE LastWriteDate;
SMB_TIME LastWriteTime;
_ULONG( FileDataSize ); // File end of data
_ULONG( FileAllocationSize ); // File allocation size
_USHORT( FileAttributes );
_USHORT( ByteCount ); // Count of data bytes; min = 0
UCHAR Buffer[1]; // Reserved buffer
} RESP_QUERY_INFORMATION2;
typedef RESP_QUERY_INFORMATION2 SMB_UNALIGNED *PRESP_QUERY_INFORMATION2;
#endif // def INCLUDE_SMB_QUERY_SET
#ifdef INCLUDE_SMB_MISC
//
// Query Information Disk SMB, see #1 page 24
// Function is SrvSmbQueryInformationDisk()
// SMB_COM_QUERY_INFORMATION_DISK 0x80
//
typedef struct _REQ_QUERY_INFORMATION_DISK {
UCHAR WordCount; // Count of parameter words = 0
_USHORT( ByteCount ); // Count of data bytes = 0
UCHAR Buffer[1]; // empty
} REQ_QUERY_INFORMATION_DISK;
typedef REQ_QUERY_INFORMATION_DISK SMB_UNALIGNED *PREQ_QUERY_INFORMATION_DISK;
typedef struct _RESP_QUERY_INFORMATION_DISK {
UCHAR WordCount; // Count of parameter words = 5
_USHORT( TotalUnits ); // Total allocation units per server
_USHORT( BlocksPerUnit ); // Blocks per allocation unit
_USHORT( BlockSize ); // Block size (in bytes)
_USHORT( FreeUnits ); // Number of free units
_USHORT( Reserved ); // Reserved (media identification code)
_USHORT( ByteCount ); // Count of data bytes = 0
UCHAR Buffer[1]; // empty
} RESP_QUERY_INFORMATION_DISK;
typedef RESP_QUERY_INFORMATION_DISK SMB_UNALIGNED *PRESP_QUERY_INFORMATION_DISK;
#endif // def INCLUDE_SMB_MISC
#ifdef INCLUDE_SMB_MISC
//
// Query Server Information SMB, see #? page ??
// Function is SrvSmbQueryInformationServer
// SMB_COM_QUERY_INFORMATION_SRV 0x21
//
typedef struct _REQ_QUERY_INFORMATION_SRV {
UCHAR WordCount; // Count of parameter words = 1
_USHORT( Mode );
_USHORT( ByteCount ); // Count of data bytes; min =
UCHAR Buffer[1]; //
} REQ_QUERY_INFORMATION_SRV;
typedef REQ_QUERY_INFORMATION_SRV SMB_UNALIGNED *PREQ_QUERY_INFORMATION_SRV;
typedef struct _RESP_QUERY_INFORMATION_SRV {
UCHAR WordCount; // Count of parameter words = 20
_ULONG( smb_fsid );
_ULONG( BlocksPerUnit );
_ULONG( smb_aunits );
_ULONG( smb_fau );
_USHORT( BlockSize );
SMB_DATE smb_vldate;
SMB_TIME smb_vltime;
UCHAR smb_vllen;
UCHAR Reserved; // Reserved (must be 0)
_USHORT( SecurityMode );
_USHORT( BlockMode );
_ULONG( Services );
_USHORT( MaxTransmitSize );
_USHORT( MaxMpxCount );
_USHORT( MaxNumberVcs );
SMB_TIME ServerTime;
SMB_DATE ServerDate;
_USHORT( ServerTimeZone );
_ULONG( Reserved2 );
_USHORT( ByteCount ); // Count of data bytes; min =
UCHAR Buffer[1]; //
} RESP_QUERY_INFORMATION_SRV;
typedef RESP_QUERY_INFORMATION_SRV SMB_UNALIGNED *PRESP_QUERY_INFORMATION_SRV;
#endif // def INCLUDE_SMB_MISC
#ifdef INCLUDE_SMB_READ_WRITE
//
// Read SMB, see #1 page 12
// Lock and Read SMB, see #2 page 44
// SMB_COM_READ 0x0A, Function is SrvSmbRead
// SMB_COM_LOCK_AND_READ 0x13, Function is SrvSmbLockAndRead
//
typedef struct _REQ_READ {
UCHAR WordCount; // Count of parameter words = 5
_USHORT( Fid ); // File handle
_USHORT( Count ); // Count of bytes being requested
_ULONG( Offset ); // Offset in file of first byte to read
_USHORT( Remaining ); // Estimate of bytes to read if nonzero
_USHORT( ByteCount ); // Count of data bytes = 0
UCHAR Buffer[1]; // empty
} REQ_READ;
typedef REQ_READ SMB_UNALIGNED *PREQ_READ;
//
// *** Warning: the following structure is defined the way it is to
// ensure longword alignment of the data buffer. (This only matters
// when packing is disabled; when packing is turned on, the right
// thing happens no matter what.)
//
typedef struct _RESP_READ {
UCHAR WordCount; // Count of parameter words = 5
_USHORT( Count ); // Count of bytes actually returned
_USHORT( Reserved )[4]; // Reserved (must be 0)
_USHORT( ByteCount ); // Count of data bytes
//UCHAR Buffer[1]; // Buffer containing:
UCHAR BufferFormat; // 0x01 -- Data block
_USHORT( DataLength ); // Length of data
ULONG Buffer[1]; // Data
} RESP_READ;
typedef RESP_READ SMB_UNALIGNED *PRESP_READ;
#endif // def INCLUDE_SMB_READ_WRITE
#ifdef INCLUDE_SMB_READ_WRITE
//
// Read and X SMB, see #2 page 56
// Function is SrvSmbReadAndX()
// SMB_COM_READ_ANDX 0x2E
//
typedef struct _REQ_READ_ANDX {
UCHAR WordCount; // Count of parameter words = 10
UCHAR AndXCommand; // Secondary (X) command; 0xFF = none
UCHAR AndXReserved; // Reserved (must be 0)
_USHORT( AndXOffset ); // Offset to next command WordCount
_USHORT( Fid ); // File handle
_ULONG( Offset ); // Offset in file to begin read
_USHORT( MaxCount ); // Max number of bytes to return
_USHORT( MinCount ); // Min number of bytes to return
_ULONG( Timeout );
_USHORT( Remaining ); // Bytes remaining to satisfy request
_USHORT( ByteCount ); // Count of data bytes = 0
UCHAR Buffer[1]; // empty
} REQ_READ_ANDX;
typedef REQ_READ_ANDX SMB_UNALIGNED *PREQ_READ_ANDX;
typedef struct _REQ_NT_READ_ANDX {
UCHAR WordCount; // Count of parameter words = 12
UCHAR AndXCommand; // Secondary (X) command; 0xFF = none
UCHAR AndXReserved; // Reserved (must be 0)
_USHORT( AndXOffset ); // Offset to next command WordCount
_USHORT( Fid ); // File handle
_ULONG( Offset ); // Offset in file to begin read
_USHORT( MaxCount ); // Max number of bytes to return
_USHORT( MinCount ); // Min number of bytes to return
union {
_ULONG( Timeout );
_USHORT( MaxCountHigh ); // upper 16 bits of MaxCount if NT request
};
_USHORT( Remaining ); // Bytes remaining to satisfy request
_ULONG( OffsetHigh ); // Used for NT Protocol only
// Upper 32 bits of offset
_USHORT( ByteCount ); // Count of data bytes = 0
UCHAR Buffer[1]; // empty
} REQ_NT_READ_ANDX;
typedef REQ_NT_READ_ANDX SMB_UNALIGNED *PREQ_NT_READ_ANDX;
typedef struct _RESP_READ_ANDX {
UCHAR WordCount; // Count of parameter words = 12
UCHAR AndXCommand; // Secondary (X) command; 0xFF = none
UCHAR AndXReserved; // Reserved (must be 0)
_USHORT( AndXOffset ); // Offset to next command WordCount
_USHORT( Remaining ); // Bytes remaining to be read
_USHORT( DataCompactionMode );
union {
_USHORT(CdiLength); // COMPRESSED_DATA_INFO length
_USHORT( Reserved ); // Reserved (must be 0)
};
_USHORT( DataLength ); // Number of data bytes (min = 0)
_USHORT( DataOffset ); // Offset (from header start) to data
union {
_USHORT( Reserved2 ); // Reserved (must be 0)
_USHORT( DataLengthHigh ); // upper 16 bits of DataLength if NT request
};
_ULONG( Reserved3 )[2]; // Reserved (must be 0)
_USHORT( ByteCount ); // Count of data bytes. Inaccurate if we
// are doing large Read&X's!
UCHAR Buffer[1]; // Buffer containing:
//UCHAR Pad[]; // Pad to SHORT or LONG
//UCHAR Data[]; // Data (size = DataLength)
} RESP_READ_ANDX;
typedef RESP_READ_ANDX SMB_UNALIGNED *PRESP_READ_ANDX;
#endif // def INCLUDE_SMB_READ_WRITE
#ifdef INCLUDE_SMB_MPX
//
// Read Block Multiplexed SMB, see #2 page 58
// Function is SrvSmbReadMpx()
// SMB_COM_READ_MPX 0x1B
// SMB_COM_READ_MPX_SECONDARY 0x1C
//
typedef struct _REQ_READ_MPX {
UCHAR WordCount; // Count of parameter words = 8
_USHORT( Fid ); // File handle
_ULONG( Offset ); // Offset in file to begin read
_USHORT( MaxCount ); // Max bytes to return (max 65535)
_USHORT( MinCount ); // Min bytes to return (normally 0)
_ULONG( Timeout );
_USHORT( Reserved );
_USHORT( ByteCount ); // Count of data bytes = 0
UCHAR Buffer[1]; // empty
} REQ_READ_MPX;
typedef REQ_READ_MPX SMB_UNALIGNED *PREQ_READ_MPX;
typedef struct _RESP_READ_MPX {
UCHAR WordCount; // Count of parameter words = 8
_ULONG( Offset ); // Offset in file where data read
_USHORT( Count ); // Total bytes being returned
_USHORT( Remaining ); // Bytes remaining to be read (pipe/dev)
_USHORT( DataCompactionMode );
_USHORT( Reserved );
_USHORT( DataLength ); // Number of data bytes this buffer
_USHORT( DataOffset ); // Offset (from header start) to data
_USHORT( ByteCount ); // Count of data bytes
UCHAR Buffer[1]; // Buffer containing:
//UCHAR Pad[]; // Pad to SHORT or LONG
//UCHAR Data[]; // Data (size = DataLength)
} RESP_READ_MPX;
typedef RESP_READ_MPX SMB_UNALIGNED *PRESP_READ_MPX;
#endif // def INCLUDE_SMB_MPX
#ifdef INCLUDE_SMB_RAW
//
// Read Block Raw SMB, see #2 page 61
// Function is SrvSmbReadRaw()
// SMB_COM_READ_RAW 0x1A
//
typedef struct _REQ_READ_RAW {
UCHAR WordCount; // Count of parameter words = 8
_USHORT( Fid ); // File handle
_ULONG( Offset ); // Offset in file to begin read
_USHORT( MaxCount ); // Max bytes to return (max 65535)
_USHORT( MinCount ); // Min bytes to return (normally 0)
_ULONG( Timeout );
_USHORT( Reserved );
_USHORT( ByteCount ); // Count of data bytes = 0
UCHAR Buffer[1]; // empty
} REQ_READ_RAW;
typedef REQ_READ_RAW SMB_UNALIGNED *PREQ_READ_RAW;
typedef struct _REQ_NT_READ_RAW {
UCHAR WordCount; // Count of parameter words = 10
_USHORT( Fid ); // File handle
_ULONG( Offset ); // Offset in file to begin read
_USHORT( MaxCount ); // Max bytes to return (max 65535)
_USHORT( MinCount ); // Min bytes to return (normally 0)
_ULONG( Timeout );
_USHORT( Reserved );
_ULONG( OffsetHigh ); // Used for NT Protocol only
// Upper 32 bits of offset
_USHORT( ByteCount ); // Count of data bytes = 0
UCHAR Buffer[1]; // empty
} REQ_NT_READ_RAW;
typedef REQ_NT_READ_RAW SMB_UNALIGNED *PREQ_NT_READ_RAW;
// No response params for raw read--the response is the raw data.
#endif // def INCLUDE_SMB_RAW
#ifdef INCLUDE_SMB_FILE_CONTROL
//
// Rename SMB, see #1 page 17
// Function is SrvSmbRename()
// SMB_COM_RENAME 0x07
//
typedef struct _REQ_RENAME {
UCHAR WordCount; // Count of parameter words = 1
_USHORT( SearchAttributes );
_USHORT( ByteCount ); // Count of data bytes; min = 4
UCHAR Buffer[1]; // Buffer containing:
//UCHAR BufferFormat1; // 0x04 -- ASCII
//UCHAR OldFileName[]; // Old file name
//UCHAR BufferFormat2; // 0x04 -- ASCII
//UCHAR NewFileName[]; // New file name
} REQ_RENAME;
typedef REQ_RENAME SMB_UNALIGNED *PREQ_RENAME;
//
// Extended NT rename SMB
// Function is SrvSmbRename()
// SMB_COM_NT_RENAME 0xA5
//
typedef struct _REQ_NTRENAME {
UCHAR WordCount; // Count of parameter words = 4
_USHORT( SearchAttributes );
_USHORT( InformationLevel );
_ULONG( ClusterCount );
_USHORT( ByteCount ); // Count of data bytes; min = 4
UCHAR Buffer[1]; // Buffer containing:
//UCHAR BufferFormat1; // 0x04 -- ASCII
//UCHAR OldFileName[]; // Old file name
//UCHAR BufferFormat2; // 0x04 -- ASCII
//UCHAR NewFileName[]; // New file name
} REQ_NTRENAME;
typedef REQ_NTRENAME SMB_UNALIGNED *PREQ_NTRENAME;
typedef struct _RESP_RENAME {
UCHAR WordCount; // Count of parameter words = 0
_USHORT( ByteCount ); // Count of data bytes = 0
UCHAR Buffer[1]; // empty
} RESP_RENAME;
typedef RESP_RENAME SMB_UNALIGNED *PRESP_RENAME;
#endif // def INCLUDE_SMB_FILE_CONTROL
#ifdef INCLUDE_SMB_SEARCH
//
// Search SMBs. One structure is common for both the core Search and the
// LAN Manager 1.0 Find First/Next/Close.
//
// Function is SrvSmbSearch()
//
// Search, see #1 page 26
// SMB_COM_SEARCH 0x81
// FindFirst and FindNext, see #2 page 27
// SMB_COM_FIND 0x82
// FindUnique, see #2 page 33
// SMB_COM_FIND_UNIQUE 0x83
// FindClose, see #2 page 31
// SMB_COM_FIND_CLOSE 0x84
//
typedef struct _REQ_SEARCH {
UCHAR WordCount; // Count of parameter words = 2
_USHORT( MaxCount ); // Number of dir. entries to return
_USHORT( SearchAttributes );
_USHORT( ByteCount ); // Count of data bytes; min = 5
UCHAR Buffer[1]; // Buffer containing:
//UCHAR BufferFormat1; // 0x04 -- ASCII
//UCHAR FileName[]; // File name, may be null
//UCHAR BufferFormat2; // 0x05 -- Variable block
//USHORT ResumeKeyLength; // Length of resume key, may be 0
//UCHAR SearchStatus[]; // Resume key
} REQ_SEARCH;
typedef REQ_SEARCH SMB_UNALIGNED *PREQ_SEARCH;
typedef struct _RESP_SEARCH {
UCHAR WordCount; // Count of parameter words = 1
_USHORT( Count ); // Number of entries returned
_USHORT( ByteCount ); // Count of data bytes; min = 3
UCHAR Buffer[1]; // Buffer containing:
//UCHAR BufferFormat; // 0x05 -- Variable block
//USHORT DataLength; // Length of data
//UCHAR Data[]; // Data
} RESP_SEARCH;
typedef RESP_SEARCH SMB_UNALIGNED *PRESP_SEARCH;
//
// These two structures are use to return information in the Search SMBs.
// SMB_DIRECTORY_INFORMATION is used to return information about a file
// that was found. In addition to the usual information about the file,
// each of these structures contains an SMB_RESUME_KEY, which is used to
// continue or rewind a search.
//
// These structures must be packed, so turn on packing if it isn't
// already on.
//
#ifdef NO_PACKING
#include <packon.h>
#endif // def NO_PACKING
typedef struct _SMB_RESUME_KEY {
UCHAR Reserved; // bit 7 - comsumer use
// bits 5,6 - system use (must preserve)
// bits 0-4 - server use (must preserve)
UCHAR FileName[11];
UCHAR Sid; // Uniquely identifies Find through Close
_ULONG( FileIndex ); // Reserved for server use
UCHAR Consumer[4]; // Reserved for comsumer use
} SMB_RESUME_KEY;
typedef SMB_RESUME_KEY SMB_UNALIGNED *PSMB_RESUME_KEY;
typedef struct _SMB_DIRECTORY_INFORMATION {
SMB_RESUME_KEY ResumeKey;
UCHAR FileAttributes;
SMB_TIME LastWriteTime;
SMB_DATE LastWriteDate;
_ULONG( FileSize );
UCHAR FileName[13]; // ASCII, space-filled null terminated
} SMB_DIRECTORY_INFORMATION;
typedef SMB_DIRECTORY_INFORMATION SMB_UNALIGNED *PSMB_DIRECTORY_INFORMATION;
#ifdef NO_PACKING
#include <packoff.h>
#endif // def NO_PACKING
#endif // def INCLUDE_SMB_SEARCH
#ifdef INCLUDE_SMB_READ_WRITE
//
// Seek SMB, see #1 page 14
// Function is SrvSmbSeek
// SMB_COM_SEEK 0x12
//
typedef struct _REQ_SEEK {
UCHAR WordCount; // Count of parameter words = 4
_USHORT( Fid ); // File handle
_USHORT( Mode ); // Seek mode:
// 0 = from start of file
// 1 = from current position
// 2 = from end of file
_ULONG( Offset ); // Relative offset
_USHORT( ByteCount ); // Count of data bytes = 0
UCHAR Buffer[1]; // empty
} REQ_SEEK;
typedef REQ_SEEK SMB_UNALIGNED *PREQ_SEEK;
typedef struct _RESP_SEEK {
UCHAR WordCount; // Count of parameter words = 2
_ULONG( Offset ); // Offset from start of file
_USHORT( ByteCount ); // Count of data bytes = 0
UCHAR Buffer[1]; // empty
} RESP_SEEK;
typedef RESP_SEEK SMB_UNALIGNED *PRESP_SEEK;
#endif // def INCLUDE_SMB_READ_WRITE
#ifdef INCLUDE_SMB_MESSAGE
//
// Send Broadcast Message SMB, see #1 page 32
// Function is SrvSmbSendBroadcastMessage()
// SMB_COM_SEND_BROADCAST_MESSAGE 0xD1
//
typedef struct _REQ_SEND_BROADCAST_MESSAGE {
UCHAR WordCount; // Count of parameter words = 0
_USHORT( ByteCount ); // Count of data bytes; min = 8
UCHAR Buffer[1]; // Buffer containing:
//UCHAR BufferFormat1; // 0x04 -- ASCII
//UCHAR OriginatorName[]; // Originator name (max = 15)
//UCHAR BufferFormat2; // 0x04 -- ASCII
//UCHAR DestinationName[]; // "*"
//UCHAR BufferFormat3; // 0x01 -- Data block
//USHORT DataLength; // Length of message; max = 128
//UCHAR Data[]; // Message
} REQ_SEND_BROADCAST_MESSAGE;
typedef REQ_SEND_BROADCAST_MESSAGE SMB_UNALIGNED *PREQ_SEND_BROADCAST_MESSAGE;
// No response for Send Broadcast Message
#endif // def INCLUDE_SMB_MESSAGE
#ifdef INCLUDE_SMB_MESSAGE
//
// Send End of Multi-block Message SMB, see #1 page 33
// Function is SrvSmbSendEndMbMessage()
// SMB_COM_SEND_END_MB_MESSAGE 0xD6
//
typedef struct _REQ_SEND_END_MB_MESSAGE {
UCHAR WordCount; // Count of parameter words = 1
_USHORT( MessageGroupId );
_USHORT( ByteCount ); // Count of data bytes = 0
UCHAR Buffer[1]; // empty
} REQ_SEND_END_MB_MESSAGE;
typedef REQ_SEND_END_MB_MESSAGE SMB_UNALIGNED *PREQ_SEND_END_MB_MESSAGE;
typedef struct _RESP_SEND_END_MB_MESSAGE {
UCHAR WordCount; // Count of parameter words = 0
_USHORT( ByteCount ); // Count of data bytes = 0
UCHAR Buffer[1]; // empty
} RESP_SEND_END_MB_MESSAGE;
typedef RESP_SEND_END_MB_MESSAGE SMB_UNALIGNED *PRESP_SEND_END_MB_MESSAGE;
#endif // def INCLUDE_SMB_MESSAGE
#ifdef INCLUDE_SMB_MESSAGE
//
// Send Single Block Message SMB, see #1 page 31
// Function is SrvSmbSendMessage()
// SMB_COM_SEND_MESSAGE 0xD0
//
typedef struct _REQ_SEND_MESSAGE {
UCHAR WordCount; // Count of parameter words = 0
_USHORT( ByteCount ); // Count of data bytes; min = 7
UCHAR Buffer[1]; // Buffer containing:
//UCHAR BufferFormat1; // 0x04 -- ASCII
//UCHAR OriginatorName[]; // Originator name (max = 15)
//UCHAR BufferFormat2; // 0x04 -- ASCII
//UCHAR DestinationName[]; // Destination name (max = 15)
//UCHAR BufferFormat3; // 0x01 -- Data block
//USHORT DataLength; // Length of message; max = 128
//UCHAR Data[]; // Message
} REQ_SEND_MESSAGE;
typedef REQ_SEND_MESSAGE SMB_UNALIGNED *PREQ_SEND_MESSAGE;
typedef struct _RESP_SEND_MESSAGE {
UCHAR WordCount; // Count of parameter words = 0
_USHORT( ByteCount ); // Count of data bytes = 0
UCHAR Buffer[1]; // empty
} RESP_SEND_MESSAGE;
typedef RESP_SEND_MESSAGE SMB_UNALIGNED *PRESP_SEND_MESSAGE;
#endif // def INCLUDE_SMB_MESSAGE
#ifdef INCLUDE_SMB_MESSAGE
//
// Send Start of Multi-block Message SMB, see #1 page 32
// Function is SrvSmbSendStartMbMessage()
// SMB_COM_SEND_START_MB_MESSAGE 0xD5
//
typedef struct _REQ_SEND_START_MB_MESSAGE {
UCHAR WordCount; // Count of parameter words = 0
_USHORT( ByteCount ); // Count of data bytes; min = 0
UCHAR Buffer[1]; // Buffer containing:
//UCHAR BufferFormat1; // 0x04 -- ASCII
//UCHAR OriginatorName[]; // Originator name (max = 15)
//UCHAR BufferFormat2; // 0x04 -- ASCII
//UCHAR DestinationName[]; // Destination name (max = 15)
} REQ_SEND_START_MB_MESSAGE;
typedef REQ_SEND_START_MB_MESSAGE SMB_UNALIGNED *PREQ_SEND_START_MB_MESSAGE;
typedef struct _RESP_SEND_START_MB_MESSAGE {
UCHAR WordCount; // Count of parameter words = 1
_USHORT( MessageGroupId );
_USHORT( ByteCount ); // Count of data bytes = 0
UCHAR Buffer[1]; // empty
} RESP_SEND_START_MB_MESSAGE;
typedef RESP_SEND_START_MB_MESSAGE SMB_UNALIGNED *PSEND_START_MB_MESSAGE;
#endif // def INCLUDE_SMB_MESSAGE
#ifdef INCLUDE_SMB_MESSAGE
//
// Send Text of Multi-block Message SMB, see #1 page 33
// Function is SrvSmbSendTextMbMessage()
// SMB_COM_SEND_TEXT_MB_MESSAGE 0xD7
//
typedef struct _REQ_SEND_TEXT_MB_MESSAGE {
UCHAR WordCount; // Count of parameter words = 1
_USHORT( MessageGroupId );
_USHORT( ByteCount ); // Count of data bytes; min = 3
UCHAR Buffer[1]; // Buffer containing:
//UCHAR BufferFormat; // 0x01 -- Data block
//USHORT DataLength; // Length of message; max = 128
//UCHAR Data[]; // Message
} REQ_SEND_TEXT_MB_MESSAGE;
typedef REQ_SEND_TEXT_MB_MESSAGE SMB_UNALIGNED *PREQ_SEND_TEXT_MB_MESSAGE;
typedef struct _RESP_SEND_TEXT_MB_MESSAGE {
UCHAR WordCount; // Count of aprameter words = 0
_USHORT( ByteCount ); // Count of data bytes = 0
UCHAR Buffer[1]; // empty
} RESP_SEND_TEXT_MB_MESSAGE;
typedef RESP_SEND_TEXT_MB_MESSAGE SMB_UNALIGNED *PRESP_SEND_TEXT_MB_MESSAGE;
#endif // def INCLUDE_SMB_MESSAGE
#ifdef INCLUDE_SMB_ADMIN
//
// Session Setup and X SMB, see #2 page 63 and #3 page 10
// Function is SrvSmbSessionSetupAndX()
// SMB_COM_SESSION_SETUP_ANDX 0x73
//
typedef struct _REQ_SESSION_SETUP_ANDX {
UCHAR WordCount; // Count of parameter words = 10
UCHAR AndXCommand; // Secondary (X) command; 0xFF = none
UCHAR AndXReserved; // Reserved (must be 0)
_USHORT( AndXOffset ); // Offset to next command WordCount
_USHORT( MaxBufferSize ); // Consumer's maximum buffer size
_USHORT( MaxMpxCount ); // Actual maximum multiplexed pending requests
_USHORT( VcNumber ); // 0 = first (only), nonzero=additional VC number
_ULONG( SessionKey ); // Session key (valid iff VcNumber != 0)
_USHORT( PasswordLength ); // Account password size
_ULONG( Reserved );
_USHORT( ByteCount ); // Count of data bytes; min = 0
UCHAR Buffer[1]; // Buffer containing:
//UCHAR AccountPassword[]; // Account Password
//UCHAR AccountName[]; // Account Name
//UCHAR PrimaryDomain[]; // Client's primary domain
//UCHAR NativeOS[]; // Client's native operating system
//UCHAR NativeLanMan[]; // Client's native LAN Manager type
} REQ_SESSION_SETUP_ANDX;
typedef REQ_SESSION_SETUP_ANDX SMB_UNALIGNED *PREQ_SESSION_SETUP_ANDX;
typedef struct _REQ_NT_SESSION_SETUP_ANDX {
UCHAR WordCount; // Count of parameter words = 13
UCHAR AndXCommand; // Secondary (X) command; 0xFF = none
UCHAR AndXReserved; // Reserved (must be 0)
_USHORT( AndXOffset ); // Offset to next command WordCount
_USHORT( MaxBufferSize ); // Consumer's maximum buffer size
_USHORT( MaxMpxCount ); // Actual maximum multiplexed pending requests
_USHORT( VcNumber ); // 0 = first (only), nonzero=additional VC number
_ULONG( SessionKey ); // Session key (valid iff VcNumber != 0)
_USHORT( CaseInsensitivePasswordLength ); // Account password size, ANSI
_USHORT( CaseSensitivePasswordLength ); // Account password size, Unicode
_ULONG( Reserved);
_ULONG( Capabilities ); // Client capabilities
_USHORT( ByteCount ); // Count of data bytes; min = 0
UCHAR Buffer[1]; // Buffer containing:
//UCHAR CaseInsensitivePassword[]; // Account Password, ANSI
//UCHAR CaseSensitivePassword[]; // Account Password, Unicode
//UCHAR AccountName[]; // Account Name
//UCHAR PrimaryDomain[]; // Client's primary domain
//UCHAR NativeOS[]; // Client's native operating system
//UCHAR NativeLanMan[]; // Client's native LAN Manager type
} REQ_NT_SESSION_SETUP_ANDX;
typedef REQ_NT_SESSION_SETUP_ANDX SMB_UNALIGNED *PREQ_NT_SESSION_SETUP_ANDX;
//
// Action flags in the response
//
#define SMB_SETUP_GUEST 0x0001 // Session setup as a guest
#define SMB_SETUP_USE_LANMAN_KEY 0x0002 // Use the Lan Manager setup key.
typedef struct _REQ_NT_EXTENDED_SESSION_SETUP_ANDX {
UCHAR WordCount; // Count of parameter words = 12
UCHAR AndXCommand; // Secondary (X) command; 0xFF = none
UCHAR AndXReserved; // Reserved (must be 0)
_USHORT( AndXOffset ); // Offset to next command WordCount
_USHORT( MaxBufferSize ); // Consumer's maximum buffer size
_USHORT( MaxMpxCount ); // Actual maximum multiplexed pending requests
_USHORT( VcNumber ); // 0 = first (only), nonzero=additional VC number
_ULONG( SessionKey ); // Session key (valid iff VcNumber != 0)
_USHORT( SecurityBlobLength ); // Account password size, Unicode
_ULONG( Reserved);
_ULONG( Capabilities ); // Client capabilities
_USHORT( ByteCount ); // Count of data bytes; min = 0
UCHAR Buffer[1]; // Buffer containing:
//UCHAR SecurityBlob[]; // opaque security byte array.
//UCHAR NativeOS[]; // Client's native operating system
//UCHAR NativeLanMan[]; // Client's native LAN Manager type
} REQ_NT_EXTENDED_SESSION_SETUP_ANDX;
typedef REQ_NT_EXTENDED_SESSION_SETUP_ANDX SMB_UNALIGNED *PREQ_NT_EXTENDED_SESSION_SETUP_ANDX;
typedef struct _RESP_SESSION_SETUP_ANDX {
UCHAR WordCount; // Count of parameter words = 3
UCHAR AndXCommand; // Secondary (X) command; 0xFF = none
UCHAR AndXReserved; // Reserved (must be 0)
_USHORT( AndXOffset ); // Offset to next command WordCount
_USHORT( Action ); // Request mode:
// bit0 = logged in as GUEST
_USHORT( ByteCount ); // Count of data bytes
UCHAR Buffer[1]; // Buffer containing:
//UCHAR NativeOS[]; // Server's native operating system
//UCHAR NativeLanMan[]; // Server's native LAN Manager type
//UCHAR PrimaryDomain[]; // Server's primary domain
} RESP_SESSION_SETUP_ANDX;
typedef RESP_SESSION_SETUP_ANDX SMB_UNALIGNED *PRESP_SESSION_SETUP_ANDX;
typedef struct _RESP_NT_EXTENDED_SESSION_SETUP_ANDX {
UCHAR WordCount; // Count of parameter words = 4
UCHAR AndXCommand; // Secondary (X) command; 0xFF = none
UCHAR AndXReserved; // Reserved (must be 0)
_USHORT( AndXOffset ); // Offset to next command WordCount
_USHORT( Action ); // Request mode:
// bit0 = logged in as GUEST
_USHORT( SecurityBlobLength ); // Length of opaque security blob.
_USHORT( ByteCount ); // Count of data bytes
UCHAR Buffer[1]; // Buffer containing:
//UCHAR SecurityBlob[]; // SecurityBlob length message
//UCHAR NativeOS[]; // Server's native operating system
//UCHAR NativeLanMan[]; // Server's native LAN Manager type
//UCHAR PrimaryDomain[]; // Server's primary domain
} RESP_NT_EXTENDED_SESSION_SETUP_ANDX;
typedef RESP_NT_EXTENDED_SESSION_SETUP_ANDX SMB_UNALIGNED *PRESP_NT_EXTENDED_SESSION_SETUP_ANDX;
#endif // def INCLUDE_SMB_ADMIN
#ifdef INCLUDE_SMB_QUERY_SET
//
// Set Information SMB, see #1 page 19
// Function is SrvSmbSetInformation()
// SMB_COM_SET_INFORMATION 0x09
//
typedef struct _REQ_SET_INFORMATION {
UCHAR WordCount; // Count of parameter words = 8
_USHORT( FileAttributes );
_ULONG( LastWriteTimeInSeconds );
_USHORT( Reserved )[5]; // Reserved (must be 0)
_USHORT( ByteCount ); // Count of data bytes; min = 2
UCHAR Buffer[1]; // Buffer containing:
//UCHAR BufferFormat; // 0x04 -- ASCII
//UCHAR FileName[]; // File name
} REQ_SET_INFORMATION;
typedef REQ_SET_INFORMATION SMB_UNALIGNED *PREQ_SET_INFORMATION;
typedef struct _RESP_SET_INFORMATION {
UCHAR WordCount; // Count of parameter words = 0
_USHORT( ByteCount ); // Count of data bytes = 0
UCHAR Buffer[1]; // empty
} RESP_SET_INFORMATION;
typedef RESP_SET_INFORMATION SMB_UNALIGNED *PRESP_SET_INFORMATION;
#endif // def INCLUDE_SMB_QUERY_SET
#ifdef INCLUDE_SMB_QUERY_SET
//
// Set Information2 SMB, see #2 page 66
// Function is SrvSmbSetInformation2
// SMB_COM_SET_INFORMATION2 0x22
//
typedef struct _REQ_SET_INFORMATION2 {
UCHAR WordCount; // Count of parameter words = 7
_USHORT( Fid ); // File handle
SMB_DATE CreationDate;
SMB_TIME CreationTime;
SMB_DATE LastAccessDate;
SMB_TIME LastAccessTime;
SMB_DATE LastWriteDate;
SMB_TIME LastWriteTime;
_USHORT( ByteCount ); // Count of data bytes; min = 0
UCHAR Buffer[1]; // Reserved buffer
} REQ_SET_INFORMATION2;
typedef REQ_SET_INFORMATION2 SMB_UNALIGNED *PREQ_SET_INFORMATION2;
typedef struct _RESP_SET_INFORMATION2 {
UCHAR WordCount; // Count of parameter words = 0
_USHORT( ByteCount ); // Count of data bytes = 0
UCHAR Buffer[1]; // empty
} RESP_SET_INFORMATION2;
typedef RESP_SET_INFORMATION2 SMB_UNALIGNED *PRESP_SET_INFORMATION2;
#endif // def INCLUDE_SMB_QUERY_SET
#ifdef INCLUDE_SMB_TRANSACTION
//
// Transaction and Transaction2 SMBs, see #2 page 68 and #3 page 13
// Function is SrvSmbTransaction()
// SMB_COM_TRANSACTION 0x25
// SMB_COM_TRANSACTION_SECONDARY 0x26
// SMB_COM_TRANSACTION2 0x32
// SMB_COM_TRANSACTION2_SECONDARY 0x33
//
// Structures for specific transaction types are defined in smbtrans.h.
//
// *** The Transaction2 secondary request format includes a USHORT Fid
// field that we ignore. We can do this because the Fid field
// occurs at the end of the word parameters part of the request, and
// because the rest of the request (parameter and data bytes) is
// pointed by offset fields occurring prior to the Fid field. (The
// Fid field was added to speed up dispatching in the OS/2 server,
// in which different worker processes handle each Fid. The NT
// server has only one process.)
//
typedef struct _REQ_TRANSACTION {
UCHAR WordCount; // Count of parameter words; value = (14 + SetupCount)
_USHORT( TotalParameterCount ); // Total parameter bytes being sent
_USHORT( TotalDataCount ); // Total data bytes being sent
_USHORT( MaxParameterCount ); // Max parameter bytes to return
_USHORT( MaxDataCount ); // Max data bytes to return
UCHAR MaxSetupCount; // Max setup words to return
UCHAR Reserved;
_USHORT( Flags ); // Additional information:
// bit 0 - also disconnect TID in Tid
// bit 1 - one-way transacion (no resp)
_ULONG( Timeout );
_USHORT( Reserved2 );
_USHORT( ParameterCount ); // Parameter bytes sent this buffer
_USHORT( ParameterOffset ); // Offset (from header start) to params
_USHORT( DataCount ); // Data bytes sent this buffer
_USHORT( DataOffset ); // Offset (from header start) to data
UCHAR SetupCount; // Count of setup words
UCHAR Reserved3; // Reserved (pad above to word)
UCHAR Buffer[1]; // Buffer containing:
//USHORT Setup[]; // Setup words (# = SetupWordCount)
//USHORT ByteCount; // Count of data bytes
//UCHAR Name[]; // Name of transaction (NULL if Transact2)
//UCHAR Pad[]; // Pad to SHORT or LONG
//UCHAR Parameters[]; // Parameter bytes (# = ParameterCount)
//UCHAR Pad1[]; // Pad to SHORT or LONG
//UCHAR Data[]; // Data bytes (# = DataCount)
} REQ_TRANSACTION;
typedef REQ_TRANSACTION SMB_UNALIGNED *PREQ_TRANSACTION;
#define SMB_TRANSACTION_DISCONNECT 1
#define SMB_TRANSACTION_NO_RESPONSE 2
#define SMB_TRANSACTION_RECONNECTING 4
#define SMB_TRANSACTION_DFSFILE 8
typedef struct _RESP_TRANSACTION_INTERIM {
UCHAR WordCount; // Count of parameter words = 0
_USHORT( ByteCount ); // Count of data bytes = 0
UCHAR Buffer[1]; // empty
} RESP_TRANSACTION_INTERIM;
typedef RESP_TRANSACTION_INTERIM SMB_UNALIGNED *PRESP_TRANSACTION_INTERIM;
typedef struct _REQ_TRANSACTION_SECONDARY {
UCHAR WordCount; // Count of parameter words = 8
_USHORT( TotalParameterCount ); // Total parameter bytes being sent
_USHORT( TotalDataCount ); // Total data bytes being sent
_USHORT( ParameterCount ); // Parameter bytes sent this buffer
_USHORT( ParameterOffset ); // Offset (from header start) to params
_USHORT( ParameterDisplacement ); // Displacement of these param bytes
_USHORT( DataCount ); // Data bytes sent this buffer
_USHORT( DataOffset ); // Offset (from header start) to data
_USHORT( DataDisplacement ); // Displacement of these data bytes
_USHORT( ByteCount ); // Count of data bytes
UCHAR Buffer[1]; // Buffer containing:
//UCHAR Pad[]; // Pad to SHORT or LONG
//UCHAR Parameters[]; // Parameter bytes (# = ParameterCount)
//UCHAR Pad1[]; // Pad to SHORT or LONG
//UCHAR Data[]; // Data bytes (# = DataCount)
} REQ_TRANSACTION_SECONDARY;
typedef REQ_TRANSACTION_SECONDARY SMB_UNALIGNED *PREQ_TRANSACTION_SECONDARY;
typedef struct _RESP_TRANSACTION {
UCHAR WordCount; // Count of data bytes; value = 10 + SetupCount
_USHORT( TotalParameterCount ); // Total parameter bytes being sent
_USHORT( TotalDataCount ); // Total data bytes being sent
_USHORT( Reserved );
_USHORT( ParameterCount ); // Parameter bytes sent this buffer
_USHORT( ParameterOffset ); // Offset (from header start) to params
_USHORT( ParameterDisplacement ); // Displacement of these param bytes
_USHORT( DataCount ); // Data bytes sent this buffer
_USHORT( DataOffset ); // Offset (from header start) to data
_USHORT( DataDisplacement ); // Displacement of these data bytes
UCHAR SetupCount; // Count of setup words
UCHAR Reserved2; // Reserved (pad above to word)
UCHAR Buffer[1]; // Buffer containing:
//USHORT Setup[]; // Setup words (# = SetupWordCount)
//USHORT ByteCount; // Count of data bytes
//UCHAR Pad[]; // Pad to SHORT or LONG
//UCHAR Parameters[]; // Parameter bytes (# = ParameterCount)
//UCHAR Pad1[]; // Pad to SHORT or LONG
//UCHAR Data[]; // Data bytes (# = DataCount)
} RESP_TRANSACTION;
typedef RESP_TRANSACTION SMB_UNALIGNED *PRESP_TRANSACTION;
typedef struct _REQ_NT_TRANSACTION {
UCHAR WordCount; // Count of parameter words; value = (19 + SetupCount)
UCHAR MaxSetupCount; // Max setup words to return
_USHORT( Flags ); // Currently unused
_ULONG( TotalParameterCount ); // Total parameter bytes being sent
_ULONG( TotalDataCount ); // Total data bytes being sent
_ULONG( MaxParameterCount ); // Max parameter bytes to return
_ULONG( MaxDataCount ); // Max data bytes to return
_ULONG( ParameterCount ); // Parameter bytes sent this buffer
_ULONG( ParameterOffset ); // Offset (from header start) to params
_ULONG( DataCount ); // Data bytes sent this buffer
_ULONG( DataOffset ); // Offset (from header start) to data
UCHAR SetupCount; // Count of setup words
_USHORT( Function ); // The transaction function code
UCHAR Buffer[1];
//USHORT Setup[]; // Setup words (# = SetupWordCount)
//USHORT ByteCount; // Count of data bytes
//UCHAR Pad1[]; // Pad to LONG
//UCHAR Parameters[]; // Parameter bytes (# = ParameterCount)
//UCHAR Pad2[]; // Pad to LONG
//UCHAR Data[]; // Data bytes (# = DataCount)
} REQ_NT_TRANSACTION;
typedef REQ_NT_TRANSACTION SMB_UNALIGNED *PREQ_NT_TRANSACTION;
#define SMB_TRANSACTION_DISCONNECT 1
#define SMB_TRANSACTION_NO_RESPONSE 2
typedef struct _RESP_NT_TRANSACTION_INTERIM {
UCHAR WordCount; // Count of parameter words = 0
_USHORT( ByteCount ); // Count of data bytes = 0
UCHAR Buffer[1];
} RESP_NT_TRANSACTION_INTERIM;
typedef RESP_NT_TRANSACTION_INTERIM SMB_UNALIGNED *PRESP_NT_TRANSACTION_INTERIM;
typedef struct _REQ_NT_TRANSACTION_SECONDARY {
UCHAR WordCount; // Count of parameter words = 18
UCHAR Reserved1; // MBZ
_USHORT( Reserved2 ); // MBZ
_ULONG( TotalParameterCount ); // Total parameter bytes being sent
_ULONG( TotalDataCount ); // Total data bytes being sent
_ULONG( ParameterCount ); // Parameter bytes sent this buffer
_ULONG( ParameterOffset ); // Offset (from header start) to params
_ULONG( ParameterDisplacement ); // Displacement of these param bytes
_ULONG( DataCount ); // Data bytes sent this buffer
_ULONG( DataOffset ); // Offset (from header start) to data
_ULONG( DataDisplacement ); // Displacement of these data bytes
UCHAR Reserved3;
_USHORT( ByteCount ); // Count of data bytes
UCHAR Buffer[1];
//UCHAR Pad1[]; // Pad to LONG
//UCHAR Parameters[]; // Parameter bytes (# = ParameterCount)
//UCHAR Pad2[]; // Pad to LONG
//UCHAR Data[]; // Data bytes (# = DataCount)
} REQ_NT_TRANSACTION_SECONDARY;
typedef REQ_NT_TRANSACTION_SECONDARY SMB_UNALIGNED *PREQ_NT_TRANSACTION_SECONDARY;
typedef struct _RESP_NT_TRANSACTION {
UCHAR WordCount; // Count of data bytes; value = 18 + SetupCount
UCHAR Reserved1;
_USHORT( Reserved2 );
_ULONG( TotalParameterCount ); // Total parameter bytes being sent
_ULONG( TotalDataCount ); // Total data bytes being sent
_ULONG( ParameterCount ); // Parameter bytes sent this buffer
_ULONG( ParameterOffset ); // Offset (from header start) to params
_ULONG( ParameterDisplacement ); // Displacement of these param bytes
_ULONG( DataCount ); // Data bytes sent this buffer
_ULONG( DataOffset ); // Offset (from header start) to data
_ULONG( DataDisplacement ); // Displacement of these data bytes
UCHAR SetupCount; // Count of setup words
UCHAR Buffer[1];
//USHORT Setup[]; // Setup words (# = SetupWordCount)
//USHORT ByteCount; // Count of data bytes
//UCHAR Pad1[]; // Pad to LONG
//UCHAR Parameters[]; // Parameter bytes (# = ParameterCount)
//UCHAR Pad2[]; // Pad to SHORT or LONG
//UCHAR Data[]; // Data bytes (# = DataCount)
} RESP_NT_TRANSACTION;
typedef RESP_NT_TRANSACTION SMB_UNALIGNED *PRESP_NT_TRANSACTION;
#endif // def INCLUDE_SMB_TRANSACTION
#ifdef INCLUDE_SMB_TREE
//
// Tree Connect SMB, see #1, page 6
// Function is SrvSmbTreeConnect()
// SMB_COM_TREE_CONNECT 0x70
//
typedef struct _REQ_TREE_CONNECT {
UCHAR WordCount; // Count of parameter words = 0
_USHORT( ByteCount ); // Count of data bytes; min = 4
UCHAR Buffer[1]; // Buffer containing:
//UCHAR BufferFormat1; // 0x04 -- ASCII
//UCHAR Path[]; // Server name and share name
//UCHAR BufferFormat2; // 0x04 -- ASCII
//UCHAR Password[]; // Password
//UCHAR BufferFormat3; // 0x04 -- ASCII
//UCHAR Service[]; // Service name
} REQ_TREE_CONNECT;
typedef REQ_TREE_CONNECT SMB_UNALIGNED *PREQ_TREE_CONNECT;
typedef struct _RESP_TREE_CONNECT {
UCHAR WordCount; // Count of parameter words = 2
_USHORT( MaxBufferSize ); // Max size message the server handles
_USHORT( Tid ); // Tree ID
_USHORT( ByteCount ); // Count of data bytes = 0
UCHAR Buffer[1]; // empty
} RESP_TREE_CONNECT;
typedef RESP_TREE_CONNECT SMB_UNALIGNED *PRESP_TREE_CONNECT;
#endif // def INCLUDE_SMB_TREE
#ifdef INCLUDE_SMB_TREE
//
// Tree Connect and X SMB, see #2, page 88
// Function is SrvSmbTreeConnectAndX()
// SMB_COM_TREE_CONNECT_ANDX 0x75
//
// TREE_CONNECT_ANDX flags
#define TREE_CONNECT_ANDX_DISCONNECT_TID (0x1)
// #define TREE_CONNECT_ANDX_W95 (0x2) -- W95 sets this flag. Don't know why.
#define TREE_CONNECT_ANDX_EXTENDED_RESPONSE (0x8)
typedef struct _REQ_TREE_CONNECT_ANDX {
UCHAR WordCount; // Count of parameter words = 4
UCHAR AndXCommand; // Secondary (X) command; 0xFF = none
UCHAR AndXReserved; // Reserved (must be 0)
_USHORT( AndXOffset ); // Offset to next command WordCount
_USHORT( Flags ); // Additional information
// bit 0 set = disconnect Tid
// bit 7 set = extended response
_USHORT( PasswordLength ); // Length of Password[]
_USHORT( ByteCount ); // Count of data bytes; min = 3
UCHAR Buffer[1]; // Buffer containing:
//UCHAR Password[]; // Password
//UCHAR Path[]; // Server name and share name
//UCHAR Service[]; // Service name
} REQ_TREE_CONNECT_ANDX;
typedef REQ_TREE_CONNECT_ANDX SMB_UNALIGNED *PREQ_TREE_CONNECT_ANDX;
typedef struct _RESP_TREE_CONNECT_ANDX {
UCHAR WordCount; // Count of parameter words = 2
UCHAR AndXCommand; // Secondary (X) command; 0xFF = none
UCHAR AndXReserved; // Reserved (must be 0)
_USHORT( AndXOffset ); // Offset to next command WordCount
_USHORT( ByteCount ); // Count of data bytes; min = 3
UCHAR Buffer[1]; // Service type connected to
} RESP_TREE_CONNECT_ANDX;
typedef RESP_TREE_CONNECT_ANDX SMB_UNALIGNED *PRESP_TREE_CONNECT_ANDX;
//
// The response for clients that are LAN Manager 2.1 or better.
//
typedef struct _RESP_21_TREE_CONNECT_ANDX {
UCHAR WordCount; // Count of parameter words = 3
UCHAR AndXCommand; // Secondary (X) command; 0xFF = none
UCHAR AndXReserved; // Reserved (must be 0)
_USHORT( AndXOffset ); // Offset to next command WordCount
_USHORT( OptionalSupport ); // Optional support bits
_USHORT( ByteCount ); // Count of data bytes; min = 3
UCHAR Buffer[1]; // Buffer containing:
//UCHAR Service[]; // Service type connected to
//UCHAR NativeFileSystem[]; // Native file system for this tree
} RESP_21_TREE_CONNECT_ANDX;
typedef RESP_21_TREE_CONNECT_ANDX SMB_UNALIGNED *PRESP_21_TREE_CONNECT_ANDX;
typedef struct _RESP_EXTENDED_TREE_CONNECT_ANDX {
UCHAR WordCount; // Count of parameter words = 7
UCHAR AndXCommand; // Secondary (X) command; 0xFF = none
UCHAR AndXReserved; // Reserved (must be 0)
_USHORT( AndXOffset ); // Offset to next command WordCount
_USHORT( OptionalSupport); // optional support bits
_ULONG( MaximalShareAccessRights ); // maximal share access rights
_ULONG( GuestMaximalShareAccessRights); // maximal guest access rights
_USHORT( ByteCount ); // Count of data bytes; min = 3
UCHAR Buffer[1]; // Service type connected to
} RESP_EXTENDED_TREE_CONNECT_ANDX;
typedef RESP_EXTENDED_TREE_CONNECT_ANDX SMB_UNALIGNED *PRESP_EXTENDED_TREE_CONNECT_ANDX;
//
// Optional Support bit definitions
//
#define SMB_SUPPORT_SEARCH_BITS 0x0001
#define SMB_SHARE_IS_IN_DFS 0x0002
#define SMB_UNIQUE_FILE_NAME 0x0010
#define SMB_CSC_MASK 0x000C // see below
//
// Bits under SMB_CSC_MASK decode like this:
//
#define SMB_CSC_CACHE_MANUAL_REINT 0x0000 // No automatic file by file reint
#define SMB_CSC_CACHE_AUTO_REINT 0x0004 // File by file reint is OK
#define SMB_CSC_CACHE_VDO 0x0008 // no need to flow opens
#define SMB_CSC_NO_CACHING 0x000C // client should not cache this share
#endif // def INCLUDE_SMB_TREE
#ifdef INCLUDE_SMB_TREE
//
// Tree Disconnect SMB, see #1 page 7
// Function is SrvSmbTreeDisconnect()
// SMB_COM_TREE_DISCONNECT 0x71
//
typedef struct _REQ_TREE_DISCONNECT {
UCHAR WordCount; // Count of parameter words = 0
_USHORT( ByteCount ); // Count of data bytes = 0
UCHAR Buffer[1]; // empty
} REQ_TREE_DISCONNECT;
typedef REQ_TREE_DISCONNECT SMB_UNALIGNED *PREQ_TREE_DISCONNECT;
typedef struct _RESP_TREE_DISCONNECT {
UCHAR WordCount; // Count of parameter words = 0
_USHORT( ByteCount ); // Count of data bytes = 0
UCHAR Buffer[1]; // empty
} RESP_TREE_DISCONNECT;
typedef RESP_TREE_DISCONNECT SMB_UNALIGNED *PRESP_TREE_DISCONNECT;
#endif // def INCLUDE_SMB_TREE
#ifdef INCLUDE_SMB_LOCK
//
// Unlock Byte Range SMB, see #1 page 20
// Function is SrvSmbUnlockByteRange()
// SMB_COM_UNLOCK_BYTE_RANGE 0x0D
//
typedef struct _REQ_UNLOCK_BYTE_RANGE {
UCHAR WordCount; // Count of parameter words = 5
_USHORT( Fid ); // File handle
_ULONG( Count ); // Count of bytes to unlock
_ULONG( Offset ); // Offset from start of file
_USHORT( ByteCount ); // Count of data bytes = 0
UCHAR Buffer[1]; // empty
} REQ_UNLOCK_BYTE_RANGE;
typedef REQ_UNLOCK_BYTE_RANGE SMB_UNALIGNED *PREQ_UNLOCK_BYTE_RANGE;
typedef struct _RESP_UNLOCK_BYTE_RANGE {
UCHAR WordCount; // Count of parameter words = 0
_USHORT( ByteCount ); // Count of data bytes = 0
UCHAR Buffer[1]; // empty
} RESP_UNLOCK_BYTE_RANGE;
typedef RESP_UNLOCK_BYTE_RANGE SMB_UNALIGNED *PRESP_UNLOCK_BYTE_RANGE;
#endif // def INCLUDE_SMB_LOCK
#ifdef INCLUDE_SMB_READ_WRITE
//
// Write SMB, see #1 page 12
// Write and Unlock SMB, see #2 page 92
// Function is SrvSmbWrite()
// SMB_COM_WRITE 0x0B
// SMB_COM_WRITE_AND_UNLOCK 0x14
//
//
// *** Warning: the following structure is defined the way it is to
// ensure longword alignment of the data buffer. (This only matters
// when packing is disabled; when packing is turned on, the right
// thing happens no matter what.)
//
typedef struct _REQ_WRITE {
UCHAR WordCount; // Count of parameter words = 5
_USHORT( Fid ); // File handle
_USHORT( Count ); // Number of bytes to be written
_ULONG( Offset ); // Offset in file to begin write
_USHORT( Remaining ); // Bytes remaining to satisfy request
_USHORT( ByteCount ); // Count of data bytes
//UCHAR Buffer[1]; // Buffer containing:
UCHAR BufferFormat; // 0x01 -- Data block
_USHORT( DataLength ); // Length of data
ULONG Buffer[1]; // Data
} REQ_WRITE;
typedef REQ_WRITE SMB_UNALIGNED *PREQ_WRITE;
typedef struct _RESP_WRITE {
UCHAR WordCount; // Count of parameter words = 1
_USHORT( Count ); // Count of bytes actually written
_USHORT( ByteCount ); // Count of data bytes = 0
UCHAR Buffer[1]; // empty
} RESP_WRITE;
typedef RESP_WRITE SMB_UNALIGNED *PRESP_WRITE;
#endif // def INCLUDE_SMB_READ_WRITE
#ifdef INCLUDE_SMB_READ_WRITE
//
// Write and Close SMB, see #2 page 90
// Function is SrvSmbWriteAndClose()
// SMB_COM_WRITE_AND_CLOSE 0x2C
//
//
// The Write and Close parameters can be 6 words long or 12 words long,
// depending on whether it's supposed to look like a Write SMB or a
// Write and X SMB. So we define two different structures here.
//
// *** Warning: the following structures are defined the way they are to
// ensure longword alignment of the data buffer. (This only matters
// when packing is disabled; when packing is turned on, the right
// thing happens no matter what.)
//
typedef struct _REQ_WRITE_AND_CLOSE {
UCHAR WordCount; // Count of parameter words = 6
_USHORT( Fid ); // File handle
_USHORT( Count ); // Number of bytes to write
_ULONG( Offset ); // Offset in file of first byte to write
_ULONG( LastWriteTimeInSeconds ); // Time of last write
_USHORT( ByteCount ); // 1 (for pad) + value of Count
UCHAR Pad; // To force to doubleword boundary
ULONG Buffer[1]; // Data
} REQ_WRITE_AND_CLOSE;
typedef REQ_WRITE_AND_CLOSE SMB_UNALIGNED *PREQ_WRITE_AND_CLOSE;
typedef struct _REQ_WRITE_AND_CLOSE_LONG {
UCHAR WordCount; // Count of parameter words = 12
_USHORT( Fid ); // File handle
_USHORT( Count ); // Number of bytes to write
_ULONG( Offset ); // Offset in file of first byte to write
_ULONG( LastWriteTimeInSeconds ); // Time of last write
_ULONG( Reserved )[3]; // Reserved, must be 0
_USHORT( ByteCount ); // 1 (for pad) + value of Count
UCHAR Pad; // To force to doubleword boundary
ULONG Buffer[1]; // Data
} REQ_WRITE_AND_CLOSE_LONG;
typedef REQ_WRITE_AND_CLOSE_LONG SMB_UNALIGNED *PREQ_WRITE_AND_CLOSE_LONG;
typedef struct _RESP_WRITE_AND_CLOSE {
UCHAR WordCount; // Count of parameter words = 1
_USHORT( Count ); // Count of bytes actually written
_USHORT( ByteCount ); // Count of data bytes = 0
UCHAR Buffer[1]; // empty
} RESP_WRITE_AND_CLOSE;
typedef RESP_WRITE_AND_CLOSE SMB_UNALIGNED *PRESP_WRITE_AND_CLOSE;
#endif // def INCLUDE_SMB_READ_WRITE
#ifdef INCLUDE_SMB_READ_WRITE
//
// Write and X SMB, see #2 page 94
// Function is SrvSmbWriteAndX()
// SMB_COM_WRITE_ANDX 0x2F
//
typedef struct _REQ_WRITE_ANDX {
UCHAR WordCount; // Count of parameter words = 12
UCHAR AndXCommand; // Secondary (X) command; 0xFF = none
UCHAR AndXReserved; // Reserved (must be 0)
_USHORT( AndXOffset ); // Offset to next command WordCount
_USHORT( Fid ); // File handle
_ULONG( Offset ); // Offset in file to begin write
_ULONG( Timeout );
_USHORT( WriteMode ); // Write mode:
// 0 - write through
// 1 - return Remaining
// 2 - use WriteRawNamedPipe (n. pipes)
// 3 - "this is the start of the msg"
_USHORT( Remaining ); // Bytes remaining to satisfy request
_USHORT( Reserved );
_USHORT( DataLength ); // Number of data bytes in buffer (>=0)
_USHORT( DataOffset ); // Offset to data bytes
_USHORT( ByteCount ); // Count of data bytes
UCHAR Buffer[1]; // Buffer containing:
//UCHAR Pad[]; // Pad to SHORT or LONG
//UCHAR Data[]; // Data (# = DataLength)
} REQ_WRITE_ANDX;
typedef REQ_WRITE_ANDX SMB_UNALIGNED *PREQ_WRITE_ANDX;
typedef struct _REQ_NT_WRITE_ANDX {
UCHAR WordCount; // Count of parameter words = 14
UCHAR AndXCommand; // Secondary (X) command; 0xFF = none
UCHAR AndXReserved; // Reserved (must be 0)
_USHORT( AndXOffset ); // Offset to next command WordCount
_USHORT( Fid ); // File handle
_ULONG( Offset ); // Offset in file to begin write
_ULONG( Timeout );
_USHORT( WriteMode ); // Write mode:
// 0 - write through
// 1 - return Remaining
// 2 - use WriteRawNamedPipe (n. pipes)
// 3 - "this is the start of the msg"
union {
_USHORT( Remaining ); // Bytes remaining to satisfy request
_USHORT( CdiLength ); // if SMB_FLAGS2_COMPRESSED
};
_USHORT( DataLengthHigh );
_USHORT( DataLength ); // Number of data bytes in buffer (>=0)
_USHORT( DataOffset ); // Offset to data bytes
_ULONG( OffsetHigh ); // Used for NT Protocol only
// Upper 32 bits of offset
_USHORT( ByteCount ); // Count of data bytes
UCHAR Buffer[1]; // Buffer containing:
//UCHAR Pad[]; // Pad to SHORT or LONG
//UCHAR Data[]; // Data (# = DataLength)
} REQ_NT_WRITE_ANDX;
typedef REQ_NT_WRITE_ANDX SMB_UNALIGNED *PREQ_NT_WRITE_ANDX;
typedef struct _RESP_WRITE_ANDX {
UCHAR WordCount; // Count of parameter words = 6
UCHAR AndXCommand; // Secondary (X) command; 0xFF = none
UCHAR AndXReserved; // Reserved (must be 0)
_USHORT( AndXOffset ); // Offset to next command WordCount
_USHORT( Count ); // Number of bytes written
_USHORT( Remaining ); // Bytes remaining to be read (pipe/dev)
union {
_ULONG( Reserved );
_USHORT( CountHigh ); // if large write&x
};
_USHORT( ByteCount ); // Count of data bytes. Inaccurate if
// large writes
UCHAR Buffer[1]; // empty
} RESP_WRITE_ANDX;
typedef RESP_WRITE_ANDX SMB_UNALIGNED *PRESP_WRITE_ANDX;
#endif // def INCLUDE_SMB_READ_WRITE
#ifdef INCLUDE_SMB_MPX
//
// Write Block Multiplexed SMB, see #2 page 97
// Function is SrvSmbWriteMpx()
// SMB_COM_WRITE_MPX 0x1E
// SMB_COM_WRITE_MPX_SECONDARY 0x1F
// SMB_COM_WRITE_MPX_COMPLETE 0x20
//
typedef struct _REQ_WRITE_MPX {
UCHAR WordCount; // Count of parameter words = 12
_USHORT( Fid ); // File handle
_USHORT( Count ); // Total bytes, including this buffer
_USHORT( Reserved );
_ULONG( Offset ); // Offset in file to begin write
_ULONG( Timeout );
_USHORT( WriteMode ); // Write mode:
// bit 0 - complete write to disk and
// send final result response
// bit 1 - return Remaining (pipe/dev)
// bit 7 - IPX datagram mode
union {
struct {
_USHORT( DataCompactionMode );
_USHORT( Reserved2 );
} ;
_ULONG( Mask ); // IPX datagram mode mask
} ;
_USHORT( DataLength ); // Number of data bytes this buffer
_USHORT( DataOffset ); // Offset (from header start) to data
_USHORT( ByteCount ); // Count of data bytes
UCHAR Buffer[1]; // Buffer containing:
//UCHAR Pad[]; // Pad to SHORT or LONG
//UCHAR Data[]; // Data (# = DataLength)
} REQ_WRITE_MPX;
typedef REQ_WRITE_MPX SMB_UNALIGNED *PREQ_WRITE_MPX;
typedef struct _RESP_WRITE_MPX_INTERIM { // First response
UCHAR WordCount; // Count of parameter words = 1
_USHORT( Remaining ); // Bytes ramaining to be read (pipe/dev)
_USHORT( ByteCount ); // Count of data bytes = 0
UCHAR Buffer[1]; // empty
} RESP_WRITE_MPX_INTERIM;
typedef RESP_WRITE_MPX_INTERIM SMB_UNALIGNED *PRESP_WRITE_MPX_INTERIM;
typedef struct _RESP_WRITE_MPX_DATAGRAM { // Response to sequenced request
UCHAR WordCount; // Count of parameter words = 2
_ULONG( Mask ); // OR of all masks received
_USHORT( ByteCount ); // Count of data bytes = 0
UCHAR Buffer[1]; // empty
} RESP_WRITE_MPX_DATAGRAM;
typedef RESP_WRITE_MPX_DATAGRAM SMB_UNALIGNED *PRESP_WRITE_MPX_DATAGRAM;
// Secondary request format, 0 to N of these.
typedef struct _REQ_WRITE_MPX_SECONDARY {
UCHAR WordCount; // Count of parameter words = 8
_USHORT( Fid ); // File handle
_USHORT( Count ); // Total bytes to be sent
_ULONG( Offset ); // Offset in file to begin write
_ULONG( Reserved );
_USHORT( DataLength ); // Number of data bytes this buffer
_USHORT( DataOffset ); // Offset (from header start) to data
_USHORT( ByteCount ); // Count of data bytes
UCHAR Buffer[1]; // Buffer containing:
//UCHAR Pad[]; // Pad to SHORT or LONG
//UCHAR Data[]; // Data (# = DataLength)
} REQ_WRITE_MPX_SECONDARY;
typedef REQ_WRITE_MPX_SECONDARY SMB_UNALIGNED *PREQ_WRITE_MPX_SECONDARY;
#endif // def INCLUDE_SMB_MPX
#ifndef INCLUDE_SMB_WRITE_COMPLETE
#ifdef INCLUDE_SMB_MPX
#define INCLUDE_SMB_WRITE_COMPLETE
#else
#ifdef INCLUDE_SMB_RAW
#define INCLUDE_SMB_WRITE_COMPLETE
#endif
#endif
#endif
#ifdef INCLUDE_SMB_WRITE_COMPLETE
//
// The following structure is used as the final response to both Write
// Block Multiplexed and Write Block Raw.
//
typedef struct _RESP_WRITE_COMPLETE { // Final response; command is
// SMB_COM_WRITE_COMPLETE
UCHAR WordCount; // Count of parameter words = 1
_USHORT( Count ); // Total number of bytes written
_USHORT( ByteCount ); // Count of data bytes = 0
UCHAR Buffer[1]; // empty
} RESP_WRITE_COMPLETE;
typedef RESP_WRITE_COMPLETE SMB_UNALIGNED *PRESP_WRITE_COMPLETE;
#endif // def INCLUDE_SMB_WRITE_COMPLETE
#ifdef INCLUDE_SMB_READ_WRITE
//
// Write Print File SMB, see #1 page 29
// Function is SrvSmbWritePrintFile()
// SMB_COM_WRITE_PRINT_FILE 0xC1
//
typedef struct _REQ_WRITE_PRINT_FILE {
UCHAR WordCount; // Count of parameter words = 1
_USHORT( Fid ); // File handle
_USHORT( ByteCount ); // Count of data bytes; min = 4
UCHAR Buffer[1]; // Buffer containing:
//UCHAR BufferFormat; // 0x01 -- Data block
//USHORT DataLength; // Length of data
//UCHAR Data[]; // Data
} REQ_WRITE_PRINT_FILE;
typedef REQ_WRITE_PRINT_FILE SMB_UNALIGNED *PREQ_WRITE_PRINT_FILE;
typedef struct _RESP_WRITE_PRINT_FILE {
UCHAR WordCount; // Count of parameter words = 0
_USHORT( ByteCount ); // Count of data bytes = 0
UCHAR Buffer[1]; // empty
} RESP_WRITE_PRINT_FILE;
typedef RESP_WRITE_PRINT_FILE SMB_UNALIGNED *PRESP_WRITE_PRINT_FILE;
#endif // def INCLUDE_SMB_READ_WRITE
#ifdef INCLUDE_SMB_RAW
//
// Write Block Raw SMB, see #2 page 100
// Function is SrvSmbWriteRaw()
// SMB_COM_WRITE_RAW 0x1D
//
typedef struct _REQ_WRITE_RAW {
UCHAR WordCount; // Count of parameter words = 12
_USHORT( Fid ); // File handle
_USHORT( Count ); // Total bytes, including this buffer
_USHORT( Reserved );
_ULONG( Offset ); // Offset in file to begin write
_ULONG( Timeout );
_USHORT( WriteMode ); // Write mode:
// bit 0 - complete write to disk and
// send final result response
// bit 1 - return Remaining (pipe/dev)
// (see WriteAndX for #defines)
_ULONG( Reserved2 );
_USHORT( DataLength ); // Number of data bytes this buffer
_USHORT( DataOffset ); // Offset (from header start) to data
_USHORT( ByteCount ); // Count of data bytes
UCHAR Buffer[1]; // Buffer containing:
//UCHAR Pad[]; // Pad to SHORT or LONG
//UCHAR Data[]; // Data (# = DataLength)
} REQ_WRITE_RAW;
typedef REQ_WRITE_RAW SMB_UNALIGNED *PREQ_WRITE_RAW;
typedef struct _REQ_NT_WRITE_RAW {
UCHAR WordCount; // Count of parameter words = 14
_USHORT( Fid ); // File handle
_USHORT( Count ); // Total bytes, including this buffer
_USHORT( Reserved );
_ULONG( Offset ); // Offset in file to begin write
_ULONG( Timeout );
_USHORT( WriteMode ); // Write mode:
// bit 0 - complete write to disk and
// send final result response
// bit 1 - return Remaining (pipe/dev)
// (see WriteAndX for #defines)
_ULONG( Reserved2 );
_USHORT( DataLength ); // Number of data bytes this buffer
_USHORT( DataOffset ); // Offset (from header start) to data
_ULONG( OffsetHigh ); // Used for NT Protocol only
// Upper 32 bits of offset
_USHORT( ByteCount ); // Count of data bytes
UCHAR Buffer[1]; // Buffer containing:
//UCHAR Pad[]; // Pad to SHORT or LONG
//UCHAR Data[]; // Data (# = DataLength)
} REQ_NT_WRITE_RAW;
typedef REQ_NT_WRITE_RAW SMB_UNALIGNED *PREQ_NT_WRITE_RAW;
typedef struct _RESP_WRITE_RAW_INTERIM { // First response
UCHAR WordCount; // Count of parameter words = 1
_USHORT( Remaining ); // Bytes remaining to be read (pipe/dev)
_USHORT( ByteCount ); // Count of data bytes = 0
UCHAR Buffer[1]; // empty
} RESP_WRITE_RAW_INTERIM;
typedef RESP_WRITE_RAW_INTERIM SMB_UNALIGNED *PRESP_WRITE_RAW_INTERIM;
typedef struct _RESP_WRITE_RAW_SECONDARY { // Second (final) response
UCHAR WordCount; // Count of parameter words = 1
_USHORT( Count ); // Total number of bytes written
_USHORT( ByteCount ); // Count of data bytes = 0
UCHAR Buffer[1]; // empty
} RESP_WRITE_RAW_SECONDARY;
typedef RESP_WRITE_RAW_SECONDARY SMB_UNALIGNED *PRESP_WRITE_RAW_SECONDARY;
typedef struct _REQ_103_WRITE_RAW {
UCHAR WordCount; // Count of parameter words
_USHORT( Fid ); // File handle
_USHORT( Count );
_USHORT( Reserved );
_ULONG( Offset );
_ULONG( Timeout );
_USHORT( WriteMode );
_ULONG( Reserved2 );
_USHORT( ByteCount ); // Count of data bytes; min =
UCHAR Buffer[1]; //
} REQ_103_WRITE_RAW;
typedef REQ_103_WRITE_RAW SMB_UNALIGNED *PREQ_103_WRITE_RAW;
typedef struct _RESP_103_WRITE_RAW {
UCHAR WordCount; // Count of parameter words
_USHORT( ByteCount ); // Count of data bytes; min =
UCHAR Buffer[1]; //
} RESP_103_WRITE_RAW;
typedef RESP_103_WRITE_RAW SMB_UNALIGNED *PRESP_103_WRITE_RAW;
#endif // def INCLUDE_SMB_RAW
typedef struct _REQ_NT_CANCEL {
UCHAR WordCount; // = 0
_USHORT( ByteCount ); // = 0
UCHAR Buffer[1];
} REQ_NT_CANCEL;
typedef REQ_NT_CANCEL SMB_UNALIGNED *PREQ_NT_CANCEL;
typedef struct _RESP_NT_CANCEL {
UCHAR WordCount; // = 0
_USHORT( ByteCount ); // = 0
UCHAR Buffer[1];
} RESP_NT_CANCEL;
typedef RESP_NT_CANCEL SMB_UNALIGNED *PRESP_NT_CANCEL;
//
// File open modes
//
#define SMB_ACCESS_READ_ONLY 0
#define SMB_ACCESS_WRITE_ONLY 1
#define SMB_ACCESS_READ_WRITE 2
#define SMB_ACCESS_EXECUTE 3
//
// Open flags
//
#define SMB_OPEN_QUERY_INFORMATION 0x01
#define SMB_OPEN_OPLOCK 0x02
#define SMB_OPEN_OPBATCH 0x04
#define SMB_OPEN_QUERY_EA_LENGTH 0x08
#define SMB_OPEN_EXTENDED_RESPONSE 0x10
//
// NT open manifests
//
#define NT_CREATE_REQUEST_OPLOCK 0x02
#define NT_CREATE_REQUEST_OPBATCH 0x04
#define NT_CREATE_OPEN_TARGET_DIR 0x08
#define NT_CREATE_REQUEST_EXTENDED_RESPONSE 0x10
// these options are post NT 5
#ifdef INCLUDE_SMB_IFMODIFIED
#define NT_CREATE_IFMODIFIED_REQUEST 0x20
#define NT_CREATE_REQUEST_EXTENDED_RESPONSE2 0x80
#endif
#ifdef INCLUDE_SMB_PERSISTENT
#define NT_CREATE_PERSISTANT_HANDLE 0x100
#endif
#define Added 0
#define Removed 1
#define Modified 2
#define RenamedOldName 3
#define RenamedNewName 4
//
// Lockrange for use with OS/2 DosFileLocks call
//
// *** Where is this used?
//typedef struct lockrange {
// ULONG offset;
// ULONG range;
// };
//#define LOCK 0x1
//#define UNLOCK 0x2
//
// Data buffer format codes, from the core protocol.
//
#define SMB_FORMAT_DATA 1
#define SMB_FORMAT_DIALECT 2
#define SMB_FORMAT_PATHNAME 3
#define SMB_FORMAT_ASCII 4
#define SMB_FORMAT_VARIABLE 5
//
// WriteMode flags
//
#define SMB_WMODE_WRITE_THROUGH 0x0001 // complete write before responding
#define SMB_WMODE_SET_REMAINING 0x0002 // returning amt remaining in pipe
#define SMB_WMODE_WRITE_RAW_NAMED_PIPE 0x0004 // write named pipe in raw mode
#define SMB_WMODE_START_OF_MESSAGE 0x0008 // start of pipe message
#define SMB_WMODE_DATAGRAM 0x0080 // start of pipe message
//
// Various SMB flags:
//
//
// If the server supports LockAndRead and WriteAndUnlock, it sets this
// bit the Negotiate response.
//
#define SMB_FLAGS_LOCK_AND_READ_OK 0x01
//
// When on, the consumer guarantees that there is a receive buffer posted
// such that a "Send.No.Ack" can be used by the server to respond to
// the consumer's request.
//
#define SMB_FLAGS_SEND_NO_ACK 0x2
//
// This is part of the Flags field of every SMB header. If this bit
// is set, then all pathnames in the SMB should be treated as case-
// insensitive.
//
#define SMB_FLAGS_CASE_INSENSITIVE 0x8
//
// When on in session setup, this bit indicates that all paths sent to
// the server are already in OS/2 canonicalized format.
//
#define SMB_FLAGS_CANONICALIZED_PATHS 0x10
//
// When on in a open file request SMBs (open, create, openX, etc.) this
// bit indicates a request for an oplock on the file. When on in the
// response, this bit indicates that the oplock was granted.
//
#define SMB_FLAGS_OPLOCK 0x20
//
// When on, this bit indicates that the server should notify the client
// on any request that could cause the file to be changed. If not set,
// the server only notifies the client on other open requests on the
// file.
//
#define SMB_FLAGS_OPLOCK_NOTIFY_ANY 0x40
//
// This bit indicates that the SMB is being sent from server to redir.
//
#define SMB_FLAGS_SERVER_TO_REDIR 0x80
//
// Valid bits for Flags on an incoming SMB
//
#define INCOMING_SMB_FLAGS \
(SMB_FLAGS_LOCK_AND_READ_OK | \
SMB_FLAGS_SEND_NO_ACK | \
SMB_FLAGS_CASE_INSENSITIVE | \
SMB_FLAGS_CANONICALIZED_PATHS | \
SMB_FLAGS_OPLOCK_NOTIFY_ANY | \
SMB_FLAGS_OPLOCK)
//
// Names for bits in Flags2 field of SMB header that indicate what the
// client app is aware of.
//
#define SMB_FLAGS2_KNOWS_LONG_NAMES 0x0001
#define SMB_FLAGS2_KNOWS_EAS 0x0002
#define SMB_FLAGS2_SMB_SECURITY_SIGNATURE 0x0004
#define SMB_FLAGS2_COMPRESSED 0x0008
// Unused 0x0010
// Unused 0x0020
#define SMB_FLAGS2_IS_LONG_NAME 0x0040
// Unused 0x0080
// Unused 0x0100
// Unused 0x0200
#define SMB_FLAGS2_REPARSE_PATH 0x0400
#define SMB_FLAGS2_EXTENDED_SECURITY 0x0800
#define SMB_FLAGS2_DFS 0x1000
#define SMB_FLAGS2_PAGING_IO 0x2000
#define SMB_FLAGS2_NT_STATUS 0x4000
#define SMB_FLAGS2_UNICODE 0x8000
//
// Valid bits for Flags2 on an incoming SMB
//
#define INCOMING_SMB_FLAGS2 \
(SMB_FLAGS2_KNOWS_LONG_NAMES | \
SMB_FLAGS2_KNOWS_EAS | \
SMB_FLAGS2_SMB_SECURITY_SIGNATURE | \
SMB_FLAGS2_EXTENDED_SECURITY| \
SMB_FLAGS2_DFS | \
SMB_FLAGS2_PAGING_IO | \
SMB_FLAGS2_IS_LONG_NAME | \
SMB_FLAGS2_NT_STATUS | \
SMB_FLAGS2_COMPRESSED | \
SMB_FLAGS2_UNICODE | \
SMB_FLAGS2_REPARSE_PATH)
//
// The SMB open function determines what action should be taken depending
// on the existence or lack thereof of files used in the operation. It
// has the following mapping:
//
// 1111 1
// 5432 1098 7654 3210
// rrrr rrrr rrrC rrOO
//
// where:
//
// O - Open (action to be taken if the target file exists)
// 0 - Fail
// 1 - Open or Append file
// 2 - Truncate file
//
// C - Create (action to be taken if the target file does not exist)
// 0 - Fail
// 1 - Create file
//
#define SMB_OFUN_OPEN_MASK 0x3
#define SMB_OFUN_CREATE_MASK 0x10
#define SMB_OFUN_OPEN_FAIL 0
#define SMB_OFUN_OPEN_APPEND 1
#define SMB_OFUN_OPEN_OPEN 1
#define SMB_OFUN_OPEN_TRUNCATE 2
#define SMB_OFUN_CREATE_FAIL 0x00
#define SMB_OFUN_CREATE_CREATE 0x10
//++
//
// BOOLEAN
// SmbOfunCreate(
// IN USHORT SmbOpenFunction
// )
//
//--
#define SmbOfunCreate(SmbOpenFunction) \
(BOOLEAN)((SmbOpenFunction & SMB_OFUN_CREATE_MASK) == SMB_OFUN_CREATE_CREATE)
//++
//
// BOOLEAN
// SmbOfunAppend(
// IN USHORT SmbOpenFunction
// )
//
//--
#define SmbOfunAppend(SmbOpenFunction) \
(BOOLEAN)((SmbOpenFunction & SMB_OFUN_OPEN_MASK) == SMB_OFUN_OPEN_APPEND)
//++
//
// BOOLEAN
// SmbOfunTruncate(
// IN USHORT SmbOpenFunction
// )
//
//--
#define SmbOfunTruncate(SmbOpenFunction) \
(BOOLEAN)((SmbOpenFunction & SMB_OFUN_OPEN_MASK) == SMB_OFUN_OPEN_TRUNCATE)
//
// The desired access mode passed in Open and Open and X has the following
// mapping:
//
// 1111 11
// 5432 1098 7654 3210
// rWrC rLLL rSSS rAAA
//
// where:
//
// W - Write through mode. No read ahead or write behind allowed on
// this file or device. When protocol is returned, data is expected
// to be on the disk or device.
//
// S - Sharing mode:
// 0 - Compatibility mode (as in core open)
// 1 - Deny read/write/execute (exclusive)
// 2 - Deny write
// 3 - Deny read/execute
// 4 - Deny none
//
// A - Access mode
// 0 - Open for reading
// 1 - Open for writing
// 2 - Open for reading and writing
// 3 - Open for execute
//
// rSSSrAAA = 11111111 (hex FF) indicates FCB open (as in core protocol)
//
// C - Cache mode
// 0 - Normal file
// 1 - Do not cache this file
//
// L - Locality of reference
// 0 - Locality of reference is unknown
// 1 - Mainly sequential access
// 2 - Mainly random access
// 3 - Random access with some locality
// 4 to 7 - Currently undefined
//
#define SMB_DA_SHARE_MASK 0x70
#define SMB_DA_ACCESS_MASK 0x07
#define SMB_DA_FCB_MASK (UCHAR)0xFF
#define SMB_DA_ACCESS_READ 0x00
#define SMB_DA_ACCESS_WRITE 0x01
#define SMB_DA_ACCESS_READ_WRITE 0x02
#define SMB_DA_ACCESS_EXECUTE 0x03
#define SMB_DA_SHARE_COMPATIBILITY 0x00
#define SMB_DA_SHARE_EXCLUSIVE 0x10
#define SMB_DA_SHARE_DENY_WRITE 0x20
#define SMB_DA_SHARE_DENY_READ 0x30
#define SMB_DA_SHARE_DENY_NONE 0x40
#define SMB_DA_FCB (UCHAR)0xFF
#define SMB_CACHE_NORMAL 0x0000
#define SMB_DO_NOT_CACHE 0x1000
#define SMB_LR_UNKNOWN 0x0000
#define SMB_LR_SEQUENTIAL 0x0100
#define SMB_LR_RANDOM 0x0200
#define SMB_LR_RANDOM_WITH_LOCALITY 0x0300
#define SMB_LR_MASK 0x0F00
#define SMB_DA_WRITE_THROUGH 0x4000
//
// The Action field of OpenAndX has the following format:
//
// 1111 11
// 5432 1098 7654 3210
// Lrrr rrrr rrrr rrOO
//
// where:
//
// L - Opportunistic lock. 1 if lock granted, else 0.
//
// O - Open action:
// 1 - The file existed and was opened
// 2 - The file did not exist but was created
// 3 - The file existed and was truncated
//
#define SMB_OACT_OPENED 0x01
#define SMB_OACT_CREATED 0x02
#define SMB_OACT_TRUNCATED 0x03
#define SMB_OACT_OPLOCK 0x8000
//
// These flags are passed in the Flags field of the copy and extended rename
// SMBs.
//
//
// If set, the target must be a file or directory.
//
#define SMB_TARGET_IS_FILE 0x1
#define SMB_TARGET_IS_DIRECTORY 0x2
//
// The copy mode--if set, ASCII copying should be done, otherwise binary.
//
#define SMB_COPY_TARGET_ASCII 0x4
#define SMB_COPY_SOURCE_ASCII 0x8
#define SMB_COPY_TREE 0x20
//
// If set, verify all writes.
//
#define SMB_VERIFY_WRITES
//
// Define file attribute bits as used in the SMB protocol. The specific
// bit positions are, for the most part, identical to those used in NT.
// However, NT does not define Volume and Directory bits. It also has
// an explicit Normal bit; this bit is implied in SMB attributes by
// Hidden, System, and Directory being off.
//
#define SMB_FILE_ATTRIBUTE_READONLY 0x01
#define SMB_FILE_ATTRIBUTE_HIDDEN 0x02
#define SMB_FILE_ATTRIBUTE_SYSTEM 0x04
#define SMB_FILE_ATTRIBUTE_VOLUME 0x08
#define SMB_FILE_ATTRIBUTE_DIRECTORY 0x10
#define SMB_FILE_ATTRIBUTE_ARCHIVE 0x20
//
// Share type strings are passed in SMBs to indicate what type of shared
// resource is being or has been connected to.
//
#define SHARE_TYPE_NAME_DISK "A:"
#define SHARE_TYPE_NAME_PIPE "IPC"
#define SHARE_TYPE_NAME_COMM "COMM"
#define SHARE_TYPE_NAME_PRINT "LPT1:"
#define SHARE_TYPE_NAME_WILD "?????"
//
// SMB Error codes:
//
//
// Success Class:
//
#define SMB_ERR_SUCCESS (UCHAR)0x00
//
// DOS Error Class:
//
#define SMB_ERR_CLASS_DOS (UCHAR)0x01
#define SMB_ERR_BAD_FUNCTION 1 // Invalid function
#define SMB_ERR_BAD_FILE 2 // File not found
#define SMB_ERR_BAD_PATH 3 // Invalid directory
#define SMB_ERR_NO_FIDS 4 // Too many open files
#define SMB_ERR_ACCESS_DENIED 5 // Access not allowed for req. func.
#define SMB_ERR_BAD_FID 6 // Invalid file handle
#define SMB_ERR_BAD_MCB 7 // Memory control blocks destroyed
#define SMB_ERR_INSUFFICIENT_MEMORY 8 // For the desired function
#define SMB_ERR_BAD_MEMORY 9 // Invalid memory block address
#define SMB_ERR_BAD_ENVIRONMENT 10 // Invalid environment
#define SMB_ERR_BAD_FORMAT 11 // Invalid format
#define SMB_ERR_BAD_ACCESS 12 // Invalid open mode
#define SMB_ERR_BAD_DATA 13 // Invalid data (only from IOCTL)
#define SMB_ERR_RESERVED 14
#define SMB_ERR_BAD_DRIVE 15 // Invalid drive specified
#define SMB_ERR_CURRENT_DIRECTORY 16 // Attempted to remove currect directory
#define SMB_ERR_DIFFERENT_DEVICE 17 // Not the same device
#define SMB_ERR_NO_FILES 18 // File search can't find more files
#define SMB_ERR_BAD_SHARE 32 // An open conflicts with FIDs on file
#define SMB_ERR_LOCK 33 // Conflict with existing lock
#define SMB_ERR_FILE_EXISTS 80 // Tried to overwrite existing file
#define SMB_ERR_BAD_PIPE 230 // Invalie pipe
#define SMB_ERR_PIPE_BUSY 231 // All instances of the pipe are busy
#define SMB_ERR_PIPE_CLOSING 232 // Pipe close in progress
#define SMB_ERR_PIPE_NOT_CONNECTED 233 // No process on other end of pipe
#define SMB_ERR_MORE_DATA 234 // There is more data to return
//
// SERVER Error Class:
//
#define SMB_ERR_CLASS_SERVER (UCHAR)0x02
#define SMB_ERR_ERROR 1 // Non-specific error code
#define SMB_ERR_BAD_PASSWORD 2 // Bad name/password pair
#define SMB_ERR_BAD_TYPE 3 // Reserved
#define SMB_ERR_ACCESS 4 // Requester lacks necessary access
#define SMB_ERR_BAD_TID 5 // Invalid TID
#define SMB_ERR_BAD_NET_NAME 6 // Invalid network name in tree connect
#define SMB_ERR_BAD_DEVICE 7 // Invalid device request
#define SMB_ERR_QUEUE_FULL 49 // Print queue full--returned print file
#define SMB_ERR_QUEUE_TOO_BIG 50 // Print queue full--no space
#define SMB_ERR_QUEUE_EOF 51 // EOF on print queue dump
#define SMB_ERR_BAD_PRINT_FID 52 // Invalid print file FID
#define SMB_ERR_BAD_SMB_COMMAND 64 // SMB command not recognized
#define SMB_ERR_SERVER_ERROR 65 // Internal server error
#define SMB_ERR_FILE_SPECS 67 // FID and pathname were incompatible
#define SMB_ERR_RESERVED2 68
#define SMB_ERR_BAD_PERMITS 69 // Access permissions invalid
#define SMB_ERR_RESERVED3 70
#define SMB_ERR_BAD_ATTRIBUTE_MODE 71 // Invalid attribute mode specified
#define SMB_ERR_SERVER_PAUSED 81 // Server is paused
#define SMB_ERR_MESSAGE_OFF 82 // Server not receiving messages
#define SMB_ERR_NO_ROOM 83 // No room for buffer message
#define SMB_ERR_TOO_MANY_NAMES 87 // Too many remote user names
#define SMB_ERR_TIMEOUT 88 // Operation was timed out
#define SMB_ERR_NO_RESOURCE 89 // No resources available for request
#define SMB_ERR_TOO_MANY_UIDS 90 // Too many UIDs active in session
#define SMB_ERR_BAD_UID 91 // UID not known as a valid UID
#define SMB_ERR_INVALID_NAME 123 // Invalid name returned from FAT.
#define SMB_ERR_INVALID_NAME_RANGE 206 // Non 8.3 name passed to FAT (or non 255 name to HPFS)
#define SMB_ERR_USE_MPX 250 // Can't support Raw; use MPX
#define SMB_ERR_USE_STANDARD 251 // Can't support Raw, use standard r/w
#define SMB_ERR_CONTINUE_MPX 252 // Reserved
#define SMB_ERR_RESERVED4 253
#define SMB_ERR_RESERVED5 254
#define SMB_ERR_NO_SUPPORT_INTERNAL 255 // Internal code for NO_SUPPORT--
// allows codes to be stored in a byte
#define SMB_ERR_NO_SUPPORT (USHORT)0xFFFF // Function not supported
//
// HARDWARE Error Class:
//
#define SMB_ERR_CLASS_HARDWARE (UCHAR)0x03
#define SMB_ERR_NO_WRITE 19 // Write attempted to write-prot. disk
#define SMB_ERR_BAD_UNIT 20 // Unknown unit
#define SMB_ERR_DRIVE_NOT_READY 21 // Disk drive not ready
#define SMB_ERR_BAD_COMMAND 22 // Unknown command
#define SMB_ERR_DATA 23 // Data error (CRC)
#define SMB_ERR_BAD_REQUEST 24 // Bad request structure length
#define SMB_ERR_SEEK 25 // Seek error
#define SMB_ERR_BAD_MEDIA 26 // Unknown media type
#define SMB_ERR_BAD_SECTOR 27 // Sector not found
#define SMB_ERR_NO_PAPER 28 // Printer out of paper
#define SMB_ERR_WRITE_FAULT 29 // Write fault
#define SMB_ERR_READ_FAULT 30 // Read fault
#define SMB_ERR_GENERAL 31 // General failure
#define SMB_ERR_LOCK_CONFLICT 33 // Lock conflicts with existing lock
#define SMB_ERR_WRONG_DISK 34 // Wrong disk was found in a drive
#define SMB_ERR_FCB_UNAVAILABLE 35 // No FCBs available to process request
#define SMB_ERR_SHARE_BUFFER_EXCEEDED 36
#define SMB_ERR_DISK_FULL 39 // !!! Undocumented, but in LM2.0
//
// Other Error Classes:
//
#define SMB_ERR_CLASS_XOS (UCHAR)0x04 // Reserved for XENIX
#define SMB_ERR_CLASS_RMX1 (UCHAR)0xE1 // Reserved for iRMX
#define SMB_ERR_CLASS_RMX2 (UCHAR)0xE2 // Reserved for iRMX
#define SMB_ERR_CLASS_RMX3 (UCHAR)0xE3 // Reserved for iRMX
#define SMB_ERR_CLASS_COMMAND (UCHAR)0xFF // Command was not in the SMB format
//
// Turn structure packing back off
//
#ifndef NO_PACKING
#include <packoff.h>
#endif // ndef NO_PACKING
#endif // _SMB_
// Old (LanMan 1.2) and new (NT) field names:
// (Undocumented fields have corresponding structure in parenthesis)
// smb_access Access
// smb_action Action
// smb_adate AccessDate
// smb_allocsize AllocationSize
// smb_aname AccountName
// smb_apasslen PasswordSize
// smb_apasswd AccountPassword
// smb_atime AccessTime
// smb_attr Attribute
// smb_attribute Attribute
// smb_aunits (RESP_QUERY_INFORMATION_SERVER)
// smb_bcc BufferSize
// smb_blkmode BlockMode
// smb_blksize BlockSize
// smb_blksperunit BlocksPerUnit
// smb_bpu BlocksPerUnit
// smb_bs BlockSize
// smb_bufsize MaxBufferSize
// smb_buf[1] Buffer[1]
// smb_bytes[*] Bytes[*]
// smb_cat Category
// smb_cct FilesCopied
// smb_cdate CreateDate
// smb_cert CertificateOffset
// smb_com Command
// smb_com2 AndXCommand
// smb_count Count
// smb_count_left Remaining
// smb_cryptkey[*] CryptKey
// smb_ctime CreateTime
// smb_datablock DataBlock
// smb_datalen DataSize
// smb_datasize DataSize
// smb_data[*] Data[*]
// smb_dcmode DataCompactMode
// smb_dev DeviceName
// smb_doff DataOffset
// smb_drcnt DataCount
// smb_drdisp DataDisplacement
// smb_droff DataOffset
// smb_dscnt DataCount
// smb_dsdisp DataDisplacement
// smb_dsize DataSize
// smb_dsoff DataOffset
// smb_encrypt EncryptKey
// smb_encryptlen EncryptKeySize
// smb_encryptoff EncryptKeyOffset
// smb_eos EndOfSearch
// smb_err Error
// smb_errmsg[1] ErrorMessage[1]
// smb_fau (RESP_QUERY_INFORMATION_SERVER)
// smb_fid Fid
// smb_fileid ServerFid
// smb_flag Flag
// smb_flag2 Flag2
// smb_flags Flag
// smb_flg Flag
// smb_freeunits FreeUnits
// smb_fsid (RESP_QUERY_INFORMATION_SERVER)
// smb_fsize FileSize
// smb_fun Function
// smb_gid Gid
// smb_handle Handle
// smb_ident1 Identifier
// smb_idf[4] Protocol[4]
// smb_index Index
// smb_info Info
// smb_left Remaining
// smb_len SetupLength
// smb_locknum NumberOfLocks
// smb_lockrng[*] LockRange
// smb_locktype LockType
// smb_lpid OwnerPid
// smb_maxbytes MaxBytes
// smb_maxcnt MaxCount
// smb_maxcount MaxCount
// smb_maxmux (RESP_NEGOTIATE)
// smb_maxvcs MaxNumberVcs
// smb_maxxmitsz MaxTransmitSize
// smb_maxxmt MaxTransmitSize
// smb_mdate ModificationDate
// smb_mdrcnt MaxDataCount
// smb_mid Mid
// smb_mincnt MinCount
// smb_mode Mode
// smb_mprcnt MaxParameterCount
// smb_mpxmax MaxMpxCount
// smb_msrcnt MaxSetupCount
// smb_mtime ModificationTime
// smb_name[*] Name[*]
// smb_off2 AndXOffset
// smb_offset Offset
// smb_ofun OpenFunction
// smb_pad Pad
// smb_pad1[] Pad1
// smb_pad[] Pad[]
// smb_param[*] Parameter[*]
// smb_path ServerName
// smb_pathname PathName
// smb_pid Pid
// smb_prcnt ParameterCount
// smb_prdisp ParameterDisplacement
// smb_proff ParameterCount
// smb_pscnt ParameterCount
// smb_psdisp ParameterDisplacement
// smb_psoff ParameterOffset
// smb_range LockLength or UnlockLength
// smb_rcls ErrorClass
// smb_reh ReservedH
// smb_reh2 ReservedH2
// smb_remaining Remaining
// smb_remcnt Remaining
// smb_res1 Reserved
// smb_res2 Reserved2
// smb_res3 Reserved3
// smb_res4 Reserved4
// smb_res5 Reserved5
// smb_reserved Reserved
// smb_restart Restart
// smb_resumekey ResumeKey
// smb_res[5] Reserved[]
// smb_reverb ReverbCount
// smb_rsvd Reserved
// smb_rsvd1 Reserved
// smb_rsvd2 Reserved2
// smb_rsvd3 Reserved3
// smb_rsvd4 Reserved4
// smb_sattr SearchAttribute
// smb_secmode SecurityMode
// smb_seq SequenceNumber
// smb_services Services
// smb_sesskey SessionKey
// smb_setup[*] Setup[*]
// smb_size Size
// smb_spasslen ServerPasswordSize
// smb_spasswd ServerPassword
// smb_srv_date ServerDate
// smb_srv_time ServerTime
// smb_srv_tzone ServerTimeZone
// smb_start StartIndex
// smb_state DeviceState
// smb_suwcnt SetupWordCount
// smb_su_class SetupClass
// smb_su_com SetupCommand
// smb_su_handle SetupFid
// smb_su_opcode SetupOpcode
// smb_su_priority SetupPriority
// smb_tcount Count
// smb_tdis TreeDisconnect
// smb_tdrcnt TotalDataCount
// smb_tdscnt TotalDataCount
// smb_tid Tid
// smb_tid2 Tid2
// smb_time Time
// smb_timeout Timeout
// smb_totalunits TotalUnits
// smb_tprcnt TotalParameterCount
// smb_tpscnt TotalParameterCount
// smb_type FileType
// smb_uid Uid
// smb_unlkrng[*] UnlockRange
// smb_unlocknum NumberOfUnlocks
// smb_vblen DataLength
// smb_vcnum VcNumber
// smb_vldate (RESP_QUERY_INFORMATION_SERVER)
// smb_vllen (RESP_QUERY_INFORMATION_SERVER)
// smb_vltime (RESP_QUERY_INFORMATION_SERVER)
// smb_vwv[1] Param
// smb_wct WordCount
// smb_wmode WriteMode
// smb_xchain EncryptChainOffset
Reference in a new issue View git blame Copy permalink