able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/net/published/inc/dhcpapi.w

1714 lines
54 KiB
OpenEdge ABL
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*++
Copyright (c) Microsoft Corporation. All rights reserved.
Module Name:
dhcpapi.h
Abstract:
This file contains the DHCP APIs proto-type and description. Also
contains the data structures used by the DHCP APIs.
Author:
Madan Appiah (madana) 12-Aug-1993
Environment:
User Mode - Win32 - MIDL
Revision History:
Cheng Yang (t-cheny) 18-Jun-1996 superscope
--*/
#ifndef _DHCPAPI_
#define _DHCPAPI_
#if defined(MIDL_PASS)
#define LPWSTR [string] wchar_t *
#endif
//
// DHCP data structures.
//
#ifndef _DHCP_
//
// the follwing typedef's are defined in dhcp.h also.
//
typedef DWORD DHCP_IP_ADDRESS, *PDHCP_IP_ADDRESS, *LPDHCP_IP_ADDRESS;
typedef DWORD DHCP_OPTION_ID;
typedef struct _DATE_TIME {
DWORD dwLowDateTime;
DWORD dwHighDateTime;
} DATE_TIME, *LPDATE_TIME;
#define DHCP_DATE_TIME_ZERO_HIGH 0
#define DHCP_DATE_TIME_ZERO_LOW 0
#define DHCP_DATE_TIME_INFINIT_HIGH 0x7FFFFFFF
#define DHCP_DATE_TIME_INFINIT_LOW 0xFFFFFFFF
#endif
#ifndef DHCP_ENCODE_SEED
#define DHCP_ENCODE_SEED ((UCHAR)0xA5)
#endif
#ifdef __cplusplus
#define DHCP_CONST const
#else
#define DHCP_CONST
#endif // __cplusplus
#if (_MSC_VER >= 800)
#define DHCP_API_FUNCTION __stdcall
#else
#define DHCP_API_FUNCTION
#endif
//
// RPC security.
//
#define DHCP_SERVER_SECURITY L"DhcpServerApp"
#define DHCP_SERVER_SECURITY_AUTH_ID 10
#define DHCP_NAMED_PIPE L"\\PIPE\\DHCPSERVER"
#define DHCP_SERVER_BIND_PORT L""
#define DHCP_LPC_EP L"DHCPSERVERLPC"
#define DHCP_SERVER_USE_RPC_OVER_TCPIP 0x1
#define DHCP_SERVER_USE_RPC_OVER_NP 0x2
#define DHCP_SERVER_USE_RPC_OVER_LPC 0x4
#define DHCP_SERVER_USE_RPC_OVER_ALL (\
DHCP_SERVER_USE_RPC_OVER_TCPIP | \
DHCP_SERVER_USE_RPC_OVER_NP | \
DHCP_SERVER_USE_RPC_OVER_LPC)
#ifndef HARDWARE_TYPE_10MB_EITHERNET
#define HARDWARE_TYPE_10MB_EITHERNET (1)
#endif
#define DHCP_RAS_CLASS_TXT "RRAS.Microsoft"
#define DHCP_BOOTP_CLASS_TXT "BOOTP.Microsoft"
#define DHCP_MSFT50_CLASS_TXT "MSFT 5.0"
#define DHCP_MSFT98_CLASS_TXT "MSFT 98"
#define DHCP_MSFT_CLASS_TXT "MSFT"
typedef DWORD DHCP_IP_MASK;
typedef DWORD DHCP_RESUME_HANDLE;
typedef struct _DHCP_IP_RANGE {
DHCP_IP_ADDRESS StartAddress;
DHCP_IP_ADDRESS EndAddress;
} DHCP_IP_RANGE, *LPDHCP_IP_RANGE;
typedef struct _DHCP_BINARY_DATA {
DWORD DataLength;
#if defined(MIDL_PASS)
[size_is(DataLength)]
#endif // MIDL_PASS
BYTE *Data;
} DHCP_BINARY_DATA, *LPDHCP_BINARY_DATA;
typedef DHCP_BINARY_DATA DHCP_CLIENT_UID;
typedef struct _DHCP_HOST_INFO {
DHCP_IP_ADDRESS IpAddress; // minimum information always available
LPWSTR NetBiosName; // optional information
LPWSTR HostName; // optional information
} DHCP_HOST_INFO, *LPDHCP_HOST_INFO;
//
// Flag type that is used to delete DHCP objects.
//
typedef enum _DHCP_FORCE_FLAG {
DhcpFullForce,
DhcpNoForce
} DHCP_FORCE_FLAG, *LPDHCP_FORCE_FLAG;
//
// DWORD_DWORD - subtitute for LARGE_INTEGER
//
typedef struct _DWORD_DWORD {
DWORD DWord1;
DWORD DWord2;
} DWORD_DWORD, *LPDWORD_DWORD;
//
// Subnet State.
//
// Currently a Subnet scope can be Enabled or Disabled.
//
// If the state is Enabled State,
// The server distributes address to the client, extends leases and
// accepts releases.
//
// If the state is Disabled State,
// The server does not distribute address to any new client, and does
// extent (and sends NACK) old leases, but the servers accepts lease
// releases.
//
// The idea behind this subnet state is, when the admin wants to stop
// serving a subnet, he moves the state from Enbaled to Disabled so
// that the clients from the subnets smoothly move to another servers
// serving that subnet. When all or most of the clients move to
// another server, the admin can delete the subnet without any force
// if no client left in that subnet, otherwise the admin should use
// full force to delete the subnet.
//
typedef enum _DHCP_SUBNET_STATE {
DhcpSubnetEnabled,
DhcpSubnetDisabled,
DhcpSubnetEnabledSwitched,
DhcpSubnetDisabledSwitched
} DHCP_SUBNET_STATE, *LPDHCP_SUBNET_STATE;
//
// Subnet related data structures.
//
typedef struct _DHCP_SUBNET_INFO {
DHCP_IP_ADDRESS SubnetAddress;
DHCP_IP_MASK SubnetMask;
LPWSTR SubnetName;
LPWSTR SubnetComment;
DHCP_HOST_INFO PrimaryHost;
DHCP_SUBNET_STATE SubnetState;
} DHCP_SUBNET_INFO, *LPDHCP_SUBNET_INFO;
typedef struct _DHCP_IP_ARRAY {
DWORD NumElements;
#if defined(MIDL_PASS)
[size_is(NumElements)]
#endif // MIDL_PASS
LPDHCP_IP_ADDRESS Elements; //array
} DHCP_IP_ARRAY, *LPDHCP_IP_ARRAY;
typedef struct _DHCP_IP_CLUSTER {
DHCP_IP_ADDRESS ClusterAddress; // First IP address of the cluster.
DWORD ClusterMask; // Cluster usage mask, 0xFFFFFFFF
// indicates the cluster is fully used.
} DHCP_IP_CLUSTER, *LPDHCP_IP_CLUSTER;
typedef struct _DHCP_IP_RESERVATION {
DHCP_IP_ADDRESS ReservedIpAddress;
DHCP_CLIENT_UID *ReservedForClient;
} DHCP_IP_RESERVATION, *LPDHCP_IP_RESERVATION;
typedef enum _DHCP_SUBNET_ELEMENT_TYPE_V5 {
//
// If you don't care about what you wan't to get..
// NB: These six lines should not be changed!
//
DhcpIpRanges,
DhcpSecondaryHosts,
DhcpReservedIps,
DhcpExcludedIpRanges,
DhcpIpUsedClusters, // read only
//
// These are for IP ranges for DHCP ONLY
//
DhcpIpRangesDhcpOnly,
//
// These are ranges that are BOTH DHCP & Dynamic BOOTP
//
DhcpIpRangesDhcpBootp,
//
// These are ranges that are ONLY BOOTP
//
DhcpIpRangesBootpOnly,
} DHCP_SUBNET_ELEMENT_TYPE, *LPDHCP_SUBNET_ELEMENT_TYPE;
#define ELEMENT_MASK(E) ((((E) <= DhcpIpRangesBootpOnly) && (DhcpIpRangesDhcpOnly <= (E)))?(0):(E))
typedef struct _DHCP_SUBNET_ELEMENT_DATA {
DHCP_SUBNET_ELEMENT_TYPE ElementType;
#if defined(MIDL_PASS)
[switch_is(ELEMENT_MASK(ElementType)), switch_type(DHCP_SUBNET_ELEMENT_TYPE)]
union _DHCP_SUBNET_ELEMENT_UNION {
[case(DhcpIpRanges)] DHCP_IP_RANGE *IpRange;
[case(DhcpSecondaryHosts)] DHCP_HOST_INFO *SecondaryHost;
[case(DhcpReservedIps)] DHCP_IP_RESERVATION *ReservedIp;
[case(DhcpExcludedIpRanges)] DHCP_IP_RANGE *ExcludeIpRange;
[case(DhcpIpUsedClusters)] DHCP_IP_CLUSTER *IpUsedCluster;
[default] ;
} Element;
#else
union _DHCP_SUBNET_ELEMENT_UNION {
DHCP_IP_RANGE *IpRange;
DHCP_HOST_INFO *SecondaryHost;
DHCP_IP_RESERVATION *ReservedIp;
DHCP_IP_RANGE *ExcludeIpRange;
DHCP_IP_CLUSTER *IpUsedCluster;
} Element;
#endif // MIDL_PASS
} DHCP_SUBNET_ELEMENT_DATA, *LPDHCP_SUBNET_ELEMENT_DATA;
#if !defined(MIDL_PASS)
typedef union _DHCP_SUBNET_ELEMENT_UNION
DHCP_SUBNET_ELEMENT_UNION, *LPDHCP_SUBNET_ELEMENT_UNION;
#endif
typedef struct _DHCP_SUBNET_ELEMENT_INFO_ARRAY {
DWORD NumElements;
#if defined(MIDL_PASS)
[size_is(NumElements)]
#endif // MIDL_PASS
LPDHCP_SUBNET_ELEMENT_DATA Elements; //array
} DHCP_SUBNET_ELEMENT_INFO_ARRAY, *LPDHCP_SUBNET_ELEMENT_INFO_ARRAY;
//
// DHCP Options related data structures.
//
typedef enum _DHCP_OPTION_DATA_TYPE {
DhcpByteOption,
DhcpWordOption,
DhcpDWordOption,
DhcpDWordDWordOption,
DhcpIpAddressOption,
DhcpStringDataOption,
DhcpBinaryDataOption,
DhcpEncapsulatedDataOption
} DHCP_OPTION_DATA_TYPE, *LPDHCP_OPTION_DATA_TYPE;
typedef struct _DHCP_OPTION_DATA_ELEMENT {
DHCP_OPTION_DATA_TYPE OptionType;
#if defined(MIDL_PASS)
[switch_is(OptionType), switch_type(DHCP_OPTION_DATA_TYPE)]
union _DHCP_OPTION_ELEMENT_UNION {
[case(DhcpByteOption)] BYTE ByteOption;
[case(DhcpWordOption)] WORD WordOption;
[case(DhcpDWordOption)] DWORD DWordOption;
[case(DhcpDWordDWordOption)] DWORD_DWORD DWordDWordOption;
[case(DhcpIpAddressOption)] DHCP_IP_ADDRESS IpAddressOption;
[case(DhcpStringDataOption)] LPWSTR StringDataOption;
[case(DhcpBinaryDataOption)] DHCP_BINARY_DATA BinaryDataOption;
[case(DhcpEncapsulatedDataOption)] DHCP_BINARY_DATA EncapsulatedDataOption;
[default] ;
} Element;
#else
union _DHCP_OPTION_ELEMENT_UNION {
BYTE ByteOption;
WORD WordOption;
DWORD DWordOption;
DWORD_DWORD DWordDWordOption;
DHCP_IP_ADDRESS IpAddressOption;
LPWSTR StringDataOption;
DHCP_BINARY_DATA BinaryDataOption;
DHCP_BINARY_DATA EncapsulatedDataOption;
// for vendor specific information option.
} Element;
#endif // MIDL_PASS
} DHCP_OPTION_DATA_ELEMENT, *LPDHCP_OPTION_DATA_ELEMENT;
#if !defined(MIDL_PASS)
typedef union _DHCP_OPTION_ELEMENT_UNION
DHCP_OPTION_ELEMENT_UNION, *LPDHCP_OPTION_ELEMENT_UNION;
#endif
typedef struct _DHCP_OPTION_DATA {
DWORD NumElements; // number of option elements in the pointed array
#if defined(MIDL_PASS)
[size_is(NumElements)]
#endif // MIDL_PASS
LPDHCP_OPTION_DATA_ELEMENT Elements; //array
} DHCP_OPTION_DATA, *LPDHCP_OPTION_DATA;
typedef enum _DHCP_OPTION_TYPE {
DhcpUnaryElementTypeOption,
DhcpArrayTypeOption
} DHCP_OPTION_TYPE, *LPDHCP_OPTION_TYPE;
typedef struct _DHCP_OPTION {
DHCP_OPTION_ID OptionID;
LPWSTR OptionName;
LPWSTR OptionComment;
DHCP_OPTION_DATA DefaultValue;
DHCP_OPTION_TYPE OptionType;
} DHCP_OPTION, *LPDHCP_OPTION;
typedef struct _DHCP_OPTION_ARRAY {
DWORD NumElements; // number of options in the pointed array
#if defined(MIDL_PASS)
[size_is(NumElements)]
#endif // MIDL_PASS
LPDHCP_OPTION Options; // array
} DHCP_OPTION_ARRAY, *LPDHCP_OPTION_ARRAY;
typedef struct _DHCP_OPTION_VALUE {
DHCP_OPTION_ID OptionID;
DHCP_OPTION_DATA Value;
} DHCP_OPTION_VALUE, *LPDHCP_OPTION_VALUE;
typedef struct _DHCP_OPTION_VALUE_ARRAY {
DWORD NumElements; // number of options in the pointed array
#if defined(MIDL_PASS)
[size_is(NumElements)]
#endif // MIDL_PASS
LPDHCP_OPTION_VALUE Values; // array
} DHCP_OPTION_VALUE_ARRAY, *LPDHCP_OPTION_VALUE_ARRAY;
typedef enum _DHCP_OPTION_SCOPE_TYPE {
DhcpDefaultOptions,
DhcpGlobalOptions,
DhcpSubnetOptions,
DhcpReservedOptions,
DhcpMScopeOptions
} DHCP_OPTION_SCOPE_TYPE, *LPDHCP_OPTION_SCOPE_TYPE;
typedef struct _DHCP_RESERVED_SCOPE {
DHCP_IP_ADDRESS ReservedIpAddress;
DHCP_IP_ADDRESS ReservedIpSubnetAddress;
} DHCP_RESERVED_SCOPE, *LPDHCP_RESERVED_SCOPE;
typedef struct _DHCP_OPTION_SCOPE_INFO {
DHCP_OPTION_SCOPE_TYPE ScopeType;
#if defined(MIDL_PASS)
[switch_is(ScopeType), switch_type(DHCP_OPTION_SCOPE_TYPE)]
union _DHCP_OPTION_SCOPE_UNION {
[case(DhcpDefaultOptions)] ; // PVOID DefaultScopeInfo;
[case(DhcpGlobalOptions)] ; // PVOID GlobalScopeInfo;
[case(DhcpSubnetOptions)] DHCP_IP_ADDRESS SubnetScopeInfo;
[case(DhcpReservedOptions)] DHCP_RESERVED_SCOPE ReservedScopeInfo;
[case(DhcpMScopeOptions)] LPWSTR MScopeInfo;
[default] ;
} ScopeInfo;
#else
union _DHCP_OPTION_SCOPE_UNION {
PVOID DefaultScopeInfo; // must be NULL
PVOID GlobalScopeInfo; // must be NULL
DHCP_IP_ADDRESS SubnetScopeInfo;
DHCP_RESERVED_SCOPE ReservedScopeInfo;
LPWSTR MScopeInfo;
} ScopeInfo;
#endif // MIDL_PASS
} DHCP_OPTION_SCOPE_INFO, *LPDHCP_OPTION_SCOPE_INFO;
#if !defined(MIDL_PASS)
typedef union _DHCP_OPTION_SCOPE_UNION
DHCP_OPTION_SCOPE_UNION, *LPDHCP_OPTION_SCOPE_UNION;
#endif
typedef struct _DHCP_OPTION_LIST {
DWORD NumOptions;
#if defined(MIDL_PASS)
[size_is(NumOptions)]
#endif // MIDL_PASS
DHCP_OPTION_VALUE *Options; // array
} DHCP_OPTION_LIST, *LPDHCP_OPTION_LIST;
//
// DHCP Client information data structures
//
typedef struct _DHCP_CLIENT_INFO {
DHCP_IP_ADDRESS ClientIpAddress; // currently assigned IP address.
DHCP_IP_MASK SubnetMask;
DHCP_CLIENT_UID ClientHardwareAddress;
LPWSTR ClientName; // optional.
LPWSTR ClientComment;
DATE_TIME ClientLeaseExpires; // UTC time in FILE_TIME format.
DHCP_HOST_INFO OwnerHost; // host that distributed this IP address.
} DHCP_CLIENT_INFO, *LPDHCP_CLIENT_INFO;
typedef struct _DHCP_CLIENT_INFO_ARRAY {
DWORD NumElements;
#if defined(MIDL_PASS)
[size_is(NumElements)]
#endif // MIDL_PASS
LPDHCP_CLIENT_INFO *Clients; // array of pointers
} DHCP_CLIENT_INFO_ARRAY, *LPDHCP_CLIENT_INFO_ARRAY;
typedef enum _DHCP_CLIENT_SEARCH_TYPE {
DhcpClientIpAddress,
DhcpClientHardwareAddress,
DhcpClientName
} DHCP_SEARCH_INFO_TYPE, *LPDHCP_SEARCH_INFO_TYPE;
typedef struct _DHCP_CLIENT_SEARCH_INFO {
DHCP_SEARCH_INFO_TYPE SearchType;
#if defined(MIDL_PASS)
[switch_is(SearchType), switch_type(DHCP_SEARCH_INFO_TYPE)]
union _DHCP_CLIENT_SEARCH_UNION {
[case(DhcpClientIpAddress)] DHCP_IP_ADDRESS ClientIpAddress;
[case(DhcpClientHardwareAddress)] DHCP_CLIENT_UID ClientHardwareAddress;
[case(DhcpClientName)] LPWSTR ClientName;
[default] ;
} SearchInfo;
#else
union _DHCP_CLIENT_SEARCH_UNION {
DHCP_IP_ADDRESS ClientIpAddress;
DHCP_CLIENT_UID ClientHardwareAddress;
LPWSTR ClientName;
} SearchInfo;
#endif // MIDL_PASS
} DHCP_SEARCH_INFO, *LPDHCP_SEARCH_INFO;
#if !defined(MIDL_PASS)
typedef union _DHCP_CLIENT_SEARCH_UNION
DHCP_CLIENT_SEARCH_UNION, *LPDHCP_CLIENT_SEARCH_UNION;
#endif // MIDL_PASS
//
// Mib Info structures.
//
typedef struct _SCOPE_MIB_INFO {
DHCP_IP_ADDRESS Subnet;
DWORD NumAddressesInuse;
DWORD NumAddressesFree;
DWORD NumPendingOffers;
} SCOPE_MIB_INFO, *LPSCOPE_MIB_INFO;
typedef struct _DHCP_MIB_INFO {
DWORD Discovers;
DWORD Offers;
DWORD Requests;
DWORD Acks;
DWORD Naks;
DWORD Declines;
DWORD Releases;
DATE_TIME ServerStartTime;
DWORD Scopes;
#if defined(MIDL_PASS)
[size_is(Scopes)]
#endif // MIDL_PASS
LPSCOPE_MIB_INFO ScopeInfo; // array.
} DHCP_MIB_INFO, *LPDHCP_MIB_INFO;
#define Set_APIProtocolSupport 0x00000001
#define Set_DatabaseName 0x00000002
#define Set_DatabasePath 0x00000004
#define Set_BackupPath 0x00000008
#define Set_BackupInterval 0x00000010
#define Set_DatabaseLoggingFlag 0x00000020
#define Set_RestoreFlag 0x00000040
#define Set_DatabaseCleanupInterval 0x00000080
#define Set_DebugFlag 0x00000100
#define Set_PingRetries 0x00000200
#define Set_BootFileTable 0x00000400
#define Set_AuditLogState 0x00000800
typedef struct _DHCP_SERVER_CONFIG_INFO {
DWORD APIProtocolSupport; // bit map of the protocols supported.
LPWSTR DatabaseName; // JET database name.
LPWSTR DatabasePath; // JET database path.
LPWSTR BackupPath; // Backup path.
DWORD BackupInterval; // Backup interval in mins.
DWORD DatabaseLoggingFlag; // Boolean database logging flag.
DWORD RestoreFlag; // Boolean database restore flag.
DWORD DatabaseCleanupInterval; // Database Cleanup Interval in mins.
DWORD DebugFlag; // Bit map of server debug flags.
} DHCP_SERVER_CONFIG_INFO, *LPDHCP_SERVER_CONFIG_INFO;
typedef enum _DHCP_SCAN_FLAG {
DhcpRegistryFix,
DhcpDatabaseFix
} DHCP_SCAN_FLAG, *LPDHCP_SCAN_FLAG;
typedef struct _DHCP_SCAN_ITEM {
DHCP_IP_ADDRESS IpAddress;
DHCP_SCAN_FLAG ScanFlag;
} DHCP_SCAN_ITEM, *LPDHCP_SCAN_ITEM;
typedef struct _DHCP_SCAN_LIST {
DWORD NumScanItems;
#if defined(MIDL_PASS)
[size_is(NumScanItems)]
#endif // MIDL_PASS
DHCP_SCAN_ITEM *ScanItems; // array
} DHCP_SCAN_LIST, *LPDHCP_SCAN_LIST;
typedef struct _DHCP_CLASS_INFO {
LPWSTR ClassName;
LPWSTR ClassComment;
DWORD ClassDataLength;
BOOL IsVendor;
DWORD Flags;
#if defined(MIDL_PASS)
[size_is(ClassDataLength)]
#endif // MIDL_PASS
LPBYTE ClassData;
} DHCP_CLASS_INFO, *LPDHCP_CLASS_INFO;
typedef struct _DHCP_CLASS_INFO_ARRAY {
DWORD NumElements;
#if defined(MIDL_PASS)
[size_is(NumElements)]
#endif //MIDL_PASS
LPDHCP_CLASS_INFO Classes;
} DHCP_CLASS_INFO_ARRAY, *LPDHCP_CLASS_INFO_ARRAY;
//
// API proto types
//
//
// Subnet APIs
//
#ifndef DHCPAPI_NO_PROTOTYPES
DWORD DHCP_API_FUNCTION
DhcpCreateSubnet(
DHCP_CONST WCHAR *ServerIpAddress,
DHCP_IP_ADDRESS SubnetAddress,
DHCP_CONST DHCP_SUBNET_INFO * SubnetInfo
);
DWORD DHCP_API_FUNCTION
DhcpSetSubnetInfo(
DHCP_CONST WCHAR *ServerIpAddress,
DHCP_IP_ADDRESS SubnetAddress,
DHCP_CONST DHCP_SUBNET_INFO * SubnetInfo
);
DWORD DHCP_API_FUNCTION
DhcpGetSubnetInfo(
DHCP_CONST WCHAR *ServerIpAddress,
DHCP_IP_ADDRESS SubnetAddress,
LPDHCP_SUBNET_INFO * SubnetInfo
);
DWORD DHCP_API_FUNCTION
DhcpEnumSubnets(
DHCP_CONST WCHAR *ServerIpAddress,
DHCP_RESUME_HANDLE *ResumeHandle,
DWORD PreferredMaximum,
LPDHCP_IP_ARRAY *EnumInfo,
DWORD *ElementsRead,
DWORD *ElementsTotal
);
DWORD DHCP_API_FUNCTION
DhcpAddSubnetElement(
DHCP_CONST WCHAR *ServerIpAddress,
DHCP_IP_ADDRESS SubnetAddress,
DHCP_CONST DHCP_SUBNET_ELEMENT_DATA * AddElementInfo
);
DWORD DHCP_API_FUNCTION
DhcpEnumSubnetElements(
DHCP_CONST WCHAR *ServerIpAddress,
DHCP_IP_ADDRESS SubnetAddress,
DHCP_SUBNET_ELEMENT_TYPE EnumElementType,
DHCP_RESUME_HANDLE *ResumeHandle,
DWORD PreferredMaximum,
LPDHCP_SUBNET_ELEMENT_INFO_ARRAY *EnumElementInfo,
DWORD *ElementsRead,
DWORD *ElementsTotal
);
DWORD DHCP_API_FUNCTION
DhcpRemoveSubnetElement(
DHCP_CONST WCHAR *ServerIpAddress,
DHCP_IP_ADDRESS SubnetAddress,
DHCP_CONST DHCP_SUBNET_ELEMENT_DATA * RemoveElementInfo,
DHCP_FORCE_FLAG ForceFlag
);
DWORD DHCP_API_FUNCTION
DhcpDeleteSubnet(
DHCP_CONST WCHAR *ServerIpAddress,
DHCP_IP_ADDRESS SubnetAddress,
DHCP_FORCE_FLAG ForceFlag
);
//
// Option APIs
//
DWORD DHCP_API_FUNCTION
DhcpCreateOption(
DHCP_CONST WCHAR *ServerIpAddress,
DHCP_OPTION_ID OptionID,
DHCP_CONST DHCP_OPTION * OptionInfo
);
DWORD DHCP_API_FUNCTION
DhcpSetOptionInfo(
DHCP_CONST WCHAR *ServerIpAddress,
DHCP_OPTION_ID OptionID,
DHCP_CONST DHCP_OPTION * OptionInfo
);
DWORD DHCP_API_FUNCTION
DhcpGetOptionInfo(
DHCP_CONST WCHAR *ServerIpAddress,
DHCP_OPTION_ID OptionID,
LPDHCP_OPTION *OptionInfo
);
DWORD DHCP_API_FUNCTION
DhcpEnumOptions(
DHCP_CONST WCHAR *ServerIpAddress,
DHCP_RESUME_HANDLE *ResumeHandle,
DWORD PreferredMaximum,
LPDHCP_OPTION_ARRAY *Options,
DWORD *OptionsRead,
DWORD *OptionsTotal
);
DWORD DHCP_API_FUNCTION
DhcpRemoveOption(
DHCP_CONST WCHAR *ServerIpAddress,
DHCP_OPTION_ID OptionID
);
DWORD DHCP_API_FUNCTION
DhcpSetOptionValue(
DHCP_CONST WCHAR *ServerIpAddress,
DHCP_OPTION_ID OptionID,
DHCP_CONST DHCP_OPTION_SCOPE_INFO * ScopeInfo,
DHCP_CONST DHCP_OPTION_DATA * OptionValue
);
DWORD DHCP_API_FUNCTION
DhcpSetOptionValues(
DHCP_CONST WCHAR *ServerIpAddress,
DHCP_CONST DHCP_OPTION_SCOPE_INFO * ScopeInfo,
DHCP_CONST DHCP_OPTION_VALUE_ARRAY * OptionValues
);
DWORD DHCP_API_FUNCTION
DhcpGetOptionValue(
DHCP_CONST WCHAR *ServerIpAddress,
DHCP_OPTION_ID OptionID,
DHCP_CONST DHCP_OPTION_SCOPE_INFO *ScopeInfo,
LPDHCP_OPTION_VALUE *OptionValue
);
DWORD DHCP_API_FUNCTION
DhcpEnumOptionValues(
DHCP_CONST WCHAR *ServerIpAddress,
DHCP_CONST DHCP_OPTION_SCOPE_INFO *ScopeInfo,
DHCP_RESUME_HANDLE *ResumeHandle,
DWORD PreferredMaximum,
LPDHCP_OPTION_VALUE_ARRAY *OptionValues,
DWORD *OptionsRead,
DWORD *OptionsTotal
);
DWORD DHCP_API_FUNCTION
DhcpRemoveOptionValue(
DHCP_CONST WCHAR *ServerIpAddress,
DHCP_OPTION_ID OptionID,
DHCP_CONST DHCP_OPTION_SCOPE_INFO * ScopeInfo
);
//
// Client APIs
//
DWORD DHCP_API_FUNCTION
DhcpCreateClientInfo(
DHCP_CONST WCHAR *ServerIpAddress,
DHCP_CONST DHCP_CLIENT_INFO *ClientInfo
);
DWORD DHCP_API_FUNCTION
DhcpSetClientInfo(
DHCP_CONST WCHAR *ServerIpAddress,
DHCP_CONST DHCP_CLIENT_INFO *ClientInfo
);
DWORD DHCP_API_FUNCTION
DhcpGetClientInfo(
DHCP_CONST WCHAR *ServerIpAddress,
DHCP_CONST DHCP_SEARCH_INFO *SearchInfo,
LPDHCP_CLIENT_INFO *ClientInfo
);
DWORD DHCP_API_FUNCTION
DhcpDeleteClientInfo(
DHCP_CONST WCHAR *ServerIpAddress,
DHCP_CONST DHCP_SEARCH_INFO *ClientInfo
);
DWORD DHCP_API_FUNCTION
DhcpEnumSubnetClients(
DHCP_CONST WCHAR *ServerIpAddress,
DHCP_IP_ADDRESS SubnetAddress,
DHCP_RESUME_HANDLE *ResumeHandle,
DWORD PreferredMaximum,
LPDHCP_CLIENT_INFO_ARRAY *ClientInfo,
DWORD *ClientsRead,
DWORD *ClientsTotal
);
DWORD DHCP_API_FUNCTION
DhcpGetClientOptions(
DHCP_CONST WCHAR *ServerIpAddress,
DHCP_IP_ADDRESS ClientIpAddress,
DHCP_IP_MASK ClientSubnetMask,
LPDHCP_OPTION_LIST *ClientOptions
);
DWORD DHCP_API_FUNCTION
DhcpGetMibInfo(
DHCP_CONST WCHAR *ServerIpAddress,
LPDHCP_MIB_INFO *MibInfo
);
DWORD DHCP_API_FUNCTION
DhcpServerSetConfig(
DHCP_CONST WCHAR *ServerIpAddress,
DWORD FieldsToSet,
LPDHCP_SERVER_CONFIG_INFO ConfigInfo
);
DWORD DHCP_API_FUNCTION
DhcpServerGetConfig(
DHCP_CONST WCHAR *ServerIpAddress,
LPDHCP_SERVER_CONFIG_INFO *ConfigInfo
);
DWORD DHCP_API_FUNCTION
DhcpScanDatabase(
DHCP_CONST WCHAR *ServerIpAddress,
DHCP_IP_ADDRESS SubnetAddress,
DWORD FixFlag,
LPDHCP_SCAN_LIST *ScanList
);
VOID DHCP_API_FUNCTION
DhcpRpcFreeMemory(
PVOID BufferPointer
);
DWORD DHCP_API_FUNCTION
DhcpGetVersion(
LPWSTR ServerIpAddress,
LPDWORD MajorVersion,
LPDWORD MinorVersion
);
#endif DHCPAPI_NO_PROTOTYPES
//
// new structures for NT4SP1
//
typedef struct _DHCP_IP_RESERVATION_V4 {
DHCP_IP_ADDRESS ReservedIpAddress;
DHCP_CLIENT_UID *ReservedForClient;
BYTE bAllowedClientTypes;
} DHCP_IP_RESERVATION_V4, *LPDHCP_IP_RESERVATION_V4;
typedef struct _DHCP_SUBNET_ELEMENT_DATA_V4 {
DHCP_SUBNET_ELEMENT_TYPE ElementType;
#if defined(MIDL_PASS)
[switch_is(ELEMENT_MASK(ElementType)), switch_type(DHCP_SUBNET_ELEMENT_TYPE)]
union _DHCP_SUBNET_ELEMENT_UNION_V4 {
[case(DhcpIpRanges)] DHCP_IP_RANGE *IpRange;
[case(DhcpSecondaryHosts)] DHCP_HOST_INFO *SecondaryHost;
[case(DhcpReservedIps)] DHCP_IP_RESERVATION_V4 *ReservedIp;
[case(DhcpExcludedIpRanges)] DHCP_IP_RANGE *ExcludeIpRange;
[case(DhcpIpUsedClusters)] DHCP_IP_CLUSTER *IpUsedCluster;
[default] ;
} Element;
#else
union _DHCP_SUBNET_ELEMENT_UNION_V4 {
DHCP_IP_RANGE *IpRange;
DHCP_HOST_INFO *SecondaryHost;
DHCP_IP_RESERVATION_V4 *ReservedIp;
DHCP_IP_RANGE *ExcludeIpRange;
DHCP_IP_CLUSTER *IpUsedCluster;
} Element;
#endif // MIDL_PASS
} DHCP_SUBNET_ELEMENT_DATA_V4, *LPDHCP_SUBNET_ELEMENT_DATA_V4;
#if !defined(MIDL_PASS)
typedef union _DHCP_SUBNET_ELEMENT_UNION_V4
DHCP_SUBNET_ELEMENT_UNION_V4, *LPDHCP_SUBNET_ELEMENT_UNION_V4;
#endif
typedef struct _DHCP_SUBNET_ELEMENT_INFO_ARRAY_V4 {
DWORD NumElements;
#if defined(MIDL_PASS)
[size_is(NumElements)]
#endif // MIDL_PASS
LPDHCP_SUBNET_ELEMENT_DATA_V4 Elements; //array
} DHCP_SUBNET_ELEMENT_INFO_ARRAY_V4, *LPDHCP_SUBNET_ELEMENT_INFO_ARRAY_V4;
// DHCP_CLIENT_INFO:bClientType
#define CLIENT_TYPE_UNSPECIFIED 0x0 // for backward compatibility
#define CLIENT_TYPE_DHCP 0x1
#define CLIENT_TYPE_BOOTP 0x2
#define CLIENT_TYPE_BOTH ( CLIENT_TYPE_DHCP | CLIENT_TYPE_BOOTP )
#define CLIENT_TYPE_RESERVATION_FLAG 0x4
#define CLIENT_TYPE_NONE 0x64
#define BOOT_FILE_STRING_DELIMITER ','
#define BOOT_FILE_STRING_DELIMITER_W L','
typedef struct _DHCP_CLIENT_INFO_V4 {
DHCP_IP_ADDRESS ClientIpAddress; // currently assigned IP address.
DHCP_IP_MASK SubnetMask;
DHCP_CLIENT_UID ClientHardwareAddress;
LPWSTR ClientName; // optional.
LPWSTR ClientComment;
DATE_TIME ClientLeaseExpires; // UTC time in FILE_TIME format.
DHCP_HOST_INFO OwnerHost; // host that distributed this IP address.
//
// new fields for NT4SP1
//
BYTE bClientType; // CLIENT_TYPE_DHCP | CLIENT_TYPE_BOOTP |
// CLIENT_TYPE_NONE
} DHCP_CLIENT_INFO_V4, *LPDHCP_CLIENT_INFO_V4;
typedef struct _DHCP_CLIENT_INFO_ARRAY_V4 {
DWORD NumElements;
#if defined(MIDL_PASS)
[size_is(NumElements)]
#endif // MIDL_PASS
LPDHCP_CLIENT_INFO_V4 *Clients; // array of pointers
} DHCP_CLIENT_INFO_ARRAY_V4, *LPDHCP_CLIENT_INFO_ARRAY_V4;
typedef struct _DHCP_SERVER_CONFIG_INFO_V4 {
DWORD APIProtocolSupport; // bit map of the protocols supported.
LPWSTR DatabaseName; // JET database name.
LPWSTR DatabasePath; // JET database path.
LPWSTR BackupPath; // Backup path.
DWORD BackupInterval; // Backup interval in mins.
DWORD DatabaseLoggingFlag; // Boolean database logging flag.
DWORD RestoreFlag; // Boolean database restore flag.
DWORD DatabaseCleanupInterval; // Database Cleanup Interval in mins.
DWORD DebugFlag; // Bit map of server debug flags.
// new fields for NT4 SP1
DWORD dwPingRetries; // valid range: 0-5 inclusive
DWORD cbBootTableString;
#if defined( MIDL_PASS )
[ size_is( cbBootTableString ) ]
#endif
WCHAR *wszBootTableString;
BOOL fAuditLog; // TRUE to enable audit log
} DHCP_SERVER_CONFIG_INFO_V4, *LPDHCP_SERVER_CONFIG_INFO_V4;
//
// superscope info structure (added by t-cheny)
//
typedef struct _DHCP_SUPER_SCOPE_TABLE_ENTRY {
DHCP_IP_ADDRESS SubnetAddress; // subnet address
DWORD SuperScopeNumber; // super scope group number
DWORD NextInSuperScope; // index of the next subnet in the superscope
LPWSTR SuperScopeName; // super scope name
// NULL indicates no superscope membership.
} DHCP_SUPER_SCOPE_TABLE_ENTRY, *LPDHCP_SUPER_SCOPE_TABLE_ENTRY;
typedef struct _DHCP_SUPER_SCOPE_TABLE
{
DWORD cEntries;
#if defined( MIDL_PASS )
[ size_is( cEntries ) ]
#endif;
DHCP_SUPER_SCOPE_TABLE_ENTRY *pEntries;
} DHCP_SUPER_SCOPE_TABLE, *LPDHCP_SUPER_SCOPE_TABLE;
//
// NT4SP1 RPC interface
//
#ifndef DHCPAPI_NO_PROTOTYPES
DWORD DHCP_API_FUNCTION
DhcpAddSubnetElementV4(
DHCP_CONST WCHAR *ServerIpAddress,
DHCP_IP_ADDRESS SubnetAddress,
DHCP_CONST DHCP_SUBNET_ELEMENT_DATA_V4 * AddElementInfo
);
DWORD DHCP_API_FUNCTION
DhcpEnumSubnetElementsV4(
DHCP_CONST WCHAR *ServerIpAddress,
DHCP_IP_ADDRESS SubnetAddress,
DHCP_SUBNET_ELEMENT_TYPE EnumElementType,
DHCP_RESUME_HANDLE *ResumeHandle,
DWORD PreferredMaximum,
LPDHCP_SUBNET_ELEMENT_INFO_ARRAY_V4 *EnumElementInfo,
DWORD *ElementsRead,
DWORD *ElementsTotal
);
DWORD DHCP_API_FUNCTION
DhcpRemoveSubnetElementV4(
DHCP_CONST WCHAR *ServerIpAddress,
DHCP_IP_ADDRESS SubnetAddress,
DHCP_CONST DHCP_SUBNET_ELEMENT_DATA_V4 * RemoveElementInfo,
DHCP_FORCE_FLAG ForceFlag
);
DWORD DHCP_API_FUNCTION
DhcpCreateClientInfoV4(
DHCP_CONST WCHAR *ServerIpAddress,
DHCP_CONST DHCP_CLIENT_INFO_V4 *ClientInfo
);
DWORD DHCP_API_FUNCTION
DhcpSetClientInfoV4(
DHCP_CONST WCHAR *ServerIpAddress,
DHCP_CONST DHCP_CLIENT_INFO_V4 *ClientInfo
);
DWORD DHCP_API_FUNCTION
DhcpGetClientInfoV4(
DHCP_CONST WCHAR *ServerIpAddress,
DHCP_CONST DHCP_SEARCH_INFO *SearchInfo,
LPDHCP_CLIENT_INFO_V4 *ClientInfo
);
DWORD DHCP_API_FUNCTION
DhcpEnumSubnetClientsV4(
DHCP_CONST WCHAR *ServerIpAddress,
DHCP_IP_ADDRESS SubnetAddress,
DHCP_RESUME_HANDLE *ResumeHandle,
DWORD PreferredMaximum,
LPDHCP_CLIENT_INFO_ARRAY_V4 *ClientInfo,
DWORD *ClientsRead,
DWORD *ClientsTotal
);
DWORD DHCP_API_FUNCTION
DhcpServerSetConfigV4(
DHCP_CONST WCHAR *ServerIpAddress,
DWORD FieldsToSet,
LPDHCP_SERVER_CONFIG_INFO_V4 ConfigInfo
);
DWORD DHCP_API_FUNCTION
DhcpServerGetConfigV4(
DHCP_CONST WCHAR *ServerIpAddress,
LPDHCP_SERVER_CONFIG_INFO_V4 *ConfigInfo
);
DWORD
DhcpSetSuperScopeV4(
DHCP_CONST WCHAR *ServerIpAddress,
DHCP_CONST DHCP_IP_ADDRESS SubnetAddress,
DHCP_CONST LPWSTR SuperScopeName,
DHCP_CONST BOOL ChangeExisting
);
DWORD
DhcpDeleteSuperScopeV4(
DHCP_CONST WCHAR *ServerIpAddress,
DHCP_CONST LPWSTR SuperScopeName
);
DWORD
DhcpGetSuperScopeInfoV4(
DHCP_CONST WCHAR *ServerIpAddress,
LPDHCP_SUPER_SCOPE_TABLE *SuperScopeTable
);
#endif DHCPAPI_NO_PROTOTYPES
typedef struct _DHCP_CLIENT_INFO_V5 {
DHCP_IP_ADDRESS ClientIpAddress; // currently assigned IP address.
DHCP_IP_MASK SubnetMask;
DHCP_CLIENT_UID ClientHardwareAddress;
LPWSTR ClientName; // optional.
LPWSTR ClientComment;
DATE_TIME ClientLeaseExpires; // UTC time in FILE_TIME format.
DHCP_HOST_INFO OwnerHost; // host that distributed this IP address.
//
// new fields for NT4SP1
//
BYTE bClientType; // CLIENT_TYPE_DHCP | CLIENT_TYPE_BOOTP |
// CLIENT_TYPE_NONE
// new field for NT5.0
BYTE AddressState; // OFFERED, DOOMED ...etc as given below
} DHCP_CLIENT_INFO_V5, *LPDHCP_CLIENT_INFO_V5;
// the following are four valid states for the record. Note that only the last two
// bits must be used to find out the state... the higher bits are used as bit flags to
// indicate DNS stuff.
#define V5_ADDRESS_STATE_OFFERED 0x0
#define V5_ADDRESS_STATE_ACTIVE 0x1
#define V5_ADDRESS_STATE_DECLINED 0x2
#define V5_ADDRESS_STATE_DOOM 0x3
// DELETED => DNS DeRegistration pending
// UNREGISTERED => DNS Registration pending
// BOTH_REC => Both [Name->Ip] AND [Ip->Name] DNS registration would be done by server.
#define V5_ADDRESS_BIT_DELETED 0x80
#define V5_ADDRESS_BIT_UNREGISTERED 0x40
#define V5_ADDRESS_BIT_BOTH_REC 0x20
// Here are the flags that could be set/unset to affect DNS behaviour (option 81)
// If FLAG_ENABLED is not set, then this client is ignored for DNS updates or cleanups
// If update DOWNLEVEL is set, then DOWNLEVEL clients would have both A & Ptr records updated.
// If Cleanup expired is set, then the client's records would be cleaned up on delete.
// If UPDATE_BOTH_ALWAYS is set, all clients are treated like down level clients with both records updated.
//
// Some common cases:
// If you want updates to occur as requested by client, clear UPDATE_ALWAYS
// If you want updates to be only Ip->Name, clear FLAG_UPDATE_BOTH_ALWAYS
// If you want down level clients to be handled, set UPDATE_DOWNLEVEL
// If you want de-registrations on lease expiry, set CLEANUP_EXPIRED
// If you want any DNS activity at all, set ENABLED
#define DNS_FLAG_ENABLED 0x01
#define DNS_FLAG_UPDATE_DOWNLEVEL 0x02
#define DNS_FLAG_CLEANUP_EXPIRED 0x04
#define DNS_FLAG_UPDATE_BOTH_ALWAYS 0x10
typedef struct _DHCP_CLIENT_INFO_ARRAY_V5 {
DWORD NumElements;
#if defined(MIDL_PASS)
[size_is(NumElements)]
#endif // MIDL_PASS
LPDHCP_CLIENT_INFO_V5 *Clients; // array of pointers
} DHCP_CLIENT_INFO_ARRAY_V5, *LPDHCP_CLIENT_INFO_ARRAY_V5;
#ifndef DHCPAPI_NO_PROTOTYPES
// Newer NT50 Version of the function..
DWORD DHCP_API_FUNCTION
DhcpEnumSubnetClientsV5(
DHCP_CONST WCHAR *ServerIpAddress,
DHCP_IP_ADDRESS SubnetAddress,
DHCP_RESUME_HANDLE *ResumeHandle,
DWORD PreferredMaximum,
LPDHCP_CLIENT_INFO_ARRAY_V5 *ClientInfo,
DWORD *ClientsRead,
DWORD *ClientsTotal
);
//================================================================================
// here is the NT 5.0 Beta2 stuff -- ClassId and Vendor specific stuff
//================================================================================
DWORD // ERROR_DHCP_OPTION_EXITS if option is already there
DhcpCreateOptionV5( // create a new option (must not exist)
IN LPWSTR ServerIpAddress,
IN DWORD Flags,
IN DHCP_OPTION_ID OptionId, // must be between 0-255 or 256-511 (for vendor stuff)
IN LPWSTR ClassName,
IN LPWSTR VendorName,
IN LPDHCP_OPTION OptionInfo
) ;
DWORD // ERROR_DHCP_OPTION_NOT_PRESENT if option does not exist
DhcpSetOptionInfoV5( // Modify existing option's fields
IN LPWSTR ServerIpAddress,
IN DWORD Flags,
IN DHCP_OPTION_ID OptionID,
IN LPWSTR ClassName,
IN LPWSTR VendorName,
IN LPDHCP_OPTION OptionInfo
) ;
DWORD // ERROR_DHCP_OPTION_NOT_PRESENT
DhcpGetOptionInfoV5( // retrieve the information from off the mem structures
IN LPWSTR ServerIpAddress,
IN DWORD Flags,
IN DHCP_OPTION_ID OptionID,
IN LPWSTR ClassName,
IN LPWSTR VendorName,
OUT LPDHCP_OPTION *OptionInfo // allocate memory using MIDL functions
) ;
DWORD // ERROR_DHCP_OPTION_NOT_PRESENT if option does not exist
DhcpEnumOptionsV5( // enumerate the options defined
IN LPWSTR ServerIpAddress,
IN DWORD Flags,
IN LPWSTR ClassName,
IN LPWSTR VendorName,
IN OUT DHCP_RESUME_HANDLE *ResumeHandle, // must be zero intially and then never touched
IN DWORD PreferredMaximum, // max # of bytes of info to pass along
OUT LPDHCP_OPTION_ARRAY *Options, // fill this option array
OUT DWORD *OptionsRead, // fill in the # of options read
OUT DWORD *OptionsTotal // fill in the total # here
) ;
DWORD // ERROR_DHCP_OPTION_NOT_PRESENT if option not existent
DhcpRemoveOptionV5( // remove the option definition from the registry
IN LPWSTR ServerIpAddress,
IN DWORD Flags,
IN DHCP_OPTION_ID OptionID,
IN LPWSTR ClassName,
IN LPWSTR VendorName
) ;
DWORD // OPTION_NOT_PRESENT if option is not defined
DhcpSetOptionValueV5( // replace or add a new option value
IN LPWSTR ServerIpAddress,
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 // not atomic!!!!
DhcpSetOptionValuesV5( // set a bunch of options
IN LPWSTR ServerIpAddress,
IN DWORD Flags,
IN LPWSTR ClassName,
IN LPWSTR VendorName,
IN LPDHCP_OPTION_SCOPE_INFO ScopeInfo,
IN LPDHCP_OPTION_VALUE_ARRAY OptionValues
) ;
DWORD
DhcpGetOptionValueV5( // fetch the required option at required level
IN LPWSTR ServerIpAddress,
IN DWORD Flags,
IN DHCP_OPTION_ID OptionID,
IN LPWSTR ClassName,
IN LPWSTR VendorName,
IN LPDHCP_OPTION_SCOPE_INFO ScopeInfo,
OUT LPDHCP_OPTION_VALUE *OptionValue // allocate memory using MIDL_user_allocate
) ;
DWORD
DhcpEnumOptionValuesV5(
IN LPWSTR ServerIpAddress,
IN DWORD Flags,
IN LPWSTR ClassName,
IN LPWSTR VendorName,
IN LPDHCP_OPTION_SCOPE_INFO ScopeInfo,
IN DHCP_RESUME_HANDLE *ResumeHandle,
IN DWORD PreferredMaximum,
OUT LPDHCP_OPTION_VALUE_ARRAY *OptionValues,
OUT DWORD *OptionsRead,
OUT DWORD *OptionsTotal
) ;
DWORD
DhcpRemoveOptionValueV5(
IN LPWSTR ServerIpAddress,
IN DWORD Flags,
IN DHCP_OPTION_ID OptionID,
IN LPWSTR ClassName,
IN LPWSTR VendorName,
IN LPDHCP_OPTION_SCOPE_INFO ScopeInfo
) ;
DWORD
DhcpCreateClass(
IN LPWSTR ServerIpAddress,
IN DWORD ReservedMustBeZero,
IN LPDHCP_CLASS_INFO ClassInfo
) ;
DWORD
DhcpModifyClass(
IN LPWSTR ServerIpAddress,
IN DWORD ReservedMustBeZero,
IN LPDHCP_CLASS_INFO ClassInfo
) ;
DWORD
DhcpDeleteClass(
IN LPWSTR ServerIpAddress,
IN DWORD ReservedMustBeZero,
IN LPWSTR ClassName
) ;
DWORD
DhcpGetClassInfo(
IN LPWSTR ServerIpAddress,
IN DWORD ReservedMustBeZero,
IN LPDHCP_CLASS_INFO PartialClassInfo,
OUT LPDHCP_CLASS_INFO *FilledClassInfo
) ;
DWORD
DhcpEnumClasses(
IN LPWSTR ServerIpAddress,
IN DWORD ReservedMustBeZero,
IN OUT DHCP_RESUME_HANDLE *ResumeHandle,
IN DWORD PreferredMaximum,
OUT LPDHCP_CLASS_INFO_ARRAY *ClassInfoArray,
OUT DWORD *nRead,
OUT DWORD *nTotal
) ;
#endif DHCPAPI_NO_PROTOTYPES
#define DHCP_OPT_ENUM_IGNORE_VENDOR 0x01
#define DHCP_OPT_ENUM_USE_CLASSNAME 0x02
typedef struct _DHCP_ALL_OPTIONS {
DWORD Flags; // must be zero -- not used..
LPDHCP_OPTION_ARRAY NonVendorOptions;
DWORD NumVendorOptions;
#if defined(MIDL_PASS)
[size_is(NumVendorOptions)]
#endif
struct /* anonymous */ {
DHCP_OPTION Option;
LPWSTR VendorName;
LPWSTR ClassName; // currently unused.
} *VendorOptions;
} DHCP_ALL_OPTIONS, *LPDHCP_ALL_OPTIONS;
typedef struct _DHCP_ALL_OPTION_VALUES {
DWORD Flags; // must be zero -- not used
DWORD NumElements; // the # of elements in array of Options below..
#if defined(MIDL_PASS)
[size_is(NumElements)]
#endif MIDL_PASS
struct /* anonymous */ {
LPWSTR ClassName; // for each user class (NULL if none exists)
LPWSTR VendorName; // for each vendor class (NULL if none exists)
BOOL IsVendor; // is this set of options vendor specific?
LPDHCP_OPTION_VALUE_ARRAY OptionsArray; // list of options for the above pair: (vendor,user)
} *Options; // for each vendor/user class pair, one element in this array..
} DHCP_ALL_OPTION_VALUES, *LPDHCP_ALL_OPTION_VALUES;
#ifndef DHCPAPI_NO_PROTOTYPES
// NT 50 Beta2 extended options api
DWORD
DhcpGetAllOptions(
IN LPWSTR ServerIpAddress,
IN DWORD Flags,
OUT LPDHCP_ALL_OPTIONS *OptionStruct // fill the fields of this structure
) ;
DWORD
DhcpGetAllOptionValues(
IN LPWSTR ServerIpAddress,
IN DWORD Flags,
IN LPDHCP_OPTION_SCOPE_INFO ScopeInfo,
OUT LPDHCP_ALL_OPTION_VALUES *Values
) ;
#endif DHCPAPI_NO_PROTOTYPES
#ifndef _ST_SRVR_H_
#define _ST_SRVR_H_
typedef struct _DHCPDS_SERVER {
DWORD Version; // version of this structure -- currently zero
LPWSTR ServerName; // [DNS?] unique name for server
DWORD ServerAddress; // ip address of server
DWORD Flags; // additional info -- state
DWORD State; // not used ...
LPWSTR DsLocation; // ADsPath to server object
DWORD DsLocType; // path relative? absolute? diff srvr?
} DHCPDS_SERVER, *LPDHCPDS_SERVER, *PDHCPDS_SERVER;
typedef struct _DHCPDS_SERVERS {
DWORD Flags; // not used currently.
DWORD NumElements; // # of elements in array
LPDHCPDS_SERVER Servers; // array of server info
} DHCPDS_SERVERS, *LPDHCPDS_SERVERS, *PDHCPDS_SERVERS;
typedef DHCPDS_SERVER DHCP_SERVER_INFO;
typedef PDHCPDS_SERVER PDHCP_SERVER_INFO;
typedef LPDHCPDS_SERVER LPDHCP_SERVER_INFO;
typedef DHCPDS_SERVERS DHCP_SERVER_INFO_ARRAY;
typedef PDHCPDS_SERVERS PDHCP_SERVER_INFO_ARRAY;
typedef LPDHCPDS_SERVERS LPDHCP_SERVER_INFO_ARRAY;
#endif _ST_SRVR_H_
//DOC DhcpDsInit must be called exactly once per process.. this initializes the
//DOC memory and other structures for this process. This initializes some DS
//DOC object handles (memory), and hence is slow as this has to read from DS.
DWORD
DhcpDsInit(
VOID
);
//DOC DhcpDsCleanup undoes the effect of any DhcpDsInit. This function should be
//DOC called exactly once for each process, and only at termination. Note that
//DOC it is safe to call this function even if DhcpDsInit does not succeed.
VOID
DhcpDsCleanup(
VOID
);
#define DHCP_FLAGS_DONT_ACCESS_DS 0x01
#define DHCP_FLAGS_DONT_DO_RPC 0x02
#define DHCP_FLAGS_OPTION_IS_VENDOR 0x03
//DOC DhcpSetThreadOptions currently allows only one option to be set. This is the
//DOC flag DHCP_FLAGS_DONT_ACCESS_DS. This affects only the current executing thread.
//DOC When this function is executed, all calls made further DONT access the registry,
//DOC excepting the DhcpEnumServers, DhcpAddServer and DhcpDeleteServer calls.
DWORD
DhcpSetThreadOptions( // set options for current thread
IN DWORD Flags, // options, currently 0 or DHCP_FLAGS_DONT_ACCESS_DS
IN LPVOID Reserved // must be NULL, reserved for future
);
//DOC DhcpGetThreadOptions retrieves the current thread options as set by DhcpSetThreadOptions.
//DOC If none were set, the return value is zero.
DWORD
DhcpGetThreadOptions( // get current thread options
OUT LPDWORD pFlags, // this DWORD is filled with current optiosn..
IN OUT LPVOID Reserved // must be NULL, reserved for future
);
#ifndef DHCPAPI_NO_PROTOTYPES
//DOC DhcpEnumServers enumerates the list of servers found in the DS. If the DS
//DOC is not accessible, it returns an error. The only currently used parameter
//DOC is the out parameter Servers. This is a SLOW call.
DWORD
DhcpEnumServers(
IN DWORD Flags, // must be zero
IN LPVOID IdInfo, // must be NULL
OUT LPDHCP_SERVER_INFO_ARRAY *Servers, // output servers list
IN LPVOID CallbackFn, // must be NULL
IN LPVOID CallbackData // must be NULL
);
//DOC DhcpAddServer tries to add a new server to the existing list of servers in
//DOC the DS. The function returns error if the Server already exists in the DS.
//DOC The function tries to upload the server configuration to the DS..
//DOC This is a SLOW call. Currently, the DsLocation and DsLocType are not valid
//DOC fields in the NewServer and they'd be ignored. Version must be zero.
DWORD
DhcpAddServer(
IN DWORD Flags, // must be zero
IN LPVOID IdInfo, // must be NULL
IN LPDHCP_SERVER_INFO NewServer, // input server information
IN LPVOID CallbackFn, // must be NULL
IN LPVOID CallbackData // must be NULL
);
//DOC DhcpDeleteServer tries to delete the server from DS. It is an error if the
//DOC server does not already exist. This also deletes any objects related to
//DOC this server in the DS (like subnet, reservations etc.).
DWORD
DhcpDeleteServer(
IN DWORD Flags, // must be zero
IN LPVOID IdInfo, // must be NULL
IN LPDHCP_SERVER_INFO NewServer, // input server information
IN LPVOID CallbackFn, // must be NULL
IN LPVOID CallbackData // must be NULL
);
#endif // DHCPAPI_NO_PROTOTYPES
#define DHCP_ATTRIB_BOOL_IS_ROGUE 0x01
#define DHCP_ATTRIB_BOOL_IS_DYNBOOTP 0x02
#define DHCP_ATTRIB_BOOL_IS_PART_OF_DSDC 0x03
#define DHCP_ATTRIB_BOOL_IS_BINDING_AWARE 0x04
#define DHCP_ATTRIB_BOOL_IS_ADMIN 0x05
#define DHCP_ATTRIB_ULONG_RESTORE_STATUS 0x06
#define DHCP_ATTRIB_TYPE_BOOL 0x01
#define DHCP_ATTRIB_TYPE_ULONG 0x02
typedef ULONG DHCP_ATTRIB_ID, *PDHCP_ATTRIB_ID, *LPDHCP_ATTRIB_ID;
typedef struct _DHCP_ATTRIB {
DHCP_ATTRIB_ID DhcpAttribId; // one of the DHCP_ATTRIB_*
ULONG DhcpAttribType;// type of attrib
#if defined(MIDL_PASS)
[switch_is(DhcpAttribType), switch_type(ULONG)]
union {
[case(DHCP_ATTRIB_TYPE_BOOL)] BOOL DhcpAttribBool;
[case(DHCP_ATTRIB_TYPE_ULONG)] ULONG DhcpAttribUlong;
};
#else MIDL_PASS
union { // predefined values..
BOOL DhcpAttribBool;
ULONG DhcpAttribUlong;
};
#endif MIDL_PASS
} DHCP_ATTRIB, *PDHCP_ATTRIB, *LPDHCP_ATTRIB;
typedef struct _DHCP_ATTRIB_ARRAY {
ULONG NumElements;
#if defined(MIDL_PASS)
[size_is(NumElements)]
#endif MIDL_PASS
LPDHCP_ATTRIB DhcpAttribs;
} DHCP_ATTRIB_ARRAY, *PDHCP_ATTRIB_ARRAY, *LPDHCP_ATTRIB_ARRAY;
DWORD // Status code
DhcpServerQueryAttribute( // get a server status
IN LPWSTR ServerIpAddr, // String form of server IP
IN ULONG dwReserved, // reserved for future
IN DHCP_ATTRIB_ID DhcpAttribId, // the attrib being queried
OUT LPDHCP_ATTRIB *pDhcpAttrib // fill in this field
);
DWORD // Status code
DhcpServerQueryAttributes( // query multiple attributes
IN LPWSTR ServerIpAddr, // String form of server IP
IN ULONG dwReserved, // reserved for future
IN ULONG dwAttribCount, // # of attribs being queried
IN DHCP_ATTRIB_ID pDhcpAttribs[],// array of attribs
OUT LPDHCP_ATTRIB_ARRAY *pDhcpAttribArr // Ptr is filled w/ array
);
DWORD // Status code
DhcpServerRedoAuthorization( // retry the rogue server stuff
IN LPWSTR ServerIpAddr, // String form of server IP
IN ULONG dwReserved // reserved for future
);
DWORD
DhcpAuditLogSetParams( // set some auditlogging params
IN LPWSTR ServerIpAddress,
IN DWORD Flags, // currently must be zero
IN LPWSTR AuditLogDir, // directory to log files in..
IN DWORD DiskCheckInterval, // how often to check disk space?
IN DWORD MaxLogFilesSize, // how big can all logs files be..
IN DWORD MinSpaceOnDisk // mininum amt of free disk space
);
DWORD
DhcpAuditLogGetParams( // get the auditlogging params
IN LPWSTR ServerIpAddress,
IN DWORD Flags, // must be zero
OUT LPWSTR *AuditLogDir, // same meaning as in AuditLogSetParams
OUT DWORD *DiskCheckInterval, // ditto
OUT DWORD *MaxLogFilesSize, // ditto
OUT DWORD *MinSpaceOnDisk // ditto
);
typedef struct _DHCP_BOOTP_IP_RANGE {
DHCP_IP_ADDRESS StartAddress;
DHCP_IP_ADDRESS EndAddress;
ULONG BootpAllocated;
ULONG MaxBootpAllowed;
} DHCP_BOOTP_IP_RANGE, *LPDHCP_BOOT_IP_RANGE;
typedef struct _DHCP_SUBNET_ELEMENT_DATA_V5 {
DHCP_SUBNET_ELEMENT_TYPE ElementType;
#if defined(MIDL_PASS)
[switch_is(ELEMENT_MASK(ElementType)), switch_type(DHCP_SUBNET_ELEMENT_TYPE)]
union _DHCP_SUBNET_ELEMENT_UNION_V5 {
[case(DhcpIpRanges)] DHCP_BOOTP_IP_RANGE *IpRange;
[case(DhcpSecondaryHosts)] DHCP_HOST_INFO *SecondaryHost;
[case(DhcpReservedIps)] DHCP_IP_RESERVATION_V4 *ReservedIp;
[case(DhcpExcludedIpRanges)] DHCP_IP_RANGE *ExcludeIpRange;
[case(DhcpIpUsedClusters)] DHCP_IP_CLUSTER *IpUsedCluster;
[default] ;
} Element;
#else
union _DHCP_SUBNET_ELEMENT_UNION_V5 {
DHCP_BOOTP_IP_RANGE *IpRange;
DHCP_HOST_INFO *SecondaryHost;
DHCP_IP_RESERVATION_V4 *ReservedIp;
DHCP_IP_RANGE *ExcludeIpRange;
DHCP_IP_CLUSTER *IpUsedCluster;
} Element;
#endif // MIDL_PASS
} DHCP_SUBNET_ELEMENT_DATA_V5, *LPDHCP_SUBNET_ELEMENT_DATA_V5;
typedef struct _DHCP_SUBNET_ELEMENT_INFO_ARRAY_V5 {
DWORD NumElements;
#if defined(MIDL_PASS)
[size_is(NumElements)]
#endif // MIDL_PASS
LPDHCP_SUBNET_ELEMENT_DATA_V5 Elements; //array
} DHCP_SUBNET_ELEMENT_INFO_ARRAY_V5, *LPDHCP_SUBNET_ELEMENT_INFO_ARRAY_V5;
#ifndef DHCPAPI_NO_PROTOTYPES
DWORD DHCP_API_FUNCTION
DhcpAddSubnetElementV5(
DHCP_CONST WCHAR *ServerIpAddress,
DHCP_IP_ADDRESS SubnetAddress,
DHCP_CONST DHCP_SUBNET_ELEMENT_DATA_V5 * AddElementInfo
);
DWORD DHCP_API_FUNCTION
DhcpEnumSubnetElementsV5(
DHCP_CONST WCHAR *ServerIpAddress,
DHCP_IP_ADDRESS SubnetAddress,
DHCP_SUBNET_ELEMENT_TYPE EnumElementType,
DHCP_RESUME_HANDLE *ResumeHandle,
DWORD PreferredMaximum,
LPDHCP_SUBNET_ELEMENT_INFO_ARRAY_V5 *EnumElementInfo,
DWORD *ElementsRead,
DWORD *ElementsTotal
);
DWORD DHCP_API_FUNCTION
DhcpRemoveSubnetElementV5(
DHCP_CONST WCHAR *ServerIpAddress,
DHCP_IP_ADDRESS SubnetAddress,
DHCP_CONST DHCP_SUBNET_ELEMENT_DATA_V5 * RemoveElementInfo,
DHCP_FORCE_FLAG ForceFlag
);
#endif // DHCPAPI_NO_PROTOTYPES
#define DHCPCTR_SHARED_MEM_NAME L"DHCPCTRS_SHMEM"
#pragma pack(4)
typedef struct _DHCP_PERF_STATS { // performance statistics
//
// DO NOT CHANGE THIS ORDER -- THIS AFFECTS THE PERF COUNTER DEFINITION
// ORDER IN DHCPDATA.C (under PERF directory)
//
ULONG dwNumPacketsReceived;
ULONG dwNumPacketsDuplicate;
ULONG dwNumPacketsExpired;
ULONG dwNumMilliSecondsProcessed;
ULONG dwNumPacketsInActiveQueue;
ULONG dwNumPacketsInPingQueue;
ULONG dwNumDiscoversReceived;
ULONG dwNumOffersSent;
ULONG dwNumRequestsReceived;
ULONG dwNumInformsReceived;
ULONG dwNumAcksSent;
ULONG dwNumNacksSent;
ULONG dwNumDeclinesReceived;
ULONG dwNumReleasesReceived;
//
// This is not a counter value.. but there just to aid calculation of packet
// processing time/ # of packets processed.
//
ULONG dwNumPacketsProcessed;
} DHCP_PERF_STATS, *LPDHCP_PERF_STATS;
#pragma pack()
typedef VOID (WINAPI *DHCP_CLEAR_DS_ROUTINE) (VOID);
VOID
WINAPI
DhcpDsClearHostServerEntries(
VOID
);
typedef VOID (WINAPI *DHCP_MARKUPG_ROUTINE) (VOID);
VOID
WINAPI
DhcpMarkUpgrade(
VOID
);
#define DHCP_ENDPOINT_FLAG_CANT_MODIFY 0x01
typedef struct _DHCP_BIND_ELEMENT {
ULONG Flags;
BOOL fBoundToDHCPServer;
DHCP_IP_ADDRESS AdapterPrimaryAddress;
DHCP_IP_ADDRESS AdapterSubnetAddress;
LPWSTR IfDescription;
ULONG IfIdSize;
#if defined (MIDL_PASS)
[size_is(IfIdSize)]
#endif // MIDL_PASS
LPBYTE IfId;
} DHCP_BIND_ELEMENT, *LPDHCP_BIND_ELEMENT;
typedef struct _DHCP_BIND_ELEMENT_ARRAY {
DWORD NumElements;
#if defined (MIDL_PASS)
[size_is(NumElements)]
#endif // MIDL_PASS
LPDHCP_BIND_ELEMENT Elements; //array
} DHCP_BIND_ELEMENT_ARRAY, *LPDHCP_BIND_ELEMENT_ARRAY;
#ifndef DHCPAPI_NO_PROTOTYPES
DWORD DHCP_API_FUNCTION
DhcpGetServerBindingInfo(
DHCP_CONST WCHAR *ServerIpAddress,
ULONG Flags,
LPDHCP_BIND_ELEMENT_ARRAY *BindElementsInfo
);
DWORD DHCP_API_FUNCTION
DhcpSetServerBindingInfo(
DHCP_CONST WCHAR *ServerIpAddress,
ULONG Flags,
LPDHCP_BIND_ELEMENT_ARRAY BindElementInfo
);
#endif // DHCPAPI_NO_PROTOTYPES
DWORD
DhcpServerQueryDnsRegCredentials(
IN LPWSTR ServerIpAddress,
IN ULONG UnameSize, //in BYTES
OUT LPWSTR Uname,
IN ULONG DomainSize, // in BYTES
OUT LPWSTR Domain
);
DWORD
DhcpServerSetDnsRegCredentials(
IN LPWSTR ServerIpAddress,
IN LPWSTR Uname,
IN LPWSTR Domain,
IN LPWSTR Passwd
);
DWORD
DhcpServerBackupDatabase(
IN LPWSTR ServerIpAddress,
IN LPWSTR Path
);
DWORD
DhcpServerRestoreDatabase(
IN LPWSTR ServerIpAddress,
IN LPWSTR Path
);
#endif // _DHCPAPI_
Reference in a new issue Copy permalink