《APUE.3E》用gdb调试ftw函数（图4-22）

所谓的ftw函数，就是降序遍历文件层次结构，对各种类型的文件计数
solaris上提供的ftw函数对每一个文件都是使用stat函数，这就会使得程序跟随符号链接，造成可能会由于成环的符号链接导致的多次重复处理同一个目录的问题，下面的apue.3e中图4-22使用了lstat阻止跟随符号链接的问题。为记录自己的学习，下面代码中加上自己的部分注释以及调试过程。

#include "apue.h"
#include <dirent.h>
#include <limits.h>

/* function type that is called for each filename */
typedef    int    Myfunc(const char *, const struct stat *, int);

static Myfunc    myfunc;
static int        myftw(char *, Myfunc *);
static int        dopath(Myfunc *);

static long    nreg, ndir, nblk, nchr, nfifo, nslink, nsock, ntot;

int
main(int argc, char *argv[])
{
    int        ret;

    if (argc != 2)
        err_quit("usage:  ftw  <starting-pathname>");

    ret = myftw(argv[1], myfunc);        /* 调用myftw函数 */

    ntot = nreg + ndir + nblk + nchr + nfifo + nslink + nsock;
    if (ntot == 0)
        ntot = 1;        /* avoid divide by 0; print 0 for all counts */
    printf("regular files  = %7ld, %5.2f %%\n", nreg,
      nreg*100.0/ntot);
    printf("directories    = %7ld, %5.2f %%\n", ndir,
      ndir*100.0/ntot);
    printf("block special  = %7ld, %5.2f %%\n", nblk,
      nblk*100.0/ntot);
    printf("char special   = %7ld, %5.2f %%\n", nchr,
      nchr*100.0/ntot);
    printf("FIFOs          = %7ld, %5.2f %%\n", nfifo,
      nfifo*100.0/ntot);
    printf("symbolic links = %7ld, %5.2f %%\n", nslink,
      nslink*100.0/ntot);
    printf("sockets        = %7ld, %5.2f %%\n", nsock,
      nsock*100.0/ntot);
    exit(ret);
}

/*
 * Descend through the hierarchy, starting at "pathname".
 * The caller's func() is called for every file.
 */
#define    FTW_F    1        /* file other than directory */
#define    FTW_D    2        /* directory */
#define    FTW_DNR    3        /* directory that can't be read */
#define    FTW_NS    4        /* file that we can't stat */

static char    *fullpath;        /* contains full pathname for every file */
static size_t pathlen;

static int                    /* we return whatever func() returns */
myftw(char *pathname, Myfunc *func)
{
    fullpath = path_alloc(&pathlen); 
    /* 该函数见下面另一个程序，就是为fullpath分配PATH_MAX+1 bytes的空间，并返回其地址，这里调试的时候pathlen为4096 */
    if (pathlen <= strlen(pathname)) {
        pathlen = strlen(pathname) * 2;
        if ((fullpath = realloc(fullpath, pathlen)) == NULL)
            err_sys("realloc failed");
    }
    strcpy(fullpath, pathname);
    return(dopath(func));//从这里进入dopath函数，直到所有都处理完了才返回这儿，再返回main
}

/*
 * Descend through the hierarchy, starting at "fullpath".
 * If "fullpath" is anything other than a directory, we lstat() it,
 * call func(), and return.  For a directory, we call ourself
 * recursively for each name in the directory.
 */
