fiatlux/firmware/web.cpp

//
// Created by jedi on 25.06.21.
//

#include "web.h"
#include "system.h"
#include "lux.h"
#include "wifi.h"
#include "log.h"

#include <cstring>
#include <FreeRTOS.h>
#include <task.h>

extern "C" {
#include <sysparam.h>
#include <lwipopts.h>
}

#include <espressif/esp_common.h>
#include <lwip/tcp.h>

extern "C" {
#include <httpd/httpd.h>
}

#define vTaskDelayMs(ms) vTaskDelay((ms) / portTICK_PERIOD_MS)

struct {
    bool global;
    bool connection;
    bool wifi;
} has_changed;

void websocket_task(void *pvParameter) {
    auto *pcb = (struct tcp_pcb *) pvParameter;

    size_t connstarttime = xTaskGetTickCount();
    has_changed = {true, true, true};
    syslog_attach();
    unsigned local_log_tail = syslog_current_tail();

    for (;;) {
        if(pcb == nullptr || pcb->state != ESTABLISHED) {
            syslog("Connection closed, deleting task\n");
            break;
        }

        //Syslog
        if(syslog_data_after(local_log_tail) != 0) {
            char response[128];
            response[0] = 'L';
            size_t len = syslog_copy_out(&response[4], 124, local_log_tail);
            response[1] = len;
            ((uint16_t &) response[2]) = local_log_tail & 0xFFFF;
            if(len < sizeof(response)) {
                LOCK_TCPIP_CORE();
                websocket_write(pcb, (unsigned char *) response, len + 4, WS_BIN_MODE);
                local_log_tail += len;
                UNLOCK_TCPIP_CORE();
            } else
                syslog("buffer too small -1\n");
            vTaskDelayMs(1000);
        }

        //Global Info
        if(has_changed.global) {
            timeval tv{};
            gettimeofday(&tv, nullptr);
            size_t uptime = xTaskGetTickCount() * portTICK_PERIOD_MS / 1000;
            int heap = (int) xPortGetFreeHeapSize();
            uint32_t chip_id = sdk_system_get_chip_id();
            uint32_t flash_id = sdk_spi_flash_get_id();
            uint32_t flash_size = sdk_flashchip.chip_size >> 10;
            char *hostname = nullptr;

            sysparam_get_string("hostname", &hostname);
            /* Generate response in JSON format */
            char response[192];
            size_t len = snprintf(response, sizeof(response),
                                  "{\"walltime\" : \"%d\","
                                  "\"uptime\" : \"%d\","
                                  " \"heap\" : \"%d\","
                                  " \"chipid\" : \"%08x\","
                                  " \"flashid\" : \"0x%08x\","
                                  " \"flashsize\" : \"%u\","
                                  " \"hostname\" : \"%s\""
                                  "}", (int) tv.tv_sec, uptime, heap, chip_id, flash_id, flash_size, hostname);
            free(hostname);
            if(len < sizeof(response)) {
                LOCK_TCPIP_CORE();
                websocket_write(pcb, (unsigned char *) response, len, WS_TEXT_MODE);
                has_changed.global = false;
                UNLOCK_TCPIP_CORE();
            } else
                syslog("buffer too small 0\n");
            vTaskDelayMs(1000);
        }

        //Connection Info
        if(has_changed.connection) {
            timeval tv{};
            gettimeofday(&tv, nullptr);
            size_t connuptime = (xTaskGetTickCount() - connstarttime) * portTICK_PERIOD_MS / 1000;

            printf("conn %d: " IPSTR " <-> " IPSTR " \n", pcb->netif_idx, IP2STR(&pcb->local_ip),
                   IP2STR(&pcb->remote_ip));
            char response[192];
            size_t len = snprintf(response, sizeof(response),
                                  "{\"connage\" : \"%d\","
                                  "\"clientip\" : \"" IPSTR "\""
                                  "}", connuptime, IP2STR(&pcb->remote_ip));
            if(len < sizeof(response)) {
                LOCK_TCPIP_CORE();
                websocket_write(pcb, (unsigned char *) response, len, WS_TEXT_MODE);
                has_changed.connection = false;
                UNLOCK_TCPIP_CORE();
            } else
                syslog("buffer too small 1\n");
            vTaskDelayMs(1000);
        }

        if(has_changed.wifi) {
            has_changed.wifi = false;
            uint8_t opmode = sdk_wifi_get_opmode();
            const char *opmode_str = "??";
            switch (opmode) {
                case NULL_MODE:
                    opmode_str = "Null";
                    break;
                case STATION_MODE:
                    opmode_str = "Station";
                    break;
                case SOFTAP_MODE:
                    opmode_str = "SoftAP";
                    break;
                case STATIONAP_MODE:
                    opmode_str = "StationAP";
                    break;
                default:
                    break;
            }


            /*struct sockaddr_storage addr;
            socklen_t addr_len = sizeof(addr);
            if (getpeername(s, (struct sockaddr *)&addr, &addr_len) == 0) {
                printf("peer\n");
            }*/


            if(opmode == SOFTAP_MODE || opmode == STATIONAP_MODE) {
                uint8_t hwaddr[6];
                sdk_wifi_get_macaddr(SOFTAP_IF, hwaddr);
                ip_info info{};
                sdk_wifi_get_ip_info(SOFTAP_IF, &info);

                char *apssid = nullptr;
                sysparam_get_string("wifi_ap_ssid", &apssid);

                /* Generate response in JSON format */
                char response[128];
                size_t len = snprintf(response, sizeof(response),
                                      "{\"opmode\" : \"%s\","
                                      " \"apssid\" : \"%s\","
                                      " \"apip\" : \"" IPSTR "\","
                                      " \"apmac\" : \"" MACSTR "\""
                                      "}", opmode_str, apssid, IP2STR(&info.ip), MAC2STR(hwaddr));
                free(apssid);
                if(len < sizeof(response)) {
                    LOCK_TCPIP_CORE();
                    websocket_write(pcb, (unsigned char *) response, len, WS_TEXT_MODE);
                    UNLOCK_TCPIP_CORE();
                } else
                    syslog("buffer too small 2\n");
            }

            vTaskDelayMs(1000);

            if(opmode == STATION_MODE || opmode == STATIONAP_MODE) {
                uint8_t hwaddr[6];
                sdk_wifi_get_macaddr(STATION_IF, hwaddr);
                ip_info info{};
                sdk_wifi_get_ip_info(STATION_IF, &info);
                char *stassid = nullptr;
                sysparam_get_string("wifi_sta_ssid", &stassid);

                /* Generate response in JSON format */
                char response[128];
                size_t len = snprintf(response, sizeof(response),
                                      "{\"opmode\" : \"%s\","
                                      " \"stassid\" : \"%s\","
                                      " \"staip\" : \"" IPSTR "\","
                                      " \"stamac\" : \"" MACSTR "\""
                                      "}", opmode_str, stassid, IP2STR(&info.ip), MAC2STR(hwaddr));
                free(stassid);
                if(len < sizeof(response)) {
                    LOCK_TCPIP_CORE();
                    websocket_write(pcb, (unsigned char *) response, len, WS_TEXT_MODE);
                    UNLOCK_TCPIP_CORE();
                } else
                    syslog("buffer too small 3\n");
            }

        }

        /*vTaskDelayMs(250);
        {
            uint8_t response[3];
            uint16_t val;
            val = sdk_system_adc_read();
            response[2] = (uint8_t) val;
            response[1] = val >> 8;
            response[0] = 'V';
            LOCK_TCPIP_CORE();
            websocket_write(pcb, response, 3, WS_BIN_MODE);
            UNLOCK_TCPIP_CORE();
        }*/
        vTaskDelayMs(500);
        //printf("9: %d\n",gpio_read(9));
        //printf("10: %d\n",gpio_read(10));
    }

    syslog_detach();

    vTaskDelete(nullptr);
}

