Commit | Line | Data |
---|---|---|
805e021f CE |
1 | /* |
2 | * Copyright (c) 2001-2002 International Business Machines Corp. | |
3 | * All rights reserved. | |
4 | * | |
5 | * This software has been released under the terms of the IBM Public | |
6 | * License. For details, see the LICENSE file in the top-level source | |
7 | * directory or online at http://www.openafs.org/dl/license10.html | |
8 | * | |
9 | * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS | |
10 | * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT | |
11 | * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR | |
12 | * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR | |
13 | * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, | |
14 | * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, | |
15 | * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR | |
16 | * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF | |
17 | * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING | |
18 | * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS | |
19 | * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | |
20 | */ | |
21 | ||
22 | #include <afs/param.h> | |
23 | #include <afs/com_err.h> | |
24 | #include <errno.h> | |
25 | ||
26 | #include "Internal.h" | |
27 | #include "org_openafs_jafs_File.h" | |
28 | ||
29 | #include <sys/stat.h> | |
30 | #include <fcntl.h> | |
31 | #include <jni.h> | |
32 | #include <pthread.h> | |
33 | /*#include <afs/afs_usrops.h>*/ | |
34 | #include <afs/prs_fs.h> | |
35 | #include <sys/time.h> | |
36 | #include <unistd.h> | |
37 | ||
38 | /* Access Rights */ | |
39 | #define UAFS_READ 1 | |
40 | #define UAFS_WRITE 2 | |
41 | #define UAFS_INSERT 4 | |
42 | #define UAFS_LOOKUP 8 | |
43 | #define UAFS_DELETE 16 | |
44 | #define UAFS_LOCK 32 | |
45 | #define UAFS_ADMIN 64 | |
46 | ||
47 | #ifdef DMALLOC | |
48 | #include "dmalloc.h" | |
49 | #endif | |
50 | ||
51 | void setFileNotExistsAttributes(JNIEnv *env, jobject *obj); | |
52 | ||
53 | typedef struct { | |
54 | char *fileName; | |
55 | void *next; | |
56 | } FileNameNode; | |
57 | ||
58 | /*static char compile_date[] = COMPILE_DATE;*/ | |
59 | ||
60 | int sub_time(struct timeval *tv1, struct timeval *tv2) | |
61 | { | |
62 | if (tv2->tv_usec > tv1->tv_usec) { | |
63 | tv1->tv_usec += 1000000; | |
64 | tv1->tv_usec -= 1; | |
65 | } | |
66 | ||
67 | tv1->tv_usec -= tv2->tv_usec; | |
68 | tv1->tv_sec -= tv2->tv_sec; | |
69 | } | |
70 | ||
71 | /** | |
72 | * Sets dirName to the absolute path according to the path field | |
73 | * within the Java File object (obj). | |
74 | * | |
75 | * env the Java environment | |
76 | * obj the current Java object | |
77 | */ | |
78 | char* getAbsolutePath(JNIEnv *env, jobject *obj, char *dirName) | |
79 | { | |
80 | jclass thisClass; | |
81 | jstring jDirName; | |
82 | jmethodID getAbsolutePathID; | |
83 | const char *auxDirName; | |
84 | jfieldID fid; | |
85 | ||
86 | thisClass = (*env)->GetObjectClass(env, *obj); | |
87 | if(thisClass == NULL) { | |
88 | fprintf(stderr, "File::getAbsolutePath(): GetObjectClass failed\n"); | |
89 | return NULL; | |
90 | } | |
91 | fid = (*env)->GetFieldID(env, thisClass, "path", "Ljava/lang/String;"); | |
92 | if (fid == 0) { | |
93 | fprintf(stderr, "File::getAbsolutePath(): GetFieldID (path) failed\n"); | |
94 | return NULL; | |
95 | } | |
96 | jDirName = (*env)->GetObjectField(env, *obj, fid); | |
97 | ||
98 | if(jDirName == NULL) { | |
99 | fprintf(stderr, "File::getAbsolutePath(): failed to get file name\n"); | |
100 | return NULL; | |
101 | } | |
102 | auxDirName = (*env) -> GetStringUTFChars(env, jDirName, 0); | |
103 | strcpy(dirName, auxDirName); | |
104 | (*env) -> ReleaseStringUTFChars(env, jDirName, auxDirName); | |
105 | } | |
106 | ||
107 | /** | |
108 | * Performs a file stat on the actual AFS file and populates | |
109 | * the Java object's respective field members with the appropriate values. | |
110 | * method will, if authorized, perform a stat on the | |
111 | * actual AFS file and update its respective field members; defining | |
112 | * this file object's attributes. | |
113 | * | |
114 | * env the Java environment | |
115 | * obj the current Java object | |
116 | * | |
117 | * return true if and only if the current user is allowed to stat the file; | |
118 | * false otherwise. | |
119 | * | |
120 | * throws AFSException | |
121 | */ | |
122 | JNIEXPORT jboolean JNICALL Java_org_openafs_jafs_File_setAttributes | |
123 | (JNIEnv *env, jobject obj) | |
124 | { | |
125 | char target[FILENAME_MAX+1]; | |
126 | char dirName[FILENAME_MAX]; | |
127 | jclass thisClass; | |
128 | jfieldID fid; | |
129 | struct stat st; | |
130 | int rc, fd; | |
131 | int mtpoint = 0; | |
132 | jboolean islink = JNI_FALSE; | |
133 | int i; | |
134 | struct timeval tv0, tv1; | |
135 | ||
136 | /*memset(target, 0, FILENAME_MAX);*/ | |
137 | ||
138 | *dirName = '\0'; | |
139 | getAbsolutePath(env, &obj, dirName); | |
140 | ||
141 | /*fprintf(stderr, "dirName=%s\n", dirName);*/ | |
142 | ||
143 | if(*dirName == '\0') { | |
144 | fprintf(stderr, "File::setAttributes(): failed to get dirName\n"); | |
145 | return JNI_FALSE; | |
146 | } | |
147 | ||
148 | thisClass = (*env) -> GetObjectClass(env, obj); | |
149 | if(thisClass == NULL) { | |
150 | fprintf(stderr, "File::setAttributes(): GetObjectClass failed\n"); | |
151 | return JNI_FALSE; | |
152 | } | |
153 | ||
154 | gettimeofday(&tv0, NULL); | |
155 | if ((strcmp(dirName, "/afs") == 0) || (strcmp(dirName, "/afs/") == 0)) { | |
156 | rc = 1; /* special case for /afs since statmountpoint fails on it */ | |
157 | } else { | |
158 | rc = uafs_statmountpoint(dirName); | |
159 | gettimeofday(&tv1, NULL); | |
160 | sub_time(&tv1, &tv0); | |
161 | /*printf("%s: statmountpoint %d.%06d\n", dirName, tv1.tv_sec, tv1.tv_usec);*/ | |
162 | } | |
163 | ||
164 | if(rc < 0) { | |
165 | setError(env, &obj, errno); | |
166 | if(errno == ENOENT) { | |
167 | setFileNotExistsAttributes(env, &obj); | |
168 | return JNI_TRUE; /* not really an error */ | |
169 | } else { | |
170 | fprintf(stderr, "File::setAttributes(): uafs_statmountpoint failed " | |
171 | "for %s (%s)\n", dirName, afs_error_message(errno)); | |
172 | return JNI_FALSE; | |
173 | } | |
174 | } | |
175 | ||
176 | if (rc == 1) { | |
177 | /* this is an AFS mount point; we don't want to stat it */ | |
178 | /* fake up a stat entry instead */ | |
179 | mtpoint = 1; | |
180 | st.st_mtime = 0; | |
181 | st.st_size = 2048; | |
182 | st.st_mode = 0; /* don't match anything */ | |
183 | } else { | |
184 | mtpoint = 0; | |
185 | fid = (*env)->GetFieldID(env, thisClass, "isLink", "Z"); | |
186 | if (fid == 0) { | |
187 | fprintf(stderr, "File::setAttributes(): GetFieldID (isLink) failed\n"); | |
188 | setError(env, &obj, -1); | |
189 | return JNI_FALSE; | |
190 | } | |
191 | islink = (*env)->GetBooleanField(env, obj, fid); | |
192 | if (islink != JNI_TRUE) { | |
193 | rc = uafs_lstat(dirName, &st); | |
194 | } else { | |
195 | /* Here we are being called on a link object for the second time, | |
196 | so we want info on the object pointed to by the link. */ | |
197 | fprintf(stderr, "islink = TRUE on file %s\n", dirName); | |
198 | rc = uafs_stat(dirName, &st); | |
199 | } | |
200 | ||
201 | if(rc < 0) { | |
202 | setError(env, &obj, errno); | |
203 | fprintf(stderr, "uafs_lstat failed for dir %s: error %d\n", | |
204 | dirName, errno); | |
205 | if(errno == ENOENT) { | |
206 | setFileNotExistsAttributes(env, &obj); | |
207 | return JNI_TRUE; | |
208 | } | |
209 | fprintf(stderr, | |
210 | "File::setAttributes(): uafs_stat failed for %s (%s)\n", | |
211 | dirName, afs_error_message(errno)); | |
212 | return JNI_FALSE; | |
213 | } | |
214 | } | |
215 | ||
216 | fid = (*env)->GetFieldID(env, thisClass, "exists", "Z"); | |
217 | if (fid == 0) { | |
218 | fprintf(stderr, | |
219 | "File::setAttributes(): GetFieldID (exists) failed\n"); | |
220 | setError(env, &obj, -1); | |
221 | return JNI_FALSE; | |
222 | } | |
223 | (*env)->SetBooleanField(env, obj, fid, JNI_TRUE); | |
224 | ||
225 | fid = (*env)->GetFieldID(env, thisClass, "isDirectory", "Z"); | |
226 | if (fid == 0) { | |
227 | fprintf(stderr, | |
228 | "File::setAttributes(): GetFieldID (isDirectory) failed\n"); | |
229 | setError(env, &obj, -1); | |
230 | return JNI_FALSE; | |
231 | } | |
232 | if ((st.st_mode & S_IFMT) == S_IFDIR && !mtpoint) { | |
233 | (*env)->SetBooleanField(env, obj, fid, JNI_TRUE); | |
234 | } else { | |
235 | (*env)->SetBooleanField(env, obj, fid, JNI_FALSE); | |
236 | } | |
237 | ||
238 | fid = (*env)->GetFieldID(env, thisClass, "isFile", "Z"); | |
239 | if (fid == 0) { | |
240 | fprintf(stderr, | |
241 | "File::setAttributes(): GetFieldID (isFile) failed\n"); | |
242 | setError(env, &obj, -1); | |
243 | return JNI_FALSE; | |
244 | } | |
245 | if ((st.st_mode & S_IFMT) == S_IFREG) { | |
246 | (*env)->SetBooleanField(env, obj, fid, JNI_TRUE); | |
247 | } else { | |
248 | (*env)->SetBooleanField(env, obj, fid, JNI_FALSE); | |
249 | } | |
250 | ||
251 | fid = (*env)->GetFieldID(env, thisClass, "isLink", "Z"); | |
252 | if (fid == 0) { | |
253 | fprintf(stderr, | |
254 | "File::setAttributes(): GetFieldID (isLink) failed\n"); | |
255 | setError(env, &obj, -1); | |
256 | return JNI_FALSE; | |
257 | } | |
258 | ||
259 | if (islink != JNI_TRUE) { /* don't re-process link */ | |
260 | if ((st.st_mode & S_IFMT) == S_IFLNK) { | |
261 | (*env)->SetBooleanField(env, obj, fid, JNI_TRUE); | |
262 | ||
263 | /* Find the target of the link */ | |
264 | rc = uafs_readlink(dirName, target, FILENAME_MAX); | |
265 | if (rc < 0) { | |
266 | fprintf(stderr, "File::setAttributes(): uafs_readlink failed\n"); | |
267 | setError(env, &obj, errno); | |
268 | return JNI_FALSE; | |
269 | } else { | |
270 | target[rc] = 0; /* weird that we have to do this */ | |
271 | /*fprintf(stderr, "readlink %s succeeded, target=%s, rc=%d\n", dirName, | |
272 | target, rc);*/ | |
273 | } | |
274 | ||
275 | rc = setString(env, &obj, "target", target); | |
276 | if (rc < 0) { | |
277 | fprintf(stderr, "setString dirName=%s target=%s failed\n", | |
278 | dirName, target); | |
279 | } | |
280 | } else { | |
281 | (*env)->SetBooleanField(env, obj, fid, JNI_FALSE); | |
282 | } | |
283 | } | |
284 | ||
285 | fid = (*env)->GetFieldID(env, thisClass, "isMountPoint", "Z"); | |
286 | if (fid == 0) { | |
287 | fprintf(stderr, | |
288 | "File::setAttributes(): GetFieldID (isMountPoint) failed\n"); | |
289 | setError(env, &obj, -1); | |
290 | return JNI_FALSE; | |
291 | } | |
292 | ||
293 | if (mtpoint) { | |
294 | (*env)->SetBooleanField(env, obj, fid, JNI_TRUE); | |
295 | } else { | |
296 | (*env)->SetBooleanField(env, obj, fid, JNI_FALSE); | |
297 | } | |
298 | ||
299 | fid = (*env)->GetFieldID(env, thisClass, "lastModified", "J"); | |
300 | if (fid == 0) { | |
301 | fprintf(stderr, | |
302 | "File::setAttributes(): GetFieldID (lastModified) failed\n"); | |
303 | setError(env, &obj, -1); | |
304 | return JNI_FALSE; | |
305 | } | |
306 | (*env)->SetLongField(env, obj, fid, ((jlong) st.st_mtime)*1000); | |
307 | ||
308 | fid = (*env)->GetFieldID(env, thisClass, "length", "J"); | |
309 | if (fid == 0) { | |
310 | fprintf(stderr, | |
311 | "File::setAttributes(): GetFieldID (length) failed\n"); | |
312 | setError(env, &obj, -1); | |
313 | return JNI_FALSE; | |
314 | } | |
315 | (*env)->SetLongField(env, obj, fid, st.st_size); | |
316 | ||
317 | setError(env, &obj, 0); | |
318 | ||
319 | return JNI_TRUE; | |
320 | } | |
321 | ||
322 | /** | |
323 | * Returns the permission/ACL mask for the represented directory | |
324 | * | |
325 | * env the Java environment | |
326 | * obj the current Java object | |
327 | * | |
328 | * return permission/ACL mask | |
329 | */ | |
330 | JNIEXPORT jint JNICALL Java_org_openafs_jafs_File_getRights | |
331 | (JNIEnv *env, jobject obj) | |
332 | { | |
333 | char dirName[FILENAME_MAX]; | |
334 | jclass thisClass; | |
335 | jfieldID fid; | |
336 | int rc; | |
337 | int afs_rights; | |
338 | int rights; | |
339 | ||
340 | *dirName = '\0'; | |
341 | getAbsolutePath(env, &obj, dirName); | |
342 | ||
343 | if(*dirName == '\0') { | |
344 | fprintf(stderr, "File::getRights(): failed to get dirName\n"); | |
345 | setError(env, &obj, -1); | |
346 | return JNI_FALSE; | |
347 | } | |
348 | ||
349 | /*-Access Rights- | |
350 | * UAFS_READ 1 | |
351 | * UAFS_WRITE 2 | |
352 | * UAFS_INSERT 4 | |
353 | * UAFS_LOOKUP 8 | |
354 | * UAFS_DELETE 16 | |
355 | * UAFS_LOCK 32 | |
356 | * UAFS_ADMIN 64 | |
357 | */ | |
358 | ||
359 | rights = 0; | |
360 | afs_rights = uafs_getRights(dirName); | |
361 | if (afs_rights < 0) { | |
362 | setError(env, &obj, errno); | |
363 | return -1; | |
364 | } | |
365 | ||
366 | if (afs_rights & PRSFS_READ) | |
367 | rights |= UAFS_READ; | |
368 | if (afs_rights & PRSFS_WRITE) | |
369 | rights |= UAFS_WRITE; | |
370 | if (afs_rights & PRSFS_INSERT) | |
371 | rights |= UAFS_INSERT; | |
372 | if (afs_rights & PRSFS_LOOKUP) | |
373 | rights |= UAFS_LOOKUP; | |
374 | if (afs_rights & PRSFS_DELETE) | |
375 | rights |= UAFS_DELETE; | |
376 | if (afs_rights & PRSFS_LOCK) | |
377 | rights |= UAFS_LOCK; | |
378 | if (afs_rights & PRSFS_ADMINISTER) | |
379 | rights |= UAFS_ADMIN; | |
380 | ||
381 | return rights; | |
382 | } | |
383 | ||
384 | ||
385 | /** | |
386 | * List the contents of the represented directory. | |
387 | * | |
388 | * env the Java environment | |
389 | * obj the current Java object | |
390 | * | |
391 | * return the directory handle | |
392 | */ | |
393 | JNIEXPORT jlong JNICALL Java_org_openafs_jafs_File_listNative | |
394 | (JNIEnv *env, jobject obj, jobject buffer) | |
395 | { | |
396 | return 0; | |
397 | #if 0 | |
398 | char dirName[FILENAME_MAX]; | |
399 | jclass arrayListClass; | |
400 | jmethodID addID; | |
401 | jstring entryJString; | |
402 | usr_DIR *dirp; | |
403 | struct usr_dirent *enp; | |
404 | int i, dirSize; | |
405 | ||
406 | *dirName='\0'; | |
407 | getAbsolutePath(env, &obj, dirName); | |
408 | if(*dirName == '\0') { | |
409 | fprintf(stderr, "File::listNative(): failed to get dirName\n"); | |
410 | setError(env, &obj, -1); | |
411 | return 0; | |
412 | } | |
413 | arrayListClass = (*env)->GetObjectClass(env, buffer); | |
414 | if(arrayListClass == NULL) { | |
415 | fprintf(stderr, "File::listNative(): GetObjectClass failed\n"); | |
416 | setError(env, &obj, -1); | |
417 | return 0; | |
418 | } | |
419 | addID = (*env) -> GetMethodID(env, arrayListClass, "add", | |
420 | "(Ljava/lang/Object;)Z"); | |
421 | if(addID == 0) { | |
422 | fprintf(stderr, | |
423 | "File::listNative(): failed to get addID\n"); | |
424 | setError(env, &obj, -1); | |
425 | return 0; | |
426 | } | |
427 | dirp = uafs_opendir(dirName); | |
428 | if(dirp == NULL) { | |
429 | fprintf(stderr, "File::listNative(): uafs_opendir(%s) failed(%s)\n", | |
430 | dirName, afs_error_message(errno)); | |
431 | setError(env, &obj, errno); | |
432 | //throwAFSSecurityException( env, errno ); | |
433 | return 0; | |
434 | } | |
435 | while((enp = uafs_readdir(dirp)) != NULL) { | |
436 | if(strcmp(enp->d_name, ".") == 0 || strcmp(enp->d_name, "..") == 0) { | |
437 | continue; | |
438 | } | |
439 | entryJString = (*env) -> NewStringUTF(env, enp->d_name); | |
440 | if(entryJString == NULL) { | |
441 | fprintf(stderr, "File::listNative(): NewStringUTF failed\n"); | |
442 | setError(env, &obj, -1); | |
443 | return 0; | |
444 | } | |
445 | (*env) -> CallBooleanMethod(env, buffer, addID, entryJString); | |
446 | } | |
447 | /*uafs_closedir(dirp);*/ | |
448 | ||
449 | setError(env, &obj, 0); | |
450 | ||
451 | return (jlong) dirp; | |
452 | #endif | |
453 | } | |
454 | ||
455 | /** | |
456 | * Close the currently open directory using a provided directory handle. | |
457 | * | |
458 | * env the Java environment | |
459 | * obj the current Java object | |
460 | * | |
461 | * return true if the directory closes without error | |
462 | */ | |
463 | JNIEXPORT jboolean JNICALL Java_org_openafs_jafs_File_closeDir | |
464 | (JNIEnv *env, jobject obj, jlong dp) | |
465 | { | |
466 | ||
467 | return JNI_TRUE; | |
468 | ||
469 | #if 0 | |
470 | usr_DIR *dirp = (usr_DIR *) dp; | |
471 | int rc; | |
472 | ||
473 | rc = uafs_closedir(dirp); | |
474 | if (rc < 0) { | |
475 | setError(env, &obj, errno); | |
476 | return JNI_FALSE; | |
477 | } | |
478 | else return JNI_TRUE; | |
479 | #endif | |
480 | ||
481 | } | |
482 | ||
483 | ||
484 | /** | |
485 | * Removes/deletes the represented file. | |
486 | * | |
487 | * env the Java environment | |
488 | * obj the current Java object | |
489 | * | |
490 | * return true if the file is removed without error | |
491 | */ | |
492 | JNIEXPORT jboolean JNICALL Java_org_openafs_jafs_File_rmfile | |
493 | (JNIEnv *env, jobject obj) | |
494 | { | |
495 | char dirName[FILENAME_MAX]; | |
496 | int rc; | |
497 | ||
498 | *dirName='\0'; | |
499 | getAbsolutePath(env, &obj, dirName); | |
500 | if(*dirName == '\0') { | |
501 | setError(env, &obj, EINVAL); | |
502 | fprintf(stderr, "File::rmfile(): failed to get dirName\n"); | |
503 | return JNI_FALSE; | |
504 | } | |
505 | rc = uafs_unlink(dirName); | |
506 | if(rc < 0) { | |
507 | setError(env, &obj, errno); | |
508 | fprintf(stderr, "File::rmfile(): uafs_unlink failed\n"); | |
509 | return JNI_FALSE; | |
510 | } | |
511 | setError(env, &obj, 0); | |
512 | return JNI_TRUE; | |
513 | } | |
514 | ||
515 | /** | |
516 | * Removes/deletes the represented directory. | |
517 | * | |
518 | * env the Java environment | |
519 | * obj the current Java object | |
520 | * | |
521 | * return true if the directory is removed without error | |
522 | */ | |
523 | JNIEXPORT jboolean JNICALL Java_org_openafs_jafs_File_rmdir | |
524 | (JNIEnv *env, jobject obj) | |
525 | { | |
526 | char dirName[FILENAME_MAX]; | |
527 | int rc; | |
528 | ||
529 | *dirName='\0'; | |
530 | getAbsolutePath(env, &obj, dirName); | |
531 | if(*dirName == '\0') { | |
532 | setError(env, &obj, -1); | |
533 | fprintf(stderr, "File::rmdir(): failed to get dirName\n"); | |
534 | return JNI_FALSE; | |
535 | } | |
536 | rc = uafs_rmdir(dirName); | |
537 | if(rc < 0) { | |
538 | setError(env, &obj, errno); | |
539 | fprintf(stderr, "File::rmdir(): uafs_unlink failed\n"); | |
540 | return JNI_FALSE; | |
541 | } | |
542 | setError(env, &obj, 0); | |
543 | return JNI_TRUE; | |
544 | } | |
545 | ||
546 | /** | |
547 | * Creates the directory named by this abstract pathname. | |
548 | * | |
549 | * env the Java environment | |
550 | * obj the current Java object | |
551 | * | |
552 | * return true if and only if the directory was | |
553 | * created; false otherwise | |
554 | */ | |
555 | JNIEXPORT jboolean JNICALL Java_org_openafs_jafs_File_mkdir | |
556 | (JNIEnv *env, jobject obj) | |
557 | { | |
558 | char dirName[FILENAME_MAX]; | |
559 | int rc; | |
560 | ||
561 | *dirName='\0'; | |
562 | getAbsolutePath(env, &obj, dirName); | |
563 | if(*dirName == '\0') { | |
564 | setError(env, &obj, EINVAL); | |
565 | fprintf(stderr, "File::mkdir(): failed to get dirName\n"); | |
566 | return JNI_FALSE; | |
567 | } | |
568 | rc = uafs_mkdir(dirName, 0755); | |
569 | if(rc < 0) { | |
570 | setError(env, &obj, errno); | |
571 | fprintf(stderr, "File::mkdir(): uafs_mkdir failed\n"); | |
572 | return JNI_FALSE; | |
573 | } | |
574 | setError(env, &obj, 0); | |
575 | return JNI_TRUE; | |
576 | } | |
577 | ||
578 | /** | |
579 | * Renames the file denoted by this abstract pathname. | |
580 | * | |
581 | * env the Java environment | |
582 | * obj the current Java object | |
583 | * dest the new abstract pathname for the named file | |
584 | * | |
585 | * return true if and only if the renaming succeeded; | |
586 | * false otherwise | |
587 | * | |
588 | * throws NullPointerException | |
589 | * If parameter dest is null | |
590 | */ | |
591 | JNIEXPORT jboolean JNICALL Java_org_openafs_jafs_File_renameTo | |
592 | (JNIEnv *env, jobject obj, jobject newFile) | |
593 | { | |
594 | char thisDirName[FILENAME_MAX], newDirName[FILENAME_MAX]; | |
595 | int rc; | |
596 | ||
597 | *thisDirName='\0'; | |
598 | getAbsolutePath(env, &obj, thisDirName); | |
599 | if(*thisDirName == '\0') { | |
600 | setError(env, &obj, -1); | |
601 | fprintf(stderr, "File::renameTo(): failed to get dirName for this \n"); | |
602 | return JNI_FALSE; | |
603 | } | |
604 | *newDirName='\0'; | |
605 | getAbsolutePath(env, &newFile, newDirName); | |
606 | if(*newDirName == '\0') { | |
607 | setError(env, &obj, -1); | |
608 | fprintf(stderr, "File::renameTo(): failed to get dirName for new \n"); | |
609 | return JNI_FALSE; | |
610 | } | |
611 | rc = uafs_rename(thisDirName, newDirName); | |
612 | if(rc < 0) { | |
613 | setError(env, &obj, errno); | |
614 | fprintf(stderr, "File::renameTo(): uafs_rename failed\n"); | |
615 | return JNI_FALSE; | |
616 | } | |
617 | return JNI_TRUE; | |
618 | } | |
619 | ||
620 | /** | |
621 | * Set all the necessary fields within the Java File class to indicate the | |
622 | * does not exist. | |
623 | * | |
624 | * env the Java environment | |
625 | * obj the current Java object | |
626 | */ | |
627 | void setFileNotExistsAttributes | |
628 | (JNIEnv *env, jobject *obj) | |
629 | { | |
630 | jclass thisClass; | |
631 | jfieldID fid; | |
632 | ||
633 | thisClass = (*env) -> GetObjectClass(env, *obj); | |
634 | if(thisClass == NULL) { | |
635 | fprintf(stderr, | |
636 | "File::setFileNotExistsAttributes(): GetObjectClass failed\n"); | |
637 | return; | |
638 | } | |
639 | ||
640 | fid = (*env)->GetFieldID(env, thisClass, "exists", "Z"); | |
641 | if (fid == 0) { | |
642 | fprintf(stderr, | |
643 | "File::setFileNotExistsAttributes(): GetFieldID (exists) failed\n"); | |
644 | return; | |
645 | } | |
646 | (*env)->SetBooleanField(env, *obj, fid, JNI_FALSE); | |
647 | ||
648 | fid = (*env)->GetFieldID(env, thisClass, "isDirectory", "Z"); | |
649 | if (fid == 0) { | |
650 | fprintf(stderr, | |
651 | "File::setFileNotExistsAttributes(): GetFieldID (isDirectory) failed\n"); | |
652 | return; | |
653 | } | |
654 | (*env)->SetBooleanField(env, *obj, fid, JNI_FALSE); | |
655 | ||
656 | fid = (*env)->GetFieldID(env, thisClass, "isFile", "Z"); | |
657 | if (fid == 0) { | |
658 | fprintf(stderr, | |
659 | "File::setFileNotExistsAttributes(): GetFieldID (isDirectory) failed\n"); | |
660 | return; | |
661 | } | |
662 | (*env)->SetBooleanField(env, *obj, fid, JNI_FALSE); | |
663 | ||
664 | fid = (*env)->GetFieldID(env, thisClass, "lastModified", "J"); | |
665 | if (fid == 0) { | |
666 | fprintf(stderr, | |
667 | "File::setFileNotExistsAttributes(): GetFieldID (lastModified) failed\n"); | |
668 | return; | |
669 | } | |
670 | (*env)->SetLongField(env, *obj, fid, 0); | |
671 | ||
672 | ||
673 | fid = (*env)->GetFieldID(env, thisClass, "length", "J"); | |
674 | if (fid == 0) { | |
675 | fprintf(stderr, | |
676 | "File::setFileNotExistsAttributes(): GetFieldID (length) failed\n"); | |
677 | return; | |
678 | } | |
679 | (*env)->SetLongField(env, *obj, fid, 0); | |
680 | ||
681 | return; | |
682 | } | |
683 | ||
684 |