windows-server-2003/net/rras/ras/ui/common/sharing/sharing.c

/*++

Copyright (c) 1998, Microsoft Corporation

Module Name:

    sharing.c

Abstract:

    This module contains code for routines which support connection sharing
    configuration.

    Connection sharing involves a public (internet) interface, ordinarily
    a dialup interface identified by phonebook/entry-name, as well as
    a private (home) interface, required to be a lan interface.

    On setting up connection sharing, the service is enabled if necessary,
    and the private lan interface is configured with static address 169.254.0.1
    via the TCP/IP 'SetAdapterIpAddress' API routine.

    The name of the shared connection is stored in the registry along with
    the GUID of the shared private LAN connection, under the registry key
    HKLM\Software\Microsoft\SharedAccess\Parameters.

    N.B. NT registry routines are used, to avoid the hit incurred by
    going through the Win32 server.

Author:

    Abolade Gbadegesin  (aboladeg)  22-Apr-1998

Revision History:

--*/

#include "precomp.h"
#pragma hdrstop
#define _PNP_POWER_
#include <ndispnp.h>
#include <ntddip.h>
#include <winsock2.h>
#include <dhcpcapi.h>
#include <netconp.h>

#if 0

//
// Structure:   CS_ADDRESS_INFORMATION
//

typedef struct _CS_ADDRESS_INFORMATION {
    PKEY_VALUE_PARTIAL_INFORMATION IPAddress;
    PKEY_VALUE_PARTIAL_INFORMATION SubnetMask;
    PKEY_VALUE_PARTIAL_INFORMATION DefaultGateway;
    PKEY_VALUE_PARTIAL_INFORMATION EnableDHCP;
} CS_ADDRESS_INFORMATION, *PCS_ADDRESS_INFORMATION;

//
// DHCPCSVC.DLL import prototype
//

typedef DWORD
(APIENTRY* PDHCPNOTIFYCONFIGCHANGE)(
    LPWSTR,
    LPWSTR,
    BOOL,
    DWORD,
    DWORD,
    DWORD,
    SERVICE_ENABLE
    );

#endif

//
// OLE entrypoints loaded dynamically
//

PCOINITIALIZEEX g_pCoInitializeEx;
PCOUNINITIALIZE g_pCoUninitialize;
PCOCREATEINSTANCE g_pCoCreateInstance;
PCOSETPROXYBLANKET g_pCoSetProxyBlanket;
PCOTASKMEMFREE g_pCoTaskMemFree;

//
// CONSTANT DEFINITIONS
//

#if 0
const CHAR c_szAllocateAndGetIpAddrTableFromStack[] =
    "AllocateAndGetIpAddrTableFromStack";
#endif
const CHAR c_szCoInitializeEx[] = "CoInitializeEx";
const CHAR c_szCoUninitialize[] = "CoUninitialize";
const CHAR c_szCoCreateInstance[] = "CoCreateInstance";
const CHAR c_szCoSetProxyBlanket[] = "CoSetProxyBlanket";
const CHAR c_szCoTaskMemFree[] = "CoTaskMemFree";
#if 0
const CHAR c_szDhcpNotifyConfigChange[] = "DhcpNotifyConfigChange";
const CHAR c_szGetInterfaceInfo[] = "GetInterfaceInfo";
#endif
const CHAR c_szMprConfigBufferFree[] = "MprConfigBufferFree";
const CHAR c_szMprConfigServerConnect[] = "MprConfigServerConnect";
const CHAR c_szMprConfigServerDisconnect[] = "MprConfigServerDisconnect";
const CHAR c_szMprConfigTransportGetHandle[] = "MprConfigTransportGetHandle";
const CHAR c_szMprConfigTransportGetInfo[] = "MprConfigTransportGetInfo";
const CHAR c_szMprInfoBlockFind[] = "MprInfoBlockFind";
#if 0
const CHAR c_szSetAdapterIpAddress[] = "SetAdapterIpAddress";
#endif
const TCHAR c_szSharedAccess[] = TEXT("SharedAccess");
#if 0
const WCHAR c_szBackupDefaultGateway[] = L"BackupDefaultGateway";
const WCHAR c_szBackupEnableDHCP[] = L"BackupEnableDHCP";
const WCHAR c_szBackupIPAddress[] = L"BackupIPAddress";
const WCHAR c_szBackupSubnetMask[] = L"BackupSubnetMask";
const WCHAR c_szDefaultGateway[] = L"DefaultGateway";
const WCHAR c_szDevice[] = L"\\Device\\";
const WCHAR c_szDhcpcsvcDll[] = L"DHCPCSVC.DLL";
const WCHAR c_szEmpty[] = L"";
const WCHAR c_szEnableDHCP[] = L"EnableDHCP";
const WCHAR c_szInterfaces[] = L"Interfaces";
const WCHAR c_szIPAddress[] = L"IPAddress";
const WCHAR c_szIphlpapiDll[] = L"IPHLPAPI.DLL";
#endif
const WCHAR c_szMprapiDll[] = L"MPRAPI.DLL";
const WCHAR c_szMsTcpip[] = L"MS_TCPIP";
const WCHAR c_szOle32Dll[] = L"OLE32.DLL";
#if 0
const WCHAR c_szScopeAddress[] = L"ScopeAddress";
const WCHAR c_szScopeMask[] = L"ScopeMask";
#endif
const WCHAR c_szSharedAccessParametersKey[] =
    L"\\Registry\\Machine\\System\\CurrentControlSet\\Services\\SharedAccess"
    L"\\Parameters";
#if 0
const WCHAR c_szSharedConnection[] = L"SharedConnection";
const WCHAR c_szSharedPrivateLan[] = L"SharedPrivateLan";
const WCHAR c_szSubnetMask[] = L"SubnetMask";
const WCHAR c_szTcpip[] = L"Tcpip";
const WCHAR c_szTcpipParametersKey[] =
    L"\\Registry\\Machine\\System\\CurrentControlSet\\Services\\Tcpip"
    L"\\Parameters";
const WCHAR c_szFirewallConnection[] = L"FirewallConnection";
const WCHAR c_szFirewallConnectionCount[] = L"FirewallConnectionCount";
#endif

//
// LOCAL VARIABLE DEFINITIONS
//

static BOOLEAN CsInitialized = FALSE;
static CRITICAL_SECTION CsCriticalSection;
static BOOLEAN CsDllMainCalled = FALSE;
static HINSTANCE CsOle32Dll = NULL;

//
// FUNCTION PROTOTYPES
//

#if 0

VOID
CspBackupAddressInformation(
    HANDLE Key,
    PCS_ADDRESS_INFORMATION AddressInformation
    );

NTSTATUS
CspCaptureAddressInformation(
    PWCHAR AdapterGuid,
    PCS_ADDRESS_INFORMATION Information
    );

VOID
CspCleanupAddressInformation(
    PCS_ADDRESS_INFORMATION AddressInformation
    );

NTSTATUS
CspRestoreAddressInformation(
    HANDLE Key,
    PWCHAR AdapterGuid
    );

BOOLEAN
CspIsConnectionFwWorker(
    LPRASSHARECONN ConnectionArray,
    ULONG Count,
    LPRASSHARECONN Connection,
    ULONG *ConnNumber OUT OPTIONAL
    );

ULONG
CspAddFirewallConnection(
    LPRASSHARECONN Connection,
    ULONG Number
    );

ULONG
CspRemoveFirewallConnection(
    LPRASSHARECONN Connection,
    ULONG Position,
    LPRASSHARECONN ConnectionArray,
    ULONG Count
    );
    
#endif


BOOL
CsDllMain(
    ULONG Reason
    )

/*++

Routine Description:

    This pseudo-entrypoint is invoked by RASAPI32.DLL's DllMain,
    to initialize and shutdown the connection-sharing module.
    Initialization is minimal to keep down the performance hit incurred
    on systems which make no use of the shared-access functionality.

Arguments:

    Reason - indicates whether to initialize or shutdown.

Return Value:

    BOOL - indicates success (TRUE) or failure (FALSE).

--*/

{
    if (Reason == DLL_PROCESS_ATTACH) {
        __try {
            InitializeCriticalSection(&CsCriticalSection);
        } __except(EXCEPTION_EXECUTE_HANDLER) {
            return FALSE;
        }
        CsDllMainCalled = TRUE;
    } else if (Reason == DLL_PROCESS_DETACH) {
        if (!CsDllMainCalled) { return TRUE; }
        __try {
            EnterCriticalSection(&CsCriticalSection);
        } __except(EXCEPTION_EXECUTE_HANDLER) {
            return TRUE;
        }
        CsShutdownModule();
        LeaveCriticalSection(&CsCriticalSection);
        DeleteCriticalSection(&CsCriticalSection);
    }
    return TRUE;
} // DllMain


VOID
CsControlService(
    ULONG ControlCode
    )

/*++

Routine Description:

    This routine is called to send a control-code to the Shared Access service
    if it is active. Control-codes are used to indicate changes to the settings
    for the service; see IPNATHLP.H for a list of private control-codes used
    to indicate configuration changes.

Arguments:

    ControlCode - the control to be sent.

Return Value:

    none.

--*/

{
    SC_HANDLE ScmHandle;
    SC_HANDLE ServiceHandle;
    SERVICE_STATUS ServiceStatus;

    ScmHandle = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS);
    if (ScmHandle) {
        ServiceHandle =
            OpenService(ScmHandle, c_szSharedAccess, SERVICE_ALL_ACCESS);
        if (ServiceHandle) {
            ControlService(ServiceHandle, ControlCode, &ServiceStatus);
            CloseServiceHandle(ServiceHandle);
        }
        CloseServiceHandle(ScmHandle);
    }

} // CsControlService

#if 0


ULONG
CsFirewallConnection(
    LPRASSHARECONN Connection,
    BOOLEAN Enable
    )

/*++

Routine Description:

    This routine is invoked to enable or disable the firewall on a connection.

Arguments:

    Connection - the connection to [un]firewall

    Enable - true if the firewall is to be enabled for this connection,
             false if the firewall is to be disabled
             
Return Value:

    Win32 Error code

--*/

