aboutsummaryrefslogtreecommitdiff
path: root/src/org/traccar/protocol
diff options
context:
space:
mode:
Diffstat (limited to 'src/org/traccar/protocol')
-rw-r--r--src/org/traccar/protocol/NavisFrameDecoder.java80
-rw-r--r--src/org/traccar/protocol/NavisProtocol.java4
-rw-r--r--src/org/traccar/protocol/NavisProtocolDecoder.java463
3 files changed, 499 insertions, 48 deletions
diff --git a/src/org/traccar/protocol/NavisFrameDecoder.java b/src/org/traccar/protocol/NavisFrameDecoder.java
new file mode 100644
index 000000000..2480629ac
--- /dev/null
+++ b/src/org/traccar/protocol/NavisFrameDecoder.java
@@ -0,0 +1,80 @@
+/*
+ * Copyright 2019 Anton Tananaev (anton@traccar.org)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.traccar.protocol;
+
+import io.netty.buffer.ByteBuf;
+import io.netty.channel.Channel;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.handler.codec.TooLongFrameException;
+import org.traccar.BaseFrameDecoder;
+
+public class NavisFrameDecoder extends BaseFrameDecoder {
+
+ private static final int NTCB_HEADER_LENGHT = 16;
+ private static final int NTCB_LENGHT_OFFSET = 12;
+ private static final int MAX_FRAME_LENGHT = 65551;
+
+ private static byte src8Checksum(ByteBuf buf, int length) {
+ byte sum = (byte) 0xFF;
+ for (int i = 0; i < length; i++) {
+ sum ^= buf.getUnsignedByte(i);
+ for (int j = 0; j < 8; j++) {
+ sum = (sum & 0x80) != 0 ? (byte) ((sum << 1) ^ 0x31) : (byte) (sum << 1);
+ }
+ }
+ return sum;
+ }
+
+ @Override
+ protected Object decode(
+ ChannelHandlerContext ctx, Channel channel, ByteBuf buf) throws Exception {
+
+ // Check minimum length
+ if (buf.readableBytes() < 1) {
+ return null;
+ }
+
+ if (buf.getByte(buf.readerIndex()) == 0x7F) {
+ // FLEX keep alive frame
+ return buf.readRetainedSlice(1);
+ } else if (buf.getByte(buf.readerIndex()) == 0x7E /* "~" */) {
+ // FLEX frame
+ if (buf.readableBytes() > MAX_FRAME_LENGHT) {
+ throw new TooLongFrameException();
+ }
+
+ if (src8Checksum(buf, buf.readableBytes() - 1) == buf.getByte(buf.readableBytes() - 1)) {
+ return buf.readRetainedSlice(buf.readableBytes());
+ }
+ } else {
+ // NTCB frame
+ if (buf.readableBytes() < NTCB_HEADER_LENGHT) {
+ return null;
+ }
+
+ int length = buf.getUnsignedShortLE(buf.readerIndex() + NTCB_LENGHT_OFFSET);
+ if (buf.readableBytes() >= NTCB_HEADER_LENGHT + length) {
+ if (buf.readableBytes() > MAX_FRAME_LENGHT) {
+ throw new TooLongFrameException();
+ }
+ return buf.readRetainedSlice(NTCB_HEADER_LENGHT + length);
+ }
+ }
+
+ return null;
+ }
+
+}
diff --git a/src/org/traccar/protocol/NavisProtocol.java b/src/org/traccar/protocol/NavisProtocol.java
index 83a9dc99d..4250ba4dc 100644
--- a/src/org/traccar/protocol/NavisProtocol.java
+++ b/src/org/traccar/protocol/NavisProtocol.java
@@ -15,19 +15,17 @@
*/
package org.traccar.protocol;
-import io.netty.handler.codec.LengthFieldBasedFrameDecoder;
import org.traccar.BaseProtocol;
import org.traccar.PipelineBuilder;
import org.traccar.TrackerServer;
-import java.nio.ByteOrder;
public class NavisProtocol extends BaseProtocol {
public NavisProtocol() {
addServer(new TrackerServer(false, getName()) {
@Override
protected void addProtocolHandlers(PipelineBuilder pipeline) {
- pipeline.addLast(new LengthFieldBasedFrameDecoder(ByteOrder.LITTLE_ENDIAN, 4096, 12, 2, 2, 0, true));
+ pipeline.addLast(new NavisFrameDecoder());
pipeline.addLast(new NavisProtocolDecoder(NavisProtocol.this));
}
});
diff --git a/src/org/traccar/protocol/NavisProtocolDecoder.java b/src/org/traccar/protocol/NavisProtocolDecoder.java
index 83088e9f0..3c5abc2a4 100644
--- a/src/org/traccar/protocol/NavisProtocolDecoder.java
+++ b/src/org/traccar/protocol/NavisProtocolDecoder.java
@@ -18,6 +18,8 @@ package org.traccar.protocol;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.Channel;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
import org.traccar.BaseProtocolDecoder;
import org.traccar.DeviceSession;
import org.traccar.NetworkMessage;
@@ -31,14 +33,20 @@ import java.net.SocketAddress;
import java.nio.charset.StandardCharsets;
import java.util.LinkedList;
import java.util.List;
+import java.util.Date;
public class NavisProtocolDecoder extends BaseProtocolDecoder {
private String prefix;
private long deviceUniqueId, serverId;
+ private int flexDataSize; // bits
+ private final byte[] flexBitfield;
+ private byte flexProtocolVersion, flexStructVersion;
+ private static final Logger LOGGER = LoggerFactory.getLogger(NavisProtocolDecoder.class);
public NavisProtocolDecoder(Protocol protocol) {
super(protocol);
+ this.flexBitfield = new byte[16];
}
public static final int F10 = 0x01;
@@ -77,7 +85,7 @@ public class NavisProtocolDecoder extends BaseProtocolDecoder {
}
}
- private ParseResult parsePosition(DeviceSession deviceSession, ByteBuf buf) {
+ private ParseResult parseNTCBPosition(DeviceSession deviceSession, ByteBuf buf) {
Position position = new Position(getProtocolName());
position.setDeviceId(deviceSession.getDeviceId());
@@ -95,7 +103,7 @@ public class NavisProtocolDecoder extends BaseProtocolDecoder {
position.set(Position.KEY_EVENT, buf.readUnsignedShortLE());
- buf.skipBytes(6); // event time
+ buf.skipBytes(6); // Event time
short armedStatus = buf.readUnsignedByte();
if (isFormat(format, F10, F20, F30, F40, F50, F51, F52)) {
@@ -114,19 +122,48 @@ public class NavisProtocolDecoder extends BaseProtocolDecoder {
position.set(Position.KEY_RSSI, buf.readUnsignedByte());
if (isFormat(format, F10, F20, F30)) {
- position.set(Position.KEY_OUTPUT, buf.readUnsignedShortLE());
+ int output = buf.readUnsignedShortLE();
+ position.set(Position.KEY_OUTPUT, output);
+ for (int i = 0; i < 16; i++) {
+ position.set(Position.PREFIX_OUT + (i + 1), BitUtil.check(output, i));
+ }
} else if (isFormat(format, F50, F51, F52)) {
- int extField = buf.readUnsignedByte();
+ short extField = buf.readUnsignedByte();
position.set(Position.KEY_OUTPUT, extField & 0x3);
position.set(Position.KEY_SATELLITES, extField >> 2);
+ position.set(Position.PREFIX_OUT + 1, BitUtil.check(extField, 0));
+ position.set(Position.PREFIX_OUT + 2, BitUtil.check(extField, 1));
} else if (isFormat(format, F40, F60)) {
- position.set(Position.KEY_OUTPUT, buf.readUnsignedByte() & 0xF);
+ short output = buf.readUnsignedByte();
+ position.set(Position.KEY_OUTPUT, output & 0xF);
+ for (int i = 0; i < 4; i++) {
+ position.set(Position.PREFIX_OUT + (i + 1), BitUtil.check(output, i));
+ }
}
if (isFormat(format, F10, F20, F30, F40)) {
- position.set(Position.KEY_INPUT, buf.readUnsignedShortLE());
+ int input = buf.readUnsignedShortLE();
+ position.set(Position.KEY_INPUT, input);
+ if (!isFormat(format, F40)) {
+ for (int i = 0; i < 16; i++) {
+ position.set(Position.PREFIX_IN + (i + 1), BitUtil.check(input, i));
+ }
+ } else {
+ position.set(Position.PREFIX_IN + 1, BitUtil.check(input, 0));
+ position.set(Position.PREFIX_IN + 2, BitUtil.check(input, 1));
+ position.set(Position.PREFIX_IN + 3, BitUtil.check(input, 2));
+ position.set(Position.PREFIX_IN + 4, BitUtil.check(input, 3));
+ position.set(Position.PREFIX_IN + 5, (input & 0x70) >> 4);
+ position.set(Position.PREFIX_IN + 6, (input & 0x380) >> 7);
+ position.set(Position.PREFIX_IN + 7, (input & 0xC00) >> 10);
+ position.set(Position.PREFIX_IN + 8, (input & 0x3000) >> 12);
+ }
} else if (isFormat(format, F50, F51, F52, F60)) {
- position.set(Position.KEY_INPUT, buf.readUnsignedByte());
+ short input = buf.readUnsignedByte();
+ position.set(Position.KEY_INPUT, input);
+ for (int i = 0; i < 8; i++) {
+ position.set(Position.PREFIX_IN + (i + 1), BitUtil.check(input, i));
+ }
}
position.set(Position.KEY_POWER, buf.readUnsignedShortLE() * 0.001);
@@ -199,6 +236,7 @@ public class NavisProtocolDecoder extends BaseProtocolDecoder {
position.setLatitude(buf.readFloatLE() / Math.PI * 180);
position.setLongitude(buf.readFloatLE() / Math.PI * 180);
}
+
position.setSpeed(UnitsConverter.knotsFromKph(buf.readFloatLE()));
position.setCourse(buf.readUnsignedShortLE());
@@ -234,13 +272,13 @@ public class NavisProtocolDecoder extends BaseProtocolDecoder {
return new ParseResult(index, position);
}
- private Object processSingle(DeviceSession deviceSession, Channel channel, ByteBuf buf) {
- ParseResult result = parsePosition(deviceSession, buf);
+ private Object processNTCBSingle(DeviceSession deviceSession, Channel channel, ByteBuf buf) {
+ ParseResult result = parseNTCBPosition(deviceSession, buf);
- ByteBuf response = Unpooled.buffer(8);
+ ByteBuf response = Unpooled.buffer(7);
response.writeCharSequence("*<T", StandardCharsets.US_ASCII);
response.writeIntLE((int) result.getId());
- sendReply(channel, response);
+ sendNTCBReply(channel, response);
if (result.getPosition().getFixTime() == null) {
return null;
@@ -249,21 +287,21 @@ public class NavisProtocolDecoder extends BaseProtocolDecoder {
return result.getPosition();
}
- private Object processArray(DeviceSession deviceSession, Channel channel, ByteBuf buf) {
+ private Object processNTCBArray(DeviceSession deviceSession, Channel channel, ByteBuf buf) {
List<Position> positions = new LinkedList<>();
int count = buf.readUnsignedByte();
for (int i = 0; i < count; i++) {
- Position position = parsePosition(deviceSession, buf).getPosition();
+ Position position = parseNTCBPosition(deviceSession, buf).getPosition();
if (position.getFixTime() != null) {
positions.add(position);
}
}
- ByteBuf response = Unpooled.buffer(8);
+ ByteBuf response = Unpooled.buffer(7);
response.writeCharSequence("*<A", StandardCharsets.US_ASCII);
response.writeByte(count);
- sendReply(channel, response);
+ sendNTCBReply(channel, response);
if (positions.isEmpty()) {
return null;
@@ -272,70 +310,405 @@ public class NavisProtocolDecoder extends BaseProtocolDecoder {
return positions;
}
+ private ParseResult parseFLEXPosition(DeviceSession deviceSession, ByteBuf buf) {
+ LOGGER.info("DEBUG: id={} parseFLEXPosition_START", deviceSession.getDeviceId());
+ Position position = new Position(getProtocolName());
+
+ position.setDeviceId(deviceSession.getDeviceId());
+
+ long index = 0;
+
+ for (int i = 0; i < flexDataSize; i++) {
+ if ((flexBitfield[(int) (i / 8)] & (0x80 >> i % 8)) == 0) {
+ // Skip FLEX data field
+ continue;
+ }
+ LOGGER.info("DEBUG: id={} parseFLEXPosition_FIELD={}", deviceSession.getDeviceId(), i + 1);
+ int status = 0;
+ short input = 0;
+ short output = 0;
+
+ switch (i) {
+ case 0:
+ index = buf.readUnsignedIntLE();
+ position.set(Position.KEY_INDEX, index);
+ break;
+ case 1:
+ position.set(Position.KEY_EVENT, buf.readUnsignedShortLE());
+ break;
+ case 2:
+ buf.skipBytes(4); // Event time
+ break;
+ case 3:
+ short armedStatus = buf.readUnsignedByte();
+ position.set(Position.KEY_ARMED, armedStatus & 0x1);
+ if (BitUtil.check(armedStatus, 1)) {
+ position.set(Position.KEY_ALARM, Position.ALARM_GENERAL);
+ }
+ break;
+ case 4:
+ status = buf.readUnsignedByte();
+ position.set(Position.KEY_STATUS, status);
+ break;
+ case 5:
+ int status2 = buf.readUnsignedByte();
+ position.set(Position.KEY_STATUS, (short) ((status & 0xFF) | (status2 << 1)));
+ break;
+ case 6:
+ position.set(Position.KEY_RSSI, buf.readUnsignedByte());
+ break;
+ case 7:
+ int navSensorState = buf.readUnsignedByte();
+ position.setValid(BitUtil.check(navSensorState, 1));
+ position.set(Position.KEY_SATELLITES, navSensorState >> 2);
+ break;
+ case 8:
+ position.setTime(new DateBuilder(new Date(buf.readUnsignedIntLE() * 1000)).getDate());
+ break;
+ case 9:
+ position.setLatitude(buf.readIntLE() / 600000.0);
+ break;
+ case 10:
+ position.setLongitude(buf.readIntLE() / 600000.0);
+ break;
+ case 11:
+ position.setAltitude(buf.readIntLE() * 0.1);
+ break;
+ case 12:
+ position.setSpeed(UnitsConverter.knotsFromKph(buf.readFloatLE()));
+ break;
+ case 13:
+ position.setCourse(buf.readUnsignedShortLE());
+ break;
+ case 14:
+ position.set(Position.KEY_ODOMETER, buf.readFloatLE() * 1000);
+ break;
+ case 15:
+ position.set(Position.KEY_DISTANCE, buf.readFloatLE() * 1000);
+ break;
+ case 16:
+ case 17:
+ buf.skipBytes(2);
+ break;
+ case 18:
+ position.set(Position.KEY_POWER, buf.readUnsignedShortLE() * 0.001);
+ break;
+ case 19:
+ position.set(Position.KEY_BATTERY, buf.readUnsignedShortLE() * 0.001);
+ break;
+ case 20:
+ case 21:
+ case 22:
+ case 23:
+ case 24:
+ case 25:
+ case 26:
+ case 27:
+ position.set(Position.PREFIX_ADC + (i - 19), buf.readUnsignedShortLE());
+ break;
+ case 28:
+ input = buf.readUnsignedByte();
+ position.set(Position.KEY_INPUT, input);
+ for (int k = 0; k < 8; k++) {
+ position.set(Position.PREFIX_IN + (k + 1), BitUtil.check(input, k));
+ }
+ break;
+ case 29:
+ short input2 = buf.readUnsignedByte();
+ position.set(Position.KEY_INPUT, (short) ((input & 0xFF) | (input2 << 1)));
+ for (int k = 0; k < 8; k++) {
+ position.set(Position.PREFIX_IN + (k + 9), BitUtil.check(input2, k));
+ }
+ break;
+ case 30:
+ output = buf.readUnsignedByte();
+ position.set(Position.KEY_OUTPUT, output);
+ for (int k = 0; k < 8; k++) {
+ position.set(Position.PREFIX_OUT + (k + 1), BitUtil.check(output, k));
+ }
+ break;
+ case 31:
+ short output2 = buf.readUnsignedByte();
+ position.set(Position.KEY_OUTPUT, (short) ((output & 0xFF) | (output2 << 1)));
+ for (int k = 0; k < 8; k++) {
+ position.set(Position.PREFIX_OUT + (k + 9), BitUtil.check(output2, k));
+ }
+ break;
+ case 32:
+ case 33: // Impulse counters
+ buf.skipBytes(4);
+ break;
+ case 34:
+ case 35: // Fuel
+ buf.skipBytes(2);
+ break;
+ case 36:
+ position.set(Position.KEY_HOURS, buf.readUnsignedIntLE() * 1000);
+ break;
+ case 37:
+ case 38:
+ case 39:
+ case 40:
+ case 41:
+ case 42:
+ case 43: // Fuel RS-485
+ buf.skipBytes(2);
+ break;
+ case 44:
+ case 45:
+ case 46:
+ case 47:
+ case 48:
+ case 49:
+ case 50:
+ case 51:
+ position.set(Position.PREFIX_TEMP + (i - 43), buf.readByte());
+ break;
+ case 52: // CAN Fuel
+ buf.skipBytes(2);
+ break;
+ case 53: // CAN Fuel consumption
+ buf.skipBytes(4);
+ break;
+ case 54: // CAN RPM
+ buf.skipBytes(2);
+ break;
+ case 55: // CAN Coolant temperature
+ buf.skipBytes(1);
+ break;
+ case 56: // CAN Kilometrage
+ buf.skipBytes(4);
+ break;
+ case 57:
+ case 58:
+ case 59:
+ case 60:
+ case 61: // CAN Axle weight
+ buf.skipBytes(2);
+ break;
+ case 62: // CAN Accelerator
+ buf.skipBytes(1);
+ break;
+ case 63: // CAN Brake
+ buf.skipBytes(1);
+ break;
+ case 64: // CAN Engine load
+ buf.skipBytes(1);
+ break;
+ case 65: // CAN Filter fluid level
+ buf.skipBytes(2);
+ break;
+ case 66: // CAN Engine time
+ buf.skipBytes(4);
+ break;
+ case 67: // CAN Distance to maintenance
+ buf.skipBytes(2);
+ break;
+ case 68: // CAN Speed
+ position.set("can-speed", buf.readByte());
+ break;
+ default:
+ break;
+ }
+ }
+
+ return new ParseResult(index, position);
+ }
+
+ private Object processFLEXSingle(DeviceSession deviceSession, Channel channel, ByteBuf buf) {
+ buf.skipBytes(4); // Event index
+
+ ParseResult result = parseFLEXPosition(deviceSession, buf);
+
+ ByteBuf response = Unpooled.buffer(6);
+ response.writeCharSequence("~T", StandardCharsets.US_ASCII);
+ response.writeIntLE((int) result.getId());
+ sendFLEXReply(channel, response);
+
+ if (result.getPosition().getFixTime() == null) {
+ return null;
+ }
+
+ return result.getPosition();
+ }
+
+ private Object processFLEXArray(DeviceSession deviceSession, Channel channel, ByteBuf buf) {
+ List<Position> positions = new LinkedList<>();
+ int count = buf.readUnsignedByte();
+ LOGGER.info("DEBUG: id={} processFLEXArray_COUNT={}", deviceSession.getDeviceId(), count);
+ for (int i = 0; i < count; i++) {
+ Position position = parseFLEXPosition(deviceSession, buf).getPosition();
+ if (position.getFixTime() != null) {
+ positions.add(position);
+ }
+ }
+
+ ByteBuf response = Unpooled.buffer(6);
+ response.writeCharSequence("~A", StandardCharsets.US_ASCII);
+ response.writeByte(count);
+ sendFLEXReply(channel, response);
+
+ if (positions.isEmpty()) {
+ return null;
+ }
+
+ return positions;
+ }
+
+ private Object processFLEXNegotiation(Channel channel, ByteBuf buf) {
+ if (buf.readByte() != (byte) 0xB0) {
+ return null;
+ }
+
+ flexProtocolVersion = buf.readByte();
+ flexStructVersion = buf.readByte();
+ if (flexProtocolVersion != (byte) 0x0A && flexProtocolVersion != (byte) 0x14) {
+ return null;
+ }
+ if (flexStructVersion != (byte) 0x0A && flexStructVersion != (byte) 0x14) {
+ return null;
+ }
+
+ flexDataSize = buf.readByte();
+ if (flexDataSize > 122) {
+ return null;
+ }
+ buf.readBytes(flexBitfield, 0, (int) Math.ceil(flexDataSize / 8));
+
+ ByteBuf response = Unpooled.buffer(9);
+ response.writeCharSequence("*<FLEX", StandardCharsets.US_ASCII);
+ response.writeByte(0xB0);
+ response.writeByte(flexProtocolVersion);
+ response.writeByte(flexStructVersion);
+ sendNTCBReply(channel, response);
+
+ return null;
+ }
+
private Object processHandshake(Channel channel, SocketAddress remoteAddress, ByteBuf buf) {
- buf.readByte(); // colon symbol
+ buf.readByte(); // Colon symbol
if (getDeviceSession(channel, remoteAddress, buf.toString(StandardCharsets.US_ASCII)) != null) {
- sendReply(channel, Unpooled.copiedBuffer("*<S", StandardCharsets.US_ASCII));
+ sendNTCBReply(channel, Unpooled.copiedBuffer("*<S", StandardCharsets.US_ASCII));
}
return null;
}
- private static short checksum(ByteBuf buf) {
- short sum = 0;
+ private static byte xorChecksum(ByteBuf buf) {
+ byte sum = 0;
+ for (int i = 0; i < buf.readableBytes(); i++) {
+ sum ^= buf.getUnsignedByte(i);
+ }
+ return sum;
+ }
+
+ private static byte src8Checksum(ByteBuf buf) {
+ byte sum = (byte) 0xFF;
for (int i = 0; i < buf.readableBytes(); i++) {
sum ^= buf.getUnsignedByte(i);
+ for (int j = 0; j < 8; j++) {
+ sum = (sum & 0x80) != 0 ? (byte) ((sum << 1) ^ 0x31) : (byte) (sum << 1);
+ }
}
return sum;
}
- private void sendReply(Channel channel, ByteBuf data) {
+ private void sendNTCBReply(Channel channel, ByteBuf data) {
if (channel != null) {
ByteBuf header = Unpooled.buffer(16);
header.writeCharSequence(prefix, StandardCharsets.US_ASCII);
header.writeIntLE((int) deviceUniqueId);
header.writeIntLE((int) serverId);
header.writeShortLE(data.readableBytes());
- header.writeByte(checksum(data));
- header.writeByte(checksum(header));
+ header.writeByte(xorChecksum(data));
+ header.writeByte(xorChecksum(header));
channel.writeAndFlush(new NetworkMessage(Unpooled.wrappedBuffer(header, data), channel.remoteAddress()));
}
}
+ private void sendFLEXReply(Channel channel, ByteBuf data) {
+ if (channel != null) {
+ ByteBuf cs = Unpooled.buffer(1);
+ cs.writeByte(src8Checksum(data));
+
+ channel.writeAndFlush(new NetworkMessage(Unpooled.wrappedBuffer(data, cs), channel.remoteAddress()));
+ }
+ }
+
@Override
protected Object decode(
Channel channel, SocketAddress remoteAddress, Object msg) throws Exception {
ByteBuf buf = (ByteBuf) msg;
- prefix = buf.toString(buf.readerIndex(), 4, StandardCharsets.US_ASCII);
- buf.skipBytes(prefix.length()); // prefix @NTC by default
- serverId = buf.readUnsignedIntLE();
- deviceUniqueId = buf.readUnsignedIntLE();
- int length = buf.readUnsignedShortLE();
- buf.skipBytes(2); // header and data XOR checksum
-
- if (length == 0) {
- return null; // keep alive message
- }
-
- String type = buf.toString(buf.readerIndex(), 3, StandardCharsets.US_ASCII);
- buf.skipBytes(type.length());
-
- if (type.equals("*>S")) {
- return processHandshake(channel, remoteAddress, buf);
+ if (buf.getByte(buf.readerIndex()) == 0x7F) {
+ // FLEX keep alive message
+ return null;
+ } else if (buf.getByte(buf.readerIndex()) == 0x7E) { // "~"
+ // FLEX message
+ try {
+ DeviceSession deviceSession = getDeviceSession(channel, remoteAddress);
+ if (deviceSession != null) {
+ switch (buf.readShortLE()) {
+ // FLEX 1.0
+ case 0x417E: // "~A"
+ return processFLEXArray(deviceSession, channel, buf);
+ case 0x547E: // "~T"
+ case 0x437E: // "~C"
+ return processFLEXSingle(deviceSession, channel, buf);
+ // FLEX 2.0
+ case 0x457E: // "~E"
+ LOGGER.info("DEBUG: id={} FLEX \"~E\"", deviceSession.getDeviceId());
+ break;
+ case 0x587E: // "~X"
+ LOGGER.info("DEBUG: id={} FLEX \"~X\"", deviceSession.getDeviceId());
+ break;
+ default:
+ break;
+ }
+ }
+ } catch (IndexOutOfBoundsException error) {
+ LOGGER.warn("Navis FLEX message parsing error", error);
+ }
} else {
- DeviceSession deviceSession = getDeviceSession(channel, remoteAddress);
- if (deviceSession != null) {
- if (type.equals("*>T")) {
- return processSingle(deviceSession, channel, buf);
- } else if (type.equals("*>A")) {
- return processArray(deviceSession, channel, buf);
+ // NTCB message
+ prefix = buf.toString(buf.readerIndex(), 4, StandardCharsets.US_ASCII);
+ buf.skipBytes(prefix.length()); // Prefix @NTC by default
+ serverId = buf.readUnsignedIntLE();
+ deviceUniqueId = buf.readUnsignedIntLE();
+ int length = buf.readUnsignedShortLE();
+ buf.skipBytes(2); // Header and data XOR checksum
+
+ if (length == 0) {
+ return null; // Keep alive message
+ }
+
+ int type = buf.getIntLE(buf.readerIndex());
+ buf.skipBytes(3);
+ if ((type & 0xFFFFFF) == 0x533E2AL) { // "*>S"
+ return processHandshake(channel, remoteAddress, buf);
+ } else {
+ DeviceSession deviceSession = getDeviceSession(channel, remoteAddress);
+ if (deviceSession != null) {
+ try {
+ switch (type & 0xFFFFFF) {
+ case 0x413E2A: // "*>A"
+ return processNTCBArray(deviceSession, channel, buf);
+ case 0x543E2A: // "*>T"
+ return processNTCBSingle(deviceSession, channel, buf);
+ case 0x463E2A: // "*>F" (*>FLEX)
+ buf.skipBytes(3);
+ return processFLEXNegotiation(channel, buf);
+ default:
+ break;
+ }
+ } catch (IndexOutOfBoundsException error) {
+ LOGGER.warn("Navis NTCB message parsing error", error);
+ }
}
}
}
return null;
}
-
}
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-19 17:49:34 +0000