/**

 * WinPR: Windows Portable Runtime

 * Process Environment Functions

 *

 * Copyright 2012 Marc-Andre Moreau <marcandre.moreau@gmail.com>

 * Copyright 2013 Thincast Technologies GmbH

 * Copyright 2013 DI (FH) Martin Haimberger <martin.haimberger@thincast.com>

 *

 * 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 <winpr/config.h>

#include <winpr/crt.h>

#include <winpr/platform.h>

#include <winpr/error.h>

#include <winpr/file.h>

#include <winpr/string.h>

#include <winpr/wlog.h>

#include <winpr/environment.h>

#include "../log.h"

#define TAG WINPR_TAG("environment")

#ifndef _WIN32

#include <errno.h>

#ifdef WINPR_HAVE_UNISTD_H

#include <unistd.h>

#endif

#if defined(__IOS__)

#elif defined(__MACOSX__)

#include <crt_externs.h>

#define environ (*_NSGetEnviron())

#endif

DWORD GetCurrentDirectoryA(DWORD nBufferLength, LPSTR lpBuffer)

{

  size_t length = 0;

  char* cwd = nullptr;

  char* ccwd = nullptr;

  do

  {

    length += MAX_PATH;

    char* tmp = realloc(cwd, length);

    if (!tmp)

    {

      free(cwd);

      return 0;

    }

    cwd = tmp;

    ccwd = getcwd(cwd, length);

  } while (!ccwd && (errno == ERANGE));

  if (!ccwd)

  {

    free(cwd);

    return 0;

  }

  length = strnlen(cwd, length);

  if ((nBufferLength == 0) && (lpBuffer == nullptr))

  {

    free(cwd);

    return (DWORD)length;

  }

  else

  {

    if (lpBuffer == nullptr)

    {

      free(cwd);

      return 0;

    }

    if ((length + 1) > nBufferLength)

    {

      free(cwd);

      return (DWORD)(length + 1);

    }

    memcpy(lpBuffer, cwd, length + 1);

    free(cwd);

    return (DWORD)length;

  }

}

DWORD GetCurrentDirectoryW(WINPR_ATTR_UNUSED DWORD nBufferLength, WINPR_ATTR_UNUSED LPWSTR lpBuffer)

{

  WLog_ERR(TAG, "TODO: not implemented");

  return 0;

}

BOOL SetCurrentDirectoryA(WINPR_ATTR_UNUSED LPCSTR lpPathName)

{

  WLog_ERR(TAG, "TODO: not implemented");

  return TRUE;

}

BOOL SetCurrentDirectoryW(WINPR_ATTR_UNUSED LPCWSTR lpPathName)

{

  WLog_ERR(TAG, "TODO: not implemented");

  return TRUE;

}

DWORD SearchPathA(WINPR_ATTR_UNUSED LPCSTR lpPath, WINPR_ATTR_UNUSED LPCSTR lpFileName,

                  WINPR_ATTR_UNUSED LPCSTR lpExtension, WINPR_ATTR_UNUSED DWORD nBufferLength,

                  WINPR_ATTR_UNUSED LPSTR lpBuffer, WINPR_ATTR_UNUSED LPSTR* lpFilePart)

{

  WLog_ERR(TAG, "TODO: not implemented");

  return 0;

}

DWORD SearchPathW(WINPR_ATTR_UNUSED LPCWSTR lpPath, WINPR_ATTR_UNUSED LPCWSTR lpFileName,

                  WINPR_ATTR_UNUSED LPCWSTR lpExtension, WINPR_ATTR_UNUSED DWORD nBufferLength,

                  WINPR_ATTR_UNUSED LPWSTR lpBuffer, WINPR_ATTR_UNUSED LPWSTR* lpFilePart)

{

  WLog_ERR(TAG, "TODO: not implemented");

  return 0;

}

LPSTR GetCommandLineA(VOID)

{

  WLog_ERR(TAG, "TODO: not implemented");

  return nullptr;

}

LPWSTR GetCommandLineW(VOID)

{

  WLog_ERR(TAG, "TODO: not implemented");

  return nullptr;

}

BOOL NeedCurrentDirectoryForExePathA(WINPR_ATTR_UNUSED LPCSTR ExeName)

{

  WLog_ERR(TAG, "TODO: not implemented");

  return TRUE;

}

BOOL NeedCurrentDirectoryForExePathW(WINPR_ATTR_UNUSED LPCWSTR ExeName)

{

  WLog_ERR(TAG, "TODO: not implemented");

  return TRUE;

}

#endif

#if !defined(_WIN32) || defined(_UWP)

DWORD GetEnvironmentVariableA(LPCSTR lpName, LPSTR lpBuffer, DWORD nSize)

{

#if !defined(_UWP)

  size_t length = 0;

  // NOLINTNEXTLINE(concurrency-mt-unsafe)

  char* env = getenv(lpName);

  if (!env)

  {

    SetLastError(ERROR_ENVVAR_NOT_FOUND);

    return 0;

  }

  length = strlen(env);

  if ((length + 1 > nSize) || (!lpBuffer))

    return (DWORD)length + 1;

  CopyMemory(lpBuffer, env, length);

  lpBuffer[length] = '\0';

  return (DWORD)length;

#else

  SetLastError(ERROR_ENVVAR_NOT_FOUND);

  return 0;

#endif

}

DWORD GetEnvironmentVariableW(WINPR_ATTR_UNUSED LPCWSTR lpName, WINPR_ATTR_UNUSED LPWSTR lpBuffer,

                              WINPR_ATTR_UNUSED DWORD nSize)

{

  WLog_ERR(TAG, "TODO: not implemented");

  SetLastError(ERROR_ENVVAR_NOT_FOUND);

  return 0;

}

BOOL SetEnvironmentVariableA(LPCSTR lpName, LPCSTR lpValue)

{

#if !defined(_UWP)

  if (!lpName)

    return FALSE;

  if (lpValue)

  {

    // NOLINTNEXTLINE(concurrency-mt-unsafe)

    if (0 != setenv(lpName, lpValue, 1))

      return FALSE;

  }

  else

  {

    // NOLINTNEXTLINE(concurrency-mt-unsafe)

    if (0 != unsetenv(lpName))

      return FALSE;

  }

  return TRUE;

#else

  return FALSE;

#endif

}

BOOL SetEnvironmentVariableW(WINPR_ATTR_UNUSED LPCWSTR lpName, WINPR_ATTR_UNUSED LPCWSTR lpValue)

{

  WLog_ERR(TAG, "TODO: not implemented");

  return FALSE;

}

/**

 * GetEnvironmentStrings function:

 * http://msdn.microsoft.com/en-us/library/windows/desktop/ms683187/

 *

 * The GetEnvironmentStrings function returns a pointer to a block of memory

 * that contains the environment variables of the calling process (both the

 * system and the user environment variables). Each environment block contains

 * the environment variables in the following format:

 *

 * Var1=Value1\0

 * Var2=Value2\0

 * Var3=Value3\0

 * ...

 * VarN=ValueN\0\0

 */

