Reorder times so that they are 8-byte aligned

Author: tannewt

README.rst

@@ -160,8 +160,8 @@ The header is four fixed entries and a variable length path:
 * 1 Byte reserved for padding.
 * Path length: 16-bit number encoding the encoded length of the path string.
 * Offset: 32-bit number encoding the starting offset to write.
-* Total size: 32-bit number encoding the total length of the file contents.
 * Current time: 64-bit number encoding nanoseconds since January 1st, 1970. Used as the file modification time. Not all system will support the full resolution. Use the truncated time response value for caching.
+* Total size: 32-bit number encoding the total length of the file contents.
 * Path: UTF-8 encoded string that is *not* null terminated. (We send the length instead.)
 
 The server will repeatedly respond until the total length has been transferred with:
@@ -170,8 +170,8 @@ The server will repeatedly respond until the total length has been transferred w
 * Status: Single byte. ``0x01`` if OK. ``0x02`` if any parent directory is missing or a file.
 * 2 Bytes reserved for padding.
 * Offset: 32-bit number encoding the starting offset to write. (Should match the offset from the previous 0x20 or 0x22 message)
-* Free space: 32-bit number encoding the amount of data the client can send.
 * Truncated time: 64-bit number encoding nanoseconds since January 1st, 1970 as stored by the file system. The resolution may be less that the protocol. It is sent back for use in caching on the host side.
+* Free space: 32-bit number encoding the amount of data the client can send.
 
 The client will repeatedly respond until the total length has been transferred with:
 
@@ -216,14 +216,15 @@ The header is two fixed entries and a variable length path:
 * Command: Single byte. Always ``0x40``.
 * 1 Byte reserved for padding.
 * Path length: 16-bit number encoding the encoded length of the path string.
+* 4 Bytes reserved for padding.
 * Current time: 64-bit number encoding nanoseconds since January 1st, 1970. Used as the file modification time. Not all system will support the full resolution. Use the truncated time response value for caching.
 * Path: UTF-8 encoded string that is *not* null terminated. (We send the length instead.)
 
 The server will reply with:
 
 * Command: Single byte. Always ``0x41``.
 * Status: Single byte. ``0x01`` if the directory(s) were created or ``0x02`` if any parent of the path is an existing file.
-* 2 Bytes reserved for padding.
+* 6 Bytes reserved for padding.
 * Truncated time: 64-bit number encoding nanoseconds since January 1st, 1970 as stored by the file system. The resolution may be less that the protocol. It is sent back for use in caching on the host side.
 
 ``0x50`` - List a directory
@@ -250,8 +251,8 @@ The server will reply with n+1 entries for a directory with n files:
   - Bit 0: Set when the entry is a directory
   - Bits 1-7: Reserved
 
-* File size: 32-bit number encoding the size of the file. Ignore for directories. Value may change.
 * Modification time: 64-bit number of nanoseconds since January 1st, 1970. *However*, files modifiers may not have an accurate clock so do *not* assume it is correct. Instead, only use it to determine cacheability vs a local copy.
+* File size: 32-bit number encoding the size of the file. Ignore for directories. Value may change.
 * Path: UTF-8 encoded string that is *not* null terminated. (We send the length instead.) These paths are relative so they won't contain ``/`` at all.
 
 The transaction is complete when the final entry is sent from the server. It will have entry number == total entries and zeros for flags, file size and path length.

adafruit_ble_file_transfer.py

@@ -120,7 +120,7 @@ class FileTransferClient:
     def __init__(self, service):
         self._service = service
 
-        if service.version != 4:
+        if service.version < 3:
             raise RuntimeError("Service on other device too old")
 
     def _write(self, buffer):
@@ -221,21 +221,21 @@ def write(self, path, contents, *, offset=0, modification_time=None):
             modification_time = int(time.time() * 1_000_000_000)
         encoded = (
             struct.pack(
-                "<BxHIIQ",
+                "<BxHIQI",
                 FileTransferService.WRITE,
                 len(path),
                 offset,
-                total_length,
                 modification_time,
+                total_length,
             )
             + path
         )
         self._write(encoded)
-        b = bytearray(struct.calcsize("<BBxxIIQ"))
+        b = bytearray(struct.calcsize("<BBxxIQI"))
         written = 0
         while written < len(contents):
             self._readinto(b)
-            cmd, status, current_offset, free_space, _ = struct.unpack("<BBxxIIQ", b)
+            cmd, status, current_offset, _, free_space = struct.unpack("<BBxxIQI", b)
             if status != FileTransferService.OK:
                 print("write error", status)
                 raise RuntimeError()
