blob: 37f237fed6e0aa6186d9c176b7f215ed6edf3c36 [file] [log] [blame]
Christopher Faulet3d97c902015-12-09 14:59:38 +01001/*
2 * Stream filters related variables and functions.
3 *
4 * Copyright (C) 2015 Qualys Inc., Christopher Faulet <cfaulet@qualys.com>
5 *
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version
9 * 2 of the License, or (at your option) any later version.
10 *
11 */
12
13#include <common/buffer.h>
14#include <common/cfgparse.h>
Willy Tarreaub96b77e2018-12-11 10:22:41 +010015#include <common/htx.h>
Willy Tarreau0108d902018-11-25 19:14:37 +010016#include <common/initcall.h>
Christopher Faulet3d97c902015-12-09 14:59:38 +010017#include <common/mini-clist.h>
18#include <common/standard.h>
19
20#include <types/compression.h>
21#include <types/filters.h>
Christopher Faulet3d97c902015-12-09 14:59:38 +010022#include <types/proxy.h>
23#include <types/sample.h>
24
25#include <proto/compression.h>
Christopher Faulet92d36382015-11-05 13:35:03 +010026#include <proto/filters.h>
Christopher Faulet3d97c902015-12-09 14:59:38 +010027#include <proto/hdr_idx.h>
Christopher Faulete6902cd2018-11-30 22:29:48 +010028#include <proto/http_htx.h>
Christopher Faulet3d97c902015-12-09 14:59:38 +010029#include <proto/proto_http.h>
30#include <proto/sample.h>
31#include <proto/stream.h>
32
Christopher Fauletf4a4ef72018-12-07 17:39:53 +010033const char *http_comp_flt_id = "compression filter";
Christopher Faulet92d36382015-11-05 13:35:03 +010034
35struct flt_ops comp_ops;
36
Christopher Faulet92d36382015-11-05 13:35:03 +010037struct comp_state {
38 struct comp_ctx *comp_ctx; /* compression context */
39 struct comp_algo *comp_algo; /* compression algorithm if not NULL */
Christopher Faulete6902cd2018-11-30 22:29:48 +010040
41 /* Following fields are used by the legacy code only: */
Christopher Fauletb77c5c22015-12-07 16:48:42 +010042 int hdrs_len;
43 int tlrs_len;
Christopher Faulet2fb28802015-12-01 10:40:57 +010044 int consumed;
45 int initialized;
Christopher Fauletb77c5c22015-12-07 16:48:42 +010046 int finished;
Christopher Faulet92d36382015-11-05 13:35:03 +010047};
48
Willy Tarreau8ceae722018-11-26 11:58:30 +010049/* Pools used to allocate comp_state structs */
50DECLARE_STATIC_POOL(pool_head_comp_state, "comp_state", sizeof(struct comp_state));
51
52static THREAD_LOCAL struct buffer tmpbuf;
53static THREAD_LOCAL struct buffer zbuf;
Willy Tarreau8ceae722018-11-26 11:58:30 +010054
Christopher Faulet92d36382015-11-05 13:35:03 +010055static int select_compression_request_header(struct comp_state *st,
56 struct stream *s,
57 struct http_msg *msg);
58static int select_compression_response_header(struct comp_state *st,
59 struct stream *s,
60 struct http_msg *msg);
Christopher Faulet27d93c32018-12-15 22:32:02 +010061static int set_compression_response_header(struct comp_state *st,
62 struct stream *s,
63 struct http_msg *msg);
Christopher Faulet92d36382015-11-05 13:35:03 +010064
Christopher Faulete6902cd2018-11-30 22:29:48 +010065static int htx_compression_buffer_init(struct htx *htx, struct buffer *out);
66static int htx_compression_buffer_add_data(struct comp_state *st, const char *data, size_t len,
67 struct buffer *out);
68static int htx_compression_buffer_end(struct comp_state *st, struct buffer *out, int end);
69
Christopher Fauletb61481c2018-12-17 13:17:53 +010070static int http_compression_buffer_init(struct channel *inc, struct buffer *out);
Christopher Faulet92d36382015-11-05 13:35:03 +010071static int http_compression_buffer_add_data(struct comp_state *st,
72 struct buffer *in,
Willy Tarreaud54a8ce2018-06-29 18:42:02 +020073 int in_out,
Christopher Faulet92d36382015-11-05 13:35:03 +010074 struct buffer *out, int sz);
75static int http_compression_buffer_end(struct comp_state *st, struct stream *s,
Willy Tarreauc9fa0482018-07-10 17:43:27 +020076 struct channel *chn, struct buffer *out,
Christopher Fauletb61481c2018-12-17 13:17:53 +010077 int end);
Christopher Faulet92d36382015-11-05 13:35:03 +010078
79/***********************************************************************/
80static int
Christopher Faulete6902cd2018-11-30 22:29:48 +010081comp_flt_init(struct proxy *px, struct flt_conf *fconf)
82{
Christopher Faulet6e540952018-12-03 22:43:41 +010083 fconf->flags |= FLT_CFG_FL_HTX;
Christopher Faulete6902cd2018-11-30 22:29:48 +010084 return 0;
85}
86
87static int
Christopher Faulet8ca3b4b2017-07-25 11:07:15 +020088comp_flt_init_per_thread(struct proxy *px, struct flt_conf *fconf)
Christopher Faulet92d36382015-11-05 13:35:03 +010089{
Willy Tarreauc9fa0482018-07-10 17:43:27 +020090 if (!tmpbuf.size && b_alloc(&tmpbuf) == NULL)
Christopher Fauletb77c5c22015-12-07 16:48:42 +010091 return -1;
Willy Tarreauc9fa0482018-07-10 17:43:27 +020092 if (!zbuf.size && b_alloc(&zbuf) == NULL)
Christopher Fauletb77c5c22015-12-07 16:48:42 +010093 return -1;
Christopher Faulet92d36382015-11-05 13:35:03 +010094 return 0;
95}
96
97static void
Christopher Faulet8ca3b4b2017-07-25 11:07:15 +020098comp_flt_deinit_per_thread(struct proxy *px, struct flt_conf *fconf)
Christopher Faulet92d36382015-11-05 13:35:03 +010099{
Willy Tarreauc9fa0482018-07-10 17:43:27 +0200100 if (tmpbuf.size)
Christopher Faulet92d36382015-11-05 13:35:03 +0100101 b_free(&tmpbuf);
Willy Tarreauc9fa0482018-07-10 17:43:27 +0200102 if (zbuf.size)
Christopher Fauletb77c5c22015-12-07 16:48:42 +0100103 b_free(&zbuf);
Christopher Faulet92d36382015-11-05 13:35:03 +0100104}
105
106static int
107comp_start_analyze(struct stream *s, struct filter *filter, struct channel *chn)
108{
Christopher Faulet8ca3b4b2017-07-25 11:07:15 +0200109
Christopher Faulet92d36382015-11-05 13:35:03 +0100110 if (filter->ctx == NULL) {
111 struct comp_state *st;
112
Willy Tarreaubafbe012017-11-24 17:34:44 +0100113 st = pool_alloc_dirty(pool_head_comp_state);
Christopher Fauleta03d4ad2017-06-26 16:53:33 +0200114 if (st == NULL)
Christopher Faulet92d36382015-11-05 13:35:03 +0100115 return -1;
116
Christopher Faulet2fb28802015-12-01 10:40:57 +0100117 st->comp_algo = NULL;
118 st->comp_ctx = NULL;
Christopher Fauletb77c5c22015-12-07 16:48:42 +0100119 st->hdrs_len = 0;
120 st->tlrs_len = 0;
Christopher Faulet2fb28802015-12-01 10:40:57 +0100121 st->consumed = 0;
122 st->initialized = 0;
Christopher Fauletb77c5c22015-12-07 16:48:42 +0100123 st->finished = 0;
Christopher Faulet2fb28802015-12-01 10:40:57 +0100124 filter->ctx = st;
Christopher Faulet3dc860d2017-09-15 11:39:36 +0200125
126 /* Register post-analyzer on AN_RES_WAIT_HTTP because we need to
127 * analyze response headers before http-response rules execution
128 * to be sure we can use res.comp and res.comp_algo sample
129 * fetches */
130 filter->post_analyzers |= AN_RES_WAIT_HTTP;
Christopher Faulet92d36382015-11-05 13:35:03 +0100131 }
132 return 1;
133}
134
135static int
Christopher Faulet92d36382015-11-05 13:35:03 +0100136comp_end_analyze(struct stream *s, struct filter *filter, struct channel *chn)
137{
138 struct comp_state *st = filter->ctx;
Christopher Faulet92d36382015-11-05 13:35:03 +0100139
Christopher Fauletd60b3cf2017-06-26 11:47:13 +0200140 if (!st)
Christopher Faulet92d36382015-11-05 13:35:03 +0100141 goto end;
142
Christopher Faulet92d36382015-11-05 13:35:03 +0100143 /* release any possible compression context */
Christopher Fauletd60b3cf2017-06-26 11:47:13 +0200144 if (st->comp_algo)
145 st->comp_algo->end(&st->comp_ctx);
Willy Tarreaubafbe012017-11-24 17:34:44 +0100146 pool_free(pool_head_comp_state, st);
Christopher Faulet92d36382015-11-05 13:35:03 +0100147 filter->ctx = NULL;
148 end:
149 return 1;
150}
151
152static int
Christopher Faulet1339d742016-05-11 16:48:33 +0200153comp_http_headers(struct stream *s, struct filter *filter, struct http_msg *msg)
154{
155 struct comp_state *st = filter->ctx;
156
157 if (!strm_fe(s)->comp && !s->be->comp)
158 goto end;
159
160 if (!(msg->chn->flags & CF_ISRESP))
161 select_compression_request_header(st, s, msg);
162 else {
Christopher Faulet3dc860d2017-09-15 11:39:36 +0200163 /* Response headers have already been checked in
164 * comp_http_post_analyze callback. */
Christopher Faulet1339d742016-05-11 16:48:33 +0200165 if (st->comp_algo) {
Christopher Faulet27d93c32018-12-15 22:32:02 +0100166 if (!set_compression_response_header(st, s, msg))
167 goto end;
Christopher Faulet1339d742016-05-11 16:48:33 +0200168 register_data_filter(s, msg->chn, filter);
Christopher Faulete6902cd2018-11-30 22:29:48 +0100169 if (!IS_HTX_STRM(s))
170 st->hdrs_len = s->txn->rsp.sov;
Christopher Faulet1339d742016-05-11 16:48:33 +0200171 }
172 }
173
174 end:
175 return 1;
176}
177
178static int
Christopher Faulet3dc860d2017-09-15 11:39:36 +0200179comp_http_post_analyze(struct stream *s, struct filter *filter,
180 struct channel *chn, unsigned an_bit)
181{
182 struct http_txn *txn = s->txn;
183 struct http_msg *msg = &txn->rsp;
184 struct comp_state *st = filter->ctx;
185
186 if (an_bit != AN_RES_WAIT_HTTP)
187 goto end;
188
189 if (!strm_fe(s)->comp && !s->be->comp)
190 goto end;
191
192 select_compression_response_header(st, s, msg);
193
194 end:
195 return 1;
196}
197
198static int
Christopher Faulete6902cd2018-11-30 22:29:48 +0100199comp_http_payload(struct stream *s, struct filter *filter, struct http_msg *msg,
200 unsigned int offset, unsigned int len)
201{
202 struct comp_state *st = filter->ctx;
Christopher Faulet27ba2dc2018-12-05 11:53:24 +0100203 struct htx *htx = htxbuf(&msg->chn->buf);
Christopher Faulete6902cd2018-11-30 22:29:48 +0100204 struct htx_blk *blk;
Christopher Faulete6902cd2018-11-30 22:29:48 +0100205 int ret, consumed = 0, to_forward = 0;
206
Christopher Fauletee847d42019-05-23 11:55:33 +0200207 for (blk = htx_get_first_blk(htx); blk && len; blk = htx_get_next_blk(htx, blk)) {
Christopher Faulete6902cd2018-11-30 22:29:48 +0100208 enum htx_blk_type type = htx_get_blk_type(blk);
209 uint32_t sz = htx_get_blksz(blk);
210 struct ist v;
211
Christopher Fauletee847d42019-05-23 11:55:33 +0200212 if (offset >= sz) {
213 offset -= sz;
214 continue;
215 }
216
Christopher Faulete6902cd2018-11-30 22:29:48 +0100217 switch (type) {
218 case HTX_BLK_UNUSED:
219 break;
220
221 case HTX_BLK_DATA:
222 v = htx_get_blk_value(htx, blk);
223 v.ptr += offset;
224 v.len -= offset;
225 if (v.len > len)
226 v.len = len;
227 if (htx_compression_buffer_init(htx, &trash) < 0) {
228 msg->chn->flags |= CF_WAKE_WRITE;
229 goto end;
230 }
231 ret = htx_compression_buffer_add_data(st, v.ptr, v.len, &trash);
232 if (ret < 0)
233 goto error;
234 if (htx_compression_buffer_end(st, &trash, 0) < 0)
235 goto error;
236 len -= ret;
237 consumed += ret;
238 to_forward += b_data(&trash);
239 if (ret == sz && !b_data(&trash)) {
240 offset = 0;
241 blk = htx_remove_blk(htx, blk);
242 continue;
243 }
244 v.len = ret;
245 blk = htx_replace_blk_value(htx, blk, v, ist2(b_head(&trash), b_data(&trash)));
246 break;
247
Christopher Faulete6902cd2018-11-30 22:29:48 +0100248 case HTX_BLK_TLR:
Christopher Faulet2d7c5392019-06-03 10:41:26 +0200249 case HTX_BLK_EOT:
Christopher Faulete6902cd2018-11-30 22:29:48 +0100250 case HTX_BLK_EOM:
251 if (msg->flags & HTTP_MSGF_COMPRESSING) {
252 if (htx_compression_buffer_init(htx, &trash) < 0) {
253 msg->chn->flags |= CF_WAKE_WRITE;
254 goto end;
255 }
256 if (htx_compression_buffer_end(st, &trash, 1) < 0)
257 goto error;
Christopher Fauletd238ae32018-12-21 15:10:25 +0100258 if (b_data(&trash)) {
Christopher Faulet86bc8df2019-06-11 10:38:38 +0200259 struct htx_blk *last = htx_add_last_data(htx, ist2(b_head(&trash), b_data(&trash)));
260 if (!last)
261 goto error;
262 blk = htx_get_next_blk(htx, last);
Christopher Fauletd238ae32018-12-21 15:10:25 +0100263 if (!blk)
264 goto error;
265 to_forward += b_data(&trash);
266 }
Christopher Faulete6902cd2018-11-30 22:29:48 +0100267 msg->flags &= ~HTTP_MSGF_COMPRESSING;
268 /* We let the mux add last empty chunk and empty trailers */
269 }
270 /* fall through */
271
272 default:
273 sz -= offset;
274 if (sz > len)
275 sz = len;
276 consumed += sz;
277 to_forward += sz;
278 len -= sz;
279 break;
280 }
281
282 offset = 0;
Christopher Faulete6902cd2018-11-30 22:29:48 +0100283 }
284
285 end:
286 if (to_forward != consumed)
287 flt_update_offsets(filter, msg->chn, to_forward - consumed);
288
289 if (st->comp_ctx && st->comp_ctx->cur_lvl > 0) {
Willy Tarreauef6fd852019-02-04 11:48:03 +0100290 update_freq_ctr(&global.comp_bps_in, consumed);
Olivier Houchard43da3432019-03-08 18:50:27 +0100291 _HA_ATOMIC_ADD(&strm_fe(s)->fe_counters.comp_in, consumed);
292 _HA_ATOMIC_ADD(&s->be->be_counters.comp_in, consumed);
Christopher Faulete6902cd2018-11-30 22:29:48 +0100293 update_freq_ctr(&global.comp_bps_out, to_forward);
Olivier Houchard43da3432019-03-08 18:50:27 +0100294 _HA_ATOMIC_ADD(&strm_fe(s)->fe_counters.comp_out, to_forward);
295 _HA_ATOMIC_ADD(&s->be->be_counters.comp_out, to_forward);
Willy Tarreauef6fd852019-02-04 11:48:03 +0100296 } else {
Olivier Houchard43da3432019-03-08 18:50:27 +0100297 _HA_ATOMIC_ADD(&strm_fe(s)->fe_counters.comp_byp, consumed);
298 _HA_ATOMIC_ADD(&s->be->be_counters.comp_byp, consumed);
Christopher Faulete6902cd2018-11-30 22:29:48 +0100299 }
300 return to_forward;
301
302 error:
303 return -1;
304}
305
306static int
Christopher Faulet2fb28802015-12-01 10:40:57 +0100307comp_http_data(struct stream *s, struct filter *filter, struct http_msg *msg)
Christopher Faulet92d36382015-11-05 13:35:03 +0100308{
309 struct comp_state *st = filter->ctx;
Willy Tarreaubcbd3932018-06-06 07:13:22 +0200310 struct channel *chn = msg->chn;
Christopher Faulet3e7bc672015-12-07 13:39:08 +0100311 unsigned int *nxt = &flt_rsp_nxt(filter);
Christopher Faulet2fb28802015-12-01 10:40:57 +0100312 unsigned int len;
Christopher Faulet92d36382015-11-05 13:35:03 +0100313 int ret;
314
Olivier Houchard0b662842018-06-29 18:16:31 +0200315 len = MIN(msg->chunk_len + msg->next, ci_data(chn)) - *nxt;
Christopher Faulet2fb28802015-12-01 10:40:57 +0100316 if (!len)
317 return len;
318
319 if (!st->initialized) {
Christopher Fauletb77c5c22015-12-07 16:48:42 +0100320 unsigned int fwd = flt_rsp_fwd(filter) + st->hdrs_len;
Christopher Faulet3e7bc672015-12-07 13:39:08 +0100321
Willy Tarreauc9fa0482018-07-10 17:43:27 +0200322 b_reset(&tmpbuf);
Willy Tarreaubcbd3932018-06-06 07:13:22 +0200323 c_adv(chn, fwd);
Christopher Fauletb61481c2018-12-17 13:17:53 +0100324 ret = http_compression_buffer_init(chn, &zbuf);
Willy Tarreaubcbd3932018-06-06 07:13:22 +0200325 c_rew(chn, fwd);
Christopher Faulet2fb28802015-12-01 10:40:57 +0100326 if (ret < 0) {
327 msg->chn->flags |= CF_WAKE_WRITE;
328 return 0;
329 }
330 }
Christopher Fauletb77c5c22015-12-07 16:48:42 +0100331
332 if (msg->flags & HTTP_MSGF_TE_CHNK) {
Christopher Faulet06ecf3a2016-09-22 15:31:43 +0200333 int block;
Christopher Fauletb77c5c22015-12-07 16:48:42 +0100334
Willy Tarreauc9fa0482018-07-10 17:43:27 +0200335 len = MIN(b_room(&tmpbuf), len);
Christopher Faulet06ecf3a2016-09-22 15:31:43 +0200336
Willy Tarreaubcbd3932018-06-06 07:13:22 +0200337 c_adv(chn, *nxt);
Willy Tarreau7194d3c2018-06-06 16:55:45 +0200338 block = ci_contig_data(chn);
Willy Tarreauc9fa0482018-07-10 17:43:27 +0200339 memcpy(b_tail(&tmpbuf), ci_head(chn), block);
Christopher Faulet06ecf3a2016-09-22 15:31:43 +0200340 if (len > block)
Willy Tarreauc9fa0482018-07-10 17:43:27 +0200341 memcpy(b_tail(&tmpbuf)+block, b_orig(&chn->buf), len-block);
Willy Tarreaubcbd3932018-06-06 07:13:22 +0200342 c_rew(chn, *nxt);
Christopher Faulet06ecf3a2016-09-22 15:31:43 +0200343
Willy Tarreauc9fa0482018-07-10 17:43:27 +0200344 b_add(&tmpbuf, len);
Christopher Fauletb77c5c22015-12-07 16:48:42 +0100345 ret = len;
346 }
347 else {
Willy Tarreaubcbd3932018-06-06 07:13:22 +0200348 c_adv(chn, *nxt);
Willy Tarreauc9fa0482018-07-10 17:43:27 +0200349 ret = http_compression_buffer_add_data(st, &chn->buf, co_data(chn), &zbuf, len);
Willy Tarreaubcbd3932018-06-06 07:13:22 +0200350 c_rew(chn, *nxt);
Christopher Fauletb77c5c22015-12-07 16:48:42 +0100351 if (ret < 0)
352 return ret;
353 }
Christopher Faulet92d36382015-11-05 13:35:03 +0100354
Christopher Faulet2fb28802015-12-01 10:40:57 +0100355 st->initialized = 1;
356 msg->next += ret;
357 msg->chunk_len -= ret;
Christopher Faulet3e7bc672015-12-07 13:39:08 +0100358 *nxt = msg->next;
Christopher Faulet2fb28802015-12-01 10:40:57 +0100359 return 0;
Christopher Faulet92d36382015-11-05 13:35:03 +0100360}
361
362static int
Christopher Faulet2fb28802015-12-01 10:40:57 +0100363comp_http_chunk_trailers(struct stream *s, struct filter *filter,
364 struct http_msg *msg)
Christopher Faulet92d36382015-11-05 13:35:03 +0100365{
366 struct comp_state *st = filter->ctx;
Christopher Faulet92d36382015-11-05 13:35:03 +0100367
Christopher Fauletb77c5c22015-12-07 16:48:42 +0100368 if (!st->initialized) {
369 if (!st->finished) {
Willy Tarreaubcbd3932018-06-06 07:13:22 +0200370 struct channel *chn = msg->chn;
Christopher Fauletb77c5c22015-12-07 16:48:42 +0100371 unsigned int fwd = flt_rsp_fwd(filter) + st->hdrs_len;
Christopher Faulet2fb28802015-12-01 10:40:57 +0100372
Willy Tarreauc9fa0482018-07-10 17:43:27 +0200373 b_reset(&tmpbuf);
Willy Tarreaubcbd3932018-06-06 07:13:22 +0200374 c_adv(chn, fwd);
Christopher Fauletb61481c2018-12-17 13:17:53 +0100375 http_compression_buffer_init(chn, &zbuf);
Willy Tarreaubcbd3932018-06-06 07:13:22 +0200376 c_rew(chn, fwd);
Christopher Fauletb77c5c22015-12-07 16:48:42 +0100377 st->initialized = 1;
378 }
379 }
380 st->tlrs_len = msg->sol;
Christopher Faulet2fb28802015-12-01 10:40:57 +0100381 return 1;
Christopher Faulet92d36382015-11-05 13:35:03 +0100382}
383
Christopher Faulet2fb28802015-12-01 10:40:57 +0100384
Christopher Faulet92d36382015-11-05 13:35:03 +0100385static int
386comp_http_forward_data(struct stream *s, struct filter *filter,
387 struct http_msg *msg, unsigned int len)
388{
389 struct comp_state *st = filter->ctx;
Christopher Faulet2fb28802015-12-01 10:40:57 +0100390 int ret;
Christopher Faulet92d36382015-11-05 13:35:03 +0100391
Christopher Faulet2fb28802015-12-01 10:40:57 +0100392 /* To work, previous filters MUST forward all data */
Christopher Fauletb77c5c22015-12-07 16:48:42 +0100393 if (flt_rsp_fwd(filter) + len != flt_rsp_nxt(filter)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100394 ha_warning("HTTP compression failed: unexpected behavior of previous filters\n");
Christopher Faulet2fb28802015-12-01 10:40:57 +0100395 return -1;
Christopher Faulet92d36382015-11-05 13:35:03 +0100396 }
397
Christopher Faulet2fb28802015-12-01 10:40:57 +0100398 if (!st->initialized) {
Christopher Fauletb77c5c22015-12-07 16:48:42 +0100399 if (!len) {
Joseph Herlant942eea32018-11-15 13:57:22 -0800400 /* Nothing to forward */
Christopher Fauletb77c5c22015-12-07 16:48:42 +0100401 ret = len;
402 }
403 else if (st->hdrs_len > len) {
404 /* Forward part of headers */
405 ret = len;
406 st->hdrs_len -= len;
407 }
408 else if (st->hdrs_len > 0) {
409 /* Forward remaining headers */
410 ret = st->hdrs_len;
411 st->hdrs_len = 0;
412 }
413 else if (msg->msg_state < HTTP_MSG_TRAILERS) {
414 /* Do not forward anything for now. This only happens
415 * with chunk-encoded responses. Waiting data are part
416 * of the chunk envelope (the chunk size or the chunk
417 * CRLF). These data will be skipped during the
418 * compression. */
419 ret = 0;
420 }
421 else {
422 /* Forward trailers data */
423 ret = len;
424 }
Christopher Faulet2fb28802015-12-01 10:40:57 +0100425 return ret;
Christopher Faulet92d36382015-11-05 13:35:03 +0100426 }
427
Christopher Fauletb77c5c22015-12-07 16:48:42 +0100428 if (msg->flags & HTTP_MSGF_TE_CHNK) {
Willy Tarreauc9fa0482018-07-10 17:43:27 +0200429 ret = http_compression_buffer_add_data(st, &tmpbuf, 0,
430 &zbuf, b_data(&tmpbuf));
431 if (ret != b_data(&tmpbuf)) {
Willy Tarreau506a29a2018-07-18 10:07:58 +0200432 ha_warning("HTTP compression failed: Must consume %u bytes but only %d bytes consumed\n",
Willy Tarreauc9fa0482018-07-10 17:43:27 +0200433 (unsigned int)b_data(&tmpbuf), ret);
Christopher Fauletb77c5c22015-12-07 16:48:42 +0100434 return -1;
435 }
436 }
437
438 st->consumed = len - st->hdrs_len - st->tlrs_len;
Willy Tarreaubcbd3932018-06-06 07:13:22 +0200439 c_adv(msg->chn, flt_rsp_fwd(filter) + st->hdrs_len);
Christopher Fauletb61481c2018-12-17 13:17:53 +0100440 ret = http_compression_buffer_end(st, s, msg->chn, &zbuf, msg->msg_state >= HTTP_MSG_TRAILERS);
Willy Tarreaubcbd3932018-06-06 07:13:22 +0200441 c_rew(msg->chn, flt_rsp_fwd(filter) + st->hdrs_len);
Christopher Faulet2fb28802015-12-01 10:40:57 +0100442 if (ret < 0)
443 return ret;
Christopher Faulet92d36382015-11-05 13:35:03 +0100444
Christopher Fauletb77c5c22015-12-07 16:48:42 +0100445 flt_change_forward_size(filter, msg->chn, ret - st->consumed);
446 msg->next += (ret - st->consumed);
447 ret += st->hdrs_len + st->tlrs_len;
448
Christopher Faulet2fb28802015-12-01 10:40:57 +0100449 st->initialized = 0;
Christopher Fauletb77c5c22015-12-07 16:48:42 +0100450 st->finished = (msg->msg_state >= HTTP_MSG_TRAILERS);
451 st->hdrs_len = 0;
452 st->tlrs_len = 0;
Christopher Faulet92d36382015-11-05 13:35:03 +0100453 return ret;
454}
Christopher Faulet3d97c902015-12-09 14:59:38 +0100455
Christopher Fauletd60b3cf2017-06-26 11:47:13 +0200456static int
457comp_http_end(struct stream *s, struct filter *filter,
458 struct http_msg *msg)
459{
460 struct comp_state *st = filter->ctx;
461
462 if (!(msg->chn->flags & CF_ISRESP) || !st || !st->comp_algo)
463 goto end;
464
465 if (strm_fe(s)->mode == PR_MODE_HTTP)
Olivier Houchard43da3432019-03-08 18:50:27 +0100466 _HA_ATOMIC_ADD(&strm_fe(s)->fe_counters.p.http.comp_rsp, 1);
Christopher Fauletd60b3cf2017-06-26 11:47:13 +0200467 if ((s->flags & SF_BE_ASSIGNED) && (s->be->mode == PR_MODE_HTTP))
Olivier Houchard43da3432019-03-08 18:50:27 +0100468 _HA_ATOMIC_ADD(&s->be->be_counters.p.http.comp_rsp, 1);
Christopher Fauletd60b3cf2017-06-26 11:47:13 +0200469 end:
470 return 1;
471}
Christopher Faulet3d97c902015-12-09 14:59:38 +0100472/***********************************************************************/
Christopher Faulet27d93c32018-12-15 22:32:02 +0100473static int
474http_set_comp_reshdr(struct comp_state *st, struct stream *s, struct http_msg *msg)
475{
476 struct http_txn *txn = s->txn;
Tim Duesterhusb229f012019-01-29 16:38:56 +0100477 struct hdr_ctx ctx;
Christopher Faulet27d93c32018-12-15 22:32:02 +0100478
479 /*
480 * Add Content-Encoding header when it's not identity encoding.
481 * RFC 2616 : Identity encoding: This content-coding is used only in the
482 * Accept-Encoding header, and SHOULD NOT be used in the Content-Encoding
483 * header.
484 */
485 if (st->comp_algo->cfg_name_len != 8 || memcmp(st->comp_algo->cfg_name, "identity", 8) != 0) {
486 trash.data = 18;
487 memcpy(trash.area, "Content-Encoding: ", trash.data);
488 memcpy(trash.area + trash.data, st->comp_algo->ua_name,
489 st->comp_algo->ua_name_len);
490 trash.data += st->comp_algo->ua_name_len;
491 trash.area[trash.data] = '\0';
492 if (http_header_add_tail2(msg, &txn->hdr_idx, trash.area, trash.data) < 0)
493 goto error;
494 }
495
496 /* remove Content-Length header */
497 if (msg->flags & HTTP_MSGF_CNT_LEN) {
Christopher Faulet27d93c32018-12-15 22:32:02 +0100498 ctx.idx = 0;
499 while (http_find_header2("Content-Length", 14, ci_head(&s->res), &txn->hdr_idx, &ctx))
500 http_remove_header2(msg, &txn->hdr_idx, &ctx);
501 }
502
503 /* add Transfer-Encoding header */
504 if (!(msg->flags & HTTP_MSGF_TE_CHNK)) {
505 if (http_header_add_tail2(msg, &txn->hdr_idx, "Transfer-Encoding: chunked", 26) < 0)
506 goto error;
507 }
508
Tim Duesterhusb229f012019-01-29 16:38:56 +0100509 ctx.idx = 0;
510 if (http_find_full_header2("ETag", 4, ci_head(&s->res), &txn->hdr_idx, &ctx)) {
511 if (ctx.line[ctx.val] == '"') {
512 /* This a strong ETag. Convert it to a weak one. */
513 trash.data = 8;
514 if (trash.data + ctx.vlen > trash.size)
515 goto error;
516 memcpy(trash.area, "ETag: W/", trash.data);
517 memcpy(trash.area + trash.data, ctx.line + ctx.val, ctx.vlen);
518 trash.data += ctx.vlen;
519 trash.area[trash.data] = '\0';
520 http_remove_header2(msg, &txn->hdr_idx, &ctx);
521 if (http_header_add_tail2(msg, &txn->hdr_idx, trash.area, trash.data) < 0)
522 goto error;
523 }
524 }
Christopher Faulet27d93c32018-12-15 22:32:02 +0100525
Tim Duesterhus721d6862019-06-17 16:10:07 +0200526 if (http_header_add_tail2(msg, &txn->hdr_idx, "Vary: Accept-Encoding", 21) < 0)
527 goto error;
528
Christopher Faulet27d93c32018-12-15 22:32:02 +0100529 return 1;
530
531 error:
532 st->comp_algo->end(&st->comp_ctx);
533 st->comp_algo = NULL;
534 return 0;
535}
536
537static int
538htx_set_comp_reshdr(struct comp_state *st, struct stream *s, struct http_msg *msg)
539{
540 struct htx *htx = htxbuf(&msg->chn->buf);
Tim Duesterhusb229f012019-01-29 16:38:56 +0100541 struct http_hdr_ctx ctx;
Christopher Faulet27d93c32018-12-15 22:32:02 +0100542
543 /*
544 * Add Content-Encoding header when it's not identity encoding.
545 * RFC 2616 : Identity encoding: This content-coding is used only in the
546 * Accept-Encoding header, and SHOULD NOT be used in the Content-Encoding
547 * header.
548 */
549 if (st->comp_algo->cfg_name_len != 8 || memcmp(st->comp_algo->cfg_name, "identity", 8) != 0) {
550 struct ist v = ist2(st->comp_algo->ua_name, st->comp_algo->ua_name_len);
551
552 if (!http_add_header(htx, ist("Content-Encoding"), v))
553 goto error;
554 }
555
556 /* remove Content-Length header */
557 if (msg->flags & HTTP_MSGF_CNT_LEN) {
Christopher Faulet27d93c32018-12-15 22:32:02 +0100558 ctx.blk = NULL;
559 while (http_find_header(htx, ist("Content-Length"), &ctx, 1))
560 http_remove_header(htx, &ctx);
561 }
562
563 /* add "Transfer-Encoding: chunked" header */
564 if (!(msg->flags & HTTP_MSGF_TE_CHNK)) {
565 if (!http_add_header(htx, ist("Transfer-Encoding"), ist("chunked")))
566 goto error;
567 }
568
Tim Duesterhusb229f012019-01-29 16:38:56 +0100569 /* convert "ETag" header to a weak ETag */
570 ctx.blk = NULL;
571 if (http_find_header(htx, ist("ETag"), &ctx, 1)) {
572 if (ctx.value.ptr[0] == '"') {
573 /* This a strong ETag. Convert it to a weak one. */
574 struct ist v = ist2(trash.area, 0);
575 if (istcat(&v, ist("W/"), trash.size) == -1 || istcat(&v, ctx.value, trash.size) == -1)
576 goto error;
577
578 if (!http_replace_header_value(htx, &ctx, v))
579 goto error;
580 }
581 }
582
Tim Duesterhus721d6862019-06-17 16:10:07 +0200583 if (!http_add_header(htx, ist("Vary"), ist("Accept-Encoding")))
584 goto error;
585
Christopher Faulet27d93c32018-12-15 22:32:02 +0100586 return 1;
587
588 error:
589 st->comp_algo->end(&st->comp_ctx);
590 st->comp_algo = NULL;
591 return 0;
592}
593
594static int
595set_compression_response_header(struct comp_state *st, struct stream *s, struct http_msg *msg)
596{
597 if (IS_HTX_STRM(s))
598 return htx_set_comp_reshdr(st, s, msg);
599 else
600 return http_set_comp_reshdr(st, s, msg);
601}
602
Christopher Faulet3d97c902015-12-09 14:59:38 +0100603/*
604 * Selects a compression algorithm depending on the client request.
605 */
Christopher Faulete6902cd2018-11-30 22:29:48 +0100606static int
607http_select_comp_reqhdr(struct comp_state *st, struct stream *s, struct http_msg *msg)
Christopher Faulet3d97c902015-12-09 14:59:38 +0100608{
609 struct http_txn *txn = s->txn;
Olivier Houchard0b662842018-06-29 18:16:31 +0200610 struct channel *req = msg->chn;
Christopher Faulet3d97c902015-12-09 14:59:38 +0100611 struct hdr_ctx ctx;
612 struct comp_algo *comp_algo = NULL;
613 struct comp_algo *comp_algo_back = NULL;
614
615 /* Disable compression for older user agents announcing themselves as "Mozilla/4"
616 * unless they are known good (MSIE 6 with XP SP2, or MSIE 7 and later).
617 * See http://zoompf.com/2012/02/lose-the-wait-http-compression for more details.
618 */
619 ctx.idx = 0;
Olivier Houchard0b662842018-06-29 18:16:31 +0200620 if (http_find_header2("User-Agent", 10, ci_head(req), &txn->hdr_idx, &ctx) &&
Christopher Faulet3d97c902015-12-09 14:59:38 +0100621 ctx.vlen >= 9 &&
622 memcmp(ctx.line + ctx.val, "Mozilla/4", 9) == 0 &&
623 (ctx.vlen < 31 ||
624 memcmp(ctx.line + ctx.val + 25, "MSIE ", 5) != 0 ||
625 ctx.line[ctx.val + 30] < '6' ||
626 (ctx.line[ctx.val + 30] == '6' &&
627 (ctx.vlen < 54 || memcmp(ctx.line + 51, "SV1", 3) != 0)))) {
Christopher Faulet92d36382015-11-05 13:35:03 +0100628 st->comp_algo = NULL;
Christopher Faulet3d97c902015-12-09 14:59:38 +0100629 return 0;
630 }
631
632 /* search for the algo in the backend in priority or the frontend */
Christopher Faulet92d36382015-11-05 13:35:03 +0100633 if ((s->be->comp && (comp_algo_back = s->be->comp->algos)) ||
634 (strm_fe(s)->comp && (comp_algo_back = strm_fe(s)->comp->algos))) {
Christopher Faulet3d97c902015-12-09 14:59:38 +0100635 int best_q = 0;
636
637 ctx.idx = 0;
Olivier Houchard0b662842018-06-29 18:16:31 +0200638 while (http_find_header2("Accept-Encoding", 15, ci_head(req), &txn->hdr_idx, &ctx)) {
Christopher Faulet3d97c902015-12-09 14:59:38 +0100639 const char *qval;
640 int q;
641 int toklen;
642
643 /* try to isolate the token from the optional q-value */
644 toklen = 0;
Willy Tarreau2235b262016-11-05 15:50:20 +0100645 while (toklen < ctx.vlen && HTTP_IS_TOKEN(*(ctx.line + ctx.val + toklen)))
Christopher Faulet3d97c902015-12-09 14:59:38 +0100646 toklen++;
647
648 qval = ctx.line + ctx.val + toklen;
649 while (1) {
Willy Tarreau2235b262016-11-05 15:50:20 +0100650 while (qval < ctx.line + ctx.val + ctx.vlen && HTTP_IS_LWS(*qval))
Christopher Faulet3d97c902015-12-09 14:59:38 +0100651 qval++;
652
653 if (qval >= ctx.line + ctx.val + ctx.vlen || *qval != ';') {
654 qval = NULL;
655 break;
656 }
657 qval++;
658
Willy Tarreau2235b262016-11-05 15:50:20 +0100659 while (qval < ctx.line + ctx.val + ctx.vlen && HTTP_IS_LWS(*qval))
Christopher Faulet3d97c902015-12-09 14:59:38 +0100660 qval++;
661
662 if (qval >= ctx.line + ctx.val + ctx.vlen) {
663 qval = NULL;
664 break;
665 }
666 if (strncmp(qval, "q=", MIN(ctx.line + ctx.val + ctx.vlen - qval, 2)) == 0)
667 break;
668
669 while (qval < ctx.line + ctx.val + ctx.vlen && *qval != ';')
670 qval++;
671 }
672
673 /* here we have qval pointing to the first "q=" attribute or NULL if not found */
Willy Tarreauab813a42018-09-10 18:41:28 +0200674 q = qval ? http_parse_qvalue(qval + 2, NULL) : 1000;
Christopher Faulet3d97c902015-12-09 14:59:38 +0100675
676 if (q <= best_q)
677 continue;
678
679 for (comp_algo = comp_algo_back; comp_algo; comp_algo = comp_algo->next) {
680 if (*(ctx.line + ctx.val) == '*' ||
681 word_match(ctx.line + ctx.val, toklen, comp_algo->ua_name, comp_algo->ua_name_len)) {
Christopher Faulet92d36382015-11-05 13:35:03 +0100682 st->comp_algo = comp_algo;
Christopher Faulet3d97c902015-12-09 14:59:38 +0100683 best_q = q;
684 break;
685 }
686 }
687 }
688 }
689
690 /* remove all occurrences of the header when "compression offload" is set */
Christopher Faulet92d36382015-11-05 13:35:03 +0100691 if (st->comp_algo) {
692 if ((s->be->comp && s->be->comp->offload) ||
693 (strm_fe(s)->comp && strm_fe(s)->comp->offload)) {
Christopher Faulet3d97c902015-12-09 14:59:38 +0100694 http_remove_header2(msg, &txn->hdr_idx, &ctx);
695 ctx.idx = 0;
Olivier Houchard0b662842018-06-29 18:16:31 +0200696 while (http_find_header2("Accept-Encoding", 15, ci_head(req), &txn->hdr_idx, &ctx)) {
Christopher Faulet3d97c902015-12-09 14:59:38 +0100697 http_remove_header2(msg, &txn->hdr_idx, &ctx);
698 }
699 }
Christopher Faulete6902cd2018-11-30 22:29:48 +0100700 return 1;
701 }
702
703 /* identity is implicit does not require headers */
704 if ((s->be->comp && (comp_algo_back = s->be->comp->algos)) ||
705 (strm_fe(s)->comp && (comp_algo_back = strm_fe(s)->comp->algos))) {
706 for (comp_algo = comp_algo_back; comp_algo; comp_algo = comp_algo->next) {
707 if (comp_algo->cfg_name_len == 8 && memcmp(comp_algo->cfg_name, "identity", 8) == 0) {
708 st->comp_algo = comp_algo;
709 return 1;
710 }
711 }
712 }
713
714 st->comp_algo = NULL;
715 return 0;
716}
717
718static int
719htx_select_comp_reqhdr(struct comp_state *st, struct stream *s, struct http_msg *msg)
720{
Christopher Faulet27ba2dc2018-12-05 11:53:24 +0100721 struct htx *htx = htxbuf(&msg->chn->buf);
Christopher Faulete6902cd2018-11-30 22:29:48 +0100722 struct http_hdr_ctx ctx;
723 struct comp_algo *comp_algo = NULL;
724 struct comp_algo *comp_algo_back = NULL;
725
726 /* Disable compression for older user agents announcing themselves as "Mozilla/4"
727 * unless they are known good (MSIE 6 with XP SP2, or MSIE 7 and later).
728 * See http://zoompf.com/2012/02/lose-the-wait-http-compression for more details.
729 */
730 ctx.blk = NULL;
731 if (http_find_header(htx, ist("User-Agent"), &ctx, 1) &&
732 ctx.value.len >= 9 &&
733 memcmp(ctx.value.ptr, "Mozilla/4", 9) == 0 &&
734 (ctx.value.len < 31 ||
735 memcmp(ctx.value.ptr + 25, "MSIE ", 5) != 0 ||
736 *(ctx.value.ptr + 30) < '6' ||
737 (*(ctx.value.ptr + 30) == '6' &&
738 (ctx.value.len < 54 || memcmp(ctx.value.ptr + 51, "SV1", 3) != 0)))) {
739 st->comp_algo = NULL;
740 return 0;
741 }
742
743 /* search for the algo in the backend in priority or the frontend */
744 if ((s->be->comp && (comp_algo_back = s->be->comp->algos)) ||
745 (strm_fe(s)->comp && (comp_algo_back = strm_fe(s)->comp->algos))) {
746 int best_q = 0;
747
748 ctx.blk = NULL;
749 while (http_find_header(htx, ist("Accept-Encoding"), &ctx, 0)) {
750 const char *qval;
751 int q;
752 int toklen;
753
754 /* try to isolate the token from the optional q-value */
755 toklen = 0;
756 while (toklen < ctx.value.len && HTTP_IS_TOKEN(*(ctx.value.ptr + toklen)))
757 toklen++;
758
759 qval = ctx.value.ptr + toklen;
760 while (1) {
761 while (qval < ctx.value.ptr + ctx.value.len && HTTP_IS_LWS(*qval))
762 qval++;
763
764 if (qval >= ctx.value.ptr + ctx.value.len || *qval != ';') {
765 qval = NULL;
766 break;
767 }
768 qval++;
769
770 while (qval < ctx.value.ptr + ctx.value.len && HTTP_IS_LWS(*qval))
771 qval++;
772
773 if (qval >= ctx.value.ptr + ctx.value.len) {
774 qval = NULL;
775 break;
776 }
777 if (strncmp(qval, "q=", MIN(ctx.value.ptr + ctx.value.len - qval, 2)) == 0)
778 break;
779
780 while (qval < ctx.value.ptr + ctx.value.len && *qval != ';')
781 qval++;
782 }
783
784 /* here we have qval pointing to the first "q=" attribute or NULL if not found */
785 q = qval ? http_parse_qvalue(qval + 2, NULL) : 1000;
786
787 if (q <= best_q)
788 continue;
789
790 for (comp_algo = comp_algo_back; comp_algo; comp_algo = comp_algo->next) {
791 if (*(ctx.value.ptr) == '*' ||
792 word_match(ctx.value.ptr, toklen, comp_algo->ua_name, comp_algo->ua_name_len)) {
793 st->comp_algo = comp_algo;
794 best_q = q;
795 break;
796 }
797 }
798 }
799 }
800
801 /* remove all occurrences of the header when "compression offload" is set */
802 if (st->comp_algo) {
803 if ((s->be->comp && s->be->comp->offload) ||
804 (strm_fe(s)->comp && strm_fe(s)->comp->offload)) {
805 http_remove_header(htx, &ctx);
806 ctx.blk = NULL;
807 while (http_find_header(htx, ist("Accept-Encoding"), &ctx, 1))
808 http_remove_header(htx, &ctx);
809 }
Christopher Faulet3d97c902015-12-09 14:59:38 +0100810 return 1;
811 }
812
813 /* identity is implicit does not require headers */
Christopher Faulet92d36382015-11-05 13:35:03 +0100814 if ((s->be->comp && (comp_algo_back = s->be->comp->algos)) ||
815 (strm_fe(s)->comp && (comp_algo_back = strm_fe(s)->comp->algos))) {
Christopher Faulet3d97c902015-12-09 14:59:38 +0100816 for (comp_algo = comp_algo_back; comp_algo; comp_algo = comp_algo->next) {
817 if (comp_algo->cfg_name_len == 8 && memcmp(comp_algo->cfg_name, "identity", 8) == 0) {
Christopher Faulet92d36382015-11-05 13:35:03 +0100818 st->comp_algo = comp_algo;
Christopher Faulet3d97c902015-12-09 14:59:38 +0100819 return 1;
820 }
821 }
822 }
823
Christopher Faulet92d36382015-11-05 13:35:03 +0100824 st->comp_algo = NULL;
Christopher Faulet3d97c902015-12-09 14:59:38 +0100825 return 0;
826}
827
Christopher Faulete6902cd2018-11-30 22:29:48 +0100828static int
829select_compression_request_header(struct comp_state *st, struct stream *s,
830 struct http_msg *msg)
831{
832 if (IS_HTX_STRM(s))
833 return htx_select_comp_reqhdr(st, s, msg);
834 else
835 return http_select_comp_reqhdr(st, s, msg);
836}
Christopher Faulet92d36382015-11-05 13:35:03 +0100837
Christopher Faulet3d97c902015-12-09 14:59:38 +0100838/*
839 * Selects a comression algorithm depending of the server response.
840 */
Christopher Faulet92d36382015-11-05 13:35:03 +0100841static int
Christopher Faulete6902cd2018-11-30 22:29:48 +0100842http_select_comp_reshdr(struct comp_state *st, struct stream *s, struct http_msg *msg)
Christopher Faulet3d97c902015-12-09 14:59:38 +0100843{
844 struct http_txn *txn = s->txn;
Olivier Houchard0b662842018-06-29 18:16:31 +0200845 struct channel *c = msg->chn;
Christopher Faulet3d97c902015-12-09 14:59:38 +0100846 struct hdr_ctx ctx;
847 struct comp_type *comp_type;
848
849 /* no common compression algorithm was found in request header */
Christopher Faulet92d36382015-11-05 13:35:03 +0100850 if (st->comp_algo == NULL)
Christopher Faulet3d97c902015-12-09 14:59:38 +0100851 goto fail;
852
Christopher Faulet1d3613a2019-01-07 14:41:59 +0100853 /* compression already in progress */
854 if (msg->flags & HTTP_MSGF_COMPRESSING)
855 goto fail;
856
Christopher Faulet3d97c902015-12-09 14:59:38 +0100857 /* HTTP < 1.1 should not be compressed */
858 if (!(msg->flags & HTTP_MSGF_VER_11) || !(txn->req.flags & HTTP_MSGF_VER_11))
859 goto fail;
860
Christopher Faulet92d36382015-11-05 13:35:03 +0100861 if (txn->meth == HTTP_METH_HEAD)
862 goto fail;
863
Christopher Faulet3d97c902015-12-09 14:59:38 +0100864 /* compress 200,201,202,203 responses only */
865 if ((txn->status != 200) &&
866 (txn->status != 201) &&
867 (txn->status != 202) &&
868 (txn->status != 203))
869 goto fail;
870
871
872 /* Content-Length is null */
873 if (!(msg->flags & HTTP_MSGF_TE_CHNK) && msg->body_len == 0)
874 goto fail;
875
876 /* content is already compressed */
877 ctx.idx = 0;
Olivier Houchard0b662842018-06-29 18:16:31 +0200878 if (http_find_header2("Content-Encoding", 16, ci_head(c), &txn->hdr_idx, &ctx))
Christopher Faulet3d97c902015-12-09 14:59:38 +0100879 goto fail;
880
881 /* no compression when Cache-Control: no-transform is present in the message */
882 ctx.idx = 0;
Olivier Houchard0b662842018-06-29 18:16:31 +0200883 while (http_find_header2("Cache-Control", 13, ci_head(c), &txn->hdr_idx, &ctx)) {
Christopher Faulet3d97c902015-12-09 14:59:38 +0100884 if (word_match(ctx.line + ctx.val, ctx.vlen, "no-transform", 12))
885 goto fail;
886 }
887
Tim Duesterhusb229f012019-01-29 16:38:56 +0100888 /* no compression when ETag is malformed */
889 ctx.idx = 0;
890 if (http_find_full_header2("ETag", 4, ci_head(c), &txn->hdr_idx, &ctx)) {
891 if (!(((ctx.vlen >= 4 && memcmp(ctx.line + ctx.val, "W/\"", 3) == 0) || /* Either a weak ETag */
892 (ctx.vlen >= 2 && ctx.line[ctx.val] == '"')) && /* or strong ETag */
893 ctx.line[ctx.val + ctx.vlen - 1] == '"')) {
894 goto fail;
895 }
896 }
897 /* no compression when multiple ETags are present
898 * Note: Do not reset ctx.idx!
899 */
900 if (http_find_full_header2("ETag", 4, ci_head(c), &txn->hdr_idx, &ctx))
901 goto fail;
902
Christopher Faulet3d97c902015-12-09 14:59:38 +0100903 comp_type = NULL;
904
905 /* we don't want to compress multipart content-types, nor content-types that are
906 * not listed in the "compression type" directive if any. If no content-type was
907 * found but configuration requires one, we don't compress either. Backend has
908 * the priority.
909 */
910 ctx.idx = 0;
Olivier Houchard0b662842018-06-29 18:16:31 +0200911 if (http_find_header2("Content-Type", 12, ci_head(c), &txn->hdr_idx, &ctx)) {
Christopher Faulet3d97c902015-12-09 14:59:38 +0100912 if (ctx.vlen >= 9 && strncasecmp("multipart", ctx.line+ctx.val, 9) == 0)
913 goto fail;
914
915 if ((s->be->comp && (comp_type = s->be->comp->types)) ||
916 (strm_fe(s)->comp && (comp_type = strm_fe(s)->comp->types))) {
917 for (; comp_type; comp_type = comp_type->next) {
918 if (ctx.vlen >= comp_type->name_len &&
919 strncasecmp(ctx.line+ctx.val, comp_type->name, comp_type->name_len) == 0)
920 /* this Content-Type should be compressed */
921 break;
922 }
923 /* this Content-Type should not be compressed */
924 if (comp_type == NULL)
925 goto fail;
926 }
927 }
928 else { /* no content-type header */
Christopher Faulet92d36382015-11-05 13:35:03 +0100929 if ((s->be->comp && s->be->comp->types) ||
930 (strm_fe(s)->comp && strm_fe(s)->comp->types))
Christopher Faulet3d97c902015-12-09 14:59:38 +0100931 goto fail; /* a content-type was required */
932 }
933
934 /* limit compression rate */
935 if (global.comp_rate_lim > 0)
936 if (read_freq_ctr(&global.comp_bps_in) > global.comp_rate_lim)
937 goto fail;
938
939 /* limit cpu usage */
Willy Tarreau81036f22019-05-20 19:24:50 +0200940 if (ti->idle_pct < compress_min_idle)
Christopher Faulet3d97c902015-12-09 14:59:38 +0100941 goto fail;
942
943 /* initialize compression */
Christopher Faulet92d36382015-11-05 13:35:03 +0100944 if (st->comp_algo->init(&st->comp_ctx, global.tune.comp_maxlevel) < 0)
Christopher Faulet3d97c902015-12-09 14:59:38 +0100945 goto fail;
Christopher Faulet92d36382015-11-05 13:35:03 +0100946 msg->flags |= HTTP_MSGF_COMPRESSING;
Christopher Faulet3d97c902015-12-09 14:59:38 +0100947 return 1;
948
949fail:
Christopher Faulet92d36382015-11-05 13:35:03 +0100950 st->comp_algo = NULL;
Christopher Faulet3d97c902015-12-09 14:59:38 +0100951 return 0;
952}
953
Christopher Faulete6902cd2018-11-30 22:29:48 +0100954static int
955htx_select_comp_reshdr(struct comp_state *st, struct stream *s, struct http_msg *msg)
956{
Christopher Faulet27ba2dc2018-12-05 11:53:24 +0100957 struct htx *htx = htxbuf(&msg->chn->buf);
Christopher Faulete6902cd2018-11-30 22:29:48 +0100958 struct http_txn *txn = s->txn;
959 struct http_hdr_ctx ctx;
960 struct comp_type *comp_type;
961
962 /* no common compression algorithm was found in request header */
963 if (st->comp_algo == NULL)
964 goto fail;
965
Christopher Faulet1d3613a2019-01-07 14:41:59 +0100966 /* compression already in progress */
967 if (msg->flags & HTTP_MSGF_COMPRESSING)
968 goto fail;
969
Christopher Faulete6902cd2018-11-30 22:29:48 +0100970 /* HTTP < 1.1 should not be compressed */
971 if (!(msg->flags & HTTP_MSGF_VER_11) || !(txn->req.flags & HTTP_MSGF_VER_11))
972 goto fail;
973
974 if (txn->meth == HTTP_METH_HEAD)
975 goto fail;
976
977 /* compress 200,201,202,203 responses only */
978 if ((txn->status != 200) &&
979 (txn->status != 201) &&
980 (txn->status != 202) &&
981 (txn->status != 203))
982 goto fail;
983
Christopher Fauletc963eb22018-12-21 14:53:54 +0100984 if (!(msg->flags & HTTP_MSGF_XFER_LEN) || msg->flags & HTTP_MSGF_BODYLESS)
Christopher Faulete6902cd2018-11-30 22:29:48 +0100985 goto fail;
986
987 /* content is already compressed */
988 ctx.blk = NULL;
989 if (http_find_header(htx, ist("Content-Encoding"), &ctx, 1))
990 goto fail;
991
992 /* no compression when Cache-Control: no-transform is present in the message */
993 ctx.blk = NULL;
994 while (http_find_header(htx, ist("Cache-Control"), &ctx, 0)) {
995 if (word_match(ctx.value.ptr, ctx.value.len, "no-transform", 12))
996 goto fail;
997 }
998
Tim Duesterhusb229f012019-01-29 16:38:56 +0100999 /* no compression when ETag is malformed */
1000 ctx.blk = NULL;
1001 if (http_find_header(htx, ist("ETag"), &ctx, 1)) {
1002 if (!(((ctx.value.len >= 4 && memcmp(ctx.value.ptr, "W/\"", 3) == 0) || /* Either a weak ETag */
1003 (ctx.value.len >= 2 && ctx.value.ptr[0] == '"')) && /* or strong ETag */
1004 ctx.value.ptr[ctx.value.len - 1] == '"')) {
1005 goto fail;
1006 }
1007 }
1008 /* no compression when multiple ETags are present
1009 * Note: Do not reset ctx.blk!
1010 */
1011 if (http_find_header(htx, ist("ETag"), &ctx, 1))
1012 goto fail;
1013
Christopher Faulete6902cd2018-11-30 22:29:48 +01001014 comp_type = NULL;
1015
1016 /* we don't want to compress multipart content-types, nor content-types that are
1017 * not listed in the "compression type" directive if any. If no content-type was
1018 * found but configuration requires one, we don't compress either. Backend has
1019 * the priority.
1020 */
1021 ctx.blk = NULL;
1022 if (http_find_header(htx, ist("Content-Type"), &ctx, 1)) {
1023 if (ctx.value.len >= 9 && strncasecmp("multipart", ctx.value.ptr, 9) == 0)
1024 goto fail;
1025
1026 if ((s->be->comp && (comp_type = s->be->comp->types)) ||
1027 (strm_fe(s)->comp && (comp_type = strm_fe(s)->comp->types))) {
1028 for (; comp_type; comp_type = comp_type->next) {
1029 if (ctx.value.len >= comp_type->name_len &&
1030 strncasecmp(ctx.value.ptr, comp_type->name, comp_type->name_len) == 0)
1031 /* this Content-Type should be compressed */
1032 break;
1033 }
1034 /* this Content-Type should not be compressed */
1035 if (comp_type == NULL)
1036 goto fail;
1037 }
1038 }
1039 else { /* no content-type header */
1040 if ((s->be->comp && s->be->comp->types) ||
1041 (strm_fe(s)->comp && strm_fe(s)->comp->types))
1042 goto fail; /* a content-type was required */
1043 }
1044
1045 /* limit compression rate */
1046 if (global.comp_rate_lim > 0)
1047 if (read_freq_ctr(&global.comp_bps_in) > global.comp_rate_lim)
1048 goto fail;
1049
1050 /* limit cpu usage */
Willy Tarreau81036f22019-05-20 19:24:50 +02001051 if (ti->idle_pct < compress_min_idle)
Christopher Faulete6902cd2018-11-30 22:29:48 +01001052 goto fail;
1053
1054 /* initialize compression */
1055 if (st->comp_algo->init(&st->comp_ctx, global.tune.comp_maxlevel) < 0)
1056 goto fail;
Christopher Faulete6902cd2018-11-30 22:29:48 +01001057 msg->flags |= HTTP_MSGF_COMPRESSING;
1058 return 1;
1059
1060 deinit_comp_ctx:
1061 st->comp_algo->end(&st->comp_ctx);
1062 fail:
1063 st->comp_algo = NULL;
1064 return 0;
1065}
1066
1067static int
1068select_compression_response_header(struct comp_state *st, struct stream *s, struct http_msg *msg)
1069{
1070 if (IS_HTX_STRM(s))
1071 return htx_select_comp_reshdr(st, s, msg);
1072 else
1073 return http_select_comp_reshdr(st, s, msg);
1074}
Christopher Faulet3d97c902015-12-09 14:59:38 +01001075/***********************************************************************/
1076/* emit the chunksize followed by a CRLF on the output and return the number of
1077 * bytes written. It goes backwards and starts with the byte before <end>. It
1078 * returns the number of bytes written which will not exceed 10 (8 digits, CR,
1079 * and LF). The caller is responsible for ensuring there is enough room left in
1080 * the output buffer for the string.
1081 */
1082static int
1083http_emit_chunk_size(char *end, unsigned int chksz)
1084{
1085 char *beg = end;
1086
1087 *--beg = '\n';
1088 *--beg = '\r';
1089 do {
1090 *--beg = hextab[chksz & 0xF];
1091 } while (chksz >>= 4);
1092 return end - beg;
1093}
1094
1095/*
1096 * Init HTTP compression
1097 */
Christopher Faulet92d36382015-11-05 13:35:03 +01001098static int
Christopher Fauletb61481c2018-12-17 13:17:53 +01001099http_compression_buffer_init(struct channel *inc, struct buffer *out)
Christopher Faulet3d97c902015-12-09 14:59:38 +01001100{
1101 /* output stream requires at least 10 bytes for the gzip header, plus
1102 * at least 8 bytes for the gzip trailer (crc+len), plus a possible
1103 * plus at most 5 bytes per 32kB block and 2 bytes to close the stream.
1104 */
Olivier Houchard0b662842018-06-29 18:16:31 +02001105 if (c_room(inc) < 20 + 5 * ((ci_data(inc) + 32767) >> 15))
Christopher Faulet3d97c902015-12-09 14:59:38 +01001106 return -1;
1107
1108 /* prepare an empty output buffer in which we reserve enough room for
1109 * copying the output bytes from <in>, plus 10 extra bytes to write
1110 * the chunk size. We don't copy the bytes yet so that if we have to
1111 * cancel the operation later, it's cheap.
1112 */
1113 b_reset(out);
Christopher Fauletb61481c2018-12-17 13:17:53 +01001114 out->head += co_data(inc) + 10;
Christopher Faulet3d97c902015-12-09 14:59:38 +01001115 return 0;
1116}
1117
Christopher Faulete6902cd2018-11-30 22:29:48 +01001118static int
1119htx_compression_buffer_init(struct htx *htx, struct buffer *out)
1120{
1121 /* output stream requires at least 10 bytes for the gzip header, plus
1122 * at least 8 bytes for the gzip trailer (crc+len), plus a possible
1123 * plus at most 5 bytes per 32kB block and 2 bytes to close the stream.
1124 */
1125 if (htx_free_space(htx) < 20 + 5 * ((htx->data + 32767) >> 15))
1126 return -1;
1127 b_reset(out);
1128 return 0;
1129}
1130
Christopher Faulet3d97c902015-12-09 14:59:38 +01001131/*
1132 * Add data to compress
1133 */
Christopher Faulet92d36382015-11-05 13:35:03 +01001134static int
1135http_compression_buffer_add_data(struct comp_state *st, struct buffer *in,
Willy Tarreaud54a8ce2018-06-29 18:42:02 +02001136 int in_out, struct buffer *out, int sz)
Christopher Faulet3d97c902015-12-09 14:59:38 +01001137{
Christopher Faulet3d97c902015-12-09 14:59:38 +01001138 int consumed_data = 0;
1139 int data_process_len;
1140 int block1, block2;
1141
Christopher Faulet92d36382015-11-05 13:35:03 +01001142 if (!sz)
Christopher Faulet3e7bc672015-12-07 13:39:08 +01001143 goto end;
Christopher Faulet3d97c902015-12-09 14:59:38 +01001144
Christopher Faulet92d36382015-11-05 13:35:03 +01001145 /* select the smallest size between the announced chunk size, the input
Christopher Faulet3d97c902015-12-09 14:59:38 +01001146 * data, and the available output buffer size. The compressors are
Christopher Faulet92d36382015-11-05 13:35:03 +01001147 * assumed to be able to process all the bytes we pass to them at
1148 * once. */
Willy Tarreaueac52592018-06-15 13:59:36 +02001149 data_process_len = MIN(b_room(out), sz);
Christopher Faulet92d36382015-11-05 13:35:03 +01001150
Christopher Faulet3d97c902015-12-09 14:59:38 +01001151 block1 = data_process_len;
Willy Tarreaud54a8ce2018-06-29 18:42:02 +02001152 if (block1 > b_contig_data(in, in_out))
1153 block1 = b_contig_data(in, in_out);
Christopher Faulet3d97c902015-12-09 14:59:38 +01001154 block2 = data_process_len - block1;
1155
1156 /* compressors return < 0 upon error or the amount of bytes read */
Christopher Faulet96667202018-12-17 12:02:57 +01001157 consumed_data = st->comp_algo->add_data(st->comp_ctx, b_peek(in, in_out), block1, out);
Christopher Faulet3e7bc672015-12-07 13:39:08 +01001158 if (consumed_data != block1 || !block2)
1159 goto end;
Christopher Faulet96667202018-12-17 12:02:57 +01001160 consumed_data = st->comp_algo->add_data(st->comp_ctx, b_orig(in), block2, out);
Christopher Faulet3e7bc672015-12-07 13:39:08 +01001161 if (consumed_data < 0)
1162 goto end;
1163 consumed_data += block1;
1164
1165 end:
Christopher Faulet3d97c902015-12-09 14:59:38 +01001166 return consumed_data;
1167}
1168
Christopher Faulete6902cd2018-11-30 22:29:48 +01001169static int
1170htx_compression_buffer_add_data(struct comp_state *st, const char *data, size_t len,
1171 struct buffer *out)
1172{
1173 return st->comp_algo->add_data(st->comp_ctx, data, len, out);
1174}
1175
Christopher Faulet3d97c902015-12-09 14:59:38 +01001176/*
1177 * Flush data in process, and write the header and footer of the chunk. Upon
1178 * success, in and out buffers are swapped to avoid a copy.
1179 */
Christopher Faulet92d36382015-11-05 13:35:03 +01001180static int
1181http_compression_buffer_end(struct comp_state *st, struct stream *s,
Willy Tarreauc9fa0482018-07-10 17:43:27 +02001182 struct channel *chn, struct buffer *out,
Christopher Fauletb61481c2018-12-17 13:17:53 +01001183 int end)
Christopher Faulet3d97c902015-12-09 14:59:38 +01001184{
Willy Tarreauc9fa0482018-07-10 17:43:27 +02001185 struct buffer tmp_buf;
Christopher Faulet3d97c902015-12-09 14:59:38 +01001186 char *tail;
Christopher Faulet92d36382015-11-05 13:35:03 +01001187 int to_forward, left;
Christopher Faulet3d97c902015-12-09 14:59:38 +01001188
1189#if defined(USE_SLZ) || defined(USE_ZLIB)
1190 int ret;
1191
1192 /* flush data here */
Christopher Faulet3d97c902015-12-09 14:59:38 +01001193 if (end)
Willy Tarreauc9fa0482018-07-10 17:43:27 +02001194 ret = st->comp_algo->finish(st->comp_ctx, out); /* end of data */
Christopher Faulet3d97c902015-12-09 14:59:38 +01001195 else
Willy Tarreauc9fa0482018-07-10 17:43:27 +02001196 ret = st->comp_algo->flush(st->comp_ctx, out); /* end of buffer */
Christopher Faulet3d97c902015-12-09 14:59:38 +01001197
1198 if (ret < 0)
1199 return -1; /* flush failed */
1200
1201#endif /* USE_ZLIB */
Willy Tarreauc9fa0482018-07-10 17:43:27 +02001202 if (b_data(out) == 0) {
Christopher Faulet3d97c902015-12-09 14:59:38 +01001203 /* No data were appended, let's drop the output buffer and
1204 * keep the input buffer unchanged.
1205 */
1206 return 0;
1207 }
1208
Willy Tarreauc9fa0482018-07-10 17:43:27 +02001209 /* OK so at this stage, we have an output buffer <out> looking like this :
Christopher Faulet3d97c902015-12-09 14:59:38 +01001210 *
1211 * <-- o --> <------ i ----->
1212 * +---------+---+------------+-----------+
1213 * | out | c | comp_in | empty |
1214 * +---------+---+------------+-----------+
1215 * data p size
1216 *
Willy Tarreaud54a8ce2018-06-29 18:42:02 +02001217 * <out> is the room reserved to copy the channel output. It starts at
Willy Tarreauc9fa0482018-07-10 17:43:27 +02001218 * out->area and has not yet been filled. <c> is the room reserved to
Willy Tarreaud54a8ce2018-06-29 18:42:02 +02001219 * write the chunk size (10 bytes). <comp_in> is the compressed
1220 * equivalent of the data part of ib->len. <empty> is the amount of
1221 * empty bytes at the end of the buffer, into which we may have to
1222 * copy the remaining bytes from ib->len after the data
1223 * (chunk size, trailers, ...).
Christopher Faulet3d97c902015-12-09 14:59:38 +01001224 */
1225
Joseph Herlant942eea32018-11-15 13:57:22 -08001226 /* Write real size at the beginning of the chunk, no need of wrapping.
Willy Tarreauc9fa0482018-07-10 17:43:27 +02001227 * We write the chunk using a dynamic length and adjust out->p and out->i
Christopher Faulet3d97c902015-12-09 14:59:38 +01001228 * accordingly afterwards. That will move <out> away from <data>.
1229 */
Willy Tarreauc9fa0482018-07-10 17:43:27 +02001230 left = http_emit_chunk_size(b_head(out), b_data(out));
1231 b_add(out, left);
Christopher Fauletb61481c2018-12-17 13:17:53 +01001232 out->head -= co_data(chn) + (left);
Willy Tarreauc9fa0482018-07-10 17:43:27 +02001233 /* Copy previous data from chn into out */
Willy Tarreaud54a8ce2018-06-29 18:42:02 +02001234 if (co_data(chn) > 0) {
Willy Tarreauc9fa0482018-07-10 17:43:27 +02001235 left = b_contig_data(&chn->buf, 0);
Christopher Fauletb61481c2018-12-17 13:17:53 +01001236 if (left > co_data(chn))
1237 left = co_data(chn);
Christopher Faulet3d97c902015-12-09 14:59:38 +01001238
Willy Tarreauc9fa0482018-07-10 17:43:27 +02001239 memcpy(b_head(out), co_head(chn), left);
1240 b_add(out, left);
Willy Tarreaud54a8ce2018-06-29 18:42:02 +02001241 if (co_data(chn) - left) {/* second part of the buffer */
Willy Tarreauc9fa0482018-07-10 17:43:27 +02001242 memcpy(b_head(out) + left, b_orig(&chn->buf), co_data(chn) - left);
1243 b_add(out, co_data(chn) - left);
Willy Tarreaud54a8ce2018-06-29 18:42:02 +02001244 }
Christopher Faulet3d97c902015-12-09 14:59:38 +01001245 }
1246
1247 /* chunked encoding requires CRLF after data */
Willy Tarreauc9fa0482018-07-10 17:43:27 +02001248 tail = b_tail(out);
Christopher Faulet3d97c902015-12-09 14:59:38 +01001249 *tail++ = '\r';
1250 *tail++ = '\n';
1251
Christopher Faulet2fb28802015-12-01 10:40:57 +01001252 /* At the end of data, we must write the empty chunk 0<CRLF>,
1253 * and terminate the trailers section with a last <CRLF>. If
1254 * we're forwarding a chunked-encoded response, we'll have a
1255 * trailers section after the empty chunk which needs to be
1256 * forwarded and which will provide the last CRLF. Otherwise
1257 * we write it ourselves.
1258 */
1259 if (end) {
1260 struct http_msg *msg = &s->txn->rsp;
1261
1262 memcpy(tail, "0\r\n", 3);
1263 tail += 3;
Christopher Fauletb77c5c22015-12-07 16:48:42 +01001264 if (!(msg->flags & HTTP_MSGF_TE_CHNK)) {
Christopher Faulet2fb28802015-12-01 10:40:57 +01001265 memcpy(tail, "\r\n", 2);
1266 tail += 2;
1267 }
1268 }
1269
Willy Tarreauc9fa0482018-07-10 17:43:27 +02001270 b_add(out, tail - b_tail(out));
Christopher Fauletb61481c2018-12-17 13:17:53 +01001271 to_forward = b_data(out) - co_data(chn);
Christopher Faulet3d97c902015-12-09 14:59:38 +01001272
1273 /* update input rate */
Christopher Faulet92d36382015-11-05 13:35:03 +01001274 if (st->comp_ctx && st->comp_ctx->cur_lvl > 0) {
Christopher Faulet2fb28802015-12-01 10:40:57 +01001275 update_freq_ctr(&global.comp_bps_in, st->consumed);
Olivier Houchard43da3432019-03-08 18:50:27 +01001276 _HA_ATOMIC_ADD(&strm_fe(s)->fe_counters.comp_in, st->consumed);
1277 _HA_ATOMIC_ADD(&s->be->be_counters.comp_in, st->consumed);
Christopher Faulet3d97c902015-12-09 14:59:38 +01001278 } else {
Olivier Houchard43da3432019-03-08 18:50:27 +01001279 _HA_ATOMIC_ADD(&strm_fe(s)->fe_counters.comp_byp, st->consumed);
1280 _HA_ATOMIC_ADD(&s->be->be_counters.comp_byp, st->consumed);
Christopher Faulet3d97c902015-12-09 14:59:38 +01001281 }
1282
1283 /* copy the remaining data in the tmp buffer. */
Willy Tarreaubcbd3932018-06-06 07:13:22 +02001284 c_adv(chn, st->consumed);
Willy Tarreauc9fa0482018-07-10 17:43:27 +02001285 if (b_data(&chn->buf) - co_data(chn) > 0) {
Willy Tarreau7194d3c2018-06-06 16:55:45 +02001286 left = ci_contig_data(chn);
Willy Tarreauc9fa0482018-07-10 17:43:27 +02001287 memcpy(b_tail(out), ci_head(chn), left);
1288 b_add(out, left);
1289 if (b_data(&chn->buf) - (co_data(chn) + left)) {
1290 memcpy(b_tail(out), b_orig(&chn->buf), b_data(&chn->buf) - left);
1291 b_add(out, b_data(&chn->buf) - left);
Christopher Faulet3d97c902015-12-09 14:59:38 +01001292 }
1293 }
Christopher Fauletb61481c2018-12-17 13:17:53 +01001294 c_rew(chn, st->consumed);
1295
Christopher Faulet3d97c902015-12-09 14:59:38 +01001296 /* swap the buffers */
Willy Tarreauc9fa0482018-07-10 17:43:27 +02001297 tmp_buf = chn->buf;
1298 chn->buf = *out;
1299 *out = tmp_buf;
1300
Christopher Faulet92d36382015-11-05 13:35:03 +01001301 if (st->comp_ctx && st->comp_ctx->cur_lvl > 0) {
Christopher Faulet3d97c902015-12-09 14:59:38 +01001302 update_freq_ctr(&global.comp_bps_out, to_forward);
Olivier Houchard43da3432019-03-08 18:50:27 +01001303 _HA_ATOMIC_ADD(&strm_fe(s)->fe_counters.comp_out, to_forward);
1304 _HA_ATOMIC_ADD(&s->be->be_counters.comp_out, to_forward);
Christopher Faulet3d97c902015-12-09 14:59:38 +01001305 }
1306
Christopher Faulet3d97c902015-12-09 14:59:38 +01001307 return to_forward;
1308}
1309
Christopher Faulete6902cd2018-11-30 22:29:48 +01001310static int
1311htx_compression_buffer_end(struct comp_state *st, struct buffer *out, int end)
1312{
1313 if (end)
1314 return st->comp_algo->finish(st->comp_ctx, out);
1315 else
1316 return st->comp_algo->flush(st->comp_ctx, out);
1317}
1318
Christopher Faulet3d97c902015-12-09 14:59:38 +01001319
1320/***********************************************************************/
Christopher Faulet92d36382015-11-05 13:35:03 +01001321struct flt_ops comp_ops = {
Christopher Faulete6902cd2018-11-30 22:29:48 +01001322 .init = comp_flt_init,
Christopher Faulet8ca3b4b2017-07-25 11:07:15 +02001323 .init_per_thread = comp_flt_init_per_thread,
1324 .deinit_per_thread = comp_flt_deinit_per_thread,
Christopher Faulet92d36382015-11-05 13:35:03 +01001325
1326 .channel_start_analyze = comp_start_analyze,
Christopher Faulet92d36382015-11-05 13:35:03 +01001327 .channel_end_analyze = comp_end_analyze,
Christopher Faulet3dc860d2017-09-15 11:39:36 +02001328 .channel_post_analyze = comp_http_post_analyze,
Christopher Faulet92d36382015-11-05 13:35:03 +01001329
Christopher Faulet1339d742016-05-11 16:48:33 +02001330 .http_headers = comp_http_headers,
Christopher Faulete6902cd2018-11-30 22:29:48 +01001331 .http_payload = comp_http_payload,
1332 .http_end = comp_http_end,
1333
Christopher Faulet309c6412015-12-02 09:57:32 +01001334 .http_data = comp_http_data,
1335 .http_chunk_trailers = comp_http_chunk_trailers,
1336 .http_forward_data = comp_http_forward_data,
Christopher Faulet92d36382015-11-05 13:35:03 +01001337};
1338
Christopher Faulet3d97c902015-12-09 14:59:38 +01001339static int
1340parse_compression_options(char **args, int section, struct proxy *proxy,
1341 struct proxy *defpx, const char *file, int line,
1342 char **err)
1343{
Christopher Faulet92d36382015-11-05 13:35:03 +01001344 struct comp *comp;
Christopher Faulet3d97c902015-12-09 14:59:38 +01001345
1346 if (proxy->comp == NULL) {
Vincent Bernat02779b62016-04-03 13:48:43 +02001347 comp = calloc(1, sizeof(*comp));
Christopher Faulet3d97c902015-12-09 14:59:38 +01001348 proxy->comp = comp;
1349 }
1350 else
1351 comp = proxy->comp;
1352
1353 if (!strcmp(args[1], "algo")) {
1354 struct comp_ctx *ctx;
1355 int cur_arg = 2;
1356
1357 if (!*args[cur_arg]) {
1358 memprintf(err, "parsing [%s:%d] : '%s' expects <algorithm>\n",
1359 file, line, args[0]);
1360 return -1;
1361 }
1362 while (*(args[cur_arg])) {
1363 if (comp_append_algo(comp, args[cur_arg]) < 0) {
1364 memprintf(err, "'%s' : '%s' is not a supported algorithm.\n",
1365 args[0], args[cur_arg]);
1366 return -1;
1367 }
1368 if (proxy->comp->algos->init(&ctx, 9) == 0)
1369 proxy->comp->algos->end(&ctx);
1370 else {
1371 memprintf(err, "'%s' : Can't init '%s' algorithm.\n",
1372 args[0], args[cur_arg]);
1373 return -1;
1374 }
1375 cur_arg++;
1376 continue;
1377 }
1378 }
1379 else if (!strcmp(args[1], "offload"))
1380 comp->offload = 1;
1381 else if (!strcmp(args[1], "type")) {
1382 int cur_arg = 2;
1383
1384 if (!*args[cur_arg]) {
1385 memprintf(err, "'%s' expects <type>\n", args[0]);
1386 return -1;
1387 }
1388 while (*(args[cur_arg])) {
1389 comp_append_type(comp, args[cur_arg]);
1390 cur_arg++;
1391 continue;
1392 }
1393 }
1394 else {
1395 memprintf(err, "'%s' expects 'algo', 'type' or 'offload'\n",
1396 args[0]);
1397 return -1;
1398 }
1399
1400 return 0;
1401}
1402
Christopher Faulet92d36382015-11-05 13:35:03 +01001403static int
1404parse_http_comp_flt(char **args, int *cur_arg, struct proxy *px,
Thierry Fournier3610c392016-04-13 18:27:51 +02001405 struct flt_conf *fconf, char **err, void *private)
Christopher Faulet92d36382015-11-05 13:35:03 +01001406{
Christopher Faulet443ea1a2016-02-04 13:40:26 +01001407 struct flt_conf *fc, *back;
Christopher Faulet92d36382015-11-05 13:35:03 +01001408
Christopher Faulet443ea1a2016-02-04 13:40:26 +01001409 list_for_each_entry_safe(fc, back, &px->filter_configs, list) {
1410 if (fc->id == http_comp_flt_id) {
Christopher Faulet92d36382015-11-05 13:35:03 +01001411 memprintf(err, "%s: Proxy supports only one compression filter\n", px->id);
1412 return -1;
1413 }
1414 }
1415
Christopher Faulet443ea1a2016-02-04 13:40:26 +01001416 fconf->id = http_comp_flt_id;
1417 fconf->conf = NULL;
1418 fconf->ops = &comp_ops;
Christopher Faulet92d36382015-11-05 13:35:03 +01001419 (*cur_arg)++;
1420
1421 return 0;
1422}
1423
1424
1425int
Christopher Fauletc9df7f72018-12-10 16:14:04 +01001426check_implicit_http_comp_flt(struct proxy *proxy)
Christopher Faulet92d36382015-11-05 13:35:03 +01001427{
Christopher Faulet443ea1a2016-02-04 13:40:26 +01001428 struct flt_conf *fconf;
Christopher Faulet27d93c32018-12-15 22:32:02 +01001429 int explicit = 0;
1430 int comp = 0;
Christopher Faulet92d36382015-11-05 13:35:03 +01001431 int err = 0;
1432
1433 if (proxy->comp == NULL)
1434 goto end;
Christopher Faulet443ea1a2016-02-04 13:40:26 +01001435 if (!LIST_ISEMPTY(&proxy->filter_configs)) {
1436 list_for_each_entry(fconf, &proxy->filter_configs, list) {
1437 if (fconf->id == http_comp_flt_id)
Christopher Faulet27d93c32018-12-15 22:32:02 +01001438 comp = 1;
1439 else if (fconf->id == cache_store_flt_id) {
1440 if (comp) {
1441 ha_alert("config: %s '%s': unable to enable the compression filter "
1442 "before any cache filter.\n",
1443 proxy_type_str(proxy), proxy->id);
1444 err++;
1445 goto end;
1446 }
1447 }
1448 else
1449 explicit = 1;
Christopher Faulet92d36382015-11-05 13:35:03 +01001450 }
Christopher Faulet27d93c32018-12-15 22:32:02 +01001451 }
1452 if (comp)
1453 goto end;
1454 else if (explicit) {
1455 ha_alert("config: %s '%s': require an explicit filter declaration to use "
1456 "HTTP compression\n", proxy_type_str(proxy), proxy->id);
Christopher Faulet92d36382015-11-05 13:35:03 +01001457 err++;
1458 goto end;
1459 }
1460
Christopher Faulet27d93c32018-12-15 22:32:02 +01001461 /* Implicit declaration of the compression filter is always the last
1462 * one */
Christopher Faulet443ea1a2016-02-04 13:40:26 +01001463 fconf = calloc(1, sizeof(*fconf));
1464 if (!fconf) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001465 ha_alert("config: %s '%s': out of memory\n",
1466 proxy_type_str(proxy), proxy->id);
Christopher Faulet92d36382015-11-05 13:35:03 +01001467 err++;
1468 goto end;
1469 }
Christopher Faulet443ea1a2016-02-04 13:40:26 +01001470 fconf->id = http_comp_flt_id;
1471 fconf->conf = NULL;
1472 fconf->ops = &comp_ops;
1473 LIST_ADDQ(&proxy->filter_configs, &fconf->list);
Christopher Faulet92d36382015-11-05 13:35:03 +01001474 end:
1475 return err;
1476}
1477
1478/*
1479 * boolean, returns true if compression is used (either gzip or deflate) in the
1480 * response.
1481 */
Christopher Faulet3d97c902015-12-09 14:59:38 +01001482static int
Christopher Faulet92d36382015-11-05 13:35:03 +01001483smp_fetch_res_comp(const struct arg *args, struct sample *smp, const char *kw,
1484 void *private)
Christopher Faulet3d97c902015-12-09 14:59:38 +01001485{
Willy Tarreaube508f12016-03-10 11:47:01 +01001486 struct http_txn *txn = smp->strm ? smp->strm->txn : NULL;
Christopher Faulet92d36382015-11-05 13:35:03 +01001487
Christopher Faulet3d97c902015-12-09 14:59:38 +01001488 smp->data.type = SMP_T_BOOL;
Christopher Faulet92d36382015-11-05 13:35:03 +01001489 smp->data.u.sint = (txn && (txn->rsp.flags & HTTP_MSGF_COMPRESSING));
Christopher Faulet3d97c902015-12-09 14:59:38 +01001490 return 1;
1491}
1492
Christopher Faulet92d36382015-11-05 13:35:03 +01001493/*
1494 * string, returns algo
1495 */
Christopher Faulet3d97c902015-12-09 14:59:38 +01001496static int
Christopher Faulet92d36382015-11-05 13:35:03 +01001497smp_fetch_res_comp_algo(const struct arg *args, struct sample *smp,
1498 const char *kw, void *private)
Christopher Faulet3d97c902015-12-09 14:59:38 +01001499{
Willy Tarreaube508f12016-03-10 11:47:01 +01001500 struct http_txn *txn = smp->strm ? smp->strm->txn : NULL;
Christopher Faulet92d36382015-11-05 13:35:03 +01001501 struct filter *filter;
1502 struct comp_state *st;
1503
Christopher Faulet03d85532017-09-15 10:14:43 +02001504 if (!txn || !(txn->rsp.flags & HTTP_MSGF_COMPRESSING))
Christopher Faulet3d97c902015-12-09 14:59:38 +01001505 return 0;
1506
Christopher Fauletfcf035c2015-12-03 11:48:03 +01001507 list_for_each_entry(filter, &strm_flt(smp->strm)->filters, list) {
Christopher Faulet443ea1a2016-02-04 13:40:26 +01001508 if (FLT_ID(filter) != http_comp_flt_id)
Christopher Faulet92d36382015-11-05 13:35:03 +01001509 continue;
1510
1511 if (!(st = filter->ctx))
1512 break;
1513
1514 smp->data.type = SMP_T_STR;
1515 smp->flags = SMP_F_CONST;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001516 smp->data.u.str.area = st->comp_algo->cfg_name;
1517 smp->data.u.str.data = st->comp_algo->cfg_name_len;
Christopher Faulet92d36382015-11-05 13:35:03 +01001518 return 1;
1519 }
1520 return 0;
Christopher Faulet3d97c902015-12-09 14:59:38 +01001521}
1522
1523/* Declare the config parser for "compression" keyword */
1524static struct cfg_kw_list cfg_kws = {ILH, {
1525 { CFG_LISTEN, "compression", parse_compression_options },
1526 { 0, NULL, NULL },
1527 }
1528};
1529
Willy Tarreau0108d902018-11-25 19:14:37 +01001530INITCALL1(STG_REGISTER, cfg_register_keywords, &cfg_kws);
1531
Christopher Faulet92d36382015-11-05 13:35:03 +01001532/* Declare the filter parser for "compression" keyword */
1533static struct flt_kw_list filter_kws = { "COMP", { }, {
Thierry Fournier3610c392016-04-13 18:27:51 +02001534 { "compression", parse_http_comp_flt, NULL },
1535 { NULL, NULL, NULL },
Christopher Faulet92d36382015-11-05 13:35:03 +01001536 }
1537};
1538
Willy Tarreau0108d902018-11-25 19:14:37 +01001539INITCALL1(STG_REGISTER, flt_register_keywords, &filter_kws);
1540
Christopher Faulet3d97c902015-12-09 14:59:38 +01001541/* Note: must not be declared <const> as its list will be overwritten */
1542static struct sample_fetch_kw_list sample_fetch_keywords = {ILH, {
Christopher Faulet92d36382015-11-05 13:35:03 +01001543 { "res.comp", smp_fetch_res_comp, 0, NULL, SMP_T_BOOL, SMP_USE_HRSHP },
1544 { "res.comp_algo", smp_fetch_res_comp_algo, 0, NULL, SMP_T_STR, SMP_USE_HRSHP },
1545 { /* END */ },
1546 }
1547};
Christopher Faulet3d97c902015-12-09 14:59:38 +01001548
Willy Tarreau0108d902018-11-25 19:14:37 +01001549INITCALL1(STG_REGISTER, sample_register_fetches, &sample_fetch_keywords);