mirror of https://github.com/jeelabs/esp-link.git
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
489 lines
12 KiB
489 lines
12 KiB
#include "web-server.h"
|
|
|
|
#include <espconn.h>
|
|
|
|
#include "espfs.h"
|
|
#include "config.h"
|
|
#include "cgi.h"
|
|
#include "cmd.h"
|
|
#include "serbridge.h"
|
|
|
|
// the file is responsible for handling user defined web-pages
|
|
// - collects HTML files from user image, shows them on the left frame
|
|
// - handles JSON data coming from the browser
|
|
// - handles SLIP messages coming from MCU
|
|
|
|
#define MAX_ARGUMENT_BUFFER_SIZE 128
|
|
#define HEADER_SIZE 32
|
|
|
|
uint32_t web_server_cb = 0;
|
|
|
|
struct ArgumentBuffer
|
|
{
|
|
char argBuffer[MAX_ARGUMENT_BUFFER_SIZE];
|
|
int argBufferPtr;
|
|
int numberOfArgs;
|
|
};
|
|
|
|
static char* web_server_reasons[] = {
|
|
"load", // readable name for RequestReason::LOAD
|
|
"refresh", // readable name for RequestReason::REFRESH
|
|
"button", // readable name for RequestReason::BUTTON
|
|
"submit" // readable name for RequestReason::SUBMIT
|
|
};
|
|
|
|
// this variable contains the names of the user defined pages
|
|
// this information appears at the left frame below of the built in URL-s
|
|
// format: ,"UserPage1", "/UserPage1.html", "UserPage2", "/UserPage2.html",
|
|
char * webServerPages = NULL;
|
|
|
|
char * ICACHE_FLASH_ATTR WEB_UserPages()
|
|
{
|
|
return webServerPages;
|
|
}
|
|
|
|
// generates the content of webServerPages variable (called at booting/web page uploading)
|
|
void ICACHE_FLASH_ATTR WEB_BrowseFiles()
|
|
{
|
|
char buffer[1024];
|
|
buffer[0] = 0;
|
|
|
|
if( espFsIsValid( userPageCtx ) )
|
|
{
|
|
EspFsIterator it;
|
|
espFsIteratorInit(userPageCtx, &it);
|
|
while( espFsIteratorNext(&it) )
|
|
{
|
|
int nameLen = os_strlen(it.name);
|
|
if( nameLen >= 6 )
|
|
{
|
|
// fetch HTML files
|
|
if( os_strcmp( it.name + nameLen-5, ".html" ) == 0 )
|
|
{
|
|
int slashPos = nameLen - 5;
|
|
|
|
// chop path and .html from the name
|
|
while( slashPos > 0 && it.name[slashPos-1] != '/' )
|
|
slashPos--;
|
|
|
|
// here we check buffer overrun
|
|
int maxLen = 10 + os_strlen( it.name ) + (nameLen - slashPos -5);
|
|
if( maxLen >= sizeof(buffer) )
|
|
break;
|
|
|
|
os_strcat(buffer, ", \"");
|
|
|
|
int writePos = os_strlen(buffer);
|
|
for( int i=slashPos; i < nameLen-5; i++ )
|
|
buffer[writePos++] = it.name[i];
|
|
buffer[writePos] = 0; // terminating zero
|
|
|
|
os_strcat(buffer, "\", \"/");
|
|
os_strcat(buffer, it.name);
|
|
os_strcat(buffer, "\"");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if( webServerPages != NULL )
|
|
os_free( webServerPages );
|
|
|
|
int len = os_strlen(buffer) + 1;
|
|
webServerPages = (char *)os_malloc( len );
|
|
os_memcpy( webServerPages, buffer, len );
|
|
}
|
|
|
|
// initializer
|
|
void ICACHE_FLASH_ATTR WEB_Init()
|
|
{
|
|
espFsInit(userPageCtx, (void *)getUserPageSectionStart(), ESPFS_FLASH);
|
|
if( espFsIsValid( userPageCtx ) )
|
|
os_printf("Valid user file system found!\n");
|
|
else
|
|
os_printf("No user file system found!\n");
|
|
WEB_BrowseFiles(); // collect user defined HTML files
|
|
}
|
|
|
|
// initializes the argument buffer
|
|
static void ICACHE_FLASH_ATTR WEB_argInit(struct ArgumentBuffer * argBuffer)
|
|
{
|
|
argBuffer->numberOfArgs = 0;
|
|
argBuffer->argBufferPtr = 0;
|
|
}
|
|
|
|
// adds an argument to the argument buffer (returns 0 if successful)
|
|
static int ICACHE_FLASH_ATTR WEB_addArg(struct ArgumentBuffer * argBuffer, char * arg, int argLen )
|
|
{
|
|
if( argBuffer->argBufferPtr + argLen + sizeof(int) >= MAX_ARGUMENT_BUFFER_SIZE )
|
|
return -1; // buffer overflow
|
|
|
|
os_memcpy(argBuffer->argBuffer + argBuffer->argBufferPtr, &argLen, sizeof(int));
|
|
|
|
if( argLen != 0 )
|
|
{
|
|
os_memcpy( argBuffer->argBuffer + argBuffer->argBufferPtr + sizeof(int), arg, argLen );
|
|
argBuffer->numberOfArgs++;
|
|
}
|
|
|
|
argBuffer->argBufferPtr += argLen + sizeof(int);
|
|
return 0;
|
|
}
|
|
|
|
// creates and sends a SLIP message from the argument buffer
|
|
static void ICACHE_FLASH_ATTR WEB_sendArgBuffer(struct ArgumentBuffer * argBuffer, HttpdConnData *connData, RequestReason reason)
|
|
{
|
|
cmdResponseStart(CMD_RESP_CB, web_server_cb, 4 + argBuffer->numberOfArgs);
|
|
uint16_t r = (uint16_t)reason;
|
|
cmdResponseBody(&r, sizeof(uint16_t)); // 1st argument: reason
|
|
cmdResponseBody(&connData->conn->proto.tcp->remote_ip, 4); // 2nd argument: IP
|
|
cmdResponseBody(&connData->conn->proto.tcp->remote_port, sizeof(uint16_t)); // 3rd argument: port
|
|
cmdResponseBody(connData->url, os_strlen(connData->url)); // 4th argument: URL
|
|
|
|
int p = 0;
|
|
for( int j=0; j < argBuffer->numberOfArgs; j++ )
|
|
{
|
|
int argLen;
|
|
os_memcpy( &argLen, argBuffer->argBuffer + p, sizeof(int) );
|
|
|
|
char * arg = argBuffer->argBuffer + p + sizeof(int);
|
|
cmdResponseBody(arg, argLen);
|
|
p += argLen + sizeof(int);
|
|
}
|
|
|
|
cmdResponseEnd();
|
|
}
|
|
|
|
// this method processes SLIP data from MCU and converts to JSON
|
|
// this method receives JSON from the browser, sends SLIP data to MCU
|
|
static int ICACHE_FLASH_ATTR WEB_handleJSONRequest(HttpdConnData *connData)
|
|
{
|
|
if( !flashConfig.slip_enable )
|
|
{
|
|
errorResponse(connData, 400, "Slip processing is disabled!");
|
|
return HTTPD_CGI_DONE;
|
|
}
|
|
|
|
if( web_server_cb == 0 )
|
|
{
|
|
errorResponse(connData, 500, "No MCU callback is registered!");
|
|
return HTTPD_CGI_DONE;
|
|
}
|
|
if( serbridgeInMCUFlashing() )
|
|
{
|
|
errorResponse(connData, 500, "Slip disabled at uploading program onto the MCU!");
|
|
return HTTPD_CGI_DONE;
|
|
}
|
|
|
|
char reasonBuf[16];
|
|
int i;
|
|
int len = httpdFindArg(connData->getArgs, "reason", reasonBuf, sizeof(reasonBuf));
|
|
if( len < 0 )
|
|
{
|
|
errorResponse(connData, 400, "No reason specified!");
|
|
return HTTPD_CGI_DONE;
|
|
}
|
|
|
|
RequestReason reason = INVALID;
|
|
for(i=0; i < sizeof(web_server_reasons)/sizeof(char *); i++)
|
|
{
|
|
if( os_strcmp( web_server_reasons[i], reasonBuf ) == 0 )
|
|
reason = (RequestReason)i;
|
|
}
|
|
|
|
if( reason == INVALID )
|
|
{
|
|
errorResponse(connData, 400, "Invalid reason!");
|
|
return HTTPD_CGI_DONE;
|
|
}
|
|
|
|
struct ArgumentBuffer argBuffer;
|
|
WEB_argInit( &argBuffer );
|
|
|
|
switch(reason)
|
|
{
|
|
case BUTTON:
|
|
{
|
|
char id_buf[40];
|
|
|
|
int id_len = httpdFindArg(connData->getArgs, "id", id_buf, sizeof(id_buf));
|
|
if( id_len <= 0 )
|
|
{
|
|
errorResponse(connData, 400, "No button ID specified!");
|
|
return HTTPD_CGI_DONE;
|
|
}
|
|
if( WEB_addArg(&argBuffer, id_buf, id_len) )
|
|
{
|
|
errorResponse(connData, 400, "Post too large!");
|
|
return HTTPD_CGI_DONE;
|
|
}
|
|
}
|
|
break;
|
|
case SUBMIT:
|
|
{
|
|
if( connData->post->received < connData->post->len )
|
|
{
|
|
errorResponse(connData, 400, "Post too large!");
|
|
return HTTPD_CGI_DONE;
|
|
}
|
|
|
|
int bptr = 0;
|
|
int sent_args = 0;
|
|
int max_buf_size = MAX_ARGUMENT_BUFFER_SIZE - HEADER_SIZE - os_strlen(connData->url);
|
|
|
|
while( bptr < connData->post->len )
|
|
{
|
|
char * line = connData->post->buff + bptr;
|
|
|
|
char * eo = os_strchr(line, '&' );
|
|
if( eo != NULL )
|
|
{
|
|
*eo = 0;
|
|
bptr = eo - connData->post->buff + 1;
|
|
}
|
|
else
|
|
{
|
|
eo = line + os_strlen( line );
|
|
bptr = connData->post->len;
|
|
}
|
|
|
|
int len = os_strlen(line);
|
|
while( len >= 1 && ( line[len-1] == '\r' || line[len-1] == '\n' ))
|
|
len--;
|
|
line[len] = 0;
|
|
|
|
char * val = os_strchr(line, '=');
|
|
if( val != NULL )
|
|
{
|
|
*val = 0;
|
|
char * name = line;
|
|
int vblen = os_strlen(val+1) * 2;
|
|
char value[vblen];
|
|
httpdUrlDecode(val+1, strlen(val+1), value, vblen);
|
|
|
|
int namLen = os_strlen(name);
|
|
int valLen = os_strlen(value);
|
|
|
|
char arg[namLen + valLen + 3];
|
|
int argPtr = 0;
|
|
arg[argPtr++] = (char)WEB_STRING;
|
|
os_strcpy( arg + argPtr, name );
|
|
argPtr += namLen;
|
|
arg[argPtr++] = 0;
|
|
os_strcpy( arg + argPtr, value );
|
|
argPtr += valLen;
|
|
|
|
if( sent_args != 0 )
|
|
{
|
|
if( argBuffer.argBufferPtr + argPtr >= max_buf_size )
|
|
{
|
|
WEB_addArg(&argBuffer, NULL, 0); // there's enough room in the buffer for termination block
|
|
WEB_sendArgBuffer(&argBuffer, connData, reason );
|
|
WEB_argInit( &argBuffer );
|
|
sent_args = 0;
|
|
}
|
|
}
|
|
|
|
if( WEB_addArg(&argBuffer, arg, argPtr) )
|
|
{
|
|
errorResponse(connData, 400, "Post too large!");
|
|
return HTTPD_CGI_DONE;
|
|
}
|
|
sent_args++;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
case LOAD:
|
|
case REFRESH:
|
|
default:
|
|
break;
|
|
}
|
|
|
|
if( WEB_addArg(&argBuffer, NULL, 0) )
|
|
{
|
|
errorResponse(connData, 400, "Post too large!");
|
|
return HTTPD_CGI_DONE;
|
|
}
|
|
|
|
os_printf("Web callback to MCU: %s\n", reasonBuf);
|
|
|
|
WEB_sendArgBuffer(&argBuffer, connData, reason );
|
|
|
|
if( reason == SUBMIT )
|
|
{
|
|
httpdStartResponse(connData, 204);
|
|
httpdEndHeaders(connData);
|
|
return HTTPD_CGI_DONE;
|
|
}
|
|
|
|
return HTTPD_CGI_MORE;
|
|
}
|
|
|
|
// this method receives SLIP data from MCU sends JSON to the browser
|
|
static int ICACHE_FLASH_ATTR WEB_handleMCUResponse(HttpdConnData *connData, CmdRequest * response)
|
|
{
|
|
char jsonBuf[1500];
|
|
int jsonPtr = 0;
|
|
|
|
|
|
jsonBuf[jsonPtr++] = '{';
|
|
|
|
int c = 2;
|
|
while( c++ < cmdGetArgc(response) )
|
|
{
|
|
int len = cmdArgLen(response);
|
|
char buf[len+1];
|
|
buf[len] = 0;
|
|
|
|
cmdPopArg(response, buf, len);
|
|
|
|
if(len == 0)
|
|
break; // last argument
|
|
|
|
if( c > 3 ) // skip the first argument
|
|
jsonBuf[jsonPtr++] = ',';
|
|
|
|
if( jsonPtr + 20 + len > sizeof(jsonBuf) )
|
|
{
|
|
errorResponse(connData, 500, "Response too large!");
|
|
return HTTPD_CGI_DONE;
|
|
}
|
|
|
|
WebValueType type = (WebValueType)buf[0];
|
|
|
|
int nameLen = os_strlen(buf+1);
|
|
jsonBuf[jsonPtr++] = '"';
|
|
os_memcpy(jsonBuf + jsonPtr, buf + 1, nameLen);
|
|
jsonPtr += nameLen;
|
|
jsonBuf[jsonPtr++] = '"';
|
|
jsonBuf[jsonPtr++] = ':';
|
|
|
|
char * value = buf + 2 + nameLen;
|
|
|
|
switch(type)
|
|
{
|
|
case WEB_NULL:
|
|
os_memcpy(jsonBuf + jsonPtr, "null", 4);
|
|
jsonPtr += 4;
|
|
break;
|
|
case WEB_INTEGER:
|
|
{
|
|
int v;
|
|
os_memcpy( &v, value, 4);
|
|
|
|
char intbuf[20];
|
|
os_sprintf(intbuf, "%d", v);
|
|
os_strcpy(jsonBuf + jsonPtr, intbuf);
|
|
jsonPtr += os_strlen(intbuf);
|
|
}
|
|
break;
|
|
case WEB_BOOLEAN:
|
|
if( *value ) {
|
|
os_memcpy(jsonBuf + jsonPtr, "true", 4);
|
|
jsonPtr += 4;
|
|
} else {
|
|
os_memcpy(jsonBuf + jsonPtr, "false", 5);
|
|
jsonPtr += 5;
|
|
}
|
|
break;
|
|
case WEB_FLOAT:
|
|
{
|
|
float f;
|
|
os_memcpy( &f, value, 4);
|
|
|
|
// os_sprintf doesn't support %f
|
|
int intPart = f;
|
|
int fracPart = (f - intPart) * 1000; // use 3 digit precision
|
|
if( fracPart < 0 ) // for negative numbers
|
|
fracPart = -fracPart;
|
|
|
|
char floatBuf[20];
|
|
os_sprintf(floatBuf, "%d.%03d", intPart, fracPart);
|
|
os_strcpy(jsonBuf + jsonPtr, floatBuf);
|
|
jsonPtr += os_strlen(floatBuf);
|
|
}
|
|
break;
|
|
case WEB_STRING:
|
|
jsonBuf[jsonPtr++] = '"';
|
|
while(*value)
|
|
{
|
|
if( *value == '\\' || *value == '"' )
|
|
jsonBuf[jsonPtr++] = '\\';
|
|
jsonBuf[jsonPtr++] = *(value++);
|
|
}
|
|
jsonBuf[jsonPtr++] = '"';
|
|
break;
|
|
case WEB_JSON:
|
|
os_memcpy(jsonBuf + jsonPtr, value, len - 2 - nameLen);
|
|
jsonPtr += len - 2 - nameLen;
|
|
break;
|
|
}
|
|
}
|
|
|
|
jsonBuf[jsonPtr++] = '}';
|
|
|
|
noCacheHeaders(connData, 200);
|
|
httpdHeader(connData, "Content-Type", "application/json");
|
|
|
|
char cl[16];
|
|
os_sprintf(cl, "%d", jsonPtr);
|
|
httpdHeader(connData, "Content-Length", cl);
|
|
httpdEndHeaders(connData);
|
|
|
|
httpdSend(connData, jsonBuf, jsonPtr);
|
|
return HTTPD_CGI_DONE;
|
|
}
|
|
|
|
// this method is responsible for the MCU <==JSON==> Browser communication
|
|
int ICACHE_FLASH_ATTR WEB_CgiJsonHook(HttpdConnData *connData)
|
|
{
|
|
if (connData->conn==NULL) return HTTPD_CGI_DONE; // Connection aborted. Clean up.
|
|
|
|
void * cgiData = connData->cgiData;
|
|
|
|
if( cgiData == NULL )
|
|
{
|
|
connData->cgiData = (void *)1; // indicate, that request was processed
|
|
return WEB_handleJSONRequest(connData);
|
|
}
|
|
|
|
if( connData->cgiResponse != NULL ) // data from MCU
|
|
return WEB_handleMCUResponse(connData, (CmdRequest *)(connData->cgiResponse));
|
|
|
|
return HTTPD_CGI_MORE;
|
|
}
|
|
|
|
// configuring the callback
|
|
void ICACHE_FLASH_ATTR WEB_Setup(CmdPacket *cmd)
|
|
{
|
|
CmdRequest req;
|
|
cmdRequest(&req, cmd);
|
|
|
|
if (cmdGetArgc(&req) < 1) return;
|
|
|
|
cmdPopArg(&req, &web_server_cb, 4); // pop the callback
|
|
|
|
os_printf("Web-server connected, cb=0x%x\n", web_server_cb);
|
|
}
|
|
|
|
// this method is called when MCU transmits WEB_DATA command
|
|
void ICACHE_FLASH_ATTR WEB_Data(CmdPacket *cmd)
|
|
{
|
|
CmdRequest req;
|
|
cmdRequest(&req, cmd);
|
|
|
|
if (cmdGetArgc(&req) < 2) return;
|
|
|
|
uint8_t ip[4];
|
|
cmdPopArg(&req, ip, 4); // pop the IP address
|
|
|
|
uint16_t port;
|
|
cmdPopArg(&req, &port, 2); // pop the HTTP port
|
|
|
|
HttpdConnData * conn = httpdLookUpConn(ip, port); // look up connection based on IP/port
|
|
if( conn != NULL && conn->cgi == WEB_CgiJsonHook ) // make sure that the right CGI handler is configured
|
|
httpdSetCGIResponse( conn, &req );
|
|
else
|
|
os_printf("WEB_DATA ignored as no valid HTTP connection found!\n");
|
|
}
|
|
|