/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-

 * vim: sw=2 ts=8 et :

 */

/* This Source Code Form is subject to the terms of the Mozilla Public

 * License, v. 2.0. If a copy of the MPL was not distributed with this

 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#include <unistd.h>

#include <sys/types.h>

#include <sys/wait.h>

#include <errno.h>

#include <sys/utsname.h>

#include "nsCRTGlue.h"

#include "nsExceptionHandler.h"

#include "nsICrashReporter.h"

#include "prenv.h"

#include "GfxInfoX11.h"

namespace mozilla {

namespace widget {

#ifdef DEBUG

NS_IMPL_ISUPPORTS_INHERITED(GfxInfo, GfxInfoBase, nsIGfxInfoDebug)

#endif

// these global variables will be set when firing the glxtest process

int glxtest_pipe = -1;

pid_t glxtest_pid = 0;

nsresult

GfxInfo::Init()

{

    mGLMajorVersion = 0;

    mMajorVersion = 0;

    mMinorVersion = 0;

    mRevisionVersion = 0;

    mIsMesa = false;

    mIsNVIDIA = false;

    mIsFGLRX = false;

    mIsNouveau = false;

    mIsIntel = false;

    mIsOldSwrast = false;

    mIsLlvmpipe = false;

    mHasTextureFromPixmap = false;

    return GfxInfoBase::Init();

}

void

GfxInfo::GetData()

{

    // to understand this function, see bug 639842. We retrieve the OpenGL driver information in a

    // separate process to protect against bad drivers.

    // if glxtest_pipe == -1, that means that we already read the information

    if (glxtest_pipe == -1)

        return;

    enum { buf_size = 1024 };

    char buf[buf_size];

    ssize_t bytesread = read(glxtest_pipe,

                             &buf,

                             buf_size-1); // -1 because we'll append a zero

    close(glxtest_pipe);

    glxtest_pipe = -1;

    // bytesread < 0 would mean that the above read() call failed.

    // This should never happen. If it did, the outcome would be to blacklist anyway.

    if (bytesread < 0)

        bytesread = 0;

    // let buf be a zero-terminated string

    buf[bytesread] = 0;

    // Wait for the glxtest process to finish. This serves 2 purposes:

    // * avoid having a zombie glxtest process laying around

    // * get the glxtest process status info.

    int glxtest_status = 0;

    bool wait_for_glxtest_process = true;

    bool waiting_for_glxtest_process_failed = false;

    int waitpid_errno = 0;

    while(wait_for_glxtest_process) {

        wait_for_glxtest_process = false;

        if (waitpid(glxtest_pid, &glxtest_status, 0) == -1) {

            waitpid_errno = errno;

            if (waitpid_errno == EINTR) {

                wait_for_glxtest_process = true;

            } else {

                // Bug 718629

                // ECHILD happens when the glxtest process got reaped got reaped after a PR_CreateProcess

                // as per bug 227246. This shouldn't matter, as we still seem to get the data

                // from the pipe, and if we didn't, the outcome would be to blacklist anyway.

                waiting_for_glxtest_process_failed = (waitpid_errno != ECHILD);

            }

        }

    }

    bool exited_with_error_code = !waiting_for_glxtest_process_failed &&

                                  WIFEXITED(glxtest_status) && 

                                  WEXITSTATUS(glxtest_status) != EXIT_SUCCESS;

    bool received_signal = !waiting_for_glxtest_process_failed &&

                           WIFSIGNALED(glxtest_status);

    bool error = waiting_for_glxtest_process_failed || exited_with_error_code || received_signal;

    nsCString textureFromPixmap; 

    nsCString *stringToFill = nullptr;

    char *bufptr = buf;

    if (!error) {

        while(true) {

            char *line = NS_strtok("\n", &bufptr);

            if (!line)

                break;

            if (stringToFill) {

                stringToFill->Assign(line);

                stringToFill = nullptr;

            }

            else if(!strcmp(line, "VENDOR"))

                stringToFill = &mVendor;

            else if(!strcmp(line, "RENDERER"))

                stringToFill = &mRenderer;

            else if(!strcmp(line, "VERSION"))

                stringToFill = &mVersion;

            else if(!strcmp(line, "TFP"))

                stringToFill = &textureFromPixmap;

        }

    }

    if (!strcmp(textureFromPixmap.get(), "TRUE"))

        mHasTextureFromPixmap = true;

    // only useful for Linux kernel version check for FGLRX driver.

    // assumes X client == X server, which is sad.

    struct utsname unameobj;

    if (uname(&unameobj) >= 0)

    {

      mOS.Assign(unameobj.sysname);

      mOSRelease.Assign(unameobj.release);

    }

    const char *spoofedVendor = PR_GetEnv("MOZ_GFX_SPOOF_GL_VENDOR");

    if (spoofedVendor)

        mVendor.Assign(spoofedVendor);

    const char *spoofedRenderer = PR_GetEnv("MOZ_GFX_SPOOF_GL_RENDERER");

    if (spoofedRenderer)

        mRenderer.Assign(spoofedRenderer);

    const char *spoofedVersion = PR_GetEnv("MOZ_GFX_SPOOF_GL_VERSION");

    if (spoofedVersion)

        mVersion.Assign(spoofedVersion);

    const char *spoofedOS = PR_GetEnv("MOZ_GFX_SPOOF_OS");

    if (spoofedOS)

        mOS.Assign(spoofedOS);

    const char *spoofedOSRelease = PR_GetEnv("MOZ_GFX_SPOOF_OS_RELEASE");

    if (spoofedOSRelease)

        mOSRelease.Assign(spoofedOSRelease);

    if (error ||

        mVendor.IsEmpty() ||

        mRenderer.IsEmpty() ||

        mVersion.IsEmpty() ||

        mOS.IsEmpty() ||

        mOSRelease.IsEmpty())

    {

        mAdapterDescription.AppendLiteral("GLXtest process failed");

        if (waiting_for_glxtest_process_failed)

            mAdapterDescription.AppendPrintf(" (waitpid failed with errno=%d for pid %d)", waitpid_errno, glxtest_pid);

        if (exited_with_error_code)

            mAdapterDescription.AppendPrintf(" (exited with status %d)", WEXITSTATUS(glxtest_status));

        if (received_signal)

            mAdapterDescription.AppendPrintf(" (received signal %d)", WTERMSIG(glxtest_status));

        if (bytesread) {

            mAdapterDescription.AppendLiteral(": ");

            mAdapterDescription.Append(nsDependentCString(buf));

            mAdapterDescription.Append('\n');

        }

        CrashReporter::AppendAppNotesToCrashReport(mAdapterDescription);

        return;

    }

    mAdapterDescription.Append(mVendor);

    mAdapterDescription.AppendLiteral(" -- ");

    mAdapterDescription.Append(mRenderer);

    nsAutoCString note;

    note.AppendLiteral("OpenGL: ");

    note.Append(mAdapterDescription);

    note.AppendLiteral(" -- ");

    note.Append(mVersion);

    if (mHasTextureFromPixmap)

        note.AppendLiteral(" -- texture_from_pixmap");

    note.Append('\n');

    CrashReporter::AppendAppNotesToCrashReport(note);

    // determine the major OpenGL version. That's the first integer in the version string.

    mGLMajorVersion = strtol(mVersion.get(), 0, 10);

    // determine driver type (vendor) and where in the version string

    // the actual driver version numbers should be expected to be found (whereToReadVersionNumbers)

    const char *whereToReadVersionNumbers = nullptr;

    const char *Mesa_in_version_string = strstr(mVersion.get(), "Mesa");

    if (Mesa_in_version_string) {

        mIsMesa = true;

        // with Mesa, the version string contains "Mesa major.minor" and that's all the version information we get:

        // there is no actual driver version info.

        whereToReadVersionNumbers = Mesa_in_version_string + strlen("Mesa");

        if (strcasestr(mVendor.get(), "nouveau"))

            mIsNouveau = true;

        if (strcasestr(mRenderer.get(), "intel")) // yes, intel is in the renderer string

            mIsIntel = true;

        if (strcasestr(mRenderer.get(), "llvmpipe"))

            mIsLlvmpipe = true;

        if (strcasestr(mRenderer.get(), "software rasterizer"))

            mIsOldSwrast = true;

    } else if (strstr(mVendor.get(), "NVIDIA Corporation")) {

        mIsNVIDIA = true;

        // with the NVIDIA driver, the version string contains "NVIDIA major.minor"

        // note that here the vendor and version strings behave differently, that's why we don't put this above

        // alongside Mesa_in_version_string.

        const char *NVIDIA_in_version_string = strstr(mVersion.get(), "NVIDIA");

        if (NVIDIA_in_version_string)

            whereToReadVersionNumbers = NVIDIA_in_version_string + strlen("NVIDIA");

    } else if (strstr(mVendor.get(), "ATI Technologies Inc")) {

        mIsFGLRX = true;

        // with the FGLRX driver, the version string only gives a OpenGL version :/ so let's return that.

        // that can at least give a rough idea of how old the driver is.

        whereToReadVersionNumbers = mVersion.get();

    }

    // read major.minor version numbers of the driver (not to be confused with the OpenGL version)

    if (whereToReadVersionNumbers) {

        // copy into writable buffer, for tokenization

        strncpy(buf, whereToReadVersionNumbers, buf_size);

        bufptr = buf;

        // now try to read major.minor version numbers. In case of failure, gracefully exit: these numbers have

        // been initialized as 0 anyways

        char *token = NS_strtok(".", &bufptr);

        if (token) {

            mMajorVersion = strtol(token, 0, 10);

            token = NS_strtok(".", &bufptr);

            if (token) {

                mMinorVersion = strtol(token, 0, 10);

                token = NS_strtok(".", &bufptr);

                if (token)

                    mRevisionVersion = strtol(token, 0, 10);

            }

        }

    }

}

static inline uint64_t version(uint32_t major, uint32_t minor, uint32_t revision = 0)

{

    return (uint64_t(major) << 32) + (uint64_t(minor) << 16) + uint64_t(revision);

}

const nsTArray<GfxDriverInfo>&

GfxInfo::GetGfxDriverInfo()

{

  // Nothing here yet.

  //if (!sDriverInfo->Length()) {

  //

  //}

  return *sDriverInfo;

}

nsresult

GfxInfo::GetFeatureStatusImpl(int32_t aFeature,

                              int32_t *aStatus,

                              nsAString & aSuggestedDriverVersion,

                              const nsTArray<GfxDriverInfo>& aDriverInfo,

                              nsACString& aFailureId,

                              OperatingSystem* aOS /* = nullptr */)

