Changeset 2a28c1

Timestamp:

02/03/08 15:02:34 (4 years ago)

Author:

Tomash Brechko <tomash.brechko@…>

Branches:

master-v0.7, master-v0.6, memcached_gzip, upstream_count_limit

Children:

dbd2c3, f54237

Parents:

e1c857 (diff), 2bbdb3 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

git-author:

Tomash Brechko <tomash.brechko@…> (02/03/08 15:02:34)

git-committer:

Tomash Brechko <tomash.brechko@…> (02/03/08 15:02:34)

Message:

Merge branch 'gunzip' into memcached_gzip

Location:

server/src/http/modules

Files:

• ngx_http_gzip_filter_module.c (modified) (5 diffs)
• ngx_http_memcached_module.c (modified) (7 diffs)

server/src/http/modules/ngx_http_gzip_filter_module.c

@@ -319 +319 @@
 
     if (ctx->preallocated == NULL) {
-        wbits = conf->wbits;
+        wbits = (!r->gunzip ? conf->wbits : 15);
         memlevel = conf->memlevel;
 
-        if (ctx->length > 0) {
+        if (!r->gunzip && ctx->length > 0) {
 
             /* the actual zlib window size is smaller by 262 bytes */
@@ -543 +543 @@
             ctx->out_buf->last = ctx->zstream.next_out;
 
-            if (ctx->zstream.avail_out == 0) {
-
-                /* zlib wants to output some more gzipped data */
-
-                cl = ngx_alloc_chain_link(r->pool);
-                if (cl == NULL) {
-                    ngx_http_gzip_error(ctx);
-                    return NGX_ERROR;
-                }
-
-                cl->buf = ctx->out_buf;
-                cl->next = NULL;
-                *ctx->last_out = cl;
-                ctx->last_out = &cl->next;
-
-                ctx->redo = 1;
-
-                continue;
-            }
-
             ctx->redo = 0;
 
-            if (ctx->flush == Z_SYNC_FLUSH
-                && ctx->out_buf->last > ctx->out_buf->pos) {
-
-                ctx->zstream.avail_out = 0;
+            if (ctx->flush == Z_SYNC_FLUSH) {
+
                 ctx->out_buf->flush = 1;
                 ctx->flush = Z_NO_FLUSH;
 
-                cl = ngx_alloc_chain_link(r->pool);
-                if (cl == NULL) {
-                    ngx_http_gzip_error(ctx);
-                    return NGX_ERROR;
-                }
-
-                cl->buf = ctx->out_buf;
-                cl->next = NULL;
-                *ctx->last_out = cl;
-                ctx->last_out = &cl->next;
-
-                break;
+                /*
+                 * On decompression there might be not enough input
+                 * data to produce any output data.
+                 */
+                if (ctx->out_buf->last > ctx->out_buf->pos) {
+
+                    ctx->zstream.avail_out = 0;
+
+                    cl = ngx_alloc_chain_link(r->pool);
+                    if (cl == NULL) {
+                        ngx_http_gzip_error(ctx);
+                        return NGX_ERROR;
+                    }
+
+                    cl->buf = ctx->out_buf;
+                    cl->next = NULL;
+                    *ctx->last_out = cl;
+                    ctx->last_out = &cl->next;
+
+                    break;
+                }
             }
 
@@ -596 +583 @@
                     ctx->zout = ctx->zstream.total_out;
 
-                    r->gunzip = 0;
                     rc = inflateEnd(&ctx->zstream);
                 }
@@ -667 +653 @@
                 } else {
                     ctx->out_buf->last_buf = 1;
+                    r->gunzip = 0;
                 }
 
@@ -677 +664 @@
 
                 break;
+            }
+
+            if (ctx->zstream.avail_out == 0) {
+
+                /* zlib wants to output some more gzipped data */
+
+                cl = ngx_alloc_chain_link(r->pool);
+                if (cl == NULL) {
+                    ngx_http_gzip_error(ctx);
+                    return NGX_ERROR;
+                }
+
+                cl->buf = ctx->out_buf;
+                cl->next = NULL;
+                *ctx->last_out = cl;
+                ctx->last_out = &cl->next;
+
+                ctx->redo = 1;
+
+                continue;
             }
 

server/src/http/modules/ngx_http_memcached_module.c

@@ -14 +14 @@
     ngx_http_upstream_conf_t   upstream;
     ngx_int_t                  index;
+    ngx_uint_t                 gzip_flag;
 } ngx_http_memcached_loc_conf_t;
 
