【安全函数】C11 安全格式化函数解析：sprintf_s 与 snprintf_s 的设计、用法与兼容性

#if defined(__STDC_WANT_LIB_EXT1__) && __STDC_WANT_LIB_EXT1__ >= 1
    // 支持C11 Annex K，使用sprintf_s/snprintf_s
#else
    // 不支持，降级使用snprintf或自定义安全函数
#endif

int sprintf_s(char *restrict dest, rsize_t destsz, const char *restrict format, ...);

int sprintf_s(char *dest, size_t destsz, const char *format, ...);

int snprintf_s(char *restrict dest, rsize_t destsz, rsize_t maxlen, const char *restrict format, ...);

int snprintf_s(char *dest, size_t destsz, const char *format, ...);

#include <stdarg.h>
#include <stddef.h>
#include <errno.h>

// 定义C11标准的最大合法缓冲区大小（示例值）
#define RSIZE_MAX (SIZE_MAX / 2)

// 无效参数处理（默认触发abort，可自定义）
static void invalid_parameter_handler(const char *expr, const char *file, int line, const char *func) {
    fprintf(stderr, "无效参数：%s（文件：%s，行：%d，函数：%s）\n", expr, file, line, func);
    abort(); // 终止程序，避免安全风险扩散
}

int sprintf_s(char *restrict dest, rsize_t destsz, const char *restrict format, ...) {
    // 阶段1：参数合法性校验（C11 Annex K强制要求）
    // 1.1 检查dest是否为NULL，destsz是否合法（0 < destsz <= RSIZE_MAX）
    if (dest == NULL || destsz == 0 || destsz > RSIZE_MAX) {
        errno = EINVAL;
        invalid_parameter_handler("dest is NULL or destsz invalid", __FILE__, __LINE__, __func__);
        return -1; // 仅为兼容，实际可能已abort
    }
    // 1.2 检查format是否为NULL
    if (format == NULL) {
        errno = EINVAL;
        invalid_parameter_handler("format is NULL", __FILE__, __LINE__, __func__);
        return -1;
    }

    // 阶段2：初始化可变参数与缓冲区指针
    va_list args;
    va_start(args, format);
    char *dest_ptr = dest;
    const char *fmt_ptr = format;
    int written = 0; // 已写入字符数（不含'\0'）
    const rsize_t max_write = destsz - 1; // 留1字节存'\0'

    // 阶段3：格式解析与参数处理（新增格式符校验）
    while (*fmt_ptr != '\0') {
        if (*fmt_ptr != '%') {
            // 处理普通字符：检查是否超出缓冲区
            if (written >= max_write) {
                errno = ERANGE;
                va_end(args);
                return -1; // 缓冲区不足，返回错误
            }
            *dest_ptr++ = *fmt_ptr++;
            written++;
            continue;
        }

        // 处理格式说明符：先检查是否为禁止的格式符（如%n）
        fmt_ptr++;
        if (*fmt_ptr == 'n') {
            // C11默认禁止%n（可能篡改内存），需显式开启才允许
            errno = EINVAL;
            invalid_parameter_handler("format contains forbidden '%n'", __FILE__, __LINE__, __func__);
            va_end(args);
            return -1;
        }

        // 提取格式符（简化处理，实际需支持宽度、精度等）
        char spec = *fmt_ptr;
        fmt_ptr++;

        // 阶段4：参数类型匹配检查（_s版本核心增强）
        char temp_buf[64];
        int temp_len = 0;
        switch (spec) {
            case 'd': {
                // 检查参数是否为int类型（实际实现需通过类型信息校验）
                if (!va_arg_type_check(args, int)) { // 伪函数：校验参数类型
                    errno = EINVAL;
                    invalid_parameter_handler("format '%d' mismatch with argument type", __FILE__, __LINE__, __func__);
                    va_end(args);
                    return -1;
                }
                int num = va_arg(args, int);
                temp_len = itoa_simple(num, temp_buf); // 复用之前的整数转字符串函数
                break;
            }
            case 's': {
                if (!va_arg_type_check(args, const char*)) {
                    errno = EINVAL;
                    invalid_parameter_handler("format '%s' mismatch with argument type", __FILE__, __LINE__, __func__);
                    va_end(args);
                    return -1;
                }
                const char *str = va_arg(args, const char*);
                if (str == NULL) {
                    // _s版本通常禁止NULL字符串，避免访问非法内存
                    errno = EINVAL;
                    invalid_parameter_handler("argument for '%s' is NULL", __FILE__, __LINE__, __func__);
                    va_end(args);
                    return -1;
                }
                temp_len = strlen(str);
                strncpy(temp_buf, str, temp_len);
                break;
            }
            // 其他格式符（如%f、%x）处理逻辑类似，均需类型校验
            default: {
                errno = EINVAL;
                invalid_parameter_handler("unknown format specifier", __FILE__, __LINE__, __func__);
                va_end(args);
                return -1;
            }
        }

        // 阶段5：写入临时内容，检查缓冲区是否充足
        if (written + temp_len > max_write) {
            errno = ERANGE;
            va_end(args);
            return -1;
        }
        memcpy(dest_ptr, temp_buf, temp_len);
        dest_ptr += temp_len;
        written += temp_len;
    }

    // 阶段6：添加字符串结束符，释放参数列表
    *dest_ptr = '\0';
    va_end(args);
    return written; // 成功返回写入字符数
}

