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.
 
 
 
 
 
 

721 lines
20 KiB

/**********************************************************************/
/** Microsoft Windows/NT **/
/** Copyright(c) Microsoft Corporation, 1997 - 1999 **/
/**********************************************************************/
/*
general.h
Header file for the general DHCP snapin admin classes
FILE HISTORY:
*/
#ifndef _GENERAL_H
#define _GENERAL_H
extern const TCHAR g_szDefaultHelpTopic[];
#define SCOPE_DFAULT_LEASE_DAYS 8
#define SCOPE_DFAULT_LEASE_HOURS 0
#define SCOPE_DFAULT_LEASE_MINUTES 0
#define MSCOPE_DFAULT_LEASE_DAYS 30
#define MSCOPE_DFAULT_LEASE_HOURS 0
#define MSCOPE_DFAULT_LEASE_MINUTES 0
#define DYN_BOOTP_DFAULT_LEASE_DAYS 30
#define DYN_BOOTP_DFAULT_LEASE_HOURS 0
#define DYN_BOOTP_DFAULT_LEASE_MINUTES 0
#define DHCP_IP_ADDRESS_INVALID ((DHCP_IP_ADDRESS)0)
#define DHCP_OPTION_ID_CSR 249
class CDhcpServer;
class CTimerDesc
{
public:
SPITFSNode spNode;
CDhcpServer * pServer;
UINT_PTR uTimer;
TIMERPROC timerProc;
};
typedef CArray<CTimerDesc *, CTimerDesc *> CTimerArrayBase;
class CTimerMgr : CTimerArrayBase
{
public:
CTimerMgr();
~CTimerMgr();
public:
int AllocateTimer(ITFSNode * pNode, CDhcpServer * pServer, UINT uTimerValue, TIMERPROC TimerProc);
void FreeTimer(UINT_PTR uEventId);
void ChangeInterval(UINT_PTR uEventId, UINT uNewInterval);
CTimerDesc * GetTimerDesc(UINT_PTR uEventId);
CCriticalSection m_csTimerMgr;
};
typedef CArray<DWORD_DWORD, DWORD_DWORD> CDWordDWordArray;
/////////////////////////////////////////////////////////////////////
//
// CDhcpIpRange prototype
//
// Simple wrapper for a DHCP_IP_RANGE
//
/////////////////////////////////////////////////////////////////////
class CDhcpClient
{
public:
CDhcpClient ( const DHCP_CLIENT_INFO * pdhcClientInfo ) ;
CDhcpClient ( const DHCP_CLIENT_INFO_V4 * pdhcClientInfo ) ;
CDhcpClient () ;
~ CDhcpClient () ;
const CString & QueryName () const
{ return m_strName ; }
const CString & QueryComment () const
{ return m_strComment ; }
const CString & QueryHostName ( BOOL bNetbios = FALSE ) const
{ return bNetbios ? m_strHostNetbiosName : m_strHostName ; }
DHCP_IP_ADDRESS QueryIpAddress () const
{ return m_dhcpIpAddress ; }
DHCP_IP_MASK QuerySubnet () const
{ return m_dhcpIpMask ; }
DHCP_IP_ADDRESS QueryHostAddress () const
{ return m_dhcpIpHost ; }
const DATE_TIME & QueryExpiryDateTime () const
{ return m_dtExpires ; }
const CByteArray & QueryHardwareAddress () const
{ return m_baHardwareAddress ; }
BYTE QueryClientType() const
{ return m_bClientType; }
BOOL IsReservation () const
{ return m_bReservation ; }
void SetReservation ( BOOL bReservation = TRUE )
{ m_bReservation = bReservation ; }
// Data change accessors: SOME OF THESE THROW EXCEPTIONS
void SetIpAddress ( DHCP_IP_ADDRESS dhipa )
{ m_dhcpIpAddress = dhipa ; }
void SetIpMask ( DHCP_IP_ADDRESS dhipa )
{ m_dhcpIpMask = dhipa ; }
void SetName ( const CString & cName )
{ m_strName = cName ; }
void SetComment( const CString & cComment )
{ m_strComment = cComment ; }
void SetHostName ( const CString & cHostName )
{ m_strHostName = cHostName ; }
void SetHostNetbiosName ( const CString & cHostNbName )
{ m_strHostNetbiosName = cHostNbName ; }
void SetHostIpAddress ( DHCP_IP_ADDRESS dhipa )
{ m_dhcpIpHost = dhipa ; }
void SetExpiryDateTime ( DATE_TIME dt )
{ m_dtExpires = dt ; }
void SetHardwareAddress ( const CByteArray & caByte ) ;
void SetClientType(BYTE bClientType)
{ m_bClientType = bClientType; }
protected:
void InitializeData(const DHCP_CLIENT_INFO * pdhcClientInfo);
protected:
DHCP_IP_ADDRESS m_dhcpIpAddress; // Client's IP address
DHCP_IP_MASK m_dhcpIpMask; // Client's subnet
CByteArray m_baHardwareAddress; // hardware addresss
CString m_strName; // Client name
CString m_strComment; // Client comment
DATE_TIME m_dtExpires; // date/time lease expires
BOOL m_bReservation; // This is a reservation
BYTE m_bClientType; // Client Type V4 and above only
// Host information
CString m_strHostName;
CString m_strHostNetbiosName;
DHCP_IP_ADDRESS m_dhcpIpHost;
};
/////////////////////////////////////////////////////////////////////
//
// CDhcpIpRange prototype
//
// Simple wrapper for a DHCP_IP_RANGE
//
/////////////////////////////////////////////////////////////////////
class CDhcpIpRange
{
protected:
DHCP_IP_RANGE m_dhcpIpRange;
UINT m_RangeType;
public:
CDhcpIpRange (DHCP_IP_RANGE dhcpIpRange);
CDhcpIpRange ();
virtual ~CDhcpIpRange();
operator DHCP_IP_RANGE ()
{ return m_dhcpIpRange; }
operator DHCP_IP_RANGE () const
{ return m_dhcpIpRange; }
// Return TRUE if both addresses are generally OK
operator BOOL ()
{ return m_dhcpIpRange.StartAddress != DHCP_IP_ADDRESS_INVALID
&& m_dhcpIpRange.EndAddress != DHCP_IP_ADDRESS_INVALID
&& m_dhcpIpRange.StartAddress <= m_dhcpIpRange.EndAddress; }
CDhcpIpRange & operator = (const DHCP_IP_RANGE dhcpIpRange);
DHCP_IP_ADDRESS QueryAddr (BOOL bStart) const
{ return bStart ? m_dhcpIpRange.StartAddress : m_dhcpIpRange.EndAddress; }
DHCP_IP_ADDRESS SetAddr (DHCP_IP_ADDRESS dhcpIpAddress, BOOL bStart);
// Return TRUE if this range overlaps the given range.
BOOL IsOverlap (DHCP_IP_RANGE dhcpIpRange);
// Return TRUE if this range is a subset of the given range.
BOOL IsSubset (DHCP_IP_RANGE dhcpIpRange);
// Return TRUE if this range is a superset of the given range.
BOOL IsSuperset (DHCP_IP_RANGE dhcpIpRange);
// Sort helper function
//int OrderByAddress ( const CObjectPlus * pobIpRange ) const;
void SetRangeType(UINT uRangeType);
UINT GetRangeType();
};
typedef CList<CDhcpIpRange *, CDhcpIpRange *> CExclusionList;
/////////////////////////////////////////////////////////////////////
//
// CDhcpOptionValue prototype
//
// Simple wrapper for DHCP_OPTION_DATA
//
/////////////////////////////////////////////////////////////////////
class CDhcpOptionValue
{
public:
CDhcpOptionValue ( const DHCP_OPTION & dhcpOption );
CDhcpOptionValue ( const DHCP_OPTION_VALUE & dhcpOptionValue );
CDhcpOptionValue ( DHCP_OPTION_DATA_TYPE dhcDataType, INT cUpperBound = 0);
// Copy constructor.
CDhcpOptionValue ( const CDhcpOptionValue & cOptionValue );
CDhcpOptionValue ( const CDhcpOptionValue * dhcpOption );
// Assignment operator: assign a new value to this one.
CDhcpOptionValue & operator = ( const CDhcpOptionValue & dhcpValue );
CDhcpOptionValue () { };
~CDhcpOptionValue ();
//
// Query functions
//
DHCP_OPTION_DATA_TYPE QueryDataType () const
{
return m_dhcpOptionDataType;
}
int QueryUpperBound () const
{
return m_nUpperBound;
}
void SetUpperBound ( int nNewBound = 1 );
void RemoveAll();
long QueryNumber ( INT index = 0 ) const;
DHCP_IP_ADDRESS QueryIpAddr ( INT index = 0 ) const;
LPCTSTR QueryString ( INT index = 0 ) const;
INT QueryBinary ( INT index = 0 ) const;
const CByteArray * QueryBinaryArray () const;
DWORD_DWORD QueryDwordDword ( INT index = 0 ) const;
//
// Return a string representation of the current value.
//
LONG QueryDisplayString ( CString & strResult, BOOL fLineFeed = FALSE ) const;
LONG QueryRouteArrayDisplayString( CString & strResult) const;
//
// Modifiers: SetString accepts any string representation;
// others are specific.
//
LONG SetData ( const DHCP_OPTION_DATA * podData );
LONG SetData ( const CDhcpOptionValue * pOptionValue );
BOOL SetDataType ( DHCP_OPTION_DATA_TYPE dhcpType, INT cUpperBound = 0 );
LONG SetString ( LPCTSTR pszNewValue, INT index = 0 );
LONG SetNumber ( INT nValue, INT nIndex = 0 );
LONG SetIpAddr ( DHCP_IP_ADDRESS dhcpIpAddress, INT index = 0 );
LONG SetDwordDword ( DWORD_DWORD dwdwValue, INT index = 0 );
LONG RemoveString ( INT index = 0);
LONG RemoveNumber ( INT index = 0);
LONG RemoveIpAddr ( INT index = 0);
LONG RemoveDwordDword ( INT index = 0);
BOOL IsValid () const;
LONG CreateOptionDataStruct(//const CDhcpOptionValue * pdhcpOptionValue,
LPDHCP_OPTION_DATA * ppOptionData,
BOOL bForceType = FALSE);
LONG FreeOptionDataStruct();
// implementation
private:
//
// Release the value union data
//
void FreeValue ();
//
// Initialize the value union data
//
LONG InitValue ( DHCP_OPTION_DATA_TYPE dhcDataType,
INT cUpperBound,
BOOL bProvideDefaultValue = TRUE );
BOOL CreateBinaryData ( const DHCP_BINARY_DATA * podBin, DHCP_BINARY_DATA * pobData ) ;
BOOL CreateBinaryData ( const CByteArray * paByte, DHCP_BINARY_DATA * pobData ) ;
// Attributes
private:
DHCP_OPTION_DATA_TYPE m_dhcpOptionDataType;
DHCP_OPTION_DATA * m_pdhcpOptionDataStruct;
INT m_nUpperBound ;
union
{
CObject * pCObj; // Generic pointer
CDWordArray * paDword; // 8-, 16-, 32-bit data.
CStringArray * paString; // String data
CByteArray * paBinary; // Binary and encapsulated data
CDWordDWordArray * paDwordDword;// 62-bit data.
} m_dhcpOptionValue;
};
/////////////////////////////////////////////////////////////////////
//
// CDhcpOption prototype
//
// Simple wrapper for DHCP_OPTION
//
/////////////////////////////////////////////////////////////////////
class CDhcpOption
{
public:
// Standard constructor uses API data
CDhcpOption ( const DHCP_OPTION & dhpOption );
// Constructor that must get info about option id referenced by the given value.
CDhcpOption ( const DHCP_OPTION_VALUE & dhcpOptionValue,
LPCTSTR pszVendor,
LPCTSTR pszClass );
// Constructor with overriding value.
CDhcpOption ( const CDhcpOption & dhpType,
const DHCP_OPTION_VALUE & dhcOptionValue );
// Constructor for dynamic instances
CDhcpOption ( DHCP_OPTION_ID nId,
DHCP_OPTION_DATA_TYPE dhcType,
LPCTSTR pszOptionName,
LPCTSTR pszComment,
DHCP_OPTION_TYPE dhcOptType = DhcpUnaryElementTypeOption );
// Copy constructor
CDhcpOption ( const CDhcpOption & dhpType );
~CDhcpOption ();
CDhcpOptionValue & QueryValue ()
{
return m_dhcpOptionValue ;
}
const CDhcpOptionValue & QueryValue () const
{
return m_dhcpOptionValue ;
}
DHCP_OPTION_DATA_TYPE QueryDataType () const
{
return m_dhcpOptionValue.QueryDataType() ;
}
DHCP_OPTION_ID QueryId () const
{
return m_dhcpOptionId ;
}
LPCTSTR QueryName () const
{
return m_strName ;
}
LPCTSTR QueryComment () const
{
return m_strComment ;
}
void SetOptType ( DHCP_OPTION_TYPE dhcOptType ) ;
DHCP_OPTION_TYPE QueryOptType() const
{
return m_dhcpOptionType ;
}
// Return TRUE if the option type is an array.
BOOL IsArray () const
{
return QueryOptType() == DhcpArrayTypeOption ;
}
// Fill the given string with a displayable representation of the item.
void QueryDisplayName ( CString & cStr ) const ;
BOOL SetName ( LPCTSTR pszName ) ;
BOOL SetComment ( LPCTSTR pszComment ) ;
LONG Update ( const CDhcpOptionValue & dhcpOptionValue ) ;
static INT MaxSizeOfType ( DHCP_OPTION_DATA_TYPE dhcType ) ;
BOOL SetDirty(BOOL bDirty = TRUE)
{
BOOL bOldFlag = m_bDirty;
m_bDirty = bDirty;
return bOldFlag;
}
// vendor specifc option stuff
void SetVendor(LPCTSTR pszVendor) { m_strVendor = pszVendor; }
BOOL IsVendor() { return !m_strVendor.IsEmpty(); }
LPCTSTR GetVendor() { return m_strVendor.IsEmpty() ? NULL : (LPCTSTR) m_strVendor; }
BOOL IsDirty() { return m_bDirty; }
// class ID methods
LPCTSTR GetClassName() { return m_strClassName; }
void SetClassName(LPCTSTR pClassName) { m_strClassName = pClassName; }
BOOL IsClassOption() { return m_strClassName.IsEmpty() ? FALSE : TRUE; }
DWORD SetApiErr(DWORD dwErr)
{
DWORD dwOldErr = m_dwErr;
m_dwErr = dwErr;
return dwOldErr;
}
DWORD QueryApiErr() { return m_dwErr; }
protected:
DHCP_OPTION_ID m_dhcpOptionId; // Option identifier
DHCP_OPTION_TYPE m_dhcpOptionType; // Option type
CDhcpOptionValue m_dhcpOptionValue; // Default value info
CString m_strName; // Name of option
CString m_strComment; // Comment for option
CString m_strVendor; // Vendor Name for this option
BOOL m_bDirty;
DWORD m_dwErr; // stored err for later display
CString m_strClassName;
};
/////////////////////////////////////////////////////////////////////
//
// COptionList
//
// Object contains a list of options. Can be iterated.
//
/////////////////////////////////////////////////////////////////////
typedef CList<CDhcpOption*, CDhcpOption*> COptionListBase;
class COptionList : public COptionListBase
{
public:
COptionList()
: m_pos(NULL), m_bDirty(FALSE) {}
~COptionList()
{
DeleteAll();
}
public:
void DeleteAll()
{
while (!IsEmpty())
{
delete RemoveHead();
}
}
// removes an option from the list
void Remove(CDhcpOption * pOption)
{
POSITION pos = Find(pOption);
if (pos)
RemoveAt(pos);
}
void Reset() { m_pos = GetHeadPosition(); }
CDhcpOption * Next()
{
if (m_pos)
return GetNext(m_pos);
else
return NULL;
}
CDhcpOption * FindId(DWORD dwId, LPCTSTR pszVendor)
{
CDhcpOption * pOpt = NULL;
CString strVendor = pszVendor;
POSITION pos = GetHeadPosition();
while (pos)
{
CDhcpOption * pCurOpt = GetNext(pos);
if ( (pCurOpt->QueryId() == dwId) &&
( (!pszVendor && !pCurOpt->GetVendor()) ||
(pCurOpt->GetVendor() && (strVendor.CompareNoCase(pCurOpt->GetVendor()) == 0) ) ) )
{
pOpt = pCurOpt;
break;
}
}
return pOpt;
}
BOOL SetAll(BOOL bDirty)
{
BOOL bWasDirty = FALSE;
POSITION pos = GetHeadPosition();
while (pos)
{
CDhcpOption * pCurOpt = GetNext(pos);
if (pCurOpt->SetDirty(bDirty))
bWasDirty = TRUE;
}
return bWasDirty;
}
BOOL SetDirty(BOOL bDirty = TRUE)
{
BOOL bOldFlag = m_bDirty;
m_bDirty = bDirty;
return bOldFlag;
}
static int __cdecl SortByIdHelper(const void * pa, const void * pb)
{
CDhcpOption ** ppOpt1 = (CDhcpOption **) pa;
CDhcpOption ** ppOpt2 = (CDhcpOption **) pb;
if ((*ppOpt1)->QueryId() < (*ppOpt2)->QueryId())
return -1;
else
if ((*ppOpt1)->QueryId() > (*ppOpt2)->QueryId())
return 1;
else
{
// options have equal IDs, but standard options come first
if ((*ppOpt1)->IsVendor() && !(*ppOpt2)->IsVendor())
return 1;
else
if (!(*ppOpt1)->IsVendor() && (*ppOpt2)->IsVendor())
return -1;
else
return 0; // they are either both standard or both vendor -- equal
}
}
LONG SortById()
{
LONG err = 0;
CDhcpOption * pOpt;
int cItems = (int) GetCount();
if ( cItems < 2 )
return NO_ERROR;
CATCH_MEM_EXCEPTION
{
// Allocate the array
CDhcpOption ** paOpt = (CDhcpOption **) alloca(sizeof(CDhcpOption *) * cItems);
/// Fill the helper array.
POSITION pos = GetHeadPosition();
for (UINT i = 0; pos != NULL; i++ )
{
pOpt = GetNext(pos);
paOpt[i] = pOpt;
}
RemoveAll();
ASSERT( GetCount() == 0 );
// Sort the helper array
::qsort( paOpt,
cItems,
sizeof(paOpt[0]),
SortByIdHelper ) ;
// Refill the list from the helper array.
for ( i = 0 ; i < (UINT) cItems ; i++ )
{
AddTail( paOpt[i] );
}
ASSERT( GetCount() == cItems ) ;
}
END_MEM_EXCEPTION(err)
return err ;
}
private:
POSITION m_pos;
BOOL m_bDirty;
};
/*---------------------------------------------------------------------------
Class: COptionValueEnum
---------------------------------------------------------------------------*/
class COptionValueEnum : public COptionList
{
public:
COptionValueEnum();
DWORD Init(LPCTSTR pServer, LARGE_INTEGER & liVersion, DHCP_OPTION_SCOPE_INFO & dhcpOptionScopeInfo);
DWORD Enum();
void Copy(COptionValueEnum * pEnum);
void Remove(DHCP_OPTION_ID optionId, LPCTSTR pszVendor, LPCTSTR pszClass);
protected:
DWORD EnumOptions();
DWORD EnumOptionsV5();
// V5 Helper
HRESULT CreateOptions(LPDHCP_OPTION_VALUE_ARRAY pOptionValues, LPCTSTR pClassName, LPCTSTR pszVendor);
public:
DHCP_OPTION_SCOPE_INFO m_dhcpOptionScopeInfo;
LARGE_INTEGER m_liVersion;
CString m_strServer;
CString m_strDynBootpClassName;
};
/////////////////////////////////////////////////////////////////////
//
// CDhcpDefaultOptionsOnServer prototype
//
// Object contains a list of default options on a DHCP server
//
/////////////////////////////////////////////////////////////////////
class CDhcpDefaultOptionsOnServer
{
// constructors
public:
CDhcpDefaultOptionsOnServer();
~CDhcpDefaultOptionsOnServer();
// exposed functions
public:
LONG Enumerate(LPCWSTR pServer, LARGE_INTEGER liVersion);
CDhcpOption * Find(DHCP_OPTION_ID dhcpOptionId, LPCTSTR pszVendor);
BOOL IsEmpty() { return m_listOptions.IsEmpty(); }
int GetCount() { return (int) m_listOptions.GetCount(); }
CDhcpOption * First();
CDhcpOption * Next();
void Reset();
LONG SortById();
COptionList & GetOptionList() { return m_listOptions; }
// implementation
private:
LONG RemoveAll();
LONG EnumerateV4(LPCWSTR pServer);
LONG EnumerateV5(LPCWSTR pServer);
// attributes
private:
COptionList m_listOptions;
DWORD m_dwLastUpdate;
DWORD m_dwOptionsTotal;
POSITION m_pos;
};
/////////////////////////////////////////////////////////////////////
//
// CDhcpDefaultOptionsMasterList prototype
//
// Object contains master list of known options
//
/////////////////////////////////////////////////////////////////////
enum OPT_FIELD
{
OPTF_OPTION,
OPTF_NAME,
OPTF_TYPE,
OPTF_ARRAY_FLAG,
OPTF_LENGTH,
OPTF_DESCRIPTION,
OPTF_REMARK,
OPTF_MAX
};
typedef struct
{
int eOptType ;
LPCTSTR pszOptTypeName ;
} OPT_TOKEN ;
class CDhcpDefaultOptionsMasterList
{
// constructors
public:
CDhcpDefaultOptionsMasterList();
~CDhcpDefaultOptionsMasterList();
// exposed functions
public:
LONG BuildList();
CDhcpOption * First();
CDhcpOption * Next();
void Reset();
int GetCount();
// implementation
private:
BOOL scanNextParamType(LPCTSTR * ppszText, CDhcpOption * * ppParamType);
LPCTSTR scanNextField(LPCTSTR pszLine, LPTSTR pszOut, int cFieldSize);
BOOL allDigits(LPCTSTR psz);
int recognizeToken(OPT_TOKEN * apToken, LPCTSTR pszToken);
LPCTSTR skipToNextLine(LPCTSTR pszLine);
BOOL skipWs(LPCTSTR * ppszLine);
// attributes
private:
COptionList m_listOptions;
POSITION m_pos;
};
#endif _GENERAL_H