X-Git-Url: https://git.syn-net.org/debian/?a=blobdiff_plain;f=src%2FnetworkAddress.cpp;h=349f1a8111b66e8641c491a0ed649c03927b0b54;hb=ad68eaec71b8cd401dcc4ee7a13bd0e18ce392b0;hp=770115929ea4fb6d11904c56022d37d880c931e0;hpb=bb834fe0ed7a38b724f49b944adb801634eb6194;p=anytun.git diff --git a/src/networkAddress.cpp b/src/networkAddress.cpp index 7701159..349f1a8 100644 --- a/src/networkAddress.cpp +++ b/src/networkAddress.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,7 +27,20 @@ * 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 "threadUtils.hpp" @@ -39,42 +52,41 @@ NetworkAddress::NetworkAddress():ipv4_address_(),ipv6_address_() { - network_address_type_=ipv4; + network_address_type_=ipv4; } -NetworkAddress::NetworkAddress(const NetworkAddress & ref) : mutex_(),ipv4_address_(ref.ipv4_address_),ipv6_address_(ref.ipv6_address_),ethernet_address_(ref.ethernet_address_),network_address_type_(ref.network_address_type_) +NetworkAddress::NetworkAddress(const NetworkAddress& ref) : mutex_(),ipv4_address_(ref.ipv4_address_),ipv6_address_(ref.ipv6_address_),ethernet_address_(ref.ethernet_address_),network_address_type_(ref.network_address_type_) { } -NetworkAddress::NetworkAddress(const std::string & address) +NetworkAddress::NetworkAddress(const std::string& address) { - boost::asio::ip::address addr = boost::asio::ip::address::from_string(address); - if (addr.is_v4()) - { - network_address_type_=ipv4; - ipv4_address_ = addr.to_v4(); - } else { - network_address_type_=ipv6; - ipv6_address_ = addr.to_v6(); - } + boost::asio::ip::address addr = boost::asio::ip::address::from_string(address); + if(addr.is_v4()) { + network_address_type_=ipv4; + ipv4_address_ = addr.to_v4(); + } else { + network_address_type_=ipv6; + ipv6_address_ = addr.to_v6(); + } } NetworkAddress::NetworkAddress(boost::asio::ip::address_v6 ipv6_address) { - network_address_type_=ipv6; - ipv6_address_ = ipv6_address; + network_address_type_=ipv6; + ipv6_address_ = ipv6_address; } NetworkAddress::NetworkAddress(boost::asio::ip::address_v4 ipv4_address) { - network_address_type_=ipv4; - ipv4_address_ = ipv4_address; + network_address_type_=ipv4; + ipv4_address_ = ipv4_address; } -NetworkAddress::NetworkAddress(u_int64_t ethernet_address) +NetworkAddress::NetworkAddress(uint64_t ethernet_address) { - network_address_type_=ethernet; - ethernet_address_=ethernet_address; + network_address_type_=ethernet; + ethernet_address_=ethernet_address; } @@ -82,123 +94,122 @@ NetworkAddress::~NetworkAddress() { } -NetworkAddress::NetworkAddress(const network_address_type_t type, const std::string & address ) +NetworkAddress::NetworkAddress(const network_address_type_t type, const std::string& address) { - setNetworkAddress( type, address); + setNetworkAddress(type, address); } -void NetworkAddress::setNetworkAddress(const network_address_type_t type, const std::string & address ) +void NetworkAddress::setNetworkAddress(const network_address_type_t type, const std::string& address) { - if (type==ipv4) - { - ipv4_address_=boost::asio::ip::address_v4::from_string(address); - } else if (type==ipv6) { - ipv6_address_=boost::asio::ip::address_v6::from_string(address); - } else if (type==ethernet) { - //TODO - } else { - //TODO - } - network_address_type_ = type; + if(type==ipv4) { + ipv4_address_=boost::asio::ip::address_v4::from_string(address); + } else if(type==ipv6) { + ipv6_address_=boost::asio::ip::address_v6::from_string(address); + } else if(type==ethernet) { + //TODO + } else { + //TODO + } + network_address_type_ = type; } void NetworkAddress::setNetworkAddress(boost::asio::ip::address_v4 addr) { - network_address_type_=ipv4; - ipv4_address_ = addr; + network_address_type_=ipv4; + ipv4_address_ = addr; } void NetworkAddress::setNetworkAddress(boost::asio::ip::address_v6 addr) { - network_address_type_=ipv6; - ipv6_address_ = addr; + network_address_type_=ipv6; + ipv6_address_ = addr; } -void NetworkAddress::setNetworkAddress(u_int64_t addr) +void NetworkAddress::setNetworkAddress(uint64_t addr) { - network_address_type_=ethernet; - ethernet_address_=addr; + network_address_type_=ethernet; + ethernet_address_=addr; } network_address_type_t NetworkAddress::getNetworkAddressType() const { - return network_address_type_; + return network_address_type_; } const boost::asio::ip::address_v4& NetworkAddress::getNetworkAddressV4() const { - if(network_address_type_ != ipv4) + if(network_address_type_ != ipv4) { AnytunError::throwErr() << "wrong address type"; - + } + return ipv4_address_; } const boost::asio::ip::address_v6& NetworkAddress::getNetworkAddressV6() const { - if(network_address_type_ != ipv6) + if(network_address_type_ != ipv6) { AnytunError::throwErr() << "wrong address type"; - + } + return ipv6_address_; } -const u_int64_t NetworkAddress::getNetworkAdrressEther() const +const uint64_t NetworkAddress::getNetworkAdrressEther() const { - if(network_address_type_ != ethernet) + if(network_address_type_ != ethernet) { AnytunError::throwErr() << "wrong address type"; - + } + return ethernet_address_; } std::string NetworkAddress::toString() const { - if (network_address_type_==ipv4){ - return ipv4_address_.to_string(); - } - else if (network_address_type_==ipv6) { - return ipv6_address_.to_string(); - } - else if (network_address_type_==ethernet) { - // TODO - } + if(network_address_type_==ipv4) { + return ipv4_address_.to_string(); + } else if(network_address_type_==ipv6) { + return ipv6_address_.to_string(); + } else if(network_address_type_==ethernet) { + // TODO + } return std::string(""); } ipv4_bytes_type NetworkAddress::to_bytes_v4() const { - return ipv4_address_.to_bytes(); + return ipv4_address_.to_bytes(); } ipv6_bytes_type NetworkAddress::to_bytes_v6() const { - return ipv6_address_.to_bytes(); + return ipv6_address_.to_bytes(); } ethernet_bytes_type NetworkAddress::to_bytes_ethernet() const { - boost::array result; - u_int64_t ether=ethernet_address_; - for (int i = 0; i < 6; i++) - { - result[i] = (unsigned char) (ether && 0xff); - ether >>= 8; - } - return result; -} - -bool NetworkAddress::operator<(const NetworkAddress &right) const -{ - if (network_address_type_!=right.network_address_type_) - AnytunError::throwErr() << "NetworkAddress::operator<() address types don't match"; - if (network_address_type_==ipv4) - { - return (ipv4_address_ < right.ipv4_address_); - } else if (network_address_type_==ipv6) { - return (ipv6_address_ < right.ipv6_address_); - } else if (network_address_type_==ethernet) { - return (ethernet_address_ < right.ethernet_address_); - } else { - //TODO - } - return false; + boost::array result; + uint64_t ether=ethernet_address_; + for(int i = 0; i < 6; i++) { + result[i] = (unsigned char)(ether & 0xff); + ether >>= 8; + } + return result; +} + +bool NetworkAddress::operator<(const NetworkAddress& right) const +{ + if(network_address_type_!=right.network_address_type_) { + AnytunError::throwErr() << "NetworkAddress::operator<() address types don't match"; + } + if(network_address_type_==ipv4) { + return (ipv4_address_ < right.ipv4_address_); + } else if(network_address_type_==ipv6) { + return (ipv6_address_ < right.ipv6_address_); + } else if(network_address_type_==ethernet) { + return (ethernet_address_ < right.ethernet_address_); + } else { + //TODO + } + return false; }