#include <wininetp.h>
#include <wininet.h>

//#include "..\inc\cookimp.h"

#define NS_COOKIE_IMPORT_KEY        TEXT("SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Internet Settings\\5.0\\NSCookieUpgrade")
#define NS_COOKIE_IMPORT_VERSION    TEXT("Version")
#define NS_COOKIE_IMPORT_FLAG       TEXT("DisableUpgrade")

#define HTML_FILE_EXTENSION         TEXT(".htm")
#define NS_EXE_FILENAME             TEXT("Netscape.exe")
#define NS_COOKIE_FILENAME          TEXT("cookies.txt")

#define OPEN_COMMAND_OF_APP         TEXT("\\shell\\open\\command")
#define NS_APP_PATHS_REG            TEXT("SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\App Paths\\Netscape.exe")

#define NS3_COOKIE_REG_PATH         TEXT("Software\\Netscape\\Netscape Navigator\\Cookies")
#define NS3_COOKIE_REG_KEY          TEXT("Cookie File")
#define NS4_USERS_REG_PATH          TEXT("Software\\Netscape\\Netscape Navigator\\Users")
#define NS4_USERPATH_REG_KEY        TEXT("DirRoot")

//  note:  LENGTHOFSTR()'s result includes terminating character
#define LENGTHOFTSTR( x ) (sizeof(x) / sizeof(TCHAR))

bool EndOfLine( CHAR chr );
BOOL InternetTimeFromTime_tA( IN DWORD dwTime, OUT LPSTR lpszTime, /* in-out */ DWORD cbBufferSize );


//--------------------------------------------------------------------
//
//  ImportCookieFile
//

//  parses a Netscape 'cookies.txt' file and adds each cookie using InternetSetCookie
BOOLAPI ImportCookieFileW( IN LPCWSTR szFilename)
{
    MEMORYPACKET mpFilename;
    ALLOC_MB(szFilename,0,mpFilename);
    if (!mpFilename.psStr)
    {
        return FALSE;
    }
    UNICODE_TO_ANSI(szFilename,mpFilename);

    return ImportCookieFileA( mpFilename.psStr);
};


