#include "wininetp.h"
#include "autodial.h"

const CHAR szRegPathConnections[] = REGSTR_PATH_INTERNET_SETTINGS "\\Connections";
static const CHAR szRegValProxyEnabled[] = REGSTR_VAL_PROXYENABLE;
static const CHAR szLegacyAutoConfigURL[] = "AutoConfigURL";

// when we haven't looked up dial-up override for autodetect
#define UNKNOWN_AUTODETECT      ((DWORD)(-1))

// Internet Settings reg value do determine dial-up override for autodetect
static const CHAR szDialupAutodetect[] = "DialupAutodetect";

// base hkey we use for settings.  May be per user or per machine.
CRefdKey* g_prkBase = NULL;

// type for RtlConvertSidToUnicodeString, exported from ntdll.dll
typedef NTSTATUS (* PCONVERTSID)(
    PUNICODE_STRING UnicodeString,
    PSID Sid,
    BOOLEAN AllocateDestinationString
    );

// some winsock stacks fault if we do a gethostbyname(NULL).  If we come
// accross one of these, don't do any more autodetecting.
BOOL g_fGetHostByNameNULLFails = FALSE;

//
// IsConnectionMatch - a worker function to simply some logic elsewhere,
//  it just handles Connection Name Matching.
//

BOOL 
IsConnectionMatch(
    LPCSTR lpszConnection1,
    LPCSTR lpszConnection2)
{
    if ( lpszConnection1 == NULL && 
         lpszConnection2 == NULL) 
    {
        return TRUE;
    }

    if ( lpszConnection1 && lpszConnection2 &&
         stricmp(lpszConnection1, lpszConnection2) == 0 )
    {
        return TRUE;
    }

    return FALSE;
}

//
// Decide whether or not autodiscovery is turned based on IEAK setting.
// Only used when upgrading or creating settings for a new connectoid.
//
BOOL
EnableAutodiscoverForDialup(
    VOID
    )
{
    static DWORD dwDialUpAutodetect = UNKNOWN_AUTODETECT;

    if(UNKNOWN_AUTODETECT == dwDialUpAutodetect)
    {
        DWORD   dwType, dwSize = sizeof(DWORD);

        if(ERROR_SUCCESS !=
            SHGetValue(HKEY_CURRENT_USER, INTERNET_POLICY_KEY,
            szDialupAutodetect, &dwType, &dwDialUpAutodetect, &dwSize))
        {
            // not set
            dwDialUpAutodetect = 0;
        }
    }

    return (BOOL)dwDialUpAutodetect;
}

///////////////////////////////////////////////////////////////////////////
//
// CRegBlob implementation
//
///////////////////////////////////////////////////////////////////////////

CRegBlob::CRegBlob(
    BOOL fWrite
    )
{
    // initialize members
    _fWrite = fWrite;
    _fCommit = TRUE;
    _dwOffset = 0;
    _pBuffer = NULL;
    _dwBufferLimit = 0;
    _hkey = NULL;
}


CRegBlob::~CRegBlob(
    )
{
    Commit();

    if(_hkey)
        REGCLOSEKEY(_hkey);

    if(_pBuffer)
        FREE_FIXED_MEMORY(_pBuffer);

    // caller owns _pszValue pointer
}


DWORD
CRegBlob::Init(
    HKEY hBaseKey,
    LPCSTR pszSubKey,
    LPCSTR pszValue
    )
{
    long lRes;
    REGSAM  regsam = KEY_QUERY_VALUE;
    DWORD dwDisposition;

    // If we're writing, save reg value name and set access
    if(_fWrite)
    {
        _pszValue = pszValue;
        regsam = KEY_SET_VALUE;
    }

    lRes = REGCREATEKEYEX(hBaseKey, pszSubKey, 0, "", 0,
                regsam, NULL, &_hkey, &dwDisposition);
    if(lRes != ERROR_SUCCESS)
    {
        return lRes;
    }

    // figure out buffer size
    _dwBufferLimit = BLOB_BUFF_GRANULARITY;
    if(FALSE == _fWrite)
    {
        // get size of registry blob
        lRes = RegQueryValueEx(_hkey, pszValue, NULL, NULL, NULL, &_dwBufferLimit);
        if(lRes != ERROR_SUCCESS)
        {
            // nothing there - make zero size buffer
            _dwBufferLimit = 0;
        }
    }

    // allocate buffer if necessary
    if(_dwBufferLimit)
    {
        _pBuffer = (BYTE *)ALLOCATE_FIXED_MEMORY(_dwBufferLimit);
        if(NULL == _pBuffer)
            return GetLastError();
    }

    // if we're reading, fill in buffer
    if(FALSE == _fWrite && _dwBufferLimit)
    {
        // read reg key
        DWORD dwSize = _dwBufferLimit;
        lRes = RegQueryValueEx(_hkey, pszValue, NULL, NULL, _pBuffer, &dwSize);
        if(lRes != ERROR_SUCCESS)
        {
            return lRes;
        }
    }

    // reset pointer to beginning of blob
    _dwOffset = 0;

    return 0;
}

DWORD
CRegBlob::Abandon(
    VOID
    )
{
    // don't commit changes when the time comes
    _fCommit = FALSE;

    return 0;
}

DWORD
CRegBlob::Commit(
    )
{
    long lres = 0;

    if(_fCommit && _fWrite && _pszValue && _pBuffer)
    {
        // save blob to reg key
        lres = RegSetValueEx(_hkey, _pszValue, 0, REG_BINARY, _pBuffer, _dwOffset);
    }

    return lres;
}


DWORD
CRegBlob::Encrpyt(
    )
{
    return 0;
}


DWORD
CRegBlob::Decrypt(
    )
{
    return 0;
}


DWORD
CRegBlob::WriteString(
    LPCSTR pszString
    )
{
    DWORD dwBytes, dwLen = 0;

    if(pszString)
    {
        dwLen = lstrlen(pszString);
    }

    dwBytes = WriteBytes(&dwLen, sizeof(DWORD));
    if(dwLen && dwBytes == sizeof(DWORD))
        dwBytes = WriteBytes(pszString, dwLen);

    return dwBytes;
}



DWORD
CRegBlob::ReadString(
    LPCSTR * ppszString
    )
{
    DWORD dwLen, dwBytes = 0;
    LPSTR lpszTemp = NULL;

    dwBytes = ReadBytes(&dwLen, sizeof(DWORD));
    if(dwBytes == sizeof(DWORD))
    {
        if(dwLen)
        {
            lpszTemp = (LPSTR)GlobalAlloc(GPTR, dwLen + 1);
            if(lpszTemp)
            {
                dwBytes = ReadBytes(lpszTemp, dwLen);
                lpszTemp[dwBytes] = 0;
            }
        }
    }

    *ppszString = lpszTemp;
    return dwBytes;
}


