Code Coverage: vinyl-cache/bin/vinyld/cache/cache_vrt_var.c
 
82217aa4fc7094b3610340078afaf78cd95a8ec9
 
0
/*-
1
 * Copyright (c) 2006 Verdens Gang AS
2
 * Copyright (c) 2006-2015 Varnish Software AS
3
 * All rights reserved.
4
 *
5
 * Author: Poul-Henning Kamp <phk@phk.freebsd.dk>
6
 *
7
 * SPDX-License-Identifier: BSD-2-Clause
8
 *
9
 * Redistribution and use in source and binary forms, with or without
10
 * modification, are permitted provided that the following conditions
11
 * are met:
12
 * 1. Redistributions of source code must retain the above copyright
13
 *    notice, this list of conditions and the following disclaimer.
14
 * 2. Redistributions in binary form must reproduce the above copyright
15
 *    notice, this list of conditions and the following disclaimer in the
16
 *    documentation and/or other materials provided with the distribution.
17
 *
18
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
19
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
20
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
21
 * ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
22
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
23
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
24
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
25
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
26
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
27
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
28
 * SUCH DAMAGE.
29
 *
30
 * Runtime support for compiled VCL programs
31
 */
32
#include "config.h"
33
34
#include <stdio.h>
35
36
#include "cache_int.h"
37
#include "cache_objhead.h"
38
#include "cache_transport.h"
39
#include "storage/storage.h"
40
#include "common/heritage.h"
41
42
#include "vcl.h"
43
#include "vtim.h"
44
#include "vtcp.h"
45
46
#include "vrt_obj.h"
47
48 25
#define VRT_TMO(tmo) (isinf(tmo) ? VRT_DECIMAL_MAX : tmo)
49
50
static char vrt_hostname[255] = "";
51
const char *retry_disabled = "disabled from VCL";
52
53
/*--------------------------------------------------------------------
54
 * VRT variables relating to first line of HTTP/1.1 req/resp
55
 */
56
57
static void
58
vrt_do_strands(VRT_CTX, struct http *hp, int fld,
59
    const char *err, const char *str, VCL_STRANDS s)
