ssliop_credentials.cpp

这是广泛使用的通信开源项目,对于大容量,高并发的通讯要求完全能够胜任,他广泛可用于网络游戏医学图像网关的高qos要求.更详细的内容可阅读相应的材料

                                      der_cert->get_buffer (),
                                      der_cert->length ()) <= 0)
        {
          if (TAO_debug_level > 0)
            ACE_ERROR ((LM_ERROR,
                        "(%P|%t) ERROR: Unable to refresh SSLIOP "
                        "credentials using certificate in ASN.1 "
                        "format.\n"));

          ACE_THROW_RETURN (CORBA::BAD_OPERATION (), 0);
        }
    }

  // Attempt to extract a filename that contains the certificate from
  // the Any.
  else if (refresh_data >>= cert_filename)
    {
      // @@ Should we do this sort of thing, i.e. first try to open a
      //    PEM file, and then an ASN.1 file?

      // Try extracting a PEM formatted certificate from the given
      // file.
      if (::SSL_use_certificate_file (this->ssl_,
                                      cert_filename,
                                      SSL_FILETYPE_PEM) <= 0)
        {
          if (TAO_debug_level > 0)
            ACE_DEBUG ((LM_WARNING,
                        "(%P|%t) WARNING: Unable to refresh SSLIOP "
                        "credentials using PEM certificate in file \"%s\"\n",
                        cert_filename));
        }

      // Try extracted an ASN.1 formatted certificate from the given
      // file.
      else if (::SSL_use_certificate_file (this->ssl_,
                                           cert_filename,
                                           SSL_FILETYPE_ASN1) <= 0)
        {
          if (TAO_debug_level > 0)
            ACE_DEBUG ((LM_WARNING,
                        "(%P|%t) WARNING: Unable to refresh SSLIOP "
                        "credentials using ASN.1 certificate in file \"%s\"\n",
                        cert_filename));
        }

      else
        ACE_THROW_RETURN (CORBA::BAD_OPERATION (), 0);
    }
  else
    ACE_THROW_RETURN (CORBA::BAD_PARAM (), 0);

  // Renegotiate the SSL session to force the new settings to be used.
  if (::SSL_renegotiate (this->ssl_) <= 0)
    ACE_THROW_RETURN (CORBA::BAD_OPERATION (), 0);

  return 1;
#endif  /* 0 */
}

CORBA::Boolean
TAO_SSLIOP_Credentials::operator== (const TAO_SSLIOP_Credentials &rhs)
{
  X509 *xa = this->x509_.in ();
  X509 *xb = rhs.x509_.in ();
  // EVP_PKEY *ea = this->evp_.in ();
  // EVP_PKEY *eb = rhs.evp_.in ();

  return
    this->accepting_options_supported_ == rhs.accepting_options_supported_
    && this->accepting_options_required_ == rhs.accepting_options_required_
    && this->invocation_options_supported_ == rhs.invocation_options_supported_
    && this->invocation_options_required_ == rhs.invocation_options_required_
    && ((xa == xb) || (xa != 0 && xb != 0 && ::X509_cmp (xa, xb) == 0))
    // && ((ea == eb) || (ea != 0 && eb != 0 && ::EVP_PKEY_cmp (ea, eb) == 0))
    ;
}

CORBA::ULong
TAO_SSLIOP_Credentials::hash (void) const
{
  X509 *x509 = this->x509_.in ();

  return (x509 == 0 ? 0 : ::X509_issuer_name_hash (x509));
}

TAO_SSLIOP_Credentials_ptr
TAO_SSLIOP_Credentials::_narrow (CORBA::Object_ptr obj
                                 ACE_ENV_ARG_DECL_NOT_USED)
{
  return  TAO_SSLIOP_Credentials::_duplicate (
              dynamic_cast<TAO_SSLIOP_Credentials *> (obj));
}

TAO_SSLIOP_Credentials_ptr
TAO_SSLIOP_Credentials::_duplicate (TAO_SSLIOP_Credentials_ptr obj)
{
  if (!CORBA::is_nil (obj))
    obj->_add_ref ();

  return obj;
}

// -----------------------------------------------------------

int TAO_SSLIOP_Credentials::_tao_class_id = 0;

TAO_SSLIOP_Credentials_ptr
tao_TAO_SSLIOP_Credentials_duplicate (
    TAO_SSLIOP_Credentials_ptr p
  )
{
  return TAO_SSLIOP_Credentials::_duplicate (p);
}

void
tao_TAO_SSLIOP_Credentials_release (
    TAO_SSLIOP_Credentials_ptr p
  )
{
  CORBA::release (p);
}

TAO_SSLIOP_Credentials_ptr
tao_TAO_SSLIOP_Credentials_nil (
    void
  )
{
  return TAO_SSLIOP_Credentials::_nil ();
}

TAO_SSLIOP_Credentials_ptr
tao_TAO_SSLIOP_Credentials_narrow (
    CORBA::Object *p
    ACE_ENV_ARG_DECL
  )
{
  return TAO_SSLIOP_Credentials::_narrow (p ACE_ENV_ARG_PARAMETER);
}

CORBA::Object *
tao_TAO_SSLIOP_Credentials_upcast (
    void *src
  )
{
  TAO_SSLIOP_Credentials **tmp =
    ACE_static_cast (TAO_SSLIOP_Credentials **, src);
  return *tmp;
}

// *************************************************************
// Operations for class TAO_SSLIOP_Credentials_var
// *************************************************************

TAO_SSLIOP_Credentials_var::TAO_SSLIOP_Credentials_var (void) // default constructor
  : ptr_ (TAO_SSLIOP_Credentials::_nil ())
{}