DWORD
CRegBlob::WriteBytes(
    LPCVOID pBytes,
    DWORD dwByteCount
    )
{
    BYTE * pNewBuffer;

    // can only do this on write blob
    if(FALSE == _fWrite)
        return 0;

    // grow buffer if necessary
    if(_dwBufferLimit - _dwOffset < dwByteCount)
    {
        DWORD dw = _dwBufferLimit + ((dwByteCount / BLOB_BUFF_GRANULARITY)+1)*BLOB_BUFF_GRANULARITY;
        pNewBuffer = (BYTE *)ALLOCATE_FIXED_MEMORY(dw);
        if(NULL == pNewBuffer)
        {
            // failed to get more memory
            return 0;
        }

        memset(pNewBuffer, 0, dw);
        memcpy(pNewBuffer, _pBuffer, _dwBufferLimit);
        FREE_FIXED_MEMORY(_pBuffer);
        _pBuffer = pNewBuffer;
        _dwBufferLimit = dw;
    }

    // copy callers data to buffer
    memcpy(_pBuffer + _dwOffset, pBytes, dwByteCount);
    _dwOffset += dwByteCount;

    // tell caller how much we wrote
    return dwByteCount;
}



DWORD
CRegBlob::ReadBytes(
    LPVOID pBytes,
    DWORD dwByteCount
    )
{
    DWORD   dwActual = _dwBufferLimit - _dwOffset;

    // can only do this on read blob
    if(_fWrite)
        return 0;

    // don't read past end of blob
    if(dwByteCount < dwActual)
        dwActual = dwByteCount;

    // copy bytes and increment offset
    if(dwActual > 0)
    {
        memcpy(pBytes, _pBuffer + _dwOffset, dwActual);
        _dwOffset += dwActual;
    }

    // tell caller how much we actually read
    return dwActual;
}


///////////////////////////////////////////////////////////////////////////
//
// Helpers to read and write proxy settings
//
///////////////////////////////////////////////////////////////////////////

//
// Maximum size of TOKEN_USER information.
//

#define SIZE_OF_TOKEN_INFORMATION                   \
    sizeof( TOKEN_USER )                            \
    + sizeof( SID )                                 \
    + sizeof( ULONG ) * SID_MAX_SUB_AUTHORITIES

#define MAX_SID_STRING 256


//
// Function Declarations
//

BOOL
InitClientUserString (
    LPWSTR pString
    )

/*++

Routine Description:

Arguments:

    pString - output string of current user

Return Value:

    TRUE = success,
    FALSE = fail

    Returns in pString a ansi string if the impersonated client's
    SID can be expanded successfully into  Unicode string. If the conversion
    was unsuccessful, returns FALSE.

--*/

{
    DEBUG_ENTER((DBG_DIALUP,
                 Bool,
                 "InitClientUserString",
                 "%#x",
                 pString
                 ));

    HANDLE      TokenHandle;
    UCHAR       TokenInformation[ SIZE_OF_TOKEN_INFORMATION ];
    ULONG       ReturnLength;
    BOOL        Status;
    DWORD       dwLastError;
    UNICODE_STRING UnicodeString;
    HMODULE     hNtDll;
    PCONVERTSID pRtlConvertSid;

    /*
    if (GlobalIsProcessNtService)
    {
        char    szUserName[10];
        DWORD   cbUserNameSize = ARRAYSIZE(szUserName);
        GlobalUserName.Get(szUserName,&cbUserNameSize);
        if (0 == lstrcmpi(szUserName, "SYSTEM"))
        {
            DEBUG_PRINT(DIALUP, INFO, ("User Profile = %s(env = %d)\n",
                        szUserName, GlobalIsProcessNtService
                        ));
            
            wcscpy(pString, L".default");

            DEBUG_PRINT(DIALUP, INFO, ("User SID = %ws\n",
                        pString
                        ));

            DEBUG_LEAVE(TRUE);
            return TRUE;
        }
    }
    */
    
    //
    // get RtlConvertSideToUnicodeString entry point in NTDLL
    //
    hNtDll = LoadLibrary("ntdll.dll");
    if(NULL == hNtDll)
    {
        return FALSE;
    }

    pRtlConvertSid = (PCONVERTSID)GetProcAddress(hNtDll, "RtlConvertSidToUnicodeString");
    if(NULL == pRtlConvertSid)
    {
        FreeLibrary(hNtDll);
        DEBUG_LEAVE(FALSE);
        return FALSE;
    }

    //
    // We can use OpenThreadToken because this server thread
    // is impersonating a client
    //
    Status = OpenThreadToken(
                GetCurrentThread(),
                TOKEN_READ,
                TRUE,                // Open as self
                &TokenHandle
                );
    dwLastError = GetLastError();

    if( Status == FALSE )
    {
        DEBUG_PRINT(DIALUP, INFO, ("OpenThreadToken() failed: Error=%d\n",
                    dwLastError
                    ));

        Status = OpenProcessToken(
                    GetCurrentProcess(),
                    TOKEN_READ,
                    &TokenHandle
                    );
        dwLastError = GetLastError();

        if( Status == FALSE )
        {
            DEBUG_LEAVE(FALSE);
            return FALSE ;
        }
    }

    //
    // Notice that we've allocated enough space for the
    // TokenInformation structure. so if we fail, we
    // return a NULL pointer indicating failure
    //
    Status = GetTokenInformation( TokenHandle,
                                  TokenUser,
                                  TokenInformation,
                                  sizeof( TokenInformation ),
                                  &ReturnLength
                                   );
    dwLastError = GetLastError();
    CloseHandle( TokenHandle );

    if ( Status == FALSE ) {
        DEBUG_PRINT(DIALUP, INFO, ("GetTokenInformation failed: Error=%d\n",
                    dwLastError
                    ));
        DEBUG_LEAVE(FALSE);
        return FALSE;
    }

    //
    // Convert the Sid (pointed to by pSid) to its
    // equivalent Unicode string representation.
    //

    UnicodeString.Length = 0;
    UnicodeString.MaximumLength = MAX_SID_STRING;
    UnicodeString.Buffer = pString;

    Status = (*pRtlConvertSid)(
                 &UnicodeString,
                 ((PTOKEN_USER)TokenInformation)->User.Sid,
                 FALSE );
    FreeLibrary(hNtDll);

    if( !NT_SUCCESS( Status )){
        DEBUG_PRINT(DIALUP, INFO, ("RtlConvertSidToUnicodeString failed: Error=%d\n",
                    Status
                    ));
        DEBUG_LEAVE(FALSE);
        return FALSE;
    }
    
    DEBUG_PRINT(DIALUP, INFO, ("User SID = %ws\n",
                pString
                ));

    DEBUG_LEAVE(TRUE);
    return TRUE;
}


