---

network_generic.cpp

Go to the documentation of this file.

/*
        $Id: network_generic.cpp,v 1.3 2001/02/28 15:06:03 sphair 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 OBSOLUTE_STUFF

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

#include <API/Core/System/error.h>
#include <API/Core/System/system.h>
#include <API/Network/netsession.h>
#include <API/Network/network.h>
#include <Network/Generic/network_delivery_impl.h>
#include <Network/Generic/netsession_client.h>
#include <Network/Generic/netsession_server.h>
#include <Network/Generic/network_generic.h>

#ifndef WIN32
        #include <sys/socket.h>
        #include <netinet/in.h>
        #include <arpa/inet.h>
        #include <netdb.h>
#else
        #include <windows.h>
#endif

CL_Network_Generic *CL_Network_Generic::self = NULL;

CL_Network_Generic::CL_Network_Generic(CL_ConnectionProvider *provider)
{
        this->provider = provider;
        self = this;
        udp_connection = provider->create_udp_connection(0);
}

CL_Network_Generic::~CL_Network_Generic()
{
        delete udp_connection;
        delete provider;
        self = NULL;
}

void CL_Network_Generic::find_sessions_broadcast(
        std::string game_id,
        int port)
{
        CL_OutputSource_MemoryGeneric msg;
        msg.write_int32(0); // ping message.
        msg.write_int32(game_id.length());
        msg.write(game_id.c_str(), game_id.length());

        CL_UDPConnectionPacket netmsg;
        netmsg.ip_addr = 0;
        netmsg.port = port;
        netmsg.size = msg.size();
        netmsg.data = msg.get_data();

        udp_connection->broadcast(netmsg);
}

void CL_Network_Generic::find_session_at(
        std::string app_id,
        const char *host_address,
        int port)
{
        // lookup dns name, if needed.
        unsigned int addr = 0;
        
        addr = inet_addr(host_address);
        if (addr == INADDR_NONE)
        {
                hostent *host = gethostbyname(host_address);
                if (host == NULL) throw CL_Error("Could not lookup DNS name");

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

        queue.push(
                new CL_NetSession_Client(
                        addr,
                        port,
                        app_id,
                        this));
}

bool CL_Network_Generic::peek_game_found()
{
        if (udp_connection->peek())
        {
                CL_UDPConnectionPacket netmsg = udp_connection->receive();
                CL_InputSource_MemoryGeneric input(netmsg.data, netmsg.size);

                if (input.read_int32() == 1)
                {
                        std::string game_id = input.read_string();
                        queue.push(
                                new CL_NetSession_Client(
                                        netmsg.ip_addr,
                                        netmsg.port,
                                        game_id,
                                        this));
                }
        }

        return !queue.empty();
}

CL_NetSession *CL_Network_Generic::receive_session_found(int timeout_millis)
{
        if (timeout_millis > 0) CL_System::sleep(timeout_millis);
        peek_game_found();

        if (queue.empty()) throw CL_Error("Game not found");
        CL_NetSession *session = queue.front();
        queue.pop();
        return session;
}

void CL_Network_Generic::clear_games_found()
{
        while (queue.empty() == false)
        {
                delete queue.front();
                queue.pop();
        }
}

CL_NetSession *CL_Network_Generic::create_session(std::string game_id, int port)
{
        return new CL_NetSession_Server(
                this,
                game_id.c_str(),
                port);
}

void CL_Network_Generic::keep_alive()
{
}

/*
        CL_Network API static function calls:
        -------------------------------------
*/

void CL_Network::find_sessions_broadcast(
        std::string game_id,
        int port)
{
        if (CL_Network_Generic::self == NULL)
                throw CL_Error("Network not initialized!");

        CL_Network_Generic::self->find_sessions_broadcast(
                game_id,
                port);
}
        
void CL_Network::find_session_at(
        std::string app_id,
        const char *host_address,
        int port)
{
        if (CL_Network_Generic::self == NULL)
                throw CL_Error("Network not initialized!");

        CL_Network_Generic::self->find_session_at(
                app_id,
                host_address,
                port);
}
        
bool CL_Network::peek_session_found()
{
        if (CL_Network_Generic::self == NULL)
                throw CL_Error("Network not initialized!");

        return CL_Network_Generic::self->peek_game_found();
}

CL_NetSession *CL_Network::receive_session_found(int timeout)
{
        if (CL_Network_Generic::self == NULL)
                throw CL_Error("Network not initialized!");

        return CL_Network_Generic::self->receive_session_found(timeout);
}

void CL_Network::clear_sessions_found()
{
        if (CL_Network_Generic::self == NULL)
                throw CL_Error("Network not initialized!");

        CL_Network_Generic::self->clear_sessions_found();
}

CL_NetSession *CL_Network::create_session(
        std::string session_id,
        int port)
{
        if (CL_Network_Generic::self == NULL)
                throw CL_Error("Network not initialized!");

        return CL_Network_Generic::self->create_session(
                session_id,
                port);
}

// --- netgroup: ---

CL_NetGroup::CL_NetGroup()
{
}

CL_NetGroup::CL_NetGroup(CL_NetComputer *comp)
{
        computers.push_back(comp);
}

#endif

---