---

o_net.cpp

Go to the documentation of this file.

// OMICRON ENGINE HEADER FILE
//
// --------------------------------------------------------------------------
// Copyright (C) 2001-2002 by Bjoern Paetzel <kolrabi@gmx.de>
//
// This file is part of the Omicron Engine.
//
// The Omicron Engine is free software; you can redistribute it and/or modify
// it under the terms of the  GNU General Public License  as published by the
// Free Software Foundation;  either version  2  of the License,  or (at your
// option) any later version.
//
// The Omicron Engine  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 General Public License
// for more details.
//
// You should have  received a copy of the  GNU General Public License  along
// with The Omicron Engine;  if not,  write to the  Free Software Foundation,
// Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA 
//
// --------------------------------------------------------------------------
// Last modified:       $Date: 2002/12/13 12:29:26 $
// By           :       $Author: kolrabi $
// $Id: o_net.cpp,v 1.2 2002/12/13 12:29:26 kolrabi Exp $ 

/*

  $Log: o_net.cpp,v $
  Revision 1.2  2002/12/13 12:29:26  kolrabi
  fixed some bugs

  Revision 1.1.1.1  2002/12/07 19:02:06  kolrabi
  initial release


*/

#include            "omicron/internal.h"


#include            "omicron/net.h"
#include            "omicron/array.h"
#include            "omicron/list.h"

/**************************************************************************** 
 **************************************************************************** 
 * CLIENT ******************************************************************* 
 **************************************************************************** 
 ****************************************************************************/ 

net_client_c::net_client_c()
{
    _log_printf(MSG_DEBUG, "net_client_c()");

    sock        = INVALID_SOCKET;
//    udpsock     = INVALID_SOCKET;

    queue       = new list_c<char>;
    queuelen    = 0;
}

net_client_c::~net_client_c()
{
    AssertThis;

    // clear queue
    char *buf = (char*)queue->get_first();

    while(buf)
    {
        SafeDelete(buf);
        buf = (char*)queue->get_next();
    }

    SafeDelete(queue);

    // close socket
    shutdown(sock, 0);
    closesocket(sock);
}

void net_client_c::send_message(net_message_header_t *msg, bool /* reliable */)
{
    AssertThis;
    AssertReturn3(gv.netman, msg, queue);

    if (sock == INVALID_SOCKET)
        return;

    _log_printf(MSG_DEBUG, "SV: send_message: %u %u", msg->type, msg->len);

    fd_set fd;
    TIMEVAL tv;

    tv.tv_sec   = 0;
    tv.tv_usec  = 0;

    FD_ZERO(&fd);
    FD_SET(sock, &fd);
    if (select(1, NULL, &fd, NULL, &tv)) // clear to send?
    {
        // first send queue..

        char *buf = (char*)queue->get_first();

        while(buf)
        {
            _log_printf(MSG_DEBUG, "SV: sending queued message");

            int res = send(sock, buf, ((net_message_header_t*)buf)->len, 0);

            if (res == SOCKET_ERROR)
            {
                status = NETSTAT_DISCONNECTED;
                _log_printf(MSG_DEBUG, "SV: network error");
                return;
            }

            queuelen --;
            queue->remove(buf);
            SafeArrayDelete(buf);
            buf = (char*)queue->get_first();
        }

        // then message
        int res = send(sock, (char*)msg, msg->len, 0);
        if (res == SOCKET_ERROR)
        {
            status = NETSTAT_DISCONNECTED;
            _log_printf(MSG_DEBUG, "SV: network error");
            return;
        }
        _log_printf(MSG_DEBUG, "SV: message sent");
    }
    else    // no.. add to queue
    {
        _log_printf(MSG_DEBUG, "SV: message added to queue");

        char *buf = new char[msg->len];

        memcpy(buf, msg, msg->len);
        queue->append(buf);
        queuelen++;
    }
}

