622 lines
14 KiB
C
622 lines
14 KiB
C
/**
|
||
* @file debug_link.c
|
||
* @brief 调试链路层实现（comm_link_ctx + TCP Socket + comm_link 分发）
|
||
*/
|
||
|
||
#include "debug_link.h"
|
||
#include "tcp_protocol.h"
|
||
#include "publicdata/public_define.h"
|
||
#include "lwip/sockets.h"
|
||
#include "lwip/netdb.h"
|
||
#include <string.h>
|
||
#include <stdio.h>
|
||
#include "FreeRTOS.h"
|
||
#include "task.h"
|
||
#include "semphr.h"
|
||
#include "app_fatfs/fatfs_init.h"
|
||
|
||
#if BLE_DEBUG_EN
|
||
#include "ble_link/fc41d_ble.h"
|
||
#endif
|
||
|
||
#if TCP_DEBUG_EN
|
||
|
||
/* =============================================================================
|
||
* 会话上下文（原 comm_link_ctx.c）
|
||
* ============================================================================= */
|
||
|
||
static comm_link_ctx_t s_comm_link_ctx;
|
||
|
||
comm_link_ctx_t *comm_link_ctx_get(void)
|
||
{
|
||
return &s_comm_link_ctx;
|
||
}
|
||
|
||
comm_link_session_t *comm_link_session(void)
|
||
{
|
||
return &s_comm_link_ctx.session;
|
||
}
|
||
|
||
void comm_link_ctx_reset_session(void)
|
||
{
|
||
comm_link_type_t saved_type = s_comm_link_ctx.session.type;
|
||
|
||
memset(&s_comm_link_ctx.session, 0, sizeof(s_comm_link_ctx.session));
|
||
s_comm_link_ctx.session.type = saved_type;
|
||
}
|
||
|
||
void comm_link_ctx_reset_all(void)
|
||
{
|
||
memset(&s_comm_link_ctx, 0, sizeof(s_comm_link_ctx));
|
||
}
|
||
|
||
/* =============================================================================
|
||
* TCP Socket 后端（原 tcp_server_socket.c，本文件内 static）
|
||
* ============================================================================= */
|
||
|
||
#ifndef AF_INET
|
||
#define AF_INET 2
|
||
#endif
|
||
#ifndef SOCK_STREAM
|
||
#define SOCK_STREAM 1
|
||
#endif
|
||
#ifndef SOL_SOCKET
|
||
#define SOL_SOCKET 0xFFF
|
||
#endif
|
||
#ifndef SO_REUSEADDR
|
||
#define SO_REUSEADDR 0x0004
|
||
#endif
|
||
#ifndef INADDR_ANY
|
||
#define INADDR_ANY 0x00000000
|
||
#endif
|
||
#ifndef F_GETFL
|
||
#define F_GETFL 3
|
||
#endif
|
||
#ifndef F_SETFL
|
||
#define F_SETFL 4
|
||
#endif
|
||
#ifndef O_NONBLOCK
|
||
#define O_NONBLOCK 0x0004
|
||
#endif
|
||
#ifndef EWOULDBLOCK
|
||
#define EWOULDBLOCK 11
|
||
#endif
|
||
#ifndef EAGAIN
|
||
#define EAGAIN 11
|
||
#endif
|
||
#ifndef ECONNRESET
|
||
#define ECONNRESET 104
|
||
#endif
|
||
#ifndef EPIPE
|
||
#define EPIPE 32
|
||
#endif
|
||
#ifndef ECONNABORTED
|
||
#define ECONNABORTED 103
|
||
#endif
|
||
#ifndef ETIMEDOUT
|
||
#define ETIMEDOUT 110
|
||
#endif
|
||
#ifndef ENETDOWN
|
||
#define ENETDOWN 100
|
||
#endif
|
||
#ifndef ENETUNREACH
|
||
#define ENETUNREACH 101
|
||
#endif
|
||
#ifndef EHOSTUNREACH
|
||
#define EHOSTUNREACH 113
|
||
#endif
|
||
#ifndef errno
|
||
extern int errno;
|
||
#endif
|
||
|
||
#define TCP_LOCAL_PORT TCP_DEBUG_PORT
|
||
#define MAX_CLIENTS TCP_DEBUG_MAX_CLIENTS
|
||
|
||
typedef struct {
|
||
int server_socket;
|
||
int client_socket;
|
||
uint8_t is_client_connected;
|
||
struct sockaddr_in client_addr;
|
||
} tcp_socket_server_t;
|
||
|
||
static tcp_socket_server_t socket_server = {
|
||
.server_socket = -1,
|
||
.client_socket = -1,
|
||
.is_client_connected = 0,
|
||
};
|
||
|
||
static SemaphoreHandle_t socket_mutex = NULL;
|
||
|
||
static int tcp_socket_create_server(void)
|
||
{
|
||
int sock;
|
||
struct sockaddr_in server_addr;
|
||
int opt = 1;
|
||
|
||
sock = lwip_socket(AF_INET, SOCK_STREAM, 0);
|
||
if (sock < 0) {
|
||
TCP_PRINT("Failed to create socket: %d\r\n", sock);
|
||
return -1;
|
||
}
|
||
|
||
lwip_setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
|
||
|
||
memset(&server_addr, 0, sizeof(server_addr));
|
||
server_addr.sin_family = AF_INET;
|
||
server_addr.sin_addr.s_addr = INADDR_ANY;
|
||
server_addr.sin_port = htons(TCP_LOCAL_PORT);
|
||
|
||
if (lwip_bind(sock, (struct sockaddr *)&server_addr, sizeof(server_addr)) < 0) {
|
||
TCP_PRINT("Failed to bind socket to port %d\r\n", TCP_LOCAL_PORT);
|
||
lwip_close(sock);
|
||
return -1;
|
||
}
|
||
|
||
if (lwip_listen(sock, MAX_CLIENTS) < 0) {
|
||
TCP_PRINT("Failed to listen on socket\r\n");
|
||
lwip_close(sock);
|
||
return -1;
|
||
}
|
||
|
||
{
|
||
int flags = lwip_fcntl(sock, F_GETFL, 0);
|
||
lwip_fcntl(sock, F_SETFL, flags | O_NONBLOCK);
|
||
}
|
||
|
||
TCP_PRINT("TCP server socket created on port %d\r\n", TCP_LOCAL_PORT);
|
||
return sock;
|
||
}
|
||
|
||
static int tcp_socket_init(void)
|
||
{
|
||
socket_mutex = xSemaphoreCreateMutex();
|
||
if (socket_mutex == NULL) {
|
||
TCP_PRINT("Failed to create socket mutex\r\n");
|
||
return -1;
|
||
}
|
||
|
||
socket_server.server_socket = tcp_socket_create_server();
|
||
if (socket_server.server_socket < 0) {
|
||
vSemaphoreDelete(socket_mutex);
|
||
socket_mutex = NULL;
|
||
return -1;
|
||
}
|
||
|
||
socket_server.client_socket = -1;
|
||
socket_server.is_client_connected = 0;
|
||
|
||
TCP_PRINT("Socket server initialized successfully\r\n");
|
||
return 0;
|
||
}
|
||
|
||
static int tcp_socket_accept_client(void)
|
||
{
|
||
struct sockaddr_in client_addr;
|
||
socklen_t addr_len = sizeof(client_addr);
|
||
int new_sock;
|
||
|
||
if (socket_server.server_socket < 0) {
|
||
return -1;
|
||
}
|
||
|
||
if (socket_mutex != NULL) {
|
||
xSemaphoreTake(socket_mutex, portMAX_DELAY);
|
||
}
|
||
|
||
new_sock = lwip_accept(socket_server.server_socket,
|
||
(struct sockaddr *)&client_addr, &addr_len);
|
||
|
||
if (new_sock >= 0) {
|
||
if (socket_server.is_client_connected) {
|
||
TCP_PRINT("Rejecting new connection - already have a client\r\n");
|
||
lwip_close(new_sock);
|
||
if (socket_mutex != NULL) {
|
||
xSemaphoreGive(socket_mutex);
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
{
|
||
int flags = lwip_fcntl(new_sock, F_GETFL, 0);
|
||
lwip_fcntl(new_sock, F_SETFL, flags | O_NONBLOCK);
|
||
}
|
||
|
||
socket_server.client_socket = new_sock;
|
||
socket_server.is_client_connected = 1;
|
||
memcpy(&socket_server.client_addr, &client_addr, sizeof(client_addr));
|
||
|
||
TCP_PRINT("Client connected from %s:%d\r\n",
|
||
inet_ntoa(client_addr.sin_addr), ntohs(client_addr.sin_port));
|
||
}
|
||
|
||
if (socket_mutex != NULL) {
|
||
xSemaphoreGive(socket_mutex);
|
||
}
|
||
|
||
return (new_sock >= 0) ? 1 : 0;
|
||
}
|
||
|
||
static int tcp_socket_receive_data(uint8_t *buffer, uint32_t buffer_size)
|
||
{
|
||
int received;
|
||
|
||
if (buffer == NULL || buffer_size == 0U) {
|
||
return -1;
|
||
}
|
||
|
||
if (socket_mutex != NULL) {
|
||
xSemaphoreTake(socket_mutex, portMAX_DELAY);
|
||
}
|
||
|
||
if (!socket_server.is_client_connected || socket_server.client_socket < 0) {
|
||
if (socket_mutex != NULL) {
|
||
xSemaphoreGive(socket_mutex);
|
||
}
|
||
return -1;
|
||
}
|
||
|
||
received = lwip_recv(socket_server.client_socket, buffer, buffer_size, 0);
|
||
|
||
if (received > 0) {
|
||
TCP_PRINT("Received %d bytes from client\r\n", received);
|
||
} else if (received == 0) {
|
||
TCP_PRINT("Client disconnected\r\n");
|
||
lwip_close(socket_server.client_socket);
|
||
socket_server.client_socket = -1;
|
||
socket_server.is_client_connected = 0;
|
||
received = -1;
|
||
#if FATFS_EN
|
||
fatfs_set_write_disable_flag(FATFS_WRITE_DISABLE_TCP_DEBUG, 0);
|
||
#endif
|
||
} else {
|
||
int err = errno;
|
||
if (err != EWOULDBLOCK && err != EAGAIN) {
|
||
TCP_PRINT("Socket receive error: %d\r\n", err);
|
||
if (err == ECONNRESET || err == EPIPE || err == ECONNABORTED ||
|
||
err == ETIMEDOUT || err == ENETDOWN || err == ENETUNREACH ||
|
||
err == EHOSTUNREACH) {
|
||
TCP_PRINT("Connection error detected, closing socket\r\n");
|
||
lwip_close(socket_server.client_socket);
|
||
socket_server.client_socket = -1;
|
||
socket_server.is_client_connected = 0;
|
||
#if FATFS_EN
|
||
fatfs_set_write_disable_flag(FATFS_WRITE_DISABLE_TCP_DEBUG, 0);
|
||
#endif
|
||
}
|
||
received = -1;
|
||
} else {
|
||
received = 0;
|
||
}
|
||
}
|
||
|
||
if (socket_mutex != NULL) {
|
||
xSemaphoreGive(socket_mutex);
|
||
}
|
||
|
||
return received;
|
||
}
|
||
|
||
static int tcp_socket_send_data(const uint8_t *data, uint32_t len)
|
||
{
|
||
int sent;
|
||
|
||
if (data == NULL || len == 0U) {
|
||
return -1;
|
||
}
|
||
|
||
if (socket_mutex != NULL) {
|
||
xSemaphoreTake(socket_mutex, portMAX_DELAY);
|
||
}
|
||
|
||
if (!socket_server.is_client_connected || socket_server.client_socket < 0) {
|
||
if (socket_mutex != NULL) {
|
||
xSemaphoreGive(socket_mutex);
|
||
}
|
||
return -1;
|
||
}
|
||
|
||
sent = lwip_send(socket_server.client_socket, data, len, 0);
|
||
|
||
if (sent > 0) {
|
||
TCP_PRINT("Sent %d bytes to client\r\n", sent);
|
||
} else {
|
||
TCP_PRINT("Failed to send data: %d\r\n", sent);
|
||
if (sent < 0) {
|
||
int err = errno;
|
||
if (err == ECONNRESET || err == EPIPE) {
|
||
TCP_PRINT("Connection broken, closing socket\r\n");
|
||
lwip_close(socket_server.client_socket);
|
||
socket_server.client_socket = -1;
|
||
socket_server.is_client_connected = 0;
|
||
}
|
||
}
|
||
}
|
||
|
||
if (socket_mutex != NULL) {
|
||
xSemaphoreGive(socket_mutex);
|
||
}
|
||
|
||
return sent;
|
||
}
|
||
|
||
static int tcp_socket_is_client_connected(void)
|
||
{
|
||
int connected;
|
||
|
||
if (socket_mutex != NULL) {
|
||
xSemaphoreTake(socket_mutex, portMAX_DELAY);
|
||
}
|
||
|
||
connected = socket_server.is_client_connected;
|
||
|
||
if (socket_mutex != NULL) {
|
||
xSemaphoreGive(socket_mutex);
|
||
}
|
||
|
||
return connected;
|
||
}
|
||
|
||
static void tcp_socket_close_client(void)
|
||
{
|
||
if (socket_mutex != NULL) {
|
||
xSemaphoreTake(socket_mutex, portMAX_DELAY);
|
||
}
|
||
|
||
if (socket_server.client_socket >= 0) {
|
||
lwip_close(socket_server.client_socket);
|
||
socket_server.client_socket = -1;
|
||
}
|
||
|
||
socket_server.is_client_connected = 0;
|
||
|
||
#if FATFS_EN
|
||
fatfs_set_write_disable_flag(FATFS_WRITE_DISABLE_TCP_DEBUG, 0);
|
||
#endif
|
||
|
||
TCP_PRINT("Client connection closed\r\n");
|
||
|
||
if (socket_mutex != NULL) {
|
||
xSemaphoreGive(socket_mutex);
|
||
}
|
||
}
|
||
|
||
static void tcp_socket_close_server(void)
|
||
{
|
||
if (socket_mutex != NULL) {
|
||
xSemaphoreTake(socket_mutex, portMAX_DELAY);
|
||
}
|
||
|
||
if (socket_server.client_socket >= 0) {
|
||
lwip_close(socket_server.client_socket);
|
||
socket_server.client_socket = -1;
|
||
}
|
||
|
||
if (socket_server.server_socket >= 0) {
|
||
lwip_close(socket_server.server_socket);
|
||
socket_server.server_socket = -1;
|
||
}
|
||
|
||
socket_server.is_client_connected = 0;
|
||
|
||
#if FATFS_EN
|
||
fatfs_set_write_disable_flag(FATFS_WRITE_DISABLE_TCP_DEBUG, 0);
|
||
#endif
|
||
|
||
if (socket_mutex != NULL) {
|
||
xSemaphoreGive(socket_mutex);
|
||
vSemaphoreDelete(socket_mutex);
|
||
socket_mutex = NULL;
|
||
}
|
||
|
||
TCP_PRINT("Socket server closed\r\n");
|
||
}
|
||
|
||
static int tcp_socket_get_client_ip(char *ip_buffer, uint32_t buffer_size)
|
||
{
|
||
const char *ip_str;
|
||
|
||
if (ip_buffer == NULL || buffer_size == 0U) {
|
||
return -1;
|
||
}
|
||
|
||
if (socket_mutex != NULL) {
|
||
xSemaphoreTake(socket_mutex, portMAX_DELAY);
|
||
}
|
||
|
||
if (!socket_server.is_client_connected) {
|
||
if (socket_mutex != NULL) {
|
||
xSemaphoreGive(socket_mutex);
|
||
}
|
||
return -1;
|
||
}
|
||
|
||
ip_str = inet_ntoa(socket_server.client_addr.sin_addr);
|
||
if (ip_str != NULL) {
|
||
strncpy(ip_buffer, ip_str, buffer_size - 1U);
|
||
ip_buffer[buffer_size - 1U] = '\0';
|
||
} else {
|
||
if (socket_mutex != NULL) {
|
||
xSemaphoreGive(socket_mutex);
|
||
}
|
||
return -1;
|
||
}
|
||
|
||
if (socket_mutex != NULL) {
|
||
xSemaphoreGive(socket_mutex);
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
|
||
/* =============================================================================
|
||
* comm_link 分发（原 comm_link.c）
|
||
* ============================================================================= */
|
||
|
||
#define SESS (comm_link_session())
|
||
|
||
static uint8_t comm_link_using_ble(void)
|
||
{
|
||
#if BLE_DEBUG_EN
|
||
return (SESS->type == COMM_LINK_BLE) ? 1U : 0U;
|
||
#else
|
||
return 0U;
|
||
#endif
|
||
}
|
||
|
||
void comm_link_set_type(comm_link_type_t type)
|
||
{
|
||
SESS->type = type;
|
||
}
|
||
|
||
comm_link_type_t comm_link_get_type(void)
|
||
{
|
||
return SESS->type;
|
||
}
|
||
|
||
comm_link_type_t comm_link_type_from_dip(void)
|
||
{
|
||
#if BLE_DEBUG_EN
|
||
return ble_link_is_bt_mode() ? COMM_LINK_BLE : COMM_LINK_TCP;
|
||
#else
|
||
return COMM_LINK_TCP;
|
||
#endif
|
||
}
|
||
|
||
int comm_link_start(void)
|
||
{
|
||
if (comm_link_using_ble() != 0U) {
|
||
#if BLE_DEBUG_EN
|
||
return comm_link_ble_start();
|
||
#endif
|
||
}
|
||
return tcp_socket_init();
|
||
}
|
||
|
||
void comm_link_stop(void)
|
||
{
|
||
if (comm_link_using_ble() != 0U) {
|
||
#if BLE_DEBUG_EN
|
||
comm_link_ble_stop();
|
||
#endif
|
||
return;
|
||
}
|
||
tcp_socket_close_server();
|
||
}
|
||
|
||
void comm_link_process(void)
|
||
{
|
||
#if BLE_DEBUG_EN
|
||
if (comm_link_using_ble() != 0U) {
|
||
comm_link_ble_process();
|
||
}
|
||
#endif
|
||
}
|
||
|
||
int comm_link_accept_client(void)
|
||
{
|
||
if (comm_link_using_ble() != 0U) {
|
||
return 0;
|
||
}
|
||
return tcp_socket_accept_client();
|
||
}
|
||
|
||
int comm_link_is_client_connected(void)
|
||
{
|
||
if (comm_link_using_ble() != 0U) {
|
||
#if BLE_DEBUG_EN
|
||
return comm_link_ble_is_client_connected();
|
||
#endif
|
||
return 0;
|
||
}
|
||
return tcp_socket_is_client_connected();
|
||
}
|
||
|
||
void comm_link_close_client(void)
|
||
{
|
||
if (comm_link_using_ble() != 0U) {
|
||
#if BLE_DEBUG_EN
|
||
comm_link_ble_close_client();
|
||
#endif
|
||
return;
|
||
}
|
||
tcp_socket_close_client();
|
||
}
|
||
|
||
int comm_link_receive_data(uint8_t *buffer, uint32_t buffer_size)
|
||
{
|
||
if (comm_link_using_ble() != 0U) {
|
||
#if BLE_DEBUG_EN
|
||
return comm_link_ble_receive_data(buffer, buffer_size);
|
||
#endif
|
||
return 0;
|
||
}
|
||
return tcp_socket_receive_data(buffer, buffer_size);
|
||
}
|
||
|
||
int comm_link_send_data(const uint8_t *data, uint32_t len)
|
||
{
|
||
if (comm_link_using_ble() != 0U) {
|
||
#if BLE_DEBUG_EN
|
||
return comm_link_ble_send_data(data, len);
|
||
#endif
|
||
return -1;
|
||
}
|
||
return tcp_socket_send_data(data, len);
|
||
}
|
||
|
||
int comm_link_get_peer_info(char *buf, uint32_t buf_size)
|
||
{
|
||
if ((buf == NULL) || (buf_size == 0U)) {
|
||
return -1;
|
||
}
|
||
|
||
if (SESS->peer_info[0] != '\0') {
|
||
(void)snprintf(buf, buf_size, "%s", SESS->peer_info);
|
||
return 0;
|
||
}
|
||
|
||
if (comm_link_using_ble() != 0U) {
|
||
#if BLE_DEBUG_EN
|
||
return comm_link_ble_get_peer_info(buf, buf_size);
|
||
#endif
|
||
}
|
||
return tcp_socket_get_client_ip(buf, buf_size);
|
||
}
|
||
|
||
#else /* TCP_DEBUG_EN */
|
||
|
||
comm_link_ctx_t *comm_link_ctx_get(void) { return NULL; }
|
||
comm_link_session_t *comm_link_session(void) { return NULL; }
|
||
void comm_link_ctx_reset_session(void) { }
|
||
void comm_link_ctx_reset_all(void) { }
|
||
|
||
void comm_link_set_type(comm_link_type_t type) { (void)type; }
|
||
comm_link_type_t comm_link_get_type(void) { return COMM_LINK_TCP; }
|
||
comm_link_type_t comm_link_type_from_dip(void) { return COMM_LINK_TCP; }
|
||
int comm_link_start(void) { return -1; }
|
||
void comm_link_stop(void) { }
|
||
void comm_link_process(void) { }
|
||
int comm_link_accept_client(void) { return -1; }
|
||
int comm_link_is_client_connected(void) { return 0; }
|
||
void comm_link_close_client(void) { }
|
||
int comm_link_receive_data(uint8_t *buffer, uint32_t buffer_size)
|
||
{
|
||
(void)buffer;
|
||
(void)buffer_size;
|
||
return -1;
|
||
}
|
||
int comm_link_send_data(const uint8_t *data, uint32_t len)
|
||
{
|
||
(void)data;
|
||
(void)len;
|
||
return -1;
|
||
}
|
||
int comm_link_get_peer_info(char *buf, uint32_t buf_size)
|
||
{
|
||
(void)buf;
|
||
(void)buf_size;
|
||
return -1;
|
||
}
|
||
|
||
#endif /* TCP_DEBUG_EN */
|