/**
@SYMTestCaseID SYSLIB-DBMS-CT-0010
@SYMTestCaseDesc Table R/w operations. The caller has a set of capabilities which satisfy database's
schema security policy only. The test checks that the capapbility checking
on the DBMS server side works properly. Some of the R/W table operations won't be
executed and the returned error will be KErrPermisssionDenied.
@SYMTestPriority High
@SYMTestActions Attempts to execute RDbTable::Insert()/RDbTable::Update()/RDbTable::FirstL()
on different tables from the test database.
@SYMTestExpectedResults The test must not fail.
@SYMREQ REQ2429
DBMS shall provide an API to apply security policies to database tables.
*/
static void TblRWL()
{
TheTest.Printf(_L("An attempt to write in table B\n"));
TInt err = TheTbl.Open(TheDb, KTblNameB, RDbRowSet::EReadOnly);
TEST2(err, KErrNone);
//"Write table B" test must fail, because the test app has no capabilities
//to satisfy table B, policy W.
TRAP(err, TheTbl.InsertL());
TEST2(err, KErrPermissionDenied);
TRAP(err, TheTbl.UpdateL());
TEST2(err, KErrPermissionDenied);
TheTest.Printf(_L("An attempt to read from table B\n"));
//"Read table B" test must pass, because table B has no R policy
TBool res = TheTbl.FirstL();
TEST(!res);
TheTbl.Close();
TheTest.Printf(_L("An attempt to write in table C\n"));
//"Write table C" test must fail, because the test app has no capabilities
//to satisfy table C, policy W.
err = TheTbl.Open(TheDb, KTblNameC, RDbRowSet::EReadOnly);
TEST2(err, KErrNone);
TRAP(err, TheTbl.InsertL());
TEST2(err, KErrPermissionDenied);
TRAP(err, TheTbl.UpdateL());
TEST2(err, KErrPermissionDenied);
TheTest.Printf(_L("An attempt to read from table C\n"));
//"Read table C" test must pass, because table C has no R policy
res = TheTbl.FirstL();
TEST(!res);
TheTbl.Close();
}
//Deletes some records from the test table using "delete" transaction.
//Do not put TEST or TEST2 macro calls here (except for record count checks)!
//The method must leave if some of the calls inside fail.
static void DeleteRecordsL()
{
RDbTable tbl;
CleanupClosePushL(tbl);
LEAVE_IF_ERROR(tbl.Open(TheDb, KTestTableName, RDbRowSet::EUpdatable));
TEST(tbl.CountL() == KTestRecordsCount);
TheDb.Begin();
tbl.FirstL();
for(TInt i=0;i<(KTestRecordsCount/2);++i)
{
tbl.DeleteL();
tbl.NextL();
}
TInt err = TheDb.Commit();
if(err != KErrNone)
{
TheDb.Rollback();
LEAVE(err);
}
TEST(tbl.CountL() == (KTestRecordsCount / 2));
CleanupStack::PopAndDestroy(&tbl);
}
// ---------------------------------------------------------------------------
// CIRNmsLogDb:AddNmsLogStartL()
// adds the NmsLog log entry into data base
// ---------------------------------------------------------------------------
//
void CIRNmsLogDb::AddNmsLogStartL( CIRNmsLogger& aNmsLog )
{
IRLOG_DEBUG( "CIRNmsLogDb::AddNmsLogStartL" );
OpenDbL();
RDbTable nmsLogtable;
TInt error=nmsLogtable.Open( iNmsLogDb, KNmsLogTable, nmsLogtable.
EUpdatable );
CleanupClosePushL( nmsLogtable );
if ( error )
{
CloseDb();
User::LeaveIfError( error );
}
//! arrange the presets in incresing order of index
nmsLogtable.SetIndex( KNmsLogIndex );
nmsLogtable.Reset();
//if NmsLog log is greater or equal to than 5
if ( nmsLogtable.CountL() >= KMaxNoNmsLog )
{
//first row is selected
nmsLogtable.FirstL();
//the current row is selected
nmsLogtable.GetL();
//delete that entry
nmsLogtable.DeleteL();
}
CleanupStack::PopAndDestroy( &nmsLogtable );
//Algorithm : else condition need not handle seperatly
//Algorithm : add NmsLogid and informations like
//starttime,connectedfrom,NmsLogid,connectiontype,channelid
//currentnetwork,homenetwork,NmsLogtable
//Algorithm: if no. of NmsLog is greater than 5
_LIT( query, "SELECT * FROM %S" );
HBufC* sqlStr=HBufC::NewLC( query().Length() + KNmsLogTable().Length() );
sqlStr->Des().Format( query, &KNmsLogTable );
// Create a view on the database
RDbView view;
error = view.Prepare( iNmsLogDb, *sqlStr );
if ( error )
{
CloseDb();
User::LeaveIfError( error );
}
CleanupStack::PopAndDestroy( sqlStr );
CleanupClosePushL( view );
error = view.EvaluateAll();
if ( error )
{
CloseDb();
User::LeaveIfError( error );
}
CDbColSet* columns = view.ColSetL();
CleanupStack::PushL( columns );
RDbColWriteStream writeStream;
TRAP( error, //trap start
// Insert a row. Column order matches sql select statement
view.InsertL();
//get index
view.SetColL( columns->ColNo( KID ), aNmsLog.NmsLogId() );
//!open stream
writeStream.OpenLC( view, columns->ColNo( KNmsLogCol ) );
aNmsLog.ExternalizeL( writeStream );
writeStream.CommitL();
CleanupStack::PopAndDestroy( &writeStream );
);
//--------------------------------------------------------------------
//--------------------------------------------------------------------
//
void CPosLmNameIndex::SaveL( TChar aDrive )
{
RDbTable table;
TInt err = table.Open( iDatabase, KPosLmIndexTable, RDbRowSet::EUpdatable );
if ( err == KErrNotFound )
{
PosLmDatabaseManager::CreateIndexTableL( iDatabase );
err = table.Open( iDatabase, KPosLmIndexTable, RDbRowSet::EUpdatable );
}
User::LeaveIfError( err );
CleanupClosePushL( table );
TInt currentSize = 0;
table.FirstL();
if ( table.AtEnd() )
{
table.InsertL();
}
else
{
table.GetL();
currentSize = table.ColSize( EPosLmIncIndexDataCol );
table.UpdateL();
}
if ( currentSize < DataSize() )
{
// check disk size
CPosLmDiskUtilities* diskUtilities = CPosLmDiskUtilities::NewL();
CleanupStack::PushL( diskUtilities );
TInt bytesToWrite = DataSize() - currentSize;
diskUtilities->DiskSpaceBelowCriticalLevelL( bytesToWrite, aDrive );
CleanupStack::PopAndDestroy( diskUtilities );
}
// current language
table.SetColL( EPosLmIncLanguageCol, User::Language() );
// index data
RDbColWriteStream writeStream;
writeStream.OpenL( table, EPosLmIncIndexDataCol );
CleanupClosePushL( writeStream );
ExternalizeL( writeStream );
CleanupStack::PopAndDestroy( &writeStream );
// index timestamp
TTime now;
now.UniversalTime();
table.SetColL( EPosLmIncTimestampCol, now );
#ifdef _DEBUG
TBuf<64> mtime;
now.FormatL( mtime, KPosLmTimeFormat );
LOG1( "NameIndex: Saving index timestamp %S", &mtime);
#endif
table.PutL();
CleanupStack::PopAndDestroy ( &table );
iTimeStamp = now;
}
//--------------------------------------------------------------------
//--------------------------------------------------------------------
//
void CPosLmNameIndex::LoadL()
{
// Skip index loading for empty databases
TInt numLandmarks = PosLmServerUtility::TotalLandmarkCountL( iDbAccess );
if ( numLandmarks == 0 )
{
iTimeStamp.UniversalTime();
iStatus = KErrNone;
return;
}
RDbTable table;
TInt err = table.Open( iDatabase, KPosLmIndexTable, RDbRowSet::EReadOnly );
if ( err )
{
LOG("NameIndex::LoadL: index table not found");
User::Leave( err );
}
CleanupClosePushL( table );
table.FirstL();
if ( table.AtEnd() )
{
LOG("NameIndex::LoadL: index not found");
User::Leave( KErrNotFound );
}
table.GetL();
// verify that index is valid for current language
if ( !table.IsColNull( EPosLmIncLanguageCol ) )
{
TLanguage lang = (TLanguage) table.ColInt32( EPosLmIncLanguageCol );
if ( User::Language() != lang )
{
LOG2("NameIndex::LoadL: index not valid, lang %d, current lang %d",
lang, User::Language() );
User::Leave( KErrCorrupt );
}
}
else
{
LOG("NameIndex::LoadL: index lang not found");
User::Leave( KErrCorrupt );
}
// read the index
if ( !table.IsColNull( EPosLmIncIndexDataCol ) )
{
RDbColReadStream readStream;
readStream.OpenL( table, EPosLmIncIndexDataCol );
CleanupClosePushL( readStream );
InternalizeL( readStream );
CleanupStack::PopAndDestroy( &readStream );
// basic check for the index
if ( Count() != numLandmarks )
{
LOG2("NameIndex::LoadL: index not valid, count %d, landmarks in db %d",
Count(), numLandmarks );
User::Leave( KErrCorrupt );
}
}
else
{
LOG("NameIndex::LoadL: index data not found");
User::Leave( KErrCorrupt );
}
// read the time stamp
iTimeStamp.UniversalTime();
if ( !table.IsColNull( EPosLmIncTimestampCol ) )
{
iTimeStamp = table.ColTime( EPosLmIncTimestampCol );
}
else
{
LOG("NameIndex::LoadL: index timestamp not found");
User::Leave( KErrCorrupt );
}
CleanupStack::PopAndDestroy ( &table );
// index is valid
iStatus = KErrNone;
}
// -----------------------------------------------------------------------------
// CLogTask::DoExecuteL
// Helper to executes the task.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CLogTask::DoExecuteL()
{
RDbs dbSession;
User::LeaveIfError( dbSession.Connect() );
CleanupClosePushL( dbSession );
// Construct the db format string
HBufC* formatString = HBufC::NewLC( KLogSecureFormat().Length() +
KLogAccessPolicyUid.Name().Length() );
TPtr ptr( formatString->Des() );
TUidName uidStr = KLogAccessPolicyUid.Name();
ptr.Format( KLogSecureFormat, &uidStr );
RDbNamedDatabase dbs;
// Try to open the db
TInt err = dbs.Open( dbSession, KLogDatabaseName, *formatString );
if ( err == KErrNotFound )
{
// DB not exist, create it
User::LeaveIfError( dbs.Create( dbSession, KLogDatabaseName, *formatString ) );
}
else if ( err != KErrNone )
{
User::Leave( err );
}
CleanupClosePushL( dbs );
// See if the log table already exists
TBool needCompact( EFalse );
RDbTable table;
err = table.Open( dbs, KLogTableName );
if ( err != KErrNone )
{
// Table does not exist
// Create the table
User::LeaveIfError( dbs.Execute( KLogCreateTableSQL ) );
}
else
{
// Check that we don't have too many rows
CleanupClosePushL( table );
if ( table.CountL( RDbTable::EQuick ) >= KMaxLogEntryCount )
{
// Delete the first row
table.FirstL();
table.DeleteL();
needCompact = ETrue;
}
CleanupStack::PopAndDestroy( &table );
}
// Add entry to the table
// Time
HBufC* timeString = HBufC::NewLC( KMaxTimeStringLength );
TPtr timePtr( timeString->Des() );
timePtr.Num( iLogEntry.iTime.Int64() );
// Version
HBufC* version = ConstructVersionStringLC( iLogEntry.iVersion.iMajor,
iLogEntry.iVersion.iMinor,
iLogEntry.iVersion.iBuild );
// Construct the sql query
HBufC* sqlQuery = HBufC::NewLC( KLogInsertSQLFormat().Length() +
KMaxLogNameLength +
KMaxLogVendorLength +
version->Length() +
timeString->Length() +
KExtraCharsInSql );
TPtr sqlPtr( sqlQuery->Des() );
sqlPtr.Format( KLogInsertSQLFormat, timeString, iLogEntry.iUid.iUid, &(iLogEntry.iName),
&(iLogEntry.iVendor), version, iLogEntry.iAction, iLogEntry.iIsStartup );
// Execute the query
User::LeaveIfError( dbs.Execute( *sqlQuery ) );
// Compact the db if needed
if ( needCompact )
{
dbs.Compact();
}
CleanupStack::PopAndDestroy( 6 ); // sqlQuery, version, timeString, dbs, formatString, dbSession
}
/**
@SYMTestCaseID SYSLIB-DBMS-CT-0016
@SYMTestCaseDesc R/W operations at a table level.
This test app has "PowerMgmt" (TABLE A: READ) capability, which allows it to
read data from table A. B and C tables can be read too, because they do
not have read security policy.
@SYMTestPriority High
@SYMTestActions R/W table operations.
@SYMTestExpectedResults The test must not fail.
@SYMREQ REQ2429
DBMS shall provide an API to apply security policies to database tables.
*/
static void TblRWL()
{
TheTest.Printf(_L("Table A - Write\n"));
TInt err = TheTbl.Open(TheDb, KTblNameA, RDbRowSet::EReadOnly);
TEST2(err, KErrNone);
//The test must fail, because the test app cannot satisfy table A, policy W.
TRAP(err, TheTbl.InsertL());
TEST2(err, KErrPermissionDenied);
err = TheDb.Execute(_L("UPDATE A SET DATA1 = 400 WHERE ID < 10"));
TEST2(err, KErrPermissionDenied);
TheTest.Printf(_L("Table A - Read\n"));
//The test must pass, because the test app can satisfy table A, policy R.
TBool res = EFalse;
TRAP(err, res = TheTbl.FirstL());
TEST2(err, KErrNone);
TEST(res);
TInt cnt = TheTbl.CountL();
TEST(cnt > 0);
err = TheView.Prepare(TheDb, TDbQuery(_L("SELECT * FROM A")));
TEST2(err, KErrNone);
cnt = TheView.CountL();
TEST(cnt > 0);
TheView.Close();
TheTbl.Close();
TheTest.Printf(_L("Table B - Write\n"));
err = TheTbl.Open(TheDb, KTblNameB, RDbRowSet::EReadOnly);
TEST2(err, KErrNone);
//The test must fail, because the test app cannot satisfy table B, policy W.
TRAP(err, TheTbl.InsertL());
TEST2(err, KErrPermissionDenied);
err = TheDb.Execute(_L("INSERT INTO B (DATA2) VALUES (45)"));
TEST2(err, KErrPermissionDenied);
TheTest.Printf(_L("Table B - Read\n"));
//The test must pass, because table B has no R policy.
TRAP(err, res = TheTbl.FirstL());
TEST2(err, KErrNone);
TEST(res);
cnt = TheTbl.CountL();
TEST(cnt > 0);
err = TheView.Prepare(TheDb, TDbQuery(_L("SELECT * FROM B")));
TEST2(err, KErrNone);
cnt = TheView.CountL();
TEST(cnt > 0);
TheView.Close();
TheTbl.Close();
TheTest.Printf(_L("Table C - Write\n"));
err = TheTbl.Open(TheDb, KTblNameC);
//The test must fail, because the test app cannot satisfy table C, policy W.
TEST2(err, KErrPermissionDenied);
err = TheTbl.Open(TheDb, KTblNameC, RDbRowSet::EReadOnly);
TEST2(err, KErrNone);
TRAP(err, TheTbl.InsertL());
TEST2(err, KErrPermissionDenied);
err = TheDb.Execute(_L("UPDATE C SET DATA1 = 400 WHERE ID < 10"));
TEST2(err, KErrPermissionDenied);
TheTest.Printf(_L("Table C - Read\n"));
//The test must pass, because table C has no R policy.
TRAP(err, res = TheTbl.FirstL());
TEST2(err, KErrNone);
TEST(res);
cnt = TheTbl.CountL();
TEST(cnt > 0);
err = TheView.Prepare(TheDb, TDbQuery(_L("SELECT * FROM C")));
TEST2(err, KErrNone);
cnt = TheView.CountL();
TEST(cnt > 0);
TheView.Close();
TheTbl.Close();
}