static UserPrincipal lookup(String name) throws IOException {
SecurityManager sm = System.getSecurityManager();
if (sm != null) {
sm.checkPermission(new RuntimePermission("lookupUserInformation"));
}
// invoke LookupAccountName to get buffer size needed for SID
int size = 0;
try {
size = LookupAccountName(name, 0L, 0);
} catch (WindowsException x) {
if (x.lastError() == ERROR_NONE_MAPPED) throw new UserPrincipalNotFoundException(name);
throw new IOException(name + ": " + x.errorString());
}
assert size > 0;
// allocate buffer and re-invoke LookupAccountName get SID
NativeBuffer sidBuffer = NativeBuffers.getNativeBuffer(size);
try {
int newSize = LookupAccountName(name, sidBuffer.address(), size);
if (newSize != size) {
// can this happen?
throw new AssertionError("SID change during lookup");
}
// return user principal
return fromSid(sidBuffer.address());
} catch (WindowsException x) {
throw new IOException(name + ": " + x.errorString());
} finally {
sidBuffer.release();
}
}
public long[] getApproximateSizes(NativeRange... ranges) {
if (ranges == null) {
return null;
}
long rc[] = new long[ranges.length];
NativeRange.RangeJNI structs[] = new NativeRange.RangeJNI[ranges.length];
if (rc.length > 0) {
NativeBuffer range_array = NativeRange.RangeJNI.arrayCreate(ranges.length);
try {
for (int i = 0; i < ranges.length; i++) {
structs[i] = new NativeRange.RangeJNI(ranges[i]);
structs[i].arrayWrite(range_array.pointer(), i);
}
DBJNI.GetApproximateSizes(self, range_array.pointer(), ranges.length, rc);
} finally {
for (int i = 0; i < ranges.length; i++) {
if (structs[i] != null) {
structs[i].delete();
}
}
range_array.delete();
}
}
return rc;
}
public void delete(NativeWriteOptions options, byte[] key) throws DBException {
checkArgNotNull(options, "options");
checkArgNotNull(key, "key");
NativeBuffer keyBuffer = new NativeBuffer(key);
try {
delete(options, keyBuffer);
} finally {
keyBuffer.delete();
}
}
public byte[] get(NativeReadOptions options, byte[] key) throws DBException {
checkArgNotNull(options, "options");
checkArgNotNull(key, "key");
NativeBuffer keyBuffer = new NativeBuffer(key);
try {
return get(options, keyBuffer);
} finally {
keyBuffer.delete();
}
}
@Override
public NativeSizeBuffer put(NativeBuffer buffer) {
if (remaining() < buffer.remaining()) {
throw new IndexOutOfBoundsException();
}
while (buffer.hasRemaining()) {
put(buffer.get());
}
return this;
}
public String getProperty(String name) {
checkArgNotNull(name, "name");
NativeBuffer keyBuffer = new NativeBuffer(name.getBytes());
try {
byte[] property = getProperty(keyBuffer);
if (property == null) {
return null;
} else {
return new String(property);
}
} finally {
keyBuffer.delete();
}
}
public void put(NativeWriteOptions options, byte[] key, byte[] value) throws DBException {
checkArgNotNull(options, "options");
checkArgNotNull(key, "key");
checkArgNotNull(value, "value");
NativeBuffer keyBuffer = new NativeBuffer(key);
try {
NativeBuffer valueBuffer = new NativeBuffer(value);
try {
put(options, keyBuffer, valueBuffer);
} finally {
valueBuffer.delete();
}
} finally {
keyBuffer.delete();
}
}
@Override
public String implProbeContentType(Path obj) throws IOException {
if (!gioAvailable) return null;
if (!(obj instanceof UnixPath)) return null;
UnixPath path = (UnixPath) obj;
NativeBuffer buffer = NativeBuffers.asNativeBuffer(path.getByteArrayForSysCalls());
try {
// GIO may access file so need permission check
path.checkRead();
byte[] type = probeGio(buffer.address());
return (type == null) ? null : Util.toString(type);
} finally {
buffer.release();
}
}
public void delete() {
if (name_buffer != null) {
name_buffer.delete();
name_buffer = null;
}
if (globalRef != 0) {
NativeDB.DBJNI.DeleteGlobalRef(globalRef);
globalRef = 0;
}
}
public NativeComparator() {
super(ComparatorJNI.create());
try {
name_buffer = NativeBuffer.create(name());
globalRef = NativeDB.DBJNI.NewGlobalRef(this);
if (globalRef == 0) {
throw new RuntimeException("jni call failed: NewGlobalRef");
}
ComparatorJNI struct = new ComparatorJNI();
struct.compare_method = NativeDB.DBJNI.GetMethodID(this.getClass(), "compare", "(JJ)I");
if (struct.compare_method == 0) {
throw new RuntimeException("jni call failed: GetMethodID");
}
struct.target = globalRef;
struct.name = name_buffer.pointer();
ComparatorJNI.memmove(self, struct, ComparatorJNI.SIZEOF);
} catch (RuntimeException e) {
delete();
throw e;
}
}
/**
* Register a directory for changes as follows:
*
* <p>1. Open directory 2. Read its attributes (and check it really is a directory) 3. Assign
* completion key and associated handle with completion port 4. Call ReadDirectoryChangesW to
* start (async) read of changes 5. Create or return existing key representing registration
*/
@Override
Object implRegister(
Path obj, Set<? extends WatchEvent.Kind<?>> events, WatchEvent.Modifier... modifiers) {
WindowsPath dir = (WindowsPath) obj;
boolean watchSubtree = false;
// FILE_TREE modifier allowed
for (WatchEvent.Modifier modifier : modifiers) {
if (modifier == ExtendedWatchEventModifier.FILE_TREE) {
watchSubtree = true;
} else {
if (modifier == null) return new NullPointerException();
if (modifier instanceof com.sun.nio.file.SensitivityWatchEventModifier)
continue; // ignore
return new UnsupportedOperationException("Modifier not supported");
}
}
// open directory
long handle;
try {
handle =
CreateFile(
dir.getPathForWin32Calls(),
FILE_LIST_DIRECTORY,
(FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE),
OPEN_EXISTING,
FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OVERLAPPED);
} catch (WindowsException x) {
return x.asIOException(dir);
}
boolean registered = false;
try {
// read attributes and check file is a directory
WindowsFileAttributes attrs;
try {
attrs = WindowsFileAttributes.readAttributes(handle);
} catch (WindowsException x) {
return x.asIOException(dir);
}
if (!attrs.isDirectory()) {
return new NotDirectoryException(dir.getPathForExceptionMessage());
}
// check if this directory is already registered
FileKey fk =
new FileKey(attrs.volSerialNumber(), attrs.fileIndexHigh(), attrs.fileIndexLow());
WindowsWatchKey existing = fk2key.get(fk);
// if already registered and we're not changing the subtree
// modifier then simply update the event and return the key.
if (existing != null && watchSubtree == existing.watchSubtree()) {
existing.setEvents(events);
return existing;
}
// Can overflow the int type capacity.
// Skip WAKEUP_COMPLETION_KEY value.
int completionKey = ++lastCompletionKey;
if (completionKey == WAKEUP_COMPLETION_KEY) completionKey = ++lastCompletionKey;
// associate handle with completion port
try {
CreateIoCompletionPort(handle, port, completionKey);
} catch (WindowsException x) {
return new IOException(x.getMessage());
}
// allocate memory for events, including space for other structures
// needed to do overlapped I/O
int size = CHANGES_BUFFER_SIZE + SIZEOF_DWORD + SIZEOF_OVERLAPPED;
NativeBuffer buffer = NativeBuffers.getNativeBuffer(size);
long bufferAddress = buffer.address();
long overlappedAddress = bufferAddress + size - SIZEOF_OVERLAPPED;
long countAddress = overlappedAddress - SIZEOF_DWORD;
// zero the overlapped structure
UNSAFE.setMemory(overlappedAddress, SIZEOF_OVERLAPPED, (byte) 0);
// start async read of changes to directory
try {
createAndAttachEvent(overlappedAddress);
ReadDirectoryChangesW(
handle,
bufferAddress,
CHANGES_BUFFER_SIZE,
watchSubtree,
ALL_FILE_NOTIFY_EVENTS,
countAddress,
overlappedAddress);
} catch (WindowsException x) {
closeAttachedEvent(overlappedAddress);
buffer.release();
return new IOException(x.getMessage());
}
WindowsWatchKey watchKey;
if (existing == null) {
// not registered so create new watch key
watchKey =
new WindowsWatchKey(dir, watcher, fk)
.init(
handle,
events,
watchSubtree,
buffer,
countAddress,
overlappedAddress,
completionKey);
// map file key to watch key
fk2key.put(fk, watchKey);
} else {
// directory already registered so need to:
// 1. remove mapping from old completion key to existing watch key
// 2. release existing key's resources (handle/buffer)
// 3. re-initialize key with new handle/buffer
ck2key.remove(existing.completionKey());
releaseResources(existing);
watchKey =
existing.init(
handle,
events,
watchSubtree,
buffer,
countAddress,
overlappedAddress,
completionKey);
}
// map completion map to watch key
ck2key.put(completionKey, watchKey);
registered = true;
return watchKey;
} finally {
if (!registered) CloseHandle(handle);
}
}
static NativeBuffer arrayCreate(int dimension) {
return NativeBuffer.create(dimension * SliceJNI.SIZEOF);
}
public NativeSlice set(NativeBuffer buffer) {
this.size_ = buffer.capacity();
this.data_ = buffer.pointer();
return this;
}
public NativeSlice(NativeBuffer buffer) {
this(buffer.pointer(), buffer.capacity());
}
