/**
 * Asynchronous pluggable protocol for Applications
 *
 * Copyright (C) Microsoft Corporation, 2000
 */

/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////

#include "precomp.h"
#include "app.h"

#include <stdio.h> // for _snprintf

char * stristr(char *pszMain, char *pszSub)
{
    char * pszCur = pszMain;
    char ch = (char) tolower(*pszSub);
    int cb = strlen(pszSub) - 1; // -1 to ignore leading character

    for (;;) {
        while (tolower(*pszCur) != ch && *pszCur)
            pszCur++;

        if (!*pszCur)
            return NULL;

        if (_strnicmp(pszCur + 1, pszSub + 1, cb) == 0)
            return pszCur;

        pszCur++;
    }
}

/**
 * Return last Win32 error as an HRESULT.
 */
HRESULT
GetLastWin32Error()
{
    // Win 95 can return 0, even when there's an error.
    DWORD dw = GetLastError();
    return dw ? HRESULT_FROM_WIN32(dw) : E_FAIL;
}

HRESULT
RunCommand(WCHAR *cmdLine)
{
    HRESULT hr = S_OK;
    STARTUPINFO si;
    PROCESS_INFORMATION pi;

    ZeroMemory(&si, sizeof(si));
    ZeroMemory(&pi, sizeof(pi));

    si.cb = sizeof(si);
    
    if(!CreateProcess(NULL, cmdLine, NULL, NULL, TRUE, 0, NULL, NULL, &si, &pi))
    {
        hr = GetLastWin32Error();
        goto exit;
    }

    if(WaitForSingleObject(pi.hProcess, 180000L) == WAIT_TIMEOUT)
    {
        hr = HRESULT_FROM_WIN32(ERROR_TIMEOUT);
        goto exit;
    }

exit:
    if(pi.hProcess) CloseHandle(pi.hProcess);
    if(pi.hThread) CloseHandle(pi.hThread);

    return hr;
}

#define ToHex(val) val <= 9 ? val + '0': val - 10 + 'A'
DWORD ConvertToHex(WCHAR* strForm, BYTE* byteForm, DWORD dwSize)
{
    DWORD i = 0;
    DWORD j = 0;
    for(i = 0; i < dwSize; i++) {
        strForm[j++] =  ToHex((0xf & byteForm[i]));
        strForm[j++] =  ToHex((0xf & (byteForm[i] >> 4)));
    }
    strForm[j] = L'\0';
    return j;
}

/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////

// {B8BF3C7E-4DB6-4fdb-9CD3-13D2CE728CA8}, by guidgen VS7
CLSID   CLSID_AppProtocol = { 0xb8bf3c7e,
                              0x4db6, 0x4fdb,
                              { 0x9c, 0xd3, 0x13, 0xd2, 0xce, 0x72, 0x8c, 0xa8 } };


BOOL                        g_fStarted              = FALSE;
AppProtocolFactory          g_AppProtocolFactory;
IInternetSecurityManager*   g_pSecurityMgr          = NULL;

/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
// Class AppProtocol ctor

AppProtocol::AppProtocol(IUnknown *  pUnkOuter)
    : m_refs                   (1),
      m_pProtocolSink          (NULL),
//      m_cookie                 (NULL),   
      m_fullUri             (NULL),
      m_uriPath                (NULL),
      m_queryString            (NULL),
      m_appOrigin              (NULL),
      m_appRoot                (NULL),
      m_appRootTranslated      (NULL),
      m_extraHeaders           (NULL),
      m_inputDataSize          (0),
      m_inputData              (NULL),
      m_pInputRead             (NULL),
      m_pOutputRead            (NULL),
      m_pOutputWrite           (NULL),
      m_started                (FALSE),
      m_aborted                (FALSE),
      m_done                   (FALSE),
      m_responseMimeType       (NULL),
      m_cbOutput               (0),
      m_extraHeadersUpr        (NULL),
      m_strResponseHeader      (NULL),
      m_postedMimeType         (NULL),
      m_verb                   (NULL),
      m_localStoreFilePath     (NULL),
      m_appType                (APPTYPE_IE),
      m_status                 (STATUS_CLEAR)
{
    m_pUnkOuter = (pUnkOuter ? pUnkOuter : (IUnknown *)(IPrivateUnknown *)this);
    InitializeCriticalSection(&m_csOutputWriter);
}

/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////

void
AppProtocol::Cleanup()
{
    ClearInterface(&m_pOutputRead);
    ClearInterface(&m_pOutputWrite);
    ClearInterface(&m_pProtocolSink);
    ClearInterface(&m_pInputRead);

    m_appType = APPTYPE_IE;
    m_status = STATUS_CLEAR;
    m_done = TRUE;
    m_aborted = FALSE; //???

    if (m_bindinfo.cbSize)
    {
        ReleaseBindInfo(&m_bindinfo);
        ZeroMemory(&m_bindinfo, sizeof(m_bindinfo));
    }
}

/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////

void
AppProtocol::FreeStrings()
{
    MemClearFn((void **)&m_fullUri);
    m_uriPath = NULL;
    m_queryString = NULL;

    MemClearFn((void **)&m_appOrigin) ;
    m_appRoot = NULL;

    MemClearFn((void **)&m_appRootTranslated);

    if(m_extraHeaders)
    {
        CoTaskMemFree(m_extraHeaders);
        m_extraHeaders = NULL;
    }

//    MemClearFn((void **)&m_cookie);
    MemClearFn((void **)&m_extraHeadersUpr);
    MemClearFn((void **)&m_strResponseHeader);
    MemClearFn((void **)&m_verb);
    MemClearFn((void **)&m_postedMimeType);
    MemClearFn((void **)&m_responseMimeType);
    MemClearFn((void **)&m_localStoreFilePath);
}

/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////

AppProtocol::~AppProtocol()
{
    FreeStrings();

    Cleanup();

    DeleteCriticalSection(&m_csOutputWriter);

    if (g_pSecurityMgr != NULL)
    {
        g_pSecurityMgr->Release();
        g_pSecurityMgr = NULL;
    }
}

/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
// Private QI

ULONG
AppProtocol::PrivateAddRef()
{
    return ++m_refs;
}

ULONG
AppProtocol::PrivateRelease()
{
    if (--m_refs > 0)
        return m_refs;

    delete this;
    return 0;
}

HRESULT
AppProtocol::PrivateQueryInterface(
        REFIID      iid, 
        void**      ppv)
{
    *ppv = NULL;

    if (iid == IID_IInternetProtocol ||
        iid == IID_IInternetProtocolRoot)
    {
        *ppv = (IInternetProtocol *)this;
    }
    else if (iid == IID_IUnknown)
    {
        *ppv = (IUnknown *)(IPrivateUnknown *)this;
    }
    else if (iid == IID_IWinInetHttpInfo)
    {
        *ppv = (IWinInetHttpInfo *)this;
    }
    else
    {
        return E_NOINTERFACE;
    }

    ((IUnknown *)*ppv)->AddRef();
    return S_OK;
}

/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
// Public (delegated) QI

ULONG
AppProtocol::AddRef()
{
    m_pUnkOuter->AddRef();
    return PrivateAddRef();
}

ULONG
AppProtocol::Release()
{
    m_pUnkOuter->Release();
    return PrivateRelease();
}

HRESULT
AppProtocol::QueryInterface(
        REFIID    iid, 
        void **   ppv)
{
    return m_pUnkOuter->QueryInterface(iid, ppv);
}

/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////

