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









































 571 }
--- EOF ---