def run(address, port, keyfile):
"""starts server"""
try:
server.start_server(keyfile, address, port)
except KeyboardInterrupt:
logger.info('got a KeyboardInterrupt, quitting.')
os.unlink(config.admin_sock_file)
os.unlink(config.io_sock_file)
def run(address, port, keyfile):
"""starts server"""
try:
server.start_server(keyfile, address, port)
except KeyboardInterrupt:
logger.info('got a KeyboardInterrupt, quitting.')
os.unlink(config.admin_sock_file)
os.unlink(config.io_sock_file)
def talk_server(handler, request):
try:
req_type = request.__class__.__name__
func = ROUTES_SERVER[req_type]
# found route, execute:
logger.info('routing {} -> {}'.format(req_type, func))
func(handler, request)
except KeyError as err:
logger.info('no route ' + err)
def talk_server(handler, request):
try:
req_type = request.__class__.__name__
func = ROUTES_SERVER[req_type]
# found route, execute:
logger.info('routing {} -> {}'.format(req_type, func))
func(handler, request)
except KeyError as err:
logger.info('no route '+err)
def get(index_name):
try:
return indexes[index_name]
except KeyError:
try:
ix = index.open_dir(config.index_path, schema=FileSchema, indexname=index_name)
except index.EmptyIndexError:
logger.info('no index "{}" found, creating a new one'.format(index_name))
ix = index.create_in(config.index_path, schema=FileSchema, indexname=index_name)
indexes[index_name] = ix
return ix
def route(self, handler, msg):
logger.debug('routing: {}'.format(msg))
try:
msg = loads(msg.decode())
except ValueError:
# Any ValueError means a bad json message
logger.debug('raising BadJsonMessage')
handler.send_data('["bad_json"]')
raise BadJsonMessage()
admin_commands = {
'ping': (ping_msg, {}),
'seed': (seed_msg, seed_msg_schema),
'planted': (plant_msg, {})
}
try:
# split header from values
# default cmd_values is {}
try:
cmd_header = msg[0]
cmd_values = msg[1]
except IndexError:
cmd_values = {} # default
# grab func, schema and validate
func, schema = admin_commands[cmd_header]
try:
if not validator.validate(cmd_values, schema):
logger.info('msg not valid')
raise BadSchema()
except ValidationError:
logger.info('validation error')
raise BadSchema()
# run func
cmd_reply = func(handler, cmd_values)
if cmd_reply:
logger.debug('sending: {}'.format(cmd_reply))
handler.send_data(cmd_reply)
else:
# Ack if cmd_reply is empty
logger.debug('sending: {}'.format(dumps(['ack'])))
handler.send_data(dumps(['ack']))
except KeyError:
# Any KeyError means a bad request
handler.send_data(dumps(['bad_request']))
except BadSchema:
# Any KeyError means a bad request
handler.send_data(dumps(['bad_schema']))
except BadJsonMessage:
# Any KeyError means a bad request
handler.send_data(dumps(['bad_json']))
def route(self, handler, msg):
logger.debug('routing: {}'.format(msg))
try:
msg = loads(msg.decode())
except ValueError:
# Any ValueError means a bad json message
logger.debug('raising BadJsonMessage')
handler.send_data('["bad_json"]')
raise BadJsonMessage()
admin_commands = {'ping': (ping_msg, {}),
'seed': (seed_msg, seed_msg_schema),
'planted': (plant_msg, {})
}
try:
# split header from values
# default cmd_values is {}
try:
cmd_header = msg[0]
cmd_values = msg[1]
except IndexError:
cmd_values = {} # default
# grab func, schema and validate
func, schema = admin_commands[cmd_header]
try:
if not validator.validate(cmd_values, schema):
logger.info('msg not valid')
raise BadSchema()
except ValidationError:
logger.info('validation error')
raise BadSchema()
# run func
cmd_reply = func(handler, cmd_values)
if cmd_reply:
logger.debug('sending: {}'.format(cmd_reply))
handler.send_data(cmd_reply)
else:
# Ack if cmd_reply is empty
logger.debug('sending: {}'.format(dumps(['ack'])))
handler.send_data(dumps(['ack']))
except KeyError:
# Any KeyError means a bad request
handler.send_data(dumps(['bad_request']))
except BadSchema:
# Any KeyError means a bad request
handler.send_data(dumps(['bad_schema']))
except BadJsonMessage:
# Any KeyError means a bad request
handler.send_data(dumps(['bad_json']))
def get(index_name):
try:
return indexes[index_name]
except KeyError:
try:
ix = index.open_dir(config.index_path, schema=FileSchema,
indexname=index_name)
except index.EmptyIndexError:
logger.info("no index \"{}\" found, creating a new one"
.format(index_name))
ix = index.create_in(config.index_path, schema=FileSchema,
indexname=index_name)
indexes[index_name] = ix
return ix
def do_handshake(self, handler, msg):
logger.debug('do_handshake()')
try:
# receive client pubkey and create my init_box
handler.init_box = CryptoBox(self.keyobj)
logger.debug("server init_box pk: {}".format(self.keyobj.pk))
logger.debug("server init_box sk: {}".format(self.keyobj.sk))
# init box with client's pubkey
handler.init_box.box_with(msg.key)
# create and send secret
handler.box = SecretBox()
sk_msg = encode(PubKeyReply(handler.box.sk))
sk_msg = handler.init_box.encrypt(sk_msg)
handler.send_data(compress_buff(sk_msg))
handler.handshaked = True
logger.info('HANDSHAKED1')
except:
raise BadHandshake()
def route(self, handler, msg):
logger.debug('routing msg: {}'.format(msg))
try:
msg = decompress_buff(msg)
logger.debug('decompressed msg: {}'.format(msg))
if not handler.handshaked:
msg = decode(msg)
logger.debug('decoded msg: {}'.format(msg))
# at this point we can only expect PubKeyReply
self.do_handshake(handler, msg)
else:
msg = handler.box.decrypt(msg)
request = decode(msg)
logger.debug('decrypted and decoded msg: {}'.format(request))
# TODO treat client requests here
routes.talk_server(handler, request)
except Exception as err:
logger.info('ignoring request [bad key] {}'.format(err))
raise
def do_handshake(self, handler, msg):
logger.debug('do_handshake()')
try:
# receive client pubkey and create my init_box
handler.init_box = CryptoBox(self.keyobj)
logger.debug("server init_box pk: {}".format(self.keyobj.pk))
logger.debug("server init_box sk: {}".format(self.keyobj.sk))
# init box with client's pubkey
handler.init_box.box_with(msg.key)
# create and send secret
handler.box = SecretBox()
sk_msg = encode(PubKeyReply(handler.box.sk))
sk_msg = handler.init_box.encrypt(sk_msg)
handler.send_data(compress_buff(sk_msg))
handler.handshaked = True
logger.info('HANDSHAKED1')
except:
raise BadHandshake()
def route(self, handler, msg):
logger.debug('routing msg: {}'.format(msg))
try:
msg = decompress_buff(msg)
logger.debug('decompressed msg: {}'.format(msg))
if not handler.handshaked:
msg = decode(msg)
logger.debug('decoded msg: {}'.format(msg))
# at this point we can only expect PubKeyReply
self.do_handshake(handler, msg)
else:
msg = handler.box.decrypt(msg)
request = decode(msg)
logger.debug('decrypted and decoded msg: {}'.format(request))
# TODO treat client requests here
routes.talk_server(handler, request)
except Exception as err:
logger.info('ignoring request [bad key] {}'.format(err))
raise
