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.
5334 lines
143 KiB
5334 lines
143 KiB
/*++
|
|
|
|
Copyright (c) 1994 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
dhcpcmd.c
|
|
|
|
Abstract:
|
|
|
|
This file contains program to test all DHCP APIs.
|
|
|
|
Author:
|
|
|
|
Madan Appiah (madana) 5-Oct-1993
|
|
|
|
Environment:
|
|
|
|
User Mode - Win32
|
|
|
|
Revision History:
|
|
|
|
--*/
|
|
|
|
#include <nt.h>
|
|
#include <ntrtl.h>
|
|
#include <nturtl.h>
|
|
#include <windows.h>
|
|
#include <winsock.h>
|
|
#include <dhcp.h>
|
|
#include <dhcpapi.h>
|
|
#include <dhcplib.h>
|
|
#include <stdio.h>
|
|
#include <ctype.h>
|
|
#include <wchar.h>
|
|
#include <string.h>
|
|
#include <stdlib.h>
|
|
#include <time.h>
|
|
#include <jet.h> // for JET_cbColumnMost
|
|
#ifdef NT5
|
|
#include <mdhcsapi.h>
|
|
#endif NT5
|
|
#include <heapx.h>
|
|
#include <ipexport.h>
|
|
#include <icmpif.h>
|
|
#include <icmpapi.h>
|
|
#include <winnls.h>
|
|
|
|
#ifdef DBG
|
|
#ifdef __DHCP_USE_DEBUG_HEAP__
|
|
|
|
|
|
#pragma message ( "*** DHCPCMD will use debug heap ***" )
|
|
|
|
#define DhcpAllocateMemory(x) calloc(1,x)
|
|
#define DhcpFreeMemory(x) free(x)
|
|
|
|
#endif
|
|
#endif
|
|
|
|
|
|
typedef enum _COMMAND_CODE {
|
|
AddIpRange,
|
|
RemoveIpRange,
|
|
EnumIpRanges,
|
|
AddReservedIp,
|
|
EnumClients,
|
|
EnumClientsV5,
|
|
DeleteBadClients,
|
|
DeleteClient,
|
|
MibCounts,
|
|
ServerConfig,
|
|
GetDhcpVersion,
|
|
SetSuperScope,
|
|
DeleteSuperScope,
|
|
GetSuperScopeTable,
|
|
RemoveSubscope,
|
|
CheckDB,
|
|
CreateSubnet,
|
|
AddExcludeRange,
|
|
RemoveReservedIp,
|
|
RemoveExcludeRange,
|
|
SetSubnetState,
|
|
DeleteSubnet,
|
|
CreateOption,
|
|
DeleteOption,
|
|
EnumOptions,
|
|
SetGlobalOptionValue,
|
|
SetGlobalOptionValues,
|
|
RemoveGlobalOptionValue,
|
|
SetSubnetOptionValue,
|
|
RemoveSubnetOptionValue,
|
|
SetReservedOptionValue,
|
|
RemoveReservedOptionValue,
|
|
GetAllOptions,
|
|
GetAllOptionValues,
|
|
CreateMScope,
|
|
DeleteMScope,
|
|
AddMScopeRange,
|
|
EnumMScopeClients,
|
|
ReconcileMScope,
|
|
EnumMScopes,
|
|
MCastMibCounts,
|
|
CreateClass,
|
|
DeleteClass,
|
|
EnumClasses,
|
|
AddServer,
|
|
DelServer,
|
|
EnumServers,
|
|
GetServerStatus,
|
|
RetryAuthorization,
|
|
GetBindings,
|
|
SetBinding,
|
|
UnknownCommand
|
|
} COMMAND_CODE, *LPCOMMAND_CODE;
|
|
|
|
typedef struct _COMMAND_INFO {
|
|
LPSTR CommandName;
|
|
COMMAND_CODE CommandCode;
|
|
} COMMAND_INFO, *LPCOMMAND_INFO;
|
|
|
|
LPWSTR GlobalServerIpAddressUnicodeString = NULL;
|
|
LPSTR GlobalServerIpAddressAnsiString = NULL;
|
|
LPWSTR GlobalClassName = NULL;
|
|
LPWSTR GlobalVendorName = NULL;
|
|
BOOL GlobalIsVendor = FALSE;
|
|
BOOL GlobalNoRPC = FALSE;
|
|
BOOL GlobalNoDS = TRUE;
|
|
|
|
DWORD GlobalClientCount;
|
|
DWORD g_dwMajor = (DWORD) -1 ,
|
|
g_dwMinor = (DWORD) -1; // version control
|
|
|
|
#define CLASS_ID_VERSION 0x5
|
|
|
|
COMMAND_INFO GlobalCommandInfo[] = {
|
|
// global server stuff.
|
|
{"MibCounts", MibCounts },
|
|
{"GetVersion", GetDhcpVersion },
|
|
{"ServerConfig", ServerConfig },
|
|
|
|
// subnet stuff
|
|
{"CreateSubnet", CreateSubnet },
|
|
{"DeleteSubnet", DeleteSubnet },
|
|
{"SetSubnetState", SetSubnetState },
|
|
|
|
// ranges
|
|
{"AddIpRange", AddIpRange },
|
|
{"RemoveIpRange", RemoveIpRange },
|
|
#ifdef NT5
|
|
{"EnumIpRanges", EnumIpRanges },
|
|
#endif NT5
|
|
{"AddExcludeRange", AddExcludeRange },
|
|
{"RemoveExcludeRange", RemoveExcludeRange },
|
|
|
|
// active leases
|
|
{"EnumClients", EnumClients },
|
|
{"DeleteBadClients", DeleteBadClients },
|
|
{"DeleteClient", DeleteClient },
|
|
#ifdef NT5
|
|
{"EnumClientsV5", EnumClientsV5 },
|
|
#endif NT5
|
|
|
|
// reservations
|
|
{"AddReservedIp", AddReservedIp },
|
|
{"RemoveReservedIp", RemoveReservedIp },
|
|
|
|
// super-scoping
|
|
{"SetSuperScope", SetSuperScope },
|
|
{"DeleteSuperScope", DeleteSuperScope },
|
|
{"GetSuperScopeTable", GetSuperScopeTable },
|
|
{"RemoveSubscope", RemoveSubscope },
|
|
|
|
// reconcile
|
|
{"CheckDB", CheckDB },
|
|
|
|
// options
|
|
{"CreateOption", CreateOption },
|
|
{"DeleteOption", DeleteOption },
|
|
{"SetGlobalOptionValue", SetGlobalOptionValue },
|
|
{"SetGlobalOptionValues", SetGlobalOptionValues },
|
|
{"RemoveGlobalOptionValue", RemoveGlobalOptionValue },
|
|
{"SetSubnetOptionValue", SetSubnetOptionValue },
|
|
{"RemoveSubnetOptionValue", RemoveSubnetOptionValue },
|
|
{"SetReservedOptionValue",SetReservedOptionValue },
|
|
{"RemoveReservedOptionValue", RemoveReservedOptionValue },
|
|
{"EnumOptions", EnumOptions},
|
|
|
|
#ifdef NT5
|
|
{"GetAllOptions", GetAllOptions },
|
|
{"GetAllOptionValues", GetAllOptionValues },
|
|
|
|
// multicast stuff
|
|
{"CreateMScope", CreateMScope},
|
|
{"DeleteMScope", DeleteMScope},
|
|
{"AddMScopeIpRange", AddMScopeRange},
|
|
{"EnumMScopeClients", EnumMScopeClients},
|
|
{"ReconcileMScope", ReconcileMScope},
|
|
{"EnumMScopes", EnumMScopes},
|
|
{"MCastMibCounts", MCastMibCounts},
|
|
|
|
// classes
|
|
{"CreateClass", CreateClass},
|
|
{"DeleteClass", DeleteClass},
|
|
{"EnumClasses", EnumClasses},
|
|
|
|
// servers
|
|
{"AddServer", AddServer},
|
|
{"DeleteServer", DelServer},
|
|
{"EnumServers", EnumServers},
|
|
|
|
{"GetServerStatus", GetServerStatus},
|
|
{"RetryAuthorization", RetryAuthorization},
|
|
|
|
{"GetBindings", GetBindings},
|
|
{"SetBinding", SetBinding}
|
|
#endif NT5
|
|
};
|
|
|
|
typedef enum _CONFIG_COMMAND_CODE {
|
|
ConfigAPIProtocolSupport,
|
|
ConfigDatabaseName,
|
|
ConfigDatabasePath,
|
|
ConfigBackupPath,
|
|
ConfigBackupInterval,
|
|
ConfigDatabaseLoggingFlag,
|
|
ConfigRestoreFlag,
|
|
ConfigDatabaseCleanupInterval,
|
|
ConfigDebugFlag,
|
|
ConfigActivityLog,
|
|
ConfigPingRetries,
|
|
ConfigBootFileTable,
|
|
UnknownConfigCommand
|
|
} CONFIG_COMMAND_CODE, *LPCONFIG_COMMAND_CODE;
|
|
|
|
typedef struct _CONFIG_COMMAND_INFO {
|
|
LPSTR CommandName;
|
|
CONFIG_COMMAND_CODE CommandCode;
|
|
} CONFIG_COMMAND_INFO, *LPCONFIG_COMMAND_INFO;
|
|
|
|
CONFIG_COMMAND_INFO GlobalConfigCommandInfo[] =
|
|
{
|
|
{"APIProtocolSupport", ConfigAPIProtocolSupport },
|
|
{"DatabaseName", ConfigDatabaseName },
|
|
{"DatabasePath", ConfigDatabasePath },
|
|
{"BackupPath", ConfigBackupPath },
|
|
{"BackupInterval", ConfigBackupInterval },
|
|
{"DatabaseLoggingFlag", ConfigDatabaseLoggingFlag },
|
|
{"RestoreFlag", ConfigRestoreFlag },
|
|
{"DatabaseCleanupInterval", ConfigDatabaseCleanupInterval },
|
|
{"DebugFlag", ConfigDebugFlag },
|
|
{"ActivityLog", ConfigActivityLog },
|
|
{"PingRetries", ConfigPingRetries },
|
|
{"BootFileTable", ConfigBootFileTable }
|
|
};
|
|
|
|
|
|
|
|
|
|
#define DHCPCMD_VERSION_MAJOR 4
|
|
#define DHCPCMD_VERSION_MINOR 1
|
|
|
|
|
|
#if DBG
|
|
|
|
VOID
|
|
DhcpPrintRoutine(
|
|
IN DWORD DebugFlag,
|
|
IN LPSTR Format,
|
|
...
|
|
)
|
|
|
|
{
|
|
|
|
#define WSTRSIZE( wsz ) ( ( wcslen( wsz ) + 1 ) * sizeof( WCHAR ) )
|
|
|
|
#define MAX_PRINTF_LEN 1024 // Arbitrary.
|
|
|
|
va_list arglist;
|
|
char OutputBuffer[MAX_PRINTF_LEN];
|
|
ULONG length = 0;
|
|
|
|
//
|
|
// Put a the information requested by the caller onto the line
|
|
//
|
|
|
|
va_start(arglist, Format);
|
|
length += (ULONG) vsprintf(&OutputBuffer[length], Format, arglist);
|
|
va_end(arglist);
|
|
|
|
DhcpAssert(length <= MAX_PRINTF_LEN);
|
|
|
|
//
|
|
// Output to the debug terminal,
|
|
//
|
|
|
|
DbgPrint( "%s", OutputBuffer);
|
|
}
|
|
|
|
#endif // DBG
|
|
DWORD
|
|
SetOptionDataType(
|
|
LPSTR OptionTypeString,
|
|
LPSTR OptionValueString,
|
|
LPDHCP_OPTION_DATA_ELEMENT OptionData,
|
|
LPWSTR *UnicodeOptionValueString
|
|
)
|
|
{
|
|
DHCP_OPTION_DATA_TYPE OptionType;
|
|
DHCP_OPTION_ID OptionValue;
|
|
|
|
if( _stricmp( OptionTypeString, "BYTE") == 0 ) {
|
|
OptionType = DhcpByteOption;
|
|
} else if( _stricmp( OptionTypeString, "WORD") == 0 ) {
|
|
OptionType = DhcpWordOption;
|
|
} else if( _stricmp( OptionTypeString, "DWORD") == 0 ) {
|
|
OptionType = DhcpDWordOption;
|
|
} else if( _stricmp( OptionTypeString, "STRING") == 0 ) {
|
|
OptionType = DhcpStringDataOption;
|
|
} else if( _stricmp( OptionTypeString, "IPADDRESS") == 0 ) {
|
|
OptionType = DhcpIpAddressOption;
|
|
} else {
|
|
printf("OptionType either Unknown or not supported, %s.\n",
|
|
OptionTypeString );
|
|
return( ERROR_INVALID_PARAMETER );
|
|
}
|
|
|
|
OptionData->OptionType = OptionType;
|
|
|
|
switch( OptionType ) {
|
|
case DhcpByteOption:
|
|
OptionValue = strtoul( OptionValueString, NULL, 0 );
|
|
|
|
if( OptionValue & ~((BYTE)-1) ) {
|
|
printf("DefValue is too large (%ld).\n", OptionValue );
|
|
return( ERROR_INVALID_PARAMETER );
|
|
}
|
|
|
|
OptionData->Element.ByteOption = (BYTE)OptionValue;
|
|
break;
|
|
|
|
case DhcpWordOption:
|
|
OptionValue = strtoul( OptionValueString, NULL, 0 );
|
|
|
|
if( OptionValue & ~((WORD)-1) ) {
|
|
printf("DefValue is too large (%ld).\n", OptionValue );
|
|
return( ERROR_INVALID_PARAMETER );
|
|
}
|
|
|
|
OptionData->Element.WordOption = (WORD)OptionValue;
|
|
break;
|
|
|
|
case DhcpDWordOption:
|
|
OptionValue = strtoul( OptionValueString, NULL, 0 );
|
|
OptionData->Element.DWordOption = (DWORD)OptionValue;
|
|
break;
|
|
|
|
|
|
case DhcpIpAddressOption:
|
|
OptionData->Element.IpAddressOption =
|
|
DhcpDottedStringToIpAddress(OptionValueString);
|
|
break;
|
|
|
|
case DhcpStringDataOption:
|
|
*UnicodeOptionValueString =
|
|
DhcpOemToUnicode( OptionValueString, NULL );
|
|
if( UnicodeOptionValueString == NULL ) {
|
|
return( ERROR_NOT_ENOUGH_MEMORY );
|
|
}
|
|
OptionData->Element.StringDataOption = *UnicodeOptionValueString;
|
|
break;
|
|
|
|
default:
|
|
DhcpAssert(FALSE);
|
|
printf("CreateOptionValue: Unknown OptionType \n");
|
|
return( ERROR_INVALID_PARAMETER );
|
|
break;
|
|
}
|
|
|
|
return( ERROR_SUCCESS );
|
|
}
|
|
|
|
COMMAND_CODE
|
|
DecodeCommand(
|
|
LPSTR CommandName
|
|
)
|
|
{
|
|
DWORD i;
|
|
DWORD NumCommands;
|
|
|
|
NumCommands = sizeof(GlobalCommandInfo) / sizeof(COMMAND_INFO);
|
|
DhcpAssert( NumCommands <= UnknownCommand );
|
|
for( i = 0; i < NumCommands; i++) {
|
|
if( _stricmp( CommandName, GlobalCommandInfo[i].CommandName ) == 0 ) {
|
|
return( GlobalCommandInfo[i].CommandCode );
|
|
}
|
|
}
|
|
return( UnknownCommand );
|
|
}
|
|
|
|
VOID
|
|
PrintCommands(
|
|
VOID
|
|
)
|
|
{
|
|
DWORD i;
|
|
DWORD NumCommands;
|
|
|
|
NumCommands = sizeof(GlobalCommandInfo) / sizeof(COMMAND_INFO);
|
|
DhcpAssert( NumCommands <= UnknownCommand );
|
|
for( i = 0; i < NumCommands; i++) {
|
|
printf( " %s\n", GlobalCommandInfo[i].CommandName );
|
|
}
|
|
}
|
|
|
|
|
|
DWORD
|
|
ProcessCreateSubnet(
|
|
DWORD CommandArgc,
|
|
LPSTR *CommandArgv
|
|
)
|
|
{
|
|
DWORD Error;
|
|
DHCP_SUBNET_INFO SubnetInfo;
|
|
LPWSTR UnicodeSubnetName = NULL;
|
|
|
|
//
|
|
// Expected Parameters are : <SubnetAddress SubnetMask SubnetName>
|
|
//
|
|
|
|
|
|
if( CommandArgc < 3 ) {
|
|
printf("usage:DhcpCmd SrvIpAddress CreateSubnet [Command Parameters].\n"
|
|
"<Command Parameters> - <SubnetAddress SubnetMask SubnetName>.\n" );
|
|
Error = ERROR_SUCCESS;
|
|
goto Cleanup;
|
|
}
|
|
|
|
SubnetInfo.SubnetAddress =
|
|
DhcpDottedStringToIpAddress(CommandArgv[0]);
|
|
SubnetInfo.SubnetMask =
|
|
DhcpDottedStringToIpAddress(CommandArgv[1]);
|
|
|
|
UnicodeSubnetName = DhcpOemToUnicode( CommandArgv[2], NULL );
|
|
DhcpAssert( UnicodeSubnetName != NULL );
|
|
|
|
SubnetInfo.SubnetName = UnicodeSubnetName;
|
|
SubnetInfo.SubnetComment = NULL;
|
|
SubnetInfo.PrimaryHost.IpAddress =
|
|
DhcpDottedStringToIpAddress(GlobalServerIpAddressAnsiString);
|
|
|
|
SubnetInfo.PrimaryHost.NetBiosName = NULL;
|
|
SubnetInfo.PrimaryHost.HostName = NULL;
|
|
SubnetInfo.SubnetState = DhcpSubnetEnabled;
|
|
|
|
Error = DhcpCreateSubnet(
|
|
GlobalServerIpAddressUnicodeString,
|
|
SubnetInfo.SubnetAddress,
|
|
&SubnetInfo );
|
|
|
|
Cleanup:
|
|
|
|
if( UnicodeSubnetName != NULL ) {
|
|
DhcpFreeMemory( UnicodeSubnetName );
|
|
}
|
|
|
|
return( Error );
|
|
}
|
|
|
|
BOOL
|
|
IsValidServerVersion(
|
|
DWORD dwMajor,
|
|
DWORD dwMinor
|
|
)
|
|
{
|
|
DWORD dwServerVersion = MAKEWORD( dwMinor, dwMajor );
|
|
return ( dwServerVersion >=
|
|
MAKEWORD( DHCPCMD_VERSION_MINOR,
|
|
DHCPCMD_VERSION_MAJOR ));
|
|
}
|
|
|
|
DWORD
|
|
ProcessAddIpRange(
|
|
DWORD CommandArgc,
|
|
LPSTR *CommandArgv
|
|
)
|
|
{
|
|
DWORD Error;
|
|
ULONG MajorVersion, MinorVersion;
|
|
ULONG Resume;
|
|
DHCP_IP_RANGE IpRange;
|
|
DHCP_SUBNET_ELEMENT_DATA Element;
|
|
DHCP_SUBNET_ELEMENT_TYPE ElementType;
|
|
|
|
//
|
|
// Expected Parameters are : <SubnetAddress IpRangeStart IpRangeEnd>
|
|
//
|
|
|
|
if( CommandArgc < 3 ) {
|
|
printf("usage:DhcpCmd SrvIpAddress AddIpRange [Command Parameters].\n"
|
|
"<Command Parameters> - <SubnetAddress IpRangeStart IpRangeEnd>.\n" );
|
|
return( ERROR_SUCCESS );
|
|
}
|
|
|
|
IpRange.StartAddress = DhcpDottedStringToIpAddress(CommandArgv[1]);
|
|
IpRange.EndAddress = DhcpDottedStringToIpAddress(CommandArgv[2]);
|
|
|
|
Element.ElementType = DhcpIpRanges;
|
|
Element.Element.IpRange = &IpRange;
|
|
|
|
#ifdef NT5
|
|
if( CommandArgc >= 4 ) {
|
|
DHCP_BOOTP_IP_RANGE ThisRange = {IpRange.StartAddress, IpRange.EndAddress, 0, ~0};
|
|
|
|
Element.Element.IpRange = (PVOID)&ThisRange;
|
|
if( GlobalNoRPC ) {
|
|
MajorVersion = CLASS_ID_VERSION;
|
|
} else {
|
|
Error = DhcpGetVersion(GlobalServerIpAddressUnicodeString, &MajorVersion, &MinorVersion);
|
|
if( ERROR_SUCCESS != Error ) {
|
|
printf("Could not determine server version\n");
|
|
return Error;
|
|
}
|
|
}
|
|
|
|
if( MajorVersion >= CLASS_ID_VERSION ) {
|
|
if( CommandArgc >= 5 ) {
|
|
ThisRange.MaxBootpAllowed = strtoul( CommandArgv[4], NULL, 0 ) ;
|
|
}
|
|
|
|
if( 0 == _stricmp(CommandArgv[3], "DHCP") ) {
|
|
Element.ElementType = DhcpIpRangesDhcpOnly;
|
|
} else if( 0 == _stricmp(CommandArgv[3], "BOOTP") ) {
|
|
Element.ElementType = DhcpIpRangesBootpOnly;
|
|
} else if( 0 == _stricmp(CommandArgv[3], "DHCPBOOTP" ) ) {
|
|
Element.ElementType = DhcpIpRangesDhcpBootp;
|
|
} else {
|
|
printf("usage:DhcpCmd SrvIpAddress AddIpRange [Command Parameters].\n"
|
|
"<CommandParameters> - <SubnetAddress IpRangeStart"
|
|
" IpRangeEnd (DHCP | BOOTP | DHCPBOOTP)>\n");
|
|
return ERROR_SUCCESS;
|
|
}
|
|
|
|
return DhcpAddSubnetElementV5(
|
|
GlobalServerIpAddressUnicodeString,
|
|
DhcpDottedStringToIpAddress(CommandArgv[0]),
|
|
(PVOID)&Element
|
|
);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
Error = DhcpAddSubnetElement(
|
|
GlobalServerIpAddressUnicodeString,
|
|
DhcpDottedStringToIpAddress(CommandArgv[0]),
|
|
&Element );
|
|
|
|
return( Error );
|
|
}
|
|
|
|
DWORD
|
|
ProcessRemoveIpRange(
|
|
DWORD CommandArgc,
|
|
LPSTR *CommandArgv
|
|
)
|
|
{
|
|
DWORD Error;
|
|
ULONG MajorVersion, MinorVersion;
|
|
DHCP_IP_RANGE IpRange;
|
|
DHCP_SUBNET_ELEMENT_DATA Element;
|
|
DHCP_SUBNET_ELEMENT_TYPE ElementType;
|
|
|
|
//
|
|
// Expected Parameters are : <SubnetAddress IpRangeStart IpRangeEnd>
|
|
//
|
|
|
|
if( CommandArgc < 3 ) {
|
|
printf("usage:DhcpCmd SrvIpAddress RemoveIpRange [Command Parameters].\n"
|
|
"<Command Parameters> - <SubnetAddress IpRangeStart IpRangeEnd>.\n" );
|
|
return( ERROR_SUCCESS );
|
|
}
|
|
|
|
IpRange.StartAddress = DhcpDottedStringToIpAddress(CommandArgv[1]);
|
|
IpRange.EndAddress = DhcpDottedStringToIpAddress(CommandArgv[2]);
|
|
|
|
Element.ElementType = DhcpIpRanges;
|
|
Element.Element.IpRange = &IpRange;
|
|
|
|
#ifdef NT5
|
|
if( CommandArgc >= 4 ) {
|
|
if( GlobalNoRPC ) {
|
|
MajorVersion = CLASS_ID_VERSION;
|
|
} else {
|
|
Error = DhcpGetVersion(GlobalServerIpAddressUnicodeString, &MajorVersion, &MinorVersion);
|
|
if( ERROR_SUCCESS != Error ) {
|
|
printf("Could not determine server version\n");
|
|
return Error;
|
|
}
|
|
}
|
|
|
|
if( MajorVersion >= CLASS_ID_VERSION ) {
|
|
if( 0 == _stricmp(CommandArgv[3], "DHCP") ) {
|
|
Element.ElementType = DhcpIpRangesDhcpOnly;
|
|
} else if( 0 == _stricmp(CommandArgv[3], "BOOTP") ) {
|
|
Element.ElementType = DhcpIpRangesBootpOnly;
|
|
} else if( 0 == _stricmp(CommandArgv[3], "DHCPBOOTP" ) ) {
|
|
Element.ElementType = DhcpIpRangesDhcpBootp;
|
|
} else {
|
|
printf("usage:DhcpCmd SrvIpAddress AddIpRange [Command Parameters].\n"
|
|
"<CommandParameters> - <SubnetAddress IpRangeStart"
|
|
" IpRangeEnd (DHCP | BOOTP | DHCPBOOTP)>\n");
|
|
return ERROR_SUCCESS;
|
|
}
|
|
|
|
return DhcpRemoveSubnetElementV5(
|
|
GlobalServerIpAddressUnicodeString,
|
|
DhcpDottedStringToIpAddress(CommandArgv[0]),
|
|
(PVOID)&Element,
|
|
FALSE
|
|
);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
Error = DhcpRemoveSubnetElement(
|
|
GlobalServerIpAddressUnicodeString,
|
|
DhcpDottedStringToIpAddress(CommandArgv[0]),
|
|
&Element,
|
|
FALSE
|
|
);
|
|
|
|
return( Error );
|
|
}
|
|
|
|
#ifdef NT5
|
|
VOID
|
|
PrintRange(
|
|
DHCP_SUBNET_ELEMENT_TYPE Type,
|
|
DHCP_IP_ADDRESS Start,
|
|
DHCP_IP_ADDRESS End,
|
|
ULONG BootpAllocated,
|
|
ULONG MaxBootpAllowed
|
|
)
|
|
{
|
|
printf("Range: %s -", DhcpIpAddressToDottedString( Start ) );
|
|
printf("%s ", DhcpIpAddressToDottedString( End ) );
|
|
|
|
switch(Type ) {
|
|
case DhcpIpRanges : printf("\n"); break;
|
|
case DhcpIpRangesDhcpOnly : printf("DHCP\n"); break;
|
|
case DhcpIpRangesDhcpBootp:
|
|
printf("DHCPBOOTP Bootp Clients leased = %d; Max Allowed BootpClients = %ld\n",
|
|
BootpAllocated, MaxBootpAllowed
|
|
);
|
|
break;
|
|
case DhcpIpRangesBootpOnly:
|
|
printf("BOOTP Bootp Clients leased = %d; Max Allowed BootpClients = %ld\n",
|
|
BootpAllocated, MaxBootpAllowed
|
|
);
|
|
break;
|
|
default: printf("Unknown range type: %ld\n", Type);
|
|
}
|
|
}
|
|
|
|
DWORD
|
|
ProcessEnumIpRanges(
|
|
DWORD CommandArgc,
|
|
LPSTR *CommandArgv
|
|
)
|
|
{
|
|
ULONG Error;
|
|
ULONG MajorVersion, MinorVersion;
|
|
ULONG nRead, nTotal, i;
|
|
ULONG Resume;
|
|
BOOL fIsV5Call;
|
|
DHCP_SUBNET_ELEMENT_TYPE ElementType;
|
|
LPDHCP_SUBNET_ELEMENT_INFO_ARRAY_V4 Elements4;
|
|
LPDHCP_SUBNET_ELEMENT_INFO_ARRAY_V5 Elements5;
|
|
|
|
if( CommandArgc < 1 ) {
|
|
printf("usage:DhcpCmd SrvIpAddress EnumIpRanges <SubnetAddress>\n");
|
|
return ERROR_SUCCESS;
|
|
}
|
|
|
|
Error = DhcpGetVersion(GlobalServerIpAddressUnicodeString, &MajorVersion, &MinorVersion);
|
|
if( MajorVersion >= CLASS_ID_VERSION ) {
|
|
fIsV5Call = TRUE;
|
|
} else {
|
|
fIsV5Call = FALSE;
|
|
}
|
|
|
|
Resume = 0;
|
|
while( TRUE ) {
|
|
Elements5 = NULL;
|
|
Elements4 = NULL;
|
|
nRead = nTotal = 0;
|
|
|
|
if( fIsV5Call ) {
|
|
Error = DhcpEnumSubnetElementsV5(
|
|
GlobalServerIpAddressUnicodeString,
|
|
DhcpDottedStringToIpAddress(CommandArgv[0]),
|
|
DhcpIpRangesDhcpBootp,
|
|
&Resume,
|
|
~0,
|
|
&Elements5,
|
|
&nRead,
|
|
&nTotal
|
|
);
|
|
} else {
|
|
Error = DhcpEnumSubnetElementsV4(
|
|
GlobalServerIpAddressUnicodeString,
|
|
DhcpDottedStringToIpAddress(CommandArgv[0]),
|
|
DhcpIpRangesDhcpBootp,
|
|
&Resume,
|
|
~0,
|
|
&Elements4,
|
|
&nRead,
|
|
&nTotal
|
|
);
|
|
}
|
|
|
|
if( ERROR_SUCCESS == Error || ERROR_MORE_DATA == Error ) {
|
|
for( i = 0; i < nRead ; i ++ ) {
|
|
if( fIsV5Call ) {
|
|
PrintRange(
|
|
Elements5->Elements[i].ElementType,
|
|
Elements5->Elements[i].Element.IpRange->StartAddress,
|
|
Elements5->Elements[i].Element.IpRange->EndAddress,
|
|
Elements5->Elements[i].Element.IpRange->BootpAllocated,
|
|
Elements5->Elements[i].Element.IpRange->MaxBootpAllowed
|
|
);
|
|
} else {
|
|
PrintRange(
|
|
Elements4->Elements[i].ElementType,
|
|
Elements4->Elements[i].Element.IpRange->StartAddress,
|
|
Elements4->Elements[i].Element.IpRange->EndAddress,
|
|
0,
|
|
0
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
if( Elements4 ) DhcpRpcFreeMemory( Elements4 );
|
|
if( Elements5 ) DhcpRpcFreeMemory( Elements5 );
|
|
if( ERROR_SUCCESS == Error || ERROR_NO_MORE_ITEMS == Error ) break;
|
|
if( ERROR_MORE_DATA != Error ) return Error;
|
|
}
|
|
|
|
return ERROR_SUCCESS;
|
|
}
|
|
|
|
#endif NT5
|
|
|
|
#define COMMAND_ARG_TYPE 5
|
|
|
|
DWORD
|
|
ProcessBootpParameters(
|
|
DWORD cArgs,
|
|
LPSTR *ppszArgs,
|
|
DHCP_IP_RESERVATION_V4 *pReservation
|
|
)
|
|
{
|
|
DWORD dwResult = ERROR_SUCCESS;
|
|
|
|
|
|
if ( cArgs > COMMAND_ARG_TYPE )
|
|
{
|
|
// user specified the allowed client type
|
|
|
|
if ( !_stricmp( ppszArgs[ COMMAND_ARG_TYPE ], "bootp" ) )
|
|
{
|
|
pReservation->bAllowedClientTypes = CLIENT_TYPE_BOOTP;
|
|
}
|
|
else if ( !_stricmp ( ppszArgs[ COMMAND_ARG_TYPE ], "dhcp" ) )
|
|
{
|
|
pReservation->bAllowedClientTypes = CLIENT_TYPE_DHCP;
|
|
}
|
|
else if ( !_stricmp ( ppszArgs[ COMMAND_ARG_TYPE ], "both" ) )
|
|
{
|
|
pReservation->bAllowedClientTypes = CLIENT_TYPE_BOTH;
|
|
}
|
|
else
|
|
{
|
|
printf( "Specify BOOTP, DHCP, or BOTH for reservation type.\n" );
|
|
return ERROR_INVALID_PARAMETER;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// allow dhcp clients by default.
|
|
pReservation->bAllowedClientTypes = CLIENT_TYPE_DHCP;
|
|
return ERROR_SUCCESS;
|
|
}
|
|
|
|
return dwResult;
|
|
}
|
|
|
|
|
|
|
|
DWORD
|
|
ProcessAddReservedIp(
|
|
DWORD CommandArgc,
|
|
LPSTR *CommandArgv
|
|
)
|
|
{
|
|
#define MAX_ADDRESS_LENGTH 64 // 64 bytes
|
|
#define COMMAND_ARG_CLIENT_COMMENT 4
|
|
|
|
DWORD Error;
|
|
DHCP_SUBNET_ELEMENT_DATA_V4 Element;
|
|
DHCP_IP_RESERVATION_V4 ReserveElement;
|
|
DHCP_CLIENT_UID ClientUID;
|
|
BYTE Address[MAX_ADDRESS_LENGTH];
|
|
DWORD i;
|
|
DHCP_IP_ADDRESS ReservedIpAddress;
|
|
|
|
//
|
|
// Expected Parameters are : <SubnetAddress ReservedIp HWAddressString>
|
|
//
|
|
|
|
//
|
|
// if the server version is 4.1 or greater, <AllowedClientTypes> and <BootFileString> can
|
|
// also be supplied
|
|
//
|
|
|
|
|
|
if( CommandArgc < 3 ) {
|
|
printf("usage:DhcpCmd SrvIpAddress AddReservedIp "
|
|
"[Command Parameters].\n"
|
|
"<Command Parameters> - "
|
|
"<SubnetAddress ReservedIp HWAddressString [ClientName] [ClientComment]"
|
|
" [DHCP | BOOTP | BOTH]>\n" );
|
|
|
|
return( ERROR_SUCCESS );
|
|
}
|
|
|
|
//
|
|
// make HardwareAddress.
|
|
//
|
|
|
|
ClientUID.DataLength = strlen(CommandArgv[2]);
|
|
if( ClientUID.DataLength % 2 != 0 ) {
|
|
//
|
|
// address must be even length.
|
|
//
|
|
|
|
printf("ProcessAddReservedIp: address must be even length.\n");
|
|
return( ERROR_INVALID_PARAMETER );
|
|
}
|
|
|
|
ClientUID.DataLength /= 2;
|
|
DhcpAssert( ClientUID.DataLength < MAX_ADDRESS_LENGTH );
|
|
|
|
i = DhcpStringToHwAddress( (LPSTR)Address, CommandArgv[2] );
|
|
DhcpAssert( i == ClientUID.DataLength );
|
|
ClientUID.Data = Address;
|
|
|
|
//
|
|
// make reserve element.
|
|
//
|
|
|
|
ReservedIpAddress = DhcpDottedStringToIpAddress(CommandArgv[1]);
|
|
ReserveElement.ReservedIpAddress = ReservedIpAddress;
|
|
ReserveElement.ReservedForClient = &ClientUID;
|
|
|
|
Element.ElementType = DhcpReservedIps;
|
|
Element.Element.ReservedIp = &ReserveElement;
|
|
|
|
Error = ProcessBootpParameters( CommandArgc, CommandArgv, &ReserveElement );
|
|
if ( ERROR_SUCCESS != Error )
|
|
{
|
|
return Error;
|
|
}
|
|
|
|
Error = DhcpAddSubnetElementV4(
|
|
GlobalServerIpAddressUnicodeString,
|
|
DhcpDottedStringToIpAddress(CommandArgv[0]),
|
|
&Element );
|
|
|
|
if( Error != ERROR_SUCCESS ) {
|
|
return( Error );
|
|
}
|
|
|
|
//
|
|
// if we are asked to set the client name, do so.
|
|
//
|
|
|
|
if( CommandArgc > 3 ) {
|
|
|
|
DHCP_SEARCH_INFO ClientSearchInfo;
|
|
LPDHCP_CLIENT_INFO_V4 ClientInfo = NULL;
|
|
LPWSTR UnicodeClientName = NULL;
|
|
LPWSTR UnicodeClientComment = NULL;
|
|
|
|
//
|
|
// set client name.
|
|
//
|
|
|
|
ClientSearchInfo.SearchType = DhcpClientIpAddress;
|
|
ClientSearchInfo.SearchInfo.ClientIpAddress = ReservedIpAddress;
|
|
|
|
do {
|
|
|
|
Error = DhcpGetClientInfoV4(
|
|
GlobalServerIpAddressUnicodeString,
|
|
&ClientSearchInfo,
|
|
&ClientInfo );
|
|
|
|
if( Error != ERROR_SUCCESS ) {
|
|
break;
|
|
}
|
|
|
|
UnicodeClientName = DhcpOemToUnicode( CommandArgv[3], NULL );
|
|
|
|
if( UnicodeClientName == NULL ) {
|
|
Error = ERROR_NOT_ENOUGH_MEMORY;
|
|
break;
|
|
}
|
|
|
|
if ( ( wcslen( UnicodeClientName ) + 1 ) * sizeof(WCHAR) > JET_cbColumnMost ) {
|
|
printf("ProcessAddReservedIp: Client Name too long\n");
|
|
Error = ERROR_INVALID_PARAMETER;
|
|
break;
|
|
}
|
|
|
|
//
|
|
// if client comment is also given in the argument, store that
|
|
// as well.
|
|
//
|
|
if ( CommandArgc > COMMAND_ARG_CLIENT_COMMENT ) {
|
|
|
|
UnicodeClientComment = DhcpOemToUnicode( CommandArgv[COMMAND_ARG_CLIENT_COMMENT], NULL );
|
|
|
|
if (!UnicodeClientComment ) {
|
|
Error = ERROR_NOT_ENOUGH_MEMORY;
|
|
break;
|
|
}
|
|
|
|
//
|
|
// check the size here.
|
|
//
|
|
if ( ( wcslen( UnicodeClientComment ) + 1 ) * sizeof(WCHAR) > JET_cbColumnMost ) {
|
|
printf("ProcessAddReservedIp: Client Comment too long\n");
|
|
Error = ERROR_INVALID_PARAMETER;
|
|
break;
|
|
}
|
|
|
|
ClientInfo->ClientComment = UnicodeClientComment;
|
|
|
|
|
|
|
|
}
|
|
|
|
ClientInfo->ClientName = UnicodeClientName;
|
|
|
|
} while ( FALSE );
|
|
|
|
if ( Error == ERROR_SUCCESS ) {
|
|
|
|
Error = DhcpSetClientInfoV4(
|
|
GlobalServerIpAddressUnicodeString,
|
|
ClientInfo );
|
|
|
|
} else {
|
|
//
|
|
// Cleanup.
|
|
//
|
|
if ( ClientInfo ) {
|
|
DhcpRpcFreeMemory( ClientInfo );
|
|
}
|
|
if ( UnicodeClientName ) {
|
|
DhcpFreeMemory( UnicodeClientName );
|
|
}
|
|
if ( UnicodeClientComment ) {
|
|
DhcpFreeMemory( UnicodeClientComment );
|
|
}
|
|
}
|
|
|
|
} // if( CommandArgc > 3 )
|
|
|
|
|
|
return( Error );
|
|
}
|
|
|
|
DWORD
|
|
ProcessAddExcludeRange(
|
|
DWORD CommandArgc,
|
|
LPSTR *CommandArgv
|
|
)
|
|
{
|
|
DWORD Error;
|
|
DHCP_IP_RANGE IpRange;
|
|
DHCP_SUBNET_ELEMENT_DATA Element;
|
|
|
|
//
|
|
// Expected Parameters are : <SubnetAddress IpRangeStart IpRangeEnd>
|
|
//
|
|
|
|
|
|
if( CommandArgc < 3 ) {
|
|
printf("usage:DhcpCmd SrvIpAddress AddExcludeRange [Command Parameters].\n"
|
|
"<Command Parameters> - <SubnetAddress IpRangeStart IpRangeEnd>.\n" );
|
|
return( ERROR_SUCCESS );
|
|
}
|
|
|
|
IpRange.StartAddress = DhcpDottedStringToIpAddress(CommandArgv[1]);
|
|
IpRange.EndAddress = DhcpDottedStringToIpAddress(CommandArgv[2]);
|
|
|
|
Element.ElementType = DhcpExcludedIpRanges;
|
|
Element.Element.IpRange = &IpRange;
|
|
|
|
Error = DhcpAddSubnetElement(
|
|
GlobalServerIpAddressUnicodeString,
|
|
DhcpDottedStringToIpAddress(CommandArgv[0]),
|
|
&Element );
|
|
|
|
return( Error );
|
|
}
|
|
|
|
DWORD
|
|
ProcessRemoveExcludeRange(
|
|
DWORD CommandArgc,
|
|
LPSTR *CommandArgv
|
|
)
|
|
{
|
|
DWORD Error;
|
|
DHCP_SUBNET_ELEMENT_DATA Element;
|
|
DHCP_IP_RANGE IpRange;
|
|
|
|
//
|
|
// Expected Parameters are : <SubnetAddress IpRangeStart IpRangeEnd>
|
|
//
|
|
|
|
|
|
if( CommandArgc < 3 ) {
|
|
printf("usage:DhcpCmd SrvIpAddress RemoveExcludeRange [Command Parameters].\n"
|
|
"<Command Parameters> - <SubnetAddress IpRangeStart IpRangeEnd>.\n" );
|
|
return( ERROR_SUCCESS );
|
|
}
|
|
|
|
IpRange.StartAddress = DhcpDottedStringToIpAddress(CommandArgv[1]);
|
|
IpRange.EndAddress = DhcpDottedStringToIpAddress(CommandArgv[2]);
|
|
|
|
Element.ElementType = DhcpExcludedIpRanges;
|
|
Element.Element.ExcludeIpRange = &IpRange;
|
|
|
|
Error = DhcpRemoveSubnetElement(
|
|
GlobalServerIpAddressUnicodeString,
|
|
DhcpDottedStringToIpAddress(CommandArgv[0]),
|
|
&Element,
|
|
DhcpFullForce );
|
|
|
|
return( Error );
|
|
}
|
|
|
|
DWORD
|
|
ProcessRemoveReservedIp(
|
|
DWORD CommandArgc,
|
|
LPSTR *CommandArgv
|
|
)
|
|
{
|
|
DWORD Error;
|
|
DHCP_SUBNET_ELEMENT_DATA_V4 Element;
|
|
DHCP_IP_RESERVATION_V4 ReserveElement;
|
|
DHCP_CLIENT_UID ClientUID;
|
|
BYTE Address[MAX_ADDRESS_LENGTH];
|
|
DWORD i;
|
|
|
|
//
|
|
// Expected Parameters are : <SubnetAddress ReservedIp HWAddressString>
|
|
//
|
|
|
|
|
|
if( CommandArgc < 3 ) {
|
|
printf("usage:DhcpCmd SrvIpAddress RemoveReservedIp "
|
|
"[Command Parameters].\n"
|
|
"<Command Parameters> - "
|
|
"<SubnetAddress ReservedIp HWAddressString>.\n" );
|
|
|
|
return( ERROR_SUCCESS );
|
|
}
|
|
|
|
//
|
|
// make HardwareAddress.
|
|
//
|
|
|
|
ClientUID.DataLength = strlen(CommandArgv[2]);
|
|
if( ClientUID.DataLength % 2 != 0 ) {
|
|
//
|
|
// address must be even length.
|
|
//
|
|
|
|
printf("ProcessAddReservedIp: address must be even length.\n");
|
|
return( ERROR_INVALID_PARAMETER );
|
|
}
|
|
|
|
ClientUID.DataLength /= 2;
|
|
DhcpAssert( ClientUID.DataLength < MAX_ADDRESS_LENGTH );
|
|
|
|
i = DhcpStringToHwAddress( (LPSTR)Address, CommandArgv[2] );
|
|
DhcpAssert( i == ClientUID.DataLength );
|
|
ClientUID.Data = Address;
|
|
|
|
//
|
|
// make reserve element.
|
|
//
|
|
|
|
ReserveElement.ReservedIpAddress = DhcpDottedStringToIpAddress(CommandArgv[1]);
|
|
ReserveElement.ReservedForClient = &ClientUID;
|
|
|
|
Element.ElementType = DhcpReservedIps;
|
|
Element.Element.ReservedIp = &ReserveElement;
|
|
|
|
Error = DhcpRemoveSubnetElementV4(
|
|
GlobalServerIpAddressUnicodeString,
|
|
DhcpDottedStringToIpAddress(CommandArgv[0]),
|
|
&Element,
|
|
DhcpFullForce );
|
|
|
|
return( Error );
|
|
}
|
|
|
|
DWORD
|
|
ProcessSetSubnetState(
|
|
DWORD CommandArgc,
|
|
LPSTR *CommandArgv
|
|
)
|
|
{
|
|
DWORD Error;
|
|
LPDHCP_SUBNET_INFO SubnetInfo;
|
|
LPWSTR UnicodeSubnetName = NULL;
|
|
DWORD State;
|
|
|
|
//
|
|
// Expected Parameters are : <SubnetAddress SubnetMask SubnetName>
|
|
//
|
|
|
|
|
|
if( CommandArgc < 2 ) {
|
|
printf("usage:DhcpCmd SrvIpAddress SetSubnetState [Command Parameters].\n"
|
|
"<Command Parameters> - <SubnetAddress State>.\n" );
|
|
Error = ERROR_SUCCESS;
|
|
return( Error );
|
|
}
|
|
|
|
Error = DhcpGetSubnetInfo(
|
|
GlobalServerIpAddressUnicodeString,
|
|
DhcpDottedStringToIpAddress(CommandArgv[0]),
|
|
&SubnetInfo );
|
|
|
|
if( Error != ERROR_SUCCESS ) {
|
|
return( Error );
|
|
}
|
|
|
|
State = strtoul( CommandArgv[1], NULL, 0 );
|
|
|
|
if( State == 0 ) {
|
|
if( SubnetInfo->SubnetState == DhcpSubnetEnabled ) {
|
|
Error = ERROR_SUCCESS;
|
|
goto Cleanup;
|
|
}
|
|
SubnetInfo->SubnetState = DhcpSubnetEnabled;
|
|
}
|
|
else {
|
|
if( SubnetInfo->SubnetState == DhcpSubnetDisabled ) {
|
|
Error = ERROR_SUCCESS;
|
|
goto Cleanup;
|
|
}
|
|
SubnetInfo->SubnetState = DhcpSubnetDisabled;
|
|
}
|
|
|
|
Error = DhcpSetSubnetInfo(
|
|
GlobalServerIpAddressUnicodeString,
|
|
DhcpDottedStringToIpAddress(CommandArgv[0]),
|
|
SubnetInfo );
|
|
Cleanup:
|
|
|
|
if( SubnetInfo != NULL ) {
|
|
DhcpFreeMemory( SubnetInfo );
|
|
}
|
|
|
|
return( Error );
|
|
|
|
}
|
|
|
|
DWORD
|
|
ProcessDeleteSubnet(
|
|
IN DWORD CommandArgc,
|
|
IN LPSTR CommandArgv[]
|
|
)
|
|
{
|
|
DWORD Error;
|
|
DHCP_IP_ADDRESS SubnetAddress;
|
|
DHCP_FORCE_FLAG ForceFlag;
|
|
|
|
//
|
|
// Expected Parameters are :
|
|
// <SubnetAddress ForceFlag>
|
|
// <ForceFlag> : "DhcpFullForce" "DhcpNoForce"
|
|
|
|
if( CommandArgc != 2 ) {
|
|
printf("usage: DhcpCmd SrvIpAddress DeleteSubnet [Command Parameters].\n"
|
|
"<CommandParameters> - <SubnetAddress ForceFlag>.\n");
|
|
printf("<ForceFlag> : <DhcpFullForce | DhcpNoForce>.\n");
|
|
Error = ERROR_SUCCESS;
|
|
goto Cleanup;
|
|
}
|
|
|
|
SubnetAddress = DhcpDottedStringToIpAddress( CommandArgv[0] );
|
|
if( 0 == _stricmp(CommandArgv[1], "DhcpFullForce" ) ) {
|
|
ForceFlag = DhcpFullForce;
|
|
} else if( 0 == _stricmp(CommandArgv[1], "DhcpNoForce" ) ) {
|
|
ForceFlag = DhcpNoForce;
|
|
} else {
|
|
printf("Unknown force flag value: %s (expecting DhcpFullForce or DhcpNoForce)\n",
|
|
CommandArgv[1]);
|
|
Error = ERROR_INVALID_PARAMETER;
|
|
goto Cleanup;
|
|
}
|
|
|
|
Error = DhcpDeleteSubnet(
|
|
GlobalServerIpAddressUnicodeString,
|
|
SubnetAddress,
|
|
ForceFlag
|
|
);
|
|
|
|
Cleanup:
|
|
|
|
return Error;
|
|
}
|
|
|
|
DWORD
|
|
_CreateOption(
|
|
IN LPWSTR ServerAddress,
|
|
IN DWORD Flags,
|
|
IN DHCP_OPTION_ID OptionId,
|
|
IN LPWSTR ClassName,
|
|
IN LPWSTR VendorName,
|
|
IN DHCP_OPTION *OptionInfo
|
|
)
|
|
{
|
|
DWORD MajorVersion, MinorVersion;
|
|
DWORD Error;
|
|
|
|
#ifdef NT5
|
|
if( GlobalNoRPC ) {
|
|
MajorVersion = CLASS_ID_VERSION ;
|
|
} else {
|
|
Error = DhcpGetVersion(ServerAddress, &MajorVersion, &MinorVersion);
|
|
if( ERROR_SUCCESS != Error ) {
|
|
printf("Could not determine server version.\n");
|
|
return Error;
|
|
}
|
|
}
|
|
|
|
if( MajorVersion >= CLASS_ID_VERSION ) {
|
|
return DhcpCreateOptionV5(
|
|
ServerAddress,
|
|
GlobalIsVendor ? Flags | DHCP_FLAGS_OPTION_IS_VENDOR : Flags,
|
|
OptionId,
|
|
ClassName,
|
|
VendorName,
|
|
OptionInfo
|
|
);
|
|
}
|
|
|
|
// incorrect version, just do like before..
|
|
#endif
|
|
|
|
return DhcpCreateOption(
|
|
ServerAddress,
|
|
OptionId,
|
|
OptionInfo
|
|
);
|
|
}
|
|
|
|
ProcessCreateOption(
|
|
DWORD CommandArgc,
|
|
LPSTR *CommandArgv
|
|
)
|
|
{
|
|
DWORD Error;
|
|
DHCP_OPTION OptionInfo;
|
|
DHCP_OPTION_ID OptionID;
|
|
LPWSTR UnicodeOptionName = NULL;
|
|
LPWSTR UnicodeOptionValueString = NULL;
|
|
DHCP_OPTION_DATA_ELEMENT OptionData;
|
|
|
|
//
|
|
// Expected Parameters are :
|
|
// <OptionID OptionName DefValueType DefValue>
|
|
//
|
|
|
|
|
|
if( CommandArgc < 2 ) {
|
|
printf("usage:DhcpCmd SrvIpAddress CreateOption [Command Parameters].\n"
|
|
"<Command Parameters> - <OptionID OptionName <DefValueType DefValue>>.\n");
|
|
printf("<DefValueType> : <BYTE | WORD | DWORD | STRING | IPADDRESS>.\n");
|
|
Error = ERROR_SUCCESS;
|
|
goto Cleanup;
|
|
}
|
|
|
|
OptionID = strtoul( CommandArgv[0], NULL, 0 );
|
|
|
|
OptionInfo.OptionID = OptionID;
|
|
|
|
UnicodeOptionName = DhcpOemToUnicode( CommandArgv[1], NULL );
|
|
if( UnicodeOptionName == NULL ) {
|
|
Error = ERROR_NOT_ENOUGH_MEMORY;
|
|
goto Cleanup;
|
|
}
|
|
|
|
OptionInfo.OptionName = UnicodeOptionName;
|
|
OptionInfo.OptionComment = NULL;
|
|
|
|
if( CommandArgc >= 4 ) {
|
|
Error = SetOptionDataType(
|
|
CommandArgv[2],
|
|
CommandArgv[3],
|
|
&OptionData,
|
|
&UnicodeOptionValueString
|
|
);
|
|
|
|
if( Error != ERROR_SUCCESS ) {
|
|
goto Cleanup;
|
|
}
|
|
|
|
OptionInfo.DefaultValue.NumElements = 1;
|
|
OptionInfo.DefaultValue.Elements = &OptionData;
|
|
}
|
|
else {
|
|
OptionInfo.DefaultValue.NumElements = 0;
|
|
OptionInfo.DefaultValue.Elements = NULL;
|
|
}
|
|
|
|
OptionInfo.OptionType = DhcpUnaryElementTypeOption;
|
|
|
|
Error = _CreateOption(
|
|
GlobalServerIpAddressUnicodeString,
|
|
0,
|
|
OptionID,
|
|
GlobalClassName,
|
|
GlobalVendorName,
|
|
&OptionInfo
|
|
);
|
|
|
|
Cleanup:
|
|
if( UnicodeOptionName != NULL ) {
|
|
DhcpFreeMemory( UnicodeOptionName );
|
|
}
|
|
|
|
if( UnicodeOptionValueString != NULL ) {
|
|
DhcpFreeMemory( UnicodeOptionValueString );
|
|
}
|
|
|
|
return( Error );
|
|
|
|
}
|
|
|
|
DWORD
|
|
RemoveOption(
|
|
IN LPWSTR ServerAddress,
|
|
IN DWORD Flags,
|
|
IN DHCP_OPTION_ID OptionId,
|
|
IN LPWSTR ClassName,
|
|
IN LPWSTR VendorName
|
|
)
|
|
{
|
|
DWORD MajorVersion, MinorVersion;
|
|
DWORD Error;
|
|
|
|
#ifdef NT5
|
|
if( GlobalNoRPC ) {
|
|
MajorVersion = CLASS_ID_VERSION ;
|
|
} else {
|
|
Error = DhcpGetVersion(ServerAddress, &MajorVersion, &MinorVersion);
|
|
if( ERROR_SUCCESS != Error ) {
|
|
printf("Could not determine server version.\n");
|
|
return Error;
|
|
}
|
|
}
|
|
|
|
if( MajorVersion >= CLASS_ID_VERSION ) {
|
|
return DhcpRemoveOptionV5(
|
|
ServerAddress,
|
|
GlobalIsVendor ? Flags | DHCP_FLAGS_OPTION_IS_VENDOR : Flags,
|
|
OptionId,
|
|
ClassName,
|
|
VendorName
|
|
);
|
|
}
|
|
|
|
// incorrect version, just do like before..
|
|
#endif
|
|
|
|
return DhcpRemoveOption(
|
|
ServerAddress,
|
|
OptionId
|
|
);
|
|
}
|
|
|
|
ProcessDeleteOption(
|
|
DWORD CommandArgc,
|
|
LPSTR *CommandArgv
|
|
)
|
|
{
|
|
DWORD Error;
|
|
DHCP_OPTION_ID OptionID;
|
|
|
|
//
|
|
// Expected Parameters are :
|
|
// <OptionID>
|
|
//
|
|
|
|
|
|
if( CommandArgc != 1 ) {
|
|
printf("usage:DhcpCmd SrvIpAddress DeleteOption [Command Parameters].\n"
|
|
"<Command Parameters> - <OptionID>.\n");
|
|
Error = ERROR_SUCCESS;
|
|
goto Cleanup;
|
|
}
|
|
|
|
OptionID = strtoul( CommandArgv[0], NULL, 0 );
|
|
|
|
Error = RemoveOption(
|
|
GlobalServerIpAddressUnicodeString,
|
|
0,
|
|
OptionID,
|
|
GlobalClassName,
|
|
GlobalVendorName
|
|
);
|
|
|
|
Cleanup:
|
|
|
|
return Error ;
|
|
}
|
|
|
|
DWORD
|
|
SetOptionValue(
|
|
IN LPWSTR ServerAddress,
|
|
IN DWORD Flags,
|
|
IN DHCP_OPTION_ID OptionId,
|
|
IN LPWSTR ClassName,
|
|
IN LPWSTR VendorName,
|
|
IN LPDHCP_OPTION_SCOPE_INFO ScopeInfo,
|
|
IN LPDHCP_OPTION_DATA OptionValue
|
|
)
|
|
{
|
|
DWORD MajorVersion, MinorVersion;
|
|
DWORD Error;
|
|
|
|
#ifdef NT5
|
|
if( GlobalNoRPC ) {
|
|
MajorVersion = CLASS_ID_VERSION ;
|
|
} else {
|
|
Error = DhcpGetVersion(ServerAddress, &MajorVersion, &MinorVersion);
|
|
if( ERROR_SUCCESS != Error ) {
|
|
printf("Could not determine server version.\n");
|
|
return Error;
|
|
}
|
|
}
|
|
|
|
if( MajorVersion >= CLASS_ID_VERSION ) {
|
|
return DhcpSetOptionValueV5(
|
|
ServerAddress,
|
|
GlobalIsVendor ? Flags | DHCP_FLAGS_OPTION_IS_VENDOR : Flags,
|
|
OptionId,
|
|
ClassName,
|
|
VendorName,
|
|
ScopeInfo,
|
|
OptionValue
|
|
);
|
|
}
|
|
|
|
// incorrect version, just do like before..
|
|
#endif
|
|
|
|
return DhcpSetOptionValue(
|
|
ServerAddress,
|
|
OptionId,
|
|
ScopeInfo,
|
|
OptionValue
|
|
);
|
|
}
|
|
|
|
|
|
ProcessSetGlobalOptionValue(
|
|
DWORD CommandArgc,
|
|
LPSTR *CommandArgv
|
|
)
|
|
{
|
|
DWORD Error;
|
|
DHCP_OPTION_ID OptionID;
|
|
DHCP_OPTION_SCOPE_INFO ScopeInfo;
|
|
DHCP_OPTION_DATA OptionValue;
|
|
DHCP_OPTION_DATA_ELEMENT OptionData;
|
|
LPWSTR UnicodeOptionValueString = NULL;
|
|
|
|
//
|
|
// Expected Parameters are :
|
|
// <OptionID OptionType OptionValue>
|
|
//
|
|
|
|
if( CommandArgc < 3 ) {
|
|
printf("usage:DhcpCmd SrvIpAddress SetGlobalOptionValue [Command Parameters].\n"
|
|
"<Command Parameters> - <OptionID OptionType OptionValue>.\n");
|
|
Error = ERROR_SUCCESS;
|
|
goto Cleanup;
|
|
}
|
|
|
|
OptionID = strtoul( CommandArgv[0], NULL, 0 );
|
|
|
|
Error = SetOptionDataType(
|
|
CommandArgv[1],
|
|
CommandArgv[2],
|
|
&OptionData,
|
|
&UnicodeOptionValueString
|
|
);
|
|
|
|
if( Error != ERROR_SUCCESS ) {
|
|
goto Cleanup;
|
|
}
|
|
|
|
OptionValue.NumElements = 1;
|
|
OptionValue.Elements = &OptionData;
|
|
|
|
ScopeInfo.ScopeType = DhcpGlobalOptions;
|
|
ScopeInfo.ScopeInfo.GlobalScopeInfo = NULL;
|
|
|
|
Error = SetOptionValue(
|
|
GlobalServerIpAddressUnicodeString,
|
|
0,
|
|
(DHCP_OPTION_ID)OptionID,
|
|
GlobalClassName,
|
|
GlobalVendorName,
|
|
&ScopeInfo,
|
|
&OptionValue
|
|
);
|
|
Cleanup:
|
|
|
|
if( UnicodeOptionValueString != NULL ) {
|
|
DhcpFreeMemory( UnicodeOptionValueString );
|
|
}
|
|
|
|
return( Error );
|
|
}
|
|
|
|
DWORD
|
|
SetOptionValues(
|
|
IN LPWSTR ServerAddress,
|
|
IN DWORD Flags,
|
|
IN LPWSTR ClassName,
|
|
IN LPWSTR VendorName,
|
|
IN LPDHCP_OPTION_SCOPE_INFO ScopeInfo,
|
|
IN LPDHCP_OPTION_VALUE_ARRAY OptionValues
|
|
)
|
|
{
|
|
DWORD MajorVersion, MinorVersion;
|
|
DWORD Error;
|
|
|
|
#ifdef NT5
|
|
if( GlobalNoRPC ) {
|
|
MajorVersion = CLASS_ID_VERSION ;
|
|
} else {
|
|
Error = DhcpGetVersion(ServerAddress, &MajorVersion, &MinorVersion);
|
|
if( ERROR_SUCCESS != Error ) {
|
|
printf("Could not determine server version.\n");
|
|
return Error;
|
|
}
|
|
}
|
|
|
|
if( MajorVersion >= CLASS_ID_VERSION ) {
|
|
return DhcpSetOptionValuesV5(
|
|
ServerAddress,
|
|
GlobalIsVendor ? Flags | DHCP_FLAGS_OPTION_IS_VENDOR : Flags,
|
|
ClassName,
|
|
VendorName,
|
|
ScopeInfo,
|
|
OptionValues
|
|
);
|
|
}
|
|
|
|
// incorrect version, just do like before..
|
|
#endif
|
|
|
|
return DhcpSetOptionValues(
|
|
ServerAddress,
|
|
ScopeInfo,
|
|
OptionValues
|
|
);
|
|
}
|
|
|
|
ProcessSetGlobalOptionValues(
|
|
DWORD CommandArgc,
|
|
LPSTR *CommandArgv
|
|
)
|
|
{
|
|
|
|
#define NUM_VALUES 5
|
|
|
|
DWORD Error;
|
|
DHCP_OPTION_ID OptionID;
|
|
DHCP_OPTION_SCOPE_INFO ScopeInfo;
|
|
DHCP_OPTION_DATA OptionValue;
|
|
DHCP_OPTION_DATA_ELEMENT OptionData[NUM_VALUES];
|
|
LPWSTR UnicodeOptionValueString[NUM_VALUES];
|
|
|
|
DHCP_OPTION_VALUE_ARRAY ValuesArray;
|
|
DHCP_OPTION_VALUE Values[NUM_VALUES];
|
|
DWORD NumValue;
|
|
|
|
RtlZeroMemory( UnicodeOptionValueString, NUM_VALUES * sizeof(LPWSTR) );
|
|
|
|
//
|
|
// Expected Parameters are :
|
|
// <OptionID OptionType OptionValue>
|
|
//
|
|
|
|
if( CommandArgc < 3 ) {
|
|
printf("usage:DhcpCmd SrvIpAddress SetGlobalOptionValues [Command Parameters].\n"
|
|
"<Command Parameters> - <OptionID OptionType OptionValue> <..>.\n"); Error = ERROR_SUCCESS;
|
|
goto Cleanup;
|
|
}
|
|
|
|
for (NumValue = 0;
|
|
(CommandArgc >= 3) && (NumValue < NUM_VALUES);
|
|
NumValue++, CommandArgc -= 3, CommandArgv += 3 ) {
|
|
|
|
OptionID = strtoul( CommandArgv[0], NULL, 0 );
|
|
|
|
Error = SetOptionDataType(
|
|
CommandArgv[1],
|
|
CommandArgv[2],
|
|
&OptionData[NumValue],
|
|
&UnicodeOptionValueString[NumValue]
|
|
);
|
|
|
|
if( Error != ERROR_SUCCESS ) {
|
|
goto Cleanup;
|
|
}
|
|
|
|
Values[NumValue].OptionID = OptionID;
|
|
Values[NumValue].Value.NumElements = 1;
|
|
Values[NumValue].Value.Elements = &OptionData[NumValue];
|
|
}
|
|
|
|
ValuesArray.NumElements = NumValue;
|
|
ValuesArray.Values = Values;
|
|
|
|
ScopeInfo.ScopeType = DhcpGlobalOptions;
|
|
ScopeInfo.ScopeInfo.GlobalScopeInfo = NULL;
|
|
|
|
Error = SetOptionValues(
|
|
GlobalServerIpAddressUnicodeString,
|
|
0,
|
|
GlobalClassName,
|
|
GlobalVendorName,
|
|
&ScopeInfo,
|
|
&ValuesArray
|
|
);
|
|
|
|
Cleanup:
|
|
|
|
for (NumValue = 0; NumValue < NUM_VALUES; NumValue++) {
|
|
|
|
if( UnicodeOptionValueString[NumValue] != NULL ) {
|
|
DhcpFreeMemory( UnicodeOptionValueString );
|
|
}
|
|
}
|
|
|
|
return( Error );
|
|
}
|
|
|
|
DWORD
|
|
RemoveOptionValue(
|
|
IN LPWSTR ServerAddress,
|
|
IN DWORD Flags,
|
|
IN DHCP_OPTION_ID OptionID,
|
|
IN LPWSTR ClassName,
|
|
IN LPWSTR VendorName,
|
|
IN LPDHCP_OPTION_SCOPE_INFO ScopeInfo
|
|
)
|
|
{
|
|
DWORD MajorVersion, MinorVersion;
|
|
DWORD Error;
|
|
|
|
#ifdef NT5
|
|
if( GlobalNoRPC ) {
|
|
MajorVersion = CLASS_ID_VERSION ;
|
|
} else {
|
|
Error = DhcpGetVersion(ServerAddress, &MajorVersion, &MinorVersion);
|
|
if( ERROR_SUCCESS != Error ) {
|
|
printf("Could not determine server version.\n");
|
|
return Error;
|
|
}
|
|
}
|
|
|
|
if( MajorVersion >= CLASS_ID_VERSION ) {
|
|
return DhcpRemoveOptionValueV5(
|
|
ServerAddress,
|
|
GlobalIsVendor ? Flags | DHCP_FLAGS_OPTION_IS_VENDOR : Flags,
|
|
OptionID,
|
|
ClassName,
|
|
VendorName,
|
|
ScopeInfo
|
|
);
|
|
}
|
|
|
|
// incorrect version, just do like before..
|
|
#endif
|
|
|
|
return DhcpRemoveOptionValue(
|
|
ServerAddress,
|
|
OptionID,
|
|
ScopeInfo
|
|
);
|
|
}
|
|
|
|
DWORD
|
|
ProcessRemoveGlobalOptionValue(
|
|
DWORD CommandArgc,
|
|
LPSTR *CommandArgv
|
|
)
|
|
{
|
|
DWORD Error;
|
|
DHCP_OPTION_ID OptionID;
|
|
DHCP_OPTION_SCOPE_INFO ScopeInfo;
|
|
|
|
//
|
|
// Expected Parameters are :
|
|
// <OptionID OptionType OptionValue>
|
|
//
|
|
|
|
if( CommandArgc != 1 ) {
|
|
printf("usage:DhcpCmd SrvIpAddress RemoveGlobalOptionValue [Command Parameters].\n"
|
|
"<Command Parameters> - <OptionID>.\n");
|
|
Error = ERROR_SUCCESS;
|
|
goto Cleanup;
|
|
}
|
|
|
|
OptionID = strtoul( CommandArgv[0], NULL, 0 );
|
|
|
|
ScopeInfo.ScopeType = DhcpGlobalOptions;
|
|
ScopeInfo.ScopeInfo.GlobalScopeInfo = NULL;
|
|
|
|
Error = RemoveOptionValue(
|
|
GlobalServerIpAddressUnicodeString,
|
|
0,
|
|
(DHCP_OPTION_ID)OptionID,
|
|
GlobalClassName,
|
|
GlobalVendorName,
|
|
&ScopeInfo
|
|
);
|
|
|
|
Cleanup:
|
|
|
|
return Error ;
|
|
}
|
|
|
|
ProcessSetSubnetOptionValue(
|
|
DWORD CommandArgc,
|
|
LPSTR *CommandArgv
|
|
)
|
|
{
|
|
DWORD Error;
|
|
DHCP_OPTION_ID OptionID;
|
|
DHCP_OPTION_SCOPE_INFO ScopeInfo;
|
|
DHCP_OPTION_DATA OptionValue;
|
|
DHCP_OPTION_DATA_ELEMENT OptionData;
|
|
LPWSTR UnicodeOptionValueString = NULL;
|
|
|
|
//
|
|
// Expected Parameters are :
|
|
// subnet-address <OptionID OptionType OptionValue>
|
|
//
|
|
|
|
if( CommandArgc < 4 ) {
|
|
printf("usage:DhcpCmd SrvIpAddress SetSubnetOptionValue "
|
|
"[Command Parameters].\n"
|
|
"<Command Parameters> - "
|
|
"<SubnetAddress OptionID OptionType OptionValue>.\n");
|
|
Error = ERROR_SUCCESS;
|
|
goto Cleanup;
|
|
}
|
|
|
|
ScopeInfo.ScopeType = DhcpSubnetOptions;
|
|
ScopeInfo.ScopeInfo.SubnetScopeInfo = DhcpDottedStringToIpAddress( CommandArgv[0] );
|
|
|
|
OptionID = strtoul( CommandArgv[1], NULL, 0 );
|
|
|
|
Error = SetOptionDataType(
|
|
CommandArgv[2],
|
|
CommandArgv[3],
|
|
&OptionData,
|
|
&UnicodeOptionValueString );
|
|
|
|
if( Error != ERROR_SUCCESS ) {
|
|
goto Cleanup;
|
|
}
|
|
|
|
OptionValue.NumElements = 1;
|
|
OptionValue.Elements = &OptionData;
|
|
|
|
Error = SetOptionValue(
|
|
GlobalServerIpAddressUnicodeString,
|
|
0,
|
|
(DHCP_OPTION_ID)OptionID,
|
|
GlobalClassName,
|
|
GlobalVendorName,
|
|
&ScopeInfo,
|
|
&OptionValue
|
|
);
|
|
|
|
Cleanup:
|
|
|
|
if( UnicodeOptionValueString != NULL ) {
|
|
DhcpFreeMemory( UnicodeOptionValueString );
|
|
}
|
|
|
|
return( Error );
|
|
}
|
|
|
|
ProcessRemoveSubnetOptionValue(
|
|
DWORD CommandArgc,
|
|
LPSTR *CommandArgv
|
|
)
|
|
{
|
|
DWORD Error;
|
|
DHCP_OPTION_ID OptionID;
|
|
DHCP_OPTION_SCOPE_INFO ScopeInfo;
|
|
|
|
//
|
|
// Expected Parameters are :
|
|
// subnet-address <OptionID>
|
|
//
|
|
|
|
if( CommandArgc != 2 ) {
|
|
printf("usage:DhcpCmd SrvIpAddress RemoveSubnetOptionValue "
|
|
"[Command Parameters].\n"
|
|
"<Command Parameters> - "
|
|
"<SubnetAddress OptionID>.\n");
|
|
Error = ERROR_SUCCESS;
|
|
goto Cleanup;
|
|
}
|
|
|
|
ScopeInfo.ScopeType = DhcpSubnetOptions;
|
|
ScopeInfo.ScopeInfo.SubnetScopeInfo = DhcpDottedStringToIpAddress( CommandArgv[0] );
|
|
|
|
OptionID = strtoul( CommandArgv[1], NULL, 0 );
|
|
|
|
Error = RemoveOptionValue(
|
|
GlobalServerIpAddressUnicodeString,
|
|
0,
|
|
(DHCP_OPTION_ID)OptionID,
|
|
GlobalClassName,
|
|
GlobalVendorName,
|
|
&ScopeInfo
|
|
);
|
|
|
|
Cleanup:
|
|
|
|
return Error ;
|
|
}
|
|
|
|
ProcessSetReservedOptionValue(
|
|
DWORD CommandArgc,
|
|
LPSTR *CommandArgv
|
|
)
|
|
{
|
|
DWORD Error;
|
|
DHCP_OPTION_ID OptionID;
|
|
DHCP_OPTION_SCOPE_INFO ScopeInfo;
|
|
DHCP_OPTION_DATA OptionValue;
|
|
DHCP_OPTION_DATA_ELEMENT OptionData;
|
|
LPWSTR UnicodeOptionValueString = NULL;
|
|
|
|
//
|
|
// Expected Parameters are :
|
|
// subnet-address reservation-address <OptionID OptionType OptionValue>
|
|
//
|
|
|
|
if( CommandArgc < 5 ) {
|
|
printf("usage:DhcpCmd SrvIpAddress SetReservedOptionValue "
|
|
"[Command Parameters].\n"
|
|
"<Command Parameters> - "
|
|
"<SubnetAddress Reservation-Address OptionID OptionType OptionValue>.\n");
|
|
Error = ERROR_SUCCESS;
|
|
goto Cleanup;
|
|
}
|
|
|
|
ScopeInfo.ScopeType = DhcpReservedOptions;
|
|
ScopeInfo.ScopeInfo.ReservedScopeInfo.ReservedIpSubnetAddress =
|
|
DhcpDottedStringToIpAddress(CommandArgv[0]);
|
|
ScopeInfo.ScopeInfo.ReservedScopeInfo.ReservedIpAddress =
|
|
DhcpDottedStringToIpAddress( CommandArgv[1] );
|
|
|
|
OptionID = strtoul( CommandArgv[2], NULL, 0 );
|
|
|
|
Error = SetOptionDataType(
|
|
CommandArgv[3],
|
|
CommandArgv[4],
|
|
&OptionData,
|
|
&UnicodeOptionValueString
|
|
);
|
|
|
|
if( Error != ERROR_SUCCESS ) {
|
|
goto Cleanup;
|
|
}
|
|
|
|
OptionValue.NumElements = 1;
|
|
OptionValue.Elements = &OptionData;
|
|
|
|
Error = SetOptionValue(
|
|
GlobalServerIpAddressUnicodeString,
|
|
0,
|
|
(DHCP_OPTION_ID)OptionID,
|
|
GlobalClassName,
|
|
GlobalVendorName,
|
|
&ScopeInfo,
|
|
&OptionValue
|
|
);
|
|
|
|
Cleanup:
|
|
|
|
if( UnicodeOptionValueString != NULL ) {
|
|
DhcpFreeMemory( UnicodeOptionValueString );
|
|
}
|
|
|
|
return( Error );
|
|
}
|
|
|
|
ProcessRemoveReservedOptionValue(
|
|
DWORD CommandArgc,
|
|
LPSTR *CommandArgv
|
|
)
|
|
{
|
|
DWORD Error;
|
|
DHCP_OPTION_ID OptionID;
|
|
DHCP_OPTION_SCOPE_INFO ScopeInfo;
|
|
|
|
//
|
|
// Expected Parameters are :
|
|
// subnet-address reservation-address <OptionID>
|
|
//
|
|
|
|
if( CommandArgc < 3 ) {
|
|
printf("usage:DhcpCmd SrvIpAddress RemoveReservedOptionValue "
|
|
"[Command Parameters].\n"
|
|
"<Command Parameters> - "
|
|
"<SubnetAddress Reservation-Address OptionID>.\n");
|
|
Error = ERROR_SUCCESS;
|
|
goto Cleanup;
|
|
}
|
|
|
|
ScopeInfo.ScopeType = DhcpReservedOptions;
|
|
ScopeInfo.ScopeInfo.ReservedScopeInfo.ReservedIpSubnetAddress =
|
|
DhcpDottedStringToIpAddress(CommandArgv[0]);
|
|
ScopeInfo.ScopeInfo.ReservedScopeInfo.ReservedIpAddress =
|
|
DhcpDottedStringToIpAddress( CommandArgv[1] );
|
|
|
|
OptionID = strtoul( CommandArgv[2], NULL, 0 );
|
|
|
|
Error = RemoveOptionValue(
|
|
GlobalServerIpAddressUnicodeString,
|
|
0,
|
|
(DHCP_OPTION_ID)OptionID,
|
|
GlobalClassName,
|
|
GlobalVendorName,
|
|
&ScopeInfo
|
|
);
|
|
|
|
Cleanup:
|
|
|
|
return Error ;
|
|
}
|
|
|
|
|
|
VOID
|
|
PrintClientInfo(
|
|
LPDHCP_CLIENT_INFO_V4 ClientInfo
|
|
)
|
|
{
|
|
DWORD i;
|
|
DWORD DataLength;
|
|
LPBYTE Data;
|
|
SYSTEMTIME SystemTime;
|
|
FILETIME LocalTime;
|
|
char *szClientType;
|
|
|
|
printf("ClientInfo :\n");
|
|
printf("\tIP Address = %s.\n",
|
|
DhcpIpAddressToDottedString(ClientInfo->ClientIpAddress));
|
|
printf("\tSubnetMask = %s.\n",
|
|
DhcpIpAddressToDottedString(ClientInfo->SubnetMask));
|
|
|
|
DataLength = ClientInfo->ClientHardwareAddress.DataLength;
|
|
Data = ClientInfo->ClientHardwareAddress.Data;
|
|
printf("\tClient Hardware Address = ");
|
|
for( i = 0; i < DataLength; i++ ) {
|
|
if( (i+1) < DataLength ) {
|
|
printf("%.2lx-", (DWORD)Data[i]);
|
|
}
|
|
else {
|
|
printf("%.2lx", (DWORD)Data[i]);
|
|
}
|
|
}
|
|
printf(".\n");
|
|
|
|
printf("\tName = %ws.\n", ClientInfo->ClientName);
|
|
printf("\tComment = %ws.\n", ClientInfo->ClientComment);
|
|
printf("\tType = " );
|
|
|
|
switch( ClientInfo->bClientType )
|
|
{
|
|
case CLIENT_TYPE_NONE:
|
|
szClientType= "None";
|
|
break;
|
|
|
|
case CLIENT_TYPE_DHCP:
|
|
szClientType = "DHCP";
|
|
break;
|
|
|
|
case CLIENT_TYPE_BOOTP:
|
|
szClientType = "BOOTP";
|
|
break;
|
|
|
|
case CLIENT_TYPE_UNSPECIFIED:
|
|
szClientType = "Unspecified";
|
|
break;
|
|
|
|
default:
|
|
DhcpAssert( FALSE );
|
|
}
|
|
printf( "%s\n", szClientType );
|
|
|
|
printf("\tExpires = ");
|
|
|
|
if ( ClientInfo->ClientLeaseExpires.dwLowDateTime ==
|
|
DHCP_DATE_TIME_INFINIT_LOW &&
|
|
ClientInfo->ClientLeaseExpires.dwHighDateTime ==
|
|
DHCP_DATE_TIME_INFINIT_HIGH )
|
|
{
|
|
printf( "Never (lease duration is infinite.)\n" );
|
|
}
|
|
else if( FileTimeToLocalFileTime(
|
|
(FILETIME *)(&ClientInfo->ClientLeaseExpires),
|
|
&LocalTime) ) {
|
|
|
|
if( FileTimeToSystemTime( &LocalTime, &SystemTime ) ) {
|
|
|
|
printf( "%02u/%02u/%02u %02u:%02u:%02u.\n",
|
|
SystemTime.wMonth,
|
|
SystemTime.wDay,
|
|
SystemTime.wYear,
|
|
SystemTime.wHour,
|
|
SystemTime.wMinute,
|
|
SystemTime.wSecond );
|
|
}
|
|
else {
|
|
printf( "Can't convert time, %ld.\n", GetLastError() );
|
|
}
|
|
}
|
|
else {
|
|
printf( "Can't convert time, %ld.\n", GetLastError() );
|
|
}
|
|
|
|
printf("\tOwner Host IP Address = %s.\n",
|
|
DhcpIpAddressToDottedString(ClientInfo->OwnerHost.IpAddress));
|
|
printf("\tOwner Host NetBios Name = %ws.\n",
|
|
ClientInfo->OwnerHost.NetBiosName );
|
|
printf("\tOwner Host Name = %ws.\n",
|
|
ClientInfo->OwnerHost.HostName );
|
|
|
|
}
|
|
|
|
#ifdef NT5
|
|
VOID
|
|
PrintClientInfoV5(
|
|
LPDHCP_CLIENT_INFO_V5 ClientInfo
|
|
)
|
|
{
|
|
DWORD i;
|
|
DWORD DataLength;
|
|
LPBYTE Data;
|
|
SYSTEMTIME SystemTime;
|
|
FILETIME LocalTime;
|
|
char *szClientType;
|
|
|
|
printf("ClientInfo :\n");
|
|
printf("\tIP Address = %s.\n",
|
|
DhcpIpAddressToDottedString(ClientInfo->ClientIpAddress));
|
|
printf("\tSubnetMask = %s.\n",
|
|
DhcpIpAddressToDottedString(ClientInfo->SubnetMask));
|
|
|
|
DataLength = ClientInfo->ClientHardwareAddress.DataLength;
|
|
Data = ClientInfo->ClientHardwareAddress.Data;
|
|
printf("\tClient Hardware Address = ");
|
|
for( i = 0; i < DataLength; i++ ) {
|
|
if( (i+1) < DataLength ) {
|
|
printf("%.2lx-", (DWORD)Data[i]);
|
|
}
|
|
else {
|
|
printf("%.2lx", (DWORD)Data[i]);
|
|
}
|
|
}
|
|
printf(".\n");
|
|
|
|
printf("\tName = %ws.\n", ClientInfo->ClientName);
|
|
printf("\tComment = %ws.\n", ClientInfo->ClientComment);
|
|
printf("\tType = " );
|
|
|
|
switch( ClientInfo->bClientType )
|
|
{
|
|
case CLIENT_TYPE_NONE:
|
|
szClientType= "None";
|
|
break;
|
|
|
|
case CLIENT_TYPE_DHCP:
|
|
szClientType = "DHCP";
|
|
break;
|
|
|
|
case CLIENT_TYPE_BOOTP:
|
|
szClientType = "BOOTP";
|
|
break;
|
|
|
|
case CLIENT_TYPE_UNSPECIFIED:
|
|
szClientType = "Unspecified";
|
|
break;
|
|
|
|
default:
|
|
DhcpAssert( FALSE );
|
|
}
|
|
printf( "%s\n", szClientType );
|
|
|
|
printf("\tExpires = ");
|
|
|
|
if ( ClientInfo->ClientLeaseExpires.dwLowDateTime ==
|
|
DHCP_DATE_TIME_INFINIT_LOW &&
|
|
ClientInfo->ClientLeaseExpires.dwHighDateTime ==
|
|
DHCP_DATE_TIME_INFINIT_HIGH )
|
|
{
|
|
printf( "Never (lease duration is infinite.)\n" );
|
|
}
|
|
else if( FileTimeToLocalFileTime(
|
|
(FILETIME *)(&ClientInfo->ClientLeaseExpires),
|
|
&LocalTime) ) {
|
|
|
|
if( FileTimeToSystemTime( &LocalTime, &SystemTime ) ) {
|
|
|
|
printf( "%02u/%02u/%02u %02u:%02u:%02u.\n",
|
|
SystemTime.wMonth,
|
|
SystemTime.wDay,
|
|
SystemTime.wYear,
|
|
SystemTime.wHour,
|
|
SystemTime.wMinute,
|
|
SystemTime.wSecond );
|
|
}
|
|
else {
|
|
printf( "Can't convert time, %ld.\n", GetLastError() );
|
|
}
|
|
}
|
|
else {
|
|
printf( "Can't convert time, %ld.\n", GetLastError() );
|
|
}
|
|
|
|
printf("\tOwner Host IP Address = %s.\n",
|
|
DhcpIpAddressToDottedString(ClientInfo->OwnerHost.IpAddress));
|
|
printf("\tOwner Host NetBios Name = %ws.\n",
|
|
ClientInfo->OwnerHost.NetBiosName );
|
|
printf("\tOwner Host Name = %ws.\n",
|
|
ClientInfo->OwnerHost.HostName );
|
|
|
|
printf("\tState = %0x\n", ClientInfo->AddressState );
|
|
}
|
|
#endif NT5
|
|
|
|
VOID
|
|
PrintClientInfoShort(
|
|
LPDHCP_CLIENT_INFO_V4 ClientInfo
|
|
)
|
|
{
|
|
SYSTEMTIME SystemTime;
|
|
FILETIME LocalTime;
|
|
|
|
printf("%ld\t %- 16.16s %- 16.16ws ",
|
|
GlobalClientCount++,
|
|
DhcpIpAddressToDottedString(ClientInfo->ClientIpAddress),
|
|
ClientInfo->ClientName
|
|
);
|
|
if ( ClientInfo->ClientLeaseExpires.dwLowDateTime ==
|
|
DHCP_DATE_TIME_INFINIT_LOW &&
|
|
ClientInfo->ClientLeaseExpires.dwHighDateTime ==
|
|
DHCP_DATE_TIME_INFINIT_HIGH )
|
|
{
|
|
printf( "Never (lease duration is infinite.)\n" );
|
|
}
|
|
else if( FileTimeToLocalFileTime(
|
|
(FILETIME *)(&ClientInfo->ClientLeaseExpires),
|
|
&LocalTime) ) {
|
|
|
|
if( FileTimeToSystemTime( &LocalTime, &SystemTime ) ) {
|
|
|
|
printf( "%02u/%02u/%02u %02u:%02u:%02u",
|
|
SystemTime.wMonth,
|
|
SystemTime.wDay,
|
|
SystemTime.wYear,
|
|
SystemTime.wHour,
|
|
SystemTime.wMinute,
|
|
SystemTime.wSecond );
|
|
}
|
|
else {
|
|
printf( "% 18.18s", "******************" );
|
|
}
|
|
}
|
|
else {
|
|
printf( "%.18s", "******************" );
|
|
}
|
|
|
|
printf( "\n" );
|
|
}
|
|
|
|
#ifdef NT5
|
|
VOID
|
|
PrintClientInfoShortV5(
|
|
LPDHCP_CLIENT_INFO_V5 ClientInfo
|
|
)
|
|
{
|
|
SYSTEMTIME SystemTime;
|
|
FILETIME LocalTime;
|
|
|
|
printf("%ld\t %- 16.16s %- 16.16ws ",
|
|
GlobalClientCount++,
|
|
DhcpIpAddressToDottedString(ClientInfo->ClientIpAddress),
|
|
ClientInfo->ClientName
|
|
);
|
|
if ( ClientInfo->ClientLeaseExpires.dwLowDateTime ==
|
|
DHCP_DATE_TIME_INFINIT_LOW &&
|
|
ClientInfo->ClientLeaseExpires.dwHighDateTime ==
|
|
DHCP_DATE_TIME_INFINIT_HIGH )
|
|
{
|
|
printf( "Never (lease duration is infinite.)\n" );
|
|
}
|
|
else if( FileTimeToLocalFileTime(
|
|
(FILETIME *)(&ClientInfo->ClientLeaseExpires),
|
|
&LocalTime) ) {
|
|
|
|
if( FileTimeToSystemTime( &LocalTime, &SystemTime ) ) {
|
|
|
|
printf( "%02u/%02u/%02u %02u:%02u:%02u",
|
|
SystemTime.wMonth,
|
|
SystemTime.wDay,
|
|
SystemTime.wYear,
|
|
SystemTime.wHour,
|
|
SystemTime.wMinute,
|
|
SystemTime.wSecond );
|
|
}
|
|
else {
|
|
printf( "% 18.18s", "******************" );
|
|
}
|
|
}
|
|
else {
|
|
printf( "%.18s", "******************" );
|
|
}
|
|
printf( "State=%02x", ClientInfo->AddressState);
|
|
printf( "\n" );
|
|
}
|
|
#endif NT5
|
|
|
|
VOID
|
|
PrintClientInfoShort1(
|
|
LPDHCP_CLIENT_INFO_V4 ClientInfo
|
|
)
|
|
{
|
|
DWORD i;
|
|
DWORD DataLength;
|
|
LPBYTE Data;
|
|
|
|
printf("%ld\t %- 16.16s %- 16.16ws ",
|
|
GlobalClientCount++,
|
|
DhcpIpAddressToDottedString(ClientInfo->ClientIpAddress),
|
|
ClientInfo->ClientName
|
|
);
|
|
|
|
DataLength = ClientInfo->ClientHardwareAddress.DataLength;
|
|
Data = ClientInfo->ClientHardwareAddress.Data;
|
|
for( i = 0; i < DataLength; i++ ) {
|
|
printf("%.2lx", (DWORD)Data[i]);
|
|
}
|
|
|
|
printf( "\n" );
|
|
}
|
|
|
|
DWORD
|
|
DetectIpAddressConflict(
|
|
DHCP_IP_ADDRESS IpAddress,
|
|
DWORD dwRetries,
|
|
LPBOOL AddressExists
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This function pings the specific IP address and checks if it exists
|
|
|
|
The number of "ping" retries is controled by the parameter
|
|
DetectConflictRetries in the registry. When it is set to 0, this
|
|
function always sets result to FALSE.
|
|
|
|
Arguments:
|
|
|
|
IpAddress - The IP address to check
|
|
|
|
AddressExists - pointer to the variable where the result is to be stored
|
|
|
|
Return Value:
|
|
|
|
Windows Error
|
|
|
|
--*/
|
|
|
|
{
|
|
HANDLE IcmpHandle;
|
|
char ReplyBuffer [1000];
|
|
DWORD NumReplies = 0;
|
|
DWORD i,
|
|
dwResult;
|
|
|
|
DhcpAssert( dwRetries );
|
|
|
|
*AddressExists = FALSE;
|
|
|
|
|
|
|
|
IcmpHandle = IcmpCreateFile();
|
|
if (IcmpHandle == INVALID_HANDLE_VALUE)
|
|
return GetLastError();
|
|
|
|
|
|
for (i = 0; i < dwRetries; i++) {
|
|
|
|
NumReplies = IcmpSendEcho(
|
|
IcmpHandle,
|
|
(IPAddr) ntohl(IpAddress),
|
|
(LPVOID) "DHCP Server Bad Address",
|
|
(WORD)strlen("DHCP Server Bad Address"),
|
|
NULL,
|
|
ReplyBuffer,
|
|
sizeof(ReplyBuffer),
|
|
1000
|
|
);
|
|
|
|
if (NumReplies != 0) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
dwResult = GetLastError();
|
|
|
|
// IcmpSendEcho will also return 0 to indicate an error condition.
|
|
// IP_REQ_TIMED_OUT indicates no response
|
|
|
|
if ( IP_REQ_TIMED_OUT == dwResult )
|
|
dwResult = 0;
|
|
|
|
IcmpCloseHandle (IcmpHandle);
|
|
|
|
*AddressExists = (NumReplies != 0);
|
|
|
|
|
|
return dwResult;
|
|
}
|
|
|
|
BOOL
|
|
AddressCanBeDeleted(
|
|
IN DHCP_IP_ADDRESS Address
|
|
)
|
|
{
|
|
BOOL RetVal;
|
|
|
|
RetVal = TRUE;
|
|
DetectIpAddressConflict(
|
|
Address,
|
|
3,
|
|
&RetVal
|
|
);
|
|
if( RetVal ) {
|
|
printf("This address exists, so it wont be deleted\n");
|
|
} else {
|
|
printf("This address does not exist, so it will be deleted.\n");
|
|
}
|
|
|
|
return !RetVal;
|
|
}
|
|
|
|
DWORD
|
|
ProcessDeleteClient(
|
|
DWORD CommandArgc,
|
|
LPSTR *CommandArgv
|
|
)
|
|
{
|
|
DHCP_SEARCH_INFO SrchInfo;
|
|
DWORD Error;
|
|
|
|
if( CommandArgc != 1 ) {
|
|
printf("Usage: DhcpCmd SrvIpAddress DeleteClient ClientIp\n");
|
|
return ERROR_INVALID_PARAMETER;
|
|
}
|
|
|
|
SrchInfo.SearchType = DhcpClientIpAddress;
|
|
SrchInfo.SearchInfo.ClientIpAddress = htonl(
|
|
inet_addr( CommandArgv[0]) );
|
|
|
|
Error = DhcpDeleteClientInfo(
|
|
GlobalServerIpAddressUnicodeString, &SrchInfo );
|
|
|
|
if( NO_ERROR != Error ) {
|
|
printf("DhcpDeleteClientInfo failed %ld\n", Error);
|
|
}
|
|
|
|
return Error;
|
|
}
|
|
|
|
DWORD
|
|
ProcessDeleteBadClients(
|
|
DWORD CommandArgc,
|
|
LPSTR *CommandArgv
|
|
)
|
|
{
|
|
BOOL NoPing = FALSE;
|
|
DWORD Error;
|
|
DHCP_RESUME_HANDLE ResumeHandle = 0;
|
|
LPDHCP_CLIENT_INFO_ARRAY_V4 ClientEnumInfo = NULL;
|
|
DWORD ClientsRead = 0;
|
|
DWORD ClientsTotal = 0;
|
|
DWORD i;
|
|
|
|
|
|
if( CommandArgc > 1 || (
|
|
CommandArgc == 1 && _stricmp(CommandArgv[0], "NOPING") ) ) {
|
|
printf("usage:DhcpCmd SrvIpAddress DeleteBadClients [NOPING]\n");
|
|
return ERROR_SUCCESS;
|
|
}
|
|
|
|
NoPing = (CommandArgc == 1 );
|
|
|
|
GlobalClientCount = 1;
|
|
|
|
for(;;) {
|
|
|
|
ClientEnumInfo = NULL;
|
|
Error = DhcpEnumSubnetClientsV4(
|
|
GlobalServerIpAddressUnicodeString,
|
|
0,
|
|
&ResumeHandle,
|
|
(DWORD)(-1),
|
|
&ClientEnumInfo,
|
|
&ClientsRead,
|
|
&ClientsTotal
|
|
);
|
|
|
|
if( (Error != ERROR_SUCCESS) && (Error != ERROR_MORE_DATA) ) {
|
|
printf("DhcpEnumSubnetClients failed, %ld.\n", Error );
|
|
return( Error );
|
|
}
|
|
|
|
DhcpAssert( ClientEnumInfo != NULL );
|
|
DhcpAssert( ClientEnumInfo->NumElements == ClientsRead );
|
|
|
|
|
|
for( i = 0; i < ClientsRead; i++ ) {
|
|
if( NULL == ClientEnumInfo->Clients[i]->ClientName ) {
|
|
//
|
|
// No name? Can that be a bad client? no.
|
|
//
|
|
continue;
|
|
}
|
|
|
|
if( wcscmp(ClientEnumInfo->Clients[i]->ClientName, L"BAD_ADDRESS" ) ) {
|
|
//
|
|
// Not a bad client! ignore it.
|
|
//
|
|
continue;
|
|
}
|
|
|
|
PrintClientInfoShort1( ClientEnumInfo->Clients[i] );
|
|
if( NoPing || AddressCanBeDeleted(ClientEnumInfo->Clients[i]->ClientIpAddress) ) {
|
|
DHCP_SEARCH_INFO SrchInfo2 = {
|
|
DhcpClientIpAddress,
|
|
ClientEnumInfo->Clients[i]->ClientIpAddress
|
|
};
|
|
|
|
Error = DhcpDeleteClientInfo(
|
|
GlobalServerIpAddressUnicodeString,
|
|
&SrchInfo2
|
|
);
|
|
if( ERROR_SUCCESS != Error ) {
|
|
printf("DhcpDeleteClientInfo failed %ld, continuing. \n", Error);
|
|
}
|
|
}
|
|
}
|
|
|
|
DhcpRpcFreeMemory( ClientEnumInfo );
|
|
|
|
if( Error != ERROR_MORE_DATA ) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
return(Error);
|
|
return 0;
|
|
}
|
|
|
|
|
|
#ifdef NT5
|
|
VOID
|
|
PrintClientInfoShort1V5(
|
|
LPDHCP_CLIENT_INFO_V5 ClientInfo
|
|
)
|
|
{
|
|
DWORD i;
|
|
DWORD DataLength;
|
|
LPBYTE Data;
|
|
|
|
printf("%ld\t %- 16.16s %- 16.16ws ",
|
|
GlobalClientCount++,
|
|
DhcpIpAddressToDottedString(ClientInfo->ClientIpAddress),
|
|
ClientInfo->ClientName
|
|
);
|
|
|
|
DataLength = ClientInfo->ClientHardwareAddress.DataLength;
|
|
Data = ClientInfo->ClientHardwareAddress.Data;
|
|
for( i = 0; i < DataLength; i++ ) {
|
|
printf("%.2lx", (DWORD)Data[i]);
|
|
}
|
|
|
|
printf(" State=%02x\n", ClientInfo->AddressState);
|
|
printf( "\n" );
|
|
}
|
|
|
|
|
|
DWORD
|
|
ProcessEnumClientsV5(
|
|
DWORD CommandArgc,
|
|
LPSTR *CommandArgv
|
|
)
|
|
{
|
|
DWORD Error;
|
|
DHCP_RESUME_HANDLE ResumeHandle = 0;
|
|
LPDHCP_CLIENT_INFO_ARRAY_V5 ClientEnumInfo = NULL;
|
|
DWORD ClientsRead = 0;
|
|
DWORD ClientsTotal = 0;
|
|
DWORD i;
|
|
|
|
//
|
|
// Expected Parameters are : <SubnetAddress>
|
|
//
|
|
|
|
|
|
if( CommandArgc < 1 ) {
|
|
printf("usage:DhcpCmd SrvIpAddress EnumClients [Command Parameters].\n"
|
|
"<Command Parameters> - <SubnetAddress [-v | -h] >.\n" );
|
|
return( ERROR_SUCCESS );
|
|
}
|
|
|
|
GlobalClientCount = 1;
|
|
|
|
for(;;) {
|
|
|
|
ClientEnumInfo = NULL;
|
|
Error = DhcpEnumSubnetClientsV5(
|
|
GlobalServerIpAddressUnicodeString,
|
|
DhcpDottedStringToIpAddress(CommandArgv[0]),
|
|
&ResumeHandle,
|
|
(DWORD)(-1),
|
|
&ClientEnumInfo,
|
|
&ClientsRead,
|
|
&ClientsTotal );
|
|
|
|
if( (Error != ERROR_SUCCESS) && (Error != ERROR_MORE_DATA) ) {
|
|
printf("DhcpEnumSubnetClients failed, %ld.\n", Error );
|
|
return( Error );
|
|
}
|
|
|
|
DhcpAssert( ClientEnumInfo != NULL );
|
|
DhcpAssert( ClientEnumInfo->NumElements == ClientsRead );
|
|
|
|
if( (CommandArgc > 1) && CommandArgv[1][0] == '-') {
|
|
|
|
switch (CommandArgv[1][1]) {
|
|
case 'h':
|
|
case 'H':
|
|
for( i = 0; i < ClientsRead; i++ ) {
|
|
PrintClientInfoShort1V5( ClientEnumInfo->Clients[i] );
|
|
}
|
|
break;
|
|
|
|
case 'V':
|
|
case 'v':
|
|
printf("Num Client info read = %ld.\n", ClientsRead );
|
|
printf("Total Client count = %ld.\n", ClientsTotal );
|
|
|
|
for( i = 0; i < ClientsRead; i++ ) {
|
|
PrintClientInfoV5( ClientEnumInfo->Clients[i] );
|
|
}
|
|
break;
|
|
|
|
default:
|
|
|
|
for( i = 0; i < ClientsRead; i++ ) {
|
|
PrintClientInfoShortV5( ClientEnumInfo->Clients[i] );
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
else {
|
|
|
|
for( i = 0; i < ClientsRead; i++ ) {
|
|
PrintClientInfoShortV5( ClientEnumInfo->Clients[i] );
|
|
}
|
|
}
|
|
|
|
DhcpRpcFreeMemory( ClientEnumInfo );
|
|
|
|
if( Error != ERROR_MORE_DATA ) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
return(Error);
|
|
}
|
|
#endif NT5
|
|
|
|
DWORD
|
|
ProcessEnumClients(
|
|
DWORD CommandArgc,
|
|
LPSTR *CommandArgv
|
|
)
|
|
{
|
|
DWORD Error;
|
|
DHCP_RESUME_HANDLE ResumeHandle = 0;
|
|
LPDHCP_CLIENT_INFO_ARRAY_V4 ClientEnumInfo = NULL;
|
|
DWORD ClientsRead = 0;
|
|
DWORD ClientsTotal = 0;
|
|
DWORD i;
|
|
|
|
//
|
|
// Expected Parameters are : <SubnetAddress>
|
|
//
|
|
|
|
|
|
if( CommandArgc < 1 ) {
|
|
printf("usage:DhcpCmd SrvIpAddress EnumClients [Command Parameters].\n"
|
|
"<Command Parameters> - <SubnetAddress [-v | -h] >.\n" );
|
|
return( ERROR_SUCCESS );
|
|
}
|
|
|
|
GlobalClientCount = 1;
|
|
|
|
for(;;) {
|
|
|
|
ClientEnumInfo = NULL;
|
|
Error = DhcpEnumSubnetClientsV4(
|
|
GlobalServerIpAddressUnicodeString,
|
|
DhcpDottedStringToIpAddress(CommandArgv[0]),
|
|
&ResumeHandle,
|
|
(DWORD)(-1),
|
|
&ClientEnumInfo,
|
|
&ClientsRead,
|
|
&ClientsTotal );
|
|
|
|
if( (Error != ERROR_SUCCESS) && (Error != ERROR_MORE_DATA) ) {
|
|
printf("DhcpEnumSubnetClients failed, %ld.\n", Error );
|
|
return( Error );
|
|
}
|
|
|
|
DhcpAssert( ClientEnumInfo != NULL );
|
|
DhcpAssert( ClientEnumInfo->NumElements == ClientsRead );
|
|
|
|
if( (CommandArgc > 1) && CommandArgv[1][0] == '-') {
|
|
|
|
switch (CommandArgv[1][1]) {
|
|
case 'h':
|
|
case 'H':
|
|
for( i = 0; i < ClientsRead; i++ ) {
|
|
PrintClientInfoShort1( ClientEnumInfo->Clients[i] );
|
|
}
|
|
break;
|
|
|
|
case 'V':
|
|
case 'v':
|
|
printf("Num Client info read = %ld.\n", ClientsRead );
|
|
printf("Total Client count = %ld.\n", ClientsTotal );
|
|
|
|
for( i = 0; i < ClientsRead; i++ ) {
|
|
PrintClientInfo( ClientEnumInfo->Clients[i] );
|
|
}
|
|
break;
|
|
|
|
default:
|
|
|
|
for( i = 0; i < ClientsRead; i++ ) {
|
|
PrintClientInfoShort( ClientEnumInfo->Clients[i] );
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
else {
|
|
|
|
for( i = 0; i < ClientsRead; i++ ) {
|
|
PrintClientInfoShort( ClientEnumInfo->Clients[i] );
|
|
}
|
|
}
|
|
|
|
DhcpRpcFreeMemory( ClientEnumInfo );
|
|
|
|
if( Error != ERROR_MORE_DATA ) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
return(Error);
|
|
}
|
|
|
|
|
|
DWORD
|
|
ProcessMibCounts(
|
|
DWORD CommandArgc,
|
|
LPSTR *CommandArgv
|
|
)
|
|
{
|
|
DWORD Error;
|
|
LPDHCP_MIB_INFO MibInfo = NULL;
|
|
DWORD i;
|
|
LPSCOPE_MIB_INFO ScopeInfo;
|
|
SYSTEMTIME SystemTime;
|
|
FILETIME LocalTime;
|
|
|
|
Error = DhcpGetMibInfo(
|
|
GlobalServerIpAddressUnicodeString,
|
|
&MibInfo );
|
|
|
|
if( Error != ERROR_SUCCESS ) {
|
|
return( Error );
|
|
}
|
|
|
|
DhcpAssert( MibInfo != NULL );
|
|
|
|
printf("Discovers = %d.\n", MibInfo->Discovers);
|
|
printf("Offers = %d.\n", MibInfo->Offers);
|
|
printf("Requests = %d.\n", MibInfo->Requests);
|
|
printf("Acks = %d.\n", MibInfo->Acks);
|
|
printf("Naks = %d.\n", MibInfo->Naks);
|
|
printf("Declines = %d.\n", MibInfo->Declines);
|
|
printf("Releases = %d.\n", MibInfo->Releases);
|
|
printf("ServerStartTime = ");
|
|
|
|
if( FileTimeToLocalFileTime(
|
|
(FILETIME *)(&MibInfo->ServerStartTime),
|
|
&LocalTime) ) {
|
|
|
|
if( FileTimeToSystemTime( &LocalTime, &SystemTime ) ) {
|
|
|
|
printf( "%02u/%02u/%02u %02u:%02u:%02u.\n",
|
|
SystemTime.wMonth,
|
|
SystemTime.wDay,
|
|
SystemTime.wYear,
|
|
SystemTime.wHour,
|
|
SystemTime.wMinute,
|
|
SystemTime.wSecond );
|
|
}
|
|
else {
|
|
printf( "Can't convert time, %ld.\n", GetLastError() );
|
|
}
|
|
}
|
|
else {
|
|
printf( "Can't convert time, %ld.\n", GetLastError() );
|
|
}
|
|
|
|
printf("Scopes = %d.\n", MibInfo->Scopes);
|
|
|
|
ScopeInfo = MibInfo->ScopeInfo;
|
|
|
|
for ( i = 0; i < MibInfo->Scopes; i++ ) {
|
|
printf("Subnet = %s.\n",
|
|
DhcpIpAddressToDottedString(ScopeInfo[i].Subnet));
|
|
printf("\tNumAddressesInuse = %d.\n",
|
|
ScopeInfo[i].NumAddressesInuse );
|
|
printf("\tNumAddressesFree = %d.\n",
|
|
ScopeInfo[i].NumAddressesFree );
|
|
printf("\tNumPendingOffers = %d.\n",
|
|
ScopeInfo[i].NumPendingOffers );
|
|
}
|
|
|
|
DhcpRpcFreeMemory( MibInfo );
|
|
|
|
return( ERROR_SUCCESS );
|
|
}
|
|
|
|
VOID
|
|
PrintConfigCommands(
|
|
VOID
|
|
)
|
|
{
|
|
DWORD i;
|
|
DWORD NumCommands;
|
|
|
|
NumCommands = sizeof(GlobalConfigCommandInfo) /
|
|
sizeof(CONFIG_COMMAND_INFO);
|
|
|
|
DhcpAssert( NumCommands <= UnknownConfigCommand );
|
|
for( i = 0; i < NumCommands; i++) {
|
|
printf( "\t%ld. %s\n",
|
|
i, GlobalConfigCommandInfo[i].CommandName );
|
|
}
|
|
}
|
|
|
|
CONFIG_COMMAND_CODE
|
|
DecodeConfigCommand(
|
|
LPSTR CommandName
|
|
)
|
|
{
|
|
DWORD i;
|
|
DWORD NumCommands;
|
|
|
|
NumCommands = sizeof(GlobalConfigCommandInfo) /
|
|
sizeof(CONFIG_COMMAND_INFO);
|
|
|
|
DhcpAssert( NumCommands <= UnknownConfigCommand );
|
|
for( i = 0; i < NumCommands; i++) {
|
|
if( _stricmp( CommandName,
|
|
GlobalConfigCommandInfo[i].CommandName ) == 0 ) {
|
|
return( GlobalConfigCommandInfo[i].CommandCode );
|
|
}
|
|
}
|
|
return( UnknownConfigCommand );
|
|
}
|
|
|
|
//
|
|
// this function assumes input of the following format:
|
|
//
|
|
// [generic name1],[server name1],<boot file1>;[generic name2],...
|
|
//
|
|
//
|
|
|
|
|
|
WCHAR *
|
|
ParseBootFileTable(
|
|
char *szBootFileTable,
|
|
DWORD *pcb
|
|
)
|
|
{
|
|
WCHAR *pwszOutput;
|
|
DWORD cb;
|
|
|
|
*pcb = 0;
|
|
cb = strlen( szBootFileTable ) + 2; // double null terminator
|
|
|
|
pwszOutput = DhcpAllocateMemory( cb * sizeof( WCHAR ) );
|
|
if ( pwszOutput )
|
|
{
|
|
WCHAR *pwszTemp = DhcpOemToUnicode( szBootFileTable, pwszOutput );
|
|
|
|
if ( !pwszTemp )
|
|
{
|
|
// conversion failed
|
|
DhcpFreeMemory( pwszOutput );
|
|
pwszOutput = NULL;
|
|
}
|
|
else
|
|
{
|
|
// replace ';' with '\0'
|
|
while ( *pwszTemp )
|
|
{
|
|
if ( L';' == *pwszTemp )
|
|
{
|
|
*pwszTemp = L'\0';
|
|
}
|
|
|
|
++pwszTemp;
|
|
}
|
|
|
|
*pcb = cb * sizeof( WCHAR );
|
|
|
|
// add 2cnd null terminator
|
|
pwszOutput[ cb - 1 ] = L'\0';
|
|
}
|
|
|
|
}
|
|
|
|
return pwszOutput;
|
|
}
|
|
|
|
|
|
|
|
|
|
void PrintBootFileString(
|
|
WCHAR *wszBootFileString
|
|
)
|
|
{
|
|
WCHAR *pwszBootFile = wszBootFileString;
|
|
|
|
while( *pwszBootFile != BOOT_FILE_STRING_DELIMITER_W )
|
|
pwszBootFile++;
|
|
|
|
*pwszBootFile = L'\0';
|
|
|
|
printf( "Bootfile Server = %S\n", wszBootFileString );
|
|
printf( "Bootfile = %S\n\n", ++pwszBootFile );
|
|
}
|
|
|
|
void PrintBootTableString(
|
|
WCHAR *wszBootFileTable
|
|
)
|
|
{
|
|
while( *wszBootFileTable )
|
|
{
|
|
WCHAR *pwszDelimiter = wszBootFileTable;
|
|
DWORD cb = wcslen( wszBootFileTable ) + 1;
|
|
|
|
while( *pwszDelimiter != BOOT_FILE_STRING_DELIMITER_W )
|
|
pwszDelimiter++;
|
|
|
|
*pwszDelimiter = L'\0';
|
|
printf( "Generic Bootfile request = %S\n", wszBootFileTable );
|
|
PrintBootFileString( ++pwszDelimiter );
|
|
|
|
wszBootFileTable += cb;
|
|
}
|
|
}
|
|
|
|
DWORD ProcessRemoveSubscope(
|
|
DWORD CommandArgc,
|
|
LPSTR *CommandArgv
|
|
)
|
|
{
|
|
DHCP_IP_ADDRESS SubnetAddress;
|
|
DWORD dwResult;
|
|
|
|
if( CommandArgc < 1 )
|
|
{
|
|
printf("usage:DhcpCmd SrvIpAddress RemoveSubscope <scope ID>.\n" );
|
|
return( ERROR_SUCCESS );
|
|
}
|
|
|
|
SubnetAddress = htonl( inet_addr( CommandArgv[0] ) );
|
|
|
|
dwResult = DhcpSetSuperScopeV4(
|
|
GlobalServerIpAddressUnicodeString,
|
|
SubnetAddress,
|
|
NULL,
|
|
TRUE
|
|
);
|
|
|
|
return dwResult;
|
|
}
|
|
|
|
DWORD ProcessSetSuperScope(
|
|
DWORD CommandArgc,
|
|
LPSTR *CommandArgv
|
|
)
|
|
{
|
|
DHCP_IP_ADDRESS SubnetAddress;
|
|
WCHAR *pwszSuperScopeName;
|
|
BOOL fChangeExisting;
|
|
DWORD dwResult;
|
|
|
|
if( CommandArgc < 3 )
|
|
{
|
|
printf("usage:DhcpCmd SrvIpAddress SetSuperScope <SuperScope name> <scope ID> <1|0>\n" );
|
|
return( ERROR_SUCCESS );
|
|
}
|
|
|
|
pwszSuperScopeName = DhcpOemToUnicode( CommandArgv[0], NULL );
|
|
SubnetAddress = htonl( inet_addr( CommandArgv[1] ) );
|
|
fChangeExisting = (BOOL) ( *(CommandArgv[2]) - '0' );
|
|
|
|
dwResult = DhcpSetSuperScopeV4( GlobalServerIpAddressUnicodeString,
|
|
SubnetAddress,
|
|
pwszSuperScopeName,
|
|
fChangeExisting );
|
|
|
|
return dwResult;
|
|
}
|
|
|
|
DWORD ProcessDeleteSuperScope(
|
|
DWORD CommandArgc,
|
|
LPSTR *CommandArgv
|
|
)
|
|
{
|
|
WCHAR *pwszSuperScope;
|
|
DWORD dwResult;
|
|
|
|
if( CommandArgc < 1 ) {
|
|
printf("usage:DhcpCmd SrvIpAddress DeleteSuperScope <scope name>.\n" );
|
|
return( ERROR_SUCCESS );
|
|
}
|
|
|
|
printf( "Deleting SuperScope %s\n", CommandArgv[0] );
|
|
|
|
pwszSuperScope = DhcpOemToUnicode( CommandArgv[0], NULL );
|
|
dwResult = DhcpDeleteSuperScopeV4( GlobalServerIpAddressUnicodeString,
|
|
pwszSuperScope );
|
|
|
|
DhcpFreeMemory( pwszSuperScope );
|
|
|
|
return dwResult;
|
|
}
|
|
|
|
DWORD ProcessGetSuperScopeTable(
|
|
DWORD CommandArgc,
|
|
LPSTR *CommandArgv
|
|
)
|
|
{
|
|
DHCP_SUPER_SCOPE_TABLE *pTable = NULL;
|
|
DWORD dwResult;
|
|
|
|
dwResult = DhcpGetSuperScopeInfoV4(
|
|
GlobalServerIpAddressUnicodeString,
|
|
&pTable );
|
|
if ( ERROR_SUCCESS == dwResult )
|
|
{
|
|
DWORD n;
|
|
|
|
for ( n = 0; n < pTable->cEntries; n++ )
|
|
{
|
|
IN_ADDR InAddr;
|
|
|
|
InAddr.s_addr = htonl( pTable->pEntries[n].SubnetAddress );
|
|
|
|
printf( "Superscope name = %S\n", pTable->pEntries[n].SuperScopeName );
|
|
printf( "Subnet address = %s\n", inet_ntoa( InAddr ) );
|
|
printf( "Superscope goup number = %d\n", pTable->pEntries[n].SuperScopeNumber );
|
|
}
|
|
|
|
|
|
DhcpRpcFreeMemory( pTable );
|
|
}
|
|
|
|
|
|
return ERROR_SUCCESS;
|
|
}
|
|
|
|
DWORD
|
|
ProcessServerConfig(
|
|
DWORD CommandArgc,
|
|
LPSTR *CommandArgv
|
|
)
|
|
{
|
|
DWORD Error;
|
|
LPDHCP_SERVER_CONFIG_INFO_V4 ConfigInfo = NULL;
|
|
DWORD FieldsToSet = 0;
|
|
CONFIG_COMMAND_CODE CommandCode;
|
|
DWORD Value;
|
|
LPWSTR ValueString;
|
|
|
|
if( CommandArgc < 1 ) {
|
|
|
|
Error = DhcpServerGetConfigV4(
|
|
GlobalServerIpAddressUnicodeString,
|
|
&ConfigInfo );
|
|
|
|
if( Error != ERROR_SUCCESS ) {
|
|
return( Error );
|
|
}
|
|
|
|
DhcpAssert( ConfigInfo != NULL );
|
|
|
|
printf("APIProtocolSupport = %lx\n", ConfigInfo->APIProtocolSupport );
|
|
printf("DatabaseName = %ws\n", ConfigInfo->DatabaseName );
|
|
printf("DatabasePath = %ws\n", ConfigInfo->DatabasePath );
|
|
printf("BackupPath = %ws\n", ConfigInfo->BackupPath );
|
|
printf("BackupInterval = %ld mins.\n",
|
|
ConfigInfo->BackupInterval );
|
|
printf("DatabaseLoggingFlag = %ld\n", ConfigInfo->DatabaseLoggingFlag );
|
|
printf("RestoreFlag = %ld\n", ConfigInfo->RestoreFlag );
|
|
printf("DatabaseCleanupInterval = %ld mins.\n",
|
|
ConfigInfo->DatabaseCleanupInterval );
|
|
printf("DebugFlag = %lx\n", ConfigInfo->DebugFlag );
|
|
printf("PingRetries = %d\n", ConfigInfo->dwPingRetries );
|
|
printf("ActivityLog = %d\n", (DWORD) ConfigInfo->fAuditLog );
|
|
|
|
if ( ConfigInfo->cbBootTableString )
|
|
{
|
|
printf( "BOOTP request table:\n" );
|
|
PrintBootTableString( ConfigInfo->wszBootTableString );
|
|
}
|
|
|
|
DhcpRpcFreeMemory( ConfigInfo );
|
|
|
|
return( Error );
|
|
}
|
|
|
|
|
|
if ( CommandArgc == 1)
|
|
{
|
|
++CommandArgc;
|
|
return ERROR_INVALID_PARAMETER;
|
|
}
|
|
else
|
|
{
|
|
ConfigInfo = DhcpAllocateMemory( sizeof(DHCP_SERVER_CONFIG_INFO_V4) );
|
|
|
|
if( ConfigInfo == NULL ) {
|
|
printf("Insufficient memory\n");
|
|
return( ERROR_NOT_ENOUGH_MEMORY );
|
|
}
|
|
|
|
RtlZeroMemory( ConfigInfo, sizeof( *ConfigInfo ) );
|
|
}
|
|
while( CommandArgc >= 2 ) {
|
|
|
|
|
|
CommandCode = DecodeConfigCommand( CommandArgv[0] );
|
|
|
|
Value = 0;
|
|
ValueString = NULL;
|
|
|
|
switch( CommandCode )
|
|
{
|
|
case ConfigDatabaseName:
|
|
case ConfigDatabasePath:
|
|
case ConfigBackupPath:
|
|
case ConfigAPIProtocolSupport:
|
|
case ConfigBackupInterval:
|
|
case ConfigDatabaseLoggingFlag:
|
|
case ConfigRestoreFlag:
|
|
case ConfigDatabaseCleanupInterval:
|
|
case ConfigDebugFlag:
|
|
case ConfigActivityLog:
|
|
case ConfigPingRetries:
|
|
Value = atoi( CommandArgv[1] );
|
|
break;
|
|
|
|
case ConfigBootFileTable:
|
|
ValueString = ParseBootFileTable( CommandArgv[1],
|
|
&Value );
|
|
break;
|
|
}
|
|
|
|
|
|
switch( CommandCode ) {
|
|
case ConfigAPIProtocolSupport:
|
|
FieldsToSet |= Set_APIProtocolSupport;
|
|
ConfigInfo->APIProtocolSupport = Value;
|
|
break;
|
|
|
|
case ConfigDatabaseName:
|
|
FieldsToSet |= Set_DatabaseName;
|
|
ConfigInfo->DatabaseName = ValueString;
|
|
break;
|
|
|
|
case ConfigDatabasePath:
|
|
FieldsToSet |= Set_DatabasePath;
|
|
ConfigInfo->DatabasePath = ValueString;
|
|
break;
|
|
|
|
case ConfigBackupPath:
|
|
FieldsToSet |= Set_BackupPath;
|
|
ConfigInfo->BackupPath = ValueString;
|
|
break;
|
|
|
|
case ConfigBackupInterval:
|
|
FieldsToSet |= Set_BackupInterval;
|
|
ConfigInfo->BackupInterval = Value;
|
|
break;
|
|
|
|
case ConfigDatabaseLoggingFlag:
|
|
FieldsToSet |= Set_DatabaseLoggingFlag;
|
|
ConfigInfo->DatabaseLoggingFlag = Value;
|
|
break;
|
|
|
|
case ConfigRestoreFlag:
|
|
FieldsToSet |= Set_RestoreFlag;
|
|
ConfigInfo->RestoreFlag = Value;
|
|
break;
|
|
|
|
case ConfigDatabaseCleanupInterval:
|
|
FieldsToSet |= Set_DatabaseCleanupInterval;
|
|
ConfigInfo->DatabaseCleanupInterval = Value;
|
|
break;
|
|
|
|
case ConfigDebugFlag:
|
|
FieldsToSet |= Set_DebugFlag;
|
|
ConfigInfo->DebugFlag = Value;
|
|
break;
|
|
|
|
|
|
case ConfigPingRetries:
|
|
FieldsToSet |= Set_PingRetries;
|
|
ConfigInfo->dwPingRetries = Value;
|
|
break;
|
|
|
|
case ConfigActivityLog:
|
|
FieldsToSet |= Set_AuditLogState;
|
|
ConfigInfo->fAuditLog = (BOOL) Value;
|
|
break;
|
|
|
|
case ConfigBootFileTable:
|
|
|
|
FieldsToSet |= Set_BootFileTable;
|
|
ConfigInfo->wszBootTableString = ValueString;
|
|
ConfigInfo->cbBootTableString = Value;
|
|
|
|
break;
|
|
|
|
case UnknownConfigCommand:
|
|
default:
|
|
printf("usage:DhcpCmd SrvIpAddress ServerConfig "
|
|
"[ConfigCommand ConfigValue]"
|
|
"[ConfigCommand ConfigValue]"
|
|
"... \n");
|
|
|
|
printf("ConfigCommands : \n");
|
|
PrintConfigCommands();
|
|
|
|
Error = ERROR_INVALID_PARAMETER;
|
|
goto Cleanup;
|
|
}
|
|
|
|
CommandArgc -= 2;
|
|
CommandArgv += 2;
|
|
}
|
|
|
|
Error = DhcpServerSetConfigV4(
|
|
GlobalServerIpAddressUnicodeString,
|
|
FieldsToSet,
|
|
ConfigInfo );
|
|
|
|
if( Error != ERROR_SUCCESS ) {
|
|
goto Cleanup;
|
|
}
|
|
|
|
Error = ProcessServerConfig( 0, NULL );
|
|
|
|
Cleanup:
|
|
|
|
if( ConfigInfo != NULL ) {
|
|
|
|
if( ConfigInfo->DatabaseName != NULL ) {
|
|
DhcpFreeMemory( ConfigInfo->DatabaseName );
|
|
}
|
|
|
|
if( ConfigInfo->DatabasePath != NULL ) {
|
|
DhcpFreeMemory( ConfigInfo->DatabasePath );
|
|
}
|
|
|
|
if( ConfigInfo->BackupPath != NULL ) {
|
|
DhcpFreeMemory( ConfigInfo->BackupPath );
|
|
}
|
|
|
|
DhcpFreeMemory( ConfigInfo );
|
|
}
|
|
|
|
return( Error );
|
|
}
|
|
|
|
DWORD
|
|
ProcessCheckDB(
|
|
DWORD CommandArgc,
|
|
LPSTR *CommandArgv
|
|
)
|
|
{
|
|
DWORD Error;
|
|
LPDHCP_SCAN_LIST ScanList = NULL;
|
|
BOOL FixFlag = FALSE;
|
|
|
|
if( CommandArgc < 1 ) {
|
|
printf("usage:DhcpCmd SrvIpAddress CheckDB [Command Parameters].\n"
|
|
"<Command Parameters> - <SubnetAddress> <[Fix]>.\n" );
|
|
return( ERROR_SUCCESS );
|
|
}
|
|
|
|
if( CommandArgc >= 2 ) {
|
|
|
|
//
|
|
// parse fix parameter.
|
|
//
|
|
|
|
if( _stricmp(CommandArgv[0], "fix") ) {
|
|
FixFlag = TRUE;
|
|
}
|
|
}
|
|
|
|
//
|
|
// scan dhcp database and registry, check consistency and get bad
|
|
// entries if any.
|
|
//
|
|
|
|
Error = DhcpScanDatabase(
|
|
GlobalServerIpAddressUnicodeString,
|
|
DhcpDottedStringToIpAddress(CommandArgv[0]),
|
|
FixFlag,
|
|
&ScanList
|
|
);
|
|
|
|
if( Error != ERROR_SUCCESS ) {
|
|
printf("DhcpScanDatabase failed, %ld.\n", Error );
|
|
return( Error );
|
|
}
|
|
|
|
//
|
|
// display bad entries.
|
|
//
|
|
|
|
if( (ScanList != NULL) &&
|
|
(ScanList->NumScanItems != 0) &&
|
|
(ScanList->ScanItems != NULL) ) {
|
|
|
|
LPDHCP_SCAN_ITEM ScanItem;
|
|
LPDHCP_SCAN_ITEM ScanItemEnd;
|
|
DWORD i = 1;
|
|
|
|
ScanItemEnd =
|
|
ScanList->ScanItems +
|
|
ScanList->NumScanItems;
|
|
|
|
for( ScanItem = ScanList->ScanItems;
|
|
ScanItem < ScanItemEnd; ScanItem++ ) {
|
|
|
|
printf("%ld %- 16.16s ",
|
|
i++,
|
|
DhcpIpAddressToDottedString(ScanItem->IpAddress) );
|
|
|
|
if( ScanItem->ScanFlag == DhcpRegistryFix ) {
|
|
printf("Fix Registry\n");
|
|
}
|
|
else if( ScanItem->ScanFlag == DhcpDatabaseFix ) {
|
|
printf("Fix Database\n");
|
|
}
|
|
else {
|
|
printf("Fix Unknown\n");
|
|
}
|
|
}
|
|
}
|
|
|
|
return( ERROR_SUCCESS );
|
|
}
|
|
|
|
VOID
|
|
PrintOptionValue(
|
|
LPDHCP_OPTION_DATA OptionValue
|
|
)
|
|
{
|
|
DWORD NumElements;
|
|
DHCP_OPTION_DATA_TYPE OptionType;
|
|
DWORD i;
|
|
|
|
printf("Option Value : \n");
|
|
NumElements = OptionValue->NumElements;
|
|
|
|
printf("\tNumber of Option Elements = %ld\n", NumElements );
|
|
|
|
if( NumElements == 0 ) {
|
|
return;
|
|
}
|
|
|
|
OptionType = OptionValue->Elements[0].OptionType;
|
|
printf("\tOption Elements Type = " );
|
|
|
|
switch( OptionType ) {
|
|
case DhcpByteOption:
|
|
printf("DhcpByteOption\n");
|
|
break;
|
|
|
|
case DhcpWordOption:
|
|
printf("DhcpWordOption\n");
|
|
break;
|
|
|
|
case DhcpDWordOption:
|
|
printf("DhcpDWordOption\n");
|
|
break;
|
|
|
|
case DhcpDWordDWordOption:
|
|
printf("DhcpDWordDWordOption\n");
|
|
break;
|
|
|
|
case DhcpIpAddressOption:
|
|
printf("DhcpIpAddressOption\n");
|
|
break;
|
|
|
|
case DhcpStringDataOption:
|
|
printf("DhcpStringDataOption\n");
|
|
break;
|
|
|
|
case DhcpBinaryDataOption:
|
|
printf("DhcpBinaryDataOption\n");
|
|
break;
|
|
|
|
case DhcpEncapsulatedDataOption:
|
|
printf("DhcpEncapsulatedDataOption\n");
|
|
break;
|
|
default:
|
|
printf("Unknown\n");
|
|
return;
|
|
}
|
|
|
|
for( i = 0; i < OptionValue->NumElements; i++ ) {
|
|
DhcpAssert( OptionType == OptionValue->Elements[i].OptionType );
|
|
printf("Option Element %ld value = ", i );
|
|
|
|
switch( OptionType ) {
|
|
case DhcpByteOption:
|
|
printf("%lx.\n", (DWORD)
|
|
OptionValue->Elements[i].Element.ByteOption );
|
|
break;
|
|
|
|
case DhcpWordOption:
|
|
printf("%lx.\n", (DWORD)
|
|
OptionValue->Elements[i].Element.WordOption );
|
|
break;
|
|
|
|
case DhcpDWordOption:
|
|
printf("%lx.\n",
|
|
OptionValue->Elements[i].Element.DWordOption );
|
|
break;
|
|
|
|
case DhcpDWordDWordOption:
|
|
printf("%lx, %lx.\n",
|
|
OptionValue->Elements[i].Element.DWordDWordOption.DWord1,
|
|
OptionValue->Elements[i].Element.DWordDWordOption.DWord2 );
|
|
|
|
break;
|
|
|
|
case DhcpIpAddressOption:
|
|
printf("%lx.\n",
|
|
OptionValue->Elements[i].Element.IpAddressOption );
|
|
break;
|
|
|
|
case DhcpStringDataOption:
|
|
printf("%ws.\n",
|
|
OptionValue->Elements[i].Element.StringDataOption );
|
|
break;
|
|
|
|
case DhcpBinaryDataOption:
|
|
case DhcpEncapsulatedDataOption: {
|
|
DWORD j;
|
|
DWORD Length;
|
|
|
|
Length = OptionValue->Elements[i].Element.BinaryDataOption.DataLength;
|
|
for( j = 0; j < Length; j++ ) {
|
|
printf("%2lx ",
|
|
OptionValue->Elements[i].Element.BinaryDataOption.Data[j] );
|
|
}
|
|
printf(".\n");
|
|
break;
|
|
}
|
|
default:
|
|
printf("PrintOptionValue: Unknown OptionType.\n");
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
VOID
|
|
PrintOptionInfo(
|
|
LPDHCP_OPTION OptionInfo
|
|
)
|
|
{
|
|
printf( "Option Info : \n");
|
|
printf( "\tOptionId : %ld \n", (DWORD)OptionInfo->OptionID );
|
|
printf( "\tOptionName : %ws \n", OptionInfo->OptionName );
|
|
printf( "\tOptionComment : %ws \n", OptionInfo->OptionComment );
|
|
PrintOptionValue( &OptionInfo->DefaultValue );
|
|
printf( "\tOptionType : %ld \n", (DWORD)OptionInfo->OptionType );
|
|
}
|
|
|
|
DWORD
|
|
_EnumOptions(
|
|
IN LPWSTR ServerAddress,
|
|
IN DWORD Flags,
|
|
IN LPWSTR ClassName,
|
|
IN LPWSTR VendorName,
|
|
IN OUT DHCP_RESUME_HANDLE *ResumeHandle,
|
|
IN DWORD PreferredMaximum,
|
|
OUT LPDHCP_OPTION_ARRAY *Options,
|
|
OUT DWORD *OptionsRead,
|
|
OUT DWORD *OptionsTotal
|
|
)
|
|
{
|
|
DWORD MajorVersion, MinorVersion;
|
|
DWORD Error;
|
|
|
|
#ifdef NT5
|
|
if( GlobalNoRPC ) {
|
|
MajorVersion = CLASS_ID_VERSION ;
|
|
} else {
|
|
Error = DhcpGetVersion(ServerAddress, &MajorVersion, &MinorVersion);
|
|
if( ERROR_SUCCESS != Error ) {
|
|
printf("Could not determine server version.\n");
|
|
return Error;
|
|
}
|
|
}
|
|
|
|
if( MajorVersion >= CLASS_ID_VERSION ) {
|
|
return DhcpEnumOptionsV5(
|
|
ServerAddress,
|
|
GlobalIsVendor ? Flags | DHCP_FLAGS_OPTION_IS_VENDOR : Flags,
|
|
ClassName,
|
|
VendorName,
|
|
ResumeHandle,
|
|
PreferredMaximum,
|
|
Options,
|
|
OptionsRead,
|
|
OptionsTotal
|
|
);
|
|
}
|
|
|
|
// incorrect version, just do like before..
|
|
#endif
|
|
|
|
return DhcpEnumOptions(
|
|
ServerAddress,
|
|
ResumeHandle,
|
|
PreferredMaximum,
|
|
Options,
|
|
OptionsRead,
|
|
OptionsTotal
|
|
);
|
|
}
|
|
|
|
DWORD
|
|
ProcessEnumOptions(
|
|
DWORD CommandArgc,
|
|
LPSTR *CommandArgv
|
|
)
|
|
{
|
|
DWORD Error;
|
|
LPDHCP_OPTION_ARRAY OptionsArray = NULL;
|
|
DHCP_RESUME_HANDLE ResumeHandle = 0;
|
|
DWORD OptionsRead;
|
|
DWORD OptionsTotal;
|
|
|
|
|
|
Error = _EnumOptions(
|
|
GlobalServerIpAddressUnicodeString,
|
|
0,
|
|
GlobalClassName,
|
|
GlobalVendorName,
|
|
&ResumeHandle,
|
|
0xFFFFFFFF, // get all.
|
|
&OptionsArray,
|
|
&OptionsRead,
|
|
&OptionsTotal
|
|
);
|
|
|
|
if( Error != ERROR_SUCCESS ) {
|
|
printf("DhcpEnumOptions failed %ld\n", Error );
|
|
} else {
|
|
|
|
DWORD i;
|
|
LPDHCP_OPTION Options;
|
|
DWORD NumOptions;
|
|
|
|
printf("OptionsRead = %ld.\n", OptionsRead);
|
|
printf("OptionsTotal = %ld.\n", OptionsTotal);
|
|
|
|
Options = OptionsArray->Options;
|
|
NumOptions = OptionsArray->NumElements;
|
|
|
|
for( i = 0; i < NumOptions; i++, Options++ ) {
|
|
PrintOptionInfo( Options );
|
|
}
|
|
DhcpRpcFreeMemory( OptionsArray );
|
|
OptionsArray = NULL;
|
|
}
|
|
|
|
return( Error );
|
|
}
|
|
|
|
DWORD
|
|
ProcessGetVersion(
|
|
DWORD *pdwMajor,
|
|
DWORD *pdwMinor
|
|
)
|
|
{
|
|
DWORD Error = ERROR_SUCCESS;
|
|
DWORD MajorVersion;
|
|
DWORD MinorVersion;
|
|
|
|
if ( g_dwMajor == (DWORD) -1 && g_dwMinor == (DWORD) -1 ) {
|
|
Error = DhcpGetVersion(
|
|
GlobalServerIpAddressUnicodeString,
|
|
&g_dwMajor,
|
|
&g_dwMinor
|
|
);
|
|
|
|
if ( ERROR_SUCCESS == Error ) {
|
|
printf( "DHCP Server version %d.%d\n", g_dwMajor, g_dwMinor );
|
|
}
|
|
}
|
|
|
|
return Error;
|
|
}
|
|
|
|
VOID
|
|
PrintOptionArray(
|
|
IN LPDHCP_OPTION_ARRAY OptArray
|
|
)
|
|
{
|
|
DWORD i;
|
|
|
|
for( i = 0; i < OptArray->NumElements ; i ++ ) {
|
|
PrintOptionInfo( &OptArray->Options[i] );
|
|
}
|
|
}
|
|
|
|
VOID
|
|
PrintOptionValue1(
|
|
IN LPDHCP_OPTION_VALUE OptVal
|
|
)
|
|
{
|
|
printf("Option: %ld\n", OptVal->OptionID);
|
|
|
|
PrintOptionValue(&OptVal->Value);
|
|
}
|
|
|
|
VOID
|
|
PrintOptionValuesArray(
|
|
IN LPDHCP_OPTION_VALUE_ARRAY OptValArray
|
|
)
|
|
{
|
|
DWORD i;
|
|
|
|
if( NULL == OptValArray ) return;
|
|
for( i = 0; i < OptValArray->NumElements ; i ++ ) {
|
|
PrintOptionValue1( &OptValArray->Values[i] );
|
|
}
|
|
}
|
|
|
|
#ifdef NT5
|
|
#define CHKNULL(Str) ((Str)?(Str):L"<None>")
|
|
|
|
VOID
|
|
PrintAllOptions(
|
|
IN LPDHCP_ALL_OPTIONS Options
|
|
)
|
|
{
|
|
DWORD i;
|
|
|
|
printf("Options [Non Vendor specific]:\n"
|
|
"==============================\n");
|
|
PrintOptionArray(Options->NonVendorOptions);
|
|
|
|
for( i = 0; i < Options->NumVendorOptions; i ++ ) {
|
|
printf("\nOptions [Vendor:%ws]\n==============================\n",
|
|
CHKNULL( Options->VendorOptions[i].VendorName));
|
|
PrintOptionInfo(&(Options->VendorOptions[i].Option));
|
|
}
|
|
|
|
printf("\n\n");
|
|
}
|
|
|
|
DWORD
|
|
ProcessGetAllOptions(
|
|
IN DWORD CommandArgc,
|
|
IN LPSTR CommandArgv[]
|
|
)
|
|
{
|
|
DWORD Error, Major, Minor;
|
|
LPDHCP_ALL_OPTIONS Options;
|
|
|
|
if( TRUE == GlobalNoRPC ) {
|
|
Major = CLASS_ID_VERSION;
|
|
} else {
|
|
Error = DhcpGetVersion(
|
|
GlobalServerIpAddressUnicodeString,
|
|
&Major,
|
|
&Minor
|
|
);
|
|
if( ERROR_SUCCESS != Error ) {
|
|
printf("Could not get DHCP server version!\n");
|
|
return Error;
|
|
}
|
|
}
|
|
|
|
if( CLASS_ID_VERSION > Major ) {
|
|
printf("DHCP Server (major version %ld) does not support this function call.\n", Major);
|
|
return ERROR_SUCCESS;
|
|
}
|
|
|
|
Options = NULL;
|
|
Error = DhcpGetAllOptions(
|
|
GlobalServerIpAddressUnicodeString,
|
|
0,
|
|
&Options
|
|
);
|
|
|
|
if( ERROR_SUCCESS != Error ) return Error;
|
|
|
|
if( NULL == Options ) {
|
|
printf("Server returned no options!\n");
|
|
DhcpAssert(FALSE);
|
|
} else {
|
|
PrintAllOptions(Options);
|
|
DhcpRpcFreeMemory(Options);
|
|
}
|
|
|
|
return ERROR_SUCCESS;
|
|
}
|
|
|
|
VOID
|
|
PrintAllOptionValues(
|
|
IN LPDHCP_ALL_OPTION_VALUES OptValues
|
|
)
|
|
{
|
|
DWORD i;
|
|
|
|
printf("Flags = 0x%lx, NumValues = %ld\n", OptValues->Flags, OptValues->NumElements);
|
|
for( i = 0; i < OptValues->NumElements ; i ++ ) {
|
|
printf("Options");
|
|
if( OptValues->Options[i].IsVendor ) {
|
|
printf(" for vendor <%ws>", CHKNULL(OptValues->Options[i].VendorName));
|
|
}
|
|
if( OptValues->Options[i].ClassName ) {
|
|
printf(" for user class <%ws>", OptValues->Options[i].ClassName);
|
|
}
|
|
printf(":\n");
|
|
PrintOptionValuesArray(OptValues->Options[i].OptionsArray);
|
|
}
|
|
}
|
|
|
|
DWORD
|
|
ProcessGetAllOptionValues(
|
|
IN DWORD CommandArgc,
|
|
IN LPSTR CommandArgv[]
|
|
)
|
|
{
|
|
DWORD Error, Major, Minor;
|
|
LPDHCP_ALL_OPTION_VALUES OptionValues;
|
|
DHCP_OPTION_SCOPE_INFO ScopeInfo;
|
|
|
|
// usage: getalloptionvalues [command parameters]
|
|
// [CommandParameters] = Global/Default/SubnetAddress/SubnetAddress ReservedAddress
|
|
|
|
if( CommandArgc != 1 && CommandArgc != 2 ) {
|
|
printf("Usage: Dhcpcmd SrvIpAddress GetAllOptionValues [CommandParameters]\n");
|
|
printf("<Command parameters> - < GLOBAL | DEFAULT | Subnet-Adddress | Subnet-Address Reserved Address>.\n");
|
|
return ERROR_SUCCESS;
|
|
}
|
|
|
|
if( 1 == CommandArgc ) {
|
|
if( 0 == _stricmp(CommandArgv[0], "GLOBAL") ) {
|
|
ScopeInfo.ScopeType = DhcpGlobalOptions;
|
|
} else if ( 0 == _stricmp(CommandArgv[0], "DEFAULT" )) {
|
|
ScopeInfo.ScopeType = DhcpDefaultOptions;
|
|
} else {
|
|
ScopeInfo.ScopeType = DhcpSubnetOptions;
|
|
ScopeInfo.ScopeInfo.SubnetScopeInfo = DhcpDottedStringToIpAddress(CommandArgv[0]);
|
|
}
|
|
} else {
|
|
ScopeInfo.ScopeType = DhcpReservedOptions;
|
|
ScopeInfo.ScopeInfo.ReservedScopeInfo.ReservedIpSubnetAddress =
|
|
DhcpDottedStringToIpAddress(CommandArgv[0]);
|
|
ScopeInfo.ScopeInfo.ReservedScopeInfo.ReservedIpAddress =
|
|
DhcpDottedStringToIpAddress( CommandArgv[1] );
|
|
}
|
|
|
|
if( TRUE == GlobalNoRPC ) {
|
|
Major = CLASS_ID_VERSION;
|
|
} else {
|
|
Error = DhcpGetVersion(
|
|
GlobalServerIpAddressUnicodeString,
|
|
&Major,
|
|
&Minor
|
|
);
|
|
if( ERROR_SUCCESS != Error ) {
|
|
printf("Could not get DHCP server version!\n");
|
|
return Error;
|
|
}
|
|
}
|
|
|
|
if( CLASS_ID_VERSION > Major ) {
|
|
printf("DHCP Server (major version %ld) does not support this function call.\n", Major);
|
|
return ERROR_SUCCESS;
|
|
}
|
|
|
|
OptionValues = NULL;
|
|
Error = DhcpGetAllOptionValues(
|
|
GlobalServerIpAddressUnicodeString,
|
|
0,
|
|
&ScopeInfo,
|
|
&OptionValues
|
|
);
|
|
|
|
if( ERROR_SUCCESS != Error ) return Error;
|
|
|
|
if( NULL == OptionValues ) {
|
|
printf("Server returned no option values!\n");
|
|
DhcpAssert(FALSE);
|
|
} else {
|
|
PrintAllOptionValues(OptionValues);
|
|
DhcpRpcFreeMemory(OptionValues);
|
|
}
|
|
|
|
return ERROR_SUCCESS;
|
|
}
|
|
|
|
PBYTE
|
|
GetLangTag(
|
|
)
|
|
{
|
|
char b1[8], b2[8];
|
|
static char buff[80];
|
|
|
|
GetLocaleInfoA(LOCALE_SYSTEM_DEFAULT, LOCALE_SISO639LANGNAME, b1, sizeof(b1));
|
|
|
|
GetLocaleInfoA(LOCALE_SYSTEM_DEFAULT, LOCALE_SISO3166CTRYNAME, b2, sizeof(b2));
|
|
|
|
if (_stricmp(b1, b2))
|
|
sprintf(buff, "%s-%s", b1, b2);
|
|
else
|
|
strcpy(buff, b1);
|
|
|
|
return buff;
|
|
}
|
|
|
|
DWORD
|
|
ProcessCreateMScope(
|
|
DWORD CommandArgc,
|
|
LPSTR *CommandArgv
|
|
)
|
|
{
|
|
DWORD Error;
|
|
DHCP_MSCOPE_INFO MScopeInfo;
|
|
LPWSTR UnicodeMScopeName = NULL;
|
|
LPWSTR UnicodeMScopeDesc = NULL;
|
|
DWORD MScopeId;
|
|
LPWSTR UnicodeLangTag = NULL;
|
|
PBYTE LangTag;
|
|
DWORD ExpiryTimeInHours = 0;
|
|
|
|
|
|
//
|
|
// Expected Parameters are : <MScopeId MScopeName MScopeDescription ExpiryTime>
|
|
//
|
|
|
|
|
|
if( CommandArgc < 4 ) {
|
|
printf("usage:DhcpCmd SrvIpAddress CreateMScope [Command Parameters].\n"
|
|
"<Command Parameters> - <MScopeId MScopeName MScopeDescription ExpiryTimeInHours>.\n"
|
|
);
|
|
Error = ERROR_SUCCESS;
|
|
goto Cleanup;
|
|
}
|
|
|
|
MScopeId = atoi( CommandArgv[0] );
|
|
if (!MScopeId) {
|
|
Error = ERROR_SUCCESS;
|
|
goto Cleanup;
|
|
}
|
|
|
|
UnicodeMScopeName = DhcpOemToUnicode( CommandArgv[1], NULL );
|
|
DhcpAssert( UnicodeMScopeName != NULL );
|
|
|
|
UnicodeMScopeDesc = DhcpOemToUnicode( CommandArgv[2], NULL );
|
|
DhcpAssert( UnicodeMScopeName != NULL );
|
|
|
|
ExpiryTimeInHours = atoi(CommandArgv[3]);
|
|
LangTag = GetLangTag();
|
|
UnicodeLangTag = DhcpOemToUnicode(LangTag, NULL);
|
|
DhcpAssert(UnicodeLangTag);
|
|
|
|
MScopeInfo.MScopeName = UnicodeMScopeName;
|
|
MScopeInfo.MScopeId = MScopeId;
|
|
MScopeInfo.MScopeComment = UnicodeMScopeDesc;
|
|
MScopeInfo.PrimaryHost.IpAddress =
|
|
DhcpDottedStringToIpAddress(GlobalServerIpAddressAnsiString);
|
|
|
|
MScopeInfo.PrimaryHost.NetBiosName = NULL;
|
|
MScopeInfo.PrimaryHost.HostName = NULL;
|
|
MScopeInfo.MScopeState = DhcpSubnetEnabled;
|
|
MScopeInfo.MScopeFlags = 0;
|
|
MScopeInfo.MScopeAddressPolicy = 0;
|
|
MScopeInfo.TTL = 255;
|
|
MScopeInfo.LangTag = UnicodeLangTag;
|
|
MScopeInfo.ExpiryTime = DhcpCalculateTime(ExpiryTimeInHours*60*60);
|
|
|
|
Error = DhcpSetMScopeInfo(
|
|
GlobalServerIpAddressUnicodeString,
|
|
UnicodeMScopeName,
|
|
&MScopeInfo,
|
|
TRUE); // new scope
|
|
|
|
Cleanup:
|
|
|
|
if( UnicodeMScopeName != NULL ) {
|
|
DhcpFreeMemory( UnicodeMScopeName );
|
|
}
|
|
if( UnicodeMScopeDesc != NULL ) {
|
|
DhcpFreeMemory( UnicodeMScopeDesc );
|
|
}
|
|
|
|
return( Error );
|
|
}
|
|
|
|
DWORD
|
|
ProcessDeleteMScope(
|
|
DWORD CommandArgc,
|
|
LPSTR *CommandArgv
|
|
)
|
|
{
|
|
DWORD Error;
|
|
DHCP_MSCOPE_INFO MScopeInfo;
|
|
LPWSTR UnicodeMScopeName = NULL;
|
|
|
|
//
|
|
// Expected Parameters are : <MScopeName>
|
|
//
|
|
|
|
|
|
if( CommandArgc < 1 ) {
|
|
printf("usage:DhcpCmd SrvIpAddress DeleteMScope [Command Parameters].\n"
|
|
"<Command Parameters> - <MScopeName>.\n" );
|
|
Error = ERROR_SUCCESS;
|
|
goto Cleanup;
|
|
}
|
|
|
|
UnicodeMScopeName = DhcpOemToUnicode( CommandArgv[0], NULL );
|
|
DhcpAssert( UnicodeMScopeName != NULL );
|
|
|
|
Error = DhcpDeleteMScope(
|
|
GlobalServerIpAddressUnicodeString,
|
|
UnicodeMScopeName,
|
|
TRUE); // force flag
|
|
|
|
Cleanup:
|
|
|
|
if( UnicodeMScopeName != NULL ) {
|
|
DhcpFreeMemory( UnicodeMScopeName );
|
|
}
|
|
|
|
return( Error );
|
|
}
|
|
|
|
DWORD
|
|
ProcessAddMScopeIpRange(
|
|
DWORD CommandArgc,
|
|
LPSTR *CommandArgv
|
|
)
|
|
{
|
|
DWORD Error;
|
|
DHCP_IP_RANGE IpRange;
|
|
DHCP_SUBNET_ELEMENT_DATA_V4 Element;
|
|
LPWSTR UnicodeMScopeName = NULL;
|
|
//
|
|
// Expected Parameters are : <MScopeName IpRangeStart IpRangeEnd>
|
|
//
|
|
|
|
|
|
if( CommandArgc < 3 ) {
|
|
printf("usage:DhcpCmd SrvIpAddress AddMScopeIpRange [Command Parameters].\n"
|
|
"<Command Parameters> - <MScopeName IpRangeStart IpRangeEnd>.\n" );
|
|
return( ERROR_SUCCESS );
|
|
}
|
|
|
|
UnicodeMScopeName = DhcpOemToUnicode( CommandArgv[0], NULL );
|
|
DhcpAssert( UnicodeMScopeName != NULL );
|
|
|
|
IpRange.StartAddress = DhcpDottedStringToIpAddress(CommandArgv[1]);
|
|
IpRange.EndAddress = DhcpDottedStringToIpAddress(CommandArgv[2]);
|
|
|
|
Element.ElementType = DhcpIpRanges;
|
|
Element.Element.IpRange = &IpRange;
|
|
|
|
Error = DhcpAddMScopeElement(
|
|
GlobalServerIpAddressUnicodeString,
|
|
UnicodeMScopeName,
|
|
&Element );
|
|
|
|
if( UnicodeMScopeName != NULL ) DhcpFreeMemory( UnicodeMScopeName );
|
|
|
|
return( Error );
|
|
}
|
|
|
|
DWORD
|
|
ProcessReconcileMScope(
|
|
DWORD CommandArgc,
|
|
LPSTR *CommandArgv
|
|
)
|
|
{
|
|
DWORD Error;
|
|
LPWSTR UnicodeMScopeName = NULL;
|
|
LPDHCP_SCAN_LIST ScanList = NULL;
|
|
//
|
|
// Expected Parameters are : <MScopeName>
|
|
//
|
|
|
|
|
|
if( CommandArgc < 1 ) {
|
|
printf("usage:DhcpCmd SrvIpAddress ReconcileMScope [Command Parameters].\n"
|
|
"<Command Parameters> - <MScopeName>.\n" );
|
|
return( ERROR_SUCCESS );
|
|
}
|
|
|
|
UnicodeMScopeName = DhcpOemToUnicode( CommandArgv[0], NULL );
|
|
DhcpAssert( UnicodeMScopeName != NULL );
|
|
|
|
|
|
Error = DhcpScanMDatabase(
|
|
GlobalServerIpAddressUnicodeString,
|
|
UnicodeMScopeName,
|
|
TRUE, // fix bad entries.
|
|
&ScanList );
|
|
|
|
if( UnicodeMScopeName != NULL ) DhcpFreeMemory( UnicodeMScopeName );
|
|
if (ScanList) DhcpRpcFreeMemory( ScanList );
|
|
|
|
return( Error );
|
|
}
|
|
|
|
|
|
VOID
|
|
PrintMClientInfo(
|
|
LPDHCP_MCLIENT_INFO ClientInfo
|
|
)
|
|
{
|
|
DWORD i;
|
|
DWORD DataLength;
|
|
LPBYTE Data;
|
|
SYSTEMTIME SystemTime;
|
|
FILETIME LocalTime;
|
|
char *szClientType;
|
|
|
|
printf("ClientInfo :\n");
|
|
printf("\tIP Address = %s.\n",
|
|
DhcpIpAddressToDottedString(ClientInfo->ClientIpAddress));
|
|
printf("\tMScopeId = %lx.\n",
|
|
ClientInfo->MScopeId);
|
|
|
|
DataLength = ClientInfo->ClientId.DataLength;
|
|
Data = ClientInfo->ClientId.Data;
|
|
printf("\tClient Hardware Address = ");
|
|
for( i = 0; i < DataLength; i++ ) {
|
|
if( (i+1) < DataLength ) {
|
|
printf("%.2lx-", (DWORD)Data[i]);
|
|
}
|
|
else {
|
|
printf("%.2lx", (DWORD)Data[i]);
|
|
}
|
|
}
|
|
printf(".\n");
|
|
|
|
printf("\tName = %ws.\n", ClientInfo->ClientName);
|
|
printf("\tStarts = ");
|
|
|
|
if ( ClientInfo->ClientLeaseStarts.dwLowDateTime ==
|
|
DHCP_DATE_TIME_INFINIT_LOW &&
|
|
ClientInfo->ClientLeaseStarts.dwHighDateTime ==
|
|
DHCP_DATE_TIME_INFINIT_HIGH )
|
|
{
|
|
printf( "Never (lease duration is infinite.)\n" );
|
|
}
|
|
else if( FileTimeToLocalFileTime(
|
|
(FILETIME *)(&ClientInfo->ClientLeaseStarts),
|
|
&LocalTime) ) {
|
|
|
|
if( FileTimeToSystemTime( &LocalTime, &SystemTime ) ) {
|
|
|
|
printf( "%02u/%02u/%02u %02u:%02u:%02u.\n",
|
|
SystemTime.wMonth,
|
|
SystemTime.wDay,
|
|
SystemTime.wYear,
|
|
SystemTime.wHour,
|
|
SystemTime.wMinute,
|
|
SystemTime.wSecond );
|
|
}
|
|
else {
|
|
printf( "Can't convert time, %ld.\n", GetLastError() );
|
|
}
|
|
}
|
|
else {
|
|
printf( "Can't convert time, %ld.\n", GetLastError() );
|
|
}
|
|
|
|
printf("\tExpires = ");
|
|
|
|
if ( ClientInfo->ClientLeaseEnds.dwLowDateTime ==
|
|
DHCP_DATE_TIME_INFINIT_LOW &&
|
|
ClientInfo->ClientLeaseEnds.dwHighDateTime ==
|
|
DHCP_DATE_TIME_INFINIT_HIGH )
|
|
{
|
|
printf( "Never (lease duration is infinite.)\n" );
|
|
}
|
|
else if( FileTimeToLocalFileTime(
|
|
(FILETIME *)(&ClientInfo->ClientLeaseEnds),
|
|
&LocalTime) ) {
|
|
|
|
if( FileTimeToSystemTime( &LocalTime, &SystemTime ) ) {
|
|
|
|
printf( "%02u/%02u/%02u %02u:%02u:%02u.\n",
|
|
SystemTime.wMonth,
|
|
SystemTime.wDay,
|
|
SystemTime.wYear,
|
|
SystemTime.wHour,
|
|
SystemTime.wMinute,
|
|
SystemTime.wSecond );
|
|
}
|
|
else {
|
|
printf( "Can't convert time, %ld.\n", GetLastError() );
|
|
}
|
|
}
|
|
else {
|
|
printf( "Can't convert time, %ld.\n", GetLastError() );
|
|
}
|
|
|
|
printf("\tOwner Host IP Address = %s.\n",
|
|
DhcpIpAddressToDottedString(ClientInfo->OwnerHost.IpAddress));
|
|
printf("\tOwner Host NetBios Name = %ws.\n",
|
|
ClientInfo->OwnerHost.NetBiosName );
|
|
printf("\tOwner Host Name = %ws.\n",
|
|
ClientInfo->OwnerHost.HostName );
|
|
|
|
printf("\tState = %0x\n", ClientInfo->AddressState );
|
|
}
|
|
|
|
VOID
|
|
PrintMClientInfoShort(
|
|
LPDHCP_MCLIENT_INFO ClientInfo
|
|
)
|
|
{
|
|
SYSTEMTIME SystemTime;
|
|
FILETIME LocalTime;
|
|
|
|
printf("%ld\t %- 16.16s %- 16.16ws ",
|
|
GlobalClientCount++,
|
|
DhcpIpAddressToDottedString(ClientInfo->ClientIpAddress),
|
|
ClientInfo->ClientName
|
|
);
|
|
if ( ClientInfo->ClientLeaseEnds.dwLowDateTime ==
|
|
DHCP_DATE_TIME_INFINIT_LOW &&
|
|
ClientInfo->ClientLeaseEnds.dwHighDateTime ==
|
|
DHCP_DATE_TIME_INFINIT_HIGH )
|
|
{
|
|
printf( "Never (lease duration is infinite.)\n" );
|
|
}
|
|
else if( FileTimeToLocalFileTime(
|
|
(FILETIME *)(&ClientInfo->ClientLeaseEnds),
|
|
&LocalTime) ) {
|
|
|
|
if( FileTimeToSystemTime( &LocalTime, &SystemTime ) ) {
|
|
|
|
printf( "%02u/%02u/%02u %02u:%02u:%02u",
|
|
SystemTime.wMonth,
|
|
SystemTime.wDay,
|
|
SystemTime.wYear,
|
|
SystemTime.wHour,
|
|
SystemTime.wMinute,
|
|
SystemTime.wSecond );
|
|
}
|
|
else {
|
|
printf( "% 18.18s", "******************" );
|
|
}
|
|
}
|
|
else {
|
|
printf( "%.18s", "******************" );
|
|
}
|
|
|
|
printf( "\n" );
|
|
}
|
|
|
|
DWORD
|
|
ProcessEnumMScopeClients(
|
|
DWORD CommandArgc,
|
|
LPSTR *CommandArgv
|
|
)
|
|
{
|
|
DWORD Error;
|
|
DHCP_RESUME_HANDLE ResumeHandle = 0;
|
|
LPDHCP_MCLIENT_INFO_ARRAY ClientEnumInfo = NULL;
|
|
DWORD ClientsRead = 0;
|
|
DWORD ClientsTotal = 0;
|
|
DWORD i;
|
|
LPWSTR UnicodeMScopeName = NULL;
|
|
|
|
//
|
|
// Expected Parameters are : <MScopeNames>
|
|
//
|
|
|
|
|
|
if( CommandArgc < 1 ) {
|
|
printf("usage:DhcpCmd SrvIpAddress EnumClients [Command Parameters].\n"
|
|
"<Command Parameters> - <MScopeNames [-v | -h] >.\n" );
|
|
return( ERROR_SUCCESS );
|
|
}
|
|
|
|
UnicodeMScopeName = DhcpOemToUnicode( CommandArgv[0], NULL );
|
|
DhcpAssert( UnicodeMScopeName != NULL );
|
|
|
|
GlobalClientCount = 1;
|
|
|
|
for(;;) {
|
|
|
|
ClientEnumInfo = NULL;
|
|
Error = DhcpEnumMScopeClients(
|
|
GlobalServerIpAddressUnicodeString,
|
|
UnicodeMScopeName,
|
|
&ResumeHandle,
|
|
(DWORD)(-1),
|
|
&ClientEnumInfo,
|
|
&ClientsRead,
|
|
&ClientsTotal );
|
|
|
|
if( (Error != ERROR_SUCCESS) && (Error != ERROR_MORE_DATA) ) {
|
|
printf("DhcpEnumSubnetClients failed, %ld.\n", Error );
|
|
return( Error );
|
|
}
|
|
|
|
DhcpAssert( ClientEnumInfo != NULL );
|
|
DhcpAssert( ClientEnumInfo->NumElements == ClientsRead );
|
|
|
|
if( (CommandArgc > 1) && CommandArgv[1][0] == '-') {
|
|
|
|
switch (CommandArgv[1][1]) {
|
|
case 'h':
|
|
case 'H':
|
|
for( i = 0; i < ClientsRead; i++ ) {
|
|
PrintMClientInfoShort( ClientEnumInfo->Clients[i] );
|
|
}
|
|
break;
|
|
|
|
case 'V':
|
|
case 'v':
|
|
printf("Num Client info read = %ld.\n", ClientsRead );
|
|
printf("Total Client count = %ld.\n", ClientsTotal );
|
|
|
|
for( i = 0; i < ClientsRead; i++ ) {
|
|
PrintMClientInfo( ClientEnumInfo->Clients[i] );
|
|
}
|
|
break;
|
|
|
|
default:
|
|
|
|
for( i = 0; i < ClientsRead; i++ ) {
|
|
PrintMClientInfoShort( ClientEnumInfo->Clients[i] );
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
else {
|
|
|
|
for( i = 0; i < ClientsRead; i++ ) {
|
|
PrintMClientInfoShort( ClientEnumInfo->Clients[i] );
|
|
}
|
|
}
|
|
|
|
DhcpRpcFreeMemory( ClientEnumInfo );
|
|
|
|
if( Error != ERROR_MORE_DATA ) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
return(Error);
|
|
}
|
|
|
|
DWORD
|
|
ProcessEnumMScopes(
|
|
DWORD CommandArgc,
|
|
LPSTR *CommandArgv
|
|
)
|
|
{
|
|
DWORD Error;
|
|
DHCP_RESUME_HANDLE ResumeHandle = 0;
|
|
LPDHCP_MSCOPE_TABLE MScopeTable = NULL;
|
|
DWORD ClientsRead = 0;
|
|
DWORD ClientsTotal = 0;
|
|
DWORD i;
|
|
LPWSTR UnicodeMScopeName = NULL;
|
|
|
|
for(;;) {
|
|
|
|
MScopeTable = NULL;
|
|
Error = DhcpEnumMScopes(
|
|
GlobalServerIpAddressUnicodeString,
|
|
&ResumeHandle,
|
|
(DWORD)(-1),
|
|
&MScopeTable,
|
|
&ClientsRead,
|
|
&ClientsTotal );
|
|
|
|
if( (Error != ERROR_SUCCESS) && (Error != ERROR_MORE_DATA) ) {
|
|
printf("DhcpEnumSubnetClients failed, %ld.\n", Error );
|
|
return( Error );
|
|
}
|
|
|
|
DhcpAssert( MScopeTable != NULL );
|
|
DhcpAssert( MScopeTable->NumElements == ClientsRead );
|
|
printf("Total Client count = %ld.\n", ClientsTotal );
|
|
|
|
for( i = 0; i < ClientsRead; i++ ) {
|
|
printf("MScope %ws\n", MScopeTable->pMScopeNames[i] );
|
|
}
|
|
break;
|
|
|
|
|
|
DhcpRpcFreeMemory( MScopeTable );
|
|
|
|
if( Error != ERROR_MORE_DATA ) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
return(Error);
|
|
}
|
|
|
|
DWORD
|
|
ProcessMCastMibCounts(
|
|
DWORD CommandArgc,
|
|
LPSTR *CommandArgv
|
|
)
|
|
{
|
|
DWORD Error;
|
|
LPDHCP_MCAST_MIB_INFO MibInfo = NULL;
|
|
DWORD i;
|
|
LPMSCOPE_MIB_INFO ScopeInfo;
|
|
SYSTEMTIME SystemTime;
|
|
FILETIME LocalTime;
|
|
|
|
Error = DhcpGetMCastMibInfo(
|
|
GlobalServerIpAddressUnicodeString,
|
|
&MibInfo );
|
|
|
|
if( Error != ERROR_SUCCESS ) {
|
|
return( Error );
|
|
}
|
|
|
|
DhcpAssert( MibInfo != NULL );
|
|
|
|
printf("Discovers = %d.\n", MibInfo->Discovers);
|
|
printf("Offers = %d.\n", MibInfo->Offers);
|
|
printf("Requests = %d.\n", MibInfo->Requests);
|
|
printf("Acks = %d.\n", MibInfo->Acks);
|
|
printf("Naks = %d.\n", MibInfo->Naks);
|
|
printf("Renews = %d.\n", MibInfo->Renews);
|
|
printf("Releases = %d.\n", MibInfo->Releases);
|
|
printf("ServerStartTime = ");
|
|
|
|
if( FileTimeToLocalFileTime(
|
|
(FILETIME *)(&MibInfo->ServerStartTime),
|
|
&LocalTime) ) {
|
|
|
|
if( FileTimeToSystemTime( &LocalTime, &SystemTime ) ) {
|
|
|
|
printf( "%02u/%02u/%02u %02u:%02u:%02u.\n",
|
|
SystemTime.wMonth,
|
|
SystemTime.wDay,
|
|
SystemTime.wYear,
|
|
SystemTime.wHour,
|
|
SystemTime.wMinute,
|
|
SystemTime.wSecond );
|
|
}
|
|
else {
|
|
printf( "Can't convert time, %ld.\n", GetLastError() );
|
|
}
|
|
}
|
|
else {
|
|
printf( "Can't convert time, %ld.\n", GetLastError() );
|
|
}
|
|
|
|
printf("Scopes = %d.\n", MibInfo->Scopes);
|
|
|
|
ScopeInfo = MibInfo->ScopeInfo;
|
|
|
|
for ( i = 0; i < MibInfo->Scopes; i++ ) {
|
|
printf("Scope Name = %ws.\n",
|
|
(ScopeInfo[i].MScopeName));
|
|
printf("\tNumAddressesInuse = %d.\n",
|
|
ScopeInfo[i].NumAddressesInuse );
|
|
printf("\tNumAddressesFree = %d.\n",
|
|
ScopeInfo[i].NumAddressesFree );
|
|
printf("\tNumPendingOffers = %d.\n",
|
|
ScopeInfo[i].NumPendingOffers );
|
|
}
|
|
|
|
DhcpRpcFreeMemory( MibInfo );
|
|
|
|
return( ERROR_SUCCESS );
|
|
}
|
|
|
|
DWORD
|
|
ProcessAddServer( // add a server to DS
|
|
IN DWORD CommandArgc,
|
|
IN LPSTR *CommandArgv
|
|
)
|
|
{
|
|
DWORD Err;
|
|
DWORD Address;
|
|
LPWSTR ServerName;
|
|
DHCP_SERVER_INFO Server;
|
|
|
|
// usage: AddServer <ServerName> <ServerIpAddress>
|
|
if( CommandArgc != 2 ) { // wrong usage
|
|
printf("usage:DhcpCmd SrvIpAddress AddServer <server-dns-name> <server-ip-address>\n");
|
|
return ERROR_SUCCESS;
|
|
}
|
|
|
|
if( GlobalNoDS ) {
|
|
Err = DhcpDsInit();
|
|
if( ERROR_SUCCESS != Err ) return Err;
|
|
}
|
|
|
|
ServerName = DhcpOemToUnicode( CommandArgv[0], NULL);
|
|
Address = (inet_addr(CommandArgv[1]));
|
|
printf("Adding server %ws,%s\n", ServerName, inet_ntoa(*(struct in_addr*)&Address));
|
|
|
|
Server.Version = 0;
|
|
Server.ServerName = ServerName;
|
|
Server.ServerAddress = htonl(Address);
|
|
Server.Flags = 0;
|
|
Server.State = 0;
|
|
Server.DsLocation = NULL;
|
|
Server.DsLocType = 0;
|
|
|
|
Err = DhcpAddServer(0, NULL, &Server, NULL, NULL);
|
|
DhcpFreeMemory(ServerName);
|
|
|
|
if( ERROR_SUCCESS != Err ) { // could not add the server
|
|
printf("DhcpAddServer failed %ld (0x%lx)\n", Err, Err);
|
|
}
|
|
|
|
if( GlobalNoDS ) DhcpDsCleanup();
|
|
|
|
return Err;
|
|
}
|
|
|
|
DWORD
|
|
ProcessDelServer( // delete a server from DS
|
|
IN DWORD CommandArgc,
|
|
IN LPSTR *CommandArgv
|
|
)
|
|
{
|
|
DWORD Err;
|
|
DWORD Address;
|
|
LPWSTR ServerName;
|
|
DHCP_SERVER_INFO Server;
|
|
|
|
// usage: DelServer <ServerName> <ServerIpAddress>
|
|
if( CommandArgc != 2 ) { // wrong usage
|
|
printf("usage:DhcpCmd SrvIpAddress DelServer <server-dns-name> <server-ip-address>\n");
|
|
return ERROR_SUCCESS;
|
|
}
|
|
|
|
if( GlobalNoDS ) {
|
|
Err = DhcpDsInit();
|
|
if( ERROR_SUCCESS != Err ) return Err;
|
|
}
|
|
|
|
ServerName = DhcpOemToUnicode( CommandArgv[0], NULL);
|
|
Address = (inet_addr(CommandArgv[1]));
|
|
printf("Deleting server %ws,%s\n", ServerName, inet_ntoa(*(struct in_addr*)&Address));
|
|
|
|
Server.Version = 0;
|
|
Server.ServerName = ServerName;
|
|
Server.ServerAddress = htonl(Address);
|
|
Server.Flags = 0;
|
|
Server.State = 0;
|
|
Server.DsLocation = NULL;
|
|
Server.DsLocType = 0;
|
|
|
|
Err = DhcpDeleteServer(0, NULL, &Server, NULL, NULL);
|
|
DhcpFreeMemory(ServerName);
|
|
|
|
if( ERROR_SUCCESS != Err ) { // could not add the server
|
|
printf("DhcpDeleteServer failed %ld (0x%lx)\n", Err, Err);
|
|
}
|
|
if( GlobalNoDS ) DhcpDsCleanup();
|
|
return Err;
|
|
}
|
|
|
|
|
|
VOID
|
|
PrintServerInfo( // print server information
|
|
IN LPDHCP_SERVER_INFO Server
|
|
)
|
|
{
|
|
DHCP_IP_ADDRESS ServerAddress = htonl(Server->ServerAddress);
|
|
printf("Server [%ws] Address [%s] Ds location: %ws\n",
|
|
Server->ServerName,
|
|
inet_ntoa(*(struct in_addr *)&ServerAddress),
|
|
Server->DsLocation? Server->DsLocation : L"<no-ds-location-available>"
|
|
);
|
|
}
|
|
|
|
VOID
|
|
PrintServerInfoArray( // print list of servers
|
|
IN LPDHCP_SERVER_INFO_ARRAY Servers
|
|
)
|
|
{
|
|
DWORD i;
|
|
|
|
printf("%ld Servers were found in the DS:\n", Servers->NumElements);
|
|
for( i = 0; i < Servers->NumElements; i ++ ) {
|
|
printf("\t");
|
|
PrintServerInfo(&Servers->Servers[i]);
|
|
}
|
|
printf("\n");
|
|
}
|
|
|
|
DWORD
|
|
ProcessEnumServers( // enumerate servers in DS.
|
|
IN DWORD CommandArgc, // ignored..
|
|
IN LPSTR *CommandArgv // ignored
|
|
)
|
|
{
|
|
DWORD Err;
|
|
LPDHCP_SERVER_INFO_ARRAY Servers;
|
|
|
|
if( GlobalNoDS ) {
|
|
Err = DhcpDsInit();
|
|
if( ERROR_SUCCESS != Err ) return Err;
|
|
}
|
|
|
|
Servers = NULL;
|
|
Err = DhcpEnumServers(0, NULL, &Servers, NULL, NULL);
|
|
if( ERROR_SUCCESS != Err ) {
|
|
printf("DhcpEnumServers failed %ld (0x%lx)\n", Err, Err);
|
|
if( GlobalNoDS ) DhcpDsCleanup();
|
|
return Err;
|
|
}
|
|
|
|
PrintServerInfoArray(Servers);
|
|
LocalFree(Servers);
|
|
if( GlobalNoDS ) DhcpDsCleanup();
|
|
return ERROR_SUCCESS;
|
|
}
|
|
|
|
|
|
DWORD
|
|
ProcessCreateClass( // create a new class
|
|
IN DWORD CommandArgc,
|
|
IN LPSTR *CommandArgv
|
|
)
|
|
{
|
|
DWORD Err;
|
|
DHCP_CLASS_INFO ClassInfo;
|
|
|
|
// usage: [/IsVendor] CreateClass ClassName ClassComment Ascii-Data-For-Class
|
|
|
|
if( CommandArgc != 3 ) { // wrong usage
|
|
printf("usage:DhcpCmd SrvIpAddress CreateClass [Command Parameters]\n");
|
|
printf("[Command Parameters] - ClassName ClassComment Ascii-Date-For-Class\n");
|
|
printf("/IsVendor option would cause this to be created as a vendor class.\n");
|
|
return ERROR_SUCCESS;
|
|
}
|
|
|
|
ClassInfo.ClassName = DhcpOemToUnicode(CommandArgv[0], NULL);
|
|
ClassInfo.ClassComment = DhcpOemToUnicode(CommandArgv[1], NULL);
|
|
ClassInfo.ClassDataLength = strlen(CommandArgv[2]);
|
|
ClassInfo.ClassData = (LPBYTE)CommandArgv[2];
|
|
ClassInfo.IsVendor = GlobalIsVendor;
|
|
ClassInfo.Flags = 0;
|
|
|
|
Err = DhcpCreateClass(
|
|
GlobalServerIpAddressUnicodeString,
|
|
0,
|
|
&ClassInfo
|
|
);
|
|
|
|
DhcpFreeMemory(ClassInfo.ClassName);
|
|
DhcpFreeMemory(ClassInfo.ClassComment);
|
|
|
|
return Err;
|
|
}
|
|
|
|
|
|
DWORD
|
|
ProcessDeleteClass( // delete an existing class
|
|
IN DWORD CommandArgc,
|
|
IN LPSTR *CommandArgv
|
|
)
|
|
{
|
|
DWORD Err;
|
|
LPWSTR ClassName;
|
|
|
|
// usage: DeleteClass ClassName
|
|
|
|
if( CommandArgc != 1 ) {
|
|
printf("usage: DhcpCmd SrvIpAddress DeleteClass ClassName\n");
|
|
return ERROR_SUCCESS;
|
|
}
|
|
|
|
ClassName = DhcpOemToUnicode(CommandArgv[0], NULL);
|
|
Err = DhcpDeleteClass(
|
|
GlobalServerIpAddressUnicodeString,
|
|
0,
|
|
ClassName
|
|
);
|
|
|
|
DhcpFreeMemory(ClassName);
|
|
|
|
return Err;
|
|
}
|
|
|
|
VOID
|
|
PrintClassInfo( // print info on a single class
|
|
IN LPDHCP_CLASS_INFO Class
|
|
)
|
|
{
|
|
DWORD i;
|
|
|
|
printf("Class [%ws]:\n\tComment: %ws\n\tFlags: 0x%lx\n\tIsVendor: %s\n",
|
|
Class->ClassName, Class->ClassComment, Class->Flags, Class->IsVendor?"TRUE":"FALSE");
|
|
printf("\tClassData: ");
|
|
for( i = 0; i < Class->ClassDataLength; i ++ )
|
|
printf("%02x ", Class->ClassData[i]);
|
|
printf("\n");
|
|
}
|
|
|
|
VOID
|
|
PrintClassInfoArray( // print array of classes
|
|
IN LPDHCP_CLASS_INFO_ARRAY Classes
|
|
)
|
|
{
|
|
DWORD i;
|
|
|
|
printf("NumClasses = %ld (0x%lx)\n", Classes->NumElements, Classes->NumElements);
|
|
for( i = 0; i < Classes->NumElements; i ++ )
|
|
PrintClassInfo(&Classes->Classes[i]);
|
|
}
|
|
|
|
|
|
DWORD
|
|
ProcessEnumClasses( // enumerate list of classes defined
|
|
IN DWORD CommandArgc,
|
|
IN LPSTR *CommandArgv
|
|
)
|
|
{
|
|
DWORD Err, nRead, nTotal;
|
|
DHCP_RESUME_HANDLE ResumeHandle;
|
|
LPDHCP_CLASS_INFO_ARRAY ClassInfoArray;
|
|
|
|
// usage: EnumClasses
|
|
|
|
ClassInfoArray = NULL;
|
|
ResumeHandle = 0;
|
|
|
|
Err = DhcpEnumClasses(
|
|
GlobalServerIpAddressUnicodeString,
|
|
0,
|
|
&ResumeHandle,
|
|
0xFFFFFFFF,
|
|
&ClassInfoArray,
|
|
&nRead,
|
|
&nTotal
|
|
);
|
|
|
|
if( ERROR_MORE_DATA == Err || ERROR_NO_MORE_ITEMS == Err ) {
|
|
Err = ERROR_SUCCESS;
|
|
}
|
|
|
|
if( ERROR_SUCCESS == Err ) {
|
|
PrintClassInfoArray(ClassInfoArray);
|
|
DhcpRpcFreeMemory(ClassInfoArray);
|
|
}
|
|
|
|
return Err;
|
|
}
|
|
|
|
LPSTR
|
|
AttribString(
|
|
IN ULONG AttribId
|
|
)
|
|
{
|
|
switch(AttribId) {
|
|
case DHCP_ATTRIB_BOOL_IS_ROGUE:
|
|
return "IsRogue";
|
|
case DHCP_ATTRIB_BOOL_IS_DYNBOOTP:
|
|
return "DynamicBootpEnabled" ;
|
|
case DHCP_ATTRIB_BOOL_IS_PART_OF_DSDC:
|
|
return "ServerPartOfDsEnabledDC" ;
|
|
default:
|
|
;
|
|
}
|
|
|
|
return "UnknownAttribute";
|
|
}
|
|
|
|
VOID
|
|
PrintDhcpAttrib( // print a server attrib
|
|
IN LPDHCP_ATTRIB ServerAttrib
|
|
)
|
|
{
|
|
if( NULL == ServerAttrib ) return;
|
|
|
|
printf("Server Attrib %s [%ld]: ",
|
|
AttribString(ServerAttrib->DhcpAttribId),
|
|
ServerAttrib->DhcpAttribId );
|
|
switch( ServerAttrib->DhcpAttribType ) {
|
|
case DHCP_ATTRIB_TYPE_BOOL :
|
|
printf("%s\n", ServerAttrib->DhcpAttribBool? "TRUE" : "FALSE");
|
|
break;
|
|
case DHCP_ATTRIB_TYPE_ULONG:
|
|
printf("0x%lx\n", ServerAttrib->DhcpAttribUlong);
|
|
break;
|
|
default:
|
|
printf("unknown attrib type\n");
|
|
break;
|
|
}
|
|
}
|
|
|
|
DWORD
|
|
ProcessGetServerStatus( // what is the server status?
|
|
IN DWORD CommandArgc,
|
|
IN LPSTR *CommandArgv
|
|
)
|
|
{
|
|
DWORD Err, i;
|
|
LPDHCP_ATTRIB_ARRAY pDhcpAttribArr;
|
|
DHCP_ATTRIB_ID Attribs[] = {
|
|
DHCP_ATTRIB_BOOL_IS_ROGUE,
|
|
DHCP_ATTRIB_BOOL_IS_DYNBOOTP,
|
|
DHCP_ATTRIB_BOOL_IS_PART_OF_DSDC
|
|
};
|
|
|
|
pDhcpAttribArr = NULL;
|
|
Err = DhcpServerQueryAttributes(
|
|
GlobalServerIpAddressUnicodeString,
|
|
0,
|
|
sizeof(Attribs)/sizeof(Attribs[0]),
|
|
Attribs,
|
|
&pDhcpAttribArr
|
|
);
|
|
|
|
if( ERROR_NOT_SUPPORTED == Err ) {
|
|
Err = ERROR_SUCCESS;
|
|
}
|
|
|
|
if( ERROR_SUCCESS != Err ) {
|
|
return Err;
|
|
}
|
|
|
|
printf("Supported Server Attributes:\n");
|
|
if( pDhcpAttribArr ) {
|
|
for( i = 0; i < pDhcpAttribArr->NumElements ; i ++ ) {
|
|
PrintDhcpAttrib(&pDhcpAttribArr->DhcpAttribs[i]);
|
|
}
|
|
DhcpRpcFreeMemory(pDhcpAttribArr);
|
|
}
|
|
|
|
return ERROR_SUCCESS;
|
|
}
|
|
|
|
DWORD
|
|
ProcessRetryAuthorization( // what is the server status?
|
|
IN DWORD CommandArgc,
|
|
IN LPSTR *CommandArgv
|
|
)
|
|
{
|
|
return DhcpServerRedoAuthorization(
|
|
GlobalServerIpAddressUnicodeString,
|
|
0
|
|
);
|
|
}
|
|
|
|
|
|
DWORD
|
|
ProcessGetBindings(
|
|
IN DWORD CommandArgc,
|
|
IN LPSTR *CommandArgv
|
|
)
|
|
{
|
|
ULONG Error, i ;
|
|
LPDHCP_BIND_ELEMENT_ARRAY BindInfo = NULL;
|
|
|
|
Error = DhcpGetServerBindingInfo(
|
|
GlobalServerIpAddressUnicodeString,
|
|
0,
|
|
&BindInfo
|
|
);
|
|
if( ERROR_SUCCESS != Error ) {
|
|
printf("Error: %ld (0x%lx)\n", Error, Error);
|
|
return Error;
|
|
}
|
|
|
|
for( i = 0; i < BindInfo->NumElements ; i ++ ) {
|
|
printf("%s \"%ws\"\n",
|
|
BindInfo->Elements[i].fBoundToDHCPServer ? "[BOUND] " : "[UNBOUND]" ,
|
|
BindInfo->Elements[i].IfDescription
|
|
);
|
|
}
|
|
|
|
DhcpRpcFreeMemory(BindInfo);
|
|
return ERROR_SUCCESS;
|
|
}
|
|
|
|
DWORD
|
|
ProcessSetBinding(
|
|
IN DWORD CommandArgc,
|
|
IN LPSTR *CommandArgv
|
|
)
|
|
{
|
|
ULONG Error, i ;
|
|
BOOL Bind;
|
|
LPDHCP_BIND_ELEMENT_ARRAY BindInfo = NULL;
|
|
LPWSTR AdapterName;
|
|
|
|
if( CommandArgc != 2 ) {
|
|
printf("usage: DhcpCmd SrvIpAddress SetBinding [BIND/UNBIND] AdapterName");
|
|
return ERROR_SUCCESS;
|
|
}
|
|
|
|
if( 0 == _stricmp(CommandArgv[0], "BIND") ) {
|
|
Bind = TRUE;
|
|
} else {
|
|
Bind = FALSE;
|
|
}
|
|
|
|
AdapterName = DhcpOemToUnicode(CommandArgv[1], NULL);
|
|
|
|
Error = DhcpGetServerBindingInfo(
|
|
GlobalServerIpAddressUnicodeString,
|
|
0,
|
|
&BindInfo
|
|
);
|
|
if( ERROR_SUCCESS != Error ) {
|
|
printf("Error: %ld (0x%lx)\n", Error, Error);
|
|
return Error;
|
|
}
|
|
|
|
for( i = 0; i < BindInfo->NumElements ; i ++ ) {
|
|
if( 0 == _wcsicmp(BindInfo->Elements[i].IfDescription, AdapterName)) {
|
|
BindInfo->Elements[i].fBoundToDHCPServer = Bind;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if( i == BindInfo->NumElements ) {
|
|
printf("Requested Adapter Name not present. \n"
|
|
"Use DhcpCmd SrvIpAddress GetBindings to view bindings.\n");
|
|
return ERROR_SUCCESS;
|
|
}
|
|
|
|
Error = DhcpSetServerBindingInfo(
|
|
GlobalServerIpAddressUnicodeString,
|
|
0,
|
|
BindInfo
|
|
);
|
|
if( ERROR_SUCCESS != Error ) {
|
|
printf("Error: %ld (0x%lx)\n", Error, Error);
|
|
}
|
|
|
|
DhcpRpcFreeMemory(BindInfo);
|
|
return ERROR_SUCCESS;
|
|
}
|
|
|
|
#define CMD_OPT_INVALID 0
|
|
#define CMD_OPT_LPWSTR 1
|
|
#define CMD_OPT_BOOL 2
|
|
|
|
struct /* anonymous */ {
|
|
LPSTR CommandOptName;
|
|
DWORD CommandOptType;
|
|
LPVOID CommandOptStorage;
|
|
} CommandOpts[] = {
|
|
{ "ClassName", CMD_OPT_LPWSTR, (LPVOID)&GlobalClassName },
|
|
{ "VendorName", CMD_OPT_LPWSTR, (LPVOID)&GlobalVendorName },
|
|
{ "IsVendor", CMD_OPT_BOOL, (LPVOID)&GlobalIsVendor },
|
|
{ "NoRPC", CMD_OPT_BOOL, (LPVOID)&GlobalNoRPC },
|
|
{ "NoDS", CMD_OPT_BOOL, (LPVOID)&GlobalNoDS },
|
|
{ NULL, CMD_OPT_INVALID, NULL },
|
|
};
|
|
|
|
DWORD
|
|
ProcessOption( // process a given option
|
|
IN DWORD Index, // index into CommandOpts table
|
|
IN LPSTR Value // value passed for option
|
|
)
|
|
{
|
|
BOOL Val_BOOL;
|
|
LPWSTR Val_LPWSTR;
|
|
|
|
switch(CommandOpts[Index].CommandOptType ) { // see what type we need to convert to..
|
|
case CMD_OPT_BOOL:
|
|
if( NULL == Value || '\0' == *Value ) {
|
|
Val_BOOL = TRUE; // implicitly set value to TRUE
|
|
} else {
|
|
if( 0 == _stricmp(Value, "TRUE") ) { // explicitly setting TRUE
|
|
Val_BOOL = TRUE;
|
|
} else if( 0 == _stricmp(Value, "FALSE" ) ) {
|
|
Val_BOOL = FALSE; // explicitly setting it to FALSE
|
|
} else {
|
|
return ERROR_INVALID_PARAMETER; // unknown response..
|
|
}
|
|
}
|
|
|
|
*((LPBOOL)(CommandOpts[Index].CommandOptStorage)) = Val_BOOL;
|
|
break;
|
|
|
|
case CMD_OPT_LPWSTR:
|
|
if( NULL == Value ) {
|
|
Val_LPWSTR = NULL;
|
|
} else if( '\0' == *Value ) {
|
|
Val_LPWSTR = L"";
|
|
} else { // now convert this..
|
|
Val_LPWSTR = DhcpOemToUnicode(Value, NULL);
|
|
}
|
|
|
|
*((LPWSTR *)(CommandOpts[Index].CommandOptStorage)) = Val_LPWSTR;
|
|
break;
|
|
|
|
default:
|
|
return ERROR_CALL_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
return ERROR_SUCCESS;
|
|
}
|
|
|
|
DWORD
|
|
ProcessOptions( // process all options..
|
|
IN OUT int *argc,
|
|
IN OUT LPSTR argv[]
|
|
)
|
|
{
|
|
DWORD Error;
|
|
int i, j, k, n;
|
|
LPSTR Arg, Val;
|
|
|
|
for( i = 1; i < *argc ; i ++ ) { // process each option
|
|
if( argv[i][0] != '/' && argv[i][0] != '-' ) {
|
|
continue; // not an option
|
|
}
|
|
|
|
Arg = argv[i]; // an option to process
|
|
Arg ++; // skip leading '/' or '-'
|
|
Val = strchr(Arg, ':'); // see if it is of form /Option:Value
|
|
if( Val ) { // yup!
|
|
*Val = '\0'; // terminate Arg..
|
|
Val++; // now Val points to value in /Option:Value
|
|
}
|
|
|
|
for( j = 0; CommandOpts[j].CommandOptName ; j ++ ) {
|
|
if( 0 == _stricmp(Arg, CommandOpts[j].CommandOptName) ) {
|
|
break; // found a match!
|
|
}
|
|
}
|
|
|
|
if( NULL == CommandOpts[j].CommandOptName ) {
|
|
if( Val ) Val[-1] = ':'; // give back the colon we stole..
|
|
continue;
|
|
}
|
|
|
|
for( k = i + 1; k < *argc ; k ++ ) { // remove this arg and slide the rest
|
|
argv[k-1] = argv[k];
|
|
}
|
|
i -- ; (*argc) --;
|
|
|
|
Error = ProcessOption( j, Val ); // now process it
|
|
if( ERROR_SUCCESS != Error ) { // ouch?
|
|
DhcpPrint((0xFFFF, "Could not process option: /%s:%s\n", Arg, Val));
|
|
return Error;
|
|
}
|
|
}
|
|
|
|
return ERROR_SUCCESS;
|
|
}
|
|
|
|
VOID
|
|
CleanupOptions(
|
|
VOID
|
|
)
|
|
{
|
|
DWORD i;
|
|
LPWSTR String;
|
|
|
|
for( i = 0; CommandOpts[i].CommandOptName ; i ++ ) {
|
|
switch(CommandOpts[i].CommandOptType ) {
|
|
case CMD_OPT_BOOL:
|
|
// nothing to free
|
|
break;
|
|
case CMD_OPT_LPWSTR:
|
|
// need to free string space used..
|
|
String = *((LPWSTR *)CommandOpts[i].CommandOptStorage);
|
|
if( NULL != String ) DhcpFreeMemory(String);
|
|
break;
|
|
}
|
|
}
|
|
|
|
// done!
|
|
}
|
|
#endif NT5
|
|
|
|
#ifdef NT5
|
|
#define OPTIONS_STRING "[Options]"
|
|
#else
|
|
#define OPTIONS_STRING
|
|
#endif
|
|
|
|
DWORD __cdecl
|
|
main(
|
|
int argc,
|
|
char **argv
|
|
)
|
|
{
|
|
DWORD Error, ThreadOptions;
|
|
COMMAND_CODE CommandCode;
|
|
DWORD CommandArgc;
|
|
LPSTR *CommandArgv;
|
|
|
|
INIT_DEBUG_HEAP( HEAPX_VERIFY );
|
|
|
|
Error = ERROR_SUCCESS;
|
|
#ifdef NT5
|
|
Error = ProcessOptions(&argc, argv);
|
|
#endif NT5
|
|
|
|
if( ERROR_SUCCESS != Error || argc < 3 ) {
|
|
printf("usage:DhcpCmd SrvIpAddress" OPTIONS_STRING "Command [Command Parameters].\n");
|
|
printf("Commands : \n");
|
|
PrintCommands();
|
|
#ifdef NT5
|
|
printf("Options: \n");
|
|
printf("\t/ClassName:<string> -- [default NULL] specify class name wherever applicable.\n");
|
|
printf("\t/VendorName:<string> -- [default NULL] specify vendor name wherever applicable.\n");
|
|
printf("\t/IsVendor:TRUE/FALSE -- [default FALSE] specify that option being referred as vendor.\n");
|
|
printf("\t/NoRPC:TRUE/FALSE -- [default FALSE] specify that no RPC calls should be made.\n");
|
|
printf("\t/NoDS:TRUE/FALSE -- [default TRUE] specify that no DS calls should be made.\n");
|
|
printf("\n\n");
|
|
#endif NT5
|
|
Error = ERROR_SUCCESS;
|
|
goto Cleanup;
|
|
}
|
|
|
|
GlobalServerIpAddressAnsiString = argv[1];
|
|
GlobalServerIpAddressUnicodeString =
|
|
DhcpOemToUnicode( GlobalServerIpAddressAnsiString, NULL );
|
|
|
|
if( GlobalServerIpAddressUnicodeString == NULL ) {
|
|
Error = ERROR_NOT_ENOUGH_MEMORY;
|
|
printf("Insufficient memory\n");
|
|
goto Cleanup;
|
|
}
|
|
|
|
GlobalServerIpAddressAnsiString = argv[1];
|
|
|
|
CommandCode = DecodeCommand( argv[2] );
|
|
if( CommandCode == UnknownCommand ) {
|
|
Error = ERROR_INVALID_PARAMETER;
|
|
printf("Unknown Command Specified.\n");
|
|
goto Cleanup;
|
|
}
|
|
|
|
if( FALSE == GlobalNoRPC ) {
|
|
Error = ProcessGetVersion( &g_dwMajor, &g_dwMinor );
|
|
if ( ERROR_SUCCESS != Error ) {
|
|
printf("Unable to determine server version.\n" );
|
|
goto Cleanup;
|
|
}
|
|
} else {
|
|
Error = ERROR_SUCCESS;
|
|
}
|
|
|
|
if ( FALSE == GlobalNoRPC && !IsValidServerVersion( g_dwMajor, g_dwMinor ) ) {
|
|
printf( "This version of %s works with Microsoft DHCP server"
|
|
" running on Windows NT Server version %d.%d or later.\n",
|
|
argv[0],
|
|
DHCPCMD_VERSION_MAJOR,
|
|
DHCPCMD_VERSION_MINOR
|
|
);
|
|
Error = ERROR_OLD_WIN_VERSION;
|
|
goto Cleanup;
|
|
}
|
|
|
|
CommandArgc = (DWORD)(argc - 3);
|
|
CommandArgv = &argv[3];
|
|
|
|
#ifdef NT5
|
|
Error = ERROR_SUCCESS;
|
|
if( FALSE == GlobalNoDS ) Error = DhcpDsInit();
|
|
if( ERROR_SUCCESS != Error && FALSE == GlobalNoDS ) {
|
|
printf("DhcpDsInit() failed %ld (0x%lx), but continuing ..\n", Error, Error);
|
|
printf("This indicates that either your machine is part of a work group\n");
|
|
printf("or that your DS is unreachable\n");
|
|
}
|
|
|
|
Error = ERROR_SUCCESS;
|
|
|
|
ThreadOptions = 0;
|
|
if( GlobalNoRPC ) ThreadOptions |= DHCP_FLAGS_DONT_DO_RPC;
|
|
if( GlobalNoDS ) ThreadOptions |= DHCP_FLAGS_DONT_ACCESS_DS;
|
|
DhcpSetThreadOptions(ThreadOptions, 0);
|
|
|
|
#endif NT5
|
|
|
|
switch( CommandCode ) {
|
|
case AddIpRange:
|
|
Error = ProcessAddIpRange( CommandArgc, CommandArgv );
|
|
break;
|
|
|
|
case RemoveIpRange:
|
|
Error = ProcessRemoveIpRange( CommandArgc, CommandArgv );
|
|
break;
|
|
|
|
#ifdef NT5
|
|
case EnumIpRanges:
|
|
Error = ProcessEnumIpRanges( CommandArgc, CommandArgv );
|
|
break;
|
|
#endif NT5
|
|
|
|
case AddReservedIp:
|
|
Error = ProcessAddReservedIp( CommandArgc, CommandArgv );
|
|
break;
|
|
|
|
case EnumClients:
|
|
Error = ProcessEnumClients( CommandArgc, CommandArgv );
|
|
break;
|
|
|
|
#ifdef NT5
|
|
case EnumClientsV5:
|
|
Error = ProcessEnumClientsV5( CommandArgc, CommandArgv );
|
|
break;
|
|
#endif NT5
|
|
|
|
case MibCounts:
|
|
Error = ProcessMibCounts( CommandArgc, CommandArgv );
|
|
break;
|
|
|
|
case ServerConfig:
|
|
Error = ProcessServerConfig( CommandArgc, CommandArgv );
|
|
break;
|
|
|
|
case GetDhcpVersion:
|
|
Error = ProcessGetVersion( &g_dwMajor, &g_dwMinor );
|
|
break;
|
|
|
|
case SetSuperScope:
|
|
Error = ProcessSetSuperScope( CommandArgc, CommandArgv );
|
|
break;
|
|
|
|
case RemoveSubscope:
|
|
Error = ProcessRemoveSubscope( CommandArgc, CommandArgv );
|
|
break;
|
|
|
|
case DeleteSuperScope:
|
|
Error = ProcessDeleteSuperScope( CommandArgc, CommandArgv );
|
|
break;
|
|
|
|
case GetSuperScopeTable:
|
|
Error = ProcessGetSuperScopeTable( CommandArgc, CommandArgv );
|
|
break;
|
|
|
|
case CheckDB:
|
|
Error = ProcessCheckDB( CommandArgc, CommandArgv );
|
|
break;
|
|
|
|
case CreateSubnet:
|
|
Error = ProcessCreateSubnet( CommandArgc, CommandArgv );
|
|
break;
|
|
|
|
case DeleteSubnet:
|
|
Error = ProcessDeleteSubnet( CommandArgc, CommandArgv );
|
|
break;
|
|
|
|
case AddExcludeRange:
|
|
Error = ProcessAddExcludeRange( CommandArgc, CommandArgv );
|
|
break;
|
|
|
|
case RemoveReservedIp:
|
|
Error = ProcessRemoveReservedIp( CommandArgc, CommandArgv );
|
|
break;
|
|
|
|
case RemoveExcludeRange:
|
|
Error = ProcessRemoveExcludeRange( CommandArgc, CommandArgv );
|
|
break;
|
|
|
|
case SetSubnetState:
|
|
Error = ProcessSetSubnetState( CommandArgc, CommandArgv );
|
|
break;
|
|
|
|
case CreateOption:
|
|
Error = ProcessCreateOption( CommandArgc, CommandArgv );
|
|
break;
|
|
|
|
case DeleteOption:
|
|
Error = ProcessDeleteOption( CommandArgc, CommandArgv );
|
|
break;
|
|
|
|
case SetGlobalOptionValue:
|
|
Error = ProcessSetGlobalOptionValue( CommandArgc, CommandArgv );
|
|
break;
|
|
|
|
case SetGlobalOptionValues:
|
|
Error = ProcessSetGlobalOptionValues( CommandArgc, CommandArgv );
|
|
break;
|
|
|
|
case RemoveGlobalOptionValue:
|
|
Error = ProcessRemoveGlobalOptionValue( CommandArgc, CommandArgv );
|
|
break;
|
|
|
|
case SetSubnetOptionValue:
|
|
Error = ProcessSetSubnetOptionValue( CommandArgc, CommandArgv );
|
|
break;
|
|
|
|
case RemoveSubnetOptionValue:
|
|
Error = ProcessRemoveSubnetOptionValue( CommandArgc, CommandArgv );
|
|
break;
|
|
|
|
case SetReservedOptionValue:
|
|
Error = ProcessSetReservedOptionValue( CommandArgc, CommandArgv );
|
|
break;
|
|
|
|
case RemoveReservedOptionValue:
|
|
Error = ProcessRemoveReservedOptionValue( CommandArgc, CommandArgv );
|
|
break;
|
|
|
|
case EnumOptions:
|
|
Error = ProcessEnumOptions( CommandArgc, CommandArgv );
|
|
break;
|
|
|
|
#ifdef NT5
|
|
case GetAllOptions:
|
|
Error = ProcessGetAllOptions( CommandArgc, CommandArgv );
|
|
break;
|
|
|
|
case GetAllOptionValues:
|
|
Error = ProcessGetAllOptionValues( CommandArgc, CommandArgv );
|
|
break;
|
|
|
|
case CreateMScope:
|
|
Error = ProcessCreateMScope( CommandArgc, CommandArgv );
|
|
break;
|
|
|
|
case DeleteMScope:
|
|
Error = ProcessDeleteMScope( CommandArgc, CommandArgv );
|
|
break;
|
|
|
|
case AddMScopeRange:
|
|
Error = ProcessAddMScopeIpRange( CommandArgc, CommandArgv );
|
|
break;
|
|
|
|
case EnumMScopeClients:
|
|
Error = ProcessEnumMScopeClients( CommandArgc, CommandArgv );
|
|
break;
|
|
|
|
case ReconcileMScope:
|
|
Error = ProcessReconcileMScope( CommandArgc, CommandArgv );
|
|
break;
|
|
|
|
case EnumMScopes:
|
|
Error = ProcessEnumMScopes( CommandArgc, CommandArgv );
|
|
break;
|
|
|
|
case MCastMibCounts:
|
|
Error = ProcessMCastMibCounts( CommandArgc, CommandArgv );
|
|
break;
|
|
|
|
case EnumServers:
|
|
Error = ProcessEnumServers( CommandArgc, CommandArgv );
|
|
break;
|
|
|
|
case AddServer:
|
|
Error = ProcessAddServer( CommandArgc, CommandArgv );
|
|
break;
|
|
|
|
case DelServer:
|
|
Error = ProcessDelServer( CommandArgc, CommandArgv );
|
|
break;
|
|
|
|
case CreateClass:
|
|
Error = ProcessCreateClass( CommandArgc, CommandArgv );
|
|
break;
|
|
|
|
case DeleteClass:
|
|
Error = ProcessDeleteClass( CommandArgc, CommandArgv );
|
|
break;
|
|
|
|
case EnumClasses:
|
|
Error = ProcessEnumClasses( CommandArgc, CommandArgv );
|
|
break;
|
|
|
|
case GetServerStatus:
|
|
Error = ProcessGetServerStatus( CommandArgc, CommandArgv );
|
|
break;
|
|
|
|
case RetryAuthorization:
|
|
Error = ProcessRetryAuthorization(CommandArgc, CommandArgv);
|
|
break;
|
|
|
|
case DeleteBadClients:
|
|
Error = ProcessDeleteBadClients(CommandArgc, CommandArgv);
|
|
break;
|
|
|
|
case DeleteClient:
|
|
Error = ProcessDeleteClient(CommandArgc, CommandArgv);
|
|
break;
|
|
|
|
case GetBindings:
|
|
Error = ProcessGetBindings(CommandArgc, CommandArgv);
|
|
break;
|
|
|
|
case SetBinding:
|
|
Error = ProcessSetBinding(CommandArgc, CommandArgv);
|
|
break;
|
|
|
|
#endif NT5
|
|
|
|
case UnknownCommand:
|
|
default:
|
|
DhcpAssert( FALSE );
|
|
Error = ERROR_INVALID_PARAMETER;
|
|
printf("Unknown Command Specified.\n");
|
|
goto Cleanup;
|
|
}
|
|
|
|
Cleanup:
|
|
|
|
#ifdef NT5
|
|
DhcpDsCleanup();
|
|
#endif NT5
|
|
|
|
if( GlobalServerIpAddressUnicodeString != NULL ) {
|
|
DhcpFreeMemory( GlobalServerIpAddressUnicodeString );
|
|
}
|
|
|
|
#ifdef NT5
|
|
CleanupOptions();
|
|
#endif NT5
|
|
|
|
if( Error != ERROR_SUCCESS ) {
|
|
printf("Command failed, %ld.\n", Error );
|
|
return(1);
|
|
}
|
|
|
|
UNINIT_DEBUG_HEAP();
|
|
printf("Command successfully completed.\n");
|
|
|
|
return(0);
|
|
}
|
|
|
|
//================================================================================
|
|
// end of file
|
|
//================================================================================
|
|
|