path/shell.c

 
#include <winpr/config.h>
#include <winpr/build-config.h>
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
 
#include <winpr/crt.h>
#include <winpr/platform.h>
#include <winpr/file.h>
#include <winpr/tchar.h>
#include <winpr/environment.h>
 
#include <winpr/path.h>
#include <winpr/wlog.h>
 
#include "../file/file.h"
 
#include "../log.h"
#define TAG WINPR_TAG("path.shell")
 
#if defined(__IOS__)
#include "shell_ios.h"
#endif
 
#if defined(WIN32)
#include <windows.h>
#include <shlobj.h>
#include <shlwapi.h>
#else
#include <errno.h>
#include <dirent.h>
#endif
 
static char* GetPath_XDG_CONFIG_HOME(void);
static char* GetPath_XDG_RUNTIME_DIR(void);
 
#if defined(WIN32) && !defined(_UWP)
 
static char* win_get_known_folder(REFKNOWNFOLDERID id, BOOL currentUser)
{
  WCHAR* wpath = nullptr;
  HANDLE handle = currentUser ? nullptr : (HANDLE)-1;
  if (FAILED(SHGetKnownFolderPath(id, 0, handle, &wpath)))
    return nullptr;
 
  if (!wpath)
    return nullptr;
 
  char* path = ConvertWCharToUtf8Alloc(wpath, nullptr);
  CoTaskMemFree(wpath);
  return path;
}
#endif
 
char* GetEnvAlloc(LPCSTR lpName)
{
  DWORD nSize = 0;
  DWORD nStatus = 0;
  char* env = nullptr;
 
  nSize = GetEnvironmentVariableX(lpName, nullptr, 0);
 
  if (nSize > 0)
  {
    env = malloc(nSize);
 
    if (!env)
      return nullptr;
 
    nStatus = GetEnvironmentVariableX(lpName, env, nSize);
 
    if (nStatus != (nSize - 1))
    {
      free(env);
      return nullptr;
    }
  }
 
  return env;
}
 
static char* GetPath_HOME(void)
{
  char* path = nullptr;
#ifdef _WIN32
  path = GetEnvAlloc("UserProfile");
#elif defined(__IOS__)
  path = ios_get_home();
#else
  path = GetEnvAlloc("HOME");
#endif
  return path;
}
 
static char* GetPath_TEMP(void)
{
  char* path = nullptr;
#ifdef _WIN32
  path = GetEnvAlloc("TEMP");
#elif defined(__IOS__)
  path = ios_get_temp();
#else
  path = GetEnvAlloc("TMPDIR");
 
  if (!path)
    path = _strdup("/tmp");
 
#endif
  return path;
}
 
static char* GetPath_XDG_DATA_HOME(void)
{
  char* path = nullptr;
#if defined(WIN32) || defined(__IOS__)
  path = GetPath_XDG_CONFIG_HOME();
#else
  size_t size = 0;
  char* home = nullptr;
  path = GetEnvAlloc("XDG_DATA_HOME");
 
  if (path)
    return path;
 
  home = GetPath_HOME();
 
  if (!home)
    return nullptr;
 
  size = strlen(home) + strlen("/.local/share") + 1;
  path = (char*)malloc(size);
 
  if (!path)
  {
    free(home);
    return nullptr;
  }
 
  (void)sprintf_s(path, size, "%s%s", home, "/.local/share");
  free(home);
#endif
  return path;
}
 
static char* GetPath_XDG_CONFIG_HOME(void)
{
  char* path = nullptr;
#if defined(WIN32) && !defined(_UWP)
 
  path = win_get_known_folder(&FOLDERID_RoamingAppData, TRUE);
 
#elif defined(__IOS__)
  path = ios_get_data();
#else
  size_t size = 0;
  char* home = nullptr;
  path = GetEnvAlloc("XDG_CONFIG_HOME");
 
  if (path)
    return path;
 
  home = GetPath_HOME();
 
  if (!home)
    home = GetPath_TEMP();
 
  if (!home)
    return nullptr;
 
  size = strlen(home) + strlen("/.config") + 1;
  path = (char*)malloc(size);
 
  if (!path)
  {
    free(home);
    return nullptr;
  }
 
  (void)sprintf_s(path, size, "%s%s", home, "/.config");
  free(home);
#endif
  return path;
}
 
