src/http/modules/download/ngx_http_filesync.c

Go to the documentation of this file.

/*
 *  Copyright 2009 DreamLab Onet.pl Sp. z o.o.
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *  http://www.apache.org/licenses/LICENSE-2.0
 *
 *   Unless required by applicable law or agreed to in writing, software
 *   distributed under the License is distributed on an "AS IS" BASIS,
 *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *   See the License for the specific language governing permissions and
 *   limitations under the License.
 *
 *
 * Authors:
 * Przemyslaw Gajda, email: quermit(malpa)gmail.com
 * Piotr Janik, email: janik.piotrek(malpa)gmail.com
 *                                                                       malpa = @
 */

#include "ngx_http_filesync.h"

static ngx_buf_t*
ngx_http_filesync_get_buf(ngx_http_request_t *r, ngx_int_t max_size);
static ngx_int_t
ngx_http_filesync_read(ngx_http_request_t *r, ngx_buf_t *src, ngx_buf_t *dst);

ngx_int_t
ngx_http_filesync_get(ngx_http_request_t *r, ngx_str_t *uri, ngx_chain_t **res)
{
        u_char                                          *last;
        size_t                                          root;
        ngx_str_t                                       r_path;
        ngx_str_t                                       path;
        ngx_int_t                                       rc;
        ngx_log_t                                       *log;
        ngx_buf_t                                       *b;
        ngx_chain_t                                     out, *cl, *cl_end;
        ngx_open_file_info_t            of;
        ngx_http_core_loc_conf_t        *clcf;
        ngx_file_t                                      *file;
        u_char                                          *tmp;


        ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->pool->log, 0,
                        "[filesynch_get]");

           ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->pool->log, 0,
                        "[filesynch_get] get URI: %s", uri->data);

        if (uri->data[uri->len - 1] == '/') {
                return NGX_DECLINED;
        }

        log = r->connection->log;

        /*
         * ngx_http_map_uri_to_path() allocates memory for terminating '\0'
         * so we do not need to reserve memory for '/' for possible redirect
         */

        last = ngx_http_map_uri_to_path(r, &r_path, &root, 0);
        if (last == NULL) {
                return NGX_HTTP_INTERNAL_SERVER_ERROR;
        }

        r_path.len = last - r_path.data;

        last--;
        while(*last != '/') 
           last--;

        r_path.len = last - r_path.data + 1;

        path.data = ngx_pcalloc(r->pool, sizeof(u_char)*(r_path.len + uri->len + 1));
        path.len = r_path.len + uri->len + 1;

        tmp = ngx_cpystrn(path.data, r_path.data, r_path.len + 1);
        tmp = ngx_cpystrn(tmp, uri->data, uri->len + 1);

        ngx_log_debug1(NGX_LOG_DEBUG_HTTP, log, 0,
                                   "[filesynch_get] http filename \"%s\"", path.data);

        clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

        ngx_memzero(&of, sizeof(ngx_open_file_info_t));

        of.directio = clcf->directio;
        of.valid = clcf->open_file_cache_valid;
        of.min_uses = clcf->open_file_cache_min_uses;
        of.errors = clcf->open_file_cache_errors;
        of.events = clcf->open_file_cache_events;

        if (ngx_open_cached_file(clcf->open_file_cache, &path, &of, r->pool)
                != NGX_OK)
        {
                switch (of.err) {
                case 0:
                        return NGX_HTTP_INTERNAL_SERVER_ERROR;
                case NGX_ENOENT:
                case NGX_ENOTDIR:
                case NGX_ENAMETOOLONG:
                        //level = NGX_LOG_ERR;
                        rc = NGX_HTTP_NOT_FOUND;
                        break;
                case NGX_EACCES:
                        //level = NGX_LOG_ERR;
                        rc = NGX_HTTP_FORBIDDEN;
                        break;

                default:
                        //level = NGX_LOG_CRIT;
                        rc = NGX_HTTP_INTERNAL_SERVER_ERROR;
                        break;
                }

                if (rc != NGX_HTTP_NOT_FOUND || clcf->log_not_found) {
                        ngx_log_debug2(/*level*/NGX_LOG_DEBUG_HTTP, log, of.err,
                                                  "[filesynch_get] %s \"%s\" failed", of.failed, path.data);
                }

                return rc;
        }

        ngx_log_debug1(NGX_LOG_DEBUG_HTTP, log, 0,
                        "[filesynch_get] http static fd: %d", of.fd);

        if (of.is_dir) {
                ngx_log_debug0(NGX_LOG_DEBUG_HTTP, log, 0,
                                "[filesynch_get] http dir");

                return NGX_HTTP_MOVED_PERMANENTLY;
        }

