def networks():
try:
from .config import Config
from .networks import Networks
from .tracks import Tracks
except SystemError:
from config import Config
from networks import Networks
from tracks import Tracks
def dummy(bla):
return
test_data = get_client_test_data()[2]
test_config = Config(None).default_config
networks = Networks(test_config)
networks.notify_add_list["map"] = dummy
networks.notify_add_list["network_list"] = dummy
networks.notify_remove_list["map"] = dummy
networks.notify_remove_list["network_list"] = dummy
for x in range(2):
for data in test_data:
if data is not None and data[0] == "bssid":
networks.add_bssid_data(data[1], 0)
data[1]["lasttime"] = data[1]["lasttime"] + 1
for data in test_data:
if data is not None and data[0] == "ssid":
networks.add_ssid_data(data[1])
data[1]["lasttime"] = data[1]["lasttime"] + 1
tmp_csv_file = "%s%stest-%s.csv" % (tempfile.gettempdir(), os.sep, int(time.time()))
tmp_csv = open(tmp_csv_file, "w")
tmp_csv.write("""Network;NetType;ESSID;BSSID;Info;Channel;Cloaked;Encryption;Decrypted;MaxRate;MaxSeenRate;Beacon;LLC;Data;Crypt;Weak;Total;Carrier;Encoding;FirstTime;LastTime;BestQuality;BestSignal;BestNoise;GPSMinLat;GPSMinLon;GPSMinAlt;GPSMinSpd;GPSMaxLat;GPSMaxLon;GPSMaxAlt;GPSMaxSpd;GPSBestLat;GPSBestLon;GPSBestAlt;DataSize;IPType;IP;
1;infrastructure;asd;11:22:33:44:55:66;;3;No;WEP,WPA,PSK,AES-CCM;No;18.0;1000;25600;148;0;0;0;148;IEEE 802.11g;;Thu Jan 22 05:48:23 2009;Thu Jan 22 05:51:46 2009;0;65;-98;52.123456;13.123456;120.120003;0.000000;52.123456;13.123456;120.120003;2.934490;0.000000;0.000000;0.000000;0;None;0.0.0.0;""")
tmp_csv.close()
for x in range(2):
networks.import_networks("csv", tmp_csv_file)
networks.import_networks("netxml", "")
tmp_tracks_file = "%s%stest-tracks-%s.json" % (tempfile.gettempdir(), os.sep, int(time.time()))
test_tracks = Tracks(tmp_tracks_file)
networks_file = "%s%snetworks-%s.json" % (tempfile.gettempdir(), os.sep, int(time.time()))
networks.save(networks_file)
networks.load(networks_file)
networks.import_networks("networks",networks_file)
networks.apply_filters()
networks.save(networks_file)
networks.export_networks_netxml(tempfile.gettempdir() + os.sep + "test.netxml", networks.networks)
networks.import_networks("netxml", tempfile.gettempdir() + os.sep + "test.netxml")
networks.export_networks_kmz(tempfile.gettempdir() + os.sep + "test.kmz", networks.networks, tracks=test_tracks, filtered=False)
networks.export_networks_kmz(tempfile.gettempdir() + os.sep + "test.kmz", networks.networks, tracks=test_tracks, filtered=True)
return networks
def networks():
try:
from .config import Config
from .networks import Networks
from .tracks import Tracks
except SystemError:
from config import Config
from networks import Networks
from tracks import Tracks
def dummy(bla):
return
test_data = get_client_test_data()[2]
test_config = Config(None).default_config
networks = Networks(test_config)
networks.notify_add_list["map"] = dummy
networks.notify_add_list["network_list"] = dummy
networks.notify_remove_list["map"] = dummy
networks.notify_remove_list["network_list"] = dummy
for x in range(2):
for data in test_data:
if data is not None and data[0] == "bssid":
networks.add_bssid_data(data[1], 0)
data[1]["lasttime"] = data[1]["lasttime"] + 1
for data in test_data:
if data is not None and data[0] == "ssid":
networks.add_ssid_data(data[1])
data[1]["lasttime"] = data[1]["lasttime"] + 1
tmp_csv_file = "%s%stest-%s.csv" % (tempfile.gettempdir(), os.sep, int(time.time()))
tmp_csv = open(tmp_csv_file, "w")
tmp_csv.write("""Network;NetType;ESSID;BSSID;Info;Channel;Cloaked;Encryption;Decrypted;MaxRate;MaxSeenRate;Beacon;LLC;Data;Crypt;Weak;Total;Carrier;Encoding;FirstTime;LastTime;BestQuality;BestSignal;BestNoise;GPSMinLat;GPSMinLon;GPSMinAlt;GPSMinSpd;GPSMaxLat;GPSMaxLon;GPSMaxAlt;GPSMaxSpd;GPSBestLat;GPSBestLon;GPSBestAlt;DataSize;IPType;IP;
1;infrastructure;asd;11:22:33:44:55:66;;3;No;WEP,WPA,PSK,AES-CCM;No;18.0;1000;25600;148;0;0;0;148;IEEE 802.11g;;Thu Jan 22 05:48:23 2009;Thu Jan 22 05:51:46 2009;0;65;-98;52.123456;13.123456;120.120003;0.000000;52.123456;13.123456;120.120003;2.934490;0.000000;0.000000;0.000000;0;None;0.0.0.0;""")
tmp_csv.close()
for x in range(2):
networks.import_networks("csv", tmp_csv_file)
networks.import_networks("netxml", "")
tmp_tracks_file = "%s%stest-tracks-%s.json" % (tempfile.gettempdir(), os.sep, int(time.time()))
test_tracks = Tracks(tmp_tracks_file)
networks_file = "%s%snetworks-%s.json" % (tempfile.gettempdir(), os.sep, int(time.time()))
networks.save(networks_file)
networks.load(networks_file)
networks.import_networks("networks",networks_file)
networks.apply_filters()
networks.save(networks_file)
networks.export_networks_netxml(tempfile.gettempdir() + os.sep + "test.netxml", networks.networks)
networks.import_networks("netxml", tempfile.gettempdir() + os.sep + "test.netxml")
networks.export_networks_kmz(tempfile.gettempdir() + os.sep + "test.kmz", networks.networks, tracks=test_tracks)
return networks
class Controller:
def __init__(self):
self.estimator = Networks(NX,
NU,
x_range=np.array([X_MIN, X_MAX]),
u_range=np.array([U_MIN, U_MAX]))
self.estimator.load()
# Last state trajectory calculated
self.X = np.array([])
self.U = np.array([])
self.time = 0
self.current_state = np.zeros(NX)
self.end = np.zeros(NX)
# time from the start of the current trajectory in ns
self.t = 0 # useless as attribute?
self.t_idx = 0
self.client = actionlib.SimpleActionClient(OPT_CONTROL_ACTION_SERVER,
OptControlAction)
self.client.wait_for_server()
self.pub = rospy.Publisher('controller', Control, queue_size=10)
def next_control(self):
"""Choose next control depending on the current_state and self.U
Callback to service controller"""
self.t += 1 / CPS # Maybe useless after init
self.t_idx += 1
u = self.U[self.t_idx, :]
print('Control:', u)
# self.pub(u)
return u
def update_trajectory(self, state, resp):
"""Callback to topic simulation"""
print('UPDATE TRAJECTORYYYYY')
print(state)
print(resp)
if resp.success:
X = np.array(resp.states).reshape(len(resp.states) // NX, NX)
U = np.array(resp.controls).reshape(len(resp.controls) // NU, NU)
self.time = resp.time
# Resample the trajectories
nb_control = int(resp.time * CPS) + 1
self.X = resample(X, nb_control) # maybe not necessary
self.U = resample(U, nb_control)
tend = rospy.get_rostime()
self.t = tend.secs - self.tstart.secs
print(self.t)
self.t_idx = int(self.t * CPS)
else:
# TODO
print()
print('FAILURE OF CONTROL!!!!')
print()
def call_update_trajectory_action(self):
"""
Call ACADO warm started by the estimator.
Update the current trajectory (X, U, time).
Maybe start a timer at the beginning?
"""
self.tstart = rospy.get_rostime()
Xe, Ue, Ve = self.estimator.trajectories(self.current_state, self.end)
Xe = Xe.flatten()
Ue = Ue.flatten()
# print(Xe)
# print(Ue)
# print(Ve)
goal = OptControlGoal(list(self.current_state), list(self.end), Xe, Ue,
Ve, NX, NU)
# Fill in the goal here
self.client.send_goal(goal, self.update_trajectory)
# self.client.wait_for_result(rospy.Duration.from_sec(5.0)) # Nope!
def new_end(self, end_state):
"""More after that?"""
self.end = end_state
self.call_update_trajectory_action()
class Core:
def __init__(self):
user_dir = "%s%s.kismon%s" % (os.path.expanduser("~"), os.sep, os.sep)
if not os.path.isdir(user_dir):
print("Creating Kismon user directory %s" % user_dir)
os.mkdir(user_dir)
config_file = "%skismon.conf" % user_dir
self.config_handler = Config(config_file)
self.config_handler.read()
self.config = self.config_handler.config
self.sources = {}
self.crypt_cache = {}
self.networks = Networks(self.config)
self.client_threads = {}
self.init_client_threads()
self.tracks = Tracks("%stracks.json" % user_dir)
self.tracks.load()
if "--disable-map" in sys.argv:
self.map_error = "--disable-map used"
else:
self.map_error = check_osmgpsmap()
if self.map_error is not None:
self.map_error = "%s\nMap disabled" % self.map_error
print(self.map_error, "\n")
self.init_map()
self.main_window = MainWindow(self.config, self.client_start,
self.client_stop, self.map,
self.networks, self.sources, self.tracks,
self.client_threads)
self.main_window.log_list.add("Kismon", "started")
if self.map_error is not None:
self.main_window.log_list.add("Kismon", self.map_error)
self.networks_file = "%snetworks.json" % user_dir
if os.path.isfile(self.networks_file):
try:
self.networks.load(self.networks_file)
except:
error = sys.exc_info()[1]
print(error)
dialog_message = "Could not read the networks file '%s':\n%s\n\nDo you want to continue?" % (
self.networks_file, error)
dialog = Gtk.MessageDialog(self.main_window.gtkwin,
Gtk.DialogFlags.DESTROY_WITH_PARENT,
Gtk.MessageType.ERROR,
Gtk.ButtonsType.YES_NO,
dialog_message)
def dialog_response(dialog, response_id):
self.dialog_response = response_id
dialog.connect("response", dialog_response)
dialog.run()
dialog.destroy()
if self.dialog_response == -9:
print("exit")
self.clients_stop()
self.main_window.gtkwin = None
return
self.networks.set_autosave(self.config["networks"]["autosave"],
self.networks_file,
self.main_window.log_list.add)
if self.map is not None:
self.networks.notify_add_list["map"] = self.add_network_to_map
self.networks.notify_remove_list["map"] = self.map.remove_marker
GLib.timeout_add(100, self.map.set_last_from_config)
self.main_window.network_list.crypt_cache = self.crypt_cache
GLib.timeout_add(500, self.queues_handler)
GLib.timeout_add(300, self.queues_handler_networks)
GLib.idle_add(self.networks.apply_filters)
def init_map(self):
if self.map_error is not None:
self.map = None
else:
try:
from .map import Map
except SystemError:
from map import Map
user_agent = 'kismon/%s' % utils.get_version()
self.map = Map(self.config["map"], user_agent=user_agent)
self.map.set_last_from_config()
def init_client_thread(self, server_id):
server = self.config["kismet"]["servers"][server_id]
self.client_threads[server_id] = ClientThread(server)
self.client_threads[server_id].client.set_capabilities(
('status', 'source', 'info', 'gps', 'bssid', 'bssidsrc', 'ssid'))
if "--create-kismet-dump" in sys.argv:
self.client_threads[server_id].client.enable_dump()
def init_client_threads(self):
server_id = 0
for server in self.config["kismet"]["servers"]:
self.init_client_thread(server_id)
server_id += 1
def client_start(self, server_id):
if server_id in self.client_threads and self.client_threads[
server_id].is_running:
self.client_stop(server_id)
self.sources[server_id] = {}
self.init_client_thread(server_id)
if "--load-kismet-dump" in sys.argv:
self.client_threads[server_id].client.load_dump(sys.argv[2])
self.client_threads[server_id].start()
def client_stop(self, server_id):
if self.client_threads[server_id].client.connecting:
# kill connecting sockets, don't wait for the timeout
try:
self.client_threads[server_id].client.s.shutdown(
socket.SHUT_RDWR)
except OSError:
pass
self.client_threads[server_id].stop()
def clients_stop(self):
for server_id in self.client_threads:
self.client_stop(server_id)
return True
def queue_handler(self, server_id):
server_name = self.config['kismet']['servers'][server_id]
if self.main_window.gtkwin is None:
return False
thread = self.client_threads[server_id]
if len(thread.client.error) > 0:
for error in thread.client.error:
self.main_window.log_list.add(server_name, error)
thread.client.error = []
self.main_window.server_tabs[server_id].server_switch.set_active(
False)
page_num = self.main_window.notebook.page_num(
self.main_window.log_list.widget)
self.main_window.notebook.set_current_page(page_num)
#gps
gps = None
fix = None
gps_queue = thread.get_queue("gps")
while True:
try:
data = gps_queue.pop()
if gps is None:
gps = data
if data["fix"] > 1:
fix = (data["lat"], data["lon"])
if self.config['tracks']['store'] == True:
self.tracks.add_point_to_track(server_name,
data['lat'],
data['lon'],
data['alt'])
break
except IndexError:
break
if gps is not None:
self.main_window.server_tabs[server_id].update_gps_table(gps)
if fix is not None and self.map is not None:
server = "server%s" % (server_id + 1)
if server_id == 0:
self.map.set_position(fix[0], fix[1])
else:
self.map.add_marker(server, server, fix[0], fix[1])
self.map.add_track(fix[0], fix[1], server_id)
#status
for data in thread.get_queue("status"):
self.main_window.log_list.add(server_name, data["text"])
#info
info_queue = thread.get_queue("info")
try:
data = info_queue.pop()
self.main_window.server_tabs[server_id].update_info_table(data)
except IndexError:
pass
#source
update = False
for data in thread.get_queue("source"):
uuid = data["uuid"]
if uuid == "00000000-0000-0000-0000-000000000000":
continue
self.sources[server_id][uuid] = data
update = True
if update is True:
self.main_window.server_tabs[server_id].update_sources_table(
self.sources[server_id])
def queues_handler(self):
for server_id in self.client_threads:
self.queue_handler(server_id)
return True
def queue_handler_networks(self, server_id):
thread = self.client_threads[server_id]
#ssid
for data in thread.get_queue("ssid"):
self.networks.add_ssid_data(data)
#bssid
bssids = {}
for data in thread.get_queue("bssid"):
mac = data["bssid"]
self.networks.add_bssid_data(data, server_id)
if mac in self.main_window.signal_graphs and "signal_dbm" not in thread.client.capabilities[
"bssidsrc"]:
self.main_window.signal_graphs[mac].add_value(
None, None, data["signal_dbm"], server_id)
bssids[mac] = True
#bssidsrc
for data in thread.get_queue("bssidsrc"):
if "signal_dbm" not in data or data["uuid"] not in self.sources[
server_id]:
continue
mac = data["bssid"]
if mac in self.main_window.signal_graphs:
self.main_window.signal_graphs[mac].add_value(
self.sources[server_id][data["uuid"]], data,
data["signal_dbm"], server_id)
if len(self.networks.notify_add_queue) > 0:
self.networks.start_queue()
if len(self.networks.notify_add_queue) > 500:
self.networks.disable_refresh()
self.main_window.networks_queue_progress()
self.main_window.update_statusbar()
def queues_handler_networks(self):
for server_id in self.client_threads:
self.queue_handler_networks(server_id)
return True
def quit(self):
self.clients_stop()
if self.map is not None:
lat = self.map.osm.get_property("latitude")
lon = self.map.osm.get_property("longitude")
self.config["map"]["last_position"] = "%.6f/%.6f" % (lat, lon)
while None in self.config['kismet']['servers']:
self.config['kismet']['servers'].remove(None)
self.config_handler.write()
self.networks.save(self.networks_file, force=True)
if self.config['tracks']['store'] == True:
self.tracks.save()
def add_network_to_map(self, mac):
network = self.networks.get_network(mac)
try:
crypt = self.crypt_cache[network["cryptset"]]
except KeyError:
crypt = decode_cryptset(network["cryptset"], True)
self.crypt_cache[network["cryptset"]] = crypt
if "AES_CCM" in crypt or "AES_OCB" in crypt:
color = "red"
elif "WPA" in crypt:
color = "orange"
elif "WEP" in crypt:
color = "yellow"
else:
color = "green"
self.map.add_marker(mac, color, network["lat"], network["lon"])
class Core:
def __init__(self):
user_dir = "%s%s.kismon%s" % (os.path.expanduser("~"), os.sep, os.sep)
if not os.path.isdir(user_dir):
print("Creating Kismon user directory %s" % user_dir)
os.mkdir(user_dir)
config_file = "%skismon.conf" % user_dir
self.config_handler = Config(config_file)
self.config_handler.read()
self.config = self.config_handler.config
self.marker_text = """Encryption: %s
MAC: %s
Manuf: %s
Type: %s
Channel: %s
First seen: %s
Last seen: %s"""
self.sources = {}
self.crypt_cache = {}
self.networks = Networks(self.config)
self.init_client_thread()
if self.config["kismet"]["connect"] is True:
self.client_start()
if "--disable-map" in sys.argv:
self.map_error = "--disable-map used"
else:
self.map_error = check_osmgpsmap()
if self.map_error is not None:
self.map_error = "%s\nMap disabled" % self.map_error
print(self.map_error, "\n")
self.init_map()
self.main_window = MainWindow(self.config,
self.client_start,
self.client_stop,
self.map,
self.networks,
self.sources,
self.client_thread.client)
self.main_window.log_list.add("Kismon started")
if self.map_error is not None:
self.main_window.log_list.add(self.map_error)
self.networks_file = "%snetworks.json" % user_dir
if os.path.isfile(self.networks_file):
try:
self.networks.load(self.networks_file)
except:
error = sys.exc_info()[1]
print(error)
dialog_message = "Could not read the networks file '%s':\n%s\n\nDo you want to continue?" % (self.networks_file, error)
dialog = Gtk.MessageDialog(self.main_window.gtkwin, Gtk.DialogFlags.DESTROY_WITH_PARENT, Gtk.MessageType.ERROR, Gtk.ButtonsType.YES_NO, dialog_message)
def dialog_response(dialog, response_id):
self.dialog_response = response_id
dialog.connect("response", dialog_response)
dialog.run()
dialog.destroy()
if self.dialog_response == -9:
print("exit")
self.client_thread.stop()
self.main_window.gtkwin = None
return
self.networks.set_autosave(self.config["networks"]["autosave"], self.networks_file, self.main_window.log_list.add)
if self.map is not None:
self.networks.notify_add_list["map"] = self.add_network_to_map
self.networks.notify_remove_list["map"] = self.map.remove_marker
self.main_window.network_list.crypt_cache = self.crypt_cache
self.battery_max = None
self.battery = None
path = "/proc/acpi/battery/"
if os.path.exists(path):
for name in os.listdir(path):
self.battery = name
f = open("%s%s/info" % (path, name))
for line in f.readlines():
if line.startswith("last full capacity:"):
max = line.split(":")[1].strip()
self.battery_max = int(max.split()[0])
break
GObject.timeout_add(30000, self.update_battery_bar)
break
self.update_battery_bar()
GLib.timeout_add(500, self.queue_handler)
GLib.timeout_add(300, self.queue_handler_networks)
GLib.idle_add(self.networks.apply_filters)
def init_map(self):
if self.map_error is not None:
self.map = None
else:
try:
from .map import Map
except SystemError:
from map import Map
self.map = Map(self.config["map"])
self.map.set_zoom(16)
pos = self.config["map"]["last_position"].split("/")
self.map.set_position(float(pos[0]), float(pos[1]), True)
def init_client_thread(self):
self.client_thread = ClientThread(self.config["kismet"]["server"])
self.client_thread.client.set_capabilities(
('status', 'source', 'info', 'gps', 'bssid', 'bssidsrc', 'ssid'))
if "--create-kismet-dump" in sys.argv:
self.client_thread.client.enable_dump()
def client_start(self):
if self.client_thread.is_running is True:
self.client_stop()
self.sources = {}
self.init_client_thread()
if "--load-kismet-dump" in sys.argv:
self.client_thread.client.load_dump(sys.argv[2])
self.client_thread.start()
def client_stop(self):
self.client_thread.stop()
def queue_handler(self):
if self.main_window.gtkwin is None:
return False
if len(self.client_thread.client.error) > 0:
for error in self.client_thread.client.error:
self.main_window.log_list.add(error)
self.client_thread.client.error = []
#gps
gps = None
fix = None
gps_queue = self.client_thread.get_queue("gps")
while True:
try:
data = gps_queue.pop()
if gps is None:
gps = data
if data["fix"] > 1:
fix = (data["lat"], data["lon"])
break
except IndexError:
break
if gps is not None:
self.main_window.update_gps_table(gps)
if fix is not None and self.map is not None:
self.map.set_position(fix[0], fix[1])
#status
for data in self.client_thread.get_queue("status"):
self.main_window.log_list.add(data["text"])
#info
info_queue = self.client_thread.get_queue("info")
try:
data = info_queue.pop()
self.main_window.update_info_table(data)
except IndexError:
pass
#source
update = False
for data in self.client_thread.get_queue("source"):
uuid = data["uuid"]
if uuid == "00000000-0000-0000-0000-000000000000":
continue
self.sources[uuid] = data
update = True
if update is True:
self.main_window.update_sources_table(self.sources)
return True
def queue_handler_networks(self):
#ssid
for data in self.client_thread.get_queue("ssid"):
self.networks.add_ssid_data(data)
#bssid
bssids = {}
for data in self.client_thread.get_queue("bssid"):
mac = data["bssid"]
self.networks.add_bssid_data(data)
if mac in self.main_window.signal_graphs and "signal_dbm" not in self.client_thread.client.capabilities["bssidsrc"]:
self.main_window.signal_graphs[mac].add_value(None, None, data["signal_dbm"])
bssids[mac] = True
#bssidsrc
for data in self.client_thread.get_queue("bssidsrc"):
if "signal_dbm" not in data or data["uuid"] not in self.sources:
continue
mac = data["bssid"]
if mac in self.main_window.signal_graphs:
self.main_window.signal_graphs[mac].add_value(self.sources[data["uuid"]], data, data["signal_dbm"])
if len(self.networks.notify_add_queue) > 0:
self.networks.start_queue()
if len(self.networks.notify_add_queue) > 500:
self.networks.disable_refresh()
self.main_window.networks_queue_progress()
self.main_window.update_statusbar()
return True
def quit(self):
self.client_thread.stop()
self.config_handler.write()
self.networks.save(self.networks_file)
def get_battery_capacity(self):
filename = "/proc/acpi/battery/%s/state" % self.battery
if not os.path.isfile(filename):
return False
f = open(filename)
for line in f.readlines():
if line.startswith("remaining capacity:"):
current = line.split(":")[1].strip()
current = int(current.split()[0])
return round(100.0 / self.battery_max * current, 1)
return False
def update_battery_bar(self):
battery = self.get_battery_capacity()
self.main_window.set_battery_bar(battery)
return True
def add_network_to_map(self, mac):
network = self.networks.get_network(mac)
try:
crypt = self.crypt_cache[network["cryptset"]]
except KeyError:
crypt = decode_cryptset(network["cryptset"], True)
self.crypt_cache[network["cryptset"]] = crypt
if "WPA" in crypt:
color = "red"
elif "WEP" in crypt:
color = "orange"
else:
color = "green"
ssid = network["ssid"]
if ssid == "":
ssid = "<no ssid>"
evils = (("&", "&"),("<", "<"),(">", ">"))
for evil, good in evils:
ssid = ssid.replace(evil, good)
time_format = "%d.%m.%Y %H:%M:%S"
text = self.marker_text % (crypt, mac, network["manuf"],
network["type"], network["channel"],
time.strftime(time_format, time.localtime(network["firsttime"])),
time.strftime(time_format, time.localtime(network["lasttime"]))
)
text = text.replace("&", "&")
self.map.add_marker(mac, color, network["lat"], network["lon"])
class Core:
def __init__(self):
user_dir = "%s%s.kismon%s" % (os.path.expanduser("~"), os.sep, os.sep)
if not os.path.isdir(user_dir):
print("Creating Kismon user directory %s" % user_dir)
os.mkdir(user_dir)
config_file = "%skismon.conf" % user_dir
self.config_handler = Config(config_file)
self.config_handler.read()
self.config = self.config_handler.config
self.sources = {}
self.crypt_cache = {}
self.networks = Networks(self.config)
self.client_threads = {}
self.init_client_threads()
if "--disable-map" in sys.argv:
self.map_error = "--disable-map used"
else:
self.map_error = check_osmgpsmap()
if self.map_error is not None:
self.map_error = "%s\nMap disabled" % self.map_error
print(self.map_error, "\n")
self.init_map()
self.main_window = MainWindow(self.config,
self.client_start,
self.client_stop,
self.map,
self.networks,
self.sources,
self.client_threads)
self.main_window.log_list.add("Kismon", "started")
if self.map_error is not None:
self.main_window.log_list.add("Kismon", self.map_error)
self.networks_file = "%snetworks.json" % user_dir
if os.path.isfile(self.networks_file):
try:
self.networks.load(self.networks_file)
except:
error = sys.exc_info()[1]
print(error)
dialog_message = "Could not read the networks file '%s':\n%s\n\nDo you want to continue?" % (self.networks_file, error)
dialog = Gtk.MessageDialog(self.main_window.gtkwin, Gtk.DialogFlags.DESTROY_WITH_PARENT, Gtk.MessageType.ERROR, Gtk.ButtonsType.YES_NO, dialog_message)
def dialog_response(dialog, response_id):
self.dialog_response = response_id
dialog.connect("response", dialog_response)
dialog.run()
dialog.destroy()
if self.dialog_response == -9:
print("exit")
self.clients_stop()
self.main_window.gtkwin = None
return
self.networks.set_autosave(self.config["networks"]["autosave"], self.networks_file, self.main_window.log_list.add)
if self.map is not None:
self.networks.notify_add_list["map"] = self.add_network_to_map
self.networks.notify_remove_list["map"] = self.map.remove_marker
GLib.timeout_add(100, self.map.set_last_from_config)
self.main_window.network_list.crypt_cache = self.crypt_cache
GLib.timeout_add(500, self.queues_handler)
GLib.timeout_add(300, self.queues_handler_networks)
GLib.idle_add(self.networks.apply_filters)
def init_map(self):
if self.map_error is not None:
self.map = None
else:
try:
from .map import Map
except SystemError:
from map import Map
user_agent = 'kismon/%s' % utils.get_version()
self.map = Map(self.config["map"], user_agent=user_agent)
self.map.set_last_from_config()
def init_client_thread(self, server_id):
server = self.config["kismet"]["servers"][server_id]
self.client_threads[server_id] = ClientThread(server)
self.client_threads[server_id].client.set_capabilities(
('status', 'source', 'info', 'gps', 'bssid', 'bssidsrc', 'ssid'))
if "--create-kismet-dump" in sys.argv:
self.client_threads[server_id].client.enable_dump()
def init_client_threads(self):
server_id=0
for server in self.config["kismet"]["servers"]:
self.init_client_thread(server_id)
server_id += 1
def client_start(self, server_id):
if server_id in self.client_threads and self.client_threads[server_id].is_running:
self.client_stop(server_id)
self.sources[server_id] = {}
self.init_client_thread(server_id)
if "--load-kismet-dump" in sys.argv:
self.client_threads[server_id].client.load_dump(sys.argv[2])
self.client_threads[server_id].start()
def client_stop(self, server_id):
if self.client_threads[server_id].client.connecting:
# kill connecting sockets, don't wait for the timeout
try:
self.client_threads[server_id].client.s.shutdown(socket.SHUT_RDWR)
except OSError:
pass
self.client_threads[server_id].stop()
def clients_stop(self):
for server_id in self.client_threads:
self.client_stop(server_id)
return True
def queue_handler(self, server_id):
server_name = self.config['kismet']['servers'][server_id]
if self.main_window.gtkwin is None:
return False
thread = self.client_threads[server_id]
if len(thread.client.error) > 0:
for error in thread.client.error:
self.main_window.log_list.add(server_name, error)
thread.client.error = []
self.main_window.server_tabs[server_id].server_switch.set_active(False)
page_num = self.main_window.notebook.page_num(self.main_window.log_list.widget)
self.main_window.notebook.set_current_page(page_num)
#gps
gps = None
fix = None
gps_queue = thread.get_queue("gps")
while True:
try:
data = gps_queue.pop()
if gps is None:
gps = data
if data["fix"] > 1:
fix = (data["lat"], data["lon"])
break
except IndexError:
break
if gps is not None:
self.main_window.server_tabs[server_id].update_gps_table(gps)
if fix is not None and self.map is not None:
server = "server%s" % (server_id + 1)
if server_id == 0:
self.map.set_position(fix[0], fix[1])
else:
self.map.add_marker(server, server, fix[0], fix[1])
self.map.add_track(fix[0], fix[1], server_id)
#status
for data in thread.get_queue("status"):
self.main_window.log_list.add(server_name, data["text"])
#info
info_queue = thread.get_queue("info")
try:
data = info_queue.pop()
self.main_window.server_tabs[server_id].update_info_table(data)
except IndexError:
pass
#source
update = False
for data in thread.get_queue("source"):
uuid = data["uuid"]
if uuid == "00000000-0000-0000-0000-000000000000":
continue
self.sources[server_id][uuid] = data
update = True
if update is True:
self.main_window.server_tabs[server_id].update_sources_table(self.sources[server_id])
def queues_handler(self):
for server_id in self.client_threads:
self.queue_handler(server_id)
return True
def queue_handler_networks(self, server_id):
thread = self.client_threads[server_id]
#ssid
for data in thread.get_queue("ssid"):
self.networks.add_ssid_data(data)
#bssid
bssids = {}
for data in thread.get_queue("bssid"):
mac = data["bssid"]
self.networks.add_bssid_data(data, server_id)
if mac in self.main_window.signal_graphs and "signal_dbm" not in thread.client.capabilities["bssidsrc"]:
self.main_window.signal_graphs[mac].add_value(None, None, data["signal_dbm"], server_id)
bssids[mac] = True
#bssidsrc
for data in thread.get_queue("bssidsrc"):
if "signal_dbm" not in data or data["uuid"] not in self.sources[server_id]:
continue
mac = data["bssid"]
if mac in self.main_window.signal_graphs:
self.main_window.signal_graphs[mac].add_value(self.sources[server_id][data["uuid"]], data, data["signal_dbm"], server_id)
if len(self.networks.notify_add_queue) > 0:
self.networks.start_queue()
if len(self.networks.notify_add_queue) > 500:
self.networks.disable_refresh()
self.main_window.networks_queue_progress()
self.main_window.update_statusbar()
def queues_handler_networks(self):
for server_id in self.client_threads:
self.queue_handler_networks(server_id)
return True
def quit(self):
self.clients_stop()
lat = self.map.osm.get_property("latitude")
lon = self.map.osm.get_property("longitude")
self.config["map"]["last_position"] = "%.6f/%.6f" % (lat, lon)
while None in self.config['kismet']['servers']:
self.config['kismet']['servers'].remove(None)
self.config_handler.write()
self.networks.save(self.networks_file, force=True)
def add_network_to_map(self, mac):
network = self.networks.get_network(mac)
try:
crypt = self.crypt_cache[network["cryptset"]]
except KeyError:
crypt = decode_cryptset(network["cryptset"], True)
self.crypt_cache[network["cryptset"]] = crypt
if "AES_CCM" in crypt or "AES_OCB" in crypt:
color = "red"
elif "WPA" in crypt:
color = "orange"
elif "WEP" in crypt:
color = "yellow"
else:
color = "green"
self.map.add_marker(mac, color, network["lat"], network["lon"])
class Controller:
"""
Online controller sending commands/controls to the simulation node
"""
def __init__(self):
"""
Load the irepa built estimator then create clients for simulation
and optimal control nodes
"""
self.estimator = Networks(NX,
NU,
x_range=np.array([X_MIN, X_MAX]),
u_range=np.array([U_MIN, U_MAX]))
self.estimator.load()
# Last state trajectory calculated
self.X = np.array([])
self.U = np.array([])
self.u = np.zeros(NU)
self.time = 0
self.current_state = np.zeros(NX)
self.end_state = np.zeros(NX)
# time from the start of the current trajectory in ns
self.t_idx = 0
# update trajectory every update_times iteration
self.update_times = int(CPS / TUPS)
self.ocp_client = actionlib.SimpleActionClient(OPT_CONTROL_SERVER,
OptControlAction)
self.ocp_client.wait_for_server()
self.pub = rospy.Publisher(COMMAND_TOPIC, Command, queue_size=10)
rospy.Subscriber(CURRENT_STATE_TOPIC, State, self.update_current_state)
rospy.Subscriber(END_STATE_TOPIC, State, self.update_end_state)
# test state rate
self.t1 = rospy.get_rostime()
self.t2 = rospy.get_rostime()
# control steps
self.stop_update = False
self.stop_controls = False
self.started = False
def next_control(self):
"""
Choose next control to send to the simulation.
"""
self.t_idx += 1
if euclid(self.current_state, self.end_state) < STOP_RADIUS:
self.stop_update = True
self.stop_controls = True
else:
self.stop_update = False
self.stop_controls = False
if self.stop_controls:
self.u = np.zeros(NU)
else:
if self.t_idx < self.U.shape[0]:
self.u = self.U[self.t_idx, :]
# print(' CONTROL:', self.u)
else:
if self.started:
print(' !! No more control --> previous')
self.pub.publish(self.u)
return self.u
def update_current_state(self, msg):
"""
Callback function for the simulation Subscriber for current state.
"""
# print('CURRENT STATE received:', msg.x)
self.current_state = np.array(msg.x)
def update_end_state(self, msg):
"""
Callback function for the simulation Subscriber for end state.
"""
# print('END STATE received:', msg.x)
self.end_state = np.array(msg.x)
def update_trajectory(self, state, resp):
"""
Callback function for the optimal control action server.
Once a control trajectory is received, it is resampled using trajectory
time so that the time difference between to consecutive controls is
at the CPS.
:param state: state of the action server (nothing to do with
the state of the system)
:param resp: response of the action server containing
- states: states trajectory
- controls: controls trajectory
- time: time length of the trajectory
"""
self.started = True # control started at the first result
if resp.success:
X = np.array(resp.states).reshape(len(resp.states) // NX, NX)
U = np.array(resp.controls).reshape(len(resp.controls) // NU, NU)
self.time = resp.time
# if resp.time < UPDATE_TIME_THRES:
# self.stop_update = True
dt_acado = self.time / (X.shape[0] - 1)
nb_control = int(resp.time * CPS) + 1
self.X = resample(X, nb_control)
self.U = resample(U, nb_control)
tend = time.time()
t_calc = (tend - self.tstart)
self.t_idx = int(t_calc * CPS) if SHIFT else 0
print()
print('RESULT TRAJECTORY')
print('UPDATE TOOK:', round(t_calc, 2))
print('TIME TRAJ: ', round(resp.time, 2))
print('Dt acado', dt_acado, 'nb_control', nb_control, 'SIZE X',
X.shape[0])
print(self.t_idx)
else:
print()
print('FAILURE OF CONTROL!!!!')
print()
def call_update_trajectory_action(self):
"""
Call ACADO warm started by the estimator. The result is handled by
update_trajectory function.
"""
self.tstart = time.time()
if ESTIMATOR_INIT:
Xe, Ue, Ve = self.estimator.trajectories(self.current_state,
self.end_state)
Xe = Xe.flatten()
Ue = Ue.flatten()
else:
Xe, Ue, Ve = [], [], 0
goal = OptControlGoal(list(self.current_state), list(self.end_state),
Xe, Ue, Ve, NX, NU)
self.ocp_client.send_goal(goal, self.update_trajectory)
def start_control(self):
"""
Start the control loop at rate CPS
"""
print('Control started')
rate = rospy.Rate(CPS)
i = 0
while not rospy.is_shutdown():
i += 1
if i % self.update_times == 0:
if not self.stop_update:
self.call_update_trajectory_action()
i = 0
self.next_control()
rate.sleep()
plt.rc('legend', **{'fontsize': 10})
OPT_CONTROL_SERVER = 'solve_ocp'
rospy.init_node('ocp_solve_client')
ocp_client = actionlib.SimpleActionClient(OPT_CONTROL_SERVER, OptControlAction)
ocp_client.wait_for_server()
rospy.loginfo('End of wait for rocket')
print('Creating NN')
estimator = Networks(NX,
NU,
x_range=np.array([X_MIN, X_MAX]),
u_range=np.array([U_MIN, U_MAX]))
estimator.load()
print('Weights loaded')
Xs = []
Vs = []
def callback(state, resp):
global Xs
global Vs
X = np.array(resp.states).reshape(len(resp.states) // NX, NX)
U = np.array(resp.controls).reshape(len(resp.controls) // NU, NU)
print()
print()
print(resp.success)
print('Path length:', len(resp.states) // NX)
