GCOV - Varnish Cache


/*-
 * Copyright (c) 2006 Verdens Gang AS
 * Copyright (c) 2006-2011 Varnish Software AS
 * All rights reserved.
 *
 * Author: Dag-Erling Smørgrav <des@des.no>
 *
 * 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 <time.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <limits.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <stdint.h>
#include <string.h>
#include <sys/statvfs.h>
#if defined(__linux__) && defined(HAVE_FALLOCATE)
#  include <linux/magic.h>
#  include <sys/vfs.h>
#endif

#include "vdef.h"

#include "miniobj.h"
#include "vas.h"
#include "vsb.h"
#include "vfil.h"
#include "vqueue.h"

void
VFIL_null_fd(int target)
{
        int fd;

        assert(target >= 0);
        fd = open("/dev/null", O_RDWR);
        assert(fd >= 0);
        assert(dup2(fd, target) == target);
        closefd(&fd);
}

static char *
vfil_readfd(int fd, ssize_t *sz)
{
        struct stat st;
        char *f;
        int i;

        AZ(fstat(fd, &st));
        if (!S_ISREG(st.st_mode))
                return (NULL);
        f = malloc(st.st_size + 1);
        assert(f != NULL);
        i = read(fd, f, st.st_size + 1);
        if (i != st.st_size) {
                free(f);
                return (NULL);
        }
        f[i] = '\0';
        if (sz != NULL)
                *sz = st.st_size;
        return (f);
}

static int
vfil_writefd(int fd, const char *buf, size_t sz)
{
        ssize_t len;

        while (sz > 0) {
                len = write(fd, buf, sz);
                if (len < 0)
                        return (len);
                if (len == 0)
                        break;
                buf += len;
                sz -= len;
        }

        return (sz == 0 ? 0 : -1);
}

static int
vfil_openfile(const char *pfx, const char *fn, int flags, int mode)
{
        char fnb[PATH_MAX + 1];

        if (fn[0] != '/' && pfx != NULL) {
                /* XXX: graceful length check */
                bprintf(fnb, "/%s/%s", pfx, fn);
                fn = fnb;
        }

        if (flags & O_CREAT)
                return (open(fn, flags, mode));
        else
                return (open(fn, flags));
}

char *
VFIL_readfile(const char *pfx, const char *fn, ssize_t *sz)
{
        int fd, err;
        char *r;

        fd = vfil_openfile(pfx, fn, O_RDONLY, 0);
        if (fd < 0)
                return (NULL);
        r = vfil_readfd(fd, sz);
        err = errno;
        closefd(&fd);
        errno = err;
        return (r);
}

int
VFIL_writefile(const char *pfx, const char *fn, const char *buf, size_t sz)
{
        int fd, err;
        int r;

        fd = vfil_openfile(pfx, fn, O_WRONLY|O_CREAT|O_TRUNC, 0660);
        if (fd < 0)
                return (fd);
        r = vfil_writefd(fd, buf, sz);
        err = errno;
        closefd(&fd);
        errno = err;
        return (r);
}

int
VFIL_nonblocking(int fd)
{
        int i;

        i = fcntl(fd, F_GETFL);
        assert(i != -1);
        i |= O_NONBLOCK;
        i = fcntl(fd, F_SETFL, i);
        assert(i != -1);
        return (i);
}

/*
 * Get file system information from an fd
 * Returns block size, total size and space available in the passed pointers
 * Returns 0 on success, or -1 on failure with errno set
 */
int
VFIL_fsinfo(int fd, unsigned *pbs, uintmax_t *psize, uintmax_t *pspace)
{
        unsigned bs;
        uintmax_t size, space;
        struct statvfs fsst;

        if (fstatvfs(fd, &fsst))
                return (-1);
        bs = fsst.f_frsize;
        size = fsst.f_blocks * fsst.f_frsize;
        space = fsst.f_bavail * fsst.f_frsize;

        if (pbs)
                *pbs = bs;
        if (psize)
                *psize = size;
        if (pspace)
                *pspace = space;
        return (0);
}

/*
 * Make sure that the file system can accommodate the file of the given
 * size. Will use fallocate if available. If fallocate is not available
 * and insist is true, it will write size zero bytes.
 *
 * Returns 0 on success, -1 on failure with errno set.
 */

