c - 传递不同目录的文件名时 Stat 函数不起作用

Question

这个问题已经有答案了:

Why does stat fail using a name from readdir? [duplicate] (1 个回答)

stat() error 'No such file or directory' when file name is returned by readdir() (2 个回答)

已关闭 去年。

我正在尝试实现 ls命令并陷入 -i使用 stat() 选项列出 inode 编号的函数。

格式为./myls [options] [list of files]

如果我运行./myls -i .我得到正确的输出(这会打印当前目录中的文件)

./myls -i
1446018     myls.c
1441809     myls
1445497     something

如果我运行 ./myls ..我得到正确的输出(打印父目录中的文件)

./myls ..
Assignment2
Assignment3
Assignment4
Assignment1

但是如果将它们与父目录合并并运行 ./myls -i ..我收到错误消息

/myls -i ..
Error finding file: No such file or directory

“错误查找文件”是我在 ls 中打印的错误消息功能。

//printf("%s", name);
if (stat(name, fileStat) != 0) {
    error("Error finding file");
}

如果我取消注释 printf在此错误消息之前声明，我得到以下内容

/myls -i ..
Assignment2
Error finding file: No such file or directory

因此它正在获取父目录的第一个文件的名称，但 stat 函数失败。有人知道我该如何解决这个问题吗？

我在某处读到它可能会失败，因为它只传递文件的名称而不是其路径。但这适用于当前目录，因此这可能不是问题。如果是，那么我将如何传递路径而不仅仅是文件名？

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

int i = 0, R = 0, l = 0;
int anyFiles = 0;

void error(char *msg) {
    perror(msg);
    exit(0);
}

void ls(char *path) {
    DIR *d;
    struct dirent *dir;
    d = opendir(path);
    if (!d || d == NULL)
        error("Unable to read directory");

    char name[256]; //to store file name of each file in directory

    while ((dir = readdir(d)) != NULL) {
        strcpy(name, dir -> d_name);
        if (name[0] == '.' || strncmp(name, "..", 2) == 0)
            continue;

        if (i || R || l) {
            struct stat *fileStat;

            //printf("%s\n",name);
            if (stat(name, fileStat) != 0) {
                error("Error finding file");
            }

            if (i) {
                printf("%lu\t\t%s\n", fileStat->st_ino, name);
                continue;
            }
            /*else if (R) {
                continue;
            }
            else if (l) {
                continue;
            }*/
        }
        printf("%s\n", name);
    }
    closedir(d);
}

void process(int args, char *argsList[]) {
    int j; 
    for (j = 1; j < args; j++) {
        if (argsList[j][0] == '-') {
            int k;
            for (k = 1; k < (strlen(argsList[j])); k++) {
                if (argsList[j][k] == 'i')
                    i = 1;
                else if (argsList[j][k] == 'R')
                    R =  1;
                else if (argsList[j][k] == 'l')
                    l = 1;
                else
                    error("option not supported");
            }
        }
        else if (argsList[j][0] != '-') {
            ls(argsList[j]);
            anyFiles = 1;
        }
    }
    if (anyFiles == 0)
        ls(".");
}

int main(int argc, char *argv[]) {
    if (argc == 1)
        ls(".");
    else if (argc > 1) {
        process(argc, argv); 
    }
    return 0;
}

Answer 1

传递给 stat(name, fileStat) 中的 stat 的名称是相对于打开的目录的。您必须从 path 和 dir->d_name 构造实际名称，或者使用 fstatat()。它适用于 "." 因为相对路径恰好是相对于当前目录的。

此外，stat 结构应该声明为自动存储，而不是作为未初始化的指针。

请注意，ls 实用程序在枚举目录内容和命令行参数时不使用 stat，而是使用 lstat 返回符号值链接而不是解析它们，除非它们有尾部斜杠并解析为目录。

这是一个修改后的版本，修复了许多其他问题:

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

int flag_a, flag_i, flag_R, flag_l;

typedef struct entry_t {
    struct entry_t *next;
    char name[];
} entry_t;

typedef struct list_t {
    struct entry_t *head;
    struct entry_t *tail;
} list_t;

void free_entries(list_t *list) {
    while (list->head) {
        entry_t *ep = list->head;
        list->head = ep->next;
        free(ep);
    }
    list->tail = NULL;
}