{
    ULONG Count = 0;
    ULONG Position;
    LPRASSHARECONN ConnectionArray;
    DWORD Error;
    BOOLEAN IsFirewalled = FALSE;

    //
    // Query the number of currently firewalled connections, and
    // retrieve the connection array if any exists.
    //

    Error = CsQueryFirewallConnections(NULL, &Count);
    if (Error && Error != ERROR_INSUFFICIENT_BUFFER) {
        return Error;
    }

    if (Count) {
        ConnectionArray =
            (LPRASSHARECONN) Malloc(Count * sizeof(RASSHARECONN));

        if (!ConnectionArray) {
            return ERROR_NOT_ENOUGH_MEMORY;
        }

        Error = CsQueryFirewallConnections(ConnectionArray, &Count);
        if (Error) {
            Free(ConnectionArray);
            return Error;
        }
    } else {
        ConnectionArray = NULL;
    }

    //
    // If there are firewalled connections, check to see if the connection
    // passed in is one of them.
    //

    if (Count) {
        IsFirewalled = CspIsConnectionFwWorker(
                            ConnectionArray,
                            Count,
                            Connection,
                            &Position
                            );
    }

    if (Enable) {
    
        if (!IsFirewalled) {
            Error = CspAddFirewallConnection(
                        Connection,
                        Count
                        );

            if(ERROR_SUCCESS == Error) {
            
                //
                // Start (if needed) and update service. If the service
                // is already running, CsStartService returns ERROR_SUCCESS.
                //

                if (0 == Count) {
                    Error = CsStartService();
                }
                CsControlService(IPNATHLP_CONTROL_UPDATE_CONNECTION);
            }
            
        } else {

            //
            // Define ALREADY_ENABLED error?
            //
            
            Error = ERROR_CAN_NOT_COMPLETE;
        }

    } else {
    
        if (IsFirewalled) {
            Error = CspRemoveFirewallConnection(
                        Connection,
                        Position,
                        ConnectionArray,
                        Count
                        );

            if (ERROR_SUCCESS == Error) {
            
                //
                // Stop or update service. We only stop the service if
                // there is no shared connection, and this was the last
                // firewalled connection (i.e., count was 10
                //
                
                RASSHARECONN SharedConn;
                Error = CsQuerySharedConnection(&SharedConn);

                if (ERROR_SUCCESS != Error && 1 == Count) { 
                    CsStopService();
                } else {
                    CsControlService(IPNATHLP_CONTROL_UPDATE_CONNECTION);
                }
                Error = ERROR_SUCCESS;
            }

        } else {

            //
            // Define NOT_FIREWALLED error?
            //
            
            Error = ERROR_CAN_NOT_COMPLETE;
        }
    }

    if (ConnectionArray) {
        Free(ConnectionArray);
    }

    return Error;
} // CsFirewallConnection

#endif


ULONG
CsInitializeModule(
    VOID
    )

/*++

Routine Description:

    This routine is called to initialize the connection-sharing configuration
    module. Initialization consists of loading the entrypoints which we have
    deferred loading up till now, in both MPRAPI.DLL and OLE32.DLL.

Arguments:

    Instance - handle to the module-instance

Return Value:

    ULONG - Win32 status code.

--*/

{
    ULONG Error;
    HINSTANCE Hinstance;
    EnterCriticalSection(&CsCriticalSection);
    if (CsInitialized) {
        Error = NO_ERROR;
    } else {
        if (!(CsOle32Dll = LoadLibraryW(c_szOle32Dll)) ||
            !(g_pCoInitializeEx =
                (PCOINITIALIZEEX)GetProcAddress(
                    CsOle32Dll, c_szCoInitializeEx
                    )) ||
            !(g_pCoUninitialize =
                (PCOUNINITIALIZE)GetProcAddress(
                    CsOle32Dll, c_szCoUninitialize
                    )) ||
            !(g_pCoCreateInstance =
                (PCOCREATEINSTANCE)GetProcAddress(
                    CsOle32Dll, c_szCoCreateInstance
                    )) ||
            !(g_pCoSetProxyBlanket =
                (PCOSETPROXYBLANKET)GetProcAddress(
                    CsOle32Dll, c_szCoSetProxyBlanket
                    )) ||
            !(g_pCoTaskMemFree =
                (PCOTASKMEMFREE)GetProcAddress(
                    CsOle32Dll, c_szCoTaskMemFree
                    ))) {
            if (CsOle32Dll) { FreeLibrary(CsOle32Dll); CsOle32Dll = NULL; }
            TRACE1("CsInitializeModule: %d", GetLastError());
            Error = ERROR_PROC_NOT_FOUND;
        } else {
            CsInitialized = TRUE;
            Error = NO_ERROR;
        }
    }
    LeaveCriticalSection(&CsCriticalSection);
    return Error;

} // CsInitializeModule

#if 0


ULONG
CsIsFirewalledConnection(
    LPRASSHARECONN Connection,
    PBOOLEAN Firewalled
    )

/*++

Routine Description:

    This routine is invoked to determine if a connection is firewalled

Arguments:

    Connection - the connection to check

    Firewalled - receives the return value

Return Value:

    ULONG - win32 error
    
--*/

{
    ULONG Count = 0;
    LPRASSHARECONN ConnectionArray;
    ULONG Error;

    if (!Firewalled) {
        return ERROR_INVALID_PARAMETER;
    }
    *Firewalled = FALSE;

    Error = CsQueryFirewallConnections(NULL, &Count);
    if (Error && Error != ERROR_INSUFFICIENT_BUFFER) {
        return Error;
    }

    ConnectionArray =
        (LPRASSHARECONN) Malloc(Count * sizeof(RASSHARECONN));

    if (!ConnectionArray) {
        return ERROR_NOT_ENOUGH_MEMORY;
    }

    Error = CsQueryFirewallConnections(ConnectionArray, &Count);
    if (Error) {
        Free(ConnectionArray);
        return Error;
    }

    *Firewalled = CspIsConnectionFwWorker(ConnectionArray, Count, Connection, NULL);
    Free(ConnectionArray);
    return NO_ERROR;
} // CsIsConnectionFirewalled


BOOLEAN
CsIsRoutingProtocolInstalled(
    ULONG ProtocolId
    )

/*++

Routine Description:

    This routine is invoked to determine whether the routing protocol
    with the given protocol-ID is installed for Routing and Remote Access.
    This is determined by examining the configuration for the service.

Arguments:

    ProtocolId - identifies the protocol to be found

Return Value:

    TRUE if the protocol is installed, FALSE otherwise.

--*/

{
    PUCHAR Buffer;
    ULONG BufferLength;
    HINSTANCE Hinstance;
    PMPRCONFIGBUFFERFREE MprConfigBufferFree;
    PMPRCONFIGSERVERCONNECT MprConfigServerConnect;
    PMPRCONFIGSERVERDISCONNECT MprConfigServerDisconnect;
    PMPRCONFIGTRANSPORTGETHANDLE MprConfigTransportGetHandle;
    PMPRCONFIGTRANSPORTGETINFO MprConfigTransportGetInfo;
    PMPRINFOBLOCKFIND MprInfoBlockFind;
    HANDLE ServerHandle;
    HANDLE TransportHandle;

    //
    // Load the MPRAPI.DLL module and retrieve the entrypoints
    // to be used for examining the RRAS configuration.
    //

    if (!(Hinstance = LoadLibraryW(c_szMprapiDll)) ||
        !(MprConfigBufferFree = 
            (PMPRCONFIGBUFFERFREE)
                GetProcAddress(Hinstance, c_szMprConfigBufferFree)) ||
        !(MprConfigServerConnect = 
            (PMPRCONFIGSERVERCONNECT)
                GetProcAddress(Hinstance, c_szMprConfigServerConnect)) ||
        !(MprConfigServerDisconnect = 
            (PMPRCONFIGSERVERDISCONNECT)
                GetProcAddress(Hinstance, c_szMprConfigServerDisconnect)) ||
        !(MprConfigTransportGetHandle = 
            (PMPRCONFIGTRANSPORTGETHANDLE)
                GetProcAddress(Hinstance, c_szMprConfigTransportGetHandle)) ||
        !(MprConfigTransportGetInfo = 
            (PMPRCONFIGTRANSPORTGETINFO)
                GetProcAddress(Hinstance, c_szMprConfigTransportGetInfo)) ||
        !(MprInfoBlockFind = 
            (PMPRINFOBLOCKFIND)
                GetProcAddress(Hinstance, c_szMprInfoBlockFind))) {
        if (Hinstance) { FreeLibrary(Hinstance); }
        return FALSE;
    }

    //
    // Connect to the RRAS configuration, and retrieve the configuration
    // for the IP transport-layer routing protocols. This should include
    // the configuration for the routing-protocol in 'ProtocolId',
    // if installed.
    //

    ServerHandle = NULL;
    if (MprConfigServerConnect(NULL, &ServerHandle) != NO_ERROR ||
        MprConfigTransportGetHandle(ServerHandle, PID_IP, &TransportHandle)
            != NO_ERROR ||
        MprConfigTransportGetInfo(
            ServerHandle,
            TransportHandle,
            &Buffer,
            &BufferLength, 
            NULL,
            NULL,
            NULL
            ) != NO_ERROR) {
        if (ServerHandle) { MprConfigServerDisconnect(ServerHandle); }
        FreeLibrary(Hinstance);
        return FALSE;
    }

    MprConfigServerDisconnect(ServerHandle);

    //
    // Look for the requested protocol's configuration,
    // and return TRUE if it is found; otherwise, return FALSE.
    //

    if (MprInfoBlockFind(Buffer, ProtocolId, NULL, NULL, NULL) == NO_ERROR) {
        MprConfigBufferFree(Buffer);
        FreeLibrary(Hinstance);
        return TRUE;
    }
    MprConfigBufferFree(Buffer);
    FreeLibrary(Hinstance);
    return FALSE;
} // CsIsRoutingProtocolInstalled

#endif


ULONG
CsIsSharedConnection(
    LPRASSHARECONN Connection,
    PBOOLEAN Shared
    )

/*++

Routine Description:

    This routine is invoked to determine whether the given connection
    is the currently-shared connection.

    For added performance, this may be changed to cache the shared-connection
    and use registry change-notification to detect updates.

Arguments:

    Connection - the connection in question

    Shared - receives 'TRUE' if the 'Name' is the shared connection,
        and 'FALSE' otherwise

Return Value:

    ULONG - Win32 status code.

Environment:

    This routine is called *without* initializing the module
    (i.e. loading mprapi.dll and ole32.dll), for performance reasons.
    Hence, it may not invoke any mprapi.dll routines.

--*/

{
    ULONG Error;
    RASSHARECONN SharedConnection;
    if (Shared) {
        Error = CsQuerySharedConnection(&SharedConnection);
        if (Error) {
            *Shared = FALSE;
        } else {
            *Shared = RasIsEqualSharedConnection(Connection, &SharedConnection);
        }
    }
    return NO_ERROR;
} // CsIsSharedConnection

#if 0


ULONG
CsMapGuidToAdapterIndex(
    PWCHAR Guid,
    PGETINTERFACEINFO GetInterfaceInfo
    )

