5 at_socket中服务器主动断开连接导致后续操作异常

发布于 2022-02-21 18:52:37 浏览：1343 订阅该版

该问题和 [at socket驱动状态机缺失“CLOSE_WAIT”状态](https://club.rt-thread.org/ask/question/433591.html) 较类似，使用at_socket与服务器建立连接后，服务器主动断开连接后，此时装置会调用该函数：
```c
static void at_closed_notice_cb(struct at_socket *sock, at_socket_evt_t event, const char *buff, size_t bfsz)
{
    RT_ASSERT(event == AT_SOCKET_EVT_CLOSED);

/* check the socket object status */
    if (sock->magic != AT_SOCKET_MAGIC)
    {
        return;
    }

at_do_event_changes(sock, AT_EVENT_RECV, RT_TRUE);
    at_do_event_changes(sock, AT_EVENT_ERROR, RT_TRUE);

sock->state = AT_SOCKET_CLOSED;
    rt_sem_release(sock->recv_notice);
}
```
该函数中将at_socket的状态置为AT_SOCKET_CLOSED，但是却没有调用相应的close函数。后续代码中判断该链接为异常后，调用at_closesocket去执行关闭操作时，只执行了free_socket()，并未调用`sock->ops->at_closesocket`(本处即ec200x_socket_close)，因此4G模块中还保持着该socket连接。
```c
int at_closesocket(int socket)
{
    struct at_socket *sock = RT_NULL;
    enum at_socket_state last_state;

/* deal with TCP server actively disconnect */
    rt_thread_delay(rt_tick_from_millisecond(100));

sock = at_get_socket(socket);
    if (sock == RT_NULL)
    {
        return -1;
    }
    /* 不太理解为何使用该变量 */
    last_state = sock->state;

/* the rt_at_socket_close is need some time, so change state in advance */
    sock->state = AT_SOCKET_CLOSED;

if (last_state != AT_SOCKET_CLOSED)
    {    /* 当服务器主动断开连接后，at_closed_notice_cb已将状态置为AT_SOCKET_CLOSED，因此这部分代码都不会执行 */
        if (sock->ops->at_closesocket(sock) != 0)
        {
            free_socket(sock);
            return -1;
        }
    }

free_socket(sock);
    return 0;
}

static int ec200x_socket_close(struct at_socket *socket)
{
    int result = RT_EOK;
    at_response_t resp = RT_NULL;
    int device_socket = (int) socket->user_data;
    struct at_device *device = (struct at_device *) socket->device;

resp = at_create_resp(64, 0, rt_tick_from_millisecond(300));
    if (resp == RT_NULL)
    {
        LOG_E("no memory for resp create.");
        return -RT_ENOMEM;
    }

result = at_obj_exec_cmd(device->client, resp, "AT+QICLOSE=%d", device_socket);

at_delete_resp(resp);

return result;
}
```

此外，还想问一下```at_closesocket```函数中```last_state```这一变量，是出于何种考虑添加该变量，较为困惑。

crystal266 2022-02-21

嵌入式

我觉得这点的处理逻辑有点问题，应该在 服务器主动断开连接的回调函数里面设置一个中间状态，然后在close函数中关闭AT模组的socket服务，从而释放掉该socketID，要不然再用这个sockedID进行连接的话模组会返回错误码。  或者直接在服务器主动断开连接的回调函数里面调用`sock->ops->at_closesocket`，关闭模组的socket服务，这样`at_closesocket()`函数按照现在的逻辑直接`free_socket(sock)`也行。

---

源码的逻辑我猜是正常连接时主动关闭调用 sock->ops->at_closesocket 发送AT指令给模组，关闭模组的socket服务，释放掉该socketID。当前已经关闭的话，就不想让给模组发送AT指令关闭模组的socket服务了，默认关闭了模组的socket服务（但是忽略了现在代码执行服务器主动断开连接的回调函数里面的逻辑）
```c
if (last_state != AT_SOCKET_CLOSED)
{    /* 当服务器主动断开连接后，at_closed_notice_cb已将状态置为AT_SOCKET_CLOSED，因此这部分代码都不会执行 */
    if (sock->ops->at_closesocket(sock) != 0)
    {
        free_socket(sock);
        return -1;
    }
}
```
另外，我觉得当前处于正常状态连接状态下，主动关闭模组的socket服务时，如果执行失败，是不应该执行 free_socket() 的吧，要不然 free_socket() 后，模组还没关闭socket服务，又可能会造成使用相同的socketID进行连接的问题了。

---

按照现在的源码，参考文中提到的那个帖子，根据返回的结果来判断是否需要关闭模组的socket服务更稳妥一些，就是稍微麻烦一点。

---

附上关闭socket服务相应的AT指令 和 收到关闭URC消息的相关解释（收到该消息后应该主动发送 AT+QICLOSE=<connectID> 指令去关闭 socket 模组的服务）
![image.png](https://oss-club.rt-thread.org/uploads/20220221/dea436ef56b222ca9de5f84e62a14476.png.webp)

![image.png](https://oss-club.rt-thread.org/uploads/20220221/e8990cee2daa5f57c80b8b3730332e75.png.webp)

crystal266 2022-03-09

嵌入式

@樂飓颩俠 你好，我试了一下打印的日志如下所示，在服务器主动断开连接后，URC回调函数会将当前的 sock_fd 的状态设置为 CLOSE，然后没有清除模组内部的 sock_fd。但是再一次执行 connect 函数时，发现模组内部的 sock_fd 处于未关闭状态，会执行模组的 sock_fd 关闭函数 ec200x_socket_close()，这样就不会存在模组内部的 sock_fd 未关闭的情况了。

![image.png](https://oss-club.rt-thread.org/uploads/20220309/7e2470451c33c3c0017696129269bc4f.png.webp)

连接的源码如下：
```
/**
 * create TCP/UDP client or server connect by AT commands.
 *
 * @param socket current socket
 * @param ip server or client IP address
 * @param port server or client port
 * @param type connect socket type(tcp, udp)
 * @param is_client connection is client
 *
 * @return   0: connect success
 *          -1: connect failed, send commands error or type error
 *          -2: wait socket event timeout
 *          -5: no memory
 */
static int ec200x_socket_connect(struct at_socket *socket, char *ip, int32_t port,
    enum at_socket_type type, rt_bool_t is_client)
{
    #define CONN_RETRY  2

int i = 0;
    const char *type_str = RT_NULL;
    uint32_t event = 0;
    at_response_t resp = RT_NULL;
    int result = 0, event_result = 0;
    int device_socket = (int) socket->user_data;
    struct at_device *device = (struct at_device *) socket->device;

RT_ASSERT(ip);
    RT_ASSERT(port >= 0);

if ( ! is_client)
    {
        return -RT_ERROR;
    }

switch(type)
    {
        case AT_SOCKET_TCP:
            type_str = "TCP";
            break;
        case AT_SOCKET_UDP:
            type_str = "UDP";
            break;
        default:
            LOG_E("%s device socket(%d)  connect type error.", device->name, device_socket);
            return -RT_ERROR;
    }

resp = at_create_resp(128, 0, rt_tick_from_millisecond(300));
    if (resp == RT_NULL)
    {
        LOG_E("no memory for resp create.");
        return -RT_ENOMEM;
    }

for(i=0; i<CONN_RETRY; i++)
    {
        /* clear socket connect event */
        event = SET_EVENT(device_socket, EC200X_EVENT_CONN_OK | EC200X_EVENT_CONN_FAIL);
        ec200x_socket_event_recv(device, event, 0, RT_EVENT_FLAG_OR);

if (at_obj_exec_cmd(device->client, resp, "AT+QIOPEN=1,%d,\"%s\",\"%s\",%d,0,1",
                            device_socket, type_str, ip, port) < 0)
        {
            result = -RT_ERROR;
            break;
        }

/* waiting result event from AT URC, the device default connection timeout is 60 seconds*/
        if (ec200x_socket_event_recv(device, SET_EVENT(device_socket, 0),
                                    60 * RT_TICK_PER_SECOND, RT_EVENT_FLAG_OR) < 0)
        {
            LOG_E("%s device socket(%d) wait connect result timeout.", device->name, device_socket);
            result = -RT_ETIMEOUT;
            break;
        }
        /* waiting OK or failed result */
        event_result = ec200x_socket_event_recv(device, EC200X_EVENT_CONN_OK | EC200X_EVENT_CONN_FAIL,
                                                1 * RT_TICK_PER_SECOND, RT_EVENT_FLAG_OR);
        if (event_result < 0)
        {
            LOG_E("%s device socket(%d) wait connect OK|FAIL timeout.", device->name, device_socket);
            result = -RT_ETIMEOUT;
            break;
        }
        /* check result */
        if (event_result & EC200X_EVENT_CONN_OK)
        {
            result = RT_EOK;
            break;
        }

LOG_D("%s device socket(%d) connect failed, the socket was not be closed and now will connect retry.",
                    device->name, device_socket);
        if (ec200x_socket_close(socket) < 0)
        {
            result = -RT_ERROR;
            break;
        }
    }

if (i == CONN_RETRY)
    {
        LOG_E("%s device socket(%d) connect failed.", device->name, device_socket);
        result = -RT_ERROR;
    }

if (resp)
    {
        at_delete_resp(resp);
    }

return result;
}
```