nginx-upload-progress-module/ngx_http_uploadprogress_mod...

/*
 * Copyright (C) 2007 Brice Figureau
 * shm_zone and rbtree code Copyright (c) 2002-2007 Igor Sysoev
 */

#include <ngx_config.h>
#include <ngx_core.h>
#include <ngx_http.h>

#define TIMER_FREQUENCY 15 * 1000

typedef enum {
  uploadprogress_state_starting = 0,
  uploadprogress_state_error = 1,
  uploadprogress_state_done = 2,
  uploadprogress_state_uploading = 3,
  uploadprogress_state_none
} ngx_http_uploadprogress_state_t;

typedef struct {
  ngx_str_t name;
  ngx_http_uploadprogress_state_t idx;
} ngx_http_uploadprogress_state_map_t;

typedef struct ngx_http_uploadprogress_node_s ngx_http_uploadprogress_node_t;

struct ngx_http_uploadprogress_node_s {
  ngx_rbtree_node_t node;
  ngx_uint_t err_status;
  off_t rest;
  off_t length;
  ngx_uint_t done;
  time_t timeout;
  struct ngx_http_uploadprogress_node_s *prev;
  struct ngx_http_uploadprogress_node_s *next;
  u_char len;
  u_char data[1];
};

typedef struct {
  ngx_shm_zone_t *shm_zone;
  ngx_rbtree_node_t *node;
  ngx_http_request_t *r;
  time_t timeout;
} ngx_http_uploadprogress_cleanup_t;

typedef struct {
  ngx_rbtree_t *rbtree;
  ngx_http_uploadprogress_node_t list_head;
  ngx_http_uploadprogress_node_t list_tail;
} ngx_http_uploadprogress_ctx_t;

typedef struct {
  ngx_array_t *values;
  ngx_array_t *lengths;
} ngx_http_uploadprogress_template_t;

typedef struct {
  ngx_shm_zone_t *shm_zone;
  time_t timeout;
  ngx_event_t cleanup;
  ngx_http_handler_pt handler;
  u_char track;
  ngx_str_t content_type;
  ngx_array_t templates;
  ngx_str_t header;
  ngx_str_t jsonp_parameter;
} ngx_http_uploadprogress_conf_t;

typedef struct {
  ngx_http_event_handler_pt read_event_handler;
} ngx_http_uploadprogress_module_ctx_t;

static ngx_int_t ngx_http_reportuploads_handler(ngx_http_request_t *r);
static void ngx_http_uploadprogress_cleanup(void *data);
static char *ngx_http_report_uploads(ngx_conf_t *cf, ngx_command_t *cmd,
                                     void *conf);
static ngx_int_t ngx_http_uploadprogress_init_zone(ngx_shm_zone_t *shm_zone,
                                                   void *data);
static ngx_int_t ngx_http_uploadprogress_init(ngx_conf_t *cf);
static void *ngx_http_uploadprogress_create_loc_conf(ngx_conf_t *cf);
static char *ngx_http_uploadprogress_merge_loc_conf(ngx_conf_t *cf,
                                                    void *parent, void *child);
static ngx_int_t
ngx_http_uploadprogress_init_variables_and_templates(ngx_conf_t *cf);

static ngx_int_t ngx_http_uploadprogress_received_variable(
    ngx_http_request_t *r, ngx_http_variable_value_t *v, uintptr_t data);
static ngx_int_t ngx_http_uploadprogress_offset_variable(
    ngx_http_request_t *r, ngx_http_variable_value_t *v, uintptr_t data);
static ngx_int_t ngx_http_uploadprogress_status_variable(
    ngx_http_request_t *r, ngx_http_variable_value_t *v, uintptr_t data);
static ngx_int_t ngx_http_uploadprogress_callback_variable(
    ngx_http_request_t *r, ngx_http_variable_value_t *v, uintptr_t data);
static char *ngx_http_upload_progress_set_template(
    ngx_conf_t *cf, ngx_http_uploadprogress_template_t *t, ngx_str_t *source);
static char *ngx_http_track_uploads(ngx_conf_t *cf, ngx_command_t *cmd,
                                    void *conf);
static char *ngx_http_report_uploads(ngx_conf_t *cf, ngx_command_t *cmd,
                                     void *conf);
static char *ngx_http_upload_progress(ngx_conf_t *cf, ngx_command_t *cmd,
                                      void *conf);
static char *ngx_http_upload_progress_template(ngx_conf_t *cf,
                                               ngx_command_t *cmd, void *conf);
static char *ngx_http_upload_progress_java_output(ngx_conf_t *cf,
                                                  ngx_command_t *cmd,
                                                  void *conf);
static char *ngx_http_upload_progress_json_output(ngx_conf_t *cf,
                                                  ngx_command_t *cmd,
                                                  void *conf);
static char *ngx_http_upload_progress_jsonp_output(ngx_conf_t *cf,
                                                   ngx_command_t *cmd,
                                                   void *conf);
static void ngx_clean_old_connections(ngx_event_t *ev);
static ngx_int_t ngx_http_uploadprogress_content_handler(ngx_http_request_t *r);

static ngx_http_output_header_filter_pt ngx_http_next_header_filter;

static ngx_command_t ngx_http_uploadprogress_commands[] = {

    {ngx_string("upload_progress"), NGX_HTTP_MAIN_CONF | NGX_CONF_TAKE2,
     ngx_http_upload_progress, 0, 0, NULL},

    {ngx_string("track_uploads"),
     NGX_HTTP_MAIN_CONF | NGX_HTTP_SRV_CONF | NGX_HTTP_LOC_CONF |
         NGX_CONF_TAKE2,
     ngx_http_track_uploads, NGX_HTTP_LOC_CONF_OFFSET, 0, NULL},

    {ngx_string("report_uploads"),
     NGX_HTTP_MAIN_CONF | NGX_HTTP_SRV_CONF | NGX_HTTP_LOC_CONF |
         NGX_CONF_TAKE1,
     ngx_http_report_uploads, NGX_HTTP_LOC_CONF_OFFSET, 0, NULL},

    {ngx_string("upload_progress_content_type"),
     NGX_HTTP_MAIN_CONF | NGX_HTTP_SRV_CONF | NGX_HTTP_LOC_CONF |
         NGX_CONF_TAKE1,
     ngx_conf_set_str_slot, NGX_HTTP_LOC_CONF_OFFSET,
     offsetof(ngx_http_uploadprogress_conf_t, content_type), NULL},

    {ngx_string("upload_progress_template"),
     NGX_HTTP_MAIN_CONF | NGX_HTTP_SRV_CONF | NGX_HTTP_LOC_CONF |
         NGX_CONF_TAKE2,
     ngx_http_upload_progress_template, NGX_HTTP_LOC_CONF_OFFSET,
     offsetof(ngx_http_uploadprogress_conf_t, templates), NULL},

    {ngx_string("upload_progress_java_output"),
     NGX_HTTP_MAIN_CONF | NGX_HTTP_SRV_CONF | NGX_HTTP_LOC_CONF |
         NGX_CONF_NOARGS,
     ngx_http_upload_progress_java_output, NGX_HTTP_LOC_CONF_OFFSET, 0, NULL},

    {ngx_string("upload_progress_json_output"),
     NGX_HTTP_MAIN_CONF | NGX_HTTP_SRV_CONF | NGX_HTTP_LOC_CONF |
         NGX_CONF_NOARGS,
     ngx_http_upload_progress_json_output, NGX_HTTP_LOC_CONF_OFFSET, 0, NULL},

    {ngx_string("upload_progress_jsonp_output"),
     NGX_HTTP_MAIN_CONF | NGX_HTTP_SRV_CONF | NGX_HTTP_LOC_CONF |
         NGX_CONF_NOARGS,
     ngx_http_upload_progress_jsonp_output, NGX_HTTP_LOC_CONF_OFFSET, 0, NULL},

    {ngx_string("upload_progress_header"),
     NGX_HTTP_MAIN_CONF | NGX_HTTP_SRV_CONF | NGX_HTTP_LOC_CONF |
         NGX_CONF_TAKE1,
     ngx_conf_set_str_slot, NGX_HTTP_LOC_CONF_OFFSET,
     offsetof(ngx_http_uploadprogress_conf_t, header), NULL},

    {ngx_string("upload_progress_jsonp_parameter"),
     NGX_HTTP_MAIN_CONF | NGX_HTTP_SRV_CONF | NGX_HTTP_LOC_CONF |
         NGX_CONF_TAKE1,
     ngx_conf_set_str_slot, NGX_HTTP_LOC_CONF_OFFSET,
     offsetof(ngx_http_uploadprogress_conf_t, jsonp_parameter), NULL},

    ngx_null_command};

