One Level Up Top Level

src/core/ngx_file.c - nginx-1.7.10

Global variables defined

Functions defined

Source code


  2. /*
  3. * Copyright (C) Igor Sysoev
  4. * Copyright (C) Nginx, Inc.
  5. */


  8. #include <ngx_config.h>
  9. #include <ngx_core.h>


  12. static ngx_int_t ngx_test_full_name(ngx_str_t *name);


  15. ‌static ngx_atomic_t   temp_number = 0;
  16. ‌ngx_atomic_t         *ngx_temp_number = &temp_number;
  17. ‌ngx_atomic_int_t      ngx_random_number = 123456;


  20. ngx_int_t
  21. ‌ngx_get_full_name(ngx_pool_t *pool, ngx_str_t *prefix, ngx_str_t *name)
  22. {
  23.     size_t      len;
  24.     u_char     *p, *n;
  25.     ngx_int_t   rc;

  27.     rc = ngx_test_full_name(name);

  29.     if (rc == NGX_OK) {
  30.         return rc;
  31.     }

  33.     len = prefix->len;

  35. #if (NGX_WIN32)

  37.     if (rc == 2) {
  38.         len = rc;
  39.     }

  41. #endif

  43.     n = ngx_pnalloc(pool, len + name->len + 1);
  44.     if (n == NULL) {
  45.         return NGX_ERROR;
  46.     }

  48.     p = ngx_cpymem(n, prefix->data, len);
  49.     ngx_cpystrn(p, name->data, name->len + 1);

  51.     name->len += len;
  52.     name->data = n;

  54.     return NGX_OK;
  55. }


  58. static ngx_int_t
  59. ‌ngx_test_full_name(ngx_str_t *name)
  60. {
  61. #if (NGX_WIN32)
  62.     u_char  c0, c1;

  64.     c0 = name->data[0];

  66.     if (name->len < 2) {
  67.         if (c0 == '/') {
  68.             return 2;
  69.         }

  71.         return NGX_DECLINED;
  72.     }

  74.     c1 = name->data[1];

  76.     if (c1 == ':') {
  77.         c0 |= 0x20;

  79.         if ((c0 >= 'a' && c0 <= 'z')) {
  80.             return NGX_OK;
  81.         }

  83.         return NGX_DECLINED;
  84.     }

  86.     if (c1 == '/') {
  87.         return NGX_OK;
  88.     }

  90.     if (c0 == '/') {
  91.         return 2;
  92.     }

  94.     return NGX_DECLINED;

  96. #else

  98.     if (name->data[0] == '/') {
  99.         return NGX_OK;
  100.     }

  102.     return NGX_DECLINED;

  104. #endif
  105. }


  108. ssize_t
  109. ‌ngx_write_chain_to_temp_file(ngx_temp_file_t *tf, ngx_chain_t *chain)
  110. {
  111.     ngx_int_t  rc;

  113.     if (tf->file.fd == NGX_INVALID_FILE) {
  114.         rc = ngx_create_temp_file(&tf->file, tf->path, tf->pool,
  115.                                   tf->persistent, tf->clean, tf->access);

  117.         if (rc != NGX_OK) {
  118.             return rc;
  119.         }

  121.         if (tf->log_level) {
  122.             ngx_log_error(tf->log_level, tf->file.log, 0, "%s %V",
  123.                           tf->warn, &tf->file.name);
  124.         }
  125.     }

  127.     return ngx_write_chain_to_file(&tf->file, chain, tf->offset, tf->pool);
  128. }


  131. ngx_int_t
  132. ‌ngx_create_temp_file(ngx_file_t *file, ngx_path_t *path, ngx_pool_t *pool,
  133.     ngx_uint_t persistent, ngx_uint_t clean, ngx_uint_t access)
  134. {
  135.     uint32_t                  n;
  136.     ngx_err_t                 err;
  137.     ngx_pool_cleanup_t       *cln;
  138.     ngx_pool_cleanup_file_t  *clnf;

  140.     file->name.len = path->name.len + 1 + path->len + 10;

  142.     file->name.data = ngx_pnalloc(pool, file->name.len + 1);
  143.     if (file->name.data == NULL) {
  144.         return NGX_ERROR;
  145.     }

  147. #if 0
  148.     for (i = 0; i < file->name.len; i++) {
  149.          file->name.data[i] = 'X';
  150.     }
  151. #endif

  153.     ngx_memcpy(file->name.data, path->name.data, path->name.len);

  155.     n = (uint32_t) ngx_next_temp_number(0);

  157.     cln = ngx_pool_cleanup_add(pool, sizeof(ngx_pool_cleanup_file_t));
  158.     if (cln == NULL) {
  159.         return NGX_ERROR;
  160.     }

  162.     for ( ;; ) {
  163.         (void) ngx_sprintf(file->name.data + path->name.len + 1 + path->len,
  164.                            "%010uD%Z", n);

  166.         ngx_create_hashed_filename(path, file->name.data, file->name.len);

  168.         ngx_log_debug1(NGX_LOG_DEBUG_CORE, file->log, 0,
  169.                        "hashed path: %s", file->name.data);

  171.         file->fd = ngx_open_tempfile(file->name.data, persistent, access);

  173.         ngx_log_debug1(NGX_LOG_DEBUG_CORE, file->log, 0,
  174.                        "temp fd:%d", file->fd);

  176.         if (file->fd != NGX_INVALID_FILE) {

  178.             cln->handler = clean ? ngx_pool_delete_file : ngx_pool_cleanup_file;
  179.             clnf = cln->data;

  181.             clnf->fd = file->fd;
  182.             clnf->name = file->name.data;
  183.             clnf->log = pool->log;

  185.             return NGX_OK;
  186.         }

  188.         err = ngx_errno;

  190.         if (err == NGX_EEXIST) {
  191.             n = (uint32_t) ngx_next_temp_number(1);
  192.             continue;
  193.         }

  195.         if ((path->level[0] == 0) || (err != NGX_ENOPATH)) {
  196.             ngx_log_error(NGX_LOG_CRIT, file->log, err,
  197.                           ngx_open_tempfile_n " \"%s\" failed",
  198.                           file->name.data);
  199.             return NGX_ERROR;
  200.         }

  202.         if (ngx_create_path(file, path) == NGX_ERROR) {
  203.             return NGX_ERROR;
  204.         }
  205.     }
  206. }


  209. void
  210. ‌ngx_create_hashed_filename(ngx_path_t *path, u_char *file, size_t len)
  211. {
  212.     size_t      i, level;
  213.     ngx_uint_t  n;

  215.     i = path->name.len + 1;

  217.     file[path->name.len + path->len]  = '/';

  219.     for (n = 0; n < 3; n++) {
  220.         level = path->level[n];

  222.         if (level == 0) {
  223.             break;
  224.         }

  226.         len -= level;
  227.         file[i - 1] = '/';
  228.         ngx_memcpy(&file[i], &file[len], level);
  229.         i += level + 1;
  230.     }
  231. }


  234. ngx_int_t
  235. ‌ngx_create_path(ngx_file_t *file, ngx_path_t *path)
  236. {
  237.     size_t      pos;
  238.     ngx_err_t   err;
  239.     ngx_uint_t  i;

  241.     pos = path->name.len;

  243.     for (i = 0; i < 3; i++) {
  244.         if (path->level[i] == 0) {
  245.             break;
  246.         }

  248.         pos += path->level[i] + 1;

  250.         file->name.data[pos] = '\0';

  252.         ngx_log_debug1(NGX_LOG_DEBUG_CORE, file->log, 0,
  253.                        "temp file: \"%s\"", file->name.data);

  255.         if (ngx_create_dir(file->name.data, 0700) == NGX_FILE_ERROR) {
  256.             err = ngx_errno;
  257.             if (err != NGX_EEXIST) {
  258.                 ngx_log_error(NGX_LOG_CRIT, file->log, err,
  259.                               ngx_create_dir_n " \"%s\" failed",
  260.                               file->name.data);
  261.                 return NGX_ERROR;
  262.             }
  263.         }

  265.         file->name.data[pos] = '/';
  266.     }

  268.     return NGX_OK;
  269. }


  272. ngx_err_t
  273. ‌ngx_create_full_path(u_char *dir, ngx_uint_t access)
  274. {
  275.     u_char     *p, ch;
  276.     ngx_err_t   err;

  278.     err = 0;

  280. #if (NGX_WIN32)
  281.     p = dir + 3;
  282. #else
  283.     p = dir + 1;
  284. #endif

  286.     for ( /* void */ ; *p; p++) {
  287.         ch = *p;

  289.         if (ch != '/') {
  290.             continue;
  291.         }

  293.         *p = '\0';

  295.         if (ngx_create_dir(dir, access) == NGX_FILE_ERROR) {
  296.             err = ngx_errno;

  298.             switch (err) {
  299.             case NGX_EEXIST:
  300.                 err = 0;
  301.             case NGX_EACCES:
  302.                 break;

  304.             default:
  305.                 return err;
  306.             }
  307.         }

  309.         *p = '/';
  310.     }

  312.     return err;
  313. }


  316. ngx_atomic_uint_t
  317. ‌ngx_next_temp_number(ngx_uint_t collision)
  318. {
  319.     ngx_atomic_uint_t  n, add;

  321.     add = collision ? ngx_random_number : 1;

  323.     n = ngx_atomic_fetch_add(ngx_temp_number, add);

  325.     return n + add;
  326. }


  329. char *
  330. ‌ngx_conf_set_path_slot(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  331. {
  332.     char  *p = conf;

  334.     ssize_t      level;
  335.     ngx_str_t   *value;
  336.     ngx_uint_t   i, n;
  337.     ngx_path_t  *path, **slot;

  339.     slot = (ngx_path_t **) (p + cmd->offset);

  341.     if (*slot) {
  342.         return "is duplicate";
  343.     }

  345.     path = ngx_pcalloc(cf->pool, sizeof(ngx_path_t));
  346.     if (path == NULL) {
  347.         return NGX_CONF_ERROR;
  348.     }

  350.     value = cf->args->elts;

  352.     path->name = value[1];

  354.     if (path->name.data[path->name.len - 1] == '/') {
  355.         path->name.len--;
  356.     }

  358.     if (ngx_conf_full_name(cf->cycle, &path->name, 0) != NGX_OK) {
  359.         return NULL;
  360.     }

  362.     path->conf_file = cf->conf_file->file.name.data;
  363.     path->line = cf->conf_file->line;

  365.     for (i = 0, n = 2; n < cf->args->nelts; i++, n++) {
  366.         level = ngx_atoi(value[n].data, value[n].len);
  367.         if (level == NGX_ERROR || level == 0) {
  368.             return "invalid value";
  369.         }

  371.         path->level[i] = level;
  372.         path->len += level + 1;
  373.     }

  375.     while (i < 3) {
  376.         path->level[i++] = 0;
  377.     }

  379.     *slot = path;

  381.     if (ngx_add_path(cf, slot) == NGX_ERROR) {
  382.         return NGX_CONF_ERROR;
  383.     }

  385.     return NGX_CONF_OK;
  386. }


  389. char *
  390. ‌ngx_conf_merge_path_value(ngx_conf_t *cf, ngx_path_t **path, ngx_path_t *prev,
  391.     ngx_path_init_t *init)
  392. {
  393.     if (*path) {
  394.         return NGX_CONF_OK;
  395.     }

  397.     if (prev) {
  398.         *path = prev;
  399.         return NGX_CONF_OK;
  400.     }

  402.     *path = ngx_pcalloc(cf->pool, sizeof(ngx_path_t));
  403.     if (*path == NULL) {
  404.         return NGX_CONF_ERROR;
  405.     }

  407.     (*path)->name = init->name;

  409.     if (ngx_conf_full_name(cf->cycle, &(*path)->name, 0) != NGX_OK) {
  410.         return NGX_CONF_ERROR;
  411.     }

  413.     (*path)->level[0] = init->level[0];
  414.     (*path)->level[1] = init->level[1];
  415.     (*path)->level[2] = init->level[2];

  417.     (*path)->len = init->level[0] + (init->level[0] ? 1 : 0)
  418.                    + init->level[1] + (init->level[1] ? 1 : 0)
  419.                    + init->level[2] + (init->level[2] ? 1 : 0);

  421.     if (ngx_add_path(cf, path) != NGX_OK) {
  422.         return NGX_CONF_ERROR;
  423.     }

  425.     return NGX_CONF_OK;
  426. }


  429. char *
  430. ‌ngx_conf_set_access_slot(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  431. {
  432.     char  *confp = conf;

  434.     u_char      *p;
  435.     ngx_str_t   *value;
  436.     ngx_uint_t   i, right, shift, *access;

  438.     access = (ngx_uint_t *) (confp + cmd->offset);

  440.     if (*access != NGX_CONF_UNSET_UINT) {
  441.         return "is duplicate";
  442.     }

  444.     value = cf->args->elts;

  446.     *access = 0600;

  448.     for (i = 1; i < cf->args->nelts; i++) {

  450.         p = value[i].data;

  452.         if (ngx_strncmp(p, "user:", sizeof("user:") - 1) == 0) {
  453.             shift = 6;
  454.             p += sizeof("user:") - 1;

  456.         } else if (ngx_strncmp(p, "group:", sizeof("group:") - 1) == 0) {
  457.             shift = 3;
  458.             p += sizeof("group:") - 1;

  460.         } else if (ngx_strncmp(p, "all:", sizeof("all:") - 1) == 0) {
  461.             shift = 0;
  462.             p += sizeof("all:") - 1;

  464.         } else {
  465.             goto invalid;
  466.         }

  468.         if (ngx_strcmp(p, "rw") == 0) {
  469.             right = 6;

  471.         } else if (ngx_strcmp(p, "r") == 0) {
  472.             right = 4;

  474.         } else {
  475.             goto invalid;
  476.         }

  478.         *access |= right << shift;
  479.     }

  481.     return NGX_CONF_OK;

  483. invalid:

  485.     ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, "invalid value \"%V\"", &value[i]);

  487.     return NGX_CONF_ERROR;
  488. }


  491. ngx_int_t
  492. ‌ngx_add_path(ngx_conf_t *cf, ngx_path_t **slot)
  493. {
  494.     ngx_uint_t   i, n;
  495.     ngx_path_t  *path, **p;

  497.     path = *slot;

  499.     p = cf->cycle->paths.elts;
  500.     for (i = 0; i < cf->cycle->paths.nelts; i++) {
  501.         if (p[i]->name.len == path->name.len
  502.             && ngx_strcmp(p[i]->name.data, path->name.data) == 0)
  503.         {
  504.             if (p[i]->data != path->data) {
  505.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  506.                                    "the same path name \"%V\" "
  507.                                    "used in %s:%ui and",
  508.                                    &p[i]->name, p[i]->conf_file, p[i]->line);
  509.                 return NGX_ERROR;
  510.             }

  512.             for (n = 0; n < 3; n++) {
  513.                 if (p[i]->level[n] != path->level[n]) {
  514.                     if (path->conf_file == NULL) {
  515.                         if (p[i]->conf_file == NULL) {
  516.                             ngx_log_error(NGX_LOG_EMERG, cf->log, 0,
  517.                                       "the default path name \"%V\" has "
  518.                                       "the same name as another default path, "
  519.                                       "but the different levels, you need to "
  520.                                       "redefine one of them in http section",
  521.                                       &p[i]->name);
  522.                             return NGX_ERROR;
  523.                         }

  525.                         ngx_log_error(NGX_LOG_EMERG, cf->log, 0,
  526.                                       "the path name \"%V\" in %s:%ui has "
  527.                                       "the same name as default path, but "
  528.                                       "the different levels, you need to "
  529.                                       "define default path in http section",
  530.                                       &p[i]->name, p[i]->conf_file, p[i]->line);
  531.                         return NGX_ERROR;
  532.                     }

  534.                     ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  535.                                       "the same path name \"%V\" in %s:%ui "
  536.                                       "has the different levels than",
  537.                                       &p[i]->name, p[i]->conf_file, p[i]->line);
  538.                     return NGX_ERROR;
  539.                 }

  541.                 if (p[i]->level[n] == 0) {
  542.                     break;
  543.                 }
  544.             }

  546.             *slot = p[i];

  548.             return NGX_OK;
  549.         }
  550.     }

  552.     p = ngx_array_push(&cf->cycle->paths);
  553.     if (p == NULL) {
  554.         return NGX_ERROR;
  555.     }

  557.     *p = path;

  559.     return NGX_OK;
  560. }


  563. ngx_int_t
  564. ‌ngx_create_paths(ngx_cycle_t *cycle, ngx_uid_t user)
  565. {
  566.     ngx_err_t         err;
  567.     ngx_uint_t        i;
  568.     ngx_path_t      **path;

  570.     path = cycle->paths.elts;
  571.     for (i = 0; i < cycle->paths.nelts; i++) {

  573.         if (ngx_create_dir(path[i]->name.data, 0700) == NGX_FILE_ERROR) {
  574.             err = ngx_errno;
  575.             if (err != NGX_EEXIST) {
  576.                 ngx_log_error(NGX_LOG_EMERG, cycle->log, err,
  577.                               ngx_create_dir_n " \"%s\" failed",
  578.                               path[i]->name.data);
  579.                 return NGX_ERROR;
  580.             }
  581.         }

  583.         if (user == (ngx_uid_t) NGX_CONF_UNSET_UINT) {
  584.             continue;
  585.         }

  587. #if !(NGX_WIN32)
  588.         {
  589.         ngx_file_info_t   fi;

  591.         if (ngx_file_info((const char *) path[i]->name.data, &fi)
  592.             == NGX_FILE_ERROR)
  593.         {
  594.             ngx_log_error(NGX_LOG_EMERG, cycle->log, ngx_errno,
  595.                           ngx_file_info_n " \"%s\" failed", path[i]->name.data);
  596.             return NGX_ERROR;
  597.         }

  599.         if (fi.st_uid != user) {
  600.             if (chown((const char *) path[i]->name.data, user, -1) == -1) {
  601.                 ngx_log_error(NGX_LOG_EMERG, cycle->log, ngx_errno,
  602.                               "chown(\"%s\", %d) failed",
  603.                               path[i]->name.data, user);
  604.                 return NGX_ERROR;
  605.             }
  606.         }

  608.         if ((fi.st_mode & (S_IRUSR|S_IWUSR|S_IXUSR))
  609.                                                   != (S_IRUSR|S_IWUSR|S_IXUSR))
  610.         {
  611.             fi.st_mode |= (S_IRUSR|S_IWUSR|S_IXUSR);

  613.             if (chmod((const char *) path[i]->name.data, fi.st_mode) == -1) {
  614.                 ngx_log_error(NGX_LOG_EMERG, cycle->log, ngx_errno,
  615.                               "chmod() \"%s\" failed", path[i]->name.data);
  616.                 return NGX_ERROR;
  617.             }
  618.         }
  619.         }
  620. #endif
  621.     }

  623.     return NGX_OK;
  624. }


  627. ngx_int_t
  628. ‌ngx_ext_rename_file(ngx_str_t *src, ngx_str_t *to, ngx_ext_rename_file_t *ext)
  629. {
  630.     u_char           *name;
  631.     ngx_err_t         err;
  632.     ngx_copy_file_t   cf;

  634. #if !(NGX_WIN32)

  636.     if (ext->access) {
  637.         if (ngx_change_file_access(src->data, ext->access) == NGX_FILE_ERROR) {
  638.             ngx_log_error(NGX_LOG_CRIT, ext->log, ngx_errno,
  639.                           ngx_change_file_access_n " \"%s\" failed", src->data);
  640.             err = 0;
  641.             goto failed;
  642.         }
  643.     }

  645. #endif

  647.     if (ext->time != -1) {
  648.         if (ngx_set_file_time(src->data, ext->fd, ext->time) != NGX_OK) {
  649.             ngx_log_error(NGX_LOG_CRIT, ext->log, ngx_errno,
  650.                           ngx_set_file_time_n " \"%s\" failed", src->data);
  651.             err = 0;
  652.             goto failed;
  653.         }
  654.     }

  656.     if (ngx_rename_file(src->data, to->data) != NGX_FILE_ERROR) {
  657.         return NGX_OK;
  658.     }

  660.     err = ngx_errno;

  662.     if (err == NGX_ENOPATH) {

  664.         if (!ext->create_path) {
  665.             goto failed;
  666.         }

  668.         err = ngx_create_full_path(to->data, ngx_dir_access(ext->path_access));

  670.         if (err) {
  671.             ngx_log_error(NGX_LOG_CRIT, ext->log, err,
  672.                           ngx_create_dir_n " \"%s\" failed", to->data);
  673.             err = 0;
  674.             goto failed;
  675.         }

  677.         if (ngx_rename_file(src->data, to->data) != NGX_FILE_ERROR) {
  678.             return NGX_OK;
  679.         }

  681.         err = ngx_errno;
  682.     }

  684. #if (NGX_WIN32)

  686.     if (err == NGX_EEXIST) {
  687.         err = ngx_win32_rename_file(src, to, ext->log);

  689.         if (err == 0) {
  690.             return NGX_OK;
  691.         }
  692.     }

  694. #endif

  696.     if (err == NGX_EXDEV) {

  698.         cf.size = -1;
  699.         cf.buf_size = 0;
  700.         cf.access = ext->access;
  701.         cf.time = ext->time;
  702.         cf.log = ext->log;

  704.         name = ngx_alloc(to->len + 1 + 10 + 1, ext->log);
  705.         if (name == NULL) {
  706.             return NGX_ERROR;
  707.         }

  709.         (void) ngx_sprintf(name, "%*s.%010uD%Z", to->len, to->data,
  710.                            (uint32_t) ngx_next_temp_number(0));

  712.         if (ngx_copy_file(src->data, name, &cf) == NGX_OK) {

  714.             if (ngx_rename_file(name, to->data) != NGX_FILE_ERROR) {
  715.                 ngx_free(name);

  717.                 if (ngx_delete_file(src->data) == NGX_FILE_ERROR) {
  718.                     ngx_log_error(NGX_LOG_CRIT, ext->log, ngx_errno,
  719.                                   ngx_delete_file_n " \"%s\" failed",
  720.                                   src->data);
  721.                     return NGX_ERROR;
  722.                 }

  724.                 return NGX_OK;
  725.             }

  727.             ngx_log_error(NGX_LOG_CRIT, ext->log, ngx_errno,
  728.                           ngx_rename_file_n " \"%s\" to \"%s\" failed",
  729.                           name, to->data);

  731.             if (ngx_delete_file(name) == NGX_FILE_ERROR) {
  732.                 ngx_log_error(NGX_LOG_CRIT, ext->log, ngx_errno,
  733.                               ngx_delete_file_n " \"%s\" failed", name);

  735.             }
  736.         }

  738.         ngx_free(name);

  740.         err = 0;
  741.     }

  743. failed:

  745.     if (ext->delete_file) {
  746.         if (ngx_delete_file(src->data) == NGX_FILE_ERROR) {
  747.             ngx_log_error(NGX_LOG_CRIT, ext->log, ngx_errno,
  748.                           ngx_delete_file_n " \"%s\" failed", src->data);
  749.         }
  750.     }

  752.     if (err) {
  753.         ngx_log_error(NGX_LOG_CRIT, ext->log, err,
  754.                       ngx_rename_file_n " \"%s\" to \"%s\" failed",
  755.                       src->data, to->data);
  756.     }

  758.     return NGX_ERROR;
  759. }


  762. ngx_int_t
  763. ‌ngx_copy_file(u_char *from, u_char *to, ngx_copy_file_t *cf)
  764. {
  765.     char             *buf;
  766.     off_t             size;
  767.     size_t            len;
  768.     ssize_t           n;
  769.     ngx_fd_t          fd, nfd;
  770.     ngx_int_t         rc;
  771.     ngx_file_info_t   fi;

  773.     rc = NGX_ERROR;
  774.     buf = NULL;
  775.     nfd = NGX_INVALID_FILE;

  777.     fd = ngx_open_file(from, NGX_FILE_RDONLY, NGX_FILE_OPEN, 0);

  779.     if (fd == NGX_INVALID_FILE) {
  780.         ngx_log_error(NGX_LOG_CRIT, cf->log, ngx_errno,
  781.                       ngx_open_file_n " \"%s\" failed", from);
  782.         goto failed;
  783.     }

  785.     if (cf->size != -1) {
  786.         size = cf->size;

  788.     } else {
  789.         if (ngx_fd_info(fd, &fi) == NGX_FILE_ERROR) {
  790.             ngx_log_error(NGX_LOG_ALERT, cf->log, ngx_errno,
  791.                           ngx_fd_info_n " \"%s\" failed", from);

  793.             goto failed;
  794.         }

  796.         size = ngx_file_size(&fi);
  797.     }

  799.     len = cf->buf_size ? cf->buf_size : 65536;

  801.     if ((off_t) len > size) {
  802.         len = (size_t) size;
  803.     }

  805.     buf = ngx_alloc(len, cf->log);
  806.     if (buf == NULL) {
  807.         goto failed;
  808.     }

  810.     nfd = ngx_open_file(to, NGX_FILE_WRONLY, NGX_FILE_CREATE_OR_OPEN,
  811.                         cf->access);

  813.     if (nfd == NGX_INVALID_FILE) {
  814.         ngx_log_error(NGX_LOG_CRIT, cf->log, ngx_errno,
  815.                       ngx_open_file_n " \"%s\" failed", to);
  816.         goto failed;
  817.     }

  819.     while (size > 0) {

  821.         if ((off_t) len > size) {
  822.             len = (size_t) size;
  823.         }

  825.         n = ngx_read_fd(fd, buf, len);

  827.         if (n == -1) {
  828.             ngx_log_error(NGX_LOG_ALERT, cf->log, ngx_errno,
  829.                           ngx_read_fd_n " \"%s\" failed", from);
  830.             goto failed;
  831.         }

  833.         if ((size_t) n != len) {
  834.             ngx_log_error(NGX_LOG_ALERT, cf->log, 0,
  835.                           ngx_read_fd_n " has read only %z of %uz from %s",
  836.                           n, size, from);
  837.             goto failed;
  838.         }

  840.         n = ngx_write_fd(nfd, buf, len);

  842.         if (n == -1) {
  843.             ngx_log_error(NGX_LOG_ALERT, cf->log, ngx_errno,
  844.                           ngx_write_fd_n " \"%s\" failed", to);
  845.             goto failed;
  846.         }

  848.         if ((size_t) n != len) {
  849.             ngx_log_error(NGX_LOG_ALERT, cf->log, 0,
  850.                           ngx_write_fd_n " has written only %z of %uz to %s",
  851.                           n, size, to);
  852.             goto failed;
  853.         }

  855.         size -= n;
  856.     }

  858.     if (cf->time != -1) {
  859.         if (ngx_set_file_time(to, nfd, cf->time) != NGX_OK) {
  860.             ngx_log_error(NGX_LOG_ALERT, cf->log, ngx_errno,
  861.                           ngx_set_file_time_n " \"%s\" failed", to);
  862.             goto failed;
  863.         }
  864.     }

  866.     rc = NGX_OK;

  868. failed:

  870.     if (nfd != NGX_INVALID_FILE) {
  871.         if (ngx_close_file(nfd) == NGX_FILE_ERROR) {
  872.             ngx_log_error(NGX_LOG_ALERT, cf->log, ngx_errno,
  873.                           ngx_close_file_n " \"%s\" failed", to);
  874.         }
  875.     }

  877.     if (fd != NGX_INVALID_FILE) {
  878.         if (ngx_close_file(fd) == NGX_FILE_ERROR) {
  879.             ngx_log_error(NGX_LOG_ALERT, cf->log, ngx_errno,
  880.                           ngx_close_file_n " \"%s\" failed", from);
  881.         }
  882.     }

  884.     if (buf) {
  885.         ngx_free(buf);
  886.     }

  888.     return rc;
  889. }


  892. /*
  893. * ctx->init_handler() - see ctx->alloc
  894. * ctx->file_handler() - file handler
  895. * ctx->pre_tree_handler() - handler is called before entering directory
  896. * ctx->post_tree_handler() - handler is called after leaving directory
  897. * ctx->spec_handler() - special (socket, FIFO, etc.) file handler
  898. *
  899. * ctx->data - some data structure, it may be the same on all levels, or
  900. *     reallocated if ctx->alloc is nonzero
  901. *
  902. * ctx->alloc - a size of data structure that is allocated at every level
  903. *     and is initialized by ctx->init_handler()
  904. *
  905. * ctx->log - a log
  906. *
  907. * on fatal (memory) error handler must return NGX_ABORT to stop walking tree
  908. */

  910. ngx_int_t
  911. ‌ngx_walk_tree(ngx_tree_ctx_t *ctx, ngx_str_t *tree)
  912. {
  913.     void       *data, *prev;
  914.     u_char     *p, *name;
  915.     size_t      len;
  916.     ngx_int_t   rc;
  917.     ngx_err_t   err;
  918.     ngx_str_t   file, buf;
  919.     ngx_dir_t   dir;

  921.     ngx_str_null(&buf);

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

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

  932.     prev = ctx->data;

  934.     if (ctx->alloc) {
  935.         data = ngx_alloc(ctx->alloc, ctx->log);
  936.         if (data == NULL) {
  937.             goto failed;
  938.         }

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

  944.         ctx->data = data;

  946.     } else {
  947.         data = NULL;
  948.     }

  950.     for ( ;; ) {

  952.         ngx_set_errno(0);

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

  957.             if (err == NGX_ENOMOREFILES) {
  958.                 rc = NGX_OK;

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

  966.             goto done;
  967.         }

  969.         len = ngx_de_namelen(&dir);
  970.         name = ngx_de_name(&dir);

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

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

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

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

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

  987.             if (buf.len) {
  988.                 ngx_free(buf.data);
  989.             }

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

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

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

  1003.         file.data = buf.data;

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

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

  1016.         if (ngx_de_is_file(&dir)) {

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

  1021.             ctx->size = ngx_de_size(&dir);
  1022.             ctx->fs_size = ngx_de_fs_size(&dir);
  1023.             ctx->access = ngx_de_access(&dir);
  1024.             ctx->mtime = ngx_de_mtime(&dir);

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

  1030.         } else if (ngx_de_is_dir(&dir)) {

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

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

  1038.             rc = ctx->pre_tree_handler(ctx, &file);

  1040.             if (rc == NGX_ABORT) {
  1041.                 goto failed;
  1042.             }

  1044.             if (rc == NGX_DECLINED) {
  1045.                 ngx_log_debug1(NGX_LOG_DEBUG_CORE, ctx->log, 0,
  1046.                                "tree skip dir \"%s\"", file.data);
  1047.                 continue;
  1048.             }

  1050.             if (ngx_walk_tree(ctx, &file) == NGX_ABORT) {
  1051.                 goto failed;
  1052.             }

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

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

  1061.         } else {

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

  1066.             if (ctx->spec_handler(ctx, &file) == NGX_ABORT) {
  1067.                 goto failed;
  1068.             }
  1069.         }
  1070.     }

  1072. failed:

  1074.     rc = NGX_ABORT;

  1076. done:

  1078.     if (buf.len) {
  1079.         ngx_free(buf.data);
  1080.     }

  1082.     if (data) {
  1083.         ngx_free(data);
  1084.         ctx->data = prev;
  1085.     }

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

  1092.     return rc;
  1093. }

One Level Up Top Level