static char* GetPath_SYSTEM_CONFIG_HOME(void)
{
  char* path = nullptr;
#if defined(WIN32) && !defined(_UWP)
 
  path = win_get_known_folder(&FOLDERID_ProgramData, FALSE);
 
#elif defined(__IOS__)
  path = ios_get_data();
#else
  path = _strdup(WINPR_INSTALL_SYSCONFDIR);
#endif
  return path;
}
 
static char* GetPath_XDG_CACHE_HOME(void)
{
  char* path = nullptr;
#if defined(WIN32)
  {
    char* home = GetPath_XDG_RUNTIME_DIR();
 
    if (home)
    {
      path = GetCombinedPath(home, "cache");
 
      if (!winpr_PathFileExists(path))
        if (!winpr_PathMakePath(path, nullptr))
          path = nullptr;
    }
 
    free(home);
  }
#elif defined(__IOS__)
  path = ios_get_cache();
#else
  size_t size = 0;
  path = GetEnvAlloc("XDG_CACHE_HOME");
 
  if (path)
    return path;
 
  char* home = GetPath_HOME();
 
  if (!home)
    return nullptr;
 
  size = strlen(home) + strlen("/.cache") + 1;
  path = (char*)malloc(size);
 
  if (!path)
  {
    free(home);
    return nullptr;
  }
 
  (void)sprintf_s(path, size, "%s%s", home, "/.cache");
  free(home);
#endif
  return path;
}
 
char* GetPath_XDG_RUNTIME_DIR(void)
{
  char* path = nullptr;
#if defined(WIN32) && !defined(_UWP)
 
  path = win_get_known_folder(&FOLDERID_LocalAppData, TRUE);
 
#else
  path = GetEnvAlloc("XDG_RUNTIME_DIR");
#endif
 
  if (path)
    return path;
 
  path = GetPath_TEMP();
  return path;
}
 
char* GetKnownPath(eKnownPathTypes id)
{
  char* path = nullptr;
 
  switch (id)
  {
    case KNOWN_PATH_HOME:
      path = GetPath_HOME();
      break;
 
    case KNOWN_PATH_TEMP:
      path = GetPath_TEMP();
      break;
 
    case KNOWN_PATH_XDG_DATA_HOME:
      path = GetPath_XDG_DATA_HOME();
      break;
 
    case KNOWN_PATH_XDG_CONFIG_HOME:
      path = GetPath_XDG_CONFIG_HOME();
      break;
 
    case KNOWN_PATH_XDG_CACHE_HOME:
      path = GetPath_XDG_CACHE_HOME();
      break;
 
    case KNOWN_PATH_XDG_RUNTIME_DIR:
      path = GetPath_XDG_RUNTIME_DIR();
      break;
 
    case KNOWN_PATH_SYSTEM_CONFIG_HOME:
      path = GetPath_SYSTEM_CONFIG_HOME();
      break;
 
    default:
      path = nullptr;
      break;
  }
 
  if (!path)
    WLog_WARN(TAG, "Path %s is nullptr",
              GetKnownPathIdString(WINPR_ASSERTING_INT_CAST(int, id)));
  return path;
}
 
char* GetKnownSubPath(eKnownPathTypes id, const char* path)
{
  if (!path)
    return GetKnownSubPathV(id, "%s", "");
  return GetKnownSubPathV(id, "%s", path);
}
 
char* GetKnownSubPathV(eKnownPathTypes id, const char* path, ...)
{
  va_list ap = WINPR_C_ARRAY_INIT;
 
  va_start(ap, path);
  char* str = GetKnownSubPathVA(id, path, ap);
  va_end(ap);
  return str;
}
 
char* GetKnownSubPathVA(eKnownPathTypes id, const char* path, va_list ap)
{
  char* knownPath = GetKnownPath(id);
  if (!knownPath)
    return nullptr;
 
  char* subPath = GetCombinedPathVA(knownPath, path, ap);
  free(knownPath);
  return subPath;
}
 
char* GetEnvironmentPath(char* name)
{
  char* env = nullptr;
  DWORD nSize = 0;
  DWORD nStatus = 0;
  nSize = GetEnvironmentVariableX(name, nullptr, 0);
 
  if (nSize)
  {
    env = (LPSTR)malloc(nSize);
 
    if (!env)
      return nullptr;
 
    nStatus = GetEnvironmentVariableX(name, env, nSize);
 
    if (nStatus != (nSize - 1))
    {
      free(env);
      return nullptr;
    }
  }
 
  return env;
}
 