60 4137
{
61 4137
        const char *b;
62
63 4137
        CHECK_OBJ_NOTNULL(hp, HTTP_MAGIC);
64
65 4137
        b = VRT_StrandsWS(hp->ws, str, s);
66 4137
        if (b == NULL) {
67 0
                VRT_fail(ctx, "Workspace overflow (%s)", err);
68 0
                WS_MarkOverflow(hp->ws);
69 0
                return;
70 0
        }
71 4137
        if (*b == '\0') {
72 3
                VRT_fail(ctx, "Setting %s to empty string", err);
73 3
                return;
74 3
        }
75 4134
        http_SetH(hp, fld, b);
76 4134
}
77
78
#define VRT_HDR_L(obj, hdr, fld)                                        \
79
VCL_VOID                                                                \
80 4137
VRT_l_##obj##_##hdr(VRT_CTX, const char *str, VCL_STRANDS s)            \
81 4137
{                                                                       \
82 4137
                                                                        \
83 4137
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);                          \
84 4137
        vrt_do_strands(ctx, ctx->http_##obj, fld, #obj "." #hdr, str, s);       \
85 4137
}
86
87
#define VRT_HDR_R(obj, hdr, fld)                                        \
88
VCL_STRING                                                              \
89 48126
VRT_r_##obj##_##hdr(VRT_CTX)                                            \
90 48126
{                                                                       \
91 48126
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);                          \
92 48126
        CHECK_OBJ_NOTNULL(ctx->http_##obj, HTTP_MAGIC);                 \
93 48126
        return (ctx->http_##obj->hd[fld].b);                            \
94 48126
}
95
96
#define VRT_HDR_LR(obj, hdr, fld)                                       \
97
        VRT_HDR_L(obj, hdr, fld)                                        \
98
        VRT_HDR_R(obj, hdr, fld)
99
100
#define VRT_STATUS_L(obj)                                               \
101
VCL_VOID                                                                \
102 85
VRT_l_##obj##_status(VRT_CTX, VCL_INT num)                              \
103 85
{                                                                       \
104 85
                                                                        \
105 85
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);                          \
106 85
        CHECK_OBJ_NOTNULL(ctx->http_##obj, HTTP_MAGIC);                 \
107 85
        if (num < 0)                                                    \
108 85
                VRT_fail(ctx, "%s.status (%jd) is negative",            \
109 1
                    #obj, (intmax_t)num);                               \
110 85
        else if (num > 65535)                                           \
111 84
                VRT_fail(ctx, "%s.status (%jd) > 65535",                \
112 1
                    #obj, (intmax_t)num);                               \
113 84
        else if ((num % 1000) < 100)                                    \
114 83
                VRT_fail(ctx, "illegal %s.status (%jd) (..0##)",        \
115 1
                    #obj, (intmax_t)num);                               \
116 83
        else                                                            \
117 83
                http_SetStatus(ctx->http_##obj, (uint16_t)num, NULL);   \
118 85
}
119
120
#define VRT_STATUS_R(obj)                                               \
121
VCL_INT                                                                 \
122 8848
VRT_r_##obj##_status(VRT_CTX)                                           \
123 8848
{                                                                       \
124 8848
                                                                        \
125 8848
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);                          \
126 8848
        CHECK_OBJ_NOTNULL(ctx->http_##obj, HTTP_MAGIC);                 \
127 8848
        return (ctx->http_##obj->status);                               \
128 8848
}
129
130
VRT_HDR_LR(req,    method,      HTTP_HDR_METHOD)
131
VRT_HDR_LR(req,    url,         HTTP_HDR_URL)
132
VRT_HDR_LR(req,    proto,       HTTP_HDR_PROTO)
133
134
VRT_HDR_R(req0,    method,      HTTP_HDR_METHOD)
135
VRT_HDR_R(req0,    url,         HTTP_HDR_URL)
136
VRT_HDR_R(req0,    proto,       HTTP_HDR_PROTO)
137
138
VRT_HDR_R(req_top,    method,   HTTP_HDR_METHOD)
139
VRT_HDR_R(req_top,    url,      HTTP_HDR_URL)
140
VRT_HDR_R(req_top,    proto,    HTTP_HDR_PROTO)
141
142
VRT_HDR_LR(resp,   proto,       HTTP_HDR_PROTO)
143
VRT_HDR_LR(resp,   reason,      HTTP_HDR_REASON)
144 23
VRT_STATUS_L(resp)
145
VRT_STATUS_R(resp)
146
147
VRT_HDR_LR(bereq,  method,      HTTP_HDR_METHOD)
148
VRT_HDR_LR(bereq,  url,         HTTP_HDR_URL)
149
VRT_HDR_LR(bereq,  proto,       HTTP_HDR_PROTO)
150
VRT_HDR_LR(beresp, proto,       HTTP_HDR_PROTO)
151
VRT_HDR_LR(beresp, reason,      HTTP_HDR_REASON)
152 62
VRT_STATUS_L(beresp)
153
VRT_STATUS_R(beresp)
154
155
/*--------------------------------------------------------------------
156
 * beresp bool-fields
157
 */
158
159
static inline int
160
beresp_filter_fixed(VRT_CTX, const char *s)
161 723
{
162 723
        if (ctx->bo->vfp_filter_list == NULL)
163 722
                return (0);
164 1
        VRT_fail(ctx,
165 1
            "beresp.filters are already fixed, beresp.%s is undefined", s);
166 1
        return (1);
167 723
}
168
169 103
#define VBERESPWF0(ctx, str) (void) 0
170 723
#define VBERESPWF1(ctx, str) do {               \
171 723
        if (beresp_filter_fixed((ctx), str))    \
172 723
                return;                 \
173 723
        } while(0)
174
175
#define VBERESPW0(field, str, fltchk)
176
#define VBERESPW1(field, str, fltchk)                                   \
177
void                                                                    \
178 826
VRT_l_beresp_##field(VRT_CTX, VCL_BOOL a)                               \
179 826
{                                                                       \
180 826
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);                          \
181 826
        CHECK_OBJ_NOTNULL(ctx->bo, BUSYOBJ_MAGIC);                      \
182 826
        VBERESPWF##fltchk(ctx, str);                                    \
183 826
        ctx->bo->field = a ? 1 : 0;                                     \
184 722
}
185
186 30
#define VBERESPRF0(ctx, str) (void) 0
187 0
#define VBERESPRF1(ctx, str) do {               \
188 0
        if (beresp_filter_fixed((ctx), str))    \
189 0
                return (0);                     \
190 0
        } while(0)
191
192
#define VBERESPR1(field, str, fltchk)                                   \
193
VCL_BOOL                                                                \
194 30
VRT_r_beresp_##field(VRT_CTX)                                           \
195 30
{                                                                       \
196 30
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);                          \
197 30
        CHECK_OBJ_NOTNULL(ctx->bo, BUSYOBJ_MAGIC);                      \
198 30
        VBERESPRF##fltchk(ctx, str);                                    \
199 30
        return (ctx->bo->field);                                        \
200 0
}
201
202
#define BERESP_FLAG(l, r, w, f, d)              \
203
        VBERESPR##r(l, #l, f)                   \
204
        VBERESPW##w(l, #l, f)
205
#include "tbl/beresp_flags.h"
206
207
#undef VBERESPWF0
208
#undef VBERESPWF1
209
#undef VBERESPW0
210
#undef VBERESPW1
211
212
#undef VBERESPRF0
213
#undef VBERESPRF1
214
#undef VBERESPR1
215
216
/*--------------------------------------------------------------------
217
 * bereq bool-fields
218
 *
219
 * for macro compatiblity with the client side, r is "req" for bereq
220
 */
221
222
#define VBEREQR0(field, str)
223
#define VBEREQRreq(field, str)                                          \
224
VCL_BOOL                                                                \
225 22
VRT_r_bereq_##field(VRT_CTX)                                            \
226 22
{                                                                       \
227 22
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);                          \
228 22
        CHECK_OBJ_NOTNULL(ctx->bo, BUSYOBJ_MAGIC);                      \
229 22
        return (ctx->bo->field);                                        \
230 22
}
231
232
#define BEREQ_FLAG(l, r, w, d)          \
233
        VBEREQR##r(l, #l)
234
#include "tbl/bereq_flags.h"
235
236
#undef VBEREQR0
237
#undef VBEREQRreq
238
/*--------------------------------------------------------------------*/
239
240
VCL_BOOL
241
VRT_r_bereq_uncacheable(VRT_CTX)
242 3107
{
243 3107
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
244 3107
        CHECK_OBJ_NOTNULL(ctx->bo, BUSYOBJ_MAGIC);
245 3107
        return (ctx->bo->uncacheable);
246 3107
}
247
248
VCL_VOID
249
VRT_l_beresp_uncacheable(VRT_CTX, VCL_BOOL a)
250 96
{
251 96
        struct objcore *oc;
252
253 96
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
254 96
        CHECK_OBJ_NOTNULL(ctx->bo, BUSYOBJ_MAGIC);
255 96
        CHECK_OBJ_NOTNULL(ctx->bo->fetch_objcore, OBJCORE_MAGIC);
256
257 96
        if (ctx->bo->uncacheable && !a) {
258 0
                VSLb(ctx->vsl, SLT_VCL_Error,
259 0
                    "Ignoring attempt to reset beresp.uncacheable");
260 96
        } else if (a) {
261 95
                ctx->bo->uncacheable = 1;
262 95
        }
263 96
        oc = ctx->bo->fetch_objcore;
264
265 96
        VSLb(ctx->vsl, SLT_TTL, "VCL %.0f %.0f %.0f %.0f %s",   \
266 96
            oc->ttl, oc->grace, oc->keep, oc->t_origin,         \
267 96
            ctx->bo->uncacheable ? "uncacheable" : "cacheable");\
268 96
}
269
270
VCL_BOOL
271
VRT_r_beresp_uncacheable(VRT_CTX)
272 1
{
273 1
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
274 1
        CHECK_OBJ_NOTNULL(ctx->bo, BUSYOBJ_MAGIC);
275 1
        return (ctx->bo->uncacheable);
276 1
}
277
278
VCL_VOID
279
VRT_l_req_trace(VRT_CTX, VCL_BOOL a)
280 1
{
281 1
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
282 1
        CHECK_OBJ_NOTNULL(ctx->req, REQ_MAGIC);
283 1
        ctx->req->trace = a;
284 1
        VRT_trace(ctx, a);
285 1
}
286
VCL_VOID
287
VRT_l_bereq_trace(VRT_CTX, VCL_BOOL a)
288 0
{
289 0
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
290 0
        CHECK_OBJ_NOTNULL(ctx->bo, BUSYOBJ_MAGIC);
291 0
        ctx->bo->trace = a;
292 0
        VRT_trace(ctx, a);
293 0
}
294
295
/*--------------------------------------------------------------------*/
296
297
VCL_BYTES
298
VRT_r_beresp_transit_buffer(VRT_CTX)
299 0
{
300 0
    struct objcore *oc;
301
302 0
    CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
303 0
    CHECK_OBJ_NOTNULL(ctx->bo, BUSYOBJ_MAGIC);
304
305 0
    oc = ctx->bo->fetch_objcore;
306 0
    CHECK_OBJ_NOTNULL(oc, OBJCORE_MAGIC);
307
308 0
    return oc->boc->transit_buffer;
309 0
}
310
311
VCL_VOID
312
VRT_l_beresp_transit_buffer(VRT_CTX, VCL_BYTES value)
313 2
{
314 2
    struct objcore *oc;
315
316 2
    CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
317 2
    CHECK_OBJ_NOTNULL(ctx->bo, BUSYOBJ_MAGIC);
318
319 2
    oc = ctx->bo->fetch_objcore;
320 2
    CHECK_OBJ_NOTNULL(oc, OBJCORE_MAGIC);
321
322 2
    oc->boc->transit_buffer = value;
323 2
}
324
325
/*--------------------------------------------------------------------*/
326
327
VCL_STRING
328
VRT_r_client_identity(VRT_CTX)
329 6
{
330 6
        const char *id;
331
332 6
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
333 6
        if (ctx->req != NULL) {
334 4
                CHECK_OBJ(ctx->req, REQ_MAGIC);
335 4
                id = ctx->req->client_identity;
336 4
        } else {
337 2
                CHECK_OBJ_NOTNULL(ctx->bo, BUSYOBJ_MAGIC);
338 2
                id = ctx->bo->client_identity;
339 2
        }
340 6
        if (id != NULL)
341 4
                return (id);
342 2
        return (SES_Get_String_Attr(ctx->sp, SA_CLIENT_IP));
343 6
}
344
345
VCL_VOID
346
VRT_l_client_identity(VRT_CTX, const char *str, VCL_STRANDS s)
347 3
{
348 3
        const char *b;
349
350 3
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
351 3
        CHECK_OBJ_NOTNULL(ctx->req, REQ_MAGIC);
352 3
        b = VRT_StrandsWS(ctx->req->http->ws, str, s);
353 3
        if (b == NULL) {
354 0
                VSLb(ctx->vsl, SLT_LostHeader, "client.identity");
355 0
                WS_MarkOverflow(ctx->req->http->ws);
356 0
                return;
357 0
        }
358 3
        ctx->req->client_identity = b;
359 3
}
360
361
/*--------------------------------------------------------------------*/
362
363
#define BEREQ_TIMEOUT(prefix, which)                            \
364
VCL_VOID                                                        \
365 21
VRT_l_bereq_##which(VRT_CTX, VCL_DURATION num)                  \
366 21
{                                                               \
367 21
                                                                \
368 21
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);                  \
369 21
        CHECK_OBJ_NOTNULL(ctx->bo, BUSYOBJ_MAGIC);              \
370 21
        ctx->bo->which = num;                                   \
371 21
}                                                               \
372
                                                                \
