circuitpython/supervisor/shared/bluetooth.c

/*
 * This file is part of the MicroPython project, http://micropython.org/
 *
 * The MIT License (MIT)
 *
 * Copyright (c) 2019-2021 Scott Shawcroft for Adafruit Industries
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */

#if !CIRCUITPY_BLE_FILE_SERVICE

void supervisor_bluetooth_init(void) {
}

void supervisor_start_bluetooth(void) {
}

void supervisor_bluetooth_background(void) {
}

#else

#include <string.h>

#include "supervisor/shared/bluetooth.h"

#include "extmod/vfs.h"
#include "extmod/vfs_fat.h"

#include "shared-bindings/_bleio/__init__.h"
#include "shared-bindings/_bleio/Adapter.h"
#include "shared-bindings/_bleio/Characteristic.h"
#include "shared-bindings/_bleio/PacketBuffer.h"
#include "shared-bindings/_bleio/Service.h"
#include "shared-bindings/_bleio/UUID.h"
#if defined(CIRCUITPY_BOOT_BUTTON)
#include "shared-bindings/digitalio/DigitalInOut.h"
#endif
#include "shared-bindings/microcontroller/Processor.h"
#include "shared-bindings/microcontroller/ResetReason.h"
#include "shared-module/storage/__init__.h"

#include "bluetooth/ble_drv.h"

#include "common-hal/_bleio/__init__.h"

#include "supervisor/shared/autoreload.h"
#include "supervisor/shared/status_leds.h"
#include "supervisor/shared/tick.h"
#include "supervisor/usb.h"

#include "py/mpstate.h"

bleio_service_obj_t supervisor_ble_service;
bleio_uuid_obj_t supervisor_ble_service_uuid;
bleio_characteristic_obj_t supervisor_ble_version_characteristic;
bleio_uuid_obj_t supervisor_ble_version_uuid;
bleio_characteristic_obj_t supervisor_ble_transfer_characteristic;
bleio_uuid_obj_t supervisor_ble_transfer_uuid;

// This is the base UUID for the file transfer service.
const uint8_t file_transfer_base_uuid[16] = {0x72, 0x65, 0x66, 0x73, 0x6e, 0x61, 0x72, 0x54, 0x65, 0x6c, 0x69, 0x46, 0x00, 0x00, 0xaf, 0xad };
// This standard advertisement advertises the CircuitPython editing service and a CIRCUITPY short name.
const uint8_t public_advertising_data[] = { 0x02, 0x01, 0x06, // 0-2 Flags
                                            0x02, 0x0a, 0xd8,  // 3-5 TX power level -40
                                            0x03, 0x02, 0xbb, 0xfe,  // 6 - 9 Incomplete service list (File Transfer service)
                                            0x0e, 0xff, 0x22, 0x08,  // 10 - 13 Adafruit Manufacturer Data
                                            0x0a, 0x04, 0x00,        // 14 - 16 Creator ID / Creation ID
                                            CIRCUITPY_CREATOR_ID & 0xff,              // 17 - 20 Creator ID
                                            (CIRCUITPY_CREATOR_ID >> 8) & 0xff,
                                            (CIRCUITPY_CREATOR_ID >> 16) & 0xff,
                                            (CIRCUITPY_CREATOR_ID >> 24) & 0xff,
                                            CIRCUITPY_CREATION_ID & 0xff,              // 21 - 24 Creation ID
                                            (CIRCUITPY_CREATION_ID >> 8) & 0xff,
                                            (CIRCUITPY_CREATION_ID >> 16) & 0xff,
                                            (CIRCUITPY_CREATION_ID >> 24) & 0xff,
                                            0x05, 0x08, 0x43, 0x49, 0x52, 0x43  // 25 - 31 - Short name
};
const uint8_t private_advertising_data[] = { 0x02, 0x01, 0x06, // 0-2 Flags
                                             0x02, 0x0a, 0x00 // 3-5 TX power level 0
};
// This scan response advertises the full CIRCUITPYXXXX device name.
uint8_t circuitpython_scan_response_data[15] = {0x0e, 0x09, 0x43, 0x49, 0x52, 0x43, 0x55, 0x49, 0x54, 0x50, 0x59, 0x00, 0x00, 0x00, 0x00};
mp_obj_list_t service_list;
mp_obj_t service_list_items[1];
mp_obj_list_t characteristic_list;
mp_obj_t characteristic_list_items[2];
// 2 * 10 ringbuf packets, 512 for a disk sector and 12 for the file transfer write header.
#define PACKET_BUFFER_SIZE (2 * 10 + 512 + 12)
// uint32_t so its aligned
uint32_t _buffer[PACKET_BUFFER_SIZE / 4 + 1];
uint32_t _outgoing1[BLE_GATTS_VAR_ATTR_LEN_MAX / 4];
uint32_t _outgoing2[BLE_GATTS_VAR_ATTR_LEN_MAX / 4];
ble_drv_evt_handler_entry_t static_handler_entry;
bleio_packet_buffer_obj_t _transfer_packet_buffer;
bool boot_in_discovery_mode = false;
bool advertising = false;

