def test_connect(self): self.mox.StubOutWithMock(socket, 'create_connection') socket.create_connection(('testhost', 8025), 7).AndReturn(9) self.mox.ReplayAll() conn = HTTPConnection('testhost', 8025, True, 7) conn.connect() assert_equal(9, conn.sock)
def client_connector(backend, local_port, tunnel_data, ready=gevent.event.Event()): while True: init = tunnel_data.pop('init', None) header = copy.copy(tunnel_data) if init: header['new'] = True ready.clear() elif not ready.isSet(): ready.wait() backend_client = create_connection(backend) backend_client.sendall("{0}\n".format(json.dumps(header))) header = recv_json(backend_client) if header and 'banner' in header: print " {0}".format(header['banner']) print " Port {0} is now accessible from http://{1} ...\n".format( local_port, header['host']) ready.set() elif header and 'error' in header: print " ERROR: {0}".format(header['error']) gevent.hub.get_hub().parent.throw(SystemExit(1)) else: try: local_client = create_connection(('0.0.0.0', local_port)) join_sockets(backend_client, local_client) except IOError: backend_client.close()
def test(self): try: socket.create_connection(('localhost', get_port()), timeout=30, source_address=('', get_port())) except socket.error: ex = sys.exc_info()[1] if 'refused' not in str(ex).lower(): raise else: raise AssertionError('create_connection did not raise socket.error as expected')
def connect(self): if hasattr(self, 'source_address') and self.source_address: self.sock = socket.create_connection((self.host, self.port), self.timeout, self.source_address) else: self.sock = socket.create_connection((self.host, self.port), self.timeout) if self._tunnel_host: self._tunnel()
def test_connect(self): self.mox.StubOutWithMock(socket, "create_connection") socket.create_connection(("testhost", 8025), 7).AndReturn(9) self.mox.ReplayAll() # strict HTTPConnection became deprecated if six.PY2: conn = HTTPConnection("testhost", 8025, True, 7) else: conn = HTTPConnection("testhost", 8025, 7) conn.connect() self.assertEqual(9, conn.sock)
def test_connect(self): self.mox.StubOutWithMock(socket, 'create_connection') self.mox.StubOutWithMock(ssl, 'SSLSocket') sslsock = self.mox.CreateMockAnything() socket.create_connection(('testhost', 8025), 7).AndReturn(9) ssl.SSLSocket(9, var='val').AndReturn(sslsock) sslsock.do_handshake() self.mox.ReplayAll() conn = HTTPSConnection('testhost', 8025, {'var': 'val'}, True, 7) conn.connect() assert_equal(sslsock, conn.sock)
def netcat(host, port, proxy_host, proxy_port): request = [('CONNECT %s:%d HTTP/1.1' % (host, port)).encode('ascii')] request.append(('Host: %s:%d' % (host, port)).encode('ascii')) request.append(('Proxy-Connection: Keep-Alive').encode('ascii')) request.append(('\r\n').encode('ascii')) dst = create_connection((proxy_host, proxy_port)) dst.sendall(b'\r\n'.join(request)) data = b'' while True: data += dst.recv(1024) if b'\r\n\r\n' in data: break if b'200 Connection established' not in data and b'407' in data: service = gssapi.Name('HTTP@%s' % proxy_host, gssapi.NameType.hostbased_service) ctx = gssapi.SecurityContext(name=service, usage='initiate') token = ctx.step() b64token = base64.b64encode(token).encode('ascii') request[-1] = ('Proxy-Authorization: Negotiate %s' % b64token).encode('ascii') request.append(('\r\n').encode('ascii')) try: dst.sendall(b'\r\n'.join(request)) except: # if proxy does not support Keep-Alive dst.close() dst = create_connection((proxy_host, proxy_port)) dst.sendall(b'\r\n'.join(request)) data = b'' while True: data += dst.recv(1024) if b'\r\n\r\n' in data: break if b'200 Connection established' in data: sys.stderr.write('Proxy connection established\n') data = data.split(b'\r\n\r\n', 1)[1] if data: dst.sendall(data) forwarders = (gevent.spawn(forward_stdin, dst), gevent.spawn(forward_stdout, dst)) gevent.joinall(forwarders) elif b'407' in data: sys.stderr.write('Proxy authentication failed\n') else: version, status_code, status_message = data.split(b'\r\n', 1)[0].split(b' ', 2) sys.stderr.write('Proxy returned %s %s\n' % (status_code, status_message))
def test_connect(self): self.mox.StubOutWithMock(socket, "create_connection") self.mox.StubOutWithMock(ssl, "SSLSocket") sslsock = self.mox.CreateMockAnything() socket.create_connection(("testhost", 8025), 7).AndReturn(9) ssl.SSLSocket(9, var="val").AndReturn(sslsock) sslsock.do_handshake() self.mox.ReplayAll() # strict HTTPConnection became deprecated if six.PY2: conn = HTTPSConnection("testhost", 8025, {"var": "val"}, True, 7) else: conn = HTTPSConnection("testhost", 8025, {"var": "val"}, 7) conn.connect() self.assertEqual(sslsock, conn.sock)
def stream_data(request): from gevent import socket s = socket.create_connection(("127.0.0.1", 1234)) sf = s.makefile() return StreamingHttpResponse(FileWrapper(sf), content_type='text/plain')
def send_message_to_slave(message, address): try: payload = generate_msgpack_message_payload(message) except TypeError: logger.exception('Failed encoding message %s as msgpack', message) stats['rpc_message_pass_fail_cnt'] += 1 return False pretty_address = '%s:%s' % address message_id = message.get('message_id', '?') try: s = socket.create_connection(address) s.send(payload) sender_resp = msgpack_unpack_msg_from_socket(s) s.close() except socket.error: logging.exception('Failed connecting to %s to send message (ID %s)', pretty_address, message_id) stats['rpc_message_pass_fail_cnt'] += 1 return False if sender_resp == 'OK': logger.info('Successfully passed message (ID %s) to %s for sending', message_id, pretty_address) stats['rpc_message_pass_success_cnt'] += 1 return True else: logger.error('Failed sending message (ID %s) through %s: %s', message_id, pretty_address, sender_resp) stats['rpc_message_pass_fail_cnt'] += 1 return False
def did_it_work(server): client = socket.create_connection((params.DEFAULT_CONNECT, server.getsockname()[1])) fd = client.makefile(mode='rb') client.close() self.assertEqual(fd.readline(), b'hello\n') self.assertFalse(fd.read()) fd.close()
def test_del_closes_socket(self): timer = gevent.Timeout.start_new(0.5) def accept_once(listener): # delete/overwrite the original conn # object, only keeping the file object around # closing the file object should close everything # XXX: This is not exactly true on Python 3. # This produces a ResourceWarning. try: conn, _ = listener.accept() conn = conn.makefile(mode='wb') conn.write(b'hello\n') conn.close() _write_to_closed(conn, b'a') finally: listener.close() server = tcp_listener(('0.0.0.0', 0)) gevent.spawn(accept_once, server) client = socket.create_connection( ('127.0.0.1', server.getsockname()[1])) fd = client.makefile() client.close() assert fd.read() == 'hello\n' assert fd.read() == '' timer.cancel()
def connect(self, timeout=None): if not self._connected: try: sock = socket.create_connection(self._server, timeout) if not self._ssl_enable: self._socket = sock else: self._socket = ssl.wrap_socket( sock, keyfile=self._keyfile, certfile=self._certfile, ca_certs=self._ca_cert, cert_reqs=ssl.CERT_REQUIRED, ssl_version=ssl.PROTOCOL_TLSv1) except socket.error as err_msg: self._socket = None self._handle_event(self.SESSION_ERROR) return -1 else: self._connected = True self._socket.settimeout(None) self._set_socket_options() self._handle_event(self.SESSION_ESTABLISHED) return 0 return 0
def connect(self, hostport): if self.connected: self.disconnect() self.sock = socket.create_connection(hostport) self.conn = ssl.wrap_socket(self.sock) self.connected = True
def create_connection_hosts(addrs, port, timeout): for addr in addrs: try: return socket.create_connection((addr, port), timeout=timeout) except: pass raise socket.error("all addrs are failed.") # @UndefinedVariable
def connect(self, address, remote_pubkey): log.debug('connecting', address=address) log.info('connecting', address=address) """ gevent.socket.create_connection(address, timeout=Timeout, source_address=None) Connect to address (a 2-tuple (host, port)) and return the socket object. Passing the optional timeout parameter will set the timeout getdefaulttimeout() is default """ try: connection = create_connection(address, timeout=self.connect_timeout) except socket.timeout: log.debug('connection timeout', address=address, timeout=self.connect_timeout) self.errors.add(address, 'connection timeout') return False except socket.error as e: log.debug('connection error', errno=e.errno, reason=e.strerror) self.errors.add(address, 'connection error') return False log.debug('connecting to', connection=connection) p = self._start_peer(connection, address, remote_pubkey) p.join() return True
def handle(self, src, addr): data = b'' while True: data += src.recv(1024) if b'\r\n\r\n' in data: break service = gssapi.Name('HTTP@%s' % self.upstream[0], gssapi.NameType.hostbased_service) ctx = gssapi.SecurityContext(name=service, usage='initiate') token = ctx.step() b64token = base64.b64encode(token).encode('ascii') headers, data = data.split(b'\r\n\r\n', 1) headers = headers.split('\r\n') replaced = False for i, header in enumerate(headers): if header.startswith('Proxy-Authorization:'): headers[i] = b'Proxy-Authorization: Negotiate %s' % b64token replaced = True break if not replaced: headers.append(b'Proxy-Authorization: Negotiate %s' % b64token) dst = create_connection(self.upstream) dst.sendall(b'\r\n'.join(headers) + b'\r\n\r\n' + data) forwarders = (gevent.spawn(forward, src, dst), gevent.spawn(forward, dst, src)) gevent.joinall(forwarders)
def test_tracer_attach_timeout(self, mode): """ Tests the case where a tracer attaches but no client does. """ with QdbServer(tracer_host='localhost', tracer_port=0, client_server=QdbNopServer(), attach_timeout=0.01, timeout_disable_mode=mode) as server: tracer = socket.create_connection( ('localhost', server.tracer_server.server_port)) send_tracer_event(tracer, 'start', { 'uuid': 'test', 'auth': '', 'local': (0, 0), }) disable_event = None with Timeout(0.1, False): error_event = recv_tracer_event(tracer) disable_event = recv_tracer_event(tracer) error_dict = fmt_err_msg('client', 'No client') self.assertEqual(error_dict, error_event) self.assertEqual(fmt_msg('disable', mode), disable_event) self.assertNotIn('test', server.session_store)
def test_inactivity_timeout(self, mode): """ Tests that timeout sends a disable message with the proper mode.. """ with QdbServer( tracer_host='localhost', tracer_port=0, client_host='localhost', client_port=0, inactivity_timeout=0.01, # minutes sweep_time=0.01, # seconds timeout_disable_mode=mode) as server: tracer = socket.create_connection( ('localhost', server.tracer_server.server_port)) send_tracer_event(tracer, 'start', { 'uuid': 'test', 'auth': '', 'local': (0, 0), }) client = create_connection('ws://localhost:%d%s' % (server.client_server.server_port, DEFAULT_ROUTE_FMT.format(uuid='test'))) send_client_event(client, 'start', '') self.assertEqual({ 'e': 'start', 'p': '' }, recv_tracer_event(tracer)) self.assertEqual({ 'e': 'disable', 'p': mode }, recv_tracer_event(tracer)) self.assertEqual('disable', recv_client_event(client)['e']) self.assertFalse('test' in server.session_store)
def test_del_closes_socket(self): timer = gevent.Timeout.start_new(0.5) def accept_once(listener): # delete/overwrite the original conn # object, only keeping the file object around # closing the file object should close everything try: conn_, addr = listener.accept() conn = conn_.makefile() conn.write(b('hello\n')) conn.close() conn_.close() if PY3: self.assertRaises(AttributeError, conn.write, b('a')) else: r = conn.write(b('a')) assert r is None, r finally: listener.close() server = tcp_listener(('0.0.0.0', 0)) gevent.spawn(accept_once, server) client = socket.create_connection( ('127.0.0.1', server.getsockname()[1])) fd = client.makefile() client.close() assert fd.read() == b('hello\n') assert fd.read() == b('') timer.cancel()
def connect_with(self, protocol_class: Type[BaseProtocol], host_port: tuple, protocol_args: list, protocol_kwargs: dict) -> (BaseProtocol, socket.socket): """ Helper which creates a new connection and feeds the data stream into a protocol handler class. :rtype: tuple(protocol_class, gevent.socket) :param protocol_class: A handler class which has handler functions like on_connected, consume, and on_connection_lost :param protocol_kwargs: Keyword args to pass to the handler constructor :param protocol_args: Args to pass to the handler constructor :param host_port: (host,port) tuple where to connect """ LOG.info("Will connect to %s", host_port) sock = socket.create_connection(address=host_port) handler = protocol_class(*protocol_args, **protocol_kwargs) handler.on_connected(host_port) LOG.info("Connection to %s established", host_port) try: g = gevent.spawn(_read_loop, proto=handler, sock=sock) g.start() except Exception as e: LOG.error("Exception: %s", traceback.format_exc()) return handler, sock
def test_del_closes_socket(self): if PYPY: return timer = gevent.Timeout.start_new(0.5) def accept_once(listener): # delete/overwrite the original conn # object, only keeping the file object around # closing the file object should close everything try: conn, addr = listener.accept() conn = conn.makefile(mode='wb') conn.write(b'hello\n') conn.close() _write_to_closed(conn, b'a') finally: listener.close() server = tcp_listener(('0.0.0.0', 0)) gevent.spawn(accept_once, server) client = socket.create_connection(('127.0.0.1', server.getsockname()[1])) fd = client.makefile() client.close() assert fd.read() == 'hello\n' assert fd.read() == '' timer.cancel()
def query(self, q, local=False): """ This is a base function for communication with remote database. @param q: str, query to be executed remotely @param local: bool, this argument defines whether given query will be duplicated on local database @return: None when database returned correct NONE response False when there was an error during database communication or error during query execution Those cases are being explicitly notified using self.notify list of string lists when database reponded with some data """ if local: with self.local.connection() as c: c.execute(q) try: s = socket.create_connection(self.addr, timeout=20) s.send(q) answer = s.recv(1024) except socket.error as e: print e.__class__.__name__, e if self.notify: self.notify(_("Database Error"), q.decode('utf8', errors='replace')) return False if answer == 'FAIL': self.notify(_("Query Error"), q.decode('utf8', errors='replace')) return False if answer == 'NONE': return None return [line.split('|') for line in answer.split('\n')]
def did_it_work(server): client = socket.create_connection(('127.0.0.1', server.getsockname()[1])) fd = client.makefile(mode='rb') client.close() assert fd.readline() == b'hello\n' assert fd.read() == b'' fd.close()
def process_main(): for i in range(10000): conn = socket.create_connection(('localhost', 9977)) conn.send("ABCDE") conn.recv(5); conn.close()
def connect(self): conn = socket.create_connection(('127.0.0.1', self.port)) self.connected.append(weakref.ref(conn)) result = conn if PY3: conn_makefile = conn.makefile def makefile(*args, **kwargs): if 'bufsize' in kwargs: kwargs['buffering'] = kwargs.pop('bufsize') if 'mode' in kwargs: return conn_makefile(*args, **kwargs) # Under Python3, you can't read and write to the same # makefile() opened in (default) r, and r+ is not allowed kwargs['mode'] = 'rwb' rconn = conn_makefile(*args, **kwargs) _rconn_write = rconn.write def write(data): if isinstance(data, str): data = data.encode('ascii') return _rconn_write(data) rconn.write = write self.connected.append(weakref.ref(rconn)) return rconn class proxy(object): def __getattribute__(self, name): if name == 'makefile': return makefile return getattr(conn, name) result = proxy() return result
def setUp(self): self.tempdir, self.inst = util.create_test_instance() self.bundle = self.inst.fi.bundles.values()[0] self.local_server = local.start_server(self.inst) gevent.sleep(0) self.sock = socket.create_connection(('127.0.0.1', 54321))
def send_req(self, hostname, port, msg): try: sock = socket.create_connection((hostname, port)) except socket.error: print('ERRO: conexao recusada para {}:{}'.format(hostname, port)) return False sock.send(msg)
def handle(self, client, address): try: line = '' while 1: _data = client.recv(1) line += _data if not _data or _data == '\n': break if line: log(line) target_address = parse_address(line.split()[1]) target = create_connection(target_address) target.sendall(line) gevent.spawn(forward, client, target) gevent.spawn(forward, target, client, 500000) else: client.close() return except IOError, ex: log('failed : {}', ex) import traceback traceback.print_exc() return
def initialize(self): self.socksconn = socket.create_connection((self.socksip, self.socksport), self.timeout) self.allsocks = [self.socksconn] self.socksconn.sendall(InitRequest().pack()) read_init_reply(self.socksconn) self.status = SESSION_WAIT_REQUEST self.initialized = True
def test(self): tempsock1 = socket.socket() tempsock1.bind(('', 0)) source_port = tempsock1.getsockname()[1] tempsock2 = socket.socket() tempsock2.bind(('', 0)) tempsock2.getsockname()[1] tempsock1.close() del tempsock1 tempsock2.close() del tempsock2 try: socket.create_connection(('localhost', 4), timeout=30, source_address=('', source_port)) except socket.error, ex: if 'connection refused' not in str(ex).lower(): raise
def get_file(peer, f): f.local_path = os.path.join(settings.DOWNLOAD_PATH, os.path.split(f.name)[1]) print "Downloading to " + f.local_path if os.path.exists(f.local_path): print("File {filename} already exists.".format(filename=f.name)) return sock = socket.create_connection((peer.address, peer.tcp_port)) sock.sendall(parser.build(GetFileMessage(f.sha_hash, 0, f.length))) message_data = "" while True: new_data = sock.recv(1) message_data += new_data if new_data == parser.message_separator: message = parser.parse(message_data) if message.status != FileTransferResponseMessage.OK_STATUS: print("File Request denied by peer.") sock.close() return else: break fd = file(f.local_path, "wb") while True: new_data = sock.recv(1024) if new_data: fd.write(new_data) else: break fd.close() sock.close()
def test_inactivity_timeout(self, mode): """ Tests that timeout sends a disable message with the proper mode.. """ with QdbServer(tracer_host='localhost', tracer_port=0, client_host='localhost', client_port=0, inactivity_timeout=0.01, # minutes sweep_time=0.01, # seconds timeout_disable_mode=mode) as server: tracer = socket.create_connection( ('localhost', server.tracer_server.server_port) ) send_tracer_event(tracer, 'start', { 'uuid': 'test', 'auth': '', 'local': (0, 0), }) client = create_connection( 'ws://localhost:%d%s' % (server.client_server.server_port, DEFAULT_ROUTE_FMT.format(uuid='test')) ) send_client_event(client, 'start', '') self.assertEqual({'e': 'start', 'p': ''}, recv_tracer_event(tracer)) self.assertEqual({'e': 'disable', 'p': mode}, recv_tracer_event(tracer)) self.assertEqual('disable', recv_client_event(client)['e']) self.assertFalse('test' in server.session_store)
def proc_tcp_request(self, req): dst = (req.dstaddr, req.dstport) log.info("TCP request address: (%s:%d)" % dst) self.remoteconn = socket.create_connection(dst, self.timeout) self.track_sock(self.remoteconn) addrtype, bndaddr, bndport = sock_addr_info(self.remoteconn) request_success(self.socksconn, addrtype, bndaddr, bndport)
def test_tracer_attach_timeout(self, mode): """ Tests the case where a tracer attaches but no client does. """ with QdbServer(tracer_host='localhost', tracer_port=0, client_server=QdbNopServer(), attach_timeout=0.01, timeout_disable_mode=mode) as server: tracer = socket.create_connection( ('localhost', server.tracer_server.server_port) ) send_tracer_event(tracer, 'start', { 'uuid': 'test', 'auth': '', 'local': (0, 0), }) disable_event = None with Timeout(0.1, False): error_event = recv_tracer_event(tracer) disable_event = recv_tracer_event(tracer) error_dict = fmt_err_msg('client', 'No client') self.assertEqual(error_dict, error_event) self.assertEqual(fmt_msg('disable', mode), disable_event) self.assertNotIn('test', server.session_store)
def send_events(message): if CARBON_ENDPOINT: sock = socket.create_connection((CARBON_ENDPOINT.split(":"))) sock.sendall(message) sock.close() else: print(message)
def handle(self, source, address): log('%s:%s accepted', *address[:2]) try: dest = create_connection(self.dest) except IOError, ex: log('%s:%s failed to connect to %s:%s: %s', address[0], address[1], self.dest[0], self.dest[1], ex) return
def __init__ (self, client, endpoints): """ Set up a connection between the client_socket and multiple endpoints. endpoints should be an array of (host, port) pairs. """ # We'll need these later self.client = client self.outgoing_queue = Queue() self.connected = Event() self.connected.set() # Setup the endpoint connections and store them self.endpoints = {} for host, port in endpoints: key = "%s:%s" % (host, port) # Connect to the endpoint endpoint = create_connection((host, port)) # Stream client <- self <- endpoint self.stream(key, self.incoming, (host, port)) # Store the endpoint self.endpoints[key] = endpoint # Pick which endpoint to use first self.current_endpoint = self.endpoints.keys()[0] self.endpoints["client"] = self.client # Stream client -> self -> endpoint self.stream("client", self.outgoing)
def client(cid): s = socket.create_connection(('127.0.0.1', 7890)) w = s.makefile('w') r = s.makefile('r') def send(): times = 0 while times < 100: times += 1 gevent.sleep(1) data = str(random.randint(10, 10000)) w.write('%s, from client %d\n' % (data, cid)) w.flush() print 'client', cid, 'send:', data def recv(): while True: line = r.readline() print 'client', cid, 'recive:', line, if not line: break send_job = gevent.spawn_later(1, send) recv_job = gevent.spawn(recv) def clear(*args): gevent.killall([send_job, recv_job]) s.close() send_job.link(clear) recv_job.link(clear) gevent.joinall([send_job, recv_job]) print 'client', cid, 'finish'
def test(): conn = socket.create_connection(("192.168.2.34", 23), timeout=15) conn.send("Hello from a telnet!") data = conn.recv(20) print(data) conn.close()
def tcp_policy_client(address, postfix_protocol, force_sleep=None, timeout=None): u""" Simule l'action client de Postfix Client TCP pour envoyer au serveur RS-Policy le protocol et recevoir le résultat dans un tableau qui seront les actions renvoyés à Postfix :param address: (host, port) :param postfix_protocol: str """ if not postfix_protocol.endswith('\n\n'): """ POUR ne pas bloquer la transaction, il faut que protocol se termine par un \n ou 2 ? """ postfix_protocol = "%s\n\n" % postfix_protocol if timeout: conn = socket.create_connection(address, timeout=timeout) else: conn = socket.create_connection(address) fileobj = conn.makefile() fileobj.write(postfix_protocol) fileobj.flush() result = [] while True: if force_sleep: gevent.sleep(force_sleep) line = fileobj.readline() if not line: break elif '=' in line: line = iter(line.strip().split('=')) key = line.next() result.append(line.next()) else: fileobj.flush() break return result
def client_connect(address): sockfile = create_connection(address).makefile() while True: line = sockfile.readline() # returns None on EOF if line is not None: print "<<<", line, else: break
def __init__(self, address, transport, chanid): gevent.Greenlet.__init__(self) gevent.sleep(.2) logger.info("Tunneller creating connection -> %s", address) self.socket = socket.create_connection(address) self.transport = transport self.chanid = chanid gevent.sleep(0)
def _get_socket(self, host, port, timeout): if self.debuglevel > 0: print >> stderr, 'connect:', (host, port) new_socket = socket.create_connection((host, port), timeout) new_socket = ssl.wrap_socket(new_socket, self.keyfile, self.certfile) self.file = SSLFakeFile(new_socket) return new_socket
def startedConnecting(self, connector): """ """ address = connector.getHost() client = create_connection(address) t = Transport(client, address) self.buildProtocol(t) self._protocol = self.protocol(t, self)
def test_connect_disconnect(self): my_server = server.Server(host="0.0.0.0") my_server.run() a = client.SimpleClient( create_connection(("localhost", my_server.port))) a.close() my_server.stop()
def pg_proxy(self, client_socket, address): pg_socket = socket.create_connection(("localhost", 5439)) pg_socket.settimeout(300.0) client_socket.settimeout(300.0) joinall((Greenlet.spawn(self.query_pipe, client_socket, pg_socket), Greenlet.spawn(self.response_pipe, pg_socket, client_socket))) pg_socket.close() client_socket.close()
def did_it_work(server): client = socket.create_connection( ('127.0.0.1', server.getsockname()[1])) fd = client.makefile() client.close() assert fd.readline() == 'hello\n' assert fd.read() == '' fd.close()
def forward_processer(): last_packet = None while True: global forward_socket try: data = forward_socket.recv(65535) except socket.timeout as e: gevent.sleep(0) continue except: print(sys.exc_info()) forward_socket.close() try: forward_socket = create_connection(forwarder_address) except: log_print("re connect forward failed") gevent.sleep(0) continue if len(data) == 0: gevent.sleep(0) continue start = 0 if last_packet != None: log_print("reload packet data %d last packet %d" % (len(data), len(last_packet))) data = last_packet + data last_packet = None log_print("recv forward start len %d" % len(data)) while start < len(data): if (start + 6 > len(data)): last_packet = data[start:] break fileno, content_len = struct.unpack("!IH", data[start:start + 6]) if int(content_len) == 65535: client_socket = proxy_clients.get(fileno) if client_socket != None: log_print("close %d" % fileno) client_socket.close() start = start + 6 continue if (content_len > len(data[start + 6:])): last_packet = data[start:] log_print("save packet %d content len %d" % (len(data[start:]), content_len)) log_print(data[start:]) break log_print("recv forward start %d content %d" % (start, content_len)) client_socket = proxy_clients.get(fileno) if client_socket == None: start = start + 6 + content_len log_print("no client socket") continue try: client_socket.sendall(data[start + 6:start + 6 + content_len]) except: log_print("client_socket has closed") start = start + 6 + content_len
def __init__(self, parent): self.host = parent._parent.host self.port = parent._parent.port self._read_buffer = None self._socket = None self.ssl = parent._parent.ssl try: self._socket = socket.create_connection((self.host, self.port)) self._socket.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1) self._socket.setsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1) if len(self.ssl) > 0: ssl_context = self._get_ssl_context(self.ssl["ca_certs"]) try: self._socket = ssl_context.wrap_socket(self._socket, server_hostname=self.host) except IOError as exc: self._socket.close() raise ReqlDriverError("SSL handshake failed: %s" % (str(exc),)) try: match_hostname(self._socket.getpeercert(), hostname=self.host) except CertificateError: self._socket.close() raise self.sendall(parent._parent.handshake) # The response from the server is a null-terminated string response = b'' while True: char = self.recvall(1) if char == b'\0': break response += char except ReqlAuthError: raise except ReqlTimeoutError: raise except ReqlDriverError as ex: self.close() error = str(ex)\ .replace('receiving from', 'during handshake with')\ .replace('sending to', 'during handshake with') raise ReqlDriverError(error) except Exception as ex: self.close() raise ReqlDriverError("Could not connect to %s:%s. Error: %s" % (self.host, self.port, ex)) if response != b"SUCCESS": self.close() message = decodeUTF(response).strip() if message == "ERROR: Incorrect authorization key.": raise ReqlAuthError(self.host, self.port) else: raise ReqlDriverError("Server dropped connection with message: \"%s\"" % (message, ))
def test_client(message): conn = create_connection(('127.0.0.1', 6000)).makefile(bufsize=1) welcome = conn.readline() assert 'Welcome' in welcome, repr(welcome) conn.write(message) received = conn.read(len(message)) self.assertEqual(received, message) conn._sock.settimeout(0.1) self.assertRaises(timeout, conn.read, 1)
def __init__(self, uid=1, address=("127.0.0.1", 8080)): self.secret_key = "" self.uid = uid self.rid = 1 self.cli_sock = create_connection(address) if self.cli_sock: self.accept_event = core.read_event(self.cli_sock.fileno(), self.do_read, persist=True)
def startedConnecting(self,connector): """开始建立连接\n @param connector: BaseConnector (详见gtwisted.core.base 中对BaseConnector的定义)\n """ address = connector.getHost() client = create_connection(address) t = Transport(client,address) self.buildProtocol(t) self._protocol = self.protocol(t,self)
def test_search(start, end, direction): print "test_search: s: %d, e: %d, dir: %d" % (start, end, direction) con = create_connection(('127.0.0.1', 8090)) con.settimeout(5.0) con.send("SEARCH %d %d %d FP_3031/Suma/Suma_produkcji_ciepla_DN300\r\n" % (start, end, direction)) print con.recv(64)
def handle(self, source, address): if address[:2][0] != 'xxx': # 如果不是公司的外网ip 就不要理了 return log('%s:%s accepted', *address[:2]) try: dest = create_connection(self.dest) except IOError, ex: log('%s:%s failed to connect to %s:%s: %s', address[0], address[1], self.dest[0], self.dest[1], ex) return