zeroc-ice 3.6b1

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

@@ -0,0 +1,185 @@
+// **********************************************************************
+//
+// Copyright (c) 2003-2014 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.
+//
+// **********************************************************************
+
+#ifdef _WIN32
+#  define _CRT_RAND_S
+#endif
+
+#include <IceUtil/Random.h>
+#include <IceUtil/Mutex.h>
+#include <IceUtil/MutexPtrLock.h>
+
+#ifndef _WIN32
+#   include <unistd.h>
+#   include <fcntl.h>
+#endif
+
+using namespace std;
+using namespace IceUtil;
+
+#if !defined(_WIN32)
+namespace
+{
+
+//
+// The static mutex is required to lazy initialize the file
+// descriptor for /dev/urandom (Unix)
+//
+// Also, unfortunately on Linux (at least up to 2.6.9), concurrent
+// access to /dev/urandom can return the same value. Search for
+// "Concurrent access to /dev/urandom" in the linux-kernel mailing
+// list archive for additional details.  Since /dev/urandom on other
+// platforms is usually a port from Linux, this problem could be
+// widespread. Therefore, we serialize access to /dev/urandom using a
+// static mutex.
+// 
+Mutex* staticMutex = 0;
+int fd = -1;
+
+//
+// Callback to use with pthread_atfork to reset the "/dev/urandom"  
+// fd state. We don't need to close the fd here as that is done 
+// during static destruction.
+//
+extern "C"
+{
+
+void childAtFork()
+{
+    if(fd != -1)
+    {
+        fd = -1;
+    }
+}
+
+}
+
+class Init
+{
+public:
+
+    Init()
+    {
+        staticMutex = new IceUtil::Mutex;
+
+        //
+        // Register a callback to reset the "/dev/urandom" fd 
+        // state after fork.
+        //
+        pthread_atfork(0, 0, &childAtFork);
+    }
+    
+    ~Init()
+    {
+        if(fd != -1)
+        {
+            close(fd);
+            fd = -1;
+        }
+        delete staticMutex;
+        staticMutex = 0;
+    }
+};
+
+Init init;
+
+}
+#endif
+
+void
+IceUtilInternal::generateRandom(char* buffer, size_t size)
+{
+#ifdef _WIN32
+    int i = 0;
+    const size_t randSize = sizeof(unsigned int);
+    
+    while(size - i >= randSize)
+    {
+        unsigned int r = 0;
+        errno_t err = rand_s(&r);
+        if(err != 0)
+        {
+            throw SyscallException(__FILE__, __LINE__, errno);
+        }
+        memcpy(buffer + i, &r, randSize);   
+        i += randSize;
+    }
+
+    if(size - i > 0)
+    {
+        assert(size - i < randSize);
+        unsigned int r = 0;
+        errno_t err = rand_s(&r);
+        if(err != 0)
+        {
+            throw SyscallException(__FILE__, __LINE__, errno);
+        }
+        memcpy(buffer + i, &r, size - i);   
+    }
+#else
+    //
+    // Serialize access to /dev/urandom; see comment above.
+    //
+    IceUtilInternal::MutexPtrLock<IceUtil::Mutex> lock(staticMutex);
+    if(fd == -1)
+    {
+        fd = open("/dev/urandom", O_RDONLY);
+        if(fd == -1)
+        {
+            throw SyscallException(__FILE__, __LINE__, errno);
+        }
+    }
+    
+    //
+    // Limit the number of attempts to 20 reads to avoid
+    // a potential "for ever" loop
+    //
+    int reads = 0;
+    size_t index = 0;    
+    while(reads <= 20 && index != size)
+    {
+        ssize_t bytesRead = read(fd, buffer + index, size - index);
+        
+        if(bytesRead == -1 && errno != EINTR)
+        {
+            throw SyscallException(__FILE__, __LINE__, errno);
+        }
+        else
+        {
+            index += bytesRead;
+            reads++;
+        }
+    }
+        
+    if(index != size)
+    {
+        throw SyscallException(__FILE__, __LINE__, 0);
+    }
+#endif
+}
+
+unsigned int
+IceUtilInternal::random(int limit)
+{
+    unsigned int r;
+#ifdef _WIN32
+    errno_t err = rand_s(&r);
+    if(err != 0)
+    {
+        throw SyscallException(__FILE__, __LINE__, errno);
+    }
+#else
+    generateRandom(reinterpret_cast<char*>(&r), sizeof(unsigned int));
+#endif
+    if(limit > 0)
+    {
+        r = r % limit;
+    }
+    return r;
+}

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