HKEY
GetClientUserHandle(
    IN REGSAM samDesired
    )

/*++

Routine Description:

Arguments:

Returns:

---*/

{
    DEBUG_ENTER((DBG_DIALUP,
                 Dword,
                 "GetClientUserHandle",
                 "%#x",
                 samDesired
                 ));

    HKEY   hKeyClient;
    WCHAR  String[MAX_SID_STRING];
    LONG   ReturnValue;

    if (!InitClientUserString(String)) {
        DEBUG_LEAVE(0);
        return NULL ;
    }

    //
    // We now have the Unicode string representation of the
    // local client's Sid we'll use this string to open a handle
    // to the client's key in  the registry.

    ReturnValue = RegOpenKeyExW( HKEY_USERS,
                                 String,
                                 0,
                                 samDesired,
                                 &hKeyClient );

    //
    // If we couldn't get a handle to the local key
    // for some reason, return a NULL handle indicating
    // failure to obtain a handle to the key
    //

    if ( ReturnValue != ERROR_SUCCESS )
    {
        DEBUG_PRINT(DIALUP, INFO, ("RegOpenKeyW failed: Error=%d\n",
                    ReturnValue
                    ));

        DEBUG_ERROR(DIALUP, ReturnValue);
        SetLastError( ReturnValue );

        DEBUG_LEAVE(0);
        return NULL;
    }

    DEBUG_LEAVE(hKeyClient);
    return( hKeyClient );
}

CRefdKey*
FindBaseProxyKey(
    VOID
    )

/*
** Determine whether proxy settings live in HKLM or HKCU
**
** Returns HKEY_CURRENT_USER or HKEY_LOCAL_MACHINE
**
** Checks \HKLM\SW\MS\Win\CV\Internet Settings\ProxySettingsPerUser.  If
** exists and is zero, use HKLM otherwise use HKCU.
*/

{
    // grab the cached value
    CRefdKey* prk = (CRefdKey*)InterlockedExchangePointer((void**)&g_prkBase, NULL);

    if (prk == NULL)
    {
        HKEY hkeyBase = NULL;
        BOOL bSetNewCachedValue = FALSE;
        DWORD  dwType, dwValue, dwSize = sizeof(DWORD);

        if(ERROR_SUCCESS ==
            SHGetValue(HKEY_LOCAL_MACHINE, INTERNET_POLICY_KEY,
            TEXT("ProxySettingsPerUser"), &dwType, &dwValue, &dwSize) &&
            0 == dwValue)
        {
            hkeyBase = HKEY_LOCAL_MACHINE;
            bSetNewCachedValue = TRUE;
        }
        else
        {
            //
            // Find an HKCU equivalent for this process
            //
            if(PLATFORM_TYPE_WIN95 == GlobalPlatformType ||
               NULL == (hkeyBase = GetClientUserHandle(KEY_QUERY_VALUE | KEY_SET_VALUE)))
            {
                BOOL fLocalSystem = FALSE;
                if (GlobalIsProcessNtService)
                {
                    char    szUserName[20];
                    DWORD   cbUserNameSize = ARRAYSIZE(szUserName);
                    GlobalUserName.Get(szUserName,&cbUserNameSize);
                    if (0 == lstrcmpi(szUserName, "SYSTEM") ||
                        0 == lstrcmpi(szUserName, "LOCAL SERVICE") || 
                        0 == lstrcmpi(szUserName, "NETWORK SERVICE"))
                    {
                        fLocalSystem = TRUE;
                    }
                }
                
                if (!fLocalSystem)
                {
                    hkeyBase = HKEY_CURRENT_USER;
                    bSetNewCachedValue = TRUE;
                }
            }
            else if (!GlobalIsProcessNtService)
            {
                // only cache the CRefdKey if we are not a service
                bSetNewCachedValue = TRUE;
            }
        }

        if (hkeyBase)
        {
            prk = new CRefdKey(hkeyBase);

            if (prk)
            {
                if (bSetNewCachedValue)
                {
                    // addref it again since we are going to try and stick it in the global
                    prk->AddRef();

                    if (InterlockedCompareExchangePointer((void **)&g_prkBase, prk, 0))
                    {
                        // someone beat us in the race to fill in g_prkBase, release ours since we
                        // failed to set it into g_prkBase
                        prk->Release();
                    }
                }
            }
            else
            {
                // we failed to create a CRefdKey, so close the hkeyBase if it is not a predefined handle
                if ((hkeyBase != HKEY_LOCAL_MACHINE) &&
                    (hkeyBase != HKEY_CURRENT_USER))
                {
                    RegCloseKey(hkeyBase);
                }
            }
        }
    }
    else
    {
        // addref the global and put it back
        prk->AddRef();
        CRefdKey* prkOld = (CRefdKey*)InterlockedExchangePointer((void**)&g_prkBase, prk);
        if (prkOld)
        {
            // someone also stuck a cached value in g_prkBase! Since we just put ours back
            // in the global cache, we need to release theirs.
            prkOld->Release();
        }
    }

    return prk;
}

BOOL
CloseBaseProxyKey(
    CRefdKey* prk
    )
{
    if (prk)
    {
        prk->Release();
        return TRUE;
    }

    return FALSE;
}

DWORD
ReadProxySettings(
    LPINTERNET_PROXY_INFO_EX pInfo
    )

