/*++

   Copyright    (c)    2000    Microsoft Corporation

   Module Name :
     range.cxx

   Abstract:
     Handle Range Requests

   Author:
     Anil Ruia (AnilR)            29-Mar-2000

   Environment:
     Win32 - User Mode

   Project:
     UlW3.dll
--*/

#include "precomp.hxx"
#include "staticfile.hxx"

#define RANGE_BOUNDARY  "<q1w2e3r4t5y6u7i8o9p0zaxscdvfbgnhmjklkl>"


extern BOOL FindInETagList(CHAR * pLocalETag,
                           CHAR * pETagList,
                           BOOL   fWeakCompare);


STRA  *W3_STATIC_FILE_HANDLER::sm_pstrRangeContentType;
STRA  *W3_STATIC_FILE_HANDLER::sm_pstrRangeMidDelimiter;
STRA  *W3_STATIC_FILE_HANDLER::sm_pstrRangeEndDelimiter;


// static
HRESULT W3_STATIC_FILE_HANDLER::Initialize()
{
    ALLOC_CACHE_CONFIGURATION       acConfig;
    HRESULT                         hr = NO_ERROR;

    //
    // Setup allocation lookaside
    //
    
    acConfig.nConcurrency = 1;
    acConfig.nThreshold = 100;
    acConfig.cbSize = sizeof( W3_STATIC_FILE_HANDLER );

    DBG_ASSERT( sm_pachStaticFileHandlers == NULL );
    
    sm_pachStaticFileHandlers = new ALLOC_CACHE_HANDLER( "W3_STATIC_FILE_HANDLER",  
                                                         &acConfig );

    if ( sm_pachStaticFileHandlers == NULL )
    {
        return HRESULT_FROM_WIN32( ERROR_NOT_ENOUGH_MEMORY );
    }

    //
    // Initialize the various Range Strings
    //
    sm_pstrRangeContentType = new STRA;
    sm_pstrRangeMidDelimiter = new STRA;
    sm_pstrRangeEndDelimiter = new STRA;
    if (sm_pstrRangeContentType == NULL ||
        sm_pstrRangeMidDelimiter == NULL ||
        sm_pstrRangeEndDelimiter == NULL)
    {
        delete sm_pachStaticFileHandlers;
        sm_pachStaticFileHandlers = NULL;
        return HRESULT_FROM_WIN32(ERROR_NOT_ENOUGH_MEMORY);
    }

    if (FAILED(hr = sm_pstrRangeContentType->Copy(
                        "multipart/byteranges; boundary=")) ||
        FAILED(hr = sm_pstrRangeContentType->Append(RANGE_BOUNDARY)))
    {
        delete sm_pachStaticFileHandlers;
        sm_pachStaticFileHandlers = NULL;
        return hr;
    }

    if (FAILED(hr = sm_pstrRangeMidDelimiter->Copy("--")) ||
        FAILED(hr = sm_pstrRangeMidDelimiter->Append(RANGE_BOUNDARY)) ||
        FAILED(hr = sm_pstrRangeMidDelimiter->Append("\r\n")))
    {
        delete sm_pachStaticFileHandlers;
        sm_pachStaticFileHandlers = NULL;
        return hr;
    }

    if (FAILED(hr = sm_pstrRangeEndDelimiter->Copy("\r\n--")) ||
        FAILED(hr = sm_pstrRangeEndDelimiter->Append(RANGE_BOUNDARY)) ||
        FAILED(hr = sm_pstrRangeEndDelimiter->Append("--\r\n\r\n")))
    {
        delete sm_pachStaticFileHandlers;
        sm_pachStaticFileHandlers = NULL;
        return hr;
    }

    return S_OK;
}


BOOL ScanRange(CHAR *        *ppszRange,
               LARGE_INTEGER  liFileSize,
               LARGE_INTEGER *pliOffset,
               LARGE_INTEGER *pliSize,
               BOOL          *pfInvalidRange)
