Changeset 60481 in vbox

Timestamp:

Apr 13, 2016 8:14:41 PM (8 years ago)

Author:

vboxsync

Message:

IPRT: Added testcase for RTNtPathExpand8dot3Path and RTNtPathFindPossible8dot3Name, fixing bug in the former. include\ src\VBox\Runtime\

Location:

trunk

Files:

• include/iprt/mangling.h (modified) (3 diffs)
• include/iprt/utf16.h (modified) (3 diffs)
• src/VBox/Runtime/common/string/utf-16-case.cpp (modified) (1 diff)
• src/VBox/Runtime/common/string/utf-16.cpp (modified) (2 diffs)
• src/VBox/Runtime/nt/RTNtPathExpand8dot3Path.cpp (modified) (1 diff)
• src/VBox/Runtime/nt/RTNtPathFindPossible8dot3Name.cpp (added)
• src/VBox/Runtime/r3/nt/pathint-nt.cpp (modified) (4 diffs)
• src/VBox/Runtime/testcase/Makefile.kmk (modified) (2 diffs)
• src/VBox/Runtime/testcase/tstRTNtPath-1.cpp (added)

trunk/include/iprt/mangling.h

@@ -2194 +2194 @@
 # define RTUriIsSchemeMatch                             RT_MANGLER(RTUriIsSchemeMatch)
 # define RTUtf16AllocTag                                RT_MANGLER(RTUtf16AllocTag)
+# define RTUtf16ReallocTag                              RT_MANGLER(RTUtf16ReallocTag)
 # define RTUtf16CalcLatin1Len                           RT_MANGLER(RTUtf16CalcLatin1Len)
 # define RTUtf16CalcLatin1LenEx                         RT_MANGLER(RTUtf16CalcLatin1LenEx)
@@ -2200 +2201 @@
 # define RTUtf16Cmp                                     RT_MANGLER(RTUtf16Cmp)
 # define RTUtf16CmpAscii                                RT_MANGLER(RTUtf16CmpAscii)
+# define RTUtf16CmpUtf8                                 RT_MANGLER(RTUtf16CmpUtf8)
 # define RTUtf16DupExTag                                RT_MANGLER(RTUtf16DupExTag)
 # define RTUtf16DupTag                                  RT_MANGLER(RTUtf16DupTag)
@@ -2206 +2208 @@
 # define RTUtf16GetCpInternal                           RT_MANGLER(RTUtf16GetCpInternal)
 # define RTUtf16ICmp                                    RT_MANGLER(RTUtf16ICmp)
+# define RTUtf16ICmpUtf8                                RT_MANGLER(RTUtf16ICmpUtf8)
 # define RTUtf16IsValidEncoding                         RT_MANGLER(RTUtf16IsValidEncoding)
 # define RTUtf16Len                                     RT_MANGLER(RTUtf16Len)

trunk/include/iprt/utf16.h

@@ -82 +82 @@
 RTDECL(PRTUTF16) RTUtf16AllocTag(size_t cb, const char *pszTag);
 
