windows-server-2003/inetcore/wininet/dll/globals.cxx

/*++

Copyright (c) 1995  Microsoft Corporation

Module Name:

    globals.cxx

Abstract:

    Contains global data items for WININET.DLL and initialization function

    Contents:
        GlobalDllInitialize
        GlobalDllTerminate
        GlobalDataInitialize
        GlobalTruncateFileName;
        GlobalDataTerminate
        IsHttp1_1
        IsOffline
        SetOfflineUserState
        FetchLocalStrings
        GetWininetUserName
        ChangeGlobalSettings
        RefreshOfflineFromRegistry
        PerformStartupProcessing

Author:

    Richard L Firth (rfirth) 15-Jul-1995

Revision History:

    15-Jul-1995 rfirth
        Created

    07-Oct-1998 joshco
        updated minor version number 1->2

--*/

#include <wininetp.h>
#include <ntverp.h>
#include <autodial.h>       // InitAutodialModule, ExitAutodialModule
#include <schnlsp.h>
#include <persist.h>

//
// WinInet major & minor versions - allow to be defined externally
//

// JOSHCO

#if !defined(WININET_MAJOR_VERSION)
#define WININET_MAJOR_VERSION   1
#endif
#if !defined(WININET_MINOR_VERSION)
#define WININET_MINOR_VERSION   2
#endif

//
// external functions
//

void RefreshP3PSettings();

STDAPI_(void) UrlZonesDetach (void);

#if INET_DEBUG

VOID
InitDebugSock(
    VOID
    );

#endif

//
// private prototypes
//

#if defined(SITARA)

PRIVATE
VOID
OpenIeMainKey(
    VOID
    );

PRIVATE
VOID
CloseIeMainKey(
    VOID
    );

PRIVATE
BOOL
CheckABS(
    VOID
    );

PRIVATE
BOOL
ReadIeMainDwordValue(
    IN LPSTR pszValueName,
    OUT LPDWORD pdwValue
    );

#endif // SITARA

//
// global DLL state data
//

GLOBAL HINSTANCE GlobalDllHandle = NULL;
GLOBAL DWORD GlobalPlatformType;
GLOBAL DWORD GlobalPlatformVersion5;
GLOBAL DWORD GlobalPlatformMillennium = FALSE;
GLOBAL DWORD GlobalPlatformWhistler = FALSE;
GLOBAL DWORD GlobalDllState = INTERNET_STATE_ONLINE | INTERNET_STATE_IDLE;
GLOBAL BOOL GlobalDataInitialized = FALSE;
GLOBAL BOOL  GlobalTruncateFileName = FALSE;

//
// WinInet DLL version information (mainly for diagnostics)
//

#if INET_DEBUG

GLOBAL DWORD InternetMajorVersion = 1;
GLOBAL DWORD InternetMinorVersion = 0;

#endif // INET_DEBUG

#if !defined(VER_PRODUCTBUILD)
#define VER_PRODUCTBUILD    0
#endif

GLOBAL DWORD InternetBuildNumber = VER_PRODUCTBUILD;

//
// transport-based time-outs, etc.
//

//GLOBAL DWORD GlobalConnectTimeout = DEFAULT_CONNECT_TIMEOUT;
#ifndef unix
GLOBAL DWORD GlobalConnectTimeout = 5 * 60 * 1000;
#else
GLOBAL DWORD GlobalConnectTimeout = 1 * 60 * 1000;
#endif /* unix */
GLOBAL DWORD GlobalConnectRetries = DEFAULT_CONNECT_RETRIES;
GLOBAL DWORD GlobalSendTimeout = DEFAULT_SEND_TIMEOUT;
GLOBAL DWORD GlobalReceiveTimeout = DEFAULT_RECEIVE_TIMEOUT;
GLOBAL DWORD GlobalDataSendTimeout = DEFAULT_SEND_TIMEOUT;
GLOBAL DWORD GlobalDataReceiveTimeout = DEFAULT_RECEIVE_TIMEOUT;
GLOBAL DWORD GlobalFromCacheTimeout = (DWORD)-1;
GLOBAL DWORD GlobalFtpAcceptTimeout = DEFAULT_FTP_ACCEPT_TIMEOUT;
GLOBAL DWORD GlobalTransportPacketLength = DEFAULT_TRANSPORT_PACKET_LENGTH;
GLOBAL DWORD GlobalKeepAliveSocketTimeout = DEFAULT_KEEP_ALIVE_TIMEOUT;
GLOBAL DWORD GlobalSocketSendBufferLength = DEFAULT_SOCKET_SEND_BUFFER_LENGTH;
GLOBAL DWORD GlobalSocketReceiveBufferLength = DEFAULT_SOCKET_RECEIVE_BUFFER_LENGTH;
GLOBAL DWORD GlobalMaxHttpRedirects = DEFAULT_MAX_HTTP_REDIRECTS;
GLOBAL DWORD GlobalMaxConnectionsPerServer = DEFAULT_MAX_CONNECTIONS_PER_SERVER;
GLOBAL DWORD GlobalMaxConnectionsPer1_0Server = DEFAULT_MAX_CONS_PER_1_0_SERVER;
GLOBAL DWORD GlobalConnectionInactiveTimeout = DEFAULT_CONNECTION_INACTIVE_TIMEOUT;
GLOBAL DWORD GlobalServerInfoTimeout = DEFAULT_SERVER_INFO_TIMEOUT;
GLOBAL const DWORD GlobalMaxSizeStatusLineResultText = 1024;
GLOBAL BOOL  GlobalHaveInternetOpened = FALSE;
GLOBAL BOOL  GlobalBypassEditedEntry = FALSE;

GLOBAL DWORD GlobalCacheMode = 0;

//GLOBAL DWORD GlobalServerInfoAllocCount = 0;
//GLOBAL DWORD GlobalServerInfoDeAllocCount = 0;

//
// async worker thread variables
//

//GLOBAL DWORD GlobalMinimumWorkerThreads = DEFAULT_MINIMUM_THREADS;
//GLOBAL DWORD GlobalMaximumWorkerThreads = DEFAULT_MAXIMUM_THREADS;
//GLOBAL DWORD GlobalInitialWorkerThreads = DEFAULT_INITIAL_THREADS;
//GLOBAL DWORD GlobalWorkerThreadIdleTimeout = DEFAULT_THREAD_IDLE_TIMEOUT;
//GLOBAL DWORD GlobalWorkQueueLimit = DEFAULT_WORK_QUEUE_LIMIT;
GLOBAL DWORD GlobalWorkerThreadTimeout = DEFAULT_WORKER_THREAD_TIMEOUT;

GLOBAL BOOL g_bHibernating = FALSE;
GLOBAL BOOL g_bDisableHibernation = FALSE;
//
// switches
//

GLOBAL BOOL InDllCleanup = FALSE;
GLOBAL BOOL GlobalPleaseQuitWhatYouAreDoing = FALSE;
GLOBAL BOOL GlobalDynaUnload = FALSE;
GLOBAL BOOL GlobalDisableKeepAlive = FALSE;
GLOBAL BOOL GlobalDisablePassport = FALSE;
GLOBAL BOOL GlobalEnableHttp1_1 = FALSE;
GLOBAL BOOL GlobalEnableProxyHttp1_1 = FALSE;
GLOBAL BOOL GlobalDisableReadRange = FALSE;
GLOBAL BOOL GlobalEnableGopher = FALSE;

//GLOBAL BOOL GlobalAutoProxyInDeInit = FALSE;
GLOBAL BOOL GlobalIsProcessExplorer = FALSE;
#ifndef UNIX
GLOBAL BOOL GlobalEnableFortezza = TRUE;
#else /* for UNIX */
GLOBAL BOOL GlobalEnableFortezza = FALSE;
#endif /* UNIX */