{

  NS_ENSURE_ARG_POINTER(aStatus);

  *aStatus = nsIGfxInfo::FEATURE_STATUS_UNKNOWN;

  aSuggestedDriverVersion.SetIsVoid(true);

  OperatingSystem os = OperatingSystem::Linux;

  if (aOS)

    *aOS = os;

  if (sShutdownOccurred) {

    return NS_OK;

  }

  GetData();

  if (mGLMajorVersion == 1) {

    // We're on OpenGL 1. In most cases that indicates really old hardware.

    // We better block them, rather than rely on them to fail gracefully, because they don't!

    // see bug 696636

    *aStatus = nsIGfxInfo::FEATURE_BLOCKED_DEVICE;

    aFailureId = "FEATURE_FAILURE_OPENGL_1";

    return NS_OK;

  }

  // Don't evaluate any special cases if we're checking the downloaded blocklist.

  if (!aDriverInfo.Length()) {

    // Blacklist software GL implementations from using layers acceleration.

    // On the test infrastructure, we'll force-enable layers acceleration.

    if (aFeature == nsIGfxInfo::FEATURE_OPENGL_LAYERS &&

        (mIsLlvmpipe || mIsOldSwrast) &&

        !PR_GetEnv("MOZ_LAYERS_ALLOW_SOFTWARE_GL"))

    {

      *aStatus = nsIGfxInfo::FEATURE_BLOCKED_DEVICE;

      aFailureId = "FEATURE_FAILURE_SOFTWARE_GL";

      return NS_OK;

    }

    if (aFeature == nsIGfxInfo::FEATURE_WEBRENDER) {

      *aStatus = nsIGfxInfo::FEATURE_BLOCKED_OS_VERSION;

      aFailureId = "FEATURE_UNQUALIFIED_WEBRENDER_LINUX";

      return NS_OK;

    }

    // Only check features relevant to Linux.

    if (aFeature == nsIGfxInfo::FEATURE_OPENGL_LAYERS ||

        aFeature == nsIGfxInfo::FEATURE_WEBGL_OPENGL ||

        aFeature == nsIGfxInfo::FEATURE_WEBGL2 ||

        aFeature == nsIGfxInfo::FEATURE_WEBGL_MSAA) {

      // whitelist the linux test slaves' current configuration.

      // this is necessary as they're still using the slightly outdated 190.42 driver.

      // this isn't a huge risk, as at least this is the exact setting in which we do continuous testing,

      // and this only affects GeForce 9400 cards on linux on this precise driver version, which is very few users.

      // We do the same thing on Windows XP, see in widget/windows/GfxInfo.cpp

      if (mIsNVIDIA &&

          !strcmp(mRenderer.get(), "GeForce 9400/PCI/SSE2") &&

          !strcmp(mVersion.get(), "3.2.0 NVIDIA 190.42"))

      {

        *aStatus = nsIGfxInfo::FEATURE_STATUS_OK;

        return NS_OK;

      }

      if (mIsMesa) {

        if (mIsNouveau && version(mMajorVersion, mMinorVersion) < version(8,0)) {

          *aStatus = nsIGfxInfo::FEATURE_BLOCKED_DRIVER_VERSION;

          aFailureId = "FEATURE_FAILURE_MESA_1";

          aSuggestedDriverVersion.AssignLiteral("Mesa 8.0");

        }

        else if (version(mMajorVersion, mMinorVersion, mRevisionVersion) < version(7,10,3)) {

          *aStatus = nsIGfxInfo::FEATURE_BLOCKED_DRIVER_VERSION;

          aFailureId = "FEATURE_FAILURE_MESA_2";

          aSuggestedDriverVersion.AssignLiteral("Mesa 7.10.3");

        }

        else if (mIsOldSwrast) {

          *aStatus = nsIGfxInfo::FEATURE_BLOCKED_DRIVER_VERSION;

          aFailureId = "FEATURE_FAILURE_SW_RAST";

        }

        else if (mIsLlvmpipe && version(mMajorVersion, mMinorVersion) < version(9, 1)) {

          // bug 791905, Mesa bug 57733, fixed in Mesa 9.1 according to

          // https://bugs.freedesktop.org/show_bug.cgi?id=57733#c3

          *aStatus = nsIGfxInfo::FEATURE_BLOCKED_DRIVER_VERSION;

          aFailureId = "FEATURE_FAILURE_MESA_3";

        }

        else if (aFeature == nsIGfxInfo::FEATURE_WEBGL_MSAA)

        {

          if (mIsIntel && version(mMajorVersion, mMinorVersion) < version(8,1)) {

            *aStatus = nsIGfxInfo::FEATURE_BLOCKED_DRIVER_VERSION;

            aFailureId = "FEATURE_FAILURE_MESA_4";

            aSuggestedDriverVersion.AssignLiteral("Mesa 8.1");

          }

        }

      } else if (mIsNVIDIA) {

        if (version(mMajorVersion, mMinorVersion, mRevisionVersion) < version(257,21)) {

          *aStatus = nsIGfxInfo::FEATURE_BLOCKED_DRIVER_VERSION;

          aFailureId = "FEATURE_FAILURE_OLD_NV";

          aSuggestedDriverVersion.AssignLiteral("NVIDIA 257.21");

        }

      } else if (mIsFGLRX) {

        // FGLRX does not report a driver version number, so we have the OpenGL version instead.

        // by requiring OpenGL 3, we effectively require recent drivers.

        if (version(mMajorVersion, mMinorVersion, mRevisionVersion) < version(3, 0)) {

          *aStatus = nsIGfxInfo::FEATURE_BLOCKED_DRIVER_VERSION;

          aFailureId = "FEATURE_FAILURE_OLD_FGLRX";

          aSuggestedDriverVersion.AssignLiteral("<Something recent>");

        }

        // Bug 724640: FGLRX + Linux 2.6.32 is a crashy combo

        bool unknownOS = mOS.IsEmpty() || mOSRelease.IsEmpty();

        bool badOS = mOS.Find("Linux", true) != -1 &&

                     mOSRelease.Find("2.6.32") != -1;

        if (unknownOS || badOS) {

          *aStatus = nsIGfxInfo::FEATURE_BLOCKED_OS_VERSION;

          aFailureId = "FEATURE_FAILURE_OLD_OS";

        }

      } else {

        // like on windows, let's block unknown vendors. Think of virtual machines.

        // Also, this case is hit whenever the GLXtest probe failed to get driver info or crashed.

        *aStatus = nsIGfxInfo::FEATURE_BLOCKED_DEVICE;

      }

    }

  }

  return GfxInfoBase::GetFeatureStatusImpl(aFeature, aStatus, aSuggestedDriverVersion, aDriverInfo, aFailureId, &os);

}

