OpenDDS::RTPS::GuidGenerator Class Reference

#include <GuidGenerator.h>

Collaboration diagram for OpenDDS::RTPS::GuidGenerator:

Public Member Functions
	GuidGenerator ()
int	interfaceName (const char *nic)
void	populate (DCPS::GUID_t &container)
ACE_UINT16	getCount (bool doIncrement=true)

Private Types
enum	{ NODE_ID_SIZE = 6 }
typedef unsigned char	Node_ID[NODE_ID_SIZE]

Private Attributes
Node_ID	node_id_
pid_t	pid_
ACE_Thread_Mutex	counter_lock_
ACE_UINT16	counter_
OPENDDS_STRING	interface_name_

Detailed Description

Generate GuidPrefix_t values for use with RTPS Also see GuidConverter.h in dds/DCPS 0 GUID_t.guidPrefix[ 0] == VendorId_t == 0x01 for OCI (used for OpenDDS) 1 GUID_t.guidPrefix[ 1] == VendorId_t == 0x03 for OCI (used for OpenDDS) 2 GUID_t.guidPrefix[ 2] == MAC Address 3 GUID_t.guidPrefix[ 3] == MAC Address 4 GUID_t.guidPrefix[ 4] == MAC Address 5 GUID_t.guidPrefix[ 5] == MAC Address 6 GUID_t.guidPrefix[ 6] == MAC Address 7 GUID_t.guidPrefix[ 7] == MAC Address 8 GUID_t.guidPrefix[ 8] == Process ID (MS byte) 9 GUID_t.guidPrefix[ 9] == Process ID (LS byte) 10 GUID_t.guidPrefix[10] == Counter (MS byte) 11 GUID_t.guidPrefix[11] == Counter (LS byte)

Definition at line 43 of file GuidGenerator.h.

Member Typedef Documentation

Node_ID

typedef unsigned char OpenDDS::RTPS::GuidGenerator::Node_ID[NODE_ID_SIZE]

private

Borrowed from ACE::UUID_Node, definition of the MAC address holder type

Definition at line 64 of file GuidGenerator.h.

Member Enumeration Documentation

anonymous enum

anonymous enum

private

Enumerator
NODE_ID_SIZE

Definition at line 60 of file GuidGenerator.h.

{NODE_ID_SIZE = 6};

Constructor & Destructor Documentation

GuidGenerator()

OpenDDS::RTPS::GuidGenerator::GuidGenerator

(

)

Definition at line 51 of file GuidGenerator.cpp.

References ACE_UINT16_MAX, counter_, ACE_OS::getmacaddress(), getpid(), ACE_OS::memcpy(), ACE_OS::macaddr_node_t::node, node_id_, NODE_ID_SIZE, pid_, and ACE_OS::rand_r().

  : pid_(ACE_OS::getpid())
{
  unsigned seed = static_cast<unsigned>(SystemTimePoint::now().value().usec() + reinterpret_cast<size_t>(this));

  if (pid_ == -1) {
    pid_ = static_cast<pid_t>(ACE_OS::rand_r(&seed));
  }

#ifdef ACE_HAS_CPP11
  std::mt19937 generator(seed);
  std::uniform_int_distribution<ACE_UINT16> distribution(0, ACE_UINT16_MAX);
  counter_ = distribution(generator);
#else
  counter_ = static_cast<ACE_UINT16>(ACE_OS::rand_r(&seed));
#endif

  ACE_OS::macaddr_node_t macaddress;
  const int result = ACE_OS::getmacaddress(&macaddress);

#ifndef ACE_HAS_IOS
  if (-1 != result) {
    ACE_OS::memcpy(node_id_, macaddress.node, NODE_ID_SIZE);
  } else {
    for (int i = 0; i < NODE_ID_SIZE; ++i) {
      node_id_[i] = static_cast<unsigned char>(ACE_OS::rand_r(&seed));
    }
  }
#else
  // iOS has non-unique MAC addresses
  ACE_UNUSED_ARG(result);

  for (int i = 0; i < NODE_ID_SIZE; ++i) {
    node_id_[i] = static_cast<unsigned char>(ACE_OS::rand_r(&seed));
  }
#endif /* ACE_HAS_IOS */
}

Member Function Documentation

getCount()

ACE_UINT16 OpenDDS::RTPS::GuidGenerator::getCount

(

bool

doIncrement = true

)

Definition at line 90 of file GuidGenerator.cpp.

References counter_, and counter_lock_.

Referenced by populate().

{
  ACE_Guard<ACE_Thread_Mutex> guard(counter_lock_);
  if (doIncrement) {
    ++counter_;
  }
  return counter_;
}

interfaceName()

int OpenDDS::RTPS::GuidGenerator::interfaceName

(

const char *

nic

)

