Leaked source code of windows server 2003
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

411 lines
11 KiB

//+-------------------------------------------------------------------------
//
// Microsoft Windows
// Copyright (C) Microsoft Corporation, 1992 - 2000
//
// File: Util.h
//
// Contents: Generic utility functions and classes for dscmd
//
// History: 01-Oct-2000 JeffJon Created
//
//--------------------------------------------------------------------------
#ifndef _UTIL_H_
#define _UTIL_H_
#ifdef DBG
//+--------------------------------------------------------------------------
//
// Class: CDebugSpew
//
// Purpose: Signifies whether to spew debug output on checked builds or not
//
// History: 01-Oct-2000 JeffJon Created
//
//---------------------------------------------------------------------------
class CDebugSpew
{
public:
//
// Constructor/Destructor
//
CDebugSpew()
: m_nDebugLevel(0),
m_nIndent(0)
{}
~CDebugSpew() {}
//
// Public data accessors
//
void SetDebugLevel(UINT nDebugLevel) { m_nDebugLevel = nDebugLevel; }
UINT GetDebugLevel() { return m_nDebugLevel; }
bool IsDebugEnabled() const { return (m_nDebugLevel > 0); }
void SpewHeader();
void EnterFunction(UINT nLevel, PCWSTR pszFunction);
void LeaveFunction(UINT nLevel, PCWSTR pszFunction);
void LeaveFunctionHr(UINT nLevel, PCWSTR pszFunction, HRESULT hr);
void Output(UINT nLevel, PCWSTR pszOutput, ...);
private:
//
// Private data accessors
//
void Indent() { m_nIndent += TAB; }
void Outdent() { (m_nIndent >= TAB) ? m_nIndent -= TAB : m_nIndent = 0; }
UINT GetIndent() { return m_nIndent; }
//
// Private data
//
//
// This should always be in the range of 0 - 10 where zero is no debug output
// and 10 is complete output
//
UINT m_nDebugLevel;
UINT m_nIndent;
static const UINT TAB = 3;
};
//
// Globals
//
extern CDebugSpew DebugSpew;
//+--------------------------------------------------------------------------
//
// Class: CFunctionSpew
//
// Purpose: Object which outputs the "Enter function" debug spew on creation
// and outputs the "Leave function" debug spew on destruction
//
// History: 07-Dec-2000 JeffJon Created
//
//---------------------------------------------------------------------------
class CFunctionSpew
{
public:
//
// Constructor/Destructor
//
CFunctionSpew(UINT nDebugLevel,
PCWSTR pszFunctionName)
: m_nDebugLevel(nDebugLevel),
m_pszFunctionName(pszFunctionName),
m_bLeaveAlreadyWritten(false)
{
ASSERT(pszFunctionName);
DebugSpew.EnterFunction(nDebugLevel, pszFunctionName);
}
virtual ~CFunctionSpew()
{
if (!IsLeaveAlreadyWritten())
{
DebugSpew.LeaveFunction(GetDebugLevel(), GetFunctionName());
}
}
protected:
PCWSTR GetFunctionName() { return m_pszFunctionName; }
UINT GetDebugLevel() { return m_nDebugLevel; }
bool IsLeaveAlreadyWritten() { return m_bLeaveAlreadyWritten; }
void SetLeaveAlreadyWritten(){ m_bLeaveAlreadyWritten = true; }
private:
PCWSTR m_pszFunctionName;
UINT m_nDebugLevel;
bool m_bLeaveAlreadyWritten;
};
//+--------------------------------------------------------------------------
//
// Class: CFunctionSpewHR
//
// Purpose: Object which outputs the "Enter function" debug spew on creation
// and outputs the "Leave function" with the HRESULT return value
// on destruction
//
// History: 07-Dec-2000 JeffJon Created
//
//---------------------------------------------------------------------------
class CFunctionSpewHR : public CFunctionSpew
{
public:
//
// Constructor/Destructor
//
CFunctionSpewHR(UINT nDebugLevel,
PCWSTR pszFunctionName,
HRESULT& refHR)
: m_refHR(refHR),
CFunctionSpew(nDebugLevel, pszFunctionName)
{
}
virtual ~CFunctionSpewHR()
{
DebugSpew.LeaveFunctionHr(GetDebugLevel(), GetFunctionName(), m_refHR);
SetLeaveAlreadyWritten();
}
private:
HRESULT& m_refHR;
};
//
// Helper macros for use with CDebugSpew
//
#define ENABLE_DEBUG_OUTPUT(level) DebugSpew.SetDebugLevel((level)); \
DebugSpew.SpewHeader();
#define DISABLE_DEBUG_OUTPUT() DebugSpew.SetDebugLevel(0);
#define ENTER_FUNCTION(level, func) CFunctionSpew functionSpewObject((level), TEXT(#func));
#define ENTER_FUNCTION_HR(level, func, hr) HRESULT (hr) = S_OK; \
CFunctionSpewHR functionSpewObject((level), TEXT(#func), (hr));
#define LEAVE_FUNCTION(level, func) DebugSpew.LeaveFunction((level), TEXT(#func));
#define LEAVE_FUNCTION_HR(level, func, hr) DebugSpew.LeaveFunctionHr((level), TEXT(#func), (hr));
#define DEBUG_OUTPUT DebugSpew.Output
#else
#define ENABLE_DEBUG_OUTPUT(level)
#define DISABLE_DEBUG_OUTPUT()
#define ENTER_FUNCTION(level, func)
#define ENTER_FUNCTION_HR(level, func, hr) HRESULT (hr) = S_OK;
#define LEAVE_FUNCTION(level, func)
#define LEAVE_FUNCTION_HR(level, func, hr)
#define DEBUG_OUTPUT
#endif // DBG
//
// Debug log levels - NOTE these can be given more meaningful names as needed
//
enum
{
NO_DEBUG_LOGGING = 0,
MINIMAL_LOGGING,
LEVEL2_LOGGING,
LEVEL3_LOGGING,
LEVEL4_LOGGING,
LEVEL5_LOGGING,
LEVEL6_LOGGING,
LEVEL7_LOGGING,
LEVEL8_LOGGING,
LEVEL9_LOGGING,
FULL_LOGGING
};
//+--------------------------------------------------------------------------
//
// Function: _UnicodeToOemConvert
//
// Synopsis: takes the passed in string (pszUnicode) and converts it to
// the OEM code page
//
// Arguments: [pszUnicode - IN] : the string to be converted
// [sbstrOemUnicode - OUT] : the converted string
//
// Returns:
//
// History: 04-Oct-2000 JeffJon Created
//
//---------------------------------------------------------------------------
void _UnicodeToOemConvert(PCWSTR pszUnicode, CComBSTR& sbstrOemUnicode);
//+--------------------------------------------------------------------------
//
// Function: SpewAttrs(ADS_ATTR_INFO* pCreateAttrs, DWORD dwNumAttrs);
//
// Synopsis: Uses the DEBUG_OUTPUT macro to output the attributes and the
// values specified
//
// Arguments: [pAttrs - IN] : The ADS_ATTR_INFO
// [dwNumAttrs - IN] : The number of attributes in pAttrs
//
// Returns:
//
// History: 04-Oct-2000 JeffJon Created
//
//---------------------------------------------------------------------------
#ifdef DBG
void SpewAttrs(ADS_ATTR_INFO* pAttrs, DWORD dwNumAttrs);
#endif // DBG
//+--------------------------------------------------------------------------
//
// Function: litow
//
// Synopsis:
//
// Arguments: [li - IN] : reference to large integer to be converted to string
// [sResult - OUT] : Gets the output string
// Returns: void
//
// History: 25-Sep-2000 hiteshr Created
// Copied from dsadmin code base, changed work with CComBSTR
//---------------------------------------------------------------------------
void litow(LARGE_INTEGER& li, CComBSTR& sResult);
//+--------------------------------------------------------------------------
//
// Class: CManagedStringEntry
//
// Synopsis: My own string list entry since we are not using MFC
//
// History: 25-Oct-2000 JeffJon Created
//
//---------------------------------------------------------------------------
class CManagedStringEntry
{
public:
//
// Constructor
//
CManagedStringEntry(PCWSTR pszValue) : pNext(NULL), sbstrValue(pszValue) {}
CComBSTR sbstrValue;
CManagedStringEntry* pNext;
};
//+--------------------------------------------------------------------------
//
// Class: CManagedStringList
//
// Synopsis: My own string list since we are not using MFC
//
// History: 25-Oct-2000 JeffJon Created
//
//---------------------------------------------------------------------------
class CManagedStringList
{
public:
//
// Constructor
//
CManagedStringList() : m_pHead(NULL), m_pTail(NULL), m_nCount(0) {}
//
// Destructor
//
~CManagedStringList()
{
DeleteAll();
}
void DeleteAll()
{
CManagedStringEntry* pEntry = m_pHead;
while (pEntry != NULL)
{
CManagedStringEntry* pTempEntry = pEntry;
pEntry = pEntry->pNext;
delete pTempEntry;
}
m_nCount = 0;
}
void Add(PCWSTR pszValue)
{
if (!m_pHead)
{
m_pHead = new CManagedStringEntry(pszValue);
m_pTail = m_pHead;
m_nCount++;
}
else
{
ASSERT(m_pTail);
m_pTail->pNext = new CManagedStringEntry(pszValue);
if (m_pTail->pNext)
{
m_pTail = m_pTail->pNext;
m_nCount++;
}
}
}
bool Contains(PCWSTR pszValue)
{
bool bRet = false;
for (CManagedStringEntry* pEntry = m_pHead; pEntry; pEntry = pEntry->pNext)
{
//Security Review:This is fine.
if (_wcsicmp(pEntry->sbstrValue, pszValue) == 0)
{
bRet = true;
break;
}
}
return bRet;
}
UINT GetCount()
{
return m_nCount;
}
CManagedStringEntry* Pop()
{
CManagedStringEntry* ret = m_pHead;
if (m_pHead)
{
m_pHead = m_pHead->pNext;
ret->pNext = 0;
}
return ret;
}
private:
CManagedStringEntry* m_pHead;
CManagedStringEntry* m_pTail;
UINT m_nCount;
};
//+--------------------------------------------------------------------------
//
// Function: EncryptPasswordString
//
// Synopsis:Encrypts a password.
//
// Arguments:[pszPassword - IN] : Input Password. Input password must be
// smaller than MAX_PASSWORD_LENGTH chars in length. Function
// doesnot modify this string.
//
// [pEncryptedDataBlob - OUT] : Gets the output encrypted
// datablob.
// Returns: HRESULT
//
// History: 27-March-2002 hiteshr Created
//---------------------------------------------------------------------------
HRESULT
EncryptPasswordString(IN LPCWSTR pszPassword,
OUT DATA_BLOB *pEncryptedDataBlob);
//+--------------------------------------------------------------------------
//
// Function: DecryptPasswordString
//
// Synopsis: Decrypt encrypted password data.
//
// Arguments: [pEncryptedDataBlob- IN] : Input encrypted password data.
// [ppszPassword - OUT] :Gets the output decrypted password.
// This must be freed using LocalFree
// Returns: HRESULT
//
// History: 27-March-2002 hiteshr Created
//---------------------------------------------------------------------------
HRESULT
DecryptPasswordString(IN const DATA_BLOB* pEncryptedDataBlob,
OUT LPWSTR *ppszPassword);
#endif // _UTIL_H_