/*
* Copyright (c) 2004-2006 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description: Implementation of PnPMS components
*
*/
// INCLUDE FILES
#include "HttpProvContentType.h"
#include "NHwrParserLogger.h"
// CONSTANTS
// ============================ MEMBER FUNCTIONS ===============================
// -----------------------------------------------------------------------------
// CHttpProvContentType::CHttpProvContentType
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
CHttpProvContentType::CHttpProvContentType() :
iSEC(KSECNONE),
iContentType( KNullDesC8 ),
iMAC( KNullDesC8 )
{
}
// -----------------------------------------------------------------------------
// CHttpProvContentType::ConstructL
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
void CHttpProvContentType::ConstructL(const TDesC8& aContentTypeField)
{
ParseL( aContentTypeField );
}
// -----------------------------------------------------------------------------
// CHttpProvContentType::NewL
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CHttpProvContentType* CHttpProvContentType::NewL(const TDesC8& aContentTypeField)
{
LOGSTRING( "CHttpProvContentType::NewL()" );
CHttpProvContentType* self = NewLC(aContentTypeField);
CleanupStack::Pop();
return self;
}
// -----------------------------------------------------------------------------
// CHttpProvContentType::NewLC
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CHttpProvContentType* CHttpProvContentType::NewLC(const TDesC8& aContentTypeField)
{
LOGSTRING( "CHttpProvContentType::NewLC()" );
CHttpProvContentType* self = new(ELeave) CHttpProvContentType;
CleanupStack::PushL(self);
self->ConstructL(aContentTypeField);
return self;
}
// Destructor
CHttpProvContentType::~CHttpProvContentType()
{
LOGSTRING( "~CHttpProvContentType" );
}
// -----------------------------------------------------------------------------
// CHttpProvContentType::ParseL
// -----------------------------------------------------------------------------
//
void CHttpProvContentType::ParseL( const TDesC8& aContentTypeField )
{
LOGSTRING( "CHttpProvContentType::ParseL" );
iContentType.Set( aContentTypeField );
// Check MIME type
if( iContentType.Find( KContentTypeApplicationWapConnectivityWbxml ) == 0 )
{
LOGSTRING("CHttpProvContentType Content type application/vnd.wap.connectivity-wbxml");
iContentType.Set( KContentTypeApplicationWapConnectivityWbxml );
}
else if( iContentType.Find( KContentTypeTextPlain ) == 0 )
{
LOGSTRING("CHttpProvContentType Content type text/plain");
iContentType.Set( KContentTypeTextPlain );
}
else
{
LOGSTRING("CHttpProvContentType::ParseL->Invalid contentType");
LOGTEXT( aContentTypeField );
User::Leave( KErrNotSupported );
}
// contentTypeFieldLen is at least the lentgh of KContentTypeApplicationWapConnectivityWbxml
TInt contentTypeFieldLen( aContentTypeField.Length() );
// remove line feed/carriage return
_LIT8( KNewLine, "\n" );
_LIT8( KCarriageReturn, "\r" );
_LIT8( KLineFeed, "\r\n" );
if( aContentTypeField.Mid( contentTypeFieldLen - 1 ) == KNewLine ||
aContentTypeField.Mid( contentTypeFieldLen - 1 ) == KCarriageReturn )
{
LOGSTRING("New line / Carriage return found");
contentTypeFieldLen--;
}
else if( aContentTypeField.Mid( contentTypeFieldLen - 2 ) == KLineFeed )
{
LOGSTRING("Line feed found");
contentTypeFieldLen -= 2;
}
LOGSTRING2( "CHttpProvContentType::contentTypeFieldLen: %i", contentTypeFieldLen );
if( contentTypeFieldLen <= iContentType.Length() )
{
LOGSTRING("iSEC = KSECNONE");
// No possibility for a security breach since CHttpProvContent::AuthenticateL
// returns KHttpProvAuthResultNoAuthentication in this case
iSEC = KSECNONE;
return;
}
// aContentTypeField minus possible line feed / carriage return chars
TPtrC8 contentTypeField = aContentTypeField.Left( contentTypeFieldLen );
// Parse all parameteres
_LIT8(KDelimeter, ";");
_LIT8(KEqual,"=");
// runner is aContentTypeField without the content type (in the beginning)
// and without the line feed / carriage return chars (at the end)
TPtrC8 runner( contentTypeField.Mid( iContentType.Length() ) );
TBool eot(EFalse);
while(runner.Length()>0 && !eot)
{
// Find delimeter and seek over it
if(runner.Left(1).Compare(KDelimeter)!=0)
{
LOGSTRING("CHttpProvContentType::ParseL->Delimeter not found");
User::Leave(KErrCorrupt);
}
runner.Set(runner.Mid(1));
// new code
LOGSTRING( "skip leading space" );
// skip leading space
FOREVER
{
LOGSTRING( "FOREVER" );
if( runner.Length() && runner[0] == ' ' )
{
LOGSTRING( "skipping leading space" );
runner.Set( runner.Mid(1) );
LOGSTRING( "runner now:" );
LOGTEXT( runner );
}
else
{
LOGSTRING( "break" );
break;
}
}
LOGSTRING( "skip trailing space" );
// skip trailing space
FOREVER
{
if( runner.Length() && runner[runner.Length()-1] == ' ' )
{
LOGSTRING( "skipping trailing space" );
runner.Set( runner.Left(runner.Length()-1) );
LOGSTRING( "runner now:" );
LOGTEXT( runner );
}
else
{
LOGSTRING( "break" );
break;
}
}
// Parse parameter name and value
TInt pos = runner.Find(KEqual);
if(pos<1)
{
LOGSTRING("CHttpProvContentType::ParseL->Parameters corrupted");
User::Leave(KErrCorrupt);
}
TPtrC8 paramName(runner.Left(pos));
TPtrC8 paramValue(runner.Mid(pos+1));
TInt endpos = paramValue.Find(KDelimeter);
if(endpos>0)
{
paramValue.Set(paramValue.Left(endpos));
if(runner.Length()<=pos+1+endpos)
{
LOGSTRING("CHttpProvContentType::ParseL->Delimeter found at the end (corrupt)");
User::Leave(KErrCorrupt);
}
runner.Set(runner.Mid(pos+1+endpos));
}
else
{
eot = ETrue;
}
// Store SEC & MAC parameters
// We could store other parameters as well, but we don't need them
_LIT8(KSec,"SEC");
_LIT8(KMac,"MAC");
LOGTEXT( paramName );
LOGTEXT( paramValue );
if(paramName == KSec)
{
// parse SEC type
_LIT8(KNetWPin,"NETWPIN");
_LIT8(KUserPin,"USERPIN");
_LIT8(KUserNetWPin,"USERNETWPIN");
_LIT8(KUserPinMac,"USERPINMAC");
_LIT8( KPublicKeyAuthentication, "PKA" );
if(paramValue.Compare(KNetWPin)==0)
{
iSEC = KSECNETWPIN;
}
else if(paramValue.Compare(KUserPin)==0)
{
iSEC = KSECUSERPIN;
}
else if(paramValue.Compare(KUserNetWPin)==0)
{
iSEC = KSECUSERNETWPIN;
}
else if(paramValue.Compare(KUserPinMac)==0)
{
iSEC = KSECUSERPINMAC;
}
else if( paramValue.Compare( KPublicKeyAuthentication ) == 0
|| paramValue.Compare( _L8("PKI") ) == 0 /*temporary*/ )
{
iSEC = KSECPKA;
}
else
{
// Assume PKA method in case iSEC-parameter is missing
iSEC = KSECPKA;
//iSEC = KSECNONE;
}
}
else if(paramName == KMac)
{
// Store MAC
iMAC.Set( paramValue );
}
}
LOGSTRING( "ParseL - done" );
}
// -----------------------------------------------------------------------------
// CHttpProvContentType::MAC
// -----------------------------------------------------------------------------
//
void CHttpProvContentType::MACL(TPtrC8& aMAC)
{
if( iMAC.Length() )
{
aMAC.Set( iMAC );
}
else
{
User::Leave( KErrNotFound );
}
}
// -----------------------------------------------------------------------------
// CHttpProvContentType::SEC
// -----------------------------------------------------------------------------
//
TUint8 CHttpProvContentType::SEC()
{
return iSEC;
}
const TDesC8& CHttpProvContentType::ContentTypeL() const
{
if( iContentType.Length() < 1 )
{
User::Leave( KErrNotFound );
}
return iContentType;
}
// End of File