serversession.cpp

Go to the documentation of this file.

/*
 * serversession.cpp,v 1.43 2004/01/10 14:27:11 mattid Exp
 *
 * COBAIN - Communications API for EPOC Environments
 * Copyright (C) 2002-2003 Matti Dahlbom, Matti Kokkola
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 * Contact: Matti Dahlbom <matti@777-team.org>
 *          Matti Kokkola <matti.kokkola@iki.fi>
 */

#include "serversession.h"
#include "concreteconnection.h"
#include "Log.h"
#include "bt_sock.h"
//#include "receivesession.h"

CServerSession::CServerSession(RThread& aClient, 
                               CCobainServer* aServer) 
    : CSession(aClient),
      iServer(aServer)
{
    Log::Print(_L("** created a session"));

    // clear connections table
    Mem::FillZ(iConnections, sizeof(iConnections));
}

CServerSession::~CServerSession()
{
    // if this has already

    Log::Print(_L("** Session dying"));

    // kill bluetooth
    iBTCommunicator->StopListeningL();
    delete iBTCommunicator;
    iBTCommunicator = NULL;

    // close & deallocate all sockets in the socket table
    for( TInt i = 0; i < KMaxSocketCount; i++ ) {
        if( iConnections[i] != NULL ) {
            Log::Print(_L("~CServerSession: killing con %d"), i);

            iConnections[i]->Close(ETrue);

            delete iConnections[i];
            iConnections[i] = NULL;
        }
    }

    // inform server about our death
    iServer->DecrementSession();

    // deallocate existing peer list
    if( iPeerList != NULL ) {
        iPeerList->ResetAndDestroy();
        delete iPeerList;
        iPeerList = NULL;
    }
}

CServerSession* CServerSession::NewL(RThread& aClient, 
                                     CCobainServer* aServer) 
{
    CServerSession *session = new (ELeave)CServerSession(aClient, aServer);
    CleanupStack::PushL(session);
    session->ConstructL();
    CleanupStack::Pop(); // session

    return session;
}

void CServerSession::ConstructL()
{
    // increment client count
    iServer->IncrementSession();

    // create bluetooth communicator
    iBTCommunicator = CBTCommunicator::NewL(this);
}

CConcreteConnection* CServerSession::GetConnection(TInt id) 
{
    if( (id < 0) || (id >= KMaxSocketCount) ) {
        User::Panic(KSessionPanic, KErrSessionBadSocketTableIndex);
    }

    CConcreteConnection *con = iConnections[id];
    if( con == NULL ) {
        User::Panic(KSessionPanic, KErrSessionConnectionNotFoundInGet);
    }

    return con;
}

// allocates room in connections table for the connection
TInt CServerSession::AllocateConnection(CConcreteConnection *aConnection) 
{
    TInt slot = -1;

    __ASSERT_ALWAYS(!aConnection->IsListening(), 
                    User::Panic(KSessionPanic, KErrSessionTryingToAllocListeningCon));

    for( TInt i = 0; i < KMaxSocketCount; i++ ) {
        if( iConnections[i] == NULL ) {
            slot = i;
            break;
        }
    }

    if( slot == -1 ) {
        // no room in table - panic!
        CCobainServer::PanicServer(CCobainServer::ESocketTableFull);
    }

    Log::Print(_L("AllocateConnection(): id: %d"), slot);

    iConnections[slot] = aConnection;

    return slot;
}

// removes the given connection from the connections table
void CServerSession::DeallocateConnection(CConcreteConnection *aConnection)
{
    __ASSERT_ALWAYS(!aConnection->IsListening(), 
                    User::Panic(KSessionPanic, KErrSessionTryingToDeallocListeningCon));

    Log::Print(_L("DeallocateConnection()"));

    for( TInt i = 0; i < KMaxSocketCount; i++ ) {
        if( aConnection == iConnections[i] ) {
            iConnections[i] = NULL;
            return;
        }
    }

    Log::Print(_L("DeallocateConnection() exiting.."));
}

void CServerSession::SetPeerList(TPeerDataList *aPeerList)
{
    // if a peer list exists, it must be deleted first
    delete iPeerList;
    iPeerList = aPeerList;
}

