Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	usr.sbin/npppd/npppd/../common/bytebuf.c	Lines:	0	77	0.0 %
Date:	2017-11-07	Branches:	0	34	0.0 %


/*	$OpenBSD: bytebuf.c,v 1.8 2015/12/05 18:43:36 mmcc Exp $ */
/*-
 * Copyright (c) 2009 Internet Initiative Japan Inc.
 * All rights reserved.
 *
 * 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 THE 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.
 */
/**@file
 * bytebuffer provides 'byte buffer' helper methods.
 *
 * Example:<pre>
 *	bytebuffer *buf = bytebuffer_create(BUFSIZ);
 *	int sz = read(STDIN_FILENO, bytebuffer_pointer(buf),
 *	    bytebuffer_remaining(buf));
 *	if (sz > 0) {
 *	    bytebuffer_put(buf, BYTEBUFFER_PUT_DIRECT, sz);
 *	    bytebuffer_flip(buf);
 *
 *	    sz = write(STDOUT_FILENO, bytebuffer_pointer(buf),
 *		bytebuffer_remaining(buf));
 *	    bytebuffer_compact(buf);
 *	}</pre>
 *
 * @author Yasuoka Masahiko
 * $Id: bytebuf.c,v 1.8 2015/12/05 18:43:36 mmcc Exp $
 */
#include <stdlib.h>
#include <string.h>
#include <errno.h>

#ifdef	BYTEBUF_DEBUG
#include <stdio.h>
#endif

#ifndef	BYTEBUF_ASSERT
#ifdef	BYTEBUF_DEBUG
#define	BYTEBUF_ASSERT(cond)						\
	if (!(cond)) {						\
	    fprintf(stderr,					\
		"\nASSERT(" #cond ") failed on %s() at %s:%d.\n"\
		, __func__, __FILE__, __LINE__);		\
	    abort(); 						\
	}
#else
#define	BYTEBUF_ASSERT(cond)
#endif
#endif

#include "bytebuf.h"

struct _bytebuffer {
	/** current position */
	int 	position;
	/** current limit */
	int	limit;
	/** position mark*/
	int 	mark;
	/** capacity of buffer */
	size_t 	capacity;
	/** allocated memory area */
	void	*data;
};

/**
 * Create a bytebuffer and allocate memory area.
 *
 * @param	capacity	Capacity of allocating memory.  If zero or
 *		    negative value is specified, this function don't allocate
 *		    memory.
 */
bytebuffer *
bytebuffer_create(size_t capacity)
{
	bytebuffer *_this = NULL;

	if ((_this = calloc(1, sizeof(bytebuffer))) == NULL)
		return NULL;

	if (capacity > 0) {
		if ((_this->data = calloc(1, capacity)) == NULL)
			goto fail;
		_this->capacity = capacity;
	} else
		_this->capacity = 0;

	_this->limit = _this->capacity;
	_this->mark = -1;
	return _this;
fail:
	free(_this);
	return NULL;
}

/**
 * Create a bytebuffer using existing memory area.  This memory area will
 * be freed by bytebuffer's destructor.
 *
 * @data		the pointer to existing memory area
 * @param capacity	capacity of 'data'.
 */
bytebuffer *
bytebuffer_wrap(void *data, size_t capacity)
{
	bytebuffer *_this;

	if ((_this = bytebuffer_create(0)) == NULL)
		return NULL;

	_this->data = data;
	_this->capacity = capacity;
	_this->mark = -1;

	return _this;
}

/**
 * Unwrap memory from bytebuffer.
 *
 * @param _this		the bytebuffer object.
 */
void *
bytebuffer_unwrap(bytebuffer *_this)
{
	void *rval;

	rval = _this->data;
	_this->data = NULL;
	_this->capacity = 0;
	_this->position = 0;
	_this->limit = 0;
	_this->mark = -1;

	return rval;
}

/**
 * Change capacity of this buffer.
 *
 * @param _this		the bytebuffer object.
 * @param capacity	new capacity.
 */
int
bytebuffer_realloc(bytebuffer *_this, size_t capacity)
{
	void *new_data;

	BYTEBUF_ASSERT(_this->limit <= capacity);

	if (_this->limit > capacity) {
		errno = EINVAL;
		return -1;
	}

	if ((new_data = realloc(_this->data, capacity)) == NULL)
		return -1;

	_this->data = new_data;
	if (_this->limit == _this->capacity)
		_this->limit = capacity;
	_this->capacity = capacity;

	return 0;
}