extern char** environ;

WINPR_ATTR_MALLOC(FreeEnvironmentStringsA, 1)

static LPCH GetEnvironmentStringsAN(size_t* pLen)

{

#if !defined(_UWP)

  size_t offset = 0;

  char** envp = environ;

  const size_t blocksize = 128;

  size_t cchEnvironmentBlock = blocksize;

  LPCH lpszEnvironmentBlock = (LPCH)calloc(cchEnvironmentBlock, sizeof(CHAR));

  if (pLen)

    *pLen = 0;

  if (!lpszEnvironmentBlock)

    return nullptr;

  while (*envp)

  {

    const size_t length = strlen(*envp);

    const size_t required = offset + length + 8ull;

    if (required > UINT32_MAX)

    {

      WLog_ERR(TAG, "Environment block too large: %" PRIuz, required);

      free(lpszEnvironmentBlock);

      return nullptr;

    }

    if (required > cchEnvironmentBlock)

    {

      size_t new_size = cchEnvironmentBlock;

      do

      {

        new_size += blocksize;

      } while (new_size <= required);

      LPCH new_blk = (LPCH)realloc(lpszEnvironmentBlock, new_size * sizeof(CHAR));

      if (!new_blk)

      {

        free(lpszEnvironmentBlock);

        return nullptr;

      }

      const size_t diff = new_size - cchEnvironmentBlock;

      const size_t old = cchEnvironmentBlock;

      lpszEnvironmentBlock = new_blk;

      cchEnvironmentBlock = new_size;

      memset(&lpszEnvironmentBlock[old], 0, diff);

    }

    char* p = &(lpszEnvironmentBlock[offset]);

    CopyMemory(p, *envp, length * sizeof(CHAR));

    p[length] = '\0';

    offset += (length + 1ull);

    envp++;

  }

  lpszEnvironmentBlock[offset] = '\0';

  if (pLen)

    *pLen = cchEnvironmentBlock;

  return lpszEnvironmentBlock;

#else

  if (pLen)

    *pLen = 0;

  return nullptr;

#endif

}

