E:/Eigene Dateien/Eigene Projekte/c0re/Network.cpp

Go to the documentation of this file.

/*
        This file is part of c0re.

        c0re is a multiplayer RTS on a hexagonal map with an evolving unit concept.
    Copyright (C) 2007 Stephan Hofmann

    c0re 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 3 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, see <http://www.gnu.org/licenses/>.
*/

#include "Network.h"

#include "system.h"
#include <winsock.h>
#include <iostream>

Network::Network(Level* p_level)
{
        level = p_level;
        conSocket = INVALID_SOCKET;
}

Network::~Network()
{
}

bool Network::createServer(std::string p_level_name, std::string p_player_name, int p_port)
{
        bool ret = false;

        //create listen socket
        SOCKET listenSocket = _createServer(p_port);
        if (listenSocket == INVALID_SOCKET)
                return false;
        
        //wait for connection
        while (conSocket == INVALID_SOCKET)
        {
                //accept conection
                std::string ip_add;
                while (conSocket == INVALID_SOCKET)
                {
                        conSocket = _acceptConnection(listenSocket, ip_add);
                        sleep(10); //Wait 10ms
                }
                int waitCounter = 200; //20 times will give a chance
                while (waitCounter > 0)
                {
                        if (_test(conSocket) >= 8)
                                waitCounter = 0; //we got the first 8 bytes in time
                        waitCounter--;
                        sleep(100); //wait 100ms
                }
                
                //now test if it is the right message
                if (_test(conSocket) < 8)
                {
                        _closeConnection(conSocket);
                }
                else
                {       // fetch 8 bytes
                        char buffer[MAXBUFFER];
                        if (_recv(conSocket, buffer, 8) == 8)
                        {
                                buffer[8] = (char) 0; // we end the string
                                if (strcmp(buffer, "##c0re##") == 0)
                                {
                                        ret = true;
                                        //now sed the same msg back
                                        _send(conSocket, buffer, 8);
                                        //now send level_name
                                        sprintf_s(buffer, "%255s", p_level_name.c_str());
                                        _send(conSocket, buffer, 255);
                                }
                                else //wrong message
                                        _closeConnection(conSocket);
                        }
                        else //some socket error
                                _closeConnection(conSocket);
                }
        }
        //and close listen Socket
        _closeConnection(listenSocket);
        return ret;
}

std::string Network::connect(std::string p_player_name, std::string p_address, int p_port)
{
        std::string ret = "";
        //just connect
        conSocket = _connect(p_address, p_port);
        if (conSocket != INVALID_SOCKET)
        {
                char buffer[MAXBUFFER];
                sprintf_s(buffer, "##c0re##");
                //and send msg
                _send(conSocket, buffer, 8);

                //now wait for return message
                int waitCounter = 200; //200 times will give a chance
                while (waitCounter > 0)
                {
                        if (_test(conSocket) >= 263)
                                waitCounter = 0; //we got the first 8 bytes in time
                        waitCounter--;
                        sleep(100); //wait 100ms
                }
                
                //now test if it is the right message
                if (_test(conSocket) < 263)
                {
                        _closeConnection(conSocket);
                }
                else
                {       // fetch 8 bytes
                        char buffer[MAXBUFFER];
                        if (_recv(conSocket, buffer, 8) == 8)
                        {
                                buffer[8] = (char) 0; // we end the string
                                if (strcmp(buffer, "##c0re##") != 0)
                                {
                                        //wrong message
                                        _closeConnection(conSocket);
                                        return "";
                                }
                                else
                                {
                                        //right message ow fetch the level_name
                                        if (_recv(conSocket, buffer, 255) == 255)
                                        {
                                                buffer[255] = (char) 0;
                                                ret = buffer;
                                                //now delete headening spaces
                                                while (ret.find(" ") == 0)
                                                        ret.erase(0, 1);
                                        }
                                        else
                                        {
                                                //bad error
                                                _closeConnection(conSocket);
                                                return "";
                                        }
                                }
                        }
                        else //some socket error
                                _closeConnection(conSocket);
                }
        }

        return ret;
}


