varnish-cache/lib/libvcc/vcc_vmod.c
0
/*-
1
 * Copyright (c) 2010-2015 Varnish Software AS
2
 * All rights reserved.
3
 *
4
 * Author: Poul-Henning Kamp <phk@phk.freebsd.dk>
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
 * Parse `import`, check metadata and versioning.
30
 *
31
 */
32
33
#include "config.h"
34
35
#include <stdlib.h>
36
#include <string.h>
37
38
#include "vcc_compile.h"
39
40
#include "libvcc.h"
41
#include "vfil.h"
42
#include "vjsn.h"
43
#include "vmod_abi.h"
44
45
#include "vcc_vmod.h"
46
47
struct vmod_import {
48
        unsigned                        magic;
49
#define VMOD_IMPORT_MAGIC               0x31803a5d
50
        const char                      *err;
51
        struct vsb                      *json;
52
        char                            *path;
53
        VTAILQ_ENTRY(vmod_import)       list;
54
        int                             from_vext;
55
        int                             unimported_vext;
56
57
        // From $VMOD
58
        double                          vmod_syntax;
59
        char                            *name;
60
        char                            *func_name;
61
        char                            *file_id;
62
        char                            *abi;
63
        unsigned                        major;
64
        unsigned                        minor;
65
66
        struct symbol                   *sym;
67
        const struct token              *t_mod;
68
        struct vjsn                     *vj;
69
#define STANZA(UU, ll, ss)              int n_##ll;
70
        STANZA_TBL
71
#undef STANZA
72
};
73
74
static VTAILQ_HEAD(,vmod_import) imports = VTAILQ_HEAD_INITIALIZER(imports);
75
76
typedef void vcc_do_stanza_f(struct vcc *tl, const struct vmod_import *vim,
77
    const struct vjsn_val *vv);
