/**
 * @file llfile.cpp
 * @author Michael Schlachter
 * @date 2006-03-23
 * @brief Implementation of cross-platform POSIX file buffer and c++
 * stream classes.
 *
 * $LicenseInfo:firstyear=2006&license=viewerlgpl$
 * Second Life Viewer Source Code
 * Copyright (C) 2010, Linden Research, Inc.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation;
 * version 2.1 of the License only.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 *
 * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
 * $/LicenseInfo$
 */

#include "linden_common.h"
#include "llfile.h"
#include "llstring.h"
#include "llerror.h"
#include "stringize.h"

#if LL_WINDOWS
#include "llwin32headers.h"
#include <vector>
#else
#include <errno.h>
#endif

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
// For the situations where we directly call into Windows API functions we need to translate
// the Windows error codes into errno values
namespace
{
    struct errentry
    {
        unsigned long oserr; // Windows OS error value
        int errcode;         // System V error code
    };
}

// translation table between Windows OS error value and System V errno code
static errentry const errtable[]
{
    { ERROR_INVALID_FUNCTION,       EINVAL    },  //    1
    { ERROR_FILE_NOT_FOUND,         ENOENT    },  //    2
    { ERROR_PATH_NOT_FOUND,         ENOENT    },  //    3
    { ERROR_TOO_MANY_OPEN_FILES,    EMFILE    },  //    4
    { ERROR_ACCESS_DENIED,          EACCES    },  //    5
    { ERROR_INVALID_HANDLE,         EBADF     },  //    6
    { ERROR_ARENA_TRASHED,          ENOMEM    },  //    7
    { ERROR_NOT_ENOUGH_MEMORY,      ENOMEM    },  //    8
    { ERROR_INVALID_BLOCK,          ENOMEM    },  //    9
    { ERROR_BAD_ENVIRONMENT,        E2BIG     },  //   10
    { ERROR_BAD_FORMAT,             ENOEXEC   },  //   11
    { ERROR_INVALID_ACCESS,         EINVAL    },  //   12
    { ERROR_INVALID_DATA,           EINVAL    },  //   13
    { ERROR_INVALID_DRIVE,          ENOENT    },  //   15
    { ERROR_CURRENT_DIRECTORY,      EACCES    },  //   16
    { ERROR_NOT_SAME_DEVICE,        EXDEV     },  //   17
    { ERROR_NO_MORE_FILES,          ENOENT    },  //   18
    { ERROR_LOCK_VIOLATION,         EACCES    },  //   33
    { ERROR_BAD_NETPATH,            ENOENT    },  //   53
    { ERROR_NETWORK_ACCESS_DENIED,  EACCES    },  //   65
    { ERROR_BAD_NET_NAME,           ENOENT    },  //   67
    { ERROR_FILE_EXISTS,            EEXIST    },  //   80
    { ERROR_CANNOT_MAKE,            EACCES    },  //   82
    { ERROR_FAIL_I24,               EACCES    },  //   83
    { ERROR_INVALID_PARAMETER,      EINVAL    },  //   87
    { ERROR_NO_PROC_SLOTS,          EAGAIN    },  //   89
    { ERROR_DRIVE_LOCKED,           EACCES    },  //  108
    { ERROR_BROKEN_PIPE,            EPIPE     },  //  109
    { ERROR_DISK_FULL,              ENOSPC    },  //  112
    { ERROR_INVALID_TARGET_HANDLE,  EBADF     },  //  114
    { ERROR_WAIT_NO_CHILDREN,       ECHILD    },  //  128
    { ERROR_CHILD_NOT_COMPLETE,     ECHILD    },  //  129
    { ERROR_DIRECT_ACCESS_HANDLE,   EBADF     },  //  130
    { ERROR_NEGATIVE_SEEK,          EINVAL    },  //  131
    { ERROR_SEEK_ON_DEVICE,         EACCES    },  //  132
    { ERROR_DIR_NOT_EMPTY,          ENOTEMPTY },  //  145
    { ERROR_NOT_LOCKED,             EACCES    },  //  158
    { ERROR_BAD_PATHNAME,           ENOENT    },  //  161
    { ERROR_MAX_THRDS_REACHED,      EAGAIN    },  //  164
    { ERROR_LOCK_FAILED,            EACCES    },  //  167
    { ERROR_ALREADY_EXISTS,         EEXIST    },  //  183
    { ERROR_FILENAME_EXCED_RANGE,   ENOENT    },  //  206
    { ERROR_NESTING_NOT_ALLOWED,    EAGAIN    },  //  215
    { ERROR_NO_UNICODE_TRANSLATION, EILSEQ    },  // 1113
    { ERROR_NOT_ENOUGH_QUOTA,       ENOMEM    }   // 1816
};

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)
    {
        if (oserr == entry.oserr)
        {
            _set_errno(entry.errcode);
            return -1;
        }
    }

    _set_errno(EINVAL);
    return -1;
}

