zeroc-ice 3.7.10 → 3.8.0

data/dist/ice/cpp/src/Ice/FileUtil.cpp

@@ -0,0 +1,476 @@
+// Copyright (c) ZeroC, Inc.
+
+#include "FileUtil.h"
+#include "Ice/StringConverter.h"
+#include "Ice/StringUtil.h"
+
+#include "DisableWarnings.h"
+
+#include <cassert>
+#include <climits>
+#include <sstream>
+#include <string>
+
+#ifdef _WIN32
+#    include <Shlwapi.h>
+#    include <io.h>
+#    include <process.h>
+#else
+#    include <dirent.h>
+#    include <unistd.h>
+#endif
+
+using namespace std;
+
+//
+// Determine if path is an absolute path
+//
+bool
+IceInternal::isAbsolutePath(const string& path)
+{
+    size_t i = 0;
+    size_t size = path.size();
+
+    // Skip whitespace
+    while (i < size && isspace(static_cast<unsigned char>(path[i])))
+    {
+        ++i;
+    }
+
+#ifdef _WIN32
+    // We need at least 3 non whitespace character to have
+    // and absolute path
+    if (i + 3 > size)
+    {
+        return false;
+    }
+
+    // Check for X:\ path ('\' may have been converted to '/')
+    if ((path[i] >= 'A' && path[i] <= 'Z') || (path[i] >= 'a' && path[i] <= 'z'))
+    {
+        return path[i + 1] == ':' && (path[i + 2] == '\\' || path[i + 2] == '/');
+    }
+
+    // Check for UNC path
+    return (path[i] == '\\' && path[i + 1] == '\\') || path[i] == '/';
+#else
+    if (i >= size)
+    {
+        return false;
+    }
+
+    return path[i] == '/';
+#endif
+}
+
+//
+// Determine if a directory exists.
+//
+bool
+IceInternal::directoryExists(const string& path)
+{
+    IceInternal::structstat st;
+    if (IceInternal::stat(path, &st) != 0 || !S_ISDIR(st.st_mode))
+    {
+        return false;
+    }
+    return true;
+}
+
+//
+// Determine if a directory exists and is empty.
+//
+bool
+IceInternal::isEmptyDirectory(const string& path)
+{
+#ifdef _WIN32
+    return PathIsDirectoryEmptyW(stringToWstring(path, Ice::getProcessStringConverter()).c_str());
+#else
+    struct dirent* d;
+    DIR* dir = opendir(path.c_str());
+    if (dir)
+    {
+        bool empty = true;
+        while ((d = readdir(dir)))
+        {
+            string name(d->d_name);
+            if (name != "." && name != "..")
+            {
+                empty = false;
+                break;
+            }
+        }
+        closedir(dir);
+        return empty;
+    }
+    else
+    {
+        return false;
+    }
+#endif
+}
+
+//
+// Determine if a regular file exists.
+//
+bool
+IceInternal::fileExists(const string& path)
+{
+    IceInternal::structstat st;
+    if (IceInternal::stat(path, &st) != 0 || !S_ISREG(st.st_mode))
+    {
+        return false;
+    }
+    return true;
+}
+
+FILE*
+IceInternal::freopen(const std::string& path, const std::string& mode, FILE* stream)
+{
+#ifdef _LARGEFILE64_SOURCE
+    return freopen64(path.c_str(), mode.c_str(), stream);
+#else
+#    ifdef _WIN32
+    //
+    // Don't need to use a wide string converter, the wide strings are directly passed
+    // to Windows API.
+    //
+    const Ice::StringConverterPtr converter = Ice::getProcessStringConverter();
+    return _wfreopen(stringToWstring(path, converter).c_str(), stringToWstring(mode, converter).c_str(), stream);
+#    else
+    return freopen(path.c_str(), mode.c_str(), stream);
+#    endif
+#endif
+}
+
+#ifdef _WIN32
+
+//
+// Stat
+//
+int
+IceInternal::stat(const string& path, structstat* buffer)
+{
+    //
+    // Don't need to use a wide string converter, the wide string is directly passed
+    // to Windows API.
+    //
+    return _wstat(stringToWstring(path, Ice::getProcessStringConverter()).c_str(), buffer);
+}
+
+int
+IceInternal::remove(const string& path)
+{
+    return ::_wremove(stringToWstring(path, Ice::getProcessStringConverter()).c_str());
+}
+
+int
+IceInternal::rename(const string& from, const string& to)
+{
+    //
+    // Don't need to use a wide string converter, the wide strings are directly passed
+    // to Windows API.
+    //
+    const Ice::StringConverterPtr converter = Ice::getProcessStringConverter();
+    return ::_wrename(stringToWstring(from, converter).c_str(), stringToWstring(to, converter).c_str());
+}
+
+int
+IceInternal::rmdir(const string& path)
+{
+    //
+    // Don't need to use a wide string converter, the wide string is directly passed
+    // to Windows API.
+    //
+    return ::_wrmdir(stringToWstring(path, Ice::getProcessStringConverter()).c_str());
+}
+
+int
+IceInternal::mkdir(const string& path, int)
+{
+    //
+    // Don't need to use a wide string converter, the wide string is directly passed
+    // to Windows API.
+    //
+    return ::_wmkdir(stringToWstring(path, Ice::getProcessStringConverter()).c_str());
+}
+
+FILE*
+IceInternal::fopen(const string& path, const string& mode)
+{
+    //
+    // Don't need to use a wide string converter, the wide strings are directly passed
+    // to Windows API.
+    //
+    const Ice::StringConverterPtr converter = Ice::getProcessStringConverter();
+    return ::_wfopen(stringToWstring(path, converter).c_str(), stringToWstring(mode, converter).c_str());
+}
+
+int
+IceInternal::open(const string& path, int flags)
+{
+    //
+    // Don't need to use a wide string converter, the wide string is directly passed
+    // to Windows API.
+    //
+    if (flags & _O_CREAT)
+    {
+        return ::_wopen(stringToWstring(path, Ice::getProcessStringConverter()).c_str(), flags, _S_IREAD | _S_IWRITE);
+    }
+    else
+    {
+        return ::_wopen(stringToWstring(path, Ice::getProcessStringConverter()).c_str(), flags);
+    }
+}
+
+int
+IceInternal::getcwd(string& cwd)
+{
+    //
+    // Don't need to use a wide string converter, the wide string come
+    // from Windows API.
+    //
+    wchar_t cwdbuf[_MAX_PATH];
+    if (_wgetcwd(cwdbuf, _MAX_PATH) == nullptr)
+    {
+        return -1;
+    }
+    cwd = wstringToString(cwdbuf, Ice::getProcessStringConverter());
+    return 0;
+}
+
+int
+IceInternal::unlink(const string& path)
+{
+    //
+    // Don't need to use a wide string converter, the wide string is directly passed
+    // to Windows API.
+    //
+    return _wunlink(stringToWstring(path, Ice::getProcessStringConverter()).c_str());
+}
+
+int
+IceInternal::close(int fd)
+{
+#    ifdef _WIN32
+    return _close(fd);
+#    else
+    return ::close(fd);
+#    endif
+}
+
+IceInternal::FileLock::FileLock(const std::string& path) : _path(path)
+{
+    //
+    // Don't need to use a wide string converter, the wide string is directly passed
+    // to Windows API.
+    //
+    _fd = ::CreateFileW(
+        stringToWstring(path, Ice::getProcessStringConverter()).c_str(),
+        GENERIC_WRITE,
+        0,
+        nullptr,
+        OPEN_ALWAYS,
+        FILE_ATTRIBUTE_NORMAL,
+        nullptr);
+    _path = path;
+
+    if (_fd == INVALID_HANDLE_VALUE)
+    {
+        throw FileLockException(__FILE__, __LINE__, GetLastError(), _path);
+    }
+
+    OVERLAPPED overlaped;
+    overlaped.Internal = 0;
+    overlaped.InternalHigh = 0;
+    overlaped.Offset = 0;
+    overlaped.OffsetHigh = 0;
+
+#    if defined(_MSC_VER)
+    overlaped.hEvent = nullptr;
+#    else
+    overlaped.hEvent = 0;
+#    endif
+
+    if (::LockFileEx(_fd, LOCKFILE_EXCLUSIVE_LOCK | LOCKFILE_FAIL_IMMEDIATELY, 0, 0, 0, &overlaped) == 0)
+    {
+        ::CloseHandle(_fd);
+        throw FileLockException(__FILE__, __LINE__, GetLastError(), _path);
+    }
+    //
+    // In Windows implementation we don't write the process pid to the file, as it is
+    // not possible to read the file from other process while it is locked here.
+    //
+}
+
+IceInternal::FileLock::~FileLock()
+{
+    assert(_fd != INVALID_HANDLE_VALUE);
+    CloseHandle(_fd);
+    unlink(_path);
+}
+
+wstring
+IceInternal::streamFilename(const string& filename)
+{
+    return stringToWstring(filename, Ice::getProcessStringConverter());
+}
+
+#else
+
+//
+// Stat
+//
+int
+IceInternal::stat(const string& path, structstat* buffer)
+{
+    return ::stat(path.c_str(), buffer);
+}
+
+int
+IceInternal::remove(const string& path)
+{
+    return ::remove(path.c_str());
+}
+
+int
+IceInternal::rename(const string& from, const string& to)
+{
+    return ::rename(from.c_str(), to.c_str());
+}
+
+int
+IceInternal::rmdir(const string& path)
+{
+    return ::rmdir(path.c_str());
+}
+
+int
+IceInternal::mkdir(const string& path, int perm)
+{
+    return ::mkdir(path.c_str(), static_cast<mode_t>(perm));
+}
+
+FILE*
+IceInternal::fopen(const string& path, const string& mode)
+{
+    return ::fopen(path.c_str(), mode.c_str());
+}
+
+int
+IceInternal::open(const string& path, int flags)
+{
+    if (flags & O_CREAT)
+    {
+        // By default, create with rw-rw-rw- modified by the user's umask (same as fopen).
+        return ::open(path.c_str(), flags, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH);
+    }
+    else
+    {
+        return ::open(path.c_str(), flags);
+    }
+}
+
+int
+IceInternal::getcwd(string& cwd)
+{
+    char cwdbuf[PATH_MAX];
+    if (::getcwd(cwdbuf, PATH_MAX) == nullptr)
+    {
+        return -1;
+    }
+    cwd = cwdbuf;
+    return 0;
+}
+
+int
+IceInternal::unlink(const string& path)
+{
+    return ::unlink(path.c_str());
+}
+
+int
+IceInternal::close(int fd)
+{
+    return ::close(fd);
+}
+
+IceInternal::FileLock::FileLock(const std::string& path) : _path(path)
+{
+    _fd = ::open(path.c_str(), O_RDWR | O_CREAT, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP);
+    if (_fd < 0)
+    {
+        throw FileLockException(__FILE__, __LINE__, errno, _path);
+    }
+
+    struct ::flock lock;
+    lock.l_type = F_WRLCK;    // Write lock
+    lock.l_whence = SEEK_SET; // Beginning of file
+    lock.l_start = 0;
+    lock.l_len = 0;
+
+    //
+    // F_SETLK tells fcntl to not block if it cannot
+    // acquire the lock, if the lock cannot be acquired
+    // it returns -1 without wait.
+    //
+    if (::fcntl(_fd, F_SETLK, &lock) == -1)
+    {
+        int err = errno;
+        close(_fd);
+        throw FileLockException(__FILE__, __LINE__, err, _path);
+    }
+
+    //
+    // If there is an error after here, we close the fd,
+    // to release the lock.
+    //
+
+    //
+    // Now that we have acquire an exclusive write lock,
+    // write the process pid there.
+    //
+    ostringstream os;
+    os << getpid();
+
+    if (write(_fd, os.str().c_str(), os.str().size()) == -1)
+    {
+        int err = errno;
+        close(_fd);
+        throw FileLockException(__FILE__, __LINE__, err, _path);
+    }
+}
+
+IceInternal::FileLock::~FileLock()
+{
+    assert(_fd > -1);
+    ::close(_fd);
+    unlink(_path);
+}
+
+#endif
+
+namespace
+{
+    inline string createFileLockExceptionMessage(int error, const string& path)
+    {
+        ostringstream os;
+        os << "could not lock file '" << path << "'";
+        if (error != 0)
+        {
+            os << ": " << IceInternal::errorToString(error);
+        }
+        return os.str();
+    }
+}
+
+IceInternal::FileLockException::FileLockException(const char* file, int line, int error, const string& path)
+    : Ice::LocalException(file, line, createFileLockExceptionMessage(error, path))
+{
+}
+
+const char*
+IceInternal::FileLockException::ice_id() const noexcept
+{
+    return "::IceInternal::FileLockException";
+}