/*++

Routine Description:

    This routine is called to match the GUID in the given string to
    an adapter in the list returned by calling the given entrypoint.

Arguments:

    Guid - identifies the GUID of the adapter to be found

    GetInterfaceInfo - supplies GUID information for each adapter

Return Value:

    ULONG - the index of the adapter, if found; otherwise, -1.

--*/

{
    ULONG AdapterIndex = (ULONG)-1;
    ULONG i;
    ULONG GuidLength;
    PIP_INTERFACE_INFO Info;
    PWCHAR Name;
    ULONG NameLength;
    ULONG Size;
    Size = 0;
    GuidLength = lstrlenW(Guid);
    if (GetInterfaceInfo(NULL, &Size) == ERROR_INSUFFICIENT_BUFFER) {
        Info = Malloc(Size);
        if (Info) {
            if (GetInterfaceInfo(Info, &Size) == NO_ERROR) {
                for (i = 0; i < (ULONG)Info->NumAdapters; i++) {
                    NameLength = lstrlenW(Info->Adapter[i].Name);
                    if (NameLength < GuidLength) { continue; }
                    Name = Info->Adapter[i].Name + (NameLength - GuidLength);
                    if (lstrcmpiW(Guid, Name) == 0) {
                        AdapterIndex = Info->Adapter[i].Index;
                        break;
                    }
                }
            }
            Free(Info);
        }
    }
    return AdapterIndex;
} // CsMapGuidToAdapter

#endif


NTSTATUS
CsOpenKey(
    PHANDLE Key,
    ACCESS_MASK DesiredAccess,
    PCWSTR Name
    )

/*++

Routine Description:

    This routine is invoked to open a given registry key.

Arguments:

    Key - receives the opened key

    DesiredAccess - specifies the requested access

    Name - specifies the key to be opened

Return Value:

    NTSTATUS - NT status code.

--*/

{
    OBJECT_ATTRIBUTES ObjectAttributes;
    UNICODE_STRING UnicodeString;
    RtlInitUnicodeString(&UnicodeString, Name);
    InitializeObjectAttributes(
        &ObjectAttributes,
        &UnicodeString,
        OBJ_CASE_INSENSITIVE,
        NULL,
        NULL
        );
    return NtOpenKey(Key, DesiredAccess, &ObjectAttributes);
} // CsOpenKey

#if 0


ULONG
CspAddFirewallConnection(
    LPRASSHARECONN Connection,
    ULONG Number
    )

/*++

Routine Description:

    This routine is invoked to add a connection to the registry set.

Arguments:

    Connection - the connection to add

    Number - the number of this connection
    
Return Value:

    Win32 error code

--*/

{
    HANDLE Key;
    UNICODE_STRING ValueName;
    ULONG Count;
    NTSTATUS Status;

    //
    // +11 is enough room to hold the digits of a number >4,000,000,000, so
    // buffer overflow won't be an issue below.
    //
    
    WCHAR wsz[sizeof(c_szFirewallConnection)/sizeof(WCHAR) + 11];

    //
    // Open the key to SharedAccess/Parameters
    //

    Status = CsOpenKey(&Key, KEY_ALL_ACCESS, c_szSharedAccessParametersKey);
    if (!NT_SUCCESS(Status)) {
        return RtlNtStatusToDosError(Status);
    }

    //
    // Generate the string for the connection value
    //

    swprintf(wsz, L"%s%u", c_szFirewallConnection, Number);
    RtlInitUnicodeString(&ValueName, wsz);

    //
    // Write the connection to the registry
    //

    Status = NtSetValueKey(
                Key,
                &ValueName,
                0,
                REG_BINARY,
                Connection,
                Connection->dwSize
                );

    if(!NT_SUCCESS(Status)) {
        NtClose(Key);
        return RtlNtStatusToDosError(Status);
    }

    //
    // Write the updated count to the registry
    //

    RtlInitUnicodeString(&ValueName, c_szFirewallConnectionCount);
    Count = Number + 1; // number is 0 indexed

    Status = NtSetValueKey(
                Key,
                &ValueName,
                0,
                REG_DWORD,
                &Count,
                sizeof(DWORD)
                );

    NtClose(Key);
    return RtlNtStatusToDosError(Status);
} // CspAddFirewallConnection


VOID
CspBackupAddressInformation(
    HANDLE Key,
    PCS_ADDRESS_INFORMATION Information
    )
{
    NTSTATUS status;
    UNICODE_STRING UnicodeString;
    do {
        RtlInitUnicodeString(&UnicodeString, c_szBackupIPAddress);
        status =
            NtSetValueKey(
                Key,
                &UnicodeString,
                0,
                Information->IPAddress->Type,
                Information->IPAddress->Data,
                Information->IPAddress->DataLength
                );
        if (!NT_SUCCESS(status)) { break; }
        RtlInitUnicodeString(&UnicodeString, c_szBackupSubnetMask);
        status =
            NtSetValueKey(
                Key,
                &UnicodeString,
                0,
                Information->SubnetMask->Type,
                Information->SubnetMask->Data,
                Information->SubnetMask->DataLength
                );
        if (!NT_SUCCESS(status)) { break; }
        RtlInitUnicodeString(&UnicodeString, c_szBackupDefaultGateway);
        status =
            NtSetValueKey(
                Key,
                &UnicodeString,
                0,
                Information->DefaultGateway->Type,
                Information->DefaultGateway->Data,
                Information->DefaultGateway->DataLength
                );
        if (!NT_SUCCESS(status)) { break; }
        RtlInitUnicodeString(&UnicodeString, c_szBackupEnableDHCP);
        status =
            NtSetValueKey(
                Key,
                &UnicodeString,
                0,
                Information->EnableDHCP->Type,
                Information->EnableDHCP->Data,
                Information->EnableDHCP->DataLength
                );
        if (!NT_SUCCESS(status)) { break; }
        return;
    } while(FALSE);
    RtlInitUnicodeString(&UnicodeString, c_szBackupIPAddress);
    NtDeleteValueKey(Key, &UnicodeString);
    RtlInitUnicodeString(&UnicodeString, c_szBackupSubnetMask);
    NtDeleteValueKey(Key, &UnicodeString);
    RtlInitUnicodeString(&UnicodeString, c_szBackupDefaultGateway);
    NtDeleteValueKey(Key, &UnicodeString);
    RtlInitUnicodeString(&UnicodeString, c_szBackupEnableDHCP);
    NtDeleteValueKey(Key, &UnicodeString);
} // CspBackupAddressInformation


NTSTATUS
CspCaptureAddressInformation(
    PWCHAR AdapterGuid,
    PCS_ADDRESS_INFORMATION Information
    )
{
    HANDLE Key;
    PWCHAR KeyName;
    ULONG KeyNameLength;
    NTSTATUS status;

    KeyNameLength =
        sizeof(WCHAR) *
        (lstrlenW(c_szTcpipParametersKey) + 1 +
         lstrlenW(c_szInterfaces) + 1 +
         lstrlenW(AdapterGuid) + 2);
    if (!(KeyName = Malloc(KeyNameLength))) { return STATUS_NO_MEMORY; }

    wsprintfW(
        KeyName, L"%ls\\%ls\\%ls", c_szTcpipParametersKey, c_szInterfaces,
        AdapterGuid
        );
    status = CsOpenKey(&Key, KEY_READ, KeyName);
    Free(KeyName);
    if (!NT_SUCCESS(status)) { return status; }

    do {
        status =
            CsQueryValueKey(
                Key, c_szIPAddress, &Information->IPAddress
                );
        if (!NT_SUCCESS(status)) { break; }
        status =
            CsQueryValueKey(
                Key, c_szSubnetMask, &Information->SubnetMask
                );
        if (!NT_SUCCESS(status)) { break; }
        status =
            CsQueryValueKey(
                Key, c_szDefaultGateway, &Information->DefaultGateway
                );
        if (!NT_SUCCESS(status)) { break; }
        status =
            CsQueryValueKey(
                Key, c_szEnableDHCP, &Information->EnableDHCP
                );
        if (!NT_SUCCESS(status)) { break; }
    } while(FALSE);

    NtClose(Key);
    return status;
} // CspCaptureAddressInformation


VOID
CspCleanupAddressInformation(
    PCS_ADDRESS_INFORMATION Information
    )
{
    Free0(Information->IPAddress);
    Free0(Information->SubnetMask);
    Free0(Information->DefaultGateway);
    Free0(Information->EnableDHCP);
} // CspCleanupAddressInformation


ULONG
CspRemoveFirewallConnection(
    LPRASSHARECONN Connection,
    ULONG Position,
    LPRASSHARECONN ConnectionArray,
    ULONG Count
    )

/*++

Routine Description:

    This routine is invoked to remove a connection to the registry set.

Arguments:

    Connection - the connection to remove

    Number - its index in ConnectionArray

    ConnectionArray - currently firewalled connections

    Count - the number of entries in ConnectionArray
    
Return Value:

    Win32 error code

--*/

{
    HANDLE Key;
    UNICODE_STRING ValueName;
    ULONG i;
    NTSTATUS Status;

    //
    // +11 is enough room to hold the digits of a number >4,000,000,000, so
    // buffer overflow won't be an issue below.
    //
    
    WCHAR wsz[sizeof(c_szFirewallConnection)/sizeof(WCHAR) + 11];

    //
    // Open the key to IPFirewall/Parameters
    //

    Status = CsOpenKey(&Key, KEY_ALL_ACCESS, c_szSharedAccessParametersKey);
    if (!NT_SUCCESS(Status)) {
        return RtlNtStatusToDosError(Status);
    }

    //
    // Shift entries above the connection we're removing down one
    // (overwriting the entry we want to remove)
    //

    for (i = Position + 1; i < Count; i++) {
    
        //
        // Generate key name for previous entry
        //

        swprintf(wsz, L"%s%u", c_szFirewallConnection, i - 1);
        RtlInitUnicodeString(&ValueName, wsz);

        //
        // Write current entry into previous slot
        //

        Status = NtSetValueKey(
                Key,
                &ValueName,
                0,
                REG_BINARY,
                &ConnectionArray[i],
                ConnectionArray[i].dwSize
                );

        if(!NT_SUCCESS(Status)) {
            NtClose(Key);
            return RtlNtStatusToDosError(Status);
        }
    }

    //
    // Delete the last entry. This is either the entry we want to
    // remove (if it was the last entry to begin with), or an entry
    // that has already been duplicated into the previous position.
    //

    swprintf(wsz, L"%s%u", c_szFirewallConnection, Count - 1);
    RtlInitUnicodeString(&ValueName, wsz);

    Status = NtDeleteValueKey(Key, &ValueName);

    if(!NT_SUCCESS(Status)) {
        NtClose(Key);
        return RtlNtStatusToDosError(Status);
    }


    //
    // Store the decremented count in the registry
    //

    RtlInitUnicodeString(&ValueName, c_szFirewallConnectionCount);
    i = Count - 1;

    Status = NtSetValueKey(
                Key,
                &ValueName,
                0,
                REG_DWORD,
                &i,
                sizeof(DWORD)
                );


    NtClose(Key);
    return RtlNtStatusToDosError(Status);
} // CspRemoveFirewallConnection