@@ -268,7 +268,7 @@ def write(self, path, contents, *, offset=0, modification_time=None):
 
         # Wait for confirmation that everything was written ok.
         self._readinto(b)
-        cmd, status, offset, free_space, truncated_time = struct.unpack("<BBxxIIQ", b)
+        cmd, status, offset, truncated_time, free_space = struct.unpack("<BBxxIQI", b)
         if cmd != FileTransferService.WRITE_PACING or offset != total_length:
             raise ProtocolError()
         return truncated_time
@@ -280,15 +280,15 @@ def mkdir(self, path, modification_time=None):
             modification_time = int(time.time() * 1_000_000_000)
         encoded = (
             struct.pack(
-                "<BxHQ", FileTransferService.MKDIR, len(path), modification_time
+                "<BxHxxxxQ", FileTransferService.MKDIR, len(path), modification_time
             )
             + path
         )
         self._write(encoded)
 
-        b = bytearray(struct.calcsize("<BBxxQ"))
+        b = bytearray(struct.calcsize("<BBxxxxxxQ"))
         self._readinto(b)
-        cmd, status, truncated_time = struct.unpack("<BBxxQ", b)
+        cmd, status, truncated_time = struct.unpack("<BBxxxxxxQ", b)
         if cmd != FileTransferService.MKDIR_STATUS:
             raise ProtocolError()
         if status != FileTransferService.OK:
@@ -305,7 +305,7 @@ def listdir(self, path):
         b = bytearray(self._service.raw.incoming_packet_length)
         i = 0
         total = 10  # starting value that will be replaced by the first response
-        header_size = struct.calcsize("<BBHIIIIQ")
+        header_size = struct.calcsize("<BBHIIIQI")
         path_length = 0
         encoded_path = b""
         file_size = 0
@@ -329,9 +329,9 @@ def listdir(self, path):
                         i,
                         total,
                         flags,
-                        file_size,
                         modification_time,
-                    ) = struct.unpack_from("<BBHIIIIQ", b, offset=offset)
+                        file_size,
+                    ) = struct.unpack_from("<BBHIIIQI", b, offset=offset)
                     offset += header_size
                     encoded_path = b""
                     if cmd != FileTransferService.LISTDIR_ENTRY:
@@ -362,6 +362,8 @@ def delete(self, path):
 
     def move(self, old_path, new_path):
         """Moves the file or directory from old_path to new_path."""
+        if self._service.version < 4:
+            raise RuntimeError("Service on other device too old")
         old_path = old_path.encode("utf-8")
         new_path = new_path.encode("utf-8")
         encoded = (

examples/ble_file_transfer_listdirs.py

@@ -0,0 +1,54 @@
+# SPDX-FileCopyrightText: 2020 ladyada for Adafruit Industries
+# SPDX-License-Identifier: MIT
+
+"""
+Used with ble_uart_echo_test.py. Transmits "echo" to the UARTService and receives it back.
+"""
+
+import sys
+
+from adafruit_ble import BLERadio
+from adafruit_ble.advertising.standard import (
+    ProvideServicesAdvertisement,
+    Advertisement,
+)
+import adafruit_ble_file_transfer
+
+# Connect to a file transfer device
+ble = BLERadio()
+connection = None
+print("disconnected, scanning")
+for advertisement in ble.start_scan(
+    ProvideServicesAdvertisement, Advertisement, timeout=1
+):
+    # print(advertisement.address, advertisement.address.type)
+    if (
+        not hasattr(advertisement, "services")
+        or adafruit_ble_file_transfer.FileTransferService not in advertisement.services
+    ):
+        continue
+    connection = ble.connect(advertisement)
+    peer_address = advertisement.address
+    print("connected to", advertisement.address)
+    break
+ble.stop_scan()
+
+if not connection:
+    print("No advertisement found")
+    sys.exit(1)
+
+# Prep the connection
+if adafruit_ble_file_transfer.FileTransferService not in connection:
+    print("Connected device missing file transfer service")
+    sys.exit(1)
+if not connection.paired:
+    print("pairing")
+    connection.pair()
+print("paired")
+print()
+service = connection[adafruit_ble_file_transfer.FileTransferService]
+client = adafruit_ble_file_transfer.FileTransferClient(service)
+
+# Do the file operations
+print(client.listdir("/"))
+print(client.listdir("/lib/"))

examples/ble_file_transfer_stub_server.py

@@ -113,10 +113,10 @@ def read_complete_path(starting_path, total_length):
             (
                 path_length,
                 start_offset,
-                content_length,
                 modification_time,
-            ) = struct.unpack_from("<xHIIQ", p, offset=1)
-            path_start = struct.calcsize("<BxHIIQ")
+                content_length,
+            ) = struct.unpack_from("<xHIQI", p, offset=1)
+            path_start = struct.calcsize("<BxHIQI")
             path = read_complete_path(p[path_start:], path_length)
 
             d = find_dir(path)
