Compare commits

..

5 Commits

Author SHA1 Message Date
Alexander Zhirov 09446a63f7 fix отправки/чтения данных 2022-09-07 19:09:17 +03:00
Alexander Zhirov 4a5943ce9f Добавлены режимы запуска приложения 2022-09-07 16:43:05 +03:00
Alexander Zhirov 402c3f865f сервер + клиент 2022-09-07 15:43:34 +03:00
Alexander Zhirov 1bcbee1c36 Побайтовое чтение в функции chat() 2022-09-06 17:21:06 +03:00
Alexander Zhirov 550cf32e27 Реализован сервер, доработать chat() 2022-09-05 16:40:50 +03:00
15 changed files with 822 additions and 0 deletions

136
lesson_03/ap/ap.cpp Normal file
View File

@ -0,0 +1,136 @@
/*
* ap.cpp
*
* Created on: 05 сен. 2022 г.
* Author: alexander
*/
#include <ap.hpp>
namespace ap
{
ConfigOption::ConfigOption(const std::string &longParameter, const char shortParameter, const hasArg ha) :
_longParameter(nullptr), _shortParameter(shortParameter), _ha(ha)
{
_longParameter = new char[longParameter.length() + 1];
strcpy(_longParameter, longParameter.c_str());
}
const char* ConfigOption::getLongParameter() const
{
return _longParameter;
}
const char& ConfigOption::getShortParameter() const
{
return _shortParameter;
}
const hasArg& ConfigOption::getPresenceArgument() const
{
return _ha;
}
Option::Option() : _set(false)
{
}
void Option::set()
{
_set = true;
}
void Option::push(const std::string &value)
{
_values.push_back(value);
}
std::vector<std::string>& Option::getValues()
{
return _values;
}
bool Option::isSet() const
{
return _set;
}
void Hub::_createArguments(const std::vector<ConfigOption> &options, bool silence)
{
_longOptions = new struct option[options.size() + 1];
_sizeOptions = options.size();
std::string temp;
if (silence)
temp.push_back(':');
for (auto const &opt : options | boost::adaptors::indexed(0))
{
_longOptions[opt.index()].name = opt.value().getLongParameter();
_longOptions[opt.index()].has_arg = opt.value().getPresenceArgument();
_longOptions[opt.index()].flag = nullptr;
_longOptions[opt.index()].val = opt.value().getShortParameter();
temp.push_back(opt.value().getShortParameter());
switch (opt.value().getPresenceArgument())
{
case hasArg::OPTIONAL:
temp.push_back(':');
/* no break */
case hasArg::REQUIRED:
temp.push_back(':');
break;
case hasArg::NO:
break;
}
_arguments[opt.value().getShortParameter()].first = false;
}
_longOptions[options.size()].name = nullptr;
_longOptions[options.size()].has_arg = 0;
_longOptions[options.size()].flag = nullptr;
_longOptions[options.size()].val = 0;
_shortOptions = new char[temp.size() + 1];
strcpy(_shortOptions, temp.c_str());
}
Hub::Hub(const std::vector<ConfigOption> &options, bool silence) :
_longOptions(nullptr), _shortOptions(nullptr)
{
_createArguments(options, silence);
}
void Hub::readArguments(int argc, char *argv[], void (*_callback)())
{
int next_option;
while ((next_option = getopt_long(argc, argv, _shortOptions, _longOptions, nullptr)) != -1)
{
if (_arguments.count(next_option))
{
_arguments[next_option].first = true;
_arguments[next_option].second.set();
if (optarg)
_arguments[next_option].second.push(std::string(optarg));
}
if (next_option == '?' && _callback)
_callback();
}
}
Option Hub::getOption(char key) const
{
return _arguments.count(key) && _arguments.at(key).first ? _arguments.at(key).second : Option();
}
Hub::~Hub()
{
delete[] _shortOptions;
for (size_t i = 0; i < _sizeOptions; ++i)
{
delete[] _longOptions[i].name;
}
delete[] _longOptions;
}
}

68
lesson_03/ap/ap.hpp Normal file
View File

