Fix long path handling, listdir and delete

Author: tannewt

adafruit_ble_file_transfer.py

@@ -103,6 +103,8 @@ class FileTransferService(Service):
 
     ERR_NO_FILE = 0xb0
 
+    DIRECTORY = 0x01
+
 
 class FileTransferClient:
     def __init__(self, service):
@@ -122,14 +124,14 @@ def _readinto(self, buffer):
         while read == 0:
             try:
                 read = self._service.raw.readinto(buffer)
-            except ValueError:
+            except ValueError as e:
+                print(e)
                 long_buffer = bytearray(512)
                 read = self._service.raw.readinto(long_buffer)
                 print("long packet", long_buffer[:read])
         return read
 
     def read(self, path):
-        print("read", path)
         path = path.encode("utf-8")
         chunk_size = 10
         encoded = struct.pack(">BIH", FileTransferService.READ, chunk_size, len(path)) + path
@@ -141,68 +143,68 @@ def read(self, path):
         while content_length is None or contents_read < content_length:
             read = self._readinto(b)
             cmd, status, content_length, chunk_length = struct.unpack_from(">BBII", b)
-            print("got reply", cmd, status, content_length, chunk_length)
             if status != FileTransferService.OK:
                 raise ValueError("Missing file")
             if buf is None:
                 buf = bytearray(content_length)
             header_size = struct.calcsize(">BBII")
-            print(read, header_size)
             buf[contents_read:contents_read + (read - header_size)] = b[header_size:read]
             contents_read += read - header_size
-            print("total read", contents_read, buf)
             chunk_size = min(10, content_length - contents_read)
-            print("replying requesting", chunk_size)
             encoded = struct.pack(">BBI", FileTransferService.READ, FileTransferService.OK, chunk_size)
             r = self._service.raw.write(encoded)
-        print("return", buf)
         return buf
 
     def write(self, path, contents):
-        print("write", path, contents)
         path = path.encode("utf-8")
         encoded = struct.pack(">BIH", FileTransferService.WRITE, len(contents), len(path)) + path
         r = self._write(encoded)
         b = bytearray(struct.calcsize(">BBI"))
-        print("write", r, encoded)
         written = 0
         while written < len(contents):
             read = self._readinto(b)
             cmd, status, free_space = struct.unpack(">BBI", b)
-            print(cmd, status, free_space)
             self._service.raw.write(contents[written:written+free_space])
             written += free_space
 
     def mkdir(self, path):
-        print("mkdir", path)
         path = path.encode("utf-8")
         encoded = struct.pack(">BH", FileTransferService.MKDIR, len(path)) + path
         r = self._write(encoded)
 
         b = bytearray(struct.calcsize(">BB"))
         read = self._readinto(b)
         cmd, status = struct.unpack(">BB", b)
-        print(cmd, status)
 
     def listdir(self, path):
-        print("listdir", path)
+        paths = []
         path = path.encode("utf-8")
         chunk_size = 10
         encoded = struct.pack(">BH", FileTransferService.LISTDIR, len(path)) + path
         r = self._write(encoded)
-        b = bytearray(struct.calcsize(">BBIIBIH"))
+        b = bytearray(self._service.raw.incoming_packet_length)
         i = 0
-        total = 10
+        total = 10 # starting value that will be replaced by the first response
+        header_size = struct.calcsize(">BBIIBIH")
         while i < total:
             read = self._readinto(b)
-            cmd, status, i, total, flags, file_size, path_length = struct.unpack(">BBIIBIH", b)
-            if i >= total:
-                break
-            if len(b) < path_length:
-                b = bytearray(path_length)
-            read = self._readinto(b)
-            path = str(b[:read], "utf-8")
-            print(i, total, flags, file_size, path)
+            offset = 0
+            while offset < read:
+                cmd, status, i, total, flags, file_size, path_length = struct.unpack_from(">BBIIBIH", b, offset=offset)
+                if i >= total:
+                    break
+                path = str(b[offset + header_size:offset+header_size + path_length], "utf-8")
+                paths.append((path, file_size, flags))
+                offset += header_size + path_length
+        return paths
 
     def delete(self, path):
-        print("delete", path)
+        path = path.encode("utf-8")
+        encoded = struct.pack(">BH", FileTransferService.DELETE, len(path)) + path
+        r = self._write(encoded)
+
+        b = bytearray(struct.calcsize(">BB"))
+        read = self._readinto(b)
+        cmd, status = struct.unpack(">BB", b)
+        if status != FileTransferService.OK:
+            raise ValueError("Missing file")