STATIC void supervisor_bluetooth_start_advertising(void) {
    bool is_connected = common_hal_bleio_adapter_get_connected(&common_hal_bleio_adapter_obj);
    if (is_connected) {
        return;
    }
    bool bonded = common_hal_bleio_adapter_is_bonded_to_central(&common_hal_bleio_adapter_obj);
    #if CIRCUITPY_USB
    // Don't advertise when we have USB instead of BLE.
    if (!bonded && !boot_in_discovery_mode) {
        // mp_printf(&mp_plat_print, "skipping advertising\n");
        return;
    }
    #endif
    uint32_t timeout = 0;
    float interval = 0.1f;
    int tx_power = 0;
    const uint8_t *adv = private_advertising_data;
    size_t adv_len = sizeof(private_advertising_data);
    const uint8_t *scan_response = NULL;
    size_t scan_response_len = 0;
    // Advertise with less power when doing so publicly to reduce who can hear us. This will make it
    // harder for someone with bad intentions to pair from a distance.
    if (!bonded) {
        tx_power = -40;
        adv = public_advertising_data;
        adv_len = sizeof(public_advertising_data);
        scan_response = circuitpython_scan_response_data;
        scan_response_len = sizeof(circuitpython_scan_response_data);
    }
    uint32_t status = _common_hal_bleio_adapter_start_advertising(&common_hal_bleio_adapter_obj,
        true,
        bonded, // Advertise anonymously if we are bonded
        timeout,
        interval,
        adv,
        adv_len,
        scan_response,
        scan_response_len,
        tx_power,
        NULL);
    // This may fail if we are already advertising.
    advertising = status == NRF_SUCCESS;
}

#define BLE_DISCOVERY_DATA_GUARD 0xbb0000bb
#define BLE_DISCOVERY_DATA_GUARD_MASK 0xff0000ff

void supervisor_bluetooth_init(void) {
    uint32_t reset_state = port_get_saved_word();
    uint32_t ble_mode = 0;
    if ((reset_state & BLE_DISCOVERY_DATA_GUARD_MASK) == BLE_DISCOVERY_DATA_GUARD) {
        ble_mode = (reset_state & ~BLE_DISCOVERY_DATA_GUARD_MASK) >> 8;
    }
    const mcu_reset_reason_t reset_reason = common_hal_mcu_processor_get_reset_reason();
    boot_in_discovery_mode = false;
    if (reset_reason != RESET_REASON_POWER_ON &&
        reset_reason != RESET_REASON_RESET_PIN &&
        reset_reason != RESET_REASON_UNKNOWN &&
        reset_reason != RESET_REASON_SOFTWARE) {
        return;
    }

    // ble_mode = 1;

    if (ble_mode == 0) {
        port_set_saved_word(BLE_DISCOVERY_DATA_GUARD | (0x01 << 8));
    }
    // Wait for a while to allow for reset.

    #ifdef CIRCUITPY_BOOT_BUTTON
    digitalio_digitalinout_obj_t boot_button;
    common_hal_digitalio_digitalinout_construct(&boot_button, CIRCUITPY_BOOT_BUTTON);
    common_hal_digitalio_digitalinout_switch_to_input(&boot_button, PULL_UP);
    #endif
    uint64_t start_ticks = supervisor_ticks_ms64();
    uint64_t diff = 0;
    if (ble_mode != 0) {
        #ifdef CIRCUITPY_STATUS_LED
        new_status_color(0x0000ff);
        #endif
        common_hal_bleio_adapter_erase_bonding(&common_hal_bleio_adapter_obj);
        boot_in_discovery_mode = true;
        reset_state = 0x0;
    }
    while (diff < 1000) {
        #ifdef CIRCUITPY_STATUS_LED
        // Blink on for 100, off for 100, on for 100, off for 100 and on for 200
        bool led_on = ble_mode != 0 || (diff % 150) <= 75;
        if (led_on) {
            new_status_color(0x0000ff);
        } else {
            new_status_color(BLACK);
        }
        #endif
        #ifdef CIRCUITPY_BOOT_BUTTON
        if (!common_hal_digitalio_digitalinout_get_value(&boot_button)) {
            boot_in_discovery_mode = true;
            break;
        }
        #endif
        diff = supervisor_ticks_ms64() - start_ticks;
    }
    #if CIRCUITPY_STATUS_LED
    new_status_color(BLACK);
    status_led_deinit();
    #endif
    port_set_saved_word(reset_state);
}

