[J-u-boot.git] / lib / membuff.c

// SPDX-License-Identifier: GPL-2.0+
/*
 * Copyright (c) 2015 Google, Inc
 * Written by Simon Glass <[email protected]>
 *
 * Copyright (c) 1992 Simon Glass
 */

#include <errno.h>
#include <log.h>
#include <malloc.h>
#include "membuff.h"

void membuff_purge(struct membuff *mb)
{
	/* set mb->head and mb->tail so the buffers look empty */
	mb->head = mb->start;
	mb->tail = mb->start;
}

static int membuff_putrawflex(struct membuff *mb, int maxlen, bool update,
			      char ***data, int *offsetp)
{
	int len;

	/* always write to 'mb->head' */
	assert(data && offsetp);
	*data = &mb->start;
	*offsetp = mb->head - mb->start;

	/* if there is no buffer, we can do nothing */
	if (!mb->start)
		return 0;

	/*
	 * if head is ahead of tail, we can write from head until the end of
	 * the buffer
	 */
	if (mb->head >= mb->tail) {
		/* work out how many bytes can fit here */
		len = mb->end - mb->head - 1;
		if (maxlen >= 0 && len > maxlen)
			len = maxlen;

		/* update the head pointer to mark these bytes as written */
		if (update)
			mb->head += len;

		/*
		 * if the tail isn't at start of the buffer, then we can
		 * write one more byte right at the end
		 */
		if ((maxlen < 0 || len < maxlen) && mb->tail != mb->start) {
			len++;
			if (update)
				mb->head = mb->start;
		}

	/* otherwise now we can write until head almost reaches tail */
	} else {
		/* work out how many bytes can fit here */
		len = mb->tail - mb->head - 1;
		if (maxlen >= 0 && len > maxlen)
			len = maxlen;

		/* update the head pointer to mark these bytes as written */
		if (update)
			mb->head += len;
	}

	/* return the number of bytes which can be/must be written */
	return len;
}

int membuff_putraw(struct membuff *mb, int maxlen, bool update, char **data)
{
	char **datap;
	int offset;
	int size;

	size = membuff_putrawflex(mb, maxlen, update, &datap, &offset);
	*data = *datap + offset;

	return size;
}

bool membuff_putbyte(struct membuff *mb, int ch)
{
	char *data;

	if (membuff_putraw(mb, 1, true, &data) != 1)
		return false;
	*data = ch;

	return true;
}

int membuff_getraw(struct membuff *mb, int maxlen, bool update, char **data)
{
	int len;

	/* assume for now there is no data to get */
	len = 0;

	/*
	 * in this case head is ahead of tail, so we must return data between
	 *'tail' and 'head'
	 */
	if (mb->head > mb->tail) {
		/* work out the amount of data */
		*data = mb->tail;
		len = mb->head - mb->tail;

		/* check it isn't too much */
		if (maxlen >= 0 && len > maxlen)
			len = maxlen;

		/* & mark it as read from the buffer */
		if (update)
			mb->tail += len;
	}

	/*
	 * if head is before tail, then we have data between 'tail' and 'end'
	 * and some more data between 'start' and 'head'(which we can't
	 * return this time
	 */
	else if (mb->head < mb->tail) {
		/* work out the amount of data */
		*data = mb->tail;
		len = mb->end - mb->tail;
		if (maxlen >= 0 && len > maxlen)
			len = maxlen;
		if (update) {
			mb->tail += len;
			if (mb->tail == mb->end)
				mb->tail = mb->start;
		}
	}

	debug("getraw: maxlen=%d, update=%d, head=%d, tail=%d, data=%d, len=%d",
	      maxlen, update, (int)(mb->head - mb->start),
	      (int)(mb->tail - mb->start), (int)(*data - mb->start), len);

	/* return the number of bytes we found */
	return len;
}

int membuff_getbyte(struct membuff *mb)
{
	char *data = 0;

	return membuff_getraw(mb, 1, true, &data) != 1 ? -1 : *(uint8_t *)data;
}

int membuff_peekbyte(struct membuff *mb)
{
	char *data = 0;

	return membuff_getraw(mb, 1, false, &data) != 1 ? -1 : *(uint8_t *)data;
}

