zeroc-ice 3.6.5 → 3.7.4

data/ext/Communicator.h

@@ -1,11 +1,6 @@
-// **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) ZeroC, Inc. All rights reserved.
 //
-// This copy of Ice is licensed to you under the terms described in the
-// ICE_LICENSE file included in this distribution.
-//
-// **********************************************************************
 
 #ifndef ICE_RUBY_COMMUNICATOR_H
 #define ICE_RUBY_COMMUNICATOR_H

data/ext/Config.h

@@ -1,11 +1,6 @@
-// **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) ZeroC, Inc. All rights reserved.
 //
-// This copy of Ice is licensed to you under the terms described in the
-// ICE_LICENSE file included in this distribution.
-//
-// **********************************************************************
 
 #ifndef ICE_RUBY_CONFIG_H
 #define ICE_RUBY_CONFIG_H
@@ -19,7 +14,7 @@
 //
 // COMPILERFIX: This is required to prevent annoying warnings with aCC.
 // The aCC -mt option causes the definition of the _POSIX_C_SOURCE macro
-// (with another lower value.) and this is causing a warning because of 
+// (with another lower value.) and this is causing a warning because of
 // the redefinition.
 //
 //#if defined(__HP_aCC) && defined(_POSIX_C_SOURCE)
@@ -52,8 +47,29 @@
 #define HAVE_ISFINITE 1
 #endif
 
+//
+// BUGFIX: Workaround unused parameter in ruby.h header file
+//
+#if defined(__clang__)
+#   pragma clang diagnostic push
+#   pragma clang diagnostic ignored "-Wunused-parameter"
+//
+// BUGFIX: Workaround clang conversion warnings in ruby headers
+//
+#   pragma clang diagnostic ignored "-Wconversion"
+#elif defined(__GNUC__)
+#   pragma GCC diagnostic push
+#   pragma GCC diagnostic ignored "-Wunused-parameter"
+#endif
+
 #include <ruby.h>
 
+#if defined(__clang__)
+#   pragma clang diagnostic pop
+#elif defined(__GNUC__)
+#   pragma GCC diagnostic pop
+#endif
+
 //
 // The Ruby header file win32/win32.h defines a number of macros for
 // functions like shutdown() and close() that wreak havoc.

data/ext/Connection.cpp

@@ -1,11 +1,6 @@
-// **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) ZeroC, Inc. All rights reserved.
 //
-// This copy of Ice is licensed to you under the terms described in the
-// ICE_LICENSE file included in this distribution.
-//
-// **********************************************************************
 
 #include <Connection.h>
 #include <Endpoint.h>
@@ -25,11 +20,8 @@ static VALUE _tcpConnectionInfoClass;
 static VALUE _udpConnectionInfoClass;
 static VALUE _wsConnectionInfoClass;
 static VALUE _sslConnectionInfoClass;
-static VALUE _wssConnectionInfoClass;
 
-// **********************************************************************
 // Connection
-// **********************************************************************
 
 extern "C"
 void
@@ -47,14 +39,23 @@ IceRuby::createConnection(const Ice::ConnectionPtr& p)
 
 extern "C"
 VALUE
