rik/mimis
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Migrate jlibpipe project to gradle project

Browse Source
This commit is contained in:
Rik Veenboer
2014-11-29 17:12:25 +00:00
parent ddd108a547
commit c0aa97447f
6 changed files with 173 additions and 116 deletions
Download Patch File Download Diff File Expand all files Collapse all files

192
cpp/jlibpipe/src/main/c/pipe.c Normal file
View File

@@ -0,0 +1,192 @@
#include <windows.h>
#include <strsafe.h>
#include <jni.h>
#include "pipe.h"
#define DEBUG 0
JNIEXPORT jint JNICALL Java_pipe_Pipe_CreateNamedPipe(JNIEnv *env,
jclass className, jstring sPipeName, jint dwOpenMode, jint dwPipeMode,
jint nMaxInstances, jint nOutBufferSize, jint nInBufferSize,
jint nDefaultTimeOut, jint lpSecurityAttributes) {
HANDLE pipeHandler;
LPCSTR pipeName;
pipeName = (*env)->GetStringUTFChars(env, sPipeName, NULL );
if (pipeName == NULL )
return -1;
if (DEBUG) {
printf("Native: Pipe Name %s\n", pipeName);
printf("Native: dwOpenMode %d\n", dwOpenMode);
printf("Native: dwPipeMode %d\n", dwPipeMode);
printf("Native: nMaxInstances %d\n", nMaxInstances);
printf("Native: nOutBufferSize %d\n", nOutBufferSize);
printf("Native: nInBufferSize %d\n", nInBufferSize);
printf("Native: nDefaultTimeOut %d\n", nDefaultTimeOut);
}
pipeHandler = CreateNamedPipe((LPCSTR) pipeName, dwOpenMode, dwPipeMode,
nMaxInstances, nOutBufferSize, nInBufferSize, nDefaultTimeOut,
(LPSECURITY_ATTRIBUTES) lpSecurityAttributes);
(*env)->ReleaseStringUTFChars(env, sPipeName, pipeName);
return (jint) pipeHandler;
}
JNIEXPORT jboolean JNICALL Java_pipe_Pipe_ConnectNamedPipe(JNIEnv *env,
jclass className, jint hNamedPipe, jint lpOverlapped) {
BOOL fConnected;
HANDLE pipeHandler = (HANDLE) hNamedPipe;
fConnected = ConnectNamedPipe(pipeHandler, (LPOVERLAPPED) lpOverlapped);
return fConnected;
}
JNIEXPORT jint JNICALL Java_pipe_Pipe_GetLastError(JNIEnv *env,
jclass className) {
DWORD errorNumber = GetLastError();
return (jint) errorNumber;
}
JNIEXPORT jboolean JNICALL Java_pipe_Pipe_CloseHandle(JNIEnv *env,
jclass className, jint hNamedPipe) {
BOOL result;
HANDLE pipeHandler = (HANDLE) hNamedPipe;
result = CloseHandle(pipeHandler);
return result;
}
JNIEXPORT jbyteArray JNICALL Java_pipe_Pipe_ReadFile(JNIEnv *env,
jclass className, jint hNamedPipe, jint nNumberOfBytesToRead) {
int bytesRead = 0;
BOOL result;
HANDLE pipeHandler = (HANDLE) hNamedPipe;
LPVOID buffer;
jbyteArray lpBuffer;
buffer = (LPVOID) LocalAlloc(LMEM_ZEROINIT, nNumberOfBytesToRead);
if (DEBUG) {
printf(
"Native: Before ReadFile pipeHandler %d nNumberOfBytesToRead %d\n",
pipeHandler, nNumberOfBytesToRead);
}
result = ReadFile(pipeHandler, (LPVOID) buffer,
(DWORD) nNumberOfBytesToRead, &bytesRead, (LPOVERLAPPED) 0);
if (result) {
lpBuffer = (*env)->NewByteArray(env, (jsize) bytesRead);
(*env)->SetByteArrayRegion(env, lpBuffer, 0, (jsize) bytesRead,
(jbyte *) buffer);
} else
bytesRead = 0;
LocalFree(buffer);
if (DEBUG) {
printf("Native: After ReadFile BytesRead %d\n", bytesRead);
}
return lpBuffer;
}
JNIEXPORT jint JNICALL Java_pipe_Pipe_WriteFile(JNIEnv *env, jclass className,
jint hNamedPipe, jbyteArray lpBuffer, jint nNumberOfBytesToWrite) {
int bytesWritten = 0;
BOOL result;
HANDLE pipeHandler = (HANDLE) hNamedPipe;
LPVOID buffer;
buffer = (LPVOID) LocalAlloc(LMEM_ZEROINIT, nNumberOfBytesToWrite);
(*env)->GetByteArrayRegion(env, lpBuffer, 0, nNumberOfBytesToWrite, buffer);
result = WriteFile(pipeHandler, buffer, (DWORD) nNumberOfBytesToWrite,
(LPDWORD) &bytesWritten, (LPOVERLAPPED) 0);
LocalFree(buffer);
if (DEBUG) {
printf("Native: After WriteFile BytesReadWritten %d\n", bytesWritten);
}
if (!result) {
if (GetLastError() != ERROR_IO_PENDING)
result = 0;
else
result = 1;
}
if (!result) {
bytesWritten = -1;
}
return bytesWritten;
}
JNIEXPORT jboolean JNICALL Java_pipe_Pipe_FlushFileBuffers(JNIEnv *env,
jclass className, jint hNamedPipe) {
BOOL result;
HANDLE pipeHandler = (HANDLE) hNamedPipe;
result = FlushFileBuffers(pipeHandler);
return result;
}
JNIEXPORT jboolean JNICALL Java_pipe_Pipe_DisconnectNamedPipe(JNIEnv *env,
jclass className, jint hNamedPipe) {
BOOL result;
HANDLE pipeHandler = (HANDLE) hNamedPipe;
result = DisconnectNamedPipe(pipeHandler);
return result;
}
JNIEXPORT jint JNICALL Java_pipe_Pipe_CreateFile(JNIEnv *env, jclass className,
jstring lpFileName, jint dwDesiredAccess, jint dwShareMode,
jint lpSecurityAttributes, jint dwCreationDisposition,
jint dwFlagsAndAttributes, jint hTemplateFile) {
HANDLE pipeHandler;
const jbyte *fileName;
fileName = (*env)->GetStringUTFChars(env, lpFileName, NULL );
if (fileName == NULL )
return -1;
pipeHandler = CreateFile((LPCSTR) fileName, (DWORD) dwDesiredAccess,
(DWORD) dwShareMode, (LPSECURITY_ATTRIBUTES) lpSecurityAttributes,
(DWORD) dwCreationDisposition, (DWORD) dwFlagsAndAttributes,
(HANDLE) hTemplateFile);
return (jint) pipeHandler;
}
JNIEXPORT jboolean JNICALL Java_pipe_Pipe_WaitNamedPipe(JNIEnv *env,
jclass className, jstring lpNamedPipeName, jint nTimeOut) {
BOOL result;
const jbyte *pipeName;
pipeName = (*env)->GetStringUTFChars(env, lpNamedPipeName, NULL );
if (pipeName == NULL )
return 0;
result = WaitNamedPipe((LPCSTR) pipeName, (DWORD) nTimeOut);
return result;
}
JNIEXPORT jstring JNICALL Java_pipe_Pipe_FormatMessage(JNIEnv *env,
jclass className, jint errorCode) {
LPVOID lpMsgBuf;
LPVOID lpDisplayBuf;
DWORD dw = (DWORD) errorCode;
FormatMessage(
FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM
| FORMAT_MESSAGE_IGNORE_INSERTS, NULL, dw,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR) &lpMsgBuf, 0,
NULL );
lpDisplayBuf = (LPVOID) LocalAlloc(LMEM_ZEROINIT,
(lstrlen((LPCTSTR) lpMsgBuf) + 40) * sizeof(TCHAR));
StringCchPrintf((LPTSTR) lpDisplayBuf,
LocalSize(lpDisplayBuf) / sizeof(TCHAR),
TEXT("Failed with error %d: %s"), dw, lpMsgBuf);
return (jstring) (*env)->NewStringUTF(env, lpDisplayBuf);
}
JNIEXPORT void JNICALL Java_pipe_Pipe_Print(JNIEnv *env, jclass className,
jstring lpMsgBuf) {
const jbyte *str;
str = (*env)->GetStringUTFChars(env, lpMsgBuf, NULL );
if (str == NULL )
return;
printf("Native: %s\n", str);
(*env)->ReleaseStringUTFChars(env, lpMsgBuf, str);
return;
}