int snprintf_s(char *restrict dest, rsize_t destsz, rsize_t maxlen, const char *restrict format, ...) {
    // 阶段1：参数校验（新增maxlen合法性检查）
    if (dest == NULL || destsz == 0 || destsz > RSIZE_MAX) {
        errno = EINVAL;
        invalid_parameter_handler("dest or destsz invalid", __FILE__, __LINE__, __func__);
        return -1;
    }
    if (format == NULL) {
        errno = EINVAL;
        invalid_parameter_handler("format is NULL", __FILE__, __LINE__, __func__);
        return -1;
    }
    // 关键：maxlen不能超过destsz-1（否则缓冲区不足）
    if (maxlen > destsz - 1) {
        errno = EINVAL;
        invalid_parameter_handler("maxlen exceeds destsz-1", __FILE__, __LINE__, __func__);
        return -1;
    }

    va_list args;
    va_start(args, format);
    char *dest_ptr = dest;
    const char *fmt_ptr = format;
    int written = 0;
    int required = 0; // 总需写入字符数（用于截断判断）

    while (*fmt_ptr != '\0') {
        // 计算总需长度（无论是否写入）
        if (*fmt_ptr != '%') {
            required++;
            // 写入逻辑：仅当未超maxlen时写入
            if (written < maxlen) {
                *dest_ptr++ = *fmt_ptr;
                written++;
            }
            fmt_ptr++;
            continue;
        }

        // 格式符处理（同sprintf_s，含类型校验、禁止%n）
        fmt_ptr++;
        if (*fmt_ptr == 'n') { /* 禁止%n，处理错误 */ }
        char spec = *fmt_ptr++;
        char temp_buf[64];
        int temp_len = 0;

        // （省略格式符与参数匹配逻辑，同sprintf_s）
        switch (spec) { /* 提取参数并转换，计算temp_len */ }

        // 更新总需长度
        required += temp_len;

        // 写入逻辑：控制在maxlen内
        if (written + temp_len <= maxlen) {
            memcpy(dest_ptr, temp_buf, temp_len);
            dest_ptr += temp_len;
            written += temp_len;
        } else if (written < maxlen) {
            // 截断写入剩余空间
            size_t remaining = maxlen - written;
            memcpy(dest_ptr, temp_buf, remaining);
            dest_ptr += remaining;
            written += remaining;
        }
    }

    // 确保写入结束符
    *dest_ptr = '\0';
    va_end(args);

    // 阶段2：返回值逻辑（C11标准）
    if (required <= maxlen) {
        return written; // 无截断，返回实际写入数
    } else {
        return required; // 截断，返回总需长度
    }
}

#define LOG_LEN 128
char trade_log[LOG_LEN];
int trade_id = 1001;
double amount = 599.99;
// 使用sprintf_s，强制校验参数与缓冲区
if (sprintf_s(trade_log, LOG_LEN, "交易ID：%d，金额：%.2f", trade_id, amount) < 0) {
    fprintf(stderr, "日志格式化失败：%s\n", strerror(errno));
    // 处理错误（如回滚交易）
}

