More listdir work

Author: tannewt

adafruit_ble_file_transfer.py

@@ -103,29 +103,47 @@ class FileTransferService(Service):
 
     ERR_NO_FILE = 0xb0
 
+
 class FileTransferClient:
     def __init__(self, service):
         self._service = service
 
+    def _write(self, buffer):
+        sent = 0
+        while sent < len(buffer):
+            remaining = len(buffer) - sent
+            next_send = min(self._service.raw.outgoing_packet_length, remaining)
+            self._service.raw.write(buffer[sent:sent+next_send])
+            sent += next_send
+
+    def _readinto(self, buffer):
+        read = 0
+        # Read back how much we can write
+        while read == 0:
+            try:
+                read = self._service.raw.readinto(buffer)
+            except ValueError:
+                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
-        # TODO: we may need to split this packet up.
-        r = self._service.raw.write(encoded)
+        r = self._write(encoded)
         b = bytearray(struct.calcsize(">BBII") + chunk_size)
-        print("write", r, encoded)
         contents_read = 0
         content_length = None
         buf = None
         while content_length is None or contents_read < content_length:
-            read = 0
-            # Read back how much we can write
-            while read == 0:
-                read = self._service.raw.readinto(b)
+            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")
@@ -144,16 +162,12 @@ 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
-        # TODO: we may need to split this packet up.
-        r = self._service.raw.write(encoded)
+        r = self._write(encoded)
         b = bytearray(struct.calcsize(">BBI"))
         print("write", r, encoded)
         written = 0
         while written < len(contents):
-            read = 0
-            # Read back how much we can write
-            while read == 0:
-                read = self._service.raw.readinto(b)
+            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])
@@ -163,19 +177,32 @@ def mkdir(self, path):
         print("mkdir", path)
         path = path.encode("utf-8")
         encoded = struct.pack(">BH", FileTransferService.MKDIR, len(path)) + path
-        # TODO: we may need to split this packet up.
-        r = self._service.raw.write(encoded)
+        r = self._write(encoded)
 
         b = bytearray(struct.calcsize(">BB"))
-        read = 0
-        # Read back how much we can write
-        while read == 0:
-            read = self._service.raw.readinto(b)
+        read = self._readinto(b)
         cmd, status = struct.unpack(">BB", b)
         print(cmd, status)
 
     def listdir(self, path):
         print("listdir", path)
+        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"))
+        i = 0
+        total = 10
+        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)
 
     def delete(self, path):
         print("delete", path)

examples/ble_file_transfer_stub_server.py

@@ -32,7 +32,7 @@ def find_dir(path):
         piece = pieces[i]
         if piece not in parent:
             return None
-        parent = piece
+        parent = parent[piece]
         i += 1
     return parent
 
@@ -59,7 +59,9 @@ def find_dir(path):
             contents_read = 0
             contents = bytearray(content_length)
             print("write", content_length, path)
-            print(path.split("/"))
+            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)
@@ -69,27 +71,28 @@ def find_dir(path):
                     read = service.raw.readinto(packet_buffer)
                 contents[contents_read:contents_read+read] = packet_buffer[:read]
                 contents_read += read
-                #print(read, packet_buffer[:read])
-            stored_data[path] = contents
+                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)
             d = find_dir(path)
-            if path not in d:
+            filename = path.split("/")[-1]
+            if filename not in d:
                 print("missing path")
-                service.raw.write(struct.pack(">BBB", FileTransferService.READ, FileTransferService.ERR, FileTransferService.ERR_NO_FILE))
+                service.raw.write(struct.pack(">BBII", FileTransferService.READ, FileTransferService.ERR, 0, 0))
                 continue
 
             contents_sent = 0
-            contents = stored_data[path]
+            contents = stored_data[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.WRITE, FileTransferService.OK, len(contents), 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])
                 contents_sent += next_amount
 
@@ -122,6 +125,29 @@ def find_dir(path):
             else:
                 header = struct.pack(">BB", FileTransferService.WRITE, FileTransferService.ERR)
             service.raw.write(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)
+
+            # 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)
+
+            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")
+            header = struct.pack(">BBIIBIH", FileTransferService.WRITE, FileTransferService.OK, total_files, total_files, 0, 0, 0)
+            service.raw.write(header)
         else:
             print("unknown command", command)
     print("disconnected")