https://github.com/anyks/awh

ANYKS - WEB (AWH) C++
https://github.com/anyks/awh

anyks dtls https-client https-proxy https-server proxy proxy-server rest-server sctp socks5 socks5-server tcp-client tcp-server tls-server udp-client udp-server web-server websocket websocket-client websocket-server

Last synced: 5 days ago
JSON representation

ANYKS - WEB (AWH) C++

• Host: GitHub
• URL: https://github.com/anyks/awh
• Owner: anyks
• License: gpl-3.0
• Created: 2021-09-14T19:35:27.000Z (over 3 years ago)
• Default Branch: main
• Last Pushed: 2025-04-22T12:12:40.000Z (12 days ago)
• Last Synced: 2025-04-22T12:27:01.602Z (12 days ago)
• Topics: anyks, dtls, https-client, https-proxy, https-server, proxy, proxy-server, rest-server, sctp, socks5, socks5-server, tcp-client, tcp-server, tls-server, udp-client, udp-server, web-server, websocket, websocket-client, websocket-server
• Language: C++
• Homepage: https://anyks.com
• Size: 22.5 MB
• Stars: 10
• Watchers: 1
• Forks: 4
• Open Issues: 0
• Metadata Files:
  • Readme: README.md
  • License: LICENSE

Awesome Lists containing this project

