c - 为文件创建自定义 header (元数据)

Question

在这里，我想创建一个包含其他文件详细信息（如其他文件的元数据）的头。
如果我对struct file_header使用静态值，则此代码可以正常工作。
如果我使用malloc表示struct file_header，则此代码有问题。
具体来说，我在fread中遇到了一个问题也许fwrite工作得很好。
代码在这里：

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <dirent.h>
#include <string.h>

char path[1024] = "/home/test/main/Integration/testing/package_DIR";

//int count = 5;

struct files {

    char *file_name;
    int file_size;
};

typedef struct file_header {

    int file_count;
    struct files file[5];
} metadata;


metadata *create_header();

int main() {
    FILE *file = fopen("/home/test/main/Integration/testing/file.txt", "w");
    metadata *header;
    header = create_header();
    if(header != NULL)
    {
        printf("size of Header is %d\n",sizeof(header));
    }

    if (file != NULL) {

        if (fwrite(&header, sizeof(header), 1, file) < 1) {
            puts("short count on fwrite");
        }
        fclose(file);
    }
    file = fopen("/home/test/main/Integration/testing/file.txt", "rb");
    if (file != NULL) {
        metadata header = { 0 };
        if (fread(&header, sizeof(header), 1, file) < 1) {
            puts("short count on fread");
        }
        fclose(file);
        printf("File Name = %s\n", header.file[0].file_name);
        printf("File count = %d\n", header.file_count);
        printf("File Size = %d\n", header.file[0].file_size);
    }
    return 0;
}

metadata *create_header()
{
    int file_count = 0;
    DIR * dirp;
    struct dirent * entry;
    dirp = opendir(path);
    metadata *header = (metadata *)malloc(sizeof(metadata));
    while ((entry = readdir(dirp)) != NULL) {
        if (entry->d_type == DT_REG) { /* If the entry is a regular file */

            header->file[file_count].file_name = (char *)malloc(sizeof(char)*strlen(entry->d_name));
            strcpy(header->file[file_count].file_name,entry->d_name);
            //Put static but i have logic for this i will apply later.
            header->file[file_count].file_size = 10;
            file_count++;

        }
    }
    header->file_count = file_count;
    closedir(dirp);
    //printf("File Count : %d\n", file_count);
    return header;
}

输出：

size of Header is 8
short count on fread
File Name = (null)
File count = 21918336
File Size = 0

有谁能帮我解决这个问题吗？

Answer 1

您正在64位计算机上工作，因为指针的长度为8字节。
您试图将数据写入文件，然后再将其读回你遇到了问题，因为指针写得不好（更准确地说：指针可以毫无问题地写入，但指针只在当前运行的程序中有意义，而且很少适合写入磁盘，甚至很少适合从磁盘读取数据。）
代码的这一部分说明了问题：

struct files {
    char *file_name;
    int file_size;
};

typedef struct file_header {
    int file_count;
    struct files file[5];
} metadata;


metadata *create_header();

