config.c File Reference

#include "ndissys.h"
#include <ntifs.h>

Include dependency graph for config.c:

Go to the source code of this file.

Macros
#define	PARAMETERS_KEY   L"Parameters" /* The parameters subkey under the device-specific key */

Functions
static PMINIPORT_CONFIGURATION_CONTEXT	AllocateConfigurationContext (_In_ POBJECT_ATTRIBUTES ObjectAttributes)
static VOID	AddConfigurationParameter (_In_ PMINIPORT_CONFIGURATION_CONTEXT ConfigurationContext, _Out_ PMINIPORT_RESOURCE MiniportResource, _In_ ULONG Type, _In_ PVOID ConfigParameter)
VOID EXPORT	NdisWriteConfiguration (OUT PNDIS_STATUS Status, IN NDIS_HANDLE ConfigurationHandle, IN PNDIS_STRING Keyword, IN PNDIS_CONFIGURATION_PARAMETER ParameterValue)
VOID EXPORT	NdisCloseConfiguration (IN NDIS_HANDLE ConfigurationHandle)
VOID EXPORT	NdisOpenConfiguration (OUT PNDIS_STATUS Status, OUT PNDIS_HANDLE ConfigurationHandle, IN NDIS_HANDLE WrapperConfigurationContext)
VOID EXPORT	NdisOpenProtocolConfiguration (OUT PNDIS_STATUS Status, OUT PNDIS_HANDLE ConfigurationHandle, IN PNDIS_STRING ProtocolSection)
static UCHAR	UnicodeToHexByte (WCHAR chr)
static BOOLEAN	IsValidNumericString (PNDIS_STRING String, ULONG Base)
VOID EXPORT	NdisReadConfiguration (_At_(*Status, _Must_inspect_result_) _Out_ PNDIS_STATUS Status, _Out_ PNDIS_CONFIGURATION_PARAMETER *ParameterValue, _In_ NDIS_HANDLE ConfigurationHandle, _In_ PNDIS_STRING Keyword, _In_ NDIS_PARAMETER_TYPE ParameterType)
VOID EXPORT	NdisReadNetworkAddress (OUT PNDIS_STATUS Status, OUT PVOID *NetworkAddress, OUT PUINT NetworkAddressLength, IN NDIS_HANDLE ConfigurationHandle)
VOID EXPORT	NdisOpenConfigurationKeyByIndex (OUT PNDIS_STATUS Status, IN NDIS_HANDLE ConfigurationHandle, IN ULONG Index, OUT PNDIS_STRING KeyName, OUT PNDIS_HANDLE KeyHandle)
VOID EXPORT	NdisOpenConfigurationKeyByName (OUT PNDIS_STATUS Status, IN NDIS_HANDLE ConfigurationHandle, IN PNDIS_STRING KeyName, OUT PNDIS_HANDLE KeyHandle)

Variables
ULONG	NdisEnableTxRxFlowControl

Macro Definition Documentation

PARAMETERS_KEY

#define PARAMETERS_KEY   L"Parameters" /* The parameters subkey under the device-specific key */

Definition at line 38 of file config.c.

Function Documentation

AddConfigurationParameter()

static VOID AddConfigurationParameter ( _In_ PMINIPORT_CONFIGURATION_CONTEXT  ConfigurationContext, _Out_ PMINIPORT_RESOURCE  MiniportResource, _In_ ULONG  Type, _In_ PVOID  ConfigParameter  )

static

Definition at line 80 of file config.c.

{
    MiniportResource->ResourceType = Type;
    MiniportResource->Resource = ConfigParameter;
 
    NDIS_DbgPrint(MID_TRACE, ("inserting %p into the resource list\n",
                              MiniportResource->Resource));
 
    ExInterlockedInsertTailList(&ConfigurationContext->ResourceListHead,
                                &MiniportResource->ListEntry,
                                &ConfigurationContext->ResourceLock);
}

Referenced by NdisReadConfiguration(), and NdisReadNetworkAddress().

AllocateConfigurationContext()

static PMINIPORT_CONFIGURATION_CONTEXT AllocateConfigurationContext ( _In_ POBJECT_ATTRIBUTES  ObjectAttributes )

static

Definition at line 44 of file config.c.

