varnish-cache/vmod/vmod_debug.c
0
/*-
1
 * Copyright (c) 2012-2019 Varnish Software AS
2
 * All rights reserved.
3
 *
4
 * Author: Poul-Henning Kamp <phk@FreeBSD.org>
5
 *
6
 * SPDX-License-Identifier: BSD-2-Clause
7
 *
8
 * Redistribution and use in source and binary forms, with or without
9
 * modification, are permitted provided that the following conditions
10
 * are met:
11
 * 1. Redistributions of source code must retain the above copyright
12
 *    notice, this list of conditions and the following disclaimer.
13
 * 2. Redistributions in binary form must reproduce the above copyright
14
 *    notice, this list of conditions and the following disclaimer in the
15
 *    documentation and/or other materials provided with the distribution.
16
 *
17
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
18
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20
 * ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
21
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27
 * SUCH DAMAGE.
28
 */
29
30
#include "config.h"
31
32
#include <stdlib.h>
33
#include <stdio.h>
34
#include <string.h>
35
#include <sys/socket.h>
36
#include <unistd.h>
37
38
#include "cache/cache_varnishd.h"
39
#include "cache/cache_filter.h"
40
41
#include "vsa.h"
42
#include "vss.h"
43
#include "vtcp.h"
44
#include "vtim.h"
45
#include "vcc_debug_if.h"
46
#include "VSC_debug.h"
47
48
#include "vmod_debug.h"
49
50
struct priv_vcl {
51
        unsigned                magic;
52
#define PRIV_VCL_MAGIC          0x8E62FA9D
53
        char                    *foo;
54
        uintptr_t               obj_cb;
55
        struct vclref           *vclref_discard;
56
        struct vclref           *vclref_cold;
57
        VCL_DURATION            vcl_discard_delay;
58
        VCL_BACKEND             be;
59
        unsigned                cold_be;
60
        unsigned                cooling_be;
61
        int                     tmpf;
62
};
63
64
65
static pthread_mutex_t vsc_mtx = PTHREAD_MUTEX_INITIALIZER;
66
static struct vsc_seg *vsc_seg = NULL;
67
static struct VSC_debug *vsc = NULL;
68
static int loads;
69
static const int store_ip_token = 0;
70
static const int fail_task_fini_token = 0;
71
extern void mylog(struct vsl_log *vsl, enum VSL_tag_e tag,
72
    const char *fmt, ...) v_printflike_(3,4);
73
74
/**********************************************************************/
75
76
VCL_STRING v_matchproto_(td_debug_author)
77 135
xyzzy_author(VRT_CTX, VCL_ENUM person, VCL_ENUM someone)
78
{
79 135
        (void)someone;
80
81 135
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
82 135
        if (person == VENUM(phk))
83 54
                return ("Poul-Henning");
84 81
        assert(strcmp(person, "phk"));
85 81
        if (person == VENUM(des))
86 27
                return ("Dag-Erling");
87 54
        assert(strcmp(person, "des"));
88 54
        if (person == VENUM(kristian))
89 27
                return ("Kristian");
90 27
        assert(strcmp(person, "kristian"));
91 27
        if (person == VENUM(mithrandir))
92 27
                return ("Tollef");
93 0
        assert(strcmp(person, "mithrandir"));
94 0
        WRONG("Illegal VMOD enum");
95 135
}
96
97
#define AN0(x) (void) 0
98
#define AN1(x) AN(x)
99
#define PRIV_FINI(name, assert)                                         \
100
static void v_matchproto_(vmod_priv_fini_f)                             \
101
priv_ ## name ## _fini(VRT_CTX, void *ptr)                              \
102
{                                                                       \
103
        const char * const fmt = "priv_" #name "_fini(%p)";             \
104
                                                                        \
105
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);                          \
106
        AN ## assert (ptr);                                             \
107
        mylog(ctx->vsl, SLT_Debug, fmt, (char *)ptr);                   \
108
        free(ptr);                                                      \
109
}                                                                       \
110
                                                                        \
111
static const struct vmod_priv_methods                                   \
112
xyzzy_test_priv_ ## name ## _methods[1] = {{                            \
113
        .magic = VMOD_PRIV_METHODS_MAGIC,                               \
114
        .type = "debug_test_priv_" #name,                               \
115
        .fini = priv_ ## name ## _fini                                  \