static ngx_http_variable_t ngx_http_uploadprogress_variables[] = {

    {ngx_string("uploadprogress_received"), NULL,
     ngx_http_uploadprogress_received_variable,
     (uintptr_t)offsetof(ngx_http_uploadprogress_node_t, rest),
     NGX_HTTP_VAR_CHANGEABLE | NGX_HTTP_VAR_NOCACHEABLE | NGX_HTTP_VAR_NOHASH,
     0},

    {ngx_string("uploadprogress_remaining"), NULL,
     ngx_http_uploadprogress_offset_variable,
     (uintptr_t)offsetof(ngx_http_uploadprogress_node_t, rest),
     NGX_HTTP_VAR_CHANGEABLE | NGX_HTTP_VAR_NOCACHEABLE | NGX_HTTP_VAR_NOHASH,
     0},

    {ngx_string("uploadprogress_length"), NULL,
     ngx_http_uploadprogress_offset_variable,
     (uintptr_t)offsetof(ngx_http_uploadprogress_node_t, length),
     NGX_HTTP_VAR_CHANGEABLE | NGX_HTTP_VAR_NOCACHEABLE | NGX_HTTP_VAR_NOHASH,
     0},

    {ngx_string("uploadprogress_status"), NULL,
     ngx_http_uploadprogress_status_variable,
     (uintptr_t)offsetof(ngx_http_uploadprogress_node_t, err_status),
     NGX_HTTP_VAR_CHANGEABLE | NGX_HTTP_VAR_NOCACHEABLE | NGX_HTTP_VAR_NOHASH,
     0},

    {ngx_string("uploadprogress_callback"), NULL,
     ngx_http_uploadprogress_callback_variable, (uintptr_t)NULL,
     NGX_HTTP_VAR_CHANGEABLE | NGX_HTTP_VAR_NOCACHEABLE | NGX_HTTP_VAR_NOHASH,
     0},

    {ngx_null_string, NULL, NULL, 0, 0, 0}};

static ngx_http_module_t ngx_http_uploadprogress_module_ctx = {
    ngx_http_uploadprogress_init_variables_and_templates, /* preconfiguration */
    ngx_http_uploadprogress_init, /* postconfiguration */

    NULL, /* create main configuration */
    NULL, /* init main configuration */

    NULL, /* create server configuration */
    NULL, /* merge server configuration */

    ngx_http_uploadprogress_create_loc_conf, /* create location configuration */
    ngx_http_uploadprogress_merge_loc_conf   /* merge location configuration */
};

ngx_module_t ngx_http_uploadprogress_module = {
    NGX_MODULE_V1,
    &ngx_http_uploadprogress_module_ctx, /* module context */
    ngx_http_uploadprogress_commands,    /* module directives */
    NGX_HTTP_MODULE,                     /* module type */
    NULL,                                /* init master */
    NULL,                                /* init module */
    NULL,                                /* init process */
    NULL,                                /* init thread */
    NULL,                                /* exit thread */
    NULL,                                /* exit process */
    NULL,                                /* exit master */
    NGX_MODULE_V1_PADDING};

static ngx_http_uploadprogress_state_map_t ngx_http_uploadprogress_state_map[] =
    {
        {ngx_string("starting"), uploadprogress_state_starting},
        {ngx_string("error"), uploadprogress_state_error},
        {ngx_string("done"), uploadprogress_state_done},
        {ngx_string("uploading"), uploadprogress_state_uploading},
        {ngx_null_string, uploadprogress_state_none},
};

static ngx_str_t ngx_http_uploadprogress_java_defaults[] = {
    ngx_string("new Object({ 'state' : 'starting' })\r\n"),
    ngx_string("new Object({ 'state' : 'error', 'status' : "
               "$uploadprogress_status })\r\n"),
    ngx_string("new Object({ 'state' : 'done' })\r\n"),
    ngx_string(
        "new Object({ 'state' : 'uploading', 'received' : "
        "$uploadprogress_received, 'size' : $uploadprogress_length })\r\n")};

static ngx_str_t ngx_http_uploadprogress_json_defaults[] = {
    ngx_string("{ \"state\" : \"starting\" }\r\n"),
    ngx_string(
        "{ \"state\" : \"error\", \"status\" : $uploadprogress_status }\r\n"),
    ngx_string("{ \"state\" : \"done\" }\r\n"),
    ngx_string(
        "{ \"state\" : \"uploading\", \"received\" : $uploadprogress_received, "
        "\"size\" : $uploadprogress_length }\r\n")};

static ngx_str_t ngx_http_uploadprogress_jsonp_defaults[] = {
    ngx_string("$uploadprogress_callback({ \"state\" : \"starting\" });\r\n"),
    ngx_string("$uploadprogress_callback({ \"state\" : \"error\", \"status\" : "
               "$uploadprogress_status });\r\n"),
    ngx_string("$uploadprogress_callback({ \"state\" : \"done\" });\r\n"),
    ngx_string(
        "$uploadprogress_callback({ \"state\" : \"uploading\", \"received\" : "
        "$uploadprogress_received, \"size\" : $uploadprogress_length });\r\n")};

static ngx_array_t ngx_http_uploadprogress_global_templates;

static ngx_str_t *get_tracking_id(ngx_http_request_t *r) {
  u_char *p, *start_p;
  ngx_uint_t i;
  ngx_list_part_t *part;
  ngx_table_elt_t *header;
  ngx_str_t *ret, args;
  ngx_http_uploadprogress_conf_t *upcf;

  upcf = ngx_http_get_module_loc_conf(r, ngx_http_uploadprogress_module);

  ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
                 "upload-progress: get_tracking_id");

  part = &r->headers_in.headers.part;
  header = part->elts;

  for (i = 0; /* void */; i++) {

    if (i >= part->nelts) {
      if (part->next == NULL) {
        break;
      }

      part = part->next;
      header = part->elts;
      i = 0;
    }

    if (header[i].key.len == upcf->header.len &&
        ngx_strncasecmp(header[i].key.data, upcf->header.data,
                        header[i].key.len) == 0) {
      ret = ngx_calloc(sizeof(ngx_str_t), r->connection->log);
      ret->data = header[i].value.data;
      ret->len = header[i].value.len;
      ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
                     "upload-progress: get_tracking_id found header: %V", ret);
      return ret;
    }
  }

  ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
                 "upload-progress: get_tracking_id no header found");

  /* not found, check as a request arg */
  /* it is possible the request args have not been yet created (or already
   * released) */
  /* so let's try harder first from the request line */
  args.len = r->args.len;
  args.data = r->args.data;

  if (args.len && args.data) {
    ngx_log_debug0(
        NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
        "upload-progress: get_tracking_id no header found, args found");
    i = 0;
    p = args.data;
    do {
      ngx_uint_t len = args.len - (p - args.data);
      if (len >= (upcf->header.len + 1) &&
          ngx_strncasecmp(p, upcf->header.data, upcf->header.len) == 0 &&
          p[upcf->header.len] == '=') {
        ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
                       "upload-progress: get_tracking_id found args: %s", p);
        i = 1;
        break;
      }
      if (len <= 0)
        break;
    } while (p++);

    if (i) {
      start_p = p += upcf->header.len + 1;
      while (p < args.data + args.len) {
        if (*((p++) + 1) == '&') {
          break;
        }
      }

      ret = ngx_calloc(sizeof(ngx_str_t), r->connection->log);
      ret->data = start_p;
      ret->len = p - start_p;
      ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
                     "upload-progress: get_tracking_id found args: %V", ret);
      return ret;
    }
  }

  ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
                 "upload-progress: get_tracking_id no id found");
  return NULL;
}

