Mercurial Mercurial > oss > FCL > sf > mw > socialmobilefw / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
smf/smfcredentialmgr/smfcredmgrserver/src/smfkeystoremanager.cpp
changeset 18 013a02bf2bb0
parent 14 a469c0e6e7fb
equal deleted inserted replaced
17:106a4bfcb866 18:013a02bf2bb0 
    20 #endif
 
    20 #endif
 
    21 
    21 
    22 #include <smfcredmgrclientdatastruct.h>
 
    22 #include <smfcredmgrclientdatastruct.h>
 
    23 #include <smfcredmgrcommon.h>
 
    23 #include <smfcredmgrcommon.h>
 
    24 #include <hash.h>
 
    24 #include <hash.h>
 
       
    25 
    25 #include "smfkeystoremanager.h"
 
    26 #include "smfkeystoremanager.h"
 
    26 
    27 
       
    28 /**
 
       
    29  * NewL Method
 
       
    30  * @return The constructed CSmfKeyStoreManager instance
 
       
    31  */
 
    27 CSmfKeyStoreManager* CSmfKeyStoreManager::NewL() {
 
    32 CSmfKeyStoreManager* CSmfKeyStoreManager::NewL() {
 
    28 	CSmfKeyStoreManager* self = CSmfKeyStoreManager::NewLC();
 
    33 	CSmfKeyStoreManager* self = CSmfKeyStoreManager::NewLC();
 
    29 	CleanupStack::Pop( self );
 
    34 	CleanupStack::Pop( self );
 
    30 	return self;
 
    35 	return self;
 
    31 }
 
    36 }
 
    32 
    37 
       
    38 /**
 
       
    39  * NewLC Method
 
       
    40  * @return The constructed CSmfKeyStoreManager instance
 
       
    41  */
 
    33 CSmfKeyStoreManager* CSmfKeyStoreManager::NewLC() {
 
    42 CSmfKeyStoreManager* CSmfKeyStoreManager::NewLC() {
 
    34 	CSmfKeyStoreManager* self = new( ELeave )CSmfKeyStoreManager();
 
    43 	CSmfKeyStoreManager* self = new( ELeave )CSmfKeyStoreManager();
 
    35 	CleanupStack::PushL( self );
 
    44 	CleanupStack::PushL( self );
 
    36 	self->ConstructL();
 
    45 	self->ConstructL();
 
    37 	return self;
 
    46 	return self;
 
    38 }
 
    47 }
 
    39 
    48 
       
    49 /**
 
       
    50  * Destructor
 
       
    51  */
 
    40 CSmfKeyStoreManager::~CSmfKeyStoreManager() {
 
    52 CSmfKeyStoreManager::~CSmfKeyStoreManager() {
 
    41 	iFs.Close();
 
    53 	iFs.Close();
 
    42 	
    54 	
    43 	delete iSignParameters;
 
    55 	delete iSignParameters;
 
    44 	iSignParameters = NULL;
 
    56 	iSignParameters = NULL;
 
    46 	delete iRsaKeyParameters;
 
    58 	delete iRsaKeyParameters;
 
    47 	iRsaKeyParameters = NULL;
 
    59 	iRsaKeyParameters = NULL;
 
    48 	
    60 	
    49 }
 
    61 }
 
    50 
    62 
       
    63 /**
 
       
    64  * HandleMessageL
 
       
    65  * @param aMessage
 
       
    66  */
 
    51 void CSmfKeyStoreManager::HandleMessageL( const RMessage2& aMessage ) 
    67 void CSmfKeyStoreManager::HandleMessageL( const RMessage2& aMessage ) 
    52 	{
 
    68 	{
 
    53 	RDebug::Printf("SMF: CSmfKeyStoreManager::HandleMessageL");
 
    69 	RDebug::Printf("SMF: CSmfKeyStoreManager::HandleMessageL");
 
    54 	iMessages.AppendL( &aMessage );
 
    70 	iMessages.AppendL( &aMessage );
 
    55 	if ( !IsActive() ) 
    71 	if ( !IsActive() ) 
    56 		{
 
    72 		{
 
    57 		ContinueMessageHandlingL();
 
    73 		ContinueMessageHandlingL();
 
    58 		}
 
    74 		}
 
    59 	}
 
    75 	}
 
    60 
    76 
       
    77 /**
 
       
    78  * RunL
 
       
    79  */
 
    61 void CSmfKeyStoreManager::RunL() 
    80 void CSmfKeyStoreManager::RunL() 
    62 	{
 
    81 	{
 
    63 	RDebug::Printf("SMF: CSmfKeyStoreManager::RunL, iStatus=%d", iStatus.Int() );
 
    82 	RDebug::Printf("SMF: CSmfKeyStoreManager::RunL, iStatus=%d", iStatus.Int() );
 
    64 	
    83 	
    65 	switch( iState )
 
    84 	switch( iState )
 
   139 			iMessages.Remove( 0 );
 
   158 			iMessages.Remove( 0 );
 
   140 			break;
 
   159 			break;
 
   141 			}
 
   160 			}
 
   142 		case EDeletingKey:
 
   161 		case EDeletingKey:
 
   143 			{
 
   162 			{
 
   144 			DeleteKeys();
 
   163 			DeleteKeysL();
 
   145 			break;
 
   164 			break;
 
   146 			}
 
   165 			}
 
   147 #endif
 
   166 #endif
 
   148 		default:
 
   167 		default:
 
   149 			{
 
   168 			{
 
   155 		{
 
   174 		{
 
   156 		ContinueMessageHandlingL();
 
   175 		ContinueMessageHandlingL();
 
   157 		}	
   176 		}	
   158 	}
 
   177 	}
 
   159 
   178 
       
   179 /**
 
       
   180  * DoCancel
 
       
   181  */
 
   160 void CSmfKeyStoreManager::DoCancel() {	
   182 void CSmfKeyStoreManager::DoCancel() {	
   161 }
 
   183 }
 
   162 
   184 
       
   185 /**
 
       
   186  * RunError
 
       
   187  * @param aError
 
       
   188  * @return
 
       
   189  */
 
   163 TInt CSmfKeyStoreManager::RunError( TInt aError ) {
 
   190 TInt CSmfKeyStoreManager::RunError( TInt aError ) {
 
   164 	RDebug::Printf("SMF: CSmfKeyStoreManager::RunError error=%d", aError);
 
   191 	RDebug::Printf("SMF: CSmfKeyStoreManager::RunError error=%d", aError);
 
   165 	
   192 	
   166 	if ( iMessages.Count() ) 
   193 	if ( iMessages.Count() ) 
   167 		{
 
   194 		{
 
   170 		}
 
   197 		}
 
   171 
   198 
   172 	return KErrNone;
 
   199 	return KErrNone;
 
   173 }
 
   200 }
 
   174 
   201 
       
   202 /**
 
       
   203  * Constructor
 
       
   204  */
 
   175 CSmfKeyStoreManager::CSmfKeyStoreManager() 
   205 CSmfKeyStoreManager::CSmfKeyStoreManager() 
   176 	:CActive(EPriorityStandard), iState(EInitializingKeystore) 
   206 	:CActive(EPriorityStandard), iState(EInitializingKeystore) 
   177 	{
 
   207 	{
 
   178 	}
 
   208 	}
 
   179 
   209 
       
   210 /**
 
       
   211  * Two-phase constructor
 
       
   212  */
 
   180 void CSmfKeyStoreManager::ConstructL() {
 
   213 void CSmfKeyStoreManager::ConstructL() {
 
   181 	RDebug::Printf("SMF: CSmfKeyStoreManager::ConstructL");
 
   214 	RDebug::Printf("SMF: CSmfKeyStoreManager::ConstructL");
 
   182 	CActiveScheduler::Add( this );
 
   215 	CActiveScheduler::Add( this );
 
   183 #ifdef	SYMBIAN_V3
 
   216 #ifdef	SYMBIAN_V3
 
   184 	User::LeaveIfError( iFs.Connect() );
 
   217 	User::LeaveIfError( iFs.Connect() );
 
   188 	iState = EInitializingKeystore;
 
   221 	iState = EInitializingKeystore;
 
   189 	SetActive();	
   222 	SetActive();	
   190 #endif
 
   223 #endif
 
   191 }
 
   224 }
 
   192 
   225 
       
   226 /**
 
       
   227  * ContinueMessageHandlingL
 
       
   228  */
 
   193 void CSmfKeyStoreManager::ContinueMessageHandlingL() 
   229 void CSmfKeyStoreManager::ContinueMessageHandlingL() 
   194 	{
 
   230 	{
 
   195 	RDebug::Printf("SMF: CSmfKeyStoreManager::ContinueMessageHandling");
 
   231 	RDebug::Printf("SMF: CSmfKeyStoreManager::ContinueMessageHandling");
 
   196 	
   232 	
   197 	if ( IsActive() )
 
   233 	if ( IsActive() )
 
   219 			HMAC_SHA1_SignMessageL();
 
   255 			HMAC_SHA1_SignMessageL();
 
   220 			break;
 
   256 			break;
 
   221 			}
 
   257 			}
 
   222 		case ESmfDeleteKeys:
 
   258 		case ESmfDeleteKeys:
 
   223 			{
 
   259 			{
 
   224 			DeleteKeys();
 
   260 			DeleteKeysL();
 
   225 			break;
 
   261 			break;
 
   226 			}
 
   262 			}
 
   227 		}
 
   263 		}
 
   228 	}
 
   264 	}
 
   229 
   265 
       
   266 /**
 
       
   267  * StoreRSAKeyL
 
       
   268  */
 
   230 void CSmfKeyStoreManager::StoreRSAKeyL() 
   269 void CSmfKeyStoreManager::StoreRSAKeyL() 
   231 	{
 
   270 	{
 
   232 #ifdef SYMBIAN_V3
 
   271 #ifdef SYMBIAN_V3
 
   233 	RDebug::Printf("SMF: CSmfKeyStoreManager::StoreRSAKeyL");
 
   272 	RDebug::Printf("SMF: CSmfKeyStoreManager::StoreRSAKeyL");
 
   234 	
   273 	
   243 	SetActive();
 
   282 	SetActive();
 
   244 	iState = EImportingKey;
 
   283 	iState = EImportingKey;
 
   245 #endif
 
   284 #endif
 
   246 	}
 
   285 	}
 
   247 
   286 
       
   287 /**
 
       
   288  * RSA_SHA1_SignMessageL
 
       
   289  */
 
   248 void CSmfKeyStoreManager::RSA_SHA1_SignMessageL() 
   290 void CSmfKeyStoreManager::RSA_SHA1_SignMessageL() 
   249 	{
 
   291 	{
 
   250 	
   292 	
   251 	RDebug::Printf("SMF: CSmfKeyStoreManager::RSA_SHA1_SignMessage");
 
   293 	RDebug::Printf("SMF: CSmfKeyStoreManager::RSA_SHA1_SignMessage");
 
   252 #ifdef SYMBIAN_V3
 
   294 #ifdef SYMBIAN_V3
 
   273 				{
 
   315 				{
 
   274 			
   316 			
   275 				if ( iKeys[i]->ID() == iSignParameters->Key() ) 
   317 				if ( iKeys[i]->ID() == iSignParameters->Key() ) 
   276 					{
 
   318 					{
 
   277 					RDebug::Printf("SMF: Correct key found");
 
   319 					RDebug::Printf("SMF: Correct key found");
 
       
   320 					//might panic in CodeScanner, this open returns void
 
   278 					iKeyStore->Open( *iKeys[i], iRSASigner, iStatus );
 
   321 					iKeyStore->Open( *iKeys[i], iRSASigner, iStatus );
 
   279 					iState = EGettingRSASigner;
 
   322 					iState = EGettingRSASigner;
 
   280 					keyFound = ETrue;
 
   323 					keyFound = ETrue;
 
   281 					SetActive();
 
   324 					SetActive();
 
   282 					break;						
   325 					break;						
   303 			}
 
   346 			}
 
   304 		}	
   347 		}	
   305 #endif
 
   348 #endif
 
   306 	}
 
   349 	}
 
   307 
   350 
       
   351 /**
 
       
   352  * HMAC_SHA1_SignMessageL
 
       
   353  */
 
   308 void CSmfKeyStoreManager::HMAC_SHA1_SignMessageL()
 
   354 void CSmfKeyStoreManager::HMAC_SHA1_SignMessageL()
 
   309 	{	
   355 	{	
   310 	ReadSignParametersL();
 
   356 	ReadSignParametersL();
 
   311 	
   357 	
   312 	RDebug::Printf("SMF: CSmfKeyStoreManager::HMAC_SHA1_SignMessage");
 
   358 	RDebug::Printf("SMF: CSmfKeyStoreManager::HMAC_SHA1_SignMessage");
 
   329 	
   375 	
   330 	delete iSignParameters;
 
   376 	delete iSignParameters;
 
   331 	iSignParameters = NULL;	
   377 	iSignParameters = NULL;	
   332 	}
 
   378 	}
 
   333 
   379 
   334 void CSmfKeyStoreManager::DeleteKeys() 
   380 /**
 
       
   381  * DeleteKeysL
 
       
   382  */
 
       
   383 void CSmfKeyStoreManager::DeleteKeysL() 
   335 	{
 
   384 	{
 
   336 	RDebug::Printf("SMF: CSmfKeyStoreManager::DeleteKeys");
 
   385 	RDebug::Printf("SMF: CSmfKeyStoreManager::DeleteKeys");
 
   337 #ifdef SYMBIAN_V3
 
   386 #ifdef SYMBIAN_V3
 
   338 	switch ( iState ) 
   387 	switch ( iState ) 
   339 		{
 
   388 		{
 
   379 			}
 
   428 			}
 
   380 		}
 
   429 		}
 
   381 #endif
 
   430 #endif
 
   382 	}
 
   431 	}
 
   383 
   432 
       
   433 /**
 
       
   434  * SetPassphraseTimeout
 
       
   435  */
 
   384 void CSmfKeyStoreManager::SetPassphraseTimeout() 
   436 void CSmfKeyStoreManager::SetPassphraseTimeout() 
   385 	{
 
   437 	{
 
   386 #ifdef SYMBIAN_V3
 
   438 #ifdef SYMBIAN_V3
 
   387 	iKeyStore->SetPassphraseTimeout( -1, iStatus );
 
   439 	iKeyStore->SetPassphraseTimeout( -1, iStatus );
 
   388 	iState = ESettingPassphraseTimeout;
 
   440 	iState = ESettingPassphraseTimeout;
 
   389 	SetActive();
 
   441 	SetActive();
 
   390 #endif
 
   442 #endif
 
   391 	}
 
   443 	}
 
   392 
   444 
       
   445 /**
 
       
   446  * ReadSignParametersL
 
       
   447  */
 
   393 void CSmfKeyStoreManager::ReadSignParametersL()
 
   448 void CSmfKeyStoreManager::ReadSignParametersL()
 
   394 	{
 
   449 	{
 
   395 	RMessage2* message = iMessages[0];
 
   450 	RMessage2* message = iMessages[0];
 
   396 	RBuf8 dataBuf;
 
   451 	RBuf8 dataBuf;
 
   397 	CleanupClosePushL( dataBuf );
 
   452 	CleanupClosePushL( dataBuf );
 
   404 	iSignParameters = CSmfSignParameters::NewL( dataBuf );
 
   459 	iSignParameters = CSmfSignParameters::NewL( dataBuf );
 
   405 	
   460 	
   406 	CleanupStack::PopAndDestroy( &dataBuf );
 
   461 	CleanupStack::PopAndDestroy( &dataBuf );
 
   407 	}
 
   462 	}
 
   408 
   463 
       
   464 /**
 
       
   465  * ReadRsaKeyParametersL
 
       
   466  */
 
   409 void CSmfKeyStoreManager::ReadRsaKeyParametersL()
 
   467 void CSmfKeyStoreManager::ReadRsaKeyParametersL()
 
   410 	{
 
   468 	{
 
   411 	RMessage2* message = iMessages[0];
 
   469 	RMessage2* message = iMessages[0];
 
   412 
   470 
   413 	RBuf8 dataBuf;
 
   471 	RBuf8 dataBuf;
 
   420 	
   478 	
   421 	iRsaKeyParameters = CSmfRsaKeyParameters::NewL( dataBuf );
 
   479 	iRsaKeyParameters = CSmfRsaKeyParameters::NewL( dataBuf );
 
   422 	
   480 	
   423 	CleanupStack::PopAndDestroy( &dataBuf );
 
   481 	CleanupStack::PopAndDestroy( &dataBuf );
 
   424 	}
 
   482 	}
 
   425 
       
   426 
       
   427
FCL/sf/mw/socialmobilefw