char* GetEnvironmentSubPath(char* name, const char* path)
{
  if (!path)
    return GetEnvironmentSubPathV(name, "%s", "");
  return GetEnvironmentSubPathV(name, "%s", path);
}
 
char* GetEnvironmentSubPathV(char* name, const char* path, ...)
{
  va_list ap = WINPR_C_ARRAY_INIT;
  va_start(ap, path);
  char* str = GetEnvironmentSubPathVA(name, path, ap);
  va_end(ap);
  return str;
}
 
char* GetEnvironmentSubPathVA(char* name, WINPR_FORMAT_ARG const char* path, va_list ap)
{
  char* env = GetEnvironmentPath(name);
 
  if (!env)
    return nullptr;
 
  char* subpath = GetCombinedPathVA(env, path, ap);
  free(env);
  return subpath;
}
 
char* GetCombinedPath(const char* basePath, const char* subPathFmt)
{
  if (!subPathFmt)
    return GetCombinedPathV(basePath, "%s", "");
  return GetCombinedPathV(basePath, "%s", subPathFmt);
}
 
char* GetCombinedPathV(const char* basePath, const char* subPathFmt, ...)
{
  va_list ap = WINPR_C_ARRAY_INIT;
 
  va_start(ap, subPathFmt);
  char* str = GetCombinedPathVA(basePath, subPathFmt, ap);
  va_end(ap);
  return str;
}
 
char* GetCombinedPathVA(const char* basePath, WINPR_FORMAT_ARG const char* subPathFmt, va_list ap)
{
  HRESULT status = 0;
  char* subPathCpy = nullptr;
  size_t basePathLength = 0;
  size_t subPathLength = 0;
 
  if (basePath)
    basePathLength = strlen(basePath);
 
  bool haveSubPath = subPathFmt && (*subPathFmt != '\0');
  if (haveSubPath)
  {
    const int rc = winpr_vasprintf(&subPathCpy, &subPathLength, subPathFmt, ap);
    if (rc < 0)
      return nullptr;
    if (rc == 0)
    {
      free(subPathCpy);
      subPathCpy = nullptr;
      subPathLength = 0;
      haveSubPath = false;
    }
  }
 
  const size_t length = basePathLength + subPathLength + 1;
  char* path = (char*)calloc(1, length + 1);
 
  if (!path)
    goto fail;
 
  if (basePath)
    CopyMemory(path, basePath, basePathLength);
 
  if (FAILED(PathCchConvertStyleA(path, basePathLength, PATH_STYLE_NATIVE)))
    goto fail;
 
  if (!haveSubPath)
    return path;
 
  if (!subPathCpy)
    goto fail;
 
  if (FAILED(PathCchConvertStyleA(subPathCpy, subPathLength, PATH_STYLE_NATIVE)))
    goto fail;
 
  status = NativePathCchAppendA(path, length + 1, subPathCpy);
  if (FAILED(status))
    goto fail;
 
  free(subPathCpy);
  return path;
 
fail:
  free(path);
  free(subPathCpy);
  return nullptr;
}
 
BOOL PathMakePathA(LPCSTR path, WINPR_ATTR_UNUSED LPSECURITY_ATTRIBUTES lpAttributes)
{
#if defined(_UWP)
  return FALSE;
#elif defined(_WIN32)
  return (SHCreateDirectoryExA(nullptr, path, lpAttributes) == ERROR_SUCCESS);
#else
  const char delim = PathGetSeparatorA(PATH_STYLE_NATIVE);
  char* dup = nullptr;
  BOOL result = TRUE;
  /* we only operate on a non-null, absolute path */
#if defined(__OS2__)
 
  if (!path)
    return FALSE;
 
#else
 
  if (!path || *path != delim)
    return FALSE;
 
#endif
 
  if (!(dup = _strdup(path)))
    return FALSE;
 
#ifdef __OS2__
  p = (strlen(dup) > 3) && (dup[1] == ':') && (dup[2] == delim)) ? &dup[3] : dup;
 
  while (p)
#else
  for (char* p = dup; p;)