HRESULT
AppProtocol::Start(
        LPCWSTR                   url,
        IInternetProtocolSink *   pProtocolSink,
        IInternetBindInfo *       pBindInfo,
        DWORD                     grfSTI,
        DWORD                           )
{
    HRESULT             hr                = S_OK;
    WCHAR *             Strings[]         = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
    DWORD               cStrings          = sizeof(Strings) / sizeof(Strings[0]);
//    DWORD               cookieSize        = 0;
    IServiceProvider *  pServiceProvider  = NULL;
    IHttpNegotiate *    pHttpNegotiate    = NULL;

    FreeStrings();

    ReplaceInterface(&m_pProtocolSink, pProtocolSink);

    // ?????
    if (grfSTI & PI_PARSE_URL)
        goto exit;

    if (pProtocolSink == NULL)
    {
        hr = E_INVALIDARG;
        goto exit;
    }

    // get bindinfo
    m_bindinfo.cbSize = sizeof(BINDINFO);
    if (pBindInfo != NULL)
    {
        if (FAILED(hr = pBindInfo->GetBindInfo(&m_bindf, &m_bindinfo)))
           goto exit;
    }

    if (m_bindinfo.dwCodePage == 0)
        m_bindinfo.dwCodePage = CP_ACP;

    // extract root, uri path and query string from url
    if (FAILED(hr = ParseUrl(url)))
       goto exit;

    // get to headers in MSHtml
    if (FAILED(hr = pBindInfo->QueryInterface(IID_IServiceProvider, (void **) &pServiceProvider)))
       goto exit;
    if(pServiceProvider != NULL)
    {
        if (FAILED(hr = pServiceProvider->QueryService(IID_IHttpNegotiate, IID_IHttpNegotiate, (void **) &pHttpNegotiate)))
           goto exit;
        if(pHttpNegotiate != NULL)
        {
            hr = pHttpNegotiate->BeginningTransaction(url, NULL, 0, &m_extraHeaders);
            pHttpNegotiate->Release();
            pHttpNegotiate = NULL;
            if (FAILED(hr))
                goto exit;
        }
        pServiceProvider->Release();
        pServiceProvider = NULL;
    }

    // determine verb
    switch (m_bindinfo.dwBindVerb)
    {
    case BINDVERB_GET:  
        m_verb = DuplicateString(L"GET");
        break;

    case BINDVERB_POST: 
        m_verb = DuplicateString(L"POST");
        break;

    case BINDVERB_PUT: 
        m_verb = DuplicateString(L"PUT");
        break;

    default:
        if (m_bindinfo.szCustomVerb != NULL && m_bindinfo.dwBindVerb == BINDVERB_CUSTOM)
        {
            m_verb = DuplicateString(m_bindinfo.szCustomVerb); 
        }
        else
        {
            m_verb = DuplicateString(L"GET");
        }
        break;
    }

    // get mime type of posted data from binding
    hr = pBindInfo->GetBindString(BINDSTRING_POST_DATA_MIME, Strings, cStrings, &cStrings);
    if(hr == S_OK && cStrings)
    {
        DWORD i;

        m_postedMimeType = DuplicateString(Strings[0]);
        if (m_postedMimeType == NULL)
        {
            hr = E_OUTOFMEMORY;
            goto exit;
        }

        for(i = 0; i < cStrings; i++)
            CoTaskMemFree(Strings[i]);
    }

    // don't fail if we failed to get bind string, 
    hr = S_OK;

    // retrieve cookie
/*    cookieSize = 0;
    if(g_pInternetGetCookieW(m_fullUri, NULL, NULL, &cookieSize) && cookieSize)
    {
        m_cookie = (WCHAR *)MemAlloc(cookieSize + sizeof(WCHAR));
        if (m_cookie == NULL)
        {
            hr = E_OUTOFMEMORY;
            goto exit;
        }

        g_pInternetGetCookieW(m_fullUri, NULL, m_cookie, &cookieSize);
    }
*/

    // Input data
    if (m_bindinfo.stgmedData.tymed == TYMED_HGLOBAL)
    {
        m_inputDataSize = m_bindinfo.cbstgmedData;
        m_inputData = (BYTE *)m_bindinfo.stgmedData.hGlobal;
    }
    else if (m_bindinfo.stgmedData.tymed == TYMED_ISTREAM)
    {
        STATSTG statstg;

        ReplaceInterface(&m_pInputRead, m_bindinfo.stgmedData.pstm);

        if(m_pInputRead) 
        {
            hr = m_pInputRead->Stat(&statstg, STATFLAG_NONAME);
            if(hr == S_OK)
                m_inputDataSize = statstg.cbSize.LowPart;
            else
                m_inputDataSize = (DWORD)-1;
        }

    }

    if (FAILED(hr = CreateStreamOnHGlobal(NULL, TRUE, &m_pOutputWrite)))
        goto exit;

    if (FAILED(hr = m_pOutputWrite->Clone(&m_pOutputRead)))
        goto exit;

    PROTOCOLDATA        protData;
    protData.dwState = 1;
    protData.grfFlags = PI_FORCE_ASYNC;
    protData.pData = NULL;
    protData.cbData = 0;

    pProtocolSink->Switch(&protData);
//***    hr = E_PENDING;

exit:
    if (pHttpNegotiate)
    {
        pHttpNegotiate->Release();
        pHttpNegotiate = NULL;
    }

    if (pServiceProvider)
    {
        pServiceProvider->Release();
        pServiceProvider = NULL;
    }

    return hr;
}

/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////

HRESULT
AppProtocol::Continue(
        PROTOCOLDATA *  pProtData)
{
    HRESULT   hr                       = S_OK;
//    CHAR      appDomainPath[MAX_PATH]  = "";
    WCHAR     appRootTranslated[MAX_PATH];

    if(pProtData->dwState != 1)
    {
        hr = E_FAIL;
        goto exit;
    }

    // step 1: "install" the specified file
    appRootTranslated[0] = L'\0';

    hr = SetupAndInstall(m_fullUri, appRootTranslated);
    if (FAILED(hr))
        goto exit;

    if (m_localStoreFilePath == NULL)
    {
        hr = E_FAIL;
        goto exit;
    }

    m_appRootTranslated = DuplicateString(appRootTranslated);
    if (m_appRootTranslated == NULL)
    {
        hr = E_OUTOFMEMORY;
        goto exit;
    }
    
    // step 2: check error status
    if ((m_status & STATUS_OFFLINE_MODE) && (m_status & STATUS_NOT_IN_CACHE))
    {
        char buffer[100 + MAX_PATH];
        
        SendHeaders(HTTP_RESPONSEOK);

        _snprintf(buffer, 100+MAX_PATH, "Error: In offline mode and file not found in application store.\r\nLocal path expected- %ws", m_localStoreFilePath);
        
        WriteBytes((BYTE*) buffer, lstrlenA(buffer)+1);
        hr = Finish();

        goto exit;
    }

    // step 3: process different file types
    if (m_appType == APPTYPE_BYMANIFEST)
    {
        char buffer[512 + MAX_PATH];

        SendHeaders(HTTP_RESPONSEOK);

        // ???? ignore if excess buffer len
        // do this before as m_localStoreFilePath might be overwritten
        _snprintf(buffer, 512 + MAX_PATH, "Application installed and executed with manifest file - %ws\r\nSource - %ws", m_localStoreFilePath, m_fullUri);

        if (FAILED(hr = ProcessAppManifest()))
            goto exit;

        WriteBytes((BYTE *) buffer, lstrlenA(buffer)+1); //???? includes last '\0'
        hr = Finish();
    }
    else if (m_appType == APPTYPE_ASM)
    {
        char buffer[512 + MAX_PATH];
        
        SendHeaders(HTTP_RESPONSEOK);

        // ???? ignore if excess buffer len
        _snprintf(buffer, 512+MAX_PATH, "Assembly Executed - %ws\r\nSource - %ws", m_localStoreFilePath, m_fullUri);

        WriteBytes((BYTE*) buffer, lstrlenA(buffer)+1); //???? includes last '\0'
        hr = Finish();
    }
    else if (m_appType == APPTYPE_IE)
    {
        DWORD dwLength;
        BYTE buffer[512];
        char header[60];
        HANDLE hFile;
        int len;
        WCHAR* p;

        // set mime type
        // assume lower cases
        len = lstrlen(m_localStoreFilePath);
        p = m_localStoreFilePath + len - 5;
        if ((p[1] == L'.' && p[2] == L'h' && p[3] == L't' && p[4] == L'm')
             || (p[0] == L'.' && p[1] == L'h' && p[2] == L't' && p[3] == L'm' && p[4] == L'l')) //L".htm" ".html"
            sprintf(header, "%s\r\nContent-Type: text/html\r\n", HTTP_RESPONSEOK);
        else if (p[1] == L'.' && p[2] == L'g' && p[3] == L'i' && p[4] == L'f') //L".gif"
            sprintf(header, "%s\r\nContent-Type: image/gif\r\n", HTTP_RESPONSEOK);
        else if ((p[1] == L'.' && p[2] == L'j' && p[3] == L'p' && p[4] == L'g')
                 || (p[0] == L'.' && p[1] == L'j' && p[2] == L'p' && p[3] == L'e' && p[4] == L'g')) //L".jpg" ".jpeg"
            sprintf(header, "%s\r\nContent-Type: image/jpeg\r\n", HTTP_RESPONSEOK);
        else
            sprintf(header, "%s", HTTP_RESPONSEOK);

        SendHeaders(header);

        hFile = CreateFile(m_localStoreFilePath, GENERIC_READ, 0, NULL, 
                       OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);

        if(hFile == INVALID_HANDLE_VALUE)
        {
            hr = GetLastWin32Error();
            goto exit;
        }

        ZeroMemory(buffer, sizeof(buffer));

        while ( ReadFile (hFile, buffer, 512, &dwLength, NULL) && dwLength )
        {
                WriteBytes(buffer, dwLength);
        }
        if (hFile != INVALID_HANDLE_VALUE)
            CloseHandle(hFile);

        hr = Finish();
    }

exit:
    return hr;
}