ULONG
CsQueryFirewallConnections(
    LPRASSHARECONN ConnectionArray,
    ULONG *ConnectionCount
    )

/*++

Routine Description:

    This routine is invoked to retrieve the firewalled connections, if any.

Arguments:

    ConnectionArray - receives the retrieved connections.

    ConnectionCount - in: how many entries the array can hold
                       out: number of entries returned, or the needed
                            size of the array (for ERROR_INSUFFICIENT_BUFFER)

Return Value:

    ULONG - Win32 status code.

--*/

{
    HANDLE Key;
    PKEY_VALUE_PARTIAL_INFORMATION Information;
    NTSTATUS Status;
    ULONG Count;
    ULONG i;

    if (!ConnectionCount) { return ERROR_INVALID_PARAMETER; }
    if (*ConnectionCount && !ConnectionArray) {
        //
        // It's OK to pass in NULL for the array if just trying
        // to determine what size buffer to use
        //
        
        return ERROR_INVALID_PARAMETER;
    }

    //
    // Open the 'SharedAccess\Parameters' key,
    // and read the 'FirewallConnectionCount' value
    //

    Status = CsOpenKey(&Key, KEY_READ, c_szSharedAccessParametersKey);
    if (!NT_SUCCESS(Status)) {
        TRACE1(
            "CsQueryFirewallConnections: CsOpenKey=%x", Status
            );
        return RtlNtStatusToDosError(Status);
    }

    Status = CsQueryValueKey(Key, c_szFirewallConnectionCount, &Information);
    if (NT_SUCCESS(Status)) {

        //
        // Validate the information, and check to see if the passed in array
        // is sufficient in size.
        //

        if (Information->DataLength != sizeof(DWORD) ||
            Information->Type != REG_DWORD) {
            
            TRACE(
                "CsQueryFirewallConnections: invalid data in registry for count"
                );
            NtClose(Key);
            Free(Information);
            return ERROR_INVALID_DATA;

        }

        Count = (ULONG) *Information->Data;
        Free(Information);

    } else {
        Count = 0;
    }

    if (*ConnectionCount < Count) {
        //
        // Too many entries for the passed in buffer
        //

        NtClose(Key);
        *ConnectionCount = Count;
        return ERROR_INSUFFICIENT_BUFFER;
    }

    *ConnectionCount = Count;

    //
    // Read all of the connection entries from the registry.
    //

    for(i = 0; i < Count; i++) {
        WCHAR wsz[sizeof(c_szFirewallConnection)/sizeof(WCHAR) + 11];

        swprintf(wsz, L"%s%u", c_szFirewallConnection, i);
        Status = CsQueryValueKey(Key, wsz, &Information);
        if (!NT_SUCCESS(Status)) {
            NtClose(Key);
            return RtlNtStatusToDosError(Status);
        }

        //
        // Validate the retrieved information,
        // and copy it to the given buffer
        //

        if (Information->DataLength != sizeof(RASSHARECONN) ||
            ((LPRASSHARECONN)Information->Data)->dwSize != sizeof(RASSHARECONN)) {

            TRACE2(
                "CsQueryFirewallConnections: invalid length %d (size=%d) in registry",
                Information->DataLength,
                ((LPRASSHARECONN)Information->Data)->dwSize
                );
                
            Free(Information);
            NtClose(Key);
            return ERROR_INVALID_DATA;
        }

        CopyMemory(&ConnectionArray[i], Information->Data, sizeof(RASSHARECONN));
        Free(Information);
    }

    return NO_ERROR;

} // CsQueryFirewallConnections


BOOLEAN
CspIsConnectionFwWorker(
    LPRASSHARECONN ConnectionArray,
    ULONG Count,
    LPRASSHARECONN Connection,
    ULONG *Position OUT OPTIONAL
    )

/*++

Routine Description:

    This routine is invoked to determine if a connection is firewalled

Arguments:

    ConnectionArray - Buffer containing currently FWd connections

    Count - number of connections in the array

    Connection - the connection to check

    Position - receives the number of the connection, if found (undefined otherwise)

Return Value:

    BOOLEAN -- true if the passed in connection is currently firewalled

--*/

{
    ULONG i;

    for (i = 0; i < Count; i++) {
        if (RasIsEqualSharedConnection(Connection, &ConnectionArray[i])) {
            if (Position) *Position = i;
            return TRUE;
        }
    }

    return FALSE;
} // FwpIsConnectionFwWorker


NTSTATUS
CspRestoreAddressInformation(
    HANDLE Key,
    PWCHAR AdapterGuid
    )
{
    HANDLE AdapterKey = NULL;
    PWCHAR AdapterKeyName = NULL;
    PDHCPNOTIFYCONFIGCHANGE DhcpNotifyConfigChange;
    ULONG Error;
    HINSTANCE Hinstance;
    CS_ADDRESS_INFORMATION Information;
    ULONG Length;
    NTSTATUS status;
    UNICODE_STRING UnicodeString;

    if (!(Hinstance = LoadLibraryW(c_szDhcpcsvcDll)) ||
        !(DhcpNotifyConfigChange =
            (PDHCPNOTIFYCONFIGCHANGE)
                GetProcAddress(
                    Hinstance, c_szDhcpNotifyConfigChange
                    ))) {
        if (Hinstance) { FreeLibrary(Hinstance); }
        return ERROR_PROC_NOT_FOUND;
    }

    do {

        ZeroMemory(&Information, sizeof(Information));
        status =
            CsQueryValueKey(
                Key, c_szBackupIPAddress, &Information.IPAddress
                );
        if (!NT_SUCCESS(status)) { break; }
        status =
            CsQueryValueKey(
                Key, c_szBackupSubnetMask, &Information.SubnetMask
                );
        if (!NT_SUCCESS(status)) { break; }
        status =
            CsQueryValueKey(
                Key, c_szBackupDefaultGateway, &Information.DefaultGateway
                );
        if (!NT_SUCCESS(status)) { break; }
        status =
            CsQueryValueKey(
                Key, c_szBackupEnableDHCP, &Information.EnableDHCP
                );
        if (!NT_SUCCESS(status)) { break; }

        Length =
            sizeof(WCHAR) *
            (lstrlenW(c_szTcpipParametersKey) + 1 +
             lstrlenW(c_szInterfaces) + 1 +
             lstrlenW(AdapterGuid) + 2);
        if (!(AdapterKeyName = Malloc(Length))) {
            status = STATUS_NO_MEMORY;
            break;
        }

        wsprintfW(
            AdapterKeyName, L"%ls\\%ls\\%ls", c_szTcpipParametersKey,
            c_szInterfaces, AdapterGuid
            );
        status = CsOpenKey(&AdapterKey, KEY_ALL_ACCESS, AdapterKeyName);
        if (!NT_SUCCESS(status)) { break; }

        RtlInitUnicodeString(&UnicodeString, c_szIPAddress);
        status =
            NtSetValueKey(
                AdapterKey,
                &UnicodeString,
                0,
                Information.IPAddress->Type,
                Information.IPAddress->Data,
                Information.IPAddress->DataLength
                );
        RtlInitUnicodeString(&UnicodeString, c_szSubnetMask);
        status =
            NtSetValueKey(
                AdapterKey,
                &UnicodeString,
                0,
                Information.SubnetMask->Type,
                Information.SubnetMask->Data,
                Information.SubnetMask->DataLength
                );
        RtlInitUnicodeString(&UnicodeString, c_szDefaultGateway);
        status =
            NtSetValueKey(
                AdapterKey,
                &UnicodeString,
                0,
                Information.DefaultGateway->Type,
                Information.DefaultGateway->Data,
                Information.DefaultGateway->DataLength
                );
        RtlInitUnicodeString(&UnicodeString, c_szEnableDHCP);
        status =
            NtSetValueKey(
                AdapterKey,
                &UnicodeString,
                0,
                Information.EnableDHCP->Type,
                Information.EnableDHCP->Data,
                Information.EnableDHCP->DataLength
                );
        if (!NT_SUCCESS(status)) { break; }

        RtlInitUnicodeString(&UnicodeString, c_szBackupIPAddress);
        NtDeleteValueKey(Key, &UnicodeString);
        RtlInitUnicodeString(&UnicodeString, c_szBackupSubnetMask);
        NtDeleteValueKey(Key, &UnicodeString);
        RtlInitUnicodeString(&UnicodeString, c_szBackupDefaultGateway);
        NtDeleteValueKey(Key, &UnicodeString);
        RtlInitUnicodeString(&UnicodeString, c_szBackupEnableDHCP);
        NtDeleteValueKey(Key, &UnicodeString);

        if (*(PULONG)Information.EnableDHCP->Data) {
            Error =
                DhcpNotifyConfigChange(
                    NULL,
                    AdapterGuid,
                    FALSE,
                    0,
                    0,
                    0,
                    DhcpEnable
                    );
        } else {

            ULONG Address;
            UNICODE_STRING BindList;
            UNICODE_STRING LowerComponent;
            ULONG Mask;
            IP_PNP_RECONFIG_REQUEST Request;
            UNICODE_STRING UpperComponent;

            Address = IpPszToHostAddr((PWCHAR)Information.IPAddress->Data);
            if (Address) {
                Address = RtlUlongByteSwap(Address);
                Mask = IpPszToHostAddr((PWCHAR)Information.SubnetMask->Data);
                if (Mask) {
                    Mask = RtlUlongByteSwap(Mask);
                    Error =
                        DhcpNotifyConfigChange(
                            NULL,
                            AdapterGuid,
                            TRUE,
                            0,
                            Address,
                            Mask,
                            DhcpDisable
                            );
                }
            }

            RtlInitUnicodeString(&BindList, c_szEmpty);
            RtlInitUnicodeString(&LowerComponent, c_szEmpty);
            RtlInitUnicodeString(&UpperComponent, c_szTcpip);
            ZeroMemory(&Request, sizeof(Request));
            Request.version = IP_PNP_RECONFIG_VERSION;
            Request.gatewayListUpdate = TRUE;
            Request.Flags = IP_PNP_FLAG_GATEWAY_LIST_UPDATE;
            status =
                NdisHandlePnPEvent(
                    NDIS,
                    RECONFIGURE,
                    &LowerComponent,
                    &UpperComponent,
                    &BindList,
                    &Request,
                    sizeof(Request)
                    );
        }
    } while(FALSE);
    if (AdapterKey) { NtClose(AdapterKey); }
    Free0(AdapterKeyName);
    CspCleanupAddressInformation(&Information);
    FreeLibrary(Hinstance);
    return status;
} // CspRestoreAddressInformation


