Changeset 28903 in vbox for trunk/src/VBox/Runtime

Timestamp:

Apr 29, 2010 2:58:12 PM (15 years ago)

Author:

vboxsync

svn:sync-xref-src-repo-rev:

60847

Message:

IPRT: iconv cache.

Location:

trunk/src/VBox/Runtime

Files:

• Makefile.kmk (modified) (1 diff)
• common/misc/thread.cpp (modified) (3 diffs)
• common/string/utf-8-case.cpp (modified) (1 diff)
• common/string/utf-8.cpp (modified) (2 diffs)
• generic/pathhost-generic.cpp (modified) (3 diffs)
• include/internal/path.h (modified) (1 diff)
• include/internal/string.h (modified) (1 diff)
• include/internal/thread.h (modified) (2 diffs)
• r3/init.cpp (modified) (2 diffs)
• r3/posix/utf8-posix.cpp (modified) (8 diffs)

trunk/src/VBox/Runtime/Makefile.kmk

@@ -187 +187 @@
 endif
 ifdef VBOX_MAIN_RELEASE_LOG ## @todo (dmik): temporary, until RTThreadSelf/RTThreadAdopt are properly updated
- RuntimeR3_DEFS         += RTCRITSECT_STRICT
+ RuntimeR3_DEFS        += RTCRITSECT_STRICT
 endif
 ifdef IPRT_WITH_LZJB
- RuntimeR3_DEFS         += RTZIP_USE_LZJB
+ RuntimeR3_DEFS        += RTZIP_USE_LZJB
 endif
 ifdef IPRT_WITH_LZO
- RuntimeR3_DEFS         += RTZIP_USE_LZO
+ RuntimeR3_DEFS        += RTZIP_USE_LZO
+endif
+ifn1of ($(KBUILD_TARGET), win)
+ RuntimeR3_DEFS        += RT_WITH_ICONV_CACHE
 endif
 ifdef IPRT_WITH_FUTEX_BASED_SEMS
- RuntimeR3_DEFS.linux   += IPRT_WITH_FUTEX_BASED_SEMS
+ RuntimeR3_DEFS.linux  += IPRT_WITH_FUTEX_BASED_SEMS
 endif
 RuntimeR3_INCS          = \

trunk/src/VBox/Runtime/common/misc/thread.cpp

@@ -49 +49 @@
 #include "internal/sched.h"
 #include "internal/process.h"
+#ifdef RT_WITH_ICONV_CACHE
+# include "internal/string.h"
+#endif
 
 
@@ -354 +357 @@
 #ifdef IN_RING3
         rtLockValidatorInitPerThread(&pThread->LockValidator);
+#endif
+#ifdef RT_WITH_ICONV_CACHE
+        rtStrIconvCacheInit(pThread);
 #endif
         int rc = RTSemEventMultiCreate(&pThread->EventUser);
@@ -575 +581 @@
 
     rtLockValidatorDeletePerThread(&pThread->LockValidator);
+#endif
+#ifdef RT_WITH_ICONV_CACHE
+    rtStrIconvCacheDestroy(pThread);
 #endif
     ASMAtomicXchgU32(&pThread->u32Magic, RTTHREADINT_MAGIC_DEAD);

trunk/src/VBox/Runtime/common/string/utf-8-case.cpp

@@ -109 +109 @@
     }
 
-    /* Hit some bad encoding, continue in case insensitive mode. */
+    /* Hit some bad encoding, continue in case sensitive mode. */
     return RTStrCmp(psz1, psz2);
 }

trunk/src/VBox/Runtime/common/string/utf-8.cpp

@@ -52 +52 @@
  *                          on success (cch = cb again). Optional.
  */
-static int rtUtf8Length(const char *psz, size_t cch, size_t *pcuc, size_t *pcchActual)
+int rtUtf8Length(const char *psz, size_t cch, size_t *pcuc, size_t *pcchActual)
 {
     const unsigned char *puch = (const unsigned char *)psz;
@@ -316 +316 @@
     }
     return rc;
