Merge pull request #1 from vajr8/main

Add WiFi AP mode

CMakeLists.txt

 add_executable(picowota
 	main.c
 	tcp_comm.c
+	dhcpserver/dhcpserver.c
 )
 
 function(target_cl_options option)
 
 pico_add_extra_outputs(picowota)
 
-# Needed so that lwip can find lwipopts.h
-target_include_directories(picowota PRIVATE ${CMAKE_CURRENT_LIST_DIR})
+target_include_directories(picowota PRIVATE
+	${CMAKE_CURRENT_LIST_DIR} # Needed so that lwip can find lwipopts.h
+	${CMAKE_CURRENT_LIST_DIR}/dhcpserver)
 
 pico_enable_stdio_usb(picowota 1)
 
 	picowota_reboot
 )
 
-if (DEFINED ENV{PICOWOTA_WIFI_SSID} AND (NOT PICOWOTA_WIFI_SSID))
-	set(PICOWOTA_WIFI_SSID $ENV{PICOWOTA_WIFI_SSID})
-	message("Using PICOWOTA_WIFI_SSID from environment ('${PICOWOTA_WIFI_SSID}')")
-endif ()
+# Retrieves build variables from the environment if present
+function(picowota_retrieve_variable name hidden)
+	if (DEFINED ENV{${name}} AND (NOT ${name}))
+		set(${name} $ENV{${name}} PARENT_SCOPE)
+		if (hidden)
+			set(log_value "hidden")
+		else()
+			set(log_value "'$ENV{${name}}'")
+		endif()
+		message("Using ${name} from environment (${log_value})")
+	endif()
+endfunction()
 
