#include <assert.h>
#include "example.h"
#include "pico/stdlib.h"
#include "pico/cyw43_arch.h"
#include "hardware/structs/rosc.h"
#include "lwip/ip4_addr.h"
#include "lwip/apps/mdns.h"
#include "lwip/apps/mdns_priv.h"
#include "lwip/init.h"
#include "lwip/apps/httpd.h"
#include "lwip/altcp_tls.h"
#include "psa/crypto.h"
#include "mbedtls/platform.h"
#include "arch/sys_arch.h"
#include "pico/cyw43_arch_stk.h"
#include "threading_alt.h"
#define STR_HELPER(x) #x
#define STR(x) STR_HELPER(x)
{
"status",
"welcome",
"uptime",
"ledstate",
"ledinv",
"table",
};
#if LWIP_HTTPD_SUPPORT_POST
#define LED_STATE_BUFSIZE 4
static const uint32_t FLAG_LED_UPDATE = (1U << 0);
static const uint32_t FLAG_CONNECT_WIFI = (1U << 1);
static const uint32_t FLAG_INIT_NET = (1U << 2);
static const uint32_t FLAG_SHUTDOWN_NET = (1U << 3);
static void *s_CurrentConnection;
static absolute_time_t s_ConnectedTime;
static bool s_LedOn = false;
static altcp_tls_config *s_TlsConfig = NULL;
static void RequestLedUpdate() { s_ControlFlags.
Set(FLAG_LED_UPDATE); }
static void RequestConnectWiFi() { s_ControlFlags.
Set(FLAG_CONNECT_WIFI); }
static void RequestInitNetwork() { s_ControlFlags.
Set(FLAG_INIT_NET); }
static void RequestShutdownNetwork() { s_ControlFlags.
Set(FLAG_SHUTDOWN_NET); }
#if LWIP_MDNS_RESPONDER
static void srv_txt(struct mdns_service *service, void *txt_userdata)
{
err_t res;
LWIP_UNUSED_ARG(txt_userdata);
res = mdns_resp_add_service_txtitem(service, "path=/", 6);
LWIP_ERROR("mdns add service txt failed\n", (res == ERR_OK), return);
}
#endif
static size_t get_mac_ascii(int idx, size_t chr_off, size_t chr_len, char *dest_in)
{
static const char hexchr[] = "0123456789ABCDEF";
uint8_t mac[6];
char *dest = dest_in;
assert(chr_off + chr_len <= (2 * sizeof(mac)));
cyw43_hal_get_mac(idx, mac);
for (; chr_len && (chr_off >> 1) < sizeof(mac); ++chr_off, --chr_len)
{
*dest++ = hexchr[mac[chr_off >> 1] >> (4 * (1 - (chr_off & 1))) & 0xf];
}
return dest - dest_in;
}
static const char *cgi_handler_test(int iIndex, int iNumParams, char *pcParam[], char *pcValue[])
{
if (iNumParams > 0)
{
if (strcmp(pcParam[0], "test") == 0)
{
return "/test.shtml";
}
}
return "/index.shtml";
}
static const char *cgi_handler_restart(int iIndex, int iNumParams, char *pcParam[], char *pcValue[])
{
return "/index.shtml";
}
static const tCGI CGI_HANDLERS[] =
{
{ "/", cgi_handler_test },
{ "/index.shtml", cgi_handler_test },
{ "/restart", cgi_handler_restart },
};
u16_t ssi_example_ssi_handler(int iIndex, char *pcInsert, int iInsertLen
, uint16_t current_tag_part, uint16_t *next_tag_part
#endif
)
{
size_t printed;
switch (iIndex)
{
case 0:
{
printed = snprintf(pcInsert, iInsertLen, "Pass");
break;
}
case 1:
{
printed = snprintf(pcInsert, iInsertLen, "Hello from Pico");
break;
}
case 2:
{
uint64_t uptime_s = absolute_time_diff_us(s_ConnectedTime, get_absolute_time()) / 1e6;
printed = snprintf(pcInsert, iInsertLen, "%d", (int)uptime_s);
break;
}
case 3:
{
printed = snprintf(pcInsert, iInsertLen, "%s", s_LedOn ? "ON" : "OFF");
break;
}
case 4:
{
printed = snprintf(pcInsert, iInsertLen, "%s", s_LedOn ? "OFF" : "ON");
break;
}
#if LWIP_HTTPD_SSI_MULTIPART
case 5:
{
printed = snprintf(pcInsert, iInsertLen, "<tr><td>This is table row number %d</td></tr>", current_tag_part + 1);
if (current_tag_part < 9)
{
*next_tag_part = current_tag_part + 1;
}
break;
}
#endif
default:
{
printed = 0;
break;
}
}
return (u16_t)printed;
}
err_t httpd_post_begin(void *connection, const char *uri, const char *http_request,
u16_t http_request_len, int content_len, char *response_uri,
u16_t response_uri_len, u8_t *post_auto_wnd)
{
if (memcmp(uri, "/led.cgi", 8) == 0 && s_CurrentConnection != connection)
{
s_CurrentConnection = connection;
snprintf(response_uri, response_uri_len, "/ledfail.shtml");
*post_auto_wnd = 1;
return ERR_OK;
}
return ERR_VAL;
}
char *httpd_param_value(struct pbuf *p, const char *param_name, char *value_buf, size_t value_buf_len)
{
size_t param_len = strlen(param_name);
u16_t param_pos = pbuf_memfind(p, param_name, param_len, 0);
if (param_pos != 0xFFFF)
{
u16_t param_value_pos = param_pos + param_len;
u16_t param_value_len = 0;
u16_t tmp = pbuf_memfind(p, "&", 1, param_value_pos);
if (tmp != 0xFFFF)
{
param_value_len = tmp - param_value_pos;
}
else
{
param_value_len = p->tot_len - param_value_pos;
}
if (param_value_len > 0 && param_value_len < value_buf_len)
{
char *result = (char *)pbuf_get_contiguous(p, value_buf, value_buf_len, param_value_len, param_value_pos);
if (result)
{
result[param_value_len] = 0;
return result;
}
}
}
return NULL;
}
err_t httpd_post_receive_data(void *connection, struct pbuf *p)
{
err_t ret = ERR_VAL;
LWIP_ASSERT("NULL pbuf", p != NULL);
if (s_CurrentConnection == connection)
{
char buf[LED_STATE_BUFSIZE];
char *val = httpd_param_value(p, "led_state=", buf, sizeof(buf));
if (val)
{
s_LedOn = (strcmp(val, "ON") == 0) ? true : false;
RequestLedUpdate();
ret = ERR_OK;
}
}
pbuf_free(p);
return ret;
}
void httpd_post_finished(void *connection, char *response_uri, u16_t response_uri_len)
{
snprintf(response_uri, response_uri_len, "/ledfail.shtml");
if (s_CurrentConnection == connection)
{
snprintf(response_uri, response_uri_len, "/ledpass.shtml");
}
s_CurrentConnection = NULL;
}
#endif
{
if (cyw43_arch_init())
{
printf("failed to initialise\n");
return false;
}
psa_status_t status = psa_crypto_init();
if (status != PSA_SUCCESS)
{
printf("failed to initialise PSA crypto: %d\n", (int)status);
cyw43_arch_deinit();
return false;
}
cyw43_arch_enable_sta_mode();
return true;
}
{
#if LWIP_MDNS_RESPONDER
mdns_resp_remove_netif(&cyw43_state.netif[CYW43_ITF_STA]);
udp_remove(get_mdns_pcb());
#endif
cyw43_arch_disable_sta_mode();
cyw43_arch_deinit();
}
{
char hostname[sizeof(CYW43_HOST_NAME) + 4];
memcpy(&hostname[0], CYW43_HOST_NAME, sizeof(CYW43_HOST_NAME) - 1);
get_mac_ascii(CYW43_HAL_MAC_WLAN0, 8, 4, &hostname[sizeof(CYW43_HOST_NAME) - 1]);
hostname[sizeof(hostname) - 1] = '\0';
netif_set_hostname(&cyw43_state.netif[CYW43_ITF_STA], hostname);
#if LWIP_MDNS_RESPONDER
cyw43_arch_lwip_begin();
mdns_resp_init();
printf("mdns host name %s.local\n", hostname);
#if LWIP_VERSION_MAJOR >= 2 && LWIP_VERSION_MINOR >= 2
mdns_resp_add_netif(&cyw43_state.netif[CYW43_ITF_STA], hostname);
mdns_resp_add_service(&cyw43_state.netif[CYW43_ITF_STA], "pico_httpd", "_http", DNSSD_PROTO_TCP, 80, srv_txt, NULL);
#else
mdns_resp_add_netif(&cyw43_state.netif[CYW43_ITF_STA], hostname, 60);
mdns_resp_add_service(&cyw43_state.netif[CYW43_ITF_STA], "pico_httpd", "_http", DNSSD_PROTO_TCP, 80, 60, srv_txt, NULL);
#endif
cyw43_arch_lwip_end();
#endif
cyw43_arch_lwip_begin();
http_set_cgi_handlers(CGI_HANDLERS, LWIP_ARRAYSIZE(CGI_HANDLERS));
http_set_ssi_handler(ssi_example_ssi_handler,
SSI_TAGS, LWIP_ARRAYSIZE(
SSI_TAGS));
s_TlsConfig = altcp_tls_create_config_server_privkey_cert(
NULL, 0,
if (s_TlsConfig == NULL)
{
printf("Failed to create TLS config - HTTPS disabled, HTTP still available\n");
}
else
{
httpd_inits(s_TlsConfig);
printf("HTTPS server listening on port %d\n", HTTPD_SERVER_PORT_HTTPS);
}
cyw43_arch_lwip_end();
}
{
printf("Connecting to WiFi...\n");
{
printf("failed to connect.\n");
return false;
}
else
{
printf("Connected.\n");
}
printf("\nReady, running httpd at %s\n", ip4addr_ntoa(netif_ip4_addr(netif_list)));
s_ConnectedTime = get_absolute_time();
return true;
}
{
private:
{
bool running = true;
while (running)
{
{
continue;
}
if (raised & FLAG_LED_UPDATE)
{
cyw43_arch_lwip_begin();
cyw43_gpio_set(&cyw43_state, 0, s_LedOn);
cyw43_arch_lwip_end();
}
if (raised & FLAG_CONNECT_WIFI)
{
{
RequestConnectWiFi();
}
}
if (raised & FLAG_INIT_NET)
{
{
RequestConnectWiFi();
}
else
{
RequestInitNetwork();
}
}
if (raised & FLAG_SHUTDOWN_NET)
{
RequestInitNetwork();
}
}
}
};
{
stdio_init_all();
stk_mbedtls_threading_init();
sys_arch_set_kernel(&kernel);
cyw43_arch_stk_preinit(&kernel, &timer_host);
RequestInitNetwork();
}
unsigned char *output, size_t output_size)
{
if (flags != 0)
{
return PSA_ERROR_NOT_SUPPORTED;
}
if (output == NULL || estimate_bits == NULL)
{
return PSA_ERROR_INVALID_ARGUMENT;
}
for (size_t i = 0; i < output_size; i++)
{
uint8_t random_byte = 0;
for (int b = 0; b < 8; b++)
{
random_byte = (random_byte << 1) | (rosc_hw->randombit & 1);
}
output[i] = random_byte;
}
*estimate_bits = 8 * output_size;
return 0;
}
#ifdef DEBUG
extern "C" const char *mbedtls_ssl_states_str(mbedtls_ssl_states state)
{
switch (state)
{
case MBEDTLS_SSL_HELLO_REQUEST: return "HELLO_REQUEST";
case MBEDTLS_SSL_CLIENT_HELLO: return "CLIENT_HELLO";
case MBEDTLS_SSL_SERVER_HELLO: return "SERVER_HELLO";
case MBEDTLS_SSL_SERVER_CERTIFICATE: return "SERVER_CERTIFICATE";
case MBEDTLS_SSL_SERVER_KEY_EXCHANGE: return "SERVER_KEY_EXCHANGE";
case MBEDTLS_SSL_CERTIFICATE_REQUEST: return "CERTIFICATE_REQUEST";
case MBEDTLS_SSL_SERVER_HELLO_DONE: return "SERVER_HELLO_DONE";
case MBEDTLS_SSL_CLIENT_CERTIFICATE: return "CLIENT_CERTIFICATE";
case MBEDTLS_SSL_CLIENT_KEY_EXCHANGE: return "CLIENT_KEY_EXCHANGE";
case MBEDTLS_SSL_CERTIFICATE_VERIFY: return "CERTIFICATE_VERIFY";
case MBEDTLS_SSL_CLIENT_CHANGE_CIPHER_SPEC: return "CLIENT_CHANGE_CIPHER_SPEC";
case MBEDTLS_SSL_CLIENT_FINISHED: return "CLIENT_FINISHED";
case MBEDTLS_SSL_SERVER_CHANGE_CIPHER_SPEC: return "SERVER_CHANGE_CIPHER_SPEC";
case MBEDTLS_SSL_SERVER_FINISHED: return "SERVER_FINISHED";
case MBEDTLS_SSL_FLUSH_BUFFERS: return "FLUSH_BUFFERS";
case MBEDTLS_SSL_HANDSHAKE_WRAPUP: return "HANDSHAKE_WRAPUP";
case MBEDTLS_SSL_HANDSHAKE_OVER: return "HANDSHAKE_OVER";
default: return "UNKNOWN_STATE";
}
}
extern "C" const char *mbedtls_ssl_named_group_to_str(uint16_t group_id)
{
switch (group_id)
{
case MBEDTLS_SSL_IANA_TLS_GROUP_SECP256R1: return "secp256r1";
case MBEDTLS_SSL_IANA_TLS_GROUP_SECP384R1: return "secp384r1";
case MBEDTLS_SSL_IANA_TLS_GROUP_SECP521R1: return "secp521r1";
case MBEDTLS_SSL_IANA_TLS_GROUP_X25519: return "x25519";
case MBEDTLS_SSL_IANA_TLS_GROUP_X448: return "x448";
case MBEDTLS_SSL_IANA_TLS_GROUP_FFDHE2048: return "ffdhe2048";
case MBEDTLS_SSL_IANA_TLS_GROUP_FFDHE3072: return "ffdhe3072";
default: return "UNKNOWN_GROUP";
}
}
extern "C" const char *mbedtls_ssl_sig_alg_to_str(uint16_t sig_alg)
{
switch (sig_alg)
{
case MBEDTLS_TLS1_3_SIG_RSA_PKCS1_SHA256: return "rsa_pkcs1_sha256";
case MBEDTLS_TLS1_3_SIG_RSA_PKCS1_SHA384: return "rsa_pkcs1_sha384";
case MBEDTLS_TLS1_3_SIG_RSA_PKCS1_SHA512: return "rsa_pkcs1_sha512";
case MBEDTLS_TLS1_3_SIG_ECDSA_SECP256R1_SHA256: return "ecdsa_secp256r1_sha256";
case MBEDTLS_TLS1_3_SIG_ECDSA_SECP384R1_SHA384: return "ecdsa_secp384r1_sha384";
case MBEDTLS_TLS1_3_SIG_ECDSA_SECP521R1_SHA512: return "ecdsa_secp521r1_sha512";
case MBEDTLS_TLS1_3_SIG_RSA_PSS_RSAE_SHA256: return "rsa_pss_rsae_sha256";
case MBEDTLS_TLS1_3_SIG_RSA_PSS_RSAE_SHA384: return "rsa_pss_rsae_sha384";
case MBEDTLS_TLS1_3_SIG_RSA_PSS_RSAE_SHA512: return "rsa_pss_rsae_sha512";
case MBEDTLS_TLS1_3_SIG_ED25519: return "ed25519";
case MBEDTLS_TLS1_3_SIG_ED448: return "ed448";
default: return "unknown_sig_alg";
}
}
#endif
const unsigned char s_TlsCert[]
const unsigned char s_TlsKey[]
#define LWIP_HTTPD_SSI_MULTIPART
Top-level STK include. Provides the Kernel class template and all built-in task-switching strategies.
#define STK_UNUSED(X)
Explicitly marks a variable as unused to suppress compiler warnings.
#define STK_ASSERT(e)
Runtime assertion. Halts execution if the expression e evaluates to false.
Collection of synchronization primitives (stk::sync namespace).
Collection of time-related primitives (stk::time namespace).
Namespace of STK package.
@ ACCESS_USER
Unprivileged access mode (access to some hardware is restricted, see CPU manual for details)....
static constexpr Timeout WAIT_INFINITE
Timeout value: block indefinitely until the synchronization object is signaled.
@ KERNEL_TICKLESS
Tickless mode. To use this mode STK_TICKLESS_IDLE must be defined to 1 in stk_config....
@ KERNEL_SYNC
Synchronization support (see Event).
@ KERNEL_DYNAMIC
Tasks can be added or removed and therefore exit when done.
EventFlagsT< uint32_t > EventFlags
Default event flags group with a 32-bit flags word (31 usable flags, bit 31 reserved).
Concrete implementation of IKernel.
void Start() override
Start the scheduler. This call does not return until all tasks have exited (KERNEL_DYNAMIC mode) or i...
EAddResult AddTask(ITask *user_task) override
Register task for a soft real-time (SRT) scheduling.
void Initialize(uint32_t resolution_us=PERIODICITY_DEFAULT) override
Initialize kernel.
Partial implementation of the user task.
T Set(T flags)
Set one or more flags.
static constexpr uint32_t OPT_WAIT_ANY
T Wait(T flags, uint32_t options=OPT_WAIT_ANY, Timeout timeout_ticks=WAIT_INFINITE)
Wait for one or more flags to be set.
static bool IsError(uint32_t result)
Software timer multiplexer that manages multiple Timer instances on top of a small fixed set of kerne...
EAddResult Initialize(IKernel *kernel, EAccessMode mode, const Config &cfg=Config())
Initialize timer host instance.
@ TASK_COUNT
total number of tasks serving this instance
void Run() override
Entry point of the user task.
static const char * SSI_TAGS[]
static bool ConnectWiFi()
static void ShutdownNetwork()
const char WIFI_PASSWORD[]
static bool InitNetwork()
static bool ConnectWiFi()
int __mbedtls_platform_get_entropy(psa_driver_get_entropy_flags_t flags, size_t *estimate_bits, unsigned char *output, size_t output_size)
static void ShutdownNetwork()
static bool InitNetwork()