void add_entry(list_t *list, const char *name) {
    entry_t *ep = malloc(sizeof(*ep) + strlen(name) + 1);
    if (ep == NULL) {
        fprintf(stderr, "out of memory\n");
        exit(1);
    }
    strcpy(ep->name, name);
    /* simplistic insertion sort */
    if (!list->head || strcmp(name, list->head->name) < 0) {
        ep->next = list->head;
        list->head = ep;
        if (list->tail == NULL)
            list->tail = ep;
    } else {
        entry_t *p = list->head;
        while (p->next && strcmp(name, p->next->name) > 0)
            p = p->next;
        ep->next = p->next;
        p->next = ep;
    }
    if (list->tail->next)
        list->tail = list->tail->next;
}

int isdir(const char *name) {
    struct stat fileStat;
    return !lstat(name, &fileStat) && S_ISDIR(fileStat.st_mode);
}

int ls_files(list_t *list, list_t *dirs, const char *path) {
    int status = 0;

    for (entry_t *ep = list->head; ep; ep = ep->next) {
        if (flag_i + flag_l + flag_R) {
            char buf[1024]; //to store the constructed path name
            struct stat fileStat;
            char *name = ep->name;
            if (path) {
                snprintf(name = buf, sizeof buf, "%s/%s", path, ep->name);
            }
            if (lstat(name, &fileStat) != 0) {
                fprintf(stderr, "cannot stat file %s: %s\n",
                        name, strerror(errno));
                status |= 1;
                continue;
            }
            if (flag_R && S_ISDIR(fileStat.st_mode) &&
                strcmp(ep->name, ".") && strcmp(ep->name, "..")) {
                add_entry(dirs, name);
            }
            if (flag_i) {
                printf("%lu\t", (unsigned long)fileStat.st_ino);
            }
            if (flag_l) {
                printf("%lu\t", (unsigned long)fileStat.st_size);
                /* should also output mode and date */
            }
        }
        printf("%s\n", ep->name);
    }
    return status;
}

int ls_dir(const char *path, list_t *subdirs) {
    DIR *d = opendir(path);
    if (d == NULL) {
        fprintf(stderr, "cannot open directory %s: %s\n",
                path, strerror(errno));
        return 1;
    }

    struct dirent *dir;
    list_t files = { NULL, NULL };

    /* enumerate directory entries and store the names in a sorted list */
    while ((dir = readdir(d)) != NULL) {
        if (*dir->d_name == '.' && !flag_a)
            continue;
        add_entry(&files, dir->d_name);
    }
    closedir(d);
    int status = ls_files(&files, subdirs, path);
    free_entries(&files);
    return status;
}

int ls_dirs(list_t *dirs, int header) {
    int status = 0;
    list_t subdirs = { NULL, NULL };
    for (entry_t *ep = dirs->head; ep; ep = ep->next) {
        if (header) {
            if (header > 1)
                printf("\n");
            printf("%s:\n", ep->name);
        }
        ls_dir(ep->name, &subdirs);
        header = 2;
        if (subdirs.head) {
            /* insert the sorted list of subdirectories */
            subdirs.tail->next = ep->next;
            ep->next = subdirs.head;
            subdirs.head = subdirs.tail = NULL;
        }
    }
    return status;
}

int process(int args, char *argsList[]) {
    int status = 0;
    list_t files = { NULL, NULL };
    list_t dirs = { NULL, NULL };
    for (int j = 1; j < args; j++) {
        char *arg = argsList[j];
        if (*arg == '-') {
            for (int k = 1; arg[k] != '\0'; k++) {
                switch (arg[k]) {
                case 'a':  flag_a = 1;  continue;
                case 'i':  flag_i = 1;  continue;
                case 'R':  flag_R = 1;  continue;
                case 'l':  flag_l = 1;  continue;
                default:   fprintf(stderr, "option not supported: -%c\n", arg[k]);
                    return 1;
                }
            }
        } else {
            if (isdir(arg))
                add_entry(&dirs, arg);
            else
                add_entry(&files, arg);
        }
    }
    if (!dirs.head && !files.head) {
        add_entry(&dirs, ".");
    }
    int header = 0;
    if (files.head) {
        status |= ls_files(&files, &dirs, NULL);
        header = 2;
    }
    if (dirs.head) {
        if (!header && dirs.head->next)
            header = 1;
        status |= ls_dirs(&dirs, header);
    }
    free_entries(&files);
    free_entries(&dirs);
    return status;
}

int main(int argc, char *argv[]) {
    return process(argc, argv);
}