{
    CRegBlob r(FALSE);
    LPCSTR  pszConnectionName;
    LPCSTR  pszSavedConnectionName;
    DWORD   error = ERROR_SUCCESS;
    long    lRes;
    DWORD   i;
    BOOL    fSave = FALSE, fLanConnection = FALSE;
    CRefdKey* prkBase = NULL;
    DWORD   dwStructVersion;

    DEBUG_ENTER((DBG_DIALUP,
                 Dword,
                 "ReadProxySettings",
                 "%#x",
                 pInfo
                 ));

    // verify pInfo
    if(NULL == pInfo || pInfo->dwStructSize != sizeof(INTERNET_PROXY_INFO_EX))
    {
        DEBUG_LEAVE(ERROR_INVALID_PARAMETER);
        return ERROR_INVALID_PARAMETER;
    }

    // take mutex
    WaitForSingleObject(g_hProxyRegMutex, INFINITE);

    // figure out connection name  (NULL == 'network')
    pszConnectionName = pInfo->lpszConnectionName;
    pszSavedConnectionName = pInfo->lpszConnectionName;
    if(NULL == pszConnectionName || 0 == *pszConnectionName)
    {
        fLanConnection = TRUE;
        pszConnectionName = "DefaultConnectionSettings";
    }

    // figure out base key
    prkBase = FindBaseProxyKey();
    if (prkBase == NULL)
    {
        error = ERROR_FILE_NOT_FOUND;
        goto quit;
    }

    // initialize structure
    memset(pInfo, 0, sizeof(*pInfo));
    pInfo->dwStructSize = sizeof(*pInfo);
    pInfo->lpszConnectionName = pszSavedConnectionName;
    pInfo->dwFlags = PROXY_TYPE_DIRECT;

    // init blob
    lRes = r.Init(prkBase->GetKey(), szRegPathConnections, pszConnectionName);
    if(lRes)
    {
        error = lRes;
        goto quit;
    }

    // read fields from blob
    if(0 == r.ReadBytes(&dwStructVersion, sizeof(DWORD)) ||
         (dwStructVersion < INTERNET_PROXY_INFO_EX_VERSION))
    {
        // blob didn't exist or in correct format - set default values

        // If not on a lan connection and we're set to inherit lan settings
        if(!fLanConnection && GlobalUseLanSettings)
        {
            // Ensure we're reading the LAN proxy information.
            pInfo->lpszConnectionName = NULL;

            // Get proxy settings into pInfo
            lRes = ReadProxySettings(pInfo);
            if(lRes)
            {
                error = lRes;
                goto quit;
            }

            // Restore connection name
            pInfo->lpszConnectionName = pszSavedConnectionName;
        }
        else
        {
#ifndef UNIX
            //
            // All lan connections and overridden dial-ups get autodetect
            //
            if(fLanConnection || EnableAutodiscoverForDialup())
            {
                pInfo->dwFlags |= PROXY_TYPE_AUTO_DETECT;
            }
#else
            ;
#endif /* UNIX */
        }
    }
    else
    {
        // read the rest of the blob
        r.ReadBytes(&pInfo->dwCurrentSettingsVersion, sizeof(DWORD));
        r.ReadBytes(&pInfo->dwFlags, sizeof(DWORD));
        r.ReadString(&pInfo->lpszProxy);
        r.ReadString(&pInfo->lpszProxyBypass);
        r.ReadString(&pInfo->lpszAutoconfigUrl);
        r.ReadBytes(&pInfo->dwAutoDiscoveryFlags, sizeof(DWORD));
        r.ReadString(&pInfo->lpszLastKnownGoodAutoConfigUrl);
        r.ReadBytes(&pInfo->ftLastKnownDetectTime, sizeof(FILETIME));

        // read interface ips
        r.ReadBytes(&pInfo->dwDetectedInterfaceIpCount, sizeof(DWORD));
        if(pInfo->dwDetectedInterfaceIpCount)
        {
            pInfo->pdwDetectedInterfaceIp = (DWORD *)GlobalAlloc(GPTR, sizeof(DWORD) * pInfo->dwDetectedInterfaceIpCount);
            if(pInfo->pdwDetectedInterfaceIp)
            {
                for(i=0; i<pInfo->dwDetectedInterfaceIpCount; i++)
                {
                    r.ReadBytes(&pInfo->pdwDetectedInterfaceIp[i], sizeof(DWORD));
                }
            }
        }

        r.ReadString(&pInfo->lpszAutoconfigSecondaryUrl);
        r.ReadBytes(&pInfo->dwAutoconfigReloadDelayMins, sizeof(DWORD));
    }

    // Netware hack.  Don't ever allow autodiscovery to be turned on if
    // we're running the netware client.  It faults and it isn't useful
    // anyway.
    //
    // Some other stacks may also fault.  If we find one, don't autodetect.
    if(GlobalRunningNovellClient32 || g_fGetHostByNameNULLFails)
    {
        pInfo->dwFlags &= ~PROXY_TYPE_AUTO_DETECT;

        // save this back so we don't ever try again
        fSave = TRUE;
    }

    DEBUG_PRINT(DIALUP, INFO, ("conn=%s, vers=%u, flag=%X, prox=%s, by=%s, acu=%s\n", 
                    pszConnectionName,
                    pInfo->dwCurrentSettingsVersion,
                    pInfo->dwFlags,
                    (pInfo->lpszProxy ? pInfo->lpszProxy : "<none>"),
                    (pInfo->lpszProxyBypass ? pInfo->lpszProxyBypass : "<none>"),
                    (pInfo->lpszAutoconfigUrl ? pInfo->lpszAutoconfigUrl : "<none>")
                    ));

    if(fSave)
    {
        WriteProxySettings(pInfo, TRUE);
    }

quit:
    CloseBaseProxyKey(prkBase);
    // free mutex
    ReleaseMutex(g_hProxyRegMutex);
    DEBUG_LEAVE(error);
    return error;
}


DWORD
WriteProxySettings(
    LPINTERNET_PROXY_INFO_EX pInfo,
    BOOL fForceUpdate
    )

// serialize this.  Only write if dwCurrentSettingsVersion member has been
// incremented by exactly 1.

