source/network/TCPSocket.cpp

Go to the documentation of this file.

/*
 * Copyright (c) 2007, 2008, 2009, University of Karlsruhe (for members see AUTHORS file)
 *
 * ISC License
 *
 * Permission to use, copy, modify, and/or distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 * 
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 *
 * Created by Manfred Kroehnert on 26.07.2008.
 * based on CUDPSocket from Pedram Azad and Kai Welke
 */

// **************************************************************
// includes
// **************************************************************

#include "../include/IPSA/network/TCPSocket.h"
#include <cstdio>

#ifdef WIN32
#else
#include <netdb.h>
#include <errno.h>
#include <sys/ioctl.h>
#include <arpa/inet.h> //inte_ntop()
#endif


// **************************************************************
// defines
// **************************************************************

// **************************************************************
// CTCPSocket
// **************************************************************
CTCPSocket::CTCPSocket(const std::string& address, int nPort, bool isServer, int nTimeoutMilliSec)
:PORT(nPort),
remoteAddress(address),
timeout(nTimeoutMilliSec),
LISTEN_BACKLOG(5),
bInitialised(false),
IS_SERVER_SOCKET(isServer),
tcp_socket(-1),
server_listen_socket(-1)
{
                #ifdef WIN32
                WSADATA wsadata;
                if (WSAStartup(MAKEWORD(1, 1), &wsadata) != 0)   
                {
                                printf("WSAStartup() failed, %lu\n", (unsigned long)GetLastError());
                                exit(1);
                }
                #endif

                this->address.sin_family = AF_INET;
                this->address.sin_port = htons(PORT);
}


CTCPSocket::~CTCPSocket()
{
                closeSocket();
                
                #ifdef WIN32
                WSACleanup();
                #endif
}


bool CTCPSocket::openSocket()
{
                bInitialised = false;
                
                // create socket for TCP
                tcp_socket = socket(PF_INET, SOCK_STREAM, 0);
                
                bool result = tcp_socket != INVALID_SOCKET;
                
                if (!result)
                {
                                printf("error: could not create socket\n");
                                perror("CTCPSocket::openSocket() -> socket()");
                                return false;
                }

#ifndef WIN32
        // get rid of "Address already in use" messages
        int yes = 1;
        if (-1 == setsockopt(tcp_socket, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(int)))
                perror("setsockopt()");
#endif // !WIN32

                if (IS_SERVER_SOCKET)
                {
                                server_listen_socket = tcp_socket;
                                address.sin_addr.s_addr = htonl(INADDR_ANY);
                                memset(address.sin_zero, '\0', sizeof address.sin_zero);
                                
                                if (bind(tcp_socket, (struct sockaddr *) &address, sizeof(address)) == -1) 
                                {
                                                printf("error: could not bind to address and port '%s:%i'\n", remoteAddress.c_str(), PORT);
                                                perror("CTCPSocket::openSocket() -> bind()");
                                                closeSocket();
                                                return false;
                                }
                                if (-1 == listen(tcp_socket, LISTEN_BACKLOG))
                                                perror("listen");
                                // wait for connection
                                printf("Waiting for connection ... ");
#ifdef WIN32
                                int sin_size = sizeof(struct sockaddr_in);
#else
                                socklen_t sin_size = sizeof(struct sockaddr_in);
#endif // !WIN32
                                sockaddr_in remote_host;
                                tcp_socket = accept(server_listen_socket, (struct sockaddr*) &remote_host, &sin_size);
                                if (-1 == tcp_socket)
                                {
                                                printf("error\n");
                                                perror("accept()");
                                                return false;
                                }
#ifdef WIN32
                                printf("accepted\n");
#else
                                char ip_string[INET_ADDRSTRLEN];
                                inet_ntop(remote_host.sin_family, &remote_host.sin_addr.s_addr, ip_string, INET_ADDRSTRLEN);
                                printf("accepted\nConnected from %s:%d\n", ip_string, remote_host.sin_port);
#endif
                }
                else
                {
                                struct hostent* host = gethostbyname(remoteAddress.c_str());
                                if (NULL == host)
                                {   
#ifdef WIN32
                                                printf("gethostbyname(%s) failed with error: %ld\n",remoteAddress.c_str(),WSAGetLastError());
#else
                                                herror("CTCPSocket::openSocket() -> gethostbyname()");
#endif
                                                return false;
                                }
                                address.sin_addr = *((struct in_addr*) host->h_addr);
                                memset(address.sin_zero, '\0', sizeof address.sin_zero);

                                if (-1 == connect(tcp_socket, (struct sockaddr *)&address, sizeof address)) {
                                                perror("CTCPSocket::openSocket() -> connect()");
                                                return false;
                                }
                }

                if (!setNonBlocking(timeout))
                {
                                printf("error: could not set socket to non blocking for receiving\n");
                                closeSocket();
                                return false;
                }
                
                bInitialised = true;
                
                return true;
}