int
VFIL_allocate(int fd, uintmax_t size, int insist)
{
        struct stat st;
        uintmax_t fsspace;
        size_t l;
        ssize_t l2, l3;
        char *buf;
        ssize_t bufsiz;
        int retval = 0;

        if (ftruncate(fd, size))
                return (-1);
        if (fstat(fd, &st))
                return (-1);
        if (VFIL_fsinfo(fd, NULL, NULL, &fsspace))
                return (-1);
        if ((st.st_blocks * 512) + fsspace < size) {
                /* Sum of currently allocated blocks and available space
                   is less than requested size */
                errno = ENOSPC;
                return (-1);
        }
#if defined(__linux__) && defined(HAVE_FALLOCATE)
        {
                /* fallocate will for some filesystems (e.g. xfs) not take
                   the already allocated blocks of the file into
                   account. This will cause fallocate to report ENOSPC
                   when called on an existing fully allocated file unless
                   the filesystem has enough free space to accommodate the
                   complete new file size. Because of this we enable
                   fallocate only on filesystems that are known to work as
                   we expect. */
                struct statfs stfs;
                if (!fstatfs(fd, &stfs) && stfs.f_type == EXT4_SUPER_MAGIC) {
                        if (!fallocate(fd, 0, 0, size))
                                return (0);
                        if (errno == ENOSPC)
                                return (-1);
                }
        }
#endif
        if (!insist)
                return (0);

        /* Write size zero bytes to make sure the entire file is allocated
           in the file system */
        if (size > 65536)
                bufsiz = 64 * 1024;
        else
                bufsiz = size;
        buf = calloc(1, bufsiz);
        AN(buf);
        assert(lseek(fd, 0, SEEK_SET) == 0);
        for (l = 0; l < size; l += l2) {
                l2 = bufsiz;
                if (l + l2 > size)
                        l2 = size - l;
                l3 = write(fd, buf, l2);
                if (l3 != l2) {
                        retval = -1;
                        break;
                }
        }
        assert(lseek(fd, 0, SEEK_SET) == 0);
        free(buf);
        return (retval);
}

struct vfil_dir {
        unsigned                magic;
#define VFIL_DIR_MAGIC          0x3e214967
        char                    *dir;
        VTAILQ_ENTRY(vfil_dir)  list;
};

struct vfil_path {
        unsigned                magic;
#define VFIL_PATH_MAGIC         0x92dbcc31
        char                    *str;
        VTAILQ_HEAD(,vfil_dir)  paths;
};

/*
 * Path searching functions
 */

void
VFIL_setpath(struct vfil_path **pp, const char *path)
{
        struct vfil_path *vp;
        struct vfil_dir *vd;
        char *p, *q;

        AN(pp);
        AN(path);

        vp = *pp;
        if (vp == NULL) {
                ALLOC_OBJ(vp, VFIL_PATH_MAGIC);
                AN(vp);
                VTAILQ_INIT(&vp->paths);
                *pp = vp;
        }
        REPLACE(vp->str, path);
        while (!VTAILQ_EMPTY(&vp->paths)) {
                vd = VTAILQ_FIRST(&vp->paths);
                CHECK_OBJ_NOTNULL(vd, VFIL_DIR_MAGIC);
                VTAILQ_REMOVE(&vp->paths, vd, list);
                FREE_OBJ(vd);
        }
        for (p = vp->str; p != NULL; p = q) {
                q = strchr(p, ':');
                if (q != NULL)
                        *q++ = '\0';
                ALLOC_OBJ(vd, VFIL_DIR_MAGIC);
                AN(vd);
                vd->dir = p;
                VTAILQ_INSERT_TAIL(&vp->paths, vd, list);
        }
}

static int
vfil_path_openfile(void *priv, const char *fn)
{
        char *p, **pp;

        AN(priv);
        AN(fn);
        p = VFIL_readfile(NULL, fn, NULL);
        if (p == NULL)
                return (1);

        pp = priv;
        *pp = p;
        return (0);
}