{
    DEBUG_ENTER((DBG_DIALUP,
                 Dword,
                 "WriteProxySettings",
                 "%#x, %B",
                 pInfo,
                 fForceUpdate                 
                 ));

    CRegBlob    r(TRUE);
    CRegBlob    CurrentVersion(FALSE);
    LPCSTR      pszConnectionName;
    long        lRes;
    DWORD       i;
    DWORD       dwCurrentVersion;
    DWORD       dwCurrentStructSize;
    DWORD       error = ERROR_SUCCESS;
    DWORD       dwStructVersion = INTERNET_PROXY_INFO_EX_VERSION;
    CRefdKey*   prkBase = NULL;

    //
    // verify pInfo
    //
    if(NULL == pInfo || pInfo->dwStructSize != sizeof(INTERNET_PROXY_INFO_EX))
    {
        r.Abandon();
        DEBUG_LEAVE(ERROR_INVALID_PARAMETER);
        return ERROR_INVALID_PARAMETER;
    }

    // take mutex
    WaitForSingleObject(g_hProxyRegMutex, INFINITE);

    //
    // figure out connection name  (NULL == 'network')
    //
    pszConnectionName = pInfo->lpszConnectionName;
    if(NULL == pszConnectionName || 0 == *pszConnectionName)
    {
        pszConnectionName = "DefaultConnectionSettings";
    }

    //
    // For forced update changes, turn off this FLAG since,
    //  any major change in settings indicates a possible FIX
    //  for detection issues.
    //

    if ( fForceUpdate ) {
        pInfo->dwAutoDiscoveryFlags &= ~(AUTO_PROXY_FLAG_DETECTION_SUSPECT);
    }

    DEBUG_PRINT(DIALUP, INFO, ("conn=%s, vers=%u, flag=%X, a-flag=%X, prox=%s, by=%s, acu=%s\n", 
                    pszConnectionName,
                    pInfo->dwCurrentSettingsVersion,
                    pInfo->dwFlags,
                    pInfo->dwAutoDiscoveryFlags,
                    (pInfo->lpszProxy ? pInfo->lpszProxy : "<none>"),
                    (pInfo->lpszProxyBypass ? pInfo->lpszProxyBypass : "<none>"),
                    (pInfo->lpszAutoconfigUrl ? pInfo->lpszAutoconfigUrl : "<none>")
                    ));

    // figure out base key
    prkBase = FindBaseProxyKey();

    if (prkBase == NULL)
    {
        error = ERROR_FILE_NOT_FOUND;
        goto quit;
    }

    //
    // Get current version and verify another write hasn't happened
    //
    // Second dword is version
    //
    lRes = CurrentVersion.Init(prkBase->GetKey(), szRegPathConnections, pszConnectionName);
    if(lRes || IsInGUIModeSetup())
    {
        r.Abandon();
        error = lRes;
        goto quit;
    }

    dwCurrentStructSize = sizeof(*pInfo);
    dwCurrentVersion    = 0;

    CurrentVersion.ReadBytes(&dwCurrentStructSize, sizeof(DWORD)); // struct size
    CurrentVersion.ReadBytes(&dwCurrentVersion, sizeof(DWORD)); // actual version

    if(dwCurrentVersion != pInfo->dwCurrentSettingsVersion)
    {
        // someone else has written since this read.  If we aren't in force
        // mode, bail out
        if((fForceUpdate == FALSE) &&
           (dwCurrentStructSize >= sizeof(*pInfo)))
        {
            r.Abandon();
            error = ERROR_INVALID_DATA;
            goto quit;
        }

        // update to most recent version
        pInfo->dwCurrentSettingsVersion = dwCurrentVersion;
    }

    //
    // increment version
    //
    pInfo->dwCurrentSettingsVersion++;

    //
    // init blob
    //
    lRes = r.Init(prkBase->GetKey(), szRegPathConnections, pszConnectionName);
    if(lRes)
    {
        r.Abandon();
        error = lRes;
        goto quit;
    }

    //
    // write fields to blob
    //

    r.WriteBytes(&dwStructVersion, sizeof(DWORD)); // used for data format checking
    r.WriteBytes(&pInfo->dwCurrentSettingsVersion, sizeof(DWORD));
    r.WriteBytes(&pInfo->dwFlags, sizeof(DWORD));
    r.WriteString(pInfo->lpszProxy);
    r.WriteString(pInfo->lpszProxyBypass);
    r.WriteString(pInfo->lpszAutoconfigUrl);
    r.WriteBytes(&pInfo->dwAutoDiscoveryFlags, sizeof(DWORD));
    r.WriteString(pInfo->lpszLastKnownGoodAutoConfigUrl);
    r.WriteBytes(&pInfo->ftLastKnownDetectTime, sizeof(FILETIME));

    //
    // write interface ip list
    //
    r.WriteBytes(&pInfo->dwDetectedInterfaceIpCount, sizeof(DWORD));
    for(i=0; i<pInfo->dwDetectedInterfaceIpCount; i++)
    {
        r.WriteBytes(&pInfo->pdwDetectedInterfaceIp[i], sizeof(DWORD));
    }

    r.WriteString(pInfo->lpszAutoconfigSecondaryUrl);
    r.WriteBytes(&pInfo->dwAutoconfigReloadDelayMins, sizeof(DWORD));

quit:
    CloseBaseProxyKey(prkBase);
    // free mutex
    ReleaseMutex(g_hProxyRegMutex);

    DEBUG_LEAVE(error);

    return error;
}

void
CleanProxyStruct(
    LPINTERNET_PROXY_INFO_EX pInfo
    )

{
    if(pInfo->lpszConnectionName)             GlobalFree((LPSTR) pInfo->lpszConnectionName);
    if(pInfo->lpszProxy)                      GlobalFree((LPSTR) pInfo->lpszProxy);
    if(pInfo->lpszProxyBypass)                GlobalFree((LPSTR) pInfo->lpszProxyBypass);
    if(pInfo->lpszAutoconfigUrl)              GlobalFree((LPSTR) pInfo->lpszAutoconfigUrl);
    if(pInfo->lpszLastKnownGoodAutoConfigUrl) GlobalFree((LPSTR) pInfo->lpszLastKnownGoodAutoConfigUrl);
    if(pInfo->pdwDetectedInterfaceIp)         GlobalFree(pInfo->pdwDetectedInterfaceIp);
    memset(pInfo, 0, sizeof(INTERNET_PROXY_INFO_EX));
    pInfo->dwFlags = PROXY_TYPE_DIRECT;
}