56
cpp/jlibpipe/src/main/java/pipe/Pipe.java Normal file
View File

@@ -0,0 +1,56 @@
package pipe;
import com.github.boukefalos.jlibloader.Native;
/**
* @author Vikram S Khatri vikram.khatri@us.ibm.com
*/
public class Pipe {
static final int ERROR_PIPE_CONNECTED = 535;
static final int ERROR_BROKEN_PIPE = 109;
static final int PIPE_ACCESS_DUPLEX = 0x00000003;
static final int PIPE_WAIT = 0x00000000;
static {
Native.load("com.github.boukefalos", "jlibpipe");
}
public static final native int CreateNamedPipe(
String pipeName,
int ppenMode,
int pipeMode,
int maxInstances,
int outBufferSize,
int inBufferSize,
int defaultTimeOut,
int securityAttributes);
public static final native boolean ConnectNamedPipe(int namedPipeHandle, int overlapped);
public static final native int GetLastError();
public static final native boolean CloseHandle(int bbject);
public static final native byte[] ReadFile(int file, int numberOfBytesToRead);
public static final native int WriteFile(int file, byte[] buffer, int numberOfBytesToWrite);
public static final native boolean FlushFileBuffers(int file);
public static final native boolean DisconnectNamedPipe(int namedPipeHandle);
public static final native int CreateFile(
String fileName,
int desiredAccess,
int shareMode,
int securityAttributes,
int creationDisposition,
int flagsAndAttributes,
int templateFile);
public static final native boolean WaitNamedPipe(String namedPipeName, int timeOut);
public static final native String FormatMessage(int errorCode);
public static final native void Print(String message);
}