1 // Copyright (c) 2001-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 //

    15 

    16 // System Includes

    17 #include <wspstringconstants.h>

    18 #include <wspparamconstants.h>

    19 #include <wspcontenttypes.h>

    20 #include <wspregcontenttypes.h>

    21 #include <wspcharactersets.h>

    22 #include <wspstdconstants.h>

    23 #include <wsplanguages.h>

    24 #include <wsptypeconstants.h>

    25 

    26 // User Includes

    27 #include "cheaderfield.h"

    28 #include "cwspheaderwriter.h"

    29 

    30 const TInt KOffset = 1;				// Offset as the WspLanguages string table does not have 0x80 in it

    31 const TInt KShortIntLimit = 128;	// A short integer can be within the range of 0-127

    32 

    33 CWspHeaderWriter* CWspHeaderWriter::NewL(RStringPool aStrPool, const TStringTable& aStrTable, CWspHeaderCodec& aCodec)

    34 	{

    35 	return new(ELeave)CWspHeaderWriter(aStrPool, aStrTable, aCodec);

    36 	}

    37 

    38 CWspHeaderWriter* CWspHeaderWriter::NewLC(RStringPool aStrPool, const TStringTable& aStrTable, CWspHeaderCodec& aCodec)

    39 	{

    40 	CWspHeaderWriter* self = CWspHeaderWriter::NewL(aStrPool, aStrTable, aCodec);

    41 	CleanupStack::PushL(self);

    42 	return self;

    43 	}

    44 

    45 CWspHeaderWriter::CWspHeaderWriter(RStringPool aStrPool, const TStringTable& aStrTable, CWspHeaderCodec& aCodec)

    46 	: iStrPool(aStrPool), iStrTable(aStrTable), iCodec(aCodec)

    47 	{

    48 	}

    49 

    50 CWspHeaderWriter::~CWspHeaderWriter()

    51 	{

    52 	}

    53 

    54 void CWspHeaderWriter::EncodeHeaderL(RHeaderField& aHeader)

    55 	{

    56 	switch(aHeader.Name().Index(iStrTable))

    57 		{

    58 		case WSP::EAccept:

    59 			{

    60 			EncodeAcceptL(aHeader);

    61 			} break;

    62 		case WSP::EAcceptCharsetDep:

    63 		case WSP::EAcceptCharset:

    64 			{

    65 			EncodeAcceptCharsetL(aHeader);

    66 			} break;

    67 		case WSP::EAcceptEncodingDep:

    68 		case WSP::EAcceptEncoding:

    69 			{

    70 			EncodeAcceptEncodingL(aHeader);

    71 			} break;

    72 		case WSP::EAcceptLanguage:

    73 			{

    74 			EncodeAcceptLanguageL(aHeader);

    75 			} break;

    76 		case WSP::EAllow:

    77 			{

    78 			EncodeAllowL(aHeader);

    79 			} break;

    80 		case WSP::EAuthorization:

    81 			{

    82 			EncodeAuthorizationL(aHeader);

    83 			} break;

    84 		case WSP::EContentEncoding:

    85 			{

    86 			EncodeContentEncodingL(aHeader);

    87 			} break;

    88 		case WSP::EContentLanguage:

    89 			{

    90 			EncodeContentLanguageL(aHeader);

    91 			} break;

    92 		case WSP::EContentLocation:

    93 		case WSP::EFrom:

    94 		case WSP::EProfile:

    95 		case WSP::EReferer:

    96 		case WSP::EUpgrade:

    97 		case WSP::EUserAgent:

    98 		case WSP::EVia:

    99 			{

   100 			GenericEncodeTextStringL(aHeader);

   101 			} break;

   102 		case WSP::EContentMD5:

   103 			{

   104 			EncodeContentMD5L(aHeader);

   105 			} break;

   106 		case WSP::EContentRangeDep:

   107 		case WSP::EContentRange:

   108 			{

   109 			EncodeContentRangeL(aHeader);

   110 			} break;

   111 		case WSP::EContentType:

   112 			{

   113 			EncodeContentTypeL(aHeader);

   114 			} break;

   115 		case WSP::ECookie:

   116 			{

   117 			EncodeCookieL(aHeader);

   118 			} break;

   119 		case WSP::EDate:

   120 		case WSP::ELastModified:

   121 			{

   122 			GenericEncodeDateL(aHeader);

   123 			} break;

   124 		case WSP::EEncodingVersion:

   125 			{

   126 			EncodeEncodingVersionL(aHeader);

   127 			} break;

   128 		case WSP::EExpect:

   129 			{

   130 			EncodeExpectL(aHeader);

   131 			} break;

   132 		case WSP::EPragma:

   133 			{

   134 			EncodePragmaL(aHeader);

   135 			} break;

   136 		case WSP::EProfileDiff:

   137 			{

   138 			EncodeProfileDiffL(aHeader);

   139 			} break;

   140 		case WSP::ERange:

   141 			{

   142 			EncodeRangeL(aHeader);

   143 			} break;

   144 		case WSP::ETE:

   145 			{

   146 			EncodeTEL(aHeader);

   147 			} break;

   148 		case WSP::ETrailer:

   149 			{

   150 			EncodeTrailerL(aHeader);

   151 			} break;

   152 		case WSP::EWarning:

   153 			{

   154 			EncodeWarningL(aHeader);

   155 			} break;

   156 		case WSP::EXWapApplicationId:

   157 			{

   158 			EncodeXWapApplicationIdL(aHeader);

   159 			} break;

   160 		default:

   161 			User::Leave(KErrNotSupported);

   162 			break;

   163 		}

   164 	}

   165 

   166 

   167 void CWspHeaderWriter::EncodeAcceptL(RHeaderField& aHeader) const

   168 	{

   169 	THeaderFieldPartIter partIter = aHeader.PartsL();

   170 	partIter.First();

   171 	CWspHeaderEncoder* encoder = CWspHeaderEncoder::NewL();

   172 	CleanupStack::PushL(encoder);

   173 	TInt token = EncodeFieldName(aHeader.Name());

   174 	TInt partCount = 0;

   175 	TBool requireValueLength = EFalse;

   176 	aHeader.BeginRawDataL();

   177 	while (!partIter.AtEnd())

   178 		{

   179 		if (token == KErrNotFound)

   180 			encoder->StartHeaderL(aHeader.Name().DesC());

   181 		else

   182 			encoder->StartHeaderL((TUint8)token);

   183 		const CHeaderFieldPart* part = partIter();

   184 		if (part != NULL)

   185 			{

   186 			++partCount;

   187 			TInt numParam = part->NumParameters();

   188 			if (numParam > 0)

   189 				{

   190 				requireValueLength = ETrue;

   191 				encoder->StartValueLengthL();

   192 				}

   193 			THTTPHdrVal value = part->Value();

   194 			if (value.Type() == THTTPHdrVal::KStrFVal)

   195 				{

   196 				TInt typeValue = EncodeContentTypeValue(value);

   197 				if (typeValue < KShortIntLimit && typeValue > KErrNotFound)

   198 					encoder->AddShortIntL((TUint8)typeValue);

   199 				else if (typeValue == KErrNotFound)

   200 					{

   201 					TInt registeredValue = value.StrF().Index(WSPRegContentTypes::Table);

   202 					if (registeredValue > KErrNotFound)

   203 						{

   204 						if (!requireValueLength)

   205 							{

   206 							encoder->StartValueLengthL();

   207 							requireValueLength = ETrue;

   208 							}

   209 						const TInt KContentTypeOffset = 0x0201;	// Offset for the Registered Content Type value string table

   210 						encoder->AddLongIntL(registeredValue + KContentTypeOffset);

   211 						}

   212 					else if (registeredValue == KErrNotFound)

   213 						{

   214 						User::LeaveIfError(CheckTextString(value.StrF()));

   215 						encoder->AddTextStringL(value.StrF().DesC());

   216 						}

   217 					}

   218 

   219 				THeaderFieldParamIter paramIter = part->Parameters();

   220 				paramIter.First();

   221 				while (!paramIter.AtEnd())

   222 					{

   223 					const CHeaderFieldParam* param = paramIter();

   224 					if (param != NULL)

   225 						EncodeParameterL(*param, *encoder);

   226 					++paramIter;

   227 					}

   228 				if (requireValueLength)

   229 					encoder->EndValueLengthL();

   230 				}

   231 			else

   232 				User::Leave(KErrCorrupt);

   233 			}

   234 

   235 		HBufC8* buffer = encoder->EndHeaderL();

   236 		CleanupStack::PushL(buffer);

   237 		TInt startPos = 0;

   238 		// If there is more than one header part it is necessary to append the name of the

   239 		// header to the buffer

   240 		if (partCount == 1)

   241 			startPos = EncodeHeaderNameL(aHeader);

   242 		TPtrC8 data(buffer->Mid(startPos));

   243 		aHeader.WriteRawDataL(data);

   244 		CleanupStack::PopAndDestroy(buffer);

   245 		++partIter;

   246 		}

   247 	aHeader.CommitRawData();

   248 	CleanupStack::PopAndDestroy(encoder);

   249 	}

   250 

   251 void CWspHeaderWriter::EncodeAcceptCharsetL(RHeaderField& aHeader) const

   252 	{

   253 	THeaderFieldPartIter partIter = aHeader.PartsL();

   254 	partIter.First();

   255 	aHeader.BeginRawDataL();

   256 	CWspHeaderEncoder* encoder = CWspHeaderEncoder::NewL();

   257 	CleanupStack::PushL(encoder);

   258 	TInt token = EncodeFieldName(aHeader.Name());

   259 	TInt partCount = 0;

   260 	while (!partIter.AtEnd())

   261 		{

   262 		if (token == KErrNotFound)

   263 			encoder->StartHeaderL(aHeader.Name().DesC());

   264 		else

   265 			encoder->StartHeaderL((TUint8)token);

   266 		TBool requireValueLength = EFalse;

   267 		const CHeaderFieldPart* part = partIter();

   268 		if (part != NULL)

   269 			{

   270 			++partCount;

   271 			TInt numParam = part->NumParameters();

   272 			if (numParam > 0)

   273 				{

   274 				requireValueLength = ETrue;

   275 				encoder->StartValueLengthL();

   276 				}

   277 			THTTPHdrVal value = part->Value();

   278 			if (value.Type() == THTTPHdrVal::KStrFVal)

   279 				{

   280 				// Check for '*' (Any-charset) and that the WSP version is greater than 1.2

   281 				if ((value.StrF().Index(WSPStdConstants::Table) == WSPStdConstants::EAny) 

   282 					&& (iCodec.GetWspVersion() > CWspHeaderCodec::EVersion1_2))

   283 					{

   284 					encoder->AddTokenL(128);		// '*' is encoded as <Octet 128>

   285 					}

   286 				else

   287 					{

   288 					TInt charValue = GetCharacterSetValue(value.StrF());

   289 					switch(charValue)

   290 						{

   291 						case KErrNotFound:

   292 							{

   293 							User::LeaveIfError(CheckTextString(value.StrF()));

   294 							encoder->AddTextStringL(value.StrF().DesC());

   295 							} break;

   296 						default:

   297 							{

   298 							if (charValue < KShortIntLimit)

   299 								encoder->AddShortIntL((TUint8)charValue);

   300 							else

   301 								{

   302 								if (!requireValueLength)

   303 									{

   304 									encoder->StartValueLengthL();

   305 									requireValueLength = ETrue;

   306 									}

   307 								encoder->AddLongIntL(charValue);

   308 								}

   309 							} break;

   310 						}

   311 					}

   312 

   313 				// Check if we have any parameters

   314 				THeaderFieldParamIter paramIter = part->Parameters();

   315 				paramIter.First();

   316 				while (!paramIter.AtEnd())

   317 					{

   318 					const CHeaderFieldParam* param = paramIter();

   319 					THTTPHdrVal paramValue = param->Value();

   320 					HBufC8* qValue = EncodeQValueL(paramValue.StrF());

   321 					CleanupStack::PushL(qValue);

   322 					if (qValue != NULL)

   323 						encoder->AddDataL(*qValue);

   324 					++paramIter;

   325 					CleanupStack::PopAndDestroy(qValue);

   326 					}

   327 				}

   328 			else

   329 				User::Leave(KErrCorrupt);

   330 			}

   331 

   332 		// If we have a Q-value then we need to calculate the value-length

   333 		if (requireValueLength)

   334 			encoder->EndValueLengthL();

   335 		

   336 		HBufC8* buffer = encoder->EndHeaderL();

   337 		CleanupStack::PushL(buffer);

   338 		TInt startPos = 0;		

   339 		// If there is more than one header part it is necessary to append the name of the

   340 		// header to the buffer

   341 		if (partCount == 1)

   342 			startPos = EncodeHeaderNameL(aHeader);

   343 		TPtrC8 data(buffer->Mid(startPos));

   344 		aHeader.WriteRawDataL(data);

   345 		CleanupStack::PopAndDestroy(buffer);

   346 		++partIter;

   347 		}

   348 	aHeader.CommitRawData();

   349 	CleanupStack::PopAndDestroy(encoder);

   350 	}

   351 

   352 void CWspHeaderWriter::EncodeAcceptEncodingL(RHeaderField& aHeader) const

   353 	{

   354 	THeaderFieldPartIter partIter = aHeader.PartsL();

   355 	partIter.First();

   356 	TInt partCount = 0;

   357 	CWspHeaderEncoder* encoder = CWspHeaderEncoder::NewL();

   358 	CleanupStack::PushL(encoder);

   359 	TInt token = EncodeFieldName(aHeader.Name());	

   360 	aHeader.BeginRawDataL();

   361 	while (!partIter.AtEnd())

   362 		{

   363 		if (token == KErrNotFound)

   364 			encoder->StartHeaderL(aHeader.Name().DesC());

   365 		else

   366 			encoder->StartHeaderL((TUint8)token);

   367 		TBool requireValueLength = EFalse;

   368 		const CHeaderFieldPart* part = partIter();

   369 		if (part != NULL)

   370 			{

   371 			++partCount;

   372 			TInt numParam = part->NumParameters();

   373 			if (numParam > 0)

   374 				{

   375 				requireValueLength = ETrue;

   376 				encoder->StartValueLengthL();

   377 				}

   378 			THTTPHdrVal value = part->Value();

   379 			if (value.Type() == THTTPHdrVal::KStrFVal)

   380 				{

   381 				TInt encValue = value.StrF().Index(WSPStdConstants::Table);

   382 				// Check for '*' (Any-encoding) and that the WSP version is greater than 1.2

   383 				if ((encValue == WSPStdConstants::EAny) 

   384 					&& (iCodec.GetWspVersion() > CWspHeaderCodec::EVersion1_2))

   385 					{

   386 					if (!requireValueLength)

   387 						{

   388 						encoder->StartValueLengthL();

   389 						requireValueLength = ETrue;

   390 						}

   391 					encoder->AddTokenL(131);				// '*' is encoded as <Octet 131>

   392 					}

   393 				else

   394 					{

   395 					switch(encValue)

   396 						{

   397 						case WSPStdConstants::EGzip:		// Gzip is encoded as <Octet 128>

   398 							{

   399 							encoder->AddTokenL(128);

   400 							} break;

   401 						case WSPStdConstants::ECompress:	// Compress is encoded as <Octet 129>

   402 							{

   403 							encoder->AddTokenL(129);

   404 							} break;

   405 						case WSPStdConstants::EDeflate:		// Deflate is encoded as <Octet 130>

   406 							{

   407 							encoder->AddTokenL(130);

   408 							} break;

   409 						default:

   410 							{

   411 							encoder->AddTokenTextL(value.StrF().DesC());

   412 							} break;

   413 						}

   414 					}

   415 			

   416 				THeaderFieldParamIter paramIter = part->Parameters();

   417 				paramIter.First();

   418 				while (!paramIter.AtEnd())

   419 					{

   420 					const CHeaderFieldParam* param = paramIter();

   421 					THTTPHdrVal paramValue = param->Value();

   422 					HBufC8* qValue = EncodeQValueL(paramValue.StrF());

   423 					CleanupStack::PushL(qValue);

   424 					if (qValue != NULL)

   425 						encoder->AddDataL(*qValue);

   426 					CleanupStack::PopAndDestroy(qValue);

   427 					++paramIter;

   428 					}

   429 				}

   430 			else

   431 				User::Leave(KErrCorrupt);

   432 			}

   433 

   434 		if (requireValueLength)

   435 			encoder->EndValueLengthL();

   436 		

   437 		HBufC8* buffer = encoder->EndHeaderL();

   438 		CleanupStack::PushL(buffer);

   439 		TInt startPos = 0;	

   440 		// If there is more than one header part it is necessary to append the name of the

   441 		// header to the buffer

   442 		if (partCount == 1)

   443 			startPos = EncodeHeaderNameL(aHeader);

   444 		TPtrC8 data(buffer->Mid(startPos));

   445 		aHeader.WriteRawDataL(data);

   446 		CleanupStack::PopAndDestroy(buffer);

   447 		++partIter;

   448 		}

   449 	aHeader.CommitRawData();

   450 	CleanupStack::PopAndDestroy(encoder);

   451 	}

   452 

   453 void CWspHeaderWriter::EncodeAcceptLanguageL(RHeaderField& aHeader) const

   454 	{

   455 	THeaderFieldPartIter partIter = aHeader.PartsL();

   456 	partIter.First();

   457 	TInt partCount = 0;

   458 	CWspHeaderEncoder* encoder = CWspHeaderEncoder::NewL();

   459 	CleanupStack::PushL(encoder);

   460 	TInt token = EncodeFieldName(aHeader.Name());

   461 	aHeader.BeginRawDataL();

   462 	while (!partIter.AtEnd())

   463 		{

   464 		if (token == KErrNotFound)

   465 			encoder->StartHeaderL(aHeader.Name().DesC());

   466 		else

   467 			encoder->StartHeaderL((TUint8)token);

   468 		TBool requireValueLength = EFalse;

   469 		const CHeaderFieldPart* part = partIter();

   470 		if (part != NULL)

   471 			{

   472 			++partCount;

   473 			TInt numParam = part->NumParameters();

   474 			if (numParam > 0)

   475 				{

   476 				requireValueLength = ETrue;

   477 				encoder->StartValueLengthL();

   478 				}

   479 			THTTPHdrVal value = part->Value();

   480 			if (value.Type() == THTTPHdrVal::KStrFVal)

   481 				{

   482 				TInt langValue = value.StrF().Index(WSPLanguages::Table);

   483 				switch(langValue)

   484 					{

   485 					case WSPLanguages::EAnyLanguage:

   486 						{

   487 						encoder->AddTokenL(128);		// '*' (Any-language) is encoded as <Octet 128>

   488 						} break;

   489 					case KErrNotFound:

   490 						{

   491 						User::LeaveIfError(CheckTextString(value.StrF()));

   492 						encoder->AddTextStringL(value.StrF().DesC());

   493 						} break;

   494 					default:

   495 						{

   496 						if (langValue < KShortIntLimit)

   497 							encoder->AddShortIntL((TUint8)langValue);

   498 						else

   499 							{

   500 							if (!requireValueLength)

   501 								{

   502 								encoder->StartValueLengthL();

   503 								requireValueLength = ETrue;

   504 								}

   505 							encoder->AddLongIntL(langValue + KOffset);

   506 							}

   507 						} break;

   508 					}

   509 

   510 				THeaderFieldParamIter paramIter = part->Parameters();

   511 				paramIter.First();

   512 				while (!paramIter.AtEnd())

   513 					{

   514 					const CHeaderFieldParam* param = paramIter();

   515 					THTTPHdrVal paramValue = param->Value();

   516 					HBufC8* qValue = EncodeQValueL(paramValue.StrF());

   517 					CleanupStack::PushL(qValue);

   518 					if (qValue != NULL)

   519 						encoder->AddDataL(*qValue);

   520 					++paramIter;

   521 					CleanupStack::PopAndDestroy(qValue);

   522 					}

   523 				}

   524 			else

   525 				User::Leave(KErrCorrupt);

   526 			}

   527 

   528 		if (requireValueLength)

   529 			encoder->EndValueLengthL();

   530 		

   531 		HBufC8* buffer = encoder->EndHeaderL();

   532 		CleanupStack::PushL(buffer);

   533 		TInt startPos = 0;	

   534 		// If there is more than one header part it is necessary to append the name of the

   535 		// header to the buffer

   536 		if (partCount == 1)

   537 			startPos = EncodeHeaderNameL(aHeader);

   538 		TPtrC8 data(buffer->Mid(startPos));

   539 		aHeader.WriteRawDataL(data);

   540 		CleanupStack::PopAndDestroy(buffer);

   541 		++partIter;

   542 		}

   543 	aHeader.CommitRawData();

   544 	CleanupStack::PopAndDestroy(encoder);

   545 	}

   546 

   547 void CWspHeaderWriter::EncodeAllowL(RHeaderField& aHeader) const

   548 	{

   549 	THeaderFieldPartIter partIter = aHeader.PartsL();

   550 	aHeader.BeginRawDataL();

   551 	TInt partCount = 0;

   552 	CWspHeaderEncoder* encoder = CWspHeaderEncoder::NewL();

   553 	CleanupStack::PushL(encoder);

   554 	TInt token = EncodeFieldName(aHeader.Name());

   555 	partIter.First();

   556 	while (!partIter.AtEnd())

   557 		{

   558 		if (token == KErrNotFound)

   559 			encoder->StartHeaderL(aHeader.Name().DesC());

   560 		else

   561 			encoder->StartHeaderL((TUint8)token);

   562 		const CHeaderFieldPart* part = partIter();

   563 		if (part != NULL)

   564 			{

   565 			++partCount;

   566 			THTTPHdrVal value = part->Value();

   567 			if (value.Type() == THTTPHdrVal::KStrFVal)

   568 				{

   569 				TUint8 allowNumber = 0;

   570 				TInt allowValue = value.StrF().Index(WSPTypeConstants::Table);

   571 				switch(allowValue)

   572 					{

   573 					case WSPTypeConstants::EGet:

   574 						{

   575 						allowNumber = 64;		// Get is encoded as 0x40

   576 						} break;

   577 					case WSPTypeConstants::EOptions:

   578 						{

   579 						allowNumber = 65;		// Options is encoded as 0x41

   580 						} break;

   581 					case WSPTypeConstants::EHead:

   582 						{

   583 						allowNumber = 66;		// Head is encoded as 0x42

   584 						} break;

   585 					case WSPTypeConstants::EDelete:

   586 						{

   587 						allowNumber = 67;		// Delete is encoded as 0x43

   588 						} break;

   589 					case WSPTypeConstants::ETrace:

   590 						{

   591 						allowNumber = 68;		// Trace is encoded as 0x44

   592 						} break;

   593 					case WSPTypeConstants::EPost:

   594 						{

   595 						allowNumber = 96;		// Post is encoded as 0x60

   596 						} break;

   597 					case WSPTypeConstants::EPut:

   598 						{

   599 						allowNumber = 97;		// Put is encoded as 0x61

   600 						} break;

   601 					default:

   602 						User::Leave(KErrNotFound);

   603 						break;

   604 					}

   605 				encoder->AddShortIntL(allowNumber);

   606 				}

   607 			else

   608 				User::Leave(KErrCorrupt);

   609 			}

   610 		HBufC8* buffer = encoder->EndHeaderL();

   611 		CleanupStack::PushL(buffer);

   612 		TInt startPos = 0;

   613 		if (partCount == 1)

   614 			startPos = EncodeHeaderNameL(aHeader);

   615 		TPtrC8 data(buffer->Mid(startPos));

   616 		aHeader.WriteRawDataL(data);

   617 		CleanupStack::PopAndDestroy(buffer);

   618 		++partIter;

   619 		}

   620 	aHeader.CommitRawData();

   621 	CleanupStack::PopAndDestroy(encoder);

   622 	}

   623 

   624 void CWspHeaderWriter::EncodeAuthorizationL(RHeaderField& aHeader) const

   625 	{

   626 	THeaderFieldPartIter partIter = aHeader.PartsL();

   627 	CWspHeaderEncoder* encoder = CWspHeaderEncoder::NewL();

   628 	CleanupStack::PushL(encoder);

   629 	TInt token = EncodeFieldName(aHeader.Name());

   630 	partIter.First();

   631 	if (!partIter.AtEnd())

   632 		{

   633 		if (token == KErrNotFound)

   634 			encoder->StartHeaderL(aHeader.Name().DesC());

   635 		else

   636 			encoder->StartHeaderL((TUint8)token);

   637 		const CHeaderFieldPart* part = partIter();

   638 		if (part != NULL)

   639 			{

   640 			THTTPHdrVal value = part->Value();

   641 			if (value.Type() == THTTPHdrVal::KStrFVal)

   642 				{

   643 				encoder->StartValueLengthL();

   644 				// Check to see if the first part is 'Basic'

   645 				if (value.StrF().Index(WSPStdConstants::Table) == WSPStdConstants::EBasic)

   646 					{

   647 					// If it is, then encode Basic as <Octet 128> and then iterate through the

   648 					// following parts which should contain the 'User-ID' and 'Password'

   649 					encoder->AddTokenL(128);

   650 					++partIter;

   651 					while (!partIter.AtEnd())

   652 						{

   653 						value = partIter()->Value();

   654 						if(value.Type() == THTTPHdrVal::KStrFVal)

   655 							{

   656 							User::LeaveIfError(CheckTextString(value.StrF()));

   657 							encoder->AddTextStringL(value.StrF().DesC());

   658 							++partIter;

   659 							}

   660 						else

   661 							User::Leave(KErrCorrupt);

   662 						}

   663 					}

   664 				// Otherwise, the first part is an 'Authentication-scheme' with zero or more parameters

   665 				else

   666 					{

   667 					encoder->AddTokenTextL(value.StrF().DesC());

   668 					THeaderFieldParamIter paramIter = part->Parameters();

   669 					paramIter.First();

   670 					while (!paramIter.AtEnd())

   671 						{

   672 						const CHeaderFieldParam* param = paramIter();

   673 						if (param != NULL)

   674 							EncodeParameterL(*param, *encoder);

   675 						++paramIter;

   676 						}

   677 					}

   678 				encoder->EndValueLengthL();

   679 				}

   680 			else

   681 				User::Leave(KErrCorrupt);

   682 			}

   683 

   684 		aHeader.BeginRawDataL();	

   685 		HBufC8* buffer = encoder->EndHeaderL();

   686 		CleanupStack::PushL(buffer);

   687 		TPtrC8 data(buffer->Mid(EncodeHeaderNameL(aHeader)));

   688 		aHeader.WriteRawDataL(data);

   689 		CleanupStack::PopAndDestroy(buffer);

   690 		aHeader.CommitRawData();

   691 		}

   692 	CleanupStack::PopAndDestroy(encoder);

   693 	}

   694 

   695 void CWspHeaderWriter::EncodeContentEncodingL(RHeaderField& aHeader) const

   696 	{

   697 	THeaderFieldPartIter partIter = aHeader.PartsL();

   698 	aHeader.BeginRawDataL();

   699 	TInt partCount = 0;

   700 	CWspHeaderEncoder* encoder = CWspHeaderEncoder::NewL();

   701 	CleanupStack::PushL(encoder);

   702 	TInt token = EncodeFieldName(aHeader.Name());

   703 	partIter.First();

   704 	while (!partIter.AtEnd())

   705 		{

   706 		if (token == KErrNotFound)

   707 			encoder->StartHeaderL(aHeader.Name().DesC());

   708 		else

   709 			encoder->StartHeaderL((TUint8)token);

   710 		const CHeaderFieldPart* part = partIter();

   711 		if (part != NULL)

   712 			{

   713 			++partCount;

   714 			THTTPHdrVal value = part->Value();

   715 			if (value.Type() == THTTPHdrVal::KStrFVal)

   716 				{

   717 				TInt encValue = value.StrF().Index(WSPStdConstants::Table);

   718 				switch(encValue)

   719 					{

   720 					case WSPStdConstants::EGzip:

   721 						{

   722 						encoder->AddTokenL(128);		// Gzip is encoded as <Octet 128>

   723 						} break;

   724 					case WSPStdConstants::ECompress:

   725 						{

   726 						encoder->AddTokenL(129);		// Compress is encoded as <Octet 129>

   727 						} break;

   728 					case WSPStdConstants::EDeflate:

   729 						{

   730 						encoder->AddTokenL(130);		// Deflate is encoded as <Octet 130>

   731 						} break;

   732 					default:

   733 						{

   734 						encoder->AddTokenTextL(value.StrF().DesC());

   735 						} break;

   736 					}

   737 				}

   738 			else

   739 				User::Leave(KErrCorrupt);

   740 			}

   741 

   742 		HBufC8* buffer = encoder->EndHeaderL();

   743 		CleanupStack::PushL(buffer);

   744 		TInt startPos = 0;

   745 		if (partCount == 1)

   746 			startPos = EncodeHeaderNameL(aHeader);

   747 		TPtrC8 data(buffer->Mid(startPos));

   748 		aHeader.WriteRawDataL(data);

   749 		CleanupStack::PopAndDestroy(buffer);

   750 		++partIter;

   751 		}

   752 	aHeader.CommitRawData();

   753 	CleanupStack::PopAndDestroy(encoder);

   754 	}

   755 

   756 void CWspHeaderWriter::EncodeContentLanguageL(RHeaderField& aHeader) const

   757 	{

   758 	THeaderFieldPartIter partIter = aHeader.PartsL();

   759 	partIter.First();

   760 	TInt partCount = 0;

   761 	CWspHeaderEncoder* encoder = CWspHeaderEncoder::NewL();

   762 	CleanupStack::PushL(encoder);

   763 	TInt token = EncodeFieldName(aHeader.Name());

   764 	aHeader.BeginRawDataL();

   765 	while (!partIter.AtEnd())

   766 		{

   767 		if (token == KErrNotFound)

   768 			encoder->StartHeaderL(aHeader.Name().DesC());

   769 		else

   770 			encoder->StartHeaderL((TUint8)token);

   771 		const CHeaderFieldPart* part = partIter();

   772 		if (part != NULL)

   773 			{

   774 			++partCount;

   775 			THTTPHdrVal value = part->Value();

   776 			if (value.Type() == THTTPHdrVal::KStrFVal)

   777 				{

   778 				TInt langValue = value.StrF().Index(WSPLanguages::Table);

   779 				switch(langValue)

   780 					{

   781 					case WSPLanguages::EAnyLanguage:

   782 						{

   783 						encoder->AddTokenL(128);		// '*' (Any-language) is encoded as <Octet 128>

   784 						} break;

   785 					case KErrNotFound:

   786 						{

   787 						encoder->AddTokenTextL(value.StrF().DesC());

   788 						} break;

   789 					default:

   790 						{

   791 						if (langValue < KShortIntLimit)

   792 							encoder->AddShortIntL((TUint8)langValue);

   793 						else

   794 							encoder->AddLongIntL(langValue + KOffset);

   795 						} break;

   796 					}

   797 				}

   798 			else

   799 				User::Leave(KErrCorrupt);

   800 			}

   801 

   802 		HBufC8* buffer = encoder->EndHeaderL();

   803 		CleanupStack::PushL(buffer);

   804 		TInt startPos = 0;

   805 		if (partCount == 1)

   806 			startPos = EncodeHeaderNameL(aHeader);

   807 		TPtrC8 data(buffer->Mid(startPos));

   808 		aHeader.WriteRawDataL(data);

   809 		CleanupStack::PopAndDestroy(buffer);

   810 		++partIter;

   811 		}

   812 	aHeader.CommitRawData();

   813 	CleanupStack::PopAndDestroy(encoder);

   814 	}

   815 

   816 void CWspHeaderWriter::EncodeContentMD5L(RHeaderField& aHeader) const

   817 	{

   818 	THeaderFieldPartIter partIter = aHeader.PartsL();

   819 	CWspHeaderEncoder* encoder = CWspHeaderEncoder::NewL();

   820 	CleanupStack::PushL(encoder);

   821 	TBool requireValueLength = EFalse;

   822 	TInt token = EncodeFieldName(aHeader.Name());

   823 	partIter.First();

   824 	if (!partIter.AtEnd())

   825 		{

   826 		if (token == KErrNotFound)

   827 			encoder->StartHeaderL(aHeader.Name().DesC());

   828 		else

   829 			encoder->StartHeaderL((TUint8)token);

   830 		const CHeaderFieldPart* part = partIter();

   831 		if (part != NULL)

   832 			{

   833 			THTTPHdrVal value = part->Value();

   834 			if (value.Type() == THTTPHdrVal::KStrFVal)

   835 				{

   836 				encoder->StartValueLengthL();

   837 				encoder->AddDataL(value.StrF().DesC());

   838 				requireValueLength = ETrue;

   839 				}

   840 			else

   841 				User::Leave(KErrCorrupt);

   842 

   843 			if (requireValueLength)

   844 				encoder->EndValueLengthL();

   845 

   846 			aHeader.BeginRawDataL();	

   847 			HBufC8* buffer = encoder->EndHeaderL();

   848 			CleanupStack::PushL(buffer);

   849 			TPtrC8 data(buffer->Mid(EncodeHeaderNameL(aHeader)));

   850 			aHeader.WriteRawDataL(data);

   851 			CleanupStack::PopAndDestroy(buffer);

   852 			aHeader.CommitRawData();

   853 			}

   854 		}

   855 	CleanupStack::PopAndDestroy(encoder);

   856 	}

   857 

   858 void CWspHeaderWriter::EncodeContentRangeL(RHeaderField& aHeader) const

   859 	{

   860 	THeaderFieldPartIter partIter = aHeader.PartsL();

   861 	CWspHeaderEncoder* encoder = CWspHeaderEncoder::NewL();

   862 	CleanupStack::PushL(encoder);

   863 	TInt token = EncodeFieldName(aHeader.Name());

   864 	partIter.First();

   865 	if (!partIter.AtEnd())

   866 		{

   867 		if (token == KErrNotFound)

   868 			encoder->StartHeaderL(aHeader.Name().DesC());

   869 		else

   870 			encoder->StartHeaderL((TUint8)token);

   871 		const CHeaderFieldPart* part = partIter();

   872 		if (part != NULL)

   873 			{

   874 			THTTPHdrVal value = part->Value();

   875 			if (value.Type() == THTTPHdrVal::KTIntVal)

   876 				{

   877 				encoder->StartValueLengthL();

   878 				encoder->AddUintVarL(value);

   879 				++partIter;

   880 				if (!partIter.AtEnd())

   881 					{

   882 					value = partIter()->Value();

   883 					if (value.Type() == THTTPHdrVal::KStrFVal)

   884 						{

   885 						// Check for '*' (Any-encoding) and that the WSP version is greater than 1.2

   886 						if ((value.StrF().Index(WSPStdConstants::Table) == WSPStdConstants::EAny)

   887 							&& (iCodec.GetWspVersion() > CWspHeaderCodec::EVersion1_2))

   888 							{

   889 							encoder->AddTokenL(128);	// '*' is encoded as <Octet 128>

   890 							}

   891 						}

   892 					if (value.Type() == THTTPHdrVal::KTIntVal)

   893 						encoder->AddUintVarL(value);

   894 					}

   895 				encoder->EndValueLengthL();

   896 				}

   897 			else

   898 				User::Leave(KErrCorrupt);

   899 

   900 			aHeader.BeginRawDataL();	

   901 			HBufC8* buffer = encoder->EndHeaderL();

   902 			CleanupStack::PushL(buffer);

   903 			TPtrC8 data(buffer->Mid(EncodeHeaderNameL(aHeader)));

   904 			aHeader.WriteRawDataL(data);

   905 			CleanupStack::PopAndDestroy(buffer);

   906 			aHeader.CommitRawData();

   907 			}

   908 		}

   909 	CleanupStack::PopAndDestroy(encoder);

   910 	}

   911 

   912 void CWspHeaderWriter::EncodeContentTypeL(RHeaderField& aHeader) const

   913 	{

   914 	THeaderFieldPartIter partIter = aHeader.PartsL();

   915 	CWspHeaderEncoder* encoder = CWspHeaderEncoder::NewL();

   916 	CleanupStack::PushL(encoder);

   917 	TInt token = EncodeFieldName(aHeader.Name());

   918 	partIter.First();

   919 	TBool requireValueLength = EFalse;

   920 	if (!partIter.AtEnd())

   921 		{

   922 		if (token == KErrNotFound)

   923 			encoder->StartHeaderL(aHeader.Name().DesC());

   924 		else

   925 			encoder->StartHeaderL((TUint8)token);

   926 		const CHeaderFieldPart* part = partIter();

   927 		if (part != NULL)

   928 			{

   929 			TInt numParam = part->NumParameters();

   930 			if (numParam > 0)

   931 				{

   932 				requireValueLength = ETrue;

   933 				encoder->StartValueLengthL();

   934 				}

   935 			THTTPHdrVal value = part->Value();

   936 			if (value.Type() == THTTPHdrVal::KStrFVal)

   937 				{

   938 				TInt typeValue = EncodeContentTypeValue(value);

   939 				if (typeValue < KShortIntLimit && typeValue > KErrNotFound)

   940 					encoder->AddShortIntL((TUint8)typeValue);

   941 				else if (typeValue == KErrNotFound)

   942 					{

   943 					TInt registeredValue = value.StrF().Index(WSPRegContentTypes::Table);

   944 					if (registeredValue > KErrNotFound)

   945 						{

   946 						if (!requireValueLength)

   947 							{

   948 							encoder->StartValueLengthL();

   949 							requireValueLength = ETrue;

   950 							}

   951 						const TInt KContentTypeOffset = 0x0201;	// Offset for the Registered Content Type value string table

   952 						encoder->AddLongIntL(registeredValue + KContentTypeOffset);

   953 						}

   954 					else if (registeredValue == KErrNotFound)

   955 						{

   956 						User::LeaveIfError(CheckTextString(value.StrF()));

   957 						encoder->AddTextStringL(value.StrF().DesC());

   958 						}

   959 					}

   960 				// check for params and append to temporary buffer

   961 				THeaderFieldParamIter paramIter = part->Parameters();

   962 				paramIter.First();

   963 				while (!paramIter.AtEnd())

   964 					{

   965 					const CHeaderFieldParam* param = paramIter();

   966 					if (param != NULL)

   967 						EncodeParameterL(*param, *encoder);

   968 					++paramIter;

   969 					}

   970 

   971 				if (requireValueLength)

   972 					encoder->EndValueLengthL();

   973 

   974 				aHeader.BeginRawDataL();	

   975 				HBufC8* buffer = encoder->EndHeaderL();

   976 				CleanupStack::PushL(buffer);

   977 				TPtrC8 data(buffer->Mid(EncodeHeaderNameL(aHeader)));

   978 				aHeader.WriteRawDataL(data);

   979 				CleanupStack::PopAndDestroy(buffer);

   980 				aHeader.CommitRawData();

   981 				}

   982 			else

   983 				User::Leave(KErrCorrupt);

   984 			}

   985 		}

   986 	CleanupStack::PopAndDestroy(encoder);

   987 	}

   988 

   989 void CWspHeaderWriter::EncodeCookieL(RHeaderField& aHeader) const

   990 	{

   991 	THeaderFieldPartIter partIter = aHeader.PartsL();

   992 	CWspHeaderEncoder* encoder = CWspHeaderEncoder::NewL();

   993 	CleanupStack::PushL(encoder);

   994 	TInt token = EncodeFieldName(aHeader.Name());

   995 	partIter.First();

   996 	if (!partIter.AtEnd())

   997 		{

   998 		if (token == KErrNotFound)

   999 			encoder->StartHeaderL(aHeader.Name().DesC());

  1000 		else

  1001 			encoder->StartHeaderL((TUint8)token);

  1002 		const CHeaderFieldPart* part = partIter();

  1003 		if (part != NULL)

  1004 			{

  1005 			THTTPHdrVal value = part->Value();

  1006 			// Encode the first part which is the Cookie-version value

  1007 			if (value.Type() == THTTPHdrVal::KStrFVal)

  1008 				{

  1009 				encoder->StartValueLengthL();

  1010 				TUint8 versionValue = EncodeVersionValueL(value.StrF());

  1011 				if (versionValue == 0)

  1012 					{

  1013 					User::LeaveIfError(CheckTextString(value.StrF()));

  1014 					encoder->AddTextStringL(value.StrF().DesC());

  1015 					}

  1016 				else

  1017 					encoder->AddShortIntL(versionValue);

  1018 

  1019 				// Then move to the next part and iterate through all the parts that follow, appending

  1020 				// the parameters if any exist

  1021 				++partIter;

  1022 				while (!partIter.AtEnd())

  1023 					{

  1024 					CWspHeaderEncoder* cookieEncoder = CWspHeaderEncoder::NewL();

  1025 					CleanupStack::PushL(cookieEncoder);

  1026 					value = partIter()->Value();	// The first part is the Cookie-Name

  1027 					if (value.Type() == THTTPHdrVal::KStrFVal)

  1028 						{

  1029 						cookieEncoder->StartHeaderL((TUint8)token);

  1030 						cookieEncoder->StartValueLengthL();

  1031 						User::LeaveIfError(CheckTextString(value.StrF()));

  1032 						cookieEncoder->AddTextStringL(value.StrF().DesC());

  1033 						++partIter;

  1034 						part = partIter();

  1035 						value = partIter()->Value();	// The second part is the Cookie-Value

  1036 						if (value.Type() == THTTPHdrVal::KStrFVal)

  1037 							{

  1038 							User::LeaveIfError(CheckTextString(value.StrF()));

  1039 							cookieEncoder->AddTextStringL(value.StrF().DesC());

  1040 							THeaderFieldParamIter paramIter = part->Parameters();	// Now check for any parameters

  1041 							paramIter.First();

  1042 							while (!paramIter.AtEnd())

  1043 								{

  1044 								const CHeaderFieldParam* param = paramIter();

  1045 								if (param != NULL)

  1046 									EncodeParameterL(*param, *cookieEncoder);

  1047 								++paramIter;

  1048 								}

  1049 							}

  1050 						else

  1051 							User::Leave(KErrCorrupt);

  1052 

  1053 						cookieEncoder->EndValueLengthL();

  1054 						HBufC8* cookieBuffer = cookieEncoder->EndHeaderL();

  1055 						CleanupStack::PushL(cookieBuffer);

  1056 						// Remove the header name from the buffer and then check if 

  1057 						// the first byte is equal to 31 i.e. a length quote, and if so remove it

  1058 						TInt offset = 1;

  1059 						if (cookieBuffer->Des()[1] == 31)

  1060 							++offset;

  1061 						HBufC8* data = cookieBuffer->Mid(offset).AllocL();

  1062 						CleanupStack::PushL(data);

  1063 						encoder->AddDataL(*data);

  1064 						CleanupStack::PopAndDestroy(2, cookieBuffer);		// data. cookieBuffer

  1065 						}

  1066 					++partIter;

  1067 					part = partIter();

  1068 					CleanupStack::PopAndDestroy(cookieEncoder);

  1069 					}

  1070 				encoder->EndValueLengthL();

  1071 				}

  1072 			else

  1073 				User::Leave(KErrCorrupt);

  1074 			}	

  1075 		HBufC8* buffer = encoder->EndHeaderL();

  1076 		CleanupStack::PushL(buffer);

  1077 		TPtrC8 data(buffer->Mid(EncodeHeaderNameL(aHeader)));

  1078 		aHeader.BeginRawDataL();

  1079 		aHeader.WriteRawDataL(data);

  1080 		CleanupStack::PopAndDestroy(buffer);

  1081 		aHeader.CommitRawData();

  1082 		}

  1083 	CleanupStack::PopAndDestroy(encoder);

  1084 	}

  1085 

  1086 void CWspHeaderWriter::EncodeEncodingVersionL(RHeaderField& aHeader) const

  1087 	{

  1088 	THeaderFieldPartIter partIter = aHeader.PartsL();

  1089 	CWspHeaderEncoder* encoder = CWspHeaderEncoder::NewL();

  1090 	CleanupStack::PushL(encoder);

  1091 	TInt token = EncodeFieldName(aHeader.Name());

  1092 	partIter.First();

  1093 	if (!partIter.AtEnd())

  1094 		{

  1095 		if (token == KErrNotFound)

  1096 			encoder->StartHeaderL(aHeader.Name().DesC());

  1097 		else

  1098 			encoder->StartHeaderL((TUint8)token);

  1099 		const CHeaderFieldPart* part = partIter();

  1100 		if (part != NULL)

  1101 			{

  1102 			THTTPHdrVal value = part->Value();

  1103 			if (value.Type() == THTTPHdrVal::KStrFVal)		// There is a version-value in the first part

  1104 				{

  1105 				TUint8 versionValue = EncodeVersionValueL(value.StrF());

  1106 				if (versionValue == 0)

  1107 					{

  1108 					User::LeaveIfError(CheckTextString(value.StrF()));

  1109 					encoder->AddTextStringL(value.StrF().DesC());

  1110 					}

  1111 				else

  1112 					encoder->AddShortIntL(versionValue);

  1113 				}

  1114 			else if (value.Type() == THTTPHdrVal::KTIntVal)	// The first part is NOT a version-value but an int

  1115 				{

  1116 				encoder->StartValueLengthL();

  1117 				if (value.Int() < KShortIntLimit)

  1118 					encoder->AddShortIntL((TUint8)value);

  1119 				else

  1120 					User::Leave(KErrCorrupt);

  1121 

  1122 				++partIter;

  1123 				if (!partIter.AtEnd())

  1124 					{

  1125 					value = partIter()->Value();

  1126 					if (value.Type() == THTTPHdrVal::KStrFVal)

  1127 						{

  1128 						TUint8 versionValue = EncodeVersionValueL(value.StrF());

  1129 						if (versionValue == 0)

  1130 							{

  1131 							User::LeaveIfError(CheckTextString(value.StrF()));

  1132 							encoder->AddTextStringL(value.StrF().DesC());

  1133 							}

  1134 						else

  1135 							encoder->AddShortIntL(versionValue);