struct fw_frame {
    char t;
    uint8_t reserved[3];
    uint16_t seq;
    uint16_t len;
    uint32_t hash;
    uint8_t data[];
} __attribute__((packed));

struct fw_check {
    char t;
    uint8_t reserved[3];
    uint32_t len;
    uint32_t hash;
} __attribute__((packed));

/**
 * This function is called when websocket frame is received.
 *
 * Note: this function is executed on TCP thread and should return as soon
 * as possible.
 */
void websocket_cb(struct tcp_pcb *pcb, char *data, u16_t data_len,
                  uint8_t /*mode*/) { //mode should be WS_BIN_MODE or WS_TEXT_MODE

    uint8_t response[4];
    auto &cmd = (char &) response[0];
    auto &ret = response[1];
    auto &val = (uint16_t &) response[2];
    cmd = '0';
    ret = ERROR;
    val = 0;

    int8_t en = 0;
    bool togl = false;

    switch (data[0]) {
        case 'V': // ADC
            /* This should be done on a separate thread in 'real' applications */
            cmd = 'V';
            ret = OK;
            val = sdk_system_adc_read();
            break;
        case 'R': // Restart
            cmd = 'R';
            ret = OK;
            break;
        case 'X': // Clear Config
            cmd = 'X';
            ret = OK;
            break;
        case 'D': // Disable LED
            syslog("G\n");
            signal_led(false);
            cmd = 'G';
            ret = OK;
            val = 1;
            break;
        case 'E': // Enable LED
            syslog("E\n");
            signal_led(true);
            cmd = 'G';
            ret = OK;
            val = 0;
            break;
        case 'd': // Disable LED
            signal_led(false);
            cmd = 'G';
            ret = OK;
            val = 1;
            break;
        case 'e': // Enable LED
            signal_led(true);
            cmd = 'G';
            ret = OK;
            val = 0;
            break;
        case 'F':
            togl = !togl;
            signal_led(togl);
            {
                auto *f = (fw_frame *) data;
                if(f->seq == 0) {
                    system_otaflash_init();
                }
                uint16_t ack = 0;
                ret = system_otaflash_chunk(f->data, ntohs(f->len), ntohs(f->seq), ntohl(f->hash), &ack);
                val = htons(ack);
            }
            cmd = 'F';
            break;
        case 'C':
            signal_led(false);
            {
                auto *f = (fw_check *) data;
                ret = system_otaflash_verify_and_switch(ntohl(f->len), ntohl(f->hash));
            }
            cmd = 'C';
            break;
        case 'T': {
            auto A = *(int32_t *) &data[4];
            auto B = *(int32_t *) &data[8];
            auto C = *(int32_t *) &data[12];
            auto D = *(int32_t *) &data[16];
            /*sysparam_set_int32("noctis_A", A);
            sysparam_set_int32("noctis_B", B);
            sysparam_set_int32("noctis_C", C);
            sysparam_set_int32("noctis_D", D);*/
        }
            cmd = 'T';
            break;
        case 'N': {
            if(data[1] == 'W')
                printf("WS2812\n");
            else if(data[1] == 'A')
                printf("APA103C\n");
            else if(data[1] == 'Z')
                printf("APA103C-Z\n");
            auto num_leds = *(uint16_t *) &data[2];
            /*sysparam_set_int32("noctis_leds", num_leds);*/
        }
            cmd = 'N';
            break;
        case 'S': {
            if(data[1] == 'E')
                en = 1;
            char *ssid = &data[2];
            size_t ssid_len = strlen(ssid);
            char *password = &data[3 + ssid_len];
            size_t password_len = strlen(password);
            (void) password_len;

            sysparam_set_int8("wifi_sta_enable", en);
            sysparam_set_string("wifi_sta_ssid", ssid);
            sysparam_set_string("wifi_sta_password", password);
        }
            cmd = 'S';
            break;
        case 'A': {
            if(data[1] == 'E')
                en = 1;
            char *ssid = &data[2];
            size_t ssid_len = strlen(ssid);
            char *password = &data[3 + ssid_len];
            size_t password_len = strlen(password);
            (void) password_len;

            sysparam_set_int8("wifi_ap_enable", en);
            sysparam_set_string("wifi_ap_ssid", ssid);
            sysparam_set_string("wifi_ap_password", password);

            /*uint8_t ap_disable_if_sta = 0;
            uint8_t ssid_hidden = 0;
            uint8_t dns_enable = 0;
            uint8_t mdns_enable = 0;*/

            //sysparam_set_int8("wifi_ap_disable_if_sta", ap_disable_if_sta);
            //sysparam_set_int8("wifi_ap_ssid_hidden", ssid_hidden);
            //sysparam_set_int8("wifi_ap_dns", dns_enable);
            //sysparam_set_int8("wifi_ap_mdns", mdns_enable);
        }
            cmd = 'A';
            break;
        default:
            printf("[websocket_callback]:\n%.*s\n", (int) data_len, (char *) data);
            printf("Unknown command %c\n", data[0]);
            ret = ERROR;
            break;
    }

    LOCK_TCPIP_CORE();
    websocket_write(pcb, response, 4, WS_BIN_MODE);
    UNLOCK_TCPIP_CORE();

    if(ret == OK) {
        if(cmd == 'R' || cmd == 'C') { // Restart
            printf("rebooting now");
            vTaskDelay(1000 / portTICK_PERIOD_MS);
            vPortEnterCritical();
            sdk_system_restart();
        } else if(cmd == 'X') { // Clear Config
            vTaskDelay(1000 / portTICK_PERIOD_MS);
            system_clear_config();
        }
    }
}