{
    PMINIPORT_CONFIGURATION_CONTEXT ConfigurationContext;
    HANDLE KeyHandle;
    NTSTATUS Status;
 
    Status = ZwOpenKey(&KeyHandle, KEY_ALL_ACCESS, ObjectAttributes);
    if (!NT_SUCCESS(Status))
    {
        NDIS_DbgPrint(MIN_TRACE, ("Failed to open registry configuration for this miniport "
                                  "'%wZ', status 0x%lx\n",
                                  ObjectAttributes->ObjectName, Status));
        return NULL;
    }
 
    ConfigurationContext = ExAllocatePoolUninitialized(NonPagedPool,
                                                       sizeof(*ConfigurationContext),
                                                       TAG_CONFIG);
    if (!ConfigurationContext)
    {
        NDIS_DbgPrint(MIN_TRACE, ("Insufficient resources.\n"));
        ZwClose(KeyHandle);
        return NULL;
    }
 
    ConfigurationContext->Handle = KeyHandle;
 
    KeInitializeSpinLock(&ConfigurationContext->ResourceLock);
    InitializeListHead(&ConfigurationContext->ResourceListHead);
 
    return ConfigurationContext;
}

Referenced by NdisOpenConfiguration(), NdisOpenConfigurationKeyByIndex(), NdisOpenConfigurationKeyByName(), and NdisOpenProtocolConfiguration().

IsValidNumericString()

static BOOLEAN IsValidNumericString ( PNDIS_STRING  String, ULONG  Base  )

static

Definition at line 403 of file config.c.

{
    ULONG i;
 
    /* I don't think this will ever happen, but we warn it if it does */
    if (String->Length == 0)
    {
        NDIS_DbgPrint(MIN_TRACE, ("Got an empty string; not sure what to do here\n"));
        return FALSE;
    }
 
    for (i = 0; i < String->Length / sizeof(WCHAR); i++)
    {
        /* Skip any NULL characters we find */
        if (String->Buffer[i] == UNICODE_NULL)
            continue;
 
        /* Make sure the character is valid for a numeric string of this base */
        if (UnicodeToHexByte(String->Buffer[i]) >= Base)
            return FALSE;
    }
 
    /* It's valid */
    return TRUE;
}

Referenced by NdisReadConfiguration().

NdisCloseConfiguration()

VOID EXPORT NdisCloseConfiguration

(

IN NDIS_HANDLE

ConfigurationHandle

)

Definition at line 193 of file config.c.

{
    PMINIPORT_CONFIGURATION_CONTEXT ConfigurationContext = (PMINIPORT_CONFIGURATION_CONTEXT)ConfigurationHandle;
    PMINIPORT_RESOURCE Resource;
    PNDIS_CONFIGURATION_PARAMETER ParameterValue;
    PLIST_ENTRY CurrentEntry;
 
    while((CurrentEntry = ExInterlockedRemoveHeadList(&ConfigurationContext->ResourceListHead,
                                                      &ConfigurationContext->ResourceLock)) != NULL)
    {
        Resource = CONTAINING_RECORD(CurrentEntry, MINIPORT_RESOURCE, ListEntry);
        switch(Resource->ResourceType)
        {
          case MINIPORT_RESOURCE_TYPE_REGISTRY_DATA:
            ParameterValue = Resource->Resource;
 
            switch (ParameterValue->ParameterType)
            {
               case NdisParameterBinary:
                 ExFreePoolWithTag(ParameterValue->ParameterData.BinaryData.Buffer, TAG_CONFIG);
                 break;
 
               case NdisParameterString:
               case NdisParameterMultiString:
                 ExFreePoolWithTag(ParameterValue->ParameterData.StringData.Buffer, TAG_CONFIG);
                 break;
 
               default:
                 break;
            }
 
          /* Fall through to free NDIS_CONFIGURATION_PARAMETER struct */
 
          case MINIPORT_RESOURCE_TYPE_MEMORY:
            NDIS_DbgPrint(MAX_TRACE,("freeing 0x%x\n", Resource->Resource));
            ExFreePoolWithTag(Resource->Resource, TAG_CONFIG);
            break;
 
          default:
            NDIS_DbgPrint(MIN_TRACE,("Unknown resource type: %d\n", Resource->ResourceType));
            break;
        }
 
        ExFreePoolWithTag(Resource, TAG_CONFIG);
    }
 
    ZwClose(ConfigurationContext->Handle);
}

Referenced by DcReadConfiguration(), MiniportInitialize(), NdisIPnPStartDevice(), NvNetReadConfiguration(), and ReadNicConfiguration().

NdisOpenConfiguration()

VOID EXPORT NdisOpenConfiguration	(	OUT PNDIS_STATUS	Status,
		OUT PNDIS_HANDLE	ConfigurationHandle,
		IN NDIS_HANDLE	WrapperConfigurationContext
	)

Definition at line 254 of file config.c.