#if !(NGX_WIN32) /* the not regular files are probably Unix specific */

        if (!of.is_file) {
                ngx_log_debug1(NGX_LOG_DEBUG_HTTP, log, ngx_errno,
                                "[filesynch_get] \"%s\" is not a regular file", path.data);

                return NGX_HTTP_NOT_FOUND;
        }

#endif

        /* we need to allocate all before the header would be sent */

        b = ngx_pcalloc(r->pool, sizeof(ngx_buf_t));
        if (b == NULL) {
                return NGX_HTTP_INTERNAL_SERVER_ERROR;
        }

        file = ngx_pcalloc(r->pool, sizeof(ngx_file_t));
        if( file == NULL ) {
                return NGX_HTTP_INTERNAL_SERVER_ERROR;
        }

        b->file = file;
        b->file_pos = 0;
        b->file_last = of.size;

        b->in_file = b->file_last ? 1: 0;
        b->last_buf = (r == r->main) ? 1: 0;
        b->last_in_chain = 1;

        b->file->fd = of.fd;
        b->file->name = path;
        b->file->log = log;
        b->file->directio = of.is_directio;

        out.buf = b;
        out.next = NULL;

        cl = cl_end = NULL;
        *res = NULL;
        while( ngx_buf_size(out.buf) > 0 ) {
                // allocates new buffer
                b = ngx_http_filesync_get_buf(r, ngx_buf_size(out.buf));
                if( b == NULL ) {
                        ngx_log_debug0(NGX_LOG_DEBUG_HTTP, log, 0,
                                        "[filesynch_get] ngx_http_filesync_get_buf fail");
                        return NGX_HTTP_INTERNAL_SERVER_ERROR;
                }

                // reads file content to buffer
                rc = ngx_http_filesync_read(r, out.buf, b);

                if( rc != NGX_OK ) {
                        return rc;
                }

                if( cl == NULL ) {
                        cl = cl_end = ngx_alloc_chain_link(r->pool);
                }
                else {
                        cl_end->next = ngx_alloc_chain_link(r->pool);
                        cl_end = cl_end->next;
                }
                cl_end->buf = b;
                cl_end->next = NULL;
        }
        *res = cl;

        // we do not have to close the file, nginx does this automatically

        ngx_log_debug0(NGX_LOG_DEBUG_HTTP, log, 0,
                        "[filesynch_get] done");

        return NGX_OK;
}

static ngx_int_t
ngx_http_filesync_read(ngx_http_request_t *r, ngx_buf_t *src, ngx_buf_t *dst)
{
        off_t           size;
        ssize_t         n;

        size = ngx_buf_size(src);

        if (size > dst->end - dst->pos) {
                size = dst->end - dst->pos;
        }

        ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->pool->log, 0,
                        "[filesync_read] reading... (%d)", size);
        n = ngx_read_file(src->file, dst->pos, (size_t) size, src->file_pos);

        if (n == NGX_ERROR) {
                return (ngx_int_t) n;
        }

#if (NGX_FILE_AIO_READ)
        if (n == NGX_AGAIN) {
                return (ngx_int_t) n;
        }
#endif

        if (n != size) {
                ngx_log_debug3(NGX_LOG_DEBUG_HTTP, r->pool->log, 0,
                                "[filesync_read] read only %z of %O from \"%s\"", n, size, src->file->name.data);
                if (n == 0) {
                        return NGX_ERROR;
                }
        }

        dst->last += n;
        dst->in_file = 0;
        src->file_pos += n;

        if (src->file_pos == src->file_last) {
                dst->flush = src->flush;
                dst->last_buf = src->last_buf;
                dst->last_in_chain = src->last_in_chain;
        }

        ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->pool->log, 0,
                        "[filesync_read] ok");

        return NGX_OK;
}

static ngx_buf_t*
ngx_http_filesync_get_buf(ngx_http_request_t *r, ngx_int_t max_size)
{
        return ngx_create_temp_buf(r->pool,
                        max_size > NGX_HTTP_FILESYNC_MAX_BUF ? NGX_HTTP_FILESYNC_MAX_BUF : max_size);
}

---