540 lines
18 KiB
C++
540 lines
18 KiB
C++
/*! \file piethernet.h
|
|
* \ingroup IO
|
|
* \~\brief
|
|
* \~english Ethernet device
|
|
* \~russian Устройство 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;
|
|
|
|
class PIP_EXPORT PIEthernet: public PIIODevice {
|
|
PIIODEVICE(PIEthernet, "eth");
|
|
friend class PIPeer;
|
|
|
|
public:
|
|
//! Contructs UDP %PIEthernet with empty read address
|
|
explicit PIEthernet();
|
|
|
|
//! \brief Type of %PIEthernet
|
|
enum Type {
|
|
UDP /** UDP - User Datagram Protocol */,
|
|
TCP_Client /** TCP client - allow connection to TCP server */,
|
|
TCP_Server /** TCP server - receive connections from TCP clients */
|
|
};
|
|
|
|
//! \brief Parameters of %PIEthernet
|
|
enum Parameters {
|
|
ReuseAddress /** Rebind address if there is already binded. Enabled by default */ = 0x1,
|
|
Broadcast /** Broadcast send. Disabled by default */ = 0x2,
|
|
SeparateSockets /** If this parameter is set, %PIEthernet will initialize two different sockets,
|
|
for receive and send, instead of single one. Disabled by default */
|
|
= 0x4,
|
|
MulticastLoop /** Enable receiving multicast packets from same host. Enabled by default */ = 0x8,
|
|
KeepConnection /** Automatic reconnect TCP connection on disconnect. Enabled by default */ = 0x10,
|
|
DisonnectOnTimeout /** Disconnect TCP connection on read timeout expired. Disabled by default */ = 0x20,
|
|
NoDelay /** Use NO_DELAY option. Disabled by default */ = 0x40
|
|
};
|
|
|
|
typedef ::PINetworkAddress Address DEPRECATEDM("use PINetworkAddress instead");
|
|
|
|
//! Contructs %PIEthernet with type "type", read address "ip_port" and parameters "params"
|
|
explicit PIEthernet(Type type,
|
|
const PIString & ip_port = PIString(),
|
|
const PIFlags<Parameters> params = PIEthernet::ReuseAddress | PIEthernet::MulticastLoop |
|
|
PIEthernet::KeepConnection);
|
|
|
|
virtual ~PIEthernet();
|
|
|
|
|
|
//! Set read address
|
|
void setReadAddress(const PIString & ip, int port) {
|
|
addr_r.set(ip, port);
|
|
setPath(addr_r.toString());
|
|
}
|
|
|
|
//! Set read address in format "i.i.i.i:p"
|
|
void setReadAddress(const PIString & ip_port) {
|
|
addr_r.set(ip_port);
|
|
setPath(addr_r.toString());
|
|
}
|
|
|
|
//! Set read address
|
|
void setReadAddress(const PINetworkAddress & addr) {
|
|
addr_r = addr;
|
|
setPath(addr_r.toString());
|
|
}
|
|
|
|
//! Set read IP
|
|
void setReadIP(const PIString & ip) {
|
|
addr_r.setIP(ip);
|
|
setPath(addr_r.toString());
|
|
}
|
|
|
|
//! Set read port
|
|
void setReadPort(int port) {
|
|
addr_r.setPort(port);
|
|
setPath(addr_r.toString());
|
|
}
|
|
|
|
|
|
//! Set send address
|
|
void setSendAddress(const PIString & ip, int port) { addr_s.set(ip, port); }
|
|
|
|
//! Set send address in format "i.i.i.i:p"
|
|
void setSendAddress(const PIString & ip_port) { addr_s.set(ip_port); }
|
|
|
|
//! Set send address
|
|
void setSendAddress(const PINetworkAddress & addr) { addr_s = addr; }
|
|
|
|
//! Set send IP
|
|
void setSendIP(const PIString & ip) { addr_s.setIP(ip); }
|
|
|
|
//! Set send port
|
|
void setSendPort(int port) { addr_s.setPort(port); }
|
|
|
|
|
|
//! Returns read address in format "i.i.i.i:p"
|
|
PINetworkAddress readAddress() const { return addr_r; }
|
|
|
|
//! Returns read IP
|
|
PIString readIP() const { return addr_r.ipString(); }
|
|
|
|
//! Returns read port
|
|
int readPort() const { return addr_r.port(); }
|
|
|
|
|
|
//! Returns send address in format "i.i.i.i:p"
|
|
PINetworkAddress sendAddress() const { return addr_s; }
|
|
|
|
//! Returns send IP
|
|
PIString sendIP() const { return addr_s.ipString(); }
|
|
|
|
//! Returns send port
|
|
int sendPort() const { return addr_s.port(); }
|
|
|
|
|
|
//! Returns address of last received UDP packet in format "i.i.i.i:p"
|
|
PINetworkAddress lastReadAddress() const { return addr_lr; }
|
|
|
|
//! Returns IP of last received UDP packet
|
|
PIString lastReadIP() const { return addr_lr.ipString(); }
|
|
|
|
//! Returns port of last received UDP packet
|
|
int lastReadPort() const { return addr_lr.port(); }
|
|
|
|
|
|
//! Set parameters to "parameters_". You should to reopen %PIEthernet to apply them
|
|
void setParameters(PIFlags<PIEthernet::Parameters> parameters_) {
|
|
params = parameters_;
|
|
applyParameters();
|
|
}
|
|
|
|
//! Set parameter "parameter" to state "on". You should to reopen %PIEthernet to apply this
|
|
void setParameter(PIEthernet::Parameters parameter, bool on = true) {
|
|
params.setFlag(parameter, on);
|
|
applyParameters();
|
|
}
|
|
|
|
//! Returns if parameter "parameter" is set
|
|
bool isParameterSet(PIEthernet::Parameters parameter) const { return params[parameter]; }
|
|
|
|
//! Returns parameters
|
|
PIFlags<PIEthernet::Parameters> parameters() const { return params; }
|
|
|
|
//! Returns %PIEthernet type
|
|
Type type() const { return eth_type; }
|
|
|
|
//! Returns read timeout
|
|
PISystemTime readTimeout() const { return property("readTimeout").toSystemTime(); }
|
|
|
|
//! Returns write timeout
|
|
PISystemTime writeTimeout() const { return property("writeTimeout").toSystemTime(); }
|
|
|
|
//! Set timeout for read
|
|
void setReadTimeout(PISystemTime tm);
|
|
|
|
//! Set timeout for write
|
|
void setWriteTimeout(PISystemTime tm);
|
|
|
|
|
|
//! Set socket receive buffer size
|
|
void setReadBufferSize(int bytes);
|
|
|
|
//! Set socket send buffer size
|
|
void setWriteBufferSize(int bytes);
|
|
|
|
|
|
//! Returns TTL (Time To Live)
|
|
int TTL() const { return property("TTL").toInt(); }
|
|
|
|
//! Returns multicast TTL (Time To Live)
|
|
int multicastTTL() const { return property("MulticastTTL").toInt(); }
|
|
|
|
//! Set TTL (Time To Live), default is 64
|
|
void setTTL(int ttl) { setProperty("TTL", ttl); }
|
|
|
|
//! Set multicast TTL (Time To Live), default is 1
|
|
void setMulticastTTL(int ttl) { setProperty("MulticastTTL", ttl); }
|
|
|
|
|
|
//! Join to multicast group with address "group". Use only for UDP
|
|
bool joinMulticastGroup(const PIString & group);
|
|
|
|
//! Leave multicast group with address "group". Use only for UDP
|
|
bool leaveMulticastGroup(const PIString & group);
|
|
|
|
//! Returns joined multicast groups. Use only for UDP
|
|
const PIStringList & multicastGroups() const { return mcast_groups; }
|
|
|
|
|
|
//! If \"threaded\" queue connect to TCP server with address \a readAddress() in
|
|
//! any \a read() or \a write() call. Otherwise connect immediate.
|
|
//! Use only for TCP_Client
|
|
bool connect(bool threaded = true);
|
|
|
|
//! Connect to TCP server with address "ip":"port". Use only for TCP_Client
|
|
bool connect(const PIString & ip, int port, bool threaded = true) {
|
|
setPath(ip + PIStringAscii(":") + PIString::fromNumber(port));
|
|
return connect(threaded);
|
|
}
|
|
|
|
//! Connect to TCP server with address "ip_port". Use only for TCP_Client
|
|
bool connect(const PIString & ip_port, bool threaded = true) {
|
|
setPath(ip_port);
|
|
return connect(threaded);
|
|
}
|
|
|
|
//! Connect to TCP server with address "addr". Use only for TCP_Client
|
|
bool connect(const PINetworkAddress & addr, bool threaded = true) {
|
|
setPath(addr.toString());
|
|
return connect(threaded);
|
|
}
|
|
|
|
//! Returns if %PIEthernet connected to TCP server. Use only for TCP_Client
|
|
bool isConnected() const { return connected_; }
|
|
|
|
//! Returns if %PIEthernet is connecting to TCP server. Use only for TCP_Client
|
|
bool isConnecting() const { return connecting_; }
|
|
|
|
|
|
//! Start listen for incoming TCP connections on address \a readAddress(). Use only for TCP_Server
|
|
bool listen(bool threaded = false);
|
|
|
|
//! Start listen for incoming TCP connections on address "ip":"port". Use only for TCP_Server
|
|
bool listen(const PIString & ip, int port, bool threaded = false) { return listen(PINetworkAddress(ip, port), threaded); }
|
|
|
|
//! Start listen for incoming TCP connections on address "ip_port". Use only for TCP_Server
|
|
bool listen(const PIString & ip_port, bool threaded = false) { return listen(PINetworkAddress(ip_port), threaded); }
|
|
|
|
//! Start listen for incoming TCP connections on address "addr". Use only for TCP_Server
|
|
bool listen(const PINetworkAddress & addr, bool threaded = false);
|
|
|
|
void stopThreadedListen();
|
|
|
|
PIEthernet * client(int index);
|
|
int clientsCount() const;
|
|
PIVector<PIEthernet *> clients() const;
|
|
|
|
|
|
//! Send data "data" with size "size" to address \a sendAddress() for UDP or \a readAddress() for TCP_Client
|
|
bool send(const void * data, int size, bool threaded = false);
|
|
|
|
//! Send data "data" with size "size" to address "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);
|
|
}
|
|
|
|
//! Send data "data" with size "size" to address "ip_port"
|
|
bool send(const PIString & ip_port, const void * data, int size, bool threaded = false) {
|
|
return send(PINetworkAddress(ip_port), data, size, threaded);
|
|
}
|
|
|
|
//! Send data "data" with size "size" to address "addr"
|
|
bool send(const PINetworkAddress & addr, const void * data, int size, bool threaded = false);
|
|
|
|
//! Send data "data" to address \a sendAddress() for UDP or \a readAddress() for TCP_Client
|
|
bool send(const PIByteArray & data, bool threaded = false);
|
|
|
|
//! Send data "data" to address "ip":"port" for UDP
|
|
bool send(const PIString & ip, int port, const PIByteArray & data, bool threaded = false) {
|
|
return send(PINetworkAddress(ip, port), data, threaded);
|
|
}
|
|
|
|
//! Send data "data" to address "ip_port" for UDP
|
|
bool send(const PIString & ip_port, const PIByteArray & data, bool threaded = false) {
|
|
return send(PINetworkAddress(ip_port), data, threaded);
|
|
}
|
|
|
|
//! Send data "data" to address "addr" for UDP
|
|
bool send(const PINetworkAddress & addr, const PIByteArray & data, bool threaded = false);
|
|
|
|
bool canWrite() const override { return mode() & WriteOnly; }
|
|
|
|
void interrupt() override;
|
|
|
|
int socket() const { return sock; }
|
|
|
|
EVENT1(newConnection, PIEthernet *, client);
|
|
EVENT0(connected);
|
|
EVENT1(disconnected, bool, withError);
|
|
|
|
|
|
//! Flags of network interface
|
|
enum InterfaceFlag {
|
|
ifActive /** Is active */ = 0x1,
|
|
ifRunning /** Is running */ = 0x2,
|
|
ifBroadcast /** Support broadcast */ = 0x4,
|
|
ifMulticast /** Support multicast */ = 0x8,
|
|
ifLoopback /** Is loopback */ = 0x10,
|
|
ifPTP /** Is point-to-point */ = 0x20
|
|
};
|
|
|
|
//! %PIFlags of network interface flags
|
|
typedef PIFlags<InterfaceFlag> InterfaceFlags;
|
|
|
|
|
|
//! Network interface descriptor
|
|
struct PIP_EXPORT Interface {
|
|
//! System index
|
|
int index = -1;
|
|
|
|
//! MTU
|
|
int mtu = 0;
|
|
|
|
//! System name
|
|
PIString name;
|
|
|
|
//! MAC address in format "hh:hh:hh:hh:hh:hh" or empty if there is no MAC address
|
|
PIString mac;
|
|
|
|
//! IP address in format "i.i.i.i" or empty if there is no IP address
|
|
PIString address;
|
|
|
|
//! Netmask of IP address in format "i.i.i.i" or empty if there is no netmask
|
|
PIString netmask;
|
|
|
|
//! Broadcast address in format "i.i.i.i" or empty if there is no broadcast address
|
|
PIString broadcast;
|
|
|
|
//! Point-to-point address or empty if there is no point-to-point address
|
|
PIString ptp;
|
|
|
|
//! Flags of interface
|
|
InterfaceFlags flags;
|
|
|
|
//! Returns if interface is active
|
|
bool isValid() const { return name.isNotEmpty(); }
|
|
|
|
//! Returns if interface is active
|
|
bool isActive() const { return flags[PIEthernet::ifActive]; }
|
|
|
|
//! Returns if interface is running
|
|
bool isRunning() const { return flags[PIEthernet::ifRunning]; }
|
|
|
|
//! Returns if interface support broadcast
|
|
bool isBroadcast() const { return flags[PIEthernet::ifBroadcast]; }
|
|
|
|
//! Returns if interface support multicast
|
|
bool isMulticast() const { return flags[PIEthernet::ifMulticast]; }
|
|
|
|
//! Returns if interface is loopback
|
|
bool isLoopback() const { return flags[PIEthernet::ifLoopback]; }
|
|
|
|
//! Returns if interface is point-to-point
|
|
bool isPTP() const { return flags[PIEthernet::ifPTP]; }
|
|
};
|
|
|
|
|
|
//! Array of \a Interface with some features
|
|
class PIP_EXPORT InterfaceList: public PIVector<PIEthernet::Interface> {
|
|
public:
|
|
InterfaceList(): PIVector<PIEthernet::Interface>() {}
|
|
|
|
//! Get interface with system index "index" or 0 if there is no one
|
|
const Interface * getByIndex(int index) const {
|
|
for (int i = 0; i < size_s(); ++i)
|
|
if ((*this)[i].index == index) return &((*this)[i]);
|
|
return 0;
|
|
}
|
|
|
|
//! Get interface with system name "name" or 0 if there is no one
|
|
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;
|
|
}
|
|
|
|
//! Get interface with IP address "address" or 0 if there is no one
|
|
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;
|
|
}
|
|
|
|
//! Get loopback interface or 0 if there is no one
|
|
const Interface * getLoopback() const {
|
|
for (int i = 0; i < size_s(); ++i)
|
|
if ((*this)[i].isLoopback()) return &((*this)[i]);
|
|
return 0;
|
|
}
|
|
};
|
|
|
|
|
|
//! Returns all system network interfaces
|
|
static InterfaceList interfaces();
|
|
|
|
static PINetworkAddress interfaceAddress(const PIString & interface_);
|
|
|
|
//! Returns all system network IP addresses
|
|
static PIVector<PINetworkAddress> allAddresses();
|
|
|
|
static PIString macFromBytes(const PIByteArray & mac);
|
|
static PIByteArray macToBytes(const PIString & mac);
|
|
static PIString applyMask(const PIString & ip, const PIString & mask);
|
|
static PINetworkAddress applyMask(const PINetworkAddress & ip, const PINetworkAddress & mask);
|
|
static PIString getBroadcast(const PIString & ip, const PIString & mask);
|
|
static PINetworkAddress getBroadcast(const PINetworkAddress & ip, const PINetworkAddress & mask);
|
|
|
|
//! \events
|
|
//! \{
|
|
|
|
//! \fn void newConnection(PIEthernet * client)
|
|
//! \brief Raise on new TCP connection received
|
|
|
|
//! \fn void connected()
|
|
//! \brief Raise if succesfull TCP connection
|
|
|
|
//! \fn void disconnected(bool withError)
|
|
//! \brief Raise if TCP connection was closed
|
|
|
|
//! \}
|
|
//! \ioparams
|
|
//! \{
|
|
#ifdef DOXYGEN
|
|
//! \brief read ip, default ""
|
|
string ip;
|
|
|
|
//! \brief read port, default 0
|
|
int port;
|
|
|
|
//! \brief ethernet parameters
|
|
int parameters;
|
|
|
|
//! \brief read timeout, default 10 s
|
|
PISystemTime readTimeout;
|
|
|
|
//! \brief write timeout, default 10 s
|
|
PISystemTime writeTimeout;
|
|
|
|
//! \brief time-to-live, default 64
|
|
int TTL;
|
|
|
|
//! \brief time-to-live for multicast, default 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();
|
|
|
|
//! Executes when any read function was successful. Default implementation does nothing
|
|
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
|