libjava/java/io/natFilePosix.cc

   1 // natFile.cc - Native part of File class for POSIX.
   2
   3 /* Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2006
   4    Free Software Foundation
   5
   6    This file is part of libgcj.
   7
   8 This software is copyrighted work licensed under the terms of the
   9 Libgcj License.  Please consult the file "LIBGCJ_LICENSE" for
  10 details.  */
  11
  12 #include <config.h>
  13
  14 #include <stdio.h>
  15 #include <errno.h>
  16 #include <sys/param.h>
  17 #include <sys/stat.h>
  18 #include <sys/types.h>
  19 #include <fcntl.h>
  20 #ifdef HAVE_UNISTD_H
  21 #include <unistd.h>
  22 #endif
  23 #include <stdlib.h>
  24 #ifdef HAVE_DIRENT_H
  25 #include <dirent.h>
  26 #endif
  27 #include <string.h>
  28 #include <utime.h>
  29
  30 #include <gcj/cni.h>
  31 #include <jvm.h>
  32 #include <java/io/File.h>
  33 #include <java/io/IOException.h>
  34 #include <java/util/ArrayList.h>
  35 #include <java/lang/String.h>
  36 #include <java/io/FilenameFilter.h>
  37 #include <java/io/FileFilter.h>
  38 #include <java/lang/System.h>
  39
  40 jboolean
  41 java::io::File::_access (jint query)
  42 {
  43   char *buf = (char *) __builtin_alloca (JvGetStringUTFLength (path) + 1);
  44   jsize total = JvGetStringUTFRegion (path, 0, path->length(), buf);
  45   buf[total] = '\0';
  46   JvAssert (query == READ || query == WRITE || query == EXISTS
  47             || query == EXEC);
  48 #ifdef HAVE_ACCESS
  49   int mode;
  50   if (query == READ)
  51     mode = R_OK;
  52   else if (query == WRITE)
  53     mode = W_OK;
  54   else if (query == EXISTS)
  55     mode = F_OK;
  56   else
  57     mode = X_OK;
  58   return ::access (buf, mode) == 0;
  59 #else
  60   return false;
  61 #endif
  62 }
  63
  64 jboolean
  65 java::io::File::_stat (jint query)
  66 {
  67   if (query == ISHIDDEN)
  68     return getName()->charAt(0) == '.';
  69
  70 #ifdef HAVE_STAT
  71   char *buf = (char *) __builtin_alloca (JvGetStringUTFLength (path) + 1);
  72   jsize total = JvGetStringUTFRegion (path, 0, path->length(), buf);
  73   buf[total] = '\0';
  74
  75   struct stat sb;
  76   if (::stat (buf, &sb))
  77     return false;
  78
  79   JvAssert (query == DIRECTORY || query == ISFILE);
  80   jboolean r = S_ISDIR (sb.st_mode);
  81   return query == DIRECTORY ? r : ! r;
  82 #else
  83   return false;
  84 #endif
  85 }
  86
  87 jlong
  88 java::io::File::attr (jint query)
  89 {
  90   char *buf = (char *) __builtin_alloca (JvGetStringUTFLength (path) + 1);
  91   jsize total = JvGetStringUTFRegion (path, 0, path->length(), buf);
  92   buf[total] = '\0';
  93
  94 #ifdef HAVE_STAT
  95   struct stat sb;
  96   // FIXME: not sure about return value here.
  97   if (::stat (buf, &sb))
  98     return 0;
  99
 100   JvAssert (query == MODIFIED || query == LENGTH);
 101   return query == MODIFIED ? (jlong)sb.st_mtime * 1000 : sb.st_size;
 102 #else
 103   // There's no good choice here.
 104   return 23;
 105 #endif
 106 }
 107
 108 // These two methods are used to maintain dynamically allocated
 109 // buffers for getCanonicalPath without the overhead of calling
 110 // realloc every time a buffer is modified.  Buffers are sized
 111 // at the smallest multiple of CHUNKSIZ that is greater than or
 112 // equal to the desired length.  The default CHUNKSIZ is 256,
 113 // longer than most paths, so in most cases a getCanonicalPath
 114 // will require only one malloc per buffer.
 115
 116 #define CHUNKLOG 8
 117 #define CHUNKSIZ (1 << CHUNKLOG)
 118
 119 static int
 120 nextChunkSize (int size)
 121 {
 122   return ((size >> CHUNKLOG) + ((size & (CHUNKSIZ - 1)) ? 1 : 0)) << CHUNKLOG;
 123 }
 124
 125 static char *
 126 maybeGrowBuf (char *buf, int *size, int required)
 127 {
 128   if (required > *size)
 129     {
 130       *size = nextChunkSize (required);
 131       buf = (char *) _Jv_Realloc (buf, *size);
 132     }
 133   return buf;
 134 }
 135
 136 // Return a canonical representation of the pathname of this file.  On
 137 // the GNU system this involves the removal of redundant separators,
 138 // references to "." and "..", and symbolic links.
 139 //
 140 // The conversion proceeds on a component-by-component basis: symbolic
 141 // links and references to ".."  are resolved as and when they occur.
 142 // This means that if "/foo/bar" is a symbolic link to "/baz" then the
 143 // canonical form of "/foo/bar/.." is "/" and not "/foo".
 144 //
 145 // In order to mimic the behaviour of proprietary JVMs, non-existant
 146 // path components are allowed (a departure from the normal GNU system
 147 // convention).  This means that if "/foo/bar" is a symbolic link to
 148 // "/baz", the canonical form of "/non-existant-directory/../foo/bar"
 149 // is "/baz".
 150
 151 jstring
 152 java::io::File::getCanonicalPath (void)
 153 {
 154   jstring path = getAbsolutePath ();
 155
 156   int len = JvGetStringUTFLength (path);
 157   int srcl = nextChunkSize (len + 1);
 158   char *src = (char *) _Jv_Malloc (srcl);
 159   JvGetStringUTFRegion (path, 0, path->length(), src);
 160   src[len] = '\0';
 161   int srci = 1;
 162
 163   int dstl = nextChunkSize (2);
 164   char *dst = (char *) _Jv_Malloc (dstl);
 165   dst[0] = '/';
 166   int dsti = 1;
 167
 168   bool fschecks = true;
 169
 170   while (src[srci] != '\0')
 171     {
 172       // Skip slashes.
 173       while (src[srci] == '/')
 174         srci++;
 175       int tmpi = srci;
 176       // Find next slash.
 177       while (src[srci] != '/' && src[srci] != '\0')
 178         srci++;
 179       if (srci == tmpi)
 180         // We hit the end.
 181         break;
 182       len = srci - tmpi;
 183
 184       // Handle "." and "..".
 185       if (len == 1 && src[tmpi] == '.')
 186         continue;
 187       if (len == 2 && src[tmpi] == '.' && src[tmpi + 1] == '.')
 188         {
 189           while (dsti > 1 && dst[dsti - 1] != '/')
 190             dsti--;
 191           if (dsti != 1)
 192             dsti--;
 193           // Reenable filesystem checking if disabled, as we might
 194           // have reversed over whatever caused the problem before.
 195           // At least one proprietary JVM has inconsistencies because
 196           // it does not do this.
 197           fschecks = true;
 198           continue;
 199         }
 200
 201       // Handle real path components.
 202       dst = maybeGrowBuf (dst, &dstl, dsti + (dsti > 1 ? 1 : 0) + len + 1);
 203       int dsti_save = dsti;
 204       if (dsti > 1)
 205         dst[dsti++] = '/';
 206       strncpy (&dst[dsti], &src[tmpi], len);
 207       dsti += len;
 208       if (fschecks == false)
 209         continue;
 210
 211 #if defined (HAVE_LSTAT) && defined (HAVE_READLINK)
 212       struct stat sb;
 213       dst[dsti] = '\0';
 214       if (::lstat (dst, &sb) == 0)
 215         {
 216           if (S_ISLNK (sb.st_mode))
 217             {
 218               int tmpl = CHUNKSIZ;
 219               char *tmp = (char *) _Jv_Malloc (tmpl);
 220
 221               while (1)
 222                 {
 223                   tmpi = ::readlink (dst, tmp, tmpl);
 224                   if (tmpi < 1)
 225                     {
 226                       _Jv_Free (src);
 227                       _Jv_Free (dst);
 228                       _Jv_Free (tmp);
 229                       throw new IOException (
 230                         JvNewStringLatin1 ("readlink failed"));
 231                     }
 232                   if (tmpi < tmpl)
 233                     break;
 234                   tmpl += CHUNKSIZ;
 235                   tmp = (char *) _Jv_Realloc (tmp, tmpl);
 236                 }
 237
 238               // Prepend the link's path to src.
 239               tmp = maybeGrowBuf (tmp, &tmpl, tmpi + strlen (&src[srci]) + 1);
 240               strcpy(&tmp[tmpi], &src[srci]);
 241               _Jv_Free (src);
 242               src = tmp;
 243               srcl = tmpl;
 244               srci = 0;
 245
 246               // Either replace or append dst depending on whether the
 247               // link is relative or absolute.
 248               dsti = src[0] == '/' ? 1 : dsti_save;
 249             }
 250         }
 251       else
 252         {
 253           // Something doesn't exist, or we don't have permission to
 254           // read it, or a previous path component is a directory, or
 255           // a symlink is looped.  Whatever, we can't check the
 256           // filesystem any more.
 257           fschecks = false;
 258         }
 259 #endif // HAVE_LSTAT && HAVE_READLINK
 260     }
 261   dst[dsti] = '\0';
 262
 263   // FIXME: what encoding to assume for file names?  This affects many
 264   // calls.
 265   path = JvNewStringUTF (dst);
 266   _Jv_Free (src);
 267   _Jv_Free (dst);
 268   return path;
 269 }
 270
 271 jboolean
 272 java::io::File::isAbsolute (void)
 273 {
 274   return path->length() > 0 && path->charAt(0) == '/';
 275 }
 276
 277 jobjectArray
 278 java::io::File::performList (java::io::FilenameFilter *filter,
 279                              java::io::FileFilter *fileFilter,
 280                              java::lang::Class *result_type)
 281 {
 282   /* Some systems have dirent.h, but no directory reading functions like
 283      opendir.  */
 284 #if defined(HAVE_DIRENT_H) && defined(HAVE_OPENDIR)
 285   char *buf = (char *) __builtin_alloca (JvGetStringUTFLength (path) + 1);
 286   jsize total = JvGetStringUTFRegion (path, 0, path->length(), buf);
 287   buf[total] = '\0';
 288
 289   DIR *dir = opendir (buf);
 290   if (! dir)
 291     return NULL;
 292
 293   java::util::ArrayList *list = new java::util::ArrayList ();
 294   struct dirent *d;
 295 #if defined(HAVE_READDIR_R) && defined(_POSIX_PTHREAD_SEMANTICS)
 296   int name_max = pathconf (buf, _PC_NAME_MAX);
 297   char dbuf[sizeof (struct dirent) + name_max + 1];
 298   while (readdir_r (dir, (struct dirent *) dbuf, &d) == 0 && d != NULL)
 299 #else /* HAVE_READDIR_R */
 300   while ((d = readdir (dir)) != NULL)
 301 #endif /* HAVE_READDIR_R */
 302     {
 303       // Omit "." and "..".
 304       if (d->d_name[0] == '.'
 305           && (d->d_name[1] == '\0'
 306               || (d->d_name[1] == '.' && d->d_name[2] == '\0')))
 307         continue;
 308
 309       jstring name = JvNewStringUTF (d->d_name);
 310       if (filter && ! filter->accept(this, name))
 311         continue;
 312
 313       if (result_type == &java::io::File::class$)
 314         {
 315           java::io::File *file = new java::io::File (this, name);
 316           if (fileFilter && ! fileFilter->accept(file))
 317             continue;
 318
 319           list->add(file);
 320         }
 321       else
 322         list->add(name);
 323     }
 324
 325   closedir (dir);
 326
 327   jobjectArray ret = JvNewObjectArray (list->size(), result_type, NULL);
 328   list->toArray(ret);
 329   return ret;
 330 #else /* HAVE_DIRENT_H && HAVE_OPENDIR */
 331   return NULL;
 332 #endif /* HAVE_DIRENT_H && HAVE_OPENDIR */
 333 }
 334
 335 jboolean
 336 java::io::File::performMkdir (void)
 337 {
 338   char *buf = (char *) __builtin_alloca (JvGetStringUTFLength (path) + 1);
 339   jsize total = JvGetStringUTFRegion (path, 0, path->length(), buf);
 340   buf[total] = '\0';
 341
 342 #ifdef HAVE_MKDIR
 343   return ::mkdir (buf, 0755) == 0;
 344 #else
 345   return false;
 346 #endif
 347 }
 348
 349 jboolean
 350 java::io::File::setFilePermissions (jboolean enable,
 351                                     jboolean ownerOnly,
 352                                     jint permissions)
 353 {
 354   char *buf = (char *) __builtin_alloca (JvGetStringUTFLength (path) + 1);
 355   jsize total = JvGetStringUTFRegion (path, 0, path->length(), buf);
 356   buf[total] = '\0';
 357   JvAssert (permissions == READ || permissions == WRITE || permissions == EXEC);
 358 #if defined (HAVE_STAT) && defined (HAVE_CHMOD)
 359   mode_t mode = 0;
 360
 361   struct stat sb;
 362   if (::stat (buf, &sb))
 363     return false;
 364
 365   if (ownerOnly)
 366     {
 367       if (permissions == READ)
 368         mode |= S_IRUSR;
 369       else if (permissions == WRITE)
 370         mode |= S_IWUSR;
 371       else if (permissions == EXEC)
 372         mode |= S_IXUSR;
 373     }
 374   else
 375     {
 376       if (permissions == READ)
 377         mode |= (S_IRUSR | S_IRGRP | S_IROTH);
 378       else if (permissions == WRITE)
 379         mode |= (S_IWUSR | S_IWGRP | S_IWOTH);
 380       else if (permissions == EXEC)
 381         mode |= (S_IXUSR | S_IXGRP | S_IXOTH);
 382     }
 383
 384   if (enable)
 385     mode = sb.st_mode | mode;
 386   else
 387     mode = sb.st_mode & ~mode;
 388
 389   if (::chmod(buf, mode) < 0)
 390     return false;
 391   return true;
 392 #else
 393   return false;
 394 #endif
 395 }
 396
 397 jboolean
 398 java::io::File::performSetReadOnly (void)
 399 {
 400   char *buf = (char *) __builtin_alloca (JvGetStringUTFLength (path) + 1);
 401   jsize total = JvGetStringUTFRegion (path, 0, path->length(), buf);
 402   buf[total] = '\0';
 403
 404 #if defined (HAVE_STAT) && defined (HAVE_CHMOD)
 405   struct stat sb;
 406   if (::stat (buf, &sb))
 407     return false;
 408
 409   if (::chmod(buf, sb.st_mode & 0555))
 410     return false;
 411   return true;
 412 #else
 413   return false;
 414 #endif
 415 }
 416
 417 JArray< ::java::io::File *>*
 418 java::io::File::performListRoots ()
 419 {
 420   ::java::io::File *f = new ::java::io::File (JvNewStringLatin1 ("/"));
 421   JArray<java::io::File *> *unixroot
 422     = reinterpret_cast <JArray<java::io::File *>*>
 423           (JvNewObjectArray (1, &java::io::File::class$, f));
 424   elements (unixroot) [0] = f;
 425   return unixroot;
 426 }
 427
 428 jboolean
 429 java::io::File::performRenameTo (File *dest)
 430 {
 431   char *buf = (char *) __builtin_alloca (JvGetStringUTFLength (path) + 1);
 432   jsize total = JvGetStringUTFRegion (path, 0, path->length(), buf);
 433   buf[total] = '\0';
 434   char *buf2
 435     = (char *) __builtin_alloca (JvGetStringUTFLength (dest->path) + 1);
 436   total = JvGetStringUTFRegion (dest->path, 0, dest->path->length(), buf2);
 437   buf2[total] = '\0';
 438
 439 #ifdef HAVE_RENAME
 440   return ::rename (buf, buf2) == 0;
 441 #else
 442   return false;
 443 #endif
 444 }
 445
 446 jboolean
 447 java::io::File::performSetLastModified (jlong time)
 448 {
 449 #ifdef HAVE_UTIME
 450   utimbuf tb;
 451
 452   char *buf = (char *) __builtin_alloca (JvGetStringUTFLength (path) + 1);
 453   jsize total = JvGetStringUTFRegion (path, 0, path->length(), buf);
 454   buf[total] = '\0';
 455
 456   tb.actime = time / 1000;
 457   tb.modtime = time / 1000;
 458   return (::utime (buf, &tb) == 0);
 459 #else
 460   return false;
 461 #endif
 462 }
 463
 464 jboolean
 465 java::io::File::performCreate (void)
 466 {
 467   char *buf = (char *) __builtin_alloca (JvGetStringUTFLength (path) + 1);
 468   jsize total = JvGetStringUTFRegion (path, 0, path->length(), buf);
 469   buf[total] = '\0';
 470
 471   int fd = ::open (buf, O_CREAT | O_EXCL, 0644);
 472
 473   if (fd < 0)
 474     {
 475       if (errno == EEXIST)
 476         return false;
 477       throw new IOException (JvNewStringLatin1 (strerror (errno)));
 478     }
 479   else
 480     {
 481       ::close (fd);
 482       return true;
 483     }
 484 }
 485
 486 jboolean
 487 java::io::File::performDelete (void)
 488 {
 489   char *buf = (char *) __builtin_alloca (JvGetStringUTFLength (path) + 1);
 490   jsize total = JvGetStringUTFRegion (path, 0, path->length(), buf);
 491   buf[total] = '\0';
 492
 493 #ifdef HAVE_UNLINK
 494 #ifdef HAVE_RMDIR
 495   if (! ::rmdir (buf))
 496     return true;
 497   if (errno == ENOTDIR)
 498 #endif // HAVE_RMDIR
 499     return ::unlink (buf) == 0;
 500 #endif // HAVE_UNLINK
 501   return false;
 502 }
 503
 504 void
 505 java::io::File::init_native ()
 506 {
 507 #ifdef MAXPATHLEN
 508   maxPathLen = MAXPATHLEN;
 509 #else
 510   /* Some systems do not have a limit on the length of a file name,
 511      the GNU system is one such example.  */
 512   maxPathLen = 0;
 513 #endif
 514   caseSensitive = true;
 515 }