def img(request):
""" return file and information about it, for static """
proc_id = request.match_info.get('proc_id', "des:obj")
doc_id = request.match_info.get('doc_id', "")
img = request.match_info.get('img', "")
action = request.match_info.get('action', "img")
att = None
headers = {}
try:
fn, att, prefix = img_m(request, proc_id, doc_id, img, action)
if not fn: return web.HTTPNotFound()
headers['Content-Length'] = fn['length']
lm = locale_date("%a, %d %b %Y %H:%M:%S GMT", fn['uploadDate'].timetuple(), 'en_US.UTF-8')
headers['Last-Modified'] = lm
ims = request.if_modified_since
if ims and ims.strftime('%Y-%m-%d %H:%M:%S') >= fn['uploadDate'].strftime('%Y-%m-%d %H:%M:%S'):
headers['Date'] = locale_date("%a, %d %b %Y %H:%M:%S GMT", time.gmtime(), 'en_US.UTF-8')
return web.HTTPNotModified( headers=MultiDict( headers ) )
headers['Content-Type'] = fn['mime']
headers['Cache-Control'] = 'max-age=604800'
content = att.read()
finally:
if att: att.close()
return web.Response(body=content, headers=MultiDict( headers ))
def _get_pretty(request):
pretty = False
get_params = MultiDict(urllib.parse.parse_qsl(request.query_string.lower()))
if get_params.get('pretty'):
if str(get_params.get('pretty', None)) in ['1', 'true']:
pretty = True
# Assume pretty if html is requested and pretty is not disabled
elif 'text/html' in request.headers.get('ACCEPT', ''):
pretty = True
return pretty
def test_get_lower(self):
i_headers = MultiDict([('test', '123')])
o_headers = MultiDict([('TEST', '123')])
atoms = helpers.SafeAtoms({}, i_headers, o_headers)
self.assertEqual(atoms['{test}i'], '123')
self.assertEqual(atoms['{test}o'], '-')
self.assertEqual(atoms['{TEST}o'], '123')
self.assertEqual(atoms['{UNKNOWN}o'], '-')
self.assertEqual(atoms['{UNKNOWN}'], '-')
def _get_pretty(request):
pretty = False
get_params = MultiDict(urllib.parse.parse_qsl(
request.query_string.lower()))
if get_params.get('pretty'):
if str(get_params.get('pretty', None)) in ['1', 'true']:
pretty = True
# Assume pretty if html is requested and pretty is not disabled
elif 'text/html' in request.headers.get('ACCEPT', ''):
pretty = True
return pretty
async def handle_request(self, message, payload):
path = urlparse(message.path).path.lower()
if path.startswith(u'/api/v1/limit/'):
get_params = MultiDict(parse_qsl(urlparse(message.path).query))
domain = get_params.get('d', None)
gen_time = get_params.get('g', None)
if domain is None or gen_time is None:
await super().handle_error(
message, payload, reason='domain or gen_time not provided')
else:
await self.handle_limit(message, domain, gen_time)
else:
await super().handle_request(message, payload)
def process_generic_get(query_string, allowed_fields):
# 1- retrieve query parameters
get_params = MultiDict(parse_qsl(query_string))
r_range = get_params.get('range', "0-" + str(RANGE_DEFAULT))
r_fields = get_params.get('fields', None)
r_order = get_params.get('order_by', None)
r_sort = get_params.get('order_sort', None)
r_filter = get_params.get('filter', None)
# 2- fields to extract
fields = allowed_fields
if r_fields is not None:
fields = []
for f in r_fields.split(','):
f = f.strip().lower()
if f in allowed_fields:
fields.append(f)
if len(fields) == 0:
return rest_error("No valid fields provided : " +
get_params.get('fields'))
# 3- Build json query for mongoengine
query = {}
if r_filter is not None:
query = {"$or": []}
for k in fields:
query["$or"].append({k: {'$regex': r_filter}})
# 4- Order
order = "name"
# if r_sort is not None and r_order is not None:
# r_sort = r_sort.split(',')
# r_order = r_order.split(',')
# if len(r_sort) == len(r_order):
# order = []
# for i in range(0, len(r_sort)):
# f = r_sort[i].strip().lower()
# if f in allowed_fields:
# if r_order[i] == "desc":
# f = "-" + f
# order.append(f)
# order = tuple(order)
# 5- limit
r_range = r_range.split("-")
offset = 0
limit = RANGE_DEFAULT
try:
offset = int(r_range[0])
limit = int(r_range[1])
except:
return rest_error("No valid range provided : " +
get_params.get('range'))
# 6- Return processed data
return fields, query, order, offset, limit
async def handle_request(self, request, payload):
print('Request path: {0}'.format(request.path))
data = self.create_data(request, 200)
if request.method == 'POST':
post_data = await payload.read()
post_data = MultiDict(parse_qsl(post_data.decode('utf-8')))
print('POST data:')
for key, val in post_data.items():
print('\t- {0}: {1}'.format(key, val))
data['post_data'] = dict(post_data)
# Submit the event to the TANNER service
event_result = await self.submit_data(data)
# Log the event to slurp service if enabled
if self.run_args.slurp_enabled:
await self.submit_slurp(request.path)
content, content_type, headers, status_code = await self.parse_tanner_response(
request.path, event_result['response']['message']['detection'])
response = aiohttp.Response(self.writer,
status=status_code,
http_version=request.version)
for name, val in headers.items():
response.add_header(name, val)
response.add_header('Server', self.run_args.server_header)
if 'cookies' in data and 'sess_uuid' in data['cookies']:
previous_sess_uuid = data['cookies']['sess_uuid']
else:
previous_sess_uuid = None
if event_result is not None and (
'sess_uuid' in event_result['response']['message']):
cur_sess_id = event_result['response']['message']['sess_uuid']
if previous_sess_uuid is None or not previous_sess_uuid.strip(
) or previous_sess_uuid != cur_sess_id:
response.add_header('Set-Cookie', 'sess_uuid=' + cur_sess_id)
if not content_type:
response.add_header('Content-Type', 'text/plain')
else:
response.add_header('Content-Type', content_type)
if content:
response.add_header('Content-Length', str(len(content)))
response.send_headers()
if content:
response.write(content)
await response.write_eof()
def _request(self, method, url, headers, data):
# Note: When using aiobotocore with dynamodb, requests fail on crc32
# checksum computation as soon as the response data reaches ~5KB.
# When aws response is gzip compressed:
# 1. aiohttp is automatically uncompressessing the data
# (http://aiohttp.readthedocs.io/en/stable/client.html#binary-response-content)
# 2. botocore computes crc32 on the uncompressed data bytes and fails
# cause crc32 has been computed on the compressed data
# The following line forces aws not to use gzip compression,
# if there is a way to configure aiohttp not to perform uncompression,
# we can remove the following line and take advantage of
# aws gzip compression.
headers['Accept-Encoding'] = 'identity'
headers_ = MultiDict(
(z[0], text_(z[1], encoding='utf-8')) for z in headers.items())
# For now the request timeout is: read_timeout and max(conn_timeout)
# So we want to ensure that your conn_timeout won't get truncated by
# the read_timeout. This should be removed after
# (https://github.com/KeepSafe/aiohttp/issues/1524) is resolved
if self._read_timeout < self._conn_timeout:
warnings.warn("connection timeout may be reduced due to current "
"read timeout")
# botocore does this during the request so we do this here as well
proxy = self.proxies.get(urlparse(url.lower()).scheme)
url = yarl.URL(url, encoded=True)
resp = yield from self._aio_session.request(method,
url=url,
headers=headers_,
data=data,
proxy=proxy,
timeout=self._read_timeout)
return resp
def get_multi_dict_from_python_dict(resp_headers_dict: dict) -> MultiDictProxy:
"""Construct an :class:`aiohttp.MultiDictProxy` instance from a Python dictionary.
Note: For now, this method is used for test only.
.. note::
Neither Python dictionary nor JSON supports multi-value key. The response headers returned
by `aiohttp` is of immutable type :class:`aiohttp.MultiDictProxy` while the one returned by
`aiohttpretty` is of :class:`aiohttp.MultiDict`.
WB tests use the :class:`aiohttp.MultiDict` type for both files and folders during modification
and returns the :class:`aiohttp.MultiDictProxy` type to imitate the behavior of `aiohttp`.
:param dict resp_headers_dict: the raw response headers dictionary
:rtype: :class:`aiohttp.MultiDictProxy`
"""
resp_headers = MultiDict(resp_headers_dict)
google_hash = resp_headers.get('x-goog-hash', None)
if google_hash:
assert verify_raw_google_hash_header(google_hash)
resp_headers.pop('x-goog-hash')
google_hash_list = google_hash.split(',')
for google_hash in google_hash_list:
resp_headers.add('x-goog-hash', google_hash)
return MultiDictProxy(resp_headers)
def process_generic_get(query_string, allowed_fields):
# 1- retrieve query parameters
get_params = MultiDict(parse_qsl(query_string))
r_range = get_params.get('range', "0-" + str(RANGE_DEFAULT))
r_fields = get_params.get('fields', None)
r_order = get_params.get('order_by', None)
r_sort = get_params.get('order_sort', None)
r_filter = get_params.get('filter', None)
# 2- fields to extract
fields = allowed_fields
if r_fields is not None:
fields = []
for f in r_fields.split(','):
f = f.strip().lower()
if f in allowed_fields:
fields.append(f)
if len(fields) == 0:
return rest_error("No valid fields provided : " + get_params.get('fields'))
# 3- Build json query for mongoengine
query = {}
if r_filter is not None:
query = {"$or" : []}
for k in fields:
query["$or"].append({k : {'$regex': r_filter}})
# 4- Order
order = "name"
# if r_sort is not None and r_order is not None:
# r_sort = r_sort.split(',')
# r_order = r_order.split(',')
# if len(r_sort) == len(r_order):
# order = []
# for i in range(0, len(r_sort)):
# f = r_sort[i].strip().lower()
# if f in allowed_fields:
# if r_order[i] == "desc":
# f = "-" + f
# order.append(f)
# order = tuple(order)
# 5- limit
r_range = r_range.split("-")
offset=0
limit=RANGE_DEFAULT
try:
offset = int(r_range[0])
limit = int(r_range[1])
except:
return rest_error("No valid range provided : " + get_params.get('range') )
# 6- Return processed data
return fields, query, order, offset, limit
def _create_or_update(self, data, username, network=None):
if network:
network_data = network.to_dict()
network_data.update(data)
form = NetworkForm(formdata=MultiDict(network_data))
else:
form = NetworkForm(formdata=MultiDict(data))
form.validate()
if form.errors:
return web.Response(body=json.dumps(form.errors).encode(),
status=400,
content_type='application/json')
cleaned_data = form.data
cleaned_data['user'] = username
if network:
network = yield from NetworkStore.update(
dict(filter=('id', network.id), update=cleaned_data))
else:
network = yield from NetworkStore.create(**cleaned_data)
return web.Response(body=self.serialize(network).encode(),
content_type='application/json')
async def dl_file(self, request):
# 1- Retrieve request parameters
file_id = request.match_info.get('file_id', -1)
pfile = File.from_id(file_id)
if not pfile:
return rest_error("File with id {} doesn't exits.".format(file_id))
file = None
if os.path.isfile(pfile.path):
with open(pfile.path, 'br') as content_file:
file = content_file.read()
return web.Response(headers=MultiDict(
{'Content-Disposition': 'Attachment; filename=' + pfile.name}),
body=file)
def get(self, request):
fields, query, order, offset, limit = process_generic_get(
request.query_string, Job.public_fields)
depth = int(
MultiDict(parse_qsl(request.query_string)).get('sublvl', 0))
# Get range meta data
range_data = {
"range_offset": offset,
"range_limit": limit,
"range_total": Job.count(),
"range_max": RANGE_MAX,
}
jobs = core.jobs.get(fields, query, order, offset, limit, depth)
return rest_success([j.to_json() for j in jobs], range_data)
async def get_comments(self, request):
"""Returns information about user comments by user_id"""
user_id = request.match_info.get('user_id')
headers = {
'Content-Disposition':
'attachment; filename="comments_{}"'.format(user_id),
}
resp = web.StreamResponse(headers=MultiDict(headers))
resp.content_type = 'text/plain'
await resp.prepare(request)
comments = UserCommentsGenerator(db=request.app['db'], user_id=user_id)
async for i in comments:
resp.write(i)
await resp.write_eof()
return resp
async def union_stat(request, *args):
component = request.match_info.get('component', "Anonymous")
fname = request.match_info.get('fname', "Anonymous")
path = os.path.join(settings.tao_path, 'libs', component, 'static', fname)
# search in project directory
if component == 'static':
path = os.path.join(settings.root_path, 'static')
# search in project components
elif not os.path.exists(path):
path = os.path.join(settings.root_path, 'apps', component, 'static')
# search in core components
else:
path = os.path.join(settings.tao_path, 'libs', component, 'static')
# app.router.add_static()
content, headers = get_static_file(fname, path)
return web.Response(body=content, headers=MultiDict(headers))
def get(self, request):
# Generic processing of the get query
fields, query, order, offset, limit = process_generic_get(
request.query_string, File.public_fields)
depth = int(
MultiDict(parse_qsl(request.query_string)).get('sublvl', 0))
# Get range meta data
range_data = {
"range_offset": offset,
"range_limit": limit,
"range_total": File.count(),
"range_max": RANGE_MAX,
}
# Return result of the query for PirusFile
files = core.files.get(fields, query, order, offset, limit, depth)
return rest_success([format_file_json(f.to_json()) for f in files],
range_data)
async def dl_pipe_file(self, request):
# 1- Retrieve request parameters
pipe_id = request.match_info.get('pipe_id', -1)
filename = request.match_info.get('filename', None)
pipeline = Pipeline.from_id(pipe_id, 1)
if pipeline == None:
return rest_error("No pipeline with id {}".format(pipe_id))
if filename == None:
return rest_error("No filename provided")
path = os.path.join(pipeline.path, filename)
file = None
if os.path.isfile(path):
with open(path, 'br') as content_file:
file = content_file.read()
return web.Response(headers=MultiDict(
{'Content-Disposition': 'Attachment; filename=' + filename}),
body=file)
def download_file(self, job_id, filename, location=JOBS_DIR):
job = Job.from_id(job_id, 1)
if job == None:
return rest_error("Unable to find the job (id={})".format(job_id))
path = os.path.join(job.path, filename)
if not os.path.exists(path):
return rest_error(
"File not found. {} doesn't exists for the job (id={})".format(
filename, job_id))
content = ""
if os.path.isfile(path):
with open(path, 'br') as content_file:
file = content_file.read()
return web.Response(headers=MultiDict(
{'Content-Disposition': 'Attachment; filename=' + filename}),
body=file)
def handle_request(self, message, payload):
response = aiohttp.Response(
self.writer, 200, http_version=message.version)
get_params = MultiDict(parse_qsl(urlparse(message.path).query))
if message.method == 'POST':
post_params = yield from payload.read()
else:
post_params = None
content = "<h1>It Works!</h1>"
if get_params:
content += "<h2>Get params</h2><p>" + str(get_params) + "</p>"
if post_params:
content += "<h2>Post params</h2><p>" + str(post_params) + "</p>"
bcontent = content.encode('utf-8')
response.add_header('Content-Type', 'text/html; charset=UTF-8')
response.add_header('Content-Length', str(len(bcontent)))
response.send_headers()
response.write(bcontent)
yield from response.write_eof()
def function2245(self, arg2114, arg284):
var2033 = aiohttp.Response(self.writer,
200,
http_version=arg2114.version)
var1109 = MultiDict(parse_qsl(urlparse(arg2114.path).query))
if (arg2114.method == 'POST'):
var1549 = yield from arg284.read()
else:
var1549 = None
var2428 = '<h1>It Works!</h1>'
if var1109:
var2428 += (('<h2>Get params</h2><p>' + str(var1109)) + '</p>')
if var1549:
var2428 += (('<h2>Post params</h2><p>' + str(var1549)) + '</p>')
var4666 = var2428.encode('utf-8')
var2033.add_header('Content-Type', 'text/html; charset=UTF-8')
var2033.add_header('Content-Length', str(len(var4666)))
var2033.send_headers()
var2033.write(var4666)
yield from var2033.write_eof()
async def handle_request(self, message, payload):
"""Traite une requête POST pour executer une action"""
if message.method == 'POST':
data = await payload.read()
decoded = data.decode('utf-8')
get_params = MultiDict(parse_qsl(urlparse(message.path).query))
post_params = json.loads(decoded)
if get_params['token'] == self.token:
code = 200
post_params['client'] = self.client
method = getattr(self.Action, post_params['action'])
await method(**post_params)
else:
code = 401
else:
code = 403
response = aiohttp.Response(
self.writer, code, http_version=message.version)
response.send_headers()
await response.write_eof()
def test_get_non_existing(self):
atoms = helpers.SafeAtoms({}, MultiDict(), MultiDict())
self.assertEqual(atoms['unknown'], '-')
def handle_request(self, request, payload):
print('Request path: {0}'.format(request.path))
data = self.create_data(request, 200)
if request.method == 'POST':
post_data = yield from payload.read()
post_data = MultiDict(parse_qsl(post_data.decode('utf-8')))
print('POST data:')
for key, val in post_data.items():
print('\t- {0}: {1}'.format(key, val))
data['post_data'] = dict(post_data)
# Submit the event to the TANNER service
event_result = yield from self.submit_data(data)
# Log the event to slurp service if enabled
if self.run_args.slurp_enabled:
yield from self.submit_slurp(request.path)
response = aiohttp.Response(self.writer,
status=200,
http_version=request.version)
mimetypes.add_type('text/html', '.php')
if 'payload' in event_result['response']['message']['detection']:
payload_content = event_result['response']['message']['detection'][
'payload']
if type(payload_content) == dict:
content_type = mimetypes.guess_type(payload_content['page'])[0]
content = '<html><body></body></html>'
base_path = '/'.join(
['/opt/snare/pages', self.run_args.page_dir])
if os.path.exists(base_path + payload_content['page']):
with open(base_path + payload_content['page']) as p:
content = p.read()
soup = BeautifulSoup(content, 'html.parser')
script_tag = soup.new_tag('div')
script_tag.append(
BeautifulSoup(payload_content['value'], 'html.parser'))
soup.body.append(script_tag)
content = str(soup).encode()
else:
content_type = mimetypes.guess_type(payload_content)[0]
content = payload_content.encode('utf-8')
else:
base_path = '/'.join(['/opt/snare/pages', self.run_args.page_dir])
query = None
if request.path == '/':
parsed_url = self.run_args.index_page
else:
parsed_url = urlparse(unquote(request.path))
if parsed_url.query:
query = '?' + parsed_url.query
parsed_url = parsed_url.path
if parsed_url.startswith('/'):
parsed_url = parsed_url[1:]
path = '/'.join([base_path, parsed_url])
content_type = mimetypes.guess_type(path)[0]
if content_type is None and '.php' in path:
content_type = 'text/html'
if query is not None:
path = os.path.normpath(path + query)
else:
path = os.path.normpath(path)
if os.path.isfile(path) and path.startswith(base_path):
with open(path, 'rb') as fh:
content = fh.read()
if content_type:
if 'text/html' in content_type:
content = yield from self.handle_html_content(content)
else:
content_type = None
content = None
response = aiohttp.Response(self.writer,
status=404,
http_version=request.version)
if not content_type:
response.add_header('Content-Type', 'text/plain')
else:
response.add_header('Content-Type', content_type)
if content:
response.add_header('Content-Length', str(len(content)))
response.send_headers()
if content:
response.write(content)
yield from response.write_eof()
def handle_request(self, request, payload):
print('Request path: {0}'.format(request.path))
data = self.create_data(request, 200)
if request.method == 'POST':
post_data = yield from payload.read()
post_data = MultiDict(parse_qsl(post_data.decode('utf-8')))
print('POST data:')
for key, val in post_data.items():
print('\t- {0}: {1}'.format(key, val))
data['post_data'] = dict(post_data)
# Submit the event to the TANNER service
event_result = yield from self.submit_data(data)
# Log the event to slurp service if enabled
if self.run_args.slurp_enabled:
yield from self.submit_slurp(request.path)
response = aiohttp.Response(self.writer,
status=200,
http_version=request.version)
content_type = None
mimetypes.add_type('text/html', '.php')
mimetypes.add_type('text/html', '.aspx')
base_path = os.path.join('/opt/snare/pages', self.run_args.page_dir)
if event_result is not None and (
'payload' in event_result['response']['message']['detection']
and event_result['response']['message']['detection']['payload']
is not None):
payload_content = event_result['response']['message']['detection'][
'payload']
if type(payload_content) == dict:
if payload_content['page'].startswith('/'):
payload_content['page'] = payload_content['page'][1:]
page_path = os.path.join(base_path, payload_content['page'])
content = '<html><body></body></html>'
if os.path.exists(page_path):
content_type = mimetypes.guess_type(page_path)[0]
with open(page_path, encoding='utf-8') as p:
content = p.read()
soup = BeautifulSoup(content, 'html.parser')
script_tag = soup.new_tag('div')
script_tag.append(
BeautifulSoup(payload_content['value'], 'html.parser'))
soup.body.append(script_tag)
content = str(soup).encode()
else:
content_type = mimetypes.guess_type(payload_content)[0]
content = payload_content.encode('utf-8')
else:
query = None
if request.path == '/':
parsed_url = self.run_args.index_page
else:
parsed_url = urlparse(unquote(request.path))
if parsed_url.query:
query = '?' + parsed_url.query
parsed_url = parsed_url.path
if parsed_url.startswith('/'):
parsed_url = parsed_url[1:]
path = os.path.normpath(os.path.join(base_path, parsed_url))
if os.path.isfile(path) and path.startswith(base_path):
content_type = mimetypes.guess_type(path)[0]
with open(path, 'rb') as fh:
content = fh.read()
if content_type:
if 'text/html' in content_type:
content = yield from self.handle_html_content(content)
else:
content_type = None
content = None
response = aiohttp.Response(self.writer,
status=404,
http_version=request.version)
response.add_header('Server', self.run_args.server_header)
if 'cookies' in data and 'sess_uuid' in data['cookies']:
previous_sess_uuid = data['cookies']['sess_uuid']
else:
previous_sess_uuid = None
if event_result is not None and (
'sess_uuid' in event_result['response']['message']):
cur_sess_id = event_result['response']['message']['sess_uuid']
if previous_sess_uuid is None or not previous_sess_uuid.strip(
) or previous_sess_uuid != cur_sess_id:
response.add_header('Set-Cookie', 'sess_uuid=' + cur_sess_id)
if not content_type:
response.add_header('Content-Type', 'text/plain')
else:
response.add_header('Content-Type', content_type)
if content:
response.add_header('Content-Length', str(len(content)))
# logging of ip, stat, req, user, len, time
if args.logger:
req = request.method + ' /' + self.run_args.page_dir + request.path
major = response.version.major
minor = response.version.minor
ver = " HTTP/" + str(major) + '.' + str(minor)
req = req + ver
user = getpass.getuser()
tim = strftime("%d/%b/%Y:%H:%M:%S %z")
d = {
'hostIP': request.headers['Host'],
'stat': response.status,
'req': req,
'user': user,
'content_length': response.headers['Content-Length'],
'time': tim
}
level_dict = {
'CRITICAL': 50,
'ERROR': 40,
'WARNING': 30,
'INFO': 20,
'DEBUG': 10,
'NOTSET': 0
}
self.logger.log(level_dict[args.logger], ' ', extra=d)
response.send_headers()
if content:
response.write(content)
yield from response.write_eof()
def test_metadata_from_resp_headers_missing_resp_headers(
self, file_obj_name):
with pytest.raises(exceptions.MetadataError):
GoogleCloudFileMetadata.new_from_resp_headers(
file_obj_name, MultiDict({}))
async def get_post_params(request):
data = await request.payload.read()
data = data.decode('utf-8')
post_params = MultiDict(parse_qsl(data))
return post_params
def setUp(self):
self.loop = mock.Mock()
self._REQUEST = aiohttp.RawRequestMessage('GET', '/some/path', '1.1',
MultiDict(), True, None)
def handle_request(self, request, payload):
print('Request path: {0}'.format(request.path))
data = self.create_data(request, 200)
if request.method == 'POST':
post_data = yield from payload.read()
post_data = MultiDict(parse_qsl(post_data.decode('utf-8')))
print('POST data:')
for key, val in post_data.items():
print('\t- {0}: {1}'.format(key, val))
data['post_data'] = dict(post_data)
# Submit the event to the TANNER service
event_result = yield from self.submit_data(data)
# Log the event to slurp service if enabled
if self.run_args.slurp_enabled:
yield from self.submit_slurp(request.path)
response = aiohttp.Response(
self.writer, status=200, http_version=request.version
)
if 'payload' in event_result['response']['message']['detection']:
payload_content = event_result['response']['message']['detection']['payload']
if type(payload_content) == dict:
content_type = mimetypes.guess_type(payload_content['page'])[0]
content = '<html><body></body></html>'
base_path = '/'.join(['/opt/snare/pages', self.run_args.page_dir])
if os.path.exists(base_path + payload_content['page']):
with open(base_path + payload_content['page']) as p:
content = p.read()
soup = BeautifulSoup(content, 'html.parser')
script_tag = soup.new_tag('div')
script_tag.append(BeautifulSoup(payload_content['value'], 'html.parser'))
soup.body.append(script_tag)
content = str(soup).encode()
else:
content_type = mimetypes.guess_type(payload_content)[0]
content = payload_content.encode('utf-8')
else:
base_path = '/'.join(['/opt/snare/pages', self.run_args.page_dir])
if request.path == '/':
parsed_url = self.run_args.index_page
else:
parsed_url = urlparse(unquote(request.path)).path
if parsed_url.startswith('/'):
parsed_url = parsed_url[1:]
path = '/'.join(
[base_path, parsed_url]
)
path = os.path.normpath(path)
if os.path.isfile(path) and path.startswith(base_path):
with open(path, 'rb') as fh:
content = fh.read()
content_type = mimetypes.guess_type(path)[0]
if content_type:
if 'text/html' in content_type:
content = yield from self.handle_html_content(content)
else:
content_type = None
content = None
response = aiohttp.Response(
self.writer, status=404, http_version=request.version
)
if not content_type:
response.add_header('Content-Type', 'text/plain')
else:
response.add_header('Content-Type', content_type)
if content:
response.add_header('Content-Length', str(len(content)))
response.send_headers()
if content:
response.write(content)
yield from response.write_eof()
async def handler_exists_layer2(request):
session_redis = await get_session(request)
posted_data = await request.post()
user_id = get_user_id(session_redis, request.app['app_users'])
layer_name = posted_data.get('layer')
layer_name_redis = posted_data.get('layer_name')
file_format = posted_data.get('format')
projection = json.loads(posted_data.get('projection'))
res = await request.app['redis_conn'].get('_'.join(
[user_id, layer_name_redis, "NQ"]))
if not res:
request.app['logger'].info(
'{} - Unable to fetch the requested layer ({}/{})'.format(
user_id, layer_name, layer_name_redis))
return web.Response(
text='{"Error": "Unable to fetch the layer on the server"}')
elif file_format == "TopoJSON":
return web.Response(text=res.decode())
else:
try:
res_geojson = topojson_to_geojson(json.loads(res.decode()))
if "GeoJSON" in file_format:
return web.Response(text=res_geojson)
elif "KML" in file_format:
tmp_path = prepare_folder()
output_path = ''.join([tmp_path, "/", layer_name, ".geojson"])
savefile(output_path, res_geojson.encode())
result = reproj_convert_layer_kml(output_path)
os.removedirs(tmp_path)
return web.Response(text=result.decode())
else:
out_proj = check_projection(
projection["name"] if "name" in
projection else projection["proj4string"])
if not out_proj:
return web.Response(text=json.dumps(
{'Error': 'app_page.common.error_proj4_string'}))
available_formats = {
"ESRI Shapefile": ".shp",
"KML": ".kml",
"GML": ".gml"
}
ext = available_formats[file_format]
tmp_path = prepare_folder()
output_path = ''.join([tmp_path, "/", layer_name, ".geojson"])
savefile(output_path, res_geojson.encode())
reproj_convert_layer(output_path,
output_path.replace(".geojson", ext),
file_format, out_proj)
os.remove(output_path)
raw_data, filename = fetch_zip_clean(tmp_path, layer_name)
if ".zip" in filename:
b64_zip = b64encode(raw_data)
return web.Response(body=b64_zip,
headers=MultiDict({
"Content-Type":
"application/octet-stream",
"Content-Disposition":
''.join([
"attachment; filename=",
layer_name, ".zip"
]),
"Content-length":
len(b64_zip)
}))
else:
return web.Response(text=raw_data.decode())
except Exception as err:
request.app['logger'].info(
'{} - Error {} while converting layer {} to {} format)'.format(
user_id, err, layer_name, file_format))
return web.Response(text='{"Error": "Unexpected error"}')
return web.Response(text='{"Error": "Invalid file format"}')
