Revert #4899 "Add more functionality to LLFile and cleanup LLAPRFile"

Interferes with linux work, will be moved to a different branch and applied separately.

1 files changed, 286 insertions, 848 deletions

diff --git a/indra/llcommon/llfile.cpp b/indra/llcommon/llfile.cpp
index a1d41cdf73..a539e4fe28 100755..100644
--- a/indra/llcommon/llfile.cpp
+++ b/indra/llcommon/llfile.cpp
@@ -29,17 +29,22 @@
 
 #include "linden_common.h"
 #include "llfile.h"
+#include "llstring.h"
 #include "llerror.h"
 #include "stringize.h"
 
 #if LL_WINDOWS
-#include <fcntl.h>
+#include "llwin32headers.h"
+#include <vector>
 #else
 #include <errno.h>
-#include <sys/file.h>
 #endif
 
-// Some of the methods below use OS-level functions that mess with errno. Wrap
+using namespace std;
+
+static std::string empty;
+
+// Many of the methods below use OS-level functions that mess with errno. Wrap
 // variants of strerror() to report errors.
 
 #if LL_WINDOWS
@@ -74,7 +79,6 @@ static errentry const errtable[]
     { ERROR_CURRENT_DIRECTORY,      EACCES    },  //   16
     { ERROR_NOT_SAME_DEVICE,        EXDEV     },  //   17
     { ERROR_NO_MORE_FILES,          ENOENT    },  //   18
-    { ERROR_SHARING_VIOLATION,      EACCES    },  //   32
     { ERROR_LOCK_VIOLATION,         EACCES    },  //   33
     { ERROR_BAD_NETPATH,            ENOENT    },  //   53
     { ERROR_NETWORK_ACCESS_DENIED,  EACCES    },  //   65
@@ -105,25 +109,22 @@ static errentry const errtable[]
     { ERROR_NOT_ENOUGH_QUOTA,       ENOMEM    }   // 1816
 };
 
-static int get_errno_from_oserror(int oserr)
+static int set_errno_from_oserror(unsigned long oserr)
 {
     if (!oserr)
         return 0;
 
     // Check the table for the Windows OS error code
-    for (const struct errentry& entry : errtable)
+    for (const struct errentry &entry : errtable)
     {
         if (oserr == entry.oserr)
         {
-            return entry.errcode;
+            _set_errno(entry.errcode);
+            return -1;
         }
     }
-    return EINVAL;
-}
 
-static int set_errno_from_oserror(unsigned long oserr)
-{
-    _set_errno(get_errno_from_oserror(oserr));
+    _set_errno(EINVAL);
     return -1;
 }
 
@@ -135,8 +136,69 @@ std::string strerr(int errn)
     return buffer;
 }
 
-#else
+inline bool is_slash(wchar_t const c)
+{
+    return c == L'\\' || c == L'/';
+}
 
+static std::wstring utf8path_to_wstring(const std::string& utf8path)
+{
+    if (utf8path.size() >= MAX_PATH)
+    {
+        // By prepending "\\?\" to a path, Windows widechar file APIs will not fail on long path names
+        std::wstring utf16path = L"\\\\?\\" + ll_convert<std::wstring>(utf8path);
+        // We need to make sure that the path does not contain forward slashes as above
+        // prefix does bypass the path normalization that replaces slashes with backslashes
+        // before passing the path to kernel mode APIs
+        std::replace(utf16path.begin(), utf16path.end(), L'/', L'\\');
+        return utf16path;
+    }
+    return ll_convert<std::wstring>(utf8path);
+}
+
+static unsigned short get_fileattr(const std::wstring& utf16path, bool dontFollowSymLink = false)
+{
+    unsigned long  flags = FILE_FLAG_BACKUP_SEMANTICS;
+    if (dontFollowSymLink)
+    {
+        flags |= FILE_FLAG_OPEN_REPARSE_POINT;
+    }
+    HANDLE file_handle = CreateFileW(utf16path.c_str(), FILE_READ_ATTRIBUTES,
+                                     FILE_SHARE_DELETE | FILE_SHARE_READ | FILE_SHARE_WRITE,
+                                     nullptr, OPEN_EXISTING, flags, nullptr);
+    if (file_handle != INVALID_HANDLE_VALUE)
+    {
+        FILE_ATTRIBUTE_TAG_INFO attribute_info;
+        if (GetFileInformationByHandleEx(file_handle, FileAttributeTagInfo, &attribute_info, sizeof(attribute_info)))
+        {
+            // A volume path alone (only drive letter) is not recognized as directory while it technically is
+            bool is_directory = (attribute_info.FileAttributes & FILE_ATTRIBUTE_DIRECTORY) ||
+                                (iswalpha(utf16path[0]) && utf16path[1] == ':' &&
+                                 (!utf16path[2] || (is_slash(utf16path[2]) && !utf16path[3])));
+            unsigned short st_mode = is_directory ? S_IFDIR :
+                                     (attribute_info.FileAttributes & FILE_ATTRIBUTE_REPARSE_POINT ? S_IFLNK : S_IFREG);
+            st_mode |= (attribute_info.FileAttributes & FILE_ATTRIBUTE_READONLY) ? S_IREAD : S_IREAD | S_IWRITE;
+            // we do not try to guess executable flag
+
+            // propagate user bits to group/other fields:
+            st_mode |= (st_mode & 0700) >> 3;
+            st_mode |= (st_mode & 0700) >> 6;
+
+            CloseHandle(file_handle);
+            return st_mode;
+        }
+    }
+    // Retrieve last error and set errno before calling CloseHandle()
+    set_errno_from_oserror(GetLastError());
+
+    if (file_handle != INVALID_HANDLE_VALUE)
+    {
+        CloseHandle(file_handle);
+    }
+    return 0;
+}
+
+#else
 // On Posix we want to call strerror_r(), but alarmingly, there are two
 // different variants. The one that returns int always populates the passed
 // buffer (except in case of error), whereas the other one always returns a
