zeroc-ice 3.7.11 → 3.8.1

data/dist/ice/cpp/include/IceSSL/SChannel.h

@@ -1,72 +0,0 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
-
-#ifndef ICESSL_SCHANNEL_H
-#define ICESSL_SCHANNEL_H
-
-#ifdef _WIN32
-
-#include <IceSSL/Plugin.h>
-
-#include <wincrypt.h>
-
-namespace IceSSL
-{
-
-namespace SChannel
-{
-
-class Certificate;
-ICE_DEFINE_PTR(CertificatePtr, Certificate);
-
-/**
- * This convenience class is a wrapper around a native certificate.
- * \headerfile IceSSL/IceSSL.h
- */
-class ICESSL_API Certificate : public virtual IceSSL::Certificate
-{
-public:
-
-    /**
-     * Constructs a certificate using a native certificate.
-     * The Certificate class assumes ownership of the given native
-     * certificate.
-     * @param info The certificate data.
-     * @return The new certificate instance.
-     */
-    static CertificatePtr create(CERT_SIGNED_CONTENT_INFO* info);
-
-    /**
-     * Loads the certificate from a file. The certificate must use the
-     * PEM encoding format.
-     * @param file The certificate file.
-     * @return The new certificate instance.
-     * @throws CertificateReadException if the file cannot be read.
-     */
-    static CertificatePtr load(const std::string& file);
-
-    /**
-     * Decodes a certificate from a string that uses the PEM encoding format.
-     * @param str A string containing the encoded certificate.
-     * @return The new certificate instance.
-     * @throws CertificateEncodingException if an error occurs.
-     */
-    static CertificatePtr decode(const std::string& str);
-
-    /**
-     * Obtains the native X509 certificate value wrapped by this object.
-     * @return A reference to the native certificate.
-     * The returned reference is only valid for the lifetime of this
-     * object. The returned reference is a pointer to a struct.
-     */
-    virtual CERT_SIGNED_CONTENT_INFO* getCert() const = 0;
-};
-
-} // SChannel namespace end
-
-} // IceSSL namespace end
-
-#endif
-
-#endif

data/dist/ice/cpp/include/IceSSL/SecureTransport.h

@@ -1,72 +0,0 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
-
-#ifndef ICESSL_SECURE_TRANSPORT_H
-#define ICESSL_SECURE_TRANSPORT_H
-
-#ifdef __APPLE__
-
-#include <IceSSL/Plugin.h>
-#include <Security/Security.h>
-
-namespace IceSSL
-{
-
-namespace SecureTransport
-{
-
-class Certificate;
-ICE_DEFINE_PTR(CertificatePtr, Certificate);
-
-/**
- * This convenience class is a wrapper around a native certificate.
- * \headerfile IceSSL/IceSSL.h
- */
-class ICESSL_API Certificate : public virtual IceSSL::Certificate
-{
-public:
-
-    /**
-     * Constructs a certificate using a native certificate.
-     * The Certificate class assumes ownership of the given native
-     * certificate.
-     * @param cert The certificate cert.
-     * @return The new certificate instance.
-     */
-    static CertificatePtr create(SecCertificateRef cert);
-
-    /**
-     * Loads the certificate from a file. The certificate must use the
-     * PEM encoding format.
-     * @param file The certificate file.
-     * @return The new certificate instance.
-     * @throws CertificateReadException if the file cannot be read.
-     */
-    static CertificatePtr load(const std::string& file);
-
-    /**
-     * Decodes a certificate from a string that uses the PEM encoding format.
-     * @param str A string containing the encoded certificate.
-     * @return The new certificate instance.
-     * @throws CertificateEncodingException if an error occurs.
-     */
-    static CertificatePtr decode(const std::string& str);
-
-    /**
-     * Obtains the native X509 certificate value wrapped by this object.
-     * @return A reference to the native certificate.
-     * The returned reference is only valid for the lifetime of this
-     * object. You can increment the reference count of the returned
-     * object with CFRetain.
-     */
-    virtual SecCertificateRef getCert() const = 0;
-};
-
-} // SecureTransport namespace end
-
-} // IceSSL namespace end
-
-#endif
-
-#endif

data/dist/ice/cpp/include/IceUtil/Atomic.h

