707 lines
33 KiB
C++
707 lines
33 KiB
C++
//! \~\file piethernet.h
|
||
//! \~\ingroup IO
|
||
//! \~\brief
|
||
//! \~english Ethernet-backed UDP and TCP device
|
||
//! \~russian Устройство UDP и TCP поверх Ethernet
|
||
/*
|
||
PIP - Platform Independent Primitives
|
||
Ethernet, UDP/TCP Broadcast/Multicast
|
||
Ivan Pelipenko peri4ko@yandex.ru, Andrey Bychkov work.a.b@yandex.ru
|
||
|
||
This program is free software: you can redistribute it and/or modify
|
||
it under the terms of the GNU Lesser General Public License as published by
|
||
the Free Software Foundation, either version 3 of the License, or
|
||
(at your option) any later version.
|
||
|
||
This program is distributed in the hope that it will be useful,
|
||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||
GNU Lesser General Public License for more details.
|
||
|
||
You should have received a copy of the GNU Lesser General Public License
|
||
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||
*/
|
||
|
||
#ifndef PIETHERNET_H
|
||
#define PIETHERNET_H
|
||
|
||
#include "piiodevice.h"
|
||
#include "pinetworkaddress.h"
|
||
|
||
#ifdef ANDROID
|
||
struct
|
||
#else
|
||
class
|
||
#endif
|
||
sockaddr;
|
||
|
||
//! \~\ingroup IO
|
||
//! \~\brief
|
||
//! \~english %PIIODevice implementation for UDP sockets, TCP clients and TCP servers.
|
||
//! \~russian Реализация %PIIODevice для UDP-сокетов, TCP-клиентов и TCP-серверов.
|
||
class PIP_EXPORT PIEthernet: public PIIODevice {
|
||
PIIODEVICE(PIEthernet, "eth");
|
||
friend class PIPeer;
|
||
|
||
public:
|
||
//! \~english Constructs a UDP device with an empty read address.
|
||
//! \~russian Создает UDP-устройство с пустым адресом чтения.
|
||
explicit PIEthernet();
|
||
|
||
//! \~english Operating mode of %PIEthernet.
|
||
//! \~russian Режим работы %PIEthernet.
|
||
enum Type {
|
||
UDP /** \~english UDP datagram socket \~russian UDP-сокет датаграмм */,
|
||
TCP_Client /** \~english TCP client socket \~russian TCP-клиент */,
|
||
TCP_Server /** \~english TCP server socket \~russian TCP-сервер */
|
||
};
|
||
|
||
//! \~english Extra socket parameters for %PIEthernet.
|
||
//! \~russian Дополнительные параметры сокета %PIEthernet.
|
||
enum Parameters {
|
||
ReuseAddress = 0x1 /** \~english Allow rebinding an already bound address; enabled by default \~russian Разрешает повторную привязку
|
||
уже занятого адреса; включено по умолчанию */
|
||
,
|
||
Broadcast = 0x2 /** \~english Enable broadcast sending; disabled by default \~russian Включает отправку broadcast-пакетов; выключено
|
||
по умолчанию */
|
||
,
|
||
SeparateSockets = 0x4 /** \~english Use separate sockets for receiving and sending instead of a single one; disabled by default
|
||
\~russian Использует отдельные сокеты для приема и передачи вместо одного общего; выключено по умолчанию */
|
||
,
|
||
MulticastLoop = 0x8 /** \~english Receive multicast packets sent by the same host; enabled by default \~russian Разрешает получать
|
||
multicast-пакеты от того же хоста; включено по умолчанию */
|
||
,
|
||
KeepConnection = 0x10 /** \~english Reconnect TCP connection automatically after disconnect; enabled by default \~russian
|
||
Автоматически переподключает TCP-соединение после разрыва; включено по умолчанию */
|
||
,
|
||
DisonnectOnTimeout = 0x20 /** \~english Disconnect TCP connection when read timeout expires; disabled by default \~russian Разрывает
|
||
TCP-соединение при истечении таймаута чтения; выключено по умолчанию */
|
||
,
|
||
NoDelay = 0x40 /** \~english Enable the TCP no-delay option; disabled by default \~russian Включает опцию TCP no-delay; выключено по
|
||
умолчанию */
|
||
};
|
||
|
||
//! \~english Deprecated alias for \a PINetworkAddress.
|
||
//! \~russian Устаревший псевдоним для \a PINetworkAddress.
|
||
typedef ::PINetworkAddress Address DEPRECATEDM("use PINetworkAddress instead");
|
||
|
||
//! \~english Constructs a device with mode "type", read address "ip_port" and socket "params".
|
||
//! \~russian Создает устройство с режимом "type", адресом чтения "ip_port" и параметрами сокета "params".
|
||
explicit PIEthernet(Type type,
|
||
const PIString & ip_port = PIString(),
|
||
const PIFlags<Parameters> params = PIEthernet::ReuseAddress | PIEthernet::MulticastLoop |
|
||
PIEthernet::KeepConnection);
|
||
|
||
//! \~english Destroys the ethernet device.
|
||
//! \~russian Уничтожает ethernet-устройство.
|
||
virtual ~PIEthernet();
|
||
|
||
|
||
//! \~english Sets the read address from IP and port.
|
||
//! \~russian Устанавливает адрес чтения по IP и порту.
|
||
void setReadAddress(const PIString & ip, int port) {
|
||
addr_r.set(ip, port);
|
||
setPath(addr_r.toString());
|
||
}
|
||
|
||
//! \~english Sets the read address from string "i.i.i.i:p".
|
||
//! \~russian Устанавливает адрес чтения из строки "i.i.i.i:p".
|
||
void setReadAddress(const PIString & ip_port) {
|
||
addr_r.set(ip_port);
|
||
setPath(addr_r.toString());
|
||
}
|
||
|
||
//! \~english Sets the read address from \a PINetworkAddress.
|
||
//! \~russian Устанавливает адрес чтения из \a PINetworkAddress.
|
||
void setReadAddress(const PINetworkAddress & addr) {
|
||
addr_r = addr;
|
||
setPath(addr_r.toString());
|
||
}
|
||
|
||
//! \~english Sets only the read IP.
|
||
//! \~russian Устанавливает только IP-адрес чтения.
|
||
void setReadIP(const PIString & ip) {
|
||
addr_r.setIP(ip);
|
||
setPath(addr_r.toString());
|
||
}
|
||
|
||
//! \~english Sets only the read port.
|
||
//! \~russian Устанавливает только порт чтения.
|
||
void setReadPort(int port) {
|
||
addr_r.setPort(port);
|
||
setPath(addr_r.toString());
|
||
}
|
||
|
||
|
||
//! \~english Sets the send address from IP and port.
|
||
//! \~russian Устанавливает адрес отправки по IP и порту.
|
||
void setSendAddress(const PIString & ip, int port) { addr_s.set(ip, port); }
|
||
|
||
//! \~english Sets the send address from string "i.i.i.i:p".
|
||
//! \~russian Устанавливает адрес отправки из строки "i.i.i.i:p".
|
||
void setSendAddress(const PIString & ip_port) { addr_s.set(ip_port); }
|
||
|
||
//! \~english Sets the send address from \a PINetworkAddress.
|
||
//! \~russian Устанавливает адрес отправки из \a PINetworkAddress.
|
||
void setSendAddress(const PINetworkAddress & addr) { addr_s = addr; }
|
||
|
||
//! \~english Sets only the send IP.
|
||
//! \~russian Устанавливает только IP-адрес отправки.
|
||
void setSendIP(const PIString & ip) { addr_s.setIP(ip); }
|
||
|
||
//! \~english Sets only the send port.
|
||
//! \~russian Устанавливает только порт отправки.
|
||
void setSendPort(int port) { addr_s.setPort(port); }
|
||
|
||
|
||
//! \~english Returns the current read address.
|
||
//! \~russian Возвращает текущий адрес чтения.
|
||
PINetworkAddress readAddress() const { return addr_r; }
|
||
|
||
//! \~english Returns the current read IP.
|
||
//! \~russian Возвращает текущий IP-адрес чтения.
|
||
PIString readIP() const { return addr_r.ipString(); }
|
||
|
||
//! \~english Returns the current read port.
|
||
//! \~russian Возвращает текущий порт чтения.
|
||
int readPort() const { return addr_r.port(); }
|
||
|
||
|
||
//! \~english Returns the current send address.
|
||
//! \~russian Возвращает текущий адрес отправки.
|
||
PINetworkAddress sendAddress() const { return addr_s; }
|
||
|
||
//! \~english Returns the current send IP.
|
||
//! \~russian Возвращает текущий IP-адрес отправки.
|
||
PIString sendIP() const { return addr_s.ipString(); }
|
||
|
||
//! \~english Returns the current send port.
|
||
//! \~russian Возвращает текущий порт отправки.
|
||
int sendPort() const { return addr_s.port(); }
|
||
|
||
|
||
//! \~english Returns the source address of the last received UDP packet.
|
||
//! \~russian Возвращает адрес источника последнего принятого UDP-пакета.
|
||
PINetworkAddress lastReadAddress() const { return addr_lr; }
|
||
|
||
//! \~english Returns the IP of the last received UDP packet.
|
||
//! \~russian Возвращает IP-адрес последнего принятого UDP-пакета.
|
||
PIString lastReadIP() const { return addr_lr.ipString(); }
|
||
|
||
//! \~english Returns the port of the last received UDP packet.
|
||
//! \~russian Возвращает порт последнего принятого UDP-пакета.
|
||
int lastReadPort() const { return addr_lr.port(); }
|
||
|
||
|
||
//! \~english Replaces all socket parameters with "parameters_".
|
||
//! \~russian Полностью заменяет параметры сокета на "parameters_".
|
||
//! \~english Some parameters may require reopening the device to take full effect.
|
||
//! \~russian Для полного применения некоторых параметров может потребоваться переоткрытие устройства.
|
||
void setParameters(PIFlags<PIEthernet::Parameters> parameters_) {
|
||
params = parameters_;
|
||
applyParameters();
|
||
}
|
||
|
||
//! \~english Sets socket parameter "parameter" to state "on".
|
||
//! \~russian Устанавливает параметр сокета "parameter" в состояние "on".
|
||
//! \~english Some parameters may require reopening the device to take full effect.
|
||
//! \~russian Для полного применения некоторых параметров может потребоваться переоткрытие устройства.
|
||
void setParameter(PIEthernet::Parameters parameter, bool on = true) {
|
||
params.setFlag(parameter, on);
|
||
applyParameters();
|
||
}
|
||
|
||
//! \~english Returns whether parameter "parameter" is enabled.
|
||
//! \~russian Возвращает, включен ли параметр "parameter".
|
||
bool isParameterSet(PIEthernet::Parameters parameter) const { return params[parameter]; }
|
||
|
||
//! \~english Returns current socket parameters.
|
||
//! \~russian Возвращает текущие параметры сокета.
|
||
PIFlags<PIEthernet::Parameters> parameters() const { return params; }
|
||
|
||
//! \~english Returns the current ethernet mode.
|
||
//! \~russian Возвращает текущий режим ethernet-устройства.
|
||
Type type() const { return eth_type; }
|
||
|
||
//! \~english Returns the configured read timeout.
|
||
//! \~russian Возвращает настроенный таймаут чтения.
|
||
PISystemTime readTimeout() const { return property("readTimeout").toSystemTime(); }
|
||
|
||
//! \~english Returns the configured write timeout.
|
||
//! \~russian Возвращает настроенный таймаут записи.
|
||
PISystemTime writeTimeout() const { return property("writeTimeout").toSystemTime(); }
|
||
|
||
//! \~english Sets the read timeout.
|
||
//! \~russian Устанавливает таймаут чтения.
|
||
void setReadTimeout(PISystemTime tm);
|
||
|
||
//! \~english Sets the write timeout.
|
||
//! \~russian Устанавливает таймаут записи.
|
||
void setWriteTimeout(PISystemTime tm);
|
||
|
||
|
||
//! \~english Sets the socket receive buffer size in bytes.
|
||
//! \~russian Устанавливает размер приемного буфера сокета в байтах.
|
||
void setReadBufferSize(int bytes);
|
||
|
||
//! \~english Sets the socket send buffer size in bytes.
|
||
//! \~russian Устанавливает размер буфера передачи сокета в байтах.
|
||
void setWriteBufferSize(int bytes);
|
||
|
||
|
||
//! \~english Returns the IP packet TTL.
|
||
//! \~russian Возвращает TTL IP-пакетов.
|
||
int TTL() const { return property("TTL").toInt(); }
|
||
|
||
//! \~english Returns the multicast TTL.
|
||
//! \~russian Возвращает TTL multicast-пакетов.
|
||
int multicastTTL() const { return property("MulticastTTL").toInt(); }
|
||
|
||
//! \~english Sets the IP packet TTL, default is 64.
|
||
//! \~russian Устанавливает TTL IP-пакетов, по умолчанию 64.
|
||
void setTTL(int ttl) { setProperty("TTL", ttl); }
|
||
|
||
//! \~english Sets the multicast TTL, default is 1.
|
||
//! \~russian Устанавливает TTL multicast-пакетов, по умолчанию 1.
|
||
void setMulticastTTL(int ttl) { setProperty("MulticastTTL", ttl); }
|
||
|
||
|
||
//! \~english Joins multicast group "group". Use only with \a UDP.
|
||
//! \~russian Подключается к multicast-группе "group". Используйте только с \a UDP.
|
||
bool joinMulticastGroup(const PIString & group);
|
||
|
||
//! \~english Leaves multicast group "group". Use only with \a UDP.
|
||
//! \~russian Покидает multicast-группу "group". Используйте только с \a UDP.
|
||
bool leaveMulticastGroup(const PIString & group);
|
||
|
||
//! \~english Returns joined multicast groups. Use only with \a UDP.
|
||
//! \~russian Возвращает список подключенных multicast-групп. Используйте только с \a UDP.
|
||
const PIStringList & multicastGroups() const { return mcast_groups; }
|
||
|
||
|
||
//! \~english Connects to the TCP server at \a readAddress().
|
||
//! \~russian Подключается к TCP-серверу по адресу \a readAddress().
|
||
//! \~\details
|
||
//! \~english If "threaded" is true, connection is queued and completed from subsequent \a read() or \a write() calls.
|
||
//! \~russian Если "threaded" равно true, подключение ставится в очередь и завершается из последующих вызовов \a read() или \a write().
|
||
bool connect(bool threaded = true);
|
||
|
||
//! \~english Connects to the TCP server at "ip":"port".
|
||
//! \~russian Подключается к TCP-серверу по адресу "ip":"port".
|
||
bool connect(const PIString & ip, int port, bool threaded = true) {
|
||
setPath(ip + PIStringAscii(":") + PIString::fromNumber(port));
|
||
return connect(threaded);
|
||
}
|
||
|
||
//! \~english Connects to the TCP server at "ip_port".
|
||
//! \~russian Подключается к TCP-серверу по адресу "ip_port".
|
||
bool connect(const PIString & ip_port, bool threaded = true) {
|
||
setPath(ip_port);
|
||
return connect(threaded);
|
||
}
|
||
|
||
//! \~english Connects to the TCP server at "addr". Use only for TCP_Client
|
||
//! \~russian Подключается к TCP-серверу по адресу "addr". Только для TCP_Client
|
||
bool connect(const PINetworkAddress & addr, bool threaded = true) {
|
||
setPath(addr.toString());
|
||
return connect(threaded);
|
||
}
|
||
|
||
//! \~english Returns whether the TCP client is connected. Use only for TCP_Client
|
||
//! \~russian Возвращает, подключен ли TCP-клиент. Только для TCP_Client
|
||
bool isConnected() const { return connected_; }
|
||
|
||
//! \~english Returns whether the TCP client is currently connecting. Use only for TCP_Client
|
||
//! \~russian Возвращает, выполняется ли сейчас подключение TCP-клиента. Только для TCP_Client
|
||
bool isConnecting() const { return connecting_; }
|
||
|
||
|
||
//! \~english Starts listen for incoming TCP connections on address \a readAddress(). Use only for TCP_Server
|
||
//! \~russian Начинает прослушивание входящих TCP подключений на адресе \a readAddress(). Только для TCP_Server
|
||
bool listen(bool threaded = false);
|
||
|
||
//! \~english Starts listen for incoming TCP connections on address "ip":"port". Use only for TCP_Server
|
||
//! \~russian Начинает прослушивание входящих TCP подключений на адресе "ip":"port". Только для TCP_Server
|
||
bool listen(const PIString & ip, int port, bool threaded = false) { return listen(PINetworkAddress(ip, port), threaded); }
|
||
|
||
//! \~english Starts listen for incoming TCP connections on address "ip_port". Use only for TCP_Server
|
||
//! \~russian Начинает прослушивание входящих TCP подключений на адресе "ip_port". Только для TCP_Server
|
||
bool listen(const PIString & ip_port, bool threaded = false) { return listen(PINetworkAddress(ip_port), threaded); }
|
||
|
||
//! \~english Starts listen for incoming TCP connections on address "addr". Use only for TCP_Server
|
||
//! \~russian Начинает прослушивание входящих TCP подключений на адресе "addr". Только для TCP_Server
|
||
bool listen(const PINetworkAddress & addr, bool threaded = false);
|
||
|
||
//! \~english Stops the background listen loop started with threaded listening.
|
||
//! \~russian Останавливает фоновый цикл прослушивания, запущенный в потоковом режиме.
|
||
void stopThreadedListen();
|
||
|
||
|
||
//! \~english Returns accepted TCP client by index.
|
||
//! \~russian Возвращает принятый TCP-клиент по индексу.
|
||
PIEthernet * client(int index);
|
||
|
||
//! \~english Returns the number of accepted TCP clients.
|
||
//! \~russian Возвращает количество принятых TCP-клиентов.
|
||
int clientsCount() const;
|
||
|
||
//! \~english Returns all accepted TCP clients.
|
||
//! \~russian Возвращает всех принятых TCP-клиентов.
|
||
PIVector<PIEthernet *> clients() const;
|
||
|
||
|
||
//! \~english Sends raw buffer "data" of size "size".
|
||
//! \~russian Отправляет сырой буфер "data" размером "size".
|
||
//! \~\details
|
||
//! \~english For \a UDP it uses \a sendAddress(), for \a TCP_Client it sends through the connected peer.
|
||
//! \~russian Для \a UDP использует \a sendAddress(), для \a TCP_Client отправляет данные через подключенного пира.
|
||
bool send(const void * data, int size, bool threaded = false);
|
||
|
||
//! \~english Sends raw buffer "data" to address "ip":"port".
|
||
//! \~russian Отправляет сырой буфер "data" по адресу "ip":"port".
|
||
bool send(const PIString & ip, int port, const void * data, int size, bool threaded = false) {
|
||
return send(PINetworkAddress(ip, port), data, size, threaded);
|
||
}
|
||
|
||
//! \~english Sends raw buffer "data" to address "ip_port".
|
||
//! \~russian Отправляет сырой буфер "data" по адресу "ip_port".
|
||
bool send(const PIString & ip_port, const void * data, int size, bool threaded = false) {
|
||
return send(PINetworkAddress(ip_port), data, size, threaded);
|
||
}
|
||
|
||
//! \~english Sends raw buffer "data" to address "addr".
|
||
//! \~russian Отправляет сырой буфер "data" по адресу "addr".
|
||
bool send(const PINetworkAddress & addr, const void * data, int size, bool threaded = false);
|
||
|
||
//! \~english Sends byte array "data" using the default destination.
|
||
//! \~russian Отправляет массив байт "data" по адресу назначения по умолчанию.
|
||
bool send(const PIByteArray & data, bool threaded = false);
|
||
|
||
//! \~english Sends byte array "data" to address "ip":"port".
|
||
//! \~russian Отправляет массив байт "data" по адресу "ip":"port".
|
||
bool send(const PIString & ip, int port, const PIByteArray & data, bool threaded = false) {
|
||
return send(PINetworkAddress(ip, port), data, threaded);
|
||
}
|
||
|
||
//! \~english Sends byte array "data" to address "ip_port".
|
||
//! \~russian Отправляет массив байт "data" по адресу "ip_port".
|
||
bool send(const PIString & ip_port, const PIByteArray & data, bool threaded = false) {
|
||
return send(PINetworkAddress(ip_port), data, threaded);
|
||
}
|
||
|
||
//! \~english Sends byte array "data" to address "addr".
|
||
//! \~russian Отправляет массив байт "data" по адресу "addr".
|
||
bool send(const PINetworkAddress & addr, const PIByteArray & data, bool threaded = false);
|
||
|
||
//! \~english Returns whether writing is currently allowed.
|
||
//! \~russian Возвращает, разрешена ли сейчас запись.
|
||
bool canWrite() const override { return mode() & WriteOnly; }
|
||
|
||
//! \~english Interrupts a blocking socket operation.
|
||
//! \~russian Прерывает блокирующую операцию сокета.
|
||
void interrupt() override;
|
||
|
||
//! \~english Returns the underlying native socket descriptor.
|
||
//! \~russian Возвращает дескриптор нативного сокета.
|
||
int socket() const { return sock; }
|
||
|
||
|
||
//! \~english Flags describing a network interface.
|
||
//! \~russian Флаги, описывающие сетевой интерфейс.
|
||
enum InterfaceFlag {
|
||
ifActive = 0x1 /** \~english Interface is active \~russian Интерфейс активен */,
|
||
ifRunning = 0x2 /** \~english Interface is running \~russian Интерфейс работает */,
|
||
ifBroadcast = 0x4 /** \~english Interface supports broadcast \~russian Интерфейс поддерживает broadcast */,
|
||
ifMulticast = 0x8 /** \~english Interface supports multicast \~russian Интерфейс поддерживает multicast */,
|
||
ifLoopback = 0x10 /** \~english Interface is loopback \~russian Интерфейс является loopback */,
|
||
ifPTP = 0x20 /** \~english Interface is point-to-point \~russian Интерфейс работает в режиме point-to-point */
|
||
};
|
||
|
||
//! \~english Bitmask of \a InterfaceFlag values.
|
||
//! \~russian Битовая маска значений \a InterfaceFlag.
|
||
typedef PIFlags<InterfaceFlag> InterfaceFlags;
|
||
|
||
|
||
//! \~\ingroup IO
|
||
//! \~\brief
|
||
//! \~english Public descriptor of a system network interface.
|
||
//! \~russian Публичное описание системного сетевого интерфейса.
|
||
struct PIP_EXPORT Interface {
|
||
//! \~english System interface index.
|
||
//! \~russian Системный индекс интерфейса.
|
||
int index = -1;
|
||
|
||
//! \~english Interface MTU.
|
||
//! \~russian MTU интерфейса.
|
||
int mtu = 0;
|
||
|
||
//! \~english System interface name.
|
||
//! \~russian Системное имя интерфейса.
|
||
PIString name;
|
||
|
||
//! \~english MAC address in format "hh:hh:hh:hh:hh:hh", or empty if unavailable.
|
||
//! \~russian MAC-адрес в формате "hh:hh:hh:hh:hh:hh", либо пустая строка если он недоступен.
|
||
PIString mac;
|
||
|
||
//! \~english IPv4 address in format "i.i.i.i", or empty if unavailable.
|
||
//! \~russian IPv4-адрес в формате "i.i.i.i", либо пустая строка если он недоступен.
|
||
PIString address;
|
||
|
||
//! \~english Netmask in format "i.i.i.i", or empty if unavailable.
|
||
//! \~russian Маска сети в формате "i.i.i.i", либо пустая строка если она недоступна.
|
||
PIString netmask;
|
||
|
||
//! \~english Broadcast address in format "i.i.i.i", or empty if unavailable.
|
||
//! \~russian Broadcast-адрес в формате "i.i.i.i", либо пустая строка если он недоступен.
|
||
PIString broadcast;
|
||
|
||
//! \~english Point-to-point peer address, or empty if unavailable.
|
||
//! \~russian Адрес point-to-point-пира, либо пустая строка если он недоступен.
|
||
PIString ptp;
|
||
|
||
//! \~english Interface capability flags.
|
||
//! \~russian Флаги возможностей интерфейса.
|
||
InterfaceFlags flags;
|
||
|
||
//! \~english Returns whether the descriptor contains a valid interface.
|
||
//! \~russian Возвращает, содержит ли описание валидный интерфейс.
|
||
bool isValid() const { return name.isNotEmpty(); }
|
||
|
||
//! \~english Returns whether the interface is active.
|
||
//! \~russian Возвращает, активен ли интерфейс.
|
||
bool isActive() const { return flags[PIEthernet::ifActive]; }
|
||
|
||
//! \~english Returns whether the interface is running.
|
||
//! \~russian Возвращает, работает ли интерфейс.
|
||
bool isRunning() const { return flags[PIEthernet::ifRunning]; }
|
||
|
||
//! \~english Returns whether broadcast is supported.
|
||
//! \~russian Возвращает, поддерживается ли broadcast.
|
||
bool isBroadcast() const { return flags[PIEthernet::ifBroadcast]; }
|
||
|
||
//! \~english Returns whether multicast is supported.
|
||
//! \~russian Возвращает, поддерживается ли multicast.
|
||
bool isMulticast() const { return flags[PIEthernet::ifMulticast]; }
|
||
|
||
//! \~english Returns whether the interface is loopback.
|
||
//! \~russian Возвращает, является ли интерфейс loopback.
|
||
bool isLoopback() const { return flags[PIEthernet::ifLoopback]; }
|
||
|
||
//! \~english Returns whether the interface is point-to-point.
|
||
//! \~russian Возвращает, работает ли интерфейс в режиме point-to-point.
|
||
bool isPTP() const { return flags[PIEthernet::ifPTP]; }
|
||
};
|
||
|
||
|
||
//! \~\ingroup IO
|
||
//! \~\brief
|
||
//! \~english Collection of \a Interface descriptors with lookup helpers.
|
||
//! \~russian Коллекция описаний \a Interface с методами поиска.
|
||
class PIP_EXPORT InterfaceList: public PIVector<PIEthernet::Interface> {
|
||
public:
|
||
InterfaceList(): PIVector<PIEthernet::Interface>() {}
|
||
|
||
//! \~english Returns interface with system index "index", or 0 if absent.
|
||
//! \~russian Возвращает интерфейс с системным индексом "index", либо 0 если он не найден.
|
||
const Interface * getByIndex(int index) const {
|
||
for (int i = 0; i < size_s(); ++i)
|
||
if ((*this)[i].index == index) return &((*this)[i]);
|
||
return 0;
|
||
}
|
||
|
||
//! \~english Returns interface with system name "name", or 0 if absent.
|
||
//! \~russian Возвращает интерфейс с системным именем "name", либо 0 если он не найден.
|
||
const Interface * getByName(const PIString & name) const {
|
||
for (int i = 0; i < size_s(); ++i)
|
||
if ((*this)[i].name == name) return &((*this)[i]);
|
||
return 0;
|
||
}
|
||
|
||
//! \~english Returns interface with IP address "address", or 0 if absent.
|
||
//! \~russian Возвращает интерфейс с IP-адресом "address", либо 0 если он не найден.
|
||
const Interface * getByAddress(const PIString & address) const {
|
||
for (int i = 0; i < size_s(); ++i)
|
||
if ((*this)[i].address == address) return &((*this)[i]);
|
||
return 0;
|
||
}
|
||
|
||
//! \~english Returns the loopback interface, or 0 if absent.
|
||
//! \~russian Возвращает loopback-интерфейс, либо 0 если он не найден.
|
||
const Interface * getLoopback() const {
|
||
for (int i = 0; i < size_s(); ++i)
|
||
if ((*this)[i].isLoopback()) return &((*this)[i]);
|
||
return 0;
|
||
}
|
||
};
|
||
|
||
|
||
//! \~english Returns all detected system network interfaces.
|
||
//! \~russian Возвращает все обнаруженные системные сетевые интерфейсы.
|
||
static InterfaceList interfaces();
|
||
|
||
//! \~english Returns the address currently assigned to interface "interface_".
|
||
//! \~russian Возвращает адрес, назначенный интерфейсу "interface_".
|
||
static PINetworkAddress interfaceAddress(const PIString & interface_);
|
||
|
||
//! \~english Returns all detected system IP addresses.
|
||
//! \~russian Возвращает все обнаруженные системные IP-адреса.
|
||
static PIVector<PINetworkAddress> allAddresses();
|
||
|
||
//! \~english Converts a MAC address byte array to text form.
|
||
//! \~russian Преобразует массив байт MAC-адреса в текстовый вид.
|
||
static PIString macFromBytes(const PIByteArray & mac);
|
||
|
||
//! \~english Converts a textual MAC address to bytes.
|
||
//! \~russian Преобразует текстовый MAC-адрес в массив байт.
|
||
static PIByteArray macToBytes(const PIString & mac);
|
||
|
||
//! \~english Applies network mask "mask" to IPv4 string "ip".
|
||
//! \~russian Применяет сетевую маску "mask" к строковому IPv4-адресу "ip".
|
||
static PIString applyMask(const PIString & ip, const PIString & mask);
|
||
|
||
//! \~english Applies network mask "mask" to address "ip".
|
||
//! \~russian Применяет сетевую маску "mask" к адресу "ip".
|
||
static PINetworkAddress applyMask(const PINetworkAddress & ip, const PINetworkAddress & mask);
|
||
|
||
//! \~english Calculates broadcast address from IPv4 string and mask.
|
||
//! \~russian Вычисляет broadcast-адрес по строковому IPv4-адресу и маске.
|
||
static PIString getBroadcast(const PIString & ip, const PIString & mask);
|
||
|
||
//! \~english Calculates broadcast address from address and mask.
|
||
//! \~russian Вычисляет broadcast-адрес по адресу и маске.
|
||
static PINetworkAddress getBroadcast(const PINetworkAddress & ip, const PINetworkAddress & mask);
|
||
|
||
|
||
//! \events
|
||
//! \{
|
||
|
||
//! \fn void newConnection(PIEthernet * client)
|
||
//! \~english Raised when a new TCP client connection is accepted.
|
||
//! \~russian Вызывается при принятии нового TCP-клиентского соединения.
|
||
EVENT1(newConnection, PIEthernet *, client);
|
||
|
||
//! \fn void connected()
|
||
//! \~english Raised after a successful TCP client connection.
|
||
//! \~russian Вызывается после успешного подключения TCP-клиента.
|
||
EVENT0(connected);
|
||
|
||
//! \fn void disconnected(bool withError)
|
||
//! \~english Raised when the TCP connection is closed.
|
||
//! \~russian Вызывается при закрытии TCP-соединения.
|
||
EVENT1(disconnected, bool, withError);
|
||
|
||
//! \}
|
||
//! \ioparams
|
||
//! \{
|
||
#ifdef DOXYGEN
|
||
|
||
//! \~english Read IP address, default ""
|
||
//! \~russian IP-адрес чтения, по умолчанию ""
|
||
string ip;
|
||
|
||
//! \~english Read port, default 0
|
||
//! \~russian Порт чтения, по умолчанию 0
|
||
int port;
|
||
|
||
//! \~english Bitmask of \a Parameters values
|
||
//! \~russian Битовая маска значений \a Parameters
|
||
int parameters;
|
||
|
||
//! \~english Read timeout, default 10 s
|
||
//! \~russian Таймаут чтения, по умолчанию 10 с
|
||
PISystemTime readTimeout;
|
||
|
||
//! \~english Write timeout, default 10 s
|
||
//! \~russian Таймаут записи, по умолчанию 10 с
|
||
PISystemTime writeTimeout;
|
||
|
||
//! \~english IP packet TTL, default 64
|
||
//! \~russian TTL IP-пакетов, по умолчанию 64
|
||
int TTL;
|
||
|
||
//! \~english Multicast TTL, default 1
|
||
//! \~russian TTL multicast-пакетов, по умолчанию 1
|
||
int multicastTTL;
|
||
|
||
#endif
|
||
//! \}
|
||
|
||
protected:
|
||
explicit PIEthernet(int sock, PIString ip_port);
|
||
|
||
void propertyChanged(const char * name) override;
|
||
|
||
PIString constructFullPathDevice() const override;
|
||
void configureFromFullPathDevice(const PIString & full_path) override;
|
||
PIPropertyStorage constructVariantDevice() const override;
|
||
void configureFromVariantDevice(const PIPropertyStorage & d) override;
|
||
bool configureDevice(const void * e_main, const void * e_parent = 0) override;
|
||
ssize_t readDevice(void * read_to, ssize_t max_size) override;
|
||
ssize_t writeDevice(const void * data, ssize_t max_size) override;
|
||
DeviceInfoFlags deviceInfoFlags() const override;
|
||
void applyParameters();
|
||
|
||
//! \~english Called after any successful receive operation.
|
||
//! \~russian Вызывается после любой успешной операции приема.
|
||
//! \~\details
|
||
//! \~english Default implementation does nothing.
|
||
//! \~russian Реализация по умолчанию ничего не делает.
|
||
virtual void received(const void * data, int size) { ; }
|
||
|
||
void construct();
|
||
void init();
|
||
bool openDevice() override;
|
||
bool closeDevice() override;
|
||
void closeSocket(int & sd);
|
||
void applyTimeouts();
|
||
void applyBuffers();
|
||
void applyTimeout(int fd, int opt, PISystemTime tm);
|
||
void applyOptInt(int level, int opt, int val);
|
||
|
||
PRIVATE_DECLARATION(PIP_EXPORT)
|
||
int sock = -1, sock_s = -1, rcv_buf = 0, snd_buf = 0;
|
||
std::atomic_bool connected_ = {false}, connecting_ = {false}, listen_threaded = {false}, server_bounded = {false};
|
||
bool is_server_client = false;
|
||
mutable PINetworkAddress addr_r, addr_s, addr_lr;
|
||
Type eth_type;
|
||
PIThread server_thread_;
|
||
mutable PIMutex clients_mutex;
|
||
PIVector<PIEthernet *> clients_;
|
||
PIQueue<PIString> mcast_queue;
|
||
PIStringList mcast_groups;
|
||
PIFlags<PIEthernet::Parameters> params;
|
||
|
||
private:
|
||
EVENT_HANDLER1(void, clientDeleted, PIObject *, o);
|
||
static void server_func(void * eth);
|
||
void setType(Type t, bool reopen = true);
|
||
bool connectTCP();
|
||
#ifdef WINDOWS
|
||
long waitForEvent(PIWaitEvent & event, long mask);
|
||
#endif
|
||
|
||
static int ethErrorCore();
|
||
static PIString ethErrorString();
|
||
static int ethRecv(int sock, void * buf, int size, int flags = 0);
|
||
static int ethRecvfrom(int sock, void * buf, int size, int flags, sockaddr * addr);
|
||
static int ethSendto(int sock, const void * buf, int size, int flags, sockaddr * addr, int addr_len);
|
||
static void ethClosesocket(int sock, bool shutdown);
|
||
static int ethSetsockopt(int sock, int level, int optname, const void * optval, int optlen);
|
||
static int ethSetsockoptInt(int sock, int level, int optname, int value = 1);
|
||
static int ethSetsockoptBool(int sock, int level, int optname, bool value = true);
|
||
static void ethNonblocking(int sock);
|
||
static bool ethIsWriteable(int sock);
|
||
};
|
||
|
||
inline bool operator<(const PIEthernet::Interface & v0, const PIEthernet::Interface & v1) {
|
||
return (v0.name < v1.name);
|
||
}
|
||
inline bool operator==(const PIEthernet::Interface & v0, const PIEthernet::Interface & v1) {
|
||
return (v0.name == v1.name && v0.address == v1.address && v0.netmask == v1.netmask);
|
||
}
|
||
inline bool operator!=(const PIEthernet::Interface & v0, const PIEthernet::Interface & v1) {
|
||
return (v0.name != v1.name || v0.address != v1.address || v0.netmask != v1.netmask);
|
||
}
|
||
|
||
#endif // PIETHERNET_H
|