/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////

HRESULT 
AppProtocol::Finish()
{
    HRESULT hr = S_OK;

    if (m_done == FALSE)
    {
        m_done = TRUE;

        m_pProtocolSink->ReportData(BSCF_LASTDATANOTIFICATION | BSCF_DATAFULLYAVAILABLE, 0, m_cbOutput);

        if (m_aborted == FALSE)
            m_pProtocolSink->ReportResult(S_OK, 0, NULL);
    }
    return hr;
}

/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////

HRESULT
AppProtocol::Abort(
        HRESULT hrReason,
        DWORD           )
{
    HRESULT hr = S_OK;

    m_aborted = TRUE;
    if (m_pProtocolSink != NULL)
    {
        hr = m_pProtocolSink->ReportResult(hrReason, 0, 0);
    if (FAILED(hr))
        goto exit;
    }

exit:
    return hr;
}

/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////

HRESULT
AppProtocol::Terminate(
        DWORD )
{
    Cleanup();
    return S_OK;
}

HRESULT
AppProtocol::Suspend()
{
    return E_NOTIMPL;
}

HRESULT
AppProtocol::Resume()
{
    return E_NOTIMPL;
}

HRESULT
AppProtocol::Read(
        void *pv, 
        ULONG cb, 
        ULONG *pcbRead)
{
    HRESULT hr;

    hr = m_pOutputRead->Read(pv, cb, pcbRead);

    // We must only return S_FALSE when we have hit the absolute end of the stream
    // If we think there is more data coming down the wire, then we return E_PENDING
    // here. Even if we return S_OK and no data, UrlMON will still think we've hit
    // the end of the stream.

//    if (S_OK == hr && 0 == *pcbRead)
//****
    if (S_OK == hr && (0 == *pcbRead || cb > *pcbRead))
    {
        hr = m_done ? S_FALSE : E_PENDING;
    }

    return hr;
}

/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////

HRESULT
AppProtocol::Seek(
        LARGE_INTEGER offset, 
        DWORD origin, 
        ULARGE_INTEGER *pPos)
{
    return m_pOutputRead->Seek(offset, origin, pPos);
}


HRESULT
AppProtocol::LockRequest(
        DWORD )
{
    return S_OK;
}

HRESULT
AppProtocol::UnlockRequest()
{
    return S_OK;
}

/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////

HRESULT
AppProtocol::SendHeaders(
        LPSTR headers)
{
    HRESULT    hr       = S_OK;
//    DWORD      flags    = 0;
    DWORD      dwLength = 0;
    LPSTR      mime     = NULL;
    LPSTR      tail     = NULL;
    int        iHLen    = 0;

    if(headers == NULL)
    {
        hr = E_UNEXPECTED;
        goto exit;
    }

    if (m_strResponseHeader != NULL)
        MemFree(m_strResponseHeader);
    iHLen = strlen(headers);
    m_strResponseHeader = (WCHAR *) MemAllocClear(iHLen*sizeof(WCHAR) + 512);
    if (m_strResponseHeader != NULL)
    {
        wcscpy(m_strResponseHeader, L"Server: Microsoft.Net-App/1.0\r\nDate:"); // Microsoft-IIS/App 1.0
        WCHAR szTemp[100];
        szTemp[0] = NULL;
        GetDateFormat(LOCALE_USER_DEFAULT, DATE_LONGDATE, NULL, NULL, szTemp, 100); 
        wcscat(m_strResponseHeader, szTemp);
        wcscat(m_strResponseHeader, L" ");

        GetTimeFormat(LOCALE_USER_DEFAULT, 0, NULL, NULL, szTemp, 100); 
        wcscat(m_strResponseHeader, szTemp);
        wcscat(m_strResponseHeader, L"\r\n");
        int iLen = wcslen(m_strResponseHeader);
        MultiByteToWideChar(CP_ACP, 0, headers, -1, &m_strResponseHeader[iLen], iHLen + 256 - iLen - 1);
    }

    mime = stristr(headers, "Content-Type:");
    if(mime)
    {
        mime += 13;
        while(*mime && isspace(*mime))
            mime++;
        tail = mime;

        while(*tail && *tail != '\r')
            tail++;

        dwLength = tail - mime;
        if(dwLength)
        {
            if (m_responseMimeType)
                MemFree(m_responseMimeType);

            m_responseMimeType = (WCHAR *) MemAlloc((dwLength + 1) * sizeof(WCHAR));
            if (m_responseMimeType == NULL)
            {
                hr = E_OUTOFMEMORY;
                goto exit;
            }

            MultiByteToWideChar(CP_ACP, 0, mime, dwLength, m_responseMimeType, dwLength);
            m_responseMimeType[dwLength] = L'\0';
        }
    }

    if (m_responseMimeType && *m_responseMimeType)
        m_pProtocolSink->ReportProgress(BINDSTATUS_VERIFIEDMIMETYPEAVAILABLE, m_responseMimeType);
    else
        m_pProtocolSink->ReportProgress(BINDSTATUS_MIMETYPEAVAILABLE, L"text/plain"); //proper default not L"text/html");

//****    SaveCookie(headers);

exit:
    return hr;
}

/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////

/*HRESULT 
AppProtocol::SaveCookie(
	LPSTR header)
{
    HRESULT hr = S_OK;
    LPSTR cookie, tail;
    WCHAR *cookieBody = NULL;
    int bodyLength;

    for(cookie = stristr(header, "Set-Cookie:");
        cookie != NULL;
        cookie = (*tail ? stristr(tail, "Set-Cookie:") : NULL)) //???? added () around ? :
    {
        cookie += 11;
        while(*cookie && isspace(*cookie))
            cookie++;
        tail = cookie;
        while(*tail && *tail != '\r')
            tail++;
        bodyLength = tail - cookie;

        if(bodyLength)
        {
            cookieBody = (WCHAR *)MemAlloc(sizeof(WCHAR) *(bodyLength + 1));
            if (cookieBody == NULL)
            {
                hr = E_OUTOFMEMORY;
                goto exit;
            }
                
            MultiByteToWideChar(CP_ACP, 0, cookie, bodyLength, cookieBody, bodyLength);
            cookieBody[bodyLength] = '\0';

            if(!g_pInternetSetCookieW(m_cookiePath, NULL, cookieBody))
            {
                hr = GetLastWin32Error();
                goto exit;
            }
        }
    }
exit:
    if (cookieBody)
        MemFree(cookieBody);

    return hr;
}*/

/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////