116
}};
117 54
PRIV_FINI(call, 0)
118 405
PRIV_FINI(task, 1)
119 81
PRIV_FINI(top, 1)
120
#undef PRIV_FINI
121
#undef AN0
122
#undef AN1
123
124
VCL_VOID v_matchproto_(td_debug_test_priv_call)
125 54
xyzzy_test_priv_call(VRT_CTX, struct vmod_priv *priv)
126
{
127
128 54
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
129 54
        if (priv->priv == NULL) {
130 54
                priv->priv = strdup("BAR");
131 54
                priv->methods = xyzzy_test_priv_call_methods;
132 54
        } else {
133 0
                assert(priv->methods == xyzzy_test_priv_call_methods);
134 0
                assert(!strcmp(priv->priv, "BAR"));
135
        }
136 54
}
137
138
VCL_VOID v_matchproto_(td_debug_test_priv_task_get)
139 27
xyzzy_test_priv_task_get(VRT_CTX)
140
{
141
142 27
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
143 27
        AZ(VRT_priv_task_get(ctx, NULL));
144 27
}
145
146
VCL_STRING v_matchproto_(td_debug_test_priv_task)
147 1242
xyzzy_test_priv_task(VRT_CTX, struct vmod_priv *priv, VCL_STRING s)
148
{
149
150 1242
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
151 1242
        if (s == NULL || *s == '\0') {
152 1134
                mylog(ctx->vsl, SLT_Debug, "test_priv_task(%p) = %p (exists)",
153 567
                    priv, priv->priv);
154 1242
        } else if (priv->priv == NULL) {
155 405
                priv->priv = strdup(s);
156 405
                priv->methods = xyzzy_test_priv_task_methods;
157 810
                mylog(ctx->vsl, SLT_Debug, "test_priv_task(%p) = %p (new)",
158 405
                    priv, priv->priv);
159 405
        } else {
160 540
                char *n = realloc(priv->priv,
161 270
                    strlen(priv->priv) + strlen(s) + 2);
162 270
                if (n == NULL)
163 0
                        return (NULL);
164 270
                strcat(n, " ");
165 270
                strcat(n, s);
166 270
                priv->priv = n;
167 540
                mylog(ctx->vsl, SLT_Debug, "test_priv_task(%p) = %p (update)",
168 270
                    priv, priv->priv);
169
        }
170 1242
        if (priv->priv != NULL)
171 1215
                assert(priv->methods == xyzzy_test_priv_task_methods);
172 1242
        return (priv->priv);
173 1242
}
174
175
VCL_STRING v_matchproto_(td_debug_test_priv_top)
176 648
xyzzy_test_priv_top(VRT_CTX, struct vmod_priv *priv, VCL_STRING s)
177
{
178
179 648
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
180 648
        if (priv->priv == NULL) {
181 81
                priv->priv = strdup(s);
182 81
                priv->methods = xyzzy_test_priv_top_methods;
183 81
        } else {
184 567
                assert(priv->methods == xyzzy_test_priv_top_methods);
185
        }
186 648
        return (priv->priv);
187
}
188
189
VCL_VOID v_matchproto_(td_debug_test_priv_vcl)
190 54
xyzzy_test_priv_vcl(VRT_CTX, struct vmod_priv *priv)
191
{
192
        struct priv_vcl *priv_vcl;
193
        char t[PATH_MAX];
194
        ssize_t l;
195
196 54
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
197 54
        AN(priv);
198 54
        CAST_OBJ_NOTNULL(priv_vcl, priv->priv, PRIV_VCL_MAGIC);
199
200 54
        l = pread(priv_vcl->tmpf, t, sizeof t, 0);
201 54
        assert(l > 0);
202
203 54
        AN(priv_vcl->foo);
204 54
        assert(!strncmp(priv_vcl->foo, t, l));
205 54
}
206
207
VCL_VOID v_matchproto_(td_debug_rot52)
208 54
xyzzy_rot52(VRT_CTX, VCL_HTTP hp)
209
{
210
211 54
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
212 54
        CHECK_OBJ_NOTNULL(hp, HTTP_MAGIC);
213
214 54
        http_PrintfHeader(hp, "Encrypted: ROT52");
215 54
}
216
217
VCL_STRING v_matchproto_(td_debug_argtest)
218 189
xyzzy_argtest(VRT_CTX, struct VARGS(argtest) *arg)
219
{
220
        char buf[100];
221
222 189
        AN(arg);
223 189
        bprintf(buf, "%s %g %s %s %jd %d %s",
224
            arg->one, arg->two, arg->three, arg->comma, (intmax_t)arg->four,
225
            arg->valid_opt, arg->valid_opt ? arg->opt : "<undef>");
226 189
        return (WS_Copy(ctx->ws, buf, -1));
227
}
228
229
VCL_INT v_matchproto_(td_debug_vre_limit)
230 54
xyzzy_vre_limit(VRT_CTX)
231
{
232 54
        (void)ctx;
233 54
        return (cache_param->vre_limits.match);
234
}
235
236
static void v_matchproto_(obj_event_f)
237 54
obj_cb(struct worker *wrk, void *priv, struct objcore *oc, unsigned event)
238
{
239
        const struct priv_vcl *priv_vcl;
240
        const char *what;
241
242 54
        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
243 54
        CHECK_OBJ_NOTNULL(oc, OBJCORE_MAGIC);
244 54
        CAST_OBJ_NOTNULL(priv_vcl, priv, PRIV_VCL_MAGIC);
245 54
        switch (event) {
246 27
        case OEV_INSERT: what = "insert"; break;
247 27
        case OEV_EXPIRE: what = "expire"; break;
248 0
        default: WRONG("Wrong object event");
249 0
        }
250
251
        /* We cannot trust %p to be 0x... format as expected by m00021.vtc */
252 108
        VSL(SLT_Debug, NO_VXID, "Object Event: %s 0x%jx", what,
253 54
            (intmax_t)(uintptr_t)oc);
254 54
}
255
256
VCL_VOID v_matchproto_(td_debug_register_obj_events)
257 27
xyzzy_register_obj_events(VRT_CTX, struct vmod_priv *priv)
258
{
259
        struct priv_vcl *priv_vcl;
260
261 27
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
262 27
        CAST_OBJ_NOTNULL(priv_vcl, priv->priv, PRIV_VCL_MAGIC);
263 27
        AZ(priv_vcl->obj_cb);
264 27
        priv_vcl->obj_cb = ObjSubscribeEvents(obj_cb, priv_vcl,
265
                OEV_INSERT|OEV_EXPIRE);
266 27
        VSL(SLT_Debug, NO_VXID, "Subscribed to Object Events");
267 27
}
268
269
VCL_VOID v_matchproto_(td_debug_fail)
270 432
xyzzy_fail(VRT_CTX)
271
{
272
273 432
        VRT_fail(ctx, "Forced failure");
274 432
}
275
276
VCL_BOOL v_matchproto_(td_debug_fail2)
277 27
xyzzy_fail2(VRT_CTX)
278
{
279
280 27
        VRT_fail(ctx, "Forced failure");
281 27
        return (1);
282
}
283
284
static void v_matchproto_(vmod_priv_fini_f)
285 621
priv_vcl_fini(VRT_CTX, void *priv)
286
{
287
        struct priv_vcl *priv_vcl;
288
289 621
        CAST_OBJ_NOTNULL(priv_vcl, priv, PRIV_VCL_MAGIC);
290 621
        AZ(close(priv_vcl->tmpf));
291 621
        AN(priv_vcl->foo);
292 621
        AZ(unlink(priv_vcl->foo));
293 621
        free(priv_vcl->foo);
294 621
        if (priv_vcl->obj_cb != 0) {
295 27
                ObjUnsubscribeEvents(&priv_vcl->obj_cb);
296 27
                VSLb(ctx->vsl, SLT_Debug, "Unsubscribed from Object Events");
297 27
        }
298 621
        AZ(priv_vcl->vclref_discard);
299 621
        AZ(priv_vcl->vclref_cold);
300 621
        FREE_OBJ(priv_vcl);
301 621
}
302
303
static const struct vmod_priv_methods priv_vcl_methods[1] = {{
304
        .magic = VMOD_PRIV_METHODS_MAGIC,
305
        .type = "debug_priv_vcl_fini",
306
        .fini = priv_vcl_fini
307
}};
308
309
static int
310 2673
event_load(VRT_CTX, struct vmod_priv *priv)
311
{
312
        struct priv_vcl *priv_vcl;
313
314 2673
        AN(ctx->msg);
315
316 2673
        loads++;
317
318 2673
        if (cache_param->nuke_limit == 42) {
319 27
                VSB_cat(ctx->msg, "nuke_limit is not the answer.");
320 27
                return (-1);
321
        }
322
323 2646
        ALLOC_OBJ(priv_vcl, PRIV_VCL_MAGIC);
324 2646
        AN(priv_vcl);
325 2646
        priv_vcl->foo = strdup("worker_tmpdir/vmod_debug.XXXXXX");
326 2646
        AN(priv_vcl->foo);
327 2646
        priv_vcl->tmpf = mkstemp(priv_vcl->foo);
328 2646
        assert(priv_vcl->tmpf >= 0);
329 2646
        AN(write(priv_vcl->tmpf, priv_vcl->foo, strlen(priv_vcl->foo)));
330 2646
        priv->priv = priv_vcl;
331 2646
        priv->methods = priv_vcl_methods;
332
333 2646
        debug_add_filters(ctx);
334 2646
        debug_transport_init();
335 2646
        return (0);
336 2673
}
337
338
VCL_VOID
339 27
xyzzy_vcl_prevent_cold(VRT_CTX, struct vmod_priv *priv)
340
{
341
        struct priv_vcl *priv_vcl;
342
        char buf[32];
343
344 27
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
345 27
        AN(priv);
346 27
        CAST_OBJ_NOTNULL(priv_vcl, priv->priv, PRIV_VCL_MAGIC);
347 27
        AZ(priv_vcl->vclref_cold);
348
349 27
        bprintf(buf, "vmod-debug ref on %s", VCL_Name(ctx->vcl));
350 27
        priv_vcl->vclref_cold = VRT_VCL_Prevent_Cold(ctx, buf);
351 27
}
352
353
VCL_VOID
354 27
xyzzy_vcl_allow_cold(VRT_CTX, struct vmod_priv *priv)
355
{
356
        struct priv_vcl *priv_vcl;
357
358 27
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
359 27
        AN(priv);
360 27
        CAST_OBJ_NOTNULL(priv_vcl, priv->priv, PRIV_VCL_MAGIC);
361 27
        AN(priv_vcl->vclref_cold);
362 27
        VRT_VCL_Allow_Cold(&priv_vcl->vclref_cold);
363 27
}
364
365
VCL_VOID
366 0
xyzzy_cold_backend(VRT_CTX, struct vmod_priv *priv)
367
{
368
        struct priv_vcl *priv_vcl;
369
370 0
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
371 0
        AN(priv);
372 0
        CAST_OBJ_NOTNULL(priv_vcl, priv->priv, PRIV_VCL_MAGIC);
373 0
        priv_vcl->cold_be = 1;
374 0
}
375
376
VCL_VOID
377 0
xyzzy_cooling_backend(VRT_CTX, struct vmod_priv *priv)
378
{
379
        struct priv_vcl *priv_vcl;
380
381 0
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
382 0
        AN(priv);
383 0
        CAST_OBJ_NOTNULL(priv_vcl, priv->priv, PRIV_VCL_MAGIC);
384 0
        priv_vcl->cooling_be = 1;
385 0
}
386
387
static const struct vdi_methods empty_methods[1] = {{
388
        .magic =        VDI_METHODS_MAGIC,
389
        .type = "debug.dummy"
390
}};
391
392
static int
393 2403
event_warm(VRT_CTX, const struct vmod_priv *priv)
394
{
395
        struct priv_vcl *priv_vcl;
396
        char buf[32];
397 2403
        const char *vcl_name = VCL_Name(ctx->vcl);
398
399
        // Using VSLs for coverage
400 2403
        VSLs(SLT_Debug, NO_VXID, TOSTRANDS(2, vcl_name, ": VCL_EVENT_WARM"));
401
402 2403
        AN(ctx->msg);
403 2403
        if (cache_param->max_esi_depth == 42) {
404 81
                VSB_cat(ctx->msg, "max_esi_depth is not the answer.");
405 81
                return (-1);
406
        }
407
408 2322
        CAST_OBJ_NOTNULL(priv_vcl, priv->priv, PRIV_VCL_MAGIC);
409 2322
        AZ(priv_vcl->vclref_discard);
410
411 2322
        if (!priv_vcl->cold_be) {
412
                /* NB: set up a COOLING step unless we want a COLD backend. */
413 2322
                bprintf(buf, "vmod-debug ref on %s", VCL_Name(ctx->vcl));
414 2322
                priv_vcl->vclref_discard = VRT_VCL_Prevent_Discard(ctx, buf);
415 2322
        }
416
417 2322
        AZ(priv_vcl->be);
418 2322
        priv_vcl->be = VRT_AddDirector(ctx, empty_methods,
419
            NULL, "%s", "dir_warmcold");
420
421 2322
        return (0);
422 2403
}
423
424
static void*
425 27
cooldown_thread(void *priv)
426
{
427
        struct priv_vcl *priv_vcl;
428
429 27
        CAST_OBJ_NOTNULL(priv_vcl, priv, PRIV_VCL_MAGIC);
430 27
        AN(priv_vcl->vclref_discard);
431
432 27
        VTIM_sleep(priv_vcl->vcl_discard_delay);
433 27
        VRT_VCL_Allow_Discard(&priv_vcl->vclref_discard);
434 27
        return (NULL);
435
}
436
437
static VCL_BACKEND
438 0
create_cold_backend(VRT_CTX)
439
{
440
        struct vrt_endpoint vep[1];
441
        struct vrt_backend be[1];
442
443 0
        INIT_OBJ(vep, VRT_ENDPOINT_MAGIC);
444 0
        vep->uds_path = "/";
445 0
        INIT_OBJ(be, VRT_BACKEND_MAGIC);
446 0
        be->endpoint = vep;
447 0
        be->vcl_name = "doomed";
448 0
        return (VRT_new_backend(ctx, be, NULL));
449
}
450
451
static int
452 375
event_cold(VRT_CTX, const struct vmod_priv *priv)
453
{
454
        pthread_t thread;
455
        struct priv_vcl *priv_vcl;
456
457 375
        AZ(ctx->msg);
458
459 375
        CAST_OBJ_NOTNULL(priv_vcl, priv->priv, PRIV_VCL_MAGIC);
460
461 375
        VSL(SLT_Debug, NO_VXID, "%s: VCL_EVENT_COLD", VCL_Name(ctx->vcl));
462
463 375
        VRT_DelDirector(&priv_vcl->be);
464
465 375
        if (priv_vcl->cold_be) {
466 0
                AZ(priv_vcl->vclref_discard);
467 0
                priv_vcl->be = create_cold_backend(ctx);
468 0
                WRONG("unreachable");
469 0
        }
470
471 375
        if (priv_vcl->cooling_be) {
472 0
                AN(priv_vcl->vclref_discard);
473 0
                priv_vcl->be = create_cold_backend(ctx);
474 0
                AZ(priv_vcl->be);
475 0
        }
476
477 375
        if (priv_vcl->vcl_discard_delay == 0.0) {
478 348
                AN(priv_vcl->vclref_discard);
479 348
                VRT_VCL_Allow_Discard(&priv_vcl->vclref_discard);
480 348
                return (0);
481
        }
482
483 27
        PTOK(pthread_create(&thread, NULL, cooldown_thread, priv_vcl));
484 27
        PTOK(pthread_detach(thread));
485 27
        return (0);
486 375
}
487
488
static int
489 621
event_discard(VRT_CTX, void *priv)
490
{
491
492 621
        (void)priv;
493
494 621
        AZ(ctx->msg);
495
496 621
        debug_remove_filters(ctx);
497
498 621
        if (--loads)
499 405
                return (0);
500
501
        /*
502
         * The vsc and vsc_seg variables are not per-VCL, they are
503
         * the same in all VCL's which import the same binary version
504
         * of this VMOD, so we should only carry out cleanup on the
505
         * last discard event.
506
         */
507 216
        PTOK(pthread_mutex_lock(&vsc_mtx));
508 216
        if (vsc != NULL) {
509 27
                VSC_debug_Destroy(&vsc_seg);
510 27
                vsc = NULL;
511 27
        }
512 216
        PTOK(pthread_mutex_unlock(&vsc_mtx));
513
514 216
        return (0);
515 621
}
516
517
int v_matchproto_(vmod_event_f)
518 6072
xyzzy_event_function(VRT_CTX, struct vmod_priv *priv, enum vcl_event_e e)
519
{
520
521 6072
        switch (e) {
522 2673
        case VCL_EVENT_LOAD:    return (event_load(ctx, priv));
523 2403
        case VCL_EVENT_WARM:    return (event_warm(ctx, priv));
524 375
        case VCL_EVENT_COLD:    return (event_cold(ctx, priv));
525 621
        case VCL_EVENT_DISCARD: return (event_discard(ctx, priv));
526 0
        default: WRONG("we should test all possible events");
527 0
        }
528 6072
}
529
530
VCL_VOID v_matchproto_(td_debug_vcl_discard_delay)
531 27
xyzzy_vcl_discard_delay(VRT_CTX, struct vmod_priv *priv, VCL_DURATION delay)
532
{
533
        struct priv_vcl *priv_vcl;
534
535 27
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
536 27
        CAST_OBJ_NOTNULL(priv_vcl, priv->priv, PRIV_VCL_MAGIC);
537 27
        assert(delay > 0.0);
538 27
        priv_vcl->vcl_discard_delay = delay;
539 27
}
540
541
VCL_VOID v_matchproto_(td_debug_test_probe)
542 0
xyzzy_test_probe(VRT_CTX, VCL_PROBE probe, VCL_PROBE same)
543
{
544
545 0
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
546 0
        CHECK_OBJ_NOTNULL(probe, VRT_BACKEND_PROBE_MAGIC);
547 0
        CHECK_OBJ_ORNULL(same, VRT_BACKEND_PROBE_MAGIC);
548 0
        AZ(same == NULL || probe == same);
549 0
}
550
551
VCL_VOID
552 27
xyzzy_vsc_new(VRT_CTX)
553
{
554 27
        (void)ctx;
555 27
        PTOK(pthread_mutex_lock(&vsc_mtx));
556 27
        if (vsc == NULL) {
557 27
                AZ(vsc_seg);
558 27
                vsc = VSC_debug_New(NULL, &vsc_seg, "");
559 27
        }
560 27
        AN(vsc);
561 27
        AN(vsc_seg);
562 27
        PTOK(pthread_mutex_unlock(&vsc_mtx));
563 27
}
564
565
VCL_VOID
566 27
xyzzy_vsc_count(VRT_CTX, VCL_INT cnt)
567
{
568 27
        (void)ctx;
569 27
        PTOK(pthread_mutex_lock(&vsc_mtx));
570 27
        AN(vsc);
571 27
        vsc->count += cnt;
572 27
        PTOK(pthread_mutex_unlock(&vsc_mtx));
573 27
}
574
575
VCL_VOID
576 0
xyzzy_vsc_destroy(VRT_CTX)
577
{
578 0
        (void)ctx;
579 0
        PTOK(pthread_mutex_lock(&vsc_mtx));
580 0
        if (vsc != NULL) {
581 0
                AN(vsc_seg);
582 0
                VSC_debug_Destroy(&vsc_seg);
583 0
        }
584 0
        AZ(vsc_seg);
585 0
        vsc = NULL;
586 0
        PTOK(pthread_mutex_unlock(&vsc_mtx));
587 0
}
588
589
struct xyzzy_debug_concat {
590
        unsigned        magic;
591
#define CONCAT_MAGIC 0x6b746493
592
        VCL_STRING      s;
593
};
594
595
VCL_VOID
596 108
xyzzy_concat__init(VRT_CTX, struct xyzzy_debug_concat **concatp,
597
                   const char *vcl_name, VCL_STRANDS s)
