nudpconnection.cpp

Go to the documentation of this file.

/*
 * nudpconnection.cpp,v 1.1 2003/12/27 19:46:23 matti 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 "serversideasynch.h"
#include "nudpconnection.h"
#include "Log.h"

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

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

    return con;
}

CNUDPConnection::CNUDPConnection(RSocket* aSocket, 
                 RSocketServ *aSocketServ,
                 CServerSession &aSession,
                 TInt aMtu)
    : CConcreteConnection(aSocket, aSocketServ, aSession, aMtu)
{
    // ##TODO## Get port values somewhere...
    iSrcPort = 123;
    iDstPort = 124;
}

CNUDPConnection::~CNUDPConnection()
{
    // ##TODO## Reset the state machine?
}

// sending is asynchronous - possible failure is handled by closing the socket
// the client call will be completed immediately after 
// initiating the send operation
void CNUDPConnection::SendL(TDesC8 *aBuf)
{
    Log::Print(_L("CNUDPConnection::SendL()"));

    TInt maxPayload = GetMTU() - KNUDPHeaderSize;
    
    if (aBuf->Length() > maxPayload) {
    // The data must be fragmented
    TInt fragmentCount = (aBuf->Length() / maxPayload) + 
        (aBuf->Length() % maxPayload > 0 ? 1 : 0);
    RPointerArray<TDesC8> *fragments = 
        new (ELeave) RPointerArray<TDesC8>(fragmentCount);

    // Constrcuts fragments
    TInt pos = 0;
    TInt packet = 0;
    while (packet++ < fragmentCount) {
        if (packet == 1) {
        // First packet
        fragments->Append(CreateFrame(&(aBuf->Mid(0, maxPayload)),
                          KFirstFragment, 
                          aBuf->Length()));
        } else if (packet == fragmentCount) {
        // Last packet
        fragments->Append(CreateFrame(&(aBuf->Right(pos)), 
                          KLastFragment,
                          aBuf->Length() - pos));
        } else {
        // Middle packet
        fragments->Append(CreateFrame(&(aBuf->Mid(pos, maxPayload)),
                          KFirstFragment | KLastFragment, 
                          aBuf->Length()));
        }
        pos += maxPayload;
    }
    iSender->SendL(fragments);
    
    } else {
    // Single fragment
    iSender->SendL(CreateFrame(aBuf, 
                   KFirstFragment | KLastFragment, 
                   aBuf->Length()));
    }
}

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

    // ##TODO## dum-dum... pitäisi purkaa frame jotenkin ja passata
    // vasta sitten data clientille... ongelmia...
    // Tehdään oma nudp-spesifinen asynchreceive-luokka, joka hoitaa tämän
    // connectionin avulla vastaanottamisen tilakoneen...
    // miten mahtaa toimia homma useamman clientin kanssa?
    // pidetään tallessa pendaavia rmessageita porttinumeron perusteella
    // kun tulee kamaa sisään, haetaan siltä porttinumeron pohjalta
    // oikea rmessage ja lopetetaan pendaus

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

TDesC8 *CNUDPConnection::CreateFrame(TDesC8 *aBuf, TUint8 aFlags, 
                     TUint16 aLen)
{
    HBufC8 *buf = HBufC8::NewL(aBuf->Length() + KNUDPHeaderSize);
    TPtr8 ptr = buf->Des();
    // Constructs header
    ptr.Append(aFlags);
    ptr.Append(aLen);
    ptr.Append(iSrcPort);
    ptr.Append(iDstPort);
    // Adds payload
    ptr.Append(*aBuf);

    // ##TODO## Should we delete the aBuf?
    return buf;
}

---