DWORD
SetPerConnOptions(
    HINTERNET hInternet,
    BOOL fIsAutoProxyThread,
    LPINTERNET_PER_CONN_OPTION_LISTA pList
    )
{
    INTERNET_PROXY_INFO_EX  info, info_temp;
    DWORD   i, dwError = ERROR_SUCCESS;
    BOOL fCommit = FALSE;
    LPSTR   pszCopy, pszNew;
    BOOL    fFreeCopy = FALSE;

    memset(&info, 0, sizeof(info));
    info.dwStructSize = sizeof(info);

    if ( hInternet == NULL )
    {
        //
        // If auto-proxy thread then try to get the settings
        //  from the auto-proxy thread
        //

        if ( ! fIsAutoProxyThread || 
             ! GlobalProxyInfo.GetAutoProxyThreadSettings(&info) ||
             ! IsConnectionMatch(info.lpszConnectionName, pList->pszConnection))
        {
            fFreeCopy = TRUE;            
            info.lpszConnectionName = pList->pszConnection;
            CheckForUpgrade();
            dwError = ReadProxySettings(&info);
            if (dwError != ERROR_SUCCESS)
            {
                return dwError;
            }
        }
    }

    // loop through option list and set members
    for(i=0; i<pList->dwOptionCount; i++)
    {
        pszNew = NULL;

        switch(pList->pOptions[i].dwOption)
        {        
        case INTERNET_PER_CONN_PROXY_SERVER:
        case INTERNET_PER_CONN_PROXY_BYPASS:
        case INTERNET_PER_CONN_AUTOCONFIG_URL:
        case INTERNET_PER_CONN_AUTOCONFIG_SECONDARY_URL:        
            // make a copy of the string passed in for these guys
            pszCopy = pList->pOptions[i].Value.pszValue;
            if(pszCopy)
            {
                pszNew = (LPSTR)GlobalAlloc(GPTR, lstrlen(pszCopy) + 1);
                if(pszNew)
                {
                    lstrcpy(pszNew, pszCopy);
                }
                else
                {
                    dwError = ERROR_NOT_ENOUGH_MEMORY;
                    pList->dwOptionError = i;
                }
            }
            break;
        }

        if(dwError)
        {
            fCommit = FALSE;
            break;
        }

        switch(pList->pOptions[i].dwOption)
        {
        case INTERNET_PER_CONN_FLAGS:
            info.dwFlags = pList->pOptions[i].Value.dwValue;
            fCommit = TRUE;
            break;
        case INTERNET_PER_CONN_AUTODISCOVERY_FLAGS:
            info.dwAutoDiscoveryFlags = pList->pOptions[i].Value.dwValue;
            fCommit = TRUE;
            break;
        case INTERNET_PER_CONN_AUTOCONFIG_RELOAD_DELAY_MINS:
            info.dwAutoconfigReloadDelayMins = pList->pOptions[i].Value.dwValue;
            fCommit = TRUE;
            break;
        case INTERNET_PER_CONN_PROXY_SERVER:
            if(info.lpszProxy)
                GlobalFree((LPSTR)info.lpszProxy);
            info.lpszProxy = pszNew;
            fCommit = TRUE;
            break;
        case INTERNET_PER_CONN_PROXY_BYPASS:
            if(info.lpszProxyBypass)
                GlobalFree((LPSTR)info.lpszProxyBypass);
            info.lpszProxyBypass = pszNew;
            fCommit = TRUE;
            break;
        case INTERNET_PER_CONN_AUTOCONFIG_URL:
            if(info.lpszAutoconfigUrl)
                GlobalFree((LPSTR)info.lpszAutoconfigUrl);
            info.lpszAutoconfigUrl = pszNew;
            fCommit = TRUE;
            break;
        case INTERNET_PER_CONN_AUTOCONFIG_SECONDARY_URL:
            if(info.lpszAutoconfigSecondaryUrl)
                GlobalFree((LPSTR)info.lpszAutoconfigSecondaryUrl);
            info.lpszAutoconfigSecondaryUrl = pszNew;
            fCommit = TRUE;
            break;
        case INTERNET_PER_CONN_AUTOCONFIG_LAST_DETECT_TIME:
            dwError = ERROR_INTERNET_OPTION_NOT_SETTABLE;
            pList->dwOptionError = i;
            break;
        case INTERNET_PER_CONN_AUTOCONFIG_LAST_DETECT_URL:
            dwError = ERROR_INTERNET_OPTION_NOT_SETTABLE;
            pList->dwOptionError = i;
            break;
        default:
            dwError = ERROR_INVALID_PARAMETER;
            pList->dwOptionError = i;
            break;
        }

        if(dwError)
        {
            fCommit = FALSE;
            break;
        }
    }

    if(fCommit)
    {
        if ( hInternet == NULL ) 
        {

            memset(&info_temp, 0, sizeof(info_temp));
            info_temp.dwStructSize = sizeof(info_temp);

            if ( ! fIsAutoProxyThread ||
                 ! GlobalProxyInfo.GetAutoProxyThreadSettings(&info_temp) ||
                 ! IsConnectionMatch(info_temp.lpszConnectionName, pList->pszConnection) ||
                 ! GlobalProxyInfo.SetAutoProxyThreadSettings(&info))
                 
            { 
                WriteProxySettings(&info, TRUE);

                // update legacy settings with new values
                info.lpszConnectionName = LEGACY_SAVE_NAME;
                WriteLegacyProxyInfo(szRegPathInternetSettings, &info, TRUE);
                WriteProxySettings(&info, TRUE);
            }
        } 
        else 
        {
            GlobalProxyInfo.SetProxySettings(&info, TRUE);
        }
    }

    if ( fFreeCopy ) {
        info.lpszConnectionName = NULL; // we don't allocate this field
        CleanProxyStruct(&info);
    }

    return dwError;
}



