Code Coverage: vinyl-cache/bin/vinyltest/vtest2/src/vtc_server.c
 
82217aa4fc7094b3610340078afaf78cd95a8ec9
 
0
/*-
1
 * Copyright (c) 2008-2010 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
30
#include "config.h"
31
32
#include <sys/socket.h>
33
#include <sys/stat.h>
34
35
#include <stdio.h>
36
#include <stdlib.h>
37
#include <string.h>
38
#include <unistd.h>
39
40
#include "vsa.h"
41
#include "vtc.h"
42
43
#include "vtcp.h"
44
#include "vus.h"
45
46
struct server {
47
        unsigned                magic;
48
#define SERVER_MAGIC            0x55286619
49
        char                    *name;
50
        struct vtclog           *vl;
51
        VTAILQ_ENTRY(server)    list;
52
        struct vtc_sess         *vsp;
53
        char                    run;
54
55
        char                    *spec;
56
57
        int                     depth;
58
        int                     sock;
59
        int                     fd;
60
        unsigned                is_dispatch;
61
        char                    listen[256];
62
        char                    aaddr[VTCP_ADDRBUFSIZE];
63
        char                    aport[VTCP_PORTBUFSIZE];
64
65
        pthread_t               tp;
66
};
67
68
static pthread_mutex_t          server_mtx;
69
70
static VTAILQ_HEAD(, server)    servers = VTAILQ_HEAD_INITIALIZER(servers);
71
72
/**********************************************************************
73
 * Allocate and initialize a server
74
 */
75
76
static struct server *
77
server_new(const char *name, struct vtclog *vl)
78 1167
{
79 1167
        struct server *s;
80
81 1167
        VTC_CHECK_NAME(vl, name, "Server", 's');
82 1167
        ALLOC_OBJ(s, SERVER_MAGIC);
83 1167
        AN(s);
84 1167
        REPLACE(s->name, name);
85 1167
        s->vl = vtc_logopen("%s", s->name);
86 1167
        AN(s->vl);
87 1167
        s->vsp = Sess_New(s->vl, name);
88 1167
        AN(s->vsp);
89
90 1167
        bprintf(s->listen, "%s", default_listen_addr);
91 1167
        s->depth = 10;
92 1167
        s->sock = -1;
93 1167
        s->fd = -1;
94 1167
        PTOK(pthread_mutex_lock(&server_mtx));
95 1167
        VTAILQ_INSERT_TAIL(&servers, s, list);
96 1167
        PTOK(pthread_mutex_unlock(&server_mtx));
97 1167
        return (s);
98 1167
}
99
100
/**********************************************************************
101
 * Clean up a server
102
 */
103
104
static void
105
server_delete(struct server *s)
106 1167
{
107
108 1167
        CHECK_OBJ_NOTNULL(s, SERVER_MAGIC);
109 1167
        Sess_Destroy(&s->vsp);
110 1167
        macro_undef(s->vl, s->name, "addr");
111 1167
        macro_undef(s->vl, s->name, "port");
112 1167
        macro_undef(s->vl, s->name, "sock");
113 1167
        vtc_logclose(s->vl);
114 1167
        free(s->name);
115
        /* XXX: MEMLEAK (?) (VSS ??) */
116 1167
        FREE_OBJ(s);
117 1167
}
118
119
/**********************************************************************
120
 * Server listen
121
 */
