Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	lib/libc/stdio/fmemopen.c	Lines:	0	74	0.0 %
Date:	2017-11-07	Branches:	0	43	0.0 %


/*	$OpenBSD: fmemopen.c,v 1.3 2015/08/31 02:53:57 guenther Exp $	*/

/*
 * Copyright (c) 2011 Martin Pieuchot <mpi@openbsd.org>
 * Copyright (c) 2009 Ted Unangst
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "local.h"

struct state {
	char		*string;	/* actual stream */
	size_t		 pos;		/* current position */
	size_t		 size;		/* allocated size */
	size_t		 len;		/* length of the data */
	int		 update;	/* open for update */
};

static int
fmemopen_read(void *v, char *b, int l)
{
	struct state	*st = v;
	int		 i;

	for (i = 0; i < l && i + st->pos < st->len; i++)
		b[i] = st->string[st->pos + i];
	st->pos += i;

	return (i);
}

static int
fmemopen_write(void *v, const char *b, int l)
{
	struct state	*st = v;
	int		i;

	for (i = 0; i < l && i + st->pos < st->size; i++)
		st->string[st->pos + i] = b[i];
	st->pos += i;

	if (st->pos >= st->len) {
		st->len = st->pos;

		if (st->len < st->size)
			st->string[st->len] = '\0';
		else if (!st->update)
			st->string[st->size - 1] = '\0';
	}

	return (i);
}

static fpos_t
fmemopen_seek(void *v, fpos_t off, int whence)
{
	struct state	*st = v;
	ssize_t		 base = 0;

	switch (whence) {
	case SEEK_SET:
		break;
	case SEEK_CUR:
		base = st->pos;
		break;
	case SEEK_END:
		base = st->len;
		break;
	}

	if (off > st->size - base || off < -base) {
		errno = EOVERFLOW;
		return (-1);
	}

	st->pos = base + off;

	return (st->pos);
}

static int
fmemopen_close(void *v)
{
	free(v);

	return (0);
}

static int
fmemopen_close_free(void *v)
{
	struct state	*st = v;

	free(st->string);
	free(st);

	return (0);
}

FILE *
fmemopen(void *buf, size_t size, const char *mode)
{
	struct state	*st;
	FILE		*fp;
	int		 flags, oflags;

	if (size == 0) {
		errno = EINVAL;
		return (NULL);
	}

	if ((flags = __sflags(mode, &oflags)) == 0) {
		errno = EINVAL;
		return (NULL);
	}

	if (buf == NULL && ((oflags & O_RDWR) == 0)) {
		errno = EINVAL;
		return (NULL);
	}

	if ((st = malloc(sizeof(*st))) == NULL)
		return (NULL);

	if ((fp = __sfp()) == NULL) {
		free(st);
		return (NULL);
	}

	st->pos = 0;
	st->len = (oflags & O_WRONLY) ? 0 : size;
	st->size = size;
	st->update = oflags & O_RDWR;

	if (buf == NULL) {
		if ((st->string = malloc(size)) == NULL) {
			free(st);
			fp->_flags = 0;
			return (NULL);
		}
		*st->string = '\0';
	} else {
		st->string = (char *)buf;

		if (oflags & O_TRUNC)
			*st->string = '\0';

		if (oflags & O_APPEND) {
			char	*p;

			if ((p = memchr(st->string, '\0', size)) != NULL)
				st->pos = st->len = (p - st->string);
			else
				st->pos = st->len = size;
		}
	}

	fp->_flags = (short)flags;
	fp->_file = -1;
	fp->_cookie = (void *)st;
	fp->_read = (flags & __SWR) ? NULL : fmemopen_read;
	fp->_write = (flags & __SRD) ? NULL : fmemopen_write;
	fp->_seek = fmemopen_seek;
	fp->_close = (buf == NULL) ? fmemopen_close_free : fmemopen_close;

	return (fp);
}
DEF_WEAK(fmemopen);


Generated by: GCOVR (Version 3.3)