data/dist/ice/cpp/src/Ice/FileUtil.h

@@ -0,0 +1,152 @@
+// Copyright (c) ZeroC, Inc.
+
+#ifndef ICE_FILE_UTIL_H
+#define ICE_FILE_UTIL_H
+
+#include "Ice/Config.h"
+#include "Ice/LocalException.h"
+
+#ifdef _WIN32
+#    ifndef NOMINMAX
+#        define NOMINMAX
+#    endif
+#    include <windows.h>
+#endif
+
+#include <fcntl.h>
+#include <stdio.h>
+#include <string>
+#include <sys/stat.h>
+
+namespace IceInternal
+{
+#ifdef _WIN32
+    const char* const separator = "\\";
+#else
+    const char* const separator = "/";
+#endif
+
+    //
+    // Determine if path is an absolute path.
+    //
+    ICE_API bool isAbsolutePath(const std::string&);
+
+    //
+    // Determine if a file exists.
+    //
+    ICE_API bool fileExists(const std::string&);
+
+    //
+    // Determine if a directory exists.
+    //
+    ICE_API bool directoryExists(const std::string&);
+
+    //
+    // Determine if a directory exists and is empty.
+    //
+    ICE_API bool isEmptyDirectory(const std::string&);
+
+#ifdef _WIN32
+
+    typedef struct _stat64i32 structstat;
+
+#    ifdef _MSC_VER
+#        ifndef O_RDONLY
+#            define O_RDONLY _O_RDONLY
+#        endif
+
+#        ifndef O_BINARY
+#            define O_BINARY _O_BINARY
+#        endif
+
+#        ifndef S_ISDIR
+#            define S_ISDIR(mode) ((mode) & _S_IFDIR)
+#        endif
+
+#        ifndef S_ISREG
+#            define S_ISREG(mode) ((mode) & _S_IFREG)
+#        endif
+#    endif
+
+#else
+
+    using structstat = struct stat;
+#    define O_BINARY 0
+
+#endif
+
+    //
+    // OS stat
+    //
+    ICE_API int stat(const std::string&, structstat*);
+    ICE_API int remove(const std::string&);
+    ICE_API int rename(const std::string&, const std::string&);
+    ICE_API int rmdir(const std::string&);
+
+    ICE_API int mkdir(const std::string&, int);
+    ICE_API FILE* fopen(const std::string&, const std::string&);
+    ICE_API FILE* freopen(const std::string&, const std::string&, FILE*);
+    ICE_API int open(const std::string&, int);
+    ICE_API int getcwd(std::string&);
+
+    ICE_API int unlink(const std::string&);
+    ICE_API int close(int);
+
+    //
+    // This class is used to implement process file locking. This class
+    // is not intended to do file locking within the same process.
+    //
+    class ICE_API FileLock
+    {
+    public:
+        //
+        // The constructor opens the given file (eventually creating it)
+        // and acquires a lock on the file or throws FileLockException if
+        // the file couldn't be locked.
+        //
+        // If the lock can be acquired, the process pid is written to the
+        // file.
+        //
+        FileLock(const std::string&);
+
+        FileLock(const FileLock&) = delete;
+
+        //
+        // The destructor releases the lock and removes the file.
+        //
+        virtual ~FileLock();
+
+        FileLock& operator=(const FileLock&) = delete;
+
+    private:
+#ifdef _WIN32
+        HANDLE _fd{INVALID_HANDLE_VALUE};
+#else
+        int _fd{-1};
+#endif
+        std::string _path;
+    };
+
+    /// This exception indicates the failure to lock a file.
+    class ICE_API FileLockException final : public Ice::LocalException
+    {
+    public:
+        /// Constructs a FileLockException.
+        /// @param file The file where this exception is constructed. This C string is not copied.
+        /// @param line The line where this exception is constructed.
+        /// @param error The error code.
+        /// @param path The path of the file.
+        FileLockException(const char* file, int line, int error, const std::string& path);
+
+        [[nodiscard]] const char* ice_id() const noexcept final;
+    };
+
+    // Use streamFilename to construct the filename given to std stream classes
+    // like ifstream and ofstream.
+#if defined(_WIN32)
+    ICE_API std::wstring streamFilename(const std::string&);
+#else
+    inline std::string streamFilename(const std::string& filename) { return filename; }
+#endif
+}
+#endif