-
-
-    return RTStrUniLenEx(psz, cch, &cCpsIgnored);
 }
 RT_EXPORT_SYMBOL(RTStrValidateEncodingEx);

trunk/src/VBox/Runtime/generic/pathhost-generic.cpp

@@ -30 +30 @@
 *******************************************************************************/
 #define LOG_GROUP RTLOGGROUP_PATH
+#include "internal/iprt.h"
+#include "internal/path.h"
+#include "internal/thread.h"
+
+#include <iprt/env.h>
 #include <iprt/string.h>
-#include "internal/iprt.h"
-
-#include "internal/path.h"
+#include <iprt/once.h>
+
+
+/*******************************************************************************
+*   Global Variables                                                           *
+*******************************************************************************/
+/** Initialize once object. */
+static RTONCE       g_OnceInitPathConv = RTONCE_INITIALIZER;
+/** If set, then we can pass UTF-8 thru directly. */
+static bool         g_fPassthruUtf8    = false;
+/** The UTF-8 to FS iconv cache entry. */
+static RTSTRICONV   g_enmUtf8ToFsIdx   = RTSTRICONV_UTF8_TO_LOCALE;
+/** The FS to UTF-8 iconv cache entry. */
+static RTSTRICONV   g_enmFsToUtf8Idx   = RTSTRICONV_LOCALE_TO_UTF8;
+/** The codeset we're using. */
+static char         g_szFsCodeset[32];
+
+
+/**
+ * Do a case insensitive compare where the 2nd string is known and can be case
+ * folded when writing the code.
+ *
+ * @returns see strcmp.
+ * @param   pszStr1             The string to compare against pszLower and
+ *                              pszUpper.
+ * @param   pszUpper            The upper case edition of the 2nd string.
+ * @param   pszLower            The lower case edition of the 2nd string.
+ */
+static int rtPathStrICmp(const char *pszStr1, const char *pszUpper, const char *pszLower)
+{
+    Assert(strlen(pszLower) == strlen(pszUpper));
+    for (;;)
+    {
+        char ch1      = *pszStr1++;
+        char ch2Upper = *pszUpper++;
+        char ch2Lower = *pszLower++;
+        if (   ch1 != ch2Upper
+            && ch1 != ch2Lower)
+            return ch1 < ch2Upper ? -1 : 1;
+        if (!ch1)
+            return 0;
+    }
+}
+
+/**
+ * Is the specified codeset something we can treat as UTF-8.
+ *
+ * @returns true if we can do UTF-8 passthru, false if not.
+ * @param   pszCodeset          The codeset in question.
+ */
+static bool rtPathConvInitIsUtf8(const char *pszCodeset)
+{
+    /* Paranoia. */
+    if (!pszCodeset)
+        return false;
+
+    /*
+     * Avoid RTStrICmp at this point.
+     */
+    static struct
+    {
+        const char *pszUpper;
+        const char *pszLower;
+    } const s_aUtf8Compatible[] =
+    {
+        /* The default locale. */
+        { "C"                   , "c"                   },
+        { "POSIX"               , "posix"               },
+        /* 7-bit ASCII. */
+        { "ANSI_X3.4-1968"      , "ansi_x3.4-1968"      },
+        { "ANSI_X3.4-1986"      , "ansi_x3.4-1986"      },
+        { "US-ASCII"            , "us-ascii"            },
+        { "ISO646-US"           , "iso646-us"           },
+        { "ISO_646.IRV:1991"    , "iso_646.irv:1991"    },
+        { "ISO-IR-6"            , "iso-ir-6"            },
+        { "IBM367"              , "ibm367"              },
+        /* UTF-8 */
+        { "UTF-8"               , "utf-8"               },
+        { "UTF8"                , "utf8"                },
+        { "ISO-10646/UTF-8"     , "iso-10646/utf-8"     },
+        { "ISO-10646/UTF8"      , "iso-10646/utf8"      }
+    };
+
+    for (size_t i = 0; i < RT_ELEMENTS(s_aUtf8Compatible); i++)
+        if (!rtPathStrICmp(pszCodeset, s_aUtf8Compatible[i].pszUpper, s_aUtf8Compatible[i].pszLower))
+            return true;
+
+    return false;
+}
+
+
+/**
+ * Init once for the path conversion code.
+ *
+ * @returns IPRT status code.
+ * @param   pvUser1             Unused.
+ * @param   pvUser2             Unused.
+ */
+static DECLCALLBACK(int32_t) rtPathConvInitOnce(void *pvUser1, void *pvUser2)
+{
+    /*
+     * Read the environment variable, no mercy on misconfigs here except that
+     * empty values are quietly ignored.  (We use a temp buffer for stripping.)
+     */
+    char *pszEnvValue = NULL;
+    char  szEnvValue[sizeof(g_szFsCodeset)];
+    int rc = RTEnvGetEx(RTENV_DEFAULT, RTPATH_CODESET_ENV_VAR, szEnvValue, sizeof(szEnvValue), NULL);
+    if (rc != VERR_ENV_VAR_NOT_FOUND && RT_FAILURE(rc))
+        return rc;
+    if (RT_SUCCESS(rc))
+        pszEnvValue = RTStrStrip(szEnvValue);
+
+    if (pszEnvValue && *pszEnvValue)
+    {
+        g_fPassthruUtf8  = rtPathConvInitIsUtf8(pszEnvValue);
+        g_enmFsToUtf8Idx = RTSTRICONV_FS_TO_UTF8;
+        g_enmUtf8ToFsIdx = RTSTRICONV_UTF8_TO_FS;
+        strcpy(g_szFsCodeset, pszEnvValue);
+    }
+    else
+    {
+        const char *pszCodeset = rtStrGetLocaleCodeset();
+        size_t      cchCodeset = pszCodeset ? strlen(pszCodeset) : sizeof(g_szFsCodeset);
+        if (cchCodeset >= sizeof(g_szFsCodeset))
+            /* This shouldn't happen, but we'll manage. */
+            g_szFsCodeset[0] = '\0';
+        else
+        {
+            memcpy(g_szFsCodeset, pszCodeset, cchCodeset + 1);
+            pszCodeset = g_szFsCodeset;
+        }
+        g_fPassthruUtf8  = rtPathConvInitIsUtf8(pszCodeset);
+        g_enmFsToUtf8Idx = RTSTRICONV_LOCALE_TO_UTF8;
+        g_enmUtf8ToFsIdx = RTSTRICONV_UTF8_TO_LOCALE;
+    }
+
+    NOREF(pvUser1); NOREF(pvUser2);
+    return VINF_SUCCESS;
+}
 
 
 int rtPathToNative(char **ppszNativePath, const char *pszPath)
 {
-    return RTStrUtf8ToCurrentCP(ppszNativePath, pszPath);
-}
+    *ppszNativePath = NULL;
+
+    int rc = RTOnce(&g_OnceInitPathConv, rtPathConvInitOnce, NULL, NULL);
+    if (RT_SUCCESS(rc))
+    {
+        if (g_fPassthruUtf8 || !*pszPath)
+            *ppszNativePath = (char *)pszPath;
+        else
+            rc = rtStrConvert(pszPath, strlen(pszPath), "UTF-8",
+                              ppszNativePath, 0, g_szFsCodeset,
+                              2, g_enmUtf8ToFsIdx);
+    }
+    return rc;
+}
+
 
 int rtPathToNativeEx(char **ppszNativePath, const char *pszPath, const char *pszBasePath)
 {
+    /* We don't query the FS for codeset preferences yet, so nothing special to do here. */
     NOREF(pszBasePath);
-    return RTStrUtf8ToCurrentCP(ppszNativePath, pszPath);
-}
+    return rtPathToNative(ppszNativePath, pszPath);
+}
+
 
 void rtPathFreeNative(char *pszNativePath, const char *pszPath)
 {
-    if (pszNativePath)
+    if (    pszNativePath != pszPath
+        &&  pszNativePath)
         RTStrFree(pszNativePath);
 }
