webkitgtk-2.16.5HEADwebkitgtk-2.16.5master

2 files changed, 470 insertions, 0 deletions

diff --git a/Source/WebCore/platform/posix/FileSystemPOSIX.cpp b/Source/WebCore/platform/posix/FileSystemPOSIX.cpp
new file mode 100644
index 000000000..e29720a4f
--- /dev/null
+++ b/Source/WebCore/platform/posix/FileSystemPOSIX.cpp
@@ -0,0 +1,395 @@
+/*
+ * Copyright (C) 2007-2017 Apple Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1.  Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ * 2.  Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ * 3.  Neither the name of Apple Inc. ("Apple") nor the names of
+ *     its contributors may be used to endorse or promote products derived
+ *     from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "config.h"
+#include "FileSystem.h"
+
+#include "FileMetadata.h"
+#include <dirent.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <fnmatch.h>
+#include <libgen.h>
+#include <stdio.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <wtf/text/CString.h>
+#include <wtf/text/WTFString.h>
+
+namespace WebCore {
+
+bool fileExists(const String& path)
+{
+    if (path.isNull())
+        return false;
+
+    CString fsRep = fileSystemRepresentation(path);
+
+    if (!fsRep.data() || fsRep.data()[0] == '\0')
+        return false;
+
+    struct stat fileInfo;
+
+    // stat(...) returns 0 on successful stat'ing of the file, and non-zero in any case where the file doesn't exist or cannot be accessed
+    return !stat(fsRep.data(), &fileInfo);
+}
+
+bool deleteFile(const String& path)
+{
+    CString fsRep = fileSystemRepresentation(path);
+
+    if (!fsRep.data() || fsRep.data()[0] == '\0')
+        return false;
+
+    // unlink(...) returns 0 on successful deletion of the path and non-zero in any other case (including invalid permissions or non-existent file)
+    return !unlink(fsRep.data());
+}
+
+PlatformFileHandle openFile(const String& path, FileOpenMode mode)
+{
+    CString fsRep = fileSystemRepresentation(path);
+
+    if (fsRep.isNull())
+        return invalidPlatformFileHandle;
+
+    int platformFlag = 0;
+    if (mode == OpenForRead)
+        platformFlag |= O_RDONLY;
+    else if (mode == OpenForWrite)
+        platformFlag |= (O_WRONLY | O_CREAT | O_TRUNC);
+    return open(fsRep.data(), platformFlag, 0666);
+}
+
+void closeFile(PlatformFileHandle& handle)
+{
+    if (isHandleValid(handle)) {
+        close(handle);
+        handle = invalidPlatformFileHandle;
+    }
+}
+
+long long seekFile(PlatformFileHandle handle, long long offset, FileSeekOrigin origin)
+{
+    int whence = SEEK_SET;
+    switch (origin) {
+    case SeekFromBeginning:
+        whence = SEEK_SET;
+        break;
+    case SeekFromCurrent:
+        whence = SEEK_CUR;
+        break;
+    case SeekFromEnd:
+        whence = SEEK_END;
+        break;
+    default:
+        ASSERT_NOT_REACHED();
+    }
+    return static_cast<long long>(lseek(handle, offset, whence));
+}
+
+bool truncateFile(PlatformFileHandle handle, long long offset)
+{
+    // ftruncate returns 0 to indicate the success.
+    return !ftruncate(handle, offset);
+}
+
+int writeToFile(PlatformFileHandle handle, const char* data, int length)
+{
+    do {
+        int bytesWritten = write(handle, data, static_cast<size_t>(length));
+        if (bytesWritten >= 0)
+            return bytesWritten;
+    } while (errno == EINTR);
+    return -1;
+}
+
+int readFromFile(PlatformFileHandle handle, char* data, int length)
+{
+    do {
+        int bytesRead = read(handle, data, static_cast<size_t>(length));
+        if (bytesRead >= 0)
+            return bytesRead;
+    } while (errno == EINTR);
+    return -1;
+}
+
+#if USE(FILE_LOCK)
+bool lockFile(PlatformFileHandle handle, FileLockMode lockMode)
+{
+    COMPILE_ASSERT(LOCK_SH == LockShared, LockSharedEncodingIsAsExpected);
+    COMPILE_ASSERT(LOCK_EX == LockExclusive, LockExclusiveEncodingIsAsExpected);
+    COMPILE_ASSERT(LOCK_NB == LockNonBlocking, LockNonBlockingEncodingIsAsExpected);
+    int result = flock(handle, lockMode);
+    return (result != -1);
+}
+
+bool unlockFile(PlatformFileHandle handle)
+{
+    int result = flock(handle, LOCK_UN);
+    return (result != -1);
+}
+#endif
+
+#if !PLATFORM(MAC)
+bool deleteEmptyDirectory(const String& path)
+{
+    CString fsRep = fileSystemRepresentation(path);
+
+    if (!fsRep.data() || fsRep.data()[0] == '\0')
+        return false;
+
+    // rmdir(...) returns 0 on successful deletion of the path and non-zero in any other case (including invalid permissions or non-existent file)
+    return !rmdir(fsRep.data());
+}
+#endif
+
+bool getFileSize(const String& path, long long& result)
+{
+    CString fsRep = fileSystemRepresentation(path);
+
+    if (!fsRep.data() || fsRep.data()[0] == '\0')
+        return false;
+
+    struct stat fileInfo;
+
+    if (stat(fsRep.data(), &fileInfo))
+        return false;
+
+    result = fileInfo.st_size;
+    return true;
+}
+
+bool getFileSize(PlatformFileHandle handle, long long& result)
+{
+    struct stat fileInfo;
+    if (fstat(handle, &fileInfo))
+        return false;
+
+    result = fileInfo.st_size;
+    return true;
+}
+
+bool getFileCreationTime(const String& path, time_t& result)
+{
+#if OS(DARWIN) || OS(OPENBSD) || OS(NETBSD) || OS(FREEBSD)
+    CString fsRep = fileSystemRepresentation(path);
+
+    if (!fsRep.data() || fsRep.data()[0] == '\0')
+        return false;
+
+    struct stat fileInfo;
+
+    if (stat(fsRep.data(), &fileInfo))
+        return false;
+
+    result = fileInfo.st_birthtime;
+    return true;
+#else
+    UNUSED_PARAM(path);
+    UNUSED_PARAM(result);
+    return false;
+#endif
+}
+
+bool getFileModificationTime(const String& path, time_t& result)
+{
+    CString fsRep = fileSystemRepresentation(path);
+
+    if (!fsRep.data() || fsRep.data()[0] == '\0')
+        return false;
+
+    struct stat fileInfo;
+
+    if (stat(fsRep.data(), &fileInfo))
+        return false;
+
+    result = fileInfo.st_mtime;
+    return true;
+}
+
+bool getFileMetadata(const String& path, FileMetadata& metadata)
+{
+    CString fsRep = fileSystemRepresentation(path);
+
+    if (!fsRep.data() || fsRep.data()[0] == '\0')
+        return false;
+
+    struct stat fileInfo;
+    if (stat(fsRep.data(), &fileInfo))
+        return false;
+
+    metadata.modificationTime = fileInfo.st_mtime;
+    metadata.length = fileInfo.st_size;
+    metadata.type = S_ISDIR(fileInfo.st_mode) ? FileMetadata::TypeDirectory : FileMetadata::TypeFile;
+    return true;
+}
+
+String pathByAppendingComponent(const String& path, const String& component)
+{
+    if (path.endsWith('/'))
+        return path + component;
+    return path + "/" + component;
+}
+
+bool makeAllDirectories(const String& path)
+{
+    CString fullPath = fileSystemRepresentation(path);
+    if (!access(fullPath.data(), F_OK))
+        return true;
+
+    char* p = fullPath.mutableData() + 1;
+    int length = fullPath.length();
+
+    if(p[length - 1] == '/')
+        p[length - 1] = '\0';
+    for (; *p; ++p)
+        if (*p == '/') {
+            *p = '\0';
+            if (access(fullPath.data(), F_OK))
+                if (mkdir(fullPath.data(), S_IRWXU))
+                    return false;
+            *p = '/';
+        }
+    if (access(fullPath.data(), F_OK))
+        if (mkdir(fullPath.data(), S_IRWXU))
+            return false;
+
+    return true;
+}
+
+String pathGetFileName(const String& path)
+{
+    return path.substring(path.reverseFind('/') + 1);
+}
+
+String directoryName(const String& path)
+{
+    CString fsRep = fileSystemRepresentation(path);
+
+    if (!fsRep.data() || fsRep.data()[0] == '\0')
+        return String();
+
+    return dirname(fsRep.mutableData());
+}
+
+Vector<String> listDirectory(const String& path, const String& filter)
+{
+    Vector<String> entries;
+    CString cpath = fileSystemRepresentation(path);
+    CString cfilter = fileSystemRepresentation(filter);
+    DIR* dir = opendir(cpath.data());
+    if (dir) {
+        struct dirent* dp;
+        while ((dp = readdir(dir))) {
+            const char* name = dp->d_name;
+            if (!strcmp(name, ".") || !strcmp(name, ".."))
+                continue;
+            if (fnmatch(cfilter.data(), name, 0))
+                continue;
+            char filePath[PATH_MAX];
+            if (static_cast<int>(sizeof(filePath) - 1) < snprintf(filePath, sizeof(filePath), "%s/%s", cpath.data(), name))
+                continue; // buffer overflow
+
+            auto string = stringFromFileSystemRepresentation(filePath);
+
+            // Some file system representations cannot be represented as a UTF-16 string,
+            // so this string might be null.
+            if (!string.isNull())
+                entries.append(WTFMove(string));
+        }
+        closedir(dir);
+    }
+    return entries;
+}
+
+#if !OS(DARWIN) || PLATFORM(GTK)
+String openTemporaryFile(const String& prefix, PlatformFileHandle& handle)
+{
+    char buffer[PATH_MAX];
+    const char* tmpDir = getenv("TMPDIR");
+
+    if (!tmpDir)
+        tmpDir = "/tmp";
+
+    if (snprintf(buffer, PATH_MAX, "%s/%sXXXXXX", tmpDir, prefix.utf8().data()) >= PATH_MAX)
+        goto end;
+
+    handle = mkstemp(buffer);
+    if (handle < 0)
+        goto end;
+
+    return String::fromUTF8(buffer);
+
+end:
+    handle = invalidPlatformFileHandle;
+    return String();
+}
+#endif
+
+bool hardLinkOrCopyFile(const String& source, const String& destination)
+{
+    if (source.isEmpty() || destination.isEmpty())
+        return false;
+
+    CString fsSource = fileSystemRepresentation(source);
+    if (!fsSource.data())
+        return false;
+
+    CString fsDestination = fileSystemRepresentation(destination);
+    if (!fsDestination.data())
+        return false;
+
+    if (!link(fsSource.data(), fsDestination.data()))
+        return true;
+
+    // Hard link failed. Perform a copy instead.
+    auto handle = open(fsDestination.data(), O_WRONLY | O_CREAT | O_EXCL, 0666);
+    if (handle == -1)
+        return false;
+
+    bool appendResult = appendFileContentsToFileHandle(source, handle);
+    close(handle);
+
+    // If the copy failed, delete the unusable file.
+    if (!appendResult)
+        unlink(fsDestination.data());
+
+    return appendResult;
+}
+
+std::optional<int32_t> getFileDeviceId(const CString& fsFile)
+{
+    struct stat fileStat;
+    if (stat(fsFile.data(), &fileStat) == -1)
+        return std::nullopt;
+
+    return fileStat.st_dev;
+}
+
+} // namespace WebCore
diff --git a/Source/WebCore/platform/posix/SharedBufferPOSIX.cpp b/Source/WebCore/platform/posix/SharedBufferPOSIX.cpp
new file mode 100644
index 000000000..569f8f100
--- /dev/null
+++ b/Source/WebCore/platform/posix/SharedBufferPOSIX.cpp
@@ -0,0 +1,75 @@
+/*
+ * Copyright (C) 2010 Company 100, Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "config.h"
+#include "SharedBuffer.h"
+
+#include "FileSystem.h"
+
+#include <fcntl.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <wtf/text/CString.h>
+
+namespace WebCore {
+
+RefPtr<SharedBuffer> SharedBuffer::createFromReadingFile(const String& filePath)
+{
+    if (filePath.isEmpty())
+        return nullptr;
+
+    CString filename = fileSystemRepresentation(filePath);
+    int fd = open(filename.data(), O_RDONLY);
+    if (fd == -1)
+        return nullptr;
+
+    struct stat fileStat;
+    if (fstat(fd, &fileStat)) {
+        close(fd);
+        return nullptr;
+    }
+
+    size_t bytesToRead;
+    if (!WTF::convertSafely(fileStat.st_size, bytesToRead)) {
+        close(fd);
+        return nullptr;
+    }
+
+    Vector<char> buffer(bytesToRead);
+
+    size_t totalBytesRead = 0;
+    ssize_t bytesRead;
+    while ((bytesRead = read(fd, buffer.data() + totalBytesRead, bytesToRead - totalBytesRead)) > 0)
+        totalBytesRead += bytesRead;
+
+    close(fd);
+
+    if (totalBytesRead != bytesToRead)
+        return nullptr;
+
+    return SharedBuffer::adoptVector(buffer);
+}
+
+} // namespace WebCore