-if (DEFINED ENV{PICOWOTA_WIFI_PASS} AND (NOT PICOWOTA_WIFI_PASS))
-	set(PICOWOTA_WIFI_PASS $ENV{PICOWOTA_WIFI_PASS})
-	message("Using PICOWOTA_WIFI_PASS from environment (hidden)")
-endif ()
+picowota_retrieve_variable(PICOWOTA_WIFI_SSID false)
+picowota_retrieve_variable(PICOWOTA_WIFI_PASS true)
+picowota_retrieve_variable(PICOWOTA_WIFI_AP false)
 
 if ((NOT PICOWOTA_WIFI_SSID) OR (NOT PICOWOTA_WIFI_PASS))
         message(FATAL_ERROR
 target_compile_definitions(picowota PUBLIC PICOWOTA_WIFI_SSID=${PICOWOTA_WIFI_SSID})
 target_compile_definitions(picowota PUBLIC PICOWOTA_WIFI_PASS=${PICOWOTA_WIFI_PASS})
 
+# Use the WiFi AP mode upon request
+if (PICOWOTA_WIFI_AP)
+	target_compile_definitions(picowota PUBLIC PICOWOTA_WIFI_AP=1)
+	message("Building in WiFi AP mode.")
+endif()
+
 # Provide a helper to build a standalone target
 function(picowota_build_standalone NAME)
 	get_target_property(PICOWOTA_SRC_DIR picowota SOURCE_DIR)

README.md

 add_subdirectory(picowota)
 ```
 
-`picowota` (currently) connects to an existing WiFi network, so you need to
-set the SSID and password for the network to connect to.
+`picowota` either connects to an existing WiFi network (by default) or
+creates one, in both cases with the given SSID and password.
 
-You can either export the `PICOWOTA_WIFI_SSID` and `PICOWOTA_WIFI_PASS`
-environment variables, or set the CMake variables with the same name:
+You can either provide the following as environment variables, or set them
+as CMake variables:
 
 ```
-set(PICOWOTA_WIFI_SSID MyNetworkName)
-set(PICOWOTA_WIFI_PASS MyPassw0rd)
+PICOWOTA_WIFI_SSID # The WiFi network SSID
+PICOWOTA_WIFI_PASS # The WiFi network password
+PICOWOTA_WIFI_AP # Optional; 0 = connect to the network, 1 = create it
 ```
 
 Then, you can either build just your standalone app binary (suitable for
 valid app code uploaded yet, or your app called `picowota_reboot(true);`), you
 can upload an app `.elf` file which was built by `picowota_build_standalone()`:
 
+If using the AP mode, the Pico's IP address will be (at the time of writing)
+192.168.4.1/24, and the connected device's something in the same subnet.
+Otherwise it depends on your network settings.
+
 (Assuming your Pico's IP address is 192.168.1.123):
 ```
 serial-flash tcp:192.168.1.123:4242 my_executable_name.elf
 libraries don't give a mechanism to do so.
 
 I've raised https://github.com/raspberrypi/pico-sdk/issues/928 for consideration.
-
-### Expose an access point, rather than connecting to one
-
-It would perhaps be better if the bootloader set up an access point, rather than
-trying to connect to an existing network - or even better, provide the option.
-I expect that wouldn't be too hard to do.

dhcpserver/LICENSE

+The MIT License (MIT)
+
+Copyright (c) 2013-2022 Damien P. George
+
+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.

dhcpserver/dhcpserver.c

+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2018-2019 Damien P. George
+ *
+ * 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.
+ */
+
+// For DHCP specs see:
+//  https://www.ietf.org/rfc/rfc2131.txt
+//  https://tools.ietf.org/html/rfc2132 -- DHCP Options and BOOTP Vendor Extensions
+
+#include <stdio.h>
+#include <string.h>
+#include <errno.h>
+
+#include "cyw43_config.h"
+#include "dhcpserver.h"
+#include "lwip/udp.h"
+
+#define DHCPDISCOVER    (1)
+#define DHCPOFFER       (2)
+#define DHCPREQUEST     (3)
+#define DHCPDECLINE     (4)
+#define DHCPACK         (5)
+#define DHCPNACK        (6)
+#define DHCPRELEASE     (7)
+#define DHCPINFORM      (8)
+
+#define DHCP_OPT_PAD                (0)
+#define DHCP_OPT_SUBNET_MASK        (1)
+#define DHCP_OPT_ROUTER             (3)
+#define DHCP_OPT_DNS                (6)
+#define DHCP_OPT_HOST_NAME          (12)
+#define DHCP_OPT_REQUESTED_IP       (50)
+#define DHCP_OPT_IP_LEASE_TIME      (51)
+#define DHCP_OPT_MSG_TYPE           (53)
+#define DHCP_OPT_SERVER_ID          (54)
+#define DHCP_OPT_PARAM_REQUEST_LIST (55)
+#define DHCP_OPT_MAX_MSG_SIZE       (57)
+#define DHCP_OPT_VENDOR_CLASS_ID    (60)
+#define DHCP_OPT_CLIENT_ID          (61)
+#define DHCP_OPT_END                (255)
+
+#define PORT_DHCP_SERVER (67)
+#define PORT_DHCP_CLIENT (68)
+
+#define DEFAULT_DNS MAKE_IP4(8, 8, 8, 8)
+#define DEFAULT_LEASE_TIME_S (24 * 60 * 60) // in seconds
+
+#define MAC_LEN (6)
+#define MAKE_IP4(a, b, c, d) ((a) << 24 | (b) << 16 | (c) << 8 | (d))
+
+typedef struct {
+    uint8_t op; // message opcode
+    uint8_t htype; // hardware address type
+    uint8_t hlen; // hardware address length
+    uint8_t hops;
+    uint32_t xid; // transaction id, chosen by client
+    uint16_t secs; // client seconds elapsed
+    uint16_t flags;
+    uint8_t ciaddr[4]; // client IP address
+    uint8_t yiaddr[4]; // your IP address
+    uint8_t siaddr[4]; // next server IP address
+    uint8_t giaddr[4]; // relay agent IP address
+    uint8_t chaddr[16]; // client hardware address
+    uint8_t sname[64]; // server host name
+    uint8_t file[128]; // boot file name
+    uint8_t options[312]; // optional parameters, variable, starts with magic
+} dhcp_msg_t;
+
+static int dhcp_socket_new_dgram(struct udp_pcb **udp, void *cb_data, udp_recv_fn cb_udp_recv) {
+    // family is AF_INET
+    // type is SOCK_DGRAM
+
+    *udp = udp_new();
+    if (*udp == NULL) {
+        return -ENOMEM;
+    }
+
+    // Register callback
+    udp_recv(*udp, cb_udp_recv, (void *)cb_data);
+
+    return 0; // success
+}
+
+static void dhcp_socket_free(struct udp_pcb **udp) {
+    if (*udp != NULL) {
+        udp_remove(*udp);
+        *udp = NULL;
+    }
+}
+
+static int dhcp_socket_bind(struct udp_pcb **udp, uint32_t ip, uint16_t port) {
+    ip_addr_t addr;
+    IP4_ADDR(&addr, ip >> 24 & 0xff, ip >> 16 & 0xff, ip >> 8 & 0xff, ip & 0xff);
+    // TODO convert lwIP errors to errno
+    return udp_bind(*udp, &addr, port);
+}
+
+static int dhcp_socket_sendto(struct udp_pcb **udp, const void *buf, size_t len, uint32_t ip, uint16_t port) {
+    if (len > 0xffff) {
+        len = 0xffff;
+    }
+
+    struct pbuf *p = pbuf_alloc(PBUF_TRANSPORT, len, PBUF_RAM);
+    if (p == NULL) {
+        return -ENOMEM;
+    }
+
+    memcpy(p->payload, buf, len);
+
+    ip_addr_t dest;
+    IP4_ADDR(&dest, ip >> 24 & 0xff, ip >> 16 & 0xff, ip >> 8 & 0xff, ip & 0xff);
+    err_t err = udp_sendto(*udp, p, &dest, port);
+
+    pbuf_free(p);
+
+    if (err != ERR_OK) {
+        return err;
+    }
+
+    return len;
+}
+
+static uint8_t *opt_find(uint8_t *opt, uint8_t cmd) {
+    for (int i = 0; i < 308 && opt[i] != DHCP_OPT_END;) {
+        if (opt[i] == cmd) {
+            return &opt[i];
+        }
+        i += 2 + opt[i + 1];
+    }
+    return NULL;
+}
+
+static void opt_write_n(uint8_t **opt, uint8_t cmd, size_t n, void *data) {
+    uint8_t *o = *opt;
+    *o++ = cmd;
+    *o++ = n;
+    memcpy(o, data, n);
+    *opt = o + n;
+}
+
+static void opt_write_u8(uint8_t **opt, uint8_t cmd, uint8_t val) {
+    uint8_t *o = *opt;
+    *o++ = cmd;
+    *o++ = 1;
+    *o++ = val;
+    *opt = o;
+}
+
+static void opt_write_u32(uint8_t **opt, uint8_t cmd, uint32_t val) {
+    uint8_t *o = *opt;
+    *o++ = cmd;
+    *o++ = 4;
+    *o++ = val >> 24;
+    *o++ = val >> 16;
+    *o++ = val >> 8;
+    *o++ = val;
+    *opt = o;
+}
+
+static void dhcp_server_process(void *arg, struct udp_pcb *upcb, struct pbuf *p, const ip_addr_t *src_addr, u16_t src_port) {
+    dhcp_server_t *d = arg;
+    (void)upcb;
+    (void)src_addr;
+    (void)src_port;
+
+    // This is around 548 bytes
+    dhcp_msg_t dhcp_msg;
+
+    #define DHCP_MIN_SIZE (240 + 3)
+    if (p->tot_len < DHCP_MIN_SIZE) {
+        goto ignore_request;
+    }
+
+    size_t len = pbuf_copy_partial(p, &dhcp_msg, sizeof(dhcp_msg), 0);
+    if (len < DHCP_MIN_SIZE) {
+        goto ignore_request;
+    }
+
+    dhcp_msg.op = DHCPOFFER;
+    memcpy(&dhcp_msg.yiaddr, &d->ip.addr, 4);
+
+    uint8_t *opt = (uint8_t *)&dhcp_msg.options;
+    opt += 4; // assume magic cookie: 99, 130, 83, 99
+
+    switch (opt[2]) {
+        case DHCPDISCOVER: {
+            int yi = DHCPS_MAX_IP;
+            for (int i = 0; i < DHCPS_MAX_IP; ++i) {
+                if (memcmp(d->lease[i].mac, dhcp_msg.chaddr, MAC_LEN) == 0) {
+                    // MAC match, use this IP address
+                    yi = i;
+                    break;
+                }
+                if (yi == DHCPS_MAX_IP) {
+                    // Look for a free IP address
+                    if (memcmp(d->lease[i].mac, "\x00\x00\x00\x00\x00\x00", MAC_LEN) == 0) {
+                        // IP available
+                        yi = i;
+                    }
+                    uint32_t expiry = d->lease[i].expiry << 16 | 0xffff;
+                    if ((int32_t)(expiry - cyw43_hal_ticks_ms()) < 0) {
+                        // IP expired, reuse it
+                        memset(d->lease[i].mac, 0, MAC_LEN);
+                        yi = i;
+                    }
+                }
+            }
+            if (yi == DHCPS_MAX_IP) {
+                // No more IP addresses left
+                goto ignore_request;
+            }
+            dhcp_msg.yiaddr[3] = DHCPS_BASE_IP + yi;
+            opt_write_u8(&opt, DHCP_OPT_MSG_TYPE, DHCPOFFER);
+            break;
+        }
+
+        case DHCPREQUEST: {
+            uint8_t *o = opt_find(opt, DHCP_OPT_REQUESTED_IP);
+            if (o == NULL) {
+                // Should be NACK
+                goto ignore_request;
+            }
+            if (memcmp(o + 2, &d->ip.addr, 3) != 0) {
+                // Should be NACK
+                goto ignore_request;
+            }
+            uint8_t yi = o[5] - DHCPS_BASE_IP;
+            if (yi >= DHCPS_MAX_IP) {
+                // Should be NACK
+                goto ignore_request;
+            }
+            if (memcmp(d->lease[yi].mac, dhcp_msg.chaddr, MAC_LEN) == 0) {
+                // MAC match, ok to use this IP address
+            } else if (memcmp(d->lease[yi].mac, "\x00\x00\x00\x00\x00\x00", MAC_LEN) == 0) {
+                // IP unused, ok to use this IP address
+                memcpy(d->lease[yi].mac, dhcp_msg.chaddr, MAC_LEN);
+            } else {
+                // IP already in use
+                // Should be NACK
+                goto ignore_request;
+            }
+            d->lease[yi].expiry = (cyw43_hal_ticks_ms() + DEFAULT_LEASE_TIME_S * 1000) >> 16;
+            dhcp_msg.yiaddr[3] = DHCPS_BASE_IP + yi;
+            opt_write_u8(&opt, DHCP_OPT_MSG_TYPE, DHCPACK);
+            printf("DHCPS: client connected: MAC=%02x:%02x:%02x:%02x:%02x:%02x IP=%u.%u.%u.%u\n",
+                dhcp_msg.chaddr[0], dhcp_msg.chaddr[1], dhcp_msg.chaddr[2], dhcp_msg.chaddr[3], dhcp_msg.chaddr[4], dhcp_msg.chaddr[5],
+                dhcp_msg.yiaddr[0], dhcp_msg.yiaddr[1], dhcp_msg.yiaddr[2], dhcp_msg.yiaddr[3]);
+            break;
+        }
+
+        default:
+            goto ignore_request;
+    }
+
+    opt_write_n(&opt, DHCP_OPT_SERVER_ID, 4, &d->ip.addr);
+    opt_write_n(&opt, DHCP_OPT_SUBNET_MASK, 4, &d->nm.addr);
+    opt_write_n(&opt, DHCP_OPT_ROUTER, 4, &d->ip.addr); // aka gateway; can have mulitple addresses
+    opt_write_u32(&opt, DHCP_OPT_DNS, DEFAULT_DNS); // can have mulitple addresses
+    opt_write_u32(&opt, DHCP_OPT_IP_LEASE_TIME, DEFAULT_LEASE_TIME_S);
+    *opt++ = DHCP_OPT_END;
+    dhcp_socket_sendto(&d->udp, &dhcp_msg, opt - (uint8_t *)&dhcp_msg, 0xffffffff, PORT_DHCP_CLIENT);
+
+ignore_request:
+    pbuf_free(p);
+}
+
+void dhcp_server_init(dhcp_server_t *d, ip_addr_t *ip, ip_addr_t *nm) {
+    ip_addr_copy(d->ip, *ip);
+    ip_addr_copy(d->nm, *nm);
+    memset(d->lease, 0, sizeof(d->lease));
+    if (dhcp_socket_new_dgram(&d->udp, d, dhcp_server_process) != 0) {
+        return;
+    }
+    dhcp_socket_bind(&d->udp, 0, PORT_DHCP_SERVER);
+}
+
+void dhcp_server_deinit(dhcp_server_t *d) {
+    dhcp_socket_free(&d->udp);
+}

dhcpserver/dhcpserver.h

+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2018-2019 Damien P. George
+ *
+ * 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.
+ */
+#ifndef MICROPY_INCLUDED_LIB_NETUTILS_DHCPSERVER_H
+#define MICROPY_INCLUDED_LIB_NETUTILS_DHCPSERVER_H
+
+#include "lwip/ip_addr.h"
+
+#define DHCPS_BASE_IP (16)
+#define DHCPS_MAX_IP (8)
+
+typedef struct _dhcp_server_lease_t {
+    uint8_t mac[6];
+    uint16_t expiry;
+} dhcp_server_lease_t;
+
+typedef struct _dhcp_server_t {
+    ip_addr_t ip;
+    ip_addr_t nm;
+    dhcp_server_lease_t lease[DHCPS_MAX_IP];
+    struct udp_pcb *udp;
+} dhcp_server_t;
+
+void dhcp_server_init(dhcp_server_t *d, ip_addr_t *ip, ip_addr_t *nm);
+void dhcp_server_deinit(dhcp_server_t *d);
+
+#endif // MICROPY_INCLUDED_LIB_NETUTILS_DHCPSERVER_H

main.c

 #define DBG_PRINTF(...) { }
 #endif
 
+#if PICOWOTA_WIFI_AP == 1
+#include "dhcpserver.h"
+static dhcp_server_t dhcp_server;
+#endif
+
 #define QUOTE(name) #name
 #define STR(macro) QUOTE(macro)
 
 	return !gpio_get(BOOTLOADER_ENTRY_PIN) || wd_says_so;
 }
 
