X-Git-Url: http://average.org/gitweb/?a=blobdiff_plain;f=gps303%2Fgps303proto.py;h=ad8fd7168fe4951d75eda0bf19f87e33bd9229e3;hb=c91cccfb91f1ea45dc886e2d75796e3af0b7f00f;hp=4789b033a3936873150d12b9cad4e1502869be23;hpb=b613110bb16c95d9b641882c2ad6869e3ced1a0c;p=loctrkd.git

diff --git a/gps303/gps303proto.py b/gps303/gps303proto.py
index 4789b03..ad8fd71 100755
--- a/gps303/gps303proto.py
+++ b/gps303/gps303proto.py
@@ -21,9 +21,12 @@ from struct import pack, unpack
 
 __all__ = (
     "handle_packet",
+    "inline_response",
     "make_object",
     "make_response",
-    "set_config",
+    "parse_message",
+    "proto_by_name",
+    "GPS303Pkt",
     "UNKNOWN",
     "LOGIN",
     "SUPERVISION",
@@ -53,9 +56,9 @@ __all__ = (
 log = getLogger("gps303")
 
 
-class _GT06pkt:
+class GPS303Pkt:
     PROTO: int
-    CONFIG = None
+    INLINE = True
 
     def __init__(self, *args, **kwargs):
         assert len(args) == 0
@@ -78,56 +81,63 @@ class _GT06pkt:
         )
 
     @classmethod
-    def from_packet(cls, length, proto, payload):
-        return cls(proto=proto, payload=payload, length=length)
+    def from_packet(cls, length, payload):
+        return cls(payload=payload, length=length)
 
-    def response(self, *args):
-        if len(args) == 0:
-            return None
-        assert len(args) == 1 and isinstance(args[0], bytes)
-        payload = args[0]
+    def to_packet(self):
+        return pack("BB", self.length, self.PROTO) + self.payload
+
+    @classmethod
+    def make_packet(cls, payload):
+        assert isinstance(payload, bytes)
         length = len(payload) + 1
         if length > 6:
             length -= 6
-        return b"xx" + pack("BB", length, self.proto) + payload + b"\r\n"
+        return pack("BB", length, cls.PROTO) + payload
+
+    @classmethod
+    def inline_response(cls, packet):
+        if cls.INLINE:
+            return cls.make_packet(b"")
+        else:
+            return None
 
 
-class UNKNOWN(_GT06pkt):
-    pass
+class UNKNOWN(GPS303Pkt):
+    PROTO = 256  # > 255 is impossible in real packets
+    INLINE = False
 
 
-class LOGIN(_GT06pkt):
+class LOGIN(GPS303Pkt):
     PROTO = 0x01
 
     @classmethod
-    def from_packet(cls, length, proto, payload):
-        self = super().from_packet(length, proto, payload)
+    def from_packet(cls, length, payload):
+        self = super().from_packet(length, payload)
         self.imei = payload[:-1].hex()
         self.ver = unpack("B", payload[-1:])[0]
         return self
 
-    def response(self):
-        return super().response(b"")
 
-
-class SUPERVISION(_GT06pkt):  # Server sends supervision number status
+class SUPERVISION(GPS303Pkt):  # Server sends supervision number status
     PROTO = 0x05
+    INLINE = False
 
     def response(self, supnum=0):
         # 1: The device automatically answers Pickup effect
         # 2: Automatically Answering Two-way Calls
         # 3: Ring manually answer the two-way call
-        return super().response(b"")
+        return self.make_packet(pack("B", supnum))
 
 
-class HEARTBEAT(_GT06pkt):
+class HEARTBEAT(GPS303Pkt):
     PROTO = 0x08
 
 
-class _GPS_POSITIONING(_GT06pkt):
+class _GPS_POSITIONING(GPS303Pkt):
     @classmethod
-    def from_packet(cls, length, proto, payload):
-        self = super().from_packet(length, proto, payload)
+    def from_packet(cls, length, payload):
+        self = super().from_packet(length, payload)
         self.dtime = payload[:6]
         if self.dtime == b"\0\0\0\0\0\0":
             self.devtime = None
@@ -148,8 +158,9 @@ class _GPS_POSITIONING(_GT06pkt):
         self.flags = flags
         return self
 
-    def response(self):
-        return super().response(self.dtime)
+    @classmethod
+    def inline_response(cls, packet):
+        return cls.make_packet(packet[2:8])
 
 
 class GPS_POSITIONING(_GPS_POSITIONING):
@@ -160,12 +171,13 @@ class GPS_OFFLINE_POSITIONING(_GPS_POSITIONING):
     PROTO = 0x11
 
 
-class STATUS(_GT06pkt):
+class STATUS(GPS303Pkt):
     PROTO = 0x13
+    INLINE = False
 
     @classmethod
-    def from_packet(cls, length, proto, payload):
-        self = super().from_packet(length, proto, payload)
+    def from_packet(cls, length, payload):
+        self = super().from_packet(length, payload)
         if len(payload) == 5:
             (
                 self.batt,
@@ -182,31 +194,33 @@ class STATUS(_GT06pkt):
         return self
 
     def response(self, upload_interval=25):  # Set interval in minutes
-        return super().response(pack("B", upload_interval))
+        return self.make_packet(pack("B", upload_interval))
 
 
-class HIBERNATION(_GT06pkt):
+class HIBERNATION(GPS303Pkt):
     PROTO = 0x14
 
 
-class RESET(_GT06pkt):  # Device sends when it got reset SMS
+class RESET(GPS303Pkt):  # Device sends when it got reset SMS
     PROTO = 0x15
+    INLINE = False
 
     def response(self):  # Server can send to initiate factory reset
-        return super().response(b"")
+        return self.make_packet(b"")
 
 
-class WHITELIST_TOTAL(_GT06pkt):  # Server sends to initiage sync (0x58)
+class WHITELIST_TOTAL(GPS303Pkt):  # Server sends to initiage sync (0x58)
     PROTO = 0x16
+    INLINE = False
 
     def response(self, number=3):  # Number of whitelist entries
-        return super().response(pack("B", number))
+        return self.make_packet(pack("B", number))
 
 
-class _WIFI_POSITIONING(_GT06pkt):
+class _WIFI_POSITIONING(GPS303Pkt):
     @classmethod
-    def from_packet(cls, length, proto, payload):
-        self = super().from_packet(length, proto, payload)
+    def from_packet(cls, length, payload):
+        self = super().from_packet(length, payload)
         self.dtime = payload[:6]
         if self.dtime == b"\0\0\0\0\0\0":
             self.devtime = None
@@ -235,42 +249,68 @@ class _WIFI_POSITIONING(_GT06pkt):
 class WIFI_OFFLINE_POSITIONING(_WIFI_POSITIONING):
     PROTO = 0x17
 
-    def response(self):
-        return super().response(self.dtime)
+    @classmethod
+    def inline_response(cls, packet):
+        return cls.make_packet(packet[2:8])
 
 
-class TIME(_GT06pkt):
+class TIME(GPS303Pkt):
     PROTO = 0x30
 
-    def response(self):
-        payload = pack("!HBBBBB", *datetime.utcnow().timetuple()[:6])
-        return super().response(payload)
+    @classmethod
+    def inline_response(cls, packet):
+        return pack(
+            "!BBHBBBBB", 7, cls.PROTO, *datetime.utcnow().timetuple()[:6]
+        )
 
 
-class PROHIBIT_LBS(_GT06pkt):
+class PROHIBIT_LBS(GPS303Pkt):
     PROTO = 0x33
+    INLINE = False
 
     def response(self, status=1):  # Server sent, 0-off, 1-on
-        return super().response(pack("B", status))
+        return self.make_packet(pack("B", status))
+
+
+class LBS_SWITCH_TIMES(GPS303Pkt):
+    PROTO = 0x34
+    INLINE = False
+
+    def response(self):
+        return self.make_packet(b"")
 
 
-class MOM_PHONE(_GT06pkt):
+class REMOTE_MONITOR_PHONE(GPS303Pkt):
+    PROTO = 0x40
+    INLINE = False
+
+
+class SOS_PHONE(GPS303Pkt):
+    PROTO = 0x41
+    INLINE = False
+
+
+class DAD_PHONE(GPS303Pkt):
+    PROTO = 0x42
+    INLINE = False
+
+
+class MOM_PHONE(GPS303Pkt):
     PROTO = 0x43
+    INLINE = False
 
 
-class STOP_UPLOAD(_GT06pkt):  # Server response to LOGIN to thwart the device
+class STOP_UPLOAD(GPS303Pkt):  # Server response to LOGIN to thwart the device
     PROTO = 0x44
 
-    def response(self):
-        return super().response(b"")
-
 
-class STOP_ALARM(_GT06pkt):
+class STOP_ALARM(GPS303Pkt):
     PROTO = 0x56
 
 
-class SETUP(_GT06pkt):
+class SETUP(GPS303Pkt):
     PROTO = 0x57
+    INLINE = False
 
     def response(
         self,
@@ -304,19 +344,20 @@ class SETUP(_GT06pkt):
             ]
             + [b";".join([el.encode() for el in phoneNumbers])]
         )
-        return super().response(payload)
+        return self.make_packet(payload)
 
 
-class SYNCHRONOUS_WHITELIST(_GT06pkt):
+class SYNCHRONOUS_WHITELIST(GPS303Pkt):
     PROTO = 0x58
 
 
-class RESTORE_PASSWORD(_GT06pkt):
+class RESTORE_PASSWORD(GPS303Pkt):
     PROTO = 0x67
 
 
 class WIFI_POSITIONING(_WIFI_POSITIONING):
     PROTO = 0x69
+    INLINE = False
 
     def response(self, lat=None, lon=None):
         if lat is None or lon is None:
@@ -325,97 +366,114 @@ class WIFI_POSITIONING(_WIFI_POSITIONING):
             payload = "{:+#010.8g},{:+#010.8g}".format(lat, lon).encode(
                 "ascii"
             )
-        return super().response(payload)
+        return self.make_packet(payload)
 
 
-class MANUAL_POSITIONING(_GT06pkt):
+class MANUAL_POSITIONING(GPS303Pkt):
     PROTO = 0x80
+    INLINE = False
 
 
-class BATTERY_CHARGE(_GT06pkt):
+class BATTERY_CHARGE(GPS303Pkt):
     PROTO = 0x81
 
 
-class CHARGER_CONNECTED(_GT06pkt):
+class CHARGER_CONNECTED(GPS303Pkt):
     PROTO = 0x82
 
 
-class CHARGER_DISCONNECTED(_GT06pkt):
+class CHARGER_DISCONNECTED(GPS303Pkt):
     PROTO = 0x83
 
 
-class VIBRATION_RECEIVED(_GT06pkt):
+class VIBRATION_RECEIVED(GPS303Pkt):
     PROTO = 0x94
 
 
-class POSITION_UPLOAD_INTERVAL(_GT06pkt):
+class POSITION_UPLOAD_INTERVAL(GPS303Pkt):
     PROTO = 0x98
+    INLINE = False
 
     @classmethod
-    def from_packet(cls, length, proto, payload):
-        self = super().from_packet(length, proto, payload)
+    def from_packet(cls, length, payload):
+        self = super().from_packet(length, payload)
         self.interval = unpack("!H", payload[:2])
         return self
 
-    def response(self):
-        return super().response(pack("!H", self.interval))
+    def response(self, interval=10):
+        return self.make_packet(pack("!H", interval))
 
 
-class SOS_ALARM(_GT06pkt):
+class SOS_ALARM(GPS303Pkt):
     PROTO = 0x99
 
 
-# Build a dict protocol number -> class
+# Build dicts protocol number -> class and class name -> protocol number
 CLASSES = {}
+PROTOS = {}
 if True:  # just to indent the code, sorry!
     for cls in [
         cls
         for name, cls in globals().items()
         if isclass(cls)
-        and issubclass(cls, _GT06pkt)
+        and issubclass(cls, GPS303Pkt)
         and not name.startswith("_")
     ]:
         if hasattr(cls, "PROTO"):
             CLASSES[cls.PROTO] = cls
+            PROTOS[cls.__name__] = cls.PROTO
 
 
-def make_object(length, proto, payload):
+def proto_by_name(name):
+    return PROTOS.get(name, -1)
+
+
+def proto_of_message(packet):
+    return unpack("B", packet[1:2])[0]
+
+
+def inline_response(packet):
+    proto = proto_of_message(packet)
     if proto in CLASSES:
-        return CLASSES[proto].from_packet(length, proto, payload)
+        return CLASSES[proto].inline_response(packet)
     else:
-        return UNKNOWN.from_packet(length, proto, payload)
+        return None
 
 
-def handle_packet(packet, addr, when):
-    if len(packet) < 6:
-        return UNKNOWN.from_packet(0, 0, packet)
+def make_object(length, proto, payload):
+    if proto in CLASSES:
+        return CLASSES[proto].from_packet(length, payload)
     else:
-        xx, length, proto = unpack("!2sBB", packet[:4])
-        crlf = packet[-2:]
-        payload = packet[4:-2]
-        adjust = 2 if proto == STATUS.PROTO else 4  # Weird special case
-        if (
-            proto
-            not in (WIFI_POSITIONING.PROTO, WIFI_OFFLINE_POSITIONING.PROTO)
-            and length > 1
-            and len(payload) + adjust != length
-        ):
-            log.warning(
-                "With proto %d length is %d but payload length is %d+%d",
-                proto,
-                length,
-                len(payload),
-                adjust,
-            )
-        if xx != b"xx" or crlf != b"\r\n":
-            return UNKNOWN.from_packet(length, proto, packet)  # full packet
-        else:
-            return make_object(length, proto, payload)
+        retobj = UNKNOWN.from_packet(length, payload)
+        retobj.PROTO = proto  # Override class attr with object attr
+        return retobj
+
+
+def parse_message(packet):
+    length, proto = unpack("BB", packet[:2])
+    payload = packet[2:]
+    adjust = 2 if proto == STATUS.PROTO else 4  # Weird special case
+    if (
+        proto not in (WIFI_POSITIONING.PROTO, WIFI_OFFLINE_POSITIONING.PROTO)
+        and length > 1
+        and len(payload) + adjust != length
+    ):
+        log.warning(
+            "With proto %d length is %d but payload length is %d+%d",
+            proto,
+            length,
+            len(payload),
+            adjust,
+        )
+    return make_object(length, proto, payload)
 
 
-def make_response(msg, **kwargs):
-    return msg.response(**kwargs)
+def handle_packet(packet):  # DEPRECATED
+    if len(packet) < 6 or packet[:2] != b"xx" or packet[-2:] != b"\r\n":
+        return UNKNOWN.from_packet(len(packet), packet)
+    return parse_message(packet[2:-2])
 
 
-def set_config(config):  # Note that we are setting _class_ attribute
-    _GT06pkt.CONFIG = config
+def make_response(msg, **kwargs):  # DEPRECATED
+    inframe = msg.response(**kwargs)
+    return None if inframe is None else b"xx" + inframe + b"\r\n"