test_common/harness/os_helpers.cpp

//
// Copyright (c) 2017 The Khronos Group Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//    http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
#include "os_helpers.h"
#include "errorHelpers.h"

// =================================================================================================
// C++ interface.
// =================================================================================================

#include <cerrno> // errno, error constants
#include <climits> // PATH_MAX
#include <cstdlib> // abort, _splitpath, _makepath
#include <cstring> // strdup, strerror_r
#include <sstream>

#include <vector>

#if defined(__ANDROID__)
#include <android/api-level.h>
#endif

#define CHECK_PTR(ptr)                                                         \
    if ((ptr) == NULL)                                                         \
    {                                                                          \
        abort();                                                               \
    }

typedef std::vector<char> buffer_t;

#if !defined(PATH_MAX)
#define PATH_MAX 1000
#endif

int const _size = PATH_MAX + 1; // Initial buffer size for path.
int const _count = 8; // How many times we will try to double buffer size.

// -------------------------------------------------------------------------------------------------
// MacOS X
// -------------------------------------------------------------------------------------------------

#if defined(__APPLE__)


#include <mach-o/dyld.h> // _NSGetExecutablePath
#include <libgen.h> // dirname


static std::string
_err_msg(int err, // Error number (e. g. errno).
         int level // Nesting level, for avoiding infinite recursion.
)
{

    /*
        There are 3 incompatible versions of strerror_r:

            char * strerror_r( int, char *, size_t );  // GNU version
            int    strerror_r( int, char *, size_t );  // BSD version
            int    strerror_r( int, char *, size_t );  // XSI version

        BSD version returns error code, while XSI version returns 0 or -1 and
       sets errno.

    */

    // BSD version of strerror_r.
    buffer_t buffer(100);
    int count = _count;
    for (;;)
    {
        int rc = strerror_r(err, &buffer.front(), buffer.size());
        if (rc == EINVAL)
        {
            // Error code is not recognized, but anyway we got the message.
            return &buffer.front();
        }
        else if (rc == ERANGE)
        {
            // Buffer is not enough.
            if (count > 0)
            {
                // Enlarge the buffer.
                --count;
                buffer.resize(buffer.size() * 2);
            }
            else
            {
                std::stringstream ostr;
                ostr << "Error " << err << " "
                     << "(Getting error message failed: "
                     << "Buffer of " << buffer.size()
                     << " bytes is still too small"
                     << ")";
                return ostr.str();
            }; // if
        }
        else if (rc == 0)
        {
            // We got the message.
            return &buffer.front();
        }
        else
        {
            std::stringstream ostr;
            ostr << "Error " << err << " "
                 << "(Getting error message failed: "
                 << (level < 2 ? _err_msg(rc, level + 1) : "Oops") << ")";
            return ostr.str();
        }; // if
    }; // forever

} // _err_msg


std::string dir_sep() { return "/"; } // dir_sep


std::string exe_path()
{
    buffer_t path(_size);
    int count = _count;
    for (;;)
    {
        uint32_t size = path.size();
        int rc = _NSGetExecutablePath(&path.front(), &size);
        if (rc == 0)
        {
            break;
        }; // if
        if (count > 0)
        {
            --count;
            path.resize(size);
        }
        else
        {
            log_error("ERROR: Getting executable path failed: "
                      "_NSGetExecutablePath failed: Buffer of %lu bytes is "
                      "still too small\n",
                      (unsigned long)path.size());
            exit(2);
        }; // if
    }; // forever
    return &path.front();
} // exe_path


std::string exe_dir()
{
    std::string path = exe_path();
    // We cannot pass path.c_str() to `dirname' bacause `dirname' modifies its
    // argument.
    buffer_t buffer(path.c_str(),
                    path.c_str() + path.size() + 1); // Copy with trailing zero.
    return dirname(&buffer.front());
} // exe_dir


#endif // __APPLE__

// -------------------------------------------------------------------------------------------------
// Linux
// -------------------------------------------------------------------------------------------------

#if defined(__linux__)


#include <cerrno> // errno
#include <libgen.h> // dirname
#include <unistd.h> // readlink


