00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020 #include "mac64-address.h"
00021 #include "address.h"
00022 #include "ns3/assert.h"
00023 #include <iomanip>
00024 #include <iostream>
00025 #include <string.h>
00026
00027 namespace ns3 {
00028
00029 #define ASCII_a (0x41)
00030 #define ASCII_z (0x5a)
00031 #define ASCII_A (0x61)
00032 #define ASCII_Z (0x7a)
00033 #define ASCII_COLON (0x3a)
00034 #define ASCII_ZERO (0x30)
00035
00036 static char
00037 AsciiToLowCase (char c)
00038 {
00039 if (c >= ASCII_a && c <= ASCII_z) {
00040 return c;
00041 } else if (c >= ASCII_A && c <= ASCII_Z) {
00042 return c + (ASCII_a - ASCII_A);
00043 } else {
00044 return c;
00045 }
00046 }
00047
00048
00049 Mac64Address::Mac64Address ()
00050 {
00051 memset (m_address, 0, 8);
00052 }
00053 Mac64Address::Mac64Address (const char *str)
00054 {
00055 int i = 0;
00056 while (*str != 0 && i < 8)
00057 {
00058 uint8_t byte = 0;
00059 while (*str != ASCII_COLON && *str != 0)
00060 {
00061 byte <<= 4;
00062 char low = AsciiToLowCase (*str);
00063 if (low >= ASCII_a)
00064 {
00065 byte |= low - ASCII_a + 10;
00066 }
00067 else
00068 {
00069 byte |= low - ASCII_ZERO;
00070 }
00071 str++;
00072 }
00073 m_address[i] = byte;
00074 i++;
00075 if (*str == 0)
00076 {
00077 break;
00078 }
00079 str++;
00080 }
00081 NS_ASSERT (i == 6);
00082 }
00083 void
00084 Mac64Address::CopyFrom (const uint8_t buffer[8])
00085 {
00086 memcpy (m_address, buffer, 8);
00087 }
00088 void
00089 Mac64Address::CopyTo (uint8_t buffer[8]) const
00090 {
00091 memcpy (buffer, m_address, 8);
00092 }
00093
00094 bool
00095 Mac64Address::IsMatchingType (const Address &address)
00096 {
00097 return address.CheckCompatible (GetType (), 8);
00098 }
00099 Mac64Address::operator Address () const
00100 {
00101 return ConvertTo ();
00102 }
00103 Mac64Address
00104 Mac64Address::ConvertFrom (const Address &address)
00105 {
00106 NS_ASSERT (address.CheckCompatible (GetType (), 8));
00107 Mac64Address retval;
00108 address.CopyTo (retval.m_address);
00109 return retval;
00110 }
00111 Address
00112 Mac64Address::ConvertTo (void) const
00113 {
00114 return Address (GetType (), m_address, 8);
00115 }
00116
00117 Mac64Address
00118 Mac64Address::Allocate (void)
00119 {
00120 static uint64_t id = 0;
00121 id++;
00122 Mac64Address address;
00123 address.m_address[0] = (id >> 56) & 0xff;
00124 address.m_address[1] = (id >> 48) & 0xff;
00125 address.m_address[2] = (id >> 40) & 0xff;
00126 address.m_address[3] = (id >> 32) & 0xff;
00127 address.m_address[4] = (id >> 24) & 0xff;
00128 address.m_address[5] = (id >> 16) & 0xff;
00129 address.m_address[6] = (id >> 8) & 0xff;
00130 address.m_address[7] = (id >> 0) & 0xff;
00131 return address;
00132 }
00133 uint8_t
00134 Mac64Address::GetType (void)
00135 {
00136 static uint8_t type = Address::Register ();
00137 return type;
00138 }
00139
00140 bool operator == (const Mac64Address &a, const Mac64Address &b)
00141 {
00142 uint8_t ada[8];
00143 uint8_t adb[8];
00144 a.CopyTo (ada);
00145 b.CopyTo (adb);
00146 return memcmp (ada, adb, 8) == 0;
00147 }
00148 bool operator != (const Mac64Address &a, const Mac64Address &b)
00149 {
00150 return ! (a == b);
00151 }
00152
00153 std::ostream& operator<< (std::ostream& os, const Mac64Address & address)
00154 {
00155 uint8_t ad[8];
00156 address.CopyTo (ad);
00157
00158 os.setf (std::ios::hex, std::ios::basefield);
00159 os.fill('0');
00160 for (uint8_t i=0; i < 7; i++)
00161 {
00162 os << std::setw(2) << (uint32_t)ad[i] << ":";
00163 }
00164
00165 os << std::setw(2) << (uint32_t)ad[7];
00166 os.setf (std::ios::dec, std::ios::basefield);
00167 os.fill(' ');
00168 return os;
00169 }
00170
00171
00172 }