def ask_user_handle(self, reg_json, addr):
#必须包含的字段！
register_fields = ("ask_uid", "channel")
try:
if False in map(lambda x: True
if x in reg_json else False, register_fields):
raise Exception("reg_json field ERROR")
res = None
ask_uid = reg_json["ask_uid"]
if ask_uid in self.clients:
res = self.clients[ask_uid]
res["ask_uid"] = ask_uid
res["method"] = "ask_user_response"
res = json.dumps(res)
#res = json.dumps(self.clients[ask_uid])
else:
res = "error! user[%d] not found in server" % (ask_uid)
logging.debug(res)
self.transport_write_back(res, addr)
except Exception as e:
logging.error("PYTHON_SERVER ERROR:" + str(e))
self.transport_write_back(str(e), addr)
def debug_recv(msg):
j = {}
for d in msg.data_list:
if d == None:
logging.error("get nothing for recieved data")
sys.exit()
j[d] = []
dobj = msg.data_list[d]
if isinstance(dobj, list):
for obj_c in dobj:
if isinstance(obj_c, object):
try:
j[d].append(json.loads(str(obj_c)))
except Exception as e:
logging.info(e)
j[d].append(obj_c)
else:
print("================what error !?")
j[d].append(obj_c)
else:
print("================what error !?")
j[d].append(json.loads(dobj))
print(json.dumps(j, indent=2))
return j
def method_eotu_ask_user_start(self, ask_user=None):
logging.debug("###############EOTU ASK USER server[%s:%d]" %
(self.coturn_server[0], self.coturn_server[1]))
#初始化报头
msg_buf = bytearray(MESSAGE_MAX_LENGTH)
msg_buf_header = stun_init_header(STUN_METHOD_EOTU_ASK_USER,
self.my_user)
msg_buf = set_buf_to_msg_buf(msg_buf, 0, msg_buf_header,
STUN_HEADER_LENGTH)
if ask_user == None:
ask_user = self.ask_user
if ask_user != None:
msg = set_data_to_msg_buf(msg_buf, STUN_HEADER_LENGTH,
STUN_ATTRIBUTE_ASK_USERID_INFO, ask_user)
else:
logging.error("ask user is None ,exiting ....")
sys.exit()
#设置msg_buf长度值
msg_to_send = set_msg_buf_size_final(msg)
return msg_to_send
def turn_data_handle(self,
json_data,
addr,
stream_data=None,
org_data=None):
turn_data_fields = ("to_uid", "from_uid")
try:
if False in map(lambda x: True
if x in json_data else False, turn_data_fields):
raise Exception("reg_json field ERROR")
to_uid = json_data["to_uid"]
if to_uid[0] in self.clients:
to_addr_obj = self.clients[to_uid[0]]["addr"]
to_addr = (to_addr_obj["ip"], to_addr_obj["port"])
#开始转发
self.transport_write_back(org_data, to_addr)
self.transport_write_back(b"turn ok", addr)
else:
self.transport_write_back(b"turn fail, user not registed!",
addr)
except Exception as e:
logging.error(e)
self.transport_write_back(e.__str__, addr)
def get_content(self, data):
if isinstance(data, str):
logging.info("data is alread string")
return (0, data) #原始数据为字符串，protocol 为0,
elif isinstance(data, bytes):
protocol = bytes_to_int(data[0:4])
# 待后续校验...
# content_len = data[4:8] #数据长度
# cs = data[8:12] #校验值
content = data[12:]
if protocol == 1:
r = (1, content.decode(encoding="utf-8"))
return r
elif protocol == 2:
json_data_len = bytes_to_int(data[12:16])
json_data = data[16:(16 + json_data_len)]
stream_data_len = bytes_to_int(
data[(16 + json_data_len):(20 + json_data_len)])
stream_data = data[(20 + json_data_len):(20 + json_data_len +
stream_data_len)]
return (2, (json_data, stream_data))
else:
logging.error("protocol not support!")
return None
else:
logging.error("paras err ,not str or bytes but [%s] EXITING .." %
type(data))
return None
def bytedata(self, protocol, hexdata, streamdata=None):
if protocol == 1:
return self.set_jsondata(hexdata)
elif protocol == 2:
return self.set_streamdata(hexdata, streamdata)
else:
logging.error("not support")
return None
def prttwo_method_handle(self,
json_data,
stream_data,
addr,
org_data=None):
if "method" in json_data:
method = json_data["method"]
self.prttwo_method_cb[method](self, json_data, stream_data, addr,
org_data)
else:
logging.error("ERROR! No method in json_data")
self.transport_write_back(b"ERROR! No method in json_data", addr)
def prtone_method_handle(self, reg_json, addr):
res = "UNEXCEPT for prtone_method_handle"
if "method" in reg_json:
method = reg_json["method"]
if method in self.method_cb:
try:
self.method_cb[method](self, reg_json, addr)
return
except BaseException as e:
logging.error(e)
res = str(e)
else:
res = "method[%s] not support in reg_json" % method
else:
res = "no method field in reg_json"
logging.error(res)
self.transport_write_back(res, addr)
def transport_write_back(self, data, addr):
res = b"UNEXCEPT for transport_write_back"
if isinstance(data, str):
res = bytes(data, encoding="utf-8")
elif isinstance(data, dict):
tmp = json.dumps(self.clients)
res = bytes(tmp, encoding="utf-8")
logging.debug("dict debug ---:%s", res)
elif isinstance(data, bytes):
res = data
elif isinstance(data, int):
res = bytes(data, encoding="utf-8")
else:
res = b"SERVER INTER ERROR! What data type to send!"
logging.error(res)
logging.debug("SERVER RESPONSE:%s", res)
self.transport.write(res, addr)
logging.debug("SERVER RESPONSE SEND END \n\n")
def datagramReceived(self, data, addr):
logging.info("CLIENT[%s:%d] visit now! ----------- " %
(addr[0], addr[1]))
logging.debug("SERVER RECIEVED: %s" % data)
protocol, pdata = eotudata().get_content(
data) # return (protocol, data)
if protocol == 1:
content = pdata
recv_json = json.loads(content)
self.prtone_method_handle(recv_json, addr)
elif protocol == 2:
try:
json_data = json.loads(pdata[0].decode(encoding="utf-8"))
logging.debug("turn data is %s" % pdata[1])
self.prttwo_method_handle(json_data, pdata[1], addr, data)
except Exception as e:
logging.error(e)
self.reactor.stop()
def get_data_type(self, next_data):
if len(next_data) < 5:
logging.error("illegle")
sys.exit()
data_type = next_data[0:2]
data_type_int = bytes_to_int(next_data[0:2])
data_length = bytes_to_int(next_data[2:4])
if len(next_data) < 4 + data_length:
logging.error("total len [%d]" % len(next_data))
logging.error("message demand len [%d]" % (4 + data_length))
logging.error("get data type length error [%s] ,Exiting ...." %
next_data.hex())
#sys.exit(-1)
return (data_type_int, next_data, None)
data_value = next_data[4:(data_length + 4)]
data_attr = None
if data_type_int in data_attr_funcs:
func = data_attr_funcs[data_type_int]
if func is not None:
data_attr = data_attr_funcs[data_type_int](data_length,
data_value,
data_type_int,
data_type)
else:
data_attr = [data_value]
else:
logging.error("ATTR[%s] no function to get value [%s]" %
(data_type.hex(), data_value.hex()))
data_attr = data_value.hex()
next_data = next_data[(data_length + 4):]
return (data_type_int, data_attr, next_data)
def register_handle(self, reg_json, addr):
#必须包含的字段！
register_fields = ("uid", "channel")
try:
if False in map(lambda x: True
if x in reg_json else False, register_fields):
raise Exception("reg_json field ERROR")
uid = reg_json["uid"]
self.clients[uid] = {
"addr": {
"ip": addr[0],
"port": addr[1]
},
"channel": reg_json["channel"]
}
r = {"result": "ok"}
self.transport_write_back(r, addr)
except Exception as e:
logging.error(str(e))
self.transport_write_back(str(e), addr)
def connectionRefused(self):
logging.error("No one listening")