static int                    /* we return whatever func() returns */
dopath(Myfunc* func)
{
    struct stat        statbuf;
    struct dirent    *dirp;
    DIR                *dp;
    int                ret, n;

    if (lstat(fullpath, &statbuf) < 0)    /* stat error */
        return(func(fullpath, &statbuf, FTW_NS));

       /* not a directory */
       //这里不是目录的文件，直接处理完就返回上一层了
    if (S_ISDIR(statbuf.st_mode) == 0)
        return(func(fullpath, &statbuf, FTW_F));

    /*
     * It's a directory.  First call func() for the directory,
     * then process each filename in the directory.
     */
     //这里是目录返回值不是0的情况不会发生，因为myfunc总是返回0
    if ((ret = func(fullpath, &statbuf, FTW_D)) != 0)
        return(ret);

    n = strlen(fullpath);
    if (n + NAME_MAX + 2 > pathlen) {    /* expand path buffer */
        pathlen *= 2;
        if ((fullpath = realloc(fullpath, pathlen)) == NULL)
            err_sys("realloc failed");
    }
    fullpath[n++] = '/';
    fullpath[n] = 0;

    if ((dp = opendir(fullpath)) == NULL)    /* can't read directory */
        return(func(fullpath, &statbuf, FTW_DNR));
    //while循环不停地取dir中的目录项名字，拼凑好再进入
    while ((dirp = readdir(dp)) != NULL) {
        if (strcmp(dirp->d_name, ".") == 0  ||
            strcmp(dirp->d_name, "..") == 0)
                continue;        /* ignore dot and dot-dot */
        strcpy(&fullpath[n], dirp->d_name);    /* append name after "/" */
        if ((ret = dopath(func)) != 0)        /* 这里递归处理该文件夹下所有的文件*/
            break;    /* time to leave */
    }
    //这一个目录下所有都遍历完了，就把当前fullpath后面下级目录扔了（中间加\0）
    fullpath[n-1] = 0;    /* erase everything from slash onward */

    if (closedir(dp) < 0)
        err_ret("can't close directory %s", fullpath);
    return(ret);//返回上一级目录
}

static int
myfunc(const char *pathname, const struct stat *statptr, int type)
{
    switch (type) {
    case FTW_F:
        switch (statptr->st_mode & S_IFMT) {
        case S_IFREG:    nreg++;        break;
        case S_IFBLK:    nblk++;        break;
        case S_IFCHR:    nchr++;        break;
        case S_IFIFO:    nfifo++;    break;
        case S_IFLNK:    nslink++;    break;
        case S_IFSOCK:    nsock++;    break;
        case S_IFDIR:    /* directories should have type = FTW_D */
            err_dump("for S_IFDIR for %s", pathname);
        }
        break;
    case FTW_D:
        ndir++;
        break;
    case FTW_DNR:
        err_ret("can't read directory %s", pathname);
        break;
    case FTW_NS:
        err_ret("stat error for %s", pathname);
        break;
    default:
        err_dump("unknown type %d for pathname %s", type, pathname);
    }
    return(0);
}

/* ({Prog pathalloc}) */
下面是pathalloc函数：

#include "apue.h"
#include <errno.h>
#include <limits.h>

#ifdef    PATH_MAX
static long    pathmax = PATH_MAX;
#else
static long    pathmax = 0;
#endif

static long    posix_version = 0;
static long    xsi_version = 0;

/* If PATH_MAX is indeterminate, no guarantee this is adequate */
#define    PATH_MAX_GUESS    1024

char *
path_alloc(size_t *sizep) /* also return allocated size, if nonnull */
{
    char    *ptr;
    size_t    size;

    if (posix_version == 0)
        posix_version = sysconf(_SC_VERSION);

    if (xsi_version == 0)
        xsi_version = sysconf(_SC_XOPEN_VERSION);

    if (pathmax == 0) 
    {        /* first time through */
        errno = 0;
        if ((pathmax = pathconf("/", _PC_PATH_MAX)) < 0)
        {
            if (errno == 0)
                pathmax = PATH_MAX_GUESS;    /* it's indeterminate */
            else
                err_sys("pathconf error for _PC_PATH_MAX");
        } 
        else {
            pathmax++;        /* add one since it's relative to root */
        }
    }

    /*
     * Before POSIX.1-2001, we aren't guaranteed that PATH_MAX includes
     * the terminating null byte.  Same goes for XPG3.
     */
    if ((posix_version < 200112L) && (xsi_version < 4))
        size = pathmax + 1;
    else
        size = pathmax;

    if ((ptr = malloc(size)) == NULL)
        err_sys("malloc error for pathname");

    if (sizep != NULL)
        *sizep = size;
    return(ptr);
}

下面是用gdb调试过程：
1.新建用来遍历的目录结构，简单的结构便于单步调试

2.进入gdb调试界面后，打断点，单步运行，并注意变量变化

3.step或next进入单步调试，查看关键变量：

fullpath为选择进入的第一级目录

4.查看第一次遍历的目录或文件的dirp->d_name

5.第一次遍历的是个文件c：

6.第二次遍历的是test2文件夹，并由此进入test2/下面：

7.递归进入test2文件夹，查看其文件夹结构：

8.遍历完子目录后回到test/遍历下一个目录项，这里是文件b

9.遍历完所有的项后回到了买你，统计结果：

统计结果正确