static ngx_http_uploadprogress_node_t *
find_node(ngx_str_t *id, ngx_http_uploadprogress_ctx_t *ctx, ngx_log_t *log) {
  uint32_t hash;
  ngx_rbtree_node_t *node, *sentinel;
  ngx_int_t rc;
  ngx_http_uploadprogress_node_t *up;

  ngx_log_debug1(NGX_LOG_DEBUG_HTTP, log, 0, "upload-progress: find_node %V",
                 id);

  hash = ngx_crc32_short(id->data, id->len);

  node = ctx->rbtree->root;
  sentinel = ctx->rbtree->sentinel;

  while (node != sentinel) {
    if (hash != node->key) {
      node = (hash < node->key) ? node->left : node->right;
      continue;
    }

    /* hash == node->key */
    up = (ngx_http_uploadprogress_node_t *)node;

    rc = ngx_memn2cmp(id->data, up->data, id->len, up->len);

    /* found a key with unmatching hash (and value), let's keep comparing hashes
     * then */
    if (rc < 0) {
      node = node->left;
      continue;
    }

    if (rc > 0) {
      node = node->right;
      continue;
    }

    /* found the hash */
    ngx_log_debug0(NGX_LOG_DEBUG_HTTP, log, 0, "upload-progress: found node");
    return up;
  }

  ngx_log_debug0(NGX_LOG_DEBUG_HTTP, log, 0,
                 "upload-progress: can't find node");
  return NULL;
}

static void ngx_http_uploadprogress_event_handler(ngx_http_request_t *r);

static ngx_int_t
ngx_http_uploadprogress_content_handler(ngx_http_request_t *r) {
  ngx_int_t rc;
  ngx_http_uploadprogress_module_ctx_t *ctx;
  ngx_http_uploadprogress_conf_t *upcf;

  ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
                 "upload-progress: ngx_http_uploadprogress_content_handler");
  upcf = ngx_http_get_module_loc_conf(r, ngx_http_uploadprogress_module);

  /* call the original request handler */
  rc = upcf->handler(r);

  /* bail out if error */
  if (rc >= NGX_HTTP_SPECIAL_RESPONSE) {
    return rc;
  }

  /* request is OK, hijack the read_event_handler if the request has to be
   * tracked*/
  ctx = ngx_http_get_module_ctx(r, ngx_http_uploadprogress_module);
  if (ctx != NULL) {
    ctx->read_event_handler = r->read_event_handler;
    r->read_event_handler = ngx_http_uploadprogress_event_handler;
  }
  return rc;
}

static ngx_str_t *ngx_http_uploadprogress_strdup(ngx_str_t *src,
                                                 ngx_log_t *log) {
  ngx_str_t *dst;
  dst = ngx_alloc(src->len + sizeof(ngx_str_t), log);
  if (dst == NULL) {
    return NULL;
  }

  dst->len = src->len;
  ngx_memcpy(((char *)dst + sizeof(ngx_str_t)), src->data, src->len);
  dst->data = ((u_char *)dst + sizeof(ngx_str_t));
  return dst;
}

static void ngx_http_uploadprogress_strdupfree(ngx_str_t *str) {
  ngx_free(str);
}

static void ngx_http_uploadprogress_event_handler(ngx_http_request_t *r) {
  ngx_str_t *id, *oldid;
  ngx_slab_pool_t *shpool;
  ngx_shm_zone_t *shm_zone;
  ngx_http_request_body_t *rb;
  ngx_http_uploadprogress_ctx_t *ctx;
  ngx_http_uploadprogress_node_t *up;
  ngx_http_uploadprogress_conf_t *upcf;
  ngx_http_uploadprogress_module_ctx_t *module_ctx;
  size_t size;
  off_t rest;

  rb = r->request_body;

  ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
                 "upload-progress: ngx_http_uploadprogress_event_handler");

  /* find node, update rest */
  oldid = id = get_tracking_id(r);

  if (id == NULL) {
    ngx_log_debug0(NGX_LOG_DEBUG_HTTP, ngx_cycle->log, 0,
                   "upload-progress: read_event_handler cant find id");
    return;
  }

  /* perform a deep copy of id */
  id = ngx_http_uploadprogress_strdup(id, r->connection->log);
  ngx_free(oldid);

  ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
                 "upload-progress: read_event_handler found id: %V", id);
  upcf = ngx_http_get_module_loc_conf(r, ngx_http_uploadprogress_module);
  shm_zone = upcf->shm_zone;

  /* call the original read event handler */
  module_ctx = ngx_http_get_module_ctx(r, ngx_http_uploadprogress_module);
  if (module_ctx != NULL) {
    module_ctx->read_event_handler(r);
  }

  /* at this stage, r is not anymore safe to use */
  /* the request could have been closed/freed behind our back */
  /* and thats the same issue with any other material that was allocated in the
   * request pool */
  /* that's why we duplicate id afterward */

  /* it's also possible that the id was null if we got a spurious (like abort)
   * read */
  /* event. In this case we still have called the original read event handler */
  /* but we have to bail out, because we won't ever be able to find our upload
   * node */

  if (shm_zone == NULL) {
    ngx_http_uploadprogress_strdupfree(id);
    ngx_log_debug1(NGX_LOG_DEBUG_HTTP, ngx_cycle->log, 0,
                   "upload-progress: read_event_handler no shm_zone for id: %V",
                   id);
    return;
  }

  ctx = shm_zone->data;

  /* get the original connection of the upload */
  shpool = (ngx_slab_pool_t *)shm_zone->shm.addr;

  ngx_shmtx_lock(&shpool->mutex);

  up = find_node(id, ctx, ngx_cycle->log);
  if (up != NULL && !up->done) {
    ngx_log_debug1(NGX_LOG_DEBUG_HTTP, ngx_cycle->log, 0,
                   "upload-progress: read_event_handler found node: %V", id);

#if (NGX_HTTP_V2)
    if (r->http_connection->addr_conf->http2) { /* http/2 */
      up->rest = up->length - r->request_length;
    } else { /* http/1 */
#endif
      rest = rb->rest;
      size = rb->buf->last - rb->buf->pos;
      if ((off_t)size < rest) {
        rest -= size;
      } else {
        rest = 0;
      }
      up->rest = rest;

#if (NGX_HTTP_V2)
    }
#endif

    if (up->length == 0)
      up->length = r->headers_in.content_length_n;
    ngx_log_debug3(
        NGX_LOG_DEBUG_HTTP, ngx_cycle->log, 0,
        "upload-progress: read_event_handler storing rest %uO/%uO for %V",
        up->rest, up->length, id);
  } else {
    ngx_log_debug1(NGX_LOG_DEBUG_HTTP, ngx_cycle->log, 0,
                   "upload-progress: read_event_handler not found: %V", id);
  }
  ngx_shmtx_unlock(&shpool->mutex);
  ngx_http_uploadprogress_strdupfree(id);
}