void CTCPSocket::closeSocket()
{
#ifdef WIN32
                closesocket(tcp_socket);
#else
                close(tcp_socket);
#endif

                if (IS_SERVER_SOCKET)
                {
#ifdef WIN32
                                closesocket(server_listen_socket);
#else
                                close(server_listen_socket);
#endif
                }

                bInitialised = false;
}


bool CTCPSocket::setNonBlocking(int nTimeoutMilliSec)
{
                if (0 == nTimeoutMilliSec)
                {
                                unsigned long mode = 1;

#ifdef WIN32
                                const int RESULT = ioctlsocket(tcp_socket, FIONBIO, &mode);
#else
                                const int RESULT = ioctl(tcp_socket, FIONBIO, &mode);
#endif
                                
                                if (RESULT != 0)
                                                return false;
                }
                else if (0 > nTimeoutMilliSec)
                {
                                //negative timeout -> enable blocking
                                unsigned long disableFlag = 0;
#ifdef WIN32
                                const int RESULT = ioctlsocket(tcp_socket, FIONBIO, &disableFlag);
#else
                                const int RESULT = ioctl(tcp_socket, FIONBIO, &disableFlag);
#endif // !WIN32
                                if (-1 == RESULT)
                                                perror("CTCPSocket::setNonBlocking() -> ioctl(tcp_socket, FIONBIO)");
                }
                else
                {
#ifdef WIN32
                                __int64 to;
                                to = (__int64) nTimeoutMilliSec; // set timeout to be 1000 millisec
                                const int RESULT = setsockopt(tcp_socket, SOL_SOCKET, SO_RCVTIMEO, (char FAR*) &to, sizeof(__int64));
#else
                                struct timeval to;
                                to.tv_sec = (nTimeoutMilliSec / 1000);
                                to.tv_usec = (nTimeoutMilliSec % 1000) * 1000;
                                const int RESULT = setsockopt(tcp_socket, SOL_SOCKET, SO_RCVTIMEO, &to, sizeof(struct timeval));
#endif
                                
                                if (RESULT < 0)
                                                return false;
                }
                
                return true;
}


bool CTCPSocket::isConnected()
{
                return bInitialised;
}


int CTCPSocket::send(const char *pData, int nSize) const
{
                if (!bInitialised)
                {
                                printf("error: could not send: socket not initialised\n");
                                return -1;
                }
                
                int sentBytes = ::send(tcp_socket, pData, nSize, 0);
                //if (-1 == sentBytes)
                //              perror("CTCPSocket::send() -> send()");
                
                return sentBytes;
}


int CTCPSocket::send(const std::string& data) const
{
                return this->send(data.c_str(), data.size());
}


int CTCPSocket::receive(char *pBuffer, int nSize)
{
                if (!bInitialised)
                {
                                printf("error: could not receive: socket not initialised\n");
                                return -1;
                }
                
                int receivedBytes = recv(tcp_socket, pBuffer, nSize, 0);
                //if (-1 == receivedBytes)
                //              perror("CTCPSocket::receive() -> recv()");
                if (0 == receivedBytes)
                                bInitialised = false; //remote connection was closed
                return receivedBytes;
}

---