concreteconnection.cpp

Go to the documentation of this file.

/*
 * $id: concreteconnection.cpp,v 1.18 2003/11/20 07:52:21 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 <e32base.h>
#include <e32svr.h>
#include <es_sock.h>

//#include "clientservercommon.h"
#include "serversideasynch.h"
#include "concreteconnection.h"
#include "Log.h"

// constructs a 'normal' connection
CConcreteConnection * CConcreteConnection::NewL(RSocket *aSocket,
                                                CServerSession &aSession,
                        TInt aMtu)
{
    CConcreteConnection *con = new (ELeave) CConcreteConnection(aSocket, 
                                                                NULL,
                                                                aSession,
                                aMtu);
    CleanupStack::PushL(con);
    con->ConstructL(EFalse);
    CleanupStack::Pop(); // con

    return con;
}

// constructs a listening connection
CConcreteConnection * CConcreteConnection::NewListeningL(RSocket *aSocket,
                                                         RSocketServ *aSocketServ,
                                                         CServerSession &aSession)
{
    CConcreteConnection *con = new (ELeave) CConcreteConnection(aSocket, 
                                                                aSocketServ,
                                                                aSession,
                                128);  // ##TODO## Resolve MTU!
    CleanupStack::PushL(con);
    con->ConstructL(ETrue);
    CleanupStack::Pop(); // con
    return con;
}

CConcreteConnection::CConcreteConnection(RSocket* aSocket, 
                                         RSocketServ *aSocketServ,
                                         CServerSession &aSession,
                     TInt aMtu)
    : iSocket(aSocket),
      iSocketServ(aSocketServ),
      iSession(aSession),
      iIsClosed(EFalse),
      iMtu(aMtu)
{
}

CConcreteConnection::~CConcreteConnection()
{
    if( !iIsListening ) {
        // deallocate self from session's socket table
        iSession.DeallocateConnection(this);
    }

    // must not delete
    iSocketServ = NULL;

    // close the connection and delete asynch handlers
    Close();
}

// constructs either a 'normal' or a listening connection
// performs assertions on member data 
void CConcreteConnection::ConstructL(TBool aIsListening)
{
    if( iSocket == NULL ) User::Leave(ENullSocket);

    iIsListening = aIsListening;

    if( !aIsListening ) {
        Log::Print(_L("constructing connecting connection"));

        // connecting socket connection
        iSender = new (ELeave) CAsynchSend(this);
        iReceiver = new (ELeave) CAsynchReceive(this);
    } else {
        Log::Print(_L("constructing listening connection"));

        // listening connection
        iListener = new (ELeave) CAsynchListen(this);
    }
}

// sending is asynchronous - possible failure is handled by closing the socket
void CConcreteConnection::SendL(TDesC8 *aBuf)
{
    Log::Print(_L("CConcreteConnection::SendL()"));

    if( iSocket == NULL ) {
        Log::Print(_L("SendL(): socket closed!"));

        User::Leave(ESocketClosed);
    }

    // dispatch send. the client call will be completed immediately after 
    // initiating the send operation
    iSender->SendL(aBuf);
}

// listening is asynchronous
void CConcreteConnection::ListenL(const RMessage &aMessage) 
{
    Log::Print(_L("CConcreteConnection::ListenL()"));

    if( iSocket == NULL ) {
        Log::Print(_L("ListenL(): socket closed!"));

        User::Leave(ENoSocket);
    }

    // dispatch listener AO
    iListener->ListenL(aMessage);
}

void CConcreteConnection::ReceiveL(const RMessage &aMessage) 
{
    Log::Print(_L("CConcreteConnection::Receive()"));

    if( iSocket == NULL ) {
        Log::Print(_L("ReceiveL(): socket closed!"));

        User::Leave(ESocketClosed);
    }

    // dispatch receive. the client call will be completed upon receiving data
    iReceiver->Receive(aMessage);
}

void CConcreteConnection::Close(TBool aImmediately)
{
    // check if already closed
    if( iIsClosed ) return;

    Log::Print(_L("CConcreteConnection::Close(): listening: %d, imm: %d"),
        iIsListening, aImmediately);

    if( !iIsListening ) {
        Log::Print(_L("deleting sender & receiver"));
        iSender->Cancel();
        delete iSender;
        iSender = NULL;
        iReceiver->Cancel();
        delete iReceiver;
        iReceiver = NULL;
    } else {
        Log::Print(_L("deleting listener"));
        iListener->Cancel();
        delete iListener;
        iListener = NULL;
    }

    if( aImmediately && !iIsListening ) {
        Log::Print(_L("Calling Shutdown()"));
        TRequestStatus status;
        iSocket->Shutdown(RSocket::EImmediate, status);
        Log::Print(_L("Waiting for request completion"));
        User::WaitForRequest(status);
    }

    // close socket
    iSocket->Close();

    if( !iIsListening ) {
        // delete the socket instance
        delete iSocket;
        iSocket = NULL;
    }

    // mark the connection as closed
    iIsClosed = ETrue;

    Log::Print(_L("CConcreteConnection::Close(): exiting.."));
}

void CConcreteConnection::CancelListen()
{
    iListener->Cancel();
}

void CConcreteConnection::CancelReceive()
{
    iReceiver->Cancel();
}

// Returns maximum transfer unit of this connection as
// defined when the connection was established.
TInt CConcreteConnection::GetMTU()
{
    return iMtu;
}

---