/*++
  Routine Description:
    Scan the next range in strRange

  Returns:
    TRUE if a range was found, else FALSE

  Arguments:
    ppszRange       String pointing to the current range.
    liFileSize      Size of the file being retrieved
    pliOffset       range offset on return
    pliSizeTo       range size on return
    pfInvalidRange  set to TRUE on return if Invalid syntax
--*/
{
    CHAR *pszRange = *ppszRange;
    CHAR c;

    //
    // Skip to begining of next range
    //
    while ((c = *pszRange) && (c == ' '))
    {
        ++pszRange;
    }

    //
    // Test for no range
    //
    if (*pszRange == '\0')
    {
        return FALSE;
    }

    //
    // determine Offset & Size to send
    //
    if (*pszRange == '-')
    {
        //
        // This is in format -nnn which means send bytes filesize-nnn
        // to eof
        //
        ++pszRange;

        if (!isdigit(*pszRange))
        {
            *pfInvalidRange = TRUE;
            return TRUE;
        }

        pliSize->QuadPart = _atoi64(pszRange);
        if (pliSize->QuadPart > liFileSize.QuadPart)
        {
            pliSize->QuadPart = liFileSize.QuadPart;
            pliOffset->QuadPart = 0;
        }
        else
        {
            pliOffset->QuadPart = liFileSize.QuadPart - pliSize->QuadPart;
        }
    }
    else if (isdigit(*pszRange))
    {
        //
        // This is in format mmm-nnn which menas send bytes mmm to nnn
        //         or format mmm- which means send bytes mmm to eof
        //
        pliOffset->QuadPart = _atoi64(pszRange);

        //
        // Skip over the beginning number - and any intervening spaces
        //
        while((c = *pszRange) && isdigit(c))
        {
            pszRange++;
        }

        while((c = *pszRange) && (c == ' '))
        {
            pszRange++;
        }

        if (*pszRange != '-')
        {
            *pfInvalidRange = TRUE;
            return TRUE;
        }
        pszRange++;

        while((c = *pszRange) && (c == ' '))
        {
            pszRange++;
        }

        if (isdigit(*pszRange))
        {
            //
            // We have mmm-nnn
            //
            LARGE_INTEGER liEnd;
            liEnd.QuadPart = _atoi64(pszRange);
            if (liEnd.QuadPart < pliOffset->QuadPart)
            {
                *pfInvalidRange = TRUE;
                return TRUE;
            }

            if (liEnd.QuadPart >= liFileSize.QuadPart)
            {
                pliSize->QuadPart = liFileSize.QuadPart - pliOffset->QuadPart;
            }
            else
            {
                pliSize->QuadPart = liEnd.QuadPart - pliOffset->QuadPart + 1;
            }
        }
        else
        {
            //
            // We have mmm-
            //
            pliSize->QuadPart = liFileSize.QuadPart - pliOffset->QuadPart;
        }
    }
    else
    {
        //
        // Invalid Syntax
        //
        *pfInvalidRange = TRUE;
        return TRUE;
    }

    //
    // Skip to the start of the next range
    //
    while ((c = *pszRange) && isdigit(c))
    {
        ++pszRange;
    }

    while ((c = *pszRange) && c == ' ')
    {
        ++pszRange;
    }

    if (c == ',')
    {
        ++pszRange;
    }
    else if (c != '\0')
    {
        *pfInvalidRange = TRUE;
        return TRUE;
    }

    *ppszRange = pszRange;
    return TRUE;
}


