编程 on 星分

c拓展语法学习

Fri, 26 Jun 2026 08:04:20 +0000

pragma

　　#pragma是 C 语言的一种预处理指令，类似于#include。用于告诉编译器进行某种操作。pragma 单词本身的释义为“编译指令”。

　　最简单的一种 pragma 可以在编译时输出文本提示。

#pragma message(">>> Compiling ...")

int main(void) {
    return 0;
}

　　编译上面的 C 文件结果输出如下。

❯ gcc pragma.c
pragma.c:1:9: warning: >>> Compiling ... [-W#pragma-messages]
    1 | #pragma message(">>> Compiling ...")
      |         ^
1 warning generated.

_Pragma

　　由于宏定义之间不能嵌套，当某种 pragma 想要复用时，无法通过#define复用，此时可以通过_Pragma指令，如下所示。

#define MSG _Pragma("message(\">>> Compiling ...\")")

MSG

_Pragma("message(\">>> Compiling ...\")")

int main(void) {
    return 0;
}

　　编译后输出如下提示信息。其中的 note 消息可以忽略，关注warning: >>> Compiling ... [-W#pragma-messages]段即可。

❯ gcc pragma.c
pragma.c:3:1: warning: >>> Compiling ... [-W#pragma-messages]
    3 | MSG
      | ^
pragma.c:1:13: note: expanded from macro 'MSG'
    1 | #define MSG _Pragma("message(\">>> Compiling ...\")")
      |             ^
<scratch space>:4:2: note: expanded from here
    4 |  message(">>> Compiling ...")
      |  ^
pragma.c:5:1: warning: >>> Compiling ... [-W#pragma-messages]
    5 | _Pragma("message(\">>> Compiling ...\")")
      | ^
<scratch space>:6:2: note: expanded from here
    6 |  message(">>> Compiling ...")
      |  ^
2 warnings generated.

　　根据上面的编译输出结果，我们可以知道，如下两种编译指令是近似等价的。但是_Pragma语法本身可以放在#define中复用。

1
2

#pragma message(">>> Compiling ...")
_Pragma("message(\">>> Compiling ...\")")

pragma 指令功能表

指令	功能
clang diagnostic push	保存当前的诊断设置（哪些警告开、哪些关）到内部栈
clang diagnostic ignored “-Wexcessive-regsave”	告知编译器对接下来遇到的 -Wexcessive-regsave 警告保持沉默
clang diagnostic pop	从栈中恢复诊断设置，这样后面的代码不受影响

-Wexcessive-regsave: 这是一个在某些架构上（尤其是 ARM64）编译器生成代码时可能触发的警告：函数太复杂，编译器需要把大量寄存器保存/恢复到栈上，影响性能。通常在非常大的内联函数或深层嵌套调用时出现。

attribute

　　__attribute__ 是 GCC（GNU Compiler Collection） 提供的一种语言扩展，用于在 C/C++ 代码中指定函数、变量、类型的特殊属性（attributes），从而告诉编译器对这些实体进行特定的优化、检查或行为控制。它也被 Clang 等兼容 GCC 的编译器支持。其基本语法如下

`1`	`__attribute__((attribute-list))`

可放在声明末尾，或紧跟在标识符之后。
多个属性用逗号分隔，例如 __attribute__((aligned(8), packed))

常见属性表

函数属性

属性	说明
`noreturn`	函数永不返回（如 `exit`、`abort`），帮助消除 unreachable-code 警告
`format(archetype, string-index, first-to-check)`	声明类 printf/scanf 函数的格式串检查，例如 `format(printf, 1, 2)`
`nonnull(arg-index, ...)`	声明指针参数不可为 NULL
`const`	纯函数 - 只依赖参数值，不读全局内存，无副作用（比 `pure` 更强）
`pure`	函数无副作用，返回值仅依赖参数和全局内存（可被 CSE 优化，但调用次数不可消）
`malloc`	返回新分配的内存指针，且该指针不会与任何已有指针别名
`warn_unused_result`	调用者忽略返回值时发出警告
`used`	即使未引用也保留函数代码（防止被链接器丢弃）
`unused`	抑制"未使用函数"警告
`weak`	弱符号 - 可被同名强符号覆盖，用于提供默认实现
`constructor`	在 `main()` 之前自动执行（可带优先级参数）
`destructor`	在 `main()` 返回后或 `exit()` 时自动执行
`noinline`	禁止内联此函数
`always_inline`	强制内联（即使优化级别不支持）
`flatten`	将此函数内的每个调用都视为 `always_inline`
`hot`	标记为热点路径，优化分支预测和指令布局
`cold`	标记为冷路径，优化代码体积而非速度
`no_sanitize("sanitizer-name")`	对此函数禁用指定 sanitizer（如 address、thread）
`interrupt` / `interrupt_handler`	声明中断处理函数（自动保存/恢复寄存器，使用特殊返回指令）
`sentinel`	参数列表必须以 NULL 结尾（如 `execl`）
`alloc_size(pos)` / `alloc_size(pos1, pos2)`	标明第几个参数控制分配大小，辅助优化和安全检查
`returns_nonnull`	函数保证返回非 NULL 指针
`leaf`	函数不会回调当前编译单元内的任何函数
`nothrow`	函数保证不抛出 C++ 异常
`target("feature")`	为特定 CPU 特性编译此函数（如 `target("avx2")`）

类型属性

属性	说明
`aligned(N)`	指定类型或变量的对齐字节数（N 为 2 的幂）
`packed`	紧凑布局 - 移除成员间的填充字节
`deprecated` / `deprecated("message")`	标记为已弃用，使用时产生警告
`unavailable`	标记为不可用，使用时产生错误
`visibility("type")`	符号可见性：`default`、`hidden`、`internal`、`protected`
`mode(TI/QI/HI/SI/DI)`	指定整数类型的宽度（如 `__attribute__((mode(DI)))`）
`may_alias`	声明此类型可能与其他类型别名，抑制严格别名优化
`transparent_union`	透明联合体 - 传参时各成员类型可隐含转换
`designated_init`	只能通过指定初始化器初始化（可用于 union）
`objc_root_class`	标记 Objective-C 根类

变量属性

属性	说明
`section("name")`	将变量放入指定段（如 `.init_array`、`.bss.my_section`）
`used`	即使未引用也保留变量
`unused`	抑制"未使用变量"警告
`aligned(N)`	指定对齐（同类型属性，直接作用于变量）
`packed`	去除结构体成员对齐填充（作用于变量声明时）
`cleanup(function)`	变量离开作用域时自动调用给定函数（类似 C++ RAII）
`weak`	弱符号 - 可被同名强符号覆盖
`tls_model("model")`	指定 TLS 模型：`global-dynamic`、`local-dynamic`、`initial-exec`、`local-exec`
`noinit`	变量不初始化为零（用于保持复位后的数据）

用法示例

typedef struct {
        acpi_sdt_header_t header;
        uint32_t          PointerToOtherSDT;
} __attribute__((packed)) rsdt_t;

__attribute__((noinline)) void compiler_barrier(void)
{ __asm__ volatile("" ::: "memory"); }

volatile float __x __attribute__((unused));

aligned(N) 做了两件事：

效果	说明
起始地址	变量/结构体地址满足 addr % N == 0
sizeof 补整	末尾补 padding 使 sizeof % N == 0

volatile 关键字

　　volatile 是 C 语言的一个类型修饰符，用于告诉编译器：该变量的值可能在程序控制流之外被意外修改，因此编译器不能对该变量的访问进行某些优化（如缓存到寄存器、消除冗余读取等）。

　　__asm__和volatile可以一起使用，如下。

`1`	`__asm__ volatile("inw %1, %0" : "=a"(ret) : "dN"(port));`

编译器必须：

保留这段汇编，即使输出没用
每次都生成，不能合并
保持原位，不和其它 volatile asm 重排

ZIP 文件结构与解析流程核心笔记

Fri, 24 Apr 2026 02:10:00 +0800

ZIP 文件结构与解析流程核心笔记

ZIP文件基础结构图示

具体的结构和解析流程在后面会有详细介绍。

ZIP文件主要由三部分构成:

Local File Header: 每个压缩文件的起始位置，包含文件的元数据信息；
Central Directory(CD): 压缩文件的目录，记录了所有文件的元数据信息；
End of Central Directory(EOCDR): 压缩文件的结束位置，包含目录的元数据信息。

只考虑非分卷压缩的情况，EOCDR中包含指向Central Directory的偏移量，Central Directory的大小，以及CD条目的项数。

中央目录区包含了所有文件的元数据信息，每个文件的元数据信息由一个Central Directory Entry(CD Entry)表示。每个CD项中含有指向对应Local File Header的偏移量。

本地文件头区包含了每个压缩文件的元数据信息，每个文件的元数据信息由一个Local File Header(LFH)表示。文件的实际数据(压缩或未压缩)紧跟在其对应的LFH后面。

ZIP文件解析流程

本地文件头区已经包含了每个压缩文件的元数据信息，理论上仅通过读取LFH就能解压出压缩包内的所有文件，因此在解析ZIP文件时就产生了两种解析方式。

标准解析模式: 先读取整个Central Directory，然后根据CD项中的偏移量，随机访问到对应文件的LFH，从而获取文件的元数据信息。
流式解析模式: 从Local File Header开始，顺序解析每个压缩文件的元数据信息，直到无法读取有效的LFH签名为止。

目前大多数ZIP解析器默认采用标准解析模式，忽略掉没有被CD条目指向的LFH。

标准解析模式

从EOCDR中获取指向Central Directory的偏移量，然后根据CD项中的偏移量，随机访问到对应文件的LFH，从而获取文件的元数据信息。

sequenceDiagram
    participant Parser as 解析器
    participant File as ZIP文件
    participant LFH as 本地文件头
    participant CD as 中央目录
    participant EOCDR as 中央目录结束记录

    Parser->>File: 从文件末尾查找EOCDR签名
    File-->>Parser: 返回EOCDR位置
    Parser->>EOCDR: 读取EOCDR内容
    EOCDR-->>Parser: 返回EOCDR数据
    Parser->>Parser: 提取Central Directory偏移量
    Parser->>File: 跳转到Central Directory位置
    loop 读取所有CD项
        Parser->>CD: 读取一个CentralDirectoryHeader
        CD-->>Parser: 返回CD项数据
        Parser->>Parser: 保存CD项
    end
    loop 根据CD项读取所有LFH
        Parser->>CD: 从CD项获取Local File Header偏移量
        CD-->>Parser: 返回偏移量
        Parser->>File: 跳转到对应的Local File Header位置
        Parser->>LFH: 读取LocalFileHeader
        LFH-->>Parser: 返回LFH数据
        Parser->>Parser: 保存LFH
    end

流式解析模式

从Local File Header开始，顺序解析每个压缩文件的元数据信息，直到无法读取有效的LFH签名为止。

sequenceDiagram
    participant Parser as 解析器
    participant File as ZIP文件
    participant LFH as 本地文件头

    Parser->>File: 将文件指针定位到文件开头
    loop 顺序读取Local File Header
        Parser->>LFH: 尝试读取LocalFileHeader
        alt 成功读取LFH签名
            LFH-->>Parser: 返回LocalFileHeader数据
            Parser->>Parser: 保存LFH
            Parser->>File: 继续读取下一个LFH
        else 未找到有效的LFH签名或读取失败
            File-->>Parser: 返回读取失败
            Parser->>Parser: 停止解析
        end
    end

手工篡改ZIP进行实验

zip_analyze目录为一个Zip解析器实例，可以使用两种解析模式读取未加密的Zip文件结构。另外该目录下包含两个Zip文件，分别为zip_demo.zip和zip_demo_hacked.zip。两者的区别在于zip_demo_hacked.zip在zip_demo.zip的基础上，在LFH区添加了一个额外的文件hacked.txt对应的LFH及其数据。具体如下图所示：

使用zip_analyze解析zip_demo_hacked.zip文件，在标准解析模式下，zip_analyze忽略掉了仅在LFH中存在的hacked.txt文件；而在流式解析模式下，zip_analyze能够成功解析出hacked.txt文件的信息。

Zip文件具体分析

根据官方文档, Zip文件的结构如下:

[local file header 1]
[encryption header 1]
[file data 1]
[data descriptor 1]
.
.
.
[local file header n]
[encryption header n]
[file data n]
[data descriptor n]
[archive decryption header]
[archive extra data record]
[central directory header 1]
.
.
.
[central directory header n]
[zip64 end of central directory record]
[zip64 end of central directory locator]
[end of central directory record]

本地文件头 - Local File Header

    uint32_t signature;
    uint16_t version_needed;
    uint16_t general_bit_flag;
    uint16_t compression_method;
    uint16_t last_mod_time;
    uint16_t last_mod_date;
    uint32_t crc32;
    uint32_t compressed_size;
    uint32_t uncompressed_size;
    uint16_t filename_length;
    uint16_t extra_field_length;
    std::string filename;
    std::unique_ptr<uint8_t[]> extra_field;

本地文件头的extra_field没有固定的内容，不同的压缩器可能会在extra_field中添加不同的信息。但是在extra_field中添加信息时通常要遵循统一的结构: 标签 - 长度 - 数据。

Tag（2 字节）：标识该扩展块的类型（如操作系统相关信息、压缩算法扩展等）。
Length（2 字节）：表示后续数据的长度。
Data：具体的扩展数据，格式由 Tag 定义。

具体标签值和含义的映射可以参考官方文档的4.5.2节，其中列举了由PKWARE定义的标签值和含义。

general_bit_flag

加密头 - Encryption Header

是否存在: 仅当general_bit_flag的第0位为1时，才存在加密头。

加密头的具体长度与结构由general_bit_flag的第6位确定：

当第六位为0时，加密头格式为传统PKWARE加密格式，长度为12字节；
当第六位为1时，加密头格式强加密格式，长度为可变，至少30字节。

IVSize    2 bytes  - 初始化向量大小
IVData    IVSize   - 初始化向量数据
Size      4 bytes  - 剩余解密头数据大小
Format    2 bytes  - 格式定义 (当前必须为3)
AlgID     2 bytes  - 加密算法标识符
Bitlen    2 bytes  - 密钥长度 (32-448 bits)
Flags     2 bytes  - 处理标志
ErdSize   2 bytes  - 加密随机数据大小
ErdData   ErdSize  - 加密的随机数据
Reserved1 4 bytes  - 证书处理保留字段
Reserved2 (var)    - 证书处理保留字段
VSize     2 bytes  - 密码验证数据大小
VData     VSize-4  - 密码验证数据 (加密)
VCRC32    4 bytes  - 密码验证数据的CRC32 (加密)

校验密码是否正确即是通过加密头内的部分字段进行的。

数据描述符 - Data Descriptor

用于在流式压缩场景下，将压缩数据的CRC-32、压缩大小和未压缩大小等信息从文件数据中分离出来。

由于lfh在文件数据之前，因此在流式压缩场景下，无法提前确定lfh中的crc32, compressed_size和uncompressed_size字段。此时，需要在文件数据之后添加一个数据描述符，用于存储这些信息。

    uint32_t signature;             /* 0x08074b50 */
    uint32_t crc32;
    uint32_t compressed_size;
    uint32_t uncompressed_size;

归档解密头 - Archive Decryption Header

结构与加密头相同，不同的是加密头是在每个文件数据之前，而归档解密头是在所有文件数据之后。归档解密头的位置由Zip64 End of Central Directory Record中的Start of Central Directory字段指定。

使用归档解密头可以支持加密整个中央目录结构，保护所有文件的元数据。

只在Zip64格式下才会存在归档解密头。

归档解密头的结构与Encryption Header完全相同。

归档额外数据记录 - Archive Extra Data Record

Archive Extra Data Record 主要用于存储与中央目录加密相关的额外信息，特别是：

数字证书信息：存储 PKCS#7 证书存储、X.509 证书 ID 和签名等
加密相关数据：存储加密接收者证书列表等

其结构定义如下：

1
2
3

    uint32_t signature;             /* 0x08074b50 */
    uint32_t extra_field_length;
    std::unique_ptr<uint8_t[]> extra_field;

中央目录头 - Central Directory Header

    uint32_t signature;
    uint16_t version_made_by;
    uint16_t version_needed;
    uint16_t general_bit_flag;
    uint16_t compression_method;
    uint16_t last_mod_time;
    uint16_t last_mod_date;
    uint32_t crc32;
    uint32_t compressed_size;
    uint32_t uncompressed_size;
    uint16_t filename_length;
    uint16_t extra_field_length;
    uint16_t file_comment_length;
    uint16_t disk_number_start;
    uint16_t internal_attr;
    uint32_t external_attr;
    uint32_t local_header_offset;
    std::string filename;
    std::unique_ptr<uint8_t[]> extra_field;
    std::string file_comment;

中央目录头与本地文件头之间存在许多冗余字段，原则上相对应的一对中央目录头和本地文件头，表示含义相同的字段值应该是相同的。

相关流程

Zip64解析流程

sequenceDiagram
    participant Parser AS 解析器
    participant EOCDR AS End of Central Directory
    participant ZIP64Locator AS ZIP64 Locator
    participant ZIP64EOCDR AS ZIP64 End of Central Directory
    participant 中央目录 AS Central Directory
    participant CDH AS Central Directory Header
    participant LFH AS Local File Header
    participant 文件数据 AS File Data
    participant DD AS Data Descriptor

    Note over Parser: 初始化阶段
    Parser->>EOCDR: 1. 读取End of Central Directory Record
    EOCDR->>Parser: 返回EOCDR数据
    Parser->>Parser: 2. 检查ZIP64格式标志
    alt 检测到ZIP64标志
        Parser->>ZIP64Locator: 3. 读取ZIP64 Locator
        ZIP64Locator->>Parser: 返回ZIP64 EOCDR位置
        Parser->>ZIP64EOCDR: 4. 读取ZIP64 EOCDR
        ZIP64EOCDR->>Parser: 返回完整中央目录信息
    end
    Parser->>中央目录: 5. 定位中央目录
    Parser->>Parser: 6. 初始化文件计数器 = 0

    Note over Parser: 循环处理所有文件
    loop 对于每个文件条目
        Parser->>Parser: 7. 文件计数器 += 1
        Parser->>CDH: 8. 读取Central Directory Header
        CDH->>Parser: 返回文件元数据
        Parser->>Parser: 9. 检查是否需要ZIP64扩展
        alt 需要ZIP64扩展
            Parser->>CDH: 10. 提取ZIP64扩展信息
            CDH->>Parser: 返回8字节大小和偏移量
        end

        Note over Parser: 处理Local File Header
        Parser->>LFH: 11. 根据CDH定位LFH
        LFH->>Parser: 返回Local File Header数据
        Parser->>Parser: 12. 验证LFH与CDH一致性

        Note over Parser: 处理文件数据
        Parser->>文件数据: 13. 读取压缩文件数据
        文件数据->>Parser: 返回文件数据
        Parser->>Parser: 14. 解压/解密文件数据

        alt 存在Data Descriptor
            Parser->>DD: 15. 读取Data Descriptor
            DD->>Parser: 返回实际CRC和大小
            Parser->>Parser: 16. 验证数据完整性
        end

        Parser->>Parser: 17. 存储文件信息
        Parser->>Parser: 18. 检查是否还有更多文件
    end

    Note over Parser: 完成阶段
    Parser->>Parser: 19. 生成完整文件列表
    Parser->>Parser: 20. 验证所有文件完整性
    Parser->>Parser: 21. 返回解析结果

启用中央目录加密时的解析流程

sequenceDiagram
    participant Parser AS 解析器
    participant User AS 用户
    participant EOCD AS End of Central Directory
    participant ZIP64Locator AS ZIP64 Locator
    participant ZIP64EOCD AS ZIP64 End of Central Directory
    participant ArchiveDH AS Archive Decryption Header
    participant ArchiveExtra AS Archive Extra Data Record
    participant EncryptedCD AS Encrypted Central Directory
    participant CDH AS Central Directory Header
    participant LFH AS Local File Header
    participant FileData AS File Data

    Note over Parser: 阶段1: 定位和读取目录结构
    Parser->>EOCD: 1. 读取End of Central Directory
    EOCD->>Parser: 返回EOCD数据
    Parser->>Parser: 2. 检测ZIP64格式标志
    Parser->>ZIP64Locator: 3. 读取ZIP64 Locator
    ZIP64Locator->>Parser: 返回ZIP64 EOCD位置
    Parser->>ZIP64EOCD: 4. 读取ZIP64 EOCD
    ZIP64EOCD->>Parser: 返回完整目录信息(含加密标志)

    Note over Parser: 阶段2: 检测中央目录加密
    Parser->>Parser: 5. 检查general purpose bit flag 13
    alt 中央目录已加密
        Parser->>User: 6. 请求密码或证书
        User->>Parser: 7. 提供密码/证书
        Parser->>ArchiveDH: 8. 读取Archive Decryption Header
        ArchiveDH->>Parser: 返回加密的解密头
        Parser->>Parser: 9. 使用密码/证书解密ArchiveDH
        ArchiveDH->>Parser: 返回解密后的解密头数据

        Note over Parser: 阶段3: 解密中央目录
        Parser->>EncryptedCD: 10. 读取加密的中央目录
        EncryptedCD->>Parser: 返回加密的中央目录数据
        Parser->>Parser: 11. 使用ArchiveDH中的密钥解密中央目录
        EncryptedCD->>Parser: 返回解密后的中央目录

        Note over Parser: 阶段4: 处理Archive Extra Data
        Parser->>ArchiveExtra: 12. 读取Archive Extra Data Record
        ArchiveExtra->>Parser: 返回额外数据(证书等)
    else 中央目录未加密
        Parser->>EncryptedCD: 8. 直接读取中央目录
        EncryptedCD->>Parser: 返回未加密的中央目录
    end

    Note over Parser: 阶段5: 解析中央目录
    Parser->>CDH: 13. 解析中央目录条目
    CDH->>Parser: 返回文件元数据
    Parser->>Parser: 14. 检查是否需要ZIP64扩展

    Note over Parser: 阶段6: 解压文件数据
    loop 对于每个文件
        Parser->>LFH: 15. 根据CDH定位LFH
        LFH->>Parser: 返回Local File Header
        Parser->>Parser: 16. 验证LFH(注意掩码字段)
        Parser->>FileData: 17. 读取文件数据
        FileData->>Parser: 返回压缩/加密的文件数据
        Parser->>Parser: 18. 解密/解压文件数据
        Parser->>Parser: 19. 验证文件完整性
        Parser->>Parser: 20. 输出解压后的文件
    end

    Note over Parser: 阶段7: 完成解压
    Parser->>User: 21. 显示解压完成信息

校验密码是否正确

传统PKWARE加密格式校验密码

sequenceDiagram
    participant User as 用户
    participant Parser as 解析器
    participant ZIP as ZIP文件

    User->>Parser: 提供密码
    Parser->>ZIP: 读取Local File Header
    ZIP->>Parser: 返回LFH数据 (包含加密标志)
    Parser->>ZIP: 读取12字节加密头
    ZIP->>Parser: 返回加密头数据

    Parser->>Parser: 使用密码初始化加密密钥
    Parser->>Parser: 解密12字节加密头

    Parser->>ZIP: 读取文件CRC值
    ZIP->>Parser: 返回文件CRC

    Parser->>Parser: 提取解密后加密头的最后1/2字节
    Parser->>Parser: 比较是否等于文件CRC的高位字节

    alt 密码验证成功
        Parser->>User: 密码验证成功
        Parser->>ZIP: 继续读取文件数据
        ZIP->>Parser: 返回文件数据
        Parser->>Parser: 解密文件数据
        Parser->>User: 解压完成
    else 密码验证失败
        Parser->>User: 密码验证失败
        Parser->>User: 提示重新输入密码
    end

强加密

sequenceDiagram
    participant User as 用户
    participant Parser as 解析器
    participant ZIP as ZIP文件

    User->>Parser: 提供密码
    Parser->>ZIP: 读取Local File Header
    ZIP->>Parser: 返回LFH数据 (包含强加密标志)
    Parser->>ZIP: 读取强加密解密头
    ZIP->>Parser: 返回解密头数据 (IVSize, IVData, AlgID, VSize等)

    Parser->>Parser: 解析解密头明文字段
    Parser->>Parser: 使用密码和IVData生成主会话密钥

    Parser->>ZIP: 读取ErdData字段
    ZIP->>Parser: 返回ErdData

    Parser->>Parser: 解密ErdData获取随机数据
    Parser->>Parser: 生成文件会话密钥

    Parser->>ZIP: 读取VData和VCRC32字段
    ZIP->>Parser: 返回VData和VCRC32

    Parser->>Parser: 使用会话密钥解密VData和VCRC32
    Parser->>Parser: 计算解密后VData的CRC32
    Parser->>Parser: 比较计算的CRC32与解密的VCRC32

    alt 密码验证成功
        Parser->>User: 密码验证成功
        Parser->>ZIP: 读取文件数据
        ZIP->>Parser: 返回文件数据
        Parser->>Parser: 解密文件数据
        Parser->>User: 解压完成
    else 密码验证失败
        Parser->>User: 密码验证失败
        Parser->>User: 提示重新输入密码
    end

启用中央目录加密

sequenceDiagram
    participant User as 用户
    participant Parser as 解析器
    participant ZIP as ZIP文件

    Parser->>ZIP: 读取EOCD和ZIP64记录
    ZIP->>Parser: 返回记录数据 (包含中央目录加密标志)

    Parser->>User: 检测到中央目录加密，请提供密码
    User->>Parser: 提供密码

    Parser->>ZIP: 根据ZIP64记录定位Archive Decryption Header
    ZIP->>Parser: 返回Archive Decryption Header

    Parser->>Parser: 解析解密头明文字段
    Parser->>Parser: 使用密码生成主会话密钥

    Parser->>ZIP: 读取ErdData字段
    ZIP->>Parser: 返回ErdData

    Parser->>Parser: 解密ErdData获取随机数据
    Parser->>Parser: 生成中央目录解密密钥

    Parser->>ZIP: 读取VData和VCRC32字段
    ZIP->>Parser: 返回VData和VCRC32

    Parser->>Parser: 解密VData和VCRC32
    Parser->>Parser: 验证VData的CRC32

    alt 密码验证成功
        Parser->>ZIP: 读取加密的中央目录
        ZIP->>Parser: 返回加密的中央目录数据
        Parser->>Parser: 解密中央目录
        Parser->>Parser: 解析中央目录获取文件列表
        Parser->>User: 显示文件列表
        User->>Parser: 选择要解压的文件
        Parser->>Parser: 继续解压选中的文件
        Parser->>User: 解压完成
    else 密码验证失败
        Parser->>User: 密码验证失败，无法解密中央目录
        Parser->>User: 无法显示文件列表，请重新输入密码
    end

c语言getopt.h库解析

Wed, 22 Jan 2025 13:29:03 +0800

getopt.h简介

getopt.h 是C语言中一个用于处理命令行参数的内嵌库。可以通过以下两个函数来调用其功能：

getopt()
getopt_long()

函数 `getopt()`

getopt() 用于解析仅包含短选项的指令，例如 -g、-o、-f。

`getopt()` 示例程序

使用 getopt() 的参数处理框架如下：

#include <stdio.h>
#include <getopt.h>

int main(int argc, char *argv[]) {
    int opt;

    /* parse the command line input */
    while ((opt = getopt(argc, argv, "f:o:kh")) != -1) {
        switch (opt) {
            case 'f':
                printf("Arg -f: %s\n", optarg);
                break;
            case 'o':
                printf("Arg -o: %s\n", optarg);
                break;
            case 'k':
                printf("Arg -k do not need arguments:%s\n", optarg);
                break;
            case 'h':
                printf("Arg -k do not need arguments:%s\n", optarg);
                break;
            case '?': // An invalid option was found or a required argument is missing.
                if (optopt == 'f' || optopt == 'o') {
                    printf("Option -%c requires an argument.\n", optopt);
                } else {
                    printf("Unknown option -%c.\n", optopt);
                }
                break;
            default:
                printf("Unexpected situation.\n");
                break;
        }
    }

    /* extra arguments handling */
    if (optind < argc) {
        printf("Remaining arguments: ");
        for (; optind < argc; optind++) {
            printf("%s ", argv[optind]);
        }
    } /* optind < argc */
}

编译并运行如下指令：./test_short.out -v yuanshen -f arg:f -o arg:o -k arg:k -h arg:h

> ./test_short.out -v yuanshen -f arg:f -o arg:o -k arg:k -h arg:h
./test_short.out: invalid option -- 'v'
Invalid option: v
Arg -f: arg:f
Arg -o: arg:o
Arg -k do not need arguments:(null)
Arg -k do not need arguments:(null)
Remaining arguments: yuanshen arg:k arg:h %

`getopt()`详细说明

全局变量

全局变量	用途
optopt (int)	遇到未知选项或缺少必要参数时设置，存储导致错误的选项字符。
optarg (char*)	存储当前选项的参数值。当解析需要参数的选项（例如 `-f file.txt` 中的 `file.txt`）时，`optarg` 指向该字符串。
optind (int)	在解析命令行参数过程中，追踪位置，具体指示下一个要处理的参数的索引。

以下代码段会打印所有未被 getopt() 识别的参数（忽略这些参数的输入顺序）：

/* extra arguments handling */
if (optind < argc) {
    printf("Remaining arguments: ");
    for (; optind < argc; optind++) {
        printf("%s ", argv[optind]);
    }
}

模式字符串

模式字符串的定义是 const char *__shortopts，在示例程序中，其实例为 "f:o:kh"。

顾名思义，模式字符串定义了 getopt() 和 getopt_long() 函数中将被识别的短选项。冒号 : 跟在短选项字符后表示该选项需要一个参数。

以 "f:o:kh" 为例，此模式字符串接收4个选项。选项 -f 和 -o 需要输入参数，而选项 -k 和 -h 不需要。

注意：如果 -f 后跟一个选项，该选项会被视为参数。

函数 `getopt_long()`

getopt_long() 用于解析既包含短选项（如 -g、-o、-f）又包含长选项（如 --version、--input）的指令。

函数 getopt_long 识别一个结构体数组 struct option，该数组定义了长选项的信息。

struct option 的原型及相关介绍如下：

struct option {
    const char *name;   /* 长选项的名称 */
    int has_arg;        /* 是否需要参数 */
    int *flag;          /* 如果用户提供了此选项，*flag 将被赋值为 @val */
    int val;            /* 将长选项与短选项绑定，或赋值给 @*flag */
};

字段 has_arg 有两个有效值，即宏 no_argument 和 required_argument。

如果字段 flag 未提供，则字段 val 会被视为与当前长选项绑定的短选项。

如果提供了字段 flag，当用户提供当前长选项时，字段 val 将被赋值给 *flag。

用实例详细说明

以下是一个使用 struct option 数组和模式字符串的实例：

/* the corresponding pattern string */
const char *pattern = "suR:";

struct option long_options[] = {
    /* long option only */
    /* with flag set - 1 */
    { "onlyset1",   no_argument,        &onlyset1,      1   },

    /* long option only */
    /* with flag set - 2 */
    { "onlyset2",   no_argument,        &onlyset1,      2   },

    /* long option only */
    /* with flag set - 3 */
    { "onlyset3",   no_argument,        &onlyset2,      3   },

    /* long option only ( bind failed ) */
    /* with flag set, with val bind */
    { "setbind",    no_argument,        &setbind_flag,  's' },

    /* short and long option */
    /* without flag set, with val bind */
    { "unsetbind",  no_argument,        NULL,           'u' },

    /* short and long option */
    /* require argument */
    { "RequireArg", required_argument,  NULL,           'R' },
};

考虑到短选项和长选项，当提到某个功能的option时，可能会有以下三种情况：

仅有短选项
仅有长选项
同时具有短选项和长选项

结合模式字符串和 struct option 数组，程序接收的选项如下：

短选项	长选项
	–onlyset1
	–onlyset2
	–onlyset3
	–setbind
-s
-u	–unsetbind
-R	–RequireArg

选项 -s 和 --setbind 并未绑定在一起，因为在与 "setbind" 对应的结构体元素中设置了字段 flag。

参数需求冲突

当短选项和长选项中都定义了参数需求时，可能会发生冲突。

我们通过一个实例进行说明：

/* the corresponding pattern string */
const char *pattern = "c:d";

struct option long_options = {
    /* short and long option */
    /* conflict argument require - 1 */
    { "Conflict1",  no_argument,        NULL,           'c' },

    /* short and long option */
    /* conflict argument require - 2 */
    { "Conflict2",  required_argument,  NULL,           'd'},

    /* end of the array ( all zero ) */
    { 0,            0,                  0,              0   }
};

我们可以看到，上述程序将一个需要参数的短选项 -c 与一个不需要参数的长选项 --Conflict1 绑定在一起。

同时，它还将一个不需要参数的短选项 -d 与一个需要参数的长选项 --Conflict2 绑定在一起。

该程序运行正常，但关于参数的配置也会生效。

当用户提供 -c 或 --Conflict1 时，程序会进入同一个分支，但 --Conflict1 不会读取后续的参数，而 -c 会读取。

当用户提供 -d 或 --Conflict2 时，结果则相反。

`getopt_long()` 示例程序

以下是使用 getopt_long() 的参数处理框架：

#include <stdio.h>
#include <getopt.h>

/* test instructions:
    ./test_long.out --onlyset1 --onlyset2 --onlyset3
    ./test_long.out -s --setbind
    ./test_long.out --unsetbind --RequireArg arg:RequireArg
    ./test_long.out -u -R arg:R

    ./test_long.out -c arg:c -d arg:d
    ./test_long.out --Conflict1 arg:Conflict1 --Conflict2 arg:Conflict2

    ./test_long.out -c arg:c --Conflict1 arg:Conflict1
    ./test_long.out --Conflict1 arg:Conflict1 -c arg:c
*/

int main(int argc, char *argv[]) {
    int opt;
    int onlyset1 = 0;
    int onlyset2 = 0;
    int setbind_flag = 0;

    struct option long_options[] = {
        /* long option only */
        /* with flag set - 1 */
        { "onlyset1",   no_argument,        &onlyset1,      1   },

        /* long option only */
        /* with flag set - 2 */
        { "onlyset2",   no_argument,        &onlyset1,      2   },

        /* long option only */
        /* with flag set - 3 */
        { "onlyset3",   no_argument,        &onlyset2,      3   },

        /* long option only ( bind failed ) */
        /* with flag set, with val bound */
        { "setbind",    no_argument,        &setbind_flag,  's' },

        /* short and long option */
        /* without flag set, with val bound */
        { "unsetbind",  no_argument,        NULL,           'u' },

        /* short and long option */
        /* require argument */
        { "RequireArg", required_argument,  NULL,           'R' },

        /* short and long option */
        /* conflict argument require - 1 */
        { "Conflict1",  no_argument,        NULL,           'c' },

        /* short and long option */
        /* conflict argument require - 2 */
        { "Conflict2",  required_argument,  NULL,           'd'},

        /* end of the array ( all zero ) */
        { 0,            0,                  0,              0   }
    };

    int long_index = 0;
    while ((opt = getopt_long(argc, argv, "suR:c:d", long_options, &long_index)) != -1) {
        switch (opt) {
            case 0:
                /* provide long option with flag set */
                printf("long option with flag set recognized!\n");
                printf("long option name is %s\n", long_options[long_index].name);
                if (long_options[long_index].flag != NULL) {
                    printf("the flag value is %d\n", *(long_options[long_index].flag));
                }
                break;
            case 's':
                /* provide option -s instead of --setbind */
                printf("long option (short option only), with flag set, with val bound.\n");
                printf("setbind_flag == %d\n", setbind_flag);
                break;
            case 'u':
                /* provide option -u and --unsetbind */
                printf("long option, without flag set, with val bound.\n");
                break;
            case 'R':
                /* provide option -R and --RequireArg */
                printf("long option require argument.\n");
                printf("the argument: %s\n", optarg);
                break;
            case 'c':
                /* -c require an argument while --Conflict1 not */
                printf("conflict argument require - 1\n");
                printf("the argument: %s\n", optarg);
                break;
            case 'd':
                /* --Conflict2 require an argument while -d not */
                printf("conflict argument require - 2\n");
                printf("the argument: %s\n", optarg);
                break;
            case '?':
                /* Unrecognized option or missing argument */
                printf("Unknown option or missing argument.\n");
                break;
        }
        printf("\n");
    }

    /* Process remaining non-option arguments */
    for (int index = optind; index < argc; index++)
        printf("Non-option argument %s\n", argv[index]);

    return 0;
}

运行测试指令并分析测试结果

编译运行时的测试指令如下：

./test_long.out --onlyset1 --onlyset2 --onlyset3
./test_long.out -s --setbind
./test_long.out --unsetbind --RequireArg arg:RequireArg
./test_long.out -u -R arg:R

./test_long.out -c arg:c -d arg:d
./test_long.out --Conflict1 arg:Conflict1 --Conflict2 arg:Conflict2

./test_long.out -c arg:c --Conflict1 arg:Conflict1
./test_long.out --Conflict1 arg:Conflict1 -c arg:c

结果如下：

> ./test_long.out --onlyset1 --onlyset2 --onlyset3
long option with flag set recognized!
long option name is onlyset1
the flag value is 1

long option with flag set recognized!
long option name is onlyset2
the flag value is 2

long option with flag set recognized!
long option name is onlyset3
the flag value is 3

指令 ./test_long.out --onlyset1 --onlyset2 --onlyset3 展示了 getopt_long() 的基本功能。

它改变了 flag 地址中的值。

> ./test_long.out -s --setbind
long option (short option only), with flag set, with val bound.
setbind_flag == 0

long option with flag set recognized!
long option name is setbind
the flag value is 115

指令 ./test_long.out -s --setbind 展示了绑定失败（当 flag 字段被设置时）。

--setbind 和 -s 会进入不同的分支。

> ./test_long.out --unsetbind --RequireArg arg:RequireArg
long option, without flag set, with val bound.

long option require argument.
the argument: arg:RequireArg

> ./test_long.out -u -R arg:R
long option, without flag set, with val bound.

long option require argument.
the argument: arg:R

这对比展示了绑定成功的结果（当 flag 字段未设置时）。

--unsetbind 和 -u 被绑定在一起，进入相同的分支。

--RequireArg 和 -R 也是一样。

> ./test_long.out -c arg:c -d arg:d
conflict argument require - 1
the argument: arg:c

conflict argument require - 2
the argument: (null)

Non-option argument arg:d

> ./test_long.out --Conflict1 arg:Conflict1 --Conflict2 arg:Conflict2
conflict argument require - 1
the argument: (null)

conflict argument require - 2
the argument: arg:Conflict2

Non-option argument arg:Conflict1

这对比展示了参数要求的冲突。

-c 和 --Conflict1 被绑定在一起，但 -c 需要一个参数。

-d 和 --Conflict2 被绑定在一起，但 --Conflict2 需要一个参数。

结果显示，绑定在一起的选项会进入相同的分支。

但是，是否读取或忽略参数取决于用户提供的选项是否需要参数。

> ./test_long.out -c arg:c --Conflict1 arg:Conflict1
conflict argument require - 1
the argument: arg:c

conflict argument require - 1
the argument: (null)

Non-option argument arg:Conflict1


> ./test_long.out --Conflict1 arg:Conflict1 -c arg:c
conflict argument require - 1
the argument: (null)

conflict argument require - 1
the argument: arg:c

Non-option argument arg:Conflict1

冲突选项的另一个对比结果。

编程 on 星分

c拓展语法学习

pragma

_Pragma

pragma 指令功能表

attribute

常见属性表

函数属性

类型属性

变量属性

用法示例

volatile 关键字

ZIP 文件结构与解析流程核心笔记

ZIP 文件结构与解析流程核心笔记

ZIP文件基础结构图示

ZIP文件解析流程

标准解析模式

流式解析模式

手工篡改ZIP进行实验

Zip文件具体分析

本地文件头 - Local File Header

general_bit_flag

加密头 - Encryption Header

数据描述符 - Data Descriptor

归档解密头 - Archive Decryption Header

归档额外数据记录 - Archive Extra Data Record

中央目录头 - Central Directory Header

相关流程

Zip64解析流程

启用中央目录加密时的解析流程

校验密码是否正确

传统PKWARE加密格式校验密码

强加密

启用中央目录加密

c语言getopt.h库解析

getopt.h简介

函数 getopt()

getopt() 示例程序

getopt()详细说明

全局变量

模式字符串

函数 getopt_long()

用实例详细说明

参数需求冲突

getopt_long() 示例程序

运行测试指令并分析测试结果

函数 `getopt()`

`getopt()` 示例程序

`getopt()`详细说明

函数 `getopt_long()`

`getopt_long()` 示例程序