OpenDDS::Security::XmlUtils Namespace Reference

Typedefs
typedef DCPS::unique_ptr< xercesc::XercesDOMParser >	ParserPtr

Functions
std::string	to_string (const xercesc::SAXParseException &ex)
bool	get_parser (ParserPtr &parser, const std::string &filename, const std::string &xml)
std::string	to_string (const XMLCh *in)
bool	parse_bool (const XMLCh *in, bool &value)
bool	parse_time (const XMLCh *in, time_t &value)
bool	parse_domain_id_set (const xercesc::DOMNode *node, Security::DomainIdSet &domain_id_set)
std::string	to_string (const xercesc::XMLException &ex)
std::string	to_string (const xercesc::DOMException &ex)
std::string	to_string (const xercesc::DOMNode *node)
bool	parse_bool (const xercesc::DOMNode *node, bool &value)
bool	parse_time (const xercesc::DOMNode *node, time_t &value)
bool	is_element (const xercesc::DOMNode *node)

Typedef Documentation

ParserPtr

typedef DCPS::unique_ptr<xercesc::XercesDOMParser> OpenDDS::Security::XmlUtils::ParserPtr

Definition at line 32 of file XmlUtils.h.

Function Documentation

get_parser()

OpenDDS_Security_Export bool OpenDDS::Security::XmlUtils::get_parser	(	ParserPtr &	parser,
		const std::string &	filename,
		const std::string &	xml
	)

Definition at line 71 of file XmlUtils.cpp.

References OpenDDS::DCPS::SecurityDebug::access_error, ACE_ERROR, FACE::TS::Initialize(), LM_ERROR, OpenDDS::DCPS::unique_ptr< T, Deleter >::reset(), OpenDDS::DCPS::security_debug, and to_string().

Referenced by OpenDDS::Security::Governance::load(), and OpenDDS::Security::Permissions::load().

{
  try {
    xercesc::XMLPlatformUtils::Initialize();

  } catch (const xercesc::XMLException& ex) {
    if (security_debug.access_error) {
      ACE_ERROR((LM_ERROR, "(%P|%t) ERROR: {access_error} get_parser: "
        "XMLPlatformUtils::Initialize XMLException: %C\n",
        to_string(ex).c_str()));
    }
    parser.reset();
    return false;
  }

  parser.reset(new xercesc::XercesDOMParser());

  parser->setDoNamespaces(true);
  parser->setIncludeIgnorableWhitespace(false);
  parser->setCreateCommentNodes(false);

  ErrorHandler error_handler;
  parser->setErrorHandler(&error_handler);

  xercesc::MemBufInputSource contentbuf(
    reinterpret_cast<const XMLByte*>(xml.c_str()), xml.size(), filename.c_str());

  try {
    parser->parse(contentbuf);

  } catch (const xercesc::XMLException& ex) {
    if (security_debug.access_error) {
      ACE_ERROR((LM_ERROR, "(%P|%t) ERROR: {access_error} get_parser: "
        "XMLException while parsing \"%C\": %C\n",
        filename.c_str(), to_string(ex).c_str()));
    }
    parser.reset();
    return false;

  } catch (const xercesc::DOMException& ex) {
    if (security_debug.access_error) {
      ACE_ERROR((LM_ERROR, "(%P|%t) ERROR: {access_error} get_parser: "
        "DOMException while parsing \"%C\": %C\n",
        filename.c_str(), to_string(ex).c_str()));
    }
    parser.reset();
    return false;

  } catch (...) {
    if (security_debug.access_error) {
      ACE_ERROR((LM_ERROR, "(%P|%t) ERROR: {access_error} get_parser: "
        "Unexpected exception while parsing \"%C\"",
        filename.c_str()));
    }
    parser.reset();
    return false;
  }

  if (!parser->getDocument()->getDocumentElement()) {
    if (security_debug.access_error) {
      ACE_ERROR((LM_ERROR, "(%P|%t) ERROR: {access_error} get_parser: "
        "XML document \"%C\" is empty\n",
        filename.c_str()));
    }
    parser.reset();
    return false;
  }

  return true;
}