void net_client_c::receive_message()
{
    AssertThis;
    AssertReturn1(gv.netman);

    if (sock == INVALID_SOCKET)
        return;

    // receive and process messages

    fd_set fd;
    TIMEVAL tv;

    tv.tv_sec = 0;
    tv.tv_usec = 0;

    FD_ZERO(&fd);
    FD_SET(sock, &fd);
    while(select(1, &fd, NULL, NULL, &tv)) // is there data?
    {
        net_message_header_t header;

        int res = recv(sock, (char*)&header, sizeof(header), 0);

        if (res == SOCKET_ERROR || !res)
        {
            status = NETSTAT_DISCONNECTED;
            return;
        }

        char *buf = new char[header.len];
        memcpy(buf, &header, sizeof(header));

        recv(sock, buf+sizeof(header), header.len-sizeof(header), 0);

        _log_printf(MSG_DEBUG, "SV: message received from client: %u %u", header.type, header.len);

        switch(header.type)
        {
            case NETMSG_PONG:
                {
//                    net_message_pong_t *msg = (net_message_pong_t*)buf;
                    latency = gv.netman->sv_gametime - header.time;
                }
                break;

                        default:

                                // TODO: gv.iface->sv_clientmessage(msg);
                                break;
        }

        SafeArrayDelete(buf);
        FD_ZERO(&fd);
        FD_SET(sock, &fd);
    }
}

/**************************************************************************** 
 **************************************************************************** 
 * NET MANAGER ************************************************************** 
 **************************************************************************** 
 ****************************************************************************/ 

net_manager_c::net_manager_c()
{
    _log_printf(MSG_DEBUG, "net_manager_c()");

    SafeDelete(gv.netman);

    gv.netman = this;

    sv_lastupdate       = _time_get();
    sv_gametime         =
        cl_lastupdate   = sv_lastupdate;

    clients             = new array_c<net_client_c>;

    isserver            = false;
    isclient            = false;

    cl_socket           = INVALID_SOCKET;
//    cl_udpsocket        = INVALID_SOCKET;

    sv_socket           = INVALID_SOCKET;
//    sv_udpsocket        = INVALID_SOCKET;

    cl_queue            = new list_c<char>;
    cl_queuelen         = 0;

#if defined(WIN32) 
    WSAStartup(MAKEWORD(2,0), &wsadata);
#endif
}

net_manager_c::~net_manager_c()
{
    AssertThis;

    _log_printf(MSG_DEBUG, "~net_manager_c()");

    for (slong i=0; i<clients->get_count(); i++)
    {
        net_client_c *cl = clients->get(i);
        SafeDelete(cl);
    }
    SafeDelete(clients);

    // clear queue
    char *buf = cl_queue->get_first();

    while(buf)
    {
        SafeArrayDelete(buf);
        buf = cl_queue->get_next();
    }
    SafeDelete(cl_queue);

    gv.netman = NULL;

#if defined(WIN32) 
    WSACleanup();
#endif
}

// ******************************************************** //

void net_manager_c::start_listen(ushort port, bool local)
{
    SOCKADDR_IN     laddress;
    int             addrsize = sizeof(SOCKADDR_IN);

    stop_listen();

    sv_socket                   = socket( PF_INET, SOCK_STREAM, 0 );

    // set local address and port
    laddress.sin_family         = AF_INET;
    laddress.sin_port           = htons( port );
    laddress.sin_addr.s_addr    = local?inet_addr("127.0.0.1"):INADDR_ANY;

    if (bind(sv_socket, (struct sockaddr*)&laddress, addrsize))
    {
        _log_printf(MSG_DEBUG, "SV: failed to bind tcp socket");
        return;
    }

    if (listen(sv_socket, 1))
    {
        _log_printf(MSG_DEBUG, "SV: failed to listen on port %u", port);
        return;
    }

    _log_printf(MSG_DEBUG, "SV: tcp now listening on port %u", port);

    isserver = true;
}