void supervisor_start_bluetooth(void) {
    common_hal_bleio_adapter_set_enabled(&common_hal_bleio_adapter_obj, true);

    supervisor_ble_service_uuid.base.type = &bleio_uuid_type;
    common_hal_bleio_uuid_construct(&supervisor_ble_service_uuid, 0xfebb, NULL);

    // We know we'll only be 1 characteristic so we can statically allocate it.
    characteristic_list.base.type = &mp_type_list;
    characteristic_list.alloc = sizeof(characteristic_list_items) / sizeof(characteristic_list_items[0]);
    characteristic_list.len = 0;
    characteristic_list.items = characteristic_list_items;
    mp_seq_clear(characteristic_list.items, 0, characteristic_list.alloc, sizeof(*characteristic_list.items));

    _common_hal_bleio_service_construct(&supervisor_ble_service, &supervisor_ble_service_uuid, false /* is secondary */, &characteristic_list);

    // Version number
    supervisor_ble_version_uuid.base.type = &bleio_uuid_type;
    common_hal_bleio_uuid_construct(&supervisor_ble_version_uuid, 0x0100, file_transfer_base_uuid);
    common_hal_bleio_characteristic_construct(&supervisor_ble_version_characteristic,
        &supervisor_ble_service,
        0,                                       // handle (for remote only)
        &supervisor_ble_version_uuid,
        CHAR_PROP_READ,
        SECURITY_MODE_OPEN,
        SECURITY_MODE_NO_ACCESS,
        4,                                       // max length
        true,                                       // fixed length
        NULL);                                       // no initial value

    uint32_t version = 1;
    mp_buffer_info_t bufinfo;
    bufinfo.buf = &version;
    bufinfo.len = sizeof(version);
    common_hal_bleio_characteristic_set_value(&supervisor_ble_version_characteristic, &bufinfo);

    // Active filename.
    supervisor_ble_transfer_uuid.base.type = &bleio_uuid_type;
    common_hal_bleio_uuid_construct(&supervisor_ble_transfer_uuid, 0x0200, file_transfer_base_uuid);
    common_hal_bleio_characteristic_construct(&supervisor_ble_transfer_characteristic,
        &supervisor_ble_service,
        0,                                       // handle (for remote only)
        &supervisor_ble_transfer_uuid,
        CHAR_PROP_READ | CHAR_PROP_WRITE_NO_RESPONSE | CHAR_PROP_NOTIFY,
        SECURITY_MODE_ENC_NO_MITM,
        SECURITY_MODE_ENC_NO_MITM,
        BLE_GATTS_VAR_ATTR_LEN_MAX,                  // max length
        false,                                       // fixed length
        NULL);                                       // no initial value

    _common_hal_bleio_packet_buffer_construct(
        &_transfer_packet_buffer, &supervisor_ble_transfer_characteristic,
        _buffer, PACKET_BUFFER_SIZE,
        _outgoing1, _outgoing2, BLE_GATTS_VAR_ATTR_LEN_MAX,
        &static_handler_entry);

    // Kick off advertisments
    supervisor_bluetooth_background();
}

