/*
* Class: org_jnetpcap_PcapUtils
* Method: injectLoop
* Signature: (IILorg/jnetpcap/packet/PcapPacketHandler;Ljava/lang/Object;Lorg/jnetpcap/packet/PcapPacket;Lorg/jnetpcap/packet/JPacket$State;Lorg/jnetpcap/PcapHeader;Lorg/jnetpcap/packet/JScanner;)I
*/
JNIEXPORT jint JNICALL Java_org_jnetpcap_PcapUtils_injectLoop
(JNIEnv *env, jclass zz,
jint jcnt,
jint id,
jobject jhandler,
jobject juser,
jobject jpacket,
jobject jstate,
jobject jheader,
jobject jscanner) {
// printf("LOOP-JPacketHandler\n"); fflush(stdout);
if (jhandler == NULL) {
throwException(env, NULL_PTR_EXCEPTION, NULL);
return -1;
}
/*
* Structure to encapsulate user data object, and store our JNI information
* so we can dispatch to Java land.
*/
cb_jpacket_t data;
memset(&data, 0, sizeof(data));
data.env = env;
data.obj = jhandler;
data.pcap = NULL;
data.user = juser;
data.header = jheader;
data.packet = jpacket;
data.state = jstate;
data.id = id;
data.scanner = jscanner;
jclass clazz = env->GetObjectClass(jhandler);
data.p = NULL;
data.flags = 0;
data.mid = env->GetMethodID(clazz, "nextPacket",
"(Lorg/jnetpcap/packet/PcapPacket;Ljava/lang/Object;)V");
if (data.mid == NULL) {
return -1;
}
const pcap_pkthdr *pkt_header = (const pcap_pkthdr *)getJMemoryPhysical(env, jheader);
const u_char *pkt_data = (const u_char *)getJMemoryPhysical(env, jheader);
for (int i = 0; i < jcnt || jcnt == -1; i ++) {
cb_pcap_packet_dispatch((u_char *)&data, pkt_header, pkt_data);
if (data.exception != NULL) {
env->Throw(data.exception);
break;
}
if (data.flags & DEBUG_INJECT_PACKET_BREAK_LOOP) {
break;
}
}
return jcnt;
}
/*
* Class: org_jnetpcap_packet_JScan
* Method: scan_buf
* Signature: (Lorg/jnetpcap/nio/JBuffer;)V
*/
JNIEXPORT void JNICALL Java_org_jnetpcap_packet_JScan_scan_1buf
(JNIEnv *env, jobject obj, jobject jbuf) {
scan_t *scan = (scan_t *)getJMemoryPhysical(env, obj);
if (scan == NULL) {
return;
}
char *buf = (char *)getJMemoryPhysical(env, jbuf);
scan->buf = buf;
}
/*
* Class: org_jnetpcap_packet_JScanner
* Method: loadFlags
* Signature: ([I)V
*/
JNIEXPORT void JNICALL Java_org_jnetpcap_packet_JScanner_loadFlags
(JNIEnv *env, jobject obj, jintArray jflags) {
#ifdef DEBUG
debug_enter("loadFlags");
#endif
scanner_t *scanner = (scanner_t *)getJMemoryPhysical(env, obj);
if (scanner == NULL) {
return;
}
jsize size = env->GetArrayLength(jflags);
#ifdef DEBUG
debug_trace("load", "loaded %d flags", (int)size);
#endif
if (size != MAX_ID_COUNT) {
throwException(env,
ILLEGAL_ARGUMENT_EXCEPTION,
"size of array must be MAX_ID_COUNT size");
#ifdef DEBUG
debug_error("IllegalArgumentException",
"size of array must be MAX_ID_COUNT size");
#endif
return;
}
env->GetIntArrayRegion(jflags, 0, size, (jint *)scanner->sc_flags);
#ifdef DEBUG
debug_exit("loadFlags");
#endif
}
/*
* Class: org_jnetpcap_packet_JHeaderScanner
* Method: nativeScan
* Signature: (Lorg/jnetpcap/packet/JScan;)V
*/
JNIEXPORT void JNICALL Java_org_jnetpcap_packet_JHeaderScanner_nativeScan
(JNIEnv *env, jobject obj, jobject jscan) {
native_protocol_func_t func = (native_protocol_func_t)getJMemoryPhysical(env, obj);
if (func == NULL) {
return;
}
scan_t *scan = (scan_t *)getJMemoryPhysical(env, jscan);
if (jscan == NULL) {
return;
}
// Dispatch to function pointer
func(scan);
}
/*
* Class: org_jnetpcap_packet_JScan
* Method: scan_packet
* Signature: ()Lorg/jnetpcap/packet/JPacket;
*/
JNIEXPORT jobject JNICALL Java_org_jnetpcap_packet_JScan_scan_1packet
(JNIEnv *env, jobject obj) {
scan_t *scan = (scan_t *)getJMemoryPhysical(env, obj);
if (scan == NULL) {
return NULL;
}
return scan->jpacket;
}
/*
* Class: org_jnetpcap_packet_JScan
* Method: scan_offset
* Signature: (I)V
*/
JNIEXPORT void JNICALL Java_org_jnetpcap_packet_JScan_scan_1offset__I
(JNIEnv *env, jobject obj, jint offset) {
scan_t *scan = (scan_t *)getJMemoryPhysical(env, obj);
if (scan == NULL) {
return;
}
scan->offset = (int) offset;
}
/*
* Class: org_jnetpcap_packet_JScan
* Method: record_header
* Signature: ()V
*/
JNIEXPORT void JNICALL Java_org_jnetpcap_packet_JScan_record_1header
(JNIEnv *env, jobject obj) {
scan_t *scan = (scan_t *)getJMemoryPhysical(env, obj);
if (scan == NULL) {
return;
}
record_header(scan);
}
/*
* Class: org_jnetpcap_packet_JScan
* Method: scan_buf_len
* Signature: (I)V
*/
JNIEXPORT void JNICALL Java_org_jnetpcap_packet_JScan_scan_1buf_1len
(JNIEnv *env, jobject obj, jint len) {
scan_t *scan = (scan_t *)getJMemoryPhysical(env, obj);
if (scan == NULL) {
return;
}
scan->buf_len = (int) len;
}
/*
* Class: org_jnetpcap_packet_JScan
* Method: scan_length
* Signature: ()I
*/
JNIEXPORT jint JNICALL Java_org_jnetpcap_packet_JScan_scan_1length__
(JNIEnv *env, jobject obj) {
scan_t *scan = (scan_t *)getJMemoryPhysical(env, obj);
if (scan == NULL) {
return -1;
}
return scan->length;
}
/*
* Class: org_jnetpcap_packet_JScan
* Method: scan_next_id
* Signature: (I)V
*/
JNIEXPORT void JNICALL Java_org_jnetpcap_packet_JScan_scan_1next_1id__I
(JNIEnv *env, jobject obj, jint next_id) {
scan_t *scan = (scan_t *)getJMemoryPhysical(env, obj);
if (scan == NULL) {
return;
}
scan->next_id = (int) next_id;
}
/*
* Class: org_jnetpcap_packet_JPacket_State
* Method: getFrameNumber
* Signature: ()J
*/
JNIEXPORT jlong JNICALL Java_org_jnetpcap_packet_JPacket_00024State_getFrameNumber
(JNIEnv *env, jobject obj) {
packet_state_t *packet = (packet_state_t *)getJMemoryPhysical(env, obj);
if (packet == NULL) {
return -1;
}
return (jint) packet->pkt_frame_num;
}
/*
* Class: org_jnetpcap_packet_JPacket_State
* Method: get64BitHeaderMap
* Signature: (I)J
*/
JNIEXPORT jlong JNICALL Java_org_jnetpcap_packet_JPacket_00024State_get64BitHeaderMap
(JNIEnv *env, jobject obj, jint index) {
packet_state_t *packet = (packet_state_t *)getJMemoryPhysical(env, obj);
if (packet == NULL) {
return -1;
}
return (jlong) packet->pkt_header_map;
}
/*
* Class: org_jnetpcap_packet_JPacket_State
* Method: findHeaderIndex
* Signature: (II)I
*/
JNIEXPORT jint JNICALL Java_org_jnetpcap_packet_JPacket_00024State_findHeaderIndex
(JNIEnv *env, jobject obj, jint id, jint instance) {
packet_state_t *packet = (packet_state_t *)getJMemoryPhysical(env, obj);
if (packet == NULL) {
return -1;
}
return (jint) findHeaderById(packet, id, instance);
}
/*
* Class: org_jnetpcap_packet_JScan
* Method: scan_postix
* Signature: (I)V
*/
JNIEXPORT void JNICALL Java_org_jnetpcap_packet_JScan_scan_1postix__I
(JNIEnv *env, jobject obj, jint jvalue) {
scan_t *scan = (scan_t *)getJMemoryPhysical(env, obj);
if (scan == NULL) {
return;
}
scan->hdr_postfix = (int) jvalue;
}
/*
* Class: org_jnetpcap_packet_JPacket_State
* Method: getAnalysis
* Signature: ()Lorg/jnetpcap/analysis/JAnalysis;
*/
JNIEXPORT jobject JNICALL Java_org_jnetpcap_packet_JPacket_00024State_getAnalysis
(JNIEnv *env, jobject obj) {
packet_state_t *packet = (packet_state_t *)getJMemoryPhysical(env, obj);
if (packet == NULL) {
return NULL;
}
return packet->pkt_analysis;
}
/*
* Class: org_jnetpcap_packet_JPacket_State
* Method: setFlags
* Signature: (I)V
*/
JNIEXPORT void JNICALL Java_org_jnetpcap_packet_JPacket_00024State_setFlags
(JNIEnv *env, jobject obj, jint jflags) {
packet_state_t *packet = (packet_state_t *)getJMemoryPhysical(env, obj);
if (packet == NULL) {
return;
}
packet->pkt_flags = (uint8_t) jflags;
}
/*
* Class: org_jnetpcap_packet_JPacket_State
* Method: getWirelen
* Signature: ()I
*/
JNIEXPORT jint JNICALL Java_org_jnetpcap_packet_JPacket_00024State_getWirelen
(JNIEnv *env, jobject obj) {
packet_state_t *packet = (packet_state_t *)getJMemoryPhysical(env, obj);
if (packet == NULL) {
return -1;
}
return (jint) packet->pkt_wirelen;
}
/*
* Class: org_jnetpcap_packet_JPacket_State
* Method: setWirelen
* Signature: (I)V
*/
JNIEXPORT void JNICALL Java_org_jnetpcap_packet_JPacket_00024State_setWirelen
(JNIEnv *env, jobject obj, jint jwirelen) {
packet_state_t *packet = (packet_state_t *)getJMemoryPhysical(env, obj);
if (packet == NULL) {
return;
}
packet->pkt_wirelen = (uint32_t) jwirelen;
}
/*
* Class: org_jnetpcap_packet_JScan
* Method: scan_postix
* Signature: ()I
*/
JNIEXPORT jint JNICALL Java_org_jnetpcap_packet_JScan_scan_1postix__
(JNIEnv *env, jobject obj) {
scan_t *scan = (scan_t *)getJMemoryPhysical(env, obj);
if (scan == NULL) {
return -1;
}
return (jint) scan->hdr_postfix;
}
/*
* Class: org_jnetpcap_packet_JScanner
* Method: getFrameNumber
* Signature: ()J
*/
JNIEXPORT jlong JNICALL Java_org_jnetpcap_packet_JScanner_getFrameNumber(
JNIEnv *env, jobject obj) {
scanner_t *scanner = (scanner_t *) getJMemoryPhysical(env, obj);
if (scanner == NULL) {
return -1;
}
return (jlong) scanner->sc_cur_frame_num;
}
/*
* Class: org_jnetpcap_packet_JScanner
* Method: setFrameNumber
* Signature: (J)V
*/
JNIEXPORT void JNICALL Java_org_jnetpcap_packet_JScanner_setFrameNumber
(JNIEnv *env, jobject obj, jlong frame_no) {
scanner_t *scanner = (scanner_t *)getJMemoryPhysical(env, obj);
if (scanner == NULL) {
return;
}
scanner->sc_cur_frame_num = (uint64_t) frame_no;
return;
}
/*
* Class: org_jnetpcap_packet_JScan
* Method: scan_set_lengths
* Signature: (IIIII)V
*/
JNIEXPORT void JNICALL Java_org_jnetpcap_packet_JScan_scan_1set_1lengths
(JNIEnv *env, jobject obj, jint prefix, jint header, jint gap, jint payload, jint postfix) {
scan_t *scan = (scan_t *)getJMemoryPhysical(env, obj);
if (scan == NULL) {
return;
}
scan->hdr_prefix = (uint8_t) prefix;
scan->length = (int) header;
scan->hdr_gap = (uint8_t) gap;
scan->hdr_payload = (uint32_t) payload;
scan->hdr_postfix = (uint16_t) postfix;
}
/*
* Class: org_jnetpcap_packet_JScanner
* Method: scan
* Signature: (Lorg/jnetpcap/packet/JPacket;Lorg/jnetpcap/packet/JPacket$State;II)I
*/
JNIEXPORT jint JNICALL Java_org_jnetpcap_packet_JScanner_scan(JNIEnv *env,
jobject obj, jobject jpacket, jobject jstate, jint id, jint wirelen) {
scanner_t *scanner = (scanner_t *) getJMemoryPhysical(env, obj);
if (scanner == NULL) {
return -1;
}
char *buf = (char *) getJMemoryPhysical(env, jpacket);
if (buf == NULL) {
return -1;
}
int size = (int) env->GetIntField(jpacket, jmemorySizeFID);
if (wirelen < size) {
throwException(env, ILLEGAL_ARGUMENT_EXCEPTION, "wirelen < buffer len");
return -1;
}
return scanJPacket(env, obj, jpacket, jstate, scanner, id, buf, size,
(uint32_t) wirelen);
}
/*
* Class: org_jnetpcap_packet_JPacket_State
* Method: getHeaderOffsetByIndex
* Signature: (I)I
*/
JNIEXPORT jint JNICALL Java_org_jnetpcap_packet_JPacket_00024State_getHeaderOffsetByIndex
(JNIEnv *env, jobject obj, jint index) {
packet_state_t *packet = (packet_state_t *)getJMemoryPhysical(env, obj);
if (packet == NULL) {
return -1;
}
if (index < 0 || index >= packet->pkt_header_count) {
throwException(env, INDEX_OUT_OF_BOUNDS_EXCEPTION, "header index out of range");
return -1;
}
return (jint) packet->pkt_headers[index].hdr_offset;
}
/*
* Class: org_jnetpcap_packet_JPacket_State
* Method: peerHeaderByIndex
* Signature: (ILorg/jnetpcap/packet/JHeader$State;)I
*/
JNIEXPORT jint JNICALL Java_org_jnetpcap_packet_JPacket_00024State_peerHeaderByIndex
(JNIEnv *env, jobject obj, jint index, jobject dst) {
packet_state_t *packet = (packet_state_t *)getJMemoryPhysical(env, obj);
if (packet == NULL) {
return -1;
}
if (index >= packet->pkt_header_count) {
return -1;
}
setJMemoryPhysical(env, dst, toLong(&packet->pkt_headers[index]));
return sizeof(header_t);
}
/*
* Class: org_jnetpcap_packet_JPacket_State
* Method: getInstanceCount
* Signature: (I)I
*/
JNIEXPORT jint JNICALL Java_org_jnetpcap_packet_JPacket_00024State_getInstanceCount
(JNIEnv *env, jobject obj, jint id) {
packet_state_t *packet = (packet_state_t *)getJMemoryPhysical(env, obj);
if (packet == NULL) {
return -1;
}
int count = 0;
for (int i = 0; i < packet->pkt_header_count; i ++) {
if (packet->pkt_headers[i].hdr_id == id) {
count ++;
}
}
return (jint) count;
}
/*
* Class: org_jnetpcap_packet_JPacket_State
* Method: peerHeaderById
* Signature: (IILorg/jnetpcap/packet/JHeader$State;)I
*/
JNIEXPORT jint JNICALL Java_org_jnetpcap_packet_JPacket_00024State_peerHeaderById
(JNIEnv *env, jobject obj, jint id, jint instance, jobject dst) {
packet_state_t *packet = (packet_state_t *)getJMemoryPhysical(env, obj);
if (packet == NULL) {
return -1;
}
int index = findHeaderById(packet, id, instance);
if (index == -1) {
return -1;
}
setJMemoryPhysical(env, dst, toLong(&packet->pkt_headers[index]));
jobject keeper = env->GetObjectField(obj, jmemoryKeeperFID);
env->SetObjectField(dst, jmemoryKeeperFID, keeper);
return sizeof(header_t);
}
/*
* Class: org_jnetpcap_nio_JObjectBuffer
* Method: getObject
* Signature: (Ljava/lang/Class;I)Ljava/lang/Object;
*/
JNIEXPORT jobject JNICALL Java_org_jnetpcap_nio_JObjectBuffer_getObject
(JNIEnv *env, jobject obj, jclass clazz, jint offset) {
jbyte *mem = (jbyte *)getJMemoryPhysical(env, obj);
if (mem == NULL) {
throwException(env, NULL_PTR_EXCEPTION, "JBuffer not initialized");
return NULL;
}
//#define DEBUG
#ifdef DEBUG
printf("getObject(): here mem=%p offset=%d *=%p\n",
mem,
offset,
*((jobject *) (mem + offset)));
fflush(stdout);
#endif
return *((jobject *) (mem + offset));
}
/*
* Class: org_jnetpcap_packet_JScanner
* Method: init
* Signature: (Lorg.jnetpcap.packet.JScan;)V
*/
JNIEXPORT void JNICALL Java_org_jnetpcap_packet_JScanner_init
(JNIEnv *env, jobject obj, jobject jscan) {
#ifdef DEBUG
debug_enter("JScanner_init");
#endif
if (jscan == NULL) {
throwException(env, NULL_PTR_EXCEPTION,
"JScan parameter can not be null");
return;
}
void *block = (char *)getJMemoryPhysical(env, obj);
size_t size = (size_t)env->GetIntField(obj, jmemorySizeFID);
memset(block, 0, size);
scanner_t *scanner = (scanner_t *)block;
scanner->sc_jscan = env->NewGlobalRef(jscan);
scanner->sc_len = size - sizeof(scanner_t);
scanner->sc_offset = 0;
scanner->sc_packet = (packet_state_t *)((char *)block + sizeof(scanner_t));
for (int i = 0; i < MAX_ID_COUNT; i++) {
scanner->sc_scan_table[i] = native_protocols[i];
}
for (int i = 0; i < MAX_ID_COUNT; i++) {
for (int j = 0; j < MAX_ID_COUNT; j++) {
scanner->sc_heuristics_table[i][j] = native_heuristics[i][j];
}
}
/* Initialize sub-header area - allocate 1/10th */
scanner->sc_sublen = size / 10;
scanner->sc_subindex = 0;
scanner->sc_subheader = (header_t *)malloc(scanner->sc_sublen);
#ifdef DEBUG
debug_exit("JScanner_init");
#endif
}
/*
* Class: org_jnetpcap_PcapDumper
* Method: dump2
* Signature: (JIILorg/jnetpcap/nio/JBuffer;II)V
*/
JNIEXPORT void JNICALL Java_org_jnetpcap_PcapDumper_dump2
(JNIEnv *env, jobject obj,
jlong seconds,
jint useconds,
jint wirelen,
jobject jbuffer,
jint offset,
jint length) {
if (jbuffer == NULL) {
throwException(env, NULL_PTR_EXCEPTION, "buffer argument null");
return;
}
pcap_dumper_t *d = getPcapDumper(env, obj);
if (d == NULL) {
return; // Exception already thrown
}
pcap_pkthdr hdr;
hdr.ts.tv_sec = (int)seconds;
hdr.ts.tv_usec = (int) useconds;
hdr.caplen = (int)length;
hdr.len = (int) wirelen;
const u_char *b = (u_char *)getJMemoryPhysical(env, jbuffer);
if (b == NULL) {
throwException(env, NULL_PTR_EXCEPTION,
"Unable to retrieve native address from JBuffer object");
return;
}
jsize size = env->GetIntField(jbuffer, jmemorySizeFID);
if (offset + length > size || offset < 0 || length < 0) {
throwException(env, INDEX_OUT_OF_BOUNDS_EXCEPTION, "");
return;
}
pcap_dump((u_char *)d, &hdr, b + offset);
}