int membuff_get(struct membuff *mb, char *buff, int maxlen)
{
	char *data = 0, *buffptr = buff;
	int len = 1, i;

	/*
	 * do this in up to two lots(see GetRaw for why) stopping when there
	 * is no more data
	 */
	for (i = 0; len && i < 2; i++) {
		/* get a pointer to the data available */
		len = membuff_getraw(mb, maxlen, true, &data);

		/* copy it into the buffer */
		memcpy(buffptr, data, len);
		buffptr += len;
		maxlen -= len;
	}

	/* return the number of bytes read */
	return buffptr - buff;
}

int membuff_put(struct membuff *mb, const char *buff, int length)
{
	char *data;
	int towrite, i, written;

	for (i = written = 0; i < 2; i++) {
		/* ask where some data can be written */
		towrite = membuff_putraw(mb, length, true, &data);

		/* and write it, updating the bytes length */
		memcpy(data, buff, towrite);
		written += towrite;
		buff += towrite;
		length -= towrite;
	}

	/* return the number of bytes written */
	return written;
}

bool membuff_isempty(struct membuff *mb)
{
	return mb->head == mb->tail;
}

int membuff_avail(struct membuff *mb)
{
	struct membuff copy;
	int i, avail;
	char *data = 0;

	/* make a copy of this buffer's control data */
	copy = *mb;

	/* now read everything out of the copied buffer */
	for (i = avail = 0; i < 2; i++)
		avail += membuff_getraw(&copy, -1, true, &data);

	/* and return how much we read */
	return avail;
}

int membuff_size(struct membuff *mb)
{
	return mb->end - mb->start;
}

bool membuff_makecontig(struct membuff *mb)
{
	int topsize, botsize;

	debug("makecontig: head=%d, tail=%d, size=%d",
	      (int)(mb->head - mb->start), (int)(mb->tail - mb->start),
	      (int)(mb->end - mb->start));

	/*
	 * first we move anything at the start of the buffer into the correct
	 * place some way along
	 */
	if (mb->tail > mb->head) {
		/*
		 * the data is split into two parts, from 0 to ->head and
		 * from ->tail to ->end. We move the stuff from 0 to ->head
		 * up to make space for the other data before it
		 */
		topsize = mb->end - mb->tail;
		botsize = mb->head - mb->start;

		/*
		 * must move data at bottom up by 'topsize' bytes - check if
		 * there's room
		 */
		if (mb->head + topsize >= mb->tail)
			return false;
		memmove(mb->start + topsize, mb->start, botsize);
		debug("	- memmove(%d, %d, %d)", topsize, 0, botsize);

	/* nothing at the start, so skip that step */
	} else {
		topsize = mb->head - mb->tail;
		botsize = 0;
	}

	/* now move data at top down to the bottom */
	memcpy(mb->start, mb->tail, topsize);
	debug("	- memcpy(%d, %d, %d)", 0, (int)(mb->tail - mb->start), topsize);

	/* adjust pointers */
	mb->tail = mb->start;
	mb->head = mb->start + topsize + botsize;

	debug("	- head=%d, tail=%d", (int)(mb->head - mb->start),
	      (int)(mb->tail - mb->start));

	/* all ok */
	return true;
}

int membuff_free(struct membuff *mb)
{
	return mb->end == mb->start ? 0 :
			(mb->end - mb->start) - 1 - membuff_avail(mb);
}

int membuff_readline(struct membuff *mb, char *str, int maxlen, int minch, bool must_fit)
{
	int len;  /* number of bytes read (!= string length) */
	char *s, *end;
	bool ok = false;
	char *orig = str;

	end = mb->head >= mb->tail ? mb->head : mb->end;
	for (len = 0, s = mb->tail; s < end && len < maxlen - 1; str++) {
		*str = *s++;
		len++;
		if (*str == '\n' || *str < minch) {
			ok = true;
			break;
		}
		if (s == end && mb->tail > mb->head) {
			s = mb->start;
			end = mb->head;
		}
	}

	/* couldn't get the whole string */
	if (!ok && must_fit) {
		if (maxlen)
			*orig = '\0';
		return 0;
	}

	/* terminate the string, update the membuff and return success */
	*str = '\0';
	mb->tail = s == mb->end ? mb->start : s;

	return len;
}

