T536_DTU/dtu/dtu_main_t536/app/net_debug.c

/******************************************************************************
版权所有：
文件名称：	net_debug.c
文件版本：	01.01
创建作者:	   sunxi
创建日期：	2012-11-07
功能说明：	网络调试接口
其它说明：
修改记录：
*/
/*------------------------------- 头文件 --------------------------------------
 */
#include "head.h"
#ifdef LINUX_KERNEL_APP
#include <linux/delay.h>
#include <linux/syscalls.h>
#include <linux/signal.h>
#else
#include <pthread.h>
#include <sys/prctl.h>
#endif
/*------------------------------- 宏定义 --------------------------------------
 */

/*------------------------------ 类型结构 -------------------------------------
 */

/*------------------------------ 全局变量 -------------------------------------
 */
#ifdef LINUX_KERNEL_APP
static struct task_struct *g_ts_debug_send;
static struct task_struct *g_ts_debug_recv;
#else
static pthread_t g_ts_debug_recv = 0;
#endif

SOCKET g_debug_client = RT_SOCKET_ERR;

unsigned char g_net_debug_buf[NET_RECV_MAX]; // 以太网接收缓冲区

int g_print_to_net;
int g_print_time;

int g_print_comm_raw;
int g_print_101;
int g_print_104;
int g_print_lnk;
int g_print_hmi;
int g_print_can;
int g_print_can_monitor;
int g_print_sys;
int g_print_dd;
int g_print_goose;

u32 g_print_port = -1; // 允许打印的串口通道，用位表示

int g_test_on;

extern struct semaphore g_print_sem;

#ifdef LINUX_KERNEL_APP
extern struct semaphore g_print_sem;

static pid_t g_net_debug_thread_send_pid;
static pid_t g_net_debug_thread_recv_pid;
static int g_net_debug_send_exit_flag = 0;
#endif

static volatile int g_net_debug_sock_flag = NET_SOCKET_INIT; // 关闭SOCKET标志
static int g_net_debug_recv_exit_flag = 0;
DEBUG_COMM g_tDebug; // 定义下载串口结构
/*------------------------------ 函数声明 -------------------------------------
 */
void _net_debug_recv_reset(void);
void _net_debug_print_reset(void);
#ifdef LINUX_KERNEL_APP
int _net_debug_thread_send(void *unused);
#endif
int _net_debug_thread_recv(void *unused);

/*------------------------------ 外部函数 -------------------------------------
外部函数供其它实体文件引用，必须仔细检查传入参数的合法性.
*/

// 设置socket关闭标志并等待socket关闭完成
void net_debug_set_sock_closing(int no)
{
    struct sockaddr_in local_addr;
    unsigned int len = sizeof(local_addr);
    RUN_PARA *pRunPara = &tRunPara;
    unsigned int ip = 0;
    int bflag = 0;

    // 如果有客户端连接
    if (g_debug_client != RT_SOCKET_ERR)
    {
        // 获取客户端连接的IP
        rt_getsockname(g_debug_client, (struct sockaddr *)&local_addr, &len);

#if 1
        if (pRunPara->tNetPara[no].old_index == 0)
        {
            // 获取网卡IP
            rt_if_ip_get(pRunPara->tNetPara[no].old_ethid, (unsigned char *)&ip); // sunxi: 20220825 335x
        }
        else
        {
            // 获取虚拟网卡上的IP地址
            rt_if_ip_get2(pRunPara->tNetPara[no].old_ethid, pRunPara->tNetPara[no].old_index, (unsigned char *)&ip); // sunxi: 20220825 335x
        }

        // 如果是该网卡的IP并且该网卡要修改IP或MASK,则需要通知关闭socket
        if ((htonl(ip) == local_addr.sin_addr.s_addr) && pRunPara->tNetPara[no].bInit) // sunxi: 20220825 335x
        {
            bflag = 1;
        }
#endif

        // 该网卡的IP和MASK没有修改,则不需要通知关闭socket
        if (!bflag)
        {
            return;
        }

        g_net_debug_sock_flag = NET_SOCKET_CLOSING; // 置关闭标志

        // 等待关闭完成
        while (g_net_debug_sock_flag != NET_SOCKET_CLOSED)
        {
            msleep(20);
        }
    }
}

