/* ------------------------------------------------------------------
 * Copyright (C) 1998-2009 PacketVideo
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
 * express or implied.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 * -------------------------------------------------------------------
 */

#include "rtsp_par_com.h"
#include "oscl_string_utils.h"
#include "rtsp_range_utils.h"

OSCL_EXPORT_REF void
RTSPIncomingMessage::reset()
{
    RTSPGenericMessage::reset();

#ifdef RTSP_PLAYLIST_SUPPORT
    playlistRangeField.setPtrLen("", 0);
    playlistRangeFieldIsSet = false;
    // need to figure out how to store all the error fields.. we may not actually need to
    playlistErrorFieldIsSet = false;
    playlistErrorFieldCount = 0;
    for (int ii = 0; ii < RTSP_MAX_NUMBER_OF_PLAYLIST_ERROR_ENTRIES; ++ii)
    {
        playlistErrorField[ii].setPtrLen("", 0);
    }

    supportedFieldIsSet = false;
    numOfSupportedEntries = 0;
    for (int jj = 0; jj < RTSP_MAX_NUMBER_OF_SUPPORTED_ENTRIES; ++jj)
    {
        supportedField[jj].setPtrLen("", 0);
    }

    playlistRangeUrl.setPtrLen("", 0);
    playlistRangeClipIndex = 0;
    playlistRangeClipOffset = 0;
    playlistRangeNptTime = 0;
#endif

    amMalformed = RTSPOk;
    rtspVersionString = "";
}

