class WebSocket(util.Threadbase):
signals = 'message'
def __init__(self, ip, port):
global emitter
super(WebSocket, self).__init__()
emitter = self
port = int(port)
log.info('starting websocket on %s:%i' % (ip, port))
self.server = SimpleWebSocketServer(ip, port, WebsocketClient)
self.start()
def terminate(self):
log.debug('terminating websocket')
super().terminate()
self.server.close()
@staticmethod
def send_message(client, message_dict):
_json = json.dumps(message_dict)
for _client in clients:
if not client or _client.address[0] == client.address[0]:
_client.sendMessage(_json)
def run(self):
while not self.terminated:
self.server.serveonce()
log.debug('websocket exits')
class WebSocketServer(Thread):
def __init__(self, name, port):
Thread.__init__(self)
self.server = SimpleWebSocketServer(deviceIP, wsPort, HandleServer)
self._isClosed = False
mDNSinit()
BLINKER_LOG('websocket Server init')
BLINKER_LOG('ws://', deviceIP, ':', wsPort)
self.setDaemon(True)
def start(self):
super(WebSocketServer, self).start()
def run(self):
self.server.serveforever()
def stop(self):
self.server.close()
self._isClosed = True
def broadcast(self, msg):
if isinstance(msg, str):
msg = unicode(msg, "utf-8")
for client in clients:
client.sendMessage(msg)
while client.sendq:
opcode, payload = client.sendq.popleft()
remaining = client._sendBuffer(payload)
if remaining is not None:
client.sendq.appendleft((opcode, remaining))
break
class WebSockectLCDSimulator:
def __init__(self):
self.server = SimpleWebSocketServer('', 8000, WebSocketServer)
def on_start(self):
thread = Thread(target=self.runServer)
thread.start()
def runServer(self):
self.server.serveforever()
def message(self, message):
#TODO Find special characters and replace with others. For example Volume\x01 to u'Volume\u2600'
data = unicode(json.dumps({'jsonrpc': '2.0', 'method': 'message', 'params': message }))
global last_message
last_message = data
for client in clients:
client.sendMessage(data)
def create_char(self, location, pattern):
data = unicode(json.dumps({'jsonrpc': '2.0', 'method': 'create_char', 'params': {location: location, pattern: pattern}}))
for client in clients:
client.sendMessage(data)
def on_stop(self):
self.server.close()
def is_pressed(self, button):
if button not in set((InputManager.SELECT, InputManager.RIGHT, InputManager.DOWN, InputManager.UP, InputManager.LEFT)):
raise ValueError('Unknown button, must be SELECT, RIGHT, DOWN, UP, or LEFT.')
return pressed_keys[button]
class WebSocketServer(Thread):
def __init__(self, receiver=None):
Thread.__init__(self)
self.name = deviceIP
self.port = wsPort
self.server = SimpleWebSocketServer(self.name, self.port, HandleServer)
self._isClosed = False
self.setDaemon(True)
if receiver is not None:
receivers.append(receiver)
def start(self, name=deviceName):
mDNSinit('mediadisplay', name)
logging.info("[Server] starting tcp socket server")
super(WebSocketServer, self).start()
def run(self):
self.server.serveforever()
def stop(self):
self.server.close()
self._isClosed = True
def broadcast(self, msg):
if isinstance(msg, str):
msg = msg.encode('utf-8').decode("utf-8")
for client in clients:
client.sendMessage(msg)
while client.sendq:
opcode, payload = client.sendq.popleft()
remaining = client._sendBuffer(payload)
if remaining is not None:
client.sendq.appendleft((opcode, remaining))
break
class LogRecordSocketReceiver(SocketServer.ThreadingTCPServer):
allow_reuse_address = 1
def __init__(self, host='localhost',
port=logging.handlers.DEFAULT_TCP_LOGGING_PORT,
handler=LogRecordStreamHandler):
SocketServer.ThreadingTCPServer.__init__(self, (host, port), handler)
self.abort = 0
self.timeout = 1
self.logname = None
self.requstHandle = None
self.wsserver = SimpleWebSocketServer('', 8081, WebSocket)
def finish_request(self, request, client_address):
LogRecordStreamHandler(request, client_address, self, self.wsserver)
def cleanup(self):
self.wsserver.close()
def serve_until_stopped(self):
import select
abort = 0
while not abort:
self.wsserver.servconnman()
rd, wr, ex = select.select([self.socket.fileno()], [], [], self.timeout)
if rd:
self.handle_request()
abort = self.abort
class LogRecordSocketReceiver(SocketServer.ThreadingTCPServer):
allow_reuse_address = 1
def __init__(self,
host='localhost',
port=logging.handlers.DEFAULT_TCP_LOGGING_PORT,
handler=LogRecordStreamHandler):
SocketServer.ThreadingTCPServer.__init__(self, (host, port), handler)
self.abort = 0
self.timeout = 1
self.logname = None
self.requstHandle = None
self.wsserver = SimpleWebSocketServer('', BASE_WS_PORT, WebSocket)
def finish_request(self, request, client_address):
LogRecordStreamHandler(request, client_address, self, self.wsserver)
def cleanup(self):
self.wsserver.close()
def serve_until_stopped(self):
import select
abort = 0
while not abort:
self.wsserver.servconnman()
rd, wr, ex = select.select([self.socket.fileno()], [], [],
self.timeout)
if rd:
self.handle_request()
abort = self.abort
class TMoohIWebsocketServer:
def __init__(self, logger, host, port, defaultfilter=[]):
global websocketServer
if websocketServer != None:
raise AlreadyDefinedError("Websocket server already created.")
websocketServer = self
self.logger = logger
self.host = host
self.port = port
self.defaultfilter = defaultfilter
self.killing = False
self.clients = []
self.logger.info(
MoohLog.eventmessage(
"websocket", "WebSocketServer loading up on %s:%s!" %
(self.host, self.port)))
self.server = SimpleWebSocketServer(self.host, self.port,
websocketlogger)
self.serverthread = threading.Thread(target=self.runserver)
self.serverthread.start()
self.neweststatus = {}
def quit(self):
self.killing = True
self.logger.info(
MoohLog.eventmessage("websocket",
"WebSocketServer shutting down!"))
self.server.close()
def runserver(self):
while not self.killing:
try:
self.logger.info(
MoohLog.eventmessage("websocket",
"WebSocketServer starting!"))
self.server.serveforever()
except (KeyboardInterrupt):
self.killing = True
except OSError:
if not self.killing: # swallow errors when closing
self.logger.exception()
except Exception:
self.logger.exception()
finally:
self.logger.info(
MoohLog.eventmessage("websocket",
"WebSocketServer shut down!"))
try:
self.server.close()
except OSError:
pass # swallow "An operation was attempted on something that is not a socket" errors
class socketServerThread(threading.Thread): def __init__(self, host, port, socketQueue): threading.Thread.__init__(self) self.cls = socketServer self.socketQueue = socketQueue self.server = SimpleWebSocketServer(host, port, self.socketQueue, self.cls) def run(self): print "starting Server" self.server.serveforever() def exit(self): print "stoping Server" self.server.close()
class Server(Thread):
def run(self):
"""Starts the thread for the Web Socket Server"""
host = ""
port = 8008
self.server = SimpleWebSocketServer(host, port, Logger)
print("serving")
self.server.serveforever()
def close_sig_handler(self, signal, frame):
"""Function called upon Ctrl+C that kills the program"""
print("closing")
self.server.close()
class WebSocketInput:
def __init__(self, port=DEFAULT_PORT):
self.port = port
self.wss = None
def run(self):
print "Starting server on localhost:%d" % self.port
self.wss = SimpleWebSocketServer('', self.port, BuzzSocket)
try:
self.wss.serveforever()
except:
print "Buzzws server killed or crashed. Bye!"
def stop(self):
self.wss.close()
class BroadcasterWebsocketServer(Thread):
def __init__(self, host, port, debugInfo=False):
Thread.__init__(self)
self.server = SimpleWebSocketServer(host, port,
WebsocketBroadcasterHandler)
self._isClosed = False
global debug
debug = debugInfo
self.setDaemon(True)
def start(self):
super(BroadcasterWebsocketServer, self).start()
def run(self):
if debug:
print('starting server')
self.server.serveforever()
def stop(self):
if debug:
print('closing server')
self.server.close()
self._isClosed = True
def waitForIt(self):
try:
while self._isClosed is False:
sleep(0.1)
except KeyboardInterrupt:
pass
def broadcast(self, msg):
print("###################")
for client in clients:
client.sendMessage(msg)
while client.sendq:
opcode, payload = client.sendq.popleft()
remaining = client._sendBuffer(payload)
if remaining is not None:
client.sendq.appendleft((opcode, remaining))
break
def serverMessage(self, msg):
for client in clients:
client.sendMessage(msg)
def getMessage(self):
return command
class WebSocketServer(Thread):
# def __init__(self, name, port, type = BLINKER_DIY_WIFI):
def __init__(self, type=BLINKER_DIY_WIFI):
Thread.__init__(self)
self.name = deviceIP
self.port = wsPort
self.type = type
self.server = SimpleWebSocketServer(self.name, self.port, HandleServer)
self._isClosed = False
self.setDaemon(True)
def start(self, name=deviceName):
mDNSinit(self.type, name)
BLINKER_LOG('websocket Server init')
BLINKER_LOG('ws://', self.name, ':', self.port)
super(WebSocketServer, self).start()
def run(self):
self.server.serveforever()
def stop(self):
self.server.close()
self._isClosed = True
def broadcast(self, msg):
msg = json.dumps(msg)
# if isDebugAll() is True:
BLINKER_LOG_ALL('Response data: ', msg)
if len(clients) == 0:
wsProto.state = DISCONNECTED
# if isDebugAll() is True:
BLINKER_ERR_LOG_ALL('Faile... Disconnected')
return
# if isDebugAll() is True:
BLINKER_LOG_ALL('Succese...')
if isinstance(msg, str):
msg = msg.encode('utf-8').decode("utf-8")
for client in clients:
client.sendMessage(msg)
while client.sendq:
opcode, payload = client.sendq.popleft()
remaining = client._sendBuffer(payload)
if remaining is not None:
client.sendq.appendleft((opcode, remaining))
break
class VizWebsocketServer(Thread):
def __init__(self, cpstw, port=8000):
Thread.__init__(self)
self.cpstw = cpstw
self._websocketd = None
self._port = port
self.stop_event = threading.Event()
def run(self):
self._websocketd = SimpleWebSocketServer(
'', self._port, get_viz_websocket_handler(self.cpstw))
while not self.stop_event.is_set():
self._websocketd.serveonce()
self._websocketd.close()
def stop(self):
logger.info("Stopping VizWebsocketServer now!")
self.stop_event.set()
class WebsocketHandler:
def __init__(self, port=5678):
logging.info("Creating " + str(self.__class__.__name__) + " object")
self.__port = port
websocket_class = DataBroadcast # the websocket class we're going to use
self.__websocket_server_obj = SimpleWebSocketServer(
'', port, websocket_class)
self.__websocket_server_thread = threading.Thread(
target=self.start_websocket_server,
args=([self.__websocket_server_obj]))
self.__websocket_server_thread.daemon = True
self.__websocket_server_thread.start()
signal.signal(
signal.SIGINT, self.close_sig_handler
) # This just makes sure that the sockets are closed tidily on program exit
def broadcast(self, metric, value, level, timestamp):
message = self.format_message_for_sending(metric, value, level,
timestamp)
connected_clients = self.__websocket_server_obj.connections.values()
if len(connected_clients):
logging.debug("Sending '" + str(message) + "' to " +
str(len(connected_clients)) + " connected clients")
for client in connected_clients:
client.sendMessage(message)
def format_message_for_sending(self, metric, value, level, timestamp):
message = {
'timestamp': timestamp,
'metric': metric,
'value': value,
'level': level
}
return json.dumps(message)
def close_sig_handler(self, signal, frame):
self.__websocket_server_obj.close()
sys.exit()
def start_websocket_server(self, server):
logging.info("Starting websocket server on port " + str(self.__port))
server.serveforever()
class WebViewer(Viewer):
def __init__(self):
self.running = False
self.host_address = ''
self.port = 8500
self.server = SimpleWebSocketServer(self.host_address, self.port, SimpleMessager)
self.game = None
def init_viewer(self, board, game=None):
self.board = board
if not self.game:
self.game = game
self.server.game = self.game
if game:
if type(self.game.agents[0]) == WebViewer and type(self.game.agents[1]) == WebViewer:
self.server.configuration = CONFIG_HvH
elif type(self.game.agents[0]) == WebViewer and type(self.game.agents[1]) != WebViewer:
self.server.configuration = CONFIG_HvA
elif type(self.game.agents[0]) != WebViewer and type(self.game.agents[1]) == WebViewer:
self.server.configuration = CONFIG_AvH
elif type(self.game.agents[0]) != WebViewer and type(self.game.agents[1]) != WebViewer:
self.server.configuration = CONFIG_AvA
else:
self.server.configuration = CONFIG_R
if not connectedEvent.is_set():
self.serverThread = threading.Thread(target=self.server.serveforever)
self.serverThread.start()
connectedEvent.wait()
def run(self):
"""Launch the GUI."""
if self.running:
return
self.running = True
#self.server.serveforever()
def replay(self, trace, speed, show_end=False):
"""Replay a game given its saved trace.
Attributes:
trace -- trace of the game
speed -- speed scale of the replay
show_end -- start with the final state instead of the initial state
"""
self.trace = trace
self.speed = speed
# generate all boards to access them backwards
self.boards = [trace.get_initial_board()]
for step in range(len(trace.actions)):
player, action, t = trace.actions[step]
b = self.boards[-1].clone()
b.play_action(action)
self.boards.append(b)
self.step = 0
self.server.initialize_replay(self.trace, self.speed, self.boards)
self.init_viewer(self.boards[0], None)
def close_sig_handler(signal, frame):
self.server.close()
sys.exit()
def playing(self, step, player):
print("Step", step, "- Player", player, "is playing")
def update(self, step, action, player):
print("Step", step, "- Player", player, "has played", action)
acknowledgementEvent.clear()
self.server.update(step, action, player)
acknowledgementEvent.wait()
def play(self, percepts, player, step, time_left):
try:
hasPlayedEvent.clear()
self.server.play(percepts, player, step, time_left)
hasPlayedEvent.wait()
except EOFError:
exit(1)
try:
return lastActionPlayed
except (ValueError, AssertionError):
pass
def finished(self, steps, winner, reason=""):
if winner == 0:
print("Draw game")
else:
print("Player 1" if winner > 0 else "Player 2", "has won!")
if reason:
print("Reason:", reason)
self.server.initialize_replay(self.game.trace, 1.0, [])
self.server.finished(steps, winner, reason)
signal.signal(signal.SIGINT, close_sig_handler)
signal.signal(signal.SIGTERM, close_sig_handler)
class WebViewer(Viewer):
def __init__(self):
self.running = False
self.host_address = ''
self.port = 8500
self.server = SimpleWebSocketServer(self.host_address, self.port, SimpleMessager)
self.game = None
def init_viewer(self, board, game=None):
self.board = board
if not self.game:
self.game = game
self.server.game = self.game
if game:
if type(self.game.agents[0]) == WebViewer and type(self.game.agents[1]) == WebViewer:
self.server.configuration = CONFIG_HvH
elif type(self.game.agents[0]) == WebViewer and type(self.game.agents[1]) != WebViewer:
self.server.configuration = CONFIG_HvA
elif type(self.game.agents[0]) != WebViewer and type(self.game.agents[1]) == WebViewer:
self.server.configuration = CONFIG_AvH
elif type(self.game.agents[0]) != WebViewer and type(self.game.agents[1]) != WebViewer:
self.server.configuration = CONFIG_AvA
else:
self.server.configuration = CONFIG_R
if not connectedEvent.is_set():
self.serverThread = threading.Thread(target=self.server.serveforever)
self.serverThread.start()
connectedEvent.wait()
def run(self):
"""Launch the GUI."""
if self.running:
return
self.running = True
#self.server.serveforever()
def replay(self, trace, speed, show_end=False):
"""Replay a game given its saved trace.
Attributes:
trace -- trace of the game
speed -- speed scale of the replay
show_end -- start with the final state instead of the initial state
"""
self.trace = trace
self.speed = speed
# generate all boards to access them backwards
self.boards = [trace.get_initial_board()]
for step in range(len(trace.actions)):
player, action, t = trace.actions[step]
b = self.boards[-1].clone()
b.play_action(action)
self.boards.append(b)
self.step = 0
self.server.initialize_replay(self.trace, self.speed, self.boards)
self.init_viewer(self.boards[0], None)
def close_sig_handler(signal, frame):
self.server.close()
sys.exit()
def playing(self, step, player):
print("Step", step, "- Player", player, "is playing")
def update(self, step, action, player):
print("Step", step, "- Player", player, "has played", action)
acknowledgementEvent.clear()
self.server.update(step, action, player)
acknowledgementEvent.wait()
def play(self, percepts, player, step, time_left):
try:
hasPlayedEvent.clear()
self.server.play(percepts, player, step, time_left)
hasPlayedEvent.wait()
except EOFError:
exit(1)
try:
return lastActionPlayed
except (ValueError, AssertionError):
pass
def finished(self, steps, winner, reason=""):
if winner == 0:
print("Draw game")
else:
print("Player 1" if winner > 0 else "Player 2", "has won!")
if reason:
print("Reason:", reason)
self.server.initialize_replay(self.game.trace, 1.0, [])
self.server.finished(steps, winner, reason)
signal.signal(signal.SIGINT, close_sig_handler)
signal.signal(signal.SIGTERM, close_sig_handler)
class Server_GUI:
class WebSocket_GUI(WebSocket):
def handleMessage(self):
mode = self.data[:1]
message = self.data[1:]
if (mode == '0'): # PLAY
obj_Music.play_pause()
elif (mode == '1'): # STOP
obj_Music.stop()
elif (mode == '2'): # PREVIOUS
obj_Playlist.prev()
elif (mode == '3'): # NEXT
obj_Playlist.button_next()
elif (mode == '4'): # VOLUME
obj_Music.set_volume(float(message))
elif (mode == '5'): # PLAY INDEX
obj_Playlist.play_index(int(message))
elif (mode == '6'): # SEEK
obj_Music.seek(float(message))
elif (mode == '7'): # MUTE
obj_Music.mute_toggle()
elif (mode == '8'): # PLAYLIST CYCLE MODE
obj_Playlist.change_mode()
def handleConnected(self):
print self.address, 'connected'
Server_GUI.update_all(self);
def handleClose(self): print self.address, 'closed'
def __init__(self):
self.server = SimpleWebSocketServer('0.0.0.0', 8000, self.WebSocket_GUI)
signal.signal(signal.SIGINT, self.close_sig_handler)
logging.basicConfig(format='%(asctime)s %(message)s', level=logging.DEBUG)
thread.start_new_thread(self.thread_main,())
thread.start_new_thread(self.thread_change,())
print "Server open!"
@staticmethod
def string_playing(): return '"playing":' + str(obj_Music.get_playing()).lower() + ','
@staticmethod
def string_index(): return '"index":' + str(obj_Playlist.index).lower() + ','
@staticmethod
def string_files():
string = '"files":['
for title in obj_Playlist.array_titles:
string += '"' + title + '",'
return string[:-1] + '],'
@staticmethod
def string_length():
string = '"lengths":['
for length in obj_Playlist.array_length:
string += str(length) + ','
return string[:-1] + '],'
@staticmethod
def string_position(): return '"time":' + str(obj_Music.get_time()) + ','
@staticmethod
def string_volume(): return '"volume":' + str(obj_Music.get_volume()) + ','
@staticmethod
def string_mute(): return '"mute":' + str(obj_Music.mute).lower() + ','
@staticmethod
def string_mode(): return '"mode":' + str(obj_Playlist.mode) + ','
@staticmethod
def string_cycles():
string = '"cycles":["'
for x in obj_Playlist.array_cycles:
string += x + '","'
return (string[:-2] + '],').replace("\r", "\n").replace("\n\n", "\n").replace("\n", "\\n")
@staticmethod
def string_cycles_index():
string = '"cycles_index":['
for x in obj_Playlist.array_cycles_index:
string += str(x) + ','
return string[:-1] + '],'
def send_to_all(self, string):
for conn in self.server.connections.itervalues():
conn.sendMessage(string)
def thread_main(self):
self.server.serveforever()
@staticmethod
def update_all(client):
client.sendMessage("0{" + Server_GUI.string_cycles_index() + Server_GUI.string_cycles() + Server_GUI.string_mode() + Server_GUI.string_mute() + Server_GUI.string_volume() + Server_GUI.string_position() + Server_GUI.string_length() + Server_GUI.string_index() + Server_GUI.string_files() + Server_GUI.string_playing()[:-1] + "}")
def thread_change(self):
global running
array_prev = [None for x in range(6)]
array_current = [
obj_Music.get_playing,
(lambda: obj_Playlist.index),
obj_Music.get_time,
obj_Music.get_volume,
(lambda: obj_Music.mute),
(lambda: obj_Playlist.mode)
]
array_id = [
'2',
'3',
'5',
'6',
'7',
'8'
]
array_function = [
self.string_playing,
self.string_index,
self.string_position,
self.string_volume,
self.string_mute,
self.string_mode
]
while running:
for i in range(len(array_current)):
if (array_prev[i] != array_current[i]()):
self.send_to_all(array_id[i] + "{" + array_function[i]()[:-1] + "}")
array_prev[i] = array_current[i]()
time.sleep(1.0/15.0)
def close_sig_handler(self, signal, frame):
self.server.close()
class EventHandler:
def __init__(self):
self.__version__ = '3.1.3'
logger_format = '%(asctime)s %(message)s'
logging.basicConfig(format=logger_format, level=logging.INFO,
datefmt="%H:%M:%S", filename='./logfile.log', filemode='w')
logging.getLogger().addHandler(SysLogHandler(facility=SysLogHandler.LOG_DAEMON, address='/dev/log'))
self._SIGKILL = False
self.logging = logging
self.config = DB('./config.json')
self.network = Network(self)
self.display = DisplayContent()
self.detector = Detector()
self.ultrasound = Ultrasound(self)
self.temp = Temp()
self.server = SimpleWebSocketServer('', 8069, WebSocketServer, self)
self.cook = Cook(self)
self.energy = Energy(self)
self.history = History(self)
self.audio = Audio(self)
self.users = Users(self)
self.automations = Automations(self)
signal.signal(signal.SIGTERM, self.sig_handler)
signal.signal(signal.SIGINT, self.sig_handler)
self.log("Boot: v" + self.__version__)
def log(self, msg):
self.logging.info(msg)
def err(self, msg):
self.logging.error(msg)
self.logging.error(exc_info()[-1].tb_lineno)
def sig_handler(self, _, _2):
self._SIGKILL = True
self.server.close()
exit()
def poweroff(self):
system('sudo shutdown -h now')
async def startWebsocket(self):
while not self._SIGKILL:
self.server.serveonce()
def dispatchWorker(self, fn, *args):
return asyncio.run(fn(*args))
async def startDetectionLoop(self):
try:
while not self._SIGKILL:
networkStatus = await self.network.get()
if networkStatus == 'connected':
break
self.display.network("Automated Oven" if networkStatus == 'hostapd' else "Connecting")
await asyncio.sleep(0.5)
self.log("Network: Connected")
await self.dispatch([
[self.display.text, "Place The Item"],
[self.cook.init]
])
while not self._SIGKILL:
await self.temp.update()
if not self.cook.isCooking and await self.config.get('autoDetect'):
dist = await self.ultrasound.get()
if dist < await self.config.get('sensitivity')*0.17:
tasks = await self.dispatch([
[self.display.loading],
[self.detector.detect],
])
res = tasks[1].result()
self.log("Detection: " + res)
await self.cook.startFromDB(res)
else:
await asyncio.sleep(await self.config.get('responsiveness')*0.003)
else:
await asyncio.sleep(await self.config.get('responsiveness')*0.01)
except Exception as e:
self.err(e)
async def dispatch(self, arrayOfDispatches):
arrayOfFutures = []
with cf.ThreadPoolExecutor(max_workers=4) as executor:
loop = asyncio.get_running_loop()
for d in arrayOfDispatches:
arrayOfFutures.append(loop.run_in_executor(
executor, self.dispatchWorker, *d))
await asyncio.gather(*arrayOfFutures)
return arrayOfFutures
async def init(self):
await self.dispatch([
[self.display.init, self]
])
await self.dispatch([
[self.display.loading],
[self.detector.init, self],
[self.detector.load_model]
])
out = StringIO.StringIO()
sys.stdout = out
sys.stderr = out
join_client_room(self, room)
sys.stdout = sys.__stdout__
sys.stderr = sys.__stderr__
for client in rooms[room]:
if client != self:
client.sendMessage(out.getvalue().strip('\n'))
else:
join_client_room(self, room)
else:
clients[self.address] = None
def handleClose(self):
room = clients.pop(self.address)
if room:
rooms[room].remove(self)
if not rooms[room]:
rooms.pop(room)
logger.info('%s disconnected', self.address)
server = SimpleWebSocketServer('0.0.0.0', 8008, SimpleChat)
try:
server.serveforever()
except KeyboardInterrupt:
server.close()
logger.info('Killed')
class qiraplugin_t(idaapi.plugin_t):
flags = 0
comment = "QEMU Interactive Runtime Analyser plugin"
help = "Visit qira.me for more infos"
wanted_name = "QIRA Plugin"
wanted_hotkey = "Alt-F5"
def __init__(self):
self.max_comment_len = 100
self.qira_address = idc.BADADDR
self.wsserver = None
self.old_addr = None
self.port = 3003
self.addr = None
self.cmd = None
def init(self):
ret = self.start()
idaapi.msg("[%s] Initialized: Ready to go!\n" % (self.comment,))
return ret
def start(self):
# if __name__ == '__main__':
server = Thread(target=self.ws_server, args=(3003,))
try:
server.start()
return idaapi.PLUGIN_KEEP
except AttributeError:
return idaapi.PLUGIN_SKIP
def ws_server(self, port):
if port is None:
port = self.port
host = ''
self.wsserver = SimpleWebSocketServer(host, port, QiraServer, selectInterval=0.1)
if self.wsserver is not None:
idaapi.msg("[%s] Starting WS Server\n" % (self.comment,))
self.wsserver.serveforever()
else:
idaapi.msg("[%s] Cannot Start WS Server\n" % (self.comment,))
def ws_send(self, msg):
if self.wsserver is not None:
self.start()
if msg is not None:
if msg == 'connected':
for conn in list(CLIENTS):
conn.sendMessage(msg)
time.sleep(1)
CLIENTS.append(self)
elif msg == 'closed':
CLIENTS.remove(self)
for conn in list(CLIENTS):
conn.sendMessage(msg)
time.sleep(1)
else:
# print "Tuple: %s" % (self.wsserver.connections.items(),)
# This one still have errors in both items()/CLIENTS
for conn in list(self.wsserver.connections.items()):
if conn != self:
# debugging
if DEBUG:
idaapi.msg("[%s] ws_send : %s\n" % (self.wanted_name, msg,))
conn.sendMessage(msg)
time.sleep(0.1)
else:
idaapi.msg("[%s] ws_send : Cannot send null\n" % (self.comment,))
def set_qira_address(self, sea):
# Check if there is a BreakPoint and delete is before processing.
if (self.qira_address is not None) and (
self.qira_address != idc.BADADDR):
qea = idaapi.toEA(0, self.qira_address)
if idc.CheckBpt(qea) != -1:
idaapi.del_bpt(qea)
# Update qira_address and set BreakPont.
self.qira_address = sea
idaapi.add_bpt(self.qira_address, 0, idaapi.BPT_SOFT)
idc.EnableBpt(self.qira_address, False)
# debugging
if DEBUG:
idaapi.msg(
"[%s] set_qira_address: 0x%x\n" %
(self.wanted_name, self.qira_address,))
def send_names(self):
qira_names = idaapi.get_nlist_size()
for i in range(0, qira_names):
self.cmd = "setname 0x%x %s" % (
idaapi.get_nlist_ea(i), idaapi.get_nlist_name(i))
# debugging
if DEBUG:
idaapi.msg(
"[%s] send_names: EA [0x%x], Name [%s]\n" %
(self.wanted_name, idaapi.get_nlist_ea(i),
idaapi.get_nlist_name(i),))
self.ws_send(self.cmd)
def send_comments(self):
start = idaapi.get_segm_base(idaapi.get_first_seg())
cur = start
while True:
if cur != idc.BADADDR:
cmt = idaapi.get_cmt(cur, 0)
if (cmt is not None) and (cmt != idc.BADADDR):
self.cmd = "setcmt 0x%x %s" % (cur, cmt)
# debugging
if DEBUG:
idaapi.msg(
"[%s] send_comments: EA [0x%x], Comment [%s]\n" %
(self.wanted_name, cur, cmt,))
self.ws_send(self.cmd)
else:
break
cur = idc.NextAddr(cur)
return True
def update_address(self, addr_type, addr):
if (addr_type is not None) and (addr is not None):
self.cmd = "set%s 0x%x" % (addr_type, addr)
self.ws_send(self.cmd)
else:
idaapi.msg(
"[%s] Cannot update address: 'None'\n" %
(self.wanted_name,))
def jump_to(self, qea):
if qea is not None:
if (qea != self.qira_address) and (qea != idc.BADADDR):
self.set_qira_address(qea)
idaapi.jumpto(self.qira_address, -1, 0x0001)
else:
idaapi.jumpto(self.qira_address, -1, 0x0001)
# debugging
if DEBUG:
idaapi.msg(
"[%s] jump_to: qira_address [0x%x], ea [0x%x]\n" %
(self.wanted_name, self.qira_address, qea,))
else:
idaapi.msg("[%s] Cannot jump_to: None\n")
def run(self, arg):
idaapi.msg("[%s] Syncing with WS Server\n" % (self.wanted_name,))
self.addr = idaapi.get_screen_ea()
if self.old_addr != self.addr:
# check against idc.BADADDR and None before going
if (self.addr is not None) and (self.addr != idc.BADADDR):
# Code Address
if idaapi.isCode(idaapi.getFlags(self.addr)):
# don't set the address if it's already the qira_address
if self.addr != self.qira_address:
# debugging
if DEBUG:
idaapi.msg(
"[%s] Qira Address 0x%x \n" %
(self.wanted_name, self.addr,))
# Instruction Address
self.set_qira_address(self.addr)
self.update_address("iaddr", self.addr)
# Data Address
elif idaapi.isData(idaapi.getFlags(self.addr)):
self.update_address("daddr", self.addr)
# Tail Address
elif idaapi.isTail(idaapi.getFlags(self.addr)):
self.update_address("taddr", self.addr)
# Unknown Address
elif idaapi.isUnknown(idaapi.getFlags(self.addr)):
self.update_address("uaddr", self.addr)
# Head Address
elif idaapi.isHead(idaapi.getFlags(self.addr)):
self.update_address("haddr", self.addr)
# Flow Address
elif idaapi.isFlow(idaapi.getFlags(self.addr)):
self.update_address("faddr", self.addr)
# Var Address
elif idaapi.isVar(idaapi.getFlags(self.addr)):
self.update_address("vaddr", self.addr)
# Data Address
else:
self.update_address("daddr", self.addr)
self.old_addr = self.addr
def stop(self):
if self.wsserver is not None:
self.wsserver.close()
self.wsserver = None
else:
idaapi.msg("[%s] is not running.\n" % (self.wanted_name,))
def term(self):
idaapi.msg("[%s] Terminating tasks...\n" % (self.wanted_name,))
try:
self.stop()
except AttributeError:
pass
idaapi.msg("[%s] Uninstalled!\n" % (self.wanted_name,))
