varnish-cache/lib/libvarnish/vcli_serve.c
0
/*-
1
 * Copyright (c) 2006 Verdens Gang AS
2
 * Copyright (c) 2006-2011 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
 * Stuff for handling the CLI protocol
31
 */
32
33
#include "config.h"
34
35
#include <time.h>
36
#include <ctype.h>
37
#include <poll.h>
38
#include <stdarg.h>
39
#include <stdint.h>
40
#include <stdio.h>
41
#include <stdlib.h>
42
#include <string.h>
43
#include <unistd.h>
44
45
#include "vdef.h"
46
#include "vas.h"
47
#include "vqueue.h"
48
#include "miniobj.h"
49
50
#include "vav.h"
51
#include "vcli_serve.h"
52
#include "vsb.h"
53
#include "vtim.h"
54
55
struct VCLS_fd {
56
        unsigned                        magic;
57
#define VCLS_FD_MAGIC                   0x010dbd1e
58
        VTAILQ_ENTRY(VCLS_fd)           list;
59
        int                             fdi, fdo;
60
        struct VCLS                     *cls;
61
        struct cli                      *cli, clis;
62
        cls_cb_f                        *closefunc;
63
        void                            *priv;
64
        struct vsb                      *last_arg;
65
        char                            **argv;
66
        int                             argc;
67
        char                            *match;
68
};
69
70
struct VCLS {
71
        unsigned                        magic;
72
#define VCLS_MAGIC                      0x60f044a3
73
        VTAILQ_HEAD(,VCLS_fd)           fds;
74
        unsigned                        nfd;
75
        VTAILQ_HEAD(,cli_proto)         funcs;
76
        cls_cbc_f                       *before, *after;
77
        volatile unsigned               *limit;
78
        struct cli_proto                *wildcard;
79
};
80
81
/*--------------------------------------------------------------------*/
82
83
void v_matchproto_(cli_func_t)
84 6
VCLS_func_close(struct cli *cli, const char *const *av, void *priv)
85
{
86
87 6
        (void)av;
88 6
        (void)priv;
89 6
        VCLI_Out(cli, "Closing CLI connection");
90 6
        VCLI_SetResult(cli, CLIS_CLOSE);
91 6
}
92
93
/*--------------------------------------------------------------------*/
94
95
void v_matchproto_(cli_func_t)
96 483
VCLS_func_ping(struct cli *cli, const char * const *av, void *priv)
97
{
98
        time_t t;
99
100 483
        (void)av;
101 483
        (void)priv;
102 483
        t = time(NULL);
103 483
        VCLI_Out(cli, "PONG %jd 1.0", (intmax_t)t);
104 483
}
105
106
void v_matchproto_(cli_func_t)
107 4
VCLS_func_ping_json(struct cli *cli, const char * const *av, void *priv)
108
{
109 4
        (void)av;
110 4
        (void)priv;
111 4
        VCLI_JSON_begin(cli, 2, av);
112 4
        VCLI_Out(cli, ", \"PONG\"\n");
113 4
        VCLI_JSON_end(cli);
114 4
}
115
116
/*--------------------------------------------------------------------*/
117
118
static void
119 466
help_helper(struct cli *cli, struct cli_proto *clp, const char * const *av)
120
{
121 466
        AN(clp->desc->syntax);
122 466
        if (av[0] != NULL)
123 6
                VCLI_Out(cli, "%s\n%s\n", clp->desc->syntax, clp->desc->help);
124
        else
125 460
                VCLI_Out(cli, "%s\n", clp->desc->syntax);
126 466
}
127
128
void v_matchproto_(cli_func_t)
129 36
VCLS_func_help(struct cli *cli, const char * const *av, void *priv)
130
{
131
        struct cli_proto *clp;
132 36
        unsigned filter = 1, d;
133
        struct VCLS *cs;
134
135 36
        (void)priv;
136 36
        cs = cli->cls;
137 36
        CHECK_OBJ_NOTNULL(cs, VCLS_MAGIC);
138
139 44
        for (av += 2; av[0] != NULL && av[0][0] == '-'; av++) {
140 12
                if (!strcmp(av[0], "-a")) {
141 4
                        filter = 3;
142 12
                } else if (!strcmp(av[0], "-d")) {
143 4
                        filter = 2;
144 4
                } else {
145 4
                        VCLI_Out(cli, "Unknown flag\n");
146 4
                        VCLI_SetResult(cli, CLIS_UNKNOWN);
147 4
                        return;
148
                }
149 8
        }
150 874
        VTAILQ_FOREACH(clp, &cs->funcs, list) {
151 848
                if (clp->auth > cli->auth)
152 0
                        continue;
153 848
                if (av[0] != NULL && !strcmp(clp->desc->request, av[0])) {
154 6
                        help_helper(cli, clp, av);
155 6
                        return;
156 842
                } else if (av[0] == NULL) {
157 628
                        d = strchr(clp->flags, 'd') != NULL ? 2 : 1;
158 628
                        if (filter & d)
159 460
                                help_helper(cli, clp, av);
160 628
                }
161 842
        }
162 26
        if (av[0] != NULL) {
163 4
                VCLI_Out(cli, "Unknown request.\nType 'help' for more info.\n");
164 4
                VCLI_SetResult(cli, CLIS_UNKNOWN);
165 4
        }
166 36
}
167
168
void v_matchproto_(cli_func_t)
169 12
VCLS_func_help_json(struct cli *cli, const char * const *av, void *priv)
170
{
171
        struct cli_proto *clp;
172
        struct VCLS *cs;
173
174 12
        (void)priv;
175 12
        cs = cli->cls;
176 12
        CHECK_OBJ_NOTNULL(cs, VCLS_MAGIC);
177
178 12
        VCLI_JSON_begin(cli, 2, av);
179 468
        VTAILQ_FOREACH(clp, &cs->funcs, list) {
180 456
                if (clp->auth > cli->auth)
181 0
                        continue;
182 456
                VCLI_Out(cli, ",\n  {\n");
183 456
                VSB_indent(cli->sb, 2);
184 456
                VCLI_Out(cli, "\"request\": ");
185 456
                VCLI_JSON_str(cli, clp->desc->request);
186 456
                VCLI_Out(cli, ",\n");
187 456
                VCLI_Out(cli, "\"syntax\": ");
188 456
                VCLI_JSON_str(cli, clp->desc->syntax);
189 456
                VCLI_Out(cli, ",\n");
190 456
                VCLI_Out(cli, "\"help\": ");
191 456
                VCLI_JSON_str(cli, clp->desc->help);
192 456
                VCLI_Out(cli, ",\n");
193 456
                VCLI_Out(cli, "\"minarg\": %d", clp->desc->minarg);
194 456
                VCLI_Out(cli, ",\n");
195 456
                VCLI_Out(cli, "\"maxarg\": %d", clp->desc->maxarg);
196 456
                VCLI_Out(cli, ",\n");
197 456
                VCLI_Out(cli, "\"flags\": ");
198 456
                VCLI_JSON_str(cli, clp->flags);
199 456
                VCLI_Out(cli, ",\n");
200 912
                VCLI_Out(cli, "\"json\": %s",
201 456
                    clp->jsonfunc == NULL ? "false" : "true");
202 456
                VCLI_Out(cli, "\n");
203 456
                VSB_indent(cli->sb, -2);
204 456
                VCLI_Out(cli, "}");
205 456
        }
206 12
        VCLI_JSON_end(cli);
207 12
}
208
209
/*--------------------------------------------------------------------
210
 * Look for a CLI command to execute
211
 */
