def put(self, socket, request):
name = ""
body = ""
while True:
for header in request.header_data:
if isinstance(header, headers.Name):
name = header.decode()
self.logger.info("Receiving {}".format(name))
elif isinstance(header, headers.Length):
length = header.decode()
self.logger.info("Content length: {} bytes".format(length))
elif isinstance(header, headers.Body):
body += header.decode()
elif isinstance(header, headers.End_Of_Body):
body += header.decode()
if request.is_final():
break
# Ask for more data.
Server.send_response(self, socket, responses.Continue())
# Get the next part of the data.
request = self.request_handler.decode(socket)
Server.send_response(self, socket, responses.Success())
name = os.path.basename(name.strip("\x00"))
path = os.path.join(self.directory, name)
self.logger.info("Writing file {}".format(path))
open(path, "wb").write(body.encode())
self.bus.post(BluetoothFileReceivedEvent(path=path))
def _get_capabilities(self, socket, decoded_header):
"""Returns level of support for various imaging capabilities"""
logger.info("_get_capabilities invoked")
# TODO: replace with real data
capabilities_object = tools.generate_dummy_imaging_capabilities()
header_list = [
headers.End_Of_Body(tools.export_xml(capabilities_object))
]
self.send_response(socket, responses.Success(), header_list)
def _get_image_properties(self, socket, decoded_header):
"""Returns info regarding image formats, encodings etc."""
logger.info("_get_image_properties invoked")
handle = decoded_header["Img_Handle"]
if handle not in tools.DUMMY_IMAGE_HANDLES:
self.send_response(socket, responses.Not_Found(), [])
return
# TODO: replace with real data and get the properties for specified handle
img_prop_obj = tools.generate_dummy_image_properties(handle)
header_list = [headers.End_Of_Body(tools.export_xml(img_prop_obj))]
self.send_response(socket, responses.Success(), header_list)
def get(self, socket, request):
name = ""
type = ""
for header in request.header_data:
print("header is " + header)
if isinstance(header, headers.Name):
name = header.decode().strip(b"\x00")
print("Receiving request for %s" % name)
elif isinstance(header, headers.Type):
type = header.decode().strip(b"\x00")
print("Type %s" % type)
path = os.path.abspath(os.path.join(self.directory, name))
if os.path.isdir(path) or type == "x-obex/folder-listing":
details = {}
if path.startswith(self.directory):
l = os.listdir(path)
s = '<?xml version="1.0"?>\n<folder-listing>\n'
for i in l:
objpath = os.path.join(path, i)
if os.path.isdir(objpath):
details[i] = (i, os.stat(objpath)[stat.ST_CTIME])
s += ' <folder name="%s" created="%s" />' % details[i]
else:
details[i] = (i, os.stat(objpath)[stat.ST_CTIME],
os.stat(objpath)[stat.ST_SIZE])
s += ' <file name="%s" created="%s" size="%s" />' % details[
i]
s += "</folder-listing>\n"
print(s)
response = responses.Success()
response_headers = [
headers.Name(name.encode("utf8")),
headers.Length(len(s)),
headers.Body(s.encode("utf8"))
]
self.send_response(socket, response, response_headers)
else:
self._reject(socket)
else:
self._reject(socket)
def _get_image(self, socket, decoded_header, thumbnail=False):
"""Returns an Image with specified format and encoding"""
logger.info("_get_image invoked")
handle = decoded_header["Img_Handle"]
if handle not in tools.DUMMY_IMAGE_HANDLES:
self.send_response(socket, responses.Not_Found(), [])
return
if not thumbnail:
description = image_descriptor.parseString(
decoded_header["Img_Descriptor"], silence=True)
# construct a dummy image
if not thumbnail:
imagefile = tools.generate_dummy_image(
handle, description.image.encoding,
map(int, description.image.pixel.split("*")))
else:
imagefile = tools.generate_dummy_image(handle, thumbnail=True)
imagefile_size = len(imagefile)
# TODO: adjust the max packet length in obex connect, since bt rfcomm can send only ~1000 bytes at once
max_length = 700
bytes_transferred = 0
if imagefile_size < max_length:
image_last_chunk = imagefile
else:
while bytes_transferred < imagefile_size:
image_chunk = imagefile[bytes_transferred:(bytes_transferred +
max_length)]
header_list = [
headers.Length(max_length),
headers.Body(image_chunk)
]
# 'continue' response and process the subsequent requests
self.send_response(socket, responses.Continue(), header_list)
while True:
request = self.request_handler.decode(self.connection)
if not isinstance(request, requests.Get_Final):
self.process_request(self.connection, request)
continue
else:
break
bytes_transferred += max_length
image_last_chunk = ""
header_list = [
headers.Length(imagefile_size),
headers.End_Of_Body(image_last_chunk)
]
self.send_response(socket, responses.Success(), header_list)
def _get_images_list(self, socket, decoded_header):
"""Returns list of handles for available images along with file info like cdate, mdate etc"""
logger.info("_get_images_list invoked")
app_params = self._decode_app_params(decoded_header["App_Parameters"])
# TODO: replace with real data
images_listing_object = tools.generate_dummy_images_listing()
nb_returned_handles = app_params["NbReturnedHandles"]
list_startoffset = app_params["ListStartOffset"]
latest_captured_images = app_params["LatestCapturedImages"]
# filtering images of images_listing using filtering_parameters
img_handles_desc = image_handles_descriptor.parseString(
decoded_header["Img_Descriptor"], silence=True)
filtered_images_listing = self._filter_images_listing(
img_handles_desc, images_listing_object)
if nb_returned_handles == 0:
nb_returned_handles_hdr = {
"NbReturnedHandles":
headers.NbReturnedHandles(len(filtered_images_listing.image))
}
empty_image_listing = images_listing.images_listing()
header_list = [
headers.App_Parameters(nb_returned_handles_hdr),
headers.Img_Descriptor(tools.export_xml(img_handles_desc)),
headers.End_Of_Body(tools.export_xml(empty_image_listing))
]
else:
# restrict the images of images_listing using ListStartOffset and NbReturnedHandles
restricted_images_listing = self._restricted_images_listing(
filtered_images_listing, list_startoffset, nb_returned_handles)
# order descending based on created time to get latest captured images
if latest_captured_images:
restricted_images_listing.image.sort(
key=operator.attrgetter("created"), reverse=True)
nb_returned_handles_hdr = {
"NbReturnedHandles":
headers.NbReturnedHandles(len(restricted_images_listing.image))
}
header_list = [
headers.App_Parameters(nb_returned_handles_hdr),
headers.Img_Descriptor(tools.export_xml(img_handles_desc)),
headers.End_Of_Body(
tools.export_xml(restricted_images_listing))
]
self.send_response(socket, responses.Success(), header_list)
def put(self, socket, request):
body = ""
while True:
for header in request.header_data:
if isinstance(header, headers.Body):
body += header.decode()
elif isinstance(header, headers.End_Of_Body):
body += header.decode()
if request.is_final():
break
self.send_response(socket, responses.Continue())
request = self.request_handler.decode(socket)
self.q.put(body)
self.send_response(socket, responses.Success())
def put(self, socket, request):
request_type = None
request_body = ""
for header in request.header_data:
if isinstance(header, headers.Type):
request_type = header.decode()[3:]
elif isinstance(header, headers.Body):
request_body.appand(header.decode())
elif isinstance(header, header.End_Of_Body):
request_body.append(header.decode())
expected_type = "x-bt/MAP-event-report"
if request_type.startswith(expected_type):
response = responses.Success()
self.send_response(socket, response)
else:
self._reject(socket)
def put(self, socket, request):
name = ""
length = 0
body = ""
while True:
for header in request.header_data:
if isinstance(header, headers.Name):
name = header.decode()
print("Receiving %s" % name)
elif isinstance(header, headers.Length):
length = header.decode()
print("Length %i" % length)
elif isinstance(header, headers.Body):
body += header.decode()
elif isinstance(header, headers.End_Of_Body):
body += header.decode()
if request.is_final():
break
# Ask for more data.
self.send_response(socket, responses.Continue())
# Get the next part of the data.
request = self.request_handler.decode(socket)
self.send_response(socket, responses.Success())
name = name.strip("\x00").encode(sys.getfilesystemencoding())
name = os.path.split(name)[1]
path = os.path.join(self.directory, name)
print("Writing %s" % repr(path))
open(path, "wb").write(body)
def disconnect(self, socket):
response = responses.Success()
self.send_response(socket, response)
self.connected = False
