---

netsession_client.cpp

Go to the documentation of this file.

/*
        $Id: netsession_client.cpp,v 1.7 2001/03/23 15:09:36 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/mutex.h>
#include <API/Network/netcomputer.h>
#include <API/Network/netgroup.h>
#include <API/Network/netmessage.h>
#include <API/Core/System/error.h>
#include <API/Core/System/thread.h>
#include <API/Core/System/cl_assert.h>
#include <API/Core/System/system.h>
#include <Network/Generic/network_delivery_impl.h>
#include <Network/Generic/netsession_client.h>
#include <Network/Generic/netsession_generic.h>
#include <Network/Generic/network_generic.h>
#include <Core/IOData/Generic/outputsource_memory_generic.h>
#include <Core/IOData/Generic/inputsource_memory_generic.h>

CL_NetSession_Client::CL_NetSession_Client(
        int ip_addr,
        int port,
        const std::string &game_id,
        CL_ConnectionProvider *provider)
: CL_NetSession_Generic(provider)
{
        mutex = CL_Mutex::create();

        tcp_connection = provider->create_tcp_connection(
                ip_addr,
                port);

        if (tcp_connection == NULL)
        {
                throw CL_Error("Could not connect to host.");
        }

        udp_connection = NULL; // still no support for udp in client.

        // client code currently only knows about the server.
        server = CL_NetComputer(new CL_NetComputer_Server(this));
        all.add(server);

        // do "hello to you too" handshake.
        CL_ConnectionPacket p = tcp_connection->receive();
        while (p.size == 0) // wait until we get a hello packet.
        {
                provider->wait_for_connection_data(mutex);
                p = tcp_connection->receive();
        }
        
        CL_InputSource_MemoryGeneric input(p.data, p.size, true);
        if (input.read_int32() != Packet_Hello)
        {
                throw CL_Error("Protocol error. Didn't get a Hello.");
        }
        our_id = input.read_int32();

        int size = input.read_int32();
        if (size > 1000)
                throw CL_Error("Protocol error. Game ID size above 1000.");

        char *str = new char[size+1];
        str[size] = 0; // null-terminate.
        input.read(str, size);
        
        if (game_id != str) // not same game_id. probably an other clanlib game.
        {
                delete[] str;
                throw CL_Error("Wrong netsession id.");
        }

        delete[] str;
        
        // say "HelloToYouToo" to officially join the netsession:
        CL_OutputSource_MemoryGeneric output;
        output.write_int32(Packet_Hello_ToYouToo);
        tcp_connection->send(
                CL_ConnectionPacket(
                        output.get_data(),
                        output.size()));

        exit_thread = false;
        thread = CL_Thread::create(this);
        thread->start();
}

CL_NetSession_Client::~CL_NetSession_Client()
{
        exit_thread = true;
        thread->wait();
        delete thread;

        delete tcp_connection;
        delete udp_connection;

        // clean up connections to clients:
        for (
                std::list<CL_NetChannelQueue_Client*>::iterator it = netchannels.begin();
                it != netchannels.end();
                it++)
        {
                delete *it;
        }
/*
        should be enabled when the client knows about other clients...

        while (leave_queue.empty() == false)
        {
                delete leave_queue.pop();
        }
*/

        delete mutex;
}

CL_NetComputer &CL_NetSession_Client::get_server()
{
        return server;
}

CL_NetGroup &CL_NetSession_Client::get_all()
{
        return all;
}

bool CL_NetSession_Client::peek(int channel) const
{
        CL_MutexSection mutex_section(mutex);

        CL_NetChannelQueue_Client *queue = find_queue(channel);
        if (queue != NULL)
        {
                return !queue->empty();
        }

        return false;
}

CL_NetMessage CL_NetSession_Client::receive(int channel, int timeout)
{
        CL_MutexSection mutex_section(mutex);

        CL_NetChannelQueue_Client *queue = create_queue(channel);

        while (queue->empty()) 
        {
                int s = timeout;
                if (timeout < 0 || timeout > 20) s = 20;
                mutex->leave();
                CL_System::sleep(s);
                mutex->enter();

                if (timeout != -1)
                {
                        timeout -= s;
                        if (timeout <= 0) break;
                }
        }

        if (queue->empty()) throw CL_Error("No message to receive!");
        CL_NetMessage msg = queue->front(); queue->pop();
        check_trigger();
        return msg;
}

void CL_NetSession_Client::send(
        const int dest_channel,
        const CL_NetGroup &dest,
        const CL_NetMessage &message,
        bool reliable /*= true*/)
{
        CL_MutexSection mutex_section(mutex);

        static bool warning = true;
        if (warning && reliable == false)
        {
                cl_info(info_network, "cannot send data unreliable (udp): not implemented yet!");
                warning = false;
        }
/*      
        CL_NetChannelQueue_Client *queue = find_queue(dest_channel);

        if (queue == NULL)
                throw CL_Error("No write access to netchannel.");

        if ((queue->access & ACCESS_CHANNEL_WRITE) != ACCESS_CHANNEL_WRITE)
                throw CL_Error("No write access to netchannel.");
*/
        // permissions ok, send message:
        CL_OutputSource_MemoryGeneric output;
        output.write_int32(Packet_NetChannel_Message_ToServer);
        output.write_int32(dest_channel);

        // todo: write the computer id's on destination computers here.

        output.write_int32(message.data.size());
        output.write(message.data.data(), message.data.size());

        CL_ConnectionPacket packet;
        packet.size = output.size();
        packet.data = output.get_data();

        tcp_connection->send(packet);
}