// GetNumPeersL() has to be called first.
// Int0 - ordinal (n) of the requested peer
// Ptr1 - pointer to client-side buffer
void CServerSession::GetPeer(const RMessage &aMessage)
{
    TInt n = aMessage.Int0();

    Log::Print(_L("CServerSession::GetPeer(): n: %d"), n);

    if( (n < 0) || (n >= iPeerList->Count()) ) {
        // bad ordinal supplied
        aMessage.Complete(KErrArgument);
    }

    // write info about requested (n:th) peer
    TPeerData *data = (*iPeerList)[n];
    TPeerDataBuf buf = *data;
    aMessage.WriteL(aMessage.Ptr1(), buf);

    aMessage.Complete(KErrNone);
    return;
}

// Int0() - requested protocol
// Ptr1() - buffer for number of peers (TInt)
// Int2() - requested service identifyer (aServiceClassID for BT)
void CServerSession::GetNumPeersL(const RMessage &aMessage)
{
    // deallocate existing peer list
    if( iPeerList != NULL ) {
        iPeerList->ResetAndDestroy();
        delete iPeerList;
        iPeerList = NULL;
    }

    switch( aMessage.Int0() ) {
        case EBluetooth:
            // initiate device discovery. 
            // NOTE: the call will be completed by an active object
            iBTCommunicator->DiscoverPeersL(aMessage, 
                                            *this);
            break;
        default:
            PanicClient(aMessage, CCobainServer::EBadRequest);
            break;
    }
}

// Int0() - requested protocol (i.e. bearer)
// Ptr1() - pointer to clientside TPeerDataBuf
// Ptr2() - pointer to clientside TPckgBuf<TInt> to store the id
// ##TODO## Add parameter for requtested transfer protocol (i.e.
// nanoTCP, nanoUDP etc)
void CServerSession::ConnectL(const RMessage &aMessage)
{
    TPeerDataBuf buf;
    TInt err = KErrNone;

    // copy peer data
    aMessage.ReadL(aMessage.Ptr1(), buf);
    TPeerData &data = buf();

    // connect to the peer
    RSocket *socket = NULL;
    TInt mtu = 0;

    switch ( aMessage.Int0() ) {
        case EBluetooth:
            TRAP(err, (socket = iBTCommunicator->ConnectL(&data)));
            mtu = CBTCommunicator::ResolveMTU(*socket);
            break;

        default:
            PanicClient(aMessage, CCobainServer::EUnsupportedProtocol);
            break;
    }

    if( err != KErrNone ) {
        Log::Print(_L("ConnectL() error: %d"), err);

        // error connecting - complete call with error (negative value)
        aMessage.Complete(err);
        return;
    }

    // allocate new connection
    TInt slot = AllocateConnection(CConcreteConnection::NewL(socket, *this, mtu));

    // write the id 
    TPckgBuf<TInt> id_buf(slot);
    aMessage.WriteL(aMessage.Ptr2(), id_buf);

    aMessage.Complete(KErrNone);

    Log::Print(_L("CServerSession::ConnectL() returning.."));
}

// Int0() - socket id
// Int1() - whether to close socket abruptively (ETrue = yes, EFalse = no)
void CServerSession::CloseSocket(const RMessage &aMessage)
{
    TInt n = aMessage.Int0();

    Log::Print(_L("CServerSession::CloseSocket() %d"), n);

    CConcreteConnection *con = GetConnection(n);
    DeallocateConnection(con);

    TBool immediately = (TBool)aMessage.Int1();

    Log::Print(_L("calling con->Close()"));

    con->Close(immediately);
    delete con;

    aMessage.Complete(KErrNone);

    Log::Print(_L("CloseSocket() exiting"));
}

// asynchronous call to retrieve the next incoming connection info.
// calls asynchronous listen handler which will handle the completion of the 
// message when a new connection is available
void CServerSession::GetIncomingConnection(const RMessage& aMessage)
{
    if( iListeningConnection == NULL ) {
        PanicClient(aMessage, CCobainServer::ENotListening);
    }

    // launches asynchronous listen handler and returns
    iListeningConnection->ListenL(aMessage);    
}

