Nginx中目录树的遍历

 

Nginx中遍历目录主要是通过ngx_walk_tree函数实现的，在分析该函数之前，先来看看与其相关的数据结构：

struct ngx_tree_ctx_s {
    off_t                                         size;
    off_t                                         fs_size;
    ngx_uint_t                               access;
    time_t                                      mtime;

    ngx_tree_init_handler_pt      init_handler;
    ngx_tree_handler_pt             file_handler;
    ngx_tree_handler_pt             pre_tree_handler;
    ngx_tree_handler_pt             post_tree_handler;
    ngx_tree_handler_pt             spec_handler;

    void                                       *data;
    size_t                                      alloc;

    ngx_log_t                              *log;
};

 

其中：

size：遍历到的文件的大小；

fs_size：指的是遍历到的文件的所占磁盘块数目乘以512的值与size中的最大值，即fs_size=ngx_max(size, st_blocks*512)；

access：指的是遍历到的文件的访问权限；

mtime：指的是遍历到的文件上次被修改的时间；

 

init_handler：初始化遍历过程中的相关数据结构，与alloc配合使用，只要alloc被赋值了，那么init_handler也必须进行赋值，即一句话，要么同时存在，要么同时为空；

file_handler：处理普通文件的回调函数；

pre_tree_handler：进入一个目录前的回调函数；

post_tree_handler：离开一个目录后的回调函数；

spec_handler：处理特殊文件的回调函数，比如socket，FIFO等；

 

data：传递一些数据结构，可以在不同的目录树下使用相同的数据结构，或者也可以重新分配，前提是alloc不为0；

alloc：如果需要分配一些数据结构，在这里指定分配数据结构的大小，并由init_handler进行初始化；

log：主要用于日志的记录。

 

下面先来看看ngx_walk_tree的原型：

ngx_int_t ngx_walk_tree(ngx_tree_ctx_t *ctx, ngx_str_t *tree)；

 

其中：tree就是最开始进行遍历的路径。

 

下面看看源码是如何实现的：

 