@ -0,0 +1,68 @@
/*
* ap.hpp
*
* Created on: 05 сен. 2022 г.
* Author: alexander
*/
#pragma once
#include <getopt.h>
#include <vector>
#include <string>
#include <cstring>
#include <map>
#include <boost/range/adaptors.hpp>
namespace ap
{
enum hasArg
{
NO, REQUIRED, OPTIONAL
};
typedef std::vector<std::string> (*_handler)(const std::vector<std::string>&);
class ConfigOption
{
private:
char *_longParameter;
const char _shortParameter;
const hasArg _ha;
public:
ConfigOption(const std::string &longParameter, const char shortParameter, const hasArg ha);
const char* getLongParameter() const;
const char& getShortParameter() const;
const hasArg& getPresenceArgument() const;
};
class Option
{
private:
std::vector<std::string> _values;
bool _set;
public:
Option();
void push(const std::string &value);
std::vector<std::string>& getValues();
void set();
bool isSet() const;
};
class Hub
{
private:
struct option *_longOptions;
size_t _sizeOptions;
char *_shortOptions;
std::map<char, std::pair<bool, Option>> _arguments;
void _createArguments(const std::vector<ConfigOption> &options, bool silence);
public:
Hub(const std::vector<ConfigOption> &options, bool silence = true);
void readArguments(int argc, char *argv[], void (*_callback)() = nullptr);
Option getOption(char key) const;
~Hub();
};
}

View File

@ -0,0 +1,33 @@
/*
* address.hpp
*
* Created on: 5 сент. 2022 г.
* Author: alexander
*/
#pragma once
#include <netinet/in.h>
#include <string.h>
#include <string>
#include <memory>
#include <netdb.h>
namespace zh {
class Address
{
private:
struct sockaddr_in _addr;
std::unique_ptr<const struct hostent *> _host;
unsigned int _len;
public:
Address();
Address(const Address &address);
Address(const unsigned short int family, const unsigned int addr, const unsigned short int port);
Address(const unsigned short int family, const std::string &addr, const unsigned short int port);
unsigned int& size();
struct sockaddr_in& operator*();
};
}

View File

@ -0,0 +1,28 @@
/*
* buffer.hpp
*
* Created on: 7 сент. 2022 г.
* Author: alexander
*/
#pragma once
#include <memory>
namespace zh
{
class Buffer
{
private:
const unsigned short int _size;
std::unique_ptr<std::byte[]> _buffer;
public:
Buffer(const unsigned short int size);
const unsigned short int getSize() const;
const std::string getString() const;
void clear();
operator char*();
};
}

View File

@ -0,0 +1,26 @@
/*
* client.hpp
*
* Created on: 7 сент. 2022 г.
* Author: alexander
*/
#pragma once
#include <stock.hpp>
namespace zh
{
class ClientTCP: public Server // @suppress("Class has a virtual method and non-virtual destructor")
{
private:
bool _connect;
void chat();
public:
ClientTCP(const std::string &address, const unsigned short int port, const unsigned short int sizeBuffer = 1024);
void connect();
};
}

View File

@ -0,0 +1,55 @@
/*
* server.hpp
*
* Created on: 5 сент. 2022 г.
* Author: alexander
*/
#pragma once
//#include <algorithm>
#include <stock.hpp>
#include <vector>
#include <string>
namespace zh
{
class ServerTCP;
typedef void (*hook)(std::string buffer, ServerTCP &s);
class ServerTCP: public Server // @suppress("Class has a virtual method and non-virtual destructor")
{
private:
bool _bind;
int _connfd;
bool _listenLoop;
unsigned int _sizeClient;
std::unique_ptr<Address> _client;
class Hook
{
private:
std::string _command;
hook _handler;
public:
Hook(std::string command, hook handler);
void execute(std::string buffer, ServerTCP &s);
};
std::vector<Hook> _hooks;
void chat();
public:
ServerTCP(const unsigned short int port, const unsigned short int sizeBuffer = 1024);
void registerHook(std::string command, hook handler);
void bind();
void listen();
void disconnect();
void stop();
};
}

View File

@ -0,0 +1,26 @@
/*
* socket.hpp
*
* Created on: 5 сент. 2022 г.
* Author: alexander
*/
#pragma once
#include <stdio.h>
#include <stdlib.h>
#include <sys/socket.h>
namespace zh {
class Socket
{
private:
int _sockfd;
public:
Socket(const int domain, const int type, const int protocol);
operator int() const;
~Socket();
};
}

View File

@ -0,0 +1,31 @@
/*
* stock.hpp
*
* Created on: 7 сент. 2022 г.
* Author: alexander
*/
#pragma once
#include <memory>
#include <socket.hpp>
#include <address.hpp>
#include <buffer.hpp>
namespace zh
{
class Server // @suppress("Class has a virtual method and non-virtual destructor")
{
protected:
std::unique_ptr<Socket> _socket;
std::unique_ptr<Address> _address;
std::unique_ptr<Buffer> _buffer;
const unsigned short int _port;
public:
Server(const unsigned short int port, const unsigned short int sizeBuffer);
virtual void bind() {}
virtual void listen() {}
};
}

95
lesson_03/main.cpp Normal file
View File

