1
2/*
3 * Copyright (C) Igor Sysoev
4 * Copyright (C) Nginx, Inc.
5 */
6
7
8#include <ngx_config.h>
9#include <ngx_core.h>
10#include <ngx_http.h>
11
12
13#define NGX_HTTP_DAV_OFF             2
14
15
16#define NGX_HTTP_DAV_NO_DEPTH        -3
17#define NGX_HTTP_DAV_INVALID_DEPTH   -2
18#define NGX_HTTP_DAV_INFINITY_DEPTH  -1
19
20
21typedef struct {
22    ngx_uint_t  methods;
23    ngx_uint_t  access;
24    ngx_uint_t  min_delete_depth;
25    ngx_flag_t  create_full_put_path;
26} ngx_http_dav_loc_conf_t;
27
28
29typedef struct {
30    ngx_str_t   path;
31    size_t      len;
32} ngx_http_dav_copy_ctx_t;
33
34
35static ngx_int_t ngx_http_dav_handler(ngx_http_request_t *r);
36
37static void ngx_http_dav_put_handler(ngx_http_request_t *r);
38
39static ngx_int_t ngx_http_dav_delete_handler(ngx_http_request_t *r);
40static ngx_int_t ngx_http_dav_delete_path(ngx_http_request_t *r,
41    ngx_str_t *path, ngx_uint_t dir);
42static ngx_int_t ngx_http_dav_delete_dir(ngx_tree_ctx_t *ctx, ngx_str_t *path);
43static ngx_int_t ngx_http_dav_delete_file(ngx_tree_ctx_t *ctx, ngx_str_t *path);
44static ngx_int_t ngx_http_dav_noop(ngx_tree_ctx_t *ctx, ngx_str_t *path);
45
46static ngx_int_t ngx_http_dav_mkcol_handler(ngx_http_request_t *r,
47    ngx_http_dav_loc_conf_t *dlcf);
48
49static ngx_int_t ngx_http_dav_copy_move_handler(ngx_http_request_t *r);
50static ngx_int_t ngx_http_dav_copy_dir(ngx_tree_ctx_t *ctx, ngx_str_t *path);
51static ngx_int_t ngx_http_dav_copy_dir_time(ngx_tree_ctx_t *ctx,
52    ngx_str_t *path);
53static ngx_int_t ngx_http_dav_copy_tree_file(ngx_tree_ctx_t *ctx,
54    ngx_str_t *path);
55
56static ngx_int_t ngx_http_dav_depth(ngx_http_request_t *r, ngx_int_t dflt);
57static ngx_int_t ngx_http_dav_error(ngx_log_t *log, ngx_err_t err,
58    ngx_int_t not_found, char *failed, u_char *path);
59static ngx_int_t ngx_http_dav_location(ngx_http_request_t *r, u_char *path);
60static void *ngx_http_dav_create_loc_conf(ngx_conf_t *cf);
61static char *ngx_http_dav_merge_loc_conf(ngx_conf_t *cf,
62    void *parent, void *child);
63static ngx_int_t ngx_http_dav_init(ngx_conf_t *cf);
64
65
66static ngx_conf_bitmask_t  ngx_http_dav_methods_mask[] = {
67    { ngx_string("off"), NGX_HTTP_DAV_OFF },
68    { ngx_string("put"), NGX_HTTP_PUT },
69    { ngx_string("delete"), NGX_HTTP_DELETE },
70    { ngx_string("mkcol"), NGX_HTTP_MKCOL },
71    { ngx_string("copy"), NGX_HTTP_COPY },
72    { ngx_string("move"), NGX_HTTP_MOVE },
73    { ngx_null_string, 0 }
74};
75
76
77static ngx_command_t  ngx_http_dav_commands[] = {
78
79    { ngx_string("dav_methods"),
80      NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_1MORE,
81      ngx_conf_set_bitmask_slot,
82      NGX_HTTP_LOC_CONF_OFFSET,
83      offsetof(ngx_http_dav_loc_conf_t, methods),
84      &ngx_http_dav_methods_mask },
85
86    { ngx_string("create_full_put_path"),
87      NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
88      ngx_conf_set_flag_slot,
89      NGX_HTTP_LOC_CONF_OFFSET,
90      offsetof(ngx_http_dav_loc_conf_t, create_full_put_path),
91      NULL },
92
93    { ngx_string("min_delete_depth"),
94      NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
95      ngx_conf_set_num_slot,
96      NGX_HTTP_LOC_CONF_OFFSET,
97      offsetof(ngx_http_dav_loc_conf_t, min_delete_depth),
98      NULL },
99
100    { ngx_string("dav_access"),
101      NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE123,
102      ngx_conf_set_access_slot,
103      NGX_HTTP_LOC_CONF_OFFSET,
104      offsetof(ngx_http_dav_loc_conf_t, access),
105      NULL },
106
107      ngx_null_command
108};
109
110
111static ngx_http_module_t  ngx_http_dav_module_ctx = {
112    NULL,                                  /* preconfiguration */
113    ngx_http_dav_init,                     /* postconfiguration */
114
115    NULL,                                  /* create main configuration */
116    NULL,                                  /* init main configuration */
117
118    NULL,                                  /* create server configuration */
119    NULL,                                  /* merge server configuration */
120
121    ngx_http_dav_create_loc_conf,          /* create location configuration */
122    ngx_http_dav_merge_loc_conf            /* merge location configuration */
123};
124
125
126ngx_module_t  ngx_http_dav_module = {
127    NGX_MODULE_V1,
128    &ngx_http_dav_module_ctx,              /* module context */
129    ngx_http_dav_commands,                 /* module directives */
130    NGX_HTTP_MODULE,                       /* module type */
131    NULL,                                  /* init master */
132    NULL,                                  /* init module */
133    NULL,                                  /* init process */
134    NULL,                                  /* init thread */
135    NULL,                                  /* exit thread */
136    NULL,                                  /* exit process */
137    NULL,                                  /* exit master */
138    NGX_MODULE_V1_PADDING
139};
140
141
142static ngx_int_t
143ngx_http_dav_handler(ngx_http_request_t *r)
144{
145    ngx_int_t                 rc;
146    ngx_http_dav_loc_conf_t  *dlcf;
147
148    dlcf = ngx_http_get_module_loc_conf(r, ngx_http_dav_module);
149
150    if (!(r->method & dlcf->methods)) {
151        return NGX_DECLINED;
152    }
153
154    switch (r->method) {
155
156    case NGX_HTTP_PUT:
157
158        if (r->uri.data[r->uri.len - 1] == '/') {
159            ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
160                          "cannot PUT to a collection");
161            return NGX_HTTP_CONFLICT;
162        }
163
164        if (r->headers_in.content_range) {
165            ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
166                          "PUT with range is unsupported");
167            return NGX_HTTP_NOT_IMPLEMENTED;
168        }
169
170        r->request_body_in_file_only = 1;
171        r->request_body_in_persistent_file = 1;
172        r->request_body_in_clean_file = 1;
173        r->request_body_file_group_access = 1;
174        r->request_body_file_log_level = 0;
175
176        rc = ngx_http_read_client_request_body(r, ngx_http_dav_put_handler);
177
178        if (rc >= NGX_HTTP_SPECIAL_RESPONSE) {
179            return rc;
180        }
181
182        return NGX_DONE;
183
184    case NGX_HTTP_DELETE:
185
186        return ngx_http_dav_delete_handler(r);
187
188    case NGX_HTTP_MKCOL:
189
190        return ngx_http_dav_mkcol_handler(r, dlcf);
191
192    case NGX_HTTP_COPY:
193
194        return ngx_http_dav_copy_move_handler(r);
195
196    case NGX_HTTP_MOVE:
197
198        return ngx_http_dav_copy_move_handler(r);
199    }
200
201    return NGX_DECLINED;
202}
203
204
205static void
206ngx_http_dav_put_handler(ngx_http_request_t *r)
207{
208    size_t                    root;
209    time_t                    date;
210    ngx_str_t                *temp, path;
211    ngx_uint_t                status;
212    ngx_file_info_t           fi;
213    ngx_ext_rename_file_t     ext;
214    ngx_http_dav_loc_conf_t  *dlcf;
215
216    if (r->request_body == NULL || r->request_body->temp_file == NULL) {
217        ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
218        return;
219    }
220
221    if (ngx_http_map_uri_to_path(r, &path, &root, 0) == NULL) {
222        ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
223        return;
224    }
225
226    path.len--;
227
228    ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
229                   "http put filename: \"%s\"", path.data);
230
231    temp = &r->request_body->temp_file->file.name;
232
233    if (ngx_file_info(path.data, &fi) == NGX_FILE_ERROR) {
234        status = NGX_HTTP_CREATED;
235
236    } else {
237        status = NGX_HTTP_NO_CONTENT;
238
239        if (ngx_is_dir(&fi)) {
240            ngx_log_error(NGX_LOG_ERR, r->connection->log, NGX_EISDIR,
241                          "\"%s\" could not be created", path.data);
242
243            if (ngx_delete_file(temp->data) == NGX_FILE_ERROR) {
244                ngx_log_error(NGX_LOG_CRIT, r->connection->log, ngx_errno,
245                              ngx_delete_file_n " \"%s\" failed",
246                              temp->data);
247            }
248
249            ngx_http_finalize_request(r, NGX_HTTP_CONFLICT);
250            return;
251        }
252    }
253
254    dlcf = ngx_http_get_module_loc_conf(r, ngx_http_dav_module);
255
256    ext.access = dlcf->access;
257    ext.path_access = dlcf->access;
258    ext.time = -1;
259    ext.create_path = dlcf->create_full_put_path;
260    ext.delete_file = 1;
261    ext.log = r->connection->log;
262
263    if (r->headers_in.date) {
264        date = ngx_parse_http_time(r->headers_in.date->value.data,
265                                   r->headers_in.date->value.len);
266
267        if (date != NGX_ERROR) {
268            ext.time = date;
269            ext.fd = r->request_body->temp_file->file.fd;
270        }
271    }
272
273    if (ngx_ext_rename_file(temp, &path, &ext) != NGX_OK) {
274        ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
275        return;
276    }
277
278    if (status == NGX_HTTP_CREATED) {
279        if (ngx_http_dav_location(r, path.data) != NGX_OK) {
280            ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
281            return;
282        }
283
284        r->headers_out.content_length_n = 0;
285    }
286
287    r->headers_out.status = status;
288    r->header_only = 1;
289
290    ngx_http_finalize_request(r, ngx_http_send_header(r));
291    return;
292}
293
294
295static ngx_int_t
296ngx_http_dav_delete_handler(ngx_http_request_t *r)
297{
298    size_t                    root;
299    ngx_err_t                 err;
300    ngx_int_t                 rc, depth;
301    ngx_uint_t                i, d, dir;
302    ngx_str_t                 path;
303    ngx_file_info_t           fi;
304    ngx_http_dav_loc_conf_t  *dlcf;
305
306    if (r->headers_in.content_length_n > 0) {
307        ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
308                      "DELETE with body is unsupported");
309        return NGX_HTTP_UNSUPPORTED_MEDIA_TYPE;
310    }
311
312    dlcf = ngx_http_get_module_loc_conf(r, ngx_http_dav_module);
313
314    if (dlcf->min_delete_depth) {
315        d = 0;
316
317        for (i = 0; i < r->uri.len; /* void */) {
318            if (r->uri.data[i++] == '/') {
319                if (++d >= dlcf->min_delete_depth && i < r->uri.len) {
320                    goto ok;
321                }
322            }
323        }
324
325        ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
326                      "insufficient URI depth:%i to DELETE", d);
327        return NGX_HTTP_CONFLICT;
328    }
329
330ok:
331
332    if (ngx_http_map_uri_to_path(r, &path, &root, 0) == NULL) {
333        return NGX_HTTP_INTERNAL_SERVER_ERROR;
334    }
335
336    ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
337                   "http delete filename: \"%s\"", path.data);
338
339    if (ngx_link_info(path.data, &fi) == NGX_FILE_ERROR) {
340        err = ngx_errno;
341
342        rc = (err == NGX_ENOTDIR) ? NGX_HTTP_CONFLICT : NGX_HTTP_NOT_FOUND;
343
344        return ngx_http_dav_error(r->connection->log, err,
345                                  rc, ngx_link_info_n, path.data);
346    }
347
348    if (ngx_is_dir(&fi)) {
349
350        if (r->uri.data[r->uri.len - 1] != '/') {
351            ngx_log_error(NGX_LOG_ERR, r->connection->log, NGX_EISDIR,
352                          "DELETE \"%s\" failed", path.data);
353            return NGX_HTTP_CONFLICT;
354        }
355
356        depth = ngx_http_dav_depth(r, NGX_HTTP_DAV_INFINITY_DEPTH);
357
358        if (depth != NGX_HTTP_DAV_INFINITY_DEPTH) {
359            ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
360                          "\"Depth\" header must be infinity");
361            return NGX_HTTP_BAD_REQUEST;
362        }
363
364        path.len -= 2;  /* omit "/\0" */
365
366        dir = 1;
367
368    } else {
369
370        /*
371         * we do not need to test (r->uri.data[r->uri.len - 1] == '/')
372         * because ngx_link_info("/file/") returned NGX_ENOTDIR above
373         */
374
375        depth = ngx_http_dav_depth(r, 0);
376
377        if (depth != 0 && depth != NGX_HTTP_DAV_INFINITY_DEPTH) {
378            ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
379                          "\"Depth\" header must be 0 or infinity");
380            return NGX_HTTP_BAD_REQUEST;
381        }
382
383        dir = 0;
384    }
385
386    rc = ngx_http_dav_delete_path(r, &path, dir);
387
388    if (rc == NGX_OK) {
389        return NGX_HTTP_NO_CONTENT;
390    }
391
392    return rc;
393}
394
395
396static ngx_int_t
397ngx_http_dav_delete_path(ngx_http_request_t *r, ngx_str_t *path, ngx_uint_t dir)
398{
399    char            *failed;
400    ngx_tree_ctx_t   tree;
401
402    if (dir) {
403
404        tree.init_handler = NULL;
405        tree.file_handler = ngx_http_dav_delete_file;
406        tree.pre_tree_handler = ngx_http_dav_noop;
407        tree.post_tree_handler = ngx_http_dav_delete_dir;
408        tree.spec_handler = ngx_http_dav_delete_file;
409        tree.data = NULL;
410        tree.alloc = 0;
411        tree.log = r->connection->log;
412
413        /* TODO: 207 */
414
415        if (ngx_walk_tree(&tree, path) != NGX_OK) {
416            return NGX_HTTP_INTERNAL_SERVER_ERROR;
417        }
418
419        if (ngx_delete_dir(path->data) != NGX_FILE_ERROR) {
420            return NGX_OK;
421        }
422
423        failed = ngx_delete_dir_n;
424
425    } else {
426
427        if (ngx_delete_file(path->data) != NGX_FILE_ERROR) {
428            return NGX_OK;
429        }
430
431        failed = ngx_delete_file_n;
432    }
433
434    return ngx_http_dav_error(r->connection->log, ngx_errno,
435                              NGX_HTTP_NOT_FOUND, failed, path->data);
436}
437
438
439static ngx_int_t
440ngx_http_dav_delete_dir(ngx_tree_ctx_t *ctx, ngx_str_t *path)
441{
442    ngx_log_debug1(NGX_LOG_DEBUG_HTTP, ctx->log, 0,
443                   "http delete dir: \"%s\"", path->data);
444
445    if (ngx_delete_dir(path->data) == NGX_FILE_ERROR) {
446
447        /* TODO: add to 207 */
448
449        (void) ngx_http_dav_error(ctx->log, ngx_errno, 0, ngx_delete_dir_n,
450                                  path->data);
451    }
452
453    return NGX_OK;
454}
455
456
457static ngx_int_t
458ngx_http_dav_delete_file(ngx_tree_ctx_t *ctx, ngx_str_t *path)
459{
460    ngx_log_debug1(NGX_LOG_DEBUG_HTTP, ctx->log, 0,
461                   "http delete file: \"%s\"", path->data);
462
463    if (ngx_delete_file(path->data) == NGX_FILE_ERROR) {
464
465        /* TODO: add to 207 */
466
467        (void) ngx_http_dav_error(ctx->log, ngx_errno, 0, ngx_delete_file_n,
468                                  path->data);
469    }
470
471    return NGX_OK;
472}
473
474
475static ngx_int_t
476ngx_http_dav_noop(ngx_tree_ctx_t *ctx, ngx_str_t *path)
477{
478    return NGX_OK;
479}
480
481
482static ngx_int_t
483ngx_http_dav_mkcol_handler(ngx_http_request_t *r, ngx_http_dav_loc_conf_t *dlcf)
484{
485    u_char    *p;
486    size_t     root;
487    ngx_str_t  path;
488
489    if (r->headers_in.content_length_n > 0) {
490        ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
491                      "MKCOL with body is unsupported");
492        return NGX_HTTP_UNSUPPORTED_MEDIA_TYPE;
493    }
494
495    if (r->uri.data[r->uri.len - 1] != '/') {
496        ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
497                      "MKCOL can create a collection only");
498        return NGX_HTTP_CONFLICT;
499    }
500
501    p = ngx_http_map_uri_to_path(r, &path, &root, 0);
502    if (p == NULL) {
503        return NGX_HTTP_INTERNAL_SERVER_ERROR;
504    }
505
506    *(p - 1) = '\0';
507    r->uri.len--;
508
509    ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
510                   "http mkcol path: \"%s\"", path.data);
511
512    if (ngx_create_dir(path.data, ngx_dir_access(dlcf->access))
513        != NGX_FILE_ERROR)
514    {
515        if (ngx_http_dav_location(r, path.data) != NGX_OK) {
516            return NGX_HTTP_INTERNAL_SERVER_ERROR;
517        }
518
519        return NGX_HTTP_CREATED;
520    }
521
522    return ngx_http_dav_error(r->connection->log, ngx_errno,
523                              NGX_HTTP_CONFLICT, ngx_create_dir_n, path.data);
524}
525
526
527static ngx_int_t
528ngx_http_dav_copy_move_handler(ngx_http_request_t *r)
529{
530    u_char                   *p, *host, *last, ch;
531    size_t                    len, root;
532    ngx_err_t                 err;
533    ngx_int_t                 rc, depth;
534    ngx_uint_t                overwrite, slash, dir, flags;
535    ngx_str_t                 path, uri, duri, args;
536    ngx_tree_ctx_t            tree;
537    ngx_copy_file_t           cf;
538    ngx_file_info_t           fi;
539    ngx_table_elt_t          *dest, *over;
540    ngx_ext_rename_file_t     ext;
541    ngx_http_dav_copy_ctx_t   copy;
542    ngx_http_dav_loc_conf_t  *dlcf;
543
544    if (r->headers_in.content_length_n > 0) {
545        return NGX_HTTP_UNSUPPORTED_MEDIA_TYPE;
546    }
547
548    dest = r->headers_in.destination;
549
550    if (dest == NULL) {
551        ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
552                      "client sent no \"Destination\" header");
553        return NGX_HTTP_BAD_REQUEST;
554    }
555
556    p = dest->value.data;
557    /* there is always '\0' even after empty header value */
558    if (p[0] == '/') {
559        last = p + dest->value.len;
560        goto destination_done;
561    }
562
563    len = r->headers_in.server.len;
564
565    if (len == 0) {
566        ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
567                      "client sent no \"Host\" header");
568        return NGX_HTTP_BAD_REQUEST;
569    }
570
571#if (NGX_HTTP_SSL)
572
573    if (r->connection->ssl) {
574        if (ngx_strncmp(dest->value.data, "https://", sizeof("https://") - 1)
575            != 0)
576        {
577            goto invalid_destination;
578        }
579
580        host = dest->value.data + sizeof("https://") - 1;
581
582    } else
583#endif
584    {
585        if (ngx_strncmp(dest->value.data, "http://", sizeof("http://") - 1)
586            != 0)
587        {
588            goto invalid_destination;
589        }
590
591        host = dest->value.data + sizeof("http://") - 1;
592    }
593
594    if (ngx_strncmp(host, r->headers_in.server.data, len) != 0) {
595        ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
596                      "\"Destination\" URI \"%V\" is handled by "
597                      "different repository than the source URI",
598                      &dest->value);
599        return NGX_HTTP_BAD_REQUEST;
600    }
601
602    last = dest->value.data + dest->value.len;
603
604    for (p = host + len; p < last; p++) {
605        if (*p == '/') {
606            goto destination_done;
607        }
608    }
609
610invalid_destination:
611
612    ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
613                  "client sent invalid \"Destination\" header: \"%V\"",
614                  &dest->value);
615    return NGX_HTTP_BAD_REQUEST;
616
617destination_done:
618
619    duri.len = last - p;
620    duri.data = p;
621    flags = NGX_HTTP_LOG_UNSAFE;
622
623    if (ngx_http_parse_unsafe_uri(r, &duri, &args, &flags) != NGX_OK) {
624        goto invalid_destination;
625    }
626
627    if ((r->uri.data[r->uri.len - 1] == '/' && *(last - 1) != '/')
628        || (r->uri.data[r->uri.len - 1] != '/' && *(last - 1) == '/'))
629    {
630        ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
631                      "both URI \"%V\" and \"Destination\" URI \"%V\" "
632                      "should be either collections or non-collections",
633                      &r->uri, &dest->value);
634        return NGX_HTTP_CONFLICT;
635    }
636
637    depth = ngx_http_dav_depth(r, NGX_HTTP_DAV_INFINITY_DEPTH);
638
639    if (depth != NGX_HTTP_DAV_INFINITY_DEPTH) {
640
641        if (r->method == NGX_HTTP_COPY) {
642            if (depth != 0) {
643                ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
644                              "\"Depth\" header must be 0 or infinity");
645                return NGX_HTTP_BAD_REQUEST;
646            }
647
648        } else {
649            ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
650                          "\"Depth\" header must be infinity");
651            return NGX_HTTP_BAD_REQUEST;
652        }
653    }
654
655    over = r->headers_in.overwrite;
656
657    if (over) {
658        if (over->value.len == 1) {
659            ch = over->value.data[0];
660
661            if (ch == 'T' || ch == 't') {
662                overwrite = 1;
663                goto overwrite_done;
664            }
665
666            if (ch == 'F' || ch == 'f') {
667                overwrite = 0;
668                goto overwrite_done;
669            }
670
671        }
672
673        ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
674                      "client sent invalid \"Overwrite\" header: \"%V\"",
675                      &over->value);
676        return NGX_HTTP_BAD_REQUEST;
677    }
678
679    overwrite = 1;
680
681overwrite_done:
682
683    if (ngx_http_map_uri_to_path(r, &path, &root, 0) == NULL) {
684        return NGX_HTTP_INTERNAL_SERVER_ERROR;
685    }
686
687    ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
688                   "http copy from: \"%s\"", path.data);
689
690    uri = r->uri;
691    r->uri = duri;
692
693    if (ngx_http_map_uri_to_path(r, &copy.path, &root, 0) == NULL) {
694        return NGX_HTTP_INTERNAL_SERVER_ERROR;
695    }
696
697    r->uri = uri;
698
699    copy.path.len--;  /* omit "\0" */
700
701    if (copy.path.data[copy.path.len - 1] == '/') {
702        slash = 1;
703        copy.path.len--;
704        copy.path.data[copy.path.len] = '\0';
705
706    } else {
707        slash = 0;
708    }
709
710    ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
711                   "http copy to: \"%s\"", copy.path.data);
712
713    if (ngx_link_info(copy.path.data, &fi) == NGX_FILE_ERROR) {
714        err = ngx_errno;
715
716        if (err != NGX_ENOENT) {
717            return ngx_http_dav_error(r->connection->log, err,
718                                      NGX_HTTP_NOT_FOUND, ngx_link_info_n,
719                                      copy.path.data);
720        }
721
722        /* destination does not exist */
723
724        overwrite = 0;
725        dir = 0;
726
727    } else {
728
729        /* destination exists */
730
731        if (ngx_is_dir(&fi) && !slash) {
732            ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
733                          "\"%V\" could not be %Ved to collection \"%V\"",
734                          &r->uri, &r->method_name, &dest->value);
735            return NGX_HTTP_CONFLICT;
736        }
737
738        if (!overwrite) {
739            ngx_log_error(NGX_LOG_ERR, r->connection->log, NGX_EEXIST,
740                          "\"%s\" could not be created", copy.path.data);
741            return NGX_HTTP_PRECONDITION_FAILED;
742        }
743
744        dir = ngx_is_dir(&fi);
745    }
746
747    if (ngx_link_info(path.data, &fi) == NGX_FILE_ERROR) {
748        return ngx_http_dav_error(r->connection->log, ngx_errno,
749                                  NGX_HTTP_NOT_FOUND, ngx_link_info_n,
750                                  path.data);
751    }
752
753    if (ngx_is_dir(&fi)) {
754
755        if (r->uri.data[r->uri.len - 1] != '/') {
756            ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
757                          "\"%V\" is collection", &r->uri);
758            return NGX_HTTP_BAD_REQUEST;
759        }
760
761        if (overwrite) {
762            ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
763                           "http delete: \"%s\"", copy.path.data);
764
765            rc = ngx_http_dav_delete_path(r, &copy.path, dir);
766
767            if (rc != NGX_OK) {
768                return rc;
769            }
770        }
771    }
772
773    if (ngx_is_dir(&fi)) {
774
775        path.len -= 2;  /* omit "/\0" */
776
777        if (r->method == NGX_HTTP_MOVE) {
778            if (ngx_rename_file(path.data, copy.path.data) != NGX_FILE_ERROR) {
779                return NGX_HTTP_CREATED;
780            }
781        }
782
783        if (ngx_create_dir(copy.path.data, ngx_file_access(&fi))
784            == NGX_FILE_ERROR)
785        {
786            return ngx_http_dav_error(r->connection->log, ngx_errno,
787                                      NGX_HTTP_NOT_FOUND,
788                                      ngx_create_dir_n, copy.path.data);
789        }
790
791        copy.len = path.len;
792
793        tree.init_handler = NULL;
794        tree.file_handler = ngx_http_dav_copy_tree_file;
795        tree.pre_tree_handler = ngx_http_dav_copy_dir;
796        tree.post_tree_handler = ngx_http_dav_copy_dir_time;
797        tree.spec_handler = ngx_http_dav_noop;
798        tree.data = &copy;
799        tree.alloc = 0;
800        tree.log = r->connection->log;
801
802        if (ngx_walk_tree(&tree, &path) == NGX_OK) {
803
804            if (r->method == NGX_HTTP_MOVE) {
805                rc = ngx_http_dav_delete_path(r, &path, 1);
806
807                if (rc != NGX_OK) {
808                    return rc;
809                }
810            }
811
812            return NGX_HTTP_CREATED;
813        }
814
815    } else {
816
817        if (r->method == NGX_HTTP_MOVE) {
818
819            dlcf = ngx_http_get_module_loc_conf(r, ngx_http_dav_module);
820
821            ext.access = 0;
822            ext.path_access = dlcf->access;
823            ext.time = -1;
824            ext.create_path = 1;
825            ext.delete_file = 0;
826            ext.log = r->connection->log;
827
828            if (ngx_ext_rename_file(&path, &copy.path, &ext) == NGX_OK) {
829                return NGX_HTTP_NO_CONTENT;
830            }
831
832            return NGX_HTTP_INTERNAL_SERVER_ERROR;
833        }
834
835        dlcf = ngx_http_get_module_loc_conf(r, ngx_http_dav_module);
836
837        cf.size = ngx_file_size(&fi);
838        cf.buf_size = 0;
839        cf.access = dlcf->access;
840        cf.time = ngx_file_mtime(&fi);
841        cf.log = r->connection->log;
842
843        if (ngx_copy_file(path.data, copy.path.data, &cf) == NGX_OK) {
844            return NGX_HTTP_NO_CONTENT;
845        }
846    }
847
848    return NGX_HTTP_INTERNAL_SERVER_ERROR;
849}
850
851
852static ngx_int_t
853ngx_http_dav_copy_dir(ngx_tree_ctx_t *ctx, ngx_str_t *path)
854{
855    u_char                   *p, *dir;
856    size_t                    len;
857    ngx_http_dav_copy_ctx_t  *copy;
858
859    ngx_log_debug1(NGX_LOG_DEBUG_HTTP, ctx->log, 0,
860                   "http copy dir: \"%s\"", path->data);
861
862    copy = ctx->data;
863
864    len = copy->path.len + path->len;
865
866    dir = ngx_alloc(len + 1, ctx->log);
867    if (dir == NULL) {
868        return NGX_ABORT;
869    }
870
871    p = ngx_cpymem(dir, copy->path.data, copy->path.len);
872    (void) ngx_cpystrn(p, path->data + copy->len, path->len - copy->len + 1);
873
874    ngx_log_debug1(NGX_LOG_DEBUG_HTTP, ctx->log, 0,
875                   "http copy dir to: \"%s\"", dir);
876
877    if (ngx_create_dir(dir, ngx_dir_access(ctx->access)) == NGX_FILE_ERROR) {
878        (void) ngx_http_dav_error(ctx->log, ngx_errno, 0, ngx_create_dir_n,
879                                  dir);
880    }
881
882    ngx_free(dir);
883
884    return NGX_OK;
885}
886
887
888static ngx_int_t
889ngx_http_dav_copy_dir_time(ngx_tree_ctx_t *ctx, ngx_str_t *path)
890{
891    u_char                   *p, *dir;
892    size_t                    len;
893    ngx_http_dav_copy_ctx_t  *copy;
894
895    ngx_log_debug1(NGX_LOG_DEBUG_HTTP, ctx->log, 0,
896                   "http copy dir time: \"%s\"", path->data);
897
898    copy = ctx->data;
899
900    len = copy->path.len + path->len;
901
902    dir = ngx_alloc(len + 1, ctx->log);
903    if (dir == NULL) {
904        return NGX_ABORT;
905    }
906
907    p = ngx_cpymem(dir, copy->path.data, copy->path.len);
908    (void) ngx_cpystrn(p, path->data + copy->len, path->len - copy->len + 1);
909
910    ngx_log_debug1(NGX_LOG_DEBUG_HTTP, ctx->log, 0,
911                   "http copy dir time to: \"%s\"", dir);
912
913#if (NGX_WIN32)
914    {
915    ngx_fd_t  fd;
916
917    fd = ngx_open_file(dir, NGX_FILE_RDWR, NGX_FILE_OPEN, 0);
918
919    if (fd == NGX_INVALID_FILE) {
920        (void) ngx_http_dav_error(ctx->log, ngx_errno, 0, ngx_open_file_n, dir);
921        goto failed;
922    }
923
924    if (ngx_set_file_time(NULL, fd, ctx->mtime) != NGX_OK) {
925        ngx_log_error(NGX_LOG_ALERT, ctx->log, ngx_errno,
926                      ngx_set_file_time_n " \"%s\" failed", dir);
927    }
928
929    if (ngx_close_file(fd) == NGX_FILE_ERROR) {
930        ngx_log_error(NGX_LOG_ALERT, ctx->log, ngx_errno,
931                      ngx_close_file_n " \"%s\" failed", dir);
932    }
933    }
934
935failed:
936
937#else
938
939    if (ngx_set_file_time(dir, 0, ctx->mtime) != NGX_OK) {
940        ngx_log_error(NGX_LOG_ALERT, ctx->log, ngx_errno,
941                      ngx_set_file_time_n " \"%s\" failed", dir);
942    }
943
944#endif
945
946    ngx_free(dir);
947
948    return NGX_OK;
949}
950
951
952static ngx_int_t
953ngx_http_dav_copy_tree_file(ngx_tree_ctx_t *ctx, ngx_str_t *path)
954{
955    u_char                   *p, *file;
956    size_t                    len;
957    ngx_copy_file_t           cf;
958    ngx_http_dav_copy_ctx_t  *copy;
959
960    ngx_log_debug1(NGX_LOG_DEBUG_HTTP, ctx->log, 0,
961                   "http copy file: \"%s\"", path->data);
962
963    copy = ctx->data;
964
965    len = copy->path.len + path->len;
966
967    file = ngx_alloc(len + 1, ctx->log);
968    if (file == NULL) {
969        return NGX_ABORT;
970    }
971
972    p = ngx_cpymem(file, copy->path.data, copy->path.len);
973    (void) ngx_cpystrn(p, path->data + copy->len, path->len - copy->len + 1);
974
975    ngx_log_debug1(NGX_LOG_DEBUG_HTTP, ctx->log, 0,
976                   "http copy file to: \"%s\"", file);
977
978    cf.size = ctx->size;
979    cf.buf_size = 0;
980    cf.access = ctx->access;
981    cf.time = ctx->mtime;
982    cf.log = ctx->log;
983
984    (void) ngx_copy_file(path->data, file, &cf);
985
986    ngx_free(file);
987
988    return NGX_OK;
989}
990
991
992static ngx_int_t
993ngx_http_dav_depth(ngx_http_request_t *r, ngx_int_t dflt)
994{
995    ngx_table_elt_t  *depth;
996
997    depth = r->headers_in.depth;
998
999    if (depth == NULL) {
1000        return dflt;
1001    }
1002
1003    if (depth->value.len == 1) {
1004
1005        if (depth->value.data[0] == '0') {
1006            return 0;
1007        }
1008
1009        if (depth->value.data[0] == '1') {
1010            return 1;
1011        }
1012
1013    } else {
1014
1015        if (depth->value.len == sizeof("infinity") - 1
1016            && ngx_strcmp(depth->value.data, "infinity") == 0)
1017        {
1018            return NGX_HTTP_DAV_INFINITY_DEPTH;
1019        }
1020    }
1021
1022    ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
1023                  "client sent invalid \"Depth\" header: \"%V\"",
1024                  &depth->value);
1025
1026    return NGX_HTTP_DAV_INVALID_DEPTH;
1027}
1028
1029
1030static ngx_int_t
1031ngx_http_dav_error(ngx_log_t *log, ngx_err_t err, ngx_int_t not_found,
1032    char *failed, u_char *path)
1033{
1034    ngx_int_t   rc;
1035    ngx_uint_t  level;
1036
1037    if (err == NGX_ENOENT || err == NGX_ENOTDIR || err == NGX_ENAMETOOLONG) {
1038        level = NGX_LOG_ERR;
1039        rc = not_found;
1040
1041    } else if (err == NGX_EACCES || err == NGX_EPERM) {
1042        level = NGX_LOG_ERR;
1043        rc = NGX_HTTP_FORBIDDEN;
1044
1045    } else if (err == NGX_EEXIST) {
1046        level = NGX_LOG_ERR;
1047        rc = NGX_HTTP_NOT_ALLOWED;
1048
1049    } else if (err == NGX_ENOSPC) {
1050        level = NGX_LOG_CRIT;
1051        rc = NGX_HTTP_INSUFFICIENT_STORAGE;
1052
1053    } else {
1054        level = NGX_LOG_CRIT;
1055        rc = NGX_HTTP_INTERNAL_SERVER_ERROR;
1056    }
1057
1058    ngx_log_error(level, log, err, "%s \"%s\" failed", failed, path);
1059
1060    return rc;
1061}
1062
1063
1064static ngx_int_t
1065ngx_http_dav_location(ngx_http_request_t *r, u_char *path)
1066{
1067    u_char                    *location;
1068    ngx_http_core_loc_conf_t  *clcf;
1069
1070    r->headers_out.location = ngx_list_push(&r->headers_out.headers);
1071    if (r->headers_out.location == NULL) {
1072        return NGX_ERROR;
1073    }
1074
1075    clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);
1076
1077    if (!clcf->alias && clcf->root_lengths == NULL) {
1078        location = path + clcf->root.len;
1079
1080    } else {
1081        location = ngx_pnalloc(r->pool, r->uri.len);
1082        if (location == NULL) {
1083            return NGX_ERROR;
1084        }
1085
1086        ngx_memcpy(location, r->uri.data, r->uri.len);
1087    }
1088
1089    r->headers_out.location->hash = 1;
1090    ngx_str_set(&r->headers_out.location->key, "Location");
1091    r->headers_out.location->value.len = r->uri.len;
1092    r->headers_out.location->value.data = location;
1093
1094    return NGX_OK;
1095}
1096
1097
1098static void *
1099ngx_http_dav_create_loc_conf(ngx_conf_t *cf)
1100{
1101    ngx_http_dav_loc_conf_t  *conf;
1102
1103    conf = ngx_pcalloc(cf->pool, sizeof(ngx_http_dav_loc_conf_t));
1104    if (conf == NULL) {
1105        return NULL;
1106    }
1107
1108    /*
1109     * set by ngx_pcalloc():
1110     *
1111     *     conf->methods = 0;
1112     */
1113
1114    conf->min_delete_depth = NGX_CONF_UNSET_UINT;
1115    conf->access = NGX_CONF_UNSET_UINT;
1116    conf->create_full_put_path = NGX_CONF_UNSET;
1117
1118    return conf;
1119}
1120
1121
1122static char *
1123ngx_http_dav_merge_loc_conf(ngx_conf_t *cf, void *parent, void *child)
1124{
1125    ngx_http_dav_loc_conf_t  *prev = parent;
1126    ngx_http_dav_loc_conf_t  *conf = child;
1127
1128    ngx_conf_merge_bitmask_value(conf->methods, prev->methods,
1129                         (NGX_CONF_BITMASK_SET|NGX_HTTP_DAV_OFF));
1130
1131    ngx_conf_merge_uint_value(conf->min_delete_depth,
1132                         prev->min_delete_depth, 0);
1133
1134    ngx_conf_merge_uint_value(conf->access, prev->access, 0600);
1135
1136    ngx_conf_merge_value(conf->create_full_put_path,
1137                         prev->create_full_put_path, 0);
1138
1139    return NGX_CONF_OK;
1140}
1141
1142
1143static ngx_int_t
1144ngx_http_dav_init(ngx_conf_t *cf)
1145{
1146    ngx_http_handler_pt        *h;
1147    ngx_http_core_main_conf_t  *cmcf;
1148
1149    cmcf = ngx_http_conf_get_module_main_conf(cf, ngx_http_core_module);
1150
1151    h = ngx_array_push(&cmcf->phases[NGX_HTTP_CONTENT_PHASE].handlers);
1152    if (h == NULL) {
1153        return NGX_ERROR;
1154    }
1155
1156    *h = ngx_http_dav_handler;
1157
1158    return NGX_OK;
1159}
1160