/**

 * WinPR: Windows Portable Runtime

 * Path Functions

 *

 * Copyright 2012 Marc-Andre Moreau <marcandre.moreau@gmail.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/version.h>

#include <winpr/build-config.h>

#include <winpr/crt.h>

#include <winpr/tchar.h>

#include <winpr/path.h>

#include <winpr/file.h>

#include "../utils.h"

#include "path.h"

#if defined(WITH_CWALK)

#include <cwalk.h>

#endif

#ifndef PATHCCH_MAX_CCH

#define PATHCCH_MAX_CCH 0x8000

#endif

static const char PATH_SLASH_CHR = '/';

static const char PATH_SLASH_STR[] = "/";

static const char PATH_BACKSLASH_CHR = '\\';

#ifdef _WIN32

static const char PATH_BACKSLASH_STR[] = "\\";

static const WCHAR PATH_BACKSLASH_STR_W[] = L"\\";

static const WCHAR PATH_SLASH_CHR_W = L'/';

static const WCHAR PATH_BACKSLASH_CHR_W = L'\\';

static const WCHAR PATH_SLASH_STR_W[] = L"/";

#else

#if defined(__BIG_ENDIAN__)

static const WCHAR PATH_SLASH_CHR_W = 0x2f00;

static const WCHAR PATH_BACKSLASH_CHR_W = 0x5c00;

static const WCHAR PATH_SLASH_STR_W[] = { 0x2f00, '\0' };

#else

static const WCHAR PATH_SLASH_CHR_W = '/';

static const WCHAR PATH_BACKSLASH_CHR_W = '\\';

static const WCHAR PATH_SLASH_STR_W[] = { '/', '\0' };

#endif

#if !defined(WITHOUT_WINPR_3x_DEPRECATED)

#if defined(__BIG_ENDIAN__)

static const WCHAR PATH_BACKSLASH_STR_W[] = { 0x5c00, '\0' };

#else

static const WCHAR PATH_BACKSLASH_STR_W[] = { '\\', '\0' };

#endif

static const char PATH_BACKSLASH_STR[] = "\\";

#endif

#endif

#ifdef _WIN32

#define PATH_SEPARATOR_CHR PATH_BACKSLASH_CHR

#define PATH_SEPARATOR_STR PATH_BACKSLASH_STR

#define PATH_SEPARATOR_CHR_W PATH_BACKSLASH_CHR_W

#define PATH_SEPARATOR_STR_W PATH_BACKSLASH_STR_W

#else

#define PATH_SEPARATOR_CHR PATH_SLASH_CHR

#define PATH_SEPARATOR_STR PATH_SLASH_STR

#define PATH_SEPARATOR_CHR_W PATH_SLASH_CHR_W

#define PATH_SEPARATOR_STR_W PATH_SLASH_STR_W

#endif

#if !defined(WITHOUT_WINPR_3x_DEPRECATED)

#include "../log.h"

#define TAG WINPR_TAG("path")

#endif

#if !defined(WITHOUT_WINPR_3x_DEPRECATED)

/*

 * PathCchAddBackslash

 */

/* Windows-style Paths */

#define DEFINE_UNICODE FALSE

#define CUR_PATH_SEPARATOR_CHR PATH_BACKSLASH_CHR

#define PATH_CCH_ADD_SEPARATOR PathCchAddBackslashA

#include "include/PathCchAddSeparator.h"

#undef DEFINE_UNICODE

#undef CUR_PATH_SEPARATOR_CHR

#undef PATH_CCH_ADD_SEPARATOR

#define DEFINE_UNICODE TRUE

#define CUR_PATH_SEPARATOR_CHR PATH_BACKSLASH_CHR_W

#define PATH_CCH_ADD_SEPARATOR PathCchAddBackslashW

#include "include/PathCchAddSeparator.h"

#undef DEFINE_UNICODE

#undef CUR_PATH_SEPARATOR_CHR

#undef PATH_CCH_ADD_SEPARATOR

/* Unix-style Paths */

#define DEFINE_UNICODE FALSE

#define CUR_PATH_SEPARATOR_CHR PATH_SLASH_CHR

#define PATH_CCH_ADD_SEPARATOR PathCchAddSlashA

#include "include/PathCchAddSeparator.h"

#undef DEFINE_UNICODE

#undef CUR_PATH_SEPARATOR_CHR

#undef PATH_CCH_ADD_SEPARATOR

#define DEFINE_UNICODE TRUE

#define CUR_PATH_SEPARATOR_CHR PATH_SLASH_CHR_W

