scan_dir.c

[詳解]

/*++
/* NAME
/*  scan_dir 3
/* SUMMARY
/*  directory scanning
/* SYNOPSIS
/*  #include <scan_dir.h>
/*
/*  SCAN_DIR *scan_dir_open(path)
/*  const char *path;
/*
/*  char    *scan_dir_next(scan)
/*  SCAN_DIR *scan;
/*
/*  char    *scan_dir_path(scan)
/*  SCAN_DIR *scan;
/*
/*  void    scan_push(scan, entry)
/*  SCAN_DIR *scan;
/*  const char *entry;
/*
/*  SCAN_DIR *scan_pop(scan)
/*  SCAN_DIR *scan;
/*
/*  SCAN_DIR *scan_dir_close(scan)
/*  SCAN_DIR *scan;
/* DESCRIPTION
/*  These functions scan directories for names. The "." and
/*  ".." names are skipped. Essentially, this is <dirent>
/*  extended with error handling and with knowledge of the
/*  name of the directory being scanned.
/*
/*  scan_dir_open() opens the named directory and
/*  returns a handle for subsequent use.
/*
/*  scan_dir_close() terminates the directory scan, cleans up
/*  and returns a null pointer.
/*
/*  scan_dir_next() returns the next requested object in the specified
/*  directory. It skips the "." and ".." entries.
/*
/*  scan_dir_path() returns the name of the directory being scanned.
/*
/*  scan_dir_push() causes the specified directory scan to enter the
/*  named subdirectory.
/*
/*  scan_dir_pop() leaves the directory being scanned and returns
/*  to the previous one. The result is the argument, null if no
/*  previous directory information is available.
/* DIAGNOSTICS
/*  All errors are fatal.
/* LICENSE
/* .ad
/* .fi
/*  The Secure Mailer license must be distributed with this software.
/* AUTHOR(S)
/*  Wietse Venema
/*  IBM T.J. Watson Research
/*  P.O. Box 704
/*  Yorktown Heights, NY 10598, USA
/*
/*  Wietse Venema
/*  Google, Inc.
/*  111 8th Avenue
/*  New York, NY 10011, USA
/*--*/

/* System library. */

#include <sys_defs.h>
#ifdef HAVE_DIRENT_H
#include <dirent.h>
#else
#define dirent direct
#ifdef HAVE_SYS_NDIR_H
#include <sys/ndir.h>
#endif
#ifdef HAVE_SYS_DIR_H
#include <sys/dir.h>
#endif
#ifdef HAVE_NDIR_H
#include <ndir.h>
#endif
#endif
#include <string.h>
#include <errno.h>

/* Utility library. */

#include "msg.h"
#include "mymalloc.h"
#include "stringops.h"
#include "vstring.h"
#include "scan_dir.h"

 /*
  * The interface is based on an opaque structure, so we don't have to expose
  * the user to the guts. Subdirectory info sits in front of parent directory
  * info: a simple last-in, first-out list.
  */
typedef struct SCAN_INFO SCAN_INFO;

struct SCAN_INFO {
    char   *path;           /* directory name */
    DIR    *dir;            /* directory structure */
    SCAN_INFO *parent;          /* linkage */
};
struct SCAN_DIR {
    SCAN_INFO *current;         /* current scan */
};

#define SCAN_DIR_PATH(scan) (scan->current->path)
#define STR(x)          vstring_str(x)

/* scan_dir_path - return the path of the directory being read.  */

char   *scan_dir_path(SCAN_DIR *scan)
{
    return (SCAN_DIR_PATH(scan));
}

/* scan_dir_push - enter directory */

void    scan_dir_push(SCAN_DIR *scan, const char *path)
{
    const char *myname = "scan_dir_push";
    SCAN_INFO *info;

    info = (SCAN_INFO *) mymalloc(sizeof(*info));
    if (scan->current)
    info->path = concatenate(SCAN_DIR_PATH(scan), "/", path, (char *) 0);
    else
    info->path = mystrdup(path);
    if ((info->dir = opendir(info->path)) == 0)
    msg_fatal("%s: open directory %s: %m", myname, info->path);
    if (msg_verbose > 1)
    msg_info("%s: open %s", myname, info->path);
    info->parent = scan->current;
    scan->current = info;
}

/* scan_dir_pop - leave directory */

SCAN_DIR *scan_dir_pop(SCAN_DIR *scan)
{
    const char *myname = "scan_dir_pop";
    SCAN_INFO *info = scan->current;
    SCAN_INFO *parent;

    if (info == 0)
    return (0);
    parent = info->parent;
    if (closedir(info->dir))
    msg_fatal("%s: close directory %s: %m", myname, info->path);
    if (msg_verbose > 1)
    msg_info("%s: close %s", myname, info->path);
    myfree(info->path);
    myfree((void *) info);
    scan->current = parent;
    return (parent ? scan : 0);
}

/* scan_dir_open - start directory scan */

SCAN_DIR *scan_dir_open(const char *path)
{
    SCAN_DIR *scan;

    scan = (SCAN_DIR *) mymalloc(sizeof(*scan));
    scan->current = 0;
    scan_dir_push(scan, path);
    return (scan);
}

/* scan_dir_next - find next entry */

char   *scan_dir_next(SCAN_DIR *scan)
{
    const char *myname = "scan_dir_next";
    SCAN_INFO *info = scan->current;
    struct dirent *dp;

#define STREQ(x,y)  (strcmp((x),(y)) == 0)

    if (info) {

    /*
     * Fix 20150421: readdir() does not reset errno after reaching the
     * end-of-directory. This dates back all the way to the initial
     * implementation of 19970309.
     */
    errno = 0;
    while ((dp = readdir(info->dir)) != 0) {
        if (STREQ(dp->d_name, ".") || STREQ(dp->d_name, "..")) {
        if (msg_verbose > 1)
            msg_info("%s: skip %s", myname, dp->d_name);
        continue;
        } else {
        if (msg_verbose > 1)
            msg_info("%s: found %s", myname, dp->d_name);
        return (dp->d_name);
        }
    }
    }
    return (0);
}

/* scan_dir_close - terminate directory scan */

SCAN_DIR *scan_dir_close(SCAN_DIR *scan)
{
    while (scan->current)
    scan_dir_pop(scan);
    myfree((void *) scan);
    return (0);
}