{
    PMINIPORT_CONFIGURATION_CONTEXT ConfigurationContext;
    PNDIS_WRAPPER_CONTEXT WrapperContext = (PNDIS_WRAPPER_CONTEXT)WrapperConfigurationContext;
    HANDLE RootKeyHandle = WrapperContext->RegistryHandle;
    OBJECT_ATTRIBUTES ObjectAttributes;
    UNICODE_STRING NoName = RTL_CONSTANT_STRING(L"");
 
    NDIS_DbgPrint(MAX_TRACE, ("Called\n"));
 
    *ConfigurationHandle = NULL;
 
    InitializeObjectAttributes(&ObjectAttributes,
                               &NoName,
                               OBJ_KERNEL_HANDLE,
                               RootKeyHandle,
                               NULL);
 
    ConfigurationContext = AllocateConfigurationContext(&ObjectAttributes);
    if(!ConfigurationContext)
    {
        NDIS_DbgPrint(MIN_TRACE,("Insufficient resources.\n"));
        *Status = NDIS_STATUS_RESOURCES;
        return;
    }
 
    *ConfigurationHandle = (NDIS_HANDLE)ConfigurationContext;
    *Status = NDIS_STATUS_SUCCESS;
 
    NDIS_DbgPrint(MAX_TRACE,("returning success\n"));
}

Referenced by DcReadConfiguration(), MiniportInitialize(), NdisIPnPStartDevice(), NvNetReadConfiguration(), and ParaNdis_OpenNICConfiguration().

NdisOpenConfigurationKeyByIndex()

VOID EXPORT NdisOpenConfigurationKeyByIndex	(	OUT PNDIS_STATUS	Status,
		IN NDIS_HANDLE	ConfigurationHandle,
		IN ULONG	Index,
		OUT PNDIS_STRING	KeyName,
		OUT PNDIS_HANDLE	KeyHandle
	)

Definition at line 876 of file config.c.

{
    KEY_BASIC_INFORMATION *KeyInformation;
    ULONG KeyInformationLength;
    OBJECT_ATTRIBUTES KeyAttributes;
    PMINIPORT_CONFIGURATION_CONTEXT ConfigurationContext;
 
    *KeyHandle = NULL;
 
    *Status = ZwEnumerateKey(ConfigurationHandle, Index, KeyBasicInformation, NULL, 0, &KeyInformationLength);
    if(*Status != STATUS_BUFFER_TOO_SMALL && *Status != STATUS_BUFFER_OVERFLOW && *Status != STATUS_SUCCESS)
    {
        NDIS_DbgPrint(MIN_TRACE, ("ZwEnumerateKey failed (%x)\n", *Status));
        *Status = NDIS_STATUS_FAILURE;
        return;
    }
 
    KeyInformation = ExAllocatePoolUninitialized(PagedPool,
                                                 KeyInformationLength + sizeof(*KeyInformation),
                                                 TAG_CONFIG);
    if(!KeyInformation)
    {
        NDIS_DbgPrint(MIN_TRACE,("Insufficient resources.\n"));
        *Status = NDIS_STATUS_FAILURE;
        return;
    }
 
    *Status = ZwEnumerateKey(ConfigurationHandle, Index, KeyBasicInformation, KeyInformation,
        KeyInformationLength + sizeof(KEY_BASIC_INFORMATION), &KeyInformationLength);
 
    if(*Status != STATUS_SUCCESS)
    {
        NDIS_DbgPrint(MIN_TRACE, ("ZwEnumerateKey failed (%x)\n", *Status));
        ExFreePoolWithTag(KeyInformation, TAG_CONFIG);
        *Status = NDIS_STATUS_FAILURE;
        return;
    }
 
    /* should i fail instead if the passed-in string isn't long enough? */
    wcsncpy(KeyName->Buffer, KeyInformation->Name, KeyName->MaximumLength/sizeof(WCHAR));
    KeyName->Length = (USHORT)min(KeyInformation->NameLength, KeyName->MaximumLength);
 
    InitializeObjectAttributes(&KeyAttributes, KeyName, OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE, ConfigurationHandle, NULL);
 
    ConfigurationContext = AllocateConfigurationContext(&KeyAttributes);
    ExFreePoolWithTag(KeyInformation, TAG_CONFIG);
    if(!ConfigurationContext)
    {
        NDIS_DbgPrint(MIN_TRACE,("Insufficient resources.\n"));
        *Status = NDIS_STATUS_FAILURE;
        return;
    }
 
    *KeyHandle = (NDIS_HANDLE)ConfigurationContext;
    *Status = NDIS_STATUS_SUCCESS;
}

NdisOpenConfigurationKeyByName()

VOID EXPORT NdisOpenConfigurationKeyByName	(	OUT PNDIS_STATUS	Status,
		IN NDIS_HANDLE	ConfigurationHandle,
		IN PNDIS_STRING	KeyName,
		OUT PNDIS_HANDLE	KeyHandle
	)