// 设置socket重新创建标志
void net_debug_set_sock_initflag(void)
{
    if (g_net_debug_sock_flag == NET_SOCKET_CLOSED)
    {
        g_net_debug_sock_flag = NET_SOCKET_REINIT;
    }
}

//
#ifdef LINUX_KERNEL_APP
int net_debug_s_init(void)
{
    struct sched_param sp;
    pid_t pid;

#if 1
    // 如果已经初始化，退出
    if (g_ts_debug_send)
    {
        return 0;
    }

    // 运行应用调试线程
    // g_ts_debug_send = kthread_run(_net_debug_thread_send,NULL,"net_debug_send");
    pid = kernel_thread(_net_debug_thread_send, NULL, CLONE_FS | CLONE_FILES | CLONE_SIGHAND | SIGCHLD);
    g_ts_debug_send = find_task_by_vpid(pid);
    if (IS_ERR(g_ts_debug_send))
    {
        printk("ts=%p\r\n", g_ts_debug_send);
        g_ts_debug_send = NULL;
        return -1;
    }
    g_net_debug_thread_send_pid = pid;
    memset(&sp, 0, sizeof(sp));
    sp.sched_priority = 8;
    sched_setscheduler(g_ts_debug_send, SCHED_FIFO, &sp);
    // 设置进程名字
    set_task_comm(g_ts_debug_send, "net_debug_send");

#endif

    return 0;
}
#else
int net_debug_s_init(void)
{
    return 0;
}
#endif

#ifdef LINUX_KERNEL_APP
int net_debug_s_exit(void)
{
    int status;

    if (g_ts_debug_send != NULL)
    {
        up(&g_print_sem);
        g_net_debug_send_exit_flag = 1;

        sys_wait4(g_net_debug_thread_send_pid, (int __user *)&status, 0, NULL);

        g_ts_debug_send = NULL;
    }
    return 0;
}
#else
int net_debug_s_exit(void)
{
    return 0;
}
#endif

// TODO: 需要确认是否需要重新初始化
int net_debug_init(void)
{
    int ret;
    pthread_attr_t attr;

    // attr.__schedpolicy = SCHED_FIFO;
    // attr.__schedparam.sched_priority =8;

    // 设置调度策略和优先级
    pthread_attr_init(&attr);
    pthread_attr_setschedpolicy(&attr, SCHED_FIFO); // 调度
    struct sched_param s_parm;
    // s_parm.sched_priority = sched_get_priority_max(SCHED_FIFO);
    s_parm.sched_priority = 8;
    pthread_attr_setschedparam(&attr, &s_parm); // 优先级

    ret = pthread_create(&g_ts_debug_recv, &attr, (void *)_net_debug_thread_recv, NULL);
    if (!ret)
    {
        rt_printf("ret = %d, err = %s\r\n", ret, strerror(ret));
        // g_ts_rcd = 0;
        return ret;
    }

    return 0;
}

#ifdef LINUX_KERNEL_APP
int net_debug_exit(void)
{
    int status;
#if 0
	if(g_ts_debug_send != NULL)
	{
		up(&g_print_sem);
		g_net_debug_send_exit_flag = 1;
		
		sys_wait4(g_net_debug_thread_send_pid, (int __user *)&status, 0, NULL);
		
		g_ts_debug_send = NULL;
			
	}
#endif
    if (g_ts_debug_recv != NULL)
    {
        g_net_debug_recv_exit_flag = 1;

        sys_wait4(g_net_debug_thread_recv_pid, (int __user *)&status, 0, NULL);

        g_ts_debug_recv = NULL;
    }

    return 0;
}
#else
int net_debug_exit(void)
{
    if (g_ts_debug_recv)
    {
        g_net_debug_recv_exit_flag = 1;

        // sys_wait4(g_net_debug_thread_recv_pid, (int __user *)&status, 0, NULL);
        pthread_join(g_ts_debug_recv, NULL);

        g_ts_debug_recv = 0;
    }

    return 0;
}

#endif

// 此函数必须在线程中调用，不能在中断中调用。
int net_debug_send(unsigned char *buf, int len)
{
    if (g_debug_client == RT_SOCKET_ERR)
    {
        return 0;
    }

    return rt_send(g_debug_client, buf, len, 0);
}