static std::string _err_msg(int err, int level)
{

    /*
        There are 3 incompatible versions of strerror_r:

            char * strerror_r( int, char *, size_t );  // GNU version
            int    strerror_r( int, char *, size_t );  // BSD version
            int    strerror_r( int, char *, size_t );  // XSI version

        BSD version returns error code, while XSI version returns 0 or -1 and
       sets errno.

    */

#if (defined(__ANDROID__) && __ANDROID_API__ < 23)                             \
    || ((_POSIX_C_SOURCE >= 200112L || _XOPEN_SOURCE >= 600) && !_GNU_SOURCE)

// XSI version of strerror_r.
#warning Not tested!
    buffer_t buffer(200);
    int count = _count;
    for (;;)
    {
        int rc = strerror_r(err, &buffer.front(), buffer.size());
        if (rc == -1)
        {
            int _err = errno;
            if (_err == ERANGE)
            {
                if (count > 0)
                {
                    // Enlarge the buffer.
                    --count;
                    buffer.resize(buffer.size() * 2);
                }
                else
                {
                    std::stringstream ostr;
                    ostr << "Error " << err << " "
                         << "(Getting error message failed: "
                         << "Buffer of " << buffer.size()
                         << " bytes is still too small"
                         << ")";
                    return ostr.str();
                }; // if
            }
            else
            {
                std::stringstream ostr;
                ostr << "Error " << err << " "
                     << "(Getting error message failed: "
                     << (level < 2 ? _err_msg(_err, level + 1) : "Oops") << ")";
                return ostr.str();
            }; // if
        }
        else
        {
            // We got the message.
            return &buffer.front();
        }; // if
    }; // forever

#else

    // GNU version of strerror_r.
    char buffer[2000];
    return strerror_r(err, buffer, sizeof(buffer));

#endif

} // _err_msg


std::string dir_sep() { return "/"; } // dir_sep


std::string exe_path()
{

    static std::string const exe = "/proc/self/exe";

    buffer_t path(_size);
    int count = _count; // Max number of iterations.

    for (;;)
    {

        ssize_t len = readlink(exe.c_str(), &path.front(), path.size());

        if (len < 0)
        {
            // Oops.
            int err = errno;
            log_error("ERROR: Getting executable path failed: "
                      "Reading symlink `%s' failed: %s\n",
                      exe.c_str(), err_msg(err).c_str());
            exit(2);
        }; // if

        if (len < path.size())
        {
            // We got the path.
            path.resize(len);
            break;
        }; // if

        // Oops, buffer is too small.
        if (count > 0)
        {
            --count;
            // Enlarge the buffer.
            path.resize(path.size() * 2);
        }
        else
        {
            log_error("ERROR: Getting executable path failed: "
                      "Reading symlink `%s' failed: Buffer of %lu bytes is "
                      "still too small\n",
                      exe.c_str(), (unsigned long)path.size());
            exit(2);
        }; // if

    }; // forever

    return std::string(&path.front(), path.size());

} // exe_path


std::string exe_dir()
{
    std::string path = exe_path();
    // We cannot pass path.c_str() to `dirname' bacause `dirname' modifies its
    // argument.
    buffer_t buffer(path.c_str(),
                    path.c_str() + path.size() + 1); // Copy with trailing zero.
    return dirname(&buffer.front());
} // exe_dir

#endif // __linux__

// -------------------------------------------------------------------------------------------------
// MS Windows
// -------------------------------------------------------------------------------------------------

#if defined(_WIN32)


#include <windows.h>
#if defined(max)
#undef max
#endif

#include <cctype>
#include <algorithm>


static std::string _err_msg(int err, int level)
{

    std::string msg;

    LPSTR buffer = NULL;
    DWORD flags = FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM
        | FORMAT_MESSAGE_IGNORE_INSERTS;

    DWORD len = FormatMessageA(flags, NULL, err, LANG_USER_DEFAULT,
                               reinterpret_cast<LPSTR>(&buffer), 0, NULL);

    if (buffer == NULL || len == 0)
    {

        int _err = GetLastError();
        char str[1024] = { 0 };
        snprintf(str, sizeof(str),
                 "Error 0x%08x (Getting error message failed: %s )", err,
                 (level < 2 ? _err_msg(_err, level + 1).c_str() : "Oops"));
        msg = std::string(str);
    }
    else
    {

        // Trim trailing whitespace (including `\r' and `\n').
        while (len > 0 && isspace(buffer[len - 1]))
        {
            --len;
        }; // while

        // Drop trailing full stop.
        if (len > 0 && buffer[len - 1] == '.')
        {
            --len;
        }; // if

        msg.assign(buffer, len);

    }; // if

    if (buffer != NULL)
    {
        LocalFree(buffer);
    }; // if

    return msg;

} // _get_err_msg