void
RTSPIncomingMessage::parseFirstFields()
{

    char * endOfString;

    // The first thing to do is to parse the status line;
    // the rest of the parsing (regular fields) can be parsed out by
    // parseNextPortion() method, since it has to know how to do that anyway.
    // We also have to find out if Content-length is there, etc.

    // so, let's set up the pointers first
    //
    secondaryBufferSpace = secondaryBuffer;
    if (CHAR_CR == *secondaryBufferSpace)
    {
        ++secondaryBufferSpace;
    }
    if (CHAR_LF == *secondaryBufferSpace)
    {
        ++secondaryBufferSpace;
    }

#ifdef SIMPLE_HTTP_SUPPORT
    if (secondaryBufferSizeUsed >= 4)
    {// Real http cloaking. H\02\00\00
        if (('H' != secondaryBufferSpace[0])
                || ('T' != secondaryBufferSpace[1])
                || ('T' != secondaryBufferSpace[2])
                || ('P' != secondaryBufferSpace[3])
           )
        {
            if ('H' == secondaryBufferSpace[0])
            {//HTTP_RESPONSE
                uint32 nOptionLen = secondaryBufferSpace[1];
                secondaryBufferSpace += (2 + nOptionLen);
            }
            /* TBD
            else if('r' == secondaryBufferSpace[0])
            {//HTTP_RV_RESPONSE
            }
            */
        }
    }
#endif

    numPtrFields = 0;

    char * wordPtr[3] = { NULL, NULL, NULL };
    char * endOfLine;
    int   wordCount;
    bool  wordCountTrigger;

    for (endOfLine = secondaryBufferSpace, wordCount = 0, wordCountTrigger = true;
            (endOfLine < secondaryBufferSpace + secondaryBufferSizeUsed)
            && (CHAR_CR != *endOfLine)
            && (CHAR_LF != *endOfLine);
            ++endOfLine
        )
    {
        switch (wordCountTrigger)
        {
            case true:  // if non-space, then it's a beginning of a new word
            {
                if ((*endOfLine >= 0x09 && *endOfLine <= 0x0D) || *endOfLine == 0x20)
                { // spaces
                }
                else
                { // word
                    if (3 > wordCount)
                    {
                        wordPtr[wordCount] = endOfLine;
                    }
                    ++wordCount;

                    // uncock the trigger
                    wordCountTrigger = false;
                }

                break;
            }

            case false: // if space, then cock the trigger
            {
                if ((*endOfLine >= 0x09 && *endOfLine <= 0x0D) || *endOfLine == 0x20)
                { // yeah, space
                    wordCountTrigger = true;
                }
                else
                { // still a word
                }
                break;
            }

            default:
                // ERROR: internal inconsistency, a switch on a boolean should not hit
                // this point
                ;;
        }
    }

    if (3 > wordCount)
    { // only two words in the status line - error

        amMalformed = RTSPErrorSyntax;
        return;
    }

    if (CHAR_CR == *endOfLine)
    {
        *(endOfLine++) = CHAR_NULL;
        if (CHAR_LF == *endOfLine)
        {
            *(endOfLine++) = CHAR_NULL;
        }
    }
    else if (CHAR_LF == *endOfLine)
    {
        *(endOfLine++) = CHAR_NULL;
    }
    else
    {
        // ran to the end of input, didn't find a single newline....
        // most probably the message was too big to handle, but parser still
        // created a message hoping that at least something can be found...
        //

        amMalformed = RTSPErrorSyntax;

        return;
    }


    // figure out the format of the message - request or response?
    //
    // make out the first word... don't forget about '$'
    //

////  endOfString = secondaryBufferSpace;
////  while( ! isspace(*endOfString) )
////    ++endOfString;

    endOfString = wordPtr[1];
    while (--endOfString >= secondaryBufferSpace
            && ((*endOfString >= 0x09 && *endOfString <= 0x0D) || *endOfString == 0x20)
          )
    {
        *endOfString = CHAR_NULL;
    }

////  *endOfString = CHAR_NULL;
////  StrCSumPtrLen firstWordPLSS = secondaryBufferSpace;
    StrCSumPtrLen firstWordPLSS = wordPtr[0];

    if (('R' == *(wordPtr[0]))
            && ('T' == *(wordPtr[0] + 1))
            && ('S' == *(wordPtr[0] + 2))
            && ('P' == *(wordPtr[0] + 3))
            && ('/' == *(wordPtr[0] + 4))
       )
    {
        // it has to be a response
        //
        msgType = RTSPResponseMsg;
        rtspVersionString = firstWordPLSS;

        // if there is a mismatch, let the Engine know about it and stop parsing
        if (rtspVersionString != RTSPVersionString)
        {
            amMalformed = RTSPErrorVersion;
            return;
        }

        // get the code
////      secondaryBufferSpace = endOfString+1;
////     while( isspace(*secondaryBufferSpace) )
////      {
////          ++secondaryBufferSpace;
////        }

////      statusCode = atoi( secondaryBufferSpace );
        uint32 atoi_tmp;
        PV_atoi(wordPtr[1], 'd', atoi_tmp);
        statusCode = (RTSPStatusCode)atoi_tmp;

        // get the reason string

////      while( ! isspace( *secondaryBufferSpace ) )
////        {
////          ++secondaryBufferSpace;
////        }

////      while( isspace( *secondaryBufferSpace ) )
////        {
////          ++secondaryBufferSpace;
////        }

////      endOfString = secondaryBufferSpace;
////      while(            (CHAR_CR != *endOfString)
////                                &&  (CHAR_LF != *endOfString)
////                                )
////        {
////          ++endOfString;
////        }

////      *endOfString = CHAR_NULL;
////      reasonString = secondaryBufferSpace;
        reasonString = wordPtr[2];

        // now, resync to the next line
////      secondaryBufferSpace = endOfString+1;
////      if( CHAR_LF == *secondaryBufferSpace )
////        {
////          ++secondaryBufferSpace;
////        }

        secondaryBufferSpace = endOfLine;
    }
#ifdef SIMPLE_HTTP_SUPPORT
    else if (('H' == *(wordPtr[0]))
             && ('T' == *(wordPtr[0] + 1))
             && ('T' == *(wordPtr[0] + 2))
             && ('P' == *(wordPtr[0] + 3))
             && ('/' == *(wordPtr[0] + 4))
            )
    {
        msgType = RTSPResponseMsg;
        rtspVersionString = firstWordPLSS;

        // if there is a mismatch, let the Engine know about it and stop parsing
        if ((rtspVersionString != HTTPVersion_1_0_String)
                && (rtspVersionString != HTTPVersion_1_1_String))
        {
            amMalformed = RTSPErrorVersion;
            return;
        }
        uint32 atoi_tmp;
        PV_atoi(wordPtr[1], 'd', atoi_tmp);
        statusCode = (RTSPStatusCode)atoi_tmp;
        reasonString = wordPtr[2];
        secondaryBufferSpace = endOfLine;
    }
#endif
    else
    {   // okay, it could be a request

        // but for requests there must be exactly three words on the
        // status line
        if (3 != wordCount)
        {
            amMalformed = RTSPErrorSyntax;
            return;
        }

        msgType = RTSPRequestMsg;

        methodString = firstWordPLSS;

        if (firstWordPLSS == RtspRequestMethodStringDescribe)
        {
            method = METHOD_DESCRIBE;
        }
        else if (firstWordPLSS == RtspRequestMethodStringGetParameter)
        {
            method = METHOD_GET_PARAMETER;
        }
        else if (firstWordPLSS == RtspRequestMethodStringOptions)
        {
            method = METHOD_OPTIONS;
        }
        else if (firstWordPLSS == RtspRequestMethodStringPause)
        {
            method = METHOD_PAUSE;
        }
        else if (firstWordPLSS == RtspRequestMethodStringPlay)
        {
            method = METHOD_PLAY;
        }
        else if (firstWordPLSS == RtspRequestMethodStringSetup)
        {
            method = METHOD_SETUP;
        }
        else if (firstWordPLSS == RtspRequestMethodStringRecord)
        {
            method = METHOD_RECORD;
        }
        else if (firstWordPLSS == RtspRequestMethodStringTeardown)
        {
            method = METHOD_TEARDOWN;
        }
        else if (firstWordPLSS == RtspRequestMethodStringEndOfStream)
        {
            method = METHOD_END_OF_STREAM;
        }
        /* TBD: add Announce, SetParameter and Redirect later
        else if( firstWordPLSS == RtspRequestMethodStringAnnounce )
          {
            method = METHOD_ANNOUNCE;
          }
        */
        else if (firstWordPLSS == RtspRequestMethodStringSetParameter)
        {
            method = METHOD_SET_PARAMETER;
        }

        else if (firstWordPLSS == RtspRequestMethodStringRedirect)  //SS
        {
            method = METHOD_REDIRECT; ////SS
        }
        // now, we could put binary data here, but it's not exactly the same
        // thing; since it requires special care, let's not confuse things by
        // putting generic-looking stuff here
        else
        {
            method = METHOD_UNRECOGNIZED;
        }

        // get the URI

////      secondaryBufferSpace = endOfString +1;
////      while( isspace( *secondaryBufferSpace ) )
////        {
////          ++secondaryBufferSpace;
////        }

////      endOfString = secondaryBufferSpace;
////      while( ! isspace( *endOfString ) )
////        {
////          ++endOfString;
////        }
////      *endOfString = CHAR_NULL;

////      originalURI = secondaryBufferSpace;
        endOfString = wordPtr[2];
        while ((--endOfString) >= wordPtr[1]
                && ((*endOfString >= 0x09 && *endOfString <= 0x0D) || *endOfString == 0x20)
              )
        {
            *endOfString = CHAR_NULL;
        }
        originalURI = wordPtr[1];

        // get the RTSP version
////      secondaryBufferSpace = endOfString +1;
////      while( isspace( *secondaryBufferSpace ) )
////        {
////          ++secondaryBufferSpace;
////        }
////      endOfString = secondaryBufferSpace;
////      while( !isspace(*endOfString) )
////        {
////          ++endOfString;
////        }

////      *endOfString = CHAR_NULL;
////      rtspVersionString = secondaryBufferSpace;
        endOfString = endOfLine;
        while (--endOfString >= wordPtr[2]
                && (((*endOfString >= 0x09 && *endOfString <= 0x0D) || *endOfString == 0x20)
                    ||  CHAR_NULL == *endOfString
                   )
              )
        {
            *endOfString = CHAR_NULL;
        }
        rtspVersionString = wordPtr[2];

        // if there is a mismatch, let the Engine know about it and stop parsing
        if (rtspVersionString != RTSPVersionString)
        {
            amMalformed = RTSPErrorVersion;
            return;
        }

        // now, resync to the next line
////      secondaryBufferSpace = endOfString + 1;
////      if( CHAR_LF == *secondaryBufferSpace )
////        {
////          ++secondaryBufferSpace;
////        }
        secondaryBufferSpace = endOfLine;

        // extra URI validation
        {
            if (1 == originalURI.length())
            { // Is it a star
                if (CHAR_STAR != originalURI.c_str()[0])
                {
                    amMalformed = RTSPErrorSyntax;
                    return;
                }
            }
            else
            { // it's a normal URI

                // let's validate the scheme
                char colonStr[2];
                colonStr[0] = CHAR_COLON;
                colonStr[1] = NULL_TERM_CHAR;
                const char * colonPtr = oscl_strstr(originalURI.c_str(), colonStr);
                if (NULL == colonPtr)
                {
                    // no colon
                    amMalformed = RTSPErrorSyntax;
                    return;
                }

                // now, the first character of the scheme is a character
                const char * ptr = originalURI.c_str();
                if (!((*ptr >= 'A' && *ptr <= 'Z') || (*ptr >= 'a' && *ptr <= 'z')))

                {
                    // the URI doesn't start with a character
                    amMalformed = RTSPErrorSyntax;
                    return;
                }

                // the rest of the characters must be either characters, or
                // plus/minus, or dots...
                for (++ptr; ptr < colonPtr; ++ptr)
                {
                    if (!(((*ptr >= 'A' && *ptr <= 'Z') || (*ptr >= 'a' && *ptr <= 'z'))
                            || (*ptr >= '0' || *ptr <= '9')
                            ||  CHAR_PLUS == *ptr
                            ||  CHAR_MINUS == *ptr
                            ||  CHAR_DOT == *ptr
                         ))
                    {
                        amMalformed = RTSPErrorSyntax;
                        return;
                    }
                }
            }
        }

        // finish off the URI processing

        {
            // look for the base
            uint32  ii;
            int32   ee;
            uint32 length = originalURI.length();

            for (ii = 0; ii < length; ++ii)
            {
                if (CHAR_SLASH == originalURI.c_str()[ii])
                {
                    if (CHAR_SLASH != originalURI.c_str()[++ii])
                    {
                        break;
                    }
                    else
                    { // no, it's a separator, skip over it, continue
                    }
                }
            }
            originalURIBase = originalURI.c_str() + ii;

            // look for the control candidate
            for (ee = originalURIBase.length() - 1;
                    ee >= 0;
                    --ee
                )
            {
                if ((CHAR_SLASH      ==  originalURIBase.c_str()[ee])
                        || (CHAR_SEMICOLON  ==  originalURIBase.c_str()[ee])
                   )
                {
                    break;
                }
            }
            originalURIControlCandidate = originalURIBase.c_str() + ee + 1;

        }
    }


    // determine the total number of fields remaining to be seen

    endOfString = secondaryBuffer + secondaryBufferSizeUsed;
    *(--endOfString) = CHAR_NULL;
    --secondaryBufferSizeUsed;
    if (CHAR_CR == *(endOfString - 1))
    {
        *(--endOfString) = CHAR_NULL;
        --secondaryBufferSizeUsed;
    }


    totalFields = 0;
    for (char * ptr = secondaryBufferSpace; ptr < endOfString; ++ptr)
    {
        if (CHAR_LF == *ptr)
        {
            ++totalFields;
        }
        else if (CHAR_CR == *ptr)
        {
            if (CHAR_LF != *(ptr + 1))
            {
                ++totalFields;
            }
        }
    }

    totalFieldsParsed = 0;
    parseNextPortion();

    if (getTotalFields() != getTotalFieldsParsed())
    {
        amMalformed = RTSPErrorTooManyFields;
    }
}