@@ -1,179 +0,0 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
-
-#ifndef ICE_UTIL_ATOMIC_H
-#define ICE_UTIL_ATOMIC_H
-
-#if ((defined(ICE_CPP11_COMPILER) && defined(_MSC_VER) && (_MSC_VER > 1600)) || \
-     (defined(ICE_CPP11_COMPILER) && !defined(_MSC_VER)))
-#   define ICE_CPP11_COMPILER_HAS_ATOMIC
-#endif
-
-#if defined(ICE_CPP11_COMPILER_HAS_ATOMIC)
-#   include <atomic>
-#elif defined(ICE_USE_MUTEX_SHARED)
-
-#   include <IceUtil/Mutex.h>
-
-// Using the gcc builtins requires gcc 4.1 or better. For Linux, i386
-// doesn't work. Apple is supported for all architectures. Sun only
-// supports sparc (32 and 64 bit).
-
-#elif ((defined(__GNUC__) && (((__GNUC__* 100) + __GNUC_MINOR__) >= 401)) || __clang__)  &&                         \
-        ((defined(__sun) && (defined(__sparc) || defined(__sparcv9))) || \
-         defined(__APPLE__) || \
-        (defined(__linux__) && \
-                (defined(__i486) || defined(__i586) || \
-                 defined(__i686) || defined(__x86_64))))
-
-#   define ICE_HAS_GCC_BUILTINS
-
-#elif defined(_WIN32)
-// Nothing to include
-#else
-// Use a simple mutex
-#   include <IceUtil/Mutex.h>
-#endif
-
-namespace IceUtilInternal
-{
-
-#ifdef ICE_CPP11_COMPILER_HAS_ATOMIC
-typedef std::atomic<int> Atomic;
-#else
-
-#if defined(_WIN32)
-//
-// volatile here is required by InterlockedExchangeXXX
-// family functions.
-//
-#  if defined(__MINGW32__) || (defined(_MSC_VER) && (_MSC_VER <= 1500))
-typedef volatile LONG ATOMIC_T;
-#  else
-typedef unsigned int ATOMIC_T;
-#  endif
-#else
-typedef int ATOMIC_T;
-#endif
-
-//
-// This is temporary and very partial placeholder for std::atomic,
-// which is not yet widely available.
-//
-class ICE_API Atomic : public IceUtil::noncopyable
-{
-public:
-
-    Atomic() :
-        _ref(0)
-    {
-    }
-
-    Atomic(int desired) :
-        _ref(desired)
-    {
-    }
-
-    inline int fetch_add(int value)
-    {
-#if defined(_WIN32)
-        return InterlockedExchangeAdd(&_ref, value);
-#elif defined(ICE_HAS_GCC_BUILTINS)
-        return __sync_fetch_and_add(&_ref, value);
-#else
-        IceUtil::Mutex::Lock sync(_mutex);
-        int tmp = _ref;
-        _ref += value;
-        return tmp;
-#endif
-    }
-
-    inline int fetch_sub(int value)
-    {
-#if defined(_WIN32)
-#  if defined(__MINGW32__) || (defined(_MSC_VER) && (_MSC_VER <= 1500))
-        return InterlockedExchangeAdd(&_ref, -value);
-#  else
-        return InterlockedExchangeSubtract(&_ref, value);
-#endif
-#elif defined(ICE_HAS_GCC_BUILTINS)
-        return __sync_fetch_and_sub(&_ref, value);
-#else
-        IceUtil::Mutex::Lock sync(_mutex);
-        ATOMIC_T tmp = _ref;
-        _ref -= value;
-        return tmp;
-#endif
-    }
-
-    inline int load() const
-    {
-#if defined(_WIN32)
-        return InterlockedExchangeAdd(const_cast<ATOMIC_T*>(&_ref), 0);
-#elif defined(ICE_HAS_GCC_BUILTINS)
-        return __sync_fetch_and_add(const_cast<ATOMIC_T*>(&_ref), 0);
-#else
-        IceUtil::Mutex::Lock sync(_mutex);
-        return _ref;
-#endif
-    }
-
-    inline int exchange(int value)
-    {
-#if defined(_WIN32)
-        return InterlockedExchange(&_ref, value);
-#elif defined(ICE_HAS_GCC_BUILTINS)
-        __sync_synchronize();
-        return __sync_lock_test_and_set(&_ref, value);
-#else
-        IceUtil::Mutex::Lock sync(_mutex);
-        int tmp = _ref;
-        _ref = value;
-        return tmp;
-#endif
-    }
-
-    inline int operator++()
-    {
-        return fetch_add(1) + 1;
-    }
-
-    inline int operator--()
-    {
-        return fetch_sub(1) - 1;
-    }
-
-    inline int operator++(int)
-    {
-        return fetch_add(1);
-    }
-
-    inline int operator--(int)
-    {
-        return fetch_sub(1);
-    }
-
-    inline operator int()
-    {
-        return load();
-    }
-
-    inline operator int() const
-    {
-        return load();
-    }
-
-private:
-
-    ATOMIC_T _ref;
-#if !defined(_WIN32) && !defined(ICE_HAS_GCC_BUILTINS)
-    IceUtil::Mutex _mutex;
-#endif
-};
-
-#endif
-
-}
-
-#endif