ULONG
CsQueryLanConnTable(
    LPRASSHARECONN ExcludedConnection,
    NETCON_PROPERTIES** LanConnTable,
    LPDWORD LanConnCount
    )

/*++

Routine Description:

    This routine is invoked to retrieve an array of LAN connections,
    discounting 'ExcludeConnection', which will typically be the name
    of the public interface.

Arguments:

    ExcludeConnection - a connection not allowed to be the private connection

    LanConnTable - optionally receives a table of possible private networks.

    LanConnCount - receives a count of the possible private networks.

Return Value:

    ULONG - Win32 status code.

--*/

{
    BOOLEAN CleanupOle = TRUE;
    INetConnection* ConArray[32];
    ULONG ConCount;
    INetConnectionManager* ConMan = NULL;
    IEnumNetConnection* EnumCon = NULL;
    ULONG Error;
    HRESULT hr;
    ULONG i;
    ULONG j;
    ULONG LanCount = 0;
    NETCON_PROPERTIES* LanProps = NULL;
    NETCON_PROPERTIES* LanTable = NULL;
    BSTR Name;
    NETCON_STATUS ncs;
    NTSTATUS status;
    ULONG Size;
    NETCON_MEDIATYPE MediaType;
    UNICODE_STRING UnicodeString;

    *LanConnCount = 0;
    if (LanConnTable) { *LanConnTable = NULL; }

    hr = g_pCoInitializeEx(NULL, COINIT_MULTITHREADED|COINIT_DISABLE_OLE1DDE);
    if (!SUCCEEDED(hr)) {
        if (hr == RPC_E_CHANGED_MODE) {
            CleanupOle = FALSE;
        } else {
            TRACE1("CsQueryLanConnTable: CoInitializeEx=%x", hr);
            return ERROR_CAN_NOT_COMPLETE;
        }
    }

    i = 0;
    Error = NO_ERROR;

    do {

        //
        // Instantiate the connection manager
        //

        hr =
            g_pCoCreateInstance(
                &CLSID_ConnectionManager,
                NULL,
                CLSCTX_SERVER,
                &IID_INetConnectionManager,
                (PVOID*)&ConMan
                );
        if (!SUCCEEDED(hr)) {
            TRACE1("CsQueryLanConnTable: CoCreateInstance=%x", hr);
            ConMan = NULL; break;
        }

        //
        // Instantiate a connection-enumerator
        //

        hr =
            INetConnectionManager_EnumConnections(
                ConMan,
                NCME_DEFAULT,
                &EnumCon
                );
        if (!SUCCEEDED(hr)) {
            TRACE1("CsQueryLanConnTable: EnumConnections=%x", hr);
            EnumCon = NULL; break;
        }

        hr =
            g_pCoSetProxyBlanket(
                (IUnknown*)EnumCon,
                RPC_C_AUTHN_WINNT,
                RPC_C_AUTHN_NONE,
                NULL,
                RPC_C_AUTHN_LEVEL_CALL,
                RPC_C_IMP_LEVEL_IMPERSONATE,
                NULL,
                EOAC_NONE
                );

        //
        // Enumerate the items
        //

        for ( ; ; ) {

            hr =
                IEnumNetConnection_Next(
                    EnumCon,
                    Dimension(ConArray),
                    ConArray,
                    &ConCount
                    );
            if (!SUCCEEDED(hr) || !ConCount) { hr = S_OK; break; }

            if (LanConnTable) {

                //
                // Allocate or reallocate the memory for storing
                // connections which we will return to the caller.
                //

                if (!LanTable) {
                    LanTable =
                        (NETCON_PROPERTIES*)
                            GlobalAlloc(
                                0,
                                ConCount * sizeof(NETCON_PROPERTIES)
                                );
                } else {
                    PVOID Temp =
                        GlobalAlloc(
                            0,
                            (LanCount + ConCount) * sizeof(NETCON_PROPERTIES)
                            );
                    if (Temp) {
                        CopyMemory(
                            Temp,
                            LanTable,
                            LanCount * sizeof(NETCON_PROPERTIES)
                            );
                    }
                    GlobalFree(LanTable);
                    LanTable = Temp;
                }

                if (!LanTable) { Error = ERROR_NOT_ENOUGH_MEMORY; break; }
            }

            LanCount += ConCount;

            //
            // Examine the properties for the connections retrieved
            //

            for (j = 0; j < ConCount; j++) {

                hr = INetConnection_GetProperties(ConArray[j], &LanProps);
                INetConnection_Release(ConArray[j]);

                if (SUCCEEDED(hr) &&
                    LanProps->MediaType == NCM_LAN &&
                    (!ExcludedConnection->fIsLanConnection ||
                     !IsEqualGUID(
                        &ExcludedConnection->guid, &LanProps->guidId))) {

                    //
                    // This connection qualifies to be private; copy it.
                    //

                    if (!LanConnTable) {
                        ++i;
                    } else {
                        LanTable[i] = *LanProps;
                        LanTable[i].pszwName = StrDupW(LanProps->pszwName);
                        LanTable[i].pszwDeviceName =
                            StrDupW(LanProps->pszwDeviceName);
                        if (LanTable[i].pszwName &&
                            LanTable[i].pszwDeviceName
                            ) {
                            ++i;
                        } else {
                            Free0(LanTable[i].pszwName);
                            Free0(LanTable[i].pszwDeviceName);
                        }
                    }
                }

                if (LanProps) {
                    g_pCoTaskMemFree(LanProps->pszwName);
                    g_pCoTaskMemFree(LanProps->pszwDeviceName);
                    g_pCoTaskMemFree(LanProps);
                    LanProps = NULL;
                }
            }
        }

    } while (FALSE);

    if (EnumCon) { IEnumNetConnection_Release(EnumCon); }
    if (ConMan) { INetConnectionManager_Release(ConMan); }
    if (CleanupOle) { g_pCoUninitialize(); }

    if (LanConnTable) { *LanConnTable = LanTable; }
    *LanConnCount = i;

    return Error;

} // CsQueryLanConnTable


VOID
CsQueryScopeInformation(
    IN OUT PHANDLE Key,
    PULONG Address,
    PULONG Mask
    )

/*++

Routine Description:

    This routine is called to retrieve the private network address and mask
    to be used for shared access. If no value is found, the default
    is supplied.

Arguments:

    Key - optionally supplies an open handle to the SharedAccess\Parameters
        registry key

    Address - receives the address for the private network,
        in network byte order

    Mask - receives the mask for the private network, in network byte order

Return Value:

    none.

--*/

{
    PKEY_VALUE_PARTIAL_INFORMATION Information;
    HANDLE LocalKey = NULL;
    NTSTATUS status;

    if (!Key) { Key = &LocalKey; }
    if (*Key) {
        status = STATUS_SUCCESS;
    } else {
        status = CsOpenKey(Key, KEY_ALL_ACCESS, c_szSharedAccessParametersKey);
    }

    if (NT_SUCCESS(status)) {
        status = CsQueryValueKey(*Key, c_szScopeAddress, &Information);
        if (NT_SUCCESS(status)) {
            if (!(*Address = IpPszToHostAddr((PWCHAR)Information->Data))) {
                Free(Information);
            } else {
                Free(Information);
                status = CsQueryValueKey(*Key, c_szScopeMask, &Information);
                if (NT_SUCCESS(status)) {
                    if (!(*Mask = IpPszToHostAddr((PWCHAR)Information->Data))) {
                        Free(Information);
                    } else {
                        Free(Information);
                        *Address = RtlUlongByteSwap(*Address);
                        *Mask = RtlUlongByteSwap(*Mask);
                        if (LocalKey) { NtClose(LocalKey); }
                        return;
                    }
                }
            }
        }
    }

    *Address = DEFAULT_SCOPE_ADDRESS;
    *Mask = DEFAULT_SCOPE_MASK;
    if (LocalKey) { NtClose(LocalKey); }

} // CsQueryScopeInformation

#endif


ULONG
CsQuerySharedConnection(
    LPRASSHARECONN Connection
    )

/*++

Routine Description:

    This routine is invoked to retrieve the shared connection, if any.

Arguments:

    Connection - receives the retrieved connection.

Return Value:

    ULONG - Win32 status code.

--*/

{
    BOOL fUninitializeCOM = TRUE;
    IHNetIcsSettings *pIcsSettings;
    IEnumHNetIcsPublicConnections *pEnumIcsPub;
    IHNetIcsPublicConnection *pIcsPub;
    IHNetConnection *pConn;
    ULONG ulCount;
    HRESULT hr;
    
    ASSERT(NULL != g_pCoInitializeEx);
    ASSERT(NULL != g_pCoCreateInstance);
    ASSERT(NULL != g_pCoUninitialize);

    if (!Connection) { return ERROR_INVALID_PARAMETER; }
    
    hr = g_pCoInitializeEx(
            NULL,
            COINIT_MULTITHREADED | COINIT_DISABLE_OLE1DDE
            );

    if (FAILED(hr))
    {
        fUninitializeCOM = FALSE;
                
        if(RPC_E_CHANGED_MODE == hr)
        {
            hr = S_OK;    
        }
    }
    
    if (SUCCEEDED(hr)) 
    {
        hr = g_pCoCreateInstance(
                &CLSID_HNetCfgMgr,
                NULL,
                CLSCTX_ALL,
                &IID_IHNetIcsSettings,
                (VOID**)&pIcsSettings
                );
    }

    if (SUCCEEDED(hr))
    {
        hr = IHNetIcsSettings_EnumIcsPublicConnections(
                pIcsSettings,
                &pEnumIcsPub
                );

        IHNetIcsSettings_Release(pIcsSettings);
    }

    if (SUCCEEDED(hr))
    {
        hr = IEnumHNetIcsPublicConnections_Next(
                pEnumIcsPub,
                1,
                &pIcsPub,
                &ulCount
                );

        IEnumHNetIcsPublicConnections_Release(pEnumIcsPub);
    }

    if (SUCCEEDED(hr) && 1 == ulCount)
    {
        hr = IHNetIcsPublicConnection_QueryInterface(
                pIcsPub,
                &IID_IHNetConnection,
                (VOID**)&pConn
                );

        IHNetIcsPublicConnection_Release(pIcsPub);
    }
    else
    {
        hr = E_FAIL;
    }

    if (SUCCEEDED(hr))
    {
        HNET_CONN_PROPERTIES *pProps;
        
        //
        // Convert the IHNetConnection to a RASSHARECONN
        //

        hr = IHNetConnection_GetProperties(pConn, &pProps);

        if (SUCCEEDED(hr) && pProps->fLanConnection)
        {
            GUID *pGuid;
        
            g_pCoTaskMemFree(pProps);
            hr = IHNetConnection_GetGuid(pConn, &pGuid);

            if (SUCCEEDED(hr))
            {
                RasGuidToSharedConnection(pGuid, Connection);
                g_pCoTaskMemFree(pGuid);
            }
        }
        else if (SUCCEEDED(hr))
        {
            LPWSTR pszwName;
            LPWSTR pszwPath;
            
            g_pCoTaskMemFree(pProps);

            hr = IHNetConnection_GetName(pConn, &pszwName);

            if (SUCCEEDED(hr))
            {
                hr = IHNetConnection_GetRasPhonebookPath(pConn, &pszwPath);

                if (SUCCEEDED(hr))
                {
                    RasEntryToSharedConnection(pszwPath, pszwName, Connection);

                    g_pCoTaskMemFree(pszwPath);
                }

                g_pCoTaskMemFree(pszwName);
            }
        }

        IHNetConnection_Release(pConn);
    }

    if (fUninitializeCOM)
    {
        g_pCoUninitialize();
    }

    return SUCCEEDED(hr) ? NO_ERROR : ERROR_CAN_NOT_COMPLETE;

} // CsQuerySharedConnection

