def start_tcp_proxy(self, proto, data):
proxylog("start_tcp_proxy(%s, '%s')", proto, repr_ellipsized(data))
try:
self._potential_protocols.remove(proto)
except:
pass #might already have been removed by now
proxylog("start_tcp_proxy: protocol state before stealing: %s",
proto.get_info(alias_info=False))
#any buffers read after we steal the connection will be placed in this temporary queue:
temp_read_buffer = Queue()
client_connection = proto.steal_connection(temp_read_buffer.put)
#connect to web server:
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.settimeout(10)
host, port = self._tcp_proxy.split(":", 1)
try:
web_server_connection = _socket_connect(sock, (host, int(port)),
"web-proxy-for-%s" % proto,
"tcp")
except:
proxylog.warn("failed to connect to proxy: %s:%s", host, port)
proto.gibberish("invalid packet header", data)
return
proxylog("proxy connected to tcp server at %s:%s : %s", host, port,
web_server_connection)
sock.settimeout(self._socket_timeout)
ioe = proto.wait_for_io_threads_exit(0.5 + self._socket_timeout)
if not ioe:
proxylog.warn("proxy failed to stop all existing network threads!")
self.disconnect_protocol(proto, "internal threading error")
return
#now that we own it, we can start it again:
client_connection.set_active(True)
#and we can use blocking sockets:
self.set_socket_timeout(client_connection, None)
#prevent deadlocks on exit:
sock.settimeout(1)
proxylog("pushing initial buffer to its new destination: %s",
repr_ellipsized(data))
web_server_connection.write(data)
while not temp_read_buffer.empty():
buf = temp_read_buffer.get()
if buf:
proxylog("pushing read buffer to its new destination: %s",
repr_ellipsized(buf))
web_server_connection.write(buf)
p = XpraProxy(client_connection.target, client_connection,
web_server_connection)
self._tcp_proxy_clients.append(p)
proxylog.info(
"client connection from %s forwarded to proxy server on %s:%s",
client_connection.target, host, port)
p.run()
proxylog("run_proxy() %s ended", p)
if p in self._tcp_proxy_clients:
self._tcp_proxy_clients.remove(p)
def start_tcp_proxy(self, proto, data):
proxylog("start_tcp_proxy(%s, '%s')", proto, repr_ellipsized(data))
try:
self._potential_protocols.remove(proto)
except:
pass # might already have been removed by now
proxylog("start_tcp_proxy: protocol state before stealing: %s", proto.get_info(alias_info=False))
# any buffers read after we steal the connection will be placed in this temporary queue:
temp_read_buffer = Queue()
client_connection = proto.steal_connection(temp_read_buffer.put)
# connect to web server:
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.settimeout(10)
host, port = self._tcp_proxy.split(":", 1)
try:
web_server_connection = _socket_connect(sock, (host, int(port)), "web-proxy-for-%s" % proto, "tcp")
except:
proxylog.warn("failed to connect to proxy: %s:%s", host, port)
proto.gibberish("invalid packet header", data)
return
proxylog("proxy connected to tcp server at %s:%s : %s", host, port, web_server_connection)
sock.settimeout(self._socket_timeout)
ioe = proto.wait_for_io_threads_exit(0.5 + self._socket_timeout)
if not ioe:
proxylog.warn("proxy failed to stop all existing network threads!")
self.disconnect_protocol(proto, "internal threading error")
return
# now that we own it, we can start it again:
client_connection.set_active(True)
# and we can use blocking sockets:
self.set_socket_timeout(client_connection, None)
# prevent deadlocks on exit:
sock.settimeout(1)
proxylog("pushing initial buffer to its new destination: %s", repr_ellipsized(data))
web_server_connection.write(data)
while not temp_read_buffer.empty():
buf = temp_read_buffer.get()
if buf:
proxylog("pushing read buffer to its new destination: %s", repr_ellipsized(buf))
web_server_connection.write(buf)
p = XpraProxy(client_connection.target, client_connection, web_server_connection)
self._tcp_proxy_clients.append(p)
proxylog.info(
"client connection from %s forwarded to proxy server on %s:%s", client_connection.target, host, port
)
p.run()
proxylog("run_proxy() %s ended", p)
if p in self._tcp_proxy_clients:
self._tcp_proxy_clients.remove(p)
def start_tcp_proxy(self, proto, data):
log("start_tcp_proxy(%s, %s)", proto, data[:10])
client_connection = proto.steal_connection()
self._potential_protocols.remove(proto)
#connect to web server:
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.settimeout(10)
host, port = self._tcp_proxy.split(":", 1)
try:
web_server_connection = _socket_connect(sock, (host, int(port)),
"web-proxy-for-%s" % proto,
"tcp")
except:
log.warn("failed to connect to proxy: %s:%s", host, port)
proto.gibberish("invalid packet header", data)
return
log("proxy connected to tcp server at %s:%s : %s", host, port,
web_server_connection)
web_server_connection.write(data)
p = XpraProxy(client_connection, web_server_connection)
self._tcp_proxy_clients.append(p)
def run_proxy():
p.run()
log("run_proxy() %s ended", p)
if p in self._tcp_proxy_clients:
self._tcp_proxy_clients.remove(p)
t = make_daemon_thread(run_proxy, "web-proxy-for-%s" % proto)
t.start()
log.info("client %s forwarded to proxy server %s:%s",
client_connection, host, port)
def run_proxy(parser, opts, script_file, args, mode):
from xpra.server.proxy import XpraProxy
assert "gtk" not in sys.modules
if mode in ("_proxy_start", "_shadow_start"):
#we must use a subprocess to avoid messing things up - yuk
cmd = [script_file]
if mode=="_proxy_start":
cmd.append("start")
assert len(args)==1, "proxy/shadow-start: expected 1 argument but got %s" % len(args)
display_name = args[0]
else:
assert mode=="_shadow_start"
cmd.append("shadow")
if len(args)==1:
#display_name was provided:
display_name = args[0]
else:
display_name = guess_X11_display()
cmd += args
if opts.start_child and len(opts.start_child)>0:
for x in opts.start_child:
cmd.append("--start-child=%s" % x)
if opts.exit_with_children:
cmd.append("--exit-with-children")
if opts.exit_with_client or mode=="_shadow_start":
cmd.append("--exit-with-client")
def setsid():
os.setsid()
Popen(cmd, stdin=PIPE, stdout=PIPE, stderr=PIPE, preexec_fn=setsid)
dotxpra = DotXpra()
start = time.time()
while dotxpra.server_state(display_name, 1)!=DotXpra.LIVE:
if time.time()-start>5:
warn("server failed to start after %.1f seconds - sorry!" % (time.time()-start))
return
time.sleep(0.10)
server_conn = connect_or_fail(pick_display(parser, opts, args))
app = XpraProxy(TwoFileConnection(sys.stdout, sys.stdin, info="stdin/stdout"), server_conn)
signal.signal(signal.SIGINT, app.quit)
signal.signal(signal.SIGTERM, app.quit)
app.run()
return 0
