X-Git-Url: https://git.syn-net.org/debian/?a=blobdiff_plain;f=src%2FroutingTable.cpp;h=ea60e039e8b96232b9694de33593b0857522547d;hb=74b165bb1a2b001b52ee01eb56ee3ea59a81d10f;hp=c64366dc7a51d2f18ed9ec898078c24dfd7cf902;hpb=f9ad69dfae6bcec427652b0c4230603e465bd544;p=anytun.git diff --git a/src/routingTable.cpp b/src/routingTable.cpp index c64366d..ea60e03 100644 --- a/src/routingTable.cpp +++ b/src/routingTable.cpp @@ -6,12 +6,12 @@ * tunnel endpoints. It has less protocol overhead than IPSec in Tunnel * mode and allows tunneling of every ETHER TYPE protocol (e.g. * ethernet, ip, arp ...). satp directly includes cryptography and - * message authentication based on the methodes used by SRTP. It is + * message authentication based on the methods used by SRTP. It is * intended to deliver a generic, scaleable and secure solution for * tunneling and relaying of packets of any protocol. * * - * Copyright (C) 2007-2009 Othmar Gsenger, Erwin Nindl, + * Copyright (C) 2007-2014 Markus Grüneis, Othmar Gsenger, Erwin Nindl, * Christian Pointner * * This file is part of Anytun. @@ -27,8 +27,22 @@ * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License - * along with anytun. If not, see . + * along with Anytun. If not, see . + * + * In addition, as a special exception, the copyright holders give + * permission to link the code of portions of this program with the + * OpenSSL library under certain conditions as described in each + * individual source file, and distribute linked combinations + * including the two. + * You must obey the GNU General Public License in all respects + * for all of the code used other than OpenSSL. If you modify + * file(s) with this exception, you may extend this exception to your + * version of the file(s), but you are not obligated to do so. If you + * do not wish to do so, delete this exception statement from your + * version. If you delete this exception statement from all source + * files in the program, then also delete it here. */ + #include "networkPrefix.h" #include "threadUtils.hpp" #include "datatypes.h" @@ -37,19 +51,12 @@ #include "routingTable.h" #include "routingTree.hpp" -RoutingTable* RoutingTable::inst = NULL; -Mutex RoutingTable::instMutex; RoutingTable& gRoutingTable = RoutingTable::instance(); - RoutingTable& RoutingTable::instance() { - Lock lock(instMutex); - static instanceCleaner c; - if(!inst) - inst = new RoutingTable(); - - return *inst; + static RoutingTable instance; + return instance; } RoutingTable::RoutingTable() @@ -58,137 +65,140 @@ RoutingTable::RoutingTable() RoutingTable::~RoutingTable() { -} +} -void RoutingTable::updateRouteTreeUnlocked(const NetworkPrefix & pref) +void RoutingTable::updateRouteTreeUnlocked(const NetworkPrefix& pref) { //Lock lock(mutex_); //deadlock - u_int8_t length=pref.getNetworkPrefixLength(); - network_address_type_t type=pref.getNetworkAddressType(); - u_int16_t mux = routes_[pref.getNetworkAddressType()].find(pref)->second; - RoutingTreeNode * node = &(root_[type]); - if (type==ipv4) - { - ipv4_bytes_type bytes(pref.to_bytes_v4()); - if (length>32) - length=32; - RoutingTree::walk(bytes, node, length, mux); - } else if (type==ipv6) { - ipv6_bytes_type bytes(pref.to_bytes_v6()); - if (length>128) - length=128; - RoutingTree::walk(bytes, node, length, mux); - } else if (type==ethernet) { - ethernet_bytes_type bytes(pref.to_bytes_ethernet()); - if (length>48) - length=48; - RoutingTree::walk(bytes, node, length, mux); - } else { - AnytunError::throwErr() << "illegal protocol type"; - } - //root_[type].print(0); + uint8_t length=pref.getNetworkPrefixLength(); + network_address_type_t type=pref.getNetworkAddressType(); + uint16_t mux = routes_[pref.getNetworkAddressType()].find(pref)->second; + RoutingTreeNode* node = &(root_[type]); + if(type==ipv4) { + ipv4_bytes_type bytes(pref.to_bytes_v4()); + if(length>32) { + length=32; + } + RoutingTree::walk(bytes, node, length, mux); + } else if(type==ipv6) { + ipv6_bytes_type bytes(pref.to_bytes_v6()); + if(length>128) { + length=128; + } + RoutingTree::walk(bytes, node, length, mux); + } else if(type==ethernet) { + ethernet_bytes_type bytes(pref.to_bytes_ethernet()); + if(length>48) { + length=48; + } + RoutingTree::walk(bytes, node, length, mux); + } else { + AnytunError::throwErr() << "illegal protocol type"; + } + //root_[type].print(0); } -void RoutingTable::addRoute(const NetworkPrefix & pref, u_int16_t mux) +void RoutingTable::addRoute(const NetworkPrefix& pref, uint16_t mux) { Lock lock(mutex_); - - network_address_type_t type=pref.getNetworkAddressType(); - if (type==ipv4 || type==ipv6) - { + network_address_type_t type=pref.getNetworkAddressType(); + + if(type==ipv4 || type==ipv6) { std::pair ret = routes_[type].insert(RoutingMap::value_type(pref,mux)); - if(!ret.second) - { + if(!ret.second) { routes_[pref.getNetworkAddressType()].erase(ret.first); routes_[pref.getNetworkAddressType()].insert(RoutingMap::value_type(pref,mux)); } - root_[pref.getNetworkAddressType()]=RoutingTreeNode(); - RoutingMap::iterator it = routes_[type].begin(); - for (;it!=routes_[pref.getNetworkAddressType()].end();++it) - updateRouteTreeUnlocked(it->first); - } else if (type==ethernet) { + root_[pref.getNetworkAddressType()]=RoutingTreeNode(); + RoutingMap::iterator it = routes_[type].begin(); + for(; it!=routes_[pref.getNetworkAddressType()].end(); ++it) { + updateRouteTreeUnlocked(it->first); + } + } else if(type==ethernet) { return; // TODO: add support for ethernet - } else { - AnytunError::throwErr() << "illegal protocol type"; - } + } else { + AnytunError::throwErr() << "illegal protocol type"; + } } -void RoutingTable::delRoute(const NetworkPrefix & pref ) +void RoutingTable::delRoute(const NetworkPrefix& pref) { Lock lock(mutex_); - - routes_[pref.getNetworkAddressType()].erase(routes_[pref.getNetworkAddressType()].find(pref)); + + routes_[pref.getNetworkAddressType()].erase(routes_[pref.getNetworkAddressType()].find(pref)); } -u_int16_t RoutingTable::getRoute(const NetworkAddress & addr) +uint16_t RoutingTable::getRoute(const NetworkAddress& addr) { - Lock lock(mutex_); - network_address_type_t type=addr.getNetworkAddressType(); - - if (routes_[type].empty()) - AnytunError::throwErr() << "no route"; - - if (type==ipv4) - { - ipv4_bytes_type bytes(addr.to_bytes_v4()); - return RoutingTree::find(bytes, root_[type]); - } else if (type==ipv6) { - ipv6_bytes_type bytes(addr.to_bytes_v6()); - return RoutingTree::find(bytes, root_[type]); - } else if (type==ethernet) { - //TODO Our model wont fit to ethernet addresses well. - // maybe use hashmap or something like that instead - ethernet_bytes_type bytes(addr.to_bytes_ethernet()); - return RoutingTree::find(bytes, root_[type]); - } else { - AnytunError::throwErr() << "illegal protocol type"; - } + Lock lock(mutex_); + network_address_type_t type=addr.getNetworkAddressType(); + + if(routes_[type].empty()) { + AnytunError::throwErr() << "no route"; + } + + if(type==ipv4) { + ipv4_bytes_type bytes(addr.to_bytes_v4()); + return RoutingTree::find(bytes, root_[type]); + } else if(type==ipv6) { + ipv6_bytes_type bytes(addr.to_bytes_v6()); + return RoutingTree::find(bytes, root_[type]); + } else if(type==ethernet) { + //TODO Our model wont fit to ethernet addresses well. + // maybe use hashmap or something like that instead + ethernet_bytes_type bytes(addr.to_bytes_ethernet()); + return RoutingTree::find(bytes, root_[type]); + } else { + AnytunError::throwErr() << "illegal protocol type"; + } return 0; } -u_int16_t* RoutingTable::getOrNewRoutingTEUnlocked(const NetworkPrefix & addr) +uint16_t* RoutingTable::getOrNewRoutingTEUnlocked(const NetworkPrefix& addr) { RoutingMap::iterator it = routes_[addr.getNetworkAddressType()].find(addr); - if(it!=routes_[addr.getNetworkAddressType()].end()) + if(it!=routes_[addr.getNetworkAddressType()].end()) { return &(it->second); + } routes_[addr.getNetworkAddressType()].insert(RoutingMap::value_type(addr, 1)); it = routes_[addr.getNetworkAddressType()].find(addr); return &(it->second); } -u_int16_t RoutingTable::getCountUnlocked(network_address_type_t type) +uint16_t RoutingTable::getCountUnlocked(network_address_type_t type) { - RoutingMap::iterator it = routes_[type].begin(); - u_int16_t routes=0; - for (;it!=routes_[type].end();++it) - routes++; - return routes; + RoutingMap::iterator it = routes_[type].begin(); + uint16_t routes=0; + for(; it!=routes_[type].end(); ++it) { + routes++; + } + return routes; } RoutingMap::iterator RoutingTable::getBeginUnlocked(network_address_type_t type) { - return routes_[type].begin(); + return routes_[type].begin(); } RoutingMap::iterator RoutingTable::getEndUnlocked(network_address_type_t type) { - return routes_[type].end(); + return routes_[type].end(); } void RoutingTable::clear(network_address_type_t type) { Lock lock(mutex_); - routes_[type].clear(); + routes_[type].clear(); } bool RoutingTable::empty(network_address_type_t type) { Lock lock(mutex_); - return routes_[type].empty(); + return routes_[type].empty(); } Mutex& RoutingTable::getMutex()