int membuff_extend_by(struct membuff *mb, int by, int max)
{
	int oldhead, oldtail;
	int size, orig;
	char *ptr;

	/* double the buffer size until it is big enough */
	assert(by >= 0);
	for (orig = mb->end - mb->start, size = orig; size < orig + by;)
		size *= 2;
	if (max != -1)
		size = min(size, max);
	by = size - orig;

	/* if we're already at maximum, give up */
	if (by <= 0)
		return -E2BIG;

	oldhead = mb->head - mb->start;
	oldtail = mb->tail - mb->start;
	ptr = realloc(mb->start, size);
	if (!ptr)
		return -ENOMEM;
	mb->start = ptr;
	mb->head = mb->start + oldhead;
	mb->tail = mb->start + oldtail;

	if (mb->head < mb->tail) {
		memmove(mb->tail + by, mb->tail, orig - oldtail);
		mb->tail += by;
	}
	mb->end = mb->start + size;

	return 0;
}

void membuff_init(struct membuff *mb, char *buff, int size)
{
	mb->start = buff;
	mb->end = mb->start + size;
	membuff_purge(mb);
}

int membuff_new(struct membuff *mb, int size)
{
	mb->start = malloc(size);
	if (!mb->start)
		return -ENOMEM;

	membuff_init(mb, mb->start, size);
	return 0;
}

void membuff_uninit(struct membuff *mb)
{
	mb->end = NULL;
	mb->start = NULL;
	membuff_purge(mb);
}

void membuff_dispose(struct membuff *mb)
{
	free(&mb->start);
	membuff_uninit(mb);
}
Commit	Line	Data
83d290c5	1	// SPDX-License-Identifier: GPL-2.0+
b7b65090 SG	2	/*
	3	* Copyright (c) 2015 Google, Inc
	4	* Written by Simon Glass <[email protected]>
	5	*
	6	* Copyright (c) 1992 Simon Glass
b7b65090 SG	7	*/
b7b65090 SG	8
b7b65090	9	#include <errno.h>
f7ae49fc	10	#include <log.h>
b7b65090 SG	11	#include <malloc.h>
	12	#include "membuff.h"
	13
	14	void membuff_purge(struct membuff *mb)
	15	{
	16	/* set mb->head and mb->tail so the buffers look empty */
	17	mb->head = mb->start;
	18	mb->tail = mb->start;
	19	}
	20
	21	static int membuff_putrawflex(struct membuff *mb, int maxlen, bool update,
	22	char **data, int offsetp)
	23	{
	24	int len;
	25
	26	/* always write to 'mb->head' */
	27	assert(data && offsetp);
	28	*data = &mb->start;
	29	*offsetp = mb->head - mb->start;
	30
	31	/* if there is no buffer, we can do nothing */
	32	if (!mb->start)
	33	return 0;
	34
	35	/*
	36	* if head is ahead of tail, we can write from head until the end of
	37	* the buffer
	38	*/
	39	if (mb->head >= mb->tail) {
	40	/* work out how many bytes can fit here */
	41	len = mb->end - mb->head - 1;
	42	if (maxlen >= 0 && len > maxlen)
	43	len = maxlen;
	44
	45	/* update the head pointer to mark these bytes as written */
	46	if (update)
	47	mb->head += len;
	48
	49	/*
	50	* if the tail isn't at start of the buffer, then we can
	51	* write one more byte right at the end
	52	*/
	53	if ((maxlen < 0 \|\| len < maxlen) && mb->tail != mb->start) {
	54	len++;
	55	if (update)
	56	mb->head = mb->start;
	57	}
	58
	59	/* otherwise now we can write until head almost reaches tail */
	60	} else {
	61	/* work out how many bytes can fit here */
	62	len = mb->tail - mb->head - 1;
	63	if (maxlen >= 0 && len > maxlen)
	64	len = maxlen;
	65
	66	/* update the head pointer to mark these bytes as written */
	67	if (update)
	68	mb->head += len;
	69	}
	70
	71	/* return the number of bytes which can be/must be written */
	72	return len;
	73	}
	74
