zeroc-ice 3.6.5 → 3.7.4

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

@@ -1,192 +1,98 @@
-// **********************************************************************
 //
-// 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_SSL_UTIL_H
-#define ICE_SSL_UTIL_H
+#ifndef ICESSL_UTIL_H
+#define ICESSL_UTIL_H
 
 #include <IceUtil/Mutex.h>
 #include <IceUtil/Shared.h>
 #include <IceUtil/Handle.h>
-
 #include <IceSSL/Plugin.h>
 
-#if defined(ICE_USE_OPENSSL)
-#  include <openssl/ssl.h>
-#  include <list>
-#elif defined(ICE_USE_SECURE_TRANSPORT)
-#  include <Security/Security.h>
+#if defined(__APPLE__)
 #  include <CoreFoundation/CoreFoundation.h>
-#elif defined(ICE_USE_SCHANNEL)
-#  include <wincrypt.h>
+#  if TARGET_OS_IPHONE != 0
+#    define ICE_USE_SECURE_TRANSPORT_IOS 1
+#  else
+#    define ICE_USE_SECURE_TRANSPORT_MACOS 1
+#  endif
 #endif
 
 namespace IceSSL
 {
 
+#if defined(__APPLE__)
 //
-// Constants for X509 certificate alt names (AltNameOther, AltNameORAddress, AltNameEDIPartyName and
-// AltNameObjectIdentifier) are not supported.
+// Helper functions to use by Secure Transport.
 //
+std::string fromCFString(CFStringRef);
 
-//const int AltNameOther = 0;
-const int AltNameEmail = 1;
-const int AltNameDNS = 2;
-//const int AltNameORAddress = 3;
-const int AltNameDirectory = 4;
-//const int AltNameEDIPartyName = 5;
-const int AltNameURL = 6;
-const int AltNAmeIP = 7;
-//const AltNameObjectIdentifier = 8;
-
-#ifdef ICE_USE_OPENSSL
-
-#  ifndef OPENSSL_NO_DH
-class DHParams : public IceUtil::Shared, public IceUtil::Mutex
+inline CFStringRef
+toCFString(const std::string& s)
 {
-public:
-
-    DHParams();
-    ~DHParams();
-
-    bool add(int, const std::string&);
-    DH* get(int);
-
-private:
-
-    typedef std::pair<int, DH*> KeyParamPair;
-    typedef std::list<KeyParamPair> ParamList;
-    ParamList _params;
-
-    DH* _dh512;
-    DH* _dh1024;
-    DH* _dh2048;
-    DH* _dh4096;
-};
-typedef IceUtil::Handle<DHParams> DHParamsPtr;
-#  endif
+    return CFStringCreateWithCString(ICE_NULLPTR, s.c_str(), kCFStringEncodingUTF8);
+}
+#endif
 
+#ifdef ICE_CPP11_MAPPING
 //
-// Accumulate the OpenSSL error stack into a string.
+// Adapts the C++11 functions to C++98-like callbacks
 //
-std::string getSslErrors(bool);
-
-#elif defined(ICE_USE_SECURE_TRANSPORT)
-
-template<typename T>
-class UniqueRef
+class ICESSL_API CertificateVerifier
 {
 public:
 
-    explicit UniqueRef(CFTypeRef ptr = 0) : _ptr((T)ptr)
-    {
-    }
-
-    ~UniqueRef()
-    {
-        if(_ptr != 0)
-        {
-            CFRelease(_ptr);
-        }
-    }
-
-    T release()
-    {
-        T r = _ptr;
-        _ptr = 0;
-        return r;
-    }
-
-    void reset(CFTypeRef ptr = 0)
-    {
-        if(_ptr == ptr)
-        {
-            return;
-        }
-        if(_ptr != 0)
-        {
-            CFRelease(_ptr);
-        }
-        _ptr = (T)ptr;
-    }
-
-    void retain(CFTypeRef ptr)
-    {
-        reset(ptr ? CFRetain(ptr) : ptr);
-    }
-
-    T get() const
-    {
-        return _ptr;
-    }
-
-    operator bool() const
-    {
-        return _ptr != 0;
-    }
+    CertificateVerifier(std::function<bool(const std::shared_ptr<ConnectionInfo>&)>);
+    bool verify(const ConnectionInfoPtr&);
 
 private:
 
-    T _ptr;
+    std::function<bool(const std::shared_ptr<ConnectionInfo>&)> _verify;
 };