@@ -56 +213 @@
 int rtPathFromNative(char **ppszPath, const char *pszNativePath)
 {
-    return RTStrCurrentCPToUtf8(ppszPath, pszNativePath);
+    *ppszPath = NULL;
+
+    int rc = RTOnce(&g_OnceInitPathConv, rtPathConvInitOnce, NULL, NULL);
+    if (RT_SUCCESS(rc))
+    {
+        if (g_fPassthruUtf8 || !*pszNativePath)
+        {
+            size_t cCpsIgnored;
+            size_t cchNativePath;
+            rc = rtUtf8Length(pszNativePath, RTSTR_MAX, &cCpsIgnored, &cchNativePath);
+            if (RT_SUCCESS(rc))
+            {
+                char *pszPath;
+                *ppszPath = pszPath = RTStrAlloc(cchNativePath + 1);
+                if (pszPath)
+                    memcpy(pszPath, pszNativePath, cchNativePath + 1);
+                else
+                    rc = VERR_NO_STR_MEMORY;
+            }
+        }
+        else
+            rc = rtStrConvert(pszNativePath, strlen(pszNativePath), g_szFsCodeset,
+                              ppszPath, 0, "UTF-8",
+                              2, g_enmFsToUtf8Idx);
+    }
+    return rc;
 }
 
