Added webinterface

Author: alfredkrohmer

dcp.py

@@ -10,6 +10,17 @@
     "ip": PNDCPBlock.IP_ADDRESS
 }
 
+
+class DCPDeviceDescription:
+    def __init__(self, mac, blocks):
+        self.mac = mac2s(mac)
+        self.name = blocks[PNDCPBlock.NAME_OF_STATION].decode()
+        self.ip = s2ip(blocks[PNDCPBlock.IP_ADDRESS][0:4])
+        self.netmask = s2ip(blocks[PNDCPBlock.IP_ADDRESS][4:8])
+        self.gateway = s2ip(blocks[PNDCPBlock.IP_ADDRESS][8:12])
+        self.vendorHigh, self.vendorLow, self.devHigh, self.devLow = unpack(">BBBB", blocks[PNDCPBlock.DEVICE_ID][0:4])
+
+
 def get_param(s, src, target, param):
     dst = s2mac(target)
 
@@ -59,13 +70,19 @@ def send_request(s, src, t, value):
     s.send(bytes(eth))
 
 
-def read_response(s, my_mac, want=None, debug=False):
-    ret = []
+def read_response(s, my_mac, to=20, once=False, debug=False):
+    ret = {}
     found = []
+    s.settimeout(2)
     try:
-        with timeout(20):
-            while s is not None:
-                data = s.recv(1522)
+        with max_timeout(to) as t:
+            while True:
+                if t.timed_out:
+                    break
+                try:
+                    data = s.recv(1522)
+                except timeout:
+                    continue
 
                 # nur Ethernet Pakete an uns und vom Ethertype Profinet
                 eth = EthernetHeader(data)
@@ -81,19 +98,22 @@ def read_response(s, my_mac, want=None, debug=False):
                 # Blöcke der Response parsen
                 blocks = pro.payload
                 length = pro.length
+                parsed = {}
 
                 while length > 6:
                     block = PNDCPBlock(blocks)
-                    if want is None or (block.option, block.suboption) in want:
-                        found.append((block.option, block.suboption))
-                        ret.append(block)
+                    blockoption = (block.option, block.suboption)
+                    parsed[blockoption] = block.payload
 
                     block_len = block.length
-                    if debug:
-                        if (block.option, block.suboption) == PNDCPBlock.NAME_OF_STATION:
-                            print("Name of Station: %s" % block.payload)
-                        elif (block.option, block.suboption) == PNDCPBlock.IP_ADDRESS:
-                            print(str(block.parse_ip()))
+                    if blockoption == PNDCPBlock.NAME_OF_STATION:
+                        debug and print("Name of Station: %s" % block.payload)
+                        parsed["name"] = block.payload
+                    elif blockoption == PNDCPBlock.IP_ADDRESS:
+                        debug and print(str(block.parse_ip()))
+                        parsed["ip"] = s2ip(block.payload[0:4])
+                    elif blockoption == PNDCPBlock.DEVICE_ID:
+                        parsed["devId"] = block.payload
 
                     # Padding:
                     if block_len % 2 == 1:
@@ -102,8 +122,10 @@ def read_response(s, my_mac, want=None, debug=False):
                     # geparsten Block entfernen
                     blocks = blocks[block_len+4:]
                     length -= 4 + block_len
+
+                ret[eth.src] = parsed
 
-                if want is not None and sorted(found) == sorted(want):
+                if once:
                     break
 
     except TimeoutError:

main.py

@@ -34,7 +34,7 @@
 elif args.action.startswith("read") or args.action.startswith("write"):
     print("Getting station info ...")
     info = rpc.get_station_info(s, src, args.target)
-    con = rpc.RPCCon(*info)
+    con = rpc.RPCCon(info)
 
     print("Connecting to device ...")
     con.connect(src)

rpc.py

@@ -1,5 +1,6 @@
 from struct import unpack
 from socket import MSG_WAITALL
+from datetime import datetime
 
 from util import *
 from protocol import *
@@ -9,118 +10,110 @@
 
 def get_station_info(s, src, name):
     dcp.send_request(s, src, PNDCPBlock.NAME_OF_STATION, bytes(name, 'utf-8'))
