proxygen: folly::MacAddress Class Reference

#include <MacAddress.h>

Public Member Functions
	MacAddress ()

	MacAddress (StringPiece str)

const uint8_t *	bytes () const

uint64_t	u64NBO () const

uint64_t	u64HBO () const

std::string	toString () const

void	parse (StringPiece str)

void	setFromBinary (ByteRange value)

bool	isBroadcast () const

bool	isMulticast () const

bool	isUnicast () const

bool	isLocallyAdministered () const

bool	operator== (const MacAddress &other) const

bool	operator< (const MacAddress &other) const

bool	operator!= (const MacAddress &other) const

bool	operator> (const MacAddress &other) const

bool	operator>= (const MacAddress &other) const

bool	operator<= (const MacAddress &other) const

Static Public Member Functions
static MacAddress	fromBinary (ByteRange value)

static MacAddress	fromNBO (uint64_t value)

static MacAddress	fromHBO (uint64_t value)

static MacAddress	createMulticast (IPAddressV6 addr)

Static Public Attributes
static constexpr size_t	SIZE = 6

static const MacAddress	BROADCAST {Endian::big(uint64_t(0xffffffffffffU))}

static const MacAddress	ZERO

Private Member Functions
	MacAddress (uint64_t valueNBO)

uint64_t	getByte (size_t index) const

uint64_t	packedBytes () const

Private Attributes
unsigned char	bytes_ [8]

Detailed Description

Definition at line 31 of file MacAddress.h.

Constructor & Destructor Documentation

folly::MacAddress::MacAddress ( )

inline

Definition at line 40 of file MacAddress.h.

References bytes_.

Referenced by fromHBO(), and fromNBO().

                {
     memset(&bytes_, 0, 8);
   }

folly::MacAddress::MacAddress ( StringPiece str )

explicit

Definition at line 34 of file MacAddress.cpp.

References bytes_, and parse().

                                       {
   memset(&bytes_, 0, 8);
   parse(str);
 }

folly::MacAddress::MacAddress ( uint64_t valueNBO )

inlineexplicitprivate

Definition at line 197 of file MacAddress.h.

References bytes_.

                                          {
     memcpy(&bytes_, &valueNBO, 8);
     // Set the pad bytes to 0.
     // This allows us to easily compare two MacAddresses,
     // without having to worry about differences in the padding.
     bytes_[0] = 0;
     bytes_[1] = 0;
   }

Member Function Documentation

const uint8_t* folly::MacAddress::bytes ( ) const

inline

Definition at line 100 of file MacAddress.h.

References bytes_.

Referenced by folly::IPAddressV6::AddressStorage::AddressStorage(), createMulticast(), and testMAC().

                                {
     return bytes_ + 2;
   }

MacAddress folly::MacAddress::createMulticast ( IPAddressV6 addr )

static

Definition at line 39 of file MacAddress.cpp.

References bytes(), folly::IPAddressV6::bytes(), fromBinary(), folly::IPAddressV6::isMulticast(), SIZE, and uint8_t.

Referenced by fromHBO().

                                                          {
   // This method should only be used for multicast addresses.
   DCHECK(v6addr.isMulticast());
 
   uint8_t bytes[SIZE];
   bytes[0] = 0x33;
   bytes[1] = 0x33;
   memcpy(bytes + 2, v6addr.bytes() + 12, 4);
   return fromBinary(ByteRange(bytes, SIZE));
 }

static MacAddress folly::MacAddress::fromBinary ( ByteRange value )

inlinestatic

Definition at line 55 of file MacAddress.h.

References setFromBinary().

Referenced by createMulticast(), and folly::IPAddressV6::getMacAddressFromEUI64().

                                                 {
     MacAddress ret;
     ret.setFromBinary(value);
     return ret;
   }

static MacAddress folly::MacAddress::fromHBO ( uint64_t value )

inlinestatic

Definition at line 83 of file MacAddress.h.

References addr, folly::Endian::big(), createMulticast(), and MacAddress().

                                             {
     return MacAddress(Endian::big(value));
   }

static MacAddress folly::MacAddress::fromNBO ( uint64_t value )

inlinestatic

Definition at line 70 of file MacAddress.h.

