tmserversession.cpp

c++下s60终端对终端传输协议

/* Copyright (c) 2005, Forum Nokia. All rights reserved */


// INCLUDE FILES
#include <e32math.h>
#include "TmServerSession.h"

// FUNCTION PROTOTYPES
TInt StartServer();
TInt CreateServerProcess();

// ========================= MEMBER FUNCTIONS ==================================

// -----------------------------------------------------------------------------
// RTmServerSession::RTmServerSession()
// C++ default constructor can NOT contain any code, that might leave.
// -----------------------------------------------------------------------------
//
EXPORT_C RTmServerSession::RTmServerSession()
: RSessionBase()
    {
    // No implementation required
    }

// -----------------------------------------------------------------------------
// RTmServerSession::Connect()
// Connects to the server and creates a session.
// -----------------------------------------------------------------------------
//
EXPORT_C TInt RTmServerSession::Connect()
    {
    TInt error = StartServer();

    if ( KErrNone == error )
        {
        error = CreateSession( KTmServerName,
                               Version(),
                               KDefaultMessageSlots );
        }
    return error;
    }

// -----------------------------------------------------------------------------
// RTmServerSession::Version()
// Gets the version number.
// -----------------------------------------------------------------------------
//
TVersion RTmServerSession::Version() const
    {
    return( TVersion( KTmServMajorVersionNumber,
                      KTmServMinorVersionNumber,
                      KTmServBuildVersionNumber ) );
    }

// -----------------------------------------------------------------------------
// RTmServerSession::GetServerAddress()
// 
// -----------------------------------------------------------------------------
//
EXPORT_C void RTmServerSession::GetServerAddress(TDes& anAddress) const
    {
    TAny* messageParameters[KMaxMessageArguments];

    // Set the first message parameter to point to the descriptor
    messageParameters[0] = static_cast<TAny*>( &anAddress );

    // This call waits for the server to complete the request before
    // proceeding. 
    SendReceive( ETmServRequestAddress, &messageParameters[0] );
    }


// -----------------------------------------------------------------------------
// RTmServerSession::SetServerAddress()
// 
// -----------------------------------------------------------------------------
//
EXPORT_C void RTmServerSession::SetServerAddress(const TDesC& anAddress) const
    {
    const TAny* messageParameters[KMaxMessageArguments];

    // Set the first message parameter to point to the descriptor
    messageParameters[0] = static_cast<const TAny*>( &anAddress );

    // This call waits for the server to complete the request before
    // proceeding. 
    SendReceive( ETmServSetAddress, &messageParameters[0] );
    }

// -----------------------------------------------------------------------------
// RTmServerSession::GetServerPort()
// 
// -----------------------------------------------------------------------------
//
EXPORT_C void RTmServerSession::GetServerPort( TDes& aPort) const
    {
    TAny* messageParameters[KMaxMessageArguments];

    // Set the first message parameter to point to the descriptor
    messageParameters[0] = static_cast<TAny*>( &aPort );

    // This call waits for the server to complete the request before
    // proceeding.
    SendReceive( ETmServRequestPort, &messageParameters[0] );
    }


// -----------------------------------------------------------------------------
// RTmServerSession::SetServerPort()
// 
// -----------------------------------------------------------------------------
//
EXPORT_C void RTmServerSession::SetServerPort(const TDesC& aPort) const
    {
    const TAny* messageParameters[KMaxMessageArguments];

    // Set the first message parameter to point to the descriptor
    messageParameters[0] = static_cast<const TAny*>( &aPort );

    // This call waits for the server to complete the request before
    // proceeding. 
    SendReceive( ETmServSetPort, &messageParameters[0] );
    }

// -----------------------------------------------------------------------------
// RTmServerSession::GetServerType()
// 
// -----------------------------------------------------------------------------
//
EXPORT_C void RTmServerSession::GetServerType(TDes& aType) const
    {
    TAny* messageParameters[KMaxMessageArguments];

    // Set the first message parameter to point to the descriptor
    messageParameters[0] = static_cast<TAny*>( &aType );

    // This call waits for the server to complete the request before
    // proceeding.
    SendReceive( ETmServRequestType, &messageParameters[0] );
    }


// -----------------------------------------------------------------------------
// RTmServerSession::SetServerType()
// 
// -----------------------------------------------------------------------------
//
EXPORT_C void RTmServerSession::SetServerType(const TDesC& aType) const
    {
    const TAny* messageParameters[KMaxMessageArguments];

    // Set the first message parameter to point to the descriptor
    messageParameters[0] = static_cast<const TAny*>( &aType);

    // This call waits for the server to complete the request before
    // proceeding. 
    SendReceive( ETmServSetType, &messageParameters[0] );
    }


// ============================= OTHER FUNCTIONS ===============================

// -----------------------------------------------------------------------------
// StartServer()
// Starts the server if it is not already running
// -----------------------------------------------------------------------------
//
TInt StartServer()
    {
    TInt result(KErrNone);

    TFindServer findServer( KTmServerName );
    TFullName name;

    result = findServer.Next( name );
    if ( result == KErrNone )
        {
        // Server already running
        return KErrNone;
        }

    RSemaphore semaphore;
    result = semaphore.CreateGlobal( KTmServerSemaphoreName, 0 );
    if ( result != KErrNone )
        {
        return  result;
        }

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

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

    return KErrNone;
    }

// -----------------------------------------------------------------------------
// CreateServerProcess()
// Creates a server process
// -----------------------------------------------------------------------------
//
TInt CreateServerProcess()
    {
    TInt result;

#ifdef __WINS__

    RLibrary lib;
    const TUidType serverUid( KNullUid, KNullUid, KNullUid );
    result = lib.Load( KTmServerFilename, serverUid );
    if ( result != KErrNone )
        {
        return  result;
        }

    //  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( KTmServerName );

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

    RThread server;

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

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

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

    server.SetPriority( EPriorityMore );


#else

    RProcess server;

    _LIT( KStrEmpty,"" );
    result = server.Create( KTmServerFilename, KStrEmpty);

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

#endif

    server.Resume();
    server.Close();

    return  KErrNone;
    }

// -----------------------------------------------------------------------------
// E32Dll()
// DLL entry point, return that everything is ok
// -----------------------------------------------------------------------------
//
GLDEF_C TInt E32Dll( TDllReason )
    {
    return KErrNone;
    }


// End of File