HRESULT
AppProtocol::WriteBytes(
        BYTE *  buffer, 
        DWORD   dwLength)
{
    HRESULT hr = S_OK;
    DWORD flags = 0;

    EnterCriticalSection(&m_csOutputWriter);

    if (!m_pOutputWrite)
    {
        hr = E_UNEXPECTED;
    }

    if (FAILED(hr = m_pOutputWrite->Write(buffer, dwLength, &dwLength)))
        goto exit;

    m_cbOutput += dwLength;

    if (!m_started)
    {
        m_started = TRUE;
        flags |= BSCF_FIRSTDATANOTIFICATION;
    }
    else //****

    if (m_done)
    {
        flags |= BSCF_LASTDATANOTIFICATION | BSCF_DATAFULLYAVAILABLE;
    }

    else //****
        flags |= BSCF_INTERMEDIATEDATANOTIFICATION;

    if (FAILED(hr = m_pProtocolSink->ReportData(flags, dwLength, m_cbOutput)))
        goto exit;

exit:
    LeaveCriticalSection(&m_csOutputWriter);
    return hr;
}

/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////

/*int
AppProtocol::GetKnownRequestHeader (
        LPCWSTR  szHeader,
        LPWSTR   buf,
        int      size)
{
    if (szHeader == NULL || szHeader[0] == NULL || wcslen(szHeader) > 256)
        return 0;

    LPCWSTR  szReturn        = NULL;
    LPCWSTR  szStart         = NULL;
    int      iLen            = 0;
    HRESULT  hr              = S_OK;
//    int      iter            = 0;
    WCHAR    szHeadUpr[260]  = L"";

    wcscpy(szHeadUpr, szHeader);
    _wcsupr(szHeadUpr);

    if (wcscmp(szHeadUpr, SZ_HTTP_COOKIE) == 0)
    {
        szReturn = m_cookie;
        iLen = (m_cookie ? wcslen(m_cookie) : 0);
        goto exit;
    }

    if (m_extraHeadersUpr == NULL && m_extraHeaders != NULL)
    {
        m_extraHeadersUpr = DuplicateString(m_extraHeaders);
        if (m_extraHeadersUpr == NULL)
        {
            hr = E_OUTOFMEMORY;
            goto exit;
        }

        _wcsupr(m_extraHeadersUpr);
    }

    if (m_extraHeadersUpr == NULL)
        goto exit;
        
    szStart = wcsstr(m_extraHeadersUpr, szHeadUpr);
    if (szStart == NULL)
        goto exit;

    iLen = wcslen(szHeadUpr);
    szReturn = &(m_extraHeaders[iLen+1]);

    while(iswspace(*szReturn))
        szReturn++;

    for (iLen = 0; szReturn[iLen] != L'\r' && szReturn[iLen] != NULL; iLen++);

exit:
    if (szReturn == NULL || iLen == 0)
        return 0;

    if (iLen >= size)
        return -(iLen + 1);

    buf[iLen] = NULL;
    memcpy(buf, szReturn, iLen*sizeof(WCHAR));
    return iLen;
}
*/
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
//
// TODO: make it real, netclasses, manifest and all that 
//
// ???? construct filename, create directory
HRESULT
AppProtocol::SetupAndInstall(
        LPTSTR  url, /* *not* ok to modify */
        LPTSTR  path /* out */)
{
    HRESULT hr = S_OK;
//    WCHAR *installFromPath = NULL;  // full path - app://www.microsoft.com/app5/app.manifest
    WCHAR *origin = NULL;                  // src - www.microsoft.com/app5
    WCHAR *p, *q;
    int i, j;

    // skip app:// part
    origin = DuplicateString(url + lstrlen(PROTOCOL_SCHEME));
    if (origin == NULL)
    {
        hr = E_OUTOFMEMORY;
        goto exit;
    }

//    installFromPath = (WCHAR *) MemAlloc((lstrlen(origin/*url*/) + lstrlen(HTTP_SCHEME)/*MAX_PATH*/) * sizeof(WCHAR));
//    if (installFromPath == NULL)
//    {
//        hr = E_OUTOFMEMORY;
//        goto exit;
//    }
//???????????????????????
    WCHAR installFromPath[MAX_URL_LENGTH];

    lstrcpy(installFromPath, HTTP_SCHEME);
    lstrcat(installFromPath, origin);
    // assume file name is given (it's now passed in) - not myweb.cab
    // better? - check if last contain ".", if so assume has filename, else attach app.manifest as filename
//    lstrcat(installFromPath, L"/MyWeb.cab");  //????????? if no filename it will get index.html, if exists!

    // remove the filename, if specified
    // ?????????? this assume all filename has a '.'
    p = wcsrchr(origin, L'/');
    q = wcsrchr(origin, L'.');
    if (p && q && /*((p - origin) > 6) &&*/ (p < q))
        *p = L'\0';
    // else - no filename -> do something to installFromPath? or no '/' after "app://" in url
    else
    {
        hr = E_INVALIDARG;
        goto exit;
    }

    // install to

    if(GetEnvironmentVariable(L"ProgramFiles", path, MAX_PATH-lstrlen(STORE_PATH)-1) == 0)  //????????
    {
        // 
        hr = CO_E_PATHTOOLONG;//E_FAIL;
        goto exit;
    }

    // ????????
    lstrcat(path, STORE_PATH);
    if(!CreateDirectory(path, NULL) && GetLastError() != ERROR_ALREADY_EXISTS)
    {
        hr = GetLastWin32Error();
        goto exit;
    }
    lstrcat(path, L"\\");

    i = lstrlen(path);
    j = 0;
    while(origin[j])
    {
        if(origin[j] == L'/')
        {
            path[i] = L'\0';
            if(!CreateDirectory(path, NULL) && GetLastError() != ERROR_ALREADY_EXISTS)
            {
                hr = GetLastWin32Error();
                goto exit;
            }

            path[i] = L'\\';
        }
        else
            path[i] = origin[j];
        i++;
        j++;
    }
    path[i] = L'\0';
    if(!CreateDirectory(path, NULL) && GetLastError() != ERROR_ALREADY_EXISTS)
    {
        hr = GetLastWin32Error();
        goto exit;
    }

    // grab the files
    hr = InstallInternetFile(installFromPath, path);

exit:
//    if(installFromPath) MemFree(installFromPath);
    if(origin) MemFree(origin);

    return hr;
}