122
123
struct helper {
124
        int             depth;
125
        const char      **errp;
126
};
127
128
/* cf. VTCP_listen_on() */
129
static int v_matchproto_(vus_resolved_f)
130
uds_listen(void *priv, const struct sockaddr_un *uds)
131 61
{
132 61
        int sock, e;
133 61
        struct helper *hp = priv;
134
135 61
        sock = VUS_bind(uds, hp->errp);
136 61
        if (sock >= 0)   {
137 61
                if (listen(sock, hp->depth) != 0) {
138 0
                        e = errno;
139 0
                        closefd(&sock);
140 0
                        errno = e;
141 0
                        if (hp->errp != NULL)
142 0
                                *hp->errp = "listen(2)";
143 0
                        return (-1);
144 0
                }
145 61
        }
146 61
        if (sock > 0) {
147 61
                *hp->errp = NULL;
148 61
                return (sock);
149 61
        }
150 0
        AN(*hp->errp);
151 0
        return (0);
152 0
}
153
154
static void
155
server_listen_uds(struct server *s, const char **errp)
156 61
{
157 61
        mode_t m;
158 61
        struct helper h;
159
160 61
        h.depth = s->depth;
161 61
        h.errp = errp;
162
163 61
        errno = 0;
164 61
        if (unlink(s->listen) != 0 && errno != ENOENT)
165 0
                vtc_fatal(s->vl, "Could not unlink %s before bind: %s",
166 0
                    s->listen, strerror(errno));
167
        /*
168
         * Temporarily set the umask to 0 to avoid issues with
169
         * permissions.
170
         */
171 61
        m = umask(0);
172 61
        s->sock = VUS_resolver(s->listen, uds_listen, &h, errp);
173 61
        (void)umask(m);
174 61
        if (*errp != NULL)
175 0
                return;
176 61
        assert(s->sock > 0);
177 61
        macro_def(s->vl, s->name, "addr", "0.0.0.0");
178 61
        macro_def(s->vl, s->name, "port", "0");
179 61
        macro_def(s->vl, s->name, "sock", "%s", s->listen);
180 61
}
181
182
static void
183
server_listen_tcp(struct server *s, const char **errp)
184 1114
{
185 1114
        char buf[vsa_suckaddr_len];
186 1114
        const struct suckaddr *sua;
187
188 1114
        s->sock = VTCP_listen_on(s->listen, "0", s->depth, errp);
189 1114
        if (*errp != NULL)
190 0
                return;
191 1114
        assert(s->sock > 0);
192 1114
        sua = VSA_getsockname(s->sock, buf, sizeof buf);
193 1114
        AN(sua);
194 1114
        VTCP_name(sua, s->aaddr, sizeof s->aaddr,
195 1114
            s->aport, sizeof s->aport);
196
197
        /* Record the actual port, and reuse it on subsequent starts */
198 1114
        if (VSA_Get_Proto(sua) == AF_INET)
199 1109
                bprintf(s->listen, "%s:%s", s->aaddr, s->aport);
200 5
        else
201 5
                bprintf(s->listen, "[%s]:%s", s->aaddr, s->aport);
202
203 1114
        macro_def(s->vl, s->name, "addr", "%s", s->aaddr);
204 1114
        macro_def(s->vl, s->name, "port", "%s", s->aport);
205 1114
        macro_def(s->vl, s->name, "sock", "%s", s->listen);
206 1114
}
207
208
static void
209
server_listen(struct server *s)
210 1175
{
211 1175
        const char *err;
212
213 1175
        CHECK_OBJ_NOTNULL(s, SERVER_MAGIC);
214
215 1175
        if (s->sock >= 0)
216 101
                VTCP_close(&s->sock);
217 1175
        if (VUS_is(s->listen))
218 61
                server_listen_uds(s, &err);
219 1114
        else
220 1114
                server_listen_tcp(s, &err);
221 1175
        if (err != NULL)
222 0
                vtc_fatal(s->vl,
223 0
                    "Server listen address (%s) cannot be resolved: %s",
224 0
                    s->listen, err);
225 1175
}
226
227
/**********************************************************************
228
 * Server thread
229
 */