/* This generates the response for the report */
static ngx_int_t ngx_http_reportuploads_handler(ngx_http_request_t *r) {
  ngx_str_t *id, response;
  ngx_buf_t *b;
  ngx_chain_t out;
  ngx_int_t rc, found = 0, done = 0, err_status = 0;
  off_t rest = 0, length = 0;
  ngx_uint_t len;
  ngx_slab_pool_t *shpool;
  ngx_http_uploadprogress_conf_t *upcf;
  ngx_http_uploadprogress_ctx_t *ctx;
  ngx_http_uploadprogress_node_t *up;
  ngx_table_elt_t *expires, *cc;
  ngx_http_uploadprogress_state_t state;
  ngx_http_uploadprogress_template_t *t;

  if (r->method != NGX_HTTP_GET && r->method != NGX_HTTP_HEAD) {
    return NGX_HTTP_NOT_ALLOWED;
  }

  rc = ngx_http_discard_request_body(r);

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

  /* get the tracking id if any */
  id = get_tracking_id(r);

  if (id == NULL) {
    ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
                   "reportuploads handler cant find id");
    return NGX_DECLINED;
  }

  ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
                 "reportuploads handler found id: %V", id);

  upcf = ngx_http_get_module_loc_conf(r, ngx_http_uploadprogress_module);

  if (upcf->shm_zone == NULL) {
    ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
                   "reportuploads no shm_zone for id: %V", id);
    ngx_free(id);
    return NGX_DECLINED;
  }

  ctx = upcf->shm_zone->data;

  /* get the original connection of the upload */
  shpool = (ngx_slab_pool_t *)upcf->shm_zone->shm.addr;

  ngx_shmtx_lock(&shpool->mutex);

  up = find_node(id, ctx, r->connection->log);
  if (up != NULL) {
    ngx_log_debug5(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
                   "reportuploads found node: %V (rest: %uO, length: %uO, "
                   "done: %ui, err_status: %ui)",
                   id, up->rest, up->length, up->done, up->err_status);
    rest = up->rest;
    length = up->length;
    done = up->done;
    err_status = up->err_status;
    found = 1;
  } else {
    ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
                   "reportuploads not found: %V", id);
  }
  ngx_shmtx_unlock(&shpool->mutex);
  ngx_free(id);

  /* send the output */
  r->headers_out.content_type = upcf->content_type;

  /* force no-cache */
  expires = r->headers_out.expires;

  if (expires == NULL) {

    expires = ngx_list_push(&r->headers_out.headers);
    if (expires == NULL) {
      return NGX_HTTP_INTERNAL_SERVER_ERROR;
    }

    r->headers_out.expires = expires;
    expires->next = NULL;

    expires->hash = 1;
    expires->key.len = sizeof("Expires") - 1;
    expires->key.data = (u_char *)"Expires";
  }

  len = sizeof("Mon, 28 Sep 1970 06:00:00 GMT");
  expires->value.len = len - 1;

  cc = r->headers_out.cache_control;

  if (cc == NULL) {

    cc = ngx_list_push(&r->headers_out.headers);
    if (cc == NULL) {
      expires->hash = 0;
      return NGX_HTTP_INTERNAL_SERVER_ERROR;
    }

    r->headers_out.cache_control = cc;
    cc->next = NULL;

    cc->hash = 1;
    cc->key.len = sizeof("Cache-Control") - 1;
    cc->key.data = (u_char *)"Cache-Control";

  } else {
    for (cc = cc->next; cc; cc = cc->next) {
      cc->hash = 0;
    }

    cc = r->headers_out.cache_control;
    cc->next = NULL;
  }

  expires->value.data = (u_char *)"Thu, 01 Jan 1970 00:00:01 GMT";

  cc->value.len = sizeof("no-cache") - 1;
  cc->value.data = (u_char *)"no-cache";

  if (r->method == NGX_HTTP_HEAD) {
    r->headers_out.status = NGX_HTTP_OK;

    rc = ngx_http_send_header(r);

    if (rc == NGX_ERROR || rc > NGX_OK || r->header_only) {
      return rc;
    }
  }

  ngx_http_set_ctx(r, up, ngx_http_uploadprogress_module);

  /*
   There are 4 possibilities
     * request not yet started: found = false
     * request in error:        err_status >= NGX_HTTP_BAD_REQUEST
     * request finished:        done = true
     * request not yet started but registered:        length==0 && rest ==0
     * reauest in progress:     rest > 0
   */

  if (!found) {
    state = uploadprogress_state_starting;
  } else if (err_status >= NGX_HTTP_BAD_REQUEST) {
    state = uploadprogress_state_error;
  } else if (done) {
    state = uploadprogress_state_done;
  } else if (length == 0 && rest == 0) {
    state = uploadprogress_state_starting;
  } else {
    state = uploadprogress_state_uploading;
  }

  t = upcf->templates.elts;

  if (ngx_http_script_run(r, &response, t[(ngx_uint_t)state].lengths->elts, 0,
                          t[(ngx_uint_t)state].values->elts) == NULL) {
    return NGX_HTTP_INTERNAL_SERVER_ERROR;
  }

  ngx_log_debug4(
      NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
      "upload progress: state=%d, err_status=%ui, remaining=%uO, length=%uO",
      state, err_status, (length - rest), length);

  b = ngx_calloc_buf(r->pool);
  if (b == NULL) {
    return NGX_HTTP_INTERNAL_SERVER_ERROR;
  }

  b->pos = b->start = response.data;
  b->last = b->end = response.data + response.len;

  b->temporary = 1;
  b->memory = 1;

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

  r->headers_out.status = NGX_HTTP_OK;
  r->headers_out.content_length_n = b->last - b->pos;

  b->last_buf = 1;
  rc = ngx_http_send_header(r);

  if (rc == NGX_ERROR || rc > NGX_OK || r->header_only) {
    return rc;
  }

  return ngx_http_output_filter(r, &out);
}

