![[BACK]](/icons/back.gif){kind=icon}
Return to cmds.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / src / usr.bin / tip|
Return to cmds.c CVS log | Up to [local] / src / usr.bin / tip |
1.1 deraadt 1: /* $NetBSD: cmds.c,v 1.5 1995/09/26 06:02:08 jtc Exp $ */
2:
3: /*
4: * Copyright (c) 1983, 1993
5: * The Regents of the University of California. All rights reserved.
6: *
7: * Redistribution and use in source and binary forms, with or without
8: * modification, are permitted provided that the following conditions
9: * are met:
10: * 1. Redistributions of source code must retain the above copyright
11: * notice, this list of conditions and the following disclaimer.
12: * 2. Redistributions in binary form must reproduce the above copyright
13: * notice, this list of conditions and the following disclaimer in the
14: * documentation and/or other materials provided with the distribution.
15: * 3. All advertising materials mentioning features or use of this software
16: * must display the following acknowledgement:
17: * This product includes software developed by the University of
18: * California, Berkeley and its contributors.
19: * 4. Neither the name of the University nor the names of its contributors
20: * may be used to endorse or promote products derived from this software
21: * without specific prior written permission.
22: *
23: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
24: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
25: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
26: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
27: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
28: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
29: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
30: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
31: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
32: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
33: * SUCH DAMAGE.
34: */
35:
36: #ifndef lint
37: #if 0
38: static char sccsid[] = "@(#)cmds.c 8.1 (Berkeley) 6/6/93";
39: #endif
40: static char rcsid[] = "$NetBSD: cmds.c,v 1.5 1995/09/26 06:02:08 jtc Exp $";
41: #endif /* not lint */
42:
43: #include "tip.h"
44: #include "pathnames.h"
45:
46: /*
47: * tip
48: *
49: * miscellaneous commands
50: */
51:
52: int quant[] = { 60, 60, 24 };
53:
54: char null = '\0';
55: char *sep[] = { "second", "minute", "hour" };
56: static char *argv[10]; /* argument vector for take and put */
57:
58: void timeout(); /* timeout function called on alarm */
59: void stopsnd(); /* SIGINT handler during file transfers */
60: void intcopy(); /* interrupt routine for file transfers */
61:
62: /*
63: * FTP - remote ==> local
64: * get a file from the remote host
65: */
66: getfl(c)
67: char c;
68: {
69: char buf[256], *cp, *expand();
70:
71: putchar(c);
72: /*
73: * get the UNIX receiving file's name
74: */
75: if (prompt("Local file name? ", copyname))
76: return;
77: cp = expand(copyname);
78: if ((sfd = creat(cp, 0666)) < 0) {
79: printf("\r\n%s: cannot creat\r\n", copyname);
80: return;
81: }
82:
83: /*
84: * collect parameters
85: */
86: if (prompt("List command for remote system? ", buf)) {
87: unlink(copyname);
88: return;
89: }
90: transfer(buf, sfd, value(EOFREAD));
91: }
92:
93: /*
94: * Cu-like take command
95: */
96: cu_take(cc)
97: char cc;
98: {
99: int fd, argc;
100: char line[BUFSIZ], *expand(), *cp;
101:
102: if (prompt("[take] ", copyname))
103: return;
104: if ((argc = args(copyname, argv)) < 1 || argc > 2) {
105: printf("usage: <take> from [to]\r\n");
106: return;
107: }
108: if (argc == 1)
109: argv[1] = argv[0];
110: cp = expand(argv[1]);
111: if ((fd = creat(cp, 0666)) < 0) {
112: printf("\r\n%s: cannot create\r\n", argv[1]);
113: return;
114: }
115: sprintf(line, "cat %s;echo \01", argv[0]);
116: transfer(line, fd, "\01");
117: }
118:
119: static jmp_buf intbuf;
120: /*
121: * Bulk transfer routine --
122: * used by getfl(), cu_take(), and pipefile()
123: */
124: transfer(buf, fd, eofchars)
125: char *buf, *eofchars;
126: {
127: register int ct;
128: char c, buffer[BUFSIZ];
129: register char *p = buffer;
130: register int cnt, eof;
131: time_t start;
132: sig_t f;
133: char r;
134:
135: pwrite(FD, buf, size(buf));
136: quit = 0;
137: kill(pid, SIGIOT);
138: read(repdes[0], (char *)&ccc, 1); /* Wait until read process stops */
139:
140: /*
141: * finish command
142: */
143: r = '\r';
144: pwrite(FD, &r, 1);
145: do
146: read(FD, &c, 1);
147: while ((c&0177) != '\n');
148: ioctl(0, TIOCSETC, &defchars);
149:
150: (void) setjmp(intbuf);
151: f = signal(SIGINT, intcopy);
152: start = time(0);
153: for (ct = 0; !quit;) {
154: eof = read(FD, &c, 1) <= 0;
155: c &= 0177;
156: if (quit)
157: continue;
158: if (eof || any(c, eofchars))
159: break;
160: if (c == 0)
161: continue; /* ignore nulls */
162: if (c == '\r')
163: continue;
164: *p++ = c;
165:
166: if (c == '\n' && boolean(value(VERBOSE)))
167: printf("\r%d", ++ct);
168: if ((cnt = (p-buffer)) == number(value(FRAMESIZE))) {
169: if (write(fd, buffer, cnt) != cnt) {
170: printf("\r\nwrite error\r\n");
171: quit = 1;
172: }
173: p = buffer;
174: }
175: }
176: if (cnt = (p-buffer))
177: if (write(fd, buffer, cnt) != cnt)
178: printf("\r\nwrite error\r\n");
179:
180: if (boolean(value(VERBOSE)))
181: prtime(" lines transferred in ", time(0)-start);
182: ioctl(0, TIOCSETC, &tchars);
183: write(fildes[1], (char *)&ccc, 1);
184: signal(SIGINT, f);
185: close(fd);
186: }
187:
188: /*
189: * FTP - remote ==> local process
190: * send remote input to local process via pipe
191: */
192: pipefile()
193: {
194: int cpid, pdes[2];
195: char buf[256];
196: int status, p;
197: extern int errno;
198:
199: if (prompt("Local command? ", buf))
200: return;
201:
202: if (pipe(pdes)) {
203: printf("can't establish pipe\r\n");
204: return;
205: }
206:
207: if ((cpid = fork()) < 0) {
208: printf("can't fork!\r\n");
209: return;
210: } else if (cpid) {
211: if (prompt("List command for remote system? ", buf)) {
212: close(pdes[0]), close(pdes[1]);
213: kill (cpid, SIGKILL);
214: } else {
215: close(pdes[0]);
216: signal(SIGPIPE, intcopy);
217: transfer(buf, pdes[1], value(EOFREAD));
218: signal(SIGPIPE, SIG_DFL);
219: while ((p = wait(&status)) > 0 && p != cpid)
220: ;
221: }
222: } else {
223: register int f;
224:
225: dup2(pdes[0], 0);
226: close(pdes[0]);
227: for (f = 3; f < 20; f++)
228: close(f);
229: execute(buf);
230: printf("can't execl!\r\n");
231: exit(0);
232: }
233: }
234:
235: /*
236: * Interrupt service routine for FTP
237: */
238: void
239: stopsnd()
240: {
241:
242: stop = 1;
243: signal(SIGINT, SIG_IGN);
244: }
245:
246: /*
247: * FTP - local ==> remote
248: * send local file to remote host
249: * terminate transmission with pseudo EOF sequence
250: */
251: sendfile(cc)
252: char cc;
253: {
254: FILE *fd;
255: char *fnamex;
256: char *expand();
257:
258: putchar(cc);
259: /*
260: * get file name
261: */
262: if (prompt("Local file name? ", fname))
263: return;
264:
265: /*
266: * look up file
267: */
268: fnamex = expand(fname);
269: if ((fd = fopen(fnamex, "r")) == NULL) {
270: printf("%s: cannot open\r\n", fname);
271: return;
272: }
273: transmit(fd, value(EOFWRITE), NULL);
274: if (!boolean(value(ECHOCHECK))) {
275: struct sgttyb buf;
276:
277: ioctl(FD, TIOCGETP, &buf); /* this does a */
278: ioctl(FD, TIOCSETP, &buf); /* wflushtty */
279: }
280: }
281:
282: /*
283: * Bulk transfer routine to remote host --
284: * used by sendfile() and cu_put()
285: */
286: transmit(fd, eofchars, command)
287: FILE *fd;
288: char *eofchars, *command;
289: {
290: char *pc, lastc;
291: int c, ccount, lcount;
292: time_t start_t, stop_t;
293: sig_t f;
294:
295: kill(pid, SIGIOT); /* put TIPOUT into a wait state */
296: stop = 0;
297: f = signal(SIGINT, stopsnd);
298: ioctl(0, TIOCSETC, &defchars);
299: read(repdes[0], (char *)&ccc, 1);
300: if (command != NULL) {
301: for (pc = command; *pc; pc++)
302: send(*pc);
303: if (boolean(value(ECHOCHECK)))
304: read(FD, (char *)&c, 1); /* trailing \n */
305: else {
306: struct sgttyb buf;
307:
308: ioctl(FD, TIOCGETP, &buf); /* this does a */
309: ioctl(FD, TIOCSETP, &buf); /* wflushtty */
310: sleep(5); /* wait for remote stty to take effect */
311: }
312: }
313: lcount = 0;
314: lastc = '\0';
315: start_t = time(0);
316: while (1) {
317: ccount = 0;
318: do {
319: c = getc(fd);
320: if (stop)
321: goto out;
322: if (c == EOF)
323: goto out;
324: if (c == 0177 && !boolean(value(RAWFTP)))
325: continue;
326: lastc = c;
327: if (c < 040) {
328: if (c == '\n') {
329: if (!boolean(value(RAWFTP)))
330: c = '\r';
331: }
332: else if (c == '\t') {
333: if (!boolean(value(RAWFTP))) {
334: if (boolean(value(TABEXPAND))) {
335: send(' ');
336: while ((++ccount % 8) != 0)
337: send(' ');
338: continue;
339: }
340: }
341: } else
342: if (!boolean(value(RAWFTP)))
343: continue;
344: }
345: send(c);
346: } while (c != '\r' && !boolean(value(RAWFTP)));
347: if (boolean(value(VERBOSE)))
348: printf("\r%d", ++lcount);
349: if (boolean(value(ECHOCHECK))) {
350: timedout = 0;
351: alarm((long)value(ETIMEOUT));
352: do { /* wait for prompt */
353: read(FD, (char *)&c, 1);
354: if (timedout || stop) {
355: if (timedout)
356: printf("\r\ntimed out at eol\r\n");
357: alarm(0);
358: goto out;
359: }
360: } while ((c&0177) != character(value(PROMPT)));
361: alarm(0);
362: }
363: }
364: out:
365: if (lastc != '\n' && !boolean(value(RAWFTP)))
366: send('\r');
367: if (eofchars) {
368: for (pc = eofchars; *pc; pc++)
369: send(*pc);
370: }
371: stop_t = time(0);
372: fclose(fd);
373: signal(SIGINT, f);
374: if (boolean(value(VERBOSE)))
375: if (boolean(value(RAWFTP)))
376: prtime(" chars transferred in ", stop_t-start_t);
377: else
378: prtime(" lines transferred in ", stop_t-start_t);
379: write(fildes[1], (char *)&ccc, 1);
380: ioctl(0, TIOCSETC, &tchars);
381: }
382:
383: /*
384: * Cu-like put command
385: */
386: cu_put(cc)
387: char cc;
388: {
389: FILE *fd;
390: char line[BUFSIZ];
391: int argc;
392: char *expand();
393: char *copynamex;
394:
395: if (prompt("[put] ", copyname))
396: return;
397: if ((argc = args(copyname, argv)) < 1 || argc > 2) {
398: printf("usage: <put> from [to]\r\n");
399: return;
400: }
401: if (argc == 1)
402: argv[1] = argv[0];
403: copynamex = expand(argv[0]);
404: if ((fd = fopen(copynamex, "r")) == NULL) {
405: printf("%s: cannot open\r\n", copynamex);
406: return;
407: }
408: if (boolean(value(ECHOCHECK)))
409: sprintf(line, "cat>%s\r", argv[1]);
410: else
411: sprintf(line, "stty -echo;cat>%s;stty echo\r", argv[1]);
412: transmit(fd, "\04", line);
413: }
414:
415: /*
416: * FTP - send single character
417: * wait for echo & handle timeout
418: */
419: send(c)
420: char c;
421: {
422: char cc;
423: int retry = 0;
424:
425: cc = c;
426: pwrite(FD, &cc, 1);
427: #ifdef notdef
428: if (number(value(CDELAY)) > 0 && c != '\r')
429: nap(number(value(CDELAY)));
430: #endif
431: if (!boolean(value(ECHOCHECK))) {
432: #ifdef notdef
433: if (number(value(LDELAY)) > 0 && c == '\r')
434: nap(number(value(LDELAY)));
435: #endif
436: return;
437: }
438: tryagain:
439: timedout = 0;
440: alarm((long)value(ETIMEOUT));
441: read(FD, &cc, 1);
442: alarm(0);
443: if (timedout) {
444: printf("\r\ntimeout error (%s)\r\n", ctrl(c));
445: if (retry++ > 3)
446: return;
447: pwrite(FD, &null, 1); /* poke it */
448: goto tryagain;
449: }
450: }
451:
452: void
453: timeout()
454: {
455: signal(SIGALRM, timeout);
456: timedout = 1;
457: }
458:
459: /*
460: * Stolen from consh() -- puts a remote file on the output of a local command.
461: * Identical to consh() except for where stdout goes.
462: */
463: pipeout(c)
464: {
465: char buf[256];
466: int cpid, status, p;
467: time_t start;
468:
469: putchar(c);
470: if (prompt("Local command? ", buf))
471: return;
472: kill(pid, SIGIOT); /* put TIPOUT into a wait state */
473: signal(SIGINT, SIG_IGN);
474: signal(SIGQUIT, SIG_IGN);
475: ioctl(0, TIOCSETC, &defchars);
476: read(repdes[0], (char *)&ccc, 1);
477: /*
478: * Set up file descriptors in the child and
479: * let it go...
480: */
481: if ((cpid = fork()) < 0)
482: printf("can't fork!\r\n");
483: else if (cpid) {
484: start = time(0);
485: while ((p = wait(&status)) > 0 && p != cpid)
486: ;
487: } else {
488: register int i;
489:
490: dup2(FD, 1);
491: for (i = 3; i < 20; i++)
492: close(i);
493: signal(SIGINT, SIG_DFL);
494: signal(SIGQUIT, SIG_DFL);
495: execute(buf);
496: printf("can't find `%s'\r\n", buf);
497: exit(0);
498: }
499: if (boolean(value(VERBOSE)))
500: prtime("away for ", time(0)-start);
501: write(fildes[1], (char *)&ccc, 1);
502: ioctl(0, TIOCSETC, &tchars);
503: signal(SIGINT, SIG_DFL);
504: signal(SIGQUIT, SIG_DFL);
505: }
506:
507: #ifdef CONNECT
508: /*
509: * Fork a program with:
510: * 0 <-> remote tty in
511: * 1 <-> remote tty out
512: * 2 <-> local tty out
513: */
514: consh(c)
515: {
516: char buf[256];
517: int cpid, status, p;
518: time_t start;
519:
520: putchar(c);
521: if (prompt("Local command? ", buf))
522: return;
523: kill(pid, SIGIOT); /* put TIPOUT into a wait state */
524: signal(SIGINT, SIG_IGN);
525: signal(SIGQUIT, SIG_IGN);
526: ioctl(0, TIOCSETC, &defchars);
527: read(repdes[0], (char *)&ccc, 1);
528: /*
529: * Set up file descriptors in the child and
530: * let it go...
531: */
532: if ((cpid = fork()) < 0)
533: printf("can't fork!\r\n");
534: else if (cpid) {
535: start = time(0);
536: while ((p = wait(&status)) > 0 && p != cpid)
537: ;
538: } else {
539: register int i;
540:
541: dup2(FD, 0);
542: dup2(3, 1);
543: for (i = 3; i < 20; i++)
544: close(i);
545: signal(SIGINT, SIG_DFL);
546: signal(SIGQUIT, SIG_DFL);
547: execute(buf);
548: printf("can't find `%s'\r\n", buf);
549: exit(0);
550: }
551: if (boolean(value(VERBOSE)))
552: prtime("away for ", time(0)-start);
553: write(fildes[1], (char *)&ccc, 1);
554: ioctl(0, TIOCSETC, &tchars);
555: signal(SIGINT, SIG_DFL);
556: signal(SIGQUIT, SIG_DFL);
557: }
558: #endif
559:
560: /*
561: * Escape to local shell
562: */
563: shell()
564: {
565: int shpid, status;
566: extern char **environ;
567: char *cp;
568:
569: printf("[sh]\r\n");
570: signal(SIGINT, SIG_IGN);
571: signal(SIGQUIT, SIG_IGN);
572: unraw();
573: if (shpid = fork()) {
574: while (shpid != wait(&status));
575: raw();
576: printf("\r\n!\r\n");
577: signal(SIGINT, SIG_DFL);
578: signal(SIGQUIT, SIG_DFL);
579: return;
580: } else {
581: signal(SIGQUIT, SIG_DFL);
582: signal(SIGINT, SIG_DFL);
583: if ((cp = rindex(value(SHELL), '/')) == NULL)
584: cp = value(SHELL);
585: else
586: cp++;
587: shell_uid();
588: execl(value(SHELL), cp, 0);
589: printf("\r\ncan't execl!\r\n");
590: exit(1);
591: }
592: }
593:
594: /*
595: * TIPIN portion of scripting
596: * initiate the conversation with TIPOUT
597: */
598: setscript()
599: {
600: char c;
601: /*
602: * enable TIPOUT side for dialogue
603: */
604: kill(pid, SIGEMT);
605: if (boolean(value(SCRIPT)))
606: write(fildes[1], value(RECORD), size(value(RECORD)));
607: write(fildes[1], "\n", 1);
608: /*
609: * wait for TIPOUT to finish
610: */
611: read(repdes[0], &c, 1);
612: if (c == 'n')
613: printf("can't create %s\r\n", value(RECORD));
614: }
615:
616: /*
617: * Change current working directory of
618: * local portion of tip
619: */
620: chdirectory()
621: {
622: char dirname[80];
623: register char *cp = dirname;
624:
625: if (prompt("[cd] ", dirname)) {
626: if (stoprompt)
627: return;
628: cp = value(HOME);
629: }
630: if (chdir(cp) < 0)
631: printf("%s: bad directory\r\n", cp);
632: printf("!\r\n");
633: }
634:
635: tipabort(msg)
636: char *msg;
637: {
638:
639: kill(pid, SIGTERM);
640: disconnect(msg);
641: if (msg != NOSTR)
642: printf("\r\n%s", msg);
643: printf("\r\n[EOT]\r\n");
644: daemon_uid();
645: (void)uu_unlock(uucplock);
646: unraw();
647: exit(0);
648: }
649:
650: finish()
651: {
652: char *dismsg;
653:
654: if ((dismsg = value(DISCONNECT)) != NOSTR) {
655: write(FD, dismsg, strlen(dismsg));
656: sleep(5);
657: }
658: tipabort(NOSTR);
659: }
660:
661: void
662: intcopy()
663: {
664: raw();
665: quit = 1;
666: longjmp(intbuf, 1);
667: }
668:
669: execute(s)
670: char *s;
671: {
672: register char *cp;
673:
674: if ((cp = rindex(value(SHELL), '/')) == NULL)
675: cp = value(SHELL);
676: else
677: cp++;
678: shell_uid();
679: execl(value(SHELL), cp, "-c", s, 0);
680: }
681:
682: args(buf, a)
683: char *buf, *a[];
684: {
685: register char *p = buf, *start;
686: register char **parg = a;
687: register int n = 0;
688:
689: do {
690: while (*p && (*p == ' ' || *p == '\t'))
691: p++;
692: start = p;
693: if (*p)
694: *parg = p;
695: while (*p && (*p != ' ' && *p != '\t'))
696: p++;
697: if (p != start)
698: parg++, n++;
699: if (*p)
700: *p++ = '\0';
701: } while (*p);
702:
703: return(n);
704: }
705:
706: prtime(s, a)
707: char *s;
708: time_t a;
709: {
710: register i;
711: int nums[3];
712:
713: for (i = 0; i < 3; i++) {
714: nums[i] = (int)(a % quant[i]);
715: a /= quant[i];
716: }
717: printf("%s", s);
718: while (--i >= 0)
719: if (nums[i] || i == 0 && nums[1] == 0 && nums[2] == 0)
720: printf("%d %s%c ", nums[i], sep[i],
721: nums[i] == 1 ? '\0' : 's');
722: printf("\r\n!\r\n");
723: }
724:
725: variable()
726: {
727: char buf[256];
728:
729: if (prompt("[set] ", buf))
730: return;
731: vlex(buf);
732: if (vtable[BEAUTIFY].v_access&CHANGED) {
733: vtable[BEAUTIFY].v_access &= ~CHANGED;
734: kill(pid, SIGSYS);
735: }
736: if (vtable[SCRIPT].v_access&CHANGED) {
737: vtable[SCRIPT].v_access &= ~CHANGED;
738: setscript();
739: /*
740: * So that "set record=blah script" doesn't
741: * cause two transactions to occur.
742: */
743: if (vtable[RECORD].v_access&CHANGED)
744: vtable[RECORD].v_access &= ~CHANGED;
745: }
746: if (vtable[RECORD].v_access&CHANGED) {
747: vtable[RECORD].v_access &= ~CHANGED;
748: if (boolean(value(SCRIPT)))
749: setscript();
750: }
751: if (vtable[TAND].v_access&CHANGED) {
752: vtable[TAND].v_access &= ~CHANGED;
753: if (boolean(value(TAND)))
754: tandem("on");
755: else
756: tandem("off");
757: }
758: if (vtable[LECHO].v_access&CHANGED) {
759: vtable[LECHO].v_access &= ~CHANGED;
760: HD = boolean(value(LECHO));
761: }
762: if (vtable[PARITY].v_access&CHANGED) {
763: vtable[PARITY].v_access &= ~CHANGED;
764: setparity();
765: }
766: }
767:
768: /*
769: * Turn tandem mode on or off for remote tty.
770: */
771: tandem(option)
772: char *option;
773: {
774: struct sgttyb rmtty;
775:
776: ioctl(FD, TIOCGETP, &rmtty);
777: if (strcmp(option,"on") == 0) {
778: rmtty.sg_flags |= TANDEM;
779: arg.sg_flags |= TANDEM;
780: } else {
781: rmtty.sg_flags &= ~TANDEM;
782: arg.sg_flags &= ~TANDEM;
783: }
784: ioctl(FD, TIOCSETP, &rmtty);
785: ioctl(0, TIOCSETP, &arg);
786: }
787:
788: /*
789: * Send a break.
790: */
791: genbrk()
792: {
793:
794: ioctl(FD, TIOCSBRK, NULL);
795: sleep(1);
796: ioctl(FD, TIOCCBRK, NULL);
797: }
798:
799: /*
800: * Suspend tip
801: */
802: suspend(c)
803: char c;
804: {
805:
806: unraw();
807: kill(c == CTRL('y') ? getpid() : 0, SIGTSTP);
808: raw();
809: }
810:
811: /*
812: * expand a file name if it includes shell meta characters
813: */
814:
815: char *
816: expand(name)
817: char name[];
818: {
819: static char xname[BUFSIZ];
820: char cmdbuf[BUFSIZ];
821: register int pid, l, rc;
822: register char *cp, *Shell;
823: int s, pivec[2], (*sigint)();
824:
825: if (!anyof(name, "~{[*?$`'\"\\"))
826: return(name);
827: /* sigint = signal(SIGINT, SIG_IGN); */
828: if (pipe(pivec) < 0) {
829: perror("pipe");
830: /* signal(SIGINT, sigint) */
831: return(name);
832: }
833: sprintf(cmdbuf, "echo %s", name);
834: if ((pid = vfork()) == 0) {
835: Shell = value(SHELL);
836: if (Shell == NOSTR)
837: Shell = _PATH_BSHELL;
838: close(pivec[0]);
839: close(1);
840: dup(pivec[1]);
841: close(pivec[1]);
842: close(2);
843: shell_uid();
844: execl(Shell, Shell, "-c", cmdbuf, 0);
845: _exit(1);
846: }
847: if (pid == -1) {
848: perror("fork");
849: close(pivec[0]);
850: close(pivec[1]);
851: return(NOSTR);
852: }
853: close(pivec[1]);
854: l = read(pivec[0], xname, BUFSIZ);
855: close(pivec[0]);
856: while (wait(&s) != pid);
857: ;
858: s &= 0377;
859: if (s != 0 && s != SIGPIPE) {
860: fprintf(stderr, "\"Echo\" failed\n");
861: return(NOSTR);
862: }
863: if (l < 0) {
864: perror("read");
865: return(NOSTR);
866: }
867: if (l == 0) {
868: fprintf(stderr, "\"%s\": No match\n", name);
869: return(NOSTR);
870: }
871: if (l == BUFSIZ) {
872: fprintf(stderr, "Buffer overflow expanding \"%s\"\n", name);
873: return(NOSTR);
874: }
875: xname[l] = 0;
876: for (cp = &xname[l-1]; *cp == '\n' && cp > xname; cp--)
877: ;
878: *++cp = '\0';
879: return(xname);
880: }
881:
882: /*
883: * Are any of the characters in the two strings the same?
884: */
885:
886: anyof(s1, s2)
887: register char *s1, *s2;
888: {
889: register int c;
890:
891: while (c = *s1++)
892: if (any(c, s2))
893: return(1);
894: return(0);
895: }