com.sun.jna.LastErrorException Java Examples

/**
 * @see NativeCalls#killProcess(int)
 */
@Override
public boolean killProcess(final int processId) {
  try {
    final Pointer procHandle = Kernel32.OpenProcess(
        Kernel32.PROCESS_TERMINATE, false, processId);
    final long hval;
    if (procHandle == null || (hval = Pointer.nativeValue(procHandle)) ==
        Kernel32.INVALID_HANDLE || hval == 0) {
      return false;
    }
    else {
      final boolean result = Kernel32.TerminateProcess(procHandle, -1);
      Kernel32.CloseHandle(procHandle);
      return result;
    }
  } catch (LastErrorException le) {
    // some problem in killing the process
    return false;
  }
}
 

/**
 * @see NativeCalls#isProcessActive(int)
 */
@Override
public boolean isProcessActive(final int processId) {
  try {
    final Pointer procHandle = Kernel32.OpenProcess(
        Kernel32.PROCESS_QUERY_INFORMATION, false, processId);
    final long hval;
    if (procHandle == null || (hval = Pointer.nativeValue(procHandle)) ==
        Kernel32.INVALID_HANDLE || hval == 0) {
      return false;
    }
    else {
      final IntByReference status = new IntByReference();
      final boolean result = Kernel32.GetExitCodeProcess(procHandle, status)
          && status != null && status.getValue() == Kernel32.STILL_ACTIVE;
      Kernel32.CloseHandle(procHandle);
      return result;
    }
  } catch (LastErrorException le) {
    // some problem in getting process status
    return false;
  }
}
 

/**
 * <p>Switch the display to a graphics mode.</p>
 *
 * <p>It switches VT to graphics mode with keyboard turned off.
 * Then, it tells kernel to notify Java when VT switch occurs.
 * Also, framebuffer contents are restored and write access is enabled.</p>
 *
 * @throws RuntimeException when the switch fails
 */
public void switchToGraphicsMode() {
    LOGGER.trace("Switching console to graphics mode");
    try {
        ttyfd.setKeyboardMode(K_OFF);
        ttyfd.setConsoleMode(KD_GRAPHICS);

        NativeTTY.vt_mode vtm = new NativeTTY.vt_mode();
        vtm.mode = VT_PROCESS;
        vtm.relsig = SIGUSR2;
        vtm.acqsig = SIGUSR2;
        ttyfd.setVTmode(vtm);
    } catch (LastErrorException e) {
        throw new RuntimeException("Switch to graphics mode failed", e);
    }

    if (fbInstance != null) {
        fbInstance.restoreData();
        fbInstance.setFlushEnabled(true);
    }
}
 

/**
 * Invoke i/o control action with pointer argument.
 *
 * @param fd  Not used.
 * @param cmd IO control command.
 * @param arg IO control argument ({@link fb_con2fbmap}, {@link fb_fix_screeninfo}, {@link fb_var_screeninfo})
 * @return Zero.
 * @throws LastErrorException EINVAL when the argument or command is invalid.
 */
@Override
public int ioctl(int fd, int cmd, Pointer arg) throws LastErrorException {
    fb_con2fbmap map;
    byte[] buf;
    fb_var_screeninfo vInfo;
    switch (cmd) {
        case NativeConstants.FBIOGET_CON2FBMAP:
            map = new fb_con2fbmap(arg);
            if (!con2fb.containsKey(map.console)) {
                throw new LastErrorException(NativeConstants.EINVAL);
            }
            map.framebuffer = con2fb.get(map.console);
            map.write();
            break;
        case NativeConstants.FBIOGET_FSCREENINFO:
            buf = fixinfo.getPointer().getByteArray(0, fixinfo.size());
            arg.write(0, buf, 0, buf.length);
            break;
        case NativeConstants.FBIOGET_VSCREENINFO:
            buf = varinfo.getPointer().getByteArray(0, varinfo.size());
            arg.write(0, buf, 0, buf.length);
            break;
        case NativeConstants.FBIOPUT_VSCREENINFO:
            vInfo = new fb_var_screeninfo(arg);
            takeVarInfo(vInfo);
            break;
        default:
            throw new LastErrorException(NativeConstants.EINVAL);
    }
    return 0;
}
 

private static String getHostnamePosix() throws IOException {
  byte[] hostnameBuf = new byte[HOSTNAME_MAX_LEN];
  try {
    // Subtract 1 to ensure NUL termination.
    HostnameFetchingPosixLibrary.gethostname(hostnameBuf, hostnameBuf.length - 1);
    return Native.toString(hostnameBuf);
  } catch (LastErrorException e) {
    throw new IOException(e);
  }
}
 