#define PATH_CCH_ADD_SEPARATOR PathCchAddSlashW

#include "include/PathCchAddSeparator.h"

#undef DEFINE_UNICODE

#undef CUR_PATH_SEPARATOR_CHR

#undef PATH_CCH_ADD_SEPARATOR

/* Native-style Paths */

#define DEFINE_UNICODE FALSE

#define CUR_PATH_SEPARATOR_CHR PATH_SEPARATOR_CHR

#define PATH_CCH_ADD_SEPARATOR PathCchAddSeparatorA

#include "include/PathCchAddSeparator.h"

#undef DEFINE_UNICODE

#undef CUR_PATH_SEPARATOR_CHR

#undef PATH_CCH_ADD_SEPARATOR

#define DEFINE_UNICODE TRUE

#define CUR_PATH_SEPARATOR_CHR PATH_SEPARATOR_CHR_W

#define PATH_CCH_ADD_SEPARATOR PathCchAddSeparatorW

#include "include/PathCchAddSeparator.h"

#undef DEFINE_UNICODE

#undef CUR_PATH_SEPARATOR_CHR

#undef PATH_CCH_ADD_SEPARATOR

/*

 * PathCchRemoveBackslash

 */

HRESULT PathCchRemoveBackslashA(WINPR_ATTR_UNUSED PSTR pszPath, WINPR_ATTR_UNUSED size_t cchPath)

{

  WLog_ERR(TAG, "not implemented");

  return E_NOTIMPL;

}

HRESULT PathCchRemoveBackslashW(WINPR_ATTR_UNUSED PWSTR pszPath, WINPR_ATTR_UNUSED size_t cchPath)

{

  WLog_ERR(TAG, "not implemented");

  return E_NOTIMPL;

}

/*

 * PathCchAddBackslashEx

 */

/* Windows-style Paths */

#define DEFINE_UNICODE FALSE

#define CUR_PATH_SEPARATOR_CHR PATH_BACKSLASH_CHR

#define PATH_CCH_ADD_SEPARATOR_EX PathCchAddBackslashExA

#include "include/PathCchAddSeparatorEx.h"

#undef DEFINE_UNICODE

#undef CUR_PATH_SEPARATOR_CHR

#undef PATH_CCH_ADD_SEPARATOR_EX

#define DEFINE_UNICODE TRUE

#define CUR_PATH_SEPARATOR_CHR PATH_BACKSLASH_CHR_W

#define PATH_CCH_ADD_SEPARATOR_EX PathCchAddBackslashExW

#include "include/PathCchAddSeparatorEx.h"

#undef DEFINE_UNICODE

#undef CUR_PATH_SEPARATOR_CHR

#undef PATH_CCH_ADD_SEPARATOR_EX

/* Unix-style Paths */

#define DEFINE_UNICODE FALSE

#define CUR_PATH_SEPARATOR_CHR PATH_SLASH_CHR

#define PATH_CCH_ADD_SEPARATOR_EX PathCchAddSlashExA

#include "include/PathCchAddSeparatorEx.h"

#undef DEFINE_UNICODE

#undef CUR_PATH_SEPARATOR_CHR

#undef PATH_CCH_ADD_SEPARATOR_EX

#define DEFINE_UNICODE TRUE

#define CUR_PATH_SEPARATOR_CHR PATH_SLASH_CHR_W

#define PATH_CCH_ADD_SEPARATOR_EX PathCchAddSlashExW

#include "include/PathCchAddSeparatorEx.h"

#undef DEFINE_UNICODE

#undef CUR_PATH_SEPARATOR_CHR

#undef PATH_CCH_ADD_SEPARATOR_EX

/* Native-style Paths */

#define DEFINE_UNICODE FALSE

#define CUR_PATH_SEPARATOR_CHR PATH_SEPARATOR_CHR

#define PATH_CCH_ADD_SEPARATOR_EX PathCchAddSeparatorExA

#include "include/PathCchAddSeparatorEx.h"

#undef DEFINE_UNICODE

#undef CUR_PATH_SEPARATOR_CHR

#undef PATH_CCH_ADD_SEPARATOR_EX

#define DEFINE_UNICODE TRUE

#define CUR_PATH_SEPARATOR_CHR PATH_SEPARATOR_CHR_W

#define PATH_CCH_ADD_SEPARATOR_EX PathCchAddSeparatorExW

#include "include/PathCchAddSeparatorEx.h"

#undef DEFINE_UNICODE

#undef CUR_PATH_SEPARATOR_CHR

