diff --git a/libretroshare/src/dht/p3bitdht.cc b/libretroshare/src/dht/p3bitdht.cc index a9d26e1c2..22b674a6d 100644 --- a/libretroshare/src/dht/p3bitdht.cc +++ b/libretroshare/src/dht/p3bitdht.cc @@ -59,6 +59,13 @@ virtual int dhtValueCallback(const bdNodeId *id, std::string key, uint32_t statu return mParent->ValueCallback(id, key, status); } +virtual int dhtConnectCallback(const bdId *srcId, const bdId *proxyId, const bdId *destId, + uint32_t mode, uint32_t point, uint32_t cbtype) +{ + // nothing here fore now! + //return mParent->ValueCallback(id, key, status); +} + private: p3BitDht *mParent; diff --git a/libretroshare/src/pqi/sslfns.cc b/libretroshare/src/pqi/sslfns.cc index c977e1bd2..82b734840 100644 --- a/libretroshare/src/pqi/sslfns.cc +++ b/libretroshare/src/pqi/sslfns.cc @@ -585,7 +585,9 @@ X509 *loadX509FromDER(const uint8_t *ptr, uint32_t len) X509 *tmp = NULL; #ifdef __APPLE__ - unsigned char **certptr = (unsigned char **) &ptr; + // This depends on which version you are compiling for... OSX10.5 doesn't have consts (old OpenSSL!) + //unsigned char **certptr = (unsigned char **) &ptr; + const unsigned char **certptr = (const unsigned char **) &ptr; #else const unsigned char **certptr = (const unsigned char **) &ptr; #endif diff --git a/libretroshare/src/tcponudp/udppeer.h b/libretroshare/src/tcponudp/udppeer.h index 73124f18b..e4357fa34 100644 --- a/libretroshare/src/tcponudp/udppeer.h +++ b/libretroshare/src/tcponudp/udppeer.h @@ -70,4 +70,32 @@ int status(std::ostream &out); }; + +class UdpRelayReceiver: public UdpSubReceiver, public UdpPublisher +{ + public: + + UdpRelayReceiver(UdpPublisher *pub); +virtual ~UdpRelayReceiver() { return; } + + /* add a TCPonUDP stream */ +int addUdpPeer(UdpPeer *peer, const struct sockaddr_in &raddr); +int removeUdpPeer(UdpPeer *peer); + + /* callback for recved data (overloaded from UdpReceiver) */ +virtual int recvPkt(void *data, int size, struct sockaddr_in &from); + + /* wrapper function for relay (overloaded from UdpPublisher) */ +virtual int sendPkt(const void *data, int size, struct sockaddr_in &to, int ttl); + +int status(std::ostream &out); + + private: + + RsMutex peerMtx; /* for all class data (below) */ + + std::map streams; + +}; + #endif diff --git a/libretroshare/src/tcponudp/udprelay.cc b/libretroshare/src/tcponudp/udprelay.cc new file mode 100644 index 000000000..622cf25b7 --- /dev/null +++ b/libretroshare/src/tcponudp/udprelay.cc @@ -0,0 +1,386 @@ +/* + * tcponudp/udprelay.cc + * + * libretroshare. + * + * Copyright 2010 by Robert Fernie + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License Version 3 as published by the Free Software Foundation. + * + * This library 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 + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 + * USA. + * + * Please report all bugs and problems to "retroshare@lunamutt.com". + * + */ + +#include "udppeer.h" +#include + +/* + * #define DEBUG_UDP_PEER 1 + */ + + +UdpPeerReceiver::UdpPeerReceiver(UdpPublisher *pub) + :UdpSubReceiver(pub) +{ + return; +} + +/* higher level interface */ +int UdpPeerReceiver::recvPkt(void *data, int size, struct sockaddr_in &from) +{ + /* print packet information */ +#ifdef DEBUG_UDP_PEER + std::cerr << "UdpPeerReceiver::recvPkt(" << size << ") from: " << from; + std::cerr << std::endl; +#endif + + RsStackMutex stack(peerMtx); /********** LOCK MUTEX *********/ + + /* look for a peer */ + std::map::iterator it; + it = streams.find(from); + + if (it == streams.end()) + { + /* peer unknown */ +#ifdef DEBUG_UDP_PEER + std::cerr << "UdpPeerReceiver::recvPkt() Peer Unknown!"; + std::cerr << std::endl; +#endif + return 0; + } + else + { + /* forward to them */ +#ifdef DEBUG_UDP_PEER + std::cerr << "UdpPeerReceiver::recvPkt() Sending to UdpPeer: "; + std::cerr << it->first; + std::cerr << std::endl; +#endif + (it->second)->recvPkt(data, size); + return 1; + } + /* done */ +} + + +int UdpPeerReceiver::status(std::ostream &out) +{ + RsStackMutex stack(peerMtx); /********** LOCK MUTEX *********/ + + out << "UdpPeerReceiver::status()" << std::endl; + out << "UdpPeerReceiver::peers:" << std::endl; + std::map::iterator it; + for(it = streams.begin(); it != streams.end(); it++) + { + out << "\t" << it->first << std::endl; + } + out << std::endl; + + return 1; +} + + /* add a TCPonUDP stream */ +int UdpPeerReceiver::addUdpPeer(UdpPeer *peer, const struct sockaddr_in &raddr) +{ + RsStackMutex stack(peerMtx); /********** LOCK MUTEX *********/ + + + /* check for duplicate */ + std::map::iterator it; + it = streams.find(raddr); + bool ok = (it == streams.end()); + if (!ok) + { +#ifdef DEBUG_UDP_PEER + std::cerr << "UdpPeerReceiver::addUdpPeer() Peer already exists!" << std::endl; + std::cerr << "UdpPeerReceiver::addUdpPeer() ERROR" << std::endl; +#endif + } + else + { + streams[raddr] = peer; + } + + return ok; +} + +int UdpPeerReceiver::removeUdpPeer(UdpPeer *peer) +{ + RsStackMutex stack(peerMtx); /********** LOCK MUTEX *********/ + + /* check for duplicate */ + std::map::iterator it; + for(it = streams.begin(); it != streams.end(); it++) + { + if (it->second == peer) + { +#ifdef DEBUG_UDP_PEER + std::cerr << "UdpPeerReceiver::removeUdpPeer() SUCCESS" << std::endl; +#endif + streams.erase(it); + return 1; + } + } + +#ifdef DEBUG_UDP_PEER + std::cerr << "UdpPeerReceiver::removeUdpPeer() ERROR" << std::endl; +#endif + return 0; +} + + + + + +/****************** UDP RELAY STUFF **********/ + +int UdpRelayReciever::checkRelays() +{ + RsStackMutex stack(peerMtx); /********** LOCK MUTEX *********/ + + /* iterate through the Relays */ + + out << "UdpRelayReceiver::checkRelays()" << std::endl; + + std::list eraseList; + std::map::iterator rit; + for(rit = mRelays.begin(); rit != mRelays.end(); rit++) + { + /* calc bandwidth */ + rit->second.mBandwidth = rit->second.mDataSize / (float) (now - rit->second.mLastBandwidthTS); + rit->second.mDataSize = 0; + rit->second.mLastBandwidthTS = now; + + if (rit->second.mBandwidth > RELAY_MAX_BANDWIDTH) + { + /* if exceeding bandwidth -> drop */ + eraseList.push_back(rit->first); + } + else if (now - rit->second.mLastTS > RELAY_TIMEOUT) + { + /* if haven't transmitted for ages -> drop */ + out << "\t" << rit->first << " : " << rit->second; + out << std::endl; + eraseList.push_back(rit->first); + } + } + + std::list::iterator it; + for(it = eraseList.begin(); it != eraseList.end(); it++) + { + /* find in Relay list */ + + /* rotate around and delete matching set */ + } +} + + +int UdpRelayReciever::addUdpRelay(UdpRelayAddrSet *addrSet) +{ + RsStackMutex stack(peerMtx); /********** LOCK MUTEX *********/ + + +} + +int UdpRelayReciever::removeUdpRelay(UdpRelayAddrSet *addrSet) +{ + RsStackMutex stack(peerMtx); /********** LOCK MUTEX *********/ + + +} + +int UdpRelayReciever::addRelayUdpPeer(UdpPeer *peer, UdpRelayAddrSet *addrSet) +{ + RsStackMutex stack(peerMtx); /********** LOCK MUTEX *********/ + + + +} + +int UdpRelayReceiver::removeRelayUdpPeer(UdpPeer *peer) +{ + RsStackMutex stack(peerMtx); /********** LOCK MUTEX *********/ + + /* check for duplicate */ + std::map::iterator it; + for(it = mStreams.begin(); it != mStreams.end(); it++) + { + if (it->second == peer) + { +#ifdef DEBUG_UDP_RELAY + std::cerr << "UdpRelayReceiver::removeUdpPeer() SUCCESS" << std::endl; +#endif + mStreams.erase(it); + return 1; + } + } + +#ifdef DEBUG_UDP_RELAY + std::cerr << "UdpRelayReceiver::removeUdpPeer() ERROR" << std::endl; +#endif + return 0; +} + + +int UdpRelayReceiver::status(std::ostream &out) +{ + RsStackMutex stack(peerMtx); /********** LOCK MUTEX *********/ + + out << "UdpRelayReceiver::status()" << std::endl; + out << "UdpRelayReceiver::Relayed Connections:" << std::endl; + + std::map::iterator rit; + + for(rit = mRelays.begin(); rit != mRelays.end(); rit++) + { + out << "\t" << rit->first << " : " << rit->second; + out << std::endl; + } + + out << "UdpRelayReceiver::Connections:" << std::endl; + + std::map::iterator pit; + for(pit = mStreams.begin(); pit != mStreams.end(); pit++) + { + out << "\t" << pit->first << " : " << pit->second; + out << std::endl; + } + + return 1; +} + +/* higher level interface */ +int UdpRelayReceiver::recvPkt(void *data, int size, struct sockaddr_in &from) +{ + /* print packet information */ +#ifdef DEBUG_UDP_RELAY + std::cerr << "UdpRelayReceiver::recvPkt(" << size << ") from: " << from; + std::cerr << std::endl; +#endif + + RsStackMutex stack(peerMtx); /********** LOCK MUTEX *********/ + + /* decide if we are the relay, or the endpoint */ + UdpRelayAddrSet addrSet; + if (!extractUdpRelayAddrSet(data, size, addrSet)) + { + /* fails most basic test, drop */ + return 0; + } + + /* lookup relay first (double entries) */ + std::map::iterator rit = mRelays.find(addrSet); + if (rit != mRelays.end()) + { + /* we are the relay */ +#ifdef DEBUG_UDP_RELAY + std::cerr << "UdpRelayReceiver::recvPkt() We are the Relay. Passing onto: "; + std::cerr << it->second.endpoint; + std::cerr << std::endl; +#endif + /* do accounting */ + it->second.mLastTS = now; + it->second.mDataSize += size; + + mPublisher->sendPkt(data, size, it->second.endpoint, STD_TTL); + return 1; + } + + /* otherwise we are likely to be the endpoint */ + std::map::iterator pit = mStreams.find(addrSet); + if (pit != mStreams.end()) + { + /* we are the end-point */ +#ifdef DEBUG_UDP_RELAY + std::cerr << "UdpRelayReceiver::recvPkt() Sending to UdpPeer: "; + std::cerr << it->first; + std::cerr << std::endl; +#endif + /* remove the header */ + void *pktdata = (void *) (((uint8_t *) data) + RELAY_HEADER_SIZE); + int pktsize = size - RELAY_HEADER_SIZE; + if (pktsize > 0) + { + (it->second)->recvPkt(pktdata, pktsize); + } + else + { + /* packet undersized */ +#ifdef DEBUG_UDP_RELAY + std::cerr << "UdpRelayReceiver::recvPkt() ERROR Packet Undersized"; + std::cerr << std::endl; +#endif + } + return 1; + } + /* done */ + + /* unknown */ +#ifdef DEBUG_UDP_RELAY + std::cerr << "UdpRelayReceiver::recvPkt() Peer Unknown!"; + std::cerr << std::endl; +#endif + return 0; +} + + +int UdpRelayReceiver::sendPkt(const void *data, int size, sockaddr_in &to, int ttl) +{ + RsStackMutex stack(peerMtx); /********** LOCK MUTEX *********/ + + /* work out who the proxy is */ + std::map::iterator it; + it = mProxies.find(to); + if (it == mProxies.end()) + { + return 0; + } + + /* add a header to packet */ + char tmpPkt[MAXSIZE]; + int tmpSize = MAXSIZE; + + createRelayUdpPacket(data, size, tmpPkt, tmpSize, it->second); + + /* send the packet on */ + return mPublisher->send(tmpPkt, tmpSize, it->second.proxyAddr, STD_TTL); +} + +class UdpRelayAddrSet +{ + public: + + struct sockaddr_in srcAddr; + struct sockaddr_in proxyAddr; + struct sockaddr_in destAddr; +}; + + +int extractUdpRelayAddrSet(const void *data, const int size, UdpRelayAddrSet &addrSet) +{ + + + return 1; +} + +int createRelayUdpPacket(const void *data, const int size, void *newpkt, int *newsize, UdpRelayProxy &urp) +{ + + + + return 1; +} + diff --git a/libretroshare/src/tcponudp/udprelay.h b/libretroshare/src/tcponudp/udprelay.h new file mode 100644 index 000000000..49b11960e --- /dev/null +++ b/libretroshare/src/tcponudp/udprelay.h @@ -0,0 +1,58 @@ +#ifndef RS_UDP_RELAY_H +#define RS_UDP_RELAY_H + +/* + * tcponudp/udprelay.h + * + * libretroshare. + * + * Copyright 2010 by Robert Fernie + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License Version 3 as published by the Free Software Foundation. + * + * This library 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 + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 + * USA. + * + * Please report all bugs and problems to "retroshare@lunamutt.com". + * + */ + +#include "tcponudp/udppeer.h" + +class UdpRelayReceiver: public UdpSubReceiver, public UdpPublisher +{ + public: + + UdpRelayReceiver(UdpPublisher *pub); +virtual ~UdpRelayReceiver() { return; } + + /* add a TCPonUDP stream */ +int addUdpPeer(UdpPeer *peer, const struct sockaddr_in &raddr); +int removeUdpPeer(UdpPeer *peer); + + /* callback for recved data (overloaded from UdpReceiver) */ +virtual int recvPkt(void *data, int size, struct sockaddr_in &from); + + /* wrapper function for relay (overloaded from UdpPublisher) */ +virtual int sendPkt(const void *data, int size, struct sockaddr_in &to, int ttl); + +int status(std::ostream &out); + + private: + + RsMutex peerMtx; /* for all class data (below) */ + + std::map streams; + +}; + +#endif