/*
Let's register the upload connection in our connections rb-tree
*/
static ngx_int_t ngx_http_uploadprogress_handler(ngx_http_request_t *r) {
  size_t n;
  ngx_str_t *id;
  uint32_t hash;
  ngx_slab_pool_t *shpool;
  ngx_rbtree_node_t *node;
  ngx_http_uploadprogress_conf_t *upcf;
  ngx_http_uploadprogress_ctx_t *ctx;
  ngx_http_uploadprogress_node_t *up;
  ngx_http_uploadprogress_cleanup_t *upcln;
  ngx_pool_cleanup_t *cln;

  /* Is it a POST connection */
  if (r->method != NGX_HTTP_POST) {
    return NGX_DECLINED;
  }

  id = get_tracking_id(r);
  if (id == NULL) {
    ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
                   "trackuploads no id found in POST upload req");
    return NGX_DECLINED;
  }

  ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
                 "trackuploads id found: %V", id);

  upcf = ngx_http_get_module_loc_conf(r, ngx_http_uploadprogress_module);

  if (!upcf->track) {
    ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
                   "trackuploads not tracking in this location for id: %V", id);
    ngx_free(id);
    return NGX_DECLINED;
  }

  if (upcf->shm_zone == NULL) {
    ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
                   "trackuploads no shm_zone for id: %V", id);
    ngx_free(id);
    return NGX_DECLINED;
  }

  ctx = upcf->shm_zone->data;

  hash = ngx_crc32_short(id->data, id->len);

  ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
                 "trackuploads hash %08XD for id: %V", hash, id);

  shpool = (ngx_slab_pool_t *)upcf->shm_zone->shm.addr;

  ngx_shmtx_lock(&shpool->mutex);

  if (find_node(id, ctx, r->connection->log) != NULL) {
    ngx_shmtx_unlock(&shpool->mutex);
    /* already found a node with matching progress ID */
    ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
                  "upload_progress: tracking already registered id: %V", id);

    ngx_free(id);
    return NGX_HTTP_INTERNAL_SERVER_ERROR;
  }

  cln =
      ngx_pool_cleanup_add(r->pool, sizeof(ngx_http_uploadprogress_cleanup_t));
  if (cln == NULL) {
    ngx_shmtx_unlock(&shpool->mutex);
    ngx_free(id);
    return NGX_HTTP_INTERNAL_SERVER_ERROR;
  }

  n = sizeof(ngx_http_uploadprogress_node_t) + id->len;

  node = ngx_slab_alloc_locked(shpool, n);
  if (node == NULL) {
    ngx_shmtx_unlock(&shpool->mutex);
    ngx_free(id);
    return NGX_HTTP_SERVICE_UNAVAILABLE;
  }

  up = (ngx_http_uploadprogress_node_t *)node;

  node->key = hash;
  up->len = (u_char)id->len;
  up->err_status = r->err_status;
  up->done = 0;
  up->rest = 0;
  up->length = 0;
  up->timeout = 0;

  /* Properly handles small files where no read events happen after the */
  /* request is first handled (apparently this can happen on linux with epoll)
   */
  if (r->headers_in.content_length_n) {
    up->length = r->headers_in.content_length_n;
    if (r->request_body) {
      up->rest = r->request_body->rest;
    }
  }

  up->next = ctx->list_head.next;
  up->next->prev = up;
  up->prev = &ctx->list_head;
  ctx->list_head.next = up;

  ngx_memcpy(up->data, id->data, id->len);

  ngx_rbtree_insert(ctx->rbtree, node);
  ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
                 "trackuploads: %08XD inserted in rbtree", node->key);

  if (!upcf->cleanup.timer_set) {
    upcf->cleanup.data = upcf->shm_zone;
    upcf->cleanup.handler = ngx_clean_old_connections;
    upcf->cleanup.log = upcf->shm_zone->shm.log;
    ngx_add_timer(&upcf->cleanup, TIMER_FREQUENCY);
  }

  ngx_shmtx_unlock(&shpool->mutex);

  cln->handler = ngx_http_uploadprogress_cleanup;
  upcln = cln->data;

  upcln->shm_zone = upcf->shm_zone;
  upcln->node = node;
  upcln->timeout = upcf->timeout;
  upcln->r = r;

  ngx_free(id);

  ctx = ngx_pcalloc(r->pool, sizeof(ngx_http_uploadprogress_module_ctx_t));
  if (ctx == NULL) {
    return NGX_ERROR;
  }

  ngx_http_set_ctx(r, ctx, ngx_http_uploadprogress_module);

  /* finally says to the core we don't handle anything */
  return NGX_DECLINED;
}

static void
ngx_http_uploadprogress_rbtree_insert_value(ngx_rbtree_node_t *temp,
                                            ngx_rbtree_node_t *node,
                                            ngx_rbtree_node_t *sentinel) {
  ngx_http_uploadprogress_node_t *upn, *upnt;

  for (;;) {

    if (node->key < temp->key) {

      if (temp->left == sentinel) {
        temp->left = node;
        break;
      }

      temp = temp->left;

    } else if (node->key > temp->key) {

      if (temp->right == sentinel) {
        temp->right = node;
        break;
      }

      temp = temp->right;

    } else { /* node->key == temp->key */

      upn = (ngx_http_uploadprogress_node_t *)node;
      upnt = (ngx_http_uploadprogress_node_t *)temp;

      if (ngx_memn2cmp(upn->data, upnt->data, upn->len, upnt->len) < 0) {

        if (temp->left == sentinel) {
          temp->left = node;
          break;
        }

        temp = temp->left;

      } else {

        if (temp->right == sentinel) {
          temp->right = node;
          break;
        }

        temp = temp->right;
      }
    }
  }

  node->parent = temp;
  node->left = sentinel;
  node->right = sentinel;
  ngx_rbt_red(node);
}

static void ngx_clean_old_connections(ngx_event_t *ev) {
  ngx_shm_zone_t *shm_zone;
  ngx_http_uploadprogress_ctx_t *ctx;
  ngx_slab_pool_t *shpool;
  ngx_rbtree_node_t *node;
  ngx_http_uploadprogress_node_t *up, *upprev;
  time_t now = ngx_time();
  int count = 0;

  /* scan the rbtree */
  shm_zone = ev->data;
  ctx = shm_zone->data;
  shpool = (ngx_slab_pool_t *)shm_zone->shm.addr;

  ngx_log_debug1(NGX_LOG_DEBUG_HTTP, shm_zone->shm.log, 0,
                 "uploadprogress clean old connections at %T", now);

  ngx_shmtx_lock(&shpool->mutex);
  node = (ngx_rbtree_node_t *)ctx->list_tail.prev;
  for (;;) {

    if (node == &ctx->list_head.node) {
      break;
    }

    up = (ngx_http_uploadprogress_node_t *)node;
    upprev = up->prev;

    ngx_log_debug3(
        NGX_LOG_DEBUG_HTTP, shm_zone->shm.log, 0,
        "uploadprogress clean: scanning %08XD (req done %ui) timeout at %T",
        node->key, up->done, up->timeout);

    if ((up->done && up->timeout < now) ||
        (ngx_quit || ngx_terminate || ngx_exiting)) {
      up->next->prev = up->prev;
      up->prev->next = up->next;

      ngx_log_debug3(NGX_LOG_DEBUG_HTTP, shm_zone->shm.log, 0,
                     "uploadprogress clean: removing %08XD (req %ui) ",
                     node->key, up->done, up->timeout);

      ngx_rbtree_delete(ctx->rbtree, node);
      ngx_slab_free_locked(shpool, node);
    } else
      count++;
    node = (ngx_rbtree_node_t *)upprev;
  }

  ngx_log_debug3(
      NGX_LOG_DEBUG_HTTP, shm_zone->shm.log, 0,
      "uploadprogress clean old connections: quit: %ui term: %ui count: %ui",
      ngx_quit, ngx_terminate, count);

  /* don't reschedule timer if ngx_quit or ngx_terminate && nodes emtpy */
  if (count > 0 || !(ngx_quit || ngx_terminate || ngx_exiting)) {
    ngx_log_debug0(NGX_LOG_DEBUG_HTTP, shm_zone->shm.log, 0,
                   "uploadprogress clean old connections restarting timer");
    ngx_add_timer(ev, TIMER_FREQUENCY); /* trigger again in 60s */
  } else if (ngx_quit || ngx_terminate || ngx_exiting) {
    ngx_log_debug0(NGX_LOG_DEBUG_HTTP, shm_zone->shm.log, 0,
                   "uploadprogress clean old connections quitting , no more "
                   "active connections: not restarting timer");
  }
  ngx_shmtx_unlock(&shpool->mutex);
}

/*
removes the expired node from the upload rbtree
*/
static void ngx_http_uploadprogress_cleanup(void *data) {
  ngx_http_uploadprogress_cleanup_t *upcln = data;
  ngx_slab_pool_t *shpool;
  ngx_rbtree_node_t *node;
  ngx_http_uploadprogress_node_t *up;
  ngx_http_request_t *r;

  ngx_log_debug0(NGX_LOG_DEBUG_HTTP, upcln->shm_zone->shm.log, 0,
                 "uploadprogress cleanup called");

  shpool = (ngx_slab_pool_t *)upcln->shm_zone->shm.addr;
  node = upcln->node;
  r = upcln->r;
  up = (ngx_http_uploadprogress_node_t *)node;

  ngx_shmtx_lock(&shpool->mutex);

  up->done = 1; /* mark the original request as done */
  up->timeout = ngx_time() + upcln->timeout; /* keep tracking for 60s */

  if (r != NULL) {
    ngx_uint_t rc = r->err_status ? r->err_status : r->headers_out.status;
    if (rc >= NGX_HTTP_SPECIAL_RESPONSE) {
      up->err_status = rc;
    }
  }

  ngx_shmtx_unlock(&shpool->mutex);

  ngx_log_debug2(NGX_LOG_DEBUG_HTTP, upcln->shm_zone->shm.log, 0,
                 "uploadprogress cleanup: connection %08XD to be deleted at %T",
                 node->key, up->timeout);
}