#define COMMAND_SIZE 1024

#define ANY_COMMAND 0x00
#define THIS_COMMAND 0x01
#define READ 0x10
#define READ_DATA 0x11
#define READ_PACING 0x12
#define WRITE 0x20
#define WRITE_PACING 0x21
#define WRITE_DATA 0x22
#define DELETE 0x30
#define DELETE_STATUS 0x31
#define MKDIR 0x40
#define MKDIR_STATUS 0x41
#define LISTDIR 0x50
#define LISTDIR_ENTRY 0x51

#define STATUS_OK 0x01
#define STATUS_ERROR 0x02
#define STATUS_ERROR_NO_FILE 0x03
#define STATUS_ERROR_PROTOCOL 0x04

// Used by read and write.
FIL active_file;

struct read_command {
    uint8_t command;
    uint8_t reserved;
    uint16_t path_length;
    uint32_t chunk_offset;
    uint32_t chunk_size;
    uint8_t path[];
};

struct read_data {
    uint8_t command;
    uint8_t status;
    uint16_t reserved;
    uint32_t chunk_offset;
    uint32_t total_length;
    uint32_t data_size;
    uint8_t data[];
};

struct read_pacing {
    uint8_t command;
    uint8_t status;
    uint16_t reserved;
    uint32_t chunk_offset;
    uint32_t chunk_size;
};

uint8_t _process_read(const uint8_t *raw_buf, size_t command_len) {
    struct read_command *command = (struct read_command *)raw_buf;
    size_t header_size = 12;
    size_t response_size = 16;
    uint8_t data_buffer[response_size];
    struct read_data response;
    response.command = READ_DATA;
    response.status = STATUS_OK;
    if (command->path_length > (COMMAND_SIZE - response_size - 1)) { // -1 for the null we'll write
        // TODO: throw away any more packets of path.
        response.status = STATUS_ERROR;
        common_hal_bleio_packet_buffer_write(&_transfer_packet_buffer, (const uint8_t *)&response, response_size, NULL, 0);
        return ANY_COMMAND;
    }
    // We need to receive another packet to have the full path.
    if (command_len < header_size + command->path_length) {
        return THIS_COMMAND;
    }

    char *path = (char *)((uint8_t *)command) + header_size;
    path[command->path_length] = '\0';

    FATFS *fs = &((fs_user_mount_t *)MP_STATE_VM(vfs_mount_table)->obj)->fatfs;
    FRESULT result = f_open(fs, &active_file, path, FA_READ);
    if (result != FR_OK) {
        response.status = STATUS_ERROR;
        common_hal_bleio_packet_buffer_write(&_transfer_packet_buffer, (const uint8_t *)&response, response_size, NULL, 0);
        return ANY_COMMAND;
    }
    uint32_t total_length = f_size(&active_file);
    // Write out the response header.
    uint32_t offset = command->chunk_offset;
    uint32_t chunk_size = command->chunk_size;
    chunk_size = MIN(chunk_size, total_length - offset);
    response.chunk_offset = offset;
    response.total_length = total_length;
    response.data_size = chunk_size;
    common_hal_bleio_packet_buffer_write(&_transfer_packet_buffer, (const uint8_t *)&response, response_size, NULL, 0);
    f_lseek(&active_file, offset);
    // Write out the chunk contents. We can do this in small pieces because PacketBuffer
    // will assemble them into larger packets of its own.
    size_t chunk_end = offset + chunk_size;
    while (offset < chunk_end) {
        size_t quantity_read;
        size_t read_amount = MIN(response_size, chunk_end - offset);
        f_read(&active_file, data_buffer, read_amount, &quantity_read);
        offset += quantity_read;
        // TODO: Do something if the read fails
        common_hal_bleio_packet_buffer_write(&_transfer_packet_buffer, data_buffer, quantity_read, NULL, 0);
    }
    if (offset >= total_length) {
        f_close(&active_file);
        return ANY_COMMAND;
    }
    return READ_PACING;
}

