nginxtra 1.6.3.9 → 1.8.0.9

data/vendor/nginx/src/http/modules/ngx_http_geo_module.c

@@ -1470,7 +1470,7 @@ ngx_http_geo_include_binary_base(ngx_conf_t *cf, ngx_http_geo_conf_ctx_t *ctx,
 
     vv = (ngx_http_variable_value_t *) (base + sizeof(ngx_http_geo_header_t));
 
-    while(vv->data) {
+    while (vv->data) {
         len = ngx_align(sizeof(ngx_http_variable_value_t) + vv->len,
                         sizeof(void *));
         ngx_crc32_update(&crc32, (u_char *) vv, len);

data/vendor/nginx/src/http/modules/ngx_http_geoip_module.c

@@ -553,6 +553,9 @@ ngx_http_geoip_city_float_variable(ngx_http_request_t *r,
     val = *(float *) ((char *) gr + data);
 
     v->len = ngx_sprintf(v->data, "%.4f", val) - v->data;
+    v->valid = 1;
+    v->no_cacheable = 0;
+    v->not_found = 0;
 
     GeoIPRecord_delete(gr);
 
@@ -582,6 +585,9 @@ ngx_http_geoip_city_int_variable(ngx_http_request_t *r,
     val = *(int *) ((char *) gr + data);
 
     v->len = ngx_sprintf(v->data, "%d", val) - v->data;
+    v->valid = 1;
+    v->no_cacheable = 0;
+    v->not_found = 0;
 
     GeoIPRecord_delete(gr);
 
@@ -691,7 +697,7 @@ ngx_http_geoip_country(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
 
     if (cf->args->nelts == 3) {
         if (ngx_strcmp(value[2].data, "utf8") == 0) {
-            GeoIP_set_charset (gcf->country, GEOIP_CHARSET_UTF8);
+            GeoIP_set_charset(gcf->country, GEOIP_CHARSET_UTF8);
 
         } else {
             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
@@ -746,7 +752,7 @@ ngx_http_geoip_org(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
 
     if (cf->args->nelts == 3) {
         if (ngx_strcmp(value[2].data, "utf8") == 0) {
-            GeoIP_set_charset (gcf->org, GEOIP_CHARSET_UTF8);
+            GeoIP_set_charset(gcf->org, GEOIP_CHARSET_UTF8);
 
         } else {
             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
@@ -807,7 +813,7 @@ ngx_http_geoip_city(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
 
     if (cf->args->nelts == 3) {
         if (ngx_strcmp(value[2].data, "utf8") == 0) {
-            GeoIP_set_charset (gcf->city, GEOIP_CHARSET_UTF8);
+            GeoIP_set_charset(gcf->city, GEOIP_CHARSET_UTF8);
 
         } else {
             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,

data/vendor/nginx/src/http/modules/ngx_http_gunzip_filter_module.c

@@ -165,7 +165,7 @@ ngx_http_gunzip_header_filter(ngx_http_request_t *r)
 
     ngx_http_clear_content_length(r);
     ngx_http_clear_accept_ranges(r);
-    ngx_http_clear_etag(r);
+    ngx_http_weak_etag(r);
 
     return ngx_http_next_header_filter(r);
 }
@@ -175,6 +175,7 @@ static ngx_int_t
 ngx_http_gunzip_body_filter(ngx_http_request_t *r, ngx_chain_t *in)
 {
     int                     rc;
+    ngx_uint_t              flush;
     ngx_chain_t            *cl;
     ngx_http_gunzip_ctx_t  *ctx;
 
@@ -199,7 +200,7 @@ ngx_http_gunzip_body_filter(ngx_http_request_t *r, ngx_chain_t *in)
         }
     }
 
-    if (ctx->nomem || in == NULL) {
+    if (ctx->nomem) {
 
         /* flush busy buffers */
 
@@ -212,6 +213,10 @@ ngx_http_gunzip_body_filter(ngx_http_request_t *r, ngx_chain_t *in)
         ngx_chain_update_chains(r->pool, &ctx->free, &ctx->busy, &cl,
                                 (ngx_buf_tag_t) &ngx_http_gunzip_filter_module);
         ctx->nomem = 0;
+        flush = 0;
+
+    } else {
+        flush = ctx->busy ? 1 : 0;
     }
 
     for ( ;; ) {
@@ -258,7 +263,7 @@ ngx_http_gunzip_body_filter(ngx_http_request_t *r, ngx_chain_t *in)
             /* rc == NGX_AGAIN */
         }
 
-        if (ctx->out == NULL) {
+        if (ctx->out == NULL && !flush) {
             return ctx->busy ? NGX_AGAIN : NGX_OK;
         }
 
@@ -276,6 +281,7 @@ ngx_http_gunzip_body_filter(ngx_http_request_t *r, ngx_chain_t *in)
                        "gunzip out: %p", ctx->out);
 
         ctx->nomem = 0;
+        flush = 0;
 
         if (ctx->done) {
             return rc;

data/vendor/nginx/src/http/modules/ngx_http_gzip_filter_module.c

@@ -306,7 +306,7 @@ ngx_http_gzip_header_filter(ngx_http_request_t *r)
 
     ngx_http_clear_content_length(r);
     ngx_http_clear_accept_ranges(r);
-    ngx_http_clear_etag(r);
+    ngx_http_weak_etag(r);
 
     return ngx_http_next_header_filter(r);
 }
@@ -316,6 +316,7 @@ static ngx_int_t
 ngx_http_gzip_body_filter(ngx_http_request_t *r, ngx_chain_t *in)
 {
     int                   rc;
+    ngx_uint_t            flush;
     ngx_chain_t          *cl;
     ngx_http_gzip_ctx_t  *ctx;
 
@@ -372,7 +373,7 @@ ngx_http_gzip_body_filter(ngx_http_request_t *r, ngx_chain_t *in)
         r->connection->buffered |= NGX_HTTP_GZIP_BUFFERED;
     }
 
-    if (ctx->nomem || in == NULL) {
+    if (ctx->nomem) {
 
         /* flush busy buffers */
 
@@ -385,6 +386,10 @@ ngx_http_gzip_body_filter(ngx_http_request_t *r, ngx_chain_t *in)
         ngx_chain_update_chains(r->pool, &ctx->free, &ctx->busy, &cl,
                                 (ngx_buf_tag_t) &ngx_http_gzip_filter_module);
         ctx->nomem = 0;
+        flush = 0;
+
+    } else {
+        flush = ctx->busy ? 1 : 0;
     }
 
     for ( ;; ) {
@@ -432,7 +437,7 @@ ngx_http_gzip_body_filter(ngx_http_request_t *r, ngx_chain_t *in)
             /* rc == NGX_AGAIN */
         }
 
-        if (ctx->out == NULL) {
+        if (ctx->out == NULL && !flush) {
             ngx_http_gzip_filter_free_copy_buf(r, ctx);
 
             return ctx->busy ? NGX_AGAIN : NGX_OK;
@@ -457,6 +462,7 @@ ngx_http_gzip_body_filter(ngx_http_request_t *r, ngx_chain_t *in)
         ctx->last_out = &ctx->out;
 
         ctx->nomem = 0;
+        flush = 0;
 
         if (ctx->done) {
             return rc;

data/vendor/nginx/src/http/modules/ngx_http_gzip_static_module.c

@@ -246,8 +246,6 @@ ngx_http_gzip_static_handler(ngx_http_request_t *r)
     ngx_str_set(&h->value, "gzip");
     r->headers_out.content_encoding = h;
 
-    r->ignore_content_encoding = 1;
-
     /* we need to allocate all before the header would be sent */
 
     b = ngx_pcalloc(r->pool, sizeof(ngx_buf_t));

data/vendor/nginx/src/http/modules/ngx_http_headers_filter_module.c

@@ -28,6 +28,7 @@ struct ngx_http_header_val_s {
     ngx_str_t                  key;
     ngx_http_set_header_pt     handler;
     ngx_uint_t                 offset;
+    ngx_uint_t                 always;  /* unsigned  always:1 */
 };
 
 
@@ -43,14 +44,17 @@ typedef enum {
 
 
 typedef struct {
-    ngx_http_expires_t       expires;
-    time_t                   expires_time;
-    ngx_array_t             *headers;
+    ngx_http_expires_t         expires;
+    time_t                     expires_time;
+    ngx_http_complex_value_t  *expires_value;
+    ngx_array_t               *headers;
 } ngx_http_headers_conf_t;
 
 
 static ngx_int_t ngx_http_set_expires(ngx_http_request_t *r,
     ngx_http_headers_conf_t *conf);
+static ngx_int_t ngx_http_parse_expires(ngx_str_t *value,
+    ngx_http_expires_t *expires, time_t *expires_time, char **err);
 static ngx_int_t ngx_http_add_cache_control(ngx_http_request_t *r,
     ngx_http_header_val_t *hv, ngx_str_t *value);
 static ngx_int_t ngx_http_add_header(ngx_http_request_t *r,
@@ -98,7 +102,7 @@ static ngx_command_t  ngx_http_headers_filter_commands[] = {
 
     { ngx_string("add_header"),
       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_HTTP_LIF_CONF
-                        |NGX_CONF_TAKE2,
+                        |NGX_CONF_TAKE23,
       ngx_http_headers_add,
       NGX_HTTP_LOC_CONF_OFFSET,
       0,
@@ -146,28 +150,38 @@ static ngx_int_t
 ngx_http_headers_filter(ngx_http_request_t *r)
 {
     ngx_str_t                 value;
-    ngx_uint_t                i;
+    ngx_uint_t                i, safe_status;
     ngx_http_header_val_t    *h;
     ngx_http_headers_conf_t  *conf;
 
     conf = ngx_http_get_module_loc_conf(r, ngx_http_headers_filter_module);
 
     if ((conf->expires == NGX_HTTP_EXPIRES_OFF && conf->headers == NULL)
-        || r != r->main
-        || (r->headers_out.status != NGX_HTTP_OK
-            && r->headers_out.status != NGX_HTTP_CREATED
-            && r->headers_out.status != NGX_HTTP_NO_CONTENT
-            && r->headers_out.status != NGX_HTTP_PARTIAL_CONTENT
-            && r->headers_out.status != NGX_HTTP_MOVED_PERMANENTLY
-            && r->headers_out.status != NGX_HTTP_MOVED_TEMPORARILY
-            && r->headers_out.status != NGX_HTTP_SEE_OTHER
-            && r->headers_out.status != NGX_HTTP_NOT_MODIFIED
-            && r->headers_out.status != NGX_HTTP_TEMPORARY_REDIRECT))
+        || r != r->main)
     {
         return ngx_http_next_header_filter(r);
     }
 
-    if (conf->expires != NGX_HTTP_EXPIRES_OFF) {
+    switch (r->headers_out.status) {
+
+    case NGX_HTTP_OK:
+    case NGX_HTTP_CREATED:
+    case NGX_HTTP_NO_CONTENT:
+    case NGX_HTTP_PARTIAL_CONTENT:
+    case NGX_HTTP_MOVED_PERMANENTLY:
+    case NGX_HTTP_MOVED_TEMPORARILY:
+    case NGX_HTTP_SEE_OTHER:
+    case NGX_HTTP_NOT_MODIFIED:
+    case NGX_HTTP_TEMPORARY_REDIRECT:
+        safe_status = 1;
+        break;
+
+    default:
+        safe_status = 0;
+        break;
+    }
+
+    if (conf->expires != NGX_HTTP_EXPIRES_OFF && safe_status) {
         if (ngx_http_set_expires(r, conf) != NGX_OK) {
             return NGX_ERROR;
         }
@@ -177,6 +191,10 @@ ngx_http_headers_filter(ngx_http_request_t *r)
         h = conf->headers->elts;
         for (i = 0; i < conf->headers->nelts; i++) {
 
+            if (!safe_status && !h[i].always) {
+                continue;
+            }
+
             if (ngx_http_complex_value(r, &h[i].value, &value) != NGX_OK) {
                 return NGX_ERROR;
             }
@@ -194,28 +212,52 @@ ngx_http_headers_filter(ngx_http_request_t *r)
 static ngx_int_t
 ngx_http_set_expires(ngx_http_request_t *r, ngx_http_headers_conf_t *conf)
 {
-    size_t            len;
-    time_t            now, expires_time, max_age;
-    ngx_uint_t        i;
-    ngx_table_elt_t  *expires, *cc, **ccp;
+    char                *err;
+    size_t               len;
+    time_t               now, expires_time, max_age;
+    ngx_str_t            value;
+    ngx_int_t            rc;
+    ngx_uint_t           i;
+    ngx_table_elt_t     *e, *cc, **ccp;
+    ngx_http_expires_t   expires;
+
+    expires = conf->expires;
+    expires_time = conf->expires_time;
+
+    if (conf->expires_value != NULL) {
+
+        if (ngx_http_complex_value(r, conf->expires_value, &value) != NGX_OK) {
+            return NGX_ERROR;
+        }
+
+        rc = ngx_http_parse_expires(&value, &expires, &expires_time, &err);
+
+        if (rc != NGX_OK) {
+            return NGX_OK;
+        }
+
+        if (expires == NGX_HTTP_EXPIRES_OFF) {
+            return NGX_OK;
+        }
+    }
 
-    expires = r->headers_out.expires;
+    e = r->headers_out.expires;
 
-    if (expires == NULL) {
+    if (e == NULL) {
 
-        expires = ngx_list_push(&r->headers_out.headers);
-        if (expires == NULL) {
+        e = ngx_list_push(&r->headers_out.headers);
+        if (e == NULL) {
             return NGX_ERROR;
         }
 
-        r->headers_out.expires = expires;
+        r->headers_out.expires = e;
 
-        expires->hash = 1;
-        ngx_str_set(&expires->key, "Expires");
+        e->hash = 1;
+        ngx_str_set(&e->key, "Expires");
     }
 
     len = sizeof("Mon, 28 Sep 1970 06:00:00 GMT");
-    expires->value.len = len - 1;
+    e->value.len = len - 1;
 
     ccp = r->headers_out.cache_control.elts;
 
@@ -250,26 +292,26 @@ ngx_http_set_expires(ngx_http_request_t *r, ngx_http_headers_conf_t *conf)
         cc = ccp[0];
     }
 
-    if (conf->expires == NGX_HTTP_EXPIRES_EPOCH) {
-        expires->value.data = (u_char *) "Thu, 01 Jan 1970 00:00:01 GMT";
+    if (expires == NGX_HTTP_EXPIRES_EPOCH) {
+        e->value.data = (u_char *) "Thu, 01 Jan 1970 00:00:01 GMT";
         ngx_str_set(&cc->value, "no-cache");
         return NGX_OK;
     }
 
-    if (conf->expires == NGX_HTTP_EXPIRES_MAX) {
-        expires->value.data = (u_char *) "Thu, 31 Dec 2037 23:55:55 GMT";
+    if (expires == NGX_HTTP_EXPIRES_MAX) {
+        e->value.data = (u_char *) "Thu, 31 Dec 2037 23:55:55 GMT";
         /* 10 years */
         ngx_str_set(&cc->value, "max-age=315360000");
         return NGX_OK;
     }
 
-    expires->value.data = ngx_pnalloc(r->pool, len);
-    if (expires->value.data == NULL) {
+    e->value.data = ngx_pnalloc(r->pool, len);
+    if (e->value.data == NULL) {
         return NGX_ERROR;
     }
 
-    if (conf->expires_time == 0 && conf->expires != NGX_HTTP_EXPIRES_DAILY) {
-        ngx_memcpy(expires->value.data, ngx_cached_http_time.data,
+    if (expires_time == 0 && expires != NGX_HTTP_EXPIRES_DAILY) {
+        ngx_memcpy(e->value.data, ngx_cached_http_time.data,
                    ngx_cached_http_time.len + 1);
         ngx_str_set(&cc->value, "max-age=0");
         return NGX_OK;
@@ -277,22 +319,22 @@ ngx_http_set_expires(ngx_http_request_t *r, ngx_http_headers_conf_t *conf)
 
     now = ngx_time();
 
-    if (conf->expires == NGX_HTTP_EXPIRES_DAILY) {
-        expires_time = ngx_next_time(conf->expires_time);
+    if (expires == NGX_HTTP_EXPIRES_DAILY) {
+        expires_time = ngx_next_time(expires_time);
         max_age = expires_time - now;
 
-    } else if (conf->expires == NGX_HTTP_EXPIRES_ACCESS
+    } else if (expires == NGX_HTTP_EXPIRES_ACCESS
                || r->headers_out.last_modified_time == -1)
     {
-        expires_time = now + conf->expires_time;
-        max_age = conf->expires_time;
+        max_age = expires_time;
+        expires_time += now;
 
     } else {
-        expires_time = r->headers_out.last_modified_time + conf->expires_time;
+        expires_time += r->headers_out.last_modified_time;
         max_age = expires_time - now;
     }
 
-    ngx_http_time(expires->value.data, expires_time);
+    ngx_http_time(e->value.data, expires_time);
 
     if (conf->expires_time < 0 || max_age < 0) {
         ngx_str_set(&cc->value, "no-cache");
@@ -312,6 +354,78 @@ ngx_http_set_expires(ngx_http_request_t *r, ngx_http_headers_conf_t *conf)
 }
 
 
+static ngx_int_t
+ngx_http_parse_expires(ngx_str_t *value, ngx_http_expires_t *expires,
+    time_t *expires_time, char **err)
+{
+    ngx_uint_t  minus;
+
+    if (*expires != NGX_HTTP_EXPIRES_MODIFIED) {
+
+        if (value->len == 5 && ngx_strncmp(value->data, "epoch", 5) == 0) {
+            *expires = NGX_HTTP_EXPIRES_EPOCH;
+            return NGX_OK;
+        }
+
+        if (value->len == 3 && ngx_strncmp(value->data, "max", 3) == 0) {
+            *expires = NGX_HTTP_EXPIRES_MAX;
+            return NGX_OK;
+        }
+
+        if (value->len == 3 && ngx_strncmp(value->data, "off", 3) == 0) {
+            *expires = NGX_HTTP_EXPIRES_OFF;
+            return NGX_OK;
+        }
+    }
+
+    if (value->len && value->data[0] == '@') {
+        value->data++;
+        value->len--;
+        minus = 0;
+
+        if (*expires == NGX_HTTP_EXPIRES_MODIFIED) {
+            *err = "daily time cannot be used with \"modified\" parameter";
+            return NGX_ERROR;
+        }
+
+        *expires = NGX_HTTP_EXPIRES_DAILY;
+
+    } else if (value->len && value->data[0] == '+') {
+        value->data++;
+        value->len--;
+        minus = 0;
+
+    } else if (value->len && value->data[0] == '-') {
+        value->data++;
+        value->len--;
+        minus = 1;
+
+    } else {
+        minus = 0;
+    }
+
+    *expires_time = ngx_parse_time(value, 1);
+
+    if (*expires_time == (time_t) NGX_ERROR) {
+        *err = "invalid value";
+        return NGX_ERROR;
+    }
+
+    if (*expires == NGX_HTTP_EXPIRES_DAILY
+        && *expires_time > 24 * 60 * 60)
+    {
+        *err = "daily time value must be less than 24 hours";
+        return NGX_ERROR;
+    }
+
+    if (minus) {
+        *expires_time = - *expires_time;
+    }
+
+    return NGX_OK;
+}
+
+
 static ngx_int_t
 ngx_http_add_header(ngx_http_request_t *r, ngx_http_header_val_t *hv,
     ngx_str_t *value)
@@ -442,6 +556,7 @@ ngx_http_headers_create_conf(ngx_conf_t *cf)
      *
      *     conf->headers = NULL;
      *     conf->expires_time = 0;
+     *     conf->expires_value = NULL;
      */
 
     conf->expires = NGX_HTTP_EXPIRES_UNSET;
@@ -459,6 +574,7 @@ ngx_http_headers_merge_conf(ngx_conf_t *cf, void *parent, void *child)
     if (conf->expires == NGX_HTTP_EXPIRES_UNSET) {
         conf->expires = prev->expires;
         conf->expires_time = prev->expires_time;
+        conf->expires_value = prev->expires_value;
 
         if (conf->expires == NGX_HTTP_EXPIRES_UNSET) {
             conf->expires = NGX_HTTP_EXPIRES_OFF;
@@ -488,8 +604,12 @@ ngx_http_headers_expires(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
 {
     ngx_http_headers_conf_t *hcf = conf;
 
-    ngx_uint_t   minus, n;
-    ngx_str_t   *value;
+    char                              *err;
+    ngx_str_t                         *value;
+    ngx_int_t                          rc;
+    ngx_uint_t                         n;
+    ngx_http_complex_value_t           cv;
+    ngx_http_compile_complex_value_t   ccv;
 
     if (hcf->expires != NGX_HTTP_EXPIRES_UNSET) {
         return "is duplicate";
@@ -499,21 +619,6 @@ ngx_http_headers_expires(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
 
     if (cf->args->nelts == 2) {
 
-        if (ngx_strcmp(value[1].data, "epoch") == 0) {
-            hcf->expires = NGX_HTTP_EXPIRES_EPOCH;
-            return NGX_CONF_OK;
-        }
-
-        if (ngx_strcmp(value[1].data, "max") == 0) {
-            hcf->expires = NGX_HTTP_EXPIRES_MAX;
-            return NGX_CONF_OK;
-        }
-
-        if (ngx_strcmp(value[1].data, "off") == 0) {
-            hcf->expires = NGX_HTTP_EXPIRES_OFF;
-            return NGX_CONF_OK;
-        }
-
         hcf->expires = NGX_HTTP_EXPIRES_ACCESS;
 
         n = 1;
@@ -529,45 +634,33 @@ ngx_http_headers_expires(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
         n = 2;
     }
 
-    if (value[n].data[0] == '@') {
-        value[n].data++;
-        value[n].len--;
-        minus = 0;
-
-        if (hcf->expires == NGX_HTTP_EXPIRES_MODIFIED) {
-            return "daily time cannot be used with \"modified\" parameter";
-        }
-
-        hcf->expires = NGX_HTTP_EXPIRES_DAILY;
-
-    } else if (value[n].data[0] == '+') {
-        value[n].data++;
-        value[n].len--;
-        minus = 0;
+    ngx_memzero(&ccv, sizeof(ngx_http_compile_complex_value_t));
 
-    } else if (value[n].data[0] == '-') {
-        value[n].data++;
-        value[n].len--;
-        minus = 1;
+    ccv.cf = cf;
+    ccv.value = &value[n];
+    ccv.complex_value = &cv;
 
-    } else {
-        minus = 0;
+    if (ngx_http_compile_complex_value(&ccv) != NGX_OK) {
+        return NGX_CONF_ERROR;
     }
 
-    hcf->expires_time = ngx_parse_time(&value[n], 1);
+    if (cv.lengths != NULL) {
 
-    if (hcf->expires_time == (time_t) NGX_ERROR) {
-        return "invalid value";
-    }
+        hcf->expires_value = ngx_palloc(cf->pool,
+                                        sizeof(ngx_http_complex_value_t));
+        if (hcf->expires_value == NULL) {
+            return NGX_CONF_ERROR;
+        }
 
-    if (hcf->expires == NGX_HTTP_EXPIRES_DAILY
-        && hcf->expires_time > 24 * 60 * 60)
-    {
-        return "daily time value must be less than 24 hours";
+        *hcf->expires_value = cv;
+
+        return NGX_CONF_OK;
     }
 
-    if (minus) {
-        hcf->expires_time = - hcf->expires_time;
+    rc = ngx_http_parse_expires(&value[n], &hcf->expires, &hcf->expires_time,
+                                &err);
+    if (rc != NGX_OK) {
+        return err;
     }
 
     return NGX_CONF_OK;
@@ -603,6 +696,7 @@ ngx_http_headers_add(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
     hv->key = value[1];
     hv->handler = ngx_http_add_header;
     hv->offset = 0;
+    hv->always = 0;
 
     set = ngx_http_set_headers;
     for (i = 0; set[i].name.len; i++) {
@@ -631,5 +725,17 @@ ngx_http_headers_add(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
         return NGX_CONF_ERROR;
     }
 
+    if (cf->args->nelts == 3) {
+        return NGX_CONF_OK;
+    }
+
+    if (ngx_strcmp(value[3].data, "always") != 0) {
+        ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
+                           "invalid parameter \"%V\"", &value[3]);
+        return NGX_CONF_ERROR;
+    }
+
+    hv->always = 1;
+
     return NGX_CONF_OK;
 }