#undef PATH_CCH_ADD_SEPARATOR_EX

HRESULT PathCchRemoveBackslashExA(WINPR_ATTR_UNUSED PSTR pszPath, WINPR_ATTR_UNUSED size_t cchPath,

                                  WINPR_ATTR_UNUSED PSTR* ppszEnd,

                                  WINPR_ATTR_UNUSED size_t* pcchRemaining)

{

  WLog_ERR(TAG, "not implemented");

  return E_NOTIMPL;

}

HRESULT PathCchRemoveBackslashExW(WINPR_ATTR_UNUSED PWSTR pszPath, WINPR_ATTR_UNUSED size_t cchPath,

                                  WINPR_ATTR_UNUSED PWSTR* ppszEnd,

                                  WINPR_ATTR_UNUSED size_t* pcchRemaining)

{

  WLog_ERR(TAG, "not implemented");

  return E_NOTIMPL;

}

/*

 * PathCchAddExtension

 */

/* Windows-style Paths */

#define DEFINE_UNICODE FALSE

#define CUR_PATH_SEPARATOR_CHR PATH_BACKSLASH_CHR

#define PATH_CCH_ADD_EXTENSION PathCchAddExtensionA

#include "include/PathCchAddExtension.h"

#undef DEFINE_UNICODE

#undef CUR_PATH_SEPARATOR_CHR

#undef PATH_CCH_ADD_EXTENSION

#define DEFINE_UNICODE TRUE

#define CUR_PATH_SEPARATOR_CHR PATH_BACKSLASH_CHR_W

#define PATH_CCH_ADD_EXTENSION PathCchAddExtensionW

#include "include/PathCchAddExtension.h"

#undef DEFINE_UNICODE

#undef CUR_PATH_SEPARATOR_CHR

#undef PATH_CCH_ADD_EXTENSION

#endif

/* Unix-style Paths */

#define DEFINE_UNICODE FALSE

#define CUR_PATH_SEPARATOR_CHR PATH_SLASH_CHR

#define PATH_CCH_ADD_EXTENSION UnixPathCchAddExtensionA

#include "include/PathCchAddExtension.h"

#undef DEFINE_UNICODE

#undef CUR_PATH_SEPARATOR_CHR

#undef PATH_CCH_ADD_EXTENSION

#define DEFINE_UNICODE TRUE

#define CUR_PATH_SEPARATOR_CHR PATH_SLASH_CHR_W

#define PATH_CCH_ADD_EXTENSION UnixPathCchAddExtensionW

#include "include/PathCchAddExtension.h"

#undef DEFINE_UNICODE

#undef CUR_PATH_SEPARATOR_CHR

#undef PATH_CCH_ADD_EXTENSION

/* Native-style Paths */

#define DEFINE_UNICODE FALSE

#define CUR_PATH_SEPARATOR_CHR PATH_SEPARATOR_CHR

#define PATH_CCH_ADD_EXTENSION NativePathCchAddExtensionA

#include "include/PathCchAddExtension.h"

#undef DEFINE_UNICODE

#undef CUR_PATH_SEPARATOR_CHR

#undef PATH_CCH_ADD_EXTENSION

#define DEFINE_UNICODE TRUE

#define CUR_PATH_SEPARATOR_CHR PATH_SEPARATOR_CHR_W

#define PATH_CCH_ADD_EXTENSION NativePathCchAddExtensionW

#include "include/PathCchAddExtension.h"

#undef DEFINE_UNICODE

#undef CUR_PATH_SEPARATOR_CHR

#undef PATH_CCH_ADD_EXTENSION

/*

 * PathCchAppend

 */

/* Windows-style Paths */

#if !defined(WITHOUT_WINPR_3x_DEPRECATED)

#define DEFINE_UNICODE FALSE

#define CUR_PATH_SEPARATOR_CHR PATH_BACKSLASH_CHR

#define CUR_PATH_SEPARATOR_STR PATH_BACKSLASH_STR

#define PATH_CCH_APPEND PathCchAppendA

#include "include/PathCchAppend.h"

#undef DEFINE_UNICODE

#undef CUR_PATH_SEPARATOR_CHR

#undef CUR_PATH_SEPARATOR_STR

#undef PATH_CCH_APPEND

#define DEFINE_UNICODE TRUE

#define CUR_PATH_SEPARATOR_CHR PATH_BACKSLASH_CHR_W

#define CUR_PATH_SEPARATOR_STR PATH_BACKSLASH_STR_W

#define PATH_CCH_APPEND PathCchAppendW