CL_NetComputer CL_NetSession_Client::receive_computer_leave()
{
        throw CL_Error("Computer leave queue empty.");
}

CL_NetComputer CL_NetSession_Client::receive_computer_join()
{
        throw CL_Error("Computer join queue empty.");
}

CL_NetComputer CL_NetSession_Client::receive_computer_rejoin()
{
        throw CL_Error("Computer rejoin queue empty.");
}

bool CL_NetSession_Client::receive_session_closed()
{
        CL_MutexSection mutex_section(mutex);
        return tcp_connection->connection_lost();
}

int CL_NetSession_Client::access_status(int channel) const
{
        CL_MutexSection mutex_section(mutex);

        CL_NetChannelQueue_Client *queue = find_queue(channel);
        return (queue == NULL) ? 0 : queue->access;
}

bool CL_NetSession_Client::is_writable(int channel) const
{
        CL_MutexSection mutex_section(mutex);

        CL_NetChannelQueue_Client *queue = find_queue(channel);
        if (queue == NULL) return false;

        return (queue->access & ACCESS_CHANNEL_WRITE) == ACCESS_CHANNEL_WRITE;
}

bool CL_NetSession_Client::is_readable(int channel) const
{
        CL_MutexSection mutex_section(mutex);

        CL_NetChannelQueue_Client *queue = find_queue(channel);
        if (queue == NULL) return false;

        return (queue->access & ACCESS_CHANNEL_READ) == ACCESS_CHANNEL_READ;
}

// Client side only:
int CL_NetSession_Client::receive_access_changed()
{
        CL_MutexSection mutex_section(mutex);

        if (access_queue.empty()) return -1;
        int id = access_queue.front()->channel_id;
        access_queue.pop();
        check_trigger();
        return id;
}

// Server side only:
void CL_NetSession_Client::set_access(
        int channel,
        const CL_NetComputer &computer,
        int access_rights)
{
        throw CL_Error("We are not the network server. Cannot change access.");
}

void CL_NetSession_Client::set_access(
        int channel,
        const CL_NetGroup &group,
        int access_rights)
{
        throw CL_Error("We are not the network server. Cannot change access.");
}

void CL_NetSession_Client::keep_alive()
{
        CL_MutexSection mutex_section(mutex);

        if (tcp_connection->connection_lost())
        {
                provider->remove_connection(tcp_connection);
                return;
        }

        while (tcp_connection->peek())
        {
                if (exit_thread) return;

                CL_ConnectionPacket msg = tcp_connection->receive();
                        
                CL_InputSource_MemoryGeneric input(msg.data, msg.size, true);
                switch (input.read_int32())
                {
                case Packet_NetChannel_AccessChange:
                        {
                                CL_NetChannelQueue_Client *queue = create_queue(input.read_int32());
                                queue->access = input.read_int32();
                                access_queue.push(queue);
                                trigger.set_flag();
                        }
                        break;
                
                case Packet_NetChannel_Message_ToClient:
                        {
                                CL_NetChannelQueue_Client *queue = create_queue(input.read_int32());
                                CL_NetMessage game_msg;
                                int size = input.read_int32();
                                char *data = new char[size];
                                game_msg.from = server;
                                input.read(data, size);
                                game_msg.data.append(data, size);
                                queue->push(game_msg);
                                trigger.set_flag();
                        }
                        break;

                default:
                        cl_info(info_network, "Network Protocol error!");
                        cl_assert(false);
                }
        }
}

CL_NetChannelQueue_Client *CL_NetSession_Client::find_queue(int netchannel) const
{
        CL_MutexSection mutex_section(mutex);

        // Note: This really should be a STL map, not a list. Too lazy to fix it now -- mbn.
        for (
                std::list<CL_NetChannelQueue_Client*>::const_iterator it = netchannels.begin();
                it != netchannels.end();
                it++)
        {
                if ((*it)->channel_id == netchannel) return *it;
        }

        return NULL;
}

CL_NetChannelQueue_Client *CL_NetSession_Client::create_queue(int netchannel)
{
        CL_MutexSection mutex_section(mutex);

        CL_NetChannelQueue_Client *found = find_queue(netchannel);
        if (found != NULL) return found;
        
        CL_NetChannelQueue_Client *c = new CL_NetChannelQueue_Client;
        c->channel_id = netchannel;
        c->access = 0;

        netchannels.push_back(c);

        return c;
}

void CL_NetSession_Client::run()
{
        while (exit_thread == false)
        {
                keep_alive();
                provider->wait_for_connection_data(mutex);
        }
}

void CL_NetSession_Client::check_trigger()
{
        bool queues_empty = access_queue.empty();

        std::list<CL_NetChannelQueue_Client*>::iterator it;
        for (it = netchannels.begin(); it != netchannels.end(); it++)
        {
                if (!(*it)->empty()) queues_empty = false;
        }

        if (queues_empty) trigger.reset();
}

// CL_NetComputer_Server

CL_NetComputer_Server::CL_NetComputer_Server(CL_NetSession_Client *session)
: CL_NetComputer_Generic(session)
{
}

CL_NetComputer_Server::~CL_NetComputer_Server()
{
}

unsigned long CL_NetComputer_Server::get_address() const
{
//      return get_session()->tcp_connection->get_address();
        return 0;
}

void CL_NetComputer_Server::disconnect()
{
//      get_session()->tcp_connection->disconnect();
}

CL_NetSession_Client *CL_NetComputer_Server::get_session()
{
        return static_cast<CL_NetSession_Client*>(CL_NetComputer_Generic::get_session());
}

---