Web alhem.net

ConnectThread.cpp

Go to the documentation of this file.

/*
Copyright (C) 2004  Anders Hedstrom

This program 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.

This program 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 this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/
#include <stdincl.h>
//#include <libcgi++.h>
//#include <libiotm.h>

#include "defaults.h"
#include "EventThread.h"
#include "pprintf.h"
#include "util/Parse.h"
#include "Player.h"
#include "Main.h"
#include "events/Map.h"
#include "Map.h"
#include "ConnectThread.h"

using util::Parse;


ConnectThread::ConnectThread() : IOThread()
,m_connected(0) 
,m_port(0)
,m_pclEventThread(NULL)
,m_self(NULL)
{
        *m_host = 0;
        m_port = 0;
        m_ip = 0L;
}

ConnectThread::ConnectThread(char *host, int port) : IOThread(false)
,m_connected(0) 
,m_port(port)
,m_pclEventThread(NULL)
,m_self(NULL)
{
printf("Connect thread constructor (%s, %d)\n",host,port);
fflush(stdout);
        strcpy(m_host, host);
printf("SetRelease(true)\n");
        SetRelease(true);
}


ConnectThread::~ConnectThread()
{
        DEB(printf("~ConnectThread()\n");)
        if (m_pclEventThread)
        {
                delete m_pclEventThread;
        }
        for (players_t::iterator it = m_players.begin(); it != m_players.end(); it++)
        {
                Player *p = it -> second;
                delete p;
        }
        {
                for (maps_t::iterator it = m_maps.begin(); it != m_maps.end(); it++)
                {
                        Map *t = it -> second;
                        delete t;
                }
        }
}


unsigned long ConnectThread::get_ip(char *ip)
{
        Parse *pa;
        struct hostent *he;
        unsigned long l = 0L;
        int i,x = 1;

        for (i = 0; i < (int)strlen(ip); i++)
                if ( (ip[i] < '0' || ip[i] > '9') && ip[i] != '.')
                        x = 0;
        if (x) // ipaddr
        {
                pa = new Parse(ip,".");
                l = pa -> getvalue();
                l = (l << 8) + pa -> getvalue();
                l = (l << 8) + pa -> getvalue();
                l = (l << 8) + pa -> getvalue();
                delete pa;
                l = htonl(l);
        }
        else // hostname
        {
                he = gethostbyname(ip);
                if (he)
                        memmove(&l, he -> h_addr, 4);
        }
        DEB(printf(" ip %08lx\n", l);)
        return l;
}


void ConnectThread::Run()
{
        struct sockaddr_in sa;
        struct timeval tv;
        fd_set rfds;
        fd_set wfds;
        socket_t s;
        int n;
        int i;

printf("Parsing host name '%s'\n",m_host);
        m_ip = get_ip(m_host);

        s = ::socket(AF_INET, SOCK_STREAM, 0);
        if (s == INVALID_SOCKET)
        {
                perror("connect_thread: socket() failed");
                goto off0;
        }

        sa.sin_family = AF_INET;
        sa.sin_port = htons(m_port);
        memmove(&sa.sin_addr,&m_ip,4);

        if (connect(s, (struct sockaddr *)&sa, sizeof(sa)) == -1)
        {
                perror("connect() failed");
                goto off;
        }

        m_pclEventThread = new EventThread(); //event_thread);
        m_pclEventThread -> SetConnectThread( this );

        SetFileDescriptor(s);
        DEB(printf("Socket#%d\n", s);)
        while (IsRunning())
        {
                tv.tv_sec = 1;
                tv.tv_usec = 0; //250000; // 0.05
                FD_ZERO(&rfds);
                FD_ZERO(&wfds);
                FD_SET(s, &rfds);
                if (get_oq() > 0)
                {
                        FD_SET(s, &wfds);
                }
#ifdef WIN32
                n = select(0, &rfds, &wfds, NULL, &tv);
#else
                n = select(s + 1, &rfds, &wfds, NULL, &tv);
#endif
                if (n == -1)
                {
                        DEB(printf("select() failed\n");)
                        perror("select() failed");
                        SetRunning(false);
                }
                if (n > 0 && FD_ISSET(s, &rfds))
                {
                        DEB(printf("rfds event\n");)
                        i = fd_read(); // read(s, slask, 200);
                        if (i == -1)
                        {
#ifdef WIN32
                                int err;
                                int errlen = sizeof(err);
                                getsockopt(s, SOL_SOCKET, SO_ERROR, (char*)&err, &errlen);
                                if (err != WSAEWOULDBLOCK)
#endif
                                {
                                        DEB(printf("read() failed (-1)\n");)
                                        perror("read() failed");
                                        SetRunning(false);
                                }
                        }
                        else
                        if (!i)
                        {
                                pprintf("You have been disconnected from the server.\n");
                                fprintf(stderr,"disconnected (read() returns 0)\n");
                                SetRunning(false);
                        }
                        else
                        {
                                DEB(printf(" %d chars read\n",i);)
                        }
                        n--;
                }
                if (n > 0 && FD_ISSET(s, &wfds))
                {
                        DEB(printf("wfds event\n");)
                        i = fd_write();
                        if (i == -1)
                        {
                                perror("write() failed");
                                SetRunning(false);
                        }
                        n--;
                }
        }
        if (m_pclEventThread)
        {
                m_pclEventThread -> SetRunning(false);
        }

        // All done.
        pprintf("Disconnected from server.\n");
off:
        shutdown(s, 1);
#pragma warning( "send an sdl event about the disconnect to clean up cache's")
#ifdef WIN32
        closesocket(s);
#else
        close(s);
#endif
        SDL_Event e;
        e.type = SDL_USEREVENT;
        e.user.code = SDL_USEREVENT_DISCONNECT;
        e.user.data1 = NULL;
        e.user.data2 = NULL;
        SDL_PushEvent(&e);
off0:
        SetRunning(false);
}


IOMessage *ConnectThread::GetClass(IO_IDTYPE id)
{
        return m_pclEventThread ? m_pclEventThread -> GetClass(id) : NULL;
}


Player *ConnectThread::AddPlayer(long num)
{
        Player *p;
        p = m_players[num];
        if (!p)
        {
                p = new Player(num);
                m_players[num] = p;
        }
        return p;
}


Player *ConnectThread::AddPlayer(long num,const string &name)
{
        Player *p = AddPlayer(num);
        p -> SetName(name);
        return p;
}


void ConnectThread::SetSelf(long num,const string &name)
{
        m_self = GetPlayer(num);
}


Player *ConnectThread::GetPlayer(long num)
{
        return m_players[num];
}


Player *ConnectThread::GetSelf()
{
        return m_self;
}


Map *ConnectThread::AddMap(long x,long y,Event::Map *e)
{
        Map *map;
        long key = ((x / MAPSIZE) << 16) + (y / MAPSIZE);

        map = m_maps[key];
        if (!map)
        {
                map = new Map;
                m_maps[key] = map;
        }
        if (e)
        {
                map -> Populate(e);
        }
        return map;
}


Map *ConnectThread::GetMap(long x,long y)
{
        long key = ((x / MAPSIZE) << 16) + (y / MAPSIZE);

        return m_maps[key];
}

---