#include "include/PathCchAppend.h"

#undef DEFINE_UNICODE

#undef CUR_PATH_SEPARATOR_CHR

#undef CUR_PATH_SEPARATOR_STR

#undef PATH_CCH_APPEND

/* Unix-style Paths */

#define DEFINE_UNICODE FALSE

#define CUR_PATH_SEPARATOR_CHR PATH_SLASH_CHR

#define CUR_PATH_SEPARATOR_STR PATH_SLASH_STR

#define PATH_CCH_APPEND UnixPathCchAppendA

#include "include/PathCchAppend.h"

#undef DEFINE_UNICODE

#undef CUR_PATH_SEPARATOR_CHR

#undef CUR_PATH_SEPARATOR_STR

#undef PATH_CCH_APPEND

#define DEFINE_UNICODE TRUE

#define CUR_PATH_SEPARATOR_CHR PATH_SLASH_CHR_W

#define CUR_PATH_SEPARATOR_STR PATH_SLASH_STR_W

#define PATH_CCH_APPEND UnixPathCchAppendW

#include "include/PathCchAppend.h"

#undef DEFINE_UNICODE

#undef CUR_PATH_SEPARATOR_CHR

#undef CUR_PATH_SEPARATOR_STR

#undef PATH_CCH_APPEND

#endif

/* Native-style Paths */

#define DEFINE_UNICODE FALSE

#define CUR_PATH_SEPARATOR_CHR PATH_SEPARATOR_CHR

#define CUR_PATH_SEPARATOR_STR PATH_SEPARATOR_STR

#define PATH_CCH_APPEND NativePathCchAppendA

#include "include/PathCchAppend.h"

#undef DEFINE_UNICODE

#undef CUR_PATH_SEPARATOR_CHR

#undef CUR_PATH_SEPARATOR_STR

#undef PATH_CCH_APPEND

#define DEFINE_UNICODE TRUE

#define CUR_PATH_SEPARATOR_CHR PATH_SEPARATOR_CHR_W

#define CUR_PATH_SEPARATOR_STR PATH_SEPARATOR_STR_W

#define PATH_CCH_APPEND NativePathCchAppendW

#include "include/PathCchAppend.h"

#undef DEFINE_UNICODE

#undef CUR_PATH_SEPARATOR_CHR

#undef CUR_PATH_SEPARATOR_STR

#undef PATH_CCH_APPEND

#if !defined(WITHOUT_WINPR_3x_DEPRECATED)

/*

 * PathCchAppendEx

 */

HRESULT PathCchAppendExA(WINPR_ATTR_UNUSED PSTR pszPath, WINPR_ATTR_UNUSED size_t cchPath,

                         WINPR_ATTR_UNUSED PCSTR pszMore, WINPR_ATTR_UNUSED unsigned long dwFlags)

{

  WLog_ERR(TAG, "not implemented");

  return E_NOTIMPL;

}

HRESULT PathCchAppendExW(WINPR_ATTR_UNUSED PWSTR pszPath, WINPR_ATTR_UNUSED size_t cchPath,

                         WINPR_ATTR_UNUSED PCWSTR pszMore, WINPR_ATTR_UNUSED unsigned long dwFlags)

{

  WLog_ERR(TAG, "not implemented");

  return E_NOTIMPL;

}

#endif

#if !defined(_WIN32)

#if !defined(WITH_CWALK)

static void replace(char* str, size_t slen, const char* pattern)

{

  const size_t len = strlen(pattern);

  while (TRUE)

  {

    char* cur = strstr(str, pattern);

    if (!cur)

      return;

    const char* src = &cur[len];

    /* Ensure terminating '\0' is moved as well */

    const size_t rem = strnlen(src, slen) + 1;

    memmove(&cur[1], src, rem);

  }

}

WINPR_ATTR_NODISCARD

static BOOL replace_dotdot(char* str, size_t slen)

{

  const char pattern[] = "/../";

  const size_t len = strlen(pattern);

  while (TRUE)

  {

    char* cur = strstr(str, pattern);

    if (!cur)

      return TRUE;

    char* start = cur;

    const char* end = &cur[len];

    while (start > str)

    {

      start--;

      if (*start == '/')

        break;

    }

    if (*start != '/')

      return FALSE;

    /* Ensure terminating '\0' is moved as well */

    const size_t rem = strnlen(end, slen) + 1;

    memmove(&start[1], end, rem);

  }

}

WINPR_ATTR_NODISCARD

static BOOL replace_trailing_dotdot(char* str, size_t slen)