-IceRuby_Connection_close(VALUE self, VALUE b)
+IceRuby_Connection_close(VALUE self, VALUE mode)
 {
     ICE_RUBY_TRY
     {
         Ice::ConnectionPtr* p = reinterpret_cast<Ice::ConnectionPtr*>(DATA_PTR(self));
         assert(p);
 
-        (*p)->close(RTEST(b));
+        volatile VALUE type = callRuby(rb_path2class, "Ice::ConnectionClose");
+        if(callRuby(rb_obj_is_instance_of, mode, type) != Qtrue)
+        {
+            throw RubyException(rb_eTypeError,
+                "value for 'mode' argument must be an enumerator of Ice::ConnectionClose");
+        }
+        volatile VALUE modeValue = callRuby(rb_funcall, mode, rb_intern("to_i"), 0);
+        assert(TYPE(modeValue) == T_FIXNUM);
+        Ice::ConnectionClose cc = static_cast<Ice::ConnectionClose>(FIX2LONG(modeValue));
+        (*p)->close(cc);
     }
     ICE_RUBY_CATCH
     return Qnil;
@@ -62,14 +63,38 @@ IceRuby_Connection_close(VALUE self, VALUE b)
 
 extern "C"
 VALUE
-IceRuby_Connection_flushBatchRequests(VALUE self)
+IceRuby_Connection_flushBatchRequests(VALUE self, VALUE compress)
 {
     ICE_RUBY_TRY
     {
         Ice::ConnectionPtr* p = reinterpret_cast<Ice::ConnectionPtr*>(DATA_PTR(self));
         assert(p);
 
-        (*p)->flushBatchRequests();
+        volatile VALUE type = callRuby(rb_path2class, "Ice::CompressBatch");
+        if(callRuby(rb_obj_is_instance_of, compress, type) != Qtrue)
+        {
+            throw RubyException(rb_eTypeError,
+                "value for 'compress' argument must be an enumerator of Ice::CompressBatch");
+        }
+        volatile VALUE compressValue = callRuby(rb_funcall, compress, rb_intern("to_i"), 0);
+        assert(TYPE(compressValue) == T_FIXNUM);
+        Ice::CompressBatch cb = static_cast<Ice::CompressBatch>(FIX2LONG(compressValue));
+        (*p)->flushBatchRequests(cb);
+    }
+    ICE_RUBY_CATCH
+    return Qnil;
+}
+
+extern "C"
+VALUE
+IceRuby_Connection_heartbeat(VALUE self)
+{
+    ICE_RUBY_TRY
+    {
+        Ice::ConnectionPtr* p = reinterpret_cast<Ice::ConnectionPtr*>(DATA_PTR(self));
+        assert(p);
+
+        (*p)->heartbeat();
     }
     ICE_RUBY_CATCH
     return Qnil;
@@ -119,7 +144,14 @@ IceRuby_Connection_setACM(VALUE self, VALUE t, VALUE c, VALUE h)
             heartbeat = static_cast<Ice::ACMHeartbeat>(FIX2LONG(heartbeatValue));
         }
 
-        (*p)->setACM(timeout, close, heartbeat);
+        try
+        {
+            (*p)->setACM(timeout, close, heartbeat);
+        }
+        catch(const IceUtil::IllegalArgumentException& ex)
+        {
+            throw RubyException(rb_eArgError, ex.reason().c_str());
+        }
     }
     ICE_RUBY_CATCH
     return Qnil;
@@ -222,6 +254,7 @@ IceRuby_Connection_getEndpoint(VALUE self)
     ICE_RUBY_CATCH
     return Qnil;
 }
+
 extern "C"
 VALUE
 IceRuby_Connection_setBufferSize(VALUE self, VALUE r, VALUE s)
@@ -240,6 +273,21 @@ IceRuby_Connection_setBufferSize(VALUE self, VALUE r, VALUE s)
     return Qnil;
 }
 
+extern "C"
+VALUE
+IceRuby_Connection_throwException(VALUE self)
+{
+    ICE_RUBY_TRY
+    {
+        Ice::ConnectionPtr* p = reinterpret_cast<Ice::ConnectionPtr*>(DATA_PTR(self));
+        assert(p);
+
+        (*p)->throwException();
+    }
+    ICE_RUBY_CATCH
+    return Qnil;
+}
+
 extern "C"
 VALUE
 IceRuby_Connection_toString(VALUE self)
@@ -278,9 +326,7 @@ IceRuby_Connection_equals(VALUE self, VALUE other)
     return Qnil;
 }
 
-// **********************************************************************
 // ConnectionInfo
-// **********************************************************************
 
 extern "C"
 void