static ngx_int_t ngx_http_uploadprogress_init_zone(ngx_shm_zone_t *shm_zone,
                                                   void *data) {
  ngx_http_uploadprogress_ctx_t *octx = data;

  ngx_slab_pool_t *shpool;
  ngx_rbtree_node_t *sentinel;
  ngx_http_uploadprogress_ctx_t *ctx;

  ctx = shm_zone->data;

  if (octx) {
    ctx->rbtree = octx->rbtree;
    return NGX_OK;
  }

  shpool = (ngx_slab_pool_t *)shm_zone->shm.addr;

  ctx->rbtree = ngx_slab_alloc(shpool, sizeof(ngx_rbtree_t));
  if (ctx->rbtree == NULL) {
    return NGX_ERROR;
  }

  sentinel = ngx_slab_alloc(shpool, sizeof(ngx_rbtree_node_t));
  if (sentinel == NULL) {
    return NGX_ERROR;
  }

  ngx_rbtree_init(ctx->rbtree, sentinel,
                  ngx_http_uploadprogress_rbtree_insert_value);

  return NGX_OK;
}

static ngx_int_t ngx_http_uploadprogress_errortracker(ngx_http_request_t *r) {
  size_t n;
  ngx_str_t *id;
  ngx_slab_pool_t *shpool;
  ngx_rbtree_node_t *node;
  ngx_http_uploadprogress_ctx_t *ctx;
  ngx_http_uploadprogress_node_t *up;
  ngx_http_uploadprogress_conf_t *upcf;
  uint32_t hash;
  ngx_http_uploadprogress_cleanup_t *upcln;
  ngx_pool_cleanup_t *cln;

  ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
                 "uploadprogress error-tracker error: %D", r->err_status);
  if (r->err_status >= NGX_HTTP_SPECIAL_RESPONSE) {

    upcf = ngx_http_get_module_loc_conf(r, ngx_http_uploadprogress_module);

    if (!upcf->track) {
      ngx_log_debug0(
          NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
          "uploadprogress error-tracker not tracking in this location");
      goto finish;
    }

    id = get_tracking_id(r);
    if (id == NULL) {
      ngx_log_debug0(
          NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
          "trackuploads error-tracker no id found in POST upload req");
      goto finish;
    }

    ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
                   "trackuploads error-tracker id found: %V", id);

    if (upcf->shm_zone == NULL) {
      ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
                     "trackuploads no shm_zone for id: %V", id);
      ngx_free(id);
      goto finish;
    }

    ctx = upcf->shm_zone->data;

    hash = ngx_crc32_short(id->data, id->len);

    ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
                   "trackuploads error-tracking hash %08XD for id: %V", hash,
                   id);

    shpool = (ngx_slab_pool_t *)upcf->shm_zone->shm.addr;

    ngx_shmtx_lock(&shpool->mutex);

    if ((up = find_node(id, ctx, r->connection->log)) != NULL) {
      ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
                     "trackuploads error-tracking found node for id: %V", id);
      up->err_status = r->err_status;
      ngx_shmtx_unlock(&shpool->mutex);
      ngx_free(id);
      goto finish;
    }

    /* no lz found for this tracking id */
    n = sizeof(ngx_http_uploadprogress_node_t) + id->len;

    cln = ngx_pool_cleanup_add(r->pool,
                               sizeof(ngx_http_uploadprogress_cleanup_t));
    if (cln == NULL) {
      ngx_shmtx_unlock(&shpool->mutex);
      ngx_free(id);
      goto finish;
    }

    node = ngx_slab_alloc_locked(shpool, n);
    if (node == NULL) {
      ngx_shmtx_unlock(&shpool->mutex);
      ngx_free(id);
      goto finish;
    }

    up = (ngx_http_uploadprogress_node_t *)node;

    node->key = hash;
    up->len = (u_char)id->len;
    up->err_status = r->err_status;
    up->done = 0;
    up->rest = 0;
    up->length = 0;
    up->timeout = 0;

    ngx_memcpy(up->data, id->data, id->len);

    up->next = ctx->list_head.next;
    up->next->prev = up;
    up->prev = &ctx->list_head;
    ctx->list_head.next = up;

    ngx_rbtree_insert(ctx->rbtree, node);

    /* start the timer if needed */
    if (!upcf->cleanup.timer_set) {
      upcf->cleanup.data = upcf->shm_zone;
      upcf->cleanup.handler = ngx_clean_old_connections;
      upcf->cleanup.log = upcf->shm_zone->shm.log;
      ngx_add_timer(&upcf->cleanup, TIMER_FREQUENCY);
    }

    ngx_shmtx_unlock(&shpool->mutex);

    cln->handler = ngx_http_uploadprogress_cleanup;
    upcln = cln->data;
    upcln->shm_zone = upcf->shm_zone;
    upcln->node = node;
    upcln->timeout = upcf->timeout;
    upcln->r = r;

    ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
                   "trackuploads error-tracking adding: %08XD", node->key);
    ngx_free(id);
  }

finish:
  /* call the filter chain as usual */
  return ngx_http_next_header_filter(r);
}

static ngx_int_t ngx_http_uploadprogress_init(ngx_conf_t *cf) {
  ngx_http_handler_pt *h;
  ngx_http_core_main_conf_t *cmcf;

  cmcf = ngx_http_conf_get_module_main_conf(cf, ngx_http_core_module);

  /* install the tracking handler */
  h = ngx_array_push(&cmcf->phases[NGX_HTTP_REWRITE_PHASE].handlers);
  if (h == NULL) {
    return NGX_ERROR;
  }

  *h = ngx_http_uploadprogress_handler;

  /*
     we also need to track HTTP errors
     unfortunately, the above handler is not called in case of
     errors.
     we have to register a header output filter that will be
     called in any case to track those errors
   */
  ngx_http_next_header_filter = ngx_http_top_header_filter;
  ngx_http_top_header_filter = ngx_http_uploadprogress_errortracker;

  return NGX_OK;
}

static void *ngx_http_uploadprogress_create_loc_conf(ngx_conf_t *cf) {
  ngx_http_uploadprogress_conf_t *conf;
  ngx_uint_t i;

  conf = ngx_pcalloc(cf->pool, sizeof(ngx_http_uploadprogress_conf_t));
  if (conf == NULL) {
    return NGX_CONF_ERROR;
  }

  if (ngx_array_init(&conf->templates, cf->pool, 4,
                     sizeof(ngx_http_uploadprogress_template_t)) != NGX_OK) {
    return NGX_CONF_ERROR;
  }

  for (i = 0; i < conf->templates.nalloc; i++) {
    ngx_http_uploadprogress_template_t *elt = ngx_array_push(&conf->templates);
    if (elt == NULL) {
      return NGX_CONF_ERROR;
    }

    elt->values = NULL;
    elt->lengths = NULL;
  }

  return conf;
}