212
213
static void
214 42855
cls_dispatch(struct cli *cli, struct VCLS *cs, char * const * av, int ac)
215
{
216 42855
        int json = 0;
217
        struct cli_proto *cp;
218
219 42855
        AN(av);
220 42855
        assert(ac >= 0);
221 42855
        AZ(av[0]);
222 42855
        AN(av[1]);
223
224 782185
        VTAILQ_FOREACH(cp, &cs->funcs, list) {
225 773933
                if (cp->auth > cli->auth)
226 0
                        continue;
227 773933
                if (!strcmp(cp->desc->request, av[1]))
228 34603
                        break;
229 739330
        }
230
231 42855
        if (cp == NULL && cs->wildcard && cs->wildcard->auth <= cli->auth)
232 8250
                cp = cs->wildcard;
233
234 42855
        if (cp == NULL) {
235 2
                VCLI_Out(cli, "Unknown request.\nType 'help' for more info.\n");
236 2
                return;
237
        }
238
239 42853
        VSB_clear(cli->sb);
240
241 42853
        if (ac > 1 && !strcmp(av[2], "-j"))
242 160
                json = 1;
243
244 42853
        if (cp->func == NULL && !json) {
245 0
                VCLI_Out(cli, "Unimplemented\n");
246 0
                VCLI_SetResult(cli, CLIS_UNIMPL);
247 0
                return;
248
        }
249 42853
        if (cp->jsonfunc == NULL && json) {
250 2
                VCLI_Out(cli, "JSON unimplemented\n");
251 2
                VCLI_SetResult(cli, CLIS_UNIMPL);
252 2
                return;
253
        }
254
255 42851
        if (ac - 1 < cp->desc->minarg + json) {
256 8
                VCLI_Out(cli, "Too few parameters\n");
257 8
                VCLI_SetResult(cli, CLIS_TOOFEW);
258 8
                return;
259
        }
260
261 42843
        if (cp->desc->maxarg >= 0 && ac - 1 > cp->desc->maxarg + json) {
262 4
                VCLI_Out(cli, "Too many parameters\n");
263 4
                VCLI_SetResult(cli, CLIS_TOOMANY);
264 4
                return;
265
        }
266
267 42839
        cli->result = CLIS_OK;
268 42839
        cli->cls = cs;
269 42839
        if (json)
270 158
                cp->jsonfunc(cli, (const char * const *)av, cp->priv);
271
        else
272 42681
                cp->func(cli, (const char * const *)av, cp->priv);
273 42839
        cli->cls = NULL;
274 42855
}
275
276
/*--------------------------------------------------------------------
277
 * We have collected a full cli line, parse it and execute, if possible.
278
 */
