1 // Copyright (c) 2002-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 // Implements the Phone Smart Card application and file manipulation code.

    15 // 

    16 //

    17 

    18 /**

    19  @file

    20 */

    21 

    22 #include <testconfigfileparser.h>

    23 #include <etelmmerr.h>

    24 #include "CSimPhone.h"

    25 #include "Simlog.h"

    26 

    27 //

    28 // CSimPhoneSmartCardApp

    29 //

    30 

    31 CSimPhoneSmartCardApp* CSimPhoneSmartCardApp::NewL(CSimPhone* aPhone)

    32 /**

    33  * Standard two phase constructor.

    34  * @param aPhone The phone object from which the Phone Smart Card applications will open

    35  */

    36 	{

    37 	CSimPhoneSmartCardApp* obj=new(ELeave) CSimPhoneSmartCardApp(aPhone);

    38 	CleanupStack::PushL(obj);

    39 	obj->ConstructL();

    40 	CleanupStack::Pop();

    41 	return obj;

    42 	}

    43 

    44 CSimPhoneSmartCardApp::CSimPhoneSmartCardApp(CSimPhone* aPhone)

    45 : iPhone(aPhone), iCurrentSelection(RMobilePhone::EUSimSelectionAutomatic), 

    46 	iFoundScAppTags(EFalse)

    47 /**

    48  * Trivial first phase constructor.

    49  * @param aPhone	The phone object from which this Phone SmartCard App was opened.

    50  */

    51 	{}

    52 

    53 void CSimPhoneSmartCardApp::Init()

    54 	{}

    55 

    56 void CSimPhoneSmartCardApp::ConstructL()

    57 /**

    58 * Second phase of the 2-phase constructor.

    59 * Constructs all the member data and retrieves all the data from the config file specific to this class.

    60 *

    61 * @leave Leaves due to not enough memory or if any data member does not construct for any reason.

    62 */

    63 	{

    64 	LOGPHONE1("Starting to parse Phone Smart Card applications additional config parameters...");

    65 	ParseSmartCardApplicationInfoL();

    66 	ParseSmartCardFileInfoL();

    67 	MapUSimAppsL();

    68 	LOGPHONE1("Finished parsing Phone Smart Card applications additional config parameters...");

    69 	}

    70 

    71 

    72 CSimPhoneSmartCardApp::~CSimPhoneSmartCardApp()

    73 /**

    74  * Standard destructor.  Any objects created by the ::ConstructL() function

    75  * will be destroyed here.

    76  */

    77 	{

    78 	delete iTimer;

    79 	if(iSmartCardAppEventList)

    80 		{

    81 		iSmartCardAppEventList->Delete(0, iSmartCardAppEventList->Count());

    82 		delete iSmartCardAppEventList;

    83 		}

    84 	if(iSmartCardAppList)

    85 		{

    86 		iSmartCardAppList->Delete(0, iSmartCardAppList->Count());

    87 		delete iSmartCardAppList;

    88 		}

    89 	if (iSmartCardFileList)

    90 		{

    91 		iSmartCardFileList->ResetAndDestroy();

    92 		delete iSmartCardFileList;

    93 		}

    94 	if(iUSimAppList)

    95 		{

    96 		iUSimAppList->Close();

    97 		delete iUSimAppList;

    98 		}

    99 	}

   100 

   101 

   102 TInt CSimPhoneSmartCardApp::ExtFunc(const TTsyReqHandle aTsyReqHandle,const TInt aIpc, const TDataPackage& aPckg)

   103 /**

   104 * ExtFunc is called by the server when it has an "extended", i.e. non-core ETel request

   105 * for the TSY to process.

   106 * A request handle, request type and request data are passed to the TSY

   107 * 

   108 * @param aTsyReqHandle  The request handle for completing the request 

   109 * @param aIpc Ipc representing the request

   110 * @param aPackage any data associated with the request

   111 * @return err KErrNone if request completes ok

   112 */

   113 	{

   114 

   115 	TAny* dataPtr = aPckg.Ptr1();

   116 	TAny* dataPtr2 = aPckg.Ptr2();

   117 

   118 	// The following requests can be completed even if the completion of another request is pending.

   119 	switch(aIpc)

   120 		{

   121 	case EMobilePhoneGetCurrentActiveUSimApplication:

   122 		return GetCurrentActiveUSimApplication(aTsyReqHandle,

   123 			reinterpret_cast<RMobilePhone::TAID*>(dataPtr));

   124 			

   125 	case EMobilePhoneEnumerateUSimApplications:

   126 		return EnumerateUSimApplications(aTsyReqHandle, 

   127 			reinterpret_cast<TInt*> (dataPtr),

   128 			reinterpret_cast<RMobilePhone::TAID*> (dataPtr2));

   129 

   130 	case EMobilePhoneSetUSimApplicationStatus:

   131 		return SetUSimApplicationStatus(aTsyReqHandle,

   132 			reinterpret_cast<RMobilePhone::TAID*> (dataPtr),

   133 			reinterpret_cast<RMobilePhone::TUSimAppAction*> (dataPtr2));

   134 

   135 	case EMobilePhoneGetUSimApplicationsInfo:

   136 		return GetUSimApplicationInfo(aTsyReqHandle, 

   137 			reinterpret_cast<TInt*> (dataPtr),

   138 			aPckg.Des2n());

   139 

   140 	case EMobilePhoneNotifyUSimApplicationsInfoChange:

   141 		return NotifyUSimApplicationsInfoChange(aTsyReqHandle, 

   142 			reinterpret_cast<TInt*> (dataPtr),

   143 			reinterpret_cast<RMobilePhone::TAID*> (dataPtr2));

   144 		

   145 	case EMobilePhoneEnumerateSmartCardApplications:

   146 		return EnumerateScApplications(aTsyReqHandle, 

   147 			reinterpret_cast<TUint*>(dataPtr));

   148 

   149 	case EMobilePhoneGetSmartCardApplicationInfo:

   150 		return GetScApplicationInfo(aTsyReqHandle, 

   151 			reinterpret_cast<TInt*>(dataPtr), 

   152 			aPckg.Des2n());

   153 

   154 	case EMobilePhoneSetSmartCardApplicationStatus:

   155 		return SetScApplicationStatus(aTsyReqHandle,

   156 			reinterpret_cast<RMobilePhone::TAID*>(dataPtr),

   157 			reinterpret_cast<RMobilePhone::TSmartCardApplicationAction*>(dataPtr2));

   158 

   159 	case EMobilePhoneNotifySmartCardApplicationInfoChange:

   160 		return NotifyScApplicationInfoChange(aTsyReqHandle, 

   161 			reinterpret_cast<RMobilePhone::TAID*>(dataPtr), 

   162 			reinterpret_cast<RMobilePhone::TSmartCardApplicationEvent*>(dataPtr2));

   163 

   164 	case EMobilePhoneGetUSimAppsSelectionMode:

   165 		return GetUSimAppsSelectionMode(aTsyReqHandle,

   166 			reinterpret_cast<RMobilePhone::TUSimSelectionMode*>(dataPtr));

   167 

   168 	case EMobilePhoneSetUSimAppsSelectionMode:

   169 		return SetUSimAppsSelectionMode(aTsyReqHandle,

   170 			reinterpret_cast<RMobilePhone::TUSimSelectionMode*>(dataPtr));

   171 

   172 	case EMobilePhoneNotifyUSimAppsSelectionModeChange:

   173 		return NotifyUSIMAppsSelectionModeChange(aTsyReqHandle, 

   174 			reinterpret_cast<RMobilePhone::TUSimSelectionMode*>(dataPtr));

   175 			

   176 	case EMobilePhoneGetScFileInfo:

   177 		return GetScFileInfo(aTsyReqHandle,

   178 			*reinterpret_cast<RMobilePhone::TScFilePath*>(dataPtr),

   179 			aPckg.Des2n());

   180 		

   181 	case EMobilePhoneReadScFile:

   182 		return ReadScFile(aTsyReqHandle,

   183 			*reinterpret_cast<RMobilePhone::TScFilePathWithAccessOffsets*>(dataPtr),

   184 			aPckg.Des2n());

   185 		

   186 	case EMobilePhoneUpdateScFile:

   187 		return UpdateScFile(aTsyReqHandle,

   188 			*reinterpret_cast<RMobilePhone::TScFilePathWithAccessOffsets*>(dataPtr),

   189 			aPckg.Des2n());

   190 

   191 	default:

   192 		break;

   193 		}

   194 	return KErrNotSupported;

   195 	}

   196 	

   197 

   198 CTelObject::TReqMode CSimPhoneSmartCardApp::ReqModeL(const TInt aIpc)

   199 /**

   200  * This function returns the Request Mode for the request with the passed IPC value.

   201  * The function leaves if the IPC is not found.

   202  *

   203  * @param aIpc		The IPC number of the request.

   204  * @return TReqMode	The request mode.

   205  */

   206 	{

   207 	CTelObject::TReqMode ret=0;	

   208 

   209 	switch(aIpc)

   210 		{

   211 	case EMobilePhoneGetCurrentActiveUSimApplication:

   212 	case EMobilePhoneEnumerateUSimApplications:

   213 	case EMobilePhoneSetUSimApplicationStatus:

   214 	case EMobilePhoneGetUSimApplicationsInfo:

   215 	case EMobilePhoneEnumerateSmartCardApplications:

   216 	case EMobilePhoneSetSmartCardApplicationStatus:

   217 	case EMobilePhoneGetSmartCardApplicationInfo:

   218 	case EMobilePhoneGetUSimAppsSelectionMode:

   219 	case EMobilePhoneSetUSimAppsSelectionMode:

   220 	case EMobilePhoneGetScFileInfo:

   221 	case EMobilePhoneReadScFile:

   222 	case EMobilePhoneUpdateScFile:

   223 		break;

   224 

   225 	case EMobilePhoneNotifyUSimAppsSelectionModeChange:

   226 	case EMobilePhoneNotifyUSimApplicationsInfoChange:

   227 	case EMobilePhoneNotifySmartCardApplicationInfoChange:

   228 		ret=KReqModeMultipleCompletionEnabled | KReqModeRePostImmediately;

   229 		break;

   230 

   231 	default:

   232 		User::Leave(KErrNotSupported);

   233 		break;

   234 		}

   235 

   236 	return ret;

   237 	}

   238 	

   239 TInt CSimPhoneSmartCardApp::RegisterNotification(const TInt /*aIpc*/)

   240 /**

   241  * The ETel Server calls this function when the first client makes a notification

   242  * request.  If supported by the underlying protocol controlling the

   243  * signalling stack, this can be used to start requesting updates for the relevant

   244  * service.

   245  */

   246 	{

   247 	return KErrNone;

   248 	}

   249 

   250 TInt CSimPhoneSmartCardApp::DeregisterNotification(const TInt /*aIpc*/)

   251 /**

   252  * The ETel Server calls this function when the last client that had previously

   253  * made a notification request closes its ETel Server handle.  If supported by

   254  * the underlying protocol controlling the	signalling stack, this can be used

   255  * to stop requesting updates for the relevant service.

   256  */

   257 	{

   258 	return KErrNone;

   259 	}

   260 

   261 CTelObject* CSimPhoneSmartCardApp::OpenNewObjectByNameL(const TDesC& /*aName*/)

   262 /**

   263  * The API does not support any objects that could be opened from this one.

   264  */

   265 	{

   266 	User::Leave(KErrNotSupported);

   267 	return NULL;

   268 	}

   269 

   270 CTelObject* CSimPhoneSmartCardApp::OpenNewObjectL(TDes&)

   271 /**

   272  * The API does not support any objects that could be opened from this one.

   273  */

   274 	{

   275 	User::Leave(KErrNotSupported);

   276 	return NULL;

   277 	}

   278 

   279 

   280 TInt CSimPhoneSmartCardApp::NumberOfSlotsL(const TInt aIpc)

   281 /**

   282  * Return the number of slots that the ETel Server should allocate for buffering requests

   283  * of the given IPC number.

   284  *

   285  * @param aIpc	The IPC number of the request.

   286  */

   287 	{

   288 	TInt numberOfSlots = 0;

   289 	

   290 	switch(aIpc)

   291 		{

   292 	case EMobilePhoneNotifyUSimAppsSelectionModeChange:

   293 	case EMobilePhoneNotifyUSimApplicationsInfoChange:

   294 	case EMobilePhoneNotifySmartCardApplicationInfoChange:

   295 		numberOfSlots = KDefaultNumberOfSlots;

   296 		break;

   297 	default:

   298 		LOGPHONE1("CSimPhoneSmartCardApp: Number of Slots error, unknown IPC");

   299 		User::Leave(KErrNotSupported);

   300 		break;

   301 		}

   302 	return numberOfSlots;

   303 	}

   304 

   305 

   306 TInt CSimPhoneSmartCardApp::CancelService(const TInt aIpc,const TTsyReqHandle aTsyReqHandle)

   307 /**

   308  * Cancel an outstanding request.

   309  * @param aIpc			The IPC number of the request that is to be cancelled.

   310  * @param aTsyReqHandle	The TSY request handle of the request that is to be cancelled.

   311  * @return	Standard return value.

   312  */

   313 	{

   314 

   315 	switch(aIpc)

   316 		{

   317 	case EMobilePhoneEnumerateSmartCardApplications:

   318 		return EnumerateScApplicationsCancel(aTsyReqHandle);

   319 

   320 	case EMobilePhoneEnumerateUSimApplications:

   321 		return EnumerateUSimApplicationsCancel(aTsyReqHandle);

   322 

   323 	case EMobilePhoneSetUSimApplicationStatus:

   324 		return SetUSimApplicationStatusCancel(aTsyReqHandle);

   325 	

   326 	case EMobilePhoneGetUSimApplicationsInfo:

   327 		return GetUSimApplicationInfoCancel(aTsyReqHandle);

   328 

   329 	case EMobilePhoneNotifyUSimApplicationsInfoChange:

   330 		return NotifyUSimApplicationsInfoChangeCancel(aTsyReqHandle);

   331 

   332 	case EMobilePhoneSetSmartCardApplicationStatus:

   333 		return SetScApplicationStatusCancel(aTsyReqHandle);

   334 	

   335 	case EMobilePhoneGetSmartCardApplicationInfo:

   336 		return GetScApplicationInfoCancel(aTsyReqHandle);

   337 

   338 	case EMobilePhoneGetCurrentActiveUSimApplication:

   339 		return GetCurrentActiveUSimApplicationCancel(aTsyReqHandle);

   340 

   341 	case EMobilePhoneNotifySmartCardApplicationInfoChange:

   342 		return NotifyScApplicationInfoChangeCancel(aTsyReqHandle);

   343 		

   344 	case EMobilePhoneSetUSimAppsSelectionMode:

   345 		return SetUSimAppsSelectionModeCancel(aTsyReqHandle);

   346 	

   347 	case EMobilePhoneGetUSimAppsSelectionMode:

   348 		return GetUSimAppsSelectionModeCancel(aTsyReqHandle);

   349 	

   350 	case EMobilePhoneNotifyUSimAppsSelectionModeChange:

   351 		return NotifyUSIMAppsSelectionModeChangeCancel(aTsyReqHandle);

   352 	

   353 	case EMobilePhoneGetScFileInfo:

   354 		return GetScFileInfoCancel(aTsyReqHandle);

   355 

   356 	case EMobilePhoneReadScFile:

   357 		return ReadScFileCancel(aTsyReqHandle);

   358 

   359 	case EMobilePhoneUpdateScFile:

   360 		return UpdateScFileCancel(aTsyReqHandle);

   361 

   362 	default:

   363 		break;

   364 		}

   365 	return KErrNone;

   366 	}

   367 

   368 

   369 const CTestConfigSection* CSimPhoneSmartCardApp::CfgFile()

   370 /**

   371 * Returns a pointer to the config file section

   372 *

   373 * @return CTestConfigSection a pointer to the configuration file data section

   374 */

   375 	{

   376 	LOGPHONE1(">>CSimPhoneSmartCardApp::CfgFile");

   377 	return iPhone->CfgFile();

   378 	}

   379 

   380 void CSimPhoneSmartCardApp::TimerCallBack(TInt /*aId*/)

   381 /**

   382 * Timer callback function.  When the timer goes off, it will call back into this

   383 * function for further processing.

   384 *

   385 * @param aId an id identifying which timer callback is being called

   386 */	

   387 	{

   388 	if(iNotifyScInfo.iNotifyPending || iNotifyUSimInfo.iNotifyPending)

   389 		{

   390 		TSmartCardAppEvent theEvent=iSmartCardAppEventList->At(iEventPointer);

   391 		TInt ret;

   392 		RMobilePhone::TSmartCardApplicationEvent occuredEvent;

   393 		TBool isUSimAppAffected = EFalse;

   394 				

   395 		if(theEvent.iAction == RMobilePhone::EScApplicationActivate)

   396 			{

   397 			ret=ActivateSmartCardApp(theEvent.iAID, isUSimAppAffected);

   398 			occuredEvent = RMobilePhone::EScApplicationActivated;

   399 			}

   400 		else

   401 			{

   402 			ret=TerminateSmartCardApp(theEvent.iAID, isUSimAppAffected);

   403 			occuredEvent = RMobilePhone::EScApplicationTerminated;

   404 			}

   405 			

   406 		if (ret == KErrNone)

   407 			{

   408 			iEventPointer++;

   409 

   410 			//notify any ScApp client if such notify request is pending

   411 			if(iNotifyScInfo.iNotifyPending)

   412 				{

   413 				iNotifyScInfo.iNotifyPending=EFalse;

   414 				*(RMobilePhone::TAID*)iNotifyScInfo.iNotifyData1=theEvent.iAID;

   415 				*(RMobilePhone::TSmartCardApplicationEvent*)iNotifyScInfo.iNotifyData2=occuredEvent;

   416 				iPhone->ReqCompleted(iNotifyScInfo.iNotifyHandle,KErrNone);

   417 				}

   418 				

   419 			//notify any USimApp client if such notify request is pending

   420 			if(isUSimAppAffected  && iNotifyUSimInfo.iNotifyPending)

   421 				{

   422 				iNotifyUSimInfo.iNotifyPending=EFalse;

   423 

   424 				if(occuredEvent == RMobilePhone::EScApplicationActivated)

   425 					{

   426 					*(RMobilePhone::TAID*)iNotifyUSimInfo.iNotifyData1=theEvent.iAID;

   427 					}

   428 				else

   429 					{

   430 					*(RMobilePhone::TAID*)iNotifyUSimInfo.iNotifyData1=_L8("");

   431 					}

   432 

   433 				*(TInt*)iNotifyUSimInfo.iNotifyData2=iUSimAppList->Count();

   434 				iPhone->ReqCompleted(iNotifyUSimInfo.iNotifyHandle,KErrNone);

   435 				}

   436 			}

   437 		}//end if(iNotifyScInfo.iNotifyPending...

   438 	}

   439 	

   440 TBool CSimPhoneSmartCardApp::FoundScAppTags()

   441 /**

   442 * Returns a value to indicate whether SCApp tags were found in the Config file

   443 *

   444 */

   445 	{

   446 	return iFoundScAppTags;

   447 	}

   448 	

   449 	

   450 void CSimPhoneSmartCardApp::TSmartCardFile::GetFileInfo(RMobilePhone::TScFileInfoV5& aScFileInfo)

   451 /**

   452 * Gets the SmartCard file's File info

   453 * 

   454 * @param aScFileInfo The function passes back the file info through this reference

   455 */

   456 	{

   457 	aScFileInfo.iFileID = iFileID;

   458 	aScFileInfo.iType = iType;

   459 	aScFileInfo.iTotalLength = iTotalLength;

   460 	aScFileInfo.iRecordLength = iRecordLength;

   461 	aScFileInfo.iNumberRecords = iNumberRecords;		

   462 	}

   463 

   464 CSimPhoneSmartCardApp::TCyclicSmartCardFile::TCyclicSmartCardFile()

   465 	:iOldestRecord(0)

   466 	{}

   467 		

   468 TInt CSimPhoneSmartCardApp::TCyclicSmartCardFile::ReadFile(

   469 		const RMobilePhone::TScFilePathWithAccessOffsets& aFilePathOffsets, TDes8* aReadBuffer)

   470 /**

   471 * Concrete implementation of the ReadFile() method for reading file data from a record based

   472 * cyclic smart card file. Reads precisely one record (iRecordLength bytes).

   473 *

   474 * Note: Records are numbered from 1 to n NOT 0 to n-1

   475 *

   476 * @param aFilePathOffsets Information about which file to read (path) and where in the file to read data from (offsets)

   477 * @param aReadBuffer The requested data is read into this buffer

   478 */

   479 	{

   480 	//check that the client has provided a buffer of sufficient size

   481 	if(aReadBuffer->MaxSize() < iRecordLength)

   482 		{

   483 		return KErrOverflow;

   484 		}

   485 		

   486 	//check that the client has specified a valid start offset

   487 	else if(aFilePathOffsets.iStartOffset < 1 || aFilePathOffsets.iStartOffset > iNumberRecords)

   488 		{

   489 		LOGPHONE1("ERROR: File start offset information invalid.");

   490 		return KErrMMEtelScRecordNotFound;	

   491 		}

   492 		

   493 	else

   494 		{

   495 		//Var filepointer initially holds a pointer to the beginning of the specified record

   496 		//The record to read is specified as an offset from the oldest record. I.e. Record 1 is the

   497 		//newest record.

   498 		TInt filePointer = iOldestRecord + (aFilePathOffsets.iStartOffset * iRecordLength);

   499 		if(filePointer >= iTotalLength)

   500 			{

   501 			filePointer = filePointer - iTotalLength;	

   502 			}

   503 			

   504 		aReadBuffer->SetLength(iRecordLength);

   505 		aReadBuffer->FillZ();

   506 		

   507 		TInt index;

   508 		

   509 		for(index = 0; index < iRecordLength; index++)

   510 			{

   511 			(*aReadBuffer)[index] = iFileData[filePointer];

   512 			filePointer++;

   513 			}

   514 		return KErrNone;		

   515 		}

   516 	}

   517 

   518 TInt CSimPhoneSmartCardApp::TCyclicSmartCardFile::UpdateFile(

   519 		const RMobilePhone::TScFilePathWithAccessOffsets& /*aFilePathOffsets*/, TDes8* aWriteBuffer)

   520 /**

   521 * Concrete implementation of the UpdateFile() method for updating file data in a record based

   522 * cyclic smart card file. Updates precisely one record (iRecordLength bytes). The record that is

   523 * updated is the oldest record.

   524 *

   525 * Note: Records are numbered from 1 to n NOT 0 to n-1

   526 *

   527 * @param aReadBuffer The data with which the file should be updated.

   528 */

   529 	{

   530 	//Check that the client has provided a buffer of sufficient size

   531 	if(aWriteBuffer->Size() != iRecordLength)

   532 		{

   533 		return KErrMMEtelScWrongLength;

   534 		}

   535 	else

   536 		{

   537 		TInt filePointer = iOldestRecord ;

   538 			

   539 		TInt index;

   540 

   541 		for(index = 0; index < iRecordLength; index++)

   542 			{

   543 			iFileData[filePointer] = (*aWriteBuffer)[index];

   544 			filePointer++;

   545 			}

   546 		UpdateOldestRecordPointer();

   547 		return KErrNone;

   548 		}

   549 	}

   550 	

   551 void CSimPhoneSmartCardApp::TCyclicSmartCardFile::UpdateOldestRecordPointer()

   552 	{

   553 	//IF the OldestRecord pointer is set to point to the beginning of the buffer

   554 	if(iOldestRecord==0)

   555 		{

   556 		//Set it to point to the beginning of the last record in the buffer

   557 		iOldestRecord = iTotalLength - iRecordLength;

   558 		}

   559 	//ELSE set it to point to the beginning of previous record (the second oldest record)

   560 	else

   561 		{

   562 		iOldestRecord = iOldestRecord - iRecordLength;

   563 		}

   564 	}

   565 	

   566 	

   567 TInt CSimPhoneSmartCardApp::TLinearSmartCardFile::ReadFile(

   568 		const RMobilePhone::TScFilePathWithAccessOffsets& aFilePathOffsets, TDes8* aReadBuffer)

   569 /**

   570 * Concrete implementation of the ReadFile() method for reading file data from a record based

   571 * linear fixed smart card file. Reads precisely one record (iRecordLength bytes).

   572 *

   573 * Note: Records are numbered from 1 to n NOT 0 to n-1

   574 *

   575 * @param aFilePathOffsets Information about which file to read (path) and where in the file to read data from (offsets)

   576 * @param aReadBuffer The requested data is read into this buffer

   577 */

   578 	{

   579 	//check that the client has provided a buffer of sufficient size

   580 	if(aReadBuffer->MaxSize() < iRecordLength)

   581 		{

   582 		return KErrOverflow;

   583 		}

   584 		

   585 	//check that the client has specified a valid start offset

   586 	else if(aFilePathOffsets.iStartOffset < 1 || aFilePathOffsets.iStartOffset > iNumberRecords)

   587 		{

   588 		LOGPHONE1("ERROR: File start offset information invalid.");

   589 		return KErrMMEtelScRecordNotFound;	

   590 		}

   591 	else

   592 		{

   593 		TInt filePointer = (aFilePathOffsets.iStartOffset - 1) * iRecordLength;

   594 		TInt index;

   595 

   596 		aReadBuffer->SetLength(iRecordLength);

   597 		aReadBuffer->FillZ();

   598 		

   599 		for(index = 0; index < iRecordLength; index++)

   600 			{

   601 			(*aReadBuffer)[index] = iFileData[filePointer];

   602 			filePointer++;

   603 			}

   604 		return KErrNone;

   605 		}

   606 	}

   607 	

   608 TInt CSimPhoneSmartCardApp::TLinearSmartCardFile::UpdateFile(

   609 		const RMobilePhone::TScFilePathWithAccessOffsets& aFilePathOffsets, TDes8* aWriteBuffer)

   610 /**

   611 * Concrete implementation of the UpdateFile() method for updating data in a record based

   612 * linear fixed smart card file. Updates precisely one record (iRecordLength bytes).

   613 *

   614 * Note: Records are numbered from 1 to n NOT 0 to n-1

   615 *

   616 * @param aFilePathOffsets Information about which file to update (path) and where in the file to write data to (offsets)

   617 * @param aReadBuffer The data with which the file should be updated.

   618 */

   619 	{

   620 	//check that the client has provided a buffer of sufficient size

   621 	if(aWriteBuffer->Size() != iRecordLength)

   622 		{

   623 		return KErrMMEtelScWrongLength;

   624 		}

   625 	

   626 	//check that the client has specified a valid start offset

   627 	else if(aFilePathOffsets.iStartOffset < 1 || aFilePathOffsets.iStartOffset > iNumberRecords)

   628 		{

   629 		LOGPHONE1("ERROR: File start offset information invalid.");

   630 		return KErrMMEtelScRecordNotFound;	

   631 		}

   632 	else

   633 		{

   634 		TInt filePointer = (aFilePathOffsets.iStartOffset - 1) * iRecordLength;

   635 		TInt index;

   636 

   637 		for(index = 0; index < iRecordLength; index++)

   638 			{

   639 			iFileData[filePointer] = (*aWriteBuffer)[index];

   640 			filePointer++;

   641 			}

   642 		return KErrNone;

   643 		}

   644 	}

   645 	

   646 TInt CSimPhoneSmartCardApp::TTransparentSmartCardFile::ReadFile(

   647 		const RMobilePhone::TScFilePathWithAccessOffsets& aFilePathOffsets, TDes8* aReadBuffer)

   648 /**

   649 * Concrete implementation of the ReadFile() method for reading file data from a binary transparent

   650 * smart card file.

   651 *

   652 * @param aFilePathOffsets Information about which file to read (path) and where in the file to read data from (offsets)

   653 * @param aReadBuffer The requested data is read into this buffer

   654 */

   655 	{

   656 	const TInt& bytesToRead = aFilePathOffsets.iCount;

   657 	TInt filePointer = aFilePathOffsets.iStartOffset;

   658 

   659 	//check that the client has provided a buffer of sufficient size

   660 	if(aReadBuffer->MaxSize() < bytesToRead)

   661 		{

   662 		return KErrOverflow;

   663 		}

   664 	

   665 	//check that the client has specified a valid start offset

   666 	else if(aFilePathOffsets.iStartOffset >= (TUint)iTotalLength)

   667 		{

   668 		LOGPHONE1("ERROR: File start offset information invalid.");

   669 		return KErrMMEtelScReferencedDataNotFound;	

   670 		}

   671 	

   672 	//check the client is not requesting to read too many bytes, resulting in reading

   673 	//off the end of the file

   674 	else if((bytesToRead + filePointer) > iTotalLength)

   675 		{

   676 		LOGPHONE1("ERROR: Path offset information results in reading off the end of the file");

   677 		return KErrMMEtelScEofReached;

   678 		}

   679 	else

   680 		{

   681 		aReadBuffer->SetLength(bytesToRead);

   682 		aReadBuffer->FillZ();

   683 		

   684 		TInt index;

   685 		

   686 		for(index = 0; index < bytesToRead; index++)

   687 			{

   688 			(*aReadBuffer)[index] = iFileData[filePointer];

   689 			filePointer++;

   690 			}

   691 		return KErrNone;

   692 		}

   693 	}

   694 	

   695 TInt CSimPhoneSmartCardApp::TTransparentSmartCardFile::UpdateFile(

   696 		const RMobilePhone::TScFilePathWithAccessOffsets& aFilePathOffsets, TDes8* aWriteBuffer)

   697 /**

   698 * Concrete implementation of the UpdateFile() method for updating data in a binary transparent

   699 * smart card file.

   700 *

   701 * @param aFilePathOffsets Information about which file to update (path) and where in the file to write data to (offsets)

   702 * @param aReadBuffer The data with which the file should be updated.

   703 */

   704 	{

   705 	const TInt& bytesToWrite = aFilePathOffsets.iCount;

   706 	TInt filePointer = aFilePathOffsets.iStartOffset;

   707 	TInt index;

   708 

   709 	//check that the client has provided a buffer of sufficient size

   710 	if(aWriteBuffer->Size() != bytesToWrite)

   711 		{

   712 		//The length of the provided buffer does not match the number of bytes that client has requested

   713 		//should be updated in the file.

   714 		return KErrArgument;

   715 		}

   716 

   717 	//check that the client has specified a valid start offset

   718 	else if(aFilePathOffsets.iStartOffset >= (TUint)iTotalLength)

   719 		{

   720 		LOGPHONE1("ERROR: File start offset information invalid.");

   721 		return KErrMMEtelScReferencedDataNotFound;	

   722 		}

   723 	

   724 	//check the client is not requesting to write too many bytes, resulting in writing

   725 	//off the end of the file

   726 	else if((bytesToWrite + filePointer) > iTotalLength)

   727 		{

   728 		LOGPHONE1("ERROR: Path offset information results in reading off the end of the file");

   729 		return KErrMMEtelScEofReached;

   730 		}

   731 	else

   732 		{

   733 		for(index = 0; index < bytesToWrite; index++)

   734 			{

   735 			iFileData[filePointer] = (*aWriteBuffer)[index];

   736 			filePointer++;

   737 			}

   738 			

   739 		return KErrNone;

   740 		}

   741 	}

   742 	

   743 RMobilePhone::TAID CSimPhoneSmartCardApp::GetActiveUSim()

   744 /**

   745 * Returns the active aid (internally)

   746 *

   747 */

   748 	{

   749 	return iActiveUSimApp;

   750 	}

   751 	

   752 TInt CSimPhoneSmartCardApp::GetCurrentActiveUSimApplication(const TTsyReqHandle aTsyReqHandle, RMobilePhone::TAID* aAID)

   753 /**

   754 * Returns the active aid

   755 *

   756 * @param aReqHandle	The TSY request handle for this request.

   757 * @param aAID	Returns the AID of the Active USim Application

   758 * @return KErrNone

   759 */

   760 	{

   761 	if(iActiveUSimApp.Size() == 0)

   762 		{

   763 		iPhone->ReqCompleted(aTsyReqHandle, KErrMMEtelScApplicationNotActive);

   764 		}

   765 	else

   766 		{

   767 		*aAID=iActiveUSimApp;

   768 		iPhone->ReqCompleted(aTsyReqHandle, KErrNone);

   769 		}

   770 	return KErrNone;	

   771 	}

   772 	

   773 TInt CSimPhoneSmartCardApp::GetCurrentActiveUSimApplicationCancel(const TTsyReqHandle aTsyReqHandle)	

   774 /**

   775 * Attempts to cancel a pending GetActiveUSimApplication request (unsuccessfully)

   776 *

   777 */

   778 	{

   779 	iPhone->ReqCompleted(aTsyReqHandle, KErrNone);

   780 	return KErrNone;		

   781 	}

   782 	

   783 

   784 TInt CSimPhoneSmartCardApp::EnumerateUSimApplications(TTsyReqHandle aTsyReqHandle, TInt* aCount, RMobilePhone::TAID* aActiveAID)

   785 /**

   786 * Enumerates the number of USim applications in the UICC and returns the

   787 * AID of the active application.

   788 *

   789 * @param aTsyReqHandle A handle belonging to the client that created the

   790 *                    session with this TSY server.

   791 * @param aCount Returns the number of USim applications.

   792 * @param aActiveAID Returns the AID of the currently active application.

   793 * @return KErrNone.

   794 */

   795 	{

   796 	*aCount=iUSimAppList->Count();

   797 	aActiveAID->Copy(iActiveUSimApp);

   798 	iPhone->ReqCompleted(aTsyReqHandle, KErrNone);

   799 	return KErrNone;

   800 	}

   801 

   802 

   803 TInt CSimPhoneSmartCardApp::EnumerateUSimApplicationsCancel(TTsyReqHandle aTsyReqHandle)

   804 /**

   805 *Attempts to cancel a pending EnumerateUSimApplications request (unsuccesfully).

   806 *

   807 *@param aTsyReqHandle A handle belonging to the client that created the

   808 *                     session with this TSY server.

   809 */

   810 	{

   811 	iPhone->ReqCompleted(aTsyReqHandle, KErrNone);

   812 	return KErrNone;

   813 	}

   814 

   815 

   816 TInt CSimPhoneSmartCardApp::GetUSimApplicationInfo(TTsyReqHandle aTsyReqHandle, TInt* aUSimAppIndex, TDes8* aInfo)

   817 /**

   818 * Retrieves information for a specified USim application

   819 *

   820 * @param aTsyReqHandle A handle belonging to the client that created the

   821 *                      session with this TSY server.

   822 * @param aUSimAppIndex Used to specify the index of the application.

   823 * @param aInfo Returns the information of the specified appplication.

   824 * @return KErrNone.

   825 */	

   826 	{

   827 	if(*aUSimAppIndex>=iUSimAppList->Count())

   828 		{

   829 		iPhone->ReqCompleted(aTsyReqHandle, KErrNotFound);

   830 		return KErrNone;

   831 		}

   832 	else

   833 		{

   834 		TPckg<RMobilePhone::TUSimApplicationInfoV2>* infoPckg = 

   835 			(TPckg<RMobilePhone::TUSimApplicationInfoV2>*)aInfo;

   836 			

   837 		RMobilePhone::TUSimApplicationInfoV2& info = (*infoPckg)();

   838 

   839 		// Check that the data structure is supported by the simulated TSY version

   840 		TInt err = iPhone->CheckSimTsyVersion(info);

   841 		if(err != KErrNone)

   842 			{

   843 			iPhone->ReqCompleted(aTsyReqHandle, err);

   844 			return KErrNone;

   845 			}

   846 	

   847 		info.iAID = (*iUSimAppList)[*aUSimAppIndex]->iAID;

   848 		info.iLabel = (*iUSimAppList)[*aUSimAppIndex]->iLabel;

   849 		iPhone->ReqCompleted(aTsyReqHandle, KErrNone);

   850 		}

   851 	

   852 	return KErrNone;

   853 	}

   854 

   855 /**

   856 Attempts to cancel a pending GetUSimApplicationInfo request

   857 (unsuccesfully).

   858 

   859 @param aTsyReqHandle A handle belonging to the client that created the

   860                      session with this TSY server.

   861 */

   862 TInt CSimPhoneSmartCardApp::GetUSimApplicationInfoCancel(TTsyReqHandle aTsyReqHandle)

   863 	{

   864 	iPhone->ReqCompleted(aTsyReqHandle, KErrNone);

   865 	return KErrNone;

   866 	}

   867 

   868 

   869 TInt CSimPhoneSmartCardApp::SetUSimApplicationStatus(TTsyReqHandle aTsyReqHandle, RMobilePhone::TAID* aAID, RMobilePhone::TUSimAppAction* aUsimAppAction)

   870 /**

   871 * Attempts to set the status of a specific USim application.

   872 *

   873 * @param aTsyReqHandle A handle belonging to the client that created the

   874 *                      session with this TSY server.

   875 * @param aAID The specific application's ID whose status is to be set.

   876 * @param aUsimAppAction The status to apply to the application identified

   877 *                       by aAID.

   878 * @return KErrNone on completion of request, unless the aAID given is not

   879 *         identifiable, in which case KErrArgument is returned.

   880 */

   881 	{

   882 	TInt ret;

   883 	RMobilePhone::TAID aAidToAction;

   884 	RMobilePhone::TSmartCardApplicationEvent aScEvent;

   885 	TBool isUSimAppAffected = EFalse;

   886 	

   887 	//if the request is to activate a USimApp

   888 	if(*aUsimAppAction == RMobilePhone::EUSimActivate)

   889 		{

   890 		//if another USimApp is active. 

   891 		if(iActiveUSimApp.Size() != 0)

   892 			{

   893 			//terminate active USimApp

   894 			aAidToAction = iActiveUSimApp;

   895 			aScEvent = RMobilePhone::EScApplicationTerminated;

   896 			isUSimAppAffected = EFalse;

   897 			ret = TerminateSmartCardApp(aAidToAction, isUSimAppAffected);

   898 

   899 			//if No error terminating

   900 			if (ret == KErrNone)

   901 				{			

   902 				//notify ScApp client if notify request is pending

   903 				if(iNotifyScInfo.iNotifyPending)

   904 					{

   905 					*(RMobilePhone::TAID*)iNotifyScInfo.iNotifyData1=aAidToAction;

   906 					*(RMobilePhone::TSmartCardApplicationEvent*)iNotifyScInfo.iNotifyData2=aScEvent;

   907 					iNotifyScInfo.iNotifyPending=EFalse;

   908 					iPhone->ReqCompleted(iNotifyScInfo.iNotifyHandle,KErrNone);				

   909 					}

   910 				}

   911 			}//end if(iActiveUSimApp.Size() != 0)

   912 			

   913 		//activate the requested application

   914 		aAidToAction = *aAID;

   915 		aScEvent = RMobilePhone::EScApplicationActivated;

   916 		isUSimAppAffected = EFalse;

   917 		ret=ActivateSmartCardApp(*aAID, isUSimAppAffected);

   918 

   919 		//if no error activating

   920 		if (ret == KErrNone)

   921 			{

   922 			//notify any ScApp client if such notify request is pending

   923 			if(iNotifyScInfo.iNotifyPending)

   924 				{

   925 				iNotifyScInfo.iNotifyPending=EFalse;

   926 				*(RMobilePhone::TAID*)iNotifyScInfo.iNotifyData1=aAidToAction;

   927 				*(RMobilePhone::TSmartCardApplicationEvent*)iNotifyScInfo.iNotifyData2=aScEvent;

   928 				iPhone->ReqCompleted(iNotifyScInfo.iNotifyHandle,KErrNone);

   929 				}

   930 			//notify any USimApp client if such notify request is pending

   931 			if(iNotifyUSimInfo.iNotifyPending)

   932 				{

   933 				iNotifyUSimInfo.iNotifyPending=EFalse;

   934 				*(RMobilePhone::TAID*)iNotifyUSimInfo.iNotifyData1=aAidToAction;

   935 				*(TInt*)iNotifyUSimInfo.iNotifyData2=iUSimAppList->Count();

   936 				iPhone->ReqCompleted(iNotifyUSimInfo.iNotifyHandle,KErrNone);

   937 				}

   938 			}

   939 			

   940 		//complete requests and return

   941 		iPhone->ReqCompleted(aTsyReqHandle,ret);

   942 		return KErrNone;

   943 			

   944 		}

   945 	

   946 	else

   947 		{

   948 		//the request is to terminate a USimApp

   949 		aAidToAction = *aAID;

   950 		aScEvent = RMobilePhone::EScApplicationTerminated;	

   951 

   952 		//terminate active USimApp

   953 		isUSimAppAffected = EFalse;

   954 		ret = TerminateSmartCardApp(aAidToAction, isUSimAppAffected);

   955 

   956 		//if No error terminating

   957 		if (ret == KErrNone)

   958 			{			

   959 			//notify ScApp client if such notify request is pending

   960 			if(iNotifyScInfo.iNotifyPending)

   961 				{

   962 				*(RMobilePhone::TAID*)iNotifyScInfo.iNotifyData1=aAidToAction;

   963 				*(RMobilePhone::TSmartCardApplicationEvent*)iNotifyScInfo.iNotifyData2=aScEvent;

   964 				iNotifyScInfo.iNotifyPending=EFalse;

   965 				iPhone->ReqCompleted(iNotifyScInfo.iNotifyHandle,KErrNone);				

   966 				}

   967 			//notify any USimApp client if such notify request is pending

   968 			if(iNotifyUSimInfo.iNotifyPending)

   969 				{

   970 				*(RMobilePhone::TAID*)iNotifyUSimInfo.iNotifyData1=_L8("");

   971 				*(TInt*)iNotifyUSimInfo.iNotifyData2=iUSimAppList->Count();

   972 				iNotifyUSimInfo.iNotifyPending=EFalse;

   973 				iPhone->ReqCompleted(iNotifyUSimInfo.iNotifyHandle,KErrNone);

   974 				}			

   975 			}

   976 		//complete requests and return

   977 		iPhone->ReqCompleted(aTsyReqHandle,ret);

   978 		return KErrNone;

   979 		}

   980 	}

   981 

   982 

   983 TInt CSimPhoneSmartCardApp::SetUSimApplicationStatusCancel(TTsyReqHandle aTsyReqHandle)

   984 /**

   985 * Attempts to cancel a pending SetUSimApplicationStatus request (unsuccesfully).

   986 *

   987 * @param aTsyReqHandle A handle belonging to the client that created the

   988 *                      session with this TSY server.

   989 * @return KErrNone.

   990 */

   991 	{

   992 	iPhone->ReqCompleted(aTsyReqHandle, KErrNone);

   993 	return KErrNone;

   994 	}

   995 

   996 

   997 TInt CSimPhoneSmartCardApp::NotifyUSimApplicationsInfoChange(const TTsyReqHandle aTsyReqHandle, TInt* aCount, RMobilePhone::TAID* aActiveAID)

   998 /**

   999 * Notifies the client when the specified USim application's information

  1000 * changes.

  1001 *

  1002 * @param aTsyReqHandle A handle belonging to the client that created the

  1003 *                      session with this TSY server.

  1004 * @param aCount Returns the total number of USim applications when the

  1005 *               request completes.

  1006 * @param aActiveAID The application's AID whose infromation change will

  1007 *                   be notified to the client.

  1008 * @return KErrNone.

  1009 */

  1010 	{

  1011 	__ASSERT_ALWAYS(!iNotifyUSimInfo.iNotifyPending,SimPanic(ENotificationReqAlreadyOutstanding));

  1012 

  1013 	TInt count=iSmartCardAppEventList->Count();

  1014 

  1015 	if(iEventPointer<count)

  1016 		{

  1017 		if(iTimerStarted)

  1018 			{

  1019 			delete iTimer;

  1020 			iTimer = NULL;

  1021 			TRAP_IGNORE(iTimer=CSimTimer::NewL(iPhone));

  1022 			}

  1023 

  1024 		TSmartCardAppEvent event=iSmartCardAppEventList->At(iEventPointer);

  1025 		

  1026 		if (iTimer != NULL)

  1027 			{

  1028 			iTimer->Start(event.iDuration,this);

  1029 			iTimerStarted = ETrue;

  1030 			}

  1031 		}

  1032 

  1033 	iNotifyUSimInfo.iNotifyPending=ETrue;

  1034 	iNotifyUSimInfo.iNotifyHandle=aTsyReqHandle;

  1035 	iNotifyUSimInfo.iNotifyData1=aActiveAID;

  1036 	iNotifyUSimInfo.iNotifyData2=aCount;		

  1037 	return KErrNone;

  1038 	}

  1039 

  1040 

  1041 /**

  1042 *Attempts to cancel a pending NotifyUSimApplicationsInfoChange request.

  1043 *

  1044 *@param aTsyReqHandle A handle belonging to the client that created the

  1045 *                     session with this TSY server.

  1046 *@param KErrNone

  1047 */

  1048 TInt CSimPhoneSmartCardApp::NotifyUSimApplicationsInfoChangeCancel(TTsyReqHandle aTsyReqHandle)

  1049 	{

  1050 	if(iNotifyUSimInfo.iNotifyPending)

  1051 		{

  1052 		iNotifyUSimInfo.iNotifyPending=EFalse;

  1053 		iPhone->ReqCompleted(aTsyReqHandle,KErrCancel);

  1054 		}

  1055 	return KErrNone;

  1056 	}

  1057 	

  1058 

  1059 TInt CSimPhoneSmartCardApp::EnumerateScApplications(const TTsyReqHandle aTsyReqHandle, TUint* aCount)

  1060 /**

  1061 * Enumerates the number of Smart Card applications on the UICC

  1062 *

  1063 * @param aReqHandle	The TSY request handle for this request

  1064 * @param aCount	Returns the number of Smart Card applications

  1065 * @return KErrNone

  1066 */

  1067 

  1068 	{

  1069 	*aCount=iSmartCardAppList->Count();

  1070 	iPhone->ReqCompleted(aTsyReqHandle, KErrNone);

  1071 	return KErrNone;

  1072 	}

  1073 

  1074 TInt CSimPhoneSmartCardApp::EnumerateScApplicationsCancel(const TTsyReqHandle aTsyReqHandle)

  1075 /**

  1076 * Attempts to cancel a pending EnumerateUSimApplications request (unsuccessfully)

  1077 *

  1078 * @param aReqHandle	The TSY request handle for this request

  1079 */

  1080 	{

  1081 	iPhone->ReqCompleted(aTsyReqHandle, KErrNone);

  1082 	return KErrNone;

  1083 	}

  1084 

  1085 TInt CSimPhoneSmartCardApp::GetScApplicationInfo(const TTsyReqHandle aTsyReqHandle, TInt* aAppIndex, TDes8* aInfo)

  1086 /**

  1087 * Retrieves information for a specified Smart Card application

  1088 *

  1089 * @param aReqHandle	The TSY request handle for this request

  1090 * @param aAppIndex	is used to specify the index of the application 

  1091 * @param aInfo	Returns the information of the specified appplication

  1092 * @return KErrNone

  1093 */

  1094 	{

  1095 	if(*aAppIndex>=iSmartCardAppList->Count())

  1096 		{

  1097 		iPhone->ReqCompleted(aTsyReqHandle, KErrNotFound);

  1098 		}

  1099 	else

  1100 		{

  1101 		TPckg<RMobilePhone::TSmartCardApplicationInfoV5>* infoPckg = 

  1102 			(TPckg<RMobilePhone::TSmartCardApplicationInfoV5>*)aInfo;

  1103 

  1104 		RMobilePhone::TSmartCardApplicationInfoV5& info = (*infoPckg)();

  1105 

  1106 		// Check that the data structure is supported by the simulated TSY version

  1107 		TInt err = iPhone->CheckSimTsyVersion(info);

  1108 		if(err != KErrNone)

  1109 			{

  1110 			iPhone->ReqCompleted(aTsyReqHandle, err);

  1111 			return KErrNone;

  1112 			}

  1113 

  1114 		info.iAID=iSmartCardAppList->At(*aAppIndex).iAID;

  1115 		info.iLabel=iSmartCardAppList->At(*aAppIndex).iLabel;

  1116 		if (info.ExtensionId() == KEtelExtMultimodeV6)

  1117 			{

  1118 			RMobilePhone::TUiccApplicationEapInfoV6& withEapInfo = static_cast<RMobilePhone::TUiccApplicationEapInfoV6&>(info);

  1119 			withEapInfo.iEapTypeList = iSmartCardAppList->At(*aAppIndex).iEapList;

  1120 			}

  1121 		iPhone->ReqCompleted(aTsyReqHandle, KErrNone);

  1122 		}

  1123 	

  1124 	return KErrNone;

  1125 	}

  1126 

  1127 TInt CSimPhoneSmartCardApp::GetScApplicationInfoCancel(const TTsyReqHandle aTsyReqHandle)

  1128 /**

  1129 * Attempts to cancel a pending GetScApplicationInfo request (unsuccessfully)

  1130 *

  1131 */

  1132 	{

  1133 	iPhone->ReqCompleted(aTsyReqHandle, KErrNone);

  1134 	return KErrNone;