README

        
[![ANYKS - WEB](https://raw.githubusercontent.com/anyks/awh/main/img/banner.jpg)](https://anyks.com)

# ANYKS - WEB (AWH) C++

## Project goals and features

- **HTTP / HTTPS**: WEB - CLIENT / SERVER.

- **WS / WSS**: WebSocket - CLIENT / SERVER.

- **Proxy**: HTTP(S) / SOCKS5 PROXY - CLIENT / SERVER.

- **Compress**: GZIP / BZIP2 / ZSTD / LZ4 / LZMA / DEFLATE / BROTLI - compression support.

- **Authentication**: BASIC / DIGEST - authentication support.

## Supported protocols HTTP/1.1 and HTTP/2 (RFC9113)

## Requirements

- [LZ4](https://lz4.org)

- [Zlib](http://www.zlib.net)

- [BZip2](http://www.bzip.org)

- [Brotli](https://brotli.org)

- [ZStandart](https://github.com/facebook/zstd)

- [Lempel–Ziv–Markov](https://github.com/hunter-packages/lzma)

- [PCRE2](https://www.pcre.org)

- [OpenSSL](https://www.openssl.org)

- [CityHash](https://github.com/google/cityhash)

- [LibIconv](https://www.gnu.org/software/libiconv)

- [LibIdn2](https://www.gnu.org/software/libidn)

- [NgHttp2](https://nghttp2.org/documentation/)

- [NLohmann::json](https://json.nlohmann.me)

## To build and launch the project

### To clone the project

```bash

$ git clone --recursive https://github.com/anyks/awh.git

```

### Activate SCTP only (FreeBSD / Linux)

#### FreeBSD

```bash

$ sudo kldload sctp

```

#### Linux (Ubuntu)

```bash

$ sudo apt install libsctp-dev

$ sudo modprobe sctp

$ sudo sysctl -w net.sctp.auth_enable=1

```

```bash

$ cd ./certs

$ ./certs.sh example.com

```

### Build third party for MacOS X, Linux and FreeBSD

```bash

$ ./build_third_party.sh --idn

```

### Build on MacOS X, Linux and FreeBSD

```bash

$ mkdir ./build

$ cd ./build

$ cmake \

 -DCMAKE_BUILD_IDN=YES \

 -DCMAKE_BUILD_TYPE=Release \

 -DCMAKE_SHARED_BUILD_LIB=YES \

 ..

$ make

```

### Build on Windows [MSYS2 MinGW]

#### Development environment configuration

- [GIT](https://git-scm.com)

- [Perl](https://strawberryperl.com)

- [Python](https://www.python.org/downloads/windows)

- [MSYS2](https://www.msys2.org)

- [CMAKE](https://cmake.org/download)

#### Assembly is done in MSYS2 - MINGW64 terminal

```bash

$ pacman -Syuu

$ pacman -Ss cmake

$ pacman -S mingw64/mingw-w64-x86_64-cmake

$ pacman -S make

$ pacman -S curl

$ pacman -S wget

$ pacman -S mc

$ pacman -S gdb

$ pacman -S bash

$ pacman -S clang

$ pacman -S git

$ pacman -S autoconf

$ pacman -S --needed base-devel mingw-w64-x86_64-toolchain

$ pacman -S mingw-w64-x86_64-dlfcn

```

### Build third party for MS Windows

```bash

$ ./build_third_party.sh

```

#### Project build

```bash

$ mkdir ./build

$ cd ./build

$ cmake \

 -G "MSYS Makefiles" \

 -DCMAKE_BUILD_IDN=YES \

 -DCMAKE_BUILD_TYPE=Release \

 -DCMAKE_SYSTEM_NAME=Windows \

 -DCMAKE_SHARED_BUILD_LIB=YES \

 ..

$ cmake --build .

```

### Example WEB-client multirequests

```c++

#include 

using namespace std;

using namespace awh;

class WebClient {

	private:

		uint8_t _count;

	private:

		const fmk_t * _fmk;

		const log_t * _log;

	public:

		

		void message(const int32_t sid, const uint64_t rid, const uint32_t code, const string & message){

			(void) rid;

			

			if(code >= 300)

				this->_log->print("Request failed: %u %s stream=%i", log_t::flag_t::WARNING, code, message.c_str(), sid);

		}

		

		void active(const client::web_t::mode_t mode, client::awh_t * awh){

			this->_log->print("%s client", log_t::flag_t::INFO, (mode == client::web_t::mode_t::CONNECT ? "Connect" : "Disconnect"));

			

			if(mode == client::web_t::mode_t::CONNECT){

				uri_t uri(this->_fmk);

				client::web_t::request_t req1, req2;

				req1.method = web_t::method_t::GET;

				req2.method = web_t::method_t::GET;

				req1.url = uri.parse("/mac/");

				req2.url = uri.parse("/iphone/");

				awh->send(std::move(req1));

				awh->send(std::move(req2));

			}

		}

		void entity(const int32_t sid, const uint64_t rid, const uint32_t code, const string & message, const vector  & entity, client::awh_t * awh){

			(void) sid;

			(void) rid;

			this->_count++;

			cout << "RESPONSE: " << string(entity.begin(), entity.end()) << endl;

			if(this->_count == 2)

				awh->stop();

		}

		void headers(const int32_t sid, const uint64_t rid, const uint32_t code, const string & message, const unordered_multimap  & headers){

			(void) sid;

			(void) rid;

			for(auto & header : headers)

				cout << "HEADER: " << header.first << ": " << header.second << endl;

			cout << endl;

		}

		void complete(const int32_t sid, const uint64_t rid, const uint32_t code, const string & message, const vector  & entity, const unordered_multimap  & headers, client::awh_t * awh){

			(void) sid;

			(void) rid;

			this->_count++;

			for(auto & header : headers)

				cout << "HEADER: " << header.first << ": " << header.second << endl;

			

			cout << endl;

			cout << "RESPONSE: " << string(entity.begin(), entity.end()) << endl;

			if(this->_count == 2)

				awh->stop();

		}

	public:

		WebClient(const fmk_t * fmk, const log_t * log) : _fmk(fmk), _log(log) {}

};

int32_t main(int32_t argc, char * argv[]){

	fmk_t fmk{};

	log_t log(&fmk);

	client::core_t core(&fmk, &log);

	client::awh_t awh(&core, &fmk, &log);

	WebClient executor(&fmk, &log);

	core.proto(awh::engine_t::proto_t::HTTP2);

	// core.proto(awh::engine_t::proto_t::HTTP1_1);

	log.name("WEB Client");

	log.format("%H:%M:%S %d.%m.%Y");

	awh.mode({

		client::web_t::flag_t::NOT_INFO,

		client::web_t::flag_t::REDIRECTS,

		client::web_t::flag_t::CONNECT_METHOD_ENABLE

	});

	node_t::ssl_t ssl;

	ssl.verify = true;

	ssl.ca     = "./certs/ca.pem";

	// ssl.key  = "./certs/certificates/client-key.pem";

	// ssl.cert = "./certs/certificates/client-cert.pem";

	core.ssl(ssl);

	// awh.user("user", "password");

	// awh.authType(auth_t::type_t::BASIC);

	// awh.authType(auth_t::type_t::DIGEST, auth_t::hash_t::MD5);

	// awh.proxy("http://user:[email protected]:port");

	// awh.proxy("https://user:[email protected]:port");

	// awh.proxy("socks5://user:[email protected]:port");

	// awh.proxy(client::scheme_t::work_t::ALLOW);

	// awh.proxy(client::scheme_t::work_t::DISALLOW);

	// awh.authTypeProxy(auth_t::type_t::BASIC);

	// awh.authTypeProxy(auth_t::type_t::DIGEST, auth_t::hash_t::MD5);

	/*

	awh.compressors({

		http_t::compressor_t::ZSTD,

		http_t::compressor_t::BROTLI,

		http_t::compressor_t::GZIP,

		http_t::compressor_t::DEFLATE

	});

	*/

	awh.callback  ("active", std::bind(&WebClient::active, &executor, _1, &awh));

	awh.callback  ("response", std::bind(&WebClient::message, &executor, _1, _2, _3, _4));

	// awh.callback  &)> ("headers", std::bind(&WebClient::headers, &executor, _1, _2, _3, _4, _5));

	// awh.callback  &)> ("entity", std::bind(&WebClient::entity, &executor, _1, _2, _3, _4, _5, &awh));

	awh.callback  &, const unordered_multimap  &)> ("complete", std::bind(&WebClient::complete, &executor, _1, _2, _3, _4, _5, _6, &awh));

	

	awh.init("https://apple.com");

	awh.start();

	return EXIT_SUCCESS;

}

```

### Example simple WEB-client

```c++

#include 

using namespace std;

using namespace awh;

int32_t main(int32_t argc, char * argv[]){

	fmk_t fmk{};

	log_t log(&fmk);

	uri_t uri(&fmk);

	client::core_t core(&fmk, &log);

	client::awh_t awh(&core, &fmk, &log);

	core.proto(awh::engine_t::proto_t::HTTP2);

	// core.proto(awh::engine_t::proto_t::HTTP1_1);

	log.name("WEB Client");

	log.format("%H:%M:%S %d.%m.%Y");

	awh.mode({

		client::web_t::flag_t::NOT_INFO,

		client::web_t::flag_t::REDIRECTS,

		client::web_t::flag_t::CONNECT_METHOD_ENABLE

	});

	node_t::ssl_t ssl;

	ssl.verify = true;

	ssl.ca     = "./certs/ca.pem";

	// ssl.key  = "./certs/certificates/client-key.pem";

	// ssl.cert = "./certs/certificates/client-cert.pem";

	core.ssl(ssl);

	// awh.user("user", "password");

	// awh.authType(auth_t::type_t::BASIC);

	// awh.authType(auth_t::type_t::DIGEST, auth_t::hash_t::MD5);

	// awh.proxy("http://user:[email protected]:port");

	// awh.proxy("https://user:[email protected]:port");

	// awh.proxy("socks5://user:[email protected]:port");

	// awh.proxy(client::scheme_t::work_t::ALLOW);

	// awh.proxy(client::scheme_t::work_t::DISALLOW);

	// awh.authTypeProxy(auth_t::type_t::BASIC);

	// awh.authTypeProxy(auth_t::type_t::DIGEST, auth_t::hash_t::MD5);

	/*

	awh.compressors({

		http_t::compressor_t::ZSTD,

		http_t::compressor_t::BROTLI,

		http_t::compressor_t::GZIP,

		http_t::compressor_t::DEFLATE

	});

	*/

	uri_t::url_t url = uri.parse("https://apple.com/ru/mac");

	const auto & body = awh.GET(url);

	

	if(!body.empty())

		cout << "RESPONSE: " << string(body.begin(), body.end()) << endl;

	return EXIT_SUCCESS;

}

```

### Example WEB-server

```c++

#include 

using namespace std;

using namespace awh;

class WebServer {

	private:

		const fmk_t * _fmk;

		const log_t * _log;

	private:

		awh::web_t::method_t _method;

	public:

		string password(const uint64_t bid, const string & login){

			this->_log->print("USER: %s, PASS: %s, ID: %zu", log_t::flag_t::INFO, login.c_str(), "password", bid);

			return "password";

		}

		bool auth(const uint64_t bid, const string & login, const string & password){

			this->_log->print("USER: %s, PASS: %s, ID: %zu", log_t::flag_t::INFO, login.c_str(), password.c_str(), bid);

			return true;

		}

	public:

		bool accept(const string & ip, const string & mac, const uint32_t port){

			this->_log->print("ACCEPT: IP=%s, MAC=%s, PORT=%d", log_t::flag_t::INFO, ip.c_str(), mac.c_str(), port);

			return true;

		}

		void active(const uint64_t bid, const server::web_t::mode_t mode){

			(void) bid;

			this->_log->print("%s client", log_t::flag_t::INFO, (mode == server::web_t::mode_t::CONNECT ? "Connect" : "Disconnect"));

		}

		void handshake(const int32_t sid, const uint64_t bid, const server::web_t::agent_t agent, server::awh_t * awh){

			if((this->_method == awh::web_t::method_t::GET) && (agent == server::web_t::agent_t::HTTP)){

				cout << "URL: " << awh->parser(sid, bid)->request().url << endl << endl;

			

				const string body = "\n\nHello World!\n\n\n"

				"
\"Hello, World!\" program
\n"

				"
\nFrom Wikipedia, the free encyclopedia
\n"

				"(Redirected from Hello, world!)
\n"

				"Jump to navigationJump to search
\n"

				"\"Hello World\" redirects here. For other uses, see Hello World (disambiguation).
\n"

				"A \"Hello, World!\" program generally is a computer program that outputs or displays the message \"Hello, World!\".
\n"

				"Such a program is very simple in most programming languages, and is often used to illustrate the basic syntax of a programming language. It is often the first program written by people learning to code. It can also be used as a sanity test to make sure that computer software intended to compile or run source code is correctly installed, and that the operator understands how to use it.\n"

				"
\n\n\n";


				if(awh->proto(bid) == engine_t::proto_t::HTTP2){

					vector > headers = {

						{":method", "GET"},

						{":scheme", "https"},

						{":path", "/stylesheets/screen.css"},

						{":authority", "example.com"},

						{"accept-encoding", "gzip, deflate"}

					};

					if(awh->push2(sid, bid, headers, awh::http2_t::flag_t::NONE) < 0)

						this->_log->print("Push message is not send", log_t::flag_t::WARNING);

				}

				if(awh->trailers(sid, bid)){

					awh->trailer(sid, bid, "Goga", "Hello");

					awh->trailer(sid, bid, "Hello", "World");

					awh->trailer(sid, bid, "Anyks", "Best of the best");

					awh->trailer(sid, bid, "Checksum", this->_fmk->hash(body, fmk_t::hash_t::MD5));

				}

				awh->send(sid, bid, 200, "OK", vector  (body.begin(), body.end()));

			}

		}

		void request(const int32_t sid, const uint64_t bid, const awh::web_t::method_t method, const uri_t::url_t & url, server::awh_t * awh){

			this->_method = method;

			if(!url.empty() && (!url.path.empty() && url.path.back().compare("favicon.ico") == 0))

				awh->send(sid, bid, 404);

		}

		void headers(const int32_t sid, const uint64_t bid, const awh::web_t::method_t method, const uri_t::url_t & url, const unordered_multimap  & headers){

			(void) sid;

			(void) bid;

			(void) url;

			(void) method;

			for(auto & header : headers)

				cout << "HEADER: " << header.first << ": " << header.second << endl;

		}

		void entity(const int32_t sid, const uint64_t bid, const awh::web_t::method_t method, const uri_t::url_t & url, const vector  & entity, server::awh_t * awh){

			(void) method;

			cout << "URL: " << url << endl << endl;

			cout << "BODY: " << string(entity.begin(), entity.end()) << endl;

			awh->send(sid, bid, 200, "OK", entity, {{"Connection", "close"}});

		}

		void complete(const int32_t sid, const uint64_t bid, const awh::web_t::method_t method, const uri_t::url_t & url, const vector  & entity, const unordered_multimap  & headers, server::awh_t * awh){

			(void) method;

			for(auto & header : headers)

				cout << "HEADER: " << header.first << ": " << header.second << endl;

			cout << "URL: " << url << endl << endl;

			if(!entity.empty()){

				cout << "BODY: " << string(entity.begin(), entity.end()) << endl;

				awh->send(sid, bid, 200, "OK", entity, {{"Connection", "close"}});

			}

		}

	public:

		WebServer(const fmk_t * fmk, const log_t * log) : _fmk(fmk), _log(log), _method(awh::web_t::method_t::NONE) {}

};

int32_t main(int32_t argc, char * argv[]){

	fmk_t fmk;

	log_t log(&fmk);

	server::core_t core(&fmk, &log);

	server::awh_t awh(&core, &fmk, &log);

	WebServer executor(&fmk, &log);

	log.name("WEB Server");

	log.format("%H:%M:%S %d.%m.%Y");

	core.sonet(awh::scheme_t::sonet_t::TLS);

	core.proto(awh::engine_t::proto_t::HTTP2);

	// core.proto(awh::engine_t::proto_t::HTTP1_1);

	

	core.cluster(awh::scheme_t::mode_t::ENABLED);

	node_t::ssl_t ssl;

	ssl.verify = false;

	ssl.key    = "./certs/certificates/server-key.pem";

	ssl.cert   = "./certs/certificates/server-cert.pem";

	core.ssl(ssl);

	awh.clusterAutoRestart(true);

	// awh.authType(auth_t::type_t::BASIC);

	awh.authType(auth_t::type_t::DIGEST, auth_t::hash_t::MD5);

	awh.init(2222, "127.0.0.1", {

		awh::http_t::compressor_t::ZSTD,

		awh::http_t::compressor_t::BROTLI,

		awh::http_t::compressor_t::GZIP,

		awh::http_t::compressor_t::DEFLATE,

	});

	/*

	awh.init("anyks", {

		awh::http_t::compressor_t::ZSTD,

		awh::http_t::compressor_t::BROTLI,

		awh::http_t::compressor_t::GZIP,

		awh::http_t::compressor_t::DEFLATE,

	});

	*/

	// awh.addOrigin("example.net");

	// awh.addAltSvc("example.net", "h2=\":2222\"");

	// awh.addAltSvc("example.com", "h2=\":8000\"");

	awh.callback  ("extractPassword", std::bind(&WebServer::password, &executor, _1, _2));

	awh.callback  ("checkPassword", std::bind(&WebServer::auth, &executor, _1, _2, _3));

	awh.callback  ("active", std::bind(&WebServer::active, &executor, _1, _2));

	awh.callback  ("accept", std::bind(&WebServer::accept, &executor, _1, _2, _3));

	awh.callback  ("handshake", std::bind(&WebServer::handshake, &executor, _1, _2, _3, &awh));

	awh.callback  ("request", std::bind(&WebServer::request, &executor, _1, _2, _3, _4, &awh));

	// awh.callback  &)> ("headers", std::bind(&WebServer::headers, &executor, _1, _2, _3, _4, _5));

	// awh.callback  &)> ("entity", std::bind(&WebServer::entity, &executor, _1, _2, _3, _4, _5, &awh));

	awh.callback  &, const unordered_multimap  &)> ("complete", std::bind(&WebServer::complete, &executor, _1, _2, _3, _4, _5, _6, &awh));

	awh.start();

	return EXIT_SUCCESS;

}

```

### Example WebSocket-client

```c++

#include 

using namespace std;

using namespace awh;

using namespace awh::client;

class Executor {

	private:

		const fmk_t * _fmk;

		const log_t * _log;

	public:

		void status(const awh::core_t::status_t status){

			switch(static_cast  (status)){

				case static_cast  (awh::core_t::status_t::START):

					this->_log->print("START", log_t::flag_t::INFO);

				break;

				case static_cast  (awh::core_t::status_t::STOP):

					this->_log->print("STOP", log_t::flag_t::INFO);

				break;

			}

		}

		void handshake(const int32_t sid, const uint64_t rid, const client::web_t::agent_t agent, client::websocket_t * ws){

			(void) sid;

			(void) rid;

			if(agent == client::web_t::agent_t::WEBSOCKET){

				this->_log->print("Handshake", log_t::flag_t::INFO);

				

				const string query = "Hello World!!!";

				ws->sendMessage(vector  (query.begin(), query.end()));

			}

		}

	public:

		void error(const uint32_t code, const string & mess){

			this->_log->print("%s [%u]", log_t::flag_t::CRITICAL, mess.c_str(), code);

		}

		void message(const vector  & buffer, const bool utf8, client::websocket_t * ws){

			string subprotocol = "";

			const auto subprotocols = ws->subprotocols();

			if(!subprotocols.empty())

				subprotocol = (* subprotocols.begin());

			if(utf8){

				

				cout << "MESSAGE: " << string(buffer.begin(), buffer.end()) << endl;

				cout << "SUB PROTOCOL: " << subprotocol << endl;

			}

		}

	public:

		Executor(const fmk_t * fmk, const log_t * log) : _fmk(fmk), _log(log) {}

};

int32_t main(int32_t argc, char * argv[]){

	fmk_t fmk;

	log_t log(&fmk);

	client::core_t core(&fmk, &log);

	websocket_t ws(&core, &fmk, &log);

	Executor executor(&fmk, &log);

	log.name("WebSocket Client");

	log.format("%H:%M:%S %d.%m.%Y");

	ws.mode({

		client::web_t::flag_t::ALIVE,

		client::web_t::flag_t::REDIRECTS,

		client::web_t::flag_t::TAKEOVER_CLIENT,

		client::web_t::flag_t::TAKEOVER_SERVER,

		client::web_t::flag_t::CONNECT_METHOD_ENABLE

	});

	core.sonet(awh::scheme_t::sonet_t::TLS);

	core.proto(awh::engine_t::proto_t::HTTP2);

	// core.proto(awh::engine_t::proto_t::HTTP1_1);

	node_t::ssl_t ssl;

	ssl.verify = false;

	ssl.key    = "./certs/certificates/client-key.pem";

	ssl.cert   = "./certs/certificates/client-cert.pem";

	core.ssl(ssl);

	// ws.proxy("http://user:[email protected]:port");

	// ws.proxy("https://user:[email protected]:port");

	// ws.proxy("socks5://user:[email protected]:port");

	// ws.proxy(client::scheme_t::work_t::ALLOW);

	// ws.proxy(client::scheme_t::work_t::DISALLOW);

	// ws.authTypeProxy(auth_t::type_t::BASIC);

	// ws.authTypeProxy(auth_t::type_t::DIGEST, auth_t::hash_t::MD5);

	

	ws.user("user", "password");

	// ws.authType(awh::auth_t::type_t::BASIC);

	ws.authType(awh::auth_t::type_t::DIGEST, awh::auth_t::hash_t::MD5);

	ws.init("wss://127.0.0.1:2222", {awh::http_t::compressor_t::DEFLATE});

	ws.subprotocols({"test2", "test8", "test9"});

	// ws.extensions({{"test1", "test2", "test3"},{"good1", "good2", "good3"}});

	ws.callback  ("status", std::bind(&Executor::status, &executor, _1));

	ws.callback  ("errorWebsocket", std::bind(&Executor::error, &executor, _1, _2));

	ws.callback  &, const bool)> ("messageWebsocket", std::bind(&Executor::message, &executor, _1, _2, &ws));

	ws.callback  ("handshake", std::bind(&Executor::handshake, &executor, _1, _2, _3, &ws));

	ws.start();

	return EXIT_SUCCESS;

}

```

### Example WebSocket-server

```c++

#include 

using namespace std;

using namespace awh;

using namespace awh::server;

class Executor {

	private:

		const fmk_t * _fmk;

		const log_t * _log;

	public:

		string password(const uint64_t bid, const string & login){

			this->_log->print("USER: %s, PASS: %s, ID: %zu", log_t::flag_t::INFO, login.c_str(), "password", bid);

			return "password";

		}

		bool auth(const uint64_t bid, const string & login, const string & password){

			this->_log->print("USER: %s, PASS: %s, ID: %zu", log_t::flag_t::INFO, login.c_str(), password.c_str(), bid);

			return true;

		}

	public:

		bool accept(const string & ip, const string & mac, const uint32_t port){

			this->_log->print("ACCEPT: IP=%s, MAC=%s, PORT=%d", log_t::flag_t::INFO, ip.c_str(), mac.c_str(), port);

			return true;

		}

		void active(const uint64_t bid, const server::web_t::mode_t mode){

			(void) bid;

			switch(static_cast  (mode)){

				case static_cast  (server::web_t::mode_t::CONNECT):

					this->_log->print("CONNECT", log_t::flag_t::INFO);

				break;

				case static_cast  (server::web_t::mode_t::DISCONNECT):

					this->_log->print("DISCONNECT", log_t::flag_t::INFO);

				break;

			}

		}

		void error(const uint64_t bid, const uint32_t code, const string & mess){

			(void) bid;

			this->_log->print("%s [%u]", log_t::flag_t::CRITICAL, mess.c_str(), code);

		}

		void message(const uint64_t bid, const vector  & buffer, const bool text, server::websocket_t * ws){

			if(!buffer.empty()){

				string subprotocol = "";

				const auto subprotocols = ws->subprotocols(bid);

				if(!subprotocols.empty())

					subprotocol = (* subprotocols.begin());

				this->_log->print("Message: %s [%s]", log_t::flag_t::INFO, string(buffer.begin(), buffer.end()).c_str(), subprotocol.c_str());

				ws->sendMessage(bid, buffer, text);

			}

		}

		void headers(const int32_t sid, const uint64_t bid, const awh::web_t::method_t method, const uri_t::url_t & url, const unordered_multimap  & headers){

			(void) sid;

			(void) bid;

			(void) method;

			uri_t uri(this->_fmk);

			this->_log->print("REQUEST ID=%zu URL=%s", log_t::flag_t::INFO, bid, uri.url(url).c_str());

			for(auto & header : headers)

				cout << "HEADER: " << header.first << ": " << header.second << endl;

		}

	public:

		Executor(const fmk_t * fmk, const log_t * log) : _fmk(fmk), _log(log) {}

};

int32_t main(int32_t argc, char * argv[]){

	fmk_t fmk;

	log_t log(&fmk);

	server::core_t core(&fmk, &log);

	websocket_t ws(&core, &fmk, &log);

	Executor executor(&fmk, &log);

	log.name("WebSocket Server");

	log.format("%H:%M:%S %d.%m.%Y");

	ws.mode({

		server::web_t::flag_t::TAKEOVER_CLIENT,

		server::web_t::flag_t::TAKEOVER_SERVER

	});

	core.sonet(awh::scheme_t::sonet_t::TLS);

	core.proto(awh::engine_t::proto_t::HTTP2);

	// core.proto(awh::engine_t::proto_t::HTTP1_1);

	core.cluster(awh::scheme_t::mode_t::ENABLED);

	node_t::ssl_t ssl;

	ssl.verify = false;

	ssl.key    = "./certs/certificates/server-key.pem";

	ssl.cert   = "./certs/certificates/server-cert.pem";

	core.ssl(ssl);

	ws.subprotocols({"test1", "test2", "test3"});

	// ws.authType(awh::auth_t::type_t::BASIC);

	ws.authType(awh::auth_t::type_t::DIGEST, awh::auth_t::hash_t::MD5);

	// ws.init("anyks", {awh::http_t::compressor_t::DEFLATE});

	// ws.init(2222, "", {awh::http_t::compressor_t::DEFLATE});

	ws.init(2222, "127.0.0.1", {awh::http_t::compressor_t::DEFLATE});

	ws.callback  ("extractPassword", std::bind(&Executor::password, &executor, _1, _2));

	ws.callback  ("checkPassword", std::bind(&Executor::auth, &executor, _1, _2, _3));

	ws.callback  ("accept", std::bind(&Executor::accept, &executor, _1, _2, _3));

	ws.callback  ("active", std::bind(&Executor::active, &executor, _1, _2));

	ws.callback  ("errorWebsocket", std::bind(&Executor::error, &executor, _1, _2, _3));

	ws.callback  &, const bool)> ("messageWebsocket", std::bind(&Executor::message, &executor, _1, _2, _3, &ws));

	ws.callback  &)> ("headers", std::bind(&Executor::headers, &executor, _1, _2, _3, _4, _5));

	ws.start();

	return EXIT_SUCCESS;

}

```

### Example multiprotocol HTTPS-server

```c++

#include 

using namespace std;

using namespace awh;

class WebServer {

	private:

		const fmk_t * _fmk;

		const log_t * _log;

	private:

		awh::web_t::method_t _method;

	public:

		string password(const uint64_t bid, const string & login){

			this->_log->print("USER: %s, PASS: %s, ID: %zu", log_t::flag_t::INFO, login.c_str(), "password", bid);

			return "password";

		}

		bool auth(const uint64_t bid, const string & login, const string & password){

			this->_log->print("USER: %s, PASS: %s, ID: %zu", log_t::flag_t::INFO, login.c_str(), password.c_str(), bid);

			return true;

		}

	public:

		bool accept(const string & ip, const string & mac, const uint32_t port){

			this->_log->print("ACCEPT: IP=%s, MAC=%s, PORT=%d", log_t::flag_t::INFO, ip.c_str(), mac.c_str(), port);

			return true;

		}

		void active(const uint64_t bid, const server::web_t::mode_t mode){

			(void) bid;

			this->_log->print("%s client", log_t::flag_t::INFO, (mode == server::web_t::mode_t::CONNECT ? "Connect" : "Disconnect"));

		}

		void error(const uint64_t bid, const uint32_t code, const string & mess){

			(void) bid;

			this->_log->print("%s [%u]", log_t::flag_t::CRITICAL, mess.c_str(), code);

		}

		void message(const uint64_t bid, const vector  & buffer, const bool text, server::awh_t * awh){

			if(!buffer.empty()){

				string subprotocol = "";

				const auto subprotocols = awh->subprotocols(bid);

				if(!subprotocols.empty())

					subprotocol = (* subprotocols.begin());

				this->_log->print("Message: %s [%s]", log_t::flag_t::INFO, string(buffer.begin(), buffer.end()).c_str(), subprotocol.c_str());

				awh->sendMessage(bid, buffer, text);

			}

		}

		void handshake(const int32_t sid, const uint64_t bid, const server::web_t::agent_t agent, server::awh_t * awh){

			if((this->_method == awh::web_t::method_t::GET) && (agent == server::web_t::agent_t::HTTP)){

				cout << " URL: " << awh->parser(sid, bid)->request().url << endl;

				const string body = "\n\nHello World!\n\n\n"

				"
\"Hello, World!\" program
\n"

				"
\nFrom Wikipedia, the free encyclopedia
\n"

				"(Redirected from Hello, world!)
\n"

				"Jump to navigationJump to search
\n"

				"\"Hello World\" redirects here. For other uses, see Hello World (disambiguation).
\n"

				"A \"Hello, World!\" program generally is a computer program that outputs or displays the message \"Hello, World!\".
\n"

				"Such a program is very simple in most programming languages, and is often used to illustrate the basic syntax of a programming language. It is often the first program written by people learning to code. It can also be used as a sanity test to make sure that computer software intended to compile or run source code is correctly installed, and that the operator understands how to use it.\n"

				"
\n\n\n";


				if(awh->trailers(sid, bid)){

					awh->trailer(sid, bid, "Goga", "Hello");

					awh->trailer(sid, bid, "Hello", "World");

					awh->trailer(sid, bid, "Anyks", "Best of the best");

					awh->trailer(sid, bid, "Checksum", this->_fmk->hash(body, fmk_t::hash_t::MD5));

				}

				awh->send(sid, bid, 200, "OK", vector  (body.begin(), body.end()));

			}

		}

		void request(const int32_t sid, const uint64_t bid, const awh::web_t::method_t method, const uri_t::url_t & url, server::awh_t * awh){

			this->_method = method;

			if(!url.empty() && (!url.path.empty() && url.path.back().compare("favicon.ico") == 0))

				awh->send(sid, bid, 404);

		}

		void headers(const int32_t sid, const uint64_t bid, const awh::web_t::method_t method, const uri_t::url_t & url, const unordered_multimap  & headers){

			(void) sid;

			(void) bid;

			(void) method;

			(void) url;

			for(auto & header : headers)

				cout << "HEADER: " << header.first << ": " << header.second << endl;

		}

		void entity(const int32_t sid, const uint64_t bid, const awh::web_t::method_t method, const uri_t::url_t & url, const vector  & entity, server::awh_t * awh){

			(void) method;

			cout << "URL: " << url << endl << endl;

			cout << "BODY: " << string(entity.begin(), entity.end()) << endl;

			awh->send(sid, bid, 200, "OK", entity, {{"Connection", "close"}});

		}

		void complete(const int32_t sid, const uint64_t bid, const awh::web_t::method_t method, const uri_t::url_t & url, const vector  & entity, const unordered_multimap  & headers, server::awh_t * awh){

			(void) method;

			for(auto & header : headers)

				cout << "HEADER: " << header.first << ": " << header.second << endl;

			cout << "URL: " << url << endl << endl;

			if(!entity.empty()){

				cout << "BODY: " << string(entity.begin(), entity.end()) << endl;

				awh->send(sid, bid, 200, "OK", entity, {{"Connection", "close"}});

			}

		}

	public:

		WebServer(const fmk_t * fmk, const log_t * log) : _fmk(fmk), _log(log), _method(awh::web_t::method_t::NONE) {}

};

int32_t main(int32_t argc, char * argv[]){

	fmk_t fmk;

	log_t log(&fmk);

	server::core_t core(&fmk, &log);

	server::awh_t awh(&core, &fmk, &log);

	WebServer executor(&fmk, &log);

	log.name("WEB Server");

	log.format("%H:%M:%S %d.%m.%Y");

	awh.mode({

		server::web_t::flag_t::TAKEOVER_CLIENT,

		server::web_t::flag_t::TAKEOVER_SERVER,

		server::web_t::flag_t::WEBSOCKET_ENABLE,

		server::web_t::flag_t::CONNECT_METHOD_ENABLE

	});

	core.sonet(awh::scheme_t::sonet_t::TLS);

	core.proto(awh::engine_t::proto_t::HTTP2);

	// core.proto(awh::engine_t::proto_t::HTTP1_1);

	core.cluster(awh::scheme_t::mode_t::ENABLED);

	node_t::ssl_t ssl;

	ssl.verify = false;

	ssl.key    = "./certs/certificates/server-key.pem";

	ssl.cert   = "./certs/certificates/server-cert.pem";

	core.ssl(ssl);

	awh.clusterAutoRestart(true);

	// awh.authType(auth_t::type_t::BASIC);

	awh.authType(auth_t::type_t::DIGEST, auth_t::hash_t::MD5);

	awh.init(2222, "127.0.0.1", {

		awh::http_t::compressor_t::ZSTD,

		awh::http_t::compressor_t::BROTLI,

		awh::http_t::compressor_t::GZIP,

		awh::http_t::compressor_t::DEFLATE,

	});

	/*

	awh.init("anyks", {

		awh::http_t::compressor_t::ZSTD,

		awh::http_t::compressor_t::BROTLI,

		awh::http_t::compressor_t::GZIP,

		awh::http_t::compressor_t::DEFLATE,

	});

	*/

	awh.addOrigin("example.net");

	awh.addAltSvc("example.net", "h2=\":2222\"");

	awh.addAltSvc("example.com", "h2=\":8000\"");

	awh.subprotocols({"test1", "test2", "test3"});

	awh.callback  ("extractPassword", std::bind(&WebServer::password, &executor, _1, _2));

	awh.callback  ("checkPassword", std::bind(&WebServer::auth, &executor, _1, _2, _3));

	awh.callback  ("active", std::bind(&WebServer::active, &executor, _1, _2));

	awh.callback  ("accept", std::bind(&WebServer::accept, &executor, _1, _2, _3));

	awh.callback  ("errorWebsocket", std::bind(&WebServer::error, &executor, _1, _2, _3));

	awh.callback  &, const bool)> ("messageWebsocket", std::bind(&WebServer::message, &executor, _1, _2, _3, &awh));

	awh.callback  ("handshake", std::bind(&WebServer::handshake, &executor, _1, _2, _3, &awh));

	awh.callback  ("request", std::bind(&WebServer::request, &executor, _1, _2, _3, _4, &awh));

	// awh.callback  &)> ("entity", std::bind(&WebServer::entity, &executor, _1, _2, _3, _4, _5, &awh));

	// awh.callback  &)> ("headers", std::bind(&WebServer::headers, &executor, _1, _2, _3, _4, _5));

	awh.callback  &, const unordered_multimap  &)> ("complete", std::bind(&WebServer::complete, &executor, _1, _2, _3, _4, _5, _6, &awh));

	awh.start();

	return EXIT_SUCCESS;

}

```

### Example HTTPS PROXY-server

```c++

#include 

using namespace std;

using namespace awh;

class Proxy {

	private:

		log_t * _log;

	public:

		string password(const uint64_t bid, const string & login){

			this->_log->print("USER: %s, PASS: %s", log_t::flag_t::INFO, login.c_str(), "password");

			return "password";

		}

		bool auth(const uint64_t bid, const string & login, const string & password){

			this->_log->print("USER: %s, PASS: %s", log_t::flag_t::INFO, login.c_str(), password.c_str());

			return true;

		}

	public:

		bool accept(const string & ip, const string & mac, const uint32_t port){

			this->_log->print("ACCEPT: ip = %s, mac = %s, port = %d", log_t::flag_t::INFO, ip.c_str(), mac.c_str(), port);

			return true;

		}

		void active(const uint64_t bid, const server::proxy_t::broker_t broker, const server::web_t::mode_t mode){

			(void) bid;

			switch(static_cast  (broker)){

				case static_cast  (server::proxy_t::broker_t::CLIENT):

					this->_log->print("%s client", log_t::flag_t::INFO, (mode == server::web_t::mode_t::CONNECT ? "Connect" : "Disconnect"));

				break;

				case static_cast  (server::proxy_t::broker_t::SERVER):

					this->_log->print("%s server", log_t::flag_t::INFO, (mode == server::web_t::mode_t::CONNECT ? "Connect" : "Disconnect"));

				break;

			}

		}

	public:

		Proxy(log_t * log) : _log(log) {}

};

int32_t main(int32_t argc, char * argv[]){

	fmk_t fmk;

	log_t log(&fmk);

	Proxy executor(&log);

	server::proxy_t proxy(&fmk, &log);

	log.name("Proxy Server");

	log.format("%H:%M:%S %d.%m.%Y");

	proxy.cluster(awh::scheme_t::mode_t::ENABLED);

	node_t::ssl_t ssl;

	ssl.verify = false;

	ssl.ca     = "./certs/ca.pem";

	ssl.key    = "./certs/certificates/server-key.pem";

	ssl.cert   = "./certs/certificates/server-cert.pem";

	proxy.ssl(ssl);

	proxy.mode({

		server::proxy_t::flag_t::SYNCPROTO,

		server::proxy_t::flag_t::REDIRECTS,

		server::proxy_t::flag_t::CONNECT_METHOD_SERVER_ENABLE

	});

	proxy.hosts(server::proxy_t::broker_t::CLIENT, "/etc/hosts");

	// proxy.authType(server::proxy_t::broker_t::SERVER, auth_t::type_t::BASIC);

	// proxy.authType(server::proxy_t::broker_t::SERVER, auth_t::type_t::DIGEST, auth_t::hash_t::SHA512);

	proxy.authType(server::proxy_t::broker_t::SERVER, auth_t::type_t::DIGEST, auth_t::hash_t::MD5);

	// proxy.init("anyks", http_t::compressor_t::GZIP);

	// proxy.init(2222, "", http_t::compressor_t::GZIP);

	proxy.init(2222, "127.0.0.1", http_t::compressor_t::GZIP);

	proxy.callback  ("extractPassword", std::bind(&Proxy::password, &executor, _1, _2));

	proxy.callback  ("checkPassword", std::bind(&Proxy::auth, &executor, _1, _2, _3));

	proxy.callback  ("accept", std::bind(&Proxy::accept, &executor, _1, _2, _3));

	proxy.callback  ("active", std::bind(&Proxy::active, &executor, _1, _2, _3));

	proxy.start();

	return EXIT_SUCCESS;

}

```

### Example Socks5 PROXY-server

```c++

#include 

using namespace std;

using namespace awh;

using namespace server;

class Proxy {

	private:

		const fmk_t * _fmk;

		const log_t * _log;

	public:

		bool auth(const uint64_t bid, const string & login, const string & password){

			this->_log->print("USER: %s, PASS: %s, ID: %zu", log_t::flag_t::INFO, login.c_str(), password.c_str(), bid);

			return true;

		}

	public:

		bool accept(const string & ip, const string & mac, const uint32_t port){

			this->_log->print("ACCEPT: ip = %s, mac = %s, port = %d", log_t::flag_t::INFO, ip.c_str(), mac.c_str(), port);

			return true;

		}

		void active(const uint64_t bid, const proxy_socks5_t::mode_t mode){

			(void) bid;

			this->_log->print("%s client", log_t::flag_t::INFO, (mode == proxy_socks5_t::mode_t::CONNECT ? "Connect" : "Disconnect"));

		}

	public:

		Proxy(const fmk_t * fmk, const log_t * log) : _fmk(fmk), _log(log) {}

};

int32_t main(int32_t argc, char * argv[]){

	fmk_t fmk;

	log_t log(&fmk);

	proxy_socks5_t proxy(&fmk, &log);

	Proxy executor(&fmk, &log);

	log.name("Proxy Socks5 Server");

	log.format("%H:%M:%S %d.%m.%Y");

	node_t::ssl_t ssl;

	ssl.verify = true;

	ssl.ca     = "./certs/ca.pem";

	proxy.ssl(ssl);

	proxy.sonet(awh::scheme_t::sonet_t::TCP);

	proxy.cluster(awh::scheme_t::mode_t::ENABLED);

	// proxy.init("anyks");

	// proxy.init(2222);

	proxy.init(2222, "127.0.0.1");

	proxy.callback  ("active", std::bind(&Proxy::active, &executor, _1, _2));

	proxy.callback  ("accept", std::bind(&Proxy::accept, &executor, _1, _2, _3));

	// proxy.callback  ("checkPassword", std::bind(&Proxy::auth, &executor, _1, _2, _3));

	proxy.start();

	return EXIT_SUCCESS;

}

```

### Example Timer

```c++

#include 

#include 

using namespace std;

using namespace awh;

class Executor {

	private:

		chrono::time_point  _ts;

		chrono::time_point  _is;

	private:

		uint16_t _count;

	private:

		log_t * _log;

	public:

		void interval(const uint16_t tid, awh::timer_t * timer){

			auto shift = chrono::system_clock::now();

			this->_log->print("Interval: %u seconds", log_t::flag_t::INFO, chrono::duration_cast  (shift - this->_is).count());

			this->_is = shift;

			if((this->_count++) >= 10){

				timer->clear(tid);

				timer->stop();

			}

		}

		void timeout(const uint16_t id){

			this->_log->print("Timeout: %u seconds", log_t::flag_t::INFO, chrono::duration_cast  (chrono::system_clock::now() - this->_ts).count());

		}

		void launched(const awh::core_t::status_t status, awh::timer_t * timer){

			switch(static_cast  (status)){

				case static_cast  (awh::core_t::status_t::START): {

					this->_ts = chrono::system_clock::now();

					this->_is = this->_ts;

					this->_log->print("%s", log_t::flag_t::INFO, "Start timer");

					uint16_t tid = timer->timeout(10000);

					timer->set  (tid, std::bind(&Executor::timeout, this, tid));

					tid = timer->interval(5000);

					timer->set  (tid, std::bind(&Executor::interval, this, tid, timer));

				} break;

				case static_cast  (awh::core_t::status_t::STOP):

					this->_log->print("%s", log_t::flag_t::INFO, "Stop timer");

				break;

			}

		}

	public:

		Executor(log_t * log) : _ts(chrono::system_clock::now()), _is(chrono::system_clock::now()), _count(0), _log(log) {}

};

int32_t main(int32_t argc, char * argv[]){

	fmk_t fmk;

	log_t log(&fmk);

	Executor executor(&log);

	awh::timer_t timer(&fmk, &log);

	log.name("Timer");

	log.format("%H:%M:%S %d.%m.%Y");

	timer.callback  ("status", std::bind(&Executor::launched, &executor, _1, &timer));

	timer.start();

	return EXIT_SUCCESS;

}

```

### Example DNS-resolver

```c++

#include 

#include 

using namespace std;

using namespace awh;

int32_t main(int32_t argc, char * argv[]){

	fmk_t fmk;

	log_t log(&fmk);

	dns_t dns(&fmk, &log);

	core_t core(&fmk, &log);

	log.name("DNS");

	log.format("%H:%M:%S %d.%m.%Y");

	dns.prefix("AWH");

	dns.servers({"77.88.8.88", "77.88.8.2"});

	log.print("IP1: %s", log_t::flag_t::INFO, dns.resolve("localhost").c_str());

	log.print("IP2: %s", log_t::flag_t::INFO, dns.resolve("yandex.ru").c_str());

	log.print("IP3: %s", log_t::flag_t::INFO, dns.resolve("google.com").c_str());

	log.print("IP4: %s", log_t::flag_t::INFO, dns.resolve("stalin.info").c_str());

	const auto & yandex = dns.search("77.88.55.60");

	if(!yandex.empty()){

		for(auto & domain : yandex)

			log.print("Domain: %s => %s", log_t::flag_t::INFO, domain.c_str(), "77.88.55.60");

	}

	

	log.print("Encode domain \"ремпрофи.рф\" == \"%s\"", log_t::flag_t::INFO, dns.encode("ремпрофи.рф").c_str());

	log.print("Decode domain \"xn--e1agliedd7a.xn--p1ai\" == \"%s\"", log_t::flag_t::INFO, dns.decode("xn--e1agliedd7a.xn--p1ai").c_str());

	return EXIT_SUCCESS;

}

```

### Example NTP-client

```c++

#include 

#include 

using namespace std;

using namespace awh;

int32_t main(int32_t argc, char * argv[]){

	fmk_t fmk;

	log_t log(&fmk);

	ntp_t ntp(&fmk, &log);

	core_t core(&fmk, &log);

	log.name("NTP");

	log.format("%H:%M:%S %d.%m.%Y");

	ntp.ns({"77.88.8.88", "77.88.8.2"});

	ntp.servers({"0.ru.pool.ntp.org", "1.ru.pool.ntp.org", "2.ru.pool.ntp.org", "3.ru.pool.ntp.org"});

	log.print("Time: %s", log_t::flag_t::INFO, fmk.time2str((ntp.request() / 1000), "%H:%M:%S %d.%m.%Y").c_str());

	return EXIT_SUCCESS;

}

```

### Example ICMP-client PINGER

```c++

#include 

#include 

using namespace std;

using namespace awh;

int32_t main(int32_t argc, char * argv[]){

	fmk_t fmk;

	log_t log(&fmk);

	core_t core(&fmk, &log);

	ping_t ping(&fmk, &log);

	log.name("PING");

	log.format("%H:%M:%S %d.%m.%Y");

	const double result = ping.ping("api.telegram.org", 10);

	log.print("PING result=%f", log_t::flag_t::INFO, result);

	return EXIT_SUCCESS;

}

```

### Example TCP-client

```c++

#include 

using namespace std;

using namespace awh;

class Client {

	private:

		const fmk_t * _fmk;

		const log_t * _log;

	public:

		void active(const client::sample_t::mode_t mode, client::sample_t * sample){

			this->_log->print("%s client", log_t::flag_t::INFO, (mode == client::sample_t::mode_t::CONNECT ? "Connect" : "Disconnect"));

			if(mode == client::sample_t::mode_t::CONNECT){

				const string message = "Hello World!!!";

				sample->send(message.data(), message.size());

			}

		}

		void message(const vector  & buffer, client::sample_t * sample){

			const string message(buffer.begin(), buffer.end());

			

			this->_log->print("%s", log_t::flag_t::INFO, message.c_str());

			

			sample->stop();

		}

	public:

		Client(const fmk_t * fmk, const log_t * log) : _fmk(fmk), _log(log) {}

};

int32_t main(int32_t argc, char * argv[]){

	fmk_t fmk;

	log_t log(&fmk);

	dns_t dns(&fmk, &log);

	client::core_t core(&dns, &fmk, &log);

	client::sample_t sample(&core, &fmk, &log);

	Client executor(&fmk, &log);

	log.name("TCP Client");

	log.format("%H:%M:%S %d.%m.%Y");

	// sample.mode({client::sample_t::flag_t::NOT_INFO});

	core.sonet(awh::scheme_t::sonet_t::TCP);

	sample.init(2222, "127.0.0.1");

	sample.callback  &)> ("message", std::bind(&Client::message, &executor, _1, &sample));

	sample.callback  ("active", std::bind(&Client::active, &executor, _1, &sample));

	sample.start();

	return EXIT_SUCCESS;

}

```

### Example TCP-server

```c++

#include 

using namespace std;

using namespace awh;

class Server {

	private:

		const fmk_t * _fmk;

		const log_t * _log;

	public:

		bool accept(const string & ip, const string & mac, const uint32_t port){

			this->_log->print("ACCEPT: ip = %s, mac = %s, port = %d", log_t::flag_t::INFO, ip.c_str(), mac.c_str(), port);

			return true;

		}

		void active(const uint64_t bid, const server::sample_t::mode_t mode){

			(void) bid;

			this->_log->print("%s client", log_t::flag_t::INFO, (mode == server::sample_t::mode_t::CONNECT ? "Connect" : "Disconnect"));

		}

		void message(const uint64_t bid, const vector  & buffer, server::sample_t * sample){

			(void) bid;

			this->_log->print("%s", log_t::flag_t::INFO, string(buffer.begin(), buffer.end()).c_str());

			sample->send(bid, buffer.data(), buffer.size());

		}

	public:

		Server(const fmk_t * fmk, const log_t * log) : _fmk(fmk), _log(log) {}

};

int32_t main(int32_t argc, char * argv[]){

	fmk_t fmk;

	log_t log(&fmk);

	dns_t dns(&fmk, &log);

	server::core_t core(&dns, &fmk, &log);

	server::sample_t sample(&core, &fmk, &log);

	Server executor(&fmk, &log);

	log.name("SAMPLE Server");

	log.format("%H:%M:%S %d.%m.%Y");

	core.sonet(awh::scheme_t::sonet_t::TCP);

	core.cluster(awh::scheme_t::mode_t::ENABLED);

	sample.init(2222, "127.0.0.1");

	sample.callback  ("active", std::bind(&Server::active, &executor, _1, _2));

	sample.callback  ("accept", std::bind(&Server::accept, &executor, _1, _2, _3));

	sample.callback  &)> ("message", std::bind(&Server::message, &executor, _1, _2, &sample));

	sample.start();

	return EXIT_SUCCESS;

}

```

### Example TLS-client

```c++

#include 

using namespace std;

using namespace awh;

class Client {

	private:

		const fmk_t * _fmk;

		const log_t * _log;

	public:

		void active(const client::sample_t::mode_t mode, client::sample_t * sample){

			this->_log->print("%s client", log_t::flag_t::INFO, (mode == client::sample_t::mode_t::CONNECT ? "Connect" : "Disconnect"));

			if(mode == client::sample_t::mode_t::CONNECT){

				const string message = "Hello World!!!";

				sample->send(message.data(), message.size());

			}

		}

		void message(const vector  & buffer, client::sample_t * sample){

			const string message(buffer.begin(), buffer.end());

			

			this->_log->print("%s", log_t::flag_t::INFO, message.c_str());

			

			sample->stop();

		}

	public:

		Client(const fmk_t * fmk, const log_t * log) : _fmk(fmk), _log(log) {}

};

int32_t main(int32_t argc, char * argv[]){

	fmk_t fmk;

	log_t log(&fmk);

	dns_t dns(&fmk, &log);

	client::core_t core(&dns, &fmk, &log);

	client::sample_t sample(&core, &fmk, &log);

	Client executor(&fmk, &log);

	log.name("TLS Client");

	log.format("%H:%M:%S %d.%m.%Y");

	// sample.mode({client::sample_t::flag_t::NOT_INFO});

	core.sonet(awh::scheme_t::sonet_t::TLS);

	node_t::ssl_t ssl;

	ssl.verify = false;

	ssl.key    = "./certs/certificates/client-key.pem";

	ssl.cert   = "./certs/certificates/client-cert.pem";

	core.ssl(ssl);

	sample.init(2222, "127.0.0.1");

	sample.callback  &)> ("message", std::bind(&Client::message, &executor, _1, &sample));

	sample.callback  ("active", std::bind(&Client::active, &executor, _1, &sample));

	sample.start();

	return EXIT_SUCCESS;

}

```

### Example TLS-server

```c++

#include 

using namespace std;

using namespace awh;

class Server {

	private:

		const fmk_t * _fmk;

		const log_t * _log;

	public:

		bool accept(const string & ip, const string & mac, const uint32_t port){

			this->_log->print("ACCEPT: ip = %s, mac = %s, port = %d", log_t::flag_t::INFO, ip.c_str(), mac.c_str(), port);

			return true;

		}

		void active(const uint64_t bid, const server::sample_t::mode_t mode){

			(void) bid;

			this->_log->print("%s client", log_t::flag_t::INFO, (mode == server::sample_t::mode_t::CONNECT ? "Connect" : "Disconnect"));

		}

		void message(const uint64_t bid, const vector  & buffer, server::sample_t * sample){

			(void) bid;

			this->_log->print("%s", log_t::flag_t::INFO, string(buffer.begin(), buffer.end()).c_str());

			sample->send(bid, buffer.data(), buffer.size());

		}

	public:

		Server(const fmk_t * fmk, const log_t * log) : _fmk(fmk), _log(log) {}

};

int32_t main(int32_t argc, char * argv[]){

	fmk_t fmk;

	log_t log(&fmk);

	dns_t dns(&fmk, &log);

	server::core_t core(&dns, &fmk, &log);

	server::sample_t sample(&core, &fmk, &log);

	Server executor(&fmk, &log);

	log.name("TLS Server");

	log.format("%H:%M:%S %d.%m.%Y");

	core.sonet(awh::scheme_t::sonet_t::TLS);

	core.cluster(awh::scheme_t::mode_t::ENABLED);

	node_t::ssl_t ssl;

	ssl.verify = false;

	ssl.key    = "./certs/certificates/server-key.pem";

	ssl.cert   = "./certs/certificates/server-cert.pem";

	core.ssl(ssl);

	sample.init(2222, "127.0.0.1");

	sample.callback  ("active", std::bind(&Server::active, &executor, _1, _2));

	sample.callback  ("accept", std::bind(&Server::accept, &executor, _1, _2, _3));

	sample.callback  &)> ("message", std::bind(&Server::message, &executor, _1, _2, &sample));

	sample.start();

	return EXIT_SUCCESS;

}

```

### Example UDP-client

```c++

#include 

using namespace std;

using namespace awh;

class Client {

	private:

		const fmk_t * _fmk;

		const log_t * _log;

	public:

		void active(const client::sample_t::mode_t mode, client::sample_t * sample){

			this->_log->print("%s client", log_t::flag_t::INFO, (mode == client::sample_t::mode_t::CONNECT ? "Connect" : "Disconnect"));

			if(mode == client::sample_t::mode_t::CONNECT){

				const string message = "Hello World!!!";

				sample->send(message.data(), message.size());

			}

		}

		void message(const vector  & buffer, client::sample_t * sample){

			const string message(buffer.begin(), buffer.end());

			

			this->_log->print("%s", log_t::flag_t::INFO, message.c_str());

			

			sample->stop();

		}

	public:

		Client(const fmk_t * fmk, const log_t * log) : _fmk(fmk), _log(log) {}

};

int32_t main(int32_t argc, char * argv[]){

	fmk_t fmk;

	log_t log(&fmk);

	dns_t dns(&fmk, &log);

	client::core_t core(&dns, &fmk, &log);

	client::sample_t sample(&core, &fmk, &log);

	Client executor(&fmk, &log);

	log.name("UDP Client");

	log.format("%H:%M:%S %d.%m.%Y");

	// sample.mode({client::sample_t::flag_t::NOT_INFO});

	core.sonet(awh::scheme_t::sonet_t::UDP);

	sample.init(2222, "127.0.0.1");

	sample.callback  &)> ("message", std::bind(&Client::message, &executor, _1, &sample));

	sample.callback  ("active", std::bind(&Client::active, &executor, _1, &sample));

	sample.start();

	return EXIT_SUCCESS;

}

```

### Example UDP-server

```c++

#include 

using namespace std;

using namespace awh;

class Server {

	private:

		const fmk_t * _fmk;

		const log_t * _log;

	public:

		bool accept(const string & ip, const string & mac, const uint32_t port){

			this->_log->print("ACCEPT: ip = %s, mac = %s, port = %d", log_t::flag_t::INFO, ip.c_str(), mac.c_str(), port);

			return true;

		}

		void active(const uint64_t bid, const server::sample_t::mode_t mode){

			(void) bid;

			this->_log->print("%s client", log_t::flag_t::INFO, (mode == server::sample_t::mode_t::CONNECT ? "Connect" : "Disconnect"));

		}

		void message(const uint64_t bid, const vector  & buffer, server::sample_t * sample){

			(void) bid;

			this->_log->print("%s", log_t::flag_t::INFO, string(buffer.begin(), buffer.end()).c_str());

			sample->send(bid, buffer.data(), buffer.size());

		}

	public:

		Server(const fmk_t * fmk, const log_t * log) : _fmk(fmk), _log(log) {}

};

int32_t main(int32_t argc, char * argv[]){

	fmk_t fmk;

	log_t log(&fmk);

	dns_t dns(&fmk, &log);

	server::core_t core(&dns, &fmk, &log);

	server::sample_t sample(&core, &fmk, &log);

	Server executor(&fmk, &log);

	log.name("UDP Server");

	log.format("%H:%M:%S %d.%m.%Y");

	core.sonet(awh::scheme_t::sonet_t::UDP);

	sample.init(2222, "127.0.0.1");

	sample.callback  ("active", std::bind(&Server::active, &executor, _1, _2));

	sample.callback  ("accept", std::bind(&Server::accept, &executor, _1, _2, _3));

	sample.callback  &)> ("message", std::bind(&Server::message, &executor, _1, _2, &sample));

	sample.start();

	return EXIT_SUCCESS;

}

```

### Example SCTP-client

```c++

#include 

using namespace std;

using namespace awh;

class Client {

	private:

		const fmk_t * _fmk;

		const log_t * _log;

	public:

		void active(const client::sample_t::mode_t mode, client::sample_t * sample){

			this->_log->print("%s client", log_t::flag_t::INFO, (mode == client::sample_t::mode_t::CONNECT ? "Connect" : "Disconnect"));

			if(mode == client::sample_t::mode_t::CONNECT){

				const string message = "Hello World!!!";

				sample->send(message.data(), message.size());

			}

		}

		void message(const vector  & buffer, client::sample_t * sample){

			const string message(buffer.begin(), buffer.end());

			

			this->_log->print("%s", log_t::flag_t::INFO, message.c_str());

			

			sample->stop();

		}

	public:

		Client(const fmk_t * fmk, const log_t * log) : _fmk(fmk), _log(log) {}

};

int32_t main(int32_t argc, char * argv[]){

	fmk_t fmk;

	log_t log(&fmk);

	dns_t dns(&fmk, &log);

	client::core_t core(&dns, &fmk, &log);

	client::sample_t sample(&core, &fmk, &log);

	Client executor(&fmk, &log);

	log.name("SCTP Client");

	log.format("%H:%M:%S %d.%m.%Y");

	// sample.mode({client::sample_t::flag_t::NOT_INFO});

	core.sonet(awh::scheme_t::sonet_t::SCTP);

	

	node_t::ssl_t ssl;

	ssl.verify = false;

	ssl.key    = "./certs/certificates/client-key.pem";

	ssl.cert   = "./certs/certificates/client-cert.pem";

	core.ssl(ssl);

	sample.init(2222, "127.0.0.1");

	sample.callback  &)> ("message", std::bind(&Client::message, &executor, _1, &sample));

	sample.callback  ("active", std::bind(&Client::active, &executor, _1, &sample));

	sample.start();

	return EXIT_SUCCESS;

}

```

### Example SCTP-server

```c++

#include 

using namespace std;

using namespace awh;

class Server {

	private:

		const fmk_t * _fmk;

		const log_t * _log;

	public:

		bool accept(const string & ip, const string & mac, const uint32_t port){

			this->_log->print("ACCEPT: ip = %s, mac = %s, port = %d", log_t::flag_t::INFO, ip.c_str(), mac.c_str(), port);

			return true;

		}

		void active(const uint64_t bid, const server::sample_t::mode_t mode){

			(void) bid;

			this->_log->print("%s client", log_t::flag_t::INFO, (mode == server::sample_t::mode_t::CONNECT ? "Connect" : "Disconnect"));

		}

		void message(const uint64_t bid, const vector  & buffer, server::sample_t * sample){

			(void) bid;

			this->_log->print("%s", log_t::flag_t::INFO, string(buffer.begin(), buffer.end()).c_str());

			sample->send(bid, buffer.data(), buffer.size());

		}

	public:

		Server(const fmk_t * fmk, const log_t * log) : _fmk(fmk), _log(log) {}

};

int32_t main(int32_t argc, char * argv[]){

	fmk_t fmk;

	log_t log(&fmk);

	dns_t dns(&fmk, &log);

	server::core_t core(&dns, &fmk, &log);

	server::sample_t sample(&core, &fmk, &log);

	Server executor(&fmk, &log);

	log.name("SCTP Server");

	log.format("%H:%M:%S %d.%m.%Y");

	core.sonet(awh::scheme_t::sonet_t::SCTP);

	core.cluster(awh::scheme_t::mode_t::ENABLED);

	node_t::ssl_t ssl;

	ssl.verify = false;

	ssl.key    = "./certs/certificates/server-key.pem";

	ssl.cert   = "./certs/certificates/server-cert.pem";

	core.ssl(ssl);

	sample.init(2222, "127.0.0.1");

	sample.callback  ("active", std::bind(&Server::active, &executor, _1, _2));

	sample.callback  ("accept", std::bind(&Server::accept, &executor, _1, _2, _3));

	sample.callback  &)> ("message", std::bind(&Server::message, &executor, _1, _2, &sample));

	sample.start();

	return EXIT_SUCCESS;

}

```

### Example DTLS-client

```c++

#include 

using namespace std;

using namespace awh;

class Client {

	private:

		const fmk_t * _fmk;

		const log_t * _log;

	public:

		void active(const client::sample_t::mode_t mode, client::sample_t * sample){

			this->_log->print("%s client", log_t::flag_t::INFO, (mode == client::sample_t::mode_t::CONNECT ? "Connect" : "Disconnect"));

			if(mode == client::sample_t::mode_t::CONNECT){

				const string message = "Hello World!!!";

				sample->send(message.data(), message.size());

			}

		}

		void message(const vector  & buffer, client::sample_t * sample){

			const string message(buffer.begin(), buffer.end());

			

			this->_log->print("%s", log_t::flag_t::INFO, message.c_str());

			

			sample->stop();

		}

	public:

		Client(const fmk_t * fmk, const log_t * log) : _fmk(fmk), _log(log) {}

};

int32_t main(int32_t argc, char * argv[]){

	fmk_t fmk;

	log_t log(&fmk);

	dns_t dns(&fmk, &log);

	client::core_t core(&dns, &fmk, &log);

	client::sample_t sample(&core, &fmk, &log);

	Client executor(&fmk, &log);

	log.name("DTLS Client");

	log.format("%H:%M:%S %d.%m.%Y");

	// sample.mode({client::sample_t::flag_t::NOT_INFO});

	core.sonet(awh::scheme_t::sonet_t::DTLS);

	node_t::ssl_t ssl;

	ssl.verify = false;

	ssl.key    = "./certs/certificates/client-key.pem";

	ssl.cert   = "./certs/certificates/client-cert.pem";

	core.ssl(ssl);

	sample.init(2222, "127.0.0.1");

	sample.callback  &)> ("message", std::bind(&Client::message, &executor, _1, &sample));

	sample.callback  ("active", std::bind(&Client::active, &executor, _1, &sample));

	sample.start();

	return EXIT_SUCCESS;

}

```

### Example DTLS-server

```c++

#include 

using namespace std;

using namespace awh;

class Server {

	private:

		const fmk_t * _fmk;

		const log_t * _log;

	public:

		bool accept(const string & ip, const string & mac, const uint32_t port){

			this->_log->print("ACCEPT: ip = %s, mac = %s, port = %d", log_t::flag_t::INFO, ip.c_str(), mac.c_str(), port);

			return true;

		}

		void active(const uint64_t bid, const server::sample_t::mode_t mode){

			(void) bid;

			this->_log->print("%s client", log_t::flag_t::INFO, (mode == server::sample_t::mode_t::CONNECT ? "Connect" : "Disconnect"));

		}

		void message(const uint64_t bid, const vector  & buffer, server::sample_t * sample){

			(void) bid;

			this->_log->print("%s", log_t::flag_t::INFO, string(buffer.begin(), buffer.end()).c_str());

			sample->send(bid, buffer.data(), buffer.size());

		}

	public:

		Server(const fmk_t * fmk, const log_t * log) : _fmk(fmk), _log(log) {}

};

int32_t main(int32_t argc, char * argv[]){

	fmk_t fmk;

	log_t log(&fmk);

	dns_t dns(&fmk, &log);

	server::core_t core(&dns, &fmk, &log);

	server::sample_t sample(&core, &fmk, &log);

	Server executor(&fmk, &log);

	log.name("DTLS Server");

	log.format("%H:%M:%S %d.%m.%Y");

	core.sonet(awh::scheme_t::sonet_t::DTLS);

	node_t::ssl_t ssl;

	ssl.verify = false;

	ssl.key    = "./certs/certificates/server-key.pem";

	ssl.cert   = "./certs/certificates/server-cert.pem";

	core.ssl(ssl);

	sample.init(2222, "127.0.0.1");

	sample.callback  ("active", std::bind(&Server::active, &executor, _1, _2));

	sample.callback  ("accept", std::bind(&Server::accept, &executor, _1, _2, _3));

	sample.callback  &)> ("message", std::bind(&Server::message, &executor, _1, _2, &sample));

	sample.start();

	return EXIT_SUCCESS;

}

```

### Example UnixSocket TCP-client

```c++

#include 

using namespace std;

using namespace awh;

class Client {

	private:

		const fmk_t * _fmk;

		const log_t * _log;

	public:

		void active(const client::sample_t::mode_t mode, client::sample_t * sample){

			this->_log->print("%s client", log_t::flag_t::INFO, (mode == client::sample_t::mode_t::CONNECT ? "Connect" : "Disconnect"));

			if(mode == client::sample_t::mode_t::CONNECT){

				const string message = "Hello World!!!";

				sample->send(message.data(), message.size());

			}

		}

		void message(const vector  & buffer, client::sample_t * sample){

			const string message(buffer.begin(), buffer.end());

			

			this->_log->print("%s", log_t::flag_t::INFO, message.c_str());

			

			sample->stop();

		}

	public:

		Client(const fmk_t * fmk, const log_t * log) : _fmk(fmk), _log(log) {}

};

int32_t main(int32_t argc, char * argv[]){

	fmk_t fmk;

	log_t log(&fmk);

	dns_t dns(&fmk, &log);

	client::core_t core(&dns, &fmk, &log);

	client::sample_t sample(&core, &fmk, &log);

	Client executor(&fmk, &log);

	log.name("UnixSocket Client");

	log.format("%H:%M:%S %d.%m.%Y");

	// sample.mode({client::sample_t::flag_t::NOT_INFO});

	

	core.sonet(awh::scheme_t::sonet_t::TCP);

	core.family(awh::scheme_t::family_t::NIX);

	sample.init("anyks");

	sample.callback  &)> ("message", std::bind(&Client::message, &executor, _1, &sample));

	sample.callback  ("active", std::bind(&Client::active, &executor, _1, &sample));

	sample.start();

	return EXIT_SUCCESS;

}

```

### Example UnixSocket TCP-server

```c++

#include 

using namespace std;

using namespace awh;

class Server {

	private:

		const fmk_t * _fmk;

		const log_t * _log;

	public:

		bool accept(const string & ip, const string & mac, const uint32_t port){

			this->_log->print("ACCEPT: ip = %s, mac = %s, port = %d", log_t::flag_t::INFO, ip.c_str(), mac.c_str(), port);

			return true;

		}

		void active(const uint64_t bid, const server::sample_t::mode_t mode){

			(void) bid;

			this->_log->print("%s client", log_t::flag_t::INFO, (mode == server::sample_t::mode_t::CONNECT ? "Connect" : "Disconnect"));

		}

		void message(const uint64_t bid, const vector  & buffer, server::sample_t * sample){

			(void) bid;

			this->_log->print("%s", log_t::flag_t::INFO, string(buffer.begin(), buffer.end()).c_str());

			sample->send(bid, buffer.data(), buffer.size());

		}

	public:

		Server(const fmk_t * fmk, const log_t * log) : _fmk(fmk), _log(log) {}

};

int32_t main(int32_t argc, char * argv[]){

	fmk_t fmk;

	log_t log(&fmk);

	dns_t dns(&fmk, &log);

	server::core_t core(&dns, &fmk, &log);

	server::sample_t sample(&core, &fmk, &log);

	Server executor(&fmk, &log);

	log.name("UnixSocket Server");

	log.format("%H:%M:%S %d.%m.%Y");

	core.sonet(awh::scheme_t::sonet_t::TCP);

	core.family(awh::scheme_t::family_t::NIX);

	core.cluster(awh::scheme_t::mode_t::ENABLED);

	sample.init("anyks");

	sample.callback  ("active", std::bind(&Server::active, &executor, _1, _2));

	sample.callback  ("accept", std::bind(&Server::accept, &executor, _1, _2, _3));

	sample.callback  &)> ("message", std::bind(&Server::message, &executor, _1, _2, &sample));

	sample.start();

	return EXIT_SUCCESS;

}

```

### Example UnixSocket UDP-client

```c++

#include 

using namespace std;

using namespace awh;

class Client {

	private:

		const fmk_t * _fmk;

		const log_t * _log;

	public:

		void active(const client::sample_t::mode_t mode, client::sample_t * sample){

			this->_log->print("%s client", log_t::flag_t::INFO, (mode == client::sample_t::mode_t::CONNECT ? "Connect" : "Disconnect"));

			if(mode == client::sample_t::mode_t::CONNECT){

				const string message = "Hello World!!!";

				sample->send(message.data(), message.size());

			}

		}

		void message(const vector  & buffer, client::sample_t * sample){

			const string message(buffer.begin(), buffer.end());

			

			this->_log->print("%s", log_t::flag_t::INFO, message.c_str());

			

			sample->stop();

		}

	public:

		Client(const fmk_t * fmk, const log_t * log) : _fmk(fmk), _log(log) {}

};

int32_t main(int32_t argc, char * argv[]){

	fmk_t fmk;

	log_t log(&fmk);

	dns_t dns(&fmk, &log);

	client::core_t core(&dns, &fmk, &log);

	client::sample_t sample(&core, &fmk, &log);

	Client executor(&fmk, &log);

	log.name("UDP UnixSocket Client");

	log.format("%H:%M:%S %d.%m.%Y");

	// sample.mode({client::sample_t::flag_t::NOT_INFO});

	

	core.sonet(awh::scheme_t::sonet_t::UDP);

	core.family(awh::scheme_t::family_t::NIX);

	sample.init("anyks");

	sample.callback  &)> ("message", std::bind(&Client::message, &executor, _1, &sample));

	sample.callback  ("active", std::bind(&Client::active, &executor, _1, &sample));

	sample.start();

	return EXIT_SUCCESS;

}

```

### Example UnixSocket UDP-server

```c++

#include 

using namespace std;

using namespace awh;

class Server {

	private:

		const fmk_t * _fmk;

		const log_t * _log;

	public:

		bool accept(const string & ip, const string & mac, const uint32_t port){

			this->_log->print("ACCEPT: ip = %s, mac = %s, port = %d", log_t::flag_t::INFO, ip.c_str(), mac.c_str(), port);

			return true;

		}

		void active(const uint64_t bid, const server::sample_t::mode_t mode){

			(void) bid;

			this->_log->print("%s client", log_t::flag_t::INFO, (mode == server::sample_t::mode_t::CONNECT ? "Connect" : "Disconnect"));

		}

		void message(const uint64_t bid, const vector  & buffer, server::sample_t * sample){

			(void) bid;

			this->_log->print("%s", log_t::flag_t::INFO, string(buffer.begin(), buffer.end()).c_str());

			sample->send(bid, buffer.data(), buffer.size());

		}

	public:

		Server(const fmk_t * fmk, const log_t * log) : _fmk(fmk), _log(log) {}

};

int32_t main(int32_t argc, char * argv[]){

	fmk_t fmk;

	log_t log(&fmk);

	dns_t dns(&fmk, &log);

	server::core_t core(&dns, &fmk, &log);

	server::sample_t sample(&core, &fmk, &log);

	Server executor(&fmk, &log);

	log.name("UDP UnixSocket Server");

	log.format("%H:%M:%S %d.%m.%Y");

	core.sonet(awh::scheme_t::sonet_t::UDP);

	core.family(awh::scheme_t::family_t::NIX);

	sample.init("anyks");

	sample.callback  ("active", std::bind(&Server::active, &executor, _1, _2));

	sample.callback  ("accept", std::bind(&Server::accept, &executor, _1, _2, _3));

	sample.callback  &)> ("message", std::bind(&Server::message, &executor, _1, _2, &sample));

	sample.start();

	return EXIT_SUCCESS;

}

```

### Example Cluster

```c++

#include 

using namespace std;

using namespace awh;

class Executor {

	private:

		log_t * _log;

	public:

		void events(const cluster_t::family_t worker, const pid_t pid, const cluster_t::event_t event, cluster::core_t * core){

			(void) pid;

			if(event == cluster_t::event_t::START){

				switch(static_cast  (worker)){

					case static_cast  (cluster_t::family_t::MASTER): {

						const char * message = "Hi!";

						core->broadcast(message, strlen(message));

					} break;

					case static_cast  (cluster_t::family_t::CHILDREN): {

						const char * message = "Hello";

						core->send(message, strlen(message));

					} break;

				}

			}

		}

		void message(const cluster_t::family_t worker, const pid_t pid, const char * buffer, const size_t size){

			switch(static_cast  (worker)){

				case static_cast  (cluster_t::family_t::MASTER):

					this->_log->print("Message from children [%u]: %s", log_t::flag_t::INFO, pid, string(buffer, size).c_str());

				break;

				case static_cast  (cluster_t::family_t::CHILDREN):

					this->_log->print("Message from master: %s [%u]", log_t::flag_t::INFO, string(buffer, size).c_str(), ::getpid());

				break;

			}

		}

		void launched(const awh::core_t::status_t status){

			switch(static_cast  (status)){

				case static_cast  (awh::core_t::status_t::START):

					this->_log->print("%s", log_t::flag_t::INFO, "Start cluster");

				break;

				case static_cast  (awh::core_t::status_t::STOP):

					this->_log->print("%s", log_t::flag_t::INFO, "Stop cluster");

				break;

			}

		}

	public:

		Executor(log_t * log) : _log(log) {}

};

int32_t main(int32_t argc, char * argv[]){

	fmk_t fmk;

	log_t log(&fmk);

	Executor executor(&log);

	cluster::core_t core(&fmk, &log);

	log.name("Cluster");

	log.format("%H:%M:%S %d.%m.%Y");

	core.size();

	core.autoRestart(true);

	core.callback  ("status", std::bind(&Executor::launched, &executor, _1));

	core.callback  ("events", std::bind(&Executor::events, &executor, _1, _2, _3, &core));

	core.callback  ("message", std::bind(&Executor::message, &executor, _1, _2, _3, _4));

	core.start();

	return EXIT_SUCCESS;

}

```

### Example IP-address

```c++

#include 

using namespace std;

using namespace awh;

int32_t main(int32_t argc, char * argv[]){

	net_t net{};

	net = "[2001:0db8:11a3:09d7:1f34:8a2e:07a0:765d]";

	cout << " [2001:0db8:11a3:09d7:1f34:8a2e:07a0:765d] || " << net << " === " << net.get(net_t::format_t::LONG_IPV4) << " === " << net.get(net_t::format_t::MIDDLE_IPV4) << " === " << net.get(net_t::format_t::SHORT_IPV4) << endl;

	net = "2001:0db8:0000:0000:0000:0000:ae21:ad12";

	cout << " 2001:0db8:0000:0000:0000:0000:ae21:ad12 || " << net << endl;

	net = "2001:db8::ae21:ad12";

	cout << " 2001:db8::ae21:ad12 || " << net.get(net_t::format_t::LONG) << " and " << net.get(net_t::format_t::MIDDLE) << endl;

	net = "0000:0000:0000:0000:0000:0000:ae21:ad12";

	cout << " 0000:0000:0000:0000:0000:0000:ae21:ad12 || " << net.get(net_t::format_t::SHORT) << endl;

	net = "::ae21:ad12";

	cout << " ::ae21:ad12 || " << net.get(net_t::format_t::MIDDLE) << endl;

	net = "2001:0db8:11a3:09d7:1f34::";

	cout << " 2001:0db8:11a3:09d7:1f34:: || " << net.get(net_t::format_t::LONG) << endl;

	net = "::ffff:192.0.2.1";

	cout << boolalpha;

	cout << " ::ffff:192.0.2.1 || " << net << " ==== " << net.broadcastIPv6ToIPv4() << endl;

	net = "::1";

	cout << " ::1 || " << net.get(net_t::format_t::LONG) << endl;

	net = "[::]";

	cout << " [::] || " << net.get(net_t::format_t::LONG) << endl;

	net = "46.39.230.51";

	cout << " 46.39.230.51 || " << net.get(net_t::format_t::LONG) << " ==== " << net.broadcastIPv6ToIPv4() << endl;

	net = "192.16.0.1";

	cout << " 192.16.0.1 || " << net.get(net_t::format_t::LONG) << " === " << net.get(net_t::format_t::LONG_IPV6) << " === " << net.get(net_t::format_t::SHORT_IPV6) << " === " << net.get(net_t::format_t::MIDDLE_IPV6) << endl;

	net = "2001:0db8:11a3:09d7:1f34:8a2e:07a0:765d";

	cout << " Part of the address: 2001:0db8:11a3:09d7:1f34:8a2e:07a0:765d || " << net.v6()[0] << " and " << net.v6()[1] << endl;

	net = "46.39.230.51";

	cout << " Part of the address: 46.39.230.51 || " << net.v4() << endl;

	net = "2001:1234:abcd:5678:9877:3322:5541:aabb";

	net.impose(53, net_t::addr_t::NETWORK);

	cout << " Prefix set: 2001:1234:abcd:5678:9877:3322:5541:aabb/53 || " << net << endl;

	net = "2001:1234:abcd:5678:9877:3322:5541:aabb";

	net.impose("FFFF:FFFF:FFFF:F800::", net_t::addr_t::NETWORK);

	cout << " Mask set: 2001:1234:abcd:5678:9877:3322:5541:aabb/FFFF:FFFF:FFFF:F800:: || " << net << endl;

	net = "192.168.3.192";

	net.impose(9, net_t::addr_t::NETWORK);

	cout << " Prefix set: 192.168.3.192/9 || " << net << endl;

	net = "192.168.3.192";

	net.impose("255.128.0.0", net_t::addr_t::NETWORK);

	cout << " Mask set: 192.168.3.192/255.128.0.0 || " << net << endl;

	net = "192.168.3.192";

	net.impose("255.255.255.0", net_t::addr_t::NETWORK);

	cout << " Mask set: 192.168.3.192/255.255.255.0 || " << net << endl;

	net = "2001:1234:abcd:5678:9877:3322:5541:aabb";

	net.impose(53, net_t::addr_t::HOST);

	cout << " Get host from IP-address: 53/2001:1234:abcd:5678:9877:3322:5541:aabb || " << net << endl;

	net = "2001:1234:abcd:5678:9877:3322:5541:aabb";

	net.impose("FFFF:FFFF:FFFF:F800::", net_t::addr_t::HOST);

	cout << " Get host from IP-address: FFFF:FFFF:FFFF:F800::/2001:1234:abcd:5678:9877:3322:5541:aabb || " << net << endl;

	net = "192.168.3.192";

	net.impose(9, net_t::addr_t::HOST);

	cout << " Get host from IP-address: 9/192.168.3.192 || " << net << endl;

	net = "192.168.3.192";

	net.impose("255.128.0.0", net_t::addr_t::HOST);

	cout << " Get host from IP-address: 255.128.0.0/192.168.3.192 || " << net << endl;

	net = "192.168.3.192";

	net.impose(24, net_t::addr_t::HOST);

	cout << " Get host from IP-address: 24/192.168.3.192 || " << net << endl;

	net = "192.168.3.192";

	net.impose("255.255.255.0", net_t::addr_t::HOST);

	cout << " Get host from IP-address: 255.255.255.0/192.168.3.192 || " << net << endl;

	net = "192.168.3.192";

	cout << " Get address mask from network prefix = 9 || " << net.prefix2Mask(9) << endl;

	cout << " Get address prefix from network mask = 255.128.0.0 || " << static_cast  (net.mask2Prefix("255.128.0.0")) << endl;

	net = "2001:1234:abcd:5678:9877:3322:5541:aabb";

	cout << " Get address mask from network prefix = 53 || " << net.prefix2Mask(53) << endl;

	cout << " Get address prefix from network mask = FFFF:FFFF:FFFF:F800:: || " << static_cast  (net.mask2Prefix("FFFF:FFFF:FFFF:F800::")) << endl;

	net = "192.168.3.192";

	cout << boolalpha;

	cout << " Check the address compliance 192.168.3.192 by network 192.168.0.0 || " << net.mapping("192.168.0.0") << endl;

	

	net = "2001:1234:abcd:5678:9877:3322:5541:aabb";

	cout << boolalpha;

	cout << " Check the address compliance 2001:1234:abcd:5678:9877:3322:5541:aabb by network 2001:1234:abcd:5678:: || " << net.mapping("2001:1234:abcd:5678::") << endl;

	

	net = "192.168.3.192";

	cout << boolalpha;

	cout << " Check the address compliance 192.168.3.192 by network 192.128.0.0/9 || " << net.mapping("192.128.0.0", 9, net_t::addr_t::NETWORK) << endl;

	net = "2001:1234:abcd:5678:9877:3322:5541:aabb";

	cout << boolalpha;

	cout << " Check the address compliance 2001:1234:abcd:5678:9877:3322:5541:aabb by network 2001:1234:abcd:5000::/53 || " << net.mapping("2001:1234:abcd:5000::", 53, net_t::addr_t::NETWORK) << endl;

	net = "192.168.3.192";

	cout << boolalpha;

	cout << " Check the address compliance 192.168.3.192 by network 192.128.0.0/255.128.0.0 || " << net.mapping("192.128.0.0", "255.128.0.0", net_t::addr_t::NETWORK) << endl;

	net = "2001:1234:abcd:5678:9877:3322:5541:aabb";

	cout << boolalpha;

	cout << " Check the address compliance 2001:1234:abcd:5678:9877:3322:5541:aabb by network 2001:1234:abcd:5000::/FFFF:FFFF:FFFF:F800:: || " << net.mapping("2001:1234:abcd:5000::", "FFFF:FFFF:FFFF:F800::", net_t::addr_t::NETWORK) << endl;

	net = "192.168.3.192";

	cout << boolalpha;

	cout << " Check the address compliance 192.168.3.192 by host 9/0.40.3.192 || " << net.mapping("0.40.3.192", 9, net_t::addr_t::HOST) << endl;

	net = "2001:1234:abcd:5678:9877:3322:5541:aabb";

	cout << boolalpha;

	cout << " Check the address compliance 2001:1234:abcd:5678:9877:3322:5541:aabb by host 53/::678:9877:3322:5541:AABB || " << net.mapping("::678:9877:3322:5541:AABB", 53, net_t::addr_t::HOST) << endl;

	net = "192.168.3.192";

	cout << boolalpha;

	cout << " Check the address compliance 192.168.3.192 by host 255.128.0.0/0.40.3.192 || " << net.mapping("0.40.3.192", "255.128.0.0", net_t::addr_t::HOST) << endl;

	net = "2001:1234:abcd:5678:9877:3322:5541:aabb";

	cout << boolalpha;

	cout << " Check the address compliance 2001:1234:abcd:5678:9877:3322:5541:aabb by host FFFF:FFFF:FFFF:F800::/::678:9877:3322:5541:AABB || " << net.mapping("::678:9877:3322:5541:AABB", "FFFF:FFFF:FFFF:F800::", net_t::addr_t::HOST) << endl;

	net = "192.168.3.192";

	cout << boolalpha;

	cout << " Check whether the address 192.168.3.192 is in range [192.168.3.100 - 192.168.3.200] || " << net.range("192.168.3.100", "192.168.3.200", 24) << endl;

	net = "2001:1234:abcd:5678:9877:3322:5541:aabb";

	const auto & dump = net.data > ();

	for(auto & item : dump)

		cout << " IPv6 address chunk data || " << item << endl;

	net = "46.39.230.51";

	cout << boolalpha;

	cout << " Checking whether IP-address is global 46.39.230.51 || " << (net.mode() == net_t::mode_t::WAN) << endl;

	net = "192.168.31.12";

	cout << boolalpha;

	cout << " Checking whether IP-address is local 192.168.31.12 || " << (net.mode() == net_t::mode_t::LAN) << endl;

	net = "0.0.0.0";

	cout << boolalpha;

	cout << " Checking whether IP-address is system 0.0.0.0 || " << (net.mode() == net_t::mode_t::SYS) << endl;

	net = "[2a00:1450:4010:c0a::8b]";

	cout << boolalpha;

	cout << " Checking whether IP-address is global [2a00:1450:4010:c0a::8b] || " << (net.mode() == net_t::mode_t::WAN) << endl;

	net = "::1";

	cout << boolalpha;

	cout << " Checking whether IP-address is local [::1] || " << (net.mode() == net_t::mode_t::LAN) << endl;

	net = "::";

	cout << boolalpha;

	cout << " Checking whether IP-address is system [::] || " << (net.mode() == net_t::mode_t::SYS) << endl;

	string ip = "2001:0db8:0000:0000:0000:0000:ae21:ad12";

	cout << " Long record address || " << ip << endl;

	ip = net = ip;

	cout << " Short record address || " << ip << endl;

	net = "73:0b:04:0d:db:79";

	cout << " MAC: 73:0b:04:0d:db:79 || " << net << endl;

	net.arpa("70.255.255.5.in-addr.arpa");

	cout << " ARPA: 70.255.255.5.in-addr.arpa || " << net << endl;

	cout << " ARPA IPv4: " << net.arpa() << endl;

	net.arpa("b.a.9.8.7.6.5.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.8.b.d.0.1.0.0.2.ip6.arpa");

	cout << " ARPA: b.a.9.8.7.6.5.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.8.b.d.0.1.0.0.2.ip6.arpa || " << net << endl;

	cout << " ARPA IPv6: " << net.arpa() << endl;

	return EXIT_SUCCESS;

}

```