1/*-
2 * Copyright (c) 1991, 1993
3 *	The Regents of the University of California.  All rights reserved.
4 *
5 * This code is derived from software contributed to Berkeley by
6 * Kenneth Almquist.
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 * 4. Neither the name of the University nor the names of its contributors
17 *    may be used to endorse or promote products derived from this software
18 *    without specific prior written permission.
19 *
20 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
21 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
24 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
26 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
29 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
30 * SUCH DAMAGE.
31 */
32
33#ifndef lint
34#if 0
35static char sccsid[] = "@(#)memalloc.c	8.3 (Berkeley) 5/4/95";
36#endif
37#endif /* not lint */
38#include <sys/cdefs.h>
39__FBSDID("$FreeBSD$");
40
41#include <sys/param.h>
42#include "shell.h"
43#include "output.h"
44#include "memalloc.h"
45#include "error.h"
46#include "mystring.h"
47#include "expand.h"
48#include <stdlib.h>
49#include <unistd.h>
50
51/*
52 * Like malloc, but returns an error when out of space.
53 */
54
55pointer
56ckmalloc(size_t nbytes)
57{
58	pointer p;
59
60	INTOFF;
61	p = malloc(nbytes);
62	INTON;
63	if (p == NULL)
64		error("Out of space");
65	return p;
66}
67
68
69/*
70 * Same for realloc.
71 */
72
73pointer
74ckrealloc(pointer p, int nbytes)
75{
76	INTOFF;
77	p = realloc(p, nbytes);
78	INTON;
79	if (p == NULL)
80		error("Out of space");
81	return p;
82}
83
84void
85ckfree(pointer p)
86{
87	INTOFF;
88	free(p);
89	INTON;
90}
91
92
93/*
94 * Make a copy of a string in safe storage.
95 */
96
97char *
98savestr(const char *s)
99{
100	char *p;
101
102	p = ckmalloc(strlen(s) + 1);
103	scopy(s, p);
104	return p;
105}
106
107
108/*
109 * Parse trees for commands are allocated in lifo order, so we use a stack
110 * to make this more efficient, and also to avoid all sorts of exception
111 * handling code to handle interrupts in the middle of a parse.
112 *
113 * The size 496 was chosen because with 16-byte alignment the total size
114 * for the allocated block is 512.
115 */
116
117#define MINSIZE 496		/* minimum size of a block. */
118
119
120struct stack_block {
121	struct stack_block *prev;
122	/* Data follows */
123};
124#define SPACE(sp)	((char*)(sp) + ALIGN(sizeof(struct stack_block)))
125
126static struct stack_block *stackp;
127char *stacknxt;
128int stacknleft;
129char *sstrend;
130
131
132static void
133stnewblock(int nbytes)
134{
135	struct stack_block *sp;
136	int allocsize;
137
138	if (nbytes < MINSIZE)
139		nbytes = MINSIZE;
140
141	allocsize = ALIGN(sizeof(struct stack_block)) + ALIGN(nbytes);
142
143	INTOFF;
144	sp = ckmalloc(allocsize);
145	sp->prev = stackp;
146	stacknxt = SPACE(sp);
147	stacknleft = allocsize - (stacknxt - (char*)sp);
148	sstrend = stacknxt + stacknleft;
149	stackp = sp;
150	INTON;
151}
152
153
154pointer
155stalloc(int nbytes)
156{
157	char *p;
158
159	nbytes = ALIGN(nbytes);
160	if (nbytes > stacknleft)
161		stnewblock(nbytes);
162	p = stacknxt;
163	stacknxt += nbytes;
164	stacknleft -= nbytes;
165	return p;
166}
167
168
169void
170stunalloc(pointer p)
171{
172	if (p == NULL) {		/*DEBUG */
173		write(STDERR_FILENO, "stunalloc\n", 10);
174		abort();
175	}
176	stacknleft += stacknxt - (char *)p;
177	stacknxt = p;
178}
179
180
181
182void
183setstackmark(struct stackmark *mark)
184{
185	mark->stackp = stackp;
186	mark->stacknxt = stacknxt;
187	mark->stacknleft = stacknleft;
188	/* Ensure this block stays in place. */
189	if (stackp != NULL && stacknxt == SPACE(stackp))
190		stalloc(1);
191}
192
193
194void
195popstackmark(struct stackmark *mark)
196{
197	struct stack_block *sp;
198
199	INTOFF;
200	while (stackp != mark->stackp) {
201		sp = stackp;
202		stackp = sp->prev;
203		ckfree(sp);
204	}
205	stacknxt = mark->stacknxt;
206	stacknleft = mark->stacknleft;
207	sstrend = stacknxt + stacknleft;
208	INTON;
209}
210
211
212/*
213 * When the parser reads in a string, it wants to stick the string on the
214 * stack and only adjust the stack pointer when it knows how big the
215 * string is.  Stackblock (defined in stack.h) returns a pointer to a block
216 * of space on top of the stack and stackblocklen returns the length of
217 * this block.  Growstackblock will grow this space by at least one byte,
218 * possibly moving it (like realloc).  Grabstackblock actually allocates the
219 * part of the block that has been used.
220 */
221
222static void
223growstackblock(int min)
224{
225	char *p;
226	int newlen;
227	char *oldspace;
228	int oldlen;
229	struct stack_block *sp;
230	struct stack_block *oldstackp;
231
232	if (min < stacknleft)
233		min = stacknleft;
234	if ((unsigned int)min >=
235	    INT_MAX / 2 - ALIGN(sizeof(struct stack_block)))
236		error("Out of space");
237	min += stacknleft;
238	min += ALIGN(sizeof(struct stack_block));
239	newlen = 512;
240	while (newlen < min)
241		newlen <<= 1;
242	oldspace = stacknxt;
243	oldlen = stacknleft;
244
245	if (stackp != NULL && stacknxt == SPACE(stackp)) {
246		INTOFF;
247		oldstackp = stackp;
248		stackp = oldstackp->prev;
249		sp = ckrealloc((pointer)oldstackp, newlen);
250		sp->prev = stackp;
251		stackp = sp;
252		stacknxt = SPACE(sp);
253		stacknleft = newlen - (stacknxt - (char*)sp);
254		sstrend = stacknxt + stacknleft;
255		INTON;
256	} else {
257		newlen -= ALIGN(sizeof(struct stack_block));
258		p = stalloc(newlen);
259		if (oldlen != 0)
260			memcpy(p, oldspace, oldlen);
261		stunalloc(p);
262	}
263}
264
265
266
267/*
268 * The following routines are somewhat easier to use that the above.
269 * The user declares a variable of type STACKSTR, which may be declared
270 * to be a register.  The macro STARTSTACKSTR initializes things.  Then
271 * the user uses the macro STPUTC to add characters to the string.  In
272 * effect, STPUTC(c, p) is the same as *p++ = c except that the stack is
273 * grown as necessary.  When the user is done, she can just leave the
274 * string there and refer to it using stackblock().  Or she can allocate
275 * the space for it using grabstackstr().  If it is necessary to allow
276 * someone else to use the stack temporarily and then continue to grow
277 * the string, the user should use grabstack to allocate the space, and
278 * then call ungrabstr(p) to return to the previous mode of operation.
279 *
280 * USTPUTC is like STPUTC except that it doesn't check for overflow.
281 * CHECKSTACKSPACE can be called before USTPUTC to ensure that there
282 * is space for at least one character.
283 */
284
285static char *
286growstrstackblock(int n, int min)
287{
288	growstackblock(min);
289	return stackblock() + n;
290}
291
292char *
293growstackstr(void)
294{
295	int len;
296
297	len = stackblocksize();
298	return (growstrstackblock(len, 0));
299}
300
301
302/*
303 * Called from CHECKSTRSPACE.
304 */
305
306char *
307makestrspace(int min, char *p)
308{
309	int len;
310
311	len = p - stackblock();
312	return (growstrstackblock(len, min));
313}
314
315
316char *
317stputbin(const char *data, size_t len, char *p)
318{
319	CHECKSTRSPACE(len, p);
320	memcpy(p, data, len);
321	return (p + len);
322}
323
324char *
325stputs(const char *data, char *p)
326{
327	return (stputbin(data, strlen(data), p));
328}
329