def render_POST(self, request):
try:
fields = cgi.FieldStorage(
fp=request.content,
headers=request.getAllHeaders(),
environ={
'REQUEST_METHOD': 'POST',
'CONTENT_TYPE': request.getAllHeaders()['content-type'],
}) #hacky way to parse out file contents and filenames
token = request.args.get('token', None)[0]
fmt = request.args.get('fmt', None)[0]
if fmt not in ['authenticode']:
raise Exception('Unsupported token type for POST.')
canarydrop = Canarydrop(**get_canarydrop(canarytoken=token))
if not canarydrop:
raise NoCanarytokenPresent()
if fmt == 'authenticode':
filename = fields['file_for_signing'].filename
filebody = fields['file_for_signing'].value
if len(filebody) > settings.MAX_UPLOAD_SIZE:
raise Exception('File too large')
if not filename.lower().endswith(('exe', 'dll')):
raise Exception(
'Uploaded authenticode file must be an exe or dll')
signed_contents = make_canary_authenticode_binary(
hostname=canarydrop.get_hostname(with_random=False,
as_url=True),
filebody=filebody)
request.setHeader("Content-Type", "octet/stream")
request.setHeader("Content-Disposition",
'attachment; filename={filename}.signed'\
.format(filename=filename))
return signed_contents
except Exception as e:
log.err('Unexpected error in POST download: {err}'.format(err=e))
template = env.get_template('error.html')
return template.render(error=e.message).encode('utf8')
return NoResource().render(request)
def _listen_http(self, listener_config):
port = listener_config["port"]
bind_addresses = listener_config["bind_addresses"]
site_tag = listener_config.get("tag", port)
resources = {}
for res in listener_config["resources"]:
for name in res["names"]:
if name == "metrics":
resources[METRICS_PREFIX] = MetricsResource(RegistryProxy)
elif name == "client":
resource = JsonResource(self, canonical_json=False)
PublicRoomListRestServlet(self).register(resource)
RoomMemberListRestServlet(self).register(resource)
JoinedRoomMemberListRestServlet(self).register(resource)
RoomStateRestServlet(self).register(resource)
RoomEventContextServlet(self).register(resource)
RoomMessageListRestServlet(self).register(resource)
RegisterRestServlet(self).register(resource)
LoginRestServlet(self).register(resource)
ThreepidRestServlet(self).register(resource)
KeyQueryServlet(self).register(resource)
KeyChangesServlet(self).register(resource)
VoipRestServlet(self).register(resource)
PushRuleRestServlet(self).register(resource)
VersionsRestServlet(self).register(resource)
resources.update({"/_matrix/client": resource})
root_resource = create_resource_tree(resources, NoResource())
_base.listen_tcp(
bind_addresses,
port,
SynapseSite(
"synapse.access.http.%s" % (site_tag,),
site_tag,
listener_config,
root_resource,
self.version_string,
),
)
logger.info("Synapse client reader now listening on port %d", port)
def get_contract(self, request):
def parse_contract(contract):
if contract is not None:
request.setHeader('content-type', "application/json")
request.write(json.dumps(contract, indent=4))
request.finish()
else:
request.write(NoResource().render(request))
request.finish()
if "id" in request.args:
if "guid" in request.args:
def get_node(node):
if node is not None:
self.mserver.get_contract(node, unhexlify(request.args["id"][0]))\
.addCallback(parse_contract)
else:
request.write(NoResource().render(request))
request.finish()
try:
with open(DATA_FOLDER + "cache/" + request.args["id"][0],
"r") as filename:
contract = json.loads(filename.read(),
object_pairs_hook=OrderedDict)
parse_contract(contract)
except Exception:
self.kserver.resolve(unhexlify(
request.args["guid"][0])).addCallback(get_node)
else:
try:
with open(
HashMap().get_file(unhexlify(
request.args["id"][0])), "r") as filename:
contract = json.loads(filename.read(),
object_pairs_hook=OrderedDict)
parse_contract(contract)
except Exception:
parse_contract(None)
else:
request.write(NoResource().render(request))
request.finish()
return server.NOT_DONE_YET
def render_GET(self, request):
try:
token = request.args.get('token', None)[0]
auth = request.args.get('auth', None)[0]
canarydrop = Canarydrop(**get_canarydrop(canarytoken=token))
if not canarydrop['auth'] or canarydrop['auth'] != auth:
raise NoCanarytokenPresent()
if canarydrop.get('triggered_list', None):
for timestamp in canarydrop['triggered_list'].keys():
formatted_timestamp = datetime.datetime.fromtimestamp(
float(timestamp)).strftime('%Y %b %d %H:%M:%S')
canarydrop['triggered_list'][formatted_timestamp] = canarydrop['triggered_list'].pop(timestamp)
except (TypeError, NoCanarytokenPresent):
return NoResource().render(request)
g_api_key = get_canary_google_api_key()
template = env.get_template('manage.html')
return template.render(canarydrop=canarydrop, API_KEY=g_api_key).encode('utf8')
def _listen_http(self, listener_config):
port = listener_config["port"]
bind_addresses = listener_config["bind_addresses"]
site_tag = listener_config.get("tag", port)
resources = {}
for res in listener_config["resources"]:
for name in res["names"]:
if name == "metrics":
resources[METRICS_PREFIX] = MetricsResource(RegistryProxy)
elif name == "media":
media_repo = self.get_media_repository_resource()
# We need to serve the admin servlets for media on the
# worker.
admin_resource = JsonResource(self, canonical_json=False)
register_servlets_for_media_repo(self, admin_resource)
resources.update({
MEDIA_PREFIX:
media_repo,
LEGACY_MEDIA_PREFIX:
media_repo,
CONTENT_REPO_PREFIX:
ContentRepoResource(self, self.config.uploads_path),
"/_synapse/admin":
admin_resource,
})
root_resource = create_resource_tree(resources, NoResource())
_base.listen_tcp(
bind_addresses,
port,
SynapseSite(
"synapse.access.http.%s" % (site_tag, ),
site_tag,
listener_config,
root_resource,
self.version_string,
),
)
logger.info("Synapse media repository now listening on port %d", port)
def getChild(self, path, request):
path_str = path.decode()
keys = os.path.normpath(path_str).split('/')
if keys[0] == 'update_stock':
return UpdateStockAPIHandler()
elif keys[0] == 'image':
return UpdateImageAPIHandler()
elif keys[0] == 'cancel_order':
return CancelOrderAPIHandler()
elif keys[0] == 'dockerfile_list':
return DockerfileListAPIHandler()
elif keys[0] == 'buildimage':
return BuildImageAPIHandler()
elif keys[0] == 'dataset_list':
return DatasetListAPIHandler()
elif keys[0] == 'dataset_check':
return DatasetCheckAPIHandler()
return NoResource()
def _listen_http(self, listener_config):
port = listener_config["port"]
bind_addresses = listener_config["bind_addresses"]
site_tag = listener_config.get("tag", port)
resources = {}
for res in listener_config["resources"]:
for name in res["names"]:
if name == "metrics":
resources[METRICS_PREFIX] = MetricsResource(RegistryProxy)
elif name == "federation":
resources.update({
FEDERATION_PREFIX:
TransportLayerServer(self),
})
if name == "openid" and "federation" not in res["names"]:
# Only load the openid resource separately if federation resource
# is not specified since federation resource includes openid
# resource.
resources.update({
FEDERATION_PREFIX:
TransportLayerServer(
self,
servlet_groups=["openid"],
),
})
if name in ["keys", "federation"]:
resources[SERVER_KEY_V2_PREFIX] = KeyApiV2Resource(self)
root_resource = create_resource_tree(resources, NoResource())
_base.listen_tcp(bind_addresses,
port,
SynapseSite(
"synapse.access.http.%s" % (site_tag, ),
site_tag,
listener_config,
root_resource,
self.version_string,
),
reactor=self.get_reactor())
logger.info("Synapse federation reader now listening on port %d", port)
def get_container(self, request, container_name):
"""
Api call to get a container, given the name of the container. HTTP
status code of 200 when such a container exists, 404 if not.
"""
if container_name in self.containers:
request.responseHeaders.setRawHeaders("content-type",
["application/json"])
request.responseHeaders.setRawHeaders("x-container-object-count",
["0"])
request.responseHeaders.setRawHeaders("x-container-bytes-used",
["0"])
request.setResponseCode(OK)
return dumps([
obj.as_json()
for obj in self.containers[container_name].objects.values()
])
else:
return NoResource()
def head_container(self, request, container_name):
"""
Api call to get the meta-data regarding a container
"""
if container_name in self.containers:
container = self.containers[container_name]
object_count = "{0}".format(container.object_count).encode("utf-8")
byte_count = "{0}".format(container.byte_count).encode("utf-8")
request.responseHeaders.setRawHeaders(b"content-type",
[b"application/json"])
request.responseHeaders.setRawHeaders(b"x-container-object-count",
[object_count])
request.responseHeaders.setRawHeaders(b"x-container-bytes-used",
[byte_count])
request.setResponseCode(204)
return b""
else:
return NoResource("No such container")
def _listen_http(self, listener_config):
port = listener_config["port"]
bind_addresses = listener_config["bind_addresses"]
site_tag = listener_config.get("tag", port)
resources = {}
for res in listener_config["resources"]:
for name in res["names"]:
if name == "metrics":
resources[METRICS_PREFIX] = MetricsResource(RegistryProxy)
elif name == "client":
resource = JsonResource(self, canonical_json=False)
KeyUploadServlet(self).register(resource)
# If presence is disabled, use the stub servlet that does
# not allow sending presence
if not self.config.use_presence:
PresenceStatusStubServlet(self).register(resource)
resources.update(
{
"/_matrix/client/r0": resource,
"/_matrix/client/unstable": resource,
"/_matrix/client/v2_alpha": resource,
"/_matrix/client/api/v1": resource,
}
)
root_resource = create_resource_tree(resources, NoResource())
_base.listen_tcp(
bind_addresses,
port,
SynapseSite(
"synapse.access.http.%s" % (site_tag,),
site_tag,
listener_config,
root_resource,
self.version_string,
),
reactor=self.get_reactor(),
)
logger.info("Synapse client reader now listening on port %d", port)
def getChild(self, name, request):
protoType = request.getHeader('upgrade')
if not protoType:
if name in self.WSmap:
return self.WSmap[name][1]
else:
return NoResource()
elif protoType.lower() == 'websocket':
if name in self.WSmap:
return self.WSmap[name][0]
else:
streamer = WebMStream(name)
factory = PSFactory(streamer)
factory.protocol = PSProto
factory.setProtocolOptions(maxConnections=2)
factory.startFactory()
self.WSmap[name].append(WebSocketResource(factory))
self.WSmap[name].append(Live(streamer))
return self.WSmap[name][0]
def parse_profile(profile):
if profile is not None:
profile_json = {
"profile": {
"name": profile.name,
"location": str(CountryCode.Name(profile.location)),
"enryption_key": profile.encryption_key.encode("hex"),
"nsfw": profile.nsfw,
"vendor": profile.vendor,
"moderator": profile.moderator,
"handle": profile.handle,
"about": profile.about,
"website": profile.website,
"email": profile.email,
"primary_color": profile.primary_color,
"secondary_color": profile.secondary_color,
"background_color": profile.background_color,
"text_color": profile.text_color,
"pgp_key": profile.pgp_key.publicKey,
"avatar_hash": profile.avatar_hash.encode("hex"),
"header_hash": profile.header_hash.encode("hex"),
"social_accounts": {}
}
}
if "guid" in request.args:
profile_json["profile"]["guid"] = request.args["guid"][0]
else:
profile_json["profile"]["guid"] = KeyChain().guid.encode(
"hex")
for account in profile.social:
profile_json["profile"]["social_accounts"][str(
objects.Profile.SocialAccount.SocialType.Name(
account.type)).lower()] = {
"username": account.username,
"proof_url": account.proof_url
}
request.setHeader('content-type', "application/json")
request.write(json.dumps(profile_json, indent=4))
request.finish()
else:
request.write(NoResource().render(request))
request.finish()
def _listen_http(self, listener_config):
port = listener_config["port"]
bind_addresses = listener_config["bind_addresses"]
site_tag = listener_config.get("tag", port)
resources = {}
for res in listener_config["resources"]:
for name in res["names"]:
if name == "metrics":
resources[METRICS_PREFIX] = MetricsResource(RegistryProxy)
elif name == "client":
resource = JsonResource(self, canonical_json=False)
RoomSendEventRestServlet(self).register(resource)
RoomMembershipRestServlet(self).register(resource)
RoomStateEventRestServlet(self).register(resource)
JoinRoomAliasServlet(self).register(resource)
ProfileAvatarURLRestServlet(self).register(resource)
ProfileDisplaynameRestServlet(self).register(resource)
ProfileRestServlet(self).register(resource)
resources.update(
{
"/_matrix/client/r0": resource,
"/_matrix/client/unstable": resource,
"/_matrix/client/v2_alpha": resource,
"/_matrix/client/api/v1": resource,
}
)
root_resource = create_resource_tree(resources, NoResource())
_base.listen_tcp(
bind_addresses,
port,
SynapseSite(
"synapse.access.http.%s" % (site_tag,),
site_tag,
listener_config,
root_resource,
self.version_string,
),
)
logger.info("Synapse event creator now listening on port %d", port)
def __init__(self):
Resource.__init__(self)
self.isLeaf = True
self.r404 = NoResource()
fp = file(sys.argv[0])
self.src = fp.read()
fp.close()
from subprocess import PIPE, Popen
try:
self.src_syn = Popen(
['pandoc', '-s'], stdin=PIPE, stdout=PIPE,
stderr=PIPE).communicate("~~~~ {.python}\n" + self.src +
"~~~~\n")[0]
except OSError:
sys.stderr.write(
"pandoc not found; /src/ will default to plain text rather than syntax highlighted code\n"
)
self.src_syn = None
def create_factory(authnz, git_configuration, git_viewer=None):
if git_viewer is None:
git_viewer = NoResource()
elif not IResource.providedBy(git_viewer):
raise ValueError("git_viewer should implement IResource")
credentialFactories = [BasicCredentialFactory('Git Repositories')]
gitportal = Portal(
GitHTTPRealm(authnz, git_configuration, credentialFactories,
git_viewer))
if hasattr(authnz, 'check_password'):
log.msg("Registering PasswordChecker")
gitportal.registerChecker(PasswordChecker(authnz.check_password))
gitportal.registerChecker(AllowAnonymousAccess())
resource = HTTPAuthSessionWrapper(gitportal, credentialFactories)
site = Site(resource)
return site
def getChild(self, name, request):
if name == 'sendCommand':
if request.method == 'GET':
return File('hamjab/resources/help/sendCommand.html')
args = ('command', )
for arg in args:
result = ArgUtils._check_arg(arg, request.args)
if result:
return result
(command, ) = ArgUtils._get_args(request, args)
try:
other_args = dict([(x, request.args[x][0])
for x in request.args if x not in args])
command = command.format(**other_args)
except KeyError:
return ErrorPage(200, "Command Error",
"Missing arguments for command")
return SendCommandResource(self.device, command)
elif name == 'frontEnd':
return File('hamjab/resources/devices/{device}'.format(
device=self.device.deviceId))
elif name == 'help':
return File('hamjab/resources/help/')
elif name == 'getUnsolicited':
return GetUnsolicitedResource(self.device)
else:
self.log.warn("Unknown page requested: {name!r} as part of {path}",
name=repr(name),
path=request.path)
return NoResource()
def render_POST(self, request):
try:
try:
token = request.args.get('token', None)[0]
auth = request.args.get('auth', None)[0]
canarydrop = Canarydrop(**get_canarydrop(canarytoken=token))
if not canarydrop['auth'] or canarydrop['auth'] != auth:
raise NoCanarytokenPresent()
except (IndexError, NoCanarytokenPresent):
return NoResource().render(request)
try:
email_enable_status = request.args.get('email_enable',
None)[0] == "on"
except (TypeError, IndexError):
email_enable_status = False
try:
sms_enable_status = request.args.get('sms_enable',
None)[0] == "on"
except (TypeError, IndexError):
sms_enable_status = False
canarydrop['alert_email_enabled'] = email_enable_status
canarydrop['alert_sms_enabled'] = sms_enable_status
save_canarydrop(canarydrop=canarydrop)
template = env.get_template('manage.html')
return template.render(canarydrop=canarydrop,
saved=True,
settings=settings).encode('utf8')
except Exception as e:
template = env.get_template('manage.html')
return template.render(canarydrop=canarydrop,
error=e,
settings=settings).encode('utf8')
def get_container(self, request, container_name):
"""
Api call to get a container, given the name of the container. HTTP
status code of 200 when such a container exists, 404 if not.
"""
if container_name in self.containers:
container = self.containers[container_name]
object_count = "{0}".format(container.object_count).encode("utf-8")
byte_count = "{0}".format(container.byte_count).encode("utf-8")
request.responseHeaders.setRawHeaders(b"content-type",
[b"application/json"])
request.responseHeaders.setRawHeaders(b"x-container-object-count",
[object_count])
request.responseHeaders.setRawHeaders(b"x-container-bytes-used",
[byte_count])
request.setResponseCode(OK)
return dumps([
obj.as_json()
for obj in self.containers[container_name].objects.values()
])
else:
return NoResource("No such container")
def getChild(self, name, request): if name == '': return self if name == 'ShowCounters': return ShowCounters() if name == 'ShowLists': return ShowLists() if name == 'DisList': return DisList() if name == 'AddToList': return AddToList() if name == 'DelFromList': return DelFromList() if name == 'AddList' : return AddList() if name == 'Restart' : return Restart() if name == 'GetListLength' : return GetListLength() else: txt = "Accepted Commands are: ShowCounters, ShowLists , DisList , AddToList , DelFromList , AddList, Restart, GetListLength" return NoResource(message=txt)
def get_image(self, request):
@defer.inlineCallbacks
def _showImage(resp=None):
@defer.inlineCallbacks
def _setContentDispositionAndSend(file_path, extension, content_type):
request.setHeader('content-disposition', 'filename="%s.%s"' % (file_path, extension))
request.setHeader('content-type', content_type)
f = open(file_path, "rb")
yield FileSender().beginFileTransfer(f, request)
f.close()
defer.returnValue(0)
if os.path.exists(image_path):
yield _setContentDispositionAndSend(image_path, "jpg", "image/jpeg")
else:
request.setResponseCode(http.NOT_FOUND)
request.write("No such image '%s'" % request.path)
request.finish()
if "hash" in request.args and len(request.args["hash"][0]) == 40:
if self.db.HashMap().get_file(unhexlify(request.args["hash"][0])) is not None:
image_path = self.db.HashMap().get_file(unhexlify(request.args["hash"][0]))
else:
image_path = DATA_FOLDER + "cache/" + request.args["hash"][0]
if not os.path.exists(image_path) and "guid" in request.args:
def get_node(node):
if node is not None:
self.mserver.get_image(node, unhexlify(request.args["hash"][0])).addCallback(_showImage)
else:
_showImage()
self.kserver.resolve(unhexlify(request.args["guid"][0])).addCallback(get_node)
else:
_showImage()
else:
request.write(NoResource().render(request))
request.finish()
return server.NOT_DONE_YET
def _listen_http(self, listener_config):
port = listener_config["port"]
bind_addresses = listener_config["bind_addresses"]
site_tag = listener_config.get("tag", port)
resources = {}
for res in listener_config["resources"]:
for name in res["names"]:
if name == "metrics":
resources[METRICS_PREFIX] = MetricsResource(self)
root_resource = create_resource_tree(resources, NoResource())
_base.listen_tcp(
bind_addresses, port,
SynapseSite(
"synapse.access.http.%s" % (site_tag, ),
site_tag,
listener_config,
root_resource,
))
logger.info("Synapse federation_sender now listening on port %d", port)
def _listen_http(self, listener_config):
port = listener_config["port"]
bind_addresses = listener_config["bind_addresses"]
site_tag = listener_config.get("tag", port)
resources = {}
for res in listener_config["resources"]:
for name in res["names"]:
if name == "metrics":
resources[METRICS_PREFIX] = MetricsResource(RegistryProxy)
elif name == "client":
resource = JsonResource(self, canonical_json=False)
sync.register_servlets(self, resource)
events.register_servlets(self, resource)
InitialSyncRestServlet(self).register(resource)
RoomInitialSyncRestServlet(self).register(resource)
resources.update(
{
"/_matrix/client/r0": resource,
"/_matrix/client/unstable": resource,
"/_matrix/client/v2_alpha": resource,
"/_matrix/client/api/v1": resource,
}
)
root_resource = create_resource_tree(resources, NoResource())
_base.listen_tcp(
bind_addresses,
port,
SynapseSite(
"synapse.access.http.%s" % (site_tag,),
site_tag,
listener_config,
root_resource,
self.version_string,
),
)
logger.info("Synapse synchrotron now listening on port %d", port)
def render_GET(self, request):
if not self.exists:
return NoResource().render(request)
if self.isfile:
with open(self.path, "r") as f:
return f.read()
elif self.isdir:
ret = []
if request.args.get("recursive", ["false"])[0] == "true":
for dirpath, dirnames, filenames in os.walk(self.path):
ret.append((dirpath[len(self.path):], dirnames, filenames))
else:
files = []
dirs = []
for i in os.listdir(self.path):
if os.path.isfile(os.path.join(self.path, i)):
files.append(i)
else:
dirs.append(i)
ret = ("", dirs, files)
return json.dumps(ret)
assert False
def getChild(self, name, request):
protoType = request.getHeader('upgrade')
if not protoType:
if name in self.WSmap:
if self.webAuthenticated:
return File("/tmp/" + name)
else:
if self.checkAuth(name, request):
return File("/tmp/" + name)
else:
return ErrorPage()
else:
return NoResource()
elif protoType.lower() == 'websocket':
if name in self.WSmap:
return self.WSmap[name][0]
else:
factory = PSFactory()
factory.protocol = PSProto
factory.setProtocolOptions(maxConnections=2)
factory.startFactory()
self.WSmap[name].append(WebSocketResource(factory))
return self.WSmap[name][0]
def getChild(self, path, request):
containers = dict(self.get_containers())
try:
container = containers[path]
except KeyError:
return NoResource()
# TODO: Infer descriptor class from container
if path == 'storage':
descriptor = StoxyContainerDescriptor(container, path)
else:
descriptor = BasicContainerDescriptor(container, path)
return StaticJsonResource({
"apiVersion": "0.1",
"swaggerVersion": "1.2",
"basePath": self.base_path,
"resourcePath": "/%s" % path,
"produces": ["application/json"],
"models": descriptor.get_models(),
"apis": descriptor.get_apis()
})
def add_snapshot(self, request, folder_name):
"""
Create a new Snapshot
"""
try:
folder_config = self._global_config.get_magic_folder(folder_name)
folder_service = self._global_service.get_folder_service(
folder_name)
except ValueError:
returnValue(NoResource(b"{}"))
path_u = request.args[b"path"][0].decode("utf-8")
# preauthChild allows path-separators in the "path" (i.e. not
# just a single path-segment). That is precisely what we want
# here, though. It sill does not allow the path to "jump out"
# of the base magic_path -- that is, an InsecurePath error
# will result if you pass an absolute path outside the folder
# or a relative path that reaches up too far.
try:
path = folder_config.magic_path.preauthChild(path_u)
except InsecurePath as e:
request.setResponseCode(http.NOT_ACCEPTABLE)
_application_json(request)
returnValue(json.dumps({u"reason": str(e)}))
try:
yield folder_service.local_snapshot_service.add_file(path)
except Exception as e:
request.setResponseCode(http.INTERNAL_SERVER_ERROR)
_application_json(request)
returnValue(json.dumps({u"reason": str(e)}))
request.setResponseCode(http.CREATED)
_application_json(request)
returnValue(b"{}")
def getChild(self, name, request):
try:
action = request.args['action'][0]
except KeyError:
action = None
if not action:
for obj in self._objects:
if name == str(obj.id):
return obj
return NoResource(message="The resource %s was not found" %
request.URLPath())
else:
for obj in self._objects:
if name == str(obj.id):
device_address = obj.device_address
plugin_id = obj.plugin_id
if action == 'poweron' or action == 'poweroff':
return ValueActionResult(plugin_id, device_address,
obj.name, self.coordinator,
action, {})
elif action == 'dim':
params = {'level': request.args['level'][0]}
return ValueActionResult(plugin_id, device_address,
obj.name, self.coordinator,
action, params)
elif action == 'thermostat_setpoint':
params = {'temp': request.args['temp'][0]}
return ValueActionResult(plugin_id, device_address,
obj.name, self.coordinator,
action, params)
def render_GET(self, request):
try:
token = request.args.get('token', None)[0]
fmt = request.args.get('fmt', None)[0]
auth = request.args.get('auth', None)[0]
canarydrop = Canarydrop(**get_canarydrop(canarytoken=token))
if not canarydrop:
raise NoCanarytokenPresent()
if not canarydrop['auth'] or canarydrop['auth'] != auth:
raise NoCanarytokenPresent()
if fmt == 'zip':
request.setHeader("Content-Type", "application/zip")
request.setHeader("Content-Disposition",
'attachment; filename={token}.zip'\
.format(token=token))
return make_canary_zip(hostname=canarydrop.get_hostname(
with_random=False))
elif fmt == 'msword':
request.setHeader("Content-Type",
"application/vnd.openxmlformats-officedocument"+\
".wordprocessingml.document")
request.setHeader("Content-Disposition",
'attachment; filename={token}.docx'\
.format(token=token))
return make_canary_msword(url=canarydrop.get_url())
elif fmt == 'pdf':
request.setHeader("Content-Type", "application/pdf")
request.setHeader("Content-Disposition",
'attachment; filename={token}.pdf'\
.format(token=token))
return make_canary_pdf(hostname=canarydrop.get_hostname(
nxdomain=True, with_random=False))
except Exception as e:
log.err('Unexpected error in download: {err}'.format(err=e))
return NoResource().render(request)
def parse_listings(listings):
if listings is not None:
response = {"listings": []}
for l in listings.listing:
listing_json = {
"title": l.title,
"contract_hash": l.contract_hash.encode("hex"),
"thumbnail_hash": l.thumbnail_hash.encode("hex"),
"category": l.category,
"price": l.price,
"currency_code": l.currency_code,
"nsfw": l.nsfw,
"origin": str(CountryCode.Name(l.origin)),
"ships_to": []
}
for country in l.ships_to:
listing_json["ships_to"].append(str(CountryCode.Name(country)))
response["listings"].append(listing_json)
request.setHeader('content-type', "application/json")
request.write(json.dumps(response, indent=4))
request.finish()
else:
request.write(NoResource().render(request))
request.finish()
def list_participants(self, request, folder_name):
"""
List all participants of this folder
"""
try:
folder_config = self._global_config.get_magic_folder(folder_name)
except ValueError:
returnValue(NoResource(b"{}"))
collective = participants_from_collective(
folder_config.collective_dircap,
folder_config.upload_dircap,
self._tahoe_client,
)
try:
participants = yield collective.list()
except Exception:
# probably should log this failure
request.setResponseCode(http.INTERNAL_SERVER_ERROR)
_application_json(request)
returnValue(
json.dumps({
"reason": "unexpected error processing request"
}).encode("utf-8"))
reply = {
part.name: {
"personal_dmd": part.dircap.decode("ascii"),
# not tracked properly yet
# "public_key": part.verify_key.encode(Base32Encoder),
}
for part in participants
}
request.setResponseCode(http.OK)
_application_json(request)
returnValue(json.dumps(reply).encode("utf8"))