BOOLAPI ImportCookieFileA( IN LPCSTR szFilename )
{
    BOOL retVal = FALSE;

    HANDLE hFile = (HKEY) INVALID_HANDLE_VALUE;
    LPSTR szFile = NULL;
    DWORD cbFileSize;

    if( ReadFileToBuffer( szFilename, (BYTE**)&szFile, &cbFileSize) != TRUE)
        goto doneImportFile;

    // parse file line by line
    DWORD iPosition;
    iPosition = 0;
    while( iPosition < cbFileSize )
    {
        LPSTR szValue = NULL;
        LPSTR szURL = NULL;

        //   blank lines are ignored
        if( EndOfLine( szFile[iPosition]))
        {
            iPosition++;
            continue;
        }

        //   lines beginning with # are comments
        if( szFile[iPosition] == '#')
        {
            while ( iPosition < cbFileSize && !EndOfLine( szFile[iPosition]))
                iPosition++;

            iPosition++;
            continue;
        }

        //   see CookieFormat text file for the spec of a Netscape 'cookies.txt'
        const DWORD iArgCount = 7;
        enum eArgTypes { DOMAIN=0,UNUSED=1,PATH=2,SECURE=3,EXPIRES=4,NAME=5,VALUE=6 };

        //  parse cookie into 7 fields (szArg[0..6]) with lengths stored in cbArgLength[0..6]
        LPSTR szArg[iArgCount];
        DWORD cbArgLength[iArgCount];

        // Continue parsing fields only if end of line/file hasn't been hit.
        // 'for' is re-entered when the end of each cookie is found:
        //      On re-entry, null terminate the cookie found.
        for( DWORD iArgIndex = 0;
                iPosition < cbFileSize && !EndOfLine( szFile[iPosition]);
                iArgIndex++, szFile[iPosition++] = '\0')
        {
            //  sanity check: are there really only 7 fields?
            if( iArgIndex >= iArgCount )
            {
                INET_ASSERT(FALSE);

                // if there are more than 7 fields, move to where a new cookie should start
                while ( iPosition < cbFileSize && !EndOfLine( szFile[iPosition]))
                    iPosition++;

                // end of invalid cookie found, now increment to next cookie.
                iPosition++;

                goto doneImportCookie;
            }

            //  Mark the beginning of the field.
            szArg[iArgIndex] = &szFile[iPosition];

            //  Find the end of the field.
            while( iPosition < cbFileSize && szFile[iPosition] != '\t' && !EndOfLine( szFile[iPosition]) )
                iPosition++;

            // Calculate the length of the cookie.
            cbArgLength[iArgIndex] = (unsigned long) (&szFile[iPosition] - szArg[iArgIndex]);
        }

        if( iArgIndex < iArgCount )
        {
            //sanity check: Are there enough fields?
            INET_ASSERT(FALSE);
            goto doneImportCookie;
        }

        // build HTTP cookie string in szValue
        DWORD cbValueSize;
        cbValueSize =  cbArgLength[NAME]
                    + cbArgLength[VALUE]
                    + cbArgLength[DOMAIN]
                    + sizeof("=;secure;expires=;domain=")
                    + INTERNET_RFC1123_BUFSIZE
                    + 1;
        szValue = new CHAR[ cbValueSize];

        if( szValue == NULL )
            goto doneImportCookie;

        LPSTR pValueIterator;
        pValueIterator = szValue;

        // add 'name=value' pair
        memcpy( pValueIterator, szArg[NAME], cbArgLength[NAME] );
        pValueIterator += cbArgLength[NAME];
        pValueIterator[0] = '=';
        pValueIterator++;
        memcpy( pValueIterator, szArg[VALUE], cbArgLength[VALUE] );
        pValueIterator += cbArgLength[VALUE];

        //  set security information
        if( szArg[SECURE][0] == 'T' || szArg[SECURE][0] == 't' )
        {
            memcpy( pValueIterator, ";secure", sizeof(";secure") - 1);
            pValueIterator += sizeof(";secure") - 1;
        }

        //  In a path that is on the HD, Netscape's path is like "/c|/directory/filename.ext"
        //  I need the path to read as "/c:\directory\filename.ext".
        if( cbArgLength[DOMAIN] == 0 )
            for( LPSTR pchr = szArg[PATH]; *pchr != '\0'; pchr++ )
            {
                if( *pchr == '|' )
                    *pchr = ':';
                if( *pchr == '/' && pchr != szArg[PATH] )
                    *pchr = '\\';
            }

        //  InternetSetCookie accepts files with a local domain if it isn't
        // explicitly declared.. which related to a bug in InternetSetCookie.
        if( cbArgLength[DOMAIN] != 0 )
        {
            //  add the domain=DOMAIN pair
            memcpy( pValueIterator, ";domain=", sizeof(";domain=") - 1);
            pValueIterator += sizeof(";domain=") - 1;
            memcpy( pValueIterator, szArg[DOMAIN], cbArgLength[DOMAIN]);
            pValueIterator += cbArgLength[DOMAIN];
        }

        //  InternetSetCookie doesn't work right if the path ends in a filename.
        //so I'll stick the path in the szURL parameter (which accepts filenames)
        ////  add the path=PATH pair
        //memcpy( pValueIterator, ";path=", sizeof(";path=") - 1);
        //pValueIterator += sizeof(";path=") - 1;
        //memcpy( pValueIterator, szArg[PATH], cbArgLength[PATH]);
        //pValueIterator += cbArgLength[PATH];

        //  set expiration info
        memcpy( pValueIterator,";expires=", sizeof(";expires=") - 1);
        pValueIterator += sizeof(";expires=") - 1;

        if( InternetTimeFromTime_tA( StrToLong( szArg[EXPIRES]), pValueIterator, INTERNET_RFC1123_BUFSIZE ) != TRUE )
            goto doneImportCookie;

        //  InternetSetCookie requires an URL.. There isn't a complete url in the netscape cookie, but it can
        //be fudged.  The path in the URL will become the path stored for the cookie, the rest is checked for
        //legality then ignored.
        DWORD cbURLSize;
        cbURLSize = sizeof("nnnn://")
            + cbArgLength[DOMAIN]
            + cbArgLength[PATH]
            + 1;
        szURL = new CHAR[ cbURLSize];

        if( szURL == NULL )
            goto doneImportCookie;

        LPSTR pURLIterator;
        pURLIterator = szURL;

        if( szArg[DOMAIN][0] == '\0')
        {
            memcpy( pURLIterator, "file:/", sizeof("file:/") - 1);
            pURLIterator += sizeof("file:/") - 1;
            memcpy( pURLIterator, szArg[PATH], cbArgLength[PATH]);
            pURLIterator += cbArgLength[PATH];
        }
        else
        {
            memcpy( pURLIterator, "http://", sizeof("http://") - 1);
            pURLIterator += sizeof("http://") - 1;
            memcpy( pURLIterator, szArg[DOMAIN], cbArgLength[DOMAIN]);
            pURLIterator += cbArgLength[DOMAIN];
            memcpy( pURLIterator, szArg[PATH], cbArgLength[PATH]);
            pURLIterator += cbArgLength[PATH];
        }
        pURLIterator[0] = '\0';

        //  don't overwrite exisiting cookies.
        DWORD dwTemp;
        CHAR szNullTerminatedName[ MAX_PATH];
        memcpy( szNullTerminatedName, szArg[NAME], cbArgLength[NAME]);
        szNullTerminatedName[ cbArgLength[NAME]] = '\0';
        if( InternetGetCookieEx( szURL, szNullTerminatedName,
            NULL, &dwTemp, 0, NULL) == TRUE)
        {
            // this cookie exists!  don't import.
            goto doneImportCookie;
        }

        DEBUG_PUT(( "\n\nCalled InternetSetCookie with\nUrl:%s\nValue:%s", szURL,  szValue));

#ifdef UNICODE
#error "ImportCookieFile(): InternetSetCookieA needs to be called directly from here."
#endif
        if( InternalInternetSetCookie( szURL, NULL, szValue, COOKIE_NOUI, NULL ) == FALSE )
        {
            DWORD temp = GetLastError();
            DEBUG_PUT(("\n Cookie Rejected!  Error code: %x", temp));
        }

    // If we got this far, we're done.
    retVal = TRUE;

    doneImportCookie:
        if( szValue != NULL)
            delete [] szValue;
        if( szURL != NULL)
            delete [] szURL;
    }



doneImportFile:
    if( hFile != (HKEY) INVALID_HANDLE_VALUE)
        CloseHandle( hFile);

    if( szFile != NULL)
        delete [] szFile;


    return retVal;
}