230
231
static int
232
server_conn(void *priv, struct vtclog *vl)
233 1518
{
234 1518
        struct server *s;
235 1518
        struct sockaddr_storage addr_s;
236 1518
        struct sockaddr *addr;
237 1518
        char abuf[VTCP_ADDRBUFSIZE];
238 1518
        char pbuf[VTCP_PORTBUFSIZE];
239 1518
        socklen_t l;
240 1518
        int fd;
241
242 1518
        CAST_OBJ_NOTNULL(s, priv, SERVER_MAGIC);
243
244 1518
        addr = (void*)&addr_s;
245 1518
        l = sizeof addr_s;
246 1518
        fd = accept(s->sock, addr, &l);
247 1518
        if (fd < 0)
248 0
                vtc_fatal(vl, "Accept failed: %s", strerror(errno));
249 1518
        if (VUS_is(s->listen))
250 60
                vtc_log(vl, 3, "accepted fd %d 0.0.0.0 0", fd);
251 1458
        else {
252 1458
                VTCP_hisname(fd, abuf, sizeof abuf, pbuf, sizeof pbuf);
253 1458
                vtc_log(vl, 3, "accepted fd %d %s %s", fd, abuf, pbuf);
254 1458
        }
255 1518
        return (fd);
256 1518
}
257
258
static void
259
server_disc(void *priv, struct vtclog *vl, int *fdp)
260 1381
{
261 1381
        int j;
262 1381
        struct server *s;
263
264 1381
        CAST_OBJ_NOTNULL(s, priv, SERVER_MAGIC);
265 1381
        vtc_log(vl, 3, "shutting fd %d (server run)", *fdp);
266 1381
        j = shutdown(*fdp, SHUT_WR);
267 1381
        if (!vtc_stop && !VTCP_Check(j))
268 0
                vtc_fatal(vl, "Shutdown(RD) failed: %s", strerror(errno));
269 1381
        VTCP_close(fdp);
270 1381
}
271
272
static void
273
server_start_thread(struct server *s)
274 1154
{
275
276 1154
        s->run = 1;
277 1154
        s->tp = Sess_Start_Thread(
278 1154
            s,
279 1154
            s->vsp,
280 1154
            server_conn,
281 1154
            server_disc,
282 1154
            s->listen,
283 1154
            &s->sock,
284 1154
            s->spec
285 1154
        );
286 1154
}
287
288
/**********************************************************************
289
 * Start the server thread
290
 */
291
292
static void
293
server_start(struct server *s)
294 1154
{
295 1154
        CHECK_OBJ_NOTNULL(s, SERVER_MAGIC);
296 1154
        vtc_log(s->vl, 2, "Starting server");
297 1154
        server_listen(s);
298 1154
        vtc_log(s->vl, 1, "Listen on %s", s->listen);
299 1154
        server_start_thread(s);
300 1154
}
301
302
/**********************************************************************
303
 */
304
305
static void *
306
server_dispatch_wrk(void *priv)
307 100
{
308 100
        struct server *s;
309 100
        struct vtclog *vl;
310 100
        int j, fd;
311
312 100
        CAST_OBJ_NOTNULL(s, priv, SERVER_MAGIC);
313 100
        assert(s->sock < 0);
314
315 100
        vl = vtc_logopen("%s", s->name);
316 100
        pthread_cleanup_push(vtc_logclose, vl);
317
318 100
        fd = s->fd;
319
320 100
        vtc_log(vl, 3, "start with fd %d", fd);
321 100
        sess_process(vl, s->vsp, s->spec, &fd, &s->sock, s->listen);
322 100
        vtc_log(vl, 3, "shutting fd %d (server dispatch)", fd);
323 100
        j = shutdown(fd, SHUT_WR);
324 100
        if (!VTCP_Check(j))
325 0
                vtc_fatal(vl, "Shutdown(WR) failed: %s", strerror(errno));
326 100
        VTCP_close(&s->fd);
327 100
        vtc_log(vl, 2, "Ending");
328 100
        pthread_cleanup_pop(0);
329 100
        vtc_logclose(vl);
330 100
        return (NULL);
331 100
}
332
333
static void *
334
server_dispatch_thread(void *priv)
335 21
{
336 21
        struct server *s, *s2;
337 21
        static int sn = 1;
338 21
        int fd;
339 21
        char snbuf[8];
340 21
        struct vtclog *vl;
341 21
        struct sockaddr_storage addr_s;
342 21
        struct sockaddr *addr;
343 21
        socklen_t l;
344
345 21
        CAST_OBJ_NOTNULL(s, priv, SERVER_MAGIC);
346 21
        assert(s->sock >= 0);
347
348 21
        vl = vtc_logopen("%s", s->name);
349 21
        pthread_cleanup_push(vtc_logclose, vl);
350
351 21
        vtc_log(vl, 2, "Dispatch started on %s", s->listen);
352
353 121
        while (!vtc_stop) {
354 121
                addr = (void*)&addr_s;
355 121
                l = sizeof addr_s;
356 121
                fd = accept(s->sock, addr, &l);
357 121
                if (fd < 0)
358 0
                        vtc_fatal(vl, "Accepted failed: %s", strerror(errno));
359 121
                bprintf(snbuf, "s%d", sn++);
360 121
                vtc_log(vl, 3, "dispatch fd %d -> %s", fd, snbuf);
361 121
                s2 = server_new(snbuf, vl);
362 121
                s2->is_dispatch = 1;
363 121
                s2->spec = s->spec;
364 121
                bstrcpy(s2->listen, s->listen);
365 121
                s2->fd = fd;
366 121
                s2->run = 1;
367 121
                PTOK(pthread_create(&s2->tp, NULL, server_dispatch_wrk, s2));
368 121
        }
369 21
        pthread_cleanup_pop(0);
370 0
        vtc_logclose(vl);
371 0
        NEEDLESS(return (NULL));
372 21
}
373
374
static void
375
server_dispatch(struct server *s)
376 21
{
377 21
        CHECK_OBJ_NOTNULL(s, SERVER_MAGIC);
378 21
        server_listen(s);
379 21
        vtc_log(s->vl, 2, "Starting dispatch server");
380 21
        s->run = 1;
381 21
        PTOK(pthread_create(&s->tp, NULL, server_dispatch_thread, s));
382 21
}
383
384
/**********************************************************************
385
 * Force stop the server thread
386
 */
