clientsession.cpp

Go to the documentation of this file.

/*
 * clientsession.cpp,v 1.37 2004/01/10 14:27:11 mattid Exp
 *
 * COBAIN - Communications API for EPOC Environments
 * Copyright (C) 2002-2004 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()
{
    Log::Print(_L("~RCobainClientSession()"));

    if( iIsConnected ) {
        Close();
        iIsConnected = EFalse;
    }

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

void 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 aServiceID, 
                                         TPckgBuf<TInt> *aPeerCountBuffer, 
                                         TRequestStatus &aNotifyStatus)
{
    TInt p[4];

    p[0] = aProtocol;
    p[1] = (TInt)aPeerCountBuffer;
    p[2] = (TInt)aServiceID;
    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);
        list->Append(peer);
    }

    CleanupStack::Pop(); // list 

    return list;
}
*/

TInt RCobainClientSession::Connect() 
{
    TInt rc = ::StartServer();

    __ASSERT_ALWAYS(rc == KErrNone, 
        User::Panic(KCobainClientPanic, KErrCCPServerStartFailed));

    TVersion version(KCobainServerMajorVersion,
                     KCobainServerMinorVersion,
                     KCobainServerBuildVersion);

    rc = CreateSession(KCobainServerName, 
                       version,
                       KNumMessageSlots);

    return rc;
}

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

    p[0] = (TInt)aProtocol;
    p[1] = (TInt)aPort;
    p[2] = (TInt)aExtraInfo;
    
    User::LeaveIfError(SendReceive(CCobainServer::EStartListen, p));
}

// 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];

    // 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;

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

    // copy peer data and package it for call
    aPeer->WritePeerData(data);
    TPeerDataBuf peer_buf(data);

    p[0] = aPeer->GetProtocol();
    p[1] = (TInt)&peer_buf;
    p[2] = (TInt)&id_buf;
    
    Log::Print(_L("calling SendReceive(): EConnect"));

    User::LeaveIfError(SendReceive(CCobainServer::EConnect, p));
    
    RCobainSocket *socket = new (ELeave) RCobainSocket(*this, id_buf());

    Log::Print(_L("RCobainClientSession::ConnectSocketL() returning.."));

    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];

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

    return SendReceive(CCobainServer::ESend, p);
}

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;
}

---