W5500+RTThead+mongoose实现WEB服务器

发布于 2024-10-25 14:09:33 浏览：653 订阅该版

11 条评论

F涛T 2024-11-03

这家伙很懒，什么也没写！

虎先锋 2024-11-03

猴头留着下酒，剩下的送给大王！

armink 2024-11-16

这家伙很懒，什么也没写！

qhsj 2024-11-17

这家伙很懒，什么也没写！

虎先锋 2025-01-06

猴头留着下酒，剩下的送给大王！

虎先锋 2025-01-06

猴头留着下酒，剩下的送给大王！

虎先锋 2025-01-06

猴头留着下酒，剩下的送给大王！

虎先锋 2025-01-06

猴头留着下酒，剩下的送给大王！

[wiz_socket.c]修改如下
函数 static void wiz_timer_entry(void *parameter)
```c
static void wiz_timer_entry(void *parameter)
{
    struct wiz_socket *svr_sock = RT_NULL;
    struct wiz_socket *clnt_sock = RT_NULL;
    struct wiz_clnt_info *clnt_info = RT_NULL;
    int clnt_socket = -1;
    int bind_port = 0;
    uint8_t status = 0;
    uint8_t res = 0;

svr_sock = (struct wiz_socket *)parameter;
    bind_port = svr_sock->port;

/* check server socket listen status */
    if (svr_sock->state != SOCK_LISTEN)
    {
        return;
    }

/* allocate and initialize a new client socket */
    clnt_info = wiz_conn_clnt_info_get(svr_sock);

//wiz_conn_clnt_check(svr_sock);
    if(wiz_listen_phy_check(svr_sock)!=0)
        goto __error;

if (clnt_info == RT_NULL)
    {
        /* check server listen backlog number */
        if (svr_sock->svr_info->backlog < 0)
        {
            goto __error;
        }

if (svr_sock->svr_info->backlog == 0)
        {
            goto __check;
        }

clnt_sock = alloc_socket();
        if (clnt_sock == RT_NULL)
        {
            goto __error;
        }
        clnt_sock->type = Sn_MR_TCP;

#ifdef SAL_USING_POSIX
        rt_wqueue_init(&clnt_sock->wait_head);
#endif
        if (wizchip_socket(clnt_sock->socket, clnt_sock->type, bind_port, 0) != clnt_sock->socket)
        {
            goto __error;
        }
        clnt_sock->state = SOCK_INIT;
        clnt_sock->port = svr_sock->port;
        clnt_socket = clnt_sock->socket;

/* create client information and add client to server clnt_list */
        clnt_info = rt_calloc(1, sizeof(struct wiz_clnt_info));
        if (clnt_info == RT_NULL)
        {
            LOG_E("no memory for clinet information.");
            goto __error;
        }
        clnt_info->socket = clnt_sock->socket;
        clnt_info->state = clnt_sock->state;
        rt_slist_init(&clnt_info->list);
        rt_slist_append(&svr_sock->svr_info->clnt_list, &clnt_info->list);
    }
    else
    {
        /* get client socket structure by socket descriptor */
        clnt_sock = wiz_get_socket(clnt_info->socket);

if (clnt_sock == RT_NULL)
        {
            goto __error;
        }
    }
    clnt_socket = clnt_info->socket;

status = getSn_SR(clnt_socket);
    //2024.12.17
    clnt_sock->state = status;

clnt_info->state = status;
    switch (status)
    {
    case SOCK_INIT:
        /* listen for open local ports and wait for client connections */
        if (wizchip_listen(clnt_socket) < 0)
        {
            goto __error;
        }
        break;
    case SOCK_ESTABLISHED:
        /* set server socket to recevice connected status */
        svr_sock->state = SOCK_SYNRECV;
        svr_sock->svr_info->backlog--;
        /* send client socket connect message and events */
        rt_mb_send(svr_sock->svr_info->conn_mbox, (rt_uint32_t)clnt_sock);
        wiz_do_event_changes(svr_sock, WIZ_EVENT_RECV, RT_TRUE);
        //如果使用KA
        break;
    case SOCK_LISTEN:
        /* socket input listen mode, wait client connect */
        break;
    case SOCK_CLOSE_WAIT:
    case SOCK_CLOSED:
    default:
        goto __error;
    }
    return;

__error:
    rt_mb_send(svr_sock->svr_info->conn_mbox, (rt_uint32_t)clnt_sock);
    wiz_do_event_changes(svr_sock, WIZ_EVENT_ERROR, RT_TRUE);

__check:
//目前listen逻辑是用一个listen一个新的，用到最后一个就跳过
    return;

}
```
在连接满backlog时，再有新的连接不直接发送错误事件，而是跳过。在该定时函数每次执行时检查PHY通断，断开发送错误事件，用于网线断开后，mongoose释放和重启（释放listen的那个socket）。

虎先锋 2025-01-06

猴头留着下酒，剩下的送给大王！

