diff -r 6295dc2169f3 -r 8486d82aef45 adaptationlayer/bcaiscadapter/bcatoisc_dll/src/bcatoisc.cpp
--- a/adaptationlayer/bcaiscadapter/bcatoisc_dll/src/bcatoisc.cpp	Wed Apr 21 14:29:55 2010 +0300
+++ b/adaptationlayer/bcaiscadapter/bcatoisc_dll/src/bcatoisc.cpp	Tue Oct 19 13:16:20 2010 +0300
@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
+* Copyright (c) 2009-2010 Nokia Corporation and/or its subsidiary(-ies).
 * All rights reserved.
 * This component and the accompanying materials are made available
 * under the terms of the License "Eclipse Public License v1.0"
@@ -22,27 +22,59 @@
 #include "iscdefinitions.h"
 #include <cdbcols.h>
 
+#include <nsisi.h>
+#include <pipeisi.h>
+#include <pn_const.h>
+#include <iscnokiadefinitions.h>
+#include "pep_bca_types.h"
+
+
+const TUint8 KDataLength = 7;
+const TUint8 KStatusIndex = 0;
+const TUint8 KDevIdIndex = 5;
+const TUint8 KObjIdIndex = 6;
+const TUint8 KPadding = 0;
+const TUint KDefaultReceiveBufferSize = 2048;
+
 using namespace BasebandChannelAdaptation;
 
+/**
+* Utility function to complete a pending request and NULL request pointer.
+*/   
+ 
+static void CompleteRequest(TRequestStatus* &aReqStatus, const TInt aError)
+    {
+    if(( aReqStatus ) &&
+       ( *aReqStatus == KRequestPending ))
+        {
+        // Only realy need to trace if we actually complete the request.
+        C_TRACE( (_T("CompleteRequest completing client request with aError %d ->"), aError ) );
+
+        //Complete clients request
+        User::RequestComplete( aReqStatus, aError );
+
+        aReqStatus = NULL;
+        }
+    }
+
     
 /**
 * Default constructor to create a CNotifyFlowControlMonitor instance.
 */    
 CNotifyFlowControlMonitor::CNotifyFlowControlMonitor(RIscApi& aIscApi)
