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