@@ -293,17 +339,17 @@ IceRuby_ConnectionInfo_free(Ice::ConnectionInfoPtr* p)
 VALUE
 IceRuby::createConnectionInfo(const Ice::ConnectionInfoPtr& p)
 {
+    if(!p)
+    {
+        return Qnil;
+    }
+
     VALUE info;
     if(Ice::WSConnectionInfoPtr::dynamicCast(p))
     {
         info = Data_Wrap_Struct(_wsConnectionInfoClass, 0, IceRuby_ConnectionInfo_free, new Ice::ConnectionInfoPtr(p));
 
         Ice::WSConnectionInfoPtr ws = Ice::WSConnectionInfoPtr::dynamicCast(p);
-        rb_ivar_set(info, rb_intern("@localAddress"), createString(ws->localAddress));
-        rb_ivar_set(info, rb_intern("@localPort"), INT2FIX(ws->localPort));
-        rb_ivar_set(info, rb_intern("@remoteAddress"), createString(ws->remoteAddress));
-        rb_ivar_set(info, rb_intern("@remotePort"), INT2FIX(ws->remotePort));
-
         volatile VALUE result = callRuby(rb_hash_new);
         for(Ice::HeaderDict::const_iterator q = ws->headers.begin(); q != ws->headers.end(); ++q)
         {
@@ -318,76 +364,57 @@ IceRuby::createConnectionInfo(const Ice::ConnectionInfoPtr& p)
         info = Data_Wrap_Struct(_tcpConnectionInfoClass, 0, IceRuby_ConnectionInfo_free, new Ice::ConnectionInfoPtr(p));
 
         Ice::TCPConnectionInfoPtr tcp = Ice::TCPConnectionInfoPtr::dynamicCast(p);
-        rb_ivar_set(info, rb_intern("@localAddress"), createString(tcp->localAddress));
-        rb_ivar_set(info, rb_intern("@localPort"), INT2FIX(tcp->localPort));
-        rb_ivar_set(info, rb_intern("@remoteAddress"), createString(tcp->remoteAddress));
-        rb_ivar_set(info, rb_intern("@remotePort"), INT2FIX(tcp->remotePort));
+        rb_ivar_set(info, rb_intern("@rcvSize"), INT2FIX(tcp->rcvSize));
+        rb_ivar_set(info, rb_intern("@sndSize"), INT2FIX(tcp->sndSize));
     }
     else if(Ice::UDPConnectionInfoPtr::dynamicCast(p))
     {
         info = Data_Wrap_Struct(_udpConnectionInfoClass, 0, IceRuby_ConnectionInfo_free, new Ice::ConnectionInfoPtr(p));
 
         Ice::UDPConnectionInfoPtr udp = Ice::UDPConnectionInfoPtr::dynamicCast(p);
-        rb_ivar_set(info, rb_intern("@localAddress"), createString(udp->localAddress));
-        rb_ivar_set(info, rb_intern("@localPort"), INT2FIX(udp->localPort));
-        rb_ivar_set(info, rb_intern("@remoteAddress"), createString(udp->remoteAddress));
-        rb_ivar_set(info, rb_intern("@remotePort"), INT2FIX(udp->remotePort));
         rb_ivar_set(info, rb_intern("@mcastAddress"), createString(udp->mcastAddress));
         rb_ivar_set(info, rb_intern("@mcastPort"), INT2FIX(udp->mcastPort));
-    }
-    else if(IceSSL::WSSConnectionInfoPtr::dynamicCast(p))
-    {
-        info = Data_Wrap_Struct(_wssConnectionInfoClass, 0, IceRuby_ConnectionInfo_free, new Ice::ConnectionInfoPtr(p));
-
-        IceSSL::WSSConnectionInfoPtr wss = IceSSL::WSSConnectionInfoPtr::dynamicCast(p);
-        rb_ivar_set(info, rb_intern("@localAddress"), createString(wss->localAddress));
-        rb_ivar_set(info, rb_intern("@localPort"), INT2FIX(wss->localPort));
-        rb_ivar_set(info, rb_intern("@remoteAddress"), createString(wss->remoteAddress));
-        rb_ivar_set(info, rb_intern("@remotePort"), INT2FIX(wss->remotePort));
-        rb_ivar_set(info, rb_intern("@cipher"), createString(wss->cipher));
-        rb_ivar_set(info, rb_intern("@certs"), stringSeqToArray(wss->certs));
-        rb_ivar_set(info, rb_intern("@verified"), wss->verified ? Qtrue : Qfalse);
-
-        volatile VALUE result = callRuby(rb_hash_new);
-        for(Ice::HeaderDict::const_iterator q = wss->headers.begin(); q != wss->headers.end(); ++q)
-        {
-            volatile VALUE key = createString(q->first);
-            volatile VALUE value = createString(q->second);
-            callRuby(rb_hash_aset, result, key, value);
-        }
-        rb_ivar_set(info, rb_intern("@headers"), result);
+        rb_ivar_set(info, rb_intern("@rcvSize"), INT2FIX(udp->rcvSize));
+        rb_ivar_set(info, rb_intern("@sndSize"), INT2FIX(udp->sndSize));
     }
     else if(IceSSL::ConnectionInfoPtr::dynamicCast(p))
     {
         info = Data_Wrap_Struct(_sslConnectionInfoClass, 0, IceRuby_ConnectionInfo_free, new Ice::ConnectionInfoPtr(p));
 
         IceSSL::ConnectionInfoPtr ssl = IceSSL::ConnectionInfoPtr::dynamicCast(p);
-        rb_ivar_set(info, rb_intern("@localAddress"), createString(ssl->localAddress));
-        rb_ivar_set(info, rb_intern("@localPort"), INT2FIX(ssl->localPort));
-        rb_ivar_set(info, rb_intern("@remoteAddress"), createString(ssl->remoteAddress));
-        rb_ivar_set(info, rb_intern("@remotePort"), INT2FIX(ssl->remotePort));
         rb_ivar_set(info, rb_intern("@cipher"), createString(ssl->cipher));
-        rb_ivar_set(info, rb_intern("@certs"), stringSeqToArray(ssl->certs));
+
+        Ice::StringSeq encoded;
+        for(vector<IceSSL::CertificatePtr>::const_iterator i = ssl->certs.begin(); i != ssl->certs.end(); ++i)
+        {
+            encoded.push_back((*i)->encode());
+        }
+
+        rb_ivar_set(info, rb_intern("@certs"), stringSeqToArray(encoded));
         rb_ivar_set(info, rb_intern("@verified"), ssl->verified ? Qtrue : Qfalse);
     }
     else if(Ice::IPConnectionInfoPtr::dynamicCast(p))
     {
         info = Data_Wrap_Struct(_ipConnectionInfoClass, 0, IceRuby_ConnectionInfo_free, new Ice::ConnectionInfoPtr(p));
 
+    }
+    else
+    {
+        info = Data_Wrap_Struct(_connectionInfoClass, 0, IceRuby_ConnectionInfo_free, new Ice::ConnectionInfoPtr(p));
+    }
+
+    if(Ice::IPConnectionInfoPtr::dynamicCast(p))
+    {
         Ice::IPConnectionInfoPtr ip = Ice::IPConnectionInfoPtr::dynamicCast(p);
         rb_ivar_set(info, rb_intern("@localAddress"), createString(ip->localAddress));
         rb_ivar_set(info, rb_intern("@localPort"), INT2FIX(ip->localPort));
         rb_ivar_set(info, rb_intern("@remoteAddress"), createString(ip->remoteAddress));
         rb_ivar_set(info, rb_intern("@remotePort"), INT2FIX(ip->remotePort));
     }
-    else
-    {
-        info = Data_Wrap_Struct(_connectionInfoClass, 0, IceRuby_ConnectionInfo_free, new Ice::ConnectionInfoPtr(p));
-    }
+
+    rb_ivar_set(info, rb_intern("@underlying"), createConnectionInfo(p->underlying));
     rb_ivar_set(info, rb_intern("@incoming"), p->incoming ? Qtrue : Qfalse);
     rb_ivar_set(info, rb_intern("@adapterName"), createString(p->adapterName));
-    rb_ivar_set(info, rb_intern("@rcvSize"), INT2FIX(p->rcvSize));
-    rb_ivar_set(info, rb_intern("@sndSize"), INT2FIX(p->sndSize));
     return info;
 }
 
@@ -403,7 +430,8 @@ IceRuby::initConnection(VALUE iceModule)
     // Instance methods.
     //
     rb_define_method(_connectionClass, "close", CAST_METHOD(IceRuby_Connection_close), 1);
-    rb_define_method(_connectionClass, "flushBatchRequests", CAST_METHOD(IceRuby_Connection_flushBatchRequests), 0);
+    rb_define_method(_connectionClass, "flushBatchRequests", CAST_METHOD(IceRuby_Connection_flushBatchRequests), 1);
+    rb_define_method(_connectionClass, "heartbeat", CAST_METHOD(IceRuby_Connection_heartbeat), 0);
     rb_define_method(_connectionClass, "setACM", CAST_METHOD(IceRuby_Connection_setACM), 3);
     rb_define_method(_connectionClass, "getACM", CAST_METHOD(IceRuby_Connection_getACM), 0);
     rb_define_method(_connectionClass, "type", CAST_METHOD(IceRuby_Connection_type), 0);
@@ -411,6 +439,7 @@ IceRuby::initConnection(VALUE iceModule)
     rb_define_method(_connectionClass, "getInfo", CAST_METHOD(IceRuby_Connection_getInfo), 0);
     rb_define_method(_connectionClass, "getEndpoint", CAST_METHOD(IceRuby_Connection_getEndpoint), 0);
     rb_define_method(_connectionClass, "setBufferSize", CAST_METHOD(IceRuby_Connection_setBufferSize), 2);
+    rb_define_method(_connectionClass, "throwException", CAST_METHOD(IceRuby_Connection_throwException), 0);
     rb_define_method(_connectionClass, "toString", CAST_METHOD(IceRuby_Connection_toString), 0);
     rb_define_method(_connectionClass, "to_s", CAST_METHOD(IceRuby_Connection_toString), 0);
     rb_define_method(_connectionClass, "inspect", CAST_METHOD(IceRuby_Connection_toString), 0);
@@ -462,7 +491,7 @@ IceRuby::initConnection(VALUE iceModule)
     //
     // WSConnectionInfo
     //
-    _wsConnectionInfoClass = rb_define_class_under(iceModule, "WSConnectionInfo", _ipConnectionInfoClass);
+    _wsConnectionInfoClass = rb_define_class_under(iceModule, "WSConnectionInfo", _connectionInfoClass);
 
     //
     // Instance members.
@@ -472,22 +501,25 @@ IceRuby::initConnection(VALUE iceModule)
     //
     // SSLConnectionInfo
     //
-    _sslConnectionInfoClass = rb_define_class_under(iceModule, "SSLConnectionInfo", _ipConnectionInfoClass);
+    _sslConnectionInfoClass = rb_define_class_under(iceModule, "SSLConnectionInfo", _connectionInfoClass);
 
     //
     // Instance members.
     //
-    rb_define_attr(_wsConnectionInfoClass, "cipher", 1, 0);
-    rb_define_attr(_wsConnectionInfoClass, "certs", 1, 0);
-    rb_define_attr(_wsConnectionInfoClass, "verified", 1, 0);
+    rb_define_attr(_sslConnectionInfoClass, "cipher", 1, 0);
+    rb_define_attr(_sslConnectionInfoClass, "certs", 1, 0);
+    rb_define_attr(_sslConnectionInfoClass, "verified", 1, 0);
+}
 