override the MAC address to use a specific network interface instead of just the first (non-loopback) interface

Definition at line 100 of file GuidGenerator.cpp.

References ACE_ERROR, AF_INET, AF_UNSPEC, ACE_Wide_To_Ascii::char_rep(), ACE_OS::close(), OpenDDS::DCPS::LogLevel::Error, ACE_Allocator::free(), ACE_Allocator::instance(), interface_name_, ACE_OS::ioctl(), LM_ERROR, OpenDDS::DCPS::log_level, ACE_Allocator::malloc(), name, node_id_, PF_INET, SIOCGIFCONF, SIOCGIFHWADDR, SOCK_DGRAM, and ACE_OS::socket().

Referenced by OpenDDS::RTPS::RtpsDiscovery::add_domain_participant(), and OpenDDS::RTPS::RtpsDiscovery::generate_participant_guid().

{
  // A shortcut to determine if a *valid* interface was already checked.
  // The shortcut value (interface_name_) is stored IFF the method returns 0.
  if (interface_name_ == iface) {
    return 0;
  }

  // See ace/OS_NS_netdb.cpp ACE_OS::getmacaddress()
#if defined ACE_WIN32 && !defined ACE_HAS_WINCE
  ULONG size;
  if (::GetAdaptersAddresses(AF_UNSPEC, 0, 0, 0, &size)
      != ERROR_BUFFER_OVERFLOW) {
    return -1;
  }
  ACE_Allocator* const alloc = DCPS::SafetyProfilePool::instance();
  IP_ADAPTER_ADDRESSES* const addrs =
    static_cast<IP_ADAPTER_ADDRESSES*>(alloc->malloc(size));
  if (!addrs) {
    return -1;
  }
  if (::GetAdaptersAddresses(AF_UNSPEC, 0, 0, addrs, &size) != NO_ERROR) {
    alloc->free(addrs);
    return -1;
  }

  bool found = false;
  for (IP_ADAPTER_ADDRESSES* iter = addrs; iter && !found; iter = iter->Next) {
    if (ACE_Wide_To_Ascii(iter->FriendlyName).char_rep() == iface) {
      std::memcpy(node_id_, iter->PhysicalAddress,
                  std::min(static_cast<size_t>(iter->PhysicalAddressLength),
                           sizeof node_id_));
      found = true;
    }
  }

  alloc->free(addrs);
  if (found) {
    interface_name_ = iface;
    return 0;
  } else {
    return -1;
  }

#elif defined ACE_LINUX || defined ACE_ANDROID
  ifreq ifr;
  // Guarantee that iface will fit in ifr.ifr_name and still be null terminated
  // ifr.ifr_name is sized to IFNAMSIZ
  if (std::strlen(iface) >= sizeof(ifr.ifr_name)) {
    if (DCPS::log_level >= DCPS::LogLevel::Error) {
      ACE_ERROR((LM_ERROR, "(%P|%t) ERROR: GuidGenerator::interfaceName: "
        "Interface name %C exceeds max allowable length, must be < %d.\n",
        iface, IFNAMSIZ));
    }
    return -1;
  }
  std::strncpy(ifr.ifr_name, iface, sizeof(ifr.ifr_name));
  const ACE_HANDLE h = ACE_OS::socket(PF_INET, SOCK_DGRAM, 0);
  if (h == ACE_INVALID_HANDLE) {
    return -1;
  }
  if (ACE_OS::ioctl(h, SIOCGIFHWADDR, &ifr) < 0) {
    ACE_OS::close(h);
    return -1;
  }
  ACE_OS::close(h);
  std::memcpy(node_id_, ifr.ifr_addr.sa_data, sizeof node_id_);

  interface_name_ = iface;
  return 0;
#elif defined ACE_HAS_SIOCGIFCONF || defined ACE_HAS_MAC_OSX
  const ACE_HANDLE h = ACE_OS::socket(AF_INET, SOCK_DGRAM, 0);
  if (h == ACE_INVALID_HANDLE) {
    return -1;
  }

  const int BUFFERSIZE = 4000;
  char buffer[BUFFERSIZE];
  ifconf ifc;
  ifc.ifc_len = BUFFERSIZE;
  ifc.ifc_buf = buffer;

  if (ACE_OS::ioctl(h, SIOCGIFCONF, &ifc) < 0) {
    ACE_OS::close(h);
    return -1;
  }

  bool found = false;
  for (const char* ptr = buffer; !found && ptr < buffer + ifc.ifc_len;) {
    const ifreq* ifr = reinterpret_cast<const ifreq*>(ptr);
    if (ifr->ifr_addr.sa_family == AF_LINK && ifr->ifr_name == interface_name_) {
      const sockaddr_dl* sdl =
        reinterpret_cast<const sockaddr_dl*>(&ifr->ifr_addr);
      std::memcpy(node_id_, LLADDR(sdl), sizeof node_id_);
      found = true;
    }

    ptr += sizeof ifr->ifr_name + std::max(sizeof ifr->ifr_addr,
      static_cast<size_t>(ifr->ifr_addr.sa_len));
  }

  ACE_OS::close(h);

  if (found) {
    interface_name_ = iface;
    return 0;
  } else {
    return -1;
  }
#elif defined ACE_VXWORKS
  int name[] = {CTL_NET, AF_ROUTE, 0, 0, NET_RT_IFLIST, 0};
  static const size_t name_elts = sizeof name / sizeof name[0];

  size_t result_sz = 0u;
  if (sysctl(name, name_elts, 0, &result_sz, 0, 0u) != 0) {
    return -1;
  }

  ACE_Allocator* const alloc = DCPS::SafetyProfilePool::instance();
  char* const result = static_cast<char*>(alloc->malloc(result_sz));

  if (sysctl(name, name_elts, result, &result_sz, 0, 0u) != 0) {
    alloc->free(result);
    return -1;
  }

  for (size_t pos = 0, n; pos + sizeof(if_msghdr) < result_sz; pos += n) {
    if_msghdr* const hdr = reinterpret_cast<if_msghdr*>(result + pos);
    n = hdr->ifm_msglen;
    sockaddr_dl* const addr =
      reinterpret_cast<sockaddr_dl*>(result + pos + sizeof(if_msghdr));

    if (hdr->ifm_type == RTM_IFINFO && (hdr->ifm_addrs & RTA_IFP)
        && std::memcmp(addr->sdl_data, iface, addr->sdl_nlen) == 0
        && addr->sdl_alen >= sizeof node_id_) {
      std::memcpy(node_id_, LLADDR(addr), sizeof node_id_);
      alloc->free(result);

      interface_name_ = iface;
      return 0;
    }

    while (pos + n < result_sz) {
      if_msghdr* const nxt = reinterpret_cast<if_msghdr*>(result + pos + n);
      if (nxt->ifm_type != RTM_NEWADDR) {
        break;
      }
      n += nxt->ifm_msglen;
    }
  }

  alloc->free(result);
  return -1;
#else
  return -1;
#endif
}