uint8_t _process_read_pacing(const uint8_t *command, size_t command_len) {
    size_t response_size = 4 * sizeof(uint32_t);
    uint32_t response[response_size / sizeof(uint32_t)];
    uint8_t *response_bytes = (uint8_t *)response;
    response_bytes[0] = READ_DATA;
    response_bytes[1] = STATUS_OK;
    uint32_t offset = ((uint32_t *)command)[1];
    uint32_t chunk_size = ((uint32_t *)command)[2];
    uint32_t total_length = f_size(&active_file);
    // Write out the response header.
    chunk_size = MIN(chunk_size, total_length - offset);
    response[1] = offset;
    response[2] = total_length;
    response[3] = chunk_size;
    common_hal_bleio_packet_buffer_write(&_transfer_packet_buffer, (const uint8_t *)&response, response_size, NULL, 0);
    f_lseek(&active_file, offset);
    // Write out the chunk contents. We can do this in small pieces because PacketBuffer
    // will assemble them into larger packets of its own.
    size_t chunk_offset = 0;
    while (chunk_offset < chunk_size) {
        size_t quantity_read;
        size_t read_size = MIN(chunk_size - chunk_offset, response_size);
        FRESULT result = f_read(&active_file, response, read_size, &quantity_read);
        if (quantity_read == 0 || result != FR_OK) {
            // TODO: If we can't read everything, then the file must have been shortened. Maybe we
            // should return 0s to pad it out.
            break;
        }
        common_hal_bleio_packet_buffer_write(&_transfer_packet_buffer, (const uint8_t *)&response, quantity_read, NULL, 0);
        chunk_offset += quantity_read;
    }
    if ((offset + chunk_size) >= total_length) {
        f_close(&active_file);
        return ANY_COMMAND;
    }
    return READ_PACING;
}

// Used by write and write data to know when the write is complete.
size_t total_write_length;

struct write_command {
    uint8_t command;
    uint8_t reserved;
    uint16_t path_length;
    uint32_t offset;
    uint32_t total_length;
    uint8_t path[];
};

struct write_data {
    uint8_t command;
    uint8_t status;
    uint16_t reserved;
    uint32_t offset;
    uint32_t data_size;
    uint8_t data[];
};

struct write_pacing {
    uint8_t command;
    uint8_t status;
    uint16_t reserved;
    uint32_t offset;
    uint32_t free_space;
};

uint8_t _process_write(const uint8_t *raw_buf, size_t command_len) {
    struct write_command *command = (struct write_command *)raw_buf;
    size_t header_size = 12;
    struct write_pacing response;
    response.command = WRITE_PACING;
    response.status = STATUS_OK;
    if (command->path_length > (COMMAND_SIZE - header_size - 1)) { // -1 for the null we'll write
        // TODO: throw away any more packets of path.
        response.status = STATUS_ERROR;
        common_hal_bleio_packet_buffer_write(&_transfer_packet_buffer, (const uint8_t *)&response, sizeof(struct write_pacing), NULL, 0);
        return ANY_COMMAND;
    }
    // We need to receive another packet to have the full path.
    if (command_len < header_size + command->path_length) {
        return THIS_COMMAND;
    }
    total_write_length = command->total_length;

    char *path = (char *)command->path;
    path[command->path_length] = '\0';

    // Check to see if USB has already been mounted. If not, then we "eject" from USB until we're done.
    #if CIRCUITPY_USB_MSC
    if (storage_usb_enabled() && !usb_msc_lock()) {
        response.status = STATUS_ERROR;
        common_hal_bleio_packet_buffer_write(&_transfer_packet_buffer, (const uint8_t *)&response, sizeof(struct write_pacing), NULL, 0);
        return ANY_COMMAND;
    }
    #endif

    FATFS *fs = &((fs_user_mount_t *)MP_STATE_VM(vfs_mount_table)->obj)->fatfs;
    FRESULT result = f_open(fs, &active_file, path, FA_WRITE | FA_OPEN_ALWAYS);
    if (result != FR_OK) {
        response.status = STATUS_ERROR;
        common_hal_bleio_packet_buffer_write(&_transfer_packet_buffer, (const uint8_t *)&response, sizeof(struct write_pacing), NULL, 0);
        #if CIRCUITPY_USB_MSC
        usb_msc_unlock();
        #endif
        return ANY_COMMAND;
    }
    // Write out the pacing response.

    // Align the next chunk to a sector boundary.
    uint32_t offset = command->offset;
    size_t chunk_size = MIN(total_write_length - offset, 512 - (offset % 512));
    response.offset = offset;
    response.free_space = chunk_size;
    common_hal_bleio_packet_buffer_write(&_transfer_packet_buffer, (const uint8_t *)&response, sizeof(struct write_pacing), NULL, 0);
    return WRITE_DATA;
}

