OpenDDS::Security::SSL::SubjectName Class Reference

#include <SubjectName.h>

Collaboration diagram for OpenDDS::Security::SSL::SubjectName:

[legend]

List of all members.

Public Member Functions
	SubjectName ()
	SubjectName (const char *, bool permissive=false)
	SubjectName (const std::string &, bool permissive=false)
int	parse (const char *, bool permissive=false)
int	parse (const std::string &, bool permissive=false)
bool	operator== (const SubjectName &) const
bool	operator!= (const SubjectName &) const
Protected Types
typedef std::map< std::string, std::string >	AttrMap
Protected Member Functions
int	parse_permissive (const char *)
int	parse_dce (const char *)
int	parse_ldap_v3 (const char *)
int	simple_avp_seq_parse (const char *in, const char *s_del, const char *a_del, const char *s_trim, const char *a_trim, bool push_back)
Protected Attributes
AttrMap	map_

---

Detailed Description

Definition at line 21 of file SubjectName.h.

---

Member Typedef Documentation

typedef std::map<std::string, std::string> OpenDDS::Security::SSL::SubjectName::AttrMap [protected]

Definition at line 61 of file SubjectName.h.

---

Constructor & Destructor Documentation

OpenDDS::Security::SSL::SubjectName::SubjectName

(

)

Definition at line 11 of file SubjectName.cpp.

{}

OpenDDS::Security::SSL::SubjectName::SubjectName	(	const char *	in,
		bool	permissive = false
	)

Definition at line 18 of file SubjectName.cpp.

References parse().

  {
    parse(in, permissive);
  }

Here is the call graph for this function:

OpenDDS::Security::SSL::SubjectName::SubjectName	(	const std::string &	in,
		bool	permissive = false
	)

Definition at line 13 of file SubjectName.cpp.

References parse().

  {
    parse(in, permissive);
  }

Here is the call graph for this function:

---

Member Function Documentation

bool OpenDDS::Security::SSL::SubjectName::operator!=

(

const SubjectName &

rhs

)

const

Definition at line 165 of file SubjectName.cpp.

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

bool OpenDDS::Security::SSL::SubjectName::operator==

(

const SubjectName &

rhs

)

const

Definition at line 151 of file SubjectName.cpp.

References map_.

  {
    bool result = (map_.size() == rhs.map_.size());
    for (AttrMap::const_iterator i1 = map_.begin(), i2 = rhs.map_.begin();
         result == true && i1 != map_.end() && i2 != rhs.map_.end();
         ++i1, ++i2) {
      if (i1->first.compare(i2->first) != 0 ||
          i1->second.compare(i2->second) != 0) {
        result = false;
      }
    }
    return result;
  }

int OpenDDS::Security::SSL::SubjectName::parse	(	const std::string &	in,
		bool	permissive = false
	)

Returns:

int 0 on success; 1 on failure.

Definition at line 23 of file SubjectName.cpp.

References parse().

  {
    return parse(in.data(), permissive);
  }

Here is the call graph for this function:

int OpenDDS::Security::SSL::SubjectName::parse	(	const char *	in,
		bool	permissive = false
	)

Returns:

int 0 on success; 1 on failure.

Definition at line 28 of file SubjectName.cpp.

References parse_dce(), parse_ldap_v3(), and parse_permissive().

Referenced by parse(), SubjectName(), OpenDDS::Security::AccessControlBuiltInImpl::validate_local_permissions(), and OpenDDS::Security::AccessControlBuiltInImpl::validate_remote_permissions().

  {
    if (in == NULL) {
      return -1;
    }

    // For now, assume ASCII encoding and not UTF-8
    if (permissive) {
      return parse_permissive(in);
    } else {
      if (in[0] == '/') {
        return parse_dce(in);
      } else {
        return parse_ldap_v3(in);
      }
    }
  }

Here is the call graph for this function:

Here is the caller graph for this function:

int OpenDDS::Security::SSL::SubjectName::parse_dce

(

const char *

in

)

[protected]

Returns:

int 0 on success; 1 on failure.

Definition at line 141 of file SubjectName.cpp.

References simple_avp_seq_parse().

