windows-server-2003/net/dhcp/client/nt/apiappl.c

#include "precomp.h"

#ifdef H_ONLY
//================================================================================
//  Copyright (C) 1997 Microsoft Corporation
//  Author: RameshV
//  Description: these are the exported dhcp client api function definitions
//================================================================================

#ifndef APIAPPL_H_INCLUDED
#define APIAPPL_H_INCLUDED

#ifndef DHCPAPI_PARAMS_DEFINED
#define DHCPAPI_PARAMS_DEFINED
typedef struct _DHCPAPI_PARAMS {                  // use this structure to request params
    ULONG                          Flags;         // for future use
    ULONG                          OptionId;      // what option is this?
    BOOL                           IsVendor;      // is this vendor specific?
    LPBYTE                         Data;          // the actual data
    DWORD                          nBytesData;    // how many bytes of data are there in Data?
} DHCPAPI_PARAMS, *PDHCPAPI_PARAMS, *LPDHCPAPI_PARAMS;
#endif DHCPAPI_PARAMS_DEFINED

DWORD                                             // win32 status
DhcpAcquireParameters(                            // acquire/renew a lease
    IN      LPWSTR                 AdapterName    // adapter to acquire lease on
);

DWORD                                             // win32 status
DhcpAcquireParametersByBroadcast(                 // acquire/renew a lease
    IN      LPWSTR                 AdapterName    // adapter to acquire lease on
);

DWORD                                             // win32 status
DhcpFallbackRefreshParams(                        // refresh fallback params
    IN      LPWSTR                 AdapterName    // adapter to be refreshed
);

DWORD                                             // win32 status
DhcpReleaseParameters(                            // release an existing lease
    IN      LPWSTR                 AdapterName    // adpater to release lease for
);

DWORD                                             // win32 status
DhcpEnableDynamicConfic(                          // convert from static to dhcp
    IN      LPWSTR                 AdapterName    // convert for this adapter
);

DWORD                                             // win32 status
DhcpDisableDynamicConfig(                         // convert from dhcp to static
    IN      LPWSTR                 AdapterName    // convert this adapter
);

DWORD                                             // win32 status
DhcpReRegisterDynDns(                             // reregister static address with dns
    IN      LPWSTR                 AdapterName
);

DWORD                                             // win32 status
APIENTRY
DhcpRequestParams(                                // request parameters of client
    IN      LPWSTR                 AdapterName,   // adapter name to request for
    IN      LPBYTE                 ClassId,       // byte stream of class id to use
    IN      DWORD                  ClassIdLen,    // # of bytes of class id to use
    IN      PDHCPAPI_PARAMS        SendParams,    // parameters to send to server
    IN      DWORD                  nSendParams,   // size of above array
    IN      DWORD                  Flags,         // must be zero, reserved
    IN OUT  PDHCPAPI_PARAMS        RecdParams,    // fill this array with received params
    IN OUT  LPDWORD                pnRecdParamsBytes // i/p: size of above in BYTES, o/p required bytes or filled up # of elements
);  // returns ERROR_MORE_DATA if o/p buffer is of insufficient size, and fills in reqd size in # of bytes

DWORD                                             // win32 status
DhcpRegisterParameterChangeNotification(          // notify if a parameter has changed
    IN      LPWSTR                 AdapterName,   // adapter of interest
    IN      LPBYTE                 ClassId,       // byte stream of class id to use
    IN      DWORD                  ClassIdLen,    // # of bytes of class id
    IN      PDHCPAPI_PARAMS        Params,        // params of interest
    IN      DWORD                  nParams,       // # of elts in above array
    IN      DWORD                  Flags,         // must be zero, reserved
    IN OUT  PHANDLE                hEvent         // handle to event that will be SetEvent'ed in case of param change
);

DhcpDeRegisterParameterChangeNotification(        // undo the registration
    IN      HANDLE                 Event          // handle to event returned by DhcpRegisterParameterChangeNotification, NULL ==> everything
);

DWORD                                             // win32 status
DhcpPersistentRequestParams(                      // parameters to request persistently
    IN      LPWSTR                 AdapterName,   // adapter name to request for
    IN      LPBYTE                 ClassId,       // byte stream of class id to use
    IN      DWORD                  ClassIdLen,    // # of bytes of class id
    IN      PDHCPAPI_PARAMS        SendParams,    // persistent parameters
    IN      DWORD                  nSendParams,   // size of above array
    IN      DWORD                  Flags,         // must be zero, reserved
    IN      LPWSTR                 AppName,       // the name of the app that is to be used for this instance
    IN OUT  LPDWORD                UniqueId       // OPTIONAL, return value is id that can be used in DhcpDelPersistentRequestParams
);


DWORD                                             // win32 status
DhcpDelPersistentRequestParams(                   // undo the effect of a persistent request -- currently undo from registry
    IN      LPWSTR                 AdapterName,   // the name of the adpater to delete for
    IN      LPWSTR                 AppName,       // the name used by the app
    IN      DWORD                  UniqueId       // something for this instance
);

#endif APIAPPL_H_INCLUDED
#else  H_ONLY

#include <apiargs.h>
#include <apistub.h>
#include <apiimpl.h>
#include <apiappl.h>
#include <dhcploc.h>
#include <dhcppro.h>
#include <dhcpcsdk.h>

DWORD INLINE                                      // win32 status
DhcpApiFillBuffer(                                // fill the buffer with some params
    IN OUT  LPBYTE                 Buffer,        // the buffer to fill
    IN      DWORD                  MaxBufferSize, // the max size of buffer allwoed
    IN      LPWSTR                 AdapterName,   // fill in adapter name
    IN      BYTE                   OpCode         // what opcode to use?
) {
    DWORD                          Size;

    if( NULL == AdapterName ) Size = 0;
    else Size = (wcslen(AdapterName)+1)*sizeof(WCHAR);

    return DhcpApiArgAdd(                         // fill in the buffer with the reqd options
        Buffer,
        MaxBufferSize,
        OpCode,
        Size,
        (LPBYTE)AdapterName
    );
}

DWORD INLINE                                      // win32 status
DhcpAdapterOnlyApi(                               // execute apis that take only adapter name params
    IN      LPWSTR                 AdapterName,   // the adapter name
    IN      BYTE                   OpCode
) 
{
    LPBYTE                         Buffer;
    LPBYTE                         Buffer2;
    DWORD                          BufSize;
    DWORD                          Size;
    DWORD                          Error;

    BufSize = 0;
    Error = DhcpApiFillBuffer((LPBYTE)&BufSize, sizeof(BufSize), AdapterName, OpCode);
    DhcpAssert( ERROR_SUCCESS != Error );
    if( ERROR_MORE_DATA != Error ) return Error;
    DhcpAssert(BufSize);
    BufSize = ntohl(BufSize) + 2*sizeof(DWORD);

    Buffer = DhcpAllocateMemory(BufSize);
    if( NULL == Buffer ) return ERROR_NOT_ENOUGH_MEMORY;

    *(DWORD UNALIGNED *)Buffer = htonl(0);
    Buffer2 = Buffer + sizeof(DWORD);
    *(DWORD UNALIGNED *)Buffer2 = 0;
    BufSize -= sizeof(DWORD);
    Error = DhcpApiFillBuffer(Buffer2, BufSize, AdapterName, OpCode);
    Size = 0;
    if( ERROR_SUCCESS == Error ) Error = ExecuteApiRequest(Buffer, NULL, &Size);
    DhcpFreeMemory(Buffer);

    return Error;
}

DWORD                                             // win32 status
DhcpAcquireParameters(                            // acquire/renew a lease
    IN      LPWSTR                 AdapterName    // adapter to acquire lease on
) {
    return DhcpAdapterOnlyApi(AdapterName, AcquireParametersOpCode);
}

DWORD                                             // win32 status
DhcpAcquireParametersByBroadcast(                 // acquire/renew a lease
    IN      LPWSTR                 AdapterName    // adapter to acquire lease on
) {
    return DhcpAdapterOnlyApi(AdapterName, AcquireParametersByBroadcastOpCode);
}

DWORD                                             // win32 status
DhcpFallbackRefreshParams(                        // refresh fallback params
    IN LPWSTR AdapterName                         // adapter to be refreshed
)
{
    return DhcpAdapterOnlyApi(AdapterName, FallbackParamsOpCode);
}

DWORD                                             // win32 status
DhcpReleaseParameters(                            // release an existing lease
    IN      LPWSTR                 AdapterName    // adpater to release lease for
) {
    return DhcpAdapterOnlyApi(AdapterName, ReleaseParametersOpCode);
}

DWORD                                             // win32 status
DhcpEnableDynamicConfig(                          // convert from static to dhcp
    IN      LPWSTR                 AdapterName    // convert for this adapter
) {
    return DhcpAdapterOnlyApi(AdapterName, EnableDhcpOpCode);
}

DWORD                                             // win32 status
DhcpDisableDynamicConfig(                         // convert from dhcp to static
    IN      LPWSTR                 AdapterName    // convert this adapter
) {
    return DhcpAdapterOnlyApi(AdapterName, DisableDhcpOpCode);
}

DWORD                                             // win32 status
DhcpStaticRefreshParamsInternal(                  // refresh some static parameters that have changed
    IN      LPWSTR                 AdapterName,
    IN      BOOL                   fDoDns
) 
{
    LPBYTE Buffer, Buffer2;
    DWORD BufSize, Size, Error, Code;

    BufSize = 0;
    Error = DhcpApiFillBuffer(
        (LPBYTE)&BufSize, sizeof(BufSize), AdapterName, StaticRefreshParamsOpCode
        );
    if( ERROR_MORE_DATA != Error ) return Error;
    DhcpAssert( BufSize );
    BufSize = ntohl(BufSize) + 2 * sizeof(DWORD);
    BufSize += 3*sizeof(DWORD);

    Buffer = DhcpAllocateMemory( BufSize );
    if( NULL == Buffer ) return ERROR_NOT_ENOUGH_MEMORY;
    
    *(DWORD*)Buffer = 0;
    Buffer2 = Buffer + sizeof(DWORD);
    *(DWORD*)Buffer2 = 0;

    BufSize -= sizeof(DWORD);
    Error = DhcpApiFillBuffer(
        Buffer2, BufSize, AdapterName, StaticRefreshParamsOpCode
        );
    DhcpAssert( ERROR_SUCCESS == Error );
    Code = (fDoDns ? 0x00 : 0x01);
    Error = DhcpApiArgAdd(
        Buffer2, BufSize, (BYTE)FlagsParam, sizeof(DWORD), (LPBYTE)&Code
        );
    DhcpAssert( ERROR_SUCCESS == Error );

    Size = 0;
    Error =  ExecuteApiRequest(Buffer, NULL, &Size); 
    DhcpFreeMemory( Buffer );
    return Error;
}

DWORD
DhcpStaticRefreshParams(
    IN LPWSTR AdapterName
)
{
    return DhcpStaticRefreshParamsInternal(AdapterName, TRUE );
}