-    ret = dcp.read_response(s, src, want=(PNDCPBlock.IP_ADDRESS, PNDCPBlock.DEVICE_ID))
-
-    ip = ""
-    vendorHigh = vendorLow = devHigh = devLow = 0
-    for block in ret:
-        if (block.option, block.suboption) == PNDCPBlock.IP_ADDRESS:
-            ip = s2ip(block.payload[0:4])
-        if (block.option, block.suboption) == PNDCPBlock.DEVICE_ID:
-            vendorHigh, vendorLow, devHigh, devLow = unpack(">BBBB", block.payload[0:4])
-    
-    return ip, vendorHigh, vendorLow, devHigh, devLow
+    resp = list(dcp.read_response(s, src, once=True).items())[0]
+    return dcp.DCPDeviceDescription(*resp)
 
 
 class RPCCon:
-    def __init__(self, ip, vendorHigh, vendorLow, devHigh, devLow):
-        self.peer = (ip, 0x8894)
-        self.ip = ip
+    def __init__(self, info):
+        self.info = info
+        self.peer = (info.ip, 0x8894)
+        
+        self.ar_uuid = bytes([0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff])
+        self.activity_uuid = ar_uuid
+        
+        self.local_object_uuid  = PNRPCHeader.OBJECT_UUID_PREFIX + bytes([0x00, 0x01, 0x76,              0x54,             0x32,                 0x10])
+        self.remote_object_uuid = PNRPCHeader.OBJECT_UUID_PREFIX + bytes([0x00, 0x01, self.info.devHigh, self.info.devLow, self.info.vendorHigh, self.info.vendorLow])
+        
+        self.live = None
+        
         self.u = socket(AF_INET, SOCK_DGRAM)
-        self.vendorHigh, self.vendorLow, self.devHigh, self.devLow = vendorHigh, vendorLow, devHigh, devLow
 