373
VCL_DURATION                                                    \
374 11
VRT_r_bereq_##which(VRT_CTX)                                    \
375 11
{                                                               \
376 11
        vtim_dur res;                                           \
377 11
                                                                \
378 11
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);                  \
379 11
        CHECK_OBJ_NOTNULL(ctx->bo, BUSYOBJ_MAGIC);              \
380 11
        res = BUSYOBJ_TMO(ctx->bo, prefix, which);              \
381 11
        return (VRT_TMO(res));                                  \
382 11
}                                                               \
383
                                                                \
384
VCL_VOID                                                        \
385 7
VRT_u_bereq_##which(VRT_CTX)                                    \
386 7
{                                                               \
387 7
                                                                \
388 7
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);                  \
389 7
        CHECK_OBJ_NOTNULL(ctx->bo, BUSYOBJ_MAGIC);              \
390 7
        ctx->bo->which = NAN;                                   \
391 7
}
392
393 5
BEREQ_TIMEOUT(, connect_timeout)
394 4
BEREQ_TIMEOUT(, first_byte_timeout)
395 5
BEREQ_TIMEOUT(, between_bytes_timeout)
396 4
BEREQ_TIMEOUT(pipe_, task_deadline)
397
398
399
/*--------------------------------------------------------------------*/
400
401
VCL_STRING
402
VRT_r_beresp_backend_name(VRT_CTX)
403 1
{
404
405 1
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
406 1
        CHECK_OBJ_NOTNULL(ctx->bo, BUSYOBJ_MAGIC);
407 1
        if (ctx->bo->director_resp != NULL)
408 1
                return (ctx->bo->director_resp->vcl_name);
409 0
        return (NULL);
410 1
}
411
412
/*--------------------------------------------------------------------
413
 * Backends do not in general have a IP number (any more) and this
414
 * variable is really not about the backend, but the backend connection.
415
 * XXX: we may need a more general beresp.backend.{details|ident}
416
 */
417
418
VCL_IP
419
VRT_r_beresp_backend_ip(VRT_CTX)
420 1
{
421
422 1
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
423 1
        CHECK_OBJ_NOTNULL(ctx->bo, BUSYOBJ_MAGIC);
424 1
        return (VDI_GetIP(ctx->bo));
425 1
}
426
427
/*--------------------------------------------------------------------*/
428
429
VCL_STEVEDORE
430
VRT_r_req_storage(VRT_CTX)
431 1
{
432 1
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
433 1
        CHECK_OBJ_NOTNULL(ctx->req, REQ_MAGIC);
434 1
        return (ctx->req->storage);
435 1
}
436
437
VCL_VOID
438
VRT_l_req_storage(VRT_CTX, VCL_STEVEDORE stv)
439 7
{
440 7
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
441 7
        CHECK_OBJ_NOTNULL(ctx->req, REQ_MAGIC);
442 7
        ctx->req->storage = stv;
443 7
}
444
445
/*--------------------------------------------------------------------*/
446
447
VCL_STEVEDORE
448
VRT_r_resp_storage(VRT_CTX)
449 3
{
450 3
        struct objcore *oc;
451
452 3
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
453 3
        CHECK_OBJ_NOTNULL(ctx->req, REQ_MAGIC);
454 3
        oc = ctx->req->objcore;
455 3
        if (oc == NULL)
456 1
                VRT_l_resp_storage(ctx, NULL);
457 3
        oc = ctx->req->objcore;
458 3
        if (oc == NULL)
459 1
                return (NULL);
460 2
        CHECK_OBJ(oc, OBJCORE_MAGIC);
461 2
        return (oc->stobj->stevedore);
462 2
}
463
464
VCL_VOID
465
VRT_l_resp_storage(VRT_CTX, VCL_STEVEDORE stv)
466 3566
{
467 3566
        ssize_t *szp;
468
469 3566
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
470 3566
        assert(ctx->method == VCL_MET_SYNTH);
471 3566
        szp = ctx->specific;
472 3566
        AN(szp);
473 3566
        *szp = -1;
474 3566
        if (stv == NULL)
475 3553
                stv = stv_synth;
476 3566
        if (Resp_l_storage(ctx->req, stv))
477 3565
                *szp = 0;
478 1
        else
479 1
                VRT_fail(ctx, "Storage %s NewObject failed", stv->vclname);
480 3566
}
481
482
/*--------------------------------------------------------------------*/
483
484
VCL_STEVEDORE
485
VRT_r_beresp_storage(VRT_CTX)
486 9
{
487 9
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
488 9
        CHECK_OBJ_NOTNULL(ctx->bo, BUSYOBJ_MAGIC);
489 9
        return (ctx->bo->storage);
490 9
}
491
492
VCL_VOID
493
VRT_l_beresp_storage(VRT_CTX, VCL_STEVEDORE stv)
494 26
{
495 26
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
496 26
        CHECK_OBJ_NOTNULL(ctx->bo, BUSYOBJ_MAGIC);
497 26
        ctx->bo->storage = stv;
498 26
}
499
500
/*--------------------------------------------------------------------*/
501
502
#define VRT_OC_VAR_R(obj, which, which_magic, field)            \
503
VCL_STEVEDORE                                                   \
504 5
VRT_r_##obj##_storage(VRT_CTX)                                  \
505 5
{                                                               \
506 5
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);                  \
507 5
        CHECK_OBJ_NOTNULL(ctx->which, which_magic);             \
508 5
        CHECK_OBJ_NOTNULL(ctx->which->field, OBJCORE_MAGIC);    \
509 5
        AN(ctx->which->field->stobj);                           \
510 5
        CHECK_OBJ_NOTNULL(ctx->which->field->stobj->stevedore,  \
511 5
            STEVEDORE_MAGIC);                                   \
512 5
        return (ctx->which->field->stobj->stevedore);           \
513 5
}                                                               \
514
                                                                \
515
VCL_BOOL                                                        \
516 9
VRT_r_##obj##_can_esi(VRT_CTX)                                  \
517 9
{                                                               \
518 9
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);                  \
519 9
        CHECK_OBJ_NOTNULL(ctx->which, which_magic);             \
520 9
        CHECK_OBJ_NOTNULL(ctx->which->field, OBJCORE_MAGIC);    \
521 9
        return (ObjHasAttr(ctx->which->wrk, ctx->which->field,  \
522 9
            OA_ESIDATA));                                       \
523 9
}                                                               \
524
                                                                \
525
VCL_BOOL                                                        \
526 9
VRT_r_##obj##_uncacheable(VRT_CTX)                              \
527 9
{                                                               \
528 9
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);                  \
529 9
        CHECK_OBJ_NOTNULL(ctx->which, which_magic);             \
530 9
        CHECK_OBJ_NOTNULL(ctx->which->field, OBJCORE_MAGIC);    \
531 9
                                                                \
532 9
        return (ctx->which->field->flags & OC_F_HFM ? 1 : 0);   \
533 9
}                                                               \
534
                                                                \
535
VCL_INT                                                         \
536 34
VRT_r_##obj##_status(VRT_CTX)                                   \
537 34
{                                                               \
538 34
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);                  \
539 34
        CHECK_OBJ_NOTNULL(ctx->which, which_magic);             \
540 34
        CHECK_OBJ_NOTNULL(ctx->which->field, OBJCORE_MAGIC);    \
541 34
                                                                \
542 34
        return (HTTP_GetStatusPack(ctx->which->wrk,             \
543 34
            ctx->which->field));                                \
544 34
}                                                               \
545
                                                                \