//--------------------------------------------------------------------
//
//  FindNetscapeCookieFile
//

//  Gets the cookie file and stores it in buffer szFilename.
//lpnBufSize contains the buffer's size on the way in, and the amount used on the way out (in characters)
//If FindNetscapeCookieFile succeeds, it returns TRUE, else it returns FALSE.
//If it fails, information may be written to the buffer with error information,
//  look at RegQueryValueEx for details.
BOOL FindNetscapeCookieFile( IN DWORD dwNSVer, OUT LPTSTR szFilename, /* in-out */ LPDWORD lpnBufSize)
{
    BOOL retVal = FALSE;

    //  for Version<MS_NAVI4
    HKEY hCookieKey, hUserRootKey, hProfileKey;

    //  for MS_NAVI4 >= Version < MS_NAVI5
    hCookieKey = (HKEY) INVALID_HANDLE_VALUE;
    hUserRootKey = (HKEY) INVALID_HANDLE_VALUE;
    hProfileKey = (HKEY) INVALID_HANDLE_VALUE;

    INET_ASSERT( dwNSVer != 0x0000);

    if( dwNSVer < NS_NAVI4)
    {
        if( REGOPENKEYEX( HKEY_CURRENT_USER, NS3_COOKIE_REG_PATH, 0, KEY_READ, &hCookieKey) != ERROR_SUCCESS)
        {
            hCookieKey = (HKEY) INVALID_HANDLE_VALUE;
            goto doneFindNetscapeCookieFile;
        }

        DWORD dwType;  //  should be REG_SZ when returned from QueryValue
        DWORD cbBufSize;
        cbBufSize = *lpnBufSize * sizeof(TCHAR);
        if( RegQueryValueEx( hCookieKey, NS3_COOKIE_REG_KEY, NULL,  &dwType, (LPBYTE)szFilename, &cbBufSize) != ERROR_SUCCESS
            || dwType != REG_SZ)
        {
            *lpnBufSize = cbBufSize / sizeof(TCHAR);
            goto doneFindNetscapeCookieFile;
        }
        *lpnBufSize = cbBufSize / sizeof(TCHAR);

        retVal = TRUE;
    }
    else if ( dwNSVer < NS_NAVI5)
    {
        if( REGOPENKEYEX( HKEY_LOCAL_MACHINE, NS4_USERS_REG_PATH, 0, KEY_READ, &hUserRootKey) != ERROR_SUCCESS)
        {
            hUserRootKey = (HKEY) INVALID_HANDLE_VALUE;
            goto doneFindNetscapeCookieFile;
        }

        DWORD dwNumberOfProfiles;
        if( RegQueryInfoKey( hUserRootKey, NULL, NULL, NULL, &dwNumberOfProfiles,
            NULL, NULL, NULL, NULL, NULL, NULL, NULL) != ERROR_SUCCESS
            || dwNumberOfProfiles != 1)
        {
            goto doneFindNetscapeCookieFile;
        }

        TCHAR szProfileName[MAX_PATH];
        DWORD nProfileNameBufferSize;
        nProfileNameBufferSize = sizeof(szProfileName);
        if( RegEnumKeyEx( hUserRootKey, 0, szProfileName, &nProfileNameBufferSize, NULL, NULL, NULL, NULL) != ERROR_SUCCESS)
        {
            goto doneFindNetscapeCookieFile;
        }

        if( REGOPENKEYEX( hUserRootKey, szProfileName, 0, KEY_READ, &hProfileKey) != ERROR_SUCCESS)
        {
            hProfileKey = (HKEY) INVALID_HANDLE_VALUE;
            goto doneFindNetscapeCookieFile;
        }

        DWORD dwType;  //  should be REG_SZ when returned from QueryValue
        DWORD cbBufSize;
        cbBufSize = *lpnBufSize * sizeof(TCHAR);
        if( RegQueryValueEx( hProfileKey, NS4_USERPATH_REG_KEY, NULL, &dwType, (LPBYTE)szFilename, &cbBufSize) != ERROR_SUCCESS
            || dwType != REG_SZ)
        {
            *lpnBufSize = (cbBufSize / sizeof(TCHAR) - 1) + LENGTHOFTSTR( NS_COOKIE_FILENAME);
            goto doneFindNetscapeCookieFile;
        }

        if( (*lpnBufSize - (cbBufSize / sizeof(TCHAR) - 1)) < LENGTHOFTSTR( NS_COOKIE_FILENAME))
        {
            *lpnBufSize = (cbBufSize / sizeof(TCHAR) - 1) + LENGTHOFTSTR( NS_COOKIE_FILENAME);
            goto doneFindNetscapeCookieFile;
        }

        *lpnBufSize = cbBufSize / sizeof(TCHAR) - 1;
        szFilename[(*lpnBufSize)++] = TCHAR('\\');
        memcpy( szFilename + *lpnBufSize, NS_COOKIE_FILENAME, sizeof(NS_COOKIE_FILENAME));
        *lpnBufSize += LENGTHOFTSTR( NS_COOKIE_FILENAME);

        retVal = TRUE;
    }

doneFindNetscapeCookieFile:

    if( hCookieKey != (HKEY) INVALID_HANDLE_VALUE )
        REGCLOSEKEY( hCookieKey);

    if( hUserRootKey != (HKEY) INVALID_HANDLE_VALUE)
        REGCLOSEKEY( hUserRootKey);

    if( hProfileKey != (HKEY) INVALID_HANDLE_VALUE)
        REGCLOSEKEY( hProfileKey);

    return retVal;
}