#if defined(SITARA)

GLOBAL BOOL GlobalEnableSitara = FALSE;
GLOBAL BOOL GlobalHasSitaraModemConn = FALSE;

#endif // SITARA

GLOBAL BOOL GlobalEnableUtf8Encoding = FALSE;
GLOBAL BOOL GlobalEnableRevocation = FALSE;

// SSL Switches  (petesk 7/24/97)
GLOBAL DWORD GlobalSecureProtocols  = DEFAULT_SECURE_PROTOCOLS;

GLOBAL DWORD GlobalSslStateCount = 0;

//
// AutoDetect Proxy Globals
//

GLOBAL LONG GlobalInternetOpenHandleCount = -1;
GLOBAL DWORD GlobalProxyVersionCount = 0;
GLOBAL BOOL GlobalAutoProxyNeedsInit = FALSE;
GLOBAL BOOL GlobalAutoProxyInInit = FALSE;
GLOBAL BOOL GlobalAutoProxyCacheEnable = TRUE;
GLOBAL BOOL GlobalDisplayScriptDownloadFailureUI = FALSE;

GLOBAL BOOL GlobalSendUTF8ServerToProxy = TRUE;
GLOBAL BOOL GlobalMBCSAPIforCrack = TRUE;
GLOBAL BOOL GlobalUseUTF8ServerForNameRes = FALSE;

//
//  Workaround for Novell's Client32
//

GLOBAL BOOL fDontUseDNSLoadBalancing = FALSE;

//
// Workaround for slow RAS enumeration
//
GLOBAL BOOL GlobalDisableNT4RasCheck = FALSE;
GLOBAL BOOL GlobalUseLanSettings = FALSE;

GLOBAL BOOL GlobalSendExtraCRLF = TRUE;

//Ftp time checking
GLOBAL BOOL  GlobalBypassFtpTimeCheck = FALSE;

//
// lists
//

GLOBAL SERIALIZED_LIST GlobalObjectList = {0};
GLOBAL SERIALIZED_LIST GlobalServerInfoList = {0};

//
// cache timeouts
//

GLOBAL LONGLONG dwdwHttpDefaultExpiryDelta = 12 * 60 * 60 * (LONGLONG)10000000;  // 12 hours in 100ns units
GLOBAL LONGLONG dwdwFtpDefaultExpiryDelta = 24 * 60 * 60 * (LONGLONG)10000000;  // 24 hours in 100ns units
GLOBAL LONGLONG dwdwGopherDefaultExpiryDelta = 24 * 60 * 60 * (LONGLONG)10000000;  // 24 hours in 100ns units
GLOBAL LONGLONG dwdwSessionStartTime;
GLOBAL LONGLONG dwdwSessionStartTimeDefaultDelta = 0;

GLOBAL DWORD GlobalUrlCacheSyncMode = WININET_SYNC_MODE_DEFAULT;
GLOBAL DWORD GlobalDiskUsageLowerBound = (4*1024*1024);
GLOBAL DWORD GlobalScavengeFileLifeTime = (10*60);

GLOBAL LPSTR vszMimeExclusionList=NULL, vszHeaderExclusionList=NULL;

GLOBAL LPSTR *lpvrgszMimeExclusionTable=NULL, *lpvrgszHeaderExclusionTable=NULL;

GLOBAL DWORD *lpvrgdwMimeExclusionTableOfSizes=NULL;

GLOBAL DWORD vdwMimeExclusionTableCount=0, vdwHeaderExclusionTableCount=0;

//
// SSL globals, for UI.  We need to know
//  whether its ok for us to pop up UI.
//
//

GLOBAL BOOL GlobalWarnOnPost = FALSE;
GLOBAL BOOL GlobalWarnAlways = FALSE;
GLOBAL BOOL GlobalWarnOnZoneCrossing = TRUE;
GLOBAL BOOL GlobalWarnOnBadCertSending = FALSE;
GLOBAL BOOL GlobalWarnOnBadCertRecving = TRUE;
GLOBAL BOOL GlobalDisableSslCaching = FALSE;
GLOBAL BOOL GlobalWarnOnPostRedirect = TRUE;
GLOBAL BOOL GlobalAlwaysDrainOnRedirect = FALSE;
GLOBAL BOOL GlobalBypassSSLNoCacheCheck = FALSE;
GLOBAL BOOL GlobalWarnOnHTTPSToHTTPRedirect = TRUE;


GLOBAL SECURITY_CACHE_LIST GlobalCertCache;

GLOBAL DWORD GlobalSettingsVersion=0; // crossprocess settings versionstamp
GLOBAL BOOL GlobalSettingsLoaded = FALSE;

GLOBAL const char vszSyncMode[] = "SyncMode5";

GLOBAL const char vszDisableSslCaching[] = "DisableCachingOfSSLPages";
GLOBAL BOOL GlobalDisableNTLMPreAuth = FALSE;

GLOBAL char vszCurrentUser[MAX_PATH];
GLOBAL DWORD vdwCurrentUserLen = 0;

//
// critical sections
//

GLOBAL CRITICAL_SECTION AutoProxyDllCritSec = {0};
GLOBAL CRITICAL_SECTION LockRequestFileCritSec = {0};
GLOBAL CRITICAL_SECTION ZoneMgrCritSec = {0};
GLOBAL CRITICAL_SECTION MlangCritSec  = {0};


// cookies info

GLOBAL BOOL vfPerUserCookies = TRUE;
const char  vszAnyUserName[]="anyuser";
const char  vszPerUserCookies[] = "PerUserCookies";
const char  vszInvalidFilenameChars[] = "<>\\\"/:|?*";

GLOBAL BOOL GlobalLeashLegacyCookies = TRUE;
const char vszLeashLegacyCookies[] = REGSTR_LEASH_LEGACY_COOKIES;

// Hard-coded user agent string
// Update for each different version of IE 
#if defined(UNIX)
const char gszDefaultUserAgent[] = "Mozilla/4.0 (compatible; MSIE 6.0; X11)";
#elif defined(_WIN64)
const char gszDefaultUserAgent[] = "Mozilla/4.0 (compatible; MSIE 6.0; Win64)";
#else
const char gszDefaultUserAgent[] = "Mozilla/4.0 (compatible; MSIE 6.0; Win32)";
#endif




// Mlang related data and functions.
PRIVATE HINSTANCE hInstMlang;
PRIVATE PFNINETMULTIBYTETOUNICODE pfnInetMultiByteToUnicode;
PRIVATE BOOL bFailedMlangLoad;  // So we don't try repeatedly if we fail once.
BOOL LoadMlang( );
BOOL UnloadMlang( );
#define MLANGDLLNAME    "mlang.dll"


// shfolder.dll hmod handle
HMODULE g_HMODSHFolder = NULL;
// Shell32.dll hmod handle
HMODULE g_HMODShell32 = NULL;

GLOBAL CUserName GlobalUserName;

//
// novell client32 (hack) "support"
//

GLOBAL BOOL GlobalRunningNovellClient32 = FALSE;
GLOBAL BOOL GlobalNonBlockingClient32 = FALSE;

//
// private data
//

HANDLE g_hAutodialMutex = NULL;

//
// proxy info
//

GLOBAL PROXY_INFO_GLOBAL GlobalProxyInfo;

//
// DLL version info
//

GLOBAL INTERNET_VERSION_INFO InternetVersionInfo = {
    WININET_MAJOR_VERSION,
    WININET_MINOR_VERSION
};

//
// HTTP version info - default 1.0
//

GLOBAL HTTP_VERSION_INFO HttpVersionInfo = {1, 0};