@@ -62 +244 @@
 int rtPathFromNativeEx(char **ppszPath, const char *pszNativePath, const char *pszBasePath)
 {
+    /* We don't query the FS for codeset preferences yet, so nothing special to do here. */
     NOREF(pszBasePath);
-    return RTStrCurrentCPToUtf8(ppszPath, pszNativePath);
-}
-
+    return rtPathFromNative(ppszPath, pszNativePath);
+}
+

trunk/src/VBox/Runtime/include/internal/path.h

@@ -37 +37 @@
 # define HAVE_DRIVE 1
 #endif
+
+/** The name of the environment variable that is used to override the default
+ * codeset used when talking to the file systems.  This is only available on
+ * Mac OS X and UNIX systems. */
+#define RTPATH_CODESET_ENV_VAR          "IPRT_PATH_CODESET"
 
 

trunk/src/VBox/Runtime/include/internal/string.h

@@ -48 +48 @@
 #endif
 
-size_t rtstrFormatRt(PFNRTSTROUTPUT pfnOutput, void *pvArgOutput, const char **ppszFormat, va_list *pArgs, int cchWidth, int cchPrecision, unsigned fFlags, char chArgSize);
-size_t rtstrFormatType(PFNRTSTROUTPUT pfnOutput, void *pvArgOutput, const char **ppszFormat, va_list *pArgs, int cchWidth, int cchPrecision, unsigned fFlags, char chArgSize);
+size_t rtstrFormatRt(PFNRTSTROUTPUT pfnOutput, void *pvArgOutput, const char **ppszFormat, va_list *pArgs,
+                     int cchWidth, int cchPrecision, unsigned fFlags, char chArgSize);
+size_t rtstrFormatType(PFNRTSTROUTPUT pfnOutput, void *pvArgOutput, const char **ppszFormat, va_list *pArgs,
+                       int cchWidth, int cchPrecision, unsigned fFlags, char chArgSize);
+
+#ifdef RT_WITH_ICONV_CACHE
+void rtStrIconvCacheInit(struct RTTHREADINT *pThread);
+void rtStrIconvCacheDestroy(struct RTTHREADINT *pThread);
+#endif
+
+/**
+ * Indexes into RTTHREADINT::ahIconvs
+ */
+typedef enum RTSTRICONV
+{
+    /** UTF-8 to the locale codeset (LC_CTYPE). */
+    RTSTRICONV_UTF8_TO_LOCALE = 0,
+    /** The locale codeset (LC_CTYPE) to UTF-8. */
+    RTSTRICONV_LOCALE_TO_UTF8,
+    /** UTF-8 to the filesystem codeset - if different from the locale codeset. */
+    RTSTRICONV_UTF8_TO_FS,
+    /** The filesystem codeset to UTF-8. */
+    RTSTRICONV_FS_TO_UTF8,
+    /** The end of the valid indexes. */
+    RTSTRICONV_END
+} RTSTRICONV;
+
+int rtStrConvert(const char *pchInput, size_t cchInput, const char *pszInputCS,
+                 char **ppszOutput, size_t cbOutput, const char *pszOutputCS,
+                 unsigned cFactor, RTSTRICONV enmCacheIdx);
+const char *rtStrGetLocaleCodeset(void);
+int rtUtf8Length(const char *psz, size_t cch, size_t *pcuc, size_t *pcchActual);
 
 RT_C_DECLS_END