#ifdef METERING_ENERGY
const char main_Debug[] =
    "\r\n*********装置调试菜单*******\r\n \
0：通讯原始数据监视[通道可选]\r\n \
1：101报文监视[通道可选]\r\n \
2：104报文监视[通道可选]\r\n \
3：CAN报文监视\r\n \
4：系统信息监视\r\n \
5：报文时标开启\r\n \
6：关闭所有监视\r\n \
7：面板报文监视\r\n \
8：CAN总线监视\r\n \
A：载入默认公钥\r\n \
B：加密测试\r\n \
C：SOE测试\r\n \
D：重启系统\r\n \
E：打印点表\r\n \
F: 级联报文监视[通道可选]\r\n \
G:goose报文监视\r\n \
H:文件召唤测试\r\n \
I:程序升级测试\r\n \
J:打印终端固有参数\r\n \
K:新生成soe.xml文件\r\n \
L:新生成co.xml文件\r\n \
M:清零电压合格率\r\n \
N:清零脉冲计数值\r\n \
P:61850信息打印\r\n \
Q:生成菜单显示文件\r\n \
R:生成icd文件\r\n \
S:计量板校准\r\n \
T:计量电能清零\r\n \
U:CAN子板ID打印\r\n \
其它：关闭所有监视信息\r\n \
\r\n>:";
#else
const char main_Debug[] =
    "\r\n*********装置调试菜单*******\r\n \
0：通讯原始数据监视[通道可选]\r\n \
1：101报文监视[通道可选]\r\n \
2：104报文监视[通道可选]\r\n \
3：CAN报文监视\r\n \
4：系统信息监视\r\n \
5：报文时标开启\r\n \
6：关闭所有监视\r\n \
7：面板报文监视\r\n \
8：CAN总线监视\r\n \
A：载入默认公钥\r\n \
B：加密测试\r\n \
C：SOE测试\r\n \
D：重启系统\r\n \
E：打印点表\r\n \
F: 级联报文监视[通道可选]\r\n \
G:goose报文监视\r\n \
H:文件召唤测试\r\n \
I:程序升级测试\r\n \
J:打印终端固有参数\r\n \
K:新生成soe.xml文件\r\n \
L:新生成co.xml文件\r\n \
M:清零电压合格率\r\n \
N:清零脉冲计数值\r\n \
P:61850信息打印\r\n \
Q:生成菜单显示文件\r\n \
R:生成icd文件\r\n \
r:查看实时线程状态\r\n \
s:复位实时线程状态\r\n \
S:ADC采样状态\r\n \
v:遥调点表打印\r\n \
w:录波修正\r\n \
其它：关闭所有监视信息\r\n \
\r\n>:";
#endif

BYTE arrApn[48];
extern int g_soe_test;

int _net_debug_get_chn(void)
{
    int chn;

    if (g_tDebug.cRecvCnt >= 3)
    {
        chn = g_tDebug.arrRecvBuf[2] - '0';
        if (chn >= 0 && chn < COMM_CHANNEL_NUM)
        {
            g_print_port = 1 << chn;
            return chn;
        }
    }

    return -1;
}