/**
 * Compact this buffer.  the bytes between position and limit are copied
 * to the beginning of the buffer.
 *
 * @param _this		the bytebuffer object.
 */
void
bytebuffer_compact(bytebuffer *_this)
{
	int len;

	len = bytebuffer_remaining(_this);

	if (len <= 0)
		len = 0;
	else if (_this->position != 0)
		memmove(_this->data,
		    (const char *)_this->data + _this->position, (size_t)len);

	_this->position = len;
	_this->limit = _this->capacity;
	_this->mark = -1;
}

static int bytebuffer_direct0;
/**
 * BYTEBUFFER_PUT_DIRECT specifies the data that has been written already by
 * direct access.
 */
const void * BYTEBUFFER_PUT_DIRECT = &bytebuffer_direct0;

/**
 * BYTEBUFFER_GET_DIRECT specifies the data that has been read already by
 * direct access.
 */
void * BYTEBUFFER_GET_DIRECT = &bytebuffer_direct0;

/**
 * Write the given data to the buffer.
 * If buffer is too small, this function returns <code>NULL</code> and
 * <code>errno</code> is <code>ENOBUFS</code>
 *
 * @param _this		the bytebuffer object.
 * @param src		source data.  To specify the data that has been
 *			written already by direct access, use
 *			{@link ::BYTEBUFFER_PUT_DIRECT} for putting the data.
 *			NULL is the same {@link ::BYTEBUFFER_PUT_DIRECT}
 *			at least on this version, but using NULL is deprecated.
 * @param srclen	length of the source data.
 * @see ::BYTEBUFFER_PUT_DIRECT
 */
void *
bytebuffer_put(bytebuffer *_this, const void *src, size_t srclen)
{
	void *rval;

	BYTEBUF_ASSERT(_this != NULL);
	BYTEBUF_ASSERT(srclen > 0);

	if (srclen > bytebuffer_remaining(_this)) {
		errno = ENOBUFS;
		return NULL;
	}
	rval = (char *)_this->data + _this->position;

	if (src != NULL && src != BYTEBUFFER_PUT_DIRECT)
		memcpy(rval, src, srclen);

	_this->position += srclen;

	return rval;
}

/*
 * Transfer data from this buffer to the given destination memory.
 * If the given buffer is too small, this function returns <code>NULL</code>
 * and <code>errno</code> is <code>ENOBUFS</code>
 *
 * @param	dst	pointer of the destination memory.  Specify NULL
 *			to skip transferring the data.
 * @param	dstlne	memory size of the destination.
 */
void *
bytebuffer_get(bytebuffer *_this, void *dst, size_t dstlen)
{
	BYTEBUF_ASSERT(_this != NULL);
	BYTEBUF_ASSERT(dstlen > 0);

	if (dstlen > bytebuffer_remaining(_this)) {
		errno = ENOBUFS;
		return NULL;
	}
	if (dst != NULL && dst != BYTEBUFFER_GET_DIRECT)
		memcpy(dst, (char *)_this->data + _this->position, dstlen);

	_this->position += dstlen;

	return dst;
}

/** Returns this buffer's position */
int
bytebuffer_position(bytebuffer *_this)
{
	BYTEBUF_ASSERT(_this != NULL);

	return _this->position;
}

/** Returns this buffer's limit */
int
bytebuffer_limit(bytebuffer *_this)
{
	BYTEBUF_ASSERT(_this != NULL);

	return _this->limit;
}

/** Returns this buffer's capacity */
int
bytebuffer_capacity(bytebuffer *_this)
{
	BYTEBUF_ASSERT(_this != NULL);

	return _this->capacity;
}

/** Returns a pointer to current position */
void *
bytebuffer_pointer(bytebuffer *_this)
{
	BYTEBUF_ASSERT(_this != NULL);

	return (char *)_this->data + _this->position;
}

/** Returns the number of byte between current position and the limit*/
size_t
bytebuffer_remaining(bytebuffer *_this)
{
	BYTEBUF_ASSERT(_this != NULL);
	BYTEBUF_ASSERT(_this->limit >= _this->position);

	return _this->limit - _this->position;
}

/** Returns whether there are data between current position and the limit */
int
bytebuffer_has_remaining(bytebuffer *_this)
{
	BYTEBUF_ASSERT(_this != NULL);

	return bytebuffer_remaining(_this) > 0;
}

/**
 * Flip this buffer.
 * The limit is set to the position and the position is set zero.
 */
void
bytebuffer_flip(bytebuffer *_this)
{
	BYTEBUF_ASSERT(_this != NULL);

	_this->limit = _this->position;
	_this->position = 0;
	_this->mark = -1;
}