#if 0


ULONG
CsQuerySharedPrivateLan(
    GUID* LanGuid
    )

/*++

Routine Description:

    This routine is invoked to retrieve the private LAN connection, if any.

Arguments:

    LanGuid - receives the retrieved GUID.

Return Value:

    ULONG - Win32 status code.

--*/

{
    ULONG Error;
    HANDLE Key;
    PKEY_VALUE_PARTIAL_INFORMATION Information;
    NTSTATUS status;
    UNICODE_STRING UnicodeString;

    //
    // Open the 'SharedAccess\Parameters' key, read the 'SharedPrivateLan'
    // value, and convert it to a GUID
    //

    status = CsOpenKey(&Key, KEY_READ, c_szSharedAccessParametersKey);
    if (!NT_SUCCESS(status)) {
        TRACE1("CsQuerySharedPrivateLan: NtOpenKey=%x", status);
        return RtlNtStatusToDosError(status);
    }

    status = CsQueryValueKey(Key, c_szSharedPrivateLan, &Information);
    NtClose(Key);
    if (!NT_SUCCESS(status)) { return NO_ERROR; }

    RtlInitUnicodeString(&UnicodeString, (PWCHAR)Information->Data);
    status = RtlGUIDFromString(&UnicodeString, LanGuid);
    Free(Information);
    return NT_SUCCESS(status) ? NO_ERROR : RtlNtStatusToDosError(status);

} // CsQuerySharedPrivateLan


ULONG
CsQuerySharedPrivateLanAddress(
    PULONG Address
    )

/*++

Routine Description:

    This routine is invoked to retrieve the IP address assigned
    to the shared private LAN interface.

Arguments:

    Address - on output, receives the IP address of the shared private LAN
        interface.

Return Value:

    ULONG - Win32 status code.

--*/

{
    ULONG AdapterIndex;
    PALLOCATEANDGETIPADDRTABLEFROMSTACK AllocateAndGetIpAddrTableFromStack;
    ULONG Error;
    PGETINTERFACEINFO GetInterfaceInfo;
    HINSTANCE Hinstance;
    ULONG i;
    PKEY_VALUE_PARTIAL_INFORMATION Information;
    HANDLE Key = NULL;
    NTSTATUS status;
    PMIB_IPADDRTABLE Table;

    if (!Address) { return ERROR_INVALID_PARAMETER; }

    //
    // Open the service's Parameters key and attempt to retrieve
    // the GUID for the shared private LAN interface.
    //

    status = CsOpenKey(&Key, KEY_READ, c_szSharedAccessParametersKey);
    if (!NT_SUCCESS(status)) {
        TRACE1("CsQuerySharedPrivateLanAddress: NtOpenKey=%x", status);
        return RtlNtStatusToDosError(status);
    }
    status = CsQueryValueKey(Key, c_szSharedPrivateLan, &Information);
    NtClose(Key);
    if (!NT_SUCCESS(status)) { return ERROR_SHARING_NO_PRIVATE_LAN; }

    //
    // Load IPHLPAPI, which contains the 'GetInterfaceInfo' entrypoint
    // that we will use to map this GUID to an adapter-index,
    // as well as the 'AllocateAndGetIpAddrTableFromStack' entrypoint
    // that we will use to map the adapter-index to an IP address list.
    //

    if (!(Hinstance = LoadLibraryW(c_szIphlpapiDll)) ||
        !(AllocateAndGetIpAddrTableFromStack =
            (PALLOCATEANDGETIPADDRTABLEFROMSTACK)
                GetProcAddress(
                    Hinstance, c_szAllocateAndGetIpAddrTableFromStack
                    )) ||
        !(GetInterfaceInfo =
            (PGETINTERFACEINFO)
                GetProcAddress(
                    Hinstance, c_szGetInterfaceInfo
                    ))) {
        if (Hinstance) { FreeLibrary(Hinstance); }
        Free(Information);
        return ERROR_PROC_NOT_FOUND;
    }

    //
    // Map the GUID to an adapter index.
    //

    AdapterIndex =
        CsMapGuidToAdapterIndex((PWCHAR)Information->Data, GetInterfaceInfo);
    Free(Information);
    if (AdapterIndex == (ULONG)-1) {
        FreeLibrary(Hinstance);
        return ERROR_SHARING_NO_PRIVATE_LAN;
    }

    //
    // Map the adapter index to an IP address
    //

    Error =
        AllocateAndGetIpAddrTableFromStack(
            &Table,
            FALSE,
            GetProcessHeap(),
            0
            );
    FreeLibrary(Hinstance);
    if (Error) { return Error; }
    for (i = 0; i < Table->dwNumEntries; i++) {
        if (AdapterIndex == Table->table[i].dwIndex) {
            break;
        }
    }
    if (i >= Table->dwNumEntries) {
        Error = ERROR_SHARING_NO_PRIVATE_LAN;
    } else {
        *Address = Table->table[i].dwAddr;
    }
    HeapFree(GetProcessHeap(), 0, Table);
    return Error;

} // CsQuerySharedPrivateLanAddress

#endif


NTSTATUS
CsQueryValueKey(
    HANDLE Key,
    const WCHAR ValueName[],
    PKEY_VALUE_PARTIAL_INFORMATION* Information
    )

/*++

Routine Description:

    This routine is called to obtain the value of a registry key.

Arguments:

    Key - the key to be queried

    ValueName - the value to be queried

    Information - receives a pointer to the information read

Return Value:

    NTSTATUS - NT status code.

--*/

{
    UCHAR Buffer[sizeof(KEY_VALUE_PARTIAL_INFORMATION)];
    ULONG InformationLength;
    NTSTATUS status;
    UNICODE_STRING UnicodeString;

    RtlInitUnicodeString(&UnicodeString, ValueName);

    *Information = (PKEY_VALUE_PARTIAL_INFORMATION)Buffer;
    InformationLength = sizeof(KEY_VALUE_PARTIAL_INFORMATION);

    //
    // Read the value's size
    //

    status =
        NtQueryValueKey(
            Key,
            &UnicodeString,
            KeyValuePartialInformation,
            *Information,
            InformationLength,
            &InformationLength
            );

    if (!NT_SUCCESS(status) && status != STATUS_BUFFER_OVERFLOW &&
        status != STATUS_BUFFER_TOO_SMALL) {
        *Information = NULL;
        return status;
    }

    //
    // Allocate space for the value's size
    //

    *Information = (PKEY_VALUE_PARTIAL_INFORMATION)Malloc(InformationLength+2);
    if (!*Information) { return STATUS_NO_MEMORY; }

    //
    // Read the value's data
    //

    status =
        NtQueryValueKey(
            Key,
            &UnicodeString,
            KeyValuePartialInformation,
            *Information,
            InformationLength,
            &InformationLength
            );
    if (!NT_SUCCESS(status)) { Free(*Information); *Information = NULL; }
    return status;

} // CsQueryValueKey

#if 0


ULONG
CsRenameSharedConnection(
    LPRASSHARECONN NewConnection
    )

/*++

Routine Description:

    This routine is invoked to change the name of the currently-shared
    connection, if any. It is assumed that the private LAN will remain
    unchanged, and that the connection which is currently shared is a dialup
    connection.

Arguments:

    NewConnection - the new name for the shared connection

Return Value:

    ULONG - Win32 status code.

--*/

{
    HANDLE AdminHandle;
    PUCHAR Buffer;
    LPRASSHARECONN OldConnection;
    ULONG Error;
    PUCHAR Header;
    HANDLE Key;
    PKEY_VALUE_PARTIAL_INFORMATION Information;
    HANDLE InterfaceHandle;
    ULONG Length;
    OBJECT_ATTRIBUTES ObjectAttributes;
    HANDLE ServerHandle;
    NTSTATUS status;
    UNICODE_STRING UnicodeString;

    //
    // Open the 'SharedAccess\Parameters' key,
    // and read the 'SharedConnection' value
    //

    status = CsOpenKey(&Key, KEY_READ, c_szSharedAccessParametersKey);
    if (!NT_SUCCESS(status)) {
        TRACE1("CsRenameSharedConnection: NtOpenKey=%x", status);
        return RtlNtStatusToDosError(status);
    }

    status = CsQueryValueKey(Key, c_szSharedConnection, &Information);
    NtClose(Key);
    if (!NT_SUCCESS(status)) { return NO_ERROR; }

    //
    // Validate the data retrieved
    //

    if (Information->DataLength != sizeof(RASSHARECONN) ||
        ((LPRASSHARECONN)Information->Data)->dwSize != sizeof(RASSHARECONN)
        ) {
        TRACE2(
            "CsRenameSharedConnection: invalid length %d (size=%d) in registry",
            Information->DataLength, ((LPRASSHARECONN)Information->Data)->dwSize
            );
        Free(Information); return NO_ERROR;
    }

    //
    // Ensure that the connection which was shared is not a LAN connection,
    // and if so proceed to share the new connection instead.
    //

    OldConnection = (LPRASSHARECONN)Information->Data;
    if (OldConnection->fIsLanConnection) {
        TRACE("CsRenameSharedConnection: cannot rename shared LAN connection");
        Free(Information); return ERROR_INVALID_PARAMETER;
    }

    //
    // Clear any cached credentials for the old connection,
    // and share the new connection.
    //

    RasSetSharedConnectionCredentials(OldConnection, NULL);
    Free(Information);
    
    return CsShareConnection(NewConnection);

} // CsRenameSharedConnection


