/* * Stream filters related variables and functions. * * Copyright (C) 2015 Qualys Inc., Christopher Faulet * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License * as published by the Free Software Foundation; either version * 2 of the License, or (at your option) any later version. * */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include static const char *http_comp_flt_id = "compression filter"; struct flt_ops comp_ops; static struct buffer *tmpbuf = &buf_empty; static struct buffer *zbuf = &buf_empty; struct comp_state { struct comp_ctx *comp_ctx; /* compression context */ struct comp_algo *comp_algo; /* compression algorithm if not NULL */ int hdrs_len; int tlrs_len; int consumed; int initialized; int finished; }; static int select_compression_request_header(struct comp_state *st, struct stream *s, struct http_msg *msg); static int select_compression_response_header(struct comp_state *st, struct stream *s, struct http_msg *msg); static int http_compression_buffer_init(struct buffer *in, struct buffer *out); static int http_compression_buffer_add_data(struct comp_state *st, struct buffer *in, struct buffer *out, int sz); static int http_compression_buffer_end(struct comp_state *st, struct stream *s, struct buffer **in, struct buffer **out, int end); /***********************************************************************/ static int comp_flt_init(struct proxy *px, struct flt_conf *fconf) { if (!tmpbuf->size && b_alloc(&tmpbuf) == NULL) return -1; if (!zbuf->size && b_alloc(&zbuf) == NULL) return -1; return 0; } static void comp_flt_deinit(struct proxy *px, struct flt_conf *fconf) { if (tmpbuf->size) b_free(&tmpbuf); if (zbuf->size) b_free(&zbuf); } static int comp_start_analyze(struct stream *s, struct filter *filter, struct channel *chn) { if (filter->ctx == NULL) { struct comp_state *st; if (!(st = malloc(sizeof(*st)))) return -1; st->comp_algo = NULL; st->comp_ctx = NULL; st->hdrs_len = 0; st->tlrs_len = 0; st->consumed = 0; st->initialized = 0; st->finished = 0; filter->ctx = st; } return 1; } static int comp_analyze(struct stream *s, struct filter *filter, struct channel *chn, unsigned int an_bit) { struct comp_state *st = filter->ctx; if (!strm_fe(s)->comp && !s->be->comp) goto end; if (an_bit == AN_FLT_HTTP_HDRS) { if (!(chn->flags & CF_ISRESP)) select_compression_request_header(st, s, &s->txn->req); else { select_compression_response_header(st, s, &s->txn->rsp); if (st->comp_algo) { register_data_filter(s, chn, filter); st->hdrs_len = s->txn->rsp.sov; } } } end: return 1; } static int comp_end_analyze(struct stream *s, struct filter *filter, struct channel *chn) { struct comp_state *st = filter->ctx; if (!st || !(chn->flags & CF_ISRESP)) goto end; if (!st->comp_algo || !s->txn->status) goto release_ctx; if (strm_fe(s)->mode == PR_MODE_HTTP) strm_fe(s)->fe_counters.p.http.comp_rsp++; if ((s->flags & SF_BE_ASSIGNED) && (s->be->mode == PR_MODE_HTTP)) s->be->be_counters.p.http.comp_rsp++; /* release any possible compression context */ st->comp_algo->end(&st->comp_ctx); release_ctx: free(st); filter->ctx = NULL; end: return 1; } static int comp_http_data(struct stream *s, struct filter *filter, struct http_msg *msg) { struct comp_state *st = filter->ctx; struct buffer *buf = msg->chn->buf; unsigned int *nxt = &flt_rsp_nxt(filter); unsigned int len; int ret; len = MIN(msg->chunk_len + msg->next, buf->i) - *nxt; if (!len) return len; if (!st->initialized) { unsigned int fwd = flt_rsp_fwd(filter) + st->hdrs_len; b_reset(tmpbuf); b_adv(buf, fwd); ret = http_compression_buffer_init(buf, zbuf); b_rew(buf, fwd); if (ret < 0) { msg->chn->flags |= CF_WAKE_WRITE; return 0; } } if (msg->flags & HTTP_MSGF_TE_CHNK) { int block = bi_contig_data(buf); len = MIN(tmpbuf->size - buffer_len(tmpbuf), len); if (len > block) { memcpy(bi_end(tmpbuf), b_ptr(buf, *nxt), block); memcpy(bi_end(tmpbuf)+block, buf->data, len - block); } else memcpy(bi_end(tmpbuf), b_ptr(buf, *nxt), len); tmpbuf->i += len; ret = len; } else { b_adv(buf, *nxt); ret = http_compression_buffer_add_data(st, buf, zbuf, len); b_rew(buf, *nxt); if (ret < 0) return ret; } st->initialized = 1; msg->next += ret; msg->chunk_len -= ret; *nxt = msg->next; return 0; } static int comp_http_chunk_trailers(struct stream *s, struct filter *filter, struct http_msg *msg) { struct comp_state *st = filter->ctx; if (!st->initialized) { if (!st->finished) { struct buffer *buf = msg->chn->buf; unsigned int fwd = flt_rsp_fwd(filter) + st->hdrs_len; b_reset(tmpbuf); b_adv(buf, fwd); http_compression_buffer_init(buf, zbuf); b_rew(buf, fwd); st->initialized = 1; } } st->tlrs_len = msg->sol; return 1; } static int comp_http_forward_data(struct stream *s, struct filter *filter, struct http_msg *msg, unsigned int len) { struct comp_state *st = filter->ctx; int ret; /* To work, previous filters MUST forward all data */ if (flt_rsp_fwd(filter) + len != flt_rsp_nxt(filter)) { Warning("HTTP compression failed: unexpected behavior of previous filters\n"); return -1; } if (!st->initialized) { if (!len) { /* Nothing to foward */ ret = len; } else if (st->hdrs_len > len) { /* Forward part of headers */ ret = len; st->hdrs_len -= len; } else if (st->hdrs_len > 0) { /* Forward remaining headers */ ret = st->hdrs_len; st->hdrs_len = 0; } else if (msg->msg_state < HTTP_MSG_TRAILERS) { /* Do not forward anything for now. This only happens * with chunk-encoded responses. Waiting data are part * of the chunk envelope (the chunk size or the chunk * CRLF). These data will be skipped during the * compression. */ ret = 0; } else { /* Forward trailers data */ ret = len; } return ret; } if (msg->flags & HTTP_MSGF_TE_CHNK) { ret = http_compression_buffer_add_data(st, tmpbuf, zbuf, tmpbuf->i); if (ret != tmpbuf->i) { Warning("HTTP compression failed: Must consume %d bytes but only %d bytes consumed\n", tmpbuf->i, ret); return -1; } } st->consumed = len - st->hdrs_len - st->tlrs_len; b_adv(msg->chn->buf, flt_rsp_fwd(filter) + st->hdrs_len); ret = http_compression_buffer_end(st, s, &msg->chn->buf, &zbuf, msg->msg_state >= HTTP_MSG_TRAILERS); b_rew(msg->chn->buf, flt_rsp_fwd(filter) + st->hdrs_len); if (ret < 0) return ret; flt_change_forward_size(filter, msg->chn, ret - st->consumed); msg->next += (ret - st->consumed); ret += st->hdrs_len + st->tlrs_len; st->initialized = 0; st->finished = (msg->msg_state >= HTTP_MSG_TRAILERS); st->hdrs_len = 0; st->tlrs_len = 0; return ret; } /***********************************************************************/ /* * Selects a compression algorithm depending on the client request. */ int select_compression_request_header(struct comp_state *st, struct stream *s, struct http_msg *msg) { struct http_txn *txn = s->txn; struct buffer *req = msg->chn->buf; struct hdr_ctx ctx; struct comp_algo *comp_algo = NULL; struct comp_algo *comp_algo_back = NULL; /* Disable compression for older user agents announcing themselves as "Mozilla/4" * unless they are known good (MSIE 6 with XP SP2, or MSIE 7 and later). * See http://zoompf.com/2012/02/lose-the-wait-http-compression for more details. */ ctx.idx = 0; if (http_find_header2("User-Agent", 10, req->p, &txn->hdr_idx, &ctx) && ctx.vlen >= 9 && memcmp(ctx.line + ctx.val, "Mozilla/4", 9) == 0 && (ctx.vlen < 31 || memcmp(ctx.line + ctx.val + 25, "MSIE ", 5) != 0 || ctx.line[ctx.val + 30] < '6' || (ctx.line[ctx.val + 30] == '6' && (ctx.vlen < 54 || memcmp(ctx.line + 51, "SV1", 3) != 0)))) { st->comp_algo = NULL; return 0; } /* search for the algo in the backend in priority or the frontend */ if ((s->be->comp && (comp_algo_back = s->be->comp->algos)) || (strm_fe(s)->comp && (comp_algo_back = strm_fe(s)->comp->algos))) { int best_q = 0; ctx.idx = 0; while (http_find_header2("Accept-Encoding", 15, req->p, &txn->hdr_idx, &ctx)) { const char *qval; int q; int toklen; /* try to isolate the token from the optional q-value */ toklen = 0; while (toklen < ctx.vlen && http_is_token[(unsigned char)*(ctx.line + ctx.val + toklen)]) toklen++; qval = ctx.line + ctx.val + toklen; while (1) { while (qval < ctx.line + ctx.val + ctx.vlen && http_is_lws[(unsigned char)*qval]) qval++; if (qval >= ctx.line + ctx.val + ctx.vlen || *qval != ';') { qval = NULL; break; } qval++; while (qval < ctx.line + ctx.val + ctx.vlen && http_is_lws[(unsigned char)*qval]) qval++; if (qval >= ctx.line + ctx.val + ctx.vlen) { qval = NULL; break; } if (strncmp(qval, "q=", MIN(ctx.line + ctx.val + ctx.vlen - qval, 2)) == 0) break; while (qval < ctx.line + ctx.val + ctx.vlen && *qval != ';') qval++; } /* here we have qval pointing to the first "q=" attribute or NULL if not found */ q = qval ? parse_qvalue(qval + 2, NULL) : 1000; if (q <= best_q) continue; for (comp_algo = comp_algo_back; comp_algo; comp_algo = comp_algo->next) { if (*(ctx.line + ctx.val) == '*' || word_match(ctx.line + ctx.val, toklen, comp_algo->ua_name, comp_algo->ua_name_len)) { st->comp_algo = comp_algo; best_q = q; break; } } } } /* remove all occurrences of the header when "compression offload" is set */ if (st->comp_algo) { if ((s->be->comp && s->be->comp->offload) || (strm_fe(s)->comp && strm_fe(s)->comp->offload)) { http_remove_header2(msg, &txn->hdr_idx, &ctx); ctx.idx = 0; while (http_find_header2("Accept-Encoding", 15, req->p, &txn->hdr_idx, &ctx)) { http_remove_header2(msg, &txn->hdr_idx, &ctx); } } return 1; } /* identity is implicit does not require headers */ if ((s->be->comp && (comp_algo_back = s->be->comp->algos)) || (strm_fe(s)->comp && (comp_algo_back = strm_fe(s)->comp->algos))) { for (comp_algo = comp_algo_back; comp_algo; comp_algo = comp_algo->next) { if (comp_algo->cfg_name_len == 8 && memcmp(comp_algo->cfg_name, "identity", 8) == 0) { st->comp_algo = comp_algo; return 1; } } } st->comp_algo = NULL; return 0; } /* * Selects a comression algorithm depending of the server response. */ static int select_compression_response_header(struct comp_state *st, struct stream *s, struct http_msg *msg) { struct http_txn *txn = s->txn; struct buffer *res = msg->chn->buf; struct hdr_ctx ctx; struct comp_type *comp_type; /* no common compression algorithm was found in request header */ if (st->comp_algo == NULL) goto fail; /* HTTP < 1.1 should not be compressed */ if (!(msg->flags & HTTP_MSGF_VER_11) || !(txn->req.flags & HTTP_MSGF_VER_11)) goto fail; if (txn->meth == HTTP_METH_HEAD) goto fail; /* compress 200,201,202,203 responses only */ if ((txn->status != 200) && (txn->status != 201) && (txn->status != 202) && (txn->status != 203)) goto fail; /* Content-Length is null */ if (!(msg->flags & HTTP_MSGF_TE_CHNK) && msg->body_len == 0) goto fail; /* content is already compressed */ ctx.idx = 0; if (http_find_header2("Content-Encoding", 16, res->p, &txn->hdr_idx, &ctx)) goto fail; /* no compression when Cache-Control: no-transform is present in the message */ ctx.idx = 0; while (http_find_header2("Cache-Control", 13, res->p, &txn->hdr_idx, &ctx)) { if (word_match(ctx.line + ctx.val, ctx.vlen, "no-transform", 12)) goto fail; } comp_type = NULL; /* we don't want to compress multipart content-types, nor content-types that are * not listed in the "compression type" directive if any. If no content-type was * found but configuration requires one, we don't compress either. Backend has * the priority. */ ctx.idx = 0; if (http_find_header2("Content-Type", 12, res->p, &txn->hdr_idx, &ctx)) { if (ctx.vlen >= 9 && strncasecmp("multipart", ctx.line+ctx.val, 9) == 0) goto fail; if ((s->be->comp && (comp_type = s->be->comp->types)) || (strm_fe(s)->comp && (comp_type = strm_fe(s)->comp->types))) { for (; comp_type; comp_type = comp_type->next) { if (ctx.vlen >= comp_type->name_len && strncasecmp(ctx.line+ctx.val, comp_type->name, comp_type->name_len) == 0) /* this Content-Type should be compressed */ break; } /* this Content-Type should not be compressed */ if (comp_type == NULL) goto fail; } } else { /* no content-type header */ if ((s->be->comp && s->be->comp->types) || (strm_fe(s)->comp && strm_fe(s)->comp->types)) goto fail; /* a content-type was required */ } /* limit compression rate */ if (global.comp_rate_lim > 0) if (read_freq_ctr(&global.comp_bps_in) > global.comp_rate_lim) goto fail; /* limit cpu usage */ if (idle_pct < compress_min_idle) goto fail; /* initialize compression */ if (st->comp_algo->init(&st->comp_ctx, global.tune.comp_maxlevel) < 0) goto fail; /* remove Content-Length header */ ctx.idx = 0; if ((msg->flags & HTTP_MSGF_CNT_LEN) && http_find_header2("Content-Length", 14, res->p, &txn->hdr_idx, &ctx)) http_remove_header2(msg, &txn->hdr_idx, &ctx); /* add Transfer-Encoding header */ if (!(msg->flags & HTTP_MSGF_TE_CHNK)) http_header_add_tail2(&txn->rsp, &txn->hdr_idx, "Transfer-Encoding: chunked", 26); /* * Add Content-Encoding header when it's not identity encoding. * RFC 2616 : Identity encoding: This content-coding is used only in the * Accept-Encoding header, and SHOULD NOT be used in the Content-Encoding * header. */ if (st->comp_algo->cfg_name_len != 8 || memcmp(st->comp_algo->cfg_name, "identity", 8) != 0) { trash.len = 18; memcpy(trash.str, "Content-Encoding: ", trash.len); memcpy(trash.str + trash.len, st->comp_algo->ua_name, st->comp_algo->ua_name_len); trash.len += st->comp_algo->ua_name_len; trash.str[trash.len] = '\0'; http_header_add_tail2(&txn->rsp, &txn->hdr_idx, trash.str, trash.len); } msg->flags |= HTTP_MSGF_COMPRESSING; return 1; fail: st->comp_algo = NULL; return 0; } /***********************************************************************/ /* emit the chunksize followed by a CRLF on the output and return the number of * bytes written. It goes backwards and starts with the byte before . It * returns the number of bytes written which will not exceed 10 (8 digits, CR, * and LF). The caller is responsible for ensuring there is enough room left in * the output buffer for the string. */ static int http_emit_chunk_size(char *end, unsigned int chksz) { char *beg = end; *--beg = '\n'; *--beg = '\r'; do { *--beg = hextab[chksz & 0xF]; } while (chksz >>= 4); return end - beg; } /* * Init HTTP compression */ static int http_compression_buffer_init(struct buffer *in, struct buffer *out) { /* output stream requires at least 10 bytes for the gzip header, plus * at least 8 bytes for the gzip trailer (crc+len), plus a possible * plus at most 5 bytes per 32kB block and 2 bytes to close the stream. */ if (in->size - buffer_len(in) < 20 + 5 * ((in->i + 32767) >> 15)) return -1; /* prepare an empty output buffer in which we reserve enough room for * copying the output bytes from , plus 10 extra bytes to write * the chunk size. We don't copy the bytes yet so that if we have to * cancel the operation later, it's cheap. */ b_reset(out); out->o = in->o; out->p += out->o; out->i = 10; return 0; } /* * Add data to compress */ static int http_compression_buffer_add_data(struct comp_state *st, struct buffer *in, struct buffer *out, int sz) { int consumed_data = 0; int data_process_len; int block1, block2; if (!sz) goto end; /* select the smallest size between the announced chunk size, the input * data, and the available output buffer size. The compressors are * assumed to be able to process all the bytes we pass to them at * once. */ data_process_len = MIN(out->size - buffer_len(out), sz); block1 = data_process_len; if (block1 > bi_contig_data(in)) block1 = bi_contig_data(in); block2 = data_process_len - block1; /* compressors return < 0 upon error or the amount of bytes read */ consumed_data = st->comp_algo->add_data(st->comp_ctx, bi_ptr(in), block1, out); if (consumed_data != block1 || !block2) goto end; consumed_data = st->comp_algo->add_data(st->comp_ctx, in->data, block2, out); if (consumed_data < 0) goto end; consumed_data += block1; end: return consumed_data; } /* * Flush data in process, and write the header and footer of the chunk. Upon * success, in and out buffers are swapped to avoid a copy. */ static int http_compression_buffer_end(struct comp_state *st, struct stream *s, struct buffer **in, struct buffer **out, int end) { struct buffer *ib = *in, *ob = *out; char *tail; int to_forward, left; #if defined(USE_SLZ) || defined(USE_ZLIB) int ret; /* flush data here */ if (end) ret = st->comp_algo->finish(st->comp_ctx, ob); /* end of data */ else ret = st->comp_algo->flush(st->comp_ctx, ob); /* end of buffer */ if (ret < 0) return -1; /* flush failed */ #endif /* USE_ZLIB */ if (ob->i == 10) { /* No data were appended, let's drop the output buffer and * keep the input buffer unchanged. */ return 0; } /* OK so at this stage, we have an output buffer looking like this : * * <-- o --> <------ i -----> * +---------+---+------------+-----------+ * | out | c | comp_in | empty | * +---------+---+------------+-----------+ * data p size * * is the room reserved to copy ib->o. It starts at ob->data and * has not yet been filled. is the room reserved to write the chunk * size (10 bytes). is the compressed equivalent of the data * part of ib->i. is the amount of empty bytes at the end of * the buffer, into which we may have to copy the remaining bytes from * ib->i after the data (chunk size, trailers, ...). */ /* Write real size at the begining of the chunk, no need of wrapping. * We write the chunk using a dynamic length and adjust ob->p and ob->i * accordingly afterwards. That will move away from . */ left = 10 - http_emit_chunk_size(ob->p + 10, ob->i - 10); ob->p += left; ob->i -= left; /* Copy previous data from ib->o into ob->o */ if (ib->o > 0) { left = bo_contig_data(ib); memcpy(ob->p - ob->o, bo_ptr(ib), left); if (ib->o - left) /* second part of the buffer */ memcpy(ob->p - ob->o + left, ib->data, ib->o - left); } /* chunked encoding requires CRLF after data */ tail = ob->p + ob->i; *tail++ = '\r'; *tail++ = '\n'; /* At the end of data, we must write the empty chunk 0, * and terminate the trailers section with a last . If * we're forwarding a chunked-encoded response, we'll have a * trailers section after the empty chunk which needs to be * forwarded and which will provide the last CRLF. Otherwise * we write it ourselves. */ if (end) { struct http_msg *msg = &s->txn->rsp; memcpy(tail, "0\r\n", 3); tail += 3; if (!(msg->flags & HTTP_MSGF_TE_CHNK)) { memcpy(tail, "\r\n", 2); tail += 2; } } ob->i = tail - ob->p; to_forward = ob->i; /* update input rate */ if (st->comp_ctx && st->comp_ctx->cur_lvl > 0) { update_freq_ctr(&global.comp_bps_in, st->consumed); strm_fe(s)->fe_counters.comp_in += st->consumed; s->be->be_counters.comp_in += st->consumed; } else { strm_fe(s)->fe_counters.comp_byp += st->consumed; s->be->be_counters.comp_byp += st->consumed; } /* copy the remaining data in the tmp buffer. */ b_adv(ib, st->consumed); if (ib->i > 0) { left = bi_contig_data(ib); memcpy(ob->p + ob->i, bi_ptr(ib), left); ob->i += left; if (ib->i - left) { memcpy(ob->p + ob->i, ib->data, ib->i - left); ob->i += ib->i - left; } } /* swap the buffers */ *in = ob; *out = ib; if (st->comp_ctx && st->comp_ctx->cur_lvl > 0) { update_freq_ctr(&global.comp_bps_out, to_forward); strm_fe(s)->fe_counters.comp_out += to_forward; s->be->be_counters.comp_out += to_forward; } return to_forward; } /***********************************************************************/ struct flt_ops comp_ops = { .init = comp_flt_init, .deinit = comp_flt_deinit, .channel_start_analyze = comp_start_analyze, .channel_analyze = comp_analyze, .channel_end_analyze = comp_end_analyze, .http_data = comp_http_data, .http_chunk_trailers = comp_http_chunk_trailers, .http_forward_data = comp_http_forward_data, }; static int parse_compression_options(char **args, int section, struct proxy *proxy, struct proxy *defpx, const char *file, int line, char **err) { struct comp *comp; if (proxy->comp == NULL) { comp = calloc(1, sizeof(struct comp)); proxy->comp = comp; } else comp = proxy->comp; if (!strcmp(args[1], "algo")) { struct comp_ctx *ctx; int cur_arg = 2; if (!*args[cur_arg]) { memprintf(err, "parsing [%s:%d] : '%s' expects \n", file, line, args[0]); return -1; } while (*(args[cur_arg])) { if (comp_append_algo(comp, args[cur_arg]) < 0) { memprintf(err, "'%s' : '%s' is not a supported algorithm.\n", args[0], args[cur_arg]); return -1; } if (proxy->comp->algos->init(&ctx, 9) == 0) proxy->comp->algos->end(&ctx); else { memprintf(err, "'%s' : Can't init '%s' algorithm.\n", args[0], args[cur_arg]); return -1; } cur_arg++; continue; } } else if (!strcmp(args[1], "offload")) comp->offload = 1; else if (!strcmp(args[1], "type")) { int cur_arg = 2; if (!*args[cur_arg]) { memprintf(err, "'%s' expects \n", args[0]); return -1; } while (*(args[cur_arg])) { comp_append_type(comp, args[cur_arg]); cur_arg++; continue; } } else { memprintf(err, "'%s' expects 'algo', 'type' or 'offload'\n", args[0]); return -1; } return 0; } static int parse_http_comp_flt(char **args, int *cur_arg, struct proxy *px, struct flt_conf *fconf, char **err) { struct flt_conf *fc, *back; list_for_each_entry_safe(fc, back, &px->filter_configs, list) { if (fc->id == http_comp_flt_id) { memprintf(err, "%s: Proxy supports only one compression filter\n", px->id); return -1; } } fconf->id = http_comp_flt_id; fconf->conf = NULL; fconf->ops = &comp_ops; (*cur_arg)++; return 0; } int check_legacy_http_comp_flt(struct proxy *proxy) { struct flt_conf *fconf; int err = 0; if (proxy->comp == NULL) goto end; if (!LIST_ISEMPTY(&proxy->filter_configs)) { list_for_each_entry(fconf, &proxy->filter_configs, list) { if (fconf->id == http_comp_flt_id) goto end; } Alert("config: %s '%s': require an explicit filter declaration to use HTTP compression\n", proxy_type_str(proxy), proxy->id); err++; goto end; } fconf = calloc(1, sizeof(*fconf)); if (!fconf) { Alert("config: %s '%s': out of memory\n", proxy_type_str(proxy), proxy->id); err++; goto end; } fconf->id = http_comp_flt_id; fconf->conf = NULL; fconf->ops = &comp_ops; LIST_ADDQ(&proxy->filter_configs, &fconf->list); end: return err; } /* * boolean, returns true if compression is used (either gzip or deflate) in the * response. */ static int smp_fetch_res_comp(const struct arg *args, struct sample *smp, const char *kw, void *private) { struct http_txn *txn = smp->strm ? smp->strm->txn : NULL; smp->data.type = SMP_T_BOOL; smp->data.u.sint = (txn && (txn->rsp.flags & HTTP_MSGF_COMPRESSING)); return 1; } /* * string, returns algo */ static int smp_fetch_res_comp_algo(const struct arg *args, struct sample *smp, const char *kw, void *private) { struct http_txn *txn = smp->strm ? smp->strm->txn : NULL; struct filter *filter; struct comp_state *st; if (!(txn || !(txn->rsp.flags & HTTP_MSGF_COMPRESSING))) return 0; list_for_each_entry(filter, &strm_flt(smp->strm)->filters, list) { if (FLT_ID(filter) != http_comp_flt_id) continue; if (!(st = filter->ctx)) break; smp->data.type = SMP_T_STR; smp->flags = SMP_F_CONST; smp->data.u.str.str = st->comp_algo->cfg_name; smp->data.u.str.len = st->comp_algo->cfg_name_len; return 1; } return 0; } /* Declare the config parser for "compression" keyword */ static struct cfg_kw_list cfg_kws = {ILH, { { CFG_LISTEN, "compression", parse_compression_options }, { 0, NULL, NULL }, } }; /* Declare the filter parser for "compression" keyword */ static struct flt_kw_list filter_kws = { "COMP", { }, { { "compression", parse_http_comp_flt }, { NULL, NULL }, } }; /* Note: must not be declared as its list will be overwritten */ static struct sample_fetch_kw_list sample_fetch_keywords = {ILH, { { "res.comp", smp_fetch_res_comp, 0, NULL, SMP_T_BOOL, SMP_USE_HRSHP }, { "res.comp_algo", smp_fetch_res_comp_algo, 0, NULL, SMP_T_STR, SMP_USE_HRSHP }, { /* END */ }, } }; __attribute__((constructor)) static void __flt_http_comp_init(void) { cfg_register_keywords(&cfg_kws); flt_register_keywords(&filter_kws); sample_register_fetches(&sample_fetch_keywords); }