bool
RTSPIncomingMessage::parseNextPortion()
{
    if (totalFieldsParsed == totalFields)
    {
        return false;
    }

    char * endOfMessage = secondaryBuffer + secondaryBufferSizeUsed;
    char * ptr = secondaryBufferSpace;

    //  printf ("parcom::parseNextPortion: secondaryBuffer is \n %s \n",secondaryBuffer);


    for (numPtrFields = 0;
            (numPtrFields < RTSP_MAX_NUMBER_OF_FIELDS) && (ptr < endOfMessage);
            ++numPtrFields)
    {
        char *endOfValue = ptr;
        while (CHAR_LF != *(endOfValue)
                &&  CHAR_CR != *(endOfValue)
                &&  CHAR_NULL != *(endOfValue))
        {
            ++endOfValue;
        }

        if (CHAR_CR == *(endOfValue) && CHAR_LF == *(endOfValue + 1))
        {
            // need to increment endOfValue for CR-LF, because
            // it is needed later to step into the next field by shifting by 1
            *(endOfValue) = CHAR_NULL;
            *(++endOfValue) = CHAR_NULL;
        }
        else
        {
            *endOfValue = CHAR_NULL;
        }

        char * separator = ptr;

        while ((CHAR_COLON != *separator)   && (CHAR_NULL != *separator))
        {
            ++separator;
        }

        if (CHAR_COLON != *separator)
        {
            //amMalformed = RTSPErrorSyntax;
            //ignore the unknown lines
            ptr = endOfValue + 1;
            continue;
        }
        else
        {
            *separator = CHAR_NULL;

            // get name pointer
            char * namePtr = ptr;
            // eat through trailing whitespace
            for (char * wPtr1 = separator - 1;
                    (wPtr1 >= namePtr) && ((*wPtr1 >= 0x09 && *wPtr1 <= 0x0D) || *wPtr1 == 0x20);
                    --wPtr1)
            {
                *wPtr1 = CHAR_NULL;
            }
            // eat through leading whitespace
            while ((*namePtr >= 0x09 && *namePtr <= 0x0D) || *namePtr == 0x20)
            {
                ++namePtr;
            }

            // get value pointer
            char * valuePtr = separator + 1;
            // eat through trailing whitespace
            for (char * wPtr2 = endOfValue - 1;
                    (wPtr2 > separator)
                    && ((*wPtr2 >= 0x09 && *wPtr2 <= 0x0D) || *wPtr2 == 0x20);
                    --wPtr2)
            {
                *wPtr2 = CHAR_NULL;
            }
            //eat through leading whitespace
            while ((*valuePtr >= 0x09 && *valuePtr <= 0x0D) || *valuePtr == 0x20)
            {
                ++valuePtr;
            }

            // all right, set the pointers

            fieldKeys[ numPtrFields ] = namePtr;
            fieldVals[ numPtrFields ] = valuePtr;

            // determine if we are supposed to recognize this
            if (fieldKeys[ numPtrFields ].isCIEquivalentTo(
                        RtspRecognizedFieldSessionId))
            {
                {
                    StrPtrLen tmp = fieldVals[ numPtrFields ];
                    int Len = tmp.length();
                    char * beginPtr = (char*)tmp.c_str();
                    char * endPtr = beginPtr + Len;

                    while (beginPtr < endPtr)
                    {
                        if (*beginPtr == ';')
                        {//we got timeout field
                            while (beginPtr < endPtr)
                            {
                                if ((*beginPtr == 't') && (beginPtr[6] == 't'))
                                {//a little bit validation
                                    beginPtr += 8;
                                    PV_atoi(beginPtr, 'd', timeout);
                                    beginPtr = endPtr;
                                }
                                beginPtr++;
                            }
                        }
                        beginPtr++;
                    }
                }
                sessionId = fieldVals[ numPtrFields ];
                sessionIdIsSet = true;
            }
            if (fieldKeys[ numPtrFields ].isCIEquivalentTo(
                        RtspRecognizedFieldCSeq))
            {
                PV_atoi(valuePtr, 'd', cseq);
                cseqIsSet = true;
            }
            if (fieldKeys[ numPtrFields ].isCIEquivalentTo(
                        RtspRecognizedFieldBufferSize
                    ))
            {
                PV_atoi(valuePtr, 'd', bufferSize);
                bufferSizeIsSet = true;
            }
            if (fieldKeys[ numPtrFields ].isCIEquivalentTo(
                        RtspRecognizedFieldContentType))
            {
                contentType = fieldVals[ numPtrFields ];
                contentTypeIsSet = true;
            }
            if (fieldKeys[ numPtrFields ].isCIEquivalentTo(
                        RtspRecognizedFieldContentBase))
            {
                contentBase = fieldVals[ numPtrFields ];
                contentBaseMode = CONTENT_BASE_SET;
            }
            if (fieldKeys[ numPtrFields ].isCIEquivalentTo(
                        RtspRecognizedFieldContentLength))
            {
                PV_atoi(valuePtr, 'd', contentLength);
                contentLengthIsSet = true;
            }
            if (fieldKeys[ numPtrFields].isCIEquivalentTo(
                        RtspRecognizedFieldUserAgent))
            {
                userAgent = fieldVals[ numPtrFields ];
                userAgentIsSet = true;
            }
            if (fieldKeys[ numPtrFields ].isCIEquivalentTo(
                        RtspRecognizedFieldAccept))
            {
                accept = fieldVals[ numPtrFields ];
                acceptIsSet = true;
            }
            if (fieldKeys[ numPtrFields ].isCIEquivalentTo(
                        RtspRecognizedFieldRequire))
            {
                require = fieldVals[ numPtrFields ];
                requireIsSet = true;
            }
            if (fieldKeys[ numPtrFields ].isCIEquivalentTo(
                        RtspRecognizedFieldRTPInfo
                    ))
            {
                parseRTPInfo(numPtrFields);
            }

            if (fieldKeys[ numPtrFields ].isCIEquivalentTo(
                        RtspRecognizedFieldRange))
            {
                parseRtspRange(fieldVals[ numPtrFields].c_str(), fieldVals[ numPtrFields].length(), range);
                rangeIsSet = true;
            }
            if (fieldKeys[ numPtrFields ].isCIEquivalentTo(
                        RtspRecognizedFieldTransport))
            {
                parseTransport(numPtrFields);
            }
#ifdef RTSP_PLAYLIST_SUPPORT
            if (fieldKeys[ numPtrFields ].isCIEquivalentTo(
                        RtspRecognizedFieldSupported))
            {
                parseSupported(fieldVals[ numPtrFields].c_str(), fieldVals[ numPtrFields].length() + 1);
                supportedFieldIsSet = true;
            }
#endif
        }

        ptr = endOfValue + 1;
    }

    totalFieldsParsed += numPtrFields;

    secondaryBufferSpace = ptr;

    return true;
}