546
VCL_STRING                                                      \
547 2
VRT_r_##obj##_proto(VRT_CTX)                                    \
548 2
{                                                               \
549 2
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);                  \
550 2
        CHECK_OBJ_NOTNULL(ctx->which, which_magic);             \
551 2
        CHECK_OBJ_NOTNULL(ctx->which->field, OBJCORE_MAGIC);    \
552 2
                                                                \
553 2
        return (HTTP_GetHdrPack(ctx->which->wrk,                \
554 2
            ctx->which->field, H__Proto));                      \
555 2
}                                                               \
556
                                                                \
557
VCL_STRING                                                      \
558 2
VRT_r_##obj##_reason(VRT_CTX)                                   \
559 2
{                                                               \
560 2
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);                  \
561 2
        CHECK_OBJ_NOTNULL(ctx->which, which_magic);             \
562 2
        CHECK_OBJ_NOTNULL(ctx->which->field, OBJCORE_MAGIC);    \
563 2
                                                                \
564 2
        return (HTTP_GetHdrPack(ctx->which->wrk,                \
565 2
            ctx->which->field, H__Reason));                     \
566 2
}
567
568
VRT_OC_VAR_R(obj, req, REQ_MAGIC, objcore)
569
VRT_OC_VAR_R(obj_stale, bo, BUSYOBJ_MAGIC, stale_oc)
570
571
/*--------------------------------------------------------------------*/
572
573
#define REQ_VAR_L(nm, elem, type, extra)                                \
574
                                                                        \
575
VCL_VOID                                                                \
576 13
VRT_l_req_##nm(VRT_CTX, type arg)                                       \
577 13
{                                                                       \
578 13
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);                          \
579 13
        CHECK_OBJ_NOTNULL(ctx->req, REQ_MAGIC);                         \
580 21
        extra;                                                          \
581 13
        ctx->req->elem = arg;                                           \
582 13
}
583
584
#define REQ_VAR_R(nm, elem, type)                                       \
585
                                                                        \
586
type                                                                    \
587 31
VRT_r_req_##nm(VRT_CTX)                                                 \
588 31
{                                                                       \
589 31
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);                          \
590 31
        CHECK_OBJ_NOTNULL(ctx->req, REQ_MAGIC);                         \
591 31
        return (ctx->req->elem);                                        \
592 31
}
593
594
#define REQ_VAR_U(nm, elem, val)                                        \
595
                                                                        \
596
VCL_VOID                                                                \
597 1
VRT_u_req_##nm(VRT_CTX)                                                 \
598 1
{                                                                       \
599 1
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);                          \
600 1
        CHECK_OBJ_NOTNULL(ctx->req, REQ_MAGIC);                         \
601 1
        ctx->req->elem = val;                                           \
602 1
}
603
604
REQ_VAR_R(backend_hint, director_hint, VCL_BACKEND)
605
606
REQ_VAR_L(max_age, d_ttl, VCL_DURATION, if (!(arg>0.0)) arg = 0;)
607
REQ_VAR_R(max_age, d_ttl, VCL_DURATION)
608
REQ_VAR_U(max_age, d_ttl, -1)
609
REQ_VAR_L(grace, d_grace, VCL_DURATION, if (!(arg>0.0)) arg = 0;)
610
REQ_VAR_R(grace, d_grace, VCL_DURATION)
611
REQ_VAR_U(grace, d_grace, -1)
612
613
// deprecated, to be removed
614 0
VCL_VOID VRT_l_req_ttl(VRT_CTX, VCL_DURATION arg) { VRT_l_req_max_age(ctx, arg); }
615 0
VCL_DURATION VRT_r_req_ttl(VRT_CTX) { return (VRT_r_req_max_age(ctx)); }
616 0
VCL_VOID VRT_u_req_ttl(VRT_CTX) { VRT_u_req_max_age(ctx); }
617
618
VCL_VOID
619
VRT_l_req_backend_hint(VRT_CTX, VCL_BACKEND be)
620 153
{
621
622 153
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
623 153
        CHECK_OBJ_NOTNULL(ctx->req, REQ_MAGIC);
624 153
        VRT_Assign_Backend(&ctx->req->director_hint, be);
625 153
}
626
627
/*--------------------------------------------------------------------*/
628
629
VCL_VOID
630
VRT_l_bereq_backend(VRT_CTX, VCL_BACKEND be)
631 769
{
632
633 769
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
634 769
        CHECK_OBJ_NOTNULL(ctx->bo, BUSYOBJ_MAGIC);
635 769
        VRT_Assign_Backend(&ctx->bo->director_req, be);
636 769
}
637
638
VCL_BACKEND
639
VRT_r_bereq_backend(VRT_CTX)
640 46
{
641
642 46
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
643 46
        CHECK_OBJ_NOTNULL(ctx->bo, BUSYOBJ_MAGIC);
644 46
        return (ctx->bo->director_req);
645 46
}
646
647
VCL_BACKEND
648
VRT_r_beresp_backend(VRT_CTX)
649 39
{
650
651 39
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
652 39
        CHECK_OBJ_NOTNULL(ctx->bo, BUSYOBJ_MAGIC);
653 39
        return (ctx->bo->director_resp);
654 39
}
655
656
/*--------------------------------------------------------------------*/
657
658
VCL_VOID
659
VRT_u_bereq_body(VRT_CTX)
660 2238
{
661 2238
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
662 2238
        CHECK_OBJ_NOTNULL(ctx->bo, BUSYOBJ_MAGIC);
663
664 2238
        http_Unset(ctx->bo->bereq, H_Content_Length);
665
666 2238
        if (ctx->bo->bereq_body != NULL)
667 5
                (void)HSH_DerefObjCore(ctx->bo->wrk, &ctx->bo->bereq_body);
668
669 2238
        if (ctx->bo->req != NULL) {
670 8
                CHECK_OBJ(ctx->bo->req, REQ_MAGIC);
671 8
                VBO_SetState(ctx->bo->wrk, ctx->bo, BOS_REQ_DONE);
672 8
                AZ(ctx->bo->req);
673 8
        }
674 2238
}
675
676
/*--------------------------------------------------------------------*/
677
678
VCL_VOID
679
VRT_l_req_esi(VRT_CTX, VCL_BOOL process_esi)
680 11
{
681
682 11
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
683 11
        CHECK_OBJ_NOTNULL(ctx->req, REQ_MAGIC);
684 11
        assert(ctx->syntax <= 40);
685
        /*
686
         * Only allow you to turn of esi in the main request
687
         * else everything gets confused
688
         * NOTE: this is not true, but we do not change behavior
689
         * for vcl 4.0. For 4.1, see VRT_l_resp_do_esi()
690
         */
691 11
        if (IS_TOPREQ(ctx->req))
692 7
                ctx->req->disable_esi = !process_esi;
693 11
}
694
695
VCL_BOOL
696
VRT_r_req_esi(VRT_CTX)
697 3
{
698
699 3
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
700 3
        CHECK_OBJ_NOTNULL(ctx->req, REQ_MAGIC);
701 3
        assert(ctx->syntax <= 40);
702 3
        return (!ctx->req->disable_esi);
703 3
}
704
705
VCL_INT
706
VRT_r_req_esi_level(VRT_CTX)
707 4783
{
708
709 4783
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
710 4783
        CHECK_OBJ_NOTNULL(ctx->req, REQ_MAGIC);
711 4783
        return (ctx->req->esi_level);
712 4783
}
713
714
/*--------------------------------------------------------------------*/
715
716
VCL_BOOL
717
VRT_r_req_can_gzip(VRT_CTX)
718 8
{
719
720 8
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
721 8
        CHECK_OBJ_NOTNULL(ctx->req, REQ_MAGIC);
722 8
        return (RFC2616_Req_Gzip(ctx->req->http));      // XXX ?
723 8
}
724
725
/*--------------------------------------------------------------------*/
726
727
VCL_INT
728
VRT_r_req_restarts(VRT_CTX)
729 159
{
730
731 159
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
732 159
        CHECK_OBJ_NOTNULL(ctx->req, REQ_MAGIC);
733 159
        return (ctx->req->restarts);
734 159
}
735
736
VCL_INT
737
VRT_r_bereq_retries(VRT_CTX)
738 67
{
739
740 67
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
741 67
        CHECK_OBJ_NOTNULL(ctx->bo, BUSYOBJ_MAGIC);
742 67
        return (ctx->bo->retries);
743 67
}
744
745
VCL_VOID
746
VRT_l_bereq_retry_connect(VRT_CTX, VCL_BOOL b)
747 7
{
748
749 7
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
750 7
        CHECK_OBJ_NOTNULL(ctx->bo, BUSYOBJ_MAGIC);
751
752 7
        if (!b && ctx->bo->no_retry == NULL)
753 4
                ctx->bo->no_retry = retry_disabled;
754 3
        else if (b && ctx->bo->no_retry == retry_disabled)
755 0
                ctx->bo->no_retry = NULL;
756 7
}
757
758
VCL_BOOL
759
VRT_r_bereq_retry_connect(VRT_CTX)
760 0
{
761
762 0
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
763 0
        CHECK_OBJ_NOTNULL(ctx->bo, BUSYOBJ_MAGIC);
764 0
        return (ctx->bo->no_retry == NULL);
765 0
}
766
767
/*--------------------------------------------------------------------*/
768
769
VCL_STRING
770
VRT_r_req_transport(VRT_CTX)
771 18
{
772 18
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
773
774 18
        CHECK_OBJ_NOTNULL(ctx->req, REQ_MAGIC);
775 18
        CHECK_OBJ_NOTNULL(ctx->req->transport, TRANSPORT_MAGIC);
776 18
        return (ctx->req->transport->name);
777 18
}
778
779
/*--------------------------------------------------------------------
780
 * In exp.*:
781
 *      t_origin is absolute
782
 *      ttl is relative to t_origin
783
 *      grace&keep are relative to ttl
784
 * In VCL:
785
 *      ttl is relative to "ttl_now", which is t_req on the client
786
 *      side, except in vcl_deliver, where it is ctx->now. On the
787
 *      fetch side "ttl_now" is ctx->now (which is bo->t_prev).
788
 *      grace&keep are relative to ttl
789
 */
