Compare commits

...

6 Commits

  1. 13
      lib/ip.hpp
  2. 79
      lib/tcp_socket.hpp
  3. 166
      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 <iostream>
#include <string> #include <string>
#include <string.h> #include <string.h>
#include <arpa/inet.h>
#include <netdb.h> #if __linux__
#include <unistd.h> #include <arpa/inet.h>
#include <netdb.h>
#include <unistd.h>
#elif _WIN32
// #include <sstream>
#include <WinSock.h>
#include <ws2tcpip.h>
#endif
using namespace std; using namespace std;

@ -3,17 +3,32 @@
#include <iostream> #include <iostream>
#include <string> #include <string>
#include <vector>
#include <string.h> #include <string.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <unistd.h>
#include <openssl/ssl.h> #include <openssl/ssl.h>
#include <openssl/err.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" #include "ip.hpp"
using namespace std; using namespace std;
class client;
// class secure;
// class server;
/** /**
* Server klasa za TCP/IP soket * Server klasa za TCP/IP soket
* Instanca se incijalizira kada pokrećemo server * Instanca se incijalizira kada pokrećemo server
@ -21,12 +36,22 @@ using namespace std;
class server { class server {
public: public:
#if __linux__
int sock; int sock;
#elif _WIN32
WSADATA wsa;
SOCKET sock;
#endif
struct sockaddr_in addr; 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 (); ~server ();
// one klijent
client* cli;
void accept(const uint timeout = 100);
}; };
/** /**
@ -51,40 +76,28 @@ class secure {
class client { class client {
public: public:
int sock; // zajedničke
#if __linux__
int conn; // mijenja sock
#elif _WIN32
WSADATA wsa;
SOCKET conn; // mijenja sock
#endif
struct sockaddr_in addr; struct sockaddr_in addr;
SSL* ssl = NULL; SSL* ssl = NULL;
// server s klijentima
client (const string address, const ushort port, const uint timeout = 100, SSL_CTX* securefds = NULL); const server* srv;
~client (); // klijent sa serverom
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;
string ipv4; string ipv4;
string ipv6; 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 #endif

@ -4,12 +4,19 @@
* Kontrustruktor varijable tipa server, prima port i limit za ograničenje liste klijenata na čekanju * 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_family = AF_INET;
addr.sin_addr.s_addr = INADDR_ANY; addr.sin_addr.s_addr = INADDR_ANY;
addr.sin_port = htons(port); 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); sock = socket(AF_INET, SOCK_STREAM, 0);
if (sock <= 0) { if (sock <= 0) {
throw string("[ERROR] Unable to open TCP socket "); throw string("[ERROR] Unable to open TCP socket ");
@ -17,9 +24,16 @@ server::server (const ushort port, const uint limit) {
} }
int opt=1; int opt=1;
#if __linux__
if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt, sizeof(opt))) { if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt, sizeof(opt))) {
throw string("[ERROR] Unable to set REUSEADDR or REUSEPORT on socket "); 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) { if (bind(sock, (struct sockaddr *)&addr, sizeof(struct sockaddr_in)) < 0) {
throw string("[ERROR] Unable to bind socket "); 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 * Destruktor varijable tipa server
*/ */
@ -38,14 +56,28 @@ server::server (const ushort port, const uint limit) {
server::~server () { server::~server () {
cli->~client();
cli = NULL;
if (sock<=0) { if (sock<=0) {
throw string("[ERROR] The socket is already closed "); throw string("[ERROR] The socket is already closed ");
} }
else if (close(sock) != 0) { 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 "); 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) { client::client(const string address, const ushort port, const uint timeout, SSL_CTX* securefds) {
sock = socket(AF_INET, SOCK_STREAM, 0); #if _WIN32
if (sock < 0) { 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 "); 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_addr.s_addr = inet_addr(_address.c_str());
addr.sin_port = htons(port); 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 "); throw string("Unable to connect to server ");
} }
#if __linux__
struct timeval tv; struct timeval tv;
tv.tv_sec = timeout/1000; tv.tv_sec = timeout/1000;
tv.tv_usec = (timeout%1000)*1000; tv.tv_usec = (timeout%1000)*1000;
if (setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(struct timeval))) { if (setsockopt(conn, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(struct timeval))) {
throw string("[ERROR] Unable to set timeout "); 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) { if (securefds) {
ssl = SSL_new(securefds); ssl = SSL_new(securefds);
if (!ssl) { if (!ssl) {
throw string("[ERROR] Creating SSL object "); throw string("[ERROR] Creating SSL object ");
} }
SSL_set_fd(ssl, sock); SSL_set_fd(ssl, conn);
// Perform the SSL handshake // Perform the SSL handshake
if (SSL_connect(ssl) <= 0) { 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 * Konstruktor varijable tipa commint
* Prima pokazivač na inicijaliziranu varijablu tipa, port, * 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; srv = _srv;
socklen_t len = sizeof(struct sockaddr_in); socklen_t len = sizeof(struct sockaddr_in);
@ -225,6 +211,7 @@ comming::comming(const server *_srv, const uint timeout, SSL_CTX* securefds) {
throw string("[ERROR] Unable to accept client connection "); throw string("[ERROR] Unable to accept client connection ");
} }
#if __linux__
struct timeval tv; struct timeval tv;
tv.tv_sec = timeout/1000; tv.tv_sec = timeout/1000;
tv.tv_usec = (timeout%1000)*1000; tv.tv_usec = (timeout%1000)*1000;
@ -232,6 +219,15 @@ comming::comming(const server *_srv, const uint timeout, SSL_CTX* securefds) {
if (setsockopt(conn, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(struct timeval))) { if (setsockopt(conn, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(struct timeval))) {
throw string("[ERROR] Unable to set timeout "); 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) { 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) { if (ssl) {
SSL_shutdown(ssl); SSL_shutdown(ssl);
@ -274,44 +271,57 @@ comming::~comming() {
throw string("[ERROR] The socket is already closed "); throw string("[ERROR] The socket is already closed ");
} }
else if (close(conn) != 0) { else {
#if __linux__
if (close(conn) != 0) {
throw string("[ERROR] Unable to close socket "); 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 * Prima string koji će biti poslan
* Vraća logički statu poređenja psolanih karaktera i karaktera u stringu * 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) { if (ssl) {
sended = SSL_write(ssl, msg.c_str(), msg.length()); sended = SSL_write(ssl, msg.c_str(), msg.length());
} }
else { else {
sended = write(conn, msg.c_str(), msg.length()); sended = send(conn, msg.c_str(), msg.length(), 0);
} }
return sended == msg.length(); 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 * Prima dozvoljeni broj karaktera koji će primiti
* Vraća string primljene poruke * Vraća string primljene poruke
*/ */
string comming::obey (size_t byte_limit) { string client::pull (size_t byte_limit) {
char res[byte_limit] = {0}; char res[byte_limit] = {0};
if (ssl) { if (ssl) {
SSL_read(ssl, res, byte_limit); SSL_read(ssl, res, byte_limit);
} }
else { else {
read(conn , res, byte_limit); recv(conn , res, byte_limit, 0);
} }
return string(res); return string(res);
} }

@ -11,16 +11,16 @@ int main() {
secure crypto; secure crypto;
cout << "init cert " << endl; 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); // client myserver("localhost", 5000);
cout << "init client " << endl; cout << "init client " << endl;
string sends = "Hello world!"; string sends = "Hello world!";
cout << myserver.tell(sends) << " " << sends.length() << endl; cout << myserver.push(sends) << " " << sends.length() << endl;
cout << "wait client " << endl; cout << "wait client " << endl;
cout << myserver.obey(); cout << myserver.pull();
} }
catch (const string err) { 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() { int main() {
try{ try{
cout << "init server " << endl;
server myserver(5000);
cout << "init cert " << endl; cout << "init cert " << endl;
secure crypto ("../example/cert.pem", "../example/privkey.pem"); secure crypto ("../example/cert.pem", "../example/privkey.pem");
cout << "init server " << endl;
server myserver(8000, 100, crypto.fds);
cout << "init client " << endl; cout << "init client " << endl;
comming myclient(&myserver, 100, crypto.fds); // client myclient(&myserver, 100, crypto.fds);
// comming myclient(&myserver, 100); // 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; cout << "tell client " << fromclient << endl;
// usleep(600*1000); // usleep(600*1000);
sleep(5); //sleep(5);
myclient.tell(fromclient); myserver.cli->push(fromclient);
// myclient.push(fromclient);
// myclient.~comming(); // myclient.~comming();
// while (true) { // while (true) {

Binary file not shown.

Binary file not shown.
Loading…
Cancel
Save