extern int dt_cmd_rt(void);
extern int dt_cmd_adc(void);
extern int dt_cmd_rt_reset(void);
void net_debug_app(void)
{
    u8 ch;
    int chn;
    int ret = -1;
#ifdef CAN_SLAVE_BOARD
    static bool sb_metering = false;
#endif

    if (!g_tDebug.bData)
        return;

    g_tDebug.bData = false;

    // 超级终端处理
    ch = g_tDebug.arrRecvBuf[g_tDebug.cRecvCnt - 1];
    if (ch != 0x0d) // 回车键
    {
        _net_debug_recv_reset();
        return;
    }

    // 前7个和维护工具配合使用，不可改变
    switch (g_tDebug.arrRecvBuf[0])
    {
    case '0':
        g_print_comm_raw = 1;
        g_print_to_net = 1;
        chn = _net_debug_get_chn();
        rt_printf("\r\n打开串口原始数据监视[chn=%d]:\r\n", chn);
        break;

    case '1':
        g_print_101 = 1;
        g_print_to_net = 1;
        chn = _net_debug_get_chn();
        rt_printf("\r\n打开101报文监视[chn=%d]:\r\n", chn);
        break;

    case '2':
        g_print_104 = 1;
        g_print_to_net = 1;
        chn = _net_debug_get_chn();
        rt_printf("\r\n打开104报文监视[chn=%d]:\r\n", chn);
        break;

    case '3':
        g_print_can = 1;
        g_print_to_net = 1;
        rt_printf("\r\n打开CAN报文监视:\r\n");
        break;
    case '4':
        g_print_sys = 1;
        g_print_to_net = 1;
        rt_printf("\r\n打开系统监视:\r\n");
        break;

    case '5':
        g_print_time = 1;
        rt_printf("\r\n报文时标开启:\r\n");
        break;

    case '6':
        g_print_to_net = 1;
        g_print_port = -1;
        rt_printf("\r\n所有报文监视关闭:\r\n");
        _net_debug_print_reset();
        break;

    case '7':
        g_print_hmi = 1;
        g_print_to_net = 1;
        rt_printf("\r\n打开面板报文监视:\r\n");

        break;

    case '8':
        g_print_can_monitor = 1;
        g_print_to_net = 1;

        break;

    case 'A':
    case 'a':
        g_print_to_net = 1;
#ifdef ENCRYPT_SM2
        InitSM2Key();
        rt_printf("\r\n公钥保存成功\r\n");
#else
        rt_printf("\r\n不支持SM2加密\r\n");
#endif
        break;
    case 'B':
    case 'b':
        g_print_sys = 1;
        g_print_to_net = 1;
#ifdef ENCRYPT_SM2
        encrypt_test();
#else
        rt_printf("\r\n不支持SM2加密\r\n");
#endif
        break;
    case 'C':
    case 'c':
        g_print_to_net = 1;
        g_soe_test = 1;
        break;
    case 'D':
    case 'd':
        g_print_to_net = 1;
        rt_printf("\r\n系统重新启动\r\n");
        Delayms(dTCounter, T_1s);
        watchdog_reset_cpu(4);
        break;
    case 'E':
    case 'e':
        g_print_to_net = 1;
        tbl_printf_cvs();
        break;
    case 'f':
    case 'F':
        g_print_lnk = 1;
        g_print_to_net = 1;
        chn = _net_debug_get_chn();
        rt_printf("\r\n打开级联报文监视[chn=%d]:\r\n", chn);
        break;

    case 'J':
    case 'j':
    {
        extern void iec_printfihertset(void);
        g_print_to_net = 1;
        rt_printf("\r\n-----配电终端固有参数-----------\r\n");
        iec_printfixedset();
        g_print_dd = 1;
    }

    break;

    case 'h':
    case 'H':
    {
        g_print_to_net = 1;
        g_print_lnk = 1;
        lnk_read_test_file();
    }
    break;
    case 'i':
    case 'I':
    {
        g_print_to_net = 1;
        g_print_lnk = 1;
        lnk_write_test_file();
    }

    case 'G':
    case 'g':
        g_print_goose = 1;
        g_print_to_net = 1;
        g_print_port = -1;
        //_net_debug_get_chn();
        rt_printf("\r\n打开goose报文监视:\r\n");
        break;
    case 'k':
    case 'K':
        g_print_to_net = 1;

        ret = del_history_file(HS_FILE_SOE);

        if (!ret)
        {
            ret = create_event_rcd_file(HS_FILE_SOE);
        }

        if (!ret)
        {
            rt_printf("新生成soe.msg文件成功\r\n");
        }
        else
        {
            rt_printf("新生成soe.msg文件失败\r\n");
        }
        break;

    case 'l':
    case 'L':
        g_print_to_net = 1;

        ret = del_history_file(HS_FILE_CO);

        if (!ret)
        {
            ret = create_event_rcd_file(HS_FILE_CO);
        }

        if (!ret)
        {
            rt_printf("新生成co.msg文件成功\r\n");
        }
        else
        {
            rt_printf("新生成co.msg文件失败\r\n");
        }
        break;

    case 'M':
    case 'm':
        g_print_to_net = 1;
        SaveUqua(true);
        rt_printf("\r\n电压合格率清零\r\n");
        break;
    case 'N':
    case 'n':
        g_print_to_net = 1;
        {
            int sw;
            for (sw = 0; sw < SWITCH_NUM_MAX; sw++)
            {
                g_sw[sw].ac_in[SW_AC_IN_IMP1] = 0;
                g_sw[sw].ac_in[SW_AC_IN_IMP2] = 0;
            }
        }
        rt_printf("\r\n脉冲计数率清零\r\n");
        break;

    case 'P':
    case 'p':
    {
        void app_goose_inf_print(void);
        g_print_to_net = 1;
#ifdef __IEC61850_GOOSE_FUNC__
        app_goose_inf_print();
#endif
    }
    break;

    case 'Q':
    case 'q':
    {
        void mmd_create_menufile(void);
        g_print_to_net = 1;
        mmd_create_menufile();
        rt_printf("\r\n/app/data/lcd_menu.csv 菜单定义文件已生成\r\n");
    }
    break;

    case 'r':
    {
        g_print_to_net = 1;
        dt_cmd_rt();
    }
    break;

    case 'S':
    {
        g_print_to_net = 1;
        dt_cmd_adc();
    }
    break;

    case 's':
    {
        g_print_to_net = 1;
        dt_cmd_rt_reset();
    }
    break;
#ifdef CAN_SLAVE_BOARD

    case 'R':
    case 'r':
    {
        g_print_to_net = 1;
        can_id_printf();
    }
    break;

    case 'S':
    case 's':
    {
        sb_metering = true;
        g_print_to_net = 1;
        can_metering_calib(g_tDebug.arrRecvBuf);
    }
    break;
    case 'T':
    case 't':
    {
        g_print_to_net = 1;
        can_app_energy_clear(0, get_can_slot(0));
    }
    break;
    case 'U':
    case 'u':
    {
        g_print_to_net = 1;
        can_id_printf();
    }
    break;
#endif
    case 'v':
    {
        g_print_to_net = 1;
        printf_myRmtSetArray();
    }
    break;

    case 'w':
    {
        g_print_to_net = 1;
        enable_lb_zero_adjust();
    }
    break;

    default:
#ifdef CAN_SLAVE_BOARD
        ret = 0;
        g_print_to_net = 1;

        if (sb_metering)
        {
            ret = can_metering_calib(g_tDebug.arrRecvBuf);
        }

        if (!ret)
#endif
        {
            _net_debug_print_reset();

            net_debug_send((unsigned char *)main_Debug, sizeof(main_Debug));

            g_print_sys = false;
        }
        break;
    }

    _net_debug_recv_reset();
}

