ssltest/0000775000175000017500000000000012564334643011237 5ustar alexalexssltest/user/0000775000175000017500000000000012564277604012220 5ustar alexalexssltest/user/stdout.h0000664000175000017500000000013612564300147013700 0ustar alexalex#ifndef __DRV_STDOUT_H__ #define __DRV_STDOUT_H__ void ICACHE_FLASH_ATTR stdoutInit(); #endif ssltest/user/user_main.c0000664000175000017500000001523712564332277014354 0ustar alexalex/* The obligatory blinky demo Blink an LED on GPIO pin 2 */ #include #include #include #include #include #include "user_main.h" #include "httpclient.h" #ifndef xstr #define xstr(a) str(a) #define str(a) #a #endif #ifndef WIFI_SSID #error "Please, define wifi network" #else #define STR_WIFI_SSID xstr(WIFI_SSID) #define STR_WIFI_PASS xstr(WIFI_PASS) #endif #ifndef URL_TO_POST #error "Please, define target" #else // #define URL_TO_POST "https://test.http.server.com/path" // #define STR_URL_TO_POST xstr(URL_TO_POST) #define STR_URL_TO_POST URL_TO_POST #endif #ifndef DATA_TO_POST #error "Please, define post data" #else // #define DATA_TO_POST "var1=val1&var2=val2" #define STR_DATA_TO_POST xstr(DATA_TO_POST) #endif unsigned char *default_certificate; unsigned int default_certificate_len = 0; unsigned char *default_private_key; unsigned int default_private_key_len = 0; #define QUEUE_PRIORITY 1 #define QUEUE_LENGTH 1 static os_event_t task_queue[QUEUE_LENGTH]; static void user_task(os_event_t *events); static void ICACHE_FLASH_ATTR do_http(char *url); static ETSTimer user_t; int ICACHE_FLASH_ATTR send_user_sig(int sig, void *arg) { return system_os_post(QUEUE_PRIORITY, sig, (uint32_t)arg ); } static void ICACHE_FLASH_ATTR run_user_task(void *arg) { system_os_post(QUEUE_PRIORITY, SIG_USER, 0 ); } static int t; //Main code function static void ICACHE_FLASH_ATTR user_task(os_event_t *events) { int lt; if (events->sig == SIG_CONN_CLOSE) { os_printf("closing conn:%p\n", (void *)events->par); lt = espconn_disconnect((void *)events->par); if (lt) { os_printf("Error closing:%d\n", (int)lt); } return; } if (events->sig == SIG_CONN_SECURE_CLOSE) { os_printf("closing sconn:%p\n", (void *)events->par); lt = espconn_secure_disconnect((void *)events->par); if (lt) { os_printf("Error closing:%d\n", (int)lt); } return; } if (events->sig == SIG_WIFI) { int sta = (int)events->par; if (sta == STATION_GOT_IP) { os_printf("Starting request to:[%s]\n", STR_URL_TO_POST); do_http(STR_URL_TO_POST); } else { os_printf("wifi:%d\n", sta); } return; } if (events->sig == SIG_USER) { t++; static int last_fh; int fh = system_get_free_heap_size(); if (last_fh != fh) { os_printf("FH:%d t:%d\n", fh,t); last_fh = fh; } return; } if (events->sig == SIG_READY) { os_printf("Ready\n"); os_timer_disarm(&user_t); os_timer_setfn(&user_t, (os_timer_func_t *)run_user_task, NULL); os_timer_arm(&user_t, 1000 , 1); return; } os_printf("Unkn sig:%d\n", events->sig); } static void ICACHE_FLASH_ATTR cr_callback(char * response, int http_status, char * full_response) { os_printf("http_status=%d\n", http_status); if (http_status != HTTP_STATUS_GENERIC_ERROR) { os_printf("strlen(full_response)=%d\n", strlen(full_response)); } else { os_printf("httperr:%d\n", http_status); } } static void ICACHE_FLASH_ATTR do_http(char *url) { char *pdata = STR_DATA_TO_POST; http_post(url, pdata, "Content-Type: application/x-www-form-urlencoded\r\n", cr_callback); } static void ICACHE_FLASH_ATTR set_wifi_mode(int mode) { wifi_station_disconnect(); ETS_UART_INTR_DISABLE(); wifi_set_opmode_current(mode); ETS_UART_INTR_ENABLE(); os_delay_us(500); } static void ICACHE_FLASH_ATTR do_wifi_cfg() { struct station_config stationConf; if (wifi_get_phy_mode() != PHY_MODE_11N) { wifi_set_phy_mode(PHY_MODE_11N); } os_printf("Wifi Setup\n"); set_wifi_mode(STATION_MODE); wifi_station_set_auto_connect(FALSE); wifi_station_disconnect(); os_memset(&stationConf, 0, sizeof(struct station_config)); os_strcpy((char *)stationConf.ssid, STR_WIFI_SSID); os_strcpy((char *)stationConf.password, STR_WIFI_PASS); wifi_station_set_config(&stationConf); wifi_station_set_auto_connect(TRUE); wifi_station_connect(); } void ICACHE_FLASH_ATTR wifi_connected_cb(System_Event_t *evt) { uint8 newchannel = 0; char buf[16]; int i,sz=0; switch (evt->event) { case EVENT_STAMODE_CONNECTED: newchannel = evt->event_info.connected.channel; sz = 0; for (i=0; i < 6; i++) { sz+=os_sprintf(buf+sz,"%02X", evt->event_info.connected.bssid[i]); } os_printf("Channel: %d SSID:[%s] BSSID:%s\n", newchannel, evt->event_info.connected.ssid, buf); // system_os_post(QUEUE_PRIORITY, SIG_WIFI, STATION_CONNECT ); break; case EVENT_STAMODE_DISCONNECTED: system_os_post(QUEUE_PRIORITY, SIG_WIFI, STATION_CONNECT_FAIL ); break; case EVENT_STAMODE_AUTHMODE_CHANGE: break; case EVENT_STAMODE_GOT_IP: os_printf("Got ip\n"); system_os_post(QUEUE_PRIORITY, SIG_WIFI, STATION_GOT_IP ); break; case EVENT_SOFTAPMODE_STACONNECTED: break; case EVENT_SOFTAPMODE_STADISCONNECTED: break; } } // see eagle_soc.h for these definitions #define LED_GPIO 2 #define LED_GPIO_MUX PERIPHS_IO_MUX_GPIO2_U #define LED_GPIO_FUNC FUNC_GPIO2 #define DELAY 500000 /* microseconds */ // extern void ets_wdt_enable (void); // extern void ets_wdt_disable (void); // extern void wdt_feed (void); void user_init(void) { uint8_t state=0; // ets_wdt_enable(); // ets_wdt_disable(); // Configure pin as a GPIO // PIN_FUNC_SELECT(LED_GPIO_MUX, LED_GPIO_FUNC); stdoutInit(); os_delay_us(500); os_printf("\n\nInit SDK:%s\n", system_get_sdk_version()); if (1) { int sect; sect = 0x6b; os_printf("cachain at %x\n", sect); espconn_secure_ca_enable(1, sect); } wifi_set_event_handler_cb(wifi_connected_cb); do_wifi_cfg(); /* for(;;) { GPIO_OUTPUT_SET(LED_GPIO, state); os_delay_us(DELAY); state ^=1; // wdt_feed(); } */ system_os_task(user_task, QUEUE_PRIORITY, task_queue, QUEUE_LENGTH); send_user_sig(SIG_READY, NULL); os_printf("Init done\n"); } ssltest/user/stdout.c0000664000175000017500000000222312564300170013666 0ustar alexalex#include "espmissingincludes.h" #include "ets_sys.h" #include "osapi.h" #include "uart_hw.h" static void ICACHE_FLASH_ATTR stdoutUartTxd(char c) { //Wait until there is room in the FIFO while (((READ_PERI_REG(UART_STATUS(0))>>UART_TXFIFO_CNT_S)&UART_TXFIFO_CNT)>=126) ; //Send the character WRITE_PERI_REG(UART_FIFO(0), c); } static void ICACHE_FLASH_ATTR stdoutPutchar(char c) { //convert \n -> \r\n if (c=='\n') stdoutUartTxd('\r'); stdoutUartTxd(c); } void ICACHE_FLASH_ATTR stdoutInit() { //Enable TxD pin PIN_PULLUP_DIS(PERIPHS_IO_MUX_U0TXD_U); PIN_FUNC_SELECT(PERIPHS_IO_MUX_U0TXD_U, FUNC_U0TXD); //Set baud rate and other serial parameters to 115200,n,8,1 uart_div_modify(0, UART_CLK_FREQ/BIT_RATE_115200); WRITE_PERI_REG(UART_CONF0(0), (STICK_PARITY_DIS)|(ONE_STOP_BIT << UART_STOP_BIT_NUM_S)| \ (EIGHT_BITS << UART_BIT_NUM_S)); //Reset tx & rx fifo SET_PERI_REG_MASK(UART_CONF0(0), UART_RXFIFO_RST|UART_TXFIFO_RST); CLEAR_PERI_REG_MASK(UART_CONF0(0), UART_RXFIFO_RST|UART_TXFIFO_RST); //Clear pending interrupts WRITE_PERI_REG(UART_INT_CLR(0), 0xffff); //Install our own putchar handler os_install_putc1((void *)stdoutPutchar); } ssltest/user/user_main.h0000664000175000017500000000036512564311353014345 0ustar alexalex#ifndef __USER_MAIN__H_ #define __USER_MAIN__H_ #define SIG_USER 1 #define SIG_WIFI 2 #define SIG_CONN_CLOSE 3 #define SIG_CONN_SECURE_CLOSE 4 #define SIG_READY 5 int ICACHE_FLASH_ATTR send_user_sig(int sig, void *arg); #endif ssltest/comp.sh0000775000175000017500000000006112564305646012532 0ustar alexalexmake clean make V=1 BOOT=new APP=1 SPI_SIZE=2048 ssltest/flashdev.sh0000775000175000017500000000072112564330174013365 0ustar alexalex#! /bin/sh #./esptool.py --port /dev/ttyUSB1 --baud 115200 write_flash --flash_size 16m-c1 \ ./esptool.py --port /dev/ttyUSB1 --baud 460800 write_flash --flash_size 16m-c1 \ 0x00000 "$SDK_BASE/bin/boot_v1.4(b1).bin" \ 0x01000 firmware/upgrade/user1.1024.new.bin \ 0x6b000 bin/esp_ca_cert.bin \ 0x0fc000 "$SDK_BASE/bin/blank.bin" \ 0x1fe000 "$SDK_BASE/bin/blank.bin" \ 0x1FC000 "$SDK_BASE/bin/esp_init_data_default.bin" #0x101000 firmware/user2.bin \ ssltest/Makefile0000664000175000017500000002204112564314537012676 0ustar alexalex############################################################# # # Root Level Makefile # # (c) by CHERTS # ############################################################# BUILD_BASE = build FW_BASE = firmware # Base directory for the compiler XTENSA_TOOLS_ROOT ?= c:/Espressif/xtensa-lx106-elf/bin # base directory of the ESP8266 SDK package, absolute SDK_BASE ?= c:/Espressif/ESP8266_SDK # esptool path and port SDK_TOOLS ?= c:/Espressif/utils ESPTOOL ?= $(SDK_TOOLS)/esptool.exe ESPPORT ?= COM2 # BOOT = none # BOOT = old - boot_v1.1 # BOOT = new - boot_v1.2+ BOOT?=none # APP = 0 - eagle.flash.bin + eagle.irom0text.bin # APP = 1 - user1.bin # APP = 2 - user2.bin APP?=0 # SPI_SPEED = 20MHz, 26.7MHz, 40MHz, 80MHz SPI_SPEED?=40 # SPI_MODE: QIO, QOUT, DIO, DOUT SPI_MODE?=QIO # SPI_SIZE: 256KB, 512KB, 1024KB, 2048KB, 4096KB SPI_SIZE?=512 ifeq ($(BOOT), new) boot = new else ifeq ($(BOOT), old) boot = old else boot = none endif endif ifeq ($(APP), 1) app = 1 else ifeq ($(APP), 2) app = 2 else app = 0 endif endif ifeq ($(SPI_SPEED), 26.7) freqdiv = 1 else ifeq ($(SPI_SPEED), 20) freqdiv = 2 else ifeq ($(SPI_SPEED), 80) freqdiv = 15 else freqdiv = 0 endif endif endif ifeq ($(SPI_MODE), QOUT) mode = 1 else ifeq ($(SPI_MODE), DIO) mode = 2 else ifeq ($(SPI_MODE), DOUT) mode = 3 else mode = 0 endif endif endif # flash larger than 1024KB only use 1024KB to storage user1.bin and user2.bin ifeq ($(SPI_SIZE), 256) size = 1 flash = 256 else ifeq ($(SPI_SIZE), 1024) size = 2 flash = 1024 else ifeq ($(SPI_SIZE), 2048) size = 3 flash = 1024 else ifeq ($(SPI_SIZE), 4096) size = 4 flash = 1024 else size = 0 flash = 512 endif endif endif endif ifeq ($(flash), 512) ifeq ($(app), 1) addr = 0x01000 else ifeq ($(app), 2) addr = 0x41000 endif endif else ifeq ($(flash), 1024) ifeq ($(app), 1) addr = 0x01000 else ifeq ($(app), 2) addr = 0x81000 endif endif endif endif # name for the target project TARGET = app # which modules (subdirectories) of the project to include in compiling MODULES = driver user esphttpclient EXTRA_INCDIR = include $(SDK_BASE)/../include # libraries used in this project, mainly provided by the SDK LIBS = c gcc hal phy pp net80211 lwip wpa main ssl crypto # compiler flags using during compilation of source files CFLAGS = -Os -g -O2 -Wpointer-arith -Wundef -Werror -Wl,-EL -fno-inline-functions -nostdlib -mlongcalls -mtext-section-literals -D__ets__ -DICACHE_FLASH CFLAGS += -DWIFI_SSID="$(WIFI_SSID)" -DWIFI_PASS="$(WIFI_PASS)" CFLAGS += -DURL_TO_POST=\"$(URL_TO_POST)\" -DDATA_TO_POST="$(DATA_TO_POST)" # linker flags used to generate the main object file LDFLAGS = -nostdlib -Wl,--no-check-sections -u call_user_start -Wl,-static # linker script used for the above linkier step LD_SCRIPT = eagle.app.v6.ld ifneq ($(boot), none) ifneq ($(app),0) LD_SCRIPT = eagle.app.v6.$(boot).$(flash).app$(app).ld BIN_NAME = user$(app).$(flash).$(boot) endif else app = 0 endif # various paths from the SDK used in this project SDK_LIBDIR = lib SDK_LDDIR = ld SDK_INCDIR = include include/json # select which tools to use as compiler, librarian and linker CC := $(XTENSA_TOOLS_ROOT)/xtensa-lx106-elf-gcc AR := $(XTENSA_TOOLS_ROOT)/xtensa-lx106-elf-ar LD := $(XTENSA_TOOLS_ROOT)/xtensa-lx106-elf-gcc OBJCOPY := $(XTENSA_TOOLS_ROOT)/xtensa-lx106-elf-objcopy OBJDUMP := $(XTENSA_TOOLS_ROOT)/xtensa-lx106-elf-objdump # no user configurable options below here SRC_DIR := $(MODULES) BUILD_DIR := $(addprefix $(BUILD_BASE)/,$(MODULES)) SDK_LIBDIR := $(addprefix $(SDK_BASE)/,$(SDK_LIBDIR)) SDK_INCDIR := $(addprefix -I$(SDK_BASE)/,$(SDK_INCDIR)) SRC := $(foreach sdir,$(SRC_DIR),$(wildcard $(sdir)/*.c)) OBJ := $(patsubst %.c,$(BUILD_BASE)/%.o,$(SRC)) # $(BUILD_BASE)/cachain_img.o LIBS := $(addprefix -l,$(LIBS)) APP_AR := $(addprefix $(BUILD_BASE)/,$(TARGET)_app.a) TARGET_OUT := $(addprefix $(BUILD_BASE)/,$(TARGET).out) LD_SCRIPT := $(addprefix -T$(SDK_BASE)/$(SDK_LDDIR)/,$(LD_SCRIPT)) INCDIR := $(addprefix -I,$(SRC_DIR)) EXTRA_INCDIR := $(addprefix -I,$(EXTRA_INCDIR)) MODULE_INCDIR := $(addsuffix /include,$(INCDIR)) V ?= $(VERBOSE) ifeq ("$(V)","1") Q := vecho := @true else Q := @ vecho := @echo endif vpath %.c $(SRC_DIR) define compile-objects $1/%.o: %.c $(vecho) "CC $$<" $(Q) $(CC) $(INCDIR) $(MODULE_INCDIR) $(EXTRA_INCDIR) $(SDK_INCDIR) $(CFLAGS) -c $$< -o $$@ endef .PHONY: all checkdirs clean all: checkdirs $(TARGET_OUT) $(TARGET_OUT): $(APP_AR) $(vecho) "LD $@" $(Q) $(LD) -L$(SDK_LIBDIR) $(LD_SCRIPT) $(LDFLAGS) -Wl,--start-group $(LIBS) $(APP_AR) -Wl,--end-group -o $@ $(vecho) "Run objcopy, please wait..." $(Q) $(OBJCOPY) --only-section .text -O binary $@ eagle.app.v6.text.bin $(Q) $(OBJCOPY) --only-section .data -O binary $@ eagle.app.v6.data.bin $(Q) $(OBJCOPY) --only-section .rodata -O binary $@ eagle.app.v6.rodata.bin $(Q) $(OBJCOPY) --only-section .irom0.text -O binary $@ eagle.app.v6.irom0text.bin $(vecho) "objcopy done" $(vecho) "Run gen_appbin.py" ifeq ($(app), 0) $(Q) $(SDK_TOOLS)/gen_appbin.py $@ 0 $(mode) $(freqdiv) $(size) $(Q) mv eagle.app.flash.bin firmware/eagle.flash.bin $(Q) mv eagle.app.v6.irom0text.bin firmware/eagle.irom0text.bin $(Q) rm eagle.app.v6.* $(vecho) "No boot needed." $(vecho) "Generate eagle.flash.bin and eagle.irom0text.bin successully in folder firmware." $(vecho) "eagle.flash.bin-------->0x00000" $(vecho) "eagle.irom0text.bin---->0x40000" else ifeq ($(boot), new) $(Q) $(SDK_TOOLS)/gen_appbin.py $@ 2 $(mode) $(freqdiv) $(size) $(vecho) "Support boot_v1.2 and +" else $(Q) $(SDK_TOOLS)/gen_appbin.py $@ 1 $(mode) $(freqdiv) $(size) $(vecho) "Support boot_v1.1 and +" endif $(Q) mv eagle.app.flash.bin firmware/upgrade/$(BIN_NAME).bin $(Q) rm eagle.app.v6.* $(vecho) "Generate $(BIN_NAME).bin successully in folder firmware/upgrade." $(vecho) "boot_v1.x.bin------->0x00000" $(vecho) "$(BIN_NAME).bin--->$(addr)" endif $(vecho) "Done" $(APP_AR): $(OBJ) $(vecho) "AR $@" $(Q) $(AR) cru $@ $^ checkdirs: $(BUILD_DIR) $(FW_BASE) $(BUILD_DIR): $(Q) mkdir -p $@ firmware: $(Q) mkdir -p $@ $(Q) mkdir -p $@/upgrade flashonefile: all $(OBJCOPY) --only-section .text -O binary $(TARGET_OUT) eagle.app.v6.text.bin $(OBJCOPY) --only-section .data -O binary $(TARGET_OUT) eagle.app.v6.data.bin $(OBJCOPY) --only-section .rodata -O binary $(TARGET_OUT) eagle.app.v6.rodata.bin $(OBJCOPY) --only-section .irom0.text -O binary $(TARGET_OUT) eagle.app.v6.irom0text.bin $(SDK_TOOLS)/gen_appbin_old.exe $(TARGET_OUT) v6 $(SDK_TOOLS)/gen_flashbin.exe eagle.app.v6.flash.bin eagle.app.v6.irom0text.bin 0x40000 rm -f eagle.app.v6.data.bin rm -f eagle.app.v6.flash.bin rm -f eagle.app.v6.irom0text.bin rm -f eagle.app.v6.rodata.bin rm -f eagle.app.v6.text.bin rm -f eagle.app.sym mv eagle.app.flash.bin firmware/ $(vecho) "No boot needed." $(vecho) "Generate eagle.app.flash.bin successully in folder firmware." $(vecho) "eagle.app.flash.bin-------->0x00000" $(ESPTOOL) -p $(ESPPORT) -b 256000 write_flash 0x00000 firmware/eagle.app.flash.bin flashboot: all flashinit ifeq ($(boot), new) $(vecho) "Flash boot_v1.2 and +" $(ESPTOOL) -p $(ESPPORT) -b 256000 write_flash 0x00000 $(SDK_BASE)/bin/boot_v1.2.bin endif ifeq ($(boot), old) $(vecho) "Flash boot_v1.1 and +" $(ESPTOOL) -p $(ESPPORT) -b 256000 write_flash 0x00000 $(SDK_BASE)/bin/boot_v1.1.bin endif ifeq ($(boot), none) $(vecho) "No boot needed." endif flash: all ifeq ($(app), 0) $(ESPTOOL) -p $(ESPPORT) -b 256000 write_flash 0x00000 firmware/eagle.flash.bin 0x40000 firmware/eagle.irom0text.bin else ifeq ($(boot), none) $(ESPTOOL) -p $(ESPPORT) -b 256000 write_flash 0x00000 firmware/eagle.flash.bin 0x40000 firmware/eagle.irom0text.bin else $(ESPTOOL) -p $(ESPPORT) -b 256000 write_flash $(addr) firmware/upgrade/$(BIN_NAME).bin endif endif flashinit: $(vecho) "Flash init data default and blank data." $(ESPTOOL) -p $(ESPPORT) write_flash 0x7c000 $(SDK_BASE)/bin/esp_init_data_default.bin 0x7e000 $(SDK_BASE)/bin/blank.bin rebuild: clean all $(BUILD_BASE)/cachain_img.o: bin/esp_ca_cert.bin $(Q) cd build; $(OBJCP) -I binary -O elf32-xtensa-le -B xtensa --rename-section .data=.cachain \ ../bin/esp_ca_cert.bin cachain_img.o; cd .. clean: $(Q) rm -f $(APP_AR) $(Q) rm -f $(TARGET_OUT) $(Q) rm -rf $(BUILD_DIR) $(Q) rm -rf $(BUILD_BASE) $(Q) rm -rf $(FW_BASE) $(foreach bdir,$(BUILD_DIR),$(eval $(call compile-objects,$(bdir)))) ssltest/README.txt0000664000175000017500000000256712564331642012743 0ustar alexalexBuilding: export DATA_TO_POST="var1=val1&var2=val2" export URL_TO_POST="https://ssl.espressif.com/test/path" export WIFI_SSID="wifinetwork" export WIFI_PASS="wifipass" ./comp.sh Certificates: CA guide: https://jamielinux.com/docs/openssl-certificate-authority/introduction.html 2048 bits and disable certs v3 extensions. Generate bin/esp_ca_cert.bin - as per documentation, containing Root CA and Intermediate CA keys Flashing - Note: I'm using 2MB modules in 1024/1024 split ./esptool.py --port /dev/ttyUSB1 --baud 460800 write_flash --flash_size 16m-c1 \ 0x00000 "$SDK_BASE/bin/boot_v1.4(b1).bin" \ 0x01000 firmware/upgrade/user1.1024.new.bin \ 0x6b000 bin/esp_ca_cert.bin \ 0x0fc000 "$SDK_BASE/bin/blank.bin" \ 0x1fe000 "$SDK_BASE/bin/blank.bin" \ 0x1FC000 "$SDK_BASE/bin/esp_init_data_default.bin" Server Side: apache config ssl options: SSLEngine on SSLCACertificateFile /path/to/certs/ca-chain.cert.pem SSLCertificateFile /path/to/certs/test.com.cert.pem SSLCertificateKeyFile /path/to/certs/test.com.key.pem SSLVerifyClient none SSLHonorCipherOrder On SSLCipherSuite ECDHE-RSA-AES128-GCM-SHA256:ECDHE-RSA-RC4-SHA:ECDHE-RSA-AES128-SHA:AES128-GCM-SHA256:RC4:HIGH:!MD5:!aNULL:!EDH:!CAMELLIA; Install as default SSL host Verify with : openssl s_client -connect server.ip:443 You should see the generated certificate is returned and there is an option to renegotiate. ssltest/include/0000775000175000017500000000000012564300243012647 5ustar alexalexssltest/include/espmissingincludes.h0000664000175000017500000000500712563354464016747 0ustar alexalex#ifndef ESPMISSINGINCLUDES_H #define ESPMISSINGINCLUDES_H #include // #include //Missing function prototypes in include folders. Gcc will warn on these if we don't define 'em anywhere. //MOST OF THESE ARE GUESSED! but they seem to swork and shut up the compiler. typedef struct espconn espconn; void ets_intr_lock(); void ets_intr_unlock(); #ifdef USESSL bool espconn_secure_set_size(uint8 level, uint16 size); #endif int atoi(const char *nptr); void ets_install_putc1(void *routine); void ets_isr_attach(int intr, void *handler, void *arg); void ets_isr_mask(unsigned intr); void ets_isr_unmask(unsigned intr); int ets_memcmp(const void *s1, const void *s2, size_t n); void *ets_memcpy(void *dest, const void *src, size_t n); void *ets_memset(void *s, int c, size_t n); int ets_sprintf(char *str, const char *format, ...) __attribute__ ((format (printf, 2, 3))); int ets_str2macaddr(void *, void *); int ets_strcmp(const char *s1, const char *s2); char *ets_strcpy(char *dest, const char *src); size_t ets_strlen(const char *s); int ets_strncmp(const char *s1, const char *s2, int len); char *ets_strncpy(char *dest, const char *src, size_t n); char *ets_strstr(const char *haystack, const char *needle); void ets_timer_arm_new(ETSTimer *a, int b, int c, int isMstimer); void ets_timer_disarm(ETSTimer *a); void ets_timer_setfn(ETSTimer *t, ETSTimerFunc *fn, void *parg); void ets_update_cpu_frequency(int freqmhz); int os_printf(const char *format, ...) __attribute__ ((format (printf, 1, 2))); int os_snprintf(char *str, size_t size, const char *format, ...) __attribute__ ((format (printf, 3, 4))); int os_printf_plus(const char *format, ...) __attribute__ ((format (printf, 1, 2))); void pvPortFree(void *ptr); void *pvPortMalloc(size_t xWantedSize); void *pvPortZalloc(size_t); void uart_div_modify(int no, unsigned int freq); void vPortFree(void *ptr); void *vPortMalloc(size_t xWantedSize); uint8 wifi_get_opmode(void); uint32 system_get_time(); //int os_random(); int rand(void); void ets_bzero(void *s, size_t n); void ets_delay_us(int ms); #define USE_OPTIMIZE_STRCMP #ifdef USE_OPTIMIZE_STRCMP #define z_strncmp(a,b,l) ({ \ static const char flash_str[] ICACHE_RODATA_ATTR = b; \ os_strncmp(a, flash_str, l); \ }) #define z_strcmp(a,b) ({ \ static const char flash_str[] ICACHE_RODATA_ATTR = b; \ os_strcmp(a, flash_str); \ }) #else #define z_strncmp os_strncmp #define z_strcmp os_strcmp #endif // #define HAVE_WDT_FEED #endif ssltest/include/user_config.h0000664000175000017500000000010012467374662015334 0ustar alexalex#ifndef __USER_CONFIG_H__ #define __USER_CONFIG_H__ #endif ssltest/include/uart_hw.h0000664000175000017500000001523212564300243014474 0ustar alexalex//Generated at 2012-07-03 18:44:06 /* * Copyright (c) 2010 - 2011 Espressif System * */ #ifndef UART_REGISTER_H_INCLUDED #define UART_REGISTER_H_INCLUDED #define REG_UART_BASE( i ) (0x60000000+(i)*0xf00) //version value:32'h062000 #define UART_FIFO( i ) (REG_UART_BASE( i ) + 0x0) #define UART_RXFIFO_RD_BYTE 0x000000FF #define UART_RXFIFO_RD_BYTE_S 0 #define UART_INT_RAW( i ) (REG_UART_BASE( i ) + 0x4) #define UART_RXFIFO_TOUT_INT_RAW (BIT(8)) #define UART_BRK_DET_INT_RAW (BIT(7)) #define UART_CTS_CHG_INT_RAW (BIT(6)) #define UART_DSR_CHG_INT_RAW (BIT(5)) #define UART_RXFIFO_OVF_INT_RAW (BIT(4)) #define UART_FRM_ERR_INT_RAW (BIT(3)) #define UART_PARITY_ERR_INT_RAW (BIT(2)) #define UART_TXFIFO_EMPTY_INT_RAW (BIT(1)) #define UART_RXFIFO_FULL_INT_RAW (BIT(0)) #define UART_INT_ST( i ) (REG_UART_BASE( i ) + 0x8) #define UART_RXFIFO_TOUT_INT_ST (BIT(8)) #define UART_BRK_DET_INT_ST (BIT(7)) #define UART_CTS_CHG_INT_ST (BIT(6)) #define UART_DSR_CHG_INT_ST (BIT(5)) #define UART_RXFIFO_OVF_INT_ST (BIT(4)) #define UART_FRM_ERR_INT_ST (BIT(3)) #define UART_PARITY_ERR_INT_ST (BIT(2)) #define UART_TXFIFO_EMPTY_INT_ST (BIT(1)) #define UART_RXFIFO_FULL_INT_ST (BIT(0)) #define UART_INT_ENA( i ) (REG_UART_BASE( i ) + 0xC) #define UART_RXFIFO_TOUT_INT_ENA (BIT(8)) #define UART_BRK_DET_INT_ENA (BIT(7)) #define UART_CTS_CHG_INT_ENA (BIT(6)) #define UART_DSR_CHG_INT_ENA (BIT(5)) #define UART_RXFIFO_OVF_INT_ENA (BIT(4)) #define UART_FRM_ERR_INT_ENA (BIT(3)) #define UART_PARITY_ERR_INT_ENA (BIT(2)) #define UART_TXFIFO_EMPTY_INT_ENA (BIT(1)) #define UART_RXFIFO_FULL_INT_ENA (BIT(0)) #define UART_INT_CLR( i ) (REG_UART_BASE( i ) + 0x10) #define UART_RXFIFO_TOUT_INT_CLR (BIT(8)) #define UART_BRK_DET_INT_CLR (BIT(7)) #define UART_CTS_CHG_INT_CLR (BIT(6)) #define UART_DSR_CHG_INT_CLR (BIT(5)) #define UART_RXFIFO_OVF_INT_CLR (BIT(4)) #define UART_FRM_ERR_INT_CLR (BIT(3)) #define UART_PARITY_ERR_INT_CLR (BIT(2)) #define UART_TXFIFO_EMPTY_INT_CLR (BIT(1)) #define UART_RXFIFO_FULL_INT_CLR (BIT(0)) #define UART_CLKDIV( i ) (REG_UART_BASE( i ) + 0x14) #define UART_CLKDIV_CNT 0x000FFFFF #define UART_CLKDIV_S 0 #define UART_AUTOBAUD( i ) (REG_UART_BASE( i ) + 0x18) #define UART_GLITCH_FILT 0x000000FF #define UART_GLITCH_FILT_S 8 #define UART_AUTOBAUD_EN (BIT(0)) #define UART_STATUS( i ) (REG_UART_BASE( i ) + 0x1C) #define UART_TXD (BIT(31)) #define UART_RTSN (BIT(30)) #define UART_DTRN (BIT(29)) #define UART_TXFIFO_CNT 0x000000FF #define UART_TXFIFO_CNT_S 16 #define UART_RXD (BIT(15)) #define UART_CTSN (BIT(14)) #define UART_DSRN (BIT(13)) #define UART_RXFIFO_CNT 0x000000FF #define UART_RXFIFO_CNT_S 0 #define UART_CONF0( i ) (REG_UART_BASE( i ) + 0x20) #define UART_TXFIFO_RST (BIT(18)) #define UART_RXFIFO_RST (BIT(17)) #define UART_IRDA_EN (BIT(16)) #define UART_TX_FLOW_EN (BIT(15)) #define UART_LOOPBACK (BIT(14)) #define UART_IRDA_RX_INV (BIT(13)) #define UART_IRDA_TX_INV (BIT(12)) #define UART_IRDA_WCTL (BIT(11)) #define UART_IRDA_TX_EN (BIT(10)) #define UART_IRDA_DPLX (BIT(9)) #define UART_TXD_BRK (BIT(8)) #define UART_SW_DTR (BIT(7)) #define UART_SW_RTS (BIT(6)) #define UART_STOP_BIT_NUM 0x00000003 #define UART_STOP_BIT_NUM_S 4 #define UART_BIT_NUM 0x00000003 #define UART_BIT_NUM_S 2 #define UART_PARITY_EN (BIT(1)) #define UART_PARITY (BIT(0)) #define UART_CONF1( i ) (REG_UART_BASE( i ) + 0x24) #define UART_RX_TOUT_EN (BIT(31)) #define UART_RX_TOUT_THRHD 0x0000007F #define UART_RX_TOUT_THRHD_S 24 #define UART_RX_FLOW_EN (BIT(23)) #define UART_RX_FLOW_THRHD 0x0000007F #define UART_RX_FLOW_THRHD_S 16 #define UART_TXFIFO_EMPTY_THRHD 0x0000007F #define UART_TXFIFO_EMPTY_THRHD_S 8 #define UART_RXFIFO_FULL_THRHD 0x0000007F #define UART_RXFIFO_FULL_THRHD_S 0 #define UART_LOWPULSE( i ) (REG_UART_BASE( i ) + 0x28) #define UART_LOWPULSE_MIN_CNT 0x000FFFFF #define UART_LOWPULSE_MIN_CNT_S 0 #define UART_HIGHPULSE( i ) (REG_UART_BASE( i ) + 0x2C) #define UART_HIGHPULSE_MIN_CNT 0x000FFFFF #define UART_HIGHPULSE_MIN_CNT_S 0 #define UART_PULSE_NUM( i ) (REG_UART_BASE( i ) + 0x30) #define UART_PULSE_NUM_CNT 0x0003FF #define UART_PULSE_NUM_CNT_S 0 #define UART_DATE( i ) (REG_UART_BASE( i ) + 0x78) #define UART_ID( i ) (REG_UART_BASE( i ) + 0x7C) #define RX_BUFF_SIZE 256 #define TX_BUFF_SIZE 100 #define UART0 0 #define UART1 1 //calc bit 0..5 for UART_CONF0 register #define CALC_UARTMODE(data_bits,parity,stop_bits) \ (((parity == NONE_BITS) ? 0x0 : (UART_PARITY_EN | (parity & UART_PARITY))) | \ ((stop_bits & UART_STOP_BIT_NUM) << UART_STOP_BIT_NUM_S) | \ ((data_bits & UART_BIT_NUM) << UART_BIT_NUM_S)) typedef enum { FIVE_BITS = 0x0, SIX_BITS = 0x1, SEVEN_BITS = 0x2, EIGHT_BITS = 0x3 } UartBitsNum4Char; typedef enum { ONE_STOP_BIT = 0, ONE_HALF_STOP_BIT = BIT2, TWO_STOP_BIT = BIT2 } UartStopBitsNum; typedef enum { NONE_BITS = 0, ODD_BITS = 0, EVEN_BITS = BIT4 } UartParityMode; typedef enum { STICK_PARITY_DIS = 0, STICK_PARITY_EN = BIT3 | BIT5 } UartExistParity; typedef enum { BIT_RATE_9600 = 9600, BIT_RATE_19200 = 19200, BIT_RATE_38400 = 38400, BIT_RATE_57600 = 57600, BIT_RATE_74880 = 74880, BIT_RATE_115200 = 115200, BIT_RATE_230400 = 230400, BIT_RATE_460800 = 460800, BIT_RATE_921600 = 921600 } UartBautRate; typedef enum { NONE_CTRL, HARDWARE_CTRL, XON_XOFF_CTRL } UartFlowCtrl; typedef enum { EMPTY, UNDER_WRITE, WRITE_OVER } RcvMsgBuffState; typedef struct { uint32 RcvBuffSize; uint8 *pRcvMsgBuff; uint8 *pWritePos; uint8 *pReadPos; uint8 TrigLvl; //JLU: may need to pad RcvMsgBuffState BuffState; } RcvMsgBuff; typedef struct { uint32 TrxBuffSize; uint8 *pTrxBuff; } TrxMsgBuff; typedef enum { BAUD_RATE_DET, WAIT_SYNC_FRM, SRCH_MSG_HEAD, RCV_MSG_BODY, RCV_ESC_CHAR, } RcvMsgState; typedef struct { UartBautRate baut_rate; UartBitsNum4Char data_bits; UartExistParity exist_parity; UartParityMode parity; UartStopBitsNum stop_bits; UartFlowCtrl flow_ctrl; RcvMsgBuff rcv_buff; TrxMsgBuff trx_buff; RcvMsgState rcv_state; int received; int buff_uart_no; //indicate which uart use tx/rx buffer } UartDevice; #endif // UART_REGISTER_H_INCLUDED ssltest/esptool.py0000775000175000017500000006066012564304265013306 0ustar alexalex#!/usr/bin/env python # # ESP8266 ROM Bootloader Utility # https://github.com/themadinventor/esptool # # Copyright (C) 2014 Fredrik Ahlberg # # This program is free software; you can redistribute it and/or modify it under # the terms of the GNU General Public License as published by the Free Software # Foundation; either version 2 of the License, or (at your option) any later version. # # This program is distributed in the hope that it will be useful, but WITHOUT # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS # FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. # # You should have received a copy of the GNU General Public License along with # this program; if not, write to the Free Software Foundation, Inc., 51 Franklin # Street, Fifth Floor, Boston, MA 02110-1301 USA. import sys import struct import serial import math import time import argparse import os import subprocess import tempfile class ESPROM: # These are the currently known commands supported by the ROM ESP_FLASH_BEGIN = 0x02 ESP_FLASH_DATA = 0x03 ESP_FLASH_END = 0x04 ESP_MEM_BEGIN = 0x05 ESP_MEM_END = 0x06 ESP_MEM_DATA = 0x07 ESP_SYNC = 0x08 ESP_WRITE_REG = 0x09 ESP_READ_REG = 0x0a # Maximum block sized for RAM and Flash writes, respectively. ESP_RAM_BLOCK = 0x1800 ESP_FLASH_BLOCK = 0x400 # Default baudrate. The ROM auto-bauds, so we can use more or less whatever we want. ESP_ROM_BAUD = 115200 # First byte of the application image ESP_IMAGE_MAGIC = 0xe9 # Initial state for the checksum routine ESP_CHECKSUM_MAGIC = 0xef # OTP ROM addresses ESP_OTP_MAC0 = 0x3ff00050 ESP_OTP_MAC1 = 0x3ff00054 # Sflash stub: an assembly routine to read from spi flash and send to host SFLASH_STUB = "\x80\x3c\x00\x40\x1c\x4b\x00\x40\x21\x11\x00\x40\x00\x80" \ "\xfe\x3f\xc1\xfb\xff\xd1\xf8\xff\x2d\x0d\x31\xfd\xff\x41\xf7\xff\x4a" \ "\xdd\x51\xf9\xff\xc0\x05\x00\x21\xf9\xff\x31\xf3\xff\x41\xf5\xff\xc0" \ "\x04\x00\x0b\xcc\x56\xec\xfd\x06\xff\xff\x00\x00" def __init__(self, port = 0, baud = ESP_ROM_BAUD): self._port = serial.Serial(port, baud) """ Read bytes from the serial port while performing SLIP unescaping """ def read(self, length = 1): b = '' while len(b) < length: c = self._port.read(1) if c == '\xdb': c = self._port.read(1) if c == '\xdc': b = b + '\xc0' elif c == '\xdd': b = b + '\xdb' else: raise Exception('Invalid SLIP escape') else: b = b + c return b """ Write bytes to the serial port while performing SLIP escaping """ def write(self, packet): buf = '\xc0'+(packet.replace('\xdb','\xdb\xdd').replace('\xc0','\xdb\xdc'))+'\xc0' self._port.write(buf) """ Calculate checksum of a blob, as it is defined by the ROM """ @staticmethod def checksum(data, state = ESP_CHECKSUM_MAGIC): for b in data: state ^= ord(b) return state """ Send a request and read the response """ def command(self, op = None, data = None, chk = 0): if op: # Construct and send request pkt = struct.pack('> 16) & 0xff) == 0: oui = (0x18, 0xfe, 0x34) elif ((mac1 >> 16) & 0xff) == 1: oui = (0xac, 0xd0, 0x74) else: raise Exception("Unknown OUI") return oui + ((mac1 >> 8) & 0xff, mac1 & 0xff, (mac0 >> 24) & 0xff) """ Read SPI flash manufacturer and device id """ def flash_id(self): self.flash_begin(0, 0) self.write_reg(0x60000240, 0x0, 0xffffffff) self.write_reg(0x60000200, 0x10000000, 0xffffffff) flash_id = esp.read_reg(0x60000240) self.flash_finish(False) return flash_id """ Read SPI flash """ def flash_read(self, offset, size, count = 1): # Create a custom stub stub = struct.pack(' 16: raise Exception('Invalid firmware image') for i in xrange(segments): (offset, size) = struct.unpack(' 0x40200000 or offset < 0x3ffe0000 or size > 65536: raise Exception('Suspicious segment %x,%d' % (offset, size)) self.segments.append((offset, size, f.read(size))) # Skip the padding. The checksum is stored in the last byte so that the # file is a multiple of 16 bytes. align = 15-(f.tell() % 16) f.seek(align, 1) self.checksum = ord(f.read(1)) def add_segment(self, addr, data): # Data should be aligned on word boundary l = len(data) if l % 4: data += b"\x00" * (4 - l % 4) self.segments.append((addr, len(data), data)) def save(self, filename): f = file(filename, 'wb') f.write(struct.pack(' 0: esp.mem_block(data[0:esp.ESP_RAM_BLOCK], seq) data = data[esp.ESP_RAM_BLOCK:] seq += 1 print 'done!' print 'All segments done, executing at %08x' % image.entrypoint esp.mem_finish(image.entrypoint) elif args.operation == 'read_mem': print '0x%08x = 0x%08x' % (args.address, esp.read_reg(args.address)) elif args.operation == 'write_mem': esp.write_reg(args.address, args.value, args.mask, 0) print 'Wrote %08x, mask %08x to %08x' % (args.value, args.mask, args.address) elif args.operation == 'dump_mem': f = file(args.filename, 'wb') for i in xrange(args.size/4): d = esp.read_reg(args.address+(i*4)) f.write(struct.pack(' 0: print '\rWriting at 0x%08x... (%d %%)' % (address + seq*esp.ESP_FLASH_BLOCK, 100*(seq+1)/blocks), sys.stdout.flush() block = image[0:esp.ESP_FLASH_BLOCK] # Fix sflash config data if address == 0 and seq == 0 and block[0] == '\xe9': block = block[0:2] + flash_info + block[4:] # Pad the last block block = block + '\xff' * (esp.ESP_FLASH_BLOCK-len(block)) esp.flash_block(block, seq) image = image[esp.ESP_FLASH_BLOCK:] seq += 1 print print '\nLeaving...' esp.flash_finish(False) elif args.operation == 'run': esp.run() elif args.operation == 'image_info': image = ESPFirmwareImage(args.filename) print ('Entry point: %08x' % image.entrypoint) if image.entrypoint != 0 else 'Entry point not set' print '%d segments' % len(image.segments) print checksum = ESPROM.ESP_CHECKSUM_MAGIC for (idx, (offset, size, data)) in enumerate(image.segments): print 'Segment %d: %5d bytes at %08x' % (idx+1, size, offset) checksum = ESPROM.checksum(data, checksum) print print 'Checksum: %02x (%s)' % (image.checksum, 'valid' if image.checksum == checksum else 'invalid!') elif args.operation == 'make_image': image = ESPFirmwareImage() if len(args.segfile) == 0: raise Exception('No segments specified') if len(args.segfile) != len(args.segaddr): raise Exception('Number of specified files does not match number of specified addresses') for (seg, addr) in zip(args.segfile, args.segaddr): data = file(seg, 'rb').read() image.add_segment(addr, data) image.entrypoint = args.entrypoint image.save(args.output) elif args.operation == 'elf2image': if args.output is None: args.output = args.input + '-' e = ELFFile(args.input) image = ESPFirmwareImage() image.entrypoint = e.get_symbol_addr("call_user_start") for section, start in ((".text", "_text_start"), (".data", "_data_start"), (".rodata", "_rodata_start")): data = e.load_section(section) image.add_segment(e.get_symbol_addr(start), data) image.flash_mode = {'qio':0, 'qout':1, 'dio':2, 'dout': 3}[args.flash_mode] image.flash_size_freq = {'4m':0x00, '2m':0x10, '8m':0x20, '16m':0x30, '32m':0x40, '16m-c1': 0x50, '32m-c1':0x60, '32m-c2':0x70}[args.flash_size] image.flash_size_freq += {'40m':0, '26m':1, '20m':2, '80m': 0xf}[args.flash_freq] image.save(args.output + "0x00000.bin") data = e.load_section(".irom0.text") off = e.get_symbol_addr("_irom0_text_start") - 0x40200000 assert off >= 0 f = open(args.output + "0x%05x.bin" % off, "wb") f.write(data) f.close() elif args.operation == 'read_mac': mac = esp.read_mac() print 'MAC: %s' % ':'.join(map(lambda x: '%02x'%x, mac)) elif args.operation == 'flash_id': flash_id = esp.flash_id() print 'Manufacturer: %02x' % (flash_id & 0xff) print 'Device: %02x%02x' % ((flash_id >> 8) & 0xff, (flash_id >> 16) & 0xff) elif args.operation == 'read_flash': print 'Please wait...' file(args.filename, 'wb').write(esp.flash_read(args.address, 1024, int(math.ceil(args.size / 1024.)))[:args.size]) elif args.operation == 'erase_flash': esp.flash_erase() ssltest/esphttpclient/0000775000175000017500000000000012564331677014131 5ustar alexalexssltest/esphttpclient/httpclient.c0000664000175000017500000002572712564323771016464 0ustar alexalex/* * ---------------------------------------------------------------------------- * "THE BEER-WARE LICENSE" (Revision 42): * Martin d'Allens wrote this file. As long as you retain * this notice you can do whatever you want with this stuff. If we meet some day, * and you think this stuff is worth it, you can buy me a beer in return. * ---------------------------------------------------------------------------- */ // FIXME: sprintf->snprintf everywhere. // FIXME: support null characters in responses. #include "osapi.h" #include "user_interface.h" #include "espmissingincludes.h" #include "espconn.h" #include "mem.h" #include "httpclient.h" #include "user_main.h" #ifndef SSLBUF #define SSLBUF 5120 #endif // Debug output. #if 1 #define PRINTF(...) os_printf(__VA_ARGS__) #else #define PRINTF(...) #endif // Internal state. typedef struct { char * path; int port; char * post_data; char * headers; char * hostname; char * buffer; int buffer_size; bool secure; int done; http_callback user_callback; } request_args; static char * esp_strdup(const char * str) { if (str == NULL) { return NULL; } char * new_str = (char *)os_malloc(os_strlen(str) + 1); // 1 for null character if (new_str == NULL) { os_printf("esp_strdup: malloc error"); return NULL; } os_strcpy(new_str, str); return new_str; } static void ICACHE_FLASH_ATTR receive_callback(void * arg, char * buf, unsigned short len) { struct espconn * conn = (struct espconn *)arg; request_args * req = (request_args *)conn->reverse; if (req->done) { return; } if (req->buffer == NULL) { os_printf("ouch no buff\n"); return; } // Let's do the equivalent of a realloc(). const int new_size = req->buffer_size + len; char * new_buffer; if (new_size > BUFFER_SIZE_MAX || NULL == (new_buffer = (char *)os_malloc(new_size))) { os_printf("Response too long (%d)\n", new_size); req->buffer[0] = '\0'; // Discard the buffer to avoid using an incomplete response. if (req->secure) { // espconn_secure_disconnect(conn); send_user_sig(SIG_CONN_SECURE_CLOSE, conn); } else { // espconn_disconnect(conn); send_user_sig(SIG_CONN_CLOSE, conn); } return; // The disconnect callback will be called. } os_memcpy(new_buffer, req->buffer, req->buffer_size); os_memcpy(new_buffer + req->buffer_size - 1 /*overwrite the null character*/, buf, len); // Append new data. new_buffer[new_size - 1] = '\0'; // Make sure there is an end of string. // os_printf("recv:%s\n", new_buffer); os_free(req->buffer); req->buffer = new_buffer; req->buffer_size = new_size; char *cp = os_strstr(req->buffer,"Content-Length: "); if (cp) { cp += strlen("Content-Lenght: "); if (cp > (req->buffer + req->buffer_size)) { return; } int clen = atoi(cp); // os_printf("Clen=%d\n", clen); if (clen > 0) { cp = os_strstr(req->buffer,"\r\n\r\n"); if (cp) { // os_printf("eoh\n"); cp += 4; if (cp < (req->buffer + req->buffer_size)) { int hl = os_strlen(cp); // os_printf("data\n"); if (hl >= clen) { if (req->secure) { // espconn_secure_disconnect(conn); send_user_sig(SIG_CONN_SECURE_CLOSE, conn); } else { // espconn_disconnect(conn); send_user_sig(SIG_CONN_CLOSE, conn); } os_printf("done\n"); req->done = 1; } } } } } } static void ICACHE_FLASH_ATTR sent_callback(void * arg) { struct espconn * conn = (struct espconn *)arg; request_args * req = (request_args *)conn->reverse; if (req->post_data == NULL) { PRINTF("All sent\n"); } else { // The headers were sent, now send the contents. PRINTF("Sending request body\n"); if (req->secure) espconn_secure_sent(conn, (uint8_t *)req->post_data, strlen(req->post_data)); else espconn_sent(conn, (uint8_t *)req->post_data, strlen(req->post_data)); os_free(req->post_data); req->post_data = NULL; } } static void ICACHE_FLASH_ATTR connect_callback(void * arg) { PRINTF("Connected\n"); struct espconn * conn = (struct espconn *)arg; request_args * req = (request_args *)conn->reverse; espconn_regist_recvcb(conn, receive_callback); espconn_regist_sentcb(conn, sent_callback); const char * method = "GET"; char post_headers[32] = ""; if (req->post_data != NULL) { // If there is data this is a POST request. method = "POST"; os_sprintf(post_headers, "Content-Length: %d\r\n", strlen(req->post_data)); } char buf[89 + strlen(method) + strlen(req->path) + strlen(req->hostname) + strlen(req->headers) + strlen(post_headers)]; int len = os_sprintf(buf, "%s %s HTTP/1.1\r\n" "Host: %s:%d\r\n" "Connection: close\r\n" "User-Agent: okalfred/u1/1\r\n" "%s" "%s" "\r\n", method, req->path, req->hostname, req->port, req->headers, post_headers); if (req->secure) espconn_secure_sent(conn, (uint8_t *)buf, len); else espconn_sent(conn, (uint8_t *)buf, len); os_free(req->headers); req->headers = NULL; PRINTF("Sending request header\n"); } static void ICACHE_FLASH_ATTR disconnect_callback(void * arg) { PRINTF("Disconnected\n"); struct espconn *conn = (struct espconn *)arg; if(conn == NULL) { return; } if(conn->proto.tcp != NULL) { os_free(conn->proto.tcp); } if(conn->reverse != NULL) { request_args * req = (request_args *)conn->reverse; int http_status = -1; char *body = ""; if (req->buffer == NULL) { os_printf("Buffer shouldn't be NULL\n"); } else if (req->buffer[0] != '\0') { // FIXME: make sure this is not a partial response, using the Content-Length header. const char * version = "HTTP/1.1 "; if (os_strncmp(req->buffer, version, strlen(version)) != 0) { os_printf("Invalid version in %s\n", req->buffer); } else { http_status = atoi(req->buffer + strlen(version)); body = (char *)os_strstr(req->buffer, "\r\n\r\n") + 4; } } if (req->user_callback != NULL) { // Callback is optional. req->user_callback(body, http_status, req->buffer); } os_free(req->buffer); os_free(req->hostname); os_free(req->path); os_free(req); } os_free(conn); } static void ICACHE_FLASH_ATTR error_callback(void *arg, sint8 errType) { PRINTF("Disconnected with error\n"); disconnect_callback(arg); } static void ICACHE_FLASH_ATTR dns_callback(const char * hostname, ip_addr_t * addr, void * arg) { request_args * req = (request_args *)arg; int rc; if (addr == NULL) { os_printf("DNS failed for %s\n", hostname); if (req->user_callback != NULL) { req->user_callback("", -1, ""); } os_free(req); } else { PRINTF("DNS found %s " IPSTR "\n", hostname, IP2STR(addr)); struct espconn * conn = (struct espconn *)os_malloc(sizeof(struct espconn)); conn->type = ESPCONN_TCP; conn->state = ESPCONN_NONE; conn->proto.tcp = (esp_tcp *)os_malloc(sizeof(esp_tcp)); conn->proto.tcp->local_port = espconn_port(); conn->proto.tcp->remote_port = req->port; conn->reverse = req; os_memcpy(conn->proto.tcp->remote_ip, addr, 4); espconn_regist_connectcb(conn, connect_callback); espconn_regist_disconcb(conn, disconnect_callback); espconn_regist_reconcb(conn, error_callback); // espconn_set_opt(conn, ESPCONN_NODELAY); if (req->secure) { static int sslbufset = 0; if (!sslbufset) { espconn_secure_set_size(ESPCONN_SERVER,2); // set SSL buffer size espconn_secure_set_size(ESPCONN_CLIENT,SSLBUF); // set SSL buffer size sslbufset = 1; } rc = espconn_secure_connect(conn); if (rc != 0) { os_printf("espconn_secure_connect:%d\n",rc); } } else { rc = espconn_connect(conn); } if (rc != ESPCONN_OK) { os_printf("connect failed\n"); if (req->user_callback != NULL) { req->user_callback(NULL, 500, req->buffer); } os_free(req->buffer); os_free(req->hostname); os_free(req->path); os_free(req); } } } void ICACHE_FLASH_ATTR http_raw_request(const char * hostname, int port, bool secure, const char * path, const char * post_data, const char * headers, http_callback user_callback) { PRINTF("DNS request\n"); request_args * req = (request_args *)os_malloc(sizeof(request_args)); req->hostname = esp_strdup(hostname); req->path = esp_strdup(path); req->port = port; req->secure = secure; req->headers = esp_strdup(headers); req->post_data = esp_strdup(post_data); req->buffer_size = 1; req->buffer = (char *)os_malloc(1); req->buffer[0] = '\0'; // Empty string. req->user_callback = user_callback; req->done = 0; ip_addr_t addr; err_t error = espconn_gethostbyname((struct espconn *)req, // It seems we don't need a real espconn pointer here. hostname, &addr, dns_callback); if (error == ESPCONN_INPROGRESS) { PRINTF("DNS pending\n"); } else if (error == ESPCONN_OK) { // Already in the local names table (or hostname was an IP address), execute the callback ourselves. dns_callback(hostname, &addr, req); } else { if (error == ESPCONN_ARG) { os_printf("DNS arg error %s\n", hostname); } else { os_printf("DNS error code %d\n", error); } dns_callback(hostname, NULL, req); // Handle all DNS errors the same way. } } /* * Parse an URL of the form http://host:port/path * can be a hostname or an IP address * is optional */ void ICACHE_FLASH_ATTR http_post(const char * url, const char * post_data, const char * headers, http_callback user_callback) { // FIXME: handle HTTP auth with http://user:pass@host/ // FIXME: get rid of the #anchor part if present. char hostname[128] = ""; int port = 80; bool secure = false; bool is_http = os_strncmp(url, "http://", strlen("http://")) == 0; bool is_https = os_strncmp(url, "https://", strlen("https://")) == 0; if (is_http) url += strlen("http://"); // Get rid of the protocol. else if (is_https) { port = 443; secure = true; url += strlen("https://"); // Get rid of the protocol. } else { os_printf("URL is not HTTP or HTTPS %s\n", url); return; } char * path = os_strchr(url, '/'); if (path == NULL) { path = os_strchr(url, '\0'); // Pointer to end of string. } char * colon = os_strchr(url, ':'); if (colon > path) { colon = NULL; // Limit the search to characters before the path. } if (colon == NULL) { // The port is not present. os_memcpy(hostname, url, path - url); hostname[path - url] = '\0'; } else { port = atoi(colon + 1); if (port == 0) { os_printf("Port error %s\n", url); return; } os_memcpy(hostname, url, colon - url); hostname[colon - url] = '\0'; } if (path[0] == '\0') { // Empty path is not allowed. path = "/"; } PRINTF("hostname=%s\n", hostname); PRINTF("port=%d\n", port); PRINTF("path=%s\n", path); http_raw_request(hostname, port, secure, path, post_data, headers, user_callback); } void ICACHE_FLASH_ATTR http_get(const char * url, const char * headers, http_callback user_callback) { http_post(url, NULL, headers, user_callback); } void ICACHE_FLASH_ATTR http_callback_example(char * response, int http_status, char * full_response) { os_printf("http_status=%d\n", http_status); if (http_status != HTTP_STATUS_GENERIC_ERROR) { os_printf("strlen(full_response)=%d\n", strlen(full_response)); os_printf("response=%s\n", response); } } ssltest/esphttpclient/test/0000775000175000017500000000000012546523641015102 5ustar alexalexssltest/esphttpclient/test/httpclient_test.c0000664000175000017500000000645412546523641020474 0ustar alexalex/* * ---------------------------------------------------------------------------- * "THE BEER-WARE LICENSE" (Revision 42): * Martin d'Allens wrote this file. As long as you retain * this notice you can do whatever you want with this stuff. If we meet some day, * and you think this stuff is worth it, you can buy me a beer in return. * ---------------------------------------------------------------------------- */ #include "osapi.h" #include "user_interface.h" #include "espconn.h" #include "httpclient.h" static int test_count = 0; static ETSTimer test_timer; static void ICACHE_FLASH_ATTR test_timer_cb() { os_printf("\nTEST %d ", test_count); switch(test_count) { case 0: os_printf("=> IP address before network ready\n"); http_get("http://173.194.45.65", "", http_callback_example); // This test will fail. The DHCP request returns directly, but the TCP connection hangs. // FIXME: wait for network to be ready before connecting? break; case 1: os_printf("=> Simple GET\n"); http_get("http://wtfismyip.com/text", "", http_callback_example); break; case 2: os_printf("=> Response too long\n"); http_get("http://www.wikipedia.org/", "", http_callback_example); break; case 3: os_printf("=> Connection refused\n"); http_get("http://att.com:1234/", "", http_callback_example); break; case 4: os_printf("=> Empty response, wrong protocol\n"); http_get("http://google.com:443/", "", http_callback_example); break; case 5: os_printf("=> Invalid DNS\n"); http_get("http://invalid.dns/", "", http_callback_example); break; case 6: os_printf("=> Connection time out\n"); http_get("http://google.com:1234/", "", http_callback_example); break; case 7: os_printf("=> Simple POST\n"); http_post("http://httpbin.org/post", "first_word=hello&second_word=world", "Content-Type: application/x-www-form-urlencoded\r\n", http_callback_example); break; case 8: os_printf("=> Moved\n"); http_get("http://wikipedia.org/", "", http_callback_example); break; case 9: os_printf("=> IP address, 404\n"); http_get("http://54.200.182.206/", "", http_callback_example); break; case 10: os_printf("=> Concurrent requests\n"); http_get("http://wtfismyip.com/text", "", http_callback_example); http_post("http://httpbin.org/post", "first_word=hello&second_word=world", "Content-Type: application/x-www-form-urlencoded\r\n", http_callback_example); http_get("http://wtfismyip.com/text", "", http_callback_example); http_post("http://httpbin.org/post", "first_word=hello&second_word=world", "Content-Type: application/x-www-form-urlencoded\r\n", http_callback_example); http_get("http://wtfismyip.com/text", "", http_callback_example); http_post("http://httpbin.org/post", "first_word=hello&second_word=world", "Content-Type: application/x-www-form-urlencoded\r\n", http_callback_example); http_get("http://wtfismyip.com/text", "", http_callback_example); // FIXME: this test sometimes fails with "DNS error code -1" break; default: os_printf("=> DONE\n"); return; } test_count++; os_timer_arm(&test_timer, 3000, 0); } void ICACHE_FLASH_ATTR http_test() { // FIXME: what happens when no Wifi network is available? os_timer_disarm(&test_timer); os_timer_setfn(&test_timer, test_timer_cb, NULL); os_timer_arm(&test_timer, 0, 0); // Start immediately. } ssltest/esphttpclient/httpclient.h0000664000175000017500000000404512546541002016444 0ustar alexalex/* * ---------------------------------------------------------------------------- * "THE BEER-WARE LICENSE" (Revision 42): * Martin d'Allens wrote this file. As long as you retain * this notice you can do whatever you want with this stuff. If we meet some day, * and you think this stuff is worth it, you can buy me a beer in return. * ---------------------------------------------------------------------------- */ #ifndef HTTPCLIENT_H #define HTTPCLIENT_H #define HTTP_STATUS_GENERIC_ERROR -1 // In case of TCP or DNS error the callback is called with this status. #define BUFFER_SIZE_MAX 512 // Size of http responses that will cause an error. /* * "full_response" is a string containing all response headers and the response body. * "response_body and "http_status" are extracted from "full_response" for convenience. * * A successful request corresponds to an HTTP status code of 200 (OK). * More info at http://en.wikipedia.org/wiki/List_of_HTTP_status_codes */ typedef void (* http_callback)(char * response_body, int http_status, char * full_response); /* * Download a web page from its URL. * Try: * http_get("http://wtfismyip.com/text", http_callback_example); */ void ICACHE_FLASH_ATTR http_get(const char * url, const char * headers, http_callback user_callback); /* * Post data to a web form. * The data should be encoded as application/x-www-form-urlencoded. * Try: * http_post("http://httpbin.org/post", "first_word=hello&second_word=world", http_callback_example); */ void ICACHE_FLASH_ATTR http_post(const char * url, const char * post_data, const char * headers, http_callback user_callback); /* * Call this function to skip URL parsing if the arguments are already in separate variables. */ void ICACHE_FLASH_ATTR http_raw_request(const char * hostname, int port, bool secure, const char * path, const char * post_data, const char * headers, http_callback user_callback); /* * Output on the UART. */ void http_callback_example(char * response, int http_status, char * full_response); #endif ssltest/esphttpclient/README.md0000664000175000017500000000430412546523641015403 0ustar alexalex# esphttpclient This is a short library for ESP8266(EX) chips to make HTTP requests. ## Features * Easy to use. * Supports multiple requests in parallel. * Supports GET and POST requests. * Tested with Espressif SDK v1.0.0 ## Building If you don't have a toolchain yet, install one with then get Espressif's SDK. ### The submodule way If your project looks like esphttpd from Sprite_tm: ```bash git clone http://git.spritesserver.nl/esphttpd.git/ cd esphttpd git submodule add https://github.com/Caerbannog/esphttpclient.git lib/esphttpclient git submodule update --init ``` Now append `lib/esphttpclient` to the following `Makefile` line and you should be ready: ``` MODULES = driver user lib/esphttpclient ``` In case you want to use SSL don't forget to add `ssl` to `LIBS` in the `Makefile` ``` LIBS = c gcc hal pp phy net80211 lwip wpa main ssl ``` ### The dirty way Alternatively you could create a simple project: ```bash git clone https://github.com/esp8266/source-code-examples.git cd source-code-examples/basic_example # Set your Wifi credentials in user_config.h # I could not test this because of the UART baud rate (74880) ``` Then download this library and move the files to `user/`: ```bash git clone https://github.com/Caerbannog/esphttpclient.git mv esphttpclient/*.* user/ ``` ## Usage Include `httpclient.h` from `user_main.c` then call one of these functions: ```c void http_get(const char * url, const char * headers, http_callback user_callback); void http_post(const char * url, const char * post_data, const char * headers, http_callback user_callback); void http_callback_example(char * response, int http_status, char * full_response) { os_printf("http_status=%d\n", http_status); if (http_status != HTTP_STATUS_GENERIC_ERROR) { os_printf("strlen(full_response)=%d\n", strlen(full_response)); os_printf("response=%s\n", response); } } ``` ## Example The following code performs a single request, then calls `http_callback_example` to display your public IP address. ```c http_get("http://wtfismyip.com/text", "", http_callback_example); ``` The output looks like this: ``` http_status=200 strlen(full_response)=244 response=208.97.177.124 ```