def recvFromRemote(self, remote_socket, mask, target_ip, target_port):
try:
tunnel = self.tunnelWithSocket(remote_socket)
data = remote_socket.recv(Constants.BUFFER_SIZE)
if data:
self.logger.debug("recv from remote {}->{}: {}".format(
util.fromHexHost(tunnel.controller_host),
util.fromHexHost(tunnel.target_host),
data[:Constants.LOG_MSG_SIZE]))
self.msg_seq += 1
msg = util.encodeMessage(self.msg_seq, Constants.CMD_FORWARD,
tunnel.controller_host,
tunnel.target_host, data)
self.proxy_send_buffer.put(msg)
else:
self.logger.info("recv null from remote {}".format(
util.fromHexHost(tunnel.controller_host)))
self.disconnectRemote(tunnel.controller_host)
self.sendDisconnectRemote(tunnel.controller_host,
tunnel.target_host)
except Exception as e:
try:
(controller_ip,
controller_port) = util.fromHexHost(tunnel.controller_host)
self.logger.info("connection closed {}->{}: {}".format(
util.fromHexHost(tunnel.controller_host),
util.fromHexHost(tunnel.target_host), e))
self.disconnectRemote(tunnel.controller_host)
self.sendDisconnectRemote(tunnel.controller_host,
tunnel.target_host)
except Exception as e:
self.logger.critical("error when closing socket: {}".format(e))
self.logger.critical(
"cannot close the other side's remote socket")
def sendDisconnectRemote(self, from_host, to_host, reason=None):
self.msg_seq += 1
msg = util.encodeMessage(
self.msg_seq, Constants.CMD_REMOTE_DISCONNECT, from_host, to_host,
reason.encode()
if reason else None) # tell server the remote cannot be connected
self.proxy_send_buffer.put(msg)
def proxyKeepAliveThread(self):
self.logger.info("started")
while self.running:
if self.proxy_connected.is_set():
curr_time = time.time()
since_last_msg = curr_time - self.proxy_last_com_time
if since_last_msg > Constants.HEART_BEAT_INTERVAL:
payload = util.intToHex(int(curr_time)) + util.shortToHex(
int((curr_time * 1000) % 1000))
# send a heart beat
self.msg_seq += 1
msg = util.encodeMessage(
self.msg_seq, Constants.CMD_ALV,
util.toHexHost(self.proxy_ip, self.proxy_port),
util.toHexHost(self.proxy_ip, self.proxy_port),
payload)
self.proxy_send_buffer.put(msg)
self.logger.info("added keep alive to proxy send buffer")
time.sleep(Constants.HEART_BEAT_INTERVAL)
self.logger.info("ended")
def handleProxyMsg(self, msg):
(seq, cmd, from_host, to_host, payload) = util.decodeMessage(msg)
self.logger.debug(
"read data from proxy: cmd: {}, {}->{}: seq: {}, data: {}".format(
cmd, util.fromHexHost(from_host), util.fromHexHost(to_host),
seq, payload[:Constants.LOG_MSG_SIZE]))
if cmd == Constants.CMD_GREETING:
self.logger.info("greeting from proxy: {}".format(payload))
elif cmd == Constants.CMD_FORWARD:
self.remote_send_buffer.put(msg)
elif cmd == Constants.CMD_REMOTE_DISCONNECT:
# 3: CMD, 6:disconnect remote, 6:to be told remote, other: reason
from_ip, from_port = util.fromHexHost(from_host)
to_ip, to_port = util.fromHexHost(to_host)
if to_host not in self.tunnel_dict:
self.logger.error("error: no remote {}:{} found: {}".format(
to_ip, to_port, payload))
else:
self.logger.info(
"the other side's remote {}:{}->{}:{} disconnected: {}".
format(from_ip, from_port, to_ip, to_port, payload))
self.disconnectRemote(to_host)
elif cmd == Constants.CMD_ALV:
# echo back
latency = time.time() - (util.intFromHex(payload[0:4]) +
util.shortFromHex(payload[4:6]) / 1000.0)
self.logger.info(
"recved proxy client keepalive, latency: {}ms".format(
int(latency * 1000.0)))
self.msg_seq += 1
out_msg = util.encodeMessage(self.msg_seq, cmd, to_host, from_host,
payload)
self.proxy_send_buffer.put(out_msg)
else:
self.logger.error("unknown cmd from proxy: {}".format(cmd))
def recvFromRemote(self, sock, msg):
(seq, cmd, from_host, to_host, payload) = util.decodeMessage(msg)
try:
# remote_host = sock.getpeername()
data = sock.recv(Constants.BUFFER_SIZE)
if data:
self.logger.debug("recv from remote {}: {}".format(
sock.getpeername(), data[:Constants.LOG_MSG_SIZE]))
self.msg_seq += 1
msg = util.encodeMessage(self.msg_seq, Constants.CMD_FORWARD,
to_host, from_host, data)
self.proxy_send_buffer.put(msg)
else:
self.logger.info("recv null from remote {}".format(
sock.getsockname()))
self.disconnectRemote(sock, from_host, to_host)
self.sendDisconnectRemote(to_host, from_host)
except Exception as e:
self.logger.error("error when recv from remote {}: {}".format(
sock.getsockname(), e))
self.disconnectRemote(sock, from_host, to_host)
self.sendDisconnectRemote(to_host, from_host)