serversideasynch.cpp

Go to the documentation of this file.

/*
 * serversideasynch.cpp,v 1.15 2004/01/06 17:05:41 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 "clientservercommon.h"
#include "serversideasynch.h"
#include "concreteconnection.h"
#include "Log.h"

// dummy RMessage used to initialize references
RMessage KDummyMessage;

// CAsynchBase

CAsynchBase::CAsynchBase(CConcreteConnection *aConnection)
    : CActive(CActive::EPriorityStandard),
      iConnection(aConnection),
      iMessage(KDummyMessage)
{
    CActiveScheduler::Add(this);
}

CAsynchBase::~CAsynchBase()
{
    Log::Print(_L("~CAsynchBase()"));

    // cancel pending operation if any
    Cancel();

    // remove from scheduler
    Deque();

    Log::Print(_L("~CAsynchBase() exiting.."));
}

// CAsynchSend

CAsynchSend::CAsynchSend(CConcreteConnection *aConnection)
    : CAsynchBase(aConnection)
{
}

void CAsynchSend::SendL(TDesC8 *aBuf)
{
    Log::Print(_L("CAsynchSend::SendL()"));

    iFragmentCount = 1;
    iFragments = NULL;
    SendFragmentL(aBuf);
}

// Fragment aware SendL
void CAsynchSend::SendL(RPointerArray<TDesC8> *aFragments)
{
    Log::Print(_L("CAsynchSend::SendL()"));

    iFragments = aFragments;
    iFragmentCount = iFragments->Count();
    SendFragmentL((*iFragments)[0]);
}

void CAsynchSend::SendFragmentL(TDesC8 *aBuf) 
{
    iSendBuf = aBuf;    
    iConnection->GetSocket().Write(*aBuf, iStatus);
    SetActive();
}

void CAsynchSend::RunL()
{
    Log::Print(_L("CAsynchSend::RunL()"));

    // fragment sent; release buffer
    delete iSendBuf;
    iSendBuf = NULL;

    // anymore fragments left?
    if (--iFragmentCount > 0) {
    iFragments->Remove(0);
    SendFragmentL((*iFragments)[0]);
    } else {
    // Last fragment sent
    if (iFragments != NULL) {
        delete iFragments;
        iFragments = NULL;
    }
    }
}

TInt CAsynchSend::RunError(TInt aError)
{
    Log::Print(_L("CAsynchSend::RunError(): %d"), aError);

    iConnection->Close();
    CleanBuffers();

    return KErrNone;
}

// cancel pending send operation
void CAsynchSend::DoCancel()
{
    Log::Print(_L("CAsynchSend::DoCancel()"));

    iConnection->GetSocket().CancelSend();
    CleanBuffers();

    Log::Print(_L("CAsynchSend::DoCancel() exiting"));
}

void CAsynchSend::CleanBuffers()
{
    delete iSendBuf;
    iSendBuf = NULL;
    
    if (iFragments != NULL) {
    iFragments->ResetAndDestroy();
    delete iFragments;
    iFragments = NULL;
    }
}

// CAsynchReceive

CAsynchReceive::CAsynchReceive(CConcreteConnection *aConnection) 
  : CAsynchBase(aConnection)
{
  // do nothing
}

// asynchronous call to start waiting for data
void CAsynchReceive::Receive(const RMessage &aMessage) 
{
    Log::Print(_L("CAsynchReceive::Receive()"));

    // store the pending message
    iMessage = aMessage;

//    Log::Print(_L("calling RecvOneOrMore()"));
 //   iConnection->GetSocket().RecvOneOrMore(iRecvBuf, 0, iStatus, iRecvLen);
    Log::Print(_L("calling Read()"));
    iConnection->GetSocket().Read(iRecvBuf, iStatus);

//    Log::Print(_L("calling SetActive()"));
    SetActive();

    Log::Print(_L("CAsynchReceive::Receive() exiting.."));
}

// new data available. writes the data into the clientside buffer and completes
// the call
void CAsynchReceive::RunL()
{
    Log::Print(_L("CAsynchReceive::RunL()"));

    TInt status = iStatus.Int();
    if( status != KErrNone ) {
        Log::Print(_L("CAsynchReceive::RunL(): error (%d)"), status);

        // notify client about the error
        iMessage.Complete(status);

        return;
    }

    Log::Print(_L("received %d bytes"), iRecvBuf.Length());

    // write the data into the buffer of the pending message
    TRAPD(err, iMessage.WriteL(iMessage.Ptr1(), iRecvBuf));
    Log::Print(_L("WriteL() returned %d"), err);

    //Log::Print(_L("RECEIVE completing %d"), iMessage);

    // complete the pending call
    iMessage.Complete(err);

    //##TODO## remove
    // forget about the message
//    iMessage = NULL;

    Log::Print(_L("CAsynchReceive::RunL() returning.."));
}

TInt CAsynchReceive::RunError(TInt aError)
{
    Log::Print(_L("CAsynchReceive::RunError(): %d"), aError);

    //##TODO##: connection closed? close resources

    iMessage.Complete(aError);

    //##TODO## remove
    // forget about the message
//    iMessage = NULL;

    return KErrNone;
}

// cancels pending receive operation
void CAsynchReceive::DoCancel()
{
    Log::Print(_L("CAsynchReceive::DoCancel()"));

    iConnection->GetSocket().CancelRecv();

    Log::Print(_L("completing message.."));

    //##TODO## use error code
    iMessage.Complete(KErrNone);

    Log::Print(_L("CAsynchReceive::DoCancel() exiting"));
}

// CAsynchListen

CAsynchListen::CAsynchListen(CConcreteConnection *aConnection) 
    : CAsynchBase(aConnection)
{
}

CAsynchListen::~CAsynchListen()
{
    delete iIncomingSocket;
}

// will listen to socket from iConnection->GetSocket()
void CAsynchListen::ListenL(const RMessage &aMessage)
{
    Log::Print(_L("CAsynchListen::ListenL()"));

    // store the pending message
    iMessage = aMessage;

    // deallocate previous socket
    delete iIncomingSocket;
    iIncomingSocket = NULL;

    // allocate a blank socket 
    iIncomingSocket = new (ELeave) RSocket();

    RSocketServ &sock_serv = iConnection->GetSocketServ();
    User::LeaveIfError(iIncomingSocket->Open(sock_serv));

    // start waiting for inbound connection
    iConnection->GetSocket().Accept(*iIncomingSocket, iStatus);

    SetActive();

    Log::Print(_L("CAsynchListen::ListenL() returning"));
}

// a new inbound connection pending - estabilish connection and allocate
// resources. completes the original message to allow client call to return
void CAsynchListen::RunL()
{
    CConcreteConnection *con = NULL;

    TInt status = iStatus.Int();
    if( status != KErrNone ) {
        Log::Print(_L("CAsynchListen::RunL() error %d"), status);

        iMessage.Complete(status);
        return;
    }

    Log::Print(_L("CAsynchListen::RunL()"));
    TInt mtu = CBTCommunicator::ResolveMTU(*iIncomingSocket);
    con = CConcreteConnection::NewL(iIncomingSocket, iConnection->GetSession(), mtu);

    // forget about the socket as it will be released by others
    iIncomingSocket = NULL;

    Log::Print(_L("calling AllocateConnection()"));

    TInt id = iConnection->GetSession().AllocateConnection(con);

    // complete the message with the connection id
    iMessage.Complete(id);
}

// cancel pending listen operation
void CAsynchListen::DoCancel()
{
    Log::Print(_L("CAsynchListen::DoCancel()"));

    iConnection->GetSocket().CancelAccept();

    // complete the message with the connection id
    //##TODO## no-no.. this wont work
    iMessage.Complete(iStatus.Int());

    Log::Print(_L("CAsynchListen::DoCancel() exiting"));
}

TInt CAsynchListen::RunError(TInt aError)
{
    Log::Print(_L("CAsynchListen::RunError(): %d"), aError);

    //##TODO## handle the error

    // complete the message with the connection id
    //##TODO## whaat? no-no..
    //Log::Print(_L("COMPLETING %d"), iMessage);
    iMessage.Complete(iStatus.Int());

    return KErrNone;
}

---