SHS/pip
4
3
Fork 0
Code Issues 67 Pull Requests 1 Actions Releases Wiki Activity

git-svn-id: svn://db.shs.com.ru/pip@633 12ceb7fc-bf1f-11e4-8940-5bc7170c53b5

Browse Source
This commit is contained in:
Пелипенко Иван
2018-09-27 20:58:09 +00:00
parent 08592aae9a
commit ffe5b1d691
6 changed files with 515 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

52
src_main/io_utils/piethutilbase.cpp Normal file
View File

@@ -0,0 +1,52 @@
/*
PIP - Platform Independent Primitives
Base class for ethernet utils
Copyright (C) 2018 Ivan Pelipenko peri4ko@yandex.ru
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU 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 General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "piethutilbase.h"
#include "picrypt.h"
PIEthUtilBase::PIEthUtilBase() {
_crypt = false;
}
PIEthUtilBase::~PIEthUtilBase() {
}
void PIEthUtilBase::createCryptKey(const PIString & k) {
_key = PICrypt::hash("sodium_bug");
_key = PICrypt::hash(k);
_crypt = true;
}
PIByteArray PIEthUtilBase::cryptData(const PIByteArray & data) {
if (!_crypt) return data;
return PICrypt::crypt(data, _key);
}
PIByteArray PIEthUtilBase::decryptData(const PIByteArray & data) {
if (!_crypt) return data;
bool ok = false;
PIByteArray ret = PICrypt::decrypt(data, _key, &ok);
if (!ok) return PIByteArray();
return ret;
}

52
src_main/io_utils/piethutilbase.h Normal file
View File

@@ -0,0 +1,52 @@
/*! \file piethutilbase.h
* \brief Base class for ethernet utils
*/
/*
PIP - Platform Independent Primitives
Base class for ethernet utils
Copyright (C) 2018 Ivan Pelipenko peri4ko@yandex.ru
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU 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 General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef PIETHUTILBASE_H
#define PIETHUTILBASE_H
#include "pibytearray.h"
class PIEthUtilBase {
public:
PIEthUtilBase();
~PIEthUtilBase();
void setCryptEnabled(bool on) {_crypt = on;}
void cryptEnable() {setCryptEnabled(true);}
void cryptDisable() {setCryptEnabled(false);}
bool isCryptEnabled() const {return _crypt;}
void setCryptKey(const PIByteArray & k) {_key = k;}
void createCryptKey(const PIString & k);
PIByteArray cryptKey() const {return _key;}
protected:
PIByteArray cryptData(const PIByteArray & data);
PIByteArray decryptData(const PIByteArray & data);
private:
PIByteArray _key;
bool _crypt;
};
#endif // PIETHUTILBASE_H

178
src_main/io_utils/pimulticast.cpp Normal file
View File

@@ -0,0 +1,178 @@
/*
PIP - Platform Independent Primitives
Multicast for all interfaces, including loopback
Copyright (C) 2018 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 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 General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "pimulticast.h"
#define MULTICAST_TTL 4
PIMulticast::PIMulticast(bool send_only): PIThread(), PIEthUtilBase() {
eth_lo = 0;
_send_only = send_only;
mcast_address.set("232.13.3.14", 14100);
lo_port = 14200;
lo_pcnt = 5;
_started = false;
_reinit = true;
//initMcast(PIEthernet::allAddresses());
PIThread::start(3000);
}
PIMulticast::~PIMulticast() {
PIThread::stop();
mcast_mutex.unlock();
destroyAll();
}
void PIMulticast::destroyAll() {
piForeach (PIEthernet * e, eth_mcast) {
e->stopThreadedRead();
delete e;
}
eth_mcast.clear();
if (eth_lo) {
eth_lo->stopThreadedRead();
delete eth_lo;
eth_lo = 0;
}
}
void PIMulticast::initAll(PIVector<PIEthernet::Address> al) {
PIMutexLocker ml(mcast_mutex);
destroyAll();
_reinit = false;
prev_al = al;
al.removeAll(PIEthernet::Address("127.0.0.1"));
al << mcast_address;
eth_mcast.clear();
PIEthernet::InterfaceList ifaces = PIEthernet::interfaces();
piForeachC (PIEthernet::Address & a, al) {
// piCout << "mcast try" << a;
PIEthernet * ce = new PIEthernet();
ce->setDebug(false);
ce->setName("PIMulticast_" + a.toString());
ce->setParameters(0);
ce->setSendAddress(mcast_address);
ce->setMulticastTTL(MULTICAST_TTL);
if (!_send_only) {
ce->setReadAddress(a.ipString(), mcast_address.port());
ce->joinMulticastGroup(mcast_address.ipString());
// piCout << "mcast " << ce->readAddress() << ce->sendAddress();
if (ce->open()) {
eth_mcast << ce;
CONNECTU(ce, threadedReadEvent, this, mcastRead);
} else {
delete ce;
}
} else {
eth_mcast << ce;
}
ce = new PIEthernet();
ce->setDebug(false);
ce->setName("PIMulticast_" + a.toString());
ce->setParameters(PIEthernet::Broadcast);
const PIEthernet::Interface * cint = ifaces.getByAddress(a.ipString());
PIEthernet::Address nm((cint == 0) ? "255.255.255.0" : cint->netmask);
ce->setSendAddress(PIEthernet::getBroadcast(a, nm).ipString(), bcast_port);
if (!_send_only) {
ce->setReadAddress(PIEthernet::Address(a.ip(), bcast_port));
// piCout << "bcast " << ce->readAddress() << ce->sendAddress();
if (ce->open()) {
eth_mcast << ce;
CONNECTU(ce, threadedReadEvent, this, mcastRead);
} else {
delete ce;
}
} else {
eth_mcast << ce;
}
}
eth_lo = new PIEthernet();
eth_lo->setDebug(false);
ce->setName("PIMulticast_loopback");
if (!_send_only) {
eth_lo->setParameter(PIEthernet::ReuseAddress, false);
CONNECTU(eth_lo, threadedReadEvent, this, mcastRead);
for (int i = 0; i < lo_pcnt; ++i) {
eth_lo->setReadAddress("127.0.0.1", lo_port + i);
if (eth_lo->open()) {
// piCout << "bind local to" << (lo_port + i);
break;
}
}
}
}
void PIMulticast::send(const PIByteArray & data) {
PIByteArray cd = cryptData(data);
if (cd.isEmpty()) return;
piForeach (PIEthernet * e, eth_mcast)
e->send(cd);
if (eth_lo) {
for (int i = 0; i < lo_pcnt; ++i) {
eth_lo->send("127.0.0.1", lo_port + i, cd);
}
}
}
void PIMulticast::startRead() {
if (_send_only) return;
piForeach (PIEthernet * e, eth_mcast)
e->startThreadedRead();
if (eth_lo)
eth_lo->startThreadedRead();
_started = true;
}
void PIMulticast::stopRead() {
piForeach (PIEthernet * e, eth_mcast)
e->stopThreadedRead();
if (eth_lo)
eth_lo->stopThreadedRead();
_started = false;
}
void PIMulticast::reinit() {
}
void PIMulticast::mcastRead(uchar * data, int size) {
PIByteArray cd = decryptData(PIByteArray(data, size));
if (cd.isEmpty()) return;
received(cd);
receiveEvent(cd);
}
void PIMulticast::run() {
PIVector<PIEthernet::Address> al = PIEthernet::allAddresses();
if (al == prev_al) return;
initAll(al);
if (_started)
startRead();
}

79
src_main/io_utils/pimulticast.h Normal file
View File

@@ -0,0 +1,79 @@
/*! \file pimulticast.h
* \brief Multicast for all interfaces, including loopback
*/
/*
PIP - Platform Independent Primitives
Multicast for all interfaces, including loopback
Copyright (C) 2018 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 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 General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef PIMULTICAST_H
#define PIMULTICAST_H
#include "piethutilbase.h"
#include "piethernet.h"
#define SMDEVICE_PORT 22555
class PIMulticast: public PIThread, public PIEthUtilBase {
PIOBJECT(PIMulticast)
public:
PIMulticast(bool send_only = false);
~PIMulticast();
void setMulticastGroup(const PIString & mg) {mcast_address.setIP(mg);}
PIString multicastGroup() const {return mcast_address.ipString();}
void setMulticastPort(ushort port) {mcast_address.setPort(port);}
ushort multicastPort() const {return mcast_address.port();}
void setMulticastAddress(const PIEthernet::Address & addr) {mcast_address = addr;}
PIEthernet::Address multicastAddress() const {return mcast_address;}
void setBroadcastPort(ushort port) {bcast_port = port;}
ushort broadcastPort() {return bcast_port;}
void setLoopbackPort(ushort port) {lo_port = port;}
ushort loopbackPort() {return lo_port;}
void setLoopbackPortsCount(int count) {lo_pcnt = count;}
int loopbackPortsCount() const {return lo_pcnt;}
void startRead();
void stopRead();
void reinit();
void send(const PIByteArray & data);
EVENT1(receiveEvent, PIByteArray, data)
protected:
virtual void received(PIByteArray data) {}
private:
EVENT_HANDLER2(void, mcastRead, uchar * , data, int, size);
void destroyAll();
void initAll(PIVector<PIEthernet::Address> al);
void run();
PIEthernet::Address mcast_address;
PIMutex mcast_mutex;
PIVector<PIEthernet*> eth_mcast;
PIEthernet * eth_lo;
PIVector<PIEthernet::Address> prev_al;
ushort lo_port, bcast_port;
int lo_pcnt;
bool _started, _send_only, _reinit;
};
#endif // PIMULTICAST_H

94
src_main/io_utils/pistreampacker.cpp Normal file
View File

@@ -0,0 +1,94 @@
/*
PIP - Platform Independent Primitives
Simple packet wrap aroud any PIIODevice
Copyright (C) 2018 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 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 General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "pistreampacker.h"
#include "piiodevice.h"
PIStreamPacker::PIStreamPacker(PIIODevice * dev): PIObject() {
packet_size = -1;
max_packet_size = 1000;
packet_sign = 0xAFBE;
assignDevice(dev);
}
void PIStreamPacker::send(const PIByteArray &data) {
if (data.isEmpty()) return;
PIByteArray cd = cryptData(data);
//piCout << "crypt" << data.size() << "->" << cd.size() << key().size();
PIByteArray hdr, part;
hdr << packet_sign << int(cd.size_s());
cd.insert(0, hdr);
int pcnt = (cd.size_s() - 1) / max_packet_size + 1, pst = 0;
for (int i = 0; i < pcnt; ++i) {
if (i == pcnt - 1) part = PIByteArray(cd.data(pst), cd.size_s() - pst);
else part = PIByteArray(cd.data(pst), max_packet_size);
//piCout << "send" << part.size();
sendRequest(part);
pst += max_packet_size;
}
}
void PIStreamPacker::received(const PIByteArray & data) {
stream.append(data);
//piCout << "rec" << data.size();
while (stream.size_s() >= 4) {
if (packet_size < 0) {
ushort sign(0);
memcpy(&sign, stream.data(), 2);
if (sign != packet_sign) {
stream.pop_front();
continue;
}
int sz = -1;
memcpy(&sz, stream.data(2), 4);
if (sz < 0) {
stream.pop_front();
continue;
}
stream.remove(0, 6);
packet.clear();
packet_size = sz;
if (packet_size == 0)
packet_size = -1;
continue;
} else {
int ps = piMini(stream.size_s(), packet_size - packet.size_s());
packet.append(stream.data(), ps);
stream.remove(0, ps);
if (packet.size_s() == packet_size) {
PIByteArray cd = decryptData(packet);
//piCout << "decrypt" << packet.size() << "->" << cd.size() << key().size();
if (!cd.isEmpty()) packetReceiveEvent(cd);
packet.clear();
packet_size = -1;
}
}
}
}
void PIStreamPacker::assignDevice(PIIODevice * dev) {
if (!dev) return;
CONNECTU(dev, threadedReadEvent, this, received);
CONNECTU(this, sendRequest, dev, write);
}

60
src_main/io_utils/pistreampacker.h Normal file
View File

@@ -0,0 +1,60 @@
/*! \file pistreampacker.h
* \brief Simple packet wrap aroud any PIIODevice
*/
/*
PIP - Platform Independent Primitives
Simple packet wrap aroud any PIIODevice
Copyright (C) 2018 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 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 General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef PISTREAMPACKER_H
#define PISTREAMPACKER_H
#include "piobject.h"
#include "piethutilbase.h"
class PIIODevice;
class PIStreamPacker: public PIObject, public PIEthUtilBase {
PIOBJECT(PIStreamPacker)
public:
PIStreamPacker(PIIODevice * dev = 0);
int maxPacketSize() {return max_packet_size;}
void setMaxPacketSize(int max_size) {max_packet_size = max_size;}
ushort packetSign() {return packet_sign;}
void setPacketSign(ushort sign_) {packet_sign = sign_;}
void send(const PIByteArray & data);
void received(const PIByteArray & data);
EVENT_HANDLER2(void, received, uchar * , readed, int, size) {received(PIByteArray(readed, size));}
void assignDevice(PIIODevice * dev);
EVENT1(packetReceiveEvent, PIByteArray, data)
EVENT1(sendRequest, PIByteArray, data)
protected:
PIByteArray stream, packet;
int packet_size;
ushort packet_sign;
int max_packet_size;
};
#endif // PISTREAMPACKER_H