75	int membuff_putraw(struct membuff mb, int maxlen, bool update, char *data)
76	{
77	char **datap;
78	int offset;
79	int size;
80
81	size = membuff_putrawflex(mb, maxlen, update, &datap, &offset);
82	data = datap + offset;
83
84	return size;
85	}
86
87	bool membuff_putbyte(struct membuff *mb, int ch)
88	{
89	char *data;
90
91	if (membuff_putraw(mb, 1, true, &data) != 1)
92	return false;
93	*data = ch;
94
95	return true;
96	}
97
98	int membuff_getraw(struct membuff mb, int maxlen, bool update, char *data)
99	{
100	int len;
101
102	/* assume for now there is no data to get */
103	len = 0;
104
105	/*
106	* in this case head is ahead of tail, so we must return data between
107	*'tail' and 'head'
108	*/
109	if (mb->head > mb->tail) {
110	/* work out the amount of data */
111	*data = mb->tail;
112	len = mb->head - mb->tail;
113
114	/* check it isn't too much */
115	if (maxlen >= 0 && len > maxlen)
116	len = maxlen;
117
118	/* & mark it as read from the buffer */
119	if (update)
120	mb->tail += len;
121	}
122
123	/*
124	* if head is before tail, then we have data between 'tail' and 'end'
125	* and some more data between 'start' and 'head'(which we can't
126	* return this time
127	*/
128	else if (mb->head < mb->tail) {
129	/* work out the amount of data */
130	*data = mb->tail;
131	len = mb->end - mb->tail;
132	if (maxlen >= 0 && len > maxlen)
133	len = maxlen;
134	if (update) {
135	mb->tail += len;
136	if (mb->tail == mb->end)
137	mb->tail = mb->start;
138	}
139	}
140
141	debug("getraw: maxlen=%d, update=%d, head=%d, tail=%d, data=%d, len=%d",
142	maxlen, update, (int)(mb->head - mb->start),
143	(int)(mb->tail - mb->start), (int)(*data - mb->start), len);
144
145	/* return the number of bytes we found */
146	return len;
147	}
148
149	int membuff_getbyte(struct membuff *mb)
150	{
151	char *data = 0;
152
153	return membuff_getraw(mb, 1, true, &data) != 1 ? -1 : (uint8_t )data;
154	}
155
156	int membuff_peekbyte(struct membuff *mb)
157	{
158	char *data = 0;
159
160	return membuff_getraw(mb, 1, false, &data) != 1 ? -1 : (uint8_t )data;
161	}
162
163	int membuff_get(struct membuff mb, char buff, int maxlen)
164	{
165	char data = 0, buffptr = buff;
166	int len = 1, i;
167
168	/*
169	* do this in up to two lots(see GetRaw for why) stopping when there
170	* is no more data
171	*/
172	for (i = 0; len && i < 2; i++) {
173	/* get a pointer to the data available */
174	len = membuff_getraw(mb, maxlen, true, &data);
175
176	/* copy it into the buffer */
177	memcpy(buffptr, data, len);
178	buffptr += len;
179	maxlen -= len;
180	}
181
182	/* return the number of bytes read */
183	return buffptr - buff;
184	}
185
186	int membuff_put(struct membuff mb, const char buff, int length)
187	{
188	char *data;
189	int towrite, i, written;
190
191	for (i = written = 0; i < 2; i++) {
192	/* ask where some data can be written */
193	towrite = membuff_putraw(mb, length, true, &data);
194
195	/* and write it, updating the bytes length */
196	memcpy(data, buff, towrite);
197	written += towrite;
198	buff += towrite;
199	length -= towrite;
200	}
201
202	/* return the number of bytes written */
203	return written;
204	}
205
206	bool membuff_isempty(struct membuff *mb)
207	{
208	return mb->head == mb->tail;
209	}
210
211	int membuff_avail(struct membuff *mb)
212	{
213	struct membuff copy;
214	int i, avail;
215	char *data = 0;
216
217	/* make a copy of this buffer's control data */
218	copy = *mb;
219
220	/* now read everything out of the copied buffer */
221	for (i = avail = 0; i < 2; i++)
222	avail += membuff_getraw(&copy, -1, true, &data);
223
224	/* and return how much we read */
225	return avail;
226	}
227
228	int membuff_size(struct membuff *mb)
229	{
230	return mb->end - mb->start;
231	}
232
233	bool membuff_makecontig(struct membuff *mb)
234	{
235	int topsize, botsize;
236
237	debug("makecontig: head=%d, tail=%d, size=%d",
238	(int)(mb->head - mb->start), (int)(mb->tail - mb->start),
239	(int)(mb->end - mb->start));
240
241	/*
242	* first we move anything at the start of the buffer into the correct
243	* place some way along
244	*/
245	if (mb->tail > mb->head) {
246	/*
247	* the data is split into two parts, from 0 to ->head and
248	* from ->tail to ->end. We move the stuff from 0 to ->head
249	* up to make space for the other data before it
250	*/
251	topsize = mb->end - mb->tail;
252	botsize = mb->head - mb->start;
253
254	/*
255	* must move data at bottom up by 'topsize' bytes - check if
256	* there's room
257	*/
258	if (mb->head + topsize >= mb->tail)
259	return false;
260	memmove(mb->start + topsize, mb->start, botsize);
261	debug(" - memmove(%d, %d, %d)", topsize, 0, botsize);
262
263	/* nothing at the start, so skip that step */
264	} else {
265	topsize = mb->head - mb->tail;
266	botsize = 0;
267	}
268
269	/* now move data at top down to the bottom */
270	memcpy(mb->start, mb->tail, topsize);
271	debug(" - memcpy(%d, %d, %d)", 0, (int)(mb->tail - mb->start), topsize);
272
273	/* adjust pointers */
274	mb->tail = mb->start;
275	mb->head = mb->start + topsize + botsize;
276
277	debug(" - head=%d, tail=%d", (int)(mb->head - mb->start),
278	(int)(mb->tail - mb->start));
279
280	/* all ok */
281	return true;
282	}
283
284	int membuff_free(struct membuff *mb)
285	{
286	return mb->end == mb->start ? 0 :
287	(mb->end - mb->start) - 1 - membuff_avail(mb);
288	}
289
e58bafc3	290	int membuff_readline(struct membuff mb, char str, int maxlen, int minch, bool must_fit)
b7b65090 SG	291	{
	292	int len; /* number of bytes read (!= string length) */
	293	char s, end;
	294	bool ok = false;
	295	char *orig = str;
	296
	297	end = mb->head >= mb->tail ? mb->head : mb->end;
	298	for (len = 0, s = mb->tail; s < end && len < maxlen - 1; str++) {
	299	str = s++;
	300	len++;
	301	if (str == '\n' \|\| str < minch) {
	302	ok = true;
	303	break;
	304	}
	305	if (s == end && mb->tail > mb->head) {
	306	s = mb->start;
	307	end = mb->head;
	308	}
	309	}
	310
	311	/* couldn't get the whole string */
e58bafc3	312	if (!ok && must_fit) {
b7b65090 SG	313	if (maxlen)
	314	*orig = '\0';
	315	return 0;
	316	}
	317
	318	/* terminate the string, update the membuff and return success */
	319	*str = '\0';
	320	mb->tail = s == mb->end ? mb->start : s;
	321
	322	return len;
	323	}
	324
	325	int membuff_extend_by(struct membuff *mb, int by, int max)
	326	{
	327	int oldhead, oldtail;
	328	int size, orig;
	329	char *ptr;
	330
	331	/* double the buffer size until it is big enough */
	332	assert(by >= 0);
	333	for (orig = mb->end - mb->start, size = orig; size < orig + by;)
	334	size *= 2;
	335	if (max != -1)
	336	size = min(size, max);
	337	by = size - orig;
	338
	339	/* if we're already at maximum, give up */
	340	if (by <= 0)
	341	return -E2BIG;
	342
	343	oldhead = mb->head - mb->start;
	344	oldtail = mb->tail - mb->start;
	345	ptr = realloc(mb->start, size);
	346	if (!ptr)
	347	return -ENOMEM;
	348	mb->start = ptr;
	349	mb->head = mb->start + oldhead;
	350	mb->tail = mb->start + oldtail;
	351
	352	if (mb->head < mb->tail) {
	353	memmove(mb->tail + by, mb->tail, orig - oldtail);
	354	mb->tail += by;
	355	}
	356	mb->end = mb->start + size;
	357
	358	return 0;
	359	}
	360
	361	void membuff_init(struct membuff mb, char buff, int size)
	362	{
	363	mb->start = buff;
	364	mb->end = mb->start + size;
	365	membuff_purge(mb);
	366	}
	367
	368	int membuff_new(struct membuff *mb, int size)
	369	{
	370	mb->start = malloc(size);
	371	if (!mb->start)
	372	return -ENOMEM;
	373
	374	membuff_init(mb, mb->start, size);
	375	return 0;
	376	}
377
378	void membuff_uninit(struct membuff *mb)
379	{
380	mb->end = NULL;
381	mb->start = NULL;
382	membuff_purge(mb);
383	}
384
385	void membuff_dispose(struct membuff *mb)
386	{
387	free(&mb->start);
388	membuff_uninit(mb);
389	}