uint8_t _process_write_data(const uint8_t *raw_buf, size_t command_len) {
    struct write_data *command = (struct write_data *)raw_buf;
    size_t header_size = 12;
    struct write_pacing response;
    response.command = WRITE_PACING;
    response.status = STATUS_OK;
    if (command->data_size > (COMMAND_SIZE - header_size - 1)) { // -1 for the null we'll write
        // TODO: throw away any more packets of path.
        response.status = STATUS_ERROR;
        common_hal_bleio_packet_buffer_write(&_transfer_packet_buffer, (const uint8_t *)&response, sizeof(struct write_pacing), NULL, 0);
        #if CIRCUITPY_USB_MSC
        usb_msc_unlock();
        #endif
        return ANY_COMMAND;
    }
    // We need to receive another packet to have the full path.
    if (command_len < header_size + command->data_size) {
        return THIS_COMMAND;
    }
    uint32_t offset = command->offset;
    f_lseek(&active_file, offset);
    UINT actual;
    f_write(&active_file, command->data, command->data_size, &actual);
    if (actual < command->data_size) { // -1 for the null we'll write
        // TODO: throw away any more packets of path.
        response.status = STATUS_ERROR;
        common_hal_bleio_packet_buffer_write(&_transfer_packet_buffer, (const uint8_t *)&response, sizeof(struct write_pacing), NULL, 0);
        #if CIRCUITPY_USB_MSC
        usb_msc_unlock();
        #endif
        return ANY_COMMAND;
    }
    offset += command->data_size;
    // Align the next chunk to a sector boundary.
    size_t chunk_size = MIN(total_write_length - offset, 512);
    response.offset = offset;
    response.free_space = chunk_size;
    common_hal_bleio_packet_buffer_write(&_transfer_packet_buffer, (const uint8_t *)&response, sizeof(struct write_pacing), NULL, 0);
    if (total_write_length == offset) {
        f_truncate(&active_file);
        f_close(&active_file);
        #if CIRCUITPY_USB_MSC
        usb_msc_unlock();
        #endif
        // Don't reload until everything is written out of the packet buffer.
        common_hal_bleio_packet_buffer_flush(&_transfer_packet_buffer);
        // Trigger an autoreload
        autoreload_now();
        return ANY_COMMAND;
    }
    return WRITE_DATA;
}

struct delete_command {
    uint8_t command;
    uint8_t reserved;
    uint16_t path_length;
    uint8_t path[];
};

struct delete_response {
    uint8_t command;
    uint8_t status;
};

uint8_t _process_delete(const uint8_t *raw_buf, size_t command_len) {
    const struct delete_command *command = (struct delete_command *)raw_buf;
    size_t header_size = 4;
    struct delete_response response;
    response.command = DELETE_STATUS;
    response.status = STATUS_OK;
    if (command->path_length > (COMMAND_SIZE - header_size - 1)) { // -1 for the null we'll write
        // TODO: throw away any more packets of path.
        response.status = STATUS_ERROR;
        common_hal_bleio_packet_buffer_write(&_transfer_packet_buffer, (const uint8_t *)&response, sizeof(struct delete_response), NULL, 0);
        return ANY_COMMAND;
    }
    // We need to receive another packet to have the full path.
    if (command_len < header_size + command->path_length) {
        return THIS_COMMAND;
    }
    FATFS *fs = &((fs_user_mount_t *)MP_STATE_VM(vfs_mount_table)->obj)->fatfs;
    char *path = (char *)((uint8_t *)command) + header_size;
    path[command->path_length] = '\0';
    FRESULT result = f_unlink(fs, path);
    if (result != FR_OK) {
        response.status = STATUS_ERROR;
    }
    common_hal_bleio_packet_buffer_write(&_transfer_packet_buffer, (const uint8_t *)&response, sizeof(struct delete_response), NULL, 0);
    return ANY_COMMAND;
}

