def accept_conn(listen_sock):
global client_s
cl, remote_addr = listen_sock.accept()
if not server_handshake(cl):
send_html(cl)
return False
prev = os.dupterm(None)
os.dupterm(prev)
if prev:
print("\nConcurrent WebREPL connection from", remote_addr, "rejected")
cl.close()
return False
print("\nWebREPL connection from:", remote_addr)
client_s = cl
ws = websocket.websocket(cl, True)
ws = _webrepl._webrepl(ws)
cl.setblocking(False)
# notify REPL on socket incoming data (ESP32/ESP8266-only)
if hasattr(os, "dupterm_notify"):
cl.setsockopt(socket.SOL_SOCKET, 20, os.dupterm_notify)
os.dupterm(ws)
return True
def __init__(self, poller, client_socket):
self._socket = client_socket
self.ws = websocket.websocket(client_socket, True)
self.fileno = client_socket.fileno()
# poller.register doesn't complain if you register ws but it fails when you call ipoll.
poller.register(client_socket,
select.POLLIN | select.POLLERR | select.POLLHUP)
def setup(self, sock, addr, close_callback):
self.address = addr
self._s = sock
self.ws = websocket(self._s, True)
self._close_clb = close_callback
sock.setblocking(False)
sock.setsockopt(socket.SOL_SOCKET, 0x14, self.notify)
def WSReader(reader, writer):
webkey = None
while 1:
line = yield from reader.readline()
print(line)
if not line:
raise ValueError()
if line == b"\r\n":
break
if line.startswith(b'Sec-WebSocket-Key'):
webkey = line.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 websocket handshake")
ws = websocket.websocket(reader.ios)
print("uasyncio.StreamReader(reader.ios, ws)")
rws = uasyncio.StreamReader(reader.ios, ws)
return rws
def create_websocket(addr):
s = socket.socket()
s.connect(addr)
#s = s.makefile("rwb")
websocket_helper.client_handshake(s)
ws = websocket(s)
return ws
def http_handler(self, s, req):
meth, path, proto = req.split()
if path == b"/":
server.skip_headers(s)
s.write("HTTP/1.0 200 OK\r\n\r\n")
render(self.w, s)
elif path == b"/res/style.css":
server.skip_headers(s)
s.write("HTTP/1.0 200 OK\r\n\r\n")
with open(path[1:], "rb") as f:
data = f.read()
s.write(data)
elif path == b"/ws":
websocket_helper.server_handshake(s)
s = websocket.websocket(s)
print("websock connected")
while 1:
data = s.readline()
data = data.decode("ascii").rstrip().split()
print(data)
global CONN
CONN = s
EVENT_MAP[(int(data[0]), data[1])]()
else:
s.write("HTTP/1.0 404 NAK\r\n\r\n")
def switch(self, ct, mtu_rx, mtu_tx=125):
self.client.setblocking(False)
if ct == 'ws':
self.ws = websocket.websocket(self.client, True)
if mtu_tx > self.WS_MTU:
print(
"180: not using user MTU [%s] because rsv not implemented and mode is websocket"
% mtu_rx)
self.RX = self.RX_ws
self.TX = self.TX_ws
#max receive
self.RX_MTU = mtu_rx
else:
print('205: standard socket, mtu=', mtu_rx)
self.RX = self.RX_std
self.TX = self.TX_std
#max receive
self.RX_MTU = mtu_rx
#but limit send
mtu = mtu_tx
self.TX_MTU = mtu_tx
self.BO = self.RX_MTU * 4
self.errcnt = 0
self.log = []
def _accept_conn(server_fd):
global _client_fd
global ws
_client_fd, remote_addr = server_fd.accept()
print("websocket client from: ", remote_addr)
_client_fd.setblocking(False)
_client_fd.setsockopt(socket.SOL_SOCKET, 20, handshake_callback)
ws = websocket.websocket(_client_fd, True)
def accept_conn(self, listen_sock):
cl, remote_addr = listen_sock.accept()
print("\nWebSocket connection from:", remote_addr)
websocket_helper.server_handshake(cl)
self.ws = websocket.websocket(cl, True)
self.ws.ioctl(9, 2) # change to data frame
cl.setblocking(False)
self.client_s = cl
self.connected = True
def accept_ws(listen_sock):
global client_s
cl, remote_addr = listen_sock.accept()
client_s.append(cl)
websocket_helper.server_handshake(cl)
ws = websocket.websocket(cl, True)
cl.setblocking(False)
cl.setsockopt(socket.SOL_SOCKET, 20, uos.dupterm_notify)
uos.dupterm(ws)
def run(self):
while True:
conn, addr = self.s.accept()
try:
c = websocket(conn, addr)
print('Connected by', addr[1])
self.users.append(c)
threading.Thread(target=self.process, args=((c, ))).start()
except Exception:
pass
def __init__(self, conn, addr, s, on_close):
print("Start of init")
self.conn = conn
self.addr = addr
self.s = s
self.on_close = on_close
self.ws = websocket(s, True)
self.process()
self.client_close = False
print("End of init")
def __init__(self, addr, s, close_callback):
self.client_close = False
self.address = addr
self.socket = s
self.ws = websocket(s, True)
self.close_callback = close_callback
s.setblocking(False)
s.setsockopt(socket.SOL_SOCKET, 20, self.notify)
def main():
if len(sys.argv) != 3:
help(1)
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 1:
print(op, host, port)
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)
import getpass
passwd = getpass.getpass()
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 __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.close_callback = close_callback
s.setblocking(False)
s.setsockopt(socket.SOL_SOCKET, 20, self.notify)
def accept_conn(listen_sock):
global client_s
cl, remote_addr = listen_sock.accept()
client_s = cl
websocket_helper.server_handshake(cl)
ws = websocket.websocket(cl, True)
cl.setblocking(False)
# notify REPL on socket incoming data
cl.setsockopt(socket.SOL_SOCKET, 20, uos.dupterm_notify)
uos.dupterm(ws)
print("WebREPL connected\n>>> ", end="")
def __init__(self, addr: str, s: socket, 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 connect(self, host, port):
self.debugmsg("[d] connecting to %s %s" % (host, port))
self.s = socket.socket()
ai = socket.getaddrinfo(host, port)
addr = ai[0][4]
#self.debugmsg("connecting to adr %r" % addr)
self.s.connect(addr)
#s = s.makefile("rwb")
self.debugmsg("[d] handshake")
self.client_handshake(self.s)
self.ws = websocket(self.s)
self.ws.debug = self.debug
def __init__(self,
address,
loglevel=logging.INFO,
ssl_args=None,
max_join_time=2.0,
backlog_size=32,
**kwargs):
"""
Constructor for a simple web socket server.
`address` is a (hostname, port) tuple to bind the web socket to.
`loglevel` values should be imported from the logging module.
logging.INFO only shows server start/stop messages, logging.DEBUG shows
clients (dis)connecting and messages being sent/received.
`protocols` and `extensions` are passed directly to the websocket
constructor.
`ssl_args` is a dictionary with arguments for `websocket.enable_ssl`
(and thus to ssl.wrap_socket). If omitted, the server is not
SSL-enabled. If specified, at least the dictionary keys "keyfile" and
"certfile" must be present because these are required arguments for
`websocket.enable_ssl` for a server socket.
`max_join_time` is the maximum time (in seconds) to wait for client
responses after sending CLOSE frames, it defaults to 2 seconds.
`backlog_size` is directly passed to `websocket.listen`.
"""
logging.basicConfig(level=loglevel,
format='%(asctime)s: %(levelname)s: %(message)s',
datefmt='%H:%M:%S')
scheme = 'wss' if ssl_args else 'ws'
hostname, port = address
logging.info('Starting server at %s://%s:%d', scheme, hostname, port)
self.sock = websocket(**kwargs)
self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
if ssl_args:
self.sock.enable_ssl(server_side=True, **ssl_args)
self.sock.bind(address)
self.sock.listen(backlog_size)
self.max_join_time = max_join_time
def accept_conn(listen_sock):
global client_s
cl, remote_addr = listen_sock.accept()
if uos.dupterm():
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 = websocket.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()
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 = websocket.websocket(cl, True)
ws = _webrepl._webrepl(ws)
cl.setblocking(False)
uos.dupterm(ws)
def accept_conn(listen_sock):
global client_s
cl, remote_addr = listen_sock.accept()
if uos.dupterm():
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 = websocket.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 __init__(self, address, loglevel=logging.INFO, ssl_args=None,
max_join_time=2.0, backlog_size=32, **kwargs):
"""
Constructor for a simple web socket server.
`address` is a (hostname, port) tuple to bind the web socket to.
`loglevel` values should be imported from the logging module.
logging.INFO only shows server start/stop messages, logging.DEBUG shows
clients (dis)connecting and messages being sent/received.
`protocols` and `extensions` are passed directly to the websocket
constructor.
`ssl_args` is a dictionary with arguments for `websocket.enable_ssl`
(and thus to ssl.wrap_socket). If omitted, the server is not
SSL-enabled. If specified, at least the dictionary keys "keyfile" and
"certfile" must be present because these are required arguments for
`websocket.enable_ssl` for a server socket.
`max_join_time` is the maximum time (in seconds) to wait for client
responses after sending CLOSE frames, it defaults to 2 seconds.
`backlog_size` is directly passed to `websocket.listen`.
"""
logging.basicConfig(level=loglevel,
format='%(asctime)s: %(levelname)s: %(message)s',
datefmt='%H:%M:%S')
scheme = 'wss' if ssl_args else 'ws'
hostname, port = address
logging.info('Starting server at %s://%s:%d', scheme, hostname, port)
self.sock = websocket(**kwargs)
self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
if ssl_args:
self.sock.enable_ssl(server_side=True, **ssl_args)
self.sock.bind(address)
self.sock.listen(backlog_size)
self.max_join_time = max_join_time
def accept_conn(cls, listen_sock):
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)
WebREPL().client_s = cl
websocket_helper.server_handshake(cl)
WebREPL().ws = websocket.websocket(cl, True)
WebREPL().wr = _webrepl._webrepl(WebREPL().ws)
type(WebREPL().wr)
cl.setblocking(False)
# notify REPL on socket incoming data
cl.setsockopt(socket.SOL_SOCKET, 20, uos.dupterm_notify)
uos.dupterm(WebREPL().wr)
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)
# 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
from websocket import websocket
from connection import Connection
from message import TextMessage
from errors import SocketClosed
if __name__ == '__main__':
if len(sys.argv) < 3:
print >> sys.stderr, 'Usage: python %s HOST PORT' % sys.argv[0]
sys.exit(1)
host = sys.argv[1]
port = int(sys.argv[2])
sock = websocket()
sock.connect((host, port))
sock.settimeout(1.0)
conn = Connection(sock)
try:
try:
while True:
msg = TextMessage(raw_input())
print 'send:', msg
conn.send(msg)
try:
print 'recv:', conn.recv()
except socket.timeout:
print 'no response'
def socket_handler(listen_s):
gc.collect()
try:
client, remote_addr = listen_s.accept()
if not client.readline() == b'GET / HTTP/1.1\r\n':
client.close()
return
ws = None
ws_key = None
while True:
line = client.readline()
if line == b'\r\n' or line == b'':
break
h, v = [x.strip() for x in line.split(b':', 1)]
if h == b'Connection':
if v == b'Upgrade':
ws = True
elif h == b'Sec-WebSocket-Key':
ws_key = v
print(v, h)
if not ws:
client.close()
return
print('Got valid socket connection from', remote_addr)
d = uhashlib.sha1(ws_key)
d.update(b'258EAFA5-E914-47DA-95CA-C5AB0DC85B11')
client.send(b'\\n'
b'HTTP/1.1 101 Switching Protocols\r\n'
b'Upgrade: websocket\r\n'
b'Connection: Upgrade\r\n'
b'Sec-WebSocket-Accept: ')
client.send(ubinascii.b2a_base64(d.digest())[:-1])
client.send(b'\r\n\r\n')
ws = websocket.websocket(client)
def socket_handler_inner(client):
global settings
cmd = ws.readline().strip()
if len(cmd) == 0:
ws.close()
client.close()
return
elif cmd == b'get':
ws.write(json.dumps(settings))
ws.write(b'OK\n')
elif cmd == b'set':
settings = json.loads(ws.readline())
ws.write(b'OK\n')
elif cmd == b'exec':
try:
exec(ws.readline())
ws.write(b'OK\n')
except Exception as e:
print('error', e)
ws.write(b'ERROR\n')
ws.write(json.dumps(repr(e)))
ws.write(b'\n')
else:
ws.write(b'ERROR\nUnknown action')
ws.write(cmd)
ws.write(b'\n')
client.setblocking(False)
client.setsockopt(socket.SOL_SOCKET, 20, socket_handler_inner)
gc.collect()
except Exception as e:
print('Error handing socket:', e)
def ws_write(msg, sz):
s = uio.BytesIO()
ws = websocket.websocket(s)
ws.write(msg)
s.seek(0)
return s.read(sz)
return
if(index[1]['pState']=='false'):
#send(read("ir_Data/Ac_btn-off"))
mq.publish({"pState":"Flase"},'mi')
return
except:
print("miot err")
webrepl.start()
time.sleep(2)
lib.update_time()
blinker.DEBUG=1
mq=blinker.blinker("fbc6da5da621",cb,'light')
mq.connect()
ws=websocket.websocket(81)
ms=""
def ccb(msg):
global ms
time.sleep_ms(100)
msg=eval(msg)
msg={'data': [list(msg["data"].keys())[0], msg["data"][list(msg["data"].keys())[0]]], 'deviceType': 'DiyArduino'}
print("websocket:",msg,"\n",type(msg))
#print("websocket1:",msg)
cb("websocket",msg )
def web():
global th
b'Sec-WebSocket-Version: 13\r\n'
b'Sec-Websocket-Protocol: mqtt\r\n'
b'\r\n'))
# TODO: Validate the response to the websocket upgrade request. This
# can be done by checking the HTTP response code and validating the
# "Sec-WebSocket-Accept" header.
line = s.readline()
while line:
if line == b'\r\n':
break
line = s.readline()
# Now that the WebSocket protocol upgrade negotiation is complete,
# create a WebSocket from the TCP socket connected to the MQTT broker.
ws = websocket(s, is_client=True)
# Create an MQTT client.
client_id = hexlify(bytes([getrandbits(8) for _ in range(8)]))
client = MQTTClient(client_id, sock=ws, keepalive=keepalive)
# This is the callback function that is invoked when a message is
# received. It parses the message looking for a valid RGB tuple, and
# sends it to the NeoPixels.
def on_message_received(topic, message):
print('Message received: topic=%s, message=%s' % (topic, message))
message = message.decode('ascii')
elements = message.split(':')
if len(elements) == 2 and elements[0] == 'C':
rgb_tuple = elements[1]
rgb_tuple = rgb_tuple.split(',')
def register(client_socket):
ws = websocket.websocket(client_socket, True)
# poller.register doesn't complain if you register ws but it fails when you call ipoll.
poller.register(client_socket, select.POLLIN)
clients[client_socket.fileno()] = ws
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 = websocket.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 = websocket.websocket(uio.BytesIO()) ws.close() # ioctl ws = websocket.websocket(uio.BytesIO()) print(ws.ioctl(8)) # GET_DATA_OPTS
def ws_read(msg, sz):
ws = websocket.websocket(uio.BytesIO(msg))
return ws.read(sz)
import websocket
import json
ws = websocket.websocket()
ws.connect("ws://192.168.0.25/")
myDict = {
"sensor": "temperature",
"identifier": "SENS123456789",
"value": 10,
"timestamp": "20/10/2017 10:10:25"
}
ws.send(json.dumps(myDict))
result = ws.recv()
print(result)
ws.close()