void print_mem_net(char *addr, unsigned char *pd, int lenth)
{

    BYTE i, j;
    char buf[128], tempstr[8];

    if (addr != NULL)
    {
        sprintf(buf, "%s", addr);
        rt_printf(buf);
    }
    strcpy(buf, "");

    for (i = 0, j = 0; i < lenth; i++)
    {
        sprintf(tempstr, "%02X ", *pd++);
        strcat(buf, tempstr);
        j++;
        if (j > 18)
        {
            rt_printf(buf);
            strcpy(buf, "\r\n    ");
            j = 0;
        }
    }
    if (j > 0)
    {
        rt_printf(buf);
    }
    rt_printf("\r\n");
}

/*------------------------------ 内部函数 -------------------------------------
内部函数以下划线‘_’开头，不需要检查参数的合法性.
*/
void _net_debug_recv_reset(void)
{
    g_tDebug.cTypeCounter = 0;
    g_tDebug.cRecvCnt = 0;
}

void _net_debug_print_reset(void)
{
    g_print_to_net = 0;
    g_print_time = 0;

    g_print_101 = 0;
    g_print_104 = 0;
    g_print_lnk = 0;
    g_print_hmi = 0;
    g_print_can = 0;
    g_print_can_monitor = 0;
    g_print_sys = 0;
    g_print_dd = 0;
    g_print_comm_raw = 0;
    g_print_port = -1;
    g_test_on = 0;
    g_print_goose = 0;
}