387
388
static void
389
server_break(struct server *s)
390 7
{
391 7
        void *res;
392
393 7
        CHECK_OBJ_NOTNULL(s, SERVER_MAGIC);
394 7
        vtc_log(s->vl, 2, "Breaking for server");
395 7
        (void)pthread_cancel(s->tp);
396 7
        PTOK(pthread_join(s->tp, &res));
397 7
        VTCP_close(&s->sock);
398 7
        s->tp = 0;
399 7
        s->run = 0;
400 7
}
401
402
/**********************************************************************
403
 * Wait for server thread to stop
404
 */
405
406
static void
407
server_wait(struct server *s)
408 1268
{
409 1268
        void *res;
410
411 1268
        CHECK_OBJ_NOTNULL(s, SERVER_MAGIC);
412 1268
        vtc_log(s->vl, 2, "Waiting for server (%d/%d)", s->sock, s->fd);
413 1268
        PTOK(pthread_join(s->tp, &res));
414 1268
        if (res != NULL && !vtc_stop)
415 0
                vtc_fatal(s->vl, "Server returned \"%p\"",
416 0
                    (char *)res);
417 1268
        s->tp = 0;
418 1268
        s->run = 0;
419 1268
}
420
421
/**********************************************************************
422
 * Generate VCL backend decls for our servers
423
 */
424
425
void
426
cmd_server_gen_vcl(struct vsb *vsb)
427 929
{
428 929
        struct server *s;
429
430 929
        PTOK(pthread_mutex_lock(&server_mtx));
431 1059
        VTAILQ_FOREACH(s, &servers, list) {
432 1059
                if (s->is_dispatch)
433 21
                        continue;
434
435 1038
                if (VUS_is(s->listen))
436 18
                        VSB_printf(vsb,
437 18
                           "backend %s { .path = \"%s\"; }\n",
438 18
                           s->name, s->listen);
439 1020
                else
440 1020
                        VSB_printf(vsb,
441 1020
                           "backend %s { .host = \"%s\"; .port = \"%s\"; }\n",
442 1020
                           s->name, s->aaddr, s->aport);
443 1038
        }
444 929
        PTOK(pthread_mutex_unlock(&server_mtx));
445 929
}
446
447
448
/**********************************************************************
449
 * Generate VCL backend decls for our servers
450
 */
451
452
void
453
cmd_server_gen_haproxy_conf(struct vsb *vsb)
454 1
{
455 1
        struct server *s;
456
457 1
        PTOK(pthread_mutex_lock(&server_mtx));
458 1
        VTAILQ_FOREACH(s, &servers, list) {
459 1
                if (! VUS_is(s->listen))
460 1
                        VSB_printf(vsb,
461 1
                           "\n    backend be%s\n"
462 1
                           "\tserver srv%s %s:%s\n",
463 1
                           s->name + 1, s->name + 1, s->aaddr, s->aport);
464 0
                else
465 0
                        INCOMPL();
466 1
        }
467 1
        VTAILQ_FOREACH(s, &servers, list) {
468 1
                if (! VUS_is(s->listen))
469 1
                        VSB_printf(vsb,
470 1
                           "\n    frontend http%s\n"
471 1
                           "\tuse_backend be%s\n"
472 1
                           "\tbind \"fd@${fe%s}\"\n",
473 1
                           s->name + 1, s->name + 1, s->name + 1);
474 0
                else
475 0
                        INCOMPL();
476 1
        }
477 1
        PTOK(pthread_mutex_unlock(&server_mtx));
478 1
}
479
480
481
/**********************************************************************
482
 * Server command dispatch
483
 */