598
{
599
        struct xyzzy_debug_concat *concat;
600 108
        size_t sz = 0;
601
        char *p;
602
603 108
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
604 108
        AN(concatp);
605 108
        AZ(*concatp);
606 108
        AN(vcl_name);
607
608 108
        ALLOC_OBJ(concat, CONCAT_MAGIC);
609 108
        AN(concat);
610 108
        *concatp = concat;
611
612 324
        for (int i = 0; i < s->n; i++)
613 432
                if (s->p[i] != NULL)
614 216
                        sz += strlen(s->p[i]);
615 108
        p = malloc(sz + 1);
616 108
        AN(p);
617 108
        (void)VRT_Strands(p, sz + 1, s);
618 108
        concat->s = p;
619 108
}
620
621
VCL_VOID
622 0
xyzzy_concat__fini(struct xyzzy_debug_concat **concatp)
623
{
624
        struct xyzzy_debug_concat *concat;
625
626
627 0
        TAKE_OBJ_NOTNULL(concat, concatp, CONCAT_MAGIC);
628 0
        free(TRUST_ME(concat->s));
629 0
        FREE_OBJ(concat);
630 0
}
631
632
VCL_STRING
633 54
xyzzy_concat_get(VRT_CTX, struct xyzzy_debug_concat *concat)
634
{
635 54
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
636 54
        CHECK_OBJ_NOTNULL(concat, CONCAT_MAGIC);
637 54
        return (concat->s);
638
}
639
640
VCL_STRING
641 216
xyzzy_concatenate(VRT_CTX, VCL_STRANDS s)
642
{
643
        VCL_STRING r;
644
645 216
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
646 216
        r = VRT_StrandsWS(ctx->ws, NULL, s);
647 216
        if (r != NULL && *r != '\0')
648 162
                AN(WS_Allocated(ctx->ws, r, strlen(r) + 1));
649 216
        return (r);
650
}
651
652
VCL_STRING
653 216
xyzzy_collect(VRT_CTX, VCL_STRANDS s)
654
{
655
        VCL_STRING r;
656
657 216
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
658 216
        r = VRT_STRANDS_string(ctx, s);
659 216
        if (r != NULL && *r != '\0')
660 162
                AN(WS_Allocated(ctx->ws, r, strlen(r) + 1));
661 216
        return (r);
662
}
663
664
/* cf. VRT_SetHdr() */
665
VCL_VOID
666 216
xyzzy_sethdr(VRT_CTX, VCL_HEADER hdr, VCL_STRANDS s)
667
{
668
        struct http *hp;
669
        const char *b;
670
671 216
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
672 216
        if (hdr == NULL) {
673 0
                VRT_fail(ctx, "debug.sethdr(): header argument is NULL");
674 0
                return;
675
        }
676 216
        hp = VRT_selecthttp(ctx, hdr->where);
677 216
        if (hp == NULL) {
678 0
                VRT_fail(ctx, "debug.sethdr(): header argument "
679
                    "cannot be used here");
680 0
                return;
681
        }
682 216
        AN(hdr->what);
683 216
        CHECK_OBJ_NOTNULL(hp, HTTP_MAGIC);
684 216
        if (s->n == 0) {
685 0
                http_Unset(hp, hdr->what);
686 0
        } else {
687 216
                b = VRT_StrandsWS(hp->ws, hdr->what + 1, s);
688 216
                if (b == NULL) {
689 0
                        VSLbs(ctx->vsl, SLT_LostHeader,
690 0
                            TOSTRAND(hdr->what + 1));
691 0
                } else {
692 216
                        if (*b != '\0')
693 216
                                AN(WS_Allocated(hp->ws, b, strlen(b) + 1));
694 216
                        http_Unset(hp, hdr->what);
695 216
                        http_SetHeader(hp, b);
696
                }
697
        }
698 216
}
699
700
void
701 3726
mylog(struct vsl_log *vsl, enum VSL_tag_e tag,  const char *fmt, ...)
702
{
703
        va_list ap;
704
705 3726
        va_start(ap, fmt);
706 3726
        if (vsl != NULL)
707 3213
                VSLbv(vsl, tag, fmt, ap);
708
        else
709 513
                VSLv(tag, NO_VXID, fmt, ap);
710 3726
        va_end(ap);
711 3726
}
712
713
VCL_DURATION
714 108
xyzzy_priv_perf(VRT_CTX, VCL_INT size, VCL_INT rounds)
715
{
716
        vtim_mono t0, t1;
717
        vtim_dur d;
718
        struct vmod_priv *p;
719
        VCL_INT s, r;
720 108
        uintptr_t check = 0;
721
722 108
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
723
724 30105
        for (s = 1; s <= size; s++) {
725 29997
                p = VRT_priv_task(ctx, (void *)(uintptr_t)s);
726 29997
                if (p == NULL) {
727 0
                        VRT_fail(ctx, "no priv task - out of ws?");
728 0
                        return (-1.0);
729
                }
730 29997
                p->priv = NULL;
731 29997
        }
732
733 108
        t0 = VTIM_mono();
734 1080108
        for (r = 0; r < rounds; r++) {
735 301050000
                for (s = 1; s <= size; s++) {
736 299970000
                        p = VRT_priv_task_get(ctx, (void *)(uintptr_t)s);
737 299970000
                        AN(p);
738 299970000
                        check += (uintptr_t)p->priv;
739 299970000
                        p->priv = (void *)(uintptr_t)(s * rounds + r);
740 299970000
                }
741 1080000
        }
742 108
        t1 = VTIM_mono();
743
744 108
        d = (t1 - t0) * 1e9 / ((double)size * (double)rounds);
745
746 216
        mylog(ctx->vsl, SLT_Debug,
747
             "perf size %jd rounds %jd time %.1fns check %jd",
748 108
             (intmax_t)size, (intmax_t)rounds, d, (uintmax_t)check);
749
750 108
        return (d);
751 108
}
752
753
VCL_STRANDS
754 243
xyzzy_return_strands(VRT_CTX, VCL_STRANDS strand)
755
{
756
757 243
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
758 243
        if (ctx->vsl)
759 108
                VSLbs(ctx->vsl, SLT_Debug, strand);
760
        else
761 135
                VSLs(SLT_Debug, NO_VXID, strand);
762 243
        return (strand);
763
}
764
765
VCL_STRANDS
766 27
xyzzy_return_null_strands(VRT_CTX)
767
{
768 27
        (void)ctx;
769 27
        return (vrt_null_strands);
770
}
771
772
VCL_BOOL
773 27
xyzzy_is_null_strands(VRT_CTX, VCL_STRANDS s)
774
{
775 27
        (void)ctx;
776 27
        return (s == vrt_null_strands);
777
}
778
779
VCL_VOID
780 54
xyzzy_vsl_flush(VRT_CTX)
781
{
782 54
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
783 54
        VSL_Flush(ctx->vsl, 0);
784 54
}
785
786
/*---------------------------------------------------------------------*/
787
788
static const struct vcf_return * v_matchproto_(vcf_func_f)
789 378
xyzzy_catflap_simple(struct req *req, struct objcore **oc,
790
    struct objcore **oc_exp, int state)
