jlibpipe/src/main/c/pipe.c

#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;
}