author | igerasim |
Tue, 28 Oct 2014 15:36:27 +0300 | |
changeset 27263 | 819f5f87d485 |
parent 27184 | 2996674bd701 |
child 34890 | 0e8281ef3550 |
permissions | -rw-r--r-- |
2 | 1 |
/* |
27184 | 2 |
* Copyright (c) 2001, 2014, Oracle and/or its affiliates. All rights reserved. |
2 | 3 |
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
4 |
* |
|
5 |
* This code is free software; you can redistribute it and/or modify it |
|
6 |
* under the terms of the GNU General Public License version 2 only, as |
|
5506 | 7 |
* published by the Free Software Foundation. Oracle designates this |
2 | 8 |
* particular file as subject to the "Classpath" exception as provided |
5506 | 9 |
* by Oracle in the LICENSE file that accompanied this code. |
2 | 10 |
* |
11 |
* This code is distributed in the hope that it will be useful, but WITHOUT |
|
12 |
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
|
13 |
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
|
14 |
* version 2 for more details (a copy is included in the LICENSE file that |
|
15 |
* accompanied this code). |
|
16 |
* |
|
17 |
* You should have received a copy of the GNU General Public License version |
|
18 |
* 2 along with this work; if not, write to the Free Software Foundation, |
|
19 |
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
|
20 |
* |
|
5506 | 21 |
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
22 |
* or visit www.oracle.com if you need additional information or have any |
|
23 |
* questions. |
|
2 | 24 |
*/ |
25 |
||
26 |
#include "jni.h" |
|
27 |
#include "jni_util.h" |
|
28 |
#include "jvm.h" |
|
29 |
#include "io_util.h" |
|
30 |
#include "io_util_md.h" |
|
31 |
#include <stdio.h> |
|
19032
e31afe87fb92
8016579: (process) IOException thrown by ProcessBuilder.start() method is incorrectly encoded
uta
parents:
16476
diff
changeset
|
32 |
#include <windows.h> |
2 | 33 |
|
34 |
#include <wchar.h> |
|
35 |
#include <io.h> |
|
36 |
#include <fcntl.h> |
|
37 |
#include <errno.h> |
|
38 |
#include <string.h> |
|
39 |
#include <sys/types.h> |
|
40 |
#include <sys/stat.h> |
|
41 |
#include <limits.h> |
|
42 |
#include <wincon.h> |
|
43 |
||
19032
e31afe87fb92
8016579: (process) IOException thrown by ProcessBuilder.start() method is incorrectly encoded
uta
parents:
16476
diff
changeset
|
44 |
|
47
c8f0e41aea68
6631352: File{OutputStream,Writer} should implement atomic append mode using FILE_APPEND_DATA (win)
martin
parents:
45
diff
changeset
|
45 |
static DWORD MAX_INPUT_EVENTS = 2000; |
2 | 46 |
|
47 |
/* If this returns NULL then an exception is pending */ |
|
48 |
WCHAR* |
|
49 |
fileToNTPath(JNIEnv *env, jobject file, jfieldID id) { |
|
50 |
jstring path = NULL; |
|
51 |
if (file != NULL) { |
|
52 |
path = (*env)->GetObjectField(env, file, id); |
|
53 |
} |
|
54 |
return pathToNTPath(env, path, JNI_FALSE); |
|
55 |
} |
|
56 |
||
6885
5605d7d60c9c
6983520: java/io/pathNames/GeneralWin32.java fails with jdk7-b108 (win)
alanb
parents:
6690
diff
changeset
|
57 |
/* Returns the working directory for the given drive, or NULL */ |
5605d7d60c9c
6983520: java/io/pathNames/GeneralWin32.java fails with jdk7-b108 (win)
alanb
parents:
6690
diff
changeset
|
58 |
WCHAR* |
5605d7d60c9c
6983520: java/io/pathNames/GeneralWin32.java fails with jdk7-b108 (win)
alanb
parents:
6690
diff
changeset
|
59 |
currentDir(int di) { |
5605d7d60c9c
6983520: java/io/pathNames/GeneralWin32.java fails with jdk7-b108 (win)
alanb
parents:
6690
diff
changeset
|
60 |
UINT dt; |
5605d7d60c9c
6983520: java/io/pathNames/GeneralWin32.java fails with jdk7-b108 (win)
alanb
parents:
6690
diff
changeset
|
61 |
WCHAR root[4]; |
5605d7d60c9c
6983520: java/io/pathNames/GeneralWin32.java fails with jdk7-b108 (win)
alanb
parents:
6690
diff
changeset
|
62 |
// verify drive is valid as _wgetdcwd in the VC++ 2010 runtime |
5605d7d60c9c
6983520: java/io/pathNames/GeneralWin32.java fails with jdk7-b108 (win)
alanb
parents:
6690
diff
changeset
|
63 |
// library does not handle invalid drives. |
5605d7d60c9c
6983520: java/io/pathNames/GeneralWin32.java fails with jdk7-b108 (win)
alanb
parents:
6690
diff
changeset
|
64 |
root[0] = L'A' + (WCHAR)(di - 1); |
5605d7d60c9c
6983520: java/io/pathNames/GeneralWin32.java fails with jdk7-b108 (win)
alanb
parents:
6690
diff
changeset
|
65 |
root[1] = L':'; |
5605d7d60c9c
6983520: java/io/pathNames/GeneralWin32.java fails with jdk7-b108 (win)
alanb
parents:
6690
diff
changeset
|
66 |
root[2] = L'\\'; |
5605d7d60c9c
6983520: java/io/pathNames/GeneralWin32.java fails with jdk7-b108 (win)
alanb
parents:
6690
diff
changeset
|
67 |
root[3] = L'\0'; |
5605d7d60c9c
6983520: java/io/pathNames/GeneralWin32.java fails with jdk7-b108 (win)
alanb
parents:
6690
diff
changeset
|
68 |
dt = GetDriveTypeW(root); |
5605d7d60c9c
6983520: java/io/pathNames/GeneralWin32.java fails with jdk7-b108 (win)
alanb
parents:
6690
diff
changeset
|
69 |
if (dt == DRIVE_UNKNOWN || dt == DRIVE_NO_ROOT_DIR) { |
5605d7d60c9c
6983520: java/io/pathNames/GeneralWin32.java fails with jdk7-b108 (win)
alanb
parents:
6690
diff
changeset
|
70 |
return NULL; |
5605d7d60c9c
6983520: java/io/pathNames/GeneralWin32.java fails with jdk7-b108 (win)
alanb
parents:
6690
diff
changeset
|
71 |
} else { |
5605d7d60c9c
6983520: java/io/pathNames/GeneralWin32.java fails with jdk7-b108 (win)
alanb
parents:
6690
diff
changeset
|
72 |
return _wgetdcwd(di, NULL, MAX_PATH); |
5605d7d60c9c
6983520: java/io/pathNames/GeneralWin32.java fails with jdk7-b108 (win)
alanb
parents:
6690
diff
changeset
|
73 |
} |
5605d7d60c9c
6983520: java/io/pathNames/GeneralWin32.java fails with jdk7-b108 (win)
alanb
parents:
6690
diff
changeset
|
74 |
} |
5605d7d60c9c
6983520: java/io/pathNames/GeneralWin32.java fails with jdk7-b108 (win)
alanb
parents:
6690
diff
changeset
|
75 |
|
2 | 76 |
/* We cache the length of current working dir here to avoid |
77 |
calling _wgetcwd() every time we need to resolve a relative |
|
78 |
path. This piece of code needs to be revisited if chdir |
|
79 |
makes its way into java runtime. |
|
80 |
*/ |
|
81 |
||
82 |
int |
|
83 |
currentDirLength(const WCHAR* ps, int pathlen) { |
|
84 |
WCHAR *dir; |
|
85 |
if (pathlen > 2 && ps[1] == L':' && ps[2] != L'\\') { |
|
86 |
//drive-relative |
|
87 |
WCHAR d = ps[0]; |
|
88 |
int dirlen = 0; |
|
89 |
int di = 0; |
|
90 |
if ((d >= L'a') && (d <= L'z')) di = d - L'a' + 1; |
|
91 |
else if ((d >= L'A') && (d <= L'Z')) di = d - L'A' + 1; |
|
92 |
else return 0; /* invalid drive name. */ |
|
6885
5605d7d60c9c
6983520: java/io/pathNames/GeneralWin32.java fails with jdk7-b108 (win)
alanb
parents:
6690
diff
changeset
|
93 |
dir = currentDir(di); |
2 | 94 |
if (dir != NULL){ |
8186
d0e2cc8b3073
7017454: Residual warnings in sun/nio/** and java/io native code (win64)
alanb
parents:
7668
diff
changeset
|
95 |
dirlen = (int)wcslen(dir); |
2 | 96 |
free(dir); |
97 |
} |
|
98 |
return dirlen; |
|
99 |
} else { |
|
100 |
static int curDirLenCached = -1; |
|
101 |
//relative to both drive and directory |
|
102 |
if (curDirLenCached == -1) { |
|
103 |
int dirlen = -1; |
|
104 |
dir = _wgetcwd(NULL, MAX_PATH); |
|
105 |
if (dir != NULL) { |
|
8186
d0e2cc8b3073
7017454: Residual warnings in sun/nio/** and java/io native code (win64)
alanb
parents:
7668
diff
changeset
|
106 |
curDirLenCached = (int)wcslen(dir); |
2 | 107 |
free(dir); |
108 |
} |
|
109 |
} |
|
110 |
return curDirLenCached; |
|
111 |
} |
|
112 |
} |
|
113 |
||
785
36c29b2692f1
6481955: Uncanonicalized absolute filepath with length 248-260 no longer works (win)
sherman
parents:
47
diff
changeset
|
114 |
/* |
36c29b2692f1
6481955: Uncanonicalized absolute filepath with length 248-260 no longer works (win)
sherman
parents:
47
diff
changeset
|
115 |
The "abpathlen" is the size of the buffer needed by _wfullpath. If the |
36c29b2692f1
6481955: Uncanonicalized absolute filepath with length 248-260 no longer works (win)
sherman
parents:
47
diff
changeset
|
116 |
"path" is a relative path, it is "the length of the current dir" + "the |
36c29b2692f1
6481955: Uncanonicalized absolute filepath with length 248-260 no longer works (win)
sherman
parents:
47
diff
changeset
|
117 |
length of the path", if it's "absolute" already, it's the same as |
36c29b2692f1
6481955: Uncanonicalized absolute filepath with length 248-260 no longer works (win)
sherman
parents:
47
diff
changeset
|
118 |
pathlen which is the length of "path". |
36c29b2692f1
6481955: Uncanonicalized absolute filepath with length 248-260 no longer works (win)
sherman
parents:
47
diff
changeset
|
119 |
*/ |
36c29b2692f1
6481955: Uncanonicalized absolute filepath with length 248-260 no longer works (win)
sherman
parents:
47
diff
changeset
|
120 |
WCHAR* prefixAbpath(const WCHAR* path, int pathlen, int abpathlen) { |
36c29b2692f1
6481955: Uncanonicalized absolute filepath with length 248-260 no longer works (win)
sherman
parents:
47
diff
changeset
|
121 |
WCHAR* pathbuf = NULL; |
36c29b2692f1
6481955: Uncanonicalized absolute filepath with length 248-260 no longer works (win)
sherman
parents:
47
diff
changeset
|
122 |
WCHAR* abpath = NULL; |
36c29b2692f1
6481955: Uncanonicalized absolute filepath with length 248-260 no longer works (win)
sherman
parents:
47
diff
changeset
|
123 |
|
36c29b2692f1
6481955: Uncanonicalized absolute filepath with length 248-260 no longer works (win)
sherman
parents:
47
diff
changeset
|
124 |
abpathlen += 10; //padding |
36c29b2692f1
6481955: Uncanonicalized absolute filepath with length 248-260 no longer works (win)
sherman
parents:
47
diff
changeset
|
125 |
abpath = (WCHAR*)malloc(abpathlen * sizeof(WCHAR)); |
36c29b2692f1
6481955: Uncanonicalized absolute filepath with length 248-260 no longer works (win)
sherman
parents:
47
diff
changeset
|
126 |
if (abpath) { |
36c29b2692f1
6481955: Uncanonicalized absolute filepath with length 248-260 no longer works (win)
sherman
parents:
47
diff
changeset
|
127 |
/* Collapse instances of "foo\.." and ensure absoluteness before |
36c29b2692f1
6481955: Uncanonicalized absolute filepath with length 248-260 no longer works (win)
sherman
parents:
47
diff
changeset
|
128 |
going down to prefixing. |
36c29b2692f1
6481955: Uncanonicalized absolute filepath with length 248-260 no longer works (win)
sherman
parents:
47
diff
changeset
|
129 |
*/ |
36c29b2692f1
6481955: Uncanonicalized absolute filepath with length 248-260 no longer works (win)
sherman
parents:
47
diff
changeset
|
130 |
if (_wfullpath(abpath, path, abpathlen)) { |
36c29b2692f1
6481955: Uncanonicalized absolute filepath with length 248-260 no longer works (win)
sherman
parents:
47
diff
changeset
|
131 |
pathbuf = getPrefixed(abpath, abpathlen); |
36c29b2692f1
6481955: Uncanonicalized absolute filepath with length 248-260 no longer works (win)
sherman
parents:
47
diff
changeset
|
132 |
} else { |
36c29b2692f1
6481955: Uncanonicalized absolute filepath with length 248-260 no longer works (win)
sherman
parents:
47
diff
changeset
|
133 |
/* _wfullpath fails if the pathlength exceeds 32k wchar. |
36c29b2692f1
6481955: Uncanonicalized absolute filepath with length 248-260 no longer works (win)
sherman
parents:
47
diff
changeset
|
134 |
Instead of doing more fancy things we simply copy the |
36c29b2692f1
6481955: Uncanonicalized absolute filepath with length 248-260 no longer works (win)
sherman
parents:
47
diff
changeset
|
135 |
ps into the return buffer, the subsequent win32 API will |
36c29b2692f1
6481955: Uncanonicalized absolute filepath with length 248-260 no longer works (win)
sherman
parents:
47
diff
changeset
|
136 |
probably fail with FileNotFoundException, which is expected |
36c29b2692f1
6481955: Uncanonicalized absolute filepath with length 248-260 no longer works (win)
sherman
parents:
47
diff
changeset
|
137 |
*/ |
36c29b2692f1
6481955: Uncanonicalized absolute filepath with length 248-260 no longer works (win)
sherman
parents:
47
diff
changeset
|
138 |
pathbuf = (WCHAR*)malloc((pathlen + 6) * sizeof(WCHAR)); |
36c29b2692f1
6481955: Uncanonicalized absolute filepath with length 248-260 no longer works (win)
sherman
parents:
47
diff
changeset
|
139 |
if (pathbuf != 0) { |
36c29b2692f1
6481955: Uncanonicalized absolute filepath with length 248-260 no longer works (win)
sherman
parents:
47
diff
changeset
|
140 |
wcscpy(pathbuf, path); |
36c29b2692f1
6481955: Uncanonicalized absolute filepath with length 248-260 no longer works (win)
sherman
parents:
47
diff
changeset
|
141 |
} |
36c29b2692f1
6481955: Uncanonicalized absolute filepath with length 248-260 no longer works (win)
sherman
parents:
47
diff
changeset
|
142 |
} |
36c29b2692f1
6481955: Uncanonicalized absolute filepath with length 248-260 no longer works (win)
sherman
parents:
47
diff
changeset
|
143 |
free(abpath); |
36c29b2692f1
6481955: Uncanonicalized absolute filepath with length 248-260 no longer works (win)
sherman
parents:
47
diff
changeset
|
144 |
} |
36c29b2692f1
6481955: Uncanonicalized absolute filepath with length 248-260 no longer works (win)
sherman
parents:
47
diff
changeset
|
145 |
return pathbuf; |
36c29b2692f1
6481955: Uncanonicalized absolute filepath with length 248-260 no longer works (win)
sherman
parents:
47
diff
changeset
|
146 |
} |
36c29b2692f1
6481955: Uncanonicalized absolute filepath with length 248-260 no longer works (win)
sherman
parents:
47
diff
changeset
|
147 |
|
2 | 148 |
/* If this returns NULL then an exception is pending */ |
149 |
WCHAR* |
|
150 |
pathToNTPath(JNIEnv *env, jstring path, jboolean throwFNFE) { |
|
151 |
int pathlen = 0; |
|
152 |
WCHAR *pathbuf = NULL; |
|
785
36c29b2692f1
6481955: Uncanonicalized absolute filepath with length 248-260 no longer works (win)
sherman
parents:
47
diff
changeset
|
153 |
int max_path = 248; /* CreateDirectoryW() has the limit of 248 */ |
36c29b2692f1
6481955: Uncanonicalized absolute filepath with length 248-260 no longer works (win)
sherman
parents:
47
diff
changeset
|
154 |
|
2 | 155 |
WITH_UNICODE_STRING(env, path, ps) { |
8186
d0e2cc8b3073
7017454: Residual warnings in sun/nio/** and java/io native code (win64)
alanb
parents:
7668
diff
changeset
|
156 |
pathlen = (int)wcslen(ps); |
2 | 157 |
if (pathlen != 0) { |
158 |
if (pathlen > 2 && |
|
159 |
(ps[0] == L'\\' && ps[1] == L'\\' || //UNC |
|
785
36c29b2692f1
6481955: Uncanonicalized absolute filepath with length 248-260 no longer works (win)
sherman
parents:
47
diff
changeset
|
160 |
ps[1] == L':' && ps[2] == L'\\')) //absolute |
36c29b2692f1
6481955: Uncanonicalized absolute filepath with length 248-260 no longer works (win)
sherman
parents:
47
diff
changeset
|
161 |
{ |
2 | 162 |
if (pathlen > max_path - 1) { |
785
36c29b2692f1
6481955: Uncanonicalized absolute filepath with length 248-260 no longer works (win)
sherman
parents:
47
diff
changeset
|
163 |
pathbuf = prefixAbpath(ps, pathlen, pathlen); |
2 | 164 |
} else { |
165 |
pathbuf = (WCHAR*)malloc((pathlen + 6) * sizeof(WCHAR)); |
|
166 |
if (pathbuf != 0) { |
|
167 |
wcscpy(pathbuf, ps); |
|
23561
babc1414a7e4
8035930: Check jdk/src/windows/native/java/io/io_util_md.c for JNI pending exceptions
msheppar
parents:
19381
diff
changeset
|
168 |
} else { |
babc1414a7e4
8035930: Check jdk/src/windows/native/java/io/io_util_md.c for JNI pending exceptions
msheppar
parents:
19381
diff
changeset
|
169 |
JNU_ThrowOutOfMemoryError(env, "native memory allocation failed"); |
babc1414a7e4
8035930: Check jdk/src/windows/native/java/io/io_util_md.c for JNI pending exceptions
msheppar
parents:
19381
diff
changeset
|
170 |
return NULL; |
2 | 171 |
} |
172 |
} |
|
173 |
} else { |
|
174 |
/* If the path came in as a relative path, need to verify if |
|
175 |
its absolute form is bigger than max_path or not, if yes |
|
176 |
need to (1)convert it to absolute and (2)prefix. This is |
|
177 |
obviously a burden to all relative paths (The current dir/len |
|
785
36c29b2692f1
6481955: Uncanonicalized absolute filepath with length 248-260 no longer works (win)
sherman
parents:
47
diff
changeset
|
178 |
for "drive & directory" relative path is cached, so we only |
2 | 179 |
calculate it once but for "drive-relative path we call |
180 |
_wgetdcwd() and wcslen() everytime), but a hit we have |
|
181 |
to take if we want to support relative path beyond max_path. |
|
182 |
There is no way to predict how long the absolute path will be |
|
183 |
(therefor allocate the sufficient memory block) before calling |
|
184 |
_wfullpath(), we have to get the length of "current" dir first. |
|
185 |
*/ |
|
186 |
WCHAR *abpath = NULL; |
|
187 |
int dirlen = currentDirLength(ps, pathlen); |
|
188 |
if (dirlen + pathlen + 1 > max_path - 1) { |
|
785
36c29b2692f1
6481955: Uncanonicalized absolute filepath with length 248-260 no longer works (win)
sherman
parents:
47
diff
changeset
|
189 |
pathbuf = prefixAbpath(ps, pathlen, dirlen + pathlen); |
2 | 190 |
} else { |
191 |
pathbuf = (WCHAR*)malloc((pathlen + 6) * sizeof(WCHAR)); |
|
192 |
if (pathbuf != 0) { |
|
193 |
wcscpy(pathbuf, ps); |
|
23561
babc1414a7e4
8035930: Check jdk/src/windows/native/java/io/io_util_md.c for JNI pending exceptions
msheppar
parents:
19381
diff
changeset
|
194 |
} else { |
babc1414a7e4
8035930: Check jdk/src/windows/native/java/io/io_util_md.c for JNI pending exceptions
msheppar
parents:
19381
diff
changeset
|
195 |
JNU_ThrowOutOfMemoryError(env, "native memory allocation failed"); |
babc1414a7e4
8035930: Check jdk/src/windows/native/java/io/io_util_md.c for JNI pending exceptions
msheppar
parents:
19381
diff
changeset
|
196 |
return NULL; |
2 | 197 |
} |
198 |
} |
|
199 |
} |
|
200 |
} |
|
201 |
} END_UNICODE_STRING(env, ps); |
|
202 |
||
203 |
if (pathlen == 0) { |
|
204 |
if (throwFNFE == JNI_TRUE) { |
|
23561
babc1414a7e4
8035930: Check jdk/src/windows/native/java/io/io_util_md.c for JNI pending exceptions
msheppar
parents:
19381
diff
changeset
|
205 |
if (!(*env)->ExceptionCheck(env)) { |
babc1414a7e4
8035930: Check jdk/src/windows/native/java/io/io_util_md.c for JNI pending exceptions
msheppar
parents:
19381
diff
changeset
|
206 |
throwFileNotFoundException(env, path); |
babc1414a7e4
8035930: Check jdk/src/windows/native/java/io/io_util_md.c for JNI pending exceptions
msheppar
parents:
19381
diff
changeset
|
207 |
} |
2 | 208 |
return NULL; |
209 |
} else { |
|
210 |
pathbuf = (WCHAR*)malloc(sizeof(WCHAR)); |
|
23565
b28f771b8cbe
8035870: Check jdk/src/windows/native/java/io/WinNTFileSystem_md.c for JNI pending exceptions
msheppar
parents:
23561
diff
changeset
|
211 |
if (pathbuf != NULL) { |
b28f771b8cbe
8035870: Check jdk/src/windows/native/java/io/WinNTFileSystem_md.c for JNI pending exceptions
msheppar
parents:
23561
diff
changeset
|
212 |
pathbuf[0] = L'\0'; |
b28f771b8cbe
8035870: Check jdk/src/windows/native/java/io/WinNTFileSystem_md.c for JNI pending exceptions
msheppar
parents:
23561
diff
changeset
|
213 |
} else { |
b28f771b8cbe
8035870: Check jdk/src/windows/native/java/io/WinNTFileSystem_md.c for JNI pending exceptions
msheppar
parents:
23561
diff
changeset
|
214 |
JNU_ThrowOutOfMemoryError(env, 0); |
b28f771b8cbe
8035870: Check jdk/src/windows/native/java/io/WinNTFileSystem_md.c for JNI pending exceptions
msheppar
parents:
23561
diff
changeset
|
215 |
return NULL; |
b28f771b8cbe
8035870: Check jdk/src/windows/native/java/io/WinNTFileSystem_md.c for JNI pending exceptions
msheppar
parents:
23561
diff
changeset
|
216 |
} |
2 | 217 |
} |
218 |
} |
|
219 |
if (pathbuf == 0) { |
|
23565
b28f771b8cbe
8035870: Check jdk/src/windows/native/java/io/WinNTFileSystem_md.c for JNI pending exceptions
msheppar
parents:
23561
diff
changeset
|
220 |
JNU_ThrowOutOfMemoryError(env, 0); |
2 | 221 |
return NULL; |
222 |
} |
|
223 |
return pathbuf; |
|
224 |
} |
|
225 |
||
16476
e269be167fae
8001334: Remove use of JVM_* functions from java.io code
dxu
parents:
14177
diff
changeset
|
226 |
FD |
2 | 227 |
winFileHandleOpen(JNIEnv *env, jstring path, int flags) |
228 |
{ |
|
229 |
const DWORD access = |
|
230 |
(flags & O_WRONLY) ? GENERIC_WRITE : |
|
47
c8f0e41aea68
6631352: File{OutputStream,Writer} should implement atomic append mode using FILE_APPEND_DATA (win)
martin
parents:
45
diff
changeset
|
231 |
(flags & O_RDWR) ? (GENERIC_READ | GENERIC_WRITE) : |
2 | 232 |
GENERIC_READ; |
233 |
const DWORD sharing = |
|
234 |
FILE_SHARE_READ | FILE_SHARE_WRITE; |
|
235 |
const DWORD disposition = |
|
236 |
/* Note: O_TRUNC overrides O_CREAT */ |
|
237 |
(flags & O_TRUNC) ? CREATE_ALWAYS : |
|
238 |
(flags & O_CREAT) ? OPEN_ALWAYS : |
|
239 |
OPEN_EXISTING; |
|
240 |
const DWORD maybeWriteThrough = |
|
241 |
(flags & (O_SYNC | O_DSYNC)) ? |
|
242 |
FILE_FLAG_WRITE_THROUGH : |
|
243 |
FILE_ATTRIBUTE_NORMAL; |
|
244 |
const DWORD maybeDeleteOnClose = |
|
245 |
(flags & O_TEMPORARY) ? |
|
246 |
FILE_FLAG_DELETE_ON_CLOSE : |
|
247 |
FILE_ATTRIBUTE_NORMAL; |
|
248 |
const DWORD flagsAndAttributes = maybeWriteThrough | maybeDeleteOnClose; |
|
249 |
HANDLE h = NULL; |
|
250 |
||
14177 | 251 |
WCHAR *pathbuf = pathToNTPath(env, path, JNI_TRUE); |
252 |
if (pathbuf == NULL) { |
|
253 |
/* Exception already pending */ |
|
254 |
return -1; |
|
2 | 255 |
} |
14177 | 256 |
h = CreateFileW( |
257 |
pathbuf, /* Wide char path name */ |
|
258 |
access, /* Read and/or write permission */ |
|
259 |
sharing, /* File sharing flags */ |
|
260 |
NULL, /* Security attributes */ |
|
261 |
disposition, /* creation disposition */ |
|
262 |
flagsAndAttributes, /* flags and attributes */ |
|
263 |
NULL); |
|
264 |
free(pathbuf); |
|
265 |
||
2 | 266 |
if (h == INVALID_HANDLE_VALUE) { |
267 |
throwFileNotFoundException(env, path); |
|
268 |
return -1; |
|
269 |
} |
|
270 |
return (jlong) h; |
|
271 |
} |
|
272 |
||
273 |
void |
|
274 |
fileOpen(JNIEnv *env, jobject this, jstring path, jfieldID fid, int flags) |
|
275 |
{ |
|
16476
e269be167fae
8001334: Remove use of JVM_* functions from java.io code
dxu
parents:
14177
diff
changeset
|
276 |
FD h = winFileHandleOpen(env, path, flags); |
2 | 277 |
if (h >= 0) { |
27263
819f5f87d485
8023173: FileDescriptor should respect append flag
igerasim
parents:
27184
diff
changeset
|
278 |
jobject fdobj; |
819f5f87d485
8023173: FileDescriptor should respect append flag
igerasim
parents:
27184
diff
changeset
|
279 |
jboolean append; |
2 | 280 |
SET_FD(this, h, fid); |
27263
819f5f87d485
8023173: FileDescriptor should respect append flag
igerasim
parents:
27184
diff
changeset
|
281 |
|
819f5f87d485
8023173: FileDescriptor should respect append flag
igerasim
parents:
27184
diff
changeset
|
282 |
fdobj = (*env)->GetObjectField(env, this, fid); |
819f5f87d485
8023173: FileDescriptor should respect append flag
igerasim
parents:
27184
diff
changeset
|
283 |
if (fdobj != NULL) { |
819f5f87d485
8023173: FileDescriptor should respect append flag
igerasim
parents:
27184
diff
changeset
|
284 |
append = (flags & O_APPEND) == 0 ? JNI_FALSE : JNI_TRUE; |
819f5f87d485
8023173: FileDescriptor should respect append flag
igerasim
parents:
27184
diff
changeset
|
285 |
(*env)->SetBooleanField(env, fdobj, IO_append_fdID, append); |
819f5f87d485
8023173: FileDescriptor should respect append flag
igerasim
parents:
27184
diff
changeset
|
286 |
} |
2 | 287 |
} |
288 |
} |
|
289 |
||
290 |
/* These are functions that use a handle fd instead of the |
|
291 |
old C style int fd as is used in HPI layer */ |
|
292 |
||
293 |
static int |
|
16476
e269be167fae
8001334: Remove use of JVM_* functions from java.io code
dxu
parents:
14177
diff
changeset
|
294 |
handleNonSeekAvailable(FD, long *); |
2 | 295 |
static int |
16476
e269be167fae
8001334: Remove use of JVM_* functions from java.io code
dxu
parents:
14177
diff
changeset
|
296 |
handleStdinAvailable(FD, long *); |
2 | 297 |
|
298 |
int |
|
16476
e269be167fae
8001334: Remove use of JVM_* functions from java.io code
dxu
parents:
14177
diff
changeset
|
299 |
handleAvailable(FD fd, jlong *pbytes) { |
2 | 300 |
HANDLE h = (HANDLE)fd; |
301 |
DWORD type = 0; |
|
302 |
||
303 |
type = GetFileType(h); |
|
304 |
/* Handle is for keyboard or pipe */ |
|
305 |
if (type == FILE_TYPE_CHAR || type == FILE_TYPE_PIPE) { |
|
306 |
int ret; |
|
307 |
long lpbytes; |
|
308 |
HANDLE stdInHandle = GetStdHandle(STD_INPUT_HANDLE); |
|
309 |
if (stdInHandle == h) { |
|
310 |
ret = handleStdinAvailable(fd, &lpbytes); /* keyboard */ |
|
311 |
} else { |
|
312 |
ret = handleNonSeekAvailable(fd, &lpbytes); /* pipe */ |
|
313 |
} |
|
314 |
(*pbytes) = (jlong)(lpbytes); |
|
315 |
return ret; |
|
316 |
} |
|
317 |
/* Handle is for regular file */ |
|
318 |
if (type == FILE_TYPE_DISK) { |
|
7519
1488bb354081
6402006: FileInputStream.available() returns negative values when reading a large file
mchung
parents:
7515
diff
changeset
|
319 |
jlong current, end; |
1488bb354081
6402006: FileInputStream.available() returns negative values when reading a large file
mchung
parents:
7515
diff
changeset
|
320 |
|
1488bb354081
6402006: FileInputStream.available() returns negative values when reading a large file
mchung
parents:
7515
diff
changeset
|
321 |
LARGE_INTEGER filesize; |
1488bb354081
6402006: FileInputStream.available() returns negative values when reading a large file
mchung
parents:
7515
diff
changeset
|
322 |
current = handleLseek(fd, 0, SEEK_CUR); |
1488bb354081
6402006: FileInputStream.available() returns negative values when reading a large file
mchung
parents:
7515
diff
changeset
|
323 |
if (current < 0) { |
2 | 324 |
return FALSE; |
325 |
} |
|
7519
1488bb354081
6402006: FileInputStream.available() returns negative values when reading a large file
mchung
parents:
7515
diff
changeset
|
326 |
if (GetFileSizeEx(h, &filesize) == 0) { |
2 | 327 |
return FALSE; |
328 |
} |
|
7519
1488bb354081
6402006: FileInputStream.available() returns negative values when reading a large file
mchung
parents:
7515
diff
changeset
|
329 |
end = long_to_jlong(filesize.QuadPart); |
2 | 330 |
*pbytes = end - current; |
331 |
return TRUE; |
|
332 |
} |
|
333 |
return FALSE; |
|
334 |
} |
|
335 |
||
336 |
static int |
|
16476
e269be167fae
8001334: Remove use of JVM_* functions from java.io code
dxu
parents:
14177
diff
changeset
|
337 |
handleNonSeekAvailable(FD fd, long *pbytes) { |
2 | 338 |
/* This is used for available on non-seekable devices |
339 |
* (like both named and anonymous pipes, such as pipes |
|
340 |
* connected to an exec'd process). |
|
341 |
* Standard Input is a special case. |
|
342 |
* |
|
343 |
*/ |
|
344 |
HANDLE han; |
|
345 |
||
346 |
if ((han = (HANDLE) fd) == INVALID_HANDLE_VALUE) { |
|
347 |
return FALSE; |
|
348 |
} |
|
349 |
||
350 |
if (! PeekNamedPipe(han, NULL, 0, NULL, pbytes, NULL)) { |
|
351 |
/* PeekNamedPipe fails when at EOF. In that case we |
|
352 |
* simply make *pbytes = 0 which is consistent with the |
|
353 |
* behavior we get on Solaris when an fd is at EOF. |
|
354 |
* The only alternative is to raise and Exception, |
|
355 |
* which isn't really warranted. |
|
356 |
*/ |
|
357 |
if (GetLastError() != ERROR_BROKEN_PIPE) { |
|
358 |
return FALSE; |
|
359 |
} |
|
360 |
*pbytes = 0; |
|
361 |
} |
|
362 |
return TRUE; |
|
363 |
} |
|
364 |
||
365 |
static int |
|
16476
e269be167fae
8001334: Remove use of JVM_* functions from java.io code
dxu
parents:
14177
diff
changeset
|
366 |
handleStdinAvailable(FD fd, long *pbytes) { |
2 | 367 |
HANDLE han; |
368 |
DWORD numEventsRead = 0; /* Number of events read from buffer */ |
|
369 |
DWORD numEvents = 0; /* Number of events in buffer */ |
|
370 |
DWORD i = 0; /* Loop index */ |
|
371 |
DWORD curLength = 0; /* Position marker */ |
|
372 |
DWORD actualLength = 0; /* Number of bytes readable */ |
|
373 |
BOOL error = FALSE; /* Error holder */ |
|
374 |
INPUT_RECORD *lpBuffer; /* Pointer to records of input events */ |
|
375 |
DWORD bufferSize = 0; |
|
376 |
||
377 |
if ((han = GetStdHandle(STD_INPUT_HANDLE)) == INVALID_HANDLE_VALUE) { |
|
378 |
return FALSE; |
|
379 |
} |
|
380 |
||
381 |
/* Construct an array of input records in the console buffer */ |
|
382 |
error = GetNumberOfConsoleInputEvents(han, &numEvents); |
|
383 |
if (error == 0) { |
|
384 |
return handleNonSeekAvailable(fd, pbytes); |
|
385 |
} |
|
386 |
||
387 |
/* lpBuffer must fit into 64K or else PeekConsoleInput fails */ |
|
388 |
if (numEvents > MAX_INPUT_EVENTS) { |
|
389 |
numEvents = MAX_INPUT_EVENTS; |
|
390 |
} |
|
391 |
||
392 |
bufferSize = numEvents * sizeof(INPUT_RECORD); |
|
393 |
if (bufferSize == 0) |
|
394 |
bufferSize = 1; |
|
395 |
lpBuffer = malloc(bufferSize); |
|
396 |
if (lpBuffer == NULL) { |
|
397 |
return FALSE; |
|
398 |
} |
|
399 |
||
400 |
error = PeekConsoleInput(han, lpBuffer, numEvents, &numEventsRead); |
|
401 |
if (error == 0) { |
|
402 |
free(lpBuffer); |
|
403 |
return FALSE; |
|
404 |
} |
|
405 |
||
406 |
/* Examine input records for the number of bytes available */ |
|
407 |
for(i=0; i<numEvents; i++) { |
|
408 |
if (lpBuffer[i].EventType == KEY_EVENT) { |
|
409 |
KEY_EVENT_RECORD *keyRecord = (KEY_EVENT_RECORD *) |
|
410 |
&(lpBuffer[i].Event); |
|
411 |
if (keyRecord->bKeyDown == TRUE) { |
|
412 |
CHAR *keyPressed = (CHAR *) &(keyRecord->uChar); |
|
413 |
curLength++; |
|
414 |
if (*keyPressed == '\r') |
|
415 |
actualLength = curLength; |
|
416 |
} |
|
417 |
} |
|
418 |
} |
|
419 |
if(lpBuffer != NULL) |
|
420 |
free(lpBuffer); |
|
421 |
*pbytes = (long) actualLength; |
|
422 |
return TRUE; |
|
423 |
} |
|
424 |
||
425 |
/* |
|
426 |
* This is documented to succeed on read-only files, but Win32's |
|
427 |
* FlushFileBuffers functions fails with "access denied" in such a |
|
428 |
* case. So we only signal an error if the error is *not* "access |
|
429 |
* denied". |
|
430 |
*/ |
|
431 |
||
16476
e269be167fae
8001334: Remove use of JVM_* functions from java.io code
dxu
parents:
14177
diff
changeset
|
432 |
int |
e269be167fae
8001334: Remove use of JVM_* functions from java.io code
dxu
parents:
14177
diff
changeset
|
433 |
handleSync(FD fd) { |
2 | 434 |
/* |
435 |
* From the documentation: |
|
436 |
* |
|
437 |
* On Windows NT, the function FlushFileBuffers fails if hFile |
|
438 |
* is a handle to console output. That is because console |
|
439 |
* output is not buffered. The function returns FALSE, and |
|
440 |
* GetLastError returns ERROR_INVALID_HANDLE. |
|
441 |
* |
|
442 |
* On the other hand, on Win95, it returns without error. I cannot |
|
443 |
* assume that 0, 1, and 2 are console, because if someone closes |
|
444 |
* System.out and then opens a file, they might get file descriptor |
|
445 |
* 1. An error on *that* version of 1 should be reported, whereas |
|
446 |
* an error on System.out (which was the original 1) should be |
|
447 |
* ignored. So I use isatty() to ensure that such an error was due |
|
448 |
* to this bogosity, and if it was, I ignore the error. |
|
449 |
*/ |
|
450 |
||
451 |
HANDLE handle = (HANDLE)fd; |
|
452 |
||
453 |
if (!FlushFileBuffers(handle)) { |
|
454 |
if (GetLastError() != ERROR_ACCESS_DENIED) { /* from winerror.h */ |
|
455 |
return -1; |
|
456 |
} |
|
457 |
} |
|
458 |
return 0; |
|
459 |
} |
|
460 |
||
461 |
||
462 |
int |
|
16476
e269be167fae
8001334: Remove use of JVM_* functions from java.io code
dxu
parents:
14177
diff
changeset
|
463 |
handleSetLength(FD fd, jlong length) { |
2 | 464 |
HANDLE h = (HANDLE)fd; |
465 |
long high = (long)(length >> 32); |
|
466 |
DWORD ret; |
|
467 |
||
468 |
if (h == (HANDLE)(-1)) return -1; |
|
469 |
ret = SetFilePointer(h, (long)(length), &high, FILE_BEGIN); |
|
470 |
if (ret == 0xFFFFFFFF && GetLastError() != NO_ERROR) { |
|
471 |
return -1; |
|
472 |
} |
|
473 |
if (SetEndOfFile(h) == FALSE) return -1; |
|
474 |
return 0; |
|
475 |
} |
|
476 |
||
477 |
JNIEXPORT |
|
11116
3e486ce0019d
7030624: size_t usages in src/windows/native/java/io/io_util_md.c need to be re-visited
alanb
parents:
9035
diff
changeset
|
478 |
jint |
16476
e269be167fae
8001334: Remove use of JVM_* functions from java.io code
dxu
parents:
14177
diff
changeset
|
479 |
handleRead(FD fd, void *buf, jint len) |
2 | 480 |
{ |
481 |
DWORD read = 0; |
|
482 |
BOOL result = 0; |
|
483 |
HANDLE h = (HANDLE)fd; |
|
484 |
if (h == INVALID_HANDLE_VALUE) { |
|
485 |
return -1; |
|
486 |
} |
|
487 |
result = ReadFile(h, /* File handle to read */ |
|
488 |
buf, /* address to put data */ |
|
489 |
len, /* number of bytes to read */ |
|
490 |
&read, /* number of bytes read */ |
|
491 |
NULL); /* no overlapped struct */ |
|
492 |
if (result == 0) { |
|
493 |
int error = GetLastError(); |
|
494 |
if (error == ERROR_BROKEN_PIPE) { |
|
495 |
return 0; /* EOF */ |
|
496 |
} |
|
497 |
return -1; |
|
498 |
} |
|
11116
3e486ce0019d
7030624: size_t usages in src/windows/native/java/io/io_util_md.c need to be re-visited
alanb
parents:
9035
diff
changeset
|
499 |
return (jint)read; |
2 | 500 |
} |
501 |
||
16476
e269be167fae
8001334: Remove use of JVM_* functions from java.io code
dxu
parents:
14177
diff
changeset
|
502 |
static jint writeInternal(FD fd, const void *buf, jint len, jboolean append) |
2 | 503 |
{ |
504 |
BOOL result = 0; |
|
505 |
DWORD written = 0; |
|
506 |
HANDLE h = (HANDLE)fd; |
|
507 |
if (h != INVALID_HANDLE_VALUE) { |
|
7515
43202796198e
6709457: (fc) lock/tryLock() throws IOException "Access is denied" when file opened for append [win]
alanb
parents:
6885
diff
changeset
|
508 |
OVERLAPPED ov; |
43202796198e
6709457: (fc) lock/tryLock() throws IOException "Access is denied" when file opened for append [win]
alanb
parents:
6885
diff
changeset
|
509 |
LPOVERLAPPED lpOv; |
43202796198e
6709457: (fc) lock/tryLock() throws IOException "Access is denied" when file opened for append [win]
alanb
parents:
6885
diff
changeset
|
510 |
if (append == JNI_TRUE) { |
43202796198e
6709457: (fc) lock/tryLock() throws IOException "Access is denied" when file opened for append [win]
alanb
parents:
6885
diff
changeset
|
511 |
ov.Offset = (DWORD)0xFFFFFFFF; |
43202796198e
6709457: (fc) lock/tryLock() throws IOException "Access is denied" when file opened for append [win]
alanb
parents:
6885
diff
changeset
|
512 |
ov.OffsetHigh = (DWORD)0xFFFFFFFF; |
43202796198e
6709457: (fc) lock/tryLock() throws IOException "Access is denied" when file opened for append [win]
alanb
parents:
6885
diff
changeset
|
513 |
ov.hEvent = NULL; |
43202796198e
6709457: (fc) lock/tryLock() throws IOException "Access is denied" when file opened for append [win]
alanb
parents:
6885
diff
changeset
|
514 |
lpOv = &ov; |
43202796198e
6709457: (fc) lock/tryLock() throws IOException "Access is denied" when file opened for append [win]
alanb
parents:
6885
diff
changeset
|
515 |
} else { |
43202796198e
6709457: (fc) lock/tryLock() throws IOException "Access is denied" when file opened for append [win]
alanb
parents:
6885
diff
changeset
|
516 |
lpOv = NULL; |
43202796198e
6709457: (fc) lock/tryLock() throws IOException "Access is denied" when file opened for append [win]
alanb
parents:
6885
diff
changeset
|
517 |
} |
43202796198e
6709457: (fc) lock/tryLock() throws IOException "Access is denied" when file opened for append [win]
alanb
parents:
6885
diff
changeset
|
518 |
result = WriteFile(h, /* File handle to write */ |
43202796198e
6709457: (fc) lock/tryLock() throws IOException "Access is denied" when file opened for append [win]
alanb
parents:
6885
diff
changeset
|
519 |
buf, /* pointers to the buffers */ |
43202796198e
6709457: (fc) lock/tryLock() throws IOException "Access is denied" when file opened for append [win]
alanb
parents:
6885
diff
changeset
|
520 |
len, /* number of bytes to write */ |
43202796198e
6709457: (fc) lock/tryLock() throws IOException "Access is denied" when file opened for append [win]
alanb
parents:
6885
diff
changeset
|
521 |
&written, /* receives number of bytes written */ |
43202796198e
6709457: (fc) lock/tryLock() throws IOException "Access is denied" when file opened for append [win]
alanb
parents:
6885
diff
changeset
|
522 |
lpOv); /* overlapped struct */ |
2 | 523 |
} |
524 |
if ((h == INVALID_HANDLE_VALUE) || (result == 0)) { |
|
525 |
return -1; |
|
526 |
} |
|
11116
3e486ce0019d
7030624: size_t usages in src/windows/native/java/io/io_util_md.c need to be re-visited
alanb
parents:
9035
diff
changeset
|
527 |
return (jint)written; |
7515
43202796198e
6709457: (fc) lock/tryLock() throws IOException "Access is denied" when file opened for append [win]
alanb
parents:
6885
diff
changeset
|
528 |
} |
43202796198e
6709457: (fc) lock/tryLock() throws IOException "Access is denied" when file opened for append [win]
alanb
parents:
6885
diff
changeset
|
529 |
|
16476
e269be167fae
8001334: Remove use of JVM_* functions from java.io code
dxu
parents:
14177
diff
changeset
|
530 |
jint handleWrite(FD fd, const void *buf, jint len) { |
7515
43202796198e
6709457: (fc) lock/tryLock() throws IOException "Access is denied" when file opened for append [win]
alanb
parents:
6885
diff
changeset
|
531 |
return writeInternal(fd, buf, len, JNI_FALSE); |
43202796198e
6709457: (fc) lock/tryLock() throws IOException "Access is denied" when file opened for append [win]
alanb
parents:
6885
diff
changeset
|
532 |
} |
43202796198e
6709457: (fc) lock/tryLock() throws IOException "Access is denied" when file opened for append [win]
alanb
parents:
6885
diff
changeset
|
533 |
|
16476
e269be167fae
8001334: Remove use of JVM_* functions from java.io code
dxu
parents:
14177
diff
changeset
|
534 |
jint handleAppend(FD fd, const void *buf, jint len) { |
7515
43202796198e
6709457: (fc) lock/tryLock() throws IOException "Access is denied" when file opened for append [win]
alanb
parents:
6885
diff
changeset
|
535 |
return writeInternal(fd, buf, len, JNI_TRUE); |
2 | 536 |
} |
537 |
||
538 |
jint |
|
539 |
handleClose(JNIEnv *env, jobject this, jfieldID fid) |
|
540 |
{ |
|
541 |
FD fd = GET_FD(this, fid); |
|
542 |
HANDLE h = (HANDLE)fd; |
|
543 |
||
47
c8f0e41aea68
6631352: File{OutputStream,Writer} should implement atomic append mode using FILE_APPEND_DATA (win)
martin
parents:
45
diff
changeset
|
544 |
if (h == INVALID_HANDLE_VALUE) { |
2 | 545 |
return 0; |
546 |
} |
|
547 |
||
548 |
/* Set the fd to -1 before closing it so that the timing window |
|
549 |
* of other threads using the wrong fd (closed but recycled fd, |
|
550 |
* that gets re-opened with some other filename) is reduced. |
|
551 |
* Practically the chance of its occurance is low, however, we are |
|
552 |
* taking extra precaution over here. |
|
553 |
*/ |
|
554 |
SET_FD(this, -1, fid); |
|
555 |
||
556 |
if (CloseHandle(h) == 0) { /* Returns zero on failure */ |
|
557 |
JNU_ThrowIOExceptionWithLastError(env, "close failed"); |
|
558 |
} |
|
559 |
return 0; |
|
560 |
} |
|
561 |
||
562 |
jlong |
|
16476
e269be167fae
8001334: Remove use of JVM_* functions from java.io code
dxu
parents:
14177
diff
changeset
|
563 |
handleLseek(FD fd, jlong offset, jint whence) |
2 | 564 |
{ |
7519
1488bb354081
6402006: FileInputStream.available() returns negative values when reading a large file
mchung
parents:
7515
diff
changeset
|
565 |
LARGE_INTEGER pos, distance; |
2 | 566 |
DWORD lowPos = 0; |
567 |
long highPos = 0; |
|
568 |
DWORD op = FILE_CURRENT; |
|
569 |
HANDLE h = (HANDLE)fd; |
|
570 |
||
571 |
if (whence == SEEK_END) { |
|
572 |
op = FILE_END; |
|
573 |
} |
|
574 |
if (whence == SEEK_CUR) { |
|
575 |
op = FILE_CURRENT; |
|
576 |
} |
|
577 |
if (whence == SEEK_SET) { |
|
578 |
op = FILE_BEGIN; |
|
579 |
} |
|
580 |
||
7519
1488bb354081
6402006: FileInputStream.available() returns negative values when reading a large file
mchung
parents:
7515
diff
changeset
|
581 |
distance.QuadPart = offset; |
1488bb354081
6402006: FileInputStream.available() returns negative values when reading a large file
mchung
parents:
7515
diff
changeset
|
582 |
if (SetFilePointerEx(h, distance, &pos, op) == 0) { |
1488bb354081
6402006: FileInputStream.available() returns negative values when reading a large file
mchung
parents:
7515
diff
changeset
|
583 |
return -1; |
2 | 584 |
} |
7519
1488bb354081
6402006: FileInputStream.available() returns negative values when reading a large file
mchung
parents:
7515
diff
changeset
|
585 |
return long_to_jlong(pos.QuadPart); |
2 | 586 |
} |