#if 0
// pl dont use this api, use DhcpRequestParams instead.
DWORD                                             // win32 status
DhcpRequestOptions(                               // request for specific options
    IN      LPWSTR                 AdapterName,   // which adapter's info is needed
    IN      LPBYTE                 RequestedOpt,  // list of requested options
    IN      DWORD                  nRequestedOpts,// size of above BYTE array
    OUT     LPBYTE                *OptData,       // the data for each available option
    IN OUT  LPDWORD                OptDataSize,   // # of bytes of above byte array
    OUT     LPBYTE                *AvailOpts,     // the list of available options
    IN OUT  LPDWORD                nAvailOpts     // # of available options
) {
    PDHCP_API_ARGS                 DhcpApiArgs;
    CHAR                           TmpBuf[OPTION_END+1];
    LPBYTE                         OutBuf;
    LPBYTE                         InBuf;
    LPBYTE                         Buffer;
    LPBYTE                         Endp;
    LPBYTE                         RetOptList;
    LPBYTE                         RetDataList;
    DWORD                          Size;
    DWORD                          OutBufSize;
    DWORD                          InBufSize;
    DWORD                          i;
    DWORD                          nArgsReturned;
    DWORD                          Error;
    BOOL                           Tmp;

    // check parameter consistency
    if( NULL == AdapterName || NULL == RequestedOpt || 0 == nRequestedOpts )
        return ERROR_INVALID_PARAMETER;

    if( NULL == AvailOpts || 0 == nAvailOpts || NULL == OptData || 0 == OptDataSize )
        return ERROR_INVALID_PARAMETER;

    if( nRequestedOpts >= OPTION_END ) return ERROR_NO_SYSTEM_RESOURCES;

    // initialize out params
    (*nAvailOpts) = (*OptDataSize) = 0;
    (*AvailOpts) = (*OptData) = NULL;

    // calculate input buffer size for ONE option to be sent and allocate it
    InBufSize = 0;
    InBufSize += sizeof(DWORD)*2;                 // INBUF_SIZE, OUTBUF_SIZE
    InBufSize += sizeof(BYTE)+sizeof(DWORD)+(1+wcslen(AdapterName))*sizeof(WCHAR);
    InBufSize += sizeof(BYTE)+sizeof(DWORD)+nRequestedOpts+sizeof(BYTE);

    InBuf = DhcpAllocateMemory(InBufSize);
    if( NULL == InBuf ) return ERROR_NOT_ENOUGH_MEMORY;

    // intialize ptrs
    OutBufSize = 0; OutBuf = NULL;
    DhcpApiArgs = NULL;
    RetOptList = RetDataList = NULL;

    // now fill the input buffer
    ((DWORD UNALIGNED*)InBuf)[0] = htonl(OutBufSize);
    ((DWORD UNALIGNED*)InBuf)[1] = 0;
    Buffer = InBuf + sizeof(DWORD); InBufSize -= sizeof(DWORD);

    Error = DhcpApiFillBuffer(Buffer, InBufSize, AdapterName, RequestParamsOpCode);
    DhcpAssert(ERROR_SUCCESS == Error);

    TmpBuf[0] = (BYTE)OPTION_PARAMETER_REQUEST_LIST;
    memcpy(&TmpBuf[1], RequestedOpt, nRequestedOpts);

    Error = DhcpApiArgAdd(Buffer, InBufSize, NormalOptionParam, nRequestedOpts+1, TmpBuf);
    DhcpAssert(ERROR_SUCCESS == Error);

    Error = ExecuteApiRequest(InBuf, NULL, &OutBufSize);
    if( ERROR_SUCCESS == Error ) {
        DhcpAssert(0 == OutBufSize);
        goto Cleanup;
    }
    if( ERROR_MORE_DATA != Error ) goto Cleanup;  // ERROR_MORE_DATA ==> need to allocate buffer

    DhcpPrint((DEBUG_OPTIONS, "RequestOptions: retrying with buffer size [%ld]\n", OutBufSize));
    DhcpAssert(OutBufSize);
    OutBuf = DhcpAllocateMemory(OutBufSize);
    if( NULL == OutBuf) {
        Error = ERROR_NOT_ENOUGH_MEMORY;
        goto Cleanup;
    }

    ((DWORD UNALIGNED*)InBuf)[0] = htonl(OutBufSize);
    Error = ExecuteApiRequest(InBuf, OutBuf, &OutBufSize);
    DhcpAssert(ERROR_MORE_DATA != Error);         // can happen, just hope it does not...
    if( ERROR_SUCCESS != Error ) goto Cleanup;    // unexpected error

    nArgsReturned = 0;
    DhcpApiArgs = NULL;
    Error = DhcpApiArgDecode(OutBuf, OutBufSize, DhcpApiArgs, &nArgsReturned );
    if( ERROR_MORE_DATA != Error ) goto Cleanup;
    DhcpAssert(nArgsReturned);
    if( 0 == nArgsReturned ) goto Cleanup;        // no options sent? funny.. still, quit its

    DhcpApiArgs = DhcpAllocateMemory(sizeof(DHCP_API_ARGS)*nArgsReturned);
    if( NULL == DhcpApiArgs ) {
        Error = ERROR_NOT_ENOUGH_MEMORY;
        goto Cleanup;
    }

    nArgsReturned = 0;
    Error = DhcpApiArgDecode(OutBuf, OutBufSize, DhcpApiArgs, &nArgsReturned);
    if( ERROR_SUCCESS != Error ) {
        DhcpAssert(FALSE);
        goto Cleanup;
    }
    DhcpAssert(nArgsReturned);

    RetOptList = DhcpAllocateMemory(nArgsReturned);
    if( NULL == RetOptList ) {
        Error = ERROR_NOT_ENOUGH_MEMORY;
        goto Cleanup;
    }

    Size = 0;
    for( i = 0; i < nArgsReturned; i ++ ) {
        DhcpAssert(DhcpApiArgs[i].ArgId == NormalOptionParam);
        if( DhcpApiArgs[i].ArgId != NormalOptionParam ) continue;
        DhcpAssert(DhcpApiArgs[i].ArgSize <= OPTION_END +1 );
        if( DhcpApiArgs[i].ArgSize <= 1 ) continue;

        Size += DhcpApiArgs[i].ArgSize;
    }
    RetDataList = DhcpAllocateMemory(Size);
    if( NULL == RetDataList ) {
        Error = ERROR_NOT_ENOUGH_MEMORY;
        goto Cleanup;
    }

    Size = 0;
    for(i = 0; i < nArgsReturned; i ++ ) {
        if( DhcpApiArgs[i].ArgId != NormalOptionParam ) continue;
        if( DhcpApiArgs[i].ArgSize <= 1 ) continue;
        RetOptList[i] = DhcpApiArgs[i].ArgVal[0];
        RetDataList[Size++] = (BYTE)(DhcpApiArgs[i].ArgSize - 1);
        memcpy(&RetDataList[Size], DhcpApiArgs[i].ArgVal, DhcpApiArgs[i].ArgSize - 1);
        Size += DhcpApiArgs[i].ArgSize - 1;
    }

    (*AvailOpts) = RetOptList;
    (*nAvailOpts) = nArgsReturned;
    (*OptData) = RetDataList;
    (*OptDataSize) = Size;

    DhcpFreeMemory(InBuf);
    DhcpFreeMemory(OutBuf);
    DhcpFreeMemory(DhcpApiArgs);

    return ERROR_SUCCESS;

  Cleanup:
    if( InBuf ) DhcpFreeMemory(InBuf);
    if( OutBuf ) DhcpFreeMemory(OutBuf);
    if( DhcpApiArgs ) DhcpFreeMemory(DhcpApiArgs);
    if( RetDataList ) DhcpFreeMemory(RetDataList);
    if( RetOptList) DhcpFreeMemory(RetOptList);
    return Error;
}
#endif
// pl dont use this api, use DhcpRequestParams instead.
DWORD                                             // win32 status
DhcpRequestOptions(                               // request for specific options
    IN      LPWSTR                 AdapterName,   // which adapter's info is needed
    IN      LPBYTE                 RequestedOpt,  // list of requested options
    IN      DWORD                  nRequestedOpts,// size of above BYTE array
    OUT     LPBYTE                *OptData,       // the data for each available option
    IN OUT  LPDWORD                OptDataSize,   // # of bytes of above byte array
    OUT     LPBYTE                *AvailOpts,     // the list of available options
    IN OUT  LPDWORD                nAvailOpts     // # of available options
) {
    DHCPAPI_PARAMS                 SendParams;
    PDHCPAPI_PARAMS                RecdParams;
    LPBYTE                         RetDataList;
    LPBYTE                         RetOptList;
    DWORD                          nRecdParams;
    DWORD                          Error;
    DWORD                          i;
    DWORD                          OutBufSize;

    // check parameter consistency
    if( NULL == AdapterName || NULL == RequestedOpt || 0 == nRequestedOpts )
        return ERROR_INVALID_PARAMETER;

    if( NULL == AvailOpts || 0 == nAvailOpts || NULL == OptData || 0 == OptDataSize )
        return ERROR_INVALID_PARAMETER;

    if( nRequestedOpts >= OPTION_END ) return ERROR_NO_SYSTEM_RESOURCES;

    // initialize out params
    (*nAvailOpts) = (*OptDataSize) = 0;
    (*AvailOpts) = (*OptData) = NULL;

    // try to process this request
    SendParams.OptionId = (BYTE)OPTION_PARAMETER_REQUEST_LIST;
    SendParams.IsVendor = FALSE;
    SendParams.Data = RequestedOpt;
    SendParams.nBytesData = nRequestedOpts;

    nRecdParams = 0;
    Error = DhcpRequestParameters(
        AdapterName,
        NULL,
        0,
        &SendParams,
        1,
        0,
        NULL,
        &nRecdParams
    );
    if( ERROR_MORE_DATA != Error ) return Error;

    while ( TRUE ) {
        DhcpAssert(nRecdParams);
        DhcpPrint((DEBUG_OPTIONS, "RequestOptions: require: 0x%lx bytes\n", nRecdParams));
        
        RecdParams = DhcpAllocateMemory(nRecdParams);
        if( NULL == RecdParams ) return ERROR_NOT_ENOUGH_MEMORY;
        
        Error = DhcpRequestParameters(
            AdapterName,
            NULL,
            0,
            &SendParams,
            1,
            0,
            RecdParams,
            &nRecdParams
            );

        // DhcpAssert(ERROR_MORE_DATA != Error);
        if( ERROR_SUCCESS != Error ) {
            DhcpPrint((DEBUG_ERRORS, "RequestOptions:RequestParams:0x%lx\n", Error));
            DhcpFreeMemory(RecdParams);
            if( ERROR_MORE_DATA == Error ) continue;
            return Error;
        }
        break;
    }

    if( 0 == nRecdParams ) return ERROR_SUCCESS;

    DhcpPrint((DEBUG_OPTIONS, "Received 0x%lx options\n", nRecdParams));

    RetOptList = NULL;
    RetDataList = NULL;
    OutBufSize = 0;
    for( i = 0; i < nRecdParams; i ++ ) {
        DhcpPrint((DEBUG_TRACE, "Received option 0x%lx, 0x%lx bytes\n",
                   RecdParams[i].OptionId, RecdParams[i].nBytesData));
        OutBufSize += RecdParams[i].nBytesData + sizeof(BYTE);
    }

    RetOptList = DhcpAllocateMemory(nRecdParams);
    RetDataList = DhcpAllocateMemory(OutBufSize);
    if( NULL == RetOptList || NULL == RetDataList ) {
        if( RetOptList ) DhcpFreeMemory(RetOptList);
        if( RetDataList ) DhcpFreeMemory(RetDataList);
        if( RecdParams ) DhcpFreeMemory(RecdParams);
        return ERROR_NOT_ENOUGH_MEMORY;
    }

    OutBufSize = 0;
    for( i = 0; i < nRecdParams ; i ++ ) {
        RetOptList[i] = (BYTE)RecdParams[i].OptionId;
        RetDataList[OutBufSize++] = (BYTE)RecdParams[i].nBytesData;
        memcpy(&RetDataList[OutBufSize], RecdParams[i].Data, RecdParams[i].nBytesData);
        OutBufSize += RecdParams[i].nBytesData;
    }

    (*AvailOpts) = RetOptList;
    (*nAvailOpts) = nRecdParams;
    (*OptData) = RetDataList;
    (*OptDataSize) = OutBufSize;

    if( RecdParams ) DhcpFreeMemory(RecdParams);

    return ERROR_SUCCESS;
}

