Compare commits

..

6 Commits

  1. 13
      lib/ip.hpp
  2. 81
      lib/tcp_socket.hpp
  3. 202
      src/tcp_socket.cpp
  4. 6
      test/client.cpp
  5. BIN
      test/client.exe
  6. BIN
      test/client.o
  7. 1
      test/compile-client.ps1
  8. 1
      test/compile-server.ps1
  9. 19
      test/server.cpp
  10. BIN
      test/server.exe
  11. BIN
      test/server.o

@ -4,9 +4,16 @@
#include <iostream>
#include <string>
#include <string.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <unistd.h>
#if __linux__
#include <arpa/inet.h>
#include <netdb.h>
#include <unistd.h>
#elif _WIN32
// #include <sstream>
#include <WinSock.h>
#include <ws2tcpip.h>
#endif
using namespace std;

@ -3,17 +3,32 @@
#include <iostream>
#include <string>
#include <vector>
#include <string.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <unistd.h>
#include <openssl/ssl.h>
#include <openssl/err.h>
#if __linux__
#include <arpa/inet.h>
#include <netdb.h>
#include <unistd.h>
#elif _WIN32
#include <WinSock.h>
#include <ws2tcpip.h>
#pragma comment(lib,"ws2_32.lib")
#define ushort u_short
#define uint u_int
#endif
#include "ip.hpp"
using namespace std;
class client;
// class secure;
// class server;
/**
* Server klasa za TCP/IP soket
* Instanca se incijalizira kada pokrećemo server
@ -21,12 +36,22 @@ using namespace std;
class server {
public:
int sock;
#if __linux__
int sock;
#elif _WIN32
WSADATA wsa;
SOCKET sock;
#endif
struct sockaddr_in addr;
SSL_CTX* securefds = NULL;
server (const ushort port, const uint limit = 1000);
server (const ushort port, const uint limit = 1000, SSL_CTX* _securefds = NULL);
~server ();
// one klijent
client* cli;
void accept(const uint timeout = 100);
};
/**
@ -51,40 +76,28 @@ class secure {
class client {
public:
int sock;
// zajedničke
#if __linux__
int conn; // mijenja sock
#elif _WIN32
WSADATA wsa;
SOCKET conn; // mijenja sock
#endif
struct sockaddr_in addr;
SSL* ssl = NULL;
client (const string address, const ushort port, const uint timeout = 100, SSL_CTX* securefds = NULL);
~client ();
bool tell (const string msg);
string obey (size_t byte_limit = 1024);
};
/**
* Klasa za inicijalizaciju dolaznih veza
* Definira se na serverskom tipu aplikacija i predstavlja identifikator klijenta
*/
class comming {
public:
const server *srv;
struct sockaddr_in addr;
int conn;
// server s klijentima
const server* srv;
// klijent sa serverom
string ipv4;
string ipv6;
SSL* ssl = NULL;
comming(const server *_srv, const uint timeout = 100, SSL_CTX* securefds = NULL);
~comming();
bool tell (const string msg);
string obey (size_t byte_limit = 1024);
// konstruktor za klijente bez servera
client (const string address, const ushort port, const uint timeout = 100, SSL_CTX* securefds = NULL);
// konstruktor za klijente sa serverom
client (const server *_srv, const uint timeout = 100, SSL_CTX* securefds = NULL);
~client ();
bool push (const string msg);
string pull (size_t byte_limit = 1024);
};
#endif