-    //
-    // WSSConnectionInfo
-    //
-    _wssConnectionInfoClass = rb_define_class_under(iceModule, "WSSConnectionInfo", _sslConnectionInfoClass);
+Ice::ConnectionPtr
+IceRuby::getConnection(VALUE v)
+{
+    Ice::ConnectionPtr* p = reinterpret_cast<Ice::ConnectionPtr*>(DATA_PTR(v));
+    return *p;
+}
 
-    //
-    // Instance members.
-    //
-    rb_define_attr(_wssConnectionInfoClass, "headers", 1, 0);
+bool
+IceRuby::checkConnection(VALUE v)
+{
+    return callRuby(rb_obj_is_kind_of, v, _connectionClass) == Qtrue;
 }

data/ext/Connection.h

@@ -1,11 +1,6 @@
-// **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) ZeroC, Inc. All rights reserved.
 //
-// This copy of Ice is licensed to you under the terms described in the
-// ICE_LICENSE file included in this distribution.
-//
-// **********************************************************************
 
 #ifndef ICE_RUBY_CONNECTION_H
 #define ICE_RUBY_CONNECTION_H
@@ -21,6 +16,9 @@ void initConnection(VALUE);
 VALUE createConnection(const Ice::ConnectionPtr&);
 VALUE createConnectionInfo(const Ice::ConnectionInfoPtr&);
 