//--------------------------------------------------------------------
//
//  GetActiveNetscapeVersion
//

BOOL GetActiveNetscapeVersion( LPDWORD lpVersion)
{
    BOOL retVal = FALSE;

    TCHAR szFilename[MAX_PATH];
    DWORD cFilenameSize = MAX_PATH;
    BYTE* pVerBuffer = NULL;

    //  If the application currently associated with .htm files is NS,
    //thats the active version.  If it isn't, we grab the last installed
    //version of NS and say thats the active version.

    LPTSTR pFilenameSubstring;
    if( GetExecuteableFromExtension( HTML_FILE_EXTENSION, szFilename, &cFilenameSize, &pFilenameSubstring) == FALSE
        || StrCmpI( pFilenameSubstring, NS_EXE_FILENAME) != 0 )
    {
        goto doneGetActiveNetscapeVersion;
    }

    DWORD cbFileVersionBufSize;
    DWORD dwTemp;
    if( (cbFileVersionBufSize = GetFileVersionInfoSize( szFilename, &dwTemp)) == 0 )
        goto doneGetActiveNetscapeVersion;

    pVerBuffer = new BYTE[cbFileVersionBufSize];
    if( pVerBuffer == NULL)
        goto doneGetActiveNetscapeVersion;

    if( GetFileVersionInfo( szFilename, 0, cbFileVersionBufSize, pVerBuffer) == 0 )
        goto doneGetActiveNetscapeVersion;

    VS_FIXEDFILEINFO *lpVSFixedFileInfo;

    unsigned uiLength;
    if( VerQueryValue( pVerBuffer, TEXT("\\"),(LPVOID*)&lpVSFixedFileInfo, &uiLength) == 0
        || uiLength == 0)
        goto doneGetActiveNetscapeVersion;

    *lpVersion = lpVSFixedFileInfo->dwFileVersionMS;
    retVal = TRUE;

doneGetActiveNetscapeVersion:
    if( pVerBuffer != NULL)
        delete [] pVerBuffer;

    return retVal;
}