-    def read(self, api, slot, subslot, idx):
-        block = PNBlockHeader(PNBlockHeader.IDOReadRequestHeader, 60, 0x01, 0x00)
-        iod = PNIODHeader(bytes(block), 0,
-            bytes([0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff]),
-            api, slot, subslot, 0, idx, 4096, bytes(16), bytes(8), payload=bytes())
-        nrd = PNNRDData(1500, len(iod), 1500, 0, len(iod), payload=iod)
-        rpc = PNRPCHeader(0x04, PNRPCHeader.REQUEST,
+
+    def _create_rpc(self, operation, nrd):
+        return PNRPCHeader(0x04, PNRPCHeader.REQUEST,
             0x20, # Flags1
             0x00, # Flags2
             bytes([0x00, 0x00, 0x00]), # DRep
             0x00, # Serial High
-            PNRPCHeader.OBJECT_UUID_PREFIX + bytes([0x00, 0x01, self.devHigh, self.devLow, self.vendorHigh, self.vendorLow]), # ObjectUUID
+            self.remote_object_uuid,
             PNRPCHeader.IFACE_UUID_DEVICE,
-            bytes([0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff]), # ActivityUUID
+            self.activity_uuid,
             0, # ServerBootTime
             1, # InterfaceVersion
             0, # SequenceNumber
-            PNRPCHeader.READ, # OperationNumber
+            operation,
             0xFFFF, # InterfaceHint
             0xFFFF, # ActivityHint
-            len(nrd), # LengthOfBody
+            len(nrd),
             0, # FragmentNumber
             0, # AuthenticationProtocol
             0, # SerialLow
             payload=nrd
         )
+    
+    def _create_nrd(self, payload):
+        return PNNRDData(1500, len(payload), 1500, 0, len(payload), payload=payload)
+
+    def _check_timeout(self):
+        if (datetime.now() - self.live).seconds >= 10:
+            self.connect()
+
+
+    def connect(self, src_mac=None):
+        if self.live is None:
+            self.src_mac = src_mac
+
+        block = PNBlockHeader(0x0101, PNARBlockRequest.fmt_size - 2, 0x01, 0x00)
+        ar = PNARBlockRequest(bytes(block),
+            0x0006, # AR Type
+            self.ar_uuid, # AR UUID
+            0x1234, # Session key
+            src_mac,
+            self.local_object_uuid,
+            0x131, # AR Properties
+            100, # Timeout factor
+            0x8892, # udp port?
+            2,
+            bytes("tp", encoding="utf-8"), payload=bytes()
+        )
+        nrd = self._create_nrd(ar)
+        rpc = self._create_rpc(PNRPCHeader.CONNECT, nrd)
         self.u.sendto(bytes(rpc), self.peer)
 
         data = self.u.recvfrom(4096)[0]
-        rpc = PNRPCHeader(data)
-        nrd = PNNRDData(rpc.payload)
-        iod = PNIODHeader(nrd.payload)
-        block = PNBlockHeader(iod.block_header)
+        # ignore response
+        #rpc = PNRPCHeader(data)
+        #nrd = PNNRDData(rpc.payload)
+        #ar = PNARBlockRequest(nrd.payload)
+        #block = PNBlockHeader(iod.block_header)
 
-        return iod
+        self.live = datetime.now()
 
-    def write(self, api, slot, subslot, idx, data):
-        block = PNBlockHeader(0x8, 60, 0x01, 0x00)
-        iod = PNIODHeader(bytes(block), 0,
-            bytes([0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff]),
-            api, slot, subslot, 0, idx, len(data), bytes(16), bytes(8), payload=bytes(data))
-        nrd = PNNRDData(1500, len(iod), 1500, 0, len(iod), payload=iod)
-        rpc = PNRPCHeader(0x04, PNRPCHeader.REQUEST,
-            0x20, # Flags1
-            0x00, # Flags2
-            bytes([0x00, 0x00, 0x00]), # DRep
-            0x00, # Serial High
-            PNRPCHeader.OBJECT_UUID_PREFIX + bytes([0x00, 0x01, self.devHigh, self.devLow, self.vendorHigh, self.vendorLow]), # ObjectUUID
-            PNRPCHeader.IFACE_UUID_DEVICE,
-            bytes([0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff]), # ActivityUUID
-            0, # ServerBootTime
-            1, # InterfaceVersion
-            0, # SequenceNumber
-            PNRPCHeader.WRITE, # OperationNumber
-            0xFFFF, # InterfaceHint
-            0xFFFF, # ActivityHint
-            len(nrd), # LengthOfBody
-            0, # FragmentNumber
-            0, # AuthenticationProtocol
-            0, # SerialLow
-            payload=nrd
-        )
+    def read(self, api, slot, subslot, idx):
+        self._check_timeout()
+        
+        block = PNBlockHeader(PNBlockHeader.IDOReadRequestHeader, 60, 0x01, 0x00)
+        iod = PNIODHeader(bytes(block), 0, self.ar_uuid, api, slot, subslot, 0, idx, 4096, bytes(16), bytes(8), payload=bytes())
+        nrd = self._create_nrd(iod)
+        rpc = self._create_rpc(PNRPCHeader.READ, nrd)
         self.u.sendto(bytes(rpc), self.peer)
 
         data = self.u.recvfrom(4096)[0]
+        rpc = PNRPCHeader(data)
+        nrd = PNNRDData(rpc.payload)
+        iod = PNIODHeader(nrd.payload)
+        block = PNBlockHeader(iod.block_header)
+        
+        self.live = datetime.now()
 
         return iod
 
     def read_implicit(self, api, slot, subslot, idx):
         block = PNBlockHeader(PNBlockHeader.IDOReadRequestHeader, 60, 0x01, 0x00)
         iod = PNIODHeader(bytes(block), 0, bytes(16), api, slot, subslot, 0, idx, 4096, bytes(16), bytes(8), payload=bytes())
-        nrd = PNNRDData(1500, len(iod), 1500, 0, len(iod), payload=iod)
-        rpc = PNRPCHeader(0x04, PNRPCHeader.REQUEST,
-            0x20, # Flags1
-            0x00, # Flags2
-            bytes([0x00, 0x00, 0x00]), # DRep
-            0x00, # Serial High
-            PNRPCHeader.OBJECT_UUID_PREFIX + bytes([0x00, 0x01, self.devHigh, self.devLow, self.vendorHigh, self.vendorLow]), # ObjectUUID
-            PNRPCHeader.IFACE_UUID_DEVICE,
-            bytes([0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff]), # ActivityUUID
-            0, # ServerBootTime
-            1, # InterfaceVersion
-            0, # SequenceNumber
-            PNRPCHeader.IMPLICIT_READ, # OperationNumber
-            0xFFFF, # InterfaceHint
-            0xFFFF, # ActivityHint
-            len(nrd), # LengthOfBody
-            0, # FragmentNumber
-            0, # AuthenticationProtocol
-            0, # SerialLow
-            payload=nrd
-        )
+        nrd = self._create_nrd(iod)
+        rpc = self._create_rpc(PNRPCHeader.IMPLICIT_READ, nrd)
         self.u.sendto(bytes(rpc), self.peer)
 
         data = self.u.recvfrom(4096)[0]
@@ -131,51 +124,20 @@ def read_implicit(self, api, slot, subslot, idx):
 
         return iod
 
-    def connect(self, src_mac):
-        block = PNBlockHeader(0x0101, PNARBlockRequest.fmt_size - 2, 0x01, 0x00)
-        ar = PNARBlockRequest(bytes(block),
-            0x0006, # AR Type
-            bytes([0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff]), # AR UUID
-            0x1234, # Session key
-            src_mac,
-            PNRPCHeader.OBJECT_UUID_PREFIX + bytes([0x00, 0x01, 0x76, 0x54, 0x32, 0x10]),
-            0x131, # AR Properties
-            100, # Timeout factor
-            0x8892, # udp port?
-            2,
-            bytes("tp", encoding="utf-8"), payload=bytes()
-        )
-        nrd = PNNRDData(1500, len(ar), 1500, 0, len(ar), payload=ar)
-        rpc = PNRPCHeader(0x04, PNRPCHeader.REQUEST,
-            0x20, # Flags1
-            0x00, # Flags2
-            bytes([0x00, 0x00, 0x00]), # DRep
-            0x00, # Serial High
-            PNRPCHeader.OBJECT_UUID_PREFIX + bytes([0x00, 0x01, self.devHigh, self.devLow, self.vendorHigh, self.vendorLow]), # ObjectUUID
-            PNRPCHeader.IFACE_UUID_DEVICE,
-            bytes([0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff]), # ActivityUUID
-            0, # ServerBootTime
-            1, # InterfaceVersion
-            0, # SequenceNumber
-            PNRPCHeader.CONNECT, # OperationNumber
-            0xFFFF, # InterfaceHint
-            0xFFFF, # ActivityHint
-            len(nrd), # LengthOfBody
-            0, # FragmentNumber
-            0, # AuthenticationProtocol
-            0, # SerialLow
-            payload=nrd
-        )
+    def write(self, api, slot, subslot, idx, data):
+        self._check_timeout()
+        block = PNBlockHeader(0x8, 60, 0x01, 0x00)
+        iod = PNIODHeader(bytes(block), 0, self.ar_uuid, api, slot, subslot, 0, idx, len(data), bytes(16), bytes(8), payload=bytes(data))
+        nrd = self._create_nrd(iod)
+        rpc = self._create_rpc(PNRPCHeader.WRITE, nrd)
         self.u.sendto(bytes(rpc), self.peer)
 
         data = self.u.recvfrom(4096)[0]
-        #rpc = PNRPCHeader(data)
-        #nrd = PNNRDData(rpc.payload)
-        #ar = PNARBlockRequest(nrd.payload)
-        #block = PNBlockHeader(iod.block_header)
+        # ignore response
 
-        return ar
-    
+        self.live = datetime.now()
+
+
     def read_inm0filter(self):
         data = self.read(api=0, slot=0, subslot=0, idx=0xF840).payload
         block = PNBlockHeader(data)