@ -0,0 +1,95 @@
/*
* main.cpp
*
* Created on: 5 сент. 2022 г.
* Author: alexander
*/
#include <ap.hpp>
#include <iostream>
#include <server.hpp>
#include <client.hpp>
void print(std::string buffer, zh::ServerTCP &s)
{
std::cout << buffer << std::endl;
}
void stop(std::string buffer, zh::ServerTCP &s)
{
s.stop();
}
void disconnect(std::string buffer, zh::ServerTCP &s)
{
s.disconnect();
}
void server(const int port)
{
zh::ServerTCP tcpServer(port);
tcpServer.registerHook("", print);
tcpServer.registerHook("disconnect", disconnect);
tcpServer.registerHook("stop", stop);
tcpServer.bind();
tcpServer.listen();
}
void client(const int port, const std::string &host)
{
zh::ClientTCP tcpClient(host, port);
tcpClient.connect();
}
int main(int argc, char *argv[])
{
ap::Hub hub({
{ "port", 'p', ap::REQUIRED },
{ "host", 'h', ap::OPTIONAL },
{ "server", 's', ap::NO },
{ "client", 'c', ap::NO }
});
hub.readArguments(argc, argv);
auto optionPort = hub.getOption('p');
if (!optionPort.isSet())
{
std::cerr << "Порт не был установлен!" << std::endl;
exit(EXIT_FAILURE);
}
int port = std::stoi(optionPort.getValues()[0]);
auto optionClient = hub.getOption('c');
auto optionServer = hub.getOption('s');
if (optionClient.isSet())
{
auto optionHost = hub.getOption('h');
if (!optionHost.isSet())
{
std::cerr << "Адрес не был установлен!" << std::endl;
exit(EXIT_FAILURE);
}
auto host = optionHost.getValues()[0];
client(port, host);
}
else if (optionServer.isSet())
server(port);
else
{
std::cerr << "Необходимо установить режим запуска:" << std::endl
<< "\t-c\t--client\tЗапуск в режиме клиента" << std::endl
<< "\t-s\t--server\tЗапуск в режиме сервера" << std::endl
<< "\t-h\t--host\t\tУказать IP-адрес сервера" << std::endl
<< "\t-p\t--port\t\tУказать порт" << std::endl;
exit(EXIT_FAILURE);
}
return 0;
}

View File

@ -0,0 +1,56 @@
/*
* address.cpp
*
* Created on: 5 сент. 2022 г.
* Author: alexander
*/
#include <address.hpp>
namespace zh {
Address::Address()
{
memset(&_addr, 0, sizeof(_addr));
_len = sizeof(_addr);
}
Address::Address(const Address &address)
{
_addr = address._addr;
_len = address._len;
}
Address::Address(const unsigned short int family, const unsigned int addr, const unsigned short int port)
{
memset(&_addr, 0, sizeof(_addr));
_len = sizeof(_addr);
_addr.sin_family = family;
_addr.sin_addr.s_addr = htonl(addr);
_addr.sin_port = htons(port);
}
Address::Address(const unsigned short int family, const std::string &addr, const unsigned short int port)
{
memset(&_addr, 0, sizeof(_addr));
_len = sizeof(_addr);
_host = std::make_unique<const struct hostent *>(gethostbyname(addr.c_str()));
_addr.sin_family = family;
_addr.sin_addr.s_addr = *reinterpret_cast<const in_addr_t*>((*_host)->h_addr);
_addr.sin_port = htons(port);
}
unsigned int& Address::size()
{
return _len;
}
struct sockaddr_in& Address::operator*()
{
return _addr;
}
}

View File

@ -0,0 +1,40 @@
/*
* buffer.cpp
*
* Created on: 7 сент. 2022 г.
* Author: alexander
*/
#include <buffer.hpp>
#include <string.h>
#include <string>
namespace zh
{
Buffer::Buffer(const unsigned short int size) : _size(size)
{
_buffer = std::make_unique<std::byte[]>(_size);
}
const unsigned short int Buffer::getSize() const
{
return _size;
}
const std::string Buffer::getString() const
{
return reinterpret_cast<char*>(_buffer.get());
}
void Buffer::clear()
{
bzero(_buffer.get(), _size);
}
Buffer::operator char*()
{
return reinterpret_cast<char*>(_buffer.get());
}
}

View File