is_element()

bool OpenDDS::Security::XmlUtils::is_element ( const xercesc::DOMNode *  node )

inline

Definition at line 81 of file XmlUtils.h.

References OPENDDS_END_VERSIONED_NAMESPACE_DECL.

Referenced by parse_domain_id_set().

{
  return node->getNodeType() == xercesc::DOMNode::ELEMENT_NODE;
}

parse_bool() [1/2]

bool OpenDDS::Security::XmlUtils::parse_bool ( const xercesc::DOMNode *  node, bool &  value  )

inline

Definition at line 64 of file XmlUtils.h.

References parse_bool(), and value.

{
  return parse_bool(node->getTextContent(), value);
}

parse_bool() [2/2]

OpenDDS_Security_Export bool OpenDDS::Security::XmlUtils::parse_bool	(	const XMLCh *	in,
		bool &	value
	)

Definition at line 150 of file XmlUtils.cpp.

References ACE_OS::strcasecmp(), and to_string().

Referenced by OpenDDS::DCPS::StaticDiscovery::add_domain_participant_secure(), OpenDDS::Security::Governance::Governance(), parse_bool(), OpenDDS::DCPS::StaticDiscovery::parse_publisherqos(), and OpenDDS::DCPS::StaticDiscovery::parse_subscriberqos().

{
  /*
   * The security spec specifies the XML schema spec's boolean type, but the
   * XML schema spec doesn't specify that true and false can be capitalized
   * like the security spec uses.
   */
  const std::string s = to_string(in);
  if (!ACE_OS::strcasecmp(s.c_str(), "true") || s == "1") {
    value = true;
  } else if (!ACE_OS::strcasecmp(s.c_str(), "false") || s == "0") {
    value = false;
  } else {
    return false;
  }
  return true;
}

parse_domain_id_set()

OpenDDS_Security_Export bool OpenDDS::Security::XmlUtils::parse_domain_id_set	(	const xercesc::DOMNode *	node,
		Security::DomainIdSet &	domain_id_set
	)

Convert a node that's a DomainIdSet in the permissions and governance XML Schema in the security spec to a std::set of domain ids.

Definition at line 445 of file XmlUtils.cpp.

References OpenDDS::DCPS::SecurityDebug::access_error, ACE_ERROR, OpenDDS::DCPS::DisjointSequence::OrderedRanges< T >::add(), OpenDDS::Security::domain_id_max, OpenDDS::Security::domain_id_min, OpenDDS::DCPS::DisjointSequence::OrderedRanges< T >::empty(), is_element(), LM_ERROR, OPENDDS_END_VERSIONED_NAMESPACE_DECL, OpenDDS::DCPS::security_debug, and to_string().

Referenced by OpenDDS::Security::Governance::load(), OpenDDS::Security::Permissions::load(), and parse_time().