{

  const size_t len = strnlen(str, slen);

  if (len < 3)

    return TRUE;

  if (strcmp(&str[len - 3], "/..") != 0)

    return TRUE;

  char* start = &str[len - 4];

  while (start >= str)

  {

    if (*start == '/')

    {

      start[1] = '\0';

      return TRUE;

    }

    start--;

  }

  return FALSE;

}

#endif

WINPR_ATTR_NODISCARD

char* winpr_PathCanonicalize(const char* path)

{

  WINPR_ASSERT(path);

  const size_t len = strlen(path);

#if defined(WITH_CWALK)

  char* str = calloc(len + 1, sizeof(char));

  if (!str)

    return nullptr;

  (void)cwk_path_normalize(path, str, len + 1);

  return str;

#else

  char* str = strndup(path, len);

  if (!str)

    return nullptr;

  replace(str, len, "/./");

  replace(str, len, "//");

  if (!replace_dotdot(str, len) || !replace_trailing_dotdot(str, len))

  {

    free(str);

    return nullptr;

  }

  size_t slen = 0;

  while ((slen = strnlen(str, len)) > 1)

  {

    if ((str[slen - 1] == '.') || (str[slen - 1] == '/'))

      str[slen - 1] = '\0';

    else

      break;

  }

  return str;

#endif

}

#if !defined(WITHOUT_WINPR_3x_DEPRECATED)

/*

 * PathCchCanonicalize

 */

HRESULT PathCchCanonicalizeA(PSTR pszPathOut, size_t cchPathOut, PCSTR pszPathIn)

{

  char* out = winpr_PathCanonicalize(pszPathIn);

  if (!out)

    return E_OUTOFMEMORY;

  const size_t len = strnlen(out, cchPathOut);

  if (len >= cchPathOut)

  {

    free(out);

    return E_INVALIDARG;

  }

  strncpy(pszPathOut, out, cchPathOut);

  free(out);

  return S_OK;

}

HRESULT PathCchCanonicalizeW(PWSTR pszPathOut, size_t cchPathOut, PCWSTR pszPathIn)

{

  if (!pszPathIn)

    return E_OUTOFMEMORY;

  char* str = ConvertWCharToUtf8Alloc(pszPathIn, nullptr);

  if (!str)

    return E_OUTOFMEMORY;

  char* out = calloc(cchPathOut, sizeof(CHAR));

  if (!out)

  {

    free(str);

    return E_OUTOFMEMORY;

  }

  HRESULT hr = PathCchCanonicalizeA(out, cchPathOut, str);

  free(str);

  (void)ConvertUtf8NToWChar(out, cchPathOut, pszPathOut, cchPathOut);

  free(out);

  return hr;

}

/*

 * PathCchCanonicalizeEx

 */

HRESULT PathCchCanonicalizeExA(WINPR_ATTR_UNUSED PSTR pszPathOut,

                               WINPR_ATTR_UNUSED size_t cchPathOut,

                               WINPR_ATTR_UNUSED PCSTR pszPathIn,

                               WINPR_ATTR_UNUSED unsigned long dwFlags)

{

  if (dwFlags != 0)

    WLog_WARN(TAG, "flags 0x%08lx not implemented", dwFlags);

  return PathCchCanonicalizeA(pszPathOut, cchPathOut, pszPathIn);

}

HRESULT PathCchCanonicalizeExW(WINPR_ATTR_UNUSED PWSTR pszPathOut,

                               WINPR_ATTR_UNUSED size_t cchPathOut,

                               WINPR_ATTR_UNUSED PCWSTR pszPathIn,

                               WINPR_ATTR_UNUSED unsigned long dwFlags)

{

  if (dwFlags != 0)

    WLog_WARN(TAG, "flags 0x%08lx not implemented", dwFlags);

  return PathCchCanonicalizeW(pszPathOut, cchPathOut, pszPathIn);

}

/*

 * PathAllocCanonicalize

 */

HRESULT PathAllocCanonicalizeA(PCSTR pszPathIn, unsigned long dwFlags, PSTR* ppszPathOut)

{

  if (!ppszPathOut)

    return E_INVALIDARG;

  if (!pszPathIn)

    return E_OUTOFMEMORY;

  if (dwFlags != 0)

    WLog_WARN(TAG, "flags 0x%08lx not implemented", dwFlags);

  *ppszPathOut = winpr_PathCanonicalize(pszPathIn);

  if (!*ppszPathOut)

    return E_OUTOFMEMORY;

  return S_OK;

}