[wiz_socket.c]修改如下
int rt_wiz_accept(int socket, struct sockaddr *addr, socklen_t *addrlen)
```c
    while (1)
    {
        /* receive client connect message */
        if (rt_mb_recv(svr_info->conn_mbox, (void *)&clnt_sock, RT_WAITING_NO) != RT_EOK)//non-block for mongoose
        {
            rt_thread_mdelay(5);
            return -1;
        }

/* check connect message type */
        clnt_socket = clnt_sock->socket;
        if (getSn_SR(clnt_socket) != SOCK_ESTABLISHED)
        {
            /* clean server socket error event */
            wiz_do_event_clean(svr_sock, WIZ_EVENT_ERROR);
            /* error massage, close client socket */
            rt_wiz_closesocket(clnt_socket);
            return -1;
        }

#ifdef xyz_modify
//PS:在这里加上发送事件
        wiz_do_event_changes(clnt_sock, WIZ_EVENT_SEND, RT_TRUE);
#endif
```
[mongoose.c]
```c
if (c->is_resolving || c->is_closing) {
            // Do nothing
        } else if (c->is_listening && c->is_udp == 0) {
            if (c->is_readable) accept_conn(mgr, c);
        } else if (c->is_connecting) {
            if (c->is_readable || c->is_writable){
                connect_conn(c);
            }
        } else if (c->is_tls_hs) {
            if ((c->is_readable || c->is_writable)){
                mg_tls_handshake(c);
            }
        } else {
            if (c->is_readable)
                read_conn(c);
            if (c->is_writable)
                write_conn(c);
        }
```
观察mongoose源码可知，mongoose产生connect_conn是依靠polling的send事件（c->is_writeable）,解释了为什么前面有MG_EV_ACCEPT但是进不去MG_EV_HTTP_MSG的原因，在accept函数里加入send事件即可。

虎先锋 2025-01-07

猴头留着下酒，剩下的送给大王！

界面是使用mongoose提供的wizard ui制作的，低代码，只需要填写json格式的api接口，会生成后端代码框架
![screenshot_image.png](https://oss-club.rt-thread.org/uploads/20250107/1c8d0424de658ebcd4a3470d21d52b7d.png.webp)
对于w5500如果想刷新不卡死需要实现超时释放，可以超时时间可以设置在1秒左右：
```c
static void http_ev_handler(struct mg_connection *c, int ev, void *ev_data) {
    handle_uploads(c, ev, ev_data);
    if (ev == MG_EV_POLL) {
        if(c->is_listening!=1){
            if(socket_timeout_check((int)c->fd, 3000) < 0){
                c->is_closing = 1;
                rt_kprintf("TMO close %d cn\n",(int)c->fd);
            }
        }
    }else if (ev == MG_EV_CLOSE) {
        if(c->is_listening == 1){//listen被关闭
            s_mg_exit_flag = 1;
        }
        socket_timeout_stat_change((int)c->fd, is_init);
        rt_kprintf("EV close %d cn\n",(int)c->fd);
    }else if (ev == MG_EV_READ) {
        socket_timeout_stat_change((int)c->fd, is_message);
        //rt_kprintf("sk%d r msg\n",(int)c->fd);
    }
    else if (ev == MG_EV_WRITE) {
        socket_timeout_stat_change((int)c->fd, is_message);
        //rt_kprintf("sk%d w msg\n",(int)c->fd);
    }
    else if (ev == MG_EV_HTTP_MSG) {
        struct mg_http_message *hm = (struct mg_http_message *) ev_data;
        struct apihandler *h = find_handler(hm);
        struct user *u = authenticate(hm);
        //rt_kprintf("MG_EV_HTTP_MSG %s\n",hm->uri);
        if (mg_match(hm->uri, mg_str("/api/#"), NULL) &&
                (u == NULL ||
                        (h != NULL && (u->level < h->read_level ||
                                (hm->body.len > 0 && u->level < h->write_level))))) {
            // MG_INFO(("DENY: %d, %d %d", u->level, h->read_level, h->write_level));
            mg_http_reply(c, 403, JSON_HEADERS, "Not Authorised\n");
        } else if (mg_match(hm->uri, mg_str("/api/login"), NULL)) {
            handle_login(c, u);
        } else if (mg_match(hm->uri, mg_str("/api/logout"), NULL)) {
            handle_logout(c);
        } else if (mg_match(hm->uri, mg_str("/api/ok"), NULL)) {
            mg_http_reply(c, 200, JSON_HEADERS, "true\n");
        } else if (mg_match(hm->uri, mg_str("/api/heartbeat"), NULL)) {
            mg_http_reply(c, 200, JSON_HEADERS, "{%m:%lu}\n", MG_ESC("version"),
                    s_device_change_version);
        } else if (h != NULL) {
            handle_api_call(c, hm, h);
        } else {
            //        rt_kprintf("HTTP headCB\n");
            struct mg_http_serve_opts opts;
            memset(&opts, 0, sizeof(opts));
            opts.root_dir = "/web_root/";
            opts.fs = &mg_fs_packed;
            opts.extra_headers = NO_CACHE_HEADERS;

int64_t stat,end,sub;
            stat = rt_tick_get_millisecond();
            mg_http_serve_dir(c, hm, &opts);
            end =rt_tick_get_millisecond();
            sub = end -stat;
            rt_kprintf("HTTP load %d\n",sub);
        }
        // Show this request
        MG_DEBUG(("%lu %.*s %.*s %lu -> %.*s", c->id, hm->method.len,
                hm->method.buf, hm->uri.len, hm->uri.buf, hm->body.len,
                c->send.len > 15 ? 3 : 0, &c->send.buf[9]));
    } else if (ev == MG_EV_ACCEPT) {

}
}
```