/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
//
// given the url like MyWeb://www.site.com/app/something/else?querystring=aa
// sets
//      m_uriPath        to /app/something/else
//      m_queryString    to querystring=aa
//      m_appRoot        to /app or
//                         /app/something or 
//                         /app/something/else,
//          depending on which was successfully mapped to 
//      m_appRootTranslated to, for instance, c:\program files\site app\
//                       not set till SetupAndInstall() is called
//      m_appOrigin      to www.site.com
//      m_fullUri     to myweb://www.site.com/app/something/else
//
// if application was not installed, attempts to install it
//
// ???? setup strings, find out if needs install
HRESULT
AppProtocol::ParseUrl(LPCTSTR url)
{
    HRESULT hr = S_OK;
    WCHAR slash = L'/';
    WCHAR *p, *base;
    int cchFullUri = 0;
//    WCHAR appRootTranslated[MAX_PATH];

    // copy the cookie path into member variable
    m_fullUri = DuplicateString(url);
    if (m_fullUri == NULL)
    {
        hr = E_OUTOFMEMORY;
        goto exit;
    }

    // locate, store and strip query string, if any
    p = wcschr(m_fullUri, L'?');
    if(p != NULL && p[1] != L'\0')
    {
        m_queryString = p + 1;
        *p = L'\0';
    }

    // ????? to be moved
    // assume lower cases
    // need to find from end, skip ?querystring, use m_fullUri instead?
    cchFullUri = lstrlen(m_fullUri);
    m_appType = APPTYPE_IE;

    // ????? BUGBUG assume >= than 9 characters
    if (cchFullUri >= 9)
    {
        p = m_fullUri + cchFullUri - 5;
    /*    if (p[0] != L'.' && p[1] != L'.')
            // error? no extension
            m_appType = APPTYPE_IE;
        else*/
        if (p[1] == L'.' && (p[2] == L'e' && p[3] == L'x' && p[4] == L'e')
                            || (p[2] == L'd' && p[3] == L'l' && p[4] == L'l')) //L".exe" ".dll"
            m_appType = APPTYPE_ASM;    // (check asm or not?)
        else if (p[0] == L'.' && p[1] == L'a' && p[2] == L's' && p[3] == L'p' && p[4] == L'x') //L".aspx"
            m_appType = APPTYPE_MYWEB;
        else if (wcsncmp(p = m_fullUri + cchFullUri - 9, L".manifest", 9) == 0)
            m_appType = APPTYPE_BYMANIFEST;
        //else //default or others
        //    m_appType = APPTYPE_IE;
    }

    // skip through protocol:// 
    p = wcschr(m_fullUri, L':');
    if(p == NULL || p[1] != slash || p[2] != slash || p[3] == L'\0')  
    {
        hr = E_INVALIDARG;
    }

    // copy full origin path
    m_appOrigin = DuplicateString(p + 3);
    if (m_appOrigin == NULL)
    {
        hr = E_OUTOFMEMORY;
        goto exit;
    }

    // point to the end of site
    base = wcschr(m_appOrigin, slash);
    if(base == NULL)
    {
        hr = E_INVALIDARG;
        goto exit;
    }

//    appRootTranslated[0] = L'\0';

    // tear off one segment at a time from the end
    while((p = wcsrchr(m_appOrigin, slash)) != base)
    {
        *p = L'\0';
//        if(GetAppBaseDir(m_appOrigin, appRootTranslated) == S_OK)
//        {
//            break;
//        }
    }

// moved to Continue()
//    if(appRootTranslated[0] == L'\0')
//    {
//        WCHAR * appPath = DuplicateString(m_fullUri);
//        WCHAR * p;

        // application not installed, install it

/*        if (appPath == NULL)
        {
            hr = E_OUTOFMEMORY;
            goto exit;
        }
*/
        // ???? why? - this will remove the last - supposingly the filename?
//        p = wcsrchr(appPath, L'/');

//        if(p) *p = NULL;

//        hr = SetupAndInstall(m_fullUri/*appPath*/, appRootTranslated);
//        if (FAILED(hr))
//            goto exit;

//        if(appPath) MemFree(appPath);
//    }
   
/*    m_appRootTranslated = DuplicateString(appRootTranslated);
    if (m_appRootTranslated == NULL)
    {
        hr = E_OUTOFMEMORY;
        goto exit;
    }
*/
    m_appRoot = wcschr(m_appOrigin, slash);

    // ???? this should be ok
/*    if(m_appRoot == NULL)
    {
        hr = E_INVALIDARG;
        goto exit;
    }
*/
    if (m_appRoot)
        m_uriPath = wcsstr(m_fullUri, m_appRoot);
    else
        // ???? this should be ok
        m_uriPath = NULL;

exit:
    return hr;
}

/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
//
// Note: appRoot is assumed to have enough space (MAX_PATH)
//
/*HRESULT AppProtocol::GetAppBaseDir(LPCTSTR base, LPTSTR appRoot)
{
    HKEY             hKey     = NULL;
    HRESULT          hr       = E_FAIL;
    HKEY             hSubKey  = NULL;

    appRoot[0] = L'\0';

    if(RegOpenKeyEx(HKEY_LOCAL_MACHINE, MYWEBS_KEY, 0, KEY_READ, &hKey) != ERROR_SUCCESS)
    {
        hr = GetLastWin32Error();
        goto exit;
    }

    if(RegOpenKeyEx(hKey, base, 0, KEY_READ, &hSubKey) == ERROR_SUCCESS)
    {
        DWORD dwType, cb = MAX_PATH * sizeof(WCHAR);
        if(RegQueryValueEx(hSubKey, MYWEBS_APPROOT, NULL, &dwType, (LPBYTE)appRoot, &cb) == ERROR_SUCCESS)
        {
            dwType = GetFileAttributes(appRoot);
            if (dwType == (DWORD) -1 || (dwType & FILE_ATTRIBUTE_DIRECTORY) == 0)
                appRoot[0] = NULL;
            else
                hr = S_OK;
        }
        RegCloseKey(hSubKey);
    }

    RegCloseKey(hKey);
    

//exit:
    return hr;
}*/

/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////

// ???????called only from managed code?

WCHAR *
AppProtocol::MapString(
   int key)
{
/*    switch(key)
    {
    case IEWR_URIPATH:
        return m_uriPath;
    case IEWR_QUERYSTRING:
        return m_queryString;
    case IEWR_VERB:
        return m_verb;
    case IEWR_APPPATH:
        return m_appRoot;
    case IEWR_APPPATHTRANSLATED:
        return m_appRootTranslated;
    default:*/
if (key)
key=key; // ???????
        return NULL;
//    }
}

/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////

// ????????called only from managed code?
int
AppProtocol::GetStringLength(
        int key)
{
    WCHAR *targetString = MapString(key);
    return targetString ? lstrlen(targetString) + 1 : 0;
}

/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////

int 
AppProtocol::GetString(
        int        key, 
        WCHAR *    buf, 
        int        size)
{
    WCHAR *targetString = MapString(key);
    int len; 

    if(targetString == NULL)
        return 0;

    len = lstrlen(targetString);

    if(len >= size)
        return 0;

    lstrcpy(buf, targetString);

    return len + 1;
}

/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////

