blob: 879e068c54c24ba41deaf01d2d742b95f1e39a97 [file] [log] [blame]
William Lallemand41db4602017-10-30 11:15:51 +01001/*
2 * Cache management
3 *
4 * Copyright 2017 HAProxy Technologies
5 * William Lallemand <wlallemand@haproxy.com>
6 *
7 * This program is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU General Public License
9 * as published by the Free Software Foundation; either version
10 * 2 of the License, or (at your option) any later version.
11 */
12
William Lallemand41db4602017-10-30 11:15:51 +010013#include <eb32tree.h>
William Lallemandf528fff2017-11-23 19:43:17 +010014#include <import/sha1.h>
William Lallemand41db4602017-10-30 11:15:51 +010015
William Lallemand75d93292017-11-21 20:01:24 +010016#include <types/action.h>
William Lallemand1f49a362017-11-21 20:01:26 +010017#include <types/cli.h>
William Lallemand75d93292017-11-21 20:01:24 +010018#include <types/filters.h>
19#include <types/proxy.h>
20#include <types/shctx.h>
21
William Lallemand41db4602017-10-30 11:15:51 +010022#include <proto/channel.h>
William Lallemand1f49a362017-11-21 20:01:26 +010023#include <proto/cli.h>
William Lallemand41db4602017-10-30 11:15:51 +010024#include <proto/proxy.h>
25#include <proto/hdr_idx.h>
Christopher Faulet54a8d5a2018-12-07 12:21:11 +010026#include <proto/http_htx.h>
William Lallemand41db4602017-10-30 11:15:51 +010027#include <proto/filters.h>
Willy Tarreau61c112a2018-10-02 16:43:32 +020028#include <proto/http_rules.h>
William Lallemand41db4602017-10-30 11:15:51 +010029#include <proto/proto_http.h>
30#include <proto/log.h>
31#include <proto/stream.h>
32#include <proto/stream_interface.h>
33#include <proto/shctx.h>
34
William Lallemand41db4602017-10-30 11:15:51 +010035
36#include <common/cfgparse.h>
37#include <common/hash.h>
Willy Tarreaub96b77e2018-12-11 10:22:41 +010038#include <common/htx.h>
Willy Tarreau0108d902018-11-25 19:14:37 +010039#include <common/initcall.h>
William Lallemand41db4602017-10-30 11:15:51 +010040
41/* flt_cache_store */
Christopher Faulet1f672c52018-12-03 14:30:41 +010042#define CACHE_F_LEGACY_HTTP 0x00000001 /* The cache is used to store raw HTTP
43 * messages (legacy implementation) */
44#define CACHE_F_HTX 0x00000002 /* The cache is used to store HTX messages */
William Lallemand41db4602017-10-30 11:15:51 +010045
Christopher Faulet27d93c32018-12-15 22:32:02 +010046#define CACHE_FLT_F_IMPLICIT_DECL 0x00000001 /* The cache filtre was implicitly declared (ie without
Christopher Faulet99a17a22018-12-11 09:18:27 +010047 * the filter keyword) */
Christopher Fauletafd819c2018-12-11 08:57:45 +010048
Christopher Fauletf4a4ef72018-12-07 17:39:53 +010049const char *cache_store_flt_id = "cache store filter";
William Lallemand41db4602017-10-30 11:15:51 +010050
Willy Tarreau0f222992019-03-19 09:57:55 +010051static struct applet http_cache_applet;
William Lallemand41db4602017-10-30 11:15:51 +010052
53struct flt_ops cache_ops;
54
55struct cache {
Willy Tarreaufd5efb52017-11-26 08:54:31 +010056 struct list list; /* cache linked list */
William Lallemand41db4602017-10-30 11:15:51 +010057 struct eb_root entries; /* head of cache entries based on keys */
Willy Tarreaufd5efb52017-11-26 08:54:31 +010058 unsigned int maxage; /* max-age */
59 unsigned int maxblocks;
Frédéric Lécaille4eba5442018-10-25 20:29:31 +020060 unsigned int maxobjsz; /* max-object-size (in bytes) */
Willy Tarreaufd5efb52017-11-26 08:54:31 +010061 char id[33]; /* cache name */
Christopher Faulet1f672c52018-12-03 14:30:41 +010062 unsigned int flags; /* CACHE_F_* */
William Lallemand41db4602017-10-30 11:15:51 +010063};
64
Christopher Faulet95220e22018-12-07 17:34:39 +010065/* cache config for filters */
66struct cache_flt_conf {
67 union {
68 struct cache *cache; /* cache used by the filter */
69 char *name; /* cache name used during conf parsing */
70 } c;
71 unsigned int flags; /* CACHE_FLT_F_* */
72};
73
William Lallemand41db4602017-10-30 11:15:51 +010074/*
75 * cache ctx for filters
76 */
77struct cache_st {
Christopher Faulet54a8d5a2018-12-07 12:21:11 +010078 int hdrs_len; // field used in legacy mode only
William Lallemand41db4602017-10-30 11:15:51 +010079 struct shared_block *first_block;
80};
81
82struct cache_entry {
83 unsigned int latest_validation; /* latest validation date */
84 unsigned int expire; /* expiration date */
Frédéric Lécaillee7a770c2018-10-26 14:29:22 +020085 unsigned int age; /* Origin server "Age" header value */
Christopher Faulet54a8d5a2018-12-07 12:21:11 +010086 unsigned int eoh; /* Origin server end of headers offset. */ // field used in legacy mode only
87
88 unsigned int hdrs_len; // field used in HTX mode only
89 unsigned int data_len; // field used in HTX mode only
90
William Lallemand41db4602017-10-30 11:15:51 +010091 struct eb32_node eb; /* ebtree node used to hold the cache object */
William Lallemandf528fff2017-11-23 19:43:17 +010092 char hash[20];
William Lallemand41db4602017-10-30 11:15:51 +010093 unsigned char data[0];
94};
95
96#define CACHE_BLOCKSIZE 1024
Willy Tarreau96062a12018-11-11 14:00:28 +010097#define CACHE_ENTRY_MAX_AGE 2147483648U
William Lallemand41db4602017-10-30 11:15:51 +010098
99static struct list caches = LIST_HEAD_INIT(caches);
100static struct cache *tmp_cache_config = NULL;
101
Willy Tarreau8ceae722018-11-26 11:58:30 +0100102DECLARE_STATIC_POOL(pool_head_cache_st, "cache_st", sizeof(struct cache_st));
103
William Lallemandf528fff2017-11-23 19:43:17 +0100104struct cache_entry *entry_exist(struct cache *cache, char *hash)
William Lallemand4da3f8a2017-10-31 14:33:34 +0100105{
106 struct eb32_node *node;
107 struct cache_entry *entry;
108
William Lallemandf528fff2017-11-23 19:43:17 +0100109 node = eb32_lookup(&cache->entries, (*(unsigned int *)hash));
William Lallemand4da3f8a2017-10-31 14:33:34 +0100110 if (!node)
111 return NULL;
112
113 entry = eb32_entry(node, struct cache_entry, eb);
William Lallemandf528fff2017-11-23 19:43:17 +0100114
115 /* if that's not the right node */
116 if (memcmp(entry->hash, hash, sizeof(entry->hash)))
117 return NULL;
118
William Lallemand08727662017-11-21 20:01:27 +0100119 if (entry->expire > now.tv_sec) {
William Lallemand4da3f8a2017-10-31 14:33:34 +0100120 return entry;
William Lallemand08727662017-11-21 20:01:27 +0100121 } else {
William Lallemand4da3f8a2017-10-31 14:33:34 +0100122 eb32_delete(node);
William Lallemand08727662017-11-21 20:01:27 +0100123 entry->eb.key = 0;
124 }
William Lallemand4da3f8a2017-10-31 14:33:34 +0100125 return NULL;
126
127}
128
129static inline struct shared_context *shctx_ptr(struct cache *cache)
130{
131 return (struct shared_context *)((unsigned char *)cache - ((struct shared_context *)NULL)->data);
132}
133
William Lallemand77c11972017-10-31 20:43:01 +0100134static inline struct shared_block *block_ptr(struct cache_entry *entry)
135{
136 return (struct shared_block *)((unsigned char *)entry - ((struct shared_block *)NULL)->data);
137}
138
139
140
William Lallemand41db4602017-10-30 11:15:51 +0100141static int
Christopher Faulet54a8d5a2018-12-07 12:21:11 +0100142cache_store_init(struct proxy *px, struct flt_conf *fconf)
William Lallemand41db4602017-10-30 11:15:51 +0100143{
Christopher Faulet54a8d5a2018-12-07 12:21:11 +0100144 fconf->flags |= FLT_CFG_FL_HTX;
William Lallemand41db4602017-10-30 11:15:51 +0100145 return 0;
146}
147
Christopher Faulet95220e22018-12-07 17:34:39 +0100148static void
149cache_store_deinit(struct proxy *px, struct flt_conf *fconf)
150{
151 struct cache_flt_conf *cconf = fconf->conf;
152
153 free(cconf);
154}
155
William Lallemand4da3f8a2017-10-31 14:33:34 +0100156static int
Christopher Faulet95220e22018-12-07 17:34:39 +0100157cache_store_check(struct proxy *px, struct flt_conf *fconf)
158{
159 struct cache_flt_conf *cconf = fconf->conf;
Christopher Fauletafd819c2018-12-11 08:57:45 +0100160 struct flt_conf *f;
Christopher Faulet95220e22018-12-07 17:34:39 +0100161 struct cache *cache;
Christopher Faulet27d93c32018-12-15 22:32:02 +0100162 int comp = 0;
Christopher Faulet95220e22018-12-07 17:34:39 +0100163
164 /* resolve the cache name to a ptr in the filter config */
165 list_for_each_entry(cache, &caches, list) {
166 if (!strcmp(cache->id, cconf->c.name)) {
167 /* there can be only one filter per cache, so we free it there */
168 cache->flags |= ((px->options2 & PR_O2_USE_HTX)
169 ? CACHE_F_HTX
170 : CACHE_F_LEGACY_HTTP);
171
172 free(cconf->c.name);
173 cconf->c.cache = cache;
174 goto found;
175 }
176 }
177
178 ha_alert("config: %s '%s': unable to find the cache '%s' referenced by the filter 'cache'.\n",
179 proxy_type_str(px), px->id, (char *)cconf->c.name);
180 return 1;
181
182 found:
Christopher Fauletafd819c2018-12-11 08:57:45 +0100183 /* Here <cache> points on the cache the filter must use and <cconf>
184 * points on the cache filter configuration. */
185
186 /* Check all filters for proxy <px> to know if the compression is
Christopher Faulet27d93c32018-12-15 22:32:02 +0100187 * enabled and if it is after the cache. When the compression is before
188 * the cache, an error is returned. Also check if the cache filter must
189 * be explicitly declaired or not. */
Christopher Fauletafd819c2018-12-11 08:57:45 +0100190 list_for_each_entry(f, &px->filter_configs, list) {
191 if (f == fconf) {
Christopher Faulet27d93c32018-12-15 22:32:02 +0100192 /* The compression filter must be evaluated after the cache. */
193 if (comp) {
194 ha_alert("config: %s '%s': unable to enable the compression filter before "
195 "the cache '%s'.\n", proxy_type_str(px), px->id, cache->id);
196 return 1;
197 }
Christopher Faulet99a17a22018-12-11 09:18:27 +0100198 }
Christopher Faulet27d93c32018-12-15 22:32:02 +0100199 else if (f->id == http_comp_flt_id) {
Christopher Fauletafd819c2018-12-11 08:57:45 +0100200 if (!(px->options2 & PR_O2_USE_HTX)) {
201 ha_alert("config: %s '%s' : compression and cache filters cannot be "
202 "both enabled on non HTX proxy.\n",
203 proxy_type_str(px), px->id);
204 return 1;
205 }
Christopher Faulet27d93c32018-12-15 22:32:02 +0100206 comp = 1;
Christopher Fauletafd819c2018-12-11 08:57:45 +0100207 }
Christopher Faulet27d93c32018-12-15 22:32:02 +0100208 else if ((f->id != fconf->id) && (cconf->flags & CACHE_FLT_F_IMPLICIT_DECL)) {
209 /* Implicit declaration is only allowed with the
210 * compression. For other filters, an implicit
211 * declaration is required. */
212 ha_alert("config: %s '%s': require an explicit filter declaration "
213 "to use the cache '%s'.\n", proxy_type_str(px), px->id, cache->id);
214 return 1;
215 }
216
Christopher Fauletafd819c2018-12-11 08:57:45 +0100217 }
Christopher Faulet95220e22018-12-07 17:34:39 +0100218 return 0;
219}
220
221static int
William Lallemand4da3f8a2017-10-31 14:33:34 +0100222cache_store_chn_start_analyze(struct stream *s, struct filter *filter, struct channel *chn)
223{
224 if (!(chn->flags & CF_ISRESP))
225 return 1;
226
227 if (filter->ctx == NULL) {
228 struct cache_st *st;
229
Willy Tarreaubafbe012017-11-24 17:34:44 +0100230 st = pool_alloc_dirty(pool_head_cache_st);
William Lallemand4da3f8a2017-10-31 14:33:34 +0100231 if (st == NULL)
232 return -1;
233
234 st->hdrs_len = 0;
235 st->first_block = NULL;
236 filter->ctx = st;
Christopher Faulet839791a2019-01-07 16:12:07 +0100237
238 /* Register post-analyzer on AN_RES_WAIT_HTTP */
239 filter->post_analyzers |= AN_RES_WAIT_HTTP;
William Lallemand4da3f8a2017-10-31 14:33:34 +0100240 }
241
William Lallemand4da3f8a2017-10-31 14:33:34 +0100242 return 1;
243}
244
245static int
William Lallemand49dc0482017-11-24 14:33:54 +0100246cache_store_chn_end_analyze(struct stream *s, struct filter *filter, struct channel *chn)
247{
248 struct cache_st *st = filter->ctx;
Christopher Faulet95220e22018-12-07 17:34:39 +0100249 struct cache_flt_conf *cconf = FLT_CONF(filter);
250 struct cache *cache = cconf->c.cache;
William Lallemand49dc0482017-11-24 14:33:54 +0100251 struct shared_context *shctx = shctx_ptr(cache);
252
253 if (!(chn->flags & CF_ISRESP))
254 return 1;
255
256 /* Everything should be released in the http_end filter, but we need to do it
257 * there too, in case of errors */
258
259 if (st && st->first_block) {
260
261 shctx_lock(shctx);
262 shctx_row_dec_hot(shctx, st->first_block);
263 shctx_unlock(shctx);
264
265 }
266 if (st) {
Willy Tarreaubafbe012017-11-24 17:34:44 +0100267 pool_free(pool_head_cache_st, st);
William Lallemand49dc0482017-11-24 14:33:54 +0100268 filter->ctx = NULL;
269 }
270
271 return 1;
272}
273
Christopher Faulet839791a2019-01-07 16:12:07 +0100274static int
275cache_store_post_analyze(struct stream *s, struct filter *filter, struct channel *chn,
276 unsigned an_bit)
277{
278 struct http_txn *txn = s->txn;
279 struct http_msg *msg = &txn->rsp;
280 struct cache_st *st = filter->ctx;
281
282 if (an_bit != AN_RES_WAIT_HTTP)
283 goto end;
284
285 /* Here we need to check if any compression filter precedes the cache
286 * filter. This is only possible when the compression is configured in
287 * the frontend while the cache filter is configured on the
288 * backend. This case cannot be detected during HAProxy startup. So in
289 * such cases, the cache is disabled.
290 */
291 if (st && (msg->flags & HTTP_MSGF_COMPRESSING)) {
292 pool_free(pool_head_cache_st, st);
293 filter->ctx = NULL;
294 }
295
296 end:
297 return 1;
298}
William Lallemand49dc0482017-11-24 14:33:54 +0100299
300static int
William Lallemand4da3f8a2017-10-31 14:33:34 +0100301cache_store_http_headers(struct stream *s, struct filter *filter, struct http_msg *msg)
302{
303 struct cache_st *st = filter->ctx;
304
William Lallemand4da3f8a2017-10-31 14:33:34 +0100305 if (!(msg->chn->flags & CF_ISRESP) || !st)
306 return 1;
307
Christopher Faulet67658c92018-12-06 21:59:39 +0100308 if (st->first_block) {
309 register_data_filter(s, msg->chn, filter);
Christopher Faulet54a8d5a2018-12-07 12:21:11 +0100310 if (!IS_HTX_STRM(s))
311 st->hdrs_len = msg->sov;
Christopher Faulet67658c92018-12-06 21:59:39 +0100312 }
William Lallemand4da3f8a2017-10-31 14:33:34 +0100313 return 1;
314}
315
Frédéric Lécaille8df65ae2018-10-22 18:01:48 +0200316static inline void disable_cache_entry(struct cache_st *st,
317 struct filter *filter, struct shared_context *shctx)
318{
319 struct cache_entry *object;
320
321 object = (struct cache_entry *)st->first_block->data;
322 filter->ctx = NULL; /* disable cache */
323 shctx_lock(shctx);
324 shctx_row_dec_hot(shctx, st->first_block);
325 object->eb.key = 0;
326 shctx_unlock(shctx);
327 pool_free(pool_head_cache_st, st);
328}
329
William Lallemand4da3f8a2017-10-31 14:33:34 +0100330static int
Christopher Faulet54a8d5a2018-12-07 12:21:11 +0100331cache_store_http_payload(struct stream *s, struct filter *filter, struct http_msg *msg,
332 unsigned int offset, unsigned int len)
333{
Christopher Faulet95220e22018-12-07 17:34:39 +0100334 struct cache_flt_conf *cconf = FLT_CONF(filter);
335 struct shared_context *shctx = shctx_ptr(cconf->c.cache);
Christopher Faulet54a8d5a2018-12-07 12:21:11 +0100336 struct cache_st *st = filter->ctx;
337 struct htx *htx = htxbuf(&msg->chn->buf);
338 struct htx_blk *blk;
339 struct htx_ret htx_ret;
340 struct cache_entry *object;
341 int ret, to_forward = 0;
342
343 if (!len)
344 return len;
345
346 if (!st->first_block) {
347 unregister_data_filter(s, msg->chn, filter);
348 return len;
349 }
350 object = (struct cache_entry *)st->first_block->data;
351
352 htx_ret = htx_find_blk(htx, offset);
353 blk = htx_ret.blk;
354 offset = htx_ret.ret;
355
356 while (blk && len) {
357 struct shared_block *fb;
358 enum htx_blk_type type = htx_get_blk_type(blk);
359 uint32_t sz = htx_get_blksz(blk);
360 struct ist v;
361
362 switch (type) {
363 case HTX_BLK_UNUSED:
364 break;
365
366 case HTX_BLK_DATA:
367 case HTX_BLK_TLR:
368 v = htx_get_blk_value(htx, blk);
369 v.ptr += offset;
370 v.len -= offset;
371 if (v.len > len)
372 v.len = len;
373
374 shctx_lock(shctx);
375 fb = shctx_row_reserve_hot(shctx, st->first_block, v.len);
376 if (!fb) {
377 shctx_unlock(shctx);
378 goto no_cache;
379 }
380 shctx_unlock(shctx);
381
382 ret = shctx_row_data_append(shctx, st->first_block, st->first_block->last_append,
383 (unsigned char *)v.ptr, v.len);
384 if (ret < 0)
385 goto no_cache;
386
387 if (type == HTX_BLK_DATA)
388 object->data_len += v.len;
389 to_forward += v.len;
390 len -= v.len;
391 break;
392
393 default:
394 sz -= offset;
395 if (sz > len)
396 sz = len;
397 to_forward += sz;
398 len -= sz;
399 break;
400 }
401
402 offset = 0;
403 blk = htx_get_next_blk(htx, blk);
404 }
405
406 return to_forward;
407
408 no_cache:
409 disable_cache_entry(st, filter, shctx);
410 unregister_data_filter(s, msg->chn, filter);
411 return len;
412}
413
414static int
William Lallemand4da3f8a2017-10-31 14:33:34 +0100415cache_store_http_forward_data(struct stream *s, struct filter *filter,
416 struct http_msg *msg, unsigned int len)
417{
418 struct cache_st *st = filter->ctx;
Christopher Faulet95220e22018-12-07 17:34:39 +0100419 struct cache_flt_conf *cconf = FLT_CONF(filter);
420 struct shared_context *shctx = shctx_ptr(cconf->c.cache);
William Lallemand4da3f8a2017-10-31 14:33:34 +0100421 int ret;
422
Frédéric Lécaille8df65ae2018-10-22 18:01:48 +0200423 ret = 0;
424
William Lallemand4da3f8a2017-10-31 14:33:34 +0100425 /*
426 * We need to skip the HTTP headers first, because we saved them in the
427 * http-response action.
428 */
Christopher Faulet67658c92018-12-06 21:59:39 +0100429 if (!(msg->chn->flags & CF_ISRESP) || !st) {
430 /* should never happen */
431 unregister_data_filter(s, msg->chn, filter);
William Lallemand4da3f8a2017-10-31 14:33:34 +0100432 return len;
Christopher Faulet67658c92018-12-06 21:59:39 +0100433 }
William Lallemand4da3f8a2017-10-31 14:33:34 +0100434
435 if (!len) {
Joseph Herlant8dae5b32018-11-15 14:07:53 -0800436 /* Nothing to forward */
William Lallemand4da3f8a2017-10-31 14:33:34 +0100437 ret = len;
438 }
William Lallemand10935bc2017-11-14 14:39:23 +0100439 else if (st->hdrs_len >= len) {
William Lallemand4da3f8a2017-10-31 14:33:34 +0100440 /* Forward part of headers */
441 ret = len;
442 st->hdrs_len -= len;
443 }
William Lallemand4da3f8a2017-10-31 14:33:34 +0100444 else {
William Lallemand10935bc2017-11-14 14:39:23 +0100445 /* Forward data */
Christopher Faulet67658c92018-12-06 21:59:39 +0100446 if (st->first_block) {
Frédéric Lécaille8df65ae2018-10-22 18:01:48 +0200447 int to_append, append;
448 struct shared_block *fb;
449
450 to_append = MIN(ci_contig_data(msg->chn), len - st->hdrs_len);
451
Frédéric Lécaille8df65ae2018-10-22 18:01:48 +0200452 shctx_lock(shctx);
453 fb = shctx_row_reserve_hot(shctx, st->first_block, to_append);
454 if (!fb) {
Olivier Houchardcd2867a2017-11-01 13:58:21 +0100455 shctx_unlock(shctx);
Frédéric Lécaille8df65ae2018-10-22 18:01:48 +0200456 disable_cache_entry(st, filter, shctx);
Christopher Faulet67658c92018-12-06 21:59:39 +0100457 unregister_data_filter(s, msg->chn, filter);
Frédéric Lécaille8df65ae2018-10-22 18:01:48 +0200458 return len;
William Lallemand4da3f8a2017-10-31 14:33:34 +0100459 }
Frédéric Lécaille8df65ae2018-10-22 18:01:48 +0200460 shctx_unlock(shctx);
461
Frédéric Lécaillea2219f52018-10-22 16:59:13 +0200462 /* Skip remaining headers to fill the cache */
463 c_adv(msg->chn, st->hdrs_len);
Frédéric Lécaille8df65ae2018-10-22 18:01:48 +0200464 append = shctx_row_data_append(shctx, st->first_block, st->first_block->last_append,
465 (unsigned char *)ci_head(msg->chn), to_append);
466 ret = st->hdrs_len + to_append - append;
467 /* Rewind the buffer to forward all data */
468 c_rew(msg->chn, st->hdrs_len);
469 st->hdrs_len = 0;
Christopher Faulet67658c92018-12-06 21:59:39 +0100470 if (ret < 0) {
Frédéric Lécaille8df65ae2018-10-22 18:01:48 +0200471 disable_cache_entry(st, filter, shctx);
Christopher Faulet67658c92018-12-06 21:59:39 +0100472 unregister_data_filter(s, msg->chn, filter);
473 }
William Lallemand4da3f8a2017-10-31 14:33:34 +0100474 }
Christopher Faulet67658c92018-12-06 21:59:39 +0100475 else {
476 /* should never happen */
477 unregister_data_filter(s, msg->chn, filter);
Frédéric Lécaille8df65ae2018-10-22 18:01:48 +0200478 ret = len;
Christopher Faulet67658c92018-12-06 21:59:39 +0100479 }
William Lallemand4da3f8a2017-10-31 14:33:34 +0100480 }
481
482 if ((ret != len) ||
483 (FLT_NXT(filter, msg->chn) != FLT_FWD(filter, msg->chn) + ret))
484 task_wakeup(s->task, TASK_WOKEN_MSG);
485
486 return ret;
487}
488
489static int
490cache_store_http_end(struct stream *s, struct filter *filter,
491 struct http_msg *msg)
492{
493 struct cache_st *st = filter->ctx;
Christopher Faulet95220e22018-12-07 17:34:39 +0100494 struct cache_flt_conf *cconf = FLT_CONF(filter);
495 struct cache *cache = cconf->c.cache;
William Lallemand4da3f8a2017-10-31 14:33:34 +0100496 struct shared_context *shctx = shctx_ptr(cache);
497 struct cache_entry *object;
498
499 if (!(msg->chn->flags & CF_ISRESP))
500 return 1;
501
502 if (st && st->first_block) {
503
504 object = (struct cache_entry *)st->first_block->data;
505
506 /* does not need to test if the insertion worked, if it
507 * doesn't, the blocks will be reused anyway */
508
509 shctx_lock(shctx);
William Lallemand08727662017-11-21 20:01:27 +0100510 if (eb32_insert(&cache->entries, &object->eb) != &object->eb) {
511 object->eb.key = 0;
512 }
William Lallemand4da3f8a2017-10-31 14:33:34 +0100513 /* remove from the hotlist */
William Lallemand4da3f8a2017-10-31 14:33:34 +0100514 shctx_row_dec_hot(shctx, st->first_block);
515 shctx_unlock(shctx);
516
517 }
518 if (st) {
Willy Tarreaubafbe012017-11-24 17:34:44 +0100519 pool_free(pool_head_cache_st, st);
William Lallemand4da3f8a2017-10-31 14:33:34 +0100520 filter->ctx = NULL;
521 }
522
523 return 1;
524}
525
526 /*
527 * This intends to be used when checking HTTP headers for some
528 * word=value directive. Return a pointer to the first character of value, if
529 * the word was not found or if there wasn't any value assigned ot it return NULL
530 */
531char *directive_value(const char *sample, int slen, const char *word, int wlen)
532{
533 int st = 0;
534
535 if (slen < wlen)
536 return 0;
537
538 while (wlen) {
539 char c = *sample ^ *word;
540 if (c && c != ('A' ^ 'a'))
541 return NULL;
542 sample++;
543 word++;
544 slen--;
545 wlen--;
546 }
547
548 while (slen) {
549 if (st == 0) {
550 if (*sample != '=')
551 return NULL;
552 sample++;
553 slen--;
554 st = 1;
555 continue;
556 } else {
557 return (char *)sample;
558 }
559 }
560
561 return NULL;
562}
563
564/*
565 * Return the maxage in seconds of an HTTP response.
566 * Compute the maxage using either:
567 * - the assigned max-age of the cache
568 * - the s-maxage directive
569 * - the max-age directive
570 * - (Expires - Data) headers
571 * - the default-max-age of the cache
572 *
573 */
William Lallemand49b44532017-11-24 18:53:43 +0100574int http_calc_maxage(struct stream *s, struct cache *cache)
William Lallemand4da3f8a2017-10-31 14:33:34 +0100575{
576 struct http_txn *txn = s->txn;
577 struct hdr_ctx ctx;
578
579 int smaxage = -1;
580 int maxage = -1;
581
582
William Lallemand4da3f8a2017-10-31 14:33:34 +0100583 ctx.idx = 0;
584
585 /* loop on the Cache-Control values */
Willy Tarreau178b9872018-06-19 07:13:36 +0200586 while (http_find_header2("Cache-Control", 13, ci_head(&s->res), &txn->hdr_idx, &ctx)) {
William Lallemand4da3f8a2017-10-31 14:33:34 +0100587 char *directive = ctx.line + ctx.val;
588 char *value;
589
590 value = directive_value(directive, ctx.vlen, "s-maxage", 8);
591 if (value) {
Willy Tarreau83061a82018-07-13 11:56:34 +0200592 struct buffer *chk = get_trash_chunk();
William Lallemand4da3f8a2017-10-31 14:33:34 +0100593
594 chunk_strncat(chk, value, ctx.vlen - 8 + 1);
595 chunk_strncat(chk, "", 1);
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200596 maxage = atoi(chk->area);
William Lallemand4da3f8a2017-10-31 14:33:34 +0100597 }
598
599 value = directive_value(ctx.line + ctx.val, ctx.vlen, "max-age", 7);
600 if (value) {
Willy Tarreau83061a82018-07-13 11:56:34 +0200601 struct buffer *chk = get_trash_chunk();
William Lallemand4da3f8a2017-10-31 14:33:34 +0100602
603 chunk_strncat(chk, value, ctx.vlen - 7 + 1);
604 chunk_strncat(chk, "", 1);
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200605 smaxage = atoi(chk->area);
William Lallemand4da3f8a2017-10-31 14:33:34 +0100606 }
607 }
608
609 /* TODO: Expires - Data */
610
611
612 if (smaxage > 0)
William Lallemand49b44532017-11-24 18:53:43 +0100613 return MIN(smaxage, cache->maxage);
William Lallemand4da3f8a2017-10-31 14:33:34 +0100614
615 if (maxage > 0)
William Lallemand49b44532017-11-24 18:53:43 +0100616 return MIN(maxage, cache->maxage);
William Lallemand4da3f8a2017-10-31 14:33:34 +0100617
William Lallemand49b44532017-11-24 18:53:43 +0100618 return cache->maxage;
William Lallemand4da3f8a2017-10-31 14:33:34 +0100619
620}
621
622
William Lallemanda400a3a2017-11-20 19:13:12 +0100623static void cache_free_blocks(struct shared_block *first, struct shared_block *block)
624{
Willy Tarreau5bd37fa2018-04-04 20:17:03 +0200625 struct cache_entry *object = (struct cache_entry *)block->data;
626
627 if (first == block && object->eb.key)
628 eb32_delete(&object->eb);
629 object->eb.key = 0;
William Lallemanda400a3a2017-11-20 19:13:12 +0100630}
631
William Lallemand41db4602017-10-30 11:15:51 +0100632/*
633 * This fonction will store the headers of the response in a buffer and then
634 * register a filter to store the data
635 */
636enum act_return http_action_store_cache(struct act_rule *rule, struct proxy *px,
637 struct session *sess, struct stream *s, int flags)
638{
Frédéric Lécaillee7a770c2018-10-26 14:29:22 +0200639 unsigned int age;
640 long long hdr_age;
William Lallemand4da3f8a2017-10-31 14:33:34 +0100641 struct http_txn *txn = s->txn;
642 struct http_msg *msg = &txn->rsp;
643 struct filter *filter;
William Lallemand4da3f8a2017-10-31 14:33:34 +0100644 struct shared_block *first = NULL;
Christopher Faulet95220e22018-12-07 17:34:39 +0100645 struct cache_flt_conf *cconf = rule->arg.act.p[0];
646 struct shared_context *shctx = shctx_ptr(cconf->c.cache);
Christopher Faulet839791a2019-01-07 16:12:07 +0100647 struct cache_st *cache_ctx = NULL;
648 struct cache_entry *object, *old;
Willy Tarreauc9036c02019-01-11 19:38:25 +0100649 unsigned int key = *(unsigned int *)txn->cache_hash;
William Lallemand4da3f8a2017-10-31 14:33:34 +0100650
William Lallemand4da3f8a2017-10-31 14:33:34 +0100651 /* Don't cache if the response came from a cache */
652 if ((obj_type(s->target) == OBJ_TYPE_APPLET) &&
653 s->target == &http_cache_applet.obj_type) {
654 goto out;
655 }
656
657 /* cache only HTTP/1.1 */
658 if (!(txn->req.flags & HTTP_MSGF_VER_11))
659 goto out;
660
661 /* cache only GET method */
662 if (txn->meth != HTTP_METH_GET)
663 goto out;
664
Willy Tarreauc9036c02019-01-11 19:38:25 +0100665 /* cache key was not computed */
666 if (!key)
667 goto out;
668
William Lallemand4da3f8a2017-10-31 14:33:34 +0100669 /* cache only 200 status code */
670 if (txn->status != 200)
671 goto out;
672
Christopher Faulet839791a2019-01-07 16:12:07 +0100673 /* Find the corresponding filter instance for the current stream */
674 list_for_each_entry(filter, &s->strm_flt.filters, list) {
675 if (FLT_ID(filter) == cache_store_flt_id && FLT_CONF(filter) == cconf) {
676 /* No filter ctx, don't cache anything */
677 if (!filter->ctx)
678 goto out;
679 cache_ctx = filter->ctx;
680 break;
681 }
682 }
683
684 /* from there, cache_ctx is always defined */
685
Christopher Faulet54a8d5a2018-12-07 12:21:11 +0100686 if (IS_HTX_STRM(s)) {
687 struct htx *htx = htxbuf(&s->res.buf);
688 struct http_hdr_ctx ctx;
689 int32_t pos;
William Lallemand4da3f8a2017-10-31 14:33:34 +0100690
Christopher Faulet54a8d5a2018-12-07 12:21:11 +0100691 /* Do not cache too big objects. */
692 if ((msg->flags & HTTP_MSGF_CNT_LEN) && shctx->max_obj_size > 0 &&
693 htx->data + htx->extra > shctx->max_obj_size)
694 goto out;
William Lallemand4da3f8a2017-10-31 14:33:34 +0100695
Christopher Faulet54a8d5a2018-12-07 12:21:11 +0100696 /* Does not manage Vary at the moment. We will need a secondary key later for that */
697 ctx.blk = NULL;
698 if (http_find_header(htx, ist("Vary"), &ctx, 0))
699 goto out;
William Lallemand4da3f8a2017-10-31 14:33:34 +0100700
Christopher Faulet54a8d5a2018-12-07 12:21:11 +0100701 htx_check_response_for_cacheability(s, &s->res);
702
703 if (!(txn->flags & TX_CACHEABLE) || !(txn->flags & TX_CACHE_COOK))
704 goto out;
705
706 age = 0;
707 ctx.blk = NULL;
708 if (http_find_header(htx, ist("Age"), &ctx, 0)) {
709 if (!strl2llrc(ctx.value.ptr, ctx.value.len, &hdr_age) && hdr_age > 0) {
710 if (unlikely(hdr_age > CACHE_ENTRY_MAX_AGE))
711 hdr_age = CACHE_ENTRY_MAX_AGE;
712 age = hdr_age;
713 }
714 http_remove_header(htx, &ctx);
715 }
716
717 chunk_reset(&trash);
718 for (pos = htx_get_head(htx); pos != -1; pos = htx_get_next(htx, pos)) {
719 struct htx_blk *blk = htx_get_blk(htx, pos);
Christopher Fauletafd819c2018-12-11 08:57:45 +0100720 enum htx_blk_type type = htx_get_blk_type(blk);
Christopher Faulet54a8d5a2018-12-07 12:21:11 +0100721 uint32_t sz = htx_get_blksz(blk);
722
723 chunk_memcat(&trash, (char *)&blk->info, sizeof(blk->info));
Christopher Fauletafd819c2018-12-11 08:57:45 +0100724 if (type == HTX_BLK_EOH)
Christopher Faulet54a8d5a2018-12-07 12:21:11 +0100725 break;
726 chunk_memcat(&trash, htx_get_blk_ptr(htx, blk), sz);
727 }
728 }
729 else {
730 struct hdr_ctx ctx;
731
732 /* Do not cache too big objects. */
733 if ((msg->flags & HTTP_MSGF_CNT_LEN) && shctx->max_obj_size > 0 &&
734 msg->sov + msg->body_len > shctx->max_obj_size)
735 goto out;
736
737 /* Does not manage Vary at the moment. We will need a secondary key later for that */
738 ctx.idx = 0;
739 if (http_find_header2("Vary", 4, ci_head(txn->rsp.chn), &txn->hdr_idx, &ctx))
740 goto out;
741
742 check_response_for_cacheability(s, &s->res);
743
744 if (!(txn->flags & TX_CACHEABLE) || !(txn->flags & TX_CACHE_COOK))
745 goto out;
746
747 age = 0;
748 ctx.idx = 0;
749 if (http_find_header2("Age", 3, ci_head(txn->rsp.chn), &txn->hdr_idx, &ctx)) {
750 if (!strl2llrc(ctx.line + ctx.val, ctx.vlen, &hdr_age) && hdr_age > 0) {
751 if (unlikely(hdr_age > CACHE_ENTRY_MAX_AGE))
752 hdr_age = CACHE_ENTRY_MAX_AGE;
753 age = hdr_age;
754 }
755 http_remove_header2(msg, &txn->hdr_idx, &ctx);
Frédéric Lécaillee7a770c2018-10-26 14:29:22 +0200756 }
Frédéric Lécaillee7a770c2018-10-26 14:29:22 +0200757 }
758
William Lallemand4da3f8a2017-10-31 14:33:34 +0100759 shctx_lock(shctx);
Christopher Faulet54a8d5a2018-12-07 12:21:11 +0100760 if (IS_HTX_STRM(s))
761 first = shctx_row_reserve_hot(shctx, NULL, sizeof(struct cache_entry) + trash.data);
762 else
763 first = shctx_row_reserve_hot(shctx, NULL, sizeof(struct cache_entry) + msg->sov);
William Lallemand4da3f8a2017-10-31 14:33:34 +0100764 if (!first) {
765 shctx_unlock(shctx);
766 goto out;
767 }
768 shctx_unlock(shctx);
769
Willy Tarreau1093a452018-04-06 19:02:25 +0200770 /* the received memory is not initialized, we need at least to mark
771 * the object as not indexed yet.
772 */
773 object = (struct cache_entry *)first->data;
774 object->eb.node.leaf_p = NULL;
775 object->eb.key = 0;
Frédéric Lécaillee7a770c2018-10-26 14:29:22 +0200776 object->age = age;
Christopher Faulet54a8d5a2018-12-07 12:21:11 +0100777 if (IS_HTX_STRM(s)) {
778 object->hdrs_len = trash.data;
779 object->data_len = 0;
780 }
781 else
782 object->eoh = msg->eoh;
Willy Tarreau1093a452018-04-06 19:02:25 +0200783
William Lallemand4da3f8a2017-10-31 14:33:34 +0100784 /* reserve space for the cache_entry structure */
785 first->len = sizeof(struct cache_entry);
Frédéric Lécaille8df65ae2018-10-22 18:01:48 +0200786 first->last_append = NULL;
William Lallemand4da3f8a2017-10-31 14:33:34 +0100787 /* cache the headers in a http action because it allows to chose what
788 * to cache, for example you might want to cache a response before
789 * modifying some HTTP headers, or on the contrary after modifying
790 * those headers.
791 */
792
793 /* does not need to be locked because it's in the "hot" list,
794 * copy the headers */
Christopher Faulet54a8d5a2018-12-07 12:21:11 +0100795 if (IS_HTX_STRM(s)) {
796 if (shctx_row_data_append(shctx, first, NULL, (unsigned char *)trash.area, trash.data) < 0)
797 goto out;
798 }
799 else {
800 if (shctx_row_data_append(shctx, first, NULL, (unsigned char *)ci_head(&s->res), msg->sov) < 0)
801 goto out;
802 }
William Lallemand4da3f8a2017-10-31 14:33:34 +0100803
804 /* register the buffer in the filter ctx for filling it with data*/
Christopher Faulet839791a2019-01-07 16:12:07 +0100805 if (cache_ctx) {
806 cache_ctx->first_block = first;
William Lallemand4da3f8a2017-10-31 14:33:34 +0100807
Willy Tarreauc9036c02019-01-11 19:38:25 +0100808 object->eb.key = key;
809
Christopher Faulet839791a2019-01-07 16:12:07 +0100810 memcpy(object->hash, txn->cache_hash, sizeof(object->hash));
811 /* Insert the node later on caching success */
William Lallemand4da3f8a2017-10-31 14:33:34 +0100812
Christopher Faulet839791a2019-01-07 16:12:07 +0100813 shctx_lock(shctx);
Christopher Faulet95220e22018-12-07 17:34:39 +0100814
Christopher Faulet839791a2019-01-07 16:12:07 +0100815 old = entry_exist(cconf->c.cache, txn->cache_hash);
816 if (old) {
817 eb32_delete(&old->eb);
818 old->eb.key = 0;
William Lallemand4da3f8a2017-10-31 14:33:34 +0100819 }
Christopher Faulet839791a2019-01-07 16:12:07 +0100820 shctx_unlock(shctx);
821
822 /* store latest value and expiration time */
823 object->latest_validation = now.tv_sec;
824 object->expire = now.tv_sec + http_calc_maxage(s, cconf->c.cache);
825 return ACT_RET_CONT;
William Lallemand4da3f8a2017-10-31 14:33:34 +0100826 }
827
828out:
829 /* if does not cache */
830 if (first) {
831 shctx_lock(shctx);
William Lallemand08727662017-11-21 20:01:27 +0100832 first->len = 0;
833 object->eb.key = 0;
William Lallemand4da3f8a2017-10-31 14:33:34 +0100834 shctx_row_dec_hot(shctx, first);
835 shctx_unlock(shctx);
836 }
837
William Lallemand41db4602017-10-30 11:15:51 +0100838 return ACT_RET_CONT;
839}
840
Frédéric Lécaillee7a770c2018-10-26 14:29:22 +0200841#define HTTP_CACHE_INIT 0 /* Initial state. */
842#define HTTP_CACHE_HEADER 1 /* Cache entry headers forwarded. */
843#define HTTP_CACHE_FWD 2 /* Cache entry completely forwarded. */
844#define HTTP_CACHE_END 3 /* Cache entry treatment terminated. */
William Lallemand77c11972017-10-31 20:43:01 +0100845
Christopher Faulet54a8d5a2018-12-07 12:21:11 +0100846#define HTX_CACHE_INIT 0 /* Initial state. */
847#define HTX_CACHE_HEADER 1 /* Cache entry headers forwarding */
848#define HTX_CACHE_DATA 2 /* Cache entry data forwarding */
849#define HTX_CACHE_EOD 3 /* Cache entry data forwarded. DATA->TLR transition */
850#define HTX_CACHE_TLR 4 /* Cache entry trailers forwarding */
851#define HTX_CACHE_EOM 5 /* Cache entry completely forwarded. Finish the HTX message */
852#define HTX_CACHE_END 6 /* Cache entry treatment terminated */
853
William Lallemandecb73b12017-11-24 14:33:55 +0100854static void http_cache_applet_release(struct appctx *appctx)
855{
Christopher Faulet95220e22018-12-07 17:34:39 +0100856 struct cache_flt_conf *cconf = appctx->rule->arg.act.p[0];
William Lallemandecb73b12017-11-24 14:33:55 +0100857 struct cache_entry *cache_ptr = appctx->ctx.cache.entry;
Christopher Faulet95220e22018-12-07 17:34:39 +0100858 struct cache *cache = cconf->c.cache;
William Lallemandecb73b12017-11-24 14:33:55 +0100859 struct shared_block *first = block_ptr(cache_ptr);
860
861 shctx_lock(shctx_ptr(cache));
862 shctx_row_dec_hot(shctx_ptr(cache), first);
863 shctx_unlock(shctx_ptr(cache));
864}
865
Christopher Faulet54a8d5a2018-12-07 12:21:11 +0100866static size_t htx_cache_dump_headers(struct appctx *appctx, struct htx *htx)
867{
Christopher Faulet95220e22018-12-07 17:34:39 +0100868 struct cache_flt_conf *cconf = appctx->rule->arg.act.p[0];
869 struct shared_context *shctx = shctx_ptr(cconf->c.cache);
Christopher Faulet54a8d5a2018-12-07 12:21:11 +0100870 struct cache_entry *cache_ptr = appctx->ctx.cache.entry;
871 struct shared_block *shblk = appctx->ctx.cache.next;
872 struct buffer *tmp = get_trash_chunk();
873 char *end;
874 unsigned int offset, len, age;
875
876 offset = appctx->ctx.cache.offset;
877 len = cache_ptr->hdrs_len;
878
879 /* 1. Retrieve all headers from the cache */
880 list_for_each_entry_from(shblk, &shctx->hot, list) {
881 int sz;
882
883 sz = MIN(len, shctx->block_size - offset);
884 if (!chunk_memcat(tmp, (const char *)shblk->data + offset, sz))
885 return 0;
886
887 offset += sz;
888 len -= sz;
889 if (!len)
890 break;
891 offset = 0;
892 }
893 appctx->ctx.cache.offset = offset;
894 appctx->ctx.cache.next = shblk;
895 appctx->ctx.cache.sent += b_data(tmp);
896
897 /* 2. push these headers in the HTX message */
898 offset = 0;
899 while (offset < b_data(tmp)) {
900 struct htx_blk *blk;
901 enum htx_blk_type type;
902 uint32_t info, sz;
903
904 /* Read the header's info */
905 memcpy((char *)&info, b_peek(tmp, offset), 4);
906 type = (info >> 28);
907 sz = ((type == HTX_BLK_HDR)
908 ? (info & 0xff) + ((info >> 8) & 0xfffff)
909 : info & 0xfffffff);
910
911 /* Create the block with the right type and the right size */
912 blk = htx_add_blk(htx, type, sz);
913 if (!blk)
914 return 0;
915
Christopher Fauleta0df9572019-02-25 11:15:08 +0100916 /* Set the start-line offset */
917 if (type == HTX_BLK_RES_SL)
918 htx->sl_off = blk->addr;
919
Christopher Faulet54a8d5a2018-12-07 12:21:11 +0100920 /* Copy info and data */
921 blk->info = info;
922 memcpy(htx_get_blk_ptr(htx, blk), b_peek(tmp, offset+4), sz);
923
924 /* next header */
925 offset += 4 + sz;
926 }
927
928 /* 3. Append "age" header */
929 chunk_reset(tmp);
930 age = MAX(0, (int)(now.tv_sec - cache_ptr->latest_validation)) + cache_ptr->age;
931 if (unlikely(age > CACHE_ENTRY_MAX_AGE))
932 age = CACHE_ENTRY_MAX_AGE;
933 end = ultoa_o(age, b_head(tmp), b_size(tmp));
934 b_set_data(tmp, end - b_head(tmp));
935
936 if (!http_add_header(htx, ist("Age"), ist2(b_head(tmp), b_data(tmp))))
937 return 0;
938
939 return htx->data;
940}
941
942static size_t htx_cache_dump_data(struct appctx *appctx, struct htx *htx,
943 enum htx_blk_type type, unsigned int len)
944{
Christopher Faulet95220e22018-12-07 17:34:39 +0100945 struct cache_flt_conf *cconf = appctx->rule->arg.act.p[0];
946 struct shared_context *shctx = shctx_ptr(cconf->c.cache);
Christopher Faulet54a8d5a2018-12-07 12:21:11 +0100947 struct shared_block *shblk = appctx->ctx.cache.next;
Christopher Fauletcc156622019-01-07 14:07:29 +0100948 uint32_t max = channel_htx_recv_max(si_ic(appctx->owner), htx);
Christopher Faulet54a8d5a2018-12-07 12:21:11 +0100949 unsigned int offset;
950 size_t total = 0;
951
952 offset = appctx->ctx.cache.offset;
953 if (len > max)
954 len = max;
955 if (!len)
956 goto end;
957
958 list_for_each_entry_from(shblk, &shctx->hot, list) {
959 struct ist data;
960 int sz;
961
962 sz = MIN(len, shctx->block_size - offset);
963 data = ist2((const char *)shblk->data + offset, sz);
964 if (type == HTX_BLK_DATA) {
965 if (!htx_add_data(htx, data))
966 break;
967 }
968 else { /* HTX_BLK_TLR */
969 if (!htx_add_trailer(htx, data))
970 break;
971 }
972
973 offset += sz;
974 len -= sz;
975 total += sz;
976 if (!len)
977 break;
978 offset = 0;
979 }
980 appctx->ctx.cache.offset = offset;
981 appctx->ctx.cache.next = shblk;
982 appctx->ctx.cache.sent += total;
983
984 end:
985 return total;
986}
987static void htx_cache_io_handler(struct appctx *appctx)
988{
989 struct cache_entry *cache_ptr = appctx->ctx.cache.entry;
990 struct shared_block *first = block_ptr(cache_ptr);
991 struct stream_interface *si = appctx->owner;
992 struct channel *req = si_oc(si);
993 struct channel *res = si_ic(si);
994 struct htx *req_htx, *res_htx;
995 struct buffer *errmsg;
996 size_t ret, total = 0;
997
998 res_htx = htxbuf(&res->buf);
999
1000 if (unlikely(si->state == SI_ST_DIS || si->state == SI_ST_CLO))
1001 goto out;
1002
1003 /* Check if the input buffer is avalaible. */
1004 if (!b_size(&res->buf)) {
1005 si_rx_room_blk(si);
1006 goto out;
1007 }
1008
Willy Tarreauefef3232018-12-16 00:37:45 +01001009 if (res->flags & (CF_SHUTW|CF_SHUTR|CF_SHUTW_NOW))
Willy Tarreau273e9642018-12-16 00:35:15 +01001010 appctx->st0 = HTX_CACHE_END;
Christopher Faulet54a8d5a2018-12-07 12:21:11 +01001011
1012 if (appctx->st0 == HTX_CACHE_INIT) {
1013 appctx->ctx.cache.next = block_ptr(cache_ptr);
1014 appctx->ctx.cache.offset = sizeof(*cache_ptr);
1015 appctx->ctx.cache.sent = 0;
1016 appctx->st0 = HTX_CACHE_HEADER;
1017 }
1018
1019 if (appctx->st0 == HTX_CACHE_HEADER) {
1020 /* Headers must be dump at once. Otherwise it is an error */
1021 ret = htx_cache_dump_headers(appctx, res_htx);
1022 if (!ret)
1023 goto error;
1024
1025 total += ret;
Christopher Fauletf0dd0372019-02-25 11:08:34 +01001026 if (si_strm(si)->txn->meth == HTTP_METH_HEAD) {
1027 /* Skip response body for HEAD requests */
1028 appctx->st0 = HTX_CACHE_EOM;
1029 }
1030 else if (cache_ptr->data_len)
Christopher Faulet54a8d5a2018-12-07 12:21:11 +01001031 appctx->st0 = HTX_CACHE_DATA;
1032 else if (first->len > sizeof(*cache_ptr) + appctx->ctx.cache.sent) {
1033 /* Headers have benn sent (hrds_len) and there is no data
1034 * (data_len == 0). So, all the remaining is the
1035 * trailers */
1036 appctx->st0 = HTX_CACHE_EOD;
1037 }
1038 else
1039 appctx->st0 = HTX_CACHE_EOM;
1040 }
1041
1042 if (appctx->st0 == HTX_CACHE_DATA) {
1043 unsigned int len = cache_ptr->hdrs_len + cache_ptr->data_len - appctx->ctx.cache.sent;
1044
1045 ret = htx_cache_dump_data(appctx, res_htx, HTX_BLK_DATA, len);
Christopher Faulet61123912019-01-02 14:10:01 +01001046 total += ret;
1047 res_htx->extra = (len - ret);
1048 if (ret < len) {
Christopher Faulet54a8d5a2018-12-07 12:21:11 +01001049 si_rx_room_blk(si);
1050 goto out;
1051 }
1052
Christopher Faulet54a8d5a2018-12-07 12:21:11 +01001053 if (cache_ptr->hdrs_len + cache_ptr->data_len == appctx->ctx.cache.sent) {
1054 if (first->len > sizeof(*cache_ptr) + appctx->ctx.cache.sent) {
1055 /* Headers and all data have been sent
1056 * (hrds_len + data_len == sent). So, all the remaining
1057 * is the trailers */
1058 appctx->st0 = HTX_CACHE_EOD;
1059 }
1060 else
1061 appctx->st0 = HTX_CACHE_EOM;
1062 }
1063 }
1064
1065 if (appctx->st0 == HTX_CACHE_EOD) {
1066 if (!htx_add_endof(res_htx, HTX_BLK_EOD)) {
1067 si_rx_room_blk(si);
1068 goto out;
1069 }
1070
1071 total++;
1072 appctx->st0 = HTX_CACHE_TLR;
1073 }
1074
1075 if (appctx->st0 == HTX_CACHE_TLR) {
1076 unsigned int len = first->len - sizeof(*cache_ptr) - appctx->ctx.cache.sent;
1077
1078 ret = htx_cache_dump_data(appctx, res_htx, HTX_BLK_TLR, len);
Christopher Faulet74b41ba2019-01-04 16:15:34 +01001079 total += ret;
Christopher Faulet61123912019-01-02 14:10:01 +01001080 if (ret < len) {
Christopher Faulet54a8d5a2018-12-07 12:21:11 +01001081 si_rx_room_blk(si);
1082 goto out;
1083 }
1084
Christopher Faulet54a8d5a2018-12-07 12:21:11 +01001085 if (first->len == sizeof(*cache_ptr) + appctx->ctx.cache.sent)
1086 appctx->st0 = HTX_CACHE_EOM;
1087 }
1088
1089 if (appctx->st0 == HTX_CACHE_EOM) {
1090 if (!htx_add_endof(res_htx, HTX_BLK_EOM)) {
1091 si_rx_room_blk(si);
1092 goto out;
1093 }
1094
1095 total++;
1096 appctx->st0 = HTX_CACHE_END;
1097 }
1098
1099 end:
Christopher Fauletadb36312019-02-25 11:40:49 +01001100 if (!(res->flags & CF_SHUTR) && appctx->st0 == HTX_CACHE_END) {
Christopher Faulet54a8d5a2018-12-07 12:21:11 +01001101 res->flags |= CF_READ_NULL;
1102 si_shutr(si);
1103 }
1104
Christopher Faulet54a8d5a2018-12-07 12:21:11 +01001105 out:
Christopher Faulet61123912019-01-02 14:10:01 +01001106 if (total)
1107 channel_add_input(res, total);
Christopher Faulet54a8d5a2018-12-07 12:21:11 +01001108 htx_to_buf(res_htx, &res->buf);
Christopher Fauletadb36312019-02-25 11:40:49 +01001109
1110 /* eat the whole request */
1111 if (co_data(req)) {
1112 req_htx = htx_from_buf(&req->buf);
1113 co_htx_skip(req, req_htx, co_data(req));
1114 htx_to_buf(req_htx, &req->buf);
1115 }
Christopher Faulet54a8d5a2018-12-07 12:21:11 +01001116 return;
1117
1118 error:
1119 /* Sent and HTTP error 500 */
1120 b_reset(&res->buf);
1121 errmsg = &htx_err_chunks[HTTP_ERR_500];
1122 res->buf.data = b_data(errmsg);
1123 memcpy(res->buf.area, b_head(errmsg), b_data(errmsg));
1124 res_htx = htx_from_buf(&res->buf);
1125
1126 total = res_htx->data;
1127 appctx->st0 = HTX_CACHE_END;
1128 goto end;
1129}
1130
1131
Frédéric Lécaillee7a770c2018-10-26 14:29:22 +02001132/*
1133 * Append an "Age" header into <chn> channel for this <ce> cache entry.
Joseph Herlant8dae5b32018-11-15 14:07:53 -08001134 * This is the responsibility of the caller to insure there is enough
Frédéric Lécaillee7a770c2018-10-26 14:29:22 +02001135 * data in the channel.
1136 *
1137 * Returns the number of bytes inserted if succeeded, 0 if failed.
1138 */
1139static int cache_channel_append_age_header(struct cache_entry *ce, struct channel *chn)
1140{
1141 unsigned int age;
1142
1143 age = MAX(0, (int)(now.tv_sec - ce->latest_validation)) + ce->age;
1144 if (unlikely(age > CACHE_ENTRY_MAX_AGE))
1145 age = CACHE_ENTRY_MAX_AGE;
1146
1147 chunk_reset(&trash);
1148 chunk_printf(&trash, "Age: %u", age);
1149
1150 return ci_insert_line2(chn, ce->eoh, trash.area, trash.data);
1151}
1152
Frédéric Lécaille8df65ae2018-10-22 18:01:48 +02001153static int cache_channel_row_data_get(struct appctx *appctx, int len)
William Lallemand77c11972017-10-31 20:43:01 +01001154{
Frédéric Lécaille8df65ae2018-10-22 18:01:48 +02001155 int ret, total;
William Lallemand77c11972017-10-31 20:43:01 +01001156 struct stream_interface *si = appctx->owner;
1157 struct channel *res = si_ic(si);
Christopher Faulet95220e22018-12-07 17:34:39 +01001158 struct cache_flt_conf *cconf = appctx->rule->arg.act.p[0];
1159 struct cache *cache = cconf->c.cache;
William Lallemand77c11972017-10-31 20:43:01 +01001160 struct shared_context *shctx = shctx_ptr(cache);
Frédéric Lécaille8df65ae2018-10-22 18:01:48 +02001161 struct cache_entry *cache_ptr = appctx->ctx.cache.entry;
1162 struct shared_block *blk, *next = appctx->ctx.cache.next;
1163 int offset;
1164
1165 total = 0;
1166 offset = 0;
1167
1168 if (!next) {
1169 offset = sizeof(struct cache_entry);
1170 next = block_ptr(cache_ptr);
1171 }
1172
1173 blk = next;
1174 list_for_each_entry_from(blk, &shctx->hot, list) {
1175 int sz;
1176
1177 if (len <= 0)
1178 break;
1179
1180 sz = MIN(len, shctx->block_size - offset);
1181
1182 ret = ci_putblk(res, (const char *)blk->data + offset, sz);
1183 if (unlikely(offset))
1184 offset = 0;
1185 if (ret <= 0) {
1186 if (ret == -3 || ret == -1) {
Willy Tarreaudb398432018-11-15 11:08:52 +01001187 si_rx_room_blk(si);
Frédéric Lécaille8df65ae2018-10-22 18:01:48 +02001188 break;
1189 }
1190 return -1;
1191 }
1192
1193 total += sz;
1194 len -= sz;
1195 }
1196 appctx->ctx.cache.next = blk;
1197
1198 return total;
1199}
1200
1201static void http_cache_io_handler(struct appctx *appctx)
1202{
1203 struct stream_interface *si = appctx->owner;
Christopher Faulet54a8d5a2018-12-07 12:21:11 +01001204 struct stream *s = si_strm(si);
Frédéric Lécaille8df65ae2018-10-22 18:01:48 +02001205 struct channel *res = si_ic(si);
1206 struct cache_entry *cache_ptr = appctx->ctx.cache.entry;
William Lallemand77c11972017-10-31 20:43:01 +01001207 struct shared_block *first = block_ptr(cache_ptr);
Christopher Faulet54a8d5a2018-12-07 12:21:11 +01001208 unsigned int *sent = &appctx->ctx.cache.sent;
1209
1210 if (IS_HTX_STRM(s))
1211 return htx_cache_io_handler(appctx);
William Lallemand77c11972017-10-31 20:43:01 +01001212
1213 if (unlikely(si->state == SI_ST_DIS || si->state == SI_ST_CLO))
1214 goto out;
1215
Joseph Herlant8dae5b32018-11-15 14:07:53 -08001216 /* Check if the input buffer is available. */
Willy Tarreauc9fa0482018-07-10 17:43:27 +02001217 if (res->buf.size == 0) {
Willy Tarreau4b962a42018-11-15 11:03:21 +01001218 /* buf.size==0 means we failed to get a buffer and were
1219 * already subscribed to a wait list to get a buffer.
1220 */
William Lallemand77c11972017-10-31 20:43:01 +01001221 goto out;
1222 }
1223
Willy Tarreauefef3232018-12-16 00:37:45 +01001224 if (res->flags & (CF_SHUTW|CF_SHUTW_NOW|CF_SHUTR))
William Lallemand77c11972017-10-31 20:43:01 +01001225 appctx->st0 = HTTP_CACHE_END;
1226
1227 /* buffer are aligned there, should be fine */
Frédéric Lécaillee7a770c2018-10-26 14:29:22 +02001228 if (appctx->st0 == HTTP_CACHE_HEADER || appctx->st0 == HTTP_CACHE_INIT) {
Frédéric Lécaille8df65ae2018-10-22 18:01:48 +02001229 int len = first->len - *sent - sizeof(struct cache_entry);
Frédéric Lécaille8df65ae2018-10-22 18:01:48 +02001230 if (len > 0) {
1231 int ret;
1232
1233 ret = cache_channel_row_data_get(appctx, len);
1234 if (ret == -1)
1235 appctx->st0 = HTTP_CACHE_END;
1236 else
1237 *sent += ret;
Frédéric Lécaillee7a770c2018-10-26 14:29:22 +02001238 if (appctx->st0 == HTTP_CACHE_INIT && *sent > cache_ptr->eoh &&
1239 cache_channel_append_age_header(cache_ptr, res))
1240 appctx->st0 = HTTP_CACHE_HEADER;
Christopher Faulet61123912019-01-02 14:10:01 +01001241 else if (ret == len) {
1242 *sent = 0;
1243 appctx->st0 = HTTP_CACHE_FWD;
1244 }
Frédéric Lécaille8df65ae2018-10-22 18:01:48 +02001245 }
1246 else {
1247 *sent = 0;
1248 appctx->st0 = HTTP_CACHE_FWD;
William Lallemand77c11972017-10-31 20:43:01 +01001249 }
William Lallemand77c11972017-10-31 20:43:01 +01001250 }
1251
Christopher Fauletadb36312019-02-25 11:40:49 +01001252 if (appctx->st0 == HTTP_CACHE_FWD)
1253 appctx->st0 = HTTP_CACHE_END;
1254
1255 if (!(res->flags & CF_SHUTR) && appctx->st0 == HTTP_CACHE_END) {
William Lallemand77c11972017-10-31 20:43:01 +01001256 res->flags |= CF_READ_NULL;
1257 si_shutr(si);
1258 }
William Lallemand77c11972017-10-31 20:43:01 +01001259out:
Christopher Fauletadb36312019-02-25 11:40:49 +01001260 /* eat the whole request */
1261 if (co_data(si_oc(si)))
1262 co_skip(si_oc(si), co_data(si_oc(si)));
William Lallemand77c11972017-10-31 20:43:01 +01001263}
1264
Christopher Faulet95220e22018-12-07 17:34:39 +01001265static int parse_cache_rule(struct proxy *proxy, const char *name, struct act_rule *rule, char **err)
William Lallemand41db4602017-10-30 11:15:51 +01001266{
1267 struct flt_conf *fconf;
Christopher Faulet95220e22018-12-07 17:34:39 +01001268 struct cache_flt_conf *cconf = NULL;
William Lallemand41db4602017-10-30 11:15:51 +01001269
Christopher Faulet95220e22018-12-07 17:34:39 +01001270 if (!*name || strcmp(name, "if") == 0 || strcmp(name, "unless") == 0) {
William Lallemand41db4602017-10-30 11:15:51 +01001271 memprintf(err, "expects a cache name");
Christopher Faulet95220e22018-12-07 17:34:39 +01001272 goto err;
William Lallemand41db4602017-10-30 11:15:51 +01001273 }
1274
1275 /* check if a cache filter was already registered with this cache
1276 * name, if that's the case, must use it. */
1277 list_for_each_entry(fconf, &proxy->filter_configs, list) {
Christopher Faulet95220e22018-12-07 17:34:39 +01001278 if (fconf->id == cache_store_flt_id) {
1279 cconf = fconf->conf;
1280 if (cconf && !strcmp((char *)cconf->c.name, name)) {
1281 rule->arg.act.p[0] = cconf;
1282 return 1;
1283 }
William Lallemand41db4602017-10-30 11:15:51 +01001284 }
1285 }
1286
Christopher Faulet95220e22018-12-07 17:34:39 +01001287 /* Create the filter cache config */
1288 cconf = calloc(1, sizeof(*cconf));
1289 if (!cconf) {
1290 memprintf(err, "out of memory\n");
1291 goto err;
1292 }
Christopher Faulet99a17a22018-12-11 09:18:27 +01001293 cconf->flags = CACHE_FLT_F_IMPLICIT_DECL;
Christopher Faulet95220e22018-12-07 17:34:39 +01001294 cconf->c.name = strdup(name);
1295 if (!cconf->c.name) {
1296 memprintf(err, "out of memory\n");
William Lallemand41db4602017-10-30 11:15:51 +01001297 goto err;
1298 }
Christopher Faulet95220e22018-12-07 17:34:39 +01001299
William Lallemand41db4602017-10-30 11:15:51 +01001300 /* register a filter to fill the cache buffer */
1301 fconf = calloc(1, sizeof(*fconf));
1302 if (!fconf) {
Christopher Faulet95220e22018-12-07 17:34:39 +01001303 memprintf(err, "out of memory\n");
William Lallemand41db4602017-10-30 11:15:51 +01001304 goto err;
1305 }
Christopher Faulet95220e22018-12-07 17:34:39 +01001306 fconf->id = cache_store_flt_id;
1307 fconf->conf = cconf;
William Lallemand41db4602017-10-30 11:15:51 +01001308 fconf->ops = &cache_ops;
1309 LIST_ADDQ(&proxy->filter_configs, &fconf->list);
1310
Christopher Faulet95220e22018-12-07 17:34:39 +01001311 rule->arg.act.p[0] = cconf;
1312 return 1;
William Lallemand41db4602017-10-30 11:15:51 +01001313
Christopher Faulet95220e22018-12-07 17:34:39 +01001314 err:
1315 free(cconf);
1316 return 0;
1317}
1318
1319enum act_parse_ret parse_cache_store(const char **args, int *orig_arg, struct proxy *proxy,
1320 struct act_rule *rule, char **err)
1321{
1322 rule->action = ACT_CUSTOM;
1323 rule->action_ptr = http_action_store_cache;
1324
1325 if (!parse_cache_rule(proxy, args[*orig_arg], rule, err))
1326 return ACT_RET_PRS_ERR;
William Lallemand41db4602017-10-30 11:15:51 +01001327
Christopher Faulet95220e22018-12-07 17:34:39 +01001328 (*orig_arg)++;
1329 return ACT_RET_PRS_OK;
William Lallemand41db4602017-10-30 11:15:51 +01001330}
1331
William Lallemandf528fff2017-11-23 19:43:17 +01001332/* This produces a sha1 hash of the concatenation of the first
1333 * occurrence of the Host header followed by the path component if it
1334 * begins with a slash ('/'). */
Christopher Faulet54a8d5a2018-12-07 12:21:11 +01001335int sha1_hosturi(struct stream *s)
William Lallemandf528fff2017-11-23 19:43:17 +01001336{
Christopher Faulet54a8d5a2018-12-07 12:21:11 +01001337 struct http_txn *txn = s->txn;
William Lallemandf528fff2017-11-23 19:43:17 +01001338 blk_SHA_CTX sha1_ctx;
Willy Tarreau83061a82018-07-13 11:56:34 +02001339 struct buffer *trash;
Christopher Faulet54a8d5a2018-12-07 12:21:11 +01001340
William Lallemandf528fff2017-11-23 19:43:17 +01001341 trash = get_trash_chunk();
1342
Christopher Faulet54a8d5a2018-12-07 12:21:11 +01001343 if (IS_HTX_STRM(s)) {
1344 struct htx *htx = htxbuf(&s->req.buf);
1345 struct htx_sl *sl;
1346 struct http_hdr_ctx ctx;
1347 struct ist path;
William Lallemandf528fff2017-11-23 19:43:17 +01001348
Christopher Faulet54a8d5a2018-12-07 12:21:11 +01001349 ctx.blk = NULL;
1350 if (!http_find_header(htx, ist("Host"), &ctx, 0))
1351 return 0;
1352 chunk_memcat(trash, ctx.value.ptr, ctx.value.len);
1353
1354 sl = http_find_stline(htx);
1355 path = http_get_path(htx_sl_req_uri(sl));
1356 if (!path.ptr)
1357 return 0;
1358 chunk_memcat(trash, path.ptr, path.len);
1359 }
1360 else {
1361 struct hdr_ctx ctx;
1362 char *path;
1363 char *end;
1364
1365 /* retrive the host */
1366 ctx.idx = 0;
1367 if (!http_find_header2("Host", 4, ci_head(txn->req.chn), &txn->hdr_idx, &ctx))
1368 return 0;
1369 chunk_strncat(trash, ctx.line + ctx.val, ctx.vlen);
1370
1371 /* now retrieve the path */
1372 end = ci_head(txn->req.chn) + txn->req.sl.rq.u + txn->req.sl.rq.u_l;
1373 path = http_txn_get_path(txn);
1374 if (!path)
1375 return 0;
1376 chunk_strncat(trash, path, end - path);
1377 }
William Lallemandf528fff2017-11-23 19:43:17 +01001378
1379 /* hash everything */
1380 blk_SHA1_Init(&sha1_ctx);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001381 blk_SHA1_Update(&sha1_ctx, trash->area, trash->data);
William Lallemandf528fff2017-11-23 19:43:17 +01001382 blk_SHA1_Final((unsigned char *)txn->cache_hash, &sha1_ctx);
1383
1384 return 1;
1385}
1386
William Lallemand41db4602017-10-30 11:15:51 +01001387enum act_return http_action_req_cache_use(struct act_rule *rule, struct proxy *px,
1388 struct session *sess, struct stream *s, int flags)
1389{
William Lallemand77c11972017-10-31 20:43:01 +01001390
Christopher Fauletb3d4bca2019-02-25 10:59:33 +01001391 struct http_txn *txn = s->txn;
William Lallemand77c11972017-10-31 20:43:01 +01001392 struct cache_entry *res;
Christopher Faulet95220e22018-12-07 17:34:39 +01001393 struct cache_flt_conf *cconf = rule->arg.act.p[0];
1394 struct cache *cache = cconf->c.cache;
William Lallemand77c11972017-10-31 20:43:01 +01001395
Christopher Fauletb3d4bca2019-02-25 10:59:33 +01001396 /* Ignore cache for HTTP/1.0 requests and for requests other than GET
1397 * and HEAD */
1398 if (!(txn->req.flags & HTTP_MSGF_VER_11) ||
1399 (txn->meth != HTTP_METH_GET && txn->meth != HTTP_METH_HEAD))
1400 txn->flags |= TX_CACHE_IGNORE;
1401
Christopher Faulet54a8d5a2018-12-07 12:21:11 +01001402 if (IS_HTX_STRM(s))
1403 htx_check_request_for_cacheability(s, &s->req);
1404 else
1405 check_request_for_cacheability(s, &s->req);
1406
Willy Tarreau504455c2017-12-22 17:47:35 +01001407 if ((s->txn->flags & (TX_CACHE_IGNORE|TX_CACHEABLE)) == TX_CACHE_IGNORE)
1408 return ACT_RET_CONT;
1409
Christopher Faulet54a8d5a2018-12-07 12:21:11 +01001410 if (!sha1_hosturi(s))
Willy Tarreau7704b1e2017-12-22 16:32:43 +01001411 return ACT_RET_CONT;
William Lallemandf528fff2017-11-23 19:43:17 +01001412
Willy Tarreau504455c2017-12-22 17:47:35 +01001413 if (s->txn->flags & TX_CACHE_IGNORE)
1414 return ACT_RET_CONT;
1415
Willy Tarreaua1214a52018-12-14 14:00:25 +01001416 if (px == strm_fe(s))
Olivier Houchardaa090d42019-03-08 18:49:24 +01001417 _HA_ATOMIC_ADD(&px->fe_counters.p.http.cache_lookups, 1);
Willy Tarreaua1214a52018-12-14 14:00:25 +01001418 else
Olivier Houchardaa090d42019-03-08 18:49:24 +01001419 _HA_ATOMIC_ADD(&px->be_counters.p.http.cache_lookups, 1);
Willy Tarreaua1214a52018-12-14 14:00:25 +01001420
William Lallemanda400a3a2017-11-20 19:13:12 +01001421 shctx_lock(shctx_ptr(cache));
William Lallemandf528fff2017-11-23 19:43:17 +01001422 res = entry_exist(cache, s->txn->cache_hash);
William Lallemand77c11972017-10-31 20:43:01 +01001423 if (res) {
1424 struct appctx *appctx;
William Lallemanda400a3a2017-11-20 19:13:12 +01001425 shctx_row_inc_hot(shctx_ptr(cache), block_ptr(res));
1426 shctx_unlock(shctx_ptr(cache));
William Lallemand77c11972017-10-31 20:43:01 +01001427 s->target = &http_cache_applet.obj_type;
Willy Tarreau14bfe9a2018-12-19 15:19:27 +01001428 if ((appctx = si_register_handler(&s->si[1], objt_applet(s->target)))) {
William Lallemand77c11972017-10-31 20:43:01 +01001429 appctx->st0 = HTTP_CACHE_INIT;
1430 appctx->rule = rule;
1431 appctx->ctx.cache.entry = res;
Frédéric Lécaille8df65ae2018-10-22 18:01:48 +02001432 appctx->ctx.cache.next = NULL;
1433 appctx->ctx.cache.sent = 0;
Willy Tarreaua1214a52018-12-14 14:00:25 +01001434
1435 if (px == strm_fe(s))
Olivier Houchardaa090d42019-03-08 18:49:24 +01001436 _HA_ATOMIC_ADD(&px->fe_counters.p.http.cache_hits, 1);
Willy Tarreaua1214a52018-12-14 14:00:25 +01001437 else
Olivier Houchardaa090d42019-03-08 18:49:24 +01001438 _HA_ATOMIC_ADD(&px->be_counters.p.http.cache_hits, 1);
Olivier Houchardfccf8402017-11-01 14:04:02 +01001439 return ACT_RET_CONT;
William Lallemand77c11972017-10-31 20:43:01 +01001440 } else {
William Lallemand55e76742017-11-21 20:01:28 +01001441 shctx_lock(shctx_ptr(cache));
1442 shctx_row_dec_hot(shctx_ptr(cache), block_ptr(res));
1443 shctx_unlock(shctx_ptr(cache));
Olivier Houchardfccf8402017-11-01 14:04:02 +01001444 return ACT_RET_YIELD;
William Lallemand77c11972017-10-31 20:43:01 +01001445 }
1446 }
William Lallemanda400a3a2017-11-20 19:13:12 +01001447 shctx_unlock(shctx_ptr(cache));
Olivier Houchardfccf8402017-11-01 14:04:02 +01001448 return ACT_RET_CONT;
William Lallemand41db4602017-10-30 11:15:51 +01001449}
1450
1451
1452enum act_parse_ret parse_cache_use(const char **args, int *orig_arg, struct proxy *proxy,
1453 struct act_rule *rule, char **err)
1454{
William Lallemand41db4602017-10-30 11:15:51 +01001455 rule->action = ACT_CUSTOM;
1456 rule->action_ptr = http_action_req_cache_use;
1457
Christopher Faulet95220e22018-12-07 17:34:39 +01001458 if (!parse_cache_rule(proxy, args[*orig_arg], rule, err))
William Lallemand41db4602017-10-30 11:15:51 +01001459 return ACT_RET_PRS_ERR;
William Lallemand41db4602017-10-30 11:15:51 +01001460
1461 (*orig_arg)++;
1462 return ACT_RET_PRS_OK;
William Lallemand41db4602017-10-30 11:15:51 +01001463}
1464
1465int cfg_parse_cache(const char *file, int linenum, char **args, int kwm)
1466{
1467 int err_code = 0;
1468
1469 if (strcmp(args[0], "cache") == 0) { /* new cache section */
1470
1471 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001472 ha_alert("parsing [%s:%d] : '%s' expects an <id> argument\n",
1473 file, linenum, args[0]);
William Lallemand41db4602017-10-30 11:15:51 +01001474 err_code |= ERR_ALERT | ERR_ABORT;
1475 goto out;
1476 }
1477
1478 if (alertif_too_many_args(1, file, linenum, args, &err_code)) {
1479 err_code |= ERR_ABORT;
1480 goto out;
1481 }
1482
1483 if (tmp_cache_config == NULL) {
1484 tmp_cache_config = calloc(1, sizeof(*tmp_cache_config));
1485 if (!tmp_cache_config) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001486 ha_alert("parsing [%s:%d]: out of memory.\n", file, linenum);
William Lallemand41db4602017-10-30 11:15:51 +01001487 err_code |= ERR_ALERT | ERR_ABORT;
1488 goto out;
1489 }
1490
1491 strlcpy2(tmp_cache_config->id, args[1], 33);
1492 if (strlen(args[1]) > 32) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001493 ha_warning("parsing [%s:%d]: cache id is limited to 32 characters, truncate to '%s'.\n",
1494 file, linenum, tmp_cache_config->id);
William Lallemand41db4602017-10-30 11:15:51 +01001495 err_code |= ERR_WARN;
1496 }
William Lallemand49b44532017-11-24 18:53:43 +01001497 tmp_cache_config->maxage = 60;
William Lallemand41db4602017-10-30 11:15:51 +01001498 tmp_cache_config->maxblocks = 0;
Frédéric Lécaillea2219f52018-10-22 16:59:13 +02001499 tmp_cache_config->maxobjsz = 0;
Christopher Faulet1f672c52018-12-03 14:30:41 +01001500 tmp_cache_config->flags = 0;
William Lallemand41db4602017-10-30 11:15:51 +01001501 }
1502 } else if (strcmp(args[0], "total-max-size") == 0) {
Frédéric Lécailleb9b8b6b2018-10-25 20:17:45 +02001503 unsigned long int maxsize;
1504 char *err;
William Lallemand41db4602017-10-30 11:15:51 +01001505
1506 if (alertif_too_many_args(1, file, linenum, args, &err_code)) {
1507 err_code |= ERR_ABORT;
1508 goto out;
1509 }
1510
Frédéric Lécailleb9b8b6b2018-10-25 20:17:45 +02001511 maxsize = strtoul(args[1], &err, 10);
1512 if (err == args[1] || *err != '\0') {
1513 ha_warning("parsing [%s:%d]: total-max-size wrong value '%s'\n",
1514 file, linenum, args[1]);
1515 err_code |= ERR_ABORT;
1516 goto out;
1517 }
1518
1519 if (maxsize > (UINT_MAX >> 20)) {
1520 ha_warning("parsing [%s:%d]: \"total-max-size\" (%s) must not be greater than %u\n",
1521 file, linenum, args[1], UINT_MAX >> 20);
1522 err_code |= ERR_ABORT;
1523 goto out;
1524 }
1525
William Lallemand41db4602017-10-30 11:15:51 +01001526 /* size in megabytes */
Frédéric Lécailleb9b8b6b2018-10-25 20:17:45 +02001527 maxsize *= 1024 * 1024 / CACHE_BLOCKSIZE;
William Lallemand41db4602017-10-30 11:15:51 +01001528 tmp_cache_config->maxblocks = maxsize;
William Lallemand49b44532017-11-24 18:53:43 +01001529 } else if (strcmp(args[0], "max-age") == 0) {
1530 if (alertif_too_many_args(1, file, linenum, args, &err_code)) {
1531 err_code |= ERR_ABORT;
1532 goto out;
1533 }
1534
1535 if (!*args[1]) {
1536 ha_warning("parsing [%s:%d]: '%s' expects an age parameter in seconds.\n",
1537 file, linenum, args[0]);
1538 err_code |= ERR_WARN;
1539 }
1540
1541 tmp_cache_config->maxage = atoi(args[1]);
Frédéric Lécaillea2219f52018-10-22 16:59:13 +02001542 } else if (strcmp(args[0], "max-object-size") == 0) {
Frédéric Lécaille4eba5442018-10-25 20:29:31 +02001543 unsigned int maxobjsz;
1544 char *err;
1545
Frédéric Lécaillea2219f52018-10-22 16:59:13 +02001546 if (alertif_too_many_args(1, file, linenum, args, &err_code)) {
1547 err_code |= ERR_ABORT;
1548 goto out;
1549 }
1550
1551 if (!*args[1]) {
1552 ha_warning("parsing [%s:%d]: '%s' expects a maximum file size parameter in bytes.\n",
1553 file, linenum, args[0]);
1554 err_code |= ERR_WARN;
1555 }
1556
Frédéric Lécaille4eba5442018-10-25 20:29:31 +02001557 maxobjsz = strtoul(args[1], &err, 10);
1558 if (err == args[1] || *err != '\0') {
1559 ha_warning("parsing [%s:%d]: max-object-size wrong value '%s'\n",
1560 file, linenum, args[1]);
1561 err_code |= ERR_ABORT;
1562 goto out;
1563 }
1564 tmp_cache_config->maxobjsz = maxobjsz;
Frédéric Lécaillea2219f52018-10-22 16:59:13 +02001565 }
1566 else if (*args[0] != 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001567 ha_alert("parsing [%s:%d] : unknown keyword '%s' in 'cache' section\n", file, linenum, args[0]);
William Lallemand41db4602017-10-30 11:15:51 +01001568 err_code |= ERR_ALERT | ERR_FATAL;
1569 goto out;
1570 }
1571out:
1572 return err_code;
1573}
1574
1575/* once the cache section is parsed */
1576
1577int cfg_post_parse_section_cache()
1578{
1579 struct shared_context *shctx;
1580 int err_code = 0;
1581 int ret_shctx;
1582
1583 if (tmp_cache_config) {
1584 struct cache *cache;
1585
1586 if (tmp_cache_config->maxblocks <= 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001587 ha_alert("Size not specified for cache '%s'\n", tmp_cache_config->id);
William Lallemand41db4602017-10-30 11:15:51 +01001588 err_code |= ERR_FATAL | ERR_ALERT;
1589 goto out;
1590 }
1591
Frédéric Lécaille4eba5442018-10-25 20:29:31 +02001592 if (!tmp_cache_config->maxobjsz) {
Frédéric Lécaillea2219f52018-10-22 16:59:13 +02001593 /* Default max. file size is a 256th of the cache size. */
1594 tmp_cache_config->maxobjsz =
1595 (tmp_cache_config->maxblocks * CACHE_BLOCKSIZE) >> 8;
Frédéric Lécaille4eba5442018-10-25 20:29:31 +02001596 }
1597 else if (tmp_cache_config->maxobjsz > tmp_cache_config->maxblocks * CACHE_BLOCKSIZE / 2) {
1598 ha_alert("\"max-object-size\" is limited to an half of \"total-max-size\" => %u\n", tmp_cache_config->maxblocks * CACHE_BLOCKSIZE / 2);
1599 err_code |= ERR_FATAL | ERR_ALERT;
1600 goto out;
1601 }
Frédéric Lécaillea2219f52018-10-22 16:59:13 +02001602
1603 ret_shctx = shctx_init(&shctx, tmp_cache_config->maxblocks, CACHE_BLOCKSIZE,
1604 tmp_cache_config->maxobjsz, sizeof(struct cache), 1);
William Lallemand4da3f8a2017-10-31 14:33:34 +01001605
Frédéric Lécaillebc584492018-10-25 20:18:59 +02001606 if (ret_shctx <= 0) {
William Lallemand41db4602017-10-30 11:15:51 +01001607 if (ret_shctx == SHCTX_E_INIT_LOCK)
Christopher Faulet767a84b2017-11-24 16:50:31 +01001608 ha_alert("Unable to initialize the lock for the cache.\n");
William Lallemand41db4602017-10-30 11:15:51 +01001609 else
Christopher Faulet767a84b2017-11-24 16:50:31 +01001610 ha_alert("Unable to allocate cache.\n");
William Lallemand41db4602017-10-30 11:15:51 +01001611
1612 err_code |= ERR_FATAL | ERR_ALERT;
1613 goto out;
1614 }
William Lallemanda400a3a2017-11-20 19:13:12 +01001615 shctx->free_block = cache_free_blocks;
William Lallemand41db4602017-10-30 11:15:51 +01001616 memcpy(shctx->data, tmp_cache_config, sizeof(struct cache));
1617 cache = (struct cache *)shctx->data;
1618 cache->entries = EB_ROOT_UNIQUE;
William Lallemand41db4602017-10-30 11:15:51 +01001619 LIST_ADDQ(&caches, &cache->list);
1620 }
1621out:
1622 free(tmp_cache_config);
1623 tmp_cache_config = NULL;
1624 return err_code;
1625
1626}
1627
1628/*
1629 * Resolve the cache name to a pointer once the file is completely read.
1630 */
1631int cfg_cache_postparser()
1632{
William Lallemand41db4602017-10-30 11:15:51 +01001633 struct cache *cache;
William Lallemand41db4602017-10-30 11:15:51 +01001634 int err = 0;
Christopher Faulet1f672c52018-12-03 14:30:41 +01001635
1636 /* Check if the cache is used by HTX and legacy HTTP proxies in same
1637 * time
1638 */
1639 list_for_each_entry(cache, &caches, list) {
1640 if ((cache->flags & (CACHE_F_HTX|CACHE_F_LEGACY_HTTP)) == (CACHE_F_HTX|CACHE_F_LEGACY_HTTP)) {
1641 ha_alert("Cache '%s': cannot be used by HTX and legacy HTTP proxies in same time.\n",
1642 cache->id);
1643 err++;
1644 }
1645 }
1646
William Lallemand41db4602017-10-30 11:15:51 +01001647 return err;
1648}
1649
1650
1651struct flt_ops cache_ops = {
1652 .init = cache_store_init,
Christopher Faulet95220e22018-12-07 17:34:39 +01001653 .check = cache_store_check,
1654 .deinit = cache_store_deinit,
William Lallemand41db4602017-10-30 11:15:51 +01001655
William Lallemand4da3f8a2017-10-31 14:33:34 +01001656 /* Handle channels activity */
1657 .channel_start_analyze = cache_store_chn_start_analyze,
William Lallemand49dc0482017-11-24 14:33:54 +01001658 .channel_end_analyze = cache_store_chn_end_analyze,
Christopher Faulet839791a2019-01-07 16:12:07 +01001659 .channel_post_analyze = cache_store_post_analyze,
William Lallemand4da3f8a2017-10-31 14:33:34 +01001660
1661 /* Filter HTTP requests and responses */
1662 .http_headers = cache_store_http_headers,
Christopher Faulet54a8d5a2018-12-07 12:21:11 +01001663 .http_payload = cache_store_http_payload,
William Lallemand4da3f8a2017-10-31 14:33:34 +01001664 .http_end = cache_store_http_end,
1665
1666 .http_forward_data = cache_store_http_forward_data,
1667
William Lallemand41db4602017-10-30 11:15:51 +01001668};
1669
Christopher Faulet99a17a22018-12-11 09:18:27 +01001670
1671
1672static int
1673parse_cache_flt(char **args, int *cur_arg, struct proxy *px,
1674 struct flt_conf *fconf, char **err, void *private)
1675{
1676 struct flt_conf *f, *back;
Willy Tarreaua73da1e2018-12-14 10:19:28 +01001677 struct cache_flt_conf *cconf = NULL;
Christopher Faulet99a17a22018-12-11 09:18:27 +01001678 char *name = NULL;
1679 int pos = *cur_arg;
1680
1681 /* Get the cache filter name*/
1682 if (!strcmp(args[pos], "cache")) {
1683 if (!*args[pos + 1]) {
1684 memprintf(err, "%s : expects an <id> argument", args[pos]);
1685 goto error;
1686 }
1687 name = strdup(args[pos + 1]);
1688 if (!name) {
1689 memprintf(err, "%s '%s' : out of memory", args[pos], args[pos + 1]);
1690 goto error;
1691 }
1692 pos += 2;
1693 }
1694
1695 /* Check if an implicit filter with the same name already exists. If so,
1696 * we remove the implicit filter to use the explicit one. */
1697 list_for_each_entry_safe(f, back, &px->filter_configs, list) {
1698 if (f->id != cache_store_flt_id)
1699 continue;
1700
1701 cconf = f->conf;
1702 if (strcmp(name, cconf->c.name)) {
1703 cconf = NULL;
1704 continue;
1705 }
1706
1707 if (!(cconf->flags & CACHE_FLT_F_IMPLICIT_DECL)) {
1708 cconf = NULL;
1709 memprintf(err, "%s: multiple explicit declarations of the cache filter '%s'",
1710 px->id, name);
1711 return -1;
1712 }
1713
1714 /* Remove the implicit filter. <cconf> is kept for the explicit one */
1715 LIST_DEL(&f->list);
1716 free(f);
1717 free(name);
1718 break;
1719 }
1720
1721 /* No implicit cache filter found, create configuration for the explicit one */
1722 if (!cconf) {
1723 cconf = calloc(1, sizeof(*cconf));
1724 if (!cconf) {
1725 memprintf(err, "%s: out of memory", args[*cur_arg]);
1726 goto error;
1727 }
1728 cconf->c.name = name;
1729 }
1730
1731 cconf->flags = 0;
1732 fconf->id = cache_store_flt_id;
1733 fconf->conf = cconf;
1734 fconf->ops = &cache_ops;
1735
1736 *cur_arg = pos;
1737 return 0;
1738
1739 error:
1740 free(name);
1741 free(cconf);
1742 return -1;
1743}
1744
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001745static int cli_parse_show_cache(char **args, char *payload, struct appctx *appctx, void *private)
William Lallemand1f49a362017-11-21 20:01:26 +01001746{
1747 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
1748 return 1;
1749
1750 return 0;
1751}
1752
1753static int cli_io_handler_show_cache(struct appctx *appctx)
1754{
1755 struct cache* cache = appctx->ctx.cli.p0;
1756 struct stream_interface *si = appctx->owner;
1757
William Lallemand1f49a362017-11-21 20:01:26 +01001758 if (cache == NULL) {
1759 cache = LIST_ELEM((caches).n, typeof(struct cache *), list);
1760 }
1761
1762 list_for_each_entry_from(cache, &caches, list) {
1763 struct eb32_node *node = NULL;
1764 unsigned int next_key;
1765 struct cache_entry *entry;
1766
William Lallemand1f49a362017-11-21 20:01:26 +01001767 next_key = appctx->ctx.cli.i0;
Willy Tarreauafe1de52018-04-04 11:56:43 +02001768 if (!next_key) {
1769 chunk_printf(&trash, "%p: %s (shctx:%p, available blocks:%d)\n", cache, cache->id, shctx_ptr(cache), shctx_ptr(cache)->nbav);
1770 if (ci_putchk(si_ic(si), &trash) == -1) {
Willy Tarreaudb398432018-11-15 11:08:52 +01001771 si_rx_room_blk(si);
Willy Tarreauafe1de52018-04-04 11:56:43 +02001772 return 0;
1773 }
1774 }
William Lallemand1f49a362017-11-21 20:01:26 +01001775
1776 appctx->ctx.cli.p0 = cache;
1777
1778 while (1) {
1779
1780 shctx_lock(shctx_ptr(cache));
1781 node = eb32_lookup_ge(&cache->entries, next_key);
1782 if (!node) {
1783 shctx_unlock(shctx_ptr(cache));
Willy Tarreauafe1de52018-04-04 11:56:43 +02001784 appctx->ctx.cli.i0 = 0;
William Lallemand1f49a362017-11-21 20:01:26 +01001785 break;
1786 }
1787
1788 entry = container_of(node, struct cache_entry, eb);
Willy Tarreauafe1de52018-04-04 11:56:43 +02001789 chunk_printf(&trash, "%p hash:%u size:%u (%u blocks), refcount:%u, expire:%d\n", entry, (*(unsigned int *)entry->hash), block_ptr(entry)->len, block_ptr(entry)->block_count, block_ptr(entry)->refcount, entry->expire - (int)now.tv_sec);
William Lallemand1f49a362017-11-21 20:01:26 +01001790
1791 next_key = node->key + 1;
1792 appctx->ctx.cli.i0 = next_key;
1793
1794 shctx_unlock(shctx_ptr(cache));
1795
1796 if (ci_putchk(si_ic(si), &trash) == -1) {
Willy Tarreaudb398432018-11-15 11:08:52 +01001797 si_rx_room_blk(si);
William Lallemand1f49a362017-11-21 20:01:26 +01001798 return 0;
1799 }
1800 }
1801
1802 }
1803
1804 return 1;
1805
1806}
1807
Christopher Faulet99a17a22018-12-11 09:18:27 +01001808/* Declare the filter parser for "cache" keyword */
1809static struct flt_kw_list filter_kws = { "CACHE", { }, {
1810 { "cache", parse_cache_flt, NULL },
1811 { NULL, NULL, NULL },
1812 }
1813};
1814
1815INITCALL1(STG_REGISTER, flt_register_keywords, &filter_kws);
1816
William Lallemand1f49a362017-11-21 20:01:26 +01001817static struct cli_kw_list cli_kws = {{},{
William Lallemande899af82017-11-22 16:41:26 +01001818 { { "show", "cache", NULL }, "show cache : show cache status", cli_parse_show_cache, cli_io_handler_show_cache, NULL, NULL },
1819 {{},}
William Lallemand1f49a362017-11-21 20:01:26 +01001820}};
1821
Willy Tarreau0108d902018-11-25 19:14:37 +01001822INITCALL1(STG_REGISTER, cli_register_kw, &cli_kws);
William Lallemand1f49a362017-11-21 20:01:26 +01001823
William Lallemand41db4602017-10-30 11:15:51 +01001824static struct action_kw_list http_res_actions = {
1825 .kw = {
1826 { "cache-store", parse_cache_store },
1827 { NULL, NULL }
1828 }
1829};
1830
Willy Tarreau0108d902018-11-25 19:14:37 +01001831INITCALL1(STG_REGISTER, http_res_keywords_register, &http_res_actions);
1832
William Lallemand41db4602017-10-30 11:15:51 +01001833static struct action_kw_list http_req_actions = {
1834 .kw = {
1835 { "cache-use", parse_cache_use },
1836 { NULL, NULL }
1837 }
1838};
1839
Willy Tarreau0108d902018-11-25 19:14:37 +01001840INITCALL1(STG_REGISTER, http_req_keywords_register, &http_req_actions);
1841
Willy Tarreau0f222992019-03-19 09:57:55 +01001842static struct applet http_cache_applet = {
William Lallemand41db4602017-10-30 11:15:51 +01001843 .obj_type = OBJ_TYPE_APPLET,
1844 .name = "<CACHE>", /* used for logging */
William Lallemand77c11972017-10-31 20:43:01 +01001845 .fct = http_cache_io_handler,
William Lallemandecb73b12017-11-24 14:33:55 +01001846 .release = http_cache_applet_release,
William Lallemand41db4602017-10-30 11:15:51 +01001847};
1848
Willy Tarreaue6552512018-11-26 11:33:13 +01001849/* config parsers for this section */
1850REGISTER_CONFIG_SECTION("cache", cfg_parse_cache, cfg_post_parse_section_cache);
1851REGISTER_CONFIG_POSTPARSER("cache", cfg_cache_postparser);