References MacAddress().

                                             {
     return MacAddress(value);
   }

uint64_t folly::MacAddress::getByte ( size_t index ) const

inlineprivate

Definition at line 212 of file MacAddress.h.

Referenced by isLocallyAdministered(), isMulticast(), and toString().

                                               {
     return bytes_[index + 2];
   }

bool folly::MacAddress::isBroadcast ( ) const

inline

Definition at line 144 of file MacAddress.h.

References BROADCAST.

                            {
     return *this == BROADCAST;
   }

bool folly::MacAddress::isLocallyAdministered ( ) const

inline

Definition at line 164 of file MacAddress.h.

References getByte().

                                      {
     return getByte(0) & 0x2;
   }

bool folly::MacAddress::isMulticast ( ) const

inline

Definition at line 147 of file MacAddress.h.

References getByte().

Referenced by isUnicast().

                            {
     return getByte(0) & 0x1;
   }

bool folly::MacAddress::isUnicast ( ) const

inline

Definition at line 150 of file MacAddress.h.

References isMulticast().

                          {
     return !isMulticast();
   }

bool folly::MacAddress::operator!= ( const MacAddress & other ) const

inline

Definition at line 180 of file MacAddress.h.

                                                  {
     return !(*this == other);
   }

bool folly::MacAddress::operator< ( const MacAddress & other ) const

inline

Definition at line 176 of file MacAddress.h.

References u64HBO().

                                                 {
     return u64HBO() < other.u64HBO();
   }

bool folly::MacAddress::operator<= ( const MacAddress & other ) const

inline

Definition at line 192 of file MacAddress.h.

                                                  {
     return !(*this > other);
   }

bool folly::MacAddress::operator== ( const MacAddress & other ) const

inline

Definition at line 170 of file MacAddress.h.

References packedBytes().

                                                  {
     // All constructors and modifying methods make sure padding is 0,
     // so we don't need to mask these bytes out when comparing here.
     return packedBytes() == other.packedBytes();
   }

bool folly::MacAddress::operator> ( const MacAddress & other ) const

inline

Definition at line 184 of file MacAddress.h.

                                                 {
     return other < *this;
   }

bool folly::MacAddress::operator>= ( const MacAddress & other ) const

inline

Definition at line 188 of file MacAddress.h.

                                                  {
     return !(*this < other);
   }

uint64_t folly::MacAddress::packedBytes ( ) const

inlineprivate

Definition at line 216 of file MacAddress.h.

References uint64_t.

Referenced by operator==(), u64HBO(), and u64NBO().

                                {
     uint64_t u64;
     memcpy(&u64, bytes_, 8);
     return u64;
   }

void folly::MacAddress::parse ( StringPiece str )

Definition at line 74 of file MacAddress.cpp.

References folly::Range< Iter >::begin(), c, folly::Range< Iter >::end(), folly::detail::hexTable, setFromBinary(), folly::sformat(), SIZE, and uint8_t.

Referenced by MacAddress(), and u64HBO().

                                       {
   // Helper function to convert a single hex char into an integer
   auto isSeparatorChar = [](char c) { return c == ':' || c == '-'; };
 
   uint8_t parsed[SIZE];
   auto p = str.begin();
   for (unsigned int byteIndex = 0; byteIndex < SIZE; ++byteIndex) {
     if (p == str.end()) {
       throw invalid_argument(
           sformat("invalid MAC address '{}': not enough digits", str));
     }
 
     // Skip over ':' or '-' separators between bytes
     if (byteIndex != 0 && isSeparatorChar(*p)) {
       ++p;
       if (p == str.end()) {
         throw invalid_argument(
             sformat("invalid MAC address '{}': not enough digits", str));
       }
     }
 
     // Parse the upper nibble
     uint8_t upper = detail::hexTable[static_cast<uint8_t>(*p)];
     if (upper & 0x10) {
       throw invalid_argument(
           sformat("invalid MAC address '{}': contains non-hex digit", str));
     }
     ++p;
 
     // Parse the lower nibble
     uint8_t lower;
     if (p == str.end()) {
       lower = upper;
       upper = 0;
     } else {
       lower = detail::hexTable[static_cast<uint8_t>(*p)];
       if (lower & 0x10) {
         // Also accept ':', '-', or '\0', to handle the case where one
         // of the bytes was represented by just a single digit.
         if (isSeparatorChar(*p)) {
           lower = upper;
           upper = 0;
         } else {
           throw invalid_argument(
               sformat("invalid MAC address '{}': contains non-hex digit", str));
         }
       }
       ++p;
     }
 
     // Update parsed with the newly parsed byte
     parsed[byteIndex] = (upper << 4) | lower;
   }
 
   if (p != str.end()) {
     // String is too long to be a MAC address
     throw invalid_argument(
         sformat("invalid MAC address '{}': found trailing characters", str));
   }
 
   // Only update now that we have successfully parsed the entire
   // string.  This way we remain unchanged on error.
   setFromBinary(ByteRange(parsed, SIZE));
 }

