mirror of
https://github.com/sshuttle/sshuttle.git
synced 2024-12-31 19:21:14 +01:00
Add Python 3.5 support.
This commit is contained in:
parent
dd8e68b6dc
commit
ba1cf58a6c
1
setup.py
1
setup.py
@ -40,6 +40,7 @@ setup(
|
||||
"GNU General Public License v2 or later (GPLv2+)",
|
||||
"Operating System :: OS Independent",
|
||||
"Programming Language :: Python :: 2.7",
|
||||
"Programming Language :: Python :: 3.5",
|
||||
"Topic :: System :: Networking",
|
||||
],
|
||||
entry_points={
|
||||
|
@ -1,8 +1,8 @@
|
||||
import sys
|
||||
import re
|
||||
import socket
|
||||
import helpers
|
||||
import options
|
||||
import sshuttle.helpers as helpers
|
||||
import sshuttle.options as options
|
||||
import sshuttle.client as client
|
||||
import sshuttle.server as server
|
||||
import sshuttle.firewall as firewall
|
||||
@ -145,7 +145,7 @@ o = options.Options(optspec)
|
||||
if opt.daemon:
|
||||
opt.syslog = 1
|
||||
if opt.wrap:
|
||||
import ssnet
|
||||
import sshuttle.ssnet as ssnet
|
||||
ssnet.MAX_CHANNEL = int(opt.wrap)
|
||||
helpers.verbose = opt.verbose
|
||||
|
||||
@ -230,7 +230,7 @@ try:
|
||||
log('Abnormal exit code detected, failing...' % return_code)
|
||||
sys.exit(return_code)
|
||||
|
||||
except Fatal, e:
|
||||
except Fatal as e:
|
||||
log('fatal: %s\n' % e)
|
||||
sys.exit(99)
|
||||
except KeyboardInterrupt:
|
||||
|
@ -18,7 +18,7 @@ while 1:
|
||||
setattr(sys.modules[parent], parent_name, module)
|
||||
|
||||
code = compile(content, name, "exec")
|
||||
exec code in module.__dict__
|
||||
exec(code, module.__dict__)
|
||||
sys.modules[name] = module
|
||||
else:
|
||||
break
|
||||
|
@ -3,12 +3,12 @@ import errno
|
||||
import re
|
||||
import signal
|
||||
import time
|
||||
import sshuttle.compat.ssubprocess as ssubprocess
|
||||
import helpers
|
||||
import subprocess as ssubprocess
|
||||
import sshuttle.helpers as helpers
|
||||
import os
|
||||
import sshuttle.ssnet as ssnet
|
||||
import sshuttle.ssh as ssh
|
||||
import ssyslog
|
||||
import sshuttle.ssyslog as ssyslog
|
||||
import sys
|
||||
from sshuttle.ssnet import SockWrapper, Handler, Proxy, Mux, MuxWrapper
|
||||
from sshuttle.helpers import log, debug1, debug2, debug3, Fatal, islocal, \
|
||||
@ -124,7 +124,7 @@ def check_daemon(pidfile):
|
||||
_pidname = os.path.abspath(pidfile)
|
||||
try:
|
||||
oldpid = open(_pidname).read(1024)
|
||||
except IOError, e:
|
||||
except IOError as e:
|
||||
if e.errno == errno.ENOENT:
|
||||
return # no pidfile, ok
|
||||
else:
|
||||
@ -138,7 +138,7 @@ def check_daemon(pidfile):
|
||||
return # invalid pidfile, ok
|
||||
try:
|
||||
os.kill(oldpid, 0)
|
||||
except OSError, e:
|
||||
except OSError as e:
|
||||
if e.errno == errno.ESRCH:
|
||||
os.unlink(_pidname)
|
||||
return # outdated pidfile, ok
|
||||
@ -157,7 +157,7 @@ def daemonize():
|
||||
if os.fork():
|
||||
os._exit(0)
|
||||
|
||||
outfd = os.open(_pidname, os.O_WRONLY | os.O_CREAT | os.O_EXCL, 0666)
|
||||
outfd = os.open(_pidname, os.O_WRONLY | os.O_CREAT | os.O_EXCL, 0o666)
|
||||
try:
|
||||
os.write(outfd, '%d\n' % os.getpid())
|
||||
finally:
|
||||
@ -179,7 +179,7 @@ def daemonize():
|
||||
def daemon_cleanup():
|
||||
try:
|
||||
os.unlink(_pidname)
|
||||
except OSError, e:
|
||||
except OSError as e:
|
||||
if e.errno == errno.ENOENT:
|
||||
pass
|
||||
else:
|
||||
@ -215,7 +215,7 @@ def original_dst(sock):
|
||||
assert(socket.htons(proto) == socket.AF_INET)
|
||||
ip = '%d.%d.%d.%d' % (a, b, c, d)
|
||||
return (ip, port)
|
||||
except socket.error, e:
|
||||
except socket.error as e:
|
||||
if e.args[0] == errno.ENOPROTOOPT:
|
||||
return sock.getsockname()
|
||||
raise
|
||||
@ -251,7 +251,7 @@ class MultiListener:
|
||||
if self.v4:
|
||||
try:
|
||||
self.v4.listen(backlog)
|
||||
except socket.error, e:
|
||||
except socket.error as e:
|
||||
# on some systems v4 bind will fail if the v6 suceeded,
|
||||
# in this case the v6 socket will receive v4 too.
|
||||
if e.errno == errno.EADDRINUSE and self.v6:
|
||||
@ -321,17 +321,22 @@ class FirewallClient:
|
||||
self.p = ssubprocess.Popen(argv, stdout=s1, preexec_fn=setup)
|
||||
e = None
|
||||
break
|
||||
except OSError, e:
|
||||
except OSError as e:
|
||||
pass
|
||||
self.argv = argv
|
||||
s1.close()
|
||||
self.pfile = s2.makefile('wb+')
|
||||
if sys.version_info < (3, 0):
|
||||
# python 2.7
|
||||
self.pfile = s2.makefile('wb+')
|
||||
else:
|
||||
# python 3.5
|
||||
self.pfile = s2.makefile('rwb')
|
||||
if e:
|
||||
log('Spawning firewall manager: %r\n' % self.argv)
|
||||
raise Fatal(e)
|
||||
line = self.pfile.readline()
|
||||
self.check()
|
||||
if line[0:5] != 'READY':
|
||||
if line[0:5] != b'READY':
|
||||
raise Fatal('%r expected READY, got %r' % (self.argv, line))
|
||||
self.method = line[6:-1]
|
||||
|
||||
@ -341,22 +346,26 @@ class FirewallClient:
|
||||
raise Fatal('%r returned %d' % (self.argv, rv))
|
||||
|
||||
def start(self):
|
||||
self.pfile.write('ROUTES\n')
|
||||
for (family, ip, width) in self.subnets_include + self.auto_nets:
|
||||
self.pfile.write('%d,%d,0,%s\n' % (family, width, ip))
|
||||
for (family, ip, width) in self.subnets_exclude:
|
||||
self.pfile.write('%d,%d,1,%s\n' % (family, width, ip))
|
||||
self.pfile.write('GO\n')
|
||||
self.pfile.write(b'ROUTES\n')
|
||||
try:
|
||||
for (family, ip, width) in self.subnets_include + self.auto_nets:
|
||||
self.pfile.write(b'%d,%d,0,%s\n' % (family, width, ip.encode("ASCII")))
|
||||
for (family, ip, width) in self.subnets_exclude:
|
||||
self.pfile.write(b'%d,%d,1,%s\n' % (family, width, ip.encode("ASCII")))
|
||||
except Exception as e:
|
||||
debug1("exception occured %r" % e)
|
||||
raise
|
||||
self.pfile.write(b'GO\n')
|
||||
self.pfile.flush()
|
||||
line = self.pfile.readline()
|
||||
self.check()
|
||||
if line != 'STARTED\n':
|
||||
if line != b'STARTED\n':
|
||||
raise Fatal('%r expected STARTED, got %r' % (self.argv, line))
|
||||
|
||||
def sethostip(self, hostname, ip):
|
||||
assert(not re.search(r'[^-\w]', hostname))
|
||||
assert(not re.search(r'[^0-9.]', ip))
|
||||
self.pfile.write('HOST %s,%s\n' % (hostname, ip))
|
||||
self.pfile.write(b'HOST %s,%s\n' % (hostname, ip))
|
||||
self.pfile.flush()
|
||||
|
||||
def done(self):
|
||||
@ -390,7 +399,7 @@ def onaccept_tcp(listener, method, mux, handlers):
|
||||
global _extra_fd
|
||||
try:
|
||||
sock, srcip = listener.accept()
|
||||
except socket.error, e:
|
||||
except socket.error as e:
|
||||
if e.args[0] in [errno.EMFILE, errno.ENFILE]:
|
||||
debug1('Rejected incoming connection: too many open files!\n')
|
||||
# free up an fd so we can eat the connection
|
||||
@ -403,9 +412,9 @@ def onaccept_tcp(listener, method, mux, handlers):
|
||||
return
|
||||
else:
|
||||
raise
|
||||
if method == "tproxy":
|
||||
if method == b"tproxy":
|
||||
dstip = sock.getsockname()
|
||||
elif method == "pf":
|
||||
elif method == b"pf":
|
||||
dstip = pf_dst(sock)
|
||||
else:
|
||||
dstip = original_dst(sock)
|
||||
@ -420,8 +429,8 @@ def onaccept_tcp(listener, method, mux, handlers):
|
||||
log('warning: too many open channels. Discarded connection.\n')
|
||||
sock.close()
|
||||
return
|
||||
mux.send(chan, ssnet.CMD_TCP_CONNECT, '%d,%s,%s' %
|
||||
(sock.family, dstip[0], dstip[1]))
|
||||
mux.send(chan, ssnet.CMD_TCP_CONNECT, b'%d,%s,%d' %
|
||||
(sock.family, dstip[0].encode("ASCII"), dstip[1]))
|
||||
outwrap = MuxWrapper(mux, chan)
|
||||
handlers.append(Proxy(SockWrapper(sock, sock), outwrap))
|
||||
expire_connections(time.time(), mux)
|
||||
@ -439,7 +448,7 @@ def udp_done(chan, data, method, family, dstip):
|
||||
sender.bind(srcip)
|
||||
sender.sendto(data, dstip)
|
||||
sender.close()
|
||||
except socket.error, e:
|
||||
except socket.error as e:
|
||||
debug1('-- ignored socket error sending UDP data: %r\n' % e)
|
||||
|
||||
|
||||
@ -471,7 +480,7 @@ def dns_done(chan, data, method, sock, srcip, dstip, mux):
|
||||
debug3('dns_done: channel=%d src=%r dst=%r\n' % (chan, srcip, dstip))
|
||||
del mux.channels[chan]
|
||||
del dnsreqs[chan]
|
||||
if method == "tproxy":
|
||||
if method == b"tproxy":
|
||||
debug3('doing send from %r to %r\n' % (srcip, dstip,))
|
||||
sender = socket.socket(sock.family, socket.SOCK_DGRAM)
|
||||
sender.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
|
||||
@ -487,7 +496,7 @@ def dns_done(chan, data, method, sock, srcip, dstip, mux):
|
||||
def ondns(listener, method, mux, handlers):
|
||||
now = time.time()
|
||||
srcip, dstip, data = recv_udp(listener, 4096)
|
||||
if method == "tproxy" and not dstip:
|
||||
if method == b"tproxy" and not dstip:
|
||||
debug1(
|
||||
"-- ignored UDP from %r: "
|
||||
"couldn't determine destination IP address\n" % (srcip,))
|
||||
@ -517,7 +526,7 @@ def _main(tcp_listener, udp_listener, fw, ssh_cmd, remotename,
|
||||
ssh_cmd, remotename, python,
|
||||
stderr=ssyslog._p and ssyslog._p.stdin,
|
||||
options=dict(latency_control=latency_control, method=method))
|
||||
except socket.error, e:
|
||||
except socket.error as e:
|
||||
if e.args[0] == errno.EPIPE:
|
||||
raise Fatal("failed to establish ssh session (1)")
|
||||
else:
|
||||
@ -525,17 +534,17 @@ def _main(tcp_listener, udp_listener, fw, ssh_cmd, remotename,
|
||||
mux = Mux(serversock, serversock)
|
||||
handlers.append(mux)
|
||||
|
||||
expected = 'SSHUTTLE0001'
|
||||
expected = b'SSHUTTLE0001'
|
||||
|
||||
try:
|
||||
v = 'x'
|
||||
while v and v != '\0':
|
||||
while v and v != b'\0':
|
||||
v = serversock.recv(1)
|
||||
v = 'x'
|
||||
while v and v != '\0':
|
||||
while v and v != b'\0':
|
||||
v = serversock.recv(1)
|
||||
initstring = serversock.recv(len(expected))
|
||||
except socket.error, e:
|
||||
except socket.error as e:
|
||||
if e.args[0] == errno.ECONNRESET:
|
||||
raise Fatal("failed to establish ssh session (2)")
|
||||
else:
|
||||
@ -549,7 +558,7 @@ def _main(tcp_listener, udp_listener, fw, ssh_cmd, remotename,
|
||||
raise Fatal('expected server init string %r; got %r'
|
||||
% (expected, initstring))
|
||||
debug1('connected.\n')
|
||||
print 'Connected.'
|
||||
print('Connected.')
|
||||
sys.stdout.flush()
|
||||
if daemon:
|
||||
daemonize()
|
||||
@ -616,7 +625,7 @@ def main(listenip_v6, listenip_v4,
|
||||
if daemon:
|
||||
try:
|
||||
check_daemon(pidfile)
|
||||
except Fatal, e:
|
||||
except Fatal as e:
|
||||
log("%s\n" % e)
|
||||
return 5
|
||||
debug1('Starting sshuttle proxy.\n')
|
||||
@ -624,7 +633,7 @@ def main(listenip_v6, listenip_v4,
|
||||
if recvmsg is not None:
|
||||
debug1("recvmsg %s support enabled.\n" % recvmsg)
|
||||
|
||||
if method == "tproxy":
|
||||
if method == b"tproxy":
|
||||
if recvmsg is not None:
|
||||
debug1("tproxy UDP support enabled.\n")
|
||||
udp = True
|
||||
@ -643,7 +652,7 @@ def main(listenip_v6, listenip_v4,
|
||||
ports = [0, ]
|
||||
else:
|
||||
# if at least one port missing, we have to search
|
||||
ports = xrange(12300, 9000, -1)
|
||||
ports = range(12300, 9000, -1)
|
||||
|
||||
# search for free ports and try to bind
|
||||
last_e = None
|
||||
@ -688,7 +697,7 @@ def main(listenip_v6, listenip_v4,
|
||||
udp_listener.bind(lv6, lv4)
|
||||
bound = True
|
||||
break
|
||||
except socket.error, e:
|
||||
except socket.error as e:
|
||||
if e.errno == errno.EADDRINUSE:
|
||||
last_e = e
|
||||
else:
|
||||
@ -708,7 +717,7 @@ def main(listenip_v6, listenip_v4,
|
||||
nslist += resolvconf_nameservers()
|
||||
# search for spare port for DNS
|
||||
debug2('Binding DNS:')
|
||||
ports = xrange(12300, 9000, -1)
|
||||
ports = range(12300, 9000, -1)
|
||||
for port in ports:
|
||||
debug2(' %d' % port)
|
||||
dns_listener = MultiListener(socket.SOCK_DGRAM)
|
||||
@ -731,7 +740,7 @@ def main(listenip_v6, listenip_v4,
|
||||
dns_listener.bind(lv6, lv4)
|
||||
bound = True
|
||||
break
|
||||
except socket.error, e:
|
||||
except socket.error as e:
|
||||
if e.errno == errno.EADDRINUSE:
|
||||
last_e = e
|
||||
else:
|
||||
@ -750,7 +759,7 @@ def main(listenip_v6, listenip_v4,
|
||||
subnets_exclude, dnsport_v6, dnsport_v4, nslist,
|
||||
method, udp)
|
||||
|
||||
if fw.method == "tproxy":
|
||||
if fw.method == b"tproxy":
|
||||
tcp_listener.setsockopt(socket.SOL_IP, IP_TRANSPARENT, 1)
|
||||
if udp_listener:
|
||||
udp_listener.setsockopt(socket.SOL_IP, IP_TRANSPARENT, 1)
|
||||
@ -767,7 +776,7 @@ def main(listenip_v6, listenip_v4,
|
||||
if dns_listener.v6 is not None:
|
||||
dns_listener.v6.setsockopt(SOL_IPV6, IPV6_RECVORIGDSTADDR, 1)
|
||||
|
||||
if fw.method == "pf":
|
||||
if fw.method == b"pf":
|
||||
global pf_command_file
|
||||
pf_command_file = fw.pfile
|
||||
|
||||
|
File diff suppressed because it is too large
Load Diff
@ -3,8 +3,8 @@ import socket
|
||||
import select
|
||||
import signal
|
||||
import struct
|
||||
import compat.ssubprocess as ssubprocess
|
||||
import ssyslog
|
||||
import subprocess as ssubprocess
|
||||
import sshuttle.ssyslog as ssyslog
|
||||
import sys
|
||||
import os
|
||||
import re
|
||||
@ -22,7 +22,7 @@ IPPROTO_DIVERT = 254
|
||||
def nonfatal(func, *args):
|
||||
try:
|
||||
func(*args)
|
||||
except Fatal, e:
|
||||
except Fatal as e:
|
||||
log('error: %s\n' % e)
|
||||
|
||||
|
||||
@ -36,7 +36,7 @@ def ipt_chain_exists(family, table, name):
|
||||
argv = [cmd, '-t', table, '-nL']
|
||||
p = ssubprocess.Popen(argv, stdout=ssubprocess.PIPE)
|
||||
for line in p.stdout:
|
||||
if line.startswith('Chain %s ' % name):
|
||||
if line.startswith(b'Chain %s ' % name.encode("ASCII")):
|
||||
return True
|
||||
rv = p.wait()
|
||||
if rv:
|
||||
@ -134,7 +134,7 @@ def do_iptables_nat(port, dnsport, nslist, family, subnets, udp):
|
||||
'--to-ports', str(port))
|
||||
|
||||
if dnsport:
|
||||
for f, ip in filter(lambda i: i[0] == family, nslist):
|
||||
for f, ip in [i for i in nslist if i[0] == family]:
|
||||
ipt_ttl('-A', chain, '-j', 'REDIRECT',
|
||||
'--dest', '%s/32' % ip,
|
||||
'-p', 'udp',
|
||||
@ -193,7 +193,7 @@ def do_iptables_tproxy(port, dnsport, nslist, family, subnets, udp):
|
||||
'-m', 'udp', '-p', 'udp')
|
||||
|
||||
if dnsport:
|
||||
for f, ip in filter(lambda i: i[0] == family, nslist):
|
||||
for f, ip in [i for i in nslist if i[0] == family]:
|
||||
ipt('-A', mark_chain, '-j', 'MARK', '--set-mark', '1',
|
||||
'--dest', '%s/32' % ip,
|
||||
'-m', 'udp', '-p', 'udp', '--dport', '53')
|
||||
@ -440,7 +440,7 @@ def do_ipfw(port, dnsport, family, subnets, udp):
|
||||
IPPROTO_DIVERT)
|
||||
divertsock.bind(('0.0.0.0', port)) # IP field is ignored
|
||||
|
||||
for f, ip in filter(lambda i: i[0] == family, nslist):
|
||||
for f, ip in [i for i in nslist if i[0] == family]:
|
||||
# relabel and then catch outgoing DNS requests
|
||||
ipfw('add', sport, 'divert', sport,
|
||||
'udp',
|
||||
@ -553,7 +553,7 @@ def rewrite_etc_hosts(port):
|
||||
try:
|
||||
old_content = open(HOSTSFILE).read()
|
||||
st = os.stat(HOSTSFILE)
|
||||
except IOError, e:
|
||||
except IOError as e:
|
||||
if e.errno == errno.ENOENT:
|
||||
pass
|
||||
else:
|
||||
@ -575,7 +575,7 @@ def rewrite_etc_hosts(port):
|
||||
os.chmod(tmpname, st.st_mode)
|
||||
else:
|
||||
os.chown(tmpname, 0, 0)
|
||||
os.chmod(tmpname, 0644)
|
||||
os.chmod(tmpname, 0o644)
|
||||
os.rename(tmpname, HOSTSFILE)
|
||||
|
||||
|
||||
@ -625,11 +625,11 @@ pfioc_pooladdr = c_char * 1136 # sizeof(struct pfioc_pooladdr)
|
||||
|
||||
MAXPATHLEN = 1024
|
||||
|
||||
DIOCNATLOOK = ((0x40000000L | 0x80000000L) | (
|
||||
DIOCNATLOOK = ((0x40000000 | 0x80000000) | (
|
||||
(sizeof(pfioc_natlook) & 0x1fff) << 16) | ((ord('D')) << 8) | (23))
|
||||
DIOCCHANGERULE = ((0x40000000L | 0x80000000L) | (
|
||||
DIOCCHANGERULE = ((0x40000000 | 0x80000000) | (
|
||||
(sizeof(pfioc_rule) & 0x1fff) << 16) | ((ord('D')) << 8) | (26))
|
||||
DIOCBEGINADDRS = ((0x40000000L | 0x80000000L) | (
|
||||
DIOCBEGINADDRS = ((0x40000000 | 0x80000000) | (
|
||||
(sizeof(pfioc_pooladdr) & 0x1fff) << 16) | ((ord('D')) << 8) | (51))
|
||||
|
||||
PF_CHANGE_ADD_TAIL = 2
|
||||
@ -794,14 +794,14 @@ def main(port_v6, port_v4, dnsport_v6, dnsport_v4, nslist, method, udp, syslog):
|
||||
if line:
|
||||
debug1('firewall manager: starting transproxy.\n')
|
||||
|
||||
subnets_v6 = filter(lambda i: i[0] == socket.AF_INET6, subnets)
|
||||
subnets_v6 = [i for i in subnets if i[0] == socket.AF_INET6]
|
||||
if port_v6:
|
||||
do_wait = do_it(
|
||||
port_v6, dnsport_v6, nslist, socket.AF_INET6, subnets_v6, udp)
|
||||
elif len(subnets_v6) > 0:
|
||||
debug1("IPv6 subnets defined but IPv6 disabled\n")
|
||||
|
||||
subnets_v4 = filter(lambda i: i[0] == socket.AF_INET, subnets)
|
||||
subnets_v4 = [i for i in subnets if i[0] == socket.AF_INET]
|
||||
if port_v4:
|
||||
do_wait = do_it(
|
||||
port_v4, dnsport_v4, nslist, socket.AF_INET, subnets_v4, udp)
|
||||
@ -832,7 +832,7 @@ def main(port_v6, port_v4, dnsport_v6, dnsport_v4, nslist, method, udp, syslog):
|
||||
try:
|
||||
dst = pf_query_nat(*(line[13:].split(',')))
|
||||
sys.stdout.write('QUERY_PF_NAT_SUCCESS %s,%r\n' % dst)
|
||||
except IOError, e:
|
||||
except IOError as e:
|
||||
sys.stdout.write('QUERY_PF_NAT_FAILURE %s\n' % e)
|
||||
|
||||
sys.stdout.flush()
|
||||
|
@ -69,7 +69,7 @@ def islocal(ip, family):
|
||||
try:
|
||||
try:
|
||||
sock.bind((ip, 0))
|
||||
except socket.error, e:
|
||||
except socket.error as e:
|
||||
if e.args[0] == errno.EADDRNOTAVAIL:
|
||||
return False # not a local IP
|
||||
else:
|
||||
|
@ -6,7 +6,7 @@ import errno
|
||||
import os
|
||||
import sys
|
||||
|
||||
import sshuttle.compat.ssubprocess as ssubprocess
|
||||
import subprocess as ssubprocess
|
||||
import sshuttle.helpers as helpers
|
||||
from sshuttle.helpers import log, debug1, debug2, debug3
|
||||
|
||||
@ -21,7 +21,7 @@ hostnames = {}
|
||||
queue = {}
|
||||
try:
|
||||
null = open('/dev/null', 'wb')
|
||||
except IOError, e:
|
||||
except IOError as e:
|
||||
log('warning: %s\n' % e)
|
||||
null = os.popen("sh -c 'while read x; do :; done'", 'wb', 4096)
|
||||
|
||||
@ -48,7 +48,7 @@ def write_host_cache():
|
||||
def read_host_cache():
|
||||
try:
|
||||
f = open(CACHEFILE)
|
||||
except IOError, e:
|
||||
except IOError as e:
|
||||
if e.errno == errno.ENOENT:
|
||||
return
|
||||
else:
|
||||
@ -122,7 +122,7 @@ def _check_netstat():
|
||||
p = ssubprocess.Popen(argv, stdout=ssubprocess.PIPE, stderr=null)
|
||||
content = p.stdout.read()
|
||||
p.wait()
|
||||
except OSError, e:
|
||||
except OSError as e:
|
||||
log('%r failed: %r\n' % (argv, e))
|
||||
return
|
||||
|
||||
@ -142,7 +142,7 @@ def _check_smb(hostname):
|
||||
p = ssubprocess.Popen(argv, stdout=ssubprocess.PIPE, stderr=null)
|
||||
lines = p.stdout.readlines()
|
||||
p.wait()
|
||||
except OSError, e:
|
||||
except OSError as e:
|
||||
log('%r failed: %r\n' % (argv, e))
|
||||
_smb_ok = False
|
||||
return
|
||||
@ -199,7 +199,7 @@ def _check_nmb(hostname, is_workgroup, is_master):
|
||||
p = ssubprocess.Popen(argv, stdout=ssubprocess.PIPE, stderr=null)
|
||||
lines = p.stdout.readlines()
|
||||
rv = p.wait()
|
||||
except OSError, e:
|
||||
except OSError as e:
|
||||
log('%r failed: %r\n' % (argv, e))
|
||||
_nmb_ok = False
|
||||
return
|
||||
@ -267,7 +267,7 @@ def hw_main(seed_hosts):
|
||||
|
||||
while 1:
|
||||
now = time.time()
|
||||
for t, last_polled in queue.items():
|
||||
for t, last_polled in list(queue.items()):
|
||||
(op, args) = t
|
||||
if not _stdin_still_ok(0):
|
||||
break
|
||||
|
@ -186,12 +186,12 @@ class Options:
|
||||
try:
|
||||
(flags, extra) = self.optfunc(
|
||||
args, self._shortopts, self._longopts)
|
||||
except getopt.GetoptError, e:
|
||||
except getopt.GetoptError as e:
|
||||
self.fatal(e)
|
||||
|
||||
opt = OptDict()
|
||||
|
||||
for k, v in self._defaults.iteritems():
|
||||
for k, v in self._defaults.items():
|
||||
k = self._aliases[k]
|
||||
opt[k] = v
|
||||
|
||||
@ -210,6 +210,6 @@ class Options:
|
||||
else:
|
||||
v = _intify(v)
|
||||
opt[k] = v
|
||||
for (f1, f2) in self._aliases.iteritems():
|
||||
for (f1, f2) in self._aliases.items():
|
||||
opt[f1] = opt._opts.get(f2)
|
||||
return (opt, flags, extra)
|
||||
|
@ -9,7 +9,7 @@ import os
|
||||
import sshuttle.ssnet as ssnet
|
||||
import sshuttle.helpers as helpers
|
||||
import sshuttle.hostwatch as hostwatch
|
||||
import sshuttle.compat.ssubprocess as ssubprocess
|
||||
import subprocess as ssubprocess
|
||||
from sshuttle.ssnet import Handler, Proxy, Mux, MuxWrapper
|
||||
from sshuttle.helpers import log, debug1, debug2, debug3, Fatal, \
|
||||
resolvconf_random_nameserver
|
||||
@ -148,7 +148,7 @@ class DnsProxy(Handler):
|
||||
debug2('DNS: sending to %r\n' % self.peer)
|
||||
try:
|
||||
self.sock.send(self.request)
|
||||
except socket.error, e:
|
||||
except socket.error as e:
|
||||
if e.args[0] in ssnet.NET_ERRS:
|
||||
# might have been spurious; try again.
|
||||
# Note: these errors sometimes are reported by recv(),
|
||||
@ -163,7 +163,7 @@ class DnsProxy(Handler):
|
||||
def callback(self):
|
||||
try:
|
||||
data = self.sock.recv(4096)
|
||||
except socket.error, e:
|
||||
except socket.error as e:
|
||||
if e.args[0] in ssnet.NET_ERRS:
|
||||
# might have been spurious; try again.
|
||||
# Note: these errors sometimes are reported by recv(),
|
||||
@ -195,14 +195,14 @@ class UdpProxy(Handler):
|
||||
debug2('UDP: sending to %r port %d\n' % dstip)
|
||||
try:
|
||||
self.sock.sendto(data, dstip)
|
||||
except socket.error, e:
|
||||
except socket.error as e:
|
||||
log('UDP send to %r port %d: %s\n' % (dstip[0], dstip[1], e))
|
||||
return
|
||||
|
||||
def callback(self):
|
||||
try:
|
||||
data, peer = self.sock.recvfrom(4096)
|
||||
except socket.error, e:
|
||||
except socket.error as e:
|
||||
log('UDP recv from %r port %d: %s\n' % (peer[0], peer[1], e))
|
||||
return
|
||||
debug2('UDP response: %d bytes\n' % len(data))
|
||||
@ -322,13 +322,13 @@ def main():
|
||||
|
||||
if dnshandlers:
|
||||
now = time.time()
|
||||
for channel, h in dnshandlers.items():
|
||||
for channel, h in list(dnshandlers.items()):
|
||||
if h.timeout < now or not h.ok:
|
||||
debug3('expiring dnsreqs channel=%d\n' % channel)
|
||||
del dnshandlers[channel]
|
||||
h.ok = False
|
||||
if udphandlers:
|
||||
for channel, h in udphandlers.items():
|
||||
for channel, h in list(udphandlers.items()):
|
||||
if not h.ok:
|
||||
debug3('expiring UDP channel=%d\n' % channel)
|
||||
del udphandlers[channel]
|
||||
|
@ -4,7 +4,7 @@ import re
|
||||
import socket
|
||||
import zlib
|
||||
import imp
|
||||
import sshuttle.compat.ssubprocess as ssubprocess
|
||||
import subprocess as ssubprocess
|
||||
import sshuttle.helpers as helpers
|
||||
from sshuttle.helpers import debug2
|
||||
|
||||
@ -40,7 +40,7 @@ def readfile(name):
|
||||
if f is not None:
|
||||
f.close()
|
||||
|
||||
return contents
|
||||
return contents.encode("UTF8")
|
||||
|
||||
|
||||
def empackage(z, name, data=None):
|
||||
@ -48,7 +48,8 @@ def empackage(z, name, data=None):
|
||||
data = readfile(name)
|
||||
content = z.compress(data)
|
||||
content += z.flush(zlib.Z_SYNC_FLUSH)
|
||||
return '%s\n%d\n%s' % (name, len(content), content)
|
||||
|
||||
return b'%s\n%d\n%s' % (name.encode("ASCII"), len(content), content)
|
||||
|
||||
|
||||
def connect(ssh_cmd, rhostport, python, stderr, options):
|
||||
@ -77,16 +78,15 @@ def connect(ssh_cmd, rhostport, python, stderr, options):
|
||||
|
||||
z = zlib.compressobj(1)
|
||||
content = readfile('sshuttle.assembler')
|
||||
optdata = ''.join("%s=%r\n" % (k, v) for (k, v) in options.items())
|
||||
optdata = ''.join("%s=%r\n" % (k, v) for (k, v) in list(options.items()))
|
||||
optdata = optdata.encode("UTF8")
|
||||
content2 = (empackage(z, 'sshuttle') +
|
||||
empackage(z, 'sshuttle.cmdline_options', optdata) +
|
||||
empackage(z, 'sshuttle.helpers') +
|
||||
empackage(z, 'sshuttle.compat') +
|
||||
empackage(z, 'sshuttle.compat.ssubprocess') +
|
||||
empackage(z, 'sshuttle.ssnet') +
|
||||
empackage(z, 'sshuttle.hostwatch') +
|
||||
empackage(z, 'sshuttle.server') +
|
||||
"\n")
|
||||
b"\n")
|
||||
|
||||
pyscript = r"""
|
||||
import sys;
|
||||
|
@ -75,7 +75,7 @@ def _fds(l):
|
||||
def _nb_clean(func, *args):
|
||||
try:
|
||||
return func(*args)
|
||||
except OSError, e:
|
||||
except OSError as e:
|
||||
if e.errno not in (errno.EWOULDBLOCK, errno.EAGAIN):
|
||||
raise
|
||||
else:
|
||||
@ -88,7 +88,7 @@ def _try_peername(sock):
|
||||
pn = sock.getpeername()
|
||||
if pn:
|
||||
return '%s:%s' % (pn[0], pn[1])
|
||||
except socket.error, e:
|
||||
except socket.error as e:
|
||||
if e.args[0] not in (errno.ENOTCONN, errno.ENOTSOCK):
|
||||
raise
|
||||
return 'unknown'
|
||||
@ -144,7 +144,7 @@ class SockWrapper:
|
||||
self.rsock.connect(self.connect_to)
|
||||
# connected successfully (Linux)
|
||||
self.connect_to = None
|
||||
except socket.error, e:
|
||||
except socket.error as e:
|
||||
debug3('%r: connect result: %s\n' % (self, e))
|
||||
if e.args[0] == errno.EINVAL:
|
||||
# this is what happens when you call connect() on a socket
|
||||
@ -191,7 +191,7 @@ class SockWrapper:
|
||||
self.shut_write = True
|
||||
try:
|
||||
self.wsock.shutdown(SHUT_WR)
|
||||
except socket.error, e:
|
||||
except socket.error as e:
|
||||
self.seterr('nowrite: %s' % e)
|
||||
|
||||
def too_full(self):
|
||||
@ -203,7 +203,7 @@ class SockWrapper:
|
||||
self.wsock.setblocking(False)
|
||||
try:
|
||||
return _nb_clean(os.write, self.wsock.fileno(), buf)
|
||||
except OSError, e:
|
||||
except OSError as e:
|
||||
if e.errno == errno.EPIPE:
|
||||
debug1('%r: uwrite: got EPIPE\n' % self)
|
||||
self.nowrite()
|
||||
@ -225,9 +225,9 @@ class SockWrapper:
|
||||
self.rsock.setblocking(False)
|
||||
try:
|
||||
return _nb_clean(os.read, self.rsock.fileno(), 65536)
|
||||
except OSError, e:
|
||||
except OSError as e:
|
||||
self.seterr('uread: %s' % e)
|
||||
return '' # unexpected error... we'll call it EOF
|
||||
return b'' # unexpected error... we'll call it EOF
|
||||
|
||||
def fill(self):
|
||||
if self.buf:
|
||||
@ -235,7 +235,7 @@ class SockWrapper:
|
||||
rb = self.uread()
|
||||
if rb:
|
||||
self.buf.append(rb)
|
||||
if rb == '': # empty string means EOF; None means temporarily empty
|
||||
if rb == b'': # empty string means EOF; None means temporarily empty
|
||||
self.noread()
|
||||
|
||||
def copy_to(self, outwrap):
|
||||
@ -333,15 +333,15 @@ class Mux(Handler):
|
||||
self.channels = {}
|
||||
self.chani = 0
|
||||
self.want = 0
|
||||
self.inbuf = ''
|
||||
self.inbuf = b''
|
||||
self.outbuf = []
|
||||
self.fullness = 0
|
||||
self.too_full = False
|
||||
self.send(0, CMD_PING, 'chicken')
|
||||
self.send(0, CMD_PING, b'chicken')
|
||||
|
||||
def next_channel(self):
|
||||
# channel 0 is special, so we never allocate it
|
||||
for timeout in xrange(1024):
|
||||
for timeout in range(1024):
|
||||
self.chani += 1
|
||||
if self.chani > MAX_CHANNEL:
|
||||
self.chani = 1
|
||||
@ -357,7 +357,7 @@ class Mux(Handler):
|
||||
def check_fullness(self):
|
||||
if self.fullness > 32768:
|
||||
if not self.too_full:
|
||||
self.send(0, CMD_PING, 'rttest')
|
||||
self.send(0, CMD_PING, b'rttest')
|
||||
self.too_full = True
|
||||
#ob = []
|
||||
# for b in self.outbuf:
|
||||
@ -366,9 +366,9 @@ class Mux(Handler):
|
||||
#log('outbuf: %d %r\n' % (self.amount_queued(), ob))
|
||||
|
||||
def send(self, channel, cmd, data):
|
||||
data = str(data)
|
||||
assert(len(data) <= 65535)
|
||||
p = struct.pack('!ccHHH', 'S', 'S', channel, cmd, len(data)) + data
|
||||
assert isinstance(data, bytes)
|
||||
assert len(data) <= 65535
|
||||
p = struct.pack('!ccHHH', b'S', b'S', channel, cmd, len(data)) + data
|
||||
self.outbuf.append(p)
|
||||
debug2(' > channel=%d cmd=%s len=%d (fullness=%d)\n'
|
||||
% (channel, cmd_to_name.get(cmd, hex(cmd)),
|
||||
@ -435,10 +435,10 @@ class Mux(Handler):
|
||||
self.rsock.setblocking(False)
|
||||
try:
|
||||
b = _nb_clean(os.read, self.rsock.fileno(), 32768)
|
||||
except OSError, e:
|
||||
except OSError as e:
|
||||
raise Fatal('other end: %r' % e)
|
||||
#log('<<< %r\n' % b)
|
||||
if b == '': # EOF
|
||||
if b == b'': # EOF
|
||||
self.ok = False
|
||||
if b:
|
||||
self.inbuf += b
|
||||
@ -451,8 +451,8 @@ class Mux(Handler):
|
||||
if len(self.inbuf) >= (self.want or HDR_LEN):
|
||||
(s1, s2, channel, cmd, datalen) = \
|
||||
struct.unpack('!ccHHH', self.inbuf[:HDR_LEN])
|
||||
assert(s1 == 'S')
|
||||
assert(s2 == 'S')
|
||||
assert(s1 == b'S')
|
||||
assert(s2 == b'S')
|
||||
self.want = datalen + HDR_LEN
|
||||
if self.want and len(self.inbuf) >= self.want:
|
||||
data = self.inbuf[HDR_LEN:self.want]
|
||||
@ -494,18 +494,21 @@ class MuxWrapper(SockWrapper):
|
||||
|
||||
def noread(self):
|
||||
if not self.shut_read:
|
||||
debug2('%r: done reading\n' % self)
|
||||
self.shut_read = True
|
||||
self.mux.send(self.channel, CMD_TCP_STOP_SENDING, '')
|
||||
self.mux.send(self.channel, CMD_TCP_STOP_SENDING, b'')
|
||||
self.maybe_close()
|
||||
|
||||
def nowrite(self):
|
||||
if not self.shut_write:
|
||||
debug2('%r: done writing\n' % self)
|
||||
self.shut_write = True
|
||||
self.mux.send(self.channel, CMD_TCP_EOF, '')
|
||||
self.mux.send(self.channel, CMD_TCP_EOF, b'')
|
||||
self.maybe_close()
|
||||
|
||||
def maybe_close(self):
|
||||
if self.shut_read and self.shut_write:
|
||||
debug2('%r: closing connection\n' % self)
|
||||
# remove the mux's reference to us. The python garbage collector
|
||||
# will then be able to reap our object.
|
||||
self.mux.channels[self.channel] = None
|
||||
@ -523,7 +526,7 @@ class MuxWrapper(SockWrapper):
|
||||
|
||||
def uread(self):
|
||||
if self.shut_read:
|
||||
return '' # EOF
|
||||
return b'' # EOF
|
||||
else:
|
||||
return None # no data available right now
|
||||
|
||||
@ -552,7 +555,7 @@ def runonce(handlers, mux):
|
||||
r = []
|
||||
w = []
|
||||
x = []
|
||||
to_remove = filter(lambda s: not s.ok, handlers)
|
||||
to_remove = [s for s in handlers if not s.ok]
|
||||
for h in to_remove:
|
||||
handlers.remove(h)
|
||||
|
||||
|
@ -1,6 +1,6 @@
|
||||
import sys
|
||||
import os
|
||||
from compat import ssubprocess
|
||||
import subprocess as ssubprocess
|
||||
|
||||
|
||||
_p = None
|
||||
|
@ -25,10 +25,10 @@ while 1:
|
||||
count += 1
|
||||
if count >= 16384:
|
||||
count = 1
|
||||
print 'cli CREATING %d' % count
|
||||
print('cli CREATING %d' % count)
|
||||
b = struct.pack('I', count) + 'x' * count
|
||||
remain[c] = count
|
||||
print 'cli >> %r' % len(b)
|
||||
print('cli >> %r' % len(b))
|
||||
c.send(b)
|
||||
c.shutdown(socket.SHUT_WR)
|
||||
clients.append(c)
|
||||
@ -36,7 +36,7 @@ while 1:
|
||||
time.sleep(0.1)
|
||||
else:
|
||||
r = [listener] + servers + clients
|
||||
print 'select(%d)' % len(r)
|
||||
print('select(%d)' % len(r))
|
||||
r, w, x = select.select(r, [], [], 5)
|
||||
assert(r)
|
||||
for i in r:
|
||||
@ -45,7 +45,7 @@ while 1:
|
||||
servers.append(s)
|
||||
elif i in servers:
|
||||
b = i.recv(4096)
|
||||
print 'srv << %r' % len(b)
|
||||
print('srv << %r' % len(b))
|
||||
if not i in remain:
|
||||
assert(len(b) >= 4)
|
||||
want = struct.unpack('I', b[:4])[0]
|
||||
@ -54,34 +54,34 @@ while 1:
|
||||
else:
|
||||
want = remain[i]
|
||||
if want < len(b):
|
||||
print 'weird wanted %d bytes, got %d: %r' % (want, len(b), b)
|
||||
print('weird wanted %d bytes, got %d: %r' % (want, len(b), b))
|
||||
assert(want >= len(b))
|
||||
want -= len(b)
|
||||
remain[i] = want
|
||||
if not b: # EOF
|
||||
if want:
|
||||
print 'weird: eof but wanted %d more' % want
|
||||
print('weird: eof but wanted %d more' % want)
|
||||
assert(want == 0)
|
||||
i.close()
|
||||
servers.remove(i)
|
||||
del remain[i]
|
||||
else:
|
||||
print 'srv >> %r' % len(b)
|
||||
print('srv >> %r' % len(b))
|
||||
i.send('y' * len(b))
|
||||
if not want:
|
||||
i.shutdown(socket.SHUT_WR)
|
||||
elif i in clients:
|
||||
b = i.recv(4096)
|
||||
print 'cli << %r' % len(b)
|
||||
print('cli << %r' % len(b))
|
||||
want = remain[i]
|
||||
if want < len(b):
|
||||
print 'weird wanted %d bytes, got %d: %r' % (want, len(b), b)
|
||||
print('weird wanted %d bytes, got %d: %r' % (want, len(b), b))
|
||||
assert(want >= len(b))
|
||||
want -= len(b)
|
||||
remain[i] = want
|
||||
if not b: # EOF
|
||||
if want:
|
||||
print 'weird: eof but wanted %d more' % want
|
||||
print('weird: eof but wanted %d more' % want)
|
||||
assert(want == 0)
|
||||
i.close()
|
||||
clients.remove(i)
|
||||
|
@ -60,7 +60,7 @@ class Callback:
|
||||
class Runner:
|
||||
|
||||
def __init__(self, argv, logfunc, promptfunc, serverobj):
|
||||
print 'in __init__'
|
||||
print('in __init__')
|
||||
self.id = argv
|
||||
self.rv = None
|
||||
self.pid = None
|
||||
@ -70,14 +70,14 @@ class Runner:
|
||||
self.serverobj = serverobj
|
||||
self.buf = ''
|
||||
self.logfunc('\nConnecting to %s.\n' % self.serverobj.host())
|
||||
print 'will run: %r' % argv
|
||||
print('will run: %r' % argv)
|
||||
self.serverobj.setConnected_(False)
|
||||
pid, fd = pty.fork()
|
||||
if pid == 0:
|
||||
# child
|
||||
try:
|
||||
os.execvp(argv[0], argv)
|
||||
except Exception, e:
|
||||
except Exception as e:
|
||||
sys.stderr.write('failed to start: %r\n' % e)
|
||||
raise
|
||||
finally:
|
||||
@ -107,7 +107,7 @@ class Runner:
|
||||
self.serverobj.setConnected_(False)
|
||||
self.serverobj.setError_('VPN process died')
|
||||
self.logfunc('Disconnected.\n')
|
||||
print 'wait_result: %r' % self.rv
|
||||
print('wait_result: %r' % self.rv)
|
||||
return self.rv
|
||||
|
||||
def wait(self):
|
||||
@ -121,14 +121,14 @@ class Runner:
|
||||
|
||||
def kill(self):
|
||||
assert(self.pid > 0)
|
||||
print 'killing: pid=%r rv=%r' % (self.pid, self.rv)
|
||||
print('killing: pid=%r rv=%r' % (self.pid, self.rv))
|
||||
if self.rv is None:
|
||||
self.logfunc('Disconnecting from %s.\n' % self.serverobj.host())
|
||||
os.kill(self.pid, 15)
|
||||
self.wait()
|
||||
|
||||
def gotdata(self, notification):
|
||||
print 'gotdata!'
|
||||
print('gotdata!')
|
||||
d = str(self.file.availableData())
|
||||
if d:
|
||||
self.logfunc(d)
|
||||
@ -171,18 +171,18 @@ class SshuttleController(NSObject):
|
||||
|
||||
def _connect(self, server):
|
||||
host = server.host()
|
||||
print 'connecting %r' % host
|
||||
print('connecting %r' % host)
|
||||
self.fill_menu()
|
||||
|
||||
def logfunc(msg):
|
||||
print 'log! (%d bytes)' % len(msg)
|
||||
print('log! (%d bytes)' % len(msg))
|
||||
self.logField.textStorage()\
|
||||
.appendAttributedString_(NSAttributedString.alloc()
|
||||
.initWithString_(msg))
|
||||
self.logField.didChangeText()
|
||||
|
||||
def promptfunc(prompt):
|
||||
print 'prompt! %r' % prompt
|
||||
print('prompt! %r' % prompt)
|
||||
return askpass.askpass(prompt)
|
||||
nets_mode = server.autoNets()
|
||||
if nets_mode == models.NET_MANUAL:
|
||||
@ -206,7 +206,7 @@ class SshuttleController(NSObject):
|
||||
|
||||
def _disconnect(self, server):
|
||||
host = server.host()
|
||||
print 'disconnecting %r' % host
|
||||
print('disconnecting %r' % host)
|
||||
conn = self.conns.get(host)
|
||||
if conn:
|
||||
conn.kill()
|
||||
|
@ -89,7 +89,7 @@ class SshuttleServer(NSObject):
|
||||
return getattr(self, '_k_connected', False)
|
||||
|
||||
def setConnected_(self, v):
|
||||
print 'setConnected of %r to %r' % (self, v)
|
||||
print('setConnected of %r to %r' % (self, v))
|
||||
self._k_connected = v
|
||||
if v:
|
||||
self.setError_(None) # connected ok, so no error
|
||||
|
@ -53,7 +53,7 @@ def DelayedCallback(func, *args, **kwargs):
|
||||
|
||||
def _go():
|
||||
if flag[0]:
|
||||
print 'running %r (flag=%r)' % (func, flag)
|
||||
print('running %r (flag=%r)' % (func, flag))
|
||||
flag[0] = 0
|
||||
func(*args, **kwargs)
|
||||
|
||||
|
Loading…
Reference in New Issue
Block a user