35 |
obligated to do so. If you do not wish to do so, delete this |
obligated to do so. If you do not wish to do so, delete this |
36 |
exception statement from your version. */ |
exception statement from your version. */ |
37 |
|
|
38 |
|
/* do not move; needed here because of some macro definitions */ |
39 |
|
#include <config.h> |
40 |
|
|
41 |
#include <stdio.h> |
#include <stdio.h> |
42 |
#include <stdlib.h> |
#include <stdlib.h> |
|
#include <string.h> |
|
|
#include <errno.h> |
|
|
#include <sys/types.h> |
|
|
#include <fcntl.h> |
|
|
#include <utime.h> |
|
|
#include <unistd.h> |
|
|
#include <sys/stat.h> |
|
|
#include <dirent.h> |
|
43 |
|
|
44 |
#include <jni.h> |
#include <jni.h> |
45 |
#include <jcl.h> |
#include <jcl.h> |
46 |
|
|
47 |
|
#include "target_native.h" |
48 |
|
#ifndef WITHOUT_FILESYSTEM |
49 |
|
#include "target_native_file.h" |
50 |
|
#endif |
51 |
|
#include "target_native_math_int.h" |
52 |
|
|
53 |
#include "javaio.h" |
#include "javaio.h" |
54 |
|
|
55 |
#include "java_io_File.h" |
#include "java_io_File.h" |
67 |
JNIEXPORT jboolean JNICALL |
JNIEXPORT jboolean JNICALL |
68 |
Java_java_io_File_createInternal(JNIEnv *env, jclass clazz, jstring name) |
Java_java_io_File_createInternal(JNIEnv *env, jclass clazz, jstring name) |
69 |
{ |
{ |
70 |
const char *fname; |
#ifndef WITHOUT_FILESYSTEM |
71 |
int fd; |
const char *filename; |
72 |
|
int fd; |
73 |
|
int result; |
74 |
|
|
75 |
fname = JCL_jstring_to_cstring(env, name); |
filename = JCL_jstring_to_cstring(env, name); |
76 |
if (!fname) |
if (filename == NULL) |
77 |
return(0); |
{ |
78 |
|
return(0); |
79 |
|
} |
80 |
|
|
81 |
fd = open(fname, O_CREAT|O_EXCL|O_RDWR, 0777); |
TARGET_NATIVE_FILE_OPEN_CREATE(filename,fd,result); |
82 |
if (fd == -1) |
if (result != TARGET_NATIVE_OK) |
83 |
{ |
{ |
84 |
|
//??? NYI |
85 |
if (errno != EEXIST) |
if (errno != EEXIST) |
86 |
JCL_ThrowException(env, "java/io/IOException", strerror(errno)); |
JCL_ThrowException(env, |
87 |
|
"java/io/IOException", |
88 |
|
TARGET_NATIVE_LAST_ERROR_STRING()); |
89 |
return(0); |
return(0); |
90 |
} |
} |
91 |
|
TARGET_NATIVE_FILE_CLOSE(fd,result); |
92 |
|
|
|
close(fd); |
|
93 |
return(1); |
return(1); |
94 |
|
#else /* not WITHOUT_FILESYSTEM */ |
95 |
|
return(0); |
96 |
|
#endif /* not WITHOUT_FILESYSTEM */ |
97 |
} |
} |
98 |
|
|
99 |
/*************************************************************************/ |
/*************************************************************************/ |
109 |
JNIEXPORT jboolean JNICALL |
JNIEXPORT jboolean JNICALL |
110 |
Java_java_io_File_canReadInternal(JNIEnv *env, jobject obj, jstring name) |
Java_java_io_File_canReadInternal(JNIEnv *env, jobject obj, jstring name) |
111 |
{ |
{ |
112 |
const char *fname; |
#ifndef WITHOUT_FILESYSTEM |
113 |
int fd; |
const char *filename; |
114 |
|
int fd; |
115 |
|
int result; |
116 |
|
|
117 |
/* Don't use the JCL convert function because it throws an exception |
/* Don't use the JCL convert function because it throws an exception |
118 |
on failure */ |
on failure */ |
119 |
fname = (*env)->GetStringUTFChars(env, name, 0); |
filename = (*env)->GetStringUTFChars(env, name, 0); |
120 |
if (!fname) |
if (filename == NULL) |
121 |
return(0); |
{ |
122 |
|
return(0); |
123 |
|
} |
124 |
|
|
125 |
/* The lazy man's way out. We actually do open the file for reading |
/* The lazy man's way out. We actually do open the file for reading |
126 |
briefly to verify it can be done */ |
briefly to verify it can be done */ |
127 |
fd = open(fname, O_RDONLY); |
TARGET_NATIVE_FILE_OPEN_READ(filename,fd,result); |
128 |
(*env)->ReleaseStringUTFChars(env, name, fname); |
(*env)->ReleaseStringUTFChars(env, name, filename); |
129 |
|
if (result != TARGET_NATIVE_OK) |
130 |
if (fd == -1) |
{ |
131 |
return(0); |
return(0); |
132 |
|
} |
133 |
|
TARGET_NATIVE_FILE_CLOSE(fd,result); |
134 |
|
|
|
close(fd); |
|
135 |
return(1); |
return(1); |
136 |
|
#else /* not WITHOUT_FILESYSTEM */ |
137 |
|
return(0); |
138 |
|
#endif /* not WITHOUT_FILESYSTEM */ |
139 |
} |
} |
140 |
|
|
141 |
/*************************************************************************/ |
/*************************************************************************/ |
151 |
JNIEXPORT jboolean JNICALL |
JNIEXPORT jboolean JNICALL |
152 |
Java_java_io_File_canWriteInternal(JNIEnv *env, jobject obj, jstring name) |
Java_java_io_File_canWriteInternal(JNIEnv *env, jobject obj, jstring name) |
153 |
{ |
{ |
154 |
const char *fname; |
#ifndef WITHOUT_FILESYSTEM |
155 |
int fd; |
const char *filename; |
156 |
|
int fd; |
157 |
|
int result; |
158 |
|
|
159 |
/* Don't use the JCL convert function because it throws an exception |
/* Don't use the JCL convert function because it throws an exception |
160 |
on failure */ |
on failure */ |
161 |
fname = (*env)->GetStringUTFChars(env, name, 0); |
filename = (*env)->GetStringUTFChars(env, name, 0); |
162 |
if (!fname) |
if (filename == NULL) |
163 |
return(0); |
{ |
164 |
|
return(0); |
165 |
|
} |
166 |
|
|
167 |
/* The lazy man's way out. We actually do open the file for writing |
/* The lazy man's way out. We actually do open the file for writing |
168 |
briefly to verify it can be done */ |
briefly to verify it can be done */ |
169 |
fd = open(fname, O_RDWR); |
TARGET_NATIVE_FILE_OPEN_READWRITE(filename,fd,result); |
170 |
(*env)->ReleaseStringUTFChars(env, name, fname); |
(*env)->ReleaseStringUTFChars(env, name, filename); |
171 |
|
if (result != TARGET_NATIVE_OK) |
172 |
if (fd == -1) |
{ |
173 |
return(0); |
return(0); |
174 |
|
} |
175 |
|
TARGET_NATIVE_FILE_CLOSE(fd,result); |
176 |
|
|
|
close(fd); |
|
177 |
return(1); |
return(1); |
178 |
|
#else /* not WITHOUT_FILESYSTEM */ |
179 |
|
return(0); |
180 |
|
#endif /* not WITHOUT_FILESYSTEM */ |
181 |
} |
} |
182 |
|
|
183 |
/*************************************************************************/ |
/*************************************************************************/ |
193 |
JNIEXPORT jboolean JNICALL |
JNIEXPORT jboolean JNICALL |
194 |
Java_java_io_File_setReadOnlyInternal(JNIEnv *env, jobject obj, jstring name) |
Java_java_io_File_setReadOnlyInternal(JNIEnv *env, jobject obj, jstring name) |
195 |
{ |
{ |
196 |
const char *fname; |
#ifndef WITHOUT_FILESYSTEM |
197 |
struct stat buf; |
const char *filename; |
198 |
mode_t newmode; |
int result; |
|
int rc; |
|
199 |
|
|
200 |
/* Don't use the JCL convert function because it throws an exception |
/* Don't use the JCL convert function because it throws an exception |
201 |
on failure */ |
on failure */ |
202 |
fname = (*env)->GetStringUTFChars(env, name, 0); |
filename = (*env)->GetStringUTFChars(env, name, 0); |
203 |
if (!fname) |
if (filename == NULL) |
|
return(0); |
|
|
|
|
|
rc = stat(fname, &buf); |
|
|
|
|
|
if (rc == -1) |
|
204 |
{ |
{ |
|
(*env)->ReleaseStringUTFChars(env, name, fname); |
|
205 |
return(0); |
return(0); |
206 |
} |
} |
207 |
|
|
208 |
newmode = buf.st_mode; |
TARGET_NATIVE_FILE_SET_MODE_READONLY(filename,result); |
209 |
newmode = newmode & (~(S_IWRITE|S_IWGRP|S_IWOTH)); |
(*env)->ReleaseStringUTFChars(env, name, filename); |
210 |
|
|
211 |
rc = chmod(fname, newmode); |
return ((result == TARGET_NATIVE_OK)?1:0); |
212 |
(*env)->ReleaseStringUTFChars(env, name, fname); |
#else /* not WITHOUT_FILESYSTEM */ |
213 |
|
return(0); |
214 |
if (rc == -1) |
#endif /* not WITHOUT_FILESYSTEM */ |
|
return(0); |
|
|
else |
|
|
return(1); |
|
215 |
} |
} |
216 |
|
|
217 |
/*************************************************************************/ |
/*************************************************************************/ |
227 |
JNIEXPORT jboolean JNICALL |
JNIEXPORT jboolean JNICALL |
228 |
Java_java_io_File_existsInternal(JNIEnv *env, jobject obj, jstring name) |
Java_java_io_File_existsInternal(JNIEnv *env, jobject obj, jstring name) |
229 |
{ |
{ |
230 |
const char *fname; |
#ifndef WITHOUT_FILESYSTEM |
231 |
struct stat buf; |
const char *filename; |
232 |
int rc; |
int result; |
233 |
|
|
234 |
/* Don't use the JCL convert function because it throws an exception |
/* Don't use the JCL convert function because it throws an exception |
235 |
on failure */ |
on failure */ |
236 |
fname = (*env)->GetStringUTFChars(env, name, 0); |
filename = (*env)->GetStringUTFChars(env, name, 0); |
237 |
if (!fname) |
if (filename == NULL) |
238 |
return(0); |
{ |
239 |
|
return(0); |
240 |
|
} |
241 |
|
|
242 |
rc = stat(fname, &buf); |
TARGET_NATIVE_FILE_EXISTS(filename,result); |
243 |
(*env)->ReleaseStringUTFChars(env, name, fname); |
(*env)->ReleaseStringUTFChars(env, name, filename); |
244 |
|
|
245 |
if (rc == -1) |
return ((result == TARGET_NATIVE_OK)?1:0); |
246 |
return(0); |
#else /* not WITHOUT_FILESYSTEM */ |
247 |
else |
return(0); |
248 |
return(1); |
#endif /* not WITHOUT_FILESYSTEM */ |
249 |
} |
} |
250 |
|
|
251 |
/*************************************************************************/ |
/*************************************************************************/ |
262 |
JNIEXPORT jboolean JNICALL |
JNIEXPORT jboolean JNICALL |
263 |
Java_java_io_File_isFileInternal(JNIEnv *env, jobject obj, jstring name) |
Java_java_io_File_isFileInternal(JNIEnv *env, jobject obj, jstring name) |
264 |
{ |
{ |
265 |
const char *fname; |
#ifndef WITHOUT_FILESYSTEM |
266 |
struct stat buf; |
const char *filename; |
267 |
int rc; |
int result; |
268 |
|
|
269 |
/* Don't use the JCL convert function because it throws an exception |
/* Don't use the JCL convert function because it throws an exception |
270 |
on failure */ |
on failure */ |
271 |
fname = (*env)->GetStringUTFChars(env, name, 0); |
filename = (*env)->GetStringUTFChars(env, name, 0); |
272 |
if (!fname) |
if (filename == NULL) |
273 |
return(0); |
{ |
274 |
|
return(0); |
275 |
rc = stat(fname, &buf); |
} |
276 |
(*env)->ReleaseStringUTFChars(env, name, fname); |
|
277 |
|
TARGET_NATIVE_FILE_IS_FILE(filename,result); |
278 |
|
(*env)->ReleaseStringUTFChars(env, name, filename); |
279 |
|
|
280 |
if (rc == -1) |
return ((result == TARGET_NATIVE_OK)?1:0); |
281 |
return(0); |
#else /* not WITHOUT_FILESYSTEM */ |
282 |
if (S_ISREG(buf.st_mode)) |
return(0); |
283 |
return(1); |
#endif /* not WITHOUT_FILESYSTEM */ |
|
else |
|
|
return(0); |
|
284 |
} |
} |
285 |
|
|
286 |
/*************************************************************************/ |
/*************************************************************************/ |
296 |
JNIEXPORT jboolean JNICALL |
JNIEXPORT jboolean JNICALL |
297 |
Java_java_io_File_isDirectoryInternal(JNIEnv *env, jobject obj, jstring name) |
Java_java_io_File_isDirectoryInternal(JNIEnv *env, jobject obj, jstring name) |
298 |
{ |
{ |
299 |
const char *fname; |
#ifndef WITHOUT_FILESYSTEM |
300 |
struct stat buf; |
const char *filename; |
301 |
int rc; |
int result; |
302 |
|
|
303 |
/* Don't use the JCL convert function because it throws an exception |
/* Don't use the JCL convert function because it throws an exception |
304 |
on failure */ |
on failure */ |
305 |
fname = (*env)->GetStringUTFChars(env, name, 0); |
filename = (*env)->GetStringUTFChars(env, name, 0); |
306 |
if (!fname) |
if (filename == NULL) |
307 |
return(0); |
{ |
308 |
|
return(0); |
309 |
rc = stat(fname, &buf); |
} |
310 |
(*env)->ReleaseStringUTFChars(env, name, fname); |
|
311 |
|
TARGET_NATIVE_FILE_IS_DIRECTORY(filename,result); |
312 |
|
(*env)->ReleaseStringUTFChars(env, name, filename); |
313 |
|
|
314 |
if (rc == -1) |
return ((result == TARGET_NATIVE_OK)?1:0); |
315 |
return(0); |
#else /* not WITHOUT_FILESYSTEM */ |
316 |
if (S_ISDIR(buf.st_mode)) |
return(0); |
317 |
return(1); |
#endif /* not WITHOUT_FILESYSTEM */ |
|
else |
|
|
return(0); |
|
318 |
} |
} |
319 |
|
|
320 |
/*************************************************************************/ |
/*************************************************************************/ |
330 |
JNIEXPORT jlong JNICALL |
JNIEXPORT jlong JNICALL |
331 |
Java_java_io_File_lengthInternal(JNIEnv *env, jobject obj, jstring name) |
Java_java_io_File_lengthInternal(JNIEnv *env, jobject obj, jstring name) |
332 |
{ |
{ |
333 |
const char *fname; |
#ifndef WITHOUT_FILESYSTEM |
334 |
struct stat buf; |
const char *filename; |
335 |
int rc; |
int tmpfd; |
336 |
|
jlong length; |
337 |
|
int result; |
338 |
|
|
339 |
/* Don't use the JCL convert function because it throws an exception |
/* Don't use the JCL convert function because it throws an exception |
340 |
on failure */ |
on failure */ |
341 |
fname = (*env)->GetStringUTFChars(env, name, 0); |
filename = (*env)->GetStringUTFChars(env, name, 0); |
342 |
if (!fname) |
if (filename == NULL) |
343 |
return(0); |
{ |
344 |
|
return(JNI_JLONG_CONST_0); |
345 |
|
} |
346 |
|
|
347 |
rc = stat(fname, &buf); |
/* open file for reading, get size and close file */ |
348 |
(*env)->ReleaseStringUTFChars(env, name, fname); |
TARGET_NATIVE_FILE_OPEN_READ(filename,tmpfd,result); |
349 |
|
if (result != TARGET_NATIVE_OK) |
350 |
if (rc == -1) |
{ |
351 |
return(0); |
return(JNI_JLONG_CONST_0); |
352 |
|
} |
353 |
|
TARGET_NATIVE_FILE_SIZE(tmpfd,length,result); |
354 |
|
if (result != TARGET_NATIVE_OK) |
355 |
|
{ |
356 |
|
TARGET_NATIVE_FILE_CLOSE(tmpfd,result); |
357 |
|
return(JNI_JLONG_CONST_0); |
358 |
|
} |
359 |
|
TARGET_NATIVE_FILE_CLOSE(tmpfd,result); |
360 |
|
(*env)->ReleaseStringUTFChars(env, name, filename); |
361 |
|
|
362 |
return(buf.st_size); |
return ((result == TARGET_NATIVE_OK)?length:JNI_JLONG_CONST_0); |
363 |
|
#else /* not WITHOUT_FILESYSTEM */ |
364 |
|
return(JNI_JLONG_CONST_0); |
365 |
|
#endif /* not WITHOUT_FILESYSTEM */ |
366 |
} |
} |
367 |
|
|
368 |
/*************************************************************************/ |
/*************************************************************************/ |
378 |
JNIEXPORT jlong JNICALL |
JNIEXPORT jlong JNICALL |
379 |
Java_java_io_File_lastModifiedInternal(JNIEnv *env, jobject obj, jstring name) |
Java_java_io_File_lastModifiedInternal(JNIEnv *env, jobject obj, jstring name) |
380 |
{ |
{ |
381 |
const char *fname; |
#ifndef WITHOUT_FILESYSTEM |
382 |
struct stat buf; |
const char *filename; |
383 |
int rc; |
jlong mtime; |
384 |
jlong mtime; |
int result; |
385 |
|
|
386 |
/* Don't use the JCL convert function because it throws an exception |
/* Don't use the JCL convert function because it throws an exception |
387 |
on failure */ |
on failure */ |
388 |
fname = (*env)->GetStringUTFChars(env, name, 0); |
filename = (*env)->GetStringUTFChars(env, name, 0); |
389 |
if (!fname) |
if (filename == NULL) |
390 |
return(0); |
{ |
391 |
|
return(0); |
392 |
|
} |
393 |
|
|
394 |
rc = stat(fname, &buf); |
TARGET_NATIVE_FILE_GET_LAST_MODIFIED(filename,mtime,result); |
395 |
(*env)->ReleaseStringUTFChars(env, name, fname); |
(*env)->ReleaseStringUTFChars(env, name, filename); |
396 |
|
|
397 |
if (rc == -1) |
return ((result == TARGET_NATIVE_OK)?mtime:JNI_JLONG_CONST_0); |
398 |
return(0); |
#else /* not WITHOUT_FILESYSTEM */ |
399 |
|
return(JNI_JLONG_CONST_0); |
400 |
// milliseconds required |
#endif /* not WITHOUT_FILESYSTEM */ |
|
mtime = buf.st_mtime; |
|
|
mtime = mtime * 1000; |
|
|
return(mtime); |
|
401 |
} |
} |
402 |
|
|
403 |
/*************************************************************************/ |
/*************************************************************************/ |
414 |
Java_java_io_File_setLastModifiedInternal(JNIEnv *env, jobject obj, |
Java_java_io_File_setLastModifiedInternal(JNIEnv *env, jobject obj, |
415 |
jstring name, jlong newtime) |
jstring name, jlong newtime) |
416 |
{ |
{ |
417 |
const char *fname; |
#ifndef WITHOUT_FILESYSTEM |
418 |
struct stat buf; |
const char *filename; |
419 |
struct utimbuf ut; |
int result; |
|
int rc; |
|
420 |
|
|
421 |
/* Don't use the JCL convert function because it throws an exception |
/* Don't use the JCL convert function because it throws an exception |
422 |
on failure */ |
on failure */ |
423 |
fname = (*env)->GetStringUTFChars(env, name, 0); |
filename = (*env)->GetStringUTFChars(env, name, 0); |
424 |
if (!fname) |
if (filename == NULL) |
|
return(0); |
|
|
|
|
|
rc = stat(fname, &buf); |
|
|
|
|
|
if (rc == -1) |
|
425 |
{ |
{ |
|
(*env)->ReleaseStringUTFChars(env, name, fname); |
|
426 |
return(0); |
return(0); |
427 |
} |
} |
428 |
|
|
429 |
|
TARGET_NATIVE_FILE_SET_LAST_MODIFIED(filename,newtime,result); |
430 |
|
(*env)->ReleaseStringUTFChars(env, name, filename); |
431 |
|
|
432 |
ut.actime = buf.st_atime; |
return ((result == TARGET_NATIVE_OK)?1:0); |
433 |
ut.modtime = buf.st_mtime; |
#else /* not WITHOUT_FILESYSTEM */ |
434 |
|
return(0); |
435 |
rc = utime(fname, &ut); |
#endif /* not WITHOUT_FILESYSTEM */ |
|
(*env)->ReleaseStringUTFChars(env, name, fname); |
|
|
|
|
|
if (rc == -1) |
|
|
return(0); |
|
|
else |
|
|
return(1); |
|
436 |
} |
} |
437 |
|
|
438 |
/*************************************************************************/ |
/*************************************************************************/ |
449 |
JNIEXPORT jboolean JNICALL |
JNIEXPORT jboolean JNICALL |
450 |
Java_java_io_File_deleteInternal(JNIEnv *env, jobject obj, jstring name) |
Java_java_io_File_deleteInternal(JNIEnv *env, jobject obj, jstring name) |
451 |
{ |
{ |
452 |
const char *fname; |
#ifndef WITHOUT_FILESYSTEM |
453 |
int rc; |
const char *filename; |
454 |
|
int result; |
455 |
|
|
456 |
/* Don't use the JCL convert function because it throws an exception |
/* Don't use the JCL convert function because it throws an exception |
457 |
on failure */ |
on failure */ |
458 |
fname = (*env)->GetStringUTFChars(env, name, 0); |
filename = (*env)->GetStringUTFChars(env, name, 0); |
459 |
if (!fname) |
if (filename == NULL) |
460 |
return(0); |
{ |
461 |
|
return(0); |
462 |
|
} |
463 |
|
|
464 |
rc = unlink(fname); |
TARGET_NATIVE_FILE_DELETE(filename,result); |
465 |
if (rc == -1) |
(*env)->ReleaseStringUTFChars(env, name, filename); |
466 |
rc = rmdir(fname); |
|
467 |
(*env)->ReleaseStringUTFChars(env, name, fname); |
return ((result == TARGET_NATIVE_OK)?1:0); |
468 |
|
#else /* not WITHOUT_FILESYSTEM */ |
469 |
if (rc == -1) |
return(0); |
470 |
return(0); |
#endif /* not WITHOUT_FILESYSTEM */ |
|
else |
|
|
return(1); |
|
471 |
} |
} |
472 |
|
|
473 |
/*************************************************************************/ |
/*************************************************************************/ |
483 |
JNIEXPORT jboolean JNICALL |
JNIEXPORT jboolean JNICALL |
484 |
Java_java_io_File_mkdirInternal(JNIEnv *env, jobject obj, jstring name) |
Java_java_io_File_mkdirInternal(JNIEnv *env, jobject obj, jstring name) |
485 |
{ |
{ |
486 |
const char *fname; |
#ifndef WITHOUT_FILESYSTEM |
487 |
int rc; |
const char *pathname; |
488 |
|
int result; |
489 |
|
|
490 |
/* Don't use the JCL convert function because it throws an exception |
/* Don't use the JCL convert function because it throws an exception |
491 |
on failure */ |
on failure */ |
492 |
fname = (*env)->GetStringUTFChars(env, name, 0); |
pathname = (*env)->GetStringUTFChars(env, name, 0); |
493 |
if (!fname) |
if (pathname == NULL) |
494 |
return(0); |
{ |
495 |
|
return(0); |
496 |
|
} |
497 |
|
|
498 |
rc = mkdir(fname, 0777); |
TARGET_NATIVE_FILE_MAKE_DIR(pathname,result); |
499 |
(*env)->ReleaseStringUTFChars(env, name, fname); |
(*env)->ReleaseStringUTFChars(env, name, pathname); |
500 |
|
|
501 |
if (rc == -1) |
return ((result == TARGET_NATIVE_OK)?1:0); |
502 |
return(0); |
#else /* not WITHOUT_FILESYSTEM */ |
503 |
else |
return(0); |
504 |
return(1); |
#endif /* not WITHOUT_FILESYSTEM */ |
505 |
} |
} |
506 |
|
|
507 |
/*************************************************************************/ |
/*************************************************************************/ |
517 |
JNIEXPORT jboolean JNICALL |
JNIEXPORT jboolean JNICALL |
518 |
Java_java_io_File_renameToInternal(JNIEnv *env, jobject obj, jstring t, jstring d) |
Java_java_io_File_renameToInternal(JNIEnv *env, jobject obj, jstring t, jstring d) |
519 |
{ |
{ |
520 |
const char *target, *destination; |
#ifndef WITHOUT_FILESYSTEM |
521 |
int rc; |
const char *old_filename, *new_filename; |
522 |
|
int result; |
523 |
|
|
524 |
/* Don't use the JCL convert function because it throws an exception |
/* Don't use the JCL convert function because it throws an exception |
525 |
on failure */ |
on failure */ |
526 |
target = (*env)->GetStringUTFChars(env, t, 0); |
old_filename = (*env)->GetStringUTFChars(env, t, 0); |
527 |
if (!target) |
if (old_filename == NULL) |
528 |
return(0); |
{ |
529 |
|
return(0); |
530 |
|
} |
531 |
|
|
532 |
destination = (*env)->GetStringUTFChars(env, d, 0); |
new_filename = (*env)->GetStringUTFChars(env, d, 0); |
533 |
if (!destination) |
if (new_filename == NULL) |
534 |
{ |
{ |
535 |
(*env)->ReleaseStringUTFChars(env, t, target); |
(*env)->ReleaseStringUTFChars(env, t, old_filename); |
536 |
return(0); |
return(0); |
537 |
} |
} |
538 |
|
|
539 |
rc = rename(target, destination); |
TARGET_NATIVE_FILE_RENAME(old_filename,new_filename,result); |
540 |
(*env)->ReleaseStringUTFChars(env, t, target); |
(*env)->ReleaseStringUTFChars(env, d, new_filename); |
541 |
(*env)->ReleaseStringUTFChars(env, d, destination); |
(*env)->ReleaseStringUTFChars(env, t, old_filename); |
542 |
|
|
543 |
if (rc == -1) |
return ((result == TARGET_NATIVE_OK)?1:0); |
544 |
return(0); |
#else /* not WITHOUT_FILESYSTEM */ |
545 |
else |
return(0); |
546 |
return(1); |
#endif /* not WITHOUT_FILESYSTEM */ |
547 |
} |
} |
548 |
|
|
549 |
/*************************************************************************/ |
/*************************************************************************/ |
560 |
JNIEXPORT jobjectArray JNICALL |
JNIEXPORT jobjectArray JNICALL |
561 |
Java_java_io_File_listInternal(JNIEnv *env, jobject obj, jstring name) |
Java_java_io_File_listInternal(JNIEnv *env, jobject obj, jstring name) |
562 |
{ |
{ |
563 |
static jclass str_clazz = 0; |
#ifndef WITHOUT_FILESYSTEM |
564 |
int realloc_size = 10; |
const int REALLOC_SIZE = 10; |
565 |
const char *dirname; |
|
566 |
char **filelist; |
const char *dirname; |
567 |
jobjectArray retarray; |
int result; |
568 |
DIR *dir; |
char **filelist; |
569 |
struct dirent *dirent; |
void *handle; |
570 |
int i, j; |
const char *filename; |
571 |
|
unsigned long int filelist_count,max_filelist_count; |
572 |
|
char **tmp_filelist; |
573 |
|
jclass str_clazz; |
574 |
|
jobjectArray filearray; |
575 |
|
unsigned long int i; |
576 |
|
jstring str; |
577 |
|
|
578 |
/* Don't use the JCL convert function because it throws an exception |
/* Don't use the JCL convert function because it throws an exception |
579 |
on failure */ |
on failure */ |
580 |
dirname = (*env)->GetStringUTFChars(env, name, 0); |
dirname = (*env)->GetStringUTFChars(env, name, 0); |
581 |
if (!dirname) |
if (dirname == NULL) |
582 |
return(0); |
{ |
583 |
|
return(0); |
584 |
|
} |
585 |
|
|
586 |
|
/* open directory for reading */ |
587 |
|
TARGET_NATIVE_FILE_OPEN_DIR(dirname,handle,result); |
588 |
|
|
|
/* Read the files from the directory */ |
|
|
filelist = (char **)JCL_malloc(env, sizeof(char *) * realloc_size); |
|
|
//filelist = (char **)malloc(sizeof(char *) * realloc_size); |
|
|
dir = opendir(dirname); |
|
589 |
(*env)->ReleaseStringUTFChars(env, name, dirname); |
(*env)->ReleaseStringUTFChars(env, name, dirname); |
|
if (!filelist || !dir) |
|
|
return(0); |
|
590 |
|
|
591 |
for (i = 0;;) |
if (result != TARGET_NATIVE_OK) |
592 |
{ |
{ |
593 |
dirent = readdir(dir); |
return(0); |
594 |
if (!dirent) |
} |
595 |
break; |
|
596 |
|
/* allocate filelist */ |
597 |
if (!strcmp(dirent->d_name, ".") || !strcmp(dirent->d_name, "..")) |
filelist = (char **)JCL_malloc(env, sizeof(char *) * REALLOC_SIZE); |
598 |
continue; |
if (filelist==NULL) |
599 |
|
{ |
600 |
/* Allocate more memory if necessary */ |
TARGET_NATIVE_FILE_CLOSE_DIR(handle,result); |
601 |
if ((((i + 1) % realloc_size) == 0) && (i != 0)) |
return(0); |
602 |
|
} |
603 |
|
filelist_count=0; |
604 |
|
max_filelist_count=REALLOC_SIZE; |
605 |
|
|
606 |
|
/* read the files from the directory */ |
607 |
|
TARGET_NATIVE_FILE_READ_DIR(handle,filename,result); |
608 |
|
while (result == TARGET_NATIVE_OK) |
609 |
|
{ |
610 |
|
if ((strcmp(filename, ".")!=0) && (strcmp(filename, "..")!=0)) |
611 |
{ |
{ |
612 |
char **newlist; |
/* allocate more memory if necessary */ |
613 |
|
if (filelist_count >= max_filelist_count) |
|
newlist = JCL_realloc(env, filelist, ((i + 1) + realloc_size) * |
|
|
sizeof(char *)); |
|
|
//newlist = realloc(filelist, (i + 1) + realloc_size); |
|
|
if (!filelist) |
|
614 |
{ |
{ |
615 |
free(filelist); |
tmp_filelist = (char**)JCL_realloc(env, |
616 |
return(0); |
filelist, |
617 |
|
(max_filelist_count + REALLOC_SIZE) * sizeof(char*)); |
618 |
|
if (tmp_filelist==NULL) |
619 |
|
{ |
620 |
|
for (i = 0; i < filelist_count; i++) |
621 |
|
{ |
622 |
|
JCL_free(env,filelist[i]); |
623 |
|
} |
624 |
|
JCL_free(env,filelist); |
625 |
|
TARGET_NATIVE_FILE_CLOSE_DIR(handle,result); |
626 |
|
return(0); |
627 |
|
} |
628 |
|
filelist = tmp_filelist; |
629 |
|
max_filelist_count += REALLOC_SIZE; |
630 |
} |
} |
631 |
filelist = newlist; |
|
632 |
} |
/* save entry in list (avoid strdup, because it is not ANSI C, thus difficult to port) */ |
633 |
|
filelist[filelist_count]=(char*)JCL_malloc(env,strlen(filename)+1); |
634 |
filelist[i] = strdup(dirent->d_name); |
assert(filelist[filelist_count]!=NULL); |
635 |
++i; |
strcpy(filelist[filelist_count],filename); |
636 |
|
filelist_count++; |
637 |
|
} |
638 |
|
|
639 |
|
/* read next directory entry */ |
640 |
|
TARGET_NATIVE_FILE_READ_DIR(handle,filename,result); |
641 |
} |
} |
|
closedir(dir); |
|
642 |
|
|
643 |
/* Now put the list of files into a Java String array and return it */ |
/* close directory */ |
644 |
|
TARGET_NATIVE_FILE_CLOSE_DIR(handle,result); |
645 |
|
|
646 |
|
/* put the list of files into a Java String array and return it */ |
647 |
str_clazz = (*env)->FindClass(env, "java/lang/String"); |
str_clazz = (*env)->FindClass(env, "java/lang/String"); |
648 |
if (!str_clazz) |
if (str_clazz==NULL) |
649 |
{ |
{ |
650 |
free(filelist); |
for (i = 0; i < filelist_count; i++) |
651 |
|
{ |
652 |
|
JCL_free(env,filelist[i]); |
653 |
|
} |
654 |
|
JCL_free(env,filelist); |
655 |
return(0); |
return(0); |
656 |
} |
} |
657 |
|
filearray = (*env)->NewObjectArray(env, filelist_count, str_clazz, 0); |
658 |
retarray = (*env)->NewObjectArray(env, i, str_clazz, 0); |
if (filearray==NULL) |
|
if (!retarray) |
|
659 |
{ |
{ |
660 |
free(filelist); |
for (i = 0; i < filelist_count; i++) |
661 |
|
{ |
662 |
|
JCL_free(env,filelist[i]); |
663 |
|
} |
664 |
|
JCL_free(env,filelist); |
665 |
return(0); |
return(0); |
666 |
} |
} |
667 |
|
for (i = 0; i < filelist_count; i++) |
|
for (j = 0; j < i; j++) |
|
668 |
{ |
{ |
669 |
jstring str; |
/* create new string */ |
670 |
|
str = (*env)->NewStringUTF(env, filelist[i]); |
671 |
str = (*env)->NewStringUTF(env, filelist[j]); |
if (str==NULL) |
|
if (!str) |
|
672 |
{ |
{ |
673 |
/* We don't clean up everything here, but if this failed, |
/* We don't clean up everything here, but if this failed, |
674 |
something serious happened anyway */ |
something serious happened anyway */ |
675 |
free(filelist); |
for (i = 0; i < filelist_count; i++) |
676 |
|
{ |
677 |
|
JCL_free(env,filelist[i]); |
678 |
|
} |
679 |
|
JCL_free(env,filelist); |
680 |
return(0); |
return(0); |
681 |
} |
} |
682 |
|
|
683 |
(*env)->SetObjectArrayElement(env, retarray, j, str); |
/* save into array */ |
684 |
|
(*env)->SetObjectArrayElement(env, filearray, i, str); |
685 |
|
} |
686 |
|
|
687 |
|
/* free resources */ |
688 |
|
for (i = 0; i < filelist_count; i++) |
689 |
|
{ |
690 |
|
JCL_free(env,filelist[i]); |
691 |
} |
} |
692 |
|
JCL_free(env,filelist); |
693 |
|
|
694 |
return(retarray); |
return(filearray); |
695 |
|
#else /* not WITHOUT_FILESYSTEM */ |
696 |
|
return(0); |
697 |
|
#endif /* not WITHOUT_FILESYSTEM */ |
698 |
} |
} |
699 |
|
|