trunk/src/VBox/Runtime/include/internal/thread.h

@@ -37 +37 @@
 #include "internal/lockvalidator.h"
 #include "internal/magics.h"
+#ifdef RT_WITH_ICONV_CACHE
+# include "internal/string.h"
+#endif
 
 RT_C_DECLS_BEGIN
-
-
 
 
@@ -97 +98 @@
     RTLOCKVALPERTHREAD      LockValidator;
 #endif /* IN_RING3 */
+#ifdef RT_WITH_ICONV_CACHE
+    /** Handle cache for iconv.
+     * @remarks ASSUMES sizeof(void *) >= sizeof(iconv_t). */
+    void *ahIconvs[RTSTRICONV_END];
+#endif
 #ifdef IPRT_WITH_GENERIC_TLS
     /** The TLS entries for this thread. */

trunk/src/VBox/Runtime/r3/init.cpp

@@ -234 +234 @@
 {
     /*
+     * Init C runtime locale before we do anything that may end up converting
+     * paths or we'll end up using the "C" locale for path conversion.
+     */
+    setlocale(LC_CTYPE, "");
+
+    /*
      * The Process ID.
      */
@@ -309 +315 @@
      * The remainder cannot easily be undone, so it has to go last.
      */
-
-    /* Init C runtime locale. */
-    setlocale(LC_CTYPE, "");
 
     /* Fork and exit callbacks. */

trunk/src/VBox/Runtime/r3/posix/utf8-posix.cpp

@@ -30 +30 @@
 *******************************************************************************/
 #include <iprt/string.h>
+#include "internal/iprt.h"
+
 #include <iprt/alloc.h>
 #include <iprt/assert.h>
@@ -40 +42 @@
 #include <wctype.h>
 
-#ifdef RT_OS_SOLARIS
-# include <langinfo.h>
+#include <langinfo.h>
+
+#include "internal/alignmentchecks.h"
+#ifdef RT_WITH_ICONV_CACHE
+# include "internal/thread.h"
+# include "internal/string.h"
+AssertCompile(sizeof(iconv_t) <= sizeof(void *));
 #endif
 
-#include "internal/alignmentchecks.h"
-
-
-/*******************************************************************************
-*   Internal Functions                                                         *
-*******************************************************************************/
-static int rtstrConvert(const void *pvInput, size_t cbInput, const char *pszInputCS, void **ppvOutput, size_t cbOutput, const char *pszOutputCS, unsigned cFactor);
+
+/**
+ * Gets the codeset of the current locale (LC_CTYPE).
+ *
+ * @returns Pointer to read-only string with the codeset name.
+ */
+const char *rtStrGetLocaleCodeset(void)
+{
+    return nl_langinfo(CODESET);
+}
+
+
+#ifdef RT_WITH_ICONV_CACHE
+
+/**
+ * Initializes the iconv handle cache associated with a thread.
+ *
+ * @param   pThread             The thread in question.
+ */
+void rtStrIconvCacheInit(PRTTHREADINT pThread)
+{
+    for (size_t i = 0; i < RT_ELEMENTS(pThread->ahIconvs); i++)
+        pThread->ahIconvs[i] = (iconv_t)-1;
+}
+
+/**
+ * Destroys the iconv handle cache associated with a thread.
+ *
+ * @param   pThread             The thread in question.
+ */
+void rtStrIconvCacheDestroy(PRTTHREADINT pThread)
+{
+    for (size_t i = 0; i < RT_ELEMENTS(pThread->ahIconvs); i++)
+    {
+        iconv_t hIconv = pThread->ahIconvs[i];
+        pThread->ahIconvs[i] = NULL;
+        if (hIconv != (iconv_t)-1)
+            iconv_close(hIconv);
+    }
+}
 
 
@@ -66 +106 @@
  * @param   pszOutputCS     Codeset of the input string.
  * @param   cFactor         Input vs. output size factor.
- */
-static int rtstrConvert(const void *pvInput, size_t cbInput, const char *pszInputCS, void **ppvOutput, size_t cbOutput, const char *pszOutputCS, unsigned cFactor)
+ * @param   phIconv         Pointer to the cache entry.
+ */
+static int rtstrConvertCached(const void *pvInput, size_t cbInput, const char *pszInputCS,
+                              void **ppvOutput, size_t cbOutput, const char *pszOutputCS,
+                              unsigned cFactor, iconv_t *phIconv)
+{
+    /*
+     * Allocate buffer
+     */
+    bool    fUcs2Term;
+    void   *pvOutput;
+    size_t  cbOutput2;
+    if (!cbOutput)
+    {
+        cbOutput2 = cbInput * cFactor;
+        pvOutput = RTMemTmpAlloc(cbOutput2 + sizeof(RTUTF16));
+        if (!pvOutput)
+            return VERR_NO_TMP_MEMORY;
+        fUcs2Term = true;
+    }
+    else
+    {
+        pvOutput = *ppvOutput;
+        fUcs2Term = !strcmp(pszOutputCS, "UCS-2")
+                 || !strcmp(pszOutputCS, "UTF-16")
+                 || !strcmp(pszOutputCS, "ucs-2")
+                 || !strcmp(pszOutputCS, "utf-16");
+        cbOutput2 = cbOutput - (fUcs2Term ? sizeof(RTUTF16) : 1);
+        if (cbOutput2 > cbOutput)
+            return VERR_BUFFER_OVERFLOW;
+    }
+
+    /*
+     * Use a loop here to retry with bigger buffers.
+     */
+    for (unsigned cTries = 10; cTries > 0; cTries--)
+    {
+        /*
+         * Create conversion object if necessary.
+         */
+        iconv_t hIconv = (iconv_t)*phIconv;
+        if (hIconv == (iconv_t)-1)
+        {
+            IPRT_ALIGNMENT_CHECKS_DISABLE(); /* glibc causes trouble */
+            *phIconv = hIconv = iconv_open(pszOutputCS, pszInputCS);
+            IPRT_ALIGNMENT_CHECKS_ENABLE();
+        }
+        if (hIconv != (iconv_t)-1)
+        {
+            /*
+             * Do the conversion.
+             */
+            size_t      cbInLeft = cbInput;
+            size_t      cbOutLeft = cbOutput2;
+            const void *pvInputLeft = pvInput;
+            void       *pvOutputLeft = pvOutput;
+#if defined(RT_OS_LINUX) || (defined(RT_OS_DARWIN) && defined(_DARWIN_FEATURE_UNIX_CONFORMANCE)) /* there are different opinions about the constness of the input buffer. */
+            if (iconv(hIconv, (char **)&pvInputLeft, &cbInLeft, (char **)&pvOutputLeft, &cbOutLeft) != (size_t)-1)
+#else
+            if (iconv(hIconv, (const char **)&pvInputLeft, &cbInLeft, (char **)&pvOutputLeft, &cbOutLeft) != (size_t)-1)
+#endif
+            {
+                if (!cbInLeft)
+                {
+                    /*
+                     * We're done, just add the terminator and return.
+                     * (Two terminators to support UCS-2 output, too.)
+                     */
+                    ((char *)pvOutputLeft)[0] = '\0';
+                    if (fUcs2Term)
+                        ((char *)pvOutputLeft)[1] = '\0';
+                    *ppvOutput = pvOutput;
+                    return VINF_SUCCESS;
+                }
+                errno = E2BIG;
+            }
+
+            /*
+             * If we failed because of output buffer space we'll
+             * increase the output buffer size and retry.
+             */
+            if (errno == E2BIG)
+            {
+                if (!cbOutput)
+                {
+                    RTMemTmpFree(pvOutput);
+                    cbOutput2 *= 2;
+                    pvOutput = RTMemTmpAlloc(cbOutput2 + sizeof(RTUTF16));
+                    if (!pvOutput)
+                        return VERR_NO_TMP_MEMORY;
+                    continue;
+                }
+                return VERR_BUFFER_OVERFLOW;
+            }
+
+            /*
+             * Close the handle on all other errors to make sure we won't carry
+             * any bad state with us.
+             */
+            *phIconv = (iconv_t)-1;
+            iconv_close(hIconv);
+        }
+        break;
+    }
+
+    /* failure */
+    if (!cbOutput)
+        RTMemTmpFree(pvOutput);
+    return VERR_NO_TRANSLATION;
+}
+
+#endif /* RT_WITH_ICONV_CACHE */
+
+/**
+ * Converts a string from one charset to another without using the handle cache.
+ *
+ * @returns IPRT status code.
+ *
+ * @param   pvInput         Pointer to intput string.
+ * @param   cbInput         Size (in bytes) of input string. Excludes any terminators.
+ * @param   pszInputCS      Codeset of the input string.
+ * @param   ppvOutput       Pointer to pointer to output buffer if cbOutput > 0.
+ *                          If cbOutput is 0 this is where the pointer to the allocated
+ *                          buffer is stored.
+ * @param   cbOutput        Size of the passed in buffer.
+ * @param   pszOutputCS     Codeset of the input string.
+ * @param   cFactor         Input vs. output size factor.
+ */
+static int rtStrConvertUncached(const void *pvInput, size_t cbInput, const char *pszInputCS,
+                                void **ppvOutput, size_t cbOutput, const char *pszOutputCS,
+                                unsigned cFactor)
 {
     /*
@@ -103 +272 @@
         /* Solaris doesn't grok empty codeset strings, so help it find the current codeset. */
         if (!*pszInputCS)
-            pszInputCS = nl_langinfo(CODESET);
+            pszInputCS = rtStrGetLocaleCodeset();
         if (!*pszOutputCS)
-            pszOutputCS = nl_langinfo(CODESET);
+            pszOutputCS = rtStrGetLocaleCodeset();
 #endif
         IPRT_ALIGNMENT_CHECKS_DISABLE(); /* glibc causes trouble */
@@ -171 +340 @@
 
 /**
+ * Wrapper that selects rtStrConvertCached or rtStrConvertUncached.
+ *
+ * @returns IPRT status code.
+ *
+ * @param   pszInput        Pointer to intput string.
+ * @param   cchInput        Size (in bytes) of input string. Excludes any
+ *                          terminators.
+ * @param   pszInputCS      Codeset of the input string.
+ * @param   ppszOutput      Pointer to pointer to output buffer if cbOutput > 0.
+ *                          If cbOutput is 0 this is where the pointer to the
+ *                          allocated buffer is stored.
+ * @param   cbOutput        Size of the passed in buffer.
+ * @param   pszOutputCS     Codeset of the input string.
+ * @param   cFactor         Input vs. output size factor.
+ * @param   enmCacheIdx     The iconv cache index.
+ */
+DECLINLINE(int) rtStrConvertWrapper(const char *pchInput, size_t cchInput, const char *pszInputCS,
+                                    char **ppszOutput, size_t cbOutput, const char *pszOutputCS,
+                                    unsigned cFactor, RTSTRICONV enmCacheIdx)
+{
+#ifdef RT_WITH_ICONV_CACHE
+    RTTHREAD hSelf = RTThreadSelf();
+    if (hSelf != NIL_RTTHREAD)
+    {
+        PRTTHREADINT pThread = rtThreadGet(hSelf);
+        if (   pThread
+            && (pThread->fIntFlags & (RTTHREADINT_FLAGS_ALIEN | RTTHREADINT_FLAGS_MAIN)) != RTTHREADINT_FLAGS_ALIEN)
+            return rtstrConvertCached(pchInput, cchInput, pszInputCS,
+                                      (void **)ppszOutput, cbOutput, pszOutputCS,
+                                      cFactor, &pThread->ahIconvs[enmCacheIdx]);
+    }
+#endif
+    return rtStrConvertUncached(pchInput, cchInput, pszInputCS,
+                                (void **)ppszOutput, cbOutput, pszOutputCS,
+                                cFactor);
+}
+
+
+/**
+ * Internal API for use by the path conversion code.
+ *
+ * @returns IPRT status code.
+ *
+ * @param   pszInput        Pointer to intput string.
+ * @param   cchInput        Size (in bytes) of input string. Excludes any
+ *                          terminators.
+ * @param   pszInputCS      Codeset of the input string.
+ * @param   ppszOutput      Pointer to pointer to output buffer if cbOutput > 0.
+ *                          If cbOutput is 0 this is where the pointer to the
+ *                          allocated buffer is stored.
+ * @param   cbOutput        Size of the passed in buffer.
+ * @param   pszOutputCS     Codeset of the input string.
+ * @param   cFactor         Input vs. output size factor.
+ * @param   enmCacheIdx     The iconv cache index.
+ */
+int rtStrConvert(const char *pchInput, size_t cchInput, const char *pszInputCS,
+                 char **ppszOutput, size_t cbOutput, const char *pszOutputCS,
+                 unsigned cFactor, RTSTRICONV enmCacheIdx)
+{
+    Assert(enmCacheIdx >= 0 && enmCacheIdx < RTSTRICONV_END);
+    return rtStrConvertWrapper(pchInput, cchInput, pszInputCS,
+                               ppszOutput, cbOutput, pszOutputCS,
+                               cFactor, enmCacheIdx);
+}
+
+
+/**
  * Allocates tmp buffer, translates pszString from UTF8 to current codepage.
  *
@@ -196 +432 @@
         return VERR_NO_TMP_MEMORY;
     }
-    return rtstrConvert(pszString, cch, "UTF-8", (void **)ppszString, 0, "", 1);
+    return rtStrConvertWrapper(pszString, cch, "UTF-8", ppszString, 0, "", 1, RTSTRICONV_UTF8_TO_LOCALE);
 }
 
@@ -215 +451 @@
 
     /*
-     * Attempt with UTF-8 length of 2x the native lenght.
+     * Attempt with UTF-8 length of 2x the native length.
      */
     size_t cch = strlen(pszString);
@@ -226 +462 @@
         return VERR_NO_TMP_MEMORY;
     }
-    return rtstrConvert(pszString, cch, "", (void **)ppszString, 0, "UTF-8", 2);
-}
-
+    return rtStrConvertWrapper(pszString, cch, "", ppszString, 0, "UTF-8", 2, RTSTRICONV_LOCALE_TO_UTF8);
+}
+