#endif
  {
    if ((p = strchr(p + 1, delim)))
      *p = '\0';
 
    if (mkdir(dup, 0777) != 0)
      if (errno != EEXIST)
      {
        result = FALSE;
        break;
      }
 
    if (p)
      *p = delim;
  }
 
  free(dup);
  return (result);
#endif
}
 
BOOL PathMakePathW(LPCWSTR path, WINPR_ATTR_UNUSED LPSECURITY_ATTRIBUTES lpAttributes)
{
#if defined(_UWP)
  return FALSE;
#elif defined(_WIN32)
  return (SHCreateDirectoryExW(nullptr, path, lpAttributes) == ERROR_SUCCESS);
#else
  const WCHAR wdelim = PathGetSeparatorW(PATH_STYLE_NATIVE);
  const char delim = PathGetSeparatorA(PATH_STYLE_NATIVE);
  char* dup = nullptr;
  BOOL result = TRUE;
  /* we only operate on a non-null, absolute path */
#if defined(__OS2__)
 
  if (!path)
    return FALSE;
 
#else
 
  if (!path || *path != wdelim)
    return FALSE;
 
#endif
 
  dup = ConvertWCharToUtf8Alloc(path, nullptr);
  if (!dup)
    return FALSE;
 
#ifdef __OS2__
  p = (strlen(dup) > 3) && (dup[1] == ':') && (dup[2] == delim)) ? &dup[3] : dup;
 
  while (p)
#else
  for (char* p = dup; p;)
#endif
  {
    if ((p = strchr(p + 1, delim)))
      *p = '\0';
 
    if (mkdir(dup, 0777) != 0)
      if (errno != EEXIST)
      {
        result = FALSE;
        break;
      }
 
    if (p)
      *p = delim;
  }
 
  free(dup);
  return (result);
#endif
}
 
#if !defined(_WIN32) || defined(_UWP)
 
BOOL PathIsRelativeA(LPCSTR pszPath)
{
  if (!pszPath)
    return FALSE;
 
  return pszPath[0] != '/';
}
 
BOOL PathIsRelativeW(LPCWSTR pszPath)
{
  LPSTR lpFileNameA = nullptr;
  BOOL ret = FALSE;
 
  if (!pszPath)
    goto fail;
 
  lpFileNameA = ConvertWCharToUtf8Alloc(pszPath, nullptr);
  if (!lpFileNameA)
    goto fail;
  ret = PathIsRelativeA(lpFileNameA);
fail:
  free(lpFileNameA);
  return ret;
}
 
BOOL PathFileExistsA(LPCSTR pszPath)
{
  struct stat stat_info = WINPR_C_ARRAY_INIT;
 
  return (stat(pszPath, &stat_info) == 0);
}
 
BOOL PathFileExistsW(LPCWSTR pszPath)
{
  LPSTR lpFileNameA = nullptr;
  BOOL ret = FALSE;
 
  if (!pszPath)
    goto fail;
  lpFileNameA = ConvertWCharToUtf8Alloc(pszPath, nullptr);
  if (!lpFileNameA)
    goto fail;
 
  ret = winpr_PathFileExists(lpFileNameA);
fail:
  free(lpFileNameA);
  return ret;
}
 
BOOL PathIsDirectoryEmptyA(LPCSTR pszPath)
{
  struct dirent* dp = nullptr;
  int empty = 1;
  DIR* dir = opendir(pszPath);
 
  if (dir == nullptr) /* Not a directory or doesn't exist */
    return 1;
 
  // NOLINTNEXTLINE(concurrency-mt-unsafe)
  while ((dp = readdir(dir)) != nullptr)
  {
    if (strcmp(dp->d_name, ".") == 0 || strcmp(dp->d_name, "..") == 0)
      continue; /* Skip . and .. */
 
    empty = 0;
    break;
  }
 
  closedir(dir);
  return empty;
}
 
BOOL PathIsDirectoryEmptyW(LPCWSTR pszPath)
{
  LPSTR lpFileNameA = nullptr;
  BOOL ret = FALSE;
  if (!pszPath)
    goto fail;
  lpFileNameA = ConvertWCharToUtf8Alloc(pszPath, nullptr);
  if (!lpFileNameA)
    goto fail;
  ret = PathIsDirectoryEmptyA(lpFileNameA);
fail:
  free(lpFileNameA);
  return ret;
}
 
#endif
 