Referenced by parse().

  {
    return simple_avp_seq_parse(in, "/", "=", " ", " ", true);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

int OpenDDS::Security::SSL::SubjectName::parse_ldap_v3

(

const char *

in

)

[protected]

Returns:

int 0 on success; 1 on failure.

Definition at line 146 of file SubjectName.cpp.

References simple_avp_seq_parse().

Referenced by parse().

  {
    return simple_avp_seq_parse(in, ",", "=", " ", " ", false);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

int OpenDDS::Security::SSL::SubjectName::parse_permissive

(

const char *

in

)

[protected]

Returns:

int 0 on success; 1 on failure.

Definition at line 136 of file SubjectName.cpp.

References simple_avp_seq_parse().

Referenced by parse().

  {
    return simple_avp_seq_parse(in, ",/", "=", " ", " ", false);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

int OpenDDS::Security::SSL::SubjectName::simple_avp_seq_parse	(	const char *	in,
		const char *	s_del,
		const char *	a_del,
		const char *	s_trim,
		const char *	a_trim,
		bool	push_back
	)			[protected]

Definition at line 46 of file SubjectName.cpp.

References input, and map_.

Referenced by parse_dce(), parse_ldap_v3(), and parse_permissive().

  {
    std::string input(in);
    size_t input_end = input.size() - 1;
    map_.clear();

    ACE_UNUSED_ARG(push_back);

    // This parser is meant only to cover basic cases, more advanced cases
    // will need something different Specifically, this won't correctly handle
    // all escaped characters or all UTF-8 strings

    // Use size_t variables to mark positions of token beginnings and ends

    // We'll use "st" to mark positions for sequence tokens
    size_t st_begin = 0;
    size_t st_end = input.find_first_of(s_del);

    // Loop over all the sequence tokens
    while (st_begin != std::string::npos) {
      std::string st = input.substr(
        st_begin,
        (st_end == std::string::npos ? input_end + 1 : st_end) - st_begin);

      // Use once we've found a sequnce token, trim the beginning and end to
      // get a clean token
      size_t st_begin_clean = st.find_first_not_of(s_trim);
      size_t st_end_clean = st.find_last_not_of(s_trim);

      // If we've found a clean sequence token
      if (st_begin_clean != std::string::npos &&
          st_end_clean != std::string::npos) {
        std::string st_clean =
          st.substr(st_begin_clean, st_end_clean - st_begin_clean + 1);

        // We'll use "nt" to mark positions for name tokens
        size_t nt_begin = 0;
        size_t nt_end = st_clean.find_first_of(a_del);

        // If we actually found a delimiter
        if (nt_end != std::string::npos) {
          --nt_end;

          std::string nt = st_clean.substr(nt_begin, nt_end - nt_begin + 1);

          size_t nt_begin_clean = nt.find_first_not_of(a_trim);
          size_t nt_end_clean = nt.find_last_not_of(a_trim);

          // If we found a clean name token
          if (nt_begin_clean != std::string::npos &&
              nt_end_clean != std::string::npos) {
            std::string nt_clean =
              nt.substr(nt_begin_clean, nt_end_clean - nt_begin_clean + 1);

            // We'll use "vt" to mark positions for value tokens
            size_t vt_begin = nt_end + 2;  // Skip over the (single) delimiter
            size_t vt_end = st_clean.size() - 1;

            std::string vt = st_clean.substr(vt_begin, vt_end - vt_begin + 1);

            size_t vt_begin_clean = vt.find_first_not_of(a_trim);
            size_t vt_end_clean = vt.find_last_not_of(a_trim);

            // If we found a clean value token
            if (vt_begin_clean != std::string::npos &&
                vt_end_clean != std::string::npos) {
              std::string vt_clean =
                vt.substr(vt_begin_clean, vt_end_clean - vt_begin_clean + 1);

              // Push our clean pair into the map
              map_[nt_clean] = vt_clean;
            }
          }
        }
      }

      // Prepare for next iteration of loop
      if (st_end == std::string::npos) {
        st_begin = std::string::npos;
      } else {
        st_begin = st_end + 1;
        st_end = input.find_first_of(s_del, st_begin);
      }
    }

    return map_.empty() ? 1 : 0;
  }

Here is the caller graph for this function:

---

Member Data Documentation

AttrMap OpenDDS::Security::SSL::SubjectName::map_ [protected]

Definition at line 62 of file SubjectName.h.

Referenced by operator==(), and simple_avp_seq_parse().

---

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

• SubjectName.h
• SubjectName.cpp