static char *ngx_http_uploadprogress_merge_loc_conf(ngx_conf_t *cf,
                                                    void *parent, void *child) {
  ngx_http_uploadprogress_conf_t *prev = parent;
  ngx_http_uploadprogress_conf_t *conf = child;
  ngx_http_uploadprogress_template_t *t, *pt, *gt;
  ngx_uint_t i;

  if (conf->shm_zone == NULL) {
    conf->shm_zone = prev->shm_zone;
    conf->timeout = prev->timeout;
    conf->cleanup = prev->cleanup;
    conf->handler = prev->handler;
    conf->track = prev->track;
  }

  ngx_conf_merge_str_value(conf->content_type, prev->content_type,
                           "text/javascript");

  t = conf->templates.elts;
  pt = prev->templates.elts;
  gt = ngx_http_uploadprogress_global_templates.elts;

  for (i = 0; i < conf->templates.nelts; i++) {
    if (t[i].values == NULL) {
      if (pt[i].values == NULL && gt != NULL) {
        t[i].values = gt[i].values;
        t[i].lengths = gt[i].lengths;
      } else {
        t[i].values = pt[i].values;
        t[i].lengths = pt[i].lengths;
      }
    }
  }

  ngx_conf_merge_str_value(conf->header, prev->header, "X-Progress-ID");
  ngx_conf_merge_str_value(conf->jsonp_parameter, prev->jsonp_parameter,
                           "callback");

  return NGX_CONF_OK;
}

static ngx_int_t
ngx_http_uploadprogress_init_variables_and_templates(ngx_conf_t *cf) {
  ngx_http_variable_t *var, *v;
  ngx_http_uploadprogress_state_map_t *m;
  ngx_uint_t i;

  /* Add variables */
  for (v = ngx_http_uploadprogress_variables; v->name.len; v++) {
    var = ngx_http_add_variable(cf, &v->name, v->flags);
    if (var == NULL) {
      return NGX_ERROR;
    }

    var->get_handler = v->get_handler;
    var->data = v->data;
  }

  /* Compile global templates (containing Javascript output) */
  if (ngx_array_init(&ngx_http_uploadprogress_global_templates, cf->pool, 4,
                     sizeof(ngx_http_uploadprogress_template_t)) != NGX_OK) {
    return NGX_ERROR;
  }

  m = ngx_http_uploadprogress_state_map;
  i = 0;

  while (m->name.data != NULL) {
    ngx_http_uploadprogress_template_t *elt =
        ngx_array_push(&ngx_http_uploadprogress_global_templates);
    ngx_http_script_variables_count(ngx_http_uploadprogress_jsonp_defaults + i);

    if (ngx_http_upload_progress_set_template(
            cf, elt, ngx_http_uploadprogress_jsonp_defaults + i) !=
        NGX_CONF_OK) {
      return NGX_ERROR;
    }

    m++;
    i++;
  }

  return NGX_OK;
}

static char *ngx_http_upload_progress(ngx_conf_t *cf, ngx_command_t *cmd,
                                      void *conf) {
  ssize_t n;
  ngx_str_t *value;
  ngx_shm_zone_t *shm_zone;
  ngx_http_uploadprogress_ctx_t *ctx;

  value = cf->args->elts;

  ngx_log_debug1(NGX_LOG_DEBUG_HTTP, cf->log, 0, "ngx_upload_progress name: %V",
                 &value[1]);

  ctx = ngx_pcalloc(cf->pool, sizeof(ngx_http_uploadprogress_ctx_t));
  if (ctx == NULL) {
    return NGX_CONF_ERROR;
  }

  ctx->list_head.prev = NULL;
  ctx->list_head.next = &ctx->list_tail;

  ctx->list_tail.prev = &ctx->list_head;
  ctx->list_tail.next = NULL;

  n = ngx_parse_size(&value[2]);

  if (n == NGX_ERROR) {
    ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
                       "invalid size of track_uploads \"%V\"", &value[2]);
    return NGX_CONF_ERROR;
  }

  if (n < (ngx_int_t)(8 * ngx_pagesize)) {
    ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
                       "track_uploads \"%V\" is too small", &value[1]);
    return NGX_CONF_ERROR;
  }

  shm_zone =
      ngx_shared_memory_add(cf, &value[1], n, &ngx_http_uploadprogress_module);
  if (shm_zone == NULL) {
    return NGX_CONF_ERROR;
  }

  ngx_log_debug2(NGX_LOG_DEBUG_HTTP, cf->log, 0,
                 "ngx_upload_progress name: %V, szhm_zone: %p", &value[1],
                 shm_zone);

  if (shm_zone->data) {
    ctx = shm_zone->data;

    ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
                       "track_uploads \"%V\" is already created", &value[1]);
    return NGX_CONF_ERROR;
  }

  shm_zone->init = ngx_http_uploadprogress_init_zone;
  shm_zone->data = ctx;

  return NGX_CONF_OK;
}

static char *ngx_http_track_uploads(ngx_conf_t *cf, ngx_command_t *cmd,
                                    void *conf) {
  ngx_http_core_loc_conf_t *clcf;
  ngx_http_uploadprogress_conf_t *lzcf = conf;
  ngx_str_t *value;

  ngx_log_debug0(NGX_LOG_DEBUG_HTTP, cf->log, 0, "ngx_track_uploads in");

  value = cf->args->elts;

  ngx_log_debug1(NGX_LOG_DEBUG_HTTP, cf->log, 0, "ngx_track_uploads name: %V",
                 &value[1]);

  lzcf->shm_zone =
      ngx_shared_memory_add(cf, &value[1], 0, &ngx_http_uploadprogress_module);
  if (lzcf->shm_zone == NULL) {
    return NGX_CONF_ERROR;
  }

  lzcf->track = (u_char)1;

  ngx_log_debug2(NGX_LOG_DEBUG_HTTP, cf->log, 0,
                 "ngx_track_uploads name: %V,szhm_zone: %p", &value[1],
                 lzcf->shm_zone);

  lzcf->timeout = ngx_parse_time(&value[2], 1);
  if (lzcf->timeout == NGX_ERROR) {
    ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
                       "track_uploads \"%V\" timeout value invalid", &value[1]);
    return NGX_CONF_ERROR;
  }

  clcf = ngx_http_conf_get_module_loc_conf(cf, ngx_http_core_module);
  lzcf->handler = clcf->handler;
  if (lzcf->handler == NULL) {
    return "track_upload should be the last directive in the location, after "
           "either proxy_pass or fastcgi_pass";
  }
  clcf->handler = ngx_http_uploadprogress_content_handler;
  return NGX_CONF_OK;
}

static char *ngx_http_report_uploads(ngx_conf_t *cf, ngx_command_t *cmd,
                                     void *conf) {
  ngx_http_uploadprogress_conf_t *lzcf = conf;
  ngx_http_core_loc_conf_t *clcf;
  ngx_str_t *value;

  ngx_log_debug0(NGX_LOG_DEBUG_HTTP, cf->log, 0, "ngx_report_uploads in");

  value = cf->args->elts;

  ngx_log_debug1(NGX_LOG_DEBUG_HTTP, cf->log, 0, "ngx_report_uploads name: %V",
                 &value[1]);

  lzcf->shm_zone =
      ngx_shared_memory_add(cf, &value[1], 0, &ngx_http_uploadprogress_module);
  if (lzcf->shm_zone == NULL) {
    return NGX_CONF_ERROR;
  }

  ngx_log_debug2(NGX_LOG_DEBUG_HTTP, cf->log, 0,
                 "ngx_report_uploads name: %V, szhm_zone: %p", &value[1],
                 lzcf->shm_zone);

  lzcf->track = (u_char)0;

  /* install our report handler */
  clcf = ngx_http_conf_get_module_loc_conf(cf, ngx_http_core_module);
  clcf->handler = ngx_http_reportuploads_handler;

  return NGX_CONF_OK;
}