#ifdef RTSP_PLAYLIST_SUPPORT

void
RTSPIncomingMessage::parseSupported(const char *supportedString, int length)
{
    const StrPtrLen methodEosString("method.eos");
    const StrPtrLen comPvPlaylistString("com.pv.server_playlist");

    const char *end = supportedString + length;

    char *sptr;//, *eptr;

    sptr = (char*)supportedString;

    while ((sptr < end) && (numOfSupportedEntries < RTSP_MAX_NUMBER_OF_SUPPORTED_ENTRIES))
    {
        char * separator = sptr;

        while ((CHAR_COMMA != *separator)
                && (CHAR_NULL != *separator)
                && (separator < end)
              )
        {
            ++separator;
        }

        if (CHAR_COMMA == *separator)
        {
            // make sure there is a terminating char
            // in the other case, there will already be one because its the end of the line
            // and the field parsing that called this function put one there
            *separator = CHAR_NULL;
        }

        // get name pointer
        char * namePtr = sptr;
        // eat through trailing whitespace
        for (char * wPtr1 = separator - 1;
                (wPtr1 >= namePtr)
                && ((*wPtr1 >= 0x09 && *wPtr1 <= 0x0D) || *wPtr1 == 0x20);
                --wPtr1)
        {
            *wPtr1 = CHAR_NULL;
        }
        // eat through leading whitespace
        while ((*namePtr >= 0x09 && *namePtr <= 0x0D) || *namePtr == 0x20)
        {
            ++namePtr;
        }

        supportedField[numOfSupportedEntries++] = namePtr;

        if (!oscl_strncmp(namePtr, methodEosString.c_str(), methodEosString.length()))
        {
            methodEosIsSet = true;
        }
        else if (!oscl_strncmp(namePtr, comPvPlaylistString.c_str(), comPvPlaylistString.length()))
        {
            comPvServerPlaylistIsSet = true;
        }

        sptr = separator + 1;

    }  // end while
}

#endif /* RTSP_PLAYLIST_SUPPORT */


// relevant constants
const int MIN_CHANNEL_VALUE = 0;
const int MAX_CHANNEL_VALUE = 255;
const int PORT_MIN_VALUE = 0;
const int PORT_MAX_VALUE = 65535;

#define interleaved_str "interleaved="
#define interleaved_str_len 12

#define client_port_str "client_port="
#define client_port_str_len 12

#define server_port_str "server_port="
#define server_port_str_len 12

#define ttl_str "ttl="
#define ttl_str_len 4

#define mode_str "mode="
#define mode_str_len 5

#define port_str "port="
#define port_str_len 5

#define layers_str "layers="
#define layers_str_len 7

#define ssrc_str "ssrc="
#define ssrc_str_len 5

#define destination_str "destination"
#define destination_str_len 11

void
RTSPIncomingMessage::parseTransport(uint16 fieldIdx)
{
    char * cPtr;
    char * finishPtr;

    cPtr = const_cast<char*>(fieldVals[ fieldIdx ].c_str());
    finishPtr = cPtr + fieldVals[ fieldIdx ].length();

    do
    {
        parseOneTransportEntry(cPtr, finishPtr);

    }
    while (RTSPOk == amMalformed
            &&  cPtr < finishPtr
          );
}


