aboutsummaryrefslogtreecommitdiffstats
path: root/app/nginx/src/core/ngx_file.c
diff options
context:
space:
mode:
Diffstat (limited to 'app/nginx/src/core/ngx_file.c')
-rw-r--r--app/nginx/src/core/ngx_file.c1127
1 files changed, 1127 insertions, 0 deletions
diff --git a/app/nginx/src/core/ngx_file.c b/app/nginx/src/core/ngx_file.c
new file mode 100644
index 0000000..b7dd4bc
--- /dev/null
+++ b/app/nginx/src/core/ngx_file.c
@@ -0,0 +1,1127 @@
+
+/*
+ * Copyright (C) Igor Sysoev
+ * Copyright (C) Nginx, Inc.
+ */
+
+
+#include <ngx_config.h>
+#include <ngx_core.h>
+
+
+static ngx_int_t ngx_test_full_name(ngx_str_t *name);
+
+
+static ngx_atomic_t temp_number = 0;
+ngx_atomic_t *ngx_temp_number = &temp_number;
+ngx_atomic_int_t ngx_random_number = 123456;
+
+
+ngx_int_t
+ngx_get_full_name(ngx_pool_t *pool, ngx_str_t *prefix, ngx_str_t *name)
+{
+ size_t len;
+ u_char *p, *n;
+ ngx_int_t rc;
+
+ rc = ngx_test_full_name(name);
+
+ if (rc == NGX_OK) {
+ return rc;
+ }
+
+ len = prefix->len;
+
+#if (NGX_WIN32)
+
+ if (rc == 2) {
+ len = rc;
+ }
+
+#endif
+
+ n = ngx_pnalloc(pool, len + name->len + 1);
+ if (n == NULL) {
+ return NGX_ERROR;
+ }
+
+ p = ngx_cpymem(n, prefix->data, len);
+ ngx_cpystrn(p, name->data, name->len + 1);
+
+ name->len += len;
+ name->data = n;
+
+ return NGX_OK;
+}
+
+
+static ngx_int_t
+ngx_test_full_name(ngx_str_t *name)
+{
+#if (NGX_WIN32)
+ u_char c0, c1;
+
+ c0 = name->data[0];
+
+ if (name->len < 2) {
+ if (c0 == '/') {
+ return 2;
+ }
+
+ return NGX_DECLINED;
+ }
+
+ c1 = name->data[1];
+
+ if (c1 == ':') {
+ c0 |= 0x20;
+
+ if ((c0 >= 'a' && c0 <= 'z')) {
+ return NGX_OK;
+ }
+
+ return NGX_DECLINED;
+ }
+
+ if (c1 == '/') {
+ return NGX_OK;
+ }
+
+ if (c0 == '/') {
+ return 2;
+ }
+
+ return NGX_DECLINED;
+
+#else
+
+ if (name->data[0] == '/') {
+ return NGX_OK;
+ }
+
+ return NGX_DECLINED;
+
+#endif
+}
+
+
+ssize_t
+ngx_write_chain_to_temp_file(ngx_temp_file_t *tf, ngx_chain_t *chain)
+{
+ ngx_int_t rc;
+
+ if (tf->file.fd == NGX_INVALID_FILE) {
+ rc = ngx_create_temp_file(&tf->file, tf->path, tf->pool,
+ tf->persistent, tf->clean, tf->access);
+
+ if (rc != NGX_OK) {
+ return rc;
+ }
+
+ if (tf->log_level) {
+ ngx_log_error(tf->log_level, tf->file.log, 0, "%s %V",
+ tf->warn, &tf->file.name);
+ }
+ }
+
+#if (NGX_THREADS && NGX_HAVE_PWRITEV)
+
+ if (tf->thread_write) {
+ return ngx_thread_write_chain_to_file(&tf->file, chain, tf->offset,
+ tf->pool);
+ }
+
+#endif
+
+ return ngx_write_chain_to_file(&tf->file, chain, tf->offset, tf->pool);
+}
+
+
+ngx_int_t
+ngx_create_temp_file(ngx_file_t *file, ngx_path_t *path, ngx_pool_t *pool,
+ ngx_uint_t persistent, ngx_uint_t clean, ngx_uint_t access)
+{
+ size_t levels;
+ u_char *p;
+ uint32_t n;
+ ngx_err_t err;
+ ngx_str_t name;
+ ngx_uint_t prefix;
+ ngx_pool_cleanup_t *cln;
+ ngx_pool_cleanup_file_t *clnf;
+
+ if (file->name.len) {
+ name = file->name;
+ levels = 0;
+ prefix = 1;
+
+ } else {
+ name = path->name;
+ levels = path->len;
+ prefix = 0;
+ }
+
+ file->name.len = name.len + 1 + levels + 10;
+
+ file->name.data = ngx_pnalloc(pool, file->name.len + 1);
+ if (file->name.data == NULL) {
+ return NGX_ERROR;
+ }
+
+#if 0
+ for (i = 0; i < file->name.len; i++) {
+ file->name.data[i] = 'X';
+ }
+#endif
+
+ p = ngx_cpymem(file->name.data, name.data, name.len);
+
+ if (prefix) {
+ *p = '.';
+ }
+
+ p += 1 + levels;
+
+ n = (uint32_t) ngx_next_temp_number(0);
+
+ cln = ngx_pool_cleanup_add(pool, sizeof(ngx_pool_cleanup_file_t));
+ if (cln == NULL) {
+ return NGX_ERROR;
+ }
+
+ for ( ;; ) {
+ (void) ngx_sprintf(p, "%010uD%Z", n);
+
+ if (!prefix) {
+ ngx_create_hashed_filename(path, file->name.data, file->name.len);
+ }
+
+ ngx_log_debug1(NGX_LOG_DEBUG_CORE, file->log, 0,
+ "hashed path: %s", file->name.data);
+
+ file->fd = ngx_open_tempfile(file->name.data, persistent, access);
+
+ ngx_log_debug1(NGX_LOG_DEBUG_CORE, file->log, 0,
+ "temp fd:%d", file->fd);
+
+ if (file->fd != NGX_INVALID_FILE) {
+
+ cln->handler = clean ? ngx_pool_delete_file : ngx_pool_cleanup_file;
+ clnf = cln->data;
+
+ clnf->fd = file->fd;
+ clnf->name = file->name.data;
+ clnf->log = pool->log;
+
+ return NGX_OK;
+ }
+
+ err = ngx_errno;
+
+ if (err == NGX_EEXIST_FILE) {
+ n = (uint32_t) ngx_next_temp_number(1);
+ continue;
+ }
+
+ if ((path->level[0] == 0) || (err != NGX_ENOPATH)) {
+ ngx_log_error(NGX_LOG_CRIT, file->log, err,
+ ngx_open_tempfile_n " \"%s\" failed",
+ file->name.data);
+ return NGX_ERROR;
+ }
+
+ if (ngx_create_path(file, path) == NGX_ERROR) {
+ return NGX_ERROR;
+ }
+ }
+}
+
+
+void
+ngx_create_hashed_filename(ngx_path_t *path, u_char *file, size_t len)
+{
+ size_t i, level;
+ ngx_uint_t n;
+
+ i = path->name.len + 1;
+
+ file[path->name.len + path->len] = '/';
+
+ for (n = 0; n < NGX_MAX_PATH_LEVEL; n++) {
+ level = path->level[n];
+
+ if (level == 0) {
+ break;
+ }
+
+ len -= level;
+ file[i - 1] = '/';
+ ngx_memcpy(&file[i], &file[len], level);
+ i += level + 1;
+ }
+}
+
+
+ngx_int_t
+ngx_create_path(ngx_file_t *file, ngx_path_t *path)
+{
+ size_t pos;
+ ngx_err_t err;
+ ngx_uint_t i;
+
+ pos = path->name.len;
+
+ for (i = 0; i < NGX_MAX_PATH_LEVEL; i++) {
+ if (path->level[i] == 0) {
+ break;
+ }
+
+ pos += path->level[i] + 1;
+
+ file->name.data[pos] = '\0';
+
+ ngx_log_debug1(NGX_LOG_DEBUG_CORE, file->log, 0,
+ "temp file: \"%s\"", file->name.data);
+
+ if (ngx_create_dir(file->name.data, 0700) == NGX_FILE_ERROR) {
+ err = ngx_errno;
+ if (err != NGX_EEXIST) {
+ ngx_log_error(NGX_LOG_CRIT, file->log, err,
+ ngx_create_dir_n " \"%s\" failed",
+ file->name.data);
+ return NGX_ERROR;
+ }
+ }
+
+ file->name.data[pos] = '/';
+ }
+
+ return NGX_OK;
+}
+
+
+ngx_err_t
+ngx_create_full_path(u_char *dir, ngx_uint_t access)
+{
+ u_char *p, ch;
+ ngx_err_t err;
+
+ err = 0;
+
+#if (NGX_WIN32)
+ p = dir + 3;
+#else
+ p = dir + 1;
+#endif
+
+ for ( /* void */ ; *p; p++) {
+ ch = *p;
+
+ if (ch != '/') {
+ continue;
+ }
+
+ *p = '\0';
+
+ if (ngx_create_dir(dir, access) == NGX_FILE_ERROR) {
+ err = ngx_errno;
+
+ switch (err) {
+ case NGX_EEXIST:
+ err = 0;
+ case NGX_EACCES:
+ break;
+
+ default:
+ return err;
+ }
+ }
+
+ *p = '/';
+ }
+
+ return err;
+}
+
+
+ngx_atomic_uint_t
+ngx_next_temp_number(ngx_uint_t collision)
+{
+ ngx_atomic_uint_t n, add;
+
+ add = collision ? ngx_random_number : 1;
+
+ n = ngx_atomic_fetch_add(ngx_temp_number, add);
+
+ return n + add;
+}
+
+
+char *
+ngx_conf_set_path_slot(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
+{
+ char *p = conf;
+
+ ssize_t level;
+ ngx_str_t *value;
+ ngx_uint_t i, n;
+ ngx_path_t *path, **slot;
+
+ slot = (ngx_path_t **) (p + cmd->offset);
+
+ if (*slot) {
+ return "is duplicate";
+ }
+
+ path = ngx_pcalloc(cf->pool, sizeof(ngx_path_t));
+ if (path == NULL) {
+ return NGX_CONF_ERROR;
+ }
+
+ value = cf->args->elts;
+
+ path->name = value[1];
+
+ if (path->name.data[path->name.len - 1] == '/') {
+ path->name.len--;
+ }
+
+ if (ngx_conf_full_name(cf->cycle, &path->name, 0) != NGX_OK) {
+ return NGX_CONF_ERROR;
+ }
+
+ path->conf_file = cf->conf_file->file.name.data;
+ path->line = cf->conf_file->line;
+
+ for (i = 0, n = 2; n < cf->args->nelts; i++, n++) {
+ level = ngx_atoi(value[n].data, value[n].len);
+ if (level == NGX_ERROR || level == 0) {
+ return "invalid value";
+ }
+
+ path->level[i] = level;
+ path->len += level + 1;
+ }
+
+ if (path->len > 10 + i) {
+ return "invalid value";
+ }
+
+ *slot = path;
+
+ if (ngx_add_path(cf, slot) == NGX_ERROR) {
+ return NGX_CONF_ERROR;
+ }
+
+ return NGX_CONF_OK;
+}
+
+
+char *
+ngx_conf_merge_path_value(ngx_conf_t *cf, ngx_path_t **path, ngx_path_t *prev,
+ ngx_path_init_t *init)
+{
+ ngx_uint_t i;
+
+ if (*path) {
+ return NGX_CONF_OK;
+ }
+
+ if (prev) {
+ *path = prev;
+ return NGX_CONF_OK;
+ }
+
+ *path = ngx_pcalloc(cf->pool, sizeof(ngx_path_t));
+ if (*path == NULL) {
+ return NGX_CONF_ERROR;
+ }
+
+ (*path)->name = init->name;
+
+ if (ngx_conf_full_name(cf->cycle, &(*path)->name, 0) != NGX_OK) {
+ return NGX_CONF_ERROR;
+ }
+
+ for (i = 0; i < NGX_MAX_PATH_LEVEL; i++) {
+ (*path)->level[i] = init->level[i];
+ (*path)->len += init->level[i] + (init->level[i] ? 1 : 0);
+ }
+
+ if (ngx_add_path(cf, path) != NGX_OK) {
+ return NGX_CONF_ERROR;
+ }
+
+ return NGX_CONF_OK;
+}
+
+
+char *
+ngx_conf_set_access_slot(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
+{
+ char *confp = conf;
+
+ u_char *p;
+ ngx_str_t *value;
+ ngx_uint_t i, right, shift, *access, user;
+
+ access = (ngx_uint_t *) (confp + cmd->offset);
+
+ if (*access != NGX_CONF_UNSET_UINT) {
+ return "is duplicate";
+ }
+
+ value = cf->args->elts;
+
+ *access = 0;
+ user = 0600;
+
+ for (i = 1; i < cf->args->nelts; i++) {
+
+ p = value[i].data;
+
+ if (ngx_strncmp(p, "user:", sizeof("user:") - 1) == 0) {
+ shift = 6;
+ p += sizeof("user:") - 1;
+ user = 0;
+
+ } else if (ngx_strncmp(p, "group:", sizeof("group:") - 1) == 0) {
+ shift = 3;
+ p += sizeof("group:") - 1;
+
+ } else if (ngx_strncmp(p, "all:", sizeof("all:") - 1) == 0) {
+ shift = 0;
+ p += sizeof("all:") - 1;
+
+ } else {
+ goto invalid;
+ }
+
+ if (ngx_strcmp(p, "rw") == 0) {
+ right = 6;
+
+ } else if (ngx_strcmp(p, "r") == 0) {
+ right = 4;
+
+ } else {
+ goto invalid;
+ }
+
+ *access |= right << shift;
+ }
+
+ *access |= user;
+
+ return NGX_CONF_OK;
+
+invalid:
+
+ ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, "invalid value \"%V\"", &value[i]);
+
+ return NGX_CONF_ERROR;
+}
+
+
+ngx_int_t
+ngx_add_path(ngx_conf_t *cf, ngx_path_t **slot)
+{
+ ngx_uint_t i, n;
+ ngx_path_t *path, **p;
+
+ path = *slot;
+
+ p = cf->cycle->paths.elts;
+ for (i = 0; i < cf->cycle->paths.nelts; i++) {
+ if (p[i]->name.len == path->name.len
+ && ngx_strcmp(p[i]->name.data, path->name.data) == 0)
+ {
+ if (p[i]->data != path->data) {
+ ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
+ "the same path name \"%V\" "
+ "used in %s:%ui and",
+ &p[i]->name, p[i]->conf_file, p[i]->line);
+ return NGX_ERROR;
+ }
+
+ for (n = 0; n < NGX_MAX_PATH_LEVEL; n++) {
+ if (p[i]->level[n] != path->level[n]) {
+ if (path->conf_file == NULL) {
+ if (p[i]->conf_file == NULL) {
+ ngx_log_error(NGX_LOG_EMERG, cf->log, 0,
+ "the default path name \"%V\" has "
+ "the same name as another default path, "
+ "but the different levels, you need to "
+ "redefine one of them in http section",
+ &p[i]->name);
+ return NGX_ERROR;
+ }
+
+ ngx_log_error(NGX_LOG_EMERG, cf->log, 0,
+ "the path name \"%V\" in %s:%ui has "
+ "the same name as default path, but "
+ "the different levels, you need to "
+ "define default path in http section",
+ &p[i]->name, p[i]->conf_file, p[i]->line);
+ return NGX_ERROR;
+ }
+
+ ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
+ "the same path name \"%V\" in %s:%ui "
+ "has the different levels than",
+ &p[i]->name, p[i]->conf_file, p[i]->line);
+ return NGX_ERROR;
+ }
+
+ if (p[i]->level[n] == 0) {
+ break;
+ }
+ }
+
+ *slot = p[i];
+
+ return NGX_OK;
+ }
+ }
+
+ p = ngx_array_push(&cf->cycle->paths);
+ if (p == NULL) {
+ return NGX_ERROR;
+ }
+
+ *p = path;
+
+ return NGX_OK;
+}
+
+
+ngx_int_t
+ngx_create_paths(ngx_cycle_t *cycle, ngx_uid_t user)
+{
+ ngx_err_t err;
+ ngx_uint_t i;
+ ngx_path_t **path;
+
+ path = cycle->paths.elts;
+ for (i = 0; i < cycle->paths.nelts; i++) {
+
+ if (ngx_create_dir(path[i]->name.data, 0700) == NGX_FILE_ERROR) {
+ err = ngx_errno;
+ if (err != NGX_EEXIST) {
+ ngx_log_error(NGX_LOG_EMERG, cycle->log, err,
+ ngx_create_dir_n " \"%s\" failed",
+ path[i]->name.data);
+ return NGX_ERROR;
+ }
+ }
+
+ if (user == (ngx_uid_t) NGX_CONF_UNSET_UINT) {
+ continue;
+ }
+
+#if !(NGX_WIN32)
+ {
+ ngx_file_info_t fi;
+
+ if (ngx_file_info((const char *) path[i]->name.data, &fi)
+ == NGX_FILE_ERROR)
+ {
+ ngx_log_error(NGX_LOG_EMERG, cycle->log, ngx_errno,
+ ngx_file_info_n " \"%s\" failed", path[i]->name.data);
+ return NGX_ERROR;
+ }
+
+ if (fi.st_uid != user) {
+ if (chown((const char *) path[i]->name.data, user, -1) == -1) {
+ ngx_log_error(NGX_LOG_EMERG, cycle->log, ngx_errno,
+ "chown(\"%s\", %d) failed",
+ path[i]->name.data, user);
+ return NGX_ERROR;
+ }
+ }
+
+ if ((fi.st_mode & (S_IRUSR|S_IWUSR|S_IXUSR))
+ != (S_IRUSR|S_IWUSR|S_IXUSR))
+ {
+ fi.st_mode |= (S_IRUSR|S_IWUSR|S_IXUSR);
+
+ if (chmod((const char *) path[i]->name.data, fi.st_mode) == -1) {
+ ngx_log_error(NGX_LOG_EMERG, cycle->log, ngx_errno,
+ "chmod() \"%s\" failed", path[i]->name.data);
+ return NGX_ERROR;
+ }
+ }
+ }
+#endif
+ }
+
+ return NGX_OK;
+}
+
+
+ngx_int_t
+ngx_ext_rename_file(ngx_str_t *src, ngx_str_t *to, ngx_ext_rename_file_t *ext)
+{
+ u_char *name;
+ ngx_err_t err;
+ ngx_copy_file_t cf;
+
+#if !(NGX_WIN32)
+
+ if (ext->access) {
+ if (ngx_change_file_access(src->data, ext->access) == NGX_FILE_ERROR) {
+ ngx_log_error(NGX_LOG_CRIT, ext->log, ngx_errno,
+ ngx_change_file_access_n " \"%s\" failed", src->data);
+ err = 0;
+ goto failed;
+ }
+ }
+
+#endif
+
+ if (ext->time != -1) {
+ if (ngx_set_file_time(src->data, ext->fd, ext->time) != NGX_OK) {
+ ngx_log_error(NGX_LOG_CRIT, ext->log, ngx_errno,
+ ngx_set_file_time_n " \"%s\" failed", src->data);
+ err = 0;
+ goto failed;
+ }
+ }
+
+ if (ngx_rename_file(src->data, to->data) != NGX_FILE_ERROR) {
+ return NGX_OK;
+ }
+
+ err = ngx_errno;
+
+ if (err == NGX_ENOPATH) {
+
+ if (!ext->create_path) {
+ goto failed;
+ }
+
+ err = ngx_create_full_path(to->data, ngx_dir_access(ext->path_access));
+
+ if (err) {
+ ngx_log_error(NGX_LOG_CRIT, ext->log, err,
+ ngx_create_dir_n " \"%s\" failed", to->data);
+ err = 0;
+ goto failed;
+ }
+
+ if (ngx_rename_file(src->data, to->data) != NGX_FILE_ERROR) {
+ return NGX_OK;
+ }
+
+ err = ngx_errno;
+ }
+
+#if (NGX_WIN32)
+
+ if (err == NGX_EEXIST || err == NGX_EEXIST_FILE) {
+ err = ngx_win32_rename_file(src, to, ext->log);
+
+ if (err == 0) {
+ return NGX_OK;
+ }
+ }
+
+#endif
+
+ if (err == NGX_EXDEV) {
+
+ cf.size = -1;
+ cf.buf_size = 0;
+ cf.access = ext->access;
+ cf.time = ext->time;
+ cf.log = ext->log;
+
+ name = ngx_alloc(to->len + 1 + 10 + 1, ext->log);
+ if (name == NULL) {
+ return NGX_ERROR;
+ }
+
+ (void) ngx_sprintf(name, "%*s.%010uD%Z", to->len, to->data,
+ (uint32_t) ngx_next_temp_number(0));
+
+ if (ngx_copy_file(src->data, name, &cf) == NGX_OK) {
+
+ if (ngx_rename_file(name, to->data) != NGX_FILE_ERROR) {
+ ngx_free(name);
+
+ if (ngx_delete_file(src->data) == NGX_FILE_ERROR) {
+ ngx_log_error(NGX_LOG_CRIT, ext->log, ngx_errno,
+ ngx_delete_file_n " \"%s\" failed",
+ src->data);
+ return NGX_ERROR;
+ }
+
+ return NGX_OK;
+ }
+
+ ngx_log_error(NGX_LOG_CRIT, ext->log, ngx_errno,
+ ngx_rename_file_n " \"%s\" to \"%s\" failed",
+ name, to->data);
+
+ if (ngx_delete_file(name) == NGX_FILE_ERROR) {
+ ngx_log_error(NGX_LOG_CRIT, ext->log, ngx_errno,
+ ngx_delete_file_n " \"%s\" failed", name);
+
+ }
+ }
+
+ ngx_free(name);
+
+ err = 0;
+ }
+
+failed:
+
+ if (ext->delete_file) {
+ if (ngx_delete_file(src->data) == NGX_FILE_ERROR) {
+ ngx_log_error(NGX_LOG_CRIT, ext->log, ngx_errno,
+ ngx_delete_file_n " \"%s\" failed", src->data);
+ }
+ }
+
+ if (err) {
+ ngx_log_error(NGX_LOG_CRIT, ext->log, err,
+ ngx_rename_file_n " \"%s\" to \"%s\" failed",
+ src->data, to->data);
+ }
+
+ return NGX_ERROR;
+}
+
+
+ngx_int_t
+ngx_copy_file(u_char *from, u_char *to, ngx_copy_file_t *cf)
+{
+ char *buf;
+ off_t size;
+ size_t len;
+ ssize_t n;
+ ngx_fd_t fd, nfd;
+ ngx_int_t rc;
+ ngx_file_info_t fi;
+
+ rc = NGX_ERROR;
+ buf = NULL;
+ nfd = NGX_INVALID_FILE;
+
+ fd = ngx_open_file(from, NGX_FILE_RDONLY, NGX_FILE_OPEN, 0);
+
+ if (fd == NGX_INVALID_FILE) {
+ ngx_log_error(NGX_LOG_CRIT, cf->log, ngx_errno,
+ ngx_open_file_n " \"%s\" failed", from);
+ goto failed;
+ }
+
+ if (cf->size != -1) {
+ size = cf->size;
+
+ } else {
+ if (ngx_fd_info(fd, &fi) == NGX_FILE_ERROR) {
+ ngx_log_error(NGX_LOG_ALERT, cf->log, ngx_errno,
+ ngx_fd_info_n " \"%s\" failed", from);
+
+ goto failed;
+ }
+
+ size = ngx_file_size(&fi);
+ }
+
+ len = cf->buf_size ? cf->buf_size : 65536;
+
+ if ((off_t) len > size) {
+ len = (size_t) size;
+ }
+
+ buf = ngx_alloc(len, cf->log);
+ if (buf == NULL) {
+ goto failed;
+ }
+
+ nfd = ngx_open_file(to, NGX_FILE_WRONLY, NGX_FILE_CREATE_OR_OPEN,
+ cf->access);
+
+ if (nfd == NGX_INVALID_FILE) {
+ ngx_log_error(NGX_LOG_CRIT, cf->log, ngx_errno,
+ ngx_open_file_n " \"%s\" failed", to);
+ goto failed;
+ }
+
+ while (size > 0) {
+
+ if ((off_t) len > size) {
+ len = (size_t) size;
+ }
+
+ n = ngx_read_fd(fd, buf, len);
+
+ if (n == -1) {
+ ngx_log_error(NGX_LOG_ALERT, cf->log, ngx_errno,
+ ngx_read_fd_n " \"%s\" failed", from);
+ goto failed;
+ }
+
+ if ((size_t) n != len) {
+ ngx_log_error(NGX_LOG_ALERT, cf->log, 0,
+ ngx_read_fd_n " has read only %z of %O from %s",
+ n, size, from);
+ goto failed;
+ }
+
+ n = ngx_write_fd(nfd, buf, len);
+
+ if (n == -1) {
+ ngx_log_error(NGX_LOG_ALERT, cf->log, ngx_errno,
+ ngx_write_fd_n " \"%s\" failed", to);
+ goto failed;
+ }
+
+ if ((size_t) n != len) {
+ ngx_log_error(NGX_LOG_ALERT, cf->log, 0,
+ ngx_write_fd_n " has written only %z of %O to %s",
+ n, size, to);
+ goto failed;
+ }
+
+ size -= n;
+ }
+
+ if (cf->time != -1) {
+ if (ngx_set_file_time(to, nfd, cf->time) != NGX_OK) {
+ ngx_log_error(NGX_LOG_ALERT, cf->log, ngx_errno,
+ ngx_set_file_time_n " \"%s\" failed", to);
+ goto failed;
+ }
+ }
+
+ rc = NGX_OK;
+
+failed:
+
+ if (nfd != NGX_INVALID_FILE) {
+ if (ngx_close_file(nfd) == NGX_FILE_ERROR) {
+ ngx_log_error(NGX_LOG_ALERT, cf->log, ngx_errno,
+ ngx_close_file_n " \"%s\" failed", to);
+ }
+ }
+
+ if (fd != NGX_INVALID_FILE) {
+ if (ngx_close_file(fd) == NGX_FILE_ERROR) {
+ ngx_log_error(NGX_LOG_ALERT, cf->log, ngx_errno,
+ ngx_close_file_n " \"%s\" failed", from);
+ }
+ }
+
+ if (buf) {
+ ngx_free(buf);
+ }
+
+ return rc;
+}
+
+
+/*
+ * ctx->init_handler() - see ctx->alloc
+ * ctx->file_handler() - file handler
+ * ctx->pre_tree_handler() - handler is called before entering directory
+ * ctx->post_tree_handler() - handler is called after leaving directory
+ * ctx->spec_handler() - special (socket, FIFO, etc.) file handler
+ *
+ * ctx->data - some data structure, it may be the same on all levels, or
+ * reallocated if ctx->alloc is nonzero
+ *
+ * ctx->alloc - a size of data structure that is allocated at every level
+ * and is initialized by ctx->init_handler()
+ *
+ * ctx->log - a log
+ *
+ * on fatal (memory) error handler must return NGX_ABORT to stop walking 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;
+
+ if (ctx->alloc) {
+ data = ngx_alloc(ctx->alloc, ctx->log);
+ if (data == NULL) {
+ goto failed;
+ }
+
+ if (ctx->init_handler(data, prev) == NGX_ABORT) {
+ goto failed;
+ }
+
+ 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) {
+ ngx_free(buf.data);
+ }
+
+ 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;
+ }
+ }
+
+ 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);
+
+ rc = ctx->pre_tree_handler(ctx, &file);
+
+ if (rc == NGX_ABORT) {
+ goto failed;
+ }
+
+ if (rc == NGX_DECLINED) {
+ ngx_log_debug1(NGX_LOG_DEBUG_CORE, ctx->log, 0,
+ "tree skip dir \"%s\"", file.data);
+ continue;
+ }
+
+ 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;
+}