NS_IMETHODIMP

GfxInfo::GetD2DEnabled(bool *aEnabled)

{

  return NS_ERROR_FAILURE;

}

NS_IMETHODIMP

GfxInfo::GetDWriteEnabled(bool *aEnabled)

{

  return NS_ERROR_FAILURE;

}

NS_IMETHODIMP

GfxInfo::GetDWriteVersion(nsAString & aDwriteVersion)

{

  return NS_ERROR_FAILURE;

}

NS_IMETHODIMP

GfxInfo::GetCleartypeParameters(nsAString & aCleartypeParams)

{

  return NS_ERROR_FAILURE;

}

NS_IMETHODIMP

GfxInfo::GetAdapterDescription(nsAString & aAdapterDescription)

{

  GetData();

  AppendASCIItoUTF16(mAdapterDescription, aAdapterDescription);

  return NS_OK;

}

NS_IMETHODIMP

GfxInfo::GetAdapterDescription2(nsAString & aAdapterDescription)

{

  return NS_ERROR_FAILURE;

}

NS_IMETHODIMP

GfxInfo::GetAdapterRAM(nsAString & aAdapterRAM)

{

  aAdapterRAM.Truncate();

  return NS_OK;

}

NS_IMETHODIMP

GfxInfo::GetAdapterRAM2(nsAString & aAdapterRAM)