void
RTSPIncomingMessage::parseOneTransportEntry(char*& trans, char *final_end)
{
    const char *startPtr, *endPtr, *nxtPtr;
    char *transSepPtr;


    // check the counter
    //
    if (RTSP_MAX_NUMBER_OF_TRANSPORT_ENTRIES == numOfTransportEntries)
    { // limit reached
        amMalformed = RTSPErrorSyntax;  // should it be different?
        return;
    }

    RtspTransport* rtspTrans = transport + numOfTransportEntries;
    numOfTransportEntries++;

    startPtr = trans;

    if (*startPtr == ',')
    {
        // skip over any starting commas
        ++startPtr;
    }

    rtspTrans->appendIsSet = false;
    rtspTrans->channelIsSet = false;
    rtspTrans->client_portIsSet = false;
    rtspTrans->deliveryIsSet = false;
    rtspTrans->layersIsSet = false;
    rtspTrans->modeIsSet = false;
    rtspTrans->portIsSet = false;
    rtspTrans->profileIsSet = false;
    rtspTrans->protocolIsSet = false;
    rtspTrans->transportTypeIsSet = false;
    rtspTrans->server_portIsSet = false;
    rtspTrans->ttlIsSet = false;
    rtspTrans->destinationIsSet = false;


    // see if there is a tranport list separator
    transSepPtr = OSCL_CONST_CAST(char*, oscl_strstr(startPtr, ","));
    if (transSepPtr)
    {

        const char *quotePtr = oscl_strstr(startPtr, "\"");
        if (quotePtr && quotePtr < transSepPtr)
        {
            // this may be a comma in the mode list -- so find the end of the mode list
            const char *quote_end = oscl_strstr(quotePtr + 1, "\"");
            if (quote_end)
            {
                // look for another comma
                if (NULL != (transSepPtr = OSCL_CONST_CAST(char*, oscl_strstr(quote_end, ","))))
                {
                    // temporarily write a terminator to separate the transport specs.
                    *transSepPtr = '\0';
                }
            }
        }
        else
        {
            // temporarily write a terminator to separate the transport specs.
            *transSepPtr = '\0';
        }
    }


//  for (; startPtr < final_end && isspace(*startPtr); ++startPtr);
    for (; startPtr < final_end && ((*startPtr >= 0x09 && *startPtr <= 0x0D) || *startPtr == 0x20); ++startPtr);

    do
    {
        if (NULL == (endPtr = oscl_strstr(startPtr, "/")))
        {
            endPtr = final_end;
        }

        rtspTrans->protocolIsSet = true;

        if (!oscl_strncmp(startPtr, "RTP", endPtr - startPtr))
        {
            rtspTrans->protocol = RtspTransport::RTP_PROTOCOL;
        }
        else if (!oscl_strncmp(startPtr, "x-pn-tng", endPtr - startPtr))
        {
            rtspTrans->protocol = RtspTransport::RDT_PROTOCOL;
        }
        else
        {
            rtspTrans->protocol = RtspTransport::UNKNOWN_PROTOCOL;
        }

        if (endPtr == final_end)
        {
            break;
        }

        // increment the startPtr past the separator
        startPtr = endPtr + 1;

        // look for either the '/' or ';' separators
        endPtr = oscl_strstr(startPtr, "/");
        const char *endPtr2 = oscl_strstr(startPtr, ";");

        if (!endPtr)
        {
            endPtr = endPtr2;
        }

        if (endPtr2 && endPtr2 < endPtr)
        {
            endPtr = endPtr2;
        }

        if (!endPtr)
        {
            endPtr = final_end;
        }

        rtspTrans->profile = RtspTransport::UNKNOWN_PROFILE;
        rtspTrans->profileIsSet = true;
        if (!oscl_strncmp(startPtr, "AVP", endPtr - startPtr))
        {
            rtspTrans->profile = RtspTransport::AVP_PROFILE;
        }
        else if (!oscl_strncmp(startPtr, "tcp", endPtr - startPtr))
        {//RDT "x-pn-tng/tcp"
            rtspTrans->profile = RtspTransport::TCP_PROFILE;
        }

        if (*endPtr == '/')
        {
            // there is an optional transport spec
            startPtr = endPtr + 1;

            if (NULL == (endPtr = oscl_strstr(startPtr, ";")))
            {
                endPtr = final_end;
            }

            rtspTrans->transportType = RtspTransport::UNKNOWN_TRANSPORT;
            rtspTrans->transportTypeIsSet = true;

            if (!oscl_strncmp(startPtr, "UDP", endPtr - startPtr))
            {
                rtspTrans->transportType = RtspTransport::UDP_TRANSPORT;
            }
            else if (!oscl_strncmp(startPtr, "TCP", endPtr - startPtr))
            {
                rtspTrans->transportType = RtspTransport::TCP_TRANSPORT;
            }
        }

        if (endPtr == final_end)
        {
            break;
        }

        // increment the startPtr past the separator
        startPtr = endPtr + 1;

    }
    while (0); // only go through this once


    while (startPtr < final_end)
    {

        for (; startPtr < final_end && ((*startPtr >= 0x09 && *startPtr <= 0x0D) || *startPtr == 0x20); ++startPtr);

        char *sepPtr;
        // find the next separator
        if (NULL == (sepPtr = (char*)(endPtr = oscl_strstr(startPtr, ";"))))
        {
            endPtr = final_end;
        }

        if (sepPtr)
        {
            *sepPtr = '\0';
        }

        if (!oscl_strncmp(startPtr, "unicast", endPtr - startPtr))
        {
            rtspTrans->delivery = RtspTransport::UNICAST_DELIVERY;
            rtspTrans->deliveryIsSet = true;
        }
        if (!oscl_strncmp(startPtr, "multicast", endPtr - startPtr))
        {
            rtspTrans->delivery = RtspTransport::MULTICAST_DELIVERY;
            rtspTrans->deliveryIsSet = true;
        }
        else if (!oscl_strncmp(startPtr, "append", endPtr - startPtr))
        {
            rtspTrans->append = true;
            rtspTrans->appendIsSet = true;
        }
        else if (!oscl_strncmp(startPtr, destination_str,
                               destination_str_len))
        {
            nxtPtr = startPtr + destination_str_len;
            char *curEndPtr = OSCL_CONST_CAST(char*, oscl_strstr(nxtPtr, "="));
            if (curEndPtr)
            {
                nxtPtr = curEndPtr + 1;

                // skip leading whitespace
                for (; nxtPtr < endPtr && ((*nxtPtr >= 0x09 && *nxtPtr <= 0x0D) || *nxtPtr == 0x20); ++nxtPtr);

                // now find the end
                for (curEndPtr = (char*)nxtPtr; curEndPtr < endPtr && !((*curEndPtr >= 0x09 && *curEndPtr <= 0x0D) || *curEndPtr == 0x20);
                        ++curEndPtr);

                if (curEndPtr - nxtPtr > 0)
                {
                    if (curEndPtr < endPtr)
                    {
                        *curEndPtr = '\0';
                    }
                    else if (sepPtr)
                    {
                        // clear sepPtr so it won't overwrite the NULL character
                        sepPtr = NULL;
                    }
                    rtspTrans->destination.setPtrLen(nxtPtr,
                                                     curEndPtr - nxtPtr);
                    rtspTrans->destinationIsSet = true;
                }
            }

        }
        else if (!oscl_strncmp(startPtr, interleaved_str,
                               interleaved_str_len))
        {
            int tmp;
            nxtPtr = startPtr + interleaved_str_len;
            char *curEndPtr = OSCL_CONST_CAST(char*, oscl_strstr(nxtPtr, "-"));
            if (curEndPtr) *curEndPtr = '\0';
            uint32 atoi_tmp;
            PV_atoi(nxtPtr, 'd', atoi_tmp);
            tmp = atoi_tmp;
            if (tmp < MIN_CHANNEL_VALUE || tmp > MAX_CHANNEL_VALUE)
            {
                amMalformed = RTSPErrorSyntax;
                if (sepPtr)
                {
                    *sepPtr = ';';
                };
                break;
            }
            rtspTrans->channel1 = tmp;
            if (!curEndPtr)
            {
                if (rtspTrans->channel1 >= MAX_CHANNEL_VALUE)
                {
                    amMalformed = RTSPErrorSyntax;
                    if (sepPtr)
                    {
                        *sepPtr = ';';
                    };
                    break;
                }
                rtspTrans->channel2 = rtspTrans->channel1 + 1;
                rtspTrans->channelIsSet = true;
            }
            else
            {
                nxtPtr = curEndPtr + 1;
                *curEndPtr = '-';
                PV_atoi(nxtPtr, 'd', atoi_tmp);
                tmp = atoi_tmp;
                if (tmp < MIN_CHANNEL_VALUE || tmp > MAX_CHANNEL_VALUE)
                {
                    amMalformed = RTSPErrorSyntax;
                    if (sepPtr)
                    {
                        *sepPtr = ';';
                    };
                    break;
                }
                rtspTrans->channel2 = tmp;
                rtspTrans->channelIsSet = true;
            }
        }
        else if (!oscl_strncmp(startPtr, client_port_str,
                               client_port_str_len))
        {
            int tmp;
            uint32 atoi_tmp;
            nxtPtr = startPtr + client_port_str_len;
            char *curEndPtr = OSCL_CONST_CAST(char*, oscl_strstr(nxtPtr, "-"));
            if (curEndPtr) *curEndPtr = '\0';
            PV_atoi(nxtPtr, 'd', atoi_tmp);
            tmp = atoi_tmp;
            if (tmp < PORT_MIN_VALUE || tmp > PORT_MAX_VALUE)
            {
                amMalformed = RTSPErrorSyntax;
                if (sepPtr)
                {
                    *sepPtr = ';';
                };
                break;
            }
            rtspTrans->client_port1 = tmp;
            if (!curEndPtr)
            {
                if (rtspTrans->client_port1 >= PORT_MAX_VALUE)
                {
                    amMalformed = RTSPErrorSyntax;
                    if (sepPtr)
                    {
                        *sepPtr = ';';
                    };
                    break;
                }
                rtspTrans->client_port2 = rtspTrans->client_port1 + 1;
                rtspTrans->client_portIsSet = true;
            }
            else
            {
                nxtPtr = curEndPtr + 1;
                *curEndPtr = '-';
                PV_atoi(nxtPtr, 'd', atoi_tmp);
                tmp = atoi_tmp;
                if (tmp < PORT_MIN_VALUE || tmp > PORT_MAX_VALUE)
                {
                    amMalformed = RTSPErrorSyntax;
                    if (sepPtr)
                    {
                        *sepPtr = ';';
                    };
                    break;
                }
                rtspTrans->client_port2 = tmp;
                rtspTrans->client_portIsSet = true;
            }
        }
        else if (!oscl_strncmp(startPtr, server_port_str,
                               server_port_str_len))
        {
            int tmp;
            uint32 atoi_tmp;
            nxtPtr = startPtr + server_port_str_len;
            char *curEndPtr = OSCL_CONST_CAST(char*, oscl_strstr(nxtPtr, "-"));
            if (curEndPtr) *curEndPtr = '\0';
            PV_atoi(nxtPtr, 'd', atoi_tmp);
            tmp = atoi_tmp;
            if (tmp < PORT_MIN_VALUE || tmp > PORT_MAX_VALUE)
            {
                amMalformed = RTSPErrorSyntax;
                if (sepPtr)
                {
                    *sepPtr = ';';
                };
                break;
            }
            rtspTrans->server_port1 = tmp;
            if (!curEndPtr)
            {
                if (rtspTrans->server_port1 >= PORT_MAX_VALUE)
                {
                    amMalformed = RTSPErrorSyntax;
                    if (sepPtr)
                    {
                        *sepPtr = ';';
                    };
                    break;
                }
                rtspTrans->server_port2 = rtspTrans->server_port1 + 1;
                rtspTrans->server_portIsSet = true;
            }
            else
            {
                nxtPtr = curEndPtr + 1;
                *curEndPtr = '-';
                PV_atoi(nxtPtr, 'd', atoi_tmp);
                tmp = atoi_tmp;
                if (tmp < PORT_MIN_VALUE || tmp > PORT_MAX_VALUE)
                {
                    amMalformed = RTSPErrorSyntax;
                    if (sepPtr)
                    {
                        *sepPtr = ';';
                    };
                    break;
                }
                rtspTrans->server_port2 = tmp;
                rtspTrans->server_portIsSet = true;
            }
        }
        else if (!oscl_strncmp(startPtr, ttl_str, ttl_str_len))
        {
            nxtPtr = startPtr + ttl_str_len;
            int tmp;
            uint32 atoi_tmp;
            PV_atoi(nxtPtr, 'd', atoi_tmp);
            tmp = atoi_tmp;
            if (tmp < 0 || tmp > 255)
            {
                amMalformed = RTSPErrorSyntax;
                if (sepPtr)
                {
                    *sepPtr = ';';
                };
                break;
            }
            rtspTrans->ttl = tmp;
            rtspTrans->ttlIsSet = true;
        }
        else if (!oscl_strncmp(startPtr, mode_str, mode_str_len))
        {
            rtspTrans->mode.play_mode = false;
            rtspTrans->mode.record_mode = false;
            nxtPtr = startPtr + mode_str_len;
            rtspTrans->modeIsSet = true;
            char *quotePtr = NULL;
            const char *wordEndPtr;
            if (*nxtPtr == '\"')
            {
                ++nxtPtr;
                if (NULL != (quotePtr = OSCL_CONST_CAST(char*, oscl_strstr(nxtPtr, "\""))))
                {
                    *quotePtr = '\0';
                }
            }
            while (nxtPtr < endPtr)
            {
                if (NULL == (wordEndPtr = oscl_strstr(nxtPtr, ",")))
                {
                    wordEndPtr = endPtr;
                }

                if (!oscl_strncmp(nxtPtr, "PLAY", wordEndPtr - nxtPtr))
                {
                    rtspTrans->mode.play_mode = true;
                }
                else if (!oscl_strncmp(nxtPtr, "RECORD", wordEndPtr - nxtPtr))
                {
                    rtspTrans->mode.record_mode = true;
                }
                nxtPtr = wordEndPtr + 1;

            }

            if (quotePtr)
            {
                *quotePtr = '\"';
            }
        }
        else if (!oscl_strncmp(startPtr, port_str, port_str_len))
        {
            int tmp;
            uint32 atoi_tmp;
            nxtPtr = startPtr + port_str_len;
            char *curEndPtr = OSCL_CONST_CAST(char*, oscl_strstr(nxtPtr, "-"));
            if (curEndPtr) *curEndPtr = '\0';
            PV_atoi(nxtPtr, 'd', atoi_tmp);
            tmp = atoi_tmp;
            if (tmp < PORT_MIN_VALUE || tmp > PORT_MAX_VALUE)
            {
                amMalformed = RTSPErrorSyntax;
                if (sepPtr)
                {
                    *sepPtr = ';';
                };
                break;
            }
            rtspTrans->port1 = tmp;
            if (!curEndPtr)
            {
                if (rtspTrans->port1 >= PORT_MAX_VALUE)
                {
                    amMalformed = RTSPErrorSyntax;
                    if (sepPtr)
                    {
                        *sepPtr = ';';
                    };
                    break;
                }
                rtspTrans->port2 = rtspTrans->port1 + 1;
                rtspTrans->portIsSet = true;
            }
            else
            {
                nxtPtr = curEndPtr + 1;
                *curEndPtr = '-';
                PV_atoi(nxtPtr, 'd', atoi_tmp);
                tmp = atoi_tmp;
                if (tmp < PORT_MIN_VALUE || tmp > PORT_MAX_VALUE)
                {
                    amMalformed = RTSPErrorSyntax;
                    if (sepPtr)
                    {
                        *sepPtr = ';';
                    };
                    break;
                }
                rtspTrans->port2 = tmp;
                rtspTrans->portIsSet = true;
            }
        }
        else if (!oscl_strncmp(startPtr, layers_str, layers_str_len))
        {
            nxtPtr = startPtr + layers_str_len;
            PV_atoi(nxtPtr, 'd', rtspTrans->layers);
            rtspTrans->layersIsSet = true;
        }
        else if (!oscl_strncmp(startPtr, ssrc_str, ssrc_str_len))
        {
            nxtPtr = startPtr + ssrc_str_len;
            rtspTrans->ssrc = 0;
            rtspTrans->ssrcIsSet = false;
            if (!PV_atoi(nxtPtr, 'x', rtspTrans->ssrc))
            {
                amMalformed = RTSPErrorSyntax;
                if (sepPtr)
                {
                    *sepPtr = ';';
                };
                break;
            }
            rtspTrans->ssrcIsSet = true;
        }

        if (sepPtr)
        {
            *sepPtr = ';';
        }

        startPtr = endPtr + 1;

    }

    if (transSepPtr)
    {
        // put the separator character back
        *transSepPtr = ',';
        trans = transSepPtr;
    }
    else
    {
        trans = final_end;
    }

}

