#
+
import select
import sys
import os
import time
def ipfmt(ip):
- ipbytes = map(ord,ip.decode("hex"))
+ ipbytes = list(map(ord,ip.decode("hex")))
return '.'.join(map(str,ipbytes))
tagtype = {
buf,
))
-_padmap = [ chr(padding) * padding for padding in xrange(127) ]
+_padmap = [ chr(padding) * padding for padding in range(127) ]
del padding
def encrypt(packet, crypter, len=len, padmap=_padmap):
padding = ord(packet[-1])
if not (0 < padding <= crypter.block_size):
# wrong padding
- raise RuntimeError, "Truncated packet %s"
+ raise RuntimeError("Truncated packet %s")
packet = packet[:-padding]
return packet
if stderr is not None:
if crypto_mode:
- print >>stderr, "Packets are transmitted in CIPHER"
+ print("Packets are transmitted in CIPHER", file=stderr)
else:
- print >>stderr, "Packets are transmitted in PLAINTEXT"
+ print("Packets are transmitted in PLAINTEXT", file=stderr)
if hasattr(remote, 'fileno'):
remote_fd = remote.fileno()
try:
rdrdy, wrdy, errs = select(rset,wset,eset,1)
- except selecterror, e:
+ except selecterror as e:
if e.args[0] == errno.EINTR:
# just retry
continue
sent = 0
try:
try:
- for x in xrange(maxbatch):
+ for x in range(maxbatch):
packet = pullPacket(fwbuf)
if crypto_mode:
if not rnonblock or not fpacketReady(fwbuf):
break
- except OSError,e:
+ except OSError as e:
# This except handles the entire While block on PURPOSE
# as an optimization (setting a try/except block is expensive)
# The only operation that can raise this exception is rwrite
bwfree -= sent
if tun in wrdy:
try:
- for x in xrange(maxtbatch):
+ for x in range(maxtbatch):
packet = pullPacket(bkbuf)
twrite(tunfd, packet)
#wt += 1
if slowlocal:
# Give some time for the kernel to process the packets
time.sleep(0)
- except OSError,e:
+ except OSError as e:
# This except handles the entire While block on PURPOSE
# as an optimization (setting a try/except block is expensive)
# The only operation that can raise this exception is os_write
# check incoming data packets
if tun in rdrdy:
try:
- for x in xrange(maxbatch):
+ for x in range(maxbatch):
packet = tread(tunfd,2000) # tun.read blocks until it gets 2k!
if not packet:
continue
if not tnonblock or len(fwbuf) >= maxfwbuf:
break
- except OSError,e:
+ except OSError as e:
# This except handles the entire While block on PURPOSE
# as an optimization (setting a try/except block is expensive)
# The only operation that can raise this exception is os_read
if remote in rdrdy:
try:
try:
- for x in xrange(maxbatch):
+ for x in range(maxbatch):
packet = rread(remote,2000)
#rr += 1
elif not packet:
if not udp and packet == "":
# Connection broken, try to reconnect (or just die)
- raise RuntimeError, "Connection broken"
+ raise RuntimeError("Connection broken")
else:
continue
if not rnonblock or len(bkbuf) >= maxbkbuf:
break
- except OSError,e:
+ except OSError as e:
# This except handles the entire While block on PURPOSE
# as an optimization (setting a try/except block is expensive)
# The only operation that can raise this exception is rread
if e.errno not in retrycodes:
raise
- except Exception, e:
+ except Exception as e:
if reconnect is not None:
# in UDP mode, sometimes connected sockets can return a connection refused
# on read. Give the caller a chance to reconnect
def udp_connect(TERMINATE, local_addr, local_port, peer_addr, peer_port):
rsock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM, 0)
retrydelay = 1.0
- for i in xrange(30):
+ for i in range(30):
# TERMINATE is a array. An item can be added to TERMINATE, from
# outside this function to force termination of the loop
if TERMINATE:
- raise OSError, "Killed"
+ raise OSError("Killed")
try:
rsock.bind((local_addr, local_port))
break
except socket.error:
# wait a while, retry
- print >>sys.stderr, "%s: Could not bind. Retrying in a sec..." % (time.strftime('%c'),)
+ print("%s: Could not bind. Retrying in a sec..." % (time.strftime('%c'),), file=sys.stderr)
time.sleep(min(30.0,retrydelay))
retrydelay *= 1.1
else:
rsock.bind((local_addr, local_port))
- print >>sys.stderr, "Listening UDP at: %s:%d" % (local_addr, local_port)
- print >>sys.stderr, "Connecting UDP to: %s:%d" % (peer_addr, peer_port)
+ print("Listening UDP at: %s:%d" % (local_addr, local_port), file=sys.stderr)
+ print("Connecting UDP to: %s:%d" % (peer_addr, peer_port), file=sys.stderr)
rsock.connect((peer_addr, peer_port))
return rsock
pass
keepalive_thread = threading.Thread(target=keepalive)
keepalive_thread.start()
- for i in xrange(900):
+ for i in range(900):
if TERMINATE:
- raise OSError, "Killed"
+ raise OSError("Killed")
try:
heartbeat = rsock.recv(10)
break
# will be forever blocked in the connect, so we put a reasonable timeout.
rsock.settimeout(10)
# We wait for
- for i in xrange(30):
+ for i in range(30):
if stop:
break
if TERMINATE:
- raise OSError, "Killed"
+ raise OSError("Killed")
try:
rsock.connect((peer_addr, peer_port))
sock = rsock
break
except socket.error:
# wait a while, retry
- print >>sys.stderr, "%s: Could not connect. Retrying in a sec..." % (time.strftime('%c'),)
+ print("%s: Could not connect. Retrying in a sec..." % (time.strftime('%c'),), file=sys.stderr)
time.sleep(min(30.0,retrydelay))
retrydelay *= 1.1
else:
rsock.connect((peer_addr, peer_port))
sock = rsock
if sock:
- print >>sys.stderr, "tcp_connect: TCP sock connected to remote %s:%s" % (peer_addr, peer_port)
+ print("tcp_connect: TCP sock connected to remote %s:%s" % (peer_addr, peer_port), file=sys.stderr)
sock.settimeout(0)
- print >>sys.stderr, "tcp_connect: disabling NAGLE"
+ print("tcp_connect: disabling NAGLE", file=sys.stderr)
sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
return sock
retrydelay = 1.0
# We try to bind to the local virtual interface.
# It might not exist yet so we wait in a loop.
- for i in xrange(30):
+ for i in range(30):
if stop:
break
if TERMINATE:
- raise OSError, "Killed"
+ raise OSError("Killed")
try:
lsock.bind((local_addr, local_port))
break
except socket.error:
# wait a while, retry
- print >>sys.stderr, "%s: Could not bind. Retrying in a sec..." % (time.strftime('%c'),)
+ print("%s: Could not bind. Retrying in a sec..." % (time.strftime('%c'),), file=sys.stderr)
time.sleep(min(30.0,retrydelay))
retrydelay *= 1.1
else:
lsock.bind((local_addr, local_port))
- print >>sys.stderr, "tcp_listen: TCP sock listening in local sock %s:%s" % (local_addr, local_port)
+ print("tcp_listen: TCP sock listening in local sock %s:%s" % (local_addr, local_port), file=sys.stderr)
# Now we wait until the other side connects.
# The other side might not be ready yet, so we also wait in a loop for timeouts.
timeout = 1
lsock.listen(1)
- for i in xrange(30):
+ for i in range(30):
if TERMINATE:
- raise OSError, "Killed"
+ raise OSError("Killed")
rlist, wlist, xlist = select.select([lsock], [], [], timeout)
if stop:
break
if lsock in rlist:
sock,raddr = lsock.accept()
- print >>sys.stderr, "tcp_listen: TCP connection accepted in local sock %s:%s" % (local_addr, local_port)
+ print("tcp_listen: TCP connection accepted in local sock %s:%s" % (local_addr, local_port), file=sys.stderr)
break
timeout += 5
return sock
rsock.send(hand)
peer_hand = rsock.recv(4)
if not peer_hand:
- print >>sys.stderr, "tcp_handshake: connection reset by peer"
+ print("tcp_handshake: connection reset by peer", file=sys.stderr)
return False
else:
- print >>sys.stderr, "tcp_handshake: hand %r, peer_hand %r" % (hand, peer_hand)
+ print("tcp_handshake: hand %r, peer_hand %r" % (hand, peer_hand), file=sys.stderr)
if hand < peer_hand:
if listen:
win = True
end = False
sock = None
- for i in xrange(0, 50):
+ for i in range(0, 50):
if end:
break
if TERMINATE:
- raise OSError, "Killed"
+ raise OSError("Killed")
hand = struct.pack("!L", random.randint(0, 2**30))
stop = []
lresult = []
end = True
if not sock:
- raise OSError, "Error: tcp_establish could not establish connection."
+ raise OSError("Error: tcp_establish could not establish connection.")
return sock
-
-