LPCH GetEnvironmentStringsA(VOID)

{

  return GetEnvironmentStringsAN(nullptr);

}

LPWCH GetEnvironmentStringsW(VOID)

{

  size_t len = 0;

  LPCH env = GetEnvironmentStringsAN(&len);

  if (!env)

    return nullptr;

  LPWCH envW = ConvertMszUtf8NToWCharAlloc(env, len, nullptr);

  FreeEnvironmentStringsA(env);

  return envW;

}

BOOL SetEnvironmentStringsA(WINPR_ATTR_UNUSED LPCH NewEnvironment)

{

  WLog_ERR(TAG, "TODO: not implemented");

  return TRUE;

}

BOOL SetEnvironmentStringsW(WINPR_ATTR_UNUSED LPWCH NewEnvironment)

{

  WLog_ERR(TAG, "TODO: not implemented");

  return TRUE;

}

DWORD ExpandEnvironmentStringsA(WINPR_ATTR_UNUSED LPCSTR lpSrc, WINPR_ATTR_UNUSED LPSTR lpDst,

                                WINPR_ATTR_UNUSED DWORD nSize)

{

  WLog_ERR(TAG, "TODO: not implemented");

  return 0;

}

DWORD ExpandEnvironmentStringsW(WINPR_ATTR_UNUSED LPCWSTR lpSrc, WINPR_ATTR_UNUSED LPWSTR lpDst,

                                WINPR_ATTR_UNUSED DWORD nSize)

{

  WLog_ERR(TAG, "TODO: not implemented");

  return 0;

}

BOOL FreeEnvironmentStringsA(LPCH lpszEnvironmentBlock)

{

  free(lpszEnvironmentBlock);

  return TRUE;

}

BOOL FreeEnvironmentStringsW(LPWCH lpszEnvironmentBlock)

{

  free(lpszEnvironmentBlock);

  return TRUE;

}

#endif

LPCH MergeEnvironmentStrings(PCSTR original, PCSTR merge)

