1 /* $Header: /p/tcsh/cvsroot/tcsh/tc.func.c,v 3.136 2006/09/01 12:51:35 christos Exp $ */
3 * tc.func.c: New tcsh builtins.
6 * Copyright (c) 1980, 1991 The Regents of the University of California.
9 * Redistribution and use in source and binary forms, with or without
10 * modification, are permitted provided that the following conditions
12 * 1. Redistributions of source code must retain the above copyright
13 * notice, this list of conditions and the following disclaimer.
14 * 2. Redistributions in binary form must reproduce the above copyright
15 * notice, this list of conditions and the following disclaimer in the
16 * documentation and/or other materials provided with the distribution.
17 * 3. Neither the name of the University nor the names of its contributors
18 * may be used to endorse or promote products derived from this software
19 * without specific prior written permission.
21 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
22 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
25 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
35 RCSID("$tcsh: tc.func.c,v 3.136 2006/09/01 12:51:35 christos Exp $")
38 #include "ed.defns.h" /* for the function names */
43 #else /* WINNT_NATIVE */
45 #endif /* WINNT_NATIVE */
49 #include <afs/kautils.h>
50 long ka_UserAuthenticateGeneral();
56 extern time_t t_period;
57 extern int just_signaled;
58 static int precmd_active = 0;
59 static int jobcmd_active = 0; /* GrP */
60 static int postcmd_active = 0;
61 static int periodic_active = 0;
62 static int cwdcmd_active = 0; /* PWP: for cwd_cmd */
63 static int beepcmd_active = 0;
64 static void (*alm_fun)(void) = NULL;
66 static void auto_logout (void);
67 static char *xgetpass (const char *);
68 static void auto_lock (void);
70 static void insert (struct wordent *, int);
71 static void insert_we (struct wordent *, struct wordent *);
72 static int inlist (Char *, Char *);
74 static int tildecompare (const void *, const void *);
75 static Char *gethomedir (const Char *);
77 static void palarm (int);
78 static void getremotehost (int);
79 #endif /* REMOTEHOST */
86 * expand_lex: Take the given lex and return an expanded version of it.
87 * First guy in lex list is ignored; last guy is ^J which we ignore.
88 * Only take lex'es from position 'from' to position 'to' inclusive
90 * Note: csh sometimes sets bit 8 in characters which causes all kinds
91 * of problems if we don't mask it here. Note: excl's in lexes have been
92 * un-back-slashed and must be re-back-slashed
95 /* PWP: this is a combination of the old sprlex() and the expand_lex from
96 the magic-space stuff */
99 expand_lex(const struct wordent *sp0, int from, int to)
101 struct Strbuf buf = Strbuf_INIT;
102 const struct wordent *sp;
109 if (!sp0 || (sp = sp0->next) == sp0 || sp == (sp0 = sp0->prev))
110 return Strbuf_finish(&buf); /* null lex */
113 if ((i >= from) && (i <= to)) { /* if in range */
114 for (s = sp->word; *s; s++) {
116 * bugfix by Michael Bloom: anything but the current history
117 * character {(PWP) and backslash} seem to be dealt with
121 && (((*s & TRIM) == HIST) ||
122 (((*s & TRIM) == '\'') && (prev_c != '\\')) ||
123 (((*s & TRIM) == '\"') && (prev_c != '\\')) ||
124 (((*s & TRIM) == '\\') && (prev_c != '\\')))) {
125 Strbuf_append1(&buf, '\\');
127 Strbuf_append1(&buf, *s & TRIM);
130 Strbuf_append1(&buf, ' ');
137 buf.len--; /* get rid of trailing space */
139 return Strbuf_finish(&buf);
143 sprlex(const struct wordent *sp0)
145 return expand_lex(sp0, 0, INT_MAX);
150 Itoa(int n, size_t min_digits, Char attributes)
153 * The array size here is derived from
155 * which is guaranteed to be enough for a decimal
156 * representation. We add 1 because integer divide
162 Char buf[CHAR_BIT * sizeof(int) / 3 + 1], *res, *p, *s;
163 unsigned int un; /* handle most negative # too */
164 int pad = (min_digits != 0);
166 if (sizeof(buf) - 1 < min_digits)
167 min_digits = sizeof(buf) - 1;
175 *p++ = un % 10 + '0';
177 } while ((pad && --min_digits > 0) || un != 0);
179 res = xmalloc((p - buf + 2) * sizeof(*res));
184 *s++ = *--p | attributes;
193 dolist(Char **v, struct command *c)
201 struct Strbuf word = Strbuf_INIT;
203 Strbuf_terminate(&word);
204 cleanup_push(&word, Strbuf_cleanup);
205 (void) t_search(&word, LIST, TW_ZERO, 0, STRNULL, 0);
206 cleanup_until(&word);
209 v = glob_all_or_error(v);
211 cleanup_push(globbed, blk_cleanup);
212 for (k = 0; v[k] != NULL && v[k][0] != '-'; k++)
216 * We cannot process a flag therefore we let ls do it right.
220 struct wordent cmd, *nextword, *lastword;
226 cleanup_push(&pintr_disabled, disabled_cleanup);
236 /* Look at listflags, to add -A to the flags, to get a path
237 of ls if necessary */
238 if ((vp = adrof(STRlistflags)) != NULL && vp->vec != NULL &&
239 vp->vec[0] != STRNULL) {
240 if (vp->vec[1] != NULL && vp->vec[1][0] != '\0')
242 for (cp = vp->vec[0]; *cp; cp++)
260 nextword = xcalloc(1, sizeof cmd);
261 nextword->word = Strsave(lspath);
262 lastword->next = nextword;
263 nextword->prev = lastword;
265 nextword = xcalloc(1, sizeof cmd);
266 nextword->word = Strsave(STRmCF);
267 lastword->next = nextword;
268 nextword->prev = lastword;
269 #if defined(KANJI) && defined(SHORT_STRINGS) && defined(DSPMBYTE)
272 nextword = xcalloc(1, sizeof cmd);
273 nextword->word = Strsave(STRmmliteral);
274 lastword->next = nextword;
275 nextword->prev = lastword;
279 if (color_context_ls) {
281 nextword = xcalloc(1, sizeof cmd);
282 nextword->word = Strsave(STRmmcolormauto);
283 lastword->next = nextword;
284 nextword->prev = lastword;
286 #endif /* COLOR_LS_F */
288 for (cp = *v; cp; cp = *++v) {
289 nextword = xcalloc(1, sizeof cmd);
290 nextword->word = quote(Strsave(cp));
291 lastword->next = nextword;
292 nextword->prev = lastword;
295 lastword->next = &cmd;
297 cleanup_push(&cmd, lex_cleanup);
299 /* build a syntax tree for the command. */
300 t = syntax(cmd.next, &cmd, 0);
301 cleanup_push(t, syntax_cleanup);
304 /* expand aliases like process() does */
306 /* execute the parse tree. */
307 execute(t, tpgrp > 0 ? tpgrp : -1, NULL, NULL, FALSE);
308 /* done. free the lex list and parse tree. */
311 cleanup_until(&pintr_disabled);
315 struct Strbuf buf = Strbuf_INIT;
317 cleanup_push(&buf, Strbuf_cleanup);
318 for (k = 0, i = 0; v[k] != NULL; k++) {
319 tmp = dnormalize(v[k], symlinks == SYM_IGNORE);
320 cleanup_push(tmp, xfree);
321 dp = Strend(tmp) - 1;
322 if (*dp == '/' && dp != tmp)
327 if (stat(short2str(tmp), &st) == -1) {
334 print_by_column(STRNULL, &v[i], k - i, FALSE);
336 xprintf("%S: %s.\n", tmp, strerror(err));
339 else if (S_ISDIR(st.st_mode)) {
345 print_by_column(STRNULL, &v[i], k - i, FALSE);
347 if (k != 0 && v[1] != NULL)
349 xprintf("%S:\n", tmp);
351 for (cp = tmp; *cp; cp++)
352 Strbuf_append1(&buf, (*cp | QUOTE));
353 Strbuf_terminate(&buf);
354 dp = &buf.s[buf.len - 1];
357 (*dp != (Char) (':' | QUOTE)) &&
358 #endif /* WINNT_NATIVE */
359 (*dp != (Char) ('/' | QUOTE))) {
360 Strbuf_append1(&buf, '/');
361 Strbuf_terminate(&buf);
364 (void) t_search(&buf, LIST, TW_ZERO, 0, STRNULL, 0);
373 print_by_column(STRNULL, &v[i], k - i, FALSE);
377 cleanup_until(globbed);
380 extern int GotTermCaps;
384 dotelltc(Char **v, struct command *c)
395 doechotc(Char **v, struct command *c)
405 dosettc(Char **v, struct command *c)
413 tv[0] = strsave(short2str(v[1]));
414 cleanup_push(tv[0], xfree);
415 tv[1] = strsave(short2str(v[2]));
416 cleanup_push(tv[1], xfree);
418 cleanup_until(tv[0]);
421 /* The dowhich() is by:
422 * Andreas Luik <luik@isaak.isa.de>
423 * I S A GmbH - Informationssysteme fuer computerintegrierte Automatisierung
430 cmd_expand(Char *cmd, Char **str)
432 struct wordent lexp[3];
436 lexp[0].next = &lexp[1];
437 lexp[1].next = &lexp[2];
438 lexp[2].next = &lexp[0];
440 lexp[0].prev = &lexp[2];
441 lexp[1].prev = &lexp[0];
442 lexp[2].prev = &lexp[1];
444 lexp[0].word = STRNULL;
445 lexp[2].word = STRret;
447 if ((vp = adrof1(cmd, &aliases)) != NULL && vp->vec != NULL) {
449 xprintf(CGETS(22, 1, "%S: \t aliased to "), cmd);
454 *str = blkexpand(vp->vec);
458 rv = tellmewhat(lexp, str);
466 dowhich(Char **v, struct command *c)
472 * We don't want to glob dowhich args because we lose quoteing
473 * E.g. which \ls if ls is aliased will not work correctly if
478 rv &= cmd_expand(*v, NULL);
481 setcopy(STRstatus, STR1, VAR_READWRITE);
484 /* PWP: a hack to start up your stopped editor on a single keystroke */
485 /* jbs - fixed hack so it worked :-) 3/28/89 */
490 struct process *pp, *retp;
496 if ((ep = getenv("EDITOR")) != NULL) { /* if we have a value */
497 if ((p = strrchr(ep, '/')) != NULL) /* if it has a path */
498 ep = p + 1; /* then we want only the last part */
503 if ((vp = getenv("VISUAL")) != NULL) { /* if we have a value */
504 if ((p = strrchr(vp, '/')) != NULL) /* and it has a path */
505 vp = p + 1; /* then we want only the last part */
510 for (vpl = 0; vp[vpl] && !isspace((unsigned char)vp[vpl]); vpl++)
512 for (epl = 0; ep[epl] && !isspace((unsigned char)ep[epl]); epl++)
515 if (pcurrent == NULL) /* see if we have any jobs */
516 return NULL; /* nope */
519 for (pp = proclist.p_next; pp; pp = pp->p_next)
520 if (pp->p_procid == pp->p_jobid) {
523 * Only foreground an edit session if it is suspended. Some GUI
524 * editors have may be happily running in a separate window, no
525 * point in foregrounding these if they're already running - webb
527 pstatus = (int) (pp->p_flags & PALLSTATES);
528 if (pstatus != PINTERRUPTED && pstatus != PSTOPPED &&
529 pstatus != PSIGNALED)
532 p = short2str(pp->p_command);
533 /* get the first word */
534 for (cp = p; *cp && !isspace((unsigned char) *cp); cp++)
538 if ((cp = strrchr(p, '/')) != NULL) /* and it has a path */
539 cp = cp + 1; /* then we want only the last part */
541 cp = p; /* else we get all of it */
543 /* if we find either in the current name, fg it */
544 if (strncmp(ep, cp, epl) == 0 ||
545 strncmp(vp, cp, vpl) == 0) {
548 * If there is a choice, then choose the current process if
549 * available, or the previous process otherwise, or else
550 * anything will do - Robert Webb (robertw@mulga.cs.mu.oz.au).
554 else if (retp == NULL || pp == pprevious)
559 return retp; /* Will be NULL if we didn't find a job */
563 fg_proc_entry(struct process *pp)
573 oGettingInput = GettingInput;
576 ohaderr = haderr; /* we need to ignore setting of haderr due to
577 * process getting stopped by a signal */
578 omark = cleanup_push_mark();
579 if (setexit() == 0) { /* come back here after pjwait */
581 (void) alarm(0); /* No autologout */
582 alrmcatch_disabled = 1;
583 if (!pstart(pp, 1)) {
585 stderror(ERR_BADJOB, pp->p_command, strerror(errno));
589 setalarm(1); /* Autologout back on */
590 cleanup_pop_mark(omark);
593 GettingInput = oGettingInput;
595 disabled_cleanup(&pintr_disabled);
599 xgetpass(const char *prm)
601 static struct strbuf pass; /* = strbuf_INIT; */
604 struct sigaction sa, osa;
606 sa.sa_handler = SIG_IGN;
607 sigemptyset(&sa.sa_mask);
609 (void)sigaction(SIGINT, &sa, &osa);
612 sigaddset(&set, SIGINT);
613 (void)sigprocmask(SIG_UNBLOCK, &set, &oset);
615 cleanup_push(&osa, sigint_cleanup);
616 cleanup_push(&oset, sigprocmask_cleanup);
617 (void) Rawmode(); /* Make sure, cause we want echo off */
618 fd = xopen("/dev/tty", O_RDWR|O_LARGEFILE);
622 cleanup_push(&fd, open_cleanup);
624 xprintf("%s", prm); flush();
629 if (xread(fd, &c, 1) < 1 || c == '\n')
631 strbuf_append1(&pass, c);
633 strbuf_terminate(&pass);
642 extern char *crypt ();
650 * Ask the user for his login password to continue working
651 * On systems that have a shadow password, this will only
652 * work for root, but what can we do?
654 * If we fail to get the password, then we log the user out
669 #if defined(HAVE_AUTH_H) && defined(HAVE_GETAUTHUID)
671 struct authorization *apw;
672 extern char *crypt16 (const char *, const char *);
674 # define XCRYPT(a, b) crypt16(a, b)
676 if ((pw = xgetpwuid(euid)) != NULL && /* effective user passwd */
677 (apw = getauthuid(euid)) != NULL) /* enhanced ultrix passwd */
678 srpp = apw->a_password;
680 #elif defined(HAVE_SHADOW_H)
684 # define XCRYPT(a, b) crypt(a, b)
686 if ((pw = xgetpwuid(euid)) != NULL) { /* effective user passwd */
688 while ((spw = getspnam(pw->pw_name)) == NULL && errno == EINTR) {
689 handle_pending_signals();
692 if (spw != NULL) /* shadowed passwd */
698 #define XCRYPT(a, b) crypt(a, b)
700 #if !defined(__MVS__)
701 if ((pw = xgetpwuid(euid)) != NULL) /* effective user passwd */
702 srpp = pw->pw_passwd;
713 setalarm(0); /* Not for locking any more */
715 for (i = 0; i < 5; i++) {
722 if ((safs = varval(STRafsuser)) != STRNULL)
723 afsname = short2str(safs);
725 if ((afsname = getenv("AFSUSER")) == NULL)
726 afsname = pw->pw_name;
728 pp = xgetpass("Password:");
730 crpp = XCRYPT(pp, srpp);
731 if ((strcmp(crpp, srpp) == 0)
733 || (ka_UserAuthenticateGeneral(KA_USERAUTH_VERSION,
744 (void) memset(pp, 0, strlen(pp));
745 if (GettingInput && !just_signaled) {
754 xprintf(CGETS(22, 2, "\nIncorrect passwd for %s\n"), pw->pw_name);
756 #endif /* NO_CRYPT */
764 xprintf("auto-logout\n");
765 /* Don't leave the tty in raw mode */
769 setcopy(STRlogout, STRautomatic, VAR_READWRITE);
774 GettingInput = FALSE; /* make flush() work to write hist files. Huber*/
786 * Karl Kleinpaste, 21oct1983.
787 * Added precmd(), which checks for the alias
788 * precmd in aliases. If it's there, the alias
789 * is executed as a command. This is done
790 * after mailchk() and just before print-
791 * ing the prompt. Useful for things like printing
792 * one's current directory just before each command.
798 cleanup_push(&pintr_disabled, disabled_cleanup);
799 if (precmd_active) { /* an error must have been caught */
800 aliasrun(2, STRunalias, STRprecmd);
801 xprintf(CGETS(22, 3, "Faulty alias 'precmd' removed.\n"));
805 if (!whyles && adrof1(STRprecmd, &aliases))
806 aliasrun(1, STRprecmd, NULL);
809 cleanup_until(&pintr_disabled);
816 cleanup_push(&pintr_disabled, disabled_cleanup);
817 if (postcmd_active) { /* an error must have been caught */
818 aliasrun(2, STRunalias, STRpostcmd);
819 xprintf(CGETS(22, 3, "Faulty alias 'postcmd' removed.\n"));
823 if (!whyles && adrof1(STRpostcmd, &aliases))
824 aliasrun(1, STRpostcmd, NULL);
827 cleanup_until(&pintr_disabled);
831 * Paul Placeway 11/24/87 Added cwd_cmd by hacking precmd() into
832 * submission... Run every time $cwd is set (after it is set). Useful
833 * for putting your machine and cwd (or anything else) in an xterm title
840 cleanup_push(&pintr_disabled, disabled_cleanup);
841 if (cwdcmd_active) { /* an error must have been caught */
842 aliasrun(2, STRunalias, STRcwdcmd);
843 xprintf(CGETS(22, 4, "Faulty alias 'cwdcmd' removed.\n"));
847 if (!whyles && adrof1(STRcwdcmd, &aliases))
848 aliasrun(1, STRcwdcmd, NULL);
851 cleanup_until(&pintr_disabled);
855 * Joachim Hoenig 07/16/91 Added beep_cmd, run every time tcsh wishes
856 * to beep the terminal bell. Useful for playing nice sounds instead.
862 cleanup_push(&pintr_disabled, disabled_cleanup);
863 if (beepcmd_active) { /* an error must have been caught */
864 aliasrun(2, STRunalias, STRbeepcmd);
865 xprintf(CGETS(22, 5, "Faulty alias 'beepcmd' removed.\n"));
869 if (!whyles && adrof1(STRbeepcmd, &aliases))
870 aliasrun(1, STRbeepcmd, NULL);
873 cleanup_until(&pintr_disabled);
878 * Karl Kleinpaste, 18 Jan 1984.
879 * Added period_cmd(), which executes the alias "periodic" every
880 * $tperiod minutes. Useful for occasional checking of msgs and such.
889 cleanup_push(&pintr_disabled, disabled_cleanup);
890 if (periodic_active) { /* an error must have been caught */
891 aliasrun(2, STRunalias, STRperiodic);
892 xprintf(CGETS(22, 6, "Faulty alias 'periodic' removed.\n"));
896 if (!whyles && adrof1(STRperiodic, &aliases)) {
897 vp = varval(STRtperiod);
899 aliasrun(1, STRperiodic, NULL);
904 if (t - t_period >= interval * 60) {
906 aliasrun(1, STRperiodic, NULL);
911 cleanup_until(&pintr_disabled);
916 * GrP Greg Parker May 2001
917 * Added job_cmd(), which is run every time a job is started or
918 * foregrounded. The command is passed a single argument, the string
919 * used to start the job originally. With precmd, useful for setting
921 * Cloned from cwd_cmd().
927 cleanup_push(&pintr_disabled, disabled_cleanup);
928 if (jobcmd_active) { /* an error must have been caught */
929 aliasrun(2, STRunalias, STRjobcmd);
930 xprintf(CGETS(22, 14, "Faulty alias 'jobcmd' removed.\n"));
934 if (!whyles && adrof1(STRjobcmd, &aliases)) {
935 struct process *pp = pcurrjob; /* put things back after the hook */
936 aliasrun(2, STRjobcmd, args);
941 cleanup_until(&pintr_disabled);
946 * Karl Kleinpaste, 21oct1983.
947 * Set up a one-word alias command, for use for special things.
948 * This code is based on the mainline of process().
951 aliasrun(int cnt, Char *s1, Char *s2)
953 struct wordent w, *new1, *new2; /* for holding alias name */
954 struct command *t = NULL;
962 seterr = NULL; /* don't repeatedly print err msg. */
965 new1 = xcalloc(1, sizeof w);
966 new1->word = Strsave(s1);
968 /* build a lex list with one word. */
969 w.next = w.prev = new1;
970 new1->next = new1->prev = &w;
973 /* build a lex list with two words. */
974 new2 = xcalloc(1, sizeof w);
975 new2->word = Strsave(s2);
976 w.next = new2->prev = new1;
977 new1->next = w.prev = new2;
978 new1->prev = new2->next = &w;
980 cleanup_push(&w, lex_cleanup);
982 /* Save the old status */
983 status = getn(varval(STRstatus));
985 /* expand aliases like process() does. */
987 /* build a syntax tree for the command. */
988 t = syntax(w.next, &w, 0);
989 cleanup_push(t, syntax_cleanup);
994 cleanup_push(&cnt, psavejob_cleanup); /* cnt is used only as a marker */
996 /* catch any errors here */
997 omark = cleanup_push_mark();
999 /* execute the parse tree. */
1001 * From: Michael Schroeder <mlschroe@immd4.informatik.uni-erlangen.de>
1002 * was execute(t, tpgrp);
1004 execute(t, tpgrp > 0 ? tpgrp : -1, NULL, NULL, TRUE);
1005 /* reset the error catcher to the old place */
1006 cleanup_pop_mark(omark);
1011 * Either precmd, or cwdcmd, or periodic had an error. Call it again so
1012 * that it is removed
1020 * XXX: On the other hand, just interrupting them causes an error too.
1021 * So if we hit ^C in the middle of cwdcmd or periodic the alias gets
1022 * removed. We don't want that. Note that we want to remove precmd
1023 * though, cause that could lead into an infinite loop. This should be
1024 * fixed correctly, but then haderr should give us the whole exit
1025 * status not just true or false.
1027 else if (cwdcmd_active)
1029 else if (beepcmd_active)
1031 else if (periodic_active)
1037 /* Restore status */
1038 setv(STRstatus, putn(status), VAR_READWRITE);
1046 unsigned alrm_time = 0, logout_time, lock_time;
1047 time_t cl, nl, sched_dif;
1049 if ((vp = adrof(STRautologout)) != NULL && vp->vec != NULL) {
1050 if ((cp = vp->vec[0]) != 0) {
1051 if ((logout_time = (unsigned) atoi(short2str(cp)) * 60) > 0) {
1054 * Solaris alarm(2) uses a timer based in clock ticks
1055 * internally so it multiplies our value with CLK_TCK...
1056 * Of course that can overflow leading to unexpected
1057 * results, so we clip it here. Grr. Where is that
1060 if (logout_time >= 0x7fffffff / CLK_TCK)
1061 logout_time = 0x7fffffff / CLK_TCK;
1062 #endif /* SOLARIS2 */
1063 alrm_time = logout_time;
1064 alm_fun = auto_logout;
1067 if ((cp = vp->vec[1]) != 0) {
1068 if ((lock_time = (unsigned) atoi(short2str(cp)) * 60) > 0) {
1070 if (alrm_time == 0 || lock_time < alrm_time) {
1071 alrm_time = lock_time;
1072 alm_fun = auto_lock;
1075 else /* lock_time always < alrm_time */
1077 alrm_time -= lock_time;
1081 if ((nl = sched_next()) != -1) {
1083 sched_dif = nl > cl ? nl - cl : 0;
1084 if ((alrm_time == 0) || ((unsigned) sched_dif < alrm_time)) {
1085 alrm_time = ((unsigned) sched_dif) + 1;
1086 alm_fun = sched_run;
1089 alrmcatch_disabled = 0;
1090 (void) alarm(alrm_time); /* Autologout ON */
1093 #undef RMDEBUG /* For now... */
1096 rmstar(struct wordent *cp)
1098 struct wordent *we, *args;
1099 struct wordent *tmp, *del;
1102 static Char STRrmdebug[] = {'r', 'm', 'd', 'e', 'b', 'u', 'g', '\0'};
1104 #endif /* RMDEBUG */
1107 int ask, doit, star = 0, silent = 0;
1109 if (!adrof(STRrmstar))
1112 tag = varval(STRrmdebug);
1113 #endif /* RMDEBUG */
1115 while (*we->word == ';' && we != cp)
1120 xprintf(CGETS(22, 7, "parsing command line\n"));
1121 #endif /* RMDEBUG */
1122 if (!Strcmp(we->word, STRrm)) {
1124 ask = (*args->word != '-');
1125 while (*args->word == '-' && !silent) { /* check options */
1126 for (charac = (args->word + 1); *charac && !silent; charac++)
1127 silent = (*charac == 'i' || *charac == 'f');
1130 ask = (ask || (!ask && !silent));
1132 for (; !star && *args->word != ';'
1133 && args != cp; args = args->next)
1134 if (!Strcmp(args->word, STRstar))
1137 xprintf(CGETS(22, 8,
1138 "Do you really want to delete all files? [n/y] "));
1140 (void) force_read(SHIN, &c, 1);
1142 * Perhaps we should use the yesexpr from the
1145 doit = (strchr(CGETS(22, 14, "Yy"), c) != NULL);
1146 while (c != '\n' && force_read(SHIN, &c, 1) == 1)
1149 /* remove the command instead */
1152 xprintf(CGETS(22, 9,
1153 "skipping deletion of files!\n"));
1154 #endif /* RMDEBUG */
1156 *tmp->word != '\n' &&
1157 *tmp->word != ';' && tmp != cp;) {
1158 tmp->prev->next = tmp->next;
1159 tmp->next->prev = tmp->prev;
1165 if (*tmp->word == ';') {
1166 tmp->prev->next = tmp->next;
1167 tmp->next->prev = tmp->prev;
1180 *we->word != ';' && we != cp;
1183 if (*we->word == ';')
1188 xprintf(CGETS(22, 10, "command line now is:\n"));
1189 for (we = cp->next; we != cp; we = we->next)
1190 xprintf("%S ", we->word);
1192 #endif /* RMDEBUG */
1197 /* Check if command is in continue list
1198 and do a "aliasing" if it exists as a job in background */
1200 #undef CNDEBUG /* For now */
1202 continue_jobs(struct wordent *cp)
1205 struct process *pp, *np;
1206 Char *cmd, *continue_list, *continue_args_list;
1210 static Char STRcndebug[] =
1211 {'c', 'n', 'd', 'e', 'b', 'u', 'g', '\0'};
1212 #endif /* CNDEBUG */
1213 int in_cont_list, in_cont_arg_list;
1217 tag = varval(STRcndebug);
1218 #endif /* CNDEBUG */
1219 continue_list = varval(STRcontinue);
1220 continue_args_list = varval(STRcontinue_args);
1221 if (*continue_list == '\0' && *continue_args_list == '\0')
1225 while (*we->word == ';' && we != cp)
1230 xprintf(CGETS(22, 11, "parsing command line\n"));
1231 #endif /* CNDEBUG */
1233 in_cont_list = inlist(continue_list, cmd);
1234 in_cont_arg_list = inlist(continue_args_list, cmd);
1235 if (in_cont_list || in_cont_arg_list) {
1238 xprintf(CGETS(22, 12, "in one of the lists\n"));
1239 #endif /* CNDEBUG */
1241 for (pp = proclist.p_next; pp; pp = pp->p_next) {
1242 if (prefix(cmd, pp->p_command)) {
1250 insert(we, in_cont_arg_list);
1254 *we->word != ';' && we != cp;
1257 if (*we->word == ';')
1262 xprintf(CGETS(22, 13, "command line now is:\n"));
1263 for (we = cp->next; we != cp; we = we->next)
1264 xprintf("%S ", we->word);
1266 #endif /* CNDEBUG */
1270 /* The actual "aliasing" of for backgrounds() is done here
1271 with the aid of insert_we(). */
1273 insert(struct wordent *pl, int file_args)
1275 struct wordent *now, *last;
1276 Char *cmd, *bcmd, *cp1, *cp2;
1278 Char *upause = STRunderpause;
1279 size_t p_len = Strlen(upause);
1281 cmd_len = Strlen(pl->word);
1282 cmd = xcalloc(1, (cmd_len + 1) * sizeof(Char));
1283 (void) Strcpy(cmd, pl->word);
1284 /* Do insertions at beginning, first replace command word */
1289 now->word = xcalloc(1, 5 * sizeof(Char));
1290 (void) Strcpy(now->word, STRecho);
1292 now = xcalloc(1, sizeof(struct wordent));
1293 now->word = xcalloc(1, 6 * sizeof(Char));
1294 (void) Strcpy(now->word, STRbackqpwd);
1297 for (last = now; *last->word != '\n' && *last->word != ';';
1301 now = xcalloc(1, sizeof(struct wordent));
1302 now->word = xcalloc(1, 2 * sizeof(Char));
1303 (void) Strcpy(now->word, STRgt);
1304 insert_we(now, last->prev);
1306 now = xcalloc(1, sizeof(struct wordent));
1307 now->word = xcalloc(1, 2 * sizeof(Char));
1308 (void) Strcpy(now->word, STRbang);
1309 insert_we(now, last->prev);
1311 now = xcalloc(1, sizeof(struct wordent));
1312 now->word = xcalloc(1, (cmd_len + p_len + 4) * sizeof(Char));
1318 while ((*cp1++ = *cp2++) != '\0')
1322 while ((*cp1++ = *cp2++) != '\0')
1324 insert_we(now, last->prev);
1326 now = xcalloc(1, sizeof(struct wordent));
1327 now->word = xcalloc(1, 2 * sizeof(Char));
1328 (void) Strcpy(now->word, STRsemi);
1329 insert_we(now, last->prev);
1330 bcmd = xcalloc(1, (cmd_len + 2) * sizeof(Char));
1332 Strcpy(bcmd + 1, cmd);
1333 now = xcalloc(1, sizeof(struct wordent));
1335 insert_we(now, last->prev);
1338 struct wordent *del;
1342 now->word = xcalloc(1, (cmd_len + 2) * sizeof(Char));
1344 Strcpy(now->word + 1, cmd);
1345 for (now = now->next;
1346 *now->word != '\n' && *now->word != ';' && now != pl;) {
1347 now->prev->next = now->next;
1348 now->next->prev = now->prev;
1358 insert_we(struct wordent *new, struct wordent *where)
1362 new->next = where->next;
1364 new->next->prev = new;
1368 inlist(Char *list, Char *name)
1379 if (*n == '\0' && (*l == ' ' || *l == '\0'))
1385 while (*l && *l != ' ')
1386 l++; /* skip to blank */
1387 while (*l && *l == ' ')
1388 l++; /* and find first nonblank character */
1395 #endif /* BSDJOBS */
1399 * Implement a small cache for tilde names. This is used primarily
1400 * to expand tilde names to directories, but also
1401 * we can find users from their home directories for the tilde
1402 * prompt, on machines where yp lookup is slow this can be a big win...
1403 * As with any cache this can run out of sync, rehash can sync it again.
1405 static struct tildecache {
1413 static size_t tsize = TILINCR;
1416 tildecompare(const void *xp1, const void *xp2)
1418 const struct tildecache *p1, *p2;
1422 return Strcmp(p1->user, p2->user);
1426 gethomedir(const Char *us)
1430 char **res, **res1, *cp;
1434 pp = xgetpwnam(short2str(us));
1440 /* Don't return if root */
1441 if (pp->pw_dir[0] == '/' && pp->pw_dir[1] == '\0')
1445 return Strsave(str2short(pp->pw_dir));
1448 res = hes_resolve(short2str(us), "filsys");
1451 if ((*res) != NULL) {
1453 * Look at the first token to determine how to interpret
1455 * Yes, strtok is evil (it's not thread-safe), but it's also
1458 cp = strtok(*res, " ");
1459 if (strcmp(cp, "AFS") == 0) {
1460 /* next token is AFS pathname.. */
1461 cp = strtok(NULL, " ");
1463 rp = Strsave(str2short(cp));
1464 } else if (strcmp(cp, "NFS") == 0) {
1466 if ((strtok(NULL, " ")) && /* skip remote pathname */
1467 (strtok(NULL, " ")) && /* skip host */
1468 (strtok(NULL, " ")) && /* skip mode */
1469 (cp = strtok(NULL, " "))) {
1470 rp = Strsave(str2short(cp));
1474 for (res1 = res; *res1; res1++)
1477 /* Don't return if root */
1478 if (rp != NULL && rp[0] == '/' && rp[1] == '\0') {
1490 gettilde(const Char *us)
1492 struct tildecache *bp1, *bp2, *bp;
1495 /* Ignore NIS special names */
1496 if (*us == '+' || *us == '-')
1500 tcache = xmalloc(TILINCR * sizeof(struct tildecache));
1504 for (bp1 = tcache, bp2 = tcache + tlength; bp1 < bp2;) {
1507 bp = bp1 + ((bp2 - bp1) >> 1);
1508 if ((i = *us - *bp->user) == 0 && (i = Strcmp(us, bp->user)) == 0)
1516 * Not in the cache, try to get it from the passwd file
1518 hd = gethomedir(us);
1525 tcache[tlength].user = Strsave(us);
1526 tcache[tlength].home = hd;
1527 tcache[tlength++].hlen = Strlen(hd);
1529 qsort(tcache, tlength, sizeof(struct tildecache), tildecompare);
1531 if (tlength == tsize) {
1533 tcache = xrealloc(tcache, tsize * sizeof(struct tildecache));
1539 * Return the username if the directory path passed contains a
1540 * user's home directory in the tilde cache, otherwise return NULL
1541 * hm points to the place where the path became different.
1542 * Special case: Our own home directory.
1543 * If we are passed a null pointer, then we flush the cache.
1546 getusername(Char **hm)
1552 for (i = 0; i < tlength; i++) {
1553 xfree(tcache[i].home);
1554 xfree(tcache[i].user);
1563 if (((h = varval(STRhome)) != STRNULL) &&
1564 (Strncmp(p, h, j = Strlen(h)) == 0) &&
1565 (p[j] == '/' || p[j] == '\0')) {
1569 for (i = 0; i < tlength; i++)
1570 if ((Strncmp(p, tcache[i].home, (j = tcache[i].hlen)) == 0) &&
1571 (p[j] == '/' || p[j] == '\0')) {
1573 return tcache[i].user;
1580 * set the shell-level var to 1 or apply change to it.
1587 if ((cp = getenv("SHLVL")) != NULL) {
1595 if (adrof(STRshlvl) != NULL)
1597 Unsetenv(STRKSHLVL);
1602 p = Itoa(val, 0, 0);
1603 cleanup_push(p, xfree);
1604 setv(STRshlvl, p, VAR_READWRITE);
1607 tsetenv(STRKSHLVL, p);
1611 setcopy(STRshlvl, STR1, VAR_READWRITE);
1612 tsetenv(STRKSHLVL, STR1);
1618 * Try to recover from a read error
1621 fixio(int fd, int e)
1624 case -1: /* Make sure that the code is reachable */
1629 #endif /* EWOULDBLOCK */
1631 #if defined(POSIX) && defined(EAGAIN)
1632 # if !defined(EWOULDBLOCK) || EWOULDBLOCK != EAGAIN
1635 # endif /* !EWOULDBLOCK || EWOULDBLOCK != EAGAIN */
1636 #endif /* POSIX && EAGAIN */
1642 * Great! we have on suns 3 flavors and 5 names...
1643 * I hope that will cover everything.
1644 * I added some more defines... many systems have different defines.
1645 * Rather than dealing with getting the right includes, we'll just
1646 * cover all the known possibilities here. -- sterling@netcom.com
1649 # define O_NONBLOCK 0
1650 # endif /* O_NONBLOCK */
1653 # endif /* O_NDELAY */
1659 # endif /* _FNBIO */
1662 # endif /* FNONBIO */
1664 # define FNONBLOCK 0
1665 # endif /* FNONBLOCK */
1667 # define _FNONBLOCK 0
1668 # endif /* _FNONBLOCK */
1671 # endif /* FNDELAY */
1674 # endif /* _FNDELAY */
1675 # ifndef FNDLEAY /* Some linux versions have this typo */
1677 # endif /* FNDLEAY */
1678 if ((e = fcntl(fd, F_GETFL, 0)) == -1)
1681 e &= ~(O_NDELAY|O_NONBLOCK|FNBIO|_FNBIO|FNONBIO|FNONBLOCK|_FNONBLOCK|
1682 FNDELAY|_FNDELAY|FNDLEAY); /* whew! */
1683 if (fcntl(fd, F_SETFL, e) == -1)
1687 # endif /* F_SETFL */
1691 if (ioctl(fd, FIONBIO, (ioctl_t) &e) == -1)
1695 # endif /* FIONBIO */
1697 #endif /* FDRETRY */
1712 collate(const Char *a, const Char *b)
1715 #ifdef SHORT_STRINGS
1716 /* This strips the quote bit as a side effect */
1717 char *sa = strsave(short2str(a));
1718 char *sb = strsave(short2str(b));
1720 char *sa = strip(strsave(a));
1721 char *sb = strip(strsave(b));
1722 #endif /* SHORT_STRINGS */
1724 #if defined(NLS) && defined(HAVE_STRCOLL)
1725 errno = 0; /* strcoll sets errno, another brain-damage */
1727 rv = strcoll(sa, sb);
1730 * We should be checking for errno != 0, but some systems
1731 * forget to reset errno to 0. So we only check for the
1732 * only documented valid errno value for strcoll [EINVAL]
1734 if (errno == EINVAL) {
1737 stderror(ERR_SYSTEM, "strcoll", strerror(errno));
1740 rv = strcmp(sa, sb);
1741 #endif /* NLS && HAVE_STRCOLL */
1751 * From: peter@zeus.dialix.oz.au (Peter Wemm)
1752 * If exec() fails look first for a #! [word] [word] ....
1753 * If it is, splice the header into the argument list and retry.
1755 #define HACKBUFSZ 1024 /* Max chars in #! vector */
1757 hashbang(int fd, Char ***vp)
1759 struct blk_buf sarg = BLK_BUF_INIT;
1760 char lbuf[HACKBUFSZ], *p, *ws;
1762 int fw = 0; /* found at least one word */
1765 #endif /* WINNT_NATIVE */
1767 if (xread(fd, lbuf, HACKBUFSZ) <= 0)
1770 ws = 0; /* word started = 0 */
1772 for (p = lbuf; p < &lbuf[HACKBUFSZ]; ) {
1778 #endif /* WINNT_NATIVE */
1779 if (ws) { /* a blank after a word.. save it */
1783 real = hb_subst(ws);
1789 #endif /* WINNT_NATIVE */
1790 bb_append(&sarg, SAVE(ws));
1796 case '\0': /* Whoa!! what the hell happened */
1799 case '\n': /* The end of the line. */
1803 #endif /* WINNT_NATIVE */
1804 ws) { /* terminate the last word */
1807 /* deal with the 1-word case */
1809 real = hb_subst(ws);
1813 #endif /* !WINNT_NATIVE */
1815 bb_append(&sarg, SAVE(ws));
1818 *vp = bb_finish(&sarg);
1825 if (!ws) /* Start a new word? */
1835 #endif /* HASHBANG */
1847 getremotehost(int dest_fd)
1849 const char *host = NULL;
1851 struct sockaddr_storage saddr;
1852 static char hbuf[NI_MAXHOST];
1855 struct sockaddr_in saddr;
1857 socklen_t len = sizeof(saddr);
1860 if (getpeername(SHIN, (struct sockaddr *) &saddr, &len) != -1 &&
1861 (saddr.ss_family == AF_INET6 || saddr.ss_family == AF_INET)) {
1862 int flag = NI_NUMERICHOST;
1864 #ifdef NI_WITHSCOPEID
1865 flag |= NI_WITHSCOPEID;
1867 getnameinfo((struct sockaddr *)&saddr, len, hbuf, sizeof(hbuf),
1871 if (getpeername(SHIN, (struct sockaddr *) &saddr, &len) != -1 &&
1872 saddr.sin_family == AF_INET) {
1874 if ((hp = gethostbyaddr((char *)&saddr.sin_addr, sizeof(struct in_addr),
1879 host = inet_ntoa(saddr.sin_addr);
1882 #ifdef HAVE_STRUCT_UTMP_UT_HOST
1885 char *name = utmphost();
1886 /* Avoid empty names and local X displays */
1887 if (name != NULL && *name != '\0' && *name != ':') {
1888 struct in_addr addr;
1891 /* Look for host:display.screen */
1893 * There is conflict with IPv6 address and X DISPLAY. So,
1894 * we assume there is no IPv6 address in utmp and don't
1897 if ((sptr = strchr(name, ':')) != NULL)
1899 /* Leave IPv4 address as is */
1901 * we use inet_addr here, not inet_aton because many systems
1902 * have not caught up yet.
1904 addr.s_addr = inet_addr(name);
1905 if (addr.s_addr != (unsigned int)~0)
1911 char dbuf[MAXHOSTNAMELEN];
1912 struct addrinfo hints, *res = NULL;
1914 memset(&hints, 0, sizeof(hints));
1915 hints.ai_family = PF_UNSPEC;
1916 hints.ai_socktype = SOCK_STREAM;
1917 hints.ai_flags = AI_PASSIVE | AI_CANONNAME;
1918 if (strlen(name) < utmphostsize())
1920 if (getaddrinfo(name, NULL, &hints, &res) != 0)
1922 } else if (gethostname(dbuf, sizeof(dbuf)) == 0 &&
1923 (dbuf[sizeof(dbuf)-1] = '\0', /*FIXME: ugly*/
1924 (domain = strchr(dbuf, '.')) != NULL)) {
1925 for (s = strchr(name, '.');
1926 s != NULL; s = strchr(s + 1, '.')) {
1927 if (*(s + 1) != '\0' &&
1928 (ptr = strstr(domain, s)) != NULL) {
1931 cbuf = strspl(name, ptr);
1932 if (getaddrinfo(cbuf, NULL, &hints, &res) != 0)
1940 if (res->ai_canonname != NULL) {
1941 strncpy(hbuf, res->ai_canonname, sizeof(hbuf));
1947 if ((hp = gethostbyname(name)) == NULL) {
1948 /* Try again eliminating the trailing domain */
1949 if ((ptr = strchr(name, '.')) != NULL) {
1951 if ((hp = gethostbyname(name)) != NULL)
1968 left = strlen(host);
1972 res = xwrite(dest_fd, host, left);
1983 * From: <lesv@ppvku.ericsson.se> (Lennart Svensson)
1988 struct sigaction sa;
1989 struct strbuf hostname = strbuf_INIT;
1990 int fds[2], wait_options, status;
1991 pid_t pid, wait_res;
1993 sa.sa_handler = SIG_DFL; /* Make sure a zombie is created */
1994 sigemptyset(&sa.sa_mask);
1996 sigaction(SIGCHLD, &sa, NULL);
2002 /* Don't get stuck if the resolver does not work! */
2003 signal(SIGALRM, palarm);
2005 sigaddset(&set, SIGALRM);
2006 (void)sigprocmask(SIG_UNBLOCK, &set, NULL);
2008 getremotehost(fds[1]);
2016 res = xread(fds[0], buf, sizeof(buf));
2019 wait_options = WNOHANG;
2024 strbuf_appendn(&hostname, buf, res);
2029 while ((wait_res = waitpid(pid, &status, wait_options)) == -1
2031 handle_pending_signals();
2032 cleanup_push(&hostname, strbuf_cleanup);
2033 if (wait_res == pid && WIFEXITED(status) && WEXITSTATUS(status) == 0) {
2034 strbuf_terminate(&hostname);
2035 tsetenv(STRREMOTEHOST, str2short(hostname.s));
2037 cleanup_until(&hostname);
2040 /* From: casper@fwi.uva.nl (Casper H.S. Dik), for Solaris 2.3 */
2045 #endif /* REMOTEHOST */
2047 #ifndef WINNT_NATIVE
2049 * indicate if a terminal type is defined in terminfo/termcap
2050 * (by default the current term type). This allows ppl to look
2051 * for a working term type automatically in their login scripts
2052 * when using a terminal known as different things on different
2056 dotermname(Char **v, struct command *c)
2060 * Maximum size of a termcap record. We make it twice as large.
2062 char termcap_buffer[2048];
2065 /* try to find which entry we should be looking for */
2066 termtype = (v[1] == NULL ? getenv("TERM") : short2str(v[1]));
2067 if (termtype == NULL) {
2068 /* no luck - the user didn't provide one and none is
2069 * specified in the environment
2071 setcopy(STRstatus, STR1, VAR_READWRITE);
2076 * we use the termcap function - if we are using terminfo we
2077 * will end up with it's compatibility function
2078 * terminfo/termcap will be initialized with the new
2079 * type but we don't care because tcsh has cached all the things
2082 if (tgetent(termcap_buffer, termtype) == 1) {
2083 xprintf("%s\n", termtype);
2084 setcopy(STRstatus, STR0, VAR_READWRITE);
2086 setcopy(STRstatus, STR1, VAR_READWRITE);
2088 #endif /* WINNT_NATIVE */