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)