int main() {
    FILE *file = fopen("/home/test/main/Integration/testing/file.txt", "w");
    metadata *header;
    header = create_header();
    if(header != NULL)
    {
        printf("size of Header is %d\n",sizeof(header));
    }

旁注：
将文件名设置为 main()的参数，或者至少设置为变量把名字写两遍就很难改了。
很好，你正在做一些错误检测。不过，我不会批评它，尽管它还有相当大的改进空间。
主要意见：
在输出中可以看到 size of Header is 8，因为 header是一个指针 sizeof(metadata)（指向的类型）要大得多，可能是48字节，但这取决于编译器如何在结构中对齐和打包数据。

if (file != NULL) {    
    if (fwrite(&header, sizeof(header), 1, file) < 1) {
        puts("short count on fwrite");
    }
    fclose(file);
}

此代码将8字节的数据写入文件。它所写的是存储 header变量的地址它不写任何它指向的数据。
更接近你所追求的（但仍不打算工作）的是：

        if (fwrite(header, sizeof(*header), 1, file) < 1) {
            puts("short count on fwrite");
        }

这将向文件中写入大约48字节但是，您的文件不包含文件名；它只包含指向文件写入时存储文件名的位置的指针这里要非常小心如果您阅读此文件，您甚至可能会看到它似乎工作，因为名称可能尚未从内存中删除。
要将文件名放入文件中，必须分别处理每个文件名你得决定一个会议。例如，您可以决定该名称的前缀是一个2字节的 header，它包含文件名的长度L，然后是包含文件名及其终端NUL unsigned short的L+1字节数据然后编写每个文件数据的其他（固定大小）部分。对每个文件重复这个过程读取文件的逆向操作需要理解所写的结构在期望文件名的位置，您将读取两个字节的长度，并且可以使用该长度为文件名分配空间然后将L+1字节读入新分配的文件名然后读取该文件的其他固定长度数据，然后移动到下一个文件。
如果您想在一个 '\0'然后 fwrite()中完成所有操作，则必须修改数据结构：

struct files {
    char  file_name[MAX_PERMITTED_FILENAME_LENGTH];
    int   file_size;
};

你可以决定最大允许的文件名长度是多少，但是它是固定的。如果你的名字很短，就不用全部空格；如果你的名字很长，就可能被截断您的 fread()结构大小现在显著增加（至少如果 metadata是一个合理的大小，比如在32到1024字节之间）。但是您可以用这个在单个操作中读写整个 MAX_PERMITTED_FILENAME_LENGTH结构。
谢谢你的答复，但我是新来的，所以我如何才能做到这一点？
最终，您将能够像这样编写代码。

#include <dirent.h>
#include <errno.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

enum { MAX_FILES = 5 };

struct files
{
    char *file_name;
    int file_size;
};

typedef struct file_header
{
    int file_count;
    struct files file[MAX_FILES];
} metadata;

static void err_exit(const char *format, ...);
static metadata *create_header(const char *directory);
static void release_header(metadata *header);
static void write_header(FILE *fp, const metadata *header);
static metadata *read_header(FILE *fp);
static void dump_header(FILE *fp, const char *tag, const metadata *header);

int main(int argc, char **argv)
{
    if (argc != 3)
        err_exit("Usage: %s file directory\n", argv[0]);

    const char *name = argv[1];
    const char *path = argv[2];
    FILE *fp = fopen(name, "wb");

    if (fp == 0)
        err_exit("Failed to open file %s for writing (%d: %s)\n", name, errno, strerror(errno));

    metadata *header = create_header(path);
    dump_header(stdout, "Data to be written", header);
    write_header(fp, header);
    fclose(fp);                     // Ignore error on close
    release_header(header);

    if ((fp = fopen(name, "rb")) == 0)
        err_exit("Failed to open file %s for reading (%d: %s)\n", name, errno, strerror(errno));

    metadata *read_info = read_header(fp);
    dump_header(stdout, "Data as read", read_info);
    release_header(read_info);

    fclose(fp);                     // Ignore error on close
    return 0;
}

static metadata *create_header(const char *path)
{
    int file_count = 0;
    DIR * dirp = opendir(path);
    struct dirent * entry;
    if (dirp == 0)
        err_exit("Failed to open directory %s (%d: %s)\n", path, errno, strerror(errno));
    metadata *header = (metadata *)malloc(sizeof(metadata));
    if (header == 0)
        err_exit("Failed to malloc space for header (%d: %s)\n", errno, strerror(errno));

    header->file_count = 0;
    while ((entry = readdir(dirp)) != NULL && file_count < MAX_FILES)
    {
        // d_type is not portable - POSIX says you can only rely on d_name and d_ino
        if (entry->d_type == DT_REG)
        {   /* If the entry is a regular file */
            // Avoid off-by-one under-allocation by using strdup()
            header->file[file_count].file_name = strdup(entry->d_name);
            if (header->file[file_count].file_name == 0)
                err_exit("Failed to strdup() file %s (%d: %s)\n", entry->d_name, errno, strerror(errno));
            //Put static but i have logic for this i will apply later.
            header->file[file_count].file_size = 10;
            file_count++;
        }
    }
    header->file_count = file_count;
    closedir(dirp);
    //printf("File Count : %d\n", file_count);
    return header;
}

static void write_header(FILE *fp, const metadata *header)
{
    if (fwrite(&header->file_count, sizeof(header->file_count), 1, fp) != 1)
        err_exit("Write error on file count (%d: %s)\n", errno, strerror(errno));
    const struct files *files = header->file;
    for (int i = 0; i < header->file_count; i++)
    {
        unsigned short name_len = strlen(files[i].file_name) + 1;
        if (fwrite(&name_len, sizeof(name_len), 1, fp) != 1)
            err_exit("Write error on file name length (%d: %s)\n", errno, strerror(errno));
        if (fwrite(files[i].file_name, name_len, 1, fp) != 1)
            err_exit("Write error on file name (%d: %s)\n", errno, strerror(errno));
        if (fwrite(&files[i].file_size, sizeof(files[i].file_size), 1, fp) != 1)
            err_exit("Write error on file size (%d: %s)\n", errno, strerror(errno));
    }
}

static metadata *read_header(FILE *fp)
{
    metadata *header = malloc(sizeof(*header));
    if (header == 0)
        err_exit("Failed to malloc space for header (%d:%s)\n", errno, strerror(errno));
    if (fread(&header->file_count, sizeof(header->file_count), 1, fp) != 1)
        err_exit("Read error on file count (%d: %s)\n", errno, strerror(errno));
    struct files *files = header->file;
    for (int i = 0; i < header->file_count; i++)
    {
        unsigned short name_len;
        if (fread(&name_len, sizeof(name_len), 1, fp) != 1)
            err_exit("Read error on file name length (%d: %s)\n", errno, strerror(errno));
        files[i].file_name = malloc(name_len);
        if (files[i].file_name == 0)
            err_exit("Failed to malloc space for file name (%d:%s)\n", errno, strerror(errno));
        if (fread(files[i].file_name, name_len, 1, fp) != 1)
            err_exit("Read error on file name (%d: %s)\n", errno, strerror(errno));
        if (fread(&files[i].file_size, sizeof(files[i].file_size), 1, fp) != 1)
            err_exit("Read error on file size (%d: %s)\n", errno, strerror(errno));
    }
    return(header);
}

static void dump_header(FILE *fp, const char *tag, const metadata *header)
{
    const struct files *files = header->file;
    fprintf(fp, "Metadata: %s\n", tag);
    fprintf(fp, "File count: %d\n", header->file_count);
    for (int i = 0; i < header->file_count; i++)
        fprintf(fp, "File %d: size %5d, name %s\n", i, files[i].file_size, files[i].file_name);
}

static void release_header(metadata *header)
{
    for (int i = 0; i < header->file_count; i++)
    {
        /* Zap file name, and pointer to file name */
        memset(header->file[i].file_name, 0xDD, strlen(header->file[i].file_name)+1);
        free(header->file[i].file_name);
        memset(&header->file[i].file_name, 0xEE, sizeof(header->file[i].file_name));
    }
    free(header);
}

static void err_exit(const char *format, ...)
{
    va_list args;
    va_start(args, format);
    vfprintf(stderr, format, args);
    va_end(args);
    exit(EXIT_FAILURE);
}

我将其编译为 metadata，并按如下所示运行：

$ dump_file xyz .
Metadata: Data to be written
File count: 5
File 0: size    10, name .gitignore
File 1: size    10, name args.c
File 2: size    10, name atob.c
File 3: size    10, name bp.pl
File 4: size    10, name btwoc.c
Metadata: Data as read
File count: 5
File 0: size    10, name .gitignore
File 1: size    10, name args.c
File 2: size    10, name atob.c
File 3: size    10, name bp.pl
File 4: size    10, name btwoc.c
$ odx xyz
0x0000: 05 00 00 00 0B 00 2E 67 69 74 69 67 6E 6F 72 65   .......gitignore
0x0010: 00 0A 00 00 00 07 00 61 72 67 73 2E 63 00 0A 00   .......args.c...
0x0020: 00 00 07 00 61 74 6F 62 2E 63 00 0A 00 00 00 06   ....atob.c......
0x0030: 00 62 70 2E 70 6C 00 0A 00 00 00 08 00 62 74 77   .bp.pl.......btw
0x0040: 6F 63 2E 63 00 0A 00 00 00                        oc.c.....
0x0049:
$

我可能应该将 dump_file重命名为 err_exit()并修改错误处理，以便 err_sysexit()和相应的字符串在该函数中进行处理，而不是重复地将 errno和 errno添加到对 strerror(errno)的调用中。
评论中的信息
把一些相当广泛的评论转移到这个问题上：
我尝试了上面的代码，但是在 err_exit()之后出现了分段错误，这意味着数据写入工作正常，但数据读取有问题。 Nimit
我尝试了上面的代码，当我从文件中读取数据时出现了分段错误 user1089679
哎哟： File : 4正在警告我有关 valgrind中的无效写入那会把事情搞砸的不过，这并不难解决，这是导致这场恶作剧的第二个原因；我不小心遗漏了与号：

memset( header->file[i].file_name, 0xEE, sizeof(header->file[i].file_name));  // Broken
memset(&header->file[i].file_name, 0xEE, sizeof(header->file[i].file_name));  // Correct

这在代码中是固定的。请注意，这两个 release_header()操作都在代码中，以确保如果内存被重用，则它不包含以前的有效数据，这是一个风险，因为代码最初是将指针写到磁盘上，然后再将其读回 memset()调用不会出现在正常的生产代码中。
请注意， release_header()是一个自制十六进制转储程序（默认情况下，Mac OS X没有 memset()程序）您的系统可能已经有 memset()用于hex dump，或者您可以尝试 hd或尝试自己的Google Fu来寻找替代方案。
只是想问一下，我想在跨平台上运行这个程序，那么低位机有什么问题吗？ Nimit
在大型EnDIN或小型EnDead机器上没有这个代码，如果你把数据从一个小字节（英特尔）机器到一个大字节（SPARC，PPC，…）机器，反之亦然，那就有问题了。代码可能对32位和64位构建也很敏感；我没有将字段大小定义为n位，而是定义为方便的类型，例如可以在系统之间更改的I n t如果需要可移植的数据，请确定字段大小（主要是1、2、4、8字节，至少对于非字符串数据是这样），然后以标准方式将其写入-MSB优先（big endian）或LSB优先（little endian）。