Code Coverage: vinyl-cache/vmod/vmod_blob.c
 
82217aa4fc7094b3610340078afaf78cd95a8ec9
 
0
/*-
1
 * Copyright 2015-2017,2026 UPLEX - Nils Goroll Systemoptimierung
2
 * All rights reserved.
3
 *
4
 * Authors: Nils Goroll <nils.goroll@uplex.de>
5
 *          Geoffrey Simmons <geoffrey.simmons@uplex.de>
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 are met:
11
 * 1. Redistributions of source code must retain the above copyright notice,
12
 *    this list of conditions and the following disclaimer.
13
 * 2. Redistributions in binary form must reproduce the above copyright notice,
14
 *    this list of conditions and the following disclaimer in the documentation
15
 *    and/or other materials provided with the distribution.
16
 *
17
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND ANY
18
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
19
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
20
 * DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE FOR ANY
21
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
22
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
23
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
24
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
26
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27
 *
28
 */
29
30
#include "config.h"
31
#include <string.h>
32
33
#include "cache/cache.h"
34
35
#include "vcc_blob_if.h"
36
#include "vmod_blob.h"
37
38 262
#define VMOD_BLOB_TYPE 0xfade4faa
39
40
struct vmod_blob_blob {
41
        unsigned magic;
42
#define VMOD_BLOB_MAGIC 0xfade4fa9
43
        struct vrt_blob blob;
44
        void *freeptr;
45
        char *encoding[__MAX_ENCODING][2];
46
        pthread_mutex_t lock;
47
};
48
49
#define B64_FUNCS                                  \
50
                .decode_l       = base64_decode_l, \
51
                .decode         = base64_decode,   \
52
                .encode         = base64_encode
53
54
static const struct vmod_blob_fptr {
55
        len_f           *const decode_l;
56
        decode_f        *const decode;
57
        len_f           *const encode_l;
58
        encode_f        *const encode;
59
} func[__MAX_ENCODING] = {
60
        [IDENTITY] = {
61
                .decode_l       = id_decode_l,
62
                .decode         = id_decode,
63
                .encode_l       = id_encode_l,
64
                .encode         = id_encode
65
        },
66
        [BASE64] = {
67
                B64_FUNCS,
68
                .encode_l       = base64_encode_l
69
        },
70
        [BASE64URL] = {
71
                B64_FUNCS,
72
                .encode_l       = base64_encode_l
73
        },
74
        [BASE64URLNOPAD] = {
75
                B64_FUNCS,
76
                .encode_l       = base64nopad_encode_l
77
        },
78
        [BASE64CF] = {
79
                B64_FUNCS,
80
                .encode_l       = base64_encode_l
81
        },
82
        [HEX] = {
83
                .decode_l       = hex_decode_l,
84
                .decode         = hex_decode,
85
                .encode_l       = hex_encode_l,
86
                .encode         = hex_encode
87
        },
88
        [URL] = {
89
                .decode_l       = url_decode_l,
90
                .decode         = url_decode,
91
                .encode_l       = url_encode_l,
92
                .encode         = url_encode
93
        },
94
};
95
96
#undef B64_FUNCS
97
98
#define ERR(ctx, msg) \
99 16
        VRT_fail((ctx), "vmod blob error: " msg)
100
101
#define VERR(ctx, fmt, ...) \
102 66
        VRT_fail((ctx), "vmod blob error: " fmt, __VA_ARGS__)
103
104
#define ERRINVAL(ctx, enc) \
105 38
        VERR((ctx), "cannot decode, illegal encoding beginning with \"%s\"", \
106 38
             (enc))
107
108
#define VERRNOMEM(ctx, fmt, ...) \
109 0
        VERR((ctx), fmt ", out of space", __VA_ARGS__)
110
111
#define ERRNOMEM(ctx, msg) \
112 12
        ERR((ctx), msg ", out of space")