//--------------------------------------------------------------------
//
//  ImportCookieFile
//

//  Retrieves the executable file associated with the open command for
//a particular file extension.
//
//  Parsing the open command for the path\file can be ambiguous.
//If there is a '\' in a prefixed file argument of the open command
//the returned string will contain everying up to and including
//that argument
//
//example:
//""c:\program files\argy.exe \load file" -postfix"
//will give you
//"c:\program files\ argv.exe \load"
//
//typical case:
//""c:\program files\exec.exe -prearg" -postarg"
//will give you
//"c:\program files\exec.exe"
//
//pcFilenameSubstring will point one char past the last '\' to allow
//immediate checking of that last word.
//
BOOL GetExecuteableFromExtension(
    IN LPCTSTR szExtension,
    OUT LPTSTR szFilepath,
    /* in-out */ LPDWORD pcFilenameSize,
    OUT LPTSTR* ppFilenameSubstring)
{
    DWORD dwType;   // rewritten often, temporary values
    TCHAR szBuffer[MAX_PATH];   // reused as szCommandKeyPath and szOpenCommand
    DWORD cBufSize;

    BOOL retVal = FALSE;

    HKEY hHtmlEntry = (HKEY) INVALID_HANDLE_VALUE;
    HKEY hOpenCmd = (HKEY) INVALID_HANDLE_VALUE;

    if( REGOPENKEYEX( HKEY_CLASSES_ROOT, szExtension, 0, KEY_READ, &hHtmlEntry) != ERROR_SUCCESS)
    {
        hHtmlEntry = (HKEY) INVALID_HANDLE_VALUE;
        goto doneGetExecuteableFromExtension;
    }

    // to build a registry key in szCommandKeyPath, we first retrieve
    // the filetype (e.g. htmlfile) and then attach the registry path
    // for the 'open' command in HKEY_CLASSES_ROOT

    LPTSTR szCommandKeyPath;
    szCommandKeyPath = szBuffer;

    //  retrieve filetype
    cBufSize = MAX_PATH * sizeof(TCHAR);
    if( RegQueryValueEx( hHtmlEntry, NULL, NULL, &dwType, (BYTE*)szCommandKeyPath, &cBufSize) != ERROR_SUCCESS
        || dwType != REG_SZ )
    {
        goto doneGetExecuteableFromExtension;
    }

    //  append path ('htmlfile' -> 'htmlfile\\shell\\open\\command')
    StrCatBuff(szCommandKeyPath, OPEN_COMMAND_OF_APP, MAX_PATH);

    //  get the open command from the registry
    if( REGOPENKEYEX( HKEY_CLASSES_ROOT, szCommandKeyPath, 0, KEY_READ, &hOpenCmd) != ERROR_SUCCESS)
    {
        hOpenCmd = (HKEY) INVALID_HANDLE_VALUE;
        goto doneGetExecuteableFromExtension;
    }

    LPTSTR szOpenCommand;
    szOpenCommand = szBuffer;
    cBufSize = MAX_PATH * sizeof(TCHAR);
    if( RegQueryValueEx( hOpenCmd, "", NULL, &dwType, (BYTE*)szOpenCommand, &cBufSize) != ERROR_SUCCESS
        || dwType != REG_SZ)
    {
        goto doneGetExecuteableFromExtension;
    }

    // we now have a command line entry with the netscape filename.
    // typical format:  ""path\filename -prefixed args" -postfixed arguments"

    LPTSTR pSubstring;
    LPTSTR pRightmostWhack;
    // Now, too build a return value, point to the path\filename within the
    // command line entry and null-terminate it.
    pSubstring = szOpenCommand;
    while( *pSubstring == TCHAR('\"') || *pSubstring == TCHAR(' '))
    {
        // move beginning past any prefixed quotes or spaces
        pSubstring++;
    }

    pRightmostWhack = StrRChr(pSubstring, NULL, TCHAR('\\'));

    if (!pRightmostWhack)
    {
        // couldn't find a "\" so just set it equal to the substring
        pRightmostWhack = pSubstring;
    }
    else
    {
        // move to the the beginning of the last token (a filename, we assume)
        pRightmostWhack++;
    }

    // save the location of the filename
    *ppFilenameSubstring = pRightmostWhack;

    // move right end past the last token
    while(*pRightmostWhack != TCHAR('\"')    &&
          *pRightmostWhack != TCHAR(' ')     &&
          *pRightmostWhack != TCHAR('\0'))
    {
        pRightmostWhack++;
    }

    // null terminate the substring
    *pRightmostWhack = TCHAR('\0');

    // strictly > since lstrlen dosen't count space for NULL terminator
    if(*pcFilenameSize > (DWORD)lstrlen(pSubstring))
    {
        lstrcpyn(szFilepath, pSubstring, *pcFilenameSize);
        retVal = TRUE;
    }

    *pcFilenameSize = lstrlen(pSubstring);

doneGetExecuteableFromExtension:
    if( hHtmlEntry != (HKEY) INVALID_HANDLE_VALUE)
    {
        REGCLOSEKEY( hHtmlEntry);
    }

    if( hOpenCmd != (HKEY) INVALID_HANDLE_VALUE)
    {
        REGCLOSEKEY( hOpenCmd);
    }

    return retVal;
}