void
RTSPIncomingMessage::parseRTPInfo(uint16 fieldIdx)
{
    char * cPtr;
    char * finishPtr;

    cPtr = const_cast<char*>(fieldVals[ fieldIdx ].c_str());
    finishPtr = cPtr + fieldVals[ fieldIdx ].length();

    do
    {
        parseOneRTPInfoEntry(cPtr, finishPtr);

    }
    while (RTSPOk == amMalformed
            &&  cPtr < finishPtr
          );
}

void
RTSPIncomingMessage::parseOneRTPInfoEntry(char * & cPtr, char * finishPtr)
{
    bool   getOut;
    char * subFieldName;
    char * separator;
    char * endOfIt;

    // check the counter
    //
    if (RTSP_MAX_NUMBER_OF_RTP_INFO_ENTRIES == numOfRtpInfoEntries)
    { // limit reached
        amMalformed = RTSPErrorSyntax;  // should it be different?
        return;
    }
    ++numOfRtpInfoEntries;

    // skip comma, if necessary
    //
    if (CHAR_COMMA == *cPtr)
    {
        ++cPtr;
    }

    getOut = false;

    while ((!getOut) && cPtr < finishPtr && CHAR_COMMA != *cPtr)
    {
        // reset pointers

        subFieldName = NULL;
        separator = NULL;
        endOfIt = NULL;

        // skip whitespace

        while (cPtr < finishPtr
                && (CHAR_SPACE == *cPtr
                    || CHAR_TAB  == *cPtr
                    || CHAR_SEMICOLON == *cPtr
                    || CHAR_NULL == *cPtr
                   )
              )
        {
            ++cPtr;
        }
        if (cPtr >= finishPtr  || CHAR_COMMA  == *cPtr)
        {
            return;
        }

        // we see the beginning
        subFieldName = cPtr;

        // get the separator
        while (cPtr < finishPtr
                && CHAR_EQUAL != *cPtr
              )
        {
            ++cPtr;
        }
        if (cPtr >= finishPtr)
        {
            return;
        }
        // we see the separator
        separator = cPtr;

        // get the end of it
        while (cPtr < finishPtr
                && CHAR_SEMICOLON != *cPtr
                && CHAR_SPACE != *cPtr
                && CHAR_TAB != *cPtr
                && CHAR_COMMA != *cPtr
              )
        {
            ++cPtr;
        }

        endOfIt = cPtr;

        if (3 == separator - subFieldName)
        { // url?
            if (('u' == (subFieldName[0] | OSCL_ASCII_CASE_MAGIC_BIT))
                    && ('r' == (subFieldName[1] | OSCL_ASCII_CASE_MAGIC_BIT))
                    && ('l' == (subFieldName[2] | OSCL_ASCII_CASE_MAGIC_BIT))
               )
            {
                rtpInfo[ numOfRtpInfoEntries-1 ].url.setPtrLen(
                    separator + 1,
                    endOfIt - separator - 1
                );
                rtpInfo[ numOfRtpInfoEntries-1 ].urlIsSet = true;
                if (CHAR_COMMA == *endOfIt)
                {
                    getOut = true;
                }
                *endOfIt = CHAR_NULL;
                if (getOut)
                {
                    // skip ahead beyond the whitespace
                    // since we overwrote the comma with a NULL
                    while (cPtr < finishPtr
                            && (CHAR_SPACE == *cPtr
                                || CHAR_TAB  == *cPtr
                                || CHAR_SEMICOLON == *cPtr
                                || CHAR_NULL == *cPtr
                               )
                          )
                    {
                        ++cPtr;
                    }
                }
            }
            // or, maybe, seq?
            else if (('s' == (subFieldName[0] | OSCL_ASCII_CASE_MAGIC_BIT))
                     && ('e' == (subFieldName[1] | OSCL_ASCII_CASE_MAGIC_BIT))
                     && ('q' == (subFieldName[2] | OSCL_ASCII_CASE_MAGIC_BIT))
                    )
            {
                uint32 atoi_tmp;
                PV_atoi(separator + 1, 'd', atoi_tmp);
                rtpInfo[ numOfRtpInfoEntries-1 ].seq  = (RtpSeqType)atoi_tmp;

                rtpInfo[ numOfRtpInfoEntries-1 ].seqIsSet = true;
            }
            else
            {
                amMalformed = RTSPErrorSyntax;
                return;
            }
        }
        else if (7 == separator - subFieldName)
        { // rtptime?
            if (('r' == (subFieldName[0] | OSCL_ASCII_CASE_MAGIC_BIT))
                    && ('t' == (subFieldName[1] | OSCL_ASCII_CASE_MAGIC_BIT))
                    && ('p' == (subFieldName[2] | OSCL_ASCII_CASE_MAGIC_BIT))
                    && ('t' == (subFieldName[3] | OSCL_ASCII_CASE_MAGIC_BIT))
                    && ('i' == (subFieldName[4] | OSCL_ASCII_CASE_MAGIC_BIT))
                    && ('m' == (subFieldName[5] | OSCL_ASCII_CASE_MAGIC_BIT))
                    && ('e' == (subFieldName[6] | OSCL_ASCII_CASE_MAGIC_BIT))
               )
            {
                uint32 rtptime = 0;
                PV_atoi((separator + 1), 'd', rtptime);
                rtpInfo[ numOfRtpInfoEntries-1 ].rtptime = rtptime;
                rtpInfo[ numOfRtpInfoEntries-1 ].rtptimeIsSet = true;
            }
            else
            {
                amMalformed = RTSPErrorSyntax;
                return;
            }
        }

        else
        {
            amMalformed = RTSPErrorSyntax;
            return;
        }

        cPtr = endOfIt;
    }
}

