1 // Copyright (c) 2008-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 the License "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 // e32\debug\crashMonitor\src\scmdatatypes.cpp

    15 // Core dump server - Data Types for System Crash

    16 // 

    17 //

    18 

    19 /**

    20  @file

    21  @internalTechnology

    22 */

    23 #include <scmtrace.h>

    24 #include <scmdatatypes.h>

    25 #include <scmbytestreamutil.h>

    26 

    27 namespace Debug 

    28 	{	

    29 	/**

    30 	 * TCrashOffsetsHeader implementation

    31 	 * @internal technology

    32 	 */

    33 

    34 	/**

    35 	 * TCrashOffsetsHeader Constructor

    36 	 */

    37 	TCrashOffsetsHeader::TCrashOffsetsHeader():

    38 		iId(ESCMOffsetsHeader),	

    39 		iVersion(EChVersion1),	

    40 		iCTFullRegOffset(0),

    41 		iCTUsrStkOffset(0),

    42 		iCTSvrStkOffset(0),

    43 		iCPMetaOffset(0),

    44 		iCTMetaOffset(0),

    45 		iCPCodeSegOffset(0),

    46 		iSysUsrStkOffset(0),

    47 		iSysSvrStkOffset(0),

    48 		iSysUsrRegOffset(0),

    49 		iSysSvrRegOffset(0),

    50 		iTLstOffset(0),

    51 		iPLstOffset(0),	

    52 		iSysCodeSegOffset(0),

    53 		iExcStkOffset(0),		

    54 		iTraceOffset(0),

    55 		iScmLocksOffset(0),

    56 		iKernelHeapOffset(0),

    57 		iVarSpecInfOffset(0),

    58 		iRomInfoOffset(0),	

    59 		iSpare1(0),

    60 		iSpare2(0),

    61 		iSpare3(0),

    62 		iSpare4(0),	

    63 		iSpare5(0),	

    64 		iSpare6(0)

    65 		{	

    66 		}	

    67 

    68 	/**

    69 	 * Writes this class to the specified byte stream

    70 	 * @param aWriter Byte stream to use

    71 	 * @return One of the OS wide codes

    72 	 */

    73 	TInt TCrashOffsetsHeader::Serialize(TByteStreamWriter& aWriter)

    74 		{						

    75 		TInt startPos = aWriter.CurrentPosition();

    76 		

    77 		if(iId != ESCMOffsetsHeader)

    78 			{

    79 			CLTRACE("TCrashOffsetsHeader::Serialize Corrupt ID");

    80 			return KErrCorrupt;

    81 			}

    82 

    83 		// ID saved first 

    84 		aWriter.WriteInt(iId);		 				// 4		

    85 		aWriter.WriteShort((TUint16) iVersion);		// 2

    86 

    87 		if(iVersion == EChVersion1)

    88 			{

    89 			// write data v1 format	

    90 			aWriter.WriteInt(iCTFullRegOffset); 	// 4 

    91 			aWriter.WriteInt(iCTUsrStkOffset);  	// 4

    92 			aWriter.WriteInt(iCTSvrStkOffset);  	// 4		

    93 			aWriter.WriteInt(iCPMetaOffset);	   	// 4

    94 			aWriter.WriteInt(iCTMetaOffset);		// 4

    95 			aWriter.WriteInt(iCPCodeSegOffset);	// 4

    96 			aWriter.WriteInt(iSysUsrStkOffset);	// 4

    97 			aWriter.WriteInt(iSysSvrStkOffset);	// 4

    98 			aWriter.WriteInt(iSysUsrRegOffset);	// 4

    99 			aWriter.WriteInt(iSysSvrRegOffset);	// 4

   100 			aWriter.WriteInt(iTLstOffset);		// 4

   101 			aWriter.WriteInt(iPLstOffset);		// 4

   102 			aWriter.WriteInt(iSysCodeSegOffset);	// 4

   103 			aWriter.WriteInt(iExcStkOffset);		// 4

   104 			aWriter.WriteInt(iTraceOffset);		// 4

   105 			aWriter.WriteInt(iScmLocksOffset);	// 4

   106 			aWriter.WriteInt(iKernelHeapOffset);		// 4			

   107 			aWriter.WriteInt(iVarSpecInfOffset);		// 4

   108 			aWriter.WriteInt(iRomInfoOffset);		// 4	

   109 			}

   110 		else

   111 			{

   112 			CLTRACE("TCrashOffsetsHeader::Serialize Unsupported version");

   113 			}

   114 		

   115 		TInt sizeWritten = aWriter.CurrentPosition() - startPos;

   116 		if(sizeWritten != GetSize())

   117 			{

   118 			// error between actual size & real size in data

   119 			CLTRACE("TCrashOffsetsHeader serialization size error");	

   120 			return KErrCorrupt;

   121 			}

   122 

   123 		return KErrNone;

   124 		}

   125 	

   126 	/**

   127 	 * Reads the classes data from the specified byte stream

   128 	 * @param aReader Byte stream to use

   129 	 * @return One of the OS wide codes

   130 	 */

   131 	TInt TCrashOffsetsHeader::Deserialize(TByteStreamReader& aReader)	

   132 		{		

   133 		TInt startPos = aReader.CurrentPosition();

   134 		

   135 		iId = (SCMStructId)aReader.ReadInt();	// 4

   136 		if(iId != ESCMOffsetsHeader)

   137 			{

   138 			CLTRACE("TCrashOffsetsHeader::Deserialize Corrupt ID");

   139 			return KErrCorrupt;

   140 			}

   141 		

   142 		iVersion = (TCrashHeaderVersion)aReader.ReadShort();  //2

   143 		

   144 		if(iVersion == EChVersion1)

   145 			{	

   146 			iCTFullRegOffset = aReader.ReadInt(); // 4

   147 			iCTUsrStkOffset = aReader.ReadInt();	// 4

   148 			iCTSvrStkOffset = aReader.ReadInt();	// 4

   149 			iCPMetaOffset = aReader.ReadInt();	// 4		

   150 			iCTMetaOffset = aReader.ReadInt();	// 4

   151 			iCPCodeSegOffset = aReader.ReadInt();	// 4

   152 			iSysUsrStkOffset = aReader.ReadInt(); // 4

   153 			iSysSvrStkOffset = aReader.ReadInt(); // 4

   154 			iSysUsrRegOffset = aReader.ReadInt(); // 4

   155 			iSysSvrRegOffset = aReader.ReadInt(); // 4

   156 			iTLstOffset = aReader.ReadInt();		// 4

   157 			iPLstOffset = aReader.ReadInt();		// 4

   158 			iSysCodeSegOffset = aReader.ReadInt();// 4

   159 			iExcStkOffset = aReader.ReadInt();	// 4

   160 			iTraceOffset = aReader.ReadInt();		// 4

   161 			iScmLocksOffset = aReader.ReadInt();	// 4			

   162 			iKernelHeapOffset = aReader.ReadInt();		// 4

   163 			iVarSpecInfOffset = aReader.ReadInt();		// 4

   164 			iRomInfoOffset = aReader.ReadInt();		// 4						

   165 			}

   166 		else

   167 			{

   168 			CLTRACE("TCrashOffsetsHeader::Deserialize Unsupported version");

   169 			return KErrCorrupt;

   170 			}

   171 		

   172 		TInt endPos = aReader.CurrentPosition();

   173 		if( endPos - startPos != GetSize())

   174 			{

   175 			// error between actual size & real size in data

   176 			CLTRACE("TCrashOffsetsHeader deserialization size error");		

   177 			return KErrCorrupt;

   178 			}

   179 		return KErrNone;

   180 		}

   181 

   182 	/**

   183 	 * Get the externalised size of this class

   184 	 * @return TInt the Size

   185 	 */

   186 	TInt TCrashOffsetsHeader::GetSize() const

   187 		{

   188 		// return the size in bytes that this struct uses to serialize - deserialize itself

   189 		if(iVersion == EChVersion1)

   190 			{

   191 			return 82;

   192 			}

   193 		else

   194 			{

   195 			CLTRACE("TCrashOffsetsHeader::GetSize Unsupported version");			

   196 			return KErrNotSupported;

   197 			}

   198 		}

   199 	

   200 	TBool TCrashOffsetsHeader::operator == (const TCrashOffsetsHeader& aOther) const

   201 		{

   202 		return (iId ==  aOther.iId && 	

   203 				iVersion == aOther.iVersion &&	

   204 				iCTFullRegOffset == aOther.iCTFullRegOffset &&			

   205 				iCTUsrStkOffset == aOther.iCTUsrStkOffset &&

   206 				iCTSvrStkOffset == aOther.iCTSvrStkOffset &&

   207 				iCPMetaOffset == aOther.iCPMetaOffset &&

   208 				iCTMetaOffset == aOther.iCTMetaOffset &&		

   209 				iSysUsrStkOffset == aOther.iSysUsrStkOffset &&

   210 				iSysSvrStkOffset == aOther.iSysSvrStkOffset &&

   211 				iSysUsrRegOffset == aOther.iSysUsrRegOffset &&

   212 				iSysSvrRegOffset == aOther.iSysSvrRegOffset &&

   213 				iTLstOffset == aOther.iTLstOffset &&

   214 				iPLstOffset == aOther.iPLstOffset &&	

   215 				iExcStkOffset == aOther.iExcStkOffset &&	

   216 				iCPCodeSegOffset == aOther.iCPCodeSegOffset &&

   217 				iSysCodeSegOffset == aOther.iSysCodeSegOffset &&

   218 				iTraceOffset == aOther.iTraceOffset &&

   219 				iScmLocksOffset == aOther.iScmLocksOffset &&

   220 				iVarSpecInfOffset == aOther.iVarSpecInfOffset &&

   221 				iKernelHeapOffset == aOther.iKernelHeapOffset &&

   222 				iRomInfoOffset == aOther.iRomInfoOffset);

   223 		}

   224 	

   225 	

   226 	/**

   227 	 * TCrashInfoHeader implementation

   228 	 * @internal technology

   229 	 */

   230 	

   231 	/**

   232 	 * TCrashInfoHeader constructor

   233 	 */

   234 	TCrashInfoHeader::TCrashInfoHeader():

   235 		iId(ESCMTCrashInfo),

   236 		iVersion(ECiVersion1),

   237 		iLogSize(0),

   238 		iFlashAlign(0),

   239 		iCachedWriterSize(0),

   240 		iPid(0),

   241 		iTid(0),

   242 		iExitType(0),

   243 		iExitReason(0),

   244 		iExcCode(0),	

   245 		iCrashTime(0),

   246 		iCrashId(0),

   247 		iFlashBlockSize(0),

   248 		iFlashPartitionSize(0),

   249 		iCategorySize(0),

   250 		iSpare1(0),

   251 		iSpare2(0)

   252 		{		

   253 		TVersion ver(KSCMDataTypesMajorVersion, KSCMDataTypesMinorVersion, KSCMDataTypesBuildNumber);

   254 		iSCMDataTypesVersion = ver;

   255 		}

   256 

   257 	/**

   258 	 * Writes this classes data to the specified byte stream

   259 	 * @param aWriter byte stream to use

   260 	 * @return One of the OS wide codes

   261 	 */

   262 	TInt TCrashInfoHeader::Serialize(TByteStreamWriter& aWriter)

   263 		{	

   264 		

   265 		//CLTRACE("TCrashInfoHeader::Serialize");

   266 		TInt startPos = aWriter.CurrentPosition();

   267 		

   268 		// ID saved first 

   269 		aWriter.WriteInt(iId);		 				// 4		

   270 		if(iId != ESCMTCrashInfo)

   271 			{

   272 			CLTRACE("TCrashInfoHeader::Serialize Corrupt ID");

   273 			return KErrCorrupt;

   274 			}

   275 		

   276 		aWriter.WriteShort((TUint16) iVersion);			// 2

   277 

   278 		if(iVersion == ECiVersion1)

   279 			{

   280 			// write data v1 format

   281 			aWriter.WriteInt(iLogSize);					// 4

   282 			aWriter.WriteByte((TUint8)iFlashAlign);  	// 1

   283 			aWriter.WriteByte((TUint8)iCachedWriterSize);		// 1		

   284 			aWriter.WriteInt64(iPid);					// 8

   285 			aWriter.WriteInt64(iTid);					// 8

   286 			aWriter.WriteInt(iExitType);				// 4

   287 			aWriter.WriteInt(iExitReason);				// 4

   288 			aWriter.WriteInt(iExcCode);					// 4

   289 			aWriter.WriteInt64(iCrashTime);				// 8

   290 			aWriter.WriteInt(iCrashId);					// 4

   291 			aWriter.WriteInt(iFlashBlockSize);			// 4

   292 			aWriter.WriteInt(iFlashPartitionSize);			// 4

   293 			aWriter.WriteInt(iSCMDataTypesVersion.iMajor);  // 4

   294 			aWriter.WriteInt(iSCMDataTypesVersion.iMinor);  // 4

   295 			aWriter.WriteInt(iSCMDataTypesVersion.iBuild);  // 4

   296 			

   297 			if(iCategory.Ptr())

   298 				{

   299 				aWriter.WriteInt(iCategory.Length());	// 4		

   300 				for(TInt cnt = 0; cnt < iCategory.Length(); cnt++)

   301 					{

   302 					aWriter.WriteByte(iCategory[cnt]);  //iCategorySize bytes

   303 					}

   304 				}

   305 			else

   306 				{

   307 				aWriter.WriteInt(0);

   308 				}

   309 			}

   310 		else

   311 			{

   312 			CLTRACE("TCrashInfoHeader::Serialize Unsupported version");

   313 			return KErrCorrupt;

   314 			}

   315 		

   316 		TInt endPos = aWriter.CurrentPosition();

   317 		if( endPos - startPos != GetSize())

   318 			{

   319 			// error between actual size & real size in data

   320 			CLTRACE2("TCrashInfoHeader::Serialize serialization size error. Wrote [%d] but expected [%d]", endPos - startPos, GetSize());

   321 			return KErrCorrupt;

   322 			}

   323 		return KErrNone;

   324 		}

   325 	

   326 	/**

   327 	 * Reads the classes data from the specified byte stream

   328 	 * @param aReader Byte stream to use

   329 	 * @return One of the OS wide codes

   330 	 */

   331 	TInt TCrashInfoHeader::Deserialize(TByteStreamReader& aReader)	

   332 		{

   333 		TInt startPos = aReader.CurrentPosition();

   334 		

   335 		iId = (SCMStructId)aReader.ReadInt();

   336 		if(iId != ESCMTCrashInfo)

   337 			{

   338 			CLTRACE("TCrashInfoHeader::Deserialize Corrupt ID");

   339 			return KErrCorrupt;

   340 			}

   341 		

   342 		iVersion = (TCrashInfoHeaderVersion)aReader.ReadShort();			// 2

   343 

   344 		if(iVersion == ECiVersion1)

   345 			{

   346 			// read data v1 format

   347 			iLogSize = aReader.ReadInt(); 			 	    // 4

   348 			iFlashAlign = aReader.ReadByte();  				// 1

   349 			iCachedWriterSize = aReader.ReadByte();			// 1

   350 			iPid = aReader.ReadInt64();						// 8

   351 			iTid = aReader.ReadInt64();						// 8

   352 			iExitType = aReader.ReadInt();					// 4

   353 			iExitReason = aReader.ReadInt();				// 4

   354 			iExcCode = aReader.ReadInt();					// 4

   355 			iCrashTime = aReader.ReadInt64();				// 8

   356 			iCrashId = aReader.ReadInt();					// 4

   357 			iFlashBlockSize = aReader.ReadInt(); 			// 4	

   358 			iFlashPartitionSize = aReader.ReadInt(); 		// 4

   359 			iSCMDataTypesVersion.iMajor = aReader.ReadInt(); 		// 4

   360 			iSCMDataTypesVersion.iMinor = aReader.ReadInt(); 		// 4

   361 			iSCMDataTypesVersion.iBuild = aReader.ReadInt(); 		// 4			

   362 			

   363 

   364 			iCategorySize = aReader.ReadInt(); 				// 4

   365 			

   366 			if(iCategory.MaxLength() >= (TInt)iCategorySize)

   367 				{

   368 				iCategory.SetLength(0);

   369 				

   370 				for(TUint cnt = 0; cnt < iCategorySize; cnt++)

   371 					{

   372 					iCategory.Append(aReader.ReadByte());		//iCategorySize bytes

   373 					} 

   374 				}

   375 			}

   376 		else

   377 			{

   378 			iId = ESCMLast;	//unrecognised header

   379 			CLTRACE("TCrashInfoHeader::Deserialize Unsupported version");

   380 			return KErrCorrupt;

   381 			}

   382 		

   383 		TInt endPos = aReader.CurrentPosition();

   384 		if( endPos - startPos != GetSize())

   385 			{					

   386 			// error between actual size & real size in data

   387 			CLTRACE2("TCrashInfoHeader::Deserialize serialization size error. Read [%d] but expected [%d]", endPos - startPos, GetSize());			

   388 			iId = ESCMLast;	//unrecognised header

   389 			

   390 			return KErrCorrupt;

   391 			}

   392 		return KErrNone;

   393 		}

   394 	

   395 	/**

   396 	 * Returns the externalised size of this class

   397 	 * @return TInt size

   398 	 */

   399 	TInt TCrashInfoHeader::GetSize() const

   400 		{

   401 		if(iVersion == ECiVersion1)

   402 			{

   403 			return 76 + iCategory.Length();

   404 			}

   405 		else

   406 			{

   407 			CLTRACE("TCrashInfoHeader::GetSize Unsupported version");			

   408 			return KErrNotSupported;		

   409 			}

   410 		}

   411 		

   412 	TBool TCrashInfoHeader::operator == (const TCrashInfoHeader& aOther) const

   413 		{

   414 		return (

   415 			iId == aOther.iId &&

   416 			iVersion == aOther.iVersion &&

   417 			iLogSize == aOther.iLogSize &&	

   418 			iFlashAlign == aOther.iFlashAlign &&

   419 			iCachedWriterSize == aOther.iCachedWriterSize &&

   420 			iPid == aOther.iPid &&

   421 			iTid == aOther.iTid &&

   422 			iExitType == aOther.iExitType &&

   423 			iExitReason == aOther.iExitReason &&

   424 			iCrashTime == aOther.iCrashTime &&

   425 			iCategorySize == aOther.iCategorySize &&

   426 			iCategory == aOther.iCategory &&

   427 			iSCMDataTypesVersion.iMajor == aOther.iSCMDataTypesVersion.iMajor &&

   428 			iSCMDataTypesVersion.iMinor == aOther.iSCMDataTypesVersion.iMinor &&

   429 			iSCMDataTypesVersion.iBuild == aOther.iSCMDataTypesVersion.iBuild);

   430 		}	

   431 

   432 	/**

   433 	 * TThreadStack implementation

   434 	 * @internal technology

   435 	 */

   436 	

   437 	

   438 	/**

   439 	 * TThreadStack Constructor

   440 	 */

   441 	TThreadStack::TThreadStack():

   442 		iId(ESCMThreadStack),

   443 		iVersion(EStackVersion1),

   444 		iStackType(ELast),

   445 		iThreadId(0),

   446 		iStackSize(0),		

   447 		iSpare1(0),

   448 		iSpare2(0)

   449 		{		

   450 		}

   451 	

   452 	/**

   453 	 * Writes this classes data to the specified byte stream

   454 	 * @param aWriter byte stream to use

   455 	 * @return One of the OS wide codes

   456 	 */

   457 	TInt TThreadStack::Serialize(TByteStreamWriter& aWriter)

   458 		{

   459 		TInt startPos = aWriter.CurrentPosition();

   460 		

   461 		if(iId != ESCMThreadStack)

   462 			{

   463 			CLTRACE("TThreadStack::Serialize failed - corrupt ID");

   464 			return KErrCorrupt;

   465 			}

   466 		

   467 		aWriter.WriteInt(iId);							// 4		

   468 		aWriter.WriteShort((TUint16) iVersion);			// 2

   469 

   470 		if(iVersion == EStackVersion1)

   471 			{

   472 			// write data v1 format	

   473 			aWriter.WriteInt(iStackType);		 		// 4		

   474 			aWriter.WriteInt64(iThreadId); 			 	// 8

   475 			aWriter.WriteInt(iStackSize);  				// 4

   476 			}

   477 		else

   478 			{

   479 			CLTRACE("TThreadStack::Serialize Unsupported version");

   480 			return KErrCorrupt;

   481 			}

   482 		

   483 		TInt endPos = aWriter.CurrentPosition();

   484 		if( endPos - startPos != GetSize())

   485 			{

   486 			// error between actual size & real size in data

   487 			CLTRACE("TThreadStack::Serialize serialization size error");

   488 			return KErrCorrupt;

   489 			}

   490 		return KErrNone;

   491 		}

   492 	

   493 	/**

   494 	 * Returns the externalised size of this class

   495 	 * @return TInt size

   496 	 */

   497 	TInt TThreadStack::GetSize() const

   498 		{

   499 		if(iVersion == EStackVersion1)

   500 			{

   501 			return 22;

   502 			}

   503 		else

   504 			{

   505 			CLTRACE("TThreadStack::GetSize Unsupported version");			

   506 			return KErrNotSupported;		

   507 			}

   508 		}

   509 	

   510 	/**

   511 	 * Reads the classes data from the specified byte stream

   512 	 * @param aReader Byte stream to use

   513 	 * @return One of the OS wide codes

   514 	 */

   515 	TInt TThreadStack::Deserialize(TByteStreamReader& aReader)

   516 		{

   517 		TInt startPos = aReader.CurrentPosition();

   518 		

   519 		iId = (SCMStructId)aReader.ReadInt();			// 4

   520 		if(iId != ESCMThreadStack)

   521 			{

   522 			CLTRACE("TThreadStack::Deserialize failed Corrupt ID");

   523 			return KErrCorrupt;

   524 			}

   525 		

   526 		iVersion = (TThreadStackVersion)aReader.ReadShort();			// 2

   527 

   528 		if(iVersion == EStackVersion1)

   529 			{

   530 			// read data v1 format	

   531 			iStackType = (TThreadStackType)aReader.ReadInt();		// 4

   532 			iThreadId = aReader.ReadInt64();	// 8

   533 			iStackSize = aReader.ReadInt();		// 4

   534 

   535 			}

   536 		else

   537 			{

   538 			iId = ESCMLast;	//unrecognised header

   539 			CLTRACE("TThreadStack::Deserialize Unsupported version");

   540 			return KErrCorrupt;

   541 			}

   542 		

   543 		TInt endPos = aReader.CurrentPosition();

   544 		if( endPos - startPos != GetSize())

   545 			{

   546 			iId = ESCMLast;	//unrecognised header

   547 			

   548 			// error between actual size & real size in data

   549 			CLTRACE("TThreadStack::Deserialize serialization size error");	

   550 			return KErrCorrupt;

   551 			}

   552 		return KErrNone;

   553 		}

   554 	

   555 	/**

   556 	 * TRegisterValue implementation

   557 	 * @internal technology

   558 	 */

   559 	

   560 	/**

   561 	 * TRegisterValue Constructor

   562 	 */

   563 	TRegisterValue::TRegisterValue():

   564 		iId(ESCMRegisterValue),

   565 		iVersion(ERegisterValueVersion1),

   566 		iOwnId(0),

   567 		iType(0),

   568 		iClass(0), //core reg by default

   569 		iSubId(0),		

   570 		iSize(2) //default for core registers

   571 		{

   572 		}

   573 	

   574 	

   575 	/**

   576 	 * Returns the externalised size of this class

   577 	 * @return TInt size

   578 	 */	 

   579 	TInt TRegisterValue::GetSize() const

   580 		{

   581 		if(iVersion == ERegisterValueVersion1)

   582 			{

   583 			TInt baseSize = 22;

   584 			

   585 			//variant for union

   586 			if(iSize == 0)

   587 				{

   588 				return baseSize + 1;

   589 				}

   590 			else if(iSize == 1)

   591 				{

   592 				return baseSize + 2;

   593 				}

   594 			else if(iSize == 2)

   595 				{

   596 				return baseSize + 4;

   597 				}

   598 			else if(iSize == 3)

   599 				{

   600 				return baseSize + 8;

   601 				}

   602 			else

   603 				{

   604 				CLTRACE("TRegisterValue::GetSize() Corrupt size");

   605 				return 0;

   606 				}

   607 			}

   608 		else

   609 			{

   610 			CLTRACE("TRegisterValue::GetSize Unsupported version");			

   611 			return KErrNotSupported;		

   612 			}

   613 		}

   614 	

   615 	/**

   616 	 * Writes this classes data to the specified byte stream 

   617 	 * @param aWriter byte stream to use

   618 	 * @return One of the OS wide codes

   619 	 */	 

   620 	TInt TRegisterValue::Serialize(TByteStreamWriter& aWriter)

   621 		{

   622 		TInt startPos = aWriter.CurrentPosition();

   623 				

   624 		// ID saved first

   625 		if(iId != ESCMRegisterValue)

   626 			{

   627 			CLTRACE("TRegisterValue::Serialize Error - Corrupt ID");

   628 			return KErrCorrupt;

   629 			}

   630 		

   631 		aWriter.WriteInt(iId);							// 4

   632 		aWriter.WriteShort((TUint16) iVersion);			// 2

   633 

   634 		if(iVersion == ERegisterValueVersion1)

   635 			{

   636 			// write data v1 format	

   637 			aWriter.WriteInt64(iOwnId);		 				// 8

   638 			aWriter.WriteInt(iType);						// 4

   639 			aWriter.WriteByte(iClass);						// 1

   640 			aWriter.WriteShort(iSubId);						// 2

   641 			aWriter.WriteByte(iSize);						// 1

   642 			

   643 			//variant for union

   644 			if(iSize == 0)

   645 				{

   646 				aWriter.WriteByte(iValue8);

   647 				}

   648 			else if(iSize == 1)

   649 				{

   650 				aWriter.WriteShort(iValue16);

   651 				}

   652 			else if(iSize == 2)

   653 				{

   654 				aWriter.WriteInt(iValue32);

   655 				}

   656 			else if(iSize == 3)

   657 				{

   658 				aWriter.WriteInt64(iValue64);

   659 				}

   660 			else

   661 				{

   662 				CLTRACE("TRegisterValue::Serialize() Corrupt size");

   663 				return KErrCorrupt;

   664 				}

   665 			}

   666 		else

   667 			{

   668 			CLTRACE("TRegisterValue::Serialize Unsupported version");

   669 			}

   670 		

   671 		TInt endPos = aWriter.CurrentPosition();

   672 		if( endPos - startPos != GetSize())

   673 			{

   674 			// error between actual size & real size in data

   675 			CLTRACE("TRegisterValue::Serialize serialization size error");	

   676 			return KErrCorrupt;

   677 			}

   678 		

   679 		return KErrNone;

   680 		}

   681 	

   682 	/**

   683 	 * Reads the classes data from the specified byte stream

   684 	 * @param aReader Byte stream to use

   685 	 * @return One of the OS wide codes

   686 	 */	 

   687 	TInt TRegisterValue::Deserialize(TByteStreamReader& aReader)

   688 		{

   689 		TInt startPos = aReader.CurrentPosition();

   690 		

   691 		iId = (SCMStructId)aReader.ReadInt();

   692 		if(iId != ESCMRegisterValue)

   693 			{

   694 			CLTRACE("TRegisterValue::Deserialize() ERROR Corrupt ID");			

   695 			return KErrCorrupt;

   696 			}

   697 		

   698 		iVersion = (TRegisterValueVersion)aReader.ReadShort();			// 2

   699 

   700 		if(iVersion == ERegisterValueVersion1)

   701 			{

   702 			// read data v1 format	

   703 			iOwnId = aReader.ReadInt64();		 				// 8

   704 			iType = aReader.ReadInt();  						// 4

   705 			iClass = aReader.ReadByte();						// 1

   706 			iSubId = aReader.ReadShort();						// 2

   707 			iSize = aReader.ReadByte();							// 1

   708 			

   709 			//variant for union

   710 			if(iSize == 0)

   711 				{

   712 				iValue8 = aReader.ReadByte();				

   713 				}

   714 			else if(iSize == 1)

   715 				{

   716 				iValue16 = aReader.ReadShort();				

   717 				}

   718 			else if(iSize == 2)

   719 				{

   720 				iValue32 = aReader.ReadInt();

   721 				}

   722 			else if(iSize == 3)

   723 				{

   724 				iValue64 = aReader.ReadInt64();

   725 				}

   726 			else

   727 				{

   728 				CLTRACE("TRegisterValue::Serialize() Corrupt size");

   729 				return KErrCorrupt;

   730 				}

   731 			}

   732 		else

   733 			{

   734 			iId = ESCMLast;	//unrecognised header

   735 			CLTRACE("TRegisterValue::Deserialize Unsupported version");

   736 			return KErrCorrupt;

   737 			}

   738 		

   739 		TInt endPos = aReader.CurrentPosition();

   740 		if( endPos - startPos != GetSize())

   741 			{

   742 			iId = ESCMLast;	//unrecognised header

   743 			

   744 			// error between actual size & real size in data

   745 			CLTRACE("TRegisterValue::Deserialize serialization size error");	

   746 			return KErrCorrupt;

   747 			}

   748 		

   749 		return KErrNone;

   750 		}

   751 	

   752 	/**

   753 	 * TRegisterSet implementation

   754 	 * @internal technology

   755 	 */

   756 	

   757 	/**

   758 	 * TRegisterSet Constructor

   759 	 */

   760 	TRegisterSet::TRegisterSet():

   761 		iVersion(ETRegisterSetVersion1),

   762 		iId(ESCMRegisterSet),		

   763 		iNumRegisters(0)

   764 		{

   765 

   766 		}

   767 	

   768 	/**

   769 	 * Returns the externalised size of this class

   770 	 * @return TInt size

   771 	 */

   772 	TInt TRegisterSet::GetSize() const

   773 		{

   774 		if(iVersion == ETRegisterSetVersion1)

   775 			{

   776 			return 10;

   777 			}

   778 		else

   779 			{

   780 			CLTRACE("TRegisterSet::GetSize Unsupported version");			

   781 			return KErrNotSupported;		

   782 			}

   783 		}

   784 	

   785 	/**

   786 	 * Writes this classes data to the specified byte stream

   787 	 * @param aWriter byte stream to use

   788 	 * @return One of the OS wide codes

   789 	 */

   790 	TInt TRegisterSet::Serialize(TByteStreamWriter& aWriter)

   791 		{

   792 		TInt startPos = aWriter.CurrentPosition();

   793 				

   794 		// ID saved first

   795 		if(iId != ESCMRegisterSet)

   796 			{

   797 			CLTRACE("TRegisterSet::Serialize Error - Corrupt ID");

   798 			return KErrCorrupt;

   799 			}

   800 		

   801 		aWriter.WriteInt(iId);							// 4

   802 		aWriter.WriteShort((TUint16) iVersion);			// 2

   803 

   804 		if(iVersion == ETRegisterSetVersion1)

   805 			{

   806 			// write data v1 format

   807 			aWriter.WriteInt(iNumRegisters);				// 4

   808 			}

   809 		else

   810 			{

   811 			CLTRACE("TRegisterSet::Serialize Unsupported version");

   812 			return KErrCorrupt;

   813 			}

   814 		

   815 		TInt endPos = aWriter.CurrentPosition();

   816 		if( endPos - startPos != GetSize())

   817 			{

   818 			// error between actual size & real size in data

   819 			CLTRACE("TRegisterSet::Serialize serialization size error");

   820 			return KErrCorrupt;

   821 			}

   822 		

   823 		return KErrNone;

   824 		}

   825 	

   826 	/**

   827 	 * Reads the classes data from the specified byte stream

   828 	 * @param aReader Byte stream to use

   829 	 * @return One of the OS wide codes

   830 	 */

   831 	TInt TRegisterSet::Deserialize(TByteStreamReader& aReader)

   832 		{

   833 		TInt startPos = aReader.CurrentPosition();

   834 		

   835 		iId = (SCMStructId)aReader.ReadInt();

   836 		if(iId != ESCMRegisterSet)

   837 			{

   838 			CLTRACE("TRegisterSet::Deserialize() ERROR Corrupt ID");			

   839 			return KErrCorrupt;

   840 			}

   841 		

   842 		iVersion = (TRegisterSetVersion)aReader.ReadShort();			// 2

   843 

   844 		if(iVersion == ETRegisterSetVersion1)

   845 			{

   846 			// read data v1 format	

   847 			iNumRegisters = aReader.ReadInt();		 				// 8

   848 			}

   849 		else

   850 			{

   851 			iId = ESCMLast;	//unrecognised header

   852 			CLTRACE("TRegisterSet::Deserialize Unsupported version");

   853 			return KErrCorrupt;

   854 			}

   855 		

   856 		TInt endPos = aReader.CurrentPosition();

   857 		if( endPos - startPos != GetSize())

   858 			{

   859 			iId = ESCMLast;	//unrecognised header

   860 			

   861 			// error between actual size & real size in data

   862 			CLTRACE("TRegisterSet::Deserialize serialization size error");	

   863 			return KErrCorrupt;

   864 			}

   865 		return KErrNone;

   866 		}

   867 	

   868 	/**

   869 	 * TCodeSegmentSet implementation

   870 	 * @internal technology

   871 	 */

   872 	

   873 	/**

   874 	 * TCodeSegmentSet Constructor

   875 	 */

   876 	TCodeSegmentSet::TCodeSegmentSet():

   877 		iId(ESCMCodeSegSet),

   878 		iVersion(ETCodeSegmentSetVersion1),

   879 		iNumSegs(0),

   880 		iPid(0)		

   881 		{

   882 		}

   883 	

   884 	/**

   885 	 * Returns the externalised size of this class

   886 	 * @return TInt size

   887 	 */

   888 	TInt TCodeSegmentSet::GetSize() const

   889 		{

   890 		if(iVersion == ETCodeSegmentSetVersion1)

   891 			{

   892 			return 18;

   893 			}

   894 		else

   895 			{

   896 			CLTRACE("TCodeSegmentSet::GetSize Unsupported version");			

   897 			return KErrNotSupported;		

   898 			}

   899 		}

   900 	

   901 	/**

   902 	 * This returns the largest size this class can be

   903 	 */

   904 	TInt TCodeSegmentSet::GetMaxSize() const

   905 		{

   906 		return 18;

   907 		}

   908 	

   909 	/**

   910 	 * Writes this classes data to the specified byte stream

   911 	 * @param aWriter byte stream to use

   912 	 * @return One of the OS wide codes

   913 	 */

   914 	TInt TCodeSegmentSet::Serialize(TByteStreamWriter& aWriter)

   915 		{

   916 		TInt startPos = aWriter.CurrentPosition();

   917 				

   918 		// ID saved first

   919 		if(iId != ESCMCodeSegSet)

   920 			{

   921 			CLTRACE("TCodeSegmentSet::Serialize Error - Corrupt ID");

   922 			return KErrCorrupt;

   923 			}

   924 		

   925 		aWriter.WriteInt(iId);							// 4

   926 		if(iId != ESCMCodeSegSet)

   927 			{

   928 			CLTRACE("TCodeSegmentSet::Serialize Corrupt ID");

   929 			return KErrCorrupt;

   930 			}

   931 		

   932 		aWriter.WriteShort((TUint16) iVersion);			// 2

   933 

   934 		if(iVersion == ETCodeSegmentSetVersion1)

   935 			{

   936 			// write data v1 format

   937 			aWriter.WriteInt(iNumSegs);				// 4

   938 			aWriter.WriteInt64(iPid);				// 8

   939 			}

   940 		else

   941 			{

   942 			CLTRACE("TCodeSegmentSet::Serialize Unsupported version");

   943 			return KErrCorrupt;

   944 			}

   945 		

   946 		TInt endPos = aWriter.CurrentPosition();

   947 		if( endPos - startPos != GetSize())

   948 			{

   949 			// error between actual size & real size in data

   950 			CLTRACE("TCodeSegmentSet::Serialize serialization size error");	

   951 			return KErrCorrupt;

   952 			}

   953 		return KErrNone;

   954 		}

   955 	

   956 	/**

   957 	 * Reads the classes data from the specified byte stream

   958 	 * @param aReader Byte stream to use

   959 	 * @return One of the OS wide codes

   960 	 */

   961 	TInt TCodeSegmentSet::Deserialize(TByteStreamReader& aReader)

   962 		{

   963 		TInt startPos = aReader.CurrentPosition();

   964 		

   965 		iId = (SCMStructId)aReader.ReadInt();

   966 		if(iId != ESCMCodeSegSet)

   967 			{

   968 			CLTRACE("TCodeSegmentSet::Deserialize() ERROR Corrupt ID");			

   969 			return KErrCorrupt;

   970 			}

   971 		

   972 		iVersion = (TCodeSegmentSetVersion)aReader.ReadShort();			// 2

   973 

   974 		if(iVersion == ETCodeSegmentSetVersion1)

   975 			{

   976 			// read data v1 format	

   977 			iNumSegs = aReader.ReadInt();    				// 4

   978 			iPid = aReader.ReadInt64();		 				// 8

   979 			}

   980 		else

   981 			{

   982 			iId = ESCMLast;	//unrecognised header

   983 			CLTRACE("TRegisterSet::Deserialize Unsupported version");

   984 			return KErrCorrupt;

   985 			}

   986 		

   987 		TInt endPos = aReader.CurrentPosition();

   988 		if( endPos - startPos != GetSize())

   989 			{

   990 			iId = ESCMLast;	//unrecognised header

   991 			

   992 			// error between actual size & real size in data

   993 			CLTRACE("TRegisterSet::Deserialize serialization size error");	

   994 			return KErrCorrupt;

   995 			}

   996 		

   997 		return KErrNone;

   998 		}	

   999 	

  1000 	

  1001 	/**

  1002 	 * TCodeSegment implementation

  1003 	 * @internal technology

  1004 	 */

  1005 	

  1006 	/**

  1007 	 * TCodeSegment constructor

  1008 	 */

  1009 	TCodeSegment::TCodeSegment():

  1010 		iId(ESCMCodeSeg),

  1011 		iVersion(ETCodeSegmentVersion1),			

  1012 		iCodeSegType(EUnknownCodeSegType),		

  1013 		iXip(0),					

  1014 		iNameLength(0)		

  1015 		{

  1016 		}

  1017 

  1018 	/**

  1019 	 * Writes this classes data to the specified byte stream

  1020 	 * @param aWriter byte stream to use

  1021 	 * @return One of the OS wide codes

  1022 	 */

  1023 	TInt TCodeSegment::Serialize(TByteStreamWriter& aWriter)

  1024 		{	

  1025 		TInt startPos = aWriter.CurrentPosition();

  1026 		

  1027 		// ID saved first 

  1028 		aWriter.WriteInt(iId);		 				// 4		

  1029 		if(iId != ESCMCodeSeg)

  1030 			{

  1031 			CLTRACE("TCodeSegment::Serialize Error - Corrupt ID");

  1032 			return KErrCorrupt;

  1033 			}

  1034 		

  1035 		aWriter.WriteShort((TUint16) iVersion);			// 2

  1036 

  1037 		if(iVersion == ETCodeSegmentVersion1)

  1038 			{

  1039 			// write data v1 format

  1040 			aWriter.WriteInt(iCodeSegType);

  1041 			aWriter.WriteInt(iCodeSegMemInfo.iCodeBase);

  1042 			aWriter.WriteInt(iCodeSegMemInfo.iCodeSize);

  1043 			aWriter.WriteInt(iCodeSegMemInfo.iConstDataBase);

  1044 			aWriter.WriteInt(iCodeSegMemInfo.iConstDataSize);

  1045 			aWriter.WriteInt(iCodeSegMemInfo.iInitialisedDataBase);

  1046 			aWriter.WriteInt(iCodeSegMemInfo.iInitialisedDataSize);

  1047 			aWriter.WriteInt(iCodeSegMemInfo.iUninitialisedDataBase);

  1048 			aWriter.WriteInt(iCodeSegMemInfo.iUninitialisedDataSize);

  1049 			aWriter.WriteInt(iXip);

  1050 			

  1051 			if(iName.Ptr())

  1052 				{

  1053 				aWriter.WriteInt(iName.Length());	// 4		

  1054 				for(TInt cnt = 0; cnt < iName.Length(); cnt++)

  1055 					{

  1056 					aWriter.WriteByte(iName[cnt]);  //iCategorySize bytes

  1057 					}

  1058 				}

  1059 			else

  1060 				{

  1061 				aWriter.WriteInt(0);

  1062 				}

  1063 			}

  1064 		else

  1065 			{

  1066 			CLTRACE("TCodeSegment::Serialize Unsupported version");

  1067 			return KErrCorrupt;

  1068 			}

  1069 		

  1070 		TInt endPos = aWriter.CurrentPosition();

  1071 		if( endPos - startPos != GetSize())

  1072 			{

  1073 			// error between actual size & real size in data

  1074 			CLTRACE2("TCodeSegment::Serialize serialization size error. Wrote [%d] but expected [%d]", endPos - startPos, GetSize());

  1075 			return KErrCorrupt;

  1076 			}

  1077 		return KErrNone;

  1078 		}

  1079 	

  1080 	/**

  1081 	 * Reads the classes data from the specified byte stream

  1082 	 * @param aReader Byte stream to use

  1083 	 * @return One of the OS wide codes

  1084 	 */

  1085 	TInt TCodeSegment::Deserialize(TByteStreamReader& aReader)	

  1086 		{

  1087 		TInt startPos = aReader.CurrentPosition();

  1088 		

  1089 		iId = (SCMStructId)aReader.ReadInt();

  1090 		if(iId != ESCMCodeSeg)

  1091 			{

  1092 			CLTRACE("TCodeSegment::Deserialize Corrupt ID");

  1093 			return KErrCorrupt;

  1094 			}

  1095 		

  1096 		iVersion = (TCodeSegmentVersion)aReader.ReadShort();			// 2

  1097 

  1098 		if(iVersion == ETCodeSegmentVersion1)

  1099 			{

  1100 			// read data v1 format			

  1101 			iCodeSegType = (TCodeSegType)aReader.ReadInt();

  1102 			iCodeSegMemInfo.iCodeBase = aReader.ReadInt();

  1103 			iCodeSegMemInfo.iCodeSize = aReader.ReadInt();

  1104 			iCodeSegMemInfo.iConstDataBase = aReader.ReadInt();

  1105 			iCodeSegMemInfo.iConstDataSize = aReader.ReadInt();

  1106 			iCodeSegMemInfo.iInitialisedDataBase = aReader.ReadInt();

  1107 			iCodeSegMemInfo.iInitialisedDataSize = aReader.ReadInt();

  1108 			iCodeSegMemInfo.iUninitialisedDataBase = aReader.ReadInt();

  1109 			iCodeSegMemInfo.iUninitialisedDataSize = aReader.ReadInt();

  1110 			iXip = aReader.ReadInt();

  1111 			iNameLength = aReader.ReadInt(); 				// 4

  1112 			

  1113 			if(iName.Ptr() && iName.MaxLength() >= iNameLength)

  1114 				{

  1115 				iName.SetLength(0);

  1116 				

  1117 				for(TInt cnt = 0; cnt < iNameLength; cnt++)

  1118 					{

  1119 					iName.Append(aReader.ReadByte());		//iCategorySize bytes

  1120 					} 

  1121 				}

  1122 			}

  1123 		else

  1124 			{

  1125 			iId = ESCMLast;	//unrecognised header

  1126 			CLTRACE("TCodeSegment::Deserialize Unsupported version");

  1127 			return KErrCorrupt;

  1128 			}

  1129 		

  1130 		TInt endPos = aReader.CurrentPosition();

  1131 		if( endPos - startPos != GetSize())

  1132 			{					

  1133 			// error between actual size & real size in data

  1134 			CLTRACE2("TCodeSegment::Deserialize serialization size error. Read [%d] but expected [%d]", endPos - startPos, GetSize());