113
114
static char empty[1] = { '\0' };
115
116
static enum encoding
117
parse_encoding(VCL_ENUM e)
118 1188
{
119 1188
#define VMODENUM(n)                             \
120 5789
        do {                                    \
121 5789
                if (e == VENUM(n)) return (n);  \
122 5789
        } while (0);
123 1188
#include "vmod_blob_tbl_encodings.h"
124 0
        WRONG("illegal encoding enum");
125 0
}
126
127
static enum case_e
128
parse_case(VCL_ENUM e)
129 675
{
130 675
#define VMODENUM(n)                             \
131 1752
        do {                                    \
132 1752
                if (e == VENUM(n)) return (n);  \
133 1752
        } while (0);
134 675
#include "vmod_blob_tbl_case.h"
135 0
        WRONG("illegal case enum");
136 0
}
137
138
139
static inline size_t
140
decode_l(enum encoding dec, VCL_STRANDS s)
141 237
{
142 237
        size_t len = 0;
143
144 237
        AENC(dec);
145
146 237
        CHECK_OBJ_NOTNULL(s, STRANDS_MAGIC);
147 237
        STRANDS_FOREACH(p, s)
148 306
                if (p != NULL && *p != '\0')
149 276
                        len += vstrlen(p);
150
151 237
        return (func[dec].decode_l(len));
152 237
}
153
154
static void
155
err_decode(VRT_CTX, const char *enc)
156 42
{
157 42
        switch (errno) {
158 38
        case EINVAL:
159 38
                ERRINVAL(ctx, enc);
160 38
                break;
161 4
        case ENOMEM:
162 4
                ERRNOMEM(ctx, "cannot decode");
163 4
                break;
164 0
        default:
165 0
                WRONG("invalid errno");
166 42
        }
167 42
}
168
169
static inline int
170
encodes_hex(enum encoding enc)
171 706
{
172 706
        return (enc == HEX || enc == URL);
173 706
}
174
175
/* Require case DEFAULT for all encodings besides HEX and URL. */
176
177
static inline int
178
check_enc_case(VRT_CTX, VCL_ENUM encs, VCL_ENUM case_s, enum encoding enc,
179
    enum case_e kase)
180 675
{
181 675
        if (!encodes_hex(enc) && kase != DEFAULT) {
182 16
                VERR(ctx, "case %s is illegal with encoding %s", case_s, encs);
183 16
                return (0);
184 16
        }
185 659
        return (1);
186 675
}
187
188
/* Objects */
189
190
VCL_VOID v_matchproto_(td_blob_blob__init)
191
vmod_blob__init(VRT_CTX, struct vmod_blob_blob **blobp, const char *vcl_name,
192
    VCL_ENUM decs, VCL_STRANDS strings)
193 50
{
194 50
        struct vmod_blob_blob *b;
195 50
        enum encoding dec = parse_encoding(decs);
196 50
        void *buf;
197 50
        ssize_t len;
198
199 50
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
200 50
        AN(blobp);
201 50
        AZ(*blobp);
202 50
        AN(vcl_name);
203 50
        AENC(dec);
204 50
        CHECK_OBJ_NOTNULL(strings, STRANDS_MAGIC);
205
206 50
        ALLOC_OBJ(b, VMOD_BLOB_MAGIC);
207 50
        AN(b);
208 50
        *blobp = b;
209 50
        AZ(pthread_mutex_init(&b->lock, NULL));
210
211 50
        b->blob.magic = VRT_BLOB_MAGIC;
212 50
        b->blob.type = VMOD_BLOB_TYPE;
213
214 50
        len = decode_l(dec, strings);
215 50
        if (len == 0)
216 8
                return;
217
218 42
        assert(len > 0);
219
220 42
        buf = malloc(len);
221 42
        if (buf == NULL) {
222 0
                VERRNOMEM(ctx, "cannot create blob %s", vcl_name);
223 0
                return;
224 0
        }
225
226 42
        errno = 0;
227 42
        len = func[dec].decode(dec, buf, len, -1, strings, NULL);
228
229 42
        if (len == -1) {
230 8
                assert(errno == EINVAL);
231 8
                free(buf);
232 8
                VERR(ctx, "cannot create blob %s, illegal encoding beginning "
233 8
                    "with \"%s\"", vcl_name, strings->p[0]);
234 8
                return;
235 8
        }
236 34
        if (len == 0) {
237 0
                free(buf);
238 0
                memcpy(&b->blob, vrt_null_blob, sizeof b->blob);
239 0
                return;
240 0
        }
241 34
        b->blob.len = len;
242 34
        b->blob.blob = b->freeptr = buf;
243 34
}
244
245
VCL_BLOB v_matchproto_(td_blob_blob_get)
246
vmod_blob_get(VRT_CTX, struct vmod_blob_blob *b)
247 107
{
248 107
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
249 107
        CHECK_OBJ_NOTNULL(b, VMOD_BLOB_MAGIC);
250 107
        CHECK_OBJ(&b->blob, VRT_BLOB_MAGIC);
251 107
        return (&b->blob);
252 107
}
253
254
VCL_STRING v_matchproto_(td_blob_blob_encode)
255
vmod_blob_encode(VRT_CTX, struct vmod_blob_blob *b, VCL_ENUM encs,
256
    VCL_ENUM case_s)
