步骤1设置 SDK 许可证密钥

// 设置SDK许可证密钥（由 TUTK 提供）
int ret = TUTK_SDK_Set_License_Key(sdk_license_key);
if (ret != TUTK_ER_NoERROR) {
    printf("TUTK_SDK_Set_License_Key() error[%d]!\n", ret);
    return -1;
}

步骤2初始化 P2P 隧道服务器

// 初始化 P2P 隧道服务器（根据 SDK 版本选择接口）
#if _USE_SDK_VERSION_BELOW_4_3_5_0_
// 旧版本初始化接口（SDK 版本 < 4.3.5.0）
// 参数：允许的最大访客连接数（自定义，如8、16等）
#define MAX_CONNECTION 8  // 最大连接数示例
ret = P2PTunnelServerInitialize(MAX_CONNECTION);
if (ret != TUNNEL_ER_NoERROR) {
    printf("P2PTunnelServerInitialize() error[%d]!\n", ret);
    return -1;
}
#else
// 新版本初始化接口（SDK 版本 >= 4.3.5.0）
// 参数1：允许的最大访客连接数
// 参数2：1=开启局域网直连（提升速度，局域网内数据不加密）；0=关闭
// 注意：客户端需同样设置为1才能启用直连模式，否则无效
ret = P2PTunnelServerInitialize2(MAX_CONNECTION, 1);
if (ret != TUNNEL_ER_NoERROR) {
    printf("P2PTunnelServerInitialize2() error[%d]!\n", ret);
    return -1;
}
#endif

步骤3注册连接状态回调函数

// 注册连接状态回调函数
// 功能：当访客连接状态变更时，通过 TunnelStatusCB 回调通知业务层
// 参数1：回调函数指针（需自定义实现）
// 参数2：自定义参数（传递给回调函数，如设备上下文信息）
P2PTunnelServer_GetStatus(TunnelStatusCB, (void *)args);

步骤1实现端口验证回调函数

/**
 * P2P隧道端口验证回调函数
 * @brief 控制哪些端口允许通过隧道进行访问，实现端口级别的访问控制
 * @param nServicePort 待验证的服务端口号（如22、80等）
 * @param pArg 自定义参数（注册时传入，当前可传NULL）
 * @return 0=允许访问该端口，-1=拒绝访问该端口
 */
#define WEB_SERVICE_PORT    80    // Web服务端口（HTTP）
#define SSH_SERVICE_PORT    22    // SSH/SFTP服务端口
#define TELNET_SERVICE_PORT 23    // Telnet服务端口

int TunnelPortVerifyCB(uint16_t nServicePort, const void *pArg) {
    // 根据端口号判断是否允许访问
    switch (nServicePort) {
        case WEB_SERVICE_PORT:
        case SSH_SERVICE_PORT:
        case TELNET_SERVICE_PORT:
            // 允许访问预设的合法服务端口
            printf("[%s] 允许访问端口: %d\n", __func__, nServicePort);
            return 0;
        
        default:
            // 拒绝访问未授权的端口，防止非法访问
            printf("[%s] 拒绝访问端口: %d\n", __func__, nServicePort);
            return -1;
    }
}

步骤2注册端口验证回调

// 注册端口验证回调函数，实现端口访问控制
int ret = P2PTunnelServer_Register_Port_Verify(TunnelPortVerifyCB, NULL);
if (ret != TUNNEL_ER_NoERROR) {
    printf("P2PTunnelServer_Register_Port_Verify() 注册失败，错误码: %d\n", ret);
    return -1;
} else {
    printf("P2PTunnelServer_Register_Port_Verify() 注册成功，已启用端口访问控制\n");
}

步骤1调用启动接口

// 启动P2P隧道服务器（扩展接口，支持认证和会话信息回调）
// 参数说明：
// - gUid：服务器唯一标识（设备UID，由TUTK分配或自定义，需确保全局唯一）
// - TunnelServerAuthentication：客户端认证回调函数（验证账号密码合法性）
// - TunnelSessionInfoExCB：会话信息回调函数（获取连接模式、NAT类型等）
// - args：自定义参数（传递给回调函数，如设备上下文）
int ret = P2PTunnelServer_Start_Ex(gUid, TunnelServerAuthentication, TunnelSessionInfoExCB, args);

