USocket.h

Go to the documentation of this file.

//    Copyright (C) 2014-2015 Dylan Blair
//
//    email: dblair@alumni.cs.utexas.edu
//
//    This library is free software; you can redistribute it and/or
//    modify it under the terms of the GNU Lesser General Public
//    License as published by the Free Software Foundation; either
//    version 2.1 of the License, or (at your option) any later version.
//
//    This library 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
//    Lesser General Public License for more details.
//
//    You should have received a copy of the GNU Lesser General Public
//    License along with this library; if not, write to the Free Software
//    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

#ifndef USOCKET_H
#define USOCKET_H

#ifdef _WIN32
#include <winsock2.h>
#define COPY_LAST_SOCKET_ERROR() sprintf(_errorBuffer, "%d", WSAGetLastError())
#else
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <errno.h>

typedef int SOCKET;

#define COPY_LAST_SOCKET_ERROR() sprintf(_errorBuffer, "%d", errno)
#define INVALID_SOCKET -1
#define SOCKET_ERROR -1
#endif

#include <stdio.h>

namespace OpenSkyNet {
    namespace Utils {
        class Socket {
        public:
            static bool init(char (&errorBuffer_)[MAX_STRING_SIZE]) {
#ifdef _WIN32
                WSADATA wsaData;

                int result = WSAStartup(MAKEWORD(2, 2), &wsaData);

                if (result != NO_ERROR) {
                    sprintf(errorBuffer_, "%d", result);
                    return false;
                }
#endif

                return true;
            }

            static void shutDown() {
#ifdef _WIN32
                WSACleanup();
#endif
            }

            Socket() : _socket(INVALID_SOCKET), _acceptSocket(INVALID_SOCKET), _isConnected(false) {}

            bool create() {
                _socket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);

                if (_socket == INVALID_SOCKET) {
                    COPY_LAST_SOCKET_ERROR();
                    return false;
                }

                return true;
            }

            bool connectTo(const char* ipAddr_, unsigned int port_) {
                sockaddr_in service;
                service.sin_family = AF_INET;
                service.sin_addr.s_addr = inet_addr(ipAddr_);
                service.sin_port = htons(port_);

                int result = connect(_socket, (sockaddr*)&service, sizeof(service));

                if (result == SOCKET_ERROR) {
                    COPY_LAST_SOCKET_ERROR();
                    return false;
                }

                _isConnected = true;
                return true;
            }

            bool listenTo(const char* ipAddr_, unsigned int port_) {
                sockaddr_in service;
                service.sin_family = AF_INET;
                service.sin_addr.s_addr = inet_addr(ipAddr_);
                service.sin_port = htons(port_);

                int result = bind(_socket, (sockaddr*)&service, sizeof(service));

                if (result == SOCKET_ERROR) {
                    COPY_LAST_SOCKET_ERROR();
                    return false;
                }

                result = listen(_socket, SOMAXCONN);

                if (result == SOCKET_ERROR) {
                    COPY_LAST_SOCKET_ERROR();
                    return false;
                }

                return true;
            }

            bool acceptConnection() {
                assert(_acceptSocket == INVALID_SOCKET);
                _acceptSocket = accept(_socket, NULL, NULL);

                if (_acceptSocket == INVALID_SOCKET) {
                    COPY_LAST_SOCKET_ERROR();
                    return false;
                }

                _isConnected = true;
                return true;
            }

            bool closeConnection() {
                if (_socket != INVALID_SOCKET) {
#ifdef _WIN32
                    int result = closesocket(_socket);
#else
                    int result = shutdown(_socket, SHUT_RDWR);

                    if (result == SOCKET_ERROR) {
                        COPY_LAST_SOCKET_ERROR();
                        return false;
                    }

                    result = close(_socket);
#endif

                    if (result == SOCKET_ERROR) {
                        COPY_LAST_SOCKET_ERROR();
                        return false;
                    }
                }

                if (_acceptSocket != INVALID_SOCKET && _acceptSocket != _socket) {
#ifdef _WIN32
                    int result = closesocket(_acceptSocket);
#else
                    int result = shutdown(_acceptSocket, SHUT_RDWR);

                    if (result == SOCKET_ERROR) {
                        COPY_LAST_SOCKET_ERROR();
                        return false;
                    }

                    result = close(_acceptSocket);
#endif

                    if (result == SOCKET_ERROR) {
                        COPY_LAST_SOCKET_ERROR();
                        return false;
                    }
                }

                _socket = INVALID_SOCKET;
                _acceptSocket = INVALID_SOCKET;
                _isConnected = false;
                return true;
            }

            bool sendData(const char* buffer_, OpenSkyNet::Utils::uint bufferLen_) {
                if (isConnected()) {
                    int result = SOCKET_ERROR;

                    if (isConnectedAsClient())
                        result = send(_socket, buffer_, static_cast<int>(bufferLen_), 0);
                    else {
                        assert(isConnectedAsServer());
                        result = send(_acceptSocket, buffer_, static_cast<int>(bufferLen_), 0);
                    }

                    if (result == SOCKET_ERROR) {
                        COPY_LAST_SOCKET_ERROR();
                        return false;
                    }

                    return true;
                }

                sprintf(_errorBuffer, "Not Connected");
                return false;
            }

            int recvData(char* buffer_, OpenSkyNet::Utils::uint bufferLen_) {
                if (isConnected()) {
                    int result = SOCKET_ERROR;

                    if (isConnectedAsClient())
                        result = recv(_socket, buffer_, static_cast<int>(bufferLen_), 0);
                    else {
                        assert(isConnectedAsServer());
                        result = recv(_acceptSocket, buffer_, static_cast<int>(bufferLen_), 0);
                    }

                    if (result == 0) {
                        memset(buffer_, 0, bufferLen_);
                        return 0;
                    }
                    else if (result == SOCKET_ERROR) {
                        COPY_LAST_SOCKET_ERROR();
                        return -1;
                    }

                    return result;
                }

                sprintf(_errorBuffer, "Not Connected");
                return false;
            }

            inline bool isConnected() const { return _isConnected; }
            inline bool isConnectedAsServer() const { return isConnected() && _acceptSocket != INVALID_SOCKET; }
            inline bool isConnectedAsClient() const { return isConnected() && _acceptSocket == INVALID_SOCKET; }

            inline const char* getLastErrorString() const { return _errorBuffer; }
        private:
            SOCKET _socket;
            SOCKET _acceptSocket;
            char _errorBuffer[MAX_STRING_SIZE];
            bool _isConnected;
        };

        template<class T>
        void serialize(T val_, char*& buffer_, OpenSkyNet::Utils::uint& bufferLen_) {
            static OpenSkyNet::Utils::uint size = sizeof(T);

            memcpy(buffer_, &val_, size);
            bufferLen_ += size;
            buffer_ += size;
        }

        template<class T>
        T assemble(char*& buffer_, OpenSkyNet::Utils::uint& bufferLen_) {
            static OpenSkyNet::Utils::uint size = sizeof(T);

            T val = *reinterpret_cast<T*>(buffer_);
            bufferLen_ += size;
            buffer_ += size;

            return val;
        }
    }
}

#endif //USOCKET_H