?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
nginx 0.7.65
[nginx-catap.git] / src / core / ngx_file.c
blob6844849ad3120c6e40fba367c7e2209c7e64fb9f
1
2 /*
3 * Copyright (C) Igor Sysoev
4 */
5
6
7 #include <ngx_config.h>
8 #include <ngx_core.h>
9
10
11 static ngx_atomic_t temp_number = 0;
12 ngx_atomic_t *ngx_temp_number = &temp_number;
13 ngx_atomic_int_t ngx_random_number = 123456;
14
15
16 ssize_t
17 ngx_write_chain_to_temp_file(ngx_temp_file_t *tf, ngx_chain_t *chain)
18 {
19 ngx_int_t rc;
20
21 if (tf->file.fd == NGX_INVALID_FILE) {
22 rc = ngx_create_temp_file(&tf->file, tf->path, tf->pool,
23 tf->persistent, tf->clean, tf->access);
24
25 if (rc == NGX_ERROR || rc == NGX_AGAIN) {
26 return rc;
27 }
28
29 if (tf->log_level) {
30 ngx_log_error(tf->log_level, tf->file.log, 0, "%s %V",
31 tf->warn, &tf->file.name);
32 }
33 }
34
35 return ngx_write_chain_to_file(&tf->file, chain, tf->offset, tf->pool);
36 }
37
38
39 ngx_int_t
40 ngx_create_temp_file(ngx_file_t *file, ngx_path_t *path, ngx_pool_t *pool,
41 ngx_uint_t persistent, ngx_uint_t clean, ngx_uint_t access)
42 {
43 uint32_t n;
44 ngx_err_t err;
45 ngx_pool_cleanup_t *cln;
46 ngx_pool_cleanup_file_t *clnf;
47
48 file->name.len = path->name.len + 1 + path->len + 10;
49
50 file->name.data = ngx_pnalloc(pool, file->name.len + 1);
51 if (file->name.data == NULL) {
52 return NGX_ERROR;
53 }
54
55 #if 0
56 for (i = 0; i < file->name.len; i++) {
57 file->name.data[i] = 'X';
58 }
59 #endif
60
61 ngx_memcpy(file->name.data, path->name.data, path->name.len);
62
63 n = (uint32_t) ngx_next_temp_number(0);
64
65 cln = ngx_pool_cleanup_add(pool, sizeof(ngx_pool_cleanup_file_t));
66 if (cln == NULL) {
67 return NGX_ERROR;
68 }
69
70 for ( ;; ) {
71 (void) ngx_sprintf(file->name.data + path->name.len + 1 + path->len,
72 "%010uD%Z", n);
73
74 ngx_create_hashed_filename(path, file->name.data, file->name.len);
75
76 ngx_log_debug1(NGX_LOG_DEBUG_CORE, file->log, 0,
77 "hashed path: %s", file->name.data);
78
79 file->fd = ngx_open_tempfile(file->name.data, persistent, access);
80
81 ngx_log_debug1(NGX_LOG_DEBUG_CORE, file->log, 0,
82 "temp fd:%d", file->fd);
83
84 if (file->fd != NGX_INVALID_FILE) {
85
86 cln->handler = clean ? ngx_pool_delete_file : ngx_pool_cleanup_file;
87 clnf = cln->data;
88
89 clnf->fd = file->fd;
90 clnf->name = file->name.data;
91 clnf->log = pool->log;
92
93 return NGX_OK;
94 }
95
96 err = ngx_errno;
97
98 if (err == NGX_EEXIST) {
99 n = (uint32_t) ngx_next_temp_number(1);
100 continue;
101 }
102
103 if ((path->level[0] == 0) || (err != NGX_ENOPATH)) {
104 ngx_log_error(NGX_LOG_CRIT, file->log, err,
105 ngx_open_tempfile_n " \"%s\" failed",
106 file->name.data);
107 return NGX_ERROR;
108 }
109
110 if (ngx_create_path(file, path) == NGX_ERROR) {
111 return NGX_ERROR;
112 }
113 }
114 }
115
116
117 void
118 ngx_create_hashed_filename(ngx_path_t *path, u_char *file, size_t len)
119 {
120 size_t i, level;
121 ngx_uint_t n;
122
123 i = path->name.len + 1;
124
125 file[path->name.len + path->len] = '/';
126
127 for (n = 0; n < 3; n++) {
128 level = path->level[n];
129
130 if (level == 0) {
131 break;
132 }
133
134 len -= level;
135 file[i - 1] = '/';
136 ngx_memcpy(&file[i], &file[len], level);
137 i += level + 1;
138 }
139 }
140
141
142 ngx_int_t
143 ngx_create_path(ngx_file_t *file, ngx_path_t *path)
144 {
145 size_t pos;
146 ngx_err_t err;
147 ngx_uint_t i;
148
149 pos = path->name.len;
150
151 for (i = 0; i < 3; i++) {
152 if (path->level[i] == 0) {
153 break;
154 }
155
156 pos += path->level[i] + 1;
157
158 file->name.data[pos] = '\0';
159
160 ngx_log_debug1(NGX_LOG_DEBUG_CORE, file->log, 0,
161 "temp file: \"%s\"", file->name.data);
162
163 if (ngx_create_dir(file->name.data, 0700) == NGX_FILE_ERROR) {
164 err = ngx_errno;
165 if (err != NGX_EEXIST) {
166 ngx_log_error(NGX_LOG_CRIT, file->log, err,
167 ngx_create_dir_n " \"%s\" failed",
168 file->name.data);
169 return NGX_ERROR;
170 }
171 }
172
173 file->name.data[pos] = '/';
174 }
175
176 return NGX_OK;
177 }
178
179
180 ngx_err_t
181 ngx_create_full_path(u_char *dir, ngx_uint_t access)
182 {
183 u_char *p, ch;
184 ngx_err_t err;
185
186 err = 0;
187
188 #if (NGX_WIN32)
189 p = dir + 3;
190 #else
191 p = dir + 1;
192 #endif
193
194 for ( /* void */ ; *p; p++) {
195 ch = *p;
196
197 if (ch != '/') {
198 continue;
199 }
200
201 *p = '\0';
202
203 if (ngx_create_dir(dir, access) == NGX_FILE_ERROR) {
204 err = ngx_errno;
205
206 switch (err) {
207 case NGX_EEXIST:
208 err = 0;
209 case NGX_EACCES:
210 break;
211
212 default:
213 return err;
214 }
215 }
216
217 *p = '/';
218 }
219
220 return err;
221 }
222
223
224 ngx_atomic_uint_t
225 ngx_next_temp_number(ngx_uint_t collision)
226 {
227 ngx_atomic_uint_t n, add;
228
229 add = collision ? ngx_random_number : 1;
230
231 n = ngx_atomic_fetch_add(ngx_temp_number, add);
232
233 return n + add;
234 }
235
236
237 char *
238 ngx_conf_set_path_slot(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
239 {
240 char *p = conf;
241
242 ssize_t level;
243 ngx_str_t *value;
244 ngx_uint_t i, n;
245 ngx_path_t *path, **slot;
246
247 slot = (ngx_path_t **) (p + cmd->offset);
248
249 if (*slot) {
250 return "is duplicate";
251 }
252
253 path = ngx_pcalloc(cf->pool, sizeof(ngx_path_t));
254 if (path == NULL) {
255 return NGX_CONF_ERROR;
256 }
257
258 value = cf->args->elts;
259
260 path->name = value[1];
261
262 if (path->name.data[path->name.len - 1] == '/') {
263 path->name.len--;
264 }
265
266 if (ngx_conf_full_name(cf->cycle, &path->name, 0) != NGX_OK) {
267 return NULL;
268 }
269
270 path->len = 0;
271 path->manager = NULL;
272 path->loader = NULL;
273 path->conf_file = cf->conf_file->file.name.data;
274 path->line = cf->conf_file->line;
275
276 for (i = 0, n = 2; n < cf->args->nelts; i++, n++) {
277 level = ngx_atoi(value[n].data, value[n].len);
278 if (level == NGX_ERROR || level == 0) {
279 return "invalid value";
280 }
281
282 path->level[i] = level;
283 path->len += level + 1;
284 }
285
286 while (i < 3) {
287 path->level[i++] = 0;
288 }
289
290 *slot = path;
291
292 if (ngx_add_path(cf, slot) == NGX_ERROR) {
293 return NGX_CONF_ERROR;
294 }
295
296 return NGX_CONF_OK;
297 }
298
299
300 char *
301 ngx_conf_merge_path_value(ngx_conf_t *cf, ngx_path_t **path, ngx_path_t *prev,
302 ngx_path_init_t *init)
303 {
304 if (*path) {
305 return NGX_CONF_OK;
306 }
307
308 if (prev) {
309 *path = prev;
310 return NGX_CONF_OK;
311 }
312
313 *path = ngx_palloc(cf->pool, sizeof(ngx_path_t));
314 if (*path == NULL) {
315 return NGX_CONF_ERROR;
316 }
317
318 (*path)->name = init->name;
319
320 if (ngx_conf_full_name(cf->cycle, &(*path)->name, 0) != NGX_OK) {
321 return NGX_CONF_ERROR;
322 }
323
324 (*path)->level[0] = init->level[0];
325 (*path)->level[1] = init->level[1];
326 (*path)->level[2] = init->level[2];
327
328 (*path)->len = init->level[0] + (init->level[0] ? 1 : 0)
329 + init->level[1] + (init->level[1] ? 1 : 0)
330 + init->level[2] + (init->level[2] ? 1 : 0);
331
332 (*path)->manager = NULL;
333 (*path)->loader = NULL;
334 (*path)->conf_file = NULL;
335
336 if (ngx_add_path(cf, path) != NGX_OK) {
337 return NGX_CONF_ERROR;
338 }
339
340 return NGX_CONF_OK;
341 }
342
343
344 char *
345 ngx_conf_set_access_slot(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
346 {
347 char *confp = conf;
348
349 u_char *p;
350 ngx_str_t *value;
351 ngx_uint_t i, right, shift, *access;
352
353 access = (ngx_uint_t *) (confp + cmd->offset);
354
355 if (*access != NGX_CONF_UNSET_UINT) {
356 return "is duplicate";
357 }
358
359 value = cf->args->elts;
360
361 *access = 0600;
362
363 for (i = 1; i < cf->args->nelts; i++) {
364
365 p = value[i].data;
366
367 if (ngx_strncmp(p, "user:", sizeof("user:") - 1) == 0) {
368 shift = 6;
369 p += sizeof("user:") - 1;
370
371 } else if (ngx_strncmp(p, "group:", sizeof("group:") - 1) == 0) {
372 shift = 3;
373 p += sizeof("group:") - 1;
374
375 } else if (ngx_strncmp(p, "all:", sizeof("all:") - 1) == 0) {
376 shift = 0;
377 p += sizeof("all:") - 1;
378
379 } else {
380 goto invalid;
381 }
382
383 if (ngx_strcmp(p, "rw") == 0) {
384 right = 6;
385
386 } else if (ngx_strcmp(p, "r") == 0) {
387 right = 4;
388
389 } else {
390 goto invalid;
391 }
392
393 *access |= right << shift;
394 }
395
396 return NGX_CONF_OK;
397
398 invalid:
399
400 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, "invalid value \"%V\"", &value[i]);
401
402 return NGX_CONF_ERROR;
403 }
404
405
406 ngx_int_t
407 ngx_add_path(ngx_conf_t *cf, ngx_path_t **slot)
408 {
409 ngx_uint_t i, n;
410 ngx_path_t *path, **p;
411
412 path = *slot;
413
414 p = cf->cycle->pathes.elts;
415 for (i = 0; i < cf->cycle->pathes.nelts; i++) {
416 if (p[i]->name.len == path->name.len
417 && ngx_strcmp(p[i]->name.data, path->name.data) == 0)
418 {
419 for (n = 0; n < 3; n++) {
420 if (p[i]->level[n] != path->level[n]) {
421 if (path->conf_file == NULL) {
422 if (p[i]->conf_file == NULL) {
423 ngx_log_error(NGX_LOG_EMERG, cf->log, 0,
424 "the default path name \"%V\" has "
425 "the same name as another default path, "
426 "but the different levels, you need to "
427 "redefine one of them in http section",
428 &p[i]->name);
429 return NGX_ERROR;
430 }
431
432 ngx_log_error(NGX_LOG_EMERG, cf->log, 0,
433 "the path name \"%V\" in %s:%ui has "
434 "the same name as default path, but "
435 "the different levels, you need to "
436 "define default path in http section",
437 &p[i]->name, p[i]->conf_file, p[i]->line);
438 return NGX_ERROR;
439 }
440
441 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
442 "the same path name \"%V\" in %s:%ui "
443 "has the different levels than",
444 &p[i]->name, p[i]->conf_file, p[i]->line);
445 return NGX_ERROR;
446 }
447
448 if (p[i]->level[n] == 0) {
449 break;
450 }
451 }
452
453 *slot = p[i];
454
455 return NGX_OK;
456 }
457 }
458
459 p = ngx_array_push(&cf->cycle->pathes);
460 if (p == NULL) {
461 return NGX_ERROR;
462 }
463
464 *p = path;
465
466 return NGX_OK;
467 }
468
469
470 ngx_int_t
471 ngx_create_pathes(ngx_cycle_t *cycle, ngx_uid_t user)
472 {
473 ngx_err_t err;
474 ngx_uint_t i;
475 ngx_path_t **path;
476
477 path = cycle->pathes.elts;
478 for (i = 0; i < cycle->pathes.nelts; i++) {
479
480 if (ngx_create_dir(path[i]->name.data, 0700) == NGX_FILE_ERROR) {
481 err = ngx_errno;
482 if (err != NGX_EEXIST) {
483 ngx_log_error(NGX_LOG_EMERG, cycle->log, err,
484 ngx_create_dir_n " \"%s\" failed",
485 path[i]->name.data);
486 return NGX_ERROR;
487 }
488 }
489
490 if (user == (ngx_uid_t) NGX_CONF_UNSET_UINT) {
491 continue;
492 }
493
494 #if !(NGX_WIN32)
495 {
496 ngx_file_info_t fi;
497
498 if (ngx_file_info((const char *) path[i]->name.data, &fi)
499 == NGX_FILE_ERROR)
500 {
501 ngx_log_error(NGX_LOG_EMERG, cycle->log, ngx_errno,
502 ngx_file_info_n " \"%s\" failed", path[i]->name.data);
503 return NGX_ERROR;
504 }
505
506 if (fi.st_uid != user) {
507 if (chown((const char *) path[i]->name.data, user, -1) == -1) {
508 ngx_log_error(NGX_LOG_EMERG, cycle->log, ngx_errno,
509 "chown(\"%s\", %d) failed",
510 path[i]->name.data, user);
511 return NGX_ERROR;
512 }
513 }
514
515 if ((fi.st_mode & (S_IRUSR|S_IWUSR|S_IXUSR))
516 != (S_IRUSR|S_IWUSR|S_IXUSR))
517 {
518 fi.st_mode |= (S_IRUSR|S_IWUSR|S_IXUSR);
519
520 if (chmod((const char *) path[i]->name.data, fi.st_mode) == -1) {
521 ngx_log_error(NGX_LOG_EMERG, cycle->log, ngx_errno,
522 "chmod() \"%s\" failed", path[i]->name.data);
523 return NGX_ERROR;
524 }
525 }
526 }
527 #endif
528 }
529
530 return NGX_OK;
531 }
532
533
534 ngx_int_t
535 ngx_ext_rename_file(ngx_str_t *src, ngx_str_t *to, ngx_ext_rename_file_t *ext)
536 {
537 u_char *name;
538 ngx_err_t err;
539 ngx_copy_file_t cf;
540
541 #if !(NGX_WIN32)
542
543 if (ext->access) {
544 if (ngx_change_file_access(src->data, ext->access) == NGX_FILE_ERROR) {
545 ngx_log_error(NGX_LOG_CRIT, ext->log, ngx_errno,
546 ngx_change_file_access_n " \"%s\" failed", src->data);
547 err = 0;
548 goto failed;
549 }
550 }
551
552 #endif
553
554 if (ext->time != -1) {
555 if (ngx_set_file_time(src->data, ext->fd, ext->time) != NGX_OK) {
556 ngx_log_error(NGX_LOG_CRIT, ext->log, ngx_errno,
557 ngx_set_file_time_n " \"%s\" failed", src->data);
558 err = 0;
559 goto failed;
560 }
561 }
562
563 if (ngx_rename_file(src->data, to->data) != NGX_FILE_ERROR) {
564 return NGX_OK;
565 }
566
567 err = ngx_errno;
568
569 if (err == NGX_ENOPATH) {
570
571 if (!ext->create_path) {
572 goto failed;
573 }
574
575 err = ngx_create_full_path(to->data, ngx_dir_access(ext->path_access));
576
577 if (err) {
578 ngx_log_error(NGX_LOG_CRIT, ext->log, err,
579 ngx_create_dir_n " \"%s\" failed", to->data);
580 err = 0;
581 goto failed;
582 }
583
584 if (ngx_rename_file(src->data, to->data) != NGX_FILE_ERROR) {
585 return NGX_OK;
586 }
587
588 err = ngx_errno;
589 }
590
591 #if (NGX_WIN32)
592
593 if (err == NGX_EEXIST) {
594 err = ngx_win32_rename_file(src, to, ext->log);
595
596 if (err == 0) {
597 return NGX_OK;
598 }
599 }
600
601 #endif
602
603 if (err == NGX_EXDEV) {
604
605 cf.size = -1;
606 cf.buf_size = 0;
607 cf.access = ext->access;
608 cf.time = ext->time;
609 cf.log = ext->log;
610
611 name = ngx_alloc(to->len + 1 + 10 + 1, ext->log);
612 if (name == NULL) {
613 return NGX_ERROR;
614 }
615
616 (void) ngx_sprintf(name, "%*s.%010uD%Z", to->len, to->data,
617 (uint32_t) ngx_next_temp_number(0));
618
619 if (ngx_copy_file(src->data, name, &cf) == NGX_OK) {
620
621 if (ngx_rename_file(name, to->data) != NGX_FILE_ERROR) {
622 ngx_free(name);
623
624 if (ngx_delete_file(src->data) == NGX_FILE_ERROR) {
625 ngx_log_error(NGX_LOG_CRIT, ext->log, ngx_errno,
626 ngx_delete_file_n " \"%s\" failed",
627 src->data);
628 return NGX_ERROR;
629 }
630
631 return NGX_OK;
632 }
633
634 ngx_log_error(NGX_LOG_CRIT, ext->log, ngx_errno,
635 ngx_rename_file_n " \"%s\" to \"%s\" failed",
636 name, to->data);
637
638 if (ngx_delete_file(name) == NGX_FILE_ERROR) {
639 ngx_log_error(NGX_LOG_CRIT, ext->log, ngx_errno,
640 ngx_delete_file_n " \"%s\" failed", name);
641
642 }
643 }
644
645 ngx_free(name);
646
647 err = 0;
648 }
649
650 failed:
651
652 if (ext->delete_file) {
653 if (ngx_delete_file(src->data) == NGX_FILE_ERROR) {
654 ngx_log_error(NGX_LOG_CRIT, ext->log, ngx_errno,
655 ngx_delete_file_n " \"%s\" failed", src->data);
656 }
657 }
658
659 if (err) {
660 ngx_log_error(NGX_LOG_CRIT, ext->log, err,
661 ngx_rename_file_n " \"%s\" to \"%s\" failed",
662 src->data, to->data);
663 }
664
665 return NGX_ERROR;
666 }
667
668
669 ngx_int_t
670 ngx_copy_file(u_char *from, u_char *to, ngx_copy_file_t *cf)
671 {
672 char *buf;
673 off_t size;
674 size_t len;
675 ssize_t n;
676 ngx_fd_t fd, nfd;
677 ngx_int_t rc;
678 ngx_file_info_t fi;
679
680 rc = NGX_ERROR;
681 buf = NULL;
682 nfd = NGX_INVALID_FILE;
683
684 fd = ngx_open_file(from, NGX_FILE_RDONLY, NGX_FILE_OPEN, 0);
685
686 if (fd == NGX_INVALID_FILE) {
687 ngx_log_error(NGX_LOG_CRIT, cf->log, ngx_errno,
688 ngx_open_file_n " \"%s\" failed", from);
689 goto failed;
690 }
691
692 if (cf->size != -1) {
693 size = cf->size;
694
695 } else {
696 if (ngx_fd_info(fd, &fi) == NGX_FILE_ERROR) {
697 ngx_log_error(NGX_LOG_ALERT, cf->log, ngx_errno,
698 ngx_fd_info_n " \"%s\" failed", from);
699
700 goto failed;
701 }
702
703 size = ngx_file_size(&fi);
704 }
705
706 len = cf->buf_size ? cf->buf_size : 65536;
707
708 if ((off_t) len > size) {
709 len = (size_t) size;
710 }
711
712 buf = ngx_alloc(len, cf->log);
713 if (buf == NULL) {
714 goto failed;
715 }
716
717 nfd = ngx_open_file(to, NGX_FILE_WRONLY, NGX_FILE_CREATE_OR_OPEN,
718 cf->access);
719
720 if (nfd == NGX_INVALID_FILE) {
721 ngx_log_error(NGX_LOG_CRIT, cf->log, ngx_errno,
722 ngx_open_file_n " \"%s\" failed", to);
723 goto failed;
724 }
725
726 while (size > 0) {
727
728 if ((off_t) len > size) {
729 len = (size_t) size;
730 }
731
732 n = ngx_read_fd(fd, buf, len);
733
734 if (n == NGX_FILE_ERROR) {
735 ngx_log_error(NGX_LOG_ALERT, cf->log, ngx_errno,
736 ngx_read_fd_n " \"%s\" failed", from);
737 goto failed;
738 }
739
740 if ((size_t) n != len) {
741 ngx_log_error(NGX_LOG_ALERT, cf->log, ngx_errno,
742 ngx_read_fd_n " has read only %z of %uz from %s",
743 n, size, from);
744 goto failed;
745 }
746
747 n = ngx_write_fd(nfd, buf, len);
748
749 if (n == NGX_FILE_ERROR) {
750 ngx_log_error(NGX_LOG_ALERT, cf->log, ngx_errno,
751 ngx_write_fd_n " \"%s\" failed", to);
752 goto failed;
753 }
754
755 if ((size_t) n != len) {
756 ngx_log_error(NGX_LOG_ALERT, cf->log, ngx_errno,
757 ngx_write_fd_n " has written only %z of %uz to %s",
758 n, size, to);
759 goto failed;
760 }
761
762 size -= n;
763 }
764
765 if (ngx_set_file_time(to, nfd, cf->time) != NGX_OK) {
766 ngx_log_error(NGX_LOG_ALERT, cf->log, ngx_errno,
767 ngx_set_file_time_n " \"%s\" failed", to);
768 goto failed;
769 }
770
771 rc = NGX_OK;
772
773 failed:
774
775 if (nfd != NGX_INVALID_FILE) {
776 if (ngx_close_file(nfd) == NGX_FILE_ERROR) {
777 ngx_log_error(NGX_LOG_ALERT, cf->log, ngx_errno,
778 ngx_close_file_n " \"%s\" failed", to);
779 }
780 }
781
782 if (fd != NGX_INVALID_FILE) {
783 if (ngx_close_file(fd) == NGX_FILE_ERROR) {
784 ngx_log_error(NGX_LOG_ALERT, cf->log, ngx_errno,
785 ngx_close_file_n " \"%s\" failed", from);
786 }
787 }
788
789 if (buf) {
790 ngx_free(buf);
791 }
792
793 return rc;
794 }
795
796
797 /*
798 * ctx->init_handler() - see ctx->alloc
799 * ctx->file_handler() - file handler
800 * ctx->pre_tree_handler() - handler is called before entering directory
801 * ctx->post_tree_handler() - handler is called after leaving directory
802 * ctx->spec_handler() - special (socket, FIFO, etc.) file handler
803 *
804 * ctx->data - some data structure, it may be the same on all levels, or
805 * reallocated if ctx->alloc is nonzero
806 *
807 * ctx->alloc - a size of data structure that is allocated at every level
808 * and is initilialized by ctx->init_handler()
809 *
810 * ctx->log - a log
811 *
812 * on fatal (memory) error handler must return NGX_ABORT to stop walking tree
813 */
814
815 ngx_int_t
816 ngx_walk_tree(ngx_tree_ctx_t *ctx, ngx_str_t *tree)
817 {
818 void *data, *prev;
819 u_char *p, *name;
820 size_t len;
821 ngx_int_t rc;
822 ngx_err_t err;
823 ngx_str_t file, buf;
824 ngx_dir_t dir;
825
826 buf.len = 0;
827 buf.data = NULL;
828
829 ngx_log_debug1(NGX_LOG_DEBUG_CORE, ctx->log, 0,
830 "walk tree \"%V\"", tree);
831
832 if (ngx_open_dir(tree, &dir) == NGX_ERROR) {
833 ngx_log_error(NGX_LOG_CRIT, ctx->log, ngx_errno,
834 ngx_open_dir_n " \"%s\" failed", tree->data);
835 return NGX_ERROR;
836 }
837
838 prev = ctx->data;
839
840 if (ctx->alloc) {
841 data = ngx_alloc(ctx->alloc, ctx->log);
842 if (data == NULL) {
843 goto failed;
844 }
845
846 if (ctx->init_handler(data, prev) == NGX_ABORT) {
847 goto failed;
848 }
849
850 ctx->data = data;
851
852 } else {
853 data = NULL;
854 }
855
856 for ( ;; ) {
857
858 ngx_set_errno(0);
859
860 if (ngx_read_dir(&dir) == NGX_ERROR) {
861 err = ngx_errno;
862
863 if (err == NGX_ENOMOREFILES) {
864 rc = NGX_OK;
865
866 } else {
867 ngx_log_error(NGX_LOG_CRIT, ctx->log, err,
868 ngx_read_dir_n " \"%s\" failed", tree->data);
869 rc = NGX_ERROR;
870 }
871
872 goto done;
873 }
874
875 len = ngx_de_namelen(&dir);
876 name = ngx_de_name(&dir);
877
878 ngx_log_debug2(NGX_LOG_DEBUG_CORE, ctx->log, 0,
879 "tree name %uz:\"%s\"", len, name);
880
881 if (len == 1 && name[0] == '.') {
882 continue;
883 }
884
885 if (len == 2 && name[0] == '.' && name[1] == '.') {
886 continue;
887 }
888
889 file.len = tree->len + 1 + len;
890
891 if (file.len + NGX_DIR_MASK_LEN > buf.len) {
892
893 if (buf.len) {
894 ngx_free(buf.data);
895 }
896
897 buf.len = tree->len + 1 + len + NGX_DIR_MASK_LEN;
898
899 buf.data = ngx_alloc(buf.len + 1, ctx->log);
900 if (buf.data == NULL) {
901 goto failed;
902 }
903 }
904
905 p = ngx_cpymem(buf.data, tree->data, tree->len);
906 *p++ = '/';
907 ngx_memcpy(p, name, len + 1);
908
909 file.data = buf.data;
910
911 ngx_log_debug1(NGX_LOG_DEBUG_CORE, ctx->log, 0,
912 "tree path \"%s\"", file.data);
913
914 if (!dir.valid_info) {
915 if (ngx_de_info(file.data, &dir) == NGX_FILE_ERROR) {
916 ngx_log_error(NGX_LOG_CRIT, ctx->log, ngx_errno,
917 ngx_de_info_n " \"%s\" failed", file.data);
918 continue;
919 }
920 }
921
922 if (ngx_de_is_file(&dir)) {
923
924 ngx_log_debug1(NGX_LOG_DEBUG_CORE, ctx->log, 0,
925 "tree file \"%s\"", file.data);
926
927 ctx->size = ngx_de_size(&dir);
928 ctx->access = ngx_de_access(&dir);
929 ctx->mtime = ngx_de_mtime(&dir);
930
931 if (ctx->file_handler(ctx, &file) == NGX_ABORT) {
932 goto failed;
933 }
934
935 } else if (ngx_de_is_dir(&dir)) {
936
937 ngx_log_debug1(NGX_LOG_DEBUG_CORE, ctx->log, 0,
938 "tree enter dir \"%s\"", file.data);
939
940 ctx->access = ngx_de_access(&dir);
941 ctx->mtime = ngx_de_mtime(&dir);
942
943 if (ctx->pre_tree_handler(ctx, &file) == NGX_ABORT) {
944 goto failed;
945 }
946
947 if (ngx_walk_tree(ctx, &file) == NGX_ABORT) {
948 goto failed;
949 }
950
951 ctx->access = ngx_de_access(&dir);
952 ctx->mtime = ngx_de_mtime(&dir);
953
954 if (ctx->post_tree_handler(ctx, &file) == NGX_ABORT) {
955 goto failed;
956 }
957
958 } else {
959
960 ngx_log_debug1(NGX_LOG_DEBUG_CORE, ctx->log, 0,
961 "tree special \"%s\"", file.data);
962
963 if (ctx->spec_handler(ctx, &file) == NGX_ABORT) {
964 goto failed;
965 }
966 }
967 }
968
969 failed:
970
971 rc = NGX_ABORT;
972
973 done:
974
975 if (buf.len) {
976 ngx_free(buf.data);
977 }
978
979 if (data) {
980 ngx_free(data);
981 ctx->data = prev;
982 }
983
984 if (ngx_close_dir(&dir) == NGX_ERROR) {
985 ngx_log_error(NGX_LOG_CRIT, ctx->log, ngx_errno,
986 ngx_close_dir_n " \"%s\" failed", tree->data);
987 }
988
989 return rc;
990 }
catap's nginx repository