int
VFIL_searchpath(const struct vfil_path *vp, vfil_path_func_f *func, void *priv,
    const char *fni, char **fno)
{
        struct vsb *vsb;
        struct vfil_dir *vd;
        int i, e;

        CHECK_OBJ_NOTNULL(vp, VFIL_PATH_MAGIC);
        AN(fno);
        *fno = NULL;

        if (func == NULL) {
                func = vfil_path_openfile;
                AN(priv);
        }

        if (*fni == '/') {
                i = func(priv, fni);
                if (i <= 0)
                        REPLACE(*fno, fni);
                return (i);
        }
        vsb = VSB_new_auto();
        AN(vsb);
        VTAILQ_FOREACH(vd, &vp->paths, list) {
                VSB_clear(vsb);
                VSB_printf(vsb, "%s/%s", vd->dir, fni);
                AZ(VSB_finish(vsb));
                if (access(VSB_data(vsb), F_OK))
                        continue;
                i = func(priv, VSB_data(vsb));
                if (i <= 0) {
                        e = errno;
                        *fno = strdup(VSB_data(vsb));
                        AN(*fno);
                        VSB_destroy(&vsb);
                        errno = e;
                        return (i);
                }
        }
        VSB_destroy(&vsb);
        return (-1);
}

		varnish-cache/lib/libvarnish/vfil.c