@ -4,12 +4,19 @@
* Kontrustruktor varijable tipa server, prima port i limit za ograničenje liste klijenata na čekanju
*/
server::server (const ushort port, const uint limit) {
server::server (const ushort port, const uint limit, SSL_CTX* _securefds) {
securefds = _securefds;
addr.sin_family = AF_INET;
addr.sin_addr.s_addr = INADDR_ANY;
addr.sin_port = htons(port);
#if _WIN32
if (WSAStartup(MAKEWORD(2,2),&wsa) != 0) {
throw string("[ERROR] WSA Startup. Detail: " + to_string(WSAGetLastError()));
}
#endif
sock = socket(AF_INET, SOCK_STREAM, 0);
if (sock <= 0) {
throw string("[ERROR] Unable to open TCP socket ");
@ -17,9 +24,16 @@ server::server (const ushort port, const uint limit) {
}
int opt=1;
if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt, sizeof(opt))) {
throw string("[ERROR] Unable to set REUSEADDR or REUSEPORT on socket ");
}
#if __linux__
if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt, sizeof(opt))) {
throw string("[ERROR] Unable to set REUSEADDR or REUSEPORT on socket ");
}
#elif _WIN32
if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (const char*)&opt, sizeof(opt))) {
throw string("[ERROR] Unable to set REUSEADDR or REUSEPORT on socket ");
}
#endif
if (bind(sock, (struct sockaddr *)&addr, sizeof(struct sockaddr_in)) < 0) {
throw string("[ERROR] Unable to bind socket ");
@ -31,6 +45,10 @@ server::server (const ushort port, const uint limit) {
}
void server::accept(const uint timeout) {
cli = new client(this, timeout, securefds);
}
/**
* Destruktor varijable tipa server
*/
@ -38,14 +56,28 @@ server::server (const ushort port, const uint limit) {
server::~server () {
cli->~client();
cli = NULL;
if (sock<=0) {
throw string("[ERROR] The socket is already closed ");
}
else if (close(sock) != 0) {
throw string("[ERROR] Unable to close socket ");
}
else {
#if __linux__
if (close(sock) != 0) {
throw string("[ERROR] Unable to close socket ");
}
#elif _WIN32
if (closesocket(sock) != 0) {
throw string("[ERROR] Unable to close socket ");
}
WSACleanup();
#endif
}
}
/**
@ -110,8 +142,14 @@ secure::~secure () {
client::client(const string address, const ushort port, const uint timeout, SSL_CTX* securefds) {
sock = socket(AF_INET, SOCK_STREAM, 0);
if (sock < 0) {
#if _WIN32
if (WSAStartup(MAKEWORD(2,2),&wsa) != 0) {
throw string("[ERROR] Unable to set WinSock " + to_string(WSAGetLastError()));
}
#endif
conn = socket(AF_INET, SOCK_STREAM, 0);
if (conn < 0) {
throw string("[ERROR] Unable to open TCP socket ");
}
@ -121,24 +159,31 @@ client::client(const string address, const ushort port, const uint timeout, SSL_
addr.sin_addr.s_addr = inet_addr(_address.c_str());
addr.sin_port = htons(port);
if (connect(sock, (struct sockaddr*)&addr, sizeof(struct sockaddr_in)) != 0) {
if (connect(conn, (struct sockaddr*)&addr, sizeof(struct sockaddr_in)) != 0) {
throw string("Unable to connect to server ");
}
struct timeval tv;
tv.tv_sec = timeout/1000;
tv.tv_usec = (timeout%1000)*1000;
#if __linux__
struct timeval tv;
tv.tv_sec = timeout/1000;
tv.tv_usec = (timeout%1000)*1000;
if (setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(struct timeval))) {
throw string("[ERROR] Unable to set timeout ");
}
if (setsockopt(conn, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(struct timeval))) {
throw string("[ERROR] Unable to set timeout ");
}
#elif _WIN32
DWORD tv = timeout;
if (setsockopt(conn, SOL_SOCKET, SO_RCVTIMEO, (const char*)&tv, sizeof(tv))) {
throw string("[ERROR] Unable to set timeout ");
}
#endif
if (securefds) {
ssl = SSL_new(securefds);
if (!ssl) {
throw string("[ERROR] Creating SSL object ");
}
SSL_set_fd(ssl, sock);
SSL_set_fd(ssl, conn);
// Perform the SSL handshake
if (SSL_connect(ssl) <= 0) {
@ -150,65 +195,6 @@ client::client(const string address, const ushort port, const uint timeout, SSL_
}
/**
* Destruktor varijable tipa client
*/
client::~client () {
if (ssl) {
SSL_shutdown(ssl);
SSL_free(ssl);
}
if (sock <= 0) {
throw string("[ERROR] The socket is already closed ");
}
else if (close(sock) != 0) {
throw string("[ERROR] Unable to close socket ");
}
}
/**
* Metoda klase client za slanje podataka preko soketa
* Prima string koji će biti poslan
* Vraća logički statu poređenja psolanih karaktera i karaktera u stringu
*/
bool client::tell (const string msg) {
size_t sended = 0;
if (ssl) {
sended = SSL_write(ssl, msg.c_str(), msg.length());
}
else {
sended = write(sock, msg.c_str(), msg.length());
}
return sended == msg.length();
}
/**
* Metoda klase client za primanje poruke preko soketa
* Prima dozvoljeni broj karaktera koji će primiti
* Vraća string primljene poruke
*/
string client::obey (size_t byte_limit) {
char res[byte_limit] = {0};
if (ssl) {
SSL_read(ssl, res, byte_limit);
}
else {
read(sock , res, byte_limit);
}
return string(res);
}
/**
* Konstruktor varijable tipa commint
* Prima pokazivač na inicijaliziranu varijablu tipa, port,
@ -217,7 +203,7 @@ string client::obey (size_t byte_limit) {
*/
comming::comming(const server *_srv, const uint timeout, SSL_CTX* securefds) {
client::client(const server *_srv, const uint timeout, SSL_CTX* securefds) {
srv = _srv;
socklen_t len = sizeof(struct sockaddr_in);
@ -225,13 +211,23 @@ comming::comming(const server *_srv, const uint timeout, SSL_CTX* securefds) {
throw string("[ERROR] Unable to accept client connection ");
}
struct timeval tv;
tv.tv_sec = timeout/1000;
tv.tv_usec = (timeout%1000)*1000;
#if __linux__
struct timeval tv;
tv.tv_sec = timeout/1000;
tv.tv_usec = (timeout%1000)*1000;
if (setsockopt(conn, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(struct timeval))) {
throw string("[ERROR] Unable to set timeout ");
}
#elif _WIN32
DWORD tv = timeout;
if (setsockopt(conn, SOL_SOCKET, SO_RCVTIMEO, (const char*)&tv, sizeof(tv))) {
throw string("[ERROR] Unable to set timeout ");
}
#endif
if (setsockopt(conn, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(struct timeval))) {
throw string("[ERROR] Unable to set timeout ");
}
if (securefds) {
@ -259,11 +255,12 @@ comming::comming(const server *_srv, const uint timeout, SSL_CTX* securefds) {
}
/**
* Destruktor varijable tipa comming
* Destruktor varijable tipa client
*/
comming::~comming() {
client::~client () {
if (ssl) {
SSL_shutdown(ssl);
@ -274,44 +271,57 @@ comming::~comming() {
throw string("[ERROR] The socket is already closed ");
}
else if (close(conn) != 0) {
throw string("[ERROR] Unable to close socket ");
else {
#if __linux__
if (close(conn) != 0) {
throw string("[ERROR] Unable to close socket ");
}
#elif _WIN32
if (closesocket(conn) != 0) {
throw string("[ERROR] Unable to close socket ");
}
//WSACleanup();
#endif
}
}
/**
* Metoda klase comming za slanje podataka preko soketa
* Metoda klase client za slanje podataka preko soketa
* Prima string koji će biti poslan
* Vraća logički statu poređenja psolanih karaktera i karaktera u stringu
*/
bool comming::tell (const string msg) {
ssize_t sended = 0;
bool client::push (const string msg) {
size_t sended = 0;
if (ssl) {
sended = SSL_write(ssl, msg.c_str(), msg.length());
}
else {
sended = write(conn, msg.c_str(), msg.length());
sended = send(conn, msg.c_str(), msg.length(), 0);
}
return sended == msg.length();
}
/**
* Metoda klase comming za primanje poruke preko soketa
* Metoda klase client za primanje poruke preko soketa
* Prima dozvoljeni broj karaktera koji će primiti
* Vraća string primljene poruke
*/
string comming::obey (size_t byte_limit) {
char res[byte_limit] = {0};
string client::pull (size_t byte_limit) {
char res[byte_limit] = {0};
if (ssl) {
SSL_read(ssl, res, byte_limit);
}
else {
read(conn , res, byte_limit);
recv(conn , res, byte_limit, 0);
}
return string(res);
}

@ -11,16 +11,16 @@ int main() {
secure crypto;
cout << "init cert " << endl;
client myserver("127.0.0.1", 5000, 5000, crypto.fds);
client myserver("localhost", 8000, 5000, crypto.fds);
// client myserver("localhost", 5000);
cout << "init client " << endl;
string sends = "Hello world!";
cout << myserver.tell(sends) << " " << sends.length() << endl;
cout << myserver.push(sends) << " " << sends.length() << endl;
cout << "wait client " << endl;
cout << myserver.obey();
cout << myserver.pull();
}
catch (const string err) {

Binary file not shown.

Binary file not shown.

@ -0,0 +1 @@
g++ client.cpp ../src/* -o client.exe -lssl -lcrypto -lws2_32

@ -0,0 +1 @@
g++ server.cpp ../src/* -o server.exe -lssl -lcrypto -lws2_32

@ -6,21 +6,26 @@ using namespace std;
int main() {
try{
cout << "init server " << endl;
server myserver(5000);
cout << "init cert " << endl;
secure crypto ("../example/cert.pem", "../example/privkey.pem");
cout << "init server " << endl;
server myserver(8000, 100, crypto.fds);
cout << "init client " << endl;
comming myclient(&myserver, 100, crypto.fds);
// client myclient(&myserver, 100, crypto.fds);
// comming myclient(&myserver, 100);
cout << "wait client " << myclient.ipv4 << endl;
myserver.accept();
// cout << "wait client " << myclient.ipv4 << endl;
cout << "wait client " << myserver.cli->ipv4 << endl;
string fromclient = myclient.obey();
string fromclient = myserver.cli->pull();
// string fromclient = myclient.pull();
cout << "tell client " << fromclient << endl;
// usleep(600*1000);
sleep(5);
myclient.tell(fromclient);
//sleep(5);
myserver.cli->push(fromclient);
// myclient.push(fromclient);
// myclient.~comming();
// while (true) {

Binary file not shown.

Binary file not shown.
Loading…
Cancel
Save