def send_login_reply(self, success, worker_id, data, outer_connector):
if success:
forw_data = forward_data.ForwardData(
forward_data.DATA_TYPE.LOGIN_SUCCESS, worker_id, '', data)
else:
forw_data = forward_data.ForwardData(
forward_data.DATA_TYPE.LOGIN_FAILED, worker_id, '', data)
protocol_parser = protocol_handler.ProtocolHandler()
send_package = protocol_parser.build_data(forw_data)
outer_connector.send(send_package)
def send_preworking_reply(self, outer_connector):
tag = cfg.CONF.TAG
forw_data = forward_data.ForwardData(
forward_data.DATA_TYPE.PRE_WORKING, 0, '0.0.0.0', 0, tag)
protocol_parser = protocol_handler.ProtocolHandler()
send_package = protocol_parser.build_data(forw_data)
outer_connector.send(send_package)
def __dispatch_data(self, data, allow2other):
ip_packages = IPProtocolHandler.parse_ip_package(data)
ip_msg_map = {}
for package in ip_packages:
if package[0] == self.__tun_ip:
send_bytes = self.__tun_connector.send(package[1])
if send_bytes <= 0:
logger.error(
"InnerWorker %d trans bytes <=0 change state to CLOSED",
self.__id)
self.__state = self.State.CLOSED
return
else:
if not ip_msg_map.has_key(package[0]):
ip_msg_map[package[0]] = package[1]
else:
ip_msg_map[package[0]] += package[1]
if not allow2other:
return
for ip, data in ip_msg_map.items():
trans_data = forward_data.ForwardData(
forward_data.DATA_TYPE.TRANS_DATA, 0, ip, data)
trans_data_event = forward_event.TransDataEvent(ip, trans_data)
self.__north_interface_channel(trans_data_event)
def trans_data(self, forward_id, inner_ip, inner_port, data,
inner_connector):
ori = 0
total_len = len(data)
while ori < total_len:
if total_len - ori <= 10000:
send_data = data[ori:total_len]
else:
send_data = data[ori:ori + 10000]
_protocol_handler = ProtocolHandler()
forw_data = forward_data.ForwardData(
forward_data.DATA_TYPE.TRANS_DATA, forward_id, inner_ip,
inner_port, send_data)
send_package = _protocol_handler.build_data(forw_data)
if inner_connector and inner_connector.con_state == connector.CON_STATE.CON_CONNECTED:
send_bytes = inner_connector.send(send_package)
if send_bytes <= 0:
logger.error(
"TransData to inner send failed,forward_id:%d inner_ip:%s inner_port:%d"
% (forward_id, inner_ip, inner_port))
raise Exception("Send data failed")
#print 'inner_connector send package'
#tools.print_hex_buf(send_package)
ori += 10000
def login_to_server(self, data, outer_connector):
forw_data = forward_data.ForwardData(
forward_data.DATA_TYPE.LOGIN_USERINFO, 0, '', data)
protocol_parser = protocol_handler.ProtocolHandler()
send_package = protocol_parser.build_data(forw_data)
outer_connector.send(send_package)
def __recv_data(self, event):
error_happen = False
if event.fd_event & select.EPOLLIN:
recv_msg = self._connector.recv()
if len(recv_msg) > 0:
# trans data
# print 'recv outer %d msg:'%(self._worker_id)
# tools.print_hex_buf(recv_msg)
try:
trans_data = forward_data.ForwardData(
forward_data.DATA_TYPE.TRANS_DATA, self._worker_id,
self.__inner_ip, self.__inner_port, recv_msg)
trans_data_event = forward_event.TransDataEvent(
self._worker_id, trans_data)
self.__sourth_interface_channel(trans_data_event)
self._recv_flow_static.add_flow(len(recv_msg))
except Exception, e:
error_happen = True
logger.error(
"OuterWorker %d current state:WORKING send data error"
% (self._worker_id))
logger.debug(traceback.format_exc())
else:
if self._connector.con_state != connector.CON_STATE.CON_CONNECTED:
error_happen = True
logger.error(
"OuterWorker %d current state:WORKING recv data error" %
(self._worker_id))
def inner_connect_succed(self, forward_id, inner_ip, inner_port,
outer_connector):
forw_data = forward_data.ForwardData(
forward_data.DATA_TYPE.CONNECTION_SUCCESS, forward_id, inner_ip,
inner_port)
protocol_parser = protocol_handler.ProtocolHandler()
send_package = protocol_parser.build_data(forw_data)
outer_connector.send(send_package)
def send_pubkey_reply(self, worker_id, pubkey, outer_connector):
data = {'public_key': pubkey}
json_data = json.dumps(data)
forw_data = forward_data.ForwardData(
forward_data.DATA_TYPE.LOGIN_PUBKEY, worker_id, '', json_data)
protocol_parser = protocol_handler.ProtocolHandler()
send_package = protocol_parser.build_data(forw_data)
outer_connector.send(send_package)
def close_connection(self,forward_id,inner_ip,inner_port,inner_connector):
_protocol_handler = ProtocolHandler()
forw_data = forward_data.ForwardData(forward_data.DATA_TYPE.CLOSE_CONNECTION, forward_id,
inner_ip, inner_port, '')
send_package = _protocol_handler.build_data(forw_data)
if inner_connector and inner_connector.con_state == connector.CON_STATE.CON_CONNECTED:
send_bytes = inner_connector.send(send_package)
if send_bytes <= 0:
logger.error("CloseConnectionData send failed,forward_id:%d inner_ip:%s inner_port:%d" % (forward_id, inner_ip, inner_port))
def send_pre_working(self,inner_connector):
_protocol_handler = ProtocolHandler()
pre_work_data = forward_data.ForwardData(forward_data.DATA_TYPE.PRE_WORKING,0,'0.0.0.0',0,'')
send_package = _protocol_handler.build_data(pre_work_data)
if inner_connector and inner_connector.con_state == connector.CON_STATE.CON_CONNECTED:
send_bytes = inner_connector.send(send_package)
if send_bytes <= 0:
logger.error("Preworking data send error")
raise Exception("Send data failed")
def send_heart_beat_reply(self, inner_connector):
forw_data = forward_data.ForwardData(forward_data.DATA_TYPE.HEART_BEAT, 0, '0.0.0.0', 0, '')
protocol_parser = ProtocolHandler()
send_package = protocol_parser.build_data(forw_data)
if inner_connector and inner_connector.con_state == connector.CON_STATE.CON_CONNECTED:
send_bytes = inner_connector.send(send_package)
if send_bytes <= 0:
logger.error("HeartBeat send failed")
raise Exception("Send HeartBeat failed")
def parse_data(self, array_buf):
if array_buf[0] != 0xAB or array_buf[1] != 0xBA:
return None
result_data = forward_data.ForwardData()
result_data.data_type = array_buf[2]
result_data.id = array_buf[3] + array_buf[4] * 0x100 + array_buf[
5] * 0x10000 + array_buf[6] * 0x1000000
result_data.inner_ip = self.bytearray_to_ip(array_buf[7:11])
result_data.inner_port = array_buf[11] + array_buf[12] * 0x100
data_len = array_buf[13] + array_buf[14] * 0x100
if data_len > 0:
result_data.data = array_buf[15:15 + data_len]
return result_data
def __handle_working_event(self, event):
error_happen = False
if event.fd_event & select.EPOLLIN:
recv_msg = self.__connector.recv()
if len(recv_msg) > 0:
# trans data
try:
trans_data = forward_data.ForwardData(forward_data.DATA_TYPE.TRANS_DATA, self.__id,
self.__inner_ip, self.__inner_port, bytearray(recv_msg))
trans_data_event = forward_event.TransDataEvent(self.__id, trans_data)
self.__north_interface_channel(trans_data_event)
except Exception, e:
error_happen = True
logger.error("InnerWorker %d current state:WORKING send data error" % (self.__id))
logger.debug(traceback.format_exc())
else:
if self.__connector.con_state != connector.CON_STATE.CON_CONNECTED:
error_happen = True
logger.error("InnerWorker %d current state:WORKING recv data error" % (self.__id))
def __handle_working_event(self, event):
error_happen = False
if event.fd_event & select.EPOLLIN:
recv_msg = self.__tun_connector.recv()
if len(recv_msg) > 0:
# trans data
try:
# ip_packages = IPProtocolHandler.parse_ip_package(bytearray(recv_msg))
# ip_msg_map = {}
# for package in ip_packages:
#
# if not ip_msg_map.has_key(package[0]):
# ip_msg_map[package[0]] = package[1]
# else:
# ip_msg_map[package[0]] += package[1]
#
# for ip,data in ip_msg_map.items():
# trans_data = forward_data.ForwardData(forward_data.DATA_TYPE.TRANS_DATA, 0,ip,data)
# trans_data_event = forward_event.TransDataEvent(ip, trans_data)
# self.__north_interface_channel(trans_data_event)
trans_data = forward_data.ForwardData(
forward_data.DATA_TYPE.TRANS_DATA, 0, '',
bytearray(recv_msg))
trans_data_event = forward_event.TransDataEvent(
'', trans_data)
self.__north_interface_channel(trans_data_event)
except Exception, e:
error_happen = True
logger.error(
"InnerWorker current state:WORKING send data error")
logger.debug(traceback.format_exc())
else:
if self.__tun_connector.con_state != CON_STATE.CON_CONNECTED:
error_happen = True
logger.error(
"InnerWorker current state:WORKING recv data error")
def trans_data(self, forward_id, data, outer_connector):
ori = 0
total_len = len(data)
while ori < total_len:
if total_len - ori <= self.__one_package_size:
send_data = data[ori:total_len]
else:
send_data = data[ori:ori + self.__one_package_size]
_protocol_handler = protocol_handler.ProtocolHandler()
forw_data = forward_data.ForwardData(
forward_data.DATA_TYPE.TRANS_DATA, forward_id, '', send_data)
send_package = _protocol_handler.build_data(forw_data)
if outer_connector and outer_connector.con_state == connector.CON_STATE.CON_CONNECTED:
send_bytes = outer_connector.send(send_package)
if send_bytes <= 0:
logger.error(
"TransData to inner send failed,forward_id:%d " %
(forward_id))
raise Exception("Send data failed")
# print 'inner_connector send package'
# tools.print_hex_buf(send_package)
ori += self.__one_package_size
def login_apply_pubkey(self, outer_connector):
forw_data = forward_data.ForwardData(
forward_data.DATA_TYPE.LOGIN_PUBKEY, 0, '', '')
protocol_parser = protocol_handler.ProtocolHandler()
send_package = protocol_parser.build_data(forw_data)
outer_connector.send(send_package)
def create_connection(self,forward_id,inner_ip,inner_port,sourth_interface):
forw_data = forward_data.ForwardData(forward_data.DATA_TYPE.NEW_CONNECTION, forward_id,
inner_ip, inner_port, '')
forw_event = forward_event.TransDataEvent(forward_id,forw_data)
sourth_interface(forw_event)
def __connecte_success(self):
connected_data = forward_data.ForwardData(forward_data.DATA_TYPE.CONNECTION_SUCCESS, self.__id,
self.__inner_ip, self.__inner_port, '')
connected_event = forward_event.TransDataEvent(self.__id, connected_data)
self.__north_interface_channel(connected_event)
self.__connector_change_callback(self.__connector, self.handler_event)