DWORD                                             // win32 status
DhcpRequestParamsInternalEx(                      // request parameters of client
    IN      BYTE                   OpCodeParam,   // opcode to use
    IN      LPWSTR                 AdapterName,   // adapter name to request for
    IN      LPBYTE                 ClassId,       // byte stream of class id to use
    IN      DWORD                  ClassIdLen,    // # of bytes of class id to use
    IN      PDHCPAPI_PARAMS        SendParams,    // parameters to send to server
    IN      DWORD                  nSendParams,   // size of above array
    IN      DWORD                  Flags,         // must be zero, reserved
    IN OUT  PDHCPAPI_PARAMS        RecdParams,    // fill this array with received params
    IN OUT  DWORD                 *pnRecdParams,  // input: size of above array output: filled size
    IN      LPBYTE                 Bufp,          // buffer for data ptrs
    IN OUT  LPDWORD                pSize          // i/p: size of above array, o/p filled size
)
{
    PDHCP_API_ARGS                 DhcpApiArgs = NULL;
    LPBYTE                         OutBuf;
    LPBYTE                         InBuf = NULL;
    LPBYTE                         Buffer;
    LPBYTE                         Endp;
    DWORD                          OutBufSize;
    DWORD                          InBufSize;
    DWORD                          i,j;
    DWORD                          nArgsReturned;
    DWORD                          Error;
    DWORD                          nRecdParams = (*pnRecdParams);
    DWORD                          nParamsRequested;
    DWORD                          nVParamsRequested;
    ULONG                          Tmp, VTmp;
    CHAR                           TmpBuf[256], VTmpBuf[256];
    DWORD dwBufLen = 0;
    BYTE * Buf = NULL;
    BYTE OpCode;


    // check parameter consistency

    if( ClassIdLen && NULL == ClassId) return ERROR_INVALID_PARAMETER;
    if( 0 == ClassIdLen && NULL != ClassId ) return ERROR_INVALID_PARAMETER;
    if( nSendParams && NULL == SendParams) return ERROR_INVALID_PARAMETER;
    if( 0 == nSendParams && NULL != SendParams) return ERROR_INVALID_PARAMETER;
    if( NULL == RecdParams || 0 == nRecdParams ) return ERROR_INVALID_PARAMETER;
    if( NULL == AdapterName ) return ERROR_INVALID_PARAMETER;
    Tmp = VTmp = 0;
    for( i = 0; i < nRecdParams ; i ++ ) {
        if( FALSE == RecdParams[i].IsVendor ) {
            TmpBuf[ ++Tmp] = (BYTE)RecdParams[i].OptionId;
        } else {
            VTmpBuf[ ++VTmp] = (BYTE)RecdParams[i].OptionId;
        }
        if (Tmp >= sizeof(TmpBuf) - 1 || VTmp >= sizeof(VTmpBuf) - 1) {
            break;
        }
    }
    if (i < nRecdParams) return ERROR_INVALID_PARAMETER;
    if( 0 == (VTmp + Tmp) ) return ERROR_INVALID_PARAMETER;

    // allocate buffers

    OutBufSize = (*pSize);
    (*pSize) = 0;

    if( 0 ==  OutBufSize ) OutBuf = NULL;
    else {
        OutBuf = Bufp;
    }

    // calculate input buffer size required

    InBufSize = 0;
    InBufSize += (DWORD)(sizeof(DWORD)*2);                 // INBUF_SIZE, OUTBUF_SIZE
    InBufSize += (DWORD)(sizeof(BYTE)+sizeof(DWORD)+(1+wcslen(AdapterName))*sizeof(WCHAR));
    if( ClassIdLen )
        InBufSize += sizeof(BYTE)+sizeof(DWORD)+ClassIdLen;
    for( i = 0; i < nSendParams; i ++ ) {
        InBufSize += sizeof(BYTE)+sizeof(DWORD)+sizeof(BYTE)+SendParams[i].nBytesData;
    }

    //
    // Now for options request list (vendor and otherwise)
    //

    if( Tmp ) {
        InBufSize += sizeof(BYTE)+sizeof(DWORD)+sizeof(BYTE)+Tmp;
    }
    if( VTmp ) {
        InBufSize += sizeof(BYTE)+sizeof(DWORD)+sizeof(BYTE)+VTmp;
    }

    InBuf = DhcpAllocateMemory(InBufSize);
    if( NULL == InBuf ) {
        return ERROR_NOT_ENOUGH_MEMORY;
    }

    // fill up output buffer size right at start of input buffer

    ((DWORD UNALIGNED*)InBuf)[0] = htonl(OutBufSize);
    ((DWORD UNALIGNED*)InBuf)[1] = 0;

    Buffer = InBuf + sizeof(DWORD);
    InBufSize -= sizeof(DWORD);

    // fill in input buffer

    Error = DhcpApiFillBuffer(Buffer, InBufSize, AdapterName, OpCodeParam);
    DhcpAssert(ERROR_SUCCESS == Error);

    if( ClassIdLen ) {
        Error = DhcpApiArgAdd(Buffer, InBufSize, ClassIdParam, ClassIdLen, ClassId);
        DhcpAssert(ERROR_SUCCESS == Error);
    }

    for( i = 0; i < nSendParams; i ++ ) {

        //
        // Increase the Buf if needed
        //
        if (dwBufLen < SendParams[i].nBytesData + 1) {
            dwBufLen = SendParams[i].nBytesData + 1;
            if (Buf) {
                DhcpFreeMemory(Buf);
                Buf = NULL;
            }
        }

        //
        // Allocate Buf if it hasn't done yet
        //
        if (NULL == Buf) {
            Buf = DhcpAllocateMemory(dwBufLen);
        }
        if (Buf == NULL) {
            Error = ERROR_NOT_ENOUGH_MEMORY;
            goto Cleanup;
        }

        Buf[0] = (BYTE)SendParams[i].OptionId;
        memcpy(&Buf[1], SendParams[i].Data, SendParams[i].nBytesData);
        OpCode = SendParams[i].IsVendor? VendorOptionParam: NormalOptionParam;
        Error = DhcpApiArgAdd(Buffer, InBufSize, OpCode, SendParams[i].nBytesData+1, Buf);
        DhcpAssert(ERROR_SUCCESS == Error);
    }

    //
    // Now fillup the request lists (vendor & otherwise)
    //

    if( Tmp ) {
        TmpBuf[0] = (BYTE)OPTION_PARAMETER_REQUEST_LIST;
        Error = DhcpApiArgAdd(Buffer, InBufSize, NormalOptionParam, Tmp+1, TmpBuf);
        DhcpAssert(ERROR_SUCCESS == Error);
    }
    if( VTmp ) {
        VTmpBuf[0] = (BYTE)OPTION_PAD;
        Error = DhcpApiArgAdd(Buffer, InBufSize, VendorOptionParam, VTmp+1, VTmpBuf);
    }

    // now, execute and obtain the output filled in OutBuf

    Error = ExecuteApiRequest(InBuf, OutBuf, &OutBufSize);
    (*pSize) = OutBufSize;
    if( ERROR_MORE_DATA == Error ) {
        // recalculate the real OutBufSize required
        DhcpAssert(OutBufSize != 0);
        goto Cleanup;
    }

    if( ERROR_SUCCESS != Error ) goto Cleanup;
    if( 0 == OutBufSize ) goto Cleanup;

    // parse output and fill in the structures..
    nArgsReturned = 0;
    DhcpApiArgs = NULL;
    Error = DhcpApiArgDecode(OutBuf, OutBufSize, DhcpApiArgs, &nArgsReturned);
    DhcpAssert( 0 == nArgsReturned || ERROR_MORE_DATA == Error);
    if( ERROR_MORE_DATA != Error ) goto Cleanup;
    DhcpAssert(0 != nArgsReturned);
    DhcpApiArgs = DhcpAllocateMemory( sizeof(DHCP_API_ARGS) * nArgsReturned);
    if( NULL == DhcpApiArgs ) {
        Error = ERROR_NOT_ENOUGH_MEMORY;
        goto Cleanup;
    }

    Error = DhcpApiArgDecode(OutBuf, OutBufSize, DhcpApiArgs, &nArgsReturned);
    DhcpAssert(ERROR_SUCCESS == Error);
    DhcpAssert(nArgsReturned);

    for(i = j = 0; i < nArgsReturned && j < nRecdParams; i ++ ) {
        DhcpAssert( VendorOptionParam == DhcpApiArgs[i].ArgId || NormalOptionParam == DhcpApiArgs[i].ArgId);
        DhcpAssert( DhcpApiArgs[i].ArgSize > 1);  // one byte for option id, and atleast one byte actual option
        if( VendorOptionParam != DhcpApiArgs[i].ArgId && NormalOptionParam != DhcpApiArgs[i].ArgId )
            continue;
        RecdParams[j].OptionId = DhcpApiArgs[i].ArgVal[0];
        RecdParams[j].IsVendor = ( VendorOptionParam == DhcpApiArgs[i].ArgId );
        RecdParams[j].nBytesData = DhcpApiArgs[i].ArgSize-1;
        RecdParams[j].Data = &DhcpApiArgs[i].ArgVal[1];
        j ++;
    }
    (*pnRecdParams) = j;

    Error = ERROR_SUCCESS;

  Cleanup:
    if( NULL != InBuf ) DhcpFreeMemory(InBuf);
    if( NULL != DhcpApiArgs ) DhcpFreeMemory(DhcpApiArgs);
    if (NULL != Buf) DhcpFreeMemory(Buf);
    return Error;
}

