def WSReader(reader, writer):
webkey = None
while 1:
l = yield from reader.readline()
#print(l)
if not l:
raise ValueError()
if l == b"\r\n":
break
if l.startswith(b'Sec-WebSocket-Key'):
webkey = l.split(b":", 1)[1]
webkey = webkey.strip()
if not webkey:
raise ValueError("Not a websocker request")
respkey = make_respkey(webkey)
await writer.awrite(b"""\
HTTP/1.1 101 Switching Protocols\r
Upgrade: websocket\r
Connection: Upgrade\r
Sec-WebSocket-Accept: """)
await writer.awrite(respkey)
await writer.awrite("\r\n\r\n")
#print("Finished webrepl handshake")
ws = websocket.websocket(reader.ios)
rws = uasyncio.StreamReader(reader.ios, ws)
return rws
def accept_conn(listen_sock):
global client_s, key, cert, websslrepl
cl, remote_addr = listen_sock.accept()
prev = uos.dupterm(None)
uos.dupterm(prev)
if prev:
print("\nConcurrent WebREPL connection from", remote_addr, "rejected")
cl.close()
return
print("\nWebREPL connection from:", remote_addr)
client_s = cl
if websslrepl:
if hasattr(uos, 'dupterm_notify'):
cl.setsockopt(socket.SOL_SOCKET, 20, uos.dupterm_notify)
cl = ssl.wrap_socket(cl, server_side=True, key=key, cert=cert)
wss_helper.server_handshake(cl, ssl=True)
else:
websocket_helper.server_handshake(cl)
ws = uwebsocket.websocket(cl, True)
ws = _webrepl._webrepl(ws)
cl.setblocking(False)
# notify REPL on socket incoming data (ESP32/ESP8266-only)
if not websslrepl:
if hasattr(uos, 'dupterm_notify'):
cl.setsockopt(socket.SOL_SOCKET, 20, uos.dupterm_notify)
uos.dupterm(ws)
def input(request):
global _active_input_conn
global _input_callback_timer
if _active_input_conn is not None:
_active_input_conn.close()
conn = request.connection
_active_input_conn = conn
websocket_server_handshake(request)
ws = websocket(conn, True)
def callback(timer):
updated, inputs = read_inputs()
# TODO
# Make only-send-on-updated dependent on whether the game server is
# acting as an access point. In station mode, always sending regardless
# of updated state seems to result in more consistent latency - I
# suspect because the router sees it as a squeaky data wheel, and
# thusly greases it.
try:
ws.write(json.dumps(inputs))
except:
conn.close()
timer.deinit()
return None
timer.init(period=20, mode=Timer.ONE_SHOT, callback=callback)
gc.collect()
callback(Timer(-1))
def accept_client(self, s):
cl, cl_info = s.accept()
if self.client_socket and (utime.time() - self.last_recv) < 10:
cl.close()
else:
self.close_client()
self.client_socket = cl
websocket_helper.server_handshake(cl)
self.client = websocket.websocket(cl, True)
cl.setblocking(False)
cl.setsockopt(socket.SOL_SOCKET, 20, self.recv_client)
def __init__(self, addr, s, close_callback):
self.client_close = False
self._need_check = False
self.address = addr
self.socket = s
self.ws = websocket(s, True)
self.poll = uselect.poll()
self.close_callback = close_callback
self.socket.setblocking(False)
self.poll.register(self.socket, uselect.POLLIN)
def accept_conn(listen_sock):
global client_s
cl, remote_addr = listen_sock.accept()
prev = uos.dupterm(None)
uos.dupterm(prev)
if prev:
print("\nConcurrent WebREPL connection from", remote_addr, "rejected")
cl.close()
return
print("\nWebREPL connection from:", remote_addr)
client_s = cl
websocket_helper.server_handshake(cl)
ws = uwebsocket.websocket(cl, True)
ws = _webrepl._webrepl(ws)
cl.setblocking(False)
# notify REPL on socket incoming data
cl.setsockopt(socket.SOL_SOCKET, 20, uos.dupterm_notify)
uos.dupterm(ws)
def _accept_handler(self, sock):
(client_sock, client_addr) = sock.accept()
callback = self.do_accept(client_addr)
if callback is None: # connection is rejected
client_sock.close()
return
# Use the web REPL socket stuff to handle the connection
websocket_helper.server_handshake(client_sock)
websock = uwebsocket.websocket(client_sock, True) # Blocking writes
webreplsock = _webrepl._webrepl(websock)
client_sock.setblocking(False)
# Create a WSReader to read characters one by one and process lines
websock_reader = WSReader(webreplsock, self, callback)
# Update the list of connected clients
self._clients.append((client_addr, websock_reader))
# Let the WSReader callback handle incoming data
client_sock.setsockopt(socket.SOL_SOCKET, 20,
websock_reader._client_cbk)
def acceptConn(self, listenSock):
cl, remote_addr = self.listenSock.accept()
print("\nOtto WS connection from:", remote_addr)
if self.clientSock is not None:
try:
self.webSock.close()
self.clientSock.close()
except:
pass
self.webSock = None
self.clientSock = None
self.clientSock = cl
websocket_helper.server_handshake(self.clientSock)
self.webSock = uwebsocket.websocket(self.clientSock, True)
self.clientSock.setblocking(False)
self.clientSock.setsockopt(socket.SOL_SOCKET, 20, self.wsRemoteCommand)
def accept_conn(listen_sock):
global client_s
cl, remote_addr = listen_sock.accept()
prev = uos.dupterm(None)
uos.dupterm(prev)
if prev:
print("\nConcurrent WebREPL connection from", remote_addr, "rejected")
cl.close()
return
print("\nWebREPL connection from:", remote_addr)
client_s = cl
websocket_helper.server_handshake(cl)
ws = uwebsocket.websocket(cl, True)
ws = _webrepl._webrepl(ws)
cl.setblocking(False)
# notify REPL on socket incoming data
cl.setsockopt(socket.SOL_SOCKET, 20, uos.dupterm_notify)
uos.dupterm(ws)
def accept_conn(listen_sock):
global client_s
cl, remote_addr = listen_sock.accept()
print(accept_conn) # 这里接受链接，并清理旧的 repl 输出
#prev = uos.dupterm(None)
#uos.dupterm(prev)
#print(uos.dupterm(prev))
if prev:
print("\nConcurrent WebREPL connection from", remote_addr, "rejected")
cl.close()
return
print("\nWebREPL connection from:", remote_addr)
client_s = cl
websocket_helper.server_handshake(cl)
ws = uwebsocket.websocket(cl, True)
ws = _webrepl._webrepl(ws) # 提升 socket 到 websocket
cl.setblocking(False)
# notify REPL on socket incoming data (ESP32/ESP8266-only)
if hasattr(uos, "dupterm_notify"):
cl.setsockopt(socket.SOL_SOCKET, 20, uos.dupterm_notify)
def accept_conn(listen_sock):
global client_s
cl, remote_addr = listen_sock.accept()
print("\nWebREPL connection from:", remote_addr)
client_s = cl
websocket_helper.server_handshake(cl)
ws = uwebsocket.websocket(cl, True)
ws = _webrepl._webrepl(ws)
cl.setblocking(False)
# attach new
prev = uos.dupterm(ws)
# notify REPL on socket incoming data (ESP32/ESP8266-only)
if hasattr(uos, "dupterm_notify"):
cl.setsockopt(socket.SOL_SOCKET, 20, uos.dupterm_notify)
# last: close old, in case it errors out
if prev:
prev.close()
def main(passwd, remote, op, dst_file=None, src_file=None):
if op == "get":
host, port, src_file = parse_remote(remote)
if os.path.isdir(dst_file):
basename = src_file.rsplit("/", 1)[-1]
dst_file += "/" + basename
else:
host, port, dst_file = parse_remote(remote)
if dst_file[-1] == "/":
basename = src_file.rsplit("/", 1)[-1]
dst_file += basename
if True:
print("op:%s, host:%s, port:%d, passwd:%s." % (op, host, port, passwd))
print(src_file, "->", dst_file)
s = socket.socket()
ai = socket.getaddrinfo(host, port)
addr = ai[0][4]
s.connect(addr)
websocket_helper.client_handshake(s)
ws = websocket(s)
login(ws, passwd)
print("Remote WebREPL version:", get_ver(ws))
# Set websocket to send data marked as "binary"
ws.ioctl(9, 2)
if op == "get":
get_file(ws, dst_file, src_file)
elif op == "put":
put_file(ws, src_file, dst_file)
s.close()
def accept_conn(listen_s):
"""Accept socket connection & transform to WS
Acceptes connection, makes it a WS and
sets ws_inc_handler as the msg handler for the connection
Arguments:
listen_s {socket} -- The socket that is listened
for connections on
Returns:
websocket -- The websocket connection
"""
connection, remote_addr = listen_s.accept()
print(remote_addr)
websocket_helper.server_handshake(connection)
print("Connection: ", connection)
global ws
ws = uwebsocket.websocket(connection, True)
connection.setblocking(False)
connection.setsockopt(socket.SOL_SOCKET, 20, ws_inc_handler)
return ws
def WSReader(reader, writer):
webkey = None
while 1:
l = yield from reader.readline()
print(l) # TODO(mj) remove this cmnt
if not l:
raise ValueError()
if l == b"\r\n":
break
if l.startswith(b'Sec-WebSocket-Key'):
webkey = l.split(b":", 1)[1]
webkey = webkey.strip()
if not webkey:
raise ValueError("Not a websocker request")
respkey = make_respkey(webkey)
await writer.awrite(b"""\
HTTP/1.1 101 Switching Protocols\r
Upgrade: websocket\r
Connection: Upgrade\r
Sec-WebSocket-Accept: """)
await writer.awrite(respkey)
# This will lead to "<key>\n\r\n" being written. Not exactly
# "\r\n\r\n", but browsers seem to eat it.
await writer.awrite("\r\n")
#await writer.awrite("\r\n\r\n")
print("Finished webrepl handshake")
ws = websocket.websocket(reader.ios)
rws = uasyncio.StreamReader(reader.ios, ws)
return rws
def main():
if len(sys.argv) not in (3, 5):
help(1)
passwd = None
for i in range(len(sys.argv)):
if sys.argv[i] == '-p':
sys.argv.pop(i)
passwd = sys.argv.pop(i)
break
if passwd is None:
import getpass
passwd = getpass.getpass()
if ":" in sys.argv[1] and ":" in sys.argv[2]:
error("Operations on 2 remote files are not supported")
if ":" not in sys.argv[1] and ":" not in sys.argv[2]:
error("One remote file is required")
if ":" in sys.argv[1]:
op = "get"
host, port, src_file = parse_remote(sys.argv[1])
dst_file = sys.argv[2]
if os.path.isdir(dst_file):
basename = src_file.rsplit("/", 1)[-1]
dst_file += "/" + basename
else:
op = "put"
host, port, dst_file = parse_remote(sys.argv[2])
src_file = sys.argv[1]
if dst_file[-1] == "/":
basename = src_file.rsplit("/", 1)[-1]
dst_file += basename
if True:
print("op:%s, host:%s, port:%d, passwd:%s." % (op, host, port, passwd))
print(src_file, "->", dst_file)
s = socket.socket()
ai = socket.getaddrinfo(host, port)
addr = ai[0][4]
s.connect(addr)
#s = s.makefile("rwb")
websocket_helper.client_handshake(s)
ws = websocket(s)
login(ws, passwd)
print("Remote WebREPL version:", get_ver(ws))
# Set websocket to send data marked as "binary"
ws.ioctl(9, 2)
if op == "get":
get_file(ws, dst_file, src_file)
elif op == "put":
put_file(ws, src_file, dst_file)
s.close()
def main():
if len(sys.argv) not in (3, 5):
help(1)
passwd = None
for i in range(len(sys.argv)):
if sys.argv[i] == '-p':
sys.argv.pop(i)
passwd = sys.argv.pop(i)
break
if not passwd:
import getpass
passwd = getpass.getpass()
if ":" in sys.argv[1] and ":" in sys.argv[2]:
error("Operations on 2 remote files are not supported")
if ":" not in sys.argv[1] and ":" not in sys.argv[2]:
error("One remote file is required")
if ":" in sys.argv[1]:
op = "get"
host, port, src_file = parse_remote(sys.argv[1])
dst_file = sys.argv[2]
if os.path.isdir(dst_file):
basename = src_file.rsplit("/", 1)[-1]
dst_file += "/" + basename
else:
op = "put"
host, port, dst_file = parse_remote(sys.argv[2])
src_file = sys.argv[1]
if dst_file[-1] == "/":
basename = src_file.rsplit("/", 1)[-1]
dst_file += basename
if True:
print("op:%s, host:%s, port:%d, passwd:%s." % (op, host, port, passwd))
print(src_file, "->", dst_file)
s = socket.socket()
ai = socket.getaddrinfo(host, port)
addr = ai[0][4]
s.connect(addr)
#s = s.makefile("rwb")
websocket_helper.client_handshake(s)
ws = websocket(s)
login(ws, passwd)
print("Remote WebREPL version:", get_ver(ws))
# Set websocket to send data marked as "binary"
ws.ioctl(9, 2)
if op == "get":
get_file(ws, dst_file, src_file)
elif op == "put":
put_file(ws, src_file, dst_file)
s.close()
def ws_write(msg, sz):
s = uio.BytesIO()
ws = uwebsocket.websocket(s)
ws.write(msg)
s.seek(0)
return s.read(sz)
def ws_read(msg, sz):
ws = uwebsocket.websocket(uio.BytesIO(msg))
return ws.read(sz)
print(ws_read(b"\x80\x04ping", 4)) # FRAME_CONT print(ws_write(b"pong", 6)) # split frames are not supported # print(ws_read(b"\x01\x04ping", 4)) # extended payloads print(ws_read(b"\x81~\x00\x80" + b"ping" * 32, 128)) print(ws_write(b"pong" * 32, 132)) # mask (returned data will be 'mask' ^ 'mask') print(ws_read(b"\x81\x84maskmask", 4)) # close control frame s = uio.BytesIO(b"\x88\x00") # FRAME_CLOSE ws = uwebsocket.websocket(s) print(ws.read(1)) s.seek(2) print(s.read(4)) # misc control frames print(ws_read(b"\x89\x00\x81\x04ping", 4)) # FRAME_PING print(ws_read(b"\x8a\x00\x81\x04pong", 4)) # FRAME_PONG # close method ws = uwebsocket.websocket(uio.BytesIO()) ws.close() # ioctl ws = uwebsocket.websocket(uio.BytesIO()) print(ws.ioctl(8)) # GET_DATA_OPTS
print(ws_read(b"\x80\x04ping", 4)) # FRAME_CONT print(ws_write(b"pong", 6)) # split frames are not supported # print(ws_read(b"\x01\x04ping", 4)) # extended payloads print(ws_read(b'\x81~\x00\x80' + b'ping' * 32, 128)) print(ws_write(b"pong" * 32, 132)) # mask (returned data will be 'mask' ^ 'mask') print(ws_read(b"\x81\x84maskmask", 4)) # close control frame s = uio.BytesIO(b'\x88\x00') # FRAME_CLOSE ws = uwebsocket.websocket(s) print(ws.read(1)) s.seek(2) print(s.read(4)) # misc control frames print(ws_read(b"\x89\x00\x81\x04ping", 4)) # FRAME_PING print(ws_read(b"\x8a\x00\x81\x04pong", 4)) # FRAME_PONG # close method ws = uwebsocket.websocket(uio.BytesIO()) ws.close() # ioctl ws = uwebsocket.websocket(uio.BytesIO()) print(ws.ioctl(8)) # GET_DATA_OPTS
def __init__(self, reader, writer):
self.r = reader
self.w = writer
self.ws_reader = websocket.websocket(reader)
def ws_write(msg, sz):
s = uio.BytesIO()
ws = uwebsocket.websocket(s)
ws.write(msg)
s.seek(0)
return s.read(sz)
def ws_read(msg, sz):
ws = uwebsocket.websocket(uio.BytesIO(msg))
return ws.read(sz)