791
{
792
793 378
        CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
794 378
        CHECK_OBJ_NOTNULL(req->vcf, VCF_MAGIC);
795 378
        assert(req->vcf->func == xyzzy_catflap_simple);
796
797 378
        (void)oc;
798 378
        (void)oc_exp;
799 378
        if (state == 0) {
800 108
                if (req->vcf->priv == VENUM(first))
801 27
                        return (VCF_HIT);
802 81
                if (req->vcf->priv == VENUM(miss))
803 81
                        return (VCF_MISS);
804 0
                WRONG("Shouldn't get here");
805 0
        }
806 270
        return (VCF_DEFAULT);
807 378
}
808
809
static const struct vcf_return * v_matchproto_(vcf_func_f)
810 162
xyzzy_catflap_last(struct req *req, struct objcore **oc,
811
    struct objcore **oc_exp, int state)
812
{
813
814 162
        CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
815 162
        CHECK_OBJ_NOTNULL(req->vcf, VCF_MAGIC);
816 162
        assert(req->vcf->func == xyzzy_catflap_last);
817
818 162
        (void)oc_exp;
819 162
        if (state == 0) {
820 108
                AN(oc);
821 108
                CHECK_OBJ_NOTNULL(*oc, OBJCORE_MAGIC);
822 108
                req->vcf->priv = *oc;
823 108
                return (VCF_CONTINUE);
824
        }
825 54
        if (state == 1) {
826 27
                AN(oc);
827 27
                if (req->vcf->priv != NULL)
828 27
                        CAST_OBJ_NOTNULL(*oc, req->vcf->priv, OBJCORE_MAGIC);
829 27
                return (VCF_CONTINUE);
830
        }
831 27
        return (VCF_DEFAULT);
832 162
}
833
834
VCL_VOID
835 216
xyzzy_catflap(VRT_CTX, VCL_ENUM type)
836
{
837
        struct req *req;
838
839 216
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
840 216
        req = ctx->req;
841 216
        CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
842 216
        XXXAZ(req->vcf);
843 432
        WS_TASK_ALLOC_OBJ(ctx, req->vcf, VCF_MAGIC);
844 216
        if (req->vcf == NULL)
845 0
                return;
846 216
        if (type == VENUM(first) || type == VENUM(miss)) {
847 189
                req->vcf->func = xyzzy_catflap_simple;
848 189
                req->vcf->priv = TRUST_ME(type);
849 216
        } else if (type == VENUM(last)) {
850 27
                req->vcf->func = xyzzy_catflap_last;
851 27
        } else {
852 0
                WRONG("Wrong VENUM");
853
        }
854 216
}
855
856
VCL_BYTES
857 0
xyzzy_stk(VRT_CTX)
858
{
859 0
        const VCL_BYTES max = 100 * 1024 * 1024;
860
        const char *a, *b;
861
        VCL_BYTES r;
862
863 0
        a = TRUST_ME(&b);
864 0
        b = TRUST_ME(ctx->req->wrk);
865 0
        b += sizeof(*ctx->req->wrk);
866
867 0
        if (b > a && (r = b - a) < max)
868 0
                return (r);
869 0
        if (a > b && (r = a - b) < max)
870 0
                return (r);
871
872 0
        return (0);
873 0
}
874
875
VCL_VOID
876 216
xyzzy_sndbuf(VRT_CTX, VCL_BYTES arg)
877
{
878 216
        int fd = -1, oldbuf, newbuf, buflen;
879 216
        socklen_t intlen = sizeof(int);
880
881 216
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
882
883 216
        if (ctx->bo) {
884 0
                CHECK_OBJ(ctx->bo, BUSYOBJ_MAGIC);
885 0
                INCOMPL();
886 0
        }
887 216
        else if (ctx->req) {
888 216
                CHECK_OBJ(ctx->req, REQ_MAGIC);
889 216
                CHECK_OBJ(ctx->req->sp, SESS_MAGIC);
890 216
                fd = ctx->req->sp->fd;
891 216
        }
892
        else {
893 0
                VRT_fail(ctx, "debug.sndbuf() called outside a transaction.");
894 0
                return;
895
        }
896
897 216
        xxxassert(fd >= 0);
898
899 216
        if (arg > INT_MAX)
900 0
                buflen = INT_MAX;
901 216
        else if (arg <= 0)
902 0
                buflen = 0;
903
        else
904 216
                buflen = (int)arg;
905
906 216
        oldbuf = 0;
907 216
        AZ(getsockopt(fd, SOL_SOCKET, SO_SNDBUF, &oldbuf, &intlen));
908
909 216
        newbuf = buflen;
910 216
        AZ(setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &newbuf, intlen));