DWORD                                             // win32 status
DhcpRequestParamsInternal(                        // request parameters of client
    IN      BYTE                   OpCodeParam,   // opcode to use
    IN      LPWSTR                 AdapterName,   // adapter name to request for
    IN      LPBYTE                 ClassId,       // byte stream of class id to use
    IN      DWORD                  ClassIdLen,    // # of bytes of class id to use
    IN      PDHCPAPI_PARAMS        SendParams,    // parameters to send to server
    IN      DWORD                  nSendParams,   // size of above array
    IN      DWORD                  Flags,         // must be zero, reserved
    IN OUT  PDHCPAPI_PARAMS        RecdParams,    // fill this array with received params
    IN OUT  LPDWORD                pnRecdParams   // i/p: size of above in BYTES, o/p required or filled up size
) {
    PDHCP_API_ARGS                 DhcpApiArgs = NULL;
    LPBYTE                         OutBuf;
    LPBYTE                         InBuf = NULL;
    LPBYTE                         Buffer;
    LPBYTE                         Endp;
    DWORD                          OutBufSize;
    DWORD                          InBufSize;
    DWORD                          i,j;
    DWORD                          nArgsReturned;
    DWORD                          Error;
    DWORD                          nParamsRequested;
    DWORD                          nVParamsRequested;
    ULONG                          Tmp, VTmp;
    ULONG                          OriginalOutBufSize;
        
    // check parameter consistency

    if( ClassIdLen && NULL == ClassId) return ERROR_INVALID_PARAMETER;
    if( 0 == ClassIdLen && NULL != ClassId ) return ERROR_INVALID_PARAMETER;
    if( nSendParams && NULL == SendParams) return ERROR_INVALID_PARAMETER;
    if( 0 == nSendParams && NULL != SendParams) return ERROR_INVALID_PARAMETER;
    if( NULL == pnRecdParams ) return ERROR_INVALID_PARAMETER;
    if( *pnRecdParams && NULL == RecdParams ) return ERROR_INVALID_PARAMETER;
    if( NULL == AdapterName ) return ERROR_INVALID_PARAMETER;
    Tmp = VTmp = 0;
    for( i = 0; i < nSendParams ; i ++ ) {
        if( SendParams[i].nBytesData > OPTION_END ) return ERROR_INVALID_PARAMETER;
        if( SendParams[i].nBytesData && NULL == SendParams[i].Data )
            return ERROR_INVALID_PARAMETER;
        if( OPTION_PARAMETER_REQUEST_LIST == SendParams[i].OptionId ) {
            if( SendParams[i].IsVendor ) continue;
            nParamsRequested = SendParams[i].nBytesData;
            Tmp ++;
        }
        if( OPTION_PAD == SendParams[i].OptionId ) {
            if( !SendParams[i].IsVendor ) continue;
            nVParamsRequested = SendParams[i].nBytesData;
            VTmp ++;
        }
    }
    if( 0 == (VTmp + Tmp) || 1 < VTmp || 1 < Tmp ) return ERROR_INVALID_PARAMETER;
    if( 0 == Tmp) nParamsRequested = 0;
    if( VTmp ) nParamsRequested += nVParamsRequested;

    // allocate buffers

    OriginalOutBufSize = OutBufSize = (*pnRecdParams);
    (*pnRecdParams) = 0;

    if( 0 ==  OutBufSize ) OutBuf = NULL;
    else {
        OutBuf = DhcpAllocateMemory(OutBufSize);
        if( NULL == OutBuf ) return ERROR_NOT_ENOUGH_MEMORY;
    }

    // calculate input buffer size required

    InBufSize = 0;
    InBufSize += (DWORD)(sizeof(DWORD)*2);                 // INBUF_SIZE, OUTBUF_SIZE
    InBufSize += (DWORD)(sizeof(BYTE)+sizeof(DWORD)+(1+wcslen(AdapterName))*sizeof(WCHAR));
    if( ClassIdLen )
        InBufSize += sizeof(BYTE)+sizeof(DWORD)+ClassIdLen;
    for( i = 0; i < nSendParams; i ++ ) {
        InBufSize += sizeof(BYTE)+sizeof(DWORD)+sizeof(BYTE)+SendParams[i].nBytesData;
    }
    InBuf = DhcpAllocateMemory(InBufSize);
    if( NULL == InBuf ) {
        DhcpFreeMemory(OutBuf);
        return ERROR_NOT_ENOUGH_MEMORY;
    }

    // fill up output buffer size right at start of input buffer

    ((DWORD UNALIGNED*)InBuf)[0] = htonl(OutBufSize);
    ((DWORD UNALIGNED*)InBuf)[1] = 0;

    Buffer = InBuf + sizeof(DWORD);
    InBufSize -= sizeof(DWORD);

    // fill in input buffer

    Error = DhcpApiFillBuffer(Buffer, InBufSize, AdapterName, OpCodeParam);
    DhcpAssert(ERROR_SUCCESS == Error);

    if( ClassIdLen ) {
        Error = DhcpApiArgAdd(Buffer, InBufSize, ClassIdParam, ClassIdLen, ClassId);
        DhcpAssert(ERROR_SUCCESS == Error);
    }

    for( i = 0; i < nSendParams; i ++ ) {
        BYTE Buf[OPTION_END+1];
        BYTE OpCode;

        Buf[0] = (BYTE)SendParams[i].OptionId;
        memcpy(&Buf[1], SendParams[i].Data, SendParams[i].nBytesData);
        OpCode = SendParams[i].IsVendor? VendorOptionParam: NormalOptionParam;
        Error = DhcpApiArgAdd(Buffer, InBufSize, OpCode, SendParams[i].nBytesData+1, Buf);
        DhcpAssert(ERROR_SUCCESS == Error);
    }

    // now, execute and obtain the output filled in OutBuf

    Error = ExecuteApiRequest(InBuf, OutBuf, &OutBufSize);
    if( ERROR_MORE_DATA == Error ) {
        // recalculate the real OutBufSize required
        DhcpAssert(OutBufSize != 0);
        OutBufSize += nParamsRequested*(sizeof(DHCPAPI_PARAMS) - (2*sizeof(BYTE)+sizeof(DWORD)));
        (*pnRecdParams) = OutBufSize;
        goto Cleanup;
    }

    if( ERROR_SUCCESS != Error ) goto Cleanup;
    if( 0 == OutBufSize ) goto Cleanup;

    // parse output and fill in the structures..
    nArgsReturned = 0;
    DhcpApiArgs = NULL;
    Error = DhcpApiArgDecode(OutBuf, OutBufSize, DhcpApiArgs, &nArgsReturned);
    DhcpAssert( 0 == nArgsReturned || ERROR_MORE_DATA == Error);
    if( ERROR_MORE_DATA != Error ) goto Cleanup;
    DhcpAssert(0 != nArgsReturned);
    DhcpApiArgs = DhcpAllocateMemory( sizeof(DHCP_API_ARGS) * nArgsReturned);
    if( NULL == DhcpApiArgs ) {
        Error = ERROR_NOT_ENOUGH_MEMORY;
        goto Cleanup;
    }

    Error = DhcpApiArgDecode(OutBuf, OutBufSize, DhcpApiArgs, &nArgsReturned);
    DhcpAssert(ERROR_SUCCESS == Error);
    DhcpAssert(nArgsReturned);

    if( OriginalOutBufSize < OutBufSize + nParamsRequested*(sizeof(DHCPAPI_PARAMS) - (2*sizeof(BYTE)+sizeof(DWORD)) ) ) {
        //
        // Input size is not sufficient
        //
        (*pnRecdParams ) = OutBufSize + nParamsRequested*(
            sizeof(DHCPAPI_PARAMS) - (2*sizeof(BYTE)+sizeof(DWORD) )
            );
        Error = ERROR_MORE_DATA;
        // DbgPrint("Bug 330419 repro'ed");
        goto Cleanup;
    }
    
    Endp = OutBufSize + (LPBYTE)RecdParams + nParamsRequested*(sizeof(DHCPAPI_PARAMS) - (2*sizeof(BYTE)+sizeof(DWORD)));
    
    for(i = j = 0; i < nArgsReturned; i ++ ) {
        DhcpAssert( VendorOptionParam == DhcpApiArgs[i].ArgId || NormalOptionParam == DhcpApiArgs[i].ArgId);
        DhcpAssert( DhcpApiArgs[i].ArgSize > 1);  // one byte for option id, and atleast one byte actual option
        if( VendorOptionParam != DhcpApiArgs[i].ArgId && NormalOptionParam != DhcpApiArgs[i].ArgId )
            continue;
        RecdParams[j].OptionId = DhcpApiArgs[i].ArgVal[0];
        RecdParams[j].IsVendor = ( VendorOptionParam == DhcpApiArgs[i].ArgId );
        RecdParams[j].nBytesData = DhcpApiArgs[i].ArgSize-1;
        Endp -= RecdParams[j].nBytesData;
        memcpy(Endp, &DhcpApiArgs[i].ArgVal[1], RecdParams[j].nBytesData);
        RecdParams[j].Data = Endp;
        j ++;
    }

    DhcpAssert(((LPBYTE)&RecdParams[j]) <= Endp);

    *pnRecdParams = j;
    Error = ERROR_SUCCESS;

  Cleanup:
    DhcpFreeMemory(InBuf);
    if(OutBuf) DhcpFreeMemory(OutBuf);
    if(DhcpApiArgs) DhcpFreeMemory(DhcpApiArgs);
    return Error;
}

DWORD                                             // win32 status
APIENTRY
DhcpRequestParameters(                                // request parameters of client
    IN      LPWSTR                 AdapterName,   // adapter name to request for
    IN      LPBYTE                 ClassId,       // byte stream of class id to use
    IN      DWORD                  ClassIdLen,    // # of bytes of class id to use
    IN      PDHCPAPI_PARAMS        SendParams,    // parameters to send to server
    IN      DWORD                  nSendParams,   // size of above array
    IN      DWORD                  Flags,         // must be zero, reserved
    IN OUT  PDHCPAPI_PARAMS        RecdParams,    // fill this array with received params
    IN OUT  LPDWORD                pnRecdParams   // i/p: size of above in BYTES, o/p required or filled up size
) {
    return DhcpRequestParamsInternal(
        RequestParamsOpCode,
        AdapterName,
        ClassId,
        ClassIdLen,
        SendParams,
        nSendParams,
        Flags,
        RecdParams,
        pnRecdParams
    );
}