+using CertificateVerifierPtr = std::shared_ptr<CertificateVerifier>;
 
-//
-// Helper functions to use by Secure Transport.
-//
-
-std::string fromCFString(CFStringRef);
-
-inline CFStringRef
-toCFString(const std::string& s)
+class ICESSL_API PasswordPrompt
 {
-    return CFStringCreateWithCString(NULL, s.c_str(), kCFStringEncodingUTF8);
-}
+public:
 
-std::string errorToString(CFErrorRef);
-std::string errorToString(OSStatus);
+    PasswordPrompt(std::function<std::string()>);
+    std::string getPassword();
 
-//
-// Retrieve a certificate property
-//
-CFDictionaryRef getCertificateProperty(SecCertificateRef, CFTypeRef);
+private:
 
-//
-// Read a private key from an file and associate it to the given certificate.
-//
-SecIdentityRef loadPrivateKey(const std::string&, SecCertificateRef, SecKeychainRef, const std::string&,
-                              const PasswordPromptPtr&, int);
+    std::function<std::string()> _prompt;
+};
+using PasswordPromptPtr = std::shared_ptr<PasswordPrompt>;
+#endif
 
 //
-// Read certificate from a file.
+// Constants for X509 certificate alt names (AltNameOther, AltNameORAddress, AltNameEDIPartyName and
+// AltNameObjectIdentifier) are not supported.
 //
-CFArrayRef loadCertificateChain(const std::string&, const std::string&, SecKeychainRef, const std::string&,
-                                const PasswordPromptPtr&, int);
-
-SecCertificateRef loadCertificate(const std::string&);
-CFArrayRef loadCACertificates(const std::string&);
 
-SecCertificateRef findCertificate(SecKeychainRef, const std::string&);
-
-#elif defined(ICE_USE_SCHANNEL)
-std::vector<PCCERT_CONTEXT>
-findCertificates(const std::string&, const std::string&, const std::string&, std::vector<HCERTSTORE>&);
-#endif
+//const int AltNameOther = 0;
+const int AltNameEmail = 1;
+const int AltNameDNS = 2;
+//const int AltNameORAddress = 3;
+const int AltNameDirectory = 4;
+//const int AltNameEDIPartyName = 5;
+const int AltNameURL = 6;
+const int AltNAmeIP = 7;
+//const AltNameObjectIdentifier = 8;
 
 //
 // Read a file into memory buffer.
 //
-void readFile(const std::string&, std::vector<char>&);
+ICESSL_API void readFile(const std::string&, std::vector<char>&);
 
 //
 // Determine if a file or directory exists, with an optional default
 // directory.
 //
-bool checkPath(const std::string&, const std::string&, bool, std::string&);
+ICESSL_API bool checkPath(const std::string&, const std::string&, bool, std::string&);
+
+ICESSL_API bool parseBytes(const std::string&, std::vector<unsigned char>&);
 
 }
 

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

