1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
|
/*
* Copyright (C) 2021 Square, Inc.
*
* 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.
*/
package okio
import kotlinx.cinterop.CValuesRef
import kotlinx.cinterop.IntVar
import kotlinx.cinterop.addressOf
import kotlinx.cinterop.alloc
import kotlinx.cinterop.memScoped
import kotlinx.cinterop.ptr
import kotlinx.cinterop.usePinned
import kotlinx.cinterop.value
import platform.windows.CloseHandle
import platform.windows.ERROR_HANDLE_EOF
import platform.windows.FILE_BEGIN
import platform.windows.FlushFileBuffers
import platform.windows.GetFileSizeEx
import platform.windows.GetLastError
import platform.windows.HANDLE
import platform.windows.LARGE_INTEGER
import platform.windows.ReadFile
import platform.windows.SetEndOfFile
import platform.windows.SetFilePointer
import platform.windows.WriteFile
import platform.windows._OVERLAPPED
internal class WindowsFileHandle(
readWrite: Boolean,
private val file: HANDLE?,
) : FileHandle(readWrite) {
override fun protectedSize(): Long {
memScoped {
val result = alloc<LARGE_INTEGER>()
if (GetFileSizeEx(file, result.ptr) == 0) {
throw lastErrorToIOException()
}
return result.toLong()
}
}
override fun protectedRead(
fileOffset: Long,
array: ByteArray,
arrayOffset: Int,
byteCount: Int,
): Int {
val bytesRead = if (array.isNotEmpty()) {
array.usePinned { pinned ->
variantPread(pinned.addressOf(arrayOffset), byteCount, fileOffset)
}
} else {
0
}
if (bytesRead == 0) return -1
return bytesRead
}
fun variantPread(
target: CValuesRef<*>,
byteCount: Int,
offset: Long,
): Int {
memScoped {
val overlapped = alloc<_OVERLAPPED>()
overlapped.Offset = offset.toUInt()
overlapped.OffsetHigh = (offset ushr 32).toUInt()
val readFileResult = ReadFile(
hFile = file,
lpBuffer = target.getPointer(this),
nNumberOfBytesToRead = byteCount.toUInt(),
lpNumberOfBytesRead = null,
lpOverlapped = overlapped.ptr,
)
if (readFileResult == 0 && GetLastError().toInt() != ERROR_HANDLE_EOF) {
throw lastErrorToIOException()
}
return overlapped.InternalHigh.toInt()
}
}
override fun protectedWrite(
fileOffset: Long,
array: ByteArray,
arrayOffset: Int,
byteCount: Int,
) {
val bytesWritten = if (array.isNotEmpty()) {
array.usePinned { pinned ->
variantPwrite(pinned.addressOf(arrayOffset), byteCount, fileOffset)
}
} else {
0
}
if (bytesWritten != byteCount) throw IOException("bytesWritten=$bytesWritten")
}
fun variantPwrite(
source: CValuesRef<*>,
byteCount: Int,
offset: Long,
): Int {
memScoped {
val overlapped = alloc<_OVERLAPPED>()
overlapped.Offset = offset.toUInt()
overlapped.OffsetHigh = (offset ushr 32).toUInt()
val writeFileResult = WriteFile(
hFile = file,
lpBuffer = source.getPointer(this),
nNumberOfBytesToWrite = byteCount.toUInt(),
lpNumberOfBytesWritten = null,
lpOverlapped = overlapped.ptr,
)
if (writeFileResult == 0) {
throw lastErrorToIOException()
}
return overlapped.InternalHigh.toInt()
}
}
override fun protectedFlush() {
if (FlushFileBuffers(file) == 0) {
throw lastErrorToIOException()
}
}
override fun protectedResize(size: Long) {
memScoped {
val distanceToMoveHigh = alloc<IntVar>()
distanceToMoveHigh.value = (size ushr 32).toInt()
val movePointerResult = SetFilePointer(
hFile = file,
lDistanceToMove = size.toInt(),
lpDistanceToMoveHigh = distanceToMoveHigh.ptr,
dwMoveMethod = FILE_BEGIN.toUInt(),
)
if (movePointerResult == 0U) {
throw lastErrorToIOException()
}
if (SetEndOfFile(file) == 0) {
throw lastErrorToIOException()
}
}
}
override fun protectedClose() {
if (CloseHandle(file) == 0) {
throw lastErrorToIOException()
}
}
private fun LARGE_INTEGER.toLong(): Long {
return (HighPart.toLong() shl 32) + (LowPart.toLong() and 0xffffffffL)
}
}
|