void net_manager_c::stop_listen()
{
    AssertThis;

    if (sv_socket != INVALID_SOCKET)
    {
        _log_printf(MSG_DEBUG, "SV: no longer listening");

        shutdown(sv_socket, 0);
        closesocket(sv_socket);
    }
    sv_socket = INVALID_SOCKET;

    isserver = false;
}

// ******************************************************** //

void net_manager_c::update()
{
    AssertThis;

    sv_gametime = _time_get();

    // **********************************************************
    //  SERVER **************************************************

    // new server frame
    if (isserver && sv_gametime>=sv_lastupdate+frametime)
    {
        net_message_ping_t pingmsg;
        pingmsg.header.type = NETMSG_PING;
        pingmsg.header.len  = sizeof(net_message_ping_t);
        pingmsg.header.time = sv_gametime;

        broadcast(&pingmsg.header);

        sv_lastupdate = sv_gametime;
    }

    if (isserver)
    {
        fd_set fd;
        TIMEVAL tv;

        tv.tv_sec = 0;
        tv.tv_usec = 0;

        FD_ZERO(&fd);
        FD_SET(sv_socket, &fd); 

            // accept new connections **********************************
        if (select(1, &fd, NULL, NULL, &tv)) // is there data?
        {
            socklen_t   addrsize    = sizeof(SOCKADDR_IN);
            SOCKADDR_IN laddress;

            SOCKET      sock        = 
                accept(sv_socket, (struct sockaddr*)&laddress, &addrsize);

            net_client_c *cl = new net_client_c;

            cl->laddress    = laddress;
            cl->sock        = sock;
            cl->status      = NETSTAT_CONNECTED;

                        cl->id                  = clients->add(cl);

            _log_printf(MSG_DEBUG, "server: new connection");

                        // TODO:
                        // gv.iface->sv_clientconnect(cl)
        }

            // receive messages from clients ***************************
        for (slong i=0; i<clients->get_count(); i++)
        {
            net_client_c *cl = clients->get(i);
            if (cl)
                cl->receive_message();
        }
    }

    // clear disconnected clients + read incoming messages ******

    for (slong i=0; i<clients->get_count(); i++)
    {
        net_client_c *cl = clients->get(i);

        if (cl)
        {
            if (cl->status == NETSTAT_DISCONNECTED)
            {
                                // TODO:
                                // gv.iface->sv_clientdisconnect(cl)

                clients->remove_ptr(cl);
                SafeDelete(cl);
                        }
        }
    }

    // **********************************************************
    //  CLIENT **************************************************

    // receive and process messages
    if (isclient)
    {
        fd_set fd;
        TIMEVAL tv;

        tv.tv_sec = 0;
        tv.tv_usec = 0;

        FD_ZERO(&fd);
        FD_SET(cl_socket, &fd);
        while(select(1, &fd, NULL, NULL, &tv)) // is there data?
        {
            net_message_header_t header;

            int res = recv(cl_socket, (char*)&header, sizeof(header), 0);

            if (res == SOCKET_ERROR || !res)
            {
                disconnect_from_server();
                return;
            }

            char *buf = new char[header.len];
            memcpy(buf, &header, sizeof(header));

            recv(cl_socket, buf+sizeof(header), header.len-sizeof(header), 0);

            cl_receivemessage(&header);

            SafeArrayDelete(buf);
            FD_ZERO(&fd);
            FD_SET(cl_socket, &fd);
        }

    }

    // **********************************************************
    //  COMMON **************************************************
}

// ******************************************************** //

void net_manager_c::broadcast(net_message_header_t *msg)
{
    AssertThis;

    AssertReturn1(msg);

    for (slong i=0; i<clients->get_count(); i++)
    {
        net_client_c *cl = clients->get(i);

        if (cl)
        {
            cl->send_message(msg);
        }
    }
}