@@ -183,50 +245,9 @@ std::string strerr(int errn)
     return message_from(errn, buffer, sizeof(buffer),
                         strerror_r(errn, buffer, sizeof(buffer)));
 }
-
 #endif  // ! LL_WINDOWS
 
-#if LL_WINDOWS && 0 // turn on to debug file-locking problems
-#define PROCESS_LOCKING_CHECK 1
-static void find_locking_process(const std::string& filename)
-{
-    // Only do any of this stuff (before LL_ENDL) if it will be logged.
-    LL_DEBUGS("LLFile") << "";
-    // wrong way
-    std::string TEMP = LLFile::tmpdir();
-    if (TEMP.empty())
-    {
-        LL_CONT << "No $TEMP, not running 'handle'";
-    }
-    else
-    {
-        std::string tf(TEMP);
-        tf += "\\handle.tmp";
-        // http://technet.microsoft.com/en-us/sysinternals/bb896655
-        std::string cmd(STRINGIZE("handle \"" << filename
-                        // "openfiles /query /v | fgrep -i \"" << filename
-                        << "\" > \"" << tf << '"'));
-        LL_CONT << cmd;
-        if (system(cmd.c_str()) != 0)
-        {
-            LL_CONT << "\nDownload 'handle.exe' from http://technet.microsoft.com/en-us/sysinternals/bb896655";
-        }
-        else
-        {
-            std::ifstream inf(tf);
-            std::string   line;
-            while (std::getline(inf, line))
-            {
-                LL_CONT << '\n' << line;
-            }
-        }
-        LLFile::remove(tf);
-    }
-    LL_CONT << LL_ENDL;
-}
-#endif // LL_WINDOWS hack to identify processes holding file open
-
-static int warnif(const std::string& desc, const std::string& filename, int rc, int suppress_warning = 0)
+static int warnif(const std::string& desc, const std::string& filename, int rc, int accept = 0)
 {
     if (rc < 0)
     {
@@ -235,930 +256,319 @@ static int warnif(const std::string& desc, const std::string& filename, int rc,
 
         // For certain operations, a particular errno value might be
         // acceptable -- e.g. stat() could permit ENOENT, mkdir() could permit
-        // EEXIST. Don't log a warning if caller explicitly says this errno is okay.
-        if (errn != suppress_warning)
+        // EEXIST. Don't warn if caller explicitly says this errno is okay.
+        if (errn != accept)
         {
-            LL_WARNS("LLFile") << "Couldn't " << desc << " '" << filename << "' (errno " << errn << "): " << strerr(errn) << LL_ENDL;
+            LL_WARNS("LLFile") << "Couldn't " << desc << " '" << filename
+                               << "' (errno " << errn << "): " << strerr(errn) << LL_ENDL;
         }
-#if PROCESS_LOCKING_CHECK
+#if 0 && LL_WINDOWS                 // turn on to debug file-locking problems
         // If the problem is "Permission denied," maybe it's because another
         // process has the file open. Try to find out.
-        if (errn == EACCES) // *not* EPERM
+        if (errn == EACCES)         // *not* EPERM
         {
-            find_locking_process(filename);
+            // Only do any of this stuff (before LL_ENDL) if it will be logged.
+            LL_DEBUGS("LLFile") << empty;
+            // would be nice to use LLDir for this, but dependency goes the
+            // wrong way
+            const char* TEMP = LLFile::tmpdir();
+            if (! (TEMP && *TEMP))
+            {
+                LL_CONT << "No $TEMP, not running 'handle'";
+            }
+            else
+            {
+                std::string tf(TEMP);
+                tf += "\\handle.tmp";
+                // http://technet.microsoft.com/en-us/sysinternals/bb896655
+                std::string cmd(STRINGIZE("handle \"" << filename
+                                          // "openfiles /query /v | fgrep -i \"" << filename
+                                          << "\" > \"" << tf << '"'));
+                LL_CONT << cmd;
+                if (system(cmd.c_str()) != 0)
+                {
+                    LL_CONT << "\nDownload 'handle.exe' from http://technet.microsoft.com/en-us/sysinternals/bb896655";
+                }
+                else
+                {
+                    std::ifstream inf(tf);
+                    std::string line;
+                    while (std::getline(inf, line))
+                    {
+                        LL_CONT << '\n' << line;
+                    }
+                }
+                LLFile::remove(tf);
+            }
+            LL_CONT << LL_ENDL;
         }
-#endif
+#endif  // LL_WINDOWS hack to identify processes holding file open
     }
     return rc;
 }
 
-static int warnif(const std::string& desc, const std::string& filename, const std::error_code& ec, int suppress_warning = 0)
+// static
+int LLFile::mkdir(const std::string& dirname, int perms)
 {
-    if (ec)
-    {
-        // get Posix errno from the std::error_code so we can compare it to the suppress_warning parameter
-        // to see when a caller wants us to not generate a warning for a particular error code
-#if LL_WINDOWS
-        int errn = get_errno_from_oserror(ec.value());
-#else
-        int errn = ec.value();
-#endif
-        // For certain operations, a particular errno value might be acceptable
-        // Don't warn if caller explicitly says this errno is okay.
-        if (errn != suppress_warning)
-        {
-            LL_WARNS("LLFile") << "Couldn't " << desc << " '" << filename << "' (errno " << errn << "): " << ec.message() << LL_ENDL;
-        }
-#if PROCESS_LOCKING_CHECK
-        // Try to detect locked files by other processes
-        if (ec.value() == ERROR_SHARING_VIOLATION || ec.value() == ERROR_LOCK_VIOLATION)
-        {
-            find_locking_process(filename);
-        }
-#endif
-        return -1;
-    }
-    return 0;
-}
-
+    // We often use mkdir() to ensure the existence of a directory that might
+    // already exist. There is no known case in which we want to call out as
+    // an error the requested directory already existing.
 #if LL_WINDOWS
-
-inline int set_ec_from_system_error(std::error_code& ec, DWORD error)
-{
-    ec.assign(error, std::system_category());
-    return -1;
-}
-
-static int set_ec_from_system_error(std::error_code& ec)
-{
-    return set_ec_from_system_error(ec, GetLastError());
-}
-
-inline int set_ec_to_parameter_error(std::error_code& ec)
-{
-    return set_ec_from_system_error(ec, ERROR_INVALID_PARAMETER);
-}
-
-inline int set_ec_to_outofmemory_error(std::error_code& ec)
-{
-    return set_ec_from_system_error(ec, ERROR_NOT_ENOUGH_MEMORY);
-}
-
-inline DWORD decode_access_mode(std::ios_base::openmode omode)
-{
-    switch (omode & (LLFile::in | LLFile::out))
-    {
-        case LLFile::in:
-            return GENERIC_READ;
-        case LLFile::out:
-            return GENERIC_WRITE;
-        case LLFile::in | LLFile::out:
-            return GENERIC_READ | GENERIC_WRITE;
-    }
-    if (omode & LLFile::app)
-    {
-        return GENERIC_WRITE;
-    }
-    return 0;
-}
-
-inline DWORD decode_open_create_flags(std::ios_base::openmode omode)
-{
-    if (omode & LLFile::noreplace)
+    // permissions are ignored on Windows
+    int rc = 0;
+    std::wstring utf16dirname = utf8path_to_wstring(dirname);
+    if (!CreateDirectoryW(utf16dirname.c_str(), nullptr))
     {
-        return CREATE_NEW; // create if it does not exist, otherwise fail
-    }
-    if (omode & LLFile::trunc)
-    {
-        if (!(omode & LLFile::out))
+        // Only treat other errors than an already existing file as a real error
+        unsigned long oserr = GetLastError();
+        if (oserr != ERROR_ALREADY_EXISTS)
         {
-            return TRUNCATE_EXISTING; // open and truncate if it exists, otherwise fail
+            rc = set_errno_from_oserror(oserr);
         }
-        return CREATE_ALWAYS; // open and truncate if it exists, otherwise create it
-    }
-    if (!(omode & LLFile::out))
-    {
-        return OPEN_EXISTING; // open if it exists, otherwise fail
-    }
-    // LLFile::app or (LLFile::out and (!LLFile::trunc or !LLFile::noreplace))
-    return OPEN_ALWAYS; // open if it exists, otherwise create it
-}
-
-inline DWORD decode_share_mode(int omode)
-{
-    if (omode & LLFile::exclusive)
-    {
-        return 0; // allow no other access
-    }
-    if (omode & LLFile::shared)
-    {
-        return FILE_SHARE_READ; // allow read access
-    }
-    return FILE_SHARE_READ | FILE_SHARE_WRITE; // allow read and write access to others
-}
-
-inline DWORD decode_attributes(std::ios_base::openmode omode, int perm)
-{
-    return (perm & S_IWRITE) ? FILE_ATTRIBUTE_NORMAL : FILE_ATTRIBUTE_READONLY;
-}
-
-// Under Windows the values for the std::ios_base::seekdir constants match the according FILE_BEGIN
-// and other constants but we do a programmatic translation for now to be sure
-static DWORD seek_mode_from_dir(std::ios_base::seekdir seekdir)
-{
-    switch (seekdir)
-    {
-        case LLFile::beg:
-            return FILE_BEGIN;
-        case LLFile::cur:
-            return FILE_CURRENT;
-        case LLFile::end:
-            return FILE_END;
     }
-    return FILE_BEGIN;
-}
-
 #else
-
-inline int set_ec_from_system_error(std::error_code& ec, int error)
-{
-    ec.assign(error, std::system_category());
-    return -1;
-}
-
-static int set_ec_from_system_error(std::error_code& ec)
-{
-    return set_ec_from_system_error(ec, errno);
-}
-
-inline int set_ec_to_parameter_error(std::error_code& ec)
-{
-    return set_ec_from_system_error(ec, EINVAL);
-}
-
-inline int set_ec_to_outofmemory_error(std::error_code& ec)
-{
-    return set_ec_from_system_error(ec, ENOMEM);
-}
-
-inline int decode_access_mode(std::ios_base::openmode omode)
-{
-    switch (omode & (LLFile::in | LLFile::out))
+    int rc = ::mkdir(dirname.c_str(), (mode_t)perms);
+    if (rc < 0 && errno == EEXIST)
     {
-        case LLFile::out:
-            return O_WRONLY;
-        case LLFile::in | LLFile::out:
-            return O_RDWR;
-    }
-    return O_RDONLY;
-}
-
-inline int decode_open_mode(std::ios_base::openmode omode)
-{
-    int flags = O_CREAT | decode_access_mode(omode);
-    if (omode & LLFile::app)
-    {
-        flags |= O_APPEND;
-    }
-    if (omode & LLFile::trunc)
-    {
-        flags |= O_TRUNC;
-    }
-    if (omode & LLFile::binary)
-    {
-        // Not a thing under *nix
-    }
-    if (omode & LLFile::noreplace)
-    {
-        flags |= O_EXCL;
-    }
-    return flags;
-}
-
-inline int decode_lock_mode(std::ios_base::openmode omode)
-{
-    int lmode = omode & LLFile::noblock ? LOCK_NB : 0;
-    if (omode & LLFile::lock_mask)
-    {
-        if (omode & LLFile::exclusive)
-        {
-            return lmode | LOCK_EX;
-        }
-        return lmode | LOCK_SH;
-    }
-    return lmode | LOCK_UN;
-}
-
-// Under Linux and Mac the values for the std::ios_base::seekdir constants match the according SEEK_SET
-// and other constants but we do a programmatic translation for now to be sure
-inline int seek_mode_from_dir(std::ios_base::seekdir seekdir)
-{
-    switch (seekdir)
-    {
-        case LLFile::beg:
-            return SEEK_SET;
-        case LLFile::cur:
-            return SEEK_CUR;
-        case LLFile::end:
-            return SEEK_END;
+        // this is not the error you want, move along
+        return 0;
     }
-    return SEEK_SET;
-}
-
 #endif
-
-inline int clear_error(std::error_code& ec)
-{
-    ec.clear();
-    return 0;
-}
-
-inline bool are_open_mode_flags_invalid(std::ios_base::openmode omode)
-{
-    // at least one of input or output needs to be specified
-    if (!(omode & (LLFile::in | LLFile::out)))
-    {
-        return true;
-    }
-    // output must be possible for any of the extra options
-    if (!(omode & LLFile::out) && (omode & (LLFile::trunc | LLFile::app | LLFile::noreplace)))
-    {
-        return true;
-    }
-    // invalid combination, mutually exclusive
-    if ((omode & LLFile::app) && (omode & (LLFile::trunc | LLFile::noreplace)))
-    {
-        return true;
-    }
-    return false;
+    // anything else might be a problem
+    return warnif("mkdir", dirname, rc);
 }
 
-//----------------------------------------------------------------------------------------
-// class member functions
-//----------------------------------------------------------------------------------------
-int LLFile::open(const std::string& filename, std::ios_base::openmode omode, std::error_code& ec, int perm)
+// static
+int LLFile::rmdir(const std::string& dirname, int suppress_error)
 {
-    close(ec);
-    if (are_open_mode_flags_invalid(omode))
-    {
-        return set_ec_to_parameter_error(ec);
-    }
 #if LL_WINDOWS
-    DWORD access = decode_access_mode(omode),
-          share = decode_share_mode(omode),
-          create = decode_open_create_flags(omode),
-          attributes = decode_attributes(omode, perm);
-
-    std::wstring file_path = utf8StringToWstring(filename);
-    mHandle = CreateFileW(file_path.c_str(), access, share, nullptr, create, attributes, nullptr);
-    // The dwShareMode = share parameter takes care of locking the file for other processes if indicated,
-    // no need to do anything else for file locking here
+    std::wstring utf16dirname = utf8path_to_wstring(dirname);
+    int rc = _wrmdir(utf16dirname.c_str());
 #else
-    int oflags = decode_open_mode(omode);
-    int lmode = omode & LLFile::lock_mask;
-    mHandle = ::open(filename.c_str(), oflags, perm);
-    if (mHandle != InvalidHandle && lmode && lock(lmode | LLFile::noblock, ec) != 0)
-    {
-        close();
-        return -1;
-    }
+    int rc = ::rmdir(dirname.c_str());
 #endif
-    if (mHandle == InvalidHandle)
-    {
-        return set_ec_from_system_error(ec);
-    }
-
-    if (omode & LLFile::ate && seek(0, LLFile::end, ec) != 0)
-    {
-        close();
-        return -1;
-    }
-    mOpen = omode;
-    return clear_error(ec);
+    return warnif("rmdir", dirname, rc, suppress_error);
 }
 
-S64 LLFile::size(std::error_code& ec)
+// static
+LLFILE* LLFile::fopen(const std::string& filename, const char* mode)
 {
 #if LL_WINDOWS
-    LARGE_INTEGER value = { 0 };
-    if (GetFileSizeEx(mHandle, &value))
-    {
-        clear_error(ec);
-        return value.QuadPart;
-    }
+    std::wstring utf16filename = utf8path_to_wstring(filename);
+    std::wstring utf16mode = ll_convert<std::wstring>(std::string(mode));
+    return _wfopen(utf16filename.c_str(), utf16mode.c_str());
 #else
-    struct stat statval;
-    if (fstat(mHandle, &statval) == 0)
-    {
-        clear_error(ec);
-        return statval.st_size;
-    }
+    return ::fopen(filename.c_str(),mode);
 #endif
-    return set_ec_from_system_error(ec);
 }
 
-S64 LLFile::tell(std::error_code& ec)
+// static
+int LLFile::close(LLFILE * file)
 {
-#if LL_WINDOWS
-    LARGE_INTEGER value = { 0 };
-    if (SetFilePointerEx(mHandle, value, &value, FILE_CURRENT))
-    {
-        clear_error(ec);
-        return value.QuadPart;
-    }
-#else
-    off_t offset = lseek(mHandle, 0, SEEK_CUR);
-    if (offset != -1)
+    int ret_value = 0;
+    if (file)
     {
-        clear_error(ec);
-        return offset;
+        ret_value = fclose(file);
     }
-#endif
-    return set_ec_from_system_error(ec);
-}
-
-int LLFile::seek(S64 pos, std::error_code& ec)
-{
-    return seek(pos, LLFile::beg, ec);
+    return ret_value;
 }
 
-int LLFile::seek(S64 offset, std::ios_base::seekdir dir, std::error_code& ec)
+// static
+std::string LLFile::getContents(const std::string& filename)
 {
-    S64 newOffset = 0;
-#if LL_WINDOWS
-    DWORD seekdir = seek_mode_from_dir(dir);
-    LARGE_INTEGER value;
-    value.QuadPart = offset;
-    if (SetFilePointerEx(mHandle, value, (PLARGE_INTEGER)&newOffset, seekdir))
-#else
-    newOffset = lseek(mHandle, offset, seek_mode_from_dir(dir));
-    if (newOffset != -1)
-#endif
+    LLFILE* fp = LLFile::fopen(filename, "rb");
+    if (fp)
     {
-        return clear_error(ec);
-    }
-    return set_ec_from_system_error(ec);
-}
+        fseek(fp, 0, SEEK_END);
+        U32 length = ftell(fp);
+        fseek(fp, 0, SEEK_SET);
 
-#if LL_WINDOWS
-inline DWORD next_buffer_size(S64 nbytes)
-{
-    return nbytes > 0x80000000 ? 0x80000000 : (DWORD)nbytes;
-}
-#endif
+        std::vector<char> buffer(length);
+        size_t nread = fread(buffer.data(), 1, length, fp);
+        fclose(fp);
 
-S64 LLFile::read(void* buffer, S64 nbytes, std::error_code& ec)
-{
-    if (nbytes == 0)
-    {
-        // Nothing to do
-        return clear_error(ec);
+        return std::string(buffer.data(), nread);
     }
-    else if (!buffer || nbytes < 0)
-    {
-        return set_ec_to_parameter_error(ec);
-    }
-#if LL_WINDOWS
-    S64 totalBytes = 0;
-    char *ptr = (char*)buffer;
-    DWORD bytesRead, bytesToRead = next_buffer_size(nbytes);
 
-    // Read in chunks to support >4GB which the S64 nbytes value makes possible
-    while (ReadFile(mHandle, ptr, bytesToRead, &bytesRead, nullptr))
-    {
-        totalBytes += bytesRead;
-        if (nbytes <= totalBytes || // requested amount read
-            bytesRead < bytesToRead) // ReadFile encountered eof
-        {
-            clear_error(ec);
-            return totalBytes;
-        }
-        ptr += bytesRead;
-        bytesToRead = next_buffer_size(nbytes - totalBytes);
-    }
-#else
-    ssize_t bytesRead = ::read(mHandle, buffer, nbytes);
-    if (bytesRead != -1)
-    {
-        clear_error(ec);
-        return bytesRead;
-    }
-#endif
-    return set_ec_from_system_error(ec);
+    return LLStringUtil::null;
 }
 
-S64 LLFile::write(const void* buffer, S64 nbytes, std::error_code& ec)
+// static
+int LLFile::remove(const std::string& filename, int suppress_error)
 {
-    if (nbytes == 0)
-    {
-        // Nothing to do here
-        return clear_error(ec);
-    }
-    else if (!buffer || nbytes < 0)
-    {
-        return set_ec_to_parameter_error(ec);
-    }
 #if LL_WINDOWS
-    // If this was opened in append mode, we emulate it on Windows
-    if (mOpen & LLFile::app && seek(0, LLFile::end, ec) != 0)
+    // Posix remove() works on both files and directories although on Windows
+    // remove() and its wide char variant _wremove() only removes files just
+    // as its siblings unlink() and _wunlink().
+    // If we really only want to support files we should instead use
+    // unlink() in the non-Windows part below too
+    int rc = -1;
+    std::wstring utf16filename = utf8path_to_wstring(filename);
+    unsigned short st_mode = get_fileattr(utf16filename);
+    if (S_ISDIR(st_mode))
     {
-        return -1;
+        rc = _wrmdir(utf16filename.c_str());
     }
-
-    S64 totalBytes = 0;
-    char* ptr = (char*)buffer;
-    DWORD bytesWritten, bytesToWrite = next_buffer_size(nbytes);
-
-    // Write in chunks to support >4GB which the S64 nbytes value makes possible
-    while (WriteFile(mHandle, ptr, bytesToWrite, &bytesWritten, nullptr))
+    else if (S_ISREG(st_mode))
     {
-        totalBytes += bytesWritten;
-        if (nbytes <= totalBytes)
-        {
-            clear_error(ec);
-            return totalBytes;
-        }
-        ptr += bytesWritten;
-        bytesToWrite = next_buffer_size(nbytes - totalBytes);
+        rc = _wunlink(utf16filename.c_str());
     }
-#else
-    ssize_t bytesWritten = ::write(mHandle, buffer, nbytes);
-    if (bytesWritten != -1)
-    {
-        clear_error(ec);
-        return bytesWritten;
-    }
-#endif
-    return set_ec_from_system_error(ec);
-}
-
-S64 LLFile::printf(const char* fmt, ...)
-{
-    va_list args1;
-    va_start(args1, fmt);
-    va_list args2;
-    va_copy(args2, args1);
-    int length = vsnprintf(nullptr, 0, fmt, args1);
-    va_end(args1);
-    if (length < 0)
+    else if (st_mode)
     {
-        va_end(args2);
-        return -1;
-    }
-    void* buffer = malloc(length + 1);
-    if (!buffer)
-    {
-        va_end(args2);
-        return -1;
-    }
-    length = vsnprintf((char*)buffer, length + 1, fmt, args2);
-    va_end(args2);
-    std::error_code ec;
-    S64 written = write(buffer, length, ec);
-    free(buffer);
-    return written;
-}
-
-int LLFile::lock(int mode, std::error_code& ec)
-{
-#if LL_WINDOWS
-    if (!(mode & LLFile::lock_mask))
-    {
-        if (UnlockFile(mHandle, 0, 0, MAXDWORD, MAXDWORD))
-        {
-            return clear_error(ec);
-        }
+        // it is something else than a file or directory
+        // this should not really happen as long as we do not allow for symlink
+        // detection in the optional parameter to get_fileattr()
+        rc = set_errno_from_oserror(ERROR_INVALID_PARAMETER);
     }
     else
     {
-        OVERLAPPED overlapped = { 0 };
-        DWORD flags = (mode & LLFile::noblock) ? LOCKFILE_FAIL_IMMEDIATELY : 0;
-        if (mode & LLFile::exclusive)
-        {
-            flags |= LOCKFILE_EXCLUSIVE_LOCK;
-        }
-        // We lock the maximum range, since flock only supports locking the entire file too
-        if (LockFileEx(mHandle, flags, 0, MAXDWORD, MAXDWORD, &overlapped))
-        {
-            return clear_error(ec);
-        }
-    }
-#else
-    if (flock(mHandle, decode_lock_mode(mode)) == 0)
-    {
-        return clear_error(ec);
+        // get_fileattr() failed and already set errno, preserve it for correct error reporting
     }
-#endif
-    return set_ec_from_system_error(ec);
-}
-
-int LLFile::close(std::error_code& ec)
-{
-    if (mHandle != InvalidHandle)
-    {
-        llfile_handle_t handle = InvalidHandle;
-        std::swap(handle, mHandle);
-#if LL_WINDOWS
-        if (!CloseHandle(handle))
 #else
-        if (::close(handle))
+    int rc = ::remove(filename.c_str());
 #endif
-        {
-            return set_ec_from_system_error(ec);
-        }
-    }
-    return clear_error(ec);
+    return warnif("remove", filename, rc, suppress_error);
 }
 
-int LLFile::close()
-{
-    std::error_code ec;
-    return close(ec);
-}
-
-//----------------------------------------------------------------------------------------
-// static member functions
-//----------------------------------------------------------------------------------------
-
 // static
-LLFILE* LLFile::fopen(const std::string& filename, const char* mode, int lmode)
+int LLFile::rename(const std::string& filename, const std::string& newname, int suppress_error)
 {
-    LLFILE* file;
 #if LL_WINDOWS
-    int shflag = _SH_DENYNO;
-    switch (lmode)
+    // Posix rename() will gladly overwrite a file at newname if it exists, the Windows
+    // rename(), respectively _wrename(), will bark on that. Instead call directly the Windows
+    // API MoveFileEx() and use its flags to specify that overwrite is allowed.
+    std::wstring utf16filename = utf8path_to_wstring(filename);
+    std::wstring utf16newname = utf8path_to_wstring(newname);
+    int rc = 0;
+    if (!MoveFileExW(utf16filename.c_str(), utf16newname.c_str(), MOVEFILE_REPLACE_EXISTING | MOVEFILE_COPY_ALLOWED))
     {
-        case LLFile::exclusive:
-            shflag = _SH_DENYRW;
-            break;
-        case LLFile::shared:
-            shflag = _SH_DENYWR;
-            break;
+        rc = set_errno_from_oserror(GetLastError());
     }
-    std::wstring file_path = utf8StringToWstring(filename);
-    std::wstring utf16mode = ll_convert<std::wstring>(std::string(mode));
-    file = _wfsopen(file_path.c_str(), utf16mode.c_str(), shflag);
 #else
-    file = ::fopen(filename.c_str(), mode);
-    if (file && (lmode & (LLFile::lock_mask)))
-    {
-        // Rather fail on a sharing conflict than block
-        if (flock(fileno(file), decode_lock_mode(lmode | LLFile::noblock)))
-        {
-            ::fclose(file);
-            file = nullptr;
-        }
-    }
+    int rc = ::rename(filename.c_str(),newname.c_str());
 #endif
-    return file;
+    return warnif(STRINGIZE("rename to '" << newname << "' from"), filename, rc, suppress_error);
 }
 
-// static
-int LLFile::close(LLFILE* file)
-{
-    int ret_value = 0;
-    if (file)
-    {
-        ret_value = ::fclose(file);
-    }
-    return ret_value;
-}
-
-// static
-std::string LLFile::getContents(const std::string& filename)
-{
-    std::error_code ec;
-    return getContents(filename, ec);
-}
-
-// static
-std::string LLFile::getContents(const std::string& filename, std::error_code& ec)
-{
-    std::string buffer;
-    LLFile file(filename, LLFile::in | LLFile::binary, ec);
-    if (file)
-    {
-        S64 length = file.size(ec);
-        if (!ec && length > 0)
-        {
-            buffer = std::string(length, 0);
-            file.read(&buffer[0], length, ec);
-            if (ec)
-            {
-                buffer.clear();
-            }
-        }
-    }
-    return buffer;
-}
-
-// static
-int LLFile::mkdir(const std::string& dirname)
-{
-    std::error_code ec;
-    std::filesystem::path file_path = utf8StringToPath(dirname);
-    // We often use mkdir() to ensure the existence of a directory that might
-    // already exist. There is no known case in which we want to call out as
-    // an error the requested directory already existing.
-    std::filesystem::create_directory(file_path, ec);
-    // The return value is only true if the directory was actually created.
-    // But if it already existed, ec still indicates success.
-    return warnif("mkdir", dirname, ec);
-}
-
-// static
-int LLFile::remove(const std::string& filename, int suppress_warning)
-{
-    std::error_code ec;
-    std::filesystem::path file_path = utf8StringToPath(filename);
-    std::filesystem::remove(file_path, ec);
-    return warnif("remove", filename, ec, suppress_warning);
-}
-
-// static
-int LLFile::rename(const std::string& filename, const std::string& newname, int suppress_warning)
-{
-    std::error_code ec;
-    std::filesystem::path file_path = utf8StringToPath(filename);
-    std::filesystem::path new_path = utf8StringToPath(newname);
-    std::filesystem::rename(file_path, new_path, ec);
-    return warnif(STRINGIZE("rename to '" << newname << "' from"), filename, ec, suppress_warning);
-}
-
-// static
-S64 LLFile::read(const std::string& filename, void* buf, S64 offset, S64 nbytes)
-{
-    std::error_code ec;
-    return read(filename, buf, offset, nbytes, ec);
-}
+// Make this a define rather than using magic numbers multiple times in the code
+#define LLFILE_COPY_BUFFER_SIZE 16384
 
 // static
-S64 LLFile::read(const std::string& filename, void* buf, S64 offset, S64 nbytes, std::error_code& ec)
+bool LLFile::copy(const std::string& from, const std::string& to)
 {
-    // if number of bytes is 0 or less there is nothing to do here
-    if (nbytes <= 0)
+    bool copied = false;
+    LLFILE* in = LLFile::fopen(from, "rb");
+    if (in)
     {
-        clear_error(ec);
-        return 0;
-    }
-
-    if (!buf || offset < 0)
-    {
-        set_ec_to_parameter_error(ec);
-    }
-    else
-    {
-        std::ios_base::openmode omode = LLFile::in | LLFile::binary;
-
-        LLFile file(filename, omode, ec);
-        if (!ec && (bool)file)
+        LLFILE* out = LLFile::fopen(to, "wb");
+        if (out)
         {
-            if (offset > 0)
-            {
-                file.seek(offset, ec);
-            }
-            // else (offset == 0) file was just opened and should already be at 0.
-            if (!ec)
+            char buf[LLFILE_COPY_BUFFER_SIZE];
+            size_t readbytes;
+            bool write_ok = true;
+            while (write_ok && (readbytes = fread(buf, 1, LLFILE_COPY_BUFFER_SIZE, in)))
             {
-                S64 bytes_read = file.read(buf, nbytes, ec);
-                if (!ec)
+                if (fwrite(buf, 1, readbytes, out) != readbytes)
                 {
-                    return bytes_read;
+                    LL_WARNS("LLFile") << "Short write" << LL_ENDL;
+                    write_ok = false;
                 }
             }
-        }
-    }
-    return warnif("read from file failed", filename, ec);
-}
-
-// static
-S64 LLFile::write(const std::string& filename, const void* buf, S64 offset, S64 nbytes)
-{
-    std::error_code ec;
-    return write(filename, buf, offset, nbytes, ec);
-}
-
-// static
-S64 LLFile::write(const std::string& filename, const void* buf, S64 offset, S64 nbytes, std::error_code& ec)
-{
-    // if number of bytes is 0 or less there is nothing to do here
-    if (nbytes <= 0)
-    {
-        clear_error(ec);
-        return 0;
-    }
-
-    if (!buf)
-    {
-        set_ec_to_parameter_error(ec);
-    }
-    else
-    {
-        std::ios_base::openmode omode = LLFile::out | LLFile::binary;
-        if (offset < 0)
-        {
-            omode |= LLFile::app;
-        }
-
-        LLFile file(filename, omode, ec);
-        if (!ec && (bool)file)
-        {
-            if (offset > 0)
+            if ( write_ok )
             {
-                file.seek(offset, ec);
-            }
-            // else (offset == 0) we are not appending, file was just opened and should already be at 0.
-            if (!ec)
-            {
-                S64 bytes_written = file.write(buf, nbytes, ec);
-                if (!ec)
-                {
-                    return bytes_written;
-                }
+                copied = true;
             }
+            fclose(out);
         }
-    }
-    return warnif("write to file failed", filename, ec);
-}
-
-// static
-bool LLFile::copy(const std::string& source, const std::string& target)
-{
-    std::error_code ec;
-    return copy(source, target, std::filesystem::copy_options::overwrite_existing, ec);
-}
-
-// static
-bool LLFile::copy(const std::string& source, const std::string& target, std::filesystem::copy_options options, std::error_code& ec)
-{
-    std::filesystem::path source_path = utf8StringToPath(source);
-    std::filesystem::path target_path = utf8StringToPath(target);
-    bool copied = std::filesystem::copy_file(source_path, target_path, options, ec);
-    if (!copied)
-    {
-        warnif(STRINGIZE("copy failed, to '" << target << "' from"), source, ec);
+        fclose(in);
     }
     return copied;
 }
 
 // static
-int LLFile::stat(const std::string& filename, llstat* filestatus, const char *fname, int suppress_warning)
+int LLFile::stat(const std::string& filename, llstat* filestatus, int suppress_error)
 {
 #if LL_WINDOWS
-    std::wstring file_path = utf8StringToWstring(filename);
-    int rc = _wstat64(file_path.c_str(), filestatus);
+    std::wstring utf16filename = utf8path_to_wstring(filename);
+    int rc = _wstat64(utf16filename.c_str(), filestatus);
 #else
     int rc = ::stat(filename.c_str(), filestatus);
 #endif
-    return warnif(fname ? fname : "stat", filename, rc, suppress_warning);
+    return warnif("stat", filename, rc, suppress_error);
 }
 
 // static
-std::time_t LLFile::getCreationTime(const std::string& filename, int suppress_warning)
+unsigned short LLFile::getattr(const std::string& filename, bool dontFollowSymLink, int suppress_error)
 {
-    // As of C++20 there is no functionality in std::filesystem to retrieve this information
-    llstat filestat;
-    int rc = stat(filename, &filestat, "getCreationTime", suppress_warning);
-    if (rc == 0)
+#if LL_WINDOWS
+    // _wstat64() is a bit heavyweight on Windows, use a more lightweight API
+    // to just get the attributes
+    int rc = -1;
+    std::wstring utf16filename = utf8path_to_wstring(filename);
+    unsigned short st_mode = get_fileattr(utf16filename, dontFollowSymLink);
+    if (st_mode)
     {
-#if LL_DARWIN
-        return filestat.st_birthtime;
-#else
-        // Linux stat() doesn't have a creation/birth time (st_ctime really is the last status
-        // change or inode attributes change) unless we would use statx() instead. But that is
-        // a major effort, which would require Linux specific changes to LLFile::stat() above
-        // and possibly adaptions for other platforms that we leave for a later exercise if it
-        // is ever desired.
-        return filestat.st_ctime;
-#endif
+        return st_mode;
     }
-    return 0;
-}
-
-// static
-std::time_t LLFile::getModificationTime(const std::string& filename, int suppress_warning)
-{
-    // tried to use std::filesystem::last_write_time() but the whole std::chrono infrastructure is as of
-    // C++20 still not fully implemented on all platforms. Specifically MacOS C++20 seems lacking here,
-    // and Windows requires a roundabout through std::chrono::utc_clock to then get a
-    // std::chrono::system_clock that can return a more useful time_t.
-    // So we take the easy way out in a similar way as with getCreationTime().
-    llstat filestat;
-    int rc = stat(filename, &filestat, "getModificationTime", suppress_warning);
+#else
+    llstat filestatus;
+    int rc = dontFollowSymLink ? ::lstat(filename.c_str(), &filestatus) : ::stat(filename.c_str(), &filestatus);
     if (rc == 0)
     {
-        return filestat.st_mtime;
+        return filestatus.st_mode;
     }
+#endif
+    warnif("getattr", filename, rc, suppress_error);
     return 0;
 }
 
 // static
-S64 LLFile::size(const std::string& filename, int suppress_warning)
-{
-    std::error_code ec;
-    std::filesystem::path file_path = utf8StringToPath(filename);
-    std::intmax_t size = static_cast<std::intmax_t>(std::filesystem::file_size(file_path, ec));
-    if (ec)
-    {
-        return warnif("size", filename, ec, suppress_warning);
-    }
-    return size;
-}
-
-// static
-std::filesystem::file_status LLFile::getStatus(const std::string& filename, bool dontFollowSymLink, int suppress_warning)
-{
-    std::error_code ec;
-    std::filesystem::path file_path = utf8StringToPath(filename);
-    std::filesystem::file_status status;
-    if (dontFollowSymLink)
-    {
-        status = std::filesystem::symlink_status(file_path, ec);
-    }
-    else
-    {
-        status = std::filesystem::status(file_path, ec);
-    }
-    warnif("getStatus()", filename, ec, suppress_warning);
-    return status;
-}
-
-// static
-bool LLFile::exists(const std::string& filename)
-{
-    std::filesystem::file_status status = getStatus(filename);
-    return std::filesystem::exists(status);
-}
-
-// static
 bool LLFile::isdir(const std::string& filename)
 {
-    std::filesystem::file_status status = getStatus(filename);
-    return std::filesystem::is_directory(status);
+    return S_ISDIR(getattr(filename));
 }
 
 // static
 bool LLFile::isfile(const std::string& filename)
 {
-    std::filesystem::file_status status = getStatus(filename);
-    return std::filesystem::is_regular_file(status);
+    return S_ISREG(getattr(filename));
 }
 
 // static
 bool LLFile::islink(const std::string& filename)
 {
-    std::filesystem::file_status status = getStatus(filename, true);
-    return std::filesystem::is_symlink(status);
+    return S_ISLNK(getattr(filename, true));
 }
 
 // static
-const std::string& LLFile::tmpdir()
+const char *LLFile::tmpdir()
 {
-    static std::string temppath;
-    if (temppath.empty())
-    {
-        temppath = std::filesystem::temp_directory_path().string();
-    }
-    return temppath;
-}
+    static std::string utf8path;
 
-// static
-std::filesystem::path LLFile::utf8StringToPath(const std::string& pathname)
-{
-#if LL_WINDOWS
-    return ll_convert<std::wstring>(pathname);
-#else
-    return pathname;
-#endif
-}
-
-#if LL_WINDOWS
-
-// static
-std::wstring LLFile::utf8StringToWstring(const std::string& pathname)
-{
-    std::wstring utf16string(ll_convert<std::wstring>(pathname));
-    if (utf16string.size() >= MAX_PATH)
+    if (utf8path.empty())
     {
-        // By going through std::filesystem::path we get a lot of path sanitation done for us that
-        // is needed when passing a path with a kernel object space prefix to Windows API functions
-        // since this prefix disables the kernel32 path normalization
-        std::filesystem::path utf16path(utf16string);
+        char sep;
+#if LL_WINDOWS
+        sep = '\\';
 
-        // By prepending "\\?\" to a path, Windows widechar file APIs will not fail on long path names
-        utf16string.assign(L"\\\\?\\").append(utf16path);
+        std::vector<wchar_t> utf16path(MAX_PATH + 1);
+        GetTempPathW(static_cast<DWORD>(utf16path.size()), &utf16path[0]);
+        utf8path = ll_convert_wide_to_string(&utf16path[0]);
+#else
+        sep = '/';
 
-        /* remove trailing spaces and dots (yes, Windows really does that) */
-        size_t last_valid = utf16string.find_last_not_of(L" \t.");
-        if (last_valid == std::wstring::npos)
+        utf8path = LLStringUtil::getenv("TMPDIR", "/tmp/");
+#endif
+        if (utf8path[utf8path.size() - 1] != sep)
         {
-            return std::wstring();
+            utf8path += sep;
         }
-        return utf16string.substr(0, last_valid + 1);
     }
-    return utf16string;
+    return utf8path.c_str();
 }
 
+#if LL_WINDOWS
+
 /************** input file stream ********************************/
 
 llifstream::llifstream() {}
@@ -1176,8 +586,10 @@ void llifstream::open(const std::string& _Filename, ios_base::openmode _Mode)
                         _Mode | ios_base::in);
 }
 