//***********************************************************************************
//    registry functions to store which version of Netscape is to be imported from


//--------------------------------------------------------------------
//
//  SetNetscapeImportVersion
//

//  Store version of Netscape to import cookies from in the registry
BOOL SetNetscapeImportVersion( IN DWORD dwNSVersion)
{
    BOOL retVal = FALSE;

    HKEY hNSVersionKey = (HKEY) INVALID_HANDLE_VALUE;

    DWORD dwDisposition;  // ignored output parameter
    if( REGCREATEKEYEX( HKEY_LOCAL_MACHINE, NS_COOKIE_IMPORT_KEY, 0, TEXT("REG_SZ"),
                        REG_OPTION_NON_VOLATILE, KEY_WRITE, NULL, &hNSVersionKey, &dwDisposition) != ERROR_SUCCESS)
    {
        hNSVersionKey = (HKEY) INVALID_HANDLE_VALUE;
        goto doneSetNetscapeImportVersion;
    }

    if( RegSetValueEx( hNSVersionKey, NS_COOKIE_IMPORT_VERSION, 0, REG_DWORD, (BYTE*)&dwNSVersion, sizeof(DWORD)) != ERROR_SUCCESS )
        goto doneSetNetscapeImportVersion;

    retVal = TRUE;

doneSetNetscapeImportVersion:
    if( hNSVersionKey != (HKEY) INVALID_HANDLE_VALUE )
        REGCLOSEKEY( hNSVersionKey);

    return retVal;
}


