WIP

Author: iseki0

core/mingw/src/files/Error.kt

@@ -11,11 +11,12 @@ import platform.windows.FORMAT_MESSAGE_ALLOCATE_BUFFER
 import platform.windows.FORMAT_MESSAGE_FROM_SYSTEM
 import platform.windows.FORMAT_MESSAGE_IGNORE_INSERTS
 import platform.windows.FormatMessageW
+import platform.windows.GetLastError
 import platform.windows.LPWSTRVar
 import platform.windows.LocalFree
 
 @OptIn(ExperimentalForeignApi::class)
-internal fun formatWin32ErrorMessage(code: UInt): String {
+internal fun formatWin32ErrorMessage(code: UInt = GetLastError()): String {
     memScoped {
         val r = alloc<LPWSTRVar>()
         val n = FormatMessageW(
@@ -28,11 +29,11 @@ internal fun formatWin32ErrorMessage(code: UInt): String {
             Arguments = null,
         )
         if (n == 0u) {
-            throw RuntimeException("Error formatting error: $code")
+            return "unknown error (${code.toHexString()})"
         }
-        val s = r.value?.toKString().orEmpty()
+        val s = r.value!!.toKString().trimEnd()
         LocalFree(r.value)
-        return s
+        return "$s (${code.toHexString()})"
     }
 
 }

core/mingw/src/files/FileSystemMingw.kt

@@ -8,57 +8,86 @@
 package kotlinx.io.files
 
 import kotlinx.cinterop.Arena
+import kotlinx.cinterop.CFunction
+import kotlinx.cinterop.CPointed
+import kotlinx.cinterop.CPointer
 import kotlinx.cinterop.ExperimentalForeignApi
 import kotlinx.cinterop.alloc
 import kotlinx.cinterop.allocArray
 import kotlinx.cinterop.convert
-import kotlinx.cinterop.cstr
+import kotlinx.cinterop.invoke
 import kotlinx.cinterop.memScoped
 import kotlinx.cinterop.ptr
+import kotlinx.cinterop.reinterpret
 import kotlinx.cinterop.toKString
+import kotlinx.cinterop.wcstr
 import kotlinx.io.IOException
-import platform.posix.basename
-import platform.posix.dirname
-import platform.posix.errno
-import platform.posix.mkdir
-import platform.posix.strerror
+import platform.posix.size_t
 import platform.windows.CloseHandle
+import platform.windows.CreateDirectoryW
 import platform.windows.ERROR_FILE_NOT_FOUND
 import platform.windows.ERROR_NO_MORE_FILES
+import platform.windows.FALSE
 import platform.windows.FindClose
 import platform.windows.FindFirstFileW
 import platform.windows.FindNextFileW
 import platform.windows.GetFullPathNameW
 import platform.windows.GetLastError
+import platform.windows.GetProcAddress
 import platform.windows.HANDLE
+import platform.windows.HMODULE
+import platform.windows.HRESULT
 import platform.windows.INVALID_HANDLE_VALUE
+import platform.windows.LoadLibraryW
+import platform.windows.MAX_PATH
 import platform.windows.MOVEFILE_REPLACE_EXISTING
-import platform.windows.MoveFileExA
+import platform.windows.MoveFileExW
+import platform.windows.PWSTR
+import platform.windows.PathFindFileNameW
 import platform.windows.PathIsRelativeW
+import platform.windows.PathIsRootW
 import platform.windows.TRUE
 import platform.windows.WCHARVar
 import platform.windows.WIN32_FIND_DATAW
+import kotlin.experimental.ExperimentalNativeApi
+
+private typealias PathCchRemoveFileSpecFunc = CPointer<CFunction<(PWSTR, size_t) -> HRESULT>>
+
+@OptIn(ExperimentalNativeApi::class)
+private val kernelBaseDll = LoadLibraryW("kernelbase.dll") ?: run {
+    terminateWithUnhandledException(RuntimeException("kernelbase_dll is not supported: ${formatWin32ErrorMessage()}"))
+}
+
+@OptIn(ExperimentalNativeApi::class)
+private fun <T : CPointed> getProcAddressOrFailed(module: HMODULE, name: String): CPointer<T> {
+    val pointer = GetProcAddress(kernelBaseDll, "PathCchRemoveFileSpec") ?: terminateWithUnhandledException(
+        UnsupportedOperationException("Failed to get proc: $name: ${formatWin32ErrorMessage()}"),
+    )
+    return pointer.reinterpret()
+}
+
+// Available since Windows 8 / Windows Server 2012, long path and UNC path supported
+private val PathCchRemoveFileSpec: PathCchRemoveFileSpecFunc =
+    getProcAddressOrFailed(kernelBaseDll, "PathCchRemoveFileSpec")
 
 internal actual fun atomicMoveImpl(source: Path, destination: Path) {
-    if (MoveFileExA(source.path, destination.path, MOVEFILE_REPLACE_EXISTING.convert()) == 0) {
-        // TODO: get formatted error message
-        throw IOException("Move failed with error code: ${GetLastError()}")
+    if (MoveFileExW(source.path, destination.path, MOVEFILE_REPLACE_EXISTING.convert()) == 0) {
+        throw IOException("Move failed with error code: ${formatWin32ErrorMessage()}")
     }
 }
 
 internal actual fun dirnameImpl(path: String): String {
-    if (!path.contains(UnixPathSeparator) && !path.contains(WindowsPathSeparator)) {
-        return ""
-    }
     memScoped {
-        return dirname(path.cstr.ptr)?.toKString() ?: ""
+        val p = path.wcstr.ptr
+        // we don't care the result, even it failed.
+        PathCchRemoveFileSpec.invoke(p, path.length.convert())
+        return p.toKString()
     }
 }
 
 internal actual fun basenameImpl(path: String): String {
-    memScoped {
-        return basename(path.cstr.ptr)?.toKString() ?: ""
-    }
+    if (PathIsRootW(path)  == TRUE) return ""
+    return PathFindFileNameW(path)?.toKString() ?: ""
 }
 
 internal actual fun isAbsoluteImpl(path: String): Boolean {
@@ -72,39 +101,46 @@ internal actual fun isAbsoluteImpl(path: String): Boolean {
 }
 
 internal actual fun mkdirImpl(path: String) {
-    if (mkdir(path) != 0) {
-        throw IOException("mkdir failed: ${strerror(errno)?.toKString()}")
+    if (CreateDirectoryW(path, null) == FALSE) {
+        throw IOException("mkdir failed: $path: ${formatWin32ErrorMessage()}")
     }
 }
 
-private const val MAX_PATH_LENGTH = 32767
-
 internal actual fun realpathImpl(path: String): String {
     memScoped {
-        val buffer = allocArray<WCHARVar>(MAX_PATH_LENGTH)
-        val len = GetFullPathNameW(path, MAX_PATH_LENGTH.convert(), buffer, null)
-        if (len == 0u) throw IllegalStateException()
-        return buffer.toKString()
+        // in practice, MAX_PATH is enough for most cases
+        var buf = allocArray<WCHARVar>(MAX_PATH)
+        var r = GetFullPathNameW(path, MAX_PATH.convert(), buf, null)
+        if (r >= MAX_PATH.toUInt()) {
+            // if not, we will retry with the required size
+            buf = allocArray<WCHARVar>(r.toInt())
+            r = GetFullPathNameW(path, r, buf, null)
+        }
+        if (r == 0u) {
+            error("GetFullPathNameW failed for $path: ${formatWin32ErrorMessage()}")
+        }
+        return buf.toKString()
     }
 }
 
-internal actual class OpaqueDirEntry(directory: String) : AutoCloseable {
+internal actual class OpaqueDirEntry(private val directory: String) : AutoCloseable {
     private val arena = Arena()
     private val data = arena.alloc<WIN32_FIND_DATAW>()
     private var handle: HANDLE? = INVALID_HANDLE_VALUE
     private var firstName: String? = null
 
     init {
         try {
-            val directory0 = if (directory.endsWith('/') || directory.endsWith('\\')) "$directory*" else "$directory/*"
+            // since the root
+            val directory0 =
+                if (directory.endsWith(UnixPathSeparator) || directory.endsWith(WindowsPathSeparator)) "$directory*" else "$directory/*"
             handle = FindFirstFileW(directory0, data.ptr)
             if (handle != INVALID_HANDLE_VALUE) {
                 firstName = data.cFileName.toKString()
             } else {
-                val le = GetLastError()
-                if (le != ERROR_FILE_NOT_FOUND.toUInt()) {
-                    val strerr = formatWin32ErrorMessage(le)
-                    throw IOException("Can't open directory $directory: $le ($strerr)")
+                val e = GetLastError()
+                if (e != ERROR_FILE_NOT_FOUND.toUInt()) {
+                    throw IOException("Can't open directory $directory: ${formatWin32ErrorMessage(e)}")
                 }
             }
         } catch (th: Throwable) {
@@ -130,8 +166,7 @@ internal actual class OpaqueDirEntry(directory: String) : AutoCloseable {
         if (le == ERROR_NO_MORE_FILES.toUInt()) {
             return null
         }
-        val strerr = formatWin32ErrorMessage(le)
-        throw IOException("Can't readdir: $le ($strerr)")
+        throw IOException("Can't readdir from $directory: ${formatWin32ErrorMessage(le)}")
     }
 
     actual override fun close() {

core/mingw/test/files/SmokeFileTestWindowsMinGW.kt

@@ -5,13 +5,76 @@
 
 package kotlinx.io.files
 
+import kotlinx.cinterop.ExperimentalForeignApi
+import kotlinx.cinterop.cstr
+import kotlinx.cinterop.toKString
+import platform.posix.dirname
+import platform.windows.ERROR_TOO_MANY_OPEN_FILES
 import kotlin.test.Test
 import kotlin.test.assertEquals
+import kotlin.test.assertFails
+
+class SmokeFileTestWindowsMinGW {
+    @OptIn(ExperimentalForeignApi::class)
+    @Test
+    fun mingwProblem() {
+        assertEquals("""C:\foo""", dirname("""C:\foo\bar""".cstr)!!.toKString())
+        assertFails {
+            assertEquals(
+                """C:\あいうえお""",
+                dirname("""C:\あいうえお\かきくけこ""".cstr)!!.toKString(),
+            )
+        }.let(::println)
+        assertFails {
+            assertEquals(
+                """C:\一二三四""",
+                dirname("""C:\一二三四\五六七八""".cstr)!!.toKString(),
+            )
+        }.let(::println)
+    }
+
+    @Test
+    fun parent() {
+        assertEquals(Path("""C:\foo"""), Path("""C:\foo\bar""").parent)
+        assertEquals(Path("""C:\あいうえお"""), Path("""C:\あいうえお\かきくけこ""").parent)
+        assertEquals(Path("""C:\一二三四"""), Path("""C:\一二三四\五六七八""").parent)
+        assertEquals(null, Path("""C:\""").parent)
+    }
 
-class SmokeFileTestWindowsMinGW  {
     @Test
     fun uncParent() {
-        assertEquals(Path("\\\\server"), Path("\\\\server\\share").parent)
-        assertEquals(Path("\\\\server\\share"), Path("\\\\server\\share\\dir").parent)
+        assertEquals(Path("""\\server\share"""), Path("""\\server\share\dir""").parent)
+        // This is a root UNC path, so parent is
+        assertEquals(null, Path("""\\server\share""").parent)
+    }
+
+    @Test
+    fun basename(){
+        assertEquals("あいうえお", Path("""C:\あいうえお""").name)
+        assertEquals("", Path("""C:\""").name)
+    }
+
+
+    @Test
+    fun isAbs() {
+        assertEquals(true, Path("""C:\foo""").isAbsolute, """C:\foo""")
+        assertEquals(false, Path("""foo\bar""").isAbsolute, """foo\bar""")
+        assertEquals(true, Path("""\foo\bar""").isAbsolute, """\foo\bar""")
+        assertEquals(true, Path("""C:\""").isAbsolute, """C:\""")
+        assertEquals(true, Path("""\\server\share\dir""").isAbsolute, """\\server\share\dir""")
+    }
+
+    @Test
+    fun testFormatError() {
+        val s = formatWin32ErrorMessage(ERROR_TOO_MANY_OPEN_FILES.toUInt())
+        // it should be trimmed, drop the trailing rubbish
+        assertEquals(s.trim(), s.trim())
+    }
+
+    @Test
+    fun testReadDir() {
+        val expected = listOf("foo", "いろは歌", "天地玄黄")
+        val actual = SystemFileSystem.list(Path("""./mingw/testdir""")).map { it.name }.sorted()
+        assertEquals(expected, actual)
     }
 }