public void setNativeEnvironmentVariable(String name, String value) {
    try {
        libc.setenv(name, value, 1);
    } catch (LastErrorException lastErrorException) {
        throw new NativeIntegrationException(String.format("Could not set environment variable '%s'. errno: %d", name, lastErrorException.getErrorCode()));
    }
}
 

public void chmod(File f, int mode) throws IOException {
    try {
        byte[] encodedFilePath = encoder.encode(f);
        libc.chmod(encodedFilePath, mode);
    } catch (LastErrorException exception) {
        throw new IOException(String.format("Failed to set file permissions %s on file %s. errno: %d", mode, f.getName(), exception.getErrorCode()));
    }
}
 

/**
 * @see NativeCalls#killProcess(int)
 */
@Override
public boolean killProcess(final int processId) {
  try {
    return kill(processId, 9) == 0;
  } catch (LastErrorException le) {
    return false;
  }
}
 

public void setNativeEnvironmentVariable(String name, String value) {
    try {
        libc.setenv(name, value, 1);
    } catch (LastErrorException lastErrorException) {
        throw new NativeIntegrationException(String.format("Could not set environment variable '%s'. errno: %d", name, lastErrorException.getErrorCode()));
    }
}
 

@Override
protected int setPlatformSocketOption(int sockfd, int level, int optName,
    TCPSocketOptions opt, Integer optVal, int optSize)
    throws NativeErrorException {
  try {
    return setsockopt(sockfd, level, optName,
        new IntByReference(optVal.intValue()), optSize);
  } catch (LastErrorException le) {
    throw new NativeErrorException(le.getMessage(), le.getErrorCode(),
        le.getCause());
  }
}
 

/**
 * Fetch fixed screen info.
 *
 * @return Non-changing info about the display.
 */
public fb_fix_screeninfo getFixedScreenInfo() throws LastErrorException {
    fb_fix_screeninfo info = new fb_fix_screeninfo();
    super.ioctl(FBIOGET_FSCREENINFO, info.getPointer());
    info.read();
    return info;
}
 

/**
 * @see NativeCalls#setEnvironment(String, String)
 */
@Override
public synchronized void setEnvironment(final String name,
    final String value) {
  if (name == null) {
    throw new UnsupportedOperationException(
        "setEnvironment() for name=NULL");
  }
  int res = -1;
  Throwable cause = null;
  try {
    if (value != null) {
      res = setenv(name, value, 1);
    }
    else {
      res = unsetenv(name);
    }
  } catch (LastErrorException le) {
    cause = new NativeErrorException(le.getMessage(), le.getErrorCode(),
        le.getCause());
  }
  if (res != 0) {
    throw new IllegalArgumentException("setEnvironment: given name=" + name
        + " (value=" + value + ')', cause);
  }
  // also change in java cached map
  if (javaEnv != null) {
    if (value != null) {
      javaEnv.put(name, value);
    }
    else {
      javaEnv.remove(name);
    }
  }
}
 

@Override
public void close() throws IOException {
    if (!closeLock.getAndSet(true)) {
        try {
            close(fd);
        } catch (LastErrorException lee) {
            throw new IOException("native close() failed : " + formatError(lee));
        }
        connected = false;
    }
}
 

@Override
protected int setPlatformSocketOption(int sockfd, int level, int optName,
    TCPSocketOptions opt, Integer optVal, int optSize)
    throws NativeErrorException {
  try {
    switch (optName) {
      case OPT_TCP_KEEPALIVE_THRESHOLD:
        // value required is in millis
        final IntByReference timeout = new IntByReference(
            optVal.intValue() * 1000);
        int result = setsockopt(sockfd, level, optName, timeout, optSize);
        if (result == 0) {
          // setting ABORT_THRESHOLD to be same as KEEPALIVE_THRESHOLD
          return setsockopt(sockfd, level,
              OPT_TCP_KEEPALIVE_ABORT_THRESHOLD, timeout, optSize);
        }
        else {
          return result;
        }
      default:
        throw new UnsupportedOperationException("unsupported option " + opt);
    }
  } catch (LastErrorException le) {
    throw new NativeErrorException(le.getMessage(), le.getErrorCode(),
        le.getCause());
  }
}
 

private int doRead(ByteBuffer buf) throws IOException {
  try {
    int fdToRead = fd.acquire();
    if (fdToRead == -1) {
      return -1;
    }
    return UnixDomainSocketLibrary.read(fdToRead, buf, buf.remaining());
  } catch (LastErrorException e) {
    throw new IOException(e);
  } finally {
    fd.release();
  }
}
 

/**
 * @see NativeCalls#setEnvironment(String, String)
 */
