?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Bring back --with-sys-screenrc configure flag.
[screen-lua.git] / src / screen.c
blob3dde3b477b1ca689f5499c3a4aac3bd5d2b48c72
1 /* Copyright (c) 2010
2 * Juergen Weigert (jnweiger@immd4.informatik.uni-erlangen.de)
3 * Sadrul Habib Chowdhury (sadrul@users.sourceforge.net)
4 * Copyright (c) 2008, 2009
5 * Juergen Weigert (jnweiger@immd4.informatik.uni-erlangen.de)
6 * Michael Schroeder (mlschroe@immd4.informatik.uni-erlangen.de)
7 * Micah Cowan (micah@cowan.name)
8 * Sadrul Habib Chowdhury (sadrul@users.sourceforge.net)
9 * Copyright (c) 1993-2002, 2003, 2005, 2006, 2007
10 * Juergen Weigert (jnweiger@immd4.informatik.uni-erlangen.de)
11 * Michael Schroeder (mlschroe@immd4.informatik.uni-erlangen.de)
12 * Copyright (c) 1987 Oliver Laumann
13 #ifdef HAVE_BRAILLE
14 * Modified by:
15 * Authors: Hadi Bargi Rangin bargi@dots.physics.orst.edu
16 * Bill Barry barryb@dots.physics.orst.edu
17 * Randy Lundquist randyl@dots.physics.orst.edu
18 *
19 * Modifications Copyright (c) 1995 by
20 * Science Access Project, Oregon State University.
21 #endif
22 *
23 * This program is free software; you can redistribute it and/or modify
24 * it under the terms of the GNU General Public License as published by
25 * the Free Software Foundation; either version 3, or (at your option)
26 * any later version.
27 *
28 * This program is distributed in the hope that it will be useful,
29 * but WITHOUT ANY WARRANTY; without even the implied warranty of
30 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
31 * GNU General Public License for more details.
32 *
33 * You should have received a copy of the GNU General Public License
34 * along with this program (see the file COPYING); if not, see
35 * http://www.gnu.org/licenses/, or contact Free Software Foundation, Inc.,
36 * 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
37 *
38 ****************************************************************
39 */
40
41 #include <sys/types.h>
42 #include <ctype.h>
43
44 #include <fcntl.h>
45
46 #ifdef sgi
47 # include <sys/sysmacros.h>
48 #endif
49
50 #include <sys/stat.h>
51 #ifndef sun
52 # include <sys/ioctl.h>
53 #endif
54
55 #ifndef SIGINT
56 # include <signal.h>
57 #endif
58
59 #include "config.h"
60
61 #ifdef HAVE_STROPTS_H
62 # include <sys/stropts.h>
63 #endif
64
65 #if defined(SYSV) && !defined(ISC)
66 # include <sys/utsname.h>
67 #endif
68
69 #if defined(sequent) || defined(SVR4)
70 # include <sys/resource.h>
71 #endif /* sequent || SVR4 */
72
73 #ifdef ISC
74 # include <sys/tty.h>
75 # include <sys/sioctl.h>
76 # include <sys/pty.h>
77 #endif /* ISC */
78
79 #if (defined(AUX) || defined(_AUX_SOURCE)) && defined(POSIX)
80 # include <compat.h>
81 #endif
82 #if defined(USE_LOCALE) || defined(ENCODINGS)
83 # include <locale.h>
84 #endif
85 #if defined(HAVE_NL_LANGINFO) && defined(ENCODINGS)
86 # include <langinfo.h>
87 #endif
88
89 #include "screen.h"
90 #ifdef HAVE_BRAILLE
91 # include "braille.h"
92 #endif
93
94 #include "patchlevel.h"
95
96 /*
97 * At the moment we only need the real password if the
98 * builtin lock is used. Therefore disable SHADOWPW if
99 * we do not really need it (kind of security thing).
100 */
101 #ifndef LOCK
102 # undef SHADOWPW
103 #endif
104
105 #include <pwd.h>
106 #ifdef SHADOWPW
107 # include <shadow.h>
108 #endif /* SHADOWPW */
109
110 #include "logfile.h" /* islogfile, logfflush */
111
112 #ifdef DEBUG
113 FILE *dfp;
114 #endif
115
116
117 extern char Term[], screenterm[], **environ, Termcap[];
118 int force_vt = 1;
119 int VBellWait, MsgWait, MsgMinWait, SilenceWait;
120
121 extern struct acluser *users;
122 extern struct display *displays, *display;
123
124 extern struct LayFuncs MarkLf;
125
126
127 extern int visual_bell;
128 #ifdef COPY_PASTE
129 extern unsigned char mark_key_tab[];
130 #endif
131 extern char version[];
132 extern char DefaultShell[];
133 #ifdef ZMODEM
134 extern char *zmodem_sendcmd;
135 extern char *zmodem_recvcmd;
136 #endif
137 extern struct layout *layout_last;
138
139
140 char *ShellProg;
141 char *ShellArgs[2];
142
143 extern struct NewWindow nwin_undef, nwin_default, nwin_options;
144 struct backtick;
145
146 static struct passwd *getpwbyname __P((char *, struct passwd *));
147 static void SigChldHandler __P((void));
148 static sigret_t SigChld __P(SIGPROTOARG);
149 static sigret_t SigInt __P(SIGPROTOARG);
150 static sigret_t CoreDump __P(SIGPROTOARG);
151 static sigret_t FinitHandler __P(SIGPROTOARG);
152 static void DoWait __P((void));
153 static void serv_read_fn __P((struct event *, char *));
154 static void serv_select_fn __P((struct event *, char *));
155 static void logflush_fn __P((struct event *, char *));
156 static void backtick_filter __P((struct backtick *));
157 static void backtick_fn __P((struct event *, char *));
158 static char *runbacktick __P((struct backtick *, int *, time_t));
159 static int IsSymbol __P((char *, char *));
160 static char *ParseChar __P((char *, char *));
161 static int ParseEscape __P((char *));
162 static char *pad_expand __P((char *, char *, int, int));
163 #ifdef DEBUG
164 static void fds __P((void));
165 #endif
166
167 int nversion; /* numerical version, used for secondary DA */
168
169 /* the attacher */
170 struct passwd *ppp;
171 char *attach_tty;
172 int attach_fd = -1;
173 char *attach_term;
174 char *LoginName;
175 struct mode attach_Mode;
176
177 char SockPath[MAXPATHLEN + 2 * MAXSTR];
178 char *SockName; /* SockName is pointer in SockPath */
179 char *SockMatch = NULL; /* session id command line argument */
180 int ServerSocket = -1;
181 struct event serv_read;
182 struct event serv_select;
183 struct event logflushev;
184
185 char **NewEnv = NULL;
186
187 char *RcFileName = NULL;
188 char *home;
189
190 char *screenlogfile; /* filename layout */
191 int log_flush = 10; /* flush interval in seconds */
192 int logtstamp_on = 0; /* tstamp disabled */
193 char *logtstamp_string; /* stamp layout */
194 int logtstamp_after = 120; /* first tstamp after 120s */
195 char *hardcopydir = NULL;
196 char *BellString;
197 char *VisualBellString;
198 char *ActivityString;
199 #ifdef COPY_PASTE
200 char *BufferFile;
201 #endif
202 #ifdef POW_DETACH
203 char *PowDetachString;
204 #endif
205 char *hstatusstring;
206 char *captionstring;
207 char *timestring;
208 char *wliststr;
209 char *wlisttit;
210 int auto_detach = 1;
211 int iflag, rflag, dflag, lsflag, quietflag, wipeflag, xflag;
212 int cmdflag;
213 int queryflag = -1;
214 int adaptflag;
215
216 #ifdef MULTIUSER
217 char *multi;
218 char *multi_home;
219 int multi_uid;
220 int own_uid;
221 int multiattach;
222 int tty_mode;
223 int tty_oldmode = -1;
224 #endif
225
226 char HostName[MAXSTR];
227 int MasterPid, PanicPid;
228 int real_uid, real_gid, eff_uid, eff_gid;
229 int default_startup;
230 int ZombieKey_destroy, ZombieKey_resurrect, ZombieKey_onerror;
231 char *preselect = NULL; /* only used in Attach() */
232
233 #ifdef UTF8
234 char *screenencodings;
235 #endif
236
237 #ifdef DW_CHARS
238 int cjkwidth;
239 #endif
240
241 #ifdef NETHACK
242 int nethackflag = 0;
243 #endif
244 int maxwin;
245
246
247 struct layer *flayer;
248 struct win *fore;
249 struct win *windows;
250 struct win *console_window;
251
252
253
254 /*
255 * Do this last
256 */
257 #include "extern.h"
258
259 char strnomem[] = "Out of memory.";
260
261
262 static int InterruptPlease;
263 static int GotSigChld;
264
265 static int
266 lf_secreopen(name, wantfd, l)
267 char *name;
268 int wantfd;
269 struct logfile *l;
270 {
271 int got_fd;
272
273 close(wantfd);
274 if (((got_fd = secopen(name, O_WRONLY | O_CREAT | O_APPEND, 0666)) < 0) ||
275 lf_move_fd(got_fd, wantfd) < 0)
276 {
277 logfclose(l);
278 debug1("lf_secreopen: failed for %s\n", name);
279 return -1;
280 }
281 l->st->st_ino = l->st->st_dev = 0;
282 debug2("lf_secreopen: %d = %s\n", wantfd, name);
283 return 0;
284 }
285
286 /********************************************************************/
287 /********************************************************************/
288 /********************************************************************/
289
290
291 static struct passwd *
292 getpwbyname(name, ppp)
293 char *name;
294 struct passwd *ppp;
295 {
296 int n;
297 #ifdef SHADOWPW
298 struct spwd *sss = NULL;
299 static char *spw = NULL;
300 #endif
301
302 if (!ppp && !(ppp = getpwnam(name)))
303 return NULL;
304
305 /* Do password sanity check..., allow ##user for SUN_C2 security */
306 #ifdef SHADOWPW
307 pw_try_again:
308 #endif
309 n = 0;
310 if (ppp->pw_passwd[0] == '#' && ppp->pw_passwd[1] == '#' &&
311 strcmp(ppp->pw_passwd + 2, ppp->pw_name) == 0)
312 n = 13;
313 for (; n < 13; n++)
314 {
315 char c = ppp->pw_passwd[n];
316 if (!(c == '.' || c == '/' || c == '$' ||
317 (c >= '0' && c <= '9') ||
318 (c >= 'a' && c <= 'z') ||
319 (c >= 'A' && c <= 'Z')))
320 break;
321 }
322
323 #ifdef SHADOWPW
324 /* try to determine real password */
325 if (n < 13 && sss == 0)
326 {
327 sss = getspnam(ppp->pw_name);
328 if (sss)
329 {
330 if (spw)
331 free(spw);
332 ppp->pw_passwd = spw = SaveStr(sss->sp_pwdp);
333 endspent(); /* this should delete all buffers ... */
334 goto pw_try_again;
335 }
336 endspent(); /* this should delete all buffers ... */
337 }
338 #endif
339 if (n < 13)
340 ppp->pw_passwd = 0;
341 #ifdef linux
342 if (ppp->pw_passwd && strlen(ppp->pw_passwd) == 13 + 11)
343 ppp->pw_passwd[13] = 0; /* beware of linux's long passwords */
344 #endif
345
346 return ppp;
347 }
348
349 static char *
350 locale_name(void)
351 {
352 static char *s;
353
354 if (!s)
355 {
356 s = getenv("LC_ALL");
357 if (s == NULL)
358 s = getenv("LC_CTYPE");
359 if (s == NULL)
360 s = getenv("LANG");
361 }
362 return s;
363 }
364
365 int
366 main(ac, av)
367 int ac;
368 char **av;
369 {
370 register int n;
371 char *ap;
372 char *av0;
373 char socknamebuf[2 * MAXSTR];
374 int mflag = 0;
375 char *myname = (ac == 0) ? "screen" : av[0];
376 char *SockDir;
377 struct stat st;
378 #ifdef _MODE_T /* (jw) */
379 mode_t oumask;
380 #else
381 int oumask;
382 #endif
383 #if defined(SYSV) && !defined(ISC)
384 struct utsname utsnam;
385 #endif
386 struct NewWindow nwin;
387 int detached = 0; /* start up detached */
388 #ifdef MULTIUSER
389 char *sockp;
390 #endif
391 char *sty = 0;
392
393 #if (defined(AUX) || defined(_AUX_SOURCE)) && defined(POSIX)
394 setcompat(COMPAT_POSIX|COMPAT_BSDPROT); /* turn on seteuid support */
395 #endif
396 #if defined(sun) && defined(SVR4)
397 {
398 /* Solaris' login blocks SIGHUP! This is _very bad_ */
399 sigset_t sset;
400 sigemptyset(&sset);
401 sigprocmask(SIG_SETMASK, &sset, 0);
402 }
403 #endif
404
405 /*
406 * First, close all unused descriptors
407 * (otherwise, we might have problems with the select() call)
408 */
409 closeallfiles(0);
410 #ifdef DEBUG
411 opendebug(1, 0);
412 #endif
413 snprintf(version, 59, "%d.%.2d.%.2d%s (%s%s) %s", REV, VERS,
414 PATCHLEVEL, STATE, ORIGIN, GIT_REV, DATE);
415 nversion = REV * 10000 + VERS * 100 + PATCHLEVEL;
416 debug2("-- screen debug started %s (%s)\n", *av, version);
417 #ifdef POSIX
418 debug("POSIX\n");
419 #endif
420 #ifdef TERMIO
421 debug("TERMIO\n");
422 #endif
423 #ifdef SYSV
424 debug("SYSV\n");
425 #endif
426 #ifdef SYSVSIGS
427 debug("SYSVSIGS\n");
428 #endif
429 #ifdef NAMEDPIPE
430 debug("NAMEDPIPE\n");
431 #endif
432 #if defined(SIGWINCH) && defined(TIOCGWINSZ)
433 debug("Window size changing enabled\n");
434 #endif
435 #ifdef HAVE_SETREUID
436 debug("SETREUID\n");
437 #endif
438 #ifdef HAVE_SETEUID
439 debug("SETEUID\n");
440 #endif
441 #ifdef hpux
442 debug("hpux\n");
443 #endif
444 #ifdef USEBCOPY
445 debug("USEBCOPY\n");
446 #endif
447 #ifdef UTMPOK
448 debug("UTMPOK\n");
449 #endif
450 #ifdef LOADAV
451 debug("LOADAV\n");
452 #endif
453 #ifdef NETHACK
454 debug("NETHACK\n");
455 #endif
456 #ifdef TERMINFO
457 debug("TERMINFO\n");
458 #endif
459 #ifdef SHADOWPW
460 debug("SHADOWPW\n");
461 #endif
462 #ifdef NAME_MAX
463 debug1("NAME_MAX = %d\n", NAME_MAX);
464 #endif
465
466 BellString = SaveStr("Bell in window %n");
467 VisualBellString = SaveStr(" Wuff, Wuff!! ");
468 ActivityString = SaveStr("Activity in window %n");
469 screenlogfile = SaveStr("screenlog.%n");
470 logtstamp_string = SaveStr("-- %n:%t -- time-stamp -- %M/%d/%y %c:%s --\n");
471 hstatusstring = SaveStr("%h");
472 captionstring = SaveStr("%4n %t");
473 timestring = SaveStr("%c:%s %M %d %H%? %l%?");
474 wlisttit = SaveStr(" Num Name%=Flags");
475 wliststr = SaveStr("%4n %t%=%f");
476 #ifdef COPY_PASTE
477 BufferFile = SaveStr(DEFAULT_BUFFERFILE);
478 #endif
479 ShellProg = NULL;
480 #ifdef POW_DETACH
481 PowDetachString = 0;
482 #endif
483 default_startup = (ac > 1) ? 0 : 1;
484 adaptflag = 0;
485 VBellWait = VBELLWAIT * 1000;
486 MsgWait = MSGWAIT * 1000;
487 MsgMinWait = MSGMINWAIT * 1000;
488 SilenceWait = SILENCEWAIT;
489 #ifdef HAVE_BRAILLE
490 InitBraille();
491 #endif
492 #ifdef ZMODEM
493 zmodem_sendcmd = SaveStr("!!! sz -vv -b ");
494 zmodem_recvcmd = SaveStr("!!! rz -vv -b -E");
495 #endif
496
497 #ifdef COPY_PASTE
498 CompileKeys((char *)0, 0, mark_key_tab);
499 #endif
500 #ifdef UTF8
501 InitBuiltinTabs();
502 screenencodings = SaveStr(SCREENENCODINGS);
503 #endif
504 #ifdef DW_CHARS
505 cjkwidth = 0;
506 #endif
507 nwin = nwin_undef;
508 nwin_options = nwin_undef;
509 strcpy(screenterm, "screen");
510
511 logreopen_register(lf_secreopen);
512
513 av0 = *av;
514 /* if this is a login screen, assume -RR */
515 if (*av0 == '-')
516 {
517 rflag = 4;
518 #ifdef MULTI
519 xflag = 1;
520 #else
521 dflag = 1;
522 #endif
523 ShellProg = SaveStr(DefaultShell); /* to prevent nasty circles */
524 }
525 while (ac > 0)
526 {
527 ap = *++av;
528 if (--ac > 0 && *ap == '-')
529 {
530 if (ap[1] == '-' && ap[2] == 0)
531 {
532 av++;
533 ac--;
534 break;
535 }
536 if (ap[1] == '-' && !strcmp(ap, "--version"))
537 Panic(0, "Screen version %s", version);
538 if (ap[1] == '-' && !strcmp(ap, "--help"))
539 exit_with_usage(myname, NULL, NULL);
540 while (ap && *ap && *++ap)
541 {
542 switch (*ap)
543 {
544 case 'a':
545 nwin_options.aflag = 1;
546 break;
547 case 'A':
548 adaptflag = 1;
549 break;
550 case 'p': /* preselect */
551 if (*++ap)
552 preselect = ap;
553 else
554 {
555 if (!--ac)
556 exit_with_usage(myname, "Specify a window to preselect with -p", NULL);
557 preselect = *++av;
558 }
559 ap = NULL;
560 break;
561 #ifdef HAVE_BRAILLE
562 case 'B':
563 bd.bd_start_braille = 1;
564 break;
565 #endif
566 case 'c':
567 if (*++ap)
568 RcFileName = ap;
569 else
570 {
571 if (--ac == 0)
572 exit_with_usage(myname, "Specify an alternate rc-filename with -c", NULL);
573 RcFileName = *++av;
574 }
575 ap = NULL;
576 break;
577 case 'e':
578 if (!*++ap)
579 {
580 if (--ac == 0)
581 exit_with_usage(myname, "Specify command characters with -e", NULL);
582 ap = *++av;
583 }
584 if (ParseEscape(ap))
585 Panic(0, "Two characters are required with -e option, not '%s'.", ap);
586 ap = NULL;
587 break;
588 case 'f':
589 ap++;
590 switch (*ap++)
591 {
592 case 'n':
593 case '0':
594 nwin_options.flowflag = FLOW_NOW * 0;
595 break;
596 case '\0':
597 ap--;
598 /* FALLTHROUGH */
599 case 'y':
600 case '1':
601 nwin_options.flowflag = FLOW_NOW * 1;
602 break;
603 case 'a':
604 nwin_options.flowflag = FLOW_AUTOFLAG;
605 break;
606 default:
607 exit_with_usage(myname, "Unknown flow option -%s", --ap);
608 }
609 break;
610 case 'h':
611 if (--ac == 0)
612 exit_with_usage(myname, NULL, NULL);
613 nwin_options.histheight = atoi(*++av);
614 if (nwin_options.histheight < 0)
615 exit_with_usage(myname, "-h: %s: negative scrollback size?", *av);
616 break;
617 case 'i':
618 iflag = 1;
619 break;
620 case 't': /* title, the former AkA == -k */
621 if (--ac == 0)
622 exit_with_usage(myname, "Specify a new window-name with -t", NULL);
623 nwin_options.aka = *++av;
624 break;
625 case 'l':
626 ap++;
627 switch (*ap++)
628 {
629 case 'n':
630 case '0':
631 nwin_options.lflag = 0;
632 break;
633 case '\0':
634 ap--;
635 /* FALLTHROUGH */
636 case 'y':
637 case '1':
638 nwin_options.lflag = 1;
639 break;
640 case 'a':
641 nwin_options.lflag = 3;
642 break;
643 case 's': /* -ls */
644 case 'i': /* -list */
645 lsflag = 1;
646 if (ac > 1 && !SockMatch)
647 {
648 SockMatch = *++av;
649 ac--;
650 }
651 ap = NULL;
652 break;
653 default:
654 exit_with_usage(myname, "%s: Unknown suboption to -l", --ap);
655 }
656 break;
657 case 'w':
658 lsflag = 1;
659 wipeflag = 1;
660 if (ac > 1 && !SockMatch)
661 {
662 SockMatch = *++av;
663 ac--;
664 }
665 break;
666 case 'L':
667 nwin_options.Lflag = 1;
668 break;
669 case 'm':
670 mflag = 1;
671 break;
672 case 'O': /* to be (or not to be?) deleted. jw. */
673 force_vt = 0;
674 break;
675 case 'T':
676 if (--ac == 0)
677 exit_with_usage(myname, "Specify terminal-type with -T", NULL);
678 if (strlen(*++av) < 20)
679 strcpy(screenterm, *av);
680 else
681 Panic(0, "-T: terminal name too long. (max. 20 char)");
682 nwin_options.term = screenterm;
683 break;
684 case 'q':
685 quietflag = 1;
686 break;
687 case 'Q':
688 queryflag = 1;
689 cmdflag = 1;
690 break;
691 case 'r':
692 case 'R':
693 #ifdef MULTI
694 case 'x':
695 #endif
696 if (ac > 1 && *av[1] != '-' && !SockMatch)
697 {
698 SockMatch = *++av;
699 ac--;
700 debug2("rflag=%d, SockMatch=%s\n", dflag, SockMatch);
701 }
702 #ifdef MULTI
703 if (*ap == 'x')
704 xflag = 1;
705 #endif
706 if (rflag)
707 rflag = 2;
708 rflag += (*ap == 'R') ? 2 : 1;
709 break;
710 #ifdef REMOTE_DETACH
711 case 'd':
712 dflag = 1;
713 /* FALLTHROUGH */
714 case 'D':
715 if (!dflag)
716 dflag = 2;
717 if (ac == 2)
718 {
719 if (*av[1] != '-' && !SockMatch)
720 {
721 SockMatch = *++av;
722 ac--;
723 debug2("dflag=%d, SockMatch=%s\n", dflag, SockMatch);
724 }
725 }
726 break;
727 #endif
728 case 's':
729 if (--ac == 0)
730 exit_with_usage(myname, "Specify shell with -s", NULL);
731 if (ShellProg)
732 free(ShellProg);
733 ShellProg = SaveStr(*++av);
734 debug1("ShellProg: '%s'\n", ShellProg);
735 break;
736 case 'S':
737 if (!SockMatch)
738 {
739 if (--ac == 0)
740 exit_with_usage(myname, "Specify session-name with -S", NULL);
741 SockMatch = *++av;
742 }
743 if (!*SockMatch)
744 exit_with_usage(myname, "Empty session-name?", NULL);
745 break;
746 case 'X':
747 cmdflag = 1;
748 break;
749 case 'v':
750 Panic(0, "Screen version %s", version);
751 /* NOTREACHED */
752 #ifdef UTF8
753 case 'U':
754 nwin_options.encoding = nwin_options.encoding == -1 ? UTF8 : 0;
755 break;
756 #endif
757 default:
758 exit_with_usage(myname, "Unknown option %s", --ap);
759 }
760 }
761 }
762 else
763 break;
764 }
765
766 real_uid = getuid();
767 real_gid = getgid();
768 eff_uid = geteuid();
769 eff_gid = getegid();
770
771 #ifdef SIGBUS /* OOPS, linux has no bus errors! */
772 signal(SIGBUS, CoreDump);
773 #endif /* SIGBUS */
774 signal(SIGSEGV, CoreDump);
775
776
777 #ifdef USE_LOCALE
778 setlocale(LC_ALL, "");
779 #endif
780 #ifdef ENCODINGS
781 if (nwin_options.encoding == -1)
782 {
783 /* ask locale if we should start in UTF-8 mode */
784 # ifdef HAVE_NL_LANGINFO
785 # ifndef USE_LOCALE
786 setlocale(LC_CTYPE, "");
787 # endif
788 nwin_options.encoding = FindEncoding(nl_langinfo(CODESET));
789 debug1("locale says encoding = %d\n", nwin_options.encoding);
790 # else
791 # ifdef UTF8
792 char *s;
793 if ((s = locale_name()) && InStr(s, "UTF-8"))
794 nwin_options.encoding = UTF8;
795 # endif
796 debug1("environment says encoding=%d\n", nwin_options.encoding);
797 #endif
798 }
799 # ifdef DW_CHARS
800 {
801 char *s;
802 if ((s = locale_name()))
803 {
804 if(!strncmp(s, "zh_", 3) || !strncmp(s, "ja_", 3) || !strncmp(s, "ko_", 3))
805 {
806 cjkwidth = 1;
807 }
808 }
809 }
810 #endif
811 #endif
812 if (nwin_options.aka)
813 {
814 #ifdef ENCODINGS
815 if (nwin_options.encoding > 0)
816 {
817 size_t len = strlen(nwin_options.aka);
818 size_t newsz;
819 char *newbuf = malloc(3 * len);
820 if (!newbuf)
821 Panic(0, "%s", strnomem);
822 newsz = RecodeBuf(nwin_options.aka, len,
823 nwin_options.encoding, 0, newbuf);
824 newbuf[newsz] = '\0';
825 nwin_options.aka = newbuf;
826 }
827 else
828 #endif
829 {
830 /* If we just use the original value from av,
831 subsequent shelltitle invocations will attempt to free
832 space we don't own... */
833 nwin_options.aka = SaveStr(nwin_options.aka);
834 }
835 }
836
837 if (SockMatch && strlen(SockMatch) >= MAXSTR)
838 Panic(0, "Ridiculously long socketname - try again.");
839 if (cmdflag && !rflag && !dflag && !xflag)
840 xflag = 1;
841 if (!cmdflag && dflag && mflag && !(rflag || xflag))
842 detached = 1;
843 nwin = nwin_options;
844 #ifdef ENCODINGS
845 nwin.encoding = nwin_undef.encoding; /* let screenrc overwrite it */
846 #endif
847 if (ac)
848 nwin.args = av;
849
850 /* make the write() calls return -1 on all errors */
851 #ifdef SIGXFSZ
852 /*
853 * Ronald F. Guilmette, Oct 29 '94, bug-gnu-utils@prep.ai.mit.edu:
854 * It appears that in System V Release 4, UNIX, if you are writing
855 * an output file and you exceed the currently set file size limit,
856 * you _don't_ just get the call to `write' returning with a
857 * failure code. Rather, you get a signal called `SIGXFSZ' which,
858 * if neither handled nor ignored, will cause your program to crash
859 * with a core dump.
860 */
861 signal(SIGXFSZ, SIG_IGN);
862 #endif /* SIGXFSZ */
863
864 #ifdef SIGPIPE
865 signal(SIGPIPE, SIG_IGN);
866 #endif
867
868 if (!ShellProg)
869 {
870 register char *sh;
871
872 sh = getenv("SHELL");
873 ShellProg = SaveStr(sh ? sh : DefaultShell);
874 }
875 ShellArgs[0] = ShellProg;
876 home = getenv("HOME");
877 if (!mflag && !SockMatch)
878 {
879 sty = getenv("STY");
880 if (sty && *sty == 0)
881 sty = 0;
882 }
883
884 #ifdef NETHACK
885 if (!(nethackflag = (getenv("NETHACKOPTIONS") != NULL)))
886 {
887 char nethackrc[MAXPATHLEN];
888
889 if (home && (strlen(home) < (MAXPATHLEN - 20)))
890 {
891 sprintf(nethackrc,"%s/.nethackrc", home);
892 nethackflag = !access(nethackrc, F_OK);
893 }
894 }
895 #endif
896
897 #ifdef MULTIUSER
898 own_uid = multi_uid = real_uid;
899 if (SockMatch && (sockp = index(SockMatch, '/')))
900 {
901 *sockp = 0;
902 multi = SockMatch;
903 SockMatch = sockp + 1;
904 if (*multi)
905 {
906 struct passwd *mppp;
907 if ((mppp = getpwnam(multi)) == (struct passwd *)0)
908 Panic(0, "Cannot identify account '%s'.", multi);
909 multi_uid = mppp->pw_uid;
910 multi_home = SaveStr(mppp->pw_dir);
911 if (strlen(multi_home) > MAXPATHLEN - 10)
912 Panic(0, "home directory path too long");
913 # ifdef MULTI
914 /* always fake multi attach mode */
915 if (rflag || lsflag)
916 xflag = 1;
917 # endif /* MULTI */
918 detached = 0;
919 multiattach = 1;
920 }
921 /* Special case: effective user is multiuser. */
922 if (eff_uid && (multi_uid != eff_uid))
923 Panic(0, "Must run suid root for multiuser support.");
924 }
925 if (SockMatch && *SockMatch == 0)
926 SockMatch = 0;
927 #endif /* MULTIUSER */
928
929 if ((LoginName = getlogin()) && LoginName[0] != '\0')
930 {
931 if ((ppp = getpwnam(LoginName)) != (struct passwd *) 0)
932 if ((int)ppp->pw_uid != real_uid)
933 ppp = (struct passwd *) 0;
934 }
935 if (ppp == 0)
936 {
937 if ((ppp = getpwuid(real_uid)) == 0)
938 {
939 Panic(0, "getpwuid() can't identify your account!");
940 exit(1);
941 }
942 LoginName = ppp->pw_name;
943 }
944 LoginName = SaveStr(LoginName);
945
946 ppp = getpwbyname(LoginName, ppp);
947
948 #if !defined(SOCKDIR) && defined(MULTIUSER)
949 if (multi && !multiattach)
950 {
951 if (home && strcmp(home, ppp->pw_dir))
952 Panic(0, "$HOME must match passwd entry for multiuser screens.");
953 }
954 #endif
955
956 #define SET_GUID() do \
957 { \
958 setgid(real_gid); \
959 setuid(real_uid); \
960 eff_uid = real_uid; \
961 eff_gid = real_gid; \
962 } while (0)
963
964 #define SET_TTYNAME(fatal) do \
965 { \
966 if (!(attach_tty = ttyname(0))) \
967 { \
968 if (fatal) \
969 Panic(0, "Must be connected to a terminal."); \
970 else \
971 attach_tty = ""; \
972 } \
973 else if (stat(attach_tty, &st)) \
974 Panic(errno, "Cannot access '%s'", attach_tty); \
975 if (strlen(attach_tty) >= MAXPATHLEN) \
976 Panic(0, "TtyName too long - sorry."); \
977 } while (0)
978
979 if (home == 0 || *home == '\0')
980 home = ppp->pw_dir;
981 if (strlen(LoginName) > 20)
982 Panic(0, "LoginName too long - sorry.");
983 #ifdef MULTIUSER
984 if (multi && strlen(multi) > 20)
985 Panic(0, "Screen owner name too long - sorry.");
986 #endif
987 if (strlen(home) > MAXPATHLEN - 25)
988 Panic(0, "$HOME too long - sorry.");
989
990 attach_tty = "";
991 if (!detached && !lsflag && !cmdflag && !(dflag && !mflag && !rflag && !xflag) && !(!mflag && !SockMatch && sty && !xflag))
992 {
993 #ifndef NAMEDPIPE
994 int fl;
995 #endif
996
997 /* ttyname implies isatty */
998 SET_TTYNAME(1);
999 #ifdef MULTIUSER
1000 tty_mode = (int)st.st_mode & 0777;
1001 #endif
1002
1003 #ifndef NAMEDPIPE
1004 fl = fcntl(0, F_GETFL, 0);
1005 if (fl != -1 && (fl & (O_RDWR|O_RDONLY|O_WRONLY)) == O_RDWR)
1006 attach_fd = 0;
1007 #endif
1008 if (attach_fd == -1)
1009 {
1010 if ((n = secopen(attach_tty, O_RDWR | O_NONBLOCK, 0)) < 0)
1011 Panic(0, "Cannot open your terminal '%s' - please check.", attach_tty);
1012 close(n);
1013 }
1014 debug2("attach_tty is %s, attach_fd is %d\n", attach_tty, attach_fd);
1015
1016 if ((attach_term = getenv("TERM")) == 0 || *attach_term == 0)
1017 Panic(0, "Please set a terminal type.");
1018 if (strlen(attach_term) > sizeof(D_termname) - 1)
1019 Panic(0, "$TERM too long - sorry.");
1020 GetTTY(0, &attach_Mode);
1021 #ifdef DEBUGGGGGGGGGGGGGGG
1022 DebugTTY(&attach_Mode);
1023 #endif /* DEBUG */
1024 }
1025
1026 #ifdef _MODE_T
1027 oumask = umask(0); /* well, unsigned never fails? jw. */
1028 #else
1029 if ((oumask = (int)umask(0)) == -1)
1030 Panic(errno, "Cannot change umask to zero");
1031 #endif
1032 SockDir = getenv("SCREENDIR");
1033 if (SockDir)
1034 {
1035 if (strlen(SockDir) >= MAXPATHLEN - 1)
1036 Panic(0, "Ridiculously long $SCREENDIR - try again.");
1037 #ifdef MULTIUSER
1038 if (multi)
1039 Panic(0, "No $SCREENDIR with multi screens, please.");
1040 #endif
1041 }
1042 #ifdef MULTIUSER
1043 if (multiattach)
1044 {
1045 # ifndef SOCKDIR
1046 sprintf(SockPath, "%s/.screen", multi_home);
1047 SockDir = SockPath;
1048 # else
1049 SockDir = SOCKDIR;
1050 sprintf(SockPath, "%s/S-%s", SockDir, multi);
1051 # endif
1052 }
1053 else
1054 #endif
1055 {
1056 #ifndef SOCKDIR
1057 if (SockDir == 0)
1058 {
1059 sprintf(SockPath, "%s/.screen", home);
1060 SockDir = SockPath;
1061 }
1062 #endif
1063 if (SockDir)
1064 {
1065 if (access(SockDir, F_OK))
1066 {
1067 debug1("SockDir '%s' missing ...\n", SockDir);
1068 if (UserContext() > 0)
1069 {
1070 if (mkdir(SockDir, 0700))
1071 UserReturn(0);
1072 UserReturn(1);
1073 }
1074 if (UserStatus() <= 0)
1075 Panic(0, "Cannot make directory '%s'.", SockDir);
1076 }
1077 if (SockDir != SockPath)
1078 strcpy(SockPath, SockDir);
1079 }
1080 #ifdef SOCKDIR
1081 else
1082 {
1083 SockDir = SOCKDIR;
1084 if (stat(SockDir, &st))
1085 {
1086 n = (eff_uid == 0 && (real_uid || eff_gid == real_gid)) ? 0755 :
1087 (eff_gid != real_gid) ? 0775 :
1088 #ifdef S_ISVTX
1089 0777|S_ISVTX;
1090 #else
1091 0777;
1092 #endif
1093 if (mkdir(SockDir, n) == -1)
1094 Panic(errno, "Cannot make directory '%s'", SockDir);
1095 }
1096 else
1097 {
1098 if (!S_ISDIR(st.st_mode))
1099 Panic(0, "'%s' must be a directory.", SockDir);
1100 if (eff_uid == 0 && real_uid && (int)st.st_uid != eff_uid)
1101 Panic(0, "Directory '%s' must be owned by root.", SockDir);
1102 n = (eff_uid == 0 && (real_uid || (st.st_mode & 0775) != 0775)) ? 0755 :
1103 (eff_gid == (int)st.st_gid && eff_gid != real_gid) ? 0775 :
1104 0777;
1105 if (((int)st.st_mode & 0777) != n)
1106 Panic(0, "Directory '%s' must have mode %03o.", SockDir, n);
1107 }
1108 sprintf(SockPath, "%s/S-%s", SockDir, LoginName);
1109 if (access(SockPath, F_OK))
1110 {
1111 if (mkdir(SockPath, 0700) == -1)
1112 Panic(errno, "Cannot make directory '%s'", SockPath);
1113 (void) chown(SockPath, real_uid, real_gid);
1114 }
1115 }
1116 #endif
1117 }
1118
1119 if (stat(SockPath, &st) == -1)
1120 Panic(errno, "Cannot access %s", SockPath);
1121 else
1122 if (!S_ISDIR(st.st_mode))
1123 Panic(0, "%s is not a directory.", SockPath);
1124 #ifdef MULTIUSER
1125 if (multi)
1126 {
1127 if ((int)st.st_uid != multi_uid)
1128 Panic(0, "%s is not the owner of %s.", multi, SockPath);
1129 }
1130 else
1131 #endif
1132 {
1133 if ((int)st.st_uid != real_uid)
1134 Panic(0, "You are not the owner of %s.", SockPath);
1135 }
1136 if ((st.st_mode & 0777) != 0700)
1137 Panic(0, "Directory %s must have mode 700.", SockPath);
1138 if (SockMatch && index(SockMatch, '/'))
1139 Panic(0, "Bad session name '%s'", SockMatch);
1140 SockName = SockPath + strlen(SockPath) + 1;
1141 *SockName = 0;
1142 (void) umask(oumask);
1143 debug2("SockPath: %s SockMatch: %s\n", SockPath, SockMatch ? SockMatch : "NULL");
1144
1145 #if defined(SYSV) && !defined(ISC)
1146 if (uname(&utsnam) == -1)
1147 Panic(errno, "uname");
1148 strncpy(HostName, utsnam.nodename, sizeof(utsnam.nodename) < MAXSTR ? sizeof(utsnam.nodename) : MAXSTR - 1);
1149 HostName[sizeof(utsnam.nodename) < MAXSTR ? sizeof(utsnam.nodename) : MAXSTR - 1] = '\0';
1150 #else
1151 (void) gethostname(HostName, MAXSTR);
1152 HostName[MAXSTR - 1] = '\0';
1153 #endif
1154 if ((ap = index(HostName, '.')) != NULL)
1155 *ap = '\0';
1156
1157 if (lsflag)
1158 {
1159 int i, fo, oth;
1160
1161 #ifdef MULTIUSER
1162 if (multi)
1163 real_uid = multi_uid;
1164 #endif
1165 SET_GUID();
1166 i = FindSocket((int *)NULL, &fo, &oth, SockMatch);
1167 if (quietflag)
1168 exit(8 + (fo ? ((oth || i) ? 2 : 1) : 0) + i);
1169 if (fo == 0)
1170 Panic(0, "No Sockets found in %s.\n", SockPath);
1171 Panic(0, "%d Socket%s in %s.\n", fo, fo > 1 ? "s" : "", SockPath);
1172 /* NOTREACHED */
1173 }
1174 signal(SIG_BYE, AttacherFinit); /* prevent races */
1175 if (cmdflag)
1176 {
1177 /* attach_tty is not mandatory */
1178 SET_TTYNAME(0);
1179 if (!*av)
1180 Panic(0, "Please specify a command.");
1181 SET_GUID();
1182 SendCmdMessage(sty, SockMatch, av, queryflag >= 0);
1183 exit(0);
1184 }
1185 else if (rflag || xflag)
1186 {
1187 debug("screen -r: - is there anybody out there?\n");
1188 if (Attach(MSG_ATTACH))
1189 {
1190 Attacher();
1191 /* NOTREACHED */
1192 }
1193 #ifdef MULTIUSER
1194 if (multiattach)
1195 Panic(0, "Can't create sessions of other users.");
1196 #endif
1197 debug("screen -r: backend not responding -- still crying\n");
1198 }
1199 else if (dflag && !mflag)
1200 {
1201 SET_TTYNAME(0);
1202 Attach(MSG_DETACH);
1203 Msg(0, "[%s %sdetached.]\n", SockName, (dflag > 1 ? "power " : ""));
1204 eexit(0);
1205 /* NOTREACHED */
1206 }
1207 if (!SockMatch && !mflag && sty)
1208 {
1209 /* attach_tty is not mandatory */
1210 SET_TTYNAME(0);
1211 SET_GUID();
1212 nwin_options.args = av;
1213 SendCreateMsg(sty, &nwin);
1214 exit(0);
1215 /* NOTREACHED */
1216 }
1217 nwin_compose(&nwin_default, &nwin_options, &nwin_default);
1218
1219 if (!detached || dflag != 2)
1220 MasterPid = fork();
1221 else
1222 MasterPid = 0;
1223
1224 switch (MasterPid)
1225 {
1226 case -1:
1227 Panic(errno, "fork");
1228 /* NOTREACHED */
1229 case 0:
1230 break;
1231 default:
1232 if (detached)
1233 exit(0);
1234 if (SockMatch)
1235 sprintf(socknamebuf, "%d.%s", MasterPid, SockMatch);
1236 else
1237 sprintf(socknamebuf, "%d.%s.%s", MasterPid, stripdev(attach_tty), HostName);
1238 for (ap = socknamebuf; *ap; ap++)
1239 if (*ap == '/')
1240 *ap = '-';
1241 #ifdef NAME_MAX
1242 if (strlen(socknamebuf) > NAME_MAX)
1243 socknamebuf[NAME_MAX] = 0;
1244 #endif
1245 sprintf(SockPath + strlen(SockPath), "/%s", socknamebuf);
1246 SET_GUID();
1247 Attacher();
1248 /* NOTREACHED */
1249 }
1250
1251 if (!detached)
1252 PanicPid = getppid();
1253
1254 if (DefaultEsc == -1)
1255 DefaultEsc = Ctrl('a');
1256 if (DefaultMetaEsc == -1)
1257 DefaultMetaEsc = 'a';
1258
1259 ap = av0 + strlen(av0) - 1;
1260 while (ap >= av0)
1261 {
1262 if (!strncmp("screen", ap, 6))
1263 {
1264 strncpy(ap, "SCREEN", 6); /* name this process "SCREEN-BACKEND" */
1265 break;
1266 }
1267 ap--;
1268 }
1269 if (ap < av0)
1270 *av0 = 'S';
1271
1272 #ifdef DEBUG
1273 {
1274 char buf[256];
1275
1276 if (dfp && dfp != stderr)
1277 fclose(dfp);
1278 sprintf(buf, "%s/SCREEN.%d", DEBUGDIR, (int)getpid());
1279 if ((dfp = fopen(buf, "w")) == NULL)
1280 dfp = stderr;
1281 else
1282 (void) chmod(buf, 0666);
1283 }
1284 #endif
1285 if (!detached)
1286 {
1287 if (attach_fd == -1)
1288 {
1289 if ((n = secopen(attach_tty, O_RDWR, 0)) < 0)
1290 Panic(0, "Cannot reopen '%s' - please check.", attach_tty);
1291 }
1292 else
1293 n = dup(attach_fd);
1294 }
1295 else
1296 n = -1;
1297 freopen("/dev/null", "r", stdin);
1298 freopen("/dev/null", "w", stdout);
1299
1300 #ifdef DEBUG
1301 if (dfp != stderr)
1302 #endif
1303 freopen("/dev/null", "w", stderr);
1304 debug("-- screen.back debug started\n");
1305
1306 /*
1307 * This guarantees that the session owner is listed, even when we
1308 * start detached. From now on we should not refer to 'LoginName'
1309 * any more, use users->u_name instead.
1310 */
1311 if (UserAdd(LoginName, (char *)0, (struct acluser **)0) < 0)
1312 Panic(0, "Could not create user info");
1313 if (!detached)
1314 {
1315 if (MakeDisplay(LoginName, attach_tty, attach_term, n, getppid(), &attach_Mode) == 0)
1316 Panic(0, "Could not alloc display");
1317 PanicPid = 0;
1318 #ifdef ENCODINGS
1319 D_encoding = nwin_options.encoding > 0 ? nwin_options.encoding : 0;
1320 debug1("D_encoding = %d\n", D_encoding);
1321 #endif
1322 }
1323
1324 if (SockMatch)
1325 {
1326 /* user started us with -S option */
1327 sprintf(socknamebuf, "%d.%s", (int)getpid(), SockMatch);
1328 }
1329 else
1330 {
1331 sprintf(socknamebuf, "%d.%s.%s", (int)getpid(), stripdev(attach_tty),
1332 HostName);
1333 }
1334 for (ap = socknamebuf; *ap; ap++)
1335 if (*ap == '/')
1336 *ap = '-';
1337 #ifdef NAME_MAX
1338 if (strlen(socknamebuf) > NAME_MAX)
1339 {
1340 debug2("Socketname %s truncated to %d chars\n", socknamebuf, NAME_MAX);
1341 socknamebuf[NAME_MAX] = 0;
1342 }
1343 #endif
1344 sprintf(SockPath + strlen(SockPath), "/%s", socknamebuf);
1345
1346 ServerSocket = MakeServerSocket();
1347 InitKeytab();
1348 #ifdef ETCSCREENRC
1349 # ifdef ALLOW_SYSSCREENRC
1350 if ((ap = getenv("SYSSCREENRC")))
1351 (void)StartRc(ap, 0);
1352 else
1353 # endif
1354 (void)StartRc(ETCSCREENRC, 0);
1355 #endif
1356 (void)StartRc(RcFileName, 0);
1357 # ifdef UTMPOK
1358 # ifndef UTNOKEEP
1359 InitUtmp();
1360 # endif /* UTNOKEEP */
1361 # endif /* UTMPOK */
1362 if (display)
1363 {
1364 if (InitTermcap(0, 0))
1365 {
1366 debug("Could not init termcap - exiting\n");
1367 fcntl(D_userfd, F_SETFL, 0); /* Flush sets FNBLOCK */
1368 freetty();
1369 if (D_userpid)
1370 Kill(D_userpid, SIG_BYE);
1371 eexit(1);
1372 }
1373 MakeDefaultCanvas();
1374 InitTerm(0);
1375 #ifdef UTMPOK
1376 RemoveLoginSlot();
1377 #endif
1378 }
1379 else
1380 MakeTermcap(1);
1381 #ifdef LOADAV
1382 InitLoadav();
1383 #endif /* LOADAV */
1384 MakeNewEnv();
1385 signal(SIGHUP, SigHup);
1386 signal(SIGINT, FinitHandler);
1387 signal(SIGQUIT, FinitHandler);
1388 signal(SIGTERM, FinitHandler);
1389 #ifdef BSDJOBS
1390 signal(SIGTTIN, SIG_IGN);
1391 signal(SIGTTOU, SIG_IGN);
1392 #endif
1393
1394 if (display)
1395 {
1396 brktty(D_userfd);
1397 SetMode(&D_OldMode, &D_NewMode, D_flow, iflag);
1398 /* Note: SetMode must be called _before_ FinishRc. */
1399 SetTTY(D_userfd, &D_NewMode);
1400 if (fcntl(D_userfd, F_SETFL, FNBLOCK))
1401 Msg(errno, "Warning: NBLOCK fcntl failed");
1402 }
1403 else
1404 brktty(-1); /* just try */
1405 signal(SIGCHLD, SigChld);
1406 #ifdef ETCSCREENRC
1407 # ifdef ALLOW_SYSSCREENRC
1408 if ((ap = getenv("SYSSCREENRC")))
1409 FinishRc(ap);
1410 else
1411 # endif
1412 FinishRc(ETCSCREENRC);
1413 #endif
1414 FinishRc(RcFileName);
1415
1416 debug2("UID %d EUID %d\n", (int)getuid(), (int)geteuid());
1417 if (windows == NULL)
1418 {
1419 debug("We open one default window, as screenrc did not specify one.\n");
1420 if (MakeWindow(&nwin) == -1)
1421 {
1422 fd_set rfd;
1423 struct timeval tv = { MsgWait/1000, 1000*(MsgWait%1000) };
1424 FD_SET(0, &rfd);
1425
1426 Msg(0, "Sorry, could not find a PTY or TTY.");
1427 // allow user to exit early by pressing any key.
1428 select(1, &rfd, NULL, NULL, &tv);
1429 Finit(0);
1430 /* NOTREACHED */
1431 }
1432 }
1433 else if (ac) /* Screen was invoked with a command */
1434 {
1435 MakeWindow(&nwin);
1436 }
1437
1438 #ifdef HAVE_BRAILLE
1439 StartBraille();
1440 #endif
1441
1442 if (display && default_startup)
1443 display_copyright();
1444 signal(SIGINT, SigInt);
1445 if (rflag && (rflag & 1) == 0 && !quietflag)
1446 {
1447 Msg(0, "New screen...");
1448 rflag = 0;
1449 }
1450
1451 serv_read.type = EV_READ;
1452 serv_read.fd = ServerSocket;
1453 serv_read.handler = serv_read_fn;
1454 evenq(&serv_read);
1455
1456 serv_select.pri = -10;
1457 serv_select.type = EV_ALWAYS;
1458 serv_select.handler = serv_select_fn;
1459 evenq(&serv_select);
1460
1461 logflushev.type = EV_TIMEOUT;
1462 logflushev.handler = logflush_fn;
1463
1464 sched();
1465 /* NOTREACHED */
1466 return 0;
1467 }
1468
1469 void
1470 WindowDied(p, wstat, wstat_valid)
1471 struct win *p;
1472 #ifdef BSDWAIT
1473 union wait wstat;
1474 #else
1475 int wstat;
1476 #endif
1477 int wstat_valid;
1478 {
1479 int killit = 0;
1480
1481 if (p->w_destroyev.data == (char *)p)
1482 {
1483 wstat = p->w_exitstatus;
1484 wstat_valid = 1;
1485 evdeq(&p->w_destroyev);
1486 p->w_destroyev.data = 0;
1487 }
1488
1489 #if defined(BSDJOBS) && !defined(BSDWAIT)
1490 if (!wstat_valid && p->w_pid > 0)
1491 {
1492 /* EOF on file descriptor. The process is probably also dead.
1493 * try a waitpid */
1494 if (waitpid(p->w_pid, &wstat, WNOHANG | WUNTRACED) == p->w_pid)
1495 {
1496 p->w_pid = 0;
1497 wstat_valid = 1;
1498 }
1499 }
1500 #endif
1501 if (ZombieKey_destroy && ZombieKey_onerror && wstat_valid &&
1502 WIFEXITED(wstat) && WEXITSTATUS(wstat) == 0)
1503 killit = 1;
1504
1505 if (ZombieKey_destroy && !killit)
1506 {
1507 char buf[100], *s, reason[100];
1508 time_t now;
1509
1510 if (wstat_valid) {
1511 if (WIFEXITED(wstat))
1512 if (WEXITSTATUS(wstat))
1513 sprintf(reason, "terminated with exit status %d", WEXITSTATUS(wstat));
1514 else
1515 sprintf(reason, "terminated normally");
1516 else if (WIFSIGNALED(wstat))
1517 sprintf(reason, "terminated with signal %d%s", WTERMSIG(wstat),
1518 #ifdef WCOREDUMP
1519 WCOREDUMP(wstat) ? " (core file generated)" : "");
1520 #else
1521 "");
1522 #endif
1523 } else
1524 sprintf(reason, "detached from window");
1525
1526 (void) time(&now);
1527 s = ctime(&now);
1528 if (s && *s)
1529 s[strlen(s) - 1] = '\0';
1530 debug3("window %d (%s) going into zombie state fd %d",
1531 p->w_number, p->w_title, p->w_ptyfd);
1532 #ifdef UTMPOK
1533 if (p->w_slot != (slot_t)0 && p->w_slot != (slot_t)-1)
1534 {
1535 RemoveUtmp(p);
1536 p->w_slot = 0; /* "detached" */
1537 }
1538 #endif
1539 CloseDevice(p);
1540
1541 p->w_deadpid = p->w_pid;
1542 p->w_pid = 0;
1543 ResetWindow(p);
1544 /* p->w_y = p->w_bot; */
1545 p->w_y = MFindUsedLine(p, p->w_bot, 1);
1546 sprintf(buf, "\n\r=== Command %s (%s) ===", reason, s ? s : "?");
1547 WriteString(p, buf, strlen(buf));
1548 WindowChanged(p, 'f');
1549 }
1550 else
1551 KillWindow(p);
1552 #ifdef UTMPOK
1553 CarefulUtmp();
1554 #endif
1555 }
1556
1557 static void
1558 SigChldHandler()
1559 {
1560 struct stat st;
1561 #ifdef DEBUG
1562 fds();
1563 #endif
1564 while (GotSigChld)
1565 {
1566 GotSigChld = 0;
1567 DoWait();
1568 #ifdef SYSVSIGS
1569 signal(SIGCHLD, SigChld);
1570 #endif
1571 }
1572 if (stat(SockPath, &st) == -1)
1573 {
1574 debug1("SigChldHandler: Yuck! cannot stat '%s'\n", SockPath);
1575 if (!RecoverSocket())
1576 {
1577 debug("SCREEN cannot recover from corrupt Socket, bye\n");
1578 Finit(1);
1579 }
1580 else
1581 debug1("'%s' reconstructed\n", SockPath);
1582 }
1583 else
1584 debug2("SigChldHandler: stat '%s' o.k. (%03o)\n", SockPath, (int)st.st_mode);
1585 }
1586
1587 static sigret_t
1588 SigChld SIGDEFARG
1589 {
1590 debug("SigChld()\n");
1591 GotSigChld = 1;
1592 SIGRETURN;
1593 }
1594
1595 sigret_t
1596 SigHup SIGDEFARG
1597 {
1598 /* Hangup all displays */
1599 while ((display = displays) != 0)
1600 Hangup();
1601 SIGRETURN;
1602 }
1603
1604 /*
1605 * the backend's Interrupt handler
1606 * we cannot insert the intrc directly, as we never know
1607 * if fore is valid.
1608 */
1609 static sigret_t
1610 SigInt SIGDEFARG
1611 {
1612 #if HAZARDOUS
1613 char ibuf;
1614
1615 debug("SigInt()\n");
1616 if (fore && displays)
1617 {
1618 # if defined(TERMIO) || defined(POSIX)
1619 ibuf = displays->d_OldMode.tio.c_cc[VINTR];
1620 # else
1621 ibuf = displays->d_OldMode.m_tchars.t_intrc;
1622 # endif
1623 fore->w_inlen = 0;
1624 write(fore->w_ptyfd, &ibuf, 1);
1625 }
1626 #else
1627 signal(SIGINT, SigInt);
1628 debug("SigInt() careful\n");
1629 InterruptPlease = 1;
1630 #endif
1631 SIGRETURN;
1632 }
1633
1634 static sigret_t
1635 CoreDump SIGDEFARG
1636 {
1637 /* if running with s-bit, we must reset the s-bit, so that we get a
1638 * core file anyway.
1639 */
1640
1641 struct display *disp;
1642 char buf[80];
1643
1644 char *dump_msg = " (core dumped)";
1645
1646 int running_w_s_bit = getuid() != geteuid();
1647 #if defined(SHADOWPW) && !defined(DEBUG) && !defined(DUMPSHADOW)
1648 if (running_w_s_bit)
1649 dump_msg = "";
1650 #endif
1651
1652 #if defined(SYSVSIGS) && defined(SIGHASARG)
1653 signal(sigsig, SIG_IGN);
1654 #endif
1655 setgid(getgid());
1656 setuid(getuid());
1657 unlink("core");
1658
1659 #ifdef SIGHASARG
1660 sprintf(buf, "\r\n[screen caught signal %d.%s]\r\n", sigsig, dump_msg);
1661 #else
1662 sprintf(buf, "\r\n[screen caught a fatal signal.%s]\r\n", dump_msg);
1663 #endif
1664
1665 for (disp = displays; disp; disp = disp->d_next)
1666 {
1667 if (disp->d_nonblock < -1 || disp->d_nonblock > 1000000)
1668 continue;
1669 fcntl(disp->d_userfd, F_SETFL, 0);
1670 SetTTY(disp->d_userfd, &D_OldMode);
1671 write(disp->d_userfd, buf, strlen(buf));
1672 Kill(disp->d_userpid, SIG_BYE);
1673 }
1674
1675 if (running_w_s_bit)
1676 {
1677 #if defined(SHADOWPW) && !defined(DEBUG) && !defined(DUMPSHADOW)
1678 Kill(getpid(), SIGKILL);
1679 eexit(11);
1680 #else /* SHADOWPW && !DEBUG */
1681 abort();
1682 #endif /* SHADOWPW && !DEBUG */
1683 }
1684 else
1685 abort();
1686 SIGRETURN;
1687 }
1688
1689 static void
1690 DoWait()
1691 {
1692 register int pid;
1693 struct win *p, *next;
1694 #ifdef BSDWAIT
1695 union wait wstat;
1696 #else
1697 int wstat;
1698 #endif
1699
1700 #ifdef BSDJOBS
1701 # ifndef BSDWAIT
1702 while ((pid = waitpid(-1, &wstat, WNOHANG | WUNTRACED)) > 0)
1703 # else
1704 # ifdef USE_WAIT2
1705 /*
1706 * From: rouilj@sni-usa.com (John Rouillard)
1707 * note that WUNTRACED is not documented to work, but it is defined in
1708 * /usr/include/sys/wait.h, so it may work
1709 */
1710 while ((pid = wait2(&wstat, WNOHANG | WUNTRACED )) > 0)
1711 # else /* USE_WAIT2 */
1712 while ((pid = wait3(&wstat, WNOHANG | WUNTRACED, (struct rusage *) 0)) > 0)
1713 # endif /* USE_WAIT2 */
1714 # endif
1715 #else /* BSDJOBS */
1716 while ((pid = wait(&wstat)) < 0)
1717 if (errno != EINTR)
1718 break;
1719 if (pid > 0)
1720 #endif /* BSDJOBS */
1721 {
1722 for (p = windows; p; p = next)
1723 {
1724 next = p->w_next;
1725 if ( (p->w_pid && pid == p->w_pid) ||
1726 (p->w_deadpid && pid == p->w_deadpid) )
1727 {
1728 /* child has ceased to exist */
1729 p->w_pid = 0;
1730
1731 #ifdef BSDJOBS
1732 if (WIFSTOPPED(wstat))
1733 {
1734 debug3("Window %d pid %d: WIFSTOPPED (sig %d)\n", p->w_number, pid, WSTOPSIG(wstat));
1735 #ifdef SIGTTIN
1736 if (WSTOPSIG(wstat) == SIGTTIN)
1737 {
1738 Msg(0, "Suspended (tty input)");
1739 continue;
1740 }
1741 #endif
1742 #ifdef SIGTTOU
1743 if (WSTOPSIG(wstat) == SIGTTOU)
1744 {
1745 Msg(0, "Suspended (tty output)");
1746 continue;
1747 }
1748 #endif
1749 /* Try to restart process */
1750 Msg(0, "Child has been stopped, restarting.");
1751 if (killpg(pid, SIGCONT))
1752 kill(pid, SIGCONT);
1753 }
1754 else
1755 #endif
1756 {
1757 /* Screen will detect the window has died when the window's
1758 * file descriptor signals EOF (which it will do when the process in
1759 * the window terminates). So do this in a timeout of 10 seconds.
1760 * (not doing this at all might also work)
1761 * See #27061 for more details.
1762 */
1763 p->w_destroyev.data = (char *)p;
1764 p->w_exitstatus = wstat;
1765 SetTimeout(&p->w_destroyev, 10 * 1000);
1766 evenq(&p->w_destroyev);
1767 }
1768 break;
1769 }
1770 #ifdef PSEUDOS
1771 if (p->w_pwin && pid == p->w_pwin->p_pid)
1772 {
1773 debug2("pseudo of win Nr %d died. pid == %d\n", p->w_number, p->w_pwin->p_pid);
1774 FreePseudowin(p);
1775 break;
1776 }
1777 #endif
1778 }
1779 if (p == 0)
1780 {
1781 debug1("pid %d not found - hope that's ok\n", pid);
1782 }
1783 }
1784 }
1785
1786
1787 static sigret_t
1788 FinitHandler SIGDEFARG
1789 {
1790 #ifdef SIGHASARG
1791 debug1("FinitHandler called, sig %d.\n", sigsig);
1792 #else
1793 debug("FinitHandler called.\n");
1794 #endif
1795 Finit(1);
1796 SIGRETURN;
1797 }
1798
1799 void
1800 Finit(i)
1801 int i;
1802 {
1803 signal(SIGCHLD, SIG_DFL);
1804 signal(SIGHUP, SIG_IGN);
1805 debug1("Finit(%d);\n", i);
1806 while (windows)
1807 {
1808 struct win *p = windows;
1809 windows = windows->w_next;
1810 FreeWindow(p);
1811 }
1812 if (ServerSocket != -1)
1813 {
1814 debug1("we unlink(%s)\n", SockPath);
1815 #ifdef USE_SETEUID
1816 xseteuid(real_uid);
1817 xsetegid(real_gid);
1818 #endif
1819 (void) unlink(SockPath);
1820 #ifdef USE_SETEUID
1821 xseteuid(eff_uid);
1822 xsetegid(eff_gid);
1823 #endif
1824 }
1825 for (display = displays; display; display = display->d_next)
1826 {
1827 if (D_status)
1828 RemoveStatus();
1829 FinitTerm();
1830 #ifdef UTMPOK
1831 RestoreLoginSlot();
1832 #endif
1833 AddStr("[screen is terminating]\r\n");
1834 Flush(3);
1835 SetTTY(D_userfd, &D_OldMode);
1836 fcntl(D_userfd, F_SETFL, 0);
1837 freetty();
1838 Kill(D_userpid, SIG_BYE);
1839 }
1840 /*
1841 * we _cannot_ call eexit(i) here,
1842 * instead of playing with the Socket above. Sigh.
1843 */
1844 exit(i);
1845 }
1846
1847 void
1848 eexit(e)
1849 int e;
1850 {
1851 debug("eexit\n");
1852 if (ServerSocket != -1)
1853 {
1854 debug1("we unlink(%s)\n", SockPath);
1855 setgid(real_gid);
1856 setuid(real_uid);
1857 (void) unlink(SockPath);
1858 }
1859 exit(e);
1860 }
1861
1862 void
1863 Hangup()
1864 {
1865 if (display == 0)
1866 return;
1867 debug1("Hangup %x\n", display);
1868 if (D_userfd >= 0)
1869 {
1870 close(D_userfd);
1871 D_userfd = -1;
1872 }
1873 if (auto_detach || displays->d_next)
1874 Detach(D_HANGUP);
1875 else
1876 Finit(0);
1877 }
1878
1879 /*
1880 * Detach now has the following modes:
1881 *D_DETACH SIG_BYE detach backend and exit attacher
1882 *D_HANGUP SIG_BYE detach backend and exit attacher
1883 *D_STOP SIG_STOP stop attacher (and detach backend)
1884 *D_REMOTE SIG_BYE remote detach -- reattach to new attacher
1885 *D_POWER SIG_POWER_BYE power detach -- attacher kills his parent
1886 *D_REMOTE_POWER SIG_POWER_BYE remote power detach -- both
1887 *D_LOCK SIG_LOCK lock the attacher
1888 * (jw)
1889 * we always remove our utmp slots. (even when "lock" or "stop")
1890 * Note: Take extra care here, we may be called by interrupt!
1891 */
1892 void
1893 Detach(mode)
1894 int mode;
1895 {
1896 int sign = 0, pid;
1897 struct canvas *cv;
1898 struct win *p;
1899
1900 if (display == 0)
1901 return;
1902
1903 #define AddStrSock(msg) do { \
1904 if (SockName) \
1905 { \
1906 AddStr("[" msg " from "); \
1907 AddStr(SockName); \
1908 AddStr("]\r\n"); \
1909 } \
1910 else \
1911 AddStr("[" msg "]\r\n"); \
1912 } while (0)
1913
1914 signal(SIGHUP, SIG_IGN);
1915 debug1("Detach(%d)\n", mode);
1916 if (D_status)
1917 RemoveStatus();
1918 FinitTerm();
1919 if (!display)
1920 return;
1921 switch (mode)
1922 {
1923 case D_HANGUP:
1924 sign = SIG_BYE;
1925 break;
1926 case D_DETACH:
1927 AddStrSock("detached");
1928 sign = SIG_BYE;
1929 break;
1930 #ifdef BSDJOBS
1931 case D_STOP:
1932 sign = SIG_STOP;
1933 break;
1934 #endif
1935 #ifdef REMOTE_DETACH
1936 case D_REMOTE:
1937 AddStrSock("remote detached");
1938 sign = SIG_BYE;
1939 break;
1940 #endif
1941 #ifdef POW_DETACH
1942 case D_POWER:
1943 AddStrSock("power detached");
1944 if (PowDetachString)
1945 {
1946 AddStr(PowDetachString);
1947 AddStr("\r\n");
1948 }
1949 sign = SIG_POWER_BYE;
1950 break;
1951 #ifdef REMOTE_DETACH
1952 case D_REMOTE_POWER:
1953 AddStrSock("remote power detached");
1954 if (PowDetachString)
1955 {
1956 AddStr(PowDetachString);
1957 AddStr("\r\n");
1958 }
1959 sign = SIG_POWER_BYE;
1960 break;
1961 #endif
1962 #endif
1963 case D_LOCK:
1964 ClearAll();
1965 sign = SIG_LOCK;
1966 /* tell attacher to lock terminal with a lockprg. */
1967 break;
1968 }
1969 #ifdef UTMPOK
1970 if (displays->d_next == 0)
1971 {
1972 for (p = windows; p; p = p->w_next)
1973 {
1974 if (p->w_slot != (slot_t) -1 && !(p->w_lflag & 2))
1975 {
1976 RemoveUtmp(p);
1977 /*
1978 * Set the slot to 0 to get the window
1979 * logged in again.
1980 */
1981 p->w_slot = (slot_t) 0;
1982 }
1983 }
1984 }
1985 if (mode != D_HANGUP)
1986 RestoreLoginSlot();
1987 #endif
1988 if (displays->d_next == 0 && console_window)
1989 {
1990 if (TtyGrabConsole(console_window->w_ptyfd, 0, "detach"))
1991 {
1992 debug("could not release console - killing window\n");
1993 KillWindow(console_window);
1994 display = displays; /* restore display */
1995 }
1996 }
1997 if (D_fore)
1998 {
1999 #ifdef MULTIUSER
2000 ReleaseAutoWritelock(display, D_fore);
2001 #endif
2002 D_user->u_detachwin = D_fore->w_number;
2003 D_user->u_detachotherwin = D_other ? D_other->w_number : -1;
2004 }
2005 AutosaveLayout(D_layout);
2006 layout_last = D_layout;
2007 for (cv = D_cvlist; cv; cv = cv->c_next)
2008 {
2009 p = Layer2Window(cv->c_layer);
2010 SetCanvasWindow(cv, 0);
2011 if (p)
2012 WindowChanged(p, 'u');
2013 }
2014
2015 pid = D_userpid;
2016 debug2("display: %#x displays: %#x\n", (unsigned int)display, (unsigned int)displays);
2017 FreeDisplay();
2018 if (displays == 0)
2019 /* Flag detached-ness */
2020 (void) chsock();
2021 /*
2022 * tell father what to do. We do that after we
2023 * freed the tty, thus getty feels more comfortable on hpux
2024 * if it was a power detach.
2025 */
2026 Kill(pid, sign);
2027 debug2("Detach: Signal %d to Attacher(%d)!\n", sign, pid);
2028 debug("Detach returns, we are successfully detached.\n");
2029 signal(SIGHUP, SigHup);
2030 #undef AddStrSock
2031 }
2032
2033 static int
2034 IsSymbol(e, s)
2035 char *e, *s;
2036 {
2037 register int l;
2038
2039 l = strlen(s);
2040 return strncmp(e, s, l) == 0 && e[l] == '=';
2041 }
2042
2043 void
2044 MakeNewEnv()
2045 {
2046 register char **op, **np;
2047 static char stybuf[MAXSTR];
2048
2049 for (op = environ; *op; ++op)
2050 ;
2051 if (NewEnv)
2052 free((char *)NewEnv);
2053 NewEnv = np = (char **) malloc((unsigned) (op - environ + 7 + 1) * sizeof(char **));
2054 if (!NewEnv)
2055 Panic(0, "%s", strnomem);
2056 sprintf(stybuf, "STY=%s", strlen(SockName) <= MAXSTR - 5 ? SockName : "?");
2057 *np++ = stybuf; /* NewEnv[0] */
2058 *np++ = Term; /* NewEnv[1] */
2059 np++; /* room for SHELL */
2060 #ifdef TIOCSWINSZ
2061 np += 2; /* room for TERMCAP and WINDOW */
2062 #else
2063 np += 4; /* room for TERMCAP WINDOW LINES COLUMNS */
2064 #endif
2065
2066 for (op = environ; *op; ++op)
2067 {
2068 if (!IsSymbol(*op, "TERM") && !IsSymbol(*op, "TERMCAP")
2069 && !IsSymbol(*op, "STY") && !IsSymbol(*op, "WINDOW")
2070 && !IsSymbol(*op, "SCREENCAP") && !IsSymbol(*op, "SHELL")
2071 && !IsSymbol(*op, "LINES") && !IsSymbol(*op, "COLUMNS")
2072 )
2073 *np++ = *op;
2074 }
2075 *np = 0;
2076 }
2077
2078 #if defined(USEVARARGS) && defined(__STDC__)
2079 #define DEFINE_VARARGS_FN(fnname) void fnname (int err, const char *fmt, VA_DOTS)
2080 #else
2081 #define DEFINE_VARARGS_FN(fnname) void fnname(err, fmt, VA_DOTS) \
2082 int err; \
2083 const char *fmt; \
2084 VA_DECL
2085 #endif
2086
2087 #define PROCESS_MESSAGE(B) do { \
2088 char *p = B; \
2089 VA_LIST(ap) \
2090 VA_START(ap, fmt); \
2091 fmt = DoNLS(fmt); \
2092 (void)vsnprintf(p, sizeof(B) - 100, fmt, VA_ARGS(ap)); \
2093 VA_END(ap); \
2094 if (err) \
2095 { \
2096 p += strlen(p); \
2097 *p++ = ':'; \
2098 *p++ = ' '; \
2099 strncpy(p, strerror(err), B + sizeof(B) - p - 1); \
2100 B[sizeof(B) - 1] = 0; \
2101 } \
2102 } while (0)
2103
2104 DEFINE_VARARGS_FN(Msg)
2105 {
2106 char buf[MAXPATHLEN*2];
2107 PROCESS_MESSAGE(buf);
2108
2109 debug2("Msg('%s') (%#x);\n", buf, (unsigned int)display);
2110
2111 if (display && displays)
2112 MakeStatus(buf);
2113 else if (displays)
2114 {
2115 for (display = displays; display; display = display->d_next)
2116 MakeStatus(buf);
2117 }
2118 else if (display)
2119 {
2120 /* no displays but a display - must have forked.
2121 * send message to backend!
2122 */
2123 char *tty = D_usertty;
2124 struct display *olddisplay = display;
2125 display = 0; /* only send once */
2126 SendErrorMsg(tty, buf);
2127 display = olddisplay;
2128 }
2129 else
2130 printf("%s\r\n", buf);
2131
2132 if (queryflag >= 0)
2133 write(queryflag, buf, strlen(buf));
2134 }
2135
2136 /*
2137 * Call FinitTerm for all displays, write a message to each and call eexit();
2138 */
2139 DEFINE_VARARGS_FN(Panic)
2140 {
2141 char buf[MAXPATHLEN*2];
2142 PROCESS_MESSAGE(buf);
2143
2144 debug3("Panic('%s'); display=%x displays=%x\n", buf, display, displays);
2145 if (displays == 0 && display == 0)
2146 {
2147 printf("%s\r\n", buf);
2148 if (PanicPid)
2149 Kill(PanicPid, SIG_BYE);
2150 }
2151 else if (displays == 0)
2152 {
2153 /* no displays but a display - must have forked.
2154 * send message to backend!
2155 */
2156 char *tty = D_usertty;
2157 display = 0;
2158 SendErrorMsg(tty, buf);
2159 sleep(2);
2160 _exit(1);
2161 }
2162 else
2163 for (display = displays; display; display = display->d_next)
2164 {
2165 if (D_status)
2166 RemoveStatus();
2167 FinitTerm();
2168 Flush(3);
2169 #ifdef UTMPOK
2170 RestoreLoginSlot();
2171 #endif
2172 SetTTY(D_userfd, &D_OldMode);
2173 fcntl(D_userfd, F_SETFL, 0);
2174 write(D_userfd, buf, strlen(buf));
2175 write(D_userfd, "\n", 1);
2176 freetty();
2177 if (D_userpid)
2178 Kill(D_userpid, SIG_BYE);
2179 }
2180 #ifdef MULTIUSER
2181 if (tty_oldmode >= 0)
2182 {
2183 # ifdef USE_SETEUID
2184 if (setuid(own_uid))
2185 xseteuid(own_uid); /* may be a loop. sigh. */
2186 # else
2187 setuid(own_uid);
2188 # endif
2189 debug1("Panic: changing back modes from %s\n", attach_tty);
2190 chmod(attach_tty, tty_oldmode);
2191 }
2192 #endif
2193 eexit(1);
2194 }
2195
2196 DEFINE_VARARGS_FN(QueryMsg)
2197 {
2198 char buf[MAXPATHLEN*2];
2199
2200 if (queryflag < 0)
2201 return;
2202
2203 PROCESS_MESSAGE(buf);
2204 write(queryflag, buf, strlen(buf));
2205 }
2206
2207 DEFINE_VARARGS_FN(Dummy)
2208 {}
2209
2210 #undef PROCESS_MESSAGE
2211 #undef DEFINE_VARARGS_FN
2212
2213 /*
2214 * '^' is allowed as an escape mechanism for control characters. jw.
2215 *
2216 * Added time insertion using ideas/code from /\ndy Jones
2217 * (andy@lingua.cltr.uq.OZ.AU) - thanks a lot!
2218 *
2219 */
2220
2221 #ifndef USE_LOCALE
2222 static const char days[] = "SunMonTueWedThuFriSat";
2223 static const char months[] = "JanFebMarAprMayJunJulAugSepOctNovDec";
2224 #endif
2225
2226 static char winmsg_buf[MAXSTR];
2227 #define MAX_WINMSG_REND 256 /* rendition changes */
2228 static int winmsg_rend[MAX_WINMSG_REND];
2229 static int winmsg_rendpos[MAX_WINMSG_REND];
2230 static int winmsg_numrend;
2231
2232 static char *
2233 pad_expand(buf, p, numpad, padlen)
2234 char *buf;
2235 char *p;
2236 int numpad;
2237 int padlen;
2238 {
2239 char *pn, *pn2;
2240 int i, r;
2241
2242 padlen = padlen - (p - buf); /* space for rent */
2243 if (padlen < 0)
2244 padlen = 0;
2245 pn2 = pn = p + padlen;
2246 r = winmsg_numrend;
2247 while (p >= buf)
2248 {
2249 if (r && *p != 127 && p - buf == winmsg_rendpos[r - 1])
2250 {
2251 winmsg_rendpos[--r] = pn - buf;
2252 continue;
2253 }
2254 *pn-- = *p;
2255 if (*p-- == 127)
2256 {
2257 pn[1] = ' ';
2258 i = numpad > 0 ? (padlen + numpad - 1) / numpad : 0;
2259 padlen -= i;
2260 while (i-- > 0)
2261 *pn-- = ' ';
2262 numpad--;
2263 if (r && p - buf == winmsg_rendpos[r - 1])
2264 winmsg_rendpos[--r] = pn - buf;
2265 }
2266 }
2267 return pn2;
2268 }
2269
2270 struct backtick {
2271 struct backtick *next;
2272 int num;
2273 int tick;
2274 int lifespan;
2275 time_t bestbefore;
2276 char result[MAXSTR];
2277 char **cmdv;
2278 struct event ev;
2279 char *buf;
2280 int bufi;
2281 };
2282
2283 struct backtick *backticks;
2284
2285 static void
2286 backtick_filter(bt)
2287 struct backtick *bt;
2288 {
2289 char *p, *q;
2290 int c;
2291
2292 for (p = q = bt->result; (c = (unsigned char)*p++) != 0;)
2293 {
2294 if (c == '\t')
2295 c = ' ';
2296 if (c >= ' ' || c == '\005')
2297 *q++ = c;
2298 }
2299 *q = 0;
2300 }
2301
2302 static void
2303 backtick_fn(ev, data)
2304 struct event *ev;
2305 char *data;
2306 {
2307 struct backtick *bt;
2308 int i, j, k, l;
2309
2310 bt = (struct backtick *)data;
2311 debug1("backtick_fn for #%d\n", bt->num);
2312 i = bt->bufi;
2313 l = read(ev->fd, bt->buf + i, MAXSTR - i);
2314 if (l <= 0)
2315 {
2316 debug1("EOF on backtick #%d\n", bt->num);
2317 evdeq(ev);
2318 close(ev->fd);
2319 ev->fd = -1;
2320 return;
2321 }
2322 debug1("read %d bytes\n", l);
2323 i += l;
2324 for (j = 0; j < l; j++)
2325 if (bt->buf[i - j - 1] == '\n')
2326 break;
2327 if (j < l)
2328 {
2329 for (k = i - j - 2; k >= 0; k--)
2330 if (bt->buf[k] == '\n')
2331 break;
2332 k++;
2333 bcopy(bt->buf + k, bt->result, i - j - k);
2334 bt->result[i - j - k - 1] = 0;
2335 backtick_filter(bt);
2336 WindowChanged(0, '`');
2337 }
2338 if (j == l && i == MAXSTR)
2339 {
2340 j = MAXSTR/2;
2341 l = j + 1;
2342 }
2343 if (j < l)
2344 {
2345 if (j)
2346 bcopy(bt->buf + i - j, bt->buf, j);
2347 i = j;
2348 }
2349 bt->bufi = i;
2350 }
2351
2352 void
2353 setbacktick(num, lifespan, tick, cmdv)
2354 int num;
2355 int lifespan;
2356 int tick;
2357 char **cmdv;
2358 {
2359 struct backtick **btp, *bt;
2360 char **v;
2361
2362 debug1("setbacktick called for backtick #%d\n", num);
2363 for (btp = &backticks; (bt = *btp) != 0; btp = &bt->next)
2364 if (bt->num == num)
2365 break;
2366 if (!bt && !cmdv)
2367 return;
2368 if (bt)
2369 {
2370 for (v = bt->cmdv; *v; v++)
2371 free(*v);
2372 free(bt->cmdv);
2373 if (bt->buf)
2374 free(bt->buf);
2375 if (bt->ev.fd >= 0)
2376 close(bt->ev.fd);
2377 evdeq(&bt->ev);
2378 }
2379 if (bt && !cmdv)
2380 {
2381 *btp = bt->next;
2382 free(bt);
2383 return;
2384 }
2385 if (!bt)
2386 {
2387 bt = (struct backtick *)malloc(sizeof *bt);
2388 if (!bt)
2389 {
2390 Msg(0, "%s", strnomem);
2391 return;
2392 }
2393 bzero(bt, sizeof(*bt));
2394 bt->next = 0;
2395 *btp = bt;
2396 }
2397 bt->num = num;
2398 bt->tick = tick;
2399 bt->lifespan = lifespan;
2400 bt->bestbefore = 0;
2401 bt->result[0] = 0;
2402 bt->buf = 0;
2403 bt->bufi = 0;
2404 bt->cmdv = cmdv;
2405 bt->ev.fd = -1;
2406 if (bt->tick == 0 && bt->lifespan == 0)
2407 {
2408 debug("setbacktick: continuous mode\n");
2409 bt->buf = (char *)malloc(MAXSTR);
2410 if (bt->buf == 0)
2411 {
2412 Msg(0, "%s", strnomem);
2413 setbacktick(num, 0, 0, (char **)0);
2414 return;
2415 }
2416 bt->ev.type = EV_READ;
2417 bt->ev.fd = readpipe(bt->cmdv);
2418 bt->ev.handler = backtick_fn;
2419 bt->ev.data = (char *)bt;
2420 if (bt->ev.fd >= 0)
2421 evenq(&bt->ev);
2422 }
2423 }
2424
2425 static char *
2426 runbacktick(bt, tickp, now)
2427 struct backtick *bt;
2428 int *tickp;
2429 time_t now;
2430 {
2431 int f, i, l, j;
2432 time_t now2;
2433
2434 debug1("runbacktick called for backtick #%d\n", bt->num);
2435 if (bt->tick && (!*tickp || bt->tick < *tickp))
2436 *tickp = bt->tick;
2437 if ((bt->lifespan == 0 && bt->tick == 0) || now < bt->bestbefore)
2438 {
2439 debug1("returning old result (%d)\n", bt->lifespan);
2440 return bt->result;
2441 }
2442 f = readpipe(bt->cmdv);
2443 if (f == -1)
2444 return bt->result;
2445 i = 0;
2446 while ((l = read(f, bt->result + i, sizeof(bt->result) - i)) > 0)
2447 {
2448 debug1("runbacktick: read %d bytes\n", l);
2449 i += l;
2450 for (j = 1; j < l; j++)
2451 if (bt->result[i - j - 1] == '\n')
2452 break;
2453 if (j == l && i == sizeof(bt->result))
2454 {
2455 j = sizeof(bt->result) / 2;
2456 l = j + 1;
2457 }
2458 if (j < l)
2459 {
2460 bcopy(bt->result + i - j, bt->result, j);
2461 i = j;
2462 }
2463 }
2464 close(f);
2465 bt->result[sizeof(bt->result) - 1] = '\n';
2466 if (i && bt->result[i - 1] == '\n')
2467 i--;
2468 debug1("runbacktick: finished, %d bytes\n", i);
2469 bt->result[i] = 0;
2470 backtick_filter(bt);
2471 (void)time(&now2);
2472 bt->bestbefore = now2 + bt->lifespan;
2473 return bt->result;
2474 }
2475
2476 int
2477 AddWinMsgRend(str, r)
2478 const char *str;
2479 int r;
2480 {
2481 if (winmsg_numrend >= MAX_WINMSG_REND || str < winmsg_buf ||
2482 str >= winmsg_buf + MAXSTR)
2483 return -1;
2484
2485 winmsg_rend[winmsg_numrend] = r;
2486 winmsg_rendpos[winmsg_numrend] = str - winmsg_buf;
2487 winmsg_numrend++;
2488
2489 return 0;
2490 }
2491
2492 char *
2493 MakeWinMsgEv(str, win, esc, padlen, ev, rec)
2494 char *str;
2495 struct win *win;
2496 int esc;
2497 int padlen;
2498 struct event *ev;
2499 int rec;
2500 {
2501 static int tick;
2502 char *s = str;
2503 register char *p = winmsg_buf;
2504 register int ctrl;
2505 struct timeval now;
2506 struct tm *tm;
2507 int l, i, r;
2508 int num;
2509 int zeroflg;
2510 int longflg;
2511 int minusflg;
2512 int plusflg;
2513 int qmflag = 0, omflag = 0, qmnumrend = 0;
2514 char *qmpos = 0;
2515 int numpad = 0;
2516 int lastpad = 0;
2517 int truncpos = -1;
2518 int truncper = 0;
2519 int trunclong = 0;
2520 struct backtick *bt;
2521
2522 if (winmsg_numrend >= 0)
2523 winmsg_numrend = 0;
2524 else
2525 winmsg_numrend = -winmsg_numrend;
2526
2527 tick = 0;
2528 tm = 0;
2529 ctrl = 0;
2530 gettimeofday(&now, NULL);
2531 for (; *s && (l = winmsg_buf + MAXSTR - 1 - p) > 0; s++, p++)
2532 {
2533 *p = *s;
2534 if (ctrl)
2535 {
2536 ctrl = 0;
2537 if (*s != '^' && *s >= 64)
2538 *p &= 0x1f;
2539 continue;
2540 }
2541 if (*s != esc)
2542 {
2543 if (esc == '%')
2544 {
2545 switch (*s)
2546 {
2547 #if 0
2548 case '~':
2549 *p = BELL;
2550 break;
2551 #endif
2552 case '^':
2553 ctrl = 1;
2554 *p-- = '^';
2555 break;
2556 default:
2557 break;
2558 }
2559 }
2560 continue;
2561 }
2562 if (*++s == esc) /* double escape ? */
2563 continue;
2564 if ((plusflg = *s == '+') != 0)
2565 s++;
2566 if ((minusflg = *s == '-') != 0)
2567 s++;
2568 if ((zeroflg = *s == '0') != 0)
2569 s++;
2570 num = 0;
2571 while(*s >= '0' && *s <= '9')
2572 num = num * 10 + (*s++ - '0');
2573 if ((longflg = *s == 'L') != 0)
2574 s++;
2575 switch (*s)
2576 {
2577 case '?':
2578 p--;
2579 if (qmpos)
2580 {
2581 if ((!qmflag && !omflag) || omflag == 1)
2582 {
2583 p = qmpos;
2584 if (qmnumrend < winmsg_numrend)
2585 winmsg_numrend = qmnumrend;
2586 }
2587 qmpos = 0;
2588 break;
2589 }
2590 qmpos = p;
2591 qmnumrend = winmsg_numrend;
2592 qmflag = omflag = 0;
2593 break;
2594 case ':':
2595 p--;
2596 if (!qmpos)
2597 break;
2598 if (qmflag && omflag != 1)
2599 {
2600 omflag = 1;
2601 qmpos = p;
2602 qmnumrend = winmsg_numrend;
2603 }
2604 else
2605 {
2606 p = qmpos;
2607 if (qmnumrend < winmsg_numrend)
2608 winmsg_numrend = qmnumrend;
2609 omflag = -1;
2610 }
2611 break;
2612 case 'd': case 'D': case 'm': case 'M': case 'y': case 'Y':
2613 case 'a': case 'A': case 's': case 'c': case 'C':
2614 if (l < 4)
2615 break;
2616 if (tm == 0)
2617 {
2618 time_t nowsec = now.tv_sec;
2619 tm = localtime(&nowsec);
2620 }
2621 qmflag = 1;
2622 if (!tick || tick > 3600)
2623 tick = 3600;
2624 switch (*s)
2625 {
2626 case 'd':
2627 sprintf(p, "%02d", tm->tm_mday % 100);
2628 break;
2629 case 'D':
2630 #ifdef USE_LOCALE
2631 strftime(p, l, (longflg ? "%A" : "%a"), tm);
2632 #else
2633 sprintf(p, "%3.3s", days + 3 * tm->tm_wday);
2634 #endif
2635 break;
2636 case 'm':
2637 sprintf(p, "%02d", tm->tm_mon + 1);
2638 break;
2639 case 'M':
2640 #ifdef USE_LOCALE
2641 strftime(p, l, (longflg ? "%B" : "%b"), tm);
2642 #else
2643 sprintf(p, "%3.3s", months + 3 * tm->tm_mon);
2644 #endif
2645 break;
2646 case 'y':
2647 sprintf(p, "%02d", tm->tm_year % 100);
2648 break;
2649 case 'Y':
2650 sprintf(p, "%04d", tm->tm_year + 1900);
2651 break;
2652 case 'a':
2653 sprintf(p, tm->tm_hour >= 12 ? "pm" : "am");
2654 break;
2655 case 'A':
2656 sprintf(p, tm->tm_hour >= 12 ? "PM" : "AM");
2657 break;
2658 case 's':
2659 sprintf(p, "%02d", tm->tm_sec);
2660 tick = 1;
2661 break;
2662 case 'c':
2663 sprintf(p, zeroflg ? "%02d:%02d" : "%2d:%02d", tm->tm_hour, tm->tm_min);
2664 if (!tick || tick > 60)
2665 tick = 60;
2666 break;
2667 case 'C':
2668 sprintf(p, zeroflg ? "%02d:%02d" : "%2d:%02d", (tm->tm_hour + 11) % 12 + 1, tm->tm_min);
2669 if (!tick || tick > 60)
2670 tick = 60;
2671 break;
2672 default:
2673 break;
2674 }
2675 p += strlen(p) - 1;
2676 break;
2677 case 'l':
2678 #ifdef LOADAV
2679 *p = 0;
2680 if (l > 20)
2681 AddLoadav(p);
2682 if (*p)
2683 {
2684 qmflag = 1;
2685 p += strlen(p) - 1;
2686 }
2687 else
2688 *p = '?';
2689 if (!tick || tick > 60)
2690 tick = 60;
2691 #else
2692 *p = '?';
2693 #endif
2694 p += strlen(p) - 1;
2695 break;
2696 case '`':
2697 case 'h':
2698 if (rec >= 10 || (*s == 'h' && (win == 0 || win->w_hstatus == 0 || *win->w_hstatus == 0)))
2699 {
2700 p--;
2701 break;
2702 }
2703 if (*s == '`')
2704 {
2705 for (bt = backticks; bt; bt = bt->next)
2706 if (bt->num == num)
2707 break;
2708 if (bt == 0)
2709 {
2710 p--;
2711 break;
2712 }
2713 }
2714 {
2715 char savebuf[sizeof(winmsg_buf)];
2716 int oldtick = tick;
2717 int oldnumrend = winmsg_numrend;
2718
2719 *p = 0;
2720 strcpy(savebuf, winmsg_buf);
2721 winmsg_numrend = -winmsg_numrend;
2722 MakeWinMsgEv(*s == 'h' ? win->w_hstatus : runbacktick(bt, &oldtick, now.tv_sec), win, '\005', 0, (struct event *)0, rec + 1);
2723 debug2("oldtick=%d tick=%d\n", oldtick, tick);
2724 if (!tick || oldtick < tick)
2725 tick = oldtick;
2726 if ((int)strlen(winmsg_buf) < l)
2727 strcat(savebuf, winmsg_buf);
2728 strcpy(winmsg_buf, savebuf);
2729 while (oldnumrend < winmsg_numrend)
2730 winmsg_rendpos[oldnumrend++] += p - winmsg_buf;
2731 if (*p)
2732 qmflag = 1;
2733 p += strlen(p) - 1;
2734 }
2735 break;
2736 case 'w':
2737 case 'W':
2738 {
2739 struct win *oldfore = 0;
2740 char *ss;
2741
2742 if (display)
2743 {
2744 oldfore = D_fore;
2745 D_fore = win;
2746 }
2747 ss = AddWindows(p, l - 1, (*s == 'w' ? 0 : 1) | (longflg ? 0 : 2) | (plusflg ? 4 : 0) | (minusflg ? 8 : 0), win ? win->w_number : -1);
2748 if (display)
2749 D_fore = oldfore;
2750 }
2751 if (*p)
2752 qmflag = 1;
2753 p += strlen(p) - 1;
2754 break;
2755 case 'u':
2756 *p = 0;
2757 if (win)
2758 AddOtherUsers(p, l - 1, win);
2759 if (*p)
2760 qmflag = 1;
2761 p += strlen(p) - 1;
2762 break;
2763 case 'f':
2764 *p = 0;
2765 if (win)
2766 AddWindowFlags(p, l - 1, win);
2767 if (*p)
2768 qmflag = 1;
2769 p += strlen(p) - 1;
2770 break;
2771 case 't':
2772 *p = 0;
2773 if (win && (int)strlen(win->w_title) < l)
2774 {
2775 strcpy(p, win->w_title);
2776 if (*p)
2777 qmflag = 1;
2778 }
2779 p += strlen(p) - 1;
2780 break;
2781 case '{':
2782 {
2783 char rbuf[128];
2784 s++;
2785 for (i = 0; i < 127; i++)
2786 if (s[i] && s[i] != '}')
2787 rbuf[i] = s[i];
2788 else
2789 break;
2790 if (s[i] == '}' && winmsg_numrend < MAX_WINMSG_REND)
2791 {
2792 r = -1;
2793 rbuf[i] = 0;
2794 debug1("MakeWinMsg attrcolor %s\n", rbuf);
2795 if (i != 1 || rbuf[0] != '-')
2796 r = ParseAttrColor(rbuf, (char *)0, 0);
2797 if (r != -1 || (i == 1 && rbuf[0] == '-'))
2798 {
2799 winmsg_rend[winmsg_numrend] = r;
2800 winmsg_rendpos[winmsg_numrend] = p - winmsg_buf;
2801 winmsg_numrend++;
2802 }
2803 }
2804 s += i;
2805 p--;
2806 }
2807 break;
2808 case 'H':
2809 *p = 0;
2810 if ((int)strlen(HostName) < l)
2811 {
2812 strcpy(p, HostName);
2813 if (*p)
2814 qmflag = 1;
2815 }
2816 p += strlen(p) - 1;
2817 break;
2818 case 'S':
2819 {
2820 char *session_name;
2821 *p = 0;
2822 session_name = strchr(SockName, '.') + 1;
2823 if ((int)strlen(session_name) < l)
2824 {
2825 strcpy(p, session_name);
2826 if (*p)
2827 qmflag = 1;
2828 }
2829 p += strlen(p) - 1;
2830 }
2831 break;
2832 case 'p':
2833 {
2834 sprintf(p, "%d", (plusflg && display) ? D_userpid : getpid());
2835 p += strlen(p) - 1;
2836 }
2837 break;
2838 case 'F':
2839 p--;
2840 /* small hack */
2841 if (display && ((ev && ev == &D_forecv->c_captev) || (!ev && win && win == D_fore)))
2842 minusflg = !minusflg;
2843 if (minusflg)
2844 qmflag = 1;
2845 break;
2846 case 'P':
2847 p--;
2848 #ifdef COPY_PASTE
2849 if (display && ev && ev != &D_hstatusev) /* Hack */
2850 {
2851 /* Is the layer in the current canvas in copy mode? */
2852 struct canvas *cv = (struct canvas *)ev->data;
2853 if (ev == &cv->c_captev && cv->c_layer->l_layfn == &MarkLf)
2854 qmflag = 1;
2855 }
2856 #endif
2857 break;
2858 case '>':
2859 truncpos = p - winmsg_buf;
2860 truncper = num > 100 ? 100 : num;
2861 trunclong = longflg;
2862 p--;
2863 break;
2864 case '=':
2865 case '<':
2866 *p = ' ';
2867 if (num || zeroflg || plusflg || longflg || (*s != '='))
2868 {
2869 /* expand all pads */
2870 if (minusflg)
2871 {
2872 num = (plusflg ? lastpad : padlen) - num;
2873 if (!plusflg && padlen == 0)
2874 num = p - winmsg_buf;
2875 plusflg = 0;
2876 }
2877 else if (!zeroflg)
2878 {
2879 if (*s != '=' && num == 0 && !plusflg)
2880 num = 100;
2881 if (num > 100)
2882 num = 100;
2883 if (padlen == 0)
2884 num = p - winmsg_buf;
2885 else
2886 num = (padlen - (plusflg ? lastpad : 0)) * num / 100;
2887 }
2888 if (num < 0)
2889 num = 0;
2890 if (plusflg)
2891 num += lastpad;
2892 if (num > MAXSTR - 1)
2893 num = MAXSTR - 1;
2894 if (numpad)
2895 p = pad_expand(winmsg_buf, p, numpad, num);
2896 numpad = 0;
2897 if (p - winmsg_buf > num && !longflg)
2898 {
2899 int left, trunc;
2900
2901 if (truncpos == -1)
2902 {
2903 truncpos = lastpad;
2904 truncper = 0;
2905 }
2906 trunc = lastpad + truncper * (num - lastpad) / 100;
2907 if (trunc > num)
2908 trunc = num;
2909 if (trunc < lastpad)
2910 trunc = lastpad;
2911 left = truncpos - trunc;
2912 if (left > p - winmsg_buf - num)
2913 left = p - winmsg_buf - num;
2914 debug1("lastpad = %d, ", lastpad);
2915 debug3("truncpos = %d, trunc = %d, left = %d\n", truncpos, trunc, left);
2916 if (left > 0)
2917 {
2918 if (left + lastpad > p - winmsg_buf)
2919 left = p - winmsg_buf - lastpad;
2920 if (p - winmsg_buf - lastpad - left > 0)
2921 bcopy(winmsg_buf + lastpad + left, winmsg_buf + lastpad, p - winmsg_buf - lastpad - left);
2922 p -= left;
2923 r = winmsg_numrend;
2924 while (r && winmsg_rendpos[r - 1] > lastpad)
2925 {
2926 r--;
2927 winmsg_rendpos[r] -= left;
2928 if (winmsg_rendpos[r] < lastpad)
2929 winmsg_rendpos[r] = lastpad;
2930 }
2931 if (trunclong)
2932 {
2933 if (p - winmsg_buf > lastpad)
2934 winmsg_buf[lastpad] = '.';
2935 if (p - winmsg_buf > lastpad + 1)
2936 winmsg_buf[lastpad + 1] = '.';
2937 if (p - winmsg_buf > lastpad + 2)
2938 winmsg_buf[lastpad + 2] = '.';
2939 }
2940 }
2941 if (p - winmsg_buf > num)
2942 {
2943 p = winmsg_buf + num;
2944 if (trunclong)
2945 {
2946 if (num - 1 >= lastpad)
2947 p[-1] = '.';
2948 if (num - 2 >= lastpad)
2949 p[-2] = '.';
2950 if (num - 3 >= lastpad)
2951 p[-3] = '.';
2952 }
2953 r = winmsg_numrend;
2954 while (r && winmsg_rendpos[r - 1] > num)
2955 winmsg_rendpos[--r] = num;
2956 }
2957 truncpos = -1;
2958 trunclong = 0;
2959 if (lastpad > p - winmsg_buf)
2960 lastpad = p - winmsg_buf;
2961 debug1("lastpad now %d\n", lastpad);
2962 }
2963 if (*s == '=')
2964 {
2965 while (p - winmsg_buf < num)
2966 *p++ = ' ';
2967 lastpad = p - winmsg_buf;
2968 truncpos = -1;
2969 trunclong = 0;
2970 debug1("lastpad2 now %d\n", lastpad);
2971 }
2972 p--;
2973 }
2974 else if (padlen)
2975 {
2976 *p = 127; /* internal pad representation */
2977 numpad++;
2978 }
2979 break;
2980 case 'n':
2981 s++;
2982 /* FALLTHROUGH */
2983 default:
2984 s--;
2985 if (l > 10 + num)
2986 {
2987 if (num == 0)
2988 num = 1;
2989 if (!win)
2990 sprintf(p, "%*s", num, num > 1 ? "--" : "-");
2991 else
2992 sprintf(p, "%*d", num, win->w_number);
2993 qmflag = 1;
2994 p += strlen(p) - 1;
2995 }
2996 break;
2997 }
2998 }
2999 if (qmpos && !qmflag)
3000 p = qmpos + 1;
3001 *p = '\0';
3002 if (numpad)
3003 {
3004 if (padlen > MAXSTR - 1)
3005 padlen = MAXSTR - 1;
3006 p = pad_expand(winmsg_buf, p, numpad, padlen);
3007 }
3008 if (ev)
3009 {
3010 evdeq(ev); /* just in case */
3011 ev->timeout.tv_sec = 0;
3012 ev->timeout.tv_usec = 0;
3013 }
3014 if (ev && tick)
3015 {
3016 now.tv_usec = 100000;
3017 if (tick == 1)
3018 now.tv_sec++;
3019 else
3020 now.tv_sec += tick - (now.tv_sec % tick);
3021 ev->timeout = now;
3022 debug2("NEW timeout %d %d\n", ev->timeout.tv_sec, tick);
3023 }
3024 return winmsg_buf;
3025 }
3026
3027 char *
3028 MakeWinMsg(s, win, esc)
3029 char *s;
3030 struct win *win;
3031 int esc;
3032 {
3033 return MakeWinMsgEv(s, win, esc, 0, (struct event *)0, 0);
3034 }
3035
3036 void
3037 PutWinMsg(s, start, max)
3038 char *s;
3039 int start, max;
3040 {
3041 int i, p, l, r, n;
3042 struct mchar rend;
3043 struct mchar rendstack[MAX_WINMSG_REND];
3044 int rendstackn = 0;
3045
3046 if (s != winmsg_buf)
3047 {
3048 /* sorry, no fancy coloring available */
3049 debug1("PutWinMsg %s plain\n", s);
3050 l = strlen(s);
3051 if (l > max)
3052 l = max;
3053 l -= start;
3054 s += start;
3055 while (l-- > 0)
3056 PUTCHARLP(*s++);
3057 return;
3058 }
3059 rend = D_rend;
3060 p = 0;
3061 l = strlen(s);
3062 debug2("PutWinMsg %s start attr %x\n", s, rend.attr);
3063 for (i = 0; i < winmsg_numrend && max > 0; i++)
3064 {
3065 if (p > winmsg_rendpos[i] || winmsg_rendpos[i] > l)
3066 break;
3067 if (p < winmsg_rendpos[i])
3068 {
3069 n = winmsg_rendpos[i] - p;
3070 if (n > max)
3071 n = max;
3072 max -= n;
3073 p += n;
3074 while(n-- > 0)
3075 {
3076 if (start-- > 0)
3077 s++;
3078 else
3079 PUTCHARLP(*s++);
3080 }
3081 }
3082 r = winmsg_rend[i];
3083 if (r == -1)
3084 {
3085 if (rendstackn > 0)
3086 rend = rendstack[--rendstackn];
3087 }
3088 else
3089 {
3090 rendstack[rendstackn++] = rend;
3091 ApplyAttrColor(r, &rend);
3092 }
3093 SetRendition(&rend);
3094 }
3095 if (p < l)
3096 {
3097 n = l - p;
3098 if (n > max)
3099 n = max;
3100 while(n-- > 0)
3101 {
3102 if (start-- > 0)
3103 s++;
3104 else
3105 PUTCHARLP(*s++);
3106 }
3107 }
3108 }
3109
3110
3111 #ifdef DEBUG
3112 static void
3113 fds1(i, j)
3114 int i, j;
3115 {
3116 while (i < j)
3117 {
3118 debug1("%d ", i);
3119 i++;
3120 }
3121 if ((j = open("/dev/null", 0)) >= 0)
3122 {
3123 fds1(i + 1, j);
3124 close(j);
3125 }
3126 else
3127 {
3128 while (dup(++i) < 0 && errno != EBADF)
3129 debug1("%d ", i);
3130 debug1(" [%d]\n", i);
3131 }
3132 }
3133
3134 static void
3135 fds()
3136 {
3137 debug("fds: ");
3138 fds1(-1, -1);
3139 }
3140 #endif
3141
3142 static void
3143 serv_read_fn(ev, data)
3144 struct event *ev;
3145 char *data;
3146 {
3147 debug("Knock - knock!\n");
3148 ReceiveMsg();
3149 }
3150
3151 static void
3152 serv_select_fn(ev, data)
3153 struct event *ev;
3154 char *data;
3155 {
3156 struct win *p;
3157
3158 debug("serv_select_fn called\n");
3159 /* XXX: messages?? */
3160 if (GotSigChld)
3161 {
3162 SigChldHandler();
3163 }
3164 if (InterruptPlease)
3165 {
3166 debug("Backend received interrupt\n");
3167 /* This approach is rather questionable in a multi-display
3168 * environment */
3169 if (fore && displays)
3170 {
3171 #if defined(TERMIO) || defined(POSIX)
3172 char ibuf = displays->d_OldMode.tio.c_cc[VINTR];
3173 #else
3174 char ibuf = displays->d_OldMode.m_tchars.t_intrc;
3175 #endif
3176 #ifdef PSEUDOS
3177 write(W_UWP(fore) ? fore->w_pwin->p_ptyfd : fore->w_ptyfd,
3178 &ibuf, 1);
3179 debug1("Backend wrote interrupt to %d", fore->w_number);
3180 debug1("%s\n", W_UWP(fore) ? " (pseudowin)" : "");
3181 #else
3182 write(fore->w_ptyfd, &ibuf, 1);
3183 debug1("Backend wrote interrupt to %d\n", fore->w_number);
3184 #endif
3185 }
3186 InterruptPlease = 0;
3187 }
3188
3189 for (p = windows; p; p = p->w_next)
3190 {
3191 if (p->w_bell == BELL_FOUND || p->w_bell == BELL_VISUAL)
3192 {
3193 struct canvas *cv;
3194 int visual = p->w_bell == BELL_VISUAL || visual_bell;
3195 p->w_bell = BELL_ON;
3196 for (display = displays; display; display = display->d_next)
3197 {
3198 for (cv = D_cvlist; cv; cv = cv->c_next)
3199 if (cv->c_layer->l_bottom == &p->w_layer)
3200 break;
3201 if (cv == 0)
3202 {
3203 p->w_bell = BELL_DONE;
3204 Msg(0, "%s", MakeWinMsg(BellString, p, '%'));
3205 }
3206 else if (visual && !D_VB && (!D_status || !D_status_bell))
3207 {
3208 Msg(0, "%s", VisualBellString);
3209 if (D_status)
3210 {
3211 D_status_bell = 1;
3212 debug1("using vbell timeout %d\n", VBellWait);
3213 SetTimeout(&D_statusev, VBellWait );
3214 }
3215 }
3216 }
3217 /* don't annoy the user with two messages */
3218 if (p->w_monitor == MON_FOUND)
3219 p->w_monitor = MON_DONE;
3220 WindowChanged(p, 'f');
3221 }
3222 if (p->w_monitor == MON_FOUND)
3223 {
3224 struct canvas *cv;
3225 p->w_monitor = MON_ON;
3226 for (display = displays; display; display = display->d_next)
3227 {
3228 for (cv = D_cvlist; cv; cv = cv->c_next)
3229 if (cv->c_layer->l_bottom == &p->w_layer)
3230 break;
3231 if (cv)
3232 continue; /* user already sees window */
3233 #ifdef MULTIUSER
3234 if (!(ACLBYTE(p->w_mon_notify, D_user->u_id) & ACLBIT(D_user->u_id)))
3235 continue; /* user doesn't care */
3236 #endif
3237 Msg(0, "%s", MakeWinMsg(ActivityString, p, '%'));
3238 p->w_monitor = MON_DONE;
3239 }
3240 WindowChanged(p, 'f');
3241 }
3242 if (p->w_silence == SILENCE_FOUND)
3243 {
3244 /* Unset the flag if the user switched to this window. */
3245 if (p->w_layer.l_cvlist)
3246 {
3247 p->w_silence = SILENCE_ON;
3248 WindowChanged(p, 'f');
3249 }
3250 }
3251 }
3252
3253 for (display = displays; display; display = display->d_next)
3254 {
3255 struct canvas *cv;
3256 if (D_status == STATUS_ON_WIN)
3257 continue;
3258 /* XXX: should use display functions! */
3259 for (cv = D_cvlist; cv; cv = cv->c_next)
3260 {
3261 int lx, ly;
3262
3263 /* normalize window, see resize.c */
3264 lx = cv->c_layer->l_x;
3265 ly = cv->c_layer->l_y;
3266 if (lx == cv->c_layer->l_width)
3267 lx--;
3268 if (ly + cv->c_yoff < cv->c_ys)
3269 {
3270 int i, n = cv->c_ys - (ly + cv->c_yoff);
3271 cv->c_yoff = cv->c_ys - ly;
3272 RethinkViewportOffsets(cv);
3273 if (n > cv->c_layer->l_height)
3274 n = cv->c_layer->l_height;
3275 CV_CALL(cv,
3276 LScrollV(flayer, -n, 0, flayer->l_height - 1, 0);
3277 LayRedisplayLine(-1, -1, -1, 1);
3278 for (i = 0; i < n; i++)
3279 LayRedisplayLine(i, 0, flayer->l_width - 1, 1);
3280 if (cv == cv->c_display->d_forecv)
3281 LaySetCursor();
3282 );
3283 }
3284 else if (ly + cv->c_yoff > cv->c_ye)
3285 {
3286 int i, n = ly + cv->c_yoff - cv->c_ye;
3287 cv->c_yoff = cv->c_ye - ly;
3288 RethinkViewportOffsets(cv);
3289 if (n > cv->c_layer->l_height)
3290 n = cv->c_layer->l_height;
3291 CV_CALL(cv,
3292 LScrollV(flayer, n, 0, cv->c_layer->l_height - 1, 0);
3293 LayRedisplayLine(-1, -1, -1, 1);
3294 for (i = 0; i < n; i++)
3295 LayRedisplayLine(i + flayer->l_height - n, 0, flayer->l_width - 1, 1);
3296 if (cv == cv->c_display->d_forecv)
3297 LaySetCursor();
3298 );
3299 }
3300 if (lx + cv->c_xoff < cv->c_xs)
3301 {
3302 int i, n = cv->c_xs - (lx + cv->c_xoff);
3303 if (n < (cv->c_xe - cv->c_xs + 1) / 2)
3304 n = (cv->c_xe - cv->c_xs + 1) / 2;
3305 if (cv->c_xoff + n > cv->c_xs)
3306 n = cv->c_xs - cv->c_xoff;
3307 cv->c_xoff += n;
3308 RethinkViewportOffsets(cv);
3309 if (n > cv->c_layer->l_width)
3310 n = cv->c_layer->l_width;
3311 CV_CALL(cv,
3312 LayRedisplayLine(-1, -1, -1, 1);
3313 for (i = 0; i < flayer->l_height; i++)
3314 {
3315 LScrollH(flayer, -n, i, 0, flayer->l_width - 1, 0, 0);
3316 LayRedisplayLine(i, 0, n - 1, 1);
3317 }
3318 if (cv == cv->c_display->d_forecv)
3319 LaySetCursor();
3320 );
3321 }
3322 else if (lx + cv->c_xoff > cv->c_xe)
3323 {
3324 int i, n = lx + cv->c_xoff - cv->c_xe;
3325 if (n < (cv->c_xe - cv->c_xs + 1) / 2)
3326 n = (cv->c_xe - cv->c_xs + 1) / 2;
3327 if (cv->c_xoff - n + cv->c_layer->l_width - 1 < cv->c_xe)
3328 n = cv->c_xoff + cv->c_layer->l_width - 1 - cv->c_xe;
3329 cv->c_xoff -= n;
3330 RethinkViewportOffsets(cv);
3331 if (n > cv->c_layer->l_width)
3332 n = cv->c_layer->l_width;
3333 CV_CALL(cv,
3334 LayRedisplayLine(-1, -1, -1, 1);
3335 for (i = 0; i < flayer->l_height; i++)
3336 {
3337 LScrollH(flayer, n, i, 0, flayer->l_width - 1, 0, 0);
3338 LayRedisplayLine(i, flayer->l_width - n, flayer->l_width - 1, 1);
3339 }
3340 if (cv == cv->c_display->d_forecv)
3341 LaySetCursor();
3342 );
3343 }
3344 }
3345 }
3346
3347 for (display = displays; display; display = display->d_next)
3348 {
3349 if (D_status == STATUS_ON_WIN || D_cvlist == 0 || D_cvlist->c_next == 0)
3350 continue;
3351 debug1("serv_select_fn: Restore on cv %#x\n", (int)D_forecv);
3352 CV_CALL(D_forecv, LayRestore();LaySetCursor());
3353 }
3354 }
3355
3356 static void
3357 logflush_fn(ev, data)
3358 struct event *ev;
3359 char *data;
3360 {
3361 struct win *p;
3362 char *buf;
3363 int n;
3364
3365 if (!islogfile(NULL))
3366 return; /* no more logfiles */
3367 logfflush(NULL);
3368 n = log_flush ? log_flush : (logtstamp_after + 4) / 5;
3369 if (n)
3370 {
3371 SetTimeout(ev, n * 1000);
3372 evenq(ev); /* re-enqueue ourself */
3373 }
3374 if (!logtstamp_on)
3375 return;
3376 /* write fancy time-stamp */
3377 for (p = windows; p; p = p->w_next)
3378 {
3379 if (!p->w_log)
3380 continue;
3381 p->w_logsilence += n;
3382 if (p->w_logsilence < logtstamp_after)
3383 continue;
3384 if (p->w_logsilence - n >= logtstamp_after)
3385 continue;
3386 buf = MakeWinMsg(logtstamp_string, p, '%');
3387 logfwrite(p->w_log, buf, strlen(buf));
3388 }
3389 }
3390
3391 /*
3392 * Interprets ^?, ^@ and other ^-control-char notation.
3393 * Interprets \ddd octal notation
3394 *
3395 * The result is placed in *cp, p is advanced behind the parsed expression and
3396 * returned.
3397 */
3398 static char *
3399 ParseChar(p, cp)
3400 char *p, *cp;
3401 {
3402 if (*p == 0)
3403 return 0;
3404 if (*p == '^' && p[1])
3405 {
3406 if (*++p == '?')
3407 *cp = '\177';
3408 else if (*p >= '@')
3409 *cp = Ctrl(*p);
3410 else
3411 return 0;
3412 ++p;
3413 }
3414 else if (*p == '\\' && *++p <= '7' && *p >= '0')
3415 {
3416 *cp = 0;
3417 do
3418 *cp = *cp * 8 + *p - '0';
3419 while (*++p <= '7' && *p >= '0');
3420 }
3421 else
3422 *cp = *p++;
3423 return p;
3424 }
3425
3426 static int
3427 ParseEscape(p)
3428 char *p;
3429 {
3430 unsigned char buf[2];
3431
3432 if (*p == 0)
3433 SetEscape((struct acluser *)0, -1, -1);
3434 else
3435 {
3436 if ((p = ParseChar(p, (char *)buf)) == NULL ||
3437 (p = ParseChar(p, (char *)buf+1)) == NULL || *p)
3438 return -1;
3439 SetEscape((struct acluser *)0, buf[0], buf[1]);
3440 }
3441 return 0;
3442 }
3443
Lua scripting support for GNU Screen