{
  const xercesc::DOMNodeList* const domainIdNodes = node->getChildNodes();
  for (XMLSize_t did = 0, did_len = domainIdNodes->getLength(); did < did_len; ++did) {
    const xercesc::DOMNode* const domainIdNode = domainIdNodes->item(did);
    if (!is_element(domainIdNode)) {
      continue;
    }
    const std::string domainIdNodeName = to_string(domainIdNode->getNodeName());
    if (domainIdNodeName == "id") {
      DomainId_t domain_id;
      if (!parse_domain_id(domainIdNode, domain_id)) {
        if (security_debug.access_error) {
          ACE_ERROR((LM_ERROR, "(%P|%t) ERROR: {access_error} parse_domain_id_set: "
            "Invalid domain ID \"%C\" in id\n",
            to_string(domainIdNode).c_str()));
        }
        return false;
      }
      domain_id_set.add(domain_id);

    } else if (domainIdNodeName == "id_range") {
      const xercesc::DOMNodeList* const domRangeIdNodes = domainIdNode->getChildNodes();
      DomainId_t min_value = domain_id_min;
      bool has_min = false;
      DomainId_t max_value = domain_id_max;
      bool has_max = false;
      const XMLSize_t drid_len = domRangeIdNodes->getLength();
      for (XMLSize_t drid = 0; drid < drid_len; ++drid) {
        const xercesc::DOMNode* const domRangeIdNode = domRangeIdNodes->item(drid);
        if (!is_element(domRangeIdNode)) {
          continue;
        }
        const std::string domRangeIdNodeName = to_string(domRangeIdNode->getNodeName());
        if ("min" == domRangeIdNodeName && !has_min) {
          if (!parse_domain_id(domRangeIdNode, min_value)) {
            if (security_debug.access_error) {
              ACE_ERROR((LM_ERROR, "(%P|%t) ERROR: {access_error} parse_domain_id_set: "
                "Invalid domain ID \"%C\" in min_value\n",
                to_string(domRangeIdNode).c_str()));
            }
            return false;
          }
          has_min = true;

        } else if ("max" == domRangeIdNodeName && !has_max) {
          if (!parse_domain_id(domRangeIdNode, max_value)) {
            if (security_debug.access_error) {
              ACE_ERROR((LM_ERROR, "(%P|%t) ERROR: {access_error} parse_domain_id_set: "
                "Invalid domain ID \"%C\" in max_value\n",
                to_string(domRangeIdNode).c_str()));
            }
            return false;
          }
          if (min_value > max_value) {
            if (security_debug.access_error) {
              ACE_ERROR((LM_ERROR,"(%P|%t) ERROR: {access_error} parse_domain_id_set: "
                "Permission XML Domain Range invalid.\n"));
            }
            return false;
          }
          has_max = true;

        } else {
          if (security_debug.access_error) {
            ACE_ERROR((LM_ERROR, "(%P|%t) ERROR: {access_error} parse_domain_id_set: "
              "Invalid tag \"%C\" in id_range\n",
              domRangeIdNodeName.c_str()));
          }
          return false;
        }
      }

      domain_id_set.add(min_value, max_value);

    } else {
      if (security_debug.access_error) {
        ACE_ERROR((LM_ERROR, "(%P|%t) ERROR: {access_error} parse_domain_id_set: "
          "Invalid tag \"%C\" in domain ID set\n",
          domainIdNodeName.c_str()));
      }
      return false;
    }
  }

  if (domain_id_set.empty()) {
    if (security_debug.access_error) {
      ACE_ERROR((LM_ERROR, "(%P|%t) ERROR: {access_error} parse_domain_id_set: "
        "empty domain ID set\n"));
    }
    return false;
  }

  return true;
}

parse_time() [1/2]

bool OpenDDS::Security::XmlUtils::parse_time ( const xercesc::DOMNode *  node, time_t &  value  )

inline

Definition at line 69 of file XmlUtils.h.

References OpenDDS_Security_Export, parse_domain_id_set(), parse_time(), and value.

{
  return parse_time(node->getTextContent(), value);
}

parse_time() [2/2]

OpenDDS_Security_Export bool OpenDDS::Security::XmlUtils::parse_time	(	const XMLCh *	in,
		time_t &	value
	)

Definition at line 245 of file XmlUtils.cpp.

References OpenDDS::DCPS::SecurityDebug::access_error, ACE_ERROR, ace_timezone(), OpenDDS::Security::domain_id_max, ENOTSUP, LM_ERROR, OpenDDS::DCPS::security_debug, to_string(), and value.

Referenced by OpenDDS::Security::Permissions::load(), and parse_time().