BOOL winpr_MoveFile(LPCSTR lpExistingFileName, LPCSTR lpNewFileName)
{
  return winpr_MoveFileEx(lpExistingFileName, lpNewFileName, 0);
}
 
BOOL winpr_MoveFileEx(LPCSTR lpExistingFileName, LPCSTR lpNewFileName, DWORD dwFlags)
{
#ifndef _WIN32
  struct stat st;
  int ret = 0;
  ret = stat(lpNewFileName, &st);
 
  if ((dwFlags & MOVEFILE_REPLACE_EXISTING) == 0)
  {
    if (ret == 0)
    {
      SetLastError(ERROR_ALREADY_EXISTS);
      return FALSE;
    }
  }
  else
  {
    if (ret == 0 && (st.st_mode & S_IWUSR) == 0)
    {
      SetLastError(ERROR_ACCESS_DENIED);
      return FALSE;
    }
  }
 
  ret = rename(lpExistingFileName, lpNewFileName);
 
  if (ret != 0)
    SetLastError(map_posix_err(errno));
 
  return ret == 0;
#else
  BOOL result = FALSE;
  LPWSTR lpExistingFileNameW = nullptr;
  LPWSTR lpNewFileNameW = nullptr;
 
  if (!lpExistingFileName || !lpNewFileName)
    return FALSE;
 
  lpExistingFileNameW = ConvertUtf8ToWCharAlloc(lpExistingFileName, nullptr);
  if (!lpExistingFileNameW)
    goto cleanup;
  lpNewFileNameW = ConvertUtf8ToWCharAlloc(lpNewFileName, nullptr);
  if (!lpNewFileNameW)
    goto cleanup;
 
  result = MoveFileExW(lpExistingFileNameW, lpNewFileNameW, dwFlags);
 
cleanup:
  free(lpExistingFileNameW);
  free(lpNewFileNameW);
  return result;
#endif
}
 
BOOL winpr_DeleteFile(const char* lpFileName)
{
#ifndef _WIN32
  if (!lpFileName)
    return FALSE;
 
  const int status = unlink(lpFileName);
  return (status != -1);
#else
  LPWSTR lpFileNameW = nullptr;
  BOOL result = FALSE;
 
  if (lpFileName)
    lpFileNameW = ConvertUtf8ToWCharAlloc(lpFileName, nullptr);
 
  if (!lpFileNameW)
    goto cleanup;
 
  result = DeleteFileW(lpFileNameW);
 
cleanup:
  free(lpFileNameW);
  return result;
#endif
}
 
BOOL winpr_RemoveDirectory(LPCSTR lpPathName)
{
#ifndef _WIN32
  int ret = rmdir(lpPathName);
 
  if (ret != 0)
    SetLastError(map_posix_err(errno));
  else
    SetLastError(STATUS_SUCCESS);
 
  return ret == 0;
#else
  LPWSTR lpPathNameW = nullptr;
  BOOL result = FALSE;
 
  if (lpPathName)
    lpPathNameW = ConvertUtf8ToWCharAlloc(lpPathName, nullptr);
 
  if (!lpPathNameW)
    goto cleanup;
 
  result = RemoveDirectoryW(lpPathNameW);
 
cleanup:
  free(lpPathNameW);
  return result;
#endif
}
 
BOOL winpr_PathFileExists(const char* pszPath)
{
  if (!pszPath)
    return FALSE;
#ifndef _WIN32
  return PathFileExistsA(pszPath);
#else
  WCHAR* pathW = ConvertUtf8ToWCharAlloc(pszPath, nullptr);
  BOOL result = FALSE;
 
  if (!pathW)
    return FALSE;
 
  result = PathFileExistsW(pathW);
  free(pathW);
 
  return result;
#endif
}
 
BOOL winpr_PathMakePath(const char* path, LPSECURITY_ATTRIBUTES lpAttributes)
{
  if (!path)
    return FALSE;
#ifndef _WIN32
  return PathMakePathA(path, lpAttributes);
#else
  WCHAR* pathW = ConvertUtf8ToWCharAlloc(path, nullptr);
  BOOL result = FALSE;
 
  if (!pathW)
    return FALSE;
 
  result = SHCreateDirectoryExW(nullptr, pathW, lpAttributes) == ERROR_SUCCESS;
  free(pathW);
 
  return result;
#endif
}