911 216
        AZ(getsockopt(fd, SOL_SOCKET, SO_SNDBUF, &newbuf, &intlen));
912
913 216
        AN(ctx->vsl);
914 432
        VSLb(ctx->vsl, SLT_Debug, "SO_SNDBUF fd=%d old=%d new=%d actual=%d",
915 216
            fd, oldbuf, buflen, newbuf);
916 216
}
917
918
VCL_VOID
919 378
xyzzy_store_ip(VRT_CTX, VCL_IP ip)
920
{
921
        struct vmod_priv *priv;
922
923 378
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
924
925 378
        priv = VRT_priv_task(ctx, &store_ip_token);
926 378
        if (priv == NULL) {
927 0
                VRT_fail(ctx, "no priv task - out of ws?");
928 0
                return;
929
        }
930
931 378
        AZ(priv->methods);
932 378
        assert(VSA_Sane(ip));
933 378
        priv->priv = TRUST_ME(ip);
934 378
}
935
936
VCL_IP
937 756
xyzzy_get_ip(VRT_CTX)
938
{
939
        struct vmod_priv *priv;
940
        VCL_IP ip;
941
942 756
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
943
944 756
        priv = VRT_priv_task_get(ctx, &store_ip_token);
945 756
        AN(priv);
946 756
        AZ(priv->methods);
947
948 756
        ip = priv->priv;
949 756
        assert(VSA_Sane(ip));
950 756
        return (ip);
951
}
952
953
/*---------------------------------------------------------------------*/
954
955
struct VPFX(debug_director) {
956
        unsigned                        magic;
957
#define VMOD_DEBUG_DIRECTOR_MAGIC       0x66b9ff3d
958
        VCL_BACKEND                     dir;
959
};
960
961
/* XXX more callbacks ? */
962
static vdi_healthy_f vmod_debug_director_healthy;
963
static vdi_resolve_f vmod_debug_director_resolve;
964
965
static const struct vdi_methods vmod_debug_director_methods[1] = {{
966
        .magic =        VDI_METHODS_MAGIC,
967
        .type =         "debug.director",
968
        .resolve =      vmod_debug_director_resolve,
969
        .healthy =      vmod_debug_director_healthy
970
}};
971
972
VCL_VOID v_matchproto_(td_xyzzy_debug_director__init)
973 27
xyzzy_director__init(VRT_CTX, struct VPFX(debug_director) **dp,
974
    const char *vcl_name)
