SmartPDCode/f407/applications/web.c

#include "web.h"
#include "mongoose.h"
#include "thread.h"
#include "list.h"
#include "power.h"
#include "paras.h"
#include "cfg.h"
#include <stdio.h>
#include "datadef.h"

#define TIMER_INTERVAL     1000
typedef void (*http_fn_t)(void *arg);

#define USE_MG716


#ifdef USE_MG716
typedef struct mg_tls_opts mg_tls_t;
#else
typedef struct mg_serve_http_opts mg_opts_t;
#define MG_PATH_MAX  128
#endif

typedef struct {
    struct mg_connection *c;
    int     ev;
    void    *ev_data;
}mg_stream_t;

typedef struct {
    pthread_t       tid;
    
    struct mg_mgr   mgr;
#ifdef USE_MG716
    mg_tls_t        tls;
#else
    mg_opts_t       opts;
#endif
    
    handle_t        list;
    char            rootDir[MG_PATH_MAX];
    char            *buf;
    int             buflen;
}web_handle_t;
static web_handle_t webHandle={0};



static int ws_send(web_handle_t *h, struct mg_connection *c, uint8_t type, void *data, int len, int isbin)
{
    pkt_hdr_t *hdr=NULL;
    
    if(!h->buf || !len || h->buflen<sizeof(pkt_hdr_t)+len) {
        LOGE("____ws_send, para are invalid\n");
        return -1;
    }
    hdr = (pkt_hdr_t*)h->buf;
    
    hdr->magic = PKT_MAGIC;
    hdr->type  = type;
    hdr->nack  = 0;
    hdr->dlen  = len;
    memcpy(hdr->data, data, len);
#ifdef USE_MG716
    mg_ws_send(c, hdr, len+sizeof(pkt_hdr_t), isbin?WEBSOCKET_OP_BINARY:WEBSOCKET_OP_TEXT);
#else
    mg_send_websocket_frame(c, isbin?WEBSOCKET_OP_BINARY:WEBSOCKET_OP_TEXT, hdr, len+sizeof(pkt_hdr_t));
#endif
    
    return 0;
}
static void send_powerc(web_handle_t *h, struct mg_connection *c)
{
    int i,r;
    power_data_t pd=power_data_get();
    
    for(i=0; i<pd.chs; i++) {
        ws_send(h, c, PKT_TYPE_POWER_CH, &pd.pch[i], sizeof(power_ch_t), 1);
    }
}
static void send_powert(web_handle_t *h, struct mg_connection *c)
{
    int i,r;
    power_data_t pd=power_data_get();
    
    if(r==0) {
        ws_send(h, c, PKT_TYPE_POWER_TOTAL, &pd.ttl, sizeof(power_total_t), 1);
    }
}


static int is_websocket(struct mg_connection *c)
{
    int r=0;
#ifdef USE_MG716
    r = c->is_websocket;
#else
    r = (c->flags & MG_F_IS_WEBSOCKET)?1:0;
#endif
}
static int ws_handle(web_handle_t *h, pkt_hdr_t *hdr, struct mg_connection *c)
{
    int r=0;
    
    if (!is_websocket(c)) {
        return -1;
    }
    
    if(hdr->magic!=PKT_MAGIC) {
        LOGE("___ magic: 0x%x is wrong!, correct is: 0x%x\n", hdr->magic, PKT_MAGIC);
        return -1;
    }
    
    //LOGD("_____ ws handle, type: %d, flag: %d\n", hdr->type, hdr->flag);
    switch(hdr->type) {
        case PKT_TYPE_PARAS:
        {
            //setup
        }
        break;
        
        case PKT_TYPE_POWER_CH:
        {
            if(hdr->dlen>0) {
                power_ch_t *pch=(power_ch_t*)hdr->data;
                switch(hdr->subtype) {
                    case SUB_TYPE_POWER_SWITCH:
                    {
                        r = power_set_ch_sw(pch->info.ch, pch->power[0].status);
                    }
                    break;
                    
                    case SUB_TYPE_POWER_ALARM:
                    {
                        r = power_set_alarm(pch);
                    }
                    break;
                    
                    case SUB_TYPE_POWER_THRESHOLD:
                    {
                        r = power_set_threshold(pch);
                    }
                    break;
                    
                    case SUB_TYPE_POWER_START_DELAY:
                    {
                        r = power_set_start_delay(pch);
                    }
                    break;
                    
                    case SUB_TYPE_POWER_STOP_DELAY:
                    {
                        r = power_set_stop_delay(pch);
                    }
                    break;
                }
            }
            else {
                LOGD("_____ send_powerc\n");
                send_powerc(h, c);
            }
        }
        break;
        
        case PKT_TYPE_POWER_TOTAL:
        {
            LOGD("_____ send_powert\n");
            send_powert(h, c);
        }
        break;
        
        case PKT_TYPE_CH_ALL:
        {
            power_set_all_sw(hdr->flag);
        }
        break;
        
        case PKT_TYPE_POWER_RESET:
        {
            r = power_reset();
        }
        break;
        
        case PKT_TYPE_SCAN:
        {
            r = power_scan();
        }
        break;
        
        case PKT_TYPE_FACTORY:
        {
            //r = power_scan();
        }
        break;
        
        case PKT_TYPE_SENSOR:
        {
            
        }
        break;
        
        case PKT_TYPE_BREAKER:
        {
            
        }
        break;
        
        case PKT_TYPE_FILE:
        {
            
        }
        break;
        
    }
}