DWORD
QueryPerConnOptions(
    HINTERNET hInternet,
    BOOL fIsAutoProxyThread,
    LPINTERNET_PER_CONN_OPTION_LISTA pList
    )
{
    INTERNET_PROXY_INFO_EX  info;
    LPCSTR   pszCopy;
    LPSTR    pszNew;
    DWORD    i, dwError = ERROR_SUCCESS;
    BOOL     fFreeCopy = FALSE;

    pList->dwOptionError = 0;

    memset(&info, 0, sizeof(info));
    info.dwStructSize = sizeof(info);
    info.lpszConnectionName = pList->pszConnection;

    if ( hInternet == NULL ) 
    {
        if ( ! fIsAutoProxyThread ||                          
             ! GlobalProxyInfo.GetAutoProxyThreadSettings(&info) ||
             ! IsConnectionMatch(info.lpszConnectionName, pList->pszConnection)) 
        { 
            CheckForUpgrade();
            dwError = ReadProxySettings(&info);
            if (dwError != ERROR_SUCCESS)
            {
                return dwError;
            }
            fFreeCopy = TRUE;
        }
    }
    else 
    {
        GlobalProxyInfo.GetProxySettings(&info, FALSE);
    }

    // loop through option list and fill in members
    for(i=0; i<pList->dwOptionCount; i++)
    {
        pList->pOptions[i].Value.pszValue = NULL;
        pszCopy = NULL;

        switch(pList->pOptions[i].dwOption)
        {
        case INTERNET_PER_CONN_FLAGS:
            pList->pOptions[i].Value.dwValue = info.dwFlags;
            break;
        case INTERNET_PER_CONN_AUTODISCOVERY_FLAGS:
            pList->pOptions[i].Value.dwValue = info.dwAutoDiscoveryFlags;
            break;
        case INTERNET_PER_CONN_AUTOCONFIG_RELOAD_DELAY_MINS:
            pList->pOptions[i].Value.dwValue = info.dwAutoconfigReloadDelayMins;
            break;
        case INTERNET_PER_CONN_PROXY_SERVER:
            pszCopy = info.lpszProxy;
            break;
        case INTERNET_PER_CONN_PROXY_BYPASS:
            pszCopy = info.lpszProxyBypass;
            break;
        case INTERNET_PER_CONN_AUTOCONFIG_URL:
            pszCopy = info.lpszAutoconfigUrl;
            break;
        case INTERNET_PER_CONN_AUTOCONFIG_SECONDARY_URL:
            pszCopy = info.lpszAutoconfigSecondaryUrl;
            break;
        case INTERNET_PER_CONN_AUTOCONFIG_LAST_DETECT_URL:
            pszCopy = info.lpszLastKnownGoodAutoConfigUrl;
            break;
        case INTERNET_PER_CONN_AUTOCONFIG_LAST_DETECT_TIME:
            *(LONGLONG *) &(pList->pOptions[i].Value.ftValue) = *(LONGLONG *) &(info.ftLastKnownDetectTime);
            break;

        default:
            dwError = ERROR_INVALID_PARAMETER;
            pList->dwOptionError = i;
            break;
        }

        // if this is a string value, make a copy of the string for the
        // caller
        if(pszCopy)
        {
            // make a copy of the string and stick it in the option
            pszNew = (LPSTR)GlobalAlloc(GPTR, lstrlen(pszCopy) + 1);
            if(pszNew)
            {
                lstrcpy(pszNew, pszCopy);
                pList->pOptions[i].Value.pszValue = pszNew;
            }
            else
            {
                dwError = ERROR_NOT_ENOUGH_MEMORY;
                pList->dwOptionError = i;
            }
        }

        if(dwError)
        {
            break;
        }
    }

    if (dwError)
    {
        // If an error has occurred, we should get rid of any strings that
        // we've allocated.
        for (i=0; i<pList->dwOptionError; i++)
        {
            switch(pList->pOptions[i].dwOption)
            {
            case INTERNET_PER_CONN_PROXY_SERVER:
            case INTERNET_PER_CONN_PROXY_BYPASS:
            case INTERNET_PER_CONN_AUTOCONFIG_URL:
            case INTERNET_PER_CONN_AUTOCONFIG_SECONDARY_URL:
            case INTERNET_PER_CONN_AUTOCONFIG_LAST_DETECT_URL:
                if (pList->pOptions[i].Value.pszValue)
                {
                    GlobalFree(pList->pOptions[i].Value.pszValue);
                    pList->pOptions[i].Value.pszValue = NULL;
                }
                break;

            default:
                break;
            }
        }
    }

    if ( fFreeCopy ) {
        info.lpszConnectionName = NULL; // we don't allocate this field
        CleanProxyStruct(&info);
    }

    return dwError;
}


BOOL
ReadLegacyProxyInfo(
    IN LPCTSTR pszKey,
    LPINTERNET_PROXY_INFO_EX pProxy
    )

/*++

Routine Description:

    Reads legacy proxy information from a specified key.

Arguments:

    pszKey      - key from which to read proxy info
    pProxy      - pointer to PROXY structure to store info

Return Value:

    BOOL
        TRUE    - success
        FALSE   - failed

--*/

{
    DEBUG_ENTER((DBG_DIALUP,
                 Bool,
                 "ReadLegacyProxyInfo",
                 "%#x (%q), %#x",
                 pszKey,
                 pszKey,
                 pProxy
                 ));

    BOOL    fSuccess = FALSE;
    HKEY    hKey;
    CRefdKey* prkBase;
    DWORD   dwSize, dwValue;

    pProxy->dwFlags = PROXY_TYPE_DIRECT;

    prkBase = FindBaseProxyKey();

    if(prkBase && 
       (ERROR_SUCCESS == REGOPENKEYEX(prkBase->GetKey(), pszKey, NULL,
                                KEY_READ, &hKey))) {
        // read enable
        dwSize = sizeof(DWORD);
        if(ERROR_SUCCESS != RegQueryValueEx(hKey, szRegValProxyEnabled,
                    NULL, NULL, (LPBYTE)&dwValue, &dwSize)) {
            dwValue = 0;
        }
        if(dwValue)
        {
            pProxy->dwFlags |= PROXY_TYPE_PROXY;
        }

        // read server
        dwSize = INTERNET_MAX_URL_LENGTH;
        pProxy->lpszProxy = (LPSTR)GlobalAlloc(GMEM_FIXED, dwSize);
        if(pProxy->lpszProxy)
        {
            if(ERROR_SUCCESS != RegQueryValueEx(hKey, REGSTR_VAL_PROXYSERVER,
                NULL, NULL, (LPBYTE)pProxy->lpszProxy, &dwSize) ||
                (dwSize == 0) ||
                (*pProxy->lpszProxy == '\0'))
            {
                GlobalFree((LPVOID)pProxy->lpszProxy);
                pProxy->lpszProxy = NULL;
            }
        }

        // read override
        dwSize = INTERNET_MAX_URL_LENGTH;
        pProxy->lpszProxyBypass = (LPSTR)GlobalAlloc(GMEM_FIXED, dwSize);
        if(pProxy->lpszProxyBypass)
        {
            if(ERROR_SUCCESS != RegQueryValueEx(hKey, REGSTR_VAL_PROXYOVERRIDE,
                NULL, NULL, (LPBYTE)pProxy->lpszProxyBypass, &dwSize) ||
                (dwSize == 0) ||
                (*pProxy->lpszProxyBypass == '\0'))
            {
                GlobalFree((LPVOID)pProxy->lpszProxyBypass);
                pProxy->lpszProxyBypass = NULL;
            }
        }
        

        // read autoconfig URL
        dwSize = INTERNET_MAX_URL_LENGTH;
        pProxy->lpszAutoconfigUrl = (LPSTR)GlobalAlloc(GMEM_FIXED, dwSize);
        if(pProxy->lpszAutoconfigUrl)
        {
            if(ERROR_SUCCESS != RegQueryValueEx(hKey, szLegacyAutoConfigURL,
                NULL, NULL, (LPBYTE)pProxy->lpszAutoconfigUrl, &dwSize) ||
                (dwSize == 0) ||
                (*pProxy->lpszAutoconfigUrl == '\0'))
            {
                // clear out
                GlobalFree((LPVOID)pProxy->lpszAutoconfigUrl);
                pProxy->lpszAutoconfigUrl = NULL;
            }
            else
            {
                // turn on if there's an URL
                pProxy->dwFlags |= PROXY_TYPE_AUTO_PROXY_URL;
            }
        }

        REGCLOSEKEY(hKey);
        fSuccess = TRUE;
    }

    DEBUG_PRINT(DIALUP, INFO, ("flag=%x, prox=%s, by=%s, acu=%s\n", 
                    pProxy->dwFlags,
                    (pProxy->lpszProxy ? pProxy->lpszProxy : "<none>"),
                    (pProxy->lpszProxyBypass ? pProxy->lpszProxyBypass : "<none>"),
                    (pProxy->lpszAutoconfigUrl ? pProxy->lpszAutoconfigUrl : "<none>")
                    ));

    CloseBaseProxyKey(prkBase);

    DEBUG_LEAVE(fSuccess);
    return fSuccess;
}