@ -0,0 +1,58 @@
/*
* client.cpp
*
* Created on: 7 сент. 2022 г.
* Author: alexander
*/
#include <client.hpp>
#include <iostream>
#include <arpa/inet.h>
#include <unistd.h>
namespace zh
{
ClientTCP::ClientTCP(const std::string &address, const unsigned short int port, const unsigned short int sizeBuffer) : Server(port, sizeBuffer), _connect(false)
{
_socket = std::make_unique<Socket>(AF_INET, SOCK_STREAM, IPPROTO_IP);
_address = std::make_unique<Address>(AF_INET, address, port);
}
void ClientTCP::connect()
{
if (_connect)
{
std::cerr << "Клиентский сокет уже подключён к серверному сокету!" << std::endl;
return;
}
if (::connect(*_socket, reinterpret_cast<const sockaddr*>(&(*_address)), (*_address).size()) != 0)
std::cerr << "Не удаётся подключить клиентский сокет к серверному сокету!" << std::endl;
else
_connect = true;
chat();
}
void ClientTCP::chat()
{
Buffer *bf = &(*_buffer);
while (_connect)
{
bf->clear();
std::cin.getline(*bf, bf->getSize());
write(*_socket, *bf, bf->getSize());
bf->clear();
if (read(*_socket, *bf, bf->getSize()) > 0)
{
if (bf->getString() == "exit")
break;
else
std::cout << '\t' << bf->getString() << std::endl;
}
}
close(*_socket);
}
}

120
lesson_03/source/server.cpp Normal file
View File

@ -0,0 +1,120 @@
/*
* server.cpp
*
* Created on: 5 сент. 2022 г.
* Author: alexander
*/
#include <server.hpp>
#include <iostream>
#include <unistd.h>
#include <string.h>
#include <algorithm>
namespace zh
{
ServerTCP::Hook::Hook(std::string command, hook handler) : _command(command), _handler(handler)
{
}
void ServerTCP::Hook::execute(std::string buffer, ServerTCP &s)
{
if (_command == "")
{
_handler(buffer, s);
}
else
{
if (buffer == _command)
{
_handler(buffer, s);
}
}
}
void ServerTCP::registerHook(std::string command, hook handler)
{
_hooks.push_back({ command, handler });
}
ServerTCP::ServerTCP(const unsigned short int port, const unsigned short int sizeBuffer) : Server(port, sizeBuffer), _bind(false), _connfd(-1), _listenLoop(true)
{
_socket = std::make_unique<Socket>(AF_INET, SOCK_STREAM, IPPROTO_IP);
_address = std::make_unique<Address>(AF_INET, INADDR_ANY, port);
_sizeClient = sizeof(_client);
}
void ServerTCP::bind()
{
if (_bind)
{
std::cerr << "Адрес уже связан с дескриптором слушающего сокета!" << std::endl;
return;
}
if (::bind(*_socket, reinterpret_cast<const sockaddr*>(&(*_address)), (*_address).size()) != 0)
std::cerr << "Не удаётся связать адрес с дескриптором слушающего сокета!" << std::endl;
else
_bind = true;
}
void ServerTCP::listen()
{
if (::listen(*_socket, 0) != 0)
{
std::cerr << "Не удаётся создать очередь соединений для сокета!" << std::endl;
return;
}
while (_bind)
{
if ((_connfd = ::accept(*_socket, reinterpret_cast<sockaddr*>(&(*_client)), &_sizeClient)) < 0)
{
std::cerr << "Не удаётся верифицировать и принять пакеты от клиента!" << std::endl;
return;
}
else
_listenLoop = true;
// Обработка соединения с клиентом
chat();
}
}
void ServerTCP::chat()
{
Buffer *bf = &(*_buffer);
while (_listenLoop)
{
bf->clear();
int size = read(_connfd, *bf, bf->getSize());
if (size > 0)
{
std::for_each(_hooks.begin(), _hooks.end(), [&](Hook &hook)
{
hook.execute(bf->getString(), *this);
});
if (!_listenLoop)
write(_connfd, "exit", 4);
else
write(_connfd, "OK", 2);
}
else if (size < 0)
break;
}
close(_connfd);
}
void ServerTCP::stop()
{
_listenLoop = false;
_bind = 0;
}
void ServerTCP::disconnect()
{
_listenLoop = false;
}
}

View File

@ -0,0 +1,32 @@
/*
* socket.cpp
*
* Created on: 5 сент. 2022 г.
* Author: alexander
*/
#include <socket.hpp>
#include <unistd.h>
namespace zh {
Socket::Socket(const int domain, const int type, const int protocol)
{
if ((_sockfd = socket(domain, type, protocol)) < 0)
{
perror("socket creation failed");
exit(EXIT_FAILURE);
}
}
Socket::operator int() const
{
return _sockfd;
}
Socket::~Socket()
{
::close(_sockfd);
}
}

View File

@ -0,0 +1,18 @@
/*
* stock.cpp
*
* Created on: 7 сент. 2022 г.
* Author: alexander
*/
#include <stock.hpp>
namespace zh
{
Server::Server(const unsigned short int port, const unsigned short int sizeBuffer) : _port(port)
{
_buffer = std::make_unique<Buffer>(sizeBuffer);
}
}