@@ -0,0 +1,157 @@
+//
+// Copyright (c) ZeroC, Inc. All rights reserved.
+//
+
+#include <IceUtil/ConsoleUtil.h>
+#include <IceUtil/MutexPtrLock.h>
+#include <IceUtil/Mutex.h>
+
+using namespace IceUtilInternal;
+using namespace std;
+
+#if defined(_WIN32) && !defined(ICE_OS_UWP)
+namespace
+{
+
+IceUtil::Mutex* consoleMutex = 0;
+ConsoleUtil* consoleUtil = 0;
+
+class Init
+{
+public:
+
+    Init()
+    {
+        consoleMutex = new IceUtil::Mutex;
+    }
+
+    ~Init()
+    {
+        //
+        // We leak consoleUtil object to ensure that is available
+        // during static destruction.
+        //
+        //delete consoleUtil;
+        //consoleUtil = 0;
+        delete consoleMutex;
+        consoleMutex = 0;
+    }
+};
+
+Init init;
+
+}
+
+const ConsoleUtil&
+IceUtilInternal::getConsoleUtil()
+{
+    IceUtilInternal::MutexPtrLock<IceUtil::Mutex> sync(consoleMutex);
+    if(consoleUtil == 0)
+    {
+        consoleUtil = new ConsoleUtil();
+    }
+    return *consoleUtil;
+}
+
+ConsoleOut IceUtilInternal::consoleOut;
+ConsoleErr IceUtilInternal::consoleErr;
+
+ConsoleUtil::ConsoleUtil() :
+    _converter(IceUtil::getProcessStringConverter()),
+    _consoleConverter(IceUtil::createWindowsStringConverter(GetConsoleOutputCP()))
+{
+}
+
+string
+ConsoleUtil::toConsoleEncoding(const string& message) const
+{
+    try
+    {
+        // Convert message to UTF-8
+        string u8s = nativeToUTF8(message, _converter);
+
+        // Then from UTF-8 to console CP
+        string consoleString;
+        _consoleConverter->fromUTF8(reinterpret_cast<const IceUtil::Byte* > (u8s.data()),
+                                    reinterpret_cast<const IceUtil::Byte*>(u8s.data() + u8s.size()),
+                                    consoleString);
+
+        return consoleString;
+    }
+    catch(const IceUtil::IllegalConversionException&)
+    {
+        //
+        // If there is a problem with the encoding conversions we just
+        // return the original message without encoding conversions.
+        //
+        return message;
+    }
+}
+
+void
+ConsoleUtil::output(const string& message) const
+{
+    //
+    // Use fprintf_s to avoid encoding conversion when stderr is connected
+    // to Windows console.
+    //
+    fprintf_s(stdout, "%s", toConsoleEncoding(message).c_str());
+}
+
+void
+ConsoleUtil::error(const string& message) const
+{
+    //
+    // Use fprintf_s to avoid encoding conversion when stderr is connected
+    // to Windows console.
+    //
+    fprintf_s(stderr, "%s", toConsoleEncoding(message).c_str());
+}
+
+ConsoleOut&
+IceUtilInternal::endl(ConsoleOut& out)
+{
+    fprintf_s(stdout, "\n");
+    fflush(stdout);
+    return out;
+}
+
+ConsoleOut&
+IceUtilInternal::flush(ConsoleOut& out)
+{
+    fflush(stdout);
+    return out;
+}
+
+ConsoleOut&
+ConsoleOut::operator<<(ConsoleOut& (*pf)(ConsoleOut&))
+{
+    pf(*this);
+    return *this;
+}
+
+ConsoleErr&
+IceUtilInternal::endl(ConsoleErr& err)
+{
+    fprintf_s(stderr, "\n");
+    fflush(stderr);
+    return err;
+}
+
+ConsoleErr&
+IceUtilInternal::flush(ConsoleErr& err)
+{
+    fflush(stderr);
+    return err;
+}
+
+ConsoleErr&
+ConsoleErr::operator<<(ConsoleErr& (*pf)(ConsoleErr&))
+{
+    pf(*this);
+    return *this;
+}
+#else
+std::ostream& IceUtilInternal::consoleOut = cout;
+std::ostream& IceUtilInternal::consoleErr = cerr;
+#endif

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

@@ -1,8 +1,8 @@
 /*
  * Copyright 2001-2004 Unicode, Inc.
- * 
+ *
  * Disclaimer
- * 
+ *
  * This source code is provided as is by Unicode, Inc. No claims are
  * made as to fitness for any particular purpose. No warranties of any
  * kind are expressed or implied. The recipient agrees to determine
@@ -10,9 +10,9 @@
  * purchased on magnetic or optical media from Unicode, Inc., the
  * sole remedy for any claim will be exchange of defective media
  * within 90 days of receipt.
- * 
+ *
  * Limitations on Rights to Redistribute This Code
- * 
+ *
  * Unicode, Inc. hereby grants the right to freely use the information
  * supplied in this file in the creation of products supporting the
  * Unicode Standard, and to make copies of this file in any form
@@ -20,14 +20,9 @@
  * remains attached.
  */
 
-// **********************************************************************
 //
-// 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.
-//
-// **********************************************************************
 
 /* ---------------------------------------------------------------------
 
@@ -47,9 +42,15 @@
 
 ------------------------------------------------------------------------ */
 
+#include <IceUtil/Config.h>
+
+#ifndef ICE_HAS_CODECVT_UTF8
+//
+// It's better to exclude the file from the build, but it's not always
+// easy to do.
+//
 
 #include <IceUtil/ConvertUTF.h>
-#include <IceUtil/StringConverter.h>
 
 #ifdef CVTUTF_DEBUG
 #include <stdio.h>
@@ -77,7 +78,6 @@ const UTF32 halfMask = 0x3FFUL;
 // #define false           0
 // #define true     1
 