790
791
static double
792
ttl_now(VRT_CTX)
793 1584
{
794 1584
        if (ctx->bo) {
795 1556
                return (ctx->now);
796 1556
        } else {
797 28
                CHECK_OBJ(ctx->req, REQ_MAGIC);
798 28
                return (ctx->method == VCL_MET_DELIVER
799 28
                    ? ctx->now : ctx->req->t_req);
800 28
        }
801 1584
}
802
803
#define VRT_DO_EXP_L(which, oc, fld, offset)                    \
804
                                                                \
805
VCL_VOID                                                        \
806 481
VRT_l_##which##_##fld(VRT_CTX, VCL_DURATION a)                  \
807 481
{                                                               \
808 481
                                                                \
809 481
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);                  \
810 481
        a += (offset);                                          \
811 481
        if (a < 0.0)                                            \
812 481
                a = 0.0;                                        \
813 481
        oc->fld = a;                                            \
814 481
        VSLb(ctx->vsl, SLT_TTL, "VCL %.0f %.0f %.0f %.0f %s",   \
815 481
            oc->ttl, oc->grace, oc->keep, oc->t_origin,         \
816 481
            ctx->bo->uncacheable ? "uncacheable" : "cacheable");\
817 481
}
818
819
#define VRT_DO_EXP_R(which, oc, fld, offset)                    \
820
                                                                \
821
VCL_DURATION                                                    \
822 1335
VRT_r_##which##_##fld(VRT_CTX)                                  \
823 1335
{                                                               \
824 1335
        double d;                                               \
825 1335
                                                                \
826 1335
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);                  \
827 1335
        d = oc->fld;                                            \
828 1335
        if (d <= 0.0)                                           \
829 1335
                d = 0.0;                                        \
830 1335
        d -= (offset);                                          \
831 1335
        return (d);                                             \
832 1335
}
833
834
/*lint -save -e835 */   // Zero right hand arg to '-'
835
836
VRT_DO_EXP_R(obj_stale, ctx->bo->stale_oc, ttl,
837
    ttl_now(ctx) - ctx->bo->stale_oc->t_origin)
838
VRT_DO_EXP_R(obj, ctx->req->objcore, ttl,
839
    ttl_now(ctx) - ctx->req->objcore->t_origin)
840
VRT_DO_EXP_R(obj_stale, ctx->bo->stale_oc, grace, 0)
841
VRT_DO_EXP_R(obj, ctx->req->objcore, grace, 0)
842
VRT_DO_EXP_R(obj_stale, ctx->bo->stale_oc, keep, 0)
843
VRT_DO_EXP_R(obj, ctx->req->objcore, keep, 0)
844
VRT_DO_EXP_L(beresp, ctx->bo->fetch_objcore, ttl,
845
    ttl_now(ctx) - ctx->bo->fetch_objcore->t_origin)
846
VRT_DO_EXP_R(beresp, ctx->bo->fetch_objcore, ttl,
847
    ttl_now(ctx) - ctx->bo->fetch_objcore->t_origin)
848
849
VRT_DO_EXP_L(beresp, ctx->bo->fetch_objcore, grace, 0)
850
VRT_DO_EXP_R(beresp, ctx->bo->fetch_objcore, grace, 0)
851
VRT_DO_EXP_L(beresp, ctx->bo->fetch_objcore, keep, 0)
852
VRT_DO_EXP_R(beresp, ctx->bo->fetch_objcore, keep, 0)
853
854
/*lint -restore */
855
856
// XXX more assertions?
857
#define VRT_DO_TIME_R(which, where, field)                              \
858
                                                                        \
859
VCL_TIME                                                                \
860 28
VRT_r_##which##_time(VRT_CTX)                                           \
861 28
{                                                                       \
862 28
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);                          \
863 28
        AN((ctx)->where);                                               \
864 28
                                                                        \
865 28
        return ((ctx)->where->field);                                   \
866 28
}
867
868
VRT_DO_TIME_R(req, req, t_req)
869
VRT_DO_TIME_R(req_top, req->top->topreq, t_req)
870
VRT_DO_TIME_R(resp, req, t_resp)
871
VRT_DO_TIME_R(bereq, bo, t_first)
872
VRT_DO_TIME_R(beresp, bo, t_resp)
873
VRT_DO_TIME_R(obj, req->objcore, t_origin)
874
VRT_DO_TIME_R(obj_stale, bo->stale_oc, t_origin)
875
876
/*--------------------------------------------------------------------
877
 */
878
879
#define VRT_DO_AGE_R(which, oc)                                 \
880
                                                                \
881
VCL_DURATION                                                    \
882 10
VRT_r_##which##_##age(VRT_CTX)                                  \
883 10
{                                                               \
884 10
                                                                \
885 10
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);                  \
886 10
        return (ttl_now(ctx) - oc->t_origin);                   \
887 10
}
888
889
VRT_DO_AGE_R(obj_stale, ctx->bo->stale_oc)
890
VRT_DO_AGE_R(obj, ctx->req->objcore)
891
VRT_DO_AGE_R(beresp, ctx->bo->fetch_objcore)
892
893
/*--------------------------------------------------------------------
894
 * [[be]req|sess].xid
895
 */
