Mercurial Mercurial > oss > FCL > sf > os > cellularsrv / 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.
telephonyserverplugins/simtsy/src/CSimSat.cpp
branchRCL_3
changeset 65 630d2f34d719
parent 0 3553901f7fa8
child 66 07a122eea281
equal deleted inserted replaced
61:17af172ffa5f 65:630d2f34d719 
     1 // Copyright (c) 2001-2009 Nokia Corporation and/or its subsidiary(-ies).
 
     1 // Copyright (c) 2001-2010 Nokia Corporation and/or its subsidiary(-ies).
 
     2 // All rights reserved.
 
     2 // All rights reserved.
 
     3 // This component and the accompanying materials are made available
 
     3 // This component and the accompanying materials are made available
 
     4 // under the terms of "Eclipse Public License v1.0"
 
     4 // under the terms of "Eclipse Public License v1.0"
 
     5 // which accompanies this distribution, and is available
 
     5 // which accompanies this distribution, and is available
 
     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".
 
     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".
 
    18 
    18 
    19 /**
 
    19 /**
 
    20  @file
 
    20  @file
 
    21 */
 
    21 */
 
    22 
    22 
       
    23 
       
    24 
       
    25 #include "OstTraceDefinitions.h"
 
       
    26 #ifdef OST_TRACE_COMPILER_IN_USE
 
       
    27 #include "CSimSatTraces.h"
 
       
    28 #endif
 
       
    29 
    23 #include "CSimSat.h" 
    30 #include "CSimSat.h" 
    24 #include "Simlog.h"
 
       
    25 #include "CSimPhone.h"
 
    31 #include "CSimPhone.h"
 
    26 #include "utils.h"
 
    32 #include "utils.h"
 
    27 #include <satcs.h>
 
    33 #include <satcs.h>
 
    28 #include <e32math.h>
 
    34 #include <e32math.h>
 
    29 
    35 
    68 *
 
    74 *
 
    69 * @leave Leaves no memory or any data member does not construct for any reason.
 
    75 * @leave Leaves no memory or any data member does not construct for any reason.
 
    70 */
 
    76 */
 
    71 	{
 
    77 	{
 
    72 	
    78 	
    73 	LOGMISC1("CSimSat: Entered ConstructL()");
 
    79 	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMSAT_CONSTRUCTL_1, "CSimSat: Entered ConstructL()");
 
    74 	
    80 	
    75 	iSatInfo	=new(ELeave) CArrayFixFlat<TSatInfo>(KSatGranularity);
 
    81 	iSatInfo	=new(ELeave) CArrayFixFlat<TSatInfo>(KSatGranularity);
 
    76 
    82 
    77 	iTimer = CSimTimer::NewL(iPhone);
 
    83 	iTimer = CSimTimer::NewL(iPhone);
 
    78 
    84 
    79 	LOGMISC1("Starting to parse Sat config parameters...");
 
    85 	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMSAT_CONSTRUCTL_2, "Starting to parse Sat config parameters...");
 
    80 	
    86 	
    81 	TInt count		=CfgFile()->ItemCount(KSatRefresh);
 
    87 	TInt count		=CfgFile()->ItemCount(KSatRefresh);
 
    82 	const CTestConfigItem* item=NULL;
 
    88 	const CTestConfigItem* item=NULL;
 
    83 	TInt ret=KErrNone;
 
    89 	TInt ret=KErrNone;
 
    84 
    90 
    93 		TPtrC8 fileList;
 
    99 		TPtrC8 fileList;
 
    94 
   100 
    95 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,duration);
 
   101 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,duration);
 
    96 		if(ret!=KErrNone)
 
   102 		if(ret!=KErrNone)
 
    97 			{
 
   103 			{
 
    98 			LOGPARSERR("duration",ret,0,&KSatRefresh);
 
   104 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMSAT_CONSTRUCTL_3, "WARNING - CONFIGURATION FILE PARSING - Reading element DURATION returned %d (element no. %d) from tag %s.",ret,0,KSatRefresh);
 
    99 			continue;
 
   105 			continue;
 
   100 			}
 
   106 			}
 
   101 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,type);
 
   107 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,type);
 
   102 		if(ret!=KErrNone)
 
   108 		if(ret!=KErrNone)
 
   103 			{
 
   109 			{
 
   104 			LOGPARSERR("type",ret,1,&KSatRefresh);
 
   110 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMSAT_CONSTRUCTL_4, "WARNING - CONFIGURATION FILE PARSING - Reading element TYPE returned %d (element no. %d) from tag %s.",ret,1,KSatRefresh);
 
   105 			continue;
 
   111 			continue;
 
   106 			}
 
   112 			}
 
   107 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,2,fileList);
 
   113 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,2,fileList);
 
   108 		if(ret!=KErrNone)
 
   114 		if(ret!=KErrNone)
 
   109 			{
 
   115 			{
 
   110 			LOGPARSERR("fileList",ret,2,&KSatRefresh);
 
   116 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMSAT_CONSTRUCTL_5, "WARNING - CONFIGURATION FILE PARSING - Reading element FILELIST returned %d (element no. %d) from tag %s.",ret,2,KSatRefresh);
 
   111 			continue;
 
   117 			continue;
 
   112 			}
 
   118 			}
 
   113 
   119 
   114 		TSatInfo satInfo;
 
   120 		TSatInfo satInfo;
 
   115 		satInfo.iDuration = duration;
 
   121 		satInfo.iDuration = duration;
 
   120 		else
 
   126 		else
 
   121 			satInfo.iFileList.Set(fileList);
 
   127 			satInfo.iFileList.Set(fileList);
 
   122 		iSatInfo->AppendL(satInfo);
 
   128 		iSatInfo->AppendL(satInfo);
 
   123 		}
 
   129 		}
 
   124 	
   130 	
   125 	LOGMISC1("...Finished parsing Sat config parameters...");
 
   131 	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMSAT_CONSTRUCTL_6, "...Finished parsing Sat config parameters...");
 
   126 	
   132 	
   127 	if(iSatInfo->Count()!=0)
 
   133 	if(iSatInfo->Count()!=0)
 
   128 		{
 
   134 		{
 
   129 		iSatIndex=0;
 
   135 		iSatIndex=0;
 
   130 		iTimer->Start(iSatInfo->At(0).iDuration,this);
 
   136 		iTimer->Start(iSatInfo->At(0).iDuration,this);
 
   136 * Trivial Destructor
 
   142 * Trivial Destructor
 
   137 * Closes all CObject type objects and destroys all other objects created in the ConstructL()
 
   143 * Closes all CObject type objects and destroys all other objects created in the ConstructL()
 
   138 *
 
   144 *
 
   139 */
 
   145 */
 
   140 	{
 
   146 	{
 
   141 	LOGMISC1("CSimSat: Entered destructor");
 
   147 	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMSAT_DTOR_1, "CSimSat: Entered destructor");
 
   142 	delete iTimer;
 
   148 	delete iTimer;
 
   143 	if(iSatInfo)
 
   149 	if(iSatInfo)
 
   144 		{
 
   150 		{
 
   145 		iSatInfo->Delete(0,iSatInfo->Count());
 
   151 		iSatInfo->Delete(0,iSatInfo->Count());
 
   146 		delete iSatInfo;
 
   152 		delete iSatInfo;
 
   328 		case ESatNotifySetUpCallPCmd:
 
   334 		case ESatNotifySetUpCallPCmd:
 
   329 		case ESatNotifySendUssdPCmd:
 
   335 		case ESatNotifySendUssdPCmd:
 
   330 		case ESatNotifyGetInkeyPCmd:
 
   336 		case ESatNotifyGetInkeyPCmd:
 
   331 		case ESatNotifySendSsPCmd:
 
   337 		case ESatNotifySendSsPCmd:
 
   332 		case ESatNotifyLaunchBrowserPCmd:
 
   338 		case ESatNotifyLaunchBrowserPCmd:
 
   333 			LOGMISC1("CSimSat: ReqModeL");
 
   339 			OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMSAT_REQMODEL_1, "CSimSat: ReqModeL");
 
   334 			ret=KReqModeMultipleCompletionEnabled | KReqModeRePostImmediately;
 
   340 			ret=KReqModeMultipleCompletionEnabled | KReqModeRePostImmediately;
 
   335 			break;
 
   341 			break;
 
   336 		case ESatRefreshAllowed:
 
   342 		case ESatRefreshAllowed:
 
   337 		case ESatTerminalRsp:
 
   343 		case ESatTerminalRsp:
 
   338 		case ESatGetMeSideSatProfile:
 
   344 		case ESatGetMeSideSatProfile:
 
   380 		case ESatEventDownload:
 
   386 		case ESatEventDownload:
 
   381 		case ESatNotifySendUssdPCmd:
 
   387 		case ESatNotifySendUssdPCmd:
 
   382 		case ESatNotifyGetInkeyPCmd:
 
   388 		case ESatNotifyGetInkeyPCmd:
 
   383 		case ESatNotifySendSsPCmd:
 
   389 		case ESatNotifySendSsPCmd:
 
   384 		case ESatNotifyLaunchBrowserPCmd:
 
   390 		case ESatNotifyLaunchBrowserPCmd:
 
   385 			LOGMISC1("CSimSat: RegisterNotification");
 
   391 			OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMSAT_REGISTERNOTIFICATION_1, "CSimSat: RegisterNotification");
 
   386 			return KErrNone;
 
   392 			return KErrNone;
 
   387 		default:
 
   393 		default:
 
   388 			// Unknown or invalid IPC
 
   394 			// Unknown or invalid IPC
 
   389 			LOGMISC1("CSimSat: Register error, unknown IPC");
 
   395 			OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMSAT_REGISTERNOTIFICATION_2, "CSimSat: Register error, unknown IPC");
 
   390 			return KErrNotSupported;
 
   396 			return KErrNotSupported;
 
   391 		}
 
   397 		}
 
   392 	}
 
   398 	}
 
   393 
   399 
   394 TInt CSimSat::DeregisterNotification(const TInt aIpc)
 
   400 TInt CSimSat::DeregisterNotification(const TInt aIpc)
 
   423 		case ESatEventDownload:
 
   429 		case ESatEventDownload:
 
   424 		case ESatNotifySendUssdPCmd:
 
   430 		case ESatNotifySendUssdPCmd:
 
   425 		case ESatNotifyGetInkeyPCmd:
 
   431 		case ESatNotifyGetInkeyPCmd:
 
   426 		case ESatNotifySendSsPCmd:
 
   432 		case ESatNotifySendSsPCmd:
 
   427 		case ESatNotifyLaunchBrowserPCmd:
 
   433 		case ESatNotifyLaunchBrowserPCmd:
 
   428 			LOGMISC1("CSimSat: DeregisterNotification");
 
   434 			OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMSAT_DEREGISTERNOTIFICATION_1, "CSimSat: DeregisterNotification");
 
   429 			return KErrNone;
 
   435 			return KErrNone;
 
   430 		default:
 
   436 		default:
 
   431 			// Unknown or invalid IPC
 
   437 			// Unknown or invalid IPC
 
   432 			LOGMISC1("CSimSat: Deregister error, unknown IPC");
 
   438 			OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMSAT_DEREGISTERNOTIFICATION_2, "CSimSat: Deregister error, unknown IPC");
 
   433 			return KErrNotSupported;
 
   439 			return KErrNotSupported;
 
   434 		}
 
   440 		}
 
   435 	}
 
   441 	}
 
   436 
   442 
   437 TInt CSimSat::NumberOfSlotsL(const TInt aIpc)
 
   443 TInt CSimSat::NumberOfSlotsL(const TInt aIpc)
 
   462 		case ESatEventDownload:
 
   468 		case ESatEventDownload:
 
   463 		case ESatNotifySendUssdPCmd:
 
   469 		case ESatNotifySendUssdPCmd:
 
   464 		case ESatNotifyGetInkeyPCmd:
 
   470 		case ESatNotifyGetInkeyPCmd:
 
   465 		case ESatNotifySendSsPCmd:
 
   471 		case ESatNotifySendSsPCmd:
 
   466 		case ESatNotifyLaunchBrowserPCmd:
 
   472 		case ESatNotifyLaunchBrowserPCmd:
 
   467 			LOGMISC1("CSimSat: Registered with 2 slot");
 
   473 			OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMSAT_NUMBEROFSLOTSL_1, "CSimSat: Registered with 2 slot");
 
   468 			numberOfSlots=2;
 
   474 			numberOfSlots=2;
 
   469 			break;
 
   475 			break;
 
   470 		default:
 
   476 		default:
 
   471 			// Unknown or invalid IPC
 
   477 			// Unknown or invalid IPC
 
   472 			LOGMISC1("CSimSat: Number of Slots error, unknown IPC");
 
   478 			OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMSAT_NUMBEROFSLOTSL_2, "CSimSat: Number of Slots error, unknown IPC");
 
   473 			User::Leave(KErrNotSupported);
 
   479 			User::Leave(KErrNotSupported);
 
   474 			break;
 
   480 			break;
 
   475 		}  
   481 		}  
   476 	return numberOfSlots;
 
   482 	return numberOfSlots;
 
   477 	}
 
   483 	}
 
   560 * @param aTsyReqHandle  The request handle for completing the request 
   566 * @param aTsyReqHandle  The request handle for completing the request 
   561 * @param aIpc Ipc representing the request
 
   567 * @param aIpc Ipc representing the request
 
   562 * @return err KErrNone if request completes ok
 
   568 * @return err KErrNone if request completes ok
 
   563 */
 
   569 */
 
   564 	{
 
   570 	{
 
   565 	LOGMISC1("CSimSat: - CancelService called");
 
   571 	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMSAT_CANCELSERVICE_1, "CSimSat: - CancelService called");
 
   566 	switch (aIpc)
 
   572 	switch (aIpc)
 
   567 		{
 
   573 		{
 
   568 		case ESatNotifyRefreshPCmd:
 
   574 		case ESatNotifyRefreshPCmd:
 
   569 			return NotifyRefreshPCmdCancel(aTsyReqHandle);
 
   575 			return NotifyRefreshPCmdCancel(aTsyReqHandle);
 
   570 		case ESatNotifyRefreshRequired:
 
   576 		case ESatNotifyRefreshRequired:
 
   730 		}
 
   736 		}
 
   731 
   737 
   732 	RSat::TRefreshRspV1Pckg* aRspPckg = (RSat::TRefreshRspV1Pckg*)aRefreshAllowedRsp;
 
   738 	RSat::TRefreshRspV1Pckg* aRspPckg = (RSat::TRefreshRspV1Pckg*)aRefreshAllowedRsp;
 
   733 	RSat::TRefreshRspV1& rspV1 = (*aRspPckg)();
 
   739 	RSat::TRefreshRspV1& rspV1 = (*aRspPckg)();
 
   734 
   740 
   735 	LOGMISC2("RefreshAllowed: - aRefreshAllowedResult %d",rspV1.iGeneralResult);
 
   741 	OstTraceDef1(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMSAT_REFRESHALLOWED_1, "RefreshAllowed: - aRefreshAllowedResult %d",rspV1.iGeneralResult);
 
   736 
   742 
   737 	/* Set simtsy status to reflect clients status */
 
   743 	/* Set simtsy status to reflect clients status */
 
   738 	RSat::TPCmdResult refreshAllowedResult = rspV1.iGeneralResult;
 
   744 	RSat::TPCmdResult refreshAllowedResult = rspV1.iGeneralResult;
 
   739 
   745 
   740 	__ASSERT_ALWAYS(!iRefreshAllowed.iNotifyPending,SimPanic(ENotificationReqAlreadyOutstanding));
 
   746 	__ASSERT_ALWAYS(!iRefreshAllowed.iNotifyPending,SimPanic(ENotificationReqAlreadyOutstanding));
 
  1663 	return KErrNone;
 
  1669 	return KErrNone;
 
  1664 	}
 
  1670 	}
 
  1665 	
  1671 	
  1666 TInt CSimSat::TerminalRsp(const TTsyReqHandle aTsyReqHandle, RSat::TPCmd* aPCmd, TDes8* aRsp)
 
  1672 TInt CSimSat::TerminalRsp(const TTsyReqHandle aTsyReqHandle, RSat::TPCmd* aPCmd, TDes8* aRsp)
 
  1667 {
 
  1673 {
 
  1668 	LOGMISC1(">>CSimSat::TerminalRsp");
 
  1674 	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMSAT_TERMINALRSP_1, ">>CSimSat::TerminalRsp");
 
  1669 	iPendingTerRsp = ETrue;
 
  1675 	iPendingTerRsp = ETrue;
 
  1670 	
  1676 	
  1671 	switch (*aPCmd)
 
  1677 	switch (*aPCmd)
 
  1672 		{
 
  1678 		{
 
  1673 		case RSat::ERetrieveMultimediaMsg:
 
  1679 		case RSat::ERetrieveMultimediaMsg:
 
  1724 * function for further processing.
 
  1730 * function for further processing.
 
  1725 *
 
  1731 *
 
  1726 * @param aId an id identifying which timer callback is being called
 
  1732 * @param aId an id identifying which timer callback is being called
 
  1727 */
 
  1733 */
 
  1728 	{
 
  1734 	{
 
  1729 	LOGMISC1(">>CSimSat::TimerCallBack");
 
  1735 	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMSAT_TIMERCALLBACK_1, ">>CSimSat::TimerCallBack");
 
  1730 		
  1736 		
  1731 	//
 
  1737 	//
 
  1732 	// Convert the SIM TSY text version into the RSat binary version...
 
  1738 	// Convert the SIM TSY text version into the RSat binary version...
 
  1733 	//
 
  1739 	//
 
  1734 	/* Obtain type and file list if present and cache for completion by Refresh Allowed */
 
  1740 	/* Obtain type and file list if present and cache for completion by Refresh Allowed */
 
  2075 	else
 
  2081 	else
 
  2076 		{
 
  2082 		{
 
  2077 		iTimer->Start(randTime(),this);
 
  2083 		iTimer->Start(randTime(),this);
 
  2078 		}
 
  2084 		}
 
  2079 	
  2085 	
  2080 	LOGMISC1("<<CSimSat::TimerCallBack");
 
  2086 	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMSAT_TIMERCALLBACK_2, "<<CSimSat::TimerCallBack");
 
  2081 	}
 
  2087 	}
 
  2082 
  2088 
  2083 
  2089 
  2084 const CTestConfigSection* CSimSat::CfgFile()
 
  2090 const CTestConfigSection* CSimSat::CfgFile()
 
  2085 /**
 
  2091 /**
 
  3373 	}
 
  3379 	}
 
  3374 
  3380 
  3375 
  3381 
  3376 TInt CSimSat::ConfigL(unsigned int aCmd)
 
  3382 TInt CSimSat::ConfigL(unsigned int aCmd)
 
  3377 	{
 
  3383 	{
 
  3378 	LOGMISC1("CSimSat: Entered ConfigL()");
 
  3384 	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMSAT_CONFIGL_1, "CSimSat: Entered ConfigL()");
 
  3379 
  3385 
  3380 	TInt dcs,terRsp,src,UICCRsp,lastEnv,duration,type,frameId,frmLayout,defFrmLayout,frameSeparator;
 
  3386 	TInt dcs,terRsp,src,UICCRsp,lastEnv,duration,type,frameId,frmLayout,defFrmLayout,frameSeparator;
 
  3381 	TInt immRsp,dispPrio,clrScr,utranQlfr,infoType,brType,location,destn,alphaIDSts;
 
  3387 	TInt immRsp,dispPrio,clrScr,utranQlfr,infoType,brType,location,destn,alphaIDSts;
 
  3382 	TInt iconid,iconidqlfr,textStatus,ret=KErrNone;
 
  3388 	TInt iconid,iconidqlfr,textStatus,ret=KErrNone;
 
  3383 	TInt i;			
  3389 	TInt i;			
  3436 					}
 
  3442 					}
 
  3437 
  3443 
  3438 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,destn);
 
  3444 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,destn);
 
  3439 				if(ret!=KErrNone)
 
  3445 				if(ret!=KErrNone)
 
  3440 					{
 
  3446 					{
 
  3441 					LOGPARSERR("destination",ret,0,&KMMRetrieve);
 
  3447 					OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMSAT_CONFIGL_2, "WARNING - CONFIGURATION FILE PARSING - Reading element DESTINATION returned %d (element no. %d) from tag %s.",ret,0,KMMRetrieve);
 
  3442 					continue;
 
  3448 					continue;
 
  3443 					}
 
  3449 					}
 
  3444 				tMMRetrieve.iDestn = destn;
 
  3450 				tMMRetrieve.iDestn = destn;
 
  3445 
  3451 
  3446 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,alphaIDSts);
 
  3452 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,alphaIDSts);
 
  3447 				if(ret!=KErrNone)
 
  3453 				if(ret!=KErrNone)
 
  3448 					{
 
  3454 					{
 
  3449 					LOGPARSERR("alphaIDStatus",ret,1,&KMMRetrieve);
 
  3455 					OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMSAT_CONFIGL_3, "WARNING - CONFIGURATION FILE PARSING - Reading element ALPHAIDSTATUS returned %d (element no. %d) from tag %s.",ret,1,KMMRetrieve);
 
  3450 					continue;
 
  3456 					continue;
 
  3451 					}
 
  3457 					}
 
  3452 				tMMRetrieve.iAlphaStatus=alphaIDSts;
 
  3458 				tMMRetrieve.iAlphaStatus=alphaIDSts;
 
  3453 
  3459 
  3454 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,2,alphaIDBuf);
 
  3460 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,2,alphaIDBuf);
 
  3455 				if(ret!=KErrNone)
 
  3461 				if(ret!=KErrNone)
 
  3456 					{
 
  3462 					{
 
  3457 					LOGPARSERR("alphaIDBuf",ret,2,&KMMRetrieve);
 
  3463 					OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMSAT_CONFIGL_4, "WARNING - CONFIGURATION FILE PARSING - Reading element ALPHAIDBUF returned %d (element no. %d) from tag %s.",ret,2,KMMRetrieve);
 
  3458 					continue;
 
  3464 					continue;
 
  3459 					}
 
  3465 					}
 
  3460 				location = alphaIDBuf.Locate('\n');
 
  3466 				location = alphaIDBuf.Locate('\n');
 
  3461 				if(location > 0)
 
  3467 				if(location > 0)
 
  3462 					{
 
  3468 					{
 
  3468 					}
 
  3474 					}
 
  3469 
  3475 
  3470 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,3,iconid);
 
  3476 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,3,iconid);
 
  3471 				if(ret!=KErrNone)
 
  3477 				if(ret!=KErrNone)
 
  3472 					{
 
  3478 					{
 
  3473 					LOGPARSERR("IconID Identifier",ret,3,&KMMRetrieve);
 
  3479 					OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMSAT_CONFIGL_5, "WARNING - CONFIGURATION FILE PARSING - Reading element ICONID IDENTIFIER returned %d (element no. %d) from tag %s.",ret,3,KMMRetrieve);
 
  3474 					continue;
 
  3480 					continue;
 
  3475 					}
 
  3481 					}
 
  3476 				tMMRetrieve.iIconID = iconid;
 
  3482 				tMMRetrieve.iIconID = iconid;
 
  3477 			
  3483 			
  3478 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,4,iconidqlfr);
 
  3484 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,4,iconidqlfr);
 
  3479 				if(ret!=KErrNone)
 
  3485 				if(ret!=KErrNone)
 
  3480 					{
 
  3486 					{
 
  3481 					LOGPARSERR("IconID qualifier",ret,4,&KMMRetrieve);
 
  3487 					OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMSAT_CONFIGL_6, "WARNING - CONFIGURATION FILE PARSING - Reading element ICONID QUALIFIER returned %d (element no. %d) from tag %s.",ret,4,KMMRetrieve);
 
  3482 					continue;
 
  3488 					continue;
 
  3483 					}
 
  3489 					}
 
  3484 				tMMRetrieve.iIconIDBuf = iconidqlfr;
 
  3490 				tMMRetrieve.iIconIDBuf = iconidqlfr;
 
  3485 
  3491 
  3486 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,5,msgRef);
 
  3492 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,5,msgRef);
 
  3487 				if(ret!=KErrNone)
 
  3493 				if(ret!=KErrNone)
 
  3488 					{
 
  3494 					{
 
  3489 					LOGPARSERR("Message Reference",ret,5,&KMMRetrieve);
 
  3495 					OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMSAT_CONFIGL_7, "WARNING - CONFIGURATION FILE PARSING - Reading element MESSAGE REFERENCE returned %d (element no. %d) from tag %s.",ret,5,KMMRetrieve);
 
  3490 					continue;
 
  3496 					continue;
 
  3491 					}
 
  3497 					}
 
  3492 				location = msgRef.Locate('\n');
 
  3498 				location = msgRef.Locate('\n');
 
  3493 				if(location > 0)
 
  3499 				if(location > 0)
 
  3494 					{
 
  3500 					{
 
  3500 					}
 
  3506 					}
 
  3501 
  3507 
  3502 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,6,rcpFile);
 
  3508 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,6,rcpFile);
 
  3503 				if(ret!=KErrNone)
 
  3509 				if(ret!=KErrNone)
 
  3504 					{
 
  3510 					{
 
  3505 					LOGPARSERR("Reception File",ret,6,&KMMRetrieve);
 
  3511 					OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMSAT_CONFIGL_8, "WARNING - CONFIGURATION FILE PARSING - Reading element RECEPTION FILE returned %d (element no. %d) from tag %s.",ret,6,KMMRetrieve);
 
  3506 					continue;
 
  3512 					continue;
 
  3507 					}
 
  3513 					}
 
  3508 				location = rcpFile.Locate('\n');
 
  3514 				location = rcpFile.Locate('\n');
 
  3509 				if(location > 0)
 
  3515 				if(location > 0)
 
  3510 					{
 
  3516 					{
 
  3516 					}
 
  3522 					}
 
  3517 
  3523 
  3518 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,7,conId);
 
  3524 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,7,conId);
 
  3519 				if(ret!=KErrNone)
 
  3525 				if(ret!=KErrNone)
 
  3520 					{
 
  3526 					{
 
  3521 					LOGPARSERR("Content Identifier",ret,7,&KMMRetrieve);
 
  3527 					OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMSAT_CONFIGL_9, "WARNING - CONFIGURATION FILE PARSING - Reading element CONTENT IDENTIFIER returned %d (element no. %d) from tag %s.",ret,7,KMMRetrieve);
 
  3522 					continue;
 
  3528 					continue;
 
  3523 					}
 
  3529 					}
 
  3524 				location = conId.Locate('\n');
 
  3530 				location = conId.Locate('\n');
 
  3525 				if(location > 0)
 
  3531 				if(location > 0)
 
  3526 					{		
  3532 					{		
  3532 					}
 
  3538 					}
 
  3533 
  3539 
  3534 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,8,msgId);
 
  3540 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,8,msgId);
 
  3535 				if(ret!=KErrNone)
 
  3541 				if(ret!=KErrNone)
 
  3536 					{
 
  3542 					{
 
  3537 					LOGPARSERR("Message Identifier",ret,8,&KMMRetrieve);
 
  3543 					OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMSAT_CONFIGL_10, "WARNING - CONFIGURATION FILE PARSING - Reading element MESSAGE IDENTIFIER returned %d (element no. %d) from tag %s.",ret,8,KMMRetrieve);
 
  3538 					continue;
 
  3544 					continue;
 
  3539 					}
 
  3545 					}
 
  3540 				location = msgId.Locate('\n');
 
  3546 				location = msgId.Locate('\n');
 
  3541 				if(location > 0)
 
  3547 				if(location > 0)
 
  3542 					{
 
  3548 					{
 
  3548 					}
 
  3554 					}
 
  3549 				
  3555 				
  3550 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,9,textStatus);
 
  3556 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,9,textStatus);
 
  3551 				if(ret!=KErrNone)
 
  3557 				if(ret!=KErrNone)
 
  3552 					{
 
  3558 					{
 
  3553 					LOGPARSERR("Text Attribute Status",ret,9,&KMMRetrieve);
 
  3559 					OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMSAT_CONFIGL_11, "WARNING - CONFIGURATION FILE PARSING - Reading element TEXT ATTRIBUTE STATUS returned %d (element no. %d) from tag %s.",ret,9,KMMRetrieve);
 
  3554 					continue;
 
  3560 					continue;
 
  3555 					}
 
  3561 					}
 
  3556 				tMMRetrieve.iTextAttStatus = textStatus;
 
  3562 				tMMRetrieve.iTextAttStatus = textStatus;
 
  3557 
  3563 
  3558 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,10,txtAttr);
 
  3564 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,10,txtAttr);
 
  3559 				if(ret!=KErrNone)
 
  3565 				if(ret!=KErrNone)
 
  3560 					{
 
  3566 					{
 
  3561 					LOGPARSERR("Text Attribute",ret,10,&KMMRetrieve);
 
  3567 					OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMSAT_CONFIGL_12, "WARNING - CONFIGURATION FILE PARSING - Reading element TEXT ATTRIBUTE returned %d (element no. %d) from tag %s.",ret,10,KMMRetrieve);
 
  3562 					continue;
 
  3568 					continue;
 
  3563 					}
 
  3569 					}
 
  3564 				location = txtAttr.Locate('\n');
 
  3570 				location = txtAttr.Locate('\n');
 
  3565 				if(location > 0)
 
  3571 				if(location > 0)
 
  3566 					{
 
  3572 					{
 
  3588 					}
 
  3594 					}
 
  3589 							
  3595 							
  3590 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,destn);
 
  3596 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,destn);
 
  3591 				if(ret!=KErrNone)
 
  3597 				if(ret!=KErrNone)
 
  3592 					{
 
  3598 					{
 
  3593 					LOGPARSERR("destination",ret,0,&KMMSubmit);
 
  3599 					OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMSAT_CONFIGL_13, "WARNING - CONFIGURATION FILE PARSING - Reading element DESTINATION returned %d (element no. %d) from tag %s.",ret,0,KMMSubmit);
 
  3594 					continue;
 
  3600 					continue;
 
  3595 					}
 
  3601 					}
 
  3596 				tMMSubmit.iDestn = destn;
 
  3602 				tMMSubmit.iDestn = destn;
 
  3597 
  3603 
  3598 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,alphaIDSts);
 
  3604 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,alphaIDSts);
 
  3599 				if(ret!=KErrNone)
 
  3605 				if(ret!=KErrNone)
 
  3600 					{
 
  3606 					{
 
  3601 					LOGPARSERR("alphaIDStatus",ret,1,&KMMSubmit);
 
  3607 					OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMSAT_CONFIGL_14, "WARNING - CONFIGURATION FILE PARSING - Reading element ALPHAIDSTATUS returned %d (element no. %d) from tag %s.",ret,1,KMMSubmit);
 
  3602 					continue;
 
  3608 					continue;
 
  3603 					}
 
  3609 					}
 
  3604 				tMMSubmit.iAlphaStatus=alphaIDSts;
 
  3610 				tMMSubmit.iAlphaStatus=alphaIDSts;
 
  3605 
  3611 
  3606 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,2,alphaIDBuf);
 
  3612 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,2,alphaIDBuf);
 
  3607 				if(ret!=KErrNone)
 
  3613 				if(ret!=KErrNone)
 
  3608 					{
 
  3614 					{
 
  3609 					LOGPARSERR("alphaIDBuf",ret,2,&KMMSubmit);
 
  3615 					OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMSAT_CONFIGL_15, "WARNING - CONFIGURATION FILE PARSING - Reading element ALPHAIDBUF returned %d (element no. %d) from tag %s.",ret,2,KMMSubmit);
 
  3610 					continue;
 
  3616 					continue;
 
  3611 					}
 
  3617 					}
 
  3612 				location = alphaIDBuf.Locate('\n');
 
  3618 				location = alphaIDBuf.Locate('\n');
 
  3613 				if(location > 0)
 
  3619 				if(location > 0)
 
  3614 					tMMSubmit.iAlphaIDBuf.Set(alphaIDBuf.Left(location));
 
  3620 					tMMSubmit.iAlphaIDBuf.Set(alphaIDBuf.Left(location));
 
  3616 					tMMSubmit.iAlphaIDBuf.Set(alphaIDBuf);
 
  3622 					tMMSubmit.iAlphaIDBuf.Set(alphaIDBuf);
 
  3617 
  3623 
  3618 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,3,iconid);
 
  3624 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,3,iconid);
 
  3619 				if(ret!=KErrNone)
 
  3625 				if(ret!=KErrNone)
 
  3620 					{
 
  3626 					{
 
  3621 					LOGPARSERR("IconID Identifier",ret,3,&KMMSubmit);
 
  3627 					OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMSAT_CONFIGL_16, "WARNING - CONFIGURATION FILE PARSING - Reading element ICONID IDENTIFIER returned %d (element no. %d) from tag %s.",ret,3,KMMSubmit);
 
  3622 					continue;
 
  3628 					continue;
 
  3623 					}
 
  3629 					}
 
  3624 				tMMSubmit.iIconID = iconid;
 
  3630 				tMMSubmit.iIconID = iconid;
 
  3625 			
  3631 			
  3626 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,4,iconidqlfr);
 
  3632 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,4,iconidqlfr);
 
  3627 				if(ret!=KErrNone)
 
  3633 				if(ret!=KErrNone)
 
  3628 					{
 
  3634 					{
 
  3629 					LOGPARSERR("IconID qualifier",ret,4,&KMMSubmit);
 
  3635 					OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMSAT_CONFIGL_17, "WARNING - CONFIGURATION FILE PARSING - Reading element ICONID QUALIFIER returned %d (element no. %d) from tag %s.",ret,4,KMMSubmit);
 
  3630 					continue;
 
  3636 					continue;
 
  3631 					}
 
  3637 					}
 
  3632 				tMMSubmit.iIconIDBuf = iconidqlfr;
 
  3638 				tMMSubmit.iIconIDBuf = iconidqlfr;
 
  3633 				
  3639 				
  3634 				
  3640 				
  3635 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,5,subFile);
 
  3641 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,5,subFile);
 
  3636 				if(ret!=KErrNone)
 
  3642 				if(ret!=KErrNone)
 
  3637 					{
 
  3643 					{
 
  3638 					LOGPARSERR("Submission File",ret,5,&KMMSubmit);
 
  3644 					OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMSAT_CONFIGL_18, "WARNING - CONFIGURATION FILE PARSING - Reading element SUBMISSION FILE returned %d (element no. %d) from tag %s.",ret,5,KMMSubmit);
 
  3639 					continue;
 
  3645 					continue;
 
  3640 					}
 
  3646 					}
 
  3641 				location = subFile.Locate('\n');
 
  3647 				location = subFile.Locate('\n');
 
  3642 				if(location > 0)
 
  3648 				if(location > 0)
 
  3643 					tMMSubmit.iSbmsnFile.Set(subFile.Left(location));
 
  3649 					tMMSubmit.iSbmsnFile.Set(subFile.Left(location));
 
  3645 					tMMSubmit.iSbmsnFile.Set(subFile);
 
  3651 					tMMSubmit.iSbmsnFile.Set(subFile);
 
  3646 				
  3652 				
  3647 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,6,msgId);
 
  3653 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,6,msgId);
 
  3648 				if(ret!=KErrNone)
 
  3654 				if(ret!=KErrNone)
 
  3649 					{
 
  3655 					{
 
  3650 					LOGPARSERR("Message Identifier",ret,6,&KMMSubmit);
 
  3656 					OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMSAT_CONFIGL_19, "WARNING - CONFIGURATION FILE PARSING - Reading element MESSAGE IDENTIFIER returned %d (element no. %d) from tag %s.",ret,6,KMMSubmit);
 
  3651 					continue;
 
  3657 					continue;
 
  3652 					}
 
  3658 					}
 
  3653 				location = msgId.Locate('\n');
 
  3659 				location = msgId.Locate('\n');
 
  3654 				if(location > 0)
 
  3660 				if(location > 0)
 
  3655 					tMMSubmit.iMsgId.Set(msgId.Left(location));
 
  3661 					tMMSubmit.iMsgId.Set(msgId.Left(location));
 
  3657 					tMMSubmit.iMsgId.Set(msgId);
 
  3663 					tMMSubmit.iMsgId.Set(msgId);
 
  3658 				
  3664 				
  3659 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,7,textStatus);
 
  3665 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,7,textStatus);
 
  3660 				if(ret!=KErrNone)
 
  3666 				if(ret!=KErrNone)
 
  3661 					{
 
  3667 					{
 
  3662 					LOGPARSERR("Text Attribute Status",ret,7,&KMMSubmit);
 
  3668 					OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMSAT_CONFIGL_20, "WARNING - CONFIGURATION FILE PARSING - Reading element TEXT ATTRIBUTE STATUS returned %d (element no. %d) from tag %s.",ret,7,KMMSubmit);
 
  3663 					continue;
 
  3669 					continue;
 
  3664 					}
 
  3670 					}
 
  3665 				tMMSubmit.iTextAttStatus = textStatus;
 
  3671 				tMMSubmit.iTextAttStatus = textStatus;
 
  3666 
  3672 
  3667 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,8,txtAttr);
 
  3673 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,8,txtAttr);
 
  3668 				if(ret!=KErrNone)
 
  3674 				if(ret!=KErrNone)
 
  3669 					{
 
  3675 					{
 
  3670 					LOGPARSERR("Text Attribute",ret,8,&KMMSubmit);
 
  3676 					OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMSAT_CONFIGL_21, "WARNING - CONFIGURATION FILE PARSING - Reading element TEXT ATTRIBUTE returned %d (element no. %d) from tag %s.",ret,8,KMMSubmit);
 
  3671 					continue;
 
  3677 					continue;
 
  3672 					}
 
  3678 					}
 
  3673 				location = txtAttr.Locate('\n');
 
  3679 				location = txtAttr.Locate('\n');
 
  3674 				if(location > 0)
 
  3680 				if(location > 0)
 
  3675 					tMMSubmit.iTextAttBuf.Set(txtAttr.Left(location));
 
  3681 					tMMSubmit.iTextAttBuf.Set(txtAttr.Left(location));
 
  3694 					}
 
  3700 					}
 
  3695 				
  3701 				
  3696 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,destn);
 
  3702 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,destn);
 
  3697 				if(ret!=KErrNone)
 
  3703 				if(ret!=KErrNone)
 
  3698 					{
 
  3704 					{
 
  3699 					LOGPARSERR("destination",ret,0,&KMMDisplay);
 
  3705 					OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMSAT_CONFIGL_22, "WARNING - CONFIGURATION FILE PARSING - Reading element DESTINATION returned %d (element no. %d) from tag %s.",ret,0,KMMDisplay);
 
  3700 					continue;
 
  3706 					continue;
 
  3701 					}
 
  3707 					}
 
  3702 				tMMDisplay.iDestn = destn;
 
  3708 				tMMDisplay.iDestn = destn;
 
  3703 				
  3709 				
  3704 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,dispPrio);
 
  3710 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,dispPrio);
 
  3705 				if(ret!=KErrNone)
 
  3711 				if(ret!=KErrNone)
 
  3706 					{
 
  3712 					{
 
  3707 					LOGPARSERR("Display Priority",ret,1,&KMMDisplay);
 
  3713 					OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMSAT_CONFIGL_23, "WARNING - CONFIGURATION FILE PARSING - Reading element DISPLAY PRIORITY returned %d (element no. %d) from tag %s.",ret,1,KMMDisplay);
 
  3708 					continue;
 
  3714 					continue;
 
  3709 					}
 
  3715 					}
 
  3710 				tMMDisplay.iDispPri = dispPrio;
 
  3716 				tMMDisplay.iDispPri = dispPrio;
 
  3711 				
  3717 				
  3712 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,2,clrScr);
 
  3718 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,2,clrScr);
 
  3713 				if(ret!=KErrNone)
 
  3719 				if(ret!=KErrNone)
 
  3714 					{
 
  3720 					{
 
  3715 					LOGPARSERR("ClearScreen",ret,2,&KMMDisplay);
 
  3721 					OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMSAT_CONFIGL_24, "WARNING - CONFIGURATION FILE PARSING - Reading element CLEARSCREEN returned %d (element no. %d) from tag %s.",ret,2,KMMDisplay);
 
  3716 					continue;
 
  3722 					continue;
 
  3717 					}
 
  3723 					}
 
  3718 				tMMDisplay.iClrScr = clrScr;
 
  3724 				tMMDisplay.iClrScr = clrScr;
 
  3719 				
  3725 				
  3720 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,3,dispFile);
 
  3726 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,3,dispFile);
 
  3721 				if(ret!=KErrNone)
 
  3727 				if(ret!=KErrNone)
 
  3722 					{
 
  3728 					{
 
  3723 					LOGPARSERR("Submission File",ret,3,&KMMDisplay);
 
  3729 					OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMSAT_CONFIGL_25, "WARNING - CONFIGURATION FILE PARSING - Reading element SUBMISSION FILE returned %d (element no. %d) from tag %s.",ret,3,KMMDisplay);
 
  3724 					continue;
 
  3730 					continue;
 
  3725 					}
 
  3731 					}
 
  3726 				location = dispFile.Locate('\n');
 
  3732 				location = dispFile.Locate('\n');
 
  3727 				if(location > 0)
 
  3733 				if(location > 0)
 
  3728 					tMMDisplay.iSbmsnFile.Set(dispFile.Left(location));
 
  3734 					tMMDisplay.iSbmsnFile.Set(dispFile.Left(location));
 
  3730 					tMMDisplay.iSbmsnFile.Set(dispFile);
 
  3736 					tMMDisplay.iSbmsnFile.Set(dispFile);
 
  3731 				
  3737 				
  3732 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,4,msgId);
 
  3738 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,4,msgId);
 
  3733 				if(ret!=KErrNone)
 
  3739 				if(ret!=KErrNone)
 
  3734 					{
 
  3740 					{
 
  3735 					LOGPARSERR("Message Identifier",ret,4,&KMMSubmit);
 
  3741 					OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMSAT_CONFIGL_26, "WARNING - CONFIGURATION FILE PARSING - Reading element MESSAGE IDENTIFIER returned %d (element no. %d) from tag %s.",ret,4,KMMSubmit);
 
  3736 					continue;
 
  3742 					continue;
 
  3737 					}
 
  3743 					}
 
  3738 				location = msgId.Locate('\n');
 
  3744 				location = msgId.Locate('\n');
 
  3739 				if(location > 0)
 
  3745 				if(location > 0)
 
  3740 					tMMDisplay.iMsgId.Set(msgId.Left(location));
 
  3746 					tMMDisplay.iMsgId.Set(msgId.Left(location));
 
  3742 					tMMDisplay.iMsgId.Set(msgId);
 
  3748 					tMMDisplay.iMsgId.Set(msgId);
 
  3743 				
  3749 				
  3744 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,5,immRsp);
 
  3750 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,5,immRsp);
 
  3745 				if(ret!=KErrNone)
 
  3751 				if(ret!=KErrNone)
 
  3746 					{
 
  3752 					{
 
  3747 					LOGPARSERR("Immediate Response",ret,5,&KMMDisplay);
 
  3753 					OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMSAT_CONFIGL_27, "WARNING - CONFIGURATION FILE PARSING - Reading element IMMEDIATE RESPONSE returned %d (element no. %d) from tag %s.",ret,5,KMMDisplay);
 
  3748 					continue;
 
  3754 					continue;
 
  3749 					}
 
  3755 					}
 
  3750 				tMMDisplay.iImmRsp = immRsp;
 
  3756 				tMMDisplay.iImmRsp = immRsp;
 
  3751 					
  3757 					
  3752 				iMMDisplay->AppendL(tMMDisplay);		
  3758 				iMMDisplay->AppendL(tMMDisplay);		
  3767 					}
 
  3773 					}
 
  3768 			
  3774 			
  3769 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,destn);
 
  3775 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,destn);
 
  3770 				if(ret!=KErrNone)
 
  3776 				if(ret!=KErrNone)
 
  3771 					{
 
  3777 					{
 
  3772 					LOGPARSERR("destination",ret,0,&KSetFrames);
 
  3778 					OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMSAT_CONFIGL_28, "WARNING - CONFIGURATION FILE PARSING - Reading element DESTINATION returned %d (element no. %d) from tag %s.",ret,0,KSetFrames);
 
  3773 					continue;
 
  3779 					continue;
 
  3774 					}
 
  3780 					}
 
  3775 				tSetFrms.iDestn = destn;
 
  3781 				tSetFrms.iDestn = destn;
 
  3776 						
  3782 						
  3777 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,frameId);
 
  3783 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,frameId);
 
  3778 				if(ret!=KErrNone)
 
  3784 				if(ret!=KErrNone)
 
  3779 					{
 
  3785 					{
 
  3780 					LOGPARSERR("Frame Identifier",ret,1,&KSetFrames);
 
  3786 					OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMSAT_CONFIGL_29, "WARNING - CONFIGURATION FILE PARSING - Reading element FRAME IDENTIFIER returned %d (element no. %d) from tag %s.",ret,1,KSetFrames);
 
  3781 					}
 
  3787 					}
 
  3782 				tSetFrms.iFrmId = frameId;
 
  3788 				tSetFrms.iFrmId = frameId;
 
  3783 				
  3789 				
  3784 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,2,frmLayout);
 
  3790 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,2,frmLayout);
 
  3785 				if(ret!=KErrNone)
 
  3791 				if(ret!=KErrNone)
 
  3786 					{
 
  3792 					{
 
  3787 					LOGPARSERR("Frame Layout",ret,2,&KSetFrames);
 
  3793 					OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMSAT_CONFIGL_30, "WARNING - CONFIGURATION FILE PARSING - Reading element FRAME LAYOUT returned %d (element no. %d) from tag %s.",ret,2,KSetFrames);
 
  3788 					}
 
  3794 					}
 
  3789 				tSetFrms.iFrmLayout = frmLayout;
 
  3795 				tSetFrms.iFrmLayout = frmLayout;
 
  3790 				
  3796 				
  3791 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,3,frmLayoutBuf);
 
  3797 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,3,frmLayoutBuf);
 
  3792 				if(ret!=KErrNone)
 
  3798 				if(ret!=KErrNone)
 
  3793 					{
 
  3799 					{
 
  3794 					LOGPARSERR("Frame Layout buffer",ret,3,&KSetFrames);
 
  3800 					OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMSAT_CONFIGL_31, "WARNING - CONFIGURATION FILE PARSING - Reading element FRAME LAYOUT BUFFER returned %d (element no. %d) from tag %s.",ret,3,KSetFrames);
 
  3795 					}
 
  3801 					}
 
  3796 				location = frmLayoutBuf.Locate('\n');
 
  3802 				location = frmLayoutBuf.Locate('\n');
 
  3797 				if(location > 0)
 
  3803 				if(location > 0)
 
  3798 					tSetFrms.iFrmLayoutBuf.Set(frmLayoutBuf.Left(location));
 
  3804 					tSetFrms.iFrmLayoutBuf.Set(frmLayoutBuf.Left(location));
 
  3799 				else
 
  3805 				else
 
  3800 					tSetFrms.iFrmLayoutBuf.Set(frmLayoutBuf);
 
  3806 					tSetFrms.iFrmLayoutBuf.Set(frmLayoutBuf);
 
  3801 				
  3807 				
  3802 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,4,defFrmLayout);
 
  3808 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,4,defFrmLayout);
 
  3803 				if(ret!=KErrNone)
 
  3809 				if(ret!=KErrNone)
 
  3804 					{
 
  3810 					{
 
  3805 					LOGPARSERR("Default Frame Layout",ret,4,&KSetFrames);
 
  3811 					OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMSAT_CONFIGL_32, "WARNING - CONFIGURATION FILE PARSING - Reading element DEFAULT FRAME LAYOUT returned %d (element no. %d) from tag %s.",ret,4,KSetFrames);
 
  3806 					}
 
  3812 					}
 
  3807 				tSetFrms.iDefFrmId = defFrmLayout;
 
  3813 				tSetFrms.iDefFrmId = defFrmLayout;
 
  3808 						
  3814 						
  3809 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,5,frameSeparator);
 
  3815 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,5,frameSeparator);
 
  3810 				if(ret!=KErrNone)
 
  3816 				if(ret!=KErrNone)
 
  3811 					{
 
  3817 					{
 
  3812 					LOGPARSERR("Frame Separator",ret,5,&KSetFrames);
 
  3818 					OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMSAT_CONFIGL_33, "WARNING - CONFIGURATION FILE PARSING - Reading element FRAME SEPARATOR returned %d (element no. %d) from tag %s.",ret,5,KSetFrames);
 
  3813 					}
 
  3819 					}
 
  3814 				tSetFrms.iFrmSeparator = frameSeparator;
 
  3820 				tSetFrms.iFrmSeparator = frameSeparator;
 
  3815 				
  3821 				
  3816 				iSetFrms->AppendL(tSetFrms);
 
  3822 				iSetFrms->AppendL(tSetFrms);
 
  3817 				
  3823 				
  3830 					}
 
  3836 					}
 
  3831 
  3837 
  3832 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,destn);
 
  3838 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,destn);
 
  3833 				if(ret!=KErrNone)
 
  3839 				if(ret!=KErrNone)
 
  3834 					{
 
  3840 					{
 
  3835 					LOGPARSERR("destination",ret,0,&KGetFramesStatus);
 
  3841 					OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMSAT_CONFIGL_34, "WARNING - CONFIGURATION FILE PARSING - Reading element DESTINATION returned %d (element no. %d) from tag %s.",ret,0,KGetFramesStatus);
 
  3836 					continue;
 
  3842 					continue;
 
  3837 					}
 
  3843 					}
 
  3838 				tGetFrmsSts.iDestn = destn;
 
  3844 				tGetFrmsSts.iDestn = destn;
 
  3839 				
  3845 				
  3840 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,frameId);
 
  3846 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,frameId);
 
  3841 				if(ret!=KErrNone)
 
  3847 				if(ret!=KErrNone)
 
  3842 					{
 
  3848 					{
 
  3843 					LOGPARSERR("Frame Id",ret,1,&KGetFramesStatus);
 
  3849 					OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMSAT_CONFIGL_35, "WARNING - CONFIGURATION FILE PARSING - Reading element FRAME ID returned %d (element no. %d) from tag %s.",ret,1,KGetFramesStatus);
 
  3844 					continue;
 
  3850 					continue;
 
  3845 					}
 
  3851 					}
 
  3846 				tGetFrmsSts.iFrmId = frameId;
 
  3852 				tGetFrmsSts.iFrmId = frameId;
 
  3847 				
  3853 				
  3848 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,2,frmLayoutBuf);
 
  3854 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,2,frmLayoutBuf);
 
  3849 				if(ret!=KErrNone)
 
  3855 				if(ret!=KErrNone)
 
  3850 					{
 
  3856 					{
 
  3851 					LOGPARSERR("FrameLayout Buffer",ret,1,&KGetFramesStatus);
 
  3857 					OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMSAT_CONFIGL_36, "WARNING - CONFIGURATION FILE PARSING - Reading element FRAMELAYOUT BUFFER returned %d (element no. %d) from tag %s.",ret,1,KGetFramesStatus);
 
  3852 					continue;
 
  3858 					continue;
 
  3853 					}
 
  3859 					}
 
  3854 				location = frmLayoutBuf.Locate('\n');
 
  3860 				location = frmLayoutBuf.Locate('\n');
 
  3855 				if(location > 0)
 
  3861 				if(location > 0)
 
  3856 					tGetFrmsSts.iFrmList.Set(frmLayoutBuf.Left(location));
 
  3862 					tGetFrmsSts.iFrmList.Set(frmLayoutBuf.Left(location));
 
  3874 					}
 
  3880 					}
 
  3875 					
  3881 					
  3876 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,destn);
 
  3882 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,destn);
 
  3877 				if(ret!=KErrNone)
 
  3883 				if(ret!=KErrNone)
 
  3878 					{
 
  3884 					{
 
  3879 					LOGPARSERR("Destination",ret,0,&KLocalInfo);
 
  3885 					OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMSAT_CONFIGL_37, "WARNING - CONFIGURATION FILE PARSING - Reading element DESTINATION returned %d (element no. %d) from tag %s.",ret,0,KLocalInfo);
 
  3880 					continue;
 
  3886 					continue;
 
  3881 					}
 
  3887 					}
 
  3882 				tLocalInfo.iDeviceId = destn;
 
  3888 				tLocalInfo.iDeviceId = destn;
 
  3883 				
  3889 				
  3884 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,infoType);
 
  3890 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,infoType);
 
  3885 				if(ret!=KErrNone)
 
  3891 				if(ret!=KErrNone)
 
  3886 					{
 
  3892 					{
 
  3887 					LOGPARSERR("Information Type",ret,1,&KLocalInfo);
 
  3893 					OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMSAT_CONFIGL_38, "WARNING - CONFIGURATION FILE PARSING - Reading element INFORMATION TYPE returned %d (element no. %d) from tag %s.",ret,1,KLocalInfo);
 
  3888 					continue;
 
  3894 					continue;
 
  3889 					}
 
  3895 					}
 
  3890 				tLocalInfo.iLocalInfoType = infoType;
 
  3896 				tLocalInfo.iLocalInfoType = infoType;
 
  3891 				
  3897 				
  3892 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,2,utranQlfr);
 
  3898 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,2,utranQlfr);
 
  3893 				if(ret!=KErrNone)
 
  3899 				if(ret!=KErrNone)
 
  3894 					{
 
  3900 					{
 
  3895 					LOGPARSERR("UTRAN Qlfr",ret,2,&KLocalInfo);
 
  3901 					OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMSAT_CONFIGL_39, "WARNING - CONFIGURATION FILE PARSING - Reading element UTRAN QLFR returned %d (element no. %d) from tag %s.",ret,2,KLocalInfo);
 
  3896 					continue;
 
  3902 					continue;
 
  3897 					}
 
  3903 					}
 
  3898 				tLocalInfo.iUTRANQlfr = utranQlfr;
 
  3904 				tLocalInfo.iUTRANQlfr = utranQlfr;
 
  3899 				
  3905 				
  3900 				iLocalInfo->AppendL(tLocalInfo);
 
  3906 				iLocalInfo->AppendL(tLocalInfo);
 
  3914 					}
 
  3920 					}
 
  3915 					
  3921 					
  3916 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,brType);
 
  3922 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,brType);
 
  3917 				if(ret!=KErrNone)
 
  3923 				if(ret!=KErrNone)
 
  3918 					{
 
  3924 					{
 
  3919 					LOGPARSERR("Destination",ret,0,&KOpenChnl);
 
  3925 					OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMSAT_CONFIGL_40, "WARNING - CONFIGURATION FILE PARSING - Reading element DESTINATION returned %d (element no. %d) from tag %s.",ret,0,KOpenChnl);
 
  3920 					continue;
 
  3926 					continue;
 
  3921 					}
 
  3927 					}
 
  3922 				tOpenChn.iBearerType = brType;
 
  3928 				tOpenChn.iBearerType = brType;
 
  3923 				
  3929 				
  3924 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,frameId);
 
  3930 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,frameId);
 
  3925 				if(ret!=KErrNone)
 
  3931 				if(ret!=KErrNone)
 
  3926 					{
 
  3932 					{
 
  3927 					LOGPARSERR("Information Type",ret,1,&KOpenChnl);
 
  3933 					OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMSAT_CONFIGL_41, "WARNING - CONFIGURATION FILE PARSING - Reading element INFORMATION TYPE returned %d (element no. %d) from tag %s.",ret,1,KOpenChnl);
 
  3928 					continue;
 
  3934 					continue;
 
  3929 					}
 
  3935 					}
 
  3930 				tOpenChn.iFrameId = frameId;
 
  3936 				tOpenChn.iFrameId = frameId;
 
  3931 				
  3937 				
  3932 				iOpenChn->AppendL(tOpenChn);
 
  3938 				iOpenChn->AppendL(tOpenChn);
 
  3948 					}
 
  3954 					}
 
  3949 					
  3955 					
  3950 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,frameId);
 
  3956 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,frameId);
 
  3951 				if(ret!=KErrNone)
 
  3957 				if(ret!=KErrNone)
 
  3952 					{
 
  3958 					{
 
  3953 					LOGPARSERR("FrameId",ret,0,&KMiscCmd);
 
  3959 					OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMSAT_CONFIGL_42, "WARNING - CONFIGURATION FILE PARSING - Reading element FRAMEID returned %d (element no. %d) from tag %s.",ret,0,KMiscCmd);
 
  3954 					continue;
 
  3960 					continue;
 
  3955 					}
 
  3961 					}
 
  3956 				tMiscCmd.iFrameId = frameId;
 
  3962 				tMiscCmd.iFrameId = frameId;
 
  3957 				
  3963 				
  3958 					iMiscCmd->AppendL(tMiscCmd);
 
  3964 					iMiscCmd->AppendL(tMiscCmd);
 
  3975 				TPtrC8 applId;
 
  3981 				TPtrC8 applId;
 
  3976 
  3982 
  3977 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,duration);
 
  3983 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,duration);
 
  3978 				if(ret!=KErrNone)
 
  3984 				if(ret!=KErrNone)
 
  3979 					{
 
  3985 					{
 
  3980 					LOGPARSERR("duration",ret,0,&KRefresh2);
 
  3986 					OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMSAT_CONFIGL_43, "WARNING - CONFIGURATION FILE PARSING - Reading element DURATION returned %d (element no. %d) from tag %s.",ret,0,KRefresh2);
 
  3981 					continue;
 
  3987 					continue;
 
  3982 					}
 
  3988 					}
 
  3983 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,type);
 
  3989 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,type);
 
  3984 				if(ret!=KErrNone)
 
  3990 				if(ret!=KErrNone)
 
  3985 					{
 
  3991 					{
 
  3986 					LOGPARSERR("Refresh Type",ret,1,&KRefresh2);
 
  3992 					OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMSAT_CONFIGL_44, "WARNING - CONFIGURATION FILE PARSING - Reading element REFRESH TYPE returned %d (element no. %d) from tag %s.",ret,1,KRefresh2);
 
  3987 					continue;
 
  3993 					continue;
 
  3988 					}
 
  3994 					}
 
  3989 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,2,applId);
 
  3995 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,2,applId);
 
  3990 				if(ret!=KErrNone)
 
  3996 				if(ret!=KErrNone)
 
  3991 					{
 
  3997 					{
 
  3992 					LOGPARSERR("Application Id",ret,2,&KRefresh2);
 
  3998 					OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMSAT_CONFIGL_45, "WARNING - CONFIGURATION FILE PARSING - Reading element APPLICATION ID returned %d (element no. %d) from tag %s.",ret,2,KRefresh2);
 
  3993 					continue;
 
  3999 					continue;
 
  3994 					}
 
  4000 					}
 
  3995 
  4001 
  3996 				TSatInfo satInfo;
 
  4002 				TSatInfo satInfo;
 
  3997 				satInfo.iDuration = duration;
 
  4003 				satInfo.iDuration = duration;
 
  4020 					}
 
  4026 					}
 
  4021 
  4027 
  4022 				ret= CTestConfig::GetElement(item->Value(),KStdDelimiter,0,textStatus);
 
  4028 				ret= CTestConfig::GetElement(item->Value(),KStdDelimiter,0,textStatus);
 
  4023 				if(ret!=KErrNone)
 
  4029 				if(ret!=KErrNone)
 
  4024 					{
 
  4030 					{
 
  4025 					LOGPARSERR("Text Attribute Status",ret,0,&KSendUssd);
 
  4031 					OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMSAT_CONFIGL_46, "WARNING - CONFIGURATION FILE PARSING - Reading element TEXT ATTRIBUTE STATUS returned %d (element no. %d) from tag %s.",ret,0,KSendUssd);
 
  4026 					continue;
 
  4032 					continue;
 
  4027 					}
 
  4033 					}
 
  4028 				tSendUssd.iTextAttStatus = textStatus;
 
  4034 				tSendUssd.iTextAttStatus = textStatus;
 
  4029 				
  4035 				
  4030 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,txtAttr);
 
  4036 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,txtAttr);
 
  4031 				if(ret!=KErrNone)
 
  4037 				if(ret!=KErrNone)
 
  4032 					{
 
  4038 					{
 
  4033 					LOGPARSERR("Text Attribute Buffer",ret,1,&KSendUssd);
 
  4039 					OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMSAT_CONFIGL_47, "WARNING - CONFIGURATION FILE PARSING - Reading element TEXT ATTRIBUTE BUFFER returned %d (element no. %d) from tag %s.",ret,1,KSendUssd);
 
  4034 					continue;
 
  4040 					continue;
 
  4035 					}
 
  4041 					}
 
  4036 				TInt location = txtAttr.Locate('\n');
 
  4042 				TInt location = txtAttr.Locate('\n');
 
  4037 				if(location > 0)
 
  4043 				if(location > 0)
 
  4038 					tSendUssd.iTextAttBuf.Set(txtAttr.Left(location));
 
  4044 					tSendUssd.iTextAttBuf.Set(txtAttr.Left(location));
 
  4056 					}
 
  4062 					}
 
  4057 							
  4063 							
  4058 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,frameId);
 
  4064 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,frameId);
 
  4059 				if(ret!=KErrNone)
 
  4065 				if(ret!=KErrNone)
 
  4060 					{
 
  4066 					{
 
  4061 					LOGPARSERR("FrameId",ret,0,&KLaunchBrowser);
 
  4067 					OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMSAT_CONFIGL_48, "WARNING - CONFIGURATION FILE PARSING - Reading element FRAMEID returned %d (element no. %d) from tag %s.",ret,0,KLaunchBrowser);
 
  4062 					continue;
 
  4068 					continue;
 
  4063 					}
 
  4069 					}
 
  4064 				tLnchBrwsr.iFrameId = frameId;
 
  4070 				tLnchBrwsr.iFrameId = frameId;
 
  4065 				
  4071 				
  4066 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,terRsp);
 
  4072 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,terRsp);
 
  4067 				if(ret!=KErrNone)
 
  4073 				if(ret!=KErrNone)
 
  4068 					{
 
  4074 					{
 
  4069 					LOGPARSERR("Terminal Response",ret,1,&KLaunchBrowser);
 
  4075 					OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMSAT_CONFIGL_49, "WARNING - CONFIGURATION FILE PARSING - Reading element TERMINAL RESPONSE returned %d (element no. %d) from tag %s.",ret,1,KLaunchBrowser);
 
  4070 					continue;
 
  4076 					continue;
 
  4071 					}
 
  4077 					}
 
  4072 				tLnchBrwsr.iTerRsp = terRsp;
 
  4078 				tLnchBrwsr.iTerRsp = terRsp;
 
  4073 				
  4079 				
  4074 				iLnchBrwsr->AppendL(tLnchBrwsr);
 
  4080 				iLnchBrwsr->AppendL(tLnchBrwsr);
 
  4089 					}
 
  4095 					}
 
  4090 
  4096 
  4091 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,src);
 
  4097 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,src);
 
  4092 				if(ret!=KErrNone)
 
  4098 				if(ret!=KErrNone)
 
  4093 					{
 
  4099 					{
 
  4094 					LOGPARSERR("Source",ret,0,&KUssdDataDownload);
 
  4100 					OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMSAT_CONFIGL_50, "WARNING - CONFIGURATION FILE PARSING - Reading element SOURCE returned %d (element no. %d) from tag %s.",ret,0,KUssdDataDownload);
 
  4095 					continue;
 
  4101 					continue;
 
  4096 					}
 
  4102 					}
 
  4097 				tUssdData.iSrc = src;
 
  4103 				tUssdData.iSrc = src;
 
  4098 				
  4104 				
  4099 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,destn);
 
  4105 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,destn);
 
  4100 				if(ret!=KErrNone)
 
  4106 				if(ret!=KErrNone)
 
  4101 					{
 
  4107 					{
 
  4102 					LOGPARSERR("Destination",ret,1,&KUssdDataDownload);
 
  4108 					OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMSAT_CONFIGL_51, "WARNING - CONFIGURATION FILE PARSING - Reading element DESTINATION returned %d (element no. %d) from tag %s.",ret,1,KUssdDataDownload);
 
  4103 					continue;
 
  4109 					continue;
 
  4104 					}
 
  4110 					}
 
  4105 				tUssdData.iDestn = destn;
 
  4111 				tUssdData.iDestn = destn;
 
  4106 
  4112 
  4107 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,2,dcs);
 
  4113 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,2,dcs);
 
  4108 				if(ret!=KErrNone)
 
  4114 				if(ret!=KErrNone)
 
  4109 					{
 
  4115 					{
 
  4110 					LOGPARSERR("Data Coding Scheme",ret,2,&KUssdDataDownload);
 
  4116 					OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMSAT_CONFIGL_52, "WARNING - CONFIGURATION FILE PARSING - Reading element DATA CODING SCHEME returned %d (element no. %d) from tag %s.",ret,2,KUssdDataDownload);
 
  4111 					continue;
 
  4117 					continue;
 
  4112 					}
 
  4118 					}
 
  4113 					tUssdData.iDcs = dcs;
 
  4119 					tUssdData.iDcs = dcs;
 
  4114 				
  4120 				
  4115 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,3,ussdStr);
 
  4121 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,3,ussdStr);
 
  4116 				if(ret!=KErrNone)
 
  4122 				if(ret!=KErrNone)
 
  4117 					{
 
  4123 					{
 
  4118 					LOGPARSERR("USSD String",ret,3,&KUssdDataDownload);
 
  4124 					OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMSAT_CONFIGL_53, "WARNING - CONFIGURATION FILE PARSING - Reading element USSD STRING returned %d (element no. %d) from tag %s.",ret,3,KUssdDataDownload);
 
  4119 					continue;
 
  4125 					continue;
 
  4120 					}
 
  4126 					}
 
  4121 				else
 
  4127 				else
 
  4122 					{
 
  4128 					{
 
  4123 					TUint16  value;
 
  4129 					TUint16  value;
 
  4127 						tUssdData.iUssdStr.SetLength(1);
 
  4133 						tUssdData.iUssdStr.SetLength(1);
 
  4128 						tUssdData.iUssdStr[0] = value;
 
  4134 						tUssdData.iUssdStr[0] = value;
 
  4129 						}
 
  4135 						}
 
  4130 					else
 
  4136 					else
 
  4131 						{
 
  4137 						{
 
  4132 						LOGPARSERR("UssdDataDownload::USSD String",KErrArgument,0,&KUssdDataDownload);
 
  4138 						OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMSAT_CONFIGL_54, "WARNING - CONFIGURATION FILE PARSING - Reading element USSDDATADOWNLOAD::USSD STRING returned %d (element no. %d) from tag %s.",KErrArgument,0,KUssdDataDownload);
 
  4133 						continue;
 
  4139 						continue;
 
  4134 						}
 
  4140 						}
 
  4135 					}
 
  4141 					}
 
  4136 				
  4142 				
  4137 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,4,UICCRsp);
 
  4143 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,4,UICCRsp);
 
  4138 				if(ret!=KErrNone)
 
  4144 				if(ret!=KErrNone)
 
  4139 					{
 
  4145 					{
 
  4140 					LOGPARSERR("UICC Response",ret,4,&KUssdDataDownload);
 
  4146 					OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMSAT_CONFIGL_55, "WARNING - CONFIGURATION FILE PARSING - Reading element UICC RESPONSE returned %d (element no. %d) from tag %s.",ret,4,KUssdDataDownload);
 
  4141 					continue;
 
  4147 					continue;
 
  4142 					}
 
  4148 					}
 
  4143 					tUssdData.iUICCRsp = UICCRsp;
 
  4149 					tUssdData.iUICCRsp = UICCRsp;
 
  4144 				
  4150 				
  4145 				iUssdData->AppendL(tUssdData);
 
  4151 				iUssdData->AppendL(tUssdData);
 
  4160 					}
 
  4166 					}
 
  4161 
  4167 
  4162 				ret= CTestConfig::GetElement(item->Value(),KStdDelimiter,0,infoType);
 
  4168 				ret= CTestConfig::GetElement(item->Value(),KStdDelimiter,0,infoType);
 
  4163 				if(ret!=KErrNone)
 
  4169 				if(ret!=KErrNone)
 
  4164 					{
 
  4170 					{
 
  4165 					LOGPARSERR("Information Type",ret,0,&KEventDnld);
 
  4171 					OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMSAT_CONFIGL_56, "WARNING - CONFIGURATION FILE PARSING - Reading element INFORMATION TYPE returned %d (element no. %d) from tag %s.",ret,0,KEventDnld);
 
  4166 					continue;
 
  4172 					continue;
 
  4167 					}
 
  4173 					}
 
  4168 				tEventDnld.iVar = infoType;
 
  4174 				tEventDnld.iVar = infoType;
 
  4169 				
  4175 				
  4170 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,framesList);
 
  4176 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,framesList);
 
  4171 				if(ret!=KErrNone)
 
  4177 				if(ret!=KErrNone)
 
  4172 					{
 
  4178 					{
 
  4173 					LOGPARSERR("Frames List",ret,1,&KEventDnld);
 
  4179 					OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMSAT_CONFIGL_57, "WARNING - CONFIGURATION FILE PARSING - Reading element FRAMES LIST returned %d (element no. %d) from tag %s.",ret,1,KEventDnld);
 
  4174 					continue;
 
  4180 					continue;
 
  4175 					}
 
  4181 					}
 
  4176 				TInt location = framesList.Locate('\n');
 
  4182 				TInt location = framesList.Locate('\n');
 
  4177 				if(location > 0)
 
  4183 				if(location > 0)
 
  4178 					tEventDnld.iFrameList.Set(framesList.Left(location));
 
  4184 					tEventDnld.iFrameList.Set(framesList.Left(location));
 
  4197 					}
 
  4203 					}
 
  4198 					
  4204 					
  4199 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,textStatus);
 
  4205 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,textStatus);
 
  4200 				if(ret!=KErrNone)
 
  4206 				if(ret!=KErrNone)
 
  4201 					{
 
  4207 					{
 
  4202 					LOGPARSERR("Text Attr Status",ret,0,&KSendSs);
 
  4208 					OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMSAT_CONFIGL_58, "WARNING - CONFIGURATION FILE PARSING - Reading element TEXT ATTR STATUS returned %d (element no. %d) from tag %s.",ret,0,KSendSs);
 
  4203 					continue;
 
  4209 					continue;
 
  4204 					}
 
  4210 					}
 
  4205 					
  4211 					
  4206 				tSendSS.iTextAttStatus = textStatus;
 
  4212 				tSendSS.iTextAttStatus = textStatus;
 
  4207 				
  4213 				
  4208 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,txtAttr);
 
  4214 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,txtAttr);
 
  4209 				if(ret!=KErrNone)
 
  4215 				if(ret!=KErrNone)
 
  4210 					{
 
  4216 					{
 
  4211 					LOGPARSERR("Text Attribute",ret,1,&KSendSs);
 
  4217 					OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMSAT_CONFIGL_59, "WARNING - CONFIGURATION FILE PARSING - Reading element TEXT ATTRIBUTE returned %d (element no. %d) from tag %s.",ret,1,KSendSs);
 
  4212 					continue;
 
  4218 					continue;
 
  4213 					}
 
  4219 					}
 
  4214 				
  4220 				
  4215 				TInt location = txtAttr.Locate('\n');
 
  4221 				TInt location = txtAttr.Locate('\n');
 
  4216 							
  4222 							
  4237 					}
 
  4243 					}
 
  4238 			
  4244 			
  4239 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,duration);
 
  4245 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,duration);
 
  4240 				if(ret!=KErrNone)
 
  4246 				if(ret!=KErrNone)
 
  4241 					{
 
  4247 					{
 
  4242 					LOGPARSERR("duration",ret,0,&KElemFiles);
 
  4248 					OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMSAT_CONFIGL_60, "WARNING - CONFIGURATION FILE PARSING - Reading element DURATION returned %d (element no. %d) from tag %s.",ret,0,KElemFiles);
 
  4243 					continue;
 
  4249 					continue;
 
  4244 					}
 
  4250 					}
 
  4245 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,type);
 
  4251 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,type);
 
  4246 				if(ret!=KErrNone)
 
  4252 				if(ret!=KErrNone)
 
  4247 					{
 
  4253 					{
 
  4248 					LOGPARSERR("Refresh Type",ret,1,&KElemFiles);
 
  4254 					OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMSAT_CONFIGL_61, "WARNING - CONFIGURATION FILE PARSING - Reading element REFRESH TYPE returned %d (element no. %d) from tag %s.",ret,1,KElemFiles);
 
  4249 					continue;
 
  4255 					continue;
 
  4250 					}
 
  4256 					}
 
  4251 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,2,FileList);
 
  4257 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,2,FileList);
 
  4252 				if(ret!=KErrNone)
 
  4258 				if(ret!=KErrNone)
 
  4253 					{
 
  4259 					{
 
  4254 					LOGPARSERR("Application Id",ret,2,&KElemFiles);
 
  4260 					OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMSAT_CONFIGL_62, "WARNING - CONFIGURATION FILE PARSING - Reading element APPLICATION ID returned %d (element no. %d) from tag %s.",ret,2,KElemFiles);
 
  4255 					continue;
 
  4261 					continue;
 
  4256 					}
 
  4262 					}
 
  4257 
  4263 
  4258 				TSatInfo satInfo;
 
  4264 				TSatInfo satInfo;
 
  4259 				satInfo.iDuration = duration;
 
  4265 				satInfo.iDuration = duration;
 
  4282 					}
 
  4288 					}
 
  4283 					
  4289 					
  4284 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,src);
 
  4290 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,src);
 
  4285 				if(ret!=KErrNone)
 
  4291 				if(ret!=KErrNone)
 
  4286 					{
 
  4292 					{
 
  4287 					LOGPARSERR("Source",ret,0,&KMmsNotificationDownload);
 
  4293 					OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMSAT_CONFIGL_63, "WARNING - CONFIGURATION FILE PARSING - Reading element SOURCE returned %d (element no. %d) from tag %s.",ret,0,KMmsNotificationDownload);
 
  4288 					continue;
 
  4294 					continue;
 
  4289 					}
 
  4295 					}
 
  4290 				tMmsNotificationDownload.iSrc = src;
 
  4296 				tMmsNotificationDownload.iSrc = src;
 
  4291 				
  4297 				
  4292 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,destn);
 
  4298 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,destn);
 
  4293 				if(ret!=KErrNone)
 
  4299 				if(ret!=KErrNone)
 
  4294 					{
 
  4300 					{
 
  4295 					LOGPARSERR("Destination",ret,1,&KMmsNotificationDownload);
 
  4301 					OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMSAT_CONFIGL_64, "WARNING - CONFIGURATION FILE PARSING - Reading element DESTINATION returned %d (element no. %d) from tag %s.",ret,1,KMmsNotificationDownload);
 
  4296 					continue;
 
  4302 					continue;
 
  4297 					}
 
  4303 					}
 
  4298 				tMmsNotificationDownload.iDestn = destn;
 
  4304 				tMmsNotificationDownload.iDestn = destn;
 
  4299 				
  4305 				
  4300 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,2,mmsNotfn);
 
  4306 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,2,mmsNotfn);
 
  4301 				if(ret!=KErrNone)
 
  4307 				if(ret!=KErrNone)
 
  4302 					{
 
  4308 					{
 
  4303 					LOGPARSERR("MMS notification",ret,2,&KMmsNotificationDownload);
 
  4309 					OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMSAT_CONFIGL_65, "WARNING - CONFIGURATION FILE PARSING - Reading element MMS NOTIFICATION returned %d (element no. %d) from tag %s.",ret,2,KMmsNotificationDownload);
 
  4304 					continue;
 
  4310 					continue;
 
  4305 					}
 
  4311 					}
 
  4306 				location = mmsNotfn.Locate('\n');
 
  4312 				location = mmsNotfn.Locate('\n');
 
  4307 				
  4313 				
  4308 				if(location > 0)
 
  4314 				if(location > 0)
 
  4311 					tMmsNotificationDownload.iMMSNotfn.Copy(mmsNotfn);
 
  4317 					tMmsNotificationDownload.iMMSNotfn.Copy(mmsNotfn);
 
  4312 				
  4318 				
  4313 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,3,lastEnv);
 
  4319 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,3,lastEnv);
 
  4314 				if(ret!=KErrNone)
 
  4320 				if(ret!=KErrNone)
 
  4315 					{
 
  4321 					{
 
  4316 					LOGPARSERR("Last envelope",ret,3,&KMmsNotificationDownload);
 
  4322 					OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMSAT_CONFIGL_66, "WARNING - CONFIGURATION FILE PARSING - Reading element LAST ENVELOPE returned %d (element no. %d) from tag %s.",ret,3,KMmsNotificationDownload);
 
  4317 					continue;
 
  4323 					continue;
 
  4318 					}
 
  4324 					}
 
  4319 				tMmsNotificationDownload.iLastEnv = lastEnv;
 
  4325 				tMmsNotificationDownload.iLastEnv = lastEnv;
 
  4320 				
  4326 				
  4321 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,4,UICCRsp);
 
  4327 				ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,4,UICCRsp);
 
  4322 				if(ret!=KErrNone)
 
  4328 				if(ret!=KErrNone)
 
  4323 					{
 
  4329 					{
 
  4324 					LOGPARSERR("UICC Response",ret,4,&KMmsNotificationDownload);
 
  4330 					OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMSAT_CONFIGL_67, "WARNING - CONFIGURATION FILE PARSING - Reading element UICC RESPONSE returned %d (element no. %d) from tag %s.",ret,4,KMmsNotificationDownload);
 
  4325 					continue;
 
  4331 					continue;
 
  4326 					}
 
  4332 					}
 
  4327 				tMmsNotificationDownload.iUICCRsp = UICCRsp;
 
  4333 				tMmsNotificationDownload.iUICCRsp = UICCRsp;
 
  4328 				
  4334 				
  4329 				iMmsDownloadData->AppendL(tMmsNotificationDownload);	
  4335 				iMmsDownloadData->AppendL(tMmsNotificationDownload);	
  4330 				}
 
  4336 				}
 
  4331 			break;
 
  4337 			break;
 
  4332 		default:
 
  4338 		default:
 
  4333 			LOGMISC1("Unknown command to process");
 
  4339 			OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMSAT_CONFIGL_68, "Unknown command to process");
 
  4334 			return KErrNotSupported;
 
  4340 			return KErrNotSupported;
 
  4335 
  4341 
  4336 		}
 
  4342 		}
 
  4337 		return KErrNone;
 
  4343 		return KErrNone;
 
  4338 
  4344
FCL/sf/os/cellularsrv