::TAO_SSLIOP_Credentials_ptr
TAO_SSLIOP_Credentials_var::ptr (void) const
{
  return this->ptr_;
}

TAO_SSLIOP_Credentials_var::TAO_SSLIOP_Credentials_var (const ::TAO_SSLIOP_Credentials_var &p) // copy constructor
  : TAO_Base_var (),
    ptr_ (TAO_SSLIOP_Credentials::_duplicate (p.ptr ()))
{}

TAO_SSLIOP_Credentials_var::~TAO_SSLIOP_Credentials_var (void) // destructor
{
  CORBA::release (this->ptr_);
}

TAO_SSLIOP_Credentials_var &
TAO_SSLIOP_Credentials_var::operator= (TAO_SSLIOP_Credentials_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

TAO_SSLIOP_Credentials_var &
TAO_SSLIOP_Credentials_var::operator= (const ::TAO_SSLIOP_Credentials_var &p)
{
  if (this != &p)
  {
    CORBA::release (this->ptr_);
    this->ptr_ = ::TAO_SSLIOP_Credentials::_duplicate (p.ptr ());
  }
  return *this;
}

TAO_SSLIOP_Credentials_var::operator const ::TAO_SSLIOP_Credentials_ptr &() const // cast
{
  return this->ptr_;
}

TAO_SSLIOP_Credentials_var::operator ::TAO_SSLIOP_Credentials_ptr &() // cast
{
  return this->ptr_;
}

::TAO_SSLIOP_Credentials_ptr
TAO_SSLIOP_Credentials_var::operator-> (void) const
{
  return this->ptr_;
}

::TAO_SSLIOP_Credentials_ptr
TAO_SSLIOP_Credentials_var::in (void) const
{
  return this->ptr_;
}

::TAO_SSLIOP_Credentials_ptr &
TAO_SSLIOP_Credentials_var::inout (void)
{
  return this->ptr_;
}

::TAO_SSLIOP_Credentials_ptr &
TAO_SSLIOP_Credentials_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::TAO_SSLIOP_Credentials::_nil ();
  return this->ptr_;
}

::TAO_SSLIOP_Credentials_ptr
TAO_SSLIOP_Credentials_var::_retn (void)
{
  // yield ownership of managed obj reference
  ::TAO_SSLIOP_Credentials_ptr val = this->ptr_;
  this->ptr_ = ::TAO_SSLIOP_Credentials::_nil ();
  return val;
}

::TAO_SSLIOP_Credentials_ptr
TAO_SSLIOP_Credentials_var::tao_duplicate (TAO_SSLIOP_Credentials_ptr p)
{
  return ::TAO_SSLIOP_Credentials::_duplicate (p);
}

void
TAO_SSLIOP_Credentials_var::tao_release (TAO_SSLIOP_Credentials_ptr p)
{
  CORBA::release (p);
}

::TAO_SSLIOP_Credentials_ptr
TAO_SSLIOP_Credentials_var::tao_nil (void)
{
  return ::TAO_SSLIOP_Credentials::_nil ();
}

::TAO_SSLIOP_Credentials_ptr
TAO_SSLIOP_Credentials_var::tao_narrow (
    CORBA::Object *p
    ACE_ENV_ARG_DECL
  )
{
  return ::TAO_SSLIOP_Credentials::_narrow (p ACE_ENV_ARG_PARAMETER);
}

CORBA::Object *
TAO_SSLIOP_Credentials_var::tao_upcast (void *src)
{
  TAO_SSLIOP_Credentials **tmp =
    ACE_static_cast (TAO_SSLIOP_Credentials **, src);
  return *tmp;
}

// *************************************************************
// Operations for class TAO_SSLIOP_Credentials_out
// *************************************************************

TAO_SSLIOP_Credentials_out::TAO_SSLIOP_Credentials_out (TAO_SSLIOP_Credentials_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = ::TAO_SSLIOP_Credentials::_nil ();
}

TAO_SSLIOP_Credentials_out::TAO_SSLIOP_Credentials_out (TAO_SSLIOP_Credentials_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::TAO_SSLIOP_Credentials::_nil ();
}

TAO_SSLIOP_Credentials_out::TAO_SSLIOP_Credentials_out (const ::TAO_SSLIOP_Credentials_out &p) // copy constructor
  : ptr_ (ACE_const_cast (TAO_SSLIOP_Credentials_out &, p).ptr_)
{}

::TAO_SSLIOP_Credentials_out &
TAO_SSLIOP_Credentials_out::operator= (const ::TAO_SSLIOP_Credentials_out &p)
{
  this->ptr_ = ACE_const_cast (TAO_SSLIOP_Credentials_out&, p).ptr_;
  return *this;
}

TAO_SSLIOP_Credentials_out &
TAO_SSLIOP_Credentials_out::operator= (const ::TAO_SSLIOP_Credentials_var &p)
{
  this->ptr_ = ::TAO_SSLIOP_Credentials::_duplicate (p.ptr ());
  return *this;
}

TAO_SSLIOP_Credentials_out &
TAO_SSLIOP_Credentials_out::operator= (TAO_SSLIOP_Credentials_ptr p)
{
  this->ptr_ = p;
  return *this;
}

TAO_SSLIOP_Credentials_out::operator ::TAO_SSLIOP_Credentials_ptr &() // cast
{
  return this->ptr_;
}

::TAO_SSLIOP_Credentials_ptr &
TAO_SSLIOP_Credentials_out::ptr (void) // ptr
{
  return this->ptr_;
}

::TAO_SSLIOP_Credentials_ptr
TAO_SSLIOP_Credentials_out::operator-> (void)
{
  return this->ptr_;
}