484
485
void
486
cmd_server(CMD_ARGS)
487 2464
{
488 2464
        struct server *s;
489
490 2464
        (void)priv;
491
492 2464
        if (av == NULL) {
493
                /* Reset and free */
494 2289
                while (1) {
495 2289
                        PTOK(pthread_mutex_lock(&server_mtx));
496 2289
                        s = VTAILQ_FIRST(&servers);
497 2289
                        CHECK_OBJ_ORNULL(s, SERVER_MAGIC);
498 2289
                        if (s != NULL)
499 1167
                                VTAILQ_REMOVE(&servers, s, list);
500 2289
                        PTOK(pthread_mutex_unlock(&server_mtx));
501 2289
                        if (s == NULL)
502 1122
                                break;
503 1167
                        if (s->run) {
504 1062
                                (void)pthread_cancel(s->tp);
505 1062
                                server_wait(s);
506 1062
                        }
507 1167
                        if (s->sock >= 0)
508 1067
                                VTCP_close(&s->sock);
509 1167
                        server_delete(s);
510 1167
                }
511 1122
                return;
512 1122
        }
513
514 1342
        AZ(vstrcmp(av[0], "server"));
515 1342
        av++;
516
517 1342
        PTOK(pthread_mutex_lock(&server_mtx));
518 1342
        VTAILQ_FOREACH(s, &servers, list)
519 608
                if (!vstrcmp(s->name, av[0]))
520 275
                        break;
521 1342
        PTOK(pthread_mutex_unlock(&server_mtx));
522 1342
        if (s == NULL)
523 1067
                s = server_new(av[0], vl);
524 1342
        CHECK_OBJ_NOTNULL(s, SERVER_MAGIC);
525 1342
        av++;
526
527 3952
        for (; *av != NULL; av++) {
528 2610
                if (vtc_error)
529 0
                        break;
530 2610
                if (!vstrcmp(*av, "-wait")) {
531 131
                        if (!s->run)
532 0
                                vtc_fatal(s->vl, "Server not -started");
533 131
                        server_wait(s);
534 131
                        continue;
535 131
                }
536
537 2479
                if (!vstrcmp(*av, "-break")) {
538 7
                        server_break(s);
539 7
                        continue;
540 7
                }
541
542
                /*
543
                 * We do an implicit -wait if people muck about with a
544
                 * running server.
545
                 */
546 2472
                if (s->run)
547 75
                        server_wait(s);
548
549 2472
                AZ(s->run);
550
551 2472
                if (Sess_GetOpt(s->vsp, &av))
552 89
                        continue;
553
554 2383
                if (!vstrcmp(*av, "-listen")) {
555 63
                        if (s->sock >= 0)
556 0
                                VTCP_close(&s->sock);
557 63
                        bprintf(s->listen, "%s", av[1]);
558 63
                        av++;
559 63
                        continue;
560 63
                }
561 2320
                if (!vstrcmp(*av, "-start")) {
562 1154
                        server_start(s);
563 1154
                        continue;
564 1154
                }
565 1166
                if (!vstrcmp(*av, "-dispatch")) {
566 21
                        if (vstrcmp(s->name, "s0"))
567 0
                                vtc_fatal(s->vl,
568 0
                                    "server -dispatch only works on s0");
569 21
                        server_dispatch(s);
570 21
                        continue;
571 21
                }
572 1145
                if (**av == '-')
573 0
                        vtc_fatal(s->vl, "Unknown server argument: %s", *av);
574 1145
                s->spec = *av;
575 1145
        }
576 1342
}
577
578
void
579
init_server(void)
580 1122
{
581
        PTOK(pthread_mutex_init(&server_mtx, NULL));
582 1122
}