//+--------------------------------------------------------------------------
//
// 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 <ByteOrdr.hxx>
//
// 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 <propapi.h>
#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_