/*int
AppProtocol::MapPath(
        WCHAR *  virtualPath, 
        WCHAR *  physicalPath, 
        int      length)
{
    int requiredLength = lstrlen(m_appRootTranslated) + 2;
    int rootLength = lstrlen(m_appRoot);
    int i = 0;

    if(virtualPath && virtualPath[0] != '\0')
    {
        requiredLength += lstrlen(virtualPath) - rootLength;
    }

    if(requiredLength <= 0)
        return 0;

    if(requiredLength > length)
        return - requiredLength;

    while(m_appRootTranslated[i])
    {
        physicalPath[i] = m_appRootTranslated[i];
        i++;
    }

    if(virtualPath && virtualPath[0] != L'\0')
    {

        if(_memicmp(virtualPath, m_appRoot, sizeof(WCHAR) * rootLength))
            return 0;

        virtualPath += rootLength;
        if(*virtualPath && *virtualPath != L'/')
            physicalPath[i++] = L'\\';

        while(*virtualPath)
        {
            if(*virtualPath == L'/')
                physicalPath[i++] = L'\\';
            else
                physicalPath[i++] = *virtualPath;
            virtualPath++;
        }
    }

    physicalPath[i] = L'\0';

    return 1;
}
*/
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
// ????? download file from url into path
HRESULT
AppProtocol::InstallInternetFile(
        LPTSTR   url, 
        LPTSTR   path)
{
    HRESULT          hr                  = S_OK;
    HINTERNET        hInternet           = NULL;
    HINTERNET        hTransfer           = NULL;
    HANDLE           hFile               = INVALID_HANDLE_VALUE;
    WCHAR *          file                = NULL;
    DWORD            bytesRead           = 0;
    DWORD            bytesWritten        = 0;
    WCHAR            szFile[MAX_PATH];
    BYTE             buffer[4096];

    BOOL             bNeedDownload       = TRUE;

//    CabHandlerInfo   cabInfo;

    // ????????? TO BE MOVED!
    // check offline mode
    DWORD            dwState             = 0;
    DWORD            dwSize              = sizeof(DWORD);
    BOOL             bRemoveEmptyFile    = FALSE;

    if(g_pInternetQueryOption(NULL, INTERNET_OPTION_CONNECTED_STATE, &dwState, &dwSize))
    {
        if(dwState & INTERNET_STATE_DISCONNECTED_BY_USER)
            m_status |= STATUS_OFFLINE_MODE;
    }

    ////////////////////////////////////////////////////////////
    // Step 1: Construct the file name 
    // ???? this assumes there is a filename after the last '/'
    ZeroMemory(szFile, sizeof(szFile));
    wcsncpy(szFile, path, MAX_PATH - 2);
    lstrcat(szFile, L"\\");
    file = wcsrchr(url, L'/');

    if (file != NULL && wcslen(szFile) + wcslen(file) < MAX_PATH)
        wcscat(szFile, file + 1);
    else
    {
        hr = CO_E_PATHTOOLONG;//E_FAIL;
        goto exit;
    }

    MemClearFn((void **)&m_localStoreFilePath);
    m_localStoreFilePath = DuplicateString(szFile);

    ////////////////////////////////////////////////////////////
    // Step 2: Create the file
    // need write access, will open (and replace/overwrite) exiting file
    // ??? FILE_SHARE_READ? but we might write to if outdated...
    hFile = CreateFile(szFile, GENERIC_WRITE, 0, NULL, 
                       OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);

    if(hFile == INVALID_HANDLE_VALUE)
    {
        hr = GetLastWin32Error();
        goto exit;
    }

    // ????????? TO BE MOVED!
    if (GetLastError() == ERROR_ALREADY_EXISTS)
    {
        FILETIME ftLastModified;
#define FTTICKSPERDAY (60*60*24*(LONGLONG) 10000000) // == 864000000000

        if (GetFileTime(hFile, NULL, NULL, &ftLastModified))
        {
                SYSTEMTIME sSysT;
                FILETIME ft;

                GetSystemTime(&sSysT);
                SystemTimeToFileTime(&sSysT, &ft);

                ULARGE_INTEGER ulInt = * (ULARGE_INTEGER *) &ft;
                ulInt.QuadPart -= FTTICKSPERDAY * 3;  // 3 days
                ft = * (FILETIME *) &ulInt;

                if (CompareFileTime(&ftLastModified, &ft) != -1)
                    // reuse file, just execute it
                    bNeedDownload = FALSE;
        }
    }
    else
         m_status |= STATUS_NOT_IN_CACHE;

    if ((m_status & STATUS_OFFLINE_MODE) && (m_status & STATUS_NOT_IN_CACHE))
    {
        // hr = E_FAIL; // ???? file not found - if uncomment this line, generic IE error page will display instead
        bRemoveEmptyFile = TRUE;
        goto exit;
    }

    if (bNeedDownload && !(m_status & STATUS_OFFLINE_MODE))
    {
    ////////////////////////////////////////////////////////////
    // Step 3: Copy the files over the internet
    hInternet = g_pInternetOpen(L"App", INTERNET_OPEN_TYPE_PRECONFIG, NULL, NULL, 0);
    if(hInternet == NULL)
    {
        hr = GetLastWin32Error();
        bRemoveEmptyFile = TRUE;
        goto exit;
    }

    // use own caching instead
    hTransfer = g_pInternetOpenUrl(hInternet, url, NULL, 0, INTERNET_FLAG_NO_CACHE_WRITE, 0);
    if(hTransfer == NULL)
    {
        hr = GetLastWin32Error();
        bRemoveEmptyFile = TRUE;
        goto exit;
    }

    // need to check if there's any error, eg. not found (404)...
    
    // synchronous download
    while(g_pInternetReadFile(hTransfer, buffer, sizeof(buffer), &bytesRead) && bytesRead != 0)
    {
        if ( !WriteFile(hFile, buffer, bytesRead, &bytesWritten, NULL) || 
             bytesWritten != bytesRead                                  )
        {
            hr = GetLastWin32Error();
            bRemoveEmptyFile = TRUE;
            goto exit;
        }
    }
    }

    // ensure file/internet handles are closed before further processing is done
    if (hFile != INVALID_HANDLE_VALUE)
        CloseHandle(hFile);    
    if (hInternet != NULL)
        g_pInternetCloseHandle(hInternet);
    if (hTransfer != NULL)
        g_pInternetCloseHandle(hTransfer);
        
    hInternet   = NULL;
    hTransfer   = NULL;
    hFile       = INVALID_HANDLE_VALUE;

    // ????????? TO BE MOVED!
    // process - run all .exe
    // lower case? end of string?
    if (/*m_appType == APPTYPE_ASM)*/wcsstr(file, L".exe"))
    {
//#define MAX_SIZE_SECURITY_ID 0x200
        DWORD                   dwZone;
        DWORD                   dwSize = MAX_SIZE_SECURITY_ID;
        BYTE                    byUniqueID[MAX_SIZE_SECURITY_ID];
        WCHAR                   wzUniqueID[MAX_SIZE_SECURITY_ID * 2 + 1];
        WCHAR                   wzCmdLine[1025];

    //IInternetSecurityManager::ProcessUrlAction

        // lazy init
        if (g_pSecurityMgr == NULL)
        {
            hr = CoCreateInstance(CLSID_InternetSecurityManager, NULL, CLSCTX_INPROC_SERVER,
                                IID_IInternetSecurityManager, (void**)&g_pSecurityMgr);

            //???? should this fails at all if security info/manager is undef?
            if (FAILED(hr))
            {
                g_pSecurityMgr = NULL;
                goto exit;
            }
        }
        
        // m_fullUri -> this should translate correctly in IInternetProtocolInfo->ParseUrl()
        if (SUCCEEDED(hr = g_pSecurityMgr->MapUrlToZone(m_fullUri, &dwZone, 0)))
        {
             // check space in site? -  assume checked in GetSecurityId
             // should site be just www.abc.com or www.abc.com/app2/appmain.exe?
             if (FAILED(hr)
             || FAILED(hr = g_pSecurityMgr->GetSecurityId(m_fullUri, byUniqueID, &dwSize, 0)))
                 goto exit;

             ConvertToHex(wzUniqueID, byUniqueID, dwSize);
        }
        else
        {
             goto exit;
        }

        // ???? any space in url? start a new proc for that asm, not hang the browser
        /* C:\\Documents and Settings\\felixybc.NTDEV\\Desktop\\work\\conexec\\Debug\\*/
        if (_snwprintf(wzCmdLine, 1025,
					L"conexec.exe \"%s\" +3 %d %s %s", szFile, dwZone, wzUniqueID, url) < 0)
        {
			hr = CO_E_PATHTOOLONG;
			goto exit;
		}
        RunCommand(wzCmdLine);
    }

exit:
    if (hFile != INVALID_HANDLE_VALUE)
        CloseHandle(hFile);
    if (hInternet != NULL)
        g_pInternetCloseHandle(hInternet);
    if (hTransfer != NULL)
        g_pInternetCloseHandle(hTransfer);
    hInternet   = NULL;
    hTransfer   = NULL;
    hFile       = INVALID_HANDLE_VALUE;

    // remove the file so that it will not be mistaken next time this runs
    // ignore if error deleting the file so the hr is not overwritten
    if (bRemoveEmptyFile)
        DeleteFile(szFile);

    return hr;
}

/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////

HRESULT
AppProtocol::QueryOption(DWORD, LPVOID, DWORD*)
{
    return E_NOTIMPL;
}

/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////

