IOS WORKS

fabiankuffer · fabiankuffer · commit 662d7c3fb898 · 2022-11-25T22:11:19.000+01:00
diff --git a/.vscode/settings.json b/.vscode/settings.json
@@ -7,6 +7,8 @@
         "random": "c",
         "array": "c",
         "string": "c",
-        "string_view": "c"
+        "string_view": "c",
+        "ble_svc_gap.h": "c",
+        "console.h": "c"
     }
 }
diff --git a/components/nimble_peripheral_utils/CMakeLists.txt b/components/nimble_peripheral_utils/CMakeLists.txt
@@ -0,0 +1,3 @@
+idf_component_register(SRCS "misc.c" "scli.c"
+                       INCLUDE_DIRS "."
+                       PRIV_REQUIRES bt console driver)
diff --git a/components/nimble_peripheral_utils/esp_peripheral.h b/components/nimble_peripheral_utils/esp_peripheral.h
@@ -0,0 +1,29 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2022 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Unlicense OR CC0-1.0
+ */
+
+#ifndef H_ESP_PERIPHERAL_
+#define H_ESP_PERIPHERAL_
+
+#include <stdbool.h>
+#include "nimble/ble.h"
+#include "modlog/modlog.h"
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Console */
+int scli_init(void);
+int scli_receive_key(int *key);
+
+/** Misc. */
+void print_bytes(const uint8_t *bytes, int len);
+void print_addr(const void *addr);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/components/nimble_peripheral_utils/misc.c b/components/nimble_peripheral_utils/misc.c
@@ -0,0 +1,30 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2022 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Unlicense OR CC0-1.0
+ */
+
+#include "esp_peripheral.h"
+
+/**
+ * Utility function to log an array of bytes.
+ */
+void
+print_bytes(const uint8_t *bytes, int len)
+{
+    int i;
+
+    for (i = 0; i < len; i++) {
+        MODLOG_DFLT(INFO, "%s0x%02x", i != 0 ? ":" : "", bytes[i]);
+    }
+}
+
+void
+print_addr(const void *addr)
+{
+    const uint8_t *u8p;
+
+    u8p = addr;
+    MODLOG_DFLT(INFO, "%02x:%02x:%02x:%02x:%02x:%02x",
+                u8p[5], u8p[4], u8p[3], u8p[2], u8p[1], u8p[0]);
+}
diff --git a/components/nimble_peripheral_utils/scli.c b/components/nimble_peripheral_utils/scli.c
@@ -0,0 +1,146 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2022 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Unlicense OR CC0-1.0
+ */
+
+#include <stdio.h>
+#include <ctype.h>
+#include "esp_log.h"
+#include <string.h>
+#include <esp_log.h>
+#include <esp_console.h>
+#include <freertos/FreeRTOS.h>
+#include <freertos/task.h>
+#include <freertos/queue.h>
+#include <driver/uart.h>
+#include "esp_peripheral.h"
+
+#define BLE_RX_TIMEOUT (30000 / portTICK_PERIOD_MS)
+
+static TaskHandle_t cli_task;
+static QueueHandle_t cli_handle;
+static int stop;
+
+static int enter_passkey_handler(int argc, char *argv[])
+{
+    int key;
+    char pkey[8];
+    int num;
+
+    if (argc != 2) {
+        return -1;
+    }
+
+    sscanf(argv[1], "%s", pkey);
+    ESP_LOGI("You entered", "%s %s", argv[0], argv[1]);
+    num = pkey[0];
+
+    if (isalpha(num)) {
+        if ((strcasecmp(pkey, "Y") == 0) || (strcasecmp(pkey, "Yes") == 0)) {
+            key = 1;
+            xQueueSend(cli_handle, &key, 0);
+        } else {
+            key = 0;
+            xQueueSend(cli_handle, &key, 0);
+        }
+    } else {
+        sscanf(pkey, "%d", &key);
+        xQueueSend(cli_handle, &key, 0);
+    }
+
+    return 0;
+}
+
+int scli_receive_key(int *console_key)
+{
+    return xQueueReceive(cli_handle, console_key, BLE_RX_TIMEOUT);
+}
+
+static esp_console_cmd_t cmds[] = {
+    {
+        .command = "key",
+        .help = "",
+        .func = enter_passkey_handler,
+    },
+};
+
+static int ble_register_cli(void)
+{
+    int cmds_num = sizeof(cmds) / sizeof(esp_console_cmd_t);
+    int i;
+    for (i = 0; i < cmds_num; i++) {
+        esp_console_cmd_register(&cmds[i]);
+    }
+    return 0;
+}
+
+static void scli_task(void *arg)
+{
+    int uart_num = (int) arg;
+    uint8_t linebuf[256];
+    int i, cmd_ret;
+    esp_err_t ret;
+    QueueHandle_t uart_queue;
+    uart_event_t event;
+
+    uart_driver_install(uart_num, 256, 0, 8, &uart_queue, 0);
+    /* Initialize the console */
+    esp_console_config_t console_config = {
+        .max_cmdline_args = 8,
+        .max_cmdline_length = 256,
+    };
+
+    esp_console_init(&console_config);
+
+    while (!stop) {
+        i = 0;
+        memset(linebuf, 0, sizeof(linebuf));
+        do {
+            ret = xQueueReceive(uart_queue, (void * )&event, (TickType_t)portMAX_DELAY);
+            if (ret != pdPASS) {
+                if (stop == 1) {
+                    break;
+                } else {
+                    continue;
+                }
+            }
+            if (event.type == UART_DATA) {
+                while (uart_read_bytes(uart_num, (uint8_t *) &linebuf[i], 1, 0)) {
+                    if (linebuf[i] == '\r') {
+                        uart_write_bytes(uart_num, "\r\n", 2);
+                    } else {
+                        uart_write_bytes(uart_num, (char *) &linebuf[i], 1);
+                    }
+                    i++;
+                }
+            }
+        } while ((i < 255) && linebuf[i - 1] != '\r');
+        if (stop) {
+            break;
+        }
+        /* Remove the truncating \r\n */
+        linebuf[strlen((char *)linebuf) - 1] = '\0';
+        ret = esp_console_run((char *) linebuf, &cmd_ret);
+        if (ret < 0) {
+            break;
+        }
+    }
+    vTaskDelete(NULL);
+}
+
+int scli_init(void)
+{
+    /* Register CLI "key <value>" to accept input from user during pairing */
+    ble_register_cli();
+
+    xTaskCreate(scli_task, "scli_cli", 4096, (void *) 0, 3, &cli_task);
+    if (cli_task == NULL) {
+        return ESP_FAIL;
+    }
+    cli_handle = xQueueCreate( 1, sizeof(int) );
+    if (cli_handle == NULL) {
+        return ESP_FAIL;
+    }
+    return ESP_OK;
+}
diff --git a/infos b/infos
@@ -0,0 +1,3 @@
+Linux reicht es wenn irgendwie viel bytes im report sind, welches zum gerät geschickt wird.
+Windows und Android muss die report größe mit der größe des report deskriptors übereinstimmen.
+IOS benötigt eine sichere Verbindung und dann noch die erlaubnis auf das report zuzugreifen wenn es eine sichere verbindung ist. Zusätzlich darf während dem aufbau einer sicheren verbindung keine connection updates durchgeführt werden.
diff --git a/main/gatt_svr.c b/main/gatt_svr.c
@@ -142,8 +142,7 @@ static const struct ble_gatt_svc_def gatt_svr_svcs[] = {
                 .descriptors = (struct ble_gatt_dsc_def[]){
                     //client configuration descriptor soll nicht manuell hinzugefügt werden, da dieser mittels dem flag notify automatisch hinzugefügt wird
                     {   
-                        //TODO: | BLE_ATT_F_WRITE_ENC vielleicht bei ios benötigt
-                        .att_flags = BLE_ATT_F_READ,
+                        .att_flags = BLE_ATT_F_READ | BLE_ATT_F_READ_ENC,
                         .access_cb = report_descriptor_callback,
                         .uuid = BLE_UUID16_DECLARE(GATT_REPORT_REFERENCE_CHAR_UUID) //damit wird angegeben welche report id und report type abgedeckt werden
                     }, {
diff --git a/main/main.c b/main/main.c
@@ -2,11 +2,13 @@
 //https://macchina.io/blog/internet-of-things/communication-with-low-energy-bluetooth-devices-on-linux/
 
 
-//TODO: alle geräte funktionieren außer ios; hier reinschauen wie notify gemacht wird; muss wahrscheinlich secure verbindung sein
-//https://github.com/Xi-MingYu/Central/tree/394ccfb02f2c58d8ea7eb0e72b0abe927602f5ea/lib/NimBLE/src
-//vielleicht eine secure verbindung aufbauen https://github.com/h2zero/NimBLE-Arduino/issues/222
-//https://github.com/wakwak-koba/ESP32-NimBLE-Keyboard/blob/ec4ce707f00d260f30286191fe63dc23d65a5934/BleKeyboard.cpp#L141
-// Diese verschlüsselung mal hinzufügen
+//TODO: Update connection parameter wieder hinzufügen (bleprh anschauen)
+//TODO: Schauen warum unter ios sich bei erneuter verbindung das gerät nicht verbinden kann
+//TODO: Bei einem erneuten verbindungsaufbau wird das gestoppte updaten der daten nicht wieder gestartet
+//TODO: vielleicht mal schauen ob a Resolvable Private Address schwierig sind hinzuzufügen statt publich adressen (bleprh anschauen)
+//Update connection parameters are not allowed during iPhone HID encryption, slave turns off the ability to automatically update connection parameters during encryption.
+
+//https://github.com/espressif/esp-idf/issues/3532
 
 #include "esp_log.h"
 #include "nvs_flash.h"
@@ -21,6 +23,7 @@
 #include "services/gap/ble_svc_gap.h"
 #include "blehr_sens.h"
 #include "host/ble_uuid.h"
+#include "esp_peripheral.h"
 
 static const char *tag = "NimBLE_BLE_HeartRate";
 static const ble_uuid16_t hid_service_uuid = BLE_UUID16_INIT(0x1812);
@@ -183,6 +186,9 @@ blehr_tx_hrate(xTimerHandle ev)
 static int
 blehr_gap_event(struct ble_gap_event *event, void *arg)
 {
+    struct ble_gap_conn_desc desc;
+    int rc;
+
     switch (event->type) {
     case BLE_GAP_EVENT_CONNECT:
         /* A new connection was established or a connection attempt failed */
@@ -205,13 +211,15 @@ blehr_gap_event(struct ble_gap_event *event, void *arg)
             .supervision_timeout = 1860/10 //10ms units, laut apple größer als itvl_max * (latency + 1) * 3
         };
 
-        ESP_ERROR_CHECK(ble_gap_update_params(event->connect.conn_handle, &connectionParameters));
+        //ESP_ERROR_CHECK(ble_gap_update_params(event->connect.conn_handle, &connectionParameters));
 
         conn_handle = event->connect.conn_handle;
+        ble_gap_security_initiate(conn_handle);
         break;
 
     case BLE_GAP_EVENT_DISCONNECT:
         ESP_LOGI("ASDF", "disconnect; reason=%d\n", event->disconnect.reason);
+        //531 = Remote User Terminated Connection
 
         /* Connection terminated; resume advertising */
         blehr_advertise();
@@ -239,7 +247,73 @@ blehr_gap_event(struct ble_gap_event *event, void *arg)
                     event->mtu.conn_handle,
                     event->mtu.value);
         break;
+    case BLE_GAP_EVENT_ENC_CHANGE:
+        ESP_LOGI("ASDF", "encryption change event; status=%d ",
+                    event->enc_change.status);
+        break;
+    case BLE_GAP_EVENT_REPEAT_PAIRING:
+        /* We already have a bond with the peer, but it is attempting to
+         * establish a new secure link.  This app sacrifices security for
+         * convenience: just throw away the old bond and accept the new link.
+         */
+        ESP_LOGI("ASDF", "establisch new secure link");
+
+        /* Delete the old bond. */
+        rc = ble_gap_conn_find(event->repeat_pairing.conn_handle, &desc);
+        assert(rc == 0);
+        ble_store_util_delete_peer(&desc.peer_id_addr);
+
+        /* Return BLE_GAP_REPEAT_PAIRING_RETRY to indicate that the host should
+         * continue with the pairing operation.
+         */
+        return BLE_GAP_REPEAT_PAIRING_RETRY;
+        break;
 
+    case BLE_GAP_EVENT_PASSKEY_ACTION:
+        ESP_LOGI("ASDF", "PASSKEY_ACTION_EVENT started \n");
+        
+        struct ble_sm_io pkey = {0};
+        int key = 0;
+
+        if (event->passkey.params.action == BLE_SM_IOACT_DISP) {
+            pkey.action = event->passkey.params.action;
+            pkey.passkey = 123456; // This is the passkey to be entered on peer
+            ESP_LOGI(tag, "Enter passkey %d on the peer side", pkey.passkey);
+            rc = ble_sm_inject_io(event->passkey.conn_handle, &pkey);
+            ESP_LOGI(tag, "ble_sm_inject_io result: %d\n", rc);
+        } else if (event->passkey.params.action == BLE_SM_IOACT_NUMCMP) {
+            ESP_LOGI(tag, "Passkey on device's display: %d", event->passkey.params.numcmp);
+            ESP_LOGI(tag, "Accept or reject the passkey through console in this format -> key Y or key N");
+            pkey.action = event->passkey.params.action;
+            if (scli_receive_key(&key)) {
+                pkey.numcmp_accept = key;
+            } else {
+                pkey.numcmp_accept = 0;
+                ESP_LOGE(tag, "Timeout! Rejecting the key");
+            }
+            rc = ble_sm_inject_io(event->passkey.conn_handle, &pkey);
+            ESP_LOGI(tag, "ble_sm_inject_io result: %d\n", rc);
+        } else if (event->passkey.params.action == BLE_SM_IOACT_OOB) {
+            static uint8_t tem_oob[16] = {0};
+            pkey.action = event->passkey.params.action;
+            for (int i = 0; i < 16; i++) {
+                pkey.oob[i] = tem_oob[i];
+            }
+            rc = ble_sm_inject_io(event->passkey.conn_handle, &pkey);
+            ESP_LOGI(tag, "ble_sm_inject_io result: %d\n", rc);
+        } else if (event->passkey.params.action == BLE_SM_IOACT_INPUT) {
+            ESP_LOGI(tag, "Enter the passkey through console in this format-> key 123456");
+            pkey.action = event->passkey.params.action;
+            if (scli_receive_key(&key)) {
+                pkey.passkey = key;
+            } else {
+                pkey.passkey = 0;
+                ESP_LOGE(tag, "Timeout! Passing 0 as the key");
+            }
+            rc = ble_sm_inject_io(event->passkey.conn_handle, &pkey);
+            ESP_LOGI(tag, "ble_sm_inject_io result: %d\n", rc);
+        }
+        return 0;
     }
 
     return 0;
@@ -297,6 +371,10 @@ void app_main(void)
     /* Initialize the NimBLE host configuration */
     ble_hs_cfg.sync_cb = blehr_on_sync;
     ble_hs_cfg.reset_cb = blehr_on_reset;
+    ble_hs_cfg.gatts_register_cb = gatt_svr_register_cb;
+    ble_hs_cfg.sm_io_cap = BLE_SM_IO_CAP_NO_IO;
+    ble_hs_cfg.sm_sc = 1;
+    ble_hs_cfg.sm_mitm = 1;
 
     /* name, period/time,  auto reload, timer ID, callback */
     blehr_tx_timer = xTimerCreate("blehr_tx_timer", pdMS_TO_TICKS(2000), pdTRUE, (void *)0, blehr_tx_hrate);

Original file line number	Diff line number	Diff line change
`@@ -7,6 +7,8 @@`
`7`	`7`	`"random": "c",`
`8`	`8`	`"array": "c",`
`9`	`9`	`"string": "c",`
`10`		`- "string_view": "c"`
	`10`	`+ "string_view": "c",`
	`11`	`+ "ble_svc_gap.h": "c",`
	`12`	`+ "console.h": "c"`
`11`	`13`	`}`
`12`	`14`	`}`
Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,3 @@`
	`1`	`+idf_component_register(SRCS "misc.c" "scli.c"`
	`2`	`+ INCLUDE_DIRS "."`
	`3`	`+ PRIV_REQUIRES bt console driver)`
Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,3 @@`
	`1`	`+Linux reicht es wenn irgendwie viel bytes im report sind, welches zum gerät geschickt wird.`
	`2`	`+Windows und Android muss die report größe mit der größe des report deskriptors übereinstimmen.`
	`3`	`+IOS benötigt eine sichere Verbindung und dann noch die erlaubnis auf das report zuzugreifen wenn es eine sichere verbindung ist. Zusätzlich darf während dem aufbau einer sicheren verbindung keine connection updates durchgeführt werden.`