+Ice::ConnectionPtr getConnection(VALUE);
+bool checkConnection(VALUE);
+
 }
 
 #endif

data/ext/Endpoint.cpp

@@ -1,11 +1,6 @@
-// **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) ZeroC, Inc. All rights reserved.
 //
-// This copy of Ice is licensed to you under the terms described in the
-// ICE_LICENSE file included in this distribution.
-//
-// **********************************************************************
 
 #include <Endpoint.h>
 #include <Util.h>
@@ -24,11 +19,8 @@ static VALUE _udpEndpointInfoClass;
 static VALUE _wsEndpointInfoClass;
 static VALUE _opaqueEndpointInfoClass;
 static VALUE _sslEndpointInfoClass;
-static VALUE _wssEndpointInfoClass;
 
-// **********************************************************************
 // Endpoint
-// **********************************************************************
 
 extern "C"
 void
@@ -116,10 +108,7 @@ IceRuby_Endpoint_equals(VALUE self, VALUE other)
     return IceRuby_Endpoint_cmp(self, other) == INT2NUM(0) ? Qtrue : Qfalse;
 }
 
-
-// **********************************************************************
 // EndpointInfo
-// **********************************************************************
 
 extern "C"
 void
@@ -132,34 +121,28 @@ IceRuby_EndpointInfo_free(Ice::EndpointPtr* p)
 VALUE
 IceRuby::createEndpointInfo(const Ice::EndpointInfoPtr& p)
 {
+    if(!p)
+    {
+        return Qnil;
+    }
+
     VALUE info;
     if(Ice::WSEndpointInfoPtr::dynamicCast(p))
     {
         info = Data_Wrap_Struct(_wsEndpointInfoClass, 0, IceRuby_EndpointInfo_free, new Ice::EndpointInfoPtr(p));
 
         Ice::WSEndpointInfoPtr ws = Ice::WSEndpointInfoPtr::dynamicCast(p);
-        rb_ivar_set(info, rb_intern("@host"), createString(ws->host));
-        rb_ivar_set(info, rb_intern("@port"), INT2FIX(ws->port));
-        rb_ivar_set(info, rb_intern("@sourceAddress"), createString(ws->sourceAddress));
         rb_ivar_set(info, rb_intern("@resource"), createString(ws->resource));
     }
     else if(Ice::TCPEndpointInfoPtr::dynamicCast(p))
     {
         info = Data_Wrap_Struct(_tcpEndpointInfoClass, 0, IceRuby_EndpointInfo_free, new Ice::EndpointInfoPtr(p));
-
-        Ice::TCPEndpointInfoPtr tcp = Ice::TCPEndpointInfoPtr::dynamicCast(p);
-        rb_ivar_set(info, rb_intern("@host"), createString(tcp->host));
-        rb_ivar_set(info, rb_intern("@port"), INT2FIX(tcp->port));
-        rb_ivar_set(info, rb_intern("@sourceAddress"), createString(tcp->sourceAddress));
     }
     else if(Ice::UDPEndpointInfoPtr::dynamicCast(p))
     {
         info = Data_Wrap_Struct(_udpEndpointInfoClass, 0, IceRuby_EndpointInfo_free, new Ice::EndpointInfoPtr(p));
 
         Ice::UDPEndpointInfoPtr udp = Ice::UDPEndpointInfoPtr::dynamicCast(p);
-        rb_ivar_set(info, rb_intern("@host"), createString(udp->host));
-        rb_ivar_set(info, rb_intern("@port"), INT2FIX(udp->port));
-        rb_ivar_set(info, rb_intern("@sourceAddress"), createString(udp->sourceAddress));
         rb_ivar_set(info, rb_intern("@mcastInterface"), createString(udp->mcastInterface));
         rb_ivar_set(info, rb_intern("@mcastTtl"), INT2FIX(udp->mcastTtl));
     }
@@ -173,39 +156,28 @@ IceRuby::createEndpointInfo(const Ice::EndpointInfoPtr& p)
         rb_ivar_set(info, rb_intern("@rawBytes"), v);
         rb_ivar_set(info, rb_intern("@rawEncoding"), createEncodingVersion(opaque->rawEncoding));
     }