//--------------------------------------------------------------------
//
//  GetNetscapeImportVersion
//

//  Retrieves version of Netscape to import coookies from in the registry
BOOL GetNetscapeImportVersion( OUT DWORD* pNSVersion)
{
    BOOL retVal = FALSE;

    HKEY hNSVersionKey = (HKEY) INVALID_HANDLE_VALUE;

    TCHAR szNSFilename[MAX_PATH];
    DWORD cNSFilenameSize = MAX_PATH;

    if( REGOPENKEYEX( HKEY_LOCAL_MACHINE, NS_COOKIE_IMPORT_KEY, 0, KEY_READ, &hNSVersionKey) != ERROR_SUCCESS)
    {
        hNSVersionKey = (HKEY) INVALID_HANDLE_VALUE;
        goto doneGetNetscapeImportVersion;
    }

    DWORD dwType;
    DWORD dwBufSize;
    dwBufSize = sizeof(DWORD);
    if( RegQueryValueEx( hNSVersionKey, NS_COOKIE_IMPORT_VERSION, 0, &dwType, (BYTE*)pNSVersion, &dwBufSize) != ERROR_SUCCESS
        || dwType != REG_DWORD)
    {
        goto doneGetNetscapeImportVersion;
    }

    //  if the "DisableImport" key has been set to a non-FALSE value,
    //fail to find a version to import from.
    DWORD fDontImport;
    if( (RegQueryValueEx( hNSVersionKey, NS_COOKIE_IMPORT_FLAG, 0, &dwType,
                        (BYTE*)&fDontImport, &(dwBufSize = sizeof(fDontImport)))
           == ERROR_SUCCESS)
        && dwType == REG_DWORD
        && fDontImport != FALSE)
    {
        goto doneGetNetscapeImportVersion;
    }

    retVal = TRUE;

doneGetNetscapeImportVersion:
    if( hNSVersionKey != (HKEY) INVALID_HANDLE_VALUE )
        REGCLOSEKEY( hNSVersionKey);

    return retVal;

}


//***************************************************************************
//  utility functions internal to cookimp.cxx


//  indicates if a character is an endofline character in a Netscape cookie file.
bool EndOfLine( CHAR chr )
{
    return chr == '\n' || chr == '\r';
}


//--------------------------------------------------------------------
//
//  InternetTimeFromTime_tA
//