896
897
VCL_INT
898
VRT_r_req_xid(VRT_CTX)
899 638
{
900
901 638
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
902 638
        CHECK_OBJ_NOTNULL(ctx->req, REQ_MAGIC);
903 638
        CHECK_OBJ_NOTNULL(ctx->req->http, HTTP_MAGIC);
904 638
        AN(ctx->req->vsl);
905 638
        return (VXID(ctx->req->vsl->wid));
906 638
}
907
908
VCL_INT
909
VRT_r_bereq_xid(VRT_CTX)
910 563
{
911
912 563
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
913 563
        CHECK_OBJ_NOTNULL(ctx->bo, BUSYOBJ_MAGIC);
914 563
        AN(ctx->bo->vsl);
915
916 563
        return (VXID(ctx->bo->vsl->wid));
917 563
}
918
919
VCL_INT
920
VRT_r_sess_xid(VRT_CTX)
921 7
{
922 7
        struct sess *sp;
923
924 7
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
925
926 7
        if (ctx->req) {
927 4
                CHECK_OBJ(ctx->req, REQ_MAGIC);
928 4
                sp = ctx->req->sp;
929 4
        } else {
930 3
                CHECK_OBJ_NOTNULL(ctx->bo, BUSYOBJ_MAGIC);
931 3
                sp = ctx->bo->sp;
932 3
        }
933
934 7
        CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
935 7
        return (VXID(sp->vxid));
936 7
}
937
938
/*--------------------------------------------------------------------
939
 * req/resp fields, both stored in struct req
940
 */
941
942
#define VREQW(where, field)                                             \
943
VCL_VOID                                                                \
944 20
VRT_l_##where##_##field(VRT_CTX, VCL_BOOL a)                            \
945 20
{                                                                       \
946 20
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);                          \
947 20
        CHECK_OBJ_NOTNULL(ctx->req, REQ_MAGIC);                         \
948 20
        ctx->req->field = a ? 1 : 0;                                    \
949 20
}
950
951
#define VREQR(where, field)                                             \
952
VCL_BOOL                                                                \
953 64
VRT_r_##where##_##field(VRT_CTX)                                        \
954 64
{                                                                       \
955 64
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);                          \
956 64
        CHECK_OBJ_NOTNULL(ctx->req, REQ_MAGIC);                         \
957 64
        return (ctx->req->field);                                       \
958 64
}
959
960
#define VREQW0(field)
961
#define VREQR0(field)
962
#define VREQWreq(field)         VREQW(req, field)
963
#define VREQRreq(field)         VREQR(req, field)
964
#define VREQWresp(field)        VREQW(resp, field)
965
#define VREQRresp(field)        VREQR(resp, field)
966
967
#define REQ_FLAG(l, r, w, d) \
968
        VREQR##r(l) \
969
        VREQW##w(l)
970
#include "tbl/req_flags.h"
971
972
#undef VREQW
973
#undef VREQR
974
#undef VREQW0
975
#undef VREQR0
976
#undef VREQWreq
977
#undef VREQRreq
978
#undef VREQWresp
979
#undef VREQRresp
980
981
982
/*--------------------------------------------------------------------*/
983
984
#define GIP(fld)                                                \
985
        VCL_IP                                                  \
986
        VRT_r_##fld##_ip(VRT_CTX)                               \
987 551
        {                                                       \
988 551
                struct suckaddr *sa;                            \
989 551
                                                                \
990 551
                CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);          \
991 551
                CHECK_OBJ_NOTNULL(ctx->sp, SESS_MAGIC);         \
992 551
                AZ(SES_Get_##fld##_addr(ctx->sp, &sa));         \
993 551
                return (sa);                                    \
994 551
        }
995
996
GIP(local)
997
GIP(remote)
998
GIP(client)
999
GIP(server)
1000
#undef GIP
1001
1002
/*--------------------------------------------------------------------
1003
 * local.[endpoint|socket]
1004
 */
1005
1006
#define LOC(var,fld)                                            \
1007
VCL_STRING                                                      \
1008 3448
VRT_r_local_##var(VRT_CTX)                                      \
1009 3448
{                                                               \
1010 3448
        struct sess *sp;                                        \
1011 3448
                                                                \
1012 3448
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);                  \
1013 3448
        if (ctx->req) {                                         \
1014 3441
                CHECK_OBJ(ctx->req, REQ_MAGIC);                 \
1015 3441
                sp = ctx->req->sp;                              \
1016 3441
        } else {                                                \
1017 7
                CHECK_OBJ_NOTNULL(ctx->bo, BUSYOBJ_MAGIC);      \
1018 7
                sp = ctx->bo->sp;                               \
1019 7
        }                                                       \
1020 3448
                                                                \
1021 3448
        CHECK_OBJ_NOTNULL(sp->listen_sock, LISTEN_SOCK_MAGIC);  \
1022 3448
        AN(sp->listen_sock->fld);                               \
1023 3448
        return (sp->listen_sock->fld);                          \
1024 3448
}
1025
1026
LOC(endpoint, endpoint)
1027
LOC(socket, name)
1028
#undef LOC
1029
1030
/*--------------------------------------------------------------------*/
1031
1032
VCL_STRING
1033
VRT_r_server_identity(VRT_CTX)
1034 10
{
1035
1036 10
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
1037 10
        if (heritage.identity != NULL)
1038 10
                return (heritage.identity);
1039 0
        else
1040 0
                return ("vinyld");
1041 10
}
1042
1043
VCL_STRING
1044
VRT_r_server_hostname(VRT_CTX)
1045 3
{
1046
1047 3
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
1048 3
        if (vrt_hostname[0] == '\0')
1049 2
                AZ(gethostname(vrt_hostname, sizeof(vrt_hostname)));
1050 3
        return (vrt_hostname);
1051 3
}
1052
1053
/*--------------------------------------------------------------------*/
1054
1055
VCL_INT
1056
VRT_r_obj_hits(VRT_CTX)
1057 88
{
1058 88
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
1059 88
        CHECK_OBJ_NOTNULL(ctx->req, REQ_MAGIC);
1060 88
        CHECK_OBJ_NOTNULL(ctx->req->objcore, OBJCORE_MAGIC);
1061 88
        if (ctx->method == VCL_MET_HIT)
1062 2
                return (ctx->req->objcore->hits);
1063 86
        return (ctx->req->is_hit ? ctx->req->objcore->hits : 0);
1064 88
}
1065
1066
/*--------------------------------------------------------------------*/
1067
1068
VCL_INT
1069
VRT_r_obj_stale_hits(VRT_CTX)
1070 1
{
1071 1
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
1072 1
        CHECK_OBJ_NOTNULL(ctx->bo, BUSYOBJ_MAGIC);
1073 1
        CHECK_OBJ_NOTNULL(ctx->bo->stale_oc, OBJCORE_MAGIC);
1074
1075 1
        return (ctx->bo->stale_oc->hits);
1076 1
}
1077
1078
VCL_BOOL
1079
VRT_r_obj_stale_is_valid(VRT_CTX)
1080 39
{
1081 39
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
1082 39
        CHECK_OBJ_NOTNULL(ctx->bo, BUSYOBJ_MAGIC);
1083 39
        CHECK_OBJ_NOTNULL(ctx->bo->stale_oc, OBJCORE_MAGIC);
1084
1085 39
        return (!(ctx->bo->stale_oc->flags & OC_F_DYING));
1086 39
}
1087
1088
/*--------------------------------------------------------------------*/
1089
1090
VCL_BOOL
1091
VRT_r_resp_is_streaming(VRT_CTX)
1092 5
{
1093 5
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
1094 5
        CHECK_OBJ_NOTNULL(ctx->req, REQ_MAGIC);
1095 5
        if (ctx->req->objcore == NULL)
1096 1
                return (0);     /* When called from vcl_synth */
1097 4
        CHECK_OBJ(ctx->req->objcore, OBJCORE_MAGIC);
1098 4
        return (ctx->req->objcore->boc == NULL ? 0 : 1);
1099 4
}
1100
1101
/*--------------------------------------------------------------------*/
1102
1103
static inline int
1104
resp_filter_fixed(VRT_CTX, const char *s)
1105 1484
{
1106 1484
        if (ctx->req->vdp_filter_list == NULL)
1107 1484
                return (0);
1108 0
        VRT_fail(ctx, "resp.filters are already fixed, %s is undefined", s);
1109 0
        return (1);
1110 1484
}
1111
1112
VCL_VOID
1113
VRT_l_resp_do_esi(VRT_CTX, VCL_BOOL process_esi)
1114 1476
{
1115
1116 1476
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
1117 1476
        CHECK_OBJ_NOTNULL(ctx->req, REQ_MAGIC);
1118 1476
        assert(ctx->syntax >= 41);
1119 1476
        if (resp_filter_fixed(ctx, "resp.do_esi"))
1120 1
                return;
1121 1475
        ctx->req->disable_esi = !process_esi;
1122 1475
}
1123
1124
VCL_BOOL
1125
VRT_r_resp_do_esi(VRT_CTX)
1126 9
{
1127
1128 9
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
1129 9
        CHECK_OBJ_NOTNULL(ctx->req, REQ_MAGIC);
1130 9
        assert(ctx->syntax >= 41);
1131 9
        if (resp_filter_fixed(ctx, "resp.do_esi"))
1132 0
                return (0);
1133 9
        return (!ctx->req->disable_esi);
1134 9
}
1135
1136
/*--------------------------------------------------------------------*/
1137
1138
static ssize_t
1139
l_obj(struct worker *wrk, struct objcore *oc, ssize_t ll, const uint8_t *data)
1140 4639
{
1141 4639
        ssize_t l, sz = ll;
1142 4639
        uint8_t *ptr;
1143
1144 9278
        while (ll > 0) {
1145
                // allocate as "size unknown" like with chunked
1146
                // will usually lead to the storage allocating fetch_chunksize
1147 4639
                l = 0;
1148 4639
                if (! ObjGetSpace(wrk, oc, &l, &ptr))
1149 0
                        return (-1);
1150 4639
                assert(l > 0);
1151 4639
                l = vmin(l, ll);
1152 4639
                vmemcpy(ptr, data, l);
1153 4639
                ObjExtend(wrk, oc, l, 0);
1154 4639
                ll -= l;
1155 4639
                data += l;
1156 4639
        }
1157 4639
        return (sz);
1158 4639
}
1159
1160
/*
1161
 * write a VCL_BODY to an object. The caller is responsible for handling
1162
 * LBODY_SET_* by creating a new object.
1163
 *
1164
 * The size written is returned, or -1 upon error
1165
 */