+/**
+ * Reallocates the specified UTF-16 string (default tag).
+ *
+ * You should normally not use this function, except if there is some very
+ * custom string handling you need doing that isn't covered by any of the other
+ * APIs.
+ *
+ * @returns VINF_SUCCESS.
+ * @retval  VERR_NO_UTF16_MEMORY if we failed to reallocate the string, @a
+ *          *ppwsz remains unchanged.
+ *
+ * @param   ppwsz               Pointer to the string variable containing the
+ *                              input and output string.
+ *
+ *                              When not freeing the string, the result will
+ *                              always have the last RTUTF16 set to the
+ *                              terminator character so that when used for
+ *                              string truncation the result will be a valid
+ *                              C-style string (your job to keep it a valid
+ *                              UTF-16 string).
+ *
+ *                              When the input string is NULL and we're supposed
+ *                              to reallocate, the returned string will also
+ *                              have the first RTUTF16 set to the terminator
+ *                              char so it will be a valid C-style string.
+ *
+ * @param   cbNew               When @a cbNew is zero, we'll behave like
+ *                              RTUtf16Free and @a *ppwsz will be set to NULL.
+ *
+ *                              When not zero, this will be rounded up to a
+ *                              multiple of two, and used as the new size of the
+ *                              memory backing the string, i.e. it includes the
+ *                              terminator (RTUTF16) char.
+ */
+#define RTUtf16Realloc(ppwsz, cb)       RTUtf16ReallocTag((ppwsz), (cb), RTSTR_TAG)
+
+/**
+ * Reallocates the specified UTF-16 string (custom tag).
+ *
+ * You should normally not use this function, except if there is some very
+ * custom string handling you need doing that isn't covered by any of the other
+ * APIs.
+ *
+ * @returns VINF_SUCCESS.
+ * @retval  VERR_NO_UTF16_MEMORY if we failed to reallocate the string, @a
+ *          *ppwsz remains unchanged.
+ *
+ * @param   ppwsz               Pointer to the string variable containing the
+ *                              input and output string.
+ *
+ *                              When not freeing the string, the result will
+ *                              always have the last RTUTF16 set to the
+ *                              terminator character so that when used for
+ *                              string truncation the result will be a valid
+ *                              C-style string (your job to keep it a valid
+ *                              UTF-16 string).
+ *
+ *                              When the input string is NULL and we're supposed
+ *                              to reallocate, the returned string will also
+ *                              have the first RTUTF16 set to the terminator
+ *                              char so it will be a valid C-style string.
+ *
+ * @param   cbNew               When @a cbNew is zero, we'll behave like
+ *                              RTUtf16Free and @a *ppwsz will be set to NULL.
+ *
+ *                              When not zero, this will be rounded up to a
+ *                              multiple of two, and used as the new size of the
+ *                              memory backing the string, i.e. it includes the
+ *                              terminator (RTUTF16) char.
+ * @param   pszTag              Allocation tag used for statistics and such.
+ */
+RTDECL(int) RTUtf16ReallocTag(PRTUTF16 *ppwsz, size_t cbNew, const char *pszTag);
 
 /**
@@ -333 +405 @@
 
 /**
+ * Performs a case sensitive string compare between an UTF-16 string and a UTF-8
+ * string.
+ *
+ * @returns < 0 if the first string less than the second string.s
+ * @returns 0 if the first string identical to the second string.
+ * @returns > 0 if the first string greater than the second string.
+ * @param   pwsz1       First UTF-16 string. Null is allowed.
+ * @param   psz2        Second string, UTF-8. Null is allowed.
+ * @remarks NULL and empty strings are treated equally.
+ */
+RTDECL(int) RTUtf16CmpUtf8(PCRTUTF16 pwsz1, const char *psz2);
+
+/**
  * Performs a case insensitive string compare between two UTF-16 strings.
  *
@@ -346 +431 @@
  */
 RTDECL(int) RTUtf16ICmp(PCRTUTF16 pwsz1, PCRTUTF16 pwsz2);
