def recvFromClientSocket(self, clientSocket): data = self.myrecv(clientSocket) if data: message_type = PacketParser.get_msg_type(data) # "tracker","low battery","help me", "heartbeat", "init" if message_type == 'init': self.IMEIs[clientSocket] = PacketParser.get_imei(data) if message_type in self.answer: self.queue_message(clientSocket, self.answer[message_type]) elif message_type == "help me" or message_type == "low battery": self.queue_message(clientSocket, "**,IMEIs:%s,E" % self.IMEIs[clientSocket]) # we should do something else, perhaps add database log. if not self.setup_repeat[clientSocket]: self.queue_message(clientSocket, '**,IMEIs:' + self.IMEIs[clientSocket] +',C,20s') self.setup_repeat[clientSocket] = True if message_type in self.signal_types: if PacketParser.is_valid_gps_signal(data): #try: ModelWriter.writeLocationLog(self.IMEIs[clientSocket],data) #except: # print 'Error writing to Location Log' else: print 'recvFromClientSocket: not valid gps signal \r\n imei=%s\r\ndata=%s' % (self.IMEIs[clientSocket],data) else: # readable socket without data means the client disconnected self.cleanup_socket(clientSocket)
class TestFilterMAC(_FilterDefaultTest, unittest.TestCase): with open('test_packets/tcp_packet', 'rb') as f: raw_data = f.read() pack_filter = OneArgumentSimpleFilter( "EthernetHeader.destination_MAC_address==" + "00:50:56:e9:04:2e") one_lvl_pack = pp.parse_Ethernet(raw_data) all_lvl_pack = pp.parse_raw_packet(raw_data, 'Ethernet') def test_one_lvl_filter_with_all_lvl_pack(self): res = self.pack_filter.filter_one_level(self.all_lvl_pack) self.check(res)
def test_all(self): p = pp.parse_Ethernet(self.raw_data) h = p.header data = p.data self.assertEqual(str(h.ether_type), "ARP") arp_header = pp.parse_ARP(data).header self.assertEqual(str(arp_header.hardware_type), "Ethernet") self.assertEqual(str(arp_header.protocol_type), "IPv4") self.assertEqual(int(arp_header.hw_addr_byte_len), 6) self.assertEqual(int(arp_header.proto_addr_byte_len), 4) self.assertEqual(int.from_bytes(arp_header.operation_code, "big"), 1) self.assertEqual(str(arp_header.hw_addr_sender), "b4:86:55:8c:fa:76") self.assertEqual(str(arp_header.proto_addr_sender), "192.168.8.1") self.assertEqual(str(arp_header.hw_addr_target), "00:00:00:00:00:00") self.assertEqual(str(arp_header.proto_addr_target), "192.168.8.103")
class TestARPhw_addr(_FilterDefaultTest, unittest.TestCase): with open('test_packets/arp_packet', 'rb') as f: raw_data = f.read() pack_filter = OneArgumentSimpleFilter( 'ARPHeader.hw_addr_sender==b4:86:55:8c:fa:76') all_lvl_pack = pp.parse_raw_packet(raw_data, 'Ethernet') one_lvl_pack = all_lvl_pack.data
class TestFilterIP(_FilterDefaultTest, unittest.TestCase): with open('test_packets/tcp_packet', 'rb') as f: raw_data = f.read() pack_filter = OneArgumentSimpleFilter( 'IPv4Header.source_address==192.168.221.128') all_lvl_pack = pp.parse_raw_packet(raw_data, 'Ethernet') one_lvl_pack = all_lvl_pack.data
def writeLocationLog(imei , data): locationLog = LocationLog() utm = PacketParser.get_utm(data) locationLog.lat = utm[0] locationLog.long = utm[1] locationLog.timestamp = timezone.now() locationLog.speed = PacketParser.get_speed(data) locationLog.heading = PacketParser.get_heading(data) locationLog.car = getCarByImei(imei) locationLog.driver = locationLog.car.getDriverByDate(locationLog.timestamp) locationLog.save() checkAlerts(locationLog)
def test_all(self): pack = pp.parse_raw_packet(self.raw_data, "Ethernet") ip_header = pack.data.header self.assertEqual(str(pack.header.ether_type), "IPv4") self.assertEqual(str(ip_header.protocol_type), "ICMP") icmp_h = pack.data.data.header self.assertEqual(str(icmp_h.type), "Echo Request")
def checkForTriggers(locationLog, alert): alert_exist = False if str(alert.type) == str(Alert.SPEED_ALERT): if locationLog.speed >= alert.max_speed: alert_exist = True if str(alert.type) == str(Alert.GEOFENCE_ALERT): if PacketParser.is_out_of_area(locationLog, alert): alert_exist = True if str(alert.type) == str(Alert.SCHEDULE_ALERT): if PacketParser.is_in_time_slot(locationLog.timestamp, alert.schedule_profile.schedule_bit_field): alert_exist = True # print "checkForTriggers returned " + str(alert_exist) return alert_exist
def test_all(self): pack = pp.parse_raw_packet(self.raw_data, "Ethernet") ip_header = pack.data.header self.assertEqual(str(pack.header.ether_type), "IPv4") ip_header = pack.data.header ip_data = pack.data.data self.assertEqual(str(ip_header.protocol_type), "UDP") udp_h = ip_data.header self.assertEqual(udp_h.source_port, 50178) self.assertEqual(udp_h.destination_port, 3702) self.assertEqual(udp_h.length, 999)
def makeNewLocationLog(self): unit_collection = Unit.objects.get(imei=self.imei) if not unit_collection: print 'we got a message from unit we don\'t know, imei# %s, it said: "%s"' % self.imei, self.data return unit = unit_collection[0] car = unit.car utm = PacketParser.get_utm(self.data) driver = car ? car.getDriverByDate(datetime.now()) : None kwargs = { "timestamp" : datetime.now(), "lat" : utm[0], "long" : utm[1], "speed" : PacketParser.get_speed(self.data), "heading" : PacketParser.get_heading(self.data) , "car" : car , "driver" : driver, } logToWrite = LocationLog(**kwargs) logToWrite.save() return logToWrite
class TestFilterPort(_FilterDefaultTest, unittest.TestCase): with open('test_packets/udp_packet', 'rb') as f: raw_data = f.read() pack_filter = OneArgumentSimpleFilter('UDPHeader.source_port==50178') all_lvl_pack = pp.parse_raw_packet(raw_data, 'Ethernet') one_lvl_pack = all_lvl_pack.data.data
def test_mac_parsing(self): pack = pp.parse_Ethernet(self.raw_data) h = pack.header self.assertEqual(str(h.destination_MAC_address), "00:50:56:e9:04:2e") self.assertEqual(str(h.source_MAC_address), "00:0c:29:84:86:5f")
def test_ip_address_parsing(self): pack = pp.parse_raw_packet(self.raw_data, "Ethernet") ip_header = pack.data.header self.assertEqual(str(ip_header.source_address), "192.168.221.128") self.assertEqual(str(ip_header.destination_address), "122.249.180.9")
def main(): wx, wy, over = 640, 480, 2 #over = oversampling parser = PacketParser.Parser(port = 6) parser.start() pygame.init() fps = pygame.time.Clock() window = pygame.display.set_mode((wx, wy)) surface = pygame.Surface((wx*over, wy*over)) font = pygame.font.Font('C:\\windows\\fonts\\lucon.ttf', 50) scale = 0.15 * over stroke_list = [] color_list = [] col = { 'black': pygame.Color(0, 0, 0), 'red': pygame.Color(255, 0, 0), 'white': pygame.Color(255, 255, 255) } region = { 'black': ((515.0, 650.0), (775.0, 915.0)), 'red': ((775.0, 650.0), (1035.0, 915.0)) } mode = { 'normal': K_1, 'tremble': K_2, 'order': K_3 } mode_inv = dict((b, a) for (a,b) in mode.items()) current_color = col['black'] chose_mode = mode['normal'] while True: if parser.get_locked(): # Get mutex mine / Get stroke stroke = parser.get_stroke(); for rn in region.keys(): # Whether be changing color or not if is_in_region(region[rn], stroke[0].x, stroke[0].y): current_color = col[rn] break else: stroke_list.append([(p.x * scale, p.y * scale) for p in stroke]) color_list.append(current_color) surface.fill(col['white']) # Let there be light mouse = pygame.mouse.get_pos() mouse_dist = norm(mouse) #arrow_line(surface, col['red'], (500, 400), mouse, mouse_dist/8, 3) for (st, co, i) in zip(stroke_list, color_list, range(1, len(stroke_list)+1)): # Draw lines if len(st) >= 5: if chose_mode == mode['normal']: pygame.draw.lines(surface, co, 0, st, 6*over) elif chose_mode == mode['tremble']: pygame.draw.lines(surface, co, 0, tremble_list(st, 5, 2), 6*over) #alt_lines(surface, co, tremble_list(st, 3, 2), 20) elif chose_mode == mode['order']: pygame.draw.lines(surface, co, 0, st, 6*over) draw_stroke_order(surface, font, col['red'], st, i, 15*over, 10*over, 30*over) for event in pygame.event.get(): # Deal with events if event.type == QUIT: pygame.display.quit() sys.exit() elif event.type == KEYDOWN: if event.key == K_ESCAPE: pygame.display.quit() sys.exit() elif event.key in mode.values(): chose_mode = mode[mode_inv[event.key]] pygame.display.set_caption('Digital Pen Test fps:%d' % fps.get_fps()) window.blit(pygame.transform.smoothscale(surface, (wx, wy)), (0, 0)) pygame.display.update() fps.tick(60)
def callback(*args): PacketParser.load_packet(*args + dicts)
def get_in_msg(self, chk): packet = self.channel.get_in_msg(chk)[1] sent_t = PacketParser.get_time(packet) ack_t = self.channel.get_in_t(chk) return (PacketParser.get_content(packet), sent_t, ack_t)