Refactored SSL and iAP transports, support for running SSL on top

of TCP/iAP/Bluetooth.

9 files changed, 265 insertions, 223 deletions

diff --git a/objective-c/src/Ice/ConnectionI.h b/objective-c/src/Ice/ConnectionI.h
index ec9bb84f68c..1ae96037183 100644
--- a/objective-c/src/Ice/ConnectionI.h
+++ b/objective-c/src/Ice/ConnectionI.h
@@ -8,11 +8,16 @@
 // **********************************************************************
 
 #import <objc/Ice/Connection.h>
-
 #import <objc/Ice/LocalObject.h>
 
 #include <Ice/Connection.h>
-//#include <IceSSL/ConnectionInfo.h>
+
+namespace IceObjC
+{
+
+ICE_API void registerConnectionInfoClass(Class cl);
+
+}
 
 @interface ICEConnectionInfo (ICEInternal)
 -(id) initWithConnectionInfo:(Ice::ConnectionInfo*)connectionInfo;
@@ -34,9 +39,5 @@
 -(id) initWithWSConnectionInfo:(Ice::WSConnectionInfo*)wsConnectionInfo;
 @end
 
-// @interface ICESSLConnectionInfo (ICEInternal)
-// -(id) initWithSSLConnectionInfo:(IceSSL::ConnectionInfo*)sslConnectionInfo;
-// @end
-
 @interface ICEConnection : ICELocalObject<ICEConnection>
 @end
diff --git a/objective-c/src/Ice/ConnectionI.mm b/objective-c/src/Ice/ConnectionI.mm
index 6e4e290b8b4..5dc6a0ff89b 100644
--- a/objective-c/src/Ice/ConnectionI.mm
+++ b/objective-c/src/Ice/ConnectionI.mm
@@ -2,7 +2,7 @@
 //
 // Copyright (c) 2003-2016 ZeroC, Inc. All rights reserved.
 //
-// This copy of Ice is licensed to you under the terms described in the
+// This copy of Ice is licensed to you  the terms described in the
 // ICE_LICENSE file included in this distribution.
 //
 // **********************************************************************
@@ -19,18 +19,92 @@
 
 #import <objc/runtime.h>
 
+#define CONNECTION dynamic_cast<Ice::Connection*>(static_cast<IceUtil::Shared*>(cxxObject_))
+
+namespace
+{
+
+std::vector<Class>* connectionInfoClasses = 0;
+
+}
+
+namespace IceObjC
+{
+
+void
+registerConnectionInfoClass(Class cl)
+{
+    if(!connectionInfoClasses)
+    {
+        connectionInfoClasses = new std::vector<Class>();
+    }
+    connectionInfoClasses->push_back(cl);
+}
+
+}
+
 @implementation ICEConnectionInfo (ICEInternal)
 
++(id) checkedConnectionInfoWithConnectionInfo:(Ice::ConnectionInfo*)connectionInfo
+{
+    assert(false);
+    return nil;
+}
+
++(id) connectionInfoWithConnectionInfo:(NSValue*)v
+{
+    Ice::ConnectionInfo* info = dynamic_cast<Ice::ConnectionInfo*>(reinterpret_cast<IceUtil::Shared*>(v.pointerValue));
+    if(!info)
+    {
+        return nil;
+    }
+
+    Ice::UDPConnectionInfoPtr udpInfo = Ice::UDPConnectionInfoPtr::dynamicCast(info);
+    if(udpInfo)
+    {
+        return [[ICEUDPConnectionInfo alloc] initWithUDPConnectionInfo:udpInfo.get()];
+    }
+
+    Ice::WSConnectionInfoPtr wsInfo = Ice::WSConnectionInfoPtr::dynamicCast(info);
+    if(wsInfo)
+    {
+        return [[ICEWSConnectionInfo alloc] initWithWSConnectionInfo:wsInfo.get()];
+    }
+
+    Ice::TCPConnectionInfoPtr tcpInfo = Ice::TCPConnectionInfoPtr::dynamicCast(info);
+    if(tcpInfo)
+    {
+        return [[ICETCPConnectionInfo alloc] initWithTCPConnectionInfo:tcpInfo.get()];
+    }
+
+    for(std::vector<Class>::const_iterator p = connectionInfoClasses->begin(); p != connectionInfoClasses->end(); ++p)
+    {
+        ICEConnectionInfo* r = [*p checkedConnectionInfoWithConnectionInfo:info];
+        if(r)
+        {
+            return r;
+        }
+    }
+
+    Ice::IPConnectionInfoPtr ipInfo = Ice::IPConnectionInfoPtr::dynamicCast(info);
+    if(ipInfo)
+    {
+        return [[ICEIPConnectionInfo alloc] initWithIPConnectionInfo:ipInfo.get()];
+    }
+
+    return [[ICEConnectionInfo alloc] initWithConnectionInfo:info];
+}
+
 -(id) initWithConnectionInfo:(Ice::ConnectionInfo*)connectionInfo;
 {
     self = [super initWithCxxObject:connectionInfo];
     if(self != nil)
     {
+        self->underlying = [ICEConnectionInfo localObjectWithCxxObjectNoAutoRelease:connectionInfo->underlying.get()
+                                                            allocator:@selector(connectionInfoWithConnectionInfo:)];
         self->incoming = connectionInfo->incoming;
         self->adapterName = [[NSString alloc] initWithUTF8String:connectionInfo->adapterName.c_str()];
         self->connectionId = [[NSString alloc] initWithUTF8String:connectionInfo->connectionId.c_str()];
-        self->rcvSize = connectionInfo->rcvSize;
-        self->sndSize = connectionInfo->sndSize;
     }
     return self;
 }
