GONEC
/
GONEC_ARTERY_HttpServer
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
GONEC_ARTERY_HttpServer/Src/httpd.c

3947 lines
135 KiB
C
Raw Blame History

/**
* @file
* LWIP HTTP server implementation
*/
/*
* Copyright (c) 2001-2003 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. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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 lwIP TCP/IP stack.
*
* Author: Adam Dunkels <adam@sics.se>
* Simon Goldschmidt
*
*/
/**
* @defgroup httpd HTTP server
* @ingroup apps
*
* This httpd supports for a
* rudimentary server-side-include facility which will replace tags of the form
* <!--#tag--> in any file whose extension is .shtml, .shtm or .ssi with
* strings provided by an include handler whose pointer is provided to the
* module via function http_set_ssi_handler().
* Additionally, a simple common
* gateway interface (CGI) handling mechanism has been added to allow clients
* to hook functions to particular request URIs.
*
* To enable SSI support, define label LWIP_HTTPD_SSI in lwipopts.h.
* To enable CGI support, define label LWIP_HTTPD_CGI in lwipopts.h.
*
* By default, the server assumes that HTTP headers are already present in
* each file stored in the file system. By defining LWIP_HTTPD_DYNAMIC_HEADERS in
* lwipopts.h, this behavior can be changed such that the server inserts the
* headers automatically based on the extension of the file being served. If
* this mode is used, be careful to ensure that the file system image used
* does not already contain the header information.
*
* File system images without headers can be created using the makefsfile
* tool with the -h command line option.
*
*
* Notes about valid SSI tags
* --------------------------
*
* The following assumptions are made about tags used in SSI markers:
*
* 1. No tag may contain '-' or whitespace characters within the tag name.
* 2. Whitespace is allowed between the tag leadin "<!--#" and the start of
* the tag name and between the tag name and the leadout string "-->".
* 3. The maximum tag name length is LWIP_HTTPD_MAX_TAG_NAME_LEN, currently 8 characters.
*
* Notes on CGI usage
* ------------------
*
* The simple CGI support offered here works with GET method requests only
* and can handle up to 16 parameters encoded into the URI. The handler
* function may not write directly to the HTTP output but must return a
* filename that the HTTP server will send to the browser as a response to
* the incoming CGI request.
*
*
*
* The list of supported file types is quite short, so if makefsdata complains
* about an unknown extension, make sure to add it (and its doctype) to
* the 'g_psHTTPHeaders' list.
*/
#include "lwip/init.h"
#include "lwip/apps/httpd.h"
#include "lwip/debug.h"
#include "lwip/stats.h"
#include "lwip/apps/fs.h"
#include "httpd_structs.h"
#include "lwip/def.h"
#include "httpd_post.h"
#include "httpd_get.h"
#include <FirmwareLoader.h>
#include "httpd_base_func.h"
#include "SystemDelayInterface.h"
#include "json_func.h"
#include "ModemGonec.h"
#include "auth.h"
#include "fs_base_func.h"
#include "lwip/altcp.h"
#include "lwip/altcp_tcp.h"
#if HTTPD_ENABLE_HTTPS
#include "lwip/altcp_tls.h"
#endif
#ifdef LWIP_HOOK_FILENAME
#include LWIP_HOOK_FILENAME
#endif
#if LWIP_HTTPD_TIMING
#include "lwip/sys.h"
#endif /* LWIP_HTTPD_TIMING */
#include <string.h> /* memset */
#include <stdlib.h> /* atoi */
#include <stdio.h>
//#include "at32f4xx_adc.h"
//#include "at32_board.h"
extern char bufLwIpWebStats[4096];
uint32_t webup_status = 255;
extern volatile uint32_t EMAC_COUNTER_DMARXDESC_DE; // desciptor error: no more descriptors for receive frame
extern volatile uint32_t EMAC_COUNTER_DMARXDESC_OE; // overflow error: frame was damaged due to buffer overflow
extern volatile uint32_t EMAC_COUNTER_DMARXDESC_IPV4HCE; // ipc checksum error: rx ipv4 header checksum error
extern volatile uint32_t EMAC_COUNTER_DMARXDESC_LC; // late collision occurred during reception
extern volatile uint32_t EMAC_COUNTER_DMARXDESC_RWT; // receive watchdog timeout: watchdog timer expired during reception
extern volatile uint32_t EMAC_COUNTER_DMARXDESC_RE; // receive error: error reported by mii interface
extern volatile uint32_t EMAC_COUNTER_DMARXDESC_CE; // crc error
#if LWIP_TCP && LWIP_CALLBACK_API
/** Minimum length for a valid HTTP/0.9 request: "GET /\r\n" -> 7 bytes */
#define MIN_REQ_LEN 7
#define CRLF "\r\n"
#if LWIP_HTTPD_SUPPORT_11_KEEPALIVE
#define HTTP11_CONNECTIONKEEPALIVE "Connection: keep-alive"
#define HTTP11_CONNECTIONKEEPALIVE2 "Connection: Keep-Alive"
#endif
#if LWIP_HTTPD_DYNAMIC_FILE_READ
#define HTTP_IS_DYNAMIC_FILE(hs) ((hs)->buf != NULL)
#else
#define HTTP_IS_DYNAMIC_FILE(hs) 0
#endif
/* This defines checks whether tcp_write has to copy data or not */
#ifndef HTTP_IS_DATA_VOLATILE
/** tcp_write does not have to copy data when sent from rom-file-system directly */
#define HTTP_IS_DATA_VOLATILE(hs) (HTTP_IS_DYNAMIC_FILE(hs) ? TCP_WRITE_FLAG_COPY : 0)
#endif
/** Default: dynamic headers are sent from ROM (non-dynamic headers are handled like file data) */
#ifndef HTTP_IS_HDR_VOLATILE
#define HTTP_IS_HDR_VOLATILE(hs, ptr) 0
#endif
/* Return values for http_send_*() */
#define HTTP_DATA_TO_SEND_FREED 3
#define HTTP_DATA_TO_SEND_BREAK 2
#define HTTP_DATA_TO_SEND_CONTINUE 1
#define HTTP_NO_DATA_TO_SEND 0
//#define CUSTOM_HTTP_SERVER
//char html_tmp[4096] = {0};
//char bigBuffer[LEN_BUF_BIG_ANSWER_HTTP];
#if LWIP_HTTPD_SUPPORT_REQUESTLIST
/** HTTP request is copied here from pbufs for simple parsing */
static char httpd_req_buf[LWIP_HTTPD_MAX_REQ_LENGTH + 1];
#endif /* LWIP_HTTPD_SUPPORT_REQUESTLIST */
#if LWIP_HTTPD_SUPPORT_POST
#if LWIP_HTTPD_POST_MAX_RESPONSE_URI_LEN > LWIP_HTTPD_MAX_REQUEST_URI_LEN
#define LWIP_HTTPD_URI_BUF_LEN LWIP_HTTPD_POST_MAX_RESPONSE_URI_LEN
#endif
#endif
#ifndef LWIP_HTTPD_URI_BUF_LEN
#define LWIP_HTTPD_URI_BUF_LEN LWIP_HTTPD_MAX_REQUEST_URI_LEN
#endif
#if LWIP_HTTPD_URI_BUF_LEN
/* Filename for response file to send when POST is finished or
* search for default files when a directory is requested. */
static char http_uri_buf[LWIP_HTTPD_URI_BUF_LEN + 1];
#endif
#if LWIP_HTTPD_DYNAMIC_HEADERS
/* The number of individual strings that comprise the headers sent before each
* requested file.
*/
#define NUM_FILE_HDR_STRINGS 7
#define HDR_STRINGS_IDX_HTTP_STATUS 0 /* e.g. "HTTP/1.0 200 OK\r\n" */
#define HDR_STRINGS_IDX_SERVER_NAME 1 /* e.g. "Server: "HTTPD_SERVER_AGENT"\r\n" */
#define HDR_STRINGS_IDX_CONTENT_LEN_KEEPALIVE 2 /* e.g. "Content-Length: xy\r\n" and/or "Connection: keep-alive\r\n" */
#define HDR_STRINGS_IDX_CONTENT_LEN_NR 3 /* the byte count, when content-length is used */
#define HDR_STRINGS_IDX_CORS 4 /* the content type (or default answer content type including default document) */
#define HDR_STRINGS_IDX_EXPIRES 5 /* the content type (or default answer content type including default document) */
#define HDR_STRINGS_IDX_CONTENT_TYPE 6 /* the content type (or default answer content type including default document) */
/* The dynamically generated Content-Length buffer needs space for CRLF + NULL */
#define LWIP_HTTPD_MAX_CONTENT_LEN_OFFSET 3
#ifndef LWIP_HTTPD_MAX_CONTENT_LEN_SIZE
/* The dynamically generated Content-Length buffer shall be able to work with
~953 MB (9 digits) */
#define LWIP_HTTPD_MAX_CONTENT_LEN_SIZE (9 + LWIP_HTTPD_MAX_CONTENT_LEN_OFFSET)
#endif
#endif /* LWIP_HTTPD_DYNAMIC_HEADERS */
#if LWIP_HTTPD_SSI
#define HTTPD_LAST_TAG_PART 0xFFFF
enum tag_check_state {
TAG_NONE, /* Not processing an SSI tag */
TAG_LEADIN, /* Tag lead in "<!--#" being processed */
TAG_FOUND, /* Tag name being read, looking for lead-out start */
TAG_LEADOUT, /* Tag lead out "-->" being processed */
TAG_SENDING /* Sending tag replacement string */
};
struct http_ssi_state {
const char *parsed; /* Pointer to the first unparsed byte in buf. */
#if !LWIP_HTTPD_SSI_INCLUDE_TAG
const char *tag_started;/* Pointer to the first opening '<' of the tag. */
#endif /* !LWIP_HTTPD_SSI_INCLUDE_TAG */
const char *tag_end; /* Pointer to char after the closing '>' of the tag. */
u32_t parse_left; /* Number of unparsed bytes in buf. */
u16_t tag_index; /* Counter used by tag parsing state machine */
u16_t tag_insert_len; /* Length of insert in string tag_insert */
#if LWIP_HTTPD_SSI_MULTIPART
u16_t tag_part; /* Counter passed to and changed by tag insertion function to insert multiple times */
#endif /* LWIP_HTTPD_SSI_MULTIPART */
u8_t tag_type; /* index into http_ssi_tag_desc array */
u8_t tag_name_len; /* Length of the tag name in string tag_name */
char tag_name[LWIP_HTTPD_MAX_TAG_NAME_LEN + 1]; /* Last tag name extracted */
char tag_insert[LWIP_HTTPD_MAX_TAG_INSERT_LEN + 1]; /* Insert string for tag_name */
enum tag_check_state tag_state; /* State of the tag processor */
};
struct http_ssi_tag_description {
const char *lead_in;
const char *lead_out;
};
#endif /* LWIP_HTTPD_SSI */
char bufAnswerGetGlobal[LEN_BUF_SMALL_ANSWER_HTTP];
char bufAnswerGetFileGlobal[1460 * 2];
char bufAnswerPostGlobal[LEN_BUF_SMALL_ANSWER_POST_HTTP];
struct http_state {
#if LWIP_HTTPD_KILL_OLD_ON_CONNECTIONS_EXCEEDED
struct http_state *next;
#endif /* LWIP_HTTPD_KILL_OLD_ON_CONNECTIONS_EXCEEDED */
struct fs_file file_handle;
struct fs_file *handle;
const char *file; /* Pointer to first unsent byte in buf. */
// Буфер данных
//char bufAnswer[LEN_BUF_SMALL_ANSWER_HTTP];
char *bufAnswer;
//char *bufAnswer;
// Признак зарузки контента из файла
bool isContentFile;
// Имя файла для динамической передачи контента
char fileNameContent[MAX_LEN_PATH_FS];
// Текущий указатель на данные в файле
u32_t contentFilePos;
char url[MAX_LEN_PATH_FS * 2];
// bool isBigBuffer;
typeAuth auth;
bool isExpires;
// Счетчик оставшихся данных для передачи
u32_t postLeft;
// Ключ
uint32_t authKey;
tHttpPostSetting settings_post;
struct altcp_pcb *pcb;
#if LWIP_HTTPD_SUPPORT_REQUESTLIST
struct pbuf *req;
#endif /* LWIP_HTTPD_SUPPORT_REQUESTLIST */
#if LWIP_HTTPD_DYNAMIC_FILE_READ
char *buf; /* File read buffer. */
int buf_len; /* Size of file read buffer, buf. */
#endif /* LWIP_HTTPD_DYNAMIC_FILE_READ */
u32_t left; /* Number of unsent bytes in buf. */
u8_t retries;
#if LWIP_HTTPD_SUPPORT_11_KEEPALIVE
u8_t keepalive;
#endif /* LWIP_HTTPD_SUPPORT_11_KEEPALIVE */
#if LWIP_HTTPD_SSI
struct http_ssi_state *ssi;
#endif /* LWIP_HTTPD_SSI */
#if LWIP_HTTPD_CGI
char *params[LWIP_HTTPD_MAX_CGI_PARAMETERS]; /* Params extracted from the request URI */
char *param_vals[LWIP_HTTPD_MAX_CGI_PARAMETERS]; /* Values for each extracted param */
#endif /* LWIP_HTTPD_CGI */
#if LWIP_HTTPD_DYNAMIC_HEADERS
const char *hdrs[NUM_FILE_HDR_STRINGS]; /* HTTP headers to be sent. */
char hdr_content_len[LWIP_HTTPD_MAX_CONTENT_LEN_SIZE];
u16_t hdr_pos; /* The position of the first unsent header byte in the
current string */
u16_t hdr_index; /* The index of the hdr string currently being sent. */
#endif /* LWIP_HTTPD_DYNAMIC_HEADERS */
#if LWIP_HTTPD_TIMING
u32_t time_started;
#endif /* LWIP_HTTPD_TIMING */
#if LWIP_HTTPD_SUPPORT_POST
u32_t post_content_len_left;
#if LWIP_HTTPD_POST_MANUAL_WND
u32_t unrecved_bytes;
u8_t no_auto_wnd;
u8_t post_finished;
#endif /* LWIP_HTTPD_POST_MANUAL_WND */
#endif /* LWIP_HTTPD_SUPPORT_POST*/
};
#if HTTPD_USE_MEM_POOL
LWIP_MEMPOOL_DECLARE(HTTPD_STATE, MEMP_NUM_PARALLEL_HTTPD_CONNS, sizeof(struct http_state), "HTTPD_STATE")
#if LWIP_HTTPD_SSI
LWIP_MEMPOOL_DECLARE(HTTPD_SSI_STATE, MEMP_NUM_PARALLEL_HTTPD_SSI_CONNS, sizeof(struct http_ssi_state), "HTTPD_SSI_STATE")
#define HTTP_FREE_SSI_STATE(x) LWIP_MEMPOOL_FREE(HTTPD_SSI_STATE, (x))
#define HTTP_ALLOC_SSI_STATE() (struct http_ssi_state *)LWIP_MEMPOOL_ALLOC(HTTPD_SSI_STATE)
#endif /* LWIP_HTTPD_SSI */
#define HTTP_ALLOC_HTTP_STATE() (struct http_state *)LWIP_MEMPOOL_ALLOC(HTTPD_STATE)
#define HTTP_FREE_HTTP_STATE(x) LWIP_MEMPOOL_FREE(HTTPD_STATE, (x))
#else /* HTTPD_USE_MEM_POOL */
#define HTTP_ALLOC_HTTP_STATE() (struct http_state *)mem_malloc(sizeof(struct http_state))
#define HTTP_FREE_HTTP_STATE(x) mem_free(x)
#if LWIP_HTTPD_SSI
#define HTTP_ALLOC_SSI_STATE() (struct http_ssi_state *)mem_malloc(sizeof(struct http_ssi_state))
#define HTTP_FREE_SSI_STATE(x) mem_free(x)
#endif /* LWIP_HTTPD_SSI */
#endif /* HTTPD_USE_MEM_POOL */
static err_t http_close_conn(struct altcp_pcb *pcb, struct http_state *hs);
static err_t http_close_or_abort_conn(struct altcp_pcb *pcb, struct http_state *hs, u8_t abort_conn);
static err_t http_find_file(struct http_state *hs, const char *uri, int is_09);
static err_t
http_init_file(struct http_state *hs, struct fs_file *file, int is_09, const char *uri, u8_t tag_check, char *params);
static err_t http_poll(void *arg, struct altcp_pcb *pcb);
static u8_t http_check_eof(struct altcp_pcb *pcb, struct http_state *hs);
#if LWIP_HTTPD_FS_ASYNC_READ
static void http_continue(void *connection);
#endif /* LWIP_HTTPD_FS_ASYNC_READ */
#if LWIP_HTTPD_SSI
/* SSI insert handler function pointer. */
static tSSIHandler httpd_ssi_handler;
#if !LWIP_HTTPD_SSI_RAW
static int httpd_num_tags;
static const char **httpd_tags;
#endif /* !LWIP_HTTPD_SSI_RAW */
/* Define the available tag lead-ins and corresponding lead-outs.
* ATTENTION: for the algorithm below using this array, it is essential
* that the lead in differs in the first character! */
const struct http_ssi_tag_description http_ssi_tag_desc[] = {
{"<!--#", "-->"},
{"/*#", "*/"}
};
#endif /* LWIP_HTTPD_SSI */
#if LWIP_HTTPD_CGI
/* CGI handler information */
static const tCGI *httpd_cgis;
static int httpd_num_cgis;
static int http_cgi_paramcount;
#define http_cgi_params hs->params
#define http_cgi_param_vals hs->param_vals
#elif LWIP_HTTPD_CGI_SSI
static char *http_cgi_params[LWIP_HTTPD_MAX_CGI_PARAMETERS]; /* Params extracted from the request URI */
static char *http_cgi_param_vals[LWIP_HTTPD_MAX_CGI_PARAMETERS]; /* Values for each extracted param */
#endif /* LWIP_HTTPD_CGI */
#if LWIP_HTTPD_KILL_OLD_ON_CONNECTIONS_EXCEEDED
/** global list of active HTTP connections, use to kill the oldest when
running out of memory */
static struct http_state *http_connections;
static void
http_add_connection(struct http_state *hs)
{
/* add the connection to the list */
hs->next = http_connections;
http_connections = hs;
}
static void
http_remove_connection(struct http_state *hs)
{
/* take the connection off the list */
if (http_connections) {
if (http_connections == hs) {
http_connections = hs->next;
} else {
struct http_state *last;
for (last = http_connections; last->next != NULL; last = last->next) {
if (last->next == hs) {
last->next = hs->next;
break;
}
}
}
}
}
static void
http_kill_oldest_connection(u8_t ssi_required)
{
struct http_state *hs = http_connections;
struct http_state *hs_free_next = NULL;
while (hs && hs->next) {
#if LWIP_HTTPD_SSI
if (ssi_required) {
if (hs->next->ssi != NULL) {
hs_free_next = hs;
}
} else
#else /* LWIP_HTTPD_SSI */
LWIP_UNUSED_ARG(ssi_required);
#endif /* LWIP_HTTPD_SSI */
{
hs_free_next = hs;
}
LWIP_ASSERT("broken list", hs != hs->next);
hs = hs->next;
}
if (hs_free_next != NULL) {
LWIP_ASSERT("hs_free_next->next != NULL", hs_free_next->next != NULL);
LWIP_ASSERT("hs_free_next->next->pcb != NULL", hs_free_next->next->pcb != NULL);
/* send RST when killing a connection because of memory shortage */
http_close_or_abort_conn(hs_free_next->next->pcb, hs_free_next->next, 1); /* this also unlinks the http_state from the list */
}
}
#else /* LWIP_HTTPD_KILL_OLD_ON_CONNECTIONS_EXCEEDED */
#define http_add_connection(hs)
#define http_remove_connection(hs)
#endif /* LWIP_HTTPD_KILL_OLD_ON_CONNECTIONS_EXCEEDED */
#if LWIP_HTTPD_SSI
/** Allocate as struct http_ssi_state. */
static struct http_ssi_state *
http_ssi_state_alloc(void)
{
struct http_ssi_state *ret = HTTP_ALLOC_SSI_STATE();
#if LWIP_HTTPD_KILL_OLD_ON_CONNECTIONS_EXCEEDED
if (ret == NULL) {
http_kill_oldest_connection(1);
ret = HTTP_ALLOC_SSI_STATE();
}
#endif /* LWIP_HTTPD_KILL_OLD_ON_CONNECTIONS_EXCEEDED */
if (ret != NULL) {
memset(ret, 0, sizeof(struct http_ssi_state));
}
return ret;
}
/** Free a struct http_ssi_state. */
static void
http_ssi_state_free(struct http_ssi_state *ssi)
{
if (ssi != NULL) {
HTTP_FREE_SSI_STATE(ssi);
}
}
#endif /* LWIP_HTTPD_SSI */
/** Initialize a struct http_state.
*/
static void
http_state_init(struct http_state *hs) {
/* Initialize the structure. */
memset(hs, 0, sizeof(struct http_state));
/*
memset(&hs->bufAnswer, 0, sizeof(hs->bufAnswer));
hs->file = 0;
//memset(&hs->file_handle, 0, sizeof(struct fs_file));
hs->handle = 0;
// Признак зарузки контента из файла
hs->isContentFile = 0;
// Текущий указатель на данные в файле
hs->contentFilePos = 0;
// Счетчик оставшихся данных для передачи
hs->postLeft = 0;
// Ключ
hs->authKey = 0;
// hs->req = 0;
hs->left = 0;
hs->retries = 0;
hs->isExpires = 0;
for (int i=0; i<NUM_FILE_HDR_STRINGS; ++i) {
hs->hdrs[i] = 0;
}
memset(hs->hdr_content_len, 0, LWIP_HTTPD_MAX_CONTENT_LEN_SIZE);
hs->hdr_pos = 0;
hs->post_content_len_left = 0;
hs->pcb = 0;
*/
hs->bufAnswer = bufAnswerGetGlobal;
#if LWIP_HTTPD_DYNAMIC_HEADERS
/* Indicate that the headers are not yet valid */
hs->hdr_index = NUM_FILE_HDR_STRINGS;
#endif /* LWIP_HTTPD_DYNAMIC_HEADERS */
}
/** Allocate a struct http_state. */
static struct http_state *
http_state_alloc(void) {
struct http_state *ret = HTTP_ALLOC_HTTP_STATE();
#if LWIP_HTTPD_KILL_OLD_ON_CONNECTIONS_EXCEEDED
if (ret == NULL) {
http_kill_oldest_connection(0);
ret = HTTP_ALLOC_HTTP_STATE();
}
#endif /* LWIP_HTTPD_KILL_OLD_ON_CONNECTIONS_EXCEEDED */
if (ret != NULL) {
http_state_init(ret);
http_add_connection(ret);
}
return ret;
}
/** Free a struct http_state.
* Also frees the file data if dynamic.
*/
static void
http_state_eof(struct http_state *hs) {
if (hs->handle) {
#if LWIP_HTTPD_TIMING
u32_t ms_needed = sys_now() - hs->time_started;
u32_t needed = LWIP_MAX(1, (ms_needed / 100));
LWIP_DEBUGF(HTTPD_DEBUG_TIMING, ("httpd: needed %"U32_F" ms to send file of %d bytes -> %"U32_F" bytes/sec\n",
ms_needed, hs->handle->len, ((((u32_t)hs->handle->len) * 10) / needed)));
#endif /* LWIP_HTTPD_TIMING */
fs_close(hs->handle);
hs->handle = NULL;
}
#if LWIP_HTTPD_DYNAMIC_FILE_READ
if (hs->buf != NULL) {
mem_free(hs->buf);
hs->buf = NULL;
}
#endif /* LWIP_HTTPD_DYNAMIC_FILE_READ */
#if LWIP_HTTPD_SSI
if (hs->ssi) {
http_ssi_state_free(hs->ssi);
hs->ssi = NULL;
}
#endif /* LWIP_HTTPD_SSI */
#if LWIP_HTTPD_SUPPORT_REQUESTLIST
if (hs->req) {
pbuf_free(hs->req);
hs->req = NULL;
}
#endif /* LWIP_HTTPD_SUPPORT_REQUESTLIST */
}
/** Free a struct http_state.
* Also frees the file data if dynamic.
*/
static void
http_state_free(struct http_state *hs) {
if (hs != NULL) {
http_state_eof(hs);
http_remove_connection(hs);
HTTP_FREE_HTTP_STATE(hs);
}
}
/** Call tcp_write() in a loop trying smaller and smaller length
*
* @param pcb altcp_pcb to send
* @param ptr Data to send
* @param length Length of data to send (in/out: on return, contains the
* amount of data sent)
* @param apiflags directly passed to tcp_write
* @return the return value of tcp_write
*/
static err_t
http_write(struct altcp_pcb *pcb, const void *ptr, u16_t *length, u8_t apiflags) {
u16_t len, max_len;
err_t err;
LWIP_ASSERT("length != NULL", length != NULL);
len = *length;
if (len == 0) {
return ERR_OK;
}
/* We cannot send more data than space available in the send buffer. */
max_len = altcp_sndbuf(pcb);
if (max_len < len) {
len = max_len;
}
#ifdef HTTPD_MAX_WRITE_LEN
/* Additional limitation: e.g. don't enqueue more than 2*mss at once */
max_len = HTTPD_MAX_WRITE_LEN(pcb);
if (len > max_len) {
len = max_len;
}
#endif /* HTTPD_MAX_WRITE_LEN */
do {
LWIP_DEBUGF(HTTPD_DEBUG | LWIP_DBG_TRACE, ("Trying to send %d bytes\n", len));
err = altcp_write(pcb, ptr, len, apiflags);
if (err == ERR_MEM) {
if ((altcp_sndbuf(pcb) == 0) ||
(altcp_sndqueuelen(pcb) >= TCP_SND_QUEUELEN)) {
/* no need to try smaller sizes */
len = 1;
} else {
len /= 2;
}
LWIP_DEBUGF(HTTPD_DEBUG | LWIP_DBG_TRACE,
("Send failed, trying less (%d bytes)\n", len));
}
} while ((err == ERR_MEM) && (len > 1));
if (err == ERR_OK) {
LWIP_DEBUGF(HTTPD_DEBUG | LWIP_DBG_TRACE, ("Sent %d bytes\n", len));
*length = len;
} else {
LWIP_DEBUGF(HTTPD_DEBUG | LWIP_DBG_TRACE, ("Send failed with err %d (\"%s\")\n", err, lwip_strerr(err)));
*length = 0;
}
#if LWIP_HTTPD_SUPPORT_11_KEEPALIVE
/* ensure nagle is normally enabled (only disabled for persistent connections
when all data has been enqueued but the connection stays open for the next
request */
altcp_nagle_enable(pcb);
#endif
return err;
}
/**
* The connection shall be actively closed (using RST to close from fault states).
* Reset the sent- and recv-callbacks.
*
* @param pcb the tcp pcb to reset callbacks
* @param hs connection state to free
*/
static err_t
http_close_or_abort_conn(struct altcp_pcb *pcb, struct http_state *hs, u8_t abort_conn) {
err_t err;
LWIP_DEBUGF(HTTPD_DEBUG, ("Closing connection %p\n", (void *) pcb));
#if LWIP_HTTPD_SUPPORT_POST
if (hs != NULL) {
if ((hs->post_content_len_left != 0)
#if LWIP_HTTPD_POST_MANUAL_WND
|| ((hs->no_auto_wnd != 0) && (hs->unrecved_bytes != 0))
#endif /* LWIP_HTTPD_POST_MANUAL_WND */
) {
/* make sure the post code knows that the connection is closed */
http_uri_buf[0] = 0;
httpd_post_finished(hs, http_uri_buf, LWIP_HTTPD_URI_BUF_LEN);
}
}
#endif /* LWIP_HTTPD_SUPPORT_POST*/
altcp_arg(pcb, NULL);
altcp_recv(pcb, NULL);
altcp_err(pcb, NULL);
altcp_poll(pcb, NULL, 0);
altcp_sent(pcb, NULL);
if (hs != NULL) {
http_state_free(hs);
}
if (abort_conn) {
altcp_abort(pcb);
return ERR_OK;
}
err = altcp_close(pcb);
if (err != ERR_OK) {
LWIP_DEBUGF(HTTPD_DEBUG, ("Error %d closing %p\n", err, (void *) pcb));
/* error closing, try again later in poll */
altcp_poll(pcb, http_poll, HTTPD_POLL_INTERVAL);
}
return err;
}
/**
* The connection shall be actively closed.
* Reset the sent- and recv-callbacks.
*
* @param pcb the tcp pcb to reset callbacks
* @param hs connection state to free
*/
static err_t
http_close_conn(struct altcp_pcb *pcb, struct http_state *hs) {
return http_close_or_abort_conn(pcb, hs, 0);
}
/** End of file: either close the connection (Connection: close) or
* close the file (Connection: keep-alive)
*/
static void
http_eof(struct altcp_pcb *pcb, struct http_state *hs) {
/* HTTP/1.1 persistent connection? (Not supported for SSI) */
#if LWIP_HTTPD_SUPPORT_11_KEEPALIVE
if (hs->keepalive) {
http_remove_connection(hs);
http_state_eof(hs);
http_state_init(hs);
/* restore state: */
hs->pcb = pcb;
hs->keepalive = 1;
http_add_connection(hs);
/* ensure nagle doesn't interfere with sending all data as fast as possible: */
altcp_nagle_disable(pcb);
} else
#endif /* LWIP_HTTPD_SUPPORT_11_KEEPALIVE */
{
http_close_conn(pcb, hs);
}
}
#if LWIP_HTTPD_CGI || LWIP_HTTPD_CGI_SSI
/**
* Extract URI parameters from the parameter-part of an URI in the form
* "test.cgi?x=y" @todo: better explanation!
* Pointers to the parameters are stored in hs->param_vals.
*
* @param hs http connection state
* @param params pointer to the NULL-terminated parameter string from the URI
* @return number of parameters extracted
*/
static int
extract_uri_parameters(struct http_state *hs, char *params) {
char *pair;
char *equals;
int loop;
LWIP_UNUSED_ARG(hs);
/* If we have no parameters at all, return immediately. */
if (!params || (params[0] == '\0')) {
return (0);
}
/* Get a pointer to our first parameter */
pair = params;
/* Parse up to LWIP_HTTPD_MAX_CGI_PARAMETERS from the passed string and ignore the
* remainder (if any) */
for (loop = 0; (loop < LWIP_HTTPD_MAX_CGI_PARAMETERS) && pair; loop++) {
/* Save the name of the parameter */
http_cgi_params[loop] = pair;
/* Remember the start of this name=value pair */
equals = pair;
/* Find the start of the next name=value pair and replace the delimiter
* with a 0 to terminate the previous pair string. */
pair = strchr(pair, '&');
if (pair) {
*pair = '\0';
pair++;
} else {
/* We didn't find a new parameter so find the end of the URI and
* replace the space with a '\0' */
pair = strchr(equals, ' ');
if (pair) {
*pair = '\0';
}
/* Revert to NULL so that we exit the loop as expected. */
pair = NULL;
}
/* Now find the '=' in the previous pair, replace it with '\0' and save
* the parameter value string. */
equals = strchr(equals, '=');
if (equals) {
*equals = '\0';
http_cgi_param_vals[loop] = equals + 1;
} else {
http_cgi_param_vals[loop] = NULL;
}
}
return loop;
}
#endif /* LWIP_HTTPD_CGI || LWIP_HTTPD_CGI_SSI */
#if LWIP_HTTPD_SSI
/**
* Insert a tag (found in an shtml in the form of "<!--#tagname-->" into the file.
* The tag's name is stored in ssi->tag_name (NULL-terminated), the replacement
* should be written to hs->tag_insert (up to a length of LWIP_HTTPD_MAX_TAG_INSERT_LEN).
* The amount of data written is stored to ssi->tag_insert_len.
*
* @todo: return tag_insert_len - maybe it can be removed from struct http_state?
*
* @param hs http connection state
*/
static void
get_tag_insert(struct http_state *hs)
{
#if LWIP_HTTPD_SSI_RAW
const char *tag;
#else /* LWIP_HTTPD_SSI_RAW */
int tag;
#endif /* LWIP_HTTPD_SSI_RAW */
size_t len;
struct http_ssi_state *ssi;
#if LWIP_HTTPD_SSI_MULTIPART
u16_t current_tag_part;
#endif /* LWIP_HTTPD_SSI_MULTIPART */
LWIP_ASSERT("hs != NULL", hs != NULL);
ssi = hs->ssi;
LWIP_ASSERT("ssi != NULL", ssi != NULL);
#if LWIP_HTTPD_SSI_MULTIPART
current_tag_part = ssi->tag_part;
ssi->tag_part = HTTPD_LAST_TAG_PART;
#endif /* LWIP_HTTPD_SSI_MULTIPART */
#if LWIP_HTTPD_SSI_RAW
tag = ssi->tag_name;
#endif
if (httpd_ssi_handler
#if !LWIP_HTTPD_SSI_RAW
&& httpd_tags && httpd_num_tags
#endif /* !LWIP_HTTPD_SSI_RAW */
) {
/* Find this tag in the list we have been provided. */
#if LWIP_HTTPD_SSI_RAW
{
#else /* LWIP_HTTPD_SSI_RAW */
for (tag = 0; tag < httpd_num_tags; tag++) {
if (strcmp(ssi->tag_name, httpd_tags[tag]) == 0)
#endif /* LWIP_HTTPD_SSI_RAW */
{
ssi->tag_insert_len = httpd_ssi_handler(tag, ssi->tag_insert,
LWIP_HTTPD_MAX_TAG_INSERT_LEN
#if LWIP_HTTPD_SSI_MULTIPART
, current_tag_part, &ssi->tag_part
#endif /* LWIP_HTTPD_SSI_MULTIPART */
#if LWIP_HTTPD_FILE_STATE
, (hs->handle ? hs->handle->state : NULL)
#endif /* LWIP_HTTPD_FILE_STATE */
);
#if LWIP_HTTPD_SSI_RAW
if (ssi->tag_insert_len != HTTPD_SSI_TAG_UNKNOWN)
#endif /* LWIP_HTTPD_SSI_RAW */
{
return;
}
}
}
}
/* If we drop out, we were asked to serve a page which contains tags that
* we don't have a handler for. Merely echo back the tags with an error
* marker. */
#define UNKNOWN_TAG1_TEXT "<b>***UNKNOWN TAG "
#define UNKNOWN_TAG1_LEN 18
#define UNKNOWN_TAG2_TEXT "***</b>"
#define UNKNOWN_TAG2_LEN 7
len = LWIP_MIN(sizeof(ssi->tag_name), LWIP_MIN(strlen(ssi->tag_name),
LWIP_HTTPD_MAX_TAG_INSERT_LEN - (UNKNOWN_TAG1_LEN + UNKNOWN_TAG2_LEN)));
MEMCPY(ssi->tag_insert, UNKNOWN_TAG1_TEXT, UNKNOWN_TAG1_LEN);
MEMCPY(&ssi->tag_insert[UNKNOWN_TAG1_LEN], ssi->tag_name, len);
MEMCPY(&ssi->tag_insert[UNKNOWN_TAG1_LEN + len], UNKNOWN_TAG2_TEXT, UNKNOWN_TAG2_LEN);
ssi->tag_insert[UNKNOWN_TAG1_LEN + len + UNKNOWN_TAG2_LEN] = 0;
len = strlen(ssi->tag_insert);
LWIP_ASSERT("len <= 0xffff", len <= 0xffff);
ssi->tag_insert_len = (u16_t)len;
}
#endif /* LWIP_HTTPD_SSI */
#if LWIP_HTTPD_DYNAMIC_HEADERS
/**
* Generate the relevant HTTP headers for the given filename and write
* them into the supplied buffer.
*/
static void
get_http_headers(struct http_state *hs, const char *uri) {
size_t content_type;
char *tmp;
char *ext;
char *vars;
if (hs->isExpires) {
hs->hdrs[HDR_STRINGS_IDX_SERVER_NAME] = g_psHTTPHeaderStrings[HTTP_HDR_SERVER];
}
/* In all cases, the second header we send is the server identification
so set it here. */
//hs->hdrs[HDR_STRINGS_IDX_SERVER_NAME] = g_psHTTPHeaderStrings[HTTP_HDR_SERVER];
hs->hdrs[HDR_STRINGS_IDX_CONTENT_LEN_KEEPALIVE] = NULL;
hs->hdrs[HDR_STRINGS_IDX_CONTENT_LEN_NR] = NULL;
/* Is this a normal file or the special case we use to send back the
default "404: Page not found" response? */
if (uri == NULL) {
hs->hdrs[HDR_STRINGS_IDX_HTTP_STATUS] = g_psHTTPHeaderStrings[HTTP_HDR_NOT_FOUND];
#if LWIP_HTTPD_SUPPORT_11_KEEPALIVE
if (hs->keepalive) {
hs->hdrs[HDR_STRINGS_IDX_CONTENT_TYPE] = g_psHTTPHeaderStrings[DEFAULT_404_HTML_PERSISTENT];
} else
#endif
{
hs->hdrs[HDR_STRINGS_IDX_CONTENT_TYPE] = g_psHTTPHeaderStrings[DEFAULT_404_HTML];
}
/* Set up to send the first header string. */
hs->hdr_index = 0;
hs->hdr_pos = 0;
return;
}
/* We are dealing with a particular filename. Look for one other
special case. We assume that any filename with "404" in it must be
indicative of a 404 server error whereas all other files require
the 200 OK header. */
if (strstr(uri, "401.html")) {
hs->hdrs[HDR_STRINGS_IDX_HTTP_STATUS] = "HTTP/1.0 401 Unauthorized\r\nWWW-Authenticate: Basic realm=\"Realm-Name\"\r\n";
} else if (strstr(uri, "404.html")) {
hs->hdrs[HDR_STRINGS_IDX_HTTP_STATUS] = g_psHTTPHeaderStrings[HTTP_HDR_NOT_FOUND];
} else if (strstr(uri, "400.html")) {
hs->hdrs[HDR_STRINGS_IDX_HTTP_STATUS] = g_psHTTPHeaderStrings[HTTP_HDR_BAD_REQUEST];
} else if (strstr(uri, "501.html")) {
hs->hdrs[HDR_STRINGS_IDX_HTTP_STATUS] = g_psHTTPHeaderStrings[HTTP_HDR_NOT_IMPL];
} else {
hs->hdrs[HDR_STRINGS_IDX_HTTP_STATUS] = g_psHTTPHeaderStrings[HTTP_HDR_OK];
}
/* Determine if the URI has any variables and, if so, temporarily remove
them. */
vars = strchr(uri, '?');
if (vars) {
*vars = '\0';
}
/* Get a pointer to the file extension. We find this by looking for the
last occurrence of "." in the filename passed. */
ext = NULL;
tmp = strchr(uri, '.');
while (tmp) {
ext = tmp + 1;
tmp = strchr(ext, '.');
}
if (ext != NULL) {
/* Now determine the content type and add the relevant header for that. */
for (content_type = 0; content_type < NUM_HTTP_HEADERS; content_type++) {
/* Have we found a matching extension? */
if (!lwip_stricmp(g_psHTTPHeaders[content_type].extension, ext)) {
break;
}
}
} else {
content_type = NUM_HTTP_HEADERS;
}
/* Reinstate the parameter marker if there was one in the original URI. */
if (vars) {
*vars = '?';
}
#if LWIP_HTTPD_OMIT_HEADER_FOR_EXTENSIONLESS_URI
/* Does the URL passed have any file extension? If not, we assume it
is a special-case URL used for control state notification and we do
not send any HTTP headers with the response. */
if (!ext) {
/* Force the header index to a value indicating that all headers
have already been sent. */
hs->hdr_index = NUM_FILE_HDR_STRINGS;
return;
}
#endif /* LWIP_HTTPD_OMIT_HEADER_FOR_EXTENSIONLESS_URI */
/* Did we find a matching extension? */
if (content_type < NUM_HTTP_HEADERS) {
/* yes, store it */
hs->hdrs[HDR_STRINGS_IDX_CONTENT_TYPE] = g_psHTTPHeaders[content_type].content_type;
} else if (!ext) {
/* no, no extension found -> use binary transfer to prevent the browser adding '.txt' on save */
hs->hdrs[HDR_STRINGS_IDX_CONTENT_TYPE] = HTTP_HDR_APP;
} else {
/* No - use the default, plain text file type. */
hs->hdrs[HDR_STRINGS_IDX_CONTENT_TYPE] = HTTP_HDR_DEFAULT_TYPE;
}
/* Set up to send the first header string. */
hs->hdr_index = 0;
hs->hdr_pos = 0;
}
/* Add content-length header? */
static void
get_http_content_length(struct http_state *hs) {
u8_t add_content_len = 0;
LWIP_ASSERT("already been here?", hs->hdrs[HDR_STRINGS_IDX_CONTENT_LEN_KEEPALIVE] == NULL);
add_content_len = 0;
#if LWIP_HTTPD_SSI
if (hs->ssi == NULL) /* @todo: get maximum file length from SSI */
#endif /* LWIP_HTTPD_SSI */
{
if ((hs->handle != NULL) && (hs->handle->flags & FS_FILE_FLAGS_HEADER_PERSISTENT)) {
add_content_len = 1;
}
}
add_content_len = 1;
if (add_content_len) {
size_t len;
lwip_itoa(hs->hdr_content_len, (size_t) LWIP_HTTPD_MAX_CONTENT_LEN_SIZE,
hs->left);
len = strlen(hs->hdr_content_len);
if (len <= LWIP_HTTPD_MAX_CONTENT_LEN_SIZE - LWIP_HTTPD_MAX_CONTENT_LEN_OFFSET) {
SMEMCPY(&hs->hdr_content_len[len], CRLF, 3);
hs->hdrs[HDR_STRINGS_IDX_CONTENT_LEN_NR] = hs->hdr_content_len;
} else {
add_content_len = 0;
}
}
#if LWIP_HTTPD_SUPPORT_11_KEEPALIVE
if (add_content_len) {
hs->hdrs[HDR_STRINGS_IDX_CONTENT_LEN_KEEPALIVE] = g_psHTTPHeaderStrings[HTTP_HDR_KEEPALIVE_LEN];
} else {
hs->hdrs[HDR_STRINGS_IDX_CONTENT_LEN_KEEPALIVE] = g_psHTTPHeaderStrings[HTTP_HDR_CONN_CLOSE];
hs->keepalive = 0;
}
#else /* LWIP_HTTPD_SUPPORT_11_KEEPALIVE */
if (add_content_len) {
hs->hdrs[HDR_STRINGS_IDX_CONTENT_LEN_KEEPALIVE] = g_psHTTPHeaderStrings[HTTP_HDR_CONTENT_LENGTH];
}
#endif /* LWIP_HTTPD_SUPPORT_11_KEEPALIVE */
}
/** Sub-function of http_send(): send dynamic headers
*
* @returns: - HTTP_NO_DATA_TO_SEND: no new data has been enqueued
* - HTTP_DATA_TO_SEND_CONTINUE: continue with sending HTTP body
* - HTTP_DATA_TO_SEND_BREAK: data has been enqueued, headers pending,
* so don't send HTTP body yet
* - HTTP_DATA_TO_SEND_FREED: http_state and pcb are already freed
*/
char CORSA[] = "Access-Control-Allow-Origin: *\r\n";
//char EXPIRES[] = "Expires: Wed, 21 Oct 2060 07:28:00 GMT\r\n";
//char EXPIRES[] = "Expires: Now\r\n";
char EXPIRES[] = "Access-Control-Allow-Headers: Origin, Authorization, X-Requested-With, Content-Type, Accept\r\n";
static u8_t
http_send_headers(struct altcp_pcb *pcb, struct http_state *hs) {
err_t err;
u16_t len;
u8_t data_to_send = HTTP_NO_DATA_TO_SEND;
u16_t hdrlen, sendlen;
if (hs->hdrs[HDR_STRINGS_IDX_CONTENT_LEN_KEEPALIVE] == NULL) {
/* set up "content-length" and "connection:" headers */
get_http_content_length(hs);
}
hs->hdrs[HDR_STRINGS_IDX_CORS] = CORSA;
hs->hdrs[HDR_STRINGS_IDX_EXPIRES] = EXPIRES;
/* How much data can we send? */
len = altcp_sndbuf(pcb);
sendlen = len;
while (len && (hs->hdr_index < NUM_FILE_HDR_STRINGS) && sendlen) {
const void *ptr;
u16_t old_sendlen;
u8_t apiflags;
/* How much do we have to send from the current header? */
hdrlen = (u16_t) strlen(hs->hdrs[hs->hdr_index]);
/* How much of this can we send? */
sendlen = (len < (hdrlen - hs->hdr_pos)) ? len : (hdrlen - hs->hdr_pos);
/* Send this amount of data or as much as we can given memory
* constraints. */
ptr = (const void *) (hs->hdrs[hs->hdr_index] + hs->hdr_pos);
old_sendlen = sendlen;
apiflags = HTTP_IS_HDR_VOLATILE(hs, ptr);
if (hs->hdr_index == HDR_STRINGS_IDX_CONTENT_LEN_NR) {
/* content-length is always volatile */
apiflags |= TCP_WRITE_FLAG_COPY;
}
if (hs->hdr_index < NUM_FILE_HDR_STRINGS - 1) {
apiflags |= TCP_WRITE_FLAG_MORE;
}
err = http_write(pcb, ptr, &sendlen, apiflags);
if ((err == ERR_OK) && (old_sendlen != sendlen)) {
/* Remember that we added some more data to be transmitted. */
data_to_send = HTTP_DATA_TO_SEND_CONTINUE;
} else if (err != ERR_OK) {
/* special case: http_write does not try to send 1 byte */
sendlen = 0;
}
/* Fix up the header position for the next time round. */
hs->hdr_pos += sendlen;
len -= sendlen;
/* Have we finished sending this string? */
if (hs->hdr_pos == hdrlen) {
/* Yes - move on to the next one */
hs->hdr_index++;
/* skip headers that are NULL (not all headers are required) */
while ((hs->hdr_index < NUM_FILE_HDR_STRINGS) &&
(hs->hdrs[hs->hdr_index] == NULL)) {
hs->hdr_index++;
}
hs->hdr_pos = 0;
}
}
if ((hs->hdr_index >= NUM_FILE_HDR_STRINGS) && (hs->file == NULL)) {
/* When we are at the end of the headers, check for data to send
* instead of waiting for ACK from remote side to continue
* (which would happen when sending files from async read). */
if (http_check_eof(pcb, hs)) {
data_to_send = HTTP_DATA_TO_SEND_BREAK;
} else {
/* At this point, for non-keepalive connections, hs is deallocated an
pcb is closed. */
return HTTP_DATA_TO_SEND_FREED;
}
}
/* If we get here and there are still header bytes to send, we send
* the header information we just wrote immediately. If there are no
* more headers to send, but we do have file data to send, drop through
* to try to send some file data too. */
if ((hs->hdr_index < NUM_FILE_HDR_STRINGS) || !hs->file) {
LWIP_DEBUGF(HTTPD_DEBUG, ("tcp_output\n"));
return HTTP_DATA_TO_SEND_BREAK;
}
return data_to_send;
}
#endif /* LWIP_HTTPD_DYNAMIC_HEADERS */
/** Sub-function of http_send(): end-of-file (or block) is reached,
* either close the file or read the next block (if supported).
*
* @returns: 0 if the file is finished or no data has been read
* 1 if the file is not finished and data has been read
*/
static u8_t
http_check_eof(struct altcp_pcb *pcb, struct http_state *hs) {
int bytes_left;
#if LWIP_HTTPD_DYNAMIC_FILE_READ
int count;
#ifdef HTTPD_MAX_WRITE_LEN
int max_write_len;
#endif /* HTTPD_MAX_WRITE_LEN */
#endif /* LWIP_HTTPD_DYNAMIC_FILE_READ */
/* Do we have a valid file handle? */
if (hs->handle == NULL) {
/* No - close the connection. */
http_eof(pcb, hs);
return 0;
}
bytes_left = fs_bytes_left(hs->handle);
if (bytes_left <= 0) {
/* We reached the end of the file so this request is done. */
LWIP_DEBUGF(HTTPD_DEBUG, ("End of file.\n"));
http_eof(pcb, hs);
return 0;
}
#if LWIP_HTTPD_DYNAMIC_FILE_READ
/* Do we already have a send buffer allocated? */
if (hs->buf) {
/* Yes - get the length of the buffer */
count = LWIP_MIN(hs->buf_len, bytes_left);
} else {
/* We don't have a send buffer so allocate one now */
count = altcp_sndbuf(pcb);
if (bytes_left < count) {
count = bytes_left;
}
#ifdef HTTPD_MAX_WRITE_LEN
/* Additional limitation: e.g. don't enqueue more than 2*mss at once */
max_write_len = HTTPD_MAX_WRITE_LEN(pcb);
if (count > max_write_len) {
count = max_write_len;
}
#endif /* HTTPD_MAX_WRITE_LEN */
do {
hs->buf = (char *)mem_malloc((mem_size_t)count);
if (hs->buf != NULL) {
hs->buf_len = count;
break;
}
count = count / 2;
} while (count > 100);
/* Did we get a send buffer? If not, return immediately. */
if (hs->buf == NULL) {
LWIP_DEBUGF(HTTPD_DEBUG, ("No buff\n"));
return 0;
}
}
/* Read a block of data from the file. */
LWIP_DEBUGF(HTTPD_DEBUG, ("Trying to read %d bytes.\n", count));
#if LWIP_HTTPD_FS_ASYNC_READ
count = fs_read_async(hs->handle, hs->buf, count, http_continue, hs);
#else /* LWIP_HTTPD_FS_ASYNC_READ */
count = fs_read(hs->handle, hs->buf, count);
#endif /* LWIP_HTTPD_FS_ASYNC_READ */
if (count < 0) {
if (count == FS_READ_DELAYED) {
/* Delayed read, wait for FS to unblock us */
return 0;
}
/* We reached the end of the file so this request is done.
* @todo: close here for HTTP/1.1 when reading file fails */
LWIP_DEBUGF(HTTPD_DEBUG, ("End of file.\n"));
http_eof(pcb, hs);
return 0;
}
/* Set up to send the block of data we just read */
LWIP_DEBUGF(HTTPD_DEBUG, ("Read %d bytes.\n", count));
hs->left = count;
hs->file = hs->buf;
#if LWIP_HTTPD_SSI
if (hs->ssi) {
hs->ssi->parse_left = count;
hs->ssi->parsed = hs->buf;
}
#endif /* LWIP_HTTPD_SSI */
#else /* LWIP_HTTPD_DYNAMIC_FILE_READ */
LWIP_ASSERT("SSI and DYNAMIC_HEADERS turned off but eof not reached", 0);
#endif /* LWIP_HTTPD_SSI || LWIP_HTTPD_DYNAMIC_HEADERS */
return 1;
}
/** Sub-function of http_send(): This is the normal send-routine for non-ssi files
*
* @returns: - 1: data has been written (so call tcp_ouput)
* - 0: no data has been written (no need to call tcp_output)
*/
static u8_t
http_send_data_nonssi(struct altcp_pcb *pcb, struct http_state *hs) {
err_t err;
u16_t len;
u8_t data_to_send = 0;
/* We are not processing an SHTML file so no tag checking is necessary.
* Just send the data as we received it from the file. */
// len = (u16_t) LWIP_MIN(hs->left, 0xffff);
len = (u16_t) LWIP_MIN(hs->left, 1460 * 2);
if (hs->isContentFile) {
FIL file;
UINT bytes_read;
// Получение указателя на расширение файла
// char *pExt = getVoidExt(hs->fileNameContent);
// if (osMutexAcquire(httpSettings.accessHTTP, TIME_MUTEX_HTTP_ACCESS) != osOK) {
// return 0;
// }
//len = (u16_t) LWIP_MIN(hs->left, LEN_BUF_SMALL_ANSWER_HTTP);
len = (u16_t) LWIP_MIN(hs->left, 1460 * 2);
FRESULT fr = f_open_i(httpSettings.fs, &file, hs->fileNameContent, FA_READ);
f_lseek_i(httpSettings.fs, &file, hs->contentFilePos);
// uint32_t t1 = SystemGetMs();
f_read_i(httpSettings.fs, &file, bufAnswerGetFileGlobal, len, &bytes_read);
// uint32_t t2 = SystemGetMs();
// uint32_t t3 = t2 - t1;
f_close_i(httpSettings.fs, &file);
// osMutexRelease(httpSettings.accessHTTP);
//err = http_write(pcb, hs->bufAnswer, &bytes_read, HTTP_IS_DATA_VOLATILE(hs));
//err = http_write(pcb, hs->bufAnswer, &bytes_read, HTTP_IS_DATA_VOLATILE(hs));
err = http_write(pcb, bufAnswerGetFileGlobal, &bytes_read, TCP_WRITE_FLAG_COPY);
//err = http_write(pcb, hs->bufAnswer, &bytes_read, TCP_WRITE_FLAG_MORE);
if (err == ERR_OK) {
data_to_send = 1;
hs->contentFilePos += bytes_read;
hs->left -= bytes_read;
}
/*
err = http_write(pcb, hs->bufAnswer, &len, TCP_WRITE_FLAG_COPY);
if (err == ERR_OK) {
data_to_send = 1;
hs->contentFilePos += len;
hs->left -= len;
}
*/
} else {
//len = (u16_t) LWIP_MIN(len, 1460 * 2);
err = http_write(pcb, hs->file, &len, TCP_WRITE_FLAG_COPY);
// err = http_write(pcb, hs->file, &len, TCP_WRITE_FLAG_MORE);
if (err == ERR_OK) {
data_to_send = 1;
hs->file += len;
hs->left -= len;
}
}
return data_to_send;
}
#if LWIP_HTTPD_SSI
/** Sub-function of http_send(): This is the send-routine for ssi files
*
* @returns: - 1: data has been written (so call tcp_ouput)
* - 0: no data has been written (no need to call tcp_output)
*/
static u8_t
http_send_data_ssi(struct altcp_pcb *pcb, struct http_state *hs)
{
err_t err = ERR_OK;
u16_t len;
u8_t data_to_send = 0;
u8_t tag_type;
struct http_ssi_state *ssi = hs->ssi;
LWIP_ASSERT("ssi != NULL", ssi != NULL);
/* We are processing an SHTML file so need to scan for tags and replace
* them with insert strings. We need to be careful here since a tag may
* straddle the boundary of two blocks read from the file and we may also
* have to split the insert string between two tcp_write operations. */
/* How much data could we send? */
len = altcp_sndbuf(pcb);
/* Do we have remaining data to send before parsing more? */
if (ssi->parsed > hs->file) {
len = (u16_t)LWIP_MIN(ssi->parsed - hs->file, 0xffff);
err = http_write(pcb, hs->file, &len, HTTP_IS_DATA_VOLATILE(hs));
if (err == ERR_OK) {
data_to_send = 1;
hs->file += len;
hs->left -= len;
}
/* If the send buffer is full, return now. */
if (altcp_sndbuf(pcb) == 0) {
return data_to_send;
}
}
LWIP_DEBUGF(HTTPD_DEBUG, ("State %d, %d left\n", ssi->tag_state, (int)ssi->parse_left));
/* We have sent all the data that was already parsed so continue parsing
* the buffer contents looking for SSI tags. */
while (((ssi->tag_state == TAG_SENDING) || ssi->parse_left) && (err == ERR_OK)) {
if (len == 0) {
return data_to_send;
}
switch (ssi->tag_state) {
case TAG_NONE:
/* We are not currently processing an SSI tag so scan for the
* start of the lead-in marker. */
for (tag_type = 0; tag_type < LWIP_ARRAYSIZE(http_ssi_tag_desc); tag_type++) {
if (*ssi->parsed == http_ssi_tag_desc[tag_type].lead_in[0]) {
/* We found what could be the lead-in for a new tag so change
* state appropriately. */
ssi->tag_type = tag_type;
ssi->tag_state = TAG_LEADIN;
ssi->tag_index = 1;
#if !LWIP_HTTPD_SSI_INCLUDE_TAG
ssi->tag_started = ssi->parsed;
#endif /* !LWIP_HTTPD_SSI_INCLUDE_TAG */
break;
}
}
/* Move on to the next character in the buffer */
ssi->parse_left--;
ssi->parsed++;
break;
case TAG_LEADIN:
/* We are processing the lead-in marker, looking for the start of
* the tag name. */
/* Have we reached the end of the leadin? */
if (http_ssi_tag_desc[ssi->tag_type].lead_in[ssi->tag_index] == 0) {
ssi->tag_index = 0;
ssi->tag_state = TAG_FOUND;
} else {
/* Have we found the next character we expect for the tag leadin? */
if (*ssi->parsed == http_ssi_tag_desc[ssi->tag_type].lead_in[ssi->tag_index]) {
/* Yes - move to the next one unless we have found the complete
* leadin, in which case we start looking for the tag itself */
ssi->tag_index++;
} else {
/* We found an unexpected character so this is not a tag. Move
* back to idle state. */
ssi->tag_state = TAG_NONE;
}
/* Move on to the next character in the buffer */
ssi->parse_left--;
ssi->parsed++;
}
break;
case TAG_FOUND:
/* We are reading the tag name, looking for the start of the
* lead-out marker and removing any whitespace found. */
/* Remove leading whitespace between the tag leading and the first
* tag name character. */
if ((ssi->tag_index == 0) && ((*ssi->parsed == ' ') ||
(*ssi->parsed == '\t') || (*ssi->parsed == '\n') ||
(*ssi->parsed == '\r'))) {
/* Move on to the next character in the buffer */
ssi->parse_left--;
ssi->parsed++;
break;
}
/* Have we found the end of the tag name? This is signalled by
* us finding the first leadout character or whitespace */
if ((*ssi->parsed == http_ssi_tag_desc[ssi->tag_type].lead_out[0]) ||
(*ssi->parsed == ' ') || (*ssi->parsed == '\t') ||
(*ssi->parsed == '\n') || (*ssi->parsed == '\r')) {
if (ssi->tag_index == 0) {
/* We read a zero length tag so ignore it. */
ssi->tag_state = TAG_NONE;
} else {
/* We read a non-empty tag so go ahead and look for the
* leadout string. */
ssi->tag_state = TAG_LEADOUT;
LWIP_ASSERT("ssi->tag_index <= 0xff", ssi->tag_index <= 0xff);
ssi->tag_name_len = (u8_t)ssi->tag_index;
ssi->tag_name[ssi->tag_index] = '\0';
if (*ssi->parsed == http_ssi_tag_desc[ssi->tag_type].lead_out[0]) {
ssi->tag_index = 1;
} else {
ssi->tag_index = 0;
}
}
} else {
/* This character is part of the tag name so save it */
if (ssi->tag_index < LWIP_HTTPD_MAX_TAG_NAME_LEN) {
ssi->tag_name[ssi->tag_index++] = *ssi->parsed;
} else {
/* The tag was too long so ignore it. */
ssi->tag_state = TAG_NONE;
}
}
/* Move on to the next character in the buffer */
ssi->parse_left--;
ssi->parsed++;
break;
/* We are looking for the end of the lead-out marker. */
case TAG_LEADOUT:
/* Remove leading whitespace between the tag leading and the first
* tag leadout character. */
if ((ssi->tag_index == 0) && ((*ssi->parsed == ' ') ||
(*ssi->parsed == '\t') || (*ssi->parsed == '\n') ||
(*ssi->parsed == '\r'))) {
/* Move on to the next character in the buffer */
ssi->parse_left--;
ssi->parsed++;
break;
}
/* Have we found the next character we expect for the tag leadout? */
if (*ssi->parsed == http_ssi_tag_desc[ssi->tag_type].lead_out[ssi->tag_index]) {
/* Yes - move to the next one unless we have found the complete
* leadout, in which case we need to call the client to process
* the tag. */
/* Move on to the next character in the buffer */
ssi->parse_left--;
ssi->parsed++;
ssi->tag_index++;
if (http_ssi_tag_desc[ssi->tag_type].lead_out[ssi->tag_index] == 0) {
/* Call the client to ask for the insert string for the
* tag we just found. */
#if LWIP_HTTPD_SSI_MULTIPART
ssi->tag_part = 0; /* start with tag part 0 */
#endif /* LWIP_HTTPD_SSI_MULTIPART */
get_tag_insert(hs);
/* Next time through, we are going to be sending data
* immediately, either the end of the block we start
* sending here or the insert string. */
ssi->tag_index = 0;
ssi->tag_state = TAG_SENDING;
ssi->tag_end = ssi->parsed;
#if !LWIP_HTTPD_SSI_INCLUDE_TAG
ssi->parsed = ssi->tag_started;
#endif /* !LWIP_HTTPD_SSI_INCLUDE_TAG*/
/* If there is any unsent data in the buffer prior to the
* tag, we need to send it now. */
if (ssi->tag_end > hs->file) {
/* How much of the data can we send? */
#if LWIP_HTTPD_SSI_INCLUDE_TAG
len = (u16_t)LWIP_MIN(ssi->tag_end - hs->file, 0xffff);
#else /* LWIP_HTTPD_SSI_INCLUDE_TAG*/
/* we would include the tag in sending */
len = (u16_t)LWIP_MIN(ssi->tag_started - hs->file, 0xffff);
#endif /* LWIP_HTTPD_SSI_INCLUDE_TAG*/
err = http_write(pcb, hs->file, &len, HTTP_IS_DATA_VOLATILE(hs));
if (err == ERR_OK) {
data_to_send = 1;
#if !LWIP_HTTPD_SSI_INCLUDE_TAG
if (ssi->tag_started <= hs->file) {
/* pretend to have sent the tag, too */
len += (u16_t)(ssi->tag_end - ssi->tag_started);
}
#endif /* !LWIP_HTTPD_SSI_INCLUDE_TAG*/
hs->file += len;
hs->left -= len;
}
}
}
} else {
/* We found an unexpected character so this is not a tag. Move
* back to idle state. */
ssi->parse_left--;
ssi->parsed++;
ssi->tag_state = TAG_NONE;
}
break;
/*
* We have found a valid tag and are in the process of sending
* data as a result of that discovery. We send either remaining data
* from the file prior to the insert point or the insert string itself.
*/
case TAG_SENDING:
/* Do we have any remaining file data to send from the buffer prior
* to the tag? */
if (ssi->tag_end > hs->file) {
/* How much of the data can we send? */
#if LWIP_HTTPD_SSI_INCLUDE_TAG
len = (u16_t)LWIP_MIN(ssi->tag_end - hs->file, 0xffff);
#else /* LWIP_HTTPD_SSI_INCLUDE_TAG*/
LWIP_ASSERT("hs->started >= hs->file", ssi->tag_started >= hs->file);
/* we would include the tag in sending */
len = (u16_t)LWIP_MIN(ssi->tag_started - hs->file, 0xffff);
#endif /* LWIP_HTTPD_SSI_INCLUDE_TAG*/
if (len != 0) {
err = http_write(pcb, hs->file, &len, HTTP_IS_DATA_VOLATILE(hs));
} else {
err = ERR_OK;
}
if (err == ERR_OK) {
data_to_send = 1;
#if !LWIP_HTTPD_SSI_INCLUDE_TAG
if (ssi->tag_started <= hs->file) {
/* pretend to have sent the tag, too */
len += (u16_t)(ssi->tag_end - ssi->tag_started);
}
#endif /* !LWIP_HTTPD_SSI_INCLUDE_TAG*/
hs->file += len;
hs->left -= len;
}
} else {
#if LWIP_HTTPD_SSI_MULTIPART
if (ssi->tag_index >= ssi->tag_insert_len) {
/* Did the last SSIHandler have more to send? */
if (ssi->tag_part != HTTPD_LAST_TAG_PART) {
/* If so, call it again */
ssi->tag_index = 0;
get_tag_insert(hs);
}
}
#endif /* LWIP_HTTPD_SSI_MULTIPART */
/* Do we still have insert data left to send? */
if (ssi->tag_index < ssi->tag_insert_len) {
/* We are sending the insert string itself. How much of the
* insert can we send? */
len = (ssi->tag_insert_len - ssi->tag_index);
/* Note that we set the copy flag here since we only have a
* single tag insert buffer per connection. If we don't do
* this, insert corruption can occur if more than one insert
* is processed before we call tcp_output. */
err = http_write(pcb, &(ssi->tag_insert[ssi->tag_index]), &len,
HTTP_IS_TAG_VOLATILE(hs));
if (err == ERR_OK) {
data_to_send = 1;
ssi->tag_index += len;
/* Don't return here: keep on sending data */
}
} else {
#if LWIP_HTTPD_SSI_MULTIPART
if (ssi->tag_part == HTTPD_LAST_TAG_PART)
#endif /* LWIP_HTTPD_SSI_MULTIPART */
{
/* We have sent all the insert data so go back to looking for
* a new tag. */
LWIP_DEBUGF(HTTPD_DEBUG, ("Everything sent.\n"));
ssi->tag_index = 0;
ssi->tag_state = TAG_NONE;
#if !LWIP_HTTPD_SSI_INCLUDE_TAG
ssi->parsed = ssi->tag_end;
#endif /* !LWIP_HTTPD_SSI_INCLUDE_TAG*/
}
}
break;
default:
break;
}
}
}
/* If we drop out of the end of the for loop, this implies we must have
* file data to send so send it now. In TAG_SENDING state, we've already
* handled this so skip the send if that's the case. */
if ((ssi->tag_state != TAG_SENDING) && (ssi->parsed > hs->file)) {
#if LWIP_HTTPD_DYNAMIC_FILE_READ && !LWIP_HTTPD_SSI_INCLUDE_TAG
if ((ssi->tag_state != TAG_NONE) && (ssi->tag_started > ssi->tag_end)) {
/* If we found tag on the edge of the read buffer: just throw away the first part
(we have copied/saved everything required for parsing on later). */
len = (u16_t)(ssi->tag_started - hs->file);
hs->left -= (ssi->parsed - ssi->tag_started);
ssi->parsed = ssi->tag_started;
ssi->tag_started = hs->buf;
} else
#endif /* LWIP_HTTPD_DYNAMIC_FILE_READ && !LWIP_HTTPD_SSI_INCLUDE_TAG */
{
len = (u16_t)LWIP_MIN(ssi->parsed - hs->file, 0xffff);
}
err = http_write(pcb, hs->file, &len, HTTP_IS_DATA_VOLATILE(hs));
if (err == ERR_OK) {
data_to_send = 1;
hs->file += len;
hs->left -= len;
}
}
return data_to_send;
}
#endif /* LWIP_HTTPD_SSI */
/**
* Try to send more data on this pcb.
*
* @param pcb the pcb to send data
* @param hs connection state
*/
static u8_t
http_send(struct altcp_pcb *pcb, struct http_state *hs) {
u8_t data_to_send = HTTP_NO_DATA_TO_SEND;
LWIP_DEBUGF(HTTPD_DEBUG | LWIP_DBG_TRACE, ("http_send: pcb=%p hs=%p left=%d\n", (void *) pcb,
(void *) hs, hs != NULL ? (int) hs->left : 0));
#if LWIP_HTTPD_SUPPORT_POST && LWIP_HTTPD_POST_MANUAL_WND
if (hs->unrecved_bytes != 0) {
return 0;
}
#endif /* LWIP_HTTPD_SUPPORT_POST && LWIP_HTTPD_POST_MANUAL_WND */
/* If we were passed a NULL state structure pointer, ignore the call. */
if (hs == NULL) {
return 0;
}
#if LWIP_HTTPD_FS_ASYNC_READ
/* Check if we are allowed to read from this file.
(e.g. SSI might want to delay sending until data is available) */
if (!fs_is_file_ready(hs->handle, http_continue, hs)) {
return 0;
}
#endif /* LWIP_HTTPD_FS_ASYNC_READ */
#if LWIP_HTTPD_DYNAMIC_HEADERS
/* Do we have any more header data to send for this file? */
if (hs->hdr_index < NUM_FILE_HDR_STRINGS) {
data_to_send = http_send_headers(pcb, hs);
if ((data_to_send == HTTP_DATA_TO_SEND_FREED) ||
((data_to_send != HTTP_DATA_TO_SEND_CONTINUE) &&
(hs->hdr_index < NUM_FILE_HDR_STRINGS))) {
return data_to_send;
}
}
#endif /* LWIP_HTTPD_DYNAMIC_HEADERS */
/* Have we run out of file data to send? If so, we need to read the next
* block from the file. */
if (hs->left == 0) {
if (!http_check_eof(pcb, hs)) {
return 0;
}
}
#if LWIP_HTTPD_SSI
if (hs->ssi) {
data_to_send = http_send_data_ssi(pcb, hs);
} else
#endif /* LWIP_HTTPD_SSI */
{
data_to_send = http_send_data_nonssi(pcb, hs);
}
if ((hs->left == 0) && (fs_bytes_left(hs->handle) <= 0)) {
/* We reached the end of the file so this request is done.
* This adds the FIN flag right into the last data segment. */
LWIP_DEBUGF(HTTPD_DEBUG, ("End of file.\n"));
// if (hs->isBigBuffer == true) {
// osMutexRelease(httpSettings.accessHTTP);
// }
http_eof(pcb, hs);
return 0;
}
LWIP_DEBUGF(HTTPD_DEBUG | LWIP_DBG_TRACE, ("send_data end.\n"));
return data_to_send;
}
#if LWIP_HTTPD_SUPPORT_EXTSTATUS
/** Initialize a http connection with a file to send for an error message
*
* @param hs http connection state
* @param error_nr HTTP error number
* @return ERR_OK if file was found and hs has been initialized correctly
* another err_t otherwise
*/
static err_t
http_find_error_file(struct http_state *hs, u16_t error_nr)
{
const char *uri, *uri1, *uri2, *uri3;
if (error_nr == 501) {
uri1 = "/501.html";
uri2 = "/501.htm";
uri3 = "/501.shtml";
} else {
/* 400 (bad request is the default) */
uri1 = "/400.html";
uri2 = "/400.htm";
uri3 = "/400.shtml";
}
if (fs_open(&hs->file_handle, uri1) == ERR_OK) {
uri = uri1;
} else if (fs_open(&hs->file_handle, uri2) == ERR_OK) {
uri = uri2;
} else if (fs_open(&hs->file_handle, uri3) == ERR_OK) {
uri = uri3;
} else {
LWIP_DEBUGF(HTTPD_DEBUG, ("Error page for error %"U16_F" not found\n",
error_nr));
return ERR_ARG;
}
return http_init_file(hs, &hs->file_handle, 0, uri, 0, NULL);
}
#else /* LWIP_HTTPD_SUPPORT_EXTSTATUS */
#define http_find_error_file(hs, error_nr) ERR_ARG
#endif /* LWIP_HTTPD_SUPPORT_EXTSTATUS */
/**
* Get the file struct for a 404 error page.
* Tries some file names and returns NULL if none found.
*
* @param uri pointer that receives the actual file name URI
* @return file struct for the error page or NULL no matching file was found
*/
static struct fs_file *
http_get_404_file(struct http_state *hs, const char **uri) {
err_t err;
*uri = "/404.html";
err = fs_open(&hs->file_handle, *uri);
if (err != ERR_OK) {
/* 404.html doesn't exist. Try 404.htm instead. */
*uri = "/404.htm";
err = fs_open(&hs->file_handle, *uri);
if (err != ERR_OK) {
/* 404.htm doesn't exist either. Try 404.shtml instead. */
*uri = "/404.shtml";
err = fs_open(&hs->file_handle, *uri);
if (err != ERR_OK) {
/* 404.htm doesn't exist either. Indicate to the caller that it should
* send back a default 404 page.
*/
*uri = NULL;
return NULL;
}
}
}
return &hs->file_handle;
}
#if LWIP_HTTPD_SUPPORT_POST
static err_t
http_handle_post_finished(struct http_state *hs) {
#if LWIP_HTTPD_POST_MANUAL_WND
/* Prevent multiple calls to httpd_post_finished, since it might have already
been called before from httpd_post_data_recved(). */
if (hs->post_finished) {
return ERR_OK;
}
hs->post_finished = 1;
#endif /* LWIP_HTTPD_POST_MANUAL_WND */
/* application error or POST finished */
/* NULL-terminate the buffer */
http_uri_buf[0] = 0;
httpd_post_finished(hs, http_uri_buf, LWIP_HTTPD_URI_BUF_LEN);
return http_find_file(hs, http_uri_buf, 0);
}
/** Pass received POST body data to the application and correctly handle
* returning a response document or closing the connection.
* ATTENTION: The application is responsible for the pbuf now, so don't free it!
*
* @param hs http connection state
* @param p pbuf to pass to the application
* @return ERR_OK if passed successfully, another err_t if the response file
* hasn't been found (after POST finished)
*/
static err_t
http_post_rxpbuf(struct http_state *hs, struct pbuf *p) {
err_t err;
if (p != NULL) {
/* adjust remaining Content-Length */
if (hs->post_content_len_left < p->tot_len) {
hs->post_content_len_left = 0;
} else {
hs->post_content_len_left -= p->tot_len;
}
}
#if LWIP_HTTPD_SUPPORT_POST && LWIP_HTTPD_POST_MANUAL_WND
/* prevent connection being closed if httpd_post_data_recved() is called nested */
hs->unrecved_bytes++;
#endif
if (p != NULL) {
err = httpd_post_receive_data(hs, p);
} else {
err = ERR_OK;
}
#if LWIP_HTTPD_SUPPORT_POST && LWIP_HTTPD_POST_MANUAL_WND
hs->unrecved_bytes--;
#endif
if (err != ERR_OK) {
/* Ignore remaining content in case of application error */
hs->post_content_len_left = 0;
}
if (hs->post_content_len_left == 0) {
#if LWIP_HTTPD_SUPPORT_POST && LWIP_HTTPD_POST_MANUAL_WND
if (hs->unrecved_bytes != 0) {
return ERR_OK;
}
#endif /* LWIP_HTTPD_SUPPORT_POST && LWIP_HTTPD_POST_MANUAL_WND */
/* application error or POST finished */
return http_handle_post_finished(hs);
}
return ERR_OK;
}
/** Handle a post request. Called from http_parse_request when method 'POST'
* is found.
*
* @param p The input pbuf (containing the POST header and body).
* @param hs The http connection state.
* @param data HTTP request (header and part of body) from input pbuf(s).
* @param data_len Size of 'data'.
* @param uri The HTTP URI parsed from input pbuf(s).
* @param uri_end Pointer to the end of 'uri' (here, the rest of the HTTP
* header starts).
* @return ERR_OK: POST correctly parsed and accepted by the application.
* ERR_INPROGRESS: POST not completely parsed (no error yet)
* another err_t: Error parsing POST or denied by the application
*/
static err_t
http_post_request(struct pbuf *inp, struct http_state *hs,
char *data, u16_t data_len, char *uri, char *uri_end) {
err_t err;
/* search for end-of-header (first double-CRLF) */
char *crlfcrlf = lwip_strnstr(uri_end + 1, CRLF CRLF, data_len - (uri_end + 1 - data));
if (crlfcrlf != NULL) {
/* search for "Content-Length: " */
#define HTTP_HDR_CONTENT_LEN "Content-Length: "
#define HTTP_HDR_CONTENT_LEN_LEN 16
#define HTTP_HDR_CONTENT_LEN_DIGIT_MAX_LEN 10
char *scontent_len = lwip_strnstr(uri_end + 1, HTTP_HDR_CONTENT_LEN, crlfcrlf - (uri_end + 1));
if (scontent_len != NULL) {
char *scontent_len_end = lwip_strnstr(scontent_len + HTTP_HDR_CONTENT_LEN_LEN, CRLF,
HTTP_HDR_CONTENT_LEN_DIGIT_MAX_LEN);
if (scontent_len_end != NULL) {
int content_len;
char *content_len_num = scontent_len + HTTP_HDR_CONTENT_LEN_LEN;
content_len = atoi(content_len_num);
if (content_len == 0) {
/* if atoi returns 0 on error, fix this */
if ((content_len_num[0] != '0') || (content_len_num[1] != '\r')) {
content_len = -1;
}
}
if (content_len >= 0) {
/* adjust length of HTTP header passed to application */
const char *hdr_start_after_uri = uri_end + 1;
u16_t hdr_len = (u16_t) LWIP_MIN(data_len, crlfcrlf + 4 - data);
u16_t hdr_data_len = (u16_t) LWIP_MIN(data_len, crlfcrlf + 4 - hdr_start_after_uri);
u8_t post_auto_wnd = 1;
http_uri_buf[0] = 0;
/* trim http header */
*crlfcrlf = 0;
err = httpd_post_begin(hs, uri, hdr_start_after_uri, hdr_data_len, content_len,
http_uri_buf, LWIP_HTTPD_URI_BUF_LEN, &post_auto_wnd);
if (err == ERR_OK) {
/* try to pass in data of the first pbuf(s) */
struct pbuf *q = inp;
u16_t start_offset = hdr_len;
#if LWIP_HTTPD_POST_MANUAL_WND
hs->no_auto_wnd = !post_auto_wnd;
#endif /* LWIP_HTTPD_POST_MANUAL_WND */
/* set the Content-Length to be received for this POST */
hs->post_content_len_left = (u32_t) content_len;
/* get to the pbuf where the body starts */
while ((q != NULL) && (q->len <= start_offset)) {
start_offset -= q->len;
q = q->next;
}
if (q != NULL) {
/* hide the remaining HTTP header */
pbuf_remove_header(q, start_offset);
#if LWIP_HTTPD_POST_MANUAL_WND
if (!post_auto_wnd) {
/* already tcp_recved() this data... */
hs->unrecved_bytes = q->tot_len;
}
#endif /* LWIP_HTTPD_POST_MANUAL_WND */
pbuf_ref(q);
return http_post_rxpbuf(hs, q);
} else if (hs->post_content_len_left == 0) {
q = pbuf_alloc(PBUF_RAW, 0, PBUF_REF);
return http_post_rxpbuf(hs, q);
} else {
return ERR_OK;
}
} else {
/* return file passed from application */
return http_find_file(hs, http_uri_buf, 0);
}
} else {
LWIP_DEBUGF(HTTPD_DEBUG, ("POST received invalid Content-Length: %s\n",
content_len_num));
return ERR_ARG;
}
}
}
/* If we come here, headers are fully received (double-crlf), but Content-Length
was not included. Since this is currently the only supported method, we have
to fail in this case! */
LWIP_DEBUGF(HTTPD_DEBUG, ("Error when parsing Content-Length\n"));
return ERR_ARG;
}
/* if we come here, the POST is incomplete */
#if LWIP_HTTPD_SUPPORT_REQUESTLIST
return ERR_INPROGRESS;
#else /* LWIP_HTTPD_SUPPORT_REQUESTLIST */
return ERR_ARG;
#endif /* LWIP_HTTPD_SUPPORT_REQUESTLIST */
}
#if LWIP_HTTPD_POST_MANUAL_WND
/**
* @ingroup httpd
* A POST implementation can call this function to update the TCP window.
* This can be used to throttle data reception (e.g. when received data is
* programmed to flash and data is received faster than programmed).
*
* @param connection A connection handle passed to httpd_post_begin for which
* httpd_post_finished has *NOT* been called yet!
* @param recved_len Length of data received (for window update)
*/
void httpd_post_data_recved(void *connection, u16_t recved_len) {
struct http_state *hs = (struct http_state *) connection;
if (hs != NULL) {
if (hs->no_auto_wnd) {
u16_t len = recved_len;
if (hs->unrecved_bytes >= recved_len) {
hs->unrecved_bytes -= recved_len;
} else {
LWIP_DEBUGF(HTTPD_DEBUG | LWIP_DBG_LEVEL_WARNING, ("httpd_post_data_recved: recved_len too big\n"));
len = (u16_t) hs->unrecved_bytes;
hs->unrecved_bytes = 0;
}
if (hs->pcb != NULL) {
if (len != 0) {
altcp_recved(hs->pcb, len);
}
if ((hs->post_content_len_left == 0) && (hs->unrecved_bytes == 0)) {
/* finished handling POST */
http_handle_post_finished(hs);
http_send(hs->pcb, hs);
}
}
}
}
}
#endif /* LWIP_HTTPD_POST_MANUAL_WND */
#endif /* LWIP_HTTPD_SUPPORT_POST */
#if LWIP_HTTPD_FS_ASYNC_READ
/** Try to send more data if file has been blocked before
* This is a callback function passed to fs_read_async().
*/
static void
http_continue(void *connection)
{
struct http_state *hs = (struct http_state *)connection;
LWIP_ASSERT_CORE_LOCKED();
if (hs && (hs->pcb) && (hs->handle)) {
LWIP_ASSERT("hs->pcb != NULL", hs->pcb != NULL);
LWIP_DEBUGF(HTTPD_DEBUG | LWIP_DBG_TRACE, ("httpd_continue: try to send more data\n"));
if (http_send(hs->pcb, hs)) {
/* If we wrote anything to be sent, go ahead and send it now. */
LWIP_DEBUGF(HTTPD_DEBUG | LWIP_DBG_TRACE, ("tcp_output\n"));
altcp_output(hs->pcb);
}
}
}
#endif /* LWIP_HTTPD_FS_ASYNC_READ */
/**
* When data has been received in the correct state, try to parse it
* as a HTTP request.
*
* @param inp the received pbuf
* @param hs the connection state
* @param pcb the altcp_pcb which received this packet
* @return ERR_OK if request was OK and hs has been initialized correctly
* ERR_INPROGRESS if request was OK so far but not fully received
* another err_t otherwise
*/
static err_t
http_parse_request(struct pbuf *inp, struct http_state *hs, struct altcp_pcb *pcb) {
char *data;
char *crlf;
u16_t data_len;
struct pbuf *p = inp;
#if LWIP_HTTPD_SUPPORT_REQUESTLIST
u16_t clen;
#endif /* LWIP_HTTPD_SUPPORT_REQUESTLIST */
#if LWIP_HTTPD_SUPPORT_POST
err_t err;
#endif /* LWIP_HTTPD_SUPPORT_POST */
LWIP_UNUSED_ARG(pcb); /* only used for post */
LWIP_ASSERT("p != NULL", p != NULL);
LWIP_ASSERT("hs != NULL", hs != NULL);
if ((hs->handle != NULL) || (hs->file != NULL)) {
LWIP_DEBUGF(HTTPD_DEBUG, ("Received data while sending a file\n"));
/* already sending a file */
/* @todo: abort? */
return ERR_USE;
}
#if LWIP_HTTPD_SUPPORT_REQUESTLIST
LWIP_DEBUGF(HTTPD_DEBUG, ("Received %"U16_F" bytes\n", p->tot_len));
/* first check allowed characters in this pbuf? */
/* enqueue the pbuf */
if (hs->req == NULL) {
LWIP_DEBUGF(HTTPD_DEBUG, ("First pbuf\n"));
hs->req = p;
} else {
LWIP_DEBUGF(HTTPD_DEBUG, ("pbuf enqueued\n"));
pbuf_cat(hs->req, p);
}
/* increase pbuf ref counter as it is freed when we return but we want to
keep it on the req list */
pbuf_ref(p);
if (hs->req->next != NULL) {
data_len = LWIP_MIN(hs->req->tot_len, LWIP_HTTPD_MAX_REQ_LENGTH);
pbuf_copy_partial(hs->req, httpd_req_buf, data_len, 0);
data = httpd_req_buf;
} else
#endif /* LWIP_HTTPD_SUPPORT_REQUESTLIST */
{
data = (char *) p->payload;
data_len = p->len;
if (p->len != p->tot_len) {
LWIP_DEBUGF(HTTPD_DEBUG, ("Warning: incomplete header due to chained pbufs\n"));
}
}
/* received enough data for minimal request? */
if (data_len >= MIN_REQ_LEN) {
/* wait for CRLF before parsing anything */
crlf = lwip_strnstr(data, CRLF, data_len);
if (crlf != NULL) {
#if LWIP_HTTPD_SUPPORT_POST
int is_post = 0;
int is_options = 0;
#endif /* LWIP_HTTPD_SUPPORT_POST */
int is_09 = 0;
char *sp1, *sp2;
u16_t left_len, uri_len;
LWIP_DEBUGF(HTTPD_DEBUG | LWIP_DBG_TRACE, ("CRLF received, parsing request\n"));
/* parse method */
if (!strncmp(data, "GET ", 4)) {
sp1 = data + 3;
/* received GET request */
LWIP_DEBUGF(HTTPD_DEBUG | LWIP_DBG_TRACE, ("Received GET request\"\n"));
#if LWIP_HTTPD_SUPPORT_POST
} else if (!strncmp(data, "POST ", 5)) {
/* store request type */
is_post = 1;
sp1 = data + 4;
/* received GET request */
LWIP_DEBUGF(HTTPD_DEBUG | LWIP_DBG_TRACE, ("Received POST request\n"));
#endif /* LWIP_HTTPD_SUPPORT_POST */
} else if (!strncmp(data, "OPTIONS ", 8)) {
is_options = true;
sp1 = data + 7;
} else {
/* null-terminate the METHOD (pbuf is freed anyway wen returning) */
data[4] = 0;
/* unsupported method! */
LWIP_DEBUGF(HTTPD_DEBUG, ("Unsupported request method (not implemented): \"%s\"\n",
data));
return http_find_error_file(hs, 501);
}
/* if we come here, method is OK, parse URI */
left_len = (u16_t) (data_len - ((sp1 + 1) - data));
sp2 = lwip_strnstr(sp1 + 1, " ", left_len);
#if LWIP_HTTPD_SUPPORT_V09
if (sp2 == NULL) {
/* HTTP 0.9: respond with correct protocol version */
sp2 = lwip_strnstr(sp1 + 1, CRLF, left_len);
is_09 = 1;
#if LWIP_HTTPD_SUPPORT_POST
if (is_post) {
/* HTTP/0.9 does not support POST */
goto badrequest;
}
#endif /* LWIP_HTTPD_SUPPORT_POST */
}
#endif /* LWIP_HTTPD_SUPPORT_V09 */
uri_len = (u16_t) (sp2 - (sp1 + 1));
if ((sp2 != 0) && (sp2 > sp1)) {
/* wait for CRLFCRLF (indicating end of HTTP headers) before parsing anything */
if (lwip_strnstr(data, CRLF CRLF, data_len) != NULL) {
char *uri = sp1 + 1;
#if LWIP_HTTPD_SUPPORT_11_KEEPALIVE
/* This is HTTP/1.0 compatible: for strict 1.1, a connection
would always be persistent unless "close" was specified. */
if (!is_09 && (lwip_strnstr(data, HTTP11_CONNECTIONKEEPALIVE, data_len) ||
lwip_strnstr(data, HTTP11_CONNECTIONKEEPALIVE2, data_len))) {
hs->keepalive = 1;
} else {
hs->keepalive = 0;
}
#endif /* LWIP_HTTPD_SUPPORT_11_KEEPALIVE */
/* null-terminate the METHOD (pbuf is freed anyway wen returning) */
*sp1 = 0;
uri[uri_len] = 0;
LWIP_DEBUGF(HTTPD_DEBUG, ("Received \"%s\" request for URI: \"%s\"\n",
data, uri));
#define HTTP_HDR_AUTH1 "authorization: Basic "
#define HTTP_HDR_AUTH2 "Authorization: Basic "
#define HTTP_HDR_AUTH_LEN 21
char authEncode[128];
memset(authEncode, 0, sizeof(authEncode));
hs->auth = AUTH_NONE;
// Поиск окончания заголовка
char *crlfcrlf = lwip_strnstr(sp2 + 1, CRLF CRLF, data_len - (sp2 + 1 - data));
// Поиск начала Authorization
char *auth_start = lwip_strnstr(sp2 + 1, HTTP_HDR_AUTH1, crlfcrlf - (sp2 + 1));
if (auth_start == NULL)
auth_start = lwip_strnstr(sp2 + 1, HTTP_HDR_AUTH2, crlfcrlf - (sp2 + 1));
if (auth_start != NULL) {
// Поиск конца строки Auth
char *auth_end = lwip_strnstr(auth_start + HTTP_HDR_AUTH_LEN, CRLF,
auth_start + HTTP_HDR_AUTH_LEN - (sp2 + 1));
if (auth_end != NULL) {
char auth[128];
memset(auth, 0, sizeof(auth));
size_t auth_len = auth_end - (auth_start + HTTP_HDR_AUTH_LEN);
if (auth_len > 127)
auth_len = 127;
memcpy(auth, auth_start + HTTP_HDR_AUTH_LEN, auth_len);
b64_decode(auth, (unsigned char *) authEncode, sizeof(authEncode));
hs->auth = Auth(httpSettings.storage, authEncode);
}
}
/*
#define HTTP_HDR_COOKIE "Cookie: "
#define HTTP_HDR_COOKIE_LEN 8
#define HTTP_HDR_AUTH "Auth="
#define HTTP_HDR_AUTH_LEN 5
hs->authKey = 0;
// Поиск окончания заголовка
char *crlfcrlf = lwip_strnstr(sp2 + 1, CRLF CRLF, data_len - (sp2 + 1 - data));
// Поиск начала Cookie
char *cookie_start = lwip_strnstr(sp2 + 1, HTTP_HDR_COOKIE, crlfcrlf - (sp2 + 1));
if (cookie_start != NULL) {
// Поиск начала Auth
char *auth_start = lwip_strnstr(cookie_start + HTTP_HDR_COOKIE_LEN, HTTP_HDR_AUTH,
cookie_start + HTTP_HDR_COOKIE_LEN - (sp2 + 1));
if (auth_start != NULL) {
// Поиск конца строки Auth
char *auth_end = lwip_strnstr(auth_start + HTTP_HDR_AUTH_LEN, CRLF,
auth_start + HTTP_HDR_AUTH_LEN - (sp2 + 1));
if (auth_end != NULL) {
char auth[12];
memset(auth, 0, sizeof(auth));
size_t auth_len = auth_end - (auth_start + HTTP_HDR_AUTH_LEN);
if (auth_len > 10)
auth_len = 10;
memcpy(auth, auth_start + HTTP_HDR_AUTH_LEN, auth_len);
hs->authKey = atoi(auth);
//b64_decode(auth, authEncode, sizeof(authEncode));
}
}
}
*/
if (is_options) {
get_http_headers(hs, uri);
return ERR_OK;
#if LWIP_HTTPD_SUPPORT_POST
} else if (is_post) {
#if LWIP_HTTPD_SUPPORT_REQUESTLIST
struct pbuf *q = hs->req;
#else /* LWIP_HTTPD_SUPPORT_REQUESTLIST */
struct pbuf *q = inp;
#endif /* LWIP_HTTPD_SUPPORT_REQUESTLIST */
err = http_post_request(q, hs, data, data_len, uri, sp2);
if (err != ERR_OK) {
/* restore header for next try */
*sp1 = ' ';
*sp2 = ' ';
uri[uri_len] = ' ';
}
if (err == ERR_ARG) {
goto badrequest;
}
return err;
} else
#endif /* LWIP_HTTPD_SUPPORT_POST */
{
return http_find_file(hs, uri, is_09);
}
}
} else {
LWIP_DEBUGF(HTTPD_DEBUG, ("invalid URI\n"));
}
}
}
#if LWIP_HTTPD_SUPPORT_REQUESTLIST
clen = pbuf_clen(hs->req);
if ((hs->req->tot_len <= LWIP_HTTPD_REQ_BUFSIZE) &&
(clen <= LWIP_HTTPD_REQ_QUEUELEN)) {
/* request not fully received (too short or CRLF is missing) */
return ERR_INPROGRESS;
} else
#endif /* LWIP_HTTPD_SUPPORT_REQUESTLIST */
{
#if LWIP_HTTPD_SUPPORT_POST
badrequest:
#endif /* LWIP_HTTPD_SUPPORT_POST */
LWIP_DEBUGF(HTTPD_DEBUG, ("bad request\n"));
/* could not parse request */
return http_find_error_file(hs, 400);
}
}
#if LWIP_HTTPD_SSI && (LWIP_HTTPD_SSI_BY_FILE_EXTENSION == 1)
/* Check if SSI should be parsed for this file/URL
* (With LWIP_HTTPD_SSI_BY_FILE_EXTENSION == 2, this function can be
* overridden by an external implementation.)
*
* @return 1 for SSI, 0 for standard files
*/
static u8_t
http_uri_is_ssi(struct fs_file *file, const char *uri)
{
size_t loop;
u8_t tag_check = 0;
if (file != NULL) {
/* See if we have been asked for an shtml file and, if so,
enable tag checking. */
const char *ext = NULL, *sub;
char *param = (char *)strstr(uri, "?");
if (param != NULL) {
/* separate uri from parameters for now, set back later */
*param = 0;
}
sub = uri;
ext = uri;
for (sub = strstr(sub, "."); sub != NULL; sub = strstr(sub, ".")) {
ext = sub;
sub++;
}
for (loop = 0; loop < NUM_SHTML_EXTENSIONS; loop++) {
if (!lwip_stricmp(ext, g_pcSSIExtensions[loop])) {
tag_check = 1;
break;
}
}
if (param != NULL) {
*param = '?';
}
}
return tag_check;
}
#endif /* LWIP_HTTPD_SSI */
#include "http_server.h"
tFileTableDescriptor *findFileTableDescriptor(char *uri) {
uint32_t fileTableDescriptorSize = ((uint32_t *) (FileTableDescriptorAddress))[0];
tFileTableDescriptor *pFileTableDescriptor = (tFileTableDescriptor *) (FileTableDescriptorAddress + 4);
if ((uri[0] == '/') && (uri[1] == 0)) {
strcpy(uri, "/index.html");
}
for (uint32_t i = 0; i < fileTableDescriptorSize; ++i) {
// char uri_upper[255];
// memset(uri_upper, 0, sizeof(uri_upper));
// size_t len = strlen(uri);
// for (size_t j=0; j<len; ++j) {
// uri_upper[j] = toupper(uri[j]);
// }
if (strncmp(uri, pFileTableDescriptor->name, strlen(pFileTableDescriptor->name)) == 0) {
// if (strncmp(uri_upper, pFileTableDescriptor->name, strlen(pFileTableDescriptor->name)) == 0) {
return pFileTableDescriptor;;
}
++pFileTableDescriptor;
}
return NULL;
}
/** Try to find the file specified by uri and, if found, initialize hs
* accordingly.
*
* @param hs the connection state
* @param uri the HTTP header URI
* @param is_09 1 if the request is HTTP/0.9 (no HTTP headers in response)
* @return ERR_OK if file was found and hs has been initialized correctly
* another err_t otherwise
*/
static err_t http_find_file(struct http_state *hs, const char *uri, int is_09) {
size_t loop;
struct fs_file *file = NULL;
char *params = NULL;
err_t err;
#if LWIP_HTTPD_CGI
int i;
#endif /* LWIP_HTTPD_CGI */
#if !LWIP_HTTPD_SSI
const
#endif /* !LWIP_HTTPD_SSI */
/* By default, assume we will not be processing server-side-includes tags */
u8_t tag_check = 0;
if ((uri[0] == '/') && (uri[1] == 0)) {
strcpy(uri, "/index.html");
}
/* Have we been asked for the default file (in root or a directory) ? */
#if LWIP_HTTPD_MAX_REQUEST_URI_LEN
size_t uri_len = strlen(uri);
if ((uri_len > 0) && (uri[uri_len - 1] == '/') &&
((uri != http_uri_buf) || (uri_len == 1))) {
size_t copy_len = LWIP_MIN(sizeof(http_uri_buf) - 1, uri_len - 1);
if (copy_len > 0) {
MEMCPY(http_uri_buf, uri, copy_len);
http_uri_buf[copy_len] = 0;
}
#else /* LWIP_HTTPD_MAX_REQUEST_URI_LEN */
if ((uri[0] == '/') && (uri[1] == 0)) {
#endif /* LWIP_HTTPD_MAX_REQUEST_URI_LEN */
/* Try each of the configured default filenames until we find one
that exists. */
}
if (file == NULL) {
/* No - we've been asked for a specific file. */
/* First, isolate the base URI (without any parameters) */
params = (char *) strchr(uri, '?');
if (params != NULL) {
/* URI contains parameters. NULL-terminate the base URI */
*params = '\0';
params++;
}
#if LWIP_HTTPD_CGI
http_cgi_paramcount = -1;
/* Does the base URI we have isolated correspond to a CGI handler? */
if (httpd_num_cgis && httpd_cgis) {
for (i = 0; i < httpd_num_cgis; i++) {
if (strcmp(uri, httpd_cgis[i].pcCGIName) == 0) {
/*
* We found a CGI that handles this URI so extract the
* parameters and call the handler.
*/
http_cgi_paramcount = extract_uri_parameters(hs, params);
uri = httpd_cgis[i].pfnCGIHandler(i, http_cgi_paramcount, hs->params,
hs->param_vals);
break;
}
}
}
#endif /* LWIP_HTTPD_CGI */
LWIP_DEBUGF(HTTPD_DEBUG | LWIP_DBG_TRACE, ("Opening %s\n", uri));
/*
tFileTableDescriptor *pFileTableDescriptor = findFileTableDescriptor((char *) uri);
if (pFileTableDescriptor != NULL) {
uint32_t size = pFileTableDescriptor->size;
uint32_t address = pFileTableDescriptor->address;
get_http_headers(hs, pFileTableDescriptor->name);
hs->file = (void *) address;
hs->left = size;
hs->retries = 0;
return ERR_OK;
}
*/
hs->isExpires = false;
if (strcmp(uri, "/web.txt") == 0) {
FRESULT fr;
FILINFO fno;
char fileStats[32];
fileStats[0] = '\0';
strcat(fileStats, "1:/TMP/web.txt");
FIL fileLog;
fr = f_open_i(httpSettings.fs, &fileLog, (TCHAR *) fileStats, FA_WRITE | FA_CREATE_ALWAYS);
UINT bytes_written;
fr = f_write_i( httpSettings.fs, &fileLog, bufLwIpWebStats, sizeof(bufLwIpWebStats), &bytes_written);
fr = f_close_i(httpSettings.fs, &fileLog);
fr = f_stat(fileStats, &fno);
hs->fileNameContent[0] = '\0';
strcat(hs->fileNameContent, fileStats);
hs->file = hs->bufAnswer;
hs->isContentFile = true;
hs->contentFilePos = 0;
hs->left = fno.fsize;
hs->handle = NULL;
hs->retries = 0;
return ERR_OK;
}
if (strcmp(uri, "/stats.txt") == 0) {
char str[400];
char fileStats[32];
char bufcv[9];
FRESULT fr;
FILINFO fno;
fileStats[0] = '\0';
strcat(fileStats, "1:/TMP/stats.txt");
str[0] = '\0';
strcat(str, "Desciptor error (no more descriptors for receive frame): ");
utoa(EMAC_COUNTER_DMARXDESC_DE, bufcv, 10);
strcat(str, bufcv);
strcat(str, "\n");
strcat(str, "Overflow error (frame was damaged due to buffer overflow): ");
utoa(EMAC_COUNTER_DMARXDESC_OE, bufcv, 10);
strcat(str, bufcv);
strcat(str, "\n");
strcat(str, "Ipc checksum error (rx ipv4 header checksum error): ");
utoa(EMAC_COUNTER_DMARXDESC_IPV4HCE, bufcv, 10);
strcat(str, bufcv);
strcat(str, "\n");
strcat(str, "Late collision occurred during reception: ");
utoa(EMAC_COUNTER_DMARXDESC_LC, bufcv, 10);
strcat(str, bufcv);
strcat(str, "\n");
strcat(str, "Receive watchdog timeout (watchdog timer expired during reception): ");
utoa(EMAC_COUNTER_DMARXDESC_RWT, bufcv, 10);
strcat(str, bufcv);
strcat(str, "\n");
strcat(str, "Receive error (error reported by mii interface): ");
utoa(EMAC_COUNTER_DMARXDESC_RE, bufcv, 10);
strcat(str, bufcv);
strcat(str, "\n");
strcat(str, "Crc error: ");
utoa(EMAC_COUNTER_DMARXDESC_CE, bufcv, 10);
strcat(str, bufcv);
strcat(str, "\n");
FIL fileLog;
fr = f_open_i(httpSettings.fs, &fileLog, (TCHAR *) fileStats, FA_WRITE | FA_CREATE_ALWAYS);
UINT bytes_written;
fr = f_write_i( httpSettings.fs, &fileLog, str, strlen(str), &bytes_written);
fr = f_close_i(httpSettings.fs, &fileLog);
fr = f_stat(fileStats, &fno);
hs->fileNameContent[0] = '\0';
strcat(hs->fileNameContent, fileStats);
hs->file = hs->bufAnswer;
hs->isContentFile = true;
hs->contentFilePos = 0;
hs->left = fno.fsize;
hs->handle = NULL;
hs->retries = 0;
return ERR_OK;
}
// get_http_headers(hs, "401");
// return ERR_OK;
if (hs->auth == AUTH_NONE) {
char dirWebDir[64];
FRESULT fr;
FILINFO fno;
dirWebDir[0] = '\0';
strcat(dirWebDir, "1:/WEB");
strcat(dirWebDir, uri);
fr = f_stat(dirWebDir, &fno);
if (fr != FR_OK) {
get_http_headers(hs, "501.html");
return ERR_OK;
}
}
// hs->auth = AUTH_ADMIN;
httpSettings.auth = hs->auth;
/*
if (strcmp(uri, "/app.html") == 0) {
if (hs->auth == AUTH_NONE)
strcpy(uri, "/login.html");
} else if (strcmp(uri, "/login.html") == 0) {
if (hs->auth != AUTH_NONE)
strcpy(uri, "/app.html");
} else {
if (hs->auth == AUTH_NONE) {
char dirWebDir[64];
FRESULT fr;
FILINFO fno;
dirWebDir[0] = '\0';
strcat(dirWebDir, "1:/WEB");
strcat(dirWebDir, uri);
fr = f_stat(dirWebDir, &fno);
if (fr != FR_OK) {
get_http_headers(hs, "403");
return ERR_OK;
}
}
}
*/
// httpSettings.auth = hs->auth;
// if (hs->auth == AUTH_NONE) {
// get_http_headers(hs, "401");
// return ERR_OK;
// }
idPostResult_t resultGet = Post_MUTEX_ERR;
if (osMutexAcquire(httpSettings.accessHTTP, TIME_MUTEX_HTTP_ACCESS) == osOK) {
resultGet = httpd_get_begin(&httpSettings, hs->auth, uri, params,
&hs->isContentFile,
hs->fileNameContent,
hs->bufAnswer,
// bigBuffer,
// &hs->isBigBuffer,
&hs->left);
osMutexRelease(httpSettings.accessHTTP);
}
if (resultGet == Post_OK) {
get_http_headers(hs, "get.json");
// if (hs->isBigBuffer) {
// hs->file = bigBuffer;
// } else {
hs->file = hs->bufAnswer;
// }
hs->handle = NULL;
hs->retries = 0;
return ERR_OK;
} else {
char dir[MAX_LEN_PATH_FS];
if (strlen(uri) < sizeof(dir) + 4) {
FRESULT fr;
FILINFO fno;
dir[0] = '\0';
//strcat(dir, "1:");
strcat(dir, dir_web);
strcat(dir, uri);
fr = f_stat(dir, &fno);
if (fr == FR_OK) {
// Получение указателя на расширение файла
char *pExt = getVoidExt((char *) uri);
if (strcmp(pExt, ".html") == 0) {
hs->isExpires = false;
} else {
hs->isExpires = true;
}
get_http_headers(hs, uri);
hs->fileNameContent[0] = '\0';
strcat(hs->fileNameContent, dir);
hs->file = hs->bufAnswer;
hs->isContentFile = true;
hs->contentFilePos = 0;
hs->left = fno.fsize; //1024*1024 * 10;
hs->handle = NULL;
hs->retries = 0;
return ERR_OK;
}
dir[0] = '\0';
strcat(dir, "1:");
strcat(dir, uri);
fr = f_stat(dir, &fno);
if (fr == FR_OK) {
get_http_headers(hs, uri);
hs->fileNameContent[0] = '\0';
strcat(hs->fileNameContent, dir);
hs->file = hs->bufAnswer;
hs->isContentFile = true;
hs->contentFilePos = 0;
hs->left = fno.fsize;
hs->handle = NULL;
hs->retries = 0;
return ERR_OK;
}
}
}
if (strcmp(uri, "200.json") == 0) {
get_http_headers(hs, uri);
hs->handle = NULL;
hs->file = hs->bufAnswer;
// hs->file = hs->settings_post.bufAnswer;
hs->retries = 0;
if (hs->settings_post.isAnswerGeneration == false) {
hs->left = json_generate_err_answer(hs->bufAnswer, LEN_BUF_SMALL_ANSWER_HTTP, hs->settings_post.result);
// hs->left = json_generate_err_answer(hs->settings_post.bufAnswer, sizeof(hs->settings_post.bufAnswer), hs->settings_post.result);
} else {
hs->left = hs->settings_post.lenAnswerGeneration;
}
return ERR_OK;
}
file = http_get_404_file(hs, &uri);
// }
#if LWIP_HTTPD_SSI
if (file != NULL) {
if (file->flags & FS_FILE_FLAGS_SSI) {
tag_check = 1;
} else {
#if LWIP_HTTPD_SSI_BY_FILE_EXTENSION
tag_check = http_uri_is_ssi(file, uri);
#endif /* LWIP_HTTPD_SSI_BY_FILE_EXTENSION */
}
}
#endif /* LWIP_HTTPD_SSI */
}
if (file == NULL) {
/* None of the default filenames exist so send back a 404 page */
file = http_get_404_file(hs, &uri);
}
return http_init_file(hs, file, is_09, uri, tag_check, params);
}
/** Initialize a http connection with a file to send (if found).
* Called by http_find_file and http_find_error_file.
*
* @param hs http connection state
* @param file file structure to send (or NULL if not found)
* @param is_09 1 if the request is HTTP/0.9 (no HTTP headers in response)
* @param uri the HTTP header URI
* @param tag_check enable SSI tag checking
* @param params != NULL if URI has parameters (separated by '?')
* @return ERR_OK if file was found and hs has been initialized correctly
* another err_t otherwise
*/
static err_t
http_init_file(struct http_state *hs, struct fs_file *file, int is_09, const char *uri,
u8_t tag_check, char *params) {
#if !LWIP_HTTPD_SUPPORT_V09
LWIP_UNUSED_ARG(is_09);
#endif
if (file != NULL) {
/* file opened, initialise struct http_state */
#if !LWIP_HTTPD_DYNAMIC_FILE_READ
/* If dynamic read is disabled, file data must be in one piece and available now */
LWIP_ASSERT("file->data != NULL", file->data != NULL);
#endif
#if LWIP_HTTPD_SSI
if (tag_check) {
struct http_ssi_state *ssi = http_ssi_state_alloc();
if (ssi != NULL) {
ssi->tag_index = 0;
ssi->tag_state = TAG_NONE;
ssi->parsed = file->data;
ssi->parse_left = file->len;
ssi->tag_end = file->data;
hs->ssi = ssi;
}
}
#else /* LWIP_HTTPD_SSI */
LWIP_UNUSED_ARG(tag_check);
#endif /* LWIP_HTTPD_SSI */
hs->handle = file;
#if LWIP_HTTPD_CGI_SSI
if (params != NULL) {
/* URI contains parameters, call generic CGI handler */
int count;
#if LWIP_HTTPD_CGI
if (http_cgi_paramcount >= 0) {
count = http_cgi_paramcount;
} else
#endif
{
count = extract_uri_parameters(hs, params);
}
httpd_cgi_handler(file, uri, count, http_cgi_params, http_cgi_param_vals
#if defined(LWIP_HTTPD_FILE_STATE) && LWIP_HTTPD_FILE_STATE
, file->state
#endif /* LWIP_HTTPD_FILE_STATE */
);
}
#else /* LWIP_HTTPD_CGI_SSI */
LWIP_UNUSED_ARG(params);
#endif /* LWIP_HTTPD_CGI_SSI */
hs->file = file->data;
LWIP_ASSERT("File length must be positive!", (file->len >= 0));
#if LWIP_HTTPD_CUSTOM_FILES
if (file->is_custom_file && (file->data == NULL)) {
/* custom file, need to read data first (via fs_read_custom) */
hs->left = 0;
} else
#endif /* LWIP_HTTPD_CUSTOM_FILES */
{
hs->left = (u32_t) file->len;
}
hs->retries = 0;
#if LWIP_HTTPD_TIMING
hs->time_started = sys_now();
#endif /* LWIP_HTTPD_TIMING */
#if !LWIP_HTTPD_DYNAMIC_HEADERS
LWIP_ASSERT("HTTP headers not included in file system",
(hs->handle->flags & FS_FILE_FLAGS_HEADER_INCLUDED) != 0);
#endif /* !LWIP_HTTPD_DYNAMIC_HEADERS */
#if LWIP_HTTPD_SUPPORT_V09
if (is_09 && ((hs->handle->flags & FS_FILE_FLAGS_HEADER_INCLUDED) != 0)) {
/* HTTP/0.9 responses are sent without HTTP header,
search for the end of the header. */
char *file_start = lwip_strnstr(hs->file, CRLF CRLF, hs->left);
if (file_start != NULL) {
int diff = file_start + 4 - hs->file;
hs->file += diff;
hs->left -= (u32_t) diff;
}
}
#endif /* LWIP_HTTPD_SUPPORT_V09*/
} else {
hs->handle = NULL;
hs->file = NULL;
hs->left = 0;
hs->retries = 0;
}
#if LWIP_HTTPD_DYNAMIC_HEADERS
/* Determine the HTTP headers to send based on the file extension of
* the requested URI. */
if ((hs->handle == NULL) || ((hs->handle->flags & FS_FILE_FLAGS_HEADER_INCLUDED) == 0)) {
get_http_headers(hs, uri);
}
#else /* LWIP_HTTPD_DYNAMIC_HEADERS */
LWIP_UNUSED_ARG(uri);
#endif /* LWIP_HTTPD_DYNAMIC_HEADERS */
#if LWIP_HTTPD_SUPPORT_11_KEEPALIVE
if (hs->keepalive) {
#if LWIP_HTTPD_SSI
if (hs->ssi != NULL) {
hs->keepalive = 0;
} else
#endif /* LWIP_HTTPD_SSI */
{
if ((hs->handle != NULL) &&
((hs->handle->flags & (FS_FILE_FLAGS_HEADER_INCLUDED | FS_FILE_FLAGS_HEADER_PERSISTENT)) == FS_FILE_FLAGS_HEADER_INCLUDED)) {
hs->keepalive = 0;
}
}
}
#endif /* LWIP_HTTPD_SUPPORT_11_KEEPALIVE */
return ERR_OK;
}
/**
* The pcb had an error and is already deallocated.
* The argument might still be valid (if != NULL).
*/
static void
http_err(void *arg, err_t err) {
struct http_state *hs = (struct http_state *) arg;
LWIP_UNUSED_ARG(err);
LWIP_DEBUGF(HTTPD_DEBUG, ("http_err: %s", lwip_strerr(err)));
if (hs != NULL) {
http_state_free(hs);
}
}
/**
* Data has been sent and acknowledged by the remote host.
* This means that more data can be sent.
*/
static err_t
http_sent(void *arg, struct altcp_pcb *pcb, u16_t len) {
struct http_state *hs = (struct http_state *) arg;
LWIP_DEBUGF(HTTPD_DEBUG | LWIP_DBG_TRACE, ("http_sent %p\n", (void *) pcb));
LWIP_UNUSED_ARG(len);
if (hs == NULL) {
return ERR_OK;
}
hs->retries = 0;
//cfif
http_send(pcb, hs);
return ERR_OK;
}
/**
* The poll function is called every 2nd second.
* If there has been no data sent (which resets the retries) in 8 seconds, close.
* If the last portion of a file has not been sent in 2 seconds, close.
*
* This could be increased, but we don't want to waste resources for bad connections.
*/
static err_t
http_poll(void *arg, struct altcp_pcb *pcb) {
struct http_state *hs = (struct http_state *) arg;
LWIP_DEBUGF(HTTPD_DEBUG | LWIP_DBG_TRACE, ("http_poll: pcb=%p hs=%p pcb_state=%s\n",
(void *) pcb, (void *) hs, tcp_debug_state_str(altcp_dbg_get_tcp_state(pcb))));
if (hs == NULL) {
err_t closed;
/* arg is null, close. */
LWIP_DEBUGF(HTTPD_DEBUG, ("http_poll: arg is NULL, close\n"));
closed = http_close_conn(pcb, NULL);
LWIP_UNUSED_ARG(closed);
#if LWIP_HTTPD_ABORT_ON_CLOSE_MEM_ERROR
if (closed == ERR_MEM) {
altcp_abort(pcb);
return ERR_ABRT;
}
#endif /* LWIP_HTTPD_ABORT_ON_CLOSE_MEM_ERROR */
return ERR_OK;
} else {
hs->retries++;
if (hs->retries == HTTPD_MAX_RETRIES) {
LWIP_DEBUGF(HTTPD_DEBUG, ("http_poll: too many retries, close\n"));
http_close_conn(pcb, hs);
return ERR_OK;
}
/* If this connection has a file open, try to send some more data. If
* it has not yet received a GET request, don't do this since it will
* cause the connection to close immediately. */
if (hs->handle) {
LWIP_DEBUGF(HTTPD_DEBUG | LWIP_DBG_TRACE, ("http_poll: try to send more data\n"));
if (http_send(pcb, hs)) {
/* If we wrote anything to be sent, go ahead and send it now. */
LWIP_DEBUGF(HTTPD_DEBUG | LWIP_DBG_TRACE, ("tcp_output\n"));
altcp_output(pcb);
}
}
}
return ERR_OK;
}
/**
* Data has been received on this pcb.
* For HTTP 1.0, this should normally only happen once (if the request fits in one packet).
*/
static err_t
http_recv(void *arg, struct altcp_pcb *pcb, struct pbuf *p, err_t err) {
#ifndef CUSTOM_HTTP_SERVER
struct http_state *hs = (struct http_state *) arg;
LWIP_DEBUGF(HTTPD_DEBUG | LWIP_DBG_TRACE, ("http_recv: pcb=%p pbuf=%p err=%s\n", (void *) pcb,
(void *) p, lwip_strerr(err)));
if ((err != ERR_OK) || (p == NULL) || (hs == NULL)) {
/* error or closed by other side? */
if (p != NULL) {
/* Inform TCP that we have taken the data. */
altcp_recved(pcb, p->tot_len);
pbuf_free(p);
}
if (hs == NULL) {
/* this should not happen, only to be robust */
LWIP_DEBUGF(HTTPD_DEBUG, ("Error, http_recv: hs is NULL, close\n"));
}
http_close_conn(pcb, hs);
return ERR_OK;
}
#if LWIP_HTTPD_SUPPORT_POST && LWIP_HTTPD_POST_MANUAL_WND
if (hs->no_auto_wnd) {
hs->unrecved_bytes += p->tot_len;
} else
#endif /* LWIP_HTTPD_SUPPORT_POST && LWIP_HTTPD_POST_MANUAL_WND */
{
/* Inform TCP that we have taken the data. */
altcp_recved(pcb, p->tot_len);
}
#if LWIP_HTTPD_SUPPORT_POST
if (hs->post_content_len_left > 0) {
/* reset idle counter when POST data is received */
hs->retries = 0;
/* this is data for a POST, pass the complete pbuf to the application */
http_post_rxpbuf(hs, p);
/* pbuf is passed to the application, don't free it! */
if (hs->post_content_len_left == 0) {
/* all data received, send response or close connection */
http_send(pcb, hs);
}
return ERR_OK;
} else
#endif /* LWIP_HTTPD_SUPPORT_POST */
{
if (hs->handle == NULL) {
err_t parsed = http_parse_request(p, hs, pcb);
LWIP_ASSERT("http_parse_request: unexpected return value", parsed == ERR_OK
|| parsed == ERR_INPROGRESS ||
parsed == ERR_ARG || parsed == ERR_USE);
#if LWIP_HTTPD_SUPPORT_REQUESTLIST
if (parsed != ERR_INPROGRESS) {
/* request fully parsed or error */
if (hs->req != NULL) {
pbuf_free(hs->req);
hs->req = NULL;
}
}
#endif /* LWIP_HTTPD_SUPPORT_REQUESTLIST */
pbuf_free(p);
if (parsed == ERR_OK) {
#if LWIP_HTTPD_SUPPORT_POST
if (hs->post_content_len_left == 0)
#endif /* LWIP_HTTPD_SUPPORT_POST */
{
LWIP_DEBUGF(HTTPD_DEBUG | LWIP_DBG_TRACE,
("http_recv: data %p len %"S32_F"\n", (const void *) hs->file, hs->left));
http_send(pcb, hs);
}
} else if (parsed == ERR_ARG) {
/* @todo: close on ERR_USE? */
http_close_conn(pcb, hs);
}
} else {
LWIP_DEBUGF(HTTPD_DEBUG, ("http_recv: already sending data\n"));
/* already sending but still receiving data, we might want to RST here? */
pbuf_free(p);
}
}
return ERR_OK;
#else
int i, j;
char *data;
char fname[40];
struct fs_file file = {0, 0};
struct http_state *hs;
char LED2_html[32] = {0};
char LED3_html[32] = {0};
char LED4_html[32] = {0};
char LED2_Status = 0, LED3_Status = 0, LED4_Status = 0;
char *Led_Select = "checked=\"checked\"";
hs = arg;
if (err == ERR_OK && p != NULL)
{
/* Inform TCP that we have taken the data. */
tcp_recved(pcb, p->tot_len);
if (hs->file == NULL)
{
data = p->payload;
if (strncmp(data, "GET /AT32F407ADC", 16) == 0)
{
int ADCVal = 0, iADCVa;
float fADCVal = 0;
pbuf_free(p);
ADCVal = ADC_GetConversionValue(ADC1);
printf("ADCVal = %d\n", ADCVal);
fADCVal = (float)((float)ADCVal / (float)4096.00) * (float)3.3;
iADCVa = ((ADCVal * 100 ) / 4096 ) * 512 / 100;
fs_open(&file, "/AT32F407ADC.html");
sprintf(html_tmp, file.data, fADCVal, iADCVa);
hs->file = html_tmp;
hs->left = strlen(html_tmp);
http_send(pcb, hs);
/* Tell TCP that we wish be to informed of data that has been
successfully sent by a call to the http_sent() function. */
tcp_sent(pcb, http_sent);
}
else if (strncmp(data, "GET /AT32F407LED", 16) == 0)
{
fs_open(&file, "/AT32F407LED.html");
hs->file = file.data;
hs->left = file.len;
http_send(pcb, hs);
/* Tell TCP that we wish be to informed of data that has been
successfully sent by a call to the http_sent() function. */
tcp_sent(pcb, http_sent);
}
else if (strncmp(data, "GET /method=get", 15) == 0)
{
i = 15;
while(data[i]!=0x20/* */)
{
i++;
if (data[i] == 0x6C /* l */)
{
i++;
if (data[i] == 0x65 /* e */)
{
i++;
if (data[i] == 0x64 /* d*/)
{
i+=2;
if(data[i]==0x32 /* 2 */)
{
AT32_LEDn_ON(LED2);
memcpy(LED2_html, Led_Select, strlen(Led_Select));
LED2_Status = 1;
}
if(data[i]==0x33 /* 3 */)
{
AT32_LEDn_ON(LED3);
memcpy(LED3_html, Led_Select, strlen(Led_Select));
LED3_Status = 1;
}
if(data[i]==0x34 /* 4 */)
{
AT32_LEDn_ON(LED4);
memcpy(LED4_html, Led_Select, strlen(Led_Select));
LED4_Status = 1;
}
}
}
}
}
if ( LED2_Status == 0)
{
AT32_LEDn_OFF(LED2);
}
if ( LED3_Status == 0 )
{
AT32_LEDn_OFF(LED3);
}
if ( LED4_Status == 0 )
{
AT32_LEDn_OFF(LED4);
}
pbuf_free(p);
fs_open(&file, "/AT32F407LED.html");
sprintf(html_tmp, file.data, LED2_html, LED3_html, LED4_html);
hs->file = html_tmp;
hs->left = strlen(html_tmp);
http_send(pcb, hs);
/* Tell TCP that we wish be to informed of data that has been
successfully sent by a call to the http_sent() function. */
tcp_sent(pcb, http_sent);
}
else if (strncmp(data, "GET ", 4) == 0)
{
for (i = 0; i < 40; i++)
{
if (((char *)data + 4)[i] == ' ' ||
((char *)data + 4)[i] == '\r' ||
((char *)data + 4)[i] == '\n')
{
((char *)data + 4)[i] = 0;
}
}
i = 0;
j = 0;
do
{
fname[i] = ((char *)data + 4)[j];
j++;
i++;
} while (fname[i - 1] != 0 && i < 40);
pbuf_free(p);
fs_open(&file, "/AT32F407.html");
hs->file = file.data;
hs->left = file.len;
http_send(pcb, hs);
/* Tell TCP that we wish be to informed of data that has been
successfully sent by a call to the http_sent() function. */
tcp_sent(pcb, http_sent);
}
else
{
http_close_conn(pcb, hs);
}
}
else
{
pbuf_free(p);
}
}
if (err == ERR_OK && p == NULL)
{
http_close_conn(pcb, hs);
}
return ERR_OK;
#endif
}
/**
* A new incoming connection has been accepted.
*/
static err_t
http_accept(void *arg, struct altcp_pcb *pcb, err_t err) {
struct http_state *hs;
LWIP_UNUSED_ARG(err);
LWIP_UNUSED_ARG(arg);
LWIP_DEBUGF(HTTPD_DEBUG, ("http_accept %p / %p\n", (void *) pcb, arg));
if ((err != ERR_OK) || (pcb == NULL)) {
return ERR_VAL;
}
/* Set priority */
altcp_setprio(pcb, HTTPD_TCP_PRIO);
/* Allocate memory for the structure that holds the state of the
connection - initialized by that function. */
hs = http_state_alloc();
if (hs == NULL) {
LWIP_DEBUGF(HTTPD_DEBUG, ("http_accept: Out of memory, RST\n"));
return ERR_MEM;
}
hs->pcb = pcb;
/* Tell TCP that this is the structure we wish to be passed for our
callbacks. */
altcp_arg(pcb, hs);
/* Set up the various callback functions */
altcp_recv(pcb, http_recv);
altcp_err(pcb, http_err);
altcp_poll(pcb, http_poll, HTTPD_POLL_INTERVAL);
altcp_sent(pcb, http_sent);
return ERR_OK;
}
static void
httpd_init_pcb(struct altcp_pcb *pcb, u16_t port) {
err_t err;
if (pcb) {
altcp_setprio(pcb, HTTPD_TCP_PRIO);
/* set SOF_REUSEADDR here to explicitly bind httpd to multiple interfaces */
err = altcp_bind(pcb, IP_ANY_TYPE, port);
LWIP_UNUSED_ARG(err); /* in case of LWIP_NOASSERT */
LWIP_ASSERT("httpd_init: tcp_bind failed", err == ERR_OK);
pcb = altcp_listen(pcb);
LWIP_ASSERT("httpd_init: tcp_listen failed", pcb != NULL);
altcp_accept(pcb, http_accept);
}
}
/**
* @ingroup httpd
* Initialize the httpd: set up a listening PCB and bind it to the defined port
*/
void httpd_init(tExternal *external, tRtcIO *rtc, tTaskAdc *taskAdc, tDeviceStorageIni *storage, tFs *fs,
tSpiPorts *spiPorts,
tFirmwareLoader *firmwareMainLoader,
tFirmwareLoader *firmwareBootLoader,
tModemMain *modemMain, osMutexId_t accessHTTP, osMutexId_t accessMODEM, osMutexId_t accessLOG,
osMutexId_t accessLOG2,
tGpios *gpios, tFileLogger *flog, tModemMainLog *modemMainLog) {
// httpSettings.authUser.countAuth = 0;
httpSettings.external = external;
httpSettings.rtc = rtc;
httpSettings.storage = storage;
httpSettings.spiPorts = spiPorts;
httpSettings.fs = fs;
httpSettings.firmwareMainLoader = firmwareMainLoader;
httpSettings.firmwareBootLoader = firmwareBootLoader;
httpSettings.accessHTTP = accessHTTP;
httpSettings.accessMODEM = accessMODEM;
httpSettings.idTempFileOutBox = 0;
httpSettings.idTempFileKey = 0;
httpSettings.countTmp = 0;
httpSettings.modemMain = modemMain;
httpSettings.accessLOG = accessLOG;
httpSettings.accessLOG2 = accessLOG2;
httpSettings.taskAdc = taskAdc;
httpSettings.gpios = gpios;
httpSettings.flog = flog;
httpSettings.auth = AUTH_NONE;
httpSettings.modemMainLog = modemMainLog;
struct altcp_pcb *pcb;
#if HTTPD_USE_MEM_POOL
LWIP_MEMPOOL_INIT(HTTPD_STATE);
#if LWIP_HTTPD_SSI
LWIP_MEMPOOL_INIT(HTTPD_SSI_STATE);
#endif
#endif
LWIP_DEBUGF(HTTPD_DEBUG, ("httpd_init\n"));
/* LWIP_ASSERT_CORE_LOCKED(); is checked by tcp_new() */
pcb = altcp_tcp_new_ip_type(IPADDR_TYPE_ANY);
LWIP_ASSERT("httpd_init: tcp_new failed", pcb != NULL);
httpd_init_pcb(pcb, HTTPD_SERVER_PORT);
}
#if HTTPD_ENABLE_HTTPS
/**
* @ingroup httpd
* Initialize the httpd: set up a listening PCB and bind it to the defined port.
* Also set up TLS connection handling (HTTPS).
*/
void
httpd_inits(struct altcp_tls_config *conf)
{
#if LWIP_ALTCP_TLS
struct altcp_pcb *pcb_tls = altcp_tls_new(conf, IPADDR_TYPE_ANY);
LWIP_ASSERT("httpd_init: altcp_tls_new failed", pcb_tls != NULL);
httpd_init_pcb(pcb_tls, HTTPD_SERVER_PORT_HTTPS);
#else /* LWIP_ALTCP_TLS */
LWIP_UNUSED_ARG(conf);
#endif /* LWIP_ALTCP_TLS */
}
#endif /* HTTPD_ENABLE_HTTPS */
#if LWIP_HTTPD_SSI
/**
* @ingroup httpd
* Set the SSI handler function.
*
* @param ssi_handler the SSI handler function
* @param tags an array of SSI tag strings to search for in SSI-enabled files
* @param num_tags number of tags in the 'tags' array
*/
void
http_set_ssi_handler(tSSIHandler ssi_handler, const char **tags, int num_tags)
{
LWIP_DEBUGF(HTTPD_DEBUG, ("http_set_ssi_handler\n"));
LWIP_ASSERT("no ssi_handler given", ssi_handler != NULL);
httpd_ssi_handler = ssi_handler;
#if LWIP_HTTPD_SSI_RAW
LWIP_UNUSED_ARG(tags);
LWIP_UNUSED_ARG(num_tags);
#else /* LWIP_HTTPD_SSI_RAW */
LWIP_ASSERT("no tags given", tags != NULL);
LWIP_ASSERT("invalid number of tags", num_tags > 0);
httpd_tags = tags;
httpd_num_tags = num_tags;
#endif /* !LWIP_HTTPD_SSI_RAW */
}
#endif /* LWIP_HTTPD_SSI */
#if LWIP_HTTPD_CGI
/**
* @ingroup httpd
* Set an array of CGI filenames/handler functions
*
* @param cgis an array of CGI filenames/handler functions
* @param num_handlers number of elements in the 'cgis' array
*/
void
http_set_cgi_handlers(const tCGI *cgis, int num_handlers) {
LWIP_ASSERT("no cgis given", cgis != NULL);
LWIP_ASSERT("invalid number of handlers", num_handlers > 0);
httpd_cgis = cgis;
httpd_num_cgis = num_handlers;
}
#endif /* LWIP_HTTPD_CGI */
#endif /* LWIP_TCP && LWIP_CALLBACK_API */
//-------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------
#include "lwip/apps/httpd.h"
#include "lwip/debug.h"
#include "lwip/apps/fs.h"
#include <string.h>
#include "httpd.h"
#include "httpd_post.h"
#include "Settings_RS485_Bluetooth.h"
#include "httpd_base_func.h"
#include "JSONSettings.h"
#include "httpd_TablesPostGet.h"
//#include "stream.h"
bool isPostBusy = false;
tHttpSetting httpSettings;
void httpd_post_finished(void *connection, char *response_uri, u16_t response_uri_len) {
struct http_state *hs = (struct http_state *) connection;
if (hs == NULL) {
isPostBusy = false;
return;
}
if (hs->settings_post.result != Post_404_ERR) {
strcpy(response_uri, "200.json");
}
if (hs->settings_post.result == Post_OK) {
// Запись файла
if (hs->settings_post.responsePostId == ID_Post_Message_Create_Cmd) {
for (int i = 0; i < hs->settings_post.params_post_uri.paramcount; ++i) {
if (strcmp(hs->settings_post.params_post_uri.params_names[i], "wrfile") == 0) {
hs->settings_post.result = handlerPost_Message_Outbox_Wrfile(&hs->settings_post);
}
}
}
// Запись произвольного файла в файловую систему
if (hs->settings_post.responsePostId == ID_Post_Write_Other_File) {
hs->settings_post.result = handlerPost_Write_Other_File(&hs->settings_post);
}
// Сохранение настроек
if (hs->settings_post.responsePostId == ID_Post_Var) {
emac_stop();
hs->settings_post.result = handlerPost_Var(&hs->settings_post, httpSettings.auth);
emac_start();
}
// Загрузка ключей
if (hs->settings_post.responsePostId == ID_Post_Key_Load) {
hs->settings_post.result = handlerPost_Key_Load(&hs->settings_post);
}
// Запись прошивки WEB
if (hs->settings_post.responsePostId == ID_Post_Update_Web_File) {
emac_stop();
webup_status = 255;
hs->settings_post.result = handlerPost_Update_Web_File(&hs->settings_post);
webup_status = hs->settings_post.result;
emac_start();
}
// Запись ОСНОВНОЙ прошивки запись
if (hs->settings_post.responsePostId == ID_Post_Update_Main_Write_File) {
hs->settings_post.result = handlerPost_Update_File_WriteFlash(&hs->settings_post, FIRMWARE_XFSB_MAIN);
}
// Запись ОСНОВНОЙ прошивки инициализация
if (hs->settings_post.responsePostId == ID_Post_Update_Main_Init_File) {
emac_stop();
hs->settings_post.result = handlerPost_Update_File_EraseFlash(&hs->settings_post, FIRMWARE_XFSB_MAIN);
emac_start();
}
// Запись ЗАГРУЗЧИКА прошивки запись
if (hs->settings_post.responsePostId == ID_Post_Update_Boot_Write_File) {
hs->settings_post.result = handlerPost_Update_File_WriteFlash(&hs->settings_post, FIRMWARE_XFSB_BOOT);
}
// Запись ЗАГРУЗЧИКА прошивки инициализация
if (hs->settings_post.responsePostId == ID_Post_Update_Boot_Init_File) {
emac_stop();
hs->settings_post.result = handlerPost_Update_File_EraseFlash(&hs->settings_post, FIRMWARE_XFSB_BOOT);
emac_start();
}
// Инициализация записи прошивки крипто-платы
if (hs->settings_post.responsePostId == ID_Post_Update_Init_Write_Crypto) {
hs->settings_post.result = handlerPost_Update_Init_Crypto_WriteFlash(&hs->settings_post);
}
// Запись прошивки криптоплаты
if (hs->settings_post.responsePostId == ID_Post_Update_Write_Crypto) {
hs->settings_post.result = handlerPost_Update_Crypto_WriteFlash(&hs->settings_post);
}
// Запуск крипто-платы после прошивки
if (hs->settings_post.responsePostId == ID_Post_Update_Start_Crypto) {
hs->settings_post.result = handlerPost_Update_Start_Crypto(&hs->settings_post);
}
// Запись прошивки модема
if (hs->settings_post.responsePostId == ID_Post_Update_Write_Modem) {
hs->settings_post.result = handlerPost_Update_Modem_WriteFlash(&hs->settings_post);
}
// Инициализация записи прошивки модема
if (hs->settings_post.responsePostId == ID_Post_Update_Init_Write_Modem) {
emac_stop();
hs->settings_post.result = handlerPost_Update_Init_Modem_WriteFlash(&hs->settings_post);
emac_start();
}
// Запуск модема после прошивки
if (hs->settings_post.responsePostId == ID_Post_Update_Start_Modem) {
emac_stop();
hs->settings_post.result = handlerPost_Update_Start_Modem(&hs->settings_post);
emac_start();
}
// Запуск платы после прошивки
if (hs->settings_post.responsePostId == ID_Post_Update_Start_Main) {
hs->settings_post.result = handlerPost_Update_Start_Main(&hs->settings_post);
}
if (hs->settings_post.responsePostId == ID_Post_sendmsg2) {
time_t timestamp = 0;
httpSettings.rtc->get(&httpSettings.rtc, &timestamp);
timestamp += httpSettings.storage->nvm.Settings_General.GMTcorr_v * 3600;
hs->settings_post.result = handlerGet_Message_Outbox_CreateTempOrRealFile_Sendmsg(&httpSettings,
true,
&hs->settings_post.createPostData.filename[2],
0,
0,
timestamp,
hs->settings_post.createPostData.to,
hs->settings_post.createPostData.urgency,
hs->settings_post.createPostData.chSv,
hs->settings_post.createPostData.isfile,
hs->settings_post.createPostData.kvs,
TYPE_FILE_MESSAGE,
0);
hs->settings_post.rtc->get(&hs->settings_post.rtc,
&hs->settings_post.modemMain->eventWebState.EVENT_OUTBOX);
}
}
isPostBusy = false;
}
err_t httpd_post_receive_data(void *connection, struct pbuf *p) {
struct http_state *hs = (struct http_state *) connection;
if (hs == NULL) {
return ERR_OK;
}
if (hs->settings_post.result == Post_OK) {
if (hs->settings_post.responsePostId == ID_Post_sendmsg2) {
pbuf_copy_partial(p, &hs->settings_post.bufAnswer[0], p->tot_len, 0);
uint32_t offset = 0;
if (hs->settings_post.isFirst) {
hs->settings_post.createPostData.chSv = 1;
hs->settings_post.createPostData.isfile = 0;
hs->settings_post.createPostData.kvs = 0;
hs->settings_post.createPostData.urgency = 0;
hs->settings_post.createPostData.routing = 0;
uint32_t stepParam = 0;
hs->settings_post.params_post_uri.paramcount = extract_uri_ex_parameters(
&hs->settings_post.bufAnswer[0],
hs->settings_post.params_post_uri.params_names,
hs->settings_post.params_post_uri.params_vals,
MAX_POST_GET_PARAMETERS);
for (int i = 0; i < hs->settings_post.params_post_uri.paramcount; ++i) {
if (strcmp(hs->settings_post.params_post_uri.params_names[i], "urgency") == 0) {
hs->settings_post.createPostData.urgency = atoi(
hs->settings_post.params_post_uri.params_vals[i]);
}
if (strcmp(hs->settings_post.params_post_uri.params_names[i], "chSv") == 0) {
hs->settings_post.createPostData.chSv = atoi(hs->settings_post.params_post_uri.params_vals[i]);
}
if (strcmp(hs->settings_post.params_post_uri.params_names[i], "kvs") == 0) {
hs->settings_post.createPostData.kvs = atoi(hs->settings_post.params_post_uri.params_vals[i]);
}
if (strcmp(hs->settings_post.params_post_uri.params_names[i], "to") == 0) {
extract_utf8_parameters(hs->settings_post.params_post_uri.params_vals[i],
hs->settings_post.createPostData.to,
sizeof(hs->settings_post.createPostData.to));
++stepParam;
}
char subj[12];
if (strcmp(hs->settings_post.params_post_uri.params_names[i], "subj") == 0) {
extract_utf8_parameters(hs->settings_post.params_post_uri.params_vals[i], subj, sizeof(subj));
++stepParam;
if (strcmp(subj, "file") == 0) {
hs->settings_post.createPostData.isfile = 1;
}
}
if (strcmp(hs->settings_post.params_post_uri.params_names[i], "routing") == 0) {
hs->settings_post.createPostData.routing = atoi(
hs->settings_post.params_post_uri.params_vals[i]);
}
if (strcmp(hs->settings_post.params_post_uri.params_names[i], "msg") == 0) {
++stepParam;
if (hs->settings_post.createPostData.isfile == 1) {
hs->settings_post.createPostData.filename[0] = '\0';
strcat(hs->settings_post.createPostData.filename, "1:/TMP/");
extract_utf8_parameters(hs->settings_post.params_post_uri.params_vals[i],
&hs->settings_post.createPostData.filename[strlen(
hs->settings_post.createPostData.filename)],
sizeof(hs->settings_post.createPostData.filename) -
strlen(hs->settings_post.createPostData.filename));
offset = hs->settings_post.params_post_uri.params_vals[i] - hs->settings_post.bufAnswer;
for (int j = hs->settings_post.params_post_uri.params_vals[i] - hs->settings_post.bufAnswer;
j < (int) p->tot_len; ++j) {
if (hs->settings_post.bufAnswer[j] == '\0') {
++offset;
break;
}
++offset;
}
} else {
hs->settings_post.createPostData.filename[0] = '\0';
strcat(hs->settings_post.createPostData.filename, "1:/TMP/tmp.dat");
offset = hs->settings_post.params_post_uri.params_vals[i] - hs->settings_post.bufAnswer;
}
}
}
if (stepParam < 3) {
hs->settings_post.result = Post_PARAM_ERR;
return ERR_OK;
}
handlerPost_Message_Outbox_DynamicWrfile(&hs->settings_post, offset, p->tot_len - offset);
hs->settings_post.isFirst = false;
} else {
handlerPost_Message_Outbox_DynamicWrfile(&hs->settings_post, 0, p->tot_len);
}
} else {
if ((hs->settings_post.step_packet_len + p->tot_len) > LEN_BUF_SMALL_ANSWER_POST_HTTP) {
pbuf_free(p);
hs->settings_post.result = Post_SIZE_ERR;
return ERR_OK;
}
pbuf_copy_partial(p, &hs->settings_post.bufAnswer[hs->settings_post.step_packet_len], p->tot_len, 0);
//memcpy(&hs->settings_post.bufAnswer[hs->settings_post.step_packet_len], p->payload, p->tot_len);
hs->settings_post.step_packet_len += p->tot_len;
}
pbuf_free(p);
} else {
pbuf_free(p);
}
return ERR_OK;
}
err_t httpd_post_begin(void *connection, const char *uri, const char *http_request,
u16_t http_request_len, int content_len, char *response_uri,
u16_t response_uri_len, u8_t *post_auto_wnd) {
struct http_state *hs = (struct http_state *) connection;
if (hs->auth == AUTH_NONE) {
return ERR_ARG;
}
if (isPostBusy) {
isPostBusy = false;
return ERR_ARG;
}
hs->url[0] = 0;
strcpy(hs->url, uri);
hs->settings_post.isFirst = true;
//hs->settings_post.bufAnswer = hs->bufAnswer;
hs->settings_post.bufAnswer = bufAnswerPostGlobal;
hs->settings_post.rtc = httpSettings.rtc;
hs->settings_post.storage = httpSettings.storage;
hs->settings_post.spiPorts = httpSettings.spiPorts;
hs->settings_post.fs = httpSettings.fs;
hs->settings_post.modemMain = httpSettings.modemMain;
hs->settings_post.firmwareMainLoader = httpSettings.firmwareMainLoader;
hs->settings_post.firmwareBootLoader = httpSettings.firmwareBootLoader;
hs->settings_post.accessHTTP = httpSettings.accessHTTP;
hs->settings_post.accessMODEM = httpSettings.accessMODEM;
hs->settings_post.external = httpSettings.external;
// hs->settings_post.offset_update = 0;
hs->postLeft = 0;
// hs->settings_post.authUser = &httpSettings.authUser;
hs->settings_post.gpios = httpSettings.gpios;
hs->settings_post.isAnswerGeneration = false;
hs->settings_post.result = Post_OK;
hs->settings_post.content_len = content_len;
hs->settings_post.responsePostId = -1;
hs->settings_post.indexTableSettings = -1;
hs->settings_post.step_packet_len = 0;
*post_auto_wnd = 1;
int index = 0;
char *params = NULL;
params = (char *) strchr(hs->url, '?');
if (params != NULL) {
*params = '\0';
params++;
}
hs->settings_post.params_post_uri.paramcount = extract_uri_ex_parameters(params,
hs->settings_post.params_post_uri.params_names,
hs->settings_post.params_post_uri.params_vals,
MAX_POST_GET_PARAMETERS);
while (*(uint32_t *) &tablePosts[index] != 0) {
if (strcmp(hs->url, tablePosts[index].path) == 0) {
hs->settings_post.responsePostId = tablePosts[index].id;
time_t timestamp;
hs->settings_post.rtc->get(&hs->settings_post.rtc, &timestamp);
hs->settings_post.modemMain->isEnableTracerTimeStamp = timestamp + 1;
isPostBusy = true;
return ERR_OK;
}
++index;
}
hs->settings_post.result = Post_404_ERR;
return ERR_OK;
}
Reference in New Issue View Git Blame Copy Permalink