@@ -0,0 +1,257 @@
+// **********************************************************************
+//
+// Copyright (c) 2003-2014 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 <IceUtil/RecMutex.h>
+#include <IceUtil/Exception.h>
+
+//
+// AbstractMutex isn't used anywhere in IceUtil, we include it here
+// to give the compiler a chance to export the class symbols.
+//
+#include <IceUtil/AbstractMutex.h>
+
+using namespace std;
+
+IceUtil::RecMutex::RecMutex() :
+    _count(0)
+{
+#ifdef _WIN32
+    init(PrioNone);
+#else
+    init(getDefaultMutexProtocol());
+#endif
+}
+
+IceUtil::RecMutex::RecMutex(const IceUtil::MutexProtocol protocol) :
+    _count(0)
+{
+    init(protocol);
+}
+
+#ifdef _WIN32
+
+void
+IceUtil::RecMutex::init(const MutexProtocol)
+{
+#   ifdef ICE_OS_WINRT
+    InitializeCriticalSectionEx(&_mutex, 0, 0);
+#   else
+    InitializeCriticalSection(&_mutex);
+#   endif
+}
+
+IceUtil::RecMutex::~RecMutex()
+{
+    assert(_count == 0);
+    DeleteCriticalSection(&_mutex);
+}
+
+void
+IceUtil::RecMutex::lock() const
+{
+    EnterCriticalSection(&_mutex);
+    if(++_count > 1)
+    {
+        LeaveCriticalSection(&_mutex);
+    }
+}
+
+bool
+IceUtil::RecMutex::tryLock() const
+{
+    if(!TryEnterCriticalSection(&_mutex))
+    {
+        return false;
+    }
+    if(++_count > 1)
+    {
+        LeaveCriticalSection(&_mutex);
+    }
+    return true;
+}
+
+void
+IceUtil::RecMutex::unlock() const
+{
+    if(--_count == 0)
+    {
+        LeaveCriticalSection(&_mutex);
+    }
+}
+
+#   ifdef ICE_HAS_WIN32_CONDVAR
+void
+IceUtil::RecMutex::unlock(LockState& state) const
+{
+    state.mutex = &_mutex;
+    state.count = _count;
+    _count = 0;
+}
+
+void
+IceUtil::RecMutex::lock(LockState& state) const
+{
+    _count = state.count;
+}
+#   else
+void
+IceUtil::RecMutex::unlock(LockState& state) const
+{
+    state.count = _count;
+    _count = 0;
+    LeaveCriticalSection(&_mutex);
+}
+
+void
+IceUtil::RecMutex::lock(LockState& state) const
+{
+    EnterCriticalSection(&_mutex);
+    _count = state.count;
+}
+#   endif
+
+#else
+
+void
+IceUtil::RecMutex::init(const MutexProtocol protocol)
+{
+    int rc;
+    pthread_mutexattr_t attr;
+    rc = pthread_mutexattr_init(&attr);
+    assert(rc == 0);
+    if(rc != 0)
+    {
+        pthread_mutexattr_destroy(&attr);
+        throw ThreadSyscallException(__FILE__, __LINE__, rc);
+    }
+
+#if defined(__linux) && !defined(__USE_UNIX98)
+    rc = pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE_NP);
+#else
+    rc = pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
+#endif
+    assert(rc == 0);
+    if(rc != 0)
+    {
+        pthread_mutexattr_destroy(&attr);
+        throw ThreadSyscallException(__FILE__, __LINE__, rc);
+    }
+
+#if defined(_POSIX_THREAD_PRIO_INHERIT) && _POSIX_THREAD_PRIO_INHERIT > 0
+    if(PrioInherit == protocol)
+    {
+        rc = pthread_mutexattr_setprotocol(&attr, PTHREAD_PRIO_INHERIT);
+        assert(rc == 0);
+        if(rc != 0)
+        {
+            throw ThreadSyscallException(__FILE__, __LINE__, rc);
+        }
+    }
+#endif
+
+    rc = pthread_mutex_init(&_mutex, &attr);
+    assert(rc == 0);
+    if(rc != 0)
+    {
+        pthread_mutexattr_destroy(&attr);
+        throw ThreadSyscallException(__FILE__, __LINE__, rc);
+    }
+
+    rc = pthread_mutexattr_destroy(&attr);
+    assert(rc == 0);
+    if(rc != 0)
+    {
+        throw ThreadSyscallException(__FILE__, __LINE__, rc);
+    }
+}
+
+IceUtil::RecMutex::~RecMutex()
+{
+    assert(_count == 0);
+#ifndef NDEBUG
+    int rc = pthread_mutex_destroy(&_mutex);
+    assert(rc == 0);
+#else
+    pthread_mutex_destroy(&_mutex);
+#endif
+}
+
+void
+IceUtil::RecMutex::lock() const
+{
+    int rc = pthread_mutex_lock(&_mutex);
+    if(rc != 0)
+    {
+        throw ThreadSyscallException(__FILE__, __LINE__, rc);
+    }
+    if(++_count > 1)
+    {
+        rc = pthread_mutex_unlock(&_mutex);
+        assert(rc == 0);
+    }
+}
+
+bool
+IceUtil::RecMutex::tryLock() const
+{
+    int rc = pthread_mutex_trylock(&_mutex);
+    bool result = (rc == 0);
+    if(!result)
+    {
+        if(rc != EBUSY)
+        {
+            throw ThreadSyscallException(__FILE__, __LINE__, rc);
+        }
+    } 
+    else if(++_count > 1)
+    {
+        rc = pthread_mutex_unlock(&_mutex);
+        if(rc != 0)
+        {
+            throw ThreadSyscallException(__FILE__, __LINE__, rc);
+        }
+    }
+    return result;
+}
+
+void
+IceUtil::RecMutex::unlock() const
+{
+    if(--_count == 0)
+    {
+#ifndef NDEBUG
+        int rc = pthread_mutex_unlock(&_mutex);
+        assert(rc == 0);
+#else
+        pthread_mutex_unlock(&_mutex);
+#endif
+    }
+}
+
+void
+IceUtil::RecMutex::unlock(LockState& state) const
+{
+    state.mutex = &_mutex;
+    state.count = _count;
+    _count = 0;
+}
+
+void
+IceUtil::RecMutex::lock(LockState& state) const
+{
+    _count = state.count;
+}
+
+#endif
+
+bool
+IceUtil::RecMutex::willUnlock() const
+{
+    return _count == 1;
+}

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