void _net_debug_recv(BYTE cRcvData)
{
    if (g_tDebug.bData)
    {
        return;
    }

    // xshell 发送的保活状态消息
    if (cRcvData == 0xff || cRcvData == 0xf1)
    {
        return;
    }

    // rt_printf("cRcvData=%02x\r\n",cRcvData);

    g_tDebug.arrRecvBuf[g_tDebug.cRecvCnt++] = cRcvData;
    if (cRcvData == 0x0d)
    {
        g_tDebug.bData = true;
    }
    if (g_tDebug.cRecvCnt >= UART_FRAME_LEN)
    {
        _net_debug_recv_reset();
        return;
    }
    return;
}

#ifdef LINUX_KERNEL_APP
int _net_debug_thread_send(void *unused)
{

    while (1)
    {
        msleep(100);

        // 检查是否退出
        if (g_net_debug_send_exit_flag)
        {
            g_net_debug_send_exit_flag = 0;
            return 0;
        }
        // noted by sunxi: 20220701 统一冷火和335x，有信号量，才往下执行
        if (down_interruptible(&g_print_sem) < 0)
        {
            continue;
        }

        rt_printf_fifo_get(1);
    }

    return 0;
}
#endif

/*
noted by sunxi：20220825  335x 修复 6000端口超时或断开后，不能重连的问题

*/
int _net_debug_thread_recv(void *unused)
{
    struct sockaddr_in server_addr;
    struct sockaddr_in client_addr;
    struct linger ling;
#ifndef LINUX_KERNEL_APP
    struct timeval timeout;
#endif

    SOCKET sk_server, tmp_sock;

    int sin_size;
    int i, len, ret;
    unsigned char *ip;
#ifdef LINUX_KERNEL_APP
    unsigned int recv_timeout;
    unsigned int link_timeout = dTCounter;
#else
    int recv_timeout;
    int link_timeout = 0;
#endif
    unsigned int ip_server;

//	while(1) //noted by sunxi：20220825  335x 修复 6000端口超时或断开后，不能重连的问题
//	{
NET_BEGIN:

    // 1、建立socket并侦听
    // 服务器端开始建立socket描述符
#ifdef LINUX_KERNEL_APP
    sk_server = rt_socket(AF_INET, SOCK_STREAM | SOCK_NONBLOCK, 0);
#else
    sk_server = rt_socket(AF_INET, SOCK_STREAM, 0);
#endif
    if (sk_server == RT_SOCKET_ERR)
    {
        RT_PRINTF_POSITION();
        g_ts_debug_recv = NULL;
        return -1;
    }

    // 服务器端填充sockaddr结构
    memset(&server_addr, 0, sizeof(struct sockaddr_in));
    server_addr.sin_family = AF_INET;
    if (get_mt_port_proc() == NET_MT_PORT_PROC_2)
    {
        if (rt_if_ip_get2(0, 3, (unsigned char *)&ip_server) == 0)
        {
            server_addr.sin_addr.s_addr = htonl(ip_server);
        }
        else
        {
            server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
        }
    }
    else
    {
        server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    }

    server_addr.sin_port = htons(NET_DEBUG_PORT);

    // 捆绑sockfd描述符
    ret = rt_bind(sk_server, (struct sockaddr *)(&server_addr), sizeof(struct sockaddr));
    if (ret < 0)
    {
        RT_PRINTF_POSITION();
        rt_socket_close(sk_server);
        g_ts_debug_recv = NULL;

        return -2;
    }

    // 监听sockfd描述符
    ret = rt_listen(sk_server, 1);
    if (ret < 0)
    {
        RT_PRINTF_POSITION();
        rt_socket_close(sk_server);
        g_ts_debug_recv = NULL;

        return -3;
    }
#ifndef LINUX_KERNEL_APP
    // 设置接收超时
    timeout.tv_sec = 0;
    timeout.tv_usec = 500000;
    rt_setsockopt(sk_server, SOL_SOCKET, SO_RCVTIMEO, (char *)&timeout, sizeof(struct timeval));
#endif

    // 设置关闭延时
    ling.l_onoff = 1;
    ling.l_linger = 0;
    rt_setsockopt(sk_server, SOL_SOCKET, SO_LINGER, (char *)&ling, sizeof(struct linger));

    prctl(PR_SET_NAME, "_net_debug_recv");
    while (1) // noted by sunxi：20220825  335x 修复 6000端口超时或断开后，不能重连的问题
    {
        g_debug_client = RT_SOCKET_ACCEPT_RST;
// 2、接受外部链接
#ifdef RT_SOCKET_FD
        while (g_debug_client < 0)
#else
        while (g_debug_client == RT_SOCKET_ACCEPT_RST)
#endif
        {
            msleep(100);

            // 服务器阻塞，直到客户程序建立连接
            sin_size = sizeof(struct sockaddr_in);
            g_debug_client = rt_accept(sk_server, (struct sockaddr *)(&client_addr), &sin_size);

            // 检查是否退出
            // if(kthread_should_stop())
            if (g_net_debug_recv_exit_flag)
            {
                // 关闭客户端
                if (g_debug_client != RT_SOCKET_ERR)
                {
                    tmp_sock = g_debug_client;
                    g_debug_client = RT_SOCKET_ERR;
                    rt_socket_close(tmp_sock);
                }
                // 关闭服务器
                rt_socket_close(sk_server);
                g_net_debug_recv_exit_flag = 0;
                return 0;
            }
            // IP已经修改要关闭SOCKET
            if (g_net_debug_sock_flag == NET_SOCKET_CLOSING)
            {
                // 关闭客户端
                if (g_debug_client != RT_SOCKET_ERR)
                {
                    tmp_sock = g_debug_client;
                    g_debug_client = RT_SOCKET_ERR;
                    rt_socket_close(tmp_sock);
                }

                // 关闭服务器
                rt_socket_close(sk_server);
                // 置已经关闭标志
                g_net_debug_sock_flag = NET_SOCKET_CLOSED;
                // 等待IP修改完成
                while (g_net_debug_sock_flag != NET_SOCKET_REINIT)
                {
                    msleep(100);
                }
                // 置为初始化
                g_net_debug_sock_flag = NET_SOCKET_INIT;
                goto NET_BEGIN;
            }
        }

        // 3、关闭侦听socket，避免多个外部连接
        // rt_shutdown(sk_server, SHUT_RDWR);
        // rt_socket_close(sk_server); //noted by sunxi：20220825  335x 修复 6000端口超时或断开后，不能重连的问题

        ip = (unsigned char *)&client_addr.sin_addr.s_addr;
        rt_printf("debug client connect(ip=%d.%d.%d.%d)!\r\n", ip[0], ip[1], ip[2], ip[3]);
        {
            char buf[64];
            char log_info[128];
            sprintf(buf, "6000端口连接(%d#网络:IP=%d.%d.%d.%d)!\r\n", set_get_network_id_from_socket(g_debug_client) + 1, ip[0], ip[1], ip[2], ip[3]);
            log_str_time(LOG_OPERATE, buf, 0, 1);
            sprintf(log_info, "6000 port connection(%d#net:IP=%d.%d.%d.%d)", set_get_network_id_from_socket(g_debug_client) + 1, ip[0], ip[1], ip[2], ip[3]);
            load_hs_log_rcd(TYPE_CHNL_LINK, true, NULL, log_info, 1);
        }

        // 4、客户端已连接，处理客户端命令
#ifdef LINUX_KERNEL_APP
        recv_timeout = dTCounter;
#else
        recv_timeout = 0;
#endif
        while (1)
        {
#ifdef LINUX_KERNEL_APP
            msleep(2); // noted by sunxi: 20221212 设为非阻塞型
            len = rt_recv(g_debug_client, g_net_debug_buf, NET_RECV_MAX, MSG_DONTWAIT);
#else
            len = rt_recv(g_debug_client, g_net_debug_buf, NET_RECV_MAX, 0);
#endif

            // 检查是否退出
            if (g_net_debug_recv_exit_flag)
            {
                // 关闭客户端
                tmp_sock = g_debug_client;
                g_debug_client = RT_SOCKET_ERR;
                rt_socket_close(tmp_sock);

                // 关闭服务器
                rt_socket_close(sk_server); // noted by sunxi：20220825  335x 修复 6000端口超时或断开后，不能重连的问题
                g_net_debug_recv_exit_flag = 0;
                return 0;
            }
            // IP已经修改要关闭SOCKET
            if (g_net_debug_sock_flag == NET_SOCKET_CLOSING)
            {
                // 关闭客户端
                tmp_sock = g_debug_client;
                g_debug_client = RT_SOCKET_ERR;
                rt_socket_close(tmp_sock);
                // 关闭服务器
                rt_socket_close(sk_server); // noted by sunxi：20220825  335x 修复 6000端口超时或断开后，不能重连的问题
                // 置已经关闭标志
                g_net_debug_sock_flag = NET_SOCKET_CLOSED;
                // 等待IP修改完成
                while (g_net_debug_sock_flag != NET_SOCKET_REINIT)
                {
                    msleep(100);
                }
                // 置为初始化
                g_net_debug_sock_flag = NET_SOCKET_INIT;
                goto NET_BEGIN;
            }

#ifdef LINUX_KERNEL_APP
            if (len == -EAGAIN)
#else
            if ((len == -EAGAIN) || (len == -1)) // 使用linux的recvfrom没有接收到数据时返回-1 		jack.liu 20200916
#endif
            {
                if (rt_get_net_linkstatus(rt_get_netcard_id_from_socket(g_debug_client)) == 1)
                {
#ifdef LINUX_KERNEL_APP
                    if ((dTCounter - link_timeout) > RT_LINK_TIMEOUT * T_1s) // 500ms超时
#else
                    link_timeout++;
                    if (link_timeout > RT_LINK_TIMEOUT * 2) // 500ms超时
#endif
                    {
                        rt_printf("%s: link down\n", __FUNCTION__);
#ifdef LINUX_KERNEL_APP
                        link_timeout = dTCounter;
#else
                        link_timeout = 0;
#endif
                        break;
                    }
                }
                else
                {
#ifdef LINUX_KERNEL_APP
                    link_timeout = dTCounter;
#else
                    link_timeout = 0;
#endif
                }

                // 超时
#ifdef LINUX_KERNEL_APP
                if ((dTCounter - recv_timeout) > 120 * T_1s) // 超时2分钟，端口未收到数据，关闭端口
#else
                recv_timeout++;
                if (recv_timeout > 240) // 超时2分钟，端口未收到数据，关闭端口
#endif
                {
                    rt_printf("net_debug_thread:timeout\r\n");

                    break;
                }
                continue;
            }
#ifdef LINUX_KERNEL_APP
            else if (len <= 0)
#else
            else if ((len == 0) || (len < -1)) // 使用linux的recvfrom没有接收到数据时返回-1 		jack.liu 20200916
#endif
            {
                // 调用recv时，如果返回0，则表示对端关闭；返回负数，表示出错
                rt_printf("net_debug_thread:peer close(ret=%d).\r\n", len);
                msleep(100);
                break;
            }

            // 接收数据
#ifdef LINUX_KERNEL_APP
            recv_timeout = dTCounter;
            link_timeout = dTCounter;
#else
            recv_timeout = 0;
            link_timeout = 0;
#endif
            for (i = 0; i < len; i++)
            {
                _net_debug_recv(g_net_debug_buf[i]);
            }
            g_tDebug.bNet = true;
        }

        // 复位调试打印信息
        _net_debug_print_reset();

        // 关闭客户端socket
        tmp_sock = g_debug_client;
        g_debug_client = RT_SOCKET_ERR;
        {
            char buf[64];
            sprintf(buf, "6000端口关闭(%d#网络:IP=%d.%d.%d.%d)!\r\n", set_get_network_id_from_socket(tmp_sock) + 1, ip[0], ip[1], ip[2], ip[3]);
            log_str_time(LOG_OPERATE, buf, 0, 0);
            load_hs_log_rcd(TYPE_CHNL_LINK, true, NULL, "6000 port disconnection", 0);
        }
        rt_socket_close(tmp_sock);
    }

    // 理论上，程序不会运行到这儿
    return 0;
}

/*------------------------------ 测试函数 -------------------------------------
一个实体文件必须带一个本模块的测试函数来进行单元测试，如果的确不方便在本模块中
进行单元测试，必须在此注明实际的测试位置（例如在哪个实体文件中使用哪个测试函数）.
*/

/*------------------------------ 文件结束 -------------------------------------
 */