/**
 * Rewind this buffer.
 * The position is set to zero.
 */
void
bytebuffer_rewind(bytebuffer *_this)
{
	BYTEBUF_ASSERT(_this != NULL);

	_this->position = 0;
	_this->mark = -1;
}

/**
 * Clear this buffer.
 * The position is set to zero.
 */
void
bytebuffer_clear(bytebuffer *_this)
{
	BYTEBUF_ASSERT(_this != NULL);

	_this->limit = _this->capacity;
	_this->position = 0;
	_this->mark = -1;
}

/** mark the current position.  */
void
bytebuffer_mark(bytebuffer *_this)
{
	BYTEBUF_ASSERT(_this != NULL);

	_this->mark = _this->position;
}

/** reset the position to the mark.  */
void
bytebuffer_reset(bytebuffer *_this)
{
	BYTEBUF_ASSERT(_this != NULL);
	BYTEBUF_ASSERT(_this->mark >= 0);

	if (_this->mark >= 0)
		_this->position = _this->mark;
}

/**
 * Destroy bytebuffer object.
 */
void
bytebuffer_destroy(bytebuffer *_this)
{
	BYTEBUF_ASSERT(_this != NULL);

	if (_this != NULL) {
		free(_this->data);
		free(_this);
	}
}


Generated by: GCOVR (Version 3.3)

