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