Line	Branch	Exec	Source
1			/* $OpenBSD: fmemopen.c,v 1.3 2015/08/31 02:53:57 guenther Exp $ */
2
3			/*
4			* Copyright (c) 2011 Martin Pieuchot <mpi@openbsd.org>
5			* Copyright (c) 2009 Ted Unangst
6			*
7			* Permission to use, copy, modify, and distribute this software for any
8			* purpose with or without fee is hereby granted, provided that the above
9			* copyright notice and this permission notice appear in all copies.
10			*
11			* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
12			* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
13			* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
14			* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
15			* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
16			* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
17			* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
18			*/
19
20			#include <errno.h>
21			#include <fcntl.h>
22			#include <stdio.h>
23			#include <stdlib.h>
24			#include <string.h>
25			#include "local.h"
26
27			struct state {
28			char string; / actual stream */
29			size_t pos; /* current position */
30			size_t size; /* allocated size */
31			size_t len; /* length of the data */
32			int update; /* open for update */
33			};
34
35			static int
36			fmemopen_read(void v, char b, int l)
37			{
38			struct state *st = v;
39			int i;
40
41			for (i = 0; i < l && i + st->pos < st->len; i++)
42			b[i] = st->string[st->pos + i];
43			st->pos += i;
44
45			return (i);
46			}
47
48			static int
49			fmemopen_write(void v, const char b, int l)
50			{
51			struct state *st = v;
52			int i;
53
54			for (i = 0; i < l && i + st->pos < st->size; i++)
55			st->string[st->pos + i] = b[i];
56			st->pos += i;
57
58			if (st->pos >= st->len) {
59			st->len = st->pos;
60
61			if (st->len < st->size)
62			st->string[st->len] = '\0';
63			else if (!st->update)
64			st->string[st->size - 1] = '\0';
65			}
66
67			return (i);
68			}
69
70			static fpos_t
71			fmemopen_seek(void *v, fpos_t off, int whence)
72			{
73			struct state *st = v;
74			ssize_t base = 0;
75
76			switch (whence) {
77			case SEEK_SET:
78			break;
79			case SEEK_CUR:
80			base = st->pos;
81			break;
82			case SEEK_END:
83			base = st->len;
84			break;
85			}
86
87			if (off > st->size - base \|\| off < -base) {
88			errno = EOVERFLOW;
89			return (-1);
90			}
91
92			st->pos = base + off;
93
94			return (st->pos);
95			}
96
97			static int
98			fmemopen_close(void *v)
99			{
100			free(v);
101
102			return (0);
103			}
104
105			static int
106			fmemopen_close_free(void *v)
107			{
108			struct state *st = v;
109
110			free(st->string);
111			free(st);
112
113			return (0);
114			}
115
116			FILE *
117			fmemopen(void buf, size_t size, const char mode)
118			{
119			struct state *st;
120			FILE *fp;
121			int flags, oflags;
122
123			if (size == 0) {
124			errno = EINVAL;
125			return (NULL);
126			}
127
128			if ((flags = __sflags(mode, &oflags)) == 0) {
129			errno = EINVAL;
130			return (NULL);
131			}
132
133			if (buf == NULL && ((oflags & O_RDWR) == 0)) {
134			errno = EINVAL;
135			return (NULL);
136			}
137
138			if ((st = malloc(sizeof(*st))) == NULL)
139			return (NULL);
140
141			if ((fp = __sfp()) == NULL) {
142			free(st);
143			return (NULL);
144			}
145
146			st->pos = 0;
147			st->len = (oflags & O_WRONLY) ? 0 : size;
148			st->size = size;
149			st->update = oflags & O_RDWR;
150
151			if (buf == NULL) {
152			if ((st->string = malloc(size)) == NULL) {
153			free(st);
154			fp->_flags = 0;
155			return (NULL);
156			}
157			*st->string = '\0';
158			} else {
159			st->string = (char *)buf;
160
161			if (oflags & O_TRUNC)
162			*st->string = '\0';
163
164			if (oflags & O_APPEND) {
165			char *p;
166
167			if ((p = memchr(st->string, '\0', size)) != NULL)
168			st->pos = st->len = (p - st->string);
169			else
170			st->pos = st->len = size;
171			}
172			}
173
174			fp->_flags = (short)flags;
175			fp->_file = -1;
176			fp->_cookie = (void *)st;
177			fp->_read = (flags & __SWR) ? NULL : fmemopen_read;
178			fp->_write = (flags & __SRD) ? NULL : fmemopen_write;
179			fp->_seek = fmemopen_seek;
180			fp->_close = (buf == NULL) ? fmemopen_close_free : fmemopen_close;
181
182			return (fp);
183			}
184			DEF_WEAK(fmemopen);