1 // Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

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

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 //

    15 

    16 #include "SqlSrvMain.h"			//CSqlServer

    17 #include "SqlSrvSession.h"		//CSqlSrvSession

    18 #include "SqlSrvStatement.h"	//CSqlSrvStatement, HSqlSrvStmtParamBuf

    19 #include "SqlSecurityImpl.h"	//CSqlSecurityPolicy

    20 #include "SqlSrvUtil.h"			//Global server functions

    21 #include "SqlUtil.h"			// config length

    22 #include "SqlSrvDriveSpace.h"	//CSqlDriveSpace, RSqlDriveSpaceCol

    23 #include "SqlSrvBlob.h"

    24 #include "SqlResourceProfiler.h"

    25 #include "SqlCompact.h"

    26 #include "UTraceSql.h"

    27 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////

    28 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////

    29 

    30 #ifdef _DEBUG

    31 

    32 const TInt KDelayedDbHeapFailureMask = 0x1000;

    33 

    34 //Puts the database connection in a test mode

    35 //Returns true if the heap failure simulation has to be delayed untill the database is opened

    36 //Initialises iDbResourceTestMode and iFailedAllocNumber (if delayed simulation) data members

    37 inline TBool CSqlSrvSession::ActivateDbTestMode(TInt aHeapFailureMode, TInt aFailedAllocNumber)

    38 	{

    39 	iDbResourceTestMode = aHeapFailureMode;

    40 	if(aHeapFailureMode & KDelayedDbHeapFailureMask)

    41 		{

    42 		iFailedAllocNumber = aFailedAllocNumber;

    43 		return ETrue;

    44 		}

    45 	return EFalse;

    46 	}

    47 

    48 //If the database connection is in a test mode then the macro will reset the heap allocation failure type.

    49 //and stop the test mode.

    50 inline void CSqlSrvSession::StopDbTestMode()

    51 	{

    52 	if(iDbResourceTestMode)

    53 		{

    54 		iDbResourceTestMode = 0;

    55 		User::__DbgSetAllocFail(RHeap::EUser, RHeap::ENone, 0);

    56 		}

    57 	}

    58 

    59 //If the database connection is in a test mode then the function will mark the allocated by the 

    60 //server resources.

    61 inline void CSqlSrvSession::DbResourceMark()

    62 	{

    63 	if(iDbResourceTestMode)

    64 		{

    65 		ResourceCountMarkStart();

    66 		}

    67 	}

    68 

    69 //If the database connection is in a test mode then the macro will check the allocated by the server resources,

    70 //comparing their count with the resource count at the moment DbResourceMark() has been called.

    71 //The client will be panicked if the resource count now is different.

    72 inline void CSqlSrvSession::DbResourceEnd(const RMessage2& aMessage)

    73 	{

    74 	if(iDbResourceTestMode)

    75 		{

    76 		ResourceCountMarkEnd(aMessage);

    77 		}

    78 	}

    79 

    80 //Executes the heap simulation failure.

    81 inline void CSqlSrvSession::DbSetAllocFail(TInt aHeapFailureMode, TInt aFailedAllocNumber)

    82 	{

    83 	User::__DbgSetAllocFail(RHeap::EUser, 

    84 							static_cast <RHeap::TAllocFail> (aHeapFailureMode & (KDelayedDbHeapFailureMask - 1)), 

    85 							aFailedAllocNumber);

    86 	}

    87 	

    88 //Executes the delayed heap simulation failure, if the connection is in test mode

    89 inline void CSqlSrvSession::DbSetDelayedAllocFail()

    90 	{

    91 	if(iDbResourceTestMode & KDelayedDbHeapFailureMask)

    92 		{

    93 		User::__DbgSetAllocFail(RHeap::EUser, 

    94 								static_cast <RHeap::TAllocFail> (iDbResourceTestMode & (KDelayedDbHeapFailureMask - 1)), 

    95 								iFailedAllocNumber);

    96 		}

    97 	}

    98 	

    99 #else //_DEBUG

   100 

   101 inline TBool CSqlSrvSession::ActivateDbTestMode(TInt, TInt)

   102 	{

   103 	return EFalse;

   104 	}

   105 

   106 inline void CSqlSrvSession::StopDbTestMode()

   107 	{

   108 	}

   109 

   110 inline void CSqlSrvSession::DbResourceMark()

   111 	{

   112 	}

   113 

   114 inline void CSqlSrvSession::DbResourceEnd(const RMessage2&)

   115 	{

   116 	}

   117 

   118 inline void CSqlSrvSession::DbSetAllocFail(TInt, TInt)

   119 	{

   120 	}

   121 	

   122 inline void CSqlSrvSession::DbSetDelayedAllocFail()

   123 	{

   124 	}

   125 

   126 #endif//_DEBUG

   127 

   128 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////

   129 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////

   130 

   131 /**

   132 Searches aContainer for an object identified by aHandle.

   133 If such object exists, a reference to it is returned.

   134 If there is no object, the client gets a panic.

   135 

   136 @panic SqlDb 4 Client panic. Invalid aHandle parameter value (zero, negative or out of range).

   137 

   138 @internalComponent

   139 */

   140 template <class T> T& SqlSessObjFind(RDbObjContainer<T>& aContainer, TInt aHandle, const RMessage2& aMessage)

   141 	{

   142 	T* obj = aContainer.Find(aHandle);

   143 	__SQLPANIC_CLIENT(obj != NULL, aMessage, ESqlPanicBadArgument);

   144 	return *obj;

   145 	}

   146 

   147 //This function return true, if there is free disk space on drive where the main database file is.

   148 static TBool HasFreeDiskSpace(RFs& aFs, TDriveNumber aDrive)

   149 	{

   150 	TVolumeInfo volInfo;

   151 	TInt err = aFs.Volume(volInfo, aDrive);

   152 	if(err == KErrNone)

   153 		{

   154 		const TInt64 KDiskSpaceThreshold = 1024 * 4;

   155 		return volInfo.iFree > KDiskSpaceThreshold;

   156 		}

   157 	return ETrue;

   158 	}

   159 	

   160 //If aError is KSqlErrFull and  there is no free disk space, then KSqlErrFull is converted to KErrDiskFull

   161 //and returned.

   162 static TInt ConvertSqlFull2DiskFullErr(TInt aError, RFs& aFs, TDriveNumber aDrive)

   163 	{

   164 	if(aError == KSqlErrFull && !HasFreeDiskSpace(aFs, aDrive))

   165 		{

   166 		aError = KErrDiskFull;

   167 		}

   168 	return aError;

   169 	}

   170 

   171 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////

   172 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////

   173 

   174 /**

   175 Creates a new instance of CSqlSrvSession class.

   176 

   177 This function shall never be called directly.

   178 It is CSqlServer responsibility to create a new server side session object as a responce to the criation of a

   179 client side session instance.

   180 

   181 @return A pointer to the created CSqlSrvSession instance.

   182 

   183 @leave KErrNoMemory, an out of memory condition has occurred;

   184 

   185 @see CSqlServer

   186 @see CSqlServer::NewSessionL()

   187 */

   188 CSqlSrvSession* CSqlSrvSession::NewL()

   189 	{

   190 	CSqlSrvSession* self = new (ELeave)	CSqlSrvSession;

   191 	CleanupStack::PushL(self);

   192 	self->ConstructL();

   193 	CleanupStack::Pop(self);

   194 	return self;

   195 	}

   196 

   197 /**

   198 Frees the allocated by CSqlSrvSession instance resources and memory.

   199 */

   200 CSqlSrvSession::~CSqlSrvSession()

   201 	{

   202 	StopDbTestMode();

   203 	DbFreeReservedSpace();

   204 	iIpcStreams.Close();

   205 	iStatements.Close();

   206 	delete iDatabase;

   207 	}

   208 

   209 /**

   210 Receives and dispatches all client side requests.

   211 

   212 CSession2::ServiceL() implementation.

   213 

   214 @param aMessage Client message containing the request (function code and data)

   215 

   216 @leave The function may leave with some database specific 

   217 	   errors categorised as ESqlDbError or system-wide error codes.

   218 

   219 @see CSession2::ServiceL()

   220 */

   221 void CSqlSrvSession::ServiceL(const RMessage2& aMessage)

   222 	{

   223 	TSqlSrvFunction funcCode = ESqlSrvTestBase;

   224 	TInt handle = 0;

   225 	Extract(aMessage, funcCode, handle);

   226 	TInt retCode = KErrNone;

   227 	if(funcCode >= ESqlSrvDbBase)

   228 		{

   229 		SQLPROFILER_REPORT_IPC(ESqlIpcRq, 0);

   230 		}

   231 	SYMBIAN_TRACE_SQL_EVENTS_ONLY(TPtrC8 funcName = GetIPCFuncStr(funcCode));

   232 	SYMBIAN_TRACE_SQL_EVENTS_ONLY(UTF::Printf(UTF::TTraceContext(UTF::EBorder), KSrvMsgStr, &funcName));

   233 	

   234 	SQLPROFILER_IPC_START(iIpcCounter, iDatabase ? (TUint)iDatabase->RawDbHandle() : 0);

   235 	

   236 	switch(funcCode)

   237 		{

   238 		//////////////////////  resource check operations  ///////////////////////////

   239 		case ESqlSrvResourceMark:

   240 			ResourceCountMarkStart();

   241 			break;

   242 		case ESqlSrvResourceCheck:

   243 			ResourceCountMarkEnd(aMessage);

   244 			break;

   245 		case ESqlSrvResourceCount:

   246 			retCode = CountResources();					//Returns the recourse count

   247 			break;

   248 		case ESqlSrvSetDbHeapFailure:

   249 			if(ActivateDbTestMode(aMessage.Int0(), aMessage.Int1()))

   250 				{

   251 				break;	

   252 				}

   253 		case ESqlSrvSetHeapFailure:

   254 			DbSetAllocFail(aMessage.Int0(), aMessage.Int1());

   255 			break;

   256 		//////////////////////   profiling operations  //////////////////////////////////

   257 		case ESqlSrvProfilerStart:

   258 			TSqlSrvResourceProfiler::StartL(aMessage);

   259 			break;

   260 		case ESqlSrvProfilerStop:

   261 			TSqlSrvResourceProfiler::StopL(aMessage);

   262 			break;

   263 		case ESqlSrvProfilerReset:

   264 			TSqlSrvResourceProfiler::ResetL(aMessage);

   265 			break;

   266 		case ESqlSrvProfilerQuery:

   267 			ProfilerQueryL(aMessage);

   268 			break;

   269 		//////////////////////   database operations //////////////////////////////////

   270 		case ESqlSrvDbCreate:

   271 		case ESqlSrvDbCreateSecure:

   272 		case ESqlSrvDbOpen:

   273 			DbResourceMark();

   274 			DbCreateObjectL(aMessage, funcCode);

   275 			DbSetDelayedAllocFail();

   276 			break;

   277 		case ESqlSrvDbOpenFromHandle:

   278 			DbResourceMark();

   279 			DbCreateObjectFromHandleL(aMessage);

   280 			DbSetDelayedAllocFail();

   281 			break;

   282 		case ESqlSrvDbAttach:

   283 			DbAttachL(aMessage);

   284 			break;

   285 		case ESqlSrvDbAttachFromHandle:

   286 			DbAttachFromHandleL(aMessage);

   287 			break;

   288 		case ESqlSrvDbDetach:

   289 			DbDetachL(aMessage);

   290 			break;

   291 		case ESqlSrvDbClose:

   292 			DbDestroyObject();

   293 			DbResourceEnd(aMessage);

   294 			StopDbTestMode();

   295 			break;

   296 		case ESqlSrvDbCopy:

   297 			DbResourceMark();

   298 			DbCopyFileL(aMessage);

   299 			break;

   300 		case ESqlSrvDbDelete:

   301 			DbResourceMark();

   302 			DbDeleteFileL(aMessage);

   303 			break;

   304 		case ESqlSrvLastErrorMsg:

   305 			retCode = DbLastErrorMessageL(aMessage);//may return that the client buffer is not big enough for the message

   306 			break;

   307 		case ESqlSrvDbLastInsertedRowId:

   308 			DbLastInsertedRowIdL(aMessage);

   309 			break;

   310 		case ESqlSrvDbExec8:

   311 			retCode = DbExecSql8L(aMessage);		//returns the count of affected records

   312 			break;

   313 		case ESqlSrvDbExec16:

   314 			retCode = DbExecSql16L(aMessage);	//returns the count of affected records

   315 			break;

   316 		case ESqlSrvDbSetIsolationLevel:

   317 			DbSetIsolationLevelL(aMessage);

   318 			break;

   319 		case ESqlSrvDbGetSecurityPolicy:

   320 			retCode = DbGetSecurityPolicyL(aMessage);//may return that the client buffer is not big enough for the security policy

   321 			break;

   322 		case ESqlSrvDbScalarFullSelect8:

   323 			retCode = DbScalarFullSelectL(aMessage, EFalse);//may return that the client buffer is not big enough for the column value

   324 			break;

   325 		case ESqlSrvDbScalarFullSelect16:

   326 			retCode = DbScalarFullSelectL(aMessage, ETrue);//may return that the client buffer is not big enough for the column value

   327 			break;

   328 		case ESqlSrvDbInTransaction:

   329 			retCode = DbInTransaction(aMessage);	//Returns whether the database in in transaction or not - true/false

   330 			break;

   331 		case ESqlSrvDbSize:

   332 			retCode = DbSizeL(aMessage);			//Returns the database size

   333 			break;

   334 		case ESqlSrvDbSize2:

   335 			DbSize2L(aMessage);

   336 			break;

   337 		case ESqlSrvDbCompact:

   338 			retCode = DbCompactL(aMessage);			//Returns the amount of the removed free database space

   339 			break;

   340 		//////////////////////   reserved drive space management ////////////////////////

   341 		case ESqlSrvDbReserveDriveSpace:

   342 			__SQLPANIC_CLIENT(iDatabase != NULL, aMessage, ESqlPanicInvalidObj);

   343 			DbReserveDriveSpaceL();

   344 			break;

   345 		case ESqlSrvDbFreeReservedSpace:

   346 			__SQLPANIC_CLIENT(iDatabase != NULL, aMessage, ESqlPanicInvalidObj);

   347 			DbFreeReservedSpace();

   348 			break;

   349 		case ESqlSrvDbGetReserveAccess:

   350 			__SQLPANIC_CLIENT(iDatabase != NULL, aMessage, ESqlPanicInvalidObj);

   351 			DbGetReserveAccessL();

   352 			break;

   353 		case ESqlSrvDbReleaseReserveAccess:

   354 			__SQLPANIC_CLIENT(iDatabase != NULL, aMessage, ESqlPanicInvalidObj);

   355 			DbReleaseReserveAccess();

   356 			break;

   357 		//////////////////////   BLOB source ///////////////////////////////////////////

   358 		case ESqlSrvDbBlobSource:

   359 			retCode = DbBlobSourceL(aMessage);		//Returns the BLOB handle

   360 			break;

   361 		//////////////////////   statement operations //////////////////////////////////

   362 		case ESqlSrvStmtPrepare8:

   363 			retCode = StmtPrepareL(aMessage, EFalse);//returns the statement handle

   364 			break;

   365 		case ESqlSrvStmtPrepare16:

   366 			retCode = StmtPrepareL(aMessage, ETrue);//returns the statement handle

   367 			break;

   368 		case ESqlSrvStmtClose:

   369 			iStatements.Remove(handle);

   370 			break;

   371 		case ESqlSrvStmtReset:

   372 			retCode = ::SqlSessObjFind(iStatements, handle, aMessage).Reset();//May return that the statement has expired

   373 			break;

   374 		case ESqlSrvStmtExec:

   375 		case ESqlSrvStmtAsyncExec:

   376 		case ESqlSrvStmtBindExec:

   377 		case ESqlSrvStmtAsyncBindExec:

   378 			retCode = StmtExecL(aMessage, handle, funcCode);//returns the count of affected records

   379 			break;

   380 		case ESqlSrvStmtNext:

   381 		case ESqlSrvStmtBindNext:

   382 			retCode = StmtNextL(aMessage, handle, funcCode);//returns a non-negative number if the client side buffer is too small

   383 			break;

   384 		case ESqlSrvStmtColumnNames:

   385 		case ESqlSrvStmtParamNames:

   386 			retCode = StmtNamesL(aMessage, handle, funcCode);//returns a non-negative number if the client side buffer is too small

   387 			break;

   388 		case ESqlSrvStmtColumnSource:

   389 			retCode = StmtColumnSourceL(aMessage, handle);//returns an IPC stream handle

   390 			break;

   391 		case ESqlSrvStmtBinParamSink:

   392 		case ESqlSrvStmtTxtParamSink16:

   393 			retCode = StmtParamSinkL(aMessage, handle, funcCode);//returns an IPC stream handle

   394 			break;

   395 		case ESqlSrvStmtBufFlat:

   396 			StmtGetBufFlatL(aMessage, handle);

   397 			break;

   398 		case ESqlSrvStmtColumnValue:

   399 			StmtColumnValueL(aMessage, handle);

   400 			break;

   401 		case ESqlSrvStmtDeclColumnTypes:

   402 			StmtDeclColumnTypesL(aMessage, handle);

   403 			break;

   404 		//////////////////////   stream operations //////////////////////////////////

   405 		case ESqlSrvStreamRead:

   406 			retCode = ::SqlSessObjFind(iIpcStreams, handle, aMessage).ReadL(aMessage);

   407 			break;

   408 		case ESqlSrvStreamWrite:

   409 			::SqlSessObjFind(iIpcStreams, handle, aMessage).WriteL(aMessage);

   410 			break;

   411 		case ESqlSrvStreamSize:

   412 			retCode = ::SqlSessObjFind(iIpcStreams, handle, aMessage).SizeL();

   413 			break;

   414 		case ESqlSrvStreamSynch:

   415 			::SqlSessObjFind(iIpcStreams, handle, aMessage).SynchL();

   416 			break;

   417 		case ESqlSrvStreamClose:

   418 			iIpcStreams.Remove(handle);

   419 			break;

   420 		//////////////////////                     //////////////////////////////////

   421 		default:	

   422 			retCode = KErrNotSupported;

   423 			break;

   424 		}

   425 	Server().Compactor().RestartTimer();

   426 	Server().MinimizeBuffers();		

   427 	if(!aMessage.IsNull())

   428 		{

   429 		aMessage.Complete(retCode);

   430 		}

   431     SQLPROFILER_IPC_END(iIpcCounter, funcCode, iDatabase ? (TUint)iDatabase->RawDbHandle() : 0, iIpcTraceData, retCode);

   432 	}

   433 

   434 /**

   435 If aError is KErrBadDescriptor, then panic the client, else - default error handling.

   436 KErrBadDescriptor error may be thrown from "message write" operations, if the client supplied a bad

   437 descriptor to the server.

   438 */

   439 void CSqlSrvSession::ServiceError(const RMessage2& aMessage, TInt aError)

   440  	{

   441 	Server().MinimizeBuffers();		

   442 	aError = ::ConvertSqlFull2DiskFullErr(aError, Server().FileData().Fs(), iDrive);

   443  	if(aError == KErrBadDescriptor)

   444  		{

   445 		//The __SQLPANIC_CLIENT() macro cannot be used here because it calls a leaving function. A leaving call

   446 		//from a leaving call will terminate the server.

   447 		_LIT(KPanicCategory, "SqlDb");

   448 		

   449 		SYMBIAN_TRACE_SQL_ERR_ONLY(UTF::Printf(UTF::TTraceContext(UTF::EError), KSqlSrvPanicClient, aError));

   450 		aMessage.Panic(KPanicCategory, ESqlPanicBadDescriptor);

   451  		}

   452  	

   453  	SYMBIAN_TRACE_SQL_ERR_ONLY(UTF::Printf(UTF::TTraceContext(UTF::EError), KSqlSrvError, aError));

   454  	SQLPROFILER_IPC_ERROR(iIpcCounter, static_cast <TSqlSrvFunction> (KSqlSrvFunctionMask & aMessage.Function()), 

   455  	       iDatabase ? (TUint)iDatabase->RawDbHandle() : 0, aError);

   456  	CSession2::ServiceError(aMessage, aError);

   457    	}

   458 

   459 ///////////////////////////////////////////////////////////////////////////////////////////////////////

   460 ////////////////////////////          Profiler  operations           ///////////////////////////////////

   461 ///////////////////////////////////////////////////////////////////////////////////////////////////////

   462 

   463 /**

   464 Retrieves the counter values for the specified profiling counter.

   465 

   466 @leave  KErrNone, the operation completed successfully,

   467         KErrOverflow, the receiving buffer size is too small;

   468                   One of the other system-wide error codes may also be returned.

   469 

   470 @see TSqlResourceProfiler

   471 

   472 Usage of the IPC call arguments:

   473  - Arg 0: [in]  profiling counter type, one of the TSqlResourceProfiler::TSqlCounter enum item values.

   474  - Arg 1: [in]  the size of the buffer for the profiling counter values.

   475  - Arg 2: [out] the buffer for the profiling counter values.

   476 

   477 @panic SqlDb 2 Client panic. iDatabase is NULL (the database object is not created yet).

   478 */

   479 void CSqlSrvSession::ProfilerQueryL(const RMessage2& aMessage)

   480 	{

   481 	__SQLPANIC_CLIENT(iDatabase != NULL, aMessage, ESqlPanicInvalidObj);

   482 	if(aMessage.Int0() == TSqlResourceProfiler::ESqlCounterConfig)

   483 		{

   484 		const TInt KConfigBufLen = 128;

   485 		if(aMessage.Int1() < KConfigBufLen)

   486 			{

   487 			__SQLLEAVE(KErrOverflow);	

   488 			}

   489 		TBuf8<KConfigBufLen> res;

   490 		iDatabase->QueryConfigL(res);

   491 		aMessage.WriteL(2, res);

   492 		}

   493 	else

   494 		{

   495 		TSqlSrvResourceProfiler::QueryL(aMessage);

   496 		}				

   497 	}

   498 

   499 ///////////////////////////////////////////////////////////////////////////////////////////////////////

   500 ////////////////////////////          Database operations           ///////////////////////////////////

   501 ///////////////////////////////////////////////////////////////////////////////////////////////////////

   502 

   503 /**

   504 Processes the request for creating/opening a database.

   505 

   506 The function initializes iDatabase and iDrive data members.

   507 

   508 Usage of the IPC call arguments:

   509 Arg 0: [in]  database file name length in 16-bit characters

   510 Arg 1: [in]  database file name

   511 Arg 2: [in]  PPPPCCCC, where PPPP is the security policy length, CCCC is the config string length.

   512 Arg 3: [in]  security policies buffer | config string

   513 

   514 @leave KErrArgument If config string length or security policy length is invalid (negative length or too big length)

   515 @panic SqlDb 1 Client panic. iDatabase is not NULL (it has been created already)

   516 */

   517 void CSqlSrvSession::DbCreateObjectL(const RMessage2& aMessage, TSqlSrvFunction aFunction)

   518 	{

   519 	__SQLPANIC_CLIENT(!iDatabase, aMessage, ESqlPanicObjExists);

   520 	const TInt KSecurityPolicyLen = (aMessage.Int2() & 0x7fff0000) >> 16;

   521 	const TInt KConfigStringLen = aMessage.Int2() & 0xffff;

   522 	if(KSecurityPolicyLen < 0 || KConfigStringLen < 0 || KConfigStringLen > KSqlSrvMaxConfigStrLen)

   523 		{

   524 		__SQLLEAVE(KErrArgument);	

   525 		}

   526 	TBuf8<KSqlSrvMaxConfigStrLen> configStr;

   527 	if(KConfigStringLen > 0)

   528 		{

   529 		aMessage.ReadL(3, configStr, KSecurityPolicyLen);

   530 		SQLPROFILER_REPORT_IPC(ESqlIpcRead, KConfigStringLen);

   531 		}

   532 	TSqlSrvFileData& fileData = Server().FileData();

   533 	fileData.SetL(aMessage, aMessage.Int0(), 1, &configStr);

   534 	iDrive = fileData.Drive();

   535 	switch(aFunction)

   536 		{

   537 		case ESqlSrvDbCreate:

   538 			if(fileData.IsSecureFileNameFmt())

   539 				{

   540 				__SQLLEAVE(KErrArgument);	

   541 				}

   542 			iDatabase = CSqlSrvDatabase::CreateL(fileData);

   543 			break;

   544 		case ESqlSrvDbCreateSecure:

   545 			{

   546 			if(!fileData.IsSecureFileNameFmt())

   547 				{

   548 				__SQLLEAVE(KErrArgument);	

   549 				}

   550 			//The caller can create a secure database which secure UID matches his secure UID.

   551 			if(fileData.SecureUid() != aMessage.SecureId())

   552 				{

   553 				__SQLLEAVE(KErrPermissionDenied);	

   554 				}

   555 			CSqlSecurityPolicy* policy = InternalizeSecurityPolicyL(aMessage);

   556 			iDatabase = CSqlSrvDatabase::CreateSecureL(fileData, policy);

   557 			}

   558 			break;

   559 		case ESqlSrvDbOpen:

   560 			iDatabase = CSqlSrvDatabase::OpenL(fileData);

   561 			break;

   562 		default:

   563 			__SQLLEAVE(KErrArgument);	

   564 			break;

   565 		}

   566 	}

   567 

   568 /**

   569 Processes the request for opening a database from file handle.

   570 The server expects that the database to be opened/created is in the applicatio's private data cage.

   571 

   572 Usage of the IPC call arguments:

   573  - Arg 0: [in]  The 32 bits of the argument are used as follow:

   574  @code

   575  MSB                                                                                 LSB

   576  31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0

   577  Ro Cr  C  C  C  C  C  C  C  C  C  C  C  C  C  C  F  F  F  F  F  F F F F F F F F F F F 

   578  @endcode

   579  Where:

   580  @code

   581   - "Ro" - read-only flag, true if the file is read-only;

   582   - "Cr" - create/open flag, true if the file was created, false if the file was opened;

   583   - "C"  - config string length in 16-bit characters;

   584   - "F"  - database file name length in 16-bit characters;

   585  @endcode

   586  - Arg 1: [in]  database file name | config string

   587  - Arg 2: [in]  file session handle

   588  - Arg 3: [in]  database file handle

   589 

   590 @panic SqlDb 1 Client panic. iDatabase is not NULL (it has been created already)

   591 */

   592 void CSqlSrvSession::DbCreateObjectFromHandleL(const RMessage2& aMessage)

   593 	{

   594 	__SQLPANIC_CLIENT(!iDatabase, aMessage, ESqlPanicObjExists);

   595 	const TBool KReadOnly = (aMessage.Int0() & 0x80000000) != 0;

   596 	const TBool KCreated = (aMessage.Int0() & 0x40000000) != 0;

   597 	const TInt KDbFileNameLen = aMessage.Int0() & 0x0000FFFF;

   598 	const TInt KConfigStringLen = (aMessage.Int0() & 0x3FFF0000) >> 16;

   599 	if(KConfigStringLen < 0 || KConfigStringLen > KSqlSrvMaxConfigStrLen)

   600 		{

   601 		__SQLLEAVE(KErrArgument);	

   602 		}

   603 	if(KDbFileNameLen < 1 || KDbFileNameLen > KMaxFileName)

   604 		{

   605 		__SQLLEAVE(KErrBadName);

   606 		}

   607 	TDes16& buffer = Server().GetBuf16L(KDbFileNameLen + KConfigStringLen);

   608 	aMessage.ReadL(1, buffer);

   609 	SQLPROFILER_REPORT_IPC(ESqlIpcRead, ((KDbFileNameLen + KConfigStringLen) * sizeof(TText)));

   610 	TFileName dbFileName;

   611 	dbFileName.Copy(buffer.LeftTPtr(KDbFileNameLen));

   612 	TBuf8<KSqlSrvMaxConfigStrLen> configStr;

   613 	if(KConfigStringLen > 0)

   614 		{

   615 		configStr.Copy(buffer.MidTPtr(KDbFileNameLen, KConfigStringLen));

   616 		}

   617 	TSqlSrvFileData& fileData = Server().FileData();

   618 	fileData.SetFromHandleL(aMessage, dbFileName, KCreated, KReadOnly, &configStr);

   619 	iDrive = fileData.Drive();

   620 	iDatabase = CSqlSrvDatabase::OpenL(fileData);

   621 	}

   622 

   623 /**

   624 Processes the request for copying a database.

   625 

   626 Only the database creator can copy the database if the database is a secure database.

   627 

   628 Usage of the IPC call arguments:

   629 Arg 0: [in]  source database file name length

   630 Arg 1: [in]  source database file name

   631 Arg 2: [in]  destination database file name length

   632 Arg 3: [in]  destination database file name

   633 */

   634 void CSqlSrvSession::DbCopyFileL(const RMessage2& aMessage)

   635 	{

   636 	const TInt KDbCnt = 2;											//"2" - because we have 2 dbases: src and dest

   637 	const TInt KSrcDbIdx = 0;

   638 	const TInt KDestDbIdx = 1;

   639 	TInt fileNameLen[KDbCnt] = {aMessage.Int0(), aMessage.Int2()};

   640 	TSqlSrvFileData& fileData = Server().FileData();

   641 	TUint dbSecureFlag[KDbCnt];

   642 	TUid  dbSID[KDbCnt] = {KNullUid, KNullUid};

   643 	TFileName dbFileName[KDbCnt];

   644 	//Initialize dbSecureFlag[], dbSID[] and dbFileName[] array elements

   645 	for(TInt i=0;i<KDbCnt;++i)									

   646 		{

   647 		fileData.SetL(aMessage, fileNameLen[i], i * KDbCnt + 1);	//"i * KDbCnt + 1" is the RMessage2 parameter number: 1 for src db, 3 for dest db

   648 		dbSecureFlag[i] = fileData.IsSecureFileNameFmt() ? 1 : 0;

   649 		if(dbSecureFlag[i])

   650 			{

   651 			dbSID[i] = fileData.SecureUid();

   652 			}

   653 		dbFileName[i].Copy(fileData.FileName());

   654 		}

   655 	//It is not allowed to copy non-secure to a secure or secure to a non-secure database.

   656 	if(dbSecureFlag[KSrcDbIdx] ^ dbSecureFlag[KDestDbIdx])

   657 		{

   658 		__SQLLEAVE(KErrPermissionDenied);	

   659 		}

   660 	//If this is a secure database "copy" operation, then...

   661 	if(dbSecureFlag[KSrcDbIdx])

   662 		{

   663 		TUid callerSid = aMessage.SecureId();

   664 		//A secure database can be copied only by its owner (database SID matches caller SID).

   665 		if(callerSid != dbSID[KSrcDbIdx] || callerSid != dbSID[KDestDbIdx])

   666 			{

   667 			__SQLLEAVE(KErrPermissionDenied);	

   668 			}

   669 		}

   670 	//Copy the database

   671 	CFileMan* fileMan = CFileMan::NewL(fileData.Fs());

   672 	CleanupStack::PushL(fileMan);

   673 	__SQLLEAVE_IF_ERROR(fileMan->Copy(dbFileName[KSrcDbIdx], dbFileName[KDestDbIdx]));

   674 	//"Copy" operation executed without errors. Now it is a time to turn off the read-only

   675 	//flag of the target file (which may be on if the source file is on a read-only drive)

   676 	__SQLLEAVE_IF_ERROR(fileData.Fs().SetAtt(dbFileName[KDestDbIdx], 0, KEntryAttReadOnly));

   677 	CleanupStack::PopAndDestroy(fileMan);

   678 	}

   679 

   680 /**

   681 Processes the request for deleting a database.

   682 

   683 Only the database creator can delete the database if the database is a secure database.

   684 

   685 Usage of the IPC call arguments:

   686 Arg 0: [in]  database file name length

   687 Arg 1: [in]  database file name

   688 */

   689 void CSqlSrvSession::DbDeleteFileL(const RMessage2& aMessage)

   690 	{	

   691 	TSqlSrvFileData& fileData = Server().FileData();

   692 	fileData.SetL(aMessage, aMessage.Int0(), 1);

   693 	if(fileData.IsSecureFileNameFmt())

   694 		{

   695 		//A secure database can be deleted only by its owner (database SID matches caller SID).

   696 		if(fileData.SecureUid() != aMessage.SecureId())

   697 			{

   698 			__SQLLEAVE(KErrPermissionDenied);	

   699 			}

   700 		}

   701 	#ifdef _NOTIFY

   702 	TPtrC fname = fileData.FileName();

   703 	RDebug::Print(_L("--SrvSess, delete, fname=\"%S\"\r\n"), &fname);

   704 	#endif		

   705 	__SQLLEAVE_IF_ERROR(fileData.Fs().Delete(fileData.FileName()));

   706 	}

   707 

   708 /**

   709 Processes the request for retrieving the last error message.

   710 

   711 If the client side buffer size is not big enough, the function returns the needed 

   712 buffer size + KSqlClientBufOverflowCode.

   713 In this case the client must increase the buffer and try again to get the message.

   714 

   715 Usage of the IPC call arguments:

   716 Arg 0: [in]		Message buffer length in 16-bit characters

   717 Arg 1: [in/out]	Message buffer

   718 

   719 @panic SqlDb 2 Client panic. iDatabase is NULL (the database object is not created yet).

   720 @panic SqlDb 4 Client panic. Negative client message buffer length (Arg 0).

   721 */

   722 TInt CSqlSrvSession::DbLastErrorMessageL(const RMessage2& aMessage)

   723 	{

   724 	__SQLPANIC_CLIENT(iDatabase != NULL, aMessage, ESqlPanicInvalidObj);

   725 	TPtrC msg = iDatabase->LastErrorMessage();

   726 	TInt msgLen = msg.Length();

   727 	TInt bufSize = aMessage.Int0();

   728 	__SQLPANIC_CLIENT(bufSize >= 0, aMessage, ESqlPanicBadArgument);

   729 	if(msgLen <= bufSize)

   730 		{

   731 		aMessage.WriteL(1, msg);

   732 		SQLPROFILER_REPORT_IPC(ESqlIpcWrite, (msgLen * sizeof(TText)));

   733 		return 0;

   734 		}

   735 	return msgLen + KSqlClientBufOverflowCode;

   736 	}

   737 	

   738 /**

   739 Processes the request for retrieving the last inserted ROWID of this database connection.

   740 

   741 Usage of the IPC call arguments:

   742 Arg 0: [in/out]	Receiving buffer

   743 

   744 @panic SqlDb 2 Client panic. The database object is not yet created yet (iDatabase is NULL).

   745 */

   746 void CSqlSrvSession::DbLastInsertedRowIdL(const RMessage2& aMessage)

   747 	{

   748 	__SQLPANIC_CLIENT(iDatabase != NULL, aMessage, ESqlPanicInvalidObj);

   749 	TInt64 rowid = iDatabase->LastInsertedRowId();

   750 	aMessage.WriteL(0, TPtrC8(reinterpret_cast <const TUint8*> (&rowid), sizeof(rowid)));

   751 	SQLPROFILER_REPORT_IPC(ESqlIpcWrite, sizeof(rowid));

   752 	}

   753 

   754 /**

   755 Processes the request for retrieving the database security policies.

   756 

   757 The method leaves with KErrNotSupported if the database is not a secure database.

   758 

   759 If the client side buffer size is not big enough, the function returns the needed 

   760 buffer size + KSqlClientBufOverflowCode.

   761 In this case the client must increase the buffer and try again to get the database security policy.

   762 

   763 Usage of the IPC call arguments:

   764 Arg 0: [in]		security policy buffer length in bytes

   765 Arg 1: [in/out]	buffer for the database security policies

   766 

   767 @panic SqlDb 2 Client panic. iDatabase is NULL (the database object is not created yet).

   768 */

   769 TInt CSqlSrvSession::DbGetSecurityPolicyL(const RMessage2& aMessage)

   770 	{

   771 	__SQLPANIC_CLIENT(iDatabase != NULL, aMessage, ESqlPanicInvalidObj);

   772 	const CSqlSecurityPolicy* securityPolicy = iDatabase->SecurityPolicy();

   773 	if(!securityPolicy)

   774 		{

   775 		__SQLLEAVE(KErrNotSupported);

   776 		}

   777 	const RSqlBufFlat& bufFlat = securityPolicy->BufFlat();

   778 	TInt size = bufFlat.Size();

   779 	if(size <= aMessage.Int0())

   780 		{

   781 		aMessage.WriteL(1, bufFlat.BufDes());

   782 		SQLPROFILER_REPORT_IPC(ESqlIpcWrite, size);

   783 		return 0;

   784 		}

   785 	return size + KSqlClientBufOverflowCode;

   786 	}

   787 

   788 /**

   789 If an error occurs during the execution the function leaves with the error code.

   790 Possible non-leaving return values:

   791  - KErrNone              - the function has completed successfully;

   792  - Positive return value - the length of the column, which means - the destination buffer is too small.

   793                            This return value is possible only with text or binary columns.

   794 

   795 @panic SqlDb 2 Client panic. iDatabase is NULL (the database object is not created yet).

   796 

   797 Usage of the IPC call arguments: 

   798 Arg 0: [in]		(8/16-bit character length of SQL statement) | (expected column value type << 24).

   799 Arg 1: [in]		SQL statement.

   800 Arg 2: [in]		Byte max length of the receiving buffer

   801 Arg 3: [in/out]	The receiving buffer

   802 */

   803 TInt CSqlSrvSession::DbScalarFullSelectL(const RMessage2& aMessage, TBool aIsText16)

   804 	{

   805 	__SQLPANIC_CLIENT(iDatabase != NULL, aMessage, ESqlPanicInvalidObj);

   806 	TUint sqlLen = static_cast <TUint> (aMessage.Int0()) & 0x00FFFFFF;

   807 	TSqlColumnType  colType = static_cast <TSqlColumnType> ((static_cast <TUint> (aMessage.Int0()) & 0xFF000000) >> 24);

   808 	TInt columnCount = -1;

   809 	TInt paramCount = -1;

   810 	CSqlSrvStatement*  stmt = aIsText16 ? 

   811 								CSqlSrvStatement::NewLC(iDatabase->RawDbHandle(), ReadString16ZL(aMessage, 1, sqlLen), columnCount, paramCount) :

   812 								CSqlSrvStatement::NewLC(iDatabase->RawDbHandle(), ReadString8ZL(aMessage, 1, sqlLen), columnCount, paramCount);

   813 	if(columnCount != 1 || paramCount != 0)

   814 		{

   815 		__SQLLEAVE(KErrArgument);	

   816 		}

   817 	TInt err = stmt->Next();

   818 	if(err == KSqlAtRow)

   819 		{

   820 		err = GetColumnValueL(aMessage, *stmt, colType);

   821 		}

   822 	else

   823 		{

   824 		__SQLLEAVE(err == KSqlAtEnd ? KErrNotFound : err);

   825 		}

   826 	CleanupStack::PopAndDestroy(stmt);

   827 	return err;

   828 	}

   829 

   830 /**

   831 @return True, if the database is in transaction, false otherwise.

   832 

   833 @panic SqlDb 2 Client panic. iDatabase is NULL (the database object is not created yet).

   834 */

   835 TBool CSqlSrvSession::DbInTransaction(const RMessage2& aMessage)

   836 	{

   837 	__SQLPANIC_CLIENT(iDatabase != NULL, aMessage, ESqlPanicInvalidObj);

   838 	return iDatabase->InTransaction();

   839 	}

   840 

   841 /**

   842 Main database size in bytes.

   843 

   844 @return Main database size in bytes.

   845 

   846 @leave KErrNoMemory, an out of memory condition has occurred,

   847                      Note that the function may also leave with some other system wide errors or 

   848                      database specific errors categorised as ESqlDbError,

   849 	   KErrTooBig,   The database is very big and the size cannot fit in a 32-bit signed integer.

   850 

   851 @panic SqlDb 2 Client panic. iDatabase is NULL (the database object is not created yet).

   852 */

   853 TInt CSqlSrvSession::DbSizeL(const RMessage2& aMessage)

   854 	{

   855 	__SQLPANIC_CLIENT(iDatabase != NULL, aMessage, ESqlPanicInvalidObj);

   856 	TInt64 size = iDatabase->SizeL();

   857 	if(size > KMaxTInt)

   858 		{

   859 		__SQLLEAVE(KErrTooBig);

   860 		}

   861 	return size;

   862 	}

   863 

   864 /**

   865 Retrieves the database size and free space.

   866 

   867 Usage of the IPC call arguments:

   868 Arg 0: [in/out]	Points to a RSqlDatabase::TSize object, where the database size and free space values

   869 			    will be copied.

   870 Arg 1: [in]		The database name length in 16-bit characters

   871 Arg 2: [in]		The attached database name or KNullDesC for the main database

   872 

   873 @leave KErrNoMemory, an out of memory condition has occurred,

   874                      Note that the function may also leave with some other system wide errors or 

   875                      database specific errors categorised as ESqlDbError.

   876        KErrBadName, Invalid database name

   877 

   878 @panic SqlDb 2 Client panic. iDatabase is NULL (the database object is not created yet).

   879 */

   880 void CSqlSrvSession::DbSize2L(const RMessage2& aMessage)

   881 	{

   882 	__SQLPANIC_CLIENT(iDatabase != NULL, aMessage, ESqlPanicInvalidObj);

   883 	const TInt KDbNameLen = aMessage.Int1();

   884 	if(KDbNameLen < 0 || KDbNameLen > KMaxFileName)

   885 		{

   886 		__SQLLEAVE(KErrBadName);

   887 		}

   888 	TPtrC dbName(KNullDesC);

   889 	if(KDbNameLen > 0)

   890 		{

   891 		dbName.Set(ReadString16L(aMessage, 2, KDbNameLen));

   892 		}

   893 	TPckgBuf<RSqlDatabase::TSize> data;

   894 	data().iSize = iDatabase->SizeL(dbName);

   895 	data().iFree = iDatabase->FreeSpaceL(dbName);

   896 	aMessage.WriteL(0, data);

   897 	SQLPROFILER_REPORT_IPC(ESqlIpcWrite, sizeof(RSqlDatabase::TSize));

   898 	}

   899 

   900 /**

   901 Runs database compaction.

   902 

   903 Usage of the IPC call arguments:

   904 Arg 0: [in]	    How much space in bytes should be compacted, all free pages should be removed if the

   905 				parameter value is RSqlDatabase::EMaxCompaction.

   906 				Note that the requested space to be compacted will be rounded up to the nearest page count,

   907 				e.g. request for removing 1 byte will remove one free page from the database file. 

   908 Arg 1: [in]		The database name length in characters

   909 Arg 2: [in]		The attached database name or KNullDesC for the main database

   910 

   911 @return The size of the removed free space

   912 

   913 @panic SqlDb 2 Client panic. iDatabase is NULL (the database object is not created yet).

   914 */

   915 TInt CSqlSrvSession::DbCompactL(const RMessage2& aMessage)

   916 	{

   917 	__SQLPANIC_CLIENT(iDatabase != NULL, aMessage, ESqlPanicInvalidObj);

   918 	const TInt KSize = aMessage.Int0();

   919 	if(KSize < 0)

   920 		{

   921 		if(KSize != RSqlDatabase::EMaxCompaction)

   922 			{

   923 			__SQLLEAVE(KErrArgument);

   924 			}

   925 		}

   926 	if(KSize == 0)

   927 		{

   928 		return 0;	

   929 		}

   930 	const TInt KDbNameLen = aMessage.Int1();

   931 	if(KDbNameLen < 0 || KDbNameLen > KMaxFileName)

   932 		{

   933 		__SQLLEAVE(KErrBadName);

   934 		}

   935 	TPtrC dbName(KNullDesC);

   936 	if(KDbNameLen > 0)

   937 		{

   938 		dbName.Set(ReadString16L(aMessage, 2, KDbNameLen));

   939 		}

   940 	return iDatabase->CompactL(KSize, dbName);

   941 	}

   942 	

   943 /**

   944 Usage of the IPC call arguments:

   945 Arg 0: [in]		requested size of the space to be reserved - not used

   946 

   947 The function leaves with KErrAlreadyExists if a drive space has been reserved already by this session.

   948 */

   949 void CSqlSrvSession::DbReserveDriveSpaceL()

   950 	{

   951 	if(iDriveSpaceReserved)

   952 		{

   953 		__SQLLEAVE(KErrAlreadyExists);

   954 		}

   955 	RSqlDriveSpaceCol& driveSpaceCol = Server().DriveSpaceCol();

   956     if(!driveSpaceCol.Find(iDrive))

   957     	{

   958     	(void)driveSpaceCol.AddL(iDrive);

   959     	}

   960 	

   961 	iDriveSpaceReserved = ETrue;

   962 	//Only iDriveSpaceReserved is set, nothing more needs to be done, because RSqlDriveSpaceCol::AddL() will

   963 	//reserve a drive space on the specified drive.

   964 	//Although it looks like that the implementation can ommit "iDriveSpaceReserved" flag, this flag plays important

   965 	//role, because it is used to ensure that every "reserve drive space" request is matched by a "free drive space"

   966 	//call.

   967 	}

   968 	

   969 /**

   970 If the client has been given an access to the reserved drive space, that access will be released.

   971 */

   972 void CSqlSrvSession::DbFreeReservedSpace()

   973 	{

   974 	DbReleaseReserveAccess();

   975 	iDriveSpaceReserved = EFalse;

   976 	}

   977 	

   978 /**

   979 The function leaves with KErrInUse if an access to the reserved drive space has been given to the client.

   980 The function leaves with KErrNotFound if no drive space has been reserved for the drive, where the database file is.

   981 */

   982 void CSqlSrvSession::DbGetReserveAccessL()

   983 	{

   984 	if(iDriveSpaceInUse)

   985 		{

   986 		__SQLLEAVE(KErrInUse);	

   987 		}

   988 	if(!iDriveSpaceReserved)

   989 		{

   990 		__SQLLEAVE(KErrNotFound);

   991 		}

   992 	CSqlDriveSpace* driveSpace = Server().DriveSpaceCol().Find(iDrive);

   993    	if(!driveSpace)

   994    		{

   995 		__SQLLEAVE(KErrNotFound);

   996    		}

   997    	driveSpace->GetAccessL();

   998    	iDriveSpaceInUse = ETrue;

   999 	}

  1000 	

  1001 /**

  1002 Releases the drive space reserve if it has been in use by this session (resp. client).

  1003 */

  1004 void CSqlSrvSession::DbReleaseReserveAccess()

  1005 	{

  1006 	if(iDriveSpaceInUse)

  1007 		{

  1008 		CSqlDriveSpace* driveSpace = Server().DriveSpaceCol().Find(iDrive);

  1009 		if(driveSpace)

  1010 			{

  1011    			driveSpace->ReleaseAccess();

  1012 			}

  1013    		iDriveSpaceInUse = EFalse;

  1014 		}

  1015 	}

  1016 

  1017 /**

  1018 Processes the request for attaching a secure or non-secure database.

  1019 

  1020 Usage of the IPC call arguments: 

  1021 Arg 0: [in]	Database file name length (counted in 16-bit characters).

  1022 Arg 1: [in]	Database file name.

  1023 Arg 2: [in]	Logical database name length (counted in 16-bit characters).

  1024 Arg 3: [in]	Logical database name.

  1025 

  1026 @panic SqlDb 2 Client panic. iDatabase is NULL (the database object is not created yet).

  1027 */

  1028 void CSqlSrvSession::DbAttachL(const RMessage2& aMessage)

  1029 	{

  1030 	__SQLPANIC_CLIENT(iDatabase != NULL, aMessage, ESqlPanicInvalidObj);

  1031 	TSqlSrvFileData& fileData = Server().FileData();

  1032 	fileData.SetL(aMessage, aMessage.Int0(), 1);

  1033 	TInt logicalDbNameLen = aMessage.Int2();

  1034 	if(logicalDbNameLen < 1 || logicalDbNameLen > KMaxFileName)

  1035 		{

  1036 		__SQLLEAVE(KErrBadName);

  1037 		}

  1038 	iDatabase->AttachDbL(fileData, ReadString16L(aMessage, 3, logicalDbNameLen));

  1039 	}

  1040 

  1041 /**

  1042 Processes the request for attaching a database using file session and file handles sent by the client.

  1043 

  1044 Usage of the IPC call arguments:

  1045  - Arg 0: [in]  The 32 bits of the argument are used as follow:

  1046  @code

  1047  MSB                                                                                 LSB

  1048  31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0

  1049  Ro  F  F  F  F  F  F  F  F  F  F  F  F  F  F  F  F  F  F  F  F  F F F F F F F F F F F

  1050  @endcode

  1051  Where:

  1052  @code

  1053   - "Ro" - read-only flag, true if the file is read-only;

  1054   - "F"  - database file name length in 16-bit characters;

  1055  @endcode

  1056 Arg 1: [in]  db names buffer

  1057 Arg 2: [in]  file session handle

  1058 Arg 3: [in]  database file handle

  1059 

  1060 @panic SqlDb 2 Client panic. iDatabase is NULL (the database object is not created yet).

  1061 */

  1062 void CSqlSrvSession::DbAttachFromHandleL(const RMessage2& aMessage)

  1063 	{

  1064 	__SQLPANIC_CLIENT(iDatabase != NULL, aMessage, ESqlPanicInvalidObj);

  1065 	//Read-only flag, buffer length, buffer allocation

  1066 	TBool readOnly = (aMessage.Int0() & 0x80000000) != 0;

  1067 	const TInt KBufLen = aMessage.Int0() & 0x7FFFFFFF;

  1068 	if(KBufLen <= 0)

  1069 		{

  1070 		__SQLLEAVE(KErrArgument);

  1071 		}

  1072 	HBufC8* buf = HBufC8::NewLC(KBufLen);

  1073 	TPtr8 bufPtr = buf->Des();

  1074 	aMessage.ReadL(1, bufPtr);

  1075 	SQLPROFILER_REPORT_IPC(ESqlIpcRead, KBufLen);

  1076 	if(KBufLen != bufPtr.Length())

  1077 		{

  1078 		__SQLLEAVE(KErrArgument);

  1079 		}

  1080 	RDesReadStream in(bufPtr);

  1081 	TDes& dbFileName = Server().FileNameBuf();

  1082 	TDes16& dbName = Server().GetBuf16L(KMaxFileName);

  1083 	in >> dbFileName;

  1084 	in >> dbName;

  1085 	CleanupStack::PopAndDestroy(buf);

  1086 	TSqlSrvFileData& fileData = Server().FileData();

  1087 	fileData.SetFromHandleL(aMessage, dbFileName, EFalse, readOnly);

  1088 	iDatabase->AttachDbL(fileData, dbName);

  1089 	}

  1090 	

  1091 /**

  1092 Processes the request for detaching a secure or non-secure database.

  1093 

  1094 Usage of the IPC call arguments: 

  1095 Arg 0: [in]	Logical database name length (counted in 16-bit characters).

  1096 Arg 1: [in]	Logical database name.

  1097 

  1098 @panic SqlDb 2 Client panic. iDatabase is NULL (the database object is not created yet).

  1099 */

  1100 void CSqlSrvSession::DbDetachL(const RMessage2& aMessage)

  1101 	{

  1102 	__SQLPANIC_CLIENT(iDatabase != NULL, aMessage, ESqlPanicInvalidObj);

  1103 	TInt logicalDbNameLen = aMessage.Int0();

  1104 	if(logicalDbNameLen < 1 || logicalDbNameLen > KMaxFileName)

  1105 		{

  1106 		__SQLLEAVE(KErrBadName);

  1107 		}

  1108 	iDatabase->DetachDbL(ReadString16L(aMessage, 1, logicalDbNameLen));

  1109 	}

  1110 

  1111 /**

  1112 Reads a 16-bit string from the specified stream and returns it in zero-terminated

  1113 8-bit format in aNameOut.

  1114 If the string is of zero length then the substitute string provided will be used instead.

  1115 

  1116 @param aStrm 				The read stream

  1117 @param aNameOut 			The output parameter that will contain the string read

  1118 @param aEmptyNameSubstitute The substitute string to use if the string to be read from

  1119 							the stream is zero length

  1120 

  1121 @leave KErrNoMemory, 		 An out of memory condition has occurred;

  1122 	   KErrArgument, 		 The UTF-16 to UTF-8 string conversion failed;	

  1123 	   KErrBadName,	 		 The string has an invalid length;

  1124 */

  1125 void CSqlSrvSession::ExtractNameL(RDesReadStream& aStrm, TDes8& aNameOut, const TDesC& aEmptyNameSubstitute)

  1126 	{

  1127 	 TBool replace = EFalse;

  1128 	 TInt32 len;

  1129 	 aStrm >> len;

  1130 

  1131 	 if(len == 0)

  1132 	 	{

  1133 	   	if(aEmptyNameSubstitute.Length() > 0)

  1134 			{