void CHttpHdrTest::TestLookupParamL()
{
// Open strings needed in this test
RStringF qStr = iStrP.StringF(HTTP::EQ,RHTTPSession::GetTable());
RStringF textHtmlStr = iStrP.StringF(HTTP::ETextHtml,RHTTPSession::GetTable());
RStringF user1Str = iStrP.OpenFStringL(_L8("user1"));
CleanupClosePushL(user1Str);
RStringF value1Str = iStrP.OpenFStringL(_L8("value1"));
CleanupClosePushL(value1Str);
RStringF user2Str = iStrP.OpenFStringL(_L8("user2"));
CleanupClosePushL(user2Str);
RStringF value2Str = iStrP.OpenFStringL(_L8("value2"));
CleanupClosePushL(value2Str);
//
CHeaderFieldPart* htmlPt = CHeaderFieldPart::NewL(THTTPHdrVal(textHtmlStr));
CleanupStack::PushL(htmlPt);
THTTPHdrVal::TQConv q(0.2);
CHeaderFieldParam* headerParam = CHeaderFieldParam::NewL(qStr, THTTPHdrVal(q));
CleanupStack::PushL(headerParam);
htmlPt->AddParamL(headerParam);
CleanupStack::Pop(headerParam);
headerParam = CHeaderFieldParam::NewL(user1Str, THTTPHdrVal(value1Str));
CleanupStack::PushL(headerParam);
htmlPt->AddParamL(headerParam);
CleanupStack::Pop(headerParam);
headerParam = CHeaderFieldParam::NewL(user2Str, THTTPHdrVal(value2Str));
CleanupStack::PushL(headerParam);
htmlPt->AddParamL(headerParam);
CleanupStack::Pop(headerParam);
//
// now lookup the params
CHeaderFieldParam* qP = htmlPt->Parameter(qStr);
RStringF qPstr = qP->Name();
TestL(qPstr.Index(RHTTPSession::GetTable()) == qStr.Index(RHTTPSession::GetTable()));
//
qP = htmlPt->Parameter(user1Str);
qPstr = qP->Name();
TestL(qPstr.Index(RHTTPSession::GetTable()) == user1Str.Index(RHTTPSession::GetTable()));
//
qP = htmlPt->Parameter(user2Str);
qPstr = qP->Name();
TestL(qPstr.Index(RHTTPSession::GetTable()) == user2Str.Index(RHTTPSession::GetTable()));
// Now just destroy that lot
CleanupStack::PopAndDestroy(5);
}
// -----------------------------------------------------------------------------
// CMceSdpCodec::Direction
// -----------------------------------------------------------------------------
//
TInt CMceSdpCodec::Direction(
CSdpMediaField& aMedia,
RPointerArray<CSdpAttributeField>& aSessionAttributes ) const
{
TInt direction = KErrNotFound;
TInt index = 0;
// look for the direction attribute, go through all attribute fields.
while( direction == KErrNotFound && index < aSessionAttributes.Count() )
{
RStringF attribute = aSessionAttributes[index++]->Attribute();
if ( attribute == SDP_STRING( SdpCodecStringConstants::EAttributeSendonly ) ||
attribute == SDP_STRING( SdpCodecStringConstants::EAttributeRecvonly ) ||
attribute == SDP_STRING( SdpCodecStringConstants::EAttributeInactive ) ||
attribute == SDP_STRING( SdpCodecStringConstants::EAttributeSendrecv ) )
{
// downlink
direction = attribute.Index( *iStringTable );
}
}
if ( direction == KErrNotFound )
{
index = 0;
RPointerArray<CSdpAttributeField>& attrfields = aMedia.AttributeFields();
// look for the direction attribute, go through all attribute fields. if not
// found then use the default sendrcv
while( direction == KErrNotFound && index < attrfields.Count() )
{
RStringF attribute = attrfields[index++]->Attribute();
if ( attribute == SDP_STRING( SdpCodecStringConstants::EAttributeSendonly ) ||
attribute == SDP_STRING( SdpCodecStringConstants::EAttributeRecvonly ) ||
attribute == SDP_STRING( SdpCodecStringConstants::EAttributeInactive ) ||
attribute == SDP_STRING( SdpCodecStringConstants::EAttributeSendrecv ) )
{
// downlink
direction = attribute.Index( *iStringTable );
}
}
}
return direction;
}
void CHttpClientHeaderReader::DecodeHeaderL(RHeaderField& aHeader)
{
RStringF fieldStr = iStrPool.StringF(aHeader.Name()); // this doesn't have to be closed
switch(fieldStr.Index(iStringTable))
{
case HTTP::EWWWAuthenticate:
{
DecodeWWWAuthenticateL(aHeader);
} break;
case HTTP::ESetCookie:
case HTTP::ESetCookie2:
DecodeSetCookieL(aHeader);
break;
case HTTP::EAge:
DecodeGenericNumberL(aHeader);
break;
case HTTP::EVary:
case HTTP::EContentLanguage:
case HTTP::EUpgrade:
DecodeGenericL(aHeader, KCommaNewline);
break;
case HTTP::ELastModified:
DecodeDateL(aHeader);
break;
default:
User::Leave(KErrNotSupported);
}
}
void CUPnPHeaderReader::DecodeHeaderL(RHeaderField& aHeader)
{
RStringF fieldStr = iStringPool.StringF(aHeader.Name());
switch( fieldStr.Index(TUPnPTable::Table()) )
{
case UPnP::ENTS:
case UPnP::ENT:
case UPnP::EST:
case UPnP::EUSN:
case UPnP::ESoapAction:
case UPnP::ESID:
DecodeGenericUpnpHeadersL(aHeader);
break;
case UPnP::ETimeout:
DecodeTimeoutHeaderL(aHeader);
break;
case UPnP::EExt:
DecodeExtL(aHeader);
break;
case UPnP::EMX:
case UPnP::ESEQ:
DecodeGenericNumberL(aHeader);
break;
case UPnP::EMAN:
DecodeManL(aHeader);
break;
case UPnP::ECallback:
DecodeCallbackL(aHeader);
break;
default:
User::Leave(KErrNotSupported);
}
}
void CHttpClientFilter::EnsureNoEndToEndHeadersInConnectionHeaderL(RHTTPTransaction aTransaction)
{
RHTTPHeaders headers = aTransaction.Request().GetHeaderCollection();
RStringF connection = iStringPool.StringF(HTTP::EConnection,iStringTable);
const TInt numConnectionHeaderParts = headers.FieldPartsL(connection);
for( TInt ii = numConnectionHeaderParts - 1; ii >= 0; --ii )
{
// Examine connection-tokens from back to front so index is always valid.
// Check for an end to end header and remove it as a connection header
// must not contain end to end headers.
THTTPHdrVal value;
TInt ret = headers.GetField(connection, ii, value);
if( ( ret != KErrNotFound ) && ( value.Type() == THTTPHdrVal::KStrFVal ) )
{
RStringF valueStrF = value.StrF();
if( valueStrF.Index(iStringTable) != HTTP::EClose &&
!IsHopByHopHeader(valueStrF) )
{
// The connection-token is not 'close' nor is it a end-to-end
// header field name - remove it.
User::LeaveIfError(headers.RemoveFieldPart(connection, ii));
}
}
else
{
// The connection-token is not a hop-by-hop header field name -
// remove it.
User::LeaveIfError(headers.RemoveFieldPart(connection, ii));
}
}
}
void CHttpHdrTest::TestLookupPartL()
{
// Open strings needed in this test
RStringF accStr = iStrP.StringF(HTTP::EAccept,RHTTPSession::GetTable());
RStringF textHtmlStr = iStrP.StringF(HTTP::ETextHtml,RHTTPSession::GetTable());
RStringF textPlainStr = iStrP.StringF(HTTP::ETextPlain,RHTTPSession::GetTable());
RStringF anyAnyStr = iStrP.StringF(HTTP::EAnyAny,RHTTPSession::GetTable());
RStringF qStr = iStrP.StringF(HTTP::EQ,RHTTPSession::GetTable());
//
// Accept: text/html; q=0.8, text/plain; q=0.2, */*
//
CHeaderField* accept = CHeaderField::NewL(accStr, *iHdrColl);
CleanupStack::PushL(accept);
//
CHeaderFieldPart* htmlPt = CHeaderFieldPart::NewL(THTTPHdrVal(textHtmlStr));
CleanupStack::PushL(htmlPt);
THTTPHdrVal::TQConv q(0.8);
CHeaderFieldParam* headerParam = CHeaderFieldParam::NewL(qStr, THTTPHdrVal(q));
CleanupStack::PushL(headerParam);
htmlPt->AddParamL(headerParam);
CleanupStack::Pop(headerParam);
accept->AddPartL(htmlPt);
CleanupStack::Pop(htmlPt); // now owned by the header
//
CHeaderFieldPart* plainPt = CHeaderFieldPart::NewL(THTTPHdrVal(textPlainStr));
CleanupStack::PushL(plainPt);
THTTPHdrVal::TQConv q2(0.2);
headerParam = CHeaderFieldParam::NewL(qStr, THTTPHdrVal(q2));
CleanupStack::PushL(headerParam);
plainPt->AddParamL(headerParam);
CleanupStack::Pop(headerParam);
accept->AddPartL(plainPt);
CleanupStack::Pop(plainPt); // now owned by the header
//
CHeaderFieldPart* headerPart = CHeaderFieldPart::NewL(THTTPHdrVal(anyAnyStr));
CleanupStack::PushL(headerPart);
accept->AddPartL(headerPart);
CleanupStack::Pop(headerPart);
// now lookup the parts by index and check they are correct
CHeaderFieldPart* pt = accept->PartL(0);
TestL(pt == htmlPt);
pt = accept->PartL(1);
TestL(pt == plainPt);
pt = accept->PartL(2);
THTTPHdrVal val = pt->Value();
TestL(val.Type() == THTTPHdrVal::KStrFVal);
TestL(val.StrF().Index(RHTTPSession::GetTable()) == anyAnyStr.Index(RHTTPSession::GetTable()));
// Now just destroy that lot
CleanupStack::PopAndDestroy(accept);
}
TBool CHttpClientFilter::IsHopByHopHeader(RStringF aHeaderName)
{
switch( aHeaderName.Index(iStringTable) )
{
case HTTP::EKeepAlive:
case HTTP::EProxyAuthorization:
case HTTP::EProxyAuthenticate:
case HTTP::ETE:
case HTTP::ETrailer:
case HTTP::ETransferEncoding:
case HTTP::EUpgrade:
return ETrue;
default:
// NOT a hop by hop header, at least not as defined in http 1.1
return EFalse;
};
}
void CHttpClientHeaderWriter::EncodeHeaderL(RHeaderField& aHeader)
{
RStringF fieldStr = iStringPool.StringF(aHeader.Name());
switch( fieldStr.Index(iStringTable) )
{
case HTTP::EAccept:
{
EncodeAcceptL(aHeader);
} break;
case HTTP::EAcceptCharset:
{
EncodeAcceptCharsetL(aHeader);
} break;
case HTTP::EAuthorization:
{
EncodeAuthorizationL(aHeader);
} break;
case HTTP::EAcceptLanguage:
{
EncodeAcceptLanguageL(aHeader);
} break;
case HTTP::EAcceptEncoding:
{
DoGeneralAcceptHeaderL(KNormalAcceptEncodingHeaderLen, aHeader, iStringPool.StringF(HTTP::EAcceptEncoding,iStringTable), KErrHttpEncodeAcceptEncoding);
} break;
case HTTP::EHost:
{
EncodeHostL(aHeader);
} break;
case HTTP::EUserAgent:
{
EncodeUserAgentL(aHeader);
} break;
case HTTP::ECookie:
{
EncodeCookieL(aHeader);
} break;
case HTTP::EIfMatch:
{
DoTokenCsvListHeaderL(aHeader, KErrHttpEncodeIfMatch);
} break;
case HTTP::EIfNoneMatch:
{
DoTokenCsvListHeaderL(aHeader, KErrHttpEncodeIfMatch);
} break;
case HTTP::EIfModifiedSince:
{
EncodeGenericDateL(aHeader, KErrHttpEncodeIfModifiedSince);
} break;
case HTTP::EIfUnmodifiedSince:
{
EncodeGenericDateL(aHeader, KErrHttpEncodeIfUnmodifiedSince);
} break;
case HTTP::ECookie2:
{
EncodeGenericNumberHeaderL(aHeader, KErrHttpEncodeCookie2);
} break;
case HTTP::ETE:
{
EncodeTEL(aHeader);
} break;
default:
User::Leave(KErrNotSupported);
break;
}
}
void CHttpHdrTest::TestHeaderCollIterL()
{
RStringF field1Str = iStrP.OpenFStringL(_L8("hcfield1"));
CleanupClosePushL(field1Str);
RStringF value1Str = iStrP.OpenFStringL(_L8("hcvalue1"));
CleanupClosePushL(value1Str);
RStringF field2Str = iStrP.OpenFStringL(_L8("hcfield2"));
CleanupClosePushL(field2Str);
RStringF value2Str = iStrP.OpenFStringL(_L8("hcvalue2"));
CleanupClosePushL(value2Str);
RStringF field3Str = iStrP.OpenFStringL(_L8("hcfield3"));
CleanupClosePushL(field3Str);
RStringF value3Str = iStrP.OpenFStringL(_L8("hcvalue3"));
CleanupClosePushL(value3Str);
RStringF field4Str = iStrP.OpenFStringL(_L8("hcfield4"));
CleanupClosePushL(field4Str);
RStringF value4Str = iStrP.OpenFStringL(_L8("hcvalue4"));
CleanupClosePushL(value4Str);
//
CTextModeHeaderCodec* headerCodec = CTextModeHeaderCodec::NewL(iStrP);
CleanupStack::PushL(headerCodec);
CHeaders* headers = CHeaders::NewL(*headerCodec);
CleanupStack::PushL(headers);
RHTTPHeaders hdr = headers->Handle();
THTTPHdrVal str1(value1Str);
hdr.SetFieldL(field1Str, str1);
THTTPHdrVal str2(value2Str);
hdr.SetFieldL(field2Str, str2);
THTTPHdrVal str3(value3Str);
hdr.SetFieldL(field3Str, str3);
THTTPHdrVal str4(value4Str);
hdr.SetFieldL(field4Str, str4);
THTTPHdrFieldIter it = hdr.Fields();
TInt count = 0;
while (it.AtEnd() == EFalse)
{
RStringTokenF nextTk = it();
RStringF nextStr = iStrP.StringF(nextTk);
THTTPHdrVal hVal;
TestL(hdr.GetField(nextStr,0,hVal)==KErrNone);
switch (count)
{
case 0:
TestL(nextStr.Index(RHTTPSession::GetTable()) == field1Str.Index(RHTTPSession::GetTable()));
break;
case 1:
TestL(nextStr.Index(RHTTPSession::GetTable()) == field2Str.Index(RHTTPSession::GetTable()));
break;
case 2:
TestL(nextStr.Index(RHTTPSession::GetTable()) == field3Str.Index(RHTTPSession::GetTable()));
break;
case 3:
TestL(nextStr.Index(RHTTPSession::GetTable()) == field4Str.Index(RHTTPSession::GetTable()));
break;
}
++it;
++count;
}
// Close strings used in this test
CleanupStack::PopAndDestroy(10);
}
void CHttpHdrTest::TestHeaderCollL()
{
// Open strings needed in this test
RStringF userAgentStr = iStrP.StringF(HTTP::EUserAgent,RHTTPSession::GetTable());
RStringF textPlainStr = iStrP.StringF(HTTP::ETextPlain,RHTTPSession::GetTable());
RStringF qStr = iStrP.StringF(HTTP::EQ,RHTTPSession::GetTable());
RStringF accStr = iStrP.StringF(HTTP::EAccept,RHTTPSession::GetTable());
RStringF textHtmlStr = iStrP.StringF(HTTP::ETextHtml,RHTTPSession::GetTable());
RStringF wmlStr = iStrP.StringF(HTTP::ETextVndWapWml,RHTTPSession::GetTable());
RStringF symbGTWapStr = iStrP.OpenFStringL(_L8("SymbGTWap"));
CleanupClosePushL(symbGTWapStr);
//
CTextModeHeaderCodec* headerCodec = CTextModeHeaderCodec::NewL(iStrP);
CleanupStack::PushL(headerCodec);
CHeaders* headers = CHeaders::NewL(*headerCodec);
CleanupStack::PushL(headers);
RHTTPHeaders hdr = headers->Handle();
THTTPHdrVal uaStr(symbGTWapStr);
hdr.SetFieldL(userAgentStr, uaStr);
THTTPHdrVal dummy;
TestL(hdr.GetField(userAgentStr,0,dummy) == KErrNone);
hdr.RemoveField(userAgentStr);
TestL(hdr.GetField(userAgentStr,0,dummy) == KErrNotFound);
THTTPHdrVal htmlStr(textHtmlStr);
THTTPHdrVal q(THTTPHdrVal::TQConv(0.5));
hdr.SetFieldL(accStr, htmlStr, qStr, q);
THTTPHdrVal wml(wmlStr);
THTTPHdrVal q2(THTTPHdrVal::TQConv(0.3));
hdr.SetFieldL(accStr, wml, qStr, q2);
THTTPHdrVal plainStr(textPlainStr);
THTTPHdrVal q3(THTTPHdrVal::TQConv(0.1));
hdr.SetFieldL(accStr, plainStr, qStr, q3);
TestL(hdr.FieldPartsL(accStr) == 3);
THTTPHdrVal v1;
hdr.GetField(accStr,0,v1);
TestL(v1.Type() == THTTPHdrVal::KStrFVal);
TestL(v1.StrF().Index(RHTTPSession::GetTable()) == textHtmlStr.Index(RHTTPSession::GetTable()));
THTTPHdrVal v2;
TestL(!hdr.GetParam(accStr, qStr, v2));
hdr.GetField(accStr, 1,v2);
TestL(v1.Type() == THTTPHdrVal::KStrFVal);
TestL(v2.StrF().Index(RHTTPSession::GetTable()) == wmlStr.Index(RHTTPSession::GetTable()));
THTTPHdrVal v3;
TestL(!hdr.GetParam(accStr, qStr, v3, 1));
hdr.GetField(accStr, 2,v3);
TestL(v3.Type() == THTTPHdrVal::KStrFVal);
TestL(v3.StrF().Index(RHTTPSession::GetTable()) == textPlainStr.Index(RHTTPSession::GetTable()));
TestL(!hdr.GetParam(accStr, qStr, v3, 2));
CleanupStack::PopAndDestroy(3);
}