populate()

void OpenDDS::RTPS::GuidGenerator::populate

(

DCPS::GUID_t &

container

)

populate a GUID container with a unique ID. This will increment the counter, and use a lock (if compiled with MT ACE) while doing so.

Definition at line 259 of file GuidGenerator.cpp.

References getCount(), OpenDDS::DCPS::GUID_t::guidPrefix, ACE_OS::memcpy(), node_id_, NODE_ID_SIZE, OPENDDS_END_VERSIONED_NAMESPACE_DECL, pid_, and OpenDDS::DCPS::VENDORID_OCI.

Referenced by OpenDDS::RTPS::RtpsDiscovery::add_domain_participant(), and OpenDDS::RTPS::RtpsDiscovery::generate_participant_guid().

{
  container.guidPrefix[0] = DCPS::VENDORID_OCI[0];
  container.guidPrefix[1] = DCPS::VENDORID_OCI[1];

  const ACE_UINT16 count = getCount();
  ACE_OS::memcpy(&container.guidPrefix[2], node_id_, NODE_ID_SIZE);
  container.guidPrefix[8] = static_cast<CORBA::Octet>(pid_ >> 8);
  container.guidPrefix[9] = static_cast<CORBA::Octet>(pid_ & 0xFF);
  container.guidPrefix[10] = static_cast<CORBA::Octet>(count >> 8);
  container.guidPrefix[11] = static_cast<CORBA::Octet>(count & 0xFF);
}

Member Data Documentation

counter_

ACE_UINT16 OpenDDS::RTPS::GuidGenerator::counter_

private

Definition at line 69 of file GuidGenerator.h.

Referenced by getCount(), and GuidGenerator().

counter_lock_

ACE_Thread_Mutex OpenDDS::RTPS::GuidGenerator::counter_lock_

private

Definition at line 68 of file GuidGenerator.h.

Referenced by getCount().

interface_name_

OPENDDS_STRING OpenDDS::RTPS::GuidGenerator::interface_name_

private

Definition at line 70 of file GuidGenerator.h.

Referenced by interfaceName().

node_id_

Node_ID OpenDDS::RTPS::GuidGenerator::node_id_

private

Definition at line 66 of file GuidGenerator.h.

Referenced by GuidGenerator(), interfaceName(), and populate().

pid_

pid_t OpenDDS::RTPS::GuidGenerator::pid_

private

Definition at line 67 of file GuidGenerator.h.

Referenced by GuidGenerator(), and populate().

---

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

• GuidGenerator.h
• GuidGenerator.cpp