xref: /titanic_51/usr/src/cmd/sh/service.c (revision bbaa8b60dd95d714741fc474adad3cf710ef4efd) 
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 
22 /*
23  * Copyright (c) 1988, 2010, Oracle and/or its affiliates. All rights reserved.
24  */
25 
26 /*	Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T	*/
27 /*	  All Rights Reserved  	*/
28 
29 /*
30  * UNIX shell
31  */
32 
33 #include	"defs.h"
34 #include	<errno.h>
35 #include	<fcntl.h>
36 
37 #define	ARGMK	01
38 
39 static unsigned char	*execs();
40 static void	gsort();
41 static int	split();
42 extern void makearg(struct argnod *);
43 extern short topfd;
44 
45 
46 /*
47  * service routines for `execute'
48  */
49 short
50 initio(struct ionod *iop, int save)
51 {
52 	unsigned char	*ion;
53 	int	iof, fd;
54 	int		ioufd;
55 	short	lastfd;
56 	int	newmode;
57 
58 	lastfd = topfd;
59 	while (iop) {
60 		iof = iop->iofile;
61 		ion = mactrim(iop->ioname);
62 		ioufd = iof & IOUFD;
63 
64 		if (*ion && (flags&noexec) == 0) {
65 			if (save) {
66 				fdmap[topfd].org_fd = ioufd;
67 				fdmap[topfd++].dup_fd = savefd(ioufd);
68 			}
69 
70 			if (iof & IODOC_SUBST) {
71 				struct tempblk tb;
72 
73 				subst(chkopen(ion, 0), (fd = tmpfil(&tb)));
74 
75 				/*
76 				 * pushed in tmpfil() --
77 				 * bug fix for problem with
78 				 * in-line scripts
79 				 */
80 				poptemp();
81 
82 				fd = chkopen(tmpout, 0);
83 				unlink((const char *)tmpout);
84 			} else if (iof & IOMOV) {
85 				if (eq(minus, ion)) {
86 					fd = -1;
87 					close(ioufd);
88 				} else if ((fd = stoi(ion)) >= USERIO) {
89 					failed(ion, badfile);
90 				}
91 				else
92 					fd = dup(fd);
93 			} else if (((iof & IOPUT) == 0) && ((iof & IORDW) == 0))
94 				fd = chkopen(ion, 0);
95 			else if (iof & IORDW) /* For <> */ {
96 				newmode = O_RDWR|O_CREAT;
97 				fd = chkopen(ion, newmode);
98 			} else if (flags & rshflg) {
99 				failed(ion, restricted);
100 			} else if (iof & IOAPP &&
101 			    (fd = open((char *)ion, 1)) >= 0) {
102 				lseek(fd, (off_t)0, SEEK_END);
103 			} else {
104 				fd = create(ion);
105 			}
106 			if (fd >= 0)
107 				renamef(fd, ioufd);
108 		}
109 
110 		iop = iop->ionxt;
111 	}
112 	return (lastfd);
113 }
114 
115 unsigned char *
116 simple(s)
117 unsigned char	*s;
118 {
119 	unsigned char	*sname;
120 
121 	sname = s;
122 	while (1) {
123 		if (any('/', sname))
124 			while (*sname++ != '/')
125 				;
126 		else
127 			return (sname);
128 	}
129 }
130 
131 unsigned char *
132 getpath(s)
133 	unsigned char	*s;
134 {
135 	unsigned char	*path, *newpath;
136 	int pathlen;
137 
138 	if (any('/', s))
139 	{
140 		if (flags & rshflg)
141 			failed(s, restricted);
142 		else
143 			return ((unsigned char *)nullstr);
144 	} else if ((path = pathnod.namval) == 0)
145 		return ((unsigned char *)defpath);
146 	else {
147 		pathlen = length(path)-1;
148 		/* Add extra ':' if PATH variable ends in ':' */
149 		if (pathlen > 2 && path[pathlen - 1] == ':' &&
150 				path[pathlen - 2] != ':') {
151 			newpath = locstak();
152 			(void) memcpystak(newpath, path, pathlen);
153 			newpath[pathlen] = ':';
154 			endstak(newpath + pathlen + 1);
155 			return (newpath);
156 		} else
157 			return (cpystak(path));
158 	}
159 }
160 
161 int
162 pathopen(unsigned char *path, unsigned char *name)
163 {
164 	int	f;
165 
166 	do
167 	{
168 		path = catpath(path, name);
169 	} while ((f = open((char *)curstak(), 0)) < 0 && path);
170 	return (f);
171 }
172 
173 unsigned char *
174 catpath(unsigned char *path, unsigned char *name)
175 {
176 	/*
177 	 * leaves result on top of stack
178 	 */
179 	unsigned char	*scanp = path;
180 	unsigned char	*argp = locstak();
181 
182 	while (*scanp && *scanp != COLON) {
183 		if (argp >= brkend)
184 			growstak(argp);
185 		*argp++ = *scanp++;
186 	}
187 	if (scanp != path) {
188 		if (argp >= brkend)
189 			growstak(argp);
190 		*argp++ = '/';
191 	}
192 	if (*scanp == COLON)
193 		scanp++;
194 	path = (*scanp ? scanp : 0);
195 	scanp = name;
196 	do
197 	{
198 		if (argp >= brkend)
199 			growstak(argp);
200 	}
201 	while (*argp++ = *scanp++)
202 		;
203 	return (path);
204 }
205 
206 unsigned char *
207 nextpath(unsigned char *path)
208 {
209 	unsigned char	*scanp = path;
210 
211 	while (*scanp && *scanp != COLON)
212 		scanp++;
213 
214 	if (*scanp == COLON)
215 		scanp++;
216 
217 	return (*scanp ? scanp : 0);
218 }
219 
220 static const char	*xecmsg;
221 static unsigned char	**xecenv;
222 
223 void
224 execa(unsigned char *at[], short pos)
225 {
226 	unsigned char	*path;
227 	unsigned char	**t = at;
228 	int		cnt;
229 
230 	if ((flags & noexec) == 0) {
231 		xecmsg = notfound;
232 		path = getpath(*t);
233 		xecenv = local_setenv();
234 
235 		if (pos > 0) {
236 			cnt = 1;
237 			while (cnt != pos) {
238 				++cnt;
239 				path = nextpath(path);
240 			}
241 			execs(path, t);
242 			path = getpath(*t);
243 		}
244 		while (path = execs(path, t))
245 			;
246 		failed(*t, xecmsg);
247 	}
248 }
249 
250 static unsigned char *
251 execs(unsigned char *ap, unsigned char *t[])
252 {
253 	unsigned char	*p, *prefix;
254 	unsigned char	*savptr;
255 
256 	prefix = catpath(ap, t[0]);
257 	trim(p = curstak());
258 	sigchk();
259 
260 	execve((const char *)p, (char *const *)&t[0],
261 	    (char *const *)xecenv);
262 
263 	switch (errno) {
264 	case ENOEXEC:		/* could be a shell script */
265 		funcnt = 0;
266 		flags = 0;
267 		*flagadr = 0;
268 		comdiv = 0;
269 		ioset = 0;
270 		clearup();	/* remove open files and for loop junk */
271 		if (input)
272 			close(input);
273 		input = chkopen(p, 0);
274 
275 #ifdef ACCT
276 		preacct(p);	/* reset accounting */
277 #endif
278 
279 		/*
280 		 * set up new args
281 		 */
282 
283 		setargs(t);
284 		longjmp(subshell, 1);
285 
286 	case ENOMEM:
287 		failed(p, toobig);
288 
289 	case E2BIG:
290 		failed(p, arglist);
291 
292 	case ETXTBSY:
293 		failed(p, txtbsy);
294 
295 	case ELIBACC:
296 		failed(p, libacc);
297 
298 	case ELIBBAD:
299 		failed(p, libbad);
300 
301 	case ELIBSCN:
302 		failed(p, libscn);
303 
304 	case ELIBMAX:
305 		failed(p, libmax);
306 
307 	default:
308 		xecmsg = badexec;
309 	case ENOENT:
310 		return (prefix);
311 	}
312 }
313 
314 BOOL		nosubst;
315 
316 void
317 trim(unsigned char *at)
318 {
319 	unsigned char	*last;
320 	unsigned char 	*current;
321 	unsigned char	c;
322 	int	len;
323 	wchar_t	wc;
324 
325 	nosubst = 0;
326 	if (current = at) {
327 		last = at;
328 		while (c = *current) {
329 			if ((len = mbtowc(&wc, (char *)current,
330 			    MB_LEN_MAX)) <= 0) {
331 				*last++ = c;
332 				current++;
333 				continue;
334 			}
335 
336 			if (wc != '\\') {
337 				memcpy(last, current, len);
338 				last += len;
339 				current += len;
340 				continue;
341 			}
342 
343 			/* remove \ and quoted nulls */
344 			nosubst = 1;
345 			current++;
346 			if (c = *current) {
347 				if ((len = mbtowc(&wc, (char *)current,
348 				    MB_LEN_MAX)) <= 0) {
349 					*last++ = c;
350 					current++;
351 					continue;
352 				}
353 				memcpy(last, current, len);
354 				last += len;
355 				current += len;
356 			} else
357 				current++;
358 		}
359 
360 		*last = 0;
361 	}
362 }
363 
364 /* Same as trim, but only removes backlashes before slashes */
365 void
366 trims(at)
367 unsigned char	*at;
368 {
369 	unsigned char	*last;
370 	unsigned char 	*current;
371 	unsigned char	c;
372 	int	len;
373 	wchar_t	wc;
374 
375 	if (current = at)
376 	{
377 		last = at;
378 		while (c = *current) {
379 			if ((len = mbtowc(&wc, (char *)current,
380 					MB_LEN_MAX)) <= 0) {
381 				*last++ = c;
382 				current++;
383 				continue;
384 			}
385 
386 			if (wc != '\\') {
387 				memcpy(last, current, len);
388 				last += len; current += len;
389 				continue;
390 			}
391 
392 			/* remove \ and quoted nulls */
393 			current++;
394 			if (!(c = *current)) {
395 				current++;
396 				continue;
397 			}
398 
399 			if (c == '/') {
400 				*last++ = c;
401 				current++;
402 				continue;
403 			}
404 
405 			*last++ = '\\';
406 			if ((len = mbtowc(&wc, (char *)current,
407 					MB_LEN_MAX)) <= 0) {
408 				*last++ = c;
409 				current++;
410 				continue;
411 			}
412 			memcpy(last, current, len);
413 			last += len; current += len;
414 		}
415 		*last = 0;
416 	}
417 }
418 
419 unsigned char *
420 mactrim(s)
421 unsigned char	*s;
422 {
423 	unsigned char	*t = macro(s);
424 
425 	trim(t);
426 	return (t);
427 }
428 
429 unsigned char **
430 scan(argn)
431 int	argn;
432 {
433 	struct argnod *argp =
434 			(struct argnod *)(Rcheat(gchain) & ~ARGMK);
435 	unsigned char **comargn, **comargm;
436 
437 	comargn = (unsigned char **)getstak(BYTESPERWORD * argn + BYTESPERWORD);
438 	comargm = comargn += argn;
439 	*comargn = ENDARGS;
440 	while (argp)
441 	{
442 		*--comargn = argp->argval;
443 
444 		trim(*comargn);
445 		argp = argp->argnxt;
446 
447 		if (argp == 0 || Rcheat(argp) & ARGMK)
448 		{
449 			gsort(comargn, comargm);
450 			comargm = comargn;
451 		}
452 		argp = (struct argnod *)(Rcheat(argp) & ~ARGMK);
453 	}
454 	return (comargn);
455 }
456 
457 static void
458 gsort(from, to)
459 unsigned char	*from[], *to[];
460 {
461 	int	k, m, n;
462 	int	i, j;
463 
464 	if ((n = to - from) <= 1)
465 		return;
466 	for (j = 1; j <= n; j *= 2)
467 		;
468 	for (m = 2 * j - 1; m /= 2; )
469 	{
470 		k = n - m;
471 		for (j = 0; j < k; j++)
472 		{
473 			for (i = j; i >= 0; i -= m)
474 			{
475 				unsigned char **fromi;
476 
477 				fromi = &from[i];
478 				if (cf(fromi[m], fromi[0]) > 0)
479 				{
480 					break;
481 				}
482 				else
483 				{
484 					unsigned char *s;
485 
486 					s = fromi[m];
487 					fromi[m] = fromi[0];
488 					fromi[0] = s;
489 				}
490 			}
491 		}
492 	}
493 }
494 
495 /*
496  * Argument list generation
497  */
498 int
499 getarg(ac)
500 struct comnod	*ac;
501 {
502 	struct argnod	*argp;
503 	int		count = 0;
504 	struct comnod	*c;
505 
506 	if (c = ac)
507 	{
508 		argp = c->comarg;
509 		while (argp)
510 		{
511 			count += split(macro(argp->argval), 1);
512 			argp = argp->argnxt;
513 		}
514 	}
515 	return (count);
516 }
517 
518 static int
519 split(s)		/* blank interpretation routine */
520 unsigned char	*s;
521 {
522 	unsigned char	*argp;
523 	int		c;
524 	int		count = 0;
525 	for (;;)
526 	{
527 		int length;
528 		sigchk();
529 		argp = locstak() + BYTESPERWORD;
530 		while (c = *s) {
531 			wchar_t wc;
532 			if ((length = mbtowc(&wc, (char *)s,
533 					MB_LEN_MAX)) <= 0) {
534 				wc = (unsigned char)*s;
535 				length = 1;
536 			}
537 
538 			if (c == '\\') { /* skip over quoted characters */
539 				if (argp >= brkend)
540 					growstak(argp);
541 				*argp++ = c;
542 				s++;
543 				/* get rest of multibyte character */
544 				if ((length = mbtowc(&wc, (char *)s,
545 						MB_LEN_MAX)) <= 0) {
546 					wc = (unsigned char)*s;
547 					length = 1;
548 				}
549 				if (argp >= brkend)
550 					growstak(argp);
551 				*argp++ = *s++;
552 				while (--length > 0) {
553 					if (argp >= brkend)
554 						growstak(argp);
555 					*argp++ = *s++;
556 				}
557 				continue;
558 			}
559 
560 			if (anys(s, ifsnod.namval)) {
561 				/* skip to next character position */
562 				s += length;
563 				break;
564 			}
565 
566 			if (argp >= brkend)
567 				growstak(argp);
568 			*argp++ = c;
569 			s++;
570 			while (--length > 0) {
571 				if (argp >= brkend)
572 					growstak(argp);
573 				*argp++ = *s++;
574 			}
575 		}
576 		if (argp == staktop + BYTESPERWORD)
577 		{
578 			if (c)
579 			{
580 				continue;
581 			}
582 			else
583 			{
584 				return (count);
585 			}
586 		}
587 		/*
588 		 * file name generation
589 		 */
590 
591 		argp = endstak(argp);
592 		trims(((struct argnod *)argp)->argval);
593 		if ((flags & nofngflg) == 0 &&
594 			(c = expand(((struct argnod *)argp)->argval, 0)))
595 			count += c;
596 		else
597 		{
598 			makearg((struct argnod *)argp);
599 			count++;
600 		}
601 		gchain = (struct argnod *)((int)gchain | ARGMK);
602 	}
603 }
604 
605 #ifdef ACCT
606 #include	<sys/types.h>
607 #include	<sys/acct.h>
608 #include 	<sys/times.h>
609 
610 struct acct sabuf;
611 struct tms buffer;
612 static clock_t before;
613 static int shaccton;	/* 0 implies do not write record on exit */
614 			/* 1 implies write acct record on exit */
615 static comp_t compress(clock_t);
616 
617 
618 /*
619  *	suspend accounting until turned on by preacct()
620  */
621 void
622 suspacct(void)
623 {
624 	shaccton = 0;
625 }
626 
627 void
628 preacct(unsigned char *cmdadr)
629 {
630 	unsigned char *simple();
631 
632 	if (acctnod.namval && *acctnod.namval) {
633 		sabuf.ac_btime = time((time_t *)0);
634 		before = times(&buffer);
635 		sabuf.ac_uid = getuid();
636 		sabuf.ac_gid = getgid();
637 		movstrn(simple(cmdadr), sabuf.ac_comm, sizeof (sabuf.ac_comm));
638 		shaccton = 1;
639 	}
640 }
641 
642 void
643 doacct(void)
644 {
645 	int fd;
646 	clock_t after;
647 
648 	if (shaccton) {
649 		after = times(&buffer);
650 		sabuf.ac_utime = compress(buffer.tms_utime + buffer.tms_cutime);
651 		sabuf.ac_stime = compress(buffer.tms_stime + buffer.tms_cstime);
652 		sabuf.ac_etime = compress(after - before);
653 
654 		if ((fd = open((char *)acctnod.namval,
655 		    O_WRONLY | O_APPEND | O_CREAT, 0666)) != -1) {
656 			write(fd, &sabuf, sizeof (sabuf));
657 			close(fd);
658 		}
659 	}
660 }
661 
662 /*
663  *	Produce a pseudo-floating point representation
664  *	with 3 bits base-8 exponent, 13 bits fraction
665  */
666 
667 static comp_t
668 compress(clock_t t)
669 {
670 	int exp = 0;
671 	int rund = 0;
672 
673 	while (t >= 8192) {
674 		exp++;
675 		rund = t & 04;
676 		t >>= 3;
677 	}
678 
679 	if (rund) {
680 		t++;
681 		if (t >= 8192) {
682 			t >>= 3;
683 			exp++;
684 		}
685 	}
686 	return ((exp << 13) + t);
687 }
688 #endif
689