bool Network::waitForRemoteSide()
{
        bool ret = false;

        //send "done"

        //wait for "done"

        return ret;
}


/*** Wrapper functios***/


long Network::_send(SOCKET p_socket, char p_buffer[MAXBUFFER], long p_size)
{
        long ret = -1;
        if (send(p_socket, p_buffer, p_size, 0) != SOCKET_ERROR)
                ret = 0;
        return ret;
}

long Network::_test(SOCKET p_socket)
{
        int ret;
        if (ioctlsocket(p_socket, FIONREAD, (u_long*) &ret) == SOCKET_ERROR)
                 ret = -1;
        return ret;
}

long Network::_recv(SOCKET p_socket, char p_buffer[MAXBUFFER], long p_maxsize)
{
        long ret = -1;
        if (recv(p_socket, p_buffer, p_maxsize, 0) != SOCKET_ERROR)
                ret = p_maxsize;
        return ret;
}

SOCKET Network::_acceptConnection(SOCKET p_socket, std::string & p_ipAddress)
{
        SOCKET ret = INVALID_SOCKET;
        struct sockaddr_in  cli;

        int cli_size = sizeof(cli);
        ret = accept(p_socket,(struct sockaddr*) &cli, &cli_size);

        if (ret == INVALID_SOCKET)
                return ret = -1;

        p_ipAddress = inet_ntoa(cli.sin_addr);
        
        return ret;
}

int Network::_closeConnection(SOCKET &p_socket)
{
        int ret = -1;
        closesocket(p_socket);
        p_socket = INVALID_SOCKET;
        return ret;
}

SOCKET Network::_createServer(int p_port)
{
        SOCKET ret = INVALID_SOCKET;
        struct sockaddr_in srv;

        WSADATA wsa;
        if (WSAStartup(MAKEWORD(1, 1), &wsa))
        {
                printf("WSAStartup() failed, %lu\n", (unsigned long)GetLastError());
        }

        ret = socket(AF_INET, SOCK_STREAM, 0);
        if (ret == INVALID_SOCKET)
        {
                std::cout <<"socket() failed\n";
                return ret;
        }

        srv.sin_addr.s_addr = INADDR_ANY;
        srv.sin_port = htons( (unsigned short int) p_port);
        srv.sin_family = AF_INET;

        if (bind(ret,(struct sockaddr*) &srv, sizeof(srv)) == -1)
        {
                std::cout << "bind() failed\n";
                return ret = INVALID_SOCKET;
        }

        if (listen(ret, 3) == INVALID_SOCKET)
        {
                std::cout << "listen() failed\n";
                return ret = INVALID_SOCKET;
        }

        long toll;
        int i = ioctlsocket(ret,FIONBIO,(u_long*) &toll);
        if (i != 0)
        {
                std::cout << "unblocking failed\n";
                return ret = INVALID_SOCKET;
        }

        return ret;
}

SOCKET Network::_connect(std::string p_ipAddress, int p_port)
{
        SOCKET ret = INVALID_SOCKET;
        struct sockaddr_in srv;

        WSADATA wsa;
        if (WSAStartup(MAKEWORD(1, 1), &wsa))
        {
                printf("WSAStartup() failed, %lu\n", (unsigned long)GetLastError());
                ret = -1;
        }


        ret = socket(AF_INET, SOCK_STREAM, 0);
        if (ret == -1)
        {
                std::cout << "socket() failed\n";
                return ret;
        }

        srv.sin_addr.s_addr = inet_addr(p_ipAddress.c_str());
        srv.sin_port = htons( (unsigned short int) p_port);
        srv.sin_family = AF_INET;

        if (::connect(ret,(struct sockaddr*) &srv, sizeof(srv)) == -1)
        {
                std::cout << "connect() failed\n";
                return ret = -1;
        }

        long toll;
        int i = ioctlsocket(ret,FIONBIO,(u_long*) &toll);
        if (i != 0)
        {
                std::cout << "unblocking failed\n";
                return ret = -1;
        }

        return ret;
}

---