struct mkdir_command {
    uint8_t command;
    uint8_t reserved;
    uint16_t path_length;
    uint8_t path[];
};

struct mkdir_response {
    uint8_t command;
    uint8_t status;
};

uint8_t _process_mkdir(const uint8_t *raw_buf, size_t command_len) {
    const struct mkdir_command *command = (struct mkdir_command *)raw_buf;
    size_t header_size = 4;
    struct mkdir_response response;
    response.command = MKDIR_STATUS;
    response.status = STATUS_OK;
    if (command->path_length > (COMMAND_SIZE - header_size - 1)) { // -1 for the null we'll write
        // TODO: throw away any more packets of path.
        response.status = STATUS_ERROR;
        common_hal_bleio_packet_buffer_write(&_transfer_packet_buffer, (const uint8_t *)&response, sizeof(struct mkdir_response), NULL, 0);
        return ANY_COMMAND;
    }
    // We need to receive another packet to have the full path.
    if (command_len < header_size + command->path_length) {
        return THIS_COMMAND;
    }
    FATFS *fs = &((fs_user_mount_t *)MP_STATE_VM(vfs_mount_table)->obj)->fatfs;
    char *path = (char *)((uint8_t *)command) + header_size;
    // TODO: Check that the final character is a `/`
    path[command->path_length - 1] = '\0';
    FRESULT result = f_mkdir(fs, path);
    if (result != FR_OK) {
        response.status = STATUS_ERROR;
    }
    common_hal_bleio_packet_buffer_write(&_transfer_packet_buffer, (const uint8_t *)&response, sizeof(struct mkdir_response), NULL, 0);
    return ANY_COMMAND;
}

struct listdir_command {
    uint8_t command;
    uint8_t reserved;
    uint16_t path_length;
    uint8_t path[];
};

struct listdir_entry {
    uint8_t command;
    uint8_t status;
    uint16_t path_length;
    uint32_t entry_number;
    uint32_t entry_count;
    uint32_t flags;
    uint32_t file_size;
    uint8_t path[];
};

uint8_t _process_listdir(uint8_t *raw_buf, size_t command_len) {
    const struct listdir_command *command = (struct listdir_command *)raw_buf;
    struct listdir_entry *entry = (struct listdir_entry *)raw_buf;
    size_t header_size = 4;
    size_t response_size = 5 * sizeof(uint32_t);
    // We reuse the command buffer so that we can produce long packets without
    // making the stack large.
    if (command->path_length > (COMMAND_SIZE - header_size - 1)) { // -1 for the null we'll write
        // TODO: throw away any more packets of path.
        entry->command = LISTDIR_ENTRY;
        entry->status = STATUS_ERROR;
        common_hal_bleio_packet_buffer_write(&_transfer_packet_buffer, (const uint8_t *)entry, response_size, NULL, 0);
        return ANY_COMMAND;
    }
    // We need to receive another packet to have the full path.
    if (command_len < header_size + command->path_length) {
        return THIS_COMMAND;
    }

    FATFS *fs = &((fs_user_mount_t *)MP_STATE_VM(vfs_mount_table)->obj)->fatfs;
    char *path = (char *)command->path;
    // -1 because fatfs doesn't want a trailing /
    path[command->path_length - 1] = '\0';
    // mp_printf(&mp_plat_print, "list %s\n", path);
    FF_DIR dir;
    FRESULT res = f_opendir(fs, &dir, path);

    entry->command = LISTDIR_ENTRY;
    entry->status = STATUS_OK;
    entry->path_length = 0;
    entry->entry_number = 0;
    entry->entry_count = 0;
    entry->flags = 0;

    if (res != FR_OK) {
        entry->status = STATUS_ERROR_NO_FILE;
        common_hal_bleio_packet_buffer_write(&_transfer_packet_buffer, (const uint8_t *)entry, response_size, NULL, 0);
        return ANY_COMMAND;
    }
    FILINFO file_info;
    res = f_readdir(&dir, &file_info);
    char *fn = file_info.fname;
    size_t total_entries = 0;
    while (res == FR_OK && fn[0] != 0) {
        res = f_readdir(&dir, &file_info);
        total_entries += 1;
    }
    // Rewind the directory.
    f_readdir(&dir, NULL);
    entry->entry_count = total_entries;
    for (size_t i = 0; i < total_entries; i++) {
        res = f_readdir(&dir, &file_info);
        entry->entry_number = i;
        if ((file_info.fattrib & AM_DIR) != 0) {
            entry->flags = 1; // Directory
            entry->file_size = 0;
        } else {
            entry->flags = 0;
            entry->file_size = file_info.fsize;
        }

        size_t name_length = strlen(file_info.fname);
        entry->path_length = name_length;
        common_hal_bleio_packet_buffer_write(&_transfer_packet_buffer, (const uint8_t *)entry, response_size, NULL, 0);
        size_t fn_offset = 0;
        while (fn_offset < name_length) {
            size_t fn_size = MIN(name_length - fn_offset, 4);
            common_hal_bleio_packet_buffer_write(&_transfer_packet_buffer, ((uint8_t *)file_info.fname) + fn_offset, fn_size, NULL, 0);
            fn_offset += fn_size;
        }
    }
    f_closedir(&dir);
    entry->path_length = 0;
    entry->entry_number = entry->entry_count;
    entry->flags = 0;
    entry->file_size = 0;
    common_hal_bleio_packet_buffer_write(&_transfer_packet_buffer, (const uint8_t *)entry, response_size, NULL, 0);
    return ANY_COMMAND;
}

