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/propmac.hxx | 479 ++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 479 insertions(+) create mode 100644 private/inc/propmac.hxx (limited to 'private/inc/propmac.hxx') diff --git a/private/inc/propmac.hxx b/private/inc/propmac.hxx new file mode 100644 index 000000000..30facf4a9 --- /dev/null +++ b/private/inc/propmac.hxx @@ -0,0 +1,479 @@ +//+-------------------------------------------------------------------------- +// +// Microsoft Windows +// Copyright (C) Microsoft Corporation, 1993 +// +// File: propmac.hxx +// +// Contents: various macros used in property set code +// +// History: +// 2/22/96 MikeHill - Protect from multiple inclusions. +// - Made Add2Ptr()'s parms const. +// - Copied DwordRemain to this file. +// 2/29/96 MikeHill Removed IsDwordAligned. +// 11/8/96 MikeHill Corrected new/delete implementation. +// +//--------------------------------------------------------------------------- + +#ifndef _PROPMAC_HXX_ +#define _PROPMAC_HXX_ + +#include + +// +// As part of moving away from using the C runtime library wherever possible, +// use Win32 wide-character functions when they're available. +// + +#ifdef _CHICAGO_ + +# define Prop_wcslen lstrlenW +# define Prop_wcsnicmp _wcsnicmp +# define Prop_wcscmp wcscmp +# define Prop_wcscpy lstrcpyW + +#else + +# define Prop_wcslen wcslen +# define Prop_wcsnicmp _wcsnicmp +# define Prop_wcscmp wcscmp +# define Prop_wcscpy wcscpy + +#endif // _CHICAGO_ + +#ifdef OLE2ANSI +# define Prop_ocslen strlen +#else +# define Prop_ocslen Prop_wcslen +#endif + +#ifdef _CAIRO_ +extern "C" NTSTATUS +SynchronousNtFsControlFile( + IN HANDLE h, + OUT IO_STATUS_BLOCK *pisb, + IN ULONG FsControlCode, + IN VOID *pvIn OPTIONAL, + IN ULONG cbIn, + OUT VOID *pvOut OPTIONAL, + IN ULONG cbOut); +#endif + + +//+--------------------------------------------------------------------------- +// Function: Add2Ptr +// +// Synopsis: Add an unscaled increment to a ptr regardless of type. +// +// Arguments: [pv] -- Initial ptr. +// [cb] -- Increment +// +// Returns: Incremented ptr. +// +//---------------------------------------------------------------------------- + +inline VOID * +Add2Ptr(VOID const *pv, ULONG cb) +{ + return((BYTE *) pv + cb); +} + + +//+--------------------------------------------------------------------------- +// Function: Add2ConstPtr +// +// Synopsis: Add an unscaled increment to a ptr regardless of type. +// +// Arguments: [pv] -- Initial ptr. +// [cb] -- Increment +// +// Returns: Incremented ptr. +// +//---------------------------------------------------------------------------- + +inline +const VOID * +Add2ConstPtr(const VOID *pv, ULONG cb) +{ + return((const BYTE *) pv + cb); +} + + +//+-------------------------------------------------------------------------- +// Function: CopyFileTime, private +// +// Synopsis: Copy LARGE_INTEGER time to FILETIME structure +// +// Arguments: [pft] -- pointer to FILETIME +// [pli] -- pointer to LARGE_INTEGER +// +// Returns: Nothing +//--------------------------------------------------------------------------- + +__inline VOID +CopyFileTime(OUT FILETIME *pft, IN LARGE_INTEGER *pli) +{ + pft->dwLowDateTime = pli->LowPart; + pft->dwHighDateTime = pli->HighPart; +} + + +//+-------------------------------------------------------------------------- +// Function: ZeroFileTime, private +// +// Synopsis: Zero FILETIME structure +// +// Arguments: [pft] -- pointer to FILETIME +// +// Returns: Nothing +//--------------------------------------------------------------------------- + +__inline VOID +ZeroFileTime(OUT FILETIME *pft) +{ + pft->dwLowDateTime = pft->dwHighDateTime = 0; +} + + +#define DwordAlign(n) (((n) + sizeof(ULONG) - 1) & ~(sizeof(ULONG) - 1)) +#define DwordRemain(cb) ((sizeof(ULONG) - ((cb) % sizeof(ULONG))) % sizeof(ULONG)) + +#define QuadAlign(n) (((n) + sizeof(LONGLONG) - 1) & ~(sizeof(LONGLONG) - 1)) + +// stuff to make Nashville properties build +#include + +#if DBG +extern "C" LONG ExceptionFilter(struct _EXCEPTION_POINTERS *pep); +#else // DBG +#define ExceptionFilter(pep) EXCEPTION_EXECUTE_HANDLER +#endif // DBG + +extern "C" UNICODECALLOUTS UnicodeCallouts; + + +// The CMemSerStream and CDeMemSerStream have different requirements for +// handling buffer overflow conditions. In the case of the driver this +// is indicative of a corrupted stream and we would like to raise an +// exception. On the other hand in Query implementation we deal with +// streams whose sizes are precomputed in the user mode. Therefore we +// do not wish to incur any additional penalty in handling such situations. +// In debug builds this condition is asserted while in retail builds it is +// ignored. The CMemSerStream and CMemDeSerStream implementation are +// implemented using a macro HANDLE_OVERFLOW(fOverflow) which take the +// appropriate action. + +#define HANDLE_OVERFLOW(fOverflow) \ + if (fOverflow) { \ + PropRaiseException(STATUS_BUFFER_OVERFLOW); \ + } + + +// +// Declare or Define the new/delete operators. In NTDLL, the declaration +// is provided by ntpropb.cxx and uses the Rtl heap. In OLE32, the +// declaration is provided by ole32\com\util\w32new.cxx and uses the IMalloc +// heap. In IProp.DLL, the declaration is provided here (as an inline). +// + +#ifdef IPROPERTY_DLL + + inline void* _CRTAPI1 + operator new(size_t cb) + { + return( CoTaskMemAlloc(cb) ); + } + + inline void _CRTAPI1 + operator delete(void *pv) + { + CoTaskMemFree( pv ); + } + +#else // #ifdef IPROPERTY_DLL + + void* _CRTAPI1 operator new(size_t cb); + void _CRTAPI1 operator delete(void *pv); + +#endif // #ifdef IPROPERTY_DLL ... #else + + + +#define newk(Tag, pCounter) new + +#if DBG +extern "C" ULONG DebugLevel; +extern "C" ULONG DebugIndent; + +#define DEBTRACE_ERROR (ULONG) 0x00000001 +#define DEBTRACE_WARN (ULONG) 0x00000002 +#define DEBTRACE_CREATESTREAM (ULONG) 0x00000004 +#define DEBTRACE_NTPROP (ULONG) 0x00000008 +#define DEBTRACE_MAPSTM (ULONG) 0x00000010 +#define DEBTRACE_PROPERTY (ULONG) 0x00000020 +#define DEBTRACE_SUMCAT (ULONG) 0x00000040 +#define DEBTRACE_PROPVALIDATE (ULONG) 0x00010000 // awfully noisy +#define DEBTRACE_PROPPATCH (ULONG) 0x00020000 // awfully noisy + +#ifndef WINNT +// in Nashville this is defined in ole32\stg\props\utils.cxx +extern ULONG DbgPrint(PCHAR Format, ...); +#endif + +#define DebugTrace(indent, flag, args) \ + if ((flag) == 0 || (DebugLevel & (flag))) \ + { \ + DebugIndent += (ULONG) (indent); \ + DbgPrint("NTDLL: %*s", DebugIndent, ""); \ + DbgPrint args; \ + } \ + else + +class CDebugTrace { +public: + inline CDebugTrace(CHAR *psz); + inline ~CDebugTrace(); +private: + CHAR const *const _psz; +}; + +inline CDebugTrace::CDebugTrace(CHAR *psz): _psz(psz) +{ + DebugTrace(+1, 0, ("Entering -- %s\n", _psz)); +} + +inline CDebugTrace::~CDebugTrace() +{ + DebugTrace(-1, 0, ("Exiting -- %s\n", _psz)); +} + +#define DEBUG_TRACE(ProcName) CDebugTrace _trace_(#ProcName); +#else +#define DebugTrace(indent, flag, args) +#define DEBUG_TRACE(ProcName) +#endif + + +// Macro to create the OSVersion field of the property +// set header. + +#define MAKEPSVER(oskind, major, minor) \ + (((oskind) << 16) | ((minor) << 8) | (major)) + + + +//+----------------------------------------------------------------------- +//+----------------------------------------------------------------------- +// +// Byte-swapping functions +// +//+----------------------------------------------------------------------- +//+----------------------------------------------------------------------- + +// FmtID Byte-Swapped Comparisson. I.e, does rfmtid1 equal +// a byte-swapped rfmtid2? + +inline BOOL IsEqualFMTIDByteSwap( REFFMTID rfmtid1, REFFMTID rfmtid2 ) +{ + + return( rfmtid1.Data1 == ByteSwap(rfmtid2.Data1) + && + rfmtid1.Data2 == ByteSwap(rfmtid2.Data2) + && + rfmtid1.Data3 == ByteSwap(rfmtid2.Data3) + && + !memcmp(&rfmtid1.Data4, &rfmtid2.Data4, sizeof(rfmtid1.Data4)) + ); +} + + +// This define is for a special-case value of cbByteSwap in +// PBSBuffer + +#define CBBYTESWAP_UID ((ULONG) -1) + +// The following byte-swapping functions mostly forward the call +// to the ByteSwap overloads when compiled in a big-endian +// system, and NOOP when compiled in a little-endian +// system (because property sets are always little-endian). + +#ifdef BIGENDIAN + +// This is a big-endian build, property byte-swapping is enabled. + +// ----------- +// Swap a Byte +// ----------- + +// This exists primarily so that PropByteSwap(OLECHAR) will work +// whether OLECHAR is Unicode or Ansi. + +inline BYTE PropByteSwap( UCHAR uc ) +{ + return ByteSwap( (BYTE) uc ); +} +inline VOID PropByteSwap( UCHAR *puc) +{ + ByteSwap( (BYTE*) puc ); +} +inline char PropByteSwap( CHAR c ) +{ + return (CHAR) ByteSwap( (BYTE) c ); +} +inline VOID PropByteSwap( CHAR *pc ) +{ + ByteSwap( (BYTE*) pc ); +} + +// ----------- +// Swap a Word +// ----------- + +inline WORD PropByteSwap( WORD w ) +{ + return ByteSwap(w); +} +inline VOID PropByteSwap( WORD *pw ) +{ + ByteSwap(pw); +} +inline SHORT PropByteSwap( SHORT s ) +{ + PROPASSERT( sizeof(WORD) == sizeof(SHORT) ); + return ByteSwap( (WORD) s ); +} +inline VOID PropByteSwap( SHORT *ps ) +{ + PROPASSERT( sizeof(WORD) == sizeof(SHORT) ); + ByteSwap( (WORD*) ps ); +} + +// ------------ +// Swap a DWORD +// ------------ + +inline DWORD PropByteSwap( DWORD dw ) +{ + return ByteSwap(dw); +} +inline VOID PropByteSwap( DWORD *pdw ) +{ + ByteSwap(pdw); +} +inline LONG PropByteSwap( LONG l ) +{ + PROPASSERT( sizeof(DWORD) == sizeof(LONG) ); + return ByteSwap( (DWORD) l ); +} +inline VOID PropByteSwap( LONG *pl ) +{ + PROPASSERT( sizeof(DWORD) == sizeof(LONG) ); + ByteSwap( (DWORD*) pl ); +} + +// ------------------------- +// Swap a LONGLONG (64 bits) +// ------------------------- + +// This routine byte-swaps the LONGLONG's DWORDs independently; +// because in the property code, we might swap a +// LONGLONG within a property set, which is only +// 32 bit aligned. + +inline VOID PropByteSwap( LONGLONG *pll ) +{ + DWORD dwFirst, dwSecond; + PROPASSERT( sizeof(LONGLONG) == 2 * sizeof(DWORD) ); + + // Get this LONGLONG's two DWORDs + dwFirst = *(DWORD*) pll; + dwSecond = *( (DWORD*) pll + 1 ); + + // Swap each of the DWORDs + ByteSwap( &dwFirst ); + ByteSwap( &dwSecond ); + + // Put the DWORDs back into the LONGLONG, but with + // their order swapped (second the first). + + *(DWORD*) pll = dwSecond; + *( (DWORD*) pll + 1 ) = dwFirst; +} +inline LONGLONG PropByteSwap( LONGLONG ll ) +{ + PropByteSwap( &ll ); + return( ll ); +} + +// ----------- +// Swap a GUID +// ----------- + +inline VOID PropByteSwap( GUID *pguid ) +{ + ByteSwap(pguid); + return; +} + + +#else // Little Endian + +// This is a little-endian build, property byte-swapping is disabled. + + +inline BYTE PropByteSwap( BYTE b ) +{ + return (b); +} +inline VOID PropByteSwap( BYTE *pb ) +{ +} + + +inline WORD PropByteSwap( WORD w ) +{ + return (w); +} +inline VOID PropByteSwap( WORD *pw ) +{ +} +inline SHORT PropByteSwap( SHORT s ) +{ + return (s); +} +inline VOID PropByteSwap( SHORT *ps ) +{ +} + +inline DWORD PropByteSwap( DWORD dw ) +{ + return (dw); +} +inline VOID PropByteSwap( DWORD *pdw ) +{ +} +inline LONG PropByteSwap( LONG l ) +{ + return (l); +} +inline VOID PropByteSwap( LONG *pl ) +{ +} + +inline LONGLONG PropByteSwap( LONGLONG ll ) +{ + return(ll); +} +inline VOID PropByteSwap( LONGLONG *pll ) +{ +} + +inline VOID PropByteSwap( GUID *pguid ) +{ +} + + +#endif // #ifdef BIGENDIAN ... #else + +#endif // _PROPMAC_HXX_ -- cgit v1.2.3