// 处理启动结果
if (ret != TUNNEL_ER_NoERROR) {
    // 启动失败：输出错误码便于排查（错误码含义参考SDK文档）
    printf("P2PTunnelServer_Start_Ex() 启动失败，错误码: %d\n", ret);
    return -1;
} else {
    // 启动成功：设备可通过互联网接收客户端连接
    printf("P2PTunnelServer_Start_Ex() 启动成功，设备UID: %s，等待客户端连接...\n", gUid);
}

回调1、客户端账号密码认证回调

/**
 * P2P隧道服务器端认证回调函数
 * @brief 验证客户端账号合法性，并返回对应密码供SDK验证
 * @param cszAccount 客户端提供的账号（由客户端传入）
 * @param cszPassword 输出参数：填充账号对应密码的缓冲区（SDK用于校验）
 * @param nPasswordMaxLength cszPassword缓冲区的最大长度（含字符串终止符'\0'）
 * @param pArg 自定义参数（启动函数传入的args）
 */
// 预设合法账号密码（实际场景建议从配置文件或云端读取）
#define TUNNEL_USERNAME "tutk_tunnel"  // 合法账号
#define TUNNEL_PASSWORD "12345678"     // 对应密码

void TunnelServerAuthentication(
    const char *cszAccount, 
    char *cszPassword, 
    uint32_t nPasswordMaxLength, 
    const void *pArg
) {
    // 打印认证日志（生产环境建议移除明文账号，避免安全风险）
    printf("[%s] 客户端认证请求 - 账号: %s, 密码缓冲区大小: %d\n",
           __func__, cszAccount ? cszAccount : "NULL", nPasswordMaxLength);

    // 校验输入参数有效性（避免空指针异常）
    if (cszAccount == NULL || cszPassword == NULL || nPasswordMaxLength == 0) {
        printf("[%s] 无效认证参数（账号/密码缓冲区为空），拒绝连接\n", __func__);
        return;
    }

    // 验证客户端账号是否合法
    if (strcmp(cszAccount, TUNNEL_USERNAME) == 0) {
        // 账号匹配：安全填充密码（使用strncpy避免缓冲区溢出）
        if (TUNNEL_PASSWORD != NULL) {
            strncpy(cszPassword, TUNNEL_PASSWORD, nPasswordMaxLength - 1);
            cszPassword[nPasswordMaxLength - 1] = '\0';  // 强制添加字符串终止符
            printf("[%s] 账号验证通过，返回密码供SDK校验\n", __func__);
        } else {
            printf("[%s] 错误：服务器未配置密码，拒绝连接\n", __func__);
        }
    } else {
        // 账号不匹配：不填充密码，SDK会自动拒绝客户端连接
        printf("[%s] 未知账号 %s，拒绝连接\n", __func__, cszAccount);
    }
}

回调2、会话信息扩展回调

/**
 * P2P隧道会话信息扩展回调函数
 * @brief 接收并处理会话详细信息（连接模式、NAT类型、版本等）
 * @param sSessionInfo 会话信息结构体指针（包含连接核心参数）
 * @param pArg 自定义参数（启动函数传入的args，当前未使用）
 */
void TunnelSessionInfoExCB(sP2PTunnelSessionInfoEx *sSessionInfo, const void *pArg) {
    // 校验输入参数有效性（避免空指针异常）
    if (sSessionInfo == NULL) {
        printf("[%s] 警告：会话信息结构体为空\n", __func__);
        return;
    }

    // 打印会话详细信息（用于监控和排查问题）
    printf("\n[%s] 会话信息更新：\n", __func__);
    
    // 解析连接模式（核心参数，影响传输速度）
    const char* modeStr = "";
    switch (sSessionInfo->nMode) {
        case 0: modeStr = "直连模式（最优，P2P直接通信）"; break;
        case 1: modeStr = "中继模式（通过TUTK服务器转发，速度较慢）"; break;
        case 2: modeStr = "局域网模式（同一局域网内通信，速度最快）"; break;
        default: modeStr = "未知模式（建议检查网络环境）";
    }
    printf("  连接模式：%d (%s)\n", sSessionInfo->nMode, modeStr);

    // 解析NAT类型（辅助排查穿透失败问题）
    printf("  NAT类型：%d（参考SDK文档NAT类型说明）\n", sSessionInfo->nNatType);

    // 版本与会话ID（用于版本兼容性校验和会话管理）
    printf("  P2PTunnelAPIs版本：0x%X\n", (unsigned int)sSessionInfo->nVersion);
    printf("  会话ID（SID）：%d（用于后续IOTCAPIs接口调用）\n", sSessionInfo->nSID);

    // 远程客户端地址信息（仅中继/局域网模式有效）
    printf("  远程设备地址：%s:%d\n", 
           sSessionInfo->szRemoteIP ? sSessionInfo->szRemoteIP : "未知IP", 
           sSessionInfo->nRemotePort);
}