// Background state that must live across background calls. After the _process
// helpers to force them to not use them.
uint8_t current_command[COMMAND_SIZE] __attribute__ ((aligned(4)));
volatile size_t current_offset;
uint8_t next_command;
bool was_connected;
void supervisor_bluetooth_background(void) {
    bool is_connected = common_hal_bleio_adapter_get_connected(&common_hal_bleio_adapter_obj);
    if (was_connected && !is_connected) {
        f_close(&active_file);
    }
    was_connected = is_connected;
    if (!is_connected) {
        next_command = 0;
        supervisor_bluetooth_start_advertising();
        return;
    }

    mp_int_t size = 1;
    while (size > 0) {
        size = common_hal_bleio_packet_buffer_readinto(&_transfer_packet_buffer, current_command + current_offset, COMMAND_SIZE - current_offset);

        if (size == 0) {
            break;
        }
        // TODO: If size < 0 return an error.
        current_offset += size;
        // mp_printf(&mp_plat_print, "buffer[:%d]:", current_offset);
        // for (size_t i = 0; i < current_offset; i++) {
        //     mp_printf(&mp_plat_print, " (%x %c)", current_command[i], current_command[i]);
        // }
        // mp_printf(&mp_plat_print, "\n");
        uint8_t current_state = current_command[0];
        // mp_printf(&mp_plat_print, "current command 0x%02x\n", current_state);
        // Check for protocol error.
        if (next_command != ANY_COMMAND && next_command != THIS_COMMAND && ((current_state & 0xf) != 0) && current_state != next_command) {
            uint8_t response[2];
            response[0] = next_command;
            response[1] = STATUS_ERROR_PROTOCOL;
            common_hal_bleio_packet_buffer_write(&_transfer_packet_buffer, response, 2, NULL, 0);
            break;
        }
        switch (current_state) {
            case READ:
                next_command = _process_read(current_command, current_offset);
                break;
            case READ_PACING:
                next_command = _process_read_pacing(current_command, current_offset);
                break;
            case WRITE:
                next_command = _process_write(current_command, current_offset);
                break;
            case WRITE_DATA:
                next_command = _process_write_data(current_command, current_offset);
                break;
            case DELETE:
                next_command = _process_delete(current_command, current_offset);
                break;
            case MKDIR:
                next_command = _process_mkdir(current_command, current_offset);
                break;
            case LISTDIR:
                next_command = _process_listdir(current_command, current_offset);
                break;
        }
        // Preserve the offset if we are waiting for more from this command.
        if (next_command != THIS_COMMAND) {
            current_offset = 0;
        }
    }
}

#endif // #else