+static void network_deinit()
+{
+#if PICOWOTA_WIFI_AP == 1
+	dhcp_server_deinit(&dhcp_server);
+#endif
+	cyw43_arch_deinit();
+}
+
 int main()
 {
 	err_t err;
 		return 1;
 	}
 
+#if PICOWOTA_WIFI_AP == 1
+	cyw43_arch_enable_ap_mode(wifi_ssid, wifi_pass, CYW43_AUTH_WPA2_AES_PSK);
+	DBG_PRINTF("Enabled the WiFi AP.\n");
+
+	ip4_addr_t gw, mask;
+	IP4_ADDR(&gw, 192, 168, 4, 1);
+	IP4_ADDR(&mask, 255, 255, 255, 0);
+
+	dhcp_server_t dhcp_server;
+	dhcp_server_init(&dhcp_server, &gw, &mask);
+	DBG_PRINTF("Started the DHCP server.\n");
+#else
 	cyw43_arch_enable_sta_mode();
 
 	DBG_PRINTF("Connecting to WiFi...\n");
 	} else {
 		DBG_PRINTF("Connected.\n");
 	}
+#endif
 
 	critical_section_init(&critical_section);
 
 				break;
 			case EVENT_TYPE_REBOOT:
 				tcp_comm_server_close(tcp);
-				cyw43_arch_deinit();
+				network_deinit();
 				picowota_reboot(ev.reboot.to_bootloader);
 				/* Should never get here */
 				break;
 			case EVENT_TYPE_GO:
 				tcp_comm_server_close(tcp);
-				cyw43_arch_deinit();
+				network_deinit();
 				disable_interrupts();
 				reset_peripherals();
 				jump_to_vtor(ev.go.vtor);
 		sleep_ms(5);
 	}
 
-	cyw43_arch_deinit();
+	network_deinit();
 	return 0;
 }