ULONG
CsSetupSharedPrivateLan(
    REFGUID LanGuid,
    BOOLEAN EnableSharing
    )

/*++

Routine Description:

    This routine is invoked to configure the designated private connection.

Arguments:

    LanGuid - identifies the LAN connection to be configured

    EnableSharing - if TRUE, sharing is enabled and the static address is set;
        otherwise, sharing is disabled.

Return Value:

    ULONG - Win32 status code.

--*/

{
    CS_ADDRESS_INFORMATION AddressInformation;
    PALLOCATEANDGETIPADDRTABLEFROMSTACK AllocateAndGetIpAddrTableFromStack;
    ANSI_STRING AnsiString;
    ULONG Error;
    PGETINTERFACEINFO GetInterfaceInfo;
    HINSTANCE Hinstance;
    ULONG i;
    HANDLE Key = NULL;
    UNICODE_STRING LanGuidString;
    ULONG ScopeAddress;
    ULONG ScopeMask;
    PSETADAPTERIPADDRESS SetAdapterIpAddress;
    ULONG Size;
    NTSTATUS status;
    PMIB_IPADDRTABLE Table;
    UNICODE_STRING UnicodeString;

    //
    // To install or remove the static private IP address,
    // we make use of several entrypoints in IPHLPAPI.DLL,
    // which we now load dynamically.
    //

    RtlStringFromGUID(LanGuid, &UnicodeString);
    RtlUnicodeStringToAnsiString(&AnsiString, &UnicodeString, TRUE);
    if (!(Hinstance = LoadLibraryW(c_szIphlpapiDll)) ||
        !(AllocateAndGetIpAddrTableFromStack =
            (PALLOCATEANDGETIPADDRTABLEFROMSTACK)
                GetProcAddress(
                    Hinstance, c_szAllocateAndGetIpAddrTableFromStack
                    )) ||
        !(GetInterfaceInfo =
            (PGETINTERFACEINFO)
                GetProcAddress(
                    Hinstance, c_szGetInterfaceInfo
                    )) ||
        !(SetAdapterIpAddress =
            (PSETADAPTERIPADDRESS)
                GetProcAddress(
                    Hinstance, c_szSetAdapterIpAddress
                    ))) {
        if (Hinstance) { FreeLibrary(Hinstance); }
        RtlFreeUnicodeString(&UnicodeString);
        RtlFreeAnsiString(&AnsiString);
        return ERROR_PROC_NOT_FOUND;
    }

    //
    // Determine whether some LAN adapter other than the private LAN
    // is already using a 169.254.0.0 address.
    // In the process, make sure that the private LAN has only one
    // IP address (otherwise, 'SetAdapterIpAddress' fails.)
    //

    CsQueryScopeInformation(&Key, &ScopeAddress, &ScopeMask);
    if (!Key) {
        FreeLibrary(Hinstance);
        RtlFreeUnicodeString(&UnicodeString);
        RtlFreeAnsiString(&AnsiString);
        return ERROR_CAN_NOT_COMPLETE;
    }
    Error =
        AllocateAndGetIpAddrTableFromStack(
            &Table,
            FALSE,
            GetProcessHeap(),
            0
            );
    if (!Error) {
        ULONG Index;
        ULONG Count;
        Index = CsMapGuidToAdapterIndex(UnicodeString.Buffer, GetInterfaceInfo);
        for (i = 0, Count = 0; i < Table->dwNumEntries; i++) {
            if (Index == Table->table[i].dwIndex) {
                ++Count;
            } else if ((Table->table[i].dwAddr & ScopeMask) ==
                       (ScopeAddress & ScopeMask)) {
                //
                // It appears that some other LAN adapter has an address in
                // the proposed scope.
                // This may happen when multiple netcards go into autonet mode
                // or when the RAS server is handing out autonet addresses.
                // Therefore, as long as we're using the autonet scope,
                // allow this behavior; otherwise prohibit it.
                //
                if ((ScopeAddress & ScopeMask) != 0x0000fea9) {
                    break;
                }
            }
        }
        if (i < Table->dwNumEntries) {
            Error = ERROR_SHARING_ADDRESS_EXISTS;
        } else if (Count > 1) {
            Error = ERROR_SHARING_MULTIPLE_ADDRESSES;
        }
        HeapFree(GetProcessHeap(), 0, Table);
    }

    if (Error) {
        FreeLibrary(Hinstance);
        RtlFreeUnicodeString(&UnicodeString);
        RtlFreeAnsiString(&AnsiString);
        NtClose(Key);
        return Error;
    }

    //
    // Set the predefined static IP address for the private LAN,
    // which we now read either from the registry or from the internal default.
    //
    // Before actually making the change, we capture the original IP address
    // so that it can be restored when the user turns off shared access.
    // Once the IP address is changed, we backup the original IP address
    // in the shared access parameters key.
    //

    status =
        CspCaptureAddressInformation(
            UnicodeString.Buffer, &AddressInformation
            );

    Error =
        SetAdapterIpAddress(
            AnsiString.Buffer,
            FALSE,
            ScopeAddress,
            ScopeMask,
            0
            );
    if (!Error) {
        if (NT_SUCCESS(status)) {
            CspBackupAddressInformation(Key, &AddressInformation);
        }
    } else {
        TRACE1("CsSetupSharedPrivateLan: SetAdapterIpAddress=%d", Error);
        if (Error == ERROR_TOO_MANY_NAMES) {
            Error = ERROR_SHARING_MULTIPLE_ADDRESSES;
        } else {
            //
            // Query the state of the connection.
            // If it is disconnected, convert the error code
            // to something more informative.
            //
            UNICODE_STRING DeviceString;
            NIC_STATISTICS NdisStatistics;
            RtlInitUnicodeString(&DeviceString, c_szDevice);
            RtlAppendUnicodeStringToString(&DeviceString, &UnicodeString);
            NdisStatistics.Size = sizeof(NdisStatistics);
            NdisQueryStatistics(&DeviceString, &NdisStatistics);
            RtlFreeUnicodeString(&DeviceString);
            if  (NdisStatistics.MediaState == MEDIA_STATE_UNKNOWN) {
                Error = ERROR_SHARING_HOST_ADDRESS_CONFLICT;
            } else if (NdisStatistics.DeviceState != DEVICE_STATE_CONNECTED ||
                NdisStatistics.MediaState != MEDIA_STATE_CONNECTED) {
                Error = ERROR_SHARING_NO_PRIVATE_LAN;
            }
        }
    }

    CspCleanupAddressInformation(&AddressInformation);
    FreeLibrary(Hinstance);
    RtlFreeUnicodeString(&UnicodeString);
    RtlFreeAnsiString(&AnsiString);
    if (Error) { NtClose(Key); return Error; }

    //
    // All went well above; now we save the name of the private LAN connection
    // under the 'SharedAccess\\Parameters' registry key.
    //

    RtlStringFromGUID(LanGuid, &LanGuidString);
    RtlInitUnicodeString(&UnicodeString, c_szSharedPrivateLan);
    status =
        NtSetValueKey(
            Key,
            &UnicodeString,
            0,
            REG_SZ,
            LanGuidString.Buffer,
            LanGuidString.Length + sizeof(WCHAR)
            );
    NtClose(Key);
    RtlFreeUnicodeString(&LanGuidString);
    if (!NT_SUCCESS(status)) { return RtlNtStatusToDosError(status); }
    return NO_ERROR;

} // CsSetupSharedPrivateLan


ULONG
CsSetSharedPrivateLan(
    REFGUID LanGuid
    )

/*++

Routine Description:

    This routine is invoked to (re)configure the designated private connection

Arguments:

    LanGuid - identifies the new LAN connection to be configured

Return Value:

    ULONG - Win32 status code.

--*/

{
    HANDLE Key;
    ULONG Error;
    NTSTATUS status;
    PKEY_VALUE_PARTIAL_INFORMATION Information;
    UNICODE_STRING UnicodeString;

    status = CsOpenKey(&Key, KEY_ALL_ACCESS, c_szSharedAccessParametersKey);
    if (!NT_SUCCESS(status)) {
        TRACE1("CsSetSharedPrivateLan: CsOpenKey=%x", status);
        return RtlNtStatusToDosError(status);
    }

    //
    // Remove old information (and reset old interface) in registry if present
    //
    
    status = CsQueryValueKey(Key, c_szSharedPrivateLan, &Information);
    RtlInitUnicodeString(&UnicodeString, c_szSharedPrivateLan);
    NtDeleteValueKey(Key, &UnicodeString);
    if (NT_SUCCESS(status)) {
        CspRestoreAddressInformation(Key, (PWCHAR)Information->Data);
        Free(Information);
    }

    //
    // Setup the private network with a private address
    //

    Error = CsSetupSharedPrivateLan(LanGuid, TRUE);
    if (Error) {
        TRACE1("CsSetSharedPrivateLan: CsSetupSharedPrivateLan=%d",Error);
        return Error;
    }

    return NO_ERROR;
    
} // CsSetSharedPrivateLan


ULONG
CsShareConnection(
    LPRASSHARECONN Connection
    )

/*++

Routine Description:

    This routine enables sharing on the connection with the given name.
    
Arguments:

    Connection - the connection to be shared

Return Value:

    ULONG - Win32 status code.

--*/

{
    UNICODE_STRING BindList;
    HANDLE Key;
    UNICODE_STRING LowerComponent;
    IP_PNP_RECONFIG_REQUEST Request;
    NTSTATUS status;
    UNICODE_STRING UpperComponent;
    ULONG Value;
    UNICODE_STRING ValueString;

    //
    // Set the 'SharedConnection' value in the registry,
    // under the 'SharedAccess\Parameters' key.
    //

    status = CsOpenKey(&Key, KEY_ALL_ACCESS, c_szSharedAccessParametersKey);
    if (!NT_SUCCESS(status)) {
        TRACE1("CsShareConnection: CsOpenKey=%x", status);
        return RtlNtStatusToDosError(status);
    }

    RtlInitUnicodeString(&ValueString, c_szSharedConnection);
    status =
        NtSetValueKey(
            Key,
            &ValueString,
            0,
            REG_BINARY,
            Connection,
            Connection->dwSize
            );
    
    NtClose(Key);
    if (!NT_SUCCESS(status)) {
        TRACE1("CsShareConnection: NtSetValueKey=%x", status);
        return RtlNtStatusToDosError(status);
    }

    return NO_ERROR;
    
} // CsShareConnection