-    :CActive(EPriorityStandard),
-    iIscApi(aIscApi)
+    :CActive(EPriorityHigh),
+    iIscApi(aIscApi),
+    iWriteStatus(NULL)
     {
-    C_TRACE( (_T("CNotifyFlowControlMonitor::CNotifyFlowControlMonitor RIscAapi 0x%x ->"), &aIscApi ) );
-    
+    C_TRACE( (_T("CNotifyFlowControlMonitor::CNotifyFlowControlMonitor RIscApi 0x%x ->"), &aIscApi ) );
     CActiveScheduler::Add(this);
-
     C_TRACE( (_T("CNotifyFlowControlMonitor::CNotifyFlowControlMonitor <-") ) );
     }
 
 void CNotifyFlowControlMonitor::NotifyFlowControlStatus()
     {
     C_TRACE( (_T("CNotifyFlowControlMonitor::NotifyFlowControlStatus() ->") ) );
-
+    
     ASSERT(!IsActive());
     
     iFlowControlValue = iIscApi.FlowControlStatus();
@@ -58,47 +90,54 @@
 void CNotifyFlowControlMonitor::RequestFlowcontrolChange( TRequestStatus& aStatus )
     {
     C_TRACE( (_T("CNotifyFlowControlMonitor::RequestFlowcontrolChange ->") ) );
-
     iWriteStatus = &aStatus;
     *iWriteStatus = KRequestPending;
-
-
     C_TRACE( (_T("CNotifyFlowControlMonitor::RequestFlowcontrolChange <-") ) );
     }
     
+void CNotifyFlowControlMonitor::CompleteFlowcontrolChangeWithCancel()
+    {
+    C_TRACE( (_T("CNotifyFlowControlMonitor::CompleteFlowcontrolChangeWithCancel() ->") ) );
+    // If pending request, complete as cancelled
+    CompleteRequest(iWriteStatus, KErrCancel);
+    C_TRACE( (_T("CNotifyFlowControlMonitor::CompleteFlowcontrolChangeWithCancel() <-") ) );
+    }
+    
 void CNotifyFlowControlMonitor::RunL()
     {
     C_TRACE( (_T("CNotifyFlowControlMonitor::RunL() iStatus %d ->"), iStatus.Int() ) );
     
-    iFlowControlValue = iIscApi.FlowControlStatus();
+    ASSERT( iStatus.Int() == KErrNone);
     
-  
+    iFlowControlValue = iIscApi.FlowControlStatus();
+      
     C_TRACE( (_T("CNotifyFlowControlMonitor::RunL flow control Value has changed and is now: (%d)"), iFlowControlValue ) );
 
-        if( *iWriteStatus == KRequestPending )
-            {
-              User::RequestComplete(iWriteStatus, KErrNone);
-            }
-
-    if( iStatus == KErrNone )
+    if( iFlowControlValue == EIscFlowControlOff)
         {
-        //Check for further flow control status changes
-        iIscApi.NotifyFlowControl(iStatus, iFlowControlValue);
-        SetActive();
+        // If pending request, complete it as flow control is now OFF
+        CompleteRequest(iWriteStatus,KErrNone);
         }
-                
+    
+    //Check for further flow control status changes
+    iIscApi.NotifyFlowControl(iStatus, iFlowControlValue);
+    SetActive();
     C_TRACE( (_T("CNotifyFlowControlMonitor::RunL() <-") ) );
     }
     
 TInt CNotifyFlowControlMonitor::GetFlowControlState()
     {
+    C_TRACE( (_T("CNotifyFlowControlMonitor::GetFlowControlState() flowcontrol value %d <->"), iFlowControlValue ) );
       return iFlowControlValue;
     }
     
 void CNotifyFlowControlMonitor::DoCancel()
     {
     C_TRACE( (_T("CNotifyFlowControlMonitor::DoCancel() ->") ) );
-    
+    // If pending request, complete it as cancelled
+    CompleteRequest(iWriteStatus, KErrCancel);
+    C_TRACE( (_T("CNotifyFlowControlMonitor::DoCancel() req is completed") ) );
+
     iIscApi.NotifyFlowControlCancel();
 
     C_TRACE( (_T("CNotifyFlowControlMonitor::DoCancel() <-") ) );
@@ -109,18 +148,17 @@
     C_TRACE( (_T("CNotifyFlowControlMonitor::~CNotifyFlowControlMonitor() ->") ) );
     
     Cancel();
-        
+
     C_TRACE( (_T("CNotifyFlowControlMonitor::~CNotifyFlowControlMonitor() <-") ) );
     }
     
 
 CNotifyWriteStatusMonitor::CNotifyWriteStatusMonitor( CBcaToIsc& aUser, RIscApi& aIscApi )
-    :CActive(EPriorityHigh),
+    :CActive(EPriorityStandard),
     iUser(aUser),
     iIscApi(aIscApi)
     {
     C_TRACE( (_T("CNotifyWriteStatusMonitor::CNotifyWriteStatusMonitor ->") ) );
- //   iBuf = new TPtr8( NULL, 0, 0 );
     CActiveScheduler::Add(this);
     C_TRACE( (_T("CNotifyWriteStatusMonitor::CNotifyWriteStatusMonitor <-") ) );
     }
@@ -128,44 +166,48 @@
 
 void CNotifyWriteStatusMonitor::Write( TRequestStatus& aStatus, const TDesC8& aBuf )
     {
-
+    C_TRACE( (_T("CNotifyWriteStatusMonitor::Write ->") ) );
     iBuf = &aBuf;
     iClientStatus = &aStatus;
     *iClientStatus = KRequestPending;
 
     if( iUser.iFlowControlMonitor->GetFlowControlState() == EIscFlowControlOff )
         {
-        //iIscApi.DataSend( aStatus, aBuf );
-        SendAndComplete();             
+        SendAndComplete(KErrNone);             
         }
     else  //flow control on
         {
-
-        //iBuf = &aBuf;
-        //  iBuf->Set( const_cast<TUint8*>(aBuf.Ptr()), aBuf.Length(), aBuf.Length() );
-        // iClientStatus = &aStatus;
-        // *iClientStatus = KRequestPending;
         iUser.iFlowControlMonitor->RequestFlowcontrolChange( iStatus );
         SetActive();
         }
-
+    C_TRACE( (_T("CNotifyWriteStatusMonitor::Write <-") ) );
     }
+    
 void CNotifyWriteStatusMonitor::RunL()
-        {
-        C_TRACE( (_T("CNotifyWriteStatusMonitor::RunL() iStatus %d ->"), iStatus.Int() ) );
-    
-    SendAndComplete();
-    //iIscApi.DataSend( *iClientStatus, *iBuf );
+    {
+    C_TRACE( (_T("CNotifyWriteStatusMonitor::RunL() iStatus %d ->"), iStatus.Int() ) );
+// KARI ei kutsu IASC apin data sendiä jos erksa OK?    
+    SendAndComplete(iStatus.Int());
     
     C_TRACE( (_T("CNotifyWriteStatusMonitor::RunL() <-") ) );
     }
 
-void CNotifyWriteStatusMonitor::SendAndComplete()
+void CNotifyWriteStatusMonitor::SendAndComplete(TInt aError)
     {
-      TInt error = KErrGeneral;
+    C_TRACE( (_T("CNotifyWriteStatusMonitor::SendAndComplete() ->")));
     
-    error = iIscApi.DataSend( *iBuf );
-    User::RequestComplete(iClientStatus, error);
+    // We may have had the request cancelled, in which case do not send the write data
+    if (aError == KErrNone)
+        {    
+        C_TRACE( (_T("CNotifyWriteStatusMonitor::SendAndComplete() iIscApi.DataSend ")));
+        aError = iIscApi.DataSend( *iBuf );
+        }
+
+    // If pending request, complete it as specified by the error status
+    // This could be OK or canncelled
+    CompleteRequest(iClientStatus, aError);
+    
+    C_TRACE( (_T("CNotifyWriteStatusMonitor::SendAndComplete() <-") ) );
     }
     
 
@@ -173,12 +215,10 @@
     {
     C_TRACE( (_T("CNotifyWriteStatusMonitor::DoCancel() ->") ) );
     
-    if( *iClientStatus == KRequestPending )
-        {
-          C_TRACE( (_T("CNotifyWriteStatusMonitor::DoCancel completing client request with KErrCancel ->") ) );
-        //Complete clients request
-        User::RequestComplete( iClientStatus, KErrCancel );
-        }
+    iUser.iFlowControlMonitor->CompleteFlowcontrolChangeWithCancel();
+
+    // If pending request, complete it as cancelled
+    CompleteRequest(iClientStatus, KErrCancel);
     
     C_TRACE( (_T("CNotifyWriteStatusMonitor::DoCancel() <-") ) );
     }
@@ -198,7 +238,11 @@
 /**
 * Default constructor to create a CBcaToIsc instance.
 */
-CBcaToIsc::CBcaToIsc() : iReadLength(0), iChannelNumber( 0xffff )
+CBcaToIsc::CBcaToIsc() : 
+    CActive( EPriorityStandard ),
+    iMessageBufferPtr( 0,0 ),
+    iReadLength(0), 
+    iChannelNumber( 0xffff )
     {
     C_TRACE( (_T("CBcaToIsc::CBcaToIsc() ->") ) );
     
@@ -216,6 +260,14 @@
     __ASSERT_DEBUG(!iWriteStatusMonitor, User::Panic(_L("BcaToIsc.dll"), EMonitorAlreadyExists));
     iFlowControlMonitor = new (ELeave)CNotifyFlowControlMonitor(iIscApi);
     iWriteStatusMonitor = new (ELeave)CNotifyWriteStatusMonitor(*this, iIscApi);
+    iReceivedMessageBuffer = HBufC8::NewL(KDefaultReceiveBufferSize);
+    iMessageBufferPtr.Set( iReceivedMessageBuffer->Des() );
+    iMessageBufferPtr.FillZ();
+    iChannelList.Append( EIscNokiaNifPep5 );
+    iChannelList.Append( EIscNokiaNifPep6 );
+    iChannelList.Append( EIscNokiaNifPep7 );
+    iChannelList.Append( EIscNokiaNifPep8 );
+    CActiveScheduler::Add( this );
     C_TRACE( (_T("CBcaToIsc::ConstructL() this 0x%x <-"), this ) );
 
     }
@@ -236,11 +288,18 @@
         {
         delete iWriteStatusMonitor;
         }
+
+    if( iReceivedMessageBuffer )
+        {
+        delete iReceivedMessageBuffer;
+        }
+
     iClientShutdownStatus = NULL;
+    iClientOpenStatus = NULL;
     C_TRACE( (_T("CBcaToIsc::~CBcaToIsc() <-") ) );
 
     }
-
+// remove loan / returnloan deadcode from lower layers
 /** This method deletes the BCA itself.*/
 void CBcaToIsc::Release()
     {
@@ -257,11 +316,14 @@
     
 * @param aStatus complete status, KErrNone if successful, error code otherwise.
 * @param aChannelId comm port name.
-*/    
+*/
 void CBcaToIsc::Open(TRequestStatus& aStatus, const TDesC& aChannelId)
     {
 
     C_TRACE( (_T("CBcaToIsc::Open aStatus %d aChannelId descriptor %S ->"), aStatus.Int(), &aChannelId ) );
+    iClientOpenStatus = &aStatus;
+    *iClientOpenStatus = KRequestPending;
+
     // Expected form either <XXX>Int_<XX> (i.e. 100Int_3) or Int!!!
     TUint16 channelid( 0xffff );
     TInt error( KErrGeneral );
@@ -282,16 +344,56 @@
         error = channelParser.Val(channelid, EDecimal);
         }
     ASSERT( KErrNone == error );
+    C_TRACE( (_T("CBcaToIsc::Open parsed channel id: 0x%x"), channelid ) );
     if( error == KErrNone )
         {
-        error = iIscApi.Loan( channelid );
-        iChannelNumber = error == KErrNone ? channelid : iChannelNumber; 
+        TInt index( 0 );
+        TBool channelOpened( EFalse );
+        TRequestStatus status( KRequestPending );
+        for( index = 0; index < iChannelList.Length(); index++ )
+            {
+            status = KRequestPending;
+            iIscApi.Open( iChannelList[index], status, EOwnerThread );
+            User::WaitForRequest( status );
+            if( KErrNone == status.Int() )
+                {
+                C_TRACE( (_T("CBcaToIsc::Open channel 0x%x opened"), iChannelList[index] ) );
+                channelOpened = ETrue;
+                break;
+                }
+            }
+
+        if( !channelOpened )
+            {
+            C_TRACE( (_T("CBcaToIsc::Open channel opening failed") ) );
+            User::RequestComplete( iClientOpenStatus, KErrGeneral );
+            iClientOpenStatus = NULL;
+            }
+        else if( KErrNone == SendNameAddReq( iChannelList[index], channelid ) )
+            {
+            iFlowControlMonitor->NotifyFlowControlStatus();
+            iChannelNumber = status.Int() == KErrNone ? iChannelList[index] : iChannelNumber; 
+            
+            iMessageBufferPtr.SetLength( 0 );
+            iStatus = KRequestPending;
+            iIscApi.Receive( iStatus, iMessageBufferPtr, iReadLength );
+            SetActive();
+            }
+        else
+            {
+            C_TRACE( (_T("CBcaToIsc::Open sending of PNS_NAME_ADD_REQ failed") ) );
+            iIscApi.Close();
+            User::RequestComplete( iClientOpenStatus, KErrGeneral );
+            iClientOpenStatus = NULL;
+            }
         }
-    ASSERT( KErrNone == error );
-    TRequestStatus* request = &aStatus;
-    User::RequestComplete( request, error );
+    else
+        {    
+        User::RequestComplete( iClientOpenStatus, error );
+        iClientOpenStatus = NULL;
+        }
+
     C_TRACE( (_T("CBcaToIsc::Open <-") ) );
-
     }
 
 /**
@@ -309,10 +411,23 @@
     iWriteStatusMonitor->Cancel();
     iFlowControlMonitor->Cancel();
     iIscApi.DataReceiveCancel();
-    iIscApi.ReturnLoan( iChannelNumber );
-    User::RequestComplete(iClientShutdownStatus, KErrNone);
+
+    if( KErrNone == SendNameRemoveReq() )
+        {
+        iMessageBufferPtr.SetLength( 0 );
+        iStatus = KRequestPending;
+        iIscApi.Receive( iStatus, iMessageBufferPtr, iReadLength );
+        SetActive();
+        }
+    else
+        {
+        C_TRACE( (_T("CBcaToIsc::Shutdown sending of PNS_NAME_REMOVE_REQ failed") ) );
+        iIscApi.Close();
+        User::RequestComplete(iClientShutdownStatus, KErrGeneral);
+        iClientShutdownStatus = NULL;
+        }
+
     C_TRACE( (_T("CBcaToIsc::Shutdown <-") ) );
-
     }
 
 /**
@@ -337,7 +452,8 @@
     C_TRACE( (_T("CBcaToIsc::Close() iChannelNumber=0x%x 4"), iChannelNumber ) );
     iIscApi.DataSendCancel();
     C_TRACE( (_T("CBcaToIsc::Close() iChannelNumber=0x%x 5"), iChannelNumber ) );
-    iIscApi.ReturnLoan( iChannelNumber );
+    
+    iIscApi.Close();
 
     C_TRACE( (_T("CBcaToIsc::Close() <-") ) );
 
@@ -369,10 +485,9 @@
 void CBcaToIsc::Write( TRequestStatus& aStatus, const TDesC8& aBuf )
     {
     C_TRACE( (_T("CBcaToIsc::Write aStatus %d aBuf %S ->"), aStatus.Int(), &aBuf ) );
-        //write requesti pitää jäädä odottamaan jos flow controlli päälä.
-                 
-        iWriteStatusMonitor->Write(aStatus, aBuf);
-            
+                
+    iWriteStatusMonitor->Write(aStatus, aBuf);
+        
     C_TRACE( (_T("CBcaToIsc::Write <-") ) );
     }
 
@@ -433,3 +548,407 @@
 
     }
 
+/**
+* Sends PNS_NAME_ADD_REQ
+
+* @param aObjId object id for the name to be added
+* @return KErrNone if message sent succesfully, otherwise error code
+*/    
+TInt CBcaToIsc::SendNameAddReq( TUint16& aObjId, TUint16& aClientObjId )
+    {
+    C_TRACE( (_T("CBcaToIsc::SendNameAddReq() ->") ) );
+
+    HBufC8* message = HBufC8::New( ISI_HEADER_SIZE + SIZE_PNS_NAME_ADD_REQ );
+    TInt err( KErrGeneral );
+
+    if( message )
+        {
+        TPtr8 messageptr = message->Des();
+        messageptr.FillZ();
+
+        // Add 32bit name (Big-endian)
+        iName.Append( aClientObjId );
+        iName.Append( PN_PEP_SUB_TYPE_SYMBIAN_INTERNAL );
+        iName.Append( PN_PEP_TYPE_COMMON );
+        iName.Append( PN_PIPE );
+        TUint8 nameOffset( ISI_HEADER_SIZE + PNS_NAME_ADD_REQ_OFFSET_NAMEENTRY );
+
+        TIsiSend isimessage( messageptr, ISI_HEADER_SIZE + SIZE_PNS_NAME_ADD_REQ );
+        isimessage.Set8bit( ISI_HEADER_OFFSET_RESOURCEID, PN_NAMESERVICE );
+        isimessage.Set8bit( ISI_HEADER_OFFSET_TRANSID, 0 );
+        isimessage.Set8bit( ISI_HEADER_OFFSET_MESSAGEID, PNS_NAME_ADD_REQ );
+        isimessage.Set8bit( ISI_HEADER_SIZE + PNS_NAME_ADD_REQ_OFFSET_RESERVED1, KPadding );
+        isimessage.Set8bit( ISI_HEADER_SIZE + PNS_NAME_ADD_REQ_OFFSET_RESERVED2, KPadding );
+        isimessage.Set8bit( nameOffset, iName[0] );
+        isimessage.Set8bit( nameOffset + 1, iName[1] );
+        isimessage.Set8bit( nameOffset + 2, iName[2] );
+        isimessage.Set8bit( nameOffset + 3, iName[3] );
+        isimessage.Set8bit( nameOffset + PN_NAME_SRV_ITEM_STR_OFFSET_DEV, THIS_DEVICE );
+        isimessage.Set8bit( nameOffset + PN_NAME_SRV_ITEM_STR_OFFSET_OBJ, aObjId );
+        isimessage.Set8bit( nameOffset + PN_NAME_SRV_ITEM_STR_OFFSET_FLAGS, PN_NAME_UNDEF );
+        isimessage.Set8bit( nameOffset + PN_NAME_SRV_ITEM_STR_OFFSET_RESERVED, KPadding );
+        isimessage.Complete();
+
+        err = iIscApi.Send( messageptr );
+        C_TRACE( (_T("CBcaToIsc::SendNameAddReq() success: 0x%x"), err ) );
+        delete message;
+        }
+    else
+        {
+        C_TRACE( (_T("CBcaToIsc::SendNameAddReq() memory allocation failed") ) );
+        ASSERT(0);
+        }
+
+    C_TRACE( (_T("CBcaToIsc::SendNameAddReq() <-") ) );
+    return err;
+    }
+
+/**
+* Sends PNS_NAME_REMOVE_REQ
+
+* @return KErrNone if message sent succesfully, otherwise error code
+*/
+TInt CBcaToIsc::SendNameRemoveReq()
+    {
+    C_TRACE( (_T("CBcaToIsc::SendNameRemoveReq() ->") ) );
+
+    HBufC8* message = HBufC8::New( ISI_HEADER_SIZE + SIZE_PNS_NAME_REMOVE_REQ );
+    TInt err( KErrGeneral );
+    if( message )
+        {
+        TPtr8 messageptr = message->Des();
+        messageptr.FillZ();
+        TUint8 nameOffset( ISI_HEADER_SIZE + PNS_NAME_REMOVE_REQ_OFFSET_NAME );
+
+        TIsiSend isimessage( messageptr, ISI_HEADER_SIZE + SIZE_PNS_NAME_REMOVE_REQ );
+        isimessage.Set8bit( ISI_HEADER_OFFSET_RESOURCEID, PN_NAMESERVICE );
+        isimessage.Set8bit( ISI_HEADER_OFFSET_TRANSID , 0 );
+        isimessage.Set8bit( ISI_HEADER_OFFSET_MESSAGEID, PNS_NAME_REMOVE_REQ );
+        isimessage.Set8bit( ISI_HEADER_SIZE + PNS_NAME_REMOVE_REQ_OFFSET_RESERVED1, KPadding );
+        isimessage.Set8bit( ISI_HEADER_SIZE + PNS_NAME_REMOVE_REQ_OFFSET_RESERVED2, KPadding );
+        isimessage.Set8bit( nameOffset, iName[0] );
+        isimessage.Set8bit( nameOffset + 1, iName[1] );
+        isimessage.Set8bit( nameOffset + 2, iName[2] );
+        isimessage.Set8bit( nameOffset + 3, iName[3] );
+        isimessage.Complete();
+        err = iIscApi.Send( messageptr );
+        C_TRACE( (_T("CBcaToIsc::SendNameRemoveReq() success: 0x%x"), err ) );
+        delete message;
+        }
+    else
+        {
+        C_TRACE( (_T("CBcaToIsc::SendNameRemoveReq() memory allocation failed") ) );
+        ASSERT(0);
+        }
+
+    C_TRACE( (_T("CBcaToIsc::SendNameRemoveReq() <-") ) );
+    return err;
+    }
+
+/**
+* Sends PNS_PEP_CTRL_RESP
+
+* @return KErrNone if message sent succesfully, otherwise error code
+*/    
+TInt CBcaToIsc::SendPepCtrlResp( 
+    TUint8 aTrId,
+    TUint8 aReceiverDev,
+    TUint8 aReceiverObj,
+    TUint8 aPipeHandle,
+    TUint8 aPepCtrlId,
+    TUint8 aPepType,
+    TUint8 aResult )
+    {
+    C_TRACE( (_T("CBcaToIsc::SendPepCtrlResp() ->") ) );
+
+    HBufC8* message = HBufC8::New( ISI_HEADER_SIZE + SIZE_PNS_PEP_CTRL_RESP );
+    TInt err( KErrGeneral ); 
+
+    if( message )
+        {
+        TPtr8 messageptr = message->Des();
+        messageptr.FillZ();
+
+        TIsiSend isimessage( messageptr, ISI_HEADER_SIZE + SIZE_PNS_PEP_CTRL_RESP );        
+        isimessage.Set8bit( ISI_HEADER_OFFSET_RECEIVERDEVICE, aReceiverDev);
+        isimessage.Set8bit( ISI_HEADER_OFFSET_RESOURCEID, PN_PIPE);
+        isimessage.Set8bit( ISI_HEADER_OFFSET_RECEIVEROBJECT, aReceiverObj);
+        isimessage.Set8bit( ISI_HEADER_OFFSET_TRANSID , aTrId);
+        isimessage.Set8bit( ISI_HEADER_OFFSET_MESSAGEID, PNS_PEP_CTRL_RESP );
+        isimessage.Set8bit( ISI_HEADER_SIZE + PNS_PEP_CTRL_RESP_OFFSET_PIPEHANDLE, aPipeHandle );
+        isimessage.Set8bit( ISI_HEADER_SIZE + PNS_PEP_CTRL_RESP_OFFSET_PEPCTRLID, aPepCtrlId );
+        isimessage.Set8bit( ISI_HEADER_SIZE + PNS_PEP_CTRL_RESP_OFFSET_PEPTYPE, aPepType );
+        isimessage.Set8bit( ISI_HEADER_SIZE + PNS_PEP_CTRL_RESP_OFFSET_ERRORCODE, aResult );
+        isimessage.Complete();
+        err = iIscApi.Send( messageptr );
+        C_TRACE( (_T("CBcaToIsc::SendPepCtrlResp() success: 0x%x"), err ) );
+        delete message;
+        }
+    else
+        {
+        C_TRACE( (_T("CBcaToIsc::SendPepCtrlResp() memory allocation failed") ) );
+        ASSERT(0);
+        }
+
+    C_TRACE( (_T("CBcaToIsc::SendPepCtrlResp() <-") ) );
+    return err;
+    }
+
+/**
+* Handles received messages
+
+* @param aObjId object id for the name to be added
+* @return KErrNone if message sent succesfully, otherwise error code
+*/
+void CBcaToIsc::RunL()
+    {
+    C_TRACE( (_T("CBcaToIsc::RunL() ->") ) );
+
+    if ( KErrNone == iStatus.Int() )
+        {
+        HandleReceivedMsg( TIsiReceiveC( iMessageBufferPtr ) );
+        }
+    else
+        {
+        C_TRACE( (_T("CBcaToIsc::RunL() error occured: 0x%x"), iStatus.Int() ) );
+        ASSERT(0);
+        }
+
+    C_TRACE( (_T("CBcaToIsc::RunL() <-") ) );
+    }
+
+/**
+* Handles cancel operation for this active object
+
+*/
+void CBcaToIsc::DoCancel()
+    {
+    C_TRACE( (_T("CBcaToIsc::DoCancel() ->") ) );
+    iIscApi.ReceiveCancel();
+    C_TRACE( (_T("CBcaToIsc::DoCancel() <-") ) );
+    }
+
+/**
+* Handles received message
+
+*/
+void CBcaToIsc::HandleReceivedMsg( const TIsiReceiveC& aIsiMsg )
+    {
+    C_TRACE( (_T("CBcaToIsc::HandleReceivedMsg() ->") ) );
+
+    TInt resource( aIsiMsg.Get8bit( ISI_HEADER_OFFSET_RESOURCEID ) );
+
+    switch( resource )
+        {
+        case PN_NAMESERVICE:
+            {
+            HandleNameServiceMsg( aIsiMsg );
+            break;
+            }
+        case PN_PIPE:
+            {
+            HandlePipeMsg( aIsiMsg );
+            break;
+            }
+        default:
+            {
+            C_TRACE( (_T("CBcaToIsc::HandleReceivedMsg() unknown resource 0x%x"), resource ) );
+            ASSERT(0);
+            break;
+            }
+        }
+
+    C_TRACE( (_T("CBcaToIsc::HandleReceivedMsg() <-") ) );
+    }
+
+/**
+* Handles received messages from resource PN_NAME
+
+*/
+void CBcaToIsc::HandleNameServiceMsg( const TIsiReceiveC& aIsiMsg )
+    {
+    C_TRACE( (_T("CBcaToIsc::HandleNameServiceMsg() ->") ) );
+    
+    TInt msgId( aIsiMsg.Get8bit( ISI_HEADER_OFFSET_MESSAGEID ) );
+    switch( msgId )
+        {
+        case PNS_NAME_ADD_RESP:
+            {
+            C_TRACE( (_T("CBcaToIsc::HandleNameServiceMsg() PNS_NAME_ADD_RESP") ) );
+            TUint8 reason( aIsiMsg.Get8bit( 
+                ISI_HEADER_SIZE + PNS_NAME_ADD_RESP_OFFSET_REASON ) );
+            if( PN_NAME_OK != reason )
+                {
+                C_TRACE( (_T("CBcaToIsc::HandleNameServiceMsg() Name adding failed: 0x%x"), reason ) );
+                if( iClientOpenStatus )
+                    {
+                    C_TRACE( (_T("CBcaToIsc::HandleNameServiceMsg() completing open") ) );
+                    User::RequestComplete( iClientOpenStatus, KErrGeneral );
+                    iClientOpenStatus = NULL;
+                    iIscApi.Close();
+                    }
+                // no else
+                }
+            else
+                {
+                C_TRACE( (_T("CBcaToIsc::HandleNameServiceMsg() Name added succesfully") ) );
+                iMessageBufferPtr.SetLength( 0 );
+                iStatus = KRequestPending;
+                iIscApi.Receive( iStatus, iMessageBufferPtr, iReadLength );
+                SetActive();
+                }
+            break;
+            }
+        case PNS_NAME_REMOVE_RESP:
+            {
+            C_TRACE( (_T("CBcaToIsc::HandleNameServiceMsg() PNS_NAME_REMOVE_RESP") ) );
+            TUint8 reason( aIsiMsg.Get8bit( 
+                ISI_HEADER_SIZE + PNS_NAME_ADD_RESP_OFFSET_REASON ) );
+            if( PN_NAME_OK != reason )
+                {
+                C_TRACE( (_T("CBcaToIsc::HandleNameServiceMsg() Name removing failed: 0x%x"), reason ) );
+                ASSERT(0);
+                if( iClientShutdownStatus )
+                    {
+                    C_TRACE( (_T("CBcaToIsc::HandleNameServiceMsg() completing shutdown") ) );
+                    User::RequestComplete(iClientShutdownStatus, KErrGeneral );
+                    iClientShutdownStatus = NULL;
+                    }
+                }
+            else
+                {
+                C_TRACE( (_T("CBcaToIsc::HandleNameServiceMsg() Name removed succesfully") ) );
+                iName.Zero();
+                iMessageBufferPtr.SetLength( 0 );
+                iStatus = KRequestPending;
+                iIscApi.Receive( iStatus, iMessageBufferPtr, iReadLength );
+                SetActive();
+                }
+            break;
+            }
+        default:
+            {
+            C_TRACE( (_T("CBcaToIsc::HandleNameServiceMsg() unknown msg 0x%x"), msgId ) );
+            break;
+            }
+        }
+
+    C_TRACE( (_T("CBcaToIsc::HandleNameServiceMsg() <-") ) );
+    }
+
+/**
+* Handles received messages from resource PN_PIPE
+
+*/
+void CBcaToIsc::HandlePipeMsg( const TIsiReceiveC& aIsiMsg )
+    {
+    C_TRACE( (_T("CBcaToIsc::HandlePipeMsg() ->") ) );
+
+    TInt msgId( aIsiMsg.Get8bit( ISI_HEADER_OFFSET_MESSAGEID ) );
+    switch( msgId )
+        {
+        case PNS_PEP_CTRL_REQ:
+            {
+            C_TRACE( (_T("CBcaToIsc::HandlePipeMsg() PNS_PEP_CTRL_REQ") ) );
+            HandlePepCtrlReq( aIsiMsg );
+            break;
+            }
+        default:
+            {
+            C_TRACE( (_T("CBcaToIsc::HandlePipeMsg() unknown msg 0x%x"), msgId ) );
+            ASSERT(0);
+            break;
+            }
+        }
+    
+    C_TRACE( (_T("CBcaToIsc::HandlePipeMsg() <-") ) );
+    }
+
+/**
+* Handles PNS_PEP_CTRL_REQ
+
+*/
+void CBcaToIsc::HandlePepCtrlReq( const TIsiReceiveC& aIsiMsg )
+    {
+    C_TRACE( (_T("CBcaToIsc::HandlePepCtrlReq() ->") ) );
+
+    TUint8 pipeHandle( aIsiMsg.Get8bit( 
+        ISI_HEADER_SIZE + PNS_PEP_CTRL_REQ_OFFSET_PIPEHANDLE ) );
+    TUint8 pepCtrlId( aIsiMsg.Get8bit( 
+        ISI_HEADER_SIZE + PNS_PEP_CTRL_REQ_OFFSET_PEPCTRLID ) );
+    TUint8 pepType( aIsiMsg.Get8bit( 
+        ISI_HEADER_SIZE + PNS_PEP_CTRL_REQ_OFFSET_PEPTYPE ) );
+    TUint8 result( PN_PIPE_ERR_NOT_SUPPORTED );
+
+    TUint8 trId( aIsiMsg.Get8bit( 
+        ISI_HEADER_OFFSET_TRANSID ) );
+    // Get sender device
+    TUint8 senderDevice( aIsiMsg.Get8bit(
+        ISI_HEADER_OFFSET_SENDERDEVICE ) );
+    // Get sender object
+    TUint8 senderObject( aIsiMsg.Get8bit(
+        ISI_HEADER_OFFSET_SENDEROBJECT ) );
+
+    C_TRACE( (_T("CBcaToIsc::HandlePepCtrlReq() pipe handle: 0x%x"), pipeHandle ) );
+    C_TRACE( (_T("CBcaToIsc::HandlePepCtrlReq() pep ctrl id: 0x%x"), pepCtrlId ) );
+    C_TRACE( (_T("CBcaToIsc::HandlePepCtrlReq() pep type: 0x%x"), pepType ) );
+
+    TBuf8<KDataLength> data( aIsiMsg.GetData( 
+        ISI_HEADER_SIZE + PNS_PEP_CTRL_REQ_OFFSET_PEPCTRLDATA, 
+        KDataLength ) );
+
+    TUint8 devId( data[KDevIdIndex] );
+    TUint8 objId( data[KObjIdIndex] );
+    C_TRACE( (_T("CBcaToIsc::HandlePepCtrlReq() dev id: 0x%x"), devId ) );
+    C_TRACE( (_T("CBcaToIsc::HandlePepCtrlReq() obj id: 0x%x"), objId ) );
+    C_TRACE( (_T("CBcaToIsc::HandlePepCtrlReq() iChannelNumber: 0x%x"), iChannelNumber ) );
+
+    if( PN_PEP_TYPE_BCA == pepType &&
+        THIS_DEVICE == devId &&
+        iChannelNumber == objId )
+        {
+        C_TRACE( (_T("CBcaToIsc::HandlePepCtrlReq() PNS_PEP_CTRL_REQ for this PEP") ) );
+        result = PN_PIPE_NO_ERROR;
+        TInt ret( KErrNone );
+
+        if( PEP_BCA_OK != data[KStatusIndex] )
+            {
+            C_TRACE( (_T("CBcaToIsc::HandlePepCtrlReq() PNS_PEP_CTRL_REQ with error 0x%x"), data[KStatusIndex] ) );
+            ret = KErrGeneral;
+            }
+
+        if( PEP_CTRL_ID_LOAN == pepCtrlId )
+            {
+            C_TRACE( (_T("CBcaToIsc::HandlePepCtrlReq() ctrl id PEP_CTRL_ID_LOAN") ) );
+            if( iClientOpenStatus )
+                {
+                C_TRACE( (_T("CBcaToIsc::HandlePepCtrlReq() completing open") ) );
+                User::RequestComplete( iClientOpenStatus, ret );
+                iClientOpenStatus = NULL;
+                }
+             }
+         else if( PEP_CTRL_ID_RETURNLOAN == pepCtrlId )
+             {
+             C_TRACE( (_T("CBcaToIsc::HandlePepCtrlReq() ctrl id PEP_CTRL_ID_RETURNLOAN") ) );
+             if( iClientShutdownStatus )
+                 {
+                 C_TRACE( (_T("CBcaToIsc::HandlePepCtrlReq() completing shutdown") ) );
+                 User::RequestComplete(iClientShutdownStatus, ret);
+                 iClientShutdownStatus = NULL;
+                 }
+             }
+         }
+
+    SendPepCtrlResp(
+        trId,
+        senderDevice,
+        senderObject,
+        pipeHandle,
+        pepCtrlId,
+        pepType,
+        result );
+
+    C_TRACE( (_T("CBcaToIsc::HandlePepCtrlReq() <-") ) );
+    }
+
+