1166
static ssize_t
1167
vrt_l_obj(struct worker *wrk, enum lbody_e type,
1168
    const char *str, VCL_BODY body, struct objcore *oc)
1169 1551
{
1170 1551
        VCL_STRANDS s;
1171 1551
        VCL_BLOB b;
1172 1551
        ssize_t sz = 0, ssz;
1173
1174 1551
        AN(body);
1175 1551
        if (type == LBODY_SET_BLOB || type == LBODY_ADD_BLOB) {
1176 6
                AZ(str);
1177 6
                b = body;
1178 6
                CHECK_OBJ(b, VRT_BLOB_MAGIC);
1179 6
                return (l_obj(wrk, oc, b->len, b->blob));
1180 6
        }
1181 1545
        assert(type == LBODY_SET_STRING || type == LBODY_ADD_STRING);
1182 1545
        if (str != NULL)
1183 0
                sz = l_obj(wrk, oc, vstrlen(str), (const uint8_t *)str);
1184 1545
        if (sz < 0)
1185 0
                return (sz);
1186
1187 1545
        s = body;
1188 1545
        CHECK_OBJ(s, STRANDS_MAGIC);
1189 4633
        STRANDS_FOREACH(p, s) {
1190 4633
                if (p == NULL || *p == '\0')
1191 0
                        continue;
1192 4633
                ssz = l_obj(wrk, oc, vstrlen(p), (const uint8_t *)p);
1193 4633
                if (ssz < 0)
1194 0
                        return (ssz);
1195 4633
                sz += ssz;
1196 4633
        }
1197
1198 1545
        return (sz);
1199 1545
}
1200
1201
#define VRT_BODY_L(which)                                       \
1202
VCL_VOID                                                        \
1203
VRT_l_##which##_body(VRT_CTX, enum lbody_e type,                \
1204 324
    const char *str, VCL_BODY body)                             \
1205 324
{                                                               \
1206 324
        struct vsb *vsb;                                        \
1207 324
        VCL_STRANDS s;                                          \
1208 324
        VCL_BLOB b;                                             \
1209 324
                                                                \
1210 324
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);                  \
1211 324
        AN(body);                                               \
1212 324
        CAST_OBJ_NOTNULL(vsb, ctx->specific, VSB_MAGIC);        \
1213 324
        if (type == LBODY_SET_STRING || type == LBODY_SET_BLOB) \
1214 326
                VSB_clear(vsb);                                 \
1215 327
        if (type == LBODY_SET_BLOB || type == LBODY_ADD_BLOB) { \
1216 0
                AZ(str);                                        \
1217 0
                b = body;                                       \
1218 0
                CHECK_OBJ_NOTNULL(b, VRT_BLOB_MAGIC);           \
1219 0
                VSB_bcat(vsb, b->blob, b->len);                 \
1220 0
                return;                                         \
1221 0
        }                                                       \
1222 324
        if (str != NULL)                                        \
1223 324
                VSB_cat(vsb, str);                              \
1224 324
        assert(type == LBODY_SET_STRING ||                      \
1225 324
            type == LBODY_ADD_STRING);                          \
1226 324
        s = body;                                               \
1227 324
        CHECK_OBJ_NOTNULL(s, STRANDS_MAGIC);                    \
1228 324
        STRANDS_FOREACH(p, s)                                   \
1229 4069
                if (p != NULL)                                  \
1230 4069
                        VSB_cat(vsb, p);                        \
1231 324
}
1232
1233 324
VRT_BODY_L(beresp)
1234
1235
VCL_VOID
1236
VRT_l_resp_body(VRT_CTX, enum lbody_e type,
1237
    const char *str, VCL_BODY body)