279
280
static int
281 42867
cls_exec(struct VCLS_fd *cfd, char * const *av, int ac)
282
{
283
        struct VCLS *cs;
284
        struct cli *cli;
285
        ssize_t len;
286
        char *s;
287
        unsigned lim;
288 42867
        int retval = 0;
289
290 42867
        CHECK_OBJ_NOTNULL(cfd, VCLS_FD_MAGIC);
291 42867
        cs = cfd->cls;
292 42867
        CHECK_OBJ_NOTNULL(cs, VCLS_MAGIC);
293
294 42867
        cli = cfd->cli;
295 42867
        CHECK_OBJ_NOTNULL(cli, CLI_MAGIC);
296 42867
        AN(cli->cmd);
297
298 42867
        cli->result = CLIS_UNKNOWN;
299 42867
        VSB_clear(cli->sb);
300
301 42867
        if (cs->before != NULL)
302 42867
                cs->before(cli);
303
304 42867
        do {
305 42867
                if (av[0] != NULL) {
306 4
                        VCLI_Out(cli, "Syntax Error: %s\n", av[0]);
307 4
                        VCLI_SetResult(cli, CLIS_SYNTAX);
308 4
                        break;
309
                }
310
311 42863
                if (av[1] == NULL) {
312 2
                        VCLI_Out(cli, "Empty CLI command.\n");
313 2
                        VCLI_SetResult(cli, CLIS_SYNTAX);
314 2
                        break;
315
                }
316
317 42861
                if (!islower(av[1][0])) {
318 6
                        VCLI_Out(cli, "All commands are in lower-case.\n");
319 6
                        VCLI_SetResult(cli, CLIS_UNKNOWN);
320 6
                        break;
321
                }
322
323 42855
                cls_dispatch(cli, cs, av, ac);
324
325 42855
        } while (0);
326
327 42867
        AZ(VSB_finish(cli->sb));
328
329 42867
        if (cs->after != NULL)
330 42863
                cs->after(cli);
331
332 42867
        s = VSB_data(cli->sb);
333 42867
        len = VSB_len(cli->sb);
334 42867
        lim = *cs->limit;
335 42867
        if (len > lim) {
336 10
                if (cli->result == CLIS_OK)
337 0
                        cli->result = CLIS_TRUNCATED;
338 10
                s[lim - 1] = '\0';
339 10
                assert(strlen(s) <= lim);
340 10
        }
341 42867
        if (VCLI_WriteResult(cfd->fdo, cli->result, s) ||
342 42861
            cli->result == CLIS_CLOSE)
343 6
                retval = 1;
344
345
        /*
346
         * In unauthenticated mode we are very intolerant, and close the
347
         * connection at the least provocation.
348
         */
349 42867
        if (cli->auth == 0 && cli->result != CLIS_OK)
350 0
                retval = 1;
351
352 42867
        return (retval);
353
}
354
355
static int
356 68086
cls_feed(struct VCLS_fd *cfd, const char *p, const char *e)
357
{
358
        struct cli *cli;
359 68086
        int i, retval = 0, ac;
360
        char **av, *q;
361
362 68086
        CHECK_OBJ_NOTNULL(cfd, VCLS_FD_MAGIC);
363 68086
        AN(p);
364 68086
        assert(e > p);
365
366 68086
        cli = cfd->cli;
367 68086
        CHECK_OBJ_NOTNULL(cli, CLI_MAGIC);
368
369 1891242
        for (;p < e; p++) {
370 1823162
                if (cli->cmd == NULL && isspace(*p)) {
371
                        /* Ignore all leading space before cmd */
372 4908
                        continue;
373
                }
374 1818254
                if (cfd->argv == NULL) {
375
376
                        /* Collect first line up to \n or \r */
377 881205
                        if (cli->cmd == NULL) {
378 42871
                                cli->cmd = VSB_new_auto();
379 42871
                                AN(cli->cmd);
380 42871
                        }
381
382
                        /* Until authenticated, limit length hard */
383 1018929
                        if (*p != '\n' && *p != '\r' &&
384 838342
                            (cli->auth > 0 || VSB_len(cli->cmd) < 80)) {
385 838342
                                VSB_putc(cli->cmd, *p);
386 838342
                                continue;
387
                        }
388
389 42863
                        AZ(VSB_finish(cli->cmd));
390
391
                        /* Ignore leading '-' */
392 42863
                        q = VSB_data(cli->cmd);
393 42863
                        if (*q == '-')
394 8
                                q++;
395 42863
                        av = VAV_Parse(q, &ac, 0);
396 42863
                        AN(av);
397
398 45847
                        if (cli->auth > 0 &&
399 40873
                            av[0] == NULL &&
400 40869
                            ac >= 3 &&
401 16560
                            !strcmp(av[ac-2], "<<") &&
402 2984
                            *av[ac - 1] != '\0') {
403
                                /* Go to "<< nonce" mode */
404 2984
                                cfd->argv = av;
405 2984
                                cfd->argc = ac;
406 2984
                                cfd->match = av[ac - 1];
407 2984
                                cfd->last_arg = VSB_new_auto();
408 2984
                                AN(cfd->last_arg);
409 2984
                        } else {
410
                                /* Plain command */
411 39879
                                i = cls_exec(cfd, av, ac - 1);
412 39879
                                VAV_Free(av);
413 39879
                                VSB_destroy(&cli->cmd);
414 39879
                                if (i)
415 6
                                        return (i);
416
                        }
417 42857
                } else {
418
                        /* "<< nonce" mode */
419 937049
                        AN(cfd->argv);
420 937049
                        AN(cfd->argc);
421 937049
                        AN(cfd->match);
422 937049
                        AN(cfd->last_arg);
423 937049
                        if (*cfd->match == '\0' && (*p == '\r' || *p == '\n')) {
424 2982
                                AZ(VSB_finish(cfd->last_arg));
425
                                // NB: VAV lib internals trusted
426 2982
                                cfd->match = NULL;
427 2982
                                REPLACE(cfd->argv[cfd->argc - 1], NULL);
428 2982
                                REPLACE(cfd->argv[cfd->argc - 2], NULL);
429 2982
                                cfd->argv[cfd->argc - 2] =
430 2982
                                    VSB_data(cfd->last_arg);
431 2982
                                i = cls_exec(cfd, cfd->argv, cfd->argc - 2);
432 2982
                                cfd->argv[cfd->argc - 2] = NULL;
433 2982
                                VAV_Free(cfd->argv);
434 2982
                                cfd->argv = NULL;
435 2982
                                VSB_destroy(&cfd->last_arg);
436 2982
                                VSB_destroy(&cli->cmd);
437 2982
                                if (i)
438 0
                                        return (i);
439 937049
                        } else if (*p == *cfd->match) {
440 53346
                                cfd->match++;
441 934067
                        } else if (cfd->match != cfd->argv[cfd->argc - 1]) {
442 5686
                                q = cfd->argv[cfd->argc - 1];
443 5686
                                VSB_bcat(cfd->last_arg, q, cfd->match - q);
444 5686
                                cfd->match = q;
445 5686
                                VSB_putc(cfd->last_arg, *p);
446 5686
                        } else {
447 875035
                                VSB_putc(cfd->last_arg, *p);
448
                        }
449
                }
450 979906
        }
451 68080
        return (retval);
452 68086
}
453
454
struct VCLS *
455 3995
VCLS_New(struct VCLS *model)
456
{
457
        struct VCLS *cs;
458
459 3995
        CHECK_OBJ_ORNULL(model, VCLS_MAGIC);
460
461 3995
        ALLOC_OBJ(cs, VCLS_MAGIC);
462 3995
        AN(cs);
463 3995
        VTAILQ_INIT(&cs->fds);
464 3995
        VTAILQ_INIT(&cs->funcs);
465 3995
        if (model != NULL)
466 1893
                VTAILQ_CONCAT(&cs->funcs, &model->funcs, list);
467 3995
        return (cs);
468
}
469
470
void
471 3859
VCLS_SetLimit(struct VCLS *cs, volatile unsigned *limit)
472
{
473 3859
        CHECK_OBJ_NOTNULL(cs, VCLS_MAGIC);
474 3859
        cs->limit = limit;
475 3859
}
476
477
void
478 3995
VCLS_SetHooks(struct VCLS *cs, cls_cbc_f *before, cls_cbc_f *after)
479
{
480
481 3995
        CHECK_OBJ_NOTNULL(cs, VCLS_MAGIC);
482 3995
        cs->before = before;
483 3995
        cs->after = after;
484 3995
}
485
486
struct cli *
487 5810
VCLS_AddFd(struct VCLS *cs, int fdi, int fdo, cls_cb_f *closefunc, void *priv)
488
{
489
        struct VCLS_fd *cfd;
490
491 5810
        CHECK_OBJ_NOTNULL(cs, VCLS_MAGIC);
492 5810
        assert(fdi >= 0);
493 5810
        assert(fdo >= 0);
494 5810
        ALLOC_OBJ(cfd, VCLS_FD_MAGIC);
495 5810
        AN(cfd);
496 5810
        cfd->cls = cs;
497 5810
        cfd->fdi = fdi;
498 5810
        cfd->fdo = fdo;
499 5810
        cfd->cli = &cfd->clis;
500 5810
        cfd->cli->magic = CLI_MAGIC;
501 5810
        cfd->cli->sb = VSB_new_auto();
502 5810
        AN(cfd->cli->sb);
503 5810
        cfd->cli->limit = cs->limit;
504 5810
        cfd->cli->priv = priv;
505 5810
        cfd->closefunc = closefunc;
506 5810
        cfd->priv = priv;
507 5810
        VTAILQ_INSERT_TAIL(&cs->fds, cfd, list);
508 5810
        cs->nfd++;
509 5810
        return (cfd->cli);
510
}
511
512
static int
513 5790
cls_close_fd(struct VCLS *cs, struct VCLS_fd *cfd)
514
{
515 5790
        int retval = 0;
516
517 5790
        CHECK_OBJ_NOTNULL(cs, VCLS_MAGIC);
518 5790
        CHECK_OBJ_NOTNULL(cfd, VCLS_FD_MAGIC);
519
520 5790
        VTAILQ_REMOVE(&cs->fds, cfd, list);
521 5790
        if (cfd->match != NULL) {
522 4
                cfd->cli->result = CLIS_TRUNCATED;
523 4
                if (cs->after != NULL)
524 2
                        cs->after(cfd->cli);
525 4
                VSB_destroy(&cfd->last_arg);
526 5790
        } else if (cfd->cli->cmd != NULL) {
527 4
                (void)VSB_finish(cfd->cli->cmd);
528 4
                cfd->cli->result = CLIS_TRUNCATED;
529 4
                if (cs->after != NULL)
530 2
                        cs->after(cfd->cli);
531 4
                VSB_destroy(&cfd->cli->cmd);
532 4
        }
533 5782
        cs->nfd--;
534 5782
        VSB_destroy(&cfd->cli->sb);
535 5782
        if (cfd->closefunc != NULL)
536 3832
                retval = cfd->closefunc(cfd->priv);
537 5782
        (void)close(cfd->fdi);
538 5782
        if (cfd->fdo != cfd->fdi)
539 1918
                (void)close(cfd->fdo);
540 5782
        if (cfd->cli->ident != NULL)
541 3914
                free(cfd->cli->ident);
542 5782
        FREE_OBJ(cfd);
543 5782
        return (retval);
544
}
545
546
void
547 37251
VCLS_AddFunc(struct VCLS *cs, unsigned auth, struct cli_proto *clp)
548
{
549
        struct cli_proto *clp2;
550
        int i;
551
552 37251
        CHECK_OBJ_NOTNULL(cs, VCLS_MAGIC);
553 37251
        AN(clp);
554
555 131259
        for (;clp->desc != NULL; clp++) {
556 94008
                clp->auth = auth;
557 94008
                if (!strcmp(clp->desc->request, "*")) {
558 2102
                        cs->wildcard = clp;
559 2102
                } else {
560 91906
                        i = 0;
561 970186
                        VTAILQ_FOREACH(clp2, &cs->funcs, list) {
562 1915976
                                i = strcmp(clp->desc->request,
563 957988
                                    clp2->desc->request);
564 957988
                                if (i <= 0)
565 79708
                                        break;
566 878280
                        }
567 91906
                        if (clp2 != NULL && i == 0) {
568 17033
                                VTAILQ_INSERT_BEFORE(clp2, clp, list);
569 17033
                                VTAILQ_REMOVE(&cs->funcs, clp2, list);
570 91906
                        } else if (clp2 != NULL)
571 62675
                                VTAILQ_INSERT_BEFORE(clp2, clp, list);
572
                        else
573 12198
                                VTAILQ_INSERT_TAIL(&cs->funcs, clp, list);
574
                }
575 94008
        }
576 37251
}
577
578
int
579 73763
VCLS_Poll(struct VCLS *cs, const struct cli *cli, int timeout)
580
{
581
        struct VCLS_fd *cfd;
582
        struct pollfd pfd[1];
583
        int i, j, k;
584
        char buf[BUFSIZ];
585
586 73763
        CHECK_OBJ_NOTNULL(cs, VCLS_MAGIC);
587 73763
        if (cs->nfd == 0) {
588 0
                errno = 0;
589 0
                return (-1);
590
        }
591 73763
        assert(cs->nfd > 0);
592
593 73763
        i = 0;
594 128096
        VTAILQ_FOREACH(cfd, &cs->fds, list) {
595 128082
                if (cfd->cli != cli)
596 54333
                        continue;
597 73749
                pfd[i].fd = cfd->fdi;
598 73749
                pfd[i].events = POLLIN;
599 73749
                pfd[i].revents = 0;
600 73749
                i++;
601 73749
                break;
602
        }
603 73763
        assert(i == 1);
604 73735
        CHECK_OBJ_NOTNULL(cfd, VCLS_FD_MAGIC);
605
606 73735
        j = poll(pfd, 1, timeout);
607 73735
        if (j <= 0)
608 0
                return (j);
609 73735
        if (pfd[0].revents & POLLHUP)
610 3780
                k = 1;
611
        else {
612 69955
                i = read(cfd->fdi, buf, sizeof buf);
613 69955
                if (i <= 0)
614 1863
                        k = 1;
615
                else
616 68092
                        k = cls_feed(cfd, buf, buf + i);
617
        }
618 73735
        if (k) {
619 5645
                i = cls_close_fd(cs, cfd);
620 5645
                if (i < 0)
621 1914
                        k = i;
622 5645
        }
623 73735
        return (k);
624 73735
}
625
626
void
627 1922
VCLS_Destroy(struct VCLS **csp)
628
{
629
        struct VCLS *cs;
630
        struct VCLS_fd *cfd, *cfd2;
631
        struct cli_proto *clp;
632
633 1922
        TAKE_OBJ_NOTNULL(cs, csp, VCLS_MAGIC);
634 2059
        VTAILQ_FOREACH_SAFE(cfd, &cs->fds, list, cfd2)
635 137
                (void)cls_close_fd(cs, cfd);
636
637 49972
        while (!VTAILQ_EMPTY(&cs->funcs)) {
638 48050
                clp = VTAILQ_FIRST(&cs->funcs);
639 48050
                VTAILQ_REMOVE(&cs->funcs, clp, list);
640
        }
641 1922
        FREE_OBJ(cs);
642 1922
}
643
644
/**********************************************************************
645
 * Utility functions for implementing CLI commands
646
 */