@@ -99 +100 @@
       offsetof(ngx_http_memcached_loc_conf_t, upstream.next_upstream),
       &ngx_http_memcached_next_upstream_masks },
+
+    { ngx_string("memcached_gzip_flag"),
+      NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
+      ngx_conf_set_num_slot,
+      NGX_HTTP_LOC_CONF_OFFSET,
+      offsetof(ngx_http_memcached_loc_conf_t, gzip_flag),
+      NULL },
 
     { ngx_string("memcached_upstream_max_fails"),
@@ -298 +306 @@
 ngx_http_memcached_process_header(ngx_http_request_t *r)
 {
-    u_char                    *p, *len;
+    u_char                    *p, *beg;
     ngx_str_t                  line;
     ngx_http_upstream_t       *u;
     ngx_http_memcached_ctx_t  *ctx;
+    ngx_http_memcached_loc_conf_t  *mlcf;
+    uint32_t                   flags;
+    ngx_table_elt_t           *h;
+    ngx_http_core_loc_conf_t  *clcf;
 
     u = r->upstream;
@@ -346 +358 @@
         }
 
-        /* skip flags */
-
-        while (*p) {
-            if (*p++ == ' ') {
-                goto length;
-            }
+        beg = p;
+
+        while (*p && *p++ != ' ') { /* void */ }
+
+        if (! *p) {
+            goto no_valid;
         }
 
-        goto no_valid;
-
-    length:
-
-        len = p;
+        flags = ngx_atoof(beg, p - beg - 1);
+
+        beg = p;
 
         while (*p && *p++ != CR) { /* void */ }
 
-        r->headers_out.content_length_n = ngx_atoof(len, p - len - 1);
+        r->headers_out.content_length_n = ngx_atoof(beg, p - beg - 1);
         if (r->headers_out.content_length_n == -1) {
             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
@@ -369 +379 @@
                           &line, &ctx->key);
             return NGX_HTTP_UPSTREAM_INVALID_HEADER;
+        }
+
+        mlcf = ngx_http_get_module_loc_conf(r, ngx_http_memcached_module);
+
+        if (flags & mlcf->gzip_flag) {
+#if (NGX_HTTP_GZIP)
+            clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);
+
+            if (ngx_http_gzip_ok(r) == NGX_OK) {
+                h = ngx_list_push(&r->headers_out.headers);
+                if (h == NULL) {
+                    return NGX_ERROR;
+                }
+
+                h->hash = 1;
+                h->key.len = sizeof("Content-Encoding") - 1;
+                h->key.data = (u_char *) "Content-Encoding";
+                h->value.len = sizeof("gzip") - 1;
+                h->value.data = (u_char *) "gzip";
+
+                r->headers_out.content_encoding = h;
+
+                if (clcf->gzip_vary) {
+                    h = ngx_list_push(&r->headers_out.headers);
+                    if (h == NULL) {
+                        return NGX_ERROR;
+                    }
+
+                    h->hash = 1;
+                    h->key.len = sizeof("Vary") - 1;
+                    h->key.data = (u_char *) "Vary";
+                    h->value.len = sizeof("Accept-Encoding") - 1;
+                    h->value.data = (u_char *) "Accept-Encoding";
+                }
+            } else {
+                if (clcf->gunzip) {
+                    r->gunzip = 1;
+                } else {
+#endif
+                    /*
+                     * If the client can't accept compressed data, and
+                     * automatic decompression is not enabled, we
+                     * return 404 in the hope that the next upstream
+                     * will return uncompressed data.
+                     */
+                    u->headers_in.status_n = 404;
+                    u->state->status = 404;
+
+                    return NGX_OK;
+#if (NGX_HTTP_GZIP)
+                }
+            }
+#endif
         }
 
@@ -532 +595 @@
 
     conf->upstream.buffer_size = NGX_CONF_UNSET_SIZE;
+
+    conf->gzip_flag = NGX_CONF_UNSET_UINT;
 
     /* the hardcoded values */
@@ -576 +641 @@
                                |NGX_HTTP_UPSTREAM_FT_TIMEOUT));
 
+    ngx_conf_merge_uint_value(conf->gzip_flag,
+                              prev->gzip_flag, 0);
+
     if (conf->upstream.next_upstream & NGX_HTTP_UPSTREAM_FT_OFF) {
         conf->upstream.next_upstream = NGX_CONF_BITMASK_SET