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
