parseutil.cpp

这是公司移植的UPNP协议

        node = list.next( node );       
        
    }
    
    if ( !inserted )
    {
        list.addAfterTail( value );
    }
}

void MediaRangeList::load( Tokenizer& scanner )
{
    ReadCommaSeparatedList( scanner, mediaList,
        0, -1, true, CreateMediaRange, AddMediaRangeToList );
}


// CommaSeparatedList
void CommaSeparatedList::toString( xstring& s )
{
    PrintCommaSeparatedList( valueList, s );
}

// add value sorted list; sorted descending 'q'
static void AddValueToSortedListCallback( HttpHeaderValueList& list,
    HttpHeaderValue *value )
{
    HttpQHeaderValue *a, *b;
    HttpHeaderValueNode* node;
    bool inserted = false;
    
    b = (HttpQHeaderValue *)value;
    
    node = list.getFirstItem();
    while ( node != NULL )
    {
        a = (HttpQHeaderValue*) node->data;
        if ( b->q > a->q )
        {
            list.addBefore( node, b );
            inserted = true;
            break;
        }

        node = list.next( node );       
    }
    
    if ( !inserted )
    {
        list.addAfterTail( value );
    }
}


void CommaSeparatedList::load( Tokenizer& scanner )
{
    AddValueToListCallback addCallback = NULL;
    
    if ( qUsed )
    {
        addCallback = AddValueToSortedListCallback;
    }
    
    ReadCommaSeparatedList( scanner, valueList,
        minItems, maxItems, qUsed, createCallback, addCallback );
}

// IdentifierValue
void IdentifierValue::toString( xstring& s )
{
    s += value;
}

void IdentifierValue::load( Tokenizer& scanner )
{
    Token* token;
    
    token = scanner.getToken();
    if ( token->tokType != Token::IDENTIFIER )
    {
        scanner.pushBack();
        throw HttpParseException(
            "IdentifierValue::load(): identifier expected",
            scanner.getLineNum() );
    }
    
    value = token->s;
}

// IdentifierQValue
void IdentifierQValue::toString( xstring& s )
{
    s += value;
    HttpQHeaderValue::toString( s );    // print q
}

void IdentifierQValue::load( Tokenizer& scanner )
{
    Token *token;
    
    token = scanner.getToken();
    if ( token->tokType != Token::IDENTIFIER )
    {
        scanner.pushBack();
        throw HttpParseException(
            "IdentifierQValue::load(): identifer expected",
            scanner.getLineNum() );
    }
    value = token->s;
    
    if ( qIsUsed )
    {
        loadOptionalQValue( scanner );
    }
}


// LanguageTag : public HttpHeaderValue
void LanguageTag::toString( xstring& s )
{
    s += lang;
    if ( qIsUsed )
    {
        HttpQHeaderValue::toString( s );
    }
}

void LanguageTag::load( Tokenizer& scanner )
{
    Token* token;
    
    token = scanner.getToken();
    if ( !ValidLanguageTag(token->s.c_str()) )
    {
        scanner.pushBack();
        DBG(
            UpnpPrintf( UPNP_INFO, MSERV, __FILE__, __LINE__,
                "invalid lang = %s\n", token->s.c_str()); )
        throw HttpParseException ( "LanguageTag::load() invalid language tag" );
    }

    if ( qIsUsed )
    {
        loadOptionalQValue( scanner );
    }
    
    lang = token->s;    
}

bool LanguageTag::setTag( const char* newLangTag )
{
    if ( !ValidLanguageTag(newLangTag) )
    {
        return false;
    }
    lang = newLangTag;
    return true;
}