Definition at line 958 of file config.c.

{
    PMINIPORT_CONFIGURATION_CONTEXT ConfigurationContext;
    OBJECT_ATTRIBUTES KeyAttributes;
 
    *KeyHandle = NULL;
 
    InitializeObjectAttributes(&KeyAttributes, KeyName, OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE, ConfigurationHandle, 0);
 
    ConfigurationContext = AllocateConfigurationContext(&KeyAttributes);
    if(!ConfigurationContext)
    {
        NDIS_DbgPrint(MIN_TRACE,("Insufficient resources.\n"));
        *Status = NDIS_STATUS_FAILURE;
        return;
    }
 
    *KeyHandle = (NDIS_HANDLE)ConfigurationContext;
    *Status = NDIS_STATUS_SUCCESS;
}

NdisOpenProtocolConfiguration()

VOID EXPORT NdisOpenProtocolConfiguration	(	OUT PNDIS_STATUS	Status,
		OUT PNDIS_HANDLE	ConfigurationHandle,
		IN PNDIS_STRING	ProtocolSection
	)

Definition at line 307 of file config.c.

{
    OBJECT_ATTRIBUTES KeyAttributes;
    UNICODE_STRING KeyNameU;
    PMINIPORT_CONFIGURATION_CONTEXT ConfigurationContext;
 
    KeyNameU.Length = 0;
    KeyNameU.MaximumLength = ProtocolSection->Length + sizeof(PARAMETERS_KEY) + sizeof(UNICODE_NULL);
    KeyNameU.Buffer = ExAllocatePoolUninitialized(PagedPool, KeyNameU.MaximumLength, TAG_CONFIG);
    if(!KeyNameU.Buffer)
    {
        NDIS_DbgPrint(MIN_TRACE,("Insufficient resources.\n"));
        *ConfigurationHandle = NULL;
        *Status = NDIS_STATUS_FAILURE;
        return;
    }
 
    RtlCopyUnicodeString(&KeyNameU, ProtocolSection);
    RtlAppendUnicodeToString(&KeyNameU, PARAMETERS_KEY);
    InitializeObjectAttributes(&KeyAttributes, &KeyNameU, OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE, NULL, NULL);
 
    ConfigurationContext = AllocateConfigurationContext(&KeyAttributes);
    ExFreePoolWithTag(KeyNameU.Buffer, TAG_CONFIG);
    if(!ConfigurationContext)
    {
        NDIS_DbgPrint(MIN_TRACE,("Insufficient resources.\n"));
        *ConfigurationHandle = NULL;
        *Status = NDIS_STATUS_FAILURE;
        return;
    }
 
    *ConfigurationHandle = (NDIS_HANDLE)ConfigurationContext;
    *Status = NDIS_STATUS_SUCCESS;
}

NdisReadConfiguration()

VOID EXPORT NdisReadConfiguration	(	_At_ *, _Must_inspect_result_ _Out_ PNDIS_STATUS	Status,
		_Out_ PNDIS_CONFIGURATION_PARAMETER *	ParameterValue,
		_In_ NDIS_HANDLE	ConfigurationHandle,
		_In_ PNDIS_STRING	Keyword,
		_In_ NDIS_PARAMETER_TYPE	ParameterType
	)

Definition at line 441 of file config.c.