data/dist/ice/cpp/include/IceUtil/Cond.h

@@ -1,317 +0,0 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
-
-#ifndef ICE_UTIL_COND_H
-#define ICE_UTIL_COND_H
-
-#include <IceUtil/Config.h>
-#include <IceUtil/Time.h>
-#include <IceUtil/ThreadException.h>
-
-#if defined(_WIN32) && !defined(ICE_HAS_WIN32_CONDVAR)
-#   include <IceUtil/Mutex.h>
-
-namespace IceUtilInternal
-{
-//
-// Needed for implementation.
-//
-class Semaphore
-{
-public:
-
-    Semaphore(long = 0);
-    ICE_API ~Semaphore();
-
-    void wait() const;
-    bool timedWait(const IceUtil::Time&) const;
-    void post(int = 1) const;
-
-private:
-
-    mutable HANDLE _sem;
-};
-}
-#endif
-
-namespace IceUtil
-{
-
-//
-// Forward declaration (for friend declarations).
-//
-template <class T> class Monitor;
-class RecMutex;
-class Mutex;
-
-//
-// Condition variable implementation. Conforms to the same semantics
-// as a POSIX threads condition variable.
-//
-class ICE_API Cond : private noncopyable
-{
-public:
-
-    Cond();
-    ~Cond();
-
-    //
-    // signal restarts one of the threads that are waiting on the
-    // condition variable cond.  If no threads are waiting on cond,
-    // nothing happens. If several threads are waiting on cond,
-    // exactly one is restarted, but it is not specified which.
-    //
-    void signal();
-
-    //
-    // broadcast restarts all the threads that are waiting on the
-    // condition variable cond. Nothing happens if no threads are
-    // waiting on cond.
-    //
-    void broadcast();
-
-    //
-    // MSVC doesn't support out-of-class definitions of member
-    // templates. See KB Article Q241949 for details.
-    //
-
-    //
-    // wait atomically unlocks the mutex and waits for the condition
-    // variable to be signaled. Before returning to the calling thread
-    // the mutex is reaquired.
-    //
-    template <typename Lock> inline void
-    wait(const Lock& lock) const
-    {
-        if(!lock.acquired())
-        {
-            throw ThreadLockedException(__FILE__, __LINE__);
-        }
-        waitImpl(lock._mutex);
-    }
-
-    //
-    // wait atomically unlocks the mutex and waits for the condition
-    // variable to be signaled for up to the given timeout. Before
-    // returning to the calling thread the mutex is reacquired. Returns
-    // true if the condition variable was signaled, false on a
-    // timeout.
-    //
-    template <typename Lock> inline bool
-    timedWait(const Lock& lock, const Time& timeout) const
-    {
-        if(!lock.acquired())
-        {
-            throw ThreadLockedException(__FILE__, __LINE__);
-        }
-        return timedWaitImpl(lock._mutex, timeout);
-    }
-
-private:
-
-    friend class Monitor<Mutex>;
-    friend class Monitor<RecMutex>;
-
-    //
-    // The Monitor implementation uses waitImpl & timedWaitImpl.
-    //
-#if defined(_WIN32) && !defined(ICE_HAS_WIN32_CONDVAR)
-
-    template <typename M> void
-    waitImpl(const M& mutex) const
-    {
-        preWait();
-
-        typedef typename M::LockState LockState;
-
-        LockState state;
-        mutex.unlock(state);
-
-        try
-        {
-            dowait();
-            mutex.lock(state);
-        }
-        catch(...)
-        {
-            mutex.lock(state);
-            throw;
-        }
-    }
-    template <typename M> bool
-    timedWaitImpl(const M& mutex, const Time& timeout) const
-    {
-        preWait();
-
-        typedef typename M::LockState LockState;
-
-        LockState state;
-        mutex.unlock(state);
-
-        try
-        {
-            bool rc = timedDowait(timeout);
-            mutex.lock(state);
-            return rc;
-        }
-        catch(...)
-        {
-            mutex.lock(state);
-            throw;
-        }
-    }
-
-#else
-
-    template <typename M> void waitImpl(const M&) const;
-    template <typename M> bool timedWaitImpl(const M&, const Time&) const;
-
-#endif
-
-#ifdef _WIN32
-#  ifdef ICE_HAS_WIN32_CONDVAR
-    mutable CONDITION_VARIABLE _cond;
-#  else
-    void wake(bool);
-    void preWait() const;
-    void postWait(bool) const;
-    bool timedDowait(const Time&) const;
-    void dowait() const;
-
-    Mutex _internal;
-    IceUtilInternal::Semaphore _gate;
-    IceUtilInternal::Semaphore _queue;
-    mutable long _blocked;
-    mutable long _unblocked;
-    enum State
-    {
-        StateIdle,
-        StateSignal,
-        StateBroadcast
-    };
-    mutable State _state;
-#  endif
-#else
-    mutable pthread_cond_t _cond;
-#endif
-
-};
-
-#ifdef _WIN32
-
-#   ifdef ICE_HAS_WIN32_CONDVAR
-
-template <typename M> inline void
-Cond::waitImpl(const M& mutex) const
-{
-    typedef typename M::LockState LockState;
-
-    LockState state;
-    mutex.unlock(state);
-    BOOL ok = SleepConditionVariableCS(&_cond, state.mutex, INFINITE);
-    mutex.lock(state);
-
-    if(!ok)
-    {
-        throw ThreadSyscallException(__FILE__, __LINE__, GetLastError());
-    }
-}
-
-template <typename M> inline bool
-Cond::timedWaitImpl(const M& mutex, const Time& timeout) const
-{
-    IceUtil::Int64 msTimeout = timeout.toMilliSeconds();
-    if(msTimeout < 0 || msTimeout > 0x7FFFFFFF)
-    {
-        throw IceUtil::InvalidTimeoutException(__FILE__, __LINE__, timeout);
-    }
-
-    typedef typename M::LockState LockState;
-
-    LockState state;
-    mutex.unlock(state);
-    BOOL ok = SleepConditionVariableCS(&_cond, state.mutex, static_cast<DWORD>(msTimeout));
-    mutex.lock(state);
-
-    if(!ok)
-    {
-        DWORD err = GetLastError();
-
-        if(err != ERROR_TIMEOUT)
-        {
-            throw ThreadSyscallException(__FILE__, __LINE__, err);
-        }
-        return false;
-    }
-    return true;
-}
-
-#   endif
-
-#else
-template <typename M> inline void
-Cond::waitImpl(const M& mutex) const
-{
-    typedef typename M::LockState LockState;
-
-    LockState state;
-    mutex.unlock(state);
-    int rc = pthread_cond_wait(&_cond, state.mutex);
-    mutex.lock(state);
-
-    if(rc != 0)
-    {
-        throw ThreadSyscallException(__FILE__, __LINE__, rc);
-    }
-}
-
-template <typename M> inline bool
-Cond::timedWaitImpl(const M& mutex, const Time& timeout) const
-{
-    if(timeout < Time::microSeconds(0))
-    {
-        throw InvalidTimeoutException(__FILE__, __LINE__, timeout);
-    }
-
-    typedef typename M::LockState LockState;
-
-    LockState state;
-    mutex.unlock(state);
-
-#   ifdef __APPLE__
-    //
-    // The monotonic time is based on mach_absolute_time and pthread
-    // condition variables require time from gettimeofday so we get
-    // the realtime time.
-    //
-    timeval tv = Time::now(Time::Realtime) + timeout;
-#   else
-    timeval tv = Time::now(Time::Monotonic) + timeout;
-#   endif
-    timespec ts;
-    ts.tv_sec = tv.tv_sec;
-    ts.tv_nsec = tv.tv_usec * 1000;
-    int rc = pthread_cond_timedwait(&_cond, state.mutex, &ts);
-    mutex.lock(state);
-
-    if(rc != 0)
-    {
-        //
-        // pthread_cond_timedwait returns ETIMEOUT in the event of a
-        // timeout.
-        //
-        if(rc != ETIMEDOUT)
-        {
-            throw ThreadSyscallException(__FILE__, __LINE__, rc);
-        }
-        return false;
-    }
-    return true;
-}
-
-#endif
-
-} // End namespace IceUtil
-
-#endif