{

  const char* cp = nullptr;

  char* p = nullptr;

  size_t offset = 0;

  size_t length = 0;

  const char* envp = nullptr;

  DWORD cchEnvironmentBlock = 0;

  LPCH lpszEnvironmentBlock = nullptr;

  const char** mergeStrings = nullptr;

  size_t mergeStringLength = 0;

  size_t mergeArraySize = 128;

  size_t mergeLength = 0;

  size_t foundMerge = 0;

  char* foundEquals = nullptr;

  mergeStrings = (LPCSTR*)calloc(mergeArraySize, sizeof(char*));

  if (!mergeStrings)

    return nullptr;

  mergeStringLength = 0;

  cp = merge;

  while (*cp && *(cp + 1))

  {

    length = strlen(cp);

    if (mergeStringLength == mergeArraySize)

    {

      const char** new_str = nullptr;

      mergeArraySize += 128;

      new_str = (const char**)realloc((void*)mergeStrings, mergeArraySize * sizeof(char*));

      if (!new_str)

      {

        free((void*)mergeStrings);

        return nullptr;

      }

      mergeStrings = new_str;

    }

    mergeStrings[mergeStringLength] = cp;

    cp += length + 1;

    mergeStringLength++;

  }

  offset = 0;

  cchEnvironmentBlock = 128;

  lpszEnvironmentBlock = (LPCH)calloc(cchEnvironmentBlock, sizeof(CHAR));

  if (!lpszEnvironmentBlock)

  {

    free((void*)mergeStrings);

    return nullptr;

  }

  envp = original;

  while ((original != nullptr) && (*envp && *(envp + 1)))

  {

    size_t old_offset = offset;

    length = strlen(envp);

    while ((offset + length + 8) > cchEnvironmentBlock)

    {

      cchEnvironmentBlock *= 2;

      LPCH tmp = (LPCH)realloc(lpszEnvironmentBlock, cchEnvironmentBlock * sizeof(CHAR));

      if (!tmp)

      {

        free((void*)lpszEnvironmentBlock);

        free((void*)mergeStrings);

        return nullptr;

      }

      lpszEnvironmentBlock = tmp;

    }

    p = &(lpszEnvironmentBlock[offset]);

    // check if this value is in the mergeStrings

    foundMerge = 0;

    for (size_t run = 0; run < mergeStringLength; run++)

    {

      if (!mergeStrings[run])

        continue;

      mergeLength = strlen(mergeStrings[run]);

      foundEquals = strstr(mergeStrings[run], "=");

      if (!foundEquals)

        continue;

      const intptr_t len = foundEquals - mergeStrings[run] + 1;

      if (strncmp(envp, mergeStrings[run], WINPR_ASSERTING_INT_CAST(size_t, len)) == 0)

      {

        // found variable in merge list ... use this ....

        if (*(foundEquals + 1) == '\0')

        {

          // check if the argument is set ... if not remove variable ...

          foundMerge = 1;

        }

        else

        {

          while ((offset + mergeLength + 8) > cchEnvironmentBlock)

          {

            cchEnvironmentBlock *= 2;

            LPCH tmp =

                (LPCH)realloc(lpszEnvironmentBlock, cchEnvironmentBlock * sizeof(CHAR));

            if (!tmp)

            {

              free((void*)lpszEnvironmentBlock);

              free((void*)mergeStrings);

              return nullptr;

            }

            lpszEnvironmentBlock = tmp;

            p = &(lpszEnvironmentBlock[old_offset]);

          }

          foundMerge = 1;

          CopyMemory(p, mergeStrings[run], mergeLength);

          mergeStrings[run] = nullptr;

          p[mergeLength] = '\0';

          offset += (mergeLength + 1);

        }

      }

    }

    if (foundMerge == 0)

    {

      CopyMemory(p, envp, length * sizeof(CHAR));

      p[length] = '\0';

      offset += (length + 1);

    }

    envp += (length + 1);

  }

  // now merge the not already merged env

  for (size_t run = 0; run < mergeStringLength; run++)

  {

    if (!mergeStrings[run])

      continue;

    mergeLength = strlen(mergeStrings[run]);

    while ((offset + mergeLength + 8) > cchEnvironmentBlock)

    {

      cchEnvironmentBlock *= 2;

      LPCH tmp = (LPCH)realloc(lpszEnvironmentBlock, cchEnvironmentBlock * sizeof(CHAR));

      if (!tmp)

      {

        free((void*)lpszEnvironmentBlock);

        free((void*)mergeStrings);

        return nullptr;

      }

      lpszEnvironmentBlock = tmp;

    }

    p = &(lpszEnvironmentBlock[offset]);

    CopyMemory(p, mergeStrings[run], mergeLength);

    mergeStrings[run] = nullptr;

    p[mergeLength] = '\0';

    offset += (mergeLength + 1);

  }

  lpszEnvironmentBlock[offset] = '\0';

  free((void*)mergeStrings);

  return lpszEnvironmentBlock;

}

DWORD GetEnvironmentVariableEBA(LPCSTR envBlock, LPCSTR lpName, LPSTR lpBuffer, DWORD nSize)

{

  size_t vLength = 0;

  char* env = nullptr;

  char* foundEquals = nullptr;

  const char* penvb = envBlock;

  size_t nLength = 0;

  size_t fLength = 0;

  size_t lpNameLength = 0;

  if (!lpName || nullptr == envBlock)

    return 0;

  lpNameLength = strlen(lpName);

  if (lpNameLength < 1)

    return 0;

  while (*penvb && *(penvb + 1))

  {

    fLength = strlen(penvb);

    foundEquals = strstr(penvb, "=");

    if (!foundEquals)

    {

      /* if no = sign is found the envBlock is broken */

      return 0;

    }

    nLength = WINPR_ASSERTING_INT_CAST(size_t, (foundEquals - penvb));

    if (nLength != lpNameLength)

    {

      penvb += (fLength + 1);

      continue;

    }

    if (strncmp(penvb, lpName, nLength) == 0)

    {

      env = foundEquals + 1;

      break;

    }

    penvb += (fLength + 1);

  }

  if (!env)

    return 0;

  vLength = strlen(env);

  if (vLength >= UINT32_MAX)

    return 0;

  if ((vLength + 1 > nSize) || (!lpBuffer))

    return (DWORD)vLength + 1;

  CopyMemory(lpBuffer, env, vLength + 1);

  return (DWORD)vLength;

}

BOOL SetEnvironmentVariableEBA(LPSTR* envBlock, LPCSTR lpName, LPCSTR lpValue)

