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)（ header指向的类型）要大得多，可能为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个字节的 unsigned short作为前缀，其中包含文件名的长度L，然后是包含文件名及其末尾NUL '\0'的L + 1个数据字节。然后，您将写入每个文件数据的其他（固定大小）部分。您将对每个文件重复此过程。读取文件的相反操作需要理解书面结构。在需要文件名的那一刻，您将读取两个字节的长度，并且可以使用该长度为文件名分配空间。然后，您将L + 1个字节读入新分配的文件名中。然后，读取文件的其他定长数据，然后移至下一个文件。

如果您希望能够在单个 fwrite()然后是 fread()中完成所有操作，则必须修改数据结构：

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

您可以决定允许的最大文件名长度是多少，但它是固定的。如果您的名字很短，那么您不会使用所有空格。如果您的名字很长，它们可能会被截断。现在，您的 metadata结构大小会急剧增加（至少如果 MAX_PERMITTED_FILENAME_LENGTH是合理的大小，例如32到1024字节之间）。但是，您可以通过一次操作读取和写入整个 metadata结构。




  感谢您的回复，但是我是C语言的新手，那么我该如何实现呢？


最终，您将能够像这样进行编码。

#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);
}

我将其编译为 dump_file，并如下所示运行它：

$ 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:
$

我可能应该将 err_exit()重命名为 err_sysexit()并修改错误处理，以便在该函数内处理 errno和相应的字符串，而不是将 errno和 strerror(errno)重复添加到对 err_exit()的调用中。



来自评论的信息

将一些相当广泛的评论转移到问题中：


  我尝试了上面的代码，但在 File : 4之后出现了分段错误，这意味着数据写入工作正常，但是我在读取数据时遇到了一些问题。 Nimit
  
  我尝试了上面的代码，但是从文件中读取数据时遇到了分段错误。 user1089679


糟糕： valgrind给我警告 release_header()中的无效写入。那会把事情搞砸。不过，这并不难解决-引起恶作剧的是 memset()中的第二个 release_header()。我不小心省略了＆符：

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

这在代码中已修复。请注意，这两个 memset()操作都在代码中，以确保如果内存被重用，则它不包含以前的有效数据，这是有风险的，因为该代码最初会将指针写到磁盘上，然后再次读取它们。 memset()调用不会出现在常规生产代码中。

请注意， odx是自制的十六进制转储程序（默认情况下，Mac OS X没有 hd程序）。您的系统可能已经有 hd用于十六进制转储，或者您可以尝试 hd或尝试使用自己的Google Fu查找替代方案。


  我只想问一个问题，我想在跨平台上运行此程序，那么低位计算机有什么问题吗？ Nimit


在大端或小端机器上，此代码都没有问题。如果您将数据从小端（Intel）计算机移至大端（SPARC，PPC等）计算机，反之亦然。该代码可能对32位和64位版本也很敏感。我没有将字段大小定义为n位，而是将int定义为可以在系统之间改变的便捷类型。如果要使用可移植数据，请确定字段大小（至少对于非字符串数据至少为1、2、4、8个字节），然后以标准方式写入-MSB优先（大端）或可能是LSB在前（小尾数法）。