HRESULT PathAllocCanonicalizeW(PCWSTR pszPathIn, unsigned long dwFlags, PWSTR* ppszPathOut)

{

  if (!ppszPathOut)

    return E_INVALIDARG;

  if (!pszPathIn)

    return E_OUTOFMEMORY;

  char* str = ConvertWCharToUtf8Alloc(pszPathIn, nullptr);

  if (!str)

    return E_OUTOFMEMORY;

  char* out = nullptr;

  HRESULT hr = PathAllocCanonicalizeA(str, dwFlags, &out);

  if (out)

    *ppszPathOut = ConvertUtf8ToWCharAlloc(out, nullptr);

  free(str);

  free(out);

  return hr;

}

#endif

#endif

#if !defined(WITHOUT_WINPR_3x_DEPRECATED)

/*

 * PathCchCombine

 */

HRESULT PathCchCombineA(WINPR_ATTR_UNUSED PSTR pszPathOut, WINPR_ATTR_UNUSED size_t cchPathOut,

                        WINPR_ATTR_UNUSED PCSTR pszPathIn, WINPR_ATTR_UNUSED PCSTR pszMore)

{

  WLog_ERR(TAG, "not implemented");

  return E_NOTIMPL;

}

HRESULT PathCchCombineW(WINPR_ATTR_UNUSED PWSTR pszPathOut, WINPR_ATTR_UNUSED size_t cchPathOut,

                        WINPR_ATTR_UNUSED PCWSTR pszPathIn, WINPR_ATTR_UNUSED PCWSTR pszMore)

{

  WLog_ERR(TAG, "not implemented");

  return E_NOTIMPL;

}

/*

 * PathCchCombineEx

 */

HRESULT PathCchCombineExA(WINPR_ATTR_UNUSED PSTR pszPathOut, WINPR_ATTR_UNUSED size_t cchPathOut,

                          WINPR_ATTR_UNUSED PCSTR pszPathIn, WINPR_ATTR_UNUSED PCSTR pszMore,

                          WINPR_ATTR_UNUSED unsigned long dwFlags)

{

  WLog_ERR(TAG, "not implemented");

  return E_NOTIMPL;

}

HRESULT PathCchCombineExW(WINPR_ATTR_UNUSED PWSTR pszPathOut, WINPR_ATTR_UNUSED size_t cchPathOut,

                          WINPR_ATTR_UNUSED PCWSTR pszPathIn, WINPR_ATTR_UNUSED PCWSTR pszMore,

                          WINPR_ATTR_UNUSED unsigned long dwFlags)

{

  WLog_ERR(TAG, "not implemented");

  return E_NOTIMPL;

}

/*

 * PathAllocCombine

 */

/* Windows-style Paths */

#define DEFINE_UNICODE FALSE

#define CUR_PATH_SEPARATOR_CHR PATH_BACKSLASH_CHR

#define CUR_PATH_SEPARATOR_STR PATH_BACKSLASH_STR

#define PATH_ALLOC_COMBINE PathAllocCombineA

#include "include/PathAllocCombine.h"

#undef DEFINE_UNICODE

#undef CUR_PATH_SEPARATOR_CHR

#undef CUR_PATH_SEPARATOR_STR

#undef PATH_ALLOC_COMBINE

#define DEFINE_UNICODE TRUE

#define CUR_PATH_SEPARATOR_CHR PATH_BACKSLASH_CHR_W

#define CUR_PATH_SEPARATOR_STR PATH_BACKSLASH_STR_W

#define PATH_ALLOC_COMBINE PathAllocCombineW

#include "include/PathAllocCombine.h"

#undef DEFINE_UNICODE

#undef CUR_PATH_SEPARATOR_CHR

#undef CUR_PATH_SEPARATOR_STR

#undef PATH_ALLOC_COMBINE

#endif

/* Unix-style Paths */

#define DEFINE_UNICODE FALSE

#define CUR_PATH_SEPARATOR_CHR PATH_SLASH_CHR

#define CUR_PATH_SEPARATOR_STR PATH_SLASH_STR

#define PATH_ALLOC_COMBINE UnixPathAllocCombineA

#include "include/PathAllocCombine.h"

#undef DEFINE_UNICODE

#undef CUR_PATH_SEPARATOR_CHR

#undef CUR_PATH_SEPARATOR_STR

#undef PATH_ALLOC_COMBINE

#define DEFINE_UNICODE TRUE

#define CUR_PATH_SEPARATOR_CHR PATH_SLASH_CHR_W

#define CUR_PATH_SEPARATOR_STR PATH_SLASH_STR_W

