def listenConnection(IpServidor, PortServidor, IpSeguro, PortSeguro): ''' Coloca o servidor para rodar, de fato Após, fica escutando a porta e quando chegar alguma conexão, cria um thread para o cliente e trata envia para a função que irá tratar a requisição :param Ip: Endereço Ip que o servidor irá rodar :param Port: Porta em que o servidor irá rodar ''' try: bson.patch_socket() cliente = socket.socket(socket.AF_INET, socket.SOCK_STREAM) servidor = socket.socket(socket.AF_INET, socket.SOCK_STREAM) try: cliente.bind((IpSeguro, int(PortSeguro))) cliente.listen(10) except: logging.info("[Seguro]Error on start server") try: servidor.connect((IpServidor, int(PortServidor))) print("[Servidor] Conexão Estabelecida") except ConnectionRefusedError: print("[Servidor] Conexão Recusada") exit(1) logging.info( "[Servidor] WebServer running on port {0}".format(PortServidor)) logging.info( "[Seguro] WebServer running on port {0}".format(PortSeguro)) threads = [] try: while True: connC, addrC = cliente.accept() logging.info(" [Cliente] New Connection from " + str(addrC[0]) + " with port " + str(addrC[1])) aux = threading.Thread(target=connected, args=(connC, addrC, servidor)) aux.setDaemon(True) aux.start() threads.append(aux) except: if (os.getuid() == 0): clearRules() logging.info(" Ending the server execution") servidor.close() cliente.close() except (KeyboardInterrupt, SystemExit): if (os.getuid() == 0): clearRules() logging.info(" Finishing execution of WebServer...") pass
def start_forever(self, timeout_interval=0): bson.patch_socket() while True: conn, addr = self.server.accept() pid = os.fork() if pid: # in parent process log(conn, 'Forked process id =', pid, 'for serving', addr) pass else: # in child process while True: obj = None try: obj = conn.recvobj() except Exception as e: log(conn, e) sys.exit(1) # die on failure if obj: log(conn, 'REQUEST', obj) response = compute_on(obj) # caution: would block! log(conn, 'REPLY', response) try: conn.sendobj(response) except Exception as e: log(conn, e) sys.exit(1) # die on failure else: log(conn, 'received obj = None. Quit.') sys.exit(1)
def __init_defaults__(self): self.DIE_ON_FAILURE = True self.connection_mode = connection_mode.LOCAL self.hosts = ['127.0.0.1'] self.port = 8181 bson.patch_socket()
def __init__(self, host, port): self.host = host self.port = port self.sock = socket.socket() self.poll = select.poll() self.handlers = {} self.fd_events = {} bson.patch_socket()
def __init__(self, host=None, port=None, socket_address=None): self.host = host self.port = port self.socket_address = socket_address t = socket.AF_INET if host is None: t = socket.AF_UNIX self.socket = socket.socket(t, socket.SOCK_STREAM) bson.patch_socket() # brings native bson encoding/decoding to socket
def test_ssl(self): def make_keys(): from OpenSSL import crypto from socket import gethostname k = crypto.PKey() k.generate_key(crypto.TYPE_RSA, 1024) cert = crypto.X509() cert.get_subject().C = "KR" cert.get_subject().L = "LocalityName" cert.get_subject().O = "OrganizationName" cert.get_subject().OU = "OrganizationUnitName" cert.get_subject().CN = gethostname() cert.set_serial_number(12345) cert.gmtime_adj_notBefore(0) cert.gmtime_adj_notAfter(365*24*60*60) cert.set_issuer(cert.get_subject()) cert.set_pubkey(k) cert.sign(k, 'sha1') open('ssl.crt', 'wt').write( crypto.dump_certificate(crypto.FILETYPE_PEM, cert)) open('ssl.key', 'wt').write( crypto.dump_privatekey(crypto.FILETYPE_PEM, k)) def destroy_keys(): os.remove('ssl.crt') os.remove('ssl.key') make_keys() bson.patch_socket() port = random.randint(2000, 65535) server = Server.run_server( ('127.0.0.1', port), app, keyfile='ssl.key', certfile='ssl.crt' ) conn = socket(AF_INET, SOCK_STREAM) conn = ssl.wrap_socket(conn, keyfile='ssl.key', certfile='ssl.crt', ssl_version=ssl.PROTOCOL_TLSv1) conn.connect(('127.0.0.1', port)) conn.sendobj({'url': '/', 'method': 'GET'}) obj = conn.recvobj() obj.pop('headers') self.assertEqual( obj, dict(status=dict(reason='OK', code='200'), url='/', method='GET', response=dict()) ) server.stop() destroy_keys()
def test_command(self): bson.patch_socket() port = random.randint(2000, 65535) server = Server.run_server(('127.0.0.1', port), app) conn = socket(AF_INET, SOCK_STREAM) conn.connect(('127.0.0.1', port)) conn.sendobj({'url': ':hello'}) self.assertEqual( conn.recvobj(), dict(status=dict(reason='OK', code='200'), url=':hello')) server.stop()
def test_command(self): bson.patch_socket() port = random.randint(2000, 65535) server = Server.run_server(('127.0.0.1', port), app) conn = socket(AF_INET, SOCK_STREAM) conn.connect(('127.0.0.1', port)) conn.sendobj({'url': ':hello'}) self.assertEqual( conn.recvobj(), dict(status=dict(reason='OK', code='200'), url=':hello') ) server.stop()
def test_ssl(self): def make_keys(): from OpenSSL import crypto from socket import gethostname k = crypto.PKey() k.generate_key(crypto.TYPE_RSA, 1024) cert = crypto.X509() cert.get_subject().C = "KR" cert.get_subject().L = "LocalityName" cert.get_subject().O = "OrganizationName" cert.get_subject().OU = "OrganizationUnitName" cert.get_subject().CN = gethostname() cert.set_serial_number(12345) cert.gmtime_adj_notBefore(0) cert.gmtime_adj_notAfter(365 * 24 * 60 * 60) cert.set_issuer(cert.get_subject()) cert.set_pubkey(k) cert.sign(k, 'sha1') open('ssl.crt', 'wt').write(crypto.dump_certificate(crypto.FILETYPE_PEM, cert)) open('ssl.key', 'wt').write(crypto.dump_privatekey(crypto.FILETYPE_PEM, k)) def destroy_keys(): os.remove('ssl.crt') os.remove('ssl.key') make_keys() bson.patch_socket() port = random.randint(2000, 65535) server = Server.run_server(('127.0.0.1', port), app, keyfile='ssl.key', certfile='ssl.crt') conn = socket(AF_INET, SOCK_STREAM) conn = ssl.wrap_socket(conn, keyfile='ssl.key', certfile='ssl.crt', ssl_version=ssl.PROTOCOL_TLSv1) conn.connect(('127.0.0.1', port)) conn.sendobj({'url': '/', 'method': 'GET'}) obj = conn.recvobj() obj.pop('headers') self.assertEqual( obj, dict(status=dict(reason='OK', code='200'), url='/', method='GET', response=dict())) server.stop() destroy_keys()
def createConection(IP, Port, IPSeguro, PortSeguro, flag): ''' Cria a conexao com o servidor e popula o protobuf de acordo com o cliente atual Roda a comunicação cliente-servidor enquanto o cliente quiser (até digitar "SAIR") Envia o protobuf de requisição populado e recebe um protobuf de resposta já populado também Imprime na tela, os pedidos da requisição e a resposta de acordo com o protobuf de resposta :param IP: IP do servidor :Port: Porta em que o servidor está rodando ''' bson.patch_socket() sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) try: sock.connect((IP, int(Port))) print("Conexão Estabelecida com o servidor") except ConnectionRefusedError: print("Conexão Recusada pelo servidor") exit(1) if flag: sockSeguro = socket.socket(socket.AF_INET, socket.SOCK_STREAM) try: sockSeguro.connect((IPSeguro, int(PortSeguro))) print("Conexão Estabelecida com o servidor seguro") except ConnectionRefusedError: print("Conexão Recusada pelo servidor seguro") exit(1) try: helpMessage() data = input("\nComando => ").upper() clientId = str(random.randint(1000,9999)) key=43501#key_exchange(sock) while(data != "SAIR"): message = sendMessage(data, communication, clientId, sock, key, True, '') respotaMensagem = getResponse(communication, message, sock, key, True) if flag: if data == "GET": messageSegura = sendMessage(data, communication, clientId, sockSeguro, key, False, message['url']) respostaMensagemSegura = getResponse(communication, messageSegura, sockSeguro, key, False) print("Hash do canal seguro:\n\t" + respostaMensagemSegura['signature']) print("Hash do servidor:\n\t" + respotaMensagem['signature']) print("\n######## NOVA REQUISIÇÃO ########") helpMessage() data = input("\nComando => ").upper() except KeyboardInterrupt: sock.close() print("\n\nFinalizando a conexão")
def test_server(self): bson.patch_socket() port = random.randint(2000, 65535) server = Server.run_server(('127.0.0.1', port), app) conn = socket(AF_INET, SOCK_STREAM) conn.connect(('127.0.0.1', port)) conn.sendobj({'url': '/', 'method': 'GET'}) obj = conn.recvobj() obj.pop('headers') self.assertEqual( obj, dict(status=dict(reason='OK', code='200'), url='/', response=dict(), method='GET')) server.stop()
def test_server(self): bson.patch_socket() port = random.randint(2000, 65535) server = Server.run_server(('127.0.0.1', port), app) conn = socket(AF_INET, SOCK_STREAM) conn.connect(('127.0.0.1', port)) conn.sendobj({'url': '/', 'method': 'GET'}) obj = conn.recvobj() obj.pop('headers') self.assertEqual( obj, dict(status=dict(reason='OK', code='200'), url='/', response=dict(), method='GET') ) server.stop()
def listenConnection(Ip, Port): ''' Coloca o servidor para rodar, de fato Após, fica escutando a porta e quando chegar alguma conexão, cria um thread para o cliente e trata envia para a função que irá tratar a requisição :param Ip: Endereço Ip que o servidor irá rodar :param Port: Porta em que o servidor irá rodar ''' try: bson.patch_socket() server = socket.socket(socket.AF_INET, socket.SOCK_STREAM) try: server.bind((Ip, int(Port))) server.listen(10) except: logging.info(" Error on start server") logging.info(" WebServer running on port {0}".format(Port)) threads = [] try: while True: conn, addr = server.accept() logging.info(" New Connection from " + str(addr[0]) + " with port " + str(addr[1])) aux = threading.Thread(target=connected, args=(conn,addr)) aux.setDaemon(True) aux.start() threads.append(aux) except: if(os.getuid() == 0): clearRules() logging.info(" Ending the server execution") server.close() except (KeyboardInterrupt, SystemExit): if(os.getuid() == 0): clearRules() logging.info(" Finishing execution of WebServer...") pass
def start_forever(self, polling_interval=60): bson.patch_socket() server = self.server inputs = self.inputs outputs = self.outputs message_queues = self.message_queues inputs = self.inputs while inputs: readable, writable, exceptional = \ select.select(inputs, outputs, inputs, polling_interval) if not (readable or writable or exceptional): # timeout will generate three empty lists continue; # loop forever self.read_each(readable) self.write_each(writable) self.catch_each(exceptional)
def createConection(IP, Port): ''' Cria a conexao com o servidor e popula o protobuf de acordo com o cliente atual Roda a comunicação cliente-servidor enquanto o cliente quiser (até digitar "SAIR") Envia o protobuf de requisição populado e recebe um protobuf de resposta já populado também Imprime na tela, os pedidos da requisição e a resposta de acordo com o protobuf de resposta :param IP: IP do servidor :Port: Porta em que o servidor está rodando ''' bson.patch_socket() sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) try: sock.connect((IP, int(Port))) print("Conexão Estabelecida") except ConnectionRefusedError: print("Conexão Recusada") exit(1) try: helpMessage() data = input("\nComando => ").upper() clientId = str(random.randint(1000, 9999)) key = key_exchange(sock) while (data != "SAIR"): message = sendMessage(data, communication, clientId, sock, key) getResponse(communication, message, sock, key) print("\n######## NOVA REQUISIÇÃO ########") helpMessage() data = input("\nComando => ").upper() except KeyboardInterrupt: sock.close() print("\n\nFinalizando a conexão")
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. # Handle transport and serialization callbacks for Go-style RPC servers. # # This is pretty simple. The client initiates an HTTP CONNECT and then # hijacks the socket. The client is synchronous, but implements deadlines. import errno import socket import struct import time import urlparse import bson bson.patch_socket() try: # use optimized cbson which has slightly different API import cbson decode_document = cbson.decode_next except ImportError: from bson import codec decode_document = codec.decode_document _len = len _join = ''.join class GoRpcError(Exception): pass
def start_server(cls, host=getattr(settings, 'MOBILE_HOST', '0.0.0.0'), port=getattr(settings, 'MOBILE_PORT', 9338)): bson.patch_socket() server = cls((host, int(port)), IMRequestHandler) server_thread = threading.Thread(target=server.serve_forever) server_thread.start()
# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. # Handle transport and serialization callbacks for Go-style RPC servers. # # This is pretty simple. The client initiates an HTTP CONNECT and then # hijacks the socket. The client is synchronous, but implements deadlines. import errno import socket import struct import time import urlparse import bson;bson.patch_socket() try: # use optimized cbson which has slightly different API import cbson decode_document = cbson.decode_next except ImportError: from bson import codec decode_document = codec.decode_document _len = len _join = ''.join class GoRpcError(Exception): pass
#!/usr/bin/env python import sys import gevent import time import logging import bson from gevent import socket try: bson.patch_socket(socket.socket) except: import bsonbuffer bsonbuffer.patch_socket(socket.socket) def new_sock(addr): logging.debug('opening router socket at %s:%d' % addr) sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) sock.connect(addr) return sock class Connection(object): def __init__(self, clientid, sockaddr): self.clientid = clientid self.sockaddr = sockaddr self.stats = {'sent': 0, 'recv': 0}
from gevent import monkey, socket monkey.patch_all() import bson bson.patch_socket() s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.connect(("127.0.0.1", 6954)) s.send(bson.dumps({u"cmd": "HELO"})) resp = s.recv(4096) print "received: ", resp b = bson.loads(resp) print "decoded: ", b