examples/ble_file_transfer_simpletest.py

@@ -31,9 +31,21 @@
                 print(c)
                 client.mkdir("/world/")
                 print(client.listdir("/world/"))
-                client.write("/world/hello.txt", "Hi world".encode("utf-8"))
+                client.write("/world/hi.txt", "Hi world".encode("utf-8"))
+                client.write("/world/hello.txt", "Hello world".encode("utf-8"))
+                c = client.read("/world/hello.txt")
+                print(c)
+                print(client.listdir("/world/"))
+                client.delete("/world/hello.txt")
+                try:
+                    client.delete("/world/") # should raise an exception
+                except ValueError:
+                    print("exception correctly raised")
                 print(client.listdir("/world/"))
-            time.sleep(5)
+                client.delete("/world/hi.txt")
+                client.delete("/world/")
+                print(client.listdir("/"))
+            time.sleep(20)
     except ConnectionError:
         pass
 

examples/ble_file_transfer_stub_server.py

@@ -36,6 +36,29 @@ def find_dir(path):
         i += 1
     return parent
 
+def read_packets(buf, *, target_size=None):
+    if not target_size:
+        target_size = len(buf)
+    total_read = 0
+    buf = memoryview(buf)
+    while total_read < target_size:
+        read = service.raw.readinto(buf[total_read:])
+        total_read += read
+
+    return read
+
+def write_packets(buf):
+    service.raw.write(buf)
+
+def read_complete_path(starting_path, total_length):
+    path = bytearray(total_length)
+    current_path_length = len(starting_path)
+    remaining_path = total_length - current_path_length
+    path[:current_path_length] = starting_path
+    if remaining_path > 0:
+        read_packets(memoryview(path)[current_path_length:], target_size=remaining_path)
+    return str(path, "utf-8")
+
 packet_buffer = bytearray(256)
 out_buffer = bytearray(256)
 while True:
@@ -55,58 +78,47 @@ def find_dir(path):
         if command == FileTransferService.WRITE:
             content_length, path_length = struct.unpack_from(">IH", p, offset=1)
             path_start = struct.calcsize(">BIH")
-            path = str(p[path_start:path_start+path_length], "utf-8")
+            path = read_complete_path(p[path_start:], path_length)
             contents_read = 0
             contents = bytearray(content_length)
-            print("write", content_length, path)
             d = find_dir(path)
             filename = path.split("/")[-1]
-            print(filename)
             while contents_read < content_length:
                 next_amount = min(10, content_length - contents_read)
-                #print(FileTransferService.WRITE, FileTransferService.OK)
-                service.raw.write(struct.pack(">BBI", FileTransferService.WRITE, FileTransferService.OK, next_amount))
-                read = service.raw.readinto(packet_buffer)
-                while read == 0:
-                    read = service.raw.readinto(packet_buffer)
+                header = struct.pack(">BBI", FileTransferService.WRITE, FileTransferService.OK, next_amount)
+                write_packets(header)
+                read = read_packets(packet_buffer, target_size=next_amount)
                 contents[contents_read:contents_read+read] = packet_buffer[:read]
                 contents_read += read
-                print(read, packet_buffer[:read])
             d[filename] = contents
 
         elif command == adafruit_ble_file_transfer.FileTransferService.READ:
             free_space, path_length = struct.unpack_from(">IH", p, offset=1)
             path_start = struct.calcsize(">BIH")
-            path = str(p[path_start:path_start+path_length], "utf-8")
-            print("read", path)
+            path = read_complete_path(p[path_start:], path_length)
             d = find_dir(path)
             filename = path.split("/")[-1]
             if filename not in d:
                 print("missing path")
-                service.raw.write(struct.pack(">BBII", FileTransferService.READ, FileTransferService.ERR, 0, 0))
+                error_response = struct.pack(">BBII", FileTransferService.READ, FileTransferService.ERR, 0, 0)
+                write_packets(error_response)
                 continue
 
             contents_sent = 0
-            contents = stored_data[filename]
+            contents = d[filename]
             while contents_sent < len(contents):
                 remaining = len(contents) - contents_sent
                 next_amount = min(remaining, free_space)