data/dist/ice/cpp/src/Ice/FixedRequestHandler.cpp

@@ -0,0 +1,34 @@
+// Copyright (c) ZeroC, Inc.
+
+#include "FixedRequestHandler.h"
+#include "ConnectionI.h"
+#include "Ice/OutgoingAsync.h"
+
+using namespace std;
+using namespace Ice;
+using namespace IceInternal;
+
+FixedRequestHandler::FixedRequestHandler(const ReferencePtr& reference, Ice::ConnectionIPtr connection, bool compress)
+    : RequestHandler(reference),
+      _connection(std::move(connection)),
+      _compress(compress)
+{
+}
+
+AsyncStatus
+FixedRequestHandler::sendAsyncRequest(const ProxyOutgoingAsyncBasePtr& out)
+{
+    return out->invokeRemote(_connection, _compress, _response);
+}
+
+void
+FixedRequestHandler::asyncRequestCanceled(const OutgoingAsyncBasePtr& outAsync, std::exception_ptr ex)
+{
+    _connection->asyncRequestCanceled(outAsync, ex);
+}
+
+Ice::ConnectionIPtr
+FixedRequestHandler::getConnection()
+{
+    return _connection;
+}

data/dist/ice/cpp/src/Ice/FixedRequestHandler.h

@@ -0,0 +1,29 @@
+// Copyright (c) ZeroC, Inc.
+
+#ifndef ICE_FIXED_REQUEST_HANDLER_H
+#define ICE_FIXED_REQUEST_HANDLER_H
+
+#include "Ice/ReferenceF.h"
+#include "RequestHandler.h"
+
+namespace IceInternal
+{
+    // A request handler for a fixed reference.
+    class FixedRequestHandler final : public RequestHandler
+    {
+    public:
+        FixedRequestHandler(const ReferencePtr&, Ice::ConnectionIPtr, bool);
+
+        AsyncStatus sendAsyncRequest(const ProxyOutgoingAsyncBasePtr&) final;
+
+        void asyncRequestCanceled(const OutgoingAsyncBasePtr&, std::exception_ptr) final;
+
+        Ice::ConnectionIPtr getConnection() final;
+
+    private:
+        Ice::ConnectionIPtr _connection;
+        bool _compress;
+    };
+}
+
+#endif