@@ -58,6 +132,11 @@
 -(id) initWithTCPConnectionInfo:(Ice::TCPConnectionInfo*)tcpConnectionInfo
 {
     self = [super initWithIPConnectionInfo:tcpConnectionInfo];
+    if(self)
+    {
+        self->rcvSize = tcpConnectionInfo->rcvSize;
+        self->sndSize = tcpConnectionInfo->sndSize;
+    }
     return self;
 }
 @end
@@ -71,6 +150,8 @@
     {
         self->mcastAddress = [[NSString alloc] initWithUTF8String:udpConnectionInfo->mcastAddress.c_str()];
         self->mcastPort = udpConnectionInfo->mcastPort;
+        self->rcvSize = udpConnectionInfo->rcvSize;
+        self->sndSize = udpConnectionInfo->sndSize;
     }
     return self;
 }
@@ -80,7 +161,7 @@
 @implementation ICEWSConnectionInfo (ICEInternal)
 -(id) initWithWSConnectionInfo:(Ice::WSConnectionInfo*)wsConnectionInfo
 {
-    self = [super initWithIPConnectionInfo:wsConnectionInfo];
+    self = [super initWithConnectionInfo:wsConnectionInfo];
     if(self)
     {
         self->headers = toNSDictionary(wsConnectionInfo->headers);
@@ -180,8 +261,6 @@ private:
 
 }
 
-#define CONNECTION dynamic_cast<Ice::Connection*>(static_cast<IceUtil::Shared*>(cxxObject_))
-
 @implementation ICEConnection
 -(void) close:(BOOL)force
 {
@@ -344,46 +423,8 @@ private:
     NSException* nsex = nil;
     try
     {
-        Ice::ConnectionInfoPtr info = CONNECTION->getInfo();
-        if(!info)
-        {
-            return nil;
-        }
-
-        Ice::UDPConnectionInfoPtr udpInfo = Ice::UDPConnectionInfoPtr::dynamicCast(info);
-        if(udpInfo)
-        {
-            return [[[ICEUDPConnectionInfo alloc] initWithUDPConnectionInfo:udpInfo.get()] autorelease];
-        }
-
-        Ice::WSConnectionInfoPtr wsInfo = Ice::WSConnectionInfoPtr::dynamicCast(info);
-        if(wsInfo)
-        {
-            return [[[ICEWSConnectionInfo alloc] initWithWSConnectionInfo:wsInfo.get()] autorelease];
-        }
-
-        Ice::TCPConnectionInfoPtr tcpInfo = Ice::TCPConnectionInfoPtr::dynamicCast(info);
-        if(tcpInfo)
-        {
-            return [[[ICETCPConnectionInfo alloc] initWithTCPConnectionInfo:tcpInfo.get()] autorelease];
-        }
-
-        std::ostringstream os;
-        os << "connectionInfoWithType_" << CONNECTION->type() << ":";
-        SEL selector = sel_registerName(os.str().c_str());
-        if([ICEConnectionInfo respondsToSelector:selector])
-        {
-            IceUtil::Shared* shared = info.get();
-            return [ICEConnectionInfo performSelector:selector withObject:[NSValue valueWithPointer:shared]];
-        }
-
-        Ice::IPConnectionInfoPtr ipInfo = Ice::IPConnectionInfoPtr::dynamicCast(info);
-        if(ipInfo)
-        {
-            return [[[ICEIPConnectionInfo alloc] initWithIPConnectionInfo:ipInfo.get()] autorelease];
-        }
-
-        return [[[ICEConnectionInfo alloc] initWithConnectionInfo:info.get()] autorelease];
+        return [ICEConnectionInfo localObjectWithCxxObject:CONNECTION->getInfo().get()
+                                                 allocator:@selector(connectionInfoWithConnectionInfo:)];
     }
     catch(const std::exception& ex)
     {
diff --git a/objective-c/src/Ice/EndpointI.h b/objective-c/src/Ice/EndpointI.h
index 60db2cb2cca..360b8ffda23 100644
--- a/objective-c/src/Ice/EndpointI.h
+++ b/objective-c/src/Ice/EndpointI.h
@@ -8,11 +8,17 @@
 // **********************************************************************
 
 #import <objc/Ice/Endpoint.h>
-
 #import <objc/Ice/LocalObject.h>
 
 #include <Ice/Endpoint.h>
 
+namespace IceObjC
+{
+
+ICE_API void registerEndpointInfoClass(Class cl);
+
+}
+
 @interface ICEEndpoint : ICELocalObject<ICEEndpoint>
 -(Ice::Endpoint*) endpoint;
 @end
diff --git a/objective-c/src/Ice/EndpointI.mm b/objective-c/src/Ice/EndpointI.mm
index d8e52ded896..757a19a266c 100644
--- a/objective-c/src/Ice/EndpointI.mm
+++ b/objective-c/src/Ice/EndpointI.mm
@@ -21,90 +21,93 @@
 #define ENDPOINT dynamic_cast<Ice::Endpoint*>(static_cast<IceUtil::Shared*>(cxxObject_))
 #define ENDPOINTINFO dynamic_cast<Ice::EndpointInfo*>(static_cast<IceUtil::Shared*>(cxxObject_))
 
-@implementation ICEEndpoint
-
--(Ice::Endpoint*) endpoint
+namespace
 {
-    return ENDPOINT;
+
+std::vector<Class>* endpointInfoClasses = 0;
+
 }
 
--(ICEEndpointInfo*) getInfo
+namespace IceObjC
 {
-    NSException* nsex = nil;
-    try
+
+void
+registerEndpointInfoClass(Class cl)
+{
+    if(!endpointInfoClasses)
     {
-        Ice::EndpointInfoPtr info = ENDPOINT->getInfo();
-        if(!info)
-        {
-            return nil;
-        }
-        
-        Ice::UDPEndpointInfoPtr udpInfo = Ice::UDPEndpointInfoPtr::dynamicCast(info);
-        if(udpInfo)
-        {
-            return [[[ICEUDPEndpointInfo alloc] initWithUDPEndpointInfo:udpInfo.get()] autorelease];
-        }
+        endpointInfoClasses = new std::vector<Class>();
+    }
+    endpointInfoClasses->push_back(cl);
+}
 
-        Ice::WSEndpointInfoPtr wsInfo = Ice::WSEndpointInfoPtr::dynamicCast(info);
-        if(wsInfo)
-        {
-            return [[[ICEWSEndpointInfo alloc] initWithWSEndpointInfo:wsInfo.get()] autorelease];
-        }
+}
 
-        Ice::TCPEndpointInfoPtr tcpInfo = Ice::TCPEndpointInfoPtr::dynamicCast(info);
-        if(tcpInfo)
-        {
-            return [[[ICETCPEndpointInfo alloc] initWithTCPEndpointInfo:tcpInfo.get()] autorelease];
-        }
+@implementation ICEEndpointInfo(ICEInternal)
 
-        Ice::OpaqueEndpointInfoPtr opaqueInfo = Ice::OpaqueEndpointInfoPtr::dynamicCast(info);
-        if(opaqueInfo)
-        {
-            return [[[ICEOpaqueEndpointInfo alloc] initWithOpaqueEndpointInfo:opaqueInfo.get()] autorelease];
-        }
-        
-        std::ostringstream os;
-        os << "endpointInfoWithType_" << info->type() << ":";
-        SEL selector = sel_registerName(os.str().c_str());
-        if([ICEEndpointInfo respondsToSelector:selector])
-        {
-            IceUtil::Shared* shared = info.get();
-            return [ICEEndpointInfo performSelector:selector withObject:[NSValue valueWithPointer:shared]];
-        }
++(id) checkedEndpointInfoWithEndpointInfo:(Ice::EndpointInfo*)endpointInfo
+{
+    assert(false);
+    return nil;
+}
 
-        Ice::IPEndpointInfoPtr ipInfo = Ice::IPEndpointInfoPtr::dynamicCast(info);
-        if(ipInfo)
-        {
-            return [[[ICEIPEndpointInfo alloc] initWithIPEndpointInfo:ipInfo.get()] autorelease];
-        }
++(id) endpointInfoWithEndpointInfo:(NSValue*)v
+{
+    Ice::EndpointInfo* info = dynamic_cast<Ice::EndpointInfo*>(reinterpret_cast<IceUtil::Shared*>([v pointerValue]));
+    if(!info)
+    {
+        return nil;
+    }
 
-        return [[[ICEEndpointInfo alloc] initWithEndpointInfo:info.get()] autorelease];
+    Ice::UDPEndpointInfoPtr udpInfo = Ice::UDPEndpointInfoPtr::dynamicCast(info);
+    if(udpInfo)
+    {
+        return [[ICEUDPEndpointInfo alloc] initWithUDPEndpointInfo:udpInfo.get()];
     }
-    catch(const std::exception& ex)
+
+    Ice::WSEndpointInfoPtr wsInfo = Ice::WSEndpointInfoPtr::dynamicCast(info);
+    if(wsInfo)
     {
-        nsex = toObjCException(ex);
+        return [[ICEWSEndpointInfo alloc] initWithWSEndpointInfo:wsInfo.get()];
     }
-    if(nsex != nil)
+
+    Ice::TCPEndpointInfoPtr tcpInfo = Ice::TCPEndpointInfoPtr::dynamicCast(info);
+    if(tcpInfo)
     {
-        @throw nsex;
+        return [[ICETCPEndpointInfo alloc] initWithTCPEndpointInfo:tcpInfo.get()];
     }
-    return nil;
-}
 
--(NSMutableString*) toString
-{
-    return [toNSMutableString(ENDPOINT->toString()) autorelease];
-}
+    Ice::OpaqueEndpointInfoPtr opaqueInfo = Ice::OpaqueEndpointInfoPtr::dynamicCast(info);
+    if(opaqueInfo)
+    {
+        return [[ICEOpaqueEndpointInfo alloc] initWithOpaqueEndpointInfo:opaqueInfo.get()];
+    }
 
-@end
+    for(std::vector<Class>::const_iterator p = endpointInfoClasses->begin(); p != endpointInfoClasses->end(); ++p)
+    {
+        ICEEndpointInfo* r = [*p checkedEndpointInfoWithEndpointInfo:info];
+        if(r)
+        {
+            return r;
+        }
+    }
 
-@implementation ICEEndpointInfo(ICEInternal)
+    Ice::IPEndpointInfoPtr ipInfo = Ice::IPEndpointInfoPtr::dynamicCast(info);
+    if(ipInfo)
+    {
+        return [[ICEIPEndpointInfo alloc] initWithIPEndpointInfo:ipInfo.get()];
+    }
+
+    return [[ICEEndpointInfo alloc] initWithEndpointInfo:info];
+}
 
 -(id) initWithEndpointInfo:(Ice::EndpointInfo*)endpointInfo;
 {
     self = [super initWithCxxObject:endpointInfo];
     if(self)
     {
+        self->underlying = [ICEEndpointInfo localObjectWithCxxObjectNoAutoRelease:endpointInfo->underlying.get()
+                                            allocator:@selector(endpointInfoWithEndpointInfo:)];
         self->timeout = endpointInfo->timeout;
         self->compress = endpointInfo->compress;
     }
@@ -170,7 +173,7 @@
 
 -(id) initWithWSEndpointInfo:(Ice::WSEndpointInfo*)wsEndpointInfo
 {
-    self = [super initWithIPEndpointInfo:wsEndpointInfo];
+    self = [super initWithEndpointInfo:wsEndpointInfo];
     if(self)
     {
         self->resource = [[NSString alloc] initWithUTF8String:wsEndpointInfo->resource.c_str()];
@@ -194,3 +197,37 @@
 }
 
 @end
+
+@implementation ICEEndpoint
+
+-(Ice::Endpoint*) endpoint
+{
+    return ENDPOINT;
+}
+
+-(ICEEndpointInfo*) getInfo
+{
+    NSException* nsex = nil;
+    try
+    {
+        return [ICEEndpointInfo localObjectWithCxxObject:ENDPOINT->getInfo().get()
+                                               allocator:@selector(endpointInfoWithEndpointInfo:)];
+    }
+    catch(const std::exception& ex)
+    {
+        nsex = toObjCException(ex);
+    }
+    if(nsex != nil)
+    {
+        @throw nsex;
+    }
+    return nil;
+}
+
+-(NSMutableString*) toString
+{
+    return [toNSMutableString(ENDPOINT->toString()) autorelease];
+}
+
+@end
+
diff --git a/objective-c/src/Ice/Initialize.mm b/objective-c/src/Ice/Initialize.mm
index b40c0672f1d..b1ea0d6dd38 100644
--- a/objective-c/src/Ice/Initialize.mm
+++ b/objective-c/src/Ice/Initialize.mm
@@ -21,6 +21,7 @@
 #import <objc/Ice/LocalException.h>
 
 #include <Ice/Initialize.h>
+#include <Ice/RegisterPlugins.h>
 #include <IceUtil/UUID.h>
 #include <IceUtil/MutexPtrLock.h>
 
@@ -33,6 +34,21 @@
 #  define ICE_USE_CFSTREAM 1
 #endif
 
+extern "C"
+{
+
+Ice::Plugin*
+createIceSSL(const Ice::CommunicatorPtr&, const std::string&, const Ice::StringSeq&);
+Ice::Plugin*
+createIceDiscovery(const Ice::CommunicatorPtr&, const std::string&, const Ice::StringSeq&);
+Ice::Plugin*
+createIceLocatorDiscovery(const Ice::CommunicatorPtr&, const std::string&, const Ice::StringSeq&);
+#if defined(__APPLE__) && TARGET_OS_IPHONE > 0
+Ice::Plugin*
+createIceIAP(const Ice::CommunicatorPtr&, const std::string&, const Ice::StringSeq&);
+#endif
+}
+
 namespace
 {
 typedef std::map<int, std::string> CompactIdMap;
diff --git a/objective-c/src/Ice/LocalObject.mm b/objective-c/src/Ice/LocalObject.mm
index 7c80effca05..70b7dc692fa 100644
--- a/objective-c/src/Ice/LocalObject.mm
+++ b/objective-c/src/Ice/LocalObject.mm
@@ -16,7 +16,7 @@
 
 #define CXXOBJECT ((IceUtil::Shared*)cxxObject_)
 
-namespace 
+namespace
 {
 
 std::map<IceUtil::Shared*, ICELocalObject*> cachedObjects;
@@ -59,7 +59,7 @@ std::map<IceUtil::Shared*, ICELocalObject*> cachedObjects;
 }
 
 -(void) dealloc
-{  
+{
     if(cxxObject_)
     {
         //
@@ -84,7 +84,7 @@ std::map<IceUtil::Shared*, ICELocalObject*> cachedObjects;
     {
         return nil;
     }
-    
+
     @synchronized([ICELocalObject class])
     {
         std::map<IceUtil::Shared*, ICELocalObject*>::const_iterator p = cachedObjects.find(arg);
@@ -102,7 +102,7 @@ std::map<IceUtil::Shared*, ICELocalObject*> cachedObjects;
     {
         return nil;
     }
-    
+
     @synchronized([ICELocalObject class])
     {
         std::map<IceUtil::Shared*, ICELocalObject*>::const_iterator p = cachedObjects.find(arg);
@@ -118,11 +118,37 @@ std::map<IceUtil::Shared*, ICELocalObject*> cachedObjects;
     return nil; // Keep the compiler happy.
 }
 
++(id) localObjectWithCxxObjectNoAutoRelease:(IceUtil::Shared*)arg allocator:(SEL)alloc
+{
+    if(arg == 0)
+    {
+        return nil;
+    }
+
+    @synchronized([ICELocalObject class])
+    {
+        std::map<IceUtil::Shared*, ICELocalObject*>::const_iterator p = cachedObjects.find(arg);
+        if(p != cachedObjects.end())
+        {
+            return [p->second retain];
+        }
+        else
+        {
+            return [self performSelector:alloc withObject:[NSValue valueWithPointer:arg]];
+        }
+    }
+    return nil; // Keep the compiler happy.
+}
+
 +(id) localObjectWithCxxObject:(IceUtil::Shared*)arg
 {
     return [[self localObjectWithCxxObjectNoAutoRelease:arg] autorelease];
 }
 
++(id) localObjectWithCxxObject:(IceUtil::Shared*)arg allocator:(SEL)alloc
+{
+    return [[self localObjectWithCxxObjectNoAutoRelease:arg allocator:alloc] autorelease];
+}
 
 -(id) retain
 {
@@ -132,7 +158,7 @@ std::map<IceUtil::Shared*, ICELocalObject*> cachedObjects;
 
 -(oneway void) release
 {
-    @synchronized([ICELocalObject class])  
+    @synchronized([ICELocalObject class])
     {
         if(NSDecrementExtraRefCountWasZero(self))
         {
diff --git a/objective-c/src/Ice/LocalObjectI.h b/objective-c/src/Ice/LocalObjectI.h
index 35790a2dcac..bb8eec04ed1 100644
--- a/objective-c/src/Ice/LocalObjectI.h
+++ b/objective-c/src/Ice/LocalObjectI.h
@@ -24,7 +24,9 @@ class Shared;
 +(id) getLocalObjectWithCxxObjectNoAutoRelease:(IceUtil::Shared*)arg;
 
 +(id) localObjectWithCxxObjectNoAutoRelease:(IceUtil::Shared*)arg;
++(id) localObjectWithCxxObjectNoAutoRelease:(IceUtil::Shared*)arg allocator:(SEL)alloc;
 +(id) localObjectWithCxxObject:(IceUtil::Shared*)arg;
++(id) localObjectWithCxxObject:(IceUtil::Shared*)arg allocator:(SEL)alloc;
 
 -(IceUtil::Shared*) cxxObject;
 @end
diff --git a/objective-c/src/IceSSL/ConnectionInfoI.mm b/objective-c/src/IceSSL/ConnectionInfoI.mm
index 337d4d46955..53357fd3de5 100644
--- a/objective-c/src/IceSSL/ConnectionInfoI.mm
+++ b/objective-c/src/IceSSL/ConnectionInfoI.mm
@@ -16,9 +16,14 @@
 
 @implementation ICESSLConnectionInfo (IceSSL)
 
++(void) load
+{
+    IceObjC::registerConnectionInfoClass([ICESSLConnectionInfo class]);
+}
+
 -(id) initWithSSLConnectionInfo:(IceSSL::ConnectionInfo*)sslConnectionInfo
 {
-    self = [super initWithIPConnectionInfo:sslConnectionInfo];
+    self = [super initWithConnectionInfo:sslConnectionInfo];
     if(self)
     {
         self->cipher = [[NSString alloc] initWithUTF8String:sslConnectionInfo->cipher.c_str()];
@@ -28,56 +33,12 @@
     return self;
 }
 
-@end
-
-@implementation ICEConnectionInfo (IceSSL)
-
-+(id) connectionInfoWithType_ssl:(NSValue*)connectionInfo
++(id) checkedConnectionInfoWithConnectionInfo:(Ice::ConnectionInfo*)connectionInfo
 {
-    if(!connectionInfo)
-    {
-        return nil;
-    }
-
-    IceUtil::Shared* shared = reinterpret_cast<IceUtil::Shared*>([connectionInfo pointerValue]);
-    IceSSL::ConnectionInfo* obj = dynamic_cast<IceSSL::ConnectionInfo*>(shared);
-    if(obj)
-    {
-        return [[[ICESSLConnectionInfo alloc] initWithSSLConnectionInfo:obj] autorelease];
-    }
-    return nil;
-}
-
-@end
-
-@implementation ICESSLWSSConnectionInfo (IceSSL)
-
--(id) initWithWSSConnectionInfo:(IceSSL::WSSConnectionInfo*)wssConnectionInfo
-{
-    self = [super initWithSSLConnectionInfo:wssConnectionInfo];
-    if(self)
-    {
-        self->headers = toNSDictionary(wssConnectionInfo->headers);
-    }
-    return self;
-}
-
-@end
-
-@implementation ICEConnectionInfo (IceSSLWSS)
-
-+(id) connectionInfoWithType_wss:(NSValue*)connectionInfo
-{
-    if(!connectionInfo)
-    {
-        return nil;
-    }
-
-    IceUtil::Shared* shared = reinterpret_cast<IceUtil::Shared*>([connectionInfo pointerValue]);
-    IceSSL::WSSConnectionInfo* obj = dynamic_cast<IceSSL::WSSConnectionInfo*>(shared);
-    if(obj)
+    IceSSL::ConnectionInfo* sslConnectionInfo = dynamic_cast<IceSSL::ConnectionInfo*>(connectionInfo);
+    if(sslConnectionInfo)
     {
-        return [[[ICESSLWSSConnectionInfo alloc] initWithWSSConnectionInfo:obj] autorelease];
+        return [[ICESSLConnectionInfo alloc] initWithSSLConnectionInfo:sslConnectionInfo];
     }
     return nil;
 }
diff --git a/objective-c/src/IceSSL/EndpointInfoI.mm b/objective-c/src/IceSSL/EndpointInfoI.mm
index e149256f315..ce6cd7ee401 100644
--- a/objective-c/src/IceSSL/EndpointInfoI.mm
+++ b/objective-c/src/IceSSL/EndpointInfoI.mm
@@ -8,73 +8,25 @@
 // **********************************************************************
 
 #import <objc/IceSSL/EndpointInfo.h>
-#import <ConnectionI.h>
+#import <EndpointI.h>
 #import <LocalObjectI.h>
 #import <Util.h>
 
 #include <IceSSL/EndpointInfo.h>
 
 @implementation ICESSLEndpointInfo (IceSSL)
-
--(id) initWithSSLEndpointInfo:(IceSSL::EndpointInfo*)sslEndpointInfo
++(void) load
 {
-    self = [super initWithIPEndpointInfo:sslEndpointInfo];
-    return self;
+    IceObjC::registerEndpointInfoClass([ICESSLEndpointInfo class]);
 }
 
-@end
-
-@implementation ICEEndpointInfo (IceSSL)
-
-+(id) endpointInfoWithType_2:(NSValue*)endpointInfo
++(id) checkedEndpointInfoWithEndpointInfo:(Ice::EndpointInfo*)endpointInfo
 {
-    if(!endpointInfo)
+    IceSSL::EndpointInfo* sslEndpointInfo = dynamic_cast<IceSSL::EndpointInfo*>(endpointInfo);
+    if(sslEndpointInfo)
     {
-        return nil;
-    }
-
-    IceUtil::Shared* shared = reinterpret_cast<IceUtil::Shared*>([endpointInfo pointerValue]);
-    IceSSL::EndpointInfo* obj = dynamic_cast<IceSSL::EndpointInfo*>(shared);
-    if(obj)
-    {
-        return [[[ICESSLEndpointInfo alloc] initWithSSLEndpointInfo:obj] autorelease];
+        return [[ICESSLEndpointInfo alloc] initWithEndpointInfo:sslEndpointInfo];
     }
     return nil;
 }
-
 @end
-
-@implementation ICESSLWSSEndpointInfo (IceSSL)
-
--(id) initWithWSSEndpointInfo:(IceSSL::WSSEndpointInfo*)wssEndpointInfo
-{
-    self = [super initWithSSLEndpointInfo:wssEndpointInfo];
-    if(self)
-    {
-        self->resource = [[NSString alloc] initWithUTF8String:wssEndpointInfo->resource.c_str()];
-    }
-    return self;
-}
-
-@end
-
-@implementation ICEEndpointInfo (IceSSLWSS)
-
-+(id) endpointInfoWithType_5:(NSValue*)endpointInfo
-{
-    if(!endpointInfo)
-    {
-        return nil;
-    }
-
-    IceUtil::Shared* shared = reinterpret_cast<IceUtil::Shared*>([endpointInfo pointerValue]);
-    IceSSL::WSSEndpointInfo* obj = dynamic_cast<IceSSL::WSSEndpointInfo*>(shared);
-    if(obj)
-    {
-        return [[[ICESSLWSSEndpointInfo alloc] initWithWSSEndpointInfo:obj] autorelease];
-    }
-    return nil;
-}
-
-@end
-