mirror of https://github.com/jeelabs/esp-link.git
Benjamin Runnels
9 years ago
commit
546b9c3774
@ -1,3 +0,0 @@ |
|||||||
[submodule "lib/heatshrink"] |
|
||||||
path = lib/heatshrink |
|
||||||
url = https://github.com/atomicobject/heatshrink.git |
|
||||||
@ -0,0 +1,179 @@ |
|||||||
|
// Copyright 2015 by Thorsten von Eicken, see LICENSE.txt
|
||||||
|
//
|
||||||
|
// Adapted from: github.com/tuanpmt/esp_bridge, Created on: Jan 9, 2015, Author: Minh
|
||||||
|
|
||||||
|
#include "esp8266.h" |
||||||
|
#include "cmd.h" |
||||||
|
#include "crc16.h" |
||||||
|
#include "serbridge.h" |
||||||
|
#include "uart.h" |
||||||
|
|
||||||
|
extern const CmdList commands[]; |
||||||
|
|
||||||
|
//===== ESP -> Serial responses
|
||||||
|
|
||||||
|
static void ICACHE_FLASH_ATTR |
||||||
|
CMD_ProtoWrite(uint8_t data) { |
||||||
|
switch(data){ |
||||||
|
case SLIP_START: |
||||||
|
case SLIP_END: |
||||||
|
case SLIP_REPL: |
||||||
|
uart0_write_char(SLIP_REPL); |
||||||
|
uart0_write_char(SLIP_ESC(data)); |
||||||
|
break; |
||||||
|
default: |
||||||
|
uart0_write_char(data); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
static void ICACHE_FLASH_ATTR |
||||||
|
CMD_ProtoWriteBuf(uint8_t *data, short len) { |
||||||
|
while (len--) CMD_ProtoWrite(*data++); |
||||||
|
} |
||||||
|
|
||||||
|
// Start a response, returns the partial CRC
|
||||||
|
uint16_t ICACHE_FLASH_ATTR |
||||||
|
CMD_ResponseStart(uint16_t cmd, uint32_t callback, uint32_t _return, uint16_t argc) { |
||||||
|
uint16_t crc = 0; |
||||||
|
|
||||||
|
uart0_write_char(SLIP_START); |
||||||
|
CMD_ProtoWriteBuf((uint8_t*)&cmd, 2); |
||||||
|
crc = crc16_data((uint8_t*)&cmd, 2, crc); |
||||||
|
CMD_ProtoWriteBuf((uint8_t*)&callback, 4); |
||||||
|
crc = crc16_data((uint8_t*)&callback, 4, crc); |
||||||
|
CMD_ProtoWriteBuf((uint8_t*)&_return, 4); |
||||||
|
crc = crc16_data((uint8_t*)&_return, 4, crc); |
||||||
|
CMD_ProtoWriteBuf((uint8_t*)&argc, 2); |
||||||
|
crc = crc16_data((uint8_t*)&argc, 2, crc); |
||||||
|
return crc; |
||||||
|
} |
||||||
|
|
||||||
|
// Adds data to a response, returns the partial CRC
|
||||||
|
uint16_t ICACHE_FLASH_ATTR |
||||||
|
CMD_ResponseBody(uint16_t crc_in, uint8_t* data, short len) { |
||||||
|
short pad_len = len+3 - (len+3)%4; // round up to multiple of 4
|
||||||
|
CMD_ProtoWriteBuf((uint8_t*)&pad_len, 2); |
||||||
|
crc_in = crc16_data((uint8_t*)&pad_len, 2, crc_in); |
||||||
|
|
||||||
|
CMD_ProtoWriteBuf(data, len); |
||||||
|
crc_in = crc16_data(data, len, crc_in); |
||||||
|
|
||||||
|
if (pad_len > len) { |
||||||
|
uint32_t temp = 0; |
||||||
|
CMD_ProtoWriteBuf((uint8_t*)&temp, pad_len-len); |
||||||
|
crc_in = crc16_data((uint8_t*)&temp, pad_len-len, crc_in); |
||||||
|
} |
||||||
|
|
||||||
|
return crc_in; |
||||||
|
} |
||||||
|
|
||||||
|
// Ends a response
|
||||||
|
void ICACHE_FLASH_ATTR |
||||||
|
CMD_ResponseEnd(uint16_t crc) { |
||||||
|
CMD_ProtoWriteBuf((uint8_t*)&crc, 2); |
||||||
|
uart0_write_char(SLIP_END); |
||||||
|
} |
||||||
|
|
||||||
|
//===== serial -> ESP commands
|
||||||
|
|
||||||
|
// Execute a parsed command
|
||||||
|
static uint32_t ICACHE_FLASH_ATTR |
||||||
|
CMD_Exec(const CmdList *scp, CmdPacket *packet) { |
||||||
|
uint16_t crc = 0; |
||||||
|
// Iterate through the command table and call the appropriate function
|
||||||
|
while (scp->sc_function != NULL) { |
||||||
|
if(scp->sc_name == packet->cmd) { |
||||||
|
//os_printf("CMD: Dispatching cmd=%d\n", packet->cmd);
|
||||||
|
// call command function
|
||||||
|
uint32_t ret = scp->sc_function(packet); |
||||||
|
// if requestor asked for a response, send it
|
||||||
|
if (packet->_return){ |
||||||
|
os_printf("CMD: Response: 0x%lx, cmd: %d\r\n", ret, packet->cmd); |
||||||
|
crc = CMD_ResponseStart(packet->cmd, 0, ret, 0); |
||||||
|
CMD_ResponseEnd(crc); |
||||||
|
} else { |
||||||
|
//os_printf("CMD: no response (%lu)\n", packet->_return);
|
||||||
|
} |
||||||
|
return ret; |
||||||
|
} |
||||||
|
scp++; |
||||||
|
} |
||||||
|
os_printf("CMD: cmd=%d not found\n", packet->cmd); |
||||||
|
return 0; |
||||||
|
} |
||||||
|
|
||||||
|
// Parse a packet and print info about it
|
||||||
|
void ICACHE_FLASH_ATTR |
||||||
|
CMD_parse_packet(uint8_t *buf, short len) { |
||||||
|
// minimum command length
|
||||||
|
if (len < 12) return; |
||||||
|
|
||||||
|
// init pointers into buffer
|
||||||
|
CmdPacket *packet = (CmdPacket*)buf; |
||||||
|
uint8_t *data_ptr = (uint8_t*)&packet->args; |
||||||
|
uint8_t *data_limit = data_ptr+len; |
||||||
|
uint16_t argc = packet->argc; |
||||||
|
uint16_t argn = 0; |
||||||
|
|
||||||
|
os_printf("CMD: cmd=%d argc=%d cb=%p ret=%lu\n", |
||||||
|
packet->cmd, packet->argc, (void *)packet->callback, packet->_return); |
||||||
|
|
||||||
|
// print out arguments
|
||||||
|
while (data_ptr+2 < data_limit && argc--) { |
||||||
|
short l = *(uint16_t*)data_ptr; |
||||||
|
os_printf("CMD: arg[%d] len=%d:", argn++, l); |
||||||
|
data_ptr += 2; |
||||||
|
while (data_ptr < data_limit && l--) { |
||||||
|
os_printf(" %02X", *data_ptr++); |
||||||
|
} |
||||||
|
os_printf("\n"); |
||||||
|
} |
||||||
|
|
||||||
|
if (data_ptr <= data_limit) { |
||||||
|
CMD_Exec(commands, packet); |
||||||
|
} else { |
||||||
|
os_printf("CMD: packet length overrun, parsing arg %d\n", argn-1); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
//===== Helpers to parse a command packet
|
||||||
|
|
||||||
|
// Fill out a CmdRequest struct given a CmdPacket
|
||||||
|
void ICACHE_FLASH_ATTR |
||||||
|
CMD_Request(CmdRequest *req, CmdPacket* cmd) { |
||||||
|
req->cmd = cmd; |
||||||
|
req->arg_num = 0; |
||||||
|
req->arg_ptr = (uint8_t*)&cmd->args; |
||||||
|
} |
||||||
|
|
||||||
|
// Return the number of arguments given a command struct
|
||||||
|
uint32_t ICACHE_FLASH_ATTR |
||||||
|
CMD_GetArgc(CmdRequest *req) { |
||||||
|
return req->cmd->argc; |
||||||
|
} |
||||||
|
|
||||||
|
// Copy the next argument from a command structure into the data pointer, returns 0 on success
|
||||||
|
// -1 on error
|
||||||
|
int32_t ICACHE_FLASH_ATTR |
||||||
|
CMD_PopArg(CmdRequest *req, void *data, uint16_t len) { |
||||||
|
uint16_t length; |
||||||
|
|
||||||
|
if (req->arg_num >= req->cmd->argc) |
||||||
|
return -1; |
||||||
|
|
||||||
|
length = *(uint16_t*)req->arg_ptr; |
||||||
|
if (length != len) return -1; // safety check
|
||||||
|
|
||||||
|
req->arg_ptr += 2; |
||||||
|
os_memcpy(data, req->arg_ptr, length); |
||||||
|
req->arg_ptr += length; |
||||||
|
|
||||||
|
req->arg_num ++; |
||||||
|
return 0; |
||||||
|
} |
||||||
|
|
||||||
|
// Return the length of the next argument
|
||||||
|
uint16_t ICACHE_FLASH_ATTR |
||||||
|
CMD_ArgLen(CmdRequest *req) { |
||||||
|
return *(uint16_t*)req->arg_ptr; |
||||||
|
} |
||||||
@ -0,0 +1,90 @@ |
|||||||
|
// Copyright 2015 by Thorsten von Eicken, see LICENSE.txt
|
||||||
|
//
|
||||||
|
// Adapted from: github.com/tuanpmt/esp_bridge, Created on: Jan 9, 2015, Author: Minh
|
||||||
|
|
||||||
|
#ifndef CMD_H |
||||||
|
#define CMD_H |
||||||
|
|
||||||
|
// Escape chars used by tuanpmt, dunno why he didn't use std ones...
|
||||||
|
#define SLIP_START 0x7E |
||||||
|
#define SLIP_END 0x7F |
||||||
|
#define SLIP_REPL 0x7D |
||||||
|
#define SLIP_ESC(x) (x ^ 0x20) |
||||||
|
|
||||||
|
#if 0 |
||||||
|
// Proper SLIP escape chars from RFC
|
||||||
|
#define SLIP_END 0300 // indicates end of packet
|
||||||
|
#define SLIP_ESC 0333 // indicates byte stuffing
|
||||||
|
#define SLIP_ESC_END 0334 // ESC ESC_END means END data byte
|
||||||
|
#define SLIP_ESC_ESC 0335 // ESC ESC_ESC means ESC data byte
|
||||||
|
#endif |
||||||
|
|
||||||
|
typedef struct __attribute((__packed__)) { |
||||||
|
uint16_t len; // length of data
|
||||||
|
uint8_t data[0]; // really data[len]
|
||||||
|
} CmdArg; |
||||||
|
|
||||||
|
typedef struct __attribute((__packed__)) { |
||||||
|
uint16_t cmd; // command to perform, from CmdName enum
|
||||||
|
uint32_t callback; // callback pointer to embed in response
|
||||||
|
uint32_t _return; // return value to embed in response (?)
|
||||||
|
uint16_t argc; // number of arguments to command
|
||||||
|
CmdArg args[0]; // really args[argc]
|
||||||
|
} CmdPacket; |
||||||
|
|
||||||
|
typedef struct { |
||||||
|
CmdPacket *cmd; // command packet header
|
||||||
|
uint32_t arg_num; // number of args parsed
|
||||||
|
uint8_t *arg_ptr; // pointer to ??
|
||||||
|
} CmdRequest; |
||||||
|
|
||||||
|
typedef enum { |
||||||
|
CMD_NULL = 0, |
||||||
|
CMD_RESET, // reset esp (not honored in this implementation)
|
||||||
|
CMD_IS_READY, // health-check
|
||||||
|
CMD_WIFI_CONNECT, // (3) connect to AP (not honored in this implementation)
|
||||||
|
CMD_MQTT_SETUP, |
||||||
|
CMD_MQTT_CONNECT, |
||||||
|
CMD_MQTT_DISCONNECT, |
||||||
|
CMD_MQTT_PUBLISH, |
||||||
|
CMD_MQTT_SUBSCRIBE, |
||||||
|
CMD_MQTT_LWT, |
||||||
|
CMD_MQTT_EVENTS, |
||||||
|
CMD_REST_SETUP, // (11)
|
||||||
|
CMD_REST_REQUEST, |
||||||
|
CMD_REST_SETHEADER, |
||||||
|
CMD_REST_EVENTS |
||||||
|
} CmdName; |
||||||
|
|
||||||
|
typedef uint32_t (*cmdfunc_t)(CmdPacket *cmd); |
||||||
|
|
||||||
|
typedef struct { |
||||||
|
CmdName sc_name; |
||||||
|
cmdfunc_t sc_function; |
||||||
|
} CmdList; |
||||||
|
|
||||||
|
void CMD_parse_packet(uint8_t *buf, short len); |
||||||
|
|
||||||
|
// Responses
|
||||||
|
|
||||||
|
// Start a response, returns the partial CRC
|
||||||
|
uint16_t CMD_ResponseStart(uint16_t cmd, uint32_t callback, uint32_t _return, uint16_t argc); |
||||||
|
// Adds data to a response, returns the partial CRC
|
||||||
|
uint16_t CMD_ResponseBody(uint16_t crc_in, uint8_t* data, short len); |
||||||
|
// Ends a response
|
||||||
|
void CMD_ResponseEnd(uint16_t crc); |
||||||
|
|
||||||
|
void CMD_Response(uint16_t cmd, uint32_t callback, uint32_t _return, uint16_t argc, CmdArg* args[]); |
||||||
|
|
||||||
|
// Requests
|
||||||
|
|
||||||
|
// Fill out a CmdRequest struct given a CmdPacket
|
||||||
|
void CMD_Request(CmdRequest *req, CmdPacket* cmd); |
||||||
|
// Return the number of arguments given a request
|
||||||
|
uint32_t CMD_GetArgc(CmdRequest *req); |
||||||
|
// Return the length of the next argument
|
||||||
|
uint16_t CMD_ArgLen(CmdRequest *req); |
||||||
|
// Copy next arg from request into the data pointer, returns 0 on success, -1 on error
|
||||||
|
int32_t CMD_PopArg(CmdRequest *req, void *data, uint16_t len); |
||||||
|
|
||||||
|
#endif |
||||||
@ -0,0 +1,83 @@ |
|||||||
|
// Copyright 2015 by Thorsten von Eicken, see LICENSE.txt
|
||||||
|
//
|
||||||
|
// Adapted from: github.com/tuanpmt/esp_bridge, Created on: Jan 9, 2015, Author: Minh
|
||||||
|
|
||||||
|
#include "esp8266.h" |
||||||
|
#include "cmd.h" |
||||||
|
#include "rest.h" |
||||||
|
#include "crc16.h" |
||||||
|
#include "serbridge.h" |
||||||
|
#include "uart.h" |
||||||
|
#include "cgiwifi.h" |
||||||
|
|
||||||
|
static uint32_t ICACHE_FLASH_ATTR CMD_Null(CmdPacket *cmd); |
||||||
|
static uint32_t ICACHE_FLASH_ATTR CMD_IsReady(CmdPacket *cmd); |
||||||
|
static uint32_t ICACHE_FLASH_ATTR CMD_WifiConnect(CmdPacket *cmd); |
||||||
|
|
||||||
|
// Command dispatch table for serial -> ESP commands
|
||||||
|
const CmdList commands[] = { |
||||||
|
{CMD_NULL, CMD_Null}, |
||||||
|
{CMD_RESET, CMD_Null}, |
||||||
|
{CMD_IS_READY, CMD_IsReady}, |
||||||
|
{CMD_WIFI_CONNECT, CMD_WifiConnect}, |
||||||
|
|
||||||
|
/*
|
||||||
|
{CMD_MQTT_SETUP, MQTTAPP_Setup}, |
||||||
|
{CMD_MQTT_CONNECT, MQTTAPP_Connect}, |
||||||
|
{CMD_MQTT_DISCONNECT, MQTTAPP_Disconnect}, |
||||||
|
{CMD_MQTT_PUBLISH, MQTTAPP_Publish}, |
||||||
|
{CMD_MQTT_SUBSCRIBE , MQTTAPP_Subscribe}, |
||||||
|
{CMD_MQTT_LWT, MQTTAPP_Lwt}, |
||||||
|
*/ |
||||||
|
|
||||||
|
{CMD_REST_SETUP, REST_Setup}, |
||||||
|
{CMD_REST_REQUEST, REST_Request}, |
||||||
|
{CMD_REST_SETHEADER, REST_SetHeader}, |
||||||
|
{CMD_NULL, NULL} |
||||||
|
}; |
||||||
|
|
||||||
|
// Command handler for IsReady (healthcheck) command
|
||||||
|
static uint32_t ICACHE_FLASH_ATTR |
||||||
|
CMD_IsReady(CmdPacket *cmd) { |
||||||
|
os_printf("CMD: Check ready\n"); |
||||||
|
return 1; |
||||||
|
} |
||||||
|
|
||||||
|
// Command handler for Null command
|
||||||
|
static uint32_t ICACHE_FLASH_ATTR |
||||||
|
CMD_Null(CmdPacket *cmd) { |
||||||
|
os_printf("CMD: NULL/unsupported command\n"); |
||||||
|
return 1; |
||||||
|
} |
||||||
|
|
||||||
|
static uint8_t lastWifiStatus; |
||||||
|
static uint32_t wifiCallback; |
||||||
|
|
||||||
|
// Callback from wifi subsystem to notify us of status changes
|
||||||
|
static void ICACHE_FLASH_ATTR |
||||||
|
CMD_WifiCb(uint8_t wifiStatus) { |
||||||
|
if (wifiStatus != lastWifiStatus){ |
||||||
|
lastWifiStatus = wifiStatus; |
||||||
|
if (wifiCallback) { |
||||||
|
uint8_t status = wifiStatus == wifiGotIP ? 5 : 1; |
||||||
|
uint16_t crc = CMD_ResponseStart(CMD_WIFI_CONNECT, wifiCallback, 0, 1); |
||||||
|
crc = CMD_ResponseBody(crc, (uint8_t*)&status, 1); |
||||||
|
CMD_ResponseEnd(crc); |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// Command handler for Wifi connect command
|
||||||
|
static uint32_t ICACHE_FLASH_ATTR |
||||||
|
CMD_WifiConnect(CmdPacket *cmd) { |
||||||
|
os_printf("CMD: Wifi connect\n"); |
||||||
|
if(cmd->argc != 2 || cmd->callback == 0) |
||||||
|
return 0xFFFFFFFF; |
||||||
|
|
||||||
|
wifiStatusCb = CMD_WifiCb; // register our callback with wifi subsystem
|
||||||
|
wifiCallback = cmd->callback; // save the MCU's callback
|
||||||
|
// trigger an immediate callback with the current status
|
||||||
|
lastWifiStatus = 0xff; |
||||||
|
CMD_WifiCb(wifiState); |
||||||
|
return 1; |
||||||
|
} |
||||||
@ -0,0 +1,426 @@ |
|||||||
|
// Copyright 2015 by Thorsten von Eicken, see LICENSE.txt
|
||||||
|
//
|
||||||
|
// Adapted from: github.com/tuanpmt/esp_bridge, Created on: Mar 4, 2015, Author: Minh
|
||||||
|
|
||||||
|
#include "esp8266.h" |
||||||
|
#include "rest.h" |
||||||
|
#include "cmd.h" |
||||||
|
|
||||||
|
// Connection pool for REST clients. Attached MCU's just call REST_setup and this allocates
|
||||||
|
// a connection, They never call any 'free' and given that the attached MCU could restart at
|
||||||
|
// any time, we cannot really rely on the attached MCU to call 'free' ever, so better do without.
|
||||||
|
// Instead, we allocate a fixed pool of connections an round-robin. What this means is that the
|
||||||
|
// attached MCU should really use at most as many REST connections as there are slots in the pool.
|
||||||
|
#define MAX_REST 4 |
||||||
|
static RestClient restClient[MAX_REST]; |
||||||
|
static uint8_t restNum = 0xff; // index into restClient for next slot to allocate
|
||||||
|
#define REST_CB 0xdead0000 // fudge added to callback for arduino so we can detect problems
|
||||||
|
|
||||||
|
extern uint8_t ICACHE_FLASH_ATTR UTILS_StrToIP(const char* str, void *ip); |
||||||
|
|
||||||
|
static void ICACHE_FLASH_ATTR |
||||||
|
tcpclient_discon_cb(void *arg) { |
||||||
|
struct espconn *pespconn = (struct espconn *)arg; |
||||||
|
RestClient* client = (RestClient *)pespconn->reverse; |
||||||
|
// free the data buffer, if we have one
|
||||||
|
if (client->data) os_free(client->data); |
||||||
|
client->data = 0; |
||||||
|
} |
||||||
|
|
||||||
|
static void ICACHE_FLASH_ATTR |
||||||
|
tcpclient_recv(void *arg, char *pdata, unsigned short len) { |
||||||
|
uint8_t currentLineIsBlank = 0; |
||||||
|
uint8_t httpBody = 0; |
||||||
|
uint8_t inStatus = 0; |
||||||
|
char statusCode[4]; |
||||||
|
int i = 0, j; |
||||||
|
uint32_t code = 0; |
||||||
|
uint16_t crc; |
||||||
|
|
||||||
|
struct espconn *pCon = (struct espconn*)arg; |
||||||
|
RestClient *client = (RestClient *)pCon->reverse; |
||||||
|
|
||||||
|
for(j=0 ;j<len; j++){ |
||||||
|
char c = pdata[j]; |
||||||
|
|
||||||
|
if(c == ' ' && !inStatus){ |
||||||
|
inStatus = 1; |
||||||
|
} |
||||||
|
if(inStatus && i < 3 && c != ' '){ |
||||||
|
statusCode[i] = c; |
||||||
|
i++; |
||||||
|
} |
||||||
|
if(i == 3){ |
||||||
|
statusCode[i] = '\0'; |
||||||
|
code = atoi(statusCode); |
||||||
|
} |
||||||
|
|
||||||
|
if(httpBody){ |
||||||
|
//only write response if its not null
|
||||||
|
uint32_t body_len = len - j; |
||||||
|
os_printf("REST: status=%ld, body=%ld\n", code, body_len); |
||||||
|
if(body_len == 0){ |
||||||
|
crc = CMD_ResponseStart(CMD_REST_EVENTS, client->resp_cb, code, 0); |
||||||
|
} else { |
||||||
|
crc = CMD_ResponseStart(CMD_REST_EVENTS, client->resp_cb, code, 1); |
||||||
|
crc = CMD_ResponseBody(crc, (uint8_t*)(pdata+j), body_len); |
||||||
|
} |
||||||
|
CMD_ResponseEnd(crc); |
||||||
|
break; |
||||||
|
} else { |
||||||
|
if (c == '\n' && currentLineIsBlank) { |
||||||
|
httpBody = true; |
||||||
|
} |
||||||
|
if (c == '\n') { |
||||||
|
// you're starting a new line
|
||||||
|
currentLineIsBlank = true; |
||||||
|
} else if (c != '\r') { |
||||||
|
// you've gotten a character on the current line
|
||||||
|
currentLineIsBlank = false; |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
//if(client->security)
|
||||||
|
// espconn_secure_disconnect(client->pCon);
|
||||||
|
//else
|
||||||
|
espconn_disconnect(client->pCon); |
||||||
|
|
||||||
|
} |
||||||
|
|
||||||
|
static void ICACHE_FLASH_ATTR |
||||||
|
tcpclient_sent_cb(void *arg) { |
||||||
|
struct espconn *pCon = (struct espconn *)arg; |
||||||
|
RestClient* client = (RestClient *)pCon->reverse; |
||||||
|
os_printf("REST: Sent\n"); |
||||||
|
if (client->data_sent != client->data_len) { |
||||||
|
// we only sent part of the buffer, send the rest
|
||||||
|
espconn_sent(client->pCon, (uint8_t*)(client->data+client->data_sent), |
||||||
|
client->data_len-client->data_sent); |
||||||
|
client->data_sent = client->data_len; |
||||||
|
} else { |
||||||
|
// we're done sending, free the memory
|
||||||
|
if (client->data) os_free(client->data); |
||||||
|
client->data = 0; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
static void ICACHE_FLASH_ATTR |
||||||
|
tcpclient_connect_cb(void *arg) { |
||||||
|
struct espconn *pCon = (struct espconn *)arg; |
||||||
|
RestClient* client = (RestClient *)pCon->reverse; |
||||||
|
os_printf("REST #%d: connected\n", client-restClient); |
||||||
|
|
||||||
|
espconn_regist_disconcb(client->pCon, tcpclient_discon_cb); |
||||||
|
espconn_regist_recvcb(client->pCon, tcpclient_recv); |
||||||
|
espconn_regist_sentcb(client->pCon, tcpclient_sent_cb); |
||||||
|
|
||||||
|
client->data_sent = client->data_len <= 1400 ? client->data_len : 1400; |
||||||
|
os_printf("REST #%d: sending %d\n", client-restClient, client->data_sent); |
||||||
|
//if(client->security){
|
||||||
|
// espconn_secure_sent(client->pCon, client->data, client->data_sent);
|
||||||
|
//}
|
||||||
|
//else{
|
||||||
|
espconn_sent(client->pCon, (uint8_t*)client->data, client->data_sent); |
||||||
|
//}
|
||||||
|
} |
||||||
|
|
||||||
|
static void ICACHE_FLASH_ATTR |
||||||
|
tcpclient_recon_cb(void *arg, sint8 errType) { |
||||||
|
struct espconn *pCon = (struct espconn *)arg; |
||||||
|
RestClient* client = (RestClient *)pCon->reverse; |
||||||
|
os_printf("REST $%d: conn reset\n", client-restClient); |
||||||
|
} |
||||||
|
|
||||||
|
static void ICACHE_FLASH_ATTR |
||||||
|
rest_dns_found(const char *name, ip_addr_t *ipaddr, void *arg) { |
||||||
|
struct espconn *pConn = (struct espconn *)arg; |
||||||
|
RestClient* client = (RestClient *)pConn->reverse; |
||||||
|
|
||||||
|
if(ipaddr == NULL) { |
||||||
|
os_printf("REST DNS: Got no ip, try to reconnect\n"); |
||||||
|
return; |
||||||
|
} |
||||||
|
|
||||||
|
os_printf("REST DNS: found ip %d.%d.%d.%d\n", |
||||||
|
*((uint8 *) &ipaddr->addr), |
||||||
|
*((uint8 *) &ipaddr->addr + 1), |
||||||
|
*((uint8 *) &ipaddr->addr + 2), |
||||||
|
*((uint8 *) &ipaddr->addr + 3)); |
||||||
|
|
||||||
|
if(client->ip.addr == 0 && ipaddr->addr != 0) { |
||||||
|
os_memcpy(client->pCon->proto.tcp->remote_ip, &ipaddr->addr, 4); |
||||||
|
//if(client->security){
|
||||||
|
// espconn_secure_connect(client->pCon);
|
||||||
|
//}
|
||||||
|
//else {
|
||||||
|
espconn_connect(client->pCon); |
||||||
|
//}
|
||||||
|
os_printf("REST: connecting...\n"); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
uint32_t ICACHE_FLASH_ATTR |
||||||
|
REST_Setup(CmdPacket *cmd) { |
||||||
|
CmdRequest req; |
||||||
|
uint32_t port, security; |
||||||
|
|
||||||
|
// start parsing the command
|
||||||
|
CMD_Request(&req, cmd); |
||||||
|
if(CMD_GetArgc(&req) != 3) return 0; |
||||||
|
|
||||||
|
// get the hostname
|
||||||
|
uint16_t len = CMD_ArgLen(&req); |
||||||
|
if (len > 128) return 0; // safety check
|
||||||
|
uint8_t *rest_host = (uint8_t*)os_zalloc(len + 1); |
||||||
|
if (CMD_PopArg(&req, rest_host, len)) return 0; |
||||||
|
rest_host[len] = 0; |
||||||
|
|
||||||
|
// get the port
|
||||||
|
if (CMD_PopArg(&req, (uint8_t*)&port, 4)) { |
||||||
|
os_free(rest_host); |
||||||
|
return 0; |
||||||
|
} |
||||||
|
|
||||||
|
// get the security mode
|
||||||
|
if (CMD_PopArg(&req, (uint8_t*)&security, 4)) { |
||||||
|
os_free(rest_host); |
||||||
|
return 0; |
||||||
|
} |
||||||
|
|
||||||
|
// clear connection structures the first time
|
||||||
|
if (restNum == 0xff) { |
||||||
|
os_memset(restClient, 0, MAX_REST * sizeof(RestClient)); |
||||||
|
restNum = 0; |
||||||
|
} |
||||||
|
|
||||||
|
// allocate a connection structure
|
||||||
|
RestClient *client = restClient + restNum; |
||||||
|
uint8_t clientNum = restNum; |
||||||
|
restNum = (restNum+1)%MAX_REST; |
||||||
|
|
||||||
|
// free any data structure that may be left from a previous connection
|
||||||
|
if (client->header) os_free(client->header); |
||||||
|
if (client->content_type) os_free(client->content_type); |
||||||
|
if (client->user_agent) os_free(client->user_agent); |
||||||
|
if (client->data) os_free(client->data); |
||||||
|
if (client->pCon) { |
||||||
|
if (client->pCon->proto.tcp) os_free(client->pCon->proto.tcp); |
||||||
|
os_free(client->pCon); |
||||||
|
} |
||||||
|
os_memset(client, 0, sizeof(RestClient)); |
||||||
|
|
||||||
|
os_printf("REST: setup #%d host=%s port=%ld security=%ld\n", clientNum, rest_host, port, security); |
||||||
|
|
||||||
|
client->resp_cb = cmd->callback; |
||||||
|
|
||||||
|
client->host = (char *)rest_host; |
||||||
|
client->port = port; |
||||||
|
client->security = security; |
||||||
|
|
||||||
|
client->header = (char*)os_zalloc(4); |
||||||
|
client->header[0] = 0; |
||||||
|
|
||||||
|
client->content_type = (char*)os_zalloc(22); |
||||||
|
os_sprintf((char *)client->content_type, "x-www-form-urlencoded"); |
||||||
|
|
||||||
|
client->user_agent = (char*)os_zalloc(9); |
||||||
|
os_sprintf((char *)client->user_agent, "esp-link"); |
||||||
|
|
||||||
|
client->pCon = (struct espconn *)os_zalloc(sizeof(struct espconn)); |
||||||
|
client->pCon->proto.tcp = (esp_tcp *)os_zalloc(sizeof(esp_tcp)); |
||||||
|
|
||||||
|
client->pCon->type = ESPCONN_TCP; |
||||||
|
client->pCon->state = ESPCONN_NONE; |
||||||
|
client->pCon->proto.tcp->local_port = espconn_port(); |
||||||
|
client->pCon->proto.tcp->remote_port = client->port; |
||||||
|
|
||||||
|
client->pCon->reverse = client; |
||||||
|
|
||||||
|
return REST_CB | (uint32_t)clientNum; |
||||||
|
} |
||||||
|
|
||||||
|
uint32_t ICACHE_FLASH_ATTR |
||||||
|
REST_SetHeader(CmdPacket *cmd) { |
||||||
|
CmdRequest req; |
||||||
|
CMD_Request(&req, cmd); |
||||||
|
|
||||||
|
if(CMD_GetArgc(&req) != 3) |
||||||
|
return 0; |
||||||
|
|
||||||
|
// Get client
|
||||||
|
uint32_t clientNum; |
||||||
|
if (CMD_PopArg(&req, (uint8_t*)&clientNum, 4)) return 0; |
||||||
|
if ((clientNum & 0xffff0000) != REST_CB) return 0; |
||||||
|
RestClient *client = restClient + ((clientNum & 0xffff) % MAX_REST); |
||||||
|
|
||||||
|
// Get header selector
|
||||||
|
uint32_t header_index; |
||||||
|
if (CMD_PopArg(&req, (uint8_t*)&header_index, 4)) return 0; |
||||||
|
|
||||||
|
// Get header value
|
||||||
|
uint16_t len = CMD_ArgLen(&req); |
||||||
|
if (len > 256) return 0; //safety check
|
||||||
|
switch(header_index) { |
||||||
|
case HEADER_GENERIC: |
||||||
|
if(client->header) os_free(client->header); |
||||||
|
client->header = (char*)os_zalloc(len + 3); |
||||||
|
CMD_PopArg(&req, (uint8_t*)client->header, len); |
||||||
|
client->header[len] = '\r'; |
||||||
|
client->header[len+1] = '\n'; |
||||||
|
client->header[len+2] = 0; |
||||||
|
os_printf("REST: Set header: %s\r\n", client->header); |
||||||
|
break; |
||||||
|
case HEADER_CONTENT_TYPE: |
||||||
|
if(client->content_type) os_free(client->content_type); |
||||||
|
client->content_type = (char*)os_zalloc(len + 3); |
||||||
|
CMD_PopArg(&req, (uint8_t*)client->content_type, len); |
||||||
|
client->content_type[len] = '\r'; |
||||||
|
client->content_type[len+1] = '\n'; |
||||||
|
client->content_type[len+2] = 0; |
||||||
|
os_printf("REST: Set content_type: %s\r\n", client->content_type); |
||||||
|
break; |
||||||
|
case HEADER_USER_AGENT: |
||||||
|
if(client->user_agent) os_free(client->user_agent); |
||||||
|
client->user_agent = (char*)os_zalloc(len + 3); |
||||||
|
CMD_PopArg(&req, (uint8_t*)client->user_agent, len); |
||||||
|
client->user_agent[len] = '\r'; |
||||||
|
client->user_agent[len+1] = '\n'; |
||||||
|
client->user_agent[len+2] = 0; |
||||||
|
os_printf("REST: Set user_agent: %s\r\n", client->user_agent); |
||||||
|
break; |
||||||
|
} |
||||||
|
return 1; |
||||||
|
} |
||||||
|
|
||||||
|
uint32_t ICACHE_FLASH_ATTR |
||||||
|
REST_Request(CmdPacket *cmd) { |
||||||
|
CmdRequest req; |
||||||
|
CMD_Request(&req, cmd); |
||||||
|
os_printf("REST: request"); |
||||||
|
|
||||||
|
// Get client
|
||||||
|
uint32_t clientNum; |
||||||
|
if (CMD_PopArg(&req, (uint8_t*)&clientNum, 4)) goto fail; |
||||||
|
if ((clientNum & 0xffff0000) != REST_CB) goto fail; |
||||||
|
clientNum &= 0xffff; |
||||||
|
RestClient *client = restClient + clientNum % MAX_REST; |
||||||
|
os_printf(" #%ld", clientNum); |
||||||
|
|
||||||
|
// Get HTTP method
|
||||||
|
uint16_t len = CMD_ArgLen(&req); |
||||||
|
if (len > 15) goto fail; |
||||||
|
char method[16]; |
||||||
|
CMD_PopArg(&req, method, len); |
||||||
|
method[len] = 0; |
||||||
|
os_printf(" method=%s", method); |
||||||
|
|
||||||
|
// Get HTTP path
|
||||||
|
len = CMD_ArgLen(&req); |
||||||
|
if (len > 1023) goto fail; |
||||||
|
char path[1024]; |
||||||
|
CMD_PopArg(&req, path, len); |
||||||
|
path[len] = 0; |
||||||
|
os_printf(" path=%s", path); |
||||||
|
|
||||||
|
// Get HTTP body
|
||||||
|
uint32_t realLen = 0; |
||||||
|
if (CMD_GetArgc(&req) == 3) { |
||||||
|
realLen = 0; |
||||||
|
len = 0; |
||||||
|
} else { |
||||||
|
CMD_PopArg(&req, (uint8_t*)&realLen, 4); |
||||||
|
|
||||||
|
len = CMD_ArgLen(&req); |
||||||
|
if (len > 2048 || realLen > len) goto fail; |
||||||
|
} |
||||||
|
os_printf(" bodyLen=%ld", realLen); |
||||||
|
|
||||||
|
// we need to allocate memory for the header plus the body. First we count the length of the
|
||||||
|
// header (including some extra counted "%s" and then we add the body length. We allocate the
|
||||||
|
// whole shebang and copy everything into it.
|
||||||
|
char *headerFmt = "%s %s HTTP/1.1\r\n" |
||||||
|
"Host: %s\r\n" |
||||||
|
"%s" |
||||||
|
"Content-Length: %d\r\n" |
||||||
|
"Connection: close\r\n" |
||||||
|
"Content-Type: %s\r\n" |
||||||
|
"User-Agent: %s\r\n\r\n"; |
||||||
|
uint16_t headerLen = strlen(headerFmt) + strlen(method) + strlen(path) + strlen(client->host) + |
||||||
|
strlen(client->header) + strlen(client->content_type) + strlen(client->user_agent); |
||||||
|
os_printf(" hdrLen=%d", headerLen); |
||||||
|
if (client->data) os_free(client->data); |
||||||
|
client->data = (char*)os_zalloc(headerLen + realLen); |
||||||
|
if (client->data == NULL) goto fail; |
||||||
|
os_printf(" totLen=%ld data=%p", headerLen + realLen, client->data); |
||||||
|
client->data_len = os_sprintf((char*)client->data, headerFmt, method, path, client->host, |
||||||
|
client->header, realLen, client->content_type, client->user_agent); |
||||||
|
os_printf(" hdrLen=%d", client->data_len); |
||||||
|
|
||||||
|
if (realLen > 0) { |
||||||
|
CMD_PopArg(&req, client->data + client->data_len, realLen); |
||||||
|
client->data_len += realLen; |
||||||
|
} |
||||||
|
|
||||||
|
client->pCon->state = ESPCONN_NONE; |
||||||
|
espconn_regist_connectcb(client->pCon, tcpclient_connect_cb); |
||||||
|
espconn_regist_reconcb(client->pCon, tcpclient_recon_cb); |
||||||
|
os_printf("\n"); |
||||||
|
|
||||||
|
if(UTILS_StrToIP((char *)client->host, &client->pCon->proto.tcp->remote_ip)) { |
||||||
|
os_printf("REST: Connect to ip %s:%ld\n",client->host, client->port); |
||||||
|
//if(client->security){
|
||||||
|
// espconn_secure_connect(client->pCon);
|
||||||
|
//}
|
||||||
|
//else {
|
||||||
|
espconn_connect(client->pCon); |
||||||
|
//}
|
||||||
|
} else { |
||||||
|
os_printf("REST: Connect to host %s:%ld\n", client->host, client->port); |
||||||
|
espconn_gethostbyname(client->pCon, (char *)client->host, &client->ip, rest_dns_found); |
||||||
|
} |
||||||
|
|
||||||
|
return 1; |
||||||
|
|
||||||
|
fail: |
||||||
|
os_printf("\n"); |
||||||
|
return 0; |
||||||
|
} |
||||||
|
|
||||||
|
uint8_t ICACHE_FLASH_ATTR |
||||||
|
UTILS_StrToIP(const char* str, void *ip) |
||||||
|
{ |
||||||
|
/* The count of the number of bytes processed. */ |
||||||
|
int i; |
||||||
|
/* A pointer to the next digit to process. */ |
||||||
|
const char * start; |
||||||
|
|
||||||
|
start = str; |
||||||
|
for (i = 0; i < 4; i++) { |
||||||
|
/* The digit being processed. */ |
||||||
|
char c; |
||||||
|
/* The value of this byte. */ |
||||||
|
int n = 0; |
||||||
|
while (1) { |
||||||
|
c = * start; |
||||||
|
start++; |
||||||
|
if (c >= '0' && c <= '9') { |
||||||
|
n *= 10; |
||||||
|
n += c - '0'; |
||||||
|
} |
||||||
|
/* We insist on stopping at "." if we are still parsing
|
||||||
|
the first, second, or third numbers. If we have reached |
||||||
|
the end of the numbers, we will allow any character. */ |
||||||
|
else if ((i < 3 && c == '.') || i == 3) { |
||||||
|
break; |
||||||
|
} |
||||||
|
else { |
||||||
|
return 0; |
||||||
|
} |
||||||
|
} |
||||||
|
if (n >= 256) { |
||||||
|
return 0; |
||||||
|
} |
||||||
|
((uint8_t*)ip)[i] = n; |
||||||
|
} |
||||||
|
return 1; |
||||||
|
} |
||||||
@ -0,0 +1,40 @@ |
|||||||
|
/*
|
||||||
|
* api.h |
||||||
|
* |
||||||
|
* Created on: Mar 4, 2015 |
||||||
|
* Author: Minh |
||||||
|
*/ |
||||||
|
|
||||||
|
#ifndef MODULES_API_H_ |
||||||
|
#define MODULES_API_H_ |
||||||
|
|
||||||
|
#include "c_types.h" |
||||||
|
#include "ip_addr.h" |
||||||
|
#include "cmd.h" |
||||||
|
|
||||||
|
typedef enum { |
||||||
|
HEADER_GENERIC = 0, |
||||||
|
HEADER_CONTENT_TYPE, |
||||||
|
HEADER_USER_AGENT |
||||||
|
} HEADER_TYPE; |
||||||
|
|
||||||
|
typedef struct { |
||||||
|
char *host; |
||||||
|
uint32_t port; |
||||||
|
uint32_t security; |
||||||
|
ip_addr_t ip; |
||||||
|
struct espconn *pCon; |
||||||
|
char *header; |
||||||
|
char *data; |
||||||
|
uint16_t data_len; |
||||||
|
uint16_t data_sent; |
||||||
|
char *content_type; |
||||||
|
char *user_agent; |
||||||
|
uint32_t resp_cb; |
||||||
|
} RestClient; |
||||||
|
|
||||||
|
uint32_t REST_Setup(CmdPacket *cmd); |
||||||
|
uint32_t REST_Request(CmdPacket *cmd); |
||||||
|
uint32_t REST_SetHeader(CmdPacket *cmd); |
||||||
|
|
||||||
|
#endif /* MODULES_INCLUDE_API_H_ */ |
||||||
@ -0,0 +1,315 @@ |
|||||||
|
// Copyright 2015 by Thorsten von Eicken, see LICENSE.txt
|
||||||
|
//
|
||||||
|
// TCP client library allowing uControllers attached to the serial port to send commands
|
||||||
|
// to open/close TCP connections and send/recv data.
|
||||||
|
// The serial protocol is described in https://gist.github.com/tve/a46c44bf1f6b42bc572e
|
||||||
|
|
||||||
|
#include <esp8266.h> |
||||||
|
#include "config.h" |
||||||
|
#include "uart.h" |
||||||
|
#include "serled.h" |
||||||
|
#include "tcpclient.h" |
||||||
|
|
||||||
|
// max number of channels the client can open
|
||||||
|
#define MAX_CHAN MAX_TCP_CHAN |
||||||
|
// size of tx buffer
|
||||||
|
#define MAX_TXBUF 1024 |
||||||
|
|
||||||
|
enum TcpState { |
||||||
|
TCP_idle, // unused connection
|
||||||
|
TCP_dns, // doing gethostbyname
|
||||||
|
TCP_conn, // connecting to remote server
|
||||||
|
TCP_data, // connected
|
||||||
|
}; |
||||||
|
|
||||||
|
// Connections
|
||||||
|
typedef struct { |
||||||
|
struct espconn *conn; // esp connection structure
|
||||||
|
esp_tcp *tcp; // esp TCP parameters
|
||||||
|
char *txBuf; // buffer to accumulate into
|
||||||
|
char *txBufSent; // buffer held by espconn
|
||||||
|
uint8_t txBufLen; // number of chars in txbuf
|
||||||
|
enum TcpState state; |
||||||
|
} TcpConn; |
||||||
|
|
||||||
|
static TcpConn tcpConn[MAX_CHAN]; |
||||||
|
|
||||||
|
// forward declarations
|
||||||
|
static void tcpConnFree(TcpConn* tci); |
||||||
|
static TcpConn* tcpConnAlloc(uint8_t chan); |
||||||
|
static void tcpDoSend(TcpConn *tci); |
||||||
|
static void tcpConnectCb(void *arg); |
||||||
|
static void tcpDisconCb(void *arg); |
||||||
|
static void tcpResetCb(void *arg, sint8 err); |
||||||
|
static void tcpSentCb(void *arg); |
||||||
|
static void tcpRecvCb(void *arg, char *data, uint16_t len); |
||||||
|
|
||||||
|
//===== allocate / free connections
|
||||||
|
|
||||||
|
// Allocate a new connection dynamically and return it. Returns NULL if buf alloc failed
|
||||||
|
static TcpConn* ICACHE_FLASH_ATTR |
||||||
|
tcpConnAlloc(uint8_t chan) { |
||||||
|
TcpConn *tci = tcpConn+chan; |
||||||
|
if (tci->state != TCP_idle && tci->conn != NULL) return tci; |
||||||
|
|
||||||
|
// malloc and return espconn struct
|
||||||
|
tci->conn = os_malloc(sizeof(struct espconn)); |
||||||
|
if (tci->conn == NULL) goto fail; |
||||||
|
memset(tci->conn, 0, sizeof(struct espconn)); |
||||||
|
// malloc esp_tcp struct
|
||||||
|
tci->tcp = os_malloc(sizeof(esp_tcp)); |
||||||
|
if (tci->tcp == NULL) goto fail; |
||||||
|
memset(tci->tcp, 0, sizeof(esp_tcp)); |
||||||
|
|
||||||
|
// common init
|
||||||
|
tci->state = TCP_dns; |
||||||
|
tci->conn->type = ESPCONN_TCP; |
||||||
|
tci->conn->state = ESPCONN_NONE; |
||||||
|
tci->conn->proto.tcp = tci->tcp; |
||||||
|
tci->tcp->remote_port = 80; |
||||||
|
espconn_regist_connectcb(tci->conn, tcpConnectCb); |
||||||
|
espconn_regist_reconcb(tci->conn, tcpResetCb); |
||||||
|
espconn_regist_sentcb(tci->conn, tcpSentCb); |
||||||
|
espconn_regist_recvcb(tci->conn, tcpRecvCb); |
||||||
|
espconn_regist_disconcb(tci->conn, tcpDisconCb); |
||||||
|
tci->conn->reverse = tci; |
||||||
|
|
||||||
|
return tci; |
||||||
|
|
||||||
|
fail: |
||||||
|
tcpConnFree(tci); |
||||||
|
return NULL; |
||||||
|
} |
||||||
|
|
||||||
|
// Free a connection dynamically.
|
||||||
|
static void ICACHE_FLASH_ATTR |
||||||
|
tcpConnFree(TcpConn* tci) { |
||||||
|
if (tci->conn != NULL) os_free(tci->conn); |
||||||
|
if (tci->tcp != NULL) os_free(tci->tcp); |
||||||
|
if (tci->txBuf != NULL) os_free(tci->txBuf); |
||||||
|
if (tci->txBufSent != NULL) os_free(tci->txBufSent); |
||||||
|
memset(tci, 0, sizeof(TcpConn)); |
||||||
|
} |
||||||
|
|
||||||
|
//===== DNS
|
||||||
|
|
||||||
|
// DNS name resolution callback
|
||||||
|
static void ICACHE_FLASH_ATTR |
||||||
|
tcpClientHostnameCb(const char *name, ip_addr_t *ipaddr, void *arg) { |
||||||
|
struct espconn *conn = arg; |
||||||
|
TcpConn *tci = conn->reverse; |
||||||
|
os_printf("TCP dns CB (%p %p)\n", arg, tci); |
||||||
|
if (ipaddr == NULL) { |
||||||
|
os_printf("TCP %s not found\n", name); |
||||||
|
} else { |
||||||
|
os_printf("TCP %s -> %d.%d.%d.%d\n", name, IP2STR(ipaddr)); |
||||||
|
tci->tcp->remote_ip[0] = ip4_addr1(ipaddr); |
||||||
|
tci->tcp->remote_ip[1] = ip4_addr2(ipaddr); |
||||||
|
tci->tcp->remote_ip[2] = ip4_addr3(ipaddr); |
||||||
|
tci->tcp->remote_ip[3] = ip4_addr4(ipaddr); |
||||||
|
os_printf("TCP connect %d.%d.%d.%d (%p)\n", IP2STR(tci->tcp->remote_ip), tci); |
||||||
|
if (espconn_connect(tci->conn) == ESPCONN_OK) { |
||||||
|
tci->state = TCP_conn; |
||||||
|
return; |
||||||
|
} |
||||||
|
os_printf("TCP connect failure\n"); |
||||||
|
} |
||||||
|
// oops
|
||||||
|
tcpConnFree(tci); |
||||||
|
} |
||||||
|
|
||||||
|
//===== Connect / disconnect
|
||||||
|
|
||||||
|
// Connected callback
|
||||||
|
static void ICACHE_FLASH_ATTR |
||||||
|
tcpConnectCb(void *arg) { |
||||||
|
struct espconn *conn = arg; |
||||||
|
TcpConn *tci = conn->reverse; |
||||||
|
os_printf("TCP connect CB (%p %p)\n", arg, tci); |
||||||
|
tci->state = TCP_data; |
||||||
|
// send any buffered data
|
||||||
|
if (tci->txBuf != NULL && tci->txBufLen > 0) tcpDoSend(tci); |
||||||
|
// reply to serial
|
||||||
|
char buf[6]; |
||||||
|
short l = os_sprintf(buf, "\n~@%dC\n", tci-tcpConn); |
||||||
|
uart0_tx_buffer(buf, l); |
||||||
|
} |
||||||
|
|
||||||
|
// Disconnect callback
|
||||||
|
static void ICACHE_FLASH_ATTR tcpDisconCb(void *arg) { |
||||||
|
struct espconn *conn = arg; |
||||||
|
TcpConn *tci = conn->reverse; |
||||||
|
os_printf("TCP disconnect CB (%p %p)\n", arg, tci); |
||||||
|
// notify to serial
|
||||||
|
char buf[6]; |
||||||
|
short l = os_sprintf(buf, "\n~@%dZ\n", tci-tcpConn); |
||||||
|
uart0_tx_buffer(buf, l); |
||||||
|
// free
|
||||||
|
tcpConnFree(tci); |
||||||
|
} |
||||||
|
|
||||||
|
// Connection reset callback
|
||||||
|
static void ICACHE_FLASH_ATTR tcpResetCb(void *arg, sint8 err) { |
||||||
|
struct espconn *conn = arg; |
||||||
|
TcpConn *tci = conn->reverse; |
||||||
|
os_printf("TCP reset CB (%p %p) err=%d\n", arg, tci, err); |
||||||
|
// notify to serial
|
||||||
|
char buf[6]; |
||||||
|
short l = os_sprintf(buf, "\n~@%dZ\n", tci-tcpConn); |
||||||
|
uart0_tx_buffer(buf, l); |
||||||
|
// free
|
||||||
|
tcpConnFree(tci); |
||||||
|
} |
||||||
|
|
||||||
|
//===== Sending and receiving
|
||||||
|
|
||||||
|
// Send the next buffer (assumes that the connection is in a state that allows it)
|
||||||
|
static void ICACHE_FLASH_ATTR |
||||||
|
tcpDoSend(TcpConn *tci) { |
||||||
|
sint8 err = espconn_sent(tci->conn, (uint8*)tci->txBuf, tci->txBufLen); |
||||||
|
if (err == ESPCONN_OK) { |
||||||
|
// send successful
|
||||||
|
os_printf("TCP sent (%p %p)\n", tci->conn, tci); |
||||||
|
tci->txBuf[tci->txBufLen] = 0; os_printf("TCP data: %s\n", tci->txBuf); |
||||||
|
tci->txBufSent = tci->txBuf; |
||||||
|
tci->txBuf = NULL; |
||||||
|
tci->txBufLen = 0; |
||||||
|
} else { |
||||||
|
// send error, leave as-is and try again later...
|
||||||
|
os_printf("TCP send err (%p %p) %d\n", tci->conn, tci, err); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// Sent callback
|
||||||
|
static void ICACHE_FLASH_ATTR |
||||||
|
tcpSentCb(void *arg) { |
||||||
|
struct espconn *conn = arg; |
||||||
|
TcpConn *tci = conn->reverse; |
||||||
|
os_printf("TCP sent CB (%p %p)\n", arg, tci); |
||||||
|
if (tci->txBufSent != NULL) os_free(tci->txBufSent); |
||||||
|
tci->txBufSent = NULL; |
||||||
|
|
||||||
|
if (tci->txBuf != NULL && tci->txBufLen == MAX_TXBUF) { |
||||||
|
// next buffer is full, send it now
|
||||||
|
tcpDoSend(tci); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// Recv callback
|
||||||
|
static void ICACHE_FLASH_ATTR tcpRecvCb(void *arg, char *data, uint16_t len) { |
||||||
|
struct espconn *conn = arg; |
||||||
|
TcpConn *tci = conn->reverse; |
||||||
|
os_printf("TCP recv CB (%p %p)\n", arg, tci); |
||||||
|
if (tci->state == TCP_data) { |
||||||
|
uint8_t chan; |
||||||
|
for (chan=0; chan<MAX_CHAN && tcpConn+chan!=tci; chan++) |
||||||
|
if (chan >= MAX_CHAN) return; // oops!?
|
||||||
|
char buf[6]; |
||||||
|
short l = os_sprintf(buf, "\n~%d", chan); |
||||||
|
uart0_tx_buffer(buf, l); |
||||||
|
uart0_tx_buffer(data, len); |
||||||
|
uart0_tx_buffer("\0\n", 2); |
||||||
|
} |
||||||
|
serledFlash(50); // short blink on serial LED
|
||||||
|
} |
||||||
|
|
||||||
|
void ICACHE_FLASH_ATTR |
||||||
|
tcpClientSendChar(uint8_t chan, char c) { |
||||||
|
TcpConn *tci = tcpConn+chan; |
||||||
|
if (tci->state == TCP_idle) return; |
||||||
|
|
||||||
|
if (tci->txBuf != NULL) { |
||||||
|
// we have a buffer
|
||||||
|
if (tci->txBufLen < MAX_TXBUF) { |
||||||
|
// buffer has space, add char and return
|
||||||
|
tci->txBuf[tci->txBufLen++] = c; |
||||||
|
return; |
||||||
|
} else if (tci->txBufSent == NULL) { |
||||||
|
// we don't have a send pending, send full buffer off
|
||||||
|
if (tci->state == TCP_data) tcpDoSend(tci); |
||||||
|
if (tci->txBuf != NULL) return; // something went wrong
|
||||||
|
} else { |
||||||
|
// buffers all backed-up, drop char
|
||||||
|
return; |
||||||
|
} |
||||||
|
} |
||||||
|
// we do not have a buffer (either didn't have one or sent it off)
|
||||||
|
// allocate one
|
||||||
|
tci->txBuf = os_malloc(MAX_TXBUF); |
||||||
|
tci->txBufLen = 0; |
||||||
|
if (tci->txBuf != NULL) { |
||||||
|
tci->txBuf[tci->txBufLen++] = c; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
void ICACHE_FLASH_ATTR |
||||||
|
tcpClientSendPush(uint8_t chan) { |
||||||
|
TcpConn *tci = tcpConn+chan; |
||||||
|
if (tci->state != TCP_data) return; // no active connection on this channel
|
||||||
|
if (tci->txBuf == NULL || tci->txBufLen == 0) return; // no chars accumulated to send
|
||||||
|
if (tci->txBufSent != NULL) return; // already got a send in progress
|
||||||
|
tcpDoSend(tci); |
||||||
|
} |
||||||
|
|
||||||
|
//===== Command parsing
|
||||||
|
|
||||||
|
// Perform a TCP command: parse the command and do the right thing.
|
||||||
|
// Returns true on success.
|
||||||
|
bool ICACHE_FLASH_ATTR |
||||||
|
tcpClientCommand(uint8_t chan, char cmd, char *cmdBuf) { |
||||||
|
TcpConn *tci; |
||||||
|
char *hostname; |
||||||
|
char *port; |
||||||
|
|
||||||
|
// copy the command so we can modify it
|
||||||
|
char buf[128]; |
||||||
|
os_strncpy(buf, cmdBuf, 128); |
||||||
|
buf[127] = 0; |
||||||
|
|
||||||
|
switch (cmd) { |
||||||
|
//== TCP Connect command
|
||||||
|
case 'T': |
||||||
|
hostname = buf; |
||||||
|
port = hostname; |
||||||
|
while (*port != 0 && *port != ':') port++; |
||||||
|
if (*port != ':') break; |
||||||
|
*port = 0; |
||||||
|
port++; |
||||||
|
int portInt = atoi(port); |
||||||
|
if (portInt < 1 || portInt > 65535) break; |
||||||
|
|
||||||
|
// allocate a connection
|
||||||
|
tci = tcpConnAlloc(chan); |
||||||
|
if (tci == NULL) break; |
||||||
|
tci->state = TCP_dns; |
||||||
|
tci->tcp->remote_port = portInt; |
||||||
|
|
||||||
|
// start the DNS resolution
|
||||||
|
os_printf("TCP %p resolving %s for chan %d (conn=%p)\n", tci, hostname, chan ,tci->conn); |
||||||
|
ip_addr_t ip; |
||||||
|
err_t err = espconn_gethostbyname(tci->conn, hostname, &ip, tcpClientHostnameCb); |
||||||
|
if (err == ESPCONN_OK) { |
||||||
|
// dns cache hit, got the IP address, fake the callback (sigh)
|
||||||
|
os_printf("TCP DNS hit\n"); |
||||||
|
tcpClientHostnameCb(hostname, &ip, tci->conn); |
||||||
|
} else if (err != ESPCONN_INPROGRESS) { |
||||||
|
tcpConnFree(tci); |
||||||
|
break; |
||||||
|
} |
||||||
|
|
||||||
|
return true; |
||||||
|
|
||||||
|
//== TCP Close/disconnect command
|
||||||
|
case 'C': |
||||||
|
os_printf("TCP closing chan %d\n", chan); |
||||||
|
tci = tcpConn+chan; |
||||||
|
if (tci->state > TCP_idle) { |
||||||
|
tci->state = TCP_idle; // hackish...
|
||||||
|
espconn_disconnect(tci->conn); |
||||||
|
} |
||||||
|
break; |
||||||
|
|
||||||
|
} |
||||||
|
return false; |
||||||
|
} |
||||||
|
|
||||||
@ -0,0 +1,78 @@ |
|||||||
|
/*
|
||||||
|
* Copyright (c) 2005, Swedish Institute of Computer Science |
||||||
|
* All rights reserved. |
||||||
|
* |
||||||
|
* Redistribution and use in source and binary forms, with or without |
||||||
|
* modification, are permitted provided that the following conditions |
||||||
|
* are met: |
||||||
|
* 1. Redistributions of source code must retain the above copyright |
||||||
|
* notice, this list of conditions and the following disclaimer. |
||||||
|
* 2. Redistributions in binary form must reproduce the above copyright |
||||||
|
* notice, this list of conditions and the following disclaimer in the |
||||||
|
* documentation and/or other materials provided with the distribution. |
||||||
|
* 3. Neither the name of the Institute nor the names of its contributors |
||||||
|
* may be used to endorse or promote products derived from this software |
||||||
|
* without specific prior written permission. |
||||||
|
* |
||||||
|
* THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND |
||||||
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
||||||
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
||||||
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE |
||||||
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
||||||
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS |
||||||
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
||||||
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT |
||||||
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY |
||||||
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
||||||
|
* SUCH DAMAGE. |
||||||
|
* |
||||||
|
* This file is part of the Contiki operating system. |
||||||
|
* |
||||||
|
*/ |
||||||
|
|
||||||
|
/** \addtogroup crc16
|
||||||
|
* @{ */ |
||||||
|
|
||||||
|
/**
|
||||||
|
* \file |
||||||
|
* Implementation of the CRC16 calculcation |
||||||
|
* \author |
||||||
|
* Adam Dunkels <adam@sics.se> |
||||||
|
* |
||||||
|
*/ |
||||||
|
|
||||||
|
/* CITT CRC16 polynomial ^16 + ^12 + ^5 + 1 */ |
||||||
|
/*---------------------------------------------------------------------------*/ |
||||||
|
unsigned short |
||||||
|
crc16_add(unsigned char b, unsigned short acc) |
||||||
|
{ |
||||||
|
/*
|
||||||
|
acc = (unsigned char)(acc >> 8) | (acc << 8); |
||||||
|
acc ^= b; |
||||||
|
acc ^= (unsigned char)(acc & 0xff) >> 4; |
||||||
|
acc ^= (acc << 8) << 4; |
||||||
|
acc ^= ((acc & 0xff) << 4) << 1; |
||||||
|
*/ |
||||||
|
|
||||||
|
acc ^= b; |
||||||
|
acc = (acc >> 8) | (acc << 8); |
||||||
|
acc ^= (acc & 0xff00) << 4; |
||||||
|
acc ^= (acc >> 8) >> 4; |
||||||
|
acc ^= (acc & 0xff00) >> 5; |
||||||
|
return acc; |
||||||
|
} |
||||||
|
/*---------------------------------------------------------------------------*/ |
||||||
|
unsigned short |
||||||
|
crc16_data(const unsigned char *data, int len, unsigned short acc) |
||||||
|
{ |
||||||
|
int i; |
||||||
|
|
||||||
|
for(i = 0; i < len; ++i) { |
||||||
|
acc = crc16_add(*data, acc); |
||||||
|
++data; |
||||||
|
} |
||||||
|
return acc; |
||||||
|
} |
||||||
|
/*---------------------------------------------------------------------------*/ |
||||||
|
|
||||||
|
/** @} */ |
||||||
@ -0,0 +1,100 @@ |
|||||||
|
/*
|
||||||
|
* Copyright (c) 2005, Swedish Institute of Computer Science |
||||||
|
* All rights reserved. |
||||||
|
* |
||||||
|
* Redistribution and use in source and binary forms, with or without |
||||||
|
* modification, are permitted provided that the following conditions |
||||||
|
* are met: |
||||||
|
* 1. Redistributions of source code must retain the above copyright |
||||||
|
* notice, this list of conditions and the following disclaimer. |
||||||
|
* 2. Redistributions in binary form must reproduce the above copyright |
||||||
|
* notice, this list of conditions and the following disclaimer in the |
||||||
|
* documentation and/or other materials provided with the distribution. |
||||||
|
* 3. Neither the name of the Institute nor the names of its contributors |
||||||
|
* may be used to endorse or promote products derived from this software |
||||||
|
* without specific prior written permission. |
||||||
|
* |
||||||
|
* THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND |
||||||
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
||||||
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
||||||
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE |
||||||
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
||||||
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS |
||||||
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
||||||
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT |
||||||
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY |
||||||
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
||||||
|
* SUCH DAMAGE. |
||||||
|
* |
||||||
|
* This file is part of the Contiki operating system. |
||||||
|
* |
||||||
|
*/ |
||||||
|
|
||||||
|
/**
|
||||||
|
* \file |
||||||
|
* Header file for the CRC16 calculcation |
||||||
|
* \author |
||||||
|
* Adam Dunkels <adam@sics.se> |
||||||
|
* |
||||||
|
*/ |
||||||
|
|
||||||
|
/** \addtogroup lib
|
||||||
|
* @{ */ |
||||||
|
|
||||||
|
/**
|
||||||
|
* \defgroup crc16 Cyclic Redundancy Check 16 (CRC16) calculation |
||||||
|
* |
||||||
|
* The Cyclic Redundancy Check 16 is a hash function that produces a |
||||||
|
* checksum that is used to detect errors in transmissions. The CRC16 |
||||||
|
* calculation module is an iterative CRC calculator that can be used |
||||||
|
* to cumulatively update a CRC checksum for every incoming byte. |
||||||
|
* |
||||||
|
* @{ |
||||||
|
*/ |
||||||
|
|
||||||
|
#ifndef CRC16_H_ |
||||||
|
#define CRC16_H_ |
||||||
|
#ifdef __cplusplus |
||||||
|
extern "C" { |
||||||
|
#endif |
||||||
|
/**
|
||||||
|
* \brief Update an accumulated CRC16 checksum with one byte. |
||||||
|
* \param b The byte to be added to the checksum |
||||||
|
* \param crc The accumulated CRC that is to be updated. |
||||||
|
* \return The updated CRC checksum. |
||||||
|
* |
||||||
|
* This function updates an accumulated CRC16 checksum |
||||||
|
* with one byte. It can be used as a running checksum, or |
||||||
|
* to checksum an entire data block. |
||||||
|
* |
||||||
|
* \note The algorithm used in this implementation is |
||||||
|
* tailored for a running checksum and does not perform as |
||||||
|
* well as a table-driven algorithm when checksumming an |
||||||
|
* entire data block. |
||||||
|
* |
||||||
|
*/ |
||||||
|
unsigned short crc16_add(unsigned char b, unsigned short crc); |
||||||
|
|
||||||
|
/**
|
||||||
|
* \brief Calculate the CRC16 over a data area |
||||||
|
* \param data Pointer to the data |
||||||
|
* \param datalen The length of the data |
||||||
|
* \param acc The accumulated CRC that is to be updated (or zero). |
||||||
|
* \return The CRC16 checksum. |
||||||
|
* |
||||||
|
* This function calculates the CRC16 checksum of a data area. |
||||||
|
* |
||||||
|
* \note The algorithm used in this implementation is |
||||||
|
* tailored for a running checksum and does not perform as |
||||||
|
* well as a table-driven algorithm when checksumming an |
||||||
|
* entire data block. |
||||||
|
*/ |
||||||
|
unsigned short crc16_data(const unsigned char *data, int datalen, |
||||||
|
unsigned short acc); |
||||||
|
#ifdef __cplusplus |
||||||
|
} |
||||||
|
#endif |
||||||
|
#endif /* CRC16_H_ */ |
||||||
|
|
||||||
|
/** @} */ |
||||||
|
/** @} */ |
||||||
@ -0,0 +1,136 @@ |
|||||||
|
// Copyright 2015 by Thorsten von Eicken, see LICENSE.txt
|
||||||
|
|
||||||
|
#include "esp8266.h" |
||||||
|
#include "uart.h" |
||||||
|
#include "crc16.h" |
||||||
|
#include "serbridge.h" |
||||||
|
#include "serled.h" |
||||||
|
#include "console.h" |
||||||
|
#include "cmd.h" |
||||||
|
|
||||||
|
uint8_t slip_disabled; // disable slip to allow flashing of attached MCU
|
||||||
|
|
||||||
|
extern void ICACHE_FLASH_ATTR console_process(char *buf, short len); |
||||||
|
|
||||||
|
// This SLIP parser does not conform to RFC 1055 https://tools.ietf.org/html/rfc1055,
|
||||||
|
// instead, it implements the framing implemented in https://github.com/tuanpmt/esp_bridge
|
||||||
|
// It accumulates each packet into a static buffer and calls cmd_parse() when the end
|
||||||
|
// of a packet is reached. It expects cmd_parse() to copy anything it needs from the
|
||||||
|
// buffer elsewhere as the buffer is immediately reused.
|
||||||
|
// One special feature is that if the first two characters of a packet are both printable or
|
||||||
|
// \n or \r then the parser assumes it's dealing with console debug output and calls
|
||||||
|
// slip_console(c) for each character and does not accumulate chars in the buffer until the
|
||||||
|
// next SLIP_END marker is seen. This allows random console debug output to come in between
|
||||||
|
// packets as long as each packet starts *and* ends with SLIP_END (which is an official
|
||||||
|
// variation on the SLIP protocol).
|
||||||
|
|
||||||
|
static bool slip_escaped; // true when prev char received is escape
|
||||||
|
static bool slip_inpkt; // true when we're after SLIP_START and before SLIP_END
|
||||||
|
#define SLIP_MAX 1024 // max length of SLIP packet
|
||||||
|
static char slip_buf[SLIP_MAX]; // buffer for current SLIP packet
|
||||||
|
static short slip_len; // accumulated length in slip_buf
|
||||||
|
|
||||||
|
// SLIP process a packet or a bunch of debug console chars
|
||||||
|
static void ICACHE_FLASH_ATTR |
||||||
|
slip_process() { |
||||||
|
if (slip_len < 1) return; |
||||||
|
|
||||||
|
if (!slip_inpkt) { |
||||||
|
// debug console stuff
|
||||||
|
console_process(slip_buf, slip_len); |
||||||
|
} else { |
||||||
|
// proper SLIP packet, invoke command processor after checking CRC
|
||||||
|
//os_printf("SLIP: rcv %d\n", slip_len);
|
||||||
|
if (slip_len > 2) { |
||||||
|
uint16_t crc = crc16_data((uint8_t*)slip_buf, slip_len-2, 0); |
||||||
|
uint16_t rcv = ((uint16_t)slip_buf[slip_len-2]) | ((uint16_t)slip_buf[slip_len-1] << 8); |
||||||
|
if (crc == rcv) { |
||||||
|
CMD_parse_packet((uint8_t*)slip_buf, slip_len-2); |
||||||
|
} else { |
||||||
|
os_printf("SLIP: bad CRC, crc=%x rcv=%x\n", crc, rcv); |
||||||
|
for (short i=0; i<slip_len; i++) { |
||||||
|
if (slip_buf[i] >= ' ' && slip_buf[i] <= '~') |
||||||
|
os_printf("%c", slip_buf[i]); |
||||||
|
else |
||||||
|
os_printf("\\%02X", slip_buf[i]); |
||||||
|
} |
||||||
|
os_printf("\n"); |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
#if 0 |
||||||
|
// determine whether a character is printable or not (or \r \n)
|
||||||
|
static bool ICACHE_FLASH_ATTR |
||||||
|
slip_printable(char c) { |
||||||
|
return (c >= ' ' && c <= '~') || c == '\n' || c == '\r'; |
||||||
|
} |
||||||
|
#endif |
||||||
|
|
||||||
|
static void ICACHE_FLASH_ATTR |
||||||
|
slip_reset() { |
||||||
|
slip_inpkt = false; |
||||||
|
slip_escaped = false; |
||||||
|
slip_len = 0; |
||||||
|
} |
||||||
|
|
||||||
|
// SLIP parse a single character
|
||||||
|
static void ICACHE_FLASH_ATTR |
||||||
|
slip_parse_char(char c) { |
||||||
|
if (!slip_inpkt) { |
||||||
|
if (c == SLIP_START) { |
||||||
|
if (slip_len > 0) console_process(slip_buf, slip_len); |
||||||
|
slip_reset(); |
||||||
|
slip_inpkt = true; |
||||||
|
return; |
||||||
|
} |
||||||
|
} else if (slip_escaped) { |
||||||
|
// prev char was SLIP_REPL
|
||||||
|
c = SLIP_ESC(c); |
||||||
|
slip_escaped = false; |
||||||
|
} else { |
||||||
|
switch (c) { |
||||||
|
case SLIP_REPL: |
||||||
|
slip_escaped = true; |
||||||
|
return; |
||||||
|
case SLIP_END: |
||||||
|
// end of packet, process it and get ready for next one
|
||||||
|
if (slip_len > 0) slip_process(); |
||||||
|
slip_reset(); |
||||||
|
return; |
||||||
|
case SLIP_START: |
||||||
|
os_printf("SLIP: got SLIP_START while in packet?\n"); |
||||||
|
slip_reset(); |
||||||
|
return; |
||||||
|
} |
||||||
|
} |
||||||
|
if (slip_len < SLIP_MAX) slip_buf[slip_len++] = c; |
||||||
|
} |
||||||
|
|
||||||
|
// callback with a buffer of characters that have arrived on the uart
|
||||||
|
void ICACHE_FLASH_ATTR |
||||||
|
serbridgeUartCb(char *buf, short length) { |
||||||
|
if (slip_disabled > 0) { |
||||||
|
//os_printf("SLIP: disabled got %d\n", length);
|
||||||
|
console_process(buf, length); |
||||||
|
for (short i=0; i<length; i++) |
||||||
|
if (buf[i] == SLIP_START) { |
||||||
|
os_printf("SLIP: START while disabled=%d\n", slip_disabled); |
||||||
|
break; |
||||||
|
} |
||||||
|
return; |
||||||
|
} |
||||||
|
|
||||||
|
// do SLIP parsing
|
||||||
|
for (short i=0; i<length; i++) |
||||||
|
slip_parse_char(buf[i]); |
||||||
|
|
||||||
|
// if we're in-between packets (debug console) then print it now
|
||||||
|
if (!slip_inpkt && length > 0) { |
||||||
|
slip_process(); |
||||||
|
slip_reset(); |
||||||
|
} |
||||||
|
|
||||||
|
serledFlash(50); // short blink on serial LED
|
||||||
|
} |
||||||
@ -1,315 +0,0 @@ |
|||||||
// Copyright 2015 by Thorsten von Eicken, see LICENSE.txt
|
|
||||||
//
|
|
||||||
// TCP client library allowing uControllers attached to the serial port to send commands
|
|
||||||
// to open/close TCP connections and send/recv data.
|
|
||||||
// The serial protocol is described in https://gist.github.com/tve/a46c44bf1f6b42bc572e
|
|
||||||
|
|
||||||
#include <esp8266.h> |
|
||||||
#include "config.h" |
|
||||||
#include "uart.h" |
|
||||||
#include "serled.h" |
|
||||||
#include "tcpclient.h" |
|
||||||
|
|
||||||
// max number of channels the client can open
|
|
||||||
#define MAX_CHAN MAX_TCP_CHAN |
|
||||||
// size of tx buffer
|
|
||||||
#define MAX_TXBUF 1024 |
|
||||||
|
|
||||||
enum TcpState { |
|
||||||
TCP_idle, // unused connection
|
|
||||||
TCP_dns, // doing gethostbyname
|
|
||||||
TCP_conn, // connecting to remote server
|
|
||||||
TCP_data, // connected
|
|
||||||
}; |
|
||||||
|
|
||||||
// Connections
|
|
||||||
typedef struct { |
|
||||||
struct espconn *conn; // esp connection structure
|
|
||||||
esp_tcp *tcp; // esp TCP parameters
|
|
||||||
char *txBuf; // buffer to accumulate into
|
|
||||||
char *txBufSent; // buffer held by espconn
|
|
||||||
uint8_t txBufLen; // number of chars in txbuf
|
|
||||||
enum TcpState state; |
|
||||||
} TcpConn; |
|
||||||
|
|
||||||
static TcpConn tcpConn[MAX_CHAN]; |
|
||||||
|
|
||||||
// forward declarations
|
|
||||||
static void tcpConnFree(TcpConn* tci); |
|
||||||
static TcpConn* tcpConnAlloc(uint8_t chan); |
|
||||||
static void tcpDoSend(TcpConn *tci); |
|
||||||
static void tcpConnectCb(void *arg); |
|
||||||
static void tcpDisconCb(void *arg); |
|
||||||
static void tcpResetCb(void *arg, sint8 err); |
|
||||||
static void tcpSentCb(void *arg); |
|
||||||
static void tcpRecvCb(void *arg, char *data, uint16_t len); |
|
||||||
|
|
||||||
//===== allocate / free connections
|
|
||||||
|
|
||||||
// Allocate a new connection dynamically and return it. Returns NULL if buf alloc failed
|
|
||||||
static TcpConn* ICACHE_FLASH_ATTR |
|
||||||
tcpConnAlloc(uint8_t chan) { |
|
||||||
TcpConn *tci = tcpConn+chan; |
|
||||||
if (tci->state != TCP_idle && tci->conn != NULL) return tci; |
|
||||||
|
|
||||||
// malloc and return espconn struct
|
|
||||||
tci->conn = os_malloc(sizeof(struct espconn)); |
|
||||||
if (tci->conn == NULL) goto fail; |
|
||||||
memset(tci->conn, 0, sizeof(struct espconn)); |
|
||||||
// malloc esp_tcp struct
|
|
||||||
tci->tcp = os_malloc(sizeof(esp_tcp)); |
|
||||||
if (tci->tcp == NULL) goto fail; |
|
||||||
memset(tci->tcp, 0, sizeof(esp_tcp)); |
|
||||||
|
|
||||||
// common init
|
|
||||||
tci->state = TCP_dns; |
|
||||||
tci->conn->type = ESPCONN_TCP; |
|
||||||
tci->conn->state = ESPCONN_NONE; |
|
||||||
tci->conn->proto.tcp = tci->tcp; |
|
||||||
tci->tcp->remote_port = 80; |
|
||||||
espconn_regist_connectcb(tci->conn, tcpConnectCb); |
|
||||||
espconn_regist_reconcb(tci->conn, tcpResetCb); |
|
||||||
espconn_regist_sentcb(tci->conn, tcpSentCb); |
|
||||||
espconn_regist_recvcb(tci->conn, tcpRecvCb); |
|
||||||
espconn_regist_disconcb(tci->conn, tcpDisconCb); |
|
||||||
tci->conn->reverse = tci; |
|
||||||
|
|
||||||
return tci; |
|
||||||
|
|
||||||
fail: |
|
||||||
tcpConnFree(tci); |
|
||||||
return NULL; |
|
||||||
} |
|
||||||
|
|
||||||
// Free a connection dynamically.
|
|
||||||
static void ICACHE_FLASH_ATTR |
|
||||||
tcpConnFree(TcpConn* tci) { |
|
||||||
if (tci->conn != NULL) os_free(tci->conn); |
|
||||||
if (tci->tcp != NULL) os_free(tci->tcp); |
|
||||||
if (tci->txBuf != NULL) os_free(tci->txBuf); |
|
||||||
if (tci->txBufSent != NULL) os_free(tci->txBufSent); |
|
||||||
memset(tci, 0, sizeof(TcpConn)); |
|
||||||
} |
|
||||||
|
|
||||||
//===== DNS
|
|
||||||
|
|
||||||
// DNS name resolution callback
|
|
||||||
static void ICACHE_FLASH_ATTR |
|
||||||
tcpClientHostnameCb(const char *name, ip_addr_t *ipaddr, void *arg) { |
|
||||||
struct espconn *conn = arg; |
|
||||||
TcpConn *tci = conn->reverse; |
|
||||||
os_printf("TCP dns CB (%p %p)\n", arg, tci); |
|
||||||
if (ipaddr == NULL) { |
|
||||||
os_printf("TCP %s not found\n", name); |
|
||||||
} else { |
|
||||||
os_printf("TCP %s -> %d.%d.%d.%d\n", name, IP2STR(ipaddr)); |
|
||||||
tci->tcp->remote_ip[0] = ip4_addr1(ipaddr); |
|
||||||
tci->tcp->remote_ip[1] = ip4_addr2(ipaddr); |
|
||||||
tci->tcp->remote_ip[2] = ip4_addr3(ipaddr); |
|
||||||
tci->tcp->remote_ip[3] = ip4_addr4(ipaddr); |
|
||||||
os_printf("TCP connect %d.%d.%d.%d (%p)\n", IP2STR(tci->tcp->remote_ip), tci); |
|
||||||
if (espconn_connect(tci->conn) == ESPCONN_OK) { |
|
||||||
tci->state = TCP_conn; |
|
||||||
return; |
|
||||||
} |
|
||||||
os_printf("TCP connect failure\n"); |
|
||||||
} |
|
||||||
// oops
|
|
||||||
tcpConnFree(tci); |
|
||||||
} |
|
||||||
|
|
||||||
//===== Connect / disconnect
|
|
||||||
|
|
||||||
// Connected callback
|
|
||||||
static void ICACHE_FLASH_ATTR |
|
||||||
tcpConnectCb(void *arg) { |
|
||||||
struct espconn *conn = arg; |
|
||||||
TcpConn *tci = conn->reverse; |
|
||||||
os_printf("TCP connect CB (%p %p)\n", arg, tci); |
|
||||||
tci->state = TCP_data; |
|
||||||
// send any buffered data
|
|
||||||
if (tci->txBuf != NULL && tci->txBufLen > 0) tcpDoSend(tci); |
|
||||||
// reply to serial
|
|
||||||
char buf[6]; |
|
||||||
short l = os_sprintf(buf, "\n~@%dC\n", tci-tcpConn); |
|
||||||
uart0_tx_buffer(buf, l); |
|
||||||
} |
|
||||||
|
|
||||||
// Disconnect callback
|
|
||||||
static void ICACHE_FLASH_ATTR tcpDisconCb(void *arg) { |
|
||||||
struct espconn *conn = arg; |
|
||||||
TcpConn *tci = conn->reverse; |
|
||||||
os_printf("TCP disconnect CB (%p %p)\n", arg, tci); |
|
||||||
// notify to serial
|
|
||||||
char buf[6]; |
|
||||||
short l = os_sprintf(buf, "\n~@%dZ\n", tci-tcpConn); |
|
||||||
uart0_tx_buffer(buf, l); |
|
||||||
// free
|
|
||||||
tcpConnFree(tci); |
|
||||||
} |
|
||||||
|
|
||||||
// Connection reset callback
|
|
||||||
static void ICACHE_FLASH_ATTR tcpResetCb(void *arg, sint8 err) { |
|
||||||
struct espconn *conn = arg; |
|
||||||
TcpConn *tci = conn->reverse; |
|
||||||
os_printf("TCP reset CB (%p %p) err=%d\n", arg, tci, err); |
|
||||||
// notify to serial
|
|
||||||
char buf[6]; |
|
||||||
short l = os_sprintf(buf, "\n~@%dZ\n", tci-tcpConn); |
|
||||||
uart0_tx_buffer(buf, l); |
|
||||||
// free
|
|
||||||
tcpConnFree(tci); |
|
||||||
} |
|
||||||
|
|
||||||
//===== Sending and receiving
|
|
||||||
|
|
||||||
// Send the next buffer (assumes that the connection is in a state that allows it)
|
|
||||||
static void ICACHE_FLASH_ATTR |
|
||||||
tcpDoSend(TcpConn *tci) { |
|
||||||
sint8 err = espconn_sent(tci->conn, (uint8*)tci->txBuf, tci->txBufLen); |
|
||||||
if (err == ESPCONN_OK) { |
|
||||||
// send successful
|
|
||||||
os_printf("TCP sent (%p %p)\n", tci->conn, tci); |
|
||||||
tci->txBuf[tci->txBufLen] = 0; os_printf("TCP data: %s\n", tci->txBuf); |
|
||||||
tci->txBufSent = tci->txBuf; |
|
||||||
tci->txBuf = NULL; |
|
||||||
tci->txBufLen = 0; |
|
||||||
} else { |
|
||||||
// send error, leave as-is and try again later...
|
|
||||||
os_printf("TCP send err (%p %p) %d\n", tci->conn, tci, err); |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
// Sent callback
|
|
||||||
static void ICACHE_FLASH_ATTR |
|
||||||
tcpSentCb(void *arg) { |
|
||||||
struct espconn *conn = arg; |
|
||||||
TcpConn *tci = conn->reverse; |
|
||||||
os_printf("TCP sent CB (%p %p)\n", arg, tci); |
|
||||||
if (tci->txBufSent != NULL) os_free(tci->txBufSent); |
|
||||||
tci->txBufSent = NULL; |
|
||||||
|
|
||||||
if (tci->txBuf != NULL && tci->txBufLen == MAX_TXBUF) { |
|
||||||
// next buffer is full, send it now
|
|
||||||
tcpDoSend(tci); |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
// Recv callback
|
|
||||||
static void ICACHE_FLASH_ATTR tcpRecvCb(void *arg, char *data, uint16_t len) { |
|
||||||
struct espconn *conn = arg; |
|
||||||
TcpConn *tci = conn->reverse; |
|
||||||
os_printf("TCP recv CB (%p %p)\n", arg, tci); |
|
||||||
if (tci->state == TCP_data) { |
|
||||||
uint8_t chan; |
|
||||||
for (chan=0; chan<MAX_CHAN && tcpConn+chan!=tci; chan++) |
|
||||||
if (chan >= MAX_CHAN) return; // oops!?
|
|
||||||
char buf[6]; |
|
||||||
short l = os_sprintf(buf, "\n~%d", chan); |
|
||||||
uart0_tx_buffer(buf, l); |
|
||||||
uart0_tx_buffer(data, len); |
|
||||||
uart0_tx_buffer("\0\n", 2); |
|
||||||
} |
|
||||||
serledFlash(50); // short blink on serial LED
|
|
||||||
} |
|
||||||
|
|
||||||
void ICACHE_FLASH_ATTR |
|
||||||
tcpClientSendChar(uint8_t chan, char c) { |
|
||||||
TcpConn *tci = tcpConn+chan; |
|
||||||
if (tci->state == TCP_idle) return; |
|
||||||
|
|
||||||
if (tci->txBuf != NULL) { |
|
||||||
// we have a buffer
|
|
||||||
if (tci->txBufLen < MAX_TXBUF) { |
|
||||||
// buffer has space, add char and return
|
|
||||||
tci->txBuf[tci->txBufLen++] = c; |
|
||||||
return; |
|
||||||
} else if (tci->txBufSent == NULL) { |
|
||||||
// we don't have a send pending, send full buffer off
|
|
||||||
if (tci->state == TCP_data) tcpDoSend(tci); |
|
||||||
if (tci->txBuf != NULL) return; // something went wrong
|
|
||||||
} else { |
|
||||||
// buffers all backed-up, drop char
|
|
||||||
return; |
|
||||||
} |
|
||||||
} |
|
||||||
// we do not have a buffer (either didn't have one or sent it off)
|
|
||||||
// allocate one
|
|
||||||
tci->txBuf = os_malloc(MAX_TXBUF); |
|
||||||
tci->txBufLen = 0; |
|
||||||
if (tci->txBuf != NULL) { |
|
||||||
tci->txBuf[tci->txBufLen++] = c; |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
void ICACHE_FLASH_ATTR |
|
||||||
tcpClientSendPush(uint8_t chan) { |
|
||||||
TcpConn *tci = tcpConn+chan; |
|
||||||
if (tci->state != TCP_data) return; // no active connection on this channel
|
|
||||||
if (tci->txBuf == NULL || tci->txBufLen == 0) return; // no chars accumulated to send
|
|
||||||
if (tci->txBufSent != NULL) return; // already got a send in progress
|
|
||||||
tcpDoSend(tci); |
|
||||||
} |
|
||||||
|
|
||||||
//===== Command parsing
|
|
||||||
|
|
||||||
// Perform a TCP command: parse the command and do the right thing.
|
|
||||||
// Returns true on success.
|
|
||||||
bool ICACHE_FLASH_ATTR |
|
||||||
tcpClientCommand(uint8_t chan, char cmd, char *cmdBuf) { |
|
||||||
TcpConn *tci; |
|
||||||
char *hostname; |
|
||||||
char *port; |
|
||||||
|
|
||||||
// copy the command so we can modify it
|
|
||||||
char buf[128]; |
|
||||||
os_strncpy(buf, cmdBuf, 128); |
|
||||||
buf[127] = 0; |
|
||||||
|
|
||||||
switch (cmd) { |
|
||||||
//== TCP Connect command
|
|
||||||
case 'T': |
|
||||||
hostname = buf; |
|
||||||
port = hostname; |
|
||||||
while (*port != 0 && *port != ':') port++; |
|
||||||
if (*port != ':') break; |
|
||||||
*port = 0; |
|
||||||
port++; |
|
||||||
int portInt = atoi(port); |
|
||||||
if (portInt < 1 || portInt > 65535) break; |
|
||||||
|
|
||||||
// allocate a connection
|
|
||||||
tci = tcpConnAlloc(chan); |
|
||||||
if (tci == NULL) break; |
|
||||||
tci->state = TCP_dns; |
|
||||||
tci->tcp->remote_port = portInt; |
|
||||||
|
|
||||||
// start the DNS resolution
|
|
||||||
os_printf("TCP %p resolving %s for chan %d (conn=%p)\n", tci, hostname, chan ,tci->conn); |
|
||||||
ip_addr_t ip; |
|
||||||
err_t err = espconn_gethostbyname(tci->conn, hostname, &ip, tcpClientHostnameCb); |
|
||||||
if (err == ESPCONN_OK) { |
|
||||||
// dns cache hit, got the IP address, fake the callback (sigh)
|
|
||||||
os_printf("TCP DNS hit\n"); |
|
||||||
tcpClientHostnameCb(hostname, &ip, tci->conn); |
|
||||||
} else if (err != ESPCONN_INPROGRESS) { |
|
||||||
tcpConnFree(tci); |
|
||||||
break; |
|
||||||
} |
|
||||||
|
|
||||||
return true; |
|
||||||
|
|
||||||
//== TCP Close/disconnect command
|
|
||||||
case 'C': |
|
||||||
os_printf("TCP closing chan %d\n", chan); |
|
||||||
tci = tcpConn+chan; |
|
||||||
if (tci->state > TCP_idle) { |
|
||||||
tci->state = TCP_idle; // hackish...
|
|
||||||
espconn_disconnect(tci->conn); |
|
||||||
} |
|
||||||
break; |
|
||||||
|
|
||||||
} |
|
||||||
return false; |
|
||||||
} |
|
||||||
|
|
||||||
Loading…
Reference in new issue