#define COMMENT_LEN 64
char comment_show[COMMENT_LEN];
const char *username = "user123";
const char *comment = "这是一条很长的用户评论，超过64字节需要截断";
// 使用snprintf_s，控制最大写入长度，允许截断
int required = snprintf_s(comment_show, COMMENT_LEN, COMMENT_LEN-1, "用户%s评论：%s", username, comment);
if (required < 0) {
    fprintf(stderr, "评论格式化失败：%s\n", strerror(errno));
} else if (required >= COMMENT_LEN-1) {
    // 截断时补充省略号（确保缓冲区充足）
    comment_show[COMMENT_LEN-4] = '.';
    comment_show[COMMENT_LEN-3] = '.';
    comment_show[COMMENT_LEN-2] = '.';
    comment_show[COMMENT_LEN-1] = '\0';
}

// 适配MSVC与GCC的snprintf_s调用
#ifdef _MSC_VER
    // MSVC：无maxlen，destsz直接作为最大限制
    #define safe_snprintf(dest, destsz, format, ...) snprintf_s(dest, destsz, format, __VA_ARGS__)
#else
    // GCC：需显式传入maxlen=destsz-1
    #define safe_snprintf(dest, destsz, format, ...) snprintf_s(dest, destsz, destsz-1, format, __VA_ARGS__)
#endif

// 使用兼容宏
char buf[32];
int ret = safe_snprintf(buf, sizeof(buf), "数值：%d", 123);
if (ret < 0) {
    // 统一错误处理
}

#include <crtdbg.h> // MSVC专用头文件

// 自定义无效参数处理函数
void my_invalid_parameter_handler(const wchar_t *expr, const wchar_t *file, unsigned int line, const wchar_t *func, unsigned int subcode) {
    wprintf(L"参数错误：%s（文件：%s，行：%d）\n", expr, file, line);
    // 记录错误日志后，选择优雅退出而非abort
    exit(EXIT_FAILURE);
}

int main() {
    // 设置自定义处理程序（MSVC专用）
    _set_invalid_parameter_handler(my_invalid_parameter_handler);
    // 禁用快速失败模式（避免直接abort）
    _CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF);

    char buf[10];
    // 故意传入NULL format，触发自定义处理
    sprintf_s(buf, sizeof(buf), NULL, 123);
    return 0;
}

#define __STDC_WANT_LIB_EXT1__ 1
#include <stdio.h>

int main() {
    #if defined(__STDC_LIB_EXT1__) && __STDC_LIB_EXT1__ >= 1
        char buf[32];
        int n;
        // 启用后可使用%n
        sprintf_s(buf, sizeof(buf), "写入%n个字符", &n);
        printf("实际写入：%d个字符\n", n); // 输出“实际写入：6个字符”
    #else
        printf("编译器不支持启用%n\n");
    #endif
    return 0;
}

#define __STDC_WANT_LIB_EXT1__ 1 // 开启GCC的Annex K支持
#include <stdio.h>
#include <errno.h>
#include <string.h>

// 编译器兼容宏（适配MSVC/GCC）
#ifdef _MSC_VER
    #define SAFE_SPRINTF(dest, destsz, fmt, ...) sprintf_s(dest, destsz, fmt, __VA_ARGS__)
    #define SAFE_SNPRINTF(dest, destsz, fmt, ...) snprintf_s(dest, destsz, fmt, __VA_ARGS__)
#else
    #define SAFE_SPRINTF(dest, destsz, fmt, ...) sprintf_s(dest, destsz, fmt, __VA_ARGS__)
    #define SAFE_SNPRINTF(dest, destsz, fmt, ...) snprintf_s(dest, destsz, destsz-1, fmt, __VA_ARGS__)
#endif

int main() {
    // 1. sprintf_s：固定长度，禁止截断
    char fixed_buf[64];
    int id = 5;
    const char *name = "设备A";
    // 格式化设备信息（长度固定，无溢出风险）
    int ret1 = SAFE_SPRINTF(fixed_buf, sizeof(fixed_buf), "设备ID：%d，名称：%s", id, name);
    if (ret1 < 0) {
        fprintf(stderr, "sprintf_s失败：%s\n", strerror(errno));
        return -1;
    }
    printf("sprintf_s结果：%s（写入%d字符）\n", fixed_buf, ret1);

    // 2. snprintf_s：动态长度，允许截断
    char dynamic_buf[32];
    const char *long_str = "这是一条超过32字节的长字符串，用于测试截断";
    // 格式化长字符串，允许截断
    int ret2 = SAFE_SNPRINTF(dynamic_buf, sizeof(dynamic_buf), "描述：%s", long_str);
    if (ret2 < 0) {
        fprintf(stderr, "snprintf_s失败：%s\n", strerror(errno));
        return -1;
    } else if (ret2 >= sizeof(dynamic_buf)-1) {
        // 处理截断：末尾添加省略号
        dynamic_buf[sizeof(dynamic_buf)-4] = '.';
        dynamic_buf[sizeof(dynamic_buf)-3] = '.';
        dynamic_buf[sizeof(dynamic_buf)-2] = '.';
        dynamic_buf[sizeof(dynamic_buf)-1] = '\0';
        printf("snprintf_s结果（截断）：%s（需%d字节，实际%d字节）\n", 
               dynamic_buf, ret2, sizeof(dynamic_buf)-1);
    } else {
        printf("snprintf_s结果（无截断）：%s\n", dynamic_buf);
    }

    return 0;
}