975
{
976
        struct VPFX(debug_director) *d;
977
978 27
        AN(dp);
979 27
        AZ(*dp);
980 27
        ALLOC_OBJ(d, VMOD_DEBUG_DIRECTOR_MAGIC);
981 27
        AN(d);
982
983 27
        *dp = d;
984 54
        d->dir = VRT_AddDirector(ctx, vmod_debug_director_methods, d,
985 27
            "%s", vcl_name);
986 27
}
987
988
VCL_VOID v_matchproto_(td_xyzzy_debug_director__fini)
989 0
xyzzy_director__fini(struct VPFX(debug_director) **dp)
990
{
991
        struct VPFX(debug_director) *d;
992
993 0
        TAKE_OBJ_NOTNULL(d, dp, VMOD_DEBUG_DIRECTOR_MAGIC);
994 0
        VRT_DelDirector(&d->dir);
995 0
        FREE_OBJ(d);
996 0
}
997
998
VCL_BACKEND v_matchproto_(td_xyzzy_debug_director_fail)
999 54
xyzzy_director_fail(VRT_CTX, struct VPFX(debug_director) *d)
1000
{
1001 54
        CHECK_OBJ_NOTNULL(d, VMOD_DEBUG_DIRECTOR_MAGIC);
1002 54
        (void) ctx;
1003
1004 54
        return (d->dir);
1005
}
1006
1007
static VCL_BOOL v_matchproto_(vdi_healthy_f)
1008 54
vmod_debug_director_healthy(VRT_CTX, VCL_BACKEND dir, VCL_TIME *changed)
1009
{
1010 54
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
1011
1012 54
        (void) dir;
1013 54
        (void) changed;
1014
1015 54
        VRT_fail(ctx, "fail");
1016 54
        return (1);
1017
}
1018
1019
static VCL_BACKEND v_matchproto_(vdi_resolve_f)
1020 27
vmod_debug_director_resolve(VRT_CTX, VCL_BACKEND dir)
1021
{
1022 27
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
1023
1024 27
        (void) dir;
1025
1026 27
        VRT_fail(ctx, "fail");
1027 27
        return (NULL);
1028
}
1029
1030
VCL_STRING v_matchproto_(td_xyzzy_debug_client_ip)
1031 27
xyzzy_client_ip(VRT_CTX)
1032
{
1033 27
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
1034
1035 27
        return (SES_Get_String_Attr(ctx->sp, SA_CLIENT_IP));
1036
}
1037
1038
VCL_STRING v_matchproto_(td_xyzzy_debug_client_port)
1039 27
xyzzy_client_port(VRT_CTX)
1040
{
1041 27
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
1042
1043 27
        return (SES_Get_String_Attr(ctx->sp, SA_CLIENT_PORT));
1044
}
1045
1046
static void * fail_magic = &fail_magic;
1047
1048
static void
1049 81
fail_f(VRT_CTX, void *priv)
1050
{
1051
1052 81
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
1053 81
        assert(priv == fail_magic);
1054
1055 81
        VRT_fail(ctx, "thou shalt not fini");
1056 81
}
1057
1058
static const struct vmod_priv_methods xyzzy_fail_task_fini_methods[1] = {{
1059
        .magic = VMOD_PRIV_METHODS_MAGIC,
1060
        .type = "debug_fail_task_fini",
1061
        .fini = fail_f
1062
}};
1063
1064
VCL_VOID v_matchproto_(td_xyzzy_debug_fail_task_fini)
1065 108
xyzzy_fail_task_fini(VRT_CTX)
1066
{
1067
        struct vmod_priv *p;
1068
1069 108
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
1070
1071 108
        p = VRT_priv_task(ctx, &fail_task_fini_token);
1072 108
        if (p == NULL) {
1073 0
                VRT_fail(ctx, "no priv task - out of ws?");
1074 0
                return;
1075
        }
1076
1077 108
        if (p->priv != NULL) {
1078 0
                assert(p->priv == fail_magic);
1079 0
                assert(p->methods == xyzzy_fail_task_fini_methods);
1080 0
                return;
1081
        }
1082
1083 108
        p->priv = fail_magic;
1084 108
        p->methods = xyzzy_fail_task_fini_methods;
1085 108
}
1086
1087
VCL_VOID v_matchproto_(td_xyzzy_debug_ok_task_fini)
1088 27
xyzzy_ok_task_fini(VRT_CTX)
1089
{
1090
        struct vmod_priv *p;
1091
1092 27
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
1093
1094 27
        p = VRT_priv_task(ctx, &fail_task_fini_token);
1095 27
        if (p == NULL) {
1096 0
                VRT_fail(ctx, "no priv task - out of ws?");
1097 0
                return;
1098
        }
1099
1100 27
        p->priv = NULL;
1101 27
        p->methods = NULL;
1102 27
}
1103
1104
VCL_STRING v_matchproto_(td_xyzzy_debug_re_quote)
1105 162
xyzzy_re_quote(VRT_CTX, VCL_STRING s)
1106
{
1107
        struct vsb vsb[1];
1108
        char *q;
1109
1110 162
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
1111 162
        CHECK_OBJ_NOTNULL(ctx->ws, WS_MAGIC);
1112 162
        WS_VSB_new(vsb, ctx->ws);
1113 162
        VRE_quote(vsb, s);
1114 162
        q = WS_VSB_finish(vsb, ctx->ws, NULL);
1115 162
        if (q == NULL)
1116 0
                WS_MarkOverflow(ctx->ws);
1117 162
        return (q);
1118
}
1119
1120
VCL_STRING v_matchproto_(td_xyzzy_priv_task_with_option)
1121 81
xyzzy_priv_task_with_option(VRT_CTX, struct VARGS(priv_task_with_option) *args)
1122
{
1123
1124 81
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
1125 81
        AN(args->priv);
1126 81
        if (args->priv->priv == NULL && args->valid_opt)
1127 27
                args->priv->priv = WS_Copy(ctx->ws, args->opt, -1);
1128 81
        return (args->priv->priv);
1129
}
1130
1131
VCL_BOOL v_matchproto_(td_xyzzy_validhdr)
1132 54
xyzzy_validhdr(VRT_CTX, VCL_STRANDS s)
1133
{
1134 54
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
1135 54
        return (VRT_ValidHdr(ctx, s));
1136
}
1137
1138
VCL_REGEX v_matchproto_(td_xyzzy_regex)
1139 162
xyzzy_just_return_regex(VRT_CTX, VCL_REGEX r)
1140
{
1141
1142 162
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
1143 162
        AN(r);
1144 162
        return (r);
1145
}
1146
1147
/*---------------------------------------------------------------------*/
1148
1149
VCL_VOID v_matchproto_(td_xyzzy_call)
1150 324
xyzzy_call(VRT_CTX, VCL_SUB sub)
1151
{
1152 324
        VRT_call(ctx, sub);
1153 324
}
1154
1155
VCL_STRING v_matchproto_(td_xyzzy_check_call)
1156 27
xyzzy_check_call(VRT_CTX, VCL_SUB sub)
1157
{
1158 27
        return (VRT_check_call(ctx, sub));
1159
}
1160
1161
/* the next two are to test WRONG vmod behavior:
1162
 * holding a VCL_SUB reference across vcls
1163
 */
