<think>我们需要解析multipart协议内容，通常用于HTTP协议中的multipart/form-data类型，常见于文件上传。 由于C语言标准库中没有直接解析multipart的功能，我们需要手动解析。这里我们将根据RFC 2046和RFC 2388来实现。 步骤： 1. 获取请求体（body）和Content-Type头部，从中提取boundary（边界字符串）。 2. 根据boundary将整个body分割成多个部分（part）。 3. 对于每个part，解析其头部和内容体。头部和内容体之间由空行（\r\n\r\n）分隔。 4. 解析每个part的头部，获取该part的相关信息（如Content-Disposition, Content-Type等），特别是从Content-Disposition中获取name和filename。 注意：boundary在Content-Type中指定，格式为：multipart/form-data; boundary=----WebKitFormBoundary7MA4YWxkTrZu0gW 实际上，boundary前面会加上两个减号（--），而整个body的结束标志是boundary加上两个减号（即--boundary--）。 我们将编写一个函数来解析multipart数据。由于C语言处理字符串比较繁琐，我们将使用一些标准库函数（如strstr，strtok等）来辅助。 但是注意：strtok会修改原字符串，所以我们最好先复制一份。另外，由于multipart数据中可能包含二进制数据（如图片），我们不能假设数据是字符串（即以'\0'结尾），所以需要基于长度操作。 然而，为了简化，我们假设整个请求体是一个字符串（即我们处理的是文本，或者我们将二进制数据也当作字符数组处理，但要注意其中可能包含'\0'，所以不能使用strlen等函数）。因此，我们最好使用指针和长度来操作。 由于问题要求使用C语言，我们将设计一个解析器，它接收原始数据、数据长度、boundary，然后输出解析出的各个部分。 设计结构体来存储每个part的信息： typedef struct { char *name; // 字段名 char *filename; // 文件名（如果有） char *content_type; // 内容类型 const char *data; // 指向part主体数据的指针 size_t data_len; // 主体数据的长度 } Part; 函数原型： Part* parse_multipart(const char *data, size_t data_len, const char *boundary, size_t *part_count); 步骤： 1. 计算boundary的长度，并构造带前置"--"的boundary字符串（即delimiter），以及结束边界（即delimiter后面加"--"）。 2. 在data中查找第一个delimiter的位置，然后跳过它（注意：第一个delimiter之后是\r\n，然后才是part内容）。 3. 然后查找下一个delimiter，两个delimiter之间的数据就是一个part（注意：每个part之前可能有一个\r\n，除了第一个part）。 4. 对于每个part，先读取头部（直到遇到\r\n\r\n），然后解析头部，剩下的就是主体部分（直到下一个delimiter之前，但要注意主体部分末尾的\r\n需要去掉？实际上，每个part的末尾有一个\r\n，在分割part时应该去掉）。 5. 重复直到遇到结束边界。 注意：由于数据可能很大，我们使用指针操作，避免不必要的复制。 由于C语言没有内置的字符串分割函数可以处理二进制安全的数据，我们将手动查找边界。 实现查找函数：使用Boyer-Moore算法？但为了简单，我们使用简单的内存比较（memcmp）来查找边界。 具体步骤： - 初始化： delimiter = "--" + boundary; // 注意：boundary是从Content-Type中获取的，不包含前面的"--" delimiter_len = strlen(delimiter); // 这里注意，boundary本身不包含前置的"--"，所以我们要构造一个带"--"的字符串 end_delimiter = delimiter + "--"; // 结束边界，即delimiter后加两个减号 end_delimiter_len = delimiter_len + 2; - 在数据中查找delimiter，注意每个delimiter前面都有一个换行（除了第一个），但实际上第一个delimiter前面没有换行，但在整个body的开头？实际上，body开头可能是delimiter，也可能是其他（但标准是body以delimiter开始）。 根据标准，multipart body的格式如下： --<boundary>\r\n Content-Disposition: form-data; name="field1"\r\n \r\n value1\r\n --<boundary>\r\n Content-Disposition: form-data; name="field2"; filename="example.txt"\r\n Content-Type: text/plain\r\n \r\n ... contents of example.txt ...\r\n --<boundary>--\r\n 因此，我们首先跳过开头的"--"和boundary，然后读取一个part，直到遇到下一个"--"和boundary。 由于我们使用内存数据，我们可以这样： 1. 检查data的前delimiter_len个字节是否等于delimiter，如果不等于，则格式错误。 2. 然后从位置delimiter_len开始，跳过接下来的\r\n（如果存在）。 然后我们开始解析part： - 下一个delimiter应该在当前part的后面，所以我们从当前位置开始查找下一个delimiter。 - 如何查找？我们可以在剩余的数据中搜索delimiter。注意：delimiter前面有一个\r\n（除了第一个part之后，每个part之前都有一个\r\n，但实际上第一个part之后也有一个\r\n？看上面的格式，每个boundary前面都有\r\n，包括第一个？不对，第一个boundary在开头，后面是\r\n，然后开始part。而第二个boundary前面是前一个part的末尾的\r\n，所以每个boundary前面都有\r\n，除了开头的boundary？开头的boundary前面没有\r\n。 因此，我们在查找下一个边界时，应该从当前位置开始，查找"\r\n--<boundary>"，但注意第一个part的结束位置就是下一个boundary，而它前面有\r\n。 所以，我们实际在body中查找的边界是：\r\n--<boundary>，但第一个boundary没有前面的\r\n。因此，在第一个boundary之后，我们查找下一个边界时，应该查找"\r\n" + delimiter。 但是，为了统一，我们可以这样处理： 第一个boundary在开头，我们跳过它（包括后面的\r\n），然后当前位置就是第一个part的开始。 然后我们查找下一个出现的"\r\n" + delimiter，这个位置就是当前part的结束位置。 然后我们从这个位置跳过整个边界（包括前面的\r\n和边界字符串），然后继续。 另外，最后一个part的结束边界是"\r\n" + delimiter + "--"。 步骤： 1. 初始化指针：start = data + delimiter_len; // 跳过开头的边界 // 然后检查start[0]和start[1]是不是\r\n，如果是，则跳过这两个字符（start += 2） 2. 然后我们设置current = start; 3. 在剩余数据中查找子串：search_str = "\r\n" + delimiter (长度为2+delimiter_len) 4. 找到这个子串的位置ptr，那么从current到ptr就是当前part的数据（包括头部和主体，以及头部和主体之间的空行）。 5. 在part数据中，我们查找第一个"\r\n\r\n"，将头部和主体分开。 6. 解析头部（多行，每行以\r\n分隔），然后主体部分就是头部之后（跳过\r\n\r\n）到part结束（ptr）之前，注意主体部分可能包含二进制数据。 7. 然后，我们设置下一个part的起始位置：ptr + search_str_len，然后跳过这个边界，如果这个边界后面紧跟"--"，则说明是结束边界，结束解析；否则，跳过边界后，下一个位置就是下一个part的开始（注意跳过\r\n）。 但是，注意：在最后一个part的结束边界，我们不需要再跳过\r\n，因为它后面就是结束边界。 由于这个解析过程比较复杂，我们写一个循环。 另外，注意：在查找边界时，我们可能找不到？那么就是错误。 考虑到效率，我们可以使用一个循环来查找边界，每次移动一个字节，然后比较。 由于数据可能很大，但boundary通常不会太长，所以这样查找是可以接受的。 代码实现： 我们将实现一个函数，在内存中查找指定子串（二进制安全），返回位置指针。 注意：由于数据中可能包含0，所以我们不能使用strstr，而是使用memmem函数。但是memmem不是标准C库函数（在POSIX中定义）。为了可移植性，我们实现一个简单的memmem。 或者，我们可以自己写一个循环来查找。 这里我们实现一个简单的内存查找函数： void* memfind(const void *haystack, size_t haystacklen, const void *needle, size_t needlelen) { if (haystack == NULL || needle == NULL || haystacklen < needlelen) return NULL; const char *h = haystack; const char *n = needle; size_t i, j; for (i=0; i<=haystacklen-needlelen; i++) { for (j=0; j<needlelen; j++) { if (h[i+j] != n[j]) break; } if (j == needlelen) return (void*)(h+i); } return NULL; } 然后，我们使用这个函数来查找边界。 具体步骤： 1. 构造delimiter: 带前置"--"，比如boundary是"abcdef"，那么delimiter就是"--abcdef"。 2. 构造part之间的边界标记：boundary_marker = "\r\n" + delimiter; // 长度为2+delimiter_len 3. 结束边界：end_marker = "\r\n" + delimiter + "--"; // 然后我们还要检查结束边界，注意结束边界后面可能还有\r\n，但解析时我们不需要。 但是，第一个part前面没有\r\n，所以我们在查找第一个part的结束位置时，应该查找boundary_marker（即"\r\n--abcdef"），但是第一个part的结束位置确实是在第一个boundary_marker处吗？ 实际上，在第一个boundary（即开头的"--abcdef"）之后，紧接着是第一个part的数据，然后遇到第一个boundary_marker（即"\r\n--abcdef"）表示第一个part结束。 所以，我们可以这样： - 从第一个part的起始位置（即开头的boundary之后，跳过\r\n）开始，查找boundary_marker。 - 如果找到，则当前part的数据就是：从当前开始位置到找到的boundary_marker的起始位置（即这个位置之前是当前part的数据，注意这个数据末尾没有\r\n，因为boundary_marker前面有\r\n，所以当前part的数据末尾的\r\n属于boundary_marker的一部分，应该去掉？） 但是，注意：每个part的数据格式是： 头部（多行）\r\n \r\n 主体数据\r\n 而boundary_marker前面的\r\n实际上是主体数据后面的换行，所以当我们找到boundary_marker时，当前part的数据包括这个换行吗？实际上，boundary_marker前面的\r\n是分隔符，不属于当前part。所以，当前part的数据应该到boundary_marker之前的\r\n之前？不对，因为主体数据后面可能本来就有一个换行，而且这个换行是主体数据的一部分吗？ 根据RFC，每个part的主体数据后面没有规定必须有换行，但是boundary前面的\r\n是作为分隔符。所以，我们解析出的part数据中，主体数据不应该包含boundary_marker前面的\r\n。因此，当我们找到boundary_marker时，当前part的结束位置应该是boundary_marker的起始位置，然后我们从这个位置向前看两个字节，如果是\r\n，则说明主体数据后面有两个字节的换行，我们应该去掉。但是，主体数据可能很长，而且可能是二进制的，所以不能简单地去掉最后两个字节，因为可能不是\r\n。 实际上，在boundary_marker之前，必须有一个\r\n（这是标准规定的），所以我们可以认为part数据在boundary_marker之前，并且part数据的最后两个字节是\r\n（属于该part的结尾换行，但它是分隔符还是主体内容？根据标准，这个\r\n是分隔符，不属于主体内容。所以我们在解析part主体时，应该去掉这个换行。 但是，标准规定：每个part以分隔符（boundary）结束，而分隔符前面有一个CRLF（除了最后一个part的结束边界），所以每个非最后一个part的主体数据后面都会有一个CRLF。因此，当我们提取主体数据时，这个CRLF应该被去掉。 所以，在找到boundary_marker的位置ptr后，当前part的数据范围是：start 到 ptr-2（因为ptr-2到ptr是\r\n，不属于主体，而是分隔符的一部分）。 但是，如果part的数据中不包含这个换行，那么可能是格式错误？所以我们需要检查ptr-2和ptr-1是否是\r\n。 因此，步骤： 1. 查找boundary_marker，位置为ptr。 2. 如果ptr为NULL，则说明没有找到下一个边界，可能是最后一个part？但我们应该有结束边界，所以这种情况是错误。 3. 当前part的数据长度为 ptr - start - 2? 不对，因为ptr指向boundary_marker的开始位置，而boundary_marker前面有两个字节的\r\n，所以part的数据结束位置应该是ptr-2，所以数据长度是 (ptr-2) - start + 1? 不对，应该是 (ptr - start) - 2，即长度= ptr - start - 2。 然后，在这个part数据中（从start开始，长度len = ptr - start - 2），我们再解析头部和主体。 4. 解析part的头部：在part数据中查找"\r\n\r\n"，位置为header_end。 头部数据：从start到header_end（不包括header_end，因为header_end指向第一个\r\n\r\n的开始） 主体数据：从header_end+4（跳过\r\n\r\n）到 start+len（即整个part数据的末尾） 但是，注意：主体数据可能包含二进制内容，所以我们需要记录指针和长度。 5. 解析头部：头部由多行组成，每行以\r\n结尾。我们可以按行分割，然后解析每一行。 6. 解析Content-Disposition行：通常包含name和filename（如果有的话）。格式如： Content-Disposition: form-data; name="user"; filename="hello.txt" 我们可以使用字符串函数来提取。 7. 继续处理下一个part：将start设置为ptr + boundary_marker_len（即跳过这个boundary_marker），然后检查接下来的两个字节是不是"--"，如果是，则结束；否则，继续解析。 注意：结束边界是boundary_marker（即"\r\n--abcdef"）后面紧接着"--"，然后可能还有\r\n（整个body结束的\r\n）。 所以，当我们找到一个boundary_marker后，检查紧接着boundary_marker后面的两个字节（即ptr + boundary_marker_len）是否是"--"： if (memcmp(ptr + boundary_marker_len, "--", 2) == 0) { // 结束 } 如果是结束边界，那么整个解析完成。 另外，第一个part的起始位置是开头的boundary之后，跳过\r\n（如果存在）。但是，开头的boundary后面紧跟的是\r\n（根据标准），所以我们可以这样： if (data_len < delimiter_len) 错误 if (memcmp(data, delimiter, delimiter_len) != 0) 错误 // 检查开头的boundary后面是不是\r\n if (data_len >= delimiter_len+2 && memcmp(data+delimiter_len, "\r\n", 2)==0) { start = data + delimiter_len + 2; } else { // 错误，或者可能是没有\r\n？但标准要求有 // 这里我们当作错误处理 return NULL; } 然后，我们定义boundary_marker = "\r\n" + delimiter; // 长度为 delimiter_len + 2 boundary_marker_len = delimiter_len + 2; 结束边界：end_marker = boundary_marker + "--"; // 即"\r\n--abcdef--"，但结束边界我们单独判断。 然后循环解析part。 由于代码较长，我们将分步骤实现。 注意：内存管理，我们需要分配Part结构体数组，以及为每个Part中的字符串分配内存（使用strdup），但是注意，解析出的主体数据我们只保存指针和长度，不复制，因为可能很大。 但是，调用者需要保证原始数据在解析过程中有效（因为保存的是指针）。 另外，如果part中没有Content-Disposition，或者没有name，我们怎么处理？我们只处理有Content-Disposition并且有name的part。 下面给出代码框架： 注意：由于代码较长，我们只实现核心解析逻辑，并假设输入的数据是完整的，且格式正确。实际应用中需要更健壮的检查。 我们将实现以下函数： // 在haystack中查找needle，返回位置指针，找不到返回NULL static const char* find_bytes(const char *haystack, size_t haystack_len, const char *needle, size_t needle_len) { for (size_t i = 0; i <= haystack_len - needle_len; i++) { if (memcmp(haystack+i, needle, needle_len) == 0) { return haystack+i; } } return NULL; } // 解析头部字符串，提取字段名和值（这里我们只处理Content-Disposition和Content-Type，并且只解析简单的值） // 对于Content-Disposition，我们提取name和filename static void parse_headers(const char *header_data, size_t header_len, Part *part) { // 将header_data按行分割（行以\r\n分隔） const char *start = header_data; const char *end = header_data + header_len; const char *line_end; while (start < end) { // 查找下一个\r\n line_end = find_bytes(start, end - start, "\r\n", 2); if (line_end == NULL) { line_end = end; // 最后一行 } // 解析一行 const char *colon = find_bytes(start, line_end - start, ":", 1); if (colon) { char *name = (char*)malloc(colon - start + 1); memcpy(name, start, colon - start); name[colon-start] = '\0'; // 值跳过冒号和空格 const char *value = colon + 1; while (*value == ' ') value++; char *value_str = (char*)malloc(line_end - value + 1); memcpy(value_str, value, line_end - value); value_str[line_end - value] = '\0'; // 如果是Content-Disposition if (strcasecmp(name, "Content-Disposition") == 0) { // 解析value_str，格式为：form-data; name="..."; filename="..." (filename可选) char *token = strtok(value_str, ";"); while (token) { // 跳过空格 while (*token == ' ') token++; if (strncasecmp(token, "name=", 5) == 0) { char *name_val = token + 5; if (*name_val == '"') { name_val++; char *end_quote = strchr(name_val, '"'); if (end_quote) { *end_quote = '\0'; part->name = strdup(name_val); } } else { part->name = strdup(name_val); } } else if (strncasecmp(token, "filename=", 9) == 0) { char *filename_val = token + 9; if (*filename_val == '"') { filename_val++; char *end_quote = strchr(filename_val, '"'); if (end_quote) { *end_quote = '\0'; part->filename = strdup(filename_val); } } else { part->filename = strdup(filename_val); } } token = strtok(NULL, ";"); } } else if (strcasecmp(name, "Content-Type") == 0) { part->content_type = strdup(value_str); } free(name); free(value_str); } if (line_end == end) break; start = line_end + 2; // 跳过\r\n } } // 解析multipart数据 Part* parse_multipart(const char *data, size_t data_len, const char *boundary, size_t *part_count) { // 构造delimiter: "--" + boundary size_t boundary_len = strlen(boundary); size_t delimiter_len = boundary_len + 2; char *delimiter = (char*)malloc(delimiter_len + 1); sprintf(delimiter, "--%s", boundary); delimiter[delimiter_len] = '\0'; // 检查数据开头是否是delimiter if (data_len < delimiter_len || memcmp(data, delimiter, delimiter_len) != 0) { free(delimiter); return NULL; } // 构造part之间的分隔符：boundary_marker = "\r\n" + delimiter size_t boundary_marker_len = delimiter_len + 2; char *boundary_marker = (char*)malloc(boundary_marker_len + 1); sprintf(boundary_marker, "\r\n%s", delimiter); boundary_marker[boundary_marker_len] = '\0'; // 结束边界：boundary_marker + "--" size_t end_marker_len = boundary_marker_len + 2; char *end_marker = (char*)malloc(end_marker_len + 1); sprintf(end_marker, "%s--", boundary_marker); end_marker[end_marker_len] = '\0'; // 跳过开头的delimiter和后面的\r\n const char *start = data + delimiter_len; if (data_len < delimiter_len + 2 || memcmp(start, "\r\n", 2) != 0) { // 错误 free(delimiter); free(boundary_marker); free(end_marker); return NULL; } start += 2; // 现在start指向第一个part的开始 // 预分配一些Part，假设最多16个 Part *parts = (Part*)malloc(16 * sizeof(Part)); size_t capacity = 16; *part_count = 0; const char *current = start; size_t remaining_len = data_len - (start - data); while (remaining_len > 0) { // 查找下一个boundary_marker const char *next_marker = find_bytes(current, remaining_len, boundary_marker, boundary_marker_len); if (next_marker == NULL) { // 没有找到，可能是最后一个part？但我们应该有结束边界，所以尝试查找end_marker next_marker = find_bytes(current, remaining_len, end_marker, end_marker_len); if (next_marker == NULL) { // 错误，没有找到结束边界 break; } else { // 找到了结束边界，那么这个part的结束位置就是next_marker // part数据：current 到 next_marker，注意：end_marker前面也有\r\n？是的，所以同样要减去两个字节 // 但是，end_marker前面也有\r\n吗？根据标准，最后一个part结束边界前面也有\r\n，所以同样处理：part数据长度= next_marker - current - 2 // 但是，我们要检查是否确实有\r\n if (next_marker - current < 2 || memcmp(next_marker-2, "\r\n", 2) != 0) { // 错误 break; } size_t part_len = next_marker - current - 2; // 解析这个part Part part; memset(&part, 0, sizeof(Part)); // 在part数据中查找头部和主体的分界：\r\n\r\n const char *header_end = find_bytes(current, part_len, "\r\n\r\n", 4); if (header_end == NULL) { // 错误，没有空行分隔头部和主体 break; } size_t header_len = header_end - current; // 解析头部 parse_headers(current, header_len, &part); // 主体数据：从header_end+4 到 current+part_len part.data = header_end + 4; part.data_len = (current + part_len) - (header_end + 4); // 保存part if (*part_count >= capacity) { capacity *= 2; parts = (Part*)realloc(parts, capacity * sizeof(Part)); } parts[*part_count] = part; (*part_count)++; // 结束 break; } } // 找到了一个boundary_marker，那么当前part的数据结束位置是next_marker-2（因为前面有\r\n） if (next_marker - current < 2 || memcmp(next_marker-2, "\r\n", 2) != 0) { // 错误 break; } size_t part_len = next_marker - current - 2; // 解析这个part Part part; memset(&part, 0, sizeof(Part)); const char *header_end = find_bytes(current, part_len, "\r\n\r\n", 4); if (header_end == NULL) { break; } size_t header_len = header_end - current; parse_headers(current, header_len, &part); part.data = header_end + 4; part.data_len = (current + part_len) - (header_end + 4); // 保存part if (*part_count >= capacity) { capacity *= 2; parts = (Part*)realloc(parts, capacity * sizeof(Part)); } parts[*part_count] = part; (*part_count)++; // 移动current：跳过当前part和boundary_marker，注意boundary_marker后面可能有"--"（结束标志）或直接是下一个part current = next_marker + boundary_marker_len; remaining_len = data_len - (current - data); // 检查current后面是不是紧跟着"--"，即结束边界 if (remaining_len >= 2 && memcmp(current, "--", 2) == 0) { // 结束 break; } } free(delimiter); free(boundary_marker); free(end_marker); return parts; } 注意：上面的代码没有释放Part结构体内部分配的内存，也没有处理错误情况。在实际使用中，我们需要在错误时释放已分配的内存。 另外，这个解析器假设数据格式完全正确，实际中需要更健壮的错误处理。 由于代码较长，且C语言处理字符串比较繁琐，这里我们只提供一个基本框架。实际应用中可能需要根据具体需求调整。 下面是一个简单的使用示例： const char *data = ...; // multipart body size_t data_len = ...; const char *boundary = "----WebKitFormBoundary7MA4YWxkTrZu0gW"; size_t part_count; Part *parts = parse_multipart(data, data_len, boundary, &part_count); for (size_t i=0; i<part_count; i++) { printf("Part %zu: name=%s, filename=%s, content_type=%s, data_len=%zu\n", i, parts[i].name, parts[i].filename, parts[i].content_type, parts[i].data_len); // 使用parts[i].data和parts[i].data_len } // 释放parts for (size_t i=0; i<part_count; i++) { free(parts[i].name); free(parts[i].filename); free(parts[i].content_type); } free(parts); 注意：这个示例中，我们假设Part结构体中的字符串字段都是用strdup分配的，所以需要free。 由于multipart解析的复杂性，上述代码可能需要进一步测试和优化。 最后，我们给出完整代码（包括必要的头文件和辅助函数）： </think> 以下是使用C语言解析HTTP multipart/form-data协议的详细实现。该协议常用于文件上传和表单提交，需要处理边界(boundary)分隔的多部分数据。 ### 解决方案 我们将实现一个multipart解析器，主要步骤包括： 1. 从Content-Type头中提取boundary 2. 根据boundary分割多部分数据 3. 解析每个部分的头部和内容 4. 处理二进制文件数据 ```c #include <stdio.h> #include <stdlib.h> #include <string.h> #include <ctype.h> typedef struct { char* name; // 字段名 char* filename; // 文件名 char* content_type; // 内容类型 char* data; // 数据指针 size_t data_size; // 数据大小 } MultipartPart; typedef struct { MultipartPart* parts; // 多部分数组 size_t count; // 部分数量 } MultipartData; // 查找字符串在内存中的位置（二进制安全） const char* memfind(const char* haystack, size_t haystack_len, const char* needle, size_t needle_len) { if (needle_len == 0) return haystack; if (haystack_len < needle_len) return NULL; for (size_t i = 0; i <= haystack_len - needle_len; i++) { if (memcmp(haystack + i, needle, needle_len) == 0) { return haystack + i; } } return NULL; } // 解析multipart/form-data数据 MultipartData parse_multipart(const char* data, size_t data_len, const char* boundary) { MultipartData result = {NULL, 0}; if (!data || data_len == 0 || !boundary) return result; // 构造完整边界（带前置"--"） char full_boundary[256]; snprintf(full_boundary, sizeof(full_boundary), "--%s", boundary); const size_t boundary_len = strlen(full_boundary); // 结束边界（带"--"后缀） char end_boundary[256]; snprintf(end_boundary, sizeof(end_boundary), "%s--", full_boundary); const size_t end_boundary_len = strlen(end_boundary); const char* current = data; size_t remaining = data_len; // 预分配空间存储解析结果 result.parts = malloc(10 * sizeof(MultipartPart)); size_t capacity = 10; while (remaining > boundary_len) { // 查找下一个边界位置 const char* next_boundary = memfind(current, remaining, full_boundary, boundary_len); if (!next_boundary) break; // 跳过当前边界 const char* part_start = next_boundary + boundary_len; // 检查是否结束边界 if (memcmp(part_start, "--", 2) == 0) break; // 跳过CRLF if (memcmp(part_start, "\r\n", 2) == 0) part_start += 2; // 查找下一个边界或结束边界 const char* part_end = memfind(part_start, remaining - (part_start - current), full_boundary, boundary_len); if (!part_end) { // 尝试匹配结束边界 part_end = memfind(part_start, remaining - (part_start - current), end_boundary, end_boundary_len); if (!part_end) break; } // 计算当前部分大小 size_t part_size = part_end - part_start; // 移除尾部CRLF（如果存在） if (part_size >= 2 && memcmp(part_end - 2, "\r\n", 2) == 0) { part_size -= 2; } // 查找头部结束位置（空行） const char* headers_end = memfind(part_start, part_size, "\r\n\r\n", 4); if (!headers_end) { current = part_end; remaining = data_len - (current - data); continue; } // 准备新部分 if (result.count >= capacity) { capacity *= 2; result.parts = realloc(result.parts, capacity * sizeof(MultipartPart)); } MultipartPart* part = &result.parts[result.count]; memset(part, 0, sizeof(MultipartPart)); // 解析头部 size_t headers_size = headers_end - part_start; char* headers = malloc(headers_size + 1); memcpy(headers, part_start, headers_size); headers[headers_size] = '\0'; // 提取内容类型和内容位置 part->data = (char*)(headers_end + 4); part->data_size = part_start + part_size - (headers_end + 4); // 处理头部字段 char* line = strtok(headers, "\r\n"); while (line) { if (strstr(line, "Content-Disposition:")) { // 提取字段名 char* name_start = strstr(line, "name=\""); if (name_start) { name_start += 6; char* name_end = strchr(name_start, '"'); if (name_end) { size_t name_len = name_end - name_start; part->name = malloc(name_len + 1); strncpy(part->name, name_start, name_len); part->name[name_len] = '\0'; } } // 提取文件名 char* filename_start = strstr(line, "filename=\""); if (filename_start) { filename_start += 10; char* filename_end = strchr(filename_start, '"'); if (filename_end) { size_t filename_len = filename_end - filename_start; part->filename = malloc(filename_len + 1); strncpy(part->filename, filename_start, filename_len); part->filename[filename_len] = '\0'; } } } else if (strstr(line, "Content-Type:")) { // 提取内容类型 char* type_start = line + 13; while (*type_start && isspace(*type_start)) type_start++; size_t type_len = strlen(type_start); part->content_type = malloc(type_len + 1); strcpy(part->content_type, type_start); } line = strtok(NULL, "\r\n"); } free(headers); result.count++; // 移动到下一部分 current = part_end; remaining = data_len - (current - data); } return result; } // 释放multipart解析结果 void free_multipart(MultipartData* data) { for (size_t i = 0; i < data->count; i++) { MultipartPart* part = &data->parts[i]; free(part->name); free(part->filename); free(part->content_type); // 注意：data指向原始数据，不单独释放 } free(data->parts); data->parts = NULL; data->count = 0; } int main() { // 示例multipart数据（实际使用中应从HTTP请求获取） const char* data = "--BOUNDARY123\r\n" "Content-Disposition: form-data; name=\"username\"\r\n\r\n" "John Doe\r\n" "--BOUNDARY123\r\n" "Content-Disposition: form-data; name=\"avatar\"; filename=\"profile.jpg\"\r\n" "Content-Type: image/jpeg\r\n\r\n" "JPEG_DATA_HERE\r\n" "--BOUNDARY123--"; size_t data_len = strlen(data); const char* boundary = "BOUNDARY123"; // 解析multipart数据 MultipartData multipart = parse_multipart(data, data_len, boundary); // 打印解析结果 for (size_t i = 0; i < multipart.count; i++) { MultipartPart* part = &multipart.parts[i]; printf("Part %zu:\n", i + 1); printf(" Name: %s\n", part->name ? part->name : "(null)"); printf(" Filename: %s\n", part->filename ? part->filename : "(null)"); printf(" Content-Type: %s\n", part->content_type ? part->content_type : "(null)"); printf(" Data size: %zu bytes\n", part->data_size); // 打印文本内容（如果是文本） if (!part->filename && part->data_size < 100) { printf(" Data: %.*s\n", (int)part->data_size, part->data); } printf("\n"); } // 清理资源 free_multipart(&multipart); return 0; } ``` ### 代码解释 1. **核心数据结构**: - `MultipartPart`: 存储单个表单字段的信息 - `MultipartData`: 存储整个解析结果 2. **关键函数**: - `memfind()`: 二进制安全的字符串查找函数 - `parse_multipart()`: 主解析函数，处理boundary识别和部分提取 - `free_multipart()`: 释放分配的内存资源 3. **解析流程**: - 构造完整boundary（带"--"前缀） - 遍历数据查找boundary位置 - 提取各部分内容并解析头部 - 处理Content-Disposition和Content-Type头部 - 分离头部和主体数据 4. **特殊处理**: - 自动处理CRLF换行符 - 识别结束boundary（带"--"后缀） - 正确处理文件名和内容类型 - 避免数据复制（直接引用原始数据） 5. **内存管理**: - 动态分配存储解析结果 - 提供资源释放函数 - 原始数据不复制（调用者需保持有效） ### 使用注意事项 1. 此实现假设输入数据是完整的、格式正确的multipart数据 2. 对于大型文件，建议使用流式处理而非一次性加载全部数据 3. 实际使用中需要从HTTP请求头获取boundary值 4. 处理二进制数据时需注意指针和大小计算