{
  xercesc::XMLDateTime xdt(in);
  try {
    xdt.parseDateTime();
  } catch (const xercesc::XMLException& ex) {
    if (security_debug.access_error) {
      ACE_ERROR((LM_ERROR, "(%P|%t) ERROR: {access_error} parse_time: "
        "failed to parse date/time \"%C\": %C\n",
        to_string(in).c_str(), to_string(ex).c_str()));
    }
    return false;
  }

#if XMLDATETIME_HAS_GETEPOCH
  value = xdt.getEpoch();
#else
  /*
   * Doesn't seem like older Xerces' actually have a way to get the information
   * from XMLDateTime, so we have to do it ourselves.
   *
   * For this we'll follow https://www.w3.org/TR/xmlschema-2/#dateTime, which
   * is basically the same as ISO8601.
   * The exceptions are:
   * - We won't accept a negative datetime (-0001 is the year 2BCE), since the
   *   standard library might not be able to handle such a far back and we're
   *   certainly not expecting it.
   * - The Schema spec says that times without timezone info should be
   *   interpreted as "local", but seems it be intentionally vague as what that
   *   means. The DDS Security 1.1 spec explicitly says in 9.4.1.3.2.2 that it
   *   would be UTC. Xerces getEpoch values match up with this in the unit test
   *   for this code, so it's also interpreting them as UTC instead of
   *   something like the local system timezone.
   * - Since we use time_t we will accept but ignore fractional seconds.
   *   NOTE: The security spec is missing fractional seconds in a format
   *   description in a comment in example XML. This comment has been copied
   *   into many permissions files sitting in OpenDDS.
   */

  const std::string str = to_string(in);
  if (str[0] == '-') {
    if (security_debug.access_error) {
      ACE_ERROR((LM_ERROR, "(%P|%t) ERROR: {access_error} parse_time: "
        "date/time can't be negative: \"%C\"\n",
        str.c_str()));
    }
    return false;
  }

  /*
   * After this the expected lexical format given by the Schema spec is:
   *   yyyy '-' mm '-' dd 'T' hh ':' mm ':' ss ('.' s+)? ((('+' | '-') hh ':' mm) | 'Z')?
   * or alternatively as the Security spec says, except with fractional seconds:
   *   CCYY-MM-DDThh:mm:ss[.fffff...][Z|(+|-)hh:mm]
   * See unit tests for this code for examples
   */
  std::tm dttm;
  size_t pos = 0;

  // Year
  if (!parse_time_field(str, pos, dttm.tm_year, 4)) {
    return false;
  }
  dttm.tm_year -= 1900;
  if (!parse_time_char(str, pos, "-")) {
    return false;
  }
  // Month
  if (!parse_time_field(str, pos, dttm.tm_mon)) {
    return false;
  }
  --dttm.tm_mon;
  if (!parse_time_char(str, pos, "-")) {
    return false;
  }
  // Day
  if (!parse_time_field(str, pos, dttm.tm_mday)) {
    return false;
  }
  if (!parse_time_char(str, pos, "T")) {
    return false;
  }
  // Hour
  if (!parse_time_field(str, pos, dttm.tm_hour)) {
    return false;
  }
  if (!parse_time_char(str, pos, ":")) {
    return false;
  }
  // Minutes
  if (!parse_time_field(str, pos, dttm.tm_min)) {
    return false;
  }
  if (!parse_time_char(str, pos, ":")) {
    return false;
  }
  // Seconds
  if (!parse_time_field(str, pos, dttm.tm_sec)) {
    return false;
  }

  // Ignore Fractional Seconds
  if (str[pos] == '.') {
    ++pos;
    for (; str[pos] >= '0' && str[pos] <= '9'; ++pos) {
    }
  }

  // Optional Timezone Info
  time_t timezone_offset = 0;
  char tz_char = '\0';
  bool end;
  if (!parse_time_char_or_end(str, pos, "+-Z", tz_char, end)) {
    return false;
  }
  if (!end && tz_char != 'Z') {
    int tz_hour;
    if (!parse_time_field(str, pos, tz_hour)) {
      return false;
    }

    if (!parse_time_char(str, pos, ":")) {
      return false;
    }

    int tz_min;
    if (!parse_time_field(str, pos, tz_min)) {
      return false;
    }

    /*
     * We will have to do the reverse of the sign to convert the local time to
     * UTC. For example 00:00:00-06:00 (12AM CST) is 06:00:00+00:00 (6AM UTC).
     */
    const int timezone_offset_sign = tz_char == '+' ? -1 : 1;

    /*
     * We could modify the tm struct here to account for the timezone, but then
     * we'd also have to adjust the hour if the minutes carried over and the
     * date fields if the hour carried over to another date. Instead we're
     * going to calculate the number of seconds in the offset and add that to
     * the time_t value later.
     */
    timezone_offset = timezone_offset_sign * (tz_hour * 60 * 60 + tz_min * 60);
  }

  std::string leftover;
  if (parse_time_string(str, pos, leftover)) {
    if (security_debug.access_error) {
      ACE_ERROR((LM_ERROR, "(%P|%t) ERROR: {access_error} parse_time: "
        "leftover characters in \"%C\": \"%C\"\n",
        str.c_str(), leftover.c_str()));
    }
    return false;
  }

  dttm.tm_isdst = 0; // Don't try to do anything with DST
  value = std::mktime(&dttm);
  if (value == time_t(-1)) {
    if (security_debug.access_error) {
      ACE_ERROR((LM_ERROR, "(%P|%t) ERROR: {access_error} parse_time: "
        "failed to convert to time_t \"%C\"\n",
        to_string(in).c_str()));
    }
    return false;
  }

  // mktime assumes the tm struct is in the local time, so we need to correct
  // for that.
  const time_t local_timezone = static_cast<time_t>(ace_timezone());
  if (local_timezone == 0 && errno == ENOTSUP) {
    if (security_debug.access_error) {
      ACE_ERROR((LM_ERROR, "(%P|%t) ERROR: {access_error} parse_time: "
        "ace_timezone not supported\n"));
    }
    return false;
  }
  value -= local_timezone;

  // Adjust for the timezone specified in the string if there was one.
  value += timezone_offset;
#endif // XMLDATETIME_HAS_GETEPOCH

  return value;
}