{

  return NS_ERROR_FAILURE;

}

NS_IMETHODIMP

GfxInfo::GetAdapterDriver(nsAString & aAdapterDriver)

{

  aAdapterDriver.Truncate();

  return NS_OK;

}

NS_IMETHODIMP

GfxInfo::GetAdapterDriver2(nsAString & aAdapterDriver)

{

  return NS_ERROR_FAILURE;

}

NS_IMETHODIMP

GfxInfo::GetAdapterDriverVersion(nsAString & aAdapterDriverVersion)

{

  GetData();

  CopyASCIItoUTF16(mVersion, aAdapterDriverVersion);

  return NS_OK;

}

NS_IMETHODIMP

GfxInfo::GetAdapterDriverVersion2(nsAString & aAdapterDriverVersion)

{

  return NS_ERROR_FAILURE;

}

NS_IMETHODIMP

GfxInfo::GetAdapterDriverDate(nsAString & aAdapterDriverDate)

{

  aAdapterDriverDate.Truncate();

  return NS_OK;

}

NS_IMETHODIMP

GfxInfo::GetAdapterDriverDate2(nsAString & aAdapterDriverDate)

{

  return NS_ERROR_FAILURE;

}

NS_IMETHODIMP

GfxInfo::GetAdapterVendorID(nsAString & aAdapterVendorID)