BOOL
WriteLegacyProxyInfo(
    IN LPCTSTR pszKey,
    LPINTERNET_PROXY_INFO_EX pProxy,
    IN BOOL    fOverwrite
    )

/*++

Routine Description:

    Writes legacy proxy info a specified key

Arguments:

    pszKey      - key to write proxy inf to
    pProxy      - pointer to PROXY structure containing info to write
    fOverwrite  - If TRUE, overwrite existing info. otherwise only create

Return Value:

    BOOL
        TRUE    - success
        FALSE   - failed

--*/

{
    DEBUG_ENTER((DBG_DIALUP,
                 Bool,
                 "WriteLegacyProxyInfo",
                 "%#x (%q), %#x, %B",
                 pszKey,
                 pszKey,
                 pProxy,
                 fOverwrite
                 ));

    BOOL    fSuccess = FALSE;
    HKEY    hKey;
    CRefdKey* prkBase;
    DWORD   dwDisposition, dwValue;

    prkBase = FindBaseProxyKey();
    if (!prkBase)
    {
        goto quit;
    }

    if (IsInGUIModeSetup())
    {
        fSuccess = TRUE;  // don't return a failure, just skip
        goto quit;
    }

    DEBUG_PRINT(DIALUP, INFO, ("flag=%x, prox=%s, by=%s, acu=%s\n", 
                    pProxy->dwFlags,
                    (pProxy->lpszProxy ? pProxy->lpszProxy : "<none>"),
                    (pProxy->lpszProxyBypass ? pProxy->lpszProxyBypass : "<none>"),
                    (pProxy->lpszAutoconfigUrl ? pProxy->lpszAutoconfigUrl : "<none>")
                    ));

    if(ERROR_SUCCESS == REGCREATEKEYEX(prkBase->GetKey(), pszKey, 0, "", 0,
                KEY_WRITE, NULL, &hKey, &dwDisposition)) {

        fSuccess = TRUE;

        //
        // if we're not supposed to overwrite, check enable key.  If it
        // exists, bail
        //
        if(FALSE == fOverwrite) {
            DWORD dwEnable, dwSize = sizeof(DWORD);
            if(ERROR_SUCCESS == RegQueryValueEx(hKey, szRegValProxyEnabled,
                    NULL, NULL, (LPBYTE)&dwEnable, &dwSize)) {
                REGCLOSEKEY(hKey);
                DEBUG_PRINT(DIALUP, INFO, ("Overwrite not set.\n"));
                goto quit;
            }
        }

        // write enable
        dwValue = 0;
        if(pProxy->dwFlags & PROXY_TYPE_PROXY)
            dwValue = 1;
        DEBUG_PRINT(DIALUP, INFO, ("Setting legacy enabled=%d\n", dwValue));
        if(ERROR_SUCCESS != RegSetValueEx(hKey, szRegValProxyEnabled, 0,
                    REG_DWORD, (BYTE *)&dwValue, sizeof(DWORD)))
            fSuccess = FALSE;

        // write server
        if(pProxy->lpszProxy)
        {
            if(ERROR_SUCCESS != RegSetValueEx(hKey, REGSTR_VAL_PROXYSERVER, 0,
                    REG_SZ, (BYTE *)pProxy->lpszProxy,
                    lstrlen(pProxy->lpszProxy)))
                fSuccess = FALSE;
        }
        else
        {
            RegDeleteValue(hKey, REGSTR_VAL_PROXYSERVER);
            DEBUG_PRINT(DIALUP, INFO, ("Deleting legacy server\n"));
        }

        // write override
        if(pProxy->lpszProxyBypass)
        {
            if(ERROR_SUCCESS != RegSetValueEx(hKey, REGSTR_VAL_PROXYOVERRIDE, 0,
                    REG_SZ, (BYTE *)pProxy->lpszProxyBypass,
                    lstrlen(pProxy->lpszProxyBypass)))
                fSuccess = FALSE;
        }
        else
        {
            RegDeleteValue(hKey, REGSTR_VAL_PROXYOVERRIDE);
            DEBUG_PRINT(DIALUP, INFO, ("Deleting legacy override\n"));
        }

        // write autoconfig url
        if( (pProxy->dwFlags & PROXY_TYPE_AUTO_PROXY_URL) &&
             pProxy->lpszAutoconfigUrl)
        {
            if(ERROR_SUCCESS != RegSetValueEx(hKey, szLegacyAutoConfigURL, 0,
                REG_SZ, (BYTE *)pProxy->lpszAutoconfigUrl,
                lstrlen(pProxy->lpszAutoconfigUrl)))
            {
                fSuccess = FALSE;
            }
        }
        else
        {
            RegDeleteValue(hKey, szLegacyAutoConfigURL);
            DEBUG_PRINT(DIALUP, INFO, ("Deleting legacy autoconfig url\n"));
        }

        REGCLOSEKEY(hKey);
    }

    //
    // duplicate proxy enable reg settings to HKEY_CURRENT_CONFIG so 
    // shell doesn't blow away the setting when it migrates.
    //
    dwValue = (pProxy->dwFlags & PROXY_TYPE_PROXY) ? 1 : 0;
    SHSetValue(HKEY_CURRENT_CONFIG, pszKey, szRegValProxyEnabled,
        REG_DWORD, &dwValue, sizeof(DWORD));

quit:
    CloseBaseProxyKey(prkBase);

    DEBUG_LEAVE(fSuccess);
    return fSuccess;
}