From e611b132f9b8abe35b362e5870b74bce94a1e58e Mon Sep 17 00:00:00 2001 From: Adam Date: Sat, 16 May 2020 20:51:50 -0700 Subject: initial commit --- private/inc/smbgtpt.h | 915 ++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 915 insertions(+) create mode 100644 private/inc/smbgtpt.h (limited to 'private/inc/smbgtpt.h') diff --git a/private/inc/smbgtpt.h b/private/inc/smbgtpt.h new file mode 100644 index 000000000..b8bbd1b06 --- /dev/null +++ b/private/inc/smbgtpt.h @@ -0,0 +1,915 @@ +/*++ + +Copyright (c) 1990 Microsoft Corporation + +Module Name: + + smbgtpt.h + +Abstract: + + This module defines macros for retrieving and storing SMB data. + The macros account for the misaligned nature of the SMB protocol. + They also translate from the little-endian SMB format into + big-endian format, when necessary. + +Author: + + Chuck Lenzmeier (chuckl) 2-Mar-90 + David Treadwell (davditr) + +Revision History: + + 15-Apr-1991 JohnRo + Include , to define SMBDBG etc. +--*/ + +#ifndef _SMBGTPT_ +#define _SMBGTPT_ + +#include +//#include + +// +// The following macros store and retrieve USHORTS and ULONGS from +// potentially unaligned addresses, avoiding alignment faults. They +// would best be written as inline assembly code. +// +// The macros are designed to be used for accessing SMB fields. Such +// fields are always stored in little-endian byte order, so these macros +// do byte swapping when compiled for a big-endian machine. +// +// !!! Not yet. +// + +#if !SMBDBG + +#define BYTE_0_MASK 0xFF + +#define BYTE_0(Value) (UCHAR)( (Value) & BYTE_0_MASK) +#define BYTE_1(Value) (UCHAR)( ((Value) >> 8) & BYTE_0_MASK) +#define BYTE_2(Value) (UCHAR)( ((Value) >> 16) & BYTE_0_MASK) +#define BYTE_3(Value) (UCHAR)( ((Value) >> 24) & BYTE_0_MASK) + +#endif + +//++ +// +// USHORT +// SmbGetUshort ( +// IN PSMB_USHORT SrcAddress +// ) +// +// Routine Description: +// +// This macro retrieves a USHORT value from the possibly misaligned +// source address, avoiding alignment faults. +// +// Arguments: +// +// SrcAddress - where to retrieve USHORT value from +// +// Return Value: +// +// USHORT - the value retrieved. The target must be aligned. +// +//-- + +#if !SMBDBG + +#if !SMBDBG1 +#if SMB_USE_UNALIGNED +#define SmbGetUshort(SrcAddress) *(PSMB_USHORT)(SrcAddress) +#else +#define SmbGetUshort(SrcAddress) (USHORT)( \ + ( ( (PUCHAR)(SrcAddress) )[0] ) | \ + ( ( (PUCHAR)(SrcAddress) )[1] << 8 ) \ + ) +#endif +#else +#define SmbGetUshort(SrcAddress) (USHORT)( \ + ( ( (PUCHAR)(SrcAddress ## S) )[0] ) | \ + ( ( (PUCHAR)(SrcAddress ## S) )[1] << 8 ) \ + ) +#endif + +#else + +USHORT +SmbGetUshort ( + IN PSMB_USHORT SrcAddress + ); + +#endif + +//++ +// +// USHORT +// SmbGetAlignedUshort ( +// IN PUSHORT SrcAddress +// ) +// +// Routine Description: +// +// This macro retrieves a USHORT value from the source address, +// correcting for the endian characteristics of the server if +// necessary. +// +// Arguments: +// +// SrcAddress - where to retrieve USHORT value from; must be aligned. +// +// Return Value: +// +// USHORT - the value retrieved. The target must be aligned. +// +//-- + +#if !SMBDBG + +#if !SMBDBG1 +#define SmbGetAlignedUshort(SrcAddress) *(SrcAddress) +#else +#define SmbGetAlignedUshort(SrcAddress) *(SrcAddress ## S) +#endif + +#else + +USHORT +SmbGetAlignedUshort ( + IN PUSHORT SrcAddress + ); + +#endif + +//++ +// +// VOID +// SmbPutUshort ( +// OUT PSMB_USHORT DestAddress, +// IN USHORT Value +// ) +// +// Routine Description: +// +// This macro stores a USHORT value at the possibly misaligned +// destination address, avoiding alignment faults. +// +// Arguments: +// +// DestAddress - where to store USHORT value. Address may be +// misaligned. +// +// Value - USHORT to store. Value must be a constant or an aligned +// field. +// +// Return Value: +// +// None. +// +//-- + +#if !SMBDBG + +#if !SMBDBG1 +#if SMB_USE_UNALIGNED +#define SmbPutUshort(SrcAddress, Value) \ + *(PSMB_USHORT)(SrcAddress) = (Value) +#else +#define SmbPutUshort(DestAddress,Value) { \ + ( (PUCHAR)(DestAddress) )[0] = BYTE_0(Value); \ + ( (PUCHAR)(DestAddress) )[1] = BYTE_1(Value); \ + } +#endif +#else +#define SmbPutUshort(DestAddress,Value) { \ + ( (PUCHAR)(DestAddress ## S) )[0] = BYTE_0(Value); \ + ( (PUCHAR)(DestAddress ## S) )[1] = BYTE_1(Value); \ + } +#endif + +#else + +VOID +SmbPutUshort ( + OUT PSMB_USHORT DestAddress, + IN USHORT Value + ); + +#endif + +//++ +// +// VOID +// SmbPutAlignedUshort ( +// OUT PUSHORT DestAddres, +// IN USHORT Value +// ) +// +// Routine Description: +// +// This macro stores a USHORT value from the source address, +// correcting for the endian characteristics of the server if +// necessary. +// +// Arguments: +// +// DestAddress - where to store USHORT value. Address may not be +// misaligned. +// +// Value - USHORT to store. Value must be a constant or an aligned +// field. +// +// Return Value: +// +// None. +// +//-- + +#if !SMBDBG + +#if !SMBDBG1 +#define SmbPutAlignedUshort(DestAddress,Value) *(DestAddress) = (Value) +#else +#define SmbPutAlignedUshort(DestAddress,Value) *(DestAddress ## S) = (Value) +#endif + +#else + +VOID +SmbPutAlignedUshort ( + OUT PUSHORT DestAddress, + IN USHORT Value + ); + +#endif + +//++ +// +// VOID +// SmbMoveUshort ( +// OUT PSMB_USHORT DestAddress +// IN PSMB_USHORT SrcAddress +// ) +// +// Routine Description: +// +// This macro moves a USHORT value from the possibly misaligned +// source address to the possibly misaligned destination address, +// avoiding alignment faults. +// +// Arguments: +// +// DestAddress - where to store USHORT value +// +// SrcAddress - where to retrieve USHORT value from +// +// Return Value: +// +// None. +// +//-- + +#if !SMBDBG + +#if !SMBDBG1 +#if SMB_USE_UNALIGNED +#define SmbMoveUshort(DestAddress, SrcAddress) \ + *(PSMB_USHORT)(DestAddress) = *(PSMB_USHORT)(SrcAddress) +#else +#define SmbMoveUshort(DestAddress,SrcAddress) { \ + ( (PUCHAR)(DestAddress) )[0] = ( (PUCHAR)(SrcAddress) )[0]; \ + ( (PUCHAR)(DestAddress) )[1] = ( (PUCHAR)(SrcAddress) )[1]; \ + } +#endif +#else +#define SmbMoveUshort(DestAddress,SrcAddress) { \ + ( (PUCHAR)(DestAddress ## S) )[0] = ( (PUCHAR)(SrcAddress ## S) )[0]; \ + ( (PUCHAR)(DestAddress ## S) )[1] = ( (PUCHAR)(SrcAddress ## S) )[1]; \ + } +#endif + +#else + +VOID +SmbMoveUshort ( + OUT PSMB_USHORT DestAddress, + IN PSMB_USHORT SrcAddress + ); + +#endif + +//++ +// +// ULONG +// SmbGetUlong ( +// IN PSMB_ULONG SrcAddress +// ) +// +// Routine Description: +// +// This macro retrieves a ULONG value from the possibly misaligned +// source address, avoiding alignment faults. +// +// Arguments: +// +// SrcAddress - where to retrieve ULONG value from +// +// Return Value: +// +// ULONG - the value retrieved. The target must be aligned. +// +//-- + +#if !SMBDBG + +#if !SMBDBG1 +#if SMB_USE_UNALIGNED +#define SmbGetUlong(SrcAddress) *(PSMB_ULONG)(SrcAddress) +#else +#define SmbGetUlong(SrcAddress) (ULONG)( \ + ( ( (PUCHAR)(SrcAddress) )[0] ) | \ + ( ( (PUCHAR)(SrcAddress) )[1] << 8 ) | \ + ( ( (PUCHAR)(SrcAddress) )[2] << 16 ) | \ + ( ( (PUCHAR)(SrcAddress) )[3] << 24 ) \ + ) +#endif +#else +#define SmbGetUlong(SrcAddress) (ULONG)( \ + ( ( (PUCHAR)(SrcAddress ## L) )[0] ) | \ + ( ( (PUCHAR)(SrcAddress ## L) )[1] << 8 ) | \ + ( ( (PUCHAR)(SrcAddress ## L) )[2] << 16 ) | \ + ( ( (PUCHAR)(SrcAddress ## L) )[3] << 24 ) \ + ) +#endif + +#else + +ULONG +SmbGetUlong ( + IN PSMB_ULONG SrcAddress + ); + +#endif + +//++ +// +// USHORT +// SmbGetAlignedUlong ( +// IN PULONG SrcAddress +// ) +// +// Routine Description: +// +// This macro retrieves a ULONG value from the source address, +// correcting for the endian characteristics of the server if +// necessary. +// +// Arguments: +// +// SrcAddress - where to retrieve ULONG value from; must be aligned. +// +// Return Value: +// +// ULONG - the value retrieved. The target must be aligned. +// +//-- + +#if !SMBDBG + +#if !SMBDBG1 +#define SmbGetAlignedUlong(SrcAddress) *(SrcAddress) +#else +#define SmbGetAlignedUlong(SrcAddress) *(SrcAddress ## L) +#endif + +#else + +ULONG +SmbGetAlignedUlong ( + IN PULONG SrcAddress + ); + +#endif + +//++ +// +// VOID +// SmbPutUlong ( +// OUT PSMB_ULONG DestAddress, +// IN ULONG Value +// ) +// +// Routine Description: +// +// This macro stores a ULONG value at the possibly misaligned +// destination address, avoiding alignment faults. +// +// Arguments: +// +// DestAddress - where to store ULONG value +// +// Value - ULONG to store. Value must be a constant or an aligned +// field. +// +// Return Value: +// +// None. +// +//-- + +#if !SMBDBG + +#if !SMBDBG1 +#if SMB_USE_UNALIGNED +#define SmbPutUlong(SrcAddress, Value) *(PSMB_ULONG)(SrcAddress) = Value +#else +#define SmbPutUlong(DestAddress,Value) { \ + ( (PUCHAR)(DestAddress) )[0] = BYTE_0(Value); \ + ( (PUCHAR)(DestAddress) )[1] = BYTE_1(Value); \ + ( (PUCHAR)(DestAddress) )[2] = BYTE_2(Value); \ + ( (PUCHAR)(DestAddress) )[3] = BYTE_3(Value); \ + } +#endif +#else +#define SmbPutUlong(DestAddress,Value) { \ + ( (PUCHAR)(DestAddress ## L) )[0] = BYTE_0(Value); \ + ( (PUCHAR)(DestAddress ## L) )[1] = BYTE_1(Value); \ + ( (PUCHAR)(DestAddress ## L) )[2] = BYTE_2(Value); \ + ( (PUCHAR)(DestAddress ## L) )[3] = BYTE_3(Value); \ + } +#endif + +#else + +VOID +SmbPutUlong ( + OUT PSMB_ULONG DestAddress, + IN ULONG Value + ); + +#endif + +//++ +// +// VOID +// SmbPutAlignedUlong ( +// OUT PULONG DestAddres, +// IN ULONG Value +// ) +// +// Routine Description: +// +// This macro stores a ULONG value from the source address, +// correcting for the endian characteristics of the server if +// necessary. +// +// Arguments: +// +// DestAddress - where to store ULONG value. Address may not be +// misaligned. +// +// Value - ULONG to store. Value must be a constant or an aligned +// field. +// +// Return Value: +// +// None. +// +//-- + +#if !SMBDBG + +#if !SMBDBG1 +#define SmbPutAlignedUlong(DestAddress,Value) *(DestAddress) = (Value) +#else +#define SmbPutAlignedUlong(DestAddress,Value) *(DestAddress ## L) = (Value) +#endif + +#else + +VOID +SmbPutAlignedUlong ( + OUT PULONG DestAddress, + IN ULONG Value + ); + +#endif + +//++ +// +// VOID +// SmbMoveUlong ( +// OUT PSMB_ULONG DestAddress, +// IN PSMB_ULONG SrcAddress +// ) +// +// Routine Description: +// +// This macro moves a ULONG value from the possibly misaligned +// source address to the possible misaligned destination address, +// avoiding alignment faults. +// +// Arguments: +// +// DestAddress - where to store ULONG value +// +// SrcAddress - where to retrieve ULONG value from +// +// Return Value: +// +// None. +// +//-- + +#if !SMBDBG + +#if !SMBDBG1 +#if SMB_USE_UNALIGNED +#define SmbMoveUlong(DestAddress,SrcAddress) \ + *(PSMB_ULONG)(DestAddress) = *(PSMB_ULONG)(SrcAddress) +#else +#define SmbMoveUlong(DestAddress,SrcAddress) { \ + ( (PUCHAR)(DestAddress) )[0] = ( (PUCHAR)(SrcAddress) )[0]; \ + ( (PUCHAR)(DestAddress) )[1] = ( (PUCHAR)(SrcAddress) )[1]; \ + ( (PUCHAR)(DestAddress) )[2] = ( (PUCHAR)(SrcAddress) )[2]; \ + ( (PUCHAR)(DestAddress) )[3] = ( (PUCHAR)(SrcAddress) )[3]; \ + } +#endif +#else +#define SmbMoveUlong(DestAddress,SrcAddress) { \ + ( (PUCHAR)(DestAddress ## L) )[0] = ( (PUCHAR)(SrcAddress ## L) )[0]; \ + ( (PUCHAR)(DestAddress ## L) )[1] = ( (PUCHAR)(SrcAddress ## L) )[1]; \ + ( (PUCHAR)(DestAddress ## L) )[2] = ( (PUCHAR)(SrcAddress ## L) )[2]; \ + ( (PUCHAR)(DestAddress ## L) )[3] = ( (PUCHAR)(SrcAddress ## L) )[3]; \ + } +#endif + +#else + +VOID +SmbMoveUlong ( + OUT PSMB_ULONG DestAddress, + IN PSMB_ULONG SrcAddress + ); + +#endif + +//++ +// +// VOID +// SmbPutDate ( +// OUT PSMB_DATE DestAddress, +// IN SMB_DATE Value +// ) +// +// Routine Description: +// +// This macro stores an SMB_DATE value at the possibly misaligned +// destination address, avoiding alignment faults. This macro +// is different from SmbPutUshort in order to be able to handle +// funny bitfield / big-endian interactions. +// +// Arguments: +// +// DestAddress - where to store SMB_DATE value +// +// Value - SMB_DATE to store. Value must be a constant or an +// aligned field. +// +// Return Value: +// +// None. +// +//-- + +#if !SMBDBG + +#if SMB_USE_UNALIGNED +#define SmbPutDate(DestAddress,Value) (DestAddress)->Ushort = (Value).Ushort +#else +#define SmbPutDate(DestAddress,Value) { \ + ( (PUCHAR)&(DestAddress)->Ushort )[0] = BYTE_0((Value).Ushort); \ + ( (PUCHAR)&(DestAddress)->Ushort )[1] = BYTE_1((Value).Ushort); \ + } +#endif + +#else + +VOID +SmbPutDate ( + OUT PSMB_DATE DestAddress, + IN SMB_DATE Value + ); + +#endif + +//++ +// +// VOID +// SmbMoveDate ( +// OUT PSMB_DATE DestAddress, +// IN PSMB_DATE SrcAddress +// ) +// +// Routine Description: +// +// This macro copies an SMB_DATE value from the possibly misaligned +// source address, avoiding alignment faults. This macro is +// different from SmbGetUshort in order to be able to handle funny +// bitfield / big-endian interactions. +// +// Note that there is no SmbGetDate because of the way SMB_DATE is +// defined. It is a union containing a USHORT and a bitfield +// struct. The caller of an SmbGetDate macro would have to +// explicitly use one part of the union. +// +// Arguments: +// +// DestAddress - where to store SMB_DATE value. MUST BE ALIGNED! +// +// SrcAddress - where to retrieve SMB_DATE value from +// +// Return Value: +// +// None. +// +//-- + +#if !SMBDBG + +#if SMB_USE_UNALIGNED +#define SmbMoveDate(DestAddress,SrcAddress) \ + (DestAddress)->Ushort = (SrcAddress)->Ushort +#else +#define SmbMoveDate(DestAddress,SrcAddress) \ + (DestAddress)->Ushort = \ + ( ( (PUCHAR)&(SrcAddress)->Ushort )[0] ) | \ + ( ( (PUCHAR)&(SrcAddress)->Ushort )[1] << 8 ) +#endif + +#else + +VOID +SmbMoveDate ( + OUT PSMB_DATE DestAddress, + IN PSMB_DATE SrcAddress + ); + +#endif + +//++ +// +// VOID +// SmbZeroDate ( +// IN PSMB_DATE Date +// ) +// +// Routine Description: +// +// This macro zeroes a possibly misaligned SMB_DATE field. +// +// Arguments: +// +// Date - Pointer to SMB_DATE field to zero. +// +// Return Value: +// +// None. +// +//-- + +#if !SMBDBG + +#if SMB_USE_UNALIGNED +#define SmbZeroDate(Date) (Date)->Ushort = 0 +#else +#define SmbZeroDate(Date) { \ + ( (PUCHAR)&(Date)->Ushort )[0] = 0; \ + ( (PUCHAR)&(Date)->Ushort )[1] = 0; \ + } +#endif + +#else + +VOID +SmbZeroDate ( + IN PSMB_DATE Date + ); + +#endif + +//++ +// +// BOOLEAN +// SmbIsDateZero ( +// IN PSMB_DATE Date +// ) +// +// Routine Description: +// +// This macro returns TRUE if the supplied SMB_DATE value is zero. +// +// Arguments: +// +// Date - Pointer to SMB_DATE value to check. MUST BE ALIGNED! +// +// Return Value: +// +// BOOLEAN - TRUE if Date is zero, else FALSE. +// +//-- + +#if !SMBDBG + +#define SmbIsDateZero(Date) ( (Date)->Ushort == 0 ) + +#else + +BOOLEAN +SmbIsDateZero ( + IN PSMB_DATE Date + ); + +#endif + +//++ +// +// VOID +// SmbPutTime ( +// OUT PSMB_TIME DestAddress, +// IN SMB_TIME Value +// ) +// +// Routine Description: +// +// This macro stores an SMB_TIME value at the possibly misaligned +// destination address, avoiding alignment faults. This macro +// is different from SmbPutUshort in order to be able to handle +// funny bitfield / big-endian interactions. +// +// Arguments: +// +// DestAddress - where to store SMB_TIME value +// +// Value - SMB_TIME to store. Value must be a constant or an +// aligned field. +// +// Return Value: +// +// None. +// +//-- + +#if !SMBDBG + +#if SMB_USE_UNALIGNED +#define SmbPutTime(DestAddress,Value) (DestAddress)->Ushort = (Value).Ushort +#else +#define SmbPutTime(DestAddress,Value) { \ + ( (PUCHAR)&(DestAddress)->Ushort )[0] = BYTE_0((Value).Ushort); \ + ( (PUCHAR)&(DestAddress)->Ushort )[1] = BYTE_1((Value).Ushort); \ + } +#endif + +#else + +VOID +SmbPutTime ( + OUT PSMB_TIME DestAddress, + IN SMB_TIME Value + ); + +#endif + +//++ +// +// VOID +// SmbMoveTime ( +// OUT PSMB_TIME DestAddress, +// IN PSMB_TIME SrcAddress +// ) +// +// Routine Description: +// +// This macro copies an SMB_TIME value from the possibly +// misaligned source address, avoiding alignment faults. This macro +// is different from SmbGetUshort in order to be able to handle +// funny bitfield / big-endian interactions. +// +// Note that there is no SmbGetTime because of the way SMB_TIME is +// defined. It is a union containing a USHORT and a bitfield +// struct. The caller of an SmbGetTime macro would have to +// explicitly use one part of the union. +// +// Arguments: +// +// DestAddress - where to store SMB_TIME value. MUST BE ALIGNED! +// +// SrcAddress - where to retrieve SMB_TIME value from +// +// Return Value: +// +// None. +// +//-- + +#if !SMBDBG + +#if SMB_USE_UNALIGNED +#define SmbMoveTime(DestAddress,SrcAddress) \ + (DestAddress)->Ushort = (SrcAddress)->Ushort +#else +#define SmbMoveTime(DestAddress,SrcAddress) \ + (DestAddress)->Ushort = \ + ( ( (PUCHAR)&(SrcAddress)->Ushort )[0] ) | \ + ( ( (PUCHAR)&(SrcAddress)->Ushort )[1] << 8 ) +#endif + +#else + +VOID +SmbMoveTime ( + OUT PSMB_TIME DestAddress, + IN PSMB_TIME SrcAddress + ); + +#endif + +//++ +// +// VOID +// SmbZeroTime ( +// IN PSMB_TIME Time +// ) +// +// Routine Description: +// +// This macro zeroes a possibly misaligned SMB_TIME field. +// +// Arguments: +// +// Time - Pointer to SMB_TIME field to zero. +// +// Return Value: +// +// None. +// +//-- + +#if !SMBDBG + +#if SMB_USE_UNALIGNED +#define SmbZeroTime(Time) (Time)->Ushort = 0 +#else +#define SmbZeroTime(Time) { \ + ( (PUCHAR)&(Time)->Ushort )[0] = 0; \ + ( (PUCHAR)&(Time)->Ushort )[1] = 0; \ + } +#endif + +#else + +VOID +SmbZeroTime ( + IN PSMB_TIME Time + ); + +#endif + +//++ +// +// BOOLEAN +// SmbIsTimeZero ( +// IN PSMB_TIME Time +// ) +// +// Routine Description: +// +// This macro returns TRUE if the supplied SMB_TIME value is zero. +// +// Arguments: +// +// Time - Pointer to SMB_TIME value to check. Must be aligned and +// in native format! +// +// Return Value: +// +// BOOLEAN - TRUE if Time is zero, else FALSE. +// +//-- + +#if !SMBDBG + +#define SmbIsTimeZero(Time) ( (Time)->Ushort == 0 ) + +#else + +BOOLEAN +SmbIsTimeZero ( + IN PSMB_TIME Time + ); + +#endif + +#endif // def _SMBGTPT_ -- cgit v1.2.3