257 177
{
258 177
        enum encoding enc = parse_encoding(encs);
259 177
        AENC(enc);
260 177
        enum case_e kase = parse_case(case_s);
261
262 177
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
263 177
        CHECK_OBJ_NOTNULL(b, VMOD_BLOB_MAGIC);
264 177
        CHECK_OBJ(&b->blob, VRT_BLOB_MAGIC);
265
266 177
        if (!check_enc_case(ctx, encs, case_s, enc, kase))
267 8
                return (NULL);
268 169
        if (b->blob.len == 0)
269 20
                return ("");
270 149
        if (kase == DEFAULT)
271 91
                kase = LOWER;
272
273 149
        if (b->encoding[enc][kase] == NULL) {
274 61
                PTOK(pthread_mutex_lock(&b->lock));
275 61
                if (b->encoding[enc][kase] == NULL) {
276 61
                        ssize_t len = func[enc].encode_l(b->blob.len);
277
278 61
                        assert(len >= 0);
279 61
                        if (len == 0)
280 0
                                b->encoding[enc][kase] = empty;
281 61
                        else {
282 61
                                b->encoding[enc][kase] = malloc(len);
283 61
                                if (b->encoding[enc][kase] == NULL)
284 61
                                        ERRNOMEM(ctx, "cannot encode");
285 61
                                else {
286 61
                                        char *s = b->encoding[enc][kase];
287 61
                                        len =
288 61
                                                func[enc].encode(
289 61
                                                        enc, kase, s, len,
290 61
                                                        b->blob.blob,
291 61
                                                        b->blob.len);
292 61
                                        assert(len >= 0);
293 61
                                        if (len == 0) {
294 0
                                                free(s);
295 0
                                                b->encoding[enc][kase] = empty;
296 0
                                        }
297 61
                                        else
298 61
                                                s[len] = '\0';
299 61
                                }
300 61
                        }
301 61
                }
302 61
                PTOK(pthread_mutex_unlock(&b->lock));
303 61
        }
304 149
        return (b->encoding[enc][kase]);
305 149
}
306
307
VCL_VOID v_matchproto_(td_blob_blob__fini)
308
vmod_blob__fini(struct vmod_blob_blob **blobp)
309 25
{
310 25
        struct vmod_blob_blob *b;
311 25
        char *s;
312 25
        int i, j;
313
314 25
        TAKE_OBJ_NOTNULL(b, blobp, VMOD_BLOB_MAGIC);
315 25
        CHECK_OBJ(&b->blob, VRT_BLOB_MAGIC);
316
317 25
        if (b->freeptr != NULL) {
318 14
                free(b->freeptr);
319 14
                b->blob.blob = NULL;
320 14
        }
321
322 225
        for (i = 0; i < __MAX_ENCODING; i++)
323 600
                for (j = 0; j < 2; j++) {
324 400
                        s = b->encoding[i][j];
325 400
                        if (s != NULL && s != empty) {
326 20
                                free(s);
327 20
                                b->encoding[i][j] = NULL;
328 20
                        }
329 400
                }
330
331 25
        PTOK(pthread_mutex_destroy(&b->lock));
332 25
        FREE_OBJ(b);
333 25
}
334
335
/* Functions */
336
337
VCL_BLOB v_matchproto_(td_blob_decode)
338
vmod_decode(VRT_CTX, VCL_ENUM decs, VCL_INT length, VCL_STRANDS strings)
339 276
{
340 276
        enum encoding dec = parse_encoding(decs);
341 276
        char *buf;
342 276
        ssize_t len;
343 276
        unsigned space;
344
345 276
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
346 276
        AENC(dec);
347 276
        CHECK_OBJ_NOTNULL(strings, STRANDS_MAGIC);
348 276
        CHECK_OBJ_NOTNULL(ctx->ws, WS_MAGIC);
349
350 276
        space = WS_ReserveAll(ctx->ws);
351 552
        buf = WS_Reservation(ctx->ws);
352
353 276
        if (length <= 0)
354 195
                length = -1;
355 552
        errno = 0;
356 552
        len = func[dec].decode(dec, buf, space, length, strings, NULL);
357
358 552
        if (len == -1) {
359 21
                err_decode(ctx, strings->p[0]);
360 21
                WS_Release(ctx->ws, 0);
361 21
                return (NULL);
362 21
        }
363 255
        if (len == 0) {
364 43
                WS_Release(ctx->ws, 0);
365 43
                return (vrt_null_blob);
366 43
        }
367 212
        WS_Release(ctx->ws, len);
368
369 212
        assert(len > 0);
370
371 212
        return (VRT_blob(ctx, "blob.decode", buf, len, VMOD_BLOB_TYPE));
372 212
}
373
374
static VCL_STRING
375
encode(VRT_CTX, enum encoding enc, enum case_e kase, VCL_BLOB b)
376 303
{
377 303
        ssize_t len;
378 303
        char *buf;
379 303
        unsigned space;
380
381 303
        AENC(enc);
382
383 303
        if (b == NULL)
384 27
                return (NULL);
385
386 276
        CHECK_OBJ(b, VRT_BLOB_MAGIC);
387 276
        CHECK_OBJ_NOTNULL(ctx->ws, WS_MAGIC);
388 276
        space = WS_ReserveAll(ctx->ws);
389 552
        buf = WS_Reservation(ctx->ws);
390
391 0
        len = func[enc].encode(enc, kase, buf, space, b->blob, b->len);
392
393 552
        if (len == -1) {
394 5
                ERRNOMEM(ctx, "cannot encode");
395 5
                WS_Release(ctx->ws, 0);
396 5
                return (NULL);
397 5
        }
398 271
        if (len == 0) {
399 36
                WS_Release(ctx->ws, 0);
400 36
                return ("");
401 36
        }
402 235
        buf[len] = '\0';
403 235
        WS_Release(ctx->ws, len + 1);
404 235
        return (buf);
405 271
}
406
407
VCL_STRING v_matchproto_(td_blob_encode)
408
vmod_encode(VRT_CTX, VCL_ENUM encs, VCL_ENUM case_s, VCL_BLOB b)
409 311
{
410 311
        enum encoding enc = parse_encoding(encs);
411 311
        enum case_e kase = parse_case(case_s);
412
413 311
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
414 311
        if (!check_enc_case(ctx, encs, case_s, enc, kase))
415 8
                return (NULL);
416 303
        return (encode(ctx, enc, kase, b));
417 311
}
418
419
/*
420
 * Remove the first len bytes from strands
421
 *
422
 * to VRT?
423
 */