-                print("sending", next_amount)
                 header = struct.pack(">BBII", FileTransferService.READ, FileTransferService.OK, len(contents), next_amount)
-                service.raw.write(header + contents[contents_sent:contents_sent + next_amount])
+                write_packets(header + contents[contents_sent:contents_sent + next_amount])
                 contents_sent += next_amount
 
-                # Wait for the next free amount even if we've sent everything. A 0 free reply can
-                # confirm everything worked.
-                read = service.raw.readinto(packet_buffer)
-                while read == 0:
-                    read = service.raw.readinto(packet_buffer)
+                read = read_packets(packet_buffer, target_size=struct.calcsize(">BBI"))
                 confirm, status, free_space = struct.unpack_from(">BBI", p)
         elif command == adafruit_ble_file_transfer.FileTransferService.MKDIR:
             path_length = struct.unpack_from(">H", p, offset=1)[0]
             path_start = struct.calcsize(">BH")
-            path = str(p[path_start:path_start+path_length], "utf-8")
-            print("mkdir", path)
+            path = read_complete_path(p[path_start:], path_length)
             pieces = path.split("/")
             parent = stored_data
             i = 1
@@ -124,30 +136,64 @@ def find_dir(path):
                 header = struct.pack(">BB", FileTransferService.WRITE, FileTransferService.OK)
             else:
                 header = struct.pack(">BB", FileTransferService.WRITE, FileTransferService.ERR)
-            service.raw.write(header)
+            write_packets(header)
         elif command == adafruit_ble_file_transfer.FileTransferService.LISTDIR:
             path_length = struct.unpack_from(">H", p, offset=1)[0]
             path_start = struct.calcsize(">BH")
-            path = str(p[path_start:path_start+path_length], "utf-8")
-            print("listdir", path)
+            path = read_complete_path(p[path_start:], path_length)
 
             # cmd, status, i, total, flags, file_size, path_length = struct.unpack(">BBIIBIH", b)
 
             d = find_dir(path)
             if d is None:
                 error = struct.pack(">BBIIBIH", FileTransferService.WRITE, FileTransferService.ERR, 0, 0, 0, 0, 0)
-                service.raw.write(error)
+                write_packets(error)
 
-            print(d, type(d))
             filenames = sorted(d.keys())
             total_files = len(filenames)
             for i, filename in enumerate(filenames):
-                print(i, filename)
-                header = struct.pack(">BBIIBIH", FileTransferService.WRITE, FileTransferService.OK, i, total_files, 0, 0, 0)
-                service.raw.write(header + filename.encode("utf-8"))
-            print("send last entry")
+                encoded_filename = filename.encode("utf-8")
+                flags = 0
+                contents = d[filename]
+                if isinstance(contents, dict):
+                    flags = FileTransferService.DIRECTORY
+                else:
+                    content_length = len(contents)
+                header = struct.pack(">BBIIBIH", FileTransferService.WRITE, FileTransferService.OK, i, total_files, flags, content_length, len(encoded_filename))
+                packet = header + encoded_filename
+                write_packets(packet)
+
             header = struct.pack(">BBIIBIH", FileTransferService.WRITE, FileTransferService.OK, total_files, total_files, 0, 0, 0)
-            service.raw.write(header)
+            write_packets(header)
+        elif command == adafruit_ble_file_transfer.FileTransferService.DELETE:
+            path_length = struct.unpack_from(">H", p, offset=1)[0]
+            path_start = struct.calcsize(">BH")
+            path = read_complete_path(p[path_start:], path_length)
+            d = find_dir(path)
+            filename = path.split("/")[-1]
+            if not filename and d:
+                print("trying to delete directory with contents")
+                error_response = struct.pack(">BB", FileTransferService.WRITE, FileTransferService.ERR)
+                write_packets(error_response)
+                continue
+
+            # We're a directory.
+            if not filename:
+                path = path[:-1]
+                filename = path.split("/")[-1]
+                d = find_dir(path)
+
+            if filename not in d:
+                print("missing path")
+                error_response = struct.pack(">BB", FileTransferService.WRITE, FileTransferService.ERR)
+                write_packets(error_response)
+                continue
+            ok = True
+
+            del d[filename]
+            
+            header = struct.pack(">BB", FileTransferService.WRITE, FileTransferService.OK)
+            write_packets(header)
         else:
             print("unknown command", command)
     print("disconnected")