-
 /* --------------------------------------------------------------------- */
 
 /*
@@ -103,7 +103,7 @@ const char trailingBytesForUTF8[256] = {
  * This table contains as many values as there might be trailing bytes
  * in a UTF-8 sequence.
  */
-const UTF32 offsetsFromUTF8[6] = { 0x00000000UL, 0x00003080UL, 0x000E2080UL, 
+const UTF32 offsetsFromUTF8[6] = { 0x00000000UL, 0x00003080UL, 0x000E2080UL,
                      0x03C82080UL, 0xFA082080UL, 0x82082080UL };
 
 /*
@@ -128,7 +128,7 @@ const UTF8 firstByteMark[7] = { 0x00, 0x00, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC };
 /* --------------------------------------------------------------------- */
 
 ConversionResult ConvertUTF16toUTF8 (
-        const UTF16** sourceStart, const UTF16* sourceEnd, 
+        const UTF16** sourceStart, const UTF16* sourceEnd,
         UTF8** targetStart, UTF8* targetEnd, ConversionFlags flags) {
     ConversionResult result = conversionOK;
     const UTF16* source = *sourceStart;
@@ -137,7 +137,7 @@ ConversionResult ConvertUTF16toUTF8 (
         UTF32 ch;
         unsigned short bytesToWrite = 0;
         const UTF32 byteMask = 0xBF;
-        const UTF32 byteMark = 0x80; 
+        const UTF32 byteMark = 0x80;
         const UTF16* oldSource = source; /* In case we have to back up because of target overflow. */
         ch = *source++;
         /* If we have a surrogate pair, convert to UTF32 first. */
@@ -236,7 +236,7 @@ Boolean isLegalUTF8(const UTF8 *source, int length) {
 /* --------------------------------------------------------------------- */
 
 ConversionResult ConvertUTF8toUTF16 (
-        const UTF8** sourceStart, const UTF8* sourceEnd, 
+        const UTF8** sourceStart, const UTF8* sourceEnd,
         UTF16** targetStart, UTF16* targetEnd, ConversionFlags flags) {
     ConversionResult result = conversionOK;
     const UTF8* source = *sourceStart;
@@ -309,7 +309,7 @@ ConversionResult ConvertUTF8toUTF16 (
 /* --------------------------------------------------------------------- */
 
 ConversionResult ConvertUTF32toUTF8 (
-        const UTF32** sourceStart, const UTF32* sourceEnd, 
+        const UTF32** sourceStart, const UTF32* sourceEnd,
         UTF8** targetStart, UTF8* targetEnd, ConversionFlags flags) {
     ConversionResult result = conversionOK;
     const UTF32* source = *sourceStart;
@@ -318,7 +318,7 @@ ConversionResult ConvertUTF32toUTF8 (
         UTF32 ch;
         unsigned short bytesToWrite = 0;
         const UTF32 byteMask = 0xBF;
-        const UTF32 byteMark = 0x80; 
+        const UTF32 byteMark = 0x80;
         ch = *source++;
         if (flags == strictConversion ) {
             /* UTF-16 surrogate values are illegal in UTF-32 */
@@ -340,7 +340,7 @@ ConversionResult ConvertUTF32toUTF8 (
                                             ch = UNI_REPLACEMENT_CHAR;
                                             result = sourceIllegal;
         }
-        
+
         target += bytesToWrite;
         if (target > targetEnd) {
             --source; /* Back up source pointer! */
@@ -362,7 +362,7 @@ ConversionResult ConvertUTF32toUTF8 (
 /* --------------------------------------------------------------------- */
 
 ConversionResult ConvertUTF8toUTF32 (
-        const UTF8** sourceStart, const UTF8* sourceEnd, 
+        const UTF8** sourceStart, const UTF8* sourceEnd,
         UTF32** targetStart, UTF32* targetEnd, ConversionFlags flags) {
     ConversionResult result = conversionOK;
     const UTF8* source = *sourceStart;
@@ -439,12 +439,6 @@ ConversionResult ConvertUTF8toUTF32 (
     similarly unrolled loops.
 
    --------------------------------------------------------------------- */
-}
-
-namespace IceUtil
-{
-
-using namespace IceUtilInternal;
 
 /* --------------------------------------------------------------------- */
 
@@ -473,5 +467,6 @@ Boolean isLegalUTF8Sequence(const UTF8 *source, const UTF8 *sourceEnd) {
         }
     }
 }
-
 }
+
+#endif