source: lib/libvarnishapi/vsl_arg.c @ 6e6edd

Revision 6e6edd, 6.6 KB checked in by Poul-Henning Kamp <phk@…>, 3 years ago (diff)

Complete (?) the varnish API #include cleanup.

We now have

<vapi/vs[mcl].h> for the programmatic API

<vapi/vs[cl]_int.h> for the underlying structure,

shared between API and varnishd

  • Property mode set to 100644
Line 
1/*-
2 * Copyright (c) 2006 Verdens Gang AS
3 * Copyright (c) 2006-2011 Varnish Software AS
4 * All rights reserved.
5 *
6 * Author: Poul-Henning Kamp <phk@phk.freebsd.dk>
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 "vapi/vsm.h"
33#include "vapi/vsl.h"
34
35#include <sys/types.h>
36#include <sys/stat.h>
37
38#include <ctype.h>
39#include <errno.h>
40#include <fcntl.h>
41#include <stdio.h>
42#include <stdlib.h>
43#include <string.h>
44#include <unistd.h>
45
46#include "vas.h"
47#include "vre.h"
48#include "vbm.h"
49#include "miniobj.h"
50
51#include "vsm_api.h"
52#include "vsl_api.h"
53
54/*--------------------------------------------------------------------
55 * Look up a tag
56 *   0..255     tag number
57 *   -1         no tag matches
58 *   -2         multiple tags match
59 */
60
61int
62VSL_Name2Tag(const char *name, int l)
63{
64        int i, n;
65
66        if (l == -1)
67                l = strlen(name);
68        n = -1;
69        for (i = 0; i < 256; i++) {
70                if (VSL_tags[i] != NULL &&
71                    !strncasecmp(name, VSL_tags[i], l)) {
72                        if (n == -1)
73                                n = i;
74                        else
75                                n = -2;
76                }
77        }
78        return (n);
79}
80
81
82/*--------------------------------------------------------------------*/
83
84static int
85vsl_r_arg(const struct VSM_data *vd, const char *opt)
86{
87
88        CHECK_OBJ_NOTNULL(vd, VSM_MAGIC);
89        if (!strcmp(opt, "-"))
90                vd->vsl->r_fd = STDIN_FILENO;
91        else
92                vd->vsl->r_fd = open(opt, O_RDONLY);
93        if (vd->vsl->r_fd < 0) {
94                perror(opt);
95                return (-1);
96        }
97        return (1);
98}
99
100/*--------------------------------------------------------------------*/
101
102static int
103vsl_IX_arg(const struct VSM_data *vd, const char *opt, int arg)
104{
105        vre_t **rp;
106        const char *error;
107        int erroroffset;
108
109        CHECK_OBJ_NOTNULL(vd, VSM_MAGIC);
110        if (arg == 'I')
111                rp = &vd->vsl->regincl;
112        else
113                rp = &vd->vsl->regexcl;
114        if (*rp != NULL) {
115                fprintf(stderr, "Option %c can only be given once", arg);
116                return (-1);
117        }
118        *rp = VRE_compile(opt, vd->vsl->regflags, &error, &erroroffset);
119        if (*rp == NULL) {
120                fprintf(stderr, "Illegal regex: %s\n", error);
121                return (-1);
122        }
123        return (1);
124}
125
126/*--------------------------------------------------------------------*/
127
128static int
129vsl_ix_arg(const struct VSM_data *vd, const char *opt, int arg)
130{
131        int i, l;
132        const char *b, *e;
133
134        CHECK_OBJ_NOTNULL(vd, VSM_MAGIC);
135        /* If first option is 'i', set all bits for supression */
136        if (arg == 'i' && !(vd->vsl->flags & F_SEEN_IX))
137                for (i = 0; i < 256; i++)
138                        vbit_set(vd->vsl->vbm_supress, i);
139        vd->vsl->flags |= F_SEEN_IX;
140
141        for (b = opt; *b; b = e) {
142                while (isspace(*b))
143                        b++;
144                e = strchr(b, ',');
145                if (e == NULL)
146                        e = strchr(b, '\0');
147                l = e - b;
148                if (*e == ',')
149                        e++;
150                while (isspace(b[l - 1]))
151                        l--;
152                i = VSL_Name2Tag(b, l);
153                if (i >= 0) {
154                        if (arg == 'x')
155                                vbit_set(vd->vsl->vbm_supress, i);
156                        else
157                                vbit_clr(vd->vsl->vbm_supress, i);
158                } else if (i == -2) {
159                        fprintf(stderr,
160                            "\"%*.*s\" matches multiple tags\n", l, l, b);
161                        return (-1);
162                } else {
163                        fprintf(stderr,
164                            "Could not match \"%*.*s\" to any tag\n", l, l, b);
165                        return (-1);
166                }
167        }
168        return (1);
169}
170
171/*--------------------------------------------------------------------*/
172
173
174static int
175vsl_m_arg(const struct VSM_data *vd, const char *opt)
176{
177        struct vsl_re_match *m;
178        const char *error;
179        char *o, *regex;
180        int erroroffset;
181
182        CHECK_OBJ_NOTNULL(vd, VSM_MAGIC);
183
184        if (!strchr(opt, ':')) {
185                fprintf(stderr, "No : found in -o option %s\n", opt);
186                return (-1);
187        }
188
189        o = strdup(opt);
190        AN(o);
191        regex = strchr(o, ':');
192        *regex = '\0';
193        regex++;
194
195        ALLOC_OBJ(m, VSL_RE_MATCH_MAGIC);
196        AN(m);
197        m->tag = VSL_Name2Tag(o, -1);
198        if (m->tag < 0) {
199                fprintf(stderr, "Illegal tag %s specified\n", o);
200                free(o);
201                FREE_OBJ(m);
202                return (-1);
203        }
204        /* Get tag, regex */
205        m->re = VRE_compile(regex, vd->vsl->regflags, &error, &erroroffset);
206        if (m->re == NULL) {
207                fprintf(stderr, "Illegal regex: %s\n", error);
208                free(o);
209                FREE_OBJ(m);
210                return (-1);
211        }
212        vd->vsl->num_matchers++;
213        VTAILQ_INSERT_TAIL(&vd->vsl->matchers, m, next);
214        free(o);
215        return (1);
216}
217
218/*--------------------------------------------------------------------*/
219
220static int
221vsl_s_arg(const struct VSM_data *vd, const char *opt)
222{
223        char *end;
224
225        CHECK_OBJ_NOTNULL(vd, VSM_MAGIC);
226        if (*opt == '\0') {
227                fprintf(stderr, "number required for -s\n");
228                return (-1);
229        }
230        vd->vsl->skip = strtoul(opt, &end, 10);
231        if (*end != '\0') {
232                fprintf(stderr, "invalid number for -s\n");
233                return (-1);
234        }
235        return (1);
236}
237
238/*--------------------------------------------------------------------*/
239
240static int
241vsl_k_arg(const struct VSM_data *vd, const char *opt)
242{
243        char *end;
244
245        CHECK_OBJ_NOTNULL(vd, VSM_MAGIC);
246        if (*opt == '\0') {
247                fprintf(stderr, "number required for -k\n");
248                return (-1);
249        }
250        vd->vsl->keep = strtoul(opt, &end, 10);
251        if (*end != '\0') {
252                fprintf(stderr, "invalid number for -k\n");
253                return (-1);
254        }
255        return (1);
256}
257
258/*--------------------------------------------------------------------*/
259
260int
261VSL_Arg(struct VSM_data *vd, int arg, const char *opt)
262{
263
264        CHECK_OBJ_NOTNULL(vd, VSM_MAGIC);
265        switch (arg) {
266        case 'b': vd->vsl->b_opt = !vd->vsl->b_opt; return (1);
267        case 'c': vd->vsl->c_opt = !vd->vsl->c_opt; return (1);
268        case 'd':
269                vd->vsl->d_opt = !vd->vsl->d_opt;
270                vd->vsl->flags |= F_NON_BLOCKING;
271                return (1);
272        case 'i': case 'x': return (vsl_ix_arg(vd, opt, arg));
273        case 'k': return (vsl_k_arg(vd, opt));
274        case 'n': return (VSM_n_Arg(vd, opt));
275        case 'r': return (vsl_r_arg(vd, opt));
276        case 's': return (vsl_s_arg(vd, opt));
277        case 'I': case 'X': return (vsl_IX_arg(vd, opt, arg));
278        case 'm': return (vsl_m_arg(vd, opt));
279        case 'C': vd->vsl->regflags = VRE_CASELESS; return (1);
280        default:
281                return (0);
282        }
283}
Note: See TracBrowser for help on using the repository browser.