{
    PMINIPORT_CONFIGURATION_CONTEXT ConfigurationContext = ConfigurationHandle;
    PKEY_VALUE_PARTIAL_INFORMATION KeyInformation = NULL;
    PNDIS_CONFIGURATION_PARAMETER ConfigParameter = NULL;
    PMINIPORT_RESOURCE MiniportResource = NULL;
    NDIS_STATUS NdisStatus = NDIS_STATUS_SUCCESS;
    NTSTATUS NtStatus;
    ULONG LocalUlong;
    PVOID RegData;
    ULONG RegType;
    ULONG RegDataLength;
    static const UNICODE_STRING NdisVersionKey = RTL_CONSTANT_STRING(L"NdisVersion");
    static const UNICODE_STRING EnvironmentKey = RTL_CONSTANT_STRING(L"Environment");
    static const UNICODE_STRING ProcessorTypeKey = RTL_CONSTANT_STRING(L"ProcessorType");
    static const UNICODE_STRING FlowControlKey = RTL_CONSTANT_STRING(L"*FlowControl");
 
    NDIS_DbgPrint(MAX_TRACE, ("requested read type %d of '%wZ'\n", ParameterType, Keyword));
 
    ASSERT(ConfigurationContext);
 
    /* Check for predefined entry names */
    if (!NdisEnableTxRxFlowControl && RtlEqualUnicodeString(Keyword, &FlowControlKey, TRUE))
    {
        NDIS_DbgPrint(MID_TRACE, ("Disable TX/RX flow control for this miniport\n"));
        LocalUlong = 0;
 
        RegType = REG_DWORD;
        RegData = &LocalUlong;
        RegDataLength = sizeof(LocalUlong);
    }
    else if (RtlEqualUnicodeString(Keyword, &NdisVersionKey, TRUE))
    {
        LocalUlong = NDIS_VERSION;
 
        RegType = REG_DWORD;
        RegData = &LocalUlong;
        RegDataLength = sizeof(LocalUlong);
    }
    else if (RtlEqualUnicodeString(Keyword, &EnvironmentKey, TRUE))
    {
        LocalUlong = NdisEnvironmentWindowsNt;
 
        RegType = REG_DWORD;
        RegData = &LocalUlong;
        RegDataLength = sizeof(LocalUlong);
    }
    else if (RtlEqualUnicodeString(Keyword, &ProcessorTypeKey, TRUE))
    {
#if defined(_M_IX86)
        LocalUlong = NdisProcessorX86;
#elif defined(_M_MIPS)
        LocalUlong = NdisProcessorMips;
#elif defined(_M_ALPHA)
        LocalUlong = NdisProcessorAlpha;
#elif defined(_M_MPPC)
        LocalUlong = NdisProcessorPpc;
#elif defined(_M_AMD64)
        LocalUlong = NdisProcessorAmd64;
#elif defined(_M_IA64)
        LocalUlong = NdisProcessorIA64;
#elif defined(_M_ARM)
        LocalUlong = NdisProcessorArm;
#elif defined(_M_ARM64)
        LocalUlong = NdisProcessorArm64;
#else
#error Unknown architecture
#endif
 
        RegType = REG_DWORD;
        RegData = &LocalUlong;
        RegDataLength = sizeof(LocalUlong);
    }
    else
    {
        ULONG KeyDataLength, RetryCount;
 
        /* The most common case is NdisParameterInteger (REG_DWORD) */
        KeyDataLength = FIELD_OFFSET(KEY_VALUE_PARTIAL_INFORMATION, Data) + sizeof(ULONG);
 
        for (RetryCount = 0; RetryCount < 2; ++RetryCount)
        {
            KeyInformation = ExAllocatePoolUninitialized(PagedPool, KeyDataLength, TAG_CONFIG);
            if (!KeyInformation)
            {
                NDIS_DbgPrint(MIN_TRACE, ("Insufficient resources.\n"));
                *Status = NDIS_STATUS_RESOURCES;
                return;
            }
 
            /* Query the value */
            NtStatus = ZwQueryValueKey(ConfigurationContext->Handle,
                                       Keyword,
                                       KeyValuePartialInformation,
                                       KeyInformation,
                                       KeyDataLength,
                                       &KeyDataLength);
 
            /* Increase the allocation size if it's too small */
            if (NtStatus == STATUS_BUFFER_OVERFLOW || NtStatus == STATUS_BUFFER_TOO_SMALL)
            {
                ExFreePoolWithTag(KeyInformation, TAG_CONFIG);
                KeyInformation = NULL;
                continue;
            }
 
            break;
        }
 
        if (!NT_SUCCESS(NtStatus))
        {
            NDIS_DbgPrint(MIN_TRACE, ("ZwQueryValueKey failed for '%wZ', status 0x%lx\n",
                                      Keyword, NtStatus));
            NdisStatus = NDIS_STATUS_FAILURE;
            goto Exit;
        }
 
        RegType = KeyInformation->Type;
        RegData = &KeyInformation->Data[0];
        RegDataLength = KeyInformation->DataLength;
    }
 
    MiniportResource = ExAllocatePoolUninitialized(PagedPool,
                                                   sizeof(*MiniportResource),
                                                   TAG_CONFIG);
    if (!MiniportResource)
    {
       NDIS_DbgPrint(MIN_TRACE, ("Insufficient resources.\n"));
       NdisStatus = NDIS_STATUS_RESOURCES;
       goto Exit;
    }
 
    ConfigParameter = ExAllocatePoolZero(PagedPool, sizeof(*ConfigParameter), TAG_CONFIG);
    if (!ConfigParameter)
    {
        NDIS_DbgPrint(MIN_TRACE, ("Insufficient resources.\n"));
        NdisStatus = NDIS_STATUS_RESOURCES;
        goto Exit;
    }
 
    switch (RegType)
    {
        case REG_DWORD:
        {
            ASSERT(RegDataLength == sizeof(ULONG));
 
            ConfigParameter->ParameterType = NdisParameterInteger;
            ConfigParameter->ParameterData.IntegerData = *(PULONG)RegData;
 
            NDIS_DbgPrint(MAX_TRACE, ("NdisParameterInteger 0x%lX (%lu)\n",
                                      ConfigParameter->ParameterData.IntegerData,
                                      ConfigParameter->ParameterData.IntegerData));
            break;
        }
        case REG_BINARY:
        {
            PVOID Buffer;
 
            NDIS_DbgPrint(MAX_TRACE, ("NdisParameterBinary\n"));
 
            Buffer = ExAllocatePoolUninitialized(PagedPool, RegDataLength, TAG_CONFIG);
            if (!Buffer)
            {
                NDIS_DbgPrint(MIN_TRACE, ("Insufficient resources.\n"));
                NdisStatus = NDIS_STATUS_RESOURCES;
                goto Exit;
            }
            RtlCopyMemory(Buffer, RegData, RegDataLength);
 
            ConfigParameter->ParameterData.BinaryData.Buffer = Buffer;
            ConfigParameter->ParameterData.BinaryData.Length = RegDataLength;
            break;
        }
        case REG_MULTI_SZ:
        {
            PVOID Buffer;
 
            NDIS_DbgPrint(MAX_TRACE, ("NdisParameterMultiString\n"));
 
            Buffer = ExAllocatePoolUninitialized(PagedPool, RegDataLength, TAG_CONFIG);
            if (!Buffer)
            {
                NDIS_DbgPrint(MIN_TRACE, ("Insufficient resources.\n"));
                NdisStatus = NDIS_STATUS_RESOURCES;
                goto Exit;
            }
            RtlCopyMemory(Buffer, RegData, RegDataLength);
 
            ConfigParameter->ParameterType = NdisParameterMultiString;
            ConfigParameter->ParameterData.StringData.Buffer = Buffer;
            ConfigParameter->ParameterData.StringData.Length = RegDataLength;
            break;
        }
        case REG_SZ:
        {
            UNICODE_STRING String;
            ULONG Base;
            PVOID Buffer;
 
            if (ParameterType == NdisParameterInteger)
                Base = 10;
            else if (ParameterType == NdisParameterHexInteger)
                Base = 16;
            else
                Base = 0;
 
            String.Length = String.MaximumLength = (USHORT)RegDataLength;
            String.Buffer = RegData;
 
            if (Base != 0 && IsValidNumericString(&String, Base))
            {
                NtStatus = RtlUnicodeStringToInteger(&String,
                                                     Base,
                                                     &ConfigParameter->ParameterData.IntegerData);
                ASSERT(NT_SUCCESS(NtStatus));
 
                NDIS_DbgPrint(MAX_TRACE, ("NdisParameter(Hex)Integer 0x%lX (%lu)\n",
                                          ConfigParameter->ParameterData.IntegerData,
                                          ConfigParameter->ParameterData.IntegerData));
 
                /*
                 * MSDN documents that this is returned for all integers,
                 * regardless of the ParameterType passed in.
                 */
                ConfigParameter->ParameterType = NdisParameterInteger;
            }
            else
            {
                NDIS_DbgPrint(MAX_TRACE, ("NdisParameterString\n"));
 
                ConfigParameter->ParameterType = NdisParameterString;
 
                Buffer = ExAllocatePoolUninitialized(PagedPool,
                                                     RegDataLength,
                                                     TAG_CONFIG);
                if (!Buffer)
                {
                    NDIS_DbgPrint(MIN_TRACE, ("Insufficient resources.\n"));
                    NdisStatus = NDIS_STATUS_RESOURCES;
                    goto Exit;
                }
                RtlCopyMemory(Buffer, RegData, RegDataLength);
 
                ConfigParameter->ParameterData.StringData.Buffer = Buffer;
                ConfigParameter->ParameterData.StringData.Length = RegDataLength;
            }
            break;
        }
        default:
        {
            NDIS_DbgPrint(MIN_TRACE, ("Invalid type for NdisReadConfiguration (%d)\n", RegType));
            NDIS_DbgPrint(MIN_TRACE, ("Requested type: %lu\n", ParameterType));
            NDIS_DbgPrint(MIN_TRACE, ("Registry entry: '%wZ'\n", Keyword));
 
            NdisStatus = NDIS_STATUS_FAILURE;
            goto Exit;
        }
    }
 
    if ((ConfigParameter->ParameterType != ParameterType) &&
        !((ParameterType == NdisParameterHexInteger) &&
          (ConfigParameter->ParameterType == NdisParameterInteger)))
    {
        NDIS_DbgPrint(MIN_TRACE, ("Parameter type mismatch! (Requested: %d | Received: %d)\n",
                                  ParameterType, ConfigParameter->ParameterType));
        NDIS_DbgPrint(MIN_TRACE, ("Registry entry: '%wZ'\n", Keyword));
    }
 
    ASSERT(NdisStatus == NDIS_STATUS_SUCCESS);
 
    *ParameterValue = ConfigParameter;
 
    AddConfigurationParameter(ConfigurationContext,
                              MiniportResource,
                              MINIPORT_RESOURCE_TYPE_REGISTRY_DATA,
                              ConfigParameter);
Exit:
    *Status = NdisStatus;
 
    if (NdisStatus != NDIS_STATUS_SUCCESS)
    {
        if (ConfigParameter)
            ExFreePoolWithTag(ConfigParameter, TAG_CONFIG);
        if (MiniportResource)
            ExFreePoolWithTag(MiniportResource, TAG_CONFIG);
    }
 
    if (KeyInformation)
        ExFreePoolWithTag(KeyInformation, TAG_CONFIG);
}