to_string() [1/5]

OpenDDS_Security_Export std::string OpenDDS::Security::XmlUtils::to_string

(

const xercesc::SAXParseException &

ex

)

Definition at line 30 of file XmlUtils.cpp.

References OpenDDS::DCPS::SecurityDebug::access_error, OpenDDS::DCPS::SecurityDebug::access_warn, ACE_ERROR, LM_ERROR, OpenDDS::DCPS::security_debug, and OpenDDS::DCPS::to_dds_string().

Referenced by get_parser(), OpenDDS::Security::Governance::Governance(), OpenDDS::Security::Governance::load(), parse_bool(), parse_domain_id_set(), parse_time(), and to_string().

{
  return
    to_string(ex.getSystemId()) +
    ":" + DCPS::to_dds_string(ex.getLineNumber()) +
    ":" + DCPS::to_dds_string(ex.getColumnNumber()) +
    ": " + to_string(ex.getMessage());
}

to_string() [2/5]

std::string OpenDDS::Security::XmlUtils::to_string ( const xercesc::XMLException &  ex )

inline

Definition at line 49 of file XmlUtils.h.

References to_string().

{
  return to_string(ex.getMessage());
}

to_string() [3/5]

std::string OpenDDS::Security::XmlUtils::to_string ( const xercesc::DOMException &  ex )

inline

Definition at line 54 of file XmlUtils.h.

References to_string().

{
  return to_string(ex.getMessage());
}

to_string() [4/5]

std::string OpenDDS::Security::XmlUtils::to_string ( const xercesc::DOMNode *  node )

inline

Definition at line 59 of file XmlUtils.h.

References to_string().

{
  return to_string(node->getTextContent());
}

to_string() [5/5]

OpenDDS_Security_Export std::string OpenDDS::Security::XmlUtils::to_string

(

const XMLCh *

in

)

Definition at line 142 of file XmlUtils.cpp.

{
  char* c = xercesc::XMLString::transcode(in);
  const std::string s(c);
  xercesc::XMLString::release(&c);
  return s;
}