#define PATH_ALLOC_COMBINE UnixPathAllocCombineW

#include "include/PathAllocCombine.h"

#undef DEFINE_UNICODE

#undef CUR_PATH_SEPARATOR_CHR

#undef CUR_PATH_SEPARATOR_STR

#undef PATH_ALLOC_COMBINE

/* Native-style Paths */

#define DEFINE_UNICODE FALSE

#define CUR_PATH_SEPARATOR_CHR PATH_SEPARATOR_CHR

#define CUR_PATH_SEPARATOR_STR PATH_SEPARATOR_STR

#define PATH_ALLOC_COMBINE NativePathAllocCombineA

#include "include/PathAllocCombine.h"

#undef DEFINE_UNICODE

#undef CUR_PATH_SEPARATOR_CHR

#undef CUR_PATH_SEPARATOR_STR

#undef PATH_ALLOC_COMBINE

#define DEFINE_UNICODE TRUE

#define CUR_PATH_SEPARATOR_CHR PATH_SEPARATOR_CHR_W

#define CUR_PATH_SEPARATOR_STR PATH_SEPARATOR_STR_W

#define PATH_ALLOC_COMBINE NativePathAllocCombineW

#include "include/PathAllocCombine.h"

#undef DEFINE_UNICODE

#undef CUR_PATH_SEPARATOR_CHR

#undef CUR_PATH_SEPARATOR_STR

#undef PATH_ALLOC_COMBINE

#if !defined(WITHOUT_WINPR_3x_DEPRECATED)

/**

 * PathCchFindExtension

 */

HRESULT PathCchFindExtensionA(PCSTR pszPath, size_t cchPath, PCSTR* ppszExt)

{

  const char* p = (const char*)pszPath;

  if (!pszPath || !cchPath || !ppszExt)

    return E_INVALIDARG;

  /* find end of string */

  while (*p && --cchPath)

  {

    p++;

  }

  if (*p)

  {

    /* pszPath is not null terminated within the cchPath range */

    return E_INVALIDARG;

  }

  /* If no extension is found, ppszExt must point to the string's terminating null */

  *ppszExt = p;

  /* search backwards for '.' */

  while (p > pszPath)

  {

    if (*p == '.')

    {

      *ppszExt = (PCSTR)p;

      break;

    }

    if ((*p == '\\') || (*p == '/') || (*p == ':'))

      break;

    p--;

  }

  return S_OK;

}

HRESULT PathCchFindExtensionW(WINPR_ATTR_UNUSED PCWSTR pszPath, WINPR_ATTR_UNUSED size_t cchPath,

                              WINPR_ATTR_UNUSED PCWSTR* ppszExt)

{

  WLog_ERR(TAG, "not implemented");

  return E_NOTIMPL;

}

/**

 * PathCchRenameExtension

 */

HRESULT PathCchRenameExtensionA(WINPR_ATTR_UNUSED PSTR pszPath, WINPR_ATTR_UNUSED size_t cchPath,

                                WINPR_ATTR_UNUSED PCSTR pszExt)

{

  WLog_ERR(TAG, "not implemented");

  return E_NOTIMPL;

}

HRESULT PathCchRenameExtensionW(WINPR_ATTR_UNUSED PWSTR pszPath, WINPR_ATTR_UNUSED size_t cchPath,

                                WINPR_ATTR_UNUSED PCWSTR pszExt)

{

  WLog_ERR(TAG, "not implemented");

  return E_NOTIMPL;

}

/**

 * PathCchRemoveExtension

 */

HRESULT PathCchRemoveExtensionA(WINPR_ATTR_UNUSED PSTR pszPath, WINPR_ATTR_UNUSED size_t cchPath)

{

  WLog_ERR(TAG, "not implemented");

  return E_NOTIMPL;

}

HRESULT PathCchRemoveExtensionW(WINPR_ATTR_UNUSED PWSTR pszPath, WINPR_ATTR_UNUSED size_t cchPath)

{

  WLog_ERR(TAG, "not implemented");

  return E_NOTIMPL;

}

/**

 * PathCchIsRoot

 */

BOOL PathCchIsRootA(WINPR_ATTR_UNUSED PCSTR pszPath)

{

  WLog_ERR(TAG, "not implemented");

  return FALSE;

}

BOOL PathCchIsRootW(WINPR_ATTR_UNUSED PCWSTR pszPath)

{

  WLog_ERR(TAG, "not implemented");

  return FALSE;

}

/**

 * PathIsUNCEx

 */