GLOBAL BOOL fCdromDialogActive = FALSE;
GLOBAL DWORD g_dwCredPersistAvail = CRED_PERSIST_UNKNOWN;

//
// The following globals are literal strings passed to winsock.
// Do NOT make them const, otherwise they end up in .text section,
// and web release of winsock2 has a bug where it locks and dirties
// send buffers, confusing the win95 vmm and resulting in code
// getting corrupted when it is paged back in.  -RajeevD
//

GLOBAL char gszAt[]   = "@";
GLOBAL char gszBang[] = "!";
GLOBAL char gszCRLF[] = "\r\n";


extern GLOBAL SERIALIZED_LIST BlockedRequestQueue;


// Identity-related globals
GLOBAL DWORD GlobalIdentity = 0;
GLOBAL GUID  GlobalIdentityGuid = { 0x00000000L, 0x0000, 0x0000, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
GLOBAL BOOL GlobalSuppressCookiesPolicy = FALSE;
#ifdef WININET6
GLOBAL HKEY GlobalCacheHKey = HKEY_CURRENT_USER;
#endif

GLOBAL PTSTR GlobalSpecialDomains = NULL;
GLOBAL PTSTR *GlobalSDOffsets = NULL;

// auth globals

DWORD GlobalEnableNegotiate = FALSE;


// Nt service loading wininet. This triggers special semantics for webdav redir to avoid deadlocks
// due to crossprocessmutexes being taken (ConnectionMutex is a good example of that)
// (Shishir Pardikar)

GLOBAL BOOL GlobalIsProcessNtService = FALSE;

// Global Cred hack for Mars V2

PWC * g_pwcUserAndPassword;


// Begin (a-thkesa)
// The following global added to read expire time value from registry:Default is 30 Min
// See Windows Bug:557284/WinSE:23879 
// Declared in proxysup.hxx
GLOBAL DWORD GlobalBadProxyExpiresTime = 30*60; // this will be multiplied 
// End(a-thkesa)  


BOOL       g_fHasCredsTimestamp;
SYSTEMTIME g_TimeCredsEntered;

void SetUserOrPass (LPSTR lpszIn, BOOL fUser)
{
    if (NULL == g_pwcUserAndPassword)
    {
        g_pwcUserAndPassword = PWC_Create(NULL, 0, NULL, NULL, NULL);
    }

    if (g_pwcUserAndPassword)
    {
        AuthLock();

        if (fUser)
        {
            g_pwcUserAndPassword->SetUser(lpszIn);
        }
        else
        {
            g_pwcUserAndPassword->SetPass(lpszIn);
        }

        AuthUnlock();
    }
}

void TimeStampCreds(void) 
{
    ::GetSystemTime(&g_TimeCredsEntered); // time-stamp the creds
    g_fHasCredsTimestamp = TRUE;
}

PSYSTEMTIME GetCredTimeStamp (void) 
{
    if (g_fHasCredsTimestamp)
    {
        return &g_TimeCredsEntered;
    } 
    else 
    {
        return NULL;
    }
}

BOOL GetUserAndPass (LPSTR *pszUser, LPSTR *pszPass)
{
    if (g_pwcUserAndPassword)
    {
        if (g_pwcUserAndPassword->lpszUser && g_pwcUserAndPassword->lpszPass)
        {
            *pszUser = g_pwcUserAndPassword->GetUser();
            *pszPass = g_pwcUserAndPassword->GetPass();
            return TRUE;
        }
    }

    *pszUser = *pszPass = NULL;
    return FALSE;
}

//
// functions
//


#ifdef UNIX
extern "C"
#endif /* UNIX */
VOID
GlobalDllInitialize(
    VOID
    )

/*++

Routine Description:

    The set of initializations - critical sections, etc. - that must be done at
    DLL_PROCESS_ATTACH

Arguments:

    None.

Return Value:

    None.

--*/

{
    DEBUG_ENTER((DBG_GLOBAL,
                 None,
                 "GlobalDllInitialize",
                 NULL
                 ));

    CLEAR_DEBUG_CRIT(szDebugBlankBuffer);

    GetCurrentGmtTime((LPFILETIME)&dwdwSessionStartTime);

    InitializeCriticalSection(&AutoProxyDllCritSec);
    InitializeCriticalSection(&LockRequestFileCritSec);
    InitializeCriticalSection(&ZoneMgrCritSec);
    InitializeCriticalSection(&MlangCritSec);


    InitializeSerializedList(&GlobalObjectList);
    InitializeSerializedList(&GlobalServerInfoList);
    InitializeSerializedList(&BlockedRequestQueue);

    AuthOpen();

    IwinsockInitialize();
    SecurityInitialize();
    FtpInitialize();
    GopherInitialize();

    //
    // initialize cache critical sections etc.
    //

    DLLUrlCacheEntry(DLL_PROCESS_ATTACH);

    EnsureInternetSettingsKeyCached();

    DEBUG_LEAVE(0);
}


#ifdef UNIX
extern "C"
#endif /* UNIX */
VOID
GlobalDllTerminate(
    VOID
    )

/*++

Routine Description:

    Undoes the initializations of GlobalDllInitialize

Arguments:

    None.

Return Value:

    None.

--*/

{
    DEBUG_ENTER((DBG_GLOBAL,
                 None,
                 "GlobalDllTerminate",
                 NULL
                 ));

    //
    // only perform resource clean-up if this DLL is being unloaded due to a
    // FreeLibrary() call. Otherwise, we take the lazy way out and let the
    // system clean up after us
    //

    if (GlobalDynaUnload) {
        TerminateAsyncSupport();
        GopherTerminate();
        FtpTerminate();
        IwinsockTerminate();
        HandleTerminate();
    }

    CHECK_SOCKETS();

    AuthClose();

    TerminateSerializedList(&BlockedRequestQueue);
    TerminateSerializedList(&GlobalServerInfoList);

    //
    //BUGBUG: we can't Terminate the list here because
    //        of a race condition from IE3
    //        (someone still holds the handle)
    //        but we don't want to leak the CritSec
    //        TerminateSerlizedList == DeleteCritSec + some Asserts
    //
    //TerminateSerializedList(&GlobalObjectList);
    DeleteCriticalSection(&(GlobalObjectList.Lock));


    DeleteCriticalSection(&MlangCritSec);
    DeleteCriticalSection(&ZoneMgrCritSec);
    DeleteCriticalSection(&LockRequestFileCritSec);
    DeleteCriticalSection(&AutoProxyDllCritSec);

    DLLUrlCacheEntry(DLL_PROCESS_DETACH);

    SecurityTerminate();

    if (g_HMODSHFolder)
    {
        FreeLibrary(g_HMODSHFolder);
        g_HMODSHFolder = NULL;
    }
    if (g_HMODShell32)
    {
        FreeLibrary(g_HMODShell32);
        g_HMODShell32 = NULL;
    }
    
    CloseInternetSettingsKey();

    DEBUG_LEAVE(0);
}


DWORD
GlobalDataInitialize(
    VOID
    )

/*++

Routine Description:

    Loads any global data items from the registry

Arguments:

    None.

Return Value:

    DWORD
        Success - ERROR_SUCCESS

        Failure - ERROR_NOT_ENOUGH_MEMORY

--*/

{
    DEBUG_ENTER((DBG_GLOBAL,
                 Dword,
                 "GlobalDataInitialize",
                 NULL
                 ));

    static BOOL Initializing = FALSE;
    static BOOL Initialized = FALSE;
    static DWORD error = ERROR_SUCCESS;
    
    //
    // only one thread initializes
    //

    if (InterlockedExchange((LPLONG)&Initializing, TRUE)) {
        while (!Initialized) {
            SleepEx(0, TRUE);
        }
        goto done;
    }

    //
    // we ignore any failure return codes from reading the registry. All the
    // global variables are initialized to default values
    //

    //
    // UseSchannelDirectly - TRUE if we are to bypass SSPI "Secur32/Security"
    //      and directly call into SCHANNEL.  This should give us a perf
    //      improvement since we don't have to load an extra DLL.
    //

    g_fHasCredsTimestamp = FALSE;

//
// BUGBUG - all these need to be per-process. They are intended for IE
//
    memset(&GlobalIdentityGuid, 0, sizeof(GlobalIdentityGuid));

    InternetReadRegistryDword("FromCacheTimeout",
                              (LPDWORD)&GlobalFromCacheTimeout
                              );

    //InternetReadRegistryDword("UseSchannelDirectly",
    //                          (LPDWORD)&GlobalUseSchannelDirectly
    //                          );

    // also in ChangeGlobalSettings()
    InternetReadRegistryDword("SecureProtocols",
                              (LPDWORD)&GlobalSecureProtocols
                              );

    // also in ChangeGlobalSettings()
    if (!GlobalPlatformWhistler)
    {
        // Fortezza support has been removed from XP
        InternetReadRegistryDword("Fortezza",
                                  (LPDWORD)&GlobalEnableFortezza
                                  );
    }
    else
    {
        GlobalEnableFortezza = FALSE;
    }

    // also in ChangeGlobalSettings()
    InternetReadRegistryDword("CertificateRevocation",
                              (LPDWORD)&GlobalEnableRevocation
                              );

    InternetReadRegistryDword("DisableKeepAlive",
                              (LPDWORD)&GlobalDisableKeepAlive
                              );

    InternetReadRegistryDword("DisablePassport",
                          (LPDWORD)&GlobalDisablePassport
                          );

    InternetReadRegistryDword("CacheMode", (LPDWORD) &GlobalCacheMode);

    // also in ChangeGlobalSettings()
    InternetReadRegistryDword("EnableHttp1_1",
                              (LPDWORD)&GlobalEnableHttp1_1
                              );

    // also in ChangeGlobalSettings()
    InternetReadRegistryDword("ProxyHttp1.1",
                              (LPDWORD)&GlobalEnableProxyHttp1_1
                              );

    DWORD dwEnableNegotiate = -1;
    InternetReadRegistryDword("EnableNegotiate",
                      (LPDWORD)&dwEnableNegotiate
                      );
    if (dwEnableNegotiate != -1)
    {
        // the value is present in the registy, so we honor it.
        GlobalEnableNegotiate = dwEnableNegotiate;
    }
    else
    {
        if (GlobalPlatformWhistler && !IsInGUIModeSetup())
        {
            // the value is abscent in Whistler, we'll need to turn set the value to 1
            InternetWriteRegistryDword("EnableNegotiate", 1);
            GlobalEnableNegotiate = TRUE;
        }
    }


    GetUrlCacheHeaderData(CACHE_HEADER_DATA_DOWNLOAD_PARTIAL, &GlobalSslStateCount);


    DWORD dwType, dwSize;

    dwSize = sizeof(DWORD);

    SHGetValue(HKEY_CURRENT_USER, INTERNET_POLICY_KEY,
        "EnableAutoProxyResultCache", &dwType, &GlobalAutoProxyCacheEnable, &dwSize);

    dwSize = sizeof(DWORD);
    SHGetValue(HKEY_CURRENT_USER, INTERNET_POLICY_KEY,
        "DisplayScriptDownloadFailureUI", &dwType, &GlobalDisplayScriptDownloadFailureUI, &dwSize);

    dwSize = sizeof(DWORD);
    SHGetValue(HKEY_CURRENT_USER, INTERNET_POLICY_KEY,
        "MBCSServername", &dwType, &GlobalSendUTF8ServerToProxy, &dwSize);
    
    dwSize = sizeof(DWORD);
    SHGetValue(HKEY_CURRENT_USER, INTERNET_POLICY_KEY,
        "MBCSAPIforCrack", &dwType, &GlobalMBCSAPIforCrack, &dwSize);

    dwSize = sizeof(DWORD);
    SHGetValue(HKEY_CURRENT_USER, INTERNET_POLICY_KEY,
        "UTF8ServerNameRes", &dwType, &GlobalUseUTF8ServerForNameRes, &dwSize);

    //Read DisableWorkerThreadHibernation from HKLM first and allow HKCU override.
    InternetReadRegistryDwordKey(HKEY_LOCAL_MACHINE,
                                 "DisableWorkerThreadHibernation",
                                 (LPDWORD)&g_bDisableHibernation
                                 );
    InternetReadRegistryDword("DisableWorkerThreadHibernation",
                              (LPDWORD)&g_bDisableHibernation
                              );
                              
    GlobalUseUTF8ServerForNameRes = GlobalUseUTF8ServerForNameRes 
                            && GlobalSendUTF8ServerToProxy;
                              
    InternetReadRegistryDword("DisableReadRange",
                              (LPDWORD)&GlobalDisableReadRange
                              );

    InternetReadRegistryDword("SocketSendBufferLength",
                              &GlobalSocketSendBufferLength
                              );

    InternetReadRegistryDword("SocketReceiveBufferLength",
                              &GlobalSocketReceiveBufferLength
                              );

    InternetReadRegistryDword("KeepAliveTimeout",
                              &GlobalKeepAliveSocketTimeout
                              );

    InternetReadRegistryDword("MaxHttpRedirects",
                              &GlobalMaxHttpRedirects
                              );

    InternetReadRegistryDword("MaxConnectionsPerServer",
                              &GlobalMaxConnectionsPerServer
                              );

    InternetReadRegistryDword("MaxConnectionsPer1_0Server",
                              &GlobalMaxConnectionsPer1_0Server
                              );

    InternetReadRegistryDword("ServerInfoTimeout",
                              &GlobalServerInfoTimeout
                              );

    InternetReadRegistryDword("ReceiveTimeOut",
                              (LPDWORD)&GlobalReceiveTimeout
                              );

    InternetReadRegistryDword("DisableNTLMPreAuth",
                              (LPDWORD)&GlobalDisableNTLMPreAuth
                              );

    InternetReadRegistryDword("ScavengeCacheLowerBound",
                              (LPDWORD)&GlobalDiskUsageLowerBound
                              );

    InternetCacheReadRegistryDword("ScavengeCacheFileLifeTime",
                              (LPDWORD)&GlobalScavengeFileLifeTime
                              );

    DWORD dwDefTime;

    if (InternetReadRegistryDword("HttpDefaultExpiryTimeSecs", &dwDefTime) ==
            ERROR_SUCCESS) {
        dwdwHttpDefaultExpiryDelta = dwDefTime * (LONGLONG)10000000;
    }

    if (InternetReadRegistryDword("FtpDefaultExpiryTimeSecs", &dwDefTime) ==
            ERROR_SUCCESS) {
        dwdwFtpDefaultExpiryDelta = dwDefTime * (LONGLONG)10000000;
    }

    if (InternetReadRegistryDword("GopherDefaultExpiryTimeSecs", &dwDefTime) ==
            ERROR_SUCCESS) {
        dwdwGopherDefaultExpiryDelta = dwDefTime * (LONGLONG)10000000;
    }

    InternetReadRegistryDword(vszDisableSslCaching, (LPDWORD)&GlobalDisableSslCaching);

    InternetReadRegistryDword(vszPerUserCookies, (LPDWORD)&vfPerUserCookies);

    InternetReadRegistryDword(vszLeashLegacyCookies, (LPDWORD)&GlobalLeashLegacyCookies);

    InternetReadRegistryDword("DisableNT4RasCheck", (LPDWORD)&GlobalDisableNT4RasCheck);
    InternetReadRegistryDword("DialupUseLanSettings", (LPDWORD)&GlobalUseLanSettings);

    InternetReadRegistryDword("SendExtraCRLF", (LPDWORD)&GlobalSendExtraCRLF);
    InternetReadRegistryDword("BypassFtpTimeCheck", (LPDWORD)&GlobalBypassFtpTimeCheck);

    InternetReadRegistryDword("EnableGopher", (LPDWORD)&GlobalEnableGopher);

    dwSize = sizeof(DWORD);
    SHRegGetUSValue( INTERNET_SETTINGS_KEY, "BypassSSLNoCacheCheck", &dwType, 
                    (LPVOID)&GlobalBypassSSLNoCacheCheck, &dwSize, FALSE, NULL, 0 );


    //
    //  fix for Novell's Client32 - zekel 23-jul-96
    //  first check HKLM then HKCU, HKCU takes precdence
    //

    InternetReadRegistryDwordKey(HKEY_LOCAL_MACHINE,
                                 "DontUseDNSLoadBalancing",
                                 (LPDWORD)&fDontUseDNSLoadBalancing
                                 );
    InternetReadRegistryDword("DontUseDNSLoadBalancing",
                              (LPDWORD) &fDontUseDNSLoadBalancing
                              );

    InternetReadRegistryDword("NonBlockingClient32",
                              (LPDWORD)&GlobalNonBlockingClient32
                              );

    //
    // Get the list of MIME types for which caching needs to be disabled
    //

    CreateMimeExclusionTableForCache();

    //
    // Get the list of headers that should be excluded from the cache
    //

    CreateHeaderExclusionTableForCache();


    DEBUG_PRINT(HTTP,
                INFO,
                ("Current wininet user is %s length %d\n",
                vszCurrentUser,
                vdwCurrentUserLen
                ));


    //
    // initialize databases
    //

    InitializeResolverCache();
    GlobalDataReadWarningUIFlags();

    PerformStartupProcessing();

    //
    // create the global keep-alive, cert-cache and proxy lists
    //

    GlobalCertCache.Initialize();
    GlobalProxyInfo.InitializeProxySettings();
    

    //LoadServerInfoDatabase();


    //
    // initialize offline mode from registry
    //

    RefreshOfflineFromRegistry();

    //
    // read the global (cache) settings version to avoid an unnecessary reload
    // N.B. we rely on the side effect of calling urlcache InitGlobals
    //
    InternetSettingsChanged();

    char buf[MAX_PATH + 1];

    if (GetModuleFileName(NULL, buf, sizeof(buf))) {
        LPSTR p = strrchr(buf, DIR_SEPARATOR_CHAR);
        p = p ? ++p : buf;

        DEBUG_PRINT(INET, INFO, ("process is %q\n", p));

        if (lstrcmpi(p, "EXPLORER.EXE") && lstrcmpi(p, "IEXPLORE.EXE")) {

            //
            // yet another app-hack: AOL's current browser can't understand
            // HTTP 1.1. When they do, they have to call InternetSetOption()
            // with INTERNET_OPTION_HTTP_VERSION
            //

            if (!lstrcmpi(p, "WAOL.EXE")) {
                GlobalEnableHttp1_1 = FALSE;
            }


            if (!lstrcmpi(p, "SVCHOST.EXE")     ||
                !lstrcmpi(p, "SERVICES.EXE")) {
                GlobalIsProcessNtService = TRUE;
            }
            
            //
            // non-IE app must supply this through option
            //

            GlobalFromCacheTimeout = (DWORD)-1;
        } else {
            GlobalIsProcessExplorer = TRUE;
        }
    } else {

        DEBUG_PRINT(INET,
                    INFO,
                    ("GetModuleFileName() returns %d\n",
                    GetLastError()
                    ));

    }

    

    //
    // initialize the autodial code
    //

    // NB!!! this has been moved AFTER the above app hack because it uses the GlobalIsProcessNtService
    // variable to decide whether to create a perprocess connection mutex or cross-process
    // (Shishir Pardikar)

    InitAutodialModule(FALSE);




#if defined(SITARA)

    //
    // check if Sitara is loaded (IE5B1). Existence of key means Sitara
    // installed
    //

    HKEY key;

    if (RegOpenKeyEx(HKEY_LOCAL_MACHINE,
                     "Software\\Microsoft\\InternetExpressLane",
                     0,
                     KEY_QUERY_VALUE,
                     &key) == ERROR_SUCCESS) {
        REGCLOSEKEY(key);
        OpenIeMainKey();
        GlobalEnableSitara = CheckABS();
    }

#endif // SITARA

    DWORD urlEncoding;

    urlEncoding = 0;
    InternetReadRegistryDwordKey(HKEY_LOCAL_MACHINE,
                                 "UrlEncoding",
                                 &urlEncoding
                                 );
    if (urlEncoding == 0) {
        GlobalEnableUtf8Encoding = TRUE;
    }

    // File name truncate ?
    DWORD dwTruncateFileName;

    dwTruncateFileName = 0;
    InternetReadRegistryDword("TruncateFileName", &dwTruncateFileName);

    if (dwTruncateFileName != 0) 
        GlobalTruncateFileName = TRUE;

    //
    // perform module/package-specific initialization
    //

    error = HandleInitialize();
    if (error != ERROR_SUCCESS) {
        goto quit;
    }

    //
    // initalize the cookie system
    //

    if (!OpenTheCookieJar()) {
        error = ERROR_NOT_ENOUGH_MEMORY;
        goto quit;
    }

    //
    // initialize the background task manager
    //
    if( !LoadBackgroundTaskMgr() ) {
        error = ERROR_NOT_ENOUGH_MEMORY;
        //goto quit;
    }


	// Begin (a-thkesa) 
	// Read GlobalBadProxyExpiresTime value from the registry.
	  InternetReadRegistryDword("BadProxyExpiresTime", (LPDWORD)&GlobalBadProxyExpiresTime);
	// End (a-thkesa)


quit:

    //
    // finally, if EnableHttp1_1 was set to non-zero in the registry, enable
    // HTTP 1.1
    //

    if (GlobalEnableHttp1_1) {
        HttpVersionInfo.dwMajorVersion = 1;
        HttpVersionInfo.dwMinorVersion = 1;
    }

    if (error == ERROR_SUCCESS) {
        GlobalDataInitialized = TRUE;
    }

    //
    // irrespective of success or failure, we have attempted global data
    // initialization. If we failed then we assume its something fundamental
    // and fatal: we don't try again
    //

    Initialized = TRUE;

done:

    DEBUG_LEAVE(error);

    return error;
}


VOID
GlobalDataReadWarningUIFlags(
    VOID
    )

/*++

Routine Description:

    Reads Registry values into global data.
    Used to read read the registry on connects.

Arguments:

    None.

Return Value:

    DWORD
        Success - ERROR_SUCCESS

        Failure - ERROR_NOT_ENOUGH_MEMORY

--*/

{
    DEBUG_ENTER((DBG_GLOBAL,
                 None,
                 "GlobalDataReadWarningUIFlags",
                 NULL
                 ));

#ifndef WININET6
    //
    // Load SSL Values from the Registry on whether to pop up UI on error.
    //

    InternetReadRegistryDword("WarnOnPost", (LPDWORD)&GlobalWarnOnPost);

    GlobalWarnAlways = FALSE;
    InternetReadRegistryDword("WarnAlwaysOnPost", (LPDWORD)&GlobalWarnAlways);

    //
    // If Global Warn On Post is set to "2" we reset the "WarnAlways" to TRUE,
    //  since this is the new way INETCPL reads/writes the registry.
    //

    if ( GlobalWarnOnPost == 2 )
    {
        GlobalWarnAlways = TRUE;
    }

    InternetReadRegistryDword("WarnOnZoneCrossing", (LPDWORD)&GlobalWarnOnZoneCrossing);

    InternetReadRegistryDword("WarnOnBadCertSending", (LPDWORD)&GlobalWarnOnBadCertSending);

    InternetReadRegistryDword("WarnOnBadCertRecving", (LPDWORD)&GlobalWarnOnBadCertRecving);

    InternetReadRegistryDword("WarnOnPostRedirect", (LPDWORD)&GlobalWarnOnPostRedirect);

    InternetReadRegistryDword("AlwaysDrainOnRedirect", (LPDWORD)&GlobalAlwaysDrainOnRedirect);
    
    InternetReadRegistryDword("WarnOnHTTPSToHTTPRedirect", (LPDWORD)&GlobalWarnOnHTTPSToHTTPRedirect);

#else
    //
    // Load SSL Values from the Registry on whether to pop up UI on error.
    //

    InternetIDEReadRegistryDword("WarnOnPost", (LPDWORD)&GlobalWarnOnPost);

    GlobalWarnAlways = FALSE;
    InternetIDEReadRegistryDword("WarnAlwaysOnPost", (LPDWORD)&GlobalWarnAlways);

    //
    // If Global Warn On Post is set to "2" we reset the "WarnAlways" to TRUE,
    //  since this is the new way INETCPL reads/writes the registry.
    //

    if ( GlobalWarnOnPost == 2 )
    {
        GlobalWarnAlways = TRUE;
    }

    InternetIDEReadRegistryDword("WarnOnZoneCrossing", (LPDWORD)&GlobalWarnOnZoneCrossing);

    InternetIDEReadRegistryDword("WarnOnBadCertSending", (LPDWORD)&GlobalWarnOnBadCertSending);



    InternetIDEReadRegistryDword("WarnOnBadCertRecving", (LPDWORD)&GlobalWarnOnBadCertRecving);

    InternetIDEReadRegistryDword("WarnOnPostRedirect", (LPDWORD)&GlobalWarnOnPostRedirect);

    InternetIDEReadRegistryDword("WarnOnHTTPSToHTTPRedirect", (LPDWORD)&GlobalWarnOnHTTPSToHTTPRedirect);
#endif


    DEBUG_LEAVE(0);
}


VOID
GlobalDataTerminate(
    VOID
    )

/*++

Routine Description:

    Undoes work of GlobalDataInitialize()

Arguments:

    None.

Return Value:

    None.

--*/

{
    DEBUG_ENTER((DBG_GLOBAL,
                 None,
                 "GlobalDataTerminate",
                 NULL
                 ));

    //
    // Release background task manager
    //
    UnloadBackgroundTaskMgr();

    PWC_Free(g_pwcUserAndPassword);

    AuthUnload();
    UrlZonesDetach();

    TerminateResolverCache();
    CloseTheCookieJar();

    if (GlobalSpecialDomains)
    {
        delete [] GlobalSpecialDomains;
        delete [] GlobalSDOffsets;
    }
    
    //
    // destroy lists created from registry
    //

    DestroyMimeExclusionTableForCache();
    DestroyHeaderExclusionTableForCache();

    //
    // terminate the global cert-cache and proxy lists
    //

    GlobalCertCache.Terminate();
    GlobalProxyInfo.TerminateProxySettings();


    //SaveServerInfoDatabase();
    PurgeServerInfoList(TRUE);

    //TerminateAsyncSupport();

    //
    // free up the handle to the startup mutex
    //
    if (g_hAutodialMutex) {
        CloseHandle(g_hAutodialMutex);
    }

#if defined(SITARA)

    CloseIeMainKey();

#endif // SITARA

    UnloadMlang();
    UnloadSecurity();

    GlobalDataInitialized = FALSE;

    DEBUG_LEAVE(0);
}


BOOL
IsHttp1_1(
    VOID
    )

/*++

Routine Description:

    Determine if we are using HTTP 1.1 or greater

Arguments:

    None.

Return Value:

    BOOL

--*/

{
    return (HttpVersionInfo.dwMajorVersion > 1)
            ? TRUE
            : (((HttpVersionInfo.dwMajorVersion == 1)
                && (HttpVersionInfo.dwMajorVersion >= 1))
                ? TRUE
                : FALSE);
}


BOOL
IsOffline(
    VOID
    )

/*++

Routine Description:

    Returns whether we are in (global) offline mode or not. We are offline if
    we went offline because of network failure, or we were put into offline
    mode by the user

Arguments:

    None.

Return Value:

    BOOL
        TRUE    - we are currently offline

        FALSE   - not offline

--*/

{
    DEBUG_ENTER((DBG_SESSION,
                 Bool,
                 "IsOffline",
                 NULL
                 ));

    INET_ASSERT(((GlobalDllState & INTERNET_LINE_STATE_MASK) == INTERNET_STATE_ONLINE)
                || ((GlobalDllState & INTERNET_LINE_STATE_MASK) == INTERNET_STATE_OFFLINE));
    INET_ASSERT((GlobalDllState & INTERNET_STATE_OFFLINE_USER)
                ? ((GlobalDllState & INTERNET_LINE_STATE_MASK) == INTERNET_STATE_OFFLINE)
                : TRUE);

    BOOL offline = (GlobalDllState & (INTERNET_STATE_OFFLINE | INTERNET_STATE_OFFLINE_USER))
                    ? TRUE
                    : FALSE;

    DEBUG_LEAVE(offline);

    return offline;
}


DWORD
SetOfflineUserState(
    IN DWORD dwState,
    IN BOOL bForce
    )

/*++

Routine Description:

    If we are in online state, puts Wininet into user-induced offline mode. Stop
    all outstanding requests, if required and set the global scope. If we are in
    offline mode, then change state to online

Arguments:

    dwState - INTERNET_STATE_ONLINE or INTERNET_STATE_OFFLINE

    bForce  - TRUE if we are to forcibly complete all outstanding requests
              (including synchronous requests)

Return Value:

    DWORD
        Success - ERROR_SUCCESS

        Failure -

--*/

{
    DEBUG_ENTER((DBG_GLOBAL,
                 Dword,
                 "SetOfflineUserState",
                 "%s (%d), %B",
                 (dwState == INTERNET_STATE_ONLINE) ? "INTERNET_STATE_ONLINE"
                 : (dwState == INTERNET_STATE_OFFLINE) ? "INTERNET_STATE_OFFLINE"
                 : "???",
                 dwState,
                 bForce
                 ));

    INET_ASSERT((dwState == INTERNET_STATE_ONLINE)
                || (dwState == INTERNET_STATE_OFFLINE));
    INET_ASSERT(((GlobalDllState & INTERNET_LINE_STATE_MASK) == INTERNET_STATE_ONLINE)
                || ((GlobalDllState & INTERNET_LINE_STATE_MASK) == INTERNET_STATE_OFFLINE));

    DWORD error = ERROR_SUCCESS;

    if (dwState == INTERNET_STATE_OFFLINE) {
        GlobalDllState = (GlobalDllState & ~INTERNET_LINE_STATE_MASK)
                       | (INTERNET_STATE_OFFLINE | INTERNET_STATE_OFFLINE_USER);
        if (bForce) {
            //CancelActiveAsyncRequests(ERROR_INTERNET_OFFLINE);
            CancelActiveSyncRequests(ERROR_INTERNET_OFFLINE);
            GlobalProxyInfo.AbortAutoProxy();
        }
    } else {
        GlobalDllState = GlobalDllState
                       & ~(INTERNET_LINE_STATE_MASK | INTERNET_STATE_OFFLINE_USER)
                       | INTERNET_STATE_ONLINE;
    }

    DEBUG_PRINT(GLOBAL,
                INFO,
                ("GlobalDllState = %#x\n",
                GlobalDllState
                ));

    DEBUG_LEAVE(error);

    return error;
}


/*++

FetchLocalStrings:

    This routine fetches the strings necessary to display information in the
    language of the local user.

Arguments:

    None

Return Value:

    The address of a LOCAL_STRINGS structure containing the addresses of the
    localized strings to display.

Author:

    Doug Barlow (dbarlow) 4/25/1996

--*/
//
// WARNING!  The order of elements in the following array must match the
// order of elements in the LOCAL_STRINGS structure.
//

static const UINT
    uStringId[]
        = { IDS_LW95_ENTERAUTHINFO,
            IDS_SECERT_CERTINFO,
            IDS_SECERT_STRENGTH_HIGH,
            IDS_SECERT_STRENGTH_MEDIUM,
            IDS_SECERT_STRENGTH_LOW,
            IDS_CERT_SUBJECT,
            IDS_CERT_ISSUER,
            IDS_CERT_EFFECTIVE_DATE,
            IDS_CERT_EXPIRATION_DATE,
            IDS_CERT_PROTOCOL,
            IDS_CERT_USAGE,
            IDS_CERT_ENCRYPT_ALG,
            IDS_CERT_HASH_ALG,
            IDS_CERT_EXCH_ALG,
            IDS_CERT_COMMENT,
            IDS_COMMENT_EXPIRES,
            IDS_COMMENT_NOT_VALID,
            IDS_COMMENT_BAD_CN,
            IDS_COMMENT_BAD_CA,
            IDS_COMMENT_BAD_SIGNATURE,
            IDS_COMMENT_REVOKED,
            IDS_STRING_CIPHMSG,
            IDS_STRING_HASHMSG,
            IDS_STRING_EXCHMSG,
            IDS_CERT_FINGERPRINT,
            IDS_DOMAIN,
            IDS_REALM,
            IDS_SITE,
            IDS_FIREWALL
};

PLOCAL_STRINGS
FetchLocalStrings(
    void)
{

    static LOCAL_STRINGS
        lszStrings;
    static BOOL fInitialized = FALSE;

    INET_ASSERT(sizeof(uStringId) == offsetof(LOCAL_STRINGS, rgchBuffer));
    EnterCriticalSection(&GeneralInitCritSec);
    __try
    {
        if (!fInitialized)
        {
            LPWSTR szBufEntry;
            LPWSTR *pszName;
            DWORD dwOffset;
            DWORD index, len;


            //
            // It needs to be initialized.
            //

            pszName = (LPWSTR *)&lszStrings;
            dwOffset = 0;
            for (index = 0;
                 index < sizeof(uStringId) / sizeof(UINT);
                 index += 1)
            {
                szBufEntry = &lszStrings.rgchBuffer[dwOffset];
                len = LoadStringWrapW(
                            GlobalDllHandle,
                            uStringId[index],
                            szBufEntry,
                            LOCAL_STRINGS_MAX_BUFFER - dwOffset);
                INET_ASSERT(0 != len);  // Resource missing!
                dwOffset += len;
                lszStrings.rgchBuffer[dwOffset++] = 0;
                *pszName++ = szBufEntry;
            }

            INET_ASSERT(LOCAL_STRINGS_MAX_BUFFER > dwOffset);


            //
            // Make it available to this and future callers.
            //

            fInitialized = TRUE;
        }
    }
    __finally
    {
        LeaveCriticalSection(&GeneralInitCritSec);
    }
    ENDFINALLY
    return &lszStrings;
}

PLOCAL_STRINGSA
FetchLocalStringsA(
    void)
{
    static LOCAL_STRINGSA
        lszStrings;
    static BOOL fInitialized = FALSE;

    INET_ASSERT(sizeof(uStringId) == offsetof(LOCAL_STRINGSA, rgchBuffer));
    EnterCriticalSection(&GeneralInitCritSec);
    __try
    {
        if (!fInitialized)
        {
            LPSTR szBufEntry;
            LPSTR *pszName;
            DWORD dwOffset;
            DWORD index, len;


            //
            // It needs to be initialized.
            //

            pszName = (LPSTR *)&lszStrings;
            dwOffset = 0;
            for (index = 0;
                 index < sizeof(uStringId) / sizeof(UINT);
                 index += 1)
            {
                szBufEntry = &lszStrings.rgchBuffer[dwOffset];
                len = LoadStringA(
                            GlobalDllHandle,
                            uStringId[index],
                            szBufEntry,
                            LOCAL_STRINGS_MAX_BUFFER - dwOffset);
                INET_ASSERT(0 != len);  // Resource missing!
                dwOffset += len;
                lszStrings.rgchBuffer[dwOffset++] = 0;
                *pszName++ = szBufEntry;
            }

            INET_ASSERT(LOCAL_STRINGS_MAX_BUFFER > dwOffset);

            //
            // Make it available to this and future callers.
            //

            fInitialized = TRUE;
        }
    }
    __finally
    {
        LeaveCriticalSection(&GeneralInitCritSec);
    }
    ENDFINALLY
    return &lszStrings;
}

BOOL
GetWininetUserName(
    VOID
)
{
    BOOL fRet = FALSE;
    DWORD dwT;
    CHAR *ptr;

    // Note this critsect could be blocked for a while if RPC gets involved...
    EnterCriticalSection(&GeneralInitCritSec);

    if (vdwCurrentUserLen) {
        fRet = TRUE;
        goto Done;
    }

    dwT = sizeof(vszCurrentUser);

    if (vfPerUserCookies) {

        fRet = GetUserName(vszCurrentUser, &dwT);

        if (!fRet) {

            DEBUG_PRINT(HTTP,
                        ERROR,
                        ("GetUsername returns %d\n",
                        GetLastError()
                        ));
        }

    }

    if (fRet == FALSE){

        strcpy(vszCurrentUser, vszAnyUserName);

        fRet = TRUE;
    }

    // Downcase the username.
    ptr = vszCurrentUser;
    while (*ptr)
    {
        /* BUGBUG: This logic mangles the user name when 
                   there are multi-byte characters.
           Unfortunately fixing it would lose legacy cookies so the 
           fix had to be backed out.
           The correct code is commented out below. */

        *ptr = tolower(*ptr);
        ptr++;

        // if (!IsDBCSLeadByte(*ptr))
        //    *ptr = tolower(*ptr);
        // ptr = CharNextExA(CP_ACP, ptr, 0);
    }

    INET_ASSERT(fRet == TRUE);

    vdwCurrentUserLen = (DWORD) (ptr - vszCurrentUser);


Done:
    LeaveCriticalSection(&GeneralInitCritSec);
    return (fRet);
}


VOID
ChangeGlobalSettings(
    VOID
    )

/*++

Routine Description:

    Changes global settings

Arguments:

    None.

Return Value:

    None.

--*/

{
    DEBUG_ENTER((DBG_GLOBAL,
                 None,
                 "ChangeGlobalSettings",
                 NULL
                 ));

    InternetReadRegistryDword(vszSyncMode,
                              &GlobalUrlCacheSyncMode
                              );

    InternetReadRegistryDword(vszDisableSslCaching,
                              (LPDWORD)&GlobalDisableSslCaching
                              );

    InternetReadRegistryDword("EnableHttp1_1",
                              (LPDWORD)&GlobalEnableHttp1_1
                              );

    InternetReadRegistryDword("ProxyHttp1.1",
                              (LPDWORD)&GlobalEnableProxyHttp1_1
                              );

    InternetReadRegistryDword(vszPerUserCookies,
                              (LPDWORD)&vfPerUserCookies
                              );

    InternetReadRegistryDword(vszLeashLegacyCookies, (LPDWORD)&GlobalLeashLegacyCookies);

    if (!GlobalProxyInfo.IsModifiedInProcess())
    {
        FixProxySettingsForCurrentConnection(
            FALSE
            );
    }

    //
    // update security protocol changes.
    //

    InternetReadRegistryDword("SecureProtocols",
                          (LPDWORD)&GlobalSecureProtocols
                          );

    if (!GlobalPlatformWhistler)
    {
        // Fortezza support has been removed from XP
        InternetReadRegistryDword("Fortezza",
                                  (LPDWORD)&GlobalEnableFortezza
                                  );
    }
    else
    {
        GlobalEnableFortezza = FALSE;
    }

    InternetReadRegistryDword("CertificateRevocation",
                              (LPDWORD)&GlobalEnableRevocation
                              );

    //
    // Check autodial settings and hang up if autodial was turned off
    //

    // have autodial module reset itself
    ResetAutodialModule();

    RefreshOfflineFromRegistry();

    // force reload of cookie-settings from registry by flushing memory cache
    RefreshP3PSettings();

    DEBUG_LEAVE(0);
}


VOID
RefreshOfflineFromRegistry(
    VOID
    )

/*++

Routine Description:

    Reads offline setting in the registry and sets wininet's offline mode
    accordingly.

Arguments:

    None.

Return Value:

    None.

--*/

{
    DEBUG_ENTER((DBG_GLOBAL,
                 None,
                 "RefreshOfflineFromRegistry",
                 NULL
                 ));

    DWORD dwTemp = 0;

    // note: this won't alter dwTemp if not found and so will default to
    // online
    InternetReadRegistryDword("GlobalUserOffline", &dwTemp);

    // convert to appropriate flags
    if(0 == dwTemp) {
        // online
        dwTemp = INTERNET_STATE_ONLINE;
    } else {
        // offline
        dwTemp = INTERNET_STATE_OFFLINE;
    }
    SetOfflineUserState(dwTemp, FALSE);

    DEBUG_LEAVE(0);
}


VOID
PerformStartupProcessing(
    VOID
    )

/*++

Routine Description:

    Performs actions exactly once on system startup.  Resets offline mode.

Arguments:

    None.

Return Value:

    None.

--*/

{
    DEBUG_ENTER((DBG_GLOBAL,
                 None,
                 "PerformStartupProcessing",
                 NULL
                 ));

    INET_ASSERT(NULL == g_hAutodialMutex);

    g_hAutodialMutex = OpenMutex(SYNCHRONIZE, FALSE, WININET_STARTUP_MUTEX);
    if (g_hAutodialMutex == NULL && (GetLastError() == ERROR_FILE_NOT_FOUND || GetLastError() == ERROR_INVALID_NAME))
    {
        SECURITY_ATTRIBUTES* psa = SHGetAllAccessSA();
        if (psa)
        {
            g_hAutodialMutex = CreateMutex(psa, FALSE, WININET_STARTUP_MUTEX);
        }
    }

    if(g_hAutodialMutex) {
        DWORD dwLastError = GetLastError();

        if(ERROR_SUCCESS == dwLastError) {
            // GetLastError returns ERROR_ALREADY_EXISTS if the mutex existed
            // before we created it.  If we don't get this error, we're the
            // first so proceed with out startup processing

            if(!GlobalPlatformVersion5)
            {
                // Reset global offline mode on non-Win2K platforms
                InternetWriteRegistryDword("GlobalUserOffline", 0);
            }
        }
    }

    DEBUG_LEAVE(0);
}

#if defined(SITARA)

PRIVATE HKEY IeMainKey = NULL;


PRIVATE
VOID
OpenIeMainKey(
    VOID
    )
{
    if (RegOpenKeyEx(HKEY_CURRENT_USER,
                     "Software\\Microsoft\\Internet Explorer\\Main",
                     0,
                     KEY_QUERY_VALUE,
                     &IeMainKey
                     ) != ERROR_SUCCESS) {
        IeMainKey = NULL;
    }
}


PRIVATE
VOID
CloseIeMainKey(
    VOID
    )
{
    if (IeMainKey != NULL) {
        REGCLOSEKEY(IeMainKey);
        IeMainKey = NULL;
    }
}


DWORD
GetSitaraProtocol(
    VOID
    )
{
    DEBUG_ENTER((DBG_SOCKETS,
                 Int,
                 "GetSitaraProtocol",
                 NULL
                 ));

    DWORD dwProtocol = IPPROTO_TCP;
    DWORD dwEnabled = 0;

    if (ReadIeMainDwordValue("Use_Express_Lane", &dwEnabled) && (dwEnabled != 0)) {
        dwProtocol = 901;
    }

    DEBUG_LEAVE(dwProtocol);

    return dwProtocol;
}


PRIVATE
BOOL
CheckABS(
    VOID
    )
{
    DEBUG_ENTER((DBG_SOCKETS,
                 Bool,
                 "CheckABS",
                 NULL
                 ));

    BOOL on = 0;

    ReadIeMainDwordValue("ABS", (LPDWORD)&on);

    DEBUG_LEAVE(!on);

    return !on;
}


PRIVATE
BOOL
ReadIeMainDwordValue(
    IN LPSTR pszValueName,
    OUT LPDWORD pdwValue
    )
{
    if (IeMainKey != NULL) {

        DWORD value;
        DWORD valueType;
        DWORD valueLength = sizeof(value);
        DWORD err = RegQueryValueEx(IeMainKey,
                                    pszValueName,
                                    NULL,
                                    &valueType,
                                    (LPBYTE)&value,
                                    &valueLength
                                    );

        if ((err == ERROR_SUCCESS)
            && ((valueType == REG_DWORD) || (valueType == REG_BINARY))
            && (valueLength == sizeof(DWORD))) {
            *pdwValue = value;
            return TRUE;
        }
    }
    return FALSE;
}

#endif // SITARA


// Loads Mlang.dll and get the entry point we are interested in.

BOOL LoadMlang( )
{
    EnterCriticalSection(&MlangCritSec);

    if (hInstMlang == NULL && !bFailedMlangLoad)
    {
        INET_ASSERT(pfnInetMultiByteToUnicode == NULL);
        hInstMlang = LoadLibrary(MLANGDLLNAME);

        if (hInstMlang != NULL)
        {
            pfnInetMultiByteToUnicode = (PFNINETMULTIBYTETOUNICODE)GetProcAddress
                                            (hInstMlang,"ConvertINetMultiByteToUnicode");
            if (pfnInetMultiByteToUnicode == NULL)
            {
                INET_ASSERT(FALSE);
                FreeLibrary(hInstMlang);
                hInstMlang = NULL;
            }
        }
        else
        {
            INET_ASSERT(FALSE); // bad news if we can't load mlang.dll
        }

        if (pfnInetMultiByteToUnicode == NULL)
            bFailedMlangLoad = TRUE;
    }

    LeaveCriticalSection(&MlangCritSec);

    return (pfnInetMultiByteToUnicode != NULL);
}

BOOL UnloadMlang( )
{
    EnterCriticalSection(&MlangCritSec);

    if (hInstMlang)
        FreeLibrary(hInstMlang);

    hInstMlang = NULL;
    pfnInetMultiByteToUnicode = NULL;
    bFailedMlangLoad = FALSE;

    LeaveCriticalSection(&MlangCritSec);

    return TRUE;
}

PFNINETMULTIBYTETOUNICODE GetInetMultiByteToUnicode( )
{
    // We are checking for pfnInetMultiByteToUnicode without getting a crit section.
    // This works only because UnloadMlang is called at the Dll unload time.

    if (pfnInetMultiByteToUnicode == NULL)
    {
        LoadMlang( );
    }

    return pfnInetMultiByteToUnicode;
}