// this is a synchronous call to start listening to a given port
//
// Int0() - protocol
// Int1() - port 
// Int2() - protocol specific extra info
void CServerSession::StartListen(const RMessage& aMessage)
{
    if( iListeningConnection != NULL ) {
        PanicClient(aMessage, CCobainServer::EAlreadyListening);
    }

    TUint port = (TUint)aMessage.Int1();
    TUint list_sock_type = (TUint)aMessage.Int2();

    //##TODO## read these from client
    _LIT8(KServiceName, "Cobain");
    _LIT8(KServiceDesc, "CobainServiceDesc");

    switch( aMessage.Int0() ) {
        case EBluetooth:
            iListeningConnection = iBTCommunicator->StartListeningL(port,
                                                                    -1,
                                                                    KServiceName,
                                                                    KServiceDesc,
                                                                    list_sock_type);
            break;
        default:
            PanicClient(aMessage, CCobainServer::EUnsupportedProtocol);
            break;
    }

    // complete the message, allowing client call to return
    aMessage.Complete(KErrNone);
}

// Int0() - protocol
void CServerSession::AbortListen(const RMessage& aMessage)
{
    Log::Print(_L("AbortListen()"));

    switch( aMessage.Int0() ) {
        case EBluetooth:
            iBTCommunicator->StopListeningL();
            break;
        default:
            PanicClient(aMessage, CCobainServer::EUnsupportedProtocol);
            break;
    }

    iListeningConnection = NULL;

    aMessage.Complete(KErrNone);
}

// Int0() - socket ID
// Ptr1() - buffer for received packet of size minimum KRecvBufSize
void CServerSession::Receive(const RMessage& aMessage)
{
    Log::Print(_L("CServerSession::Receive()"));

    TInt n = aMessage.Int0();
    CConcreteConnection *con = GetConnection(n);
    con->ReceiveL(aMessage);

    Log::Print(_L("CServerSession::Receive() returning"));
}

// Int0 - socket id
void CServerSession::CancelReceive(const RMessage &aMessage) 
{
    Log::Print(_L("CancelReceive()"));

    TInt id = aMessage.Int0();
    CConcreteConnection *con = GetConnection(id);
    con->CancelReceive();
    aMessage.Complete(KErrNone);
}

// Int0() - socket id
// Int1() - data length
// Ptr2() - send buffer
void CServerSession::Send(const RMessage &aMessage)
{
    TInt id = aMessage.Int0();
    TInt len = aMessage.Int1();

    Log::Print(_L("Send(): id: %d, len: %d"), id, len);

    // allocate buffer for the data. buffer will be released by CAsynchSend
    // after it has been sent
    HBufC8 *buf = HBufC8::NewL(len);
    CleanupStack::PushL(buf);

    // read data from client thread
    TPtr8 ptr = buf->Des();
    aMessage.ReadL(aMessage.Ptr2(), ptr);

    // get the connection matching the socket id
    CConcreteConnection *con = GetConnection(id);

    // send the data
    TRAPD(err, con->SendL(buf));

    CleanupStack::Pop(); // buf

    // allow client call to return
    //##TODO## handle error situations
    aMessage.Complete(err);
}

void CServerSession::ServiceL(const RMessage& aMessage)
{
    TInt function = aMessage.Function();

//    Log::Print(_L("ServiceL(): %d"), function);

    switch( function )
    {
        case CCobainServer::ESend:
            Send(aMessage);
            break;
        case CCobainServer::EConnect:
            ConnectL(aMessage);
            break;
        case CCobainServer::ECloseSocket:
            CloseSocket(aMessage);
            break;
        case CCobainServer::EGetNumPeers:
            GetNumPeersL(aMessage);
            break;
        case CCobainServer::EGetPeer:
            GetPeer(aMessage);
            break;
        case CCobainServer::EStartListen:
            StartListen(aMessage);
            break;
        case CCobainServer::EAbortListen:
            AbortListen(aMessage);
            break;
        case CCobainServer::EGetIncomingConnection:
            GetIncomingConnection(aMessage);
            break;
        case CCobainServer::EReceive:
            Receive(aMessage);
            break;
        case CCobainServer::ECancelReceive:
            CancelReceive(aMessage);
            break;
        default:
            PanicClient(aMessage, CCobainServer::EBadRequest);
            break;
    }

    //Log::Print(_L("ServiceL() returning"));
}

void CServerSession::PanicClient(const RMessage& aMessage, 
                                 CCobainServer::TServerPanic aPanic)
{
    aMessage.Panic(KClientPanic, aPanic);
}

---