#endif


VOID
CsShutdownModule(
    VOID
    )

/*++

Routine Description:

    This routine is invoked to clean up state for the module.

Arguments:

    none.

Return Value:

    none.

Environment:

    Invoked with 'CsCriticalSection' held by the caller.

--*/

{
    if (CsInitialized) {
        if (CsOle32Dll) { FreeLibrary(CsOle32Dll); CsOle32Dll = NULL; }
    }
} // CsShutdownModule

#if 0


ULONG
CsStartService(
    VOID
    )

/*++

Routine Description:

    This routine is invoked to start the routing and remote access service.

Arguments:

    none.

Return Value:

    ULONG - Win32 status code.

Revision History:

    Loosely based on CService::HrMoveOutOfState by KennT.

--*/

{
    ULONG Error;
    SC_HANDLE ScmHandle;
    SC_HANDLE ServiceHandle;
    SERVICE_STATUS ServiceStatus;
    ULONG Timeout;

    //
    // Connect to the service control manager
    //

    ScmHandle = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS);
    if (!ScmHandle) { return GetLastError(); }

    do {

        //
        // Open the shared access service
        //

        ServiceHandle =
            OpenService(ScmHandle, c_szSharedAccess, SERVICE_ALL_ACCESS);
        if (!ServiceHandle) { Error = GetLastError(); break; }

        //
        // Mark it as auto-start
        //

        ChangeServiceConfig(
            ServiceHandle,
            SERVICE_NO_CHANGE,
            SERVICE_AUTO_START,
            SERVICE_NO_CHANGE,
            NULL,
            NULL,
            NULL,
            NULL,
            NULL,
            NULL,
            NULL
            );

        //
        // Attempt to start the service
        //

        if (!StartService(ServiceHandle, 0, NULL)) {
            Error = GetLastError();
            if (Error == ERROR_SERVICE_ALREADY_RUNNING) { Error = NO_ERROR; }
            break;
        }

        //
        // Wait for the service to start
        //

        Timeout = 30;
        Error = ERROR_CAN_NOT_COMPLETE;

        do {

            //
            // Query the service's state
            //

            if (!QueryServiceStatus(ServiceHandle, &ServiceStatus)) {
                Error = GetLastError(); break;
            }

            //
            // See if the service has started
            //

            if (ServiceStatus.dwCurrentState == SERVICE_RUNNING) {
                Error = NO_ERROR; break;
            } else if (ServiceStatus.dwCurrentState == SERVICE_STOPPED ||
                       ServiceStatus.dwCurrentState == SERVICE_STOP_PENDING) {
                break;
            }

            //
            // Wait a little longer
            //

            Sleep(1000);

        } while(Timeout--);

    } while(FALSE);

    if (ServiceHandle) { CloseServiceHandle(ServiceHandle); }
    CloseServiceHandle(ScmHandle);

    return Error;

} // CsStartService


VOID
CsStopService(
    VOID
    )

/*++

Routine Description:

    This routine is invoked to uninstall the service.
    The routine, however, does not uninstall the service at all,
    which just goes to show you...
    Instead, it marks the service as demand-start.

Arguments:

    none.

Return Value:

    none.

--*/

{
    ULONG Error;
    SC_HANDLE ScmHandle;
    SC_HANDLE ServiceHandle;
    SERVICE_STATUS ServiceStatus;

    //
    // Connect to the service control manager
    //

    ScmHandle = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS);
    if (!ScmHandle) { return; }

    do {

        //
        // Open the shared access service
        //

        ServiceHandle =
            OpenService(ScmHandle, c_szSharedAccess, SERVICE_ALL_ACCESS);
        if (!ServiceHandle) { Error = GetLastError(); break; }

        //
        // Mark it as demand-start
        //

        ChangeServiceConfig(
            ServiceHandle,
            SERVICE_NO_CHANGE,
            SERVICE_DEMAND_START,
            SERVICE_NO_CHANGE,
            NULL,
            NULL,
            NULL,
            NULL,
            NULL,
            NULL,
            NULL
            );

        //
        // Attempt to stop the service
        //

        ControlService(ServiceHandle, SERVICE_CONTROL_STOP, &ServiceStatus);

    } while(FALSE);

    if (ServiceHandle) { CloseServiceHandle(ServiceHandle); }
    CloseServiceHandle(ScmHandle);

    return;


} // CsStopService


ULONG
CsUnshareConnection(
    BOOLEAN RemovePrivateLan,
    PBOOLEAN Shared
    )

/*++

Routine Description:

    This routine is invoked to unshare a shared connection.
    This is accomplished by removing the settings from the registry.

Arguments:

    RemovePrivateLan - if TRUE, the private LAN connection is reset
        to use DHCP rather than the NAT private address.

    Shared - receives 'TRUE' if a shared connection was found, FALSE otherwise.

Return Value:

    ULONG - Win32 status code.

--*/

{
    LPRASSHARECONN Connection;
    HANDLE Key;
    PKEY_VALUE_PARTIAL_INFORMATION Information;
    PIP_NAT_INTERFACE_INFO Info;
    GUID LanGuid;
    ULONG Length;
    ULONG Size;
    NTSTATUS status;
    UNICODE_STRING UnicodeString;

    if (Shared) { *Shared = FALSE; }

    //
    // Open the 'SharedAccess\Parameters' key, read the 'SharedConnection'
    // value, and validate the information retrieved.
    //

    status = CsOpenKey(&Key, KEY_ALL_ACCESS, c_szSharedAccessParametersKey);
    if (!NT_SUCCESS(status)) {
        TRACE1("CsUnshareConnection: NtOpenKey=%x", status);
        return RtlNtStatusToDosError(status);
    }

    //
    // Read the 'SharedConnection' value
    //

    status = CsQueryValueKey(Key, c_szSharedConnection, &Information);
    if (!NT_SUCCESS(status)) { return NO_ERROR; }

    if (Information->DataLength != sizeof(RASSHARECONN) ||
        ((LPRASSHARECONN)Information->Data)->dwSize != sizeof(RASSHARECONN)) {
        TRACE2(
            "CsUnshareConnection: invalid length %d (size=%d) in registry",
            Information->DataLength, ((LPRASSHARECONN)Information->Data)->dwSize
            );
        NtClose(Key); Free(Information); return NO_ERROR;
    }

    //
    // Inform the caller that a connection was indeed originally shared,
    // clear any credentials cached for that connection, free the buffer
    // containing the shared connection's information, and delete the
    // 'SharedConnection' value from the registry.
    //

    if (Shared) { *Shared = TRUE; }
    Connection = (LPRASSHARECONN)Information->Data;
    RasSetSharedConnectionCredentials(Connection, NULL);

    Free(Information);
    RtlInitUnicodeString(&UnicodeString, c_szSharedConnection);
    NtDeleteValueKey(Key, &UnicodeString);

    //
    // See if we're resetting the private LAN connection,
    // and if so, read (and delete) the 'SharedPrivateLan' value.
    // In the process, restore the original address-information
    // for the connection.
    //

    if (RemovePrivateLan) {
        status = CsQueryValueKey(Key, c_szSharedPrivateLan, &Information);
        RtlInitUnicodeString(&UnicodeString, c_szSharedPrivateLan);
        NtDeleteValueKey(Key, &UnicodeString);
        if (NT_SUCCESS(status)) {
            CspRestoreAddressInformation(Key, (PWCHAR)Information->Data);
            Free(Information);
        }
    }

    NtClose(Key);
    return NO_ERROR;

} // CsUnshareConnection


WCHAR*
StrDupW(
    LPCWSTR psz
    )
{
    WCHAR* psz2 = Malloc((lstrlenW(psz) + 1) * sizeof(WCHAR));
    if (psz2) { lstrcpyW(psz2, psz); }
    return psz2;
}


VOID
TestBackupAddress(
    PWCHAR Guid
    )
{
    HANDLE Key;
    CS_ADDRESS_INFORMATION Information;
    NTSTATUS status;
    status = CspCaptureAddressInformation(Guid, &Information);
    if (NT_SUCCESS(status)) {
        status = CsOpenKey(&Key, KEY_ALL_ACCESS, c_szSharedAccessParametersKey);
        if (NT_SUCCESS(status)) {
            CspBackupAddressInformation(Key, &Information);
            NtClose(Key);
        }
        CspCleanupAddressInformation(&Information);
    }
}

VOID
TestRestoreAddress(
    PWCHAR Guid
    )
{
    HANDLE Key;
    NTSTATUS status;
    status = CsOpenKey(&Key, KEY_ALL_ACCESS, c_szSharedAccessParametersKey);
    if (NT_SUCCESS(status)) {
        status = CspRestoreAddressInformation(Key, Guid);
    }
}

VOID CsRefreshNetConnections(
    VOID
    )
{
    BOOL bUninitializeCOM = TRUE;
    HRESULT hResult;
    
    ASSERT(NULL != g_pCoInitializeEx);
    ASSERT(NULL != g_pCoCreateInstance);
    ASSERT(NULL != g_pCoUninitialize);
    
    hResult = g_pCoInitializeEx(NULL, COINIT_MULTITHREADED|COINIT_DISABLE_OLE1DDE); // we don't know if the thread is COM or not
    if(RPC_E_CHANGED_MODE == hResult)
    {
        hResult = S_OK;
        bUninitializeCOM = FALSE;
    }
    
    if (SUCCEEDED(hResult)) 
    {
        INetConnectionRefresh * pRefresh = NULL;
        hResult = g_pCoCreateInstance(&CLSID_ConnectionManager, NULL, CLSCTX_LOCAL_SERVER | CLSCTX_NO_CODE_DOWNLOAD, &IID_INetConnectionRefresh, (void**) &pRefresh);
        if(SUCCEEDED(hResult))
        {

            g_pCoSetProxyBlanket((IUnknown*) pRefresh, RPC_C_AUTHN_WINNT, RPC_C_AUTHZ_NONE, NULL,  RPC_C_AUTHN_LEVEL_CALL,  RPC_C_IMP_LEVEL_IMPERSONATE, NULL, EOAC_NONE);
            // ignore error as the interface is not invalidated by error
            
            hResult = INetConnectionRefresh_RefreshAll(pRefresh);
            INetConnectionRefresh_Release(pRefresh);
        }
        
        if(TRUE == bUninitializeCOM)
        {
            g_pCoUninitialize();
        }
    }
}

#endif