1238 3571
{
1239 3571
        struct vscarab *scarab;
1240 3571
        struct viov *viov;
1241 3571
        struct req *req;
1242 3571
        ssize_t sz = 0, *szp;
1243 3571
        VCL_STRANDS s;
1244 3571
        VCL_BLOB b;
1245
1246
1247 3571
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
1248 3571
        assert(ctx->method == VCL_MET_SYNTH);
1249 3571
        AN(body);
1250 3571
        req = ctx->req;
1251 3571
        CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
1252 3571
        szp = ctx->specific;
1253 3571
        AN(szp);
1254
1255 3571
        if (req->objcore == NULL)
1256 3552
                VRT_l_resp_storage(ctx, NULL);
1257 19
        else if (*szp != 0 && (type == LBODY_SET_STRING || type == LBODY_SET_BLOB))
1258 4
                VRT_l_resp_storage(ctx, req->objcore->stobj->stevedore);
1259 3571
        if (req->objcore == NULL)
1260 1
                return;
1261
1262
        // latch just in case we did not check for VCL_RET_FAIL since last call
1263 3570
        if (*szp < 0)
1264 0
                return;
1265
1266 3570
        AN(req->objcore->stobj->stevedore);
1267 3570
        if (req->objcore->stobj->stevedore->allocobj != ssy_stevedore.allocobj) {
1268 1551
                sz = vrt_l_obj(req->wrk, type, str, body, req->objcore);
1269 1551
                if (sz < 0)
1270 0
                        goto fail;
1271 1551
                *szp += sz;
1272 1551
                return;
1273 1551
        }
1274
1275
        // The remaining code of this function special cases for ssy, where we
1276
        // do not request storage, but rather a scarab to fill with pointers,
1277
        // iow we provide io vectors rather than copy into storage
1278
1279 2019
        if (! ObjGetSpace(req->wrk, req->objcore, &sz, (uint8_t **)(void*)&scarab))
1280 0
                goto fail;
1281
1282 2019
        VSCARAB_CHECK_NOTNULL(scarab);
1283
1284 2019
        if (type == LBODY_SET_BLOB || type == LBODY_ADD_BLOB) {
1285 6
                AZ(str);
1286 6
                b = body;
1287 6
                CHECK_OBJ(b, VRT_BLOB_MAGIC);
1288 6
                if (b->len == 0)
1289 0
                        return;
1290 6
                viov = VSCARAB_GET(scarab);
1291 6
                AN(viov);       // ObjGetSpace ensures
1292 6
                viov->iov.iov_base = TRUST_ME(b->blob);
1293 6
                viov->iov.iov_len = b->len;
1294 6
                *szp += viov->iov.iov_len;
1295 6
                return;
1296 6
        }
1297 2013
        if (str != NULL && *str != '\0') {
1298 0
                viov = VSCARAB_GET(scarab);
1299 0
                AN(viov);       // ObjGetSpace ensures
1300 0
                viov->iov.iov_base = TRUST_ME(str);
1301 0
                viov->iov.iov_len = vstrlen(str);
1302 0
                *szp += viov->iov.iov_len;
1303 0
        }
1304
1305 2013
        s = body;
1306 10277
        STRANDS_FOREACH(p, s) {
1307 10277
                if (p == NULL || *p == '\0')
1308 16
                        continue;
1309
1310 10261
                viov = VSCARAB_GET(scarab);
1311 10261
                if (viov == NULL) {
1312 433
                        if (! ObjGetSpace(req->wrk, req->objcore, &sz,
1313 433
                            (uint8_t **)(void*)&scarab))
1314 0
                                goto fail;
1315 433
                        viov = VSCARAB_GET(scarab);
1316 433
                }
1317 10261
                AN(viov);
1318 10261
                viov->iov.iov_base = TRUST_ME(p);
1319 10261
                viov->iov.iov_len = vstrlen(p);
1320 10261
                *szp += viov->iov.iov_len;
1321 10261
        }
1322 2013
        return;
1323 2013
    fail:
1324 0
        *szp = -1;
1325 0
        VRT_fail(ctx, "Storage %s GetSpace failed",
1326 0
            req->objcore->stobj->stevedore->vclname);
1327 0
}
1328
1329
1330
/*--------------------------------------------------------------------*/
1331
1332
                        /* digest */
1333 16
#define BLOB_HASH_TYPE 0x00d16357
1334
1335
VCL_BLOB
1336
VRT_r_req_hash(VRT_CTX)
1337 4
{
1338 4
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
1339 4
        CHECK_OBJ_NOTNULL(ctx->req, REQ_MAGIC);
1340 4
        return (VRT_blob(ctx, "req.hash", ctx->req->digest, DIGEST_LEN,
1341 4
            BLOB_HASH_TYPE));
1342 4
}
1343
1344
VCL_BLOB
1345
VRT_r_bereq_hash(VRT_CTX)
1346 12
{
1347 12
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
1348 12
        CHECK_OBJ_NOTNULL(ctx->bo, BUSYOBJ_MAGIC);
1349 12
        return (VRT_blob(ctx, "bereq.hash", ctx->bo->digest, DIGEST_LEN,
1350 12
            BLOB_HASH_TYPE));
1351 12
}
1352
1353
/*--------------------------------------------------------------------*/
1354
1355
#define HTTP_VAR(x)                                             \
1356
VCL_HTTP                                                        \
1357 29
VRT_r_##x(VRT_CTX)                                              \
1358 29
{                                                               \
1359 29
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);                  \
1360 29
        CHECK_OBJ_NOTNULL(ctx->http_##x, HTTP_MAGIC);           \
1361 29
        return (ctx->http_##x);                                 \
1362 29
}
1363
1364
HTTP_VAR(req)
1365
HTTP_VAR(resp)
1366
HTTP_VAR(bereq)
1367
HTTP_VAR(beresp)
1368
1369
/*--------------------------------------------------------------------*/
1370
1371
static inline void
1372
set_idle_send_timeout(const struct sess *sp, VCL_DURATION d)
1373 3
{
1374 3
        struct timeval tv = VTIM_timeval_sock(d);
1375 3
        VTCP_Assert(setsockopt(sp->fd, SOL_SOCKET, SO_SNDTIMEO,
1376 3
            &tv, sizeof tv));
1377 3
}
1378
1379
#define SESS_VAR_DUR(x, setter)                         \
1380
VCL_VOID                                                \
1381 18
VRT_l_sess_##x(VRT_CTX, VCL_DURATION d)                 \
1382 18
{                                                       \
1383 18
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);          \
1384 18
        CHECK_OBJ_NOTNULL(ctx->sp, SESS_MAGIC);         \
1385 18
        d = vmax(d, 0.0);                               \
1386 18
        setter;                                         \
1387 18
        ctx->sp->x = d;                                 \
1388 18
}                                                       \
1389
                                                        \
1390
VCL_DURATION                                            \
1391 14
VRT_r_sess_##x(VRT_CTX)                                 \
1392 14
{                                                       \
1393 14
        vtim_dur res;                                   \
1394 14
                                                        \
1395 14
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);          \
1396 14
        CHECK_OBJ_NOTNULL(ctx->sp, SESS_MAGIC);         \
1397 14
        res = SESS_TMO(ctx->sp, x);                     \
1398 14
        return (VRT_TMO(res));                          \
1399 14
}                                                       \
1400
                                                        \
1401
VCL_VOID                                                \
1402 4
VRT_u_sess_##x(VRT_CTX)                                 \
1403 4
{                                                       \
1404 4
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);          \
1405 4
        CHECK_OBJ_NOTNULL(ctx->sp, SESS_MAGIC);         \
1406 4
        ctx->sp->x = NAN;                               \
1407 4
}
1408
1409 5
SESS_VAR_DUR(timeout_idle, )
1410 4
SESS_VAR_DUR(timeout_linger, )
1411 4
SESS_VAR_DUR(send_timeout, )
1412 5
SESS_VAR_DUR(idle_send_timeout, set_idle_send_timeout(ctx->sp, d))
1413
1414
/*--------------------------------------------------------------------*/
1415
1416
#define PARAM_VAR(x, type)                              \
1417
VCL_##type                                              \
1418 45
VRT_r_param_##x(VRT_CTX)                                \
1419 45
{                                                       \
1420 45
                                                        \
1421 45
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);          \
1422 45
        return (cache_param->x);                        \
1423 45
}                                                       \
1424
1425
PARAM_VAR(backend_idle_timeout, DURATION)
1426
PARAM_VAR(backend_wait_limit, INT)
1427
PARAM_VAR(backend_wait_timeout, DURATION)
1428
PARAM_VAR(between_bytes_timeout, DURATION)
1429
PARAM_VAR(connect_timeout, DURATION)
1430
PARAM_VAR(default_grace, DURATION)
1431
PARAM_VAR(default_keep, DURATION)
1432
PARAM_VAR(default_ttl, DURATION)
1433
PARAM_VAR(first_byte_timeout, DURATION)
1434
PARAM_VAR(idle_send_timeout, DURATION)
1435
PARAM_VAR(max_esi_depth, INT)
1436
PARAM_VAR(max_restarts, INT)
1437
PARAM_VAR(max_retries, INT)
1438
PARAM_VAR(pipe_task_deadline, DURATION)
1439
PARAM_VAR(pipe_timeout, DURATION)
1440
PARAM_VAR(send_timeout, DURATION)
1441
PARAM_VAR(shortlived, DURATION)
1442
PARAM_VAR(timeout_idle, DURATION)
1443
PARAM_VAR(transit_buffer, BYTES)
1444
PARAM_VAR(uncacheable_ttl, DURATION)