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() 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)