GCOV - Varnish Cache


/*-
 * Copyright (c) 2010-2011 Varnish Software AS
 * All rights reserved.
 *
 * Author: Poul-Henning Kamp <phk@phk.freebsd.dk>
 *
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

#include "config.h"

#include <sys/types.h>
#include <sys/uio.h>

#include <poll.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#include "vdef.h"

#include "vas.h"        // XXX Flexelint "not used" - but req'ed for assert()
#include "vcli.h"
#include "vsha256.h"
#include "vtim.h"

void
VCLI_AuthResponse(int S_fd, const char *challenge,
    char response[CLI_AUTH_RESPONSE_LEN + 1])
{
        VSHA256_CTX ctx;
        uint8_t buf[VSHA256_LEN];
        int i;

        assert(CLI_AUTH_RESPONSE_LEN == (VSHA256_LEN * 2));

        VSHA256_Init(&ctx);
        VSHA256_Update(&ctx, challenge, 32);
        VSHA256_Update(&ctx, "\n", 1);
        do {
                i = read(S_fd, buf, 1);
                if (i == 1)
                        VSHA256_Update(&ctx, buf, i);
        } while (i > 0);
        VSHA256_Update(&ctx, challenge, 32);
        VSHA256_Update(&ctx, "\n", 1);
        VSHA256_Final(buf, &ctx);
        for (i = 0; i < VSHA256_LEN; i++)
                assert(snprintf(response + 2 * i, 3, "%02x", buf[i]) == 2);
}

int
VCLI_WriteResult(int fd, unsigned status, const char *result)
{
        int i, l;
        struct iovec iov[3];
        char nl[2] = "\n";
        size_t len;
        char res[CLI_LINE0_LEN + 2];    /*
                                         * NUL + one more so we can catch
                                         * any misformats by snprintf
                                         */

        assert(status >= 100);
        assert(status <= 999);          /*lint !e650 const out of range */

        len = strlen(result);

        i = snprintf(res, sizeof res, "%-3d %-8zd\n", status, len);
        assert(i == CLI_LINE0_LEN);
        assert(strtoul(res + 3, NULL, 10) == len);

        iov[0].iov_base = res;
        iov[0].iov_len = CLI_LINE0_LEN;

        iov[1].iov_base = (void*)(uintptr_t)result;     /* TRUST ME */
        iov[1].iov_len = len;

        iov[2].iov_base = nl;
        iov[2].iov_len = 1;

        for (l = i = 0; i < 3; i++)
                l += iov[i].iov_len;
        i = writev(fd, iov, 3);
        return (i != l);
}

static int
read_tmo(int fd, char *ptr, unsigned len, double tmo)
{
        int i, j;
        struct pollfd pfd;

        pfd.fd = fd;
        pfd.events = POLLIN;
        for (j = 0; len > 0; ) {
                i = poll(&pfd, 1, VTIM_poll_tmo(tmo));
                if (i < 0) {
                        errno = EINTR;
                        return (-1);
                }
                if (i == 0) {
                        errno = ETIMEDOUT;
                        return (-1);
                }
                i = read(fd, ptr, len);
                if (i < 0)
                        return (i);
                if (i == 0)
                        break;
                len -= i;
                ptr += i;
                j += i;
        }
        return (j);
}

int
VCLI_ReadResult(int fd, unsigned *status, char **ptr, double tmo)
{
        char res[CLI_LINE0_LEN];        /* For NUL */
        int i, j;
        unsigned u, v, s;
        char *p = NULL;
        const char *err = "CLI communication error (hdr)";

        if (status == NULL)
                status = &s;
        if (ptr != NULL)
                *ptr = NULL;
        do {
                i = read_tmo(fd, res, CLI_LINE0_LEN, tmo);
                if (i != CLI_LINE0_LEN)
                        break;

                if (res[3] != ' ')
                        break;

                if (res[CLI_LINE0_LEN - 1] != '\n')
                        break;

                res[CLI_LINE0_LEN - 1] = '\0';
                j = sscanf(res, "%u %u\n", &u, &v);
                if (j != 2)
                        break;

                err = "CLI communication error (body)";

                *status = u;
                p = malloc(v + 1L);
                if (p == NULL)
                        break;

                i = read_tmo(fd, p, v + 1, tmo);
                if (i < 0)
                        break;
                if (i != v + 1)
                        break;
                if (p[v] != '\n')
                        break;

                p[v] = '\0';
                if (ptr == NULL)
                        free(p);
                else
                        *ptr = p;
                return (0);
        } while (0);

        free(p);
        *status = CLIS_COMMS;
        if (ptr != NULL)
                *ptr = strdup(err);
        return (*status);
}

		varnish-cache/lib/libvarnish/vcli_proto.c