424
static void
425
strands_consume(struct strands *strings, size_t consume)
426 169
{
427 169
        const char *s;
428 169
        size_t len;
429 169
        int i;
430
431 169
        CHECK_OBJ_NOTNULL(strings, STRANDS_MAGIC);
432
433 300
        for (i = 0; i < strings->n; i++) {
434 211
                s = strings->p[i];
435 211
                if (s == NULL || *s == '\0')
436 18
                        continue;
437 193
                len = vstrlen(s);
438 193
                if (consume >= len) {
439 113
                        strings->p[i] = NULL;
440 113
                        consume -= len;
441 113
                        continue;
442 113
                }
443 80
                strings->p[i] += consume;
444 80
                break;
445 193
        }
446
447
        // i is at first string still needed
448 169
        assert(i >= 0);
449 169
        assert(i <= strings->n);
450 169
        if (i == strings->n) {
451 89
                memset(strings->p, 0, strings->n * sizeof *strings->p);
452 89
                strings->n = 0;
453 89
                return;
454 89
        }
455 80
        len = (unsigned)strings->n - i;
456 80
        vmemmove(strings->p, strings->p + i, len * sizeof *strings->p);
457 80
        strings->n -= i;
458 80
}
459
460
VCL_STRING v_matchproto_(td_blob_transcode)
461
vmod_transcode(VRT_CTX, VCL_ENUM decs, VCL_ENUM encs, VCL_ENUM case_s,
462
               VCL_INT length, VCL_STRANDS stringsa)