Referenced by DcConfigQueryInteger(), GetConfigurationEntry(), MiniportInitialize(), NdisIPnPStartDevice(), NdisReadNetworkAddress(), and QueryInteger().

NdisReadNetworkAddress()

VOID EXPORT NdisReadNetworkAddress	(	OUT PNDIS_STATUS	Status,
		OUT PVOID *	NetworkAddress,
		OUT PUINT	NetworkAddressLength,
		IN NDIS_HANDLE	ConfigurationHandle
	)

Definition at line 757 of file config.c.

{
    PMINIPORT_CONFIGURATION_CONTEXT ConfigurationContext = (PMINIPORT_CONFIGURATION_CONTEXT)ConfigurationHandle;
    PMINIPORT_RESOURCE MiniportResource = NULL;
    PNDIS_CONFIGURATION_PARAMETER ParameterValue = NULL;
    NDIS_STRING Keyword;
    UINT *IntArray = 0;
    UINT i,j = 0;
    WCHAR Buff[11];
    NDIS_STRING str;
 
    NdisInitUnicodeString(&Keyword, L"NetworkAddress");
    NdisReadConfiguration(Status, &ParameterValue, ConfigurationHandle, &Keyword, NdisParameterString);
    if(*Status != NDIS_STATUS_SUCCESS)
    {
        NDIS_DbgPrint(MID_TRACE, ("NdisReadConfiguration failed (%x)\n", *Status));
        *Status = NDIS_STATUS_FAILURE;
        return;
    }
 
    if (ParameterValue->ParameterType == NdisParameterInteger)
    {
        NDIS_DbgPrint(MAX_TRACE, ("Read integer data %lx\n",
                                  ParameterValue->ParameterData.IntegerData));
 
        str.Buffer = Buff;
        str.MaximumLength = (USHORT)sizeof(Buff);
        str.Length = 0;
 
        *Status = RtlIntegerToUnicodeString(ParameterValue->ParameterData.IntegerData,
                                            10,
                                            &str);
 
        if (*Status != NDIS_STATUS_SUCCESS)
        {
            NDIS_DbgPrint(MIN_TRACE, ("RtlIntegerToUnicodeString failed (%x)\n", *Status));
            *Status = NDIS_STATUS_FAILURE;
            return;
        }
 
        NDIS_DbgPrint(MAX_TRACE, ("Converted integer data into %wZ\n", &str));
    }
    else
    {
        ASSERT(ParameterValue->ParameterType == NdisParameterString);
        str = ParameterValue->ParameterData.StringData;
    }
 
    while (j < str.Length && str.Buffer[j] != '\0') j++;
 
    *NetworkAddressLength = (j+1) >> 1;
 
    if ((*NetworkAddressLength) == 0)
    {
        NDIS_DbgPrint(MIN_TRACE,("Empty NetworkAddress registry entry.\n"));
        *Status = NDIS_STATUS_FAILURE;
        return;
    }
 
    IntArray = ExAllocatePoolUninitialized(PagedPool,
                                           (*NetworkAddressLength) * sizeof(*IntArray),
                                           TAG_CONFIG);
    if(!IntArray)
    {
        NDIS_DbgPrint(MIN_TRACE,("Insufficient resources.\n"));
        *Status = NDIS_STATUS_RESOURCES;
        return;
    }
 
    MiniportResource = ExAllocatePoolUninitialized(PagedPool,
                                                   sizeof(*MiniportResource),
                                                   TAG_CONFIG);
    if(!MiniportResource)
    {
        NDIS_DbgPrint(MIN_TRACE,("Insufficient resources.\n"));
        ExFreePoolWithTag(IntArray, TAG_CONFIG);
        *Status = NDIS_STATUS_RESOURCES;
        return;
    }
 
    AddConfigurationParameter(ConfigurationContext,
                              MiniportResource,
                              MINIPORT_RESOURCE_TYPE_MEMORY,
                              IntArray);
 
    /* convert from string to bytes */
    for(i=0; i<(*NetworkAddressLength); i++)
    {
        IntArray[i] = (UnicodeToHexByte((str.Buffer)[2*i]) << 4) +
                UnicodeToHexByte((str.Buffer)[2*i+1]);
    }
 
    *NetworkAddress = IntArray;
 
    *Status = NDIS_STATUS_SUCCESS;
}