std::string dir_sep() { return "\\"; } // dir_sep


std::string exe_path()
{

    buffer_t path(_size);
    int count = _count;

    for (;;)
    {

        DWORD len = GetModuleFileNameA(NULL, &path.front(), path.size());

        if (len == 0)
        {
            int err = GetLastError();
            log_error("ERROR: Getting executable path failed: %s\n",
                      err_msg(err).c_str());
            exit(2);
        }; // if

        if (len < path.size())
        {
            path.resize(len);
            break;
        }; // if

        // Buffer too small.
        if (count > 0)
        {
            --count;
            path.resize(path.size() * 2);
        }
        else
        {
            log_error("ERROR: Getting executable path failed: "
                      "Buffer of %lu bytes is still too small\n",
                      (unsigned long)path.size());
            exit(2);
        }; // if

    }; // forever

    return std::string(&path.front(), path.size());

} // exe_path


std::string exe_dir()
{

    std::string exe = exe_path();
    int count = 0;

    // Splitting path into components.
    buffer_t drv(_MAX_DRIVE);
    buffer_t dir(_MAX_DIR);
    count = _count;
#if defined(_MSC_VER)
    for (;;)
    {
        int rc =
            _splitpath_s(exe.c_str(), &drv.front(), drv.size(), &dir.front(),
                         dir.size(), NULL, 0, // We need neither name
                         NULL, 0 // nor extension
            );
        if (rc == 0)
        {
            break;
        }
        else if (rc == ERANGE)
        {
            if (count > 0)
            {
                --count;
                // Buffer is too small, but it is not clear which one.
                // So we have to enlarge all.
                drv.resize(drv.size() * 2);
                dir.resize(dir.size() * 2);
            }
            else
            {
                log_error("ERROR: Getting executable path failed: "
                          "Splitting path `%s' to components failed: "
                          "Buffers of %lu and %lu bytes are still too small\n",
                          exe.c_str(), (unsigned long)drv.size(),
                          (unsigned long)dir.size());
                exit(2);
            }; // if
        }
        else
        {
            log_error("ERROR: Getting executable path failed: "
                      "Splitting path `%s' to components failed: %s\n",
                      exe.c_str(), err_msg(rc).c_str());
            exit(2);
        }; // if
    }; // forever

#else // __MINGW32__

    // MinGW does not have the "secure" _splitpath_s, use the insecure version
    // instead.
    _splitpath(exe.c_str(), &drv.front(), &dir.front(),
               NULL, // We need neither name
               NULL // nor extension
    );
#endif // __MINGW32__

    // Combining components back to path.
    // I failed with "secure" `_makepath_s'. If buffer is too small, instead of
    // returning ERANGE, `_makepath_s' pops up dialog box and offers to debug
    // the program. D'oh! So let us try to guess the size of result and go with
    // insecure `_makepath'.
    buffer_t path(std::max(drv.size() + dir.size(), size_t(_MAX_PATH)) + 10);
    _makepath(&path.front(), &drv.front(), &dir.front(), NULL, NULL);

    return &path.front();

} // exe_dir


#endif // _WIN32


std::string err_msg(int err) { return _err_msg(err, 0); } // err_msg


// =================================================================================================
// C interface.
// =================================================================================================


char* get_err_msg(int err)
{
    char* msg = strdup(err_msg(err).c_str());
    CHECK_PTR(msg);
    return msg;
} // get_err_msg


char* get_dir_sep()
{
    char* sep = strdup(dir_sep().c_str());
    CHECK_PTR(sep);
    return sep;
} // get_dir_sep


char* get_exe_path()
{
    char* path = strdup(exe_path().c_str());
    CHECK_PTR(path);
    return path;
} // get_exe_path


char* get_exe_dir()
{
    char* dir = strdup(exe_dir().c_str());
    CHECK_PTR(dir);
    return dir;
} // get_exe_dir


// end of file //