0		/*-
1		* Copyright (c) 2006 Verdens Gang AS
2		* Copyright (c) 2006-2011 Varnish Software AS
3		* All rights reserved.
4		*
5		* Author: Dag-Erling Smørgrav <des@des.no>
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 <time.h>
34		#include <sys/types.h>
35		#include <sys/stat.h>
36		#include <fcntl.h>
37		#include <limits.h>
38		#include <stdio.h>
39		#include <stdlib.h>
40		#include <unistd.h>
41		#include <stdint.h>
42		#include <string.h>
43		#include <sys/statvfs.h>
44		#if defined(__linux__) && defined(HAVE_FALLOCATE)
45		# include <linux/magic.h>
46		# include <sys/vfs.h>
47		#endif
48
49		#include "vdef.h"
50
51		#include "miniobj.h"
52		#include "vas.h"
53		#include "vsb.h"
54		#include "vfil.h"
55		#include "vqueue.h"
56
57		void
58	578126	VFIL_null_fd(int target)
59		{
60		int fd;
61
62	578126	assert(target >= 0);
63	578126	fd = open("/dev/null", O_RDWR);
64	578126	assert(fd >= 0);
65	578126	assert(dup2(fd, target) == target);
66	578126	closefd(&fd);
67	578126	}
68
69		static char *
70	236280	vfil_readfd(int fd, ssize_t *sz)
71		{
72		struct stat st;
73		char *f;
74		int i;
75
76	236280	AZ(fstat(fd, &st));
77	236280	if (!S_ISREG(st.st_mode))
78	0	return (NULL);
79	236280	f = malloc(st.st_size + 1);
80	236280	assert(f != NULL);
81	236280	i = read(fd, f, st.st_size + 1);
82	236280	if (i != st.st_size) {
83	0	free(f);
84	0	return (NULL);
85		}
86	236280	f[i] = '\0';
87	236280	if (sz != NULL)
88	440	*sz = st.st_size;
89	236280	return (f);
90	236280	}
91
92		static int
93	560	vfil_writefd(int fd, const char *buf, size_t sz)
94		{
95		ssize_t len;
96
97	1120	while (sz > 0) {
98	560	len = write(fd, buf, sz);
99	560	if (len < 0)
100	0	return (len);
101	560	if (len == 0)
102	0	break;
103	560	buf += len;
104	560	sz -= len;
105		}
106
107	560	return (sz == 0 ? 0 : -1);
108	560	}
109
110		static int
111	237160	vfil_openfile(const char pfx, const char fn, int flags, int mode)
112		{
113		char fnb[PATH_MAX + 1];
114
115	237160	if (fn[0] != '/' && pfx != NULL) {
116		/* XXX: graceful length check */
117	0	bprintf(fnb, "/%s/%s", pfx, fn);
118	0	fn = fnb;
119	0	}
120
121	237160	if (flags & O_CREAT)
122	560	return (open(fn, flags, mode));
123		else
124	236600	return (open(fn, flags));
125	237160	}
126
127		char *
128	236600	VFIL_readfile(const char pfx, const char fn, ssize_t *sz)
129		{
130		int fd, err;
131		char *r;
132
133	236600	fd = vfil_openfile(pfx, fn, O_RDONLY, 0);
134	236600	if (fd < 0)
135	320	return (NULL);
136	236280	r = vfil_readfd(fd, sz);
137	236280	err = errno;
138	236280	closefd(&fd);
139	236280	errno = err;
140	236280	return (r);
141	236600	}
142
143		int
144	560	VFIL_writefile(const char pfx, const char fn, const char *buf, size_t sz)
145		{
146		int fd, err;
147		int r;
148
149	560	fd = vfil_openfile(pfx, fn, O_WRONLY\|O_CREAT\|O_TRUNC, 0660);
150	560	if (fd < 0)
151	0	return (fd);
152	560	r = vfil_writefd(fd, buf, sz);
153	560	err = errno;
154	560	closefd(&fd);
155	560	errno = err;
156	560	return (r);
157	560	}
158
159		int
160	38440	VFIL_nonblocking(int fd)
161		{
162		int i;
163
164	38440	i = fcntl(fd, F_GETFL);
165	38440	assert(i != -1);
166	38440	i \|= O_NONBLOCK;
167	38440	i = fcntl(fd, F_SETFL, i);
168	38440	assert(i != -1);
169	38440	return (i);
170		}
171
172		/*
173		* Get file system information from an fd
174		* Returns block size, total size and space available in the passed pointers
175		* Returns 0 on success, or -1 on failure with errno set
176		*/
177		int
178	1885856	VFIL_fsinfo(int fd, unsigned pbs, uintmax_t psize, uintmax_t *pspace)
179		{
180		unsigned bs;
181		uintmax_t size, space;
182		struct statvfs fsst;
183
184	1885856	if (fstatvfs(fd, &fsst))
185	0	return (-1);
186	1885856	bs = fsst.f_frsize;
187	1885856	size = fsst.f_blocks * fsst.f_frsize;
188	1885856	space = fsst.f_bavail * fsst.f_frsize;
189
190	1885856	if (pbs)
191	1760	*pbs = bs;
192	1885856	if (psize)
193	1760	*psize = size;
194	1885856	if (pspace)
195	1884096	*pspace = space;
196	1885856	return (0);
197	1885856	}
198
199		/*
200		* Make sure that the file system can accommodate the file of the given
201		* size. Will use fallocate if available. If fallocate is not available
202		* and insist is true, it will write size zero bytes.
203		*
204		* Returns 0 on success, -1 on failure with errno set.
205		*/
206
207		int
208	1884096	VFIL_allocate(int fd, uintmax_t size, int insist)
209		{
210		struct stat st;
211		uintmax_t fsspace;
212		size_t l;
213		ssize_t l2, l3;
214		char *buf;
215		ssize_t bufsiz;
216	1884096	int retval = 0;
217
218	1884096	if (ftruncate(fd, size))
219	0	return (-1);
220	1884096	if (fstat(fd, &st))
221	0	return (-1);
222	1884096	if (VFIL_fsinfo(fd, NULL, NULL, &fsspace))
223	0	return (-1);
224	1884096	if ((st.st_blocks * 512) + fsspace < size) {
225		/* Sum of currently allocated blocks and available space
226		is less than requested size */
227	0	errno = ENOSPC;
228	0	return (-1);
229		}
230		#if defined(__linux__) && defined(HAVE_FALLOCATE)
231		{
232		/* fallocate will for some filesystems (e.g. xfs) not take
233		the already allocated blocks of the file into
234		account. This will cause fallocate to report ENOSPC
235		when called on an existing fully allocated file unless
236		the filesystem has enough free space to accommodate the
237		complete new file size. Because of this we enable
238		fallocate only on filesystems that are known to work as
239		we expect. */
240		struct statfs stfs;
241		if (!fstatfs(fd, &stfs) && stfs.f_type == EXT4_SUPER_MAGIC) {
242		if (!fallocate(fd, 0, 0, size))
243		return (0);
244		if (errno == ENOSPC)
245		return (-1);
246		}
247		}
248		#endif
249	1884096	if (!insist)
250	200	return (0);
251
252		/* Write size zero bytes to make sure the entire file is allocated
253		in the file system */
254	1883896	if (size > 65536)
255	37392	bufsiz = 64 * 1024;
256		else
257	1846504	bufsiz = size;
258	1883896	buf = calloc(1, bufsiz);
259	1883896	AN(buf);
260	1883896	assert(lseek(fd, 0, SEEK_SET) == 0);
261	5019296	for (l = 0; l < size; l += l2) {
262	3135400	l2 = bufsiz;
263	3135400	if (l + l2 > size)
264	0	l2 = size - l;
265	3135400	l3 = write(fd, buf, l2);
266	3135400	if (l3 != l2) {
267	0	retval = -1;
268	0	break;
269		}
270	3135400	}
271	1883896	assert(lseek(fd, 0, SEEK_SET) == 0);
272	1883896	free(buf);
273	1883896	return (retval);
274	1884096	}
275
276		struct vfil_dir {
277		unsigned magic;
278		#define VFIL_DIR_MAGIC 0x3e214967
279		char *dir;
280		VTAILQ_ENTRY(vfil_dir) list;
281		};
282
283		struct vfil_path {
284		unsigned magic;
285		#define VFIL_PATH_MAGIC 0x92dbcc31
286		char *str;
287		VTAILQ_HEAD(,vfil_dir) paths;
288		};
289
290		/*
291		* Path searching functions
292		*/
293
294		void
295	122520	VFIL_setpath(struct vfil_path *pp, const char path)
296		{
297		struct vfil_path *vp;
298		struct vfil_dir *vd;
299		char p, q;
300
301	122520	AN(pp);
302	122520	AN(path);
303
304	122520	vp = *pp;
305	122520	if (vp == NULL) {
306	122360	ALLOC_OBJ(vp, VFIL_PATH_MAGIC);
307	122360	AN(vp);
308	122360	VTAILQ_INIT(&vp->paths);
309	122360	*pp = vp;
310	122360	}
311	122520	REPLACE(vp->str, path);
312	122840	while (!VTAILQ_EMPTY(&vp->paths)) {
313	320	vd = VTAILQ_FIRST(&vp->paths);
314	320	CHECK_OBJ_NOTNULL(vd, VFIL_DIR_MAGIC);
315	320	VTAILQ_REMOVE(&vp->paths, vd, list);
316	320	FREE_OBJ(vd);
317		}
318	305880	for (p = vp->str; p != NULL; p = q) {
319	183360	q = strchr(p, ':');
320	183360	if (q != NULL)
321	60840	*q++ = '\0';
322	183360	ALLOC_OBJ(vd, VFIL_DIR_MAGIC);
323	183360	AN(vd);
324	183360	vd->dir = p;
325	183360	VTAILQ_INSERT_TAIL(&vp->paths, vd, list);
326	183360	}
327	122520	}
328
329		static int
330	2520	vfil_path_openfile(void priv, const char fn)
331		{
332		char p, *pp;
333
334	2520	AN(priv);
335	2520	AN(fn);
336	2520	p = VFIL_readfile(NULL, fn, NULL);
337	2520	if (p == NULL)
338	80	return (1);
339
340	2440	pp = priv;
341	2440	*pp = p;
342	2440	return (0);
343	2520	}
344
345		int
346	26200	VFIL_searchpath(const struct vfil_path vp, vfil_path_func_f func, void *priv,
347		const char fni, char *fno)
348		{
349		struct vsb *vsb;
350		struct vfil_dir *vd;
351		int i, e;
352
353	26200	CHECK_OBJ_NOTNULL(vp, VFIL_PATH_MAGIC);
354	26200	AN(fno);
355	26200	*fno = NULL;
356
357	26200	if (func == NULL) {
358	2600	func = vfil_path_openfile;
359	2600	AN(priv);
360	2600	}
361
362	26200	if (*fni == '/') {
363	2080	i = func(priv, fni);
364	2080	if (i <= 0)
365	2000	REPLACE(*fno, fni);
366	2080	return (i);
367		}
368	24120	vsb = VSB_new_auto();
369	24120	AN(vsb);
370	24360	VTAILQ_FOREACH(vd, &vp->paths, list) {
371	24240	VSB_clear(vsb);
372	24240	VSB_printf(vsb, "%s/%s", vd->dir, fni);
373	24240	AZ(VSB_finish(vsb));
374	24240	if (access(VSB_data(vsb), F_OK))
375	240	continue;
376	24000	i = func(priv, VSB_data(vsb));
377	24000	if (i <= 0) {
378	24000	e = errno;
379	24000	*fno = strdup(VSB_data(vsb));
380	24000	AN(*fno);
381	24000	VSB_destroy(&vsb);
382	24000	errno = e;
383	24000	return (i);
384		}
385	0	}
386	120	VSB_destroy(&vsb);
387	120	return (-1);
388	26200	}