/**
 * This function is called when new websocket is open and
 * creates a new websocket_task if requested URI equals '/stream'.
 */
void websocket_open_cb(struct tcp_pcb *pcb, const char *uri) {
    printf("WS URI: %s\n", uri);
    if(!strcmp(uri, "/stream")) {
        xTaskCreate(&websocket_task, "websocket_task", 512, (void *) pcb, 3, nullptr);
    }
}

/*const char *gpio_cgi_handler(int iIndex, int iNumParams, char *pcParam[], char *pcValue[]) {
    for (int i = 0; i < iNumParams; i++) {
        if(strcmp(pcParam[i], "on") == 0) {
            uint8_t gpio_num = atoi(pcValue[i]);
            gpio_enable(gpio_num, GPIO_OUTPUT);
            gpio_write(gpio_num, true);
        } else if(strcmp(pcParam[i], "off") == 0) {
            uint8_t gpio_num = atoi(pcValue[i]);
            gpio_enable(gpio_num, GPIO_OUTPUT);
            gpio_write(gpio_num, false);
        } else if(strcmp(pcParam[i], "toggle") == 0) {
            uint8_t gpio_num = atoi(pcValue[i]);
            gpio_enable(gpio_num, GPIO_OUTPUT);
            gpio_toggle(gpio_num);
        }
    }
    return "/index.html";
}*/

extern "C" void httpd_task(void *pvParameters) {
    (void) pvParameters;

    while (!uxSemaphoreGetCount(wifi_available_semaphore)) {
        vTaskDelay(500 / portTICK_PERIOD_MS);
    }

    websocket_register_callbacks((tWsOpenHandler) websocket_open_cb, (tWsHandler) websocket_cb);
    httpd_init();

    vTaskDelete(nullptr);
}