// CacheDirective
void CacheDirective::toString( xstring& s )
{
    switch ( type )
    {
        case NO_CACHE:
            s += "no-cache";
            break;
            
        case NO_CACHE_FIELDS:
            s += "no-cache=";
            assert( fields.length() > 0 );
            s += fields;
            break;
            
        case NO_STORE:
            s += "no-store";
            break;
            
        case MAX_AGE:
            s += "max-age = ";
            assert( secondsValid );
            deltaSeconds.toString( s );
            break;
            
        case MAX_STALE:
            s += "max-stale";
            if ( secondsValid )
            {
                s += " = ";
                deltaSeconds.toString( s );
            }
            break;
            
        case MIN_FRESH:
            s += "min-fresh = ";
            assert( secondsValid );
            deltaSeconds.toString( s );
            break;
            
        case NO_TRANSFORM:
            s += "no-transform";
            break;
            
        case ONLY_IF_CACHED:
            s += "only-if-cached";
            break;
            
        case PUBLIC:
            s += "public";
            break;
            
        case PRIVATE:
            s += "private";
            if ( fields.length() > 0 )
            {
                s += " = ";
                s += fields;
            }
            break;
            
        case MUST_REVALIDATE:
            s += "must-revalidate";
            break;
            
        case PROXY_REVALIDATE:
            s += "proxy-revalidate";
            break;
            
        case S_MAXAGE:
            s += "max age = ";
            assert( secondsValid );
            deltaSeconds.toString( s );
            break;
            
        case EXTENSION:
            s += extensionName;
            s += " = ";
            if ( extType == IDENTIFIER )
            {
                s += extensionValue;
            }
            else if ( extType == QUOTED_STRING )
            {
                s += '"';
                s += extensionValue;
                s += '"';
            }
            else
            {
                assert( 0 );    // unknown type
            }
            break;
        
        case UNKNOWN:
        default:
            assert( 0 );
            break;
    }
}


void CacheDirective::load( Tokenizer& scanner )
{
    Token* token;

    // init
    secondsValid = false;
    fields = "";
    deltaSeconds.num = 0;
    extensionName = "";
    extensionValue = "";


    token = scanner.getToken();
    if ( token->tokType != Token::IDENTIFIER )
    {
        scanner.pushBack();
        throw HttpParseException( "CacheDirective::load() expected identifier",
            scanner.getLineNum() );
    }
    
    if ( token->s == "no-cache" )
    {
        bool fieldsRead;
        
        fieldsRead = readFields( scanner );
        if ( fieldsRead )
        {
            type = NO_CACHE_FIELDS;
        }
        else
        {
            type = NO_CACHE;
        }
    }
    else if ( token->s == "no-store" )
    {
        type = NO_STORE;
    }
    else if ( token->s == "max-age" )
    {
        type = MAX_AGE;
        readDeltaSeconds( scanner, false );
    }
    else if ( token->s == "max-stale" )
    {
        type = MAX_STALE;
        readDeltaSeconds( scanner, true );
    }
    else if ( token->s == "min-fresh" )
    {
        type = MIN_FRESH;
        readDeltaSeconds( scanner, false );
    }
    else if ( token->s == "no-transform" )
    {
        type = NO_TRANSFORM;
    }
    else if ( token->s == "only-if-cached" )
    {
        type = ONLY_IF_CACHED;
    }
    else if ( token->s == "public" )
    {
        type = PUBLIC;
    }
    else if ( token->s == "private" )
    {
        type = PRIVATE;
        readFields( scanner );
    }
    else if ( token->s == "must-revalidate" )
    {
        type = MUST_REVALIDATE;
    }
    else if ( token->s == "proxy-revalidate" )
    {
        type = PROXY_REVALIDATE;
    }
    else if ( token->s == "s-maxage" )
    {
        type = S_MAXAGE;
        readDeltaSeconds( scanner, false );
    }
    else
    {
        type = EXTENSION;
        extensionName = token->s;
        readExtension( scanner );
    }
}

// returns true if any fields were read
bool CacheDirective::readFields( Tokenizer& scanner )
{
    Token* token;

    SkipOptionalLWS( scanner );
    token = scanner.getToken();
    if ( token->s == '=' )
    {
        // match: '=' 1#fields
            
        SkipOptionalLWS( scanner );
        token = scanner.getToken();
        if ( token->tokType != Token::QUOTED_STRING )
        {
            scanner.pushBack();
            throw HttpParseException(
                "CacheDirective::load() expected quoted fields",
                scanner.getLineNum() );
        }

        fields = token->s;

        return true;

        /* ********** old code *************
        token = scanner.getToken();
        if ( token->s != '"' )
        {
            scanner.pushBack();
            throw HttpParseException(
                "CacheDirective::readFields() expected \" quote",
                scanner.getLineNum() );
        }
        SkipOptionalLWS( scanner );
        
        fields.load( scanner );
            
        SkipOptionalLWS( scanner );
        token = scanner.getToken();
        if ( token->s != '"' )
        {
            scanner.pushBack();
            throw HttpParseException(
                "CacheDirective:load() expected close quote",
                scanner.getLineNum() );
        }

        return true;
         ****************** old code end *******************/
    }
    else
    {
        scanner.pushBack();
        return false;
    }
}