HRESULT
AppProtocol::QueryInfo(
        DWORD        dwOption, 
        LPVOID       pBuffer, 
        LPDWORD      pcbBuf, 
        LPDWORD      , 
        LPDWORD      )
{
    if (pcbBuf == NULL)
        return E_FAIL;
    
    HRESULT hr              = S_OK;
    LPCWSTR szHeader        = NULL;
    DWORD   dwOpt           = (dwOption & HTTP_QUERY_HEADER_MASK);
    DWORD   dwLen           = (m_strResponseHeader ? wcslen(m_strResponseHeader) : 0);

    switch(dwOpt)
    {
    case HTTP_QUERY_RAW_HEADERS_CRLF: 
    case HTTP_QUERY_RAW_HEADERS:
        if (m_strResponseHeader == NULL)
            return E_FAIL;

        if (*pcbBuf < dwLen + 1)
        {
            hr = HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER);
        }
        else
        {
            if (dwOpt == HTTP_QUERY_RAW_HEADERS_CRLF)
            {
                wcscpy((WCHAR *) pBuffer, m_strResponseHeader);
            }
            else
            {
                DWORD iPos = 0;
                for(DWORD iter=0; iter<dwLen; iter++)
                    if (m_strResponseHeader[iter] == L'\r' && m_strResponseHeader[iter+1] == L'\n')
                    {
                        ((WCHAR *)pBuffer)[iPos++] = L'0';
                        iter++;
                    }
                    else
                    {
                        ((WCHAR *)pBuffer)[iPos++] = m_strResponseHeader[iter];
                    }

                *pcbBuf = iPos;
            }
        }
        goto exit;
    case HTTP_QUERY_ACCEPT:
        szHeader = L"Accept:";
        break;
    case HTTP_QUERY_ACCEPT_CHARSET: 
        szHeader = L"Accept-Charset:";
        break;
    case HTTP_QUERY_ACCEPT_ENCODING: 
        szHeader = L"Accept-Encoding:";
        break;
    case HTTP_QUERY_ACCEPT_LANGUAGE: 
        szHeader = L"Accept-Language:";
        break;
    case HTTP_QUERY_ACCEPT_RANGES: 
        szHeader = L"Accept-Ranges:";
        break;
    case HTTP_QUERY_AGE: 
        szHeader = L"Age:";
        break;
    case HTTP_QUERY_ALLOW: 
        szHeader = L"Allow:";
        break;
    case HTTP_QUERY_AUTHORIZATION: 
        szHeader = L"Authorization:";
        break;
    case HTTP_QUERY_CACHE_CONTROL: 
        szHeader = L"Cache-Control:";
        break;
    case HTTP_QUERY_CONNECTION: 
        szHeader = L"Connection:";
        break;
    case HTTP_QUERY_CONTENT_BASE: 
        szHeader = L"Content-Base:";
        break;
    case HTTP_QUERY_CONTENT_DESCRIPTION: 
        szHeader = L"Content-Description:";
        break;
    case HTTP_QUERY_CONTENT_DISPOSITION: 
        szHeader = L"Content-Disposition:";
        break;
    case HTTP_QUERY_CONTENT_ENCODING: 
        szHeader = L"Content-encoding:";
        break;
    case HTTP_QUERY_CONTENT_ID: 
        szHeader = L"Content-ID:";
        break;
    case HTTP_QUERY_CONTENT_LANGUAGE: 
        szHeader = L"Content-Language:";
        break;
    case HTTP_QUERY_CONTENT_LENGTH: 
        szHeader = L"Content-Langth:";
        break;
    case HTTP_QUERY_CONTENT_LOCATION: 
        szHeader = L"Content-Location:";
        break;
    case HTTP_QUERY_CONTENT_MD5: 
        szHeader = L"Content-MD5:";
        break;
    case HTTP_QUERY_CONTENT_TRANSFER_ENCODING: 
        szHeader = L"Content-Transfer-Encoding:";
        break;
    case HTTP_QUERY_CONTENT_TYPE: 
        szHeader = L"Content-Type:";
        break;
    case HTTP_QUERY_COOKIE: 
        szHeader = L"Cookie:";
        break;
    case HTTP_QUERY_COST: 
        szHeader = L"Cost:";
        break;
    case HTTP_QUERY_CUSTOM: 
        szHeader = L"Custom:";
        break;
    case HTTP_QUERY_DATE: 
        szHeader = L"Date:";
        break;
    case HTTP_QUERY_DERIVED_FROM: 
        szHeader = L"Derived-From:";
        break;
    case HTTP_QUERY_ECHO_HEADERS: 
        szHeader = L"Echo-Headers:";
        break;
    case HTTP_QUERY_ECHO_HEADERS_CRLF: 
        szHeader = L"Echo-Headers-Crlf:";
        break;
    case HTTP_QUERY_ECHO_REPLY: 
        szHeader = L"Echo-Reply:";
        break;
    case HTTP_QUERY_ECHO_REQUEST: 
        szHeader = L"Echo-Request:";
        break;
    case HTTP_QUERY_ETAG: 
        szHeader = L"ETag:";
        break;
    case HTTP_QUERY_EXPECT: 
        szHeader = L"Expect:";
        break;
    case HTTP_QUERY_EXPIRES: 
        szHeader = L"Expires:";
        break;
    case HTTP_QUERY_FORWARDED: 
        szHeader = L"Forwarded:";
        break;
    case HTTP_QUERY_FROM: 
        szHeader = L"From:";
        break;
    case HTTP_QUERY_HOST: 
        szHeader = L"Host:";
        break;
    case HTTP_QUERY_IF_MATCH: 
        szHeader = L"If-Match:";
        break;
    case HTTP_QUERY_IF_MODIFIED_SINCE: 
        szHeader = L"If-Modified-Since:";
        break;
    case HTTP_QUERY_IF_NONE_MATCH: 
        szHeader = L"If-None-Match:";
        break;
    case HTTP_QUERY_IF_RANGE: 
        szHeader = L"If-Range:";
        break;
    case HTTP_QUERY_IF_UNMODIFIED_SINCE:
        szHeader = L"If-Unmodified-since:";
        break;
    case HTTP_QUERY_LINK:
        szHeader = L"Link:";
        break;
    case HTTP_QUERY_LAST_MODIFIED: 
        szHeader = L"Last-Modified:";
        break;
    case HTTP_QUERY_LOCATION: 
        szHeader = L"Location:";
        break;
    case HTTP_QUERY_MAX_FORWARDS: 
        szHeader = L"Max-Forwards:";
        break;
    case HTTP_QUERY_MESSAGE_ID: 
        szHeader = L"Message_Id:";
        break;
    case HTTP_QUERY_MIME_VERSION: 
        szHeader = L"Mime-Version:";
        break;
    case HTTP_QUERY_ORIG_URI: 
        szHeader = L"Orig-Uri:";
        break;
    case HTTP_QUERY_PRAGMA: 
        szHeader = L"Pragma:";
        break;
    case HTTP_QUERY_PROXY_AUTHENTICATE: 
        szHeader = L"Authenticate:";
        break;
    case HTTP_QUERY_PROXY_AUTHORIZATION: 
        szHeader = L"Proxy-Authorization:";
        break;
    case HTTP_QUERY_PROXY_CONNECTION: 
        szHeader = L"Proxy-Connection:";
        break;
    case HTTP_QUERY_PUBLIC: 
        szHeader = L"Public:";
        break;
    case HTTP_QUERY_RANGE: 
        szHeader = L"Range:";
        break;
    case HTTP_QUERY_REFERER: 
        szHeader = L"Referer:";
        break;
    case HTTP_QUERY_REFRESH: 
        szHeader = L"Refresh:";
        break;
    case HTTP_QUERY_REQUEST_METHOD: 
        szHeader = L"Request-Method:";
        break;
    case HTTP_QUERY_RETRY_AFTER: 
        szHeader = L"Retry-After:";
        break;
    case HTTP_QUERY_SERVER: 
        szHeader = L"Server:";
        break;
    case HTTP_QUERY_SET_COOKIE: 
        szHeader = L"Set-Cookie:";
        break;
    case HTTP_QUERY_STATUS_CODE: 
        szHeader = L"HTTP/1.1"; // Special!!!
        break;
    case HTTP_QUERY_STATUS_TEXT: 
        szHeader = L"HTTP/1.1"; // Special!!!
        break;
    case HTTP_QUERY_TITLE: 
        szHeader = L"Title:";
        break;
    case HTTP_QUERY_TRANSFER_ENCODING: 
        szHeader = L"Transfer-Encoding:";
        break;
    case HTTP_QUERY_UNLESS_MODIFIED_SINCE: 
        szHeader = L"Unless-Modified-Since:";
        break;
    case HTTP_QUERY_UPGRADE: 
        szHeader = L"Upgrade:";
        break;
    case HTTP_QUERY_URI: 
        szHeader = L"Uri:";
        break;
    case HTTP_QUERY_USER_AGENT: 
        szHeader = L"User-Agent:";
        break;
    case HTTP_QUERY_VARY: 
        szHeader = L"Vary:";
        break;
    case HTTP_QUERY_VERSION: 
        szHeader = L"Version:";
        break;
    case HTTP_QUERY_VIA: 
        szHeader = L"Via:";
        break;
    case HTTP_QUERY_WARNING: 
        szHeader = L"Warning:";
        break;
    case HTTP_QUERY_WWW_AUTHENTICATE:
        szHeader = L"WWW-Authenticate:";
        break;
    default:
        goto exit;
    }

    if (dwOption & HTTP_QUERY_FLAG_SYSTEMTIME)
    {
        if (*pcbBuf < sizeof(SYSTEMTIME) || pBuffer == NULL)
        {
            hr = HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER);
            goto exit;
        }
        else
        {
            LPSYSTEMTIME pSys = (LPSYSTEMTIME) pBuffer;
            GetSystemTime(pSys);
            *pcbBuf = sizeof(SYSTEMTIME);
            goto exit;
        }
    }


    if ((dwOption & HTTP_QUERY_FLAG_REQUEST_HEADERS) == 0)
        hr = DealWithBuffer(m_strResponseHeader, szHeader, dwOpt, dwOption, pBuffer, pcbBuf);
    if (hr == E_FAIL)
        hr = DealWithBuffer(m_extraHeaders, szHeader, dwOpt, dwOption, pBuffer, pcbBuf);

