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(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() 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()
#! /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 # ----------------------------------------------- # 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 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