void CacheDirective::readDeltaSeconds( Tokenizer& scanner, bool optional )
{
    Token* token;
    
    SkipOptionalLWS( scanner );
    
    token = scanner.getToken();
    if ( token->s == '=' )
    {
        SkipOptionalLWS( scanner );
        deltaSeconds.load( scanner );
        secondsValid = true;
    }
    else
    {
        scanner.pushBack();
        if ( !optional )
        {
            throw HttpParseException(
                "CacheDirective::readDeltaSeconds() expected =",
                scanner.getLineNum() );
        }
    }
}

void CacheDirective::readExtension( Tokenizer& scanner )
{
    Token* token;
    
    SkipOptionalLWS( scanner );
    
    token = scanner.getToken();
    if ( token->s != '=' )
    {
        scanner.pushBack();
        throw HttpParseException(
            "CacheDirective::readExtension() expected =",
            scanner.getLineNum() );
    }
    
    SkipOptionalLWS( scanner );
    
    token = scanner.getToken();
    if ( token->tokType == Token::IDENTIFIER )
    {
        extType = IDENTIFIER;
        extensionValue = token->s;
    }
    else if ( token->tokType == Token::QUOTED_STRING )
    {
        extType = QUOTED_STRING;
        extensionValue = token->s;
    }
    else
    {
        scanner.pushBack();
        throw HttpParseException(
            "CacheDirective::readExtension() expected ident or quotedstring",
            scanner.getLineNum() );
    }
}

//////////////////////////////////
// HttpDateValue
void HttpDateValue::load( Tokenizer& scanner )
{
    LoadDateTime( scanner, gmtDateTime );
}

void HttpDateValue::toString( xstring& s )
{
    char *str;
    
    str = DateToString( &gmtDateTime );
    s += str;
    free( str );
}


//////////////////////////////////
// HttpDateOrSeconds
void HttpDateOrSeconds::load( Tokenizer& scanner )
{
    isSeconds = true;
    
    // is it seconds?
    try
    {
        seconds = loadNum( scanner, 10 );
    }
    catch ( HttpParseException& e )
    {
        DBG(
            UpnpPrintf( UPNP_INFO, MSERV, __FILE__, __LINE__,
                "httpexception: %s\n", e.getMessage()); )
        isSeconds = false;
    }
    
    // then date/time maybe?
    if ( !isSeconds )
    {
        LoadDateTime( scanner, gmtDateTime );
    }
}

void HttpDateOrSeconds::toString( xstring& s )
{
    if ( isSeconds )
    {
        NumberToString( seconds, s );
    }   
    else
    {
        char *str;
        str = DateToString( &gmtDateTime );
        s += str;
        free( str );
    }
}

//////////////////////////////////
// HostPortValue
void HostPortValue::load( Tokenizer& scanner )
{
    Token* token;
    
    token = scanner.getToken();
    if ( token->tokType != Token::IDENTIFIER )
    {
        scanner.pushBack();
        throw HttpParseException( "HostPortValue::load()",
            scanner.getLineNum() );
    }
    
    xstring hport = token->s;
    int len;
    
    token = scanner.getToken();
    if ( token->s == ':' )
    {
        hport += ':';
        token = scanner.getToken();
        if ( token->tokType != Token::IDENTIFIER )
        {
            scanner.pushBack();
            throw HttpParseException( "HostPortValue::load()",
                scanner.getLineNum() );
        }
        hport += token->s;
    }
    else
    {
        scanner.pushBack();
    }
    
    len = parse_hostport( (char *)(hport.c_str()), hport.length(),
        &hostport );
    if ( len < 0 )
    {
        throw HttpParseException( "HostPortValue::load()",
            scanner.getLineNum() );
    }