void folly::MacAddress::setFromBinary ( ByteRange value )

Definition at line 139 of file MacAddress.cpp.

References folly::Range< Iter >::begin(), bytes_, folly::sformat(), SIZE, and folly::Range< Iter >::size().

Referenced by fromBinary(), parse(), and u64HBO().

                                               {
   if (value.size() != SIZE) {
     throw invalid_argument(
         sformat("MAC address must be 6 bytes long, got ", value.size()));
   }
   memcpy(bytes_ + 2, value.begin(), SIZE);
 }

string folly::MacAddress::toString ( ) const

Definition at line 50 of file MacAddress.cpp.

References getByte().

Referenced by folly::operator<<(), folly::toAppend(), and u64HBO().

                                   {
   static const char hexValues[] = "0123456789abcdef";
   string result;
   result.resize(17);
   result[0] = hexValues[getByte(0) >> 4];
   result[1] = hexValues[getByte(0) & 0xf];
   result[2] = ':';
   result[3] = hexValues[getByte(1) >> 4];
   result[4] = hexValues[getByte(1) & 0xf];
   result[5] = ':';
   result[6] = hexValues[getByte(2) >> 4];
   result[7] = hexValues[getByte(2) & 0xf];
   result[8] = ':';
   result[9] = hexValues[getByte(3) >> 4];
   result[10] = hexValues[getByte(3) & 0xf];
   result[11] = ':';
   result[12] = hexValues[getByte(4) >> 4];
   result[13] = hexValues[getByte(4) & 0xf];
   result[14] = ':';
   result[15] = hexValues[getByte(5) >> 4];
   result[16] = hexValues[getByte(5) & 0xf];
   return result;
 }

uint64_t folly::MacAddress::u64HBO ( ) const

inline

Definition at line 122 of file MacAddress.h.

References folly::Endian::big(), packedBytes(), parse(), setFromBinary(), string, toString(), and folly::value().

Referenced by std::hash< folly::MacAddress >::operator()(), operator<(), and testMAC().

                           {
     // Endian::big() does what we want here, even though we are converting
     // from big-endian to host byte order.  This swaps if and only if
     // the host byte order is little endian.
     return Endian::big(packedBytes());
   }

uint64_t folly::MacAddress::u64NBO ( ) const

inline

Definition at line 110 of file MacAddress.h.

References packedBytes().

Referenced by testMAC().

                           {
     return packedBytes();
   }

Member Data Documentation

const MacAddress folly::MacAddress::BROADCAST {Endian::big(uint64_t(0xffffffffffffU))}

static

Definition at line 34 of file MacAddress.h.

Referenced by isBroadcast().

unsigned char folly::MacAddress::bytes_[8]

private

Definition at line 210 of file MacAddress.h.

Referenced by bytes(), MacAddress(), and setFromBinary().

constexpr size_t folly::MacAddress::SIZE = 6

static

Definition at line 33 of file MacAddress.h.

Referenced by createMulticast(), parse(), and setFromBinary().

const MacAddress folly::MacAddress::ZERO

static

Definition at line 35 of file MacAddress.h.

The documentation for this class was generated from the following files:

proxygen/folly/folly/MacAddress.h
proxygen/folly/folly/MacAddress.cpp

Public Member Functions

Static Public Member Functions

Static Public Attributes

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation