source: EcnlProtoTool/trunk/ntshell/webserver/httpd.c@ 278

/*
 *  TOPPERS ECHONET Lite Communication Middleware
 *
 *  Copyright (C) 2017 Cores Co., Ltd. Japan
 *
 *  上記著作権者
は，以下の(1)～(4)ã®æ¡ä»¶ã‚’æº€ãŸã™å ´åˆã«é™ã‚Šï¼Œæœ¬ã‚½ãƒ•ãƒˆã‚¦ã‚§
 *  ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改
 *  変・再é…
å¸ƒï¼ˆä»¥ä¸‹ï¼Œåˆ©ç”¨ã¨å‘¼ã¶ï¼‰ã™ã‚‹ã“とを無償で許諾する．
 *  (1) æœ¬ã‚½ãƒ•ãƒˆã‚¦ã‚§ã‚¢ã‚’ã‚½ãƒ¼ã‚¹ã‚³ãƒ¼ãƒ‰ã®å½¢ã§åˆ©ç”¨ã™ã‚‹å ´åˆã«ã¯ï¼Œä¸Šè¨˜ã®è‘—ä½œ
 *      権表示，この利用条件および下記の無保証規定が，そのままの形でソー
 *      スコード中に含まれていること．
 *  (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使
 *      用できる形で再é…
å¸ƒã™ã‚‹å ´åˆã«ã¯ï¼Œå†é…
å¸ƒã«ä¼´ã†ãƒ‰ã‚­ãƒ¥ãƒ¡ãƒ³ãƒˆï¼ˆåˆ©ç”¨
 *      者
マニュアルなど）に，上記の著作権表示，この利用条件および下記
 *      の無保証規定を掲載すること．
 *  (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使
 *      用できない形で再é…
å¸ƒã™ã‚‹å ´åˆã«ã¯ï¼Œæ¬¡ã®ã„ずれかの条件を満たすこ
 *      と．
 *    (a) 再é…
å¸ƒã«ä¼´ã†ãƒ‰ã‚­ãƒ¥ãƒ¡ãƒ³ãƒˆï¼ˆåˆ©ç”¨è€…
マニュアルなど）に，上記の著
 *        作権表示，この利用条件および下記の無保証規定を掲載すること．
 *    (b) 再é…
å¸ƒã®å½¢æ…
‹ã‚’，別に定める方法によって，TOPPERSプロジェクトに
 *        å ±å‘Šã™ã‚‹ã“ã¨ï¼Ž
 *  (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損
 *      害からも，上記著作権者
およびTOPPERSプロジェクトをå…
è²¬ã™ã‚‹ã“と．
 *      また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理
 *      由に基づく請求からも，上記著作権者
およびTOPPERSプロジェクトを
 *      å…
è²¬ã™ã‚‹ã“と．
 *
 *  本ソフトウェアは，無保証で提供されているものである．上記著作権者
お
 *  よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的
 *  に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ
 *  アの利用により直接的または間接的に生じたいかなる損害に関しても，そ
 *  ã®è²¬ä»»ã‚’è² ã‚ãªã„ï¼Ž
 *
 *  @(#) $Id: httpd.c 270 2017-02-09 04:03:47Z coas-nagasima $
 */

#include "httpd.h"
#include <string.h>
#include <stdlib.h>
#include "syssvc/syslog.h"
#include "http-strings.h"
#include "netinet/in.h"
#include "arduino.h"

#define TRUE 1
#define FALSE 0

#ifndef _MSC_VER
/* strnlen() is a POSIX.2008 addition. Can't rely on it being available so
 * define it ourselves.
 */
size_t
strnlen(const char *s, size_t maxlen)
{
        const char *p;

        p = memchr(s, '\0', maxlen);
        if (p == NULL)
                return maxlen;

        return p - s;
}

void strcpy_s(char *dst, int size, const char *src)
{
        int slen = strlen(src);
        if (slen >= size)
                slen = size - 1;
        memcpy(dst, src, slen);
        dst[slen] = '\0';
}

void strcat_s(char *dst, int size, const char *src)
{
        int dlen = strlen(dst);
        int slen = strlen(src);
        if (dlen + slen >= size)
                slen = size - 1 - dlen;
        memcpy(&dst[dlen], src, slen);
        dst[dlen + slen] = '\0';
}
#endif

int httpd_strnicmp(const char *s1, const char *s2, size_t n)
{
        int i;
        char c1, c2;

        for (i = 0; i < n; i++, s1++, s2++) {
                c1 = *s1;
                c2 = *s2;
                if (c1 == '\0' && c2 == '\0')
                        return 0;

                if (c1 >= 'a' && c1 <= 'z')
                        c1 += 'A' - 'a';

                if (c2 >= 'a' && c2 <= 'z')
                        c2 += 'A' - 'a';

                if (c1 < c2)
                        return -1;

                if (c1 > c2)
                        return 1;
        }

        return 0;
}

size_t
strlncat(char *dst, size_t len, const char *src, size_t n)
{
        size_t slen;
        size_t dlen;
        size_t rlen;
        size_t ncpy = 0;

        slen = strnlen(src, n);
        dlen = strnlen(dst, len);

        if (dlen < len) {
                rlen = len - dlen;
                ncpy = slen < rlen ? slen : (rlen - 1);
                memcpy(dst + dlen, src, ncpy);
                dst[dlen + ncpy] = '\0';
        }

        //assert(len > slen + dlen);
        //return slen + dlen;
        return ncpy;
}

extern struct httpd_state *uploding;

int websvr_message_begin(http_parser *p)
{
        struct httpd_state *s = get_context(p);
        memset(&s->message, 0, sizeof(s->message));
        s->message.message_begin_cb_called = TRUE;
        return 0;
}

int websvr_request_url(http_parser *p, const char *buf, size_t len)
{
        struct httpd_state *s = get_context(p);

        strlncat(s->message.request_url, sizeof(s->message.request_url), buf, len);

        char *ptr = strrchr(s->message.request_url, '?');
        if (ptr != NULL) {
                ptr[0] = '\0';
                s->query = &ptr[1];
        }
        else
                s->query = NULL;

        /* ""か"/"なら"index.html"に変更 */
        if ((s->message.request_url[0] == '\0') || ((s->message.request_url[0] == '/') && (s->message.request_url[1] == '\0'))) {
                s->filename = &s->message.filename[sizeof(s->message.filename) - 2];
                strcpy_s(s->filename, sizeof(s->message.request_url) + 2, "0:");
                strcat_s(s->filename, sizeof(s->message.request_url) + 2, http_index_html);
                s->file.redirect = 1;
        }
        /* "/~/"ならSDカードから読み込み */
        else if ((s->message.request_url[0] == '/') && (s->message.request_url[1] == '~') && (s->message.request_url[2] == '/')) {
                s->filename = &s->message.filename[sizeof(s->message.filename) - 2 - sizeof(http_www) - 1 + 2];
                memcpy(s->filename, "1:", 2);
                memcpy(s->filename, http_www, sizeof(http_www) - 1);
        }
        else {
                s->filename = &s->message.filename[sizeof(s->message.filename) - 2];
                memcpy(s->filename, "0:", 2);
        }
        return 0;
}

int websvr_response_status(http_parser *p, const char *buf, size_t len)
{
        struct httpd_state *s = get_context(p);

        strlncat(s->message.response_status, sizeof(s->message.response_status), buf, len);

        return 0;
}

int websvr_header_field(http_parser *p, const char *buf, size_t len)
{
        struct httpd_state *s = get_context(p);
        struct message *m = &s->message;

        if (strncmp("Referer", buf, len) == 0) {
                m->num_headers = 1;
        }
        else if (strncmp("Host", buf, len) == 0) {
                m->num_headers = 2;
        }
        else if (strncmp("Upgrade", buf, len) == 0) {
                m->num_headers = 3;
        }
        else if (strncmp("Connection", buf, len) == 0) {
                m->num_headers = 4;
        }
        else if (strncmp("Sec-WebSocket-Key", buf, len) == 0) {
                m->num_headers = 5;
        }
        else if (strncmp("Origin", buf, len) == 0) {
                m->num_headers = 6;
        }
        else if (strncmp("Sec-WebSocket-Protocol", buf, len) == 0) {
                m->num_headers = 7;
        }
        else if (strncmp("Sec-WebSocket-Version", buf, len) == 0) {
                m->num_headers = 8;
        }
        else {
                m->num_headers = 0;
        }

        return 0;
}

int websvr_header_value(http_parser *p, const char *buf, size_t len)
{
        struct httpd_state *s = get_context(p);
        struct message *m = &s->message;

        switch (m->num_headers) {
        case 1:
                strlncat(m->referer, sizeof(m->referer), buf, len);
                break;
        case 2:
                strlncat(m->host, sizeof(m->host), buf, len);
                break;
        case 3:
                strlncat(m->upgrade, sizeof(m->upgrade), buf, len);
                break;
        case 4:
                strlncat(m->connection, sizeof(m->connection), buf, len);
                break;
        case 5:
                strlncat(m->sec_websocket_key, sizeof(m->sec_websocket_key), buf, len);
                break;
        case 6:
                strlncat(m->origin, sizeof(m->origin), buf, len);
                break;
        case 7:
                strlncat(m->sec_websocket_protocol, sizeof(m->sec_websocket_protocol), buf, len);
                break;
        case 8:
                strlncat(m->sec_websocket_version, sizeof(m->sec_websocket_version), buf, len);
                break;
        }

        return 0;
}