#if (defined(ASF_STREAMING) || defined(RTSP_PLAYLIST_SUPPORT))
OSCL_EXPORT_REF bool
RTSPIncomingMessage::parseEntityBody(RTSPEntityBody * entityBody)
{
    char * endOfMessage = (char *) entityBody->ptr + entityBody->len;
    char * ptr;

    for (ptr = (char *) entityBody->ptr;
            ptr < endOfMessage ;
            ++numPtrFields
        )
    {
        char * endOfValue = ptr;
        while (CHAR_LF != *(endOfValue)
                &&  CHAR_CR != *(endOfValue)
                &&  CHAR_NULL != *(endOfValue))
        {
            ++endOfValue;
        }

        if (CHAR_CR == *(endOfValue) && CHAR_LF == *(endOfValue + 1))
        {
            // need to increment endOfValue for CR-LF, because
            // it is needed later to step into the next field by shifting by 1
            *(endOfValue) = CHAR_NULL;
            *(++endOfValue) = CHAR_NULL;
        }
        else
        {
            *endOfValue = CHAR_NULL;
        }

        char * separator = ptr;

        while ((CHAR_COLON != *separator)
                && (CHAR_NULL != *separator)
              )
        {
            ++separator;
        }

        if (CHAR_COLON != *separator)
        {
            amMalformed = RTSPErrorSyntax;
        }
        else
        {   // field is pretty much normal

            *separator = CHAR_NULL;

            // get name pointer
            char * namePtr = ptr;
            // eat through trailing whitespace
            for (char * wPtr1 = separator - 1;
                    (wPtr1 >= namePtr)
                    && ((*wPtr1 >= 0x09 && *wPtr1 <= 0x0D) || *wPtr1 == 0x20);
                    --wPtr1)
            {
                *wPtr1 = CHAR_NULL;
            }
            // eat through leading whitespace
            while ((*namePtr >= 0x09 && *namePtr <= 0x0D) || *namePtr == 0x20)
            {
                ++namePtr;
            }

            // get value pointer
            char * valuePtr = separator + 1;
            // eat through trailing whitespace
            for (char * wPtr2 = endOfValue - 1;
                    (wPtr2 > separator)
                    && ((*wPtr2 >= 0x09 && *wPtr2 <= 0x0D) || *wPtr2 == 0x20);
                    --wPtr2)
            {
                *wPtr2 = CHAR_NULL;
            }
            //eat through leading whitespace
            while ((*valuePtr >= 0x09 && *valuePtr <= 0x0D) || *valuePtr == 0x20)
            {
                ++valuePtr;
            }

            // set the pointers

            fieldKeys[ numPtrFields ] = namePtr;
            fieldVals[ numPtrFields ] = valuePtr;

            // now, figure out if we are supposed to recognize this
            if (fieldKeys[ numPtrFields ].isCIEquivalentTo(
                        RtspRecognizedFieldSessionId))
            {
                sessionId = fieldVals[ numPtrFields ];
                sessionIdIsSet = true;
            }
//RTSP_PAR_COM_CONSTANTS_H_
#define RtspRecognizedFieldEOF "EOF"

            if (fieldKeys[ numPtrFields ].isCIEquivalentTo(
                        RtspRecognizedFieldEOF))
            {
                eofField = fieldVals[ numPtrFields ];
                eofFieldIsSet = true;
            }
#ifdef RTSP_PLAYLIST_SUPPORT
            if (fieldKeys[ numPtrFields ].isCIEquivalentTo(
                        RtspRecognizedFieldPlaylistRange))
            {
                playlistRangeField = fieldVals[ numPtrFields ];  // not sure we really need to store this, but do it for now anyway
                playlistRangeFieldIsSet = true;
                // now parse the entry
                /*playlistRangeField.setPtrLen("",0);
                playlistRangeFieldIsSet = false;
                playlistErrorFieldIsSet = false;
                playlistErrorFieldCount = 0;
                playlistRangeUrl.setPtrLen("",0);
                playlistRangeClipIndex=0;
                playlistRangeClipOffset=0;
                playlistRangeNptTime=0;*/
                char* curr = valuePtr; // set curr to the start of the entry after the colon, whitespace was already removed
                StrPtrLen eStr;

                eStr = curr;
                // look for playlist_play_time
                const StrPtrLen RtspPlaylistPlayTimeStr = "playlist_play_time";
                if (0 && RtspPlaylistPlayTimeStr.isCIPrefixOf(eStr))
                {
                    curr += 18; // move past "playlist_play_time"
                    // eat through leading whitespace
                    while ((*curr >= 0x09 && *curr <= 0x0D) || *curr == 0x20)
                    {
                        ++curr;
                    }
                    if (*curr != CHAR_EQUAL)
                    {
                        // problem
                    }
                    // could be more whitespace
                    while ((*curr >= 0x09 && *curr <= 0x0D) || *curr == 0x20)
                    {
                        ++curr;
                    }
                    if (*curr != CHAR_LT)
                    {
                        // problem
                    }
                    ++curr; // move past '<'
                    // could be even more whitespace
                    while ((*curr >= 0x09 && *curr <= 0x0D) || *curr == 0x20)
                    {
                        ++curr;
                    }
                    // now comes the url
                    // find the end first
                    char* end = curr;
                    while (*end != CHAR_COMMA)
                    {
                        ++end;
                    }
                    char* endtmp = end;
                    // may have trailing whitespace
                    if (*(endtmp - 1) == 0x09 || *(endtmp - 1) == 0x0D || *(endtmp - 1) == 0x20)
                    {
                        --endtmp;
                        while ((*endtmp >= 0x09 && *endtmp <= 0x0D) || *endtmp == 0x20)
                        {
                            --endtmp;
                        }
                        // will be on a non space char, move it over
                        ++endtmp;
                    }
                    // to do - not sure if we need a '\0' here..
                    playlistRangeUrl.setPtrLen(curr, endtmp - curr);

                    curr = end + 1;
                    // next should be the clip index
                    // of course, could be more whitespace
                    while ((*curr >= 0x09 && *curr <= 0x0D) || *curr == 0x20)
                    {
                        ++curr;
                    }
                    // find next comma
                    end = curr;
                    while (*end != CHAR_COMMA)
                    {
                        ++end;
                    }
                    // may have trailing whitespace
                    // dont worry about it for now  atoi should be ok
                    /*if(*(end-1) == 0x09 ||*(end-1) == 0x0D ||*(end-1) == 0x20)
                    {
                    --end;
                    while( (*end >= 0x09 && *end <= 0x0D) || *end == 0x20 )
                    {
                    --end;
                    }
                    // will be on a non space char, move it over
                    ++end;
                    }*/
                    // finally get the value
                    uint32 atoi_tmp;
                    PV_atoi(curr, 'd', atoi_tmp);
                    playlistRangeClipIndex = atoi_tmp;

                    curr = end + 1;
                    // next should be the clip offset
                    // of course, could be more whitespace
                    while ((*curr >= 0x09 && *curr <= 0x0D) || *curr == 0x20)
                    {
                        ++curr;
                    }
                    // find next comma
                    end = curr;
                    while (*end != CHAR_GT)
                    {
                        ++end;
                    }
                    // may have trailing whitespace
                    // dont worry about it for now  atoi should be ok
                    /*if(*(end-1) == 0x09 ||*(end-1) == 0x0D ||*(end-1) == 0x20)
                    {
                    --end;
                    while( (*end >= 0x09 && *end <= 0x0D) || *end == 0x20 )
                    {
                    --end;
                    }
                    // will be on a non space char, move it over
                    ++end;
                    }*/
                    // finally get the value
                    PV_atoi(curr, 'd', atoi_tmp);
                    playlistRangeClipOffset = atoi_tmp;

                }
                else
                {
                    // problem
                }
            }
            if (fieldKeys[ numPtrFields ].isCIEquivalentTo(
                        RtspRecognizedFieldPlaylistError))
            {
                if (playlistErrorFieldCount < RTSP_MAX_NUMBER_OF_PLAYLIST_ERROR_ENTRIES)
                {
                    playlistErrorField[playlistErrorFieldCount++] = fieldVals[ numPtrFields ];  // this needs to be an array since the number can be unbounded
                    playlistErrorFieldIsSet = true;
                }
            }
#endif
        }
        ptr = endOfValue + 1;
    }
    return true;
}

#endif