1 /*

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

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

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

     6 * which accompanies this distribution, and is available

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

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:  AgentLog db-interface

    15 *

    16 */

    17 

    18 

    19 

    20 // INCLUDE FILES

    21 #include <sysutil.h>

    22 #include <bautils.h>

    23 #include <utf.h>

    24 #include <nsmlconstants.h>

    25 #include <nsmldebug.h>

    26 

    27 #include "nsmldbcaps.h"

    28 #include "nsmldsdefines.h"

    29 #include "nsmlagentlog.h"

    30 #include "smldevinfdtd.h"

    31 

    32 

    33 // CONSTANTS

    34 

    35 // Size of empty AgentLog database in bytes.

    36 const TInt KNSmlAgentLogEmptyDatabaseSize = 580;

    37 // Estimated maximum size of AgentLog table row without the unrestricted

    38 // ServerDeviceInfo and ServerFilterInfo fields.

    39 const TInt KNSmlAgentLogMaxFixedLogRowSize = 860;

    40 // Maximum size of Authentication table row without unrestricted Nonce field.

    41 const TInt KNSmlAgentLogMaxFixedAuthRowSize = 320;

    42 // Additional treshold used with OOD checks.

    43 const TInt KNSmlAgentLogTreshold = 50;

    44 

    45 _LIT8( KTabSeparator, " ");

    46 

    47 //=============================================

    48 //

    49 //		CNSmlDSAgentLog

    50 //

    51 //=============================================

    52 

    53 //=============================================

    54 //		CNSmlDSAgentLog::NewL()

    55 //		Creates a new instance of CNSmlDSAgentLog object.

    56 //=============================================

    57 

    58 EXPORT_C CNSmlDSAgentLog* CNSmlDSAgentLog::NewL()

    59 	{

    60 	DBG_FILE(_S8("CNSmlDSAgentLog::NewL"));

    61 	CNSmlDSAgentLog* self = CNSmlDSAgentLog::NewLC();	

    62 	CleanupStack::Pop();

    63 	return self;

    64 	}	

    65 

    66 //=============================================

    67 //		CNSmlDSAgentLog::NewLC()

    68 //		Creates a new instance of CNSmlDSAgentLog object. 

    69 //		Pushes and leaves new instance into CleanupStack.

    70 //=============================================

    71 EXPORT_C CNSmlDSAgentLog* CNSmlDSAgentLog::NewLC()

    72 	{

    73 	DBG_FILE(_S8("CNSmlDSAgentLog::NewLC"));

    74 	CNSmlDSAgentLog* self = new ( ELeave ) CNSmlDSAgentLog;

    75 	CleanupStack::PushL( self );

    76 	self->ConstructL();	

    77 	return self;

    78 	}

    79 

    80 //=============================================

    81 //		CNSmlDSAgentLog::ConstructL()

    82 //		Second phase constructor.

    83 //=============================================

    84 

    85 void CNSmlDSAgentLog::ConstructL()

    86 	{

    87 	DBG_FILE(_S8("CNSmlDSAgentLog::ConstructL(): begin"));

    88 	iLocalDB = HBufC::NewL( KNSmlMaxStringColumnLength );

    89 	iServerId = HBufC::NewL( KNSmlMaxServerIdLength );

    90 	iRemoteDB = HBufC::NewL( KNSmlMaxStringColumnLength );

    91 

    92 	User::LeaveIfError( iFsSession.Connect() );	

    93 	User::LeaveIfError( iRdbSession.Connect() );

    94     iFsSession.SetSessionToPrivate( KNSmlAgentLogDbDrive );

    95 

    96     TParse name;

    97     

    98     TBool createdDatabase = EFalse;

    99 

   100 #ifdef SYMBIAN_SECURE_DBMS

   101 	name.Set( KNSmlAgentLogDbName(), NULL, NULL );

   102 #else

   103     name.Set( KNSmlAgentLogDbName(), KNSmlDatabasesNonSecurePath, NULL );

   104 #endif

   105 	// PP: data compatibility fix: If incompatible database is 

   106     // found, it will be deleted & recreated.

   107     TInt retry0(5);

   108     while ( retry0>0 )

   109         {

   110         retry0 = retry0 - 1;

   111 	    TInt err = iDatabase.Open( iRdbSession /*iFsSession*/,

   112 	                               name.FullName(),

   113 	                               KNSmlDBMSSecureSOSServerID );

   114 	    if (err == KErrNone)

   115 	    	{

   116 	    	User::LeaveIfError( iTableAgentLog.Open( iDatabase, KNSmlTableAgentLog ) );

   117 	    	iColSet = iTableAgentLog.ColSetL();

   118 	    

   119 	    	//RD_SUSPEND_RESUME	

   120 	    	if (iColSet->ColNo( KNSmlAgentLogSuspendedState ) == KDbNullColNo

   121 	    			|| iColSet->ColNo( KNSmlAgentLogPreviousSyncType ) == KDbNullColNo 

   122 	    			|| iColSet->ColNo( KNSmlAgentLogPreviousClientSyncType ) == KDbNullColNo)

   123        			{

   124 	    		iTableAgentLog.Close();

   125 	    		iDatabase.Close();

   126 	    		TInt error = iRdbSession.DeleteDatabase( name.FullName(), KNSmlSOSServerPolicyUID );

   127        			if (error == KErrNone)

   128 	       			{

   129 	       			err = KErrNotFound;	

   130 	       			}

   131        			

   132        			}

   133 	    	}

   134 	    	

   135 	    if ( err == KErrNotFound )

   136 		    {

   137 		    CreateDatabaseL( name.FullName() );

   138 		    User::LeaveIfError( iDatabase.Open( iRdbSession,

   139 		                                        name.FullName(),

   140 		                                        KNSmlDBMSSecureSOSServerID ) );

   141 		    createdDatabase = ETrue;

   142 		    }

   143 	    else

   144 		    {

   145 		    User::LeaveIfError( err );

   146 		    }

   147 		    

   148 		if (createdDatabase) 

   149 			{

   150 			User::LeaveIfError( iTableAgentLog.Open( iDatabase, KNSmlTableAgentLog ) );

   151 		    iColSet = iTableAgentLog.ColSetL();

   152 			}

   153 	      	    

   154 	    User::LeaveIfError( iTableAuthentication.Open( iDatabase, KNSmlTableAuthentication ) );

   155 	    iColSetTableAuth = iTableAuthentication.ColSetL();

   156         TInt err2 = iTableDatastore.Open( iDatabase, KNSmlTableDatastore() );

   157         // Table datastore missing => must delete db

   158         if ( err2==KErrNotFound )

   159             {

   160 	        delete iColSetTableDS;

   161 	        iColSetTableDS = NULL;

   162 	        delete iColSetTableAuth;

   163 	        iColSetTableAuth = NULL;

   164             iTableAgentLog.Close();

   165             iTableAuthentication.Close();

   166             User::LeaveIfError(iDatabase.Destroy());

   167             }

   168         else

   169             {

   170             retry0=0;

   171 	        User::LeaveIfError( err2 );

   172             }

   173         }

   174 	iColSetTableDS = iTableDatastore.ColSetL();

   175 	        

   176 	DBG_FILE(_S8("CNSmlDSAgentLog::ConstructL(): end"));

   177 	}

   178 

   179 //=============================================

   180 //		CNSmlDSAgentLog::~CNSmlDSAgentLog()

   181 //		Destructor.

   182 //=============================================

   183 

   184 CNSmlDSAgentLog::~CNSmlDSAgentLog()

   185 	{

   186 	DBG_FILE(_S8("CNSmlDSAgentLog::~CNSmlDSAgentLog begins"));

   187 

   188 	delete iLocalDB;

   189 	delete iServerId;

   190 	delete iRemoteDB;

   191 

   192 	iView.Close();

   193 	delete iColSet;

   194 	iTableAgentLog.Close();

   195 	

   196 // <MAPINFO_RESEND_MOD_BEGIN>

   197 	delete iColSetTableDS;

   198 	iTableDatastore.Close();

   199 // <MAPINFO_RESEND_MOD_END>

   200 		

   201 	delete iColSetTableAuth;

   202 	iTableAuthentication.Close();

   203 

   204 	iDatabase.Close();

   205 	iFsSession.Close();

   206 	iRdbSession.Close();

   207 	

   208 	DBG_FILE(_S8("CNSmlDSAgentLog::~CNSmlDSAgentLog ends"));

   209 	}

   210 

   211 //=============================================

   212 //		CNSmlDSAgentLog::CreateDatabaseL()

   213 //		Creates Agent Log database.

   214 //=============================================

   215 

   216 void CNSmlDSAgentLog::CreateDatabaseL(const TDesC& aFullName)

   217 	{

   218 	DBG_FILE(_S8("CNSmlDSAgentLog::CreateDatabaseL begins"));

   219 

   220     // Check OOD before crating new AgentLog database

   221     if ( SysUtil::FFSSpaceBelowCriticalLevelL( &iFsSession,

   222             KNSmlAgentLogEmptyDatabaseSize + KNSmlAgentLogTreshold ) )

   223 	    {

   224         User::Leave( KErrDiskFull );

   225 		}

   226 

   227 	_LIT( KCreateAgentLogTable, "CREATE TABLE AgentLog ( Id INTEGER NOT NULL, \

   228 ImplementationUID INTEGER NOT NULL,  LocalDatabase CHAR(%d) NOT NULL, \

   229 ServerId CHAR(%d), RemoteDatabase CHAR(%d) NOT NULL, \

   230 LastSyncronised TIMESTAMP, SyncAnchor TIMESTAMP, SlowSyncRequest INTEGER, \

   231 ServerDeviceInfo LONG VARCHAR, ServerSupportsNOC BIT, ServerSyncTypes INTEGER, \

   232 ServerFilterInfo LONG VARCHAR, ServerSupportsHierarchicalSync BIT ,\

   233 SyncSuspendedState INTEGER,PreviousSyncType INTEGER,\

   234 PreviousClientSyncType INTEGER)" );

   235 

   236 //RD_SUSPEND_RESUME- 3 new columns added

   237 	_LIT( KCreateAuthenticationTable, "CREATE TABLE Authentication ( ServerId \

   238 CHAR(%d), Nonce LONG VARCHAR, Type INTEGER, SessionId INTEGER )" );

   239 

   240 // <MAPINFO_RESEND_MOD_BEGIN>

   241 	_LIT( KCreateDatastoreTable, "CREATE TABLE %S ( %S COUNTER NOT NULL, \

   242 	%S INTEGER NOT NULL, %S INTEGER NOT NULL, %S LONG VARBINARY )" );

   243 // <MAPINFO_RESEND_MOD_END>

   244 

   245 	_LIT( KCreateVersionTable, "CREATE TABLE Version ( \

   246 VerMajor UNSIGNED TINYINT, VerMinor UNSIGNED TINYINT )" );

   247 

   248 	HBufC* createAgentLogTable = HBufC::NewLC( KCreateAgentLogTable().Length() + 20 );

   249 	TPtr agentLogTablePtr = createAgentLogTable->Des();

   250 	HBufC* createAuthenticationTable = HBufC::NewLC( KCreateAuthenticationTable().Length() + 10);

   251 	TPtr authenticationTablePtr = createAuthenticationTable->Des();

   252 

   253 // <MAPINFO_RESEND_MOD_BEGIN>

   254 	HBufC* createDatastoreTable = HBufC::NewLC( KCreateDatastoreTable().Length() * 3);

   255 	TPtr datastoreTablePtr = createDatastoreTable->Des();

   256 // <MAPINFO_RESEND_MOD_END>

   257 

   258 	agentLogTablePtr.Format( KCreateAgentLogTable, KNSmlMaxDataLength,

   259 	    KNSmlMaxServerIdLength, KNSmlMaxRemoteNameLength );

   260 	authenticationTablePtr.Format( KCreateAuthenticationTable, KNSmlMaxServerIdLength );

   261 

   262 // <MAPINFO_RESEND_MOD_BEGIN>

   263 	datastoreTablePtr.Format(KCreateDatastoreTable(), &KNSmlTableDatastore(), &KNSmlDatastoreRowID(), &KNSmlDatastoreAgentlogID(), &KNSmlDatastoreStreamID(), &KNSmlDatastoreStreamData());

   264 // <MAPINFO_RESEND_MOD_END>

   265 

   266 	User::LeaveIfError( iDatabase.Create( iRdbSession,

   267 	                                      aFullName,

   268 	                                      KNSmlDBMSSecureSOSServerID ) );

   269 	iDatabase.Begin();

   270 	iDatabase.Execute( *createAgentLogTable );

   271 	iDatabase.Execute( *createAuthenticationTable );

   272 // <MAPINFO_RESEND_MOD_BEGIN>

   273 	iDatabase.Execute( *createDatastoreTable );

   274 // <MAPINFO_RESEND_MOD_END>

   275 	iDatabase.Execute( KCreateVersionTable() );

   276 

   277 	RDbTable table;

   278 	User::LeaveIfError( table.Open( iDatabase, KNSmlTableVersion() ) );

   279 	CleanupClosePushL( table );

   280 	CDbColSet* colSet = table.ColSetL();

   281 	CleanupStack::PushL( colSet );

   282 	table.InsertL();

   283 	table.SetColL( colSet->ColNo( KNSmlVersionColumnMajor ), KNSmlAgentLogCurrentVersionMajor );

   284 	table.SetColL( colSet->ColNo( KNSmlVersionColumnMinor ), KNSmlAgentLogCurrentVersionMinor );

   285 	table.PutL();

   286 	

   287 	CommitAndCompact();

   288 	iDatabase.Close();

   289 	

   290 	DBG_FILE(_S8("CNSmlDSAgentLog::CreateDatabaseL ends"));

   291 // <MAPINFO_RESEND_MOD_BEGIN>

   292 	CleanupStack::PopAndDestroy( 5 ); // createAgentLogTable, createAuthenticationTable, colset, table

   293 	//CleanupStack::PopAndDestroy( 4 ); // createAgentLogTable, createAuthenticationTable, colset, table

   294 // <MAPINFO_RESEND_MOD_END>

   295 	}	

   296 

   297 //=============================================

   298 //		CNSmlDSAgentLog::SetAgentLogKeyL()

   299 //		Sets AgentLog key with given string values.

   300 //=============================================

   301 

   302 EXPORT_C void CNSmlDSAgentLog::SetAgentLogKeyL( const TInt aImplUid, const TDesC& aLocalDB, const TDesC& aServerId, const TDesC& aRemoteDB )

   303 	{

   304 	DBG_FILE(_S8("CNSmlDSAgentLog::SetAgentLogKeyL begins"));

   305 	HBufC* sql = HBufC::NewLC( KSQLGetAgentLogRow().Length() + 5 + aLocalDB.Length() + aServerId.Length() );

   306     

   307 	TPtr sqlPtr = sql->Des();

   308 	sqlPtr.Format( KSQLGetAgentLogRow, aImplUid, &aLocalDB, &aServerId );

   309 	

   310 	PrepareViewL( *sql, iView.EReadOnly );

   311 	

   312 	if ( iView.FirstL() )

   313 		{

   314 			for(TInt i = 0; i < iView.CountL() ; i++ )

   315 			{

   316 		iView.GetL();

   317 				if( aRemoteDB.CompareF( iView.ColDes16( iColSet->ColNo( KNSmlAgentLogRemoteDatabase  ) ) ) == 0 )

   318 				{

   319 		iID = iView.ColInt( iColSet->ColNo( KNSmlAgentLogId ) );

   320 					i = iView.CountL() ; // terminates the loop

   321 				}

   322 				else

   323 				{

   324 					iView.NextL();	

   325 				}

   326 				

   327 			}

   328 		}

   329 	else

   330 		{

   331 		iID = KNSmlNewObject;

   332 		}

   333 	

   334 	CleanupStack::PopAndDestroy( 1 ); // sql

   335 

   336 	iImplUid = aImplUid;

   337 	*iLocalDB = aLocalDB;

   338 	*iServerId = aServerId;

   339 	*iRemoteDB = aRemoteDB;

   340 

   341 	DBG_FILE(_S8("CNSmlDSAgentLog::SetAgentLogKeyL ends"));

   342 	}

   343 

   344 

   345 //=============================================

   346 //		CNSmlDSAgentLog::SetIntValueL()

   347 //		Sets given integer value.

   348 //=============================================

   349 

   350 EXPORT_C void CNSmlDSAgentLog::SetIntValueL( TNSmlAgentLogData aType, const TInt aNewValue )

   351 	{

   352 	DBG_FILE(_S8("CNSmlDSAgentLog::SetIntValueL begins"));

   353 	// BPSS-7NZESW : return if remote database value is empty

   354 	if ( iLocalDB == NULL || iServerId == NULL ||iRemoteDB == NULL || iRemoteDB->Length() < 1  )

   355 		{

   356 		return;

   357 		}

   358 

   359 	TBuf<32> columnName;

   360 	TInt setValue( aNewValue );

   361 

   362 	switch ( aType )

   363 		{

   364 		case ( EAgentLogSlowSyncRequest ) :

   365 			columnName = KNSmlAgentLogSlowSyncRequest;

   366 			break;

   367 

   368 		case ( EAgentLogServerSupportsNOC ) :

   369 			columnName = KNSmlAgentLogServerSupportsNOC;

   370 			// Make sure that value is 1 or 0

   371 			if ( setValue )

   372 				{

   373 				setValue = 1;

   374 				}

   375 			else

   376 				{

   377 				setValue = 0;

   378 				}

   379 			break;

   380 

   381 		case ( EAgentLogServerSupportsHierarchicalSync ) :

   382 			columnName = KNSmlAgentLogServerSupportsHierarchicalSync ;

   383 			// Make sure that value is 1 or 0

   384 			if ( setValue )

   385 				{

   386 				setValue = 1;

   387 				}

   388 			else

   389 				{

   390 				setValue = 0;

   391 				}

   392 			break;

   393 

   394 		case ( EAgentLogServerSyncTypes ) :

   395 			columnName = KNSmlAgentLogServerSyncTypes;

   396 			break;

   397 		//RD_SUSPEND_RESUME

   398 		case (EAgentLogSyncSuspendedState) :

   399 			columnName = KNSmlAgentLogSuspendedState;

   400 			break;

   401 			

   402 		case (EAgentLogPreviousSyncType) :

   403 		     columnName=KNSmlAgentLogPreviousSyncType;

   404 		     break;

   405 		case (EAgentLogPreviousClientSyncType):

   406 		     columnName=KNSmlAgentLogPreviousClientSyncType;

   407 		     break;

   408 		

   409 		default:

   410 			User::Panic( KNSmlIndexOutOfBoundStr, KNSmlPanicIndexOutOfBound );

   411 		}

   412 

   413 	HBufC* sql = AgentLogRowSqlLC();

   414 	PrepareViewL( *sql, iView.EUpdatable );

   415 	

   416 	iDatabase.Begin();

   417 	if ( iView.FirstL() )

   418 		{

   419 		//existing row

   420 		iView.GetL();

   421 		iView.UpdateL();

   422 		iView.SetColL( iColSet->ColNo( columnName ), setValue );

   423 		iView.PutL();

   424 		}

   425 	else

   426 		{

   427 		//new row

   428 		InitNewRowL();

   429 		iTableAgentLog.SetColL( iColSet->ColNo( columnName ), setValue );

   430 		iTableAgentLog.PutL();		

   431 		}	

   432 	CommitAndCompact();

   433 	

   434 	CleanupStack::PopAndDestroy( 1 ); // sql

   435 	DBG_FILE(_S8("CNSmlDSAgentLog::SetIntValueL ends"));

   436 	}

   437 

   438 //=============================================

   439 //		CNSmlDSAgentLog::IntValueL()

   440 //		Gets given integer value.

   441 //=============================================

   442 

   443 EXPORT_C TInt CNSmlDSAgentLog::IntValueL( TNSmlAgentLogData aType )

   444 	{

   445 	DBG_FILE(_S8("CNSmlDSAgentLog::IntValueL begins"));

   446 	HBufC* sql = AgentLogRowSqlLC();

   447 

   448 	TBuf<30>columnName;

   449 

   450 	switch ( aType )

   451 		{

   452 		case ( EAgentLogSlowSyncRequest ) :

   453 			columnName = KNSmlAgentLogSlowSyncRequest;

   454 			break;

   455 

   456 		case ( EAgentLogServerSupportsNOC ) :

   457 			columnName = KNSmlAgentLogServerSupportsNOC;

   458 			break;

   459 		

   460 		case ( EAgentLogServerSyncTypes ) :

   461 			columnName = KNSmlAgentLogServerSyncTypes;

   462 			break;

   463 			

   464 		case EAgentLogServerSupportsHierarchicalSync:

   465 			columnName = KNSmlAgentLogServerSupportsHierarchicalSync;

   466 			break;

   467 		//RD_SUSPEND_RESUME

   468 		case (EAgentLogSyncSuspendedState) :

   469 			columnName = KNSmlAgentLogSuspendedState;

   470 			break;

   471 		case (EAgentLogPreviousSyncType) :

   472 		     columnName=KNSmlAgentLogPreviousSyncType;

   473              break;

   474 		case(EAgentLogPreviousClientSyncType):

   475 		    columnName=KNSmlAgentLogPreviousClientSyncType;

   476 		    break;

   477 		 //RD_SUSPEND_RESUME

   478 		default:

   479 			{

   480 			User::Panic( KNSmlIndexOutOfBoundStr, KNSmlPanicIndexOutOfBound );

   481 			}

   482 		}

   483 	

   484 	PrepareViewL( *sql, iView.EReadOnly );

   485 

   486 	TInt status( 0 );

   487 

   488 	if ( iView.FirstL() )

   489 		{

   490 		iView.GetL();

   491 		status = iView.ColInt( iColSet->ColNo( columnName ) );

   492 		}

   493 

   494 	CleanupStack::PopAndDestroy( 1 ); // sql 

   495 	DBG_FILE(_S8("CNSmlDSAgentLog::IntValueL ends"));

   496 	return status;

   497 	}

   498 

   499 //=============================================

   500 //		CNSmlDSAgentLog::SetTimeValueL()

   501 //		Sets given datetime value.

   502 //=============================================

   503 

   504 EXPORT_C void CNSmlDSAgentLog::SetTimeValueL( TNSmlAgentLogData aType, const TTime& aNewValue )

   505 	{

   506 	DBG_FILE(_S8("CNSmlDSAgentLog::SetTimeValueL begins"));

   507 	if ( iLocalDB == NULL || iServerId == NULL || iRemoteDB == NULL )

   508 		{

   509 		return;

   510 		}

   511 	

   512 	HBufC* sql = AgentLogRowSqlLC();

   513 

   514 	TBuf<20> columnName;

   515 

   516 	switch ( aType )

   517 		{

   518 		case ( EAgentLogLastSyncronised ) :

   519 			{

   520 			columnName.Format( KColumn, &KNSmlAgentLogLastSyncronised );

   521 			}

   522 		break;

   523 

   524 		case ( EAgentLogLastSyncAnchor ) :

   525 			{

   526 			columnName.Format( KColumn, &KNSmlAgentLogLastSyncAnchor );

   527 			}

   528 		break;

   529 		

   530 		default:

   531 			{

   532 			User::Panic( KNSmlIndexOutOfBoundStr, KNSmlPanicIndexOutOfBound );

   533 			}

   534 		}

   535 	

   536 	PrepareViewL( *sql, iView.EUpdatable );

   537 		

   538 	iDatabase.Begin();

   539 	if ( iView.FirstL() )

   540 		{

   541 		//existing row

   542 		iView.GetL();

   543 		iView.UpdateL();

   544 		iView.SetColL( iColSet->ColNo( columnName ), aNewValue );  //check

   545 		iView.PutL();

   546 		}

   547 	else

   548 		{

   549 		//new row

   550 		InitNewRowL();

   551 		iTableAgentLog.SetColL( iColSet->ColNo( columnName ), aNewValue );

   552 		iTableAgentLog.PutL();	

   553 		}

   554 	

   555 	CommitAndCompact();

   556 	CleanupStack::PopAndDestroy( 1 ); // sql, 

   557 	DBG_FILE(_S8("CNSmlDSAgentLog::SetTimeValueL ends"));

   558 	}

   559 

   560 //=============================================

   561 //		CNSmlDSAgentLog::TimeValueL()

   562 //		Gets given datetime value.

   563 //		If the returned value is TTime(0),

   564 //		given value was not found.

   565 //=============================================

   566 

   567 EXPORT_C TTime CNSmlDSAgentLog::TimeValueL( TNSmlAgentLogData aType )

   568 	{

   569 	DBG_FILE(_S8("CNSmlDSAgentLog::TimeValueL begins"));

   570 	HBufC* sql = AgentLogRowSqlLC();

   571 	TBuf<20> columnName;

   572 

   573 	switch ( aType )

   574 		{

   575 		case ( EAgentLogLastSyncronised ) :

   576 			{

   577 			columnName.Format( KColumn, &KNSmlAgentLogLastSyncronised );

   578 			}

   579 		break;

   580 

   581 		case ( EAgentLogLastSyncAnchor ) :

   582 			{

   583 			columnName.Format( KColumn, &KNSmlAgentLogLastSyncAnchor );

   584 			}

   585 		break;

   586 		

   587 		default:

   588 			{

   589 			User::Panic( KNSmlIndexOutOfBoundStr, KNSmlPanicIndexOutOfBound );

   590 			}

   591 		}

   592 	

   593 	PrepareViewL( *sql, iView.EReadOnly );

   594 	

   595 	TTime dateTimeValue( 0 );

   596 

   597 	if ( iView.FirstL() )

   598 		{

   599 		iView.GetL();

   600 		dateTimeValue = iView.ColTime( iColSet->ColNo( columnName ) );

   601 		}

   602 	

   603 	CleanupStack::PopAndDestroy( 1 ); // sql

   604 	DBG_FILE(_S8("CNSmlDSAgentLog::TimeValueL ends"));

   605 	return dateTimeValue;

   606 	}

   607 

   608 //=============================================

   609 //		CNSmlDSAgentLog::SetNonceL()

   610 //		Sets nonce.

   611 //=============================================

   612 

   613 EXPORT_C void CNSmlDSAgentLog::SetNonceL( const TDesC& aServerId, const TDesC& aNewValue )

   614 	{	

   615 	DBG_FILE(_S8("CNSmlDSAgentLog::SetNonceL begins"));

   616 	HBufC* sql = AuthenticationSqlLC( aServerId );

   617 	

   618 	PrepareViewL( *sql, iView.EUpdatable );

   619 	iDatabase.Begin();

   620 

   621     RDbColReadStream in;

   622     TInt oldNonceSize(0);

   623    	if ( iView.FirstL() )

   624         {

   625         iView.GetL();

   626         in.OpenLC( iView, iColSetTableAuth->ColNo( KNSmlAuthenticationNonce ) );

   627         oldNonceSize = in.Source()->SizeL();

   628 		CleanupStack::PopAndDestroy(); // in

   629         }

   630 		

   631 	RDbColWriteStream out;

   632 	if ( iView.FirstL() )

   633 		{

   634 		//existing row

   635 				

   636 		// Check OOD before updating existing nonce value

   637         if ((aNewValue.Size() > oldNonceSize ) && (SysUtil::FFSSpaceBelowCriticalLevelL( &iFsSession,

   638                 ( aNewValue.Size() - oldNonceSize ) + KNSmlAgentLogTreshold )))

   639     	    {

   640             iDatabase.Rollback();

   641             User::Leave( KErrDiskFull );

   642     		}

   643 		

   644 		// Replace nonce

   645 		iView.GetL();

   646 		iView.UpdateL();

   647 		out.OpenLC( iView, iColSetTableAuth->ColNo( KNSmlAuthenticationNonce ) );

   648 		out.WriteL( aNewValue );

   649 		out.Close();

   650 		iView.PutL();

   651 		}

   652 	else

   653 		{

   654 		//new row

   655 		

   656 		// Check OOD before inserting new row into Authentication table

   657         if ( SysUtil::FFSSpaceBelowCriticalLevelL( &iFsSession, aNewValue.Size() +

   658                 KNSmlAgentLogMaxFixedAuthRowSize + KNSmlAgentLogTreshold ) )

   659        	    {

   660             iDatabase.Rollback();

   661             User::Leave( KErrDiskFull );

   662     		}

   663 		

   664 		// Insert new row

   665 		PrepareViewL( KSQLGetAuthenticationAll, iView.EUpdatable );

   666 		iView.InsertL();

   667 		out.OpenLC( iView, iColSetTableAuth->ColNo( KNSmlAuthenticationNonce ) );

   668 		out.WriteL( aNewValue );

   669 		out.Close();

   670 		iView.SetColL( iColSetTableAuth->ColNo( KNSmlAuthenticationServerId ), aServerId );		

   671 		iView.PutL();

   672 		}

   673 	

   674 	CommitAndCompact();

   675 	CleanupStack::PopAndDestroy( 2 ); // sql, out

   676 	DBG_FILE(_S8("CNSmlDSAgentLog::SetNonceL ends"));

   677 	}

   678 

   679 //=============================================

   680 //		CNSmlDSAgentLog::NonceL()

   681 //		Gets nonce.

   682 //		If length of the returned string is 0,

   683 //		nonce was not found.

   684 //=============================================

   685 

   686 EXPORT_C HBufC* CNSmlDSAgentLog::NonceL( const TDesC& aServerId )

   687 {

   688 	DBG_FILE(_S8("CNSmlDSAgentLog::NonceL begins"));

   689 	

   690 	HBufC* sql = AuthenticationSqlLC( aServerId );

   691 		

   692 	PrepareViewL( *sql, iView.EReadOnly );

   693 	

   694 	HBufC* stringValue;

   695 

   696 	if ( iView.FirstL() )

   697 		{

   698 		iView.GetL();		

   699 		RDbColReadStream in;

   700 		in.OpenLC( iView, iColSetTableAuth->ColNo( KNSmlAuthenticationNonce ) );

   701 		stringValue = HBufC::NewLC( iView.ColLength( iColSetTableAuth->ColNo( KNSmlAuthenticationNonce ) ) );

   702 		TPtr ptr = stringValue->Des();

   703 		in.ReadL( ptr, iView.ColLength( iColSetTableAuth->ColNo( KNSmlAuthenticationNonce ) ) );

   704 		CleanupStack::Pop( 1 ); // stringValue

   705 		CleanupStack::PopAndDestroy( 1 ); //in

   706 		}

   707 	else

   708 		{

   709 		//couldn't find

   710 		stringValue = HBufC::NewL( 0 );

   711 		}

   712 	

   713 	CleanupStack::PopAndDestroy( 1 ); // sql

   714 	DBG_FILE(_S8("CNSmlDSAgentLog::NonceL ends"));

   715 	return stringValue;

   716 	}

   717 

   718 //=============================================

   719 //		CNSmlDSAgentLog::SetSessionIDL()

   720 //		Sets session Id.

   721 //=============================================

   722 

   723 EXPORT_C void CNSmlDSAgentLog::SetSessionIDL( const TDesC& aServerId, const TInt aSessionID )

   724 	{	

   725 	DBG_FILE(_S8("CNSmlDSAgentLog::SetSessionIDL begins"));

   726 	

   727 	HBufC* sql = AuthenticationSqlLC( aServerId );

   728 

   729 	PrepareViewL( *sql, iView.EUpdatable );

   730 		

   731 	iDatabase.Begin();

   732 

   733 	if ( iView.FirstL() )

   734 		{

   735 		//existing row

   736 		iView.GetL();

   737 		iView.UpdateL();

   738 		iView.SetColL( iColSetTableAuth->ColNo( KNSmlAuthenticationSessionId ), ( TInt ) aSessionID );

   739 		iView.PutL();

   740 		}

   741 	else

   742 		{

   743 		//new row

   744 		

   745 		// Check OOD before inserting new row into Authentication table

   746         if ( SysUtil::FFSSpaceBelowCriticalLevelL( &iFsSession,

   747                 KNSmlAgentLogMaxFixedAuthRowSize + KNSmlAgentLogTreshold ) )

   748             {

   749             iDatabase.Rollback();

   750             User::Leave( KErrDiskFull );

   751             }

   752 		

   753 		iTableAuthentication.InsertL();

   754 		iTableAuthentication.SetColL( iColSetTableAuth->ColNo( KNSmlAuthenticationServerId ), aServerId );

   755 		iTableAuthentication.SetColL( iColSetTableAuth->ColNo( KNSmlAuthenticationSessionId ), aSessionID );

   756 		iTableAuthentication.PutL();

   757 		}

   758 		

   759 	CommitAndCompact();

   760 	CleanupStack::PopAndDestroy( 1 ); // sql

   761 	DBG_FILE(_S8("CNSmlDSAgentLog::SetSessionIDL ends"));

   762 	}

   763 

   764 //=============================================

   765 //		CNSmlDSAgentLog::SessionIDL()

   766 //		Get Session Id

   767 //=============================================

   768 

   769 EXPORT_C TInt CNSmlDSAgentLog::SessionIDL( const TDesC& aServerId )

   770 	{

   771 	DBG_FILE(_S8("CNSmlDSAgentLog::SessionIDL begins"));

   772 		 

   773 	HBufC* sql = AuthenticationSqlLC( aServerId );

   774 	

   775 	PrepareViewL( *sql, iView.EReadOnly );

   776 	

   777 	TInt id( 0 );

   778 

   779 	if ( iView.FirstL() )

   780 		{

   781 		iView.GetL();

   782 		id = iView.ColInt( iColSetTableAuth->ColNo( KNSmlAuthenticationSessionId ) );

   783 		}

   784 

   785 	CleanupStack::PopAndDestroy( 1 ); // sql

   786 	DBG_FILE(_S8("CNSmlDSAgentLog::SessionIDL ends"));

   787 	return id;

   788 	}

   789 

   790 //=============================================

   791 //		CNSmlDSAgentLog::SetAuthTypeL()

   792 //		Set Authentication type

   793 //=============================================

   794 

   795 EXPORT_C void CNSmlDSAgentLog::SetAuthTypeL( const TDesC& aServerId, const TNSmlAgentLogAuthenticationType aNewValue )

   796 {

   797 	DBG_FILE(_S8("CNSmlDSAgentLog::SetAuthTypeL begins"));

   798 	

   799 	HBufC* sql = AuthenticationSqlLC( aServerId );

   800 	

   801 	PrepareViewL( *sql, iView.EUpdatable );

   802 		

   803 	iDatabase.Begin();

   804 

   805 	if ( iView.FirstL() )

   806 		{

   807 		//existing row

   808 		iView.GetL();

   809 		iView.UpdateL();

   810 		iView.SetColL( iColSetTableAuth->ColNo( KNSmlAuthenticationType ), ( TInt ) aNewValue );

   811 		iView.PutL();

   812 		}

   813 	else

   814 		{

   815 		//new row

   816 		

   817         // Check OOD before inserting new row into Authentication table

   818         if ( SysUtil::FFSSpaceBelowCriticalLevelL( &iFsSession,

   819                 KNSmlAgentLogMaxFixedAuthRowSize + KNSmlAgentLogTreshold ) )

   820             {

   821             iDatabase.Rollback();

   822             User::Leave( KErrDiskFull );

   823             }		

   824 		

   825 		iTableAuthentication.InsertL();

   826 		iTableAuthentication.SetColL( iColSetTableAuth->ColNo( KNSmlAuthenticationServerId ), aServerId );

   827 		iTableAuthentication.SetColL( iColSetTableAuth->ColNo( KNSmlAuthenticationType ), (TInt)aNewValue );

   828 		iTableAuthentication.PutL();

   829 		}

   830 

   831 	CommitAndCompact();

   832 	CleanupStack::PopAndDestroy( 1 ); // sql

   833 	DBG_FILE(_S8("CNSmlDSAgentLog::SetAuthTypeL ends"));

   834 	}

   835 

   836 //=============================================

   837 //		CNSmlDSAgentLog::AuthTypeL()

   838 //		Get authentication type

   839 //=============================================

   840 

   841 EXPORT_C TInt CNSmlDSAgentLog::AuthTypeL( const TDesC& aServerId )

   842 	{

   843 	DBG_FILE(_S8("CNSmlDSAgentLog::AuthTypeL begins"));

   844 		 

   845 	HBufC* sql = AuthenticationSqlLC( aServerId );

   846 	

   847 	PrepareViewL( *sql, iView.EReadOnly );

   848 

   849 	TInt type( 0 );

   850 

   851 	if ( iView.FirstL() )

   852 		{

   853 		iView.GetL();

   854 		type = iView.ColInt( iColSetTableAuth->ColNo( KNSmlAuthenticationType ) );

   855 		}

   856 

   857 	CleanupStack::PopAndDestroy( 1 ); // sql

   858 	DBG_FILE(_S8("CNSmlDSAgentLog::AuthTypeL ends"));

   859 	return type;

   860 	}

   861 

   862 //=============================================

   863 //		CNSmlDSAgentLog::SetServerIdL()

   864 //		Sets ServerId.

   865 //=============================================

   866 

   867 EXPORT_C void CNSmlDSAgentLog::SetServerIdL( TDesC& aOldServerId, TDesC& aNewValue )

   868 	{	

   869 	DBG_FILE(_S8("CNSmlDSAgentLog::SetServerIdL begins"));

   870 	HBufC* sql = AuthenticationSqlLC( aOldServerId );

   871 	

   872 	PrepareViewL( *sql, iView.EUpdatable );

   873 	TInt replaceCount(0); // Number of replaced Server Ids

   874 		

   875 	iDatabase.Begin();

   876 	if ( iView.FirstL() )

   877 		{

   878 	    ++replaceCount;

   879 		

   880 		//existing row

   881 		iView.GetL();

   882 		iView.UpdateL();

   883 		iView.SetColL( iColSetTableAuth->ColNo( KNSmlAuthenticationServerId ), aNewValue );

   884 		iView.PutL();

   885 		}

   886 	else

   887 		{

   888 		// Given ServerId was not found. Update unsuccessful.

   889 		DBG_FILE(_S8("CNSmlDSAgentLog::AuthenticationTable update unsuccessful"));

   890 		}

   891 	CleanupStack::PopAndDestroy(); // sql

   892 	

   893 	// Update all old Server Ids also in the agentlog table

   894 	*iServerId = aNewValue;

   895 

   896 	HBufC* sqlAgentLog = HBufC::NewLC( KSQLGetAgentLogRowWithServerId().Length() + aOldServerId.Length() );

   897 	TPtr sqlPtr = sqlAgentLog->Des();

   898 	sqlPtr.Format( KSQLGetAgentLogRowWithServerId, &aOldServerId );

   899 

   900 	

   901 	PrepareViewL( *sqlAgentLog, iView.EUpdatable );

   902 

   903 	if ( iView.FirstL() )

   904 		{

   905 		replaceCount += iView.CountL();

   906 		

   907 		do 

   908 			{

   909 			//existing row

   910 			iView.GetL();

   911 			iView.UpdateL();

   912 			iView.SetColL( iColSet->ColNo( KNSmlAgentLogServerId ), aNewValue );

   913 			iView.PutL();

   914 			}

   915 		while ( iView.NextL() );

   916 		}

   917 	else

   918 		{

   919 		// Given ServerId was not found. Update unsuccessful.

   920 		DBG_FILE(_S8("CNSmlDSAgentLog::AgentLogTable update unsuccessful"));

   921 		}

   922 

   923     // Check OOD before commiting

   924     if ( (aNewValue.Size() > aOldServerId.Size()) && (SysUtil::FFSSpaceBelowCriticalLevelL( &iFsSession, (replaceCount * 

   925             (aNewValue.Size() - aOldServerId.Size())) + KNSmlAgentLogTreshold )))

   926         {

   927         iDatabase.Rollback();

   928         User::Leave( KErrDiskFull );

   929         }

   930 

   931 	CommitAndCompact();

   932 	CleanupStack::PopAndDestroy(); // sqlAgentLog

   933 	DBG_FILE(_S8("CNSmlDSAgentLog::SetServerIdL ends"));

   934 	}

   935 

   936 //=============================================

   937 //		CNSmlDSAgentLog::SetServerDeviceInfoL()

   938 //		Sets Server Device Info given in parameter.

   939 //=============================================

   940 

   941 EXPORT_C void CNSmlDSAgentLog::SetServerDeviceInfoL( const RPointerArray<CNSmlDbCaps>& aDbCaps )

   942 	{

   943 	DBG_FILE(_S8("CNSmlDSAgentLog::SetServerDeviceInfoL begins"));

   944 

   945 	_LIT8( KSeparator, ";");

   946 

   947 	CBufFlat* deviceData = CBufFlat::NewL(8);

   948 	CleanupStack::PushL( deviceData );

   949 	TInt pos( 0 );

   950 	TBuf8<6> buffer;  //for num part

   951 

   952 	HBufC* stringValue16=0;

   953 	

   954 	TInt arrayCount(0);

   955 	while (arrayCount<aDbCaps.Count())

   956 		{

   957 		

   958 		SmlDevInfDatastore_t* dataStore = aDbCaps[arrayCount]->DatastoreL();

   959 		CleanupStack::PushL(dataStore);

   960 

   961 		buffer.Num( ( TInt )CNSmlDSAgentLog::EDataStore  );	

   962 		deviceData->InsertL( pos, buffer );

   963 		pos += buffer.Length();

   964 

   965 		deviceData->InsertL( pos, KSeparator );

   966 		pos++;

   967 		deviceData->InsertL( pos, KSeparator );

   968 		pos++;

   969 		

   970 

   971 		if (dataStore->sourceref)

   972 			{

   973 			buffer.Num( ( TInt )CNSmlDSAgentLog::ESourceRef  );	

   974 			deviceData->InsertL( pos, buffer );

   975 			pos += buffer.Length();

   976 

   977 			deviceData->InsertL( pos, KSeparator );

   978 			pos++;

   979 

   980 			deviceData->InsertL( pos,  dataStore->sourceref->Data());

   981 			pos += dataStore->sourceref->Data().Length();

   982 

   983 			deviceData->InsertL( pos, KSeparator );

   984 			pos++;

   985 			}

   986 

   987 		if (dataStore->displayname)

   988 			{

   989 			buffer.Num( ( TInt )CNSmlDSAgentLog::EDisplayName  );	

   990 			deviceData->InsertL( pos, buffer );

   991 			pos += buffer.Length();

   992 

   993 			deviceData->InsertL( pos, KSeparator );

   994 			pos++;

   995 

   996 			deviceData->InsertL( pos,  dataStore->displayname->Data());

   997 			pos += dataStore->displayname->Data().Length();

   998 

   999 			deviceData->InsertL( pos, KSeparator );

  1000 			pos++;

  1001 			}

  1002 

  1003 		if (dataStore->maxguidsize)

  1004 			{

  1005 			buffer.Num( ( TInt )CNSmlDSAgentLog::EMaxGUIDSize  );	

  1006 			deviceData->InsertL( pos, buffer );

  1007 			pos += buffer.Length();

  1008 

  1009 			deviceData->InsertL( pos, KSeparator );

  1010 			pos++;

  1011 

  1012 			deviceData->InsertL( pos,  dataStore->maxguidsize->Data());

  1013 			pos += dataStore->maxguidsize->Data().Length();

  1014 

  1015 			deviceData->InsertL( pos, KSeparator );

  1016 			pos++;

  1017 			}

  1018 

  1019 		if (dataStore->rxpref)

  1020 			{

  1021 			buffer.Num( ( TInt )CNSmlDSAgentLog::ERxPref  );	

  1022 			deviceData->InsertL( pos, buffer );

  1023 			pos += buffer.Length();

  1024 

  1025 			deviceData->InsertL( pos, KSeparator );

  1026 			pos++;

  1027 

  1028 			deviceData->InsertL( pos,  dataStore->rxpref->cttype->Data());

  1029 			pos += dataStore->rxpref->cttype->Data().Length();

  1030 

  1031 			deviceData->InsertL( pos, KTabSeparator );

  1032 			pos++;

  1033 

  1034 			deviceData->InsertL( pos,  dataStore->rxpref->verct->Data());

  1035 			pos += dataStore->rxpref->verct->Data().Length();

  1036 

  1037 			deviceData->InsertL( pos, KSeparator );

  1038 			pos++;

  1039 			}

  1040 

  1041 		if (dataStore->rx)

  1042 			{

  1043 			SmlDevInfXmitListPtr_t rx= dataStore->rx;

  1044 

  1045 			while (rx)

  1046 				{

  1047 				buffer.Num( ( TInt )CNSmlDSAgentLog::ERx);	

  1048 				deviceData->InsertL( pos, buffer );

  1049 				pos += buffer.Length();

  1050 

  1051 				deviceData->InsertL( pos, KSeparator );

  1052 				pos++;

  1053 

  1054 				deviceData->InsertL( pos,  rx->data->cttype->Data());

  1055 				pos += rx->data->cttype->Data().Length();

  1056 

  1057 				deviceData->InsertL( pos, KTabSeparator );

  1058 				pos++;

  1059 

  1060 				deviceData->InsertL( pos,  rx->data->verct->Data());

  1061 				pos += rx->data->verct->Data().Length();

  1062 

  1063 				deviceData->InsertL( pos, KSeparator );

  1064 				pos++;

  1065 

  1066 				rx=rx->next;

  1067 				}

  1068 			}

  1069 

  1070 		if (dataStore->txpref)

  1071 			{

  1072 			buffer.Num( ( TInt )CNSmlDSAgentLog::ETxPref  );	

  1073 			deviceData->InsertL( pos, buffer );

  1074 			pos += buffer.Length();

  1075 

  1076 			deviceData->InsertL( pos, KSeparator );

  1077 			pos++;

  1078 

  1079 			deviceData->InsertL( pos,  dataStore->txpref->cttype->Data());

  1080 			pos += dataStore->txpref->cttype->Data().Length();

  1081 

  1082 			deviceData->InsertL( pos, KTabSeparator );

  1083 			pos++;

  1084 

  1085 			deviceData->InsertL( pos,  dataStore->txpref->verct->Data());

  1086 			pos += dataStore->txpref->verct->Data().Length();

  1087 

  1088 			deviceData->InsertL( pos, KSeparator );

  1089 			pos++;

  1090 			}

  1091 

  1092 		if (dataStore->tx)

  1093 			{

  1094 			SmlDevInfXmitListPtr_t tx= dataStore->tx;

  1095 

  1096 			while (tx)

  1097 				{

  1098 				buffer.Num( ( TInt )CNSmlDSAgentLog::ETx);	

  1099 				deviceData->InsertL( pos, buffer );

  1100 				pos += buffer.Length();

  1101 

  1102 				deviceData->InsertL( pos, KSeparator );

  1103 				pos++;

  1104 

  1105 				deviceData->InsertL( pos,  tx->data->cttype->Data());

  1106 				pos += tx->data->cttype->Data().Length();

  1107 

  1108 				deviceData->InsertL( pos, KTabSeparator );

  1109 				pos++;

  1110 

  1111 				deviceData->InsertL( pos,  tx->data->verct->Data());

  1112 				pos += tx->data->verct->Data().Length();

  1113 

  1114 				deviceData->InsertL( pos, KSeparator );

  1115 				pos++;

  1116 

  1117 				tx=tx->next;

  1118 				}

  1119 			}

  1120 

  1121 		if (dataStore->dsmem)

  1122 			{

  1123 			buffer.Num( ( TInt )CNSmlDSAgentLog::EDSMem );	

  1124 			deviceData->InsertL( pos, buffer );

  1125 			pos += buffer.Length();

  1126 

  1127 			deviceData->InsertL( pos, KSeparator );

  1128 			pos++;

  1129 

  1130 			deviceData->InsertL( pos,  dataStore->dsmem->Data());

  1131 			pos += dataStore->dsmem->Data().Length();

  1132 

  1133 			deviceData->InsertL( pos, KSeparator );

  1134 			pos++;