def __init__(self, remote, tundev, switch, protocol, keyfile, samcfg=None, loop=None):
"""
"""
self._switch = switch
self._remote_dest = remote
self._tundev = tundev
self._protocol = protocol
self._write_buff = collections.deque()
self._read_buff = collections.deque()
self.loop = loop or asyncio.get_event_loop()
self._bw = 0
self._pps = 0
self._log.debug("creating sam")
if samcfg:
samaddr = (samcfg["controlHost"], samcfg["controlPort"])
dgramaddr = (samcfg["dgramHost"], samcfg["dgramPort"])
dgrambind = (samcfg["dgramBind"], 0)
self._conn = socket.socket(type=socket.SOCK_DGRAM, samaddr=samaddr, dgramaddr=dgramaddr, dgrambind=dgrambind)
else:
self._conn = socket.socket(type=socket.SOCK_DGRAM)
self._conn.bind(keyfile, nickname="samtun")
self._log.debug("sam bound")
self.dest = self._conn.getsocketinfo()
self.loop.add_reader(self._tundev, self._read_tun)
self.loop.add_reader(self._conn, self._read_sock)
self.loop.call_soon(self._pump)
def test_bind(self):
"""
test socket bind
"""
ssock = socket.socket()
ssock.bind(None)
csock = socket.socket()
csock.connect(ssock.getsocketname())
asock, addr = ssock.accept()
asock.close()
csock.close()
ssock.close()
def test_bind(self):
"""
test socket bind
"""
ssock = socket.socket()
ssock.bind(None)
csock = socket.socket()
csock.connect(ssock.getsockname())
asock, addr = ssock.accept()
asock.close()
csock.close()
ssock.close()
def minitest_select(rans,
wans,
eans,
timeout,
f1=None,
f4=None,
c1=None,
c4=None):
"""Mini-unit test for select (Python and I2P sockets).
Calls f1() on socket S1, f4() on socket S4, uses select()
timeout 'timeout'. rans, wans, and eans should be lists
containing indexes 1...6 of the sockets defined below. The
result of i2p.select.select() will be verified against these
lists. After this, calls c1() on S1, and c4() on S4."""
S1 = pysocket.socket(pysocket.AF_INET, pysocket.SOCK_STREAM)
S2 = pysocket.socket(pysocket.AF_INET, pysocket.SOCK_DGRAM)
S3 = pysocket.socket(pysocket.AF_INET, pysocket.SOCK_RAW)
kw = {'in_depth': 0, 'out_depth': 0}
S4 = socket.socket('Fella', socket.SOCK_STREAM, **kw)
S5 = socket.socket('Boar', socket.SOCK_DGRAM, **kw)
S6 = socket.socket('Gehka', socket.SOCK_RAW, **kw)
if f1: f1(S1)
if f4: f4(S4)
L = [S1, S2, S3, S4, S5, S6]
start = time.time()
ans = select.select(L, L, L, timeout)
ans1 = select.select(L, [], [], timeout)
ans2 = select.select([], L, [], timeout)
ans3 = select.select([], [], L, timeout)
end = time.time()
T = end - start
ans = [[L.index(x) + 1 for x in ans[i]] for i in range(3)]
ans1 = [[L.index(x) + 1 for x in ans1[i]] for i in range(3)]
ans2 = [[L.index(x) + 1 for x in ans2[i]] for i in range(3)]
ans3 = [[L.index(x) + 1 for x in ans3[i]] for i in range(3)]
assert ans1[0] == rans
assert ans2[1] == wans
assert ans3[2] == eans
assert ans == [rans, wans, eans]
assert T < 4 * timeout + 0.1
if c1: c1(S1)
if c4: c4(S4)
def getBootstrapListFromEepsite():
try:
dest = shared.config.get('bitmessagesettings', 'bootstrapeepsite')
except:
return []
if not dest or dest == '':
return []
while True:
print 'Getting some defaultKnownNodes from eepsite', dest
try:
S = socket.socket('', socket.SOCK_STREAM)
S.connect(dest)
S.send('GET /bootstrap.json HTTP/1.0\r\n\r\n') # Send request
break
except socket.NetworkError as ne:
print "I2P Network Error:", ne
continue
f = S.makefile() # File object
while True: # Read header
line = f.readline().strip() # Read a line
if line == '': break # Content begins
str = f.read() # Read file object
f.close() # Close file, connection
S.close()
import json
return json.loads(str) # Load list from JSON and return
def __init__(self, netif, tap, switch, protocol, keyfile, samcfg, loop=None):
"""
"""
self._pump_interval = protocol.pumpInterval
self.switch = switch
if tap:
self._frame_type = protocol.FrameType.ETHER
else:
self._frame_type = protocol.FrameType.IP
self._netif = netif
self._protocol = protocol
self._write_buff = collections.deque()
self._read_buff = collections.deque()
self.loop = loop or asyncio.get_event_loop()
self._bw = 0
self._pps = 0
self._log.debug("creating sam")
samaddr = (samcfg["controlHost"], samcfg["controlPort"])
dgramaddr = (samcfg["dgramHost"], samcfg["dgramPort"])
dgrambind = (samcfg["dgramBind"], 0)
self._conn = socket.socket(socket.AF_I2P, type=socket.SOCK_DGRAM, samaddr=samaddr, dgramaddr=dgramaddr, dgrambind=dgrambind)
self._conn.bind(keyfile, **samcfg["opts"])
self._log.debug("sam bound")
self.dest = self._conn.getsocketinfo()
self.loop.add_reader(self._netif, self._read_netif)
self.loop.add_reader(self._conn, self._read_sock)
self.loop.call_soon(self._pump)
def client_func():
# FIXME: i2p.socket.NetworkError('TIMEOUT', '') errors are produced
# for our streams if we use '' for all clients. Why?
C = socket.socket('Bobb', socket.SOCK_STREAM, **kwargs)
C.setblocking(False)
try:
C.connect(serv.dest)
except socket.BlockError:
# One could also use timeout=0.1 and loop
(Rlist, Wlist, Elist) = select.select([C], [C], [C])
if len(Elist) > 0:
assert Elist[0] == C
raise Elist[0].sessobj.err
C.send(msg_to_server)
C.setblocking(True)
rmsg = C.recv(len(msg_to_client), socket.MSG_WAITALL)
if rmsg != msg_to_client:
raise ValueError('message should have been: ' +
repr(msg_to_client) + ' was: ' + repr(rmsg))
C.close()
global client_count, client_lock
# Synchronized
client_lock.acquire()
try: client_count += 1
finally: client_lock.release()
def test_connect(self):
"""
test socket connections
"""
sock = socket.socket()
sock.connect(("psi.i2p", 80))
sock.close()
def test_connect(self):
"""
test socket connections
"""
sock = socket.socket()
sock.connect(("psi.i2p", 80))
sock.close()
def test_connect(self):
"""
test socket connections
"""
sock = socket.socket(socket.AF_I2P)
sock.connect(("str4d.i2p", 80))
sock.close()
def test_connect(self):
"""
test socket connections
"""
sock = socket.socket(socket.AF_I2P)
sock.connect(("str4d.i2p", 80))
sock.close()
def _createListenSocket(self, session=shared.i2psession):
sock = socket.socket(session, socket.SOCK_STREAM)
# This option apparently avoids the TIME_WAIT state so that we can
# rebind faster
# sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
# sock.bind((HOST, PORT))
sock.listen(2)
return sock
def test_connect(self):
"""
test socket connections
"""
sock = socket.socket()
sock.connect(("psi.i2p", 80))
sock.sendall(b'GET / HTTP/1.0\r\n\r\n')
sock.recv(1024)
sock.close()
def test_connect(self):
"""
test socket connections
"""
sock = socket.socket()
sock.connect(("psi.i2p", 80))
sock.sendall(b'GET / HTTP/1.0\r\n\r\n')
sock.recv(1024)
sock.close()
def test_connect(self):
"""
test socket connections
"""
sock = socket.socket()
assert not sock.isConnected()
sock.connect(("psi.i2p", 80))
assert sock.isConnected()
sock.close()
assert not sock.isConnected()
def minitest_select(rans, wans, eans, timeout,
f1=None, f4=None, c1=None, c4=None):
"""Mini-unit test for select (Python and I2P sockets).
Calls f1() on socket S1, f4() on socket S4, uses select()
timeout 'timeout'. rans, wans, and eans should be lists
containing indexes 1...6 of the sockets defined below. The
result of i2p.select.select() will be verified against these
lists. After this, calls c1() on S1, and c4() on S4."""
S1 = pysocket.socket(pysocket.AF_INET, pysocket.SOCK_STREAM)
S2 = pysocket.socket(pysocket.AF_INET, pysocket.SOCK_DGRAM)
S3 = pysocket.socket(pysocket.AF_INET, pysocket.SOCK_RAW)
kw = {'in_depth':0, 'out_depth':0}
S4 = socket.socket('Fella', socket.SOCK_STREAM, **kw)
S5 = socket.socket('Boar', socket.SOCK_DGRAM, **kw)
S6 = socket.socket('Gehka', socket.SOCK_RAW, **kw)
if f1: f1(S1)
if f4: f4(S4)
L = [S1, S2, S3, S4, S5, S6]
start = time.time()
ans = select.select(L, L, L, timeout)
ans1 = select.select(L, [], [], timeout)
ans2 = select.select([], L, [], timeout)
ans3 = select.select([], [], L, timeout)
end = time.time()
T = end - start
ans = [[L.index(x) + 1 for x in ans [i]] for i in range(3)]
ans1 = [[L.index(x) + 1 for x in ans1[i]] for i in range(3)]
ans2 = [[L.index(x) + 1 for x in ans2[i]] for i in range(3)]
ans3 = [[L.index(x) + 1 for x in ans3[i]] for i in range(3)]
assert ans1[0] == rans
assert ans2[1] == wans
assert ans3[2] == eans
assert ans == [rans, wans, eans]
assert T < 4 * timeout + 0.1
if c1: c1(S1)
if c4: c4(S4)
def multi_stream_test(n):
"""See if we can have n streams open at once."""
server = None
client = [None] * n
kwargs = {'in_depth': 0, 'out_depth': 0}
server = socket.socket('Aligi',socket.SOCK_STREAM,**kwargs)
server.listen(n)
for i in range(n):
client[i] = socket.socket('Bobo', socket.SOCK_STREAM, \
in_depth=0, out_depth=0)
for i in range(n):
client[i].connect(server.dest)
client[i].send('Hi')
for i in range(n):
client[i].close()
server.close()
test_passed(str(n) + ' streams open at once')
def stream_client(dest):
"""Sub-unit test for socket.socket in SOCK_STREAM mode."""
S = socket.socket('Alice', socket.SOCK_STREAM)
S.connect(dest)
S.send('GET / HTTP/1.0\r\n\r\n') # Send request
f = S.makefile() # File object
while True: # Read header
line = f.readline().strip() # Read a line
if line == '': break # Content begins
s = f.read() # Get content
f.close()
S.close()
def main():
"""
main driver
"""
import argparse
ap = argparse.ArgumentParser()
ap.add_argument('--listen', action='store_const', const=True, default=False)
ap.add_argument('--debug', action='store_const', const=True, default=False)
ap.add_argument('--host', default='psi.i2p')
ap.add_argument('--port', default=80, type=int)
args = ap.parse_args()
lvl = logging.INFO
if args.debug:
lvl = logging.DEBUG
logging.basicConfig(level=lvl)
log = logging.getLogger("i2p.socket")
log.debug("wait for interface to be up")
# wait for the interface to go up
socket.get_default_interface().up()
log.debug(socket.get_default_interface().dest)
if args.listen:
while args.listen:
time.sleep(1)
try:
log.debug("create socket")
# make the socket
sock = socket.socket()
# run it
log.debug("connect")
sock.connect((args.host, args.port))
log.debug("send")
data = 'GET / HTTP/1.1\r\nHost: {}\r\n\r\n'.format(args.host).encode("utf-8")
sock.send(data)
log.debug("sent")
sock.close()
log.debug("closed")
except Exception as e:
log.error(e)
traceback.print_exc(e)
finally:
socket.close()
def __init__(self,
netif,
tap,
switch,
protocol,
keyfile,
samcfg,
loop=None):
"""
"""
self._pump_interval = protocol.pumpInterval
self.switch = switch
if tap:
self._frame_type = protocol.FrameType.ETHER
else:
self._frame_type = protocol.FrameType.IP
self._netif = netif
self._protocol = protocol
self._write_buff = collections.deque()
self._read_buff = collections.deque()
self.loop = loop or asyncio.get_event_loop()
self._bw = 0
self._pps = 0
self._log.debug("creating sam")
samaddr = (samcfg["controlHost"], samcfg["controlPort"])
dgramaddr = (samcfg["dgramHost"], samcfg["dgramPort"])
dgrambind = (samcfg["dgramBind"], 0)
self._conn = socket.socket(socket.AF_I2P,
type=socket.SOCK_DGRAM,
samaddr=samaddr,
dgramaddr=dgramaddr,
dgrambind=dgrambind)
self._conn.bind(keyfile, **samcfg["opts"])
self._log.debug("sam bound")
self.dest = self._conn.getsocketinfo()
self.loop.add_reader(self._netif, self._read_netif)
self.loop.add_reader(self._conn, self._read_sock)
self.loop.call_soon(self._pump)
#! /usr/bin/env python
# -----------------------------------------------
# raw_server.py: Raw server
# -----------------------------------------------
from i2p import socket
S = socket.socket('Eve', socket.SOCK_RAW)
print 'Serving at:', S.dest
while True:
data = S.recv(1000) # Read packet
print 'Got', data
#! /usr/bin/env python
# -----------------------------------------------
# datagram.py: Datagram client
# -----------------------------------------------
from i2p import socket
print 'Sending a packet to yourserver.i2p...'
dest = socket.resolve('yourserver.i2p')
S = socket.socket('Bob', socket.SOCK_DGRAM)
S.sendto('Hello packet', 0, dest)
# Get packet up to 1000 bytes -- the rest is discarded.
(data, dest) = S.recvfrom(1000)
print data
import os
from i2p import socket
def get_i2p_server_address():
source = os.popen('curl -fsSL 127.0.0.1:7070/?page=i2p_tunnels').read()
return str(source.split('⇐')).split('<br>')[-3].split(' ')[5]
i2p_addres = get_i2p_server_address()
print('Your i2p server adress: ', i2p_addres)
#основной сокет
print('step 1')
sock = socket.socket()
print('step 2')
sock.bind(('', 2389))
print('step 3')
sock.listen(5)
print('step 4')
conn, addr = sock.accept()
print('step 5')
while True:
data = conn.recv(1024)
if not data:
break
conn.send(data.upper())
conn.close()
def packet_test(raw=True):
"""Unit test for socket.socket in SOCK_DGRAM or SOCK_RAW modes."""
try:
multithread_wait_time = 500.0
may_need_increase = False
kwargs = {'in_depth': 0, 'out_depth': 0}
if raw:
C = socket.socket('Carola', socket.SOCK_RAW, **kwargs)
D = socket.socket('Davey', socket.SOCK_RAW, **kwargs)
else:
C = socket.socket('Carol', socket.SOCK_DGRAM, **kwargs)
D = socket.socket('Dave', socket.SOCK_DGRAM, **kwargs)
global C_recv, D_recv, C_got, D_got, __lock
C_recv = [] # Packets C *should* receive
D_recv = [] # Packets D *should* receive
C_got = [] # Packets C actually got
D_got = [] # Packets D actually got
n = 50 # Create n threads
m = 40 # Each thread sends m packets
global __done_count
__done_count = 0
__lock = threading.Lock()
# Use C and D to send and read in many different threads.
def f():
# This code is run in each separate thread
global C_recv, D_recv, C_got, D_got, __lock, __done_count
for i in range(m):
# Random binary string of length 2-80.
index_list = range(random.randrange(2, 80))
s = ''.join([chr(random.randrange(256)) for j in index_list])
if random.randrange(2) == 0:
# Send packet from C to D, and log it.
C.sendto(s, 0, D.dest)
__lock.acquire()
D_recv += [s]
__lock.release()
else:
# Send packet from D to C, and log it.
D.sendto(s, 0, C.dest)
__lock.acquire()
C_recv += [s]
__lock.release()
time.sleep(0.01*random.uniform(0.0,1.0))
# Read any available packets.
try: (p, fromaddr) = C.recvfrom(1000, socket.MSG_DONTWAIT)
except socket.BlockError: p = None
if p != None and not raw: assert fromaddr == D.dest
__lock.acquire()
if p != None: C_got += [p]
__lock.release()
try: (p, fromaddr) = D.recvfrom(1000, socket.MSG_DONTWAIT)
except socket.BlockError: p = None
if p != None and not raw: assert fromaddr == C.dest
__lock.acquire()
if p != None: D_got += [p]
__lock.release()
__lock.acquire()
__done_count += 1
__lock.release()
# Create n threads.
for i in range(n):
threading.Thread(target=f).start()
# Wait for them to finish.
while __done_count < n: time.sleep(0.01)
# Read any left-over received packets.
end_time = time.time() + multithread_wait_time
while time.time() < end_time:
# Read any available packets.
try: (p, fromaddr) = C.recvfrom(1000, socket.MSG_DONTWAIT)
except socket.BlockError: p = None
if p != None and not raw: assert fromaddr == D.dest
if p != None: C_got += [p]
try: (p, fromaddr) = D.recvfrom(1000, socket.MSG_DONTWAIT)
except socket.BlockError: p = None
if p != None and not raw: assert fromaddr == C.dest
if p != None: D_got += [p]
if len(C_got) == len(C_recv) and len(D_got) == len(D_recv):
break
if time.time() >= end_time:
may_need_increase = True
C_got.sort()
D_got.sort()
C_recv.sort()
D_recv.sort()
assert C_got == C_recv
assert D_got == D_recv
C.close()
D.close()
except:
if raw:
print 'Unit test failed for socket.socket (SOCK_RAW).'
print 'Raw packets are not reliable.'
else:
print 'Unit test failed for socket.socket (SOCK_DGRAM).'
print 'Datagram packets are not reliable.'
if may_need_increase:
print 'Try increasing multithread_wait_time.'
traceback.print_exc(); sys.exit()
if raw:
test_passed('socket.socket (SOCK_RAW)')
else:
test_passed('socket.socket (SOCK_DGRAM)')
def f():
while True:
S = socket.socket(dest, socket.SOCK_STREAM)
S.connect(dest)
S.send('GET / HTTP/1.0\r\n\r\n')
S.close()
#! /usr/bin/env python
# -----------------------------------------------
# stream_server.py: Simple stream server
# -----------------------------------------------
import i2p
from i2p import socket
S = socket.socket('Dave', socket.SOCK_STREAM)
S.listen(10) # Queue up to 10 connections
print 'Serving at:', S.dest
while True:
try:
(C, remotedest) = S.accept() # Get a connection
f = C.makefile() # File object
req = f.readline() # Read HTTP request
s = '<h1>Hello!</h1>' # String to send back
f.write('HTTP/1.0 200 OK\r\nContent-Type: text/html' +
'\r\nContent-Length: ' + str(int(len(s))) + '\r\n\r\n' + s)
f.close() # Close file
C.close() # Close connection
except socket.Error, e:
# Recover from socket errors
print 'Warning:', str(e)
def stream_test():
"""Multithreaded unit test for socket.socket (SOCK_STREAM)."""
try:
multithread_wait_time = 200.0
may_need_increase = False
kwargs = {'in_depth':0, 'out_depth':0}
C = socket.socket('Carolic', socket.SOCK_STREAM, **kwargs)
D = socket.socket('David', socket.SOCK_STREAM, **kwargs)
Cout = socket.socket('Carolic', socket.SOCK_STREAM, **kwargs)
Dout = socket.socket('David', socket.SOCK_STREAM, **kwargs)
assert C.dest == Cout.dest
assert D.dest == Dout.dest
C.listen(5)
D.listen(5)
Cout.connect(D.dest)
Dout.connect(C.dest)
(Cin, ignoredest) = C.accept()
(Din, ignoredest) = D.accept()
global C_recv, D_recv, C_got, D_got, __lock
C_recv = [] # String data C *should* receive
D_recv = [] # String data D *should* receive
C_got = [] # String data C actually got
D_got = [] # String data D actually got
n = 50 # Create n threads
m = 40 # Each thread sends m strings
global __done_count
__done_count = 0
__lock = threading.Lock()
# Use C and D to send and read in many different threads.
def f():
# This code is run in each separate thread
global C_recv, D_recv, C_got, D_got, __lock, __done_count
for i in range(m):
# Random binary string of length 2-80.
index_list = range(random.randrange(2, 80))
s = ''.join([chr(random.randrange(256)) for j in index_list])
if random.randrange(2) == 0:
# Send packet from C to D, and log it.
__lock.acquire()
Cout.send(s)
D_recv += [s]
__lock.release()
else:
# Send packet from D to C, and log it.
__lock.acquire()
Dout.send(s)
C_recv += [s]
__lock.release()
time.sleep(0.01*random.uniform(0.0,1.0))
# Read any available string data, non-blocking.
__lock.acquire()
try: p = Cin.recv(100000, socket.MSG_DONTWAIT)
except socket.BlockError: p = None
if p != None: C_got += [p]
__lock.release()
__lock.acquire()
try: p = Din.recv(100000, socket.MSG_DONTWAIT)
except socket.BlockError: p = None
if p != None: D_got += [p]
__lock.release()
__lock.acquire()
__done_count += 1
__lock.release()
# Create n threads.
for i in range(n):
threading.Thread(target=f).start()
# Wait for them to finish.
while __done_count < n: time.sleep(0.01)
# Read any left-over received string data.
end_time = time.time() + multithread_wait_time
while time.time() < end_time:
# Read any available string data, non-blocking.
try: p = Cin.recv(100000, socket.MSG_DONTWAIT)
except socket.BlockError: p = None
if p != None: C_got += [p]
try: p = Din.recv(100000, socket.MSG_DONTWAIT)
except socket.BlockError: p = None
if p != None: D_got += [p]
if len(''.join(C_got)) == len(''.join(C_recv)) and \
len(''.join(D_got)) == len(''.join(D_recv)):
break
if time.time() >= end_time:
may_need_increase = True
C_got = ''.join(C_got)
D_got = ''.join(D_got)
C_recv = ''.join(C_recv)
D_recv = ''.join(D_recv)
assert C_got == C_recv
assert D_got == D_recv
Cin.close()
Din.close()
Cout.close()
Dout.close()
C.close()
D.close()
except:
print 'Unit test failed for socket.socket ' + \
'(SOCK_STREAM, multithreaded).'
if may_need_increase:
print 'Try increasing multithread_wait_time.'
traceback.print_exc(); sys.exit()
test_passed('socket.socket (SOCK_STREAM, multithreaded)')
from i2p import socket
#sock = socket.socket()
i2plo = socket.socket()
portlol = int(input('Введите порт для локального сервера:'))
#sock.bind(('', portlol))
print('step 2')
#sock.listen()
print('step 3')
#conn, addr = sock.accept()
print('step 4')
i2plo.connect(
("q5vc65lf345bakn6z55csafm2oo7hgnuxqzxoyjoj5hhasmjf2ga.b32.i2p", 2389))
print('step 5')
while (True):
while (True):
login = str(input('Введите логин:'))
if (' ' in login):
print('Не испуользуйте пробел.')
else:
break
while (True):
password = str(input('Введите пароль:'))
if (' ' in password):
print('Не испуользуйте пробел.')
else:
break
while (True):
secretkey = str(input('Введите секретный ключ:'))
if (' ' in secretkey):
print('Не испуользуйте пробел.')
else:
#! /usr/bin/env python
# -----------------------------------------------
# stream_noblock.py: Non-blocking stream server
# -----------------------------------------------
import i2p
from i2p import socket
import thread, time
S = socket.socket('Dave', socket.SOCK_STREAM)
S.listen(10) # Queue up to 10 connections
S.setblocking(False) # Non-blocking
print 'Serving at:', S.dest
def handle_connection(C):
"""Handle a single connection in a thread of its own."""
try:
f = C.makefile() # File object
req = f.readline() # Read HTTP request
s = '<h1>Hello!</h1>' # String to send back
f.write('HTTP/1.0 200 OK\r\nContent-Type: text/html' +
'\r\nContent-Length: ' + str(int(len(s))) + '\r\n\r\n' + s)
f.close() # Close file
C.close() # Close connection
except socket.Error, e:
# Recover from socket errors
#! /usr/bin/env python
# -----------------------------------------------
# stream_eepget.py: Get an eepsite using sockets
# -----------------------------------------------
from i2p import socket
S = socket.socket('Alice', socket.SOCK_STREAM)
S.connect('duck.i2p')
S.send('GET / HTTP/1.0\r\n\r\n') # Send request
f = S.makefile() # File object
while True: # Read header
line = f.readline().strip() # Read a line
if line == '': break # Content begins
print f.read() # Read file object
#! /usr/bin/env python
# -----------------------------------------------
# raw_server.py: Raw server
# -----------------------------------------------
from i2p import socket
S = socket.socket('Eve', socket.SOCK_RAW)
print 'Serving at:', S.dest
while True:
data = S.recv(1000) # Read packet
print 'Got', data
#! /usr/bin/env python
# -----------------------------------------------
# datagram_server.py: Datagram server
# -----------------------------------------------
from i2p import socket
S = socket.socket('Eve', socket.SOCK_DGRAM)
print 'Serving at:', S.dest
while True:
(data, dest) = S.recvfrom(1000) # Read packet
print 'Got', data, 'from', dest
S.sendto('Hi client!', 0, dest)
#! /usr/bin/env python
# -----------------------------------------------
# datagram_server.py: Datagram server
# -----------------------------------------------
from i2p import socket
S = socket.socket('Eve', socket.SOCK_DGRAM)
print 'Serving at:', S.dest
while True:
(data, dest) = S.recvfrom(1000) # Read packet
print 'Got', data, 'from', dest
S.sendto('Hi client!', 0, dest)
def f():
while True:
S = socket.socket(dest, socket.SOCK_STREAM)
S.connect(dest)
S.send('GET / HTTP/1.0\r\n\r\n')
S.close()
def noblock_stream_test():
"""Unit test for non-blocking stream commands and listen."""
kwargs = {'in_depth': 0, 'out_depth': 0}
serv = socket.socket('Allison',socket.SOCK_STREAM,**kwargs)
serv.setblocking(False)
serv.listen(100)
assert serv.gettimeout() == 0.0
msg_to_client = 'Hi, client!!!!'
msg_to_server = 'Hi, server!'
nconnects = 5
global server_done, client_count, client_lock
server_done = False
client_count = 0
client_lock = threading.Lock()
def serv_func(n = nconnects):
while True:
try:
(C, ignoredest) = serv.accept()
C.send(msg_to_client)
rmsg = C.recv(len(msg_to_server), socket.MSG_WAITALL)
if rmsg != msg_to_server:
raise ValueError('message should have been: ' +
repr(msg_to_server) + ' was: ' + repr(rmsg))
C.close()
n -= 1
if n == 0: break
except socket.BlockError:
pass
time.sleep(0.01)
global server_done
server_done = True
def client_func():
# FIXME: i2p.socket.NetworkError('TIMEOUT', '') errors are produced
# for our streams if we use '' for all clients. Why?
C = socket.socket('Bobb', socket.SOCK_STREAM, **kwargs)
C.setblocking(False)
try:
C.connect(serv.dest)
except socket.BlockError:
# One could also use timeout=0.1 and loop
(Rlist, Wlist, Elist) = select.select([C], [C], [C])
if len(Elist) > 0:
assert Elist[0] == C
raise Elist[0].sessobj.err
C.send(msg_to_server)
C.setblocking(True)
rmsg = C.recv(len(msg_to_client), socket.MSG_WAITALL)
if rmsg != msg_to_client:
raise ValueError('message should have been: ' +
repr(msg_to_client) + ' was: ' + repr(rmsg))
C.close()
global client_count, client_lock
# Synchronized
client_lock.acquire()
try: client_count += 1
finally: client_lock.release()
thread.start_new_thread(serv_func, ())
for i in range(nconnects):
thread.start_new_thread(client_func, ())
while True:
if server_done and client_count == nconnects: break
time.sleep(0.01)
test_passed('socket.listen (SOCK_STREAM), and non-blocking IO')
#! /usr/bin/env python
# -----------------------------------------------
# raw.py: Raw client
# -----------------------------------------------
from i2p import socket
dest = socket.resolve('yourserver.i2p') # Send to dest
S = socket.socket('Carol', socket.SOCK_RAW)
S.sendto('Hello packet', 0, dest)
#! /usr/bin/env python
# -----------------------------------------------
# stream.py: Simple stream client
# -----------------------------------------------
from i2p import socket
S = socket.socket('Alice', socket.SOCK_STREAM)
S.connect('duck.i2p')
S.send('GET / HTTP/1.0\r\n\r\n') # Send request
print S.recv(1000) # Read up to 1000 bytes
