Fix prototype for signal handlers
[dragonfly.git] / usr.bin / tip / tip / cmds.c
1 /*
2  * Copyright (c) 1983, 1993
3  *      The Regents of the University of California.  All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  * 3. All advertising materials mentioning features or use of this software
14  *    must display the following acknowledgement:
15  *      This product includes software developed by the University of
16  *      California, Berkeley and its contributors.
17  * 4. 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.
20  *
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
31  * SUCH DAMAGE.
32  *
33  * @(#)cmds.c   8.1 (Berkeley) 6/6/93
34  * $FreeBSD: src/usr.bin/tip/tip/cmds.c,v 1.11.2.2 2000/07/01 12:24:23 ps Exp $
35  * $DragonFly: src/usr.bin/tip/tip/cmds.c,v 1.4 2004/08/19 23:26:12 joerg Exp $
36  */
37
38 #include "tipconf.h"
39 #include "tip.h"
40 #include "pathnames.h"
41
42 #include <sys/types.h>
43 #include <sys/wait.h>
44 #include <err.h>
45 #include <libutil.h>
46 #include <stdio.h>
47 #include <unistd.h>
48
49 /*
50  * tip
51  *
52  * miscellaneous commands
53  */
54
55 int     quant[] = { 60, 60, 24 };
56
57 char    null = '\0';
58 char    *sep[] = { "second", "minute", "hour" };
59 static char *argv[10];          /* argument vector for take and put */
60
61 void            timeout(int);           /* timeout function called on alarm */
62 static void     stopsnd(int);           /* SIGINT handler during file transfers */
63 static void     intcopy();              /* interrupt routine for file transfers */
64
65 void suspend(char);
66 void genbrk(void);
67 void variable(void);
68 void finish(void);
69 void tipabort(char *);
70 void chdirectory(void);
71 void shell(void);
72 void cu_put(char);
73 void sendfile(char);
74 void pipefile(void);
75 void cu_take(char);
76 void getfl(char);
77
78 static int anyof(char *, char *);
79 static void tandem(char *);
80 static void prtime(char *, time_t);
81 static int args(char *, char **, int);
82 static void execute(char *);
83 static void send(char);
84 static void transmit(FILE *, char *, char *);
85 static void transfer(char *, int, char *);
86 static void xfer(char *, int, char *);
87
88 void
89 usedefchars (void)
90 {
91 #if HAVE_TERMIOS
92         int cnt;
93         struct termios ttermios;
94         ttermios = ctermios;
95         for (cnt = 0; cnt < NCCS; cnt++)
96                 ttermios.c_cc [cnt] = otermios.c_cc [cnt];
97         tcsetattr (0, TCSANOW, &ttermios);
98 #else
99         ioctl(0, TIOCSETC, &defchars);
100 #endif
101 }
102
103 void
104 usetchars (void)
105 {
106 #if HAVE_TERMIOS
107         tcsetattr (0, TCSANOW, &ctermios);
108 #else
109         ioctl(0, TIOCSETC, &tchars);
110 #endif
111 }
112
113 void
114 flush_remote (void)
115 {
116 #ifdef TIOCFLUSH
117         int cmd = 0;
118         ioctl (FD, TIOCFLUSH, &cmd);
119 #else
120         struct sgttyb buf;
121         ioctl (FD, TIOCGETP, &buf);     /* this does a */
122         ioctl (FD, TIOCSETP, &buf);     /*   wflushtty */
123 #endif
124 }
125
126 /*
127  * FTP - remote ==> local
128  *  get a file from the remote host
129  */
130 void
131 getfl(char c)
132 {
133         char buf[256], *cp, *expand();
134
135         putchar(c);
136         /*
137          * get the UNIX receiving file's name
138          */
139         if (prompt("Local file name? ", copyname, sizeof(copyname)))
140                 return;
141         cp = expand(copyname);
142         if ((sfd = creat(cp, 0666)) < 0) {
143                 printf("\r\n%s: cannot creat\r\n", copyname);
144                 return;
145         }
146
147         /*
148          * collect parameters
149          */
150         if (prompt("List command for remote system? ", buf, sizeof(buf))) {
151                 unlink(copyname);
152                 return;
153         }
154         transfer(buf, sfd, value(EOFREAD));
155 }
156
157 /*
158  * Cu-like take command
159  */
160 void
161 cu_take(char cc)
162 {
163         int fd, argc;
164         char line[BUFSIZ], *expand(), *cp;
165
166         if (prompt("[take] ", copyname, sizeof(copyname)))
167                 return;
168         if ((argc = args(copyname, argv, sizeof(argv)/sizeof(argv[0]))) < 1 || argc > 2) {
169                 printf("usage: <take> from [to]\r\n");
170                 return;
171         }
172         if (argc == 1)
173                 argv[1] = argv[0];
174         cp = expand(argv[1]);
175         if ((fd = creat(cp, 0666)) < 0) {
176                 printf("\r\n%s: cannot create\r\n", argv[1]);
177                 return;
178         }
179         (void)snprintf(line, sizeof(line), "cat %s ; echo \"\" ; echo ___tip_end_of_file_marker___", argv[0]);
180         xfer(line, fd, "\n___tip_end_of_file_marker___\n");
181 }
182
183 static jmp_buf intbuf;
184
185 static void
186 xfer(char *buf, int fd, char *eofchars)
187 {
188         int ct;
189         char c, *match;
190         int cnt, eof, v;
191         time_t start;
192         sig_t f;
193         char r;
194         FILE *ff;
195
196         v = boolean(value(VERBOSE));
197
198         if ((ff = fdopen (fd, "w")) == NULL) {
199                 warn("file open");
200                 return;
201         }
202         if ((cnt = number(value(FRAMESIZE))) != BUFSIZ)
203                 if (setvbuf(ff, NULL, _IOFBF, cnt) != 0) {
204                         warn("file allocation");
205                         (void)fclose(ff);
206                         return;
207                 }
208
209         xpwrite(FD, buf, size(buf));
210         quit = 0;
211         kill(pid, SIGIOT);
212         read(repdes[0], (char *)&ccc, 1);  /* Wait until read process stops */
213
214         /*
215          * finish command
216          */
217         r = '\r';
218         xpwrite(FD, &r, 1);
219         do
220                 read(FD, &c, 1);
221         while ((c&0177) != '\n');
222
223         usedefchars ();
224
225         (void) setjmp(intbuf);
226         f = signal(SIGINT, intcopy);
227         start = time(0);
228         match = eofchars;
229         for (ct = 0; !quit;) {
230                 eof = read(FD, &c, 1) <= 0;
231                 c &= 0177;
232                 if (quit)
233                         continue;
234                 if (eof)
235                         break;
236                 if (c == 0)
237                         continue;       /* ignore nulls */
238                 if (c == '\r')
239                         continue;
240                 if (c != *match && match > eofchars) {
241                         register char *p = eofchars;
242                         while (p < match) {
243                                 if (*p == '\n'&& v)
244                                         (void)printf("\r%d", ++ct);
245                                 fputc(*p++, ff);
246                         }
247                         match = eofchars;
248                 }
249                 if (c == *match) {
250                         if (*++match == '\0')
251                                 break;
252                 } else {
253                         if (c == '\n' && v)
254                                 (void)printf("\r%d", ++ct);
255                         fputc(c, ff);
256                 }
257         }
258         if (v)
259                 prtime(" lines transferred in ", time(0)-start);
260         usetchars ();
261         write(fildes[1], (char *)&ccc, 1);
262         signal(SIGINT, f);
263         (void)fclose(ff);
264 }
265
266 /*
267  * Bulk transfer routine --
268  *  used by getfl(), cu_take(), and pipefile()
269  */
270 static void
271 transfer(char *buf, int fd, char *eofchars)
272 {
273         register int ct;
274         char c;
275         register int cnt, eof, v;
276         time_t start;
277         sig_t f;
278         char r;
279         FILE *ff;
280
281         v = boolean(value(VERBOSE));
282
283         if ((ff = fdopen (fd, "w")) == NULL) {
284                 warn("file open");
285                 return;
286         }
287         if ((cnt = number(value(FRAMESIZE))) != BUFSIZ)
288                 if (setvbuf(ff, NULL, _IOFBF, cnt) != 0) {
289                         warn("file allocation");
290                         (void)fclose(ff);
291                         return;
292                 }
293
294         xpwrite(FD, buf, size(buf));
295         quit = 0;
296         kill(pid, SIGIOT);
297         read(repdes[0], (char *)&ccc, 1);  /* Wait until read process stops */
298
299         /*
300          * finish command
301          */
302         r = '\r';
303         xpwrite(FD, &r, 1);
304         do
305                 read(FD, &c, 1);
306         while ((c&0177) != '\n');
307         usedefchars ();
308         (void) setjmp(intbuf);
309         f = signal(SIGINT, intcopy);
310         start = time(0);
311         for (ct = 0; !quit;) {
312                 eof = read(FD, &c, 1) <= 0;
313                 c &= 0177;
314                 if (quit)
315                         continue;
316                 if (eof || any(c, eofchars))
317                         break;
318                 if (c == 0)
319                         continue;       /* ignore nulls */
320                 if (c == '\r')
321                         continue;
322                 if (c == '\n' && v)
323                         printf("\r%d", ++ct);
324                 fputc(c, ff);
325         }
326         if (v)
327                 prtime(" lines transferred in ", time(0)-start);
328         usetchars ();
329         write(fildes[1], (char *)&ccc, 1);
330         signal(SIGINT, f);
331         (void)fclose(ff);
332 }
333
334 /*
335  * FTP - remote ==> local process
336  *   send remote input to local process via pipe
337  */
338 void
339 pipefile(void)
340 {
341         int cpid, pdes[2];
342         char buf[256];
343         int status, p;
344
345         if (prompt("Local command? ", buf, sizeof(buf)))
346                 return;
347
348         if (pipe(pdes)) {
349                 printf("can't establish pipe\r\n");
350                 return;
351         }
352
353         if ((cpid = fork()) < 0) {
354                 printf("can't fork!\r\n");
355                 return;
356         } else if (cpid) {
357                 if (prompt("List command for remote system? ", buf, sizeof(buf))) {
358                         close(pdes[0]), close(pdes[1]);
359                         kill (cpid, SIGKILL);
360                 } else {
361                         close(pdes[0]);
362                         signal(SIGPIPE, intcopy);
363                         transfer(buf, pdes[1], value(EOFREAD));
364                         signal(SIGPIPE, SIG_DFL);
365                         while ((p = wait(&status)) > 0 && p != cpid)
366                                 ;
367                 }
368         } else {
369                 register int f;
370
371                 dup2(pdes[0], 0);
372                 close(pdes[0]);
373                 for (f = 3; f < 20; f++)
374                         close(f);
375                 execute(buf);
376                 printf("can't execl!\r\n");
377                 exit(0);
378         }
379 }
380
381 /*
382  * Interrupt service routine for FTP
383  */
384 void
385 stopsnd(int __dummy)
386 {
387
388         stop = 1;
389         signal(SIGINT, SIG_IGN);
390 }
391
392 /*
393  * FTP - local ==> remote
394  *  send local file to remote host
395  *  terminate transmission with pseudo EOF sequence
396  */
397 void
398 sendfile(char cc)
399 {
400         FILE *fd;
401         char *fnamex;
402         char *expand();
403
404         putchar(cc);
405         /*
406          * get file name
407          */
408         if (prompt("Local file name? ", fname, sizeof(fname)))
409                 return;
410
411         /*
412          * look up file
413          */
414         fnamex = expand(fname);
415         if ((fd = fopen(fnamex, "r")) == NULL) {
416                 printf("%s: cannot open\r\n", fname);
417                 return;
418         }
419         transmit(fd, value(EOFWRITE), NULL);
420         if (!boolean(value(ECHOCHECK))) {
421                 flush_remote ();
422         }
423 }
424
425 /*
426  * Bulk transfer routine to remote host --
427  *   used by sendfile() and cu_put()
428  */
429 static void
430 transmit(FILE *fd, char *eofchars, char *command)
431 {
432         char *pc, lastc;
433         int c, ccount, lcount;
434         time_t start_t, stop_t;
435         sig_t f;
436
437         kill(pid, SIGIOT);      /* put TIPOUT into a wait state */
438         stop = 0;
439         f = signal(SIGINT, stopsnd);
440         usedefchars ();
441         read(repdes[0], (char *)&ccc, 1);
442         if (command != NULL) {
443                 for (pc = command; *pc; pc++)
444                         send(*pc);
445                 if (boolean(value(ECHOCHECK)))
446                         read(FD, (char *)&c, 1);        /* trailing \n */
447                 else {
448                         flush_remote ();
449                         sleep(5); /* wait for remote stty to take effect */
450                 }
451         }
452         lcount = 0;
453         lastc = '\0';
454         start_t = time(0);
455         while (1) {
456                 ccount = 0;
457                 do {
458                         c = getc(fd);
459                         if (stop)
460                                 goto out;
461                         if (c == EOF)
462                                 goto out;
463                         if (c == 0177 && !boolean(value(RAWFTP)))
464                                 continue;
465                         lastc = c;
466                         if (c < 040) {
467                                 if (c == '\n') {
468                                         if (!boolean(value(RAWFTP)))
469                                                 c = '\r';
470                                 }
471                                 else if (c == '\t') {
472                                         if (!boolean(value(RAWFTP))) {
473                                                 if (boolean(value(TABEXPAND))) {
474                                                         send(' ');
475                                                         while ((++ccount % 8) != 0)
476                                                                 send(' ');
477                                                         continue;
478                                                 }
479                                         }
480                                 } else
481                                         if (!boolean(value(RAWFTP)))
482                                                 continue;
483                         }
484                         send(c);
485                 } while (c != '\r' && !boolean(value(RAWFTP)));
486                 if (boolean(value(VERBOSE)))
487                         printf("\r%d", ++lcount);
488                 if (boolean(value(ECHOCHECK))) {
489                         timedout = 0;
490                         alarm(number(value(ETIMEOUT)));
491                         do {    /* wait for prompt */
492                                 read(FD, (char *)&c, 1);
493                                 if (timedout || stop) {
494                                         if (timedout)
495                                                 printf("\r\ntimed out at eol\r\n");
496                                         alarm(0);
497                                         goto out;
498                                 }
499                         } while ((c&0177) != character(value(PROMPT)));
500                         alarm(0);
501                 }
502         }
503 out:
504         if (lastc != '\n' && !boolean(value(RAWFTP)))
505                 send('\r');
506         for (pc = eofchars; pc && *pc; pc++)
507                 send(*pc);
508         stop_t = time(0);
509         fclose(fd);
510         signal(SIGINT, f);
511         if (boolean(value(VERBOSE)))
512                 if (boolean(value(RAWFTP)))
513                         prtime(" chars transferred in ", stop_t-start_t);
514                 else
515                         prtime(" lines transferred in ", stop_t-start_t);
516         write(fildes[1], (char *)&ccc, 1);
517         usetchars ();
518 }
519
520 /*
521  * Cu-like put command
522  */
523 void
524 cu_put(char cc)
525 {
526         FILE *fd;
527         char line[BUFSIZ];
528         int argc;
529         char *expand();
530         char *copynamex;
531
532         if (prompt("[put] ", copyname, sizeof(copyname)))
533                 return;
534         if ((argc = args(copyname, argv, sizeof(argv)/sizeof(argv[0]))) < 1 || argc > 2) {
535                 printf("usage: <put> from [to]\r\n");
536                 return;
537         }
538         if (argc == 1)
539                 argv[1] = argv[0];
540         copynamex = expand(argv[0]);
541         if ((fd = fopen(copynamex, "r")) == NULL) {
542                 printf("%s: cannot open\r\n", copynamex);
543                 return;
544         }
545         if (boolean(value(ECHOCHECK)))
546                 snprintf(line, sizeof(line), "cat>%s\r", argv[1]);
547         else
548                 snprintf(line, sizeof(line), "stty -echo;cat>%s;stty echo\r", argv[1]);
549         transmit(fd, "\04", line);
550 }
551
552
553 static int
554 nap(int msec)
555 {
556         if (usleep(msec*1000) != 0) {
557                 fprintf ( stderr, "warning: ldelay or cdelay interrupted, "
558                           "delay time cut short: %s\n",
559                           strerror(errno) );
560         }
561
562         return 0;
563 }
564
565
566 /*
567  * FTP - send single character
568  *  wait for echo & handle timeout
569  */
570 static void
571 send(char c)
572 {
573         char cc;
574         int retry = 0;
575
576         cc = c;
577         xpwrite(FD, &cc, 1);
578         if (number(value(CDELAY)) > 0 && c != '\r')
579                 nap(number(value(CDELAY)));
580         if (!boolean(value(ECHOCHECK))) {
581                 if (number(value(LDELAY)) > 0 && c == '\r')
582                         nap(number(value(LDELAY)));
583                 return;
584         }
585 tryagain:
586         timedout = 0;
587         alarm(number(value(ETIMEOUT)));
588         read(FD, &cc, 1);
589         alarm(0);
590         if (timedout) {
591                 printf("\r\ntimeout error (%s)\r\n", ctrl(c));
592                 if (retry++ > 3)
593                         return;
594                 xpwrite(FD, &null, 1); /* poke it */
595                 goto tryagain;
596         }
597 }
598
599 void
600 timeout(int __dummy)
601 {
602         signal(SIGALRM, timeout);
603         timedout = 1;
604 }
605
606 /*
607  * Stolen from consh() -- puts a remote file on the output of a local command.
608  *      Identical to consh() except for where stdout goes.
609  */
610 void
611 pipeout(int c)
612 {
613         char buf[256];
614         int cpid, status, p;
615         time_t start;
616
617         putchar(c);
618         if (prompt("Local command? ", buf, sizeof(buf)))
619                 return;
620         kill(pid, SIGIOT);      /* put TIPOUT into a wait state */
621         signal(SIGINT, SIG_IGN);
622         signal(SIGQUIT, SIG_IGN);
623         usedefchars ();
624         read(repdes[0], (char *)&ccc, 1);
625         /*
626          * Set up file descriptors in the child and
627          *  let it go...
628          */
629         if ((cpid = fork()) < 0)
630                 printf("can't fork!\r\n");
631         else if (cpid) {
632                 start = time(0);
633                 while ((p = wait(&status)) > 0 && p != cpid)
634                         ;
635         } else {
636                 register int i;
637
638                 dup2(FD, 1);
639                 for (i = 3; i < 20; i++)
640                         close(i);
641                 signal(SIGINT, SIG_DFL);
642                 signal(SIGQUIT, SIG_DFL);
643                 execute(buf);
644                 printf("can't find `%s'\r\n", buf);
645                 exit(0);
646         }
647         if (boolean(value(VERBOSE)))
648                 prtime("away for ", time(0)-start);
649         write(fildes[1], (char *)&ccc, 1);
650         usetchars ();
651         signal(SIGINT, SIG_DFL);
652         signal(SIGQUIT, SIG_DFL);
653 }
654
655 #if CONNECT
656
657 int
658 tiplink (char *cmd, unsigned int flags)
659 {
660         int cpid, status, p;
661         time_t start;
662
663         if (flags & TL_SIGNAL_TIPOUT) {
664                 kill(pid, SIGIOT);      /* put TIPOUT into a wait state */
665                 signal(SIGINT, SIG_IGN);
666                 signal(SIGQUIT, SIG_IGN);
667                 usedefchars ();
668                 read(repdes[0], (char *)&ccc, 1);
669         }
670
671         /*
672          * Set up file descriptors in the child and
673          *  let it go...
674          */
675         if ((cpid = fork()) < 0)
676                 printf("can't fork!\r\n");
677         else if (cpid) {
678                 start = time(0);
679                 while ((p = wait(&status)) > 0 && p != cpid)
680                         ;
681         } else {
682                 register int fd;
683
684                 dup2(FD, 0);
685                 dup2(3, 1);
686                 for (fd = 3; fd < 20; fd++)
687                         close (fd);
688                 signal(SIGINT, SIG_DFL);
689                 signal(SIGQUIT, SIG_DFL);
690                 execute (cmd);
691                 printf("can't find `%s'\r\n", cmd);
692                 exit(0);
693         }
694
695         if (flags & TL_VERBOSE && boolean(value(VERBOSE)))
696                 prtime("away for ", time(0)-start);
697
698         if (flags & TL_SIGNAL_TIPOUT) {
699                 write(fildes[1], (char *)&ccc, 1);
700                 usetchars ();
701                 signal(SIGINT, SIG_DFL);
702                 signal(SIGQUIT, SIG_DFL);
703         }
704
705         return 0;
706 }
707
708 /*
709  * Fork a program with:
710  *  0 <-> remote tty in
711  *  1 <-> remote tty out
712  *  2 <-> local tty out
713  */
714 int
715 consh(int c)
716 {
717         char buf[256];
718         putchar(c);
719         if (prompt("Local command? ", buf, sizeof(buf)))
720                 return;
721         tiplink (buf, TL_SIGNAL_TIPOUT | TL_VERBOSE);
722         return 0;
723 }
724 #endif
725
726 /*
727  * Escape to local shell
728  */
729 void
730 shell(void)
731 {
732         int shpid, status;
733         char *cp;
734
735         printf("[sh]\r\n");
736         signal(SIGINT, SIG_IGN);
737         signal(SIGQUIT, SIG_IGN);
738         unraw();
739         if ((shpid = fork())) {
740                 while (shpid != wait(&status));
741                 raw();
742                 printf("\r\n!\r\n");
743                 signal(SIGINT, SIG_DFL);
744                 signal(SIGQUIT, SIG_DFL);
745                 return;
746         } else {
747                 signal(SIGQUIT, SIG_DFL);
748                 signal(SIGINT, SIG_DFL);
749                 if ((cp = rindex(value(SHELL), '/')) == NULL)
750                         cp = value(SHELL);
751                 else
752                         cp++;
753                 shell_uid();
754                 execl(value(SHELL), cp, 0);
755                 printf("\r\ncan't execl!\r\n");
756                 exit(1);
757         }
758 }
759
760 /*
761  * TIPIN portion of scripting
762  *   initiate the conversation with TIPOUT
763  */
764 void
765 setscript(void)
766 {
767         char c;
768         /*
769          * enable TIPOUT side for dialogue
770          */
771         kill(pid, SIGEMT);
772         if (boolean(value(SCRIPT)))
773                 write(fildes[1], value(RECORD), size(value(RECORD)));
774         write(fildes[1], "\n", 1);
775         /*
776          * wait for TIPOUT to finish
777          */
778         read(repdes[0], &c, 1);
779         if (c == 'n')
780                 printf("can't create %s\r\n", value(RECORD));
781 }
782
783 /*
784  * Change current working directory of
785  *   local portion of tip
786  */
787 void
788 chdirectory(void)
789 {
790         char dirname[PATH_MAX];
791         register char *cp = dirname;
792
793         if (prompt("[cd] ", dirname, sizeof(dirname))) {
794                 if (stoprompt)
795                         return;
796                 cp = value(HOME);
797         }
798         if (chdir(cp) < 0)
799                 printf("%s: bad directory\r\n", cp);
800         printf("!\r\n");
801 }
802
803 void
804 tipabort(char *msg)
805 {
806
807         kill(pid, SIGTERM);
808         disconnect(msg);
809         if (msg != NOSTR)
810                 printf("\r\n%s", msg);
811         printf("\r\n[EOT]\r\n");
812         daemon_uid();
813         (void)uu_unlock(uucplock);
814         unraw();
815         exit(0);
816 }
817
818 void
819 finish(void)
820 {
821         char *abortmsg = NOSTR, *dismsg;
822
823         if (LO != NOSTR && tiplink (LO, TL_SIGNAL_TIPOUT) != 0) {
824                 abortmsg = "logout failed";
825         }
826
827         if ((dismsg = value(DISCONNECT)) != NOSTR) {
828                 write(FD, dismsg, strlen(dismsg));
829                 sleep (2);
830         }
831         tipabort(abortmsg);
832 }
833
834 void
835 intcopy(void)
836 {
837         raw();
838         quit = 1;
839         longjmp(intbuf, 1);
840 }
841
842 static void
843 execute(char *s)
844 {
845         register char *cp;
846
847         if ((cp = rindex(value(SHELL), '/')) == NULL)
848                 cp = value(SHELL);
849         else
850                 cp++;
851         shell_uid();
852         execl(value(SHELL), cp, "-c", s, 0);
853 }
854
855 static int
856 args(char *buf, char **a, int num)
857 {
858         register char *p = buf, *start;
859         register char **parg = a;
860         register int n = 0;
861
862         while (*p && n < num) {
863                 while (*p && (*p == ' ' || *p == '\t'))
864                         p++;
865                 start = p;
866                 if (*p)
867                         *parg = p;
868                 while (*p && (*p != ' ' && *p != '\t'))
869                         p++;
870                 if (p != start)
871                         parg++, n++;
872                 if (*p)
873                         *p++ = '\0';
874         }
875         return(n);
876 }
877
878 static void
879 prtime(char *s, time_t a)
880 {
881         register i;
882         int nums[3];
883
884         for (i = 0; i < 3; i++) {
885                 nums[i] = (int)(a % quant[i]);
886                 a /= quant[i];
887         }
888         printf("%s", s);
889         while (--i >= 0)
890                 if (nums[i] || (i == 0 && nums[1] == 0 && nums[2] == 0))
891                         printf("%d %s%c ", nums[i], sep[i],
892                                 nums[i] == 1 ? '\0' : 's');
893         printf("\r\n!\r\n");
894 }
895
896 void
897 variable(void)
898 {
899         char    buf[256];
900
901         if (prompt("[set] ", buf, sizeof(buf)))
902                 return;
903         vlex(buf);
904         if (vtable[BEAUTIFY].v_access&CHANGED) {
905                 vtable[BEAUTIFY].v_access &= ~CHANGED;
906                 kill(pid, SIGSYS);
907         }
908         if (vtable[SCRIPT].v_access&CHANGED) {
909                 vtable[SCRIPT].v_access &= ~CHANGED;
910                 setscript();
911                 /*
912                  * So that "set record=blah script" doesn't
913                  *  cause two transactions to occur.
914                  */
915                 if (vtable[RECORD].v_access&CHANGED)
916                         vtable[RECORD].v_access &= ~CHANGED;
917         }
918         if (vtable[RECORD].v_access&CHANGED) {
919                 vtable[RECORD].v_access &= ~CHANGED;
920                 if (boolean(value(SCRIPT)))
921                         setscript();
922         }
923         if (vtable[TAND].v_access&CHANGED) {
924                 vtable[TAND].v_access &= ~CHANGED;
925                 if (boolean(value(TAND)))
926                         tandem("on");
927                 else
928                         tandem("off");
929         }
930         if (vtable[LECHO].v_access&CHANGED) {
931                 vtable[LECHO].v_access &= ~CHANGED;
932                 HD = boolean(value(LECHO));
933         }
934         if (vtable[PARITY].v_access&CHANGED) {
935                 vtable[PARITY].v_access &= ~CHANGED;
936                 setparity(value(PARITY));
937         }
938 }
939
940 /*
941  * Turn tandem mode on or off for remote tty.
942  */
943 static void
944 tandem(char *option)
945 {
946 #if HAVE_TERMIOS
947         struct termios ttermios;
948         tcgetattr (FD, &ttermios);
949         if (strcmp(option,"on") == 0) {
950                 ttermios.c_iflag |= IXOFF;
951                 ctermios.c_iflag |= IXOFF;
952         }
953         else {
954                 ttermios.c_iflag &= ~IXOFF;
955                 ctermios.c_iflag &= ~IXOFF;
956         }
957         tcsetattr (FD, TCSANOW, &ttermios);
958         tcsetattr (0, TCSANOW, &ctermios);
959 #else /* HAVE_TERMIOS */
960         struct sgttyb rmtty;
961
962         ioctl(FD, TIOCGETP, &rmtty);
963         if (strcmp(option,"on") == 0) {
964                 rmtty.sg_flags |= TANDEM;
965                 arg.sg_flags |= TANDEM;
966         } else {
967                 rmtty.sg_flags &= ~TANDEM;
968                 arg.sg_flags &= ~TANDEM;
969         }
970         ioctl(FD, TIOCSETP, &rmtty);
971         ioctl(0,  TIOCSETP, &arg);
972 #endif /* HAVE_TERMIOS */
973 }
974
975 /*
976  * Send a break.
977  */
978 void
979 genbrk(void)
980 {
981
982         ioctl(FD, TIOCSBRK, NULL);
983         sleep(1);
984         ioctl(FD, TIOCCBRK, NULL);
985 }
986
987 /*
988  * Suspend tip
989  */
990 void
991 suspend(char c)
992 {
993
994         unraw();
995         kill(c == CTRL('y') ? getpid() : 0, SIGTSTP);
996         raw();
997 }
998
999 /*
1000  *      expand a file name if it includes shell meta characters
1001  */
1002
1003 char *
1004 expand(char *name)
1005 {
1006         static char xname[BUFSIZ];
1007         char cmdbuf[BUFSIZ];
1008         register int pid, l;
1009         register char *cp, *Shell;
1010         int s, pivec[2] /*, (*sigint)()*/;
1011
1012         if (!anyof(name, "~{[*?$`'\"\\"))
1013                 return(name);
1014         /* sigint = signal(SIGINT, SIG_IGN); */
1015         if (pipe(pivec) < 0) {
1016                 warn("pipe");
1017                 /* signal(SIGINT, sigint) */
1018                 return(name);
1019         }
1020         snprintf(cmdbuf, sizeof(cmdbuf), "echo %s", name);
1021         if ((pid = vfork()) == 0) {
1022                 Shell = value(SHELL);
1023                 if (Shell == NOSTR)
1024                         Shell = _PATH_BSHELL;
1025                 close(pivec[0]);
1026                 close(1);
1027                 dup(pivec[1]);
1028                 close(pivec[1]);
1029                 close(2);
1030                 shell_uid();
1031                 execl(Shell, Shell, "-c", cmdbuf, 0);
1032                 _exit(1);
1033         }
1034         if (pid == -1) {
1035                 warn("fork");
1036                 close(pivec[0]);
1037                 close(pivec[1]);
1038                 return(NOSTR);
1039         }
1040         close(pivec[1]);
1041         l = read(pivec[0], xname, BUFSIZ);
1042         close(pivec[0]);
1043         while (wait(&s) != pid);
1044                 ;
1045         s &= 0377;
1046         if (s != 0 && s != SIGPIPE) {
1047                 fprintf(stderr, "\"Echo\" failed\n");
1048                 return(NOSTR);
1049         }
1050         if (l < 0) {
1051                 warn("read");
1052                 return(NOSTR);
1053         }
1054         if (l == 0) {
1055                 fprintf(stderr, "\"%s\": No match\n", name);
1056                 return(NOSTR);
1057         }
1058         if (l == BUFSIZ) {
1059                 fprintf(stderr, "Buffer overflow expanding \"%s\"\n", name);
1060                 return(NOSTR);
1061         }
1062         xname[l] = 0;
1063         for (cp = &xname[l-1]; *cp == '\n' && cp > xname; cp--)
1064                 ;
1065         *++cp = '\0';
1066         return(xname);
1067 }
1068
1069 /*
1070  * Are any of the characters in the two strings the same?
1071  */
1072
1073 static int
1074 anyof(register char *s1, register char *s2)
1075 {
1076         register int c;
1077
1078         while ((c = *s1++))
1079                 if (any(c, s2))
1080                         return(1);
1081         return(0);
1082 }