#define __STDC_WANT_LIB_EXT1__ 1
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>

#ifdef _MSC_VER
    #define SAFE_SNPRINTF(dest, destsz, fmt, ...) snprintf_s(dest, destsz, fmt, __VA_ARGS__)
#else
    #define SAFE_SNPRINTF(dest, destsz, fmt, ...) snprintf_s(dest, destsz, destsz-1, fmt, __VA_ARGS__)
#endif

// 动态分配缓冲区并安全格式化
char* dynamic_safe_format(const char *format, ...) {
    va_list args;
    va_start(args, format);

    // 步骤1：计算所需缓冲区长度（dest为NULL，destsz为0）
    int required = SAFE_SNPRINTF(NULL, 0, format, args); // 注意：MSVC不支持dest=NULL，需单独处理
    va_end(args);

    // 处理MSVC的dest=NULL问题（MSVC的snprintf_s不支持NULL dest）
    #ifdef _MSC_VER
        char temp[1024]; // 临时缓冲区估算长度
        required = SAFE_SNPRINTF(temp, sizeof(temp), format, args);
        if (required >= sizeof(temp)-1) {
            // 临时缓冲区不足，改用传统snprintf计算长度
            va_start(args, format);
            required = vsnprintf(NULL, 0, format, args);
            va_end(args);
        }
    #endif

    if (required < 0) {
        fprintf(stderr, "计算长度失败：%s\n", strerror(errno));
        return NULL;
    }

    // 步骤2：动态分配缓冲区（+1存'\0'）
    char *buf = (char*)malloc(required + 1);
    if (buf == NULL) {
        fprintf(stderr, "内存分配失败\n");
        return NULL;
    }

    // 步骤3：安全格式化
    va_start(args, format);
    int ret = SAFE_SNPRINTF(buf, required + 1, format, args);
    va_end(args);

    if (ret < 0 || ret != required) {
        fprintf(stderr, "格式化失败：%s\n", strerror(errno));
        free(buf);
        return NULL;
    }

    return buf;
}

int main() {
    const char *title = "C11安全函数";
    int version = 1;
    // 动态格式化长字符串
    char *result = dynamic_safe_format("标题：%s，版本：%d，描述：%s", 
                                      title, version, "用于高安全需求的字符串格式化");
    if (result != NULL) {
        printf("动态格式化结果：%s\n", result);
        free(result);
    }
    return 0;
}

#define __STDC_WANT_LIB_EXT1__ 1
#include <stdio.h>
#include <errno.h>

int main() {
    // 错误1：destsz为0（触发参数错误）
    char buf1[10];
    int ret1 = sprintf_s(buf1, 0, "测试：%d", 123);
    printf("错误1返回值：%d（预期：-1，errno：%s）\n", ret1, strerror(errno));

    // 错误2：format为NULL（触发参数错误）
    char buf2[10];
    errno = 0; // 重置errno
    int ret2 = sprintf_s(buf2, sizeof(buf2), NULL, 123);
    printf("错误2返回值：%d（预期：-1，errno：%s）\n", ret2, strerror(errno));

    // 错误3：%s参数为NULL（MSVC下abort，GCC下返回错误）
    char buf3[10];
    errno = 0;
    int ret3 = sprintf_s(buf3, sizeof(buf3), "字符串：%s", NULL);
    printf("错误3返回值：%d（预期：-1，errno：%s）\n", ret3, strerror(errno));

    return 0;
}

// 1. 开启GCC的Annex K支持（必须定义在#include <stdio.h>前）
#define __STDC_WANT_LIB_EXT1__ 1
#include <stdio.h>
#include <errno.h>
#include <string.h>

