00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021 #include "ns3/log.h"
00022 #include "ipv4-address.h"
00023 #include "ns3/assert.h"
00024
00025 NS_LOG_COMPONENT_DEFINE("Ipv4Address");
00026
00027 namespace ns3 {
00028
00029 #define ASCII_DOT (0x2e)
00030 #define ASCII_ZERO (0x30)
00031
00032 static uint32_t
00033 AsciiToIpv4Host (char const *address)
00034 {
00035 uint32_t host = 0;
00036 while (true) {
00037 uint8_t byte = 0;
00038 while (*address != ASCII_DOT &&
00039 *address != 0) {
00040 byte *= 10;
00041 byte += *address - ASCII_ZERO;
00042 address++;
00043 }
00044 host <<= 8;
00045 host |= byte;
00046 if (*address == 0) {
00047 break;
00048 }
00049 address++;
00050 }
00051 return host;
00052 }
00053
00054 }
00055
00056 namespace ns3 {
00057
00058 Ipv4Mask::Ipv4Mask ()
00059 : m_mask (0x66666666)
00060 {}
00061
00062 Ipv4Mask::Ipv4Mask (uint32_t mask)
00063 : m_mask (mask)
00064 {}
00065 Ipv4Mask::Ipv4Mask (char const *mask)
00066 {
00067 m_mask = AsciiToIpv4Host (mask);
00068 }
00069
00070 bool
00071 Ipv4Mask::IsEqual (Ipv4Mask other) const
00072 {
00073 if (other.m_mask == m_mask) {
00074 return true;
00075 } else {
00076 return false;
00077 }
00078 }
00079
00080 bool
00081 Ipv4Mask::IsMatch (Ipv4Address a, Ipv4Address b) const
00082 {
00083 if ((a.Get () & m_mask) == (b.Get () & m_mask)) {
00084 return true;
00085 } else {
00086 return false;
00087 }
00088 }
00089
00090 uint32_t
00091 Ipv4Mask::Get (void) const
00092 {
00093 return m_mask;
00094 }
00095 void
00096 Ipv4Mask::Set (uint32_t mask)
00097 {
00098 m_mask = mask;
00099 }
00100 uint32_t
00101 Ipv4Mask::GetInverse (void) const
00102 {
00103 return ~m_mask;
00104 }
00105
00106 void
00107 Ipv4Mask::Print (std::ostream &os) const
00108 {
00109 os << ((m_mask >> 24) & 0xff) << "."
00110 << ((m_mask >> 16) & 0xff) << "."
00111 << ((m_mask >> 8) & 0xff) << "."
00112 << ((m_mask >> 0) & 0xff);
00113 }
00114
00115
00116 Ipv4Mask
00117 Ipv4Mask::GetLoopback (void)
00118 {
00119 static Ipv4Mask loopback = Ipv4Mask ("255.0.0.0");
00120 return loopback;
00121 }
00122 Ipv4Mask
00123 Ipv4Mask::GetZero (void)
00124 {
00125 static Ipv4Mask zero = Ipv4Mask ("0.0.0.0");
00126 return zero;
00127 }
00128 Ipv4Mask
00129 Ipv4Mask::GetOnes (void)
00130 {
00131 static Ipv4Mask ones = Ipv4Mask ("255.255.255.255");
00132 return ones;
00133 }
00134
00135 Ipv4Address::Ipv4Address ()
00136 : m_address (0x66666666)
00137 {}
00138 Ipv4Address::Ipv4Address (uint32_t address)
00139 {
00140 m_address = address;
00141 }
00142 Ipv4Address::Ipv4Address (char const *address)
00143 {
00144 m_address = AsciiToIpv4Host (address);
00145 }
00146
00147 uint32_t
00148 Ipv4Address::Get (void) const
00149 {
00150 return m_address;
00151 }
00152 void
00153 Ipv4Address::Set (uint32_t address)
00154 {
00155 m_address = address;
00156 }
00157 void
00158 Ipv4Address::Set (char const *address)
00159 {
00160 m_address = AsciiToIpv4Host (address);
00161 }
00162
00163 Ipv4Address
00164 Ipv4Address::CombineMask (Ipv4Mask const &mask) const
00165 {
00166 return Ipv4Address (Get () & mask.Get ());
00167 }
00168
00169 Ipv4Address
00170 Ipv4Address::GetSubnetDirectedBroadcast (Ipv4Mask const &mask) const
00171 {
00172 if (mask == Ipv4Mask::GetOnes ())
00173 {
00174 NS_ASSERT_MSG (false, "Trying to get subnet-directed broadcast address with an all-ones netmask");
00175 }
00176 return Ipv4Address (Get () | mask.GetInverse ());
00177 }
00178
00179 bool
00180 Ipv4Address::IsSubnetDirectedBroadcast (Ipv4Mask const &mask) const
00181 {
00182 if (mask == Ipv4Mask::GetOnes ())
00183 {
00184
00185
00186 return false;
00187 }
00188 return ( (Get () | mask.GetInverse ()) == Get () );
00189 }
00190
00191 bool
00192 Ipv4Address::IsBroadcast (void) const
00193 {
00194 return (m_address == 0xffffffffU);
00195 }
00196
00197 bool
00198 Ipv4Address::IsMulticast (void) const
00199 {
00200
00201
00202
00203
00204 return (m_address >= 0xe0000000 && m_address <= 0xefffffff);
00205 }
00206
00207 void
00208 Ipv4Address::Serialize (uint8_t buf[4]) const
00209 {
00210 buf[0] = (m_address >> 24) & 0xff;
00211 buf[1] = (m_address >> 16) & 0xff;
00212 buf[2] = (m_address >> 8) & 0xff;
00213 buf[3] = (m_address >> 0) & 0xff;
00214 }
00215 Ipv4Address
00216 Ipv4Address::Deserialize (const uint8_t buf[4])
00217 {
00218 Ipv4Address ipv4;
00219 ipv4.m_address = 0;
00220 ipv4.m_address |= buf[0];
00221 ipv4.m_address <<= 8;
00222 ipv4.m_address |= buf[1];
00223 ipv4.m_address <<= 8;
00224 ipv4.m_address |= buf[2];
00225 ipv4.m_address <<= 8;
00226 ipv4.m_address |= buf[3];
00227 return ipv4;
00228 }
00229
00230 void
00231 Ipv4Address::Print (std::ostream &os) const
00232 {
00233 os << ((m_address >> 24) & 0xff) << "."
00234 << ((m_address >> 16) & 0xff) << "."
00235 << ((m_address >> 8) & 0xff) << "."
00236 << ((m_address >> 0) & 0xff);
00237 }
00238
00239 bool
00240 Ipv4Address::IsMatchingType (const Address &address)
00241 {
00242 return address.CheckCompatible (GetType (), 4);
00243 }
00244 Ipv4Address::operator Address () const
00245 {
00246 return ConvertTo ();
00247 }
00248
00249 Address
00250 Ipv4Address::ConvertTo (void) const
00251 {
00252 uint8_t buf[4];
00253 Serialize (buf);
00254 return Address (GetType (), buf, 4);
00255 }
00256
00257 Ipv4Address
00258 Ipv4Address::ConvertFrom (const Address &address)
00259 {
00260 NS_ASSERT (address.CheckCompatible (GetType (), 4));
00261 uint8_t buf[4];
00262 address.CopyTo (buf);
00263 return Deserialize (buf);
00264 }
00265
00266 uint8_t
00267 Ipv4Address::GetType (void)
00268 {
00269 static uint8_t type = Address::Register ();
00270 return type;
00271 }
00272
00273 Ipv4Address
00274 Ipv4Address::GetZero (void)
00275 {
00276 static Ipv4Address zero ("0.0.0.0");
00277 return zero;
00278 }
00279 Ipv4Address
00280 Ipv4Address::GetAny (void)
00281 {
00282 static Ipv4Address any ("0.0.0.0");
00283 return any;
00284 }
00285 Ipv4Address
00286 Ipv4Address::GetBroadcast (void)
00287 {
00288 static Ipv4Address broadcast ("255.255.255.255");
00289 return broadcast;
00290 }
00291 Ipv4Address
00292 Ipv4Address::GetLoopback (void)
00293 {
00294 Ipv4Address loopback ("127.0.0.1");
00295 return loopback;
00296 }
00297
00298 size_t Ipv4AddressHash::operator()(Ipv4Address const &x) const
00299 {
00300 return x.Get ();
00301 }
00302
00303 std::ostream& operator<< (std::ostream& os, Ipv4Address const& address)
00304 {
00305 address.Print (os);
00306 return os;
00307 }
00308 std::ostream& operator<< (std::ostream& os, Ipv4Mask const& mask)
00309 {
00310 mask.Print (os);
00311 return os;
00312 }
00313 std::istream & operator >> (std::istream &is, Ipv4Address &address)
00314 {
00315 std::string str;
00316 is >> str;
00317 address = Ipv4Address (str.c_str ());
00318 return is;
00319 }
00320 std::istream & operator >> (std::istream &is, Ipv4Mask &mask)
00321 {
00322 std::string str;
00323 is >> str;
00324 mask = Ipv4Mask (str.c_str ());
00325 return is;
00326 }
00327
00328 bool operator == (Ipv4Mask const &a, Ipv4Mask const &b)
00329 {
00330 return a.IsEqual (b);
00331 }
00332 bool operator != (Ipv4Mask const &a, Ipv4Mask const &b)
00333 {
00334 return !a.IsEqual (b);
00335 }
00336
00337 ATTRIBUTE_HELPER_CPP (Ipv4Address);
00338 ATTRIBUTE_HELPER_CPP (Ipv4Mask);
00339
00340 }