---

netsession.cpp

Go to the documentation of this file.

/*
        $Id: netsession.cpp,v 1.7 2001/03/20 13:22:20 mbn Exp $

        ------------------------------------------------------------------------
        ClanLib, the platform independent game SDK.

        This library is distributed under the GNU LIBRARY GENERAL PUBLIC LICENSE
        version 2. See COPYING for details.

        For a total list of contributers see CREDITS.

        ------------------------------------------------------------------------
*/

#ifdef WIN32
#pragma warning (disable:4786)
#endif

#include "API/Core/System/error.h"
#include "API/Core/System/cl_assert.h"
#include "API/Network/netsession.h"
#include "netsession_generic.h"
#include "netsession_server.h"
#include "netsession_client.h"
#include "network_delivery_socket.h"

// declared in setupnetwork_PLATFORM.cpp (eg. setupnetwork_win32.cpp)
extern CL_ConnectionProvider *connection_provider;

// CL_NetSession construction:

CL_NetSession::CL_NetSession(
        const std::string &app_id,
        int port)
:
        impl(NULL)
{
        impl = new CL_NetSession_Server(connection_provider, app_id.c_str(), port);
}

CL_NetSession::CL_NetSession(
        const std::string &app_id,
        const std::string &hostname,
        int port)
:
        impl(NULL)
{
        // assume hostname is in dot notation:
        unsigned int addr = inet_addr(hostname.c_str());

        if (addr == INADDR_NONE)
        {
                // ok, hostname wasnt in dot notation. Let's try a dns lookup.

                hostent *host = gethostbyname(hostname.c_str());
                if (host == NULL) throw CL_Error("Could not lookup DNS name");

                addr = *((unsigned int*) host->h_addr_list[0]);
        }

        impl = new CL_NetSession_Client(addr, port, app_id, connection_provider);
}

CL_NetSession::CL_NetSession(
        const CL_ServerInfo &server)
:
        impl(NULL)
{
        cl_assert(false); // not implemented yet.
}

CL_NetSession::~CL_NetSession()
{
        if (impl) impl->release_ref();
}

// CL_NetSession attributes:

CL_EventTrigger *CL_NetSession::get_trigger()
{
        return impl->get_trigger();
}

CL_NetComputer &CL_NetSession::get_server()
{
        return impl->get_server();
}

CL_NetGroup &CL_NetSession::get_all()
{
        return impl->get_all();
}

bool CL_NetSession::peek(int channel) const
{
        return impl->peek(channel);
}

CL_NetMessage CL_NetSession::receive(int channel, int timeout)
{
        return impl->receive(channel, timeout);
}

int CL_NetSession::access_status(int channel) const
{
        return impl->access_status(channel);
}

bool CL_NetSession::is_writable(int channel) const
{
        return impl->is_writable(channel);
}

bool CL_NetSession::is_readable(int channel) const
{
        return impl->is_readable(channel);
}

// CL_NetSession operations:

void CL_NetSession::send(
        const int dest_channel,
        const CL_NetGroup &dest,
        const CL_NetMessage &message,
        bool reliable)
{
        impl->send(
                dest_channel,
                dest,
                message,
                reliable);
}

CL_NetComputer CL_NetSession::receive_computer_leave()
{
        return impl->receive_computer_leave();
}

CL_NetComputer CL_NetSession::receive_computer_join()
{
        return impl->receive_computer_join();
}

CL_NetComputer CL_NetSession::receive_computer_rejoin()
{
        return impl->receive_computer_rejoin();
}

bool CL_NetSession::receive_session_closed()
{
        return impl->receive_session_closed();
}

int CL_NetSession::receive_access_changed()
{
        return impl->receive_access_changed();
}

void CL_NetSession::set_access(
        int channel,
        const CL_NetGroup &group,
        int access_rights)
{
        impl->set_access(channel, group, access_rights);
}

// CL_NetSession implementation:

CL_NetSession::CL_NetSession(CL_NetSession_Generic *impl)
: impl(impl)
{
        impl->add_ref();
}

---