/*
* Copyright (c) 2009 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:
*
*/

#include "MemSpyDriverLogChanClientServer.h"

// System includes
#include <memspy/driver/memspydriverobjectsshared.h>

// Shared includes
#include "MemSpyDriverOpCodes.h"
#include "MemSpyDriverObjectsInternal.h"

// User includes
#include "MemSpyDriverUtils.h"
#include "MemSpyDriverOSAdaption.h"



DMemSpyDriverLogChanClientServer::DMemSpyDriverLogChanClientServer( DMemSpyDriverDevice& aDevice, DThread& aThread )
:   DMemSpyDriverLogChanContainerBase( aDevice, aThread )
    {
	TRACE( Kern::Printf("DMemSpyDriverLogChanChunks::DMemSpyDriverLogChanChunks() - this: 0x%08x", this ));
    }


DMemSpyDriverLogChanClientServer::~DMemSpyDriverLogChanClientServer()
	{
	TRACE( Kern::Printf("DMemSpyDriverLogChanClientServer::~DMemSpyDriverLogChanClientServer() - START - this: 0x%08x", this ));

	TRACE( Kern::Printf("DMemSpyDriverLogChanClientServer::~DMemSpyDriverLogChanClientServer() - END - this: 0x%08x", this ));
	}



TInt DMemSpyDriverLogChanClientServer::Request( TInt aFunction, TAny* a1, TAny* a2 )
	{
	TInt r = DMemSpyDriverLogChanContainerBase::Request( aFunction, a1, a2 );
    if  ( r == KErrNone )
        {
	    switch( aFunction )
		    {
	    case EMemSpyDriverOpCodeClientServerGetServerSessionHandles:
            r = GetServerSessionHandles( (TMemSpyDriverInternalServerSessionHandleParams*) a1 );
            break;
	    case EMemSpyDriverOpCodeClientServerGetServerSessionInfo:
            r = GetServerSessionInfo( a1, (TMemSpyDriverServerSessionInfo*) a2 );
            break;

        default:
            r = KErrNotSupported;
		    break;
		    }
        }
    //
    return r;
	}


TBool DMemSpyDriverLogChanClientServer::IsHandler( TInt aFunction ) const
    {
    return ( aFunction > EMemSpyDriverOpCodeClientServerBase && aFunction < EMemSpyDriverOpCodeClientServerEnd );
    }






TInt DMemSpyDriverLogChanClientServer::GetServerSessionHandles( TMemSpyDriverInternalServerSessionHandleParams* aParams )
	{
    TMemSpyDriverInternalServerSessionHandleParams params;
    TInt r = Kern::ThreadRawRead( &ClientThread(), aParams, &params, sizeof(TMemSpyDriverInternalServerSessionHandleParams) );
    if  ( r != KErrNone )
        {
    	TRACE( Kern::Printf("DMemSpyDriverLogChanClientServer::GetServerSessionHandles() - END - params read error: %d", r));
        return r;
        }

    DMemSpyDriverOSAdaptionDServer& serverAdaption = OSAdaption().DServer();

	const TInt maxCount = params.iMaxCount;
    NKern::ThreadEnterCS();

    DObject* serverHandle = (DObject*) params.iServerHandle;
    serverHandle = CheckIfObjectIsInContainer( EMemSpyDriverContainerTypeServer, serverHandle );
    if  ( serverHandle == NULL )
        {
    	Kern::Printf("DMemSpyDriverLogChanClientServer::GetServerSessionHandles() - END - server not found");
        NKern::ThreadLeaveCS();
        return KErrNotFound;
        }

	ResetTempHandles();

    DServer* server = (DServer*) serverHandle;
    NKern::LockSystem();

    r = server->Open();
    if  ( r == KErrNone )
        {
        // Iterate through this server's sessions, writing back session pointer (handle)
        // to client
        SDblQue& serverQueue = serverAdaption.GetSessionQueue( *server );
        SDblQueLink* anchor = &serverQueue.iA;
        SDblQueLink* link = serverQueue.First();
        while( link != anchor )
        	{
			DSession* session = serverAdaption.GetSession( link );

            // Found a match in the specified container. Write the object's handle (aka the object address)
            // back to the client address space
            if  ( session )
                {
                AddTempHandle( session );
                }

            // Get next item
            link = link->iNext;
            }

        NKern::ThreadEnterCS();
        TRACE( Kern::Printf("DMemSpyDriverLogChanClientServer::GetServerSessionHandles() - in CS..." ));
        //
	    Kern::SafeClose( (DObject*&) server, NULL );
        TRACE( Kern::Printf("DMemSpyDriverLogChanClientServer::GetServerSessionHandles() - done safe close..." ));
        //
	    NKern::ThreadLeaveCS();
        TRACE( Kern::Printf("DMemSpyDriverLogChanClientServer::GetServerSessionHandles() - left CS" ));
        }
    else
        {
    	Kern::Printf("DMemSpyDriverLogChanClientServer::GetServerSessionHandles - error: %d opening server", r);
        }

    NKern::UnlockSystem();

    // This variable holds the number of handles that we have already
	// written to the client-side.
	TInt currentWriteIndex = 0;
	const TInt handleCount = TempHandleCount();
    TRACE( Kern::Printf("DMemSpyDriverLogChanClientServer::GetServerSessionHandles - writing %d handles to client...", handleCount ) );
    for( ; currentWriteIndex<handleCount && r == KErrNone && currentWriteIndex < maxCount; )
        {
        TAny* handle = TempHandleAt( currentWriteIndex );
        r = Kern::ThreadRawWrite( &ClientThread(), params.iSessionHandles + currentWriteIndex, &handle, sizeof(TAny*) );
        if  (r == KErrNone)
            {
            ++currentWriteIndex;
            }
        }

	if  ( r == KErrBadDescriptor )
        {
        MemSpyDriverUtils::PanicThread( ClientThread(), EPanicBadDescriptor );
        }
    else
        {
        const TInt finalWrite = Kern::ThreadRawWrite( &ClientThread(), params.iSessionCountPtr, &currentWriteIndex, sizeof(TInt) );
        if  ( r == KErrNone )
            {
            r = finalWrite;
            }
        }

	NKern::ThreadLeaveCS();

	TRACE( Kern::Printf("DMemSpyDriverLogChanClientServer::GetServerSessionHandles() - END - r: %d", r));
	return r;
    }


