Code Coverage: vinyl-cache/lib/libvcc/vcc_source.c
 
82217aa4fc7094b3610340078afaf78cd95a8ec9
 
0
/*-
1
 * Copyright (c) 2006 Verdens Gang AS
2
 * Copyright (c) 2006-2015 Varnish Software AS
3
 * All rights reserved.
4
 *
5
 * Author: Poul-Henning Kamp <phk@phk.freebsd.dk>
6
 *
7
 * SPDX-License-Identifier: BSD-2-Clause
8
 *
9
 * Redistribution and use in source and binary forms, with or without
10
 * modification, are permitted provided that the following conditions
11
 * are met:
12
 * 1. Redistributions of source code must retain the above copyright
13
 *    notice, this list of conditions and the following disclaimer.
14
 * 2. Redistributions in binary form must reproduce the above copyright
15
 *    notice, this list of conditions and the following disclaimer in the
16
 *    documentation and/or other materials provided with the distribution.
17
 *
18
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
19
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
20
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
21
 * ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
22
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
23
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
24
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
25
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
26
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
27
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
28
 * SUCH DAMAGE.
29
 */
30
31
#include "config.h"
32
33
#include <glob.h>
34
#include <stdlib.h>
35
#include <string.h>
36
#include <unistd.h>
37
38
#include "vcc_compile.h"
39
40
#include "vfil.h"
41
42
struct source *
43
vcc_new_source(const char *src, const char *kind, const char *name)
44 4929
{
45 4929
        struct source *sp;
46
47 4929
        AN(src);
48 4929
        AN(name);
49 4929
        ALLOC_OBJ(sp, SOURCE_MAGIC);
50 4929
        AN(sp);
51 4929
        REPLACE(sp->name, name);
52 4929
        sp->kind = kind;
53 4929
        sp->b = src;
54 4929
        sp->e = strchr(src, '\0');
55 4929
        VTAILQ_INIT(&sp->src_tokens);
56 4929
        return (sp);
57 4929
}
58
59
/*--------------------------------------------------------------------*/
60
61
struct source *
62
vcc_file_source(struct vcc *tl, const char *fn)
63 59
{
64 59
        char *f, *fnp;
65 59
        struct source *sp;
66
67 59
        if (!tl->unsafe_path && strchr(fn, '/') != NULL) {
68 1
                VSB_printf(tl->sb, "VCL filename '%s' is unsafe.\n", fn);
69 1
                tl->err = 1;
70 1
                return (NULL);
71 1
        }
72 58
        f = NULL;
73 58
        if (VFIL_searchpath(tl->vcl_path, NULL, &f, fn, &fnp) || f == NULL) {
74 1
                VSB_printf(tl->sb, "Cannot read file '%s' (%s)\n",
75 1
                    fnp != NULL ? fnp : fn, strerror(errno));
76 1
                free(fnp);
77 1
                tl->err = 1;
78 1
                return (NULL);
79 1
        }
80 57
        sp = vcc_new_source(f, "file", fnp);
81 57
        free(fnp);
82 57
        return (sp);
83 58
}
84
85
/*--------------------------------------------------------------------*/
86
87
static void
88
vcc_include_file(struct vcc *tl, const struct source *src_sp,
89
    const char *filename, const struct token *parent_token)
90 44
{
91 44
        struct source *sp;
92
93 44
        sp = vcc_file_source(tl, filename);
94 44
        if (sp == NULL)
95 1
                return;
96
97 43
        sp->parent = src_sp;
98 43
        sp->parent_tok = parent_token;
99 43
        vcc_lex_source(tl, sp, 0);
100 43
}
101
102
/*--------------------------------------------------------------------*/
103
104
static void
105
vcc_include_glob_file(struct vcc *tl, const struct source *src_sp,
106
    const char *filename, const struct token *parent_token)
107 5
{
108 5
        glob_t  g[1];
109 5
        unsigned u;
110 5
        int i;
111
112 5
        if (filename[0] != '/' && (filename[0] != '.' || filename[1] != '/')) {
113 1
                VSB_cat(tl->sb,
114 1
                    "+glob can only be used with absolute paths or relative "
115 1
                    "paths starting with './'\n");
116 1
                tl->err = 1;
117 1
                return;
118 1
        }
119 4
        memset(g, 0, sizeof g);
120 4
        i = glob(filename, 0, NULL, g);
121 4
        switch (i) {
122 3
        case 0:
123 8
                for (u = 0; !tl->err && u < g->gl_pathc; u++) {
124 5
                        vcc_include_file(
125 5
                            tl, src_sp, g->gl_pathv[u], parent_token);
126 5
                }
127 3
                break;
128 1
        case GLOB_NOMATCH:
129 1
                VSB_cat(tl->sb, "glob pattern matched no files.\n");
130 1
                tl->err = 1;
131 1
                break;
132 0
        default:
133 0
                VSB_printf(tl->sb, "glob(3) expansion failed (%d)\n", i);
134 0
                tl->err = 1;
135 0
                break;
136 4
        }
137 4
        globfree(g);
138 4
}
139
140
/*--------------------------------------------------------------------
141
 * NB: We cannot use vcc_ErrWhere2() on tokens which are not on the
142
 * NB: tl->tokens list.
143
 */