1164
1165
static VCL_SUB wrong = NULL;
1166
1167
VCL_VOID v_matchproto_(td_xyzzy_bad_memory)
1168 0
xyzzy_bad_memory(VRT_CTX, VCL_SUB sub)
1169
{
1170 0
        (void) ctx;
1171
1172 0
        wrong = sub;
1173 0
}
1174
1175
VCL_SUB v_matchproto_(td_xyzzy_total_recall)
1176 0
xyzzy_total_recall(VRT_CTX)
1177
{
1178 0
        (void) ctx;
1179
1180 0
        return (wrong);
1181
}
1182
1183
/*---------------------------------------------------------------------*/
1184
1185
struct VPFX(debug_caller) {
1186
       unsigned        magic;
1187
#define DEBUG_CALLER_MAGIC 0xb47f3449
1188
       VCL_SUB         sub;
1189
};
1190
1191
VCL_VOID v_matchproto_(td_xyzzy_debug_caller__init)
1192 54
xyzzy_caller__init(VRT_CTX, struct VPFX(debug_caller) **callerp,
1193
    const char *name, VCL_SUB sub)
1194
{
1195
        struct VPFX(debug_caller) *caller;
1196
1197 54
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
1198 54
        AN(callerp);
1199 54
        AZ(*callerp);
1200 54
        AN(name);
1201 54
        AN(sub);
1202
1203 54
        ALLOC_OBJ(caller, DEBUG_CALLER_MAGIC);
1204 54
        AN(caller);
1205 54
        *callerp = caller;
1206 54
        caller->sub = sub;
1207 54
}
1208
1209
VCL_VOID v_matchproto_(td_xyzzy_debug_caller__fini)
1210 0
xyzzy_caller__fini(struct VPFX(debug_caller) **callerp)
1211
{
1212
        struct VPFX(debug_caller) *caller;
1213
1214 0
        if (callerp == NULL || *callerp == NULL)
1215 0
                return;
1216 0
        TAKE_OBJ_NOTNULL(caller, callerp, DEBUG_CALLER_MAGIC);
1217 0
        FREE_OBJ(caller);
1218 0
}
1219
1220
VCL_VOID v_matchproto_(td_xyzzy_debug_caller_call)
1221 27
xyzzy_caller_call(VRT_CTX, struct VPFX(debug_caller) *caller)
1222
{
1223 27
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
1224 27
        CHECK_OBJ_NOTNULL(caller, DEBUG_CALLER_MAGIC);
1225 27
        AN(caller->sub);
1226
1227 27
        VRT_call(ctx, caller->sub);
1228 27
}
1229
1230
VCL_SUB v_matchproto_(td_xyzzy_debug_caller_sub)
1231 27
xyzzy_caller_xsub(VRT_CTX, struct VPFX(debug_caller) *caller)
1232
{
1233 27
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
1234 27
        CHECK_OBJ_NOTNULL(caller, DEBUG_CALLER_MAGIC);
1235 27
        AN(caller->sub);
1236
1237 27
        return (caller->sub);
1238
}
1239
1240
struct resolve_priv {
1241
        struct vsb vsb[1];
1242
        const char *fail_port;
1243
        const char *errp[1];
1244
};
1245
1246
static int v_matchproto_(vus_resolved_f)
1247 1242
resolve_cb(void *priv, const struct suckaddr *sa)
1248
{
1249
        struct resolve_priv *p;
1250
        char abuf[VTCP_ADDRBUFSIZE], pbuf[VTCP_PORTBUFSIZE];
1251
1252 1242
        p = (struct resolve_priv *)priv;
1253 1242
        CHECK_OBJ_NOTNULL(p->vsb, VSB_MAGIC);
1254 1242
        AN(sa);
1255 1242
        VTCP_name(sa, abuf, sizeof abuf, pbuf, sizeof pbuf);
1256 1242
        if (p->fail_port != NULL && !strcmp(p->fail_port, pbuf)) {
1257 135
                *(p->errp) = "bad port";
1258 135
                return (-1);
1259
        }
1260 1107
        VSB_printf(p->vsb, "%s%s:%s", VSB_len(p->vsb) ? ", " : "", abuf, pbuf);
1261 1107
        return (0);
1262 1242
}
1263
1264
VCL_STRING
1265 1296
xyzzy_resolve_range(VRT_CTX, struct VARGS(resolve_range) *args)
1266
{
1267
        struct resolve_priv p;
1268
        const char *def_port;
1269
        int ret;
1270
1271 1296
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
1272 1296
        if (args->addr == NULL)
1273 27
                return ("vmod-debug: s was NULL");
1274 1269
        memset(&p, 0, sizeof p);
1275 1269
        WS_VSB_new(p.vsb, ctx->ws);
1276 1269
        p.fail_port = args->valid_fail_port ? args->fail_port : NULL;
1277 1269
        def_port = args->valid_def_port ? args->def_port : NULL;
1278 1269
        ret = VSS_resolver_range(args->addr, def_port, resolve_cb, &p, p.errp);
1279 1269
        if (ret)
1280 1458
                VSB_printf(p.vsb, "%s%s", VSB_len(p.vsb) ? ", " : "Failed: ",
1281 729
                    *(p.errp));
1282 1269
        return (WS_VSB_finish(p.vsb, ctx->ws, NULL));
1283 1296
}
1284
1285
VCL_VOID
1286 864
xyzzy_use_reembarking_http1(VRT_CTX)
1287
{
1288 864
        debug_transport_use_reembarking_http1(ctx);
1289 864
}