ngx_int_t
ngx_walk_tree(ngx_tree_ctx_t *ctx, ngx_str_t *tree)
{
    void       *data, *prev;
    u_char     *p, *name;
    size_t      len;
    ngx_int_t   rc;
    ngx_err_t   err;
    ngx_str_t   file, buf;
    ngx_dir_t   dir;

    ngx_str_null(&buf);

    ngx_log_debug1(NGX_LOG_DEBUG_CORE, ctx->log, 0,
                   "walk tree \"%V\"", tree);

      /* 第一步，就是打开需要遍历的目录 */

    if (ngx_open_dir(tree, &dir) == NGX_ERROR) {
        ngx_log_error(NGX_LOG_CRIT, ctx->log, ngx_errno,
                      ngx_open_dir_n " \"%s\" failed", tree->data);
        return NGX_ERROR;
    }

    prev = ctx->data;

    /* 如果alloc不为0，就为当前层次下的目录结构重新分配数据结构 */

    if (ctx->alloc) {
        data = ngx_alloc(ctx->alloc, ctx->log);
        if (data == NULL) {
            goto failed;
        }

        /* 分配后随即进行初始化，这里我们就看到了alloc和init_handler已经被绑定了 */

        if (ctx->init_handler(data, prev) == NGX_ABORT) {
            goto failed;
        }

         /* 将新的数据结构赋予ctx->data */

        ctx->data = data;

    } else {
        data = NULL;
    }

 

    /* 开始遍历 */

    for ( ;; ) {

        ngx_set_errno(0);

 

        /* 读取当前目录下的目录项 */

        if (ngx_read_dir(&dir) == NGX_ERROR) {
            err = ngx_errno;

            if (err == NGX_ENOMOREFILES) {
                rc = NGX_OK;

            } else {
                ngx_log_error(NGX_LOG_CRIT, ctx->log, err,
                              ngx_read_dir_n " \"%s\" failed", tree->data);
                rc = NGX_ERROR;
            }

            goto done;
        }

 

        /* 获取目录项的名称和长度 */

        len = ngx_de_namelen(&dir);
        name = ngx_de_name(&dir);

        ngx_log_debug2(NGX_LOG_DEBUG_CORE, ctx->log, 0,
                      "tree name %uz:\"%s\"", len, name);

        /* 对于 . 和 .. 不处理 */

        if (len == 1 && name[0] == '.') {
            continue;
        }

        if (len == 2 && name[0] == '.' && name[1] == '.') {
            continue;
        }

 

        /* 构造当前目录项的完整路径 */

        file.len = tree->len + 1 + len;

        if (file.len + NGX_DIR_MASK_LEN > buf.len) {

            if (buf.len) {

                    /* 不等于0，说明已经分配了内存，需要先释放掉 */
                ngx_free(buf.data);
            }

            /* 重新分配内存，NGX_DIR_MASK_LEN是干什么用的，不是很明白 */

            buf.len = tree->len + 1 + len + NGX_DIR_MASK_LEN;

            buf.data = ngx_alloc(buf.len + 1, ctx->log);
            if (buf.data == NULL) {
                goto failed;
            }
        }

        p = ngx_cpymem(buf.data, tree->data, tree->len);
        *p++ = '/';
        ngx_memcpy(p, name, len + 1);

        file.data = buf.data;

        ngx_log_debug1(NGX_LOG_DEBUG_CORE, ctx->log, 0,
                       "tree path \"%s\"", file.data);

        /* 读取新的目录项的文件信息 */

        if (!dir.valid_info) {
            if (ngx_de_info(file.data, &dir) == NGX_FILE_ERROR) {
                ngx_log_error(NGX_LOG_CRIT, ctx->log, ngx_errno,
                              ngx_de_info_n " \"%s\" failed", file.data);
                continue;
            }
        }

        /* 如果新的目录项是普通文件，调用file_handler进行处理，如果是目录，递归调用ngx_walk_tree，

            如果是特殊文件，调用spec_handler进行处理 */

        if (ngx_de_is_file(&dir)) {

            ngx_log_debug1(NGX_LOG_DEBUG_CORE, ctx->log, 0,
                           "tree file \"%s\"", file.data);

            ctx->size = ngx_de_size(&dir);
            ctx->fs_size = ngx_de_fs_size(&dir);
            ctx->access = ngx_de_access(&dir);
            ctx->mtime = ngx_de_mtime(&dir);

            if (ctx->file_handler(ctx, &file) == NGX_ABORT) {
                goto failed;
            }

        } else if (ngx_de_is_dir(&dir)) {

            ngx_log_debug1(NGX_LOG_DEBUG_CORE, ctx->log, 0,
                           "tree enter dir \"%s\"", file.data);

            ctx->access = ngx_de_access(&dir);
            ctx->mtime = ngx_de_mtime(&dir);

            if (ctx->pre_tree_handler(ctx, &file) == NGX_ABORT) {
                goto failed;
            }

            if (ngx_walk_tree(ctx, &file) == NGX_ABORT) {
                goto failed;
            }

            ctx->access = ngx_de_access(&dir);
            ctx->mtime = ngx_de_mtime(&dir);

            if (ctx->post_tree_handler(ctx, &file) == NGX_ABORT) {
                goto failed;
            }

        } else {

            ngx_log_debug1(NGX_LOG_DEBUG_CORE, ctx->log, 0,
                           "tree special \"%s\"", file.data);

            if (ctx->spec_handler(ctx, &file) == NGX_ABORT) {
                goto failed;
            }
        }
    }

failed:

    rc = NGX_ABORT;

done:

    if (buf.len) {
        ngx_free(buf.data);
    }

    if (data) {
        ngx_free(data);
        ctx->data = prev;
    }

    if (ngx_close_dir(&dir) == NGX_ERROR) {
        ngx_log_error(NGX_LOG_CRIT, ctx->log, ngx_errno,
                      ngx_close_dir_n " \"%s\" failed", tree->data);
    }

    return rc;
}

 

综合上述，总的处理流程可以归纳为：

1. 打开目录

2. 处理目录项

3. 关闭目录

 

（全文完）