clientsession.cpp

Go to the documentation of this file.

/*
 * clientsession.cpp,v 1.33 2003/11/25 19:29:56 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 <e32math.h>

#include "clientsession.h"
//#include "ClientSubSession.h"
#include "cobainserver.h"
#include "clientservercommon.h"

#ifdef __WINS__
static const TUint KServerMinHeapSize =  0x1000;  //  4K
static const TUint KServerMaxHeapSize = 0x10000;  // 64K
#endif

static TInt StartServer();
static TInt CreateServerProcess();

// public API methods

RCobainClientSession::RCobainClientSession()
    : iIsConnected(EFalse)
{
}

RCobainClientSession::~RCobainClientSession()
{
    Close();
    iIsConnected = EFalse;
}

void RCobainClientSession::ConstructL()
{
    CCobainLayer::Log(_L("RCobainClientSession::ConstructL()"));

    // connect to the server
    User::LeaveIfError(Connect());
}

// discovers the peers. asynchronously returns the number of the peers
void RCobainClientSession::DiscoverPeers(TProtocol aProtocol, TUint aPort, 
                                         TPckgBuf<TInt> *aPeerCountBuffer, 
                                         TRequestStatus &aNotifyStatus)
{
    TInt p[4];

    p[0] = aProtocol;
    p[1] = (TInt)aPeerCountBuffer;
    p[2] = (TInt)aPort;
    SendReceive(CCobainServer::EGetNumPeers, p, aNotifyStatus);
}

void RCobainClientSession::FetchPeerData(TInt aPeerOrdinal, TPeerDataBuf *aPeerBuffer, 
                                         TRequestStatus &aNotifyStatus)
{
    TInt p[4];

    p[0] = aPeerOrdinal;
    p[1] = (TInt)aPeerBuffer;
    SendReceive(CCobainServer::EGetPeer, p, aNotifyStatus);
}

TPeerList* RCobainClientSession::DiscoverBTPeersL(TUint aServiceClassID)
{
    TBuf8<sizeof(TInt)> sizebuf;
    TPeerDataBuf peerbuf;
    TInt p[4];

    // fetch the number of peers
    p[0] = EBluetooth;
    p[1] = (TInt)(&sizebuf);
    p[2] = (TInt)aServiceClassID;
    User::LeaveIfError(SendReceive(CCobainServer::EGetNumPeers, p));

    TInt num;
    Mem::Copy(&num, sizebuf.Ptr(), sizeof(TInt));

    TBuf<32> buf;
    buf.Format(_L("found %d peer(s)"), num);
    CCobainLayer::Log(buf);

    // allocate the peer list
    TPeerList *list = new (ELeave) TPeerList();
    CleanupStack::PushL(list);

    // fetch all the matched peers
    for( TInt i = 0; i < num; i++ ) {
        p[0] = i;
        p[1] = (TInt)(&peerbuf);
        User::LeaveIfError(SendReceive(CCobainServer::EGetPeer, p));

        // add peer entry
        TPeerData data = peerbuf();
        CNetworkPeer *peer = CNetworkPeer::NewL(*this, 
                                                EBluetooth,
                                                data.iDeviceName, 
                                                data.iDeviceAddress,
                                                data.iServiceID,
                                                data.iPort);
        list->Append(peer);
    }

    CleanupStack::Pop(); // list 

    return list;
}

TInt RCobainClientSession::Connect() 
{
    TBuf<128> logbuf;

    CCobainLayer::Log(_L("RCobainClientSession::Connect()"));

    TInt rc = ::StartServer();
    if( rc != KErrNone ) {
        logbuf.Format(_L("StartServer() error %d"), rc);
        CCobainLayer::Log(logbuf);
    }

    if( rc == KErrNone ) 
    {
        TVersion version(KCobainServerMajorVersion,
                         KCobainServerMinorVersion,
                         KCobainServerBuildVersion);

        rc = CreateSession(KCobainServerName, 
                           version,
                           KNumMessageSlots);

        if( rc != KErrNone ) {
            logbuf.Format(_L("CreateSession() error %d"), rc);
            CCobainLayer::Log(logbuf);
        } else {
            CCobainLayer::Log(_L("connected to server"));
        }
    }

    return rc;
}

// synchronous call to start listening on a port
void RCobainClientSession::StartListening(TProtocol aProtocol, 
                                          TUint aPort)
{
    TInt p[4];

    p[0] = (TInt)aProtocol;
    p[1] = (TInt)aPort;
    SendReceive(CCobainServer::EStartListen, p);

    CCobainLayer::Log(_L("StartListening() returning"));
}

// aborts pending listening operation
void RCobainClientSession::StopListening(TProtocol aProtocol, TUint aPort)
{
    TInt p[4];

    p[0] = (TInt)aProtocol;
    p[1] = (TInt)aPort;

    // synchronously call server to abort pending listen operation
    SendReceive(CCobainServer::EAbortListen, p);
}

// asynchronous call to wait for new inbound connection 
void RCobainClientSession::GetIncomingSocketL(TRequestStatus &aNotifyStatus)
{
    TInt p[4];

    CCobainLayer::Log(_L("GetIncomingSocketL()"));

    // asynchronously call server to get socket id
    SendReceive(CCobainServer::EGetIncomingConnection, p, aNotifyStatus);
}

// synchronously connects to the peer
RCobainSocket* RCobainClientSession::ConnectSocketL(CNetworkPeer *aPeer)
{
    TInt p[4];
    TPeerData data;
    TPckgBuf<TInt> id_buf;

    CCobainLayer::Log(_L("RCobainClientSession::ConnectSocketL()"));

    // copy peer data and package it for call
    data.iDeviceAddress.Copy(aPeer->GetDeviceAddress());
    data.iDeviceName.Copy(aPeer->GetDeviceName());
    data.iPort = aPeer->GetPort();
    data.iServiceID.Copy(aPeer->GetServiceID());

    TPeerDataBuf peer_buf(data);

    p[0] = aPeer->GetProtocol();
    p[1] = (TInt)&peer_buf;
    p[2] = (TInt)&id_buf;
    
    User::LeaveIfError(SendReceive(CCobainServer::EConnect, p));

    RCobainSocket *socket = new (ELeave) RCobainSocket(*this, id_buf());

    CCobainLayer::Log(_L("RCobainClientSession::ConnectSocketL() exiting.."));

    return socket;
}

// synchronously calls server to close the actual socket resource
void RCobainClientSession::CloseSocket(TInt aId, TBool aImmediately)
{
    TInt p[4];

    p[0] = aId;
    p[1] = (TInt)aImmediately;
    SendReceive(CCobainServer::ECloseSocket, p);
}

TInt RCobainClientSession::Send(TInt aSocketId, const TDesC8 *aBuf)
{
    TInt p[4];

    CCobainLayer::Log(_L("Send()"));

    p[0] = aSocketId;
    p[1] = aBuf->Length();
    p[2] = (TInt)aBuf;

    return SendReceive(CCobainServer::ESend, p);

    CCobainLayer::Log(_L("Send() exiting.."));

}

void RCobainClientSession::Receive(TInt aSocketId, 
                                   TDes8* aBuffer,
                                   TRequestStatus& aStatus) 
{
    TInt p[4];

    p[0] = aSocketId;
    p[1] = (TInt)aBuffer;
    SendReceive(CCobainServer::EReceive, p, aStatus);
}

void RCobainClientSession::CancelReceive(TInt aSocketId) 
{
    TInt p[4];

    p[0] = aSocketId;
    SendReceive(CCobainServer::ECancelReceive, p);
}

// Static functions for server bootstrap 

static TInt StartServer()
{
  TInt rc = 0;

  TFindServer findServer(KCobainServerName);
  TFullName name;

  rc = findServer.Next(name);
  if (rc == KErrNone)
    {
      // Server already running
      return KErrNone;
    }
    
  RSemaphore semaphore;
  rc = semaphore.CreateGlobal(KCobainServerSemaphoreName, 0);
  if (rc != KErrNone)
    {
      return rc;
    }

  rc = CreateServerProcess();
  if (rc != KErrNone)
    {
      return  rc;
    }

  semaphore.Wait();
  semaphore.Close();       

  return  KErrNone;
}

static TInt CreateServerProcess()
{
    TInt rc = 0;

    const TUidType serverUid(KNullUid, KNullUid, KCobainServerUid3);

#ifdef __WINS__

    RLibrary lib;
    rc = lib.Load(KCobainServerFilename, serverUid);
    if( rc != KErrNone )
    {
        return  rc;
    }

    //  Get the WinsMain function
    TLibraryFunction functionWinsMain = lib.Lookup(1);

    //  Call it and cast the result to a thread function
    TThreadFunction serverThreadFunction = 
        reinterpret_cast<TThreadFunction>(functionWinsMain());

    TName threadName(KCobainServerName);

    // Append a random number to make it unique
    threadName.AppendNum(Math::Random(), EHex);

    RThread server;

    rc = server.Create(threadName,   // create new server thread
                       serverThreadFunction, // thread's main function
                       KDefaultStackSize,
                       NULL,
                       &lib,
                       NULL,
                       KServerMinHeapSize,
                       KServerMaxHeapSize,
                       EOwnerProcess);

    lib.Close();    // if successful, server thread has handle to library now

    if (rc != KErrNone)
    {
        return  rc;
    }

    server.SetPriority(EPriorityMore);

#else
    RProcess server;

    rc = server.Create(KCobainServerFilename, 
                       _L(""), 
                       serverUid);
    if (rc != KErrNone)
    {
        return  rc;
    }

#endif

    // Invokes ThreadFunction() function of the CobainServer
    server.Resume();
    server.Close();

    return  KErrNone;
}

// EPOC dll entry point
GLDEF_C TInt E32Dll(TDllReason) {
    return KErrNone;
}

---