int websvr_headers_complete(http_parser *p)
{
        struct httpd_state *s = get_context(p);

        s->message.method = p->method;
        s->message.http_major = p->http_major;
        s->message.http_minor = p->http_minor;
        s->message.headers_complete_cb_called = TRUE;
        s->message.should_keep_alive = http_should_keep_alive(p);

        if ((s->message.method == HTTP_GET)
                && httpd_strnicmp(http_websocket, s->message.upgrade, sizeof(s->message.upgrade)) == 0) {
                s->in.state = IN_STATE_WEBSOCKET;
                s->state = STATE_WEBSOCKET;
                s->close_req = 0;
                websocket_init(&s->websocket, s->cepid);
                return 0;
        }
        else if (s->message.method == HTTP_GET) {
                s->in.state = IN_STATE_RESPONSE;
                s->out.state = OUT_STATE_OPEN_GET_FILE;
                return 1;
        }
        else if (s->message.method == HTTP_POST) {
                if ((s->parser.content_length > 16 * 1024)
                        || httpd_strnicmp(s->message.request_url, http_upload, sizeof(http_upload) - 1) != 0) {
                        goto error;
                }

                if (uploding == NULL) {
                        uploding = s;
                        // アップロードå…
ˆã¯SDカード
                        s->filename[0] = '1';
                        syslog(LOG_NOTICE, "create:    %s.%d %s", s->addr, ((T_IPV4EP *)s->dst)->portno, s->filename);
                        if (!httpd_fs_create(s->filename, &s->file)) {
                                goto error;
                        }

                        s->in.state = IN_STATE_UPLOAD;
                }
                else if (strcmp(s->filename, uploding->filename) == 0) {
                        syslog(LOG_NOTICE, "collision: %s.%d %s", s->addr, ((T_IPV4EP *)s->dst)->portno, s->filename);
                        goto error;
                }
                else {
                        s->in.state = IN_STATE_UPLOAD_WAIT;
                        s->in.wait = true;
                }

                s->out.state = OUT_STATE_WAIT_POST_BODY;
                s->out.wait = true;
                return 0;
        }
        else {
                s->state = STATE_CLOSING;
                return 1;
        }
error:
        s->filename = NULL;
        s->response_body = http_content_403;
        s->response_pos = 0;
        s->response_len = sizeof(http_content_403) - 1;

        s->out.statushdr = http_header_403;
        s->out.state = OUT_STATE_SEND_HEADER;
        return 1;
}

int websvr_body(http_parser *p, const char *buf, size_t len)
{
        struct httpd_state *s = get_context(p);

        if (s->message.body_is_final) {
                syslog(LOG_ERROR, "\n\n *** Error http_body_is_final() should return 1 "
                        "on last on_body callback call "
                        "but it doesn't! ***\n\n");
                s->state = STATE_CLOSING;
                return 0;
        }

        httpd_fs_write(&s->file, buf, len);

        s->message.body_size += len;
        s->message.body_is_final = http_body_is_final(p);

        if (s->message.body_is_final) {
                syslog(LOG_NOTICE, "close:     %s.%d %s", s->addr, ((T_IPV4EP *)s->dst)->portno, s->filename);
                httpd_fs_close(&s->file);
                memset(&s->file, 0, sizeof(s->file));

                strcpy_s(RubyFilename, sizeof(RubyFilename), s->filename);
                s->reset = 1;

                s->filename = NULL;
                s->response_body = http_content_200;
                s->response_pos = 0;
                s->response_len = sizeof(http_content_200) - 1;

                uploding = NULL;
                s->in.state = IN_STATE_END;
                s->out.state = OUT_STATE_BODY_RECEIVED;
        }

        return 0;
}

int websvr_message_complete(http_parser *p)
{
        struct httpd_state *s = get_context(p);
        if (s->message.should_keep_alive != http_should_keep_alive(p)) {
                syslog(LOG_ERROR, "\n\n *** Error http_should_keep_alive() should have same "
                        "value in both on_message_complete and on_headers_complete "
                        "but it doesn't! ***\n\n");
                assert(0);
        }

        if (s->message.body_size &&
                http_body_is_final(p) &&
                !s->message.body_is_final) {
                syslog(LOG_ERROR, "\n\n *** Error http_body_is_final() should return 1 "
                        "on last on_body callback call "
                        "but it doesn't! ***\n\n");
                assert(0);
        }

        s->message.message_complete_cb_called = TRUE;
        return 0;
}

http_parser_settings websvr_settings =
{
        websvr_message_begin,
        websvr_request_url,
        websvr_response_status,
        websvr_header_field,
        websvr_header_value,
        websvr_headers_complete,
        websvr_body,
        websvr_message_complete,
};