BOOL PathIsUNCExA(PCSTR pszPath, PCSTR* ppszServer)

{

  if (!pszPath)

    return FALSE;

  if ((pszPath[0] == '\\') && (pszPath[1] == '\\'))

  {

    *ppszServer = &pszPath[2];

    return TRUE;

  }

  return FALSE;

}

BOOL PathIsUNCExW(PCWSTR pszPath, PCWSTR* ppszServer)

{

  if (!pszPath)

    return FALSE;

  if ((pszPath[0] == '\\') && (pszPath[1] == '\\'))

  {

    *ppszServer = &pszPath[2];

    return TRUE;

  }

  return FALSE;

}

/**

 * PathCchSkipRoot

 */

HRESULT PathCchSkipRootA(WINPR_ATTR_UNUSED PCSTR pszPath, WINPR_ATTR_UNUSED PCSTR* ppszRootEnd)

{

  WLog_ERR(TAG, "not implemented");

  return E_NOTIMPL;

}

HRESULT PathCchSkipRootW(WINPR_ATTR_UNUSED PCWSTR pszPath, WINPR_ATTR_UNUSED PCWSTR* ppszRootEnd)

{

  WLog_ERR(TAG, "not implemented");

  return E_NOTIMPL;

}

/**

 * PathCchStripToRoot

 */

HRESULT PathCchStripToRootA(WINPR_ATTR_UNUSED PSTR pszPath, WINPR_ATTR_UNUSED size_t cchPath)

{

  WLog_ERR(TAG, "not implemented");

  return E_NOTIMPL;

}

HRESULT PathCchStripToRootW(WINPR_ATTR_UNUSED PWSTR pszPath, WINPR_ATTR_UNUSED size_t cchPath)

{

  WLog_ERR(TAG, "not implemented");

  return E_NOTIMPL;

}

/**

 * PathCchStripPrefix

 */

HRESULT PathCchStripPrefixA(PSTR pszPath, size_t cchPath)

{

  BOOL hasPrefix = 0;

  if (!pszPath)

    return E_INVALIDARG;

  if (cchPath < 4 || cchPath > PATHCCH_MAX_CCH)

    return E_INVALIDARG;

  hasPrefix = ((pszPath[0] == '\\') && (pszPath[1] == '\\') && (pszPath[2] == '?') &&

               (pszPath[3] == '\\'));

  if (hasPrefix)

  {

    if (cchPath < 6)

      return S_FALSE;

    if (IsCharAlpha(pszPath[4]) && (pszPath[5] == ':')) /* like C: */

    {

      if (memmove_s(pszPath, cchPath, &pszPath[4], cchPath - 4) < 0)

        return HRESULT_FROM_WIN32(ERROR_INVALID_DATA);

      /* since the passed pszPath must not necessarily be null terminated

       * and we always have enough space after the strip we can always

       * ensure the null termination of the stripped result

       */

      pszPath[cchPath - 4] = 0;

      return S_OK;

    }

  }

  return S_FALSE;

}

HRESULT PathCchStripPrefixW(PWSTR pszPath, size_t cchPath)

{

  BOOL hasPrefix = 0;

  if (!pszPath)

    return E_INVALIDARG;

  if (cchPath < 4 || cchPath > PATHCCH_MAX_CCH)

    return E_INVALIDARG;

  hasPrefix = ((pszPath[0] == '\\') && (pszPath[1] == '\\') && (pszPath[2] == '?') &&

               (pszPath[3] == '\\'));

  if (hasPrefix)

  {

    if (cchPath < 6)

      return S_FALSE;

    const size_t rc = (_wcslen(&pszPath[4]) + 1);

    if (cchPath < rc)

      return HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER);

    if (IsCharAlphaW(pszPath[4]) && (pszPath[5] == L':')) /* like C: */

    {

      if (wmemmove_s(pszPath, cchPath, &pszPath[4], cchPath - 4) < 0)

        return HRESULT_FROM_WIN32(ERROR_INVALID_DATA);

      /* since the passed pszPath must not necessarily be null terminated

       * and we always have enough space after the strip we can always

       * ensure the null termination of the stripped result

       */

      pszPath[cchPath - 4] = 0;

      return S_OK;

    }

  }

  return S_FALSE;

}

/**

 * PathCchRemoveFileSpec

 */

HRESULT PathCchRemoveFileSpecA(WINPR_ATTR_UNUSED PSTR pszPath, WINPR_ATTR_UNUSED size_t cchPath)

{

  WLog_ERR(TAG, "not implemented");

  return E_NOTIMPL;

}