0		/*-
1		* Copyright (c) 2010-2011 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/types.h>
33		#include <sys/uio.h>
34
35		#include <poll.h>
36		#include <stdint.h>
37		#include <stdio.h>
38		#include <stdlib.h>
39		#include <string.h>
40		#include <unistd.h>
41
42		#include "vdef.h"
43
44		#include "vas.h" // XXX Flexelint "not used" - but req'ed for assert()
45		#include "vcli.h"
46		#include "vsha256.h"
47		#include "vtim.h"
48
49		void
50	80280	VCLI_AuthResponse(int S_fd, const char *challenge,
51		char response[CLI_AUTH_RESPONSE_LEN + 1])
52		{
53		VSHA256_CTX ctx;
54		uint8_t buf[VSHA256_LEN];
55		int i;
56
57	80280	assert(CLI_AUTH_RESPONSE_LEN == (VSHA256_LEN * 2));
58
59	80280	VSHA256_Init(&ctx);
60	80280	VSHA256_Update(&ctx, challenge, 32);
61	80280	VSHA256_Update(&ctx, "\n", 1);
62	80280	do {
63	20631960	i = read(S_fd, buf, 1);
64	20631960	if (i == 1)
65	20551680	VSHA256_Update(&ctx, buf, i);
66	20631960	} while (i > 0);
67	80280	VSHA256_Update(&ctx, challenge, 32);
68	80280	VSHA256_Update(&ctx, "\n", 1);
69	80280	VSHA256_Final(buf, &ctx);
70	2649240	for (i = 0; i < VSHA256_LEN; i++)
71	2568960	assert(snprintf(response + 2 * i, 3, "%02x", buf[i]) == 2);
72	80280	}
73
74		int
75	977616	VCLI_WriteResult(int fd, unsigned status, const char *result)
76		{
77		int i, l;
78		struct iovec iov[3];
79	977616	char nl[2] = "\n";
80		size_t len;
81		char res[CLI_LINE0_LEN + 2]; /*
82		* NUL + one more so we can catch
83		* any misformats by snprintf
84		*/
85
86	977616	assert(status >= 100);
87	977616	assert(status <= 999); /lint !e650 const out of range /
88
89	977616	len = strlen(result);
90
91	977616	i = snprintf(res, sizeof res, "%-3d %-8zd\n", status, len);
92	977616	assert(i == CLI_LINE0_LEN);
93	977616	assert(strtoul(res + 3, NULL, 10) == len);
94
95	977616	iov[0].iov_base = res;
96	977616	iov[0].iov_len = CLI_LINE0_LEN;
97
98	977616	iov[1].iov_base = (void)(uintptr_t)result; / TRUST ME */
99	977616	iov[1].iov_len = len;
100
101	977616	iov[2].iov_base = nl;
102	977616	iov[2].iov_len = 1;
103
104	3910464	for (l = i = 0; i < 3; i++)
105	2932848	l += iov[i].iov_len;
106	977616	i = writev(fd, iov, 3);
107	977616	return (i != l);
108		}
109
110		static int
111	1890360	read_tmo(int fd, char *ptr, unsigned len, double tmo)
112		{
113		int i, j;
114		struct pollfd pfd;
115
116	1890360	pfd.fd = fd;
117	1890360	pfd.events = POLLIN;
118	3780160	for (j = 0; len > 0; ) {
119	1890400	i = poll(&pfd, 1, VTIM_poll_tmo(tmo));
120	1890400	if (i < 0) {
121	0	errno = EINTR;
122	0	return (-1);
123		}
124	1890400	if (i == 0) {
125	160	errno = ETIMEDOUT;
126	160	return (-1);
127		}
128	1890240	i = read(fd, ptr, len);
129	1890240	if (i < 0)
130	0	return (i);
131	1890240	if (i == 0)
132	440	break;
133	1889800	len -= i;
134	1889800	ptr += i;
135	1889800	j += i;
136		}
137	1890200	return (j);
138	1890360	}
139
140		int
141	945480	VCLI_ReadResult(int fd, unsigned status, char *ptr, double tmo)
142		{
143		char res[CLI_LINE0_LEN]; /* For NUL */
144		int i, j;
145		unsigned u, v, s;
146	945480	char *p = NULL;
147	945480	const char *err = "CLI communication error (hdr)";
148
149	945480	if (status == NULL)
150	200	status = &s;
151	945480	if (ptr != NULL)
152	906400	*ptr = NULL;
153	945480	do {
154	945480	i = read_tmo(fd, res, CLI_LINE0_LEN, tmo);
155	945480	if (i != CLI_LINE0_LEN)
156	600	break;
157
158	944880	if (res[3] != ' ')
159	0	break;
160
161	944880	if (res[CLI_LINE0_LEN - 1] != '\n')
162	0	break;
163
164	944880	res[CLI_LINE0_LEN - 1] = '\0';
165	944880	j = sscanf(res, "%u %u\n", &u, &v);
166	944880	if (j != 2)
167	0	break;
168
169	944880	err = "CLI communication error (body)";
170
171	944880	*status = u;
172	944880	p = malloc(v + 1L);
173	944880	if (p == NULL)
174	0	break;
175
176	944880	i = read_tmo(fd, p, v + 1, tmo);
177	944880	if (i < 0)
178	0	break;
179	944880	if (i != v + 1)
180	0	break;
181	944880	if (p[v] != '\n')
182	0	break;
183
184	944880	p[v] = '\0';
185	944880	if (ptr == NULL)
186	38640	free(p);
187		else
188	906240	*ptr = p;
189	944880	return (0);
190		} while (0);
191
192	600	free(p);
193	600	*status = CLIS_COMMS;
194	600	if (ptr != NULL)
195	160	*ptr = strdup(err);
196	600	return (*status);
197	945480	}