HRESULT W3_STATIC_FILE_HANDLER::RangeDoWork(W3_CONTEXT   *pW3Context,
                                            W3_FILE_INFO *pOpenFile,
                                            BOOL         *pfHandled)
{
    W3_REQUEST  *pRequest  = pW3Context->QueryRequest();
    W3_RESPONSE *pResponse = pW3Context->QueryResponse();

    // First, handle If-Range: if it exists.  If the If-Range matches we
    // don't do anything. If the If-Range doesn't match then we force
    // retrieval of the whole file.

    CHAR * pszIfRange = pRequest->GetHeader(HttpHeaderIfRange);
    if (pszIfRange != NULL && *pszIfRange != L'\0')
    {
        // Need to determine if what we have is a date or an ETag.
        // An ETag may start with a W/ or a quote. A date may start
        // with a W but will never have the second character be a /.

        if (*pszIfRange == L'"' ||
            (*pszIfRange == L'W' && pszIfRange[1] == L'/'))
        {
            // This is an ETag.
            if (pOpenFile->QueryIsWeakETag() ||
                !FindInETagList(pOpenFile->QueryETag(),
                                pszIfRange,
                                FALSE))
            {
                // The If-Range failed, so we can't send a range. Force
                // sending the whole thing.
                *pfHandled = FALSE;
                return S_OK;
            }
        }
        else
        {
            // This is a date
            LARGE_INTEGER   liRangeTime;

            // This must be a date. Convert it to a time, and see if it's
            // less than or equal to our last write time. If it is, the
            // file's changed, and we can't perform the range.

            if (!StringTimeToFileTime(pszIfRange, &liRangeTime))
            {
                // Couldn't convert it, so don't send the range.
                *pfHandled = FALSE;
                return S_OK;
            }
            else
            {
                FILETIME tm;
                
                pOpenFile->QueryLastWriteTime(&tm);

                if (*(LONGLONG*)&tm > liRangeTime.QuadPart )
                {
                    // The If-Range failed, so we can't send a range. Force
                    // sending the whole thing.
                    *pfHandled = FALSE;
                    return S_OK;
                }
            }
        }
    }

    // If we fell through, then If-Range passed, we are going to try sending
    // a range response
    CHAR * pszRange = pRequest->GetHeader(HttpHeaderRange);
    //
    // We have bytes = <range1>, <range2>, ...
    // skip past the '='
    //
    pszRange = strchr(pszRange, '=');
    if (pszRange == NULL)
    {
        // Invalid syntax, send entire file
        *pfHandled = FALSE;
        return S_OK;
    }
    pszRange++;

    LARGE_INTEGER liFileSize;
    HRESULT hr = S_OK;
    pOpenFile->QuerySize(&liFileSize);
    if (liFileSize.QuadPart <= 0)
    {
        pResponse->ClearHeaders();
        pResponse->SetStatus(HttpStatusRangeNotSatisfiable);

        CHAR pszContentRange[24];
        strcpy(pszContentRange, "bytes */");
        _i64toa(liFileSize.QuadPart, pszContentRange + 8, 10);
        if (FAILED(hr = pResponse->SetHeader(HttpHeaderContentRange,
                                             pszContentRange,
                                             strlen(pszContentRange))))
        {
            return hr;
        }

        *pfHandled = TRUE;
        return S_OK;
    }

    DWORD cRanges = 0;
    STACK_BUFFER( bufByteRange, 256);
    HTTP_BYTE_RANGE *pByteRange;
    LARGE_INTEGER liRangeOffset;
    LARGE_INTEGER liRangeSize;
    BOOL fInvalidSyntax = FALSE;
    BOOL fAtLeastOneRange = FALSE;

    while (ScanRange(&pszRange,
                     liFileSize,
                     &liRangeOffset,
                     &liRangeSize,
                     &fInvalidSyntax))
    {
        fAtLeastOneRange = TRUE;

        if (fInvalidSyntax)
        {
            //
            // Invalid syntax in Range header.  Ignore Range headers,
            // Send complete File.
            //
            *pfHandled = FALSE;
            return S_OK;
        }

        if (liRangeOffset.QuadPart > liFileSize.QuadPart ||
            liRangeSize.QuadPart == 0)
        {
            //
            // The Range is not satisfiable
            //
            continue;
        }

        cRanges++;

        if (cRanges * sizeof(HTTP_BYTE_RANGE) > bufByteRange.QuerySize())
        {
            if (!bufByteRange.Resize(cRanges * sizeof(HTTP_BYTE_RANGE), 256))
            {
                return HRESULT_FROM_WIN32(ERROR_NOT_ENOUGH_MEMORY);
            }
        }

        pByteRange = (HTTP_BYTE_RANGE *)bufByteRange.QueryPtr();
        pByteRange[cRanges - 1].StartingOffset = liRangeOffset;
        pByteRange[cRanges - 1].Length         = liRangeSize;
    }

    if (!fAtLeastOneRange)
    {
        //
        // Syntactically invalid, ignore the range header
        //
        *pfHandled = FALSE;
        return S_OK;
    }

    if (cRanges == 0)
    {
        //
        // No byte ranges are satisfiable
        //
        pResponse->ClearHeaders();
        pResponse->SetStatus(HttpStatusRangeNotSatisfiable);

        CHAR pszContentRange[24];
        strcpy(pszContentRange, "bytes */");
        _i64toa(liFileSize.QuadPart, pszContentRange + 8, 10);
        if (FAILED(hr = pResponse->SetHeader(HttpHeaderContentRange,
                                             pszContentRange,
                                             strlen(pszContentRange))))
        {
            return hr;
        }

        *pfHandled = TRUE;
        return S_OK;
    }

    *pfHandled = TRUE;
    pResponse->SetStatus(HttpStatusPartialContent);
    STRA *pstrContentType = pW3Context->QueryUrlContext()->QueryUrlInfo()->
        QueryContentType();

    STACK_STRA ( strPartContentType, 128);
    if (cRanges == 1)
    {
        //
        // Only one chunk, Content-Type is same as that of complete entity
        //
        if (FAILED(hr = pResponse->SetHeaderByReference(
                            HttpHeaderContentType,
                            pstrContentType->QueryStr(),
                            pstrContentType->QueryCCH())))
        {
            return hr;
        }
    }
    else
    {
        //
        // Content-Type is multipart/byteranges; boundary=....
        //
        if (FAILED(hr = pResponse->SetHeaderByReference(
                            HttpHeaderContentType,
                            sm_pstrRangeContentType->QueryStr(),
                            sm_pstrRangeContentType->QueryCCH())))
        {
            return hr;
        }

        //
        // The actual content-type of the entity to be sent with each part
        //
        if (FAILED(hr = strPartContentType.Copy("Content-Type: ")) ||
            FAILED(hr = strPartContentType.Append(*pstrContentType)) ||
            FAILED(hr = strPartContentType.Append("\r\n")))
        {
            return hr;
        }
    }

    //
    // build the response
    //
    STRA strContentRange;
    STRA strDelimiter;
    pByteRange = (HTTP_BYTE_RANGE *)bufByteRange.QueryPtr();
    for (DWORD i = 0; i < cRanges; i++)
    {
        liRangeOffset = pByteRange[i].StartingOffset;
        liRangeSize   = pByteRange[i].Length;

        //
        // Build up the Content-Range header
        //
        CHAR pszSize[24];
        if (FAILED(hr = strContentRange.Copy("bytes ")))
        {
            return hr;
        }
        _i64toa(liRangeOffset.QuadPart, pszSize, 10);
        if (FAILED(hr = strContentRange.Append(pszSize)) ||
            FAILED(hr = strContentRange.Append("-")))
        {
            return hr;
        }
        _i64toa(liRangeOffset.QuadPart + liRangeSize.QuadPart - 1,
                pszSize, 10);
        if (FAILED(hr = strContentRange.Append(pszSize)) ||
            FAILED(hr = strContentRange.Append("/")))
        {
            return hr;
        }
        _i64toa(liFileSize.QuadPart, pszSize, 10);
        if (FAILED(hr = strContentRange.Append(pszSize)))
        {
            return hr;
        }

        if (cRanges == 1)
        {
            //
            // If only one chunk, send Content-Range as a header
            //
            if (FAILED(hr = pResponse->SetHeader(HttpHeaderContentRange,
                                                 strContentRange.QueryStr(),
                                                 strContentRange.QueryCCH())))
            {
                return hr;
            }
        }
        else
        {
            if (i > 0)
            {
                // Already sent a range, add a newline
                if (FAILED(hr = strDelimiter.Copy("\r\n", 2)))
                {
                    return hr;
                }
            }

            //
            // Add delimiter, Content-Type, Content-Range
            //
            if (FAILED(hr = strDelimiter.Append(*sm_pstrRangeMidDelimiter)) ||
                FAILED(hr = strDelimiter.Append(strPartContentType)) ||
                FAILED(hr = strDelimiter.Append("Content-Range: ", 15)) ||
                FAILED(hr = strDelimiter.Append(strContentRange)) ||
                FAILED(hr = strDelimiter.Append("\r\n\r\n", 4)))
            {
                return hr;
            }

            //
            // store the ANSI version in the BUFFER chain
            //
            DWORD bufSize = strDelimiter.QueryCCH() + 1;
            BUFFER_CHAIN_ITEM *pBCI = new BUFFER_CHAIN_ITEM(bufSize);
            if (pBCI == NULL)
            {
                return HRESULT_FROM_WIN32(ERROR_NOT_ENOUGH_MEMORY);
            }
            memcpy(pBCI->QueryPtr(),
                   strDelimiter.QueryStr(),
                   bufSize);
            if (!m_RangeBufferChain.AppendBuffer(pBCI))
            {
                return HRESULT_FROM_WIN32(GetLastError());
            }

            //
            // Now actually add this delimiter chunk
            //
            if (FAILED(hr = pResponse->AddMemoryChunkByReference(
                                           pBCI->QueryPtr(),
                                           bufSize - 1)))
            {
                return hr;
            }
        }

        //
        // Add the actual file chunk
        //
        if (pOpenFile->QueryFileBuffer() != NULL &&
            liRangeSize.HighPart == 0 &&
            liRangeOffset.HighPart == 0)
        {
            hr = pResponse->AddMemoryChunkByReference(
                     pOpenFile->QueryFileBuffer() + liRangeOffset.LowPart,
                     liRangeSize.LowPart);
        }
        else
        {
            hr = pResponse->AddFileHandleChunk( pOpenFile->QueryFileHandle(),
                                                liRangeOffset.QuadPart,
                                                liRangeSize.QuadPart );
        }

        if (FAILED(hr))
        {
            return hr;
        }
    }

    if (cRanges > 1)
    {
        //
        // Add the terminating delimiter
        //
        if (FAILED(hr = pResponse->AddMemoryChunkByReference(
                            sm_pstrRangeEndDelimiter->QueryStr(),
                            sm_pstrRangeEndDelimiter->QueryCCH())))
        {
            return hr;
        }
    }

    return S_OK;
}