/*

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

* All rights reserved.

* This component and the accompanying materials are made available

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

* which accompanies this distribution, and is available

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

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:   Server implementation fo share files in application private gage 

*                with controlled way

*

*/

#include <e32std.h>

#include <f32file.h>

#include <e32math.h>

#include "ftokenserver.h"

#include "ftokenconsts.h"

void CFsTokenServer::NewLC()

    {

    CFsTokenServer* pS = new (ELeave) CFsTokenServer;

    CleanupStack::PushL(pS);

    pS->ConstructL();

    }

void CFsTokenServer::ConstructL()

    {

    User::LeaveIfError( iFs.Connect() );

    User::LeaveIfError( iFs.ShareProtected() );

    StartL(FTOKEN_SERVER_NAME);

    }

CSession2* CFsTokenServer::NewSessionL(const TVersion& /*aVersion*/,const RMessage2& /*aMessage*/) const

    {

	return new(ELeave) CFsTokenServerSession();   

    }

void CFsTokenServer::HandleClientExit(const CSession2* aClient)

    { // Todo: We could invent somekind notify here to notify 

      // possible user of a file to release its handle as well..

    for(TInt index = iTokens.Find(*aClient, TToken::CompareOwner); 

        index != KErrNotFound; 

        index = iTokens.Find(*aClient, TToken::CompareOwner) )

        {

        if (iTokens[index].iHasSubToken == 0)

            {

            delete iTokens[index].iFileName;

            }

        iTokens.Remove(index);

        }

    }

CFsTokenServer::~CFsTokenServer()

    {

    for(TInt count = iTokens.Count(); count > 0; count-- )

        {

        if (iTokens[0].iHasSubToken == 0)

            {

            delete iTokens[0].iFileName;

            }

        iTokens.Remove(0);

        }

    iFs.Close();

	iTokens.Close();

    }

void CFsTokenServer::AddTokenL(const RMessage2& aMessage)

    {

	HBufC* fileName = 0;

    TKeyArrayFix tokenKey(_FOFF(TToken, iToken), ECmpTInt64);	  	    

	TInt function = aMessage.Function();

	switch(aMessage.Function())

        {

        case EGenerateTokenBasedOnName:

        //==================================================

        // 1) filename

        //===================================================

           {

           User::Leave(KErrNotSupported);

/*                TInt msgLenght = aMessage.GetDesLength(1);

                if (length > 0)

                    {

                    fileName = HBufC::NewLC(length);

                    TPtr ptr = fileName->Des();

                    aMessage.Read(1,ptr);

                    if (iFs.IsValidName(ptr))

                        {

                        }

                    else

                        {

                        User::Leave(KErrArgument);

                        }

                    }

                else 

                    {

                    User::Leave(KErrArgument);

                    }    

*/	    

            break;

            }

        case EGenerateTokenBasedOnOpenHandle:

        //===================================================

        // 2) handle

        //===================================================

            {

            // 2.1) check that we are able to open the file	

            RFile file;

            User::LeaveIfError(file.AdoptFromClient(aMessage,2,3));

            // 2.2) resolve full filename

            TFileName fn;

            file.FullName(fn);

            file.Close();

            fileName = fn.AllocLC();

            break;

            }

        case EGenerateTokenBasedOnAnotherToken:

        // ==================================================        

        // 3) token

        //===================================================

            {

            TInt64 token = 0;

            TPckg<TInt64> buf(token); 

            // 3.1) just check that client uid and token match     

            aMessage.ReadL(1,buf);

            TInt index = iTokens.Find(token, TToken::CompareToken);

            User::LeaveIfError( index );

	        if (iTokens[index].iPolicy.CheckPolicy(aMessage))

	            {

	            // set a pointer to existing buffer, when deleting

	            // this must be handled slightly different way

                // but theres no need to spend lots of mem 

                // for duplicate filenames

                fileName = iTokens[index].iFileName;

                // there shouldn't be more than one subtoken per token ever 

                ASSERT(iTokens[index].iHasSubToken==EFalse);

                iTokens[index].iHasSubToken = ETrue;

                }

            else 

                {

                User::Leave(KErrPermissionDenied);

                }    

            break;

            }

        default:

            break;

        }

    // add token to array

    TInt64 newToken = User::NTickCount();

    for(newToken = Math::FRand(newToken);

        iTokens.Find(newToken, TToken::CompareToken) != KErrNotFound;

        newToken = User::NTickCount())

        {

        newToken = Math::FRand(newToken);

        }

    TToken entry;

    entry.iToken = newToken; 

    entry.iFileName = fileName;

    entry.iOwner = aMessage.Session();

    TPckg<TSecurityPolicy> policyBuf(entry.iPolicy);

    aMessage.ReadL(0, policyBuf);

    User::LeaveIfError(iTokens.Append(entry));

    if (function == EGenerateTokenBasedOnOpenHandle)

        {

        CleanupStack::Pop(); // filename

        }

    }

void CFsTokenServer::OpenFileL(const RMessage2& aMessage)

    {

	// find token based on client uid and given token 

    TInt64 token = 0;

    TPckg<TInt64> buf(token); 

    aMessage.ReadL(1,buf);

    TInt index = iTokens.Find(token, TToken::CompareToken);

	User::LeaveIfError(index);

	if (iTokens[index].iPolicy.CheckPolicy(aMessage))        

	    { // authorized client requests file 

        RFile file;

	    // Todo: what should the mode be ??

	    User::LeaveIfError(file.Open(iFs, *(iTokens[index].iFileName), EFileShareReadersOnly)); 

        CleanupClosePushL(file);

        User::LeaveIfError(file.TransferToClient(aMessage, 0));

        CleanupStack::PopAndDestroy(); //file

        }

    else 

        {

        User::Leave(KErrPermissionDenied);    

        } 

    }

CFsTokenServerSession::CFsTokenServerSession()

    {

    }

CFsTokenServerSession::~CFsTokenServerSession()

    {

    ((CFsTokenServer*)(Server()))->HandleClientExit(this);

    }

void CFsTokenServerSession::ServiceL(const RMessage2& aMessage)

    {

    CFsTokenServer* server = (CFsTokenServer*)( Server() );

    switch(aMessage.Function())

        {

        case EGenerateTokenBasedOnName:

        case EGenerateTokenBasedOnOpenHandle:

        case EGenerateTokenBasedOnAnotherToken:

            {

            server->AddTokenL(aMessage);

            break;

            }

        case EOpenHandleForToken:

            {

            server->OpenFileL(aMessage);

            // Todo: We could set somekind penalty to client that continuously

            // passes wrong tokens (i.e. seems to be guessing), e.g. panic it...

            break;

            }

        default:

            aMessage.Complete(KErrNotSupported);

            break;

        }

    if (!aMessage.IsNull())

        {

        aMessage.Complete(KErrNone);

        }

    }

static void RunServerL()

	{

    // Create Scheduler, obsolete nowdays ?

    CActiveScheduler* s=new(ELeave) CActiveScheduler;

    CleanupStack::PushL(s);

    CActiveScheduler::Install(s);

    CFsTokenServer::NewLC(); 

    RProcess::Rendezvous(KErrNone);

	CActiveScheduler::Start();

	CleanupStack::PopAndDestroy(2);	

	}

TInt E32Main()

	{

	TInt err = User::RenameThread(FTOKEN_SERVER_NAME);

    if ( err != KErrNone )

        {

        return err;

        }

    // create CCleanup

    CTrapCleanup * cleanup = CTrapCleanup::New();

    if (cleanup)

        {

        TRAP(err, RunServerL());

        delete cleanup;

        }

	return err;

	}