463 187
{
464 187
        enum encoding dec = parse_encoding(decs);
465 187
        enum encoding enc = parse_encoding(encs);
466 187
        enum case_e kase = parse_case(case_s);
467 187
        VCL_STRING r;
468
        // 32K are safe because PCRE. Needs to be a multiple of three for base64
469
        // For bughunt, set to 3
470 187
        const size_t bufmax = (32 * 1024) - 2;
471 187
        size_t buflen;
472 187
        ssize_t len;
473 187
        char *out;
474 187
        unsigned space;
475 187
        size_t consumed;
476
477 187
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
478 187
        CHECK_OBJ_NOTNULL(ctx->ws, WS_MAGIC);
479 187
        CHECK_OBJ_NOTNULL(stringsa, STRANDS_MAGIC);
480
481
        // copy stringsa into strings on stack
482 187
        const char *p[stringsa->n];
483 187
        vmemcpy(p, stringsa->p, stringsa->n * sizeof *p);
484 187
        struct strands *strings = &(struct strands){.magic=STRANDS_MAGIC, .n=stringsa->n, .p=p};
485
486 187
        assert(bufmax % 3 == 0); //lint !e778 constant
487
488 187
        AENC(dec);
489 187
        AENC(enc);
490
491 187
        if (!check_enc_case(ctx, encs, case_s, enc, kase))
492 0
                return (NULL);
493
494
        /*
495
         * Allocate space for the decoded blob on the stack
496
         * ignoring the limitation imposed by n
497
         */
498 187
        buflen = decode_l(dec, strings);
499 187
        if (buflen == 0)
500 0
                return ("");
501
502 187
        if (buflen > bufmax)
503 1
                buflen = bufmax;
504
505 187
        char buf[buflen];
506
507 187
        if (length <= 0)
508 102
                length = -1;
509
510 187
        if (length == -1 && enc == dec && !encodes_hex(enc)) {
511
                /* test if decodes OK, and if so, return input
512
                 * basically the same loop as below, but without the encode step
513
                 */
514 14
                while (strings->n) {
515 9
                        errno = 0;
516 9
                        len = func[dec].decode(dec, buf, buflen, length, strings, &consumed);
517
518 9
                        if (len < 0 && errno != ENOMEM) {
519 4
                                err_decode(ctx, strings->p[0]);
520 4
                                return (NULL);
521 4
                        }
522
523 5
                        strands_consume(strings, consumed);
524 5
                }
525 5
                return (VRT_STRANDS_string(ctx, stringsa));
526 9
        }
527
528 178
        space = WS_ReserveAll(ctx->ws);
529 356
        r = out = WS_Reservation(ctx->ws);
530
531 339
        while (strings->n && length != 0) {
532 181
                errno = 0;
533
534 181
                len = func[dec].decode(dec, buf, buflen, length, strings, &consumed);
535 181
                if (len < 0 && errno != ENOMEM) {
536 17
                        err_decode(ctx, strings->p[0]);
537 17
                        WS_Release(ctx->ws, 0);
538 17
                        return (NULL);
539 17
                }
540 164
                if (len < 0)
541 4
                        len = buflen;
542
543 164
                strands_consume(strings, consumed);
544
545 164
                if (length > 0) {
546 76
                        assert(consumed <= (typeof(consumed))length);
547 76
                        length -= consumed;
548 76
                }
549
550 164
                if (len == 0)
551 0
                        continue;
552 164
                AN(consumed);
553
554 164
                errno = 0;
555 164
                len = func[enc].encode(enc, kase, out, space, buf, len);
556
557 164
                if (len == -1) {
558 3
                        ERRNOMEM(ctx, "cannot encode");
559 3
                        WS_Release(ctx->ws, 0);
560 3
                        return (NULL);
561 3
                }
562 161
                assert(len >= 0);
563 161
                assert((size_t)len <= space);
564
565 161
                out += len;
566 161
                space -= len;
567 161
        }
568
569
        // _encode_l ensures
570 158
        assert(space > 0);
571 158
        *out++ = '\0';
572 158
        WS_ReleaseP(ctx->ws, out);
573 158
        return (r);
574 158
}
575
576
VCL_BOOL v_matchproto_(td_blob_same)
577
vmod_same(VRT_CTX, VCL_BLOB b1, VCL_BLOB b2)
578 18
{
579
580 18
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
581 18
        if (b1 == b2)
582 6
                return (1);
583 12
        if (b1 == NULL || b2 == NULL)
584 3
                return (0);
585 9
        CHECK_OBJ(b1, VRT_BLOB_MAGIC);
586 9
        CHECK_OBJ(b2, VRT_BLOB_MAGIC);
587 9
        return (b1->len == b2->len && b1->blob == b2->blob);
588 9
}
589
590
VCL_BOOL v_matchproto_(td_blob_equal)
591
vmod_equal(VRT_CTX, VCL_BLOB b1, VCL_BLOB b2)
592 12
{
593
594 12
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
595 12
        if (b1 == b2)
596 3
                return (1);
597 9
        if (b1 == NULL || b2 == NULL)
598 0
                return (0);
599 9
        CHECK_OBJ(b1, VRT_BLOB_MAGIC);
600 9
        CHECK_OBJ(b2, VRT_BLOB_MAGIC);
601 9
        if (b1->len != b2->len)
602 3
                return (0);
603 6
        if (b1->blob == b2->blob)
604 2
                return (1);
605 4
        if (b1->blob == NULL || b2->blob == NULL)
606 0
                return (0);
607 4
        return (memcmp(b1->blob, b2->blob, b1->len) == 0);
608 4
}
609
610
VCL_INT v_matchproto_(td_blob_length)
611
vmod_length(VRT_CTX, VCL_BLOB b)
612 7
{
613
614 7
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
615 7
        if (b == NULL)
616 0
                return (0);
617 7
        CHECK_OBJ(b, VRT_BLOB_MAGIC);
618 7
        return (b->len);
619 7
}
620
621
VCL_BLOB v_matchproto_(td_blob_sub)
622
vmod_sub(VRT_CTX, VCL_BLOB b, VCL_BYTES n, VCL_BYTES off)
623 18
{
624
625 18
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
626
627 18
        CHECK_OBJ_ORNULL(b, VRT_BLOB_MAGIC);
628 18
        if (b == NULL || b->len == 0 || b->blob == NULL) {
629 3
                ERR(ctx, "blob is empty in blob.sub()");
630 3
                return (NULL);
631 3
        }
632
633 15
        assert(b->len > 0);
634
635
        // XXX check for > SIZE_MAX ?
636 15
        if (off < 0 || n < 0) {
637 1
                ERR(ctx, "size or offset negative in blob.sub()");
638 1
                return (NULL);
639 1
        }
640
641 14
        if ((size_t)off > b->len || (size_t)n > b->len ||
642 14
            (size_t)off + (size_t)n > b->len) {
643 4
                VERR(ctx, "size %jd from offset %jd requires more bytes than "
644 4
                    "blob length %zd in blob.sub()",
645 4
                    (intmax_t)n, (intmax_t)off, b->len);
646 4
                return (NULL);
647 4
        }
648
649 10
        return (VRT_blob(ctx, "blob.sub",
650 10
            (const char *)b->blob + off, n, b->type));
651 14
}