78
79
static int
80 6792
vcc_Extract_JSON(struct vmod_import *vim, const char *filename)
81
{
82 6792
        const char *magic = "VMOD_JSON_SPEC\x02", *p;
83
        int c;
84
        FILE *f;
85
86 6792
        CHECK_OBJ_NOTNULL(vim, VMOD_IMPORT_MAGIC);
87 6792
        AN(filename);
88
89 6792
        f = fopen(filename, "rb");
90 6792
        if (f == NULL) {
91 12
                vim->err = strerror(errno);
92 12
                return (-1);
93
        }
94
95 6780
        p = magic;
96 6780
        vim->err = "No VMOD JSON found";
97 486504
        while (1) {
98 120484224
                c = getc(f);
99 120484224
                if (c == EOF) {
100 12
                        AZ(fclose(f));
101 12
                        vim->err = "No VMOD JSON found";
102 12
                        return (-1);
103
                }
104 120484212
                if (c != *p) {
105 119997720
                        p = magic;
106 119997720
                        continue;
107
                }
108 486492
                p++;
109 486492
                if (*p == '\0')
110 6768
                        break;
111
        }
112
113 6768
        vim->json = VSB_new_auto();
114 6768
        AN(vim->json);
115
116 119890500
        while (1) {
117 119890500
                c = getc(f);
118 119890500
                if (c == EOF) {
119 12
                        AZ(fclose(f));
120 12
                        vim->err = "Truncated VMOD JSON";
121 12
                        VSB_destroy(&vim->json);
122 12
                        return (-1);
123
                }
124 119890488
                if (c == '\x03')
125 6756
                        break;
126 119883732
                VSB_putc(vim->json, c);
127
        }
128 6756
        AZ(fclose(f));
129 6756
        AZ(VSB_finish(vim->json));
130 6756
        return (0);
131 6792
}
132
133
static const char *
134 6756
vcc_ParseJSON(const struct vcc *tl, const char *jsn, struct vmod_import *vim)
135
{
136
        const struct vjsn_val *vv, *vv2, *vv3;
137
        const char *err;
138
        char *p;
139
140 6756
        vim->vj = vjsn_parse(jsn, &err);
141 6756
        if (err != NULL)
142 12
                return (err);
143 6744
        AN(vim->vj);
144
145 6744
        vv = vim->vj->value;
146 6744
        if (!vjsn_is_array(vv))
147 12
                return ("Not array[0]");
148
149 6732
        vv2 = VTAILQ_FIRST(&vv->children);
150 6732
        AN(vv2);
151 6732
        if (!vjsn_is_array(vv2))
152 12
                return ("Not array[1]");
153 6720
        vv3 = VTAILQ_FIRST(&vv2->children);
154 6720
        AN(vv3);
155 6720
        if (!vjsn_is_string(vv3))
156 12
                return ("Not string[2]");
157 6708
        if (strcmp(vv3->value, "$VMOD"))
158 12
                return ("Not $VMOD[3]");
159
160 6696
        vv3 = VTAILQ_NEXT(vv3, list);
161 6696
        AN(vv3);
162 6696
        assert(vjsn_is_string(vv3));
163 6696
        vim->vmod_syntax = strtod(vv3->value, NULL);
164 6696
        assert (vim->vmod_syntax == 1.0);
165
166 6696
        vv3 = VTAILQ_NEXT(vv3, list);
167 6696
        AN(vv3);
168 6696
        assert(vjsn_is_string(vv3));
169 6696
        vim->name = vv3->value;
170
171 6696
        vv3 = VTAILQ_NEXT(vv3, list);
172 6696
        AN(vv3);
173 6696
        assert(vjsn_is_string(vv3));
174 6696
        vim->func_name = vv3->value;
175
176 6696
        vv3 = VTAILQ_NEXT(vv3, list);
177 6696
        AN(vv3);
178 6696
        assert(vjsn_is_string(vv3));
179 6696
        vim->file_id = vv3->value;
180
181 6696
        vv3 = VTAILQ_NEXT(vv3, list);
182 6696
        AN(vv3);
183 6696
        assert(vjsn_is_string(vv3));
184 6696
        vim->abi = vv3->value;
185
186 6696
        vv3 = VTAILQ_NEXT(vv3, list);
187 6696
        AN(vv3);
188 6696
        assert(vjsn_is_string(vv3));
189 6696
        vim->major = strtoul(vv3->value, &p, 10);
190 6696
        assert(p == NULL || *p == '\0' || *p == 'U');
191
192 6696
        vv3 = VTAILQ_NEXT(vv3, list);
193 6696
        AN(vv3);
194 6696
        assert(vjsn_is_string(vv3));
195 6696
        vim->minor = strtoul(vv3->value, &p, 10);
196 6696
        assert(p == NULL || *p == '\0' || *p == 'U');
197
198
199 6696
        if (vim->major == 0 && vim->minor == 0 &&
200 5208
            strcmp(vim->abi, VMOD_ABI_Version)) {
201 12
                VSB_printf(tl->sb, "Incompatible VMOD %.*s\n", PF(vim->t_mod));
202 12
                VSB_printf(tl->sb, "\tFile name: %s\n", vim->path);
203 24
                VSB_printf(tl->sb, "\tABI mismatch, expected <%s>, got <%s>\n",
204 12
                           VMOD_ABI_Version, vim->abi);
205 12
                return ("");
206
        }
207 8160
        if (vim->major != 0 &&
208 1488
            (vim->major != VRT_MAJOR_VERSION ||
209 1476
            vim->minor > VRT_MINOR_VERSION)) {
210 12
                VSB_printf(tl->sb, "Incompatible VMOD %.*s\n", PF(vim->t_mod));
211 12
                VSB_printf(tl->sb, "\tFile name: %s\n", vim->path);
212 24
                VSB_printf(tl->sb, "\tVMOD wants ABI version %u.%u\n",
213 12
                    vim->major, vim->minor);
214 12
                VSB_printf(tl->sb, "\tvarnishd provides ABI version %u.%u\n",
215
                    VRT_MAJOR_VERSION, VRT_MINOR_VERSION);
216 12
                return ("");
217
        }
218
219
220 234432
        VTAILQ_FOREACH(vv2, &vv->children, list) {
221 227772
                assert (vjsn_is_array(vv2));
222 227772
                vv3 = VTAILQ_FIRST(&vv2->children);
223 227772
                assert(vjsn_is_string(vv3));
224 227772
                assert(vv3->value[0] == '$');
225
#define STANZA(UU, ll, ss) \
226
    if (!strcmp(vv3->value, "$" #UU)) {vim->n_##ll++; continue;}
227 227772
                STANZA_TBL
228
#undef STANZA
229 12
                return ("Unknown metadata stanza.");
230
        }
231 6660
        if (vim->n_cproto != 1)
232 12
                return ("Bad cproto stanza(s)");
233 6648
        if (vim->n_vmod != 1)
234 12
                return ("Bad vmod stanza(s)");
235 6636
        return (NULL);
236 6756
}
237
238
/*
239
 * Load and check the metadata from the objectfile containing the vmod
240
 */
241
242
static int
243 6756
vcc_VmodLoad(struct vcc *tl, struct vmod_import *vim)
244
{
245
        static const char *err;
246
        struct vmod_import *vim2;
247
248 6756
        CHECK_OBJ_NOTNULL(vim, VMOD_IMPORT_MAGIC);
249
250 6756
        err = vcc_ParseJSON(tl, VSB_data(vim->json), vim);
251 6756
        if (err != NULL && *err != '\0') {
252 192
                VSB_printf(tl->sb,
253 96
                    "VMOD %.*s: bad metadata\n", PF(vim->t_mod));
254 96
                VSB_printf(tl->sb, "\t(%s)\n", err);
255 96
                VSB_printf(tl->sb, "\tFile name: %s\n", vim->path);
256 96
        }
257
258 6756
        if (err != NULL)
259 120
                return (-1);
260
261 8292
        VTAILQ_FOREACH(vim2, &imports, list) {
262 1704
                if (strcmp(vim->name, vim2->name))
263 1656
                        continue;
264 48
                if (!strcmp(vim->file_id, vim2->file_id)) {
265
                        // (Truly) duplicate imports are OK
266 36
                        return (0);
267
                }
268 24
                VSB_printf(tl->sb,
269
                    "Different version of VMOD %.*s already loaded\n",
270 12
                    PF(vim->t_mod));
271 12
                vcc_ErrWhere(tl, vim->t_mod);
272 12
                VSB_cat(tl->sb, "Previous import at:\n");
273 12
                vcc_ErrWhere(tl, vim2->t_mod);
274 12
                vcc_Warn(tl);
275 12
                break;
276
        }
277 6600
        VTAILQ_INSERT_TAIL(&imports, vim, list);
278
279 6600
        return (0);
280 6756
}
281
282
static void v_matchproto_(vcc_do_stanza_f)
283 1356
vcc_do_event(struct vcc *tl, const struct vmod_import *vim,
284
    const struct vjsn_val *vv)
285
{
286
        struct inifin *ifp;
287
288 1356
        ifp = New_IniFin(tl);
289 2712
        VSB_printf(ifp->ini,
290
            "\tif (%s(ctx, &vmod_priv_%s, VCL_EVENT_LOAD))\n"
291
            "\t\treturn(1);",
292 1356
            vv->value, vim->sym->vmod_name);
293 2712
        VSB_printf(ifp->fin,
294
            "\t\t(void)%s(ctx, &vmod_priv_%s,\n"
295
            "\t\t\t    VCL_EVENT_DISCARD);",
296 1356
            vv->value, vim->sym->vmod_name);
297 2712
        VSB_printf(ifp->event, "%s(ctx, &vmod_priv_%s, ev)",
298 1356
            vv->value, vim->sym->vmod_name);
299 1356
}
300
301
static void v_matchproto_(vcc_do_stanza_f)
302 6552
vcc_do_cproto(struct vcc *tl, const struct vmod_import *vim,
303
    const struct vjsn_val *vv)
304
{
305 6552
        (void)vim;
306 6552
        do {
307 1196124
                assert (vjsn_is_string(vv));
308 1196124
                Fh(tl, 0, "%s\n", vv->value);
309 1196124
                vv = VTAILQ_NEXT(vv, list);
310 1196124
        } while(vv != NULL);
311 6552
}
312
313
static void
314 13104
vcc_vj_foreach(struct vcc *tl, const struct vmod_import *vim,
315
    const char *stanza, vcc_do_stanza_f *func)
316
{
317
        const struct vjsn_val *vv, *vv2, *vv3;
318
319 13104
        vv = vim->vj->value;
320 13104
        assert (vjsn_is_array(vv));
321 460128
        VTAILQ_FOREACH(vv2, &vv->children, list) {
322 447024
                assert (vjsn_is_array(vv2));
323 447024
                vv3 = VTAILQ_FIRST(&vv2->children);
324 447024
                assert (vjsn_is_string(vv3));
325 447024
                if (!strcmp(vv3->value, stanza))
326 7908
                        func(tl, vim, VTAILQ_NEXT(vv3, list));
327 447024
        }
328 13104
}
329
330
static void
331 6552
vcc_emit_setup(struct vcc *tl, const struct vmod_import *vim)
332
{
333
        struct inifin *ifp;
334 6552
        const struct token *mod = vim->t_mod;
335
336 6552
        ifp = New_IniFin(tl);
337
338 6552
        VSB_cat(ifp->ini, "\tif (VPI_Vmod_Init(ctx,\n");
339 6552
        VSB_printf(ifp->ini, "\t    &VGC_vmod_%.*s,\n", PF(mod));
340 6552
        VSB_printf(ifp->ini, "\t    %u,\n", tl->vmod_count++);
341 6552
        VSB_printf(ifp->ini, "\t    &%s,\n", vim->func_name);
342 6552
        VSB_printf(ifp->ini, "\t    sizeof(%s),\n", vim->func_name);
343 6552
        VSB_printf(ifp->ini, "\t    \"%.*s\",\n", PF(mod));
344 6552
        VSB_cat(ifp->ini, "\t    ");
345 6552
        VSB_quote(ifp->ini, vim->path, -1, VSB_QUOTE_CSTR);
346 6552
        VSB_cat(ifp->ini, ",\n");
347 6552
        AN(vim->file_id);
348 6552
        VSB_printf(ifp->ini, "\t    \"%s\",\n", vim->file_id);
349 6552
        if (vim->from_vext) {
350 12
                VSB_cat(ifp->ini, "\t    ");
351 12
                VSB_quote(ifp->ini, vim->path, -1, VSB_QUOTE_CSTR);
352 12
                VSB_cat(ifp->ini, "\n");
353 12
        } else {
354 13080
                VSB_printf(ifp->ini, "\t    \"./vmod_cache/_vmod_%.*s.%s\"\n",
355 6540
                    PF(mod), vim->file_id);
356
        }
357 6552
        VSB_cat(ifp->ini, "\t    ))\n");
358 6552
        VSB_cat(ifp->ini, "\t\treturn(1);");
359
360 6552
        VSB_cat(tl->symtab, ",\n    {\n");
361 6552
        VSB_cat(tl->symtab, "\t\"dir\": \"import\",\n");
362 6552
        VSB_cat(tl->symtab, "\t\"type\": \"$VMOD\",\n");
363 6552
        VSB_printf(tl->symtab, "\t\"name\": \"%.*s\",\n", PF(mod));
364 6552
        if (vim->from_vext)
365 12
                VSB_cat(tl->symtab, "\t\"vext\": true,\n");
366
        else
367 6540
                VSB_cat(tl->symtab, "\t\"vext\": false,\n");
368 6552
        VSB_printf(tl->symtab, "\t\"file\": \"%s\",\n", vim->path);
369 13104
        VSB_printf(tl->symtab, "\t\"dst\": \"./vmod_cache/_vmod_%.*s.%s\"\n",
370 6552
            PF(mod), vim->file_id);
371 6552
        VSB_cat(tl->symtab, "    }");
372
373
        /* XXX: zero the function pointer structure ?*/
374 13104
        VSB_printf(ifp->fin, "\t\tVRT_priv_fini(ctx, &vmod_priv_%.*s);",
375 6552
            PF(mod));
376 13104
        VSB_printf(ifp->final, "\t\tVPI_Vmod_Unload(ctx, &VGC_vmod_%.*s);",
377 6552
            PF(mod));
378
379 6552
        vcc_vj_foreach(tl, vim, "$EVENT", vcc_do_event);
380
381 6552
        Fh(tl, 0, "\n/* --- BEGIN VMOD %.*s --- */\n\n", PF(mod));
382 6552
        Fh(tl, 0, "static struct vmod *VGC_vmod_%.*s;\n", PF(mod));
383 6552
        Fh(tl, 0, "static struct vmod_priv vmod_priv_%.*s;\n", PF(mod));
384
385 6552
        vcc_vj_foreach(tl, vim, "$CPROTO", vcc_do_cproto);
386
387 6552
        Fh(tl, 0, "\n/* --- END VMOD %.*s --- */\n\n", PF(mod));
388 6552
}
389
390
static void
391 240
vcc_vim_destroy(struct vmod_import **vimp)
392
{
393
        struct vmod_import *vim;
394
395 240
        TAKE_OBJ_NOTNULL(vim, vimp, VMOD_IMPORT_MAGIC);
396 240
        if (vim->path)
397 228
                free(vim->path);
398 240
        if (vim->vj)
399 180
                vjsn_delete(&vim->vj);
400 240
        if (vim->json)
401 192
                VSB_destroy(&vim->json);
402 240
        FREE_OBJ(vim);
403 240
}
404
405
static int
406 6780
vcc_path_open(void *priv, const char *fn)
407
{
408
        struct vmod_import *vim;
409
410 6780
        CAST_OBJ_NOTNULL(vim, priv, VMOD_IMPORT_MAGIC);
411 6780
        AN(fn);
412
413 6780
        return (vcc_Extract_JSON(vim, fn));
414
}
415
416
void
417 6840
vcc_ParseImport(struct vcc *tl)
418
{
419
        char fn[1024];
420
        const char *p;
421
        struct token *mod, *tmod, *t1;
422
        struct symbol *msym, *vsym;
423 6840
        struct vmod_import *vim = NULL;
424
        const struct vmod_import *vimold;
425
426 6840
        t1 = tl->t;
427 6840
        SkipToken(tl, ID);              /* "import" */
428
429 6840
        ExpectErr(tl, ID);              /* "vmod_name" */
430 6840
        mod = tl->t;
431 6840
        tmod = vcc_PeekTokenFrom(tl, mod);
432 6840
        AN(tmod);
433 6840
        if (tmod->tok == ID && vcc_IdIs(tmod, "as")) {
434 60
                vcc_NextToken(tl);              /* "vmod_name" */
435 60
                vcc_NextToken(tl);              /* "as" */
436 60
                ExpectErr(tl, ID);              /* "vcl_name" */
437 60
        }
438 6840
        tmod = tl->t;
439
440 6840
        msym = VCC_SymbolGet(tl, SYM_MAIN, SYM_VMOD, SYMTAB_CREATE, XREF_NONE);
441 6840
        ERRCHK(tl);
442 6828
        AN(msym);
443
444 6828
        bprintf(fn, "libvmod_%.*s.so", PF(mod));
445 6828
        if (tl->t->tok == ID) {
446 60
                if (!vcc_IdIs(tl->t, "from")) {
447 12
                        VSB_cat(tl->sb, "Expected 'from path ...'\n");
448 12
                        vcc_ErrWhere(tl, tl->t);
449 12
                        return;
450
                }
451 48
                vcc_NextToken(tl);
452 48
                if (!tl->unsafe_path && strchr(tl->t->dec, '/')) {
453 12
                        VSB_cat(tl->sb,
454
                            "'import ... from path ...' is unsafe.\nAt:");
455 12
                        vcc_ErrToken(tl, tl->t);
456 12
                        vcc_ErrWhere(tl, tl->t);
457 12
                        return;
458
                }
459 36
                ExpectErr(tl, CSTR);
460 36
                p = strrchr(tl->t->dec, '/');
461 36
                if (p != NULL && p[1] == '\0')
462 12
                        bprintf(fn, "%slibvmod_%.*s.so", tl->t->dec, PF(mod));
463
                else
464 24
                        bprintf(fn, "%s", tl->t->dec);
465 36
                vcc_NextToken(tl);
466 36
        } else {
467 8496
                VTAILQ_FOREACH(vim, &imports, list) {
468 1740
                        if (!vcc_IdIs(mod, vim->name))
469 1692
                                continue;
470 48
                        if (!vim->unimported_vext)
471 36
                                continue;
472 12
                        fprintf(stderr, "IMPORT %s from VEXT\n", vim->name);
473 12
                        vim->unimported_vext = 0;
474 12
                        vim->t_mod = mod;
475 12
                        vim->sym = msym;
476 12
                        break;
477
                }
478
        }
479
480 6804
        SkipToken(tl, ';');
481
482 6804
        if (vim == NULL) {
483 6792
                ALLOC_OBJ(vim, VMOD_IMPORT_MAGIC);
484 6792
                AN(vim);
485 6792
                vim->t_mod = mod;
486 6792
                vim->sym = msym;
487
488 6792
                if (VFIL_searchpath(tl->vmod_path, vcc_path_open, vim, fn, &vim->path)) {
489 48
                        if (vim->err == NULL) {
490 24
                                VSB_printf(tl->sb,
491 12
                                    "Could not find VMOD %.*s\n", PF(mod));
492 12
                        } else {
493 72
                                VSB_printf(tl->sb,
494 36
                                    "Could not open VMOD %.*s\n", PF(mod));
495 72
                                VSB_printf(tl->sb, "\tFile name: %s\n",
496 36
                                    vim->path != NULL ? vim->path : fn);
497 36
                                VSB_printf(tl->sb, "\tError: %s\n", vim->err);
498
                        }
499 48
                        vcc_ErrWhere(tl, mod);
500 48
                        vcc_vim_destroy(&vim);
501 48
                        return;
502
                }
503
504 6744
                if (vcc_VmodLoad(tl, vim) < 0 || tl->err) {
505 120
                        vcc_ErrWhere(tl, vim->t_mod);
506 120
                        vcc_vim_destroy(&vim);
507 120
                        return;
508
                }
509 6624
        }
510
511 6636
        if (!vcc_IdIs(vim->t_mod, vim->name)) {
512 24
                vcc_ErrWhere(tl, vim->t_mod);
513 48
                VSB_printf(tl->sb, "Wrong file for VMOD %.*s\n",
514 24
                    PF(vim->t_mod));
515 24
                VSB_printf(tl->sb, "\tFile name: %s\n", vim->path);
516 24
                VSB_printf(tl->sb, "\tContains vmod \"%s\"\n", vim->name);
517 24
                vcc_vim_destroy(&vim);
518 24
                return;
519
        }
520
521 6612
        vimold = msym->import;
522 6612
        if (vimold != NULL) {
523 36
                CHECK_OBJ(vimold, VMOD_IMPORT_MAGIC);
524 36
                if (!strcmp(vimold->file_id, vim->file_id)) {
525
                        /* Identical import is OK */
526 24
                } else {
527 24
                        VSB_printf(tl->sb,
528
                            "Another module already imported as %.*s.\n",
529 12
                            PF(tmod));
530 12
                        vcc_ErrWhere2(tl, t1, tl->t);
531
                }
532 36
                vcc_vim_destroy(&vim);
533 36
                return;
534
        }
535 6576
        msym->def_b = t1;
536 6576
        msym->def_e = tl->t;
537
538 8208
        VTAILQ_FOREACH(vsym, &tl->sym_vmods, sideways) {
539 1644
                assert(vsym->kind == SYM_VMOD);
540 1644
                vimold = vsym->import;
541 1644
                CHECK_OBJ_NOTNULL(vimold, VMOD_IMPORT_MAGIC);
542 1644
                if (!strcmp(vimold->file_id, vim->file_id)) {
543
                        /* Already loaded under different name */
544 12
                        msym->eval_priv = vsym->eval_priv;
545 12
                        msym->import = vsym->import;
546 12
                        msym->vmod_name = vsym->vmod_name;
547 12
                        vcc_VmodSymbols(tl, msym);
548 12
                        AZ(tl->err);
549
                        // XXX: insert msym in sideways ?
550 12
                        vcc_vim_destroy(&vim);
551 12
                        return;
552
                }
553 1632
        }
554
555 6564
        VTAILQ_INSERT_TAIL(&tl->sym_vmods, msym, sideways);
556
557 6564
        msym->eval_priv = vim->vj;
558 6564
        msym->import = vim;
559 6564
        msym->vmod_name = TlDup(tl, vim->name);
560 6564
        vcc_VmodSymbols(tl, msym);
561 6564
        ERRCHK(tl);
562
563 6552
        vcc_emit_setup(tl, vim);
564 6840
}
565
566
void
567 12
vcc_ImportVext(struct vcc *tl, const char *filename)
568
{
569
        struct vmod_import *vim;
570
571 12
        ALLOC_OBJ(vim, VMOD_IMPORT_MAGIC);
572 12
        AN(vim);
573
574 12
        if (vcc_Extract_JSON(vim, filename)) {
575 0
                FREE_OBJ(vim);
576 0
                return;
577
        }
578 12
        fprintf(stderr, "FOUND VMOD in VEXT %s\n", filename);
579 12
        if (vcc_VmodLoad(tl, vim) < 0 || tl->err) {
580
                // vcc_ErrWhere(tl, vim->t_mod);
581 0
                vcc_vim_destroy(&vim);
582 0
                return;
583
        }
584 12
        vim->from_vext = 1;
585 12
        vim->unimported_vext = 1;
586 12
        vim->path = strdup(filename);
587 12
        vim->path += 1;
588 12
        AN(vim->path);
589 12
        fprintf(stderr, "GOOD VMOD %s in VEXT %s\n", vim->name, filename);
590 12
}