1 /* $NetBSD: memalloc.c,v 1.39 2023/04/07 10:42:28 kre Exp $ */
2
3 /*-
4 * Copyright (c) 1991, 1993
5 * The Regents of the University of California. All rights reserved.
6 *
7 * This code is derived from software contributed to Berkeley by
8 * Kenneth Almquist.
9 *
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
12 * are met:
13 * 1. Redistributions of source code must retain the above copyright
14 * notice, this list of conditions and the following disclaimer.
15 * 2. Redistributions in binary form must reproduce the above copyright
16 * notice, this list of conditions and the following disclaimer in the
17 * documentation and/or other materials provided with the distribution.
18 * 3. Neither the name of the University nor the names of its contributors
19 * may be used to endorse or promote products derived from this software
20 * without specific prior written permission.
21 *
22 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
23 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
24 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
25 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
26 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
27 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
28 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
29 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
30 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
31 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32 * SUCH DAMAGE.
33 */
34
35 #include <sys/cdefs.h>
36 #ifndef lint
37 #if 0
38 static char sccsid[] = "@(#)memalloc.c 8.3 (Berkeley) 5/4/95";
39 #else
40 __RCSID("$NetBSD: memalloc.c,v 1.39 2023/04/07 10:42:28 kre Exp $");
41 #endif
42 #endif /* not lint */
43
44 #include <limits.h>
45 #include <stdarg.h>
46 #include <stdlib.h>
47 #include <unistd.h>
48
49 #include "shell.h"
50 #include "output.h"
51 #include "memalloc.h"
52 #include "error.h"
53 #include "machdep.h"
54 #include "mystring.h"
55
56 /*
57 * Like malloc, but returns an error when out of space.
58 */
59
60 pointer
ckmalloc(size_t nbytes)61 ckmalloc(size_t nbytes)
62 {
63 pointer p;
64
65 p = malloc(nbytes);
66 if (p == NULL)
67 error("Out of space");
68 return p;
69 }
70
71
72 /*
73 * Same for realloc.
74 */
75
76 pointer
ckrealloc(pointer p,int nbytes)77 ckrealloc(pointer p, int nbytes)
78 {
79 p = realloc(p, nbytes);
80 if (p == NULL)
81 error("Out of space");
82 return p;
83 }
84
85
86 /*
87 * Make a copy of a string in safe storage.
88 */
89
90 char *
savestr(const char * s)91 savestr(const char *s)
92 {
93 char *p;
94
95 p = ckmalloc(strlen(s) + 1);
96 scopy(s, p);
97 return p;
98 }
99
100
101 /*
102 * Parse trees for commands are allocated in lifo order, so we use a stack
103 * to make this more efficient, and also to avoid all sorts of exception
104 * handling code to handle interrupts in the middle of a parse.
105 *
106 * The size 504 was chosen because the Ultrix malloc handles that size
107 * well.
108 */
109
110 #define MINSIZE 504 /* minimum size of a block */
111
112 struct stack_block {
113 struct stack_block *prev;
114 char space[MINSIZE];
115 };
116
117 struct stack_block stackbase;
118 struct stack_block *stackp = &stackbase;
119 struct stackmark *markp;
120 char *stacknxt = stackbase.space;
121 int stacknleft = MINSIZE;
122 int sstrnleft;
123 int herefd = -1;
124
125 pointer
stalloc(int nbytes)126 stalloc(int nbytes)
127 {
128 char *p;
129
130 nbytes = SHELL_ALIGN(nbytes);
131 if (nbytes > stacknleft) {
132 int blocksize;
133 struct stack_block *sp;
134
135 blocksize = nbytes;
136 if (blocksize < MINSIZE)
137 blocksize = MINSIZE;
138 INTOFF;
139 sp = ckmalloc(sizeof(struct stack_block) - MINSIZE + blocksize);
140 sp->prev = stackp;
141 stacknxt = sp->space;
142 stacknleft = blocksize;
143 stackp = sp;
144 INTON;
145 }
146 INTOFF;
147 p = stacknxt;
148 stacknxt += nbytes;
149 stacknleft -= nbytes;
150 INTON;
151 return p;
152 }
153
154
155 void
stunalloc(pointer p)156 stunalloc(pointer p)
157 {
158 if (p == NULL) { /*DEBUG */
159 write(2, "stunalloc\n", 10);
160 abort();
161 }
162 stacknleft += stacknxt - (char *)p;
163 stacknxt = p;
164 }
165
166
167 /* save the current status of the sh stack */
168 void
setstackmark(struct stackmark * mark)169 setstackmark(struct stackmark *mark)
170 {
171 mark->stackp = stackp;
172 mark->stacknxt = stacknxt;
173 mark->stacknleft = stacknleft;
174 mark->sstrnleft = sstrnleft;
175 mark->marknext = markp;
176 markp = mark;
177 }
178
179 /* reset the stack mark, and remove it from the list of marks */
180 void
popstackmark(struct stackmark * mark)181 popstackmark(struct stackmark *mark)
182 {
183 INTOFF;
184 markp = mark->marknext; /* delete mark from the list */
185 rststackmark(mark); /* and reset stack */
186 INTON;
187 }
188
189 /* reset the shell stack to its state recorded in the stack mark */
190 void
rststackmark(struct stackmark * mark)191 rststackmark(struct stackmark *mark)
192 {
193 struct stack_block *sp;
194
195 INTOFF;
196 while (stackp != mark->stackp) {
197 /* delete any recently allocated mem blocks */
198 sp = stackp;
199 stackp = sp->prev;
200 ckfree(sp);
201 }
202 stacknxt = mark->stacknxt;
203 stacknleft = mark->stacknleft;
204 sstrnleft = mark->sstrnleft;
205 INTON;
206 }
207
208
209 /*
210 * When the parser reads in a string, it wants to stick the string on the
211 * stack and only adjust the stack pointer when it knows how big the
212 * string is. Stackblock (defined in stack.h) returns a pointer to a block
213 * of space on top of the stack and stackblocklen returns the length of
214 * this block. Growstackblock will grow this space by at least one byte,
215 * possibly moving it (like realloc). Grabstackblock actually allocates the
216 * part of the block that has been used.
217 */
218
219 void
growstackblock(void)220 growstackblock(void)
221 {
222 int newlen = SHELL_ALIGN(stacknleft * 2 + 100);
223
224 INTOFF;
225 if (stacknxt == stackp->space && stackp != &stackbase) {
226 struct stack_block *oldstackp;
227 struct stackmark *xmark;
228 struct stack_block *sp;
229
230 oldstackp = stackp;
231 sp = stackp;
232 stackp = sp->prev;
233 sp = ckrealloc((pointer)sp,
234 sizeof(struct stack_block) - MINSIZE + newlen);
235 sp->prev = stackp;
236 stackp = sp;
237 stacknxt = sp->space;
238 sstrnleft += newlen - stacknleft;
239 stacknleft = newlen;
240
241 /*
242 * Stack marks pointing to the start of the old block
243 * must be relocated to point to the new block
244 */
245 xmark = markp;
246 while (xmark != NULL && xmark->stackp == oldstackp) {
247 xmark->stackp = stackp;
248 xmark->stacknxt = stacknxt;
249 xmark->sstrnleft += stacknleft - xmark->stacknleft;
250 xmark->stacknleft = stacknleft;
251 xmark = xmark->marknext;
252 }
253 } else {
254 char *oldspace = stacknxt;
255 int oldlen = stacknleft;
256 char *p = stalloc(newlen);
257
258 (void)memcpy(p, oldspace, oldlen);
259 stacknxt = p; /* free the space */
260 stacknleft += newlen; /* we just allocated */
261 }
262 INTON;
263 }
264
265 void
grabstackblock(int len)266 grabstackblock(int len)
267 {
268 len = SHELL_ALIGN(len);
269 INTOFF;
270 stacknxt += len;
271 stacknleft -= len;
272 INTON;
273 }
274
275 /*
276 * The following routines are somewhat easier to use than the above.
277 * The user declares a variable of type STACKSTR, which may be declared
278 * to be a register. The macro STARTSTACKSTR initializes things. Then
279 * the user uses the macro STPUTC to add characters to the string. In
280 * effect, STPUTC(c, p) is the same as *p++ = c except that the stack is
281 * grown as necessary. When the user is done, she can just leave the
282 * string there and refer to it using stackblock(). Or she can allocate
283 * the space for it using grabstackstr(). If it is necessary to allow
284 * someone else to use the stack temporarily and then continue to grow
285 * the string, the user should use grabstack to allocate the space, and
286 * then call ungrabstr(p) to return to the previous mode of operation.
287 *
288 * USTPUTC is like STPUTC except that it doesn't check for overflow.
289 * CHECKSTACKSPACE can be called before USTPUTC to ensure that there
290 * is space for at least one character.
291 */
292
293 char *
growstackstr(void)294 growstackstr(void)
295 {
296 int len = stackblocksize();
297 if (herefd >= 0 && len >= 1024) {
298 xwrite(herefd, stackblock(), len);
299 sstrnleft = len - 1;
300 return stackblock();
301 }
302 growstackblock();
303 sstrnleft = stackblocksize() - len - 1;
304 return stackblock() + len;
305 }
306
307 /*
308 * Called from CHECKSTRSPACE.
309 */
310
311 char *
makestrspace(void)312 makestrspace(void)
313 {
314 int len = stackblocksize() - sstrnleft;
315 growstackblock();
316 sstrnleft = stackblocksize() - len;
317 return stackblock() + len;
318 }
319
320 /*
321 * Note that this only works to release stack space for reuse
322 * if nothing else has allocated space on the stack since the grabstackstr()
323 *
324 * "s" is the start of the area to be released, and "p" represents the end
325 * of the string we have stored beyond there and are now releasing.
326 * (ie: "p" should be the same as in the call to grabstackstr()).
327 *
328 * stunalloc(s) and ungrabstackstr(s, p) are almost interchangeable after
329 * a grabstackstr(), however the latter also returns string space so we
330 * can just continue with STPUTC() etc without needing a new STARTSTACKSTR(s)
331 */
332 void
ungrabstackstr(char * s,char * p)333 ungrabstackstr(char *s, char *p)
334 {
335 #ifdef DEBUG
336 if (s < stacknxt || stacknxt + stacknleft < s)
337 abort();
338 #endif
339 stacknleft += stacknxt - s;
340 stacknxt = s;
341 sstrnleft = stacknleft - (p - s);
342 }
343
344 /*
345 * Save the concat of a sequence of strings in stack space
346 *
347 * The first arg (if not NULL) is a pointer to where the final string
348 * length will be returned.
349 *
350 * Remaining args are pointers to strings - sufficient space to hold
351 * the concat of the strings is allocated on the stack, the strings
352 * are copied into that space, and a pointer to its start is returned.
353 * The arg list is terminated with STSTRC_END.
354 *
355 * Use stunalloc(string) (in proper sequence) to release the string
356 */
357 char *
ststrcat(size_t * lp,...)358 ststrcat(size_t *lp, ...)
359 {
360 va_list ap;
361 const char *arg;
362 size_t len, tlen = 0, alen[8];
363 char *str, *nxt;
364 unsigned int n;
365
366 n = 0;
367 va_start(ap, lp);
368 arg = va_arg(ap, const char *);
369 while (arg != STSTRC_END) {
370 len = strlen(arg);
371 if (n < sizeof(alen)/sizeof(alen[0]))
372 alen[n++] = len;
373 tlen += len;
374 arg = va_arg(ap, const char *);
375 }
376 va_end(ap);
377
378 if (lp != NULL)
379 *lp = tlen;
380
381 if (tlen >= INT_MAX)
382 error("ststrcat() over length botch");
383 str = (char *)stalloc((int)tlen + 1); /* 1 for \0 */
384 str[tlen] = '\0'; /* in case of no args */
385
386 n = 0;
387 nxt = str;
388 va_start(ap, lp);
389 arg = va_arg(ap, const char *);
390 while (arg != STSTRC_END) {
391 if (n < sizeof(alen)/sizeof(alen[0]))
392 len = alen[n++];
393 else
394 len = strlen(arg);
395
396 scopy(arg, nxt);
397 nxt += len;
398
399 arg = va_arg(ap, const char *);
400 }
401 va_end(ap);
402
403 return str;
404 }
405