DWORD                                             // win32 status
DhcpRegisterParameterChangeNotificationInternal(  // notify if a parameter has changed -- common between NT and VxD
    IN      LPWSTR                 AdapterName,   // adapter of interest
    IN      LPBYTE                 ClassId,       // byte stream of class id to use
    IN      DWORD                  ClassIdLen,    // # of bytes of class id
    IN      PDHCPAPI_PARAMS        Params,        // params of interest
    IN      DWORD                  nParams,       // # of elts in above array
    IN      DWORD                  Flags,         // must be zero, reserved
    IN      DWORD                  Descriptor,    // thsi describes the event uniquely for this process
    IN      HANDLE                 hEvent         // handle to event that will be SetEvent'ed in case of param change
) {
    LPBYTE                         InBuf;
    LPBYTE                         OptList;
    LPBYTE                         VendorOptList;
    LPBYTE                         Buffer;
    DWORD                          Error;
    DWORD                          InBufSize;
    DWORD                          nVendorOpts;
    DWORD                          nOpts;
    DWORD                          ProcId;
    DWORD                          OutBufSize;
    DWORD                          i;

    VendorOptList = OptList = NULL;
    nVendorOpts = nOpts = 0;

    InBufSize = 2*sizeof(DWORD);                  // expected outbuf size + inbuf size
    InBufSize += sizeof(BYTE) + 2*sizeof(DWORD);  // Proc Id
    InBufSize += sizeof(BYTE) + 2*sizeof(DWORD);  // Event Handle
    InBufSize += sizeof(BYTE) + 2*sizeof(DWORD);  // Descriptor

    InBufSize += (DWORD)(sizeof(Descriptor)+sizeof(hEvent)+sizeof(DWORD));
    InBufSize += (DWORD)(sizeof(BYTE)+sizeof(DWORD)+(1+wcslen(AdapterName))*sizeof(WCHAR));
    if( ClassIdLen )
        InBufSize += sizeof(BYTE)+sizeof(DWORD)+ClassIdLen;

    for( i = 0; i < nParams; i ++ ) {
        if( OPTION_PARAMETER_REQUEST_LIST == Params[i].OptionId ) {
            if( Params[i].IsVendor ) continue;
            if( nOpts ) return ERROR_INVALID_PARAMETER;
            nOpts = Params[i].nBytesData;
            if( 0 == nOpts ) return ERROR_INVALID_PARAMETER;
            OptList = Params[i].Data;
            continue;
        }

        if( OPTION_PAD == Params[i].OptionId ) {
            if( ! Params[i].IsVendor ) continue;
            if( nVendorOpts ) return ERROR_INVALID_PARAMETER;
            nVendorOpts = Params[i].nBytesData;
            if( 0 == nVendorOpts ) return ERROR_INVALID_PARAMETER;
            VendorOptList = Params[i].Data;
            continue;
        }
    }
    if( 0 == nOpts + nVendorOpts ) return ERROR_INVALID_PARAMETER;

    if( nOpts ) InBufSize += sizeof(BYTE) + sizeof(DWORD) + nOpts;
    if( nVendorOpts ) InBufSize += sizeof(BYTE) + sizeof(DWORD) + nVendorOpts;

    InBuf = DhcpAllocateMemory(InBufSize);
    if( NULL == InBuf ) {
        return ERROR_NOT_ENOUGH_MEMORY;
    }

    Buffer = InBuf + sizeof(DWORD);
    ((DWORD UNALIGNED*)InBuf)[0] = 0;             // dont expect anything in return other than status
    ((DWORD UNALIGNED*)Buffer)[0] = 0;            // increase the input buffer size each time we add something
    InBufSize -= sizeof(DWORD);                   // ignore the first DWORD

    Error = DhcpApiFillBuffer(Buffer, InBufSize, AdapterName, RegisterParamsOpCode);
    DhcpAssert(ERROR_SUCCESS == Error );

    if( ClassIdLen ) {
        Error = DhcpApiArgAdd(Buffer, InBufSize, ClassIdParam, ClassIdLen, ClassId);
        DhcpAssert(ERROR_SUCCESS == Error);
    }

    if( nOpts ) {
        Error = DhcpApiArgAdd(Buffer, InBufSize, NormalOptionParam, nOpts, OptList);
        DhcpAssert(ERROR_SUCCESS == Error);
    }

    if( nVendorOpts ) {
        Error = DhcpApiArgAdd(Buffer, InBufSize, VendorOptionParam, nVendorOpts, VendorOptList);
        DhcpAssert(ERROR_SUCCESS == Error);
    }

    ProcId = GetCurrentProcessId();
    Error = DhcpApiArgAdd(Buffer, InBufSize, ProcIdParam, sizeof(ProcId), (LPBYTE) &ProcId);
    DhcpAssert(ERROR_SUCCESS == Error);

    Error = DhcpApiArgAdd(Buffer, InBufSize, DescriptorParam, sizeof(Descriptor), (LPBYTE) &Descriptor);
    DhcpAssert(ERROR_SUCCESS == Error);

    Error = DhcpApiArgAdd(Buffer, InBufSize, EventHandleParam, sizeof(hEvent), (LPBYTE) &hEvent);
    DhcpAssert(ERROR_SUCCESS == Error);

    OutBufSize = 0;
    Error = ExecuteApiRequest(InBuf, NULL, &OutBufSize);
    DhcpFreeMemory(InBuf);
    DhcpAssert(ERROR_MORE_DATA != Error );

    return Error;
}

DWORD                                             // Ring 0 handle -- used only on win9x platform
VxDGetDescriptor(                                 // convert Event to Ring0 handle for use in vdhcp.vxd
    IN      HANDLE                 Event,
    IN OUT  LPDWORD                pDescriptor
) {
    HANDLE                         Kernel32;
    DWORD                          (*HandleToRing0Handle)(HANDLE);
    DWORD                          RetVal;

    Kernel32 = LoadLibraryA("kernel32.dll");
    if( NULL == Kernel32 ) return GetLastError();

    HandleToRing0Handle = (DWORD (*)(HANDLE))GetProcAddress(Kernel32, "OpenVxDHandle");
    if( NULL == HandleToRing0Handle ) {
        CloseHandle(Kernel32);
        return GetLastError();
    }

    (*pDescriptor) = HandleToRing0Handle(Event);
    CloseHandle(Kernel32);

    if( 0 == (*pDescriptor) ) return ERROR_INVALID_PARAMETER;

    return ERROR_SUCCESS;
}

DWORD                                             // win32 status
DhcpCreateApiEventAndDescriptor(                  // create both the api event handle and the unique descriptor for it
    IN OUT  LPHANDLE               hEvent,        // fill this with a valid event handle if succeeded
    IN OUT  LPDWORD                pDescriptor    // this descriptor is unique for this process.
) {
    static  DWORD                  Descriptor = 1;// use this for the descriptor
    OSVERSIONINFO                  OsVersion;     // need to know if NT or Win95+
    BOOL                           BoolError;
    CHAR                           NameBuf[sizeof("DhcpPid-1-2-3-4-5-6-7-8UniqueId-1-2-3-4-5-6-7-8")];
    DWORD                          Error;

    // *** changing NameBuf's format requires change in apiimpl.c NotifyClients...*

    OsVersion.dwOSVersionInfoSize = sizeof(OsVersion);
    BoolError = GetVersionEx(&OsVersion);
    if( FALSE == BoolError ) return GetLastError();

    if( VER_PLATFORM_WIN32_WINDOWS == OsVersion.dwPlatformId ) {
        (*hEvent) = CreateEvent(
            NULL,                                 // no security
            FALSE,                                // auto reset
            FALSE,                                // intially signaled? NO
            NULL                                  // no name
        );
    } else {
        (*pDescriptor) = InterlockedIncrement(pDescriptor);
        sprintf(NameBuf, "DhcpPid%16xUniqueId%16x", GetCurrentProcessId(), *pDescriptor);

        (*hEvent) = CreateEventA(                 // now create the required event
            NULL,                                 // no security
            FALSE,                                // automatic reset
            FALSE,                                // intially signalled? NO!
            NameBuf                               // the name to use to create
        );
    }

    if( NULL == (*hEvent) ) return GetLastError();

    if( VER_PLATFORM_WIN32_WINDOWS != OsVersion.dwPlatformId )
        return ERROR_SUCCESS;                     // done for NT.

    // for Memphis, need to get OpenVxdHandle procedure to get Descriptor value
    Error = VxDGetDescriptor(*hEvent, pDescriptor);
    if( ERROR_SUCCESS != Error ) {
        CloseHandle(*hEvent);
    }

    return Error;
}

DWORD                                             // win32 status
DhcpRegisterParameterChangeNotification(          // notify if a parameter has changed
    IN      LPWSTR                 AdapterName,   // adapter of interest
    IN      LPBYTE                 ClassId,       // byte stream of class id to use
    IN      DWORD                  ClassIdLen,    // # of bytes of class id
    IN      PDHCPAPI_PARAMS        Params,        // params of interest
    IN      DWORD                  nParams,       // # of elts in above array
    IN      DWORD                  Flags,         // must be zero, reserved
    IN OUT  PHANDLE                hEvent         // handle to event that will be SetEvent'ed in case of param change
) {
    DWORD                          Descriptor;    // on NT this is an id unique across this process, on VxD ring0 handle
    DWORD                          Error;         //
    DWORD                          i;

    if( 0 == ClassIdLen && NULL != ClassId ) return ERROR_INVALID_PARAMETER;
    if( 0 != ClassIdLen && NULL == ClassId ) return ERROR_INVALID_PARAMETER;
    if( 0 == nParams && NULL != Params ) return ERROR_INVALID_PARAMETER;
    if( 0 != nParams && NULL == Params ) return ERROR_INVALID_PARAMETER;
    if( Flags ) return ERROR_INVALID_PARAMETER;
    if( NULL == hEvent ) return ERROR_INVALID_PARAMETER;
    for( i = 0; i < nParams ; i ++ ) {
        if( Params[i].nBytesData > OPTION_END ) return ERROR_INVALID_PARAMETER;
        if( Params[i].nBytesData && NULL == Params[i].Data )
            return ERROR_INVALID_PARAMETER;
    }

    Error = DhcpCreateApiEventAndDescriptor(hEvent, &Descriptor);
    if( ERROR_SUCCESS != Error ) return Error;

    Error = DhcpRegisterParameterChangeNotificationInternal(
        AdapterName,
        ClassId,
        ClassIdLen,
        Params,
        nParams,
        Flags,
        Descriptor,
        (*hEvent)
    );

    if( ERROR_SUCCESS != Error ) {
        CloseHandle(*hEvent);
        *hEvent = NULL;
        return Error;
    }

    return ERROR_SUCCESS;
}

DhcpDeRegisterParameterChangeNotification(        // undo the registration
    IN      HANDLE                 Event          // handle to event returned by DhcpRegisterParameterChangeNotification, NULL ==> everything
) {
    DWORD                          Error;
    DWORD                          Descriptor;
    DWORD                          ProcId;
    DWORD                          InBufSize;
    DWORD                          OutBufSize;
    LPBYTE                         InBuf;
    LPBYTE                         Buffer;

    InBufSize = 2*sizeof(DWORD);                  // input/output sizes
    InBufSize += sizeof(BYTE) + sizeof(DWORD);    // opcode
    InBufSize += sizeof(BYTE) + sizeof(DWORD)*2;  // proc id
    InBufSize += sizeof(BYTE) + sizeof(DWORD)*2;  // handle

    InBuf = DhcpAllocateMemory(InBufSize);
    if( NULL == InBuf ) return ERROR_NOT_ENOUGH_MEMORY;

    Buffer = InBuf + sizeof(DWORD);
    ((DWORD UNALIGNED*)InBuf)[0] = 0;             // nothing expected in return
    ((DWORD UNALIGNED*)Buffer)[0] = 0;            // initialize size to zero -- will be increased each time something is added

    Error = DhcpApiFillBuffer(Buffer, InBufSize, NULL, DeRegisterParamsOpCode);
    DhcpAssert(ERROR_SUCCESS == Error);

    ProcId = GetCurrentProcessId();

    Error = DhcpApiArgAdd(Buffer, InBufSize, ProcIdParam, sizeof(ProcId), (LPBYTE)&ProcId);
    DhcpAssert(ERROR_SUCCESS == Error);

    Error = DhcpApiArgAdd(Buffer, InBufSize, EventHandleParam, sizeof(Event), (LPBYTE) &Event);
    DhcpAssert(ERROR_SUCCESS == Error);

    OutBufSize = 0;
    Error = ExecuteApiRequest(InBuf, NULL, &OutBufSize);
    DhcpFreeMemory(InBuf);
    DhcpAssert(ERROR_MORE_DATA != Error);

    if( ERROR_SUCCESS == Error ) {
        CloseHandle(Event);
    }

    return Error;
}

