Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 1 | /* |
| 2 | * internal HTTP message |
| 3 | * |
| 4 | * Copyright 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/chunk.h> |
Willy Tarreau | b96b77e | 2018-12-11 10:22:41 +0100 | [diff] [blame] | 14 | #include <common/htx.h> |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 15 | |
| 16 | struct htx htx_empty = { .size = 0, .data = 0, .used = 0 }; |
| 17 | |
| 18 | /* Defragments an HTTP message, removing unused blocks and unwrapping blocks and |
| 19 | * their contents. A temporary message is used to do so. This function never |
| 20 | * fails. if <blk> is not NULL, we replace it by the new block address, after |
| 21 | * the defragmentation. The new <blk> is returned. |
| 22 | */ |
| 23 | /* TODO: merge data blocks into one */ |
| 24 | struct htx_blk *htx_defrag(struct htx *htx, struct htx_blk *blk) |
| 25 | { |
Christopher Faulet | aa75b3d | 2018-12-05 16:20:40 +0100 | [diff] [blame] | 26 | struct buffer *chunk = get_trash_chunk(); |
| 27 | struct htx *tmp = htxbuf(chunk); |
| 28 | struct htx_blk *newblk, *oldblk; |
Christopher Faulet | 200f895 | 2019-01-02 11:23:44 +0100 | [diff] [blame] | 29 | uint32_t new, old, blkpos; |
Christopher Faulet | aa75b3d | 2018-12-05 16:20:40 +0100 | [diff] [blame] | 30 | uint32_t addr, blksz; |
Christopher Faulet | 29f1758 | 2019-05-23 11:03:26 +0200 | [diff] [blame] | 31 | int32_t first = -1; |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 32 | |
Christopher Faulet | aa75b3d | 2018-12-05 16:20:40 +0100 | [diff] [blame] | 33 | if (!htx->used) |
| 34 | return NULL; |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 35 | |
Christopher Faulet | 200f895 | 2019-01-02 11:23:44 +0100 | [diff] [blame] | 36 | blkpos = -1; |
| 37 | |
Christopher Faulet | aa75b3d | 2018-12-05 16:20:40 +0100 | [diff] [blame] | 38 | new = 0; |
| 39 | addr = 0; |
| 40 | tmp->size = htx->size; |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 41 | |
Christopher Faulet | aa75b3d | 2018-12-05 16:20:40 +0100 | [diff] [blame] | 42 | /* start from the head */ |
| 43 | for (old = htx_get_head(htx); old != -1; old = htx_get_next(htx, old)) { |
| 44 | oldblk = htx_get_blk(htx, old); |
Christopher Faulet | 28f29c7 | 2019-04-30 17:55:45 +0200 | [diff] [blame] | 45 | if (htx_get_blk_type(oldblk) == HTX_BLK_UNUSED) |
Christopher Faulet | aa75b3d | 2018-12-05 16:20:40 +0100 | [diff] [blame] | 46 | continue; |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 47 | |
Christopher Faulet | aa75b3d | 2018-12-05 16:20:40 +0100 | [diff] [blame] | 48 | newblk = htx_get_blk(tmp, new); |
| 49 | newblk->addr = addr; |
| 50 | newblk->info = oldblk->info; |
| 51 | blksz = htx_get_blksz(oldblk); |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 52 | |
Christopher Faulet | 9c66b98 | 2019-04-30 18:08:26 +0200 | [diff] [blame] | 53 | /* update the start-line position */ |
Christopher Faulet | 29f1758 | 2019-05-23 11:03:26 +0200 | [diff] [blame] | 54 | if (htx->first == old) |
| 55 | first = new; |
Christopher Faulet | 174bfb1 | 2018-12-06 14:31:12 +0100 | [diff] [blame] | 56 | |
Christopher Faulet | 200f895 | 2019-01-02 11:23:44 +0100 | [diff] [blame] | 57 | /* if <blk> is defined, set its new position */ |
| 58 | if (blk != NULL && blk == oldblk) |
| 59 | blkpos = new; |
| 60 | |
Christopher Faulet | aa75b3d | 2018-12-05 16:20:40 +0100 | [diff] [blame] | 61 | memcpy((void *)tmp->blocks + addr, htx_get_blk_ptr(htx, oldblk), blksz); |
| 62 | new++; |
| 63 | addr += blksz; |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 64 | |
Christopher Faulet | b8fd4c0 | 2019-05-20 09:32:25 +0200 | [diff] [blame] | 65 | } |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 66 | |
Christopher Faulet | 28f29c7 | 2019-04-30 17:55:45 +0200 | [diff] [blame] | 67 | htx->used = new; |
Christopher Faulet | 29f1758 | 2019-05-23 11:03:26 +0200 | [diff] [blame] | 68 | htx->first = first; |
Christopher Faulet | 28f29c7 | 2019-04-30 17:55:45 +0200 | [diff] [blame] | 69 | htx->head = 0; |
Christopher Faulet | aa75b3d | 2018-12-05 16:20:40 +0100 | [diff] [blame] | 70 | htx->front = htx->tail = new - 1; |
| 71 | memcpy((void *)htx->blocks, (void *)tmp->blocks, htx->size); |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 72 | |
Christopher Faulet | 200f895 | 2019-01-02 11:23:44 +0100 | [diff] [blame] | 73 | return ((blkpos == -1) ? NULL : htx_get_blk(htx, blkpos)); |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 74 | } |
| 75 | |
| 76 | /* Reserves a new block in the HTTP message <htx> with a content of <blksz> |
| 77 | * bytes. If there is not enough space, NULL is returned. Otherwise the reserved |
| 78 | * block is returned and the HTTP message is updated. Space for this new block |
| 79 | * is reserved in the HTTP message. But it is the caller responsibility to set |
| 80 | * right info in the block to reflect the stored data. |
| 81 | */ |
| 82 | static struct htx_blk *htx_reserve_nxblk(struct htx *htx, uint32_t blksz) |
| 83 | { |
Christopher Faulet | aa75b3d | 2018-12-05 16:20:40 +0100 | [diff] [blame] | 84 | struct htx_blk *blk, *prevblk, *headblk, *frtblk; |
| 85 | uint32_t used; |
| 86 | uint32_t tail; |
| 87 | uint32_t prev; |
| 88 | uint32_t wrap; |
| 89 | uint32_t head; |
| 90 | int32_t headroom, tailroom; |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 91 | |
Christopher Faulet | aa75b3d | 2018-12-05 16:20:40 +0100 | [diff] [blame] | 92 | if (blksz > htx_free_data_space(htx)) |
| 93 | return NULL; /* full */ |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 94 | |
Christopher Faulet | aa75b3d | 2018-12-05 16:20:40 +0100 | [diff] [blame] | 95 | if (!htx->used) { |
| 96 | /* Empty message */ |
Christopher Faulet | 29f1758 | 2019-05-23 11:03:26 +0200 | [diff] [blame] | 97 | htx->front = htx->head = htx->tail = htx->first = 0; |
Christopher Faulet | 28f29c7 | 2019-04-30 17:55:45 +0200 | [diff] [blame] | 98 | htx->used = 1; |
Christopher Faulet | aa75b3d | 2018-12-05 16:20:40 +0100 | [diff] [blame] | 99 | blk = htx_get_blk(htx, htx->tail); |
| 100 | blk->addr = 0; |
| 101 | htx->data = blksz; |
| 102 | return blk; |
| 103 | } |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 104 | |
Christopher Faulet | aa75b3d | 2018-12-05 16:20:40 +0100 | [diff] [blame] | 105 | used = htx->used + 1; |
Christopher Faulet | aa75b3d | 2018-12-05 16:20:40 +0100 | [diff] [blame] | 106 | prev = htx->tail; |
Christopher Faulet | 28f29c7 | 2019-04-30 17:55:45 +0200 | [diff] [blame] | 107 | head = htx->head; |
| 108 | tail = htx->tail + 1; |
| 109 | wrap = htx_get_wrap(htx); |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 110 | |
Christopher Faulet | aa75b3d | 2018-12-05 16:20:40 +0100 | [diff] [blame] | 111 | if (tail == wrap) { |
| 112 | frtblk = htx_get_blk(htx, htx->front); |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 113 | |
Christopher Faulet | aa75b3d | 2018-12-05 16:20:40 +0100 | [diff] [blame] | 114 | /* Blocks don't wrap for now. We either need to push the new one |
| 115 | * on top of others or to defragement the table. */ |
| 116 | if (sizeof(htx->blocks[0]) * htx_pos_to_idx(htx, wrap+1) >= frtblk->addr + htx_get_blksz(frtblk)) |
| 117 | wrap++; |
| 118 | else if (tail >= used) /* There is hole at the beginning */ |
| 119 | tail = 0; |
| 120 | else { |
| 121 | /* No more room, tail hits data. We have to realign the |
| 122 | * whole message. */ |
| 123 | goto defrag; |
| 124 | } |
| 125 | } |
| 126 | else if (used >= wrap) { |
| 127 | /* We have hit the tail, we need to reorganize the blocks. */ |
| 128 | goto defrag; |
| 129 | } |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 130 | |
Christopher Faulet | aa75b3d | 2018-12-05 16:20:40 +0100 | [diff] [blame] | 131 | /* Now we have updated tail, used and wrap, we know that there is some |
| 132 | * available room at least from the protocol's perspective. This space |
| 133 | * is split in two areas : |
| 134 | * |
| 135 | * 1: the space between the beginning of the blocks table and the |
| 136 | * front data's address. This space will only be used if data don't |
| 137 | * wrap yet. |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 138 | |
Christopher Faulet | aa75b3d | 2018-12-05 16:20:40 +0100 | [diff] [blame] | 139 | * 2: If the previous tail was the front block, the space between the |
| 140 | * beginning of the message and the head data's address. |
| 141 | * Otherwise, the space between the tail data's address and the |
| 142 | * tail's one. |
| 143 | */ |
| 144 | prevblk = htx_get_blk(htx, prev); |
| 145 | headblk = htx_get_blk(htx, head); |
| 146 | if (prevblk->addr >= headblk->addr) { |
| 147 | /* the area was contiguous */ |
| 148 | frtblk = htx_get_blk(htx, htx->front); |
| 149 | tailroom = sizeof(htx->blocks[0]) * htx_pos_to_idx(htx, wrap) - (frtblk->addr + htx_get_blksz(frtblk)); |
| 150 | headroom = headblk->addr; |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 151 | |
Christopher Faulet | aa75b3d | 2018-12-05 16:20:40 +0100 | [diff] [blame] | 152 | if (tailroom >= (int32_t)blksz) { |
| 153 | /* install upfront and update ->front */ |
| 154 | blk = htx_get_blk(htx, tail); |
| 155 | blk->addr = frtblk->addr + htx_get_blksz(frtblk); |
| 156 | htx->front = tail; |
| 157 | } |
| 158 | else if (headroom >= (int32_t)blksz) { |
| 159 | blk = htx_get_blk(htx, tail); |
| 160 | blk->addr = 0; |
| 161 | } |
| 162 | else { |
| 163 | /* need to defragment the table before inserting upfront */ |
| 164 | goto defrag; |
| 165 | } |
| 166 | } |
| 167 | else { |
| 168 | /* it's already wrapped so we can't store anything in the tailroom */ |
| 169 | headroom = headblk->addr - (prevblk->addr + htx_get_blksz(prevblk)); |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 170 | |
Christopher Faulet | aa75b3d | 2018-12-05 16:20:40 +0100 | [diff] [blame] | 171 | if (headroom >= (int32_t)blksz) { |
| 172 | blk = htx_get_blk(htx, tail); |
| 173 | blk->addr = prevblk->addr + htx_get_blksz(prevblk); |
| 174 | } |
| 175 | else { |
| 176 | defrag: |
| 177 | /* need to defragment the table before inserting upfront */ |
| 178 | htx_defrag(htx, NULL); |
| 179 | frtblk = htx_get_blk(htx, htx->front); |
Christopher Faulet | aa75b3d | 2018-12-05 16:20:40 +0100 | [diff] [blame] | 180 | tail = htx->tail + 1; |
| 181 | used = htx->used + 1; |
| 182 | blk = htx_get_blk(htx, tail); |
| 183 | blk->addr = frtblk->addr + htx_get_blksz(frtblk); |
| 184 | htx->front = tail; |
| 185 | } |
| 186 | } |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 187 | |
Christopher Faulet | aa75b3d | 2018-12-05 16:20:40 +0100 | [diff] [blame] | 188 | htx->tail = tail; |
| 189 | htx->used = used; |
| 190 | htx->data += blksz; |
Christopher Faulet | 29f1758 | 2019-05-23 11:03:26 +0200 | [diff] [blame] | 191 | /* Set first position if not already set */ |
| 192 | if (htx->first == -1) |
| 193 | htx->first = tail; |
Christopher Faulet | aa75b3d | 2018-12-05 16:20:40 +0100 | [diff] [blame] | 194 | return blk; |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 195 | } |
| 196 | |
| 197 | /* Adds a new block of type <type> in the HTTP message <htx>. Its content size |
| 198 | * is passed but it is the caller responsibility to do the copy. |
| 199 | */ |
| 200 | struct htx_blk *htx_add_blk(struct htx *htx, enum htx_blk_type type, uint32_t blksz) |
| 201 | { |
Christopher Faulet | aa75b3d | 2018-12-05 16:20:40 +0100 | [diff] [blame] | 202 | struct htx_blk *blk; |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 203 | |
Christopher Faulet | aa75b3d | 2018-12-05 16:20:40 +0100 | [diff] [blame] | 204 | blk = htx_reserve_nxblk(htx, blksz); |
| 205 | if (!blk) |
| 206 | return NULL; |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 207 | |
Christopher Faulet | aa75b3d | 2018-12-05 16:20:40 +0100 | [diff] [blame] | 208 | blk->info = (type << 28); |
| 209 | return blk; |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 210 | } |
| 211 | |
| 212 | /* Removes the block <blk> from the HTTP message <htx>. The function returns the |
| 213 | * block following <blk> or NULL if <blk> is the last block or the last |
| 214 | * inserted one. |
| 215 | */ |
| 216 | struct htx_blk *htx_remove_blk(struct htx *htx, struct htx_blk *blk) |
| 217 | { |
Christopher Faulet | 54483df | 2018-11-26 15:05:52 +0100 | [diff] [blame] | 218 | enum htx_blk_type type = htx_get_blk_type(blk); |
Christopher Faulet | 28f29c7 | 2019-04-30 17:55:45 +0200 | [diff] [blame] | 219 | uint32_t next, pos, wrap; |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 220 | |
Christopher Faulet | 9c66b98 | 2019-04-30 18:08:26 +0200 | [diff] [blame] | 221 | pos = htx_get_blk_pos(htx, blk); |
Christopher Faulet | aa75b3d | 2018-12-05 16:20:40 +0100 | [diff] [blame] | 222 | if (type != HTX_BLK_UNUSED) { |
| 223 | /* Mark the block as unused, decrement allocated size */ |
| 224 | htx->data -= htx_get_blksz(blk); |
| 225 | blk->info = ((uint32_t)HTX_BLK_UNUSED << 28); |
Christopher Faulet | aa75b3d | 2018-12-05 16:20:40 +0100 | [diff] [blame] | 226 | } |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 227 | |
Christopher Faulet | aa75b3d | 2018-12-05 16:20:40 +0100 | [diff] [blame] | 228 | /* This is the last block in use */ |
Christopher Faulet | 29f1758 | 2019-05-23 11:03:26 +0200 | [diff] [blame] | 229 | if (htx->used == 1) { |
| 230 | htx_reset(htx); |
Christopher Faulet | aa75b3d | 2018-12-05 16:20:40 +0100 | [diff] [blame] | 231 | return NULL; |
| 232 | } |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 233 | |
Christopher Faulet | aa75b3d | 2018-12-05 16:20:40 +0100 | [diff] [blame] | 234 | /* There is at least 2 blocks, so tail is always >= 0 */ |
Christopher Faulet | aa75b3d | 2018-12-05 16:20:40 +0100 | [diff] [blame] | 235 | blk = NULL; |
| 236 | next = pos + 1; /* By default retrun the next block */ |
Christopher Faulet | 28f29c7 | 2019-04-30 17:55:45 +0200 | [diff] [blame] | 237 | wrap = htx_get_wrap(htx); |
| 238 | if (htx->tail + 1 == wrap) { |
Christopher Faulet | aa75b3d | 2018-12-05 16:20:40 +0100 | [diff] [blame] | 239 | /* The HTTP message doesn't wrap */ |
Christopher Faulet | 28f29c7 | 2019-04-30 17:55:45 +0200 | [diff] [blame] | 240 | if (pos == htx->head) { |
| 241 | /* move the head forward */ |
Christopher Faulet | aa75b3d | 2018-12-05 16:20:40 +0100 | [diff] [blame] | 242 | htx->used--; |
Christopher Faulet | 28f29c7 | 2019-04-30 17:55:45 +0200 | [diff] [blame] | 243 | htx->head++; |
Christopher Faulet | aa75b3d | 2018-12-05 16:20:40 +0100 | [diff] [blame] | 244 | } |
| 245 | else if (pos == htx->tail) { |
| 246 | /* remove the tail. this was the last inserted block so |
| 247 | * return NULL. */ |
Christopher Faulet | aa75b3d | 2018-12-05 16:20:40 +0100 | [diff] [blame] | 248 | htx->tail--; |
| 249 | htx->used--; |
| 250 | goto end; |
| 251 | } |
| 252 | } |
| 253 | else { |
| 254 | /* The HTTP message wraps */ |
| 255 | if (pos == htx->tail) { |
| 256 | /* remove the tail. try to unwrap the message (pos == 0) |
| 257 | * and return NULL. */ |
Christopher Faulet | 28f29c7 | 2019-04-30 17:55:45 +0200 | [diff] [blame] | 258 | htx->tail = ((pos == 0) ? wrap-1 : htx->tail-1); |
Christopher Faulet | aa75b3d | 2018-12-05 16:20:40 +0100 | [diff] [blame] | 259 | htx->used--; |
| 260 | goto end; |
| 261 | } |
Christopher Faulet | 28f29c7 | 2019-04-30 17:55:45 +0200 | [diff] [blame] | 262 | else if (pos == htx->head) { |
| 263 | /* move the head forward and try to unwrap the message |
| 264 | * (head+1 == wrap) */ |
Christopher Faulet | aa75b3d | 2018-12-05 16:20:40 +0100 | [diff] [blame] | 265 | htx->used--; |
Christopher Faulet | 28f29c7 | 2019-04-30 17:55:45 +0200 | [diff] [blame] | 266 | htx->head++; |
| 267 | if (htx->head == wrap) |
| 268 | htx->head = next = 0; |
Christopher Faulet | aa75b3d | 2018-12-05 16:20:40 +0100 | [diff] [blame] | 269 | } |
| 270 | } |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 271 | |
Christopher Faulet | aa75b3d | 2018-12-05 16:20:40 +0100 | [diff] [blame] | 272 | blk = htx_get_blk(htx, next); |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 273 | end: |
Christopher Faulet | 29f1758 | 2019-05-23 11:03:26 +0200 | [diff] [blame] | 274 | if (pos == htx->first) |
| 275 | htx->first = (blk ? htx_get_blk_pos(htx, blk) : -1); |
Christopher Faulet | aa75b3d | 2018-12-05 16:20:40 +0100 | [diff] [blame] | 276 | if (pos == htx->front) |
| 277 | htx->front = htx_find_front(htx); |
| 278 | return blk; |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 279 | } |
| 280 | |
Christopher Faulet | 00cf697 | 2019-01-07 14:53:27 +0100 | [diff] [blame] | 281 | /* Truncate all blocks after the one containing the offset <offset>. This last |
| 282 | * one is truncated too. |
| 283 | */ |
| 284 | void htx_truncate(struct htx *htx, uint32_t offset) |
| 285 | { |
| 286 | struct htx_blk *blk; |
| 287 | struct htx_ret htxret; |
| 288 | |
| 289 | htxret = htx_find_blk(htx, offset); |
| 290 | blk = htxret.blk; |
| 291 | if (blk && htxret.ret) { |
| 292 | uint32_t sz = htx_get_blksz(blk); |
| 293 | |
| 294 | htx_set_blk_value_len(blk, sz - htxret.ret); |
| 295 | blk = htx_get_next_blk(htx, blk); |
| 296 | } |
| 297 | while (blk) |
| 298 | blk = htx_remove_blk(htx, blk); |
| 299 | } |
| 300 | |
Christopher Faulet | 549822f | 2019-02-25 10:23:19 +0100 | [diff] [blame] | 301 | /* Drain <count> bytes from the HTX message <htx>. DATA blocks will be cut if |
| 302 | * necessary. Others blocks will be removed at once if <count> is large |
| 303 | * enough. The function returns an htx_ret with the first block remaing in the |
| 304 | * messsage and the amount of data drained. If everything is removed, |
| 305 | * htx_ret.blk is set to NULL. |
| 306 | */ |
| 307 | struct htx_ret htx_drain(struct htx *htx, uint32_t count) |
| 308 | { |
| 309 | struct htx_blk *blk; |
| 310 | struct htx_ret htxret = { .blk = NULL, .ret = 0 }; |
| 311 | |
| 312 | blk = htx_get_head_blk(htx); |
| 313 | while (count && blk) { |
| 314 | uint32_t sz = htx_get_blksz(blk); |
| 315 | enum htx_blk_type type = htx_get_blk_type(blk); |
| 316 | |
| 317 | /* Ingore unused block */ |
| 318 | if (type == HTX_BLK_UNUSED) |
| 319 | goto next; |
| 320 | |
| 321 | if (sz > count) { |
| 322 | if (type == HTX_BLK_DATA) { |
| 323 | htx_cut_data_blk(htx, blk, count); |
| 324 | htxret.ret += count; |
| 325 | } |
| 326 | break; |
| 327 | } |
| 328 | count -= sz; |
| 329 | htxret.ret += sz; |
| 330 | next: |
| 331 | blk = htx_remove_blk(htx, blk); |
| 332 | } |
| 333 | htxret.blk = blk; |
| 334 | |
| 335 | return htxret; |
| 336 | } |
| 337 | |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 338 | /* Tries to append data to the last inserted block, if the type matches and if |
Christopher Faulet | 6177509 | 2019-05-07 21:42:27 +0200 | [diff] [blame] | 339 | * there is enough non-wrapping space. Only DATA content can be appended. If the |
| 340 | * append fails, a new block is inserted. If an error occurred, NULL is |
| 341 | * returned. Otherwise, on success, the updated block (or the new one) is |
| 342 | * returned. |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 343 | */ |
| 344 | static struct htx_blk *htx_append_blk_value(struct htx *htx, enum htx_blk_type type, |
| 345 | const struct ist data) |
| 346 | { |
Christopher Faulet | f1449b7 | 2019-04-10 14:54:46 +0200 | [diff] [blame] | 347 | struct htx_blk *blk, *tailblk, *headblk, *frtblk; |
| 348 | struct ist v; |
| 349 | int32_t room; |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 350 | |
Christopher Faulet | aa75b3d | 2018-12-05 16:20:40 +0100 | [diff] [blame] | 351 | if (!htx->used) |
| 352 | goto add_new_block; |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 353 | |
Christopher Faulet | aa75b3d | 2018-12-05 16:20:40 +0100 | [diff] [blame] | 354 | /* Not enough space to store data */ |
| 355 | if (data.len > htx_free_data_space(htx)) |
| 356 | return NULL; |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 357 | |
Christopher Faulet | 6177509 | 2019-05-07 21:42:27 +0200 | [diff] [blame] | 358 | /* Append only DATA */ |
| 359 | if (type != HTX_BLK_DATA) |
Christopher Faulet | aa75b3d | 2018-12-05 16:20:40 +0100 | [diff] [blame] | 360 | goto add_new_block; |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 361 | |
Christopher Faulet | f1449b7 | 2019-04-10 14:54:46 +0200 | [diff] [blame] | 362 | /* get the tail and head block */ |
| 363 | tailblk = htx_get_tail_blk(htx); |
| 364 | headblk = htx_get_head_blk(htx); |
| 365 | if (tailblk == NULL || headblk == NULL) |
| 366 | goto add_new_block; |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 367 | |
Christopher Faulet | aa75b3d | 2018-12-05 16:20:40 +0100 | [diff] [blame] | 368 | /* Don't try to append data if the last inserted block is not of the |
| 369 | * same type */ |
Christopher Faulet | f1449b7 | 2019-04-10 14:54:46 +0200 | [diff] [blame] | 370 | if (type != htx_get_blk_type(tailblk)) |
Christopher Faulet | aa75b3d | 2018-12-05 16:20:40 +0100 | [diff] [blame] | 371 | goto add_new_block; |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 372 | |
Christopher Faulet | aa75b3d | 2018-12-05 16:20:40 +0100 | [diff] [blame] | 373 | /* |
| 374 | * Same type and enough space: append data |
| 375 | */ |
Christopher Faulet | f1449b7 | 2019-04-10 14:54:46 +0200 | [diff] [blame] | 376 | frtblk = htx_get_blk(htx, htx->front); |
| 377 | if (tailblk->addr >= headblk->addr) { |
| 378 | if (htx->tail != htx->front) |
| 379 | goto add_new_block; |
| 380 | room = sizeof(htx->blocks[0]) * htx_pos_to_idx(htx, htx->tail) - (frtblk->addr + htx_get_blksz(frtblk)); |
Christopher Faulet | aa75b3d | 2018-12-05 16:20:40 +0100 | [diff] [blame] | 381 | } |
Christopher Faulet | f1449b7 | 2019-04-10 14:54:46 +0200 | [diff] [blame] | 382 | else |
| 383 | room = headblk->addr - (tailblk->addr + htx_get_blksz(tailblk)); |
| 384 | |
| 385 | if (room < (int32_t)data.len) |
| 386 | tailblk = htx_defrag(htx, tailblk); |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 387 | |
| 388 | append_data: |
Christopher Faulet | aa75b3d | 2018-12-05 16:20:40 +0100 | [diff] [blame] | 389 | /* get the value of the tail block */ |
| 390 | /* FIXME: check v.len + data.len < 256MB */ |
Christopher Faulet | f1449b7 | 2019-04-10 14:54:46 +0200 | [diff] [blame] | 391 | v = htx_get_blk_value(htx, tailblk); |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 392 | |
Christopher Faulet | aa75b3d | 2018-12-05 16:20:40 +0100 | [diff] [blame] | 393 | /* Append data and update the block itself */ |
| 394 | memcpy(v.ptr + v.len, data.ptr, data.len); |
Christopher Faulet | f1449b7 | 2019-04-10 14:54:46 +0200 | [diff] [blame] | 395 | htx_set_blk_value_len(tailblk, v.len + data.len); |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 396 | |
Christopher Faulet | aa75b3d | 2018-12-05 16:20:40 +0100 | [diff] [blame] | 397 | /* Update HTTP message */ |
| 398 | htx->data += data.len; |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 399 | |
Christopher Faulet | f1449b7 | 2019-04-10 14:54:46 +0200 | [diff] [blame] | 400 | return tailblk; |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 401 | |
| 402 | add_new_block: |
Christopher Faulet | aa75b3d | 2018-12-05 16:20:40 +0100 | [diff] [blame] | 403 | /* FIXME: check tlr.len (< 256MB) */ |
| 404 | blk = htx_add_blk(htx, type, data.len); |
| 405 | if (!blk) |
| 406 | return NULL; |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 407 | |
Christopher Faulet | aa75b3d | 2018-12-05 16:20:40 +0100 | [diff] [blame] | 408 | blk->info += data.len; |
| 409 | memcpy(htx_get_blk_ptr(htx, blk), data.ptr, data.len); |
| 410 | return blk; |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 411 | } |
| 412 | |
| 413 | /* Replaces a value part of a block by a new one. The new part can be smaller or |
| 414 | * larger than the old one. This function works for any kind of block with |
| 415 | * attached data. It returns the new block on success, otherwise it returns |
| 416 | * NULL. |
| 417 | */ |
| 418 | struct htx_blk *htx_replace_blk_value(struct htx *htx, struct htx_blk *blk, |
Christopher Faulet | aa75b3d | 2018-12-05 16:20:40 +0100 | [diff] [blame] | 419 | const struct ist old, const struct ist new) |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 420 | { |
Christopher Faulet | e97f3ba | 2018-12-10 15:39:40 +0100 | [diff] [blame] | 421 | struct buffer *tmp; |
Christopher Faulet | aa75b3d | 2018-12-05 16:20:40 +0100 | [diff] [blame] | 422 | struct ist n, v; |
Christopher Faulet | e97f3ba | 2018-12-10 15:39:40 +0100 | [diff] [blame] | 423 | int32_t delta; |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 424 | |
Christopher Faulet | aa75b3d | 2018-12-05 16:20:40 +0100 | [diff] [blame] | 425 | n = htx_get_blk_name(htx, blk); |
| 426 | v = htx_get_blk_value(htx, blk); |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 427 | |
Christopher Faulet | e97f3ba | 2018-12-10 15:39:40 +0100 | [diff] [blame] | 428 | delta = new.len - old.len; |
| 429 | |
Christopher Faulet | aa75b3d | 2018-12-05 16:20:40 +0100 | [diff] [blame] | 430 | /* easy case, new data are smaller, so replace it in-place */ |
Christopher Faulet | e97f3ba | 2018-12-10 15:39:40 +0100 | [diff] [blame] | 431 | if (delta <= 0) { |
Christopher Faulet | aa75b3d | 2018-12-05 16:20:40 +0100 | [diff] [blame] | 432 | memcpy(old.ptr, new.ptr, new.len); |
| 433 | if (old.len != v.len) |
| 434 | memmove(old.ptr + new.len, old.ptr + old.len, (v.ptr + v.len) - (old.ptr + old.len)); |
Christopher Faulet | e97f3ba | 2018-12-10 15:39:40 +0100 | [diff] [blame] | 435 | htx_set_blk_value_len(blk, v.len + delta); |
| 436 | htx->data += delta; |
Christopher Faulet | aa75b3d | 2018-12-05 16:20:40 +0100 | [diff] [blame] | 437 | return blk; |
| 438 | } |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 439 | |
Christopher Faulet | aa75b3d | 2018-12-05 16:20:40 +0100 | [diff] [blame] | 440 | /* we need to allocate more space to store the new header value */ |
Christopher Faulet | e97f3ba | 2018-12-10 15:39:40 +0100 | [diff] [blame] | 441 | if (delta > htx_free_space(htx)) |
Christopher Faulet | aa75b3d | 2018-12-05 16:20:40 +0100 | [diff] [blame] | 442 | return NULL; /* not enough space */ |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 443 | |
Christopher Faulet | aa75b3d | 2018-12-05 16:20:40 +0100 | [diff] [blame] | 444 | /* |
| 445 | * Copy the new header in a temp buffer |
| 446 | */ |
| 447 | tmp = get_trash_chunk(); |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 448 | |
Christopher Faulet | aa75b3d | 2018-12-05 16:20:40 +0100 | [diff] [blame] | 449 | /* 1. copy the header name */ |
| 450 | chunk_memcat(tmp, n.ptr, n.len); |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 451 | |
Christopher Faulet | aa75b3d | 2018-12-05 16:20:40 +0100 | [diff] [blame] | 452 | /* 2. copy value before old part, if any */ |
| 453 | if (old.ptr != v.ptr) |
| 454 | chunk_memcat(tmp, v.ptr, old.ptr - v.ptr); |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 455 | |
Christopher Faulet | aa75b3d | 2018-12-05 16:20:40 +0100 | [diff] [blame] | 456 | /* 3. copy new value */ |
| 457 | chunk_memcat(tmp, new.ptr, new.len); |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 458 | |
Christopher Faulet | aa75b3d | 2018-12-05 16:20:40 +0100 | [diff] [blame] | 459 | /* 4. copy value after old part if any */ |
| 460 | if (old.len != v.len) |
| 461 | chunk_memcat(tmp, old.ptr + old.len, (v.ptr + v.len) - (old.ptr + old.len)); |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 462 | |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 463 | |
Christopher Faulet | e97f3ba | 2018-12-10 15:39:40 +0100 | [diff] [blame] | 464 | /* Expand the block size. But data are not copied yet. Then defragment |
| 465 | * the HTX message. |
Christopher Faulet | aa75b3d | 2018-12-05 16:20:40 +0100 | [diff] [blame] | 466 | */ |
Christopher Faulet | e97f3ba | 2018-12-10 15:39:40 +0100 | [diff] [blame] | 467 | htx_set_blk_value_len(blk, v.len + delta); |
| 468 | htx->data += delta; |
| 469 | blk = htx_defrag(htx, blk); |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 470 | |
Christopher Faulet | e97f3ba | 2018-12-10 15:39:40 +0100 | [diff] [blame] | 471 | /* Finaly, copy data. */ |
Christopher Faulet | aa75b3d | 2018-12-05 16:20:40 +0100 | [diff] [blame] | 472 | memcpy(htx_get_blk_ptr(htx, blk), tmp->area, tmp->data); |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 473 | |
Christopher Faulet | aa75b3d | 2018-12-05 16:20:40 +0100 | [diff] [blame] | 474 | return blk; |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 475 | } |
| 476 | |
| 477 | /* Transfer HTX blocks from <src> to <dst>, stopping on the first block of the |
Christopher Faulet | 156852b | 2019-05-16 11:29:13 +0200 | [diff] [blame] | 478 | * type <mark> (typically EOH, EOD or EOM) or when <count> bytes were moved |
| 479 | * (including payload and meta-data). It returns the number of bytes moved and |
| 480 | * the last HTX block inserted in <dst>. |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 481 | */ |
| 482 | struct htx_ret htx_xfer_blks(struct htx *dst, struct htx *src, uint32_t count, |
| 483 | enum htx_blk_type mark) |
| 484 | { |
| 485 | struct htx_blk *blk, *dstblk; |
| 486 | enum htx_blk_type type; |
Christopher Faulet | aa75b3d | 2018-12-05 16:20:40 +0100 | [diff] [blame] | 487 | uint32_t info, max, sz, ret; |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 488 | |
Christopher Faulet | 156852b | 2019-05-16 11:29:13 +0200 | [diff] [blame] | 489 | ret = htx_used_space(dst); |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 490 | blk = htx_get_blk(src, htx_get_head(src)); |
| 491 | dstblk = NULL; |
Christopher Faulet | 156852b | 2019-05-16 11:29:13 +0200 | [diff] [blame] | 492 | |
| 493 | while (blk && count) { |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 494 | type = htx_get_blk_type(blk); |
| 495 | |
| 496 | /* Ingore unused block */ |
| 497 | if (type == HTX_BLK_UNUSED) |
| 498 | goto next; |
| 499 | |
Christopher Faulet | a61e97b | 2019-05-16 11:30:31 +0200 | [diff] [blame] | 500 | /* Be sure to have enough space to xfer all headers in one |
| 501 | * time. If not while <dst> is empty, we report a parsing error |
| 502 | * on <src>. |
| 503 | */ |
| 504 | if (mark >= HTX_BLK_EOH && (type == HTX_BLK_REQ_SL || type == HTX_BLK_RES_SL)) { |
| 505 | struct htx_sl *sl = htx_get_blk_ptr(src, blk); |
| 506 | |
| 507 | if (sl->hdrs_bytes != -1 && sl->hdrs_bytes > count) { |
| 508 | if (htx_is_empty(dst)) |
| 509 | src->flags |= HTX_FL_PARSING_ERROR; |
| 510 | break; |
| 511 | } |
| 512 | } |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 513 | |
Christopher Faulet | 156852b | 2019-05-16 11:29:13 +0200 | [diff] [blame] | 514 | sz = htx_get_blksz(blk); |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 515 | info = blk->info; |
Christopher Faulet | 156852b | 2019-05-16 11:29:13 +0200 | [diff] [blame] | 516 | max = htx_get_max_blksz(dst, count); |
| 517 | if (!max) |
| 518 | break; |
Willy Tarreau | 90caa07 | 2019-04-09 16:21:54 +0200 | [diff] [blame] | 519 | if (sz > max) { |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 520 | /* Headers and pseudo headers must be fully copied */ |
Christopher Faulet | 156852b | 2019-05-16 11:29:13 +0200 | [diff] [blame] | 521 | if (type != HTX_BLK_DATA) |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 522 | break; |
Christopher Faulet | 156852b | 2019-05-16 11:29:13 +0200 | [diff] [blame] | 523 | sz = max; |
| 524 | info = (type << 28) + sz; |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 525 | } |
| 526 | |
| 527 | dstblk = htx_reserve_nxblk(dst, sz); |
| 528 | if (!dstblk) |
| 529 | break; |
| 530 | dstblk->info = info; |
| 531 | memcpy(htx_get_blk_ptr(dst, dstblk), htx_get_blk_ptr(src, blk), sz); |
| 532 | |
Christopher Faulet | 156852b | 2019-05-16 11:29:13 +0200 | [diff] [blame] | 533 | count -= sizeof(dstblk) + sz; |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 534 | if (blk->info != info) { |
| 535 | /* Partial move: don't remove <blk> from <src> but |
| 536 | * resize its content */ |
Christopher Faulet | 156852b | 2019-05-16 11:29:13 +0200 | [diff] [blame] | 537 | htx_cut_data_blk(src, blk, sz); |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 538 | break; |
| 539 | } |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 540 | next: |
| 541 | blk = htx_remove_blk(src, blk); |
| 542 | if (type == mark) |
| 543 | break; |
| 544 | |
| 545 | } |
| 546 | |
Christopher Faulet | 156852b | 2019-05-16 11:29:13 +0200 | [diff] [blame] | 547 | end: |
| 548 | ret = htx_used_space(dst) - ret; |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 549 | return (struct htx_ret){.ret = ret, .blk = dstblk}; |
| 550 | } |
| 551 | |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 552 | /* Replaces an header by a new one. The new header can be smaller or larger than |
| 553 | * the old one. It returns the new block on success, otherwise it returns NULL. |
Willy Tarreau | ed00e34 | 2018-12-07 08:47:45 +0100 | [diff] [blame] | 554 | * The header name is always lower cased. |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 555 | */ |
| 556 | struct htx_blk *htx_replace_header(struct htx *htx, struct htx_blk *blk, |
Christopher Faulet | aa75b3d | 2018-12-05 16:20:40 +0100 | [diff] [blame] | 557 | const struct ist name, const struct ist value) |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 558 | { |
Christopher Faulet | aa75b3d | 2018-12-05 16:20:40 +0100 | [diff] [blame] | 559 | enum htx_blk_type type; |
Christopher Faulet | e97f3ba | 2018-12-10 15:39:40 +0100 | [diff] [blame] | 560 | int32_t delta; |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 561 | |
Christopher Faulet | aa75b3d | 2018-12-05 16:20:40 +0100 | [diff] [blame] | 562 | type = htx_get_blk_type(blk); |
| 563 | if (type != HTX_BLK_HDR) |
| 564 | return NULL; |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 565 | |
Christopher Faulet | e97f3ba | 2018-12-10 15:39:40 +0100 | [diff] [blame] | 566 | delta = name.len + value.len - htx_get_blksz(blk); |
| 567 | |
| 568 | /* easy case, new value is smaller, so replace it in-place */ |
| 569 | if (delta <= 0) { |
| 570 | blk->info = (type << 28) + (value.len << 8) + name.len; |
| 571 | htx->data += delta; |
| 572 | goto copy; |
| 573 | } |
| 574 | |
| 575 | /* we need to allocate more space to store the new value */ |
| 576 | if (delta > htx_free_space(htx)) |
| 577 | return NULL; /* not enough space */ |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 578 | |
Christopher Faulet | e97f3ba | 2018-12-10 15:39:40 +0100 | [diff] [blame] | 579 | /* Expand the block size. But data are not copied yet. Then defragment |
| 580 | * the HTX message. |
| 581 | */ |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 582 | blk->info = (type << 28) + (value.len << 8) + name.len; |
Christopher Faulet | e97f3ba | 2018-12-10 15:39:40 +0100 | [diff] [blame] | 583 | htx->data += delta; |
| 584 | blk = htx_defrag(htx, blk); |
| 585 | |
| 586 | copy: |
| 587 | /* Finaly, copy data. */ |
Willy Tarreau | ed00e34 | 2018-12-07 08:47:45 +0100 | [diff] [blame] | 588 | ist2bin_lc(htx_get_blk_ptr(htx, blk), name); |
Christopher Faulet | aa75b3d | 2018-12-05 16:20:40 +0100 | [diff] [blame] | 589 | memcpy(htx_get_blk_ptr(htx, blk) + name.len, value.ptr, value.len); |
Christopher Faulet | aa75b3d | 2018-12-05 16:20:40 +0100 | [diff] [blame] | 590 | return blk; |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 591 | } |
| 592 | |
Christopher Faulet | f1ba18d | 2018-11-26 21:37:08 +0100 | [diff] [blame] | 593 | /* Replaces the parts of the start-line. It returns the new start-line on |
| 594 | * success, otherwise it returns NULL. It is the caller responsibility to update |
| 595 | * sl->info, if necessary. |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 596 | */ |
Christopher Faulet | f1ba18d | 2018-11-26 21:37:08 +0100 | [diff] [blame] | 597 | struct htx_sl *htx_replace_stline(struct htx *htx, struct htx_blk *blk, const struct ist p1, |
| 598 | const struct ist p2, const struct ist p3) |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 599 | { |
Christopher Faulet | f1ba18d | 2018-11-26 21:37:08 +0100 | [diff] [blame] | 600 | struct htx_sl *sl; |
| 601 | struct htx_sl tmp; /* used to save sl->info and sl->flags */ |
Christopher Faulet | aa75b3d | 2018-12-05 16:20:40 +0100 | [diff] [blame] | 602 | enum htx_blk_type type; |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 603 | uint32_t size; |
Christopher Faulet | e97f3ba | 2018-12-10 15:39:40 +0100 | [diff] [blame] | 604 | int32_t delta; |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 605 | |
Christopher Faulet | aa75b3d | 2018-12-05 16:20:40 +0100 | [diff] [blame] | 606 | type = htx_get_blk_type(blk); |
Willy Tarreau | c706cd7 | 2018-12-07 17:12:22 +0100 | [diff] [blame] | 607 | if (type != HTX_BLK_REQ_SL && type != HTX_BLK_RES_SL) |
Christopher Faulet | aa75b3d | 2018-12-05 16:20:40 +0100 | [diff] [blame] | 608 | return NULL; |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 609 | |
Christopher Faulet | f1ba18d | 2018-11-26 21:37:08 +0100 | [diff] [blame] | 610 | /* Save start-line info and flags */ |
| 611 | sl = htx_get_blk_ptr(htx, blk); |
| 612 | tmp.info = sl->info; |
| 613 | tmp.flags = sl->flags; |
Christopher Faulet | f1ba18d | 2018-11-26 21:37:08 +0100 | [diff] [blame] | 614 | |
| 615 | size = sizeof(*sl) + p1.len + p2.len + p3.len; |
Christopher Faulet | e97f3ba | 2018-12-10 15:39:40 +0100 | [diff] [blame] | 616 | delta = size - htx_get_blksz(blk); |
| 617 | |
| 618 | /* easy case, new data are smaller, so replace it in-place */ |
| 619 | if (delta <= 0) { |
| 620 | htx_set_blk_value_len(blk, size); |
| 621 | htx->data += delta; |
| 622 | goto copy; |
| 623 | } |
| 624 | |
| 625 | /* we need to allocate more space to store the new value */ |
| 626 | if (delta > htx_free_space(htx)) |
| 627 | return NULL; /* not enough space */ |
| 628 | |
| 629 | /* Expand the block size. But data are not copied yet. Then defragment |
| 630 | * the HTX message. |
| 631 | */ |
| 632 | htx_set_blk_value_len(blk, size); |
| 633 | htx->data += delta; |
| 634 | blk = htx_defrag(htx, blk); |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 635 | |
Christopher Faulet | e97f3ba | 2018-12-10 15:39:40 +0100 | [diff] [blame] | 636 | copy: |
| 637 | /* Restore start-line info and flags and copy parts of the start-line */ |
Christopher Faulet | f1ba18d | 2018-11-26 21:37:08 +0100 | [diff] [blame] | 638 | sl = htx_get_blk_ptr(htx, blk); |
| 639 | sl->info = tmp.info; |
| 640 | sl->flags = tmp.flags; |
Christopher Faulet | 05c083c | 2019-05-15 14:56:47 +0200 | [diff] [blame] | 641 | if (sl->hdrs_bytes != -1) |
| 642 | sl->hdrs_bytes += delta; |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 643 | |
Christopher Faulet | f1ba18d | 2018-11-26 21:37:08 +0100 | [diff] [blame] | 644 | HTX_SL_P1_LEN(sl) = p1.len; |
| 645 | HTX_SL_P2_LEN(sl) = p2.len; |
| 646 | HTX_SL_P3_LEN(sl) = p3.len; |
Christopher Faulet | 54483df | 2018-11-26 15:05:52 +0100 | [diff] [blame] | 647 | |
Christopher Faulet | f1ba18d | 2018-11-26 21:37:08 +0100 | [diff] [blame] | 648 | memcpy(HTX_SL_P1_PTR(sl), p1.ptr, p1.len); |
| 649 | memcpy(HTX_SL_P2_PTR(sl), p2.ptr, p2.len); |
| 650 | memcpy(HTX_SL_P3_PTR(sl), p3.ptr, p3.len); |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 651 | |
Christopher Faulet | f1ba18d | 2018-11-26 21:37:08 +0100 | [diff] [blame] | 652 | return sl; |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 653 | } |
| 654 | |
Christopher Faulet | f1ba18d | 2018-11-26 21:37:08 +0100 | [diff] [blame] | 655 | /* Add a new start-line. It returns it on success, otherwise it returns NULL. It |
| 656 | * is the caller responsibility to set sl->info, if necessary. |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 657 | */ |
Christopher Faulet | f1ba18d | 2018-11-26 21:37:08 +0100 | [diff] [blame] | 658 | struct htx_sl *htx_add_stline(struct htx *htx, enum htx_blk_type type, unsigned int flags, |
| 659 | const struct ist p1, const struct ist p2, const struct ist p3) |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 660 | { |
Christopher Faulet | aa75b3d | 2018-12-05 16:20:40 +0100 | [diff] [blame] | 661 | struct htx_blk *blk; |
Christopher Faulet | f1ba18d | 2018-11-26 21:37:08 +0100 | [diff] [blame] | 662 | struct htx_sl *sl; |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 663 | uint32_t size; |
| 664 | |
Christopher Faulet | f1ba18d | 2018-11-26 21:37:08 +0100 | [diff] [blame] | 665 | if (type != HTX_BLK_REQ_SL && type != HTX_BLK_RES_SL) |
| 666 | return NULL; |
| 667 | |
| 668 | size = sizeof(*sl) + p1.len + p2.len + p3.len; |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 669 | |
Christopher Faulet | aa75b3d | 2018-12-05 16:20:40 +0100 | [diff] [blame] | 670 | /* FIXME: check size (< 256MB) */ |
| 671 | blk = htx_add_blk(htx, type, size); |
| 672 | if (!blk) |
| 673 | return NULL; |
| 674 | blk->info += size; |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 675 | |
Christopher Faulet | f1ba18d | 2018-11-26 21:37:08 +0100 | [diff] [blame] | 676 | sl = htx_get_blk_ptr(htx, blk); |
Christopher Faulet | 05c083c | 2019-05-15 14:56:47 +0200 | [diff] [blame] | 677 | sl->hdrs_bytes = -1; |
Christopher Faulet | f1ba18d | 2018-11-26 21:37:08 +0100 | [diff] [blame] | 678 | sl->flags = flags; |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 679 | |
Christopher Faulet | f1ba18d | 2018-11-26 21:37:08 +0100 | [diff] [blame] | 680 | HTX_SL_P1_LEN(sl) = p1.len; |
| 681 | HTX_SL_P2_LEN(sl) = p2.len; |
| 682 | HTX_SL_P3_LEN(sl) = p3.len; |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 683 | |
Christopher Faulet | f1ba18d | 2018-11-26 21:37:08 +0100 | [diff] [blame] | 684 | memcpy(HTX_SL_P1_PTR(sl), p1.ptr, p1.len); |
| 685 | memcpy(HTX_SL_P2_PTR(sl), p2.ptr, p2.len); |
| 686 | memcpy(HTX_SL_P3_PTR(sl), p3.ptr, p3.len); |
| 687 | |
Christopher Faulet | aa75b3d | 2018-12-05 16:20:40 +0100 | [diff] [blame] | 688 | return sl; |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 689 | } |
| 690 | |
| 691 | /* Adds an HTX block of type HDR in <htx>. It returns the new block on |
Willy Tarreau | ed00e34 | 2018-12-07 08:47:45 +0100 | [diff] [blame] | 692 | * success. Otherwise, it returns NULL. The header name is always lower cased. |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 693 | */ |
| 694 | struct htx_blk *htx_add_header(struct htx *htx, const struct ist name, |
Christopher Faulet | aa75b3d | 2018-12-05 16:20:40 +0100 | [diff] [blame] | 695 | const struct ist value) |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 696 | { |
Christopher Faulet | aa75b3d | 2018-12-05 16:20:40 +0100 | [diff] [blame] | 697 | struct htx_blk *blk; |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 698 | |
Christopher Faulet | aa75b3d | 2018-12-05 16:20:40 +0100 | [diff] [blame] | 699 | /* FIXME: check name.len (< 256B) and value.len (< 1MB) */ |
| 700 | blk = htx_add_blk(htx, HTX_BLK_HDR, name.len + value.len); |
| 701 | if (!blk) |
| 702 | return NULL; |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 703 | |
Christopher Faulet | aa75b3d | 2018-12-05 16:20:40 +0100 | [diff] [blame] | 704 | blk->info += (value.len << 8) + name.len; |
Willy Tarreau | ed00e34 | 2018-12-07 08:47:45 +0100 | [diff] [blame] | 705 | ist2bin_lc(htx_get_blk_ptr(htx, blk), name); |
Christopher Faulet | aa75b3d | 2018-12-05 16:20:40 +0100 | [diff] [blame] | 706 | memcpy(htx_get_blk_ptr(htx, blk) + name.len, value.ptr, value.len); |
| 707 | return blk; |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 708 | } |
| 709 | |
Willy Tarreau | 52610e9 | 2019-01-03 18:26:17 +0100 | [diff] [blame] | 710 | /* Adds an HTX block of type <type> in <htx>, of size <blksz>. It returns the |
| 711 | * new block on success. Otherwise, it returns NULL. The caller is responsible |
| 712 | * for filling the block itself. |
| 713 | */ |
| 714 | struct htx_blk *htx_add_blk_type_size(struct htx *htx, enum htx_blk_type type, uint32_t blksz) |
| 715 | { |
| 716 | struct htx_blk *blk; |
| 717 | |
| 718 | blk = htx_add_blk(htx, type, blksz); |
| 719 | if (!blk) |
| 720 | return NULL; |
| 721 | |
| 722 | blk->info += blksz; |
| 723 | return blk; |
| 724 | } |
| 725 | |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 726 | struct htx_blk *htx_add_all_headers(struct htx *htx, const struct http_hdr *hdrs) |
| 727 | { |
| 728 | int i; |
| 729 | |
| 730 | for (i = 0; hdrs[i].n.len; i++) { |
| 731 | if (!htx_add_header(htx, hdrs[i].n, hdrs[i].v)) |
| 732 | return NULL; |
| 733 | } |
| 734 | return htx_add_endof(htx, HTX_BLK_EOH); |
| 735 | } |
| 736 | /* Adds an HTX block of type PHDR in <htx>. It returns the new block on |
| 737 | * success. Otherwise, it returns NULL. |
| 738 | */ |
| 739 | struct htx_blk *htx_add_pseudo_header(struct htx *htx, enum htx_phdr_type phdr, |
Christopher Faulet | aa75b3d | 2018-12-05 16:20:40 +0100 | [diff] [blame] | 740 | const struct ist value) |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 741 | { |
Christopher Faulet | aa75b3d | 2018-12-05 16:20:40 +0100 | [diff] [blame] | 742 | struct htx_blk *blk; |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 743 | |
Christopher Faulet | aa75b3d | 2018-12-05 16:20:40 +0100 | [diff] [blame] | 744 | /* FIXME: check value.len ( < 1MB) */ |
| 745 | blk = htx_add_blk(htx, HTX_BLK_PHDR, value.len); |
| 746 | if (!blk) |
| 747 | return NULL; |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 748 | |
Christopher Faulet | aa75b3d | 2018-12-05 16:20:40 +0100 | [diff] [blame] | 749 | blk->info += (value.len << 8) + phdr; |
| 750 | memcpy(htx_get_blk_ptr(htx, blk), value.ptr, value.len); |
| 751 | return blk; |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 752 | } |
| 753 | |
| 754 | /* Adds an HTX block of type EOH,EOD or EOM in <htx>. It returns the new block |
| 755 | * on success. Otherwise, it returns NULL. |
| 756 | */ |
| 757 | struct htx_blk *htx_add_endof(struct htx *htx, enum htx_blk_type type) |
| 758 | { |
Christopher Faulet | aa75b3d | 2018-12-05 16:20:40 +0100 | [diff] [blame] | 759 | struct htx_blk *blk; |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 760 | |
Christopher Faulet | aa75b3d | 2018-12-05 16:20:40 +0100 | [diff] [blame] | 761 | blk = htx_add_blk(htx, type, 1); |
| 762 | if (!blk) |
| 763 | return NULL; |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 764 | |
Christopher Faulet | aa75b3d | 2018-12-05 16:20:40 +0100 | [diff] [blame] | 765 | blk->info += 1; |
| 766 | return blk; |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 767 | } |
| 768 | |
| 769 | |
| 770 | /* Adds an HTX block of type DATA in <htx>. It first tries to append data if |
| 771 | * possible. It returns the new block on success. Otherwise, it returns NULL. |
| 772 | */ |
| 773 | struct htx_blk *htx_add_data(struct htx *htx, const struct ist data) |
| 774 | { |
Christopher Faulet | aa75b3d | 2018-12-05 16:20:40 +0100 | [diff] [blame] | 775 | return htx_append_blk_value(htx, HTX_BLK_DATA, data); |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 776 | } |
| 777 | |
Christopher Faulet | 6177509 | 2019-05-07 21:42:27 +0200 | [diff] [blame] | 778 | /* Adds an HTX block of type TLR in <htx>. It returns the new block on |
| 779 | * success. Otherwise, it returns NULL. |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 780 | */ |
| 781 | struct htx_blk *htx_add_trailer(struct htx *htx, const struct ist tlr) |
| 782 | { |
Christopher Faulet | 6177509 | 2019-05-07 21:42:27 +0200 | [diff] [blame] | 783 | struct htx_blk *blk; |
| 784 | |
| 785 | /* FIXME: check tlr.len (< 256MB) */ |
| 786 | blk = htx_add_blk(htx, HTX_BLK_TLR, tlr.len); |
| 787 | if (!blk) |
| 788 | return NULL; |
| 789 | |
| 790 | blk->info += tlr.len; |
| 791 | memcpy(htx_get_blk_ptr(htx, blk), tlr.ptr, tlr.len); |
| 792 | return blk; |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 793 | } |
| 794 | |
Christopher Faulet | 24ed835 | 2018-11-22 11:20:43 +0100 | [diff] [blame] | 795 | struct htx_blk *htx_add_data_before(struct htx *htx, const struct htx_blk *ref, |
| 796 | const struct ist data) |
| 797 | { |
| 798 | struct htx_blk *blk; |
| 799 | int32_t prev; |
| 800 | |
Christopher Faulet | aa75b3d | 2018-12-05 16:20:40 +0100 | [diff] [blame] | 801 | /* FIXME: check data.len (< 256MB) */ |
| 802 | blk = htx_add_blk(htx, HTX_BLK_DATA, data.len); |
| 803 | if (!blk) |
| 804 | return NULL; |
Christopher Faulet | 24ed835 | 2018-11-22 11:20:43 +0100 | [diff] [blame] | 805 | |
Christopher Faulet | aa75b3d | 2018-12-05 16:20:40 +0100 | [diff] [blame] | 806 | blk->info += data.len; |
| 807 | memcpy(htx_get_blk_ptr(htx, blk), data.ptr, data.len); |
Christopher Faulet | 24ed835 | 2018-11-22 11:20:43 +0100 | [diff] [blame] | 808 | |
| 809 | for (prev = htx_get_prev(htx, htx->tail); prev != -1; prev = htx_get_prev(htx, prev)) { |
| 810 | struct htx_blk *pblk = htx_get_blk(htx, prev); |
| 811 | |
| 812 | /* Swap .addr and .info fields */ |
| 813 | blk->addr ^= pblk->addr; pblk->addr ^= blk->addr; blk->addr ^= pblk->addr; |
| 814 | blk->info ^= pblk->info; pblk->info ^= blk->info; blk->info ^= pblk->info; |
| 815 | |
| 816 | if (blk->addr == pblk->addr) |
| 817 | blk->addr += htx_get_blksz(pblk); |
| 818 | htx->front = prev; |
| 819 | |
| 820 | if (pblk == ref) |
| 821 | break; |
| 822 | blk = pblk; |
| 823 | } |
Christopher Faulet | 05aab64 | 2019-04-11 13:43:57 +0200 | [diff] [blame] | 824 | |
| 825 | if (htx_get_blk_pos(htx, blk) != htx->front) |
| 826 | htx_defrag(htx, NULL); |
| 827 | |
Christopher Faulet | 24ed835 | 2018-11-22 11:20:43 +0100 | [diff] [blame] | 828 | return blk; |
| 829 | } |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 830 | |
Christopher Faulet | c59ff23 | 2018-12-03 13:58:44 +0100 | [diff] [blame] | 831 | /* Appends the H1 representation of the request line block <blk> to the |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 832 | * chunk <chk>. It returns 1 if data are successfully appended, otherwise it |
| 833 | * returns 0. |
| 834 | */ |
Christopher Faulet | c59ff23 | 2018-12-03 13:58:44 +0100 | [diff] [blame] | 835 | int htx_reqline_to_h1(const struct htx_sl *sl, struct buffer *chk) |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 836 | { |
Christopher Faulet | 570d161 | 2018-11-26 11:13:57 +0100 | [diff] [blame] | 837 | if (HTX_SL_LEN(sl) + 4 > b_room(chk)) |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 838 | return 0; |
| 839 | |
Christopher Faulet | 570d161 | 2018-11-26 11:13:57 +0100 | [diff] [blame] | 840 | chunk_memcat(chk, HTX_SL_REQ_MPTR(sl), HTX_SL_REQ_MLEN(sl)); |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 841 | chunk_memcat(chk, " ", 1); |
Christopher Faulet | 570d161 | 2018-11-26 11:13:57 +0100 | [diff] [blame] | 842 | chunk_memcat(chk, HTX_SL_REQ_UPTR(sl), HTX_SL_REQ_ULEN(sl)); |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 843 | chunk_memcat(chk, " ", 1); |
Christopher Faulet | 1e7af46 | 2018-12-03 14:05:01 +0100 | [diff] [blame] | 844 | if (sl->flags & HTX_SL_F_VER_11) |
| 845 | chunk_memcat(chk, "HTTP/1.1", 8); |
| 846 | else |
| 847 | chunk_memcat(chk, HTX_SL_REQ_VPTR(sl), HTX_SL_REQ_VLEN(sl)); |
| 848 | |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 849 | chunk_memcat(chk, "\r\n", 2); |
| 850 | |
| 851 | return 1; |
| 852 | } |
| 853 | |
Christopher Faulet | c59ff23 | 2018-12-03 13:58:44 +0100 | [diff] [blame] | 854 | /* Appends the H1 representation of the status line block <blk> to the chunk |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 855 | * <chk>. It returns 1 if data are successfully appended, otherwise it |
| 856 | * returns 0. |
| 857 | */ |
Christopher Faulet | c59ff23 | 2018-12-03 13:58:44 +0100 | [diff] [blame] | 858 | int htx_stline_to_h1(const struct htx_sl *sl, struct buffer *chk) |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 859 | { |
Christopher Faulet | 570d161 | 2018-11-26 11:13:57 +0100 | [diff] [blame] | 860 | if (HTX_SL_LEN(sl) + 4 > b_size(chk)) |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 861 | return 0; |
| 862 | |
Christopher Faulet | 1e7af46 | 2018-12-03 14:05:01 +0100 | [diff] [blame] | 863 | if (sl->flags & HTX_SL_F_VER_11) |
| 864 | chunk_memcat(chk, "HTTP/1.1", 8); |
| 865 | else |
| 866 | chunk_memcat(chk, HTX_SL_RES_VPTR(sl), HTX_SL_RES_VLEN(sl)); |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 867 | chunk_memcat(chk, " ", 1); |
Christopher Faulet | 570d161 | 2018-11-26 11:13:57 +0100 | [diff] [blame] | 868 | chunk_memcat(chk, HTX_SL_RES_CPTR(sl), HTX_SL_RES_CLEN(sl)); |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 869 | chunk_memcat(chk, " ", 1); |
Christopher Faulet | 570d161 | 2018-11-26 11:13:57 +0100 | [diff] [blame] | 870 | chunk_memcat(chk, HTX_SL_RES_RPTR(sl), HTX_SL_RES_RLEN(sl)); |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 871 | chunk_memcat(chk, "\r\n", 2); |
| 872 | |
| 873 | return 1; |
| 874 | } |
| 875 | |
Christopher Faulet | c59ff23 | 2018-12-03 13:58:44 +0100 | [diff] [blame] | 876 | /* Appends the H1 representation of the header block <blk> to the chunk |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 877 | * <chk>. It returns 1 if data are successfully appended, otherwise it returns |
| 878 | * 0. |
| 879 | */ |
Christopher Faulet | c59ff23 | 2018-12-03 13:58:44 +0100 | [diff] [blame] | 880 | int htx_hdr_to_h1(const struct ist n, const struct ist v, struct buffer *chk) |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 881 | { |
| 882 | if (n.len + v.len + 4 > b_room(chk)) |
| 883 | return 0; |
| 884 | |
| 885 | chunk_memcat(chk, n.ptr, n.len); |
| 886 | chunk_memcat(chk, ": ", 2); |
| 887 | chunk_memcat(chk, v.ptr, v.len); |
| 888 | chunk_memcat(chk, "\r\n", 2); |
| 889 | |
| 890 | return 1; |
| 891 | } |
| 892 | |
Christopher Faulet | c59ff23 | 2018-12-03 13:58:44 +0100 | [diff] [blame] | 893 | /* Appends the H1 representation of the data block <blk> to the chunk |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 894 | * <chk>. If <chunked> is non-zero, it emits HTTP/1 chunk-encoded data. It |
| 895 | * returns 1 if data are successfully appended, otherwise it returns 0. |
| 896 | */ |
Christopher Faulet | c59ff23 | 2018-12-03 13:58:44 +0100 | [diff] [blame] | 897 | int htx_data_to_h1(const struct ist data, struct buffer *chk, int chunked) |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 898 | { |
| 899 | if (chunked) { |
| 900 | uint32_t chksz; |
| 901 | char tmp[10]; |
| 902 | char *beg, *end; |
| 903 | |
| 904 | chksz = data.len; |
| 905 | |
| 906 | beg = end = tmp+10; |
| 907 | *--beg = '\n'; |
| 908 | *--beg = '\r'; |
| 909 | do { |
| 910 | *--beg = hextab[chksz & 0xF]; |
| 911 | } while (chksz >>= 4); |
| 912 | |
| 913 | if (data.len + (end - beg) + 2 > b_room(chk)) |
| 914 | return 0; |
| 915 | chunk_memcat(chk, beg, end - beg); |
| 916 | chunk_memcat(chk, data.ptr, data.len); |
| 917 | chunk_memcat(chk, "\r\n", 2); |
| 918 | } |
| 919 | else { |
| 920 | if (!chunk_memcat(chk, data.ptr, data.len)) |
| 921 | return 0; |
| 922 | } |
| 923 | |
| 924 | return 1; |
| 925 | } |
| 926 | |
Christopher Faulet | c59ff23 | 2018-12-03 13:58:44 +0100 | [diff] [blame] | 927 | /* Appends the h1 representation of the trailer block <blk> to the chunk |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 928 | * <chk>. It returns 1 if data are successfully appended, otherwise it returns |
| 929 | * 0. |
| 930 | */ |
Christopher Faulet | c59ff23 | 2018-12-03 13:58:44 +0100 | [diff] [blame] | 931 | int htx_trailer_to_h1(const struct ist tlr, struct buffer *chk) |
Christopher Faulet | a3d2a16 | 2018-10-22 08:59:39 +0200 | [diff] [blame] | 932 | { |
| 933 | /* FIXME: be sure the CRLF is here or remove it when inserted */ |
| 934 | if (!chunk_memcat(chk, tlr.ptr, tlr.len)) |
| 935 | return 0; |
| 936 | return 1; |
| 937 | } |