@Override
public synchronized void setEnvironment(final String name,
    final String value) {
  if (name == null) {
    throw new UnsupportedOperationException(
        "setEnvironment() for name=NULL");
  }
  int res = -1;
  Throwable cause = null;
  try {
    if (value != null) {
      res = setenv(name, value, 1);
    }
    else {
      res = unsetenv(name);
    }
  } catch (LastErrorException le) {
    cause = new NativeErrorException(le.getMessage(), le.getErrorCode(),
        le.getCause());
  }
  if (res != 0) {
    throw new IllegalArgumentException("setEnvironment: given name=" + name
        + " (value=" + value + ')', cause);
  }
  // also change in java cached map
  if (javaEnv != null) {
    if (value != null) {
      javaEnv.put(name, value);
    }
    else {
      javaEnv.remove(name);
    }
  }
}
 

public void chmod(File f, int mode) throws IOException {
    try {
        byte[] encodedFilePath = encoder.encode(f);
        libc.chmod(encodedFilePath, mode);
    } catch (LastErrorException exception) {
        throw new IOException(String.format("Failed to set file permissions %s on file %s. errno: %d", mode, f.getName(), exception.getErrorCode()));
    }
}
 

UnixDomainSocket(String path) throws IOException {
    if (Platform.isWindows() || Platform.isWindowsCE()) {
        throw new IOException("Unix domain sockets are not supported on Windows");
    }
    sockaddr = new SockAddr(path);
    closeLock.set(false);
    try {
        fd = socket(AF_UNIX, SOCK_STREAM, PROTOCOL);
    } catch (LastErrorException lee) {
        throw new IOException("native socket() failed : " + formatError(lee));
    }
}
 

public UnixDomainSocket(String path) throws IOException {
  if (Platform.isWindows() || Platform.isWindowsCE()) {
    throw new IOException("Unix domain sockets are not supported on Windows");
  }
  sockaddr = new SockAddr(path);
  closeLock.set(false);
  try {
    fd = socket(AF_UNIX, SOCK_STREAM, PROTOCOL);
  } catch (LastErrorException lee) {
    throw new IOException("native socket() failed : " + formatError(lee));
  }
}
 

/**
 * Close the associated file
 *
 * @throws LastErrorException when operations fails
 */
@Override
public void close() throws LastErrorException {
    if (fd != -1) {
        int copy = fd;
        fd = -1;
        libc.close(copy);
    }
}
 

/**
 * Get current TTY state.
 *
 * @return TTY state.
 * @throws LastErrorException when the operation fails.
 */
public vt_stat getVTstate() throws LastErrorException {
    vt_stat stat = new vt_stat();
    super.ioctl(VT_GETSTATE, stat.getPointer());
    stat.read();
    return stat;
}
 

@Override
protected void fallocateFD(int fd, long offset, long len)
    throws LastErrorException {
  int errno = posix_fallocate64(fd, offset, len);
  if (errno != 0) {
    throw new LastErrorException(errno);
  }
}
 

UnixDomainSocket(String path) throws IOException {
    if (Platform.isWindows() || Platform.isWindowsCE()) {
        throw new IOException("Unix domain sockets are not supported on Windows");
    }
    sockaddr = new SockAddr(path);
    closeLock.set(false);
    try {
        fd = socket(AF_UNIX, SOCK_STREAM, PROTOCOL);
    } catch (LastErrorException lee) {
        throw new IOException("native socket() failed : " + formatError(lee));
    }
}
 

@Override
public int close(int fd) throws LastErrorException {
    try {
        return impl(path(fd)).close(fd);
    } finally {
        opened.remove(fd);
    }
}
 

@Override
protected void fallocateFD(int fd, long offset, long len)
    throws LastErrorException {
  int errno = posix_fallocate64(fd, offset, len);
  if (errno != 0) {
    throw new LastErrorException(errno);
  }
}
 

@Override
public int ioctl(int fd, int cmd, @NonNull Pointer arg) throws LastErrorException {
    countIoctl_ptr++;
    return sub.ioctl(fd, cmd, arg);
}
 

protected void fallocateFD(int fd, long offset, long len)
    throws LastErrorException {
  throw new UnsupportedOperationException("not expected to be invoked");
}
 

@Override
public int open(int fd, @NonNull String path, int flags, int mode) throws LastErrorException {
    countOpen++;
    return sub.open(fd, path, flags, mode);
}
 

@Override
public int msync(@NonNull Pointer addr, @NonNull NativeLong len, int flags) throws LastErrorException {
    return impl(path(addr)).msync(addr, len, flags);
}
 

public static native boolean CloseHandle(Pointer handle)
throws LastErrorException;