DWORD                                             // win32 status
DhcpRegistryFillParamsList(                       // read the registry value and add this list of values to it
    IN      LPWSTR                 AppName,       // prefix for key
    IN      DWORD                  nSendParams    // # of values to add
) {
    HKEY                           DhcpOptionKey;
    LPWSTR                         OldValueName;
    LPWSTR                         NewValueName;
    LPWSTR                         ValueName;
    LPWSTR                         Tmp, Tmp2;
    BOOL                           fOldValueExists = FALSE;
    DWORD                          ValueNameSize;
    DWORD                          OldValueNameSize;
    DWORD                          NewValueNameSize;
    DWORD                          Error;
    DWORD                          i;

    Error = RegOpenKeyEx(                         // open the dhcp option key first
        HKEY_LOCAL_MACHINE,
        DHCP_CLIENT_OPTION_KEY,
        0 /* Reserved */,
        DHCP_CLIENT_KEY_ACCESS,
        &DhcpOptionKey
    );
    if( ERROR_SUCCESS != Error ) return Error;

    OldValueName = NULL;
    Error = GetRegistryString(
        DhcpOptionKey,
        DHCP_OPTION_LIST_VALUE,
        &OldValueName,
        &OldValueNameSize
    );

    if( ERROR_SUCCESS != Error ) {
        OldValueName = DEFAULT_DHCP_KEYS_LIST_VALUE;
        OldValueNameSize = sizeof(DEFAULT_DHCP_KEYS_LIST_VALUE);
    } else {
        fOldValueExists = TRUE;
    }

    NewValueNameSize = OldValueNameSize;

    ValueNameSize = 0;
    ValueNameSize += wcslen(AppName)*sizeof(WCHAR);
    ValueNameSize += sizeof(L"\\12345");

    ValueName = DhcpAllocateMemory(ValueNameSize);
    if( NULL == ValueName ) {
        RegCloseKey(DhcpOptionKey);
        if( fOldValueExists ) DhcpFreeMemory(OldValueName);
        return ERROR_NOT_ENOUGH_MEMORY;
    }

    NewValueNameSize = nSendParams*ValueNameSize + OldValueNameSize;
    NewValueName = DhcpAllocateMemory(NewValueNameSize);
    if( NULL == NewValueName ) {
        RegCloseKey(DhcpOptionKey);
        if( fOldValueExists ) DhcpFreeMemory(OldValueName);
        DhcpFreeMemory(ValueName);
        return ERROR_NOT_ENOUGH_MEMORY;
    }

    wcscpy(ValueName, AppName);
    wcscat(ValueName, L"\\");

    Tmp = NewValueName;
    for( i = 0; i < nSendParams ; i ++ ) {        // for each value, add its to the list
        wcscpy(Tmp, ValueName);
        Tmp += wcslen(Tmp);
        swprintf(Tmp, L"%5x", i);
        Tmp += wcslen(Tmp);
        Tmp ++;                                   // move the ptr off the last L'\0'
    }
    DhcpFreeMemory(ValueName);

    Tmp2 = OldValueName;
    while(wcslen(Tmp2)) {
        wcscpy(Tmp, Tmp2);
        Tmp += wcslen(Tmp2);
        Tmp2 += wcslen(Tmp2);
        Tmp ++;
        Tmp2 ++;
    }

    *Tmp++ = L'\0';

    if(fOldValueExists ) DhcpFreeMemory(OldValueName);

    Error = RegSetValueEx(                        // write this string back
        DhcpOptionKey,
        DHCP_OPTION_LIST_VALUE,
        0 /* Reserved */,
        REG_MULTI_SZ,
        (LPBYTE) NewValueName,
        (ULONG)(((LPBYTE)Tmp) - ((LPBYTE)NewValueName))
    );
    DhcpFreeMemory(NewValueName);
    RegCloseKey(DhcpOptionKey);

    if( ERROR_SUCCESS != Error ) {
        DhcpPrint((DEBUG_ERRORS, "RegSetValueEx(OPTION_LIST):0x%lx\n", Error));
    }

    return Error;
}

DWORD                                             // win32 status
DhcpRegistryFillParams(                           // make a subkey and fill in the details
    IN      LPWSTR                 AdapterName,   // NULL ==> global change
    IN      LPBYTE                 ClassId,       // this is the class of the option
    IN      DWORD                  ClassIdLen,    // # of bytes of above
    IN      DWORD                  i,             // key index is 3hex-digit convertion onf this
    IN      HKEY                   Key,           // use this key for creating subkeys
    IN      PDHCPAPI_PARAMS        SendParam,     // ptr to structure to use for this one key write operation
    IN      LPWSTR                 AppName        // name of app
) {
    HKEY                           SubKey;
    WCHAR                          KeyName[7];    // key is just 5 bytes
    LPWSTR                         SendLocation;
    LPWSTR                         ValueName;
    LPBYTE                         SendData;
    DWORD                          SendDataSize;
    DWORD                          Size;
    DWORD                          Disposition;
    DWORD                          Error;
    DWORD                          OptionId;
    DWORD                          IsVendor;
    DWORD                          DummyKeyType;

    swprintf(KeyName, L"%5x", i);

    OptionId = SendParam->OptionId;
    IsVendor = SendParam->IsVendor;
    SendData = SendParam->Data;
    SendDataSize = SendParam->nBytesData;

    Size = wcslen(AppName)*sizeof(WCHAR)+sizeof(KeyName) + sizeof(L"\\");
    if( AdapterName ) {
        Size += (DWORD)(sizeof(DHCP_SERVICES_KEY) + sizeof(DHCP_ADAPTER_PARAMETERS_KEY) + wcslen(AdapterName)*sizeof(WCHAR));
    } else {
        Size += sizeof(DHCP_TCPIP_PARAMETERS_KEY);
    }
    SendLocation = DhcpAllocateMemory(Size);
    if( NULL == SendLocation ) return ERROR_NOT_ENOUGH_MEMORY;

    if( AdapterName ) {
        wcscpy(SendLocation, DHCP_SERVICES_KEY DHCP_ADAPTER_PARAMETERS_KEY);
        wcscat(SendLocation, L"\\?\\");
    } else {
        wcscpy(SendLocation, DHCP_TCPIP_PARAMETERS_KEY);
    }
    wcscat(SendLocation, AppName);
    wcscat(SendLocation, KeyName);

    Error = RegCreateKeyEx(                       // create the option key
        Key,
        KeyName,
        0 /* Reserved */,
        DHCP_CLASS,
        REG_OPTION_NON_VOLATILE,
        KEY_ALL_ACCESS,
        NULL,
        &SubKey,
        &Disposition
    );
    if( ERROR_SUCCESS != Error ) {
        DhcpFreeMemory(SendLocation);
        return Error;
    }

    DhcpAssert(REG_CREATED_NEW_KEY == Disposition);

    Error = RegSetValueEx(                        // now create each of the values -- OPTION ID
        SubKey,
        DHCP_OPTION_OPTIONID_VALUE,
        0 /* Reserved */,
        DHCP_OPTION_OPTIONID_TYPE,
        (LPBYTE)&OptionId,
        sizeof(OptionId)
    );
    DhcpAssert(ERROR_SUCCESS == Error);

    Error = RegSetValueEx(                        // IS VENDOR
        SubKey,
        DHCP_OPTION_ISVENDOR_VALUE,
        0 /* Reserved */,
        DHCP_OPTION_ISVENDOR_TYPE,
        (LPBYTE) (&IsVendor),
        sizeof(IsVendor)
    );
    DhcpAssert(ERROR_SUCCESS == Error);

    if( ClassIdLen ) {
        Error = RegSetValueEx(                    // CLASS ID
            SubKey,
            DHCP_OPTION_CLASSID_VALUE,
            0 /* Reserved */,
            REG_BINARY,
            ClassId,
            ClassIdLen
        );
        DhcpAssert(ERROR_SUCCESS == Error);
    }

    Error = RegSetValueEx(
        SubKey,
        DHCP_OPTION_SEND_LOCATION_VALUE,
        0 /* Reserved */,
        REG_SZ,
        (LPBYTE)SendLocation,
        (wcslen(SendLocation)+1)*sizeof(WCHAR)
    );
    DhcpAssert(ERROR_SUCCESS == Error);

    DummyKeyType = REG_DWORD;                    // KeyType
    Error = RegSetValueEx(
        SubKey,
        DHCP_OPTION_SAVE_TYPE_VALUE,
        0 /* Reserved */,
        DHCP_OPTION_SAVE_TYPE_TYPE,
        (LPBYTE)&DummyKeyType,
        sizeof(DummyKeyType));
    DhcpAssert(ERROR_SUCCESS == Error);

    RegCloseKey(SubKey);

    if( AdapterName ) {
        wcscpy(SendLocation, DHCP_SERVICES_KEY DHCP_ADAPTER_PARAMETERS_KEY);
        wcscat(SendLocation, L"\\");
        wcscat(SendLocation, AdapterName);
    } else {
        wcscpy(SendLocation, DHCP_TCPIP_PARAMETERS_KEY);
    }

    ValueName = wcslen(SendLocation) + 1 + SendLocation;
    wcscpy(ValueName, AppName);
    wcscat(ValueName, KeyName);

    Error = RegOpenKeyEx(
        HKEY_LOCAL_MACHINE,
        SendLocation,
        0 /* Reserved */,
        KEY_ALL_ACCESS,
        &SubKey
    );
    if( ERROR_SUCCESS != Error ) {
        DhcpFreeMemory(SendLocation);
        return Error;
    }

    Error = RegSetValueEx(
        SubKey,
        ValueName,
        0 /* Reserved */,
        REG_BINARY,
        SendData,
        SendDataSize
    );
    DhcpAssert(ERROR_SUCCESS == Error);
    RegCloseKey(SubKey);
    DhcpFreeMemory(SendLocation);

    return ERROR_SUCCESS;
}

DWORD                                             // win32 status
DhcpRegistryCreateUniqueKey(                      // create a unique key with prefix AppName
    IN      LPWSTR                 AppName,       // some App descriptor
    IN OUT  HKEY*                  Key            // return the opened key here
) {
    DWORD                          FullKeyNameSize, Disposition;
    DWORD                          Error;
    LPWSTR                         FullKeyName;

    FullKeyNameSize = sizeof(DHCP_CLIENT_OPTION_KEY);
    FullKeyNameSize += wcslen(AppName)*sizeof(WCHAR) + sizeof(WCHAR);
    FullKeyName = DhcpAllocateMemory(FullKeyNameSize);
    if( NULL == FullKeyName ) return ERROR_NOT_ENOUGH_MEMORY;

    wcscpy(FullKeyName, DHCP_CLIENT_OPTION_KEY);
    wcscat(FullKeyName, L"\\");
    wcscat(FullKeyName, AppName);

    Error = RegCreateKeyEx(
        HKEY_LOCAL_MACHINE,
        FullKeyName,
        0 /* Reserved */,
        DHCP_CLASS,
        REG_OPTION_NON_VOLATILE,
        KEY_ALL_ACCESS,
        NULL,
        Key,
        &Disposition
    );

    DhcpFreeMemory(FullKeyName);
    if( ERROR_SUCCESS != Error ) return Error;

    if( REG_OPENED_EXISTING_KEY == Disposition ) {
        RegCloseKey(*Key);
        return ERROR_ALREADY_EXISTS;
    }

    return ERROR_SUCCESS;
}