+
 /************** output file stream ********************************/
 
+
 llofstream::llofstream() {}
 
 // explicit
@@ -1193,4 +605,30 @@ void llofstream::open(const std::string& _Filename, ios_base::openmode _Mode)
                         _Mode | ios_base::out);
 }
 
+/************** helper functions ********************************/
+
+std::streamsize llifstream_size(llifstream& ifstr)
+{
+    if(!ifstr.is_open()) return 0;
+    std::streampos pos_old = ifstr.tellg();
+    ifstr.seekg(0, ios_base::beg);
+    std::streampos pos_beg = ifstr.tellg();
+    ifstr.seekg(0, ios_base::end);
+    std::streampos pos_end = ifstr.tellg();
+    ifstr.seekg(pos_old, ios_base::beg);
+    return pos_end - pos_beg;
+}
+
+std::streamsize llofstream_size(llofstream& ofstr)
+{
+    if(!ofstr.is_open()) return 0;
+    std::streampos pos_old = ofstr.tellp();
+    ofstr.seekp(0, ios_base::beg);
+    std::streampos pos_beg = ofstr.tellp();
+    ofstr.seekp(0, ios_base::end);
+    std::streampos pos_end = ofstr.tellp();
+    ofstr.seekp(pos_old, ios_base::beg);
+    return pos_end - pos_beg;
+}
+
 #endif  // LL_WINDOWS