static char *ngx_http_upload_progress_set_template(
    ngx_conf_t *cf, ngx_http_uploadprogress_template_t *t, ngx_str_t *source) {
  ssize_t n;
  ngx_http_script_compile_t sc;

  n = ngx_http_script_variables_count(source);

  ngx_memzero(&sc, sizeof(ngx_http_script_compile_t));

  t->lengths = NULL;
  t->values = NULL;

  sc.cf = cf;
  sc.source = source;
  sc.lengths = &t->lengths;
  sc.values = &t->values;
  sc.variables = n;
  sc.complete_lengths = 1;
  sc.complete_values = 1;

  if (ngx_http_script_compile(&sc) != NGX_OK) {
    return NGX_CONF_ERROR;
  }

  return NGX_CONF_OK;
}

static char *ngx_http_upload_progress_template(ngx_conf_t *cf,
                                               ngx_command_t *cmd, void *conf) {
  ngx_http_uploadprogress_conf_t *upcf = conf;
  ngx_str_t *value;
  ngx_http_uploadprogress_state_map_t *m = ngx_http_uploadprogress_state_map;
  ngx_http_uploadprogress_template_t *t;

  value = cf->args->elts;

  while (m->name.data != NULL) {
    if ((value[1].len == m->name.len &&
         !ngx_strncmp(value[1].data, m->name.data, m->name.len)) ||
        (value[1].len == 2 && !ngx_strncmp(value[1].data, m->name.data, 2))) {
      break;
    }
    m++;
  }

  if (m->name.data == NULL) {
    ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, "unknown state \"%V\"", &value[1]);
    return NGX_CONF_ERROR;
  }

  t = (ngx_http_uploadprogress_template_t *)upcf->templates.elts +
      (ngx_uint_t)m->idx;

  return ngx_http_upload_progress_set_template(cf, t, &value[2]);
}

static char *ngx_http_upload_progress_java_output(ngx_conf_t *cf,
                                                  ngx_command_t *cmd,
                                                  void *conf) {
  ngx_http_uploadprogress_conf_t *upcf = conf;
  ngx_http_uploadprogress_template_t *t;
  ngx_uint_t i;
  char *rc;

  t = (ngx_http_uploadprogress_template_t *)upcf->templates.elts;

  for (i = 0; i < upcf->templates.nelts; i++) {
    rc = ngx_http_upload_progress_set_template(
        cf, t + i, ngx_http_uploadprogress_java_defaults + i);

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

  upcf->content_type.data = (u_char *)"text/javascript";
  upcf->content_type.len = sizeof("text/javascript") - 1;

  return NGX_CONF_OK;
}

static char *ngx_http_upload_progress_json_output(ngx_conf_t *cf,
                                                  ngx_command_t *cmd,
                                                  void *conf) {
  ngx_http_uploadprogress_conf_t *upcf = conf;
  ngx_http_uploadprogress_template_t *t;
  ngx_uint_t i;
  char *rc;

  t = (ngx_http_uploadprogress_template_t *)upcf->templates.elts;

  for (i = 0; i < upcf->templates.nelts; i++) {
    rc = ngx_http_upload_progress_set_template(
        cf, t + i, ngx_http_uploadprogress_json_defaults + i);

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

  upcf->content_type.data = (u_char *)"application/json";
  upcf->content_type.len = sizeof("application/json") - 1;

  return NGX_CONF_OK;
}

static char *ngx_http_upload_progress_jsonp_output(ngx_conf_t *cf,
                                                   ngx_command_t *cmd,
                                                   void *conf) {
  ngx_http_uploadprogress_conf_t *upcf = conf;
  ngx_http_uploadprogress_template_t *t;
  ngx_uint_t i;
  char *rc;

  t = (ngx_http_uploadprogress_template_t *)upcf->templates.elts;

  for (i = 0; i < upcf->templates.nelts; i++) {
    rc = ngx_http_upload_progress_set_template(
        cf, t + i, ngx_http_uploadprogress_jsonp_defaults + i);

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

  upcf->content_type.data = (u_char *)"application/javascript";
  upcf->content_type.len = sizeof("application/javascript") - 1;

  return NGX_CONF_OK;
}

static ngx_int_t ngx_http_uploadprogress_received_variable(
    ngx_http_request_t *r, ngx_http_variable_value_t *v, uintptr_t data) {
  ngx_http_uploadprogress_node_t *up;
  u_char *p;
  off_t *value;

  up = ngx_http_get_module_ctx(r, ngx_http_uploadprogress_module);

  value = (off_t *)((char *)up + data);

  p = ngx_palloc(r->pool, NGX_OFF_T_LEN);
  if (p == NULL) {
    return NGX_ERROR;
  }

  v->len = ngx_sprintf(p, "%O", up->length - *value) - p;
  v->valid = 1;
  v->no_cacheable = 0;
  v->not_found = 0;
  v->data = p;

  return NGX_OK;
}

static ngx_int_t ngx_http_uploadprogress_offset_variable(
    ngx_http_request_t *r, ngx_http_variable_value_t *v, uintptr_t data) {
  ngx_http_uploadprogress_node_t *up;
  u_char *p;
  off_t *value;

  up = ngx_http_get_module_ctx(r, ngx_http_uploadprogress_module);

  value = (off_t *)((char *)up + data);

  p = ngx_palloc(r->pool, NGX_OFF_T_LEN);
  if (p == NULL) {
    return NGX_ERROR;
  }

  v->len = ngx_sprintf(p, "%O", *value) - p;
  v->valid = 1;
  v->no_cacheable = 0;
  v->not_found = 0;
  v->data = p;

  return NGX_OK;
}

static ngx_int_t ngx_http_uploadprogress_status_variable(
    ngx_http_request_t *r, ngx_http_variable_value_t *v, uintptr_t data) {
  ngx_http_uploadprogress_node_t *up;
  u_char *p;
  off_t *value;

  up = ngx_http_get_module_ctx(r, ngx_http_uploadprogress_module);

  value = (off_t *)((char *)up + data);

  p = ngx_palloc(r->pool, NGX_OFF_T_LEN);
  if (p == NULL) {
    return NGX_ERROR;
  }

  v->len = ngx_sprintf(p, "%O", *value) - p;
  v->valid = 1;
  v->no_cacheable = 0;
  v->not_found = 0;
  v->data = p;

  return NGX_OK;
}

static ngx_int_t ngx_http_uploadprogress_callback_variable(
    ngx_http_request_t *r, ngx_http_variable_value_t *v, uintptr_t data) {
  u_char *p, *start_p, *val, prefix[1024];
  ngx_http_uploadprogress_conf_t *upcf;
  u_int len;

  upcf = ngx_http_get_module_loc_conf(r, ngx_http_uploadprogress_module);

  if (r->args.len) {
    /* '=' has to be appended to avoid matching parameters that have the */
    /* configured name as a prefix but are longer */
    ngx_snprintf(prefix, sizeof(prefix) - 1, "%s=", upcf->jsonp_parameter.data);
    len = upcf->jsonp_parameter.len + 1;
    prefix[len] = '\0'; /* Force termination of string */

    p = (u_char *)ngx_strstr(r->args.data, prefix);

    if (p) {
      p += len;
      start_p = p;
      while (p < r->args.data + r->args.len) {
        if (*((p++) + 1) == '&') {
          break;
        }
      }

      v->len = p - start_p;

      val = ngx_palloc(r->pool, v->len + 1);
      if (val == NULL) {
        return NGX_ERROR;
      }

      ngx_memcpy(val, start_p, v->len);
      val[v->len] = '\0';

      v->valid = 1;
      v->no_cacheable = 0;
      v->not_found = 0;
      v->data = val;
    } else {
      return NGX_ERROR;
    }
  } else {
    return NGX_ERROR;
  }

  return NGX_OK;
}