zeroc-ice 3.7.2 → 3.7.3

data/ext/ice/cpp/src/IceSSL/SecureTransportTransceiverI.cpp

@@ -120,7 +120,8 @@ checkTrustResult(SecTrustRef trust,
         //
         if(engine->getCheckCertName() && !host.empty())
         {
-            UniqueRef<SecPolicyRef> policy(SecPolicyCreateSSL(false, toCFString(host)));
+            UniqueRef<CFStringRef> hostref(toCFString(host));
+            UniqueRef<SecPolicyRef> policy(SecPolicyCreateSSL(false, hostref.get()));
             UniqueRef<CFArrayRef> policies;
             if((err = SecTrustCopyPolicies(trust, &policies.get())))
             {
@@ -212,8 +213,10 @@ IceSSL::SecureTransport::TransceiverI::initialize(IceInternal::Buffer& readBuffe
     //
     if(_delegate->getNativeInfo()->fd() != INVALID_SOCKET)
     {
-        _maxSendPacketSize = std::max(512, IceInternal::getSendBufferSize(_delegate->getNativeInfo()->fd()));
-        _maxRecvPacketSize = std::max(512, IceInternal::getRecvBufferSize(_delegate->getNativeInfo()->fd()));
+        _maxSendPacketSize =
+            static_cast<size_t>(std::max(512, IceInternal::getSendBufferSize(_delegate->getNativeInfo()->fd())));
+        _maxRecvPacketSize =
+            static_cast<size_t>(std::max(512, IceInternal::getRecvBufferSize(_delegate->getNativeInfo()->fd())));
     }
     else
     {
@@ -239,6 +242,18 @@ IceSSL::SecureTransport::TransceiverI::initialize(IceInternal::Buffer& readBuffe
             throw SecurityException(__FILE__, __LINE__, "IceSSL: setting SSL connection failed\n" +
                                     sslErrorToString(err));
         }
+
+        //
+        // Enable SNI
+        //
+        if(!_incoming && _engine->getServerNameIndication() && !_host.empty() && !IceInternal::isIpAddress(_host))
+        {
+            if((err = SSLSetPeerDomainName(_ssl.get(), _host.data(), _host.length())))
+            {
+                throw SecurityException(__FILE__, __LINE__, "IceSSL: setting SNI host failed `" + _host + "'\n" +
+                                        sslErrorToString(err));
+            }
+        }
     }
 
     SSLSessionState state;
@@ -289,7 +304,7 @@ IceSSL::SecureTransport::TransceiverI::initialize(IceInternal::Buffer& readBuffe
         throw ProtocolException(__FILE__, __LINE__, os.str());
     }
 
-    for(int i = 0, count = SecTrustGetCertificateCount(_trust.get()); i < count; ++i)
+    for(CFIndex i = 0, count = SecTrustGetCertificateCount(_trust.get()); i < count; ++i)
     {
         SecCertificateRef cert = SecTrustGetCertificateAtIndex(_trust.get(), i);
         CFRetain(cert);
@@ -583,7 +598,7 @@ IceSSL::SecureTransport::TransceiverI::writeRaw(const char* data, size_t* length
         IceInternal::SocketOperation op = _delegate->write(buf);
         if(op == IceInternal::SocketOperationWrite)
         {
-            *length = buf.i - buf.b.begin();
+            *length = static_cast<size_t>(buf.i - buf.b.begin());
             _tflags |= SSLWantWrite;
             return errSSLWouldBlock;
         }
@@ -616,7 +631,7 @@ IceSSL::SecureTransport::TransceiverI::readRaw(char* data, size_t* length) const
         IceInternal::SocketOperation op = _delegate->read(buf);
         if(op == IceInternal::SocketOperationRead)
         {
-            *length = buf.i - buf.b.begin();
+            *length = static_cast<size_t>(buf.i - buf.b.begin());
             _tflags |= SSLWantRead;
             return errSSLWouldBlock;
         }

data/ext/ice/cpp/src/IceSSL/SecureTransportUtil.cpp

@@ -36,12 +36,13 @@ readCertFile(const string& file)
     }
 
     is.seekg(0, is.end);
-    size_t size = is.tellg();
+    size_t size = static_cast<size_t>(is.tellg());
     is.seekg(0, is.beg);
 
-    UniqueRef<CFMutableDataRef> data(CFDataCreateMutable(kCFAllocatorDefault, size));
-    CFDataSetLength(data.get(), size);
-    is.read(reinterpret_cast<char*>(CFDataGetMutableBytePtr(data.get())), size);
+    UniqueRef<CFMutableDataRef> data(CFDataCreateMutable(kCFAllocatorDefault, static_cast<CFIndex>(size)));
+    CFDataSetLength(data.get(), static_cast<CFIndex>(size));
+    is.read(reinterpret_cast<char*>(CFDataGetMutableBytePtr(data.get())),
+            static_cast<streamsize>(size));
     if(!is.good())
     {
         throw CertificateReadException(__FILE__, __LINE__, "error reading file " + file);
@@ -112,7 +113,7 @@ isCA(SecCertificateRef cert)
     if(property)
     {
         CFArrayRef propertyValues = static_cast<CFArrayRef>(CFDictionaryGetValue(property.get(), kSecPropertyKeyValue));
-        for(int i = 0, size = CFArrayGetCount(propertyValues); i < size; ++i)
+        for(CFIndex i = 0, size = CFArrayGetCount(propertyValues); i < size; ++i)
         {
             CFDictionaryRef dict = static_cast<CFDictionaryRef>(CFArrayGetValueAtIndex(propertyValues, i));
             CFStringRef label = static_cast<CFStringRef>(CFDictionaryGetValue(dict, kSecPropertyKeyLabel));
@@ -243,7 +244,7 @@ openKeychain(const std::string& path, const std::string& keychainPassword)
     if(err == noErr)
     {
         const char* pass = keychainPassword.empty() ? 0 : keychainPassword.c_str();
-        if((err = SecKeychainUnlock(keychain.get(), keychainPassword.size(), pass, pass != 0)))
+        if((err = SecKeychainUnlock(keychain.get(), static_cast<UInt32>(keychainPassword.size()), pass, pass != 0)))
         {
             throw PluginInitializationException(__FILE__, __LINE__,
                                                 "IceSSL: unable to unlock keychain:\n" + sslErrorToString(err));
@@ -253,7 +254,8 @@ openKeychain(const std::string& path, const std::string& keychainPassword)
     {
         const char* pass = keychainPassword.empty() ? 0 : keychainPassword.c_str();
         keychain.reset(0);
-        if((err = SecKeychainCreate(keychainPath.c_str(), keychainPassword.size(), pass, pass == 0, 0, &keychain.get())))
+        if((err = SecKeychainCreate(keychainPath.c_str(),
+                                    static_cast<UInt32>(keychainPassword.size()), pass, pass == 0, 0, &keychain.get())))
         {
             throw PluginInitializationException(__FILE__, __LINE__,
                                                 "IceSSL: unable to create keychain:\n" + sslErrorToString(err));
@@ -354,9 +356,9 @@ loadPrivateKey(const string& file, SecCertificateRef cert, SecKeychainRef keycha
     // private key into the keychain and add the certificate.
     //
     UniqueRef<CFArrayRef> items(loadKeychainItems(file, kSecItemTypePrivateKey, keychain, password, prompt, retryMax));
-    int count = CFArrayGetCount(items.get());
+    CFIndex count = CFArrayGetCount(items.get());
     UniqueRef<SecKeyRef> key;
-    for(int i = 0; i < count; ++i)
+    for(CFIndex i = 0; i < count; ++i)
     {
         SecKeychainItemRef itemRef =
             static_cast<SecKeychainItemRef>(const_cast<void*>(CFArrayGetValueAtIndex(items.get(), 0)));
@@ -405,7 +407,7 @@ loadPrivateKey(const string& file, SecCertificateRef cert, SecKeychainRef keycha
         SecKeychainAttribute attr;
         attr.tag = kSecKeyLabel;
         attr.data = const_cast<UInt8*>(CFDataGetBytePtr(hash.get()));
-        attr.length = CFDataGetLength(hash.get());
+        attr.length = static_cast<UInt32>(CFDataGetLength(hash.get()));
         attributes.push_back(attr);
     }
 
@@ -421,13 +423,13 @@ loadPrivateKey(const string& file, SecCertificateRef cert, SecKeychainRef keycha
         SecKeychainAttribute attr;
         attr.tag = kSecKeyPrintName;
         attr.data = const_cast<char*>(label.c_str());
-        attr.length = label.size();
+        attr.length = static_cast<UInt32>(label.size());
         attributes.push_back(attr);
     }
 
     SecKeychainAttributeList attrs;
     attrs.attr = &attributes[0];
-    attrs.count = attributes.size();
+    attrs.count = static_cast<UInt32>(attributes.size());
     SecKeychainItemModifyAttributesAndData(reinterpret_cast<SecKeychainItemRef>(key.get()), &attrs, 0, 0);
 
     UniqueRef<SecIdentityRef> identity;
@@ -485,7 +487,8 @@ loadCerts(const string& file)
             }
 
             vector<unsigned char> data(IceInternal::Base64::decode(string(&buffer[startpos], size)));
-            UniqueRef<CFDataRef> certdata(CFDataCreate(kCFAllocatorDefault, &data[0], data.size()));
+            UniqueRef<CFDataRef> certdata(CFDataCreate(kCFAllocatorDefault, &data[0],
+                                                       static_cast<CFIndex>(data.size())));
             UniqueRef<SecCertificateRef> cert(SecCertificateCreateWithData(0, certdata.get()));
             if(!cert)
             {
@@ -637,7 +640,7 @@ IceSSL::SecureTransport::loadCACertificates(const string& file)
 #else
     UniqueRef<CFArrayRef> items(loadKeychainItems(file, kSecItemTypeCertificate, 0, "", 0, 0));
     UniqueRef<CFArrayRef> certificateAuthorities(CFArrayCreateMutable(kCFAllocatorDefault, 0, &kCFTypeArrayCallBacks));
-    int count = CFArrayGetCount(items.get());
+    CFIndex count = CFArrayGetCount(items.get());
     for(CFIndex i = 0; i < count; ++i)
     {
         SecCertificateRef cert =
@@ -760,7 +763,7 @@ IceSSL::SecureTransport::findCertificateChain(const std::string& keychainPath,
             {
                 throw PluginInitializationException(__FILE__, __LINE__, "IceSSL: invalid value `" + value + "'");
             }
-            UniqueRef<CFDataRef> v(CFDataCreate(kCFAllocatorDefault, &buffer[0], buffer.size()));
+            UniqueRef<CFDataRef> v(CFDataCreate(kCFAllocatorDefault, &buffer[0], static_cast<CFIndex>(buffer.size())));
             CFDictionarySetValue(query.get(), field == "SUBJECTKEYID" ? kSecAttrSubjectKeyID : kSecAttrSerialNumber,
                                  v.get());
             valid = true;
@@ -800,7 +803,7 @@ IceSSL::SecureTransport::findCertificateChain(const std::string& keychainPath,
                                             "IceSSL: error evaluating trust:\n" + sslErrorToString(err));
     }
 
-    int chainLength = SecTrustGetCertificateCount(trust.get());
+    CFIndex chainLength = SecTrustGetCertificateCount(trust.get());
     UniqueRef<CFArrayRef> items(CFArrayCreateMutable(kCFAllocatorDefault, chainLength, &kCFTypeArrayCallBacks));
     for(int i = 0; i < chainLength; ++i)
     {

data/ext/ice/cpp/src/IceSSL/Util.cpp

@@ -20,6 +20,12 @@
 
 #include <fstream>
 
+#ifdef __IBMCPP__
+// Work-around for xlC visibility bug
+// See "ifstream::tellg visibility error" thread on IBM xlC forum
+extern template class std::fpos<char*>;
+#endif
+
 using namespace std;
 using namespace Ice;
 using namespace IceInternal;
@@ -36,8 +42,8 @@ IceSSL::fromCFString(CFStringRef v)
     {
         CFIndex size = CFStringGetMaximumSizeForEncoding(CFStringGetLength(v), kCFStringEncodingUTF8);
         vector<char> buffer;
-        buffer.resize(size + 1);
-        CFStringGetCString(v, &buffer[0], buffer.size(), kCFStringEncodingUTF8);
+        buffer.resize(static_cast<size_t>(size + 1));
+        CFStringGetCString(v, &buffer[0], static_cast<CFIndex>(buffer.size()), kCFStringEncodingUTF8);
         s.assign(&buffer[0]);
     }
     return s;
@@ -118,12 +124,12 @@ IceSSL::readFile(const string& file, vector<char>& buffer)
     }
 
     is.seekg(0, is.end);
-    buffer.resize(static_cast<int>(is.tellg()));
+    buffer.resize(static_cast<size_t>(is.tellg()));
     is.seekg(0, is.beg);
 
     if(!buffer.empty())
     {
-        is.read(&buffer[0], buffer.size());
+        is.read(&buffer[0], static_cast<streamsize>(buffer.size()));
         if(!is.good())
         {
             throw CertificateReadException(__FILE__, __LINE__, "error reading file " + file);
@@ -134,7 +140,7 @@ IceSSL::readFile(const string& file, vector<char>& buffer)
 bool
 IceSSL::checkPath(const string& path, const string& defaultDir, bool dir, string& resolved)
 {
-#if defined(ICE_USE_SECURE_TRANSPORT_IOS)
+#if defined(ICE_USE_SECURE_TRANSPORT_IOS) || defined(ICE_SWIFT)
     CFBundleRef bundle = CFBundleGetMainBundle();
     if(bundle)
     {

data/ext/ice/cpp/src/IceUtil/FileUtil.cpp

@@ -379,7 +379,7 @@ IceUtilInternal::rmdir(const string& path)
 int
 IceUtilInternal::mkdir(const string& path, int perm)
 {
-    return ::mkdir(path.c_str(), perm);
+    return ::mkdir(path.c_str(), static_cast<mode_t>(perm));
 }
 
 FILE*

data/ext/ice/cpp/src/IceUtil/Options.cpp

@@ -431,7 +431,7 @@ IceUtilInternal::Options::split(const string& line)
                                     j < i + 3 && j < l.size() && octalDigits.find_first_of(c = l[j]) != string::npos;
                                     ++j)
                                 {
-                                    us = us * 8 + c - '0';
+                                    us = us * 8 + static_cast<unsigned short>(c - '0');
                                 }
                                 i = j - 1;
                                 arg.push_back(static_cast<char>(us));
@@ -529,7 +529,7 @@ IceUtilInternal::Options::split(const string& line)
             }
             default:
             {
-                assert(!"Impossible parse state");
+                assert(false); // Impossible parse state
                 break;
             }
         }
@@ -559,7 +559,7 @@ IceUtilInternal::Options::split(const string& line)
         }
         default:
         {
-            assert(!"Impossible parse state");
+            assert(false); // Impossible parse state
             break;
         }
     }

data/ext/ice/cpp/src/IceUtil/OutputUtil.cpp

@@ -235,33 +235,43 @@ IceUtilInternal::OutputBase::operator!() const
 // Output
 // ----------------------------------------------------------------------
 
-IceUtilInternal::Output::Output() :
+IceUtilInternal::Output::Output(bool breakBeforeBlock, bool shortEmptyBlock) :
     OutputBase(),
     _blockStart("{"),
     _blockEnd("}"),
-    _par(-1)
+    _par(-1),
+    _breakBeforeBlock(breakBeforeBlock),
+    _shortEmptyBlock(shortEmptyBlock),
+    _emptyBlock(false)
 {
 }
 
-IceUtilInternal::Output::Output(ostream& os) :
+IceUtilInternal::Output::Output(ostream& os, bool breakBeforeBlock, bool shortEmptyBlock) :
     OutputBase(os),
     _blockStart("{"),
     _blockEnd("}"),
-    _par(-1)
+    _par(-1),
+    _breakBeforeBlock(breakBeforeBlock),
+    _shortEmptyBlock(shortEmptyBlock),
+    _emptyBlock(false)
 {
 }
 
-IceUtilInternal::Output::Output(const char* s) :
+IceUtilInternal::Output::Output(const char* s, bool breakBeforeBlock, bool shortEmptyBlock) :
     OutputBase(s),
     _blockStart("{"),
     _blockEnd("}"),
-    _par(-1)
+    _par(-1),
+    _breakBeforeBlock(breakBeforeBlock),
+    _shortEmptyBlock(shortEmptyBlock),
+    _emptyBlock(false)
 {
 }
 
 void
 IceUtilInternal::Output::print(const string& s)
 {
+    _emptyBlock = false;
     if(_par >= 0)
     {
         if(++_par > 1) // No comma for the first parameter.
@@ -277,22 +287,41 @@ IceUtilInternal::Output::sb()
 {
     if(_blockStart.length())
     {
-        newline();
+        if(_breakBeforeBlock)
+        {
+            newline();
+        }
+        else
+        {
+            _out << ' ';
+        }
         _out << _blockStart;
     }
     ++_pos;
     inc();
     _separator = false;
+    _emptyBlock = true;
 }
 
 void
 IceUtilInternal::Output::eb()
 {
     dec();
-    if(_blockEnd.length())
+    if(_emptyBlock && _shortEmptyBlock)
+    {
+        if(_blockEnd.length())
+        {
+            _separator = true;
+            _out << _blockEnd;
+        }
+    }
+    else
     {
-        newline();
-        _out << _blockEnd;
+        if(_blockEnd.length())
+        {
+            newline();
+            _out << _blockEnd;
+        }
     }
     --_pos;
 }
@@ -300,6 +329,7 @@ IceUtilInternal::Output::eb()
 void
 IceUtilInternal::Output::spar(char c)
 {
+    _emptyBlock = false;
     _out << c;
     _par = 0;
 }

data/ext/ice/cpp/src/IceUtil/Random.cpp

@@ -147,7 +147,7 @@ IceUtilInternal::generateRandom(char* buffer, size_t size)
         }
         else
         {
-            index += bytesRead;
+            index += static_cast<size_t>(bytesRead);
             reads++;
         }
     }
@@ -174,7 +174,7 @@ IceUtilInternal::random(int limit)
 #endif
     if(limit > 0)
     {
-        r = r % limit;
+        r = r % static_cast<unsigned int>(limit);
     }
     return r;
 }

data/ext/ice/cpp/src/IceUtil/StringConverter.cpp

@@ -92,7 +92,7 @@ public:
         do
         {
             assert(factor <= 4);
-            const size_t chunkSize = std::max<size_t>((sourceEnd - sourceStart) * factor, 4);
+            const size_t chunkSize = std::max<size_t>(static_cast<size_t>(sourceEnd - sourceStart) * factor, 4);
             ++factor; // at the next round, we'll allocate more bytes per remaining source character
 
             targetStart = reinterpret_cast<char*>(buffer.getMoreBytes(chunkSize, reinterpret_cast<Byte*>(targetNext)));
@@ -145,7 +145,7 @@ public:
 
     virtual void fromUTF8(const Byte* sourceStart, const Byte* sourceEnd, wstring& target) const
     {
-        const size_t sourceSize = sourceEnd - sourceStart;
+        const size_t sourceSize = static_cast<size_t>(sourceEnd - sourceStart);
 
         if(sourceSize == 0)
         {
@@ -173,7 +173,7 @@ public:
                 throw IllegalConversionException(__FILE__, __LINE__, "codecvt.in failure");
             }
 
-            target.resize(targetNext - targetStart);
+            target.resize(static_cast<size_t>(targetNext - targetStart));
         }
     }
 
@@ -275,7 +275,7 @@ public:
         size_t bytesUsed = 0;
         if(firstUnused != 0)
         {
-            bytesUsed = firstUnused - reinterpret_cast<const Byte*>(_buffer.data());
+            bytesUsed = static_cast<size_t>(firstUnused - reinterpret_cast<const Byte*>(_buffer.data()));
         }
 
         if(_buffer.size() < howMany + bytesUsed)
@@ -289,7 +289,7 @@ public:
     void swap(string& other, const Byte* tail)
     {
         assert(tail >= reinterpret_cast<const Byte*>(_buffer.data()));
-        _buffer.resize(tail - reinterpret_cast<const Byte*>(_buffer.data()));
+        _buffer.resize(static_cast<size_t>(tail - reinterpret_cast<const Byte*>(_buffer.data())));
         other.swap(_buffer);
     }
 

data/ext/ice/cpp/src/IceUtil/StringUtil.cpp

@@ -22,11 +22,11 @@ toHexDigit(Byte b)
     assert(b < 16);
     if(b < 10)
     {
-        return '0' + b;
+        return static_cast<char>('0' + b);
     }
     else
     {
-        return 'a' - 10 + b;
+        return static_cast<char>('a' - 10 + b);
     }
 }
 
@@ -289,7 +289,7 @@ checkChar(const string& s, string::size_type pos)
         ostr << " has invalid ordinal value " << static_cast<int>(c);
         throw IllegalArgumentException(__FILE__, __LINE__, ostr.str());
     }
-    return c;
+    return static_cast<char>(c);
 }
 
 //