void net_manager_c::unicast(ulong clnum, net_message_header_t *msg)
{
    AssertThis;
    AssertReturn1(msg);

    net_client_c *cl = clients->get(clnum);

    AssertReturn1(cl);

    cl->send_message(msg);
}

// ******************************************************** //

bool net_manager_c::connect_to_server(char *name, ushort port)
{
    AssertThisV;
    AssertReturnValue1(name, false);

    disconnect_from_server();

    SOCKADDR_IN     laddress;
    int             addrsize = sizeof(SOCKADDR_IN);
    HOSTENT         *he;

    he = gethostbyname( name );

    AssertReturnValue1(he, false);

    _log_printf(MSG_DEBUG, "client: connecting to server %s:%u", name, port);

    cl_socket = socket( PF_INET, SOCK_STREAM, 0 );

    // set local address and port
    laddress.sin_family         = AF_INET;
    laddress.sin_port           = htons( port );

    memcpy( &laddress.sin_addr.s_addr, 
        he->h_addr_list[0], 4 );

    int res = connect(cl_socket, (sockaddr*)&laddress, addrsize);

    if (res)
    {
        _log_printf(MSG_DEBUG, "client: could not connect to server");
        disconnect_from_server();
        return false;
    }

    cl_connecttime = _time_get();

    isclient = true;

        return true;
}

void net_manager_c::disconnect_from_server() 
{
    AssertThis;

    _log_printf(MSG_DEBUG, "CL: disconnecting from server");

    isclient = false;

    if (cl_socket!=INVALID_SOCKET)
    {
        shutdown(cl_socket, 0);
        closesocket(cl_socket);
        cl_socket = INVALID_SOCKET;
    }
}

void net_manager_c::cl_sendmessage(net_message_header_t *msg)
{
    AssertThis;

    AssertReturn1(msg);

    if (cl_socket == INVALID_SOCKET)
        return;

    _log_printf(MSG_DEBUG, "CL: send_message: %u %u", msg->type, msg->len);

    fd_set fd;
    TIMEVAL tv;

    tv.tv_sec   = 0;
    tv.tv_usec  = 0;

    FD_ZERO(&fd);
    FD_SET(cl_socket, &fd);
    if (select(1, NULL, &fd, NULL, &tv)) // clear to send?
    {
        // first send queue..

        char *buf = (char*)cl_queue->get_first();

        while(buf)
        {
            _log_printf(MSG_DEBUG, "CL: sending queued message");

            int res = send(cl_socket, buf, ((net_message_header_t*)buf)->len, 0);

            if (res == SOCKET_ERROR)
            {
                _log_printf(MSG_DEBUG, "CL: network error");
                disconnect_from_server();
                return;
            }

            cl_queue->remove(buf);
            SafeArrayDelete(buf);
            buf = (char*)cl_queue->get_first();

            cl_queuelen--;
        }

        // then message
        int res = send(cl_socket, (char*)msg, msg->len, 0);
        if (res == SOCKET_ERROR)
        {
            _log_printf(MSG_DEBUG, "CL: network error");
            disconnect_from_server();
            return;
        }
        _log_printf(MSG_DEBUG, "CL: message sent");
    }
    else    // no.. add to queue
    {
        _log_printf(MSG_DEBUG, "CL: message added to queue");

        char *buf = new char[msg->len];

        memcpy(buf, msg, msg->len);
        cl_queue->append(buf);
        cl_queuelen++;
    }
}

void net_manager_c::cl_receivemessage(net_message_header_t *msg)
{
    AssertThis;
    AssertReturn1(msg);

    _log_printf(MSG_DEBUG, "client: message received from server: %u %u", msg->type, msg->len);

    switch(msg->type)
    {
        case NETMSG_PING:
            {
                msg->type = NETMSG_PONG;
                cl_sendmessage(msg);
            }
            break;

        default: // assume userdefined
            // gv.iface->cl_servermessage( ... ) 
            ;
    }
}

---