cmake_minimum_required(VERSION 2.6)

project(Socket)

set(LIBRARY_OUTPUT_PATH lib/${CMAKE_BUILD_TYPE})

set(CMAKE_CXX_STANDARD 14)

add_definitions(-DLINUX)

include_directories(Socket)

file(GLOB_RECURSE source_files Socket/*)

add_library(socket STATIC ${source_files})

MIT License

Copyright (c) 2017 Mohamed Amine Mzoughi

Permission is hereby granted, free of charge, to any person obtaining a copy

of this software and associated documentation files (the "Software"), to deal

in the Software without restriction, including without limitation the rights

to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

copies of the Software, and to permit persons to whom the Software is

furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all

copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

SOFTWARE.

[](http://opensource.org/licenses/MIT)

This is a simple TCP server/client for C++. Under Windows, it wraps WinSock and under Linux it wraps

the related socket API (BSD compatible).

It is meant to be a portable and easy-to-use API to create a TCP server or client.

Upcoming features : creating secure sockets with OpenSSL and using the sockets in an async way.

Compilation has been tested with:

- GCC 5.4.0 (GNU/Linux Ubuntu 16.04 LTS)

- Microsoft Visual Studio 2015 (Windows 10)

Create an object and provide to its constructor a callable object (for log printing) having this signature :

void(const std::string&)

This section will be completed soon....

Do not share ASocket objects across threads.

You will need CMake to generate a makefile for the static library or to build the tests/code coverage

program.

Also make sure you have libcurl and Google Test installed.

You can follow this script https://gist.github.com/fideloper/f72997d2e2c9fbe66459 to install libcurl.

This tutorial will help you installing properly Google Test on Ubuntu: https://www.eriksmistad.no/getting-started-with-google-test-on-ubuntu/

The CMake script located in the tree will produce a makefile for the creation of a static library,

whereas the one under SocketTest will produce the unit tests program.

To create a debug static library, change directory to the one containing the first CMakeLists.txt

cmake . -DCMAKE_BUILD_TYPE:STRING=Debug

make

To create a release static library, just change "Debug" by "Release".

The library will be found under lib/[BUILD_TYPE]/libsocket.a

For the unit tests program, first build the static library and use the same build type when

building it :

cd SocketTest

cmake . -DCMAKE_BUILD_TYPE=Debug # or Release

make

To run it :

./bin/[BUILD_TYPE]/test_socket

You can generate an XML file of test results by adding this argument when calling the test program

./bin/[BUILD_TYPE]/test_socket --gtest_output="xml:./TestSocket.xml"

Visual Leak Detector has been used to check memory leaks with the Windows build (Visual Sutdio 2015)

You can download it here: https://vld.codeplex.com/

To perform a leak check with the Linux build, you can do so :

valgrind --leak-check=full ./bin/Debug/test_socket

The code coverage build doesn't use the static library but compiles and uses directly the

socket API in the test program.

by the location of your ini file and launch the code coverage :

cd SocketTest

cmake . -DCMAKE_BUILD_TYPE=Coverage

make

make coverage_socket

If everything is OK, the results will be found under ./SocketTest/coverage/index.html

Under Visual Studio, you can simply use OpenCppCoverage (https://opencppcoverage.codeplex.com/)

The C++ code of the Socket C++ API classes is Cppcheck compliant.

All contributions are highly appreciated. This includes updating documentation, writing code and unit tests

to increase code coverage and enhance tools.

Try to preserve the existing coding style (Hungarian notation, indentation etc...).

#ifdef WINDOWS

#endif

#include <memory>

#else

#include <arpa/inet.h>

#include <errno.h>

#include <netinet/in.h>

#include <netdb.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <string.h>

#include <sys/types.h>

#include <sys/socket.h>

#include <unistd.h>

typedef int Socket;

#define INVALID_SOCKET -1

#ifdef WINDOWS

#else

m_pServer(nullptr)

#endif

#ifdef WINDOWS

m_ConnectSocket = socket(m_pResultAddrInfo->ai_family, // AF_INET

m_pResultAddrInfo->ai_socktype, // SOCK_STREAM

m_pResultAddrInfo->ai_protocol);// IPPROTO_TCP

#else

// socket creation

m_ConnectSocket = socket(AF_INET, SOCK_STREAM, 0);

if (m_ConnectSocket < 0)

{

m_oLog(StringFormat("[TCPClient][Error] opening socket: %s", strerror(errno)));

return false;

}

int iPort = atoi(strPort.c_str());

m_pServer = gethostbyname(strServer.c_str());

if (m_pServer == nullptr)

{

m_oLog("[TCPClient][Error] no such host.");

return false;

}

bzero(reinterpret_cast<char *>(&m_ServAddr), sizeof(m_ServAddr));

// copy address

bcopy(reinterpret_cast<char *>(m_pServer->h_addr), // src

reinterpret_cast<char *>(&m_ServAddr.sin_addr.s_addr), // dst

m_pServer->h_length); // len

m_ServAddr.sin_family = AF_INET;

m_ServAddr.sin_port = htons(iPort);

// connexion to the server

int iResult = connect(m_ConnectSocket,

reinterpret_cast<struct sockaddr *>(&m_ServAddr),

sizeof(m_ServAddr));

if (iResult >= 0)

{

m_eStatus = CONNECTED;

return true;

}

m_oLog(StringFormat("[TCPClient][Error] connecting : %s", strerror(errno)));

#endif

bool CTCPClient::Send(const char* pData, size_t uSize) const

int iResult = 0;

#ifdef WINDOWS

iResult = send(m_ConnectSocket, pData, uSize, 0);

#else

iResult = write(m_ConnectSocket, pData, uSize);

if (iResult < 0)

{

m_oLog(StringFormat("[TCPClient][Error] writing to socket : %s", strerror(errno)));

return false;

}

#endif

bool CTCPClient::Send(const std::string& strData) const

return Send(strData.c_str(), strData.length());

bool CTCPClient::Send(const std::vector<char>& Data) const

return Send(Data.data(), Data.size());

}

int CTCPClient::Receive(char* pData, size_t uSize) const

{

if (m_eStatus != CONNECTED)

{

m_oLog("[TCPClient][Error] recv failed : not connected to a server.");

return -1;

}

int iBytesRcvd = 0;

#ifdef WINDOWS

iBytesRcvd = recv(m_ConnectSocket, pData, uSize, 0);

if (iBytesRcvd < 0)

{

m_oLog(StringFormat("[TCPClient][Error] recv failed : %d", WSAGetLastError()));

}

#else

//bzero(pData, uSize);

iBytesRcvd = read(m_ConnectSocket, pData, uSize);

if (iBytesRcvd < 0)

{

m_oLog(StringFormat("[TCPClient][Error] reading from socket : %s", strerror(errno)));

}

#endif

return iBytesRcvd;

#ifdef WINDOWS

#else

close(m_ConnectSocket);

#endif

m_ConnectSocket = INVALID_SOCKET;