@@ -0,0 +1,126 @@
+// **********************************************************************
+//
+// Copyright (c) 2003-2014 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 <IceUtil/SHA1.h>
+
+#if defined(_WIN32) && !defined(ICE_OS_WINRT)
+#   include <IceUtil/Exception.h>
+#endif
+
+using namespace std;
+using namespace IceUtil;
+
+#ifndef ICE_OS_WINRT
+#   if defined(_WIN32)
+
+namespace
+{
+const int SHA_DIGEST_LENGTH = 20;
+}
+
+IceUtil::SHA1::SHA1() :
+    _ctx(0),
+    _hash(0)
+{
+    if(!CryptAcquireContext(&_ctx, 0, MS_DEF_PROV, PROV_RSA_FULL, CRYPT_VERIFYCONTEXT))
+    {
+        throw IceUtil::SyscallException(__FILE__, __LINE__, GetLastError());
+    }
+
+    if(!CryptCreateHash(_ctx, CALG_SHA1, 0, 0, &_hash))
+    {
+        throw IceUtil::SyscallException(__FILE__, __LINE__, GetLastError());
+    }
+}
+
+IceUtil::SHA1::~SHA1()
+{
+    if(_hash)
+    {
+        CryptDestroyHash(_hash);
+    }
+
+    if(_ctx)
+    {
+        CryptReleaseContext(_ctx, 0);
+    }
+}
+#   elif defined(__APPLE__)
+IceUtil::SHA1::SHA1()
+{
+    CC_SHA1_Init(&_ctx);
+}
+#   else
+IceUtil::SHA1::SHA1()
+{
+    SHA1_Init(&_ctx);
+}
+#   endif
+
+void
+IceUtil::SHA1::update(const unsigned char* data, size_t length)
+{
+#   if defined(_WIN32)
+    if(!CryptHashData(_hash, data, static_cast<DWORD>(length), 0))
+    {
+        throw IceUtil::SyscallException(__FILE__, __LINE__, GetLastError());
+    }
+#   elif defined(__APPLE__)
+    CC_SHA1_Update(&_ctx, reinterpret_cast<const void*>(data), length);
+#   else
+    SHA1_Update(&_ctx, reinterpret_cast<const void*>(data), length);
+#   endif
+}
+
+void
+IceUtil::SHA1::finalize(vector<unsigned char>& md)
+{
+#   if defined(_WIN32)
+    md.resize(SHA_DIGEST_LENGTH);
+    DWORD length = SHA_DIGEST_LENGTH;
+    if(!CryptGetHashParam(_hash, HP_HASHVAL, &md[0], &length, 0))
+    {
+        throw IceUtil::SyscallException(__FILE__, __LINE__, GetLastError());
+    }
+#   elif defined(__APPLE__)
+    md.resize(CC_SHA1_DIGEST_LENGTH);
+    CC_SHA1_Final(&md[0], &_ctx);
+#   else
+    md.resize(SHA_DIGEST_LENGTH);
+    SHA1_Final(&md[0], &_ctx);
+#   endif
+}
+#endif
+
+void
+IceUtil::sha1(const unsigned char* data, size_t length, vector<unsigned char>& md)
+{
+#if defined(ICE_OS_WINRT)
+    auto dataA =
+        ref new Platform::Array<unsigned char>(const_cast<unsigned char*>(data), static_cast<unsigned int>(length));
+    auto hasher = Windows::Security::Cryptography::Core::HashAlgorithmProvider::OpenAlgorithm("SHA1");
+    auto hashed = hasher->HashData(Windows::Security::Cryptography::CryptographicBuffer::CreateFromByteArray(dataA));
+    auto reader = ::Windows::Storage::Streams::DataReader::FromBuffer(hashed);
+    md.resize(reader->UnconsumedBufferLength);
+    if(!md.empty())
+    {
+        reader->ReadBytes(::Platform::ArrayReference<unsigned char>(&md[0], static_cast<unsigned int>(md.size())));
+    }
+#elif defined(_WIN32)
+    SHA1 hasher;
+    hasher.update(data, length);
+    hasher.finalize(md);
+#elif defined(__APPLE__)
+    md.resize(CC_SHA1_DIGEST_LENGTH);
+    CC_SHA1(&data[0], length, &md[0]);
+#else
+    md.resize(SHA_DIGEST_LENGTH);
+    ::SHA1(&data[0], length, &md[0]);
+#endif
+}