-    else if(IceSSL::WSSEndpointInfoPtr::dynamicCast(p))
-    {
-        info = Data_Wrap_Struct(_wssEndpointInfoClass, 0, IceRuby_EndpointInfo_free, new Ice::EndpointInfoPtr(p));
-
-        IceSSL::WSSEndpointInfoPtr wss = IceSSL::WSSEndpointInfoPtr::dynamicCast(p);
-        rb_ivar_set(info, rb_intern("@host"), createString(wss->host));
-        rb_ivar_set(info, rb_intern("@port"), INT2FIX(wss->port));
-        rb_ivar_set(info, rb_intern("@sourceAddress"), createString(wss->sourceAddress));
-        rb_ivar_set(info, rb_intern("@resource"), createString(wss->resource));
-    }
     else if(IceSSL::EndpointInfoPtr::dynamicCast(p))
     {
         info = Data_Wrap_Struct(_sslEndpointInfoClass, 0, IceRuby_EndpointInfo_free, new Ice::EndpointInfoPtr(p));
-
-        IceSSL::EndpointInfoPtr ssl = IceSSL::EndpointInfoPtr::dynamicCast(p);
-        rb_ivar_set(info, rb_intern("@host"), createString(ssl->host));
-        rb_ivar_set(info, rb_intern("@port"), INT2FIX(ssl->port));
-        rb_ivar_set(info, rb_intern("@sourceAddress"), createString(ssl->sourceAddress));
     }
     else if(Ice::IPEndpointInfoPtr::dynamicCast(p))
     {
         info = Data_Wrap_Struct(_ipEndpointInfoClass, 0, IceRuby_EndpointInfo_free, new Ice::EndpointInfoPtr(p));
+    }
+    else
+    {
+        info = Data_Wrap_Struct(_endpointInfoClass, 0, IceRuby_EndpointInfo_free, new Ice::EndpointInfoPtr(p));
+    }
 
