blob: 39d8196ac1ed12ba944c158dda2cf051e4908041 [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>
26#include <proto/filters.h>
27#include <proto/proto_http.h>
28#include <proto/log.h>
29#include <proto/stream.h>
30#include <proto/stream_interface.h>
31#include <proto/shctx.h>
32
William Lallemand41db4602017-10-30 11:15:51 +010033
34#include <common/cfgparse.h>
35#include <common/hash.h>
36
37/* flt_cache_store */
38
39static const char *cache_store_flt_id = "cache store filter";
40
Willy Tarreaubafbe012017-11-24 17:34:44 +010041static struct pool_head *pool_head_cache_st = NULL;
William Lallemand4da3f8a2017-10-31 14:33:34 +010042
William Lallemand41db4602017-10-30 11:15:51 +010043struct applet http_cache_applet;
44
45struct flt_ops cache_ops;
46
47struct cache {
Willy Tarreaufd5efb52017-11-26 08:54:31 +010048 struct list list; /* cache linked list */
William Lallemand41db4602017-10-30 11:15:51 +010049 struct eb_root entries; /* head of cache entries based on keys */
Willy Tarreaufd5efb52017-11-26 08:54:31 +010050 unsigned int maxage; /* max-age */
51 unsigned int maxblocks;
52 char id[33]; /* cache name */
William Lallemand41db4602017-10-30 11:15:51 +010053};
54
55/*
56 * cache ctx for filters
57 */
58struct cache_st {
59 int hdrs_len;
60 struct shared_block *first_block;
61};
62
63struct cache_entry {
64 unsigned int latest_validation; /* latest validation date */
65 unsigned int expire; /* expiration date */
66 struct eb32_node eb; /* ebtree node used to hold the cache object */
William Lallemandf528fff2017-11-23 19:43:17 +010067 char hash[20];
William Lallemand41db4602017-10-30 11:15:51 +010068 unsigned char data[0];
69};
70
71#define CACHE_BLOCKSIZE 1024
72
73static struct list caches = LIST_HEAD_INIT(caches);
74static struct cache *tmp_cache_config = NULL;
75
William Lallemandf528fff2017-11-23 19:43:17 +010076struct cache_entry *entry_exist(struct cache *cache, char *hash)
William Lallemand4da3f8a2017-10-31 14:33:34 +010077{
78 struct eb32_node *node;
79 struct cache_entry *entry;
80
William Lallemandf528fff2017-11-23 19:43:17 +010081 node = eb32_lookup(&cache->entries, (*(unsigned int *)hash));
William Lallemand4da3f8a2017-10-31 14:33:34 +010082 if (!node)
83 return NULL;
84
85 entry = eb32_entry(node, struct cache_entry, eb);
William Lallemandf528fff2017-11-23 19:43:17 +010086
87 /* if that's not the right node */
88 if (memcmp(entry->hash, hash, sizeof(entry->hash)))
89 return NULL;
90
William Lallemand08727662017-11-21 20:01:27 +010091 if (entry->expire > now.tv_sec) {
William Lallemand4da3f8a2017-10-31 14:33:34 +010092 return entry;
William Lallemand08727662017-11-21 20:01:27 +010093 } else {
William Lallemand4da3f8a2017-10-31 14:33:34 +010094 eb32_delete(node);
William Lallemand08727662017-11-21 20:01:27 +010095 entry->eb.key = 0;
96 }
William Lallemand4da3f8a2017-10-31 14:33:34 +010097 return NULL;
98
99}
100
101static inline struct shared_context *shctx_ptr(struct cache *cache)
102{
103 return (struct shared_context *)((unsigned char *)cache - ((struct shared_context *)NULL)->data);
104}
105
William Lallemand77c11972017-10-31 20:43:01 +0100106static inline struct shared_block *block_ptr(struct cache_entry *entry)
107{
108 return (struct shared_block *)((unsigned char *)entry - ((struct shared_block *)NULL)->data);
109}
110
111
112
William Lallemand41db4602017-10-30 11:15:51 +0100113static int
114cache_store_init(struct proxy *px, struct flt_conf *f1conf)
115{
116 return 0;
117}
118
William Lallemand4da3f8a2017-10-31 14:33:34 +0100119static int
120cache_store_chn_start_analyze(struct stream *s, struct filter *filter, struct channel *chn)
121{
122 if (!(chn->flags & CF_ISRESP))
123 return 1;
124
125 if (filter->ctx == NULL) {
126 struct cache_st *st;
127
Willy Tarreaubafbe012017-11-24 17:34:44 +0100128 st = pool_alloc_dirty(pool_head_cache_st);
William Lallemand4da3f8a2017-10-31 14:33:34 +0100129 if (st == NULL)
130 return -1;
131
132 st->hdrs_len = 0;
133 st->first_block = NULL;
134 filter->ctx = st;
135 }
136
137 register_data_filter(s, chn, filter);
138
139 return 1;
140}
141
142static int
William Lallemand49dc0482017-11-24 14:33:54 +0100143cache_store_chn_end_analyze(struct stream *s, struct filter *filter, struct channel *chn)
144{
145 struct cache_st *st = filter->ctx;
146 struct cache *cache = filter->config->conf;
147 struct shared_context *shctx = shctx_ptr(cache);
148
149 if (!(chn->flags & CF_ISRESP))
150 return 1;
151
152 /* Everything should be released in the http_end filter, but we need to do it
153 * there too, in case of errors */
154
155 if (st && st->first_block) {
156
157 shctx_lock(shctx);
158 shctx_row_dec_hot(shctx, st->first_block);
159 shctx_unlock(shctx);
160
161 }
162 if (st) {
Willy Tarreaubafbe012017-11-24 17:34:44 +0100163 pool_free(pool_head_cache_st, st);
William Lallemand49dc0482017-11-24 14:33:54 +0100164 filter->ctx = NULL;
165 }
166
167 return 1;
168}
169
170
171static int
William Lallemand4da3f8a2017-10-31 14:33:34 +0100172cache_store_http_headers(struct stream *s, struct filter *filter, struct http_msg *msg)
173{
174 struct cache_st *st = filter->ctx;
175
William Lallemand4da3f8a2017-10-31 14:33:34 +0100176 if (!(msg->chn->flags & CF_ISRESP) || !st)
177 return 1;
178
William Lallemand9d5f54d2017-11-14 14:39:22 +0100179 st->hdrs_len = msg->sov;
William Lallemand4da3f8a2017-10-31 14:33:34 +0100180
181 return 1;
182}
183
184static int
185cache_store_http_forward_data(struct stream *s, struct filter *filter,
186 struct http_msg *msg, unsigned int len)
187{
188 struct cache_st *st = filter->ctx;
189 struct shared_context *shctx = shctx_ptr((struct cache *)filter->config->conf);
William Lallemand08727662017-11-21 20:01:27 +0100190 struct cache_entry *object;
William Lallemand4da3f8a2017-10-31 14:33:34 +0100191 int ret;
192
193 /*
194 * We need to skip the HTTP headers first, because we saved them in the
195 * http-response action.
196 */
197 if (!(msg->chn->flags & CF_ISRESP) || !st)
198 return len;
199
200 if (!len) {
201 /* Nothing to foward */
202 ret = len;
203 }
William Lallemand10935bc2017-11-14 14:39:23 +0100204 else if (st->hdrs_len >= len) {
William Lallemand4da3f8a2017-10-31 14:33:34 +0100205 /* Forward part of headers */
206 ret = len;
207 st->hdrs_len -= len;
208 }
William Lallemand4da3f8a2017-10-31 14:33:34 +0100209 else {
William Lallemand10935bc2017-11-14 14:39:23 +0100210 /* Forward data */
Olivier Houchardcd2867a2017-11-01 13:58:21 +0100211 if (filter->ctx && st->first_block) {
212 /* disable buffering if too much data (never greater than a buffer size */
William Lallemand10935bc2017-11-14 14:39:23 +0100213 if (len - st->hdrs_len > global.tune.bufsize - global.tune.maxrewrite - st->first_block->len) {
William Lallemande1533f52017-11-14 14:39:24 +0100214 disable_cache:
William Lallemand08727662017-11-21 20:01:27 +0100215 object = (struct cache_entry *)st->first_block->data;
Olivier Houchardcd2867a2017-11-01 13:58:21 +0100216 filter->ctx = NULL; /* disable cache */
217 shctx_lock(shctx);
218 shctx_row_dec_hot(shctx, st->first_block);
William Lallemand08727662017-11-21 20:01:27 +0100219 object->eb.key = 0;
Olivier Houchardcd2867a2017-11-01 13:58:21 +0100220 shctx_unlock(shctx);
Willy Tarreaubafbe012017-11-24 17:34:44 +0100221 pool_free(pool_head_cache_st, st);
Olivier Houchardcd2867a2017-11-01 13:58:21 +0100222 } else {
William Lallemand10935bc2017-11-14 14:39:23 +0100223 /* Skip remaining headers to fill the cache */
224 b_adv(msg->chn->buf, st->hdrs_len);
225 ret = shctx_row_data_append(shctx,
226 st->first_block,
227 (unsigned char *)bi_ptr(msg->chn->buf),
228 MIN(bi_contig_data(msg->chn->buf), len - st->hdrs_len));
229 /* Rewind the buffer to forward all data */
230 b_rew(msg->chn->buf, st->hdrs_len);
William Lallemandbcd91012017-11-28 11:33:02 +0100231 st->hdrs_len = 0;
William Lallemande1533f52017-11-14 14:39:24 +0100232 if (ret)
233 goto disable_cache;
William Lallemand4da3f8a2017-10-31 14:33:34 +0100234 }
235 }
William Lallemand10935bc2017-11-14 14:39:23 +0100236 ret = len;
William Lallemand4da3f8a2017-10-31 14:33:34 +0100237 }
238
239 if ((ret != len) ||
240 (FLT_NXT(filter, msg->chn) != FLT_FWD(filter, msg->chn) + ret))
241 task_wakeup(s->task, TASK_WOKEN_MSG);
242
243 return ret;
244}
245
246static int
247cache_store_http_end(struct stream *s, struct filter *filter,
248 struct http_msg *msg)
249{
250 struct cache_st *st = filter->ctx;
251 struct cache *cache = filter->config->conf;
252 struct shared_context *shctx = shctx_ptr(cache);
253 struct cache_entry *object;
254
255 if (!(msg->chn->flags & CF_ISRESP))
256 return 1;
257
258 if (st && st->first_block) {
259
260 object = (struct cache_entry *)st->first_block->data;
261
262 /* does not need to test if the insertion worked, if it
263 * doesn't, the blocks will be reused anyway */
264
265 shctx_lock(shctx);
William Lallemand08727662017-11-21 20:01:27 +0100266 if (eb32_insert(&cache->entries, &object->eb) != &object->eb) {
267 object->eb.key = 0;
268 }
William Lallemand4da3f8a2017-10-31 14:33:34 +0100269 /* remove from the hotlist */
William Lallemand4da3f8a2017-10-31 14:33:34 +0100270 shctx_row_dec_hot(shctx, st->first_block);
271 shctx_unlock(shctx);
272
273 }
274 if (st) {
Willy Tarreaubafbe012017-11-24 17:34:44 +0100275 pool_free(pool_head_cache_st, st);
William Lallemand4da3f8a2017-10-31 14:33:34 +0100276 filter->ctx = NULL;
277 }
278
279 return 1;
280}
281
282 /*
283 * This intends to be used when checking HTTP headers for some
284 * word=value directive. Return a pointer to the first character of value, if
285 * the word was not found or if there wasn't any value assigned ot it return NULL
286 */
287char *directive_value(const char *sample, int slen, const char *word, int wlen)
288{
289 int st = 0;
290
291 if (slen < wlen)
292 return 0;
293
294 while (wlen) {
295 char c = *sample ^ *word;
296 if (c && c != ('A' ^ 'a'))
297 return NULL;
298 sample++;
299 word++;
300 slen--;
301 wlen--;
302 }
303
304 while (slen) {
305 if (st == 0) {
306 if (*sample != '=')
307 return NULL;
308 sample++;
309 slen--;
310 st = 1;
311 continue;
312 } else {
313 return (char *)sample;
314 }
315 }
316
317 return NULL;
318}
319
320/*
321 * Return the maxage in seconds of an HTTP response.
322 * Compute the maxage using either:
323 * - the assigned max-age of the cache
324 * - the s-maxage directive
325 * - the max-age directive
326 * - (Expires - Data) headers
327 * - the default-max-age of the cache
328 *
329 */
William Lallemand49b44532017-11-24 18:53:43 +0100330int http_calc_maxage(struct stream *s, struct cache *cache)
William Lallemand4da3f8a2017-10-31 14:33:34 +0100331{
332 struct http_txn *txn = s->txn;
333 struct hdr_ctx ctx;
334
335 int smaxage = -1;
336 int maxage = -1;
337
338
William Lallemand4da3f8a2017-10-31 14:33:34 +0100339 ctx.idx = 0;
340
341 /* loop on the Cache-Control values */
342 while (http_find_header2("Cache-Control", 13, s->res.buf->p, &txn->hdr_idx, &ctx)) {
343 char *directive = ctx.line + ctx.val;
344 char *value;
345
346 value = directive_value(directive, ctx.vlen, "s-maxage", 8);
347 if (value) {
348 struct chunk *chk = get_trash_chunk();
349
350 chunk_strncat(chk, value, ctx.vlen - 8 + 1);
351 chunk_strncat(chk, "", 1);
352 maxage = atoi(chk->str);
353 }
354
355 value = directive_value(ctx.line + ctx.val, ctx.vlen, "max-age", 7);
356 if (value) {
357 struct chunk *chk = get_trash_chunk();
358
359 chunk_strncat(chk, value, ctx.vlen - 7 + 1);
360 chunk_strncat(chk, "", 1);
361 smaxage = atoi(chk->str);
362 }
363 }
364
365 /* TODO: Expires - Data */
366
367
368 if (smaxage > 0)
William Lallemand49b44532017-11-24 18:53:43 +0100369 return MIN(smaxage, cache->maxage);
William Lallemand4da3f8a2017-10-31 14:33:34 +0100370
371 if (maxage > 0)
William Lallemand49b44532017-11-24 18:53:43 +0100372 return MIN(maxage, cache->maxage);
William Lallemand4da3f8a2017-10-31 14:33:34 +0100373
William Lallemand49b44532017-11-24 18:53:43 +0100374 return cache->maxage;
William Lallemand4da3f8a2017-10-31 14:33:34 +0100375
376}
377
378
William Lallemanda400a3a2017-11-20 19:13:12 +0100379static void cache_free_blocks(struct shared_block *first, struct shared_block *block)
380{
381 if (first == block) {
382 struct cache_entry *object = (struct cache_entry *)first->data;
William Lallemand08727662017-11-21 20:01:27 +0100383 if (object->eb.key) {
384 eb32_delete(&object->eb);
385 object->eb.key = 0;
386 }
William Lallemanda400a3a2017-11-20 19:13:12 +0100387 }
388}
389
William Lallemand41db4602017-10-30 11:15:51 +0100390/*
391 * This fonction will store the headers of the response in a buffer and then
392 * register a filter to store the data
393 */
394enum act_return http_action_store_cache(struct act_rule *rule, struct proxy *px,
395 struct session *sess, struct stream *s, int flags)
396{
William Lallemand4da3f8a2017-10-31 14:33:34 +0100397 struct http_txn *txn = s->txn;
398 struct http_msg *msg = &txn->rsp;
399 struct filter *filter;
400 struct hdr_ctx ctx;
401 struct shared_block *first = NULL;
William Lallemand49b44532017-11-24 18:53:43 +0100402 struct cache *cache = (struct cache *)rule->arg.act.p[0];
403 struct shared_context *shctx = shctx_ptr(cache);
William Lallemand4da3f8a2017-10-31 14:33:34 +0100404 struct cache_entry *object;
405
406
407 /* Don't cache if the response came from a cache */
408 if ((obj_type(s->target) == OBJ_TYPE_APPLET) &&
409 s->target == &http_cache_applet.obj_type) {
410 goto out;
411 }
412
413 /* cache only HTTP/1.1 */
414 if (!(txn->req.flags & HTTP_MSGF_VER_11))
415 goto out;
416
William Lallemand18f133a2017-11-08 11:25:15 +0100417 /* does not cache if Content-Length unknown */
418 if (!(msg->flags & HTTP_MSGF_CNT_LEN))
419 goto out;
420
William Lallemand4da3f8a2017-10-31 14:33:34 +0100421 /* cache only GET method */
422 if (txn->meth != HTTP_METH_GET)
423 goto out;
424
425 /* cache only 200 status code */
426 if (txn->status != 200)
427 goto out;
428
429 /* Does not manage Vary at the moment. We will need a secondary key later for that */
430 ctx.idx = 0;
431 if (http_find_header2("Vary", 4, txn->rsp.chn->buf->p, &txn->hdr_idx, &ctx))
432 goto out;
433
Willy Tarreaufaf29092017-12-21 15:59:17 +0100434 check_response_for_cacheability(s, &s->res);
William Lallemand4da3f8a2017-10-31 14:33:34 +0100435
Willy Tarreaud4569d12017-12-22 18:03:04 +0100436 if (!(txn->flags & TX_CACHEABLE) || !(txn->flags & TX_CACHE_COOK))
William Lallemand4da3f8a2017-10-31 14:33:34 +0100437 goto out;
438
William Lallemand9d5f54d2017-11-14 14:39:22 +0100439 if ((msg->sov + msg->body_len) > (global.tune.bufsize - global.tune.maxrewrite))
William Lallemand4da3f8a2017-10-31 14:33:34 +0100440 goto out;
441
442 shctx_lock(shctx);
443
William Lallemand9d5f54d2017-11-14 14:39:22 +0100444 first = shctx_row_reserve_hot(shctx, sizeof(struct cache_entry) + msg->sov + msg->body_len);
William Lallemand4da3f8a2017-10-31 14:33:34 +0100445 if (!first) {
446 shctx_unlock(shctx);
447 goto out;
448 }
449 shctx_unlock(shctx);
450
451 /* reserve space for the cache_entry structure */
452 first->len = sizeof(struct cache_entry);
453
454 /* cache the headers in a http action because it allows to chose what
455 * to cache, for example you might want to cache a response before
456 * modifying some HTTP headers, or on the contrary after modifying
457 * those headers.
458 */
459
460 /* does not need to be locked because it's in the "hot" list,
461 * copy the headers */
William Lallemand9d5f54d2017-11-14 14:39:22 +0100462 if (shctx_row_data_append(shctx, first, (unsigned char *)s->res.buf->p, msg->sov) < 0)
William Lallemand4da3f8a2017-10-31 14:33:34 +0100463 goto out;
464
465 /* register the buffer in the filter ctx for filling it with data*/
466 if (!LIST_ISEMPTY(&s->strm_flt.filters)) {
467 list_for_each_entry(filter, &s->strm_flt.filters, list) {
468 if (filter->config->id == cache_store_flt_id &&
469 filter->config->conf == rule->arg.act.p[0]) {
470 if (filter->ctx) {
471 struct cache_st *cache_ctx = filter->ctx;
Willy Tarreauc9bd34c2017-12-22 17:42:46 +0100472 struct cache_entry *old;
William Lallemand4da3f8a2017-10-31 14:33:34 +0100473
474 cache_ctx->first_block = first;
475 object = (struct cache_entry *)first->data;
476
William Lallemandf528fff2017-11-23 19:43:17 +0100477 object->eb.key = (*(unsigned int *)&txn->cache_hash);
478 memcpy(object->hash, txn->cache_hash, sizeof(object->hash));
William Lallemand4da3f8a2017-10-31 14:33:34 +0100479 /* Insert the node later on caching success */
480
481 shctx_lock(shctx);
Willy Tarreauc9bd34c2017-12-22 17:42:46 +0100482
483 old = entry_exist(cache, txn->cache_hash);
484 if (old) {
485 eb32_delete(&old->eb);
486 old->eb.key = 0;
William Lallemand4da3f8a2017-10-31 14:33:34 +0100487 }
488 shctx_unlock(shctx);
489
490 /* store latest value and expiration time */
491 object->latest_validation = now.tv_sec;
William Lallemand49b44532017-11-24 18:53:43 +0100492 object->expire = now.tv_sec + http_calc_maxage(s, cache);
William Lallemand4da3f8a2017-10-31 14:33:34 +0100493 }
494 return ACT_RET_CONT;
495 }
496 }
497 }
498
499out:
500 /* if does not cache */
501 if (first) {
William Lallemand08727662017-11-21 20:01:27 +0100502 object = (struct cache_entry *)first->data;
503
William Lallemand4da3f8a2017-10-31 14:33:34 +0100504 shctx_lock(shctx);
William Lallemand08727662017-11-21 20:01:27 +0100505 first->len = 0;
506 object->eb.key = 0;
William Lallemand4da3f8a2017-10-31 14:33:34 +0100507 shctx_row_dec_hot(shctx, first);
508 shctx_unlock(shctx);
509 }
510
William Lallemand41db4602017-10-30 11:15:51 +0100511 return ACT_RET_CONT;
512}
513
William Lallemand77c11972017-10-31 20:43:01 +0100514#define HTTP_CACHE_INIT 0
515#define HTTP_CACHE_FWD 1
516#define HTTP_CACHE_END 2
517
William Lallemandecb73b12017-11-24 14:33:55 +0100518static void http_cache_applet_release(struct appctx *appctx)
519{
520 struct cache *cache = (struct cache *)appctx->rule->arg.act.p[0];
521 struct cache_entry *cache_ptr = appctx->ctx.cache.entry;
522 struct shared_block *first = block_ptr(cache_ptr);
523
524 shctx_lock(shctx_ptr(cache));
525 shctx_row_dec_hot(shctx_ptr(cache), first);
526 shctx_unlock(shctx_ptr(cache));
527}
528
William Lallemand77c11972017-10-31 20:43:01 +0100529static void http_cache_io_handler(struct appctx *appctx)
530{
531 struct stream_interface *si = appctx->owner;
532 struct channel *res = si_ic(si);
533 struct cache *cache = (struct cache *)appctx->rule->arg.act.p[0];
534 struct cache_entry *cache_ptr = appctx->ctx.cache.entry;
535 struct shared_context *shctx = shctx_ptr(cache);
536 struct shared_block *first = block_ptr(cache_ptr);
537
538 if (unlikely(si->state == SI_ST_DIS || si->state == SI_ST_CLO))
539 goto out;
540
541 /* Check if the input buffer is avalaible. */
542 if (res->buf->size == 0) {
543 si_applet_cant_put(si);
544 goto out;
545 }
546
547 if (res->flags & (CF_SHUTW|CF_SHUTW_NOW))
548 appctx->st0 = HTTP_CACHE_END;
549
550 /* buffer are aligned there, should be fine */
551 if (appctx->st0 == HTTP_CACHE_INIT) {
552 int len = first->len - sizeof(struct cache_entry);
553 if ((shctx_row_data_get(shctx, first, (unsigned char *)bi_end(res->buf), sizeof(struct cache_entry), len)) != 0) {
William Lallemanda71cd1d2017-11-24 18:53:42 +0100554 /* should never get there, because at the moment, a
555 * cache object can never be bigger than a buffer */
556 abort();
William Lallemand55e76742017-11-21 20:01:28 +0100557
William Lallemand77c11972017-10-31 20:43:01 +0100558 si_applet_cant_put(si);
559 goto out;
560 }
561 res->buf->i += len;
562 res->total += len;
563 appctx->st0 = HTTP_CACHE_FWD;
564 }
565
566 if (appctx->st0 == HTTP_CACHE_FWD) {
567 /* eat the whole request */
568 co_skip(si_oc(si), si_ob(si)->o); // NOTE: when disabled does not repport the correct status code
569 res->flags |= CF_READ_NULL;
570 si_shutr(si);
571 }
572
573 if ((res->flags & CF_SHUTR) && (si->state == SI_ST_EST))
574 si_shutw(si);
575out:
576 ;
577}
578
William Lallemand41db4602017-10-30 11:15:51 +0100579enum act_parse_ret parse_cache_store(const char **args, int *orig_arg, struct proxy *proxy,
580 struct act_rule *rule, char **err)
581{
582 struct flt_conf *fconf;
583 int cur_arg = *orig_arg;
584 rule->action = ACT_CUSTOM;
585 rule->action_ptr = http_action_store_cache;
586
587 if (!*args[cur_arg] || strcmp(args[cur_arg], "if") == 0 || strcmp(args[cur_arg], "unless") == 0) {
588 memprintf(err, "expects a cache name");
589 return ACT_RET_PRS_ERR;
590 }
591
592 /* check if a cache filter was already registered with this cache
593 * name, if that's the case, must use it. */
594 list_for_each_entry(fconf, &proxy->filter_configs, list) {
595 if (fconf->id == cache_store_flt_id && !strcmp((char *)fconf->conf, args[cur_arg])) {
596 rule->arg.act.p[0] = fconf->conf;
597 (*orig_arg)++;
598 /* filter already registered */
599 return ACT_RET_PRS_OK;
600 }
601 }
602
603 rule->arg.act.p[0] = strdup(args[cur_arg]);
604 if (!rule->arg.act.p[0]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100605 ha_alert("config: %s '%s': out of memory\n", proxy_type_str(proxy), proxy->id);
William Lallemand41db4602017-10-30 11:15:51 +0100606 err++;
607 goto err;
608 }
609 /* register a filter to fill the cache buffer */
610 fconf = calloc(1, sizeof(*fconf));
611 if (!fconf) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100612 ha_alert("config: %s '%s': out of memory\n",
613 proxy_type_str(proxy), proxy->id);
William Lallemand41db4602017-10-30 11:15:51 +0100614 err++;
615 goto err;
616 }
617 fconf->id = cache_store_flt_id;
618 fconf->conf = rule->arg.act.p[0]; /* store the proxy name */
619 fconf->ops = &cache_ops;
620 LIST_ADDQ(&proxy->filter_configs, &fconf->list);
621
622 (*orig_arg)++;
623
624 return ACT_RET_PRS_OK;
625
626err:
Olivier Houchardfccf8402017-11-01 14:04:02 +0100627 return ACT_RET_PRS_ERR;
William Lallemand41db4602017-10-30 11:15:51 +0100628}
629
William Lallemandf528fff2017-11-23 19:43:17 +0100630/* This produces a sha1 hash of the concatenation of the first
631 * occurrence of the Host header followed by the path component if it
632 * begins with a slash ('/'). */
633int sha1_hosturi(struct http_txn *txn)
634{
635 struct hdr_ctx ctx;
636
637 blk_SHA_CTX sha1_ctx;
638 struct chunk *trash;
639 char *path;
640 char *end;
641 trash = get_trash_chunk();
642
643 /* retrive the host */
644 ctx.idx = 0;
645 if (!http_find_header2("Host", 4, txn->req.chn->buf->p, &txn->hdr_idx, &ctx))
646 return 0;
647 chunk_strncat(trash, ctx.line + ctx.val, ctx.vlen);
648
649 /* now retrieve the path */
650 end = txn->req.chn->buf->p + txn->req.sl.rq.u + txn->req.sl.rq.u_l;
651 path = http_get_path(txn);
652 if (!path)
653 return 0;
654 chunk_strncat(trash, path, end - path);
655
656 /* hash everything */
657 blk_SHA1_Init(&sha1_ctx);
658 blk_SHA1_Update(&sha1_ctx, trash->str, trash->len);
659 blk_SHA1_Final((unsigned char *)txn->cache_hash, &sha1_ctx);
660
661 return 1;
662}
663
664
William Lallemand41db4602017-10-30 11:15:51 +0100665
666enum act_return http_action_req_cache_use(struct act_rule *rule, struct proxy *px,
667 struct session *sess, struct stream *s, int flags)
668{
William Lallemand77c11972017-10-31 20:43:01 +0100669
William Lallemand77c11972017-10-31 20:43:01 +0100670 struct cache_entry *res;
William Lallemand77c11972017-10-31 20:43:01 +0100671 struct cache *cache = (struct cache *)rule->arg.act.p[0];
672
Willy Tarreau504455c2017-12-22 17:47:35 +0100673 check_request_for_cacheability(s, &s->req);
674 if ((s->txn->flags & (TX_CACHE_IGNORE|TX_CACHEABLE)) == TX_CACHE_IGNORE)
675 return ACT_RET_CONT;
676
Willy Tarreau7704b1e2017-12-22 16:32:43 +0100677 if (!sha1_hosturi(s->txn))
678 return ACT_RET_CONT;
William Lallemandf528fff2017-11-23 19:43:17 +0100679
Willy Tarreau504455c2017-12-22 17:47:35 +0100680 if (s->txn->flags & TX_CACHE_IGNORE)
681 return ACT_RET_CONT;
682
William Lallemanda400a3a2017-11-20 19:13:12 +0100683 shctx_lock(shctx_ptr(cache));
William Lallemandf528fff2017-11-23 19:43:17 +0100684 res = entry_exist(cache, s->txn->cache_hash);
William Lallemand77c11972017-10-31 20:43:01 +0100685 if (res) {
686 struct appctx *appctx;
William Lallemanda400a3a2017-11-20 19:13:12 +0100687 shctx_row_inc_hot(shctx_ptr(cache), block_ptr(res));
688 shctx_unlock(shctx_ptr(cache));
William Lallemand77c11972017-10-31 20:43:01 +0100689 s->target = &http_cache_applet.obj_type;
690 if ((appctx = stream_int_register_handler(&s->si[1], objt_applet(s->target)))) {
691 appctx->st0 = HTTP_CACHE_INIT;
692 appctx->rule = rule;
693 appctx->ctx.cache.entry = res;
Olivier Houchardfccf8402017-11-01 14:04:02 +0100694 return ACT_RET_CONT;
William Lallemand77c11972017-10-31 20:43:01 +0100695 } else {
William Lallemand55e76742017-11-21 20:01:28 +0100696 shctx_lock(shctx_ptr(cache));
697 shctx_row_dec_hot(shctx_ptr(cache), block_ptr(res));
698 shctx_unlock(shctx_ptr(cache));
Olivier Houchardfccf8402017-11-01 14:04:02 +0100699 return ACT_RET_YIELD;
William Lallemand77c11972017-10-31 20:43:01 +0100700 }
701 }
William Lallemanda400a3a2017-11-20 19:13:12 +0100702 shctx_unlock(shctx_ptr(cache));
Olivier Houchardfccf8402017-11-01 14:04:02 +0100703 return ACT_RET_CONT;
William Lallemand41db4602017-10-30 11:15:51 +0100704}
705
706
707enum act_parse_ret parse_cache_use(const char **args, int *orig_arg, struct proxy *proxy,
708 struct act_rule *rule, char **err)
709{
710 int cur_arg = *orig_arg;
711
712 rule->action = ACT_CUSTOM;
713 rule->action_ptr = http_action_req_cache_use;
714
715 if (!*args[cur_arg] || strcmp(args[cur_arg], "if") == 0 || strcmp(args[cur_arg], "unless") == 0) {
716 memprintf(err, "expects a cache name");
717 return ACT_RET_PRS_ERR;
718 }
719
720 rule->arg.act.p[0] = strdup(args[cur_arg]);
721 if (!rule->arg.act.p[0]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100722 ha_alert("config: %s '%s': out of memory\n", proxy_type_str(proxy), proxy->id);
William Lallemand41db4602017-10-30 11:15:51 +0100723 err++;
724 goto err;
725 }
726
727 (*orig_arg)++;
728 return ACT_RET_PRS_OK;
729
730err:
Olivier Houchardfccf8402017-11-01 14:04:02 +0100731 return ACT_RET_PRS_ERR;
William Lallemand41db4602017-10-30 11:15:51 +0100732
733}
734
735int cfg_parse_cache(const char *file, int linenum, char **args, int kwm)
736{
737 int err_code = 0;
738
739 if (strcmp(args[0], "cache") == 0) { /* new cache section */
740
741 if (!*args[1]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100742 ha_alert("parsing [%s:%d] : '%s' expects an <id> argument\n",
743 file, linenum, args[0]);
William Lallemand41db4602017-10-30 11:15:51 +0100744 err_code |= ERR_ALERT | ERR_ABORT;
745 goto out;
746 }
747
748 if (alertif_too_many_args(1, file, linenum, args, &err_code)) {
749 err_code |= ERR_ABORT;
750 goto out;
751 }
752
753 if (tmp_cache_config == NULL) {
754 tmp_cache_config = calloc(1, sizeof(*tmp_cache_config));
755 if (!tmp_cache_config) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100756 ha_alert("parsing [%s:%d]: out of memory.\n", file, linenum);
William Lallemand41db4602017-10-30 11:15:51 +0100757 err_code |= ERR_ALERT | ERR_ABORT;
758 goto out;
759 }
760
761 strlcpy2(tmp_cache_config->id, args[1], 33);
762 if (strlen(args[1]) > 32) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100763 ha_warning("parsing [%s:%d]: cache id is limited to 32 characters, truncate to '%s'.\n",
764 file, linenum, tmp_cache_config->id);
William Lallemand41db4602017-10-30 11:15:51 +0100765 err_code |= ERR_WARN;
766 }
William Lallemand49b44532017-11-24 18:53:43 +0100767 tmp_cache_config->maxage = 60;
William Lallemand41db4602017-10-30 11:15:51 +0100768 tmp_cache_config->maxblocks = 0;
769 }
770 } else if (strcmp(args[0], "total-max-size") == 0) {
771 int maxsize;
772
773 if (alertif_too_many_args(1, file, linenum, args, &err_code)) {
774 err_code |= ERR_ABORT;
775 goto out;
776 }
777
778 /* size in megabytes */
779 maxsize = atoi(args[1]) * 1024 * 1024 / CACHE_BLOCKSIZE;
780 tmp_cache_config->maxblocks = maxsize;
781
William Lallemand49b44532017-11-24 18:53:43 +0100782 } else if (strcmp(args[0], "max-age") == 0) {
783 if (alertif_too_many_args(1, file, linenum, args, &err_code)) {
784 err_code |= ERR_ABORT;
785 goto out;
786 }
787
788 if (!*args[1]) {
789 ha_warning("parsing [%s:%d]: '%s' expects an age parameter in seconds.\n",
790 file, linenum, args[0]);
791 err_code |= ERR_WARN;
792 }
793
794 tmp_cache_config->maxage = atoi(args[1]);
William Lallemand41db4602017-10-30 11:15:51 +0100795 } else if (*args[0] != 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100796 ha_alert("parsing [%s:%d] : unknown keyword '%s' in 'cache' section\n", file, linenum, args[0]);
William Lallemand41db4602017-10-30 11:15:51 +0100797 err_code |= ERR_ALERT | ERR_FATAL;
798 goto out;
799 }
800out:
801 return err_code;
802}
803
804/* once the cache section is parsed */
805
806int cfg_post_parse_section_cache()
807{
808 struct shared_context *shctx;
809 int err_code = 0;
810 int ret_shctx;
811
812 if (tmp_cache_config) {
813 struct cache *cache;
814
815 if (tmp_cache_config->maxblocks <= 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100816 ha_alert("Size not specified for cache '%s'\n", tmp_cache_config->id);
William Lallemand41db4602017-10-30 11:15:51 +0100817 err_code |= ERR_FATAL | ERR_ALERT;
818 goto out;
819 }
820
821 ret_shctx = shctx_init(&shctx, tmp_cache_config->maxblocks, CACHE_BLOCKSIZE, sizeof(struct cache), 1);
William Lallemand4da3f8a2017-10-31 14:33:34 +0100822
William Lallemand41db4602017-10-30 11:15:51 +0100823 if (ret_shctx < 0) {
824 if (ret_shctx == SHCTX_E_INIT_LOCK)
Christopher Faulet767a84b2017-11-24 16:50:31 +0100825 ha_alert("Unable to initialize the lock for the cache.\n");
William Lallemand41db4602017-10-30 11:15:51 +0100826 else
Christopher Faulet767a84b2017-11-24 16:50:31 +0100827 ha_alert("Unable to allocate cache.\n");
William Lallemand41db4602017-10-30 11:15:51 +0100828
829 err_code |= ERR_FATAL | ERR_ALERT;
830 goto out;
831 }
William Lallemanda400a3a2017-11-20 19:13:12 +0100832 shctx->free_block = cache_free_blocks;
William Lallemand41db4602017-10-30 11:15:51 +0100833 memcpy(shctx->data, tmp_cache_config, sizeof(struct cache));
834 cache = (struct cache *)shctx->data;
835 cache->entries = EB_ROOT_UNIQUE;
William Lallemand41db4602017-10-30 11:15:51 +0100836 LIST_ADDQ(&caches, &cache->list);
837 }
838out:
839 free(tmp_cache_config);
840 tmp_cache_config = NULL;
841 return err_code;
842
843}
844
845/*
846 * Resolve the cache name to a pointer once the file is completely read.
847 */
848int cfg_cache_postparser()
849{
850 struct act_rule *hresrule, *hrqrule;
851 void *cache_ptr;
852 struct cache *cache;
853 struct proxy *curproxy = NULL;
854 int err = 0;
855 struct flt_conf *fconf;
856
Olivier Houchardfbc74e82017-11-24 16:54:05 +0100857 for (curproxy = proxies_list; curproxy; curproxy = curproxy->next) {
William Lallemand41db4602017-10-30 11:15:51 +0100858
859 /* resolve the http response cache name to a ptr in the action rule */
860 list_for_each_entry(hresrule, &curproxy->http_res_rules, list) {
861 if (hresrule->action != ACT_CUSTOM ||
862 hresrule->action_ptr != http_action_store_cache)
863 continue;
864
865 cache_ptr = hresrule->arg.act.p[0];
866
867 list_for_each_entry(cache, &caches, list) {
868 if (!strcmp(cache->id, cache_ptr)) {
869 /* don't free there, it's still used in the filter conf */
870 cache_ptr = cache;
871 break;
872 }
873 }
874
875 if (cache_ptr == hresrule->arg.act.p[0]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100876 ha_alert("Proxy '%s': unable to find the cache '%s' referenced by http-response cache-store rule.\n",
877 curproxy->id, (char *)hresrule->arg.act.p[0]);
William Lallemand41db4602017-10-30 11:15:51 +0100878 err++;
879 }
880
881 hresrule->arg.act.p[0] = cache_ptr;
882 }
883
884 /* resolve the http request cache name to a ptr in the action rule */
885 list_for_each_entry(hrqrule, &curproxy->http_req_rules, list) {
886 if (hrqrule->action != ACT_CUSTOM ||
887 hrqrule->action_ptr != http_action_req_cache_use)
888 continue;
889
890 cache_ptr = hrqrule->arg.act.p[0];
891
892 list_for_each_entry(cache, &caches, list) {
893 if (!strcmp(cache->id, cache_ptr)) {
894 free(cache_ptr);
895 cache_ptr = cache;
896 break;
897 }
898 }
899
900 if (cache_ptr == hrqrule->arg.act.p[0]) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100901 ha_alert("Proxy '%s': unable to find the cache '%s' referenced by http-request cache-use rule.\n",
902 curproxy->id, (char *)hrqrule->arg.act.p[0]);
William Lallemand41db4602017-10-30 11:15:51 +0100903 err++;
904 }
905
906 hrqrule->arg.act.p[0] = cache_ptr;
907 }
908
909 /* resolve the cache name to a ptr in the filter config */
910 list_for_each_entry(fconf, &curproxy->filter_configs, list) {
911
William Lallemand9c54c532017-11-02 16:38:42 +0100912 if (fconf->id != cache_store_flt_id)
913 continue;
914
William Lallemand41db4602017-10-30 11:15:51 +0100915 cache_ptr = fconf->conf;
916
917 list_for_each_entry(cache, &caches, list) {
918 if (!strcmp(cache->id, cache_ptr)) {
919 /* there can be only one filter per cache, so we free it there */
920 free(cache_ptr);
921 cache_ptr = cache;
922 break;
923 }
924 }
925
926 if (cache_ptr == fconf->conf) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100927 ha_alert("Proxy '%s': unable to find the cache '%s' referenced by the filter 'cache'.\n",
928 curproxy->id, (char *)fconf->conf);
William Lallemand41db4602017-10-30 11:15:51 +0100929 err++;
930 }
931 fconf->conf = cache_ptr;
932 }
933 }
934 return err;
935}
936
937
938struct flt_ops cache_ops = {
939 .init = cache_store_init,
940
William Lallemand4da3f8a2017-10-31 14:33:34 +0100941 /* Handle channels activity */
942 .channel_start_analyze = cache_store_chn_start_analyze,
William Lallemand49dc0482017-11-24 14:33:54 +0100943 .channel_end_analyze = cache_store_chn_end_analyze,
William Lallemand4da3f8a2017-10-31 14:33:34 +0100944
945 /* Filter HTTP requests and responses */
946 .http_headers = cache_store_http_headers,
947 .http_end = cache_store_http_end,
948
949 .http_forward_data = cache_store_http_forward_data,
950
William Lallemand41db4602017-10-30 11:15:51 +0100951};
952
William Lallemand1f49a362017-11-21 20:01:26 +0100953static int cli_parse_show_cache(char **args, struct appctx *appctx, void *private)
954{
955 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
956 return 1;
957
958 return 0;
959}
960
961static int cli_io_handler_show_cache(struct appctx *appctx)
962{
963 struct cache* cache = appctx->ctx.cli.p0;
964 struct stream_interface *si = appctx->owner;
965
966 chunk_reset(&trash);
967
968
969 if (cache == NULL) {
970 cache = LIST_ELEM((caches).n, typeof(struct cache *), list);
971 }
972
973 list_for_each_entry_from(cache, &caches, list) {
974 struct eb32_node *node = NULL;
975 unsigned int next_key;
976 struct cache_entry *entry;
977
978 chunk_appendf(&trash, "%p: %s (shctx:%p, available blocks:%d)\n", cache, cache->id, shctx_ptr(cache), shctx_ptr(cache)->nbav);
979
980 next_key = appctx->ctx.cli.i0;
981
982 appctx->ctx.cli.p0 = cache;
983
984 while (1) {
985
986 shctx_lock(shctx_ptr(cache));
987 node = eb32_lookup_ge(&cache->entries, next_key);
988 if (!node) {
989 shctx_unlock(shctx_ptr(cache));
990 break;
991 }
992
993 entry = container_of(node, struct cache_entry, eb);
William Lallemandf528fff2017-11-23 19:43:17 +0100994 chunk_appendf(&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 +0100995
996 next_key = node->key + 1;
997 appctx->ctx.cli.i0 = next_key;
998
999 shctx_unlock(shctx_ptr(cache));
1000
1001 if (ci_putchk(si_ic(si), &trash) == -1) {
1002 si_applet_cant_put(si);
1003 return 0;
1004 }
1005 }
1006
1007 }
1008
1009 return 1;
1010
1011}
1012
1013static struct cli_kw_list cli_kws = {{},{
William Lallemande899af82017-11-22 16:41:26 +01001014 { { "show", "cache", NULL }, "show cache : show cache status", cli_parse_show_cache, cli_io_handler_show_cache, NULL, NULL },
1015 {{},}
William Lallemand1f49a362017-11-21 20:01:26 +01001016}};
1017
1018
William Lallemand41db4602017-10-30 11:15:51 +01001019static struct action_kw_list http_res_actions = {
1020 .kw = {
1021 { "cache-store", parse_cache_store },
1022 { NULL, NULL }
1023 }
1024};
1025
1026static struct action_kw_list http_req_actions = {
1027 .kw = {
1028 { "cache-use", parse_cache_use },
1029 { NULL, NULL }
1030 }
1031};
1032
1033struct applet http_cache_applet = {
1034 .obj_type = OBJ_TYPE_APPLET,
1035 .name = "<CACHE>", /* used for logging */
William Lallemand77c11972017-10-31 20:43:01 +01001036 .fct = http_cache_io_handler,
William Lallemandecb73b12017-11-24 14:33:55 +01001037 .release = http_cache_applet_release,
William Lallemand41db4602017-10-30 11:15:51 +01001038};
1039
1040__attribute__((constructor))
1041static void __cache_init(void)
1042{
1043 cfg_register_section("cache", cfg_parse_cache, cfg_post_parse_section_cache);
1044 cfg_register_postparser("cache", cfg_cache_postparser);
William Lallemand1f49a362017-11-21 20:01:26 +01001045 cli_register_kw(&cli_kws);
William Lallemand41db4602017-10-30 11:15:51 +01001046 http_res_keywords_register(&http_res_actions);
1047 http_req_keywords_register(&http_req_actions);
Willy Tarreaubafbe012017-11-24 17:34:44 +01001048 pool_head_cache_st = create_pool("cache_st", sizeof(struct cache_st), MEM_F_SHARED);
William Lallemand41db4602017-10-30 11:15:51 +01001049}
1050