TInt DMemSpyDriverLogChanClientServer::GetServerSessionInfo( TAny* aSessionHandle, TMemSpyDriverServerSessionInfo* aParams )
    {
    TMemSpyDriverServerSessionInfo params;
    TInt r = Kern::ThreadRawRead( &ClientThread(), aParams, &params, sizeof(TMemSpyDriverServerSessionInfo) );
    if  ( r != KErrNone )
        {
    	TRACE( Kern::Printf("DMemSpyDriverLogChanClientServer::GetServerSessionInfo() - END - params read error: %d", r));
        return r;
        }

    DMemSpyDriverOSAdaptionDSession& sessionAdaption = OSAdaption().DSession();
    DMemSpyDriverOSAdaptionDThread& threadAdaption = OSAdaption().DThread();
    DMemSpyDriverOSAdaptionDProcess& processAdaption = OSAdaption().DProcess();

	NKern::ThreadEnterCS();

    DObject* sessionHandle = (DObject*) aSessionHandle;
    sessionHandle = CheckIfObjectIsInContainer( EMemSpyDriverContainerTypeSession, sessionHandle );
    if  ( sessionHandle == NULL )
        {
    	Kern::Printf("DMemSpyDriverLogChanClientServer::GetServerSessionInfo() - END - session not found");
        NKern::ThreadLeaveCS();
        return KErrNotFound;
        }

    DSession* session = (DSession*) sessionHandle;
    session->FullName( params.iName );

    NKern::LockSystem();
    r = session->Open();
    if  ( r == KErrNone )
        {
        // Get owner type and id
        DObject* sessionOwner = sessionAdaption.GetOwner( *session );
        if  ( sessionOwner )
            {
            const TObjectType objectType = sessionAdaption.GetObjectType( *sessionOwner );
            if  ( objectType == EProcess )
                {
                DProcess* sessionProcess = (DProcess*) sessionOwner;
                //
                params.iOwnerId = processAdaption.GetId( *sessionProcess );
                params.iOwnerType = TMemSpyDriverServerSessionInfo::EOwnerProcess;
                }
            else if ( objectType == EThread )
                {
                DThread* sessionThread = (DThread*) sessionOwner;
                //
                params.iOwnerId = threadAdaption.GetId( *sessionThread );
                params.iOwnerType = TMemSpyDriverServerSessionInfo::EOwnerThread;
                }
            }
        else
            {
            params.iOwnerId = -1;
            params.iOwnerType = TMemSpyDriverServerSessionInfo::EOwnerNone;
            }

        // Other attributes
        params.iSessionType = sessionAdaption.GetSessionType( *session );
        params.iAddress = (TUint8*)session;

        NKern::ThreadEnterCS();
        TRACE( Kern::Printf("DMemSpyDriverLogChanClientServer::GetServerSessionInfo() - in CS..." ));
        //
	    Kern::SafeClose( (DObject*&) session, NULL );
        TRACE( Kern::Printf("DMemSpyDriverLogChanClientServer::GetServerSessionInfo() - done safe close..." ));
        //
	    NKern::ThreadLeaveCS();
        TRACE( Kern::Printf("DMemSpyDriverLogChanClientServer::GetServerSessionInfo() - left CS" ));
        }
    else
        {
    	Kern::Printf("DMemSpyDriverLogChanClientServer::GetServerSessionInfo - error: %d opening server", r);
        }

    NKern::UnlockSystem();

    if  ( r == KErrNone )
        {
        r = Kern::ThreadRawWrite( &ClientThread(), aParams, &params, sizeof(TMemSpyDriverServerSessionInfo) );
        }

	NKern::ThreadLeaveCS();

	TRACE( Kern::Printf("DMemSpyDriverLogChanClientServer::GetServerSessionInfo() - END - r: %d", r));
	return r;
    }