DWORD                                             // win32 status
DhcpRegistryPersistentRequestParams(              // edit registry to consider this additional persistent request
    IN      LPWSTR                 AdapterName,   // which adapter is this request for?
    IN      LPBYTE                 ClassId,       // class
    IN      DWORD                  ClassIdLen,    // # of bytes in class id
    IN      PDHCPAPI_PARAMS        SendParams,    // the actual parameters to fill up
    IN      DWORD                  nSendParams,   // the size of the above array
    IN      PDHCPAPI_PARAMS        RecdParams,    // would like to receive these
    IN      DWORD                  nRecdParams,   // count..
    IN      LPWSTR                 AppName        // some thing unique about the app that wants to do registrations
) {
    HKEY                           Key;
    DWORD                          i;
    DWORD                          Error;
    DWORD                          LastError;
    DHCPAPI_PARAMS                 NonVendorParams;
    ULONG                          nVendorOpt, nNonVendorOpt;
    CHAR                           Buf[256];

    if( NULL == AppName ) return ERROR_INVALID_PARAMETER;
    if( 0 == nSendParams && NULL != SendParams ) return ERROR_INVALID_PARAMETER;
    if( 0 != nSendParams && NULL == SendParams ) return ERROR_INVALID_PARAMETER;
    if( 0 != nRecdParams && NULL == RecdParams ) return ERROR_INVALID_PARAMETER;
    if( 0 == nRecdParams && NULL != RecdParams ) return ERROR_INVALID_PARAMETER;
    if( ClassIdLen && NULL == ClassId || 0 == ClassIdLen && NULL != ClassId)
        return ERROR_INVALID_PARAMETER;

    for( i = 0; i < nSendParams; i ++ ) {
        if( SendParams[i].nBytesData == 0 ) return ERROR_INVALID_PARAMETER;
    }

    nVendorOpt = nNonVendorOpt = 0;

    // --ft: 07/25/00 fixes the way the non-vendor options
    // are collected from RecdParams.
    for (i = 0; i < nRecdParams; i++)
    {
        if (RecdParams[i].IsVendor)
        {
            nVendorOpt = 1;
        }
        else
        {
            Buf[nNonVendorOpt++] = (BYTE)RecdParams[i].OptionId;
        }
    }

    // if nVendorOpt is 1 this means we have at least one vendor option in
    // the requested parameters list. Make sure then OPTION_VENDOR_SPEC_INFO
    // is mentioned in the array to be sent as OPTION_PARAMETER_REQUEST_LIST
    if( nVendorOpt ) {
        for( i = 0; i < nNonVendorOpt ; i ++ )
            if( Buf[i] == OPTION_VENDOR_SPEC_INFO )
                break;

        if( i == nNonVendorOpt ) Buf[nNonVendorOpt ++] = (BYTE)OPTION_VENDOR_SPEC_INFO;
    }

    NonVendorParams.Flags = 0;
    NonVendorParams.OptionId = OPTION_PARAMETER_REQUEST_LIST;
    NonVendorParams.IsVendor = FALSE;
    NonVendorParams.Data = Buf;
    NonVendorParams.nBytesData = nNonVendorOpt;

    Error = DhcpRegistryCreateUniqueKey(          // first try creating the key
        AppName,
        &Key
    );
    if( ERROR_SUCCESS != Error ) return Error;


    Error = DhcpRegistryFillParamsList(
        AppName,
        nSendParams + (nNonVendorOpt?1:0)
    );
    if( ERROR_SUCCESS != Error ) {
        DhcpAssert(FALSE);
        DhcpPrint((DEBUG_ERRORS, "DhcpRegistryFillParamsList:0x%lx\n", Error));
        RegCloseKey(Key);
        return Error;
    }

    LastError = ERROR_SUCCESS;
    for( i = 0; i < nSendParams; i ++ ) {         // now enter the particular option in the registry
        Error = DhcpRegistryFillParams(
            AdapterName,
            ClassId,
            ClassIdLen,
            i,
            Key,
            &SendParams[i],
            AppName
        );
        if( ERROR_SUCCESS != Error ) {
            DhcpAssert(FALSE);
            DhcpPrint((DEBUG_ERRORS, "DhcpRegistryFillParams:0x%lx\n", Error));
            LastError = Error;
        }
    }
    if( nNonVendorOpt ) {
        Error = DhcpRegistryFillParams(
            AdapterName,
            ClassId,
            ClassIdLen,
            i ++,
            Key,
            &NonVendorParams,
            AppName
        );
        if( ERROR_SUCCESS != Error ) {
            DhcpAssert(FALSE);
            DhcpPrint((DEBUG_ERRORS, "DhcpRegistryFillParams:0x%lx\n", Error));
            LastError = Error;
        }
    }

    RegCloseKey(Key);
    return LastError;
}

// Please note that AppName must be unique for each request (and if it is not, things are
// likely to behave weirdly..  This is the same name that should be used for the deletion..
DWORD                                             // win32 status
DhcpPersistentRequestParams(                      // parameters to request persistently
    IN      LPWSTR                 AdapterName,   // adapter name to request for
    IN      LPBYTE                 ClassId,       // byte stream of class id to use
    IN      DWORD                  ClassIdLen,    // # of bytes of class id
    IN      PDHCPAPI_PARAMS        SendParams,    // persistent parameters
    IN      DWORD                  nSendParams,   // size of above array
    IN      DWORD                  Flags,         // must be zero, reserved
    IN      LPWSTR                 AppName        // name of app doing the persistent request
) {
    DWORD                          Error;
    DWORD                          nRecdParams;

    nRecdParams = 0;
    Error = DhcpRequestParamsInternal(
        PersistentRequestParamsOpCode,
        AdapterName,
        ClassId,
        ClassIdLen,
        SendParams,
        nSendParams,
        Flags,
        NULL,
        &nRecdParams
    );
    DhcpAssert(ERROR_MORE_DATA != Error );
    if( ERROR_INVALID_PARAMETER == Error ) Error = ERROR_SUCCESS; // see below comment
    if( ERROR_SUCCESS != Error ) {                // if AdapterName is NULL or if ClassId is not the one currently in use
        return Error;                             // only then do we get ERROR_INVALID_PARAMETER -- so filter those out
    }

    return DhcpRegistryPersistentRequestParams(   // now munge the registry
        AdapterName,
        ClassId,
        ClassIdLen,
        SendParams,
        nSendParams,
        NULL,
        0,
        AppName
    );
}

DWORD                                             // win32 status
DhcpDelPersistentRequestParams(                   // undo the effect of a persistent request -- currently undo from registry
    IN      LPWSTR                 AdapterName,   // the name of the adpater to delete for
    IN      LPWSTR                 AppName        // the name used by the app
) {
    HKEY                           Key;
    DWORD                          Error;
    DWORD                          LocationSize;
    DWORD                          FullKeyNameSize, Disposition;
    LPWSTR                         FullKeyName;
    LPWSTR                         LocationValue;
    LPWSTR                         Tmp, Tmp2;

    FullKeyNameSize = sizeof(DHCP_CLIENT_OPTION_KEY);
    FullKeyNameSize += wcslen(AppName)*sizeof(WCHAR) + sizeof(WCHAR);
    FullKeyName = DhcpAllocateMemory(FullKeyNameSize);
    if( NULL == FullKeyName ) return ERROR_NOT_ENOUGH_MEMORY;

    wcscpy(FullKeyName, DHCP_CLIENT_OPTION_KEY);
    wcscat(FullKeyName, L"\\");
    wcscat(FullKeyName, AppName);

    Error = DhcpRegRecurseDelete(HKEY_LOCAL_MACHINE, FullKeyName);
    DhcpAssert(ERROR_SUCCESS == Error);
    DhcpFreeMemory(FullKeyName);

    Error = RegOpenKeyEx(
        HKEY_LOCAL_MACHINE,
        DHCP_CLIENT_OPTION_KEY,
        0 /* Reserved */,
        DHCP_CLIENT_KEY_ACCESS,
        &Key
    );
    if( ERROR_SUCCESS != Error ) {
        DhcpAssert(FALSE);
        return Error;
    } else {
        DhcpRegRecurseDelete(Key, AppName);
    }

    LocationValue = NULL;
    Error = GetRegistryString(                    // read the value
        Key,
        DHCP_OPTION_LIST_VALUE,
        &LocationValue,
        &LocationSize
    );

    if( LocationValue == NULL ) Error = ERROR_FILE_NOT_FOUND;
    
    if( ERROR_SUCCESS != Error  ) {
        RegCloseKey(Key);
        return Error;
    }

    Tmp = Tmp2 = LocationValue;
    while(wcslen(Tmp) ) {
        if( 0 != wcsncmp(AppName, Tmp, wcslen(AppName))) {
            wcscpy(Tmp2, Tmp);
            Tmp2 += wcslen(Tmp) +1;
            Tmp += wcslen(Tmp) +1;
            continue;
        }
        if( Tmp[wcslen(AppName)] != L'\\' ) {
            wcscpy(Tmp2, Tmp);
            Tmp2 += wcslen(Tmp) +1;
            Tmp += wcslen(Tmp) +1;
            continue;
        }

        //
        // found required entry.. just skip over it..
        //

        Tmp += wcslen(Tmp) +1;
    }
    *Tmp2 ++ = L'\0';

    Error = RegSetValueEx(
        Key,
        DHCP_OPTION_LIST_VALUE,
        0 /* Reserved */,
        REG_MULTI_SZ,
        (LPBYTE)LocationValue,
        (ULONG)(((LPBYTE)Tmp2 - (LPBYTE)LocationValue))
    );
    RegCloseKey(Key);
    DhcpFreeMemory(LocationValue);

    return Error;
}

BOOL _inline
CharInMem(
    IN      BYTE                   Byte,
    IN      LPBYTE                 Mem,
    IN      ULONG                  MemSz
)
{
    while(MemSz) {
        if( Byte == *Mem ) return TRUE;
        Mem ++; MemSz --;
    }
    return FALSE;
}

DWORD
APIENTRY
DhcpRegisterOptions(
    IN      LPWSTR                 AdapterName,
    IN      LPBYTE                 OptionList,
    IN      DWORD                  OptionListSz,
    IN      HANDLE                *pdwHandle
) {
    DHCPAPI_PARAMS                 DhcpParams;
    DWORD                          Error;
    DHCP_OPTION                    DummyOption;
    LPBYTE                         Value;
    DWORD                          ValueSize, ValueType;
    BYTE                           Buf[256];
    ULONG                          nElementsInBuf;

    DhcpParams.OptionId = OPTION_PARAMETER_REQUEST_LIST;
    DhcpParams.IsVendor = FALSE;
    DhcpParams.Data = OptionList;
    DhcpParams.nBytesData = OptionListSz;

    Error = DhcpRegisterParameterChangeNotification(
        AdapterName,
        NULL,
        0,
        &DhcpParams,
        1,
        0,
        pdwHandle
    );

    if( ERROR_SUCCESS != Error ) return Error;

    memset(&DummyOption, 0, sizeof(DummyOption));

    Value = NULL; ValueSize = 0;
    Error = DhcpRegReadFromAnyLocation(
        DHCP_REGISTER_OPTIONS_LOC,
        AdapterName,
        &Value,
        &ValueType,
        &ValueSize
    );
    if( ERROR_SUCCESS == Error && REG_BINARY == ValueType && 0 != ValueSize ) {
        //
        // Got some pre-existing values... add the remaining to it..
        //
        memcpy(Buf, Value, ValueSize);
        while(OptionListSz) {
            if( !CharInMem(*OptionList, Value, ValueSize) )
                Buf[ValueSize++] = *OptionList;
            OptionList ++; OptionListSz --;
        }
        OptionList = Buf;
        OptionListSz = ValueSize;
    }

    if( NULL != Value ) DhcpFreeMemory(Value);

    DummyOption.Data = OptionList;
    DummyOption.DataLen = OptionListSz;

    Error = DhcpRegSaveOptionAtLocationEx(
        &DummyOption,
        AdapterName,
        DHCP_REGISTER_OPTIONS_LOC,
        REG_BINARY
    );

    return Error;
}

DWORD
APIENTRY
DhcpDeRegisterOptions (
    IN      HANDLE                 OpenHandle
) {
    DWORD                          Error;

    Error = DhcpDeRegisterParameterChangeNotification(OpenHandle);
    if( ERROR_SUCCESS != Error ) return Error;

    //
    // can't undo registry as we don't have enough information to do that.
    //

    return Error;
}

//================================================================================
//  C L I E N T   A P I   E N T R Y  P O I N T S
//================================================================================