@@ -144,12 +144,12 @@ def read_complete_path(starting_path, total_length):
             while contents_read < content_length and ok:
                 next_amount = min(CHUNK_SIZE, content_length - contents_read)
                 header = struct.pack(
-                    "<BBxxIIQ",
+                    "<BBxxIQI",
                     FileTransferService.WRITE_PACING,
                     FileTransferService.OK,
                     contents_read,
-                    next_amount,
                     truncated_time,
+                    next_amount,
                 )
                 write_packets(header)
                 read = read_packets(
@@ -164,12 +164,12 @@ def read_complete_path(starting_path, total_length):
                 if cmd != FileTransferService.WRITE_DATA:
                     write_packets(
                         struct.pack(
-                            "<BBxxIIQ",
+                            "<BBxxIQI",
                             FileTransferService.WRITE_PACING,
                             FileTransferService.ERROR_PROTOCOL,
                             0,
-                            0,
                             truncated_time,
+                            0,
                         )
                     )
                     print("protocol error, resetting")
@@ -186,12 +186,12 @@ def read_complete_path(starting_path, total_length):
             disconnect_after = time.monotonic() + 0.7
             write_packets(
                 struct.pack(
-                    "<BBxxIIQ",
+                    "<BBxxIQI",
                     FileTransferService.WRITE_PACING,
                     FileTransferService.OK,
                     content_length,
-                    0,
                     truncated_time,
+                    0,
                 )
             )
         elif command == adafruit_ble_file_transfer.FileTransferService.READ:
@@ -267,11 +267,11 @@ def read_complete_path(starting_path, total_length):
                     print("mismatched offset")
                     break
         elif command == adafruit_ble_file_transfer.FileTransferService.MKDIR:
-            path_length, modification_time = struct.unpack_from("<xHQ", p, offset=1)
+            path_length, modification_time = struct.unpack_from("<xHxxxxQ", p, offset=1)
             # Trucate to the nearest 3 seconds.
             truncation = 3 * 1_000_000_000
             truncated_time = (modification_time // truncation) * truncation
-            path_start = struct.calcsize("<BxHQ")
+            path_start = struct.calcsize("<BxHxxxxQ")
             path = read_complete_path(p[path_start:], path_length)
             pieces = path.split("/")[1:-1]
             parent = stored_data
@@ -288,15 +288,15 @@ def read_complete_path(starting_path, total_length):
 
             if ok:
                 header = struct.pack(
-                    "<BBxxQ",
+                    "<BBxxxxxxQ",
                     FileTransferService.MKDIR_STATUS,
                     FileTransferService.OK,
                     truncated_time,
                 )
                 stored_timestamps[path] = truncated_time
             else:
                 header = struct.pack(
-                    "<BBxxQ",
+                    "<BBxxxxxxQ",
                     FileTransferService.MKDIR_STATUS,
                     FileTransferService.ERR,
                     0,
@@ -312,7 +312,7 @@ def read_complete_path(starting_path, total_length):
             d = find_dir(path)
             if d is None:
                 error = struct.pack(
-                    "<BBHIIIIQ",
+                    "<BBHIIIQI",
                     FileTransferService.LISTDIR_ENTRY,
                     FileTransferService.ERROR,
                     0,
@@ -341,21 +341,21 @@ def read_complete_path(starting_path, total_length):
                     full_file_path += "/"
                 timestamp = stored_timestamps[full_file_path]
                 header = struct.pack(
-                    "<BBHIIIIQ",
+                    "<BBHIIIQI",
                     FileTransferService.LISTDIR_ENTRY,
                     FileTransferService.OK,
                     len(encoded_filename),
                     i,
                     total_files,
                     flags,
-                    content_length,
                     timestamp,
+                    content_length,
                 )
                 packet = header + encoded_filename
                 write_packets(packet)
 
             header = struct.pack(
-                "<BBHIIIIQ",
+                "<BBHIIIQI",
                 FileTransferService.LISTDIR_ENTRY,
                 FileTransferService.OK,
                 0,