{

  size_t length = 0;

  char* envstr = nullptr;

  char* newEB = nullptr;

  if (!lpName)

    return FALSE;

  if (lpValue)

  {

    length = (strlen(lpName) + strlen(lpValue) + 2); /* +2 because of = and \0 */

    envstr = (char*)malloc(length + 1);              /* +1 because of closing \0 */

    if (!envstr)

      return FALSE;

    (void)sprintf_s(envstr, length, "%s=%s", lpName, lpValue);

  }

  else

  {

    length = strlen(lpName) + 2;        /* +2 because of = and \0 */

    envstr = (char*)malloc(length + 1); /* +1 because of closing \0 */

    if (!envstr)

      return FALSE;

    (void)sprintf_s(envstr, length, "%s=", lpName);

  }

  envstr[length] = '\0';

  newEB = MergeEnvironmentStrings((LPCSTR)*envBlock, envstr);

  free(envstr);

  free(*envBlock);

  *envBlock = newEB;

  return TRUE;

}

char** EnvironmentBlockToEnvpA(LPCH lpszEnvironmentBlock)

{

  char* p = nullptr;

  SSIZE_T index = 0;

  size_t count = 0;

  size_t length = 0;

  char** envp = nullptr;

  count = 0;

  if (!lpszEnvironmentBlock)

    return nullptr;

  p = (char*)lpszEnvironmentBlock;

  while (p[0] && p[1])

  {

    length = strlen(p);

    p += (length + 1);

    count++;

  }

  index = 0;

  p = (char*)lpszEnvironmentBlock;

  envp = (char**)calloc(count + 1, sizeof(char*));

  if (!envp)

    return nullptr;

  envp[count] = nullptr;

  while (p[0] && p[1])

  {

    length = strlen(p);

    envp[index] = _strdup(p);

    if (!envp[index])

    {

      for (index -= 1; index >= 0; --index)

      {

        free(envp[index]);

      }

      free((void*)envp);

      return nullptr;

    }

    p += (length + 1);

    index++;

  }

  return envp;

}

#ifdef _WIN32

// https://devblogs.microsoft.com/oldnewthing/20100203-00/?p=15083

#define WINPR_MAX_ENVIRONMENT_LENGTH 2048

DWORD GetEnvironmentVariableX(const char* lpName, char* lpBuffer, DWORD nSize)

{

  DWORD result = 0;

  DWORD nSizeW = 0;

  LPWSTR lpNameW = nullptr;

  LPWSTR lpBufferW = nullptr;

  LPSTR lpBufferA = lpBuffer;

  lpNameW = ConvertUtf8ToWCharAlloc(lpName, nullptr);

  if (!lpNameW)

    goto cleanup;

  if (!lpBuffer)

  {

    char lpBufferMaxA[WINPR_MAX_ENVIRONMENT_LENGTH] = WINPR_C_ARRAY_INIT;

    WCHAR lpBufferMaxW[WINPR_MAX_ENVIRONMENT_LENGTH] = WINPR_C_ARRAY_INIT;

    LPSTR lpTmpBuffer = lpBufferMaxA;

    nSizeW = ARRAYSIZE(lpBufferMaxW);

    result = GetEnvironmentVariableW(lpNameW, lpBufferMaxW, nSizeW);

    SSIZE_T rc =

        ConvertWCharNToUtf8(lpBufferMaxW, nSizeW, lpTmpBuffer, ARRAYSIZE(lpBufferMaxA));

    if ((rc < 0) || (rc >= UINT32_MAX))

      goto cleanup;

    result = (DWORD)rc + 1;

  }

  else

  {

    nSizeW = nSize;

    lpBufferW = calloc(nSizeW + 1, sizeof(WCHAR));

    if (!lpBufferW)

      goto cleanup;

    result = GetEnvironmentVariableW(lpNameW, lpBufferW, nSizeW);

    if (result == 0)

      goto cleanup;

    SSIZE_T rc = ConvertWCharNToUtf8(lpBufferW, nSizeW, lpBufferA, nSize);

    if ((rc < 0) || (rc > UINT32_MAX))

      goto cleanup;

    result = (DWORD)rc;

  }

cleanup:

  free(lpBufferW);

  free(lpNameW);

  return result;

}

#else

DWORD GetEnvironmentVariableX(const char* lpName, char* lpBuffer, DWORD nSize)

{

  return GetEnvironmentVariableA(lpName, lpBuffer, nSize);

}

#endif