{

  GetData();

  CopyUTF8toUTF16(mVendor, aAdapterVendorID);

  return NS_OK;

}

NS_IMETHODIMP

GfxInfo::GetAdapterVendorID2(nsAString & aAdapterVendorID)

{

  return NS_ERROR_FAILURE;

}

NS_IMETHODIMP

GfxInfo::GetAdapterDeviceID(nsAString & aAdapterDeviceID)

{

  GetData();

  CopyUTF8toUTF16(mRenderer, aAdapterDeviceID);

  return NS_OK;

}

NS_IMETHODIMP

GfxInfo::GetAdapterDeviceID2(nsAString & aAdapterDeviceID)

{

  return NS_ERROR_FAILURE;

}

NS_IMETHODIMP

GfxInfo::GetAdapterSubsysID(nsAString & aAdapterSubsysID)

{

  return NS_ERROR_FAILURE;

}

NS_IMETHODIMP

GfxInfo::GetAdapterSubsysID2(nsAString & aAdapterSubsysID)

{

  return NS_ERROR_FAILURE;

}

NS_IMETHODIMP

GfxInfo::GetIsGPU2Active(bool* aIsGPU2Active)

{

  return NS_ERROR_FAILURE;

}

#ifdef DEBUG

// Implement nsIGfxInfoDebug

// We don't support spoofing anything on Linux

NS_IMETHODIMP GfxInfo::SpoofVendorID(const nsAString & aVendorID)

{

  CopyUTF16toUTF8(aVendorID, mVendor);

  return NS_OK;

}

NS_IMETHODIMP GfxInfo::SpoofDeviceID(const nsAString & aDeviceID)

{

  CopyUTF16toUTF8(aDeviceID, mRenderer);

  return NS_OK;

}

NS_IMETHODIMP GfxInfo::SpoofDriverVersion(const nsAString & aDriverVersion)

{

  CopyUTF16toUTF8(aDriverVersion, mVersion);

  return NS_OK;

}

NS_IMETHODIMP GfxInfo::SpoofOSVersion(uint32_t aVersion)

{

  // We don't support OS versioning on Linux. There's just "Linux".

  return NS_OK;

}

#endif

} // end namespace widget

} // end namespace mozilla