Referenced by DcReadConfiguration(), MiniportInitialize(), NvNetReadConfiguration(), and ReadNicConfiguration().

NdisWriteConfiguration()

VOID EXPORT NdisWriteConfiguration	(	OUT PNDIS_STATUS	Status,
		IN NDIS_HANDLE	ConfigurationHandle,
		IN PNDIS_STRING	Keyword,
		IN PNDIS_CONFIGURATION_PARAMETER	ParameterValue
	)

Definition at line 102 of file config.c.

{
    ULONG ParameterType;
    ULONG DataSize;
    PVOID Data;
    WCHAR Buff[11];
 
    NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
 
    NDIS_DbgPrint(MID_TRACE, ("Parameter type: %d\n", ParameterValue->ParameterType));
 
    /* reset parameter type to standard reg types */
    switch(ParameterValue->ParameterType)
    {
        case NdisParameterHexInteger:
        case NdisParameterInteger:
             {
                 UNICODE_STRING Str;
 
                 Str.Buffer = (PWSTR) &Buff;
                 Str.MaximumLength = (USHORT)sizeof(Buff);
                 Str.Length = 0;
 
                 ParameterType = REG_SZ;
                 if (!NT_SUCCESS(RtlIntegerToUnicodeString(
                      ParameterValue->ParameterData.IntegerData,
                      (ParameterValue->ParameterType == NdisParameterInteger) ? 10 : 16, &Str)))
                 {
                      NDIS_DbgPrint(MIN_TRACE, ("RtlIntegerToUnicodeString failed (%x)\n", *Status));
                      *Status = NDIS_STATUS_FAILURE;
                      return;
                 }
                 Data = Str.Buffer;
                 DataSize = Str.Length;
             }
             break;
        case NdisParameterString:
        case NdisParameterMultiString:
            ParameterType = (ParameterValue->ParameterType == NdisParameterString) ? REG_SZ : REG_MULTI_SZ;
            Data = ParameterValue->ParameterData.StringData.Buffer;
            DataSize = ParameterValue->ParameterData.StringData.Length;
            break;
 
        /* New (undocumented) addition to 2k ddk */
        case NdisParameterBinary:
            ParameterType = REG_BINARY;
            Data = ParameterValue->ParameterData.BinaryData.Buffer;
            DataSize = ParameterValue->ParameterData.BinaryData.Length;
            break;
 
        default:
            *Status = NDIS_STATUS_NOT_SUPPORTED;
            return;
    }
 
    *Status = ZwSetValueKey(((PMINIPORT_CONFIGURATION_CONTEXT)ConfigurationHandle)->Handle,
            Keyword, 0, ParameterType, Data, DataSize);
 
    if(*Status != STATUS_SUCCESS) {
        NDIS_DbgPrint(MIN_TRACE, ("ZwSetValueKey failed (%x)\n", *Status));
        *Status = NDIS_STATUS_FAILURE;
    } else
        *Status = NDIS_STATUS_SUCCESS;
}

UnicodeToHexByte()

static UCHAR UnicodeToHexByte ( WCHAR  chr )

static

Definition at line 358 of file config.c.

{
    switch(chr)
    {
        case L'0': return 0;
        case L'1': return 1;
        case L'2': return 2;
        case L'3': return 3;
        case L'4': return 4;
        case L'5': return 5;
        case L'6': return 6;
        case L'7': return 7;
        case L'8': return 8;
        case L'9': return 9;
        case L'A':
        case L'a':
            return 10;
        case L'B':
        case L'b':
            return 11;
        case L'C':
        case L'c':
            return 12;
        case L'D':
        case L'd':
            return 13;
        case L'E':
        case L'e':
            return 14;
        case L'F':
        case L'f':
            return 15;
    }
    return 0xFF;
}

Referenced by IsValidNumericString(), and NdisReadNetworkAddress().

Variable Documentation

NdisEnableTxRxFlowControl

ULONG NdisEnableTxRxFlowControl

extern

Definition at line 25 of file main.c.

Referenced by NdisReadConfiguration(), and NdisReadRegistryEntries().