步骤1启动上层TCP/IP服务

• SSH服务：启动 openssh-server（默认端口22）；
• HTTP服务：启动 Nginx/Apache（默认端口80）；
• RTSP服务：启动流媒体服务器（默认端口554）；
• 其他私有TCP服务：按原有逻辑启动，确保端口与隧道配置一致。

步骤1停止隧道服务并释放资源

// 停止P2PTunnel Server（断开所有客户端连接）
P2PTunnelServer_Stop();

// 释放隧道服务器资源（反初始化）
P2PTunnelServerDeInitialize();

步骤1定期监控IOTC登录状态

/**
 * 监控IOTC登录状态并处理异常
 * @brief 定期检查登录状态，当重试失败次数过多时执行恢复操作
 */
// 全局变量：控制进程运行状态
bool gProcessRun = true;

// 检查是否有用户正在访问（自定义实现，如统计当前连接数）
bool checkNoUserAccess() {
    // 示例逻辑：获取当前隧道连接数，0表示无用户访问
    int currentConn = P2PTunnelServer_Get_Connection_Count();  // 假设该接口获取连接数
    return (currentConn == 0);
}

// 检查网络是否畅通（自定义实现，如ping网关或TUTK服务器）
bool checkNetworkAvailability() {
    // 示例逻辑：ping TUTK服务器地址，成功返回true
    return system("ping -c 1 tutk-server-address > /dev/null 2>&1") == 0;
}

void monitorLoginState() {
    unsigned int login_state;  // 登录状态码（7表示正常登录并收到服务器响应）

    while (gProcessRun) {
        // 获取登录信息：返回值为重试登录失败次数，输出参数为当前登录状态
        int ret = IOTC_Get_Login_Info(&login_state);
        printf("IOTC_Get_Login_Info() - 重试失败次数: %d, 登录状态: %u\n", ret, login_state);

        // 处理接口调用错误（如SDK未初始化）
        if (ret < IOTC_ER_NoERROR) {
            printf("IOTC_Get_Login_Info() 调用失败，错误码: %d，退出监控循环\n", ret);
            break;
        }

        // 解析登录状态
        if (login_state == 7) {
            printf("登录状态正常：设备已成功注册到P2P服务器\n");
        } else {
            printf("登录状态异常：状态码=%u（非7表示未正常注册，需检查网络/密钥）\n", login_state);
        }

        // 处理长时间失联情况（ret>4表示连续5次重试失败，与服务器失联）
        if (ret > 4) {
            printf("警告：已连续%d次登录重试失败，设备与P2P服务器失联\n", ret);
            
            // 检查是否满足恢复条件：无用户访问 + 网络畅通
            bool noUserAccess = checkNoUserAccess();
            bool networkAvailable = checkNetworkAvailability();
            
            if (noUserAccess && networkAvailable) {
                printf("满足恢复条件（无用户访问且网络正常），执行P2P模块重启\n");
                
                // 1. 停止隧道服务
                P2PTunnelServer_Stop();
                // 2. 反初始化隧道
                P2PTunnelServerDeInitialize();
                // 3. 重新初始化并启动（复用之前的初始化流程）
                reInitAndStartTunnelServer();  // 自定义重启函数
                // 4. 其他清理操作（如重置连接计数）
            } else {
                printf("不满足恢复条件 - 有用户访问: %s, 网络畅通: %s\n",
                       noUserAccess ? "否" : "是",
                       networkAvailable ? "是" : "否");
            }
        }

        // 休眠5秒后再次检测（分5次1秒休眠，提升退出响应速度）
        for (int sleep_count = 0; sleep_count < 5 && gProcessRun; sleep_count++) {
            sleep(1);
        }
    }
}