144
145
static struct token *
146
vcc_lex_include(struct vcc *tl, const struct source *src_sp, struct token *t)
147 53
{
148 53
        struct token *tok1;
149 53
        int i, glob_flag = 0;
150 53
        struct vsb *vsb = NULL;
151 53
        const char *filename;
152 53
        const char *p;
153
154 53
        assert(vcc_IdIs(t, "include"));
155
156 53
        tok1 = VTAILQ_NEXT(t, src_list);
157 53
        AN(tok1);
158
159 60
        while (tok1->tok != EOI) {
160 57
                t = VTAILQ_NEXT(tok1, src_list);
161 57
                AN(t);
162 57
                i = vcc_IsFlagRaw(tl, tok1, t);
163 57
                if (i < 0)
164 50
                        break;
165 7
                if (vcc_IdIs(t, "glob")) {
166 7
                        glob_flag = i;
167 7
                } else {
168 0
                        VSB_cat(tl->sb, "Unknown include flag:\n");
169 0
                        vcc_ErrWhere(tl, t);
170 0
                        return (t);
171 0
                }
172 7
                tok1 = VTAILQ_NEXT(t, src_list);
173 7
                AN(tok1);
174 7
        }
175
176 53
        if (tok1->tok != CSTR) {
177 6
                VSB_cat(tl->sb,
178 6
                    "include not followed by string constant.\n");
179 6
                vcc_ErrWhere(tl, tok1);
180 6
                return (t);
181 6
        }
182 47
        t = VTAILQ_NEXT(tok1, src_list);
183 47
        AN(t);
184
185 47
        if (t->tok != ';') {
186 1
                VSB_cat(tl->sb,
187 1
                    "include <string> not followed by semicolon.\n");
188 1
                vcc_ErrWhere(tl, tok1);
189 1
                return (t);
190 1
        }
191
192 46
        filename = tok1->dec;
193
194 46
        if (filename[0] == '.' && filename[1] == '/') {
195
                /*
196
                 * Nested include filenames, starting with "./" are
197
                 * resolved relative to the VCL file which contains
198
                 * the include directive.
199
                 */
200 10
                if (src_sp->name[0] != '/') {
201 2
                        VSB_cat(tl->sb,
202 2
                            "include \"./xxxxx\"; needs absolute "
203 2
                            "filename of including file.\n");
204 2
                        vcc_ErrWhere(tl, tok1);
205 2
                        return (t);
206 2
                }
207 8
                vsb = VSB_new_auto();
208 8
                AN(vsb);
209 8
                p = strrchr(src_sp->name, '/');
210 8
                AN(p);
211 8
                VSB_bcat(vsb, src_sp->name, p - src_sp->name);
212 8
                VSB_cat(vsb, filename + 1);
213 8
                AZ(VSB_finish(vsb));
214 8
                filename = VSB_data(vsb);
215 8
        }
216
217 44
        if (glob_flag)
218 5
                vcc_include_glob_file(tl, src_sp, filename, tok1);
219 39
        else
220 39
                vcc_include_file(tl, src_sp, filename, tok1);
221 44
        if (vsb != NULL)
222 8
                VSB_destroy(&vsb);
223 44
        if (tl->err)
224 9
                vcc_ErrWhere(tl, tok1);
225 44
        return (t);
226 46
}
227
228
void
229
vcc_lex_source(struct vcc *tl, struct source *src_sp, int eoi)
230 4929
{
231 4929
        struct token *t;
232 4929
        const struct source *sp1;
233
234 4929
        CHECK_OBJ_NOTNULL(src_sp, SOURCE_MAGIC);
235
236 4985
        for (sp1 = src_sp->parent; sp1 != NULL; sp1 = sp1->parent) {
237 58
                if (!vstrcmp(sp1->name, src_sp->name) &&
238 58
                    !vstrcmp(sp1->kind, src_sp->kind)) {
239 2
                        VSB_printf(tl->sb,
240 2
                            "Recursive use of %s \"%s\"\n\n",
241 2
                            src_sp->kind, src_sp->name);
242 2
                        tl->err = 1;
243 2
                        return;
244 2
                }
245 58
        }
246
247 4927
        VTAILQ_INSERT_TAIL(&tl->sources, src_sp, list);
248 4927
        src_sp->idx = tl->nsources++;
249
250 4927
        vcc_Lexer(tl, src_sp);
251 4927
        if (tl->err)
252 24
                return;
253 3293936
        VTAILQ_FOREACH(t, &src_sp->src_tokens, src_list) {
254 3293936
                if (!eoi && t->tok == EOI)
255 1640
                        break;
256
257
                /* Expand and lex any includes in the token string */
258 3292296
                if (t->tok == ID && vcc_IdIs(t, "include")) {
259 53
                        t = vcc_lex_include(tl, src_sp, t);
260 3292243
                } else {
261 3292243
                        VTAILQ_INSERT_TAIL(&tl->tokens, t, list);
262 3292243
                }
263 3292296
                if (tl->err)
264 18
                        return;
265 3292296
        }
266 4903
}