// On Windows, use strerror_s().
std::string strerr(int errn)
{
    char buffer[256];
    strerror_s(buffer, errn);       // infers sizeof(buffer) -- love it!
    return buffer;
}

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
// valid char* but might or might not populate the passed buffer. How do we
// know which one we're getting? Define adapters for each and let the compiler
// select the applicable adapter.

// strerror_r() returns char*
std::string message_from(int /*orig_errno*/, const char* /*buffer*/, size_t /*bufflen*/,
                         const char* strerror_ret)
{
    return strerror_ret;
}

// strerror_r() returns int
std::string message_from(int orig_errno, const char* buffer, size_t bufflen,
                         int strerror_ret)
{
    if (strerror_ret == 0)
    {
        return buffer;
    }
    // Here strerror_r() has set errno. Since strerror_r() has already failed,
    // seems like a poor bet to call it again to diagnose its own error...
    int stre_errno = errno;
    if (stre_errno == ERANGE)
    {
        return STRINGIZE("strerror_r() can't explain errno " << orig_errno
                         << " (" << bufflen << "-byte buffer too small)");
    }
    if (stre_errno == EINVAL)
    {
        return STRINGIZE("unknown errno " << orig_errno);
    }
    // Here we don't even understand the errno from strerror_r()!
    return STRINGIZE("strerror_r() can't explain errno " << orig_errno
                     << " (error " << stre_errno << ')');
}

std::string strerr(int errn)
{
    char buffer[256];
    // Select message_from() function matching the strerror_r() we have on hand.
    return message_from(errn, buffer, sizeof(buffer),
                        strerror_r(errn, buffer, sizeof(buffer)));
}
#endif  // ! LL_WINDOWS

static int warnif(const std::string& desc, const std::string& filename, int rc, int accept = 0)
{
    if (rc < 0)
    {
        // Capture errno before we start emitting output
        int errn = errno;

        // For certain operations, a particular errno value might be
        // acceptable -- e.g. stat() could permit ENOENT, mkdir() could permit
        // 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;
        }
#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
        {
            // 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  // LL_WINDOWS hack to identify processes holding file open
    }
    return rc;
}

// static
int LLFile::mkdir(const std::string& dirname, int perms)
{
    // 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
    // permissions are ignored on Windows
    int rc = 0;
    std::wstring utf16dirname = utf8path_to_wstring(dirname);
    if (!CreateDirectoryW(utf16dirname.c_str(), nullptr))
    {
        // Only treat other errors than an already existing file as a real error
        unsigned long oserr = GetLastError();
        if (oserr != ERROR_ALREADY_EXISTS)
        {
            rc = set_errno_from_oserror(oserr);
        }
    }
#else
    int rc = ::mkdir(dirname.c_str(), (mode_t)perms);
    if (rc < 0 && errno == EEXIST)
    {
        // this is not the error you want, move along
        return 0;
    }
#endif
    // anything else might be a problem
    return warnif("mkdir", dirname, rc);
}

// static
int LLFile::rmdir(const std::string& dirname, int suppress_error)
{
#if LL_WINDOWS
    std::wstring utf16dirname = utf8path_to_wstring(dirname);
    int rc = _wrmdir(utf16dirname.c_str());
#else
    int rc = ::rmdir(dirname.c_str());
#endif
    return warnif("rmdir", dirname, rc, suppress_error);
}

// static
LLFILE* LLFile::fopen(const std::string& filename, const char* mode)
{
#if LL_WINDOWS
    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
    return ::fopen(filename.c_str(),mode);
#endif
}

// 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)
{
    LLFILE* fp = LLFile::fopen(filename, "rb");
    if (fp)
    {
        fseek(fp, 0, SEEK_END);
        U32 length = ftell(fp);
        fseek(fp, 0, SEEK_SET);

        std::vector<char> buffer(length);
        size_t nread = fread(buffer.data(), 1, length, fp);
        fclose(fp);

        return std::string(buffer.data(), nread);
    }

    return LLStringUtil::null;
}

