1 /* 2 * Copyright (c) 2008, 2020, 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 package sun.nio.fs; 27 28 import jdk.internal.misc.Unsafe; 29 30 import static sun.nio.fs.WindowsConstants.*; 31 32 /** 33 * Win32 and library calls. 34 */ 35 36 class WindowsNativeDispatcher { WindowsNativeDispatcher()37 private WindowsNativeDispatcher() { } 38 39 /** 40 * HANDLE CreateEvent( 41 * LPSECURITY_ATTRIBUTES lpEventAttributes, 42 * BOOL bManualReset, 43 * BOOL bInitialState, 44 * PCTSTR lpName 45 * ); 46 */ CreateEvent(boolean bManualReset, boolean bInitialState)47 static native long CreateEvent(boolean bManualReset, boolean bInitialState) 48 throws WindowsException; 49 50 /** 51 * HANDLE CreateFile( 52 * LPCTSTR lpFileName, 53 * DWORD dwDesiredAccess, 54 * DWORD dwShareMode, 55 * LPSECURITY_ATTRIBUTES lpSecurityAttributes, 56 * DWORD dwCreationDisposition, 57 * DWORD dwFlagsAndAttributes, 58 * HANDLE hTemplateFile 59 * ) 60 */ CreateFile(String path, int dwDesiredAccess, int dwShareMode, long lpSecurityAttributes, int dwCreationDisposition, int dwFlagsAndAttributes)61 static long CreateFile(String path, 62 int dwDesiredAccess, 63 int dwShareMode, 64 long lpSecurityAttributes, 65 int dwCreationDisposition, 66 int dwFlagsAndAttributes) 67 throws WindowsException 68 { 69 NativeBuffer buffer = asNativeBuffer(path); 70 try { 71 return CreateFile0(buffer.address(), 72 dwDesiredAccess, 73 dwShareMode, 74 lpSecurityAttributes, 75 dwCreationDisposition, 76 dwFlagsAndAttributes); 77 } finally { 78 buffer.release(); 79 } 80 } CreateFile(String path, int dwDesiredAccess, int dwShareMode, int dwCreationDisposition, int dwFlagsAndAttributes)81 static long CreateFile(String path, 82 int dwDesiredAccess, 83 int dwShareMode, 84 int dwCreationDisposition, 85 int dwFlagsAndAttributes) 86 throws WindowsException 87 { 88 return CreateFile(path, dwDesiredAccess, dwShareMode, 0L, 89 dwCreationDisposition, dwFlagsAndAttributes); 90 } CreateFile0(long lpFileName, int dwDesiredAccess, int dwShareMode, long lpSecurityAttributes, int dwCreationDisposition, int dwFlagsAndAttributes)91 private static native long CreateFile0(long lpFileName, 92 int dwDesiredAccess, 93 int dwShareMode, 94 long lpSecurityAttributes, 95 int dwCreationDisposition, 96 int dwFlagsAndAttributes) 97 throws WindowsException; 98 99 /** 100 * CloseHandle( 101 * HANDLE hObject 102 * ) 103 */ CloseHandle(long handle)104 static native void CloseHandle(long handle); 105 106 /** 107 * DeleteFile( 108 * LPCTSTR lpFileName 109 * ) 110 */ DeleteFile(String path)111 static void DeleteFile(String path) throws WindowsException { 112 NativeBuffer buffer = asNativeBuffer(path); 113 try { 114 DeleteFile0(buffer.address()); 115 } finally { 116 buffer.release(); 117 } 118 } DeleteFile0(long lpFileName)119 private static native void DeleteFile0(long lpFileName) 120 throws WindowsException; 121 122 /** 123 * CreateDirectory( 124 * LPCTSTR lpPathName, 125 * LPSECURITY_ATTRIBUTES lpSecurityAttributes 126 * ) 127 */ CreateDirectory(String path, long lpSecurityAttributes)128 static void CreateDirectory(String path, long lpSecurityAttributes) throws WindowsException { 129 NativeBuffer buffer = asNativeBuffer(path); 130 try { 131 CreateDirectory0(buffer.address(), lpSecurityAttributes); 132 } finally { 133 buffer.release(); 134 } 135 } CreateDirectory0(long lpFileName, long lpSecurityAttributes)136 private static native void CreateDirectory0(long lpFileName, long lpSecurityAttributes) 137 throws WindowsException; 138 139 /** 140 * RemoveDirectory( 141 * LPCTSTR lpPathName 142 * ) 143 */ RemoveDirectory(String path)144 static void RemoveDirectory(String path) throws WindowsException { 145 NativeBuffer buffer = asNativeBuffer(path); 146 try { 147 RemoveDirectory0(buffer.address()); 148 } finally { 149 buffer.release(); 150 } 151 } RemoveDirectory0(long lpFileName)152 private static native void RemoveDirectory0(long lpFileName) 153 throws WindowsException; 154 155 /** 156 * Marks a file as a sparse file. 157 * 158 * DeviceIoControl( 159 * FSCTL_SET_SPARSE 160 * ) 161 */ DeviceIoControlSetSparse(long handle)162 static native void DeviceIoControlSetSparse(long handle) 163 throws WindowsException; 164 165 /** 166 * Retrieves the reparse point data associated with the file or directory. 167 * 168 * DeviceIoControl( 169 * FSCTL_GET_REPARSE_POINT 170 * ) 171 */ DeviceIoControlGetReparsePoint(long handle, long bufferAddress, int bufferSize)172 static native void DeviceIoControlGetReparsePoint(long handle, 173 long bufferAddress, int bufferSize) throws WindowsException; 174 175 /** 176 * HANDLE FindFirstFile( 177 * LPCTSTR lpFileName, 178 * LPWIN32_FIND_DATA lpFindFileData 179 * ) 180 */ FindFirstFile(String path)181 static FirstFile FindFirstFile(String path) throws WindowsException { 182 NativeBuffer buffer = asNativeBuffer(path); 183 try { 184 FirstFile data = new FirstFile(); 185 FindFirstFile0(buffer.address(), data); 186 return data; 187 } finally { 188 buffer.release(); 189 } 190 } 191 static class FirstFile { 192 private long handle; 193 private String name; 194 private int attributes; 195 FirstFile()196 private FirstFile() { } handle()197 public long handle() { return handle; } name()198 public String name() { return name; } attributes()199 public int attributes() { return attributes; } 200 } FindFirstFile0(long lpFileName, FirstFile obj)201 private static native void FindFirstFile0(long lpFileName, FirstFile obj) 202 throws WindowsException; 203 204 /** 205 * HANDLE FindFirstFile( 206 * LPCTSTR lpFileName, 207 * LPWIN32_FIND_DATA lpFindFileData 208 * ) 209 */ FindFirstFile(String path, long address)210 static long FindFirstFile(String path, long address) throws WindowsException { 211 NativeBuffer buffer = asNativeBuffer(path); 212 try { 213 return FindFirstFile1(buffer.address(), address); 214 } finally { 215 buffer.release(); 216 } 217 } FindFirstFile1(long lpFileName, long address)218 private static native long FindFirstFile1(long lpFileName, long address) 219 throws WindowsException; 220 221 /** 222 * FindNextFile( 223 * HANDLE hFindFile, 224 * LPWIN32_FIND_DATA lpFindFileData 225 * ) 226 * 227 * @return lpFindFileData->cFileName or null 228 */ FindNextFile(long handle, long address)229 static native String FindNextFile(long handle, long address) 230 throws WindowsException; 231 232 /** 233 * HANDLE FindFirstStreamW( 234 * LPCWSTR lpFileName, 235 * STREAM_INFO_LEVELS InfoLevel, 236 * LPVOID lpFindStreamData, 237 * DWORD dwFlags 238 * ) 239 */ FindFirstStream(String path)240 static FirstStream FindFirstStream(String path) throws WindowsException { 241 NativeBuffer buffer = asNativeBuffer(path); 242 try { 243 FirstStream data = new FirstStream(); 244 FindFirstStream0(buffer.address(), data); 245 if (data.handle() == WindowsConstants.INVALID_HANDLE_VALUE) 246 return null; 247 return data; 248 } finally { 249 buffer.release(); 250 } 251 } 252 static class FirstStream { 253 private long handle; 254 private String name; 255 FirstStream()256 private FirstStream() { } handle()257 public long handle() { return handle; } name()258 public String name() { return name; } 259 } FindFirstStream0(long lpFileName, FirstStream obj)260 private static native void FindFirstStream0(long lpFileName, FirstStream obj) 261 throws WindowsException; 262 263 /* 264 * FindNextStreamW( 265 * HANDLE hFindStream, 266 * LPVOID lpFindStreamData 267 * ) 268 */ FindNextStream(long handle)269 static native String FindNextStream(long handle) throws WindowsException; 270 271 /** 272 * FindClose( 273 * HANDLE hFindFile 274 * ) 275 */ FindClose(long handle)276 static native void FindClose(long handle) throws WindowsException; 277 278 /** 279 * GetFileInformationByHandle( 280 * HANDLE hFile, 281 * LPBY_HANDLE_FILE_INFORMATION lpFileInformation 282 * ) 283 */ GetFileInformationByHandle(long handle, long address)284 static native void GetFileInformationByHandle(long handle, long address) 285 throws WindowsException; 286 287 /** 288 * CopyFileEx( 289 * LPCWSTR lpExistingFileName 290 * LPCWSTR lpNewFileName, 291 * LPPROGRESS_ROUTINE lpProgressRoutine 292 * LPVOID lpData, 293 * LPBOOL pbCancel, 294 * DWORD dwCopyFlags 295 * ) 296 */ CopyFileEx(String source, String target, int flags, long addressToPollForCancel)297 static void CopyFileEx(String source, String target, int flags, 298 long addressToPollForCancel) 299 throws WindowsException 300 { 301 NativeBuffer sourceBuffer = asNativeBuffer(source); 302 NativeBuffer targetBuffer = asNativeBuffer(target); 303 try { 304 CopyFileEx0(sourceBuffer.address(), targetBuffer.address(), flags, 305 addressToPollForCancel); 306 } finally { 307 targetBuffer.release(); 308 sourceBuffer.release(); 309 } 310 } CopyFileEx0(long existingAddress, long newAddress, int flags, long addressToPollForCancel)311 private static native void CopyFileEx0(long existingAddress, long newAddress, 312 int flags, long addressToPollForCancel) throws WindowsException; 313 314 /** 315 * MoveFileEx( 316 * LPCTSTR lpExistingFileName, 317 * LPCTSTR lpNewFileName, 318 * DWORD dwFlags 319 * ) 320 */ MoveFileEx(String source, String target, int flags)321 static void MoveFileEx(String source, String target, int flags) 322 throws WindowsException 323 { 324 NativeBuffer sourceBuffer = asNativeBuffer(source); 325 NativeBuffer targetBuffer = asNativeBuffer(target); 326 try { 327 MoveFileEx0(sourceBuffer.address(), targetBuffer.address(), flags); 328 } finally { 329 targetBuffer.release(); 330 sourceBuffer.release(); 331 } 332 } MoveFileEx0(long existingAddress, long newAddress, int flags)333 private static native void MoveFileEx0(long existingAddress, long newAddress, 334 int flags) throws WindowsException; 335 336 /** 337 * DWORD GetFileAttributes( 338 * LPCTSTR lpFileName 339 * ) 340 */ GetFileAttributes(String path)341 static int GetFileAttributes(String path) throws WindowsException { 342 NativeBuffer buffer = asNativeBuffer(path); 343 try { 344 return GetFileAttributes0(buffer.address()); 345 } finally { 346 buffer.release(); 347 } 348 } GetFileAttributes0(long lpFileName)349 private static native int GetFileAttributes0(long lpFileName) 350 throws WindowsException; 351 352 /** 353 * SetFileAttributes( 354 * LPCTSTR lpFileName, 355 * DWORD dwFileAttributes 356 */ SetFileAttributes(String path, int dwFileAttributes)357 static void SetFileAttributes(String path, int dwFileAttributes) 358 throws WindowsException 359 { 360 NativeBuffer buffer = asNativeBuffer(path); 361 try { 362 SetFileAttributes0(buffer.address(), dwFileAttributes); 363 } finally { 364 buffer.release(); 365 } 366 } SetFileAttributes0(long lpFileName, int dwFileAttributes)367 private static native void SetFileAttributes0(long lpFileName, 368 int dwFileAttributes) throws WindowsException; 369 370 /** 371 * GetFileAttributesEx( 372 * LPCTSTR lpFileName, 373 * GET_FILEEX_INFO_LEVELS fInfoLevelId, 374 * LPVOID lpFileInformation 375 * ); 376 */ GetFileAttributesEx(String path, long address)377 static void GetFileAttributesEx(String path, long address) throws WindowsException { 378 NativeBuffer buffer = asNativeBuffer(path); 379 try { 380 GetFileAttributesEx0(buffer.address(), address); 381 } finally { 382 buffer.release(); 383 } 384 } GetFileAttributesEx0(long lpFileName, long address)385 private static native void GetFileAttributesEx0(long lpFileName, long address) 386 throws WindowsException; 387 /** 388 * SetFileTime( 389 * HANDLE hFile, 390 * CONST FILETIME *lpCreationTime, 391 * CONST FILETIME *lpLastAccessTime, 392 * CONST FILETIME *lpLastWriteTime 393 * ) 394 */ SetFileTime(long handle, long createTime, long lastAccessTime, long lastWriteTime)395 static native void SetFileTime(long handle, 396 long createTime, 397 long lastAccessTime, 398 long lastWriteTime) 399 throws WindowsException; 400 401 /** 402 * SetEndOfFile( 403 * HANDLE hFile 404 * ) 405 */ SetEndOfFile(long handle)406 static native void SetEndOfFile(long handle) throws WindowsException; 407 408 /** 409 * DWORD GetLogicalDrives(VOID) 410 */ GetLogicalDrives()411 static native int GetLogicalDrives() throws WindowsException; 412 413 /** 414 * GetVolumeInformation( 415 * LPCTSTR lpRootPathName, 416 * LPTSTR lpVolumeNameBuffer, 417 * DWORD nVolumeNameSize, 418 * LPDWORD lpVolumeSerialNumber, 419 * LPDWORD lpMaximumComponentLength, 420 * LPDWORD lpFileSystemFlags, 421 * LPTSTR lpFileSystemNameBuffer, 422 * DWORD nFileSystemNameSize 423 * ) 424 */ GetVolumeInformation(String root)425 static VolumeInformation GetVolumeInformation(String root) 426 throws WindowsException 427 { 428 NativeBuffer buffer = asNativeBuffer(root); 429 try { 430 VolumeInformation info = new VolumeInformation(); 431 GetVolumeInformation0(buffer.address(), info); 432 return info; 433 } finally { 434 buffer.release(); 435 } 436 } 437 static class VolumeInformation { 438 private String fileSystemName; 439 private String volumeName; 440 private int volumeSerialNumber; 441 private int flags; VolumeInformation()442 private VolumeInformation() { } 443 fileSystemName()444 public String fileSystemName() { return fileSystemName; } volumeName()445 public String volumeName() { return volumeName; } volumeSerialNumber()446 public int volumeSerialNumber() { return volumeSerialNumber; } flags()447 public int flags() { return flags; } 448 } GetVolumeInformation0(long lpRoot, VolumeInformation obj)449 private static native void GetVolumeInformation0(long lpRoot, 450 VolumeInformation obj) 451 throws WindowsException; 452 453 /** 454 * UINT GetDriveType( 455 * LPCTSTR lpRootPathName 456 * ) 457 */ GetDriveType(String root)458 static int GetDriveType(String root) throws WindowsException { 459 NativeBuffer buffer = asNativeBuffer(root); 460 try { 461 return GetDriveType0(buffer.address()); 462 } finally { 463 buffer.release(); 464 } 465 } GetDriveType0(long lpRoot)466 private static native int GetDriveType0(long lpRoot) throws WindowsException; 467 468 /** 469 * GetDiskFreeSpaceEx( 470 * LPCTSTR lpDirectoryName, 471 * PULARGE_INTEGER lpFreeBytesAvailableToCaller, 472 * PULARGE_INTEGER lpTotalNumberOfBytes, 473 * PULARGE_INTEGER lpTotalNumberOfFreeBytes 474 * ) 475 */ GetDiskFreeSpaceEx(String path)476 static DiskFreeSpace GetDiskFreeSpaceEx(String path) 477 throws WindowsException 478 { 479 NativeBuffer buffer = asNativeBuffer(path); 480 try { 481 DiskFreeSpace space = new DiskFreeSpace(); 482 GetDiskFreeSpaceEx0(buffer.address(), space); 483 return space; 484 } finally { 485 buffer.release(); 486 } 487 } 488 489 /** 490 * GetDiskFreeSpace( 491 * LPCTSTR lpRootPathName, 492 * LPDWORD lpSectorsPerCluster, 493 * LPDWORD lpBytesPerSector, 494 * LPDWORD lpNumberOfFreeClusters, 495 * LPDWORD lpTotalNumberOfClusters 496 * ) 497 */ GetDiskFreeSpace(String path)498 static DiskFreeSpace GetDiskFreeSpace(String path) 499 throws WindowsException 500 { 501 NativeBuffer buffer = asNativeBuffer(path); 502 try { 503 DiskFreeSpace space = new DiskFreeSpace(); 504 GetDiskFreeSpace0(buffer.address(), space); 505 return space; 506 } finally { 507 buffer.release(); 508 } 509 } 510 511 static class DiskFreeSpace { 512 private long freeBytesAvailable; 513 private long totalNumberOfBytes; 514 private long totalNumberOfFreeBytes; 515 private long bytesPerSector; DiskFreeSpace()516 private DiskFreeSpace() { } 517 freeBytesAvailable()518 public long freeBytesAvailable() { return freeBytesAvailable; } totalNumberOfBytes()519 public long totalNumberOfBytes() { return totalNumberOfBytes; } totalNumberOfFreeBytes()520 public long totalNumberOfFreeBytes() { return totalNumberOfFreeBytes; } bytesPerSector()521 public long bytesPerSector() { return bytesPerSector; } 522 } GetDiskFreeSpaceEx0(long lpDirectoryName, DiskFreeSpace obj)523 private static native void GetDiskFreeSpaceEx0(long lpDirectoryName, 524 DiskFreeSpace obj) 525 throws WindowsException; 526 527 GetDiskFreeSpace0(long lpRootPathName, DiskFreeSpace obj)528 private static native void GetDiskFreeSpace0(long lpRootPathName, 529 DiskFreeSpace obj) 530 throws WindowsException; 531 532 /** 533 * GetVolumePathName( 534 * LPCTSTR lpszFileName, 535 * LPTSTR lpszVolumePathName, 536 * DWORD cchBufferLength 537 * ) 538 * 539 * @return lpFileName 540 */ GetVolumePathName(String path)541 static String GetVolumePathName(String path) throws WindowsException { 542 NativeBuffer buffer = asNativeBuffer(path); 543 try { 544 return GetVolumePathName0(buffer.address()); 545 } finally { 546 buffer.release(); 547 } 548 } GetVolumePathName0(long lpFileName)549 private static native String GetVolumePathName0(long lpFileName) 550 throws WindowsException; 551 552 553 /** 554 * InitializeSecurityDescriptor( 555 * PSECURITY_DESCRIPTOR pSecurityDescriptor, 556 * DWORD dwRevision 557 * ) 558 */ InitializeSecurityDescriptor(long sdAddress)559 static native void InitializeSecurityDescriptor(long sdAddress) 560 throws WindowsException; 561 562 /** 563 * InitializeAcl( 564 * PACL pAcl, 565 * DWORD nAclLength, 566 * DWORD dwAclRevision 567 * ) 568 */ InitializeAcl(long aclAddress, int size)569 static native void InitializeAcl(long aclAddress, int size) 570 throws WindowsException; 571 572 /** 573 * GetFileSecurity( 574 * LPCTSTR lpFileName, 575 * SECURITY_INFORMATION RequestedInformation, 576 * PSECURITY_DESCRIPTOR pSecurityDescriptor, 577 * DWORD nLength, 578 * LPDWORD lpnLengthNeeded 579 * ) 580 */ GetFileSecurity(String path, int requestedInformation, long pSecurityDescriptor, int nLength)581 static int GetFileSecurity(String path, 582 int requestedInformation, 583 long pSecurityDescriptor, 584 int nLength) throws WindowsException 585 { 586 NativeBuffer buffer = asNativeBuffer(path); 587 try { 588 return GetFileSecurity0(buffer.address(), requestedInformation, 589 pSecurityDescriptor, nLength); 590 } finally { 591 buffer.release(); 592 } 593 } GetFileSecurity0(long lpFileName, int requestedInformation, long pSecurityDescriptor, int nLength)594 private static native int GetFileSecurity0(long lpFileName, 595 int requestedInformation, 596 long pSecurityDescriptor, 597 int nLength) throws WindowsException; 598 599 /** 600 * SetFileSecurity( 601 * LPCTSTR lpFileName, 602 * SECURITY_INFORMATION SecurityInformation, 603 * PSECURITY_DESCRIPTOR pSecurityDescriptor 604 * ) 605 */ SetFileSecurity(String path, int securityInformation, long pSecurityDescriptor)606 static void SetFileSecurity(String path, 607 int securityInformation, 608 long pSecurityDescriptor) 609 throws WindowsException 610 { 611 NativeBuffer buffer = asNativeBuffer(path); 612 try { 613 SetFileSecurity0(buffer.address(), securityInformation, 614 pSecurityDescriptor); 615 } finally { 616 buffer.release(); 617 } 618 } SetFileSecurity0(long lpFileName, int securityInformation, long pSecurityDescriptor)619 static native void SetFileSecurity0(long lpFileName, int securityInformation, 620 long pSecurityDescriptor) throws WindowsException; 621 622 /** 623 * GetSecurityDescriptorOwner( 624 * PSECURITY_DESCRIPTOR pSecurityDescriptor 625 * PSID *pOwner, 626 * LPBOOL lpbOwnerDefaulted 627 * ) 628 * 629 * @return pOwner 630 */ GetSecurityDescriptorOwner(long pSecurityDescriptor)631 static native long GetSecurityDescriptorOwner(long pSecurityDescriptor) 632 throws WindowsException; 633 634 /** 635 * SetSecurityDescriptorOwner( 636 * PSECURITY_DESCRIPTOR pSecurityDescriptor, 637 * PSID pOwner, 638 * BOOL bOwnerDefaulted 639 * ) 640 */ SetSecurityDescriptorOwner(long pSecurityDescriptor, long pOwner)641 static native void SetSecurityDescriptorOwner(long pSecurityDescriptor, 642 long pOwner) 643 throws WindowsException; 644 645 /** 646 * GetSecurityDescriptorDacl( 647 * PSECURITY_DESCRIPTOR pSecurityDescriptor, 648 * LPBOOL lpbDaclPresent, 649 * PACL *pDacl, 650 * LPBOOL lpbDaclDefaulted 651 * ) 652 */ GetSecurityDescriptorDacl(long pSecurityDescriptor)653 static native long GetSecurityDescriptorDacl(long pSecurityDescriptor); 654 655 /** 656 * SetSecurityDescriptorDacl( 657 * PSECURITY_DESCRIPTOR pSecurityDescriptor, 658 * BOOL bDaclPresent, 659 * PACL pDacl, 660 * BOOL bDaclDefaulted 661 * ) 662 */ SetSecurityDescriptorDacl(long pSecurityDescriptor, long pAcl)663 static native void SetSecurityDescriptorDacl(long pSecurityDescriptor, long pAcl) 664 throws WindowsException; 665 666 667 /** 668 * GetAclInformation( 669 * PACL pAcl, 670 * LPVOID pAclInformation, 671 * DWORD nAclInformationLength, 672 * ACL_INFORMATION_CLASS dwAclInformationClass 673 * ) 674 */ GetAclInformation(long aclAddress)675 static AclInformation GetAclInformation(long aclAddress) { 676 AclInformation info = new AclInformation(); 677 GetAclInformation0(aclAddress, info); 678 return info; 679 } 680 static class AclInformation { 681 private int aceCount; AclInformation()682 private AclInformation() { } 683 aceCount()684 public int aceCount() { return aceCount; } 685 } GetAclInformation0(long aclAddress, AclInformation obj)686 private static native void GetAclInformation0(long aclAddress, 687 AclInformation obj); 688 689 /** 690 * GetAce( 691 * PACL pAcl, 692 * DWORD dwAceIndex, 693 * LPVOID *pAce 694 * ) 695 */ GetAce(long aclAddress, int aceIndex)696 static native long GetAce(long aclAddress, int aceIndex); 697 698 /** 699 * AddAccessAllowedAceEx( 700 * PACL pAcl, 701 * DWORD dwAceRevision, 702 * DWORD AceFlags, 703 * DWORD AccessMask, 704 * PSID pSid 705 * ) 706 */ AddAccessAllowedAceEx(long aclAddress, int flags, int mask, long sidAddress)707 static native void AddAccessAllowedAceEx(long aclAddress, int flags, 708 int mask, long sidAddress) throws WindowsException; 709 710 /** 711 * AddAccessDeniedAceEx( 712 * PACL pAcl, 713 * DWORD dwAceRevision, 714 * DWORD AceFlags, 715 * DWORD AccessMask, 716 * PSID pSid 717 * ) 718 */ AddAccessDeniedAceEx(long aclAddress, int flags, int mask, long sidAddress)719 static native void AddAccessDeniedAceEx(long aclAddress, int flags, 720 int mask, long sidAddress) throws WindowsException; 721 722 /** 723 * LookupAccountSid( 724 * LPCTSTR lpSystemName, 725 * PSID Sid, 726 * LPTSTR Name, 727 * LPDWORD cbName, 728 * LPTSTR ReferencedDomainName, 729 * LPDWORD cbReferencedDomainName, 730 * PSID_NAME_USE peUse 731 * ) 732 */ LookupAccountSid(long sidAddress)733 static Account LookupAccountSid(long sidAddress) throws WindowsException { 734 Account acc = new Account(); 735 LookupAccountSid0(sidAddress, acc); 736 return acc; 737 } 738 static class Account { 739 private String domain; 740 private String name; 741 private int use; Account()742 private Account() { } 743 domain()744 public String domain() { return domain; } name()745 public String name() { return name; } use()746 public int use() { return use; } 747 } LookupAccountSid0(long sidAddress, Account obj)748 private static native void LookupAccountSid0(long sidAddress, Account obj) 749 throws WindowsException; 750 751 /** 752 * LookupAccountName( 753 * LPCTSTR lpSystemName, 754 * LPCTSTR lpAccountName, 755 * PSID Sid, 756 * LPDWORD cbSid, 757 * LPTSTR ReferencedDomainName, 758 * LPDWORD cbReferencedDomainName, 759 * PSID_NAME_USE peUse 760 * ) 761 * 762 * @return cbSid 763 */ LookupAccountName(String accountName, long pSid, int cbSid)764 static int LookupAccountName(String accountName, 765 long pSid, 766 int cbSid) throws WindowsException 767 { 768 NativeBuffer buffer = asNativeBuffer(accountName); 769 try { 770 return LookupAccountName0(buffer.address(), pSid, cbSid); 771 } finally { 772 buffer.release(); 773 } 774 } LookupAccountName0(long lpAccountName, long pSid, int cbSid)775 private static native int LookupAccountName0(long lpAccountName, long pSid, 776 int cbSid) throws WindowsException; 777 778 /** 779 * DWORD GetLengthSid( 780 * PSID pSid 781 * ) 782 */ GetLengthSid(long sidAddress)783 static native int GetLengthSid(long sidAddress); 784 785 /** 786 * ConvertSidToStringSid( 787 * PSID Sid, 788 * LPTSTR* StringSid 789 * ) 790 * 791 * @return StringSid 792 */ ConvertSidToStringSid(long sidAddress)793 static native String ConvertSidToStringSid(long sidAddress) 794 throws WindowsException; 795 796 /** 797 * ConvertStringSidToSid( 798 * LPCTSTR StringSid, 799 * PSID* pSid 800 * ) 801 * 802 * @return pSid 803 */ ConvertStringSidToSid(String sidString)804 static long ConvertStringSidToSid(String sidString) 805 throws WindowsException 806 { 807 NativeBuffer buffer = asNativeBuffer(sidString); 808 try { 809 return ConvertStringSidToSid0(buffer.address()); 810 } finally { 811 buffer.release(); 812 } 813 } ConvertStringSidToSid0(long lpStringSid)814 private static native long ConvertStringSidToSid0(long lpStringSid) 815 throws WindowsException; 816 817 /** 818 * HANDLE GetCurrentProcess(VOID) 819 */ GetCurrentProcess()820 static native long GetCurrentProcess(); 821 822 /** 823 * HANDLE GetCurrentThread(VOID) 824 */ GetCurrentThread()825 static native long GetCurrentThread(); 826 827 /** 828 * OpenProcessToken( 829 * HANDLE ProcessHandle, 830 * DWORD DesiredAccess, 831 * PHANDLE TokenHandle 832 * ) 833 */ OpenProcessToken(long hProcess, int desiredAccess)834 static native long OpenProcessToken(long hProcess, int desiredAccess) 835 throws WindowsException; 836 837 /** 838 * OpenThreadToken( 839 * HANDLE ThreadHandle, 840 * DWORD DesiredAccess, 841 * BOOL OpenAsSelf, 842 * PHANDLE TokenHandle 843 * ) 844 */ OpenThreadToken(long hThread, int desiredAccess, boolean openAsSelf)845 static native long OpenThreadToken(long hThread, int desiredAccess, 846 boolean openAsSelf) throws WindowsException; 847 848 /** 849 */ DuplicateTokenEx(long hThread, int desiredAccess)850 static native long DuplicateTokenEx(long hThread, int desiredAccess) 851 throws WindowsException; 852 853 /** 854 * SetThreadToken( 855 * PHANDLE Thread, 856 * HANDLE Token 857 * ) 858 */ SetThreadToken(long thread, long hToken)859 static native void SetThreadToken(long thread, long hToken) 860 throws WindowsException; 861 862 /** 863 * GetTokenInformation( 864 * HANDLE TokenHandle, 865 * TOKEN_INFORMATION_CLASS TokenInformationClass, 866 * LPVOID TokenInformation, 867 * DWORD TokenInformationLength, 868 * PDWORD ReturnLength 869 * ) 870 */ GetTokenInformation(long token, int tokenInfoClass, long pTokenInfo, int tokenInfoLength)871 static native int GetTokenInformation(long token, int tokenInfoClass, 872 long pTokenInfo, int tokenInfoLength) throws WindowsException; 873 874 /** 875 * AdjustTokenPrivileges( 876 * HANDLE TokenHandle, 877 * BOOL DisableAllPrivileges 878 * PTOKEN_PRIVILEGES NewState 879 * DWORD BufferLength 880 * PTOKEN_PRIVILEGES 881 * PDWORD ReturnLength 882 * ) 883 */ AdjustTokenPrivileges(long token, long luid, int attributes)884 static native void AdjustTokenPrivileges(long token, long luid, int attributes) 885 throws WindowsException; 886 887 888 /** 889 * AccessCheck( 890 * PSECURITY_DESCRIPTOR pSecurityDescriptor, 891 * HANDLE ClientToken, 892 * DWORD DesiredAccess, 893 * PGENERIC_MAPPING GenericMapping, 894 * PPRIVILEGE_SET PrivilegeSet, 895 * LPDWORD PrivilegeSetLength, 896 * LPDWORD GrantedAccess, 897 * LPBOOL AccessStatus 898 * ) 899 */ AccessCheck(long token, long securityInfo, int accessMask, int genericRead, int genericWrite, int genericExecute, int genericAll)900 static native boolean AccessCheck(long token, long securityInfo, int accessMask, 901 int genericRead, int genericWrite, int genericExecute, int genericAll) 902 throws WindowsException; 903 904 /** 905 */ LookupPrivilegeValue(String name)906 static long LookupPrivilegeValue(String name) throws WindowsException { 907 NativeBuffer buffer = asNativeBuffer(name); 908 try { 909 return LookupPrivilegeValue0(buffer.address()); 910 } finally { 911 buffer.release(); 912 } 913 } LookupPrivilegeValue0(long lpName)914 private static native long LookupPrivilegeValue0(long lpName) 915 throws WindowsException; 916 917 /** 918 * CreateSymbolicLink( 919 * LPCWSTR lpSymlinkFileName, 920 * LPCWSTR lpTargetFileName, 921 * DWORD dwFlags 922 * ) 923 * 924 * Creates a symbolic link, conditionally retrying with the addition of 925 * the flag SYMBOLIC_LINK_FLAG_ALLOW_UNPRIVILEGED_CREATE if the initial 926 * attempt fails with ERROR_PRIVILEGE_NOT_HELD. If the retry fails, throw 927 * the original exception due to ERROR_PRIVILEGE_NOT_HELD. The retry will 928 * succeed only on Windows build 14972 or later if Developer Mode is on. 929 */ CreateSymbolicLink(String link, String target, int flags)930 static void CreateSymbolicLink(String link, String target, int flags) 931 throws WindowsException 932 { 933 NativeBuffer linkBuffer = asNativeBuffer(link); 934 NativeBuffer targetBuffer = asNativeBuffer(target); 935 try { 936 CreateSymbolicLink0(linkBuffer.address(), targetBuffer.address(), 937 flags); 938 } catch (WindowsException x) { 939 if (x.lastError() == ERROR_PRIVILEGE_NOT_HELD) { 940 flags |= SYMBOLIC_LINK_FLAG_ALLOW_UNPRIVILEGED_CREATE; 941 try { 942 CreateSymbolicLink0(linkBuffer.address(), 943 targetBuffer.address(), flags); 944 return; 945 } catch (WindowsException ignored) { 946 // Will fail with ERROR_INVALID_PARAMETER for Windows 947 // builds older than 14972. 948 } 949 } 950 throw x; 951 } finally { 952 targetBuffer.release(); 953 linkBuffer.release(); 954 } 955 } CreateSymbolicLink0(long linkAddress, long targetAddress, int flags)956 private static native void CreateSymbolicLink0(long linkAddress, 957 long targetAddress, int flags) throws WindowsException; 958 959 /** 960 * CreateHardLink( 961 * LPCTSTR lpFileName, 962 * LPCTSTR lpExistingFileName, 963 * LPSECURITY_ATTRIBUTES lpSecurityAttributes 964 * ) 965 */ CreateHardLink(String newFile, String existingFile)966 static void CreateHardLink(String newFile, String existingFile) 967 throws WindowsException 968 { 969 NativeBuffer newFileBuffer = asNativeBuffer(newFile); 970 NativeBuffer existingFileBuffer = asNativeBuffer(existingFile); 971 try { 972 CreateHardLink0(newFileBuffer.address(), existingFileBuffer.address()); 973 } finally { 974 existingFileBuffer.release(); 975 newFileBuffer.release(); 976 } 977 } CreateHardLink0(long newFileBuffer, long existingFileBuffer)978 private static native void CreateHardLink0(long newFileBuffer, 979 long existingFileBuffer) throws WindowsException; 980 981 /** 982 * GetFullPathName( 983 * LPCTSTR lpFileName, 984 * DWORD nBufferLength, 985 * LPTSTR lpBuffer, 986 * LPTSTR *lpFilePart 987 * ) 988 */ GetFullPathName(String path)989 static String GetFullPathName(String path) throws WindowsException { 990 NativeBuffer buffer = asNativeBuffer(path); 991 try { 992 return GetFullPathName0(buffer.address()); 993 } finally { 994 buffer.release(); 995 } 996 } GetFullPathName0(long pathAddress)997 private static native String GetFullPathName0(long pathAddress) 998 throws WindowsException; 999 1000 /** 1001 * GetFinalPathNameByHandle( 1002 * HANDLE hFile, 1003 * LPTSTR lpszFilePath, 1004 * DWORD cchFilePath, 1005 * DWORD dwFlags 1006 * ) 1007 */ GetFinalPathNameByHandle(long handle)1008 static native String GetFinalPathNameByHandle(long handle) 1009 throws WindowsException; 1010 1011 /** 1012 * FormatMessage( 1013 * DWORD dwFlags, 1014 * LPCVOID lpSource, 1015 * DWORD dwMessageId, 1016 * DWORD dwLanguageId, 1017 * LPTSTR lpBuffer, 1018 * DWORD nSize, 1019 * va_list *Arguments 1020 * ) 1021 */ FormatMessage(int errorCode)1022 static native String FormatMessage(int errorCode); 1023 1024 /** 1025 * LocalFree( 1026 * HLOCAL hMem 1027 * ) 1028 */ LocalFree(long address)1029 static native void LocalFree(long address); 1030 1031 /** 1032 * HANDLE CreateIoCompletionPort ( 1033 * HANDLE FileHandle, 1034 * HANDLE ExistingCompletionPort, 1035 * ULONG_PTR CompletionKey, 1036 * DWORD NumberOfConcurrentThreads 1037 * ) 1038 */ CreateIoCompletionPort(long fileHandle, long existingPort, long completionKey)1039 static native long CreateIoCompletionPort(long fileHandle, long existingPort, 1040 long completionKey) throws WindowsException; 1041 1042 1043 /** 1044 * GetQueuedCompletionStatus( 1045 * HANDLE CompletionPort, 1046 * LPDWORD lpNumberOfBytesTransferred, 1047 * PULONG_PTR lpCompletionKey, 1048 * LPOVERLAPPED *lpOverlapped, 1049 * DWORD dwMilliseconds 1050 */ GetQueuedCompletionStatus(long completionPort)1051 static CompletionStatus GetQueuedCompletionStatus(long completionPort) 1052 throws WindowsException 1053 { 1054 CompletionStatus status = new CompletionStatus(); 1055 GetQueuedCompletionStatus0(completionPort, status); 1056 return status; 1057 } 1058 static class CompletionStatus { 1059 private int error; 1060 private int bytesTransferred; 1061 private long completionKey; CompletionStatus()1062 private CompletionStatus() { } 1063 error()1064 int error() { return error; } bytesTransferred()1065 int bytesTransferred() { return bytesTransferred; } completionKey()1066 long completionKey() { return completionKey; } 1067 } GetQueuedCompletionStatus0(long completionPort, CompletionStatus status)1068 private static native void GetQueuedCompletionStatus0(long completionPort, 1069 CompletionStatus status) throws WindowsException; 1070 1071 /** 1072 * PostQueuedCompletionStatus( 1073 * HANDLE CompletionPort, 1074 * DWORD dwNumberOfBytesTransferred, 1075 * ULONG_PTR dwCompletionKey, 1076 * LPOVERLAPPED lpOverlapped 1077 * ) 1078 */ PostQueuedCompletionStatus(long completionPort, long completionKey)1079 static native void PostQueuedCompletionStatus(long completionPort, 1080 long completionKey) throws WindowsException; 1081 1082 /** 1083 * ReadDirectoryChangesW( 1084 * HANDLE hDirectory, 1085 * LPVOID lpBuffer, 1086 * DWORD nBufferLength, 1087 * BOOL bWatchSubtree, 1088 * DWORD dwNotifyFilter, 1089 * LPDWORD lpBytesReturned, 1090 * LPOVERLAPPED lpOverlapped, 1091 * LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine 1092 * ) 1093 */ ReadDirectoryChangesW(long hDirectory, long bufferAddress, int bufferLength, boolean watchSubTree, int filter, long bytesReturnedAddress, long pOverlapped)1094 static native void ReadDirectoryChangesW(long hDirectory, 1095 long bufferAddress, 1096 int bufferLength, 1097 boolean watchSubTree, 1098 int filter, 1099 long bytesReturnedAddress, 1100 long pOverlapped) 1101 throws WindowsException; 1102 1103 1104 /** 1105 * CancelIo( 1106 * HANDLE hFile 1107 * ) 1108 */ CancelIo(long hFile)1109 static native void CancelIo(long hFile) throws WindowsException; 1110 1111 /** 1112 * GetOverlappedResult( 1113 * HANDLE hFile, 1114 * LPOVERLAPPED lpOverlapped, 1115 * LPDWORD lpNumberOfBytesTransferred, 1116 * BOOL bWait 1117 * ); 1118 */ GetOverlappedResult(long hFile, long lpOverlapped)1119 static native int GetOverlappedResult(long hFile, long lpOverlapped) 1120 throws WindowsException; 1121 1122 // -- support for copying String with a NativeBuffer -- 1123 1124 private static final Unsafe unsafe = Unsafe.getUnsafe(); 1125 asNativeBuffer(String s)1126 static NativeBuffer asNativeBuffer(String s) throws WindowsException { 1127 if (s.length() > (Integer.MAX_VALUE - 2)/2) { 1128 throw new WindowsException 1129 ("String too long to convert to native buffer"); 1130 } 1131 1132 int stringLengthInBytes = s.length() << 1; 1133 int sizeInBytes = stringLengthInBytes + 2; // char terminator 1134 1135 // get a native buffer of sufficient size 1136 NativeBuffer buffer = NativeBuffers.getNativeBufferFromCache(sizeInBytes); 1137 if (buffer == null) { 1138 buffer = NativeBuffers.allocNativeBuffer(sizeInBytes); 1139 } else { 1140 // buffer already contains the string contents 1141 if (buffer.owner() == s) 1142 return buffer; 1143 } 1144 1145 // copy into buffer and zero terminate 1146 char[] chars = s.toCharArray(); 1147 unsafe.copyMemory(chars, Unsafe.ARRAY_CHAR_BASE_OFFSET, null, 1148 buffer.address(), (long)stringLengthInBytes); 1149 unsafe.putChar(buffer.address() + stringLengthInBytes, (char)0); 1150 buffer.setOwner(s); 1151 return buffer; 1152 } 1153 1154 // -- native library initialization -- 1155 initIDs()1156 private static native void initIDs(); 1157 1158 static { 1159 // nio.dll has dependency on net.dll 1160 jdk.internal.loader.BootLoader.loadLibrary("net"); 1161 jdk.internal.loader.BootLoader.loadLibrary("nio"); initIDs()1162 initIDs(); 1163 } 1164 1165 } 1166