+
+/**
+ * Performs a case insensitive string compare between an UTF-16 string and a
+ * UTF-8 string.
+ *
+ * @returns < 0 if the first string less than the second string.s
+ * @returns 0 if the first string identical to the second string.
+ * @returns > 0 if the first string greater than the second string.
+ * @param   pwsz1       First UTF-16 string. Null is allowed.
+ * @param   psz2        Second string, UTF-8. Null is allowed.
+ * @remarks NULL and empty strings are treated equally.
+ */
+RTDECL(int) RTUtf16ICmpUtf8(PCRTUTF16 pwsz1, const char *psz2);
 
 /**

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

@@ -106 +106 @@
 
 
+RTDECL(int) RTUtf16ICmpUtf8(PCRTUTF16 pwsz1, const char *psz2)
+{
+    /*
+     * NULL and empty strings are all the same.
+     */
+    if (!pwsz1)
+        return !psz2 || !*psz2 ? 0 : -1;
+    if (!psz2)
+        return !*pwsz1         ? 0 :  1;
+
+    /*
+     * Compare with a UTF-8 string by enumerating them char by char.
+     */
+    for (;;)
+    {
+        RTUNICP uc1;
+        int rc = RTUtf16GetCpEx(&pwsz1, &uc1);
+        AssertRCReturn(rc, 1);
+
+        RTUNICP uc2;
+        rc = RTStrGetCpEx(&psz2, &uc2);
+        AssertRCReturn(rc, -1);
+        if (uc1 == uc2)
+        {
+            if (uc1)
+                continue;
+            return 0;
+        }
+
+        if (RTUniCpToUpper(uc1) == RTUniCpToUpper(uc2))
+            continue;
+        if (RTUniCpToLower(uc1) == RTUniCpToLower(uc2))
+            continue;
+        return uc1 < uc2 ? -1 : 1;
+    }
+}
+RT_EXPORT_SYMBOL(RTUtf16CmpIUtf8);
+
+
 RTDECL(PRTUTF16) RTUtf16ToLower(PRTUTF16 pwsz)
 {

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

@@ -114 +114 @@
 
 
+RTDECL(int) RTUtf16ReallocTag(PRTUTF16 *ppwsz, size_t cbNew, const char *pszTag)
+{
+    PRTUTF16 pwszOld = *ppwsz;
+    cbNew = RT_ALIGN_Z(cbNew, sizeof(RTUTF16));
+    if (!cbNew)
+    {
+        RTMemFree(pwszOld);
+        *ppwsz = NULL;
+    }
+    else if (pwszOld)
+    {
+        PRTUTF16 pwszNew = (PRTUTF16)RTMemReallocTag(pwszOld, cbNew, pszTag);
+        if (!pwszNew)
+            return VERR_NO_STR_MEMORY;
+        pwszNew[cbNew / sizeof(RTUTF16) - 1] = '\0';
+        *ppwsz = pwszNew;
+    }
+    else
+    {
+        PRTUTF16 pwszNew = (PRTUTF16)RTMemAllocTag(cbNew, pszTag);
+        if (!pwszNew)
+            return VERR_NO_UTF16_MEMORY;
+        pwszNew[0] = '\0';
+        pwszNew[cbNew / sizeof(RTUTF16) - 1] = '\0';
+        *ppwsz = pwszNew;
+    }
+    return VINF_SUCCESS;
+}
+RT_EXPORT_SYMBOL(RTUtf16ReallocTag);
+
+
 RTDECL(void)  RTUtf16Free(PRTUTF16 pwszString)
 {
@@ -183 +214 @@
 }
 RT_EXPORT_SYMBOL(RTUtf16Cmp);
+
+
+RTDECL(int) RTUtf16CmpUtf8(PCRTUTF16 pwsz1, const char *psz2)
+{
+    /*
+     * NULL and empty strings are all the same.
+     */
+    if (!pwsz1)
+        return !psz2 || !*psz2 ? 0 : -1;
+    if (!psz2)
+        return !*pwsz1         ? 0 :  1;
+
+    /*
+     * Compare with a UTF-8 string by enumerating them char by char.
+     */
+    for (;;)
+    {
+        RTUNICP uc1;
+        int rc = RTUtf16GetCpEx(&pwsz1, &uc1);
+        AssertRCReturn(rc, 1);
+
+        RTUNICP uc2;
+        rc = RTStrGetCpEx(&psz2, &uc2);
+        AssertRCReturn(rc, -1);
+        if (uc1 == uc2)
+        {
+            if (uc1)
+                continue;
+            return 0;
+        }
+        return uc1 < uc2 ? -1 : 1;
+    }
+}
+RT_EXPORT_SYMBOL(RTUtf16CmpUtf8);
 
 

trunk/src/VBox/Runtime/nt/RTNtPathExpand8dot3Path.cpp

@@ -158 +158 @@
                     pUniStr->Length += (USHORT)(cwcNameNew * sizeof(WCHAR));
                     pwszFixEnd      -= cwcNameOld;
-                    pwszFixEnd      -= cwcNameNew;
+                    pwszFixEnd      += cwcNameNew;
                     memcpy(pwszFix, &puBuf->Info.FileName[offName], cwcNameNew * sizeof(WCHAR));
                 }

trunk/src/VBox/Runtime/r3/nt/pathint-nt.cpp

