src/networkAddress.cpp

   1 /*
   2  *  anytun
   3  *
   4  *  The secure anycast tunneling protocol (satp) defines a protocol used
   5  *  for communication between any combination of unicast and anycast
   6  *  tunnel endpoints.  It has less protocol overhead than IPSec in Tunnel
   7  *  mode and allows tunneling of every ETHER TYPE protocol (e.g.
   8  *  ethernet, ip, arp ...). satp directly includes cryptography and
   9  *  message authentication based on the methodes used by SRTP.  It is
  10  *  intended to deliver a generic, scaleable and secure solution for
  11  *  tunneling and relaying of packets of any protocol.
  12  *
  13  *
  14  *  Copyright (C) 2007-2009 Othmar Gsenger, Erwin Nindl,
  15  *                          Christian Pointner <satp@wirdorange.org>
  16  *
  17  *  This file is part of Anytun.
  18  *
  19  *  Anytun is free software: you can redistribute it and/or modify
  20  *  it under the terms of the GNU General Public License as published by
  21  *  the Free Software Foundation, either version 3 of the License, or
  22  *  any later version.
  23  *
  24  *  Anytun is distributed in the hope that it will be useful,
  25  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  26  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  27  *  GNU General Public License for more details.
  28  *
  29  *  You should have received a copy of the GNU General Public License
  30  *  along with anytun.  If not, see <http://www.gnu.org/licenses/>.
  31  */
  32
  33 #include "threadUtils.hpp"
  34 #include "datatypes.h"
  35 #include <exception>
  36
  37 #include "networkAddress.h"
  38 #include "anytunError.h"
  39
  40 NetworkAddress::NetworkAddress():ipv4_address_(),ipv6_address_()
  41 {
  42   network_address_type_=ipv4;
  43 }
  44
  45 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_)
  46 {
  47 }
  48
  49 NetworkAddress::NetworkAddress(const std::string& address)
  50 {
  51   boost::asio::ip::address addr = boost::asio::ip::address::from_string(address);
  52   if(addr.is_v4()) {
  53     network_address_type_=ipv4;
  54     ipv4_address_ = addr.to_v4();
  55   } else {
  56     network_address_type_=ipv6;
  57     ipv6_address_ = addr.to_v6();
  58   }
  59 }
  60
  61 NetworkAddress::NetworkAddress(boost::asio::ip::address_v6 ipv6_address)
  62 {
  63   network_address_type_=ipv6;
  64   ipv6_address_ = ipv6_address;
  65 }
  66
  67 NetworkAddress::NetworkAddress(boost::asio::ip::address_v4 ipv4_address)
  68 {
  69   network_address_type_=ipv4;
  70   ipv4_address_ = ipv4_address;
  71 }
  72
  73 NetworkAddress::NetworkAddress(uint64_t ethernet_address)
  74 {
  75   network_address_type_=ethernet;
  76   ethernet_address_=ethernet_address;
  77 }
  78
  79
  80 NetworkAddress::~NetworkAddress()
  81 {
  82 }
  83
  84 NetworkAddress::NetworkAddress(const network_address_type_t type, const std::string& address)
  85 {
  86   setNetworkAddress(type, address);
  87 }
  88
  89 void NetworkAddress::setNetworkAddress(const network_address_type_t type, const std::string& address)
  90 {
  91   if(type==ipv4) {
  92     ipv4_address_=boost::asio::ip::address_v4::from_string(address);
  93   } else if(type==ipv6) {
  94     ipv6_address_=boost::asio::ip::address_v6::from_string(address);
  95   } else if(type==ethernet) {
  96     //TODO
  97   } else {
  98     //TODO
  99   }
 100   network_address_type_ = type;
 101 }
 102
 103 void NetworkAddress::setNetworkAddress(boost::asio::ip::address_v4 addr)
 104 {
 105   network_address_type_=ipv4;
 106   ipv4_address_ = addr;
 107 }
 108
 109 void NetworkAddress::setNetworkAddress(boost::asio::ip::address_v6 addr)
 110 {
 111   network_address_type_=ipv6;
 112   ipv6_address_ = addr;
 113 }
 114
 115 void NetworkAddress::setNetworkAddress(uint64_t addr)
 116 {
 117   network_address_type_=ethernet;
 118   ethernet_address_=addr;
 119 }
 120
 121 network_address_type_t NetworkAddress::getNetworkAddressType() const
 122 {
 123   return network_address_type_;
 124 }
 125
 126 const boost::asio::ip::address_v4& NetworkAddress::getNetworkAddressV4() const
 127 {
 128   if(network_address_type_ != ipv4) {
 129     AnytunError::throwErr() << "wrong address type";
 130   }
 131
 132   return ipv4_address_;
 133 }
 134
 135 const boost::asio::ip::address_v6& NetworkAddress::getNetworkAddressV6() const
 136 {
 137   if(network_address_type_ != ipv6) {
 138     AnytunError::throwErr() << "wrong address type";
 139   }
 140
 141   return ipv6_address_;
 142 }
 143
 144 const uint64_t NetworkAddress::getNetworkAdrressEther() const
 145 {
 146   if(network_address_type_ != ethernet) {
 147     AnytunError::throwErr() << "wrong address type";
 148   }
 149
 150   return ethernet_address_;
 151 }
 152
 153 std::string NetworkAddress::toString() const
 154 {
 155   if(network_address_type_==ipv4) {
 156     return ipv4_address_.to_string();
 157   } else if(network_address_type_==ipv6) {
 158     return ipv6_address_.to_string();
 159   } else if(network_address_type_==ethernet) {
 160     // TODO
 161   }
 162   return std::string("");
 163 }
 164
 165 ipv4_bytes_type NetworkAddress::to_bytes_v4() const
 166 {
 167   return ipv4_address_.to_bytes();
 168 }
 169
 170 ipv6_bytes_type NetworkAddress::to_bytes_v6() const
 171 {
 172   return ipv6_address_.to_bytes();
 173 }
 174
 175 ethernet_bytes_type     NetworkAddress::to_bytes_ethernet() const
 176 {
 177   boost::array<unsigned char,6> result;
 178   uint64_t ether=ethernet_address_;
 179   for(int i = 0; i < 6; i++) {
 180     result[i] = (unsigned char)(ether && 0xff);
 181     ether >>= 8;
 182   }
 183   return result;
 184 }
 185
 186 bool NetworkAddress::operator<(const NetworkAddress& right) const
 187 {
 188   if(network_address_type_!=right.network_address_type_) {
 189     AnytunError::throwErr() << "NetworkAddress::operator<() address types don't match";
 190   }
 191   if(network_address_type_==ipv4) {
 192     return (ipv4_address_ < right.ipv4_address_);
 193   } else if(network_address_type_==ipv6) {
 194     return (ipv6_address_ < right.ipv6_address_);
 195   } else if(network_address_type_==ethernet) {
 196     return (ethernet_address_ < right.ethernet_address_);
 197   } else {
 198     //TODO
 199   }
 200   return false;
 201 }
 202