1 /*

     2 * Copyright (c) 2008-2009 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 the License "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: 

    15 * Implements CStsServer.

    16 *

    17 */

    18 

    19 

    20 /**

    21  @file

    22  @internalComponent

    23  @released

    24 */

    25 

    26 #include "stsserver.h"

    27 #include "stsserversession.h"

    28 #include <random.h>

    29 #include <e32cmn.h>

    30 #include <e32std.h>

    31 #include <usif/sts/stsdefs.h>

    32 #include "usiflog.h"

    33 

    34 namespace Usif

    35 {

    36 

    37 CStsServerSession::CStsServerSession(CStsServer& aStsserver)

    38 	: CScsSession(static_cast<CScsServer &>(aStsserver))

    39 	{

    40 	}

    41 

    42 CStsServerSession::~CStsServerSession()

    43 	{

    44 	if (iTransactionPtr)

    45 		TRAP_IGNORE(static_cast<CStsServer*>(&iServer)->ReleaseTransactionL(iTransactionPtr));

    46 	}

    47 

    48 CStsServerSession* CStsServerSession::NewL(CStsServer &aServer, const RMessage2& /*aMessage*/)

    49 	{

    50 	CStsServerSession* self = new (ELeave) CStsServerSession(aServer);

    51 	CleanupStack::PushL(self);

    52 	self->ConstructL();

    53 	CleanupStack::Pop(self);

    54 	return self;

    55 	}

    56 

    57 void CStsServerSession::ConstructL()

    58 	{

    59 	CScsSession::ConstructL();

    60 	}

    61 

    62 

    63 _LIT(KStsPanicCategory, "StsServer");

    64 static const TInt KInvalidMessagePanicCode = KErrArgument;

    65 

    66 TBool CStsServerSession::DoServiceL(TInt aFunction, const RMessage2& aMessage)

    67 	{

    68 	DEBUG_PRINTF2(_L("CStsServerSession::DoServiceL() - Function %d"), static_cast<TStsClientServerFunctionType>(aFunction));							

    69 

    70 	TBool ret = ETrue; //used in CScsSession::ServiceL(); if set to ETRue >> aMessage.Complete(KErrNone); is executed

    71 	TStsTransactionId transactionID;

    72 	TPckg<TStsTransactionId> idPkg(transactionID);

    73 	RBuf buf;

    74 	CStsServer* server=static_cast<CStsServer*>(&iServer);

    75 	

    76 	switch(static_cast<TStsClientServerFunctionType>(aFunction))

    77 		{

    78 		case ECreateTransaction:

    79 			{

    80 			if(iTransactionPtr)

    81 				{

    82 				User::Leave(KErrInUse);

    83 				}

    84 			iTransactionPtr = server->CreateTransactionL();

    85 			transactionID = iTransactionPtr->TransactionId();

    86 			aMessage.WriteL(KIdIPCSlot, idPkg);

    87 			break;

    88 			}

    89 		case EOpenTransaction:

    90 			{

    91 			if(iTransactionPtr)

    92 				{

    93 				User::Leave(KErrInUse);

    94 				}

    95 			aMessage.ReadL(KIdIPCSlot, idPkg, 0);

    96 			iTransactionPtr = server->AttachTransactionL(transactionID);

    97 			break;

    98 			}

    99 		case ERegisterNew:

   100 			{

   101 			__ASSERT_ALWAYS(iTransactionPtr, aMessage.Panic(KStsPanicCategory, KInvalidMessagePanicCode));

   102 			buf.CreateL(KMaxFileName);

   103 			buf.CleanupClosePushL();

   104 			aMessage.ReadL(KFilePathIPCSlot, buf, 0);

   105 			iTransactionPtr->RegisterNewL(buf);

   106 			CleanupStack::PopAndDestroy(&buf);

   107 			break;

   108 			}

   109 		case ECreateNew:

   110 			{

   111 			__ASSERT_ALWAYS(iTransactionPtr, aMessage.Panic(KStsPanicCategory, KInvalidMessagePanicCode));			

   112 			// Taking the filename size from the IPC Arguments

   113 			// No need to do any validation of filename as it is done by File Server

   114 			TInt srcFileNameLen = aMessage.GetDesLengthL(KFilePathIPCSlot);

   115 			buf.CreateL(srcFileNameLen);

   116 			buf.CleanupClosePushL();

   117 			aMessage.ReadL(KFilePathIPCSlot, buf, 0);

   118 			TPckgBuf<TFileMode> pkgFileMode;

   119 			aMessage.ReadL(KFileModeIPCSlot, pkgFileMode, 0);

   120 			RFile newFile;

   121 			CleanupClosePushL(newFile);

   122 			iTransactionPtr->CreateNewL(buf, newFile, pkgFileMode());

   123 	        User::LeaveIfError(newFile.TransferToClient(aMessage, KFileHandleIPCSlot));

   124 	        ASSERT(aMessage.IsNull());  // message should have been completed

   125 	        ret = EFalse; //message need not be completed in CScsSession::ServiceL()

   126 			CleanupStack::PopAndDestroy(2, &buf);

   127 			break;

   128 			}

   129 		case ERemove:

   130 			{

   131 			__ASSERT_ALWAYS(iTransactionPtr, aMessage.Panic(KStsPanicCategory, KInvalidMessagePanicCode));			

   132 			buf.CreateL(KMaxFileName);

   133 			buf.CleanupClosePushL();

   134 			aMessage.ReadL(KFilePathIPCSlot, buf, 0);

   135 			iTransactionPtr->RemoveL(buf);

   136 			CleanupStack::PopAndDestroy(&buf);

   137 			break;

   138 			}

   139 		case ERegisterTemporary:

   140 			{

   141 			__ASSERT_ALWAYS(iTransactionPtr, aMessage.Panic(KStsPanicCategory, KInvalidMessagePanicCode));			

   142 			buf.CreateL(KMaxFileName);

   143 			buf.CleanupClosePushL();

   144 			aMessage.ReadL(KFilePathIPCSlot, buf, 0);

   145 			iTransactionPtr->RegisterTemporaryL(buf);

   146 			CleanupStack::PopAndDestroy(&buf);

   147 			break;

   148 			}

   149 		case ECreateTemporary:

   150 			{

   151 			__ASSERT_ALWAYS(iTransactionPtr, aMessage.Panic(KStsPanicCategory, KInvalidMessagePanicCode));			

   152 			// Taking the filename size from the IPC Arguments

   153 			// No need to do any validation of filename as it is done by File Server

   154 			TInt srcFileNameLen = aMessage.GetDesLengthL(KFilePathIPCSlot);

   155 			buf.CreateL(srcFileNameLen);

   156 			buf.CleanupClosePushL();

   157 			aMessage.ReadL(KFilePathIPCSlot, buf, 0);

   158 			TPckgBuf<TFileMode> pkgFileMode;

   159 			aMessage.ReadL(KFileModeIPCSlot, pkgFileMode, 0);

   160 			RFile newTempFile;

   161 			CleanupClosePushL(newTempFile);

   162 			iTransactionPtr->CreateTemporaryL(buf, newTempFile, pkgFileMode());

   163 	        User::LeaveIfError(newTempFile.TransferToClient(aMessage, KFileHandleIPCSlot));

   164 	        ASSERT(aMessage.IsNull());  // message should have been completed

   165 	        ret = EFalse; //message need not be completed in CScsSession::ServiceL()

   166 			CleanupStack::PopAndDestroy(2, &buf);

   167 			break;

   168 			}

   169 		case EOverwrite:

   170 			{

   171 			__ASSERT_ALWAYS(iTransactionPtr, aMessage.Panic(KStsPanicCategory, KInvalidMessagePanicCode));			

   172 			buf.CreateL(KMaxFileName);

   173 			buf.CleanupClosePushL();

   174 			aMessage.ReadL(KFilePathIPCSlot, buf, 0);

   175 			TPckgBuf<TFileMode> pkgFileMode;

   176 			aMessage.ReadL(KFileModeIPCSlot, pkgFileMode, 0);

   177 			RFile newFile;

   178 			CleanupClosePushL(newFile);

   179 			iTransactionPtr->OverwriteL(buf, newFile, pkgFileMode());

   180 	        User::LeaveIfError(newFile.TransferToClient(aMessage, KFileHandleIPCSlot));

   181 	        ASSERT(aMessage.IsNull());  // message should have been completed

   182 	        ret = EFalse; //message need not be completed in CScsSession::ServiceL()

   183 			CleanupStack::PopAndDestroy(2, &buf);

   184 			break;

   185 			}

   186 		case ECommit:

   187 			{

   188 			__ASSERT_ALWAYS(iTransactionPtr, aMessage.Panic(KStsPanicCategory, KInvalidMessagePanicCode));

   189 			iTransactionPtr->CommitL(); 

   190 			server->FinaliseTransactionL(iTransactionPtr); //releases transaction and erases pointer!

   191 			break;

   192 			}

   193 		case ERollBack:

   194 			{

   195 			__ASSERT_ALWAYS(iTransactionPtr, aMessage.Panic(KStsPanicCategory, KInvalidMessagePanicCode));

   196 			iTransactionPtr->RollBackL();

   197 			server->FinaliseTransactionL(iTransactionPtr); //releases transaction and erases pointer!

   198 			break;

   199 			}

   200 		case EGetId:

   201 			{

   202 			__ASSERT_ALWAYS(iTransactionPtr, aMessage.Panic(KStsPanicCategory, KInvalidMessagePanicCode));

   203 			transactionID = iTransactionPtr->TransactionId();

   204 			//return ID back to client

   205 			aMessage.WriteL(KIdIPCSlot, idPkg);

   206 			break;

   207 			}

   208 		case ERollBackAllPending:

   209 			{

   210 			server->RollBackAllPendingL();

   211 			break;

   212 			}

   213 		default:

   214 			{

   215 			User::Leave(KErrNotSupported);

   216 			break;

   217 			}

   218 		}

   219 	return ret; 

   220 	}

   221 }//end of namespace Usif