blob: 9db87c12d706a3fd809b8dae2c4bb94e567cf3e7 [file] [log] [blame]
Christopher Faulet47596d32018-10-22 09:17:28 +02001/*
2 * Functions to manipulate HTTP messages using the internal representation.
3 *
4 * Copyright (C) 2018 HAProxy Technologies, Christopher Faulet <cfaulet@haproxy.com>
5 *
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version
9 * 2 of the License, or (at your option) any later version.
10 *
11 */
12
13#include <common/config.h>
Christopher Faulet29f17582019-05-23 11:03:26 +020014#include <common/debug.h>
Christopher Fauleta7b677c2018-11-29 16:48:49 +010015#include <common/cfgparse.h>
Willy Tarreauafba57a2018-12-11 13:44:24 +010016#include <common/h1.h>
Christopher Faulet47596d32018-10-22 09:17:28 +020017#include <common/http.h>
Willy Tarreaub96b77e2018-12-11 10:22:41 +010018#include <common/htx.h>
Christopher Faulet47596d32018-10-22 09:17:28 +020019
20#include <proto/http_htx.h>
Christopher Faulet47596d32018-10-22 09:17:28 +020021
Christopher Fauleta7b677c2018-11-29 16:48:49 +010022struct buffer htx_err_chunks[HTTP_ERR_SIZE];
23
Christopher Faulet297fbb42019-05-13 14:41:27 +020024/* Returns the next unporocessed start line in the HTX message. It returns NULL
Christopher Faulet29f17582019-05-23 11:03:26 +020025 * if the start-line is undefined (first == -1). Otherwise, it returns the
Christopher Faulet297fbb42019-05-13 14:41:27 +020026 * pointer on the htx_sl structure.
Christopher Faulet47596d32018-10-22 09:17:28 +020027 */
Christopher Faulet297fbb42019-05-13 14:41:27 +020028struct htx_sl *http_get_stline(struct htx *htx)
Christopher Faulet47596d32018-10-22 09:17:28 +020029{
Christopher Faulet297fbb42019-05-13 14:41:27 +020030 struct htx_blk *blk;
Christopher Faulet573fe732018-11-28 16:55:12 +010031
Christopher Faulet29f17582019-05-23 11:03:26 +020032 BUG_ON(htx->first == -1);
33 blk = htx_get_first_blk(htx);
Christopher Faulet297fbb42019-05-13 14:41:27 +020034 if (!blk)
35 return NULL;
Christopher Faulet29f17582019-05-23 11:03:26 +020036 BUG_ON(htx_get_blk_type(blk) != HTX_BLK_REQ_SL && htx_get_blk_type(blk) != HTX_BLK_RES_SL);
Christopher Faulet297fbb42019-05-13 14:41:27 +020037 return htx_get_blk_ptr(htx, blk);
Christopher Faulet47596d32018-10-22 09:17:28 +020038}
39
40/* Finds the first or next occurrence of header <name> in the HTX message <htx>
41 * using the context <ctx>. This structure holds everything necessary to use the
42 * header and find next occurrence. If its <blk> member is NULL, the header is
43 * searched from the beginning. Otherwise, the next occurrence is returned. The
44 * function returns 1 when it finds a value, and 0 when there is no more. It is
45 * designed to work with headers defined as comma-separated lists. If <full> is
46 * set, it works on full-line headers in whose comma is not a delimiter but is
47 * part of the syntax. A special case, if ctx->value is NULL when searching for
48 * a new values of a header, the current header is rescanned. This allows
49 * rescanning after a header deletion.
50 */
51int http_find_header(const struct htx *htx, const struct ist name,
52 struct http_hdr_ctx *ctx, int full)
53{
54 struct htx_blk *blk = ctx->blk;
55 struct ist n, v;
56 enum htx_blk_type type;
Christopher Faulet47596d32018-10-22 09:17:28 +020057
58 if (blk) {
59 char *p;
60
Christopher Faulet47596d32018-10-22 09:17:28 +020061 if (!ctx->value.ptr)
62 goto rescan_hdr;
63 if (full)
64 goto next_blk;
65 v = htx_get_blk_value(htx, blk);
66 p = ctx->value.ptr + ctx->value.len + ctx->lws_after;
67 v.len -= (p - v.ptr);
68 v.ptr = p;
69 if (!v.len)
70 goto next_blk;
71 /* Skip comma */
72 if (*(v.ptr) == ',') {
73 v.ptr++;
74 v.len--;
75 }
76
77 goto return_hdr;
78 }
79
80 if (!htx->used)
81 return 0;
82
Christopher Fauleta3f15502019-05-13 15:27:23 +020083 for (blk = htx_get_first_blk(htx); blk; blk = htx_get_next_blk(htx, blk)) {
Christopher Faulet47596d32018-10-22 09:17:28 +020084 rescan_hdr:
Christopher Faulet47596d32018-10-22 09:17:28 +020085 type = htx_get_blk_type(blk);
Christopher Faulet573fe732018-11-28 16:55:12 +010086 if (type == HTX_BLK_EOH || type == HTX_BLK_EOM)
87 break;
Christopher Faulet47596d32018-10-22 09:17:28 +020088 if (type != HTX_BLK_HDR)
Christopher Faulet28f29c72019-04-30 17:55:45 +020089 continue;
Christopher Faulet47596d32018-10-22 09:17:28 +020090 if (name.len) {
91 /* If no name was passed, we want any header. So skip the comparison */
92 n = htx_get_blk_name(htx, blk);
93 if (!isteqi(n, name))
94 goto next_blk;
95 }
96 v = htx_get_blk_value(htx, blk);
97
98 return_hdr:
99 ctx->lws_before = 0;
100 ctx->lws_after = 0;
101 while (v.len && HTTP_IS_LWS(*v.ptr)) {
102 v.ptr++;
103 v.len--;
104 ctx->lws_before++;
105 }
106 if (!full)
107 v.len = http_find_hdr_value_end(v.ptr, v.ptr + v.len) - v.ptr;
108 while (v.len && HTTP_IS_LWS(*(v.ptr + v.len - 1))) {
109 v.len--;
110 ctx->lws_after++;
111 }
112 if (!v.len)
Christopher Faulet28f29c72019-04-30 17:55:45 +0200113 continue;
Christopher Faulet47596d32018-10-22 09:17:28 +0200114 ctx->blk = blk;
115 ctx->value = v;
116 return 1;
117
118 next_blk:
Christopher Faulet28f29c72019-04-30 17:55:45 +0200119 ;
Christopher Faulet47596d32018-10-22 09:17:28 +0200120 }
121
122 ctx->blk = NULL;
123 ctx->value = ist("");
124 ctx->lws_before = ctx->lws_after = 0;
125 return 0;
126}
127
128/* Adds a header block int the HTX message <htx>, just before the EOH block. It
129 * returns 1 on success, otherwise it returns 0.
130 */
131int http_add_header(struct htx *htx, const struct ist n, const struct ist v)
132{
133 struct htx_blk *blk;
134 enum htx_blk_type type = htx_get_tail_type(htx);
135 int32_t prev;
136
137 blk = htx_add_header(htx, n, v);
138 if (!blk)
139 return 0;
140
141 if (unlikely(type < HTX_BLK_EOH))
142 return 1;
143
144 /* <blk> is the head, swap it iteratively with its predecessor to place
145 * it just before the end-of-header block. So blocks remains ordered. */
Christopher Faulet29f17582019-05-23 11:03:26 +0200146 for (prev = htx_get_prev(htx, htx->tail); prev != htx->first; prev = htx_get_prev(htx, prev)) {
Christopher Faulet47596d32018-10-22 09:17:28 +0200147 struct htx_blk *pblk = htx_get_blk(htx, prev);
148 enum htx_blk_type type = htx_get_blk_type(pblk);
149
150 /* Swap .addr and .info fields */
151 blk->addr ^= pblk->addr; pblk->addr ^= blk->addr; blk->addr ^= pblk->addr;
152 blk->info ^= pblk->info; pblk->info ^= blk->info; blk->info ^= pblk->info;
153
154 if (blk->addr == pblk->addr)
155 blk->addr += htx_get_blksz(pblk);
Christopher Faulet47596d32018-10-22 09:17:28 +0200156
157 /* Stop when end-of-header is reached */
158 if (type == HTX_BLK_EOH)
159 break;
160
161 blk = pblk;
162 }
Christopher Faulet05aab642019-04-11 13:43:57 +0200163
Christopher Faulet47596d32018-10-22 09:17:28 +0200164 return 1;
165}
166
Christopher Fauletf1ba18d2018-11-26 21:37:08 +0100167/* Replaces parts of the start-line of the HTX message <htx>. It returns 1 on
Christopher Faulet29f17582019-05-23 11:03:26 +0200168 * success, otherwise it returns 0.
Christopher Faulet47596d32018-10-22 09:17:28 +0200169 */
Christopher Fauletf1ba18d2018-11-26 21:37:08 +0100170int http_replace_stline(struct htx *htx, const struct ist p1, const struct ist p2, const struct ist p3)
Christopher Faulet47596d32018-10-22 09:17:28 +0200171{
Christopher Faulet7b7d5072019-05-13 15:22:59 +0200172 struct htx_blk *blk;
Christopher Faulet47596d32018-10-22 09:17:28 +0200173
Christopher Faulet29f17582019-05-23 11:03:26 +0200174 blk = htx_get_first_blk(htx);
175 if (!blk || !htx_replace_stline(htx, blk, p1, p2, p3))
Christopher Faulet7b7d5072019-05-13 15:22:59 +0200176 return 0;
177 return 1;
Christopher Faulet47596d32018-10-22 09:17:28 +0200178}
179
Christopher Faulete010c802018-10-24 10:36:45 +0200180/* Replace the request method in the HTX message <htx> by <meth>. It returns 1
181 * on success, otherwise 0.
182 */
183int http_replace_req_meth(struct htx *htx, const struct ist meth)
184{
185 struct buffer *temp = get_trash_chunk();
Christopher Faulet297fbb42019-05-13 14:41:27 +0200186 struct htx_sl *sl = http_get_stline(htx);
Christopher Fauletf1ba18d2018-11-26 21:37:08 +0100187 struct ist uri, vsn;
Christopher Faulete010c802018-10-24 10:36:45 +0200188
Willy Tarreaucdce54c2019-02-12 12:02:27 +0100189 if (!sl)
190 return 0;
191
Christopher Faulete010c802018-10-24 10:36:45 +0200192 /* Start by copying old uri and version */
Christopher Fauletf1ba18d2018-11-26 21:37:08 +0100193 chunk_memcat(temp, HTX_SL_REQ_UPTR(sl), HTX_SL_REQ_ULEN(sl)); /* uri */
194 uri = ist2(temp->area, HTX_SL_REQ_ULEN(sl));
Christopher Faulete010c802018-10-24 10:36:45 +0200195
Christopher Fauletf1ba18d2018-11-26 21:37:08 +0100196 chunk_memcat(temp, HTX_SL_REQ_VPTR(sl), HTX_SL_REQ_VLEN(sl)); /* vsn */
197 vsn = ist2(temp->area + uri.len, HTX_SL_REQ_VLEN(sl));
Christopher Faulete010c802018-10-24 10:36:45 +0200198
Christopher Fauletf1ba18d2018-11-26 21:37:08 +0100199 /* create the new start line */
200 sl->info.req.meth = find_http_meth(meth.ptr, meth.len);
201 return http_replace_stline(htx, meth, uri, vsn);
Christopher Faulete010c802018-10-24 10:36:45 +0200202}
203
204/* Replace the request uri in the HTX message <htx> by <uri>. It returns 1 on
205 * success, otherwise 0.
206 */
207int http_replace_req_uri(struct htx *htx, const struct ist uri)
208{
209 struct buffer *temp = get_trash_chunk();
Christopher Faulet297fbb42019-05-13 14:41:27 +0200210 struct htx_sl *sl = http_get_stline(htx);
Christopher Fauletf1ba18d2018-11-26 21:37:08 +0100211 struct ist meth, vsn;
Christopher Faulete010c802018-10-24 10:36:45 +0200212
Willy Tarreaucdce54c2019-02-12 12:02:27 +0100213 if (!sl)
214 return 0;
215
Christopher Faulete010c802018-10-24 10:36:45 +0200216 /* Start by copying old method and version */
Christopher Fauletf1ba18d2018-11-26 21:37:08 +0100217 chunk_memcat(temp, HTX_SL_REQ_MPTR(sl), HTX_SL_REQ_MLEN(sl)); /* meth */
218 meth = ist2(temp->area, HTX_SL_REQ_MLEN(sl));
Christopher Faulete010c802018-10-24 10:36:45 +0200219
Christopher Fauletf1ba18d2018-11-26 21:37:08 +0100220 chunk_memcat(temp, HTX_SL_REQ_VPTR(sl), HTX_SL_REQ_VLEN(sl)); /* vsn */
221 vsn = ist2(temp->area + meth.len, HTX_SL_REQ_VLEN(sl));
Christopher Faulete010c802018-10-24 10:36:45 +0200222
Christopher Fauletf1ba18d2018-11-26 21:37:08 +0100223 /* create the new start line */
224 return http_replace_stline(htx, meth, uri, vsn);
Christopher Faulete010c802018-10-24 10:36:45 +0200225}
226
227/* Replace the request path in the HTX message <htx> by <path>. The host part
228 * and the query string are preserved. It returns 1 on success, otherwise 0.
229 */
230int http_replace_req_path(struct htx *htx, const struct ist path)
231{
232 struct buffer *temp = get_trash_chunk();
Christopher Faulet297fbb42019-05-13 14:41:27 +0200233 struct htx_sl *sl = http_get_stline(htx);
Christopher Fauletf1ba18d2018-11-26 21:37:08 +0100234 struct ist meth, uri, vsn, p;
Christopher Faulete010c802018-10-24 10:36:45 +0200235 size_t plen = 0;
236
Willy Tarreaucdce54c2019-02-12 12:02:27 +0100237 if (!sl)
238 return 0;
239
Christopher Fauletf1ba18d2018-11-26 21:37:08 +0100240 uri = htx_sl_req_uri(sl);
241 p = http_get_path(uri);
Christopher Faulete010c802018-10-24 10:36:45 +0200242 if (!p.ptr)
Christopher Fauletf1ba18d2018-11-26 21:37:08 +0100243 p = uri;
Christopher Faulete010c802018-10-24 10:36:45 +0200244 while (plen < p.len && *(p.ptr + plen) != '?')
245 plen++;
246
247 /* Start by copying old method and version and create the new uri */
Christopher Fauletf1ba18d2018-11-26 21:37:08 +0100248 chunk_memcat(temp, HTX_SL_REQ_MPTR(sl), HTX_SL_REQ_MLEN(sl)); /* meth */
249 meth = ist2(temp->area, HTX_SL_REQ_MLEN(sl));
Christopher Faulete010c802018-10-24 10:36:45 +0200250
Christopher Fauletf1ba18d2018-11-26 21:37:08 +0100251 chunk_memcat(temp, HTX_SL_REQ_VPTR(sl), HTX_SL_REQ_VLEN(sl)); /* vsn */
252 vsn = ist2(temp->area + meth.len, HTX_SL_REQ_VLEN(sl));
253
254 chunk_memcat(temp, uri.ptr, p.ptr - uri.ptr); /* uri: host part */
Christopher Faulete010c802018-10-24 10:36:45 +0200255 chunk_memcat(temp, path.ptr, path.len); /* uri: new path */
256 chunk_memcat(temp, p.ptr + plen, p.len - plen); /* uri: QS part */
Christopher Fauletf1ba18d2018-11-26 21:37:08 +0100257 uri = ist2(temp->area + meth.len + vsn.len, uri.len - plen + path.len);
Christopher Faulete010c802018-10-24 10:36:45 +0200258
259 /* create the new start line */
Christopher Fauletf1ba18d2018-11-26 21:37:08 +0100260 return http_replace_stline(htx, meth, uri, vsn);
Christopher Faulete010c802018-10-24 10:36:45 +0200261}
262
263/* Replace the request query-string in the HTX message <htx> by <query>. The
264 * host part and the path are preserved. It returns 1 on success, otherwise
265 * 0.
266 */
267int http_replace_req_query(struct htx *htx, const struct ist query)
268{
269 struct buffer *temp = get_trash_chunk();
Christopher Faulet297fbb42019-05-13 14:41:27 +0200270 struct htx_sl *sl = http_get_stline(htx);
Christopher Fauletf1ba18d2018-11-26 21:37:08 +0100271 struct ist meth, uri, vsn, q;
Christopher Faulete010c802018-10-24 10:36:45 +0200272 int offset = 1;
273
Willy Tarreaucdce54c2019-02-12 12:02:27 +0100274 if (!sl)
275 return 0;
276
Christopher Fauletf1ba18d2018-11-26 21:37:08 +0100277 uri = htx_sl_req_uri(sl);
278 q = uri;
Christopher Faulete010c802018-10-24 10:36:45 +0200279 while (q.len > 0 && *(q.ptr) != '?') {
280 q.ptr++;
281 q.len--;
282 }
283
284 /* skip the question mark or indicate that we must insert it
285 * (but only if the format string is not empty then).
286 */
287 if (q.len) {
288 q.ptr++;
289 q.len--;
290 }
291 else if (query.len > 1)
292 offset = 0;
293
294 /* Start by copying old method and version and create the new uri */
Christopher Fauletf1ba18d2018-11-26 21:37:08 +0100295 chunk_memcat(temp, HTX_SL_REQ_MPTR(sl), HTX_SL_REQ_MLEN(sl)); /* meth */
296 meth = ist2(temp->area, HTX_SL_REQ_MLEN(sl));
Christopher Faulete010c802018-10-24 10:36:45 +0200297
Christopher Fauletf1ba18d2018-11-26 21:37:08 +0100298 chunk_memcat(temp, HTX_SL_REQ_VPTR(sl), HTX_SL_REQ_VLEN(sl)); /* vsn */
299 vsn = ist2(temp->area + meth.len, HTX_SL_REQ_VLEN(sl));
Christopher Faulete010c802018-10-24 10:36:45 +0200300
Christopher Fauletf1ba18d2018-11-26 21:37:08 +0100301 chunk_memcat(temp, uri.ptr, q.ptr - uri.ptr); /* uri: host + path part */
302 chunk_memcat(temp, query.ptr + offset, query.len - offset); /* uri: new QS */
303 uri = ist2(temp->area + meth.len + vsn.len, uri.len - q.len + query.len - offset);
Christopher Faulete010c802018-10-24 10:36:45 +0200304
305 /* create the new start line */
Christopher Fauletf1ba18d2018-11-26 21:37:08 +0100306 return http_replace_stline(htx, meth, uri, vsn);
Christopher Faulete010c802018-10-24 10:36:45 +0200307}
308
309/* Replace the response status in the HTX message <htx> by <status>. It returns
310 * 1 on success, otherwise 0.
311*/
312int http_replace_res_status(struct htx *htx, const struct ist status)
313{
314 struct buffer *temp = get_trash_chunk();
Christopher Faulet297fbb42019-05-13 14:41:27 +0200315 struct htx_sl *sl = http_get_stline(htx);
Christopher Fauletf1ba18d2018-11-26 21:37:08 +0100316 struct ist vsn, reason;
Christopher Faulete010c802018-10-24 10:36:45 +0200317
Willy Tarreaucdce54c2019-02-12 12:02:27 +0100318 if (!sl)
319 return 0;
320
Christopher Faulete010c802018-10-24 10:36:45 +0200321 /* Start by copying old uri and version */
Christopher Fauletf1ba18d2018-11-26 21:37:08 +0100322 chunk_memcat(temp, HTX_SL_RES_VPTR(sl), HTX_SL_RES_VLEN(sl)); /* vsn */
323 vsn = ist2(temp->area, HTX_SL_RES_VLEN(sl));
Christopher Faulete010c802018-10-24 10:36:45 +0200324
Christopher Fauletf1ba18d2018-11-26 21:37:08 +0100325 chunk_memcat(temp, HTX_SL_RES_RPTR(sl), HTX_SL_RES_RLEN(sl)); /* reason */
326 reason = ist2(temp->area + vsn.len, HTX_SL_RES_RLEN(sl));
Christopher Faulete010c802018-10-24 10:36:45 +0200327
Christopher Fauletf1ba18d2018-11-26 21:37:08 +0100328 /* create the new start line */
329 sl->info.res.status = strl2ui(status.ptr, status.len);
330 return http_replace_stline(htx, vsn, status, reason);
Christopher Faulete010c802018-10-24 10:36:45 +0200331}
332
333/* Replace the response reason in the HTX message <htx> by <reason>. It returns
334 * 1 on success, otherwise 0.
335*/
336int http_replace_res_reason(struct htx *htx, const struct ist reason)
337{
338 struct buffer *temp = get_trash_chunk();
Christopher Faulet297fbb42019-05-13 14:41:27 +0200339 struct htx_sl *sl = http_get_stline(htx);
Christopher Fauletf1ba18d2018-11-26 21:37:08 +0100340 struct ist vsn, status;
Christopher Faulete010c802018-10-24 10:36:45 +0200341
Willy Tarreaucdce54c2019-02-12 12:02:27 +0100342 if (!sl)
343 return 0;
344
Christopher Faulete010c802018-10-24 10:36:45 +0200345 /* Start by copying old uri and version */
Christopher Fauletf1ba18d2018-11-26 21:37:08 +0100346 chunk_memcat(temp, HTX_SL_RES_VPTR(sl), HTX_SL_RES_VLEN(sl)); /* vsn */
347 vsn = ist2(temp->area, HTX_SL_RES_VLEN(sl));
Christopher Faulete010c802018-10-24 10:36:45 +0200348
Christopher Fauletf1ba18d2018-11-26 21:37:08 +0100349 chunk_memcat(temp, HTX_SL_RES_CPTR(sl), HTX_SL_RES_CLEN(sl)); /* code */
350 status = ist2(temp->area + vsn.len, HTX_SL_RES_CLEN(sl));
Christopher Faulete010c802018-10-24 10:36:45 +0200351
Christopher Fauletf1ba18d2018-11-26 21:37:08 +0100352 /* create the new start line */
353 return http_replace_stline(htx, vsn, status, reason);
Christopher Faulete010c802018-10-24 10:36:45 +0200354}
355
Christopher Faulet47596d32018-10-22 09:17:28 +0200356/* Replaces a part of a header value referenced in the context <ctx> by
357 * <data>. It returns 1 on success, otherwise it returns 0. The context is
358 * updated if necessary.
359 */
360int http_replace_header_value(struct htx *htx, struct http_hdr_ctx *ctx, const struct ist data)
361{
362 struct htx_blk *blk = ctx->blk;
363 char *start;
364 struct ist v;
365 uint32_t len, off;
366
367 if (!blk)
368 return 0;
369
370 v = htx_get_blk_value(htx, blk);
371 start = ctx->value.ptr - ctx->lws_before;
372 len = ctx->lws_before + ctx->value.len + ctx->lws_after;
373 off = start - v.ptr;
374
375 blk = htx_replace_blk_value(htx, blk, ist2(start, len), data);
376 if (!blk)
377 return 0;
378
379 v = htx_get_blk_value(htx, blk);
380 ctx->blk = blk;
381 ctx->value.ptr = v.ptr + off;
382 ctx->value.len = data.len;
383 ctx->lws_before = ctx->lws_after = 0;
384
385 return 1;
386}
387
388/* Fully replaces a header referenced in the context <ctx> by the name <name>
389 * with the value <value>. It returns 1 on success, otherwise it returns 0. The
390 * context is updated if necessary.
391 */
392int http_replace_header(struct htx *htx, struct http_hdr_ctx *ctx,
393 const struct ist name, const struct ist value)
394{
395 struct htx_blk *blk = ctx->blk;
396
397 if (!blk)
398 return 0;
399
400 blk = htx_replace_header(htx, blk, name, value);
401 if (!blk)
402 return 0;
403
404 ctx->blk = blk;
405 ctx->value = ist(NULL);
406 ctx->lws_before = ctx->lws_after = 0;
407
408 return 1;
409}
410
411/* Remove one value of a header. This only works on a <ctx> returned by
412 * http_find_header function. The value is removed, as well as surrounding commas
413 * if any. If the removed value was alone, the whole header is removed. The
414 * <ctx> is always updated accordingly, as well as the HTX message <htx>. It
415 * returns 1 on success. Otherwise, it returns 0. The <ctx> is always left in a
416 * form that can be handled by http_find_header() to find next occurrence.
417 */
418int http_remove_header(struct htx *htx, struct http_hdr_ctx *ctx)
419{
420 struct htx_blk *blk = ctx->blk;
421 char *start;
422 struct ist v;
423 uint32_t len;
424
425 if (!blk)
426 return 0;
427
428 start = ctx->value.ptr - ctx->lws_before;
429 len = ctx->lws_before + ctx->value.len + ctx->lws_after;
430
431 v = htx_get_blk_value(htx, blk);
432 if (len == v.len) {
433 blk = htx_remove_blk(htx, blk);
434 if (blk || !htx->used) {
435 ctx->blk = blk;
436 ctx->value = ist2(NULL, 0);
437 ctx->lws_before = ctx->lws_after = 0;
438 }
439 else {
440 ctx->blk = htx_get_blk(htx, htx->tail);
441 ctx->value = htx_get_blk_value(htx, ctx->blk);
442 ctx->lws_before = ctx->lws_after = 0;
443 }
444 return 1;
445 }
446
447 /* This was not the only value of this header. We have to remove the
448 * part pointed by ctx->value. If it is the last entry of the list, we
449 * remove the last separator.
450 */
451 if (start == v.ptr) {
452 /* It's the first header part but not the only one. So remove
453 * the comma after it. */
454 len++;
455 }
456 else {
457 /* There is at least one header part before the removed one. So
458 * remove the comma between them. */
459 start--;
460 len++;
461 }
462 /* Update the block content and its len */
463 memmove(start, start+len, v.len-len);
464 htx_set_blk_value_len(blk, v.len-len);
465
466 /* Update HTX msg */
467 htx->data -= len;
468
469 /* Finally update the ctx */
470 ctx->value.ptr = start;
471 ctx->value.len = 0;
472 ctx->lws_before = ctx->lws_after = 0;
473
474 return 1;
475}
Christopher Faulet7ff1cea2018-10-24 10:39:35 +0200476
477
478/* Return in <vptr> and <vlen> the pointer and length of occurrence <occ> of
479 * header whose name is <hname> of length <hlen>. If <ctx> is null, lookup is
480 * performed over the whole headers. Otherwise it must contain a valid header
481 * context, initialised with ctx->blk=NULL for the first lookup in a series. If
482 * <occ> is positive or null, occurrence #occ from the beginning (or last ctx)
483 * is returned. Occ #0 and #1 are equivalent. If <occ> is negative (and no less
484 * than -MAX_HDR_HISTORY), the occurrence is counted from the last one which is
485 * -1. The value fetch stops at commas, so this function is suited for use with
486 * list headers.
487 * The return value is 0 if nothing was found, or non-zero otherwise.
488 */
489unsigned int http_get_htx_hdr(const struct htx *htx, const struct ist hdr,
490 int occ, struct http_hdr_ctx *ctx, char **vptr, size_t *vlen)
491{
492 struct http_hdr_ctx local_ctx;
493 struct ist val_hist[MAX_HDR_HISTORY];
494 unsigned int hist_idx;
495 int found;
496
497 if (!ctx) {
498 local_ctx.blk = NULL;
499 ctx = &local_ctx;
500 }
501
502 if (occ >= 0) {
503 /* search from the beginning */
504 while (http_find_header(htx, hdr, ctx, 0)) {
505 occ--;
506 if (occ <= 0) {
507 *vptr = ctx->value.ptr;
508 *vlen = ctx->value.len;
509 return 1;
510 }
511 }
512 return 0;
513 }
514
515 /* negative occurrence, we scan all the list then walk back */
516 if (-occ > MAX_HDR_HISTORY)
517 return 0;
518
519 found = hist_idx = 0;
520 while (http_find_header(htx, hdr, ctx, 0)) {
521 val_hist[hist_idx] = ctx->value;
522 if (++hist_idx >= MAX_HDR_HISTORY)
523 hist_idx = 0;
524 found++;
525 }
526 if (-occ > found)
527 return 0;
528
529 /* OK now we have the last occurrence in [hist_idx-1], and we need to
530 * find occurrence -occ. 0 <= hist_idx < MAX_HDR_HISTORY, and we have
531 * -10 <= occ <= -1. So we have to check [hist_idx%MAX_HDR_HISTORY+occ]
532 * to remain in the 0..9 range.
533 */
534 hist_idx += occ + MAX_HDR_HISTORY;
535 if (hist_idx >= MAX_HDR_HISTORY)
536 hist_idx -= MAX_HDR_HISTORY;
537 *vptr = val_hist[hist_idx].ptr;
538 *vlen = val_hist[hist_idx].len;
539 return 1;
540}
541
542/* Return in <vptr> and <vlen> the pointer and length of occurrence <occ> of
543 * header whose name is <hname> of length <hlen>. If <ctx> is null, lookup is
544 * performed over the whole headers. Otherwise it must contain a valid header
545 * context, initialised with ctx->blk=NULL for the first lookup in a series. If
546 * <occ> is positive or null, occurrence #occ from the beginning (or last ctx)
547 * is returned. Occ #0 and #1 are equivalent. If <occ> is negative (and no less
548 * than -MAX_HDR_HISTORY), the occurrence is counted from the last one which is
549 * -1. This function differs from http_get_hdr() in that it only returns full
550 * line header values and does not stop at commas.
551 * The return value is 0 if nothing was found, or non-zero otherwise.
552 */
553unsigned int http_get_htx_fhdr(const struct htx *htx, const struct ist hdr,
554 int occ, struct http_hdr_ctx *ctx, char **vptr, size_t *vlen)
555{
556 struct http_hdr_ctx local_ctx;
557 struct ist val_hist[MAX_HDR_HISTORY];
558 unsigned int hist_idx;
559 int found;
560
561 if (!ctx) {
562 local_ctx.blk = NULL;
563 ctx = &local_ctx;
564 }
565
566 if (occ >= 0) {
567 /* search from the beginning */
568 while (http_find_header(htx, hdr, ctx, 1)) {
569 occ--;
570 if (occ <= 0) {
571 *vptr = ctx->value.ptr;
572 *vlen = ctx->value.len;
573 return 1;
574 }
575 }
576 return 0;
577 }
578
579 /* negative occurrence, we scan all the list then walk back */
580 if (-occ > MAX_HDR_HISTORY)
581 return 0;
582
583 found = hist_idx = 0;
584 while (http_find_header(htx, hdr, ctx, 1)) {
585 val_hist[hist_idx] = ctx->value;
586 if (++hist_idx >= MAX_HDR_HISTORY)
587 hist_idx = 0;
588 found++;
589 }
590 if (-occ > found)
591 return 0;
592
593 /* OK now we have the last occurrence in [hist_idx-1], and we need to
594 * find occurrence -occ. 0 <= hist_idx < MAX_HDR_HISTORY, and we have
595 * -10 <= occ <= -1. So we have to check [hist_idx%MAX_HDR_HISTORY+occ]
596 * to remain in the 0..9 range.
597 */
598 hist_idx += occ + MAX_HDR_HISTORY;
599 if (hist_idx >= MAX_HDR_HISTORY)
600 hist_idx -= MAX_HDR_HISTORY;
601 *vptr = val_hist[hist_idx].ptr;
602 *vlen = val_hist[hist_idx].len;
603 return 1;
604}
Christopher Fauleta7b677c2018-11-29 16:48:49 +0100605
606static struct htx *http_str_to_htx(struct buffer *buf, struct ist raw)
607{
608 struct htx *htx;
609 struct htx_sl *sl;
610 struct h1m h1m;
611 struct http_hdr hdrs[MAX_HTTP_HDR];
612 union h1_sl h1sl;
613 unsigned int flags = HTX_SL_F_IS_RESP;
614 int ret = 0;
615
616 buf->size = global.tune.bufsize;
617 buf->area = (char *)malloc(buf->size);
618 if (!buf->area)
619 goto error;
620 b_reset(buf);
621
622 h1m_init_res(&h1m);
623 h1m.flags |= H1_MF_NO_PHDR;
624 ret = h1_headers_to_hdr_list(raw.ptr, raw.ptr + raw.len,
625 hdrs, sizeof(hdrs)/sizeof(hdrs[0]), &h1m, &h1sl);
626 if (ret <= 0)
627 goto error;
628
629 if (unlikely(h1sl.st.v.len != 8))
630 goto error;
631 if ((*(h1sl.st.v.ptr + 5) > '1') ||
632 ((*(h1sl.st.v.ptr + 5) == '1') && (*(h1sl.st.v.ptr + 7) >= '1')))
633 h1m.flags |= H1_MF_VER_11;
634
635 if (h1m.flags & H1_MF_VER_11)
636 flags |= HTX_SL_F_VER_11;
637 if (h1m.flags & H1_MF_XFER_ENC)
638 flags |= HTX_SL_F_XFER_ENC;
639 if (h1m.flags & H1_MF_XFER_LEN) {
640 flags |= HTX_SL_F_XFER_LEN;
641 if (h1m.flags & H1_MF_CHNK)
642 goto error; /* Unsupported because there is no body parsing */
643 else if (h1m.flags & H1_MF_CLEN) {
644 flags |= HTX_SL_F_CLEN;
645 if (h1m.body_len == 0)
646 flags |= HTX_SL_F_BODYLESS;
647 }
648 }
649
650 htx = htx_from_buf(buf);
651 sl = htx_add_stline(htx, HTX_BLK_RES_SL, flags, h1sl.st.v, h1sl.st.c, h1sl.st.r);
652 if (!sl || !htx_add_all_headers(htx, hdrs))
653 goto error;
654 sl->info.res.status = h1sl.st.status;
655
Willy Tarreau0a7ef022019-05-28 10:30:11 +0200656 while (raw.len > ret) {
657 int sent = htx_add_data(htx, ist2(raw.ptr + ret, raw.len - ret));
658 if (!sent)
Christopher Fauleta7b677c2018-11-29 16:48:49 +0100659 goto error;
Willy Tarreau0a7ef022019-05-28 10:30:11 +0200660 ret += sent;
Christopher Fauleta7b677c2018-11-29 16:48:49 +0100661 }
662 if (!htx_add_endof(htx, HTX_BLK_EOM))
663 goto error;
Christopher Fauleta7b677c2018-11-29 16:48:49 +0100664 return htx;
665
666error:
667 if (buf->size)
668 free(buf->area);
669 return NULL;
670}
671
672static int http_htx_init(void)
673{
674 struct proxy *px;
675 struct buffer chk;
676 struct ist raw;
677 int rc;
678 int err_code = 0;
679
680 for (px = proxies_list; px; px = px->next) {
Christopher Faulet49040582019-04-24 15:25:00 +0200681 if (px->mode != PR_MODE_HTTP || !(px->options2 & PR_O2_USE_HTX))
Christopher Fauleta7b677c2018-11-29 16:48:49 +0100682 continue;
683
684 for (rc = 0; rc < HTTP_ERR_SIZE; rc++) {
685 if (!b_data(&px->errmsg[rc]))
686 continue;
687
688 raw = ist2(b_head(&px->errmsg[rc]), b_data(&px->errmsg[rc]));
689 if (!http_str_to_htx(&chk, raw)) {
690 ha_alert("config: %s '%s': Unable to convert message in HTX for HTTP return code %d.\n",
691 proxy_type_str(px), px->id, http_err_codes[rc]);
692 err_code |= ERR_ALERT | ERR_FATAL;
693 }
694 chunk_destroy(&px->errmsg[rc]);
695 px->errmsg[rc] = chk;
696 }
697 }
698
699 for (rc = 0; rc < HTTP_ERR_SIZE; rc++) {
700 if (!http_err_msgs[rc]) {
701 ha_alert("Internal error: no message defined for HTTP return code %d", rc);
702 err_code |= ERR_ALERT | ERR_FATAL;
703 continue;
704 }
705
706 raw = ist2(http_err_msgs[rc], strlen(http_err_msgs[rc]));
707 if (!http_str_to_htx(&chk, raw)) {
708 ha_alert("Internal error: Unable to convert message in HTX for HTTP return code %d.\n",
709 http_err_codes[rc]);
710 err_code |= ERR_ALERT | ERR_FATAL;
711 }
712 htx_err_chunks[rc] = chk;
713 }
714end:
715 return err_code;
716}
717
718REGISTER_CONFIG_POSTPARSER("http_htx", http_htx_init);