//  InternetTimeFromTime_T takes a time value formatted to the run-time library's time_t
//and gives a formatted time string formatted to the RFC format in HTTP spec 1.0
//
//  dwTime is the number of seconds since Jan 1, 1970 00:00:00.
BOOL InternetTimeFromTime_tA( IN DWORD dwTime, OUT LPSTR lpszTime, DWORD cbBufferSize )
{
    if( cbBufferSize < INTERNET_RFC1123_BUFSIZE )
        return false;

//    FILETIME ft2;
//    DosTime2FileTime( dwTime, &ft2);

    //  First create a FILETIME value, to convert to SYSTEMTIME.

    //  i19700Offset is the FILETIME offset of Jan 1, 1970 at 00:00:00...
    const DWORDLONG dwl1970Offset = 0x019dae9064bafa80;

    DWORDLONG dwlTime = dwl1970Offset + (DWORDLONG)dwTime * (DWORDLONG)10000000;
    FILETIME ft;
    ft.dwLowDateTime  = (DWORD)( dwlTime & 0x00000000FFFFFFFF);
    ft.dwHighDateTime = (DWORD)Int64ShrlMod32( Int64ShrlMod32( dwlTime & 0xFFFFFFFF00000000, 16), 16 );

    //  Second I convert the FILETIME to a SYSTEMTIME   
    SYSTEMTIME st;

    if( FileTimeToSystemTime( &ft, &st ) == 0)
        return FALSE;

#ifdef UNICODE
#error "InternetTimeFromTime_tA(): InternetTimeFromSystemTimeA needs to be called directly from here."
#endif
    //  Finally I use SYSTEMTIME to produce the formatted string.
    return InternetTimeFromSystemTime( &st, INTERNET_RFC1123_FORMAT, lpszTime, cbBufferSize );
}


//--------------------------------------------------------------------
//
//  ReadFileToBuffer
//

//  opens a file and spits it out to memory.
//  if *ppBuf originally points to NULL, memory is allocated for the file
//      and cbBufSize contains the number of bytes allocated.
//      (use delete [] *ppBuf when done)
//  if *ppBuf is not NULL, it is assumed to point to a target buffer of
//      size *lpcbBufSize, and size used is then recorded in *lpcbBufSize.
//  returns TRUE if successful.
//  on FALSE return, *lpcbBufSize contains the size needed to be allocated
//      or 0xFFFFFFFF on total failure
BOOL ReadFileToBuffer( IN LPCTSTR szFilename, LPBYTE* ppBuf, LPDWORD lpcbBufSize)
{
    BOOL retVal = FALSE;

    HANDLE hFile = INVALID_HANDLE_VALUE;

    hFile = CreateFile( szFilename, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, NULL, NULL);

    if( hFile == INVALID_HANDLE_VALUE )
    {
        //  notify failure and exit
        *lpcbBufSize = 0xFFFFFFFF;
        goto doneReadFileToBuffer;
    }

    DWORD dwHighOrderedBitsOfFileSize;
    DWORD cbFileSize;
    cbFileSize = GetFileSize( hFile, &dwHighOrderedBitsOfFileSize );
    if(  cbFileSize == 0xFFFFFFFF || dwHighOrderedBitsOfFileSize != 0 )
    {
        //  notify file was too big and exit
        *lpcbBufSize = 0xFFFFFFFF;
        goto doneReadFileToBuffer;
    }

    if( *ppBuf != NULL )
    {
        //  verify passed buffer is large enough
        if( *lpcbBufSize < cbFileSize)
        {
            //  set needed filesize and exit
            *lpcbBufSize = cbFileSize;
            goto doneReadFileToBuffer;
        }
    }
    else
    {
        *ppBuf = new BYTE[cbFileSize];

        if( *ppBuf == NULL)
        {
            //  notify failure and exit
            *lpcbBufSize = 0xFFFFFFFF;
            goto doneReadFileToBuffer;
        }
    }

    //  set output result
    *lpcbBufSize = cbFileSize;

    DWORD cbRead;
    if( ReadFile( hFile, *ppBuf, cbFileSize, &cbRead, NULL) != TRUE
        || cbRead != cbFileSize)
    {
        //  notify failure and exit
        *lpcbBufSize = 0xFFFFFFFF;
        goto doneReadFileToBuffer;
    }

    CloseHandle( hFile );
    hFile = INVALID_HANDLE_VALUE;

    retVal = TRUE;

doneReadFileToBuffer:

    if( hFile != INVALID_HANDLE_VALUE)
        CloseHandle( hFile);

    return retVal;
}