// 2. 编译器兼容宏：适配MSVC（无maxlen）与GCC（有maxlen）
#ifdef _MSC_VER
    // MSVC：snprintf_s(dest, destsz, format, ...)
    #define SAFE_SNPRINTF(dest, destsz, fmt, ...) \
        do { \
            int ret = snprintf_s(dest, destsz, fmt, __VA_ARGS__); \
            if (ret < 0) { \
                fprintf(stderr, "snprintf_s失败（MSVC）：%s\n", strerror(errno)); \
                return -1; \
            } \
        } while(0)
#else
    // GCC：snprintf_s(dest, destsz, maxlen, format, ...)，maxlen=destsz-1
    #define SAFE_SNPRINTF(dest, destsz, fmt, ...) \
        do { \
            if (dest == NULL || destsz == 0 || destsz > RSIZE_MAX) { \
                fprintf(stderr, "snprintf_s参数错误（GCC）\n"); \
                return -1; \
            } \
            int maxlen = destsz - 1; \
            int ret = snprintf_s(dest, destsz, maxlen, fmt, __VA_ARGS__); \
            if (ret < 0) { \
                fprintf(stderr, "snprintf_s失败（GCC）：%s\n", strerror(errno)); \
                return -1; \
            } else if (ret > maxlen) { \
                fprintf(stderr, "snprintf_s截断（GCC）：需%d字节，实际%d字节\n", ret, maxlen); \
            } \
        } while(0)
#endif

// 3. 实际使用示例
int main() {
    char buf[32];
    const char *data = "GCC 10 snprintf_s测试";
    int num = 2022;

    // 调用兼容宏格式化
    SAFE_SNPRINTF(buf, sizeof(buf), "数据：%s，编号：%d", data, num);
    printf("格式化结果：%s\n", buf);

    return 0;
}

#include <stdio.h>
#include <errno.h>
#include <stddef.h>

// 定义最大合法缓冲区大小（适配RSIZE_MAX）
#ifndef RSIZE_MAX
    #define RSIZE_MAX (SIZE_MAX / 2)
#endif

// 兼容接口：统一snprintf与snprintf_s的调用
int safe_format(char *dest, size_t destsz, const char *format, ...) {
    va_list args;
    va_start(args, format);
    int ret = -1;

    // 步骤1：基础参数校验（两种函数通用）
    if (dest == NULL || destsz == 0 || destsz > RSIZE_MAX || format == NULL) {
        errno = EINVAL;
        va_end(args);
        return -1;
    }

    // 步骤2：判断是否支持snprintf_s
    #if defined(__STDC_WANT_LIB_EXT1__) && __STDC_WANT_LIB_EXT1__ >= 1 && defined(__STDC_LIB_EXT1__)
        // 支持snprintf_s（C11标准）
        size_t maxlen = destsz - 1;
        ret = vsnprintf_s(dest, destsz, maxlen, format, args); // 用vsnprintf_s处理可变参数
        // 处理GCC与MSVC的返回值差异
        #ifdef _MSC_VER
            if (ret < 0) {
                errno = EINVAL; // MSVC返回-1表示错误
            } else if (ret > maxlen) {
                // MSVC不返回总需长度，需用vsnprintf重新计算
                va_list args2;
                va_copy(args2, args);
                ret = vsnprintf(NULL, 0, format, args2);
                va_end(args2);
            }
        #endif
    #else
        // 不支持snprintf_s，降级为snprintf+手动校验
        ret = vsnprintf(dest, destsz, format, args);
        // 额外校验格式符与参数匹配（简化版，实际需工具辅助）
        if (ret < 0) {
            errno = EINVAL;
        }
    #endif

    va_end(args);
    return ret;
}

// 使用示例
int main() {
    char buf[32];
    int num = 100;
    const char *str = "兼容接口测试";

    int ret = safe_format(buf, sizeof(buf), "数值：%d，字符串：%s", num, str);
    if (ret < 0) {
        fprintf(stderr, "格式化失败：%s\n", strerror(errno));
    } else if (ret >= sizeof(buf)-1) {
        fprintf(stderr, "格式化截断：需%d字节，实际%d字节\n", ret, (int)sizeof(buf)-1);
    } else {
        printf("格式化成功：%s\n", buf);
    }

    return 0;
}