1 /*

     2 * Copyright (c) 2004-2009 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of the License "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

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

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description: 

    15 *

    16 */

    17 

    18 

    19 #include "fsmarshaller.h"

    20 #include "fsdatatypes.h"

    21 #include "NullStream.h"

    22 #include <asymmetric.h>

    23 #include <bigint.h>

    24 #include <pbedata.h>

    25 #include <s32mem.h>

    26 #include <certificateapps.h>

    27 #include <ccertattributefilter.h>

    28 

    29 // Generic externalization stuff ///////////////////////////////////////////////

    30 

    31 /**

    32  * Determine how many bytes are taked up by the externalized representation of

    33  * an object.

    34  */

    35 template <class T>

    36 TInt Size(const T& aObject)

    37 	{

    38 	RNullWriteStream stream;

    39 	TRAPD(err, stream << aObject);

    40 	if(err != KErrNone)

    41 		{

    42 		_LIT(KPanicCategory, "InValid Size");

    43 		User::Panic(KPanicCategory,ESerialisationPanic);

    44 		}

    45 	stream.Close();

    46 	return stream.BytesWritten();

    47 	}

    48 

    49 /**

    50  * Externalize an object to a buffer.  Leaves if an error occurs.

    51  */

    52 template <class T>

    53 void WriteL(const T& aIn, TDes8& aOut)

    54 	{

    55 	RDesWriteStream stream(aOut);

    56 	stream << aIn;

    57 	stream.Close();

    58 	}

    59 

    60 /**

    61  * Externalize an object to a buffer.  In debug mode, it will panics if an error

    62  * occurs - eg buffer is too short.  In release mode, errors are ignored.

    63  */

    64 template <class T>

    65 void Write(const T& aIn, TDes8& aOut)

    66 	{

    67 	TRAPD(err, WriteL(aIn, aOut));

    68 	if(err != KErrNone)

    69 		{

    70 		_LIT(KPanicCategory, "Writing Error");

    71 		User::Panic(KPanicCategory,ESerialisationPanic);

    72 		}

    73 	}

    74 

    75 /**

    76  * Implement Externalization selector for RPointerArrays to use a function.

    77  */

    78 template <class T>

    79 EXTERNALIZE_FUNCTION(RPointerArray<T>)

    80 

    81 /**

    82  * Function to externalize RPointerArrays.

    83  *

    84  * Although this is generic, it's currently only instantiated for CKeyInfo.

    85  */

    86 template <class T>

    87 void ExternalizeL(const RPointerArray<T>& aIn, RWriteStream& aOut)

    88 	{

    89 	TInt count = aIn.Count();

    90 	aOut.WriteInt32L(count);

    91 	for (TInt i = 0 ; i < count ; ++i)

    92 		{

    93 		T* object = aIn[i];

    94 		if (object == NULL)

    95 			{

    96 			User::Leave(KErrArgument);

    97 			}

    98 		aOut << *object;

    99 		}

   100 	}

   101 

   102 /**

   103  * Implement Externalization selector for RArrays to use a function.

   104  */

   105 template <class T>

   106 EXTERNALIZE_FUNCTION(RArray<T>)

   107 

   108 /**

   109  * Function to externalize RArrays.

   110  */

   111 template <class T>

   112 void ExternalizeL(const RArray<T>& aIn, RWriteStream& aOut)

   113 	{

   114 	TInt count = aIn.Count();

   115 	aOut.WriteInt32L(count);

   116 	for (TInt i = 0 ; i < count ; ++i)

   117 		{

   118 		aOut << aIn[i];

   119 		}

   120 	}

   121 

   122 // No-so-generic internalization stuff /////////////////////////////////////////

   123 

   124 /**

   125  * Internalize an object from a descriptor.

   126  */

   127 template <class T>

   128 void ReadL(const TDesC8& aIn, T& aOut)

   129 	{

   130 	RDesReadStream stream(aIn);

   131 	stream >> aOut;

   132 	stream.Close();

   133 	}

   134 

   135 /**

   136  * Implement Internalization selector for RArrays to use a function.

   137  */

   138 template <class T>

   139 inline Internalize::Function Internalization(const RArray<T>*)

   140 	{

   141 	return Internalize::Function();

   142 	}

   143 

   144 /**

   145  * Function to internalize an RArray.

   146  */

   147 template <class T>

   148 void InternalizeL(RArray<T>& aOut, RReadStream& aIn)

   149 	{

   150 	ASSERT(aOut.Count() == 0);

   151 	TInt count = aIn.ReadInt32L();

   152 	for (TInt i = 0 ; i < count ; ++i)

   153 		{

   154 		T t;

   155 		aIn >> t;

   156 		User::LeaveIfError(aOut.Append(t));

   157 		}

   158 	}

   159 

   160 /**

   161  * Internalize an object from a stream.  Creates an instance by calling the

   162  * class' NewL(RReadStream&) method.

   163  */

   164 template <class T>

   165 inline void CreateL(RReadStream& aIn, T*& aOut)

   166 	{

   167 	aOut = T::NewL(aIn);

   168 	}

   169 

   170 /**

   171  * Internalize an object from a descriptor.  

   172  */

   173 template <class T>

   174 void CreateL(const TDesC8& aIn, T& aOut)

   175 	{

   176 	RDesReadStream stream(aIn);

   177 	CreateL(stream, aOut);

   178 	stream.Close();

   179 	}

   180 

   181 /**

   182  * Internalize an object from a descriptor leaving the result on the cleanup

   183  * stack.  This is generic, but is only instantiated for RInteger.

   184  */

   185 template <class T>

   186 void CreateLC(const TDesC8& aIn, T& aOut)

   187 	{

   188 	RDesReadStream stream(aIn);

   189 	CreateLC(stream, aOut);

   190 	stream.Close();

   191 	}

   192 

   193 /**

   194  * Internalize a cryptotokens object from a descriptor.

   195  */

   196 template <class T>

   197 void CreateL(const TDesC8& aIn, MCTToken& aToken, T& aOut)

   198 	{

   199 	RDesReadStream stream(aIn);

   200 	CreateL(stream, aToken, aOut);

   201 	stream.Close();

   202 	}

   203 

   204 /**

   205  * Internalize a cryptotoken object from a stream.  Creates an instance by

   206  * calling the class' NewL(RReadStream&, MCTToken&) method.

   207  */

   208 template <class T>

   209 inline void CreateL(RReadStream& aIn, MCTToken& aToken, T*& aOut)

   210 	{

   211 	aOut = T::NewL(aIn, aToken);

   212 	}

   213 

   214 /**

   215  * Internalize an array of of key info objects from a stream. 

   216  */

   217 void CreateL(RReadStream& aIn, MCTToken& aToken, MKeyInfoArray& aOut)

   218 	{

   219 	TInt count = aIn.ReadInt32L();

   220 	for (TInt i = 0 ; i < count ; ++i)

   221 		{

   222 		CCTKeyInfo* t;

   223 		CreateL(aIn, aToken, t);

   224 		CleanupReleasePushL(*t);

   225 		User::LeaveIfError(aOut.Append(t));

   226 		CleanupStack::Pop();

   227 		}

   228 	}

   229 

   230 // can we combine this with the one above?

   231 

   232 /**

   233  * Internalize an RMPointerArray of cryptotoken objects from a stream.

   234  */

   235 template <class T>

   236 void CreateL(RReadStream& aIn, MCTToken& aToken, RMPointerArray<T>& aOut)

   237 	{	

   238 	TInt count = aIn.ReadInt32L();

   239 	for (TInt i = 0 ; i < count ; ++i)

   240 		{

   241 		T* t;

   242 		CreateL(aIn, aToken, t);

   243 		CleanupReleasePushL(*t);

   244 		User::LeaveIfError(aOut.Append(t));

   245 		CleanupStack::Pop();

   246 		}

   247 	}

   248 

   249 // Serialization for RIntegers /////////////////////////////////////////////////

   250 

   251 // This is exported as it is useful itself in the server

   252 

   253 /**

   254  * Implement a CreateL function for internalizing HBufC8s.

   255  */

   256 inline void CreateL(RReadStream& aIn, HBufC8*& aOut)

   257 	{

   258 	aOut = HBufC8::NewL(aIn, KMaxIntegerSize);

   259 	}

   260 

   261 /**

   262  * Implement a CreateLC function for internalizing RIntegers. 

   263  */

   264 EXPORT_C void CreateLC(RReadStream& aIn, RInteger& aOut)

   265 	{	

   266 	HBufC8* rBuf;

   267 	CreateL(aIn, rBuf);

   268 	CleanupStack::PushL(rBuf);

   269 	TPtr8 rPtr(rBuf->Des());	

   270 	aOut = RInteger::NewL(rPtr);

   271 	CleanupStack::PopAndDestroy(rBuf);

   272 	CleanupStack::PushL(aOut);

   273 	}

   274 

   275 /**

   276  * Externalize an RInteger.

   277  */

   278 EXPORT_C void ExternalizeL(const TInteger& aIn, RWriteStream& aOut)

   279 	{

   280 	HBufC8* sBuf = aIn.BufferLC();

   281 	aOut << *sBuf;

   282 	CleanupStack::PopAndDestroy(sBuf);	

   283 	}

   284 

   285 // Externalization for signature objects ///////////////////////////////////////

   286 

   287 /**

   288  * Implement Externalization selector for CDSASignature to use a function.

   289  */

   290 EXTERNALIZE_FUNCTION(CDSASignature)

   291 

   292 /**

   293  * Externalise a DSA signature object.

   294  */

   295 void ExternalizeL(const CDSASignature& aIn, RWriteStream& aOut)

   296 	{

   297 	aOut << aIn.R();

   298 	aOut << aIn.S();

   299 	}

   300 

   301 /**

   302  * Implement Externalization selector for CRSASignature to use a function.

   303  */

   304 EXTERNALIZE_FUNCTION(CRSASignature)

   305 

   306 /**

   307  * Externalize an RSA signature object.

   308  */

   309 void ExternalizeL(const CRSASignature& aIn, RWriteStream& aOut)

   310 	{

   311 	aOut << aIn.S();

   312 	}

   313 

   314 // Internalization for signature objects ///////////////////////////////////////

   315 

   316 /**

   317  * Specialise CreateL for CRSASignature.

   318  */

   319 template <>

   320 void CreateL(RReadStream& aIn, CRSASignature*& aOut)

   321 	{

   322 	RInteger r;

   323 	CreateLC(aIn, r);

   324 	aOut = CRSASignature::NewL(r);

   325 	CleanupStack::Pop(); // r

   326 	}

   327 

   328 /**

   329  * Specialise CreateL for CDSASignature.

   330  */

   331 template <>

   332 void CreateL(RReadStream& aIn, CDSASignature*& aOut)

   333 	{

   334 	RInteger r;

   335 	CreateLC(aIn, r);

   336 	RInteger s;

   337 	CreateLC(aIn, s);

   338 	aOut = CDSASignature::NewL(r, s);

   339 	CleanupStack::Pop(2); // s, r

   340 	}

   341 

   342 // Serialization for DH ojects /////////////////////////////////////////////////

   343 

   344 /**

   345  * Implement Externalization selector for CDHParams to use a function.

   346  */

   347 EXTERNALIZE_FUNCTION(CDHParams)

   348 

   349 /**

   350  * Externalise a TDHParams object.

   351  */

   352 void ExternalizeL(const CDHParams& aIn, RWriteStream& aOut)

   353 	{

   354 	aOut << aIn.N();

   355 	aOut << aIn.G();

   356 	}

   357 

   358 /**

   359  * Specialise CreateL for CDHParams.

   360  */

   361 template <>

   362 void CreateL(RReadStream& aIn, CDHParams*& aOut)

   363 	{

   364 	RInteger n;

   365 	CreateLC(aIn, n);

   366 	RInteger g;

   367 	CreateLC(aIn, g);

   368 	aOut = CDHParams::NewL(n, g);

   369 	CleanupStack::PopAndDestroy(2, &n); // g, n

   370 	}

   371 

   372 /**

   373  * Implement Externalization selector for CDHPublicKey to use a function.

   374  */

   375 EXTERNALIZE_FUNCTION(CDHPublicKey)

   376 

   377 /**

   378  * Externalise a CDHPublicKey object.

   379  */

   380 void ExternalizeL(const CDHPublicKey& aIn, RWriteStream& aOut)

   381 	{

   382 	aOut << aIn.N();

   383 	aOut << aIn.G();

   384 	aOut << aIn.X();

   385 	}

   386 

   387 /**

   388  * Specialise CreateL for CDHPublicKey.

   389  */

   390 template <>

   391 void CreateL(RReadStream& aIn, CDHPublicKey*& aOut)

   392 	{

   393 	RInteger n;

   394 	CreateLC(aIn, n);

   395 	RInteger g;

   396 	CreateLC(aIn, g);

   397 	RInteger X;

   398 	CreateLC(aIn, X);

   399 	aOut = CDHPublicKey::NewL(n, g, X);

   400 	CleanupStack::Pop(3); // X, g, n

   401 	}

   402 

   403 // Common //////////////////////////////////////////////////////////////////////

   404 

   405 EXPORT_C void TokenDataMarshaller::ReadL(const TDesC8& aIn, RArray<TUid>& aOut)

   406 	{

   407 	::ReadL(aIn, aOut);

   408 	}

   409 

   410 EXPORT_C TInt TokenDataMarshaller::Size(const CKeyInfoBase& aIn)

   411 	{

   412 	return ::Size(aIn);

   413 	}

   414 

   415 EXPORT_C void TokenDataMarshaller::Write(const CKeyInfoBase& aIn, TDes8& aOut)

   416 	{

   417 	::Write(aIn, aOut);

   418 	}

   419 

   420 EXPORT_C TInt TokenDataMarshaller::Size(const RArray<TUid>& aIn)

   421 	{

   422 	return ::Size(aIn);

   423 	}

   424 

   425 EXPORT_C void TokenDataMarshaller::Write(const RArray<TUid>& aIn, TDes8& aOut)

   426 	{

   427 	::Write(aIn, aOut);

   428 	}

   429 

   430 EXPORT_C TInt TokenDataMarshaller::Size(const MCertInfo& aIn)

   431 	{

   432 	return ::Size(aIn);

   433 	}

   434 

   435 EXPORT_C void TokenDataMarshaller::Write(const MCertInfo& aIn, TDes8& aOut)

   436 	{

   437 	::Write(aIn, aOut);

   438 	}

   439 

   440 // Client //////////////////////////////////////////////////////////////////////

   441 

   442 EXPORT_C void TokenDataMarshaller::ReadL(const TDesC8& aIn, MCTToken& aToken, MKeyInfoArray& aOut)

   443 	{

   444 	::CreateL(aIn, aToken, aOut);

   445 	}

   446 

   447 EXPORT_C void TokenDataMarshaller::ReadL(const TDesC8& aIn, MCTToken& aToken, CCTKeyInfo*& aOut)

   448 	{

   449 	::CreateL(aIn, aToken, aOut);

   450 	}

   451 

   452 EXPORT_C void TokenDataMarshaller::ReadL(const TDesC8& aIn, CDSASignature*& aOut)

   453 	{

   454 	::CreateL(aIn, aOut);

   455 	}

   456 

   457 EXPORT_C void TokenDataMarshaller::ReadL(const TDesC8& aIn, CRSASignature*& aOut)

   458 	{

   459 	::CreateL(aIn, aOut);

   460 	}

   461 

   462 EXPORT_C TInt TokenDataMarshaller::Size(const CDHParams& aIn)

   463 	{

   464     return Size(aIn.N()) + Size(aIn.G());

   465 	}

   466 

   467 EXPORT_C void TokenDataMarshaller::WriteL(const CDHParams& aIn, TDes8& aOut)

   468 	{

   469 	::WriteL(aIn, aOut);

   470 	}

   471 

   472 EXPORT_C TInt TokenDataMarshaller::Size(const CDHPublicKey& aIn)

   473 	{

   474 	return Size(aIn.N()) + Size(aIn.G()) + Size(aIn.X());

   475 	}

   476 

   477 EXPORT_C void TokenDataMarshaller::WriteL(const CDHPublicKey& aIn, TDes8& aOut)

   478 	{

   479 	::WriteL(aIn, aOut);

   480 	}

   481 

   482 EXPORT_C void TokenDataMarshaller::ReadL(const TDesC8& aIn, RInteger& aInteger)

   483 	{

   484 	::CreateLC(aIn, aInteger);

   485 	CleanupStack::Pop();

   486 	}

   487 	

   488 EXPORT_C TInt TokenDataMarshaller::Size(const CPBEncryptParms& aIn)

   489 	{

   490 	return ::Size(aIn);

   491 	}

   492 	

   493 EXPORT_C void TokenDataMarshaller::Write(const CPBEncryptParms& aIn,  TDes8& aOut)

   494 	{

   495 	::Write(aIn, aOut);	

   496 	}

   497 

   498 EXPORT_C void TokenDataMarshaller::ReadL(const TDesC8& aIn, MCTToken& aToken, RMPointerArray<CCTCertInfo>& aOut)

   499 	{

   500 	::CreateL(aIn, aToken, aOut);

   501 	}

   502 

   503 EXPORT_C void TokenDataMarshaller::ReadL(const TDesC8& aIn, MCTToken& aToken, CCTCertInfo*& aOut)

   504 	{

   505 	::CreateL(aIn, aToken, aOut);

   506 	}

   507 

   508 EXPORT_C void TokenDataMarshaller::ReadL(const TDesC8& aIn, RArray<TCertificateAppInfo>& aOut)

   509 	{

   510 	::ReadL(aIn, aOut);

   511 	}

   512 

   513 EXPORT_C TInt TokenDataMarshaller::Size(const CCertAttributeFilter& aIn)

   514 	{

   515 	return ::Size(aIn);

   516 	}

   517 

   518 EXPORT_C void TokenDataMarshaller::WriteL(const CCertAttributeFilter& aIn, TDes8& aOut)

   519 	{

   520 	::WriteL(aIn, aOut);

   521 	}

   522 

   523 // Server //////////////////////////////////////////////////////////////////////

   524 

   525 EXPORT_C TInt TokenDataMarshaller::Size(const RPointerArray<CKeyInfo>& aIn)

   526 	{

   527 	return ::Size(aIn);

   528 	}

   529 	

   530 EXPORT_C void TokenDataMarshaller::ReadL(const TDesC8& aIn, CPBEncryptParms*& aOut)

   531 	{

   532 	::CreateL(aIn, aOut);	

   533 	}

   534 

   535 EXPORT_C void TokenDataMarshaller::Write(const RPointerArray<CKeyInfo>& aIn, TDes8& aOut)

   536 	{

   537 	::Write(aIn, aOut);

   538 	}

   539 

   540 EXPORT_C void TokenDataMarshaller::ReadL(const TDesC8& aIn, CKeyInfo*& aOut)

   541 	{

   542 	::CreateL(aIn, aOut);

   543 	}

   544 

   545 /**

   546  * Determine the size of an externalized big integer.  This assumes that the

   547  * size of the buffer returned by TInteger::BufferLC() is the same as the size

   548  * of the integer as returned by TInteger::ByteCount().  This is done to avoid

   549  * allocating the buffer just so we can tell how big it is.

   550  */

   551 EXPORT_C TInt TokenDataMarshaller::Size(const TInteger& aIn)

   552 	{

   553 	// This is an overestimate as the length is encoded with a TCardinality

   554 	return sizeof(TInt32) + aIn.ByteCount();

   555 	}

   556 

   557 EXPORT_C TInt TokenDataMarshaller::Size(const CDSASignature& aIn)

   558 	{

   559 	return Size(aIn.R()) + Size(aIn.S());

   560 	}

   561 

   562 EXPORT_C void TokenDataMarshaller::WriteL(const CDSASignature& aIn, TDes8& aOut)

   563 	{

   564 	::WriteL(aIn, aOut);

   565 	}

   566 

   567 EXPORT_C TInt TokenDataMarshaller::Size(const CRSASignature& aIn)

   568 	{

   569 	return Size(aIn.S());

   570 	}

   571 

   572 EXPORT_C void TokenDataMarshaller::WriteL(const CRSASignature& aIn, TDes8& aOut)

   573 	{

   574 	::WriteL(aIn, aOut);

   575 	}

   576 

   577 EXPORT_C void TokenDataMarshaller::ReadL(const TDesC8& aIn, CDHParams*& aOut)

   578 	{

   579 	::CreateL(aIn, aOut);

   580 	}

   581 

   582 EXPORT_C void TokenDataMarshaller::ReadL(const TDesC8& aIn, CDHPublicKey*& aOut)

   583 	{

   584 	::CreateL(aIn, aOut);

   585 	}

   586 

   587 EXPORT_C void TokenDataMarshaller::WriteL(const TInteger& aIn, TDes8& aOut)

   588 	{

   589 	::WriteL(aIn, aOut);

   590 	}

   591 

   592 EXPORT_C void TokenDataMarshaller::ReadL(const TDesC8& aIn, CCertInfo*& aOut)

   593 	{

   594 	::CreateL(aIn, aOut);

   595 	}

   596 

   597 EXPORT_C TInt TokenDataMarshaller::Size(const RPointerArray<CCertInfo>& aIn)

   598 	{

   599 	return ::Size(aIn);

   600 	}

   601 

   602 EXPORT_C void TokenDataMarshaller::Write(const RPointerArray<CCertInfo>& aIn, TDes8& aOut)

   603 	{

   604 	::Write(aIn, aOut);

   605 	}

   606 

   607 EXPORT_C TInt TokenDataMarshaller::Size(const RArray<TCertificateAppInfo>& aIn)

   608 	{

   609 	return ::Size(aIn);

   610 	}

   611    

   612 EXPORT_C void TokenDataMarshaller::Write(const RArray<TCertificateAppInfo>& aIn, TDes8& aOut)

   613 	{

   614 	::Write(aIn, aOut);

   615 	}   

   616 

   617 EXPORT_C void TokenDataMarshaller::ReadL(const TDesC8& aIn, CCertAttributeFilter*& aOut)

   618 	{

   619 	::CreateL(aIn, aOut);

   620 	}