static void http_fn(struct mg_connection *c, int ev, void *ev_data)
{
    int r,flag=0;
    web_handle_t *h=&webHandle;

#ifdef USE_MG716
    if (ev == MG_EV_HTTP_MSG) {
        struct mg_http_message *hm = (struct mg_http_message *) ev_data;
        if (mg_match(hm->uri, mg_str("/ws"), NULL)) {
            mg_ws_upgrade(c, hm, NULL);
        } else if (mg_match(hm->uri, mg_str("/rest"), NULL)) {
            // Serve REST response
            mg_http_reply(c, 200, "", "{\"result\": %d}\n", 123);
        } else {
            struct mg_http_serve_opts opts = {.root_dir = h->rootDir};
            mg_http_serve_dir(c, ev_data, &opts);
        }
    }
    else if(ev == MG_EV_ACCEPT) {
        if (c->fn_data) {
            mg_tls_init(c, &h->tls);
        }
    }
    else if(ev == MG_EV_WS_MSG) {
        struct mg_ws_message *wm = (struct mg_ws_message *) ev_data;
        pkt_hdr_t *hdr=(pkt_hdr_t*)wm->data.buf;
        ws_handle(h, hdr, c);
    }
#else
    if (ev == MG_EV_HTTP_REQUEST) {
        mg_serve_http(c, (struct http_message *)ev_data, h->opts);
    }
    else if(ev == MG_EV_WEBSOCKET_HANDSHAKE_DONE) {
        paras_data_t *p=paras_get();
        //ws_send(h, c, PKT_TYPE_PARAS, p, sizeof(paras_data_t), 1);
        //set_timer(c, TIMER_INTERVAL);
    }
    else if(ev == MG_EV_WEBSOCKET_FRAME) {
        struct websocket_message *wm = (struct websocket_message *) ev_data;
        pkt_hdr_t *hdr=(pkt_hdr_t*)wm->data;
        ws_handle(h, hdr, c);
    }
    else if(ev==MG_EV_TIMER) {
        
    #if 0
        list_node_t *ln=NULL;
        r = list_take_node(h->list, &ln, 0);
        if(r==0) {
            node_t *n=&ln->data;
            ws_send(h, c, n->tp, n->buf, n->dlen, 1);
            list_back_node(h->list, ln);
        }
   #endif
    }
#endif
}
static void timer_fn(void *arg)
{
    int r;
    web_handle_t *h=(web_handle_t*)arg;
    list_node_t *ln=NULL;
    struct mg_connection* c;
    
    r = list_take_node(h->list, &ln, 0);
    if(r==0) {
        node_t *n=&ln->data;
#ifdef USE_MG716
        for (c = h->mgr.conns; c != NULL; c = c->next) {
#else
        for (c = mg_next(&h->mgr, NULL); c != NULL; c = mg_next(&h->mgr, c)) {
#endif
            ws_send(h, c, n->tp, n->buf, n->dlen, 1);
        }
        list_back_node(h->list, ln);
    }
}
static void web_thread(void *arg)
{
    struct mg_connection *nc;
    const char *http_addr="http://[::]:80";
    const char *https_addr="https://[::]:443";
    //thread_handle_t *th=(thread_handle_t*)arg;
    //web_handle_t *h=(web_handle_t*)th->attr->arg;
    web_handle_t *h=&webHandle;

#ifdef USE_MG716
    mg_log_set(MG_LL_DEBUG);
    mg_mgr_init(&h->mgr);

    //sys_get_path(mh->rootDir, WEB_ROOT);
    strcpy(h->rootDir, "/web");

    mg_timer_add(&h->mgr, TIMER_INTERVAL, MG_TIMER_REPEAT, timer_fn, h);
    if (mg_http_listen(&h->mgr, http_addr, http_fn, NULL) == NULL) {
        MG_ERROR(("cannot listen on %s\n", http_addr));
    }

    //if (mg_http_listen(&h->mgr, https_addr, http_fn, (void*)1) == NULL) {
    //    MG_ERROR(("cannot listen on %s\n", https_addr));
    //}
    
    //mh->tls.cert = mg_str(file_load2("/root/run/app/cert/server.crt",0));
    //mh->tls.key = mg_str(file_load2("/root/run/app/cert/server.key",0));
    //mh->tls.name = mg_url_host(https_addr);
#else
    mg_mgr_init(&h->mgr, NULL);
    nc = mg_bind(&h->mgr, "80", http_fn);

    strcpy(h->rootDir, "/web");
    
    mg_set_protocol_http_websocket(nc);
    h->opts.document_root = h->rootDir;
    h->opts.enable_directory_listing = "yes";
#endif
    
    //while(th->quit==0) {
    while(1) {
        mg_mgr_poll(&h->mgr, 300);
    }
    mg_mgr_free(&h->mgr);
}


int web_init(void)
{
    list_cfg_t lc={0,0,10};
    web_handle_t *h=&webHandle;
    
    memset(h, 0, sizeof(web_handle_t));
    h->list = list_init(&lc);
    
    h->buflen = sizeof(pkt_hdr_t)+sizeof(power_ch_t)+32;
    h->buf = (char*)malloc(h->buflen);
    
    //web_thread(0);
    thread_start(THREAD_ID_WEB, web_thread, h);
    return 0;
}



int web_post(int type, void *data, int len)
{
    struct mg_connection *c;
    web_handle_t *h=&webHandle;
    
    return list_append(h->list, type, data, len);
}

#if 1
void WWDG_IRQHandler() {
    LOGD("___0\n");
}    
void PVD_IRQHandler() {
    LOGD("___1\n");
}    
void TAMP_STAMP_IRQHandler(){
    LOGD("___2\n");
}    
void RTC_WKUP_IRQHandler(){
    LOGD("___3\n");
}    
void FLASH_IRQHandler(){
    LOGD("___4\n");
}    
void RCC_IRQHandler(){
    LOGD("___5\n");
}    
//void EXTI0_IRQHandler(){
//    LOGD("___6\n");
//}    
//void EXTI1_IRQHandler(){
//    LOGD("___7\n");
//}    
//void EXTI2_IRQHandler(){
//    LOGD("___8\n");
//}    
//void EXTI3_IRQHandler(){
//    LOGD("___9\n");
//}    
//void EXTI4_IRQHandler(){
//    LOGD("___a\n");
//}    
void DMA1_Stream0_IRQHandler(){
    LOGD("___b\n");
}    
void DMA1_Stream1_IRQHandler(){
    LOGD("___c\n");
}    
void DMA1_Stream2_IRQHandler(){
    LOGD("___d\n");
}    
void DMA1_Stream3_IRQHandler(){
    LOGD("___e\n");
}    
void DMA1_Stream4_IRQHandler(){
    LOGD("___f\n");
}    
void DMA1_Stream5_IRQHandler(){
    LOGD("___g\n");
}    
void DMA1_Stream6_IRQHandler(){
    LOGD("___h\n");
}    
void ADC_IRQHandler(){
    LOGD("___i\n");
}    
void CAN1_TX_IRQHandler(){
    LOGD("___j\n");
}    
void CAN1_RX0_IRQHandler(){
    LOGD("___k\n");
}    
void CAN1_RX1_IRQHandler(){
    LOGD("___l\n");
}    
void CAN1_SCE_IRQHandler(){
    LOGD("___m\n");
}    
//void EXTI9_5_IRQHandler(){
//    LOGD("___n\n");
//}    
void TIM1_BRK_TIM9_IRQHandler(){
    LOGD("___o\n");
}    
void TIM1_UP_TIM10_IRQHandler(){
    LOGD("___p\n");
}    
void TIM1_TRG_COM_TIM11_IRQHandler(){
    LOGD("___q\n");
}    
void TIM1_CC_IRQHandler(){
    LOGD("___r\n");
}    
void TIM2_IRQHandler(){
    LOGD("___s\n");
}    
void TIM3_IRQHandler(){
    LOGD("___t\n");
}    
void TIM4_IRQHandler(){
    LOGD("___u\n");
}    
void I2C1_EV_IRQHandler(){
    LOGD("___v\n");
}    
void I2C1_ER_IRQHandler(){
    LOGD("___w\n");
}    
void I2C2_EV_IRQHandler(){
    LOGD("___x\n");
}    
void I2C2_ER_IRQHandler(){
    LOGD("___y\n");
}    
void SPI1_IRQHandler(){
    LOGD("___z\n");
}    
void SPI2_IRQHandler(){
    LOGD("___a1\n");
}    
//void USART1_IRQHandler(){
//    LOGD("___a2\n");
//}    
//void USART2_IRQHandler(){
//    LOGD("___a3\n");
//}    
//void USART3_IRQHandler(){
//    LOGD("___a4\n");
//}    
//void EXTI15_10_IRQHandler(){
//    LOGD("___a5\n");
//}    
void RTC_Alarm_IRQHandler(){
    LOGD("___a6\n");
}    
void OTG_FS_WKUP_IRQHandler(){
    LOGD("___a7\n");
}    
void TIM8_BRK_TIM12_IRQHandler(){
    LOGD("___a8\n");
}    
void TIM8_UP_TIM13_IRQHandler(){
    LOGD("___a9\n");
}    
void TIM8_TRG_COM_TIM14_IRQHandler(){
    LOGD("___aa\n");
}    
void TIM8_CC_IRQHandler(){
    LOGD("___ab\n");
}    
void DMA1_Stream7_IRQHandler(){
    LOGD("___ac\n");
}    
void FMC_IRQHandler(){
    LOGD("___ad\n");
}    
//void SDIO_IRQHandler(){
//    LOGD("___ae\n");
//}    
void TIM5_IRQHandler(){
    LOGD("___af\n");
}    
void SPI3_IRQHandler(){
    LOGD("___ag\n");
}    
void UART4_IRQHandler(){
    LOGD("___ah\n");
}    
void UART5_IRQHandler(){
    LOGD("___b1\n");
}    
void TIM6_DAC_IRQHandler(){
    LOGD("___b2\n");
}    
void TIM7_IRQHandler(){
    LOGD("___b3\n");
}    
void DMA2_Stream0_IRQHandler(){
    LOGD("___b4\n");
}    
void DMA2_Stream1_IRQHandler(){
    LOGD("___b5\n");
}    
void DMA2_Stream2_IRQHandler(){
    LOGD("___b6\n");
}    
void DMA2_Stream3_IRQHandler(){
    LOGD("___b7\n");
}    
void DMA2_Stream4_IRQHandler(){
    LOGD("___b8\n");
}    
//void ETH_IRQHandler(){
//    LOGD("___b9\n");
//}    
void ETH_WKUP_IRQHandler(){
    LOGD("___c1\n");
}    
void CAN2_TX_IRQHandler(){
    LOGD("___c2\n");
}    
void CAN2_RX0_IRQHandler(){
    LOGD("___c3\n");
}    
void CAN2_RX1_IRQHandler(){
    LOGD("___c4\n");
}    
void CAN2_SCE_IRQHandler(){
    LOGD("___c5\n");
}    
void OTG_FS_IRQHandler(){
    LOGD("___c6\n");
}    
void DMA2_Stream5_IRQHandler(){
    LOGD("___c7\n");
}    
void DMA2_Stream6_IRQHandler(){
    LOGD("___c8\n");
}    
void DMA2_Stream7_IRQHandler(){
    LOGD("___c9\n");
}    
//void USART6_IRQHandler(){
//    LOGD("___d1\n");
//}    
void I2C3_EV_IRQHandler(){
    LOGD("___d2\n");
}    
void I2C3_ER_IRQHandler(){
    LOGD("___d3\n");
}    
void OTG_HS_EP1_OUT_IRQHandler(){
    LOGD("___d4\n");
}    
void OTG_HS_EP1_IN_IRQHandler(){
    LOGD("___d5\n");
}    
void OTG_HS_WKUP_IRQHandler(){
    LOGD("___d6\n");
}    
void OTG_HS_IRQHandler(){
    LOGD("___d7\n");
}    
void DCMI_IRQHandler(){
    LOGD("___d8\n");
}    
void HASH_RNG_IRQHandler(){
    LOGD("___d9\n");
}    
void FPU_IRQHandler(){
    LOGD("___e1\n");
}    
#endif