@@ -162 +162 @@
 
 /**
- * Converts a path to NT format and encoding.
- *
- * @returns IPRT status code.
- * @param   pNtName             Where to return the NT name.
+ * Converts a windows-style path to NT format and encoding.
+ *
+ * @returns IPRT status code.
+ * @param   pNtName             Where to return the NT name.  Free using
+ *                              rtTNtPathToNative.
  * @param   phRootDir           Where to return the root handle, if applicable.
  * @param   pszPath             The UTF-8 path.
@@ -225 +226 @@
     memcpy(szPath, pszPrefix, cchPrefix);
     return rtNtPathUtf8ToUniStr(pNtName, phRootDir, szPath);
+}
+
+
+/**
+ * Converts a windows-style path to NT format and encoding.
+ *
+ * @returns IPRT status code.
+ * @param   pNtName             Where to return the NT name.  Free using
+ *                              RTNtPathToNative.
+ * @param   phRootDir           Where to return the root handle, if applicable.
+ * @param   pszPath             The UTF-8 path.
+ */
+RTDECL(int) RTNtPathFromWinUtf8(struct _UNICODE_STRING *pNtName, PHANDLE phRootDir, const char *pszPath)
+{
+    return rtNtPathToNative(pNtName, phRootDir, pszPath);
 }
 
@@ -341 +357 @@
 
 /**
+ * Ensures that the NT string has sufficient storage to hold @a cwcMin RTUTF16
+ * chars plus a terminator.
+ *
+ * The NT string must have been returned by RTNtPathFromWinUtf8 or
+ * RTNtPathFromWinUtf16Ex.
+ *
+ * @returns IPRT status code.
+ * @param   pNtName             The NT path string.
+ * @param   cwcMin              The minimum number of RTUTF16 chars. Max 32767.
+ * @sa      RTNtPathFree
+ */
+RTDECL(int) RTNtPathEnsureSpace(struct _UNICODE_STRING *pNtName, size_t cwcMin)
+{
+    if (pNtName->MaximumLength / sizeof(RTUTF16) > cwcMin)
+        return VINF_SUCCESS;
+
+    AssertReturn(cwcMin < _64K / sizeof(RTUTF16), VERR_OUT_OF_RANGE);
+
+    size_t const cbMin = (cwcMin + 1) * sizeof(RTUTF16);
+    int rc = RTUtf16Realloc(&pNtName->Buffer, cbMin);
+    if (RT_SUCCESS(rc))
+        pNtName->MaximumLength = (uint16_t)cbMin;
+    return rc;
+}
+
+
+/**
  * Frees the native path and root handle.
  *
  * @param   pNtName             The NT path after a successful rtNtPathToNative
  *                              call.
- * @param   phRootDir           The root handle variable after a
- *                              rtNtPathToNative.
+ * @param   phRootDir           The root handle variable from the same call.
  */
 static void rtNtPathFreeNative(struct _UNICODE_STRING *pNtName, PHANDLE phRootDir)
@@ -358 +400 @@
  * Frees the native path and root handle.
  *
- * @param   pNtName             The NT path after a successful
- *                              RTNtPathFromWinUtf16Ex call.
- * @param   phRootDir           The root handle variable after a successfull
- *                              RTNtPathFromWinUtf16Ex call.
+ * @param   pNtName             The NT path from a successful RTNtPathToNative
+ *                              or RTNtPathFromWinUtf16Ex call.
+ * @param   phRootDir           The root handle variable from the same call.
  */
 RTDECL(void) RTNtPathFree(struct _UNICODE_STRING *pNtName, HANDLE *phRootDir)

trunk/src/VBox/Runtime/testcase/Makefile.kmk

@@ -152 +152 @@
         tstRTProcWait \
         tstFileAppendWin-1 \
+        tstRTNtPath-1 \
         ntGetTimerResolution
 PROGRAMS.linux += \
@@ -526 +527 @@
         ../common/string/strlen.asm
 
+tstRTNtPath-1_TEMPLATE = VBOXR3TSTEXE
+tstRTNtPath-1_SOURCES = tstRTNtPath-1.cpp
+
 tstOnce_TEMPLATE = VBOXR3TSTEXE
 tstOnce_SOURCES = tstOnce.cpp