Line	Branch	Exec	Source
1			/* $OpenBSD: bytebuf.c,v 1.8 2015/12/05 18:43:36 mmcc Exp $ */
2			/*-
3			* Copyright (c) 2009 Internet Initiative Japan Inc.
4			* All rights reserved.
5			*
6			* Redistribution and use in source and binary forms, with or without
7			* modification, are permitted provided that the following conditions
8			* are met:
9			* 1. Redistributions of source code must retain the above copyright
10			* notice, this list of conditions and the following disclaimer.
11			* 2. Redistributions in binary form must reproduce the above copyright
12			* notice, this list of conditions and the following disclaimer in the
13			* documentation and/or other materials provided with the distribution.
14			*
15			* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
16			* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17			* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18			* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
19			* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
20			* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
21			* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
22			* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
23			* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
24			* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
25			* SUCH DAMAGE.
26			*/
27			/**@file
28			* bytebuffer provides 'byte buffer' helper methods.
29			*
30			* Example:<pre>
31			* bytebuffer *buf = bytebuffer_create(BUFSIZ);
32			* int sz = read(STDIN_FILENO, bytebuffer_pointer(buf),
33			* bytebuffer_remaining(buf));
34			* if (sz > 0) {
35			* bytebuffer_put(buf, BYTEBUFFER_PUT_DIRECT, sz);
36			* bytebuffer_flip(buf);
37			*
38			* sz = write(STDOUT_FILENO, bytebuffer_pointer(buf),
39			* bytebuffer_remaining(buf));
40			* bytebuffer_compact(buf);
41			* }</pre>
42			*
43			* @author Yasuoka Masahiko
44			* $Id: bytebuf.c,v 1.8 2015/12/05 18:43:36 mmcc Exp $
45			*/
46			#include <stdlib.h>
47			#include <string.h>
48			#include <errno.h>
49
50			#ifdef BYTEBUF_DEBUG
51			#include <stdio.h>
52			#endif
53
54			#ifndef BYTEBUF_ASSERT
55			#ifdef BYTEBUF_DEBUG
56			#define BYTEBUF_ASSERT(cond) \
57			if (!(cond)) { \
58			fprintf(stderr, \
59			"\nASSERT(" #cond ") failed on %s() at %s:%d.\n"\
60			, __func__, __FILE__, __LINE__); \
61			abort(); \
62			}
63			#else
64			#define BYTEBUF_ASSERT(cond)
65			#endif
66			#endif
67
68			#include "bytebuf.h"
69
70			struct _bytebuffer {
71			/** current position */
72			int position;
73			/** current limit */
74			int limit;
75			/** position mark*/
76			int mark;
77			/** capacity of buffer */
78			size_t capacity;
79			/** allocated memory area */
80			void *data;
81			};
82
83			/**
84			* Create a bytebuffer and allocate memory area.
85			*
86			* @param capacity Capacity of allocating memory. If zero or
87			* negative value is specified, this function don't allocate
88			* memory.
89			*/
90			bytebuffer *
91			bytebuffer_create(size_t capacity)
92			{
93			bytebuffer *_this = NULL;
94
95			if ((_this = calloc(1, sizeof(bytebuffer))) == NULL)
96			return NULL;
97
98			if (capacity > 0) {
99			if ((_this->data = calloc(1, capacity)) == NULL)
100			goto fail;
101			_this->capacity = capacity;
102			} else
103			_this->capacity = 0;
104
105			_this->limit = _this->capacity;
106			_this->mark = -1;
107			return _this;
108			fail:
109			free(_this);
110			return NULL;
111			}
112
113			/**
114			* Create a bytebuffer using existing memory area. This memory area will
115			* be freed by bytebuffer's destructor.
116			*
117			* @data the pointer to existing memory area
118			* @param capacity capacity of 'data'.
119			*/
120			bytebuffer *
121			bytebuffer_wrap(void *data, size_t capacity)
122			{
123			bytebuffer *_this;
124
125			if ((_this = bytebuffer_create(0)) == NULL)
126			return NULL;
127
128			_this->data = data;
129			_this->capacity = capacity;
130			_this->mark = -1;
131
132			return _this;
133			}
134
135			/**
136			* Unwrap memory from bytebuffer.
137			*
138			* @param _this the bytebuffer object.
139			*/
140			void *
141			bytebuffer_unwrap(bytebuffer *_this)
142			{
143			void *rval;
144
145			rval = _this->data;
146			_this->data = NULL;
147			_this->capacity = 0;
148			_this->position = 0;
149			_this->limit = 0;
150			_this->mark = -1;
151
152			return rval;
153			}
154
155			/**
156			* Change capacity of this buffer.
157			*
158			* @param _this the bytebuffer object.
159			* @param capacity new capacity.
160			*/
161			int
162			bytebuffer_realloc(bytebuffer *_this, size_t capacity)
163			{
164			void *new_data;
165
166			BYTEBUF_ASSERT(_this->limit <= capacity);
167
168			if (_this->limit > capacity) {
169			errno = EINVAL;
170			return -1;
171			}
172
173			if ((new_data = realloc(_this->data, capacity)) == NULL)
174			return -1;
175
176			_this->data = new_data;
177			if (_this->limit == _this->capacity)
178			_this->limit = capacity;
179			_this->capacity = capacity;
180
181			return 0;
182			}
183
184			/**
185			* Compact this buffer. the bytes between position and limit are copied
186			* to the beginning of the buffer.
187			*
188			* @param _this the bytebuffer object.
189			*/
190			void
191			bytebuffer_compact(bytebuffer *_this)
192			{
193			int len;
194
195			len = bytebuffer_remaining(_this);
196
197			if (len <= 0)
198			len = 0;
199			else if (_this->position != 0)
200			memmove(_this->data,
201			(const char *)_this->data + _this->position, (size_t)len);
202
203			_this->position = len;
204			_this->limit = _this->capacity;
205			_this->mark = -1;
206			}
207
208			static int bytebuffer_direct0;
209			/**
210			* BYTEBUFFER_PUT_DIRECT specifies the data that has been written already by
211			* direct access.
212			*/
213			const void * BYTEBUFFER_PUT_DIRECT = &bytebuffer_direct0;
214
215			/**
216			* BYTEBUFFER_GET_DIRECT specifies the data that has been read already by
217			* direct access.
218			*/
219			void * BYTEBUFFER_GET_DIRECT = &bytebuffer_direct0;
220
221			/**
222			* Write the given data to the buffer.
223			* If buffer is too small, this function returns <code>NULL</code> and
224			* <code>errno</code> is <code>ENOBUFS</code>
225			*
226			* @param _this the bytebuffer object.
227			* @param src source data. To specify the data that has been
228			* written already by direct access, use
229			* {@link ::BYTEBUFFER_PUT_DIRECT} for putting the data.
230			* NULL is the same {@link ::BYTEBUFFER_PUT_DIRECT}
231			* at least on this version, but using NULL is deprecated.
232			* @param srclen length of the source data.
233			* @see ::BYTEBUFFER_PUT_DIRECT
234			*/
235			void *
236			bytebuffer_put(bytebuffer _this, const void src, size_t srclen)
237			{
238			void *rval;
239
240			BYTEBUF_ASSERT(_this != NULL);
241			BYTEBUF_ASSERT(srclen > 0);
242
243			if (srclen > bytebuffer_remaining(_this)) {
244			errno = ENOBUFS;
245			return NULL;
246			}
247			rval = (char *)_this->data + _this->position;
248
249			if (src != NULL && src != BYTEBUFFER_PUT_DIRECT)
250			memcpy(rval, src, srclen);
251
252			_this->position += srclen;
253
254			return rval;
255			}
256
257			/*
258			* Transfer data from this buffer to the given destination memory.
259			* If the given buffer is too small, this function returns <code>NULL</code>
260			* and <code>errno</code> is <code>ENOBUFS</code>
261			*
262			* @param dst pointer of the destination memory. Specify NULL
263			* to skip transferring the data.
264			* @param dstlne memory size of the destination.
265			*/
266			void *
267			bytebuffer_get(bytebuffer _this, void dst, size_t dstlen)
268			{
269			BYTEBUF_ASSERT(_this != NULL);
270			BYTEBUF_ASSERT(dstlen > 0);
271
272			if (dstlen > bytebuffer_remaining(_this)) {
273			errno = ENOBUFS;
274			return NULL;
275			}
276			if (dst != NULL && dst != BYTEBUFFER_GET_DIRECT)
277			memcpy(dst, (char *)_this->data + _this->position, dstlen);
278
279			_this->position += dstlen;
280
281			return dst;
282			}
283
284			/** Returns this buffer's position */
285			int
286			bytebuffer_position(bytebuffer *_this)
287			{
288			BYTEBUF_ASSERT(_this != NULL);
289
290			return _this->position;
291			}
292
293			/** Returns this buffer's limit */
294			int
295			bytebuffer_limit(bytebuffer *_this)
296			{
297			BYTEBUF_ASSERT(_this != NULL);
298
299			return _this->limit;
300			}
301
302			/** Returns this buffer's capacity */
303			int
304			bytebuffer_capacity(bytebuffer *_this)
305			{
306			BYTEBUF_ASSERT(_this != NULL);
307
308			return _this->capacity;
309			}
310
311			/** Returns a pointer to current position */
312			void *
313			bytebuffer_pointer(bytebuffer *_this)
314			{
315			BYTEBUF_ASSERT(_this != NULL);
316
317			return (char *)_this->data + _this->position;
318			}
319
320			/** Returns the number of byte between current position and the limit*/
321			size_t
322			bytebuffer_remaining(bytebuffer *_this)
323			{
324			BYTEBUF_ASSERT(_this != NULL);
325			BYTEBUF_ASSERT(_this->limit >= _this->position);
326
327			return _this->limit - _this->position;
328			}
329
330			/** Returns whether there are data between current position and the limit */
331			int
332			bytebuffer_has_remaining(bytebuffer *_this)
333			{
334			BYTEBUF_ASSERT(_this != NULL);
335
336			return bytebuffer_remaining(_this) > 0;
337			}
338
339			/**
340			* Flip this buffer.
341			* The limit is set to the position and the position is set zero.
342			*/
343			void
344			bytebuffer_flip(bytebuffer *_this)
345			{
346			BYTEBUF_ASSERT(_this != NULL);
347
348			_this->limit = _this->position;
349			_this->position = 0;
350			_this->mark = -1;
351			}
352
353			/**
354			* Rewind this buffer.
355			* The position is set to zero.
356			*/
357			void
358			bytebuffer_rewind(bytebuffer *_this)
359			{
360			BYTEBUF_ASSERT(_this != NULL);
361
362			_this->position = 0;
363			_this->mark = -1;
364			}
365
366			/**
367			* Clear this buffer.
368			* The position is set to zero.
369			*/
370			void
371			bytebuffer_clear(bytebuffer *_this)
372			{
373			BYTEBUF_ASSERT(_this != NULL);
374
375			_this->limit = _this->capacity;
376			_this->position = 0;
377			_this->mark = -1;
378			}
379
380			/** mark the current position. */
381			void
382			bytebuffer_mark(bytebuffer *_this)
383			{
384			BYTEBUF_ASSERT(_this != NULL);
385
386			_this->mark = _this->position;
387			}
388
389			/** reset the position to the mark. */
390			void
391			bytebuffer_reset(bytebuffer *_this)
392			{
393			BYTEBUF_ASSERT(_this != NULL);
394			BYTEBUF_ASSERT(_this->mark >= 0);
395
396			if (_this->mark >= 0)
397			_this->position = _this->mark;
398			}
399
400			/**
401			* Destroy bytebuffer object.
402			*/
403			void
404			bytebuffer_destroy(bytebuffer *_this)
405			{
406			BYTEBUF_ASSERT(_this != NULL);
407
408			if (_this != NULL) {
409			free(_this->data);
410			free(_this);
411			}
412			}