DWORD
APIENTRY
DhcpCApiInitialize(
    OUT     LPDWORD                Version
)
/*++

    Routine Description:

       This routine intializes all the DHCP Client side APIs

    Arguemnts:

        Version    - a pointer to a DWORD that gets filled with DHCP APIs version #.

    Return Value:

        Returns STatus.
--*/
{
    if( NULL != Version ) *Version = 2;
    return ERROR_SUCCESS;
}

VOID
APIENTRY
DhcpCApiCleanup(
    VOID
)
/*++

    Routine Description:

        This routine cleansup afterall the DHCP Client side APIs have been called.

--*/
{
    return ;
}

DWORD                                             // win32 status
APIENTRY
DhcpRequestParams(                                // request parameters of client
    IN      DWORD                  Flags,         // must be DHCPCAPI_REQUEST_SYNCHRONOUS
    IN      LPVOID                 Reserved,      // this parameter is reserved
    IN      LPWSTR                 AdapterName,   // adapter name to request for
    IN      LPDHCPCAPI_CLASSID     ClassId,       // reserved must be NULL
    IN      DHCPCAPI_PARAMS_ARRAY  SendParams,    // parameters to send.
    IN OUT  DHCPCAPI_PARAMS_ARRAY  RecdParams,    // parameters that are to be requested..
    IN      LPBYTE                 Buffer,        // a buffer to hold data for RecdParams
    IN OUT  LPDWORD                pSize,         // i/p: size of above in BYTES, o/p required bytes..
    IN      LPWSTR                 RequestIdStr   // name of the application, unique per request
)   // returns ERROR_MORE_DATA if o/p buffer is of insufficient size, and fills in reqd size in # of bytes
/*++

    Routine Description:

        This routine can be used to do Request options from the DHCP Server and based on
        whether then whether the request is permanent or not, this request would be stored
        in the registry for persistence across boots.  The requests can have a particular class
        for which they'd be defined... (the class is sent on wire for the server to decide
        which options to send).  The request could be ASYNCHRONOUS in the sense that the call
        returns even before the server returns the data.. But this is not yet implemented.

    Arugments:

        Flags     -  currently DHCPCAPI_REQUEST_SYNCHRONOUS must be defined.
                     if a persisten request is desired, DHCPCAPI_REQUEST_PERSISTENT can
                     also be passed (bit-wise OR'ed)

        Reserved  -  MUST be NULL.  Reserved for future USE.

        AdapterName - The Name of the adapter for which this request is designed.  This
                     cannot be NULL currently though it is a nice thing to implement for
                     future.

        ClassId   -  The binary ClassId information to use to send on wire.

        SendParams - The Parameters to actual send on wire.

        RecdParams - The parameters to be received back from the DHCP server

        Buffer     - A buffer to hold some information.  This cannot be NULL and some
                     pointers within the RecdParams structure use this buffer, so it cannot
                     be deallocated so long as the RecdParams array is in USE.

        pSize      - This is (on input) the size in bytes of the Buffer variable.  When
                     the function returns ERROR_MORE_DATA, this variable would be the size
                     in bytes required.  If the function returns SUCCESSFULLY, this would
                     be the number of bytes space used up in reality.

        RequestIdStr - a string identifying the request being made.  This has to be unique
                     to each request (and a Guid is suggested).  This string is needed to
                     undo the effects of a RequestParam via UndoRequestParams..

    Return Value:

        This function returns ERROR_MORE_DATA if the buffer space provided by "Buffer" variable
        is not sufficient. (In this case, the pSize variable is filled in with the actual
        size required).  On success it returns ERROR_SUCCESS.  Otherwise, it returns Win32
        status.
--*/
{

    ULONG                          Error;
    ULONG                          i;

    //
    // Parameter validation
    //

    if( Flags != DHCPCAPI_REQUEST_SYNCHRONOUS &&
        Flags != DHCPCAPI_REQUEST_PERSISTENT &&
        Flags != (DHCPCAPI_REQUEST_SYNCHRONOUS | DHCPCAPI_REQUEST_PERSISTENT)) {
        return ERROR_INVALID_PARAMETER;
    }

    if( NULL != Reserved || NULL == AdapterName ||
        0 == RecdParams.nParams || NULL == pSize ) {
        return ERROR_INVALID_PARAMETER;
    }

    if( NULL == Buffer && *pSize ) {
        return ERROR_INVALID_PARAMETER;
    }

    if( NULL != ClassId ) {
        if( 0 != ClassId->Flags ) return ERROR_INVALID_PARAMETER;
        if( NULL == ClassId->Data || 0 == ClassId->nBytesData ) {
            return ERROR_INVALID_PARAMETER;
        }
    }

    if( NULL == RecdParams.Params || (0 != SendParams.nParams && NULL == SendParams.Params) ) {
        return ERROR_INVALID_PARAMETER;
    }

    for( i = 0; i < RecdParams.nParams ; i ++ ) {
        if( 0 != RecdParams.Params[i].nBytesData ||
            NULL != RecdParams.Params[i].Data ) {
            return ERROR_INVALID_PARAMETER;
        }
    }

    //
    // Now call the DhcpRequestParameters API and do datatype conversions for that..
    //

    Error = ERROR_SUCCESS;

    if( Flags & DHCPCAPI_REQUEST_SYNCHRONOUS ) {
        Error = DhcpRequestParamsInternalEx(
            RequestParamsOpCode,
            AdapterName,
            ClassId? ClassId->Data : NULL,
            ClassId? ClassId->nBytesData : 0,
            SendParams.Params,
            SendParams.nParams,
            0,
            RecdParams.Params,
            &RecdParams.nParams,
            Buffer,
            pSize
        );
    }

    if( ERROR_SUCCESS != Error ) return Error;

    if( Flags & DHCPCAPI_REQUEST_PERSISTENT ) {
        Error = DhcpRegistryPersistentRequestParams(
            AdapterName,
            ClassId? ClassId->Data : NULL,
            ClassId? ClassId->nBytesData : 0,
            SendParams.Params,
            SendParams.nParams,
            RecdParams.Params,
            RecdParams.nParams,
            RequestIdStr
        );
    }

    return Error;
}

DWORD                                             // win32 status
APIENTRY
DhcpUndoRequestParams(                            // undo the effect of a persistent request -- currently undo from registry
    IN      DWORD                  Flags,         // must be zero, reserved
    IN      LPVOID                 Reserved,      // this parameter is reserved
    IN      LPWSTR                 AdapterName,   // the original adapter this was registerdd for,..
    IN      LPWSTR                 RequestIdStr   // the requestId str passed to RequestParams..
)
/*++

    Routine Description:

       This function is used to undo the effects of a persistent request done
       via DhcpRequestParams with DHCPCAPI_REQUEST_PERSISTENT option.

    Arguments:

       Flags        -  MUST be zero. Reserved for future use.

       Reserved     -  MUST be NULL

       AdapterName  -  The original adapter name this request was made for

       RequestIdStr -  The original request Id string passed to RequestParams

    Return Value:

       returns Win32 status

--*/
{
    if( 0 != Flags || NULL != Reserved || NULL == RequestIdStr )
        return ERROR_INVALID_PARAMETER;

    return DhcpDelPersistentRequestParams(
        AdapterName,
        RequestIdStr
    );
}

DWORD                                             // win32 status
APIENTRY
DhcpRegisterParamChange(                          // notify if a parameter has changed
    IN      DWORD                  Flags,         // must be DHCPCAPI_REGISTER_HANDLE_EVENT
    IN      LPVOID                 Reserved,      // this parameter is reserved
    IN      LPWSTR                 AdapterName,   // adapter of interest
    IN      LPDHCPCAPI_CLASSID     ClassId,       // reserved must be NULL
    IN      DHCPCAPI_PARAMS_ARRAY  Params,        // parameters of interest
    IN OUT  LPVOID                 Handle         // handle to event that will be SetEvent'ed in case of param change
)
/*++

    Routine Description;

        This function registers with DHCP for any notifications on changes to the
        specified options.. (notifications are via an EVENT handle)

    Arguments:

        Flags      - this decides how the notification works -- via EVENTS or otherwise.
                     Currently, only event based mechanism is provided. So, this must be
                     DHCPCAPI_REGISTER_HANDLE_EVENT.  In this case, Handle must also
                     be the address of a handle variable. (This is not the event handle
                     itself, the event handle is returned in this address).

        Reserved   - MUST be NULL.

        AdapterName - MUST NOT BE NULL.  This is the name of the adapter for which the
                     notification is being registered..

        ClassId    - This specifies the classId if any for which the registration is.

        Params     - This is the set of parameter to listen on and notify of when any
                     change happens..

        Handle     - See "Flags" for what this variable is.

    Return values:

        returns Win32 status codes

--*/
{
    DWORD                          Error;
    CHAR                           Buf[256];      // cannot request more options than this!
    CHAR                           VBuf[256];
    DHCPAPI_PARAMS                 Param[2], *pReqParams;
    ULONG                          i;
    DWORD                          nOpt, nVOpt;

    if( Flags != DHCPCAPI_REGISTER_HANDLE_EVENT ) {
        return ERROR_INVALID_PARAMETER;
    }

    if( NULL != Reserved || NULL == AdapterName || 0 == Params.nParams || NULL == Handle ) {
        return ERROR_INVALID_PARAMETER;
    }

    nOpt = nVOpt = 0;
    for( i = 0; i < Params.nParams ; i ++ ) {
        if( Params.Params[i].IsVendor ) {
            VBuf[nVOpt++] = (BYTE)Params.Params[i].OptionId;
        } else {
            Buf[nOpt++] = (BYTE)Params.Params[i].OptionId;
        }
    }

    Param[0].OptionId = OPTION_PARAMETER_REQUEST_LIST;
    Param[0].IsVendor = FALSE;
    Param[0].Data = Buf;
    Param[0].nBytesData = nOpt;

    Param[1].OptionId = OPTION_PAD;
    Param[1].IsVendor = TRUE;
    Param[1].Data = VBuf;
    Param[1].nBytesData = nVOpt;

    if( 0 == nOpt ) pReqParams = &Param[1]; else pReqParams = &Param[0];

    return DhcpRegisterParameterChangeNotification(
        AdapterName,
        ClassId? ClassId->Data : NULL,
        ClassId? ClassId->nBytesData : 0,
        pReqParams,
        (nOpt != 0) + (nVOpt != 0),
        0,
        Handle
    );
}

DWORD
APIENTRY
DhcpDeRegisterParamChange(                        // undo the registration
    IN      DWORD                  Flags,         // MUST BE ZERO --> No flags yet.
    IN      LPVOID                 Reserved,      // MUST BE NULL --> Reserved
    IN      LPVOID                 Event          // handle to event returned by DhcpRegisterParamChange.
)
/*++

    Routine description:

        This routine undoes whateve was done by previous routine, and closes the
        handle also.  The handle cannot be used after this.

    Arguments:

        Flags   - MUST BE DHCPCAPI_REGISTER_HANDLE_EVENT currently.

        Reserved - MuST BE NULL

        Event   - this is the event handle returned in the "Handle" parameter to
                  DhcpRegisterParamChange function.

    Return Value:

        Win32 status

--*/
{
    return DhcpDeRegisterParameterChangeNotification(Event);
}


DWORD
APIENTRY
DhcpRemoveDNSRegistrations(
    VOID
    )
{
    return DhcpAdapterOnlyApi(NULL, RemoveDNSRegistrationsOpCode);
}


//================================================================================
// end of file
//================================================================================
#endif H_ONLY