778 lines
18 KiB
C
778 lines
18 KiB
C
/*++
|
|
|
|
Copyright (c) 1994 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
dhcp.c
|
|
|
|
Abstract:
|
|
|
|
This file contains utility functions.
|
|
|
|
Author:
|
|
|
|
Madan Appiah (madana) 7-Dec-1993.
|
|
|
|
Environment:
|
|
|
|
User Mode - Win32
|
|
|
|
Revision History:
|
|
|
|
--*/
|
|
|
|
#include "precomp.h"
|
|
#include "dhcpglobal.h"
|
|
#include <dhcploc.h>
|
|
#include <dhcppro.h>
|
|
|
|
#define MESSAGE_BOX_WIDTH_IN_CHARS 65
|
|
|
|
typedef struct _POPUP_THREAD_PARAM {
|
|
LPWSTR Title;
|
|
LPWSTR Message;
|
|
ULONG Flags;
|
|
} POPUP_THREAD_PARAM, *LPPOPUP_THREAD_PARAM;
|
|
|
|
POPUP_THREAD_PARAM PopupThreadParam = { NULL, NULL, 0 };
|
|
|
|
|
|
DWORD
|
|
DoPopup(
|
|
PVOID Buffer
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This function pops up a message to the user. It must run it's own
|
|
thread. When the user acknowledge the popup, the thread
|
|
deallocates the message buffer and returns.
|
|
|
|
Arguments:
|
|
|
|
Buffer - A pointer to a NULL terminated message buffer.
|
|
|
|
Return Values:
|
|
|
|
Always returns 0
|
|
|
|
--*/
|
|
{
|
|
DWORD Result;
|
|
LPPOPUP_THREAD_PARAM Params = Buffer;
|
|
|
|
Result = MessageBox(
|
|
NULL, // no owner
|
|
Params->Message,
|
|
Params->Title,
|
|
( MB_OK | Params->Flags |
|
|
MB_SERVICE_NOTIFICATION |
|
|
MB_SYSTEMMODAL |
|
|
MB_SETFOREGROUND |
|
|
MB_DEFAULT_DESKTOP_ONLY
|
|
)
|
|
);
|
|
|
|
|
|
LOCK_POPUP();
|
|
|
|
if( Params->Message != NULL ) {
|
|
LocalFree( Params->Message );
|
|
Params->Message = NULL;
|
|
}
|
|
|
|
if( Params->Title != NULL ) {
|
|
LocalFree( Params->Title );
|
|
Params->Title = NULL;
|
|
}
|
|
|
|
//
|
|
// close the global handle, so that we will not consume this
|
|
// thread resource until another popup.
|
|
//
|
|
|
|
CloseHandle( DhcpGlobalMsgPopupThreadHandle );
|
|
DhcpGlobalMsgPopupThreadHandle = NULL;
|
|
|
|
UNLOCK_POPUP();
|
|
|
|
//
|
|
// Always return 0
|
|
//
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
DWORD
|
|
DisplayUserMessage(
|
|
IN PDHCP_CONTEXT DhcpContext,
|
|
IN DWORD MessageId,
|
|
IN DHCP_IP_ADDRESS IpAddress
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This function starts a new thread to display a message box.
|
|
|
|
N.B. If a thread already exists which is waiting for user input
|
|
on a message box, then this routine does not create another
|
|
thread.
|
|
|
|
Arguments:
|
|
|
|
DhcpContext -- the context to display messages for
|
|
|
|
MessageId - The ID of the message to display.
|
|
(The actual message string is obtained from the dhcp module).
|
|
|
|
IpAddress - Ip address involved.
|
|
|
|
--*/
|
|
{
|
|
DWORD ThreadID, TitleLength, MsgLength, Flags;
|
|
LPWSTR Title = NULL, Message = NULL;
|
|
|
|
switch(MessageId) {
|
|
|
|
case MESSAGE_FAILED_TO_OBTAIN_LEASE:
|
|
Flags = MB_ICONSTOP;
|
|
break;
|
|
|
|
case MESSAGE_SUCCESSFUL_LEASE :
|
|
Flags = MB_ICONINFORMATION;
|
|
break;
|
|
|
|
default:
|
|
DhcpAssert(FALSE);
|
|
Flags = MB_ICONSTOP;
|
|
break;
|
|
}
|
|
|
|
LOCK_POPUP();
|
|
|
|
//
|
|
// if we are asked to display no message popup, simply return.
|
|
//
|
|
|
|
if ( DhcpGlobalDisplayPopup == FALSE ) {
|
|
goto Cleanup;
|
|
}
|
|
|
|
//
|
|
// if the message popup thread handle is non-null, check to see
|
|
// the thread is still running, if so don't display another popup,
|
|
// otherwise close the last popup handle and create another popup
|
|
// thread for new message.
|
|
//
|
|
|
|
if( DhcpGlobalMsgPopupThreadHandle != NULL ) {
|
|
DWORD WaitStatus;
|
|
|
|
//
|
|
// Time out immediately if the thread is still running.
|
|
//
|
|
|
|
WaitStatus = WaitForSingleObject(
|
|
DhcpGlobalMsgPopupThreadHandle,
|
|
0 );
|
|
|
|
if ( WaitStatus == WAIT_TIMEOUT ) {
|
|
goto Cleanup;
|
|
|
|
} else if ( WaitStatus == 0 ) {
|
|
|
|
//
|
|
// This shouldn't be a case, because we close this handle at
|
|
// the end of popup thread.
|
|
//
|
|
|
|
DhcpAssert( WaitStatus == 0 );
|
|
|
|
CloseHandle( DhcpGlobalMsgPopupThreadHandle );
|
|
DhcpGlobalMsgPopupThreadHandle = NULL;
|
|
|
|
} else {
|
|
DhcpPrint((
|
|
DEBUG_ERRORS,
|
|
"Cannot WaitFor message popup thread: %ld\n",
|
|
WaitStatus ));
|
|
goto Cleanup;
|
|
}
|
|
}
|
|
|
|
|
|
MsgLength = FormatMessage(
|
|
FORMAT_MESSAGE_FROM_HMODULE
|
|
| FORMAT_MESSAGE_ARGUMENT_ARRAY
|
|
| FORMAT_MESSAGE_ALLOCATE_BUFFER
|
|
| MESSAGE_BOX_WIDTH_IN_CHARS,
|
|
(LPVOID)DhcpGlobalMessageFileHandle,
|
|
MessageId,
|
|
0, // language id.
|
|
(LPWSTR)&Message, // return buffer place holder.
|
|
0, // minimum buffer size to allocate.
|
|
NULL // No Params
|
|
);
|
|
|
|
if ( MsgLength == 0) {
|
|
DhcpPrint(( DEBUG_ERRORS,
|
|
"FormatMessage failed, err = %ld.\n", GetLastError()));
|
|
goto Cleanup;
|
|
}
|
|
|
|
DhcpAssert( Message != NULL );
|
|
DhcpAssert( (wcslen(Message)) == MsgLength );
|
|
|
|
//
|
|
// get message box title.
|
|
//
|
|
|
|
TitleLength = FormatMessage(
|
|
FORMAT_MESSAGE_FROM_HMODULE |
|
|
FORMAT_MESSAGE_ALLOCATE_BUFFER,
|
|
(LPVOID)DhcpGlobalMessageFileHandle,
|
|
MESSAGE_POPUP_TITLE,
|
|
0, // language id.
|
|
(LPWSTR)&Title, // return buffer place holder.
|
|
0, // minimum buffer size to allocate.
|
|
NULL // insert strings.
|
|
);
|
|
|
|
if ( TitleLength == 0) {
|
|
DhcpPrint(( DEBUG_ERRORS,
|
|
"FormatMessage to Message box Title failed, err = %ld.\n",
|
|
GetLastError()));
|
|
goto Cleanup;
|
|
}
|
|
|
|
DhcpAssert( Title != NULL );
|
|
DhcpAssert( (wcslen(Title)) == TitleLength );
|
|
|
|
PopupThreadParam.Title = Title;
|
|
PopupThreadParam.Message = Message;
|
|
PopupThreadParam.Flags = Flags;
|
|
|
|
|
|
//
|
|
// Create a thread, to display a message box to the user. We need
|
|
// a new thread because MessageBox() blocks until the user clicks
|
|
// on the OK button, and we can't block this thread.
|
|
//
|
|
// DoPopup frees the buffer.
|
|
//
|
|
|
|
DhcpGlobalMsgPopupThreadHandle = CreateThread(
|
|
NULL, // no security.
|
|
0, // default stack size.
|
|
DoPopup, // entry point.
|
|
(PVOID)&PopupThreadParam,
|
|
0,
|
|
&ThreadID
|
|
);
|
|
|
|
if ( DhcpGlobalMsgPopupThreadHandle == NULL ) {
|
|
DhcpPrint((
|
|
DEBUG_ERRORS,
|
|
"DisplayUserMessage: Could not create thread, err = %ld.\n",
|
|
GetLastError() ));
|
|
}
|
|
|
|
Cleanup:
|
|
|
|
UNLOCK_POPUP();
|
|
|
|
return 0;
|
|
}
|
|
|
|
VOID
|
|
DhcpLogEvent(
|
|
IN PDHCP_CONTEXT DhcpContext, OPTIONAL
|
|
IN DWORD EventNumber,
|
|
IN DWORD ErrorCode OPTIONAL
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This functions formats and writes an event log entry.
|
|
|
|
Arguments:
|
|
|
|
DhcpContext - The context for the event. Optional parameter.
|
|
|
|
EventNumber - The event to log.
|
|
|
|
ErrorCode - Windows Error code to record. Optional parameter.
|
|
|
|
--*/
|
|
{
|
|
LPWSTR HWAddressBuffer = NULL;
|
|
LPWSTR IPAddressBuffer = NULL;
|
|
LPWSTR IPAddressBuffer2 = NULL;
|
|
CHAR ErrorCodeOemStringBuf[32 + 1];
|
|
WCHAR ErrorCodeStringBuf[32 + 1];
|
|
LPWSTR ErrorCodeString = NULL;
|
|
LPWSTR Strings[10];
|
|
DHCP_IP_ADDRESS IpAddr;
|
|
|
|
if( DhcpContext != NULL ) {
|
|
|
|
if( EVENT_NACK_LEASE == EventNumber ) {
|
|
IpAddr = DhcpContext->NackedIpAddress;
|
|
} if( EVENT_ADDRESS_CONFLICT == EventNumber ) {
|
|
IpAddr = DhcpContext->ConflictAddress;
|
|
} else {
|
|
IpAddr = DhcpContext->IpAddress;
|
|
}
|
|
|
|
HWAddressBuffer = DhcpAllocateMemory(
|
|
(DhcpContext->HardwareAddressLength * 2 + 1) *
|
|
sizeof(WCHAR)
|
|
);
|
|
|
|
if( HWAddressBuffer == NULL ) {
|
|
DhcpPrint(( DEBUG_MISC, "Out of memory." ));
|
|
goto Cleanup;
|
|
}
|
|
|
|
DhcpHexToString(
|
|
HWAddressBuffer,
|
|
DhcpContext->HardwareAddress,
|
|
DhcpContext->HardwareAddressLength
|
|
);
|
|
|
|
HWAddressBuffer[DhcpContext->HardwareAddressLength * 2] = '\0';
|
|
|
|
IPAddressBuffer = DhcpOemToUnicode(
|
|
inet_ntoa( *(struct in_addr *)&IpAddr ),
|
|
NULL
|
|
);
|
|
|
|
if( IPAddressBuffer == NULL ) {
|
|
DhcpPrint(( DEBUG_MISC, "Out of memory." ));
|
|
goto Cleanup;
|
|
}
|
|
|
|
if( EVENT_NACK_LEASE == EventNumber ) {
|
|
IPAddressBuffer2 = DhcpOemToUnicode(
|
|
inet_ntoa( *(struct in_addr *)&DhcpContext->DhcpServerAddress ),
|
|
NULL
|
|
);
|
|
|
|
if( NULL == IPAddressBuffer2 ) goto Cleanup;
|
|
}
|
|
}
|
|
|
|
strcpy( ErrorCodeOemStringBuf, "%%" );
|
|
_ultoa( ErrorCode, ErrorCodeOemStringBuf + 2, 10 );
|
|
|
|
ErrorCodeString = DhcpOemToUnicode(
|
|
ErrorCodeOemStringBuf,
|
|
ErrorCodeStringBuf );
|
|
|
|
//
|
|
// Log an event
|
|
//
|
|
|
|
switch ( EventNumber ) {
|
|
|
|
case EVENT_LEASE_TERMINATED:
|
|
|
|
DhcpAssert( HWAddressBuffer != NULL );
|
|
DhcpAssert( IPAddressBuffer != NULL );
|
|
|
|
Strings[0] = HWAddressBuffer;
|
|
Strings[1] = IPAddressBuffer;
|
|
|
|
DhcpReportEventW(
|
|
DHCP_EVENT_CLIENT,
|
|
EVENT_LEASE_TERMINATED,
|
|
EVENTLOG_ERROR_TYPE,
|
|
2,
|
|
0,
|
|
Strings,
|
|
NULL );
|
|
|
|
break;
|
|
|
|
case EVENT_FAILED_TO_OBTAIN_LEASE:
|
|
|
|
DhcpAssert( HWAddressBuffer != NULL );
|
|
DhcpAssert( ErrorCodeString != NULL );
|
|
|
|
Strings[0] = HWAddressBuffer;
|
|
Strings[1] = ErrorCodeString;
|
|
|
|
DhcpReportEventW(
|
|
DHCP_EVENT_CLIENT,
|
|
EVENT_FAILED_TO_OBTAIN_LEASE,
|
|
EVENTLOG_ERROR_TYPE,
|
|
2,
|
|
sizeof(ErrorCode),
|
|
Strings,
|
|
&ErrorCode );
|
|
|
|
break;
|
|
|
|
case EVENT_NACK_LEASE:
|
|
|
|
DhcpAssert( HWAddressBuffer != NULL );
|
|
DhcpAssert( IPAddressBuffer != NULL );
|
|
DhcpAssert( IPAddressBuffer2 != NULL );
|
|
|
|
Strings[0] = IPAddressBuffer;
|
|
Strings[1] = HWAddressBuffer;
|
|
Strings[2] = IPAddressBuffer2;
|
|
|
|
DhcpReportEventW(
|
|
DHCP_EVENT_CLIENT,
|
|
EVENT_NACK_LEASE,
|
|
EVENTLOG_ERROR_TYPE,
|
|
3,
|
|
0,
|
|
Strings,
|
|
NULL );
|
|
|
|
break;
|
|
|
|
case EVENT_ADDRESS_CONFLICT:
|
|
DhcpAssert( IPAddressBuffer != NULL );
|
|
DhcpAssert( HWAddressBuffer != NULL );
|
|
|
|
Strings[0] = IPAddressBuffer;
|
|
Strings[1] = HWAddressBuffer;
|
|
|
|
DhcpReportEventW(
|
|
DHCP_EVENT_CLIENT,
|
|
EVENT_ADDRESS_CONFLICT,
|
|
EVENTLOG_WARNING_TYPE,
|
|
2,
|
|
0,
|
|
Strings,
|
|
NULL );
|
|
break;
|
|
|
|
case EVENT_IPAUTOCONFIGURATION_FAILED:
|
|
DhcpAssert( HWAddressBuffer != NULL );
|
|
DhcpAssert( ErrorCodeString != NULL );
|
|
|
|
Strings[0] = HWAddressBuffer;
|
|
Strings[1] = ErrorCodeString;
|
|
|
|
DhcpReportEventW(
|
|
DHCP_EVENT_CLIENT,
|
|
EVENT_IPAUTOCONFIGURATION_FAILED,
|
|
EVENTLOG_WARNING_TYPE,
|
|
2,
|
|
sizeof(ErrorCode),
|
|
Strings,
|
|
&ErrorCode );
|
|
|
|
break;
|
|
|
|
case EVENT_FAILED_TO_RENEW:
|
|
|
|
// The 'timeout' event should be logged only if there is no PPP
|
|
// adapter up. It is so because having a PPP adapter means the
|
|
// routes are hijacked, hence renewals up to T2 are expected to
|
|
// fail.
|
|
if (ErrorCode != ERROR_SEM_TIMEOUT ||
|
|
DhcpGlobalNdisWanAdaptersCount == 0 ||
|
|
time(NULL) >= DhcpContext->T2Time)
|
|
{
|
|
DhcpAssert( HWAddressBuffer != NULL );
|
|
DhcpAssert( ErrorCodeString != NULL );
|
|
|
|
Strings[0] = HWAddressBuffer;
|
|
Strings[1] = ErrorCodeString;
|
|
|
|
DhcpReportEventW(
|
|
DHCP_EVENT_CLIENT,
|
|
EVENT_FAILED_TO_RENEW,
|
|
EVENTLOG_WARNING_TYPE,
|
|
2,
|
|
sizeof(ErrorCode),
|
|
Strings,
|
|
&ErrorCode );
|
|
}
|
|
|
|
break;
|
|
|
|
case EVENT_DHCP_SHUTDOWN:
|
|
|
|
DhcpAssert( ErrorCodeString != NULL );
|
|
|
|
Strings[0] = ErrorCodeString;
|
|
|
|
DhcpReportEventW(
|
|
DHCP_EVENT_CLIENT,
|
|
EVENT_DHCP_SHUTDOWN,
|
|
EVENTLOG_WARNING_TYPE,
|
|
1,
|
|
sizeof(ErrorCode),
|
|
Strings,
|
|
&ErrorCode );
|
|
|
|
break;
|
|
|
|
case EVENT_IPAUTOCONFIGURATION_SUCCEEDED :
|
|
|
|
Strings[0] = HWAddressBuffer;
|
|
Strings[1] = IPAddressBuffer;
|
|
|
|
DhcpReportEventW(
|
|
DHCP_EVENT_CLIENT,
|
|
EVENT_IPAUTOCONFIGURATION_SUCCEEDED,
|
|
EVENTLOG_WARNING_TYPE,
|
|
2,
|
|
sizeof(ErrorCode),
|
|
Strings,
|
|
&ErrorCode
|
|
);
|
|
break;
|
|
|
|
case EVENT_COULD_NOT_INITIALISE_INTERFACE :
|
|
|
|
DhcpAssert( NULL != ErrorCodeString);
|
|
Strings[0] = ErrorCodeString;
|
|
DhcpReportEventW(
|
|
DHCP_EVENT_CLIENT,
|
|
EVENT_COULD_NOT_INITIALISE_INTERFACE,
|
|
EVENTLOG_ERROR_TYPE,
|
|
1,
|
|
sizeof(ErrorCode),
|
|
Strings,
|
|
&ErrorCode
|
|
);
|
|
|
|
break;
|
|
|
|
case EVENT_NET_ERROR:
|
|
DhcpAssert( NULL != ErrorCodeString);
|
|
Strings[0] = ErrorCodeString;
|
|
DhcpReportEventW(
|
|
DHCP_EVENT_CLIENT,
|
|
EVENT_NET_ERROR,
|
|
EVENTLOG_WARNING_TYPE,
|
|
1,
|
|
sizeof(ErrorCode),
|
|
Strings,
|
|
&ErrorCode
|
|
);
|
|
break;
|
|
|
|
default:
|
|
|
|
DhcpPrint(( DEBUG_MISC, "Unknown event." ));
|
|
break;
|
|
}
|
|
|
|
Cleanup:
|
|
|
|
if( HWAddressBuffer != NULL ) {
|
|
DhcpFreeMemory( HWAddressBuffer );
|
|
}
|
|
|
|
if( IPAddressBuffer != NULL ) {
|
|
DhcpFreeMemory( IPAddressBuffer );
|
|
}
|
|
|
|
if( IPAddressBuffer2 != NULL ) {
|
|
DhcpFreeMemory( IPAddressBuffer2 );
|
|
}
|
|
|
|
}
|
|
|
|
#if DBG
|
|
|
|
VOID
|
|
DhcpPrintRoutine(
|
|
IN DWORD DebugFlag,
|
|
IN LPSTR Format,
|
|
...
|
|
)
|
|
|
|
{
|
|
|
|
#define MAX_PRINTF_LEN 1024 // Arbitrary.
|
|
|
|
va_list arglist;
|
|
char OutputBuffer[MAX_PRINTF_LEN];
|
|
ULONG length;
|
|
static BeginningOfLine = TRUE;
|
|
LPSTR Text;
|
|
|
|
//
|
|
// If we aren't debugging this functionality, just return.
|
|
//
|
|
|
|
if ( DebugFlag != 0 && (DhcpGlobalDebugFlag & DebugFlag) == 0 ) {
|
|
return;
|
|
}
|
|
|
|
//
|
|
// vsprintf isn't multithreaded + we don't want to intermingle output
|
|
// from different threads.
|
|
//
|
|
|
|
// EnterCriticalSection( &DhcpGlobalDebugFileCritSect );
|
|
|
|
length = 0;
|
|
|
|
//
|
|
// Handle the beginning of a new line.
|
|
//
|
|
//
|
|
|
|
if ( BeginningOfLine ) {
|
|
|
|
length += (ULONG) sprintf( &OutputBuffer[length], "[Dhcp] " );
|
|
|
|
//
|
|
// Put the timestamp at the begining of the line.
|
|
//
|
|
IF_DEBUG( TIMESTAMP ) {
|
|
SYSTEMTIME SystemTime;
|
|
GetLocalTime( &SystemTime );
|
|
length += (ULONG) sprintf( &OutputBuffer[length],
|
|
"%02u/%02u %02u:%02u:%02u ",
|
|
SystemTime.wMonth,
|
|
SystemTime.wDay,
|
|
SystemTime.wHour,
|
|
SystemTime.wMinute,
|
|
SystemTime.wSecond );
|
|
}
|
|
|
|
//
|
|
// Indicate the type of message on the line
|
|
//
|
|
switch (DebugFlag) {
|
|
case DEBUG_ERRORS:
|
|
Text = "ERRR";
|
|
break;
|
|
|
|
case DEBUG_PROTOCOL:
|
|
Text = "PROT";
|
|
break;
|
|
|
|
case DEBUG_LEASE:
|
|
Text = "LEAS";
|
|
break;
|
|
|
|
case DEBUG_PROTOCOL_DUMP:
|
|
Text = "DUMP";
|
|
break;
|
|
|
|
case DEBUG_MISC:
|
|
Text = "MISC";
|
|
break;
|
|
|
|
default:
|
|
Text = "DHCP";
|
|
break;
|
|
}
|
|
|
|
if ( Text != NULL ) {
|
|
length += (ULONG) sprintf( &OutputBuffer[length], "[%s] ", Text );
|
|
}
|
|
}
|
|
|
|
//
|
|
// Put a the information requested by the caller onto the line
|
|
//
|
|
|
|
va_start(arglist, Format);
|
|
|
|
length += (ULONG) vsprintf(&OutputBuffer[length], Format, arglist);
|
|
BeginningOfLine = (length > 0 && OutputBuffer[length-1] == '\n' );
|
|
|
|
va_end(arglist);
|
|
|
|
DhcpAssert(length <= MAX_PRINTF_LEN);
|
|
|
|
|
|
//
|
|
// Output to the debug terminal,
|
|
//
|
|
|
|
if (NULL == DhcpGlobalDebugFile) {
|
|
(void) DbgPrint( (PCH) OutputBuffer);
|
|
} else {
|
|
|
|
//
|
|
// Note: other process can still write to the log file. This should be OK since
|
|
// only the Dhcp client service is supposed to write to the log file.
|
|
//
|
|
EnterCriticalSection( &DhcpGlobalDebugFileCritSect );
|
|
SetFilePointer(DhcpGlobalDebugFile, 0, NULL, FILE_END);
|
|
WriteFile(DhcpGlobalDebugFile, OutputBuffer, length, &length, NULL);
|
|
LeaveCriticalSection( &DhcpGlobalDebugFileCritSect );
|
|
}
|
|
|
|
// LeaveCriticalSection( &DhcpGlobalDebugFileCritSect );
|
|
|
|
}
|
|
|
|
#endif // DBG
|
|
|
|
|
|
PDHCP_CONTEXT
|
|
FindDhcpContextOnNicList(
|
|
IN LPCWSTR AdapterName, OPTIONAL
|
|
IN DWORD InterfaceContext
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This function finds the DHCP_CONTEXT for the specified
|
|
adapter name on the Nic list.
|
|
|
|
This function must be called with LOCK_RENEW_LIST().
|
|
|
|
Arguments:
|
|
|
|
AdapterName - name of the adapter.
|
|
HardwareAddress - The hardware address to look for.
|
|
|
|
Return Value:
|
|
|
|
A pointer to the desired DHCP work context.
|
|
NULL - If the specified work context block cannot be found.
|
|
|
|
--*/
|
|
{
|
|
PLIST_ENTRY listEntry;
|
|
PDHCP_CONTEXT dhcpContext;
|
|
PLOCAL_CONTEXT_INFO LocalInfo;
|
|
|
|
listEntry = DhcpGlobalNICList.Flink;
|
|
while ( listEntry != &DhcpGlobalNICList ) {
|
|
dhcpContext = CONTAINING_RECORD( listEntry, DHCP_CONTEXT, NicListEntry );
|
|
|
|
LocalInfo = dhcpContext->LocalInformation;
|
|
if ( AdapterName ) {
|
|
if( _wcsicmp( LocalInfo->AdapterName, AdapterName ) == 0 ) {
|
|
return( dhcpContext );
|
|
}
|
|
|
|
} else {
|
|
if( LocalInfo->IpInterfaceContext == InterfaceContext ) {
|
|
return( dhcpContext );
|
|
}
|
|
}
|
|
|
|
listEntry = listEntry->Flink;
|
|
}
|
|
|
|
return( NULL );
|
|
}
|
|
|
|
//
|
|
// End of file
|
|
//
|