647
648
static void
649 218525
vcli_outv(struct cli *cli, const char *fmt, va_list ap)
650
{
651
652 218525
        if (VSB_len(cli->sb) < *cli->limit)
653 216189
                (void)VSB_vprintf(cli->sb, fmt, ap);
654 2336
        else if (cli->result == CLIS_OK)
655 10
                cli->result = CLIS_TRUNCATED;
656 218525
}
657
658
/*lint -e{818} cli could be const */
659
void
660 197059
VCLI_Out(struct cli *cli, const char *fmt, ...)
661
{
662
        va_list ap;
663
664 197059
        CHECK_OBJ_NOTNULL(cli, CLI_MAGIC);
665 197059
        AN(fmt);
666
667 197059
        va_start(ap, fmt);
668 197059
        vcli_outv(cli, fmt, ap);
669 197059
        va_end(ap);
670 197059
}
671
672
int v_matchproto_(VTE_format_f)
673 21466
VCLI_VTE_format(void *priv, const char *fmt, ...)
674
{
675
        struct cli *cli;
676
        va_list ap;
677
678 21466
        CAST_OBJ_NOTNULL(cli, priv, CLI_MAGIC);
679 21466
        AN(fmt);
680
681 21466
        va_start(ap, fmt);
682 21466
        vcli_outv(cli, fmt, ap);
683 21466
        va_end(ap);
684
685 21466
        return (0);
686
}
687
688
/*lint -e{818} cli could be const */
689
int
690 610
VCLI_Overflow(struct cli *cli)
691
{
692 610
        CHECK_OBJ_NOTNULL(cli, CLI_MAGIC);
693 610
        if (cli->result == CLIS_TRUNCATED ||
694 610
            VSB_len(cli->sb) >= *cli->limit)
695 0
                return (1);
696 610
        return (0);
697 610
}
698
699
/*lint -e{818} cli could be const */
700
void
701 4658
VCLI_JSON_str(struct cli *cli, const char *s)
702
{
703
704 4658
        CHECK_OBJ_NOTNULL(cli, CLI_MAGIC);
705 4658
        VSB_putc(cli->sb, '"');
706 4658
        VSB_quote(cli->sb, s, -1, VSB_QUOTE_JSON);
707 4658
        VSB_putc(cli->sb, '"');
708 4658
}
709
710
/*lint -e{818} cli could be const */
711
void
712 110
VCLI_JSON_begin(struct cli *cli, unsigned ver, const char * const * av)
713
{
714
        int i;
715
716 110
        CHECK_OBJ_NOTNULL(cli, CLI_MAGIC);
717 110
        VCLI_Out(cli, "[ %u, [", ver);
718 354
        for (i = 1; av[i] != NULL; i++) {
719 244
                VCLI_JSON_str(cli, av[i]);
720 244
                if (av[i + 1] != NULL)
721 134
                        VCLI_Out(cli, ", ");
722 244
        }
723 110
        VCLI_Out(cli, "], %.3f", VTIM_real());
724 110
        VSB_indent(cli->sb, 2);
725 110
}
726
727
void
728 110
VCLI_JSON_end(struct cli *cli)
729
{
730 110
        VSB_indent(cli->sb, -2);
731 110
        VCLI_Out(cli, "\n");
732 110
        VCLI_Out(cli, "]\n");
733 110
}
734
735
/*lint -e{818} cli could be const */
736
void
737 26
VCLI_Quote(struct cli *cli, const char *s)
738
{
739
740 26
        CHECK_OBJ_NOTNULL(cli, CLI_MAGIC);
741 26
        VSB_quote(cli->sb, s, -1, 0);
742 26
}
743
744
void
745 19440
VCLI_SetResult(struct cli *cli, unsigned res)
746
{
747
748 19440
        if (cli != NULL) {
749 19440
                CHECK_OBJ_NOTNULL(cli, CLI_MAGIC);
750 19440
                if (cli->result != CLIS_TRUNCATED || res != CLIS_OK)
751 19438
                        cli->result = res;      /*lint !e64 type mismatch */
752 19440
        } else {
753 0
                printf("CLI result = %u\n", res);
754
        }
755 19440
}