// static
int LLFile::remove(const std::string& filename, int suppress_error)
{
#if LL_WINDOWS
    // 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))
    {
        rc = _wrmdir(utf16filename.c_str());
    }
    else if (S_ISREG(st_mode))
    {
        rc = _wunlink(utf16filename.c_str());
    }
    else if (st_mode)
    {
        // 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
    {
        // get_fileattr() failed and already set errno, preserve it for correct error reporting
    }
#else
    int rc = ::remove(filename.c_str());
#endif
    return warnif("remove", filename, rc, suppress_error);
}

// static
int LLFile::rename(const std::string& filename, const std::string& newname, int suppress_error)
{
#if LL_WINDOWS
    // 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))
    {
        rc = set_errno_from_oserror(GetLastError());
    }
#else
    int rc = ::rename(filename.c_str(),newname.c_str());
#endif
    return warnif(STRINGIZE("rename to '" << newname << "' from"), filename, rc, suppress_error);
}

// Make this a define rather than using magic numbers multiple times in the code
#define LLFILE_COPY_BUFFER_SIZE 16384

// static
bool LLFile::copy(const std::string& from, const std::string& to)
{
    bool copied = false;
    LLFILE* in = LLFile::fopen(from, "rb");
    if (in)
    {
        LLFILE* out = LLFile::fopen(to, "wb");
        if (out)
        {
            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)))
            {
                if (fwrite(buf, 1, readbytes, out) != readbytes)
                {
                    LL_WARNS("LLFile") << "Short write" << LL_ENDL;
                    write_ok = false;
                }
            }
            if ( write_ok )
            {
                copied = true;
            }
            fclose(out);
        }
        fclose(in);
    }
    return copied;
}

// static
int LLFile::stat(const std::string& filename, llstat* filestatus, int suppress_error)
{
#if LL_WINDOWS
    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("stat", filename, rc, suppress_error);
}

// static
unsigned short LLFile::getattr(const std::string& filename, bool dontFollowSymLink, int suppress_error)
{
#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)
    {
        return st_mode;
    }
#else
    llstat filestatus;
    int rc = dontFollowSymLink ? ::lstat(filename.c_str(), &filestatus) : ::stat(filename.c_str(), &filestatus);
    if (rc == 0)
    {
        return filestatus.st_mode;
    }
#endif
    warnif("getattr", filename, rc, suppress_error);
    return 0;
}

// static
bool LLFile::isdir(const std::string& filename)
{
    return S_ISDIR(getattr(filename));
}

// static
bool LLFile::isfile(const std::string& filename)
{
    return S_ISREG(getattr(filename));
}

// static
bool LLFile::islink(const std::string& filename)
{
    return S_ISLNK(getattr(filename, true));
}

// static
const char *LLFile::tmpdir()
{
    static std::string utf8path;

    if (utf8path.empty())
    {
        char sep;
#if LL_WINDOWS
        sep = '\\';

        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 = '/';

        utf8path = LLStringUtil::getenv("TMPDIR", "/tmp/");
#endif
        if (utf8path[utf8path.size() - 1] != sep)
        {
            utf8path += sep;
        }
    }
    return utf8path.c_str();
}

#if LL_WINDOWS

/************** input file stream ********************************/

llifstream::llifstream() {}

// explicit
llifstream::llifstream(const std::string& _Filename, ios_base::openmode _Mode):
    std::ifstream(ll_convert<std::wstring>( _Filename ).c_str(),
                  _Mode | ios_base::in)
{
}

void llifstream::open(const std::string& _Filename, ios_base::openmode _Mode)
{
    std::ifstream::open(ll_convert<std::wstring>(_Filename).c_str(),
                        _Mode | ios_base::in);
}


/************** output file stream ********************************/


llofstream::llofstream() {}

// explicit
llofstream::llofstream(const std::string& _Filename, ios_base::openmode _Mode):
    std::ofstream(ll_convert<std::wstring>( _Filename ).c_str(),
                  _Mode | ios_base::out)
{
}

void llofstream::open(const std::string& _Filename, ios_base::openmode _Mode)
{
    std::ofstream::open(ll_convert<std::wstring>( _Filename ).c_str(),
                        _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