exit:
    return hr;
}

/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////

HRESULT
AppProtocol::DealWithBuffer(
        LPWSTR   szHeaders, 
        LPCWSTR  szHeader, 
        DWORD    dwOpt, 
        DWORD    dwOption, 
        LPVOID   pBuffer, 
        LPDWORD  pcbBuf)
{
    LPCWSTR szValue = wcsstr(szHeaders, (LPWSTR) szHeader);
    if (szValue == NULL)
        return E_FAIL;

    DWORD dwStart  = wcslen(szHeader);
    while(iswspace(szValue[dwStart]) && szValue[dwStart] != L'\r')
        dwStart++;

    DWORD dwEnd    = dwStart;
   
    switch(dwOpt)
    {
    case HTTP_QUERY_STATUS_CODE:
        dwEnd = dwStart + 3;
        break;
    case HTTP_QUERY_STATUS_TEXT:
        dwStart += 4;// Fall thru to default
        dwEnd = dwStart;
    default:
        while(szValue[dwEnd] != NULL && szValue[dwEnd] != L'\r')
            dwEnd++;
        dwEnd--;
    }

    DWORD dwReq = (dwEnd - dwStart + 1);

    if ((dwOption & HTTP_QUERY_FLAG_NUMBER) && *pcbBuf < 4)
    {
        *pcbBuf = 4;
        return HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER);            
    }
    if ((dwOption & HTTP_QUERY_FLAG_NUMBER) == 0 && *pcbBuf < dwReq)
    {
        *pcbBuf = dwReq;
        return HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER); 
    }
 

    if (dwOption & HTTP_QUERY_FLAG_NUMBER)
    {
        LPDWORD lpD = (LPDWORD) pBuffer;
        *lpD = _wtoi(&szValue[dwStart]);
        *pcbBuf = 4;
    }
    else
    {
        memcpy(pBuffer, &szValue[dwStart], dwReq*sizeof(WCHAR));
        ((WCHAR *) pBuffer)[dwReq] = NULL;
    }
    return S_OK;
}

/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////

HRESULT
AppProtocol::ProcessAppManifest()
{
    HRESULT   hr   = S_OK;

    char    *szManifest;
    HANDLE  hFile;
    BYTE    buffer[1024];
    DWORD   dwLength;

    APPINFO aiApplication;

    aiApplication._wzNewRef[0] = L'\0';
    aiApplication._wzEntryAssemblyFileName[0] = L'\0';
    aiApplication._pFileList = NULL;

    // step 1: read the .manifest
    hFile = CreateFile(m_localStoreFilePath, GENERIC_READ, 0, NULL, 
                   OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);

    if(hFile == INVALID_HANDLE_VALUE)
    {
        hr = GetLastWin32Error();
        goto exit;
    }

    ZeroMemory(buffer, sizeof(buffer));

    while ( ReadFile (hFile, buffer, sizeof(buffer), &dwLength, NULL) && dwLength )
    {
            break; //BUGBUG: read once - only the 1st 1024 bytes
    }
    if (hFile != INVALID_HANDLE_VALUE)
        CloseHandle(hFile);

    *(buffer + dwLength) = '\0';
    szManifest = (char*) buffer;

    // step 2: parsing
    ParseManifest(szManifest, &aiApplication);

    // step 3: do "the works"

    // should take the base Uri, base appRoot, + file name
//***        if (FAILED(hr = InstallInternetFile2(wzSourceUri, m_appRootTranslated, filename, hash)))
//            goto exit;
    

exit:
    return hr;
}

void
AppProtocol::ParseManifest(char* szManifest, APPINFO* pAppInfo)
{
    char    *token;
    char    seps[] = " </>=\"\t\n\r";
    FILEINFOLIST* pCurrent = NULL;

//    WCHAR   wzDummyPath[MAX_PATH];
    WCHAR   wzSourceUri[MAX_PATH];

    BOOL    fSkipNextToken = FALSE;

    // parsing code - limitation: does not work w/ space in field, even if enclosed w/ quotes
    // szManifest will be modified!
    token = strtok( szManifest, seps );
    while( token != NULL )
    {
//        wzDummyPath[0] = L'\0';

       // While there are tokens
       if (!_stricmp(token, "file"))
       {
            // get around in spaced tag
            token = strtok( NULL, seps );
            if (!_stricmp(token, "name"))
            {
                token = strtok( NULL, seps );

/*                lstrcpy(wzSourceUri, m_fullUri);
                WCHAR* p = wcsrchr(wzSourceUri, L'/');
                WCHAR* q = wcsrchr(wzSourceUri, L'.');
                if (p && q && (p < q))
                    *p = L'\0';
                else
                {
                    hr = E_INVALIDARG;
                    goto exit;
                }
                
                _snwprintf(wzSourceUri, MAX_PATH, L"%s/%S", wzSourceUri, token);*/

                // init
                if (pCurrent == NULL)
                {
                    pAppInfo->_pFileList = new FILEINFOLIST;
                    pCurrent = pAppInfo->_pFileList;
                }
                else
                {
                    pCurrent->_pNext = new FILEINFOLIST;
                    pCurrent = pCurrent->_pNext;
                }

                pCurrent->_pNext = NULL;
                _snwprintf(pCurrent->_wzFilename, MAX_PATH, L"%S", token); // worry about total path len later

//no need       m_pProtocolSink->ReportProgress(BINDSTATUS_BEGINDOWNLOADCOMPONENTS, L"downloading application files");

                token = strtok( NULL, seps );
                if (!_stricmp(token, "hash"))
                {
                    _snwprintf(pCurrent->_wzHash, 33, L"%S", token);

                    // ???? should i reuse the file handle instead?
//*                    if (IsFileCorrupted(m_localStoreFilePath, token))    Integrity
//*                        ...
                }
                else
                    fSkipNextToken = TRUE;            
            }
       }
       else if (!_stricmp(token, "newhref"))
       {
            // note, different handling... because '/' is one of seps
            for (int i = 0; i < MAX_URL_LENGTH; i++)
            {
                if (*(token+8+i) == '<')
                {
                    // BUGBUG: 8 == strlen("newhref>")
                    *(token+8+i) = '\0';
                    _snwprintf(pAppInfo->_wzNewRef, i, L"%S", token+8);

                    // BUGBUG? is this going to work?
                    token = strtok( token+i+9, seps);
                    // now  token == "newhref" && *(token-1) == '/'
                }
            }

            // BUGBUG: ignoring > MAX_URL_LENGTH case here... may mess up later if the URL contain a "keyword"
            // <newhref></newhref> may be ok...
       }

       //else
       // ignore others for now

    // Get next token...
    if(!fSkipNextToken)
        token = strtok( NULL, seps );
    else
        fSkipNextToken = FALSE;
    }
}