xref: /dragonfly/contrib/tcsh-6/tc.os.c (revision b97fef05) 
1 /*
2  * tc.os.c: OS Dependent builtin functions
3  */
4 /*-
5  * Copyright (c) 1980, 1991 The Regents of the University of California.
6  * All rights reserved.
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  * 3. 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 #include "sh.h"
33 #include "tw.h"
34 #include "ed.h"
35 #include "ed.defns.h"		/* for the function names */
36 #include "sh.decls.h"
37 
38 #ifdef _UWIN
39 #define TIOCGPGRP TIOCGETPGRP
40 #define TIOCSPGRP TIOCSETPGRP
41 #endif
42 
43 /***
44  *** MACH
45  ***/
46 
47 #ifdef MACH
48 /* dosetpath -- setpath built-in command
49  *
50  **********************************************************************
51  * HISTORY
52  * 08-May-88  Richard Draves (rpd) at Carnegie-Mellon University
53  *	Major changes to remove artificial limits on sizes and numbers
54  *	of paths.
55  *
56  **********************************************************************
57  */
58 
59 #ifdef MACH
60 static Char STRCPATH[] = {'C', 'P', 'A', 'T', 'H', '\0'};
61 static Char STRLPATH[] = {'L', 'P', 'A', 'T', 'H', '\0'};
62 static Char STRMPATH[] = {'M', 'P', 'A', 'T', 'H', '\0'};
63 # if EPATH
64 static Char STREPATH[] = {'E', 'P', 'A', 'T', 'H', '\0'};
65 # endif
66 #endif /* MACH */
67 static Char *syspaths[] = {STRKPATH, STRCPATH, STRLPATH, STRMPATH,
68 
69 #if EPATH
70 	STREPATH,
71 #endif
72 	 0};
73 #define LOCALSYSPATH	"/usr/local"
74 
75 /*ARGSUSED*/
76 void
77 dosetpath(Char **arglist, struct command *c)
78 {
79     extern char *getenv();
80     Char  **pathvars, **cmdargs;
81     char  **spaths, **cpaths, **cmds;
82     char   *tcp;
83     unsigned int npaths, ncmds;
84     int     i, sysflag;
85 
86     pintr_disabled++;
87     cleanup_push(&pintr_disabled, disabled_cleanup);
88 
89     /*
90      * setpath(3) uses stdio and we want 0, 1, 2 to work...
91      */
92     if (!didfds) {
93 	(void) dcopy(SHIN, 0);
94 	(void) dcopy(SHOUT, 1);
95 	(void) dcopy(SHDIAG, 2);
96 	didfds = 1;
97     }
98 
99     for (i = 1; arglist[i] && (arglist[i][0] != '-'); i++);
100     npaths = i - 1;
101 
102     cmdargs = &arglist[i];
103     for (; arglist[i]; i++);
104     ncmds = i - npaths - 1;
105 
106     if (npaths) {
107 	sysflag = 0;
108 	pathvars = &arglist[1];
109     }
110     else {
111 	sysflag = 1;
112 	npaths = (sizeof syspaths / sizeof *syspaths) - 1;
113 	pathvars = syspaths;
114     }
115 
116     /* note that npaths != 0 */
117 
118     spaths = xmalloc(npaths * sizeof *spaths);
119     setzero(spaths, npaths * sizeof *spaths);
120     cpaths = xmalloc((npaths + 1) * sizeof *cpaths);
121     setzero(cpaths, (npaths + 1) * sizeof *cpaths);
122     cmds = xmalloc((ncmds + 1) * sizeof *cmds);
123     setzero(cmds, (ncmds + 1) * sizeof *cmds);
124     for (i = 0; i < npaths; i++) {
125 	char   *val = getenv(short2str(pathvars[i]));
126 
127 	if (val == NULL)
128 	    val = "";
129 
130 	spaths[i] = xmalloc((Strlen(pathvars[i]) + strlen(val) + 2) *
131 			    sizeof **spaths);
132 	(void) strcpy(spaths[i], short2str(pathvars[i]));
133 	(void) strcat(spaths[i], "=");
134 	(void) strcat(spaths[i], val);
135 	cpaths[i] = spaths[i];
136     }
137 
138     for (i = 0; i < ncmds; i++) {
139 	Char   *val = globone(cmdargs[i], G_ERROR);/*FIXRESET*/
140 
141 	if (val == NULL)
142 	    goto abortpath;
143 	cmds[i] = strsave(short2str(val));
144     }
145 
146 
147     if (setpath(cpaths, cmds, LOCALSYSPATH, sysflag, 1) < 0) {
148 abortpath:
149 	if (spaths) {
150 	    for (i = 0; i < npaths; i++)
151 		xfree(spaths[i]);
152 	    xfree(spaths);
153 	}
154 	xfree(cpaths);
155 	if (cmds) {
156 	    for (i = 0; i < ncmds; i++)
157 		xfree(cmds[i]);
158 	    xfree(cmds);
159 	}
160 
161 	cleanup_until(&pintr_disabled);
162 	donefds();
163 	return;
164     }
165 
166     for (i = 0; i < npaths; i++) {
167 	Char	*val, *name;
168 
169 	name = str2short(cpaths[i]);
170 	for (val = str2short(cpaths[i]); val && *val && *val != '='; val++);
171 	if (val && *val == '=') {
172 	    *val++ = '\0';
173 
174 	    tsetenv(name, val);/*FIXRESET*/
175 	    if (Strcmp(name, STRKPATH) == 0) {
176 		importpath(val);/*FIXRESET*/
177 		if (havhash)
178 		    dohash(NULL, NULL);/*FIXRESET*/
179 	    }
180 	    *--val = '=';
181 	}
182     }
183     cleanup_until(&pintr_disabled);
184     donefds();
185 }
186 #endif /* MACH */
187 
188 /***
189  *** AIX
190  ***/
191 #ifdef TCF
192 /* ARGSUSED */
193 void
194 dogetxvers(Char **v, struct command *c)
195 {
196     char    xvers[MAXPATHLEN];
197 
198     if (getxvers(xvers, MAXPATHLEN) == -1)
199 	stderror(ERR_SYSTEM, "getxvers", strerror(errno));
200     xprintf("%s\n", xvers);
201     flush();
202 }
203 
204 /*ARGSUSED*/
205 void
206 dosetxvers(Char **v, struct command *c)
207 {
208     char   *xvers;
209 
210     ++v;
211     if (!*v || *v[0] == '\0')
212 	xvers = "";
213     else
214 	xvers = short2str(*v);
215     if (setxvers(xvers) == -1)
216 	stderror(ERR_SYSTEM, "setxvers", strerror(errno));
217 }
218 
219 #include <sf.h>
220 #ifdef _AIXPS2
221 # define XC_PDP11	0x01
222 # define XC_23		0x02
223 # define XC_Z8K		0x03
224 # define XC_8086	0x04
225 # define XC_68K		0x05
226 # define XC_Z80		0x06
227 # define XC_VAX		0x07
228 # define XC_16032	0x08
229 # define XC_286		0x09
230 # define XC_386		0x0a
231 # define XC_S370	0x0b
232 #else
233 # include <sys/x.out.h>
234 #endif /* _AIXPS2 */
235 
236 static struct xc_cpu_t {
237     short   xc_id;
238     char   *xc_name;
239 }       xcpu[] =
240 {
241     { XC_PDP11,	"pdp11"   },
242     { XC_23,	"i370"    },
243     { XC_Z8K,	"z8000"   },
244     { XC_8086,	"i86"	  },
245     { XC_68K,	"mc68000" },
246     { XC_Z80,	"x80"	  },
247     { XC_VAX,	"vax"	  },
248     { XC_16032,	"ns16032" },
249     { XC_286,	"i286"	  },
250     { XC_386,	"i386"	  },
251     { XC_S370,	"xa370"	  },
252     { 0,	NULL      }
253 };
254 
255 /*
256  * our local hack table, stolen from x.out.h
257  */
258 static char *
259 getxcode(short xcid)
260 {
261     int     i;
262 
263     for (i = 0; xcpu[i].xc_name != NULL; i++)
264 	if (xcpu[i].xc_id == xcid)
265 	    return (xcpu[i].xc_name);
266     return (NULL);
267 }
268 
269 static short
270 getxid(char *xcname)
271 {
272     int     i;
273 
274     for (i = 0; xcpu[i].xc_name != NULL; i++)
275 	if (strcmp(xcpu[i].xc_name, xcname) == 0)
276 	    return (xcpu[i].xc_id);
277     return ((short) -1);
278 }
279 
280 
281 /*ARGSUSED*/
282 void
283 dogetspath(Char **v, struct command *c)
284 {
285     int     i, j;
286     sitepath_t p[MAXSITE];
287     struct sf *st;
288     static char *local = "LOCAL ";
289 
290     if ((j = getspath(p, MAXSITE)) == -1)
291 	stderror(ERR_SYSTEM, "getspath", strerror(errno));
292     for (i = 0; i < j && (p[i] & SPATH_CPU) != NOSITE; i++) {
293 	if (p[i] & SPATH_CPU) {
294 	    if ((p[i] & SPATH_MASK) == NULLSITE)
295 		xprintf(local);
296 	    else if ((st = sfxcode((short) (p[i] & SPATH_MASK))) != NULL)
297 		xprintf("%s ", st->sf_ctype);
298 	    else {
299 		char   *xc = getxcode(p[i] & SPATH_MASK);
300 
301 		if (xc != NULL)
302 		    xprintf("%s ", xc);
303 		else
304 		    xprintf("*cpu %d* ", (int) (p[i] & SPATH_MASK));
305 		/*
306 		 * BUG in the aix code... needs that cause if
307 		 * sfxcode fails once it fails for ever
308 		 */
309 		endsf();
310 	    }
311 	}
312 	else {
313 	    if (p[i] == NULLSITE)
314 		xprintf(local);
315 	    else if ((st = sfnum(p[i])) != NULL)
316 		xprintf("%s ", st->sf_sname);
317 	    else
318 		xprintf("*site %d* ", (int) (p[i] & SPATH_MASK));
319 	}
320     }
321     xputchar('\n');
322     flush();
323 }
324 
325 /*ARGSUSED*/
326 void
327 dosetspath(Char **v, struct command *c)
328 {
329     int     i;
330     short   j;
331     char   *s;
332     sitepath_t p[MAXSITE];
333     struct sf *st;
334 
335     /*
336      * sfname() on AIX G9.9 at least, mallocs too pointers p, q
337      * then does the equivalent of while (*p++ == *q++) continue;
338      * and then tries to free(p,q) them! Congrats to the wizard who
339      * wrote that one. I bet he tested it really well too.
340      * Sooo, we set dont_free :-)
341      */
342     dont_free = 1;
343     for (i = 0, v++; *v && *v[0] != '\0'; v++, i++) {
344 	s = short2str(*v);
345 	if (isdigit(*s))
346 	    p[i] = atoi(s);
347 	else if (strcmp(s, "LOCAL") == 0)
348 	    p[i] = NULLSITE;
349 	else if ((st = sfctype(s)) != NULL)
350 	    p[i] = SPATH_CPU | st->sf_ccode;
351 	else if ((j = getxid(s)) != -1)
352 	    p[i] = SPATH_CPU | j;
353 	else if ((st = sfname(s)) != NULL)
354 	    p[i] = st->sf_id;
355 	else {
356 	    setname(s);
357 	    stderror(ERR_NAME | ERR_STRING, CGETS(23, 1, "Bad cpu/site name"));
358 	}
359 	if (i == MAXSITE - 1)
360 	    stderror(ERR_NAME | ERR_STRING, CGETS(23, 2, "Site path too long"));
361     }
362     if (setspath(p, i) == -1)
363 	stderror(ERR_SYSTEM, "setspath", strerror(errno));
364     dont_free = 0;
365 }
366 
367 /* sitename():
368  *	Return the site name where the process is running
369  */
370 char   *
371 sitename(pid_t pid)
372 {
373     siteno_t ss;
374     struct sf *st;
375 
376     if ((ss = site(pid)) == -1 || (st = sfnum(ss)) == NULL)
377 	return CGETS(23, 3, "unknown");
378     else
379 	return st->sf_sname;
380 }
381 
382 static int
383 migratepid(pit_t pid, siteno_t new_site)
384 {
385     struct sf *st;
386     int     need_local;
387 
388     need_local = (pid == 0) || (pid == getpid());
389 
390     if (kill3(pid, SIGMIGRATE, new_site) < 0) {
391 	xprintf("%d: %s\n", pid, strerror(errno));
392 	return (-1);
393     }
394 
395     if (need_local) {
396 	if ((new_site = site(0)) == -1) {
397 	    xprintf(CGETS(23, 4, "site: %s\n"), strerror(errno));
398 	    return (-1);
399 	}
400 	if ((st = sfnum(new_site)) == NULL) {
401 	    xprintf(CGETS(23, 5, "%d: Site not found\n"), new_site);
402 	    return (-1);
403 	}
404 	if (setlocal(st->sf_local, strlen(st->sf_local)) == -1) {
405 	    xprintf(CGETS(23, 6, "setlocal: %s: %s\n"),
406 			  st->sf_local, strerror(errno));
407 	    return (-1);
408 	}
409     }
410     return (0);
411 }
412 
413 /*ARGSUSED*/
414 void
415 domigrate(Char **v, struct command *c)
416 {
417     struct sf *st;
418     char   *s;
419     Char   *cp;
420     struct process *pp;
421     int    err1 = 0;
422     int    pid = 0;
423     siteno_t new_site = 0;
424 
425     pchild_disabled++;
426     cleanup_push(&pchild_disabled, disabled_cleanup);
427     if (setintr) {
428 	pintr_disabled++;
429 	cleanup_push(&pintr_disabled, disabled_cleanup);
430     }
431 
432     ++v;
433     if (*v[0] == '-') {
434 	/*
435 	 * Do the -site.
436 	 */
437 	s = short2str(&v[0][1]);
438 	/*
439 	 * see comment in setspath()
440 	 */
441 	dont_free = 1;
442 	if ((st = sfname(s)) == NULL) {
443 	    dont_free = 0;
444 	    setname(s);
445 	    stderror(ERR_NAME | ERR_STRING, CGETS(23, 7, "Site not found"));
446 	}
447 	dont_free = 0;
448 	new_site = st->sf_id;
449 	++v;
450     }
451 
452     if (!*v || *v[0] == '\0') {
453 	if (migratepid(0, new_site) == -1)
454 	    err1++;
455     }
456     else {
457 	Char **globbed;
458 
459 	v = glob_all_or_error(v);
460 	globbed = v;
461 	cleanup_push(globbed, blk_cleanup);
462 
463 	while (v && (cp = *v)) {
464 	    if (*cp == '%') {
465 		pp = pfind(cp);
466 		if (kill3(- pp->p_jobid, SIGMIGRATE, new_site) < 0) {
467 		    xprintf("%S: %s\n", cp, strerror(errno));
468 		    err1++;
469 		}
470 	    }
471 	    else if (!(Isdigit(*cp) || *cp == '-'))
472 		stderror(ERR_NAME | ERR_JOBARGS);
473 	    else {
474 		pid = atoi(short2str(cp));
475 		if (migratepid(pid, new_site) == -1)
476 		    err1++;
477 	    }
478 	    v++;
479 	}
480 	cleanup_until(globbed);
481     }
482 
483 done:
484     cleanup_until(&pchild_disabled);
485     if (err1)
486 	stderror(ERR_SILENT);
487 }
488 
489 #endif /* TCF */
490 
491 /***
492  *** CRAY ddmode <velo@sesun3.epfl.ch> (Martin Ouwehand EPFL-SIC/SE)
493  ***/
494 #if defined(_CRAY) && !defined(_CRAYMPP)
495 void
496 dodmmode(Char **v, struct command *c)
497 {
498     Char *cp = v[1];
499 
500     USE(c);
501 
502     if ( !cp ) {
503 	int mode;
504 
505 	mode = dmmode(0);
506 	dmmode(mode);
507 	xprintf("%d\n",mode);
508     }
509     else {
510 	if (cp[1] != '\0')
511 	    stderror(ERR_NAME | ERR_STRING,
512 		     CGETS(23, 30, "Too many arguments"));
513 	else
514 	    switch(*cp) {
515 	    case '0':
516 		dmmode(0);
517 		break;
518 	    case '1':
519 		dmmode(1);
520 		break;
521 	    default:
522 		stderror(ERR_NAME | ERR_STRING,
523 			 CGETS(23, 31, "Invalid argument"));
524 	    }
525     }
526 }
527 #endif /* _CRAY && !_CRAYMPP */
528 
529 
530 /***
531  *** CONVEX Warps.
532  ***/
533 
534 #ifdef WARP
535 /*
536  * handle the funky warping of symlinks
537  */
538 #include <warpdb.h>
539 #include <sys/warp.h>
540 
541 static jmp_buf sigsys_buf;
542 
543 static void
544 catch_sigsys(void)
545 {
546     sigset_t set;
547     sigemptyset(&set, SIGSYS);
548     (void)sigprocmask(SIG_UNBLOCK, &set, NULL);
549     longjmp(sigsys_buf, 1);
550 }
551 
552 
553 /*ARGSUSED*/
554 void
555 dowarp(Char **v, struct command *c)
556 {
557     int     warp, oldwarp;
558     struct warpent *we;
559     volatile struct sigaction old_sigsys_handler;
560     char   *newwarp;
561 
562     if (setjmp(sigsys_buf)) {
563 	sigaction(SIGSYS, &old_sigsys_handler, NULL);
564 	stderror(ERR_NAME | ERR_STRING,
565 		 CGETS(23, 8, "You're trapped in a universe you never made"));
566 	return;
567     }
568     sigaction(SIGSYS, NULL, &old_sigsys_handler);
569     signal(SIGSYS, catch_sigsys);
570 
571     warp = getwarp();
572 
573     v++;
574     if (*v == 0) {		/* display warp value */
575 	if (warp < 0)
576 	    stderror(ERR_NAME | ERR_STRING, CGETS(23, 9, "Getwarp failed"));
577 	we = getwarpbyvalue(warp);
578 	if (we)
579 	    printf("%s\n", we->w_name);
580 	else
581 	    printf("%d\n", warp);
582     }
583     else {			/* set warp value */
584 	oldwarp = warp;
585 	newwarp = short2str(*v);
586 	if (Isdigit(*v[0]))
587 	    warp = atoi(newwarp);
588 	else {
589 	    we = getwarpbyname(newwarp);
590 	    if (we)
591 		warp = we->w_value;
592 	    else
593 		warp = -1;
594 	}
595 	if ((warp < 0) || (warp >= WARP_MAXLINK))
596 	    stderror(ERR_NAME | ERR_STRING, CGETS(23, 10, "Invalid warp"));
597 	if ((setwarp(warp) < 0) || (getwarp() != warp)) {
598 	    (void) setwarp(oldwarp);
599 	    stderror(ERR_NAME | ERR_STRING, CGETS(23, 11, "Setwarp failed"));
600 	}
601     }
602     sigaction(SIGSYS, &old_sigsys_handler, NULL);
603 }
604 #endif /* WARP */
605 
606 /***
607  *** Masscomp or HCX
608  ***/
609 /* Added, DAS DEC-90. */
610 #if defined(masscomp) || defined(_CX_UX)
611 static void
612 setuniverse_cleanup(void *xbuf)
613 {
614     char *buf;
615 
616     buf = xbuf;
617     setuniverse(buf);
618 }
619 
620 /*ARGSUSED*/
621 void
622 douniverse(Char **v, struct command *c)
623 {
624     Char *cp = v[1];
625     Char *cp2;		/* dunno how many elements v comes in with */
626     char    ubuf[100];
627 
628     if (cp == 0) {
629 	(void) getuniverse(ubuf);
630 	xprintf("%s\n", ubuf);
631     }
632     else {
633 	cp2 = v[2];
634 	if (cp2 == 0) {
635 	    if (*cp == '\0' || setuniverse(short2str(cp)) != 0)
636 		stderror(ERR_NAME | ERR_STRING, CGETS(23, 12, "Illegal universe"));
637 	    }
638 	else {
639 	    (void) getuniverse(ubuf);
640 	    if (*cp == '\0' || setuniverse(short2str(cp)) != 0)
641 		stderror(ERR_NAME | ERR_STRING, CGETS(23, 12, "Illegal universe"));
642 	    cleanup_push(ubuf, setuniverse_cleanup);
643 	    if (setintr) {
644 		pintr_disabled++;
645 		cleanup_push(&pintr_disabled, disabled_cleanup);
646 	    }
647 	    lshift(v, 2);
648 	    if (setintr)
649 		cleanup_until(&pintr_disabled);
650 	    reexecute(c);
651 	    cleanup_until(ubuf);
652 	}
653     }
654 }
655 #endif /* masscomp || _CX_UX */
656 
657 /***
658  *** BS2000/OSD POSIX (Fujitsu Siemens Computers)
659  ***/
660 #if defined(_OSD_POSIX)
661 static int
662 bs2upcase(char *str)
663 {
664     enum { outside = ' ', singlequote='\'', doublequote='"'} string = outside;
665 
666     char *white;
667 
668     for (white = str + strlen(str) - 1; isspace(*white) && white > str; --white)
669         *white = '\0';
670 
671     for (; *str != '\0'; ++str)
672     {
673         if (string == outside)
674         {
675             *str = toupper (*str);
676         }
677         if (*str == '\'')
678         {
679             if (string == outside)
680                 string = singlequote;
681             else if (string != doublequote)
682                 string = outside;
683         }
684         else if (*str == '"')
685         {
686             if (string == outside)
687                 string = doublequote;
688             else if (string != singlequote)
689                 string = outside;
690         }
691     }
692     if (string != outside)
693     {
694         stderror(ERR_NAME | ERR_UNMATCHED, (Char) string);
695         return 1;
696     }
697     return 0;
698 }
699 static int
700 bs2cmdlist(char *str)
701 {
702     char *str_beg = NULL;
703     int ret = 0;
704 
705     enum { outside = ' ', singlequote='\'', doublequote='"'} string = outside;
706 
707     while (*str != '\0')
708     {
709         while (isspace(*str))
710             ++str;
711 
712         if (*str == '\0')
713             break;
714 
715         str_beg = str;
716 
717         for (; *str != '\0'; ++str)
718         {
719             if (string == outside && *str == ';') /* End of command */
720             {
721                 *str++ = '\0';
722                 break;    /* continue with next command */
723             }
724             if (*str == '\'')
725             {
726                 if (string == outside)
727                     string = singlequote;
728                 else if (string != doublequote)
729                     string = outside;
730             }
731             else if (*str == '"')
732             {
733                 if (string == outside)
734                     string = doublequote;
735                 else if (string != singlequote)
736                     string = outside;
737             }
738         }
739         if (strlen(str_beg) != 0)
740         {
741             ret = bs2system(str_beg);
742 	    flush();
743             if (ret != 0 /*&& !option.err_ignore*/)
744                 break; /* do not continue after errors */
745         }
746     }
747 
748     if (string != outside)
749     {
750         stderror(ERR_NAME | ERR_UNMATCHED, (Char) string);
751         return -1;
752     }
753 
754     return ret;
755 }
756 /*ARGSUSED*/
757 void
758 dobs2cmd(Char **v, struct command *c)
759 {
760     Char *cp, **globbed;
761     int  i = 0, len = 0;
762     char *cmd = NULL;
763     int     pvec[2];
764     struct command faket;
765     Char   *fakecom[2];
766     char    tibuf[BUFSIZE];
767     int     icnt, old_pintr_disabled;
768     static const Char STRbs2cmd[] = { 'b','s','2','c','m','d','\0' };
769 
770     v++;
771     if (setintr)
772 	pintr_push_enable(&old_pintr_disabled);
773     v = glob_all_or_error(v);
774     if (setintr)
775 	cleanup_until(&old_pintr_disabled);
776     globbed = v;
777     cleanup_push(globbed, blk_cleanup);
778 
779     /* First round: count the string lengths */
780     for (i=0; v[i]; ++i) {
781 	len += Strlen(v[i]) + (v[i+1] != NULL);
782     }
783 
784     cmd = xmalloc(len+1); /* 1 for the final '\0' *//* FIXME: memory leak? */
785 
786     /* 2nd round: fill cmd buffer */
787     i = 0;
788     while ((cp = *v++) != 0) {
789 	int c;
790 	while (c = *cp++)
791 	    cmd[i++] = (char)c;
792         if (*v)
793 	    cmd[i++] = ' ';
794     }
795     cmd[i] = '\0';
796 
797     /* Make upper case */
798     bs2upcase(cmd);
799 
800     faket.t_dtyp = NODE_COMMAND;
801     faket.t_dflg = F_BACKQ|F_STDERR;
802     faket.t_dlef = 0;
803     faket.t_drit = 0;
804     faket.t_dspr = 0;
805     faket.t_dcom = fakecom;
806     fakecom[0] = (Char *)STRbs2cmd;
807     fakecom[1] = 0;
808 
809     mypipe(pvec);
810     cleanup_push(&pvec[0], open_cleanup);
811     cleanup_push(&pvec[1], open_cleanup);
812     if (pfork(&faket, -1) == 0) {
813 	sigset_t set;
814         /* child */
815         xclose(pvec[0]);
816         (void) dmove(pvec[1], 1);
817         (void) dmove(SHDIAG,  2);
818         initdesc();
819 	sigemptyset(&set);
820 	sigaddset(&set, SIGINT);
821 	(void)sigprocmask(SIG_UNBLOCK, &set, NULL);
822 #ifdef SIGTSTP
823         signal(SIGTSTP, SIG_IGN);
824 #endif
825 #ifdef SIGTTIN
826         signal(SIGTTIN, SIG_IGN);
827 #endif
828 #ifdef SIGTTOU
829         signal(SIGTTOU, SIG_IGN);
830 #endif
831         xexit(bs2cmdlist(cmd));
832     }
833     cleanup_until(&pvec[1]);
834     for (;;) {
835 	int old_pintr_disabled;
836 
837 	if (setintr)
838 	    pintr_push_enable(&old_pintr_disabled);
839 	icnt = xread(pvec[0], tibuf, sizeof(tibuf));
840 	if (setintr)
841 	    cleanup_until(&old_pintr_disabled);
842         if (icnt <= 0)
843             break;
844         for (i = 0; i < icnt; i++)
845             xputchar((unsigned char) tibuf[i]);
846     }
847     cleanup_until(&pvec[0]);
848     pwait();
849 
850     flush();
851 
852     cleanup_until(globbed);
853 }
854 #endif /* _OSD_POSIX */
855 
856 #if defined(_CX_UX)
857 static void
858 setuniverse_cleanup(void *xbuf)
859 {
860     char *buf;
861 
862     buf = xbuf;
863     setuniverse(buf);
864 }
865 
866 /*ARGSUSED*/
867 void
868 doatt(Char **v, struct command *c)
869 {
870     Char *cp = v[1];
871     char    ubuf[100];
872 
873     if (cp == 0)
874 	(void) setuniverse("att");
875     else {
876 	(void) getuniverse(ubuf);
877 	(void) setuniverse("att");
878 	cleanup_push(ubuf, setuniverse_cleanup);
879 	if (setintr) {
880 	    pintr_disabled++;
881 	    cleanup_push(&pintr_disabled, disabled_cleanup);
882 	}
883 	lshift(v, 1);
884 	if (setintr)
885 	    cleanup_until(&pintr_disabled);
886 	reexecute(c);
887 	cleanup_until(ubuf);
888     }
889 }
890 
891 /*ARGSUSED*/
892 void
893 doucb(Char **v, struct command *c)
894 {
895     Char *cp = v[1];
896     char    ubuf[100];
897 
898     if (cp == 0)
899 	(void) setuniverse("ucb");
900     else {
901 	(void) getuniverse(ubuf);
902 	(void) setuniverse("ucb");
903 	cleanup_push(ubuf, setuniverse_cleanup);
904 	if (setintr) {
905 	    pintr_disabled++;
906 	    cleanup_push(&pintr_disabled, disabled_cleanup);
907 	}
908 	lshift(v, 1);
909 	if (setintr)
910 	    cleanup_until(&pintr_disabled);
911 	reexecute(c);
912 	cleanup_until(ubuf);
913     }
914 }
915 #endif /* _CX_UX */
916 
917 #ifdef _SEQUENT_
918 /*
919  * Compute the difference in process stats.
920  */
921 void
922 pr_stat_sub(struct process_stats *p2, struct process_stats *p1,
923 	    struct process_stats *pr)
924 {
925     pr->ps_utime.tv_sec = p2->ps_utime.tv_sec - p1->ps_utime.tv_sec;
926     pr->ps_utime.tv_usec = p2->ps_utime.tv_usec - p1->ps_utime.tv_usec;
927     if (pr->ps_utime.tv_usec < 0) {
928 	pr->ps_utime.tv_sec -= 1;
929 	pr->ps_utime.tv_usec += 1000000;
930     }
931     pr->ps_stime.tv_sec = p2->ps_stime.tv_sec - p1->ps_stime.tv_sec;
932     pr->ps_stime.tv_usec = p2->ps_stime.tv_usec - p1->ps_stime.tv_usec;
933     if (pr->ps_stime.tv_usec < 0) {
934 	pr->ps_stime.tv_sec -= 1;
935 	pr->ps_stime.tv_usec += 1000000;
936     }
937 
938     pr->ps_maxrss = p2->ps_maxrss - p1->ps_maxrss;
939     pr->ps_pagein = p2->ps_pagein - p1->ps_pagein;
940     pr->ps_reclaim = p2->ps_reclaim - p1->ps_reclaim;
941     pr->ps_zerofill = p2->ps_zerofill - p1->ps_zerofill;
942     pr->ps_pffincr = p2->ps_pffincr - p1->ps_pffincr;
943     pr->ps_pffdecr = p2->ps_pffdecr - p1->ps_pffdecr;
944     pr->ps_swap = p2->ps_swap - p1->ps_swap;
945     pr->ps_syscall = p2->ps_syscall - p1->ps_syscall;
946     pr->ps_volcsw = p2->ps_volcsw - p1->ps_volcsw;
947     pr->ps_involcsw = p2->ps_involcsw - p1->ps_involcsw;
948     pr->ps_signal = p2->ps_signal - p1->ps_signal;
949     pr->ps_lread = p2->ps_lread - p1->ps_lread;
950     pr->ps_lwrite = p2->ps_lwrite - p1->ps_lwrite;
951     pr->ps_bread = p2->ps_bread - p1->ps_bread;
952     pr->ps_bwrite = p2->ps_bwrite - p1->ps_bwrite;
953     pr->ps_phread = p2->ps_phread - p1->ps_phread;
954     pr->ps_phwrite = p2->ps_phwrite - p1->ps_phwrite;
955 }
956 
957 #endif /* _SEQUENT_ */
958 
959 
960 #ifndef HAVE_MEMSET
961 /* This is a replacement for a missing memset function */
962 void *xmemset(void *loc, int value, size_t len)
963 {
964     char *ptr = loc;
965 
966     while (len--)
967 	*ptr++ = value;
968     return loc;
969 }
970 #endif /* !HAVE_MEMSET */
971 
972 
973 #ifndef HAVE_MEMMOVE
974 /* memmove():
975  * 	This is the ANSI form of bcopy() with the arguments backwards...
976  *	Unlike memcpy(), it handles overlaps between source and
977  *	destination memory
978  */
979 void *
980 xmemmove(void *vdst, const void *vsrc, size_t len)
981 {
982     const char *src = vsrc;
983     char *dst = vdst;
984 
985     if (src == dst)
986 	return vdst;
987 
988     if (src > dst) {
989 	while (len--)
990 	    *dst++ = *src++;
991     }
992     else {
993 	src += len;
994 	dst += len;
995 	while (len--)
996 	    *--dst = *--src;
997     }
998     return vdst;
999 }
1000 #endif /* HAVE_MEMMOVE */
1001 
1002 
1003 #ifndef WINNT_NATIVE
1004 #ifdef NEEDtcgetpgrp
1005 pid_t
1006 xtcgetpgrp(int fd)
1007 {
1008     int     pgrp;
1009 
1010     /* ioctl will handle setting errno correctly. */
1011     if (ioctl(fd, TIOCGPGRP, (ioctl_t) & pgrp) < 0)
1012 	return (-1);
1013     return (pgrp);
1014 }
1015 
1016 /*
1017  * XXX: tcsetpgrp is not a macro any more cause on some systems,
1018  * pid_t is a short, but the ioctl() takes a pointer to int (pyr)
1019  * Thanks to Simon Day (simon@pharaoh.cyborg.bt.co.uk) for pointing
1020  * this out.
1021  */
1022 int
1023 xtcsetpgrp(int fd, int pgrp)
1024 {
1025     return ioctl(fd, TIOCSPGRP, (ioctl_t) &pgrp);
1026 }
1027 
1028 #endif	/* NEEDtcgetpgrp */
1029 #endif /* WINNT_NATIVE */
1030 
1031 
1032 #ifdef YPBUGS
1033 void
1034 fix_yp_bugs(void)
1035 {
1036     char   *mydomain;
1037 
1038     extern int yp_get_default_domain (char **);
1039     /*
1040      * PWP: The previous version assumed that yp domain was the same as the
1041      * internet name domain.  This isn't allways true. (Thanks to Mat Landau
1042      * <mlandau@bbn.com> for the original version of this.)
1043      */
1044     if (yp_get_default_domain(&mydomain) == 0) {	/* if we got a name */
1045 	extern void yp_unbind (const char *);
1046 
1047 	yp_unbind(mydomain);
1048     }
1049 }
1050 
1051 #endif /* YPBUGS */
1052 
1053 #ifdef STRCOLLBUG
1054 void
1055 fix_strcoll_bug(void)
1056 {
1057 #if defined(NLS) && defined(HAVE_STRCOLL)
1058     /*
1059      * SunOS4 checks the file descriptor from openlocale() for <= 0
1060      * instead of == -1. Someone should tell sun that file descriptor 0
1061      * is valid! Our portable hack: open one so we call it with 0 used...
1062      * We have to call this routine every time the locale changes...
1063      *
1064      * Of course it also tries to free the constant locale "C" it initially
1065      * had allocated, with the sequence
1066      * > setenv LANG "fr"
1067      * > ls^D
1068      * > unsetenv LANG
1069      * But we are smarter than that and just print a warning message.
1070      */
1071     int fd = -1;
1072     static char *root = "/";
1073 
1074     if (!didfds)
1075 	fd = xopen(root, O_RDONLY|O_LARGEFILE);
1076 
1077     (void) strcoll(root, root);
1078 
1079     if (fd != -1)
1080 	xclose(fd);
1081 #endif
1082 }
1083 #endif /* STRCOLLBUG */
1084 
1085 
1086 #ifdef OREO
1087 #include <compat.h>
1088 #endif /* OREO */
1089 
1090 void
1091 osinit(void)
1092 {
1093 #ifdef OREO
1094     set42sig();
1095     setcompat(getcompat() & ~COMPAT_EXEC);
1096     signal(SIGIO, SIG_IGN);		/* ignore SIGIO */
1097 #endif /* OREO */
1098 
1099 #ifdef aiws
1100     {
1101 	struct sigstack inst;
1102 	inst.ss_sp = xmalloc(4192) + 4192;
1103 	inst.ss_onstack = 0;
1104 	sigstack(&inst, NULL);
1105     }
1106 #endif /* aiws */
1107 
1108 #ifdef apollo
1109     (void) isapad();
1110 #endif
1111 
1112 #ifdef _SX
1113     /*
1114      * kill(SIGCONT) problems, don't know what this syscall does
1115      * [schott@rzg.mpg.de]
1116      */
1117     syscall(151, getpid(), getpid());
1118 #endif /* _SX */
1119 }
1120 
1121 #ifndef HAVE_STRERROR
1122 extern int sys_nerr;
1123 extern char *sys_errlist[];
1124 char *
1125 xstrerror(int i)
1126 {
1127     if (i >= 0 && i < sys_nerr) {
1128 	return sys_errlist[i];
1129     } else {
1130 	static char *errbuf; /* = NULL; */
1131 
1132 	xfree(errbuf);
1133 	errbuf = xasprintf(CGETS(23, 13, "Unknown Error: %d"), i);
1134 	return errbuf;
1135     }
1136 }
1137 #endif /* !HAVE_STRERROR */
1138 
1139 #ifndef HAVE_GETHOSTNAME
1140 # if !defined(_MINIX) && !defined(__EMX__) && !defined(WINNT_NATIVE)
1141 #  include <sys/utsname.h>
1142 # endif /* !_MINIX && !__EMX__ && !WINNT_NATIVE */
1143 
1144 int
1145 xgethostname(char *name, int namlen)
1146 {
1147 # if !defined(_MINIX) && !defined(__EMX__) && !defined(WINNT_NATIVE)
1148     int     i, retval;
1149     struct utsname uts;
1150 
1151     retval = uname(&uts);
1152 
1153 #  ifdef DEBUG
1154     xprintf(CGETS(23, 14, "sysname:  %s\n"), uts.sysname);
1155     xprintf(CGETS(23, 15, "nodename: %s\n"), uts.nodename);
1156     xprintf(CGETS(23, 16, "release:  %s\n"), uts.release);
1157     xprintf(CGETS(23, 17, "version:  %s\n"), uts.version);
1158     xprintf(CGETS(23, 18, "machine:  %s\n"), uts.machine);
1159 #  endif /* DEBUG */
1160     i = strlen(uts.nodename) + 1;
1161     (void) strncpy(name, uts.nodename, i < namlen ? i : namlen);
1162 
1163     return retval;
1164 # else /* !_MINIX && !__EMX__ */
1165     if (namlen > 0) {
1166 #  ifdef __EMX__
1167 	(void) strncpy(name, "OS/2", namlen);
1168 #  else /* _MINIX */
1169 	(void) strncpy(name, "minix", namlen);
1170 #  endif /* __EMX__ */
1171 	name[namlen-1] = '\0';
1172     }
1173     return(0);
1174 #endif /* _MINIX && !__EMX__ */
1175 } /* end xgethostname */
1176 #endif /* !HAVE_GETHOSTNAME */
1177 
1178 #ifndef HAVE_NICE
1179 # if defined(_MINIX) && defined(NICE)
1180 #  undef _POSIX_SOURCE	/* redefined in <lib.h> */
1181 #  undef _MINIX		/* redefined in <lib.h> */
1182 #  undef HZ		/* redefined in <minix/const.h> */
1183 #  include <lib.h>
1184 # endif /* _MINIX && NICE */
1185 int
1186 xnice(int incr)
1187 {
1188 #if defined(_MINIX) && defined(NICE)
1189     return callm1(MM, NICE, incr, 0, 0, NIL_PTR, NIL_PTR, NIL_PTR);
1190 #else
1191     return /* incr ? 0 : */ 0;
1192 #endif /* _MINIX && NICE */
1193 } /* end xnice */
1194 #endif /* !HAVE_NICE */
1195 
1196 #ifndef HAVE_GETCWD
1197 static char *strnrcpy (char *, char *, size_t);
1198 
1199 /* xgetcwd():
1200  *	Return the pathname of the current directory, or return
1201  *	an error message in pathname.
1202  */
1203 
1204 # ifdef hp9000s500
1205 /*
1206  *  From: Bernd Mohr <mohr@faui77.informatik.uni-erlangen.de>
1207  *  I also ported the tcsh to the HP9000 Series 500. This computer
1208  *  is a little bit different than the other HP 9000 computer. It has
1209  *  a HP Chip instead of a Motorola CPU and it is no "real" UNIX. It runs
1210  *  HP-UX which is emulated in top of a HP operating system. So, the last
1211  *  supported version of HP-UX is 5.2 on the HP9000s500. This has two
1212  *  consequences: it supports no job control and it has a filesystem
1213  *  without "." and ".." !!!
1214  */
1215 char *
1216 xgetcwd(char *pathname, size_t pathlen)
1217 {
1218     char pathbuf[MAXPATHLEN];	/* temporary pathname buffer */
1219     char *pnptr = &pathbuf[(sizeof pathbuf)-1]; /* pathname pointer */
1220     dev_t rdev;			/* root device number */
1221     DIR *dirp = NULL;		/* directory stream */
1222     ino_t rino;			/* root inode number */
1223     off_t rsize;		/* root size */
1224     struct direct *dir;		/* directory entry struct */
1225     struct stat d, dd;		/* file status struct */
1226     int serrno;
1227 
1228     *pnptr = '\0';
1229     (void) stat("/.", &d);
1230     rdev = d.st_dev;
1231     rino = d.st_ino;
1232     rsize = d.st_size;
1233     for (;;) {
1234 	if (stat(".", &d) == -1) {
1235 	    (void) xsnprintf(pathname, pathlen, CGETS(23, 24,
1236 		"getcwd: Cannot stat \".\" (%s)"), strerror(errno));
1237 	    goto fail;
1238 	}
1239 	if (d.st_ino == rino && d.st_dev == rdev && d.st_size == rsize)
1240 	    break;		/* reached root directory */
1241 	if ((dirp = opendir("..")) == NULL) {
1242 	    (void) xsnprintf(pathname, pathlen, CGETS(23, 19,
1243 		"getcwd: Cannot open \"..\" (%s)"), strerror(errno));
1244 	    goto fail;
1245 	}
1246 	if (chdir("..") == -1) {
1247 	    (void) xsnprintf(pathname, pathlen, CGETS(23, 20,
1248 		"getcwd: Cannot chdir to \"..\" (%s)"), strerror(errno));
1249 	    goto fail;
1250 	}
1251 	do {
1252 	    if ((dir = readdir(dirp)) == NULL) {
1253 		(void) xsnprintf(pathname, pathlen,
1254 		    CGETS(23, 21, "getcwd: Read error in \"..\" (%s)"),
1255 		    strerror(errno));
1256 		goto fail;
1257 	    }
1258 	    if (stat(dir->d_name, &dd) == -1) {
1259 		(void) xsnprintf(pathname, pathlen,
1260 		    CGETS(23, 25, "getcwd: Cannot stat directory \"%s\" (%s)"),
1261 		    dir->d_name, strerror(errno));
1262 		goto fail;
1263 	    }
1264 	} while (dd.st_ino  != d.st_ino  ||
1265 		 dd.st_dev  != d.st_dev  ||
1266 		 dd.st_size != d.st_size);
1267 	closedir(dirp);
1268 	dirp = NULL;
1269 	pnptr = strnrcpy(dirp->d_name, pnptr, pnptr - pathbuf);
1270 	pnptr = strnrcpy("/", pnptr, pnptr - pathbuf);
1271     }
1272 
1273     if (*pnptr == '\0')		/* current dir == root dir */
1274 	(void) strncpy(pathname, "/", pathlen);
1275     else {
1276 	(void) strncpy(pathname, pnptr, pathlen);
1277 	pathname[pathlen - 1] = '\0';
1278 	if (chdir(pnptr) == -1) {
1279 	    (void) xsnprintf(pathname, MAXPATHLEN, CGETS(23, 22,
1280 		    "getcwd: Cannot change back to \".\" (%s)"),
1281 		    strerror(errno));
1282 	    return NULL;
1283 	}
1284     }
1285     return pathname;
1286 
1287 fail:
1288     serrno = errno;
1289     (void) chdir(strnrcpy(".", pnptr, pnptr - pathbuf));
1290     errno = serrno;
1291     return NULL;
1292 }
1293 
1294 # else /* ! hp9000s500 */
1295 
1296 
1297 char *
1298 xgetcwd(char *pathname, size_t pathlen)
1299 {
1300     DIR    *dp;
1301     struct dirent *d;
1302 
1303     struct stat st_root, st_cur, st_next, st_dotdot;
1304     char    pathbuf[MAXPATHLEN], nextpathbuf[MAXPATHLEN * 2];
1305     char   *pathptr, *nextpathptr, *cur_name_add;
1306     int	   save_errno = 0;
1307 
1308     /* find the inode of root */
1309     if (stat("/", &st_root) == -1) {
1310 	(void) xsnprintf(pathname, pathlen, CGETS(23, 23,
1311 			"getcwd: Cannot stat \"/\" (%s)"),
1312 			strerror(errno));
1313 	return NULL;
1314     }
1315     pathbuf[MAXPATHLEN - 1] = '\0';
1316     pathptr = &pathbuf[MAXPATHLEN - 1];
1317     nextpathbuf[MAXPATHLEN - 1] = '\0';
1318     cur_name_add = nextpathptr = &nextpathbuf[MAXPATHLEN - 1];
1319 
1320     /* find the inode of the current directory */
1321     if (lstat(".", &st_cur) == -1) {
1322 	(void) xsnprintf(pathname, pathlen, CGETS(23, 24,
1323 			 "getcwd: Cannot stat \".\" (%s)"),
1324 			 strerror(errno));
1325 	return NULL;
1326     }
1327     nextpathptr = strnrcpy(nextpathptr, "../", nextpathptr - nextpathbuf);
1328 
1329     /* Descend to root */
1330     for (;;) {
1331 
1332 	/* look if we found root yet */
1333 	if (st_cur.st_ino == st_root.st_ino &&
1334 	    DEV_DEV_COMPARE(st_cur.st_dev, st_root.st_dev)) {
1335 	    (void) strncpy(pathname, *pathptr != '/' ? "/" : pathptr, pathlen);
1336 	    pathname[pathlen - 1] = '\0';
1337 	    return pathname;
1338 	}
1339 
1340 	/* open the parent directory */
1341 	if (stat(nextpathptr, &st_dotdot) == -1) {
1342 	    (void) xsnprintf(pathname, pathlen, CGETS(23, 25,
1343 			     "getcwd: Cannot stat directory \"%s\" (%s)"),
1344 			     nextpathptr, strerror(errno));
1345 	    return NULL;
1346 	}
1347 	if ((dp = opendir(nextpathptr)) == NULL) {
1348 	    (void) xsnprintf(pathname, pathlen, CGETS(23, 26,
1349 			     "getcwd: Cannot open directory \"%s\" (%s)"),
1350 			     nextpathptr, strerror(errno));
1351 	    return NULL;
1352 	}
1353 
1354 	/* look in the parent for the entry with the same inode */
1355 	if (DEV_DEV_COMPARE(st_dotdot.st_dev, st_cur.st_dev)) {
1356 	    /* Parent has same device. No need to stat every member */
1357 	    for (d = readdir(dp); d != NULL; d = readdir(dp)) {
1358 #ifdef __clipper__
1359 		if (((unsigned long)d->d_ino & 0xffff) == st_cur.st_ino)
1360 		    break;
1361 #else
1362 		if (d->d_ino == st_cur.st_ino)
1363 		    break;
1364 #endif
1365 	    }
1366 	}
1367 	else {
1368 	    /*
1369 	     * Parent has a different device. This is a mount point so we
1370 	     * need to stat every member
1371 	     */
1372 	    for (d = readdir(dp); d != NULL; d = readdir(dp)) {
1373 		if (ISDOT(d->d_name) || ISDOTDOT(d->d_name))
1374 		    continue;
1375 		(void)strncpy(cur_name_add, d->d_name,
1376 		    (size_t) (&nextpathbuf[sizeof(nextpathbuf) - 1] - cur_name_add));
1377 		if (lstat(nextpathptr, &st_next) == -1) {
1378 		    /*
1379 		     * We might not be able to stat() some path components
1380 		     * if we are using afs, but this is not an error as
1381 		     * long as we find the one we need; we also save the
1382 		     * first error to report it if we don't finally succeed.
1383 		     */
1384 		    if (save_errno == 0)
1385 			save_errno = errno;
1386 		    continue;
1387 		}
1388 		/* check if we found it yet */
1389 		if (st_next.st_ino == st_cur.st_ino &&
1390 		    DEV_DEV_COMPARE(st_next.st_dev, st_cur.st_dev))
1391 		    break;
1392 	    }
1393 	}
1394 	if (d == NULL) {
1395 	    (void) xsnprintf(pathname, pathlen, CGETS(23, 27,
1396 			     "getcwd: Cannot find \".\" in \"..\" (%s)"),
1397 			     strerror(save_errno ? save_errno : ENOENT));
1398 	    closedir(dp);
1399 	    return NULL;
1400 	}
1401 	else
1402 	    save_errno = 0;
1403 	st_cur = st_dotdot;
1404 	pathptr = strnrcpy(pathptr, d->d_name, pathptr - pathbuf);
1405 	pathptr = strnrcpy(pathptr, "/", pathptr - pathbuf);
1406 	nextpathptr = strnrcpy(nextpathptr, "../", nextpathptr - nextpathbuf);
1407 	*cur_name_add = '\0';
1408 	closedir(dp);
1409     }
1410 } /* end getcwd */
1411 # endif /* hp9000s500 */
1412 
1413 /* strnrcpy():
1414  *	Like strncpy, going backwards and returning the new pointer
1415  */
1416 static char *
1417 strnrcpy(char *ptr, char *str, size_t siz)
1418 {
1419     int len = strlen(str);
1420     if (siz == 0)
1421 	return ptr;
1422 
1423     while (len && siz--)
1424 	*--ptr = str[--len];
1425 
1426     return (ptr);
1427 } /* end strnrcpy */
1428 #endif /* !HAVE_GETCWD */
1429 
1430 #ifdef apollo
1431 /***
1432  *** Domain/OS
1433  ***/
1434 #include <apollo/base.h>
1435 #include <apollo/loader.h>
1436 #include <apollo/error.h>
1437 
1438 
1439 static char *
1440 apperr(status_$t *st)
1441 {
1442     static char *buf; /* = NULL */
1443     short e_subl, e_modl, e_codel;
1444     error_$string_t e_sub, e_mod, e_code;
1445 
1446     error_$get_text(*st, e_sub, &e_subl, e_mod, &e_modl, e_code, &e_codel);
1447     e_sub[e_subl] = '\0';
1448     e_code[e_codel] = '\0';
1449     e_mod[e_modl] = '\0';
1450     xfree(buf);
1451     buf = xasprintf("%s (%s/%s)", e_code, e_sub, e_mod);
1452 
1453     return(buf);
1454 }
1455 
1456 static int
1457 llib(Char *s)
1458 {
1459     short len = Strlen(s);
1460     status_$t st;
1461     char *t;
1462 
1463     loader_$inlib(t = short2str(s), len, &st);
1464     if (st.all != status_$ok)
1465 	stderror(ERR_SYSTEM, t, apperr(&st));
1466 }
1467 
1468 /*ARGSUSED*/
1469 void
1470 doinlib(Char **v, struct command *c)
1471 {
1472     Char **globbed;
1473 
1474     setname(short2str(*v++));
1475     v = glob_all_or_error(v);
1476     globbed = v;
1477     cleanup_push(globbed, blk_cleanup);
1478 
1479     while (v && *v)
1480 	llib(*v++);
1481     cleanup_until(globbed);
1482 }
1483 
1484 int
1485 getv(Char *v)
1486 {
1487     if (eq(v, STRbsd43))
1488 	return(1);
1489     else if (eq(v, STRsys53))
1490 	return(0);
1491     else
1492 	stderror(ERR_NAME | ERR_SYSTEM, short2str(v),
1493 		 CGETS(23, 28, "Invalid system type"));
1494     /*NOTREACHED*/
1495     return(0);
1496 }
1497 
1498 /*ARGSUSED*/
1499 void
1500 dover(Char **v, struct command *c)
1501 {
1502     Char *p;
1503 
1504     setname(short2str(*v++));
1505     if (!*v) {
1506 	if (!(p = tgetenv(STRSYSTYPE)))
1507 	    stderror(ERR_NAME | ERR_STRING,
1508 		     CGETS(23, 29, "System type is not set"));
1509 	xprintf("%S\n", p);
1510     }
1511     else {
1512 	tsetenv(STRSYSTYPE, getv(*v) ? STRbsd43 : STRsys53);
1513 	dohash(NULL, NULL);
1514     }
1515 }
1516 
1517 /*
1518  * Many thanks to rees@citi.umich.edu (Jim Rees) and
1519  *                mathys@ssdt-tempe.sps.mot.com (Yves Mathys)
1520  * For figuring out how to do this... I could have never done
1521  * it without their help.
1522  */
1523 typedef short enum {
1524 	name_$wdir_type,
1525 	name_$ndir_type,
1526 	name_$node_dir_type,
1527 } name_$dir_type_t;
1528 
1529 /*ARGSUSED*/
1530 void
1531 dorootnode(Char **v, struct command *c)
1532 {
1533     name_$dir_type_t dirtype = name_$node_dir_type;
1534     uid_$t uid;
1535     status_$t st;
1536     char *name;
1537     short namelen;
1538 
1539     setname(short2str(*v++));
1540 
1541     name = short2str(*v);
1542     namelen = strlen(name);
1543 
1544     name_$resolve(name, &namelen, &uid, &st);
1545     if (st.all != status_$ok)
1546 	stderror(ERR_SYSTEM, name, apperr(&st));
1547     namelen = 0;
1548     name_$set_diru(&uid, "", &namelen, &dirtype, &st);
1549     if (st.all != status_$ok)
1550 	stderror(ERR_SYSTEM, name, apperr(&st));
1551     dohash(NULL, NULL);
1552 }
1553 
1554 int
1555 isapad(void)
1556 {
1557     static int res = -1;
1558     static status_$t st;
1559 
1560     if (res == -1) {
1561 	int strm;
1562 	if (isatty(0))
1563 	    strm = 0;
1564 	if (isatty(1))
1565 	    strm = 1;
1566 	if (isatty(2))
1567 	    strm = 2;
1568 	else {
1569 	    res = 0;
1570 	    st.all = status_$ok;
1571 	    return(res);
1572 	}
1573 	res = stream_$isavt(&strm, &st);
1574 	res = res ? 1 : 0;
1575     }
1576     else {
1577 	if (st.all != status_$ok)
1578 	    stderror(ERR_SYSTEM, "stream_$isavt", apperr(&st));
1579     }
1580     return(res);
1581 }
1582 #endif
1583 
1584 #if defined(__CYGWIN__) && !defined(NO_CRYPT)
1585 #undef CHAR		/* Collides with Win32 API */
1586 #define WIN32_LEAN_AND_MEAN
1587 #include <windows.h>
1588 #include <sys/cygwin.h>
1589 char *
1590 cygwin_xcrypt(struct passwd *pw, const char *password, const char *expected_pwd)
1591 {
1592     static char invalid_password[] = "\377";
1593     HANDLE token = cygwin_logon_user(pw, password);
1594     if (token == INVALID_HANDLE_VALUE)
1595 	return invalid_password;
1596     CloseHandle(token);
1597     return (char *) expected_pwd;
1598 }
1599 #endif /* __CYGWIN__ && !NO_CRYPT */
1600