+    if(Ice::IPEndpointInfoPtr::dynamicCast(p))
+    {
         Ice::IPEndpointInfoPtr ip = Ice::IPEndpointInfoPtr::dynamicCast(p);
         rb_ivar_set(info, rb_intern("@host"), createString(ip->host));
         rb_ivar_set(info, rb_intern("@port"), INT2FIX(ip->port));
         rb_ivar_set(info, rb_intern("@sourceAddress"), createString(ip->sourceAddress));
     }
-    else
-    {
-        info = Data_Wrap_Struct(_endpointInfoClass, 0, IceRuby_EndpointInfo_free, new Ice::EndpointInfoPtr(p));
-    }
 
+    rb_ivar_set(info, rb_intern("@underlying"), createEndpointInfo(p->underlying));
     rb_ivar_set(info, rb_intern("@timeout"), INT2FIX(p->timeout));
     rb_ivar_set(info, rb_intern("@compress"), p->compress ? Qtrue : Qfalse);
     return info;
@@ -329,7 +301,7 @@ IceRuby::initEndpoint(VALUE iceModule)
     //
     // WSEndpointInfo
     //
-    _wsEndpointInfoClass = rb_define_class_under(iceModule, "WSEndpointInfo", _tcpEndpointInfoClass);
+    _wsEndpointInfoClass = rb_define_class_under(iceModule, "WSEndpointInfo", _endpointInfoClass);
 
     //
     // Instance members.
@@ -350,17 +322,7 @@ IceRuby::initEndpoint(VALUE iceModule)
     //
     // SSLEndpointInfo
     //
-    _sslEndpointInfoClass = rb_define_class_under(iceModule, "SSLEndpointInfo", _ipEndpointInfoClass);
-
-    //
-    // WSSEndpointInfo
-    //
-    _wssEndpointInfoClass = rb_define_class_under(iceModule, "WSSEndpointInfo", _sslEndpointInfoClass);
-
-    //
-    // Instance members.
-    //
-    rb_define_attr(_wssEndpointInfoClass, "resource", 1, 0);
+    _sslEndpointInfoClass = rb_define_class_under(iceModule, "SSLEndpointInfo", _endpointInfoClass);
 }
 
 bool