1 // Copyright (c) 1997-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 #include "TOBEXCON.H"

    17 #include "obexconstantsinternal.h"

    18 

    19 //reference object constants

    20 _LIT8(KAlphabet, "abcdefghijklmnopqrstuvwxyz");

    21 

    22 _LIT8(KRefType, "text/plain");

    23 _LIT8(KRefRichTextType, "text/richtext");

    24 _LIT8(KRefImageJpegType, "image/jpeg");

    25 

    26 _LIT8(KRefIrMCTarget, "IRMC-SYNC");

    27 _LIT8(KRefSyncMLTarget, "SYNCML-SYNC");

    28 

    29 

    30 CReferenceHandler* CReferenceHandler::NewL()

    31 {

    32     CReferenceHandler* self = new (ELeave) CReferenceHandler();

    33     return self;

    34 }

    35 

    36 CReferenceHandler::CReferenceHandler()

    37 {

    38 }

    39 

    40 CReferenceHandler::~CReferenceHandler()

    41 {

    42 }

    43 

    44 

    45 

    46 void CReferenceHandler::CreateReferenceL(CObexBufObject& aObject, CBufFlat& aObjectBuf, TInt aReferenceId, TTransport aTransport)

    47 {

    48    switch (aReferenceId)

    49    {

    50    case (1) : 

    51    		CreateReferenceObject1L(aObject,aObjectBuf,aTransport);

    52    		break;

    53    case (2) : 

    54    		CreateReferenceObject2L(aObject,aObjectBuf,aTransport);

    55    		break;

    56    case (3) : 

    57    		CreateReferenceObject3L(aObject,aObjectBuf,aTransport);

    58    		break;

    59    case (4) : 

    60    		CreateReferenceObject4L(aObject,aObjectBuf,aTransport);

    61    		break;

    62    case (5) : 

    63    		CreateReferenceObject5L(aObject,aObjectBuf,aTransport);

    64    		break;

    65    case (6) : 

    66    		CreateReferenceObject6L(aObject,aObjectBuf,aTransport);

    67    		break;

    68    case (7) : 

    69    		CreateReferenceObject7L(aObject,aObjectBuf,aTransport);

    70    		break;

    71    case (8) : 

    72    		CreateReferenceObject8L(aObject,aObjectBuf,aTransport);

    73    		break;

    74    case (9) : 

    75    		CreateReferenceObject9L(aObject,aObjectBuf,aTransport);

    76    		break;

    77    case (10) : 

    78    		CreateReferenceObject10L(aObject,aObjectBuf,aTransport);

    79    		break;

    80    default : 

    81    		CreateReferenceObject1L(aObject,aObjectBuf,aTransport);

    82    		break;

    83    }

    84 }

    85 

    86 void CReferenceHandler::CreateReferenceObject1L(CObexBufObject& aObject, CBufFlat& aObjectBuf, TTransport aTransport)

    87 {

    88 	//Reset the object (also resets the buffer)

    89 	aObject.Reset();

    90 	const TUint KNumOfAlphabets = 2;

    91 	aObjectBuf.ResizeL(KNumOfAlphabets * 30);

    92 	//populate the buffer...

    93 	TBuf8<4> buf;

    94 	TUint i;

    95 	for (i=0; i<KNumOfAlphabets; i++)

    96 		{

    97 		buf.Zero();

    98 		buf.AppendNumFixedWidth(i, EDecimal, 4);

    99 		aObjectBuf.Write(30*i, buf);

   100 		aObjectBuf.Write(30*i + 4, KAlphabet);

   101 		}

   102 	//populate the object

   103 	aObject.SetNameL(KRef2Name); // check the deletecurrentheader method

   104 	aObject.SetNameL(KRef1Name);

   105 

   106 	_LIT8(KRef1HTTP, "Accept: text/*");

   107 	_LIT8(KRef2HTTP, "Location: http://www.w3.org");

   108 	_LIT8(KRef3HTTP, "Date: Tue, 10 Nov 2002 09:17:21 GMT");

   109 

   110 	// add Http header using old API

   111 	//

   112 /*	aObject.AddHttpL(KRef1HTTP);

   113 	aObject.AddHttpL(KRef1HTTP);

   114 	aObject.AddHttpL(KRef2HTTP);

   115 	aObject.AddHttpL(KRef3HTTP);

   116 	aObject.AddHttpL(KRef1HTTP);

   117 	aObject.AddHttpL(KRef2HTTP);

   118 	aObject.AddHttpL(KRef3HTTP);

   119 	aObject.AddHttpL(KRef1HTTP);

   120 	aObject.AddHttpL(KRef2HTTP);

   121 	aObject.AddHttpL(KRef3HTTP);

   122 

   123 	// USE THE HEADER MASK TO REMOVE HTTP HEADERS FROM HEADERSET

   124 	// THIS DOES NOT REMOVE THE ITEMS FROM iHttp LIST - this tests 

   125 	// the Http() function which should remove items from iHttp list

   126 	//

   127 

   128 	TObexMatchHeader* headerMask = new(ELeave) TObexMatchHeader;

   129 	headerMask->SetHeader(TObexInternalHeader::EName); 

   130 	aObject.HeaderSet().SetMask(headerMask);

   131 	aObject.HeaderSet().DeleteMasked();

   132 	aObject.HeaderSet().SetMask(NULL);

   133 	delete headerMask;

   134 

   135 */

   136 	aObject.AddHttpL(KRef1HTTP);

   137 	aObject.AddHttpL(KRef1HTTP);

   138 	aObject.AddHttpL(KRef1HTTP);

   139 	aObject.AddHttpL(KRef2HTTP);

   140 	aObject.AddHttpL(KRef3HTTP);

   141 

   142 /*	if (aObject.Http())

   143 		{

   144 		NULL;

   145 		}

   146 */

   147 	// add a Count header using new API

   148 	//

   149 	CObexHeader* tempheader = CObexHeader::NewL();

   150 	CleanupStack::PushL(tempheader);

   151 	tempheader->SetFourByte(TObexInternalHeader::ECount, 0xFE22FF54);

   152 	aObject.AddHeaderL(*tempheader);

   153 	CleanupStack::Pop(tempheader);

   154 

   155 	// add an Http header using new API

   156 	//

   157 	tempheader = CObexHeader::NewL();

   158 	CleanupStack::PushL(tempheader);

   159 	tempheader->SetByteSeqL(TObexInternalHeader::EHttp, KRef1HTTP);

   160 	aObject.AddHeaderL(*tempheader);

   161 	CleanupStack::Pop(tempheader);

   162 

   163 	aObject.SetTypeL(KRefType);

   164 	// set again to check header update functionality

   165 	aObject.SetTypeL(KRefType);

   166 	aObject.SetLengthL(aObjectBuf.Size());

   167 	// set again to check header update functionality

   168 	aObject.SetLengthL(aObjectBuf.Size());

   169 

   170 	TBuf8<40> param;

   171 	param.Copy(_L("\x04"));

   172 	param.Append(_L("\x03"));

   173 	param.Append(_L("App params 123"));

   174 	aObject.SetAppParamL(param);

   175 	// set again to check header update functionality

   176 	aObject.SetAppParamL(param);

   177 

   178 	const TTime KRef1Time = TDateTime(2003, EApril, 29, 10, 10, 10, 0);

   179 	aObject.SetTimeL(KRef1Time);

   180 	// set again to check header update functionality

   181 	aObject.SetTimeL(KRef1Time);

   182 

   183 	// Set up the MF description header

   184 	const TUint KDescLength = ( (aTransport==EBluetooth?KObexPacketDefaultSize:2044) - KObexPacketHeaderSize - 5 - 5)/sizeof(TText); // Size in characters

   185 	HBufC* descBuf = HBufC::NewLC(KDescLength);

   186 	ASSERT(descBuf);

   187 	TPtr ptr(descBuf->Des());

   188 	ptr.Zero();

   189 	for (i=0; i<KDescLength; i++)

   190 		{

   191 		ptr.AppendNumFixedWidth(i%10, EDecimal, 1);

   192 		}

   193 	aObject.SetDescriptionL(ptr);

   194 	// set again to check header update functionality

   195 	aObject.SetDescriptionL(ptr);

   196 

   197 	CleanupStack::PopAndDestroy(descBuf);

   198 

   199 	aObject.SetTargetL(KRefTarget);

   200 	// set again to check header update functionality

   201 	aObject.SetTargetL(KRefTarget);

   202 

   203 	CObexHeader* header = CObexHeader::NewL();

   204 	CleanupStack::PushL(header);

   205 	header->SetUnicodeL(0x30, KRef1Name);

   206 	aObject.AddHeaderL(*header);

   207 	CleanupStack::Pop(header);

   208 

   209 	header = CObexHeader::NewL();

   210 	CleanupStack::PushL(header);

   211 	header->SetFourByte(TObexInternalHeader::ECreatorID, 0x5F3A2343);

   212 	aObject.AddHeaderL(*header);

   213 	CleanupStack::Pop(header);

   214 

   215 	header = CObexHeader::NewL();

   216 	CleanupStack::PushL(header);

   217 	header->SetUnicodeL(0x36, KRef5Name);

   218 	aObject.AddHeaderL(*header);

   219 	CleanupStack::Pop(header);

   220 

   221 	header = CObexHeader::NewL();

   222 	CleanupStack::PushL(header);

   223 	header->SetByteSeqL(TObexInternalHeader::EWanUUID, KRefTarget);

   224 	aObject.AddHeaderL(*header);

   225 	CleanupStack::Pop(header);

   226 

   227 	header = CObexHeader::NewL();

   228 	CleanupStack::PushL(header);

   229 	header->SetUnicodeL(0x3F, KRef5Name);

   230 	aObject.AddHeaderL(*header);

   231 	CleanupStack::Pop(header);

   232 

   233 	header = CObexHeader::NewL();

   234 	CleanupStack::PushL(header);

   235 	header->SetByte(0xB0, 0x03);

   236 	aObject.AddHeaderL(*header);

   237 	CleanupStack::Pop(header);

   238 

   239 	header = CObexHeader::NewL();

   240 	CleanupStack::PushL(header);

   241 	header->SetByte(0xBF, 0x12);

   242 	aObject.AddHeaderL(*header);

   243 	CleanupStack::Pop(header);

   244 

   245 	header = CObexHeader::NewL();

   246 	CleanupStack::PushL(header);

   247 	header->SetByte(0xBE, 0x12);

   248 	aObject.AddHeaderL(*header);

   249 	CleanupStack::Pop(header);

   250 

   251 	header = CObexHeader::NewL();

   252 	CleanupStack::PushL(header);

   253 	header->SetFourByte(0xF0, 0x54545454);

   254 	aObject.AddHeaderL(*header);

   255 	CleanupStack::Pop(header);

   256 

   257 // THIS NEXT HEADER IS A NEGATIVE TEST. It should cause a panic

   258 // 0x2F header doesnt have a FourByte HI Type.

   259 /*	header = CObexHeader::NewL();

   260 	CleanupStack::PushL(header);

   261 	header->SetFourByte(0x2F, 0x54);

   262 	aObject.AddHeaderL(*header);

   263 	CleanupStack::Pop(header);

   264 */

   265 	header = CObexHeader::NewL();

   266 	CleanupStack::PushL(header);

   267 	header->SetFourByte(0xFF, 0x00111243);

   268 	aObject.AddHeaderL(*header);

   269 	CleanupStack::Pop(header);

   270 

   271 	header = CObexHeader::NewL();

   272 	CleanupStack::PushL(header);

   273 	header->SetByteSeqL(0x73, KRefTarget);

   274 	aObject.AddHeaderL(*header);

   275 	CleanupStack::Pop(header);

   276 

   277 	header = CObexHeader::NewL();

   278 	CleanupStack::PushL(header); 

   279 	header->SetByteSeqL(TObexInternalHeader::EObjectClass, KRefTarget);

   280 	aObject.AddHeaderL(*header);

   281 	CleanupStack::Pop(header);

   282 

   283 	aObject.SetHeaderMask(KObexHdrName |KObexHdrType | KObexHdrLength  | KObexHdrTime | KObexHdrDescription | KObexHdrTarget | KObexHdrHttp | KObexHdrCount | KObexHdrAppParam | KObexHdrUserDefined | KObexHdrObjectClass | KObexHdrWanUUID  | KObexHdrCreatorID);

   284 

   285 }

   286 

   287 void CReferenceHandler::CreateReferenceObject2L(CObexBufObject& aObject, CBufFlat& aObjectBuf, TTransport aTransport)

   288 {

   289 	//Reset the object (also resets the buffer)

   290 	aObject.Reset();

   291 	const TUint KNumOfObjects = 2;

   292 	aObjectBuf.ResizeL(KNumOfObjects * 20);

   293 	//populate the buffer...

   294 	_LIT8(KRefDesc2, "*Reference Object 2*");

   295 	TUint i;

   296 	for (i=0; i<KNumOfObjects; i++)

   297 		{

   298 		aObjectBuf.Write(20*i, KRefDesc2);

   299 		}

   300 	//populate the object

   301 	aObject.SetNameL(KRef2Name);

   302 	aObject.SetTypeL(KRefType);

   303 	aObject.SetLengthL(aObjectBuf.Size());

   304 	const TTime KRef2Time = TDateTime(2002, EJanuary, 0, 0, 0, 0, 0);

   305 	aObject.SetTimeL(KRef2Time);

   306 

   307 	// Set up the MF description header

   308 	const TUint KDescLength = ( (aTransport==EBluetooth?KObexPacketDefaultSize:2044) - KObexPacketHeaderSize - 5 - 5)/sizeof(TText); // Size in characters

   309 	HBufC* descBuf = HBufC::NewLC(KDescLength);

   310 	ASSERT(descBuf);

   311 	TPtr ptr(descBuf->Des());

   312 	ptr.Zero();

   313 	for (i=0; i<KDescLength; i++)

   314 		{

   315 		ptr.AppendNumFixedWidth(i%10, EDecimal, 1);

   316 		}

   317 	aObject.SetDescriptionL(ptr);

   318 	CleanupStack::PopAndDestroy(descBuf);

   319 	aObject.SetTargetL(KRefIrMCTarget);

   320 	aObject.SetHeaderMask(KObexHdrName | KObexHdrType | KObexHdrLength  | KObexHdrTime | KObexHdrDescription | KObexHdrTarget);

   321 }

   322 

   323 void CReferenceHandler::CreateReferenceObject3L(CObexBufObject& aObject, CBufFlat& aObjectBuf, TTransport aTransport)

   324 {

   325 	//Reset the object (also resets the buffer)

   326 	aObject.Reset();

   327 	const TUint KNumOfAlphabets = 1000;

   328 	aObjectBuf.ResizeL(KNumOfAlphabets * 30);

   329 	//populate the buffer...

   330 	TBuf8<4> buf;

   331 	TUint i;

   332 	for (i=0; i<KNumOfAlphabets; i++)

   333 		{

   334 		buf.Zero();

   335 		buf.AppendNumFixedWidth(i, EDecimal, 4);

   336 		aObjectBuf.Write(30*i, buf);

   337 		aObjectBuf.Write(30*i + 4, KAlphabet);

   338 		}

   339 	//populate the object

   340 	aObject.SetNameL(KRef3Name);

   341 	aObject.SetTypeL(KRefRichTextType);

   342 	aObject.SetLengthL(aObjectBuf.Size());

   343 	const TTime KRef3Time = TDateTime(2002, EJanuary, 0, 0, 0, 0, 0);

   344 	aObject.SetTimeL(KRef3Time);

   345 

   346 	// Set up the MF description header

   347 	const TUint KDescLength = ( (aTransport==EBluetooth?KObexPacketDefaultSize:2044) - KObexPacketHeaderSize - 5 - 5)/sizeof(TText); // Size in characters

   348 	HBufC* descBuf = HBufC::NewLC(KDescLength);

   349 	ASSERT(descBuf);

   350 	TPtr ptr(descBuf->Des());

   351 	ptr.Zero();

   352 	for (i=0; i<KDescLength; i++)

   353 		{

   354 		ptr.AppendNumFixedWidth(i%10, EDecimal, 1);

   355 		}

   356 	aObject.SetDescriptionL(ptr);

   357 	CleanupStack::PopAndDestroy(descBuf);

   358 	aObject.SetTargetL(KRefTarget);

   359 

   360 	CObexHeader* header = CObexHeader::NewL();

   361 	CleanupStack::PushL(header);

   362 	header->SetUnicodeL(0x30, KRef1Name);

   363 	aObject.AddHeaderL(*header);

   364 	CleanupStack::Pop(header);

   365 

   366 	header = CObexHeader::NewL();

   367 	CleanupStack::PushL(header);

   368 	header->SetUnicodeL(0x36, KRef5Name);

   369 	aObject.AddHeaderL(*header);

   370 	CleanupStack::Pop(header);

   371 

   372 	header = CObexHeader::NewL();

   373 	CleanupStack::PushL(header);

   374 	header->SetUnicodeL(0x3F, KRef5Name);

   375 	aObject.AddHeaderL(*header);

   376 	CleanupStack::Pop(header);

   377 

   378 	header = CObexHeader::NewL();

   379 	CleanupStack::PushL(header);

   380 	header->SetByte(0xB0, 0x03);

   381 	aObject.AddHeaderL(*header);

   382 	CleanupStack::Pop(header);

   383 

   384 	header = CObexHeader::NewL();

   385 	CleanupStack::PushL(header);

   386 	header->SetByte(0xBF, 0x12);

   387 	aObject.AddHeaderL(*header);

   388 	CleanupStack::Pop(header);

   389 

   390 	header = CObexHeader::NewL();

   391 	CleanupStack::PushL(header);

   392 	header->SetFourByte(0xF0, 0x54);

   393 	aObject.AddHeaderL(*header);

   394 	CleanupStack::Pop(header);

   395 

   396 // THIS NEXT HEADER IS A NEGATIVE TEST. It should cause a panic

   397 // 0x2F header doesnt have a FourByte HI Type.

   398 /*	header = CObexHeader::NewL();

   399 	CleanupStack::PushL(header);

   400 	header->SetFourByte(0x2F, 0x54);

   401 	aObject.AddHeaderL(*header);

   402 	CleanupStack::Pop(header);

   403 */

   404 

   405 	header = CObexHeader::NewL();

   406 	CleanupStack::PushL(header);

   407 	header->SetFourByte(0xFF, 0x43);

   408 	aObject.AddHeaderL(*header);

   409 	CleanupStack::Pop(header);

   410 

   411 	header = CObexHeader::NewL();

   412 	CleanupStack::PushL(header);

   413 	header->SetByteSeqL(0x73, KRefTarget);

   414 	aObject.AddHeaderL(*header);

   415 	CleanupStack::Pop(header);

   416 

   417 	aObject.SetHeaderMask(KObexHdrName | KObexHdrType | KObexHdrLength  | KObexHdrTime | KObexHdrDescription | KObexHdrTarget | KObexHdrUserDefined);

   418 }

   419 

   420 void CReferenceHandler::CreateReferenceObject4L(CObexBufObject& aObject, CBufFlat& aObjectBuf, TTransport aTransport)

   421 {

   422 	//Reset the object (also resets the buffer)

   423 	aObject.Reset();

   424 	const TUint KNumOfAlphabets = 200;

   425 	aObjectBuf.ResizeL(KNumOfAlphabets * 30);

   426 	//populate the buffer...

   427 	TBuf8<4> buf;

   428 	TUint i;

   429 	for (i=0; i<KNumOfAlphabets; i++)

   430 		{

   431 		buf.Zero();

   432 		buf.AppendNumFixedWidth(i, EDecimal, 4);

   433 		aObjectBuf.Write(30*i, buf);

   434 		aObjectBuf.Write(30*i + 4, KAlphabet);

   435 		}

   436 	//populate the object

   437 

   438 	aObject.SetNameL(KRef4Name);

   439 	aObject.SetLengthL(aObjectBuf.Size());

   440 

   441 	// Set up the MF description header

   442 	const TUint KDescLength = ( (aTransport==EBluetooth?KObexPacketDefaultSize:2044) - KObexPacketHeaderSize - 5 - 5)/sizeof(TText); // Size in characters

   443 	HBufC* descBuf = HBufC::NewLC(KDescLength);

   444 	ASSERT(descBuf);

   445 	TPtr ptr(descBuf->Des());

   446 	ptr.Zero();

   447 	for (i=0; i<KDescLength; i++)

   448 		{

   449 		ptr.AppendNumFixedWidth(i%10, EDecimal, 1);

   450 		}

   451 	aObject.SetDescriptionL(ptr);

   452 	CleanupStack::PopAndDestroy(descBuf);

   453 	aObject.SetTargetL(KRefTarget);

   454 

   455 	TBuf8<40> param;

   456 	param.Copy(_L("\x04"));

   457 	param.Append(_L("\x03"));

   458 	param.Append(_L("App params 456"));

   459 	aObject.SetAppParamL(param);

   460 

   461 	aObject.SetHeaderMask(KObexHdrName | KObexHdrLength | KObexHdrDescription | KObexHdrTarget | KObexHdrAppParam);

   462 }

   463 

   464 void CReferenceHandler::CreateReferenceObject5L(CObexBufObject& aObject, CBufFlat& aObjectBuf, TTransport aTransport)

   465 {

   466 	//Reset the object (also resets the buffer)

   467 	aObject.Reset();

   468 	const TUint KNumOfAlphabets = 200;

   469 	aObjectBuf.ResizeL(KNumOfAlphabets * 30);

   470 	//populate the buffer...

   471 	TBuf8<4> buf;

   472 	TUint i;

   473 	for (i=0; i<KNumOfAlphabets; i++)

   474 		{

   475 		buf.Zero();

   476 		buf.AppendNumFixedWidth(i, EDecimal, 4);

   477 		aObjectBuf.Write(30*i, buf);

   478 		aObjectBuf.Write(30*i + 4, KAlphabet);

   479 		}

   480 	//populate the object

   481 	aObject.SetNameL(KRef5Name);

   482 	aObject.SetTypeL(KRefImageJpegType);

   483 	aObject.SetLengthL(aObjectBuf.Size());

   484 	const TTime KRef5Time = TDateTime(2001, EFebruary, 14, 15, 38, 24, 0);//set time to 15:38:24.0 on 14th Feb 2001 - obex doesn't transfer microseconds!!

   485 	aObject.SetTimeL(KRef5Time);

   486 

   487 	_LIT8(KRef1HTTP, "Accept: text/*");

   488 	_LIT8(KRef2HTTP, "Location: http://www.w3.org");

   489 	_LIT8(KRef3HTTP, "Date: Tue, 10 Nov 2002 09:17:21 GMT");

   490 

   491 	aObject.AddHttpL(KRef1HTTP);

   492 	aObject.AddHttpL(KRef2HTTP);

   493 	aObject.AddHttpL(KRef3HTTP);

   494 

   495 	// Set up the MF description header

   496 	const TUint KDescLength = ( (aTransport==EBluetooth?KObexPacketDefaultSize:2044) - KObexPacketHeaderSize - 5 - 5)/sizeof(TText); // Size in characters

   497 	HBufC* descBuf = HBufC::NewLC(KDescLength);

   498 	ASSERT(descBuf);

   499 	TPtr ptr(descBuf->Des());

   500 	ptr.Zero();

   501 	for (i=0; i<KDescLength; i++)

   502 		{

   503 		ptr.AppendNumFixedWidth(i%10, EDecimal, 1);

   504 		}

   505 	aObject.SetDescriptionL(ptr);

   506 	CleanupStack::PopAndDestroy(descBuf);

   507 	aObject.SetTargetL(KRefTarget);

   508 	aObject.SetHeaderMask(KObexHdrName | KObexHdrType  | KObexHdrTime | KObexHdrLength  | KObexHdrTime | KObexHdrDescription | KObexHdrHttp | KObexHdrTarget);

   509 }

   510 

   511 void CReferenceHandler::CreateReferenceObject6L(CObexBufObject& aObject, CBufFlat& aObjectBuf, TTransport aTransport)

   512 {

   513 	//Reset the object (also resets the buffer)

   514 	aObject.Reset();

   515 	const TUint KNumOfAlphabets = 200;

   516 	aObjectBuf.ResizeL(KNumOfAlphabets * 30);

   517 	//populate the buffer...

   518 	TBuf8<4> buf;

   519 	TUint i;

   520 	for (i=0; i<KNumOfAlphabets; i++)

   521 		{

   522 		buf.Zero();

   523 		buf.AppendNumFixedWidth(i, EDecimal, 4);

   524 		aObjectBuf.Write(30*i, buf);

   525 		aObjectBuf.Write(30*i + 4, KAlphabet);

   526 		}

   527 	//populate the object

   528 

   529 	aObject.SetNameL(KRef6Name);

   530 	aObject.SetTypeL(KRefImageJpegType);

   531 	aObject.SetLengthL(aObjectBuf.Size());

   532 	const TTime KRef5Time = TDateTime(2001, EFebruary, 14, 15, 38, 24, 0);//set time to 15:38:24.0 on 14th Feb 2001 - obex doesn't transfer microseconds!!

   533 	aObject.SetTimeL(KRef5Time);

   534 

   535 	_LIT8(KRef1HTTP, "Accept: text/*");

   536 	_LIT8(KRef2HTTP, "Location: http://www.w3.org");

   537 	_LIT8(KRef3HTTP, "Date: Tue, 10 Nov 2002 09:17:21 GMT");

   538 /*

   539 	TObexMatchHeader* headerMask = new(ELeave) TObexMatchHeader;

   540 

   541 	headerMask->SetHeader(TObexInternalHeader::EName); 

   542 	aObject.HeaderSet().SetMask(headerMask);

   543 	aObject.AddHttpL(KRef1HTTP);

   544 	aObject.AddHttpL(KRef2HTTP);

   545 	aObject.AddHttpL(KRef1HTTP);

   546 	aObject.AddHttpL(KRef3HTTP);

   547 	aObject.AddHttpL(KRef1HTTP);

   548 	aObject.AddHttpL(KRef3HTTP);

   549 	if (aObject.Http())

   550 		{

   551 		NULL;

   552 		}

   553 	aObject.HeaderSet().SetMask(headerMask);

   554 	aObject.HeaderSet().DeleteMasked();

   555 	aObject.AddHttpL(KRef3HTTP);

   556 	aObject.AddHttpL(KRef2HTTP);

   557 	aObject.AddHttpL(KRef1HTTP);

   558 	aObject.AddHttpL(KRef3HTTP);

   559 	aObject.AddHttpL(KRef3HTTP);

   560 	if (aObject.Http())

   561 		{

   562 		NULL;

   563 		}

   564 	aObject.HeaderSet().SetMask(headerMask);

   565 	aObject.HeaderSet().DeleteMasked();

   566 	aObject.AddHttpL(KRef2HTTP);

   567 	aObject.AddHttpL(KRef1HTTP);

   568 	aObject.AddHttpL(KRef2HTTP);

   569 	aObject.AddHttpL(KRef1HTTP);

   570 	aObject.AddHttpL(KRef1HTTP);

   571 	aObject.AddHttpL(KRef3HTTP);

   572 	

   573 

   574 	if (aObject.Http())

   575 		{

   576 		NULL;

   577 		}

   578 

   579 	aObject.HeaderSet().SetMask(headerMask);

   580 	aObject.HeaderSet().DeleteMasked();

   581 	delete headerMask;

   582 */

   583 

   584 	aObject.AddHttpL(KRef3HTTP);

   585 	aObject.AddHttpL(KRef3HTTP);

   586 	aObject.AddHttpL(KRef1HTTP);

   587 	aObject.AddHttpL(KRef2HTTP);

   588 	aObject.AddHttpL(KRef2HTTP);

   589 

   590 /*

   591 	if (aObject.Http())

   592 		{

   593 		NULL;

   594 		}

   595 

   596 

   597 	aObject.HeaderSet().SetMask(NULL);

   598 */

   599 

   600 	// Set up the MF description header

   601 	const TUint KDescLength = ( (aTransport==EBluetooth?KObexPacketDefaultSize:2044) - KObexPacketHeaderSize - 5 - 5)/sizeof(TText); // Size in characters

   602 	HBufC* descBuf = HBufC::NewLC(KDescLength);

   603 /*	ASSERT(descBuf);

   604 	TPtr ptr(descBuf->Des());

   605 	ptr.Zero();

   606 	for (i=0; i<KDescLength; i++)

   607 		{

   608 		ptr.AppendNumFixedWidth(i%10, EDecimal, 1);

   609 		}

   610 	aObject.SetDescriptionL(ptr);

   611 */	CleanupStack::PopAndDestroy(descBuf);

   612 

   613 	aObject.SetTargetL(KRefTarget);

   614 

   615 	CObexHeader* header = CObexHeader::NewL();

   616 	CleanupStack::PushL(header);

   617 	header->SetUnicodeL(0x30, KRef1Name);

   618 	aObject.AddHeaderL(*header);

   619 	CleanupStack::Pop(header);

   620 

   621 	header = CObexHeader::NewL();

   622 	CleanupStack::PushL(header);

   623 	header->SetUnicodeL(0x36, KRef5Name);

   624 	aObject.AddHeaderL(*header);

   625 	CleanupStack::Pop(header);

   626 

   627 	header = CObexHeader::NewL();

   628 	CleanupStack::PushL(header);

   629 	header->SetUnicodeL(0x3F, KRef5Name);

   630 	aObject.AddHeaderL(*header);

   631 	CleanupStack::Pop(header);

   632 

   633 	header = CObexHeader::NewL();

   634 	CleanupStack::PushL(header);

   635 	header->SetByte(0xB0, 0x03);

   636 	aObject.AddHeaderL(*header);

   637 	CleanupStack::Pop(header);

   638 

   639 	header = CObexHeader::NewL();

   640 	CleanupStack::PushL(header);

   641 	header->SetByte(0xBF, 0x12);

   642 	aObject.AddHeaderL(*header);

   643 	CleanupStack::Pop(header);

   644 

   645 	header = CObexHeader::NewL();

   646 	CleanupStack::PushL(header);

   647 	header->SetFourByte(0xF0, 0x54);

   648 	aObject.AddHeaderL(*header);

   649 	CleanupStack::Pop(header);

   650 

   651 // THIS NEXT HEADER IS A NEGATIVE TEST. It should cause a panic

   652 // 0x2F header doesnt have a FourByte HI Type.

   653 /*	header = CObexHeader::NewL();

   654 	CleanupStack::PushL(header);

   655 	header->SetFourByte(0x2F, 0x54);

   656 	aObject.AddHeaderL(*header);

   657 	CleanupStack::Pop(header);

   658 */

   659 

   660 	header = CObexHeader::NewL();

   661 	CleanupStack::PushL(header);

   662 	header->SetFourByte(0xFF, 0x43);

   663 	aObject.AddHeaderL(*header);

   664 	CleanupStack::Pop(header);

   665 

   666 	header = CObexHeader::NewL();

   667 	CleanupStack::PushL(header);

   668 	header->SetByteSeqL(0x73, KRefTarget);

   669 	aObject.AddHeaderL(*header);

   670 	CleanupStack::Pop(header);

   671 

   672 	aObject.SetHeaderMask(KObexHdrName | KObexHdrType  | KObexHdrTime | KObexHdrLength | KObexHdrHttp | KObexHdrTarget | KObexHdrUserDefined );

   673 }

   674 

   675 

   676 void CReferenceHandler::CreateReferenceObject7L(CObexBufObject& aObject, CBufFlat& aObjectBuf, TTransport aTransport)

   677 {

   678 	//Reset the object (also resets the buffer)

   679 	aObject.Reset();

   680 	const TUint KNumOfAlphabets = 200;

   681 	aObjectBuf.ResizeL(KNumOfAlphabets * 30);

   682 	//populate the buffer...

   683 	TBuf8<4> buf;

   684 	TUint i;

   685 	for (i=0; i<KNumOfAlphabets; i++)

   686 		{

   687 		buf.Zero();

   688 		buf.AppendNumFixedWidth(i, EDecimal, 4);

   689 		aObjectBuf.Write(30*i, buf);

   690 		aObjectBuf.Write(30*i + 4, KAlphabet);

   691 		}

   692 	//populate the object

   693 

   694 	aObject.SetNameL(KRef7Name);

   695 	aObject.SetTypeL(KRefImageJpegType);

   696 	aObject.SetLengthL(aObjectBuf.Size());

   697 	const TTime KRef5Time = TDateTime(2001, EFebruary, 14, 15, 38, 24, 0);//set time to 15:38:24.0 on 14th Feb 2001 - obex doesn't transfer microseconds!!

   698 	aObject.SetTimeL(KRef5Time);

   699 

   700 	_LIT8(KRef1HTTP, "Accept: text/*");

   701 	_LIT8(KRef2HTTP, "Location: http://www.w3.org");

   702 	_LIT8(KRef3HTTP, "Date: Tue, 10 Nov 2002 09:17:21 GMT");

   703 

   704 	aObject.AddHttpL(KRef1HTTP);

   705 	aObject.AddHttpL(KRef2HTTP);

   706 	aObject.AddHttpL(KRef3HTTP);

   707 	aObject.AddHttpL(KRef1HTTP);

   708 	aObject.AddHttpL(KRef2HTTP);

   709 	aObject.AddHttpL(KRef3HTTP);

   710 	aObject.AddHttpL(KRef1HTTP);

   711 	aObject.AddHttpL(KRef2HTTP);

   712 	aObject.AddHttpL(KRef3HTTP);

   713 

   714 

   715 	// Set up the MF description header

   716 	const TUint KDescLength = ( (aTransport==EBluetooth?KObexPacketDefaultSize:2044) - KObexPacketHeaderSize - 5 - 5)/sizeof(TText); // Size in characters

   717 	HBufC* descBuf = HBufC::NewLC(KDescLength);

   718 /*	ASSERT(descBuf);

   719 	TPtr ptr(descBuf->Des());

   720 	ptr.Zero();

   721 	for (i=0; i<KDescLength; i++)

   722 		{

   723 		ptr.AppendNumFixedWidth(i%10, EDecimal, 1);

   724 		}

   725 	aObject.SetDescriptionL(ptr);

   726 */

   727 	CleanupStack::PopAndDestroy(descBuf);

   728 

   729 	aObject.SetTargetL(KRefSyncMLTarget);

   730 	aObject.SetHeaderMask(KObexHdrName | KObexHdrType  | KObexHdrTime | KObexHdrLength | KObexHdrHttp | KObexHdrTarget);

   731 }

   732 

   733 void CReferenceHandler::CreateReferenceObject8L(CObexBufObject& aObject, CBufFlat& aObjectBuf, TTransport aTransport)

   734 {

   735 	//Reset the object (also resets the buffer)

   736 	aObject.Reset();

   737 	const TUint KNumOfAlphabets = 200;

   738 	aObjectBuf.ResizeL(KNumOfAlphabets * 30);

   739 

   740 	//populate the buffer...

   741 	TBuf8<4> buf;

   742 	TUint i;

   743 	for (i=0; i<KNumOfAlphabets; i++)

   744 		{

   745 		buf.Zero();

   746 		buf.AppendNumFixedWidth(i, EDecimal, 4);

   747 		aObjectBuf.Write(30*i, buf);

   748 		aObjectBuf.Write(30*i + 4, KAlphabet);

   749 		}

   750 		

   751 	//populate the object

   752 

   753 	aObject.SetNameL(KRef8Name);

   754 	aObject.SetTypeL(KRefType);

   755 	const TTime KRef10Time = TDateTime(2005, EJanuary, 17, 14, 35, 30, 0);

   756 	aObject.SetTimeL(KRef10Time);

   757 	aObject.SetTargetL(KRefIrMCTarget);

   758 	TBuf8<40> param;

   759 	param.Copy(_L("\x04"));

   760 	param.Append(_L("\x03"));

   761 	param.Append(_L("PARAM 435"));

   762 	aObject.SetAppParamL(param);

   763 

   764 	_LIT8(KRef1HTTP, "Accept: text/*");

   765 	aObject.AddHttpL(KRef1HTTP);

   766 

   767 	CObexHeader* header = CObexHeader::NewL();

   768 	CleanupStack::PushL(header);

   769 	_LIT(KUserDefUnicode2, "UserDef2");

   770 	header->SetUnicodeL(0x34, KUserDefUnicode2);

   771 	aObject.AddHeaderL(*header);

   772 	CleanupStack::Pop(header);

   773 

   774 	header = CObexHeader::NewL();

   775 	CleanupStack::PushL(header);

   776 	header->SetByte(0xBC, 0x23);

   777 	aObject.AddHeaderL(*header);

   778 	CleanupStack::Pop(header);

   779 	

   780 	// Set up the MF description header

   781 	const TUint KDescLength = ( (aTransport==EBluetooth?KObexPacketDefaultSize:2044) - KObexPacketHeaderSize - 5 - 5)/sizeof(TText); // Size in characters

   782 	HBufC* descBuf = HBufC::NewLC(KDescLength);

   783 /*	ASSERT(descBuf);

   784  	Ptr ptr(descBuf->Des());

   785 	ptr.Zero();

   786 	for (i=0; i<KDescLength; i++)

   787 		{

   788 		ptr.AppendNumFixedWidth(i%10, EDecimal, 1);

   789 		}

   790 	aObject.SetDescriptionL(ptr);

   791 */

   792 	CleanupStack::PopAndDestroy(descBuf);

   793 

   794 	aObject.SetHeaderMask(KObexHdrName | KObexHdrType | KObexHdrTime | KObexHdrTarget | KObexHdrAppParam | KObexHdrHttp |KObexHdrUserDefined);

   795 }

   796 

   797 void CReferenceHandler::CreateReferenceObject9L(CObexBufObject& aObject, CBufFlat& aObjectBuf, TTransport aTransport)

   798 {

   799 	//Reset the object (also resets the buffer)

   800 	aObject.Reset();

   801 	const TUint KNumOfAlphabets = 1000;

   802 	aObjectBuf.ResizeL(KNumOfAlphabets * 30);

   803 	//populate the buffer...

   804 	TBuf8<4> buf;

   805 	TUint i;

   806 	for (i=0; i<KNumOfAlphabets; i++)

   807 		{

   808 		buf.Zero();

   809 		buf.AppendNumFixedWidth(i, EDecimal, 4);

   810 		aObjectBuf.Write(30*i, buf);

   811 		aObjectBuf.Write(30*i + 4, KAlphabet);

   812 		}

   813 	//populate the object

   814 	aObject.SetNameL(KRef9Name);

   815 	aObject.SetTypeL(KRefType);

   816 	aObject.SetLengthL(aObjectBuf.Size());

   817 	const TTime KRef3Time = TDateTime(2002, EJanuary, 0, 0, 0, 0, 0);

   818 	aObject.SetTimeL(KRef3Time);

   819 

   820 	_LIT8(KRef1HTTP, "Accept: text/*");

   821 	_LIT8(KRef2HTTP, "Location: http://www.bluetooth.com");

   822 	_LIT8(KRef3HTTP, "Date: Tue, 10 Nov 2002 09:17:21 GMT");

   823 

   824 	aObject.AddHttpL(KRef1HTTP);

   825 	aObject.AddHttpL(KRef2HTTP);

   826 	aObject.AddHttpL(KRef3HTTP);

   827 	aObject.AddHttpL(KRef1HTTP);

   828 	aObject.AddHttpL(KRef2HTTP);

   829 	aObject.AddHttpL(KRef3HTTP);

   830 	aObject.AddHttpL(KRef1HTTP);

   831 	aObject.AddHttpL(KRef2HTTP);

   832 	aObject.AddHttpL(KRef3HTTP);

   833 	aObject.AddHttpL(KRef1HTTP);

   834 	aObject.AddHttpL(KRef2HTTP);

   835 	aObject.AddHttpL(KRef3HTTP);

   836 	aObject.AddHttpL(KRef1HTTP);

   837 	aObject.AddHttpL(KRef2HTTP);

   838 	aObject.AddHttpL(KRef3HTTP);

   839 	aObject.AddHttpL(KRef1HTTP);

   840 	aObject.AddHttpL(KRef2HTTP);

   841 	aObject.AddHttpL(KRef3HTTP);

   842 

   843 	// Set up the MF description header

   844 	const TUint KDescLength = ( (aTransport==EBluetooth?KObexPacketDefaultSize:2044) - KObexPacketHeaderSize - 5 - 5)/sizeof(TText); // Size in characters

   845 	HBufC* descBuf = HBufC::NewLC(KDescLength);

   846 /*	ASSERT(descBuf);

   847  	Ptr ptr(descBuf->Des());

   848 	ptr.Zero();

   849 	for (i=0; i<KDescLength; i++)

   850 		{

   851 		ptr.AppendNumFixedWidth(i%10, EDecimal, 1);

   852 		}

   853 	aObject.SetDescriptionL(ptr);

   854 */

   855 	CleanupStack::PopAndDestroy(descBuf);

   856 	aObject.SetTargetL(KRefSyncMLTarget);

   857 	aObject.SetHeaderMask(KObexHdrName | KObexHdrHttp | KObexHdrType | KObexHdrLength  | KObexHdrTime | KObexHdrDescription | KObexHdrTarget);

   858 }

   859 

   860 //Empty object with EoB headder

   861 void CReferenceHandler::CreateReferenceObject10L(CObexBufObject& aObject, CBufFlat& /*aObjectBuf*/, TTransport /*aTransport*/)

   862 {

   863 	//Reset the object (also resets the buffer)

   864 	aObject.Reset();

   865 

   866 	aObject.SetNameL(KRef8Name);

   867 	aObject.SetTypeL(KRefType);

   868 	const TTime KRef10Time = TDateTime(2005, EJanuary, 17, 14, 35, 30, 0);

   869 	aObject.SetTimeL(KRef10Time);

   870 	aObject.SetTargetL(KRefIrMCTarget);

   871 	TBuf8<40> param;

   872 	param.Copy(_L("\x04"));

   873 	param.Append(_L("\x03"));

   874 	param.Append(_L("PARAM 435"));

   875 	aObject.SetAppParamL(param);

   876 

   877 	_LIT8(KRef1HTTP, "Accept: text/*");

   878 	aObject.AddHttpL(KRef1HTTP);

   879 

   880 	CObexHeader* header = CObexHeader::NewL();

   881 	CleanupStack::PushL(header);

   882 	_LIT(KUserDefUnicode2, "UserDef2");

   883 	header->SetUnicodeL(0x34, KUserDefUnicode2);

   884 	aObject.AddHeaderL(*header);

   885 	CleanupStack::Pop(header);

   886 

   887 	header = CObexHeader::NewL();

   888 	CleanupStack::PushL(header);

   889 	header->SetByte(0xBC, 0x23);

   890 	aObject.AddHeaderL(*header);

   891 	CleanupStack::Pop(header);

   892 	

   893 	header = CObexHeader::NewL();

   894 	CleanupStack::PushL(header);

   895 	TBuf8<1000> dummy;

   896 	header->SetByteSeqL(TObexInternalHeader::EEndOfBody, dummy);

   897 	aObject.AddHeaderL(*header);

   898 	CleanupStack::Pop(header);

   899 

   900 

   901 	HBufC* descBuf = HBufC::NewLC(0);

   902 	CleanupStack::PopAndDestroy(descBuf);

   903 }

   904 

   905 TInt CReferenceHandler::CompareObjectToReferenceL(CObexBufObject& aObject, CBufFlat& aObjectBuf, TTransport aTransport)

   906 {

   907 	CBufFlat* buf = CBufFlat::NewL(3000);

   908 	CleanupStack::PushL(buf);

   909 	CObexBufObject* obj = CObexBufObject::NewL(buf);

   910 	CleanupStack::PushL(obj);

   911 

   912 	if (aObject.Name() == KRef1Name)

   913 		CreateReferenceObject1L(*obj, *buf, aTransport);

   914 	else if (aObject.Name() == KRef2Name)

   915 		CreateReferenceObject2L(*obj, *buf, aTransport);

   916 	else if (aObject.Name() == KRef3Name)

   917 		CreateReferenceObject3L(*obj, *buf, aTransport);

   918 	else if (aObject.Name() == KRef4Name)

   919 		CreateReferenceObject4L(*obj, *buf, aTransport);

   920 	else if (aObject.Name() == KRef5Name)

   921 		CreateReferenceObject5L(*obj, *buf, aTransport);

   922 	else if (aObject.Name() == KRef6Name)

   923 		CreateReferenceObject6L(*obj, *buf, aTransport);

   924 	else if (aObject.Name() == KRef7Name)

   925 		CreateReferenceObject7L(*obj, *buf, aTransport);

   926 	else if (aObject.Name() == KRef8Name)

   927 		CreateReferenceObject8L(*obj, *buf, aTransport);

   928 	else if (aObject.Name() == KRef9Name)

   929 		CreateReferenceObject9L(*obj, *buf, aTransport);

   930 	else //default

   931 		CreateReferenceObject1L(*obj, *buf, aTransport);

   932 

   933 	TInt res = 0;

   934 	

   935 	if (aObject.Name() != obj->Name())

   936 		res |= EDifferentName;

   937 	if (aObject.Type() != obj->Type())

   938 		res |= EDifferentType;

   939 	if (aObject.Length() != obj->Length())

   940 		res |= EDifferentLength;

   941 	if (aObject.Time() != obj->Time())

   942 		res |= EDifferentTime;

   943 	if (aObject.Description() != obj->Description())

   944 		res |= EDifferentDescription;

   945 	if (aObject.Target() != obj->Target())

   946 		res |= EDifferentTarget;

   947 	if (aObjectBuf.Ptr(0) != buf->Ptr(0))

   948 		res |= EDifferentBuf;

   949 	if (aObject.AppParam() != obj->AppParam())

   950 		res |= EDifferentAppParam;

   951 	if (aObject.Http())

   952 		{

   953 			if ( ((aObject.Http())->Count()) == ((obj->Http())->Count())) 

   954 			{	

   955 				TInt arrayIndex = 0;

   956 				while (arrayIndex < ((aObject.Http())->Count()))

   957 				{

   958 					if ((((*aObject.Http())[arrayIndex])->Des()) != (((*obj->Http())[arrayIndex])->Des()))

   959 					{

   960 						res |= EDifferentHttp;

   961 					}

   962 					arrayIndex++;

   963 				}

   964 			}

   965 			else

   966 			{

   967 				res |= EDifferentHttp;

   968 			}

   969 		}

   970 	

   971 	

   972 	CObexHeader* firstHeader = CObexHeader::NewL();

   973 	CObexHeader* secondHeader = CObexHeader::NewL();

   974 

   975 	TInt err1 =0;

   976 	TInt err2 =0;

   977 

   978 /*

   979 	TObexMatchHeader* headerMask = new(ELeave) TObexMatchHeader;

   980 

   981 	headerMask->SetHeader(TObexInternalHeader::EName); 

   982 

   983 	aObject.HeaderSet().SetMask(headerMask);

   984 	err1 = aObject.HeaderSet().This(firstHeader);

   985 	obj->HeaderSet().SetMask(headerMask);

   986 	err2 = obj->HeaderSet().This(secondHeader);

   987 	

   988 	if (err1 == err2)

   989 		{

   990 		if (firstHeader->AsUnicodeL() != secondHeader->AsUnicodeL())

   991 			{

   992 			res |= EDifferentName;

   993 			}

   994 		}

   995 	else

   996 		{

   997 		res |= EDifferentName;

   998 		}

   999 

  1000 	aObject.HeaderSet().SetMask(NULL);

  1001 	obj->HeaderSet().SetMask(NULL);

  1002 	

  1003 	delete headerMask;

  1004 	delete firstHeader;

  1005 	delete secondHeader;

  1006 

  1007 */

  1008 

  1009 	if (aObject.Http())

  1010 		{

  1011 		if (obj->Http())

  1012 			{

  1013 			aObject.HeaderSet().First();

  1014 			obj->HeaderSet().First();

  1015 

  1016 			err1 = aObject.HeaderSet().Find(TObexInternalHeader::EHttp, *firstHeader);

  1017 			err2 = obj->HeaderSet().Find(TObexInternalHeader::EHttp, *secondHeader);

  1018 	

  1019 			while (err1 == KErrNone && err2 == KErrNone)

  1020 				{

  1021 				if (firstHeader->AsByteSeq() != secondHeader->AsByteSeq())

  1022 					{

  1023 					res |= EDifferentHttp;

  1024 					}

  1025 				aObject.HeaderSet().Next();

  1026 				obj->HeaderSet().Next();

  1027 				err1 = aObject.HeaderSet().Find(TObexInternalHeader::EHttp, *firstHeader);

  1028 				err2 = obj->HeaderSet().Find(TObexInternalHeader::EHttp, *secondHeader);

  1029 				}

  1030 			if (err1 != err2)

  1031 				{

  1032 				res |= EDifferentHttp;

  1033 				}

  1034 

  1035 			}

  1036 		else

  1037 			{

  1038 			res |= EDifferentHttp;

  1039 			}

  1040 		}

  1041 	else

  1042 		{

  1043 		if (obj->Http())

  1044 			{

  1045 			res |= EDifferentHttp;

  1046 			}

  1047 		}

  1048 

  1049 

  1050 //	delete firstHeader;

  1051 //	delete secondHeader;

  1052 

  1053 	for (TUint8 headerNameIndex = KObexUserDefinedHdrAddrMin; 

  1054 	 		headerNameIndex <= KObexUserDefinedHdrAddrMax; headerNameIndex++)

  1055 		{

  1056 		TUint8 localHI =  static_cast<TUint8>(headerNameIndex | TObexInternalHeader::EUnicode);

  1057 		

  1058 		aObject.HeaderSet().First();

  1059 		obj->HeaderSet().First();

  1060 

  1061 		err1 = aObject.HeaderSet().Find(localHI, *firstHeader);

  1062 		err2 = obj->HeaderSet().Find(localHI, *secondHeader);

  1063 		

  1064 		if (err1 == err2)

  1065 			{

  1066 			if (err1 == KErrNone)

  1067 				{

  1068 				if (firstHeader->AsUnicode() != secondHeader->AsUnicode())

  1069 					{

  1070 					res |= EDifferentUserDefined;

  1071 					}

  1072 				}

  1073 			}

  1074 		else

  1075 			{

  1076 			res |= EDifferentUserDefined;

  1077 			}

  1078 					

  1079 		localHI =  static_cast<TUint8>(headerNameIndex | TObexInternalHeader::EByteSeq);

  1080 		

  1081 		aObject.HeaderSet().First();

  1082 		obj->HeaderSet().First();

  1083 

  1084 		err1 = aObject.HeaderSet().Find(localHI, *firstHeader);

  1085 		err2 = obj->HeaderSet().Find(localHI, *secondHeader);

  1086 		

  1087 		if (err1 == err2)

  1088 			{

  1089 			if (err1 == KErrNone)

  1090 				{

  1091 				if (firstHeader->AsByteSeq() != secondHeader->AsByteSeq())

  1092 					{

  1093 					res |= EDifferentUserDefined;

  1094 					}

  1095 				}

  1096 			}

  1097 		else

  1098 			{

  1099 			res |= EDifferentUserDefined;

  1100 			}

  1101 

  1102 		localHI =  static_cast<TUint8>(headerNameIndex | TObexInternalHeader::E1Byte);

  1103 		

  1104 		aObject.HeaderSet().First();

  1105 		obj->HeaderSet().First();

  1106 

  1107 		err1 = aObject.HeaderSet().Find(localHI, *firstHeader);

  1108 		err2 = obj->HeaderSet().Find(localHI, *secondHeader);

  1109 		

  1110 		if (err1 == err2)

  1111 			{

  1112 			if (err1 == KErrNone)

  1113 				{

  1114 				if (firstHeader->AsByte() != secondHeader->AsByte())

  1115 					{

  1116 					res |= EDifferentUserDefined;

  1117 					}

  1118 				}

  1119 			}

  1120 		else

  1121 			{

  1122 			res |= EDifferentUserDefined;

  1123 			}

  1124 

  1125 		localHI =  static_cast<TUint8>(headerNameIndex | TObexInternalHeader::E4Byte);

  1126 		

  1127 		aObject.HeaderSet().First();

  1128 		obj->HeaderSet().First();

  1129 

  1130 		err1 = aObject